lp_rlpt.y

lp_solve_5.5.0.13_xli_CPLEX_source.tar优化问题的求解

/* ========================================================================= */
/* NAME  : lp_rlpt.y                                                         */
/* ========================================================================= */

/*
   made reentrant with help of
   http://www.usualcoding.eu/post/2007/09/03/Building-a-reentrant-parser-in-C-with-Flex/Bison
*/

/*
   Note that a minimum version of bison is needed to be able to compile this.
   Older version don't know the reentrant code.
   Version 1.35 is not enough. v1.875 could be ok. Tested with v2.3
*/

%pure-parser
%parse-param {parse_parm *parm}
%parse-param {void *scanner}
%lex-param {yyscan_t *scanner}

%token VAR CONS INTCONS VARIABLECOLON INF FRE SEC_INT SEC_SEC SEC_SOS SOSTYPE TOK_SIGN RE_OPEQ RE_OPLE RE_OPGE MINIMISE MAXIMISE SUBJECTTO BOUNDS END UNDEFINED


%{
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#define scanner yyscanner
#define PARM yyget_extra(yyscanner)
#define YYSTYPE int
#define YY_EXTRA_TYPE parse_parm *
#define YY_FATAL_ERROR(msg) lex_fatal_error(PARM, yyscanner, msg)
#undef YY_INPUT
#define yyerror read_error

#include "lpkit.h"
#include "yacc_read.h"

typedef struct parse_vars_s
{
  char HadVar, HadConstraint, Had_lineair_sum, HadSign, OP, Sign, isign, isign0, make_neg, objconst;
  char Within_gen_decl;  /* TRUE when we are within an gen declaration */
  char Within_bin_decl;  /* TRUE when we are within an bin declaration */
  char Within_sec_decl;  /* TRUE when we are within a sec declaration */
  char Within_sos_decl;  /* TRUE when we are within a sos declaration */
  short SOStype;         /* SOS type */
  int SOSNr;
  int SOSweight;         /* SOS weight */
  int weight;
  char *Last_var;
  REAL f, f0, f1, f2;
} parse_vars;

#ifdef FORTIFY
# include "lp_fortify.h"
#endif

/* let's please C++ users */
#ifdef __cplusplus
extern "C" {
#endif

#if defined MSDOS || defined __MSDOS__ || defined WINDOWS || defined _WINDOWS || defined WIN32 || defined _WIN32
#define YY_NO_UNISTD_H

static int isatty(int f)
{
  return(FALSE);
}

#if !defined _STDLIB_H
# define _STDLIB_H
#endif
#endif

#ifdef __cplusplus
};
#endif

#include "lp_rlpt.inc"

#undef yylval

%}



%start inputfile
%%

EMPTY: /* EMPTY */
                ;

inputfile	:
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->isign = 0;
  pv->make_neg = 0;
  pv->Sign = 0;
  pv->HadConstraint = FALSE;
  pv->HadVar = FALSE;
}
		  objective_function
                  constraints
		  bounds
                  int_sec_sos_declarations
                  end
		;

/* start objective_function */

/*

 objective_function: objective_function1;
 objective_function1:MAXIMISE of | MINIMISE of;
 of:                 real_of | VARIABLECOLON real_of;
 real_of:            of_lineair_sum;
 of_lineair_sum:     EMPTY | of_lineair_sum1;
 of_lineair_sum1:    of_lineair_term | of_lineair_sum1 of_lineair_term;
 of_lineair_term:    x_SIGN of_lineair_term1
 of_lineair_term1:   REALCONS | VARIABLE VAR_STORE;

*/

objective_function:
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->f = 1;
  pv->f1 = pv->f2 = 0;
}
                  objective_function1
                ;

objective_function1:
                  MAXIMISE
                  of
{
  set_obj_dir(PARM, TRUE);
}
                | MINIMISE
                  of
{
  set_obj_dir(PARM, FALSE);
}
                ;

of              : real_of
                | VARIABLECOLON
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if(!add_constraint_name(pp, pv->Last_var))
    YYABORT;
  /* pv->HadConstraint = TRUE; */
}
                  real_of
                ;

real_of:          of_lineair_sum
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if((!pv->objconst) && (pv->f1 + pv->f2 != 0)) {
    yyerror(pp, pp->scanner, "constant in objective not supported");
    YYABORT;
  }
  if(!rhs_store(pp, -(pv->f1 + pv->f2), pv->HadConstraint, pv->HadVar, pv->Had_lineair_sum))
    YYABORT;

  add_row(pp);
  /* pv->HadConstraint = FALSE; */
  pv->HadVar = FALSE;
  pv->isign = 0;
  pv->make_neg = 0;
}
		;

of_lineair_sum  : EMPTY
                | of_lineair_sum1
                ;

of_lineair_sum1	: of_lineair_term
		| of_lineair_sum1
		  of_lineair_term
		;

of_lineair_term :
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->HadSign = FALSE;
}
                  x_SIGN
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if(pv->HadSign) {
    pv->f1 += pv->f2;
    pv->f = 1;
  }
}
                  of_lineair_term1;

of_lineair_term1: REALCONS
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if (    (pv->isign || pv->make_neg)
      && !(pv->isign && pv->make_neg)) /* but not both! */
    pv->f = -pv->f;
  pv->f2 = pv->f;
  pv->isign = 0;
}
                |
		  VARIABLE
                  VAR_STORE
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->f2 = 0;
  pv->f = 1;
}
                ;

/* end objective_function */



/* start constraints */

/*

 constraints:        EMPTY | constraints1;
 constraints1:       SUBJECTTO constraints2;
 constraints2:       EMPTY | constraints3;
 constraints3:       constraint | constraints3 constraint;
 constraint:         real_constraint | VARIABLECOLON real_constraint;
 real_constraint:    x_lineair_sum RE_OP cons_term RHS_STORE;
 RE_OP:              RE_OPEQ | RE_OPLE | RE_OPGE;
 cons_term:          x_SIGN REALCONS | INF;
 x_lineair_sum:      EMPTY | lineair_sum;
 lineair_sum:        lineair_term | lineair_sum lineair_term;
 lineair_term:       x_SIGN VARIABLE VAR_STORE | x_SIGN REALCONS VARIABLE VAR_STORE;
 x_SIGN:             EMPTY | TOK_SIGN;
 VARIABLE:           VAR | FRE;
 REALCONS:           INTCONS | CONS;

*/

constraints     : EMPTY
                | constraints1
                ;

constraints1:     SUBJECTTO
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->HadConstraint = TRUE;
}
                  constraints2
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->HadConstraint = FALSE;
}
                ;

constraints2:   EMPTY
                | constraints3
                ;

constraints3	: constraint
		| constraints3
		  constraint
		;

constraint      : real_constraint
                | VARIABLECOLON
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if(!add_constraint_name(pp, pv->Last_var))
    YYABORT;
  /* pv->HadConstraint = TRUE; */
}
                  real_constraint
                ;

real_constraint	: x_lineair_sum
		  RE_OP
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if(!store_re_op(pp, pv->OP, pv->HadConstraint, pv->HadVar, pv->Had_lineair_sum))
    YYABORT;
  pv->make_neg = 1;
}
		  cons_term
                  RHS_STORE
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->Had_lineair_sum = TRUE;
  add_row(pp);
  /* pv->HadConstraint = FALSE; */
  pv->HadVar = FALSE;
  pv->isign = 0;
  pv->make_neg = 0;
  null_tmp_store(pp, TRUE);
}
		;

x_lineair_sum	: EMPTY
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->HadConstraint = pv->HadVar = TRUE;
}
                | lineair_sum
                ;

lineair_sum	: lineair_term
		| lineair_sum
		  lineair_term
		;

lineair_term	: x_SIGN
                  VARIABLE
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->f = 1.0;
}
                  VAR_STORE
		| x_SIGN
                  REALCONS
		  VARIABLE
                  VAR_STORE
                ;

RE_OP: RE_OPEQ | RE_OPLE | RE_OPGE
                ;

cons_term:        x_SIGN
		  REALCONS
                | INF
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->isign = pv->Sign;
}
                ;

/* end constraints */



/* start bounds */

/*

 bounds:             EMPTY | BOUNDS x_bounds;
 x_bounds:           EMPTY | x_bounds1;
 x_bounds1:          bound | x_bounds1 bound;
 bound:              VARIABLE VAR_STORE bound2 | cons_term RE_OP VARIABLE VAR_STORE RHS_STORE optionalbound;
 VARIABLE:           VAR | FRE;
 bound2:             RE_OP cons_term RHS_STORE | FRE RHS_STORE RHS_STORE;
 cons_term:          x_SIGN REALCONS | INF;
 optionalbound:      EMPTY | RE_OP cons_term RHS_STORE;

*/

bounds:           EMPTY
                | BOUNDS
                  x_bounds
                ;

x_bounds:         EMPTY
                | x_bounds1
                ;

x_bounds1:        bound
                | x_bounds1
                  bound
                ;

bound:            VARIABLE
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->f = 1.0;
  pv->isign = 0;
}
                  VAR_STORE
                  bound2
		| cons_term
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pv->f0 = pv->f;
  pv->isign0 = pv->isign;
}
		  RE_OP
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  if(!store_re_op(pp, pv->OP, pv->HadConstraint, pv->HadVar, pv->Had_lineair_sum))
    YYABORT;
  pv->make_neg = 0;
}
                  VARIABLE
{