lp_rlpt.inc

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

	register int lpt_yy_is_jam;
    struct lpt_yyguts_t * lpt_yyg = (struct lpt_yyguts_t*)lpt_yyscanner; /* This var may be unused depending upon options. */
	register char *lpt_yy_cp = lpt_yyg->lpt_yy_c_buf_p;

	register YY_CHAR lpt_yy_c = 1;
	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_is_jam = (lpt_yy_current_state == 173);

	return lpt_yy_is_jam ? 0 : lpt_yy_current_state;
}

    static void lpt_yyunput (int c, register char * lpt_yy_bp , lpt_yyscan_t lpt_yyscanner)
{
	register char *lpt_yy_cp;
    struct lpt_yyguts_t * lpt_yyg = (struct lpt_yyguts_t*)lpt_yyscanner;

    lpt_yy_cp = lpt_yyg->lpt_yy_c_buf_p;

	/* undo effects of setting up lpt_yytext */
	*lpt_yy_cp = lpt_yyg->lpt_yy_hold_char;

	if ( lpt_yy_cp < YY_CURRENT_BUFFER_LVALUE->lpt_yy_ch_buf + 2 )
		{ /* need to shift things up to make room */
		/* +2 for EOB chars. */
		register int number_to_move = lpt_yyg->lpt_yy_n_chars + 2;
		register char *dest = &YY_CURRENT_BUFFER_LVALUE->lpt_yy_ch_buf[
					YY_CURRENT_BUFFER_LVALUE->lpt_yy_buf_size + 2];
		register char *source =
				&YY_CURRENT_BUFFER_LVALUE->lpt_yy_ch_buf[number_to_move];

		while ( source > YY_CURRENT_BUFFER_LVALUE->lpt_yy_ch_buf )
			*--dest = *--source;

		lpt_yy_cp += (int) (dest - source);
		lpt_yy_bp += (int) (dest - source);
		YY_CURRENT_BUFFER_LVALUE->lpt_yy_n_chars =
			lpt_yyg->lpt_yy_n_chars = YY_CURRENT_BUFFER_LVALUE->lpt_yy_buf_size;

		if ( lpt_yy_cp < YY_CURRENT_BUFFER_LVALUE->lpt_yy_ch_buf + 2 )
			YY_FATAL_ERROR( "flex scanner push-back overflow" );
		}

	*--lpt_yy_cp = (char) c;

    if ( c == '\n' ){
        --lpt_yylineno;
    }

	lpt_yyg->lpt_yytext_ptr = lpt_yy_bp;
	lpt_yyg->lpt_yy_hold_char = *lpt_yy_cp;
	lpt_yyg->lpt_yy_c_buf_p = lpt_yy_cp;
}

#ifndef YY_NO_INPUT
#ifdef __cplusplus
    static int lpt_yyinput (lpt_yyscan_t lpt_yyscanner)
#else
    static int input  (lpt_yyscan_t lpt_yyscanner)
#endif

{
	int c;
    struct lpt_yyguts_t * lpt_yyg = (struct lpt_yyguts_t*)lpt_yyscanner;

	*lpt_yyg->lpt_yy_c_buf_p = lpt_yyg->lpt_yy_hold_char;

	if ( *lpt_yyg->lpt_yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
		{
		/* lpt_yy_c_buf_p now points to the character we want to return.
		 * If this occurs *before* the EOB characters, then it's a
		 * valid NUL; if not, then we've hit the end of the buffer.
		 */
		if ( lpt_yyg->lpt_yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->lpt_yy_ch_buf[lpt_yyg->lpt_yy_n_chars] )
			/* This was really a NUL. */
			*lpt_yyg->lpt_yy_c_buf_p = '\0';

		else
			{ /* need more input */
			int offset = lpt_yyg->lpt_yy_c_buf_p - lpt_yyg->lpt_yytext_ptr;
			++lpt_yyg->lpt_yy_c_buf_p;

			switch ( lpt_yy_get_next_buffer( lpt_yyscanner ) )
				{
				case EOB_ACT_LAST_MATCH:
					/* This happens because lpt_yy_g_n_b()
					 * sees that we've accumulated a
					 * token and flags that we need to
					 * try matching the token before
					 * proceeding.  But for input(),
					 * there's no matching to consider.
					 * So convert the EOB_ACT_LAST_MATCH
					 * to EOB_ACT_END_OF_FILE.
					 */

					/* Reset buffer status. */
					lpt_yyrestart(lpt_yyin ,lpt_yyscanner);

					/*FALLTHROUGH*/

				case EOB_ACT_END_OF_FILE:
					{
					if ( lpt_yywrap(lpt_yyscanner ) )
						return EOF;

					if ( ! lpt_yyg->lpt_yy_did_buffer_switch_on_eof )
						YY_NEW_FILE;
#ifdef __cplusplus
					return lpt_yyinput(lpt_yyscanner);
#else
					return input(lpt_yyscanner);
#endif
					}

				case EOB_ACT_CONTINUE_SCAN:
					lpt_yyg->lpt_yy_c_buf_p = lpt_yyg->lpt_yytext_ptr + offset;
					break;
				}
			}
		}

	c = *(unsigned char *) lpt_yyg->lpt_yy_c_buf_p;	/* cast for 8-bit char's */
	*lpt_yyg->lpt_yy_c_buf_p = '\0';	/* preserve lpt_yytext */
	lpt_yyg->lpt_yy_hold_char = *++lpt_yyg->lpt_yy_c_buf_p;

	YY_CURRENT_BUFFER_LVALUE->lpt_yy_at_bol = (c == '\n');
	if ( YY_CURRENT_BUFFER_LVALUE->lpt_yy_at_bol )
		   
    do{ lpt_yylineno++;
        lpt_yycolumn=0;
    }while(0)
;

	return c;
}
#endif	/* ifndef YY_NO_INPUT */

/** Immediately switch to a different input stream.
 * @param input_file A readable stream.
 * @param lpt_yyscanner The scanner object.
 * @note This function does not reset the start condition to @c INITIAL .
 */
    void lpt_yyrestart  (FILE * input_file , lpt_yyscan_t lpt_yyscanner)
{
    struct lpt_yyguts_t * lpt_yyg = (struct lpt_yyguts_t*)lpt_yyscanner;

	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_init_buffer(YY_CURRENT_BUFFER,input_file ,lpt_yyscanner);
	lpt_yy_load_buffer_state(lpt_yyscanner );
}

/** Switch to a different input buffer.
 * @param new_buffer The new input buffer.
 * @param lpt_yyscanner The scanner object.
 */
    void lpt_yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , lpt_yyscan_t lpt_yyscanner)
{
    struct lpt_yyguts_t * lpt_yyg = (struct lpt_yyguts_t*)lpt_yyscanner;

	/* TODO. We should be able to replace this entire function body
	 * with
	 *		lpt_yypop_buffer_state();
	 *		lpt_yypush_buffer_state(new_buffer);
     */
	lpt_yyensure_buffer_stack (lpt_yyscanner);
	if ( YY_CURRENT_BUFFER == new_buffer )
		return;

	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*lpt_yyg->lpt_yy_c_buf_p = lpt_yyg->lpt_yy_hold_char;
		YY_CURRENT_BUFFER_LVALUE->lpt_yy_buf_pos = lpt_yyg->lpt_yy_c_buf_p;
		YY_CURRENT_BUFFER_LVALUE->lpt_yy_n_chars = lpt_yyg->lpt_yy_n_chars;
		}

	YY_CURRENT_BUFFER_LVALUE = new_buffer;
	lpt_yy_load_buffer_state(lpt_yyscanner );

	/* We don't actually know whether we did this switch during
	 * EOF (lpt_yywrap()) processing, but the only time this flag
	 * is looked at is after lpt_yywrap() is called, so it's safe
	 * to go ahead and always set it.
	 */
	lpt_yyg->lpt_yy_did_buffer_switch_on_eof = 1;
}

static void lpt_yy_load_buffer_state  (lpt_yyscan_t lpt_yyscanner)
{
    struct lpt_yyguts_t * lpt_yyg = (struct lpt_yyguts_t*)lpt_yyscanner;
	lpt_yyg->lpt_yy_n_chars = YY_CURRENT_BUFFER_LVALUE->lpt_yy_n_chars;
	lpt_yyg->lpt_yytext_ptr = lpt_yyg->lpt_yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->lpt_yy_buf_pos;
	lpt_yyin = YY_CURRENT_BUFFER_LVALUE->lpt_yy_input_file;
	lpt_yyg->lpt_yy_hold_char = *lpt_yyg->lpt_yy_c_buf_p;
}

/** Allocate and initialize an input buffer state.
 * @param file A readable stream.
 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
 * @param lpt_yyscanner The scanner object.
 * @return the allocated buffer state.
 */
    YY_BUFFER_STATE lpt_yy_create_buffer  (FILE * file, int  size , lpt_yyscan_t lpt_yyscanner)
{
	YY_BUFFER_STATE b;
    
	b = (YY_BUFFER_STATE) lpt_yyalloc(sizeof( struct lpt_yy_buffer_state ) ,lpt_yyscanner );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in lpt_yy_create_buffer()" );

	b->lpt_yy_buf_size = size;

	/* lpt_yy_ch_buf has to be 2 characters longer than the size given because
	 * we need to put in 2 end-of-buffer characters.
	 */
	b->lpt_yy_ch_buf = (char *) lpt_yyalloc(b->lpt_yy_buf_size + 2 ,lpt_yyscanner );
	if ( ! b->lpt_yy_ch_buf )
		YY_FATAL_ERROR( "out of dynamic memory in lpt_yy_create_buffer()" );

	b->lpt_yy_is_our_buffer = 1;

	lpt_yy_init_buffer(b,file ,lpt_yyscanner);

	return b;
}

/** Destroy the buffer.
 * @param b a buffer created with lpt_yy_create_buffer()
 * @param lpt_yyscanner The scanner object.
 */
    void lpt_yy_delete_buffer (YY_BUFFER_STATE  b , lpt_yyscan_t lpt_yyscanner)
{
    struct lpt_yyguts_t * lpt_yyg = (struct lpt_yyguts_t*)lpt_yyscanner;

	if ( ! b )
		return;

	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

	if ( b->lpt_yy_is_our_buffer )
		lpt_yyfree((void *) b->lpt_yy_ch_buf ,lpt_yyscanner );

	lpt_yyfree((void *) b ,lpt_yyscanner );
}

#ifndef __cplusplus
extern int isatty (int );
#endif /* __cplusplus */
    
/* Initializes or reinitializes a buffer.
 * This function is sometimes called more than once on the same buffer,
 * such as during a lpt_yyrestart() or at EOF.
 */
    static void lpt_yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , lpt_yyscan_t lpt_yyscanner)

{
	int oerrno = errno;
    struct lpt_yyguts_t * lpt_yyg = (struct lpt_yyguts_t*)lpt_yyscanner;

	lpt_yy_flush_buffer(b ,lpt_yyscanner);

	b->lpt_yy_input_file = file;
	b->lpt_yy_fill_buffer = 1;

    /* If b is the current buffer, then lpt_yy_init_buffer was _probably_
     * called from lpt_yyrestart() or through lpt_yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->lpt_yy_bs_lineno = 1;
        b->lpt_yy_bs_column = 0;
    }

        b->lpt_yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    
	errno = oerrno;
}

/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
 * @param lpt_yyscanner The scanner object.
 */
    void lpt_yy_flush_buffer (YY_BUFFER_STATE  b , lpt_yyscan_t lpt_yyscanner)
{
    struct lpt_yyguts_t * lpt_yyg = (struct lpt_yyguts_t*)lpt_yyscanner;
	if ( ! b )
		return;

	b->lpt_yy_n_chars = 0;

	/* We always need two end-of-buffer characters.  The first causes
	 * a transition to the end-of-buffer state.  The second causes
	 * a jam in that state.
	 */
	b->lpt_yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
	b->lpt_yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

	b->lpt_yy_buf_pos = &b->lpt_yy_ch_buf[0];

	b->lpt_yy_at_bol = 1;
	b->lpt_yy_buffer_status = YY_BUFFER_NEW;

	if ( b == YY_CURRENT_BUFFER )
		lpt_yy_load_buffer_state(lpt_yyscanner );
}

/** Pushes the new state onto the stack. The new state becomes
 *  the current state. This function will allocate the stack
 *  if necessary.
 *  @param new_buffer The new state.
 *  @param lpt_yyscanner The scanner object.
 */
void lpt_yypush_buffer_state (YY_BUFFER_STATE new_buffer , lpt_yyscan_t lpt_yyscanner)
{
    struct lpt_yyguts_t * lpt_yyg = (struct lpt_yyguts_t*)lpt_yyscanner;
	if (new_buffer == NULL)
		return;

	lpt_yyensure_buffer_stack(lpt_yyscanner);

	/* This block is copied from lpt_yy_switch_to_buffer. */
	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*lpt_yyg->lpt_yy_c_buf_p = lpt_yyg->lpt_yy_hold_char;
		YY_CURRENT_BUFFER_LVALUE->lpt_yy_buf_pos = lpt_yyg->lpt_yy_c_buf_p;
		YY_CURRENT_BUFFER_LVALUE->lpt_yy_n_chars = lpt_yyg->lpt_yy_n_chars;
		}

	/* Only push if top exists. Otherwise, replace top. */
	if (YY_CURRENT_BUFFER)
		lpt_yyg->lpt_yy_buffer_stack_top++;
	YY_CURRENT_BUFFER_LVALUE = new_buffer;

	/* copied from lpt_yy_switch_to_buffer. */
	lpt_yy_load_buffer_state(lpt_yyscanner );
	lpt_yyg->lpt_yy_did_buffer_switch_on_eof = 1;
}

/** Removes and deletes the top of the stack, if present.
 *  The next element becomes the new top.
 *  @param lpt_yyscanner The scanner object.
 */
void lpt_yypop_buffer_state (lpt_yyscan_t lpt_yyscanner)
{
    struct lpt_yyguts_t * lpt_yyg = (struct lpt_yyguts_t*)lpt_yyscanner;
	if (!YY_CURRENT_BUFFER)
		return;

	lpt_yy_delete_buffer(YY_CURRENT_BUFFER ,lpt_yyscanner);
	YY_CURRENT_BUFFER_LVALUE = NULL;
	if (lpt_yyg->lpt_yy_buffer_stack_top > 0)
		--lpt_yyg->lpt_yy_buffer_stack_top;

	if (YY_CURRENT_BUFFER) {
		lpt_yy_load_buffer_state(lpt_yyscanner );
		lpt_yyg->lpt_yy_did_buffer_switch_on_eof = 1;
	}
}

/* Allocates the stack if it does not exist.
 *  Guarantees space for at least one push.
 */
static void lpt_yyensure_buffer_stack (lpt_yyscan_t lpt_yyscanner)
{
	int num_to_alloc;
    struct lpt_yyguts_t * lpt_yyg = (struct lpt_yyguts_t*)lpt_yyscanner;

	if (!lpt_yyg->lpt_yy_buffer_stack) {

		/* First allocation is just for 2 elements, since we don't know if this
		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
		 * immediate realloc on the next call.
         */
		num_to_alloc = 1;
		lpt_yyg->lpt_yy_buffer_stack = (struct lpt_yy_buffer_state**)lpt_yyalloc
								(num_to_alloc * sizeof(struct lpt_yy_buffer_state*)
								, lpt_yyscanner);
		if ( ! lpt_yyg->lpt_yy_buffer_stack )
			YY_FATAL_ERROR( "out of dynamic memory in lpt_yyensure_buffer_stack()" );
								  
		memset(lpt_yyg->lpt_yy_buffer_stack, 0, num_to_alloc * sizeof(struct lpt_yy_buffer_state*));
				
		lpt_yyg->lpt_yy_buffer_stack_max = num_to_alloc;
		lpt_yyg->lpt_yy_b