lestes » lang » cplus » lex

concat_guts.yy.cc File Reference

Go to the source code of this file.

Classes

struct  yy_buffer_state
struct  yy_trans_info

Defines

#define YY_INT_ALIGNED   short int
#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION   2
#define YY_FLEX_MINOR_VERSION   5
#define YY_FLEX_SUBMINOR_VERSION   33
#define FLEX_BETA
#define INT8_MIN   (-128)
#define INT16_MIN   (-32767-1)
#define INT32_MIN   (-2147483647-1)
#define INT8_MAX   (127)
#define INT16_MAX   (32767)
#define INT32_MAX   (2147483647)
#define UINT8_MAX   (255U)
#define UINT16_MAX   (65535U)
#define UINT32_MAX   (4294967295U)
#define yyconst
#define YY_NULL   0
#define YY_SC_TO_UI(c)   ((unsigned int) (unsigned char) c)
#define BEGIN   (yy_start) = 1 + 2 *
#define YY_START   (((yy_start) - 1) / 2)
#define YYSTATE   YY_START
#define YY_STATE_EOF(state)   (YY_END_OF_BUFFER + state + 1)
#define YY_NEW_FILE   yyrestart(yyin )
#define YY_END_OF_BUFFER_CHAR   0
#define YY_BUF_SIZE   16384
#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
#define EOB_ACT_CONTINUE_SCAN   0
#define EOB_ACT_END_OF_FILE   1
#define EOB_ACT_LAST_MATCH   2
#define YY_LESS_LINENO(n)
#define yyless(n)
#define unput(c)   yyunput( c, (yytext_ptr) )
#define YY_BUFFER_NEW   0
#define YY_BUFFER_NORMAL   1
#define YY_BUFFER_EOF_PENDING   2
#define YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]
#define YY_FLUSH_BUFFER   yy_flush_buffer(YY_CURRENT_BUFFER )
#define yy_new_buffer   yy_create_buffer
#define yy_set_interactive(is_interactive)
#define yy_set_bol(at_bol)
#define YY_AT_BOL()   (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
#define yywrap(n)   1
#define YY_SKIP_YYWRAP
#define yytext_ptr   yytext
#define YY_DO_BEFORE_ACTION
#define YY_NUM_RULES   141
#define YY_END_OF_BUFFER   142
#define REJECT   reject_used_but_not_detected
#define yymore()   yymore_used_but_not_detected
#define YY_MORE_ADJ   0
#define YY_RESTORE_YY_MORE_OFFSET
#define ECHO   lassert2(false, "ECHO should not be used.")
 Avoids implicit flex rules.
#define yyterminate()   return pp_token::create(a_location,pp_token::TOK_FILE_END)
 called upon encountering real EOF, which should not happen, formal definition
#define YY_INPUT(buf, result, max_size)
 Defines flex input function.
#define YY_DECL   ptr<pp_token> concat_parse(const ptr<source_location> &a_location, const ptr<token_value> &a_value)
 Defines prototype for flex parser function.
#define YY_NO_INPUT   1
#define INITIAL   0
#define YY_EXTRA_TYPE   void *
#define YY_READ_BUF_SIZE   8192
#define YY_START_STACK_INCR   25
#define YY_FATAL_ERROR(msg)   yy_fatal_error( msg )
#define YY_BREAK   break;
#define YY_RULE_SETUP   YY_USER_ACTION
#define YY_EXIT_FAILURE   2
#define yyless(n)
#define YYTABLES_NAME   "yytables"

Typedefs

typedef signed char flex_int8_t
typedef short int flex_int16_t
typedef int flex_int32_t
typedef unsigned char flex_uint8_t
typedef unsigned short int flex_uint16_t
typedef unsigned int flex_uint32_t
typedef yy_buffer_state * YY_BUFFER_STATE
typedef unsigned int yy_size_t
typedef unsigned char YY_CHAR
typedef int yy_state_type

Functions

void yyrestart (FILE *input_file)
void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer)
YY_BUFFER_STATE yy_create_buffer (FILE *file, int size)
void yy_delete_buffer (YY_BUFFER_STATE b)
void yy_flush_buffer (YY_BUFFER_STATE b)
void yypush_buffer_state (YY_BUFFER_STATE new_buffer)
void yypop_buffer_state (void)
static void yyensure_buffer_stack (void)
static void yy_load_buffer_state (void)
static void yy_init_buffer (YY_BUFFER_STATE b, FILE *file)
YY_BUFFER_STATE yy_scan_buffer (char *base, yy_size_t size)
YY_BUFFER_STATE yy_scan_string (char *yy_str)
YY_BUFFER_STATE yy_scan_bytes (char *bytes, int len)
void * yyalloc (yy_size_t)
void * yyrealloc (void *, yy_size_t)
void yyfree (void *)
static yy_state_type yy_get_previous_state (void)
static yy_state_type yy_try_NUL_trans (yy_state_type current_state)
static int yy_get_next_buffer (void)
static void yy_fatal_error (char msg[])
ptr< pp_token > concat_parse (const ptr< source_location > &a_location, const ptr< token_value > &a_value)
static int yy_init_globals (void)
static void yy_fatal_error (char *msg)
int yyget_lineno (void)
FILE * yyget_in (void)
FILE * yyget_out (void)
int yyget_leng (void)
char * yyget_text (void)
void yyset_lineno (int line_number)
void yyset_in (FILE *in_str)
void yyset_out (FILE *out_str)
int yyget_debug (void)
void yyset_debug (int bdebug)
int yylex_destroy (void)

Variables

int yyleng
FILE * yyin
FILE * yyout
static size_t yy_buffer_stack_top = 0
static size_t yy_buffer_stack_max = 0
static YY_BUFFER_STATE * yy_buffer_stack = 0
static char yy_hold_char
static int yy_n_chars
int yyleng
static char * yy_c_buf_p = (char *) 0
static int yy_init = 0
static int yy_start = 0
static int yy_did_buffer_switch_on_eof
FILE * yyin = (FILE *) 0
FILE * yyout = (FILE *) 0
int yylineno
int yylineno = 1
char * yytext
static flex_int16_t yy_accept [669]
static flex_int32_t yy_ec [256]
static flex_int32_t yy_meta [96]
static flex_int16_t yy_base [678]
static flex_int16_t yy_def [678]
static flex_int16_t yy_nxt [2757]
static flex_int16_t yy_chk [2757]
static yy_state_type yy_last_accepting_state
static char * yy_last_accepting_cpos
int yy_flex_debug
int yy_flex_debug = 0
char * yytext

Define Documentation

#define BEGIN   (yy_start) = 1 + 2 *

Definition at line 112 of file concat_guts.yy.cc.

Referenced by lestes::lang::cplus::lex::preprocessor::classify_number(), lestes::lang::cplus::lex::ucn_token_buffer::extract_bad_literal(), lestes::lang::cplus::lex::ucn_token_buffer::extract_invalid_ucn(), lestes::lang::cplus::lex::ucn_token_buffer::extract_simple_ucn(), lestes::lang::cplus::lex::ucn_token_buffer::extract_ucn_literal(), lexer_parse(), lestes::lang::cplus::lex::macro_argument_test(), lestes::lang::cplus::lex::macro_body_test(), lestes::lang::cplus::lex::macro_head_test(), and lestes::lang::cplus::lex::string_translator::translate().

#define ECHO   lassert2(false, "ECHO should not be used.")

Avoids implicit flex rules.

Definition at line 1316 of file concat_guts.yy.cc.

Referenced by concat_parse(), and lexer_parse().

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 147 of file concat_guts.yy.cc.

Referenced by concat_parse(), and lexer_parse().

#define EOB_ACT_END_OF_FILE   1

Definition at line 148 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), and yy_get_next_buffer().

#define EOB_ACT_LAST_MATCH   2

Definition at line 149 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), and yy_get_next_buffer().

#define FLEX_BETA

Definition at line 13 of file concat_guts.yy.cc.

#define FLEX_SCANNER

Definition at line 8 of file concat_guts.yy.cc.

#define INITIAL   0

Definition at line 1357 of file concat_guts.yy.cc.

Referenced by concat_parse(), and lexer_parse().

#define INT16_MAX   (32767)

Definition at line 61 of file concat_guts.yy.cc.

#define INT16_MIN   (-32767-1)

Definition at line 52 of file concat_guts.yy.cc.

#define INT32_MAX   (2147483647)

Definition at line 64 of file concat_guts.yy.cc.

#define INT32_MIN   (-2147483647-1)

Definition at line 55 of file concat_guts.yy.cc.

#define INT8_MAX   (127)

Definition at line 58 of file concat_guts.yy.cc.

#define INT8_MIN   (-128)

Definition at line 49 of file concat_guts.yy.cc.

#define REJECT   reject_used_but_not_detected

Definition at line 1270 of file concat_guts.yy.cc.

#define UINT16_MAX   (65535U)

Definition at line 70 of file concat_guts.yy.cc.

#define UINT32_MAX   (4294967295U)

Definition at line 73 of file concat_guts.yy.cc.

#define UINT8_MAX   (255U)

Definition at line 67 of file concat_guts.yy.cc.

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

Definition at line 167 of file concat_guts.yy.cc.

 
#define YY_AT_BOL (  )     (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 323 of file concat_guts.yy.cc.

#define YY_BREAK   break;

Definition at line 1492 of file concat_guts.yy.cc.

Referenced by concat_parse(), and lexer_parse().

#define YY_BUF_SIZE   16384

Definition at line 131 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), and yyrestart().

#define YY_BUFFER_EOF_PENDING   2

Definition at line 239 of file concat_guts.yy.cc.

Referenced by yy_get_next_buffer().

#define YY_BUFFER_NEW   0

Definition at line 227 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), and yy_flush_buffer().

#define YY_BUFFER_NORMAL   1

Definition at line 228 of file concat_guts.yy.cc.

Referenced by concat_parse(), and lexer_parse().

#define YY_CURRENT_BUFFER

Value:

( (yy_buffer_stack) \
                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
                          : NULL)

Definition at line 255 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), yy_delete_buffer(), yy_flush_buffer(), yy_get_next_buffer(), yy_init_buffer(), yy_switch_to_buffer(), yylex_destroy(), yypop_buffer_state(), yypush_buffer_state(), and yyrestart().

#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]

Definition at line 262 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), yy_delete_buffer(), yy_get_next_buffer(), yy_load_buffer_state(), yy_switch_to_buffer(), yylex_destroy(), yypop_buffer_state(), yypush_buffer_state(), and yyrestart().

#define YY_DECL   ptr<pp_token> concat_parse(const ptr<source_location> &a_location, const ptr<token_value> &a_value)

Defines prototype for flex parser function.

Definition at line 1332 of file concat_guts.yy.cc.

#define YY_DO_BEFORE_ACTION

Value:

(yytext_ptr) = yy_bp; \
        yyleng = (size_t) (yy_cp - yy_bp); \
        (yy_hold_char) = *yy_cp; \
        *yy_cp = '\0'; \
        (yy_c_buf_p) = yy_cp;

Definition at line 351 of file concat_guts.yy.cc.

Referenced by concat_parse(), and lexer_parse().

#define YY_END_OF_BUFFER   142

Definition at line 359 of file concat_guts.yy.cc.

Referenced by concat_parse(), and lexer_parse().

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 127 of file concat_guts.yy.cc.

Referenced by yy_flush_buffer().

#define YY_EXIT_FAILURE   2

Definition at line 3113 of file concat_guts.yy.cc.

Referenced by yy_fatal_error().

#define YY_EXTRA_TYPE   void *

Definition at line 1368 of file concat_guts.yy.cc.

#define YY_FATAL_ERROR ( msg   )     yy_fatal_error( msg )

Definition at line 1467 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), yy_create_buffer(), and yy_get_next_buffer().

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 9 of file concat_guts.yy.cc.

#define YY_FLEX_MINOR_VERSION   5

Definition at line 10 of file concat_guts.yy.cc.

#define YY_FLEX_SUBMINOR_VERSION   33

Definition at line 11 of file concat_guts.yy.cc.

#define YY_FLUSH_BUFFER   yy_flush_buffer(YY_CURRENT_BUFFER )

Definition at line 291 of file concat_guts.yy.cc.

#define YY_INPUT ( buf,
result,
max_size   ) 

Value:

{ \
        result = concat::instance()->yy_input(buf,max_size); \
}
Defines flex input function.

Definition at line 1326 of file concat_guts.yy.cc.

#define YY_INT_ALIGNED   short int

Definition at line 4 of file concat_guts.yy.cc.

#define YY_LESS_LINENO ( n   ) 

Definition at line 151 of file concat_guts.yy.cc.

#define YY_MORE_ADJ   0

Definition at line 1272 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), yy_get_next_buffer(), and yy_get_previous_state().

#define yy_new_buffer   yy_create_buffer

Definition at line 301 of file concat_guts.yy.cc.

#define YY_NEW_FILE   yyrestart(yyin )

Definition at line 125 of file concat_guts.yy.cc.

Referenced by concat_parse(), and lexer_parse().

#define YY_NO_INPUT   1

Definition at line 1342 of file concat_guts.yy.cc.

#define YY_NULL   0

Definition at line 99 of file concat_guts.yy.cc.

Referenced by lestes::lang::cplus::lex::concat::yy_input().

#define YY_NUM_RULES   141

Definition at line 358 of file concat_guts.yy.cc.

#define YY_READ_BUF_SIZE   8192

Definition at line 1405 of file concat_guts.yy.cc.

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 1273 of file concat_guts.yy.cc.

Referenced by concat_parse(), and lexer_parse().

#define YY_RULE_SETUP   YY_USER_ACTION

Definition at line 1495 of file concat_guts.yy.cc.

Referenced by concat_parse(), and lexer_parse().

#define YY_SC_TO_UI ( c   )     ((unsigned int) (unsigned char) c)

Definition at line 106 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), and yy_get_previous_state().

#define yy_set_bol ( at_bol   ) 

Value:

{ \
        if ( ! YY_CURRENT_BUFFER ){\
        yyensure_buffer_stack (); \
                YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer(yyin,YY_BUF_SIZE ); \
        } \
        YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
        }

Definition at line 313 of file concat_guts.yy.cc.

#define yy_set_interactive ( is_interactive   ) 

Value:

{ \
        if ( ! YY_CURRENT_BUFFER ){ \
        yyensure_buffer_stack (); \
                YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer(yyin,YY_BUF_SIZE ); \
        } \
        YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
        }

Definition at line 303 of file concat_guts.yy.cc.

#define YY_SKIP_YYWRAP

Definition at line 328 of file concat_guts.yy.cc.

#define YY_START   (((yy_start) - 1) / 2)

Definition at line 118 of file concat_guts.yy.cc.

Referenced by concat_parse(), and lexer_parse().

#define YY_START_STACK_INCR   25

Definition at line 1462 of file concat_guts.yy.cc.

#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

Definition at line 136 of file concat_guts.yy.cc.

#define YY_STATE_EOF ( state   )     (YY_END_OF_BUFFER + state + 1)

Definition at line 122 of file concat_guts.yy.cc.

Referenced by concat_parse(), and lexer_parse().

#define yyconst

Definition at line 95 of file concat_guts.yy.cc.

#define yyless ( n   ) 

Value:

do \
                { \
                /* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
                yytext[yyleng] = (yy_hold_char); \
                (yy_c_buf_p) = yytext + yyless_macro_arg; \
                (yy_hold_char) = *(yy_c_buf_p); \
                *(yy_c_buf_p) = '\0'; \
                yyleng = yyless_macro_arg; \
                } \
        while ( 0 )

Definition at line 3126 of file concat_guts.yy.cc.

#define yyless ( n   ) 

Value:

do \
                { \
                /* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
                *yy_cp = (yy_hold_char); \
                YY_RESTORE_YY_MORE_OFFSET \
                (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
                } \
        while ( 0 )

Definition at line 3126 of file concat_guts.yy.cc.

Referenced by lexer_parse().

 
#define yymore (  )     yymore_used_but_not_detected

Definition at line 1271 of file concat_guts.yy.cc.

#define YYSTATE   YY_START

Definition at line 119 of file concat_guts.yy.cc.

#define YYTABLES_NAME   "yytables"

Definition at line 3316 of file concat_guts.yy.cc.

 
#define yyterminate (  )     return pp_token::create(a_location,pp_token::TOK_FILE_END)

called upon encountering real EOF, which should not happen, formal definition

Definition at line 1323 of file concat_guts.yy.cc.

Referenced by concat_parse(), and lexer_parse().

#define yytext_ptr   yytext

Definition at line 341 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), yy_get_next_buffer(), yy_get_previous_state(), and yy_load_buffer_state().

#define yywrap ( n   )     1

Definition at line 327 of file concat_guts.yy.cc.

Referenced by concat_parse(), and lexer_parse().

Typedef Documentation

typedef short int flex_int16_t

Definition at line 40 of file concat_guts.yy.cc.

typedef int flex_int32_t

Definition at line 41 of file concat_guts.yy.cc.

typedef signed char flex_int8_t

Definition at line 39 of file concat_guts.yy.cc.

typedef unsigned short int flex_uint16_t

Definition at line 43 of file concat_guts.yy.cc.

typedef unsigned int flex_uint32_t

Definition at line 44 of file concat_guts.yy.cc.

typedef unsigned char flex_uint8_t

Definition at line 42 of file concat_guts.yy.cc.

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 140 of file concat_guts.yy.cc.

typedef unsigned char YY_CHAR

Definition at line 330 of file concat_guts.yy.cc.

typedef unsigned int yy_size_t

Definition at line 176 of file concat_guts.yy.cc.

typedef int yy_state_type

Definition at line 334 of file concat_guts.yy.cc.

Function Documentation

ptr< pp_token > concat_parse ( const ptr< source_location > &  a_location,
const ptr< token_value > &  a_value 
)

The main scanner function which does all the work.

Definition at line 1500 of file concat_guts.yy.cc.

References ECHO, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, INITIAL, TOK_AMP, TOK_AMP_AMP, TOK_AMP_EQ, TOK_ASM, TOK_AUTO, TOK_BOOL, TOK_BREAK, TOK_CASE, TOK_CATCH, TOK_CHAR, TOK_CLASS, TOK_COLON, TOK_COLON_COLON, TOK_COMMA, TOK_CONST, TOK_CONST_CAST, TOK_CONTINUE, TOK_DEFAULT, TOK_DELETE, TOK_DO, TOK_DOT, TOK_DOT_DOT_DOT, TOK_DOT_STAR, TOK_DOUBLE, TOK_DYNAMIC_CAST, TOK_ELSE, TOK_ENUM, TOK_EQ, TOK_EQ_EQ, TOK_EXPLICIT, TOK_EXPORT, TOK_EXTERN, TOK_FLOAT, TOK_FOR, TOK_FRIEND, TOK_GOTO, TOK_GT, TOK_GT_EQ, TOK_GT_GT, TOK_GT_GT_EQ, TOK_HAT, TOK_HAT_EQ, TOK_IDENT, TOK_IF, TOK_INLINE, TOK_INT, TOK_LEFT_BRACE, TOK_LEFT_BRACKET, TOK_LEFT_PAR, TOK_LONG, TOK_LT, TOK_LT_EQ, TOK_LT_LT, TOK_LT_LT_EQ, TOK_MINUS, TOK_MINUS_EQ, TOK_MINUS_GT, TOK_MINUS_GT_STAR, TOK_MINUS_MINUS, TOK_MUTABLE, TOK_NAMESPACE, TOK_NEW, TOK_OPERATOR, TOK_PERCENT, TOK_PERCENT_EQ, TOK_PLUS, TOK_PLUS_EQ, TOK_PLUS_PLUS, TOK_PRIVATE, TOK_PROTECTED, TOK_PUBLIC, TOK_QMARK, TOK_REGISTER, TOK_REINTERPRET_CAST, TOK_RETURN, TOK_RIGHT_BRACE, TOK_RIGHT_BRACKET, TOK_RIGHT_PAR, TOK_SEMICOLON, TOK_SHORT, TOK_SIGNED, TOK_SIZEOF, TOK_SLASH, TOK_SLASH_EQ, TOK_STAR, TOK_STAR_EQ, TOK_STATIC, TOK_STATIC_CAST, TOK_STRUCT, TOK_SWITCH, TOK_TEMPLATE, TOK_THIS, TOK_THROW, TOK_TILDE, TOK_TRY, TOK_TYPEDEF, TOK_TYPEID, TOK_TYPENAME, TOK_UNION, TOK_UNSIGNED, TOK_USING, TOK_VBAR, TOK_VBAR_EQ, TOK_VBAR_VBAR, TOK_VIRTUAL, TOK_VOID, TOK_VOLATILE, TOK_WHILE, u, YY_BREAK, YY_BUF_SIZE, YY_BUFFER_NEW, YY_BUFFER_NORMAL, yy_c_buf_p, yy_create_buffer(), YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, YY_DO_BEFORE_ACTION, YY_END_OF_BUFFER, YY_FATAL_ERROR, yy_get_next_buffer(), yy_get_previous_state(), yy_hold_char, yy_init, yy_load_buffer_state(), YY_MORE_ADJ, yy_n_chars, YY_NEW_FILE, YY_RESTORE_YY_MORE_OFFSET, YY_RULE_SETUP, YY_SC_TO_UI, YY_START, yy_start, YY_STATE_EOF, yy_try_NUL_trans(), yyensure_buffer_stack(), yyin, yyout, yyterminate, yytext_ptr, and yywrap.

Referenced by lestes::lang::cplus::lex::concat::process().

01501 {
01502         register yy_state_type yy_current_state;
01503         register char *yy_cp, *yy_bp;
01504         register int yy_act;
01505     
01506         if ( !(yy_init) )
01507                 {
01508                 (yy_init) = 1;
01509 
01510 #ifdef YY_USER_INIT
01511                 YY_USER_INIT;
01512 #endif
01513 
01514                 if ( ! (yy_start) )
01515                         (yy_start) = 1; /* first start state */
01516 
01517                 if ( ! yyin )
01518                         yyin = stdin;
01519 
01520                 if ( ! yyout )
01521                         yyout = stdout;
01522 
01523                 if ( ! YY_CURRENT_BUFFER ) {
01524                         yyensure_buffer_stack ();
01525                         YY_CURRENT_BUFFER_LVALUE =
01526                                 yy_create_buffer(yyin,YY_BUF_SIZE );
01527                 }
01528 
01529                 yy_load_buffer_state( );
01530                 }
01531 
01532         while ( 1 )             /* loops until end-of-file is reached */
01533                 {
01534                 yy_cp = (yy_c_buf_p);
01535 
01536                 /* Support of yytext. */
01537                 *yy_cp = (yy_hold_char);
01538 
01539                 /* yy_bp points to the position in yy_ch_buf of the start of
01540                  * the current run.
01541                  */
01542                 yy_bp = yy_cp;
01543 
01544                 yy_current_state = (yy_start);
01545 yy_match:
01546                 do
01547                         {
01548                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
01549                         if ( yy_accept[yy_current_state] )
01550                                 {
01551                                 (yy_last_accepting_state) = yy_current_state;
01552                                 (yy_last_accepting_cpos) = yy_cp;
01553                                 }
01554                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01555                                 {
01556                                 yy_current_state = (int) yy_def[yy_current_state];
01557                                 if ( yy_current_state >= 669 )
01558                                         yy_c = yy_meta[(unsigned int) yy_c];
01559                                 }
01560                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01561                         ++yy_cp;
01562                         }
01563                 while ( yy_current_state != 668 );
01564                 yy_cp = (yy_last_accepting_cpos);
01565                 yy_current_state = (yy_last_accepting_state);
01566 
01567 yy_find_action:
01568                 yy_act = yy_accept[yy_current_state];
01569 
01570                 YY_DO_BEFORE_ACTION;
01571 
01572 do_action:      /* This label is used only to access EOF actions. */
01573 
01574                 switch ( yy_act )
01575         { /* beginning of action switch */
01576                         case 0: /* must back up */
01577                         /* undo the effects of YY_DO_BEFORE_ACTION */
01578                         *yy_cp = (yy_hold_char);
01579                         yy_cp = (yy_last_accepting_cpos);
01580                         yy_current_state = (yy_last_accepting_state);
01581                         goto yy_find_action;
01582 
01583 case 1:
01584 YY_RULE_SETUP
01585 {
01586         return pp_token::create(a_location,pp_token::TOK_LEFT_BRACKET);
01587 }
01588         YY_BREAK
01589 case 2:
01590 YY_RULE_SETUP
01591 {
01592         return pp_token::create_alternative(a_location,pp_token::TOK_LEFT_BRACKET);
01593 }
01594         YY_BREAK
01595 case 3:
01596 YY_RULE_SETUP
01597 {
01598         return pp_token::create(a_location,pp_token::TOK_RIGHT_BRACKET);
01599 }
01600         YY_BREAK
01601 case 4:
01602 YY_RULE_SETUP
01603 {
01604         return pp_token::create_alternative(a_location,pp_token::TOK_RIGHT_BRACKET);
01605 }
01606         YY_BREAK
01607 case 5:
01608 YY_RULE_SETUP
01609 {
01610         return pp_token::create(a_location,pp_token::TOK_LEFT_BRACE);
01611 }
01612         YY_BREAK
01613 case 6:
01614 YY_RULE_SETUP
01615 {
01616         return pp_token::create_alternative(a_location,pp_token::TOK_LEFT_BRACE);
01617 }
01618         YY_BREAK
01619 case 7:
01620 YY_RULE_SETUP
01621 {
01622         return pp_token::create(a_location,pp_token::TOK_RIGHT_BRACE);
01623 }
01624         YY_BREAK
01625 case 8:
01626 YY_RULE_SETUP
01627 {
01628         return pp_token::create_alternative(a_location,pp_token::TOK_RIGHT_BRACE);
01629 }
01630         YY_BREAK
01631 case 9:
01632 YY_RULE_SETUP
01633 {
01634         return pp_token::create(a_location,pp_token::TOK_HASH);
01635 }
01636         YY_BREAK
01637 case 10:
01638 YY_RULE_SETUP
01639 {
01640         return pp_token::create_alternative(a_location,pp_token::TOK_HASH);
01641 }
01642         YY_BREAK
01643 case 11:
01644 YY_RULE_SETUP
01645 {
01646         return pp_token::create(a_location,pp_token::TOK_HASH_HASH);
01647 }
01648         YY_BREAK
01649 case 12:
01650 YY_RULE_SETUP
01651 {
01652         return pp_token::create_alternative(a_location,pp_token::TOK_HASH_HASH);
01653 }
01654         YY_BREAK
01655 case 13:
01656 YY_RULE_SETUP
01657 {
01658         return pp_token::create(a_location,pp_token::TOK_LEFT_PAR);
01659 }
01660         YY_BREAK
01661 case 14:
01662 YY_RULE_SETUP
01663 {
01664         return pp_token::create(a_location,pp_token::TOK_RIGHT_PAR);
01665 }
01666         YY_BREAK
01667 case 15:
01668 YY_RULE_SETUP
01669 {
01670         return pp_token::create(a_location,pp_token::TOK_SEMICOLON);
01671 }
01672         YY_BREAK
01673 case 16:
01674 YY_RULE_SETUP
01675 {
01676         return pp_token::create(a_location,pp_token::TOK_COLON);
01677 }
01678         YY_BREAK
01679 case 17:
01680 YY_RULE_SETUP
01681 {
01682         return pp_token::create(a_location,pp_token::TOK_QMARK);
01683 }
01684         YY_BREAK
01685 case 18:
01686 YY_RULE_SETUP
01687 {
01688         return pp_token::create(a_location,pp_token::TOK_DOT);
01689 }
01690         YY_BREAK
01691 case 19:
01692 YY_RULE_SETUP
01693 {
01694         return pp_token::create(a_location,pp_token::TOK_PLUS);
01695 }
01696         YY_BREAK
01697 case 20:
01698 YY_RULE_SETUP
01699 {
01700         return pp_token::create(a_location,pp_token::TOK_STAR);
01701 }
01702         YY_BREAK
01703 case 21:
01704 YY_RULE_SETUP
01705 {
01706         return pp_token::create(a_location,pp_token::TOK_PERCENT);
01707 }
01708         YY_BREAK
01709 case 22:
01710 YY_RULE_SETUP
01711 {
01712         return pp_token::create(a_location,pp_token::TOK_SLASH);
01713 }
01714         YY_BREAK
01715 case 23:
01716 YY_RULE_SETUP
01717 {
01718         return pp_token::create(a_location,pp_token::TOK_HAT);
01719 }
01720         YY_BREAK
01721 case 24:
01722 YY_RULE_SETUP
01723 {
01724         return pp_token::create_alternative(a_location,pp_token::TOK_HAT);
01725 }
01726         YY_BREAK
01727 case 25:
01728 YY_RULE_SETUP
01729 {
01730         return pp_token::create(a_location,pp_token::TOK_AMP);
01731 }
01732         YY_BREAK
01733 case 26:
01734 YY_RULE_SETUP
01735 {
01736         return pp_token::create_alternative(a_location,pp_token::TOK_AMP);
01737 }
01738         YY_BREAK
01739 case 27:
01740 YY_RULE_SETUP
01741 {
01742         return pp_token::create(a_location,pp_token::TOK_VBAR);
01743 }
01744         YY_BREAK
01745 case 28:
01746 YY_RULE_SETUP
01747 {
01748         return pp_token::create_alternative(a_location,pp_token::TOK_VBAR);
01749 }
01750         YY_BREAK
01751 case 29:
01752 YY_RULE_SETUP
01753 {
01754         return pp_token::create(a_location,pp_token::TOK_TILDE);
01755 }
01756         YY_BREAK
01757 case 30:
01758 YY_RULE_SETUP
01759 {
01760         return pp_token::create_alternative(a_location,pp_token::TOK_TILDE);
01761 }
01762         YY_BREAK
01763 case 31:
01764 YY_RULE_SETUP
01765 {
01766         return pp_token::create(a_location,pp_token::TOK_EMARK);
01767 }
01768         YY_BREAK
01769 case 32:
01770 YY_RULE_SETUP
01771 {
01772         return pp_token::create_alternative(a_location,pp_token::TOK_EMARK);
01773 }
01774         YY_BREAK
01775 case 33:
01776 YY_RULE_SETUP
01777 {
01778         return pp_token::create(a_location,pp_token::TOK_EQ);
01779 }
01780         YY_BREAK
01781 case 34:
01782 YY_RULE_SETUP
01783 {
01784         return pp_token::create(a_location,pp_token::TOK_LT);
01785 }
01786         YY_BREAK
01787 case 35:
01788 YY_RULE_SETUP
01789 {
01790         return pp_token::create(a_location,pp_token::TOK_GT);
01791 }
01792         YY_BREAK
01793 case 36:
01794 YY_RULE_SETUP
01795 {
01796         return pp_token::create(a_location,pp_token::TOK_COMMA);
01797 }
01798         YY_BREAK
01799 case 37:
01800 YY_RULE_SETUP
01801 {
01802         return pp_token::create(a_location,pp_token::TOK_MINUS);
01803 }
01804         YY_BREAK
01805 case 38:
01806 YY_RULE_SETUP
01807 {
01808         return pp_token::create(a_location,pp_token::TOK_COLON_COLON);
01809 }
01810         YY_BREAK
01811 case 39:
01812 YY_RULE_SETUP
01813 {
01814         return pp_token::create(a_location,pp_token::TOK_DOT_STAR);
01815 }
01816         YY_BREAK
01817 case 40:
01818 YY_RULE_SETUP
01819 {
01820         return pp_token::create(a_location,pp_token::TOK_PLUS_EQ);
01821 }
01822         YY_BREAK
01823 case 41:
01824 YY_RULE_SETUP
01825 {
01826         return pp_token::create(a_location,pp_token::TOK_MINUS_EQ);
01827 }
01828         YY_BREAK
01829 case 42:
01830 YY_RULE_SETUP
01831 {
01832         return pp_token::create(a_location,pp_token::TOK_STAR_EQ);
01833 }
01834         YY_BREAK
01835 case 43:
01836 YY_RULE_SETUP
01837 {
01838         return pp_token::create(a_location,pp_token::TOK_SLASH_EQ);
01839 }
01840         YY_BREAK
01841 case 44:
01842 YY_RULE_SETUP
01843 {
01844         return pp_token::create(a_location,pp_token::TOK_PERCENT_EQ);
01845 }
01846         YY_BREAK
01847 case 45:
01848 YY_RULE_SETUP
01849 {
01850         return pp_token::create(a_location,pp_token::TOK_HAT_EQ);
01851 }
01852         YY_BREAK
01853 case 46:
01854 YY_RULE_SETUP
01855 {
01856         return pp_token::create_alternative(a_location,pp_token::TOK_HAT_EQ);
01857 }
01858         YY_BREAK
01859 case 47:
01860 YY_RULE_SETUP
01861 {
01862         return pp_token::create(a_location,pp_token::TOK_AMP_EQ);
01863 }
01864         YY_BREAK
01865 case 48:
01866 YY_RULE_SETUP
01867 {
01868         return pp_token::create_alternative(a_location,pp_token::TOK_AMP_EQ);
01869 }
01870         YY_BREAK
01871 case 49:
01872 YY_RULE_SETUP
01873 {
01874         return pp_token::create(a_location,pp_token::TOK_VBAR_EQ);
01875 }
01876         YY_BREAK
01877 case 50:
01878 YY_RULE_SETUP
01879 {
01880         return pp_token::create_alternative(a_location,pp_token::TOK_VBAR_EQ);
01881 }
01882         YY_BREAK
01883 case 51:
01884 YY_RULE_SETUP
01885 {
01886         return pp_token::create(a_location,pp_token::TOK_LT_LT);
01887 }
01888         YY_BREAK
01889 case 52:
01890 YY_RULE_SETUP
01891 {
01892         return pp_token::create(a_location,pp_token::TOK_GT_GT);
01893 }
01894         YY_BREAK
01895 case 53:
01896 YY_RULE_SETUP
01897 {
01898         return pp_token::create(a_location,pp_token::TOK_GT_GT_EQ);
01899 }
01900         YY_BREAK
01901 case 54:
01902 YY_RULE_SETUP
01903 {
01904         return pp_token::create(a_location,pp_token::TOK_LT_LT_EQ);
01905 }
01906         YY_BREAK
01907 case 55:
01908 YY_RULE_SETUP
01909 {
01910         return pp_token::create(a_location,pp_token::TOK_EQ_EQ);
01911 }
01912         YY_BREAK
01913 case 56:
01914 YY_RULE_SETUP
01915 {
01916         return pp_token::create(a_location,pp_token::TOK_EMARK_EQ);
01917 }
01918         YY_BREAK
01919 case 57:
01920 YY_RULE_SETUP
01921 {
01922         return pp_token::create_alternative(a_location,pp_token::TOK_EMARK_EQ);
01923 }
01924         YY_BREAK
01925 case 58:
01926 YY_RULE_SETUP
01927 {
01928         return pp_token::create(a_location,pp_token::TOK_LT_EQ);
01929 }
01930         YY_BREAK
01931 case 59:
01932 YY_RULE_SETUP
01933 {
01934         return pp_token::create(a_location,pp_token::TOK_GT_EQ);
01935 }
01936         YY_BREAK
01937 case 60:
01938 YY_RULE_SETUP
01939 {
01940         return pp_token::create(a_location,pp_token::TOK_AMP_AMP);
01941 }
01942         YY_BREAK
01943 case 61:
01944 YY_RULE_SETUP
01945 {
01946         return pp_token::create_alternative(a_location,pp_token::TOK_AMP_AMP);
01947 }
01948         YY_BREAK
01949 case 62:
01950 YY_RULE_SETUP
01951 {
01952         return pp_token::create(a_location,pp_token::TOK_VBAR_VBAR);
01953 }
01954         YY_BREAK
01955 case 63:
01956 YY_RULE_SETUP
01957 {
01958         return pp_token::create_alternative(a_location,pp_token::TOK_VBAR_VBAR);
01959 }
01960         YY_BREAK
01961 case 64:
01962 YY_RULE_SETUP
01963 {
01964         return pp_token::create(a_location,pp_token::TOK_PLUS_PLUS);
01965 }
01966         YY_BREAK
01967 case 65:
01968 YY_RULE_SETUP
01969 {
01970         return pp_token::create(a_location,pp_token::TOK_MINUS_MINUS);
01971 }
01972         YY_BREAK
01973 case 66:
01974 YY_RULE_SETUP
01975 {
01976         return pp_token::create(a_location,pp_token::TOK_MINUS_GT_STAR);
01977 }
01978         YY_BREAK
01979 case 67:
01980 YY_RULE_SETUP
01981 {
01982         return pp_token::create(a_location,pp_token::TOK_MINUS_GT);
01983 }
01984         YY_BREAK
01985 case 68:
01986 YY_RULE_SETUP
01987 {
01988         return pp_token::create(a_location,pp_token::TOK_DOT_DOT_DOT);
01989 }
01990         YY_BREAK
01991 case 69:
01992 YY_RULE_SETUP
01993 {
01994         return pp_token::create(a_location,pp_token::TOK_ASM);
01995 }
01996         YY_BREAK
01997 case 70:
01998 YY_RULE_SETUP
01999 {
02000         return pp_token::create(a_location,pp_token::TOK_AUTO);
02001 }
02002         YY_BREAK
02003 case 71:
02004 YY_RULE_SETUP
02005 {
02006         return pp_token::create(a_location,pp_token::TOK_BOOL);
02007 }
02008         YY_BREAK
02009 case 72:
02010 YY_RULE_SETUP
02011 {
02012         return pp_token::create(a_location,pp_token::TOK_BREAK);
02013 }
02014         YY_BREAK
02015 case 73:
02016 YY_RULE_SETUP
02017 {
02018         return pp_token::create(a_location,pp_token::TOK_CASE);
02019 }
02020         YY_BREAK
02021 case 74:
02022 YY_RULE_SETUP
02023 {
02024         return pp_token::create(a_location,pp_token::TOK_CATCH);
02025 }
02026         YY_BREAK
02027 case 75:
02028 YY_RULE_SETUP
02029 {
02030         return pp_token::create(a_location,pp_token::TOK_CHAR);
02031 }
02032         YY_BREAK
02033 case 76:
02034 YY_RULE_SETUP
02035 {
02036         return pp_token::create(a_location,pp_token::TOK_CLASS);
02037 }
02038         YY_BREAK
02039 case 77:
02040 YY_RULE_SETUP
02041 {
02042         return pp_token::create(a_location,pp_token::TOK_CONST);
02043 }
02044         YY_BREAK
02045 case 78:
02046 YY_RULE_SETUP
02047 {
02048         return pp_token::create(a_location,pp_token::TOK_CONST_CAST);
02049 }
02050         YY_BREAK
02051 case 79:
02052 YY_RULE_SETUP
02053 {
02054         return pp_token::create(a_location,pp_token::TOK_CONTINUE);
02055 }
02056         YY_BREAK
02057 case 80:
02058 YY_RULE_SETUP
02059 {
02060         return pp_token::create(a_location,pp_token::TOK_DEFAULT);
02061 }
02062         YY_BREAK
02063 case 81:
02064 YY_RULE_SETUP
02065 {
02066         return pp_token::create(a_location,pp_token::TOK_DELETE);
02067 }
02068         YY_BREAK
02069 case 82:
02070 YY_RULE_SETUP
02071 {
02072         return pp_token::create(a_location,pp_token::TOK_DO);
02073 }
02074         YY_BREAK
02075 case 83:
02076 YY_RULE_SETUP
02077 {
02078         return pp_token::create(a_location,pp_token::TOK_DOUBLE);
02079 }
02080         YY_BREAK
02081 case 84:
02082 YY_RULE_SETUP
02083 {
02084         return pp_token::create(a_location,pp_token::TOK_DYNAMIC_CAST);
02085 }
02086         YY_BREAK
02087 case 85:
02088 YY_RULE_SETUP
02089 {
02090         return pp_token::create(a_location,pp_token::TOK_ELSE);
02091 }
02092         YY_BREAK
02093 case 86:
02094 YY_RULE_SETUP
02095 {
02096         return pp_token::create(a_location,pp_token::TOK_ENUM);
02097 }
02098         YY_BREAK
02099 case 87:
02100 YY_RULE_SETUP
02101 {
02102         return pp_token::create(a_location,pp_token::TOK_EXPLICIT);
02103 }
02104         YY_BREAK
02105 case 88:
02106 YY_RULE_SETUP
02107 {
02108         return pp_token::create(a_location,pp_token::TOK_EXPORT);
02109 }
02110         YY_BREAK
02111 case 89:
02112 YY_RULE_SETUP
02113 {
02114         return pp_token::create(a_location,pp_token::TOK_EXTERN);
02115 }
02116         YY_BREAK
02117 case 90:
02118 YY_RULE_SETUP
02119 {
02120         return pp_token::create(a_location,pp_token::TOK_FLOAT);
02121 }
02122         YY_BREAK
02123 case 91:
02124 YY_RULE_SETUP
02125 {
02126         return pp_token::create(a_location,pp_token::TOK_FOR);
02127 }
02128         YY_BREAK
02129 case 92:
02130 YY_RULE_SETUP
02131 {
02132         return pp_token::create(a_location,pp_token::TOK_FRIEND);
02133 }
02134         YY_BREAK
02135 case 93:
02136 YY_RULE_SETUP
02137 {
02138         return pp_token::create(a_location,pp_token::TOK_GOTO);
02139 }
02140         YY_BREAK
02141 case 94:
02142 YY_RULE_SETUP
02143 {
02144         return pp_token::create(a_location,pp_token::TOK_IF);
02145 }
02146         YY_BREAK
02147 case 95:
02148 YY_RULE_SETUP
02149 {
02150         return pp_token::create(a_location,pp_token::TOK_INLINE);
02151 }
02152         YY_BREAK
02153 case 96:
02154 YY_RULE_SETUP
02155 {
02156         return pp_token::create(a_location,pp_token::TOK_INT);
02157 }
02158         YY_BREAK
02159 case 97:
02160 YY_RULE_SETUP
02161 {
02162         return pp_token::create(a_location,pp_token::TOK_LONG);
02163 }
02164         YY_BREAK
02165 case 98:
02166 YY_RULE_SETUP
02167 {
02168         return pp_token::create(a_location,pp_token::TOK_MUTABLE);
02169 }
02170         YY_BREAK
02171 case 99:
02172 YY_RULE_SETUP
02173 {
02174         return pp_token::create(a_location,pp_token::TOK_NAMESPACE);
02175 }
02176         YY_BREAK
02177 case 100:
02178 YY_RULE_SETUP
02179 {
02180         return pp_token::create(a_location,pp_token::TOK_NEW);
02181 }
02182         YY_BREAK
02183 case 101:
02184 YY_RULE_SETUP
02185 {
02186         return pp_token::create(a_location,pp_token::TOK_OPERATOR);
02187 }
02188         YY_BREAK
02189 case 102:
02190 YY_RULE_SETUP
02191 {
02192         return pp_token::create(a_location,pp_token::TOK_PRIVATE);
02193 }
02194         YY_BREAK
02195 case 103:
02196 YY_RULE_SETUP
02197 {
02198         return pp_token::create(a_location,pp_token::TOK_PROTECTED);
02199 }
02200         YY_BREAK
02201 case 104:
02202 YY_RULE_SETUP
02203 {
02204         return pp_token::create(a_location,pp_token::TOK_PUBLIC);
02205 }
02206         YY_BREAK
02207 case 105:
02208 YY_RULE_SETUP
02209 {
02210         return pp_token::create(a_location,pp_token::TOK_REGISTER);
02211 }
02212         YY_BREAK
02213 case 106:
02214 YY_RULE_SETUP
02215 {
02216         return pp_token::create(a_location,pp_token::TOK_REINTERPRET_CAST);
02217 }
02218         YY_BREAK
02219 case 107:
02220 YY_RULE_SETUP
02221 {
02222         return pp_token::create(a_location,pp_token::TOK_RETURN);
02223 }
02224         YY_BREAK
02225 case 108:
02226 YY_RULE_SETUP
02227 {
02228         return pp_token::create(a_location,pp_token::TOK_SHORT);
02229 }
02230         YY_BREAK
02231 case 109:
02232 YY_RULE_SETUP
02233 {
02234         return pp_token::create(a_location,pp_token::TOK_SIGNED);
02235 }
02236         YY_BREAK
02237 case 110:
02238 YY_RULE_SETUP
02239 {
02240         return pp_token::create(a_location,pp_token::TOK_SIZEOF);
02241 }
02242         YY_BREAK
02243 case 111:
02244 YY_RULE_SETUP
02245 {
02246         return pp_token::create(a_location,pp_token::TOK_STATIC);
02247 }
02248         YY_BREAK
02249 case 112:
02250 YY_RULE_SETUP
02251 {
02252         return pp_token::create(a_location,pp_token::TOK_STATIC_CAST);
02253 }
02254         YY_BREAK
02255 case 113:
02256 YY_RULE_SETUP
02257 {
02258         return pp_token::create(a_location,pp_token::TOK_STRUCT);
02259 }
02260         YY_BREAK
02261 case 114:
02262 YY_RULE_SETUP
02263 {
02264         return pp_token::create(a_location,pp_token::TOK_SWITCH);
02265 }
02266         YY_BREAK
02267 case 115:
02268 YY_RULE_SETUP
02269 {
02270         return pp_token::create(a_location,pp_token::TOK_TEMPLATE);
02271 }
02272         YY_BREAK
02273 case 116:
02274 YY_RULE_SETUP
02275 {
02276         return pp_token::create(a_location,pp_token::TOK_THIS);
02277 }
02278         YY_BREAK
02279 case 117:
02280 YY_RULE_SETUP
02281 {
02282         return pp_token::create(a_location,pp_token::TOK_THROW);
02283 }
02284         YY_BREAK
02285 case 118:
02286 YY_RULE_SETUP
02287 {
02288         return pp_token::create(a_location,pp_token::TOK_TRY);
02289 }
02290         YY_BREAK
02291 case 119:
02292 YY_RULE_SETUP
02293 {
02294         return pp_token::create(a_location,pp_token::TOK_TYPEDEF);
02295 }
02296         YY_BREAK
02297 case 120:
02298 YY_RULE_SETUP
02299 {
02300         return pp_token::create(a_location,pp_token::TOK_TYPEID);
02301 }
02302         YY_BREAK
02303 case 121:
02304 YY_RULE_SETUP
02305 {
02306         return pp_token::create(a_location,pp_token::TOK_TYPENAME);
02307 }
02308         YY_BREAK
02309 case 122:
02310 YY_RULE_SETUP
02311 {
02312         return pp_token::create(a_location,pp_token::TOK_UNION);
02313 }
02314         YY_BREAK
02315 case 123:
02316 YY_RULE_SETUP
02317 {
02318         return pp_token::create(a_location,pp_token::TOK_UNSIGNED);
02319 }
02320         YY_BREAK
02321 case 124:
02322 YY_RULE_SETUP
02323 {
02324         return pp_token::create(a_location,pp_token::TOK_USING);
02325 }
02326         YY_BREAK
02327 case 125:
02328 YY_RULE_SETUP
02329 {
02330         return pp_token::create(a_location,pp_token::TOK_VIRTUAL);
02331 }
02332         YY_BREAK
02333 case 126:
02334 YY_RULE_SETUP
02335 {
02336         return pp_token::create(a_location,pp_token::TOK_VOID);
02337 }
02338         YY_BREAK
02339 case 127:
02340 YY_RULE_SETUP
02341 {
02342         return pp_token::create(a_location,pp_token::TOK_VOLATILE);
02343 }
02344         YY_BREAK
02345 case 128:
02346 YY_RULE_SETUP
02347 {
02348         return pp_token::create(a_location,pp_token::TOK_WCHAR);
02349 }
02350         YY_BREAK
02351 case 129:
02352 YY_RULE_SETUP
02353 {
02354         return pp_token::create(a_location,pp_token::TOK_WHILE);
02355 }
02356         YY_BREAK
02357 case 130:
02358 YY_RULE_SETUP
02359 {
02360         return pp_token::create(a_location,pp_token::TOK_BOOL_LIT,a_value);
02361 }
02362         YY_BREAK
02363 case 131:
02364 YY_RULE_SETUP
02365 {
02366         return pp_token::create(a_location,pp_token::TOK_BOOL_LIT,a_value);
02367 }
02368         YY_BREAK
02369 /* pp number */
02370 case 132:
02371 YY_RULE_SETUP
02372 {
02373         return pp_token::create(a_location,pp_token::TOK_NUMBER_LIT,a_value);
02374 }
02375         YY_BREAK
02376 /* pp won't be number (ucn or underscore) - next best match */
02377 case 133:
02378 YY_RULE_SETUP
02379 {
02380         return pp_token::create(a_location,pp_token::TOK_NUMBER_LIT,a_value);
02381 }
02382         YY_BREAK
02383 /* pp alphanumeric identifier */
02384 case 134:
02385 YY_RULE_SETUP
02386 {
02387         return pp_token::create(a_location,pp_token::TOK_IDENT,a_value);
02388 }
02389         YY_BREAK
02390 /* pp generic identifier (contains ucns) */
02391 case 135:
02392 YY_RULE_SETUP
02393 {
02394         // check correct ucn in identifiers
02395         ucn_string us(a_value->content_get());
02396         ucn u;
02397         for (ucn_string::iterator it = us.begin(), end = us.end(); it != end; ++it) {
02398                 u = *it;
02399                 if (!(character::is_basic(u) || character::is_translated_identifier(u)))
02400          // invalid character in identifier
02401                         return NULL;
02402         }
02403         return pp_token::create(a_location,pp_token::TOK_IDENT,a_value);
02404 }
02405         YY_BREAK
02406 /* character literal */
02407 case 136:
02408 YY_RULE_SETUP
02409 {
02410    ucn_string u(a_value->content_get());
02411    ucn_string v(u.begin() + 1,u.begin() + u.length() - 1);
02412         return pp_token::create(a_location,pp_token::TOK_CHAR_LIT,token_value::create(v));
02413 }
02414         YY_BREAK
02415 /* wide character literal */
02416 case 137:
02417 YY_RULE_SETUP
02418 {
02419    ucn_string u(a_value->content_get());
02420    ucn_string v(u.begin() + 2,u.begin() + u.length() - 1);
02421         return pp_token::create(a_location,pp_token::TOK_WCHAR_LIT,token_value::create(v));
02422 }
02423         YY_BREAK
02424 /* string literal */
02425 case 138:
02426 YY_RULE_SETUP
02427 {
02428    ucn_string u(a_value->content_get());
02429    ucn_string v(u.begin() + 1,u.begin() + u.length() - 1);
02430         return pp_token::create(a_location,pp_token::TOK_STRING_LIT,token_value::create(v));
02431 }
02432         YY_BREAK
02433 /* wide string literal */
02434 case 139:
02435 YY_RULE_SETUP
02436 {
02437    ucn_string u(a_value->content_get());
02438    ucn_string v(u.begin() + 2,u.begin() + u.length() - 1);
02439         return pp_token::create(a_location,pp_token::TOK_WSTRING_LIT,token_value::create(v));
02440 }
02441         YY_BREAK
02442 /* chatch ill-formed concatenation */
02443 case 140:
02444 /* rule 140 can match eol */
02445 YY_RULE_SETUP
02446 {
02447         return NULL;
02448 }
02449         YY_BREAK
02450 case 141:
02451 YY_RULE_SETUP
02452 ECHO;
02453         YY_BREAK
02454 case YY_STATE_EOF(INITIAL):
02455         yyterminate();
02456 
02457         case YY_END_OF_BUFFER:
02458                 {
02459                 /* Amount of text matched not including the EOB char. */
02460                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
02461 
02462                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
02463                 *yy_cp = (yy_hold_char);
02464                 YY_RESTORE_YY_MORE_OFFSET
02465 
02466                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
02467                         {
02468                         /* We're scanning a new file or input source.  It's
02469                          * possible that this happened because the user
02470                          * just pointed yyin at a new source and called
02471                          * yylex().  If so, then we have to assure
02472                          * consistency between YY_CURRENT_BUFFER and our
02473                          * globals.  Here is the right place to do so, because
02474                          * this is the first action (other than possibly a
02475                          * back-up) that will match for the new input source.
02476                          */
02477                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
02478                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
02479                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
02480                         }
02481 
02482                 /* Note that here we test for yy_c_buf_p "<=" to the position
02483                  * of the first EOB in the buffer, since yy_c_buf_p will
02484                  * already have been incremented past the NUL character
02485                  * (since all states make transitions on EOB to the
02486                  * end-of-buffer state).  Contrast this with the test
02487                  * in input().
02488                  */
02489                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
02490                         { /* This was really a NUL. */
02491                         yy_state_type yy_next_state;
02492 
02493                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
02494 
02495                         yy_current_state = yy_get_previous_state(  );
02496 
02497                         /* Okay, we're now positioned to make the NUL
02498                          * transition.  We couldn't have
02499                          * yy_get_previous_state() go ahead and do it
02500                          * for us because it doesn't know how to deal
02501                          * with the possibility of jamming (and we don't
02502                          * want to build jamming into it because then it
02503                          * will run more slowly).
02504                          */
02505 
02506                         yy_next_state = yy_try_NUL_trans( yy_current_state );
02507 
02508                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
02509 
02510                         if ( yy_next_state )
02511                                 {
02512                                 /* Consume the NUL. */
02513                                 yy_cp = ++(yy_c_buf_p);
02514                                 yy_current_state = yy_next_state;
02515                                 goto yy_match;
02516                                 }
02517 
02518                         else
02519                                 {
02520                                 yy_cp = (yy_last_accepting_cpos);
02521                                 yy_current_state = (yy_last_accepting_state);
02522                                 goto yy_find_action;
02523                                 }
02524                         }
02525 
02526                 else switch ( yy_get_next_buffer(  ) )
02527                         {
02528                         case EOB_ACT_END_OF_FILE:
02529                                 {
02530                                 (yy_did_buffer_switch_on_eof) = 0;
02531 
02532                                 if ( yywrap( ) )
02533                                         {
02534                                         /* Note: because we've taken care in
02535                                          * yy_get_next_buffer() to have set up
02536                                          * yytext, we can now set up
02537                                          * yy_c_buf_p so that if some total
02538                                          * hoser (like flex itself) wants to
02539                                          * call the scanner after we return the
02540                                          * YY_NULL, it'll still work - another
02541                                          * YY_NULL will get returned.
02542                                          */
02543                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
02544 
02545                                         yy_act = YY_STATE_EOF(YY_START);
02546                                         goto do_action;
02547                                         }
02548 
02549                                 else
02550                                         {
02551                                         if ( ! (yy_did_buffer_switch_on_eof) )
02552                                                 YY_NEW_FILE;
02553                                         }
02554                                 break;
02555                                 }
02556 
02557                         case EOB_ACT_CONTINUE_SCAN:
02558                                 (yy_c_buf_p) =
02559                                         (yytext_ptr) + yy_amount_of_matched_text;
02560 
02561                                 yy_current_state = yy_get_previous_state(  );
02562 
02563                                 yy_cp = (yy_c_buf_p);
02564                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
02565                                 goto yy_match;
02566 
02567                         case EOB_ACT_LAST_MATCH:
02568                                 (yy_c_buf_p) =
02569                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
02570 
02571                                 yy_current_state = yy_get_previous_state(  );
02572 
02573                                 yy_cp = (yy_c_buf_p);
02574                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
02575                                 goto yy_find_action;
02576                         }
02577                 break;
02578                 }
02579 
02580         default:
02581                 YY_FATAL_ERROR(
02582                         "fatal flex scanner internal error--no action found" );
02583         } /* end of action switch */
02584                 } /* end of scanning one token */
02585 } /* end of yylex */

YY_BUFFER_STATE yy_create_buffer ( FILE *  file,
int  size 
)

Allocate and initialize an input buffer state.

Parameters:
file A readable stream.
size The character buffer size in bytes. When in doubt, use YY_BUF_SIZE.
Returns:
the allocated buffer state.

Definition at line 2916 of file concat_guts.yy.cc.

References b, YY_FATAL_ERROR, yy_init_buffer(), and yyalloc().

Referenced by concat_parse(), lexer_parse(), and yyrestart().

02917 {
02918         YY_BUFFER_STATE b;
02919     
02920         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
02921         if ( ! b )
02922                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
02923 
02924         b->yy_buf_size = size;
02925 
02926         /* yy_ch_buf has to be 2 characters longer than the size given because
02927          * we need to put in 2 end-of-buffer characters.
02928          */
02929         b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
02930         if ( ! b->yy_ch_buf )
02931                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
02932 
02933         b->yy_is_our_buffer = 1;
02934 
02935         yy_init_buffer(b,file );
02936 
02937         return b;
02938 }

void yy_delete_buffer ( YY_BUFFER_STATE  b  ) 

Destroy the buffer.

Parameters:
b a buffer created with yy_create_buffer()

Definition at line 2944 of file concat_guts.yy.cc.

References b, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, and yyfree().

Referenced by yylex_destroy(), yypop_buffer_state(), lestes::lang::cplus::lex::concat::~concat(), and lestes::lang::cplus::lex::pp_lex::~pp_lex().

02945 {
02946     
02947         if ( ! b )
02948                 return;
02949 
02950         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
02951                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
02952 
02953         if ( b->yy_is_our_buffer )
02954                 yyfree((void *) b->yy_ch_buf  );
02955 
02956         yyfree((void *) b  );
02957 }

static void yy_fatal_error ( char *  msg  )  [static]

Definition at line 3116 of file concat_guts.yy.cc.

References YY_EXIT_FAILURE.

03117 {
03118         /* (void) fprintf( stderr, "%s\n", msg ); */
03119         (void)msg;
03120         exit( YY_EXIT_FAILURE );
03121 }

static void yy_fatal_error ( char  msg[]  )  [static]

void yy_flush_buffer ( YY_BUFFER_STATE  b  ) 

Discard all buffered characters. On the next scan, YY_INPUT will be called.

Parameters:
b the buffer state to be flushed, usually YY_CURRENT_BUFFER.

Definition at line 2995 of file concat_guts.yy.cc.

References b, YY_BUFFER_NEW, YY_CURRENT_BUFFER, YY_END_OF_BUFFER_CHAR, and yy_load_buffer_state().

Referenced by yy_init_buffer().

02996 {
02997         if ( ! b )
02998                 return;
02999 
03000         b->yy_n_chars = 0;
03001 
03002         /* We always need two end-of-buffer characters.  The first causes
03003          * a transition to the end-of-buffer state.  The second causes
03004          * a jam in that state.
03005          */
03006         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
03007         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
03008 
03009         b->yy_buf_pos = &b->yy_ch_buf[0];
03010 
03011         b->yy_at_bol = 1;
03012         b->yy_buffer_status = YY_BUFFER_NEW;
03013 
03014         if ( b == YY_CURRENT_BUFFER )
03015                 yy_load_buffer_state( );
03016 }

static int yy_get_next_buffer ( void   )  [static]

Definition at line 2594 of file concat_guts.yy.cc.

References b, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, YY_BUFFER_EOF_PENDING, yy_c_buf_p, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, YY_FATAL_ERROR, YY_MORE_ADJ, yy_n_chars, yyrealloc(), and yytext_ptr.

Referenced by concat_parse(), and lexer_parse().

02595 {
02596         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
02597         register char *source = (yytext_ptr);
02598         register int number_to_move, i;
02599         int ret_val;
02600 
02601         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
02602                 YY_FATAL_ERROR(
02603                 "fatal flex scanner internal error--end of buffer missed" );
02604 
02605         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
02606                 { /* Don't try to fill the buffer, so this is an EOF. */
02607                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
02608                         {
02609                         /* We matched a single character, the EOB, so
02610                          * treat this as a final EOF.
02611                          */
02612                         return EOB_ACT_END_OF_FILE;
02613                         }
02614 
02615                 else
02616                         {
02617                         /* We matched some text prior to the EOB, first
02618                          * process it.
02619                          */
02620                         return EOB_ACT_LAST_MATCH;
02621                         }
02622                 }
02623 
02624         /* Try to read more data. */
02625 
02626         /* First move last chars to start of buffer. */
02627         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
02628 
02629         for ( i = 0; i < number_to_move; ++i )
02630                 *(dest++) = *(source++);
02631 
02632         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
02633                 /* don't do the read, it's not guaranteed to return an EOF,
02634                  * just force an EOF
02635                  */
02636                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
02637 
02638         else
02639                 {
02640                         int num_to_read =
02641                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
02642 
02643                 while ( num_to_read <= 0 )
02644                         { /* Not enough room in the buffer - grow it. */
02645 
02646                         /* just a shorter name for the current buffer */
02647                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
02648 
02649                         int yy_c_buf_p_offset =
02650                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
02651 
02652                         if ( b->yy_is_our_buffer )
02653                                 {
02654                                 int new_size = b->yy_buf_size * 2;
02655 
02656                                 if ( new_size <= 0 )
02657                                         b->yy_buf_size += b->yy_buf_size / 8;
02658                                 else
02659                                         b->yy_buf_size *= 2;
02660 
02661                                 b->yy_ch_buf = (char *)
02662                                         /* Include room in for 2 EOB chars. */
02663                                         yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
02664                                 }
02665                         else
02666                                 /* Can't grow it, we don't own it. */
02667                                 b->yy_ch_buf = 0;
02668 
02669                         if ( ! b->yy_ch_buf )
02670                                 YY_FATAL_ERROR(
02671                                 "fatal error - scanner input buffer overflow" );
02672 
02673                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
02674 
02675                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
02676                                                 number_to_move - 1;
02677 
02678                         }
02679 
02680                 if ( num_to_read > YY_READ_BUF_SIZE )
02681                         num_to_read = YY_READ_BUF_SIZE;
02682 
02683                 /* Read in more data. */
02684                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
02685                         (yy_n_chars), num_to_read );
02686 
02687                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
02688                 }
02689 
02690         if ( (yy_n_chars) == 0 )
02691                 {
02692                 if ( number_to_move == YY_MORE_ADJ )
02693                         {
02694                         ret_val = EOB_ACT_END_OF_FILE;
02695                         yyrestart(yyin  );
02696                         }
02697 
02698                 else
02699                         {
02700                         ret_val = EOB_ACT_LAST_MATCH;
02701                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
02702                                 YY_BUFFER_EOF_PENDING;
02703                         }
02704                 }
02705 
02706         else
02707                 ret_val = EOB_ACT_CONTINUE_SCAN;
02708 
02709         (yy_n_chars) += number_to_move;
02710         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
02711         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
02712 
02713         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
02714 
02715         return ret_val;
02716 }

static yy_state_type yy_get_previous_state ( void   )  [static]

Definition at line 2720 of file concat_guts.yy.cc.

References yy_c_buf_p, YY_MORE_ADJ, YY_SC_TO_UI, yy_start, and yytext_ptr.

Referenced by concat_parse(), and lexer_parse().

02721 {
02722         register yy_state_type yy_current_state;
02723         register char *yy_cp;
02724     
02725         yy_current_state = (yy_start);
02726 
02727         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
02728                 {
02729                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 95);
02730                 if ( yy_accept[yy_current_state] )
02731                         {
02732                         (yy_last_accepting_state) = yy_current_state;
02733                         (yy_last_accepting_cpos) = yy_cp;
02734                         }
02735                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
02736                         {
02737                         yy_current_state = (int) yy_def[yy_current_state];
02738                         if ( yy_current_state >= 669 )
02739                                 yy_c = yy_meta[(unsigned int) yy_c];
02740                         }
02741                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
02742                 }
02743 
02744         return yy_current_state;
02745 }

static void yy_init_buffer ( YY_BUFFER_STATE  b,
FILE *  file 
) [static]

Definition at line 2963 of file concat_guts.yy.cc.

References b, YY_CURRENT_BUFFER, and yy_flush_buffer().

Referenced by yy_create_buffer(), and yyrestart().

02965 {
02966 #if 0
02967         int oerrno = errno;
02968 #endif
02969     
02970         yy_flush_buffer(b );
02971 
02972         b->yy_input_file = file;
02973         b->yy_fill_buffer = 1;
02974 
02975     /* If b is the current buffer, then yy_init_buffer was _probably_
02976      * called from yyrestart() or through yy_get_next_buffer.
02977      * In that case, we don't want to reset the lineno or column.
02978      */
02979     if (b != YY_CURRENT_BUFFER){
02980         b->yy_bs_lineno = 1;
02981         b->yy_bs_column = 0;
02982     }
02983 
02984         b->yy_is_interactive = 0;
02985     
02986 #if 0
02987         errno = oerrno;
02988 #endif
02989 }

static int yy_init_globals ( void   )  [static]

Definition at line 3220 of file concat_guts.yy.cc.

References yy_buffer_stack, yy_buffer_stack_max, yy_buffer_stack_top, yy_init, yy_start, yyin, and yyout.

Referenced by yylex_destroy().

03221 {
03222         /* Initialization is the same as for the non-reentrant scanner.
03223      * This function is called from yylex_destroy(), so don't allocate here.
03224      */
03225 
03226     (yy_buffer_stack) = 0;
03227     (yy_buffer_stack_top) = 0;
03228     (yy_buffer_stack_max) = 0;
03229     (yy_c_buf_p) = (char *) 0;
03230     (yy_init) = 0;
03231     (yy_start) = 0;
03232 
03233 /* Defined in main.c */
03234 #ifdef YY_STDINIT
03235     yyin = stdin;
03236     yyout = stdout;
03237 #else
03238     yyin = (FILE *) 0;
03239     yyout = (FILE *) 0;
03240 #endif
03241 
03242     /* For future reference: Set errno on error, since we are called by
03243      * yylex_init()
03244      */
03245     return 0;
03246 }

static void yy_load_buffer_state ( void   )  [static]

Definition at line 2902 of file concat_guts.yy.cc.

References YY_CURRENT_BUFFER_LVALUE, yy_hold_char, yy_n_chars, yyin, and yytext_ptr.

Referenced by concat_parse(), lexer_parse(), yy_flush_buffer(), yy_switch_to_buffer(), yypop_buffer_state(), yypush_buffer_state(), and yyrestart().

02903 {
02904         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
02905         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
02906         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
02907         (yy_hold_char) = *(yy_c_buf_p);
02908 }

YY_BUFFER_STATE yy_scan_buffer ( char *  base,
yy_size_t  size 
)

YY_BUFFER_STATE yy_scan_bytes ( char *  bytes,
int  len 
)

YY_BUFFER_STATE yy_scan_string ( char *  yy_str  ) 

void yy_switch_to_buffer ( YY_BUFFER_STATE  new_buffer  ) 

Switch to a different input buffer.

Parameters:
new_buffer The new input buffer.

Definition at line 2871 of file concat_guts.yy.cc.

References YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, yy_hold_char, yy_load_buffer_state(), yy_n_chars, and yyensure_buffer_stack().

Referenced by lestes::lang::cplus::lex::pp_lex::activate(), and lestes::lang::cplus::lex::concat::concat().

02872 {
02873     
02874         /* TODO. We should be able to replace this entire function body
02875          * with
02876          *              yypop_buffer_state();
02877          *              yypush_buffer_state(new_buffer);
02878      */
02879         yyensure_buffer_stack ();
02880         if ( YY_CURRENT_BUFFER == new_buffer )
02881                 return;
02882 
02883         if ( YY_CURRENT_BUFFER )
02884                 {
02885                 /* Flush out information for old buffer. */
02886                 *(yy_c_buf_p) = (yy_hold_char);
02887                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
02888                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
02889                 }
02890 
02891         YY_CURRENT_BUFFER_LVALUE = new_buffer;
02892         yy_load_buffer_state( );
02893 
02894         /* We don't actually know whether we did this switch during
02895          * EOF (yywrap()) processing, but the only time this flag
02896          * is looked at is after yywrap() is called, so it's safe
02897          * to go ahead and always set it.
02898          */
02899         (yy_did_buffer_switch_on_eof) = 1;
02900 }

static yy_state_type yy_try_NUL_trans ( yy_state_type  current_state  )  [static]

Definition at line 2752 of file concat_guts.yy.cc.

References yy_c_buf_p.

Referenced by concat_parse(), and lexer_parse().

02753 {
02754         register int yy_is_jam;
02755         register char *yy_cp = (yy_c_buf_p);
02756 
02757         register YY_CHAR yy_c = 95;
02758         if ( yy_accept[yy_current_state] )
02759                 {
02760                 (yy_last_accepting_state) = yy_current_state;
02761                 (yy_last_accepting_cpos) = yy_cp;
02762                 }
02763         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
02764                 {
02765                 yy_current_state = (int) yy_def[yy_current_state];
02766                 if ( yy_current_state >= 669 )
02767                         yy_c = yy_meta[(unsigned int) yy_c];
02768                 }
02769         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
02770         yy_is_jam = (yy_current_state == 668);
02771 
02772         return yy_is_jam ? 0 : yy_current_state;
02773 }

void * yyalloc ( yy_size_t   ) 

Definition at line 3294 of file concat_guts.yy.cc.

Referenced by yy_create_buffer(), and yyensure_buffer_stack().

03295 {
03296         return (void *) malloc( size );
03297 }

static void yyensure_buffer_stack ( void   )  [static]

Definition at line 3073 of file concat_guts.yy.cc.

References yy_buffer_stack, yy_buffer_stack_max, yy_buffer_stack_top, yyalloc(), and yyrealloc().

Referenced by concat_parse(), lexer_parse(), yy_switch_to_buffer(), yypush_buffer_state(), and yyrestart().

03074 {
03075         int num_to_alloc;
03076     
03077         if (!(yy_buffer_stack)) {
03078 
03079                 /* First allocation is just for 2 elements, since we don't know if this
03080                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
03081                  * immediate realloc on the next call.
03082          */
03083                 num_to_alloc = 1;
03084                 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
03085                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
03086                                                                 );
03087                 
03088                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
03089                                 
03090                 (yy_buffer_stack_max) = num_to_alloc;
03091                 (yy_buffer_stack_top) = 0;
03092                 return;
03093         }
03094 
03095         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
03096 
03097                 /* Increase the buffer to prepare for a possible push. */
03098                 int grow_size = 8 /* arbitrary grow size */;
03099 
03100                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
03101                 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
03102                                                                 ((yy_buffer_stack),
03103                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
03104                                                                 );
03105 
03106                 /* zero only the new slots.*/
03107                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
03108                 (yy_buffer_stack_max) = num_to_alloc;
03109         }
03110 }

void yyfree ( void *   ) 

Definition at line 3311 of file concat_guts.yy.cc.

Referenced by yy_delete_buffer(), and yylex_destroy().

03312 {
03313         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
03314 }

int yyget_debug ( void   ) 

Definition at line 3210 of file concat_guts.yy.cc.

03211 {
03212         return yy_flex_debug;
03213 }

FILE* yyget_in ( void   ) 

Get the input stream.

Definition at line 3154 of file concat_guts.yy.cc.

References yyin.

03155 {
03156         return yyin;
03157 }

int yyget_leng ( void   ) 

Get the length of the current token.

Definition at line 3170 of file concat_guts.yy.cc.

References yyleng.

03171 {
03172         return yyleng;
03173 }

int yyget_lineno ( void   ) 

Get the current line number.

Definition at line 3145 of file concat_guts.yy.cc.

03146 {
03147         
03148     return yylineno;
03149 }

FILE* yyget_out ( void   ) 

Get the output stream.

Definition at line 3162 of file concat_guts.yy.cc.

References yyout.

03163 {
03164         return yyout;
03165 }

char* yyget_text ( void   ) 

Get the current token.

Definition at line 3179 of file concat_guts.yy.cc.

03180 {
03181         return yytext;
03182 }

int yylex_destroy ( void   ) 

Definition at line 3249 of file concat_guts.yy.cc.

References yy_buffer_stack, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_delete_buffer(), yy_init_globals(), yyfree(), and yypop_buffer_state().

03250 {
03251     
03252     /* Pop the buffer stack, destroying each element. */
03253         while(YY_CURRENT_BUFFER){
03254                 yy_delete_buffer(YY_CURRENT_BUFFER  );
03255                 YY_CURRENT_BUFFER_LVALUE = NULL;
03256                 yypop_buffer_state();
03257         }
03258 
03259         /* Destroy the stack itself. */
03260         yyfree((yy_buffer_stack) );
03261         (yy_buffer_stack) = NULL;
03262 
03263     /* Reset the globals. This is important in a non-reentrant scanner so the next time
03264      * yylex() is called, initialization will occur. */
03265     yy_init_globals( );
03266 
03267     return 0;
03268 }

void yypop_buffer_state ( void   ) 

Removes and deletes the top of the stack, if present. The next element becomes the new top.

Definition at line 3054 of file concat_guts.yy.cc.

References yy_buffer_stack_top, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_delete_buffer(), yy_did_buffer_switch_on_eof, and yy_load_buffer_state().

Referenced by yylex_destroy().

03055 {
03056         if (!YY_CURRENT_BUFFER)
03057                 return;
03058 
03059         yy_delete_buffer(YY_CURRENT_BUFFER );
03060         YY_CURRENT_BUFFER_LVALUE = NULL;
03061         if ((yy_buffer_stack_top) > 0)
03062                 --(yy_buffer_stack_top);
03063 
03064         if (YY_CURRENT_BUFFER) {
03065                 yy_load_buffer_state( );
03066                 (yy_did_buffer_switch_on_eof) = 1;
03067         }
03068 }

void yypush_buffer_state ( YY_BUFFER_STATE  new_buffer  ) 

Pushes the new state onto the stack. The new state becomes the current state. This function will allocate the stack if necessary.

Parameters:
new_buffer The new state.

Definition at line 3024 of file concat_guts.yy.cc.

References yy_buffer_stack_top, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, yy_hold_char, yy_load_buffer_state(), yy_n_chars, and yyensure_buffer_stack().

03025 {
03026         if (new_buffer == NULL)
03027                 return;
03028 
03029         yyensure_buffer_stack();
03030 
03031         /* This block is copied from yy_switch_to_buffer. */
03032         if ( YY_CURRENT_BUFFER )
03033                 {
03034                 /* Flush out information for old buffer. */
03035                 *(yy_c_buf_p) = (yy_hold_char);
03036                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
03037                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
03038                 }
03039 
03040         /* Only push if top exists. Otherwise, replace top. */
03041         if (YY_CURRENT_BUFFER)
03042                 (yy_buffer_stack_top)++;
03043         YY_CURRENT_BUFFER_LVALUE = new_buffer;
03044 
03045         /* copied from yy_switch_to_buffer. */
03046         yy_load_buffer_state( );
03047         (yy_did_buffer_switch_on_eof) = 1;
03048 }

void * yyrealloc ( void *  ,
yy_size_t   
)

Definition at line 3299 of file concat_guts.yy.cc.

Referenced by yy_get_next_buffer(), and yyensure_buffer_stack().

03300 {
03301         /* The cast to (char *) in the following accommodates both
03302          * implementations that use char* generic pointers, and those
03303          * that use void* generic pointers.  It works with the latter
03304          * because both ANSI C and C++ allow castless assignment from
03305          * any pointer type to void*, and deal with argument conversions
03306          * as though doing an assignment.
03307          */
03308         return (void *) realloc( (char *) ptr, size );
03309 }

void yyrestart ( FILE *  input_file  ) 

Immediately switch to a different input stream.

Parameters:
input_file A readable stream.
Note:
This function does not reset the start condition to INITIAL .

Definition at line 2854 of file concat_guts.yy.cc.

References YY_BUF_SIZE, yy_create_buffer(), YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_init_buffer(), yy_load_buffer_state(), yyensure_buffer_stack(), and yyin.

Referenced by lestes::lang::cplus::lex::concat::process().

02855 {
02856     
02857         if ( ! YY_CURRENT_BUFFER ){
02858         yyensure_buffer_stack ();
02859                 YY_CURRENT_BUFFER_LVALUE =
02860             yy_create_buffer(yyin,YY_BUF_SIZE );
02861         }
02862 
02863         yy_init_buffer(YY_CURRENT_BUFFER,input_file );
02864         yy_load_buffer_state( );
02865 }

void yyset_debug ( int  bdebug  ) 

Definition at line 3215 of file concat_guts.yy.cc.

03216 {
03217         yy_flex_debug = bdebug ;
03218 }

void yyset_in ( FILE *  in_str  ) 

Set the input stream. This does not discard the current input buffer.

Parameters:
in_str A readable stream.
See also:
yy_switch_to_buffer

Definition at line 3200 of file concat_guts.yy.cc.

References yyin.

03201 {
03202         yyin = in_str ;
03203 }

void yyset_lineno ( int  line_number  ) 

Set the current line number.

Parameters:
line_number 

Definition at line 3188 of file concat_guts.yy.cc.

03189 {
03190     
03191     yylineno = line_number;
03192 }

void yyset_out ( FILE *  out_str  ) 

Definition at line 3205 of file concat_guts.yy.cc.

References yyout.

03206 {
03207         yyout = out_str ;
03208 }

Variable Documentation

flex_int16_t yy_accept[669] [static]

Definition at line 367 of file concat_guts.yy.cc.

flex_int16_t yy_base[678] [static]

Definition at line 491 of file concat_guts.yy.cc.

YY_BUFFER_STATE* yy_buffer_stack = 0 [static]

Stack as an array.

Definition at line 247 of file concat_guts.yy.cc.

Referenced by yy_init_globals(), yyensure_buffer_stack(), and yylex_destroy().

size_t yy_buffer_stack_max = 0 [static]

capacity of stack.

Definition at line 246 of file concat_guts.yy.cc.

Referenced by yy_init_globals(), and yyensure_buffer_stack().

size_t yy_buffer_stack_top = 0 [static]

index of top of stack.

Definition at line 245 of file concat_guts.yy.cc.

Referenced by yy_init_globals(), yyensure_buffer_stack(), yypop_buffer_state(), and yypush_buffer_state().

char* yy_c_buf_p = (char *) 0 [static]

Definition at line 270 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), yy_get_next_buffer(), yy_get_previous_state(), and yy_try_NUL_trans().

flex_int16_t yy_chk[2757] [static]

Definition at line 954 of file concat_guts.yy.cc.

flex_int16_t yy_def[678] [static]

Definition at line 569 of file concat_guts.yy.cc.

int yy_did_buffer_switch_on_eof [static]

Definition at line 277 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), yy_switch_to_buffer(), yypop_buffer_state(), and yypush_buffer_state().

flex_int32_t yy_ec[256] [static]

Definition at line 444 of file concat_guts.yy.cc.

int yy_flex_debug = 0

Definition at line 1265 of file concat_guts.yy.cc.

int yy_flex_debug

Definition at line 1265 of file concat_guts.yy.cc.

char yy_hold_char [static]

Definition at line 265 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), yy_load_buffer_state(), yy_switch_to_buffer(), and yypush_buffer_state().

int yy_init = 0 [static]

Definition at line 271 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), and yy_init_globals().

char* yy_last_accepting_cpos [static]

Definition at line 1262 of file concat_guts.yy.cc.

yy_state_type yy_last_accepting_state [static]

Definition at line 1261 of file concat_guts.yy.cc.

flex_int32_t yy_meta[96] [static]

Initial value:

    {   0,
        1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1

    }

Definition at line 476 of file concat_guts.yy.cc.

int yy_n_chars [static]

Definition at line 266 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), yy_get_next_buffer(), yy_load_buffer_state(), yy_switch_to_buffer(), and yypush_buffer_state().

flex_int16_t yy_nxt[2757] [static]

Definition at line 647 of file concat_guts.yy.cc.

int yy_start = 0 [static]

Definition at line 272 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), yy_get_previous_state(), and yy_init_globals().

FILE* yyin = (FILE *) 0

Definition at line 332 of file concat_guts.yy.cc.

FILE* yyin

Definition at line 332 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), yy_init_globals(), yy_load_buffer_state(), yyget_in(), yyrestart(), and yyset_in().

int yyleng

Definition at line 267 of file concat_guts.yy.cc.

int yyleng

Definition at line 267 of file concat_guts.yy.cc.

Referenced by lexer_parse(), and yyget_leng().

int yylineno = 1

Definition at line 338 of file concat_guts.yy.cc.

int yylineno

Definition at line 338 of file concat_guts.yy.cc.

FILE * yyout = (FILE *) 0

Definition at line 332 of file concat_guts.yy.cc.

FILE * yyout

Definition at line 332 of file concat_guts.yy.cc.

Referenced by concat_parse(), lexer_parse(), yy_init_globals(), yyget_out(), and yyset_out().

char* yytext

Definition at line 1274 of file concat_guts.yy.cc.

char* yytext

Definition at line 1274 of file concat_guts.yy.cc.

Generated on Mon Feb 12 18:23:45 2007 for lestes by doxygen 1.5.1-20070107