lex.yy.c

生成C++的词法/语法分析的Flex语法分析器

#define YY_USE_PROTOS
#endif
#ifndef YY_USE_CLASS
#define YY_USE_CLASS
#endif
#else	/* ! __cplusplus */
#ifdef __STDC__
#ifdef __GNUC__
#else
#endif	/* __GNUC__ */
#ifndef YY_USE_PROTOS
#define YY_USE_PROTOS
#endif
#endif	/* __STDC__ */
#endif	/* ! __cplusplus */
/*********************************************/
/* COMPILER DEPENDENT   MACROS               */
/*********************************************/
/* use prototypes in function declarations */
#ifndef YY_PROTO
#ifdef YY_USE_PROTOS
#define YY_PROTO(proto) proto
#else
#define YY_PROTO(proto) ()
#endif
#endif
#include <stdio.h>




/* % here is the declaration from section1 %header{  */ 
#line 86 "scan.l"
#line 86 "scan.l"
#line 561 "scan.l"
# line 54 "/u/icdc/rdt/tools/lib/flexskel.h"



#ifndef YY_lex_TEXT
#define YY_lex_TEXT yytext
#endif
#ifndef YY_lex_LENG
#define YY_lex_LENG yyleng
#endif
#ifndef YY_lex_IN
#define YY_lex_IN yyin
#endif
#ifndef YY_lex_OUT
#define YY_lex_OUT yyout
#endif


#ifndef YY_USE_CLASS
typedef struct yy_buffer_state *YY_BUFFER_STATE;

extern void yyrestart YY_PROTO(( FILE *input_file ));
extern void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
extern void yy_load_buffer_state YY_PROTO(( void ));
extern YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
extern void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
extern void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
#define yy_new_buffer yy_create_buffer
extern YY_CHAR *YY_lex_TEXT;
extern int YY_lex_LENG;
extern FILE *YY_lex_IN, *YY_lex_OUT;

#else


#ifndef YY_lex_ECHO
#define YY_lex_ECHO yy_echo
#endif
#ifdef YY_lex_ECHO_PURE
#define YY_lex_ECHO_NOCODE
#endif
#ifndef YY_lex_ECHO_CODE
#define YY_lex_ECHO_CODE fwrite( (char *) YY_lex_TEXT, YY_lex_LENG, 1, YY_lex_OUT );
#endif
#ifndef YY_lex_INPUT
#define YY_lex_INPUT yy_input
#endif
#ifdef YY_lex_INPUT_PURE
#define YY_lex_INPUT_NOCODE
#endif
#ifndef YY_lex_INPUT_CODE
#define YY_lex_INPUT_CODE return result= fread(  buffer, 1,max_size,YY_lex_IN );
#endif
#ifdef YY_lex_FATAL_ERROR_PURE
#define YY_lex_FATAL_ERRO_NOCODE
#endif
#ifndef YY_lex_FATAL_ERROR
#define YY_lex_FATAL_ERROR yy_fatal_error
#endif
#ifndef YY_lex_FATAL_ERROR_CODE
#define YY_lex_FATAL_ERROR_CODE fputs( msg, stderr );putc( '\n', stderr );exit( 1 );
#endif
#ifndef YY_lex_WRAP
#define YY_lex_WRAP yy_wrap
#endif
#ifdef YY_lex_WRAP_PURE
#define YY_lex_WRAP_NOCODE
#endif
#ifndef YY_lex_WRAP_CODE
#define YY_lex_WRAP_CODE return 1;
#endif


#ifndef YY_lex_INHERIT
#define YY_lex_INHERIT
#endif
#ifndef YY_lex_LEXRETURN
#define YY_lex_LEXRETURN int
#endif
#ifndef YY_lex_LEX
#define YY_lex_LEX yylex
#endif
#ifndef YY_lex_LEXPARAM
#define YY_lex_LEXPARAM void
#endif
#ifndef YY_lex_MEMBERS
#define YY_lex_MEMBERS 
#endif
#ifndef YY_lex_CONSTRUCTOR_PARAM
#define YY_lex_CONSTRUCTOR_PARAM
#endif
#ifndef YY_lex_CONSTRUCTOR_CODE
#define YY_lex_CONSTRUCTOR_CODE
#endif
#ifndef YY_lex_CONSTRUCTOR_INIT
#define YY_lex_CONSTRUCTOR_INIT
#endif
typedef struct yy_buffer_state *YY_BUFFER_STATE;

class lex YY_lex_INHERIT
{
 private:/* data */
 YY_CHAR *yy_c_buf_p;
 YY_CHAR yy_hold_char;
 int yy_n_chars;
 int yy_init;
 int yy_start;
 int yy_did_buffer_switch_on_eof;
 private: /* functions */
 void yy_initialize();
 int input();
 int yy_get_next_buffer();
 void yyunput( YY_CHAR c, YY_CHAR *buf_ptr );
 /* use long instead of yy_state_type because it is undef */
 long yy_get_previous_state_ ( void );
 long yy_try_NUL_trans_  ( long current_state_ );
 protected:/* non virtual */
 YY_BUFFER_STATE yy_current_buffer;
 void yyrestart ( FILE *input_file );
 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer );
 void yy_load_buffer_state( void );
 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size );
 YY_BUFFER_STATE yy_new_buffer( FILE *file, int size )
        {return yy_create_buffer(file,size);}
 void yy_delete_buffer( YY_BUFFER_STATE b );
 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file );
 protected: /* virtual */
 virtual void YY_lex_ECHO()
#ifdef YY_lex_ECHO_PURE
  =0
#endif
  ;
 virtual int  YY_lex_INPUT(char  *buf,int &result,int max_size)
#ifdef YY_lex_INPUT_PURE
  =0
#endif
  ;
 virtual void  YY_lex_FATAL_ERROR(char *msg)
#ifdef YY_lex_FATAL_ERROR_PURE
  =0
#endif
  ;
 virtual int  YY_lex_WRAP()
#ifdef YY_lex_WRAP_PURE
  =0
#endif
  ;
 public:
 YY_CHAR *YY_lex_TEXT;
 int YY_lex_LENG;
 FILE *YY_lex_IN, *YY_lex_OUT;
 YY_lex_LEXRETURN YY_lex_LEX ( YY_lex_LEXPARAM);
 lex(YY_lex_CONSTRUCTOR_PARAM) ;
 public: /* added members */
 YY_lex_MEMBERS 
};
#endif



/* declaration of externs for public use of yylex scanner */

/* % here is the declaration from section2 %header{ */ 
# line 182 "/u/icdc/rdt/tools/lib/flexskel.cc"

#define yy___text YY_lex_TEXT
#define yy___leng YY_lex_LENG
#define yy___in YY_lex_IN
#define yy___out YY_lex_OUT


#ifdef YY_USE_CLASS

#define yy___echo YY_lex_ECHO
#define yy___input YY_lex_INPUT
#define yy___fatal_error YY_lex_FATAL_ERROR
#define yy___wrap YY_lex_WRAP

#endif

/* done after the current pattern has been matched and before the
 * corresponding action - sets up yy___text
 */
#define YY_DO_BEFORE_ACTION \
	yy___text = yy_bp; \
/* % code to fiddle yy___text and yy___leng for yymore() goes here */ \
	yy___leng = yy_cp - yy_bp; \
	yy_hold_char = *yy_cp; \
	*yy_cp = '\0'; \
	yy_c_buf_p = yy_cp;

#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2

/* return all but the first 'n' matched characters back to the input stream */
#define yyless(n) \
	do \
		{ \
		/* undo effects of setting up yy___text */ \
		*yy_cp = yy_hold_char; \
		yy_c_buf_p = yy_cp = yy_bp + n; \
		YY_DO_BEFORE_ACTION; /* set up yy___text again */ \
		} \
	while ( 0 )

#define unput(c) yyunput( c, yy___text )



struct yy_buffer_state
    {
    FILE *yy_input_file;

    YY_CHAR *yy_ch_buf;		/* input buffer */
    YY_CHAR *yy_buf_pos;	/* current position in input buffer */

    /* size of input buffer in bytes, not including room for EOB characters*/
    int yy_buf_size;	

    /* number of characters read into yy_ch_buf, not including EOB characters */
    int yy_n_chars;

    int yy_eof_status;		/* whether we've seen an EOF on this buffer */
#define EOF_NOT_SEEN 0
    /* "pending" happens when the EOF has been seen but there's still
     * some text process
     */
#define EOF_PENDING 1
#define EOF_DONE 2
    };

/* we provide macros for accessing buffer states in case in the
 * future we want to put the buffer states in a more general
 * "scanner state"
 */

#ifndef YY_USE_CLASS
#define YY_CURRENT_BUFFER yy_current_buffer
static YY_BUFFER_STATE yy_current_buffer;
/* yy_hold_char holds the character lost when yy___text is formed */
static YY_CHAR yy_hold_char;

static int yy_n_chars;		/* number of characters read into yy_ch_buf */

/* GLOBAL */
YY_CHAR *yy___text;
int yy___leng;

FILE *yy___in = (FILE *) 0, *yy___out = (FILE *) 0;

#ifdef __cplusplus
static int yyinput YY_PROTO(( void ));
#else
static int input YY_PROTO(( void ));
#endif
/* these variables are all declared out here so that section 3 code can
 * manipulate them
 */
/* points to current character in buffer */
static YY_CHAR *yy_c_buf_p = (YY_CHAR *) 0;
static int yy_init = 1;		/* whether we need to initialize */
static int yy_start = 0;	/* start state number */

/* flag which is used to allow yywrap()'s to do buffer switches