Fixes for glpk-4.53 (bug #501320) and library dupes (bug #505404). Added more EAPI5 changes

(Portage version: 2.2.8-prefix/cvs/Linux x86_64, signed Manifest commit with key 0x13CB1360)

3 files changed, 1181 insertions, 1 deletions

diff --git a/dev-python/cvxopt/ChangeLog b/dev-python/cvxopt/ChangeLog
index 212777dccf6e..007a342ae094 100644
--- a/dev-python/cvxopt/ChangeLog
+++ b/dev-python/cvxopt/ChangeLog
@@ -1,6 +1,13 @@
 # ChangeLog for dev-python/cvxopt
 # Copyright 1999-2014 Gentoo Foundation; Distributed under the GPL v2
-# $Header: /var/cvsroot/gentoo-x86/dev-python/cvxopt/ChangeLog,v 1.16 2014/01/16 18:44:31 bicatali Exp $
+# $Header: /var/cvsroot/gentoo-x86/dev-python/cvxopt/ChangeLog,v 1.17 2014/03/25 01:17:25 bicatali Exp $
+
+*cvxopt-1.1.6-r1 (25 Mar 2014)
+
+  25 Mar 2014; Sébastien Fabbro <bicatali@gentoo.org> +cvxopt-1.1.6-r1.ebuild,
+  +files/cvxopt-1.1.6-glpk449.patch:
+  Fixes for glpk-4.53 (bug #501320) and library dupes (bug #505404). Added more
+  EAPI5 changes
 
   16 Jan 2014; Sébastien Fabbro <bicatali@gentoo.org>
   +files/cvxopt-1.1.6-glpk.patch, -cvxopt-1.1.5-r2.ebuild,
diff --git a/dev-python/cvxopt/cvxopt-1.1.6-r1.ebuild b/dev-python/cvxopt/cvxopt-1.1.6-r1.ebuild
new file mode 100644
index 000000000000..a41572fbc4c7
--- /dev/null
+++ b/dev-python/cvxopt/cvxopt-1.1.6-r1.ebuild
@@ -0,0 +1,91 @@
+# Copyright 1999-2014 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/dev-python/cvxopt/cvxopt-1.1.6-r1.ebuild,v 1.1 2014/03/25 01:17:25 bicatali Exp $
+
+EAPI=5
+
+PYTHON_COMPAT=( python{2_6,2_7,3_2,3_3} )
+
+inherit distutils-r1 toolchain-funcs eutils
+
+DESCRIPTION="Python package for convex optimization"
+HOMEPAGE="http://cvxopt.org/"
+SRC_URI="https://github.com/${PN}/${PN}/archive/${PV}.tar.gz -> ${P}.tar.gz"
+
+LICENSE="GPL-3"
+SLOT="0"
+KEYWORDS="~amd64 ~x86 ~amd64-linux ~x86-linux"
+IUSE="doc +dsdp examples fftw +glpk gsl"
+
+RDEPEND="
+	virtual/blas
+	virtual/cblas
+	virtual/lapack
+	sci-libs/cholmod:0=
+	sci-libs/umfpack:0=
+	dsdp? ( sci-libs/dsdp:0= )
+	fftw? ( sci-libs/fftw:3.0= )
+	glpk? ( sci-mathematics/glpk:0= )
+	gsl? ( sci-libs/gsl:0= )"
+DEPEND="${RDEPEND}
+	virtual/pkgconfig
+	doc? ( dev-python/sphinx )"
+
+python_prepare_all(){
+	local PATCHES=(	"${FILESDIR}"/${PN}-1.1.6-setup.patch )
+
+	has_version ">=sci-mathematics/glpk-4.49" && \
+		epatch "${FILESDIR}"/${PN}-1.1.6-glpk449.patch
+
+	rm -r src/C/SuiteSparse*/ || die
+
+	distutils-r1_python_prepare_all
+
+	pkg_lib() {
+		local libs=$($(tc-getPKG_CONFIG) --libs-only-l $1 | \
+			sed -e 's:[ ]-l*\(pthread\|m\)\([ ]\|$\)::g' -e 's:[ ]*$::' | \
+			tr ' ' '\n' | sort -u | \
+			sed -e "s:^-l\(.*\):'\1':g" | \
+			tr '\n' ',' | sed -e 's:,$::')
+		sed -i -e "/_LIB[ ]*=/s:\(.*[ ]*=[ ]*\[\).*${1}.*:\1${libs}\]:" setup.py || die
+	}
+
+	use_cvx() {
+		if use $1 ; then
+			sed -i \
+				-e "s/\(BUILD_${1^^} =\) 0/\1 1/" \
+				setup.py || die
+		fi
+	}
+
+	pkg_lib blas
+	pkg_lib lapack
+
+	# Deal with blas/lapck libraries that are not in /usr/lib{64}
+	local lapackdir=\'$($(tc-getPKG_CONFIG) --libs-only-L lapack | sed \
+			-e 's:^-L::' \
+			-e "s:[ ]*-L:\',\':g" \
+			-e 's:[ ]*$::g')\'
+	sed -i -e "s:BLAS_LIB_DIR = '':BLAS_LIB_DIR = ${lapackdir}:" setup.py || die
+
+	use_cvx gsl
+	use_cvx fftw
+	use_cvx glpk
+	use_cvx dsdp
+}
+
+python_compile_all() {
+	use doc && export VARTEXFONTS="${T}/fonts" && emake -C doc -B html
+}
+
+python_test() {
+	cd examples/doc/chap8
+	"${EPYTHON}" lp.py || die
+}
+
+python_install_all() {
+	use doc && HTML_DOCS=( doc/build/html/. )
+	insinto /usr/share/doc/${PF}
+	use examples && doins -r examples
+	distutils-r1_python_install_all
+}
diff --git a/dev-python/cvxopt/files/cvxopt-1.1.6-glpk449.patch b/dev-python/cvxopt/files/cvxopt-1.1.6-glpk449.patch
new file mode 100644
index 000000000000..2a1cc6737be4
--- /dev/null
+++ b/dev-python/cvxopt/files/cvxopt-1.1.6-glpk449.patch
@@ -0,0 +1,1082 @@
+--- src/C/glpk.c.orig	2014-03-24 09:39:39.510214726 -0700
++++ src/C/glpk.c	2014-03-24 09:38:41.251897138 -0700
+@@ -23,75 +23,271 @@
+ #include "misc.h"
+ #include "glpk.h"
+ 
++
+ PyDoc_STRVAR(glpk__doc__,
+     "Interface to the simplex and mixed integer LP algorithms in GLPK.\n\n"
+     "The GLPK control parameters have the default values listed in \n"
+-    "the GLPK documentation, except for 'LPX_K_PRESOL', which is set\n"
++    "the GLPK documentation, except for 'presolve', which is set\n"
+     "to 1 and cannot be modified.  The other parameters can be\n"
+-    "modified by making an entry in the dictionary glpk.options.\n"
+-    "For example, the command glpk.options['LPX_K_MSGLEV'] = 0 turns\n"
+-    "off the printed output during execution of glpk.simplex().\n"
++    "modified by passing a smcp or iocp object to the appropriate function\n"
++    "For example,  the commands param = glpk.smcp(msg_lev = 0), or \n"
++    "param=glpk.smcp(); param.msg_lev=1 turn off the printed output during"
++    " execution of glpk.simplex().\n"
+     "See the documentation at www.gnu.org/software/glpk/glpk.html for\n"
+     "the list of GLPK control parameters and their default values.");
+ 
+ static PyObject *glpk_module;
+ 
+-typedef struct {
+-    char  name[20];
+-    int   idx;
+-    char  type;
+-}   param_tuple;
+-
+-static const param_tuple GLPK_PARAM_LIST[] = {
+-    {"LPX_K_MSGLEV",    LPX_K_MSGLEV,   'i'}, 
+-    {"LPX_K_SCALE",     LPX_K_SCALE,    'i'},
+-    {"LPX_K_DUAL",      LPX_K_DUAL,     'i'},
+-    {"LPX_K_PRICE",     LPX_K_PRICE,    'i'},
+-    {"LPX_K_RELAX",     LPX_K_RELAX,    'f'},
+-    {"LPX_K_TOLBND",    LPX_K_TOLBND,   'f'},
+-    {"LPX_K_TOLDJ",     LPX_K_TOLDJ,    'f'},
+-    {"LPX_K_TOLPIV",    LPX_K_TOLPIV,   'f'},
+-    {"LPX_K_ROUND",     LPX_K_ROUND,    'i'},
+-    {"LPX_K_OBJLL",     LPX_K_OBJLL,    'f'},
+-    {"LPX_K_OBJUL",     LPX_K_OBJUL,    'f'},
+-    {"LPX_K_ITLIM",     LPX_K_ITLIM,    'i'},
+-    {"LPX_K_ITCNT",     LPX_K_ITCNT,    'i'}, 
+-    {"LPX_K_TMLIM",     LPX_K_TMLIM,    'f'},
+-    {"LPX_K_OUTFRQ",    LPX_K_OUTFRQ,   'i'},
+-    {"LPX_K_OUTDLY",    LPX_K_OUTDLY,   'f'},
+-    {"LPX_K_BRANCH",    LPX_K_BRANCH,   'i'},
+-    {"LPX_K_BTRACK",    LPX_K_BTRACK,   'i'},
+-    {"LPX_K_TOLINT",    LPX_K_TOLINT,   'f'},
+-    {"LPX_K_TOLOBJ",    LPX_K_TOLOBJ,   'f'},
+-    {"LPX_K_MPSINFO",   LPX_K_MPSINFO,  'i'},
+-    {"LPX_K_MPSOBJ",    LPX_K_MPSOBJ,   'i'},
+-    {"LPX_K_MPSORIG",   LPX_K_MPSORIG,  'i'},
+-    {"LPX_K_MPSWIDE",   LPX_K_MPSWIDE,  'i'},
+-    {"LPX_K_MPSFREE",   LPX_K_MPSFREE,  'i'},
+-    {"LPX_K_MPSSKIP",   LPX_K_MPSSKIP,  'i'},
+-    {"LPX_K_LPTORIG",   LPX_K_LPTORIG,  'i'},
+-    {"LPX_K_PRESOL",    LPX_K_PRESOL,   'i'},
+-}; /* 28 paramaters */
++/* Wrappers around the option glpk structs */
++typedef struct{
++  PyObject_HEAD
++  glp_smcp obj;
++} pysmcp;
+ 
++/* Deallocation of smcp object */
++static void smcp_dealloc(pysmcp* self)
++{
++    Py_TYPE(self)->tp_free((PyObject*)self);
++}
+ 
+-#if PY_MAJOR_VERSION >= 3
+-static int get_param_idx(const char *str, int *idx, char *type)
+-#else
+-static int get_param_idx(char *str, int *idx, char *type)
+-#endif
++/* New smcp method */
++static PyObject *
++smcp_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+ {
+-    int i;
++    pysmcp *self;
++    self = (pysmcp *)type->tp_alloc(type, 0);
++    return (PyObject *)self;
++}
++
++/* Initialisation of smcp object */
++static int
++smcp_init(pysmcp *self, PyObject *args, PyObject *kwds)
++{
++    /*static char *kwlist[] = {"number", NULL};*/
++    static char *kwlist[] = { "msg_lev", "meth", "pricing", "r_test", "tol_bnd", "tol_dj", "tol_piv", "obj_ll", "obj_ul", "it_lim", "tm_lim", "out_frq", "out_dly", "presolve" };
++    glp_init_smcp(&self->obj);
++    if (! PyArg_ParseTupleAndKeywords(args, kwds, "|iiiidddddiiiii", kwlist,
++                &self->obj.msg_lev,
++                &self->obj.meth,
++                &self->obj.pricing,
++                &self->obj.r_test,
++                &self->obj.tol_bnd,
++                &self->obj.tol_dj,
++                &self->obj.tol_piv,
++                &self->obj.obj_ll,
++                &self->obj.obj_ul,
++                &self->obj.it_lim,
++                &self->obj.tm_lim,
++                &self->obj.out_frq,
++                &self->obj.out_dly,
++                &self->obj.presolve))
++        return -1;
+ 
+-    for (i=0; i<28; i++) {
+-        if (!strcmp(GLPK_PARAM_LIST[i].name, str)) {
+-            *idx =  GLPK_PARAM_LIST[i].idx;
+-            *type = GLPK_PARAM_LIST[i].type;
+-            return 1;
+-        }
+-    }
+     return 0;
+ }
+ 
++/* smcp members declaration */
++static PyMemberDef smcpMembers[] = {
++  {"msg_lev", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,msg_lev), 0, "message level: "},
++  {"meth", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,meth), 0, "simplex method option: "},
++  {"pricing", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,pricing), 0, "pricing technique: "},
++  {"r_test", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,r_test), 0, "ratio test technique: "},
++  {"tol_bnd", T_DOUBLE, offsetof(pysmcp,obj)+offsetof(glp_smcp,tol_bnd), 0, "spx.tol_bnd "},
++  {"tol_dj", T_DOUBLE, offsetof(pysmcp,obj)+offsetof(glp_smcp,tol_dj), 0, "spx.tol_dj "},
++  {"tol_piv", T_DOUBLE, offsetof(pysmcp,obj)+offsetof(glp_smcp,tol_piv), 0, "spx.tol_piv "},
++  {"obj_ll", T_DOUBLE, offsetof(pysmcp,obj)+offsetof(glp_smcp,obj_ll), 0, "spx.obj_ll "},
++  {"obj_ul", T_DOUBLE, offsetof(pysmcp,obj)+offsetof(glp_smcp,obj_ul), 0, "spx.obj_ul "},
++  {"it_lim", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,it_lim), 0, "spx.it_lim "},
++  {"tm_lim", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,tm_lim), 0, "spx.tm_lim (milliseconds) "},
++  {"out_frq", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,out_frq), 0, "spx.out_frq "},
++  {"out_dly", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,out_dly), 0, "spx.out_dly (milliseconds) "},
++  {"presolve", T_INT, offsetof(pysmcp,obj)+offsetof(glp_smcp,presolve), 0, "enable/disable using LP presolver "},
++};
++
++static PyTypeObject smcp_t = {
++    PyVarObject_HEAD_INIT(NULL, 0)
++    "glpk.smcp",               /* tp_name */
++    sizeof(pysmcp),            /* tp_basicsize */
++    0,                         /* tp_itemsize */
++    (destructor)smcp_dealloc,  /* tp_dealloc */
++    0,                         /* tp_print */
++    0,                         /* tp_getattr */
++    0,                         /* tp_setattr */
++    0,                         /* tp_reserved */
++    0,                         /* tp_repr */
++    0,                         /* tp_as_number */
++    0,                         /* tp_as_sequence */
++    0,                         /* tp_as_mapping */
++    0,                         /* tp_hash  */
++    0,                         /* tp_call */
++    0,                         /* tp_str */
++    0,                         /* tp_getattro */
++    0,                         /* tp_setattro */
++    0,                         /* tp_as_buffer */
++    Py_TPFLAGS_DEFAULT |
++        Py_TPFLAGS_BASETYPE,   /* tp_flags */
++    "simplex method control parameters",           /* tp_doc */
++    0,                         /* tp_traverse */
++    0,                         /* tp_clear */
++    0,                         /* tp_richcompare */
++    0,                         /* tp_weaklistoffset */
++    0,                         /* tp_iter */
++    0,                         /* tp_iternext */
++    0,                         /* tp_methods */
++    smcpMembers,               /* tp_members */
++    0,                         /* tp_getset */
++    0,                         /* tp_base */
++    0,                         /* tp_dict */
++    0,                         /* tp_descr_get */
++    0,                         /* tp_descr_set */
++    0,                         /* tp_dictoffset */
++    (initproc)smcp_init,       /* tp_init */
++    0,                         /* tp_alloc */
++    smcp_new,                 /* tp_new */
++};
++
++
++/* Wrappers around the option glpk structs */
++typedef struct{
++  PyObject_HEAD
++  glp_iocp obj;
++} pyiocp;
++
++/* Deallocation of iocp object */
++static void iocp_dealloc(pysmcp* self)
++{
++    Py_TYPE(self)->tp_free((PyObject*)self);
++}
++
++/* New iocp method */
++static PyObject *
++iocp_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
++{
++    pyiocp *self;
++    self = (pyiocp *)type->tp_alloc(type, 0);
++    return (PyObject *)self;
++}
++
++/* Initialisation of iocp object */
++static int
++iocp_init(pyiocp *self, PyObject *args, PyObject *kwds)
++{
++    /*static char *kwlist[] = {"number", NULL};*/
++    static char *kwlist[] = { "msg_lev", "br_tech", "bt_tech", "tol_int", "tol_obj", "tm_lim", "out_frq", "out_dly", "cb_size", "pp_tech", "mip_gap", "mir_cuts", "gmi_cuts", "cov_cuts", "clq_cuts", "presolve", "binarize", "fp_heur", "ps_heur", "ps_tm_lim", "use_sol", "save_sol", "alien",NULL};
++    glp_init_iocp(&self->obj);
++
++    if (! PyArg_ParseTupleAndKeywords(args, kwds, "|iiiddiiiiidiiiiiiiiiisi", kwlist,
++                &self->obj.msg_lev,
++                &self->obj.br_tech,
++                &self->obj.bt_tech,
++                &self->obj.tol_int,
++                &self->obj.tol_obj,
++                &self->obj.tm_lim,
++                &self->obj.out_frq,
++                &self->obj.out_dly,
++                &self->obj.cb_size,
++                &self->obj.pp_tech,
++                &self->obj.mip_gap,
++                &self->obj.mir_cuts,
++                &self->obj.gmi_cuts,
++                &self->obj.cov_cuts,
++                &self->obj.clq_cuts,
++                &self->obj.presolve,
++                &self->obj.binarize,
++                &self->obj.fp_heur,
++                &self->obj.ps_heur,
++                &self->obj.ps_tm_lim,
++                &self->obj.use_sol,
++                &self->obj.save_sol,
++                &self->obj.alien))
++                    return -1;
++
++    return 0;
++}
++
++/* iocp members declaration */
++static PyMemberDef iocpMembers[] = {
++  {"msg_lev", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,msg_lev), 0, "message level (see glp_smcp) "},
++  {"br_tech", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,br_tech), 0, "branching technique: "},
++  {"bt_tech", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,bt_tech), 0, "backtracking technique: "},
++  {"tol_int", T_DOUBLE, offsetof(pysmcp,obj)+offsetof(glp_iocp,tol_int), 0, "mip.tol_int "},
++  {"tol_obj", T_DOUBLE, offsetof(pysmcp,obj)+offsetof(glp_iocp,tol_obj), 0, "mip.tol_obj "},
++  {"tm_lim", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,tm_lim), 0, "mip.tm_lim (milliseconds) "},
++  {"out_frq", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,out_frq), 0, "mip.out_frq (milliseconds) "},
++  {"out_dly", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,out_dly), 0, "mip.out_dly (milliseconds) "},
++  /*void (*cb_func)(glp_tree *T, void *info); [> mip.cb_func <]*/
++  /*void *cb_info;          [> mip.cb_info <]*/
++  {"cb_size", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,cb_size), 0, "mip.cb_size "},
++  {"pp_tech", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,pp_tech), 0, "preprocessing technique: "},
++  {"mip_gap", T_DOUBLE, offsetof(pysmcp,obj)+offsetof(glp_iocp,mip_gap), 0, "relative MIP gap tolerance "},
++  {"mir_cuts", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,mir_cuts), 0, "MIR cuts       (GLP_ON/GLP_OFF) "},
++  {"gmi_cuts", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,gmi_cuts), 0, "Gomory's cuts  (GLP_ON/GLP_OFF) "},
++  {"cov_cuts", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,cov_cuts), 0, "cover cuts     (GLP_ON/GLP_OFF) "},
++  {"clq_cuts", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,clq_cuts), 0, "clique cuts    (GLP_ON/GLP_OFF) "},
++  {"presolve", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,presolve), 0, "enable/disable using MIP presolver "},
++  {"binarize", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,binarize), 0, "try to binarize integer variables "},
++  {"fp_heur", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,fp_heur), 0, "feasibility pump heuristic "},
++  {"ps_heur", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,ps_heur), 0, "proximity search heuristic "},
++  {"ps_tm_lim", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,ps_tm_lim), 0, "proxy time limit, milliseconds "},
++  {"use_sol", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,use_sol), 0, "use existing solution "},
++  {"save_sol",T_STRING,offsetof(pysmcp,obj)+offsetof(glp_iocp,save_sol),0, "filename to save every new solution"},
++  {"alien", T_INT, offsetof(pysmcp,obj)+offsetof(glp_iocp,alien), 0, "use alien solver "},
++};
++
++static PyTypeObject iocp_t = {
++    PyVarObject_HEAD_INIT(NULL, 0)
++    "glpk.iocp",             /* tp_name */
++    sizeof(pyiocp),            /* tp_basicsize */
++    0,                         /* tp_itemsize */
++    (destructor)iocp_dealloc, /* tp_dealloc */
++    0,                         /* tp_print */
++    0,                         /* tp_getattr */
++    0,                         /* tp_setattr */
++    0,                         /* tp_reserved */
++    0,                         /* tp_repr */
++    0,                         /* tp_as_number */
++    0,                         /* tp_as_sequence */
++    0,                         /* tp_as_mapping */
++    0,                         /* tp_hash  */
++    0,                         /* tp_call */
++    0,                         /* tp_str */
++    0,                         /* tp_getattro */
++    0,                         /* tp_setattro */
++    0,                         /* tp_as_buffer */
++    Py_TPFLAGS_DEFAULT |
++        Py_TPFLAGS_BASETYPE,   /* tp_flags */
++    "integer optimizer control parameters",           /* tp_doc */
++    0,                         /* tp_traverse */
++    0,                         /* tp_clear */
++    0,                         /* tp_richcompare */
++    0,                         /* tp_weaklistoffset */
++    0,                         /* tp_iter */
++    0,                         /* tp_iternext */
++    0,                         /* tp_methods */
++    iocpMembers,             /* tp_members */
++    0,                         /* tp_getset */
++    0,                         /* tp_base */
++    0,                         /* tp_dict */
++    0,                         /* tp_descr_get */
++    0,                         /* tp_descr_set */
++    0,                         /* tp_dictoffset */
++    (initproc)iocp_init,       /* tp_init */
++    0,                         /* tp_alloc */
++    iocp_new,                 /* tp_new */
++};
++
++
++
++/* Small helper function to generate the output string of the simplex function */
++inline static void set_output_string(PyObject* t,const char s[]) {
++            PyTuple_SET_ITEM(t, 0, (PyObject *)
++#if PY_MAJOR_VERSION >= 3
++                PyUnicode_FromString(s));
++#else
++                PyString_FromString(s));
++#endif
++    }
++
+ 
+ static char doc_simplex[] =
+     "Solves a linear program using GLPK.\n\n"
+@@ -126,21 +322,16 @@
+     PyObject *kwrds)
+ {
+     matrix *c, *h, *b=NULL, *x=NULL, *z=NULL, *y=NULL;
+-    PyObject *G, *A=NULL, *t=NULL, *param, *key, *value;
+-    LPX *lp;
+-    int m, n, p, i, j, k, nnz, nnzmax, *rn=NULL, *cn=NULL, param_id;
+-    int_t pos=0;
++    PyObject *G, *A=NULL, *t=NULL;
++    glp_prob *lp;
++    glp_smcp *options = NULL;
++    pysmcp *smcpParm = NULL;
++    int m, n, p, i, j, k, nnz, nnzmax, *rn=NULL, *cn=NULL;
+     double *a=NULL, val;
+-    char param_type, err_str[100]; 
+-#if PY_MAJOR_VERSION >= 3
+-    const char *keystr;
+-#else
+-    char *keystr;
+-#endif
+-    char *kwlist[] = {"c", "G", "h", "A", "b", NULL};
++    char *kwlist[] = {"c", "G", "h", "A", "b","options", NULL};
+ 
+-    if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OOO|OO", kwlist, &c,
+-        &G, &h, &A, &b)) return NULL;
++    if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OOO|OOO!", kwlist, &c,
++        &G, &h, &A, &b,&smcp_t,&smcpParm)) return NULL;
+ 
+     if ((Matrix_Check(G) && MAT_ID(G) != DOUBLE) ||
+         (SpMatrix_Check(G) && SP_ID(G) != DOUBLE) ||
+@@ -182,19 +373,30 @@
+         PyErr_SetString(PyExc_ValueError, "incompatible dimensions");
+         return NULL;
+     }
++    if(!smcpParm) 
++    {
++      smcpParm = (pysmcp*)malloc(sizeof(*smcpParm));
++      glp_init_smcp(&(smcpParm->obj));
++    }
++    if(smcpParm) 
++    {
++      Py_INCREF(smcpParm);
++      options = &smcpParm->obj;
++      options->presolve = 1;
++    }
+ 
+-    lp = lpx_create_prob();
+-    lpx_add_rows(lp, m+p);
+-    lpx_add_cols(lp, n);
++    lp = glp_create_prob();
++    glp_add_rows(lp, m+p);
++    glp_add_cols(lp, n);
+ 
+     for (i=0; i<n; i++){
+-        lpx_set_obj_coef(lp, i+1, MAT_BUFD(c)[i]);
+-        lpx_set_col_bnds(lp, i+1, LPX_FR, 0.0, 0.0);
++        glp_set_obj_coef(lp, i+1, MAT_BUFD(c)[i]);
++        glp_set_col_bnds(lp, i+1, GLP_FR, 0.0, 0.0);
+     }
+     for (i=0; i<m; i++)
+-        lpx_set_row_bnds(lp, i+1, LPX_UP, 0.0, MAT_BUFD(h)[i]);
++        glp_set_row_bnds(lp, i+1, GLP_UP, 0.0, MAT_BUFD(h)[i]);
+     for (i=0; i<p; i++)
+-        lpx_set_row_bnds(lp, i+m+1, LPX_FX, MAT_BUFD(b)[i],
++        glp_set_row_bnds(lp, i+m+1, GLP_FX, MAT_BUFD(b)[i],
+             MAT_BUFD(b)[i]);
+ 
+     nnzmax = (SpMatrix_Check(G) ? SP_NNZ(G) : m*n ) +
+@@ -203,7 +405,7 @@
+     rn = (int *) calloc(nnzmax+1, sizeof(int));
+     cn = (int *) calloc(nnzmax+1, sizeof(int));
+     if (!a || !rn || !cn){
+-        free(a);  free(rn);  free(cn);  lpx_delete_prob(lp);
++        free(a);  free(rn);  free(cn);  glp_delete_prob(lp);
+         return PyErr_NoMemory();
+     }
+ 
+@@ -242,84 +444,18 @@
+             nnz++;
+         }
+ 
+-    lpx_load_matrix(lp, nnz, rn, cn, a);
++    glp_load_matrix(lp, nnz, rn, cn, a);
+     free(rn);  free(cn);  free(a);
+ 
+     if (!(t = PyTuple_New(A ? 4 : 3))){
+-        lpx_delete_prob(lp);
++        glp_delete_prob(lp);
+         return PyErr_NoMemory();
+     }
+ 
+-    if (!(param = PyObject_GetAttrString(glpk_module, "options"))
+-        || !PyDict_Check(param)){
+-            lpx_delete_prob(lp);
+-            PyErr_SetString(PyExc_AttributeError,
+-                "missing glpk.options dictionary");
+-            return NULL;
+-    }
+-
+-    while (PyDict_Next(param, &pos, &key, &value))
+-#if PY_MAJOR_VERSION >= 3
+-        if ((PyUnicode_Check(key)) && 
+-            get_param_idx(_PyUnicode_AsString(key), &param_id, 
+-            &param_type)){
+-            keystr = _PyUnicode_AsString(key);
+-#else
+-        if ((keystr = PyString_AsString(key)) && get_param_idx(keystr,
+-            &param_id, &param_type)){
+-#endif
+-	    if (param_type == 'i'){
+-#if PY_MAJOR_VERSION >= 3
+-	        if (!PyLong_Check(value)){
+-#else
+-	        if (!PyInt_Check(value)){
+-#endif
+-                    sprintf(err_str, "invalid value for integer "
+-                        "GLPK parameter: %-.20s", keystr);
+-                    PyErr_SetString(PyExc_ValueError, err_str);
+-	            lpx_delete_prob(lp);
+-	            Py_DECREF(param);
+-                    return NULL;
+-	        }
+-                if (!strcmp("LPX_K_PRESOL", keystr) &&
+-#if PY_MAJOR_VERSION >= 3
+-                    PyLong_AS_LONG(value) != 1){
+-#else
+-                    PyInt_AS_LONG(value) != 1){
+-#endif
+-                    PyErr_Warn(PyExc_UserWarning, "ignoring value of "
+-                        "GLPK parameter 'LPX_K_PRESOL'");
+-                }
+-                else lpx_set_int_parm(lp, param_id,
+-#if PY_MAJOR_VERSION >= 3
+-                    PyLong_AS_LONG(value));
+-#else
+-                    PyInt_AS_LONG(value));
+-#endif
+-	    }
+-	    else {
+-#if PY_MAJOR_VERSION >= 3
+-	        if (!PyLong_Check(value) && !PyFloat_Check(value)){
+-#else
+-	        if (!PyInt_Check(value) && !PyFloat_Check(value)){
+-#endif
+-                    sprintf(err_str, "invalid value for floating point "
+-                        "GLPK parameter: %-.20s", keystr);
+-                    PyErr_SetString(PyExc_ValueError, err_str);
+-	            lpx_delete_prob(lp);
+-	            Py_DECREF(param);
+-                    return NULL;
+-	        }
+-	        lpx_set_real_parm(lp, param_id,
+-                    PyFloat_AsDouble(value));
+-	    }
+-    }
+-    lpx_set_int_parm(lp, LPX_K_PRESOL, 1);
+-    Py_DECREF(param);
+ 
+-    switch (lpx_simplex(lp)){
++    switch (glp_simplex(lp,options)){
+ 
+-        case LPX_E_OK:
++        case 0:
+ 
+             x = (matrix *) Matrix_New(n,1,DOUBLE);
+             z = (matrix *) Matrix_New(m,1,DOUBLE);
+@@ -329,65 +465,70 @@
+                 Py_XDECREF(z);
+                 Py_XDECREF(y);
+                 Py_XDECREF(t);
+-                lpx_delete_prob(lp);
++                Py_XDECREF(smcpParm);
++                glp_delete_prob(lp);
+                 return PyErr_NoMemory();
+             }
+ 
+-            PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+-                PyUnicode_FromString("optimal"));
+-#else
+-                PyString_FromString("optimal"));
+-#endif
++            set_output_string(t,"optimal");
+ 
+             for (i=0; i<n; i++)
+-                MAT_BUFD(x)[i] = lpx_get_col_prim(lp, i+1);
++                MAT_BUFD(x)[i] = glp_get_col_prim(lp, i+1);
+             PyTuple_SET_ITEM(t, 1, (PyObject *) x);
+ 
+             for (i=0; i<m; i++)
+-                MAT_BUFD(z)[i] = -lpx_get_row_dual(lp, i+1);
++                MAT_BUFD(z)[i] = -glp_get_row_dual(lp, i+1);
+             PyTuple_SET_ITEM(t, 2, (PyObject *) z);
+ 
+             if (A){
+                 for (i=0; i<p; i++)
+-                    MAT_BUFD(y)[i] = -lpx_get_row_dual(lp, m+i+1);
++                    MAT_BUFD(y)[i] = -glp_get_row_dual(lp, m+i+1);
+                 PyTuple_SET_ITEM(t, 3, (PyObject *) y);
+             }
+ 
+-            lpx_delete_prob(lp);
++            Py_XDECREF(smcpParm);
++            glp_delete_prob(lp);
+             return (PyObject *) t;
+-
+-        case LPX_E_NOPFS:
+-
+-            PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+-                PyUnicode_FromString("primal infeasible"));
+-#else
+-                PyString_FromString("primal infeasible"));
+-#endif
++        case GLP_EBADB:
++            set_output_string(t,"incorrect initial basis");
+             break;
+-
+-        case LPX_E_NODFS:
+-
+-            PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+-                PyUnicode_FromString("dual infeasible"));
+-#else
+-                PyString_FromString("dual infeasible"));
+-#endif
++        case GLP_ESING:
++            set_output_string(t,"singular initial basis matrix");
++            break;
++        case GLP_ECOND:
++            set_output_string(t,"ill-conditioned initial basis matrix");
++            break;
++        case GLP_EBOUND:
++            set_output_string(t,"incorrect bounds");
++            break;
++        case GLP_EFAIL:
++            set_output_string(t,"solver failure");
++            break;
++        case GLP_EOBJLL:
++            set_output_string(t,"objective function reached lower limit");
++            break;
++        case GLP_EOBJUL:
++            set_output_string(t,"objective function reached upper limit");
++            break;
++        case GLP_EITLIM:
++            set_output_string(t,"iteration limit exceeded");
++            break;
++        case GLP_ETMLIM:
++            set_output_string(t,"time limit exceeded");
++            break;
++        case GLP_ENOPFS:
++            set_output_string(t,"primal infeasible");
++            break;
++        case GLP_ENODFS:
++            set_output_string(t,"dual infeasible");
+             break;
+-
+         default:
+-
+-            PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+-                PyUnicode_FromString("unknown"));
+-#else
+-                PyString_FromString("unknown"));
+-#endif
++            set_output_string(t,"unknown");
++            break;
+     }
+ 
+-    lpx_delete_prob(lp);
++    Py_XDECREF(smcpParm);
++    glp_delete_prob(lp);
+ 
+     PyTuple_SET_ITEM(t, 1, Py_BuildValue(""));
+     PyTuple_SET_ITEM(t, 2, Py_BuildValue(""));
+@@ -427,21 +568,28 @@
+ {
+     matrix *c, *h, *b=NULL, *x=NULL;
+     PyObject *G, *A=NULL, *IntSet=NULL, *BinSet = NULL;
+-    PyObject *t=NULL, *param, *key, *value;
+-    LPX *lp;
+-    int m, n, p, i, j, k, nnz, nnzmax, *rn=NULL, *cn=NULL, param_id;
+-    int_t pos=0;
++    PyObject *t=NULL;
++    pyiocp *iocpParm = NULL;;
++    glp_iocp *options = NULL;
++    glp_prob *lp;
++    int m, n, p, i, j, k, nnz, nnzmax, *rn=NULL, *cn=NULL;
+     double *a=NULL, val;
+-    char param_type, err_str[100]; 
+-#if PY_MAJOR_VERSION >= 3
+-    const char *keystr;
+-#else
+-    char *keystr;
+-#endif
+-    char *kwlist[] = {"c", "G", "h", "A", "b", "I", "B", NULL};
++    char *kwlist[] = {"c", "G", "h", "A", "b", "I", "B","iocp", NULL};
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OOO|OOOOO!", kwlist, &c,
++	    &G, &h, &A, &b, &IntSet, &BinSet,iocp_t,&iocpParm)) return NULL;
+ 
+-    if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OOO|OOOO", kwlist, &c,
+-	    &G, &h, &A, &b, &IntSet, &BinSet)) return NULL;
++    if(!iocpParm) 
++    {
++      iocpParm = (pyiocp*)malloc(sizeof(*iocpParm));
++      glp_init_iocp(&(iocpParm->obj));
++    }
++    if(iocpParm) 
++    {
++      Py_INCREF(iocpParm);
++      options = &iocpParm->obj;
++      options->presolve = 1;
++    }
+ 
+     if ((Matrix_Check(G) && MAT_ID(G) != DOUBLE) ||
+         (SpMatrix_Check(G) && SP_ID(G) != DOUBLE) ||
+@@ -490,18 +638,18 @@
+     if ((BinSet) && (!PyAnySet_Check(BinSet)))
+       PY_ERR_TYPE("invalid binary index set");
+ 
+-    lp = lpx_create_prob();
+-    lpx_add_rows(lp, m+p);
+-    lpx_add_cols(lp, n);
++    lp = glp_create_prob();
++    glp_add_rows(lp, m+p);
++    glp_add_cols(lp, n);
+ 
+     for (i=0; i<n; i++){
+-        lpx_set_obj_coef(lp, i+1, MAT_BUFD(c)[i]);
+-        lpx_set_col_bnds(lp, i+1, LPX_FR, 0.0, 0.0);
++        glp_set_obj_coef(lp, i+1, MAT_BUFD(c)[i]);
++        glp_set_col_bnds(lp, i+1, GLP_FR, 0.0, 0.0);
+     }
+     for (i=0; i<m; i++)
+-        lpx_set_row_bnds(lp, i+1, LPX_UP, 0.0, MAT_BUFD(h)[i]);
++        glp_set_row_bnds(lp, i+1, GLP_UP, 0.0, MAT_BUFD(h)[i]);
+     for (i=0; i<p; i++)
+-        lpx_set_row_bnds(lp, i+m+1, LPX_FX, MAT_BUFD(b)[i],
++        glp_set_row_bnds(lp, i+m+1, GLP_FX, MAT_BUFD(b)[i],
+             MAT_BUFD(b)[i]);
+ 
+     nnzmax = (SpMatrix_Check(G) ? SP_NNZ(G) : m*n ) +
+@@ -510,7 +658,7 @@
+     rn = (int *) calloc(nnzmax+1, sizeof(int));
+     cn = (int *) calloc(nnzmax+1, sizeof(int));
+     if (!a || !rn || !cn){
+-        free(a);  free(rn);  free(cn);  lpx_delete_prob(lp);
++        free(a);  free(rn);  free(cn);  glp_delete_prob(lp);
+         return PyErr_NoMemory();
+     }
+ 
+@@ -549,79 +697,14 @@
+             nnz++;
+         }
+ 
+-    lpx_load_matrix(lp, nnz, rn, cn, a);
++    glp_load_matrix(lp, nnz, rn, cn, a);
+     free(rn);  free(cn);  free(a);
+ 
+     if (!(t = PyTuple_New(2))) {
+-        lpx_delete_prob(lp);
++        glp_delete_prob(lp);
+         return PyErr_NoMemory();
+     }
+ 
+-    if (!(param = PyObject_GetAttrString(glpk_module, "options"))
+-        || !PyDict_Check(param)){
+-            lpx_delete_prob(lp);
+-            PyErr_SetString(PyExc_AttributeError,
+-                "missing glpk.options dictionary");
+-            return NULL;
+-    }
+-
+-    while (PyDict_Next(param, &pos, &key, &value))
+-#if PY_MAJOR_VERSION >= 3
+-        if ((PyUnicode_Check(key)) && (keystr = PyUnicode_AS_DATA(key)) 
+-            && get_param_idx(keystr, &param_id, &param_type)){
+-#else
+-        if ((keystr = PyString_AsString(key)) && get_param_idx(keystr,
+-            &param_id, &param_type)){
+-#endif
+-	    if (param_type == 'i'){
+-#if PY_MAJOR_VERSION >= 3
+-	        if (!PyLong_Check(value)){
+-#else
+-	        if (!PyInt_Check(value)){
+-#endif
+-                    sprintf(err_str, "invalid value for integer "
+-                        "GLPK parameter: %-.20s", keystr);
+-                    PyErr_SetString(PyExc_ValueError, err_str);
+-	            lpx_delete_prob(lp);
+-	            Py_DECREF(param);
+-                    return NULL;
+-	        }
+-                if (!strcmp("LPX_K_PRESOL", keystr) &&
+-#if PY_MAJOR_VERSION >= 3
+-                    PyLong_AS_LONG(value) != 1){
+-#else
+-                    PyInt_AS_LONG(value) != 1){
+-#endif
+-                    PyErr_Warn(PyExc_UserWarning, "ignoring value of "
+-                        "GLPK parameter 'LPX_K_PRESOL'");
+-                }
+-                else 
+-#if PY_MAJOR_VERSION >= 3
+-                    lpx_set_int_parm(lp, param_id, PyLong_AS_LONG(value));
+-#else
+-                    lpx_set_int_parm(lp, param_id, PyInt_AS_LONG(value));
+-#endif
+-	    }
+-	    else {
+-#if PY_MAJOR_VERSION >= 3
+-	        if (!PyLong_Check(value) && !PyFloat_Check(value)){
+-#else
+-	        if (!PyInt_Check(value) && !PyFloat_Check(value)){
+-#endif
+-                    sprintf(err_str, "invalid value for floating point "
+-                        "GLPK parameter: %-.20s", keystr);
+-                    PyErr_SetString(PyExc_ValueError, err_str);
+-	            lpx_delete_prob(lp);
+-	            Py_DECREF(param);
+-                    return NULL;
+-	        }
+-	        lpx_set_real_parm(lp, param_id,
+-                    PyFloat_AsDouble(value));
+-	    }
+-    }
+-    lpx_set_int_parm(lp, LPX_K_PRESOL, 1);
+-    Py_DECREF(param);
+-
+     if (IntSet) {
+       PyObject *iter = PySequence_Fast(IntSet, "Critical error: not sequence");
+ 
+@@ -633,7 +716,7 @@
+ #else
+ 	if (!PyInt_Check(tmp)) {
+ #endif
+-	  lpx_delete_prob(lp);
++	  glp_delete_prob(lp);
+ 	  Py_DECREF(iter);
+ 	  PY_ERR_TYPE("non-integer element in I");
+ 	}
+@@ -643,7 +726,7 @@
+ 	int k = PyInt_AS_LONG(tmp);
+ #endif
+ 	if ((k < 0) || (k >= n)) {
+-	  lpx_delete_prob(lp);
++	  glp_delete_prob(lp);
+ 	  Py_DECREF(iter);
+ 	  PY_ERR(PyExc_IndexError, "index element out of range in I");
+ 	}
+@@ -664,7 +747,7 @@
+ #else
+ 	if (!PyInt_Check(tmp)) {
+ #endif
+-	  lpx_delete_prob(lp);
++	  glp_delete_prob(lp);
+ 	  Py_DECREF(iter);
+ 	  PY_ERR_TYPE("non-binary element in I");
+ 	}
+@@ -674,7 +757,7 @@
+ 	int k = PyInt_AS_LONG(tmp);
+ #endif
+ 	if ((k < 0) || (k >= n)) {
+-	  lpx_delete_prob(lp);
++	  glp_delete_prob(lp);
+ 	  Py_DECREF(iter);
+ 	  PY_ERR(PyExc_IndexError, "index element out of range in B");
+ 	}
+@@ -686,114 +769,85 @@
+     }
+ 
+ 
++      switch (glp_intopt(lp,options)){
+ 
+-    switch (lpx_intopt(lp)){
++          case 0:
+ 
+-        case LPX_E_OK:
++              x = (matrix *) Matrix_New(n,1,DOUBLE);
++              if (!x) {
++                  Py_XDECREF(iocpParm);
++                  Py_XDECREF(t);
++                  glp_delete_prob(lp);
++                  return PyErr_NoMemory();
++              }
++              set_output_string(t,"optimal");
++              set_output_string(t,"optimal");
+ 
+-            x = (matrix *) Matrix_New(n,1,DOUBLE);
+-            if (!x) {
+-                Py_XDECREF(t);
+-                lpx_delete_prob(lp);
+-                return PyErr_NoMemory();
+-            }
+-            PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+-                PyUnicode_FromString("optimal"));
+-#else
+-                PyString_FromString("optimal"));
+-#endif
++              for (i=0; i<n; i++)
++                  MAT_BUFD(x)[i] = glp_mip_col_val(lp, i+1);
++              PyTuple_SET_ITEM(t, 1, (PyObject *) x);
+ 
+-            for (i=0; i<n; i++)
+-                MAT_BUFD(x)[i] = lpx_mip_col_val(lp, i+1);
+-            PyTuple_SET_ITEM(t, 1, (PyObject *) x);
++              Py_XDECREF(iocpParm);
++              glp_delete_prob(lp);
++              return (PyObject *) t;
+ 
+-            lpx_delete_prob(lp);
+-            return (PyObject *) t;
++          case GLP_ETMLIM:
+ 
+-        case LPX_E_TMLIM:
++              x = (matrix *) Matrix_New(n,1,DOUBLE);
++              if (!x) {
++                  Py_XDECREF(t);
++                  Py_XDECREF(iocpParm);
++                  glp_delete_prob(lp);
++                  return PyErr_NoMemory();
++              }
++              set_output_string(t,"time limit exceeded");
+ 
+-            x = (matrix *) Matrix_New(n,1,DOUBLE);
+-            if (!x) {
+-                Py_XDECREF(t);
+-                lpx_delete_prob(lp);
+-                return PyErr_NoMemory();
+-            }
+-            PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+-                PyUnicode_FromString("time limit exceeded"));
+-#else
+-                PyString_FromString("time limit exceeded"));
+-#endif
++              for (i=0; i<n; i++)
++                  MAT_BUFD(x)[i] = glp_mip_col_val(lp, i+1);
++              PyTuple_SET_ITEM(t, 1, (PyObject *) x);
+ 
+-            for (i=0; i<n; i++)
+-                MAT_BUFD(x)[i] = lpx_mip_col_val(lp, i+1);
+-            PyTuple_SET_ITEM(t, 1, (PyObject *) x);
+-
+-            lpx_delete_prob(lp);
+-            return (PyObject *) t;
++              Py_XDECREF(iocpParm);
++              glp_delete_prob(lp);
++              return (PyObject *) t;
+ 
+ 
+-        case LPX_E_FAULT:
+-            PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+-                PyUnicode_FromString("invalid MIP formulation"));
+-#else
+-                PyString_FromString("invalid MIP formulation"));
+-#endif
+-            break;
++          case GLP_EBOUND:
++              set_output_string(t,"incorrect bounds");
++              break;
++          case GLP_EFAIL:
++              set_output_string(t,"invalid MIP formulation");
++              break;
+ 
+-	case LPX_E_NOPFS:
+-            PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+-                PyUnicode_FromString("primal infeasible"));
+-#else
+-                PyString_FromString("primal infeasible"));
+-#endif
+-            break;
++          case GLP_ENOPFS:
++              set_output_string(t,"primal infeasible");
++              break;
+ 
+-	case LPX_E_NODFS:
++          case GLP_ENODFS:
++              set_output_string(t,"dual infeasible");
++              break;
+ 
+-            PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+-                PyUnicode_FromString("dual infeasible"));
+-#else
+-                PyString_FromString("dual infeasible"));
+-#endif
+-            break;
++          case GLP_EMIPGAP:
++              set_output_string(t,"Relative mip gap tolerance reached");
++              break;
+ 
+-        case LPX_E_ITLIM:
++              /*case LPX_E_ITLIM:
+ 
+-            PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+-                PyUnicode_FromString("maxiters exceeded"));
+-#else
+-                PyString_FromString("maxiters exceeded"));
+-#endif
+-            break;
++                set_output_string(t,"maxiters exceeded");
++                break;*/
+ 
+-	case LPX_E_SING:
++              /*case LPX_E_SING:
+ 
+-            PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+-                PyUnicode_FromString("singular or ill-conditioned basis"));
+-#else
+-                PyString_FromString("singular or ill-conditioned basis"));
+-#endif
+-            break;
++                set_output_string(t,"singular or ill-conditioned basis");
++                break;*/
+ 
+ 
+-        default:
++          default:
+ 
+-            PyTuple_SET_ITEM(t, 0, (PyObject *)
+-#if PY_MAJOR_VERSION >= 3
+-                PyUnicode_FromString("unknown"));
+-#else
+-                PyString_FromString("unknown"));
+-#endif
+-    }
++              set_output_string(t,"unknown");
++      }
+ 
+-    lpx_delete_prob(lp);
++      Py_XDECREF(iocpParm);
++    glp_delete_prob(lp);
+ 
+     PyTuple_SET_ITEM(t, 1, Py_BuildValue(""));
+     return (PyObject *) t;
+@@ -819,10 +873,94 @@
+     NULL, NULL, NULL, NULL
+ };
+ 
++void addglpkConstants (void)
++{
++  PyModule_AddIntMacro(glpk_module, GLP_ON);
++  PyModule_AddIntMacro(glpk_module,GLP_OFF);
++
++  /* reason codes: */
++  PyModule_AddIntMacro(glpk_module,GLP_IROWGEN);
++  PyModule_AddIntMacro(glpk_module,GLP_IBINGO);
++  PyModule_AddIntMacro(glpk_module,GLP_IHEUR);
++  PyModule_AddIntMacro(glpk_module,GLP_ICUTGEN);
++  PyModule_AddIntMacro(glpk_module,GLP_IBRANCH);
++  PyModule_AddIntMacro(glpk_module,GLP_ISELECT);
++  PyModule_AddIntMacro(glpk_module,GLP_IPREPRO);
++
++  /* branch selection indicator: */
++  PyModule_AddIntMacro(glpk_module,GLP_NO_BRNCH);
++  PyModule_AddIntMacro(glpk_module,GLP_DN_BRNCH);
++  PyModule_AddIntMacro(glpk_module,GLP_UP_BRNCH);
++
++  /* return codes: */
++  PyModule_AddIntMacro(glpk_module,GLP_EBADB);
++  PyModule_AddIntMacro(glpk_module,GLP_ESING);
++  PyModule_AddIntMacro(glpk_module,GLP_ECOND);
++  PyModule_AddIntMacro(glpk_module,GLP_EBOUND);
++  PyModule_AddIntMacro(glpk_module,GLP_EFAIL);
++  PyModule_AddIntMacro(glpk_module,GLP_EOBJLL);
++  PyModule_AddIntMacro(glpk_module,GLP_EOBJUL);
++  PyModule_AddIntMacro(glpk_module,GLP_EITLIM);
++  PyModule_AddIntMacro(glpk_module,GLP_ETMLIM);
++  PyModule_AddIntMacro(glpk_module,GLP_ENOPFS);
++  PyModule_AddIntMacro(glpk_module,GLP_ENODFS);
++  PyModule_AddIntMacro(glpk_module,GLP_EROOT);
++  PyModule_AddIntMacro(glpk_module,GLP_ESTOP);
++  PyModule_AddIntMacro(glpk_module,GLP_EMIPGAP);
++  PyModule_AddIntMacro(glpk_module,GLP_ENOFEAS);
++  PyModule_AddIntMacro(glpk_module,GLP_ENOCVG);
++  PyModule_AddIntMacro(glpk_module,GLP_EINSTAB);
++  PyModule_AddIntMacro(glpk_module,GLP_EDATA);
++  PyModule_AddIntMacro(glpk_module,GLP_ERANGE);
++
++  /* condition indicator: */
++  PyModule_AddIntMacro(glpk_module,GLP_KKT_PE);
++  PyModule_AddIntMacro(glpk_module,GLP_KKT_PB);
++  PyModule_AddIntMacro(glpk_module,GLP_KKT_DE);
++  PyModule_AddIntMacro(glpk_module,GLP_KKT_DB);
++  PyModule_AddIntMacro(glpk_module,GLP_KKT_CS);
++
++  /* MPS file format: */
++  PyModule_AddIntMacro(glpk_module,GLP_MPS_DECK);
++  PyModule_AddIntMacro(glpk_module,GLP_MPS_FILE);
++
++  /* simplex method control parameters */
++  /* message level: */
++  PyModule_AddIntMacro(glpk_module,GLP_MSG_OFF);
++  PyModule_AddIntMacro(glpk_module,GLP_MSG_ERR);
++  PyModule_AddIntMacro(glpk_module,GLP_MSG_ON);
++  PyModule_AddIntMacro(glpk_module,GLP_MSG_ALL);
++  PyModule_AddIntMacro(glpk_module,GLP_MSG_DBG);
++  /* simplex method option: */
++  PyModule_AddIntMacro(glpk_module,GLP_PRIMAL);
++  PyModule_AddIntMacro(glpk_module,GLP_DUALP);
++  PyModule_AddIntMacro(glpk_module,GLP_DUAL);
++  /* pricing technique: */
++  PyModule_AddIntMacro(glpk_module,GLP_PT_STD);
++  PyModule_AddIntMacro(glpk_module,GLP_PT_PSE);
++  /* ratio test technique: */
++  PyModule_AddIntMacro(glpk_module,GLP_RT_STD);
++  PyModule_AddIntMacro(glpk_module,GLP_RT_HAR);
++
++  /* interior-point solver control parameters */
++  /* ordering algorithm: */
++  PyModule_AddIntMacro(glpk_module,GLP_ORD_NONE);
++  PyModule_AddIntMacro(glpk_module,GLP_ORD_QMD);
++  PyModule_AddIntMacro(glpk_module,GLP_ORD_AMD);
++  PyModule_AddIntMacro(glpk_module,GLP_ORD_SYMAMD);
++}
++
+ PyMODINIT_FUNC PyInit_glpk(void)
+ {
+   if (!(glpk_module = PyModule_Create(&glpk_module_def))) return NULL;
+-  PyModule_AddObject(glpk_module, "options", PyDict_New());
++  if (PyType_Ready(&iocp_t) < 0 || (PyType_Ready(&smcp_t) < 0)) return NULL;
++  /*  Adding macros */
++  addglpkConstants();
++  /* Adding  option lists as objects */
++  Py_INCREF(&smcp_t);
++  PyModule_AddObject(glpk_module,"smcp",(PyObject*)&smcp_t);
++  Py_INCREF(&iocp_t);
++  PyModule_AddObject(glpk_module,"iocp",(PyObject*)&iocp_t);
+   if (import_cvxopt() < 0) return NULL;
+   return glpk_module;
+ }
+@@ -832,8 +970,13 @@
+ PyMODINIT_FUNC initglpk(void)
+ {
+     glpk_module = Py_InitModule3("cvxopt.glpk", glpk_functions, 
+-        glpk__doc__);
+-    PyModule_AddObject(glpk_module, "options", PyDict_New());
++            glpk__doc__);
++    if (PyType_Ready(&iocp_t) < 0 || (PyType_Ready(&smcp_t) < 0)) return NULL;
++    addglpkConstants();
++    Py_INCREF(&smcp_t);
++    PyModule_AddObject(glpk_module,"smcp",(PyObject*)&smcp_t);
++    Py_INCREF(&iocp_t);
++    PyModule_AddObject(glpk_module,"iocp",(PyObject*)&iocp_t);
+     if (import_cvxopt() < 0) return;
+ }
+