parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  pv->isign = 0;  pv->f = -1.0;}                  VAR_STORE{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  pv->isign = pv->isign0;  pv->f = pv->f0;}                  RHS_STORE{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  if(!store_bounds(pp, TRUE))    YYABORT;}                  optionalbound{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  /* pv->HadConstraint = FALSE; */  pv->HadVar = FALSE;  pv->isign = 0;  pv->make_neg = 0;  null_tmp_store(pp, TRUE);}                ;bound2:           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;  if(!store_bounds(pp, TRUE))    YYABORT;  /* pv->HadConstraint = FALSE; */  pv->HadVar = FALSE;  pv->isign = 0;  pv->make_neg = 0;  null_tmp_store(pp, TRUE);}                | FRE{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  if(!store_re_op(pp, '>', pv->HadConstraint, pv->HadVar, pv->Had_lineair_sum))    YYABORT;  pv->make_neg = 1;  pv->isign = 0;  pv->f = -DEF_INFINITE;}                  RHS_STORE{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  if(!store_bounds(pp, FALSE))    YYABORT;  if(!store_re_op(pp, '<', pv->HadConstraint, pv->HadVar, pv->Had_lineair_sum))    YYABORT;  pv->f = DEF_INFINITE;  pv->isign = 0;}                  RHS_STORE{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  if(!store_bounds(pp, FALSE))    YYABORT;  /* pv->HadConstraint = FALSE; */  pv->HadVar = FALSE;  pv->isign = 0;  pv->make_neg = 0;  null_tmp_store(pp, TRUE);}                ;optionalbound:    EMPTY                | RE_OP{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  if(!store_re_op(pp, (char) ((pv->OP == '<') ? '>' : (pv->OP == '>') ? '<' : pv->OP), (int) pv->HadConstraint, (int) pv->HadVar, (int) pv->Had_lineair_sum))    YYABORT;  pv->make_neg = 0;  pv->isign = 0;}                  cons_term                  RHS_STORE{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  if(!store_bounds(pp, TRUE))    YYABORT;}                ;/* end bounds */REALCONS: INTCONS | CONS                ;RHS_STORE:        EMPTY{  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;  if(!rhs_store(pp, pv->f, pv->HadConstraint, pv->HadVar, pv->Had_lineair_sum))    YYABORT;  pv->isign = 0;}                ;x_SIGN:           EMPTY{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  pv->isign = 0;}                | TOK_SIGN{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  pv->isign = pv->Sign;  pv->HadSign = TRUE;}                ;VAR_STORE:        EMPTY{  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;  if(!var_store(pp, pv->Last_var, pv->f, pv->HadConstraint, pv->HadVar, pv->Had_lineair_sum)) {    yyerror(pp, pp->scanner, "var_store failed");    YYABORT;  }  /* pv->HadConstraint |= pv->HadVar; */  pv->HadVar = TRUE;  pv->isign = 0;}                ;/* start int_sec_sos_declarations */int_sec_sos_declarations: x_int_declarations                          x_sec_declarations                          x_sos_declarations                ;VARIABLES:        ONEVARIABLE                | VARIABLES                  ONEVARIABLE                ;SOSVARIABLES:     ONESOSVARIABLE                | SOSVARIABLES                  ONESOSVARIABLE                ;ONEVARIABLE:      VARIABLE{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  storevarandweight(pp, pv->Last_var);}                ;ONESOSVARIABLE:   VARIABLE{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  pv->SOSNr++;  pv->weight = pv->SOSNr;  storevarandweight(pp, pv->Last_var);  set_sos_weight(pp, pv->weight, 2);}                | VARIABLECOLON{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  storevarandweight(pp, pv->Last_var);}                  INTCONS{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  pv->weight = (int) (pv->f + .1);  set_sos_weight(pp, pv->weight, 2);}                ;x_int_declarations:                  EMPTY                | int_declarations                ;int_declarations: int_declaration                | int_declarations                  int_declaration                ;int_declaration: SEC_INT{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  check_int_sec_sos_free_decl(pp, pv->Within_gen_decl ? 1 : pv->Within_bin_decl ? 2 : 0, 0, 0, 0);}                 VARIABLES                ;x_sec_declarations:                 EMPTY                | sec_declarations                ;sec_declarations: sec_declaration                | sec_declarations                  sec_declaration                ;sec_declaration: SEC_SEC{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  check_int_sec_sos_free_decl(pp, 0, 1, 0, 0);}                 VARIABLES                ;x_sos_declarations:                  EMPTY                | sos_declarations                ;sos_declarations: sos_declaration                | sos_declarations                  sos_declaration                ;sos_declaration: SEC_SOS                 x_single_sos_declarations                ;x_single_sos_declarations:                  EMPTY                | single_sos_declarations                ;single_sos_declarations:                  single_sos_declaration                | single_sos_declarations                  single_sos_declaration                ;single_sos_declaration:                 SOSTYPE{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  char buf[16], *ptr, *var;  check_int_sec_sos_free_decl(pp, 0, 0, 1, 0);  pv->SOSweight++;  for (ptr = pv->Last_var; (*ptr) && (*ptr != ':'); ptr++);  if (ptr[1] == ':') {    sprintf(buf, "SOS%d", pv->SOSweight);    var = buf;    ptr = pv->Last_var;  }  else {    var = ptr + 1;    while ((ptr > pv->Last_var) && (isspace(ptr[-1]))) ptr--;    *ptr = 0;    ptr = var;    var = pv->Last_var;    while (isspace(*ptr)) ptr++;  }  storevarandweight(pp, var);  pv->SOStype = ptr[1] - '0';  set_sos_type(pp, pv->SOStype);  check_int_sec_sos_free_decl(pp, 0, 0, 2, 0);  pv->weight = 0;  pv->SOSNr = 0;}                 SOSVARIABLES{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  set_sos_weight(pp, pv->SOSweight, 1);}                ;/* end int_sec_sos_declarations */VARIABLE: VAR | FRE                ;/* start end */end:              EMPTY                | END                ;/* end end */%%static void yy_delete_allocated_memory(parse_parm *pp){  parse_vars *pv = (parse_vars *) pp->parse_vars;  /* free memory allocated by flex. Otherwise some memory is not freed.     This is a bit tricky. There is not much documentation about this, but a lot of     reports of memory that keeps allocated */  /* If you get errors on this function call, just comment it. This will only result     in some memory that is not being freed. */# if defined YY_CURRENT_BUFFER    /* flex defines the macro YY_CURRENT_BUFFER, so you should only get here if lp_rlp.h is       generated by flex */    /* lex doesn't define this macro and thus should not come here, but lex doesn't has       this memory leak also ...*/#  if 0    /* older versions of flex */    yy_delete_buffer(YY_CURRENT_BUFFER); /* comment this line if you have problems with it */    yy_init = 1; /* make sure that the next time memory is allocated again */    yy_start = 0;#  else    /* As of version 2.5.9 Flex  */    yylex_destroy(pp->scanner); /* comment this line if you have problems with it */#  endif# endif  FREE(pv->Last_var);}static int parse(parse_parm *pp){  return(yyparse(pp, pp->scanner));}lprec *read_lptex(lprec *lp, FILE *filename, int verbose, char *lp_name, char objconst0){  parse_vars *pv;  lprec *lp1 = NULL;  CALLOC(pv, 1, parse_vars);  if (pv != NULL) {    parse_parm pp;    memset(&pp, 0, sizeof(pp));    pp.parse_vars = (void *) pv;    yylex_init(&pp.scanner);    yyset_extra(&pp, pp.scanner);    yyset_in((FILE *) filename, pp.scanner);    yyset_out(NULL, pp.scanner);    pv->objconst = objconst0;    lp1 = yacc_read(lp, verbose, lp_name, parse, &pp, yy_delete_allocated_memory);    FREE(pv);  }  return(lp1);}lprec * __WINAPI read_lpt(FILE *filename, int verbose, char *lp_name){  return(read_lptex(NULL, filename, verbose, lp_name, FALSE));}lprec *read_LPTex(lprec *lp, char *filename, int verbose, char *lp_name, char objconst){  FILE *fpin;  if((fpin = fopen(filename, "r")) != NULL) {    lp = read_lptex(lp, fpin, verbose, lp_name, objconst);    fclose(fpin);  }  else    lp = NULL;  return(lp);}lprec * __WINAPI read_LPT(char *filename, int verbose, char *lp_name){  return(read_LPTex(NULL, filename, verbose, lp_name, FALSE));}