/* glpcpx.c (CPLEX LP format routines) */

/***********************************************************************

*  This code is part of GLPK (GNU Linear Programming Kit).

*

*  Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,

*  2009, 2010 Andrew Makhorin, Department for Applied Informatics,

*  Moscow Aviation Institute, Moscow, Russia. All rights reserved.

*  E-mail: <mao@gnu.org>.

*

*  GLPK is free software: you can redistribute it and/or modify it

*  under the terms of the GNU General Public License as published by

*  the Free Software Foundation, either version 3 of the License, or

*  (at your option) any later version.

*

*  GLPK is distributed in the hope that it will be useful, but WITHOUT

*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

*  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public

*  License for more details.

*

*  You should have received a copy of the GNU General Public License

*  along with GLPK. If not, see <http://www.gnu.org/licenses/>.

***********************************************************************/

#include "glpapi.h"

/***********************************************************************

*  NAME

*

*  glp_init_cpxcp - initialize CPLEX LP format control parameters

*

*  SYNOPSIS

*

*  void glp_init_cpxcp(glp_cpxcp *parm):

*

*  The routine glp_init_cpxcp initializes control parameters used by

*  the CPLEX LP input/output routines glp_read_lp and glp_write_lp with

*  default values.

*

*  Default values of the control parameters are stored in the glp_cpxcp

*  structure, which the parameter parm points to. */

void glp_init_cpxcp(glp_cpxcp *parm)

{     xassert(parm != NULL);

      return;

}

static void check_parm(const char *func, const glp_cpxcp *parm)

{     /* check control parameters */

      xassert(func != NULL);

      xassert(parm != NULL);

      return;

}

/***********************************************************************

*  NAME

*

*  glp_read_lp - read problem data in CPLEX LP format

*

*  SYNOPSIS

*

*  int glp_read_lp(glp_prob *P, const glp_cpxcp *parm, const char

*     *fname);

*

*  DESCRIPTION

*

*  The routine glp_read_lp reads problem data in CPLEX LP format from

*  a text file.

*

*  The parameter parm is a pointer to the structure glp_cpxcp, which

*  specifies control parameters used by the routine. If parm is NULL,

*  the routine uses default settings.

*

*  The character string fname specifies a name of the text file to be

*  read.

*

*  Note that before reading data the current content of the problem

*  object is completely erased with the routine glp_erase_prob.

*

*  RETURNS

*

*  If the operation was successful, the routine glp_read_lp returns

*  zero. Otherwise, it prints an error message and returns non-zero. */

struct csa

{     /* common storage area */

      glp_prob *P;

      /* LP/MIP problem object */

      const glp_cpxcp *parm;

      /* pointer to control parameters */

      const char *fname;

      /* name of input CPLEX LP file */

      XFILE *fp;

      /* stream assigned to input CPLEX LP file */

      jmp_buf jump;

      /* label for go to in case of error */

      int count;

      /* line count */

      int c;

      /* current character or XEOF */

      int token;

      /* current token: */

#define T_EOF        0x00  /* end of file */

#define T_MINIMIZE   0x01  /* keyword 'minimize' */

#define T_MAXIMIZE   0x02  /* keyword 'maximize' */

#define T_SUBJECT_TO 0x03  /* keyword 'subject to' */

#define T_BOUNDS     0x04  /* keyword 'bounds' */

#define T_GENERAL    0x05  /* keyword 'general' */

#define T_INTEGER    0x06  /* keyword 'integer' */

#define T_BINARY     0x07  /* keyword 'binary' */

#define T_END        0x08  /* keyword 'end' */

#define T_NAME       0x09  /* symbolic name */

#define T_NUMBER     0x0A  /* numeric constant */

#define T_PLUS       0x0B  /* delimiter '+' */

#define T_MINUS      0x0C  /* delimiter '-' */

#define T_COLON      0x0D  /* delimiter ':' */

#define T_LE         0x0E  /* delimiter '<=' */

#define T_GE         0x0F  /* delimiter '>=' */

#define T_EQ         0x10  /* delimiter '=' */

      char image[255+1];

      /* image of current token */

      int imlen;

      /* length of token image */

      double value;

      /* value of numeric constant */

      int n_max;

      /* length of the following five arrays (enlarged automatically,

         if necessary) */

      int *ind; /* int ind[1+n_max]; */

      double *val; /* double val[1+n_max]; */

      char *flag; /* char flag[1+n_max]; */

      /* working arrays used to construct linear forms */

      double *lb; /* double lb[1+n_max]; */

      double *ub; /* double ub[1+n_max]; */

      /* lower and upper bounds of variables (columns) */

};

#define CHAR_SET "!\"#$%&()/,.;?@_`'{}|~"

/* characters, which may appear in symbolic names */

static void error(struct csa *csa, const char *fmt, ...)

{     /* print error message and terminate processing */

      va_list arg;

      xprintf("%s:%d: ", csa->fname, csa->count);

      va_start(arg, fmt);

      xvprintf(fmt, arg);

      va_end(arg);

      longjmp(csa->jump, 1);

      /* no return */

}

static void warning(struct csa *csa, const char *fmt, ...)

{     /* print warning message and continue processing */

      va_list arg;

      xprintf("%s:%d: warning: ", csa->fname, csa->count);

      va_start(arg, fmt);

      xvprintf(fmt, arg);

      va_end(arg);

      return;

}

static void read_char(struct csa *csa)

{     /* read next character from input file */

      int c;

      xassert(csa->c != XEOF);

      if (csa->c == '\n') csa->count++;

      c = xfgetc(csa->fp);

      if (c < 0)

      {  if (xferror(csa->fp))

            error(csa, "read error - %s\n", xerrmsg());

         else if (csa->c == '\n')

         {  csa->count--;

            c = XEOF;

         }

         else

         {  warning(csa, "missing final end of line\n");

            c = '\n';

         }

      }

      else if (c == '\n')

         ;

      else if (isspace(c))

         c = ' ';

      else if (iscntrl(c))

         error(csa, "invalid control character 0x%02X\n", c);

      csa->c = c;

      return;

}

static void add_char(struct csa *csa)

{     /* append current character to current token */

      if (csa->imlen == sizeof(csa->image)-1)

         error(csa, "token `%.15s...' too long\n", csa->image);

      csa->image[csa->imlen++] = (char)csa->c;

      csa->image[csa->imlen] = '\0';

      read_char(csa);

      return;

}

static int the_same(char *s1, char *s2)

{     /* compare two character strings ignoring case sensitivity */

      for (; *s1 != '\0'; s1++, s2++)

      {  if (tolower((unsigned char)*s1) != tolower((unsigned char)*s2))

            return 0;

      }

      return 1;

}

static void scan_token(struct csa *csa)

{     /* scan next token */

      int flag;

      csa->token = -1;

      csa->image[0] = '\0';

      csa->imlen = 0;

      csa->value = 0.0;

loop: flag = 0;

      /* skip non-significant characters */

      while (csa->c == ' ') read_char(csa);

      /* recognize and scan current token */

      if (csa->c == XEOF)

         csa->token = T_EOF;

      else if (csa->c == '\n')

      {  read_char(csa);

         /* if the next character is letter, it may begin a keyword */

         if (isalpha(csa->c))

         {  flag = 1;

            goto name;

         }

         goto loop;

      }

      else if (csa->c == '\\')

      {  /* comment; ignore everything until end-of-line */

         while (csa->c != '\n') read_char(csa);

         goto loop;

      }

      else if (isalpha(csa->c) || csa->c != '.' && strchr(CHAR_SET,

         csa->c) != NULL)

name: {  /* symbolic name */

         csa->token = T_NAME;

         while (isalnum(csa->c) || strchr(CHAR_SET, csa->c) != NULL)

            add_char(csa);

         if (flag)

         {  /* check for keyword */

            if (the_same(csa->image, "minimize"))

               csa->token = T_MINIMIZE;

            else if (the_same(csa->image, "minimum"))

               csa->token = T_MINIMIZE;

            else if (the_same(csa->image, "min"))

               csa->token = T_MINIMIZE;

            else if (the_same(csa->image, "maximize"))

               csa->token = T_MAXIMIZE;

            else if (the_same(csa->image, "maximum"))

               csa->token = T_MAXIMIZE;

            else if (the_same(csa->image, "max"))

               csa->token = T_MAXIMIZE;

            else if (the_same(csa->image, "subject"))

            {  if (csa->c == ' ')

               {  read_char(csa);

                  if (tolower(csa->c) == 't')

                  {  csa->token = T_SUBJECT_TO;

                     csa->image[csa->imlen++] = ' ';

                     csa->image[csa->imlen] = '\0';

                     add_char(csa);

                     if (tolower(csa->c) != 'o')

                        error(csa, "keyword `subject to' incomplete\n");

                     add_char(csa);

                     if (isalpha(csa->c))

                        error(csa, "keyword `%s%c...' not recognized\n",

                           csa->image, csa->c);

                  }

               }

            }

            else if (the_same(csa->image, "such"))

            {  if (csa->c == ' ')

               {  read_char(csa);

                  if (tolower(csa->c) == 't')

                  {  csa->token = T_SUBJECT_TO;

                     csa->image[csa->imlen++] = ' ';

                     csa->image[csa->imlen] = '\0';

                     add_char(csa);

                     if (tolower(csa->c) != 'h')

err:                    error(csa, "keyword `such that' incomplete\n");

                     add_char(csa);

                     if (tolower(csa->c) != 'a') goto err;

                     add_char(csa);

                     if (tolower(csa->c) != 't') goto err;

                     add_char(csa);

                     if (isalpha(csa->c))

                        error(csa, "keyword `%s%c...' not recognized\n",

                           csa->image, csa->c);

                  }

               }

            }

            else if (the_same(csa->image, "st"))

               csa->token = T_SUBJECT_TO;

            else if (the_same(csa->image, "s.t."))

               csa->token = T_SUBJECT_TO;

            else if (the_same(csa->image, "st."))

               csa->token = T_SUBJECT_TO;

            else if (the_same(csa->image, "bounds"))

               csa->token = T_BOUNDS;

            else if (the_same(csa->image, "bound"))

               csa->token = T_BOUNDS;

            else if (the_same(csa->image, "general"))

               csa->token = T_GENERAL;

            else if (the_same(csa->image, "generals"))

               csa->token = T_GENERAL;

            else if (the_same(csa->image, "gen"))

               csa->token = T_GENERAL;

            else if (the_same(csa->image, "integer"))

               csa->token = T_INTEGER;

            else if (the_same(csa->image, "integers"))

               csa->token = T_INTEGER;

            else if (the_same(csa->image, "int"))

              csa->token = T_INTEGER;

            else if (the_same(csa->image, "binary"))

               csa->token = T_BINARY;

            else if (the_same(csa->image, "binaries"))

               csa->token = T_BINARY;

            else if (the_same(csa->image, "bin"))

               csa->token = T_BINARY;

            else if (the_same(csa->image, "end"))

               csa->token = T_END;

         }

      }

      else if (isdigit(csa->c) || csa->c == '.')

      {  /* numeric constant */

         csa->token = T_NUMBER;

         /* scan integer part */

         while (isdigit(csa->c)) add_char(csa);

         /* scan optional fractional part (it is mandatory, if there is

            no integer part) */

         if (csa->c == '.')

         {  add_char(csa);

            if (csa->imlen == 1 && !isdigit(csa->c))

               error(csa, "invalid use of decimal point\n");

            while (isdigit(csa->c)) add_char(csa);

         }

         /* scan optional decimal exponent */

         if (csa->c == 'e' || csa->c == 'E')

         {  add_char(csa);

            if (csa->c == '+' || csa->c == '-') add_char(csa);

            if (!isdigit(csa->c))

               error(csa, "numeric constant `%s' incomplete\n",

                  csa->image);

            while (isdigit(csa->c)) add_char(csa);

         }

         /* convert the numeric constant to floating-point */

         if (str2num(csa->image, &csa->value))

            error(csa, "numeric constant `%s' out of range\n",

               csa->image);

      }

      else if (csa->c == '+')

         csa->token = T_PLUS, add_char(csa);

      else if (csa->c == '-')

         csa->token = T_MINUS, add_char(csa);

      else if (csa->c == ':')

         csa->token = T_COLON, add_char(csa);

      else if (csa->c == '<')

      {  csa->token = T_LE, add_char(csa);

         if (csa->c == '=') add_char(csa);

      }

      else if (csa->c == '>')

      {  csa->token = T_GE, add_char(csa);

         if (csa->c == '=') add_char(csa);

      }

      else if (csa->c == '=')

      {  csa->token = T_EQ, add_char(csa);

         if (csa->c == '<')

            csa->token = T_LE, add_char(csa);

         else if (csa->c == '>')

            csa->token = T_GE, add_char(csa);

      }

      else

         error(csa, "character `%c' not recognized\n", csa->c);

      /* skip non-significant characters */

      while (csa->c == ' ') read_char(csa);

      return;

}

static int find_col(struct csa *csa, char *name)

{     /* find column by its symbolic name */

      int j;

      j = glp_find_col(csa->P, name);

      if (j == 0)

      {  /* not found; create new column */

         j = glp_add_cols(csa->P, 1);

         glp_set_col_name(csa->P, j, name);

         /* enlarge working arrays, if necessary */

         if (csa->n_max < j)

         {  int n_max = csa->n_max;

            int *ind = csa->ind;

            double *val = csa->val;

            char *flag = csa->flag;

            double *lb = csa->lb;

            double *ub = csa->ub;

            csa->n_max += csa->n_max;

            csa->ind = xcalloc(1+csa->n_max, sizeof(int));

            memcpy(&csa->ind[1], &ind[1], n_max * sizeof(int));

            xfree(ind);

            csa->val = xcalloc(1+csa->n_max, sizeof(double));

            memcpy(&csa->val[1], &val[1], n_max * sizeof(double));

            xfree(val);

            csa->flag = xcalloc(1+csa->n_max, sizeof(char));

            memset(&csa->flag[1], 0, csa->n_max * sizeof(char));

            memcpy(&csa->flag[1], &flag[1], n_max * sizeof(char));

            xfree(flag);

            csa->lb = xcalloc(1+csa->n_max, sizeof(double));

            memcpy(&csa->lb[1], &lb[1], n_max * sizeof(double));

            xfree(lb);

            csa->ub = xcalloc(1+csa->n_max, sizeof(double));

            memcpy(&csa->ub[1], &ub[1], n_max * sizeof(double));

            xfree(ub);

         }

         csa->lb[j] = +DBL_MAX, csa->ub[j] = -DBL_MAX;

      }

      return j;

}

/***********************************************************************

*  parse_linear_form - parse linear form

*

*  This routine parses the linear form using the following syntax:

*

*  <variable> ::= <symbolic name>

*  <coefficient> ::= <numeric constant>

*  <term> ::= <variable> | <numeric constant> <variable>

*  <linear form> ::= <term> | + <term> | - <term> |

*     <linear form> + <term> | <linear form> - <term>

*

*  The routine returns the number of terms in the linear form. */

static int parse_linear_form(struct csa *csa)

{     int j, k, len = 0, newlen;

      double s, coef;

loop: /* parse an optional sign */

      if (csa->token == T_PLUS)

         s = +1.0, scan_token(csa);

      else if (csa->token == T_MINUS)

         s = -1.0, scan_token(csa);

      else

         s = +1.0;

      /* parse an optional coefficient */

      if (csa->token == T_NUMBER)

         coef = csa->value, scan_token(csa);

      else

         coef = 1.0;

      /* parse a variable name */

      if (csa->token != T_NAME)

         error(csa, "missing variable name\n");

      /* find the corresponding column */

      j = find_col(csa, csa->image);

      /* check if the variable is already used in the linear form */

      if (csa->flag[j])

         error(csa, "multiple use of variable `%s' not allowed\n",

            csa->image);

      /* add new term to the linear form */

      len++, csa->ind[len] = j, csa->val[len] = s * coef;

      /* and mark that the variable is used in the linear form */

      csa->flag[j] = 1;

      scan_token(csa);

      /* if the next token is a sign, there is another term */

      if (csa->token == T_PLUS || csa->token == T_MINUS) goto loop;

      /* clear marks of the variables used in the linear form */

      for (k = 1; k <= len; k++) csa->flag[csa->ind[k]] = 0;

      /* remove zero coefficients */

      newlen = 0;

      for (k = 1; k <= len; k++)

      {  if (csa->val[k] != 0.0)

         {  newlen++;

            csa->ind[newlen] = csa->ind[k];

            csa->val[newlen] = csa->val[k];

         }

      }

      return newlen;

}

/***********************************************************************

*  parse_objective - parse objective function

*

*  This routine parses definition of the objective function using the

*  following syntax:

*

*  <obj sense> ::= minimize | minimum | min | maximize | maximum | max

*  <obj name> ::= <empty> | <symbolic name> :

*  <obj function> ::= <obj sense> <obj name> <linear form> */

static void parse_objective(struct csa *csa)

{     /* parse objective sense */

      int k, len;

      /* parse the keyword 'minimize' or 'maximize' */

      if (csa->token == T_MINIMIZE)

         glp_set_obj_dir(csa->P, GLP_MIN);

      else if (csa->token == T_MAXIMIZE)

         glp_set_obj_dir(csa->P, GLP_MAX);

      else

         xassert(csa != csa);

      scan_token(csa);

      /* parse objective name */

      if (csa->token == T_NAME && csa->c == ':')

      {  /* objective name is followed by a colon */

         glp_set_obj_name(csa->P, csa->image);

         scan_token(csa);

         xassert(csa->token == T_COLON);

         scan_token(csa);

      }

      else

      {  /* objective name is not specified; use default */

         glp_set_obj_name(csa->P, "obj");

      }

      /* parse linear form */

      len = parse_linear_form(csa);

      for (k = 1; k <= len; k++)

         glp_set_obj_coef(csa->P, csa->ind[k], csa->val[k]);

      return;

}

/***********************************************************************

*  parse_constraints - parse constraints section

*

*  This routine parses the constraints section using the following

*  syntax:

*

*  <row name> ::= <empty> | <symbolic name> :

*  <row sense> ::= < | <= | =< | > | >= | => | =

*  <right-hand side> ::= <numeric constant> | + <numeric constant> |

*     - <numeric constant>

*  <constraint> ::= <row name> <linear form> <row sense>

*     <right-hand side>

*  <subject to> ::= subject to | such that | st | s.t. | st.

*  <constraints section> ::= <subject to> <constraint> |

*     <constraints section> <constraint> */

static void parse_constraints(struct csa *csa)

{     int i, len, type;

      double s;

      /* parse the keyword 'subject to' */

      xassert(csa->token == T_SUBJECT_TO);

      scan_token(csa);

loop: /* create new row (constraint) */

      i = glp_add_rows(csa->P, 1);

      /* parse row name */

      if (csa->token == T_NAME && csa->c == ':')

      {  /* row name is followed by a colon */

         if (glp_find_row(csa->P, csa->image) != 0)

            error(csa, "constraint `%s' multiply defined\n",

               csa->image);

         glp_set_row_name(csa->P, i, csa->image);

         scan_token(csa);

         xassert(csa->token == T_COLON);

         scan_token(csa);

      }

      else

      {  /* row name is not specified; use default */

         char name[50];

         sprintf(name, "r.%d", csa->count);

         glp_set_row_name(csa->P, i, name);

      }

      /* parse linear form */

      len = parse_linear_form(csa);

      glp_set_mat_row(csa->P, i, len, csa->ind, csa->val);

      /* parse constraint sense */

      if (csa->token == T_LE)

         type = GLP_UP, scan_token(csa);

      else if (csa->token == T_GE)

         type = GLP_LO, scan_token(csa);

      else if (csa->token == T_EQ)

         type = GLP_FX, scan_token(csa);

      else

         error(csa, "missing constraint sense\n");

      /* parse right-hand side */

      if (csa->token == T_PLUS)

         s = +1.0, scan_token(csa);

      else if (csa->token == T_MINUS)

         s = -1.0, scan_token(csa);

      else

         s = +1.0;

      if (csa->token != T_NUMBER)

         error(csa, "missing right-hand side\n");

      glp_set_row_bnds(csa->P, i, type, s * csa->value, s * csa->value);

      /* the rest of the current line must be empty */

      if (!(csa->c == '\n' || csa->c == XEOF))

         error(csa, "invalid symbol(s) beyond right-hand side\n");

      scan_token(csa);

      /* if the next token is a sign, numeric constant, or a symbolic

         name, here is another constraint */

      if (csa->token == T_PLUS || csa->token == T_MINUS ||

          csa->token == T_NUMBER || csa->token == T_NAME) goto loop;

      return;

}

static void set_lower_bound(struct csa *csa, int j, double lb)

{     /* set lower bound of j-th variable */

      if (csa->lb[j] != +DBL_MAX)

      {  warning(csa, "lower bound of variable `%s' redefined\n",

            glp_get_col_name(csa->P, j));

      }

      csa->lb[j] = lb;

      return;

}

static void set_upper_bound(struct csa *csa, int j, double ub)

{     /* set upper bound of j-th variable */

      if (csa->ub[j] != -DBL_MAX)

      {  warning(csa, "upper bound of variable `%s' redefined\n",

            glp_get_col_name(csa->P, j));

      }

      csa->ub[j] = ub;

      return;

}

/***********************************************************************

*  parse_bounds - parse bounds section

*

*  This routine parses the bounds section using the following syntax:

*

*  <variable> ::= <symbolic name>

*  <infinity> ::= infinity | inf

*  <bound> ::= <numeric constant> | + <numeric constant> |

*     - <numeric constant> | + <infinity> | - <infinity>

*  <lt> ::= < | <= | =<

*  <gt> ::= > | >= | =>

*  <bound definition> ::= <bound> <lt> <variable> <lt> <bound> |

*     <bound> <lt> <variable> | <variable> <lt> <bound> |

*     <variable> <gt> <bound> | <variable> = <bound> | <variable> free

*  <bounds> ::= bounds | bound

*  <bounds section> ::= <bounds> |

*     <bounds section> <bound definition> */

static void parse_bounds(struct csa *csa)

{     int j, lb_flag;

      double lb, s;

      /* parse the keyword 'bounds' */

      xassert(csa->token == T_BOUNDS);

      scan_token(csa);

loop: /* bound definition can start with a sign, numeric constant, or

         a symbolic name */

      if (!(csa->token == T_PLUS || csa->token == T_MINUS ||

            csa->token == T_NUMBER || csa->token == T_NAME)) goto done;

      /* parse bound definition */

      if (csa->token == T_PLUS || csa->token == T_MINUS)

      {  /* parse signed lower bound */

         lb_flag = 1;

         s = (csa->token == T_PLUS ? +1.0 : -1.0);

         scan_token(csa);

         if (csa->token == T_NUMBER)

            lb = s * csa->value, scan_token(csa);

         else if (the_same(csa->image, "infinity") ||

                  the_same(csa->image, "inf"))

         {  if (s > 0.0)

               error(csa, "invalid use of `+inf' as lower bound\n");

            lb = -DBL_MAX, scan_token(csa);

         }

         else

            error(csa, "missing lower bound\n");

      }

      else if (csa->token == T_NUMBER)

      {  /* parse unsigned lower bound */

         lb_flag = 1;

         lb = csa->value, scan_token(csa);

      }

      else

      {  /* lower bound is not specified */

         lb_flag = 0;

      }

      /* parse the token that should follow the lower bound */

      if (lb_flag)

      {  if (csa->token != T_LE)

            error(csa, "missing `<', `<=', or `=<' after lower bound\n")

               ;

         scan_token(csa);

      }

      /* parse variable name */

      if (csa->token != T_NAME)

         error(csa, "missing variable name\n");

      j = find_col(csa, csa->image);

      /* set lower bound */

      if (lb_flag) set_lower_bound(csa, j, lb);

      scan_token(csa);

      /* parse the context that follows the variable name */

      if (csa->token == T_LE)

      {  /* parse upper bound */

         scan_token(csa);

         if (csa->token == T_PLUS || csa->token == T_MINUS)

         {  /* parse signed upper bound */

            s = (csa->token == T_PLUS ? +1.0 : -1.0);

            scan_token(csa);

            if (csa->token == T_NUMBER)

            {  set_upper_bound(csa, j, s * csa->value);

               scan_token(csa);

            }

            else if (the_same(csa->image, "infinity") ||

                     the_same(csa->image, "inf"))

            {  if (s < 0.0)

                  error(csa, "invalid use of `-inf' as upper bound\n");

               set_upper_bound(csa, j, +DBL_MAX);

               scan_token(csa);

            }

            else

               error(csa, "missing upper bound\n");

         }

         else if (csa->token == T_NUMBER)

         {  /* parse unsigned upper bound */

            set_upper_bound(csa, j, csa->value);

            scan_token(csa);

         }

         else

            error(csa, "missing upper bound\n");

      }

      else if (csa->token == T_GE)

      {  /* parse lower bound */

         if (lb_flag)

         {  /* the context '... <= x >= ...' is invalid */

            error(csa, "invalid bound definition\n");

         }

         scan_token(csa);

         if (csa->token == T_PLUS || csa->token == T_MINUS)

         {  /* parse signed lower bound */

            s = (csa->token == T_PLUS ? +1.0 : -1.0);

            scan_token(csa);

            if (csa->token == T_NUMBER)

            {  set_lower_bound(csa, j, s * csa->value);

               scan_token(csa);

            }

            else if (the_same(csa->image, "infinity") ||

                     the_same(csa->image, "inf") == 0)

            {  if (s > 0.0)

                  error(csa, "invalid use of `+inf' as lower bound\n");

               set_lower_bound(csa, j, -DBL_MAX);

               scan_token(csa);

            }

            else

               error(csa, "missing lower bound\n");

         }

         else if (csa->token == T_NUMBER)

         {  /* parse unsigned lower bound */

            set_lower_bound(csa, j, csa->value);

            scan_token(csa);

         }

         else

            error(csa, "missing lower bound\n");

      }

      else if (csa->token == T_EQ)

      {  /* parse fixed value */

         if (lb_flag)

         {  /* the context '... <= x = ...' is invalid */

            error(csa, "invalid bound definition\n");

         }

         scan_token(csa);

         if (csa->token == T_PLUS || csa->token == T_MINUS)

         {  /* parse signed fixed value */

            s = (csa->token == T_PLUS ? +1.0 : -1.0);

            scan_token(csa);

            if (csa->token == T_NUMBER)

            {  set_lower_bound(csa, j, s * csa->value);

               set_upper_bound(csa, j, s * csa->value);

               scan_token(csa);

            }

            else

               error(csa, "missing fixed value\n");

         }

         else if (csa->token == T_NUMBER)

         {  /* parse unsigned fixed value */

            set_lower_bound(csa, j, csa->value);

            set_upper_bound(csa, j, csa->value);

            scan_token(csa);

         }

         else

            error(csa, "missing fixed value\n");

      }

      else if (the_same(csa->image, "free"))

      {  /* parse the keyword 'free' */

         if (lb_flag)

         {  /* the context '... <= x free ...' is invalid */

            error(csa, "invalid bound definition\n");

         }

         set_lower_bound(csa, j, -DBL_MAX);

         set_upper_bound(csa, j, +DBL_MAX);

         scan_token(csa);

      }

      else if (!lb_flag)

      {  /* neither lower nor upper bounds are specified */

         error(csa, "invalid bound definition\n");

      }

      goto loop;

done: return;

}

/***********************************************************************

*  parse_integer - parse general, integer, or binary section

*

*  <variable> ::= <symbolic name>

*  <general> ::= general | generals | gen

*  <integer> ::= integer | integers | int

*  <binary> ::= binary | binaries | bin

*  <section head> ::= <general> <integer> <binary>

*  <additional section> ::= <section head> |

*     <additional section> <variable> */

static void parse_integer(struct csa *csa)

{     int j, binary;

      /* parse the keyword 'general', 'integer', or 'binary' */

      if (csa->token == T_GENERAL)

         binary = 0, scan_token(csa);

      else if (csa->token == T_INTEGER)

         binary = 0, scan_token(csa);

      else if (csa->token == T_BINARY)

         binary = 1, scan_token(csa);

      else

         xassert(csa != csa);

      /* parse list of variables (may be empty) */

      while (csa->token == T_NAME)

      {  /* find the corresponding column */

         j = find_col(csa, csa->image);

         /* change kind of the variable */

         glp_set_col_kind(csa->P, j, GLP_IV);

         /* set 0-1 bounds for the binary variable */

         if (binary)

         {  set_lower_bound(csa, j, 0.0);

            set_upper_bound(csa, j, 1.0);

         }

         scan_token(csa);

      }

      return;

}

int glp_read_lp(glp_prob *P, const glp_cpxcp *parm, const char *fname)

{     /* read problem data in CPLEX LP format */

      glp_cpxcp _parm;

      struct csa _csa, *csa = &_csa;

      int ret;

      xprintf("Reading problem data from `%s'...\n", fname);

      if (parm == NULL)

         glp_init_cpxcp(&_parm), parm = &_parm;

      /* check control parameters */

      check_parm("glp_read_lp", parm);

      /* initialize common storage area */

      csa->P = P;

      csa->parm = parm;

      csa->fname = fname;

      csa->fp = NULL;

      if (setjmp(csa->jump))

      {  ret = 1;

         goto done;

      }

      csa->count = 0;

      csa->c = '\n';

      csa->token = T_EOF;

      csa->image[0] = '\0';

      csa->imlen = 0;

      csa->value = 0.0;

      csa->n_max = 100;

      csa->ind = xcalloc(1+csa->n_max, sizeof(int));

      csa->val = xcalloc(1+csa->n_max, sizeof(double));

      csa->flag = xcalloc(1+csa->n_max, sizeof(char));

      memset(&csa->flag[1], 0, csa->n_max * sizeof(char));

      csa->lb = xcalloc(1+csa->n_max, sizeof(double));

      csa->ub = xcalloc(1+csa->n_max, sizeof(double));

      /* erase problem object */

      glp_erase_prob(P);

      glp_create_index(P);

      /* open input CPLEX LP file */

      csa->fp = xfopen(fname, "r");

      if (csa->fp == NULL)

      {  xprintf("Unable to open `%s' - %s\n", fname, xerrmsg());

         ret = 1;

         goto done;

      }

      /* scan very first token */

      scan_token(csa);

      /* parse definition of the objective function */

      if (!(csa->token == T_MINIMIZE || csa->token == T_MAXIMIZE))

         error(csa, "`minimize' or `maximize' keyword missing\n");

      parse_objective(csa);

      /* parse constraints section */

      if (csa->token != T_SUBJECT_TO)

         error(csa, "constraints section missing\n");

      parse_constraints(csa);

      /* parse optional bounds section */

      if (csa->token == T_BOUNDS) parse_bounds(csa);

      /* parse optional general, integer, and binary sections */

      while (csa->token == T_GENERAL ||

             csa->token == T_INTEGER ||

             csa->token == T_BINARY) parse_integer(csa);

      /* check for the keyword 'end' */

      if (csa->token == T_END)

         scan_token(csa);

      else if (csa->token == T_EOF)

         warning(csa, "keyword `end' missing\n");

      else

         error(csa, "symbol `%s' in wrong position\n", csa->image);

      /* nothing must follow the keyword 'end' (except comments) */

      if (csa->token != T_EOF)

         error(csa, "extra symbol(s) detected beyond `end'\n");

      /* set bounds of variables */

      {  int j, type;

         double lb, ub;

         for (j = 1; j <= P->n; j++)

         {  lb = csa->lb[j];

            ub = csa->ub[j];

            if (lb == +DBL_MAX) lb = 0.0;      /* default lb */

            if (ub == -DBL_MAX) ub = +DBL_MAX; /* default ub */

            if (lb == -DBL_MAX && ub == +DBL_MAX)

               type = GLP_FR;

            else if (ub == +DBL_MAX)

               type = GLP_LO;

            else if (lb == -DBL_MAX)

               type = GLP_UP;

            else if (lb != ub)

               type = GLP_DB;

            else

               type = GLP_FX;

            glp_set_col_bnds(csa->P, j, type, lb, ub);

         }

      }

      /* print some statistics */

      xprintf("%d row%s, %d column%s, %d non-zero%s\n",

         P->m, P->m == 1 ? "" : "s", P->n, P->n == 1 ? "" : "s",

         P->nnz, P->nnz == 1 ? "" : "s");

      if (glp_get_num_int(P) > 0)

      {  int ni = glp_get_num_int(P);

         int nb = glp_get_num_bin(P);

         if (ni == 1)

         {  if (nb == 0)

               xprintf("One variable is integer\n");

            else

               xprintf("One variable is binary\n");

         }

         else

         {  xprintf("%d integer variables, ", ni);

            if (nb == 0)

               xprintf("none");

            else if (nb == 1)

               xprintf("one");

            else if (nb == ni)

               xprintf("all");

            else

               xprintf("%d", nb);

            xprintf(" of which %s binary\n", nb == 1 ? "is" : "are");

         }

      }

      xprintf("%d lines were read\n", csa->count);

      /* problem data has been successfully read */

      glp_delete_index(P);

      glp_sort_matrix(P);

      ret = 0;

done: if (csa->fp != NULL) xfclose(csa->fp);

      xfree(csa->ind);

      xfree(csa->val);

      xfree(csa->flag);

      xfree(csa->lb);

      xfree(csa->ub);

      if (ret != 0) glp_erase_prob(P);

      return ret;

}

/***********************************************************************

*  NAME

*

*  glp_write_lp - write problem data in CPLEX LP format

*

*  SYNOPSIS

*

*  int glp_write_lp(glp_prob *P, const glp_cpxcp *parm, const char

*     *fname);

*

*  DESCRIPTION

*

*  The routine glp_write_lp writes problem data in CPLEX LP format to

*  a text file.

*

*  The parameter parm is a pointer to the structure glp_cpxcp, which

*  specifies control parameters used by the routine. If parm is NULL,

*  the routine uses default settings.

*

*  The character string fname specifies a name of the text file to be

*  written.

*

*  RETURNS

*

*  If the operation was successful, the routine glp_write_lp returns

*  zero. Otherwise, it prints an error message and returns non-zero. */

#define csa csa1

struct csa

{     /* common storage area */

      glp_prob *P;

      /* pointer to problem object */

      const glp_cpxcp *parm;

      /* pointer to control parameters */

};

static int check_name(char *name)