lp_rlpt.inc

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

#ifndef YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE 8192
#endif

/* Copy whatever the last rule matched to the standard output. */
#ifndef ECHO
/* This used to be an fputs(), but since the string might contain NUL's,
 * we now use fwrite().
 */
#define ECHO fwrite( lpt_yytext, lpt_yyleng, 1, lpt_yyout )
#endif

/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 * is returned in "result".
 */
#ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
	if ( YY_CURRENT_BUFFER_LVALUE->lpt_yy_is_interactive ) \
		{ \
		int c = '*'; \
		int n; \
		for ( n = 0; n < max_size && \
			     (c = getc( lpt_yyin )) != EOF && c != '\n'; ++n ) \
			buf[n] = (char) c; \
		if ( c == '\n' ) \
			buf[n++] = (char) c; \
		if ( c == EOF && ferror( lpt_yyin ) ) \
			YY_FATAL_ERROR( "input in flex scanner failed" ); \
		result = n; \
		} \
	else \
		{ \
		errno=0; \
		while ( (result = fread(buf, 1, max_size, lpt_yyin))==0 && ferror(lpt_yyin)) \
			{ \
			if( errno != EINTR) \
				{ \
				YY_FATAL_ERROR( "input in flex scanner failed" ); \
				break; \
				} \
			errno=0; \
			clearerr(lpt_yyin); \
			} \
		}\
\

#endif

/* No semi-colon after return; correct usage is to write "lpt_yyterminate();" -
 * we don't want an extra ';' after the "return" because that will cause
 * some compilers to complain about unreachable statements.
 */
#ifndef lpt_yyterminate
#define lpt_yyterminate() return YY_NULL
#endif

/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif

/* Report a fatal error. */
#ifndef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) lpt_yy_fatal_error( msg , lpt_yyscanner)
#endif

/* end tables serialization structures and prototypes */

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1

extern int lpt_yylex \
               (YYSTYPE * lpt_yylval_param ,lpt_yyscan_t lpt_yyscanner);

#define YY_DECL int lpt_yylex \
               (YYSTYPE * lpt_yylval_param , lpt_yyscan_t lpt_yyscanner)
#endif /* !YY_DECL */

/* Code executed at the beginning of each rule, after lpt_yytext and lpt_yyleng
 * have been set up.
 */
#ifndef YY_USER_ACTION
#define YY_USER_ACTION
#endif

/* Code executed at the end of each rule. */
#ifndef YY_BREAK
#define YY_BREAK break;
#endif

#define YY_RULE_SETUP \
	if ( lpt_yyleng > 0 ) \
		YY_CURRENT_BUFFER_LVALUE->lpt_yy_at_bol = \
				(lpt_yytext[lpt_yyleng - 1] == '\n'); \
	YY_USER_ACTION

/** The main scanner function which does all the work.
 */
YY_DECL
{
	register lpt_yy_state_type lpt_yy_current_state;
	register char *lpt_yy_cp, *lpt_yy_bp;
	register int lpt_yy_act;
    struct lpt_yyguts_t * lpt_yyg = (struct lpt_yyguts_t*)lpt_yyscanner;

    lpt_yylval = lpt_yylval_param;

	if ( !lpt_yyg->lpt_yy_init )
		{
		lpt_yyg->lpt_yy_init = 1;

#ifdef YY_USER_INIT
		YY_USER_INIT;
#endif

		if ( ! lpt_yyg->lpt_yy_start )
			lpt_yyg->lpt_yy_start = 1;	/* first start state */

		if ( ! lpt_yyin )
			lpt_yyin = stdin;

		if ( ! lpt_yyout )
			lpt_yyout = stdout;

		if ( ! YY_CURRENT_BUFFER ) {
			lpt_yyensure_buffer_stack (lpt_yyscanner);
			YY_CURRENT_BUFFER_LVALUE =
				lpt_yy_create_buffer(lpt_yyin,YY_BUF_SIZE ,lpt_yyscanner);
		}

		lpt_yy_load_buffer_state(lpt_yyscanner );
		}

	while ( 1 )		/* loops until end-of-file is reached */
		{
		lpt_yy_cp = lpt_yyg->lpt_yy_c_buf_p;

		/* Support of lpt_yytext. */
		*lpt_yy_cp = lpt_yyg->lpt_yy_hold_char;

		/* lpt_yy_bp points to the position in lpt_yy_ch_buf of the start of
		 * the current run.
		 */
		lpt_yy_bp = lpt_yy_cp;

		lpt_yy_current_state = lpt_yyg->lpt_yy_start;
		lpt_yy_current_state += YY_AT_BOL();
lpt_yy_match:
		do
			{
			register YY_CHAR lpt_yy_c = lpt_yy_ec[YY_SC_TO_UI(*lpt_yy_cp)];
			if ( lpt_yy_accept[lpt_yy_current_state] )
				{
				lpt_yyg->lpt_yy_last_accepting_state = lpt_yy_current_state;
				lpt_yyg->lpt_yy_last_accepting_cpos = lpt_yy_cp;
				}
			while ( lpt_yy_chk[lpt_yy_base[lpt_yy_current_state] + lpt_yy_c] != lpt_yy_current_state )
				{
				lpt_yy_current_state = (int) lpt_yy_def[lpt_yy_current_state];
				if ( lpt_yy_current_state >= 174 )
					lpt_yy_c = lpt_yy_meta[(unsigned int) lpt_yy_c];
				}
			lpt_yy_current_state = lpt_yy_nxt[lpt_yy_base[lpt_yy_current_state] + (unsigned int) lpt_yy_c];
			++lpt_yy_cp;
			}
		while ( lpt_yy_base[lpt_yy_current_state] != 716 );

lpt_yy_find_action:
		lpt_yy_act = lpt_yy_accept[lpt_yy_current_state];
		if ( lpt_yy_act == 0 )
			{ /* have to back up */
			lpt_yy_cp = lpt_yyg->lpt_yy_last_accepting_cpos;
			lpt_yy_current_state = lpt_yyg->lpt_yy_last_accepting_state;
			lpt_yy_act = lpt_yy_accept[lpt_yy_current_state];
			}

		YY_DO_BEFORE_ACTION;

		if ( lpt_yy_act != YY_END_OF_BUFFER && lpt_yy_rule_can_match_eol[lpt_yy_act] )
			{
			int lpt_yyl;
			for ( lpt_yyl = 0; lpt_yyl < lpt_yyleng; ++lpt_yyl )
				if ( lpt_yytext[lpt_yyl] == '\n' )
					   
    do{ lpt_yylineno++;
        lpt_yycolumn=0;
    }while(0)
;
			}

do_action:	/* This label is used only to access EOF actions. */

		switch ( lpt_yy_act )
	{ /* beginning of action switch */
			case 0: /* must back up */
			/* undo the effects of YY_DO_BEFORE_ACTION */
			*lpt_yy_cp = lpt_yyg->lpt_yy_hold_char;
			lpt_yy_cp = lpt_yyg->lpt_yy_last_accepting_cpos;
			lpt_yy_current_state = lpt_yyg->lpt_yy_last_accepting_state;
			goto lpt_yy_find_action;

case 1:
YY_RULE_SETUP
{
  BEGIN LINECOMMENT;
} /* begin skip LINECOMMENT */
	YY_BREAK
case 2:
/* rule 2 can match eol */
YY_RULE_SETUP
{
  BEGIN INITIAL;
} /* end skip LINECOMMENT */
	YY_BREAK
case 3:
YY_RULE_SETUP
{
  BEGIN INITIAL;
} /* end skip LINECOMMENT */
	YY_BREAK
case 4:
YY_RULE_SETUP
{
}
	YY_BREAK
case 5:
/* rule 5 can match eol */
YY_RULE_SETUP
{
}
	YY_BREAK
case 6:
YY_RULE_SETUP
{
  parse_parm *pp = PARM;

  pp->lineno = lpt_yylineno;
  return(MINIMISE);
}
	YY_BREAK
case 7:
YY_RULE_SETUP
{
  parse_parm *pp = PARM;

  pp->lineno = lpt_yylineno;
  return(MAXIMISE);
}
	YY_BREAK
case 8:
YY_RULE_SETUP
{
  parse_parm *pp = PARM;

  pp->lineno = lpt_yylineno;
  return(SUBJECTTO);
}
	YY_BREAK
case 9:
YY_RULE_SETUP
{
  parse_parm *pp = PARM;

  pp->lineno = lpt_yylineno;
  return(BOUNDS);
}
	YY_BREAK
case 10:
YY_RULE_SETUP
{
  parse_parm *pp = PARM;

  pp->lineno = lpt_yylineno;
  return(END);
}
	YY_BREAK
case 11:
YY_RULE_SETUP
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;
  char *ptr = (char *)lpt_yytext;

  pp->lineno = lpt_yylineno;
  while ((isspace(*ptr))) ptr++;
  pv->f = atof(ptr);
  return(INTCONS);
} /* f contains the last float */
	YY_BREAK
case 12:
YY_RULE_SETUP
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;
  char *ptr = (char *)lpt_yytext;

  pp->lineno = lpt_yylineno;
  while ((isspace(*ptr))) ptr++;
  pv->f = atof(ptr);
  return(CONS);
} /* f contains the last float */
	YY_BREAK
case 13:
/* rule 13 can match eol */
YY_RULE_SETUP
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;
  char *ptr = (char *)lpt_yytext;

  pp->lineno = lpt_yylineno;
  pv->f = DEF_INFINITE;
  pv->Sign = 0;
  while (isspace(*ptr)) ptr++;
  if(*ptr == '-')
    pv->Sign = 1;
  return(INF);
} /* f contains the last float */
	YY_BREAK
case 14:
YY_RULE_SETUP
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;
  char *ptr = (char *)lpt_yytext;

  pp->lineno = lpt_yylineno;
  while ((isspace(*ptr))) ptr++;
  FREE(pv->Last_var);
  pv->Last_var = strdup(ptr);
  return(FRE);
}
	YY_BREAK
case 15:
YY_RULE_SETUP
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;
  int x;

  pp->lineno = lpt_yylineno;
  pv->Sign = 0;
  for(x = 0; x < lpt_yyleng; x++)
    if(lpt_yytext[x] == '-' || lpt_yytext[x] == '+')
      pv->Sign = (pv->Sign == (lpt_yytext[x] == '+'));
  return (TOK_SIGN);
  /* Sign is TRUE if the sign-string
     represents a '-'. Otherwise Sign
     is FALSE */
}
	YY_BREAK
case 16:
YY_RULE_SETUP
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;
  char *ptr = (char *)lpt_yytext;

  pp->lineno = lpt_yylineno;
  while ((isspace(*ptr))) ptr++;
  pv->Within_gen_decl = pv->Within_bin_decl = pv->Within_sec_decl = pv->Within_sos_decl = FALSE;
  if((toupper(*ptr) == 'G') || (toupper(*ptr) == 'I'))
    pv->Within_gen_decl = TRUE;
  else
    pv->Within_bin_decl = TRUE;
  return(SEC_INT);
}
	YY_BREAK
case 17:
YY_RULE_SETUP
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pp->lineno = lpt_yylineno;
  pv->Within_gen_decl = pv->Within_bin_decl = pv->Within_sec_decl = pv->Within_sos_decl = FALSE;
  pv->Within_sec_decl = TRUE;
  return(SEC_SEC);
}
	YY_BREAK
case 18:
YY_RULE_SETUP
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;

  pp->lineno = lpt_yylineno;
  pv->Within_gen_decl = pv->Within_bin_decl = pv->Within_sec_decl = pv->Within_sos_decl = FALSE;
  pv->Within_sos_decl = TRUE;
  return(SEC_SOS);
}
	YY_BREAK
case 19:
YY_RULE_SETUP
{
  parse_parm *pp = PARM;
  parse_vars *pv = (parse_vars *) pp->parse_vars;
  char *ptr = (char *)lpt_yytext;

  pp->lineno = lpt_yylineno;
  while ((isspace(*ptr))) ptr++;
  FREE(pv->Last_var);