pp_lex_guts.yy.cc File Reference

C++ preprocessor lexical analyser. More...

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   180
#define	YY_END_OF_BUFFER   181
#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.")
	avoiding implicit rules
#define	yyterminate()   return pp_token::create(LOCGET,pp_token::TOK_FILE_END)
	Handles encountering real EOF, which should not happen, formal definition.
#define	YY_USER_ACTION
	Defines action triggered for each rule.
#define	YY_INPUT(buf, result, max_size)
	Defines flex input function.
#define	YY_DECL   ptr<pp_token> lexer_parse(bool line_start)
	Defines prototype for flex parser function.
#define	ADVANCE   current_utb->advance(yyleng)
	Skips all tokens comprising the current rule.
#define	SKIP(num)   current_utb->advance(num)
	Skips supplied count of tokens.
#define	PEEK   current_utb->peek_front()
	Returns next token from buffer.
#define	LOCSAVE   current_ppl->location_save()
	Saves location of the next token in buffer.
#define	LOCGET   current_ppl->location_create()
	Returns the saved location.
#define	EXTRACT_UNTIL(stop)   current_utb->extract_until(stop)
	Extracts ordinary sequence until stop character from buffer.
#define	EXTRACT_ORDINARY(len)   current_utb->extract_ordinary(len)
	Extracts ordinary sequence of length len from buffer.
#define	EXTRACT_UCN_IDENTIFIER(len)   current_utb->extract_simple_ucn(len,true)
	Extracts identifier with ucn of length len from buffer.
#define	EXTRACT_UCN_NUMBER(len)   current_utb->extract_simple_ucn(len,false)
	Extracts number with ucn of length len from buffer.
#define	EXTRACT_BAD_IDENTIFIER(len)   current_utb->extract_invalid_ucn(len,true)
	Extracts identifier with bad ucn of length len from buffer.
#define	EXTRACT_BAD_NUMBER(len)   current_utb->extract_invalid_ucn(len,false)
	Extracts number with bad ucn of length len from buffer.
#define	EXTRACT_UCN_LITERAL(len)   current_utb->extract_ucn_literal(len)
	Extracts literal of length len from buffer.
#define	EXTRACT_BAD_LITERAL(len)   current_utb->extract_bad_literal(len)
	Extracts literal with invalid escape sequences of length len from buffer.
#define	YY_NO_INPUT   1
#define	INITIAL   0
#define	include   1
#define	line   2
#define	directive   3
#define	directive_name   4
#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[])
lstring	escape_nonprintable (const lstring &inp)
ptr< pp_token >	lexer_parse (bool line_start)
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 [1094]
static flex_int32_t	yy_ec [256]
static flex_int32_t	yy_meta [100]
static flex_int16_t	yy_base [1204]
static flex_int16_t	yy_def [1204]
static flex_int16_t	yy_nxt [15282]
static flex_int16_t	yy_chk [15282]
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
static pp_lex *	current_ppl
	Current wrapper class, which will be live when used.
static ucn_token_buffer *	current_utb
	Current ucn token buffer, which will be live when used.

---

Detailed Description

C++ preprocessor lexical analyser.

Performs lexical analysis of incoming text, forming preprocessor tokens. Should only be called by pp_lex objects, which ensure proper connection.

Because flex can only handle 7 bit input, ucn tokens are stored outside in an synchronized buffer and flex processes only the corresponding character classes: end of file, translated ucn and each basic source character is represented in its own class. Basic source characters character classes values are encoded in ASCII, independently on the character set flex operates in.

Author:

pt

Definition in file pp_lex_guts.yy.cc.

---

Define Documentation

#define ADVANCE   current_utb->advance(yyleng)

Skips all tokens comprising the current rule.

Definition at line 4314 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse().

#define BEGIN   (yy_start) = 1 + 2 *

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

#define directive   3

Definition at line 4389 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse(), and lestes::lang::cplus::lex::evaluator::process_directive().

#define directive_name   4

Definition at line 4390 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse().

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

avoiding implicit rules

Definition at line 4266 of file pp_lex_guts.yy.cc.

#define EOB_ACT_CONTINUE_SCAN   0

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

#define EOB_ACT_END_OF_FILE   1

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

#define EOB_ACT_LAST_MATCH   2

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

#define EXTRACT_BAD_IDENTIFIER

(

len

)

current_utb->extract_invalid_ucn(len,true)

Extracts identifier with bad ucn of length len from buffer.

Definition at line 4332 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse().

#define EXTRACT_BAD_LITERAL

(

len

)

current_utb->extract_bad_literal(len)

Extracts literal with invalid escape sequences of length len from buffer.

Definition at line 4338 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse().

#define EXTRACT_BAD_NUMBER

(

len

)

current_utb->extract_invalid_ucn(len,false)

Extracts number with bad ucn of length len from buffer.

Definition at line 4334 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse().

#define EXTRACT_ORDINARY

(

len

)

current_utb->extract_ordinary(len)

Extracts ordinary sequence of length len from buffer.

Definition at line 4326 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse().

#define EXTRACT_UCN_IDENTIFIER

(

len

)

current_utb->extract_simple_ucn(len,true)

Extracts identifier with ucn of length len from buffer.

Definition at line 4328 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse().

#define EXTRACT_UCN_LITERAL

(

len

)

current_utb->extract_ucn_literal(len)

Extracts literal of length len from buffer.

Definition at line 4336 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse().

#define EXTRACT_UCN_NUMBER

(

len

)

current_utb->extract_simple_ucn(len,false)

Extracts number with ucn of length len from buffer.

Definition at line 4330 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse().

#define EXTRACT_UNTIL

(

stop

)

current_utb->extract_until(stop)

Extracts ordinary sequence until stop character from buffer.

Definition at line 4324 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse().

#define FLEX_BETA

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

#define FLEX_SCANNER

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

#define include   1

Definition at line 4387 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse().

#define INITIAL   0

Definition at line 4386 of file pp_lex_guts.yy.cc.

#define INT16_MAX   (32767)

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

#define INT16_MIN   (-32767-1)

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

#define INT32_MAX   (2147483647)

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

#define INT32_MIN   (-2147483647-1)

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

#define INT8_MAX   (127)

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

#define INT8_MIN   (-128)

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

#define line   2

Definition at line 4388 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse().

#define LOCGET   current_ppl->location_create()

Returns the saved location.

Definition at line 4322 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse().

#define LOCSAVE   current_ppl->location_save()

Saves location of the next token in buffer.

Definition at line 4320 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse().

#define PEEK   current_utb->peek_front()

Returns next token from buffer.

Definition at line 4318 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse().

#define REJECT   reject_used_but_not_detected

Definition at line 4192 of file pp_lex_guts.yy.cc.

#define SKIP

(

num

)

current_utb->advance(num)

Skips supplied count of tokens.

Definition at line 4316 of file pp_lex_guts.yy.cc.

Referenced by lexer_parse().

#define UINT16_MAX   (65535U)

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

#define UINT32_MAX   (4294967295U)

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

#define UINT8_MAX   (255U)

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

#define unput

(

c

)

yyunput( c, (yytext_ptr) )

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

 

#define YY_AT_BOL

(

)

(YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

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

#define YY_BREAK   break;

Definition at line 4525 of file pp_lex_guts.yy.cc.

#define YY_BUF_SIZE   16384

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

#define YY_BUFFER_EOF_PENDING   2

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

#define YY_BUFFER_NEW   0

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

#define YY_BUFFER_NORMAL   1

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

#define YY_CURRENT_BUFFER

Value:

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

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

#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]

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

#define YY_DECL   ptr<pp_token> lexer_parse(bool line_start)

Defines prototype for flex parser function.

Definition at line 4311 of file pp_lex_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 pp_lex_guts.yy.cc.

#define YY_END_OF_BUFFER   181

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

#define YY_END_OF_BUFFER_CHAR   0

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

#define YY_EXIT_FAILURE   2

Definition at line 7394 of file pp_lex_guts.yy.cc.

#define YY_EXTRA_TYPE   void *

Definition at line 4401 of file pp_lex_guts.yy.cc.

#define YY_FATAL_ERROR

(

msg

)

yy_fatal_error( msg )

Definition at line 4500 of file pp_lex_guts.yy.cc.

#define YY_FLEX_MAJOR_VERSION   2

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

#define YY_FLEX_MINOR_VERSION   5

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

#define YY_FLEX_SUBMINOR_VERSION   33

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

#define YY_FLUSH_BUFFER   yy_flush_buffer(YY_CURRENT_BUFFER )

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

#define YY_INPUT	(	buf,
		result,
		max_size		)

Value:

{ \
        result = current_ppl->yy_input(buf,max_size); \
}

Defines flex input function.

Definition at line 4305 of file pp_lex_guts.yy.cc.

#define YY_INT_ALIGNED   short int

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

#define YY_LESS_LINENO

(

n

)

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

#define YY_MORE_ADJ   0

Definition at line 4194 of file pp_lex_guts.yy.cc.

#define yy_new_buffer   yy_create_buffer

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

#define YY_NEW_FILE   yyrestart(yyin )

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

#define YY_NO_INPUT   1

Definition at line 4348 of file pp_lex_guts.yy.cc.

#define YY_NULL   0

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

#define YY_NUM_RULES   180

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

#define YY_READ_BUF_SIZE   8192

Definition at line 4438 of file pp_lex_guts.yy.cc.

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 4195 of file pp_lex_guts.yy.cc.

#define YY_RULE_SETUP   YY_USER_ACTION

Definition at line 4528 of file pp_lex_guts.yy.cc.

#define YY_SC_TO_UI

(

c

)

((unsigned int) (unsigned char) c)

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

#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 pp_lex_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 pp_lex_guts.yy.cc.

#define YY_SKIP_YYWRAP

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

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

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

#define YY_START_STACK_INCR   25

Definition at line 4495 of file pp_lex_guts.yy.cc.

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

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

#define YY_STATE_EOF

(

state

)

(YY_END_OF_BUFFER + state + 1)

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

#define YY_USER_ACTION

Value:

{ \
        /* avoid the warning: address requested for `yy_act', which is declared `register' */ \
        int copy_yy_act = yy_act ; \
        pp_lex_guts_logger << "Rule #" << copy_yy_act << " matched `" << escape_nonprintable(yytext) << "'\n" << msg::eolog; \
}

Defines action triggered for each rule.

Definition at line 4297 of file pp_lex_guts.yy.cc.

#define yyconst

Definition at line 95 of file pp_lex_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 7407 of file pp_lex_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 7407 of file pp_lex_guts.yy.cc.

 

#define yymore

(

)

yymore_used_but_not_detected

Definition at line 4193 of file pp_lex_guts.yy.cc.

#define YYSTATE   YY_START

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

#define YYTABLES_NAME   "yytables"

Definition at line 7597 of file pp_lex_guts.yy.cc.

 

#define yyterminate

(

)

return pp_token::create(LOCGET,pp_token::TOK_FILE_END)

Handles encountering real EOF, which should not happen, formal definition.

Definition at line 4279 of file pp_lex_guts.yy.cc.

#define yytext_ptr   yytext

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

#define yywrap

(

n

)

1

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

---

Typedef Documentation

typedef short int flex_int16_t

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

typedef int flex_int32_t

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

typedef signed char flex_int8_t

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

typedef unsigned short int flex_uint16_t

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

typedef unsigned int flex_uint32_t

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

typedef unsigned char flex_uint8_t

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

typedef struct yy_buffer_state* YY_BUFFER_STATE

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

typedef unsigned char YY_CHAR

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

typedef unsigned int yy_size_t

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

typedef int yy_state_type

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

---

Function Documentation

lstring escape_nonprintable

(

const lstring &

inp

)

Definition at line 4281 of file pp_lex_guts.yy.cc.

{
   ::std::stringbuf sb;
   ::std::ostream os(&sb);
   
   for (lstring::const_iterator it = inp.begin(), end = inp.end(); it != end; ++it) {
      char c = *it;
      if (isprint(c)) 
         os << c;
      else
         os << "\\x" << ::std::hex << ::std::setfill('0') << ::std::setw(2) << (ulint)c;
   }
   return sb.str();
}

ptr< pp_token > lexer_parse

(

bool

line_start

)

The main scanner function which does all the work.

Definition at line 4533 of file pp_lex_guts.yy.cc.

References ADVANCE, BEGIN, directive, directive_name, ECHO, lestes::lang::cplus::lex::empty_character_constant(), EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, lestes::msg::eolog, EXTRACT_BAD_IDENTIFIER, EXTRACT_BAD_LITERAL, EXTRACT_BAD_NUMBER, EXTRACT_ORDINARY, EXTRACT_UCN_IDENTIFIER, EXTRACT_UCN_LITERAL, EXTRACT_UCN_NUMBER, EXTRACT_UNTIL, include, INITIAL, line, loc, LOCGET, LOCSAVE, lestes::lang::cplus::lex::missing_terminating_dquote(), lestes::lang::cplus::lex::missing_terminating_quote(), PEEK, lestes::report(), SKIP, 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_ERROR, 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, lestes::lang::cplus::lex::unterminated_comment(), 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, yyleng, yyless, yyout, yyterminate, yytext_ptr, and yywrap.

Referenced by lestes::lang::cplus::lex::pp_lex::read().

{
        register yy_state_type yy_current_state;
        register char *yy_cp, *yy_bp;
        register int yy_act;
    
   if (line_start)
      BEGIN(directive);

        if ( !(yy_init) )
                {
                (yy_init) = 1;

#ifdef YY_USER_INIT
                YY_USER_INIT;
#endif

                if ( ! (yy_start) )
                        (yy_start) = 1; /* first start state */

                if ( ! yyin )
                        yyin = stdin;

                if ( ! yyout )
                        yyout = stdout;

                if ( ! YY_CURRENT_BUFFER ) {
                        yyensure_buffer_stack ();
                        YY_CURRENT_BUFFER_LVALUE =
                                yy_create_buffer(yyin,YY_BUF_SIZE );
                }

                yy_load_buffer_state( );
                }

        while ( 1 )             /* loops until end-of-file is reached */
                {
                yy_cp = (yy_c_buf_p);

                /* Support of yytext. */
                *yy_cp = (yy_hold_char);

                /* yy_bp points to the position in yy_ch_buf of the start of
                 * the current run.
                 */
                yy_bp = yy_cp;

                yy_current_state = (yy_start);
yy_match:
                do
                        {
                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
                        if ( yy_accept[yy_current_state] )
                                {
                                (yy_last_accepting_state) = yy_current_state;
                                (yy_last_accepting_cpos) = yy_cp;
                                }
                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                                {
                                yy_current_state = (int) yy_def[yy_current_state];
                                if ( yy_current_state >= 1094 )
                                        yy_c = yy_meta[(unsigned int) yy_c];
                                }
                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
                        ++yy_cp;
                        }
                while ( yy_base[yy_current_state] != 15182 );

yy_find_action:
                yy_act = yy_accept[yy_current_state];
                if ( yy_act == 0 )
                        { /* have to back up */
                        yy_cp = (yy_last_accepting_cpos);
                        yy_current_state = (yy_last_accepting_state);
                        yy_act = yy_accept[yy_current_state];
                        }

                YY_DO_BEFORE_ACTION;

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

                switch ( yy_act )
        { /* beginning of action switch */
                        case 0: /* must back up */
                        /* undo the effects of YY_DO_BEFORE_ACTION */
                        *yy_cp = (yy_hold_char);
                        yy_cp = (yy_last_accepting_cpos);
                        yy_current_state = (yy_last_accepting_state);
                        goto yy_find_action;

case 1:
/* rule 1 can match eol */
YY_RULE_SETUP
{
   pp_lex_guts_logger << "line comment\n" << msg::eolog;
   
   LOCSAVE;
   /* leave newline in buffer */
        ulint len = yyleng - 1;
        yyless(len);
        SKIP(len);
        return pp_token::create(LOCGET,pp_token::TOK_BLANK);
}
        YY_BREAK
case 2:
/* rule 2 can match eol */
YY_RULE_SETUP
{
   pp_lex_guts_logger << "long comment\n" << msg::eolog;

   LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_BLANK);
}
        YY_BREAK
case 3:
/* rule 3 can match eol */
YY_RULE_SETUP
{
   pp_lex_guts_logger << "unterminated long comment\n" << msg::eolog;

   LOCSAVE;

   /* leave the implicit new line and EOF in buffer */
        ulint len = yyleng - 2;
   yyless(len);
        SKIP(len);

   ptr<source_location> loc = LOCGET;
        
   /* error: eof within comment == unterminated comment */
        report << unterminated_comment << loc;

        return pp_token::create(loc,pp_token::TOK_BLANK);
}
        YY_BREAK
/* character literal without ucn escape sequences */
case 4:
YY_RULE_SETUP
{
   pp_lex_guts_logger << "character literal without escaped ucn\n" << msg::eolog;

   LOCSAVE;
   /* the beginning quote */
        SKIP(1);
        ptr<token_value> tv(EXTRACT_ORDINARY(yyleng - 2));
   /* the ending quote */
        SKIP(1);
        return pp_token::create(LOCGET,pp_token::TOK_CHAR_LIT,tv);
}
        YY_BREAK
/* wide character literal without ucn escape sequences */
case 5:
YY_RULE_SETUP
{
   pp_lex_guts_logger << "wide character literal without escaped ucn\n" << msg::eolog;

   LOCSAVE;
   /* the beginning L and quote */
        SKIP(2);
        ptr<token_value> tv(EXTRACT_ORDINARY(yyleng - 3));
   /* the ending quote */
        SKIP(1);
        return pp_token::create(LOCGET,pp_token::TOK_WCHAR_LIT,tv);
}
        YY_BREAK
/* character literal with ucn escape sequences */
case 6:
YY_RULE_SETUP
{
   pp_lex_guts_logger << "character literal with escaped ucn\n" << msg::eolog;

   LOCSAVE;
   /* the beginning quote */
        SKIP(1);
        ptr<token_value> tv(EXTRACT_UCN_LITERAL(yyleng - 2));
   /* the ending quote */
        SKIP(1);
        return pp_token::create(LOCGET,pp_token::TOK_CHAR_LIT,tv);
}
        YY_BREAK
/* wide character literal with ucn escape sequences */
case 7:
YY_RULE_SETUP
{
   pp_lex_guts_logger << "wide character literal with escaped ucn\n" << msg::eolog;

   LOCSAVE;
   /* the beginning L and quote */
        SKIP(2);
        ptr<token_value> tv(EXTRACT_UCN_LITERAL(yyleng - 3));
   /* the ending quote */
        SKIP(1);
        return pp_token::create(LOCGET,pp_token::TOK_WCHAR_LIT,tv);
}
        YY_BREAK
/* empty, malformed or unterminated character literal */
case 8:
/* rule 8 can match eol */
YY_RULE_SETUP
{
   pp_lex_guts_logger << "character literal with errors\n" << msg::eolog;

   LOCSAVE;

   ptr<source_location> loc = LOCGET;
   
   bool empty = false;
   /* the beginning quote */
        SKIP(1);
        ptr<token_value> tv;
   if (yyleng == 2) {
      /* empty character literal */
      report << empty_character_constant << loc;
      empty = true;
   } else {
      tv = EXTRACT_BAD_LITERAL(yyleng - 2);
      empty = tv->content_get().size() == 0;
   }
   
   if (empty) {
      /* make nonempty character literal */
      tv = token_value::create("\\0");
   }

   ptr<ucn_token> ut = PEEK;
   /* check ending quote */
   if (ut->type_get() == ucn_token::TOK_BASIC &&
         ut->value_get() == character::ascii_quote) {
      /* skip the quote */
           SKIP(1);
   } else {
      /* return the last character */
      yyless(yyleng - 1);
      /* missing terminating ' character */
      report << missing_terminating_quote << loc;
   }

        return pp_token::create(loc,pp_token::TOK_CHAR_LIT,tv);
}
        YY_BREAK
/* empty, malformed or unterminated wide character literal */
case 9:
/* rule 9 can match eol */
YY_RULE_SETUP
{
   pp_lex_guts_logger << "wide character literal with errors\n" << msg::eolog;

   LOCSAVE;
   ptr<source_location> loc = LOCGET;

   bool empty = false;
   /* the beginning L and quote */
        SKIP(2);
        ptr<token_value> tv;
   if (yyleng == 3) {
      /* empty character constant */
      report << empty_character_constant << loc;
      empty = true;
   } else {
      tv = EXTRACT_BAD_LITERAL(yyleng - 3);
      empty = tv->content_get().size() == 0;
   }
   
   if (empty) {
      /* make nonempty wide character literal */
      tv = token_value::create("\\0");
   }

   ptr<ucn_token> ut = PEEK;
   /* check ending quote */
   if (ut->type_get() == ucn_token::TOK_BASIC &&
         ut->value_get() == character::ascii_quote) {
      /* skip the quote */
           SKIP(1);
   } else {
      /* return the last character */
      yyless(yyleng - 1);
      /* missing terminating ' character */
      report << missing_terminating_quote << loc;
   }

        return pp_token::create(LOCGET,pp_token::TOK_WCHAR_LIT,tv);
}
        YY_BREAK
/* string literal without ucn escape sequences */
case 10:
YY_RULE_SETUP
{
   pp_lex_guts_logger << "string literal without escaped ucn\n" << msg::eolog;

   LOCSAVE;
   /* the beginning dquote */
        SKIP(1);
        ptr<token_value> tv(EXTRACT_ORDINARY(yyleng - 2));
   /* the ending dquote */
        SKIP(1);
        return pp_token::create(LOCGET,pp_token::TOK_STRING_LIT,tv);
}
        YY_BREAK
/* wide string literal without ucn escape sequences */
case 11:
YY_RULE_SETUP
{
   pp_lex_guts_logger << "wide string literal without escaped ucn\n" << msg::eolog;

   LOCSAVE;
   /* the beginning L and dquote */
        SKIP(2);
        ptr<token_value> tv(EXTRACT_ORDINARY(yyleng - 3));
   /* the ending dquote */
        SKIP(1);
        return pp_token::create(LOCGET,pp_token::TOK_WSTRING_LIT,tv);
}
        YY_BREAK
/* string literal with ucn escape sequences */
case 12:
YY_RULE_SETUP
{
   pp_lex_guts_logger << "string literal with escaped ucn\n" << msg::eolog;

   LOCSAVE;
   /* the beginning dquote */
        SKIP(1);
        ptr<token_value> tv(EXTRACT_UCN_LITERAL(yyleng - 2));
   /* the ending dquote */
        SKIP(1);
        return pp_token::create(LOCGET,pp_token::TOK_STRING_LIT,tv);
}
        YY_BREAK
/* wide string literal with ucn escape sequences */
case 13:
YY_RULE_SETUP
{
   pp_lex_guts_logger << "wide string literal with escaped ucn\n" << msg::eolog;

   LOCSAVE;
   /* the beginning L and dquote */
        SKIP(2);
        ptr<token_value> tv(EXTRACT_UCN_LITERAL(yyleng - 3));
   /* the ending dquote */
        SKIP(1);
        return pp_token::create(LOCGET,pp_token::TOK_WSTRING_LIT,tv);
}
        YY_BREAK
/* malformed or unterminated string literal */
case 14:
/* rule 14 can match eol */
YY_RULE_SETUP
{
   pp_lex_guts_logger << "wide string literal with errors\n" << msg::eolog;

   LOCSAVE;
   ptr<source_location> loc = LOCGET;

   /* the beginning dquote */
        SKIP(1);
        ptr<token_value> tv(EXTRACT_BAD_LITERAL(yyleng - 2));

   ptr<ucn_token> ut = PEEK;
   /* check ending dquote */
   if (ut->type_get() == ucn_token::TOK_BASIC &&
         ut->value_get() == character::ascii_dquote) {
      /* skip the dquote */
           SKIP(1);
   } else {
      /* return the last character */
      yyless(yyleng - 1);
      /* missing terminating " character */
      report << missing_terminating_dquote << loc;
   }

        return pp_token::create(loc,pp_token::TOK_STRING_LIT,tv);
}
        YY_BREAK
/* malformed or unterminated wide string literal */
case 15:
/* rule 15 can match eol */
YY_RULE_SETUP
{
   pp_lex_guts_logger << "wide string literal with errors\n" << msg::eolog;

   LOCSAVE;
   ptr<source_location> loc = LOCGET;
   
   /* the beginning L and dquote */
        SKIP(2);
        ptr<token_value> tv(EXTRACT_BAD_LITERAL(yyleng - 3));

   ptr<ucn_token> ut = PEEK;
   /* check ending dquote */
   if (ut->type_get() == ucn_token::TOK_BASIC &&
         ut->value_get() == character::ascii_dquote) {
      /* skip the dquote */
           SKIP(1);
   } else {
      /* return the last character */
      yyless(yyleng - 1);
      /* missing terminating " character */
      report << missing_terminating_dquote << loc;
   }

        return pp_token::create(loc,pp_token::TOK_WSTRING_LIT,tv);
}
        YY_BREAK
case 16:
YY_RULE_SETUP
{
   pp_lex_guts_logger << "blanks\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_BLANK);
}
        YY_BREAK
case 17:
/* rule 17 can match eol */
YY_RULE_SETUP
{
   pp_lex_guts_logger << "new line\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_LINE_END);
}
        YY_BREAK
case 18:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "left_bracket\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_LEFT_BRACKET);
}
        YY_BREAK
case 19:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "left_bracket\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_LEFT_BRACKET);
}
        YY_BREAK
case 20:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "right_bracket\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_RIGHT_BRACKET);
}
        YY_BREAK
case 21:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "right_bracket\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_RIGHT_BRACKET);
}
        YY_BREAK
case 22:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "left_brace\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_LEFT_BRACE);
}
        YY_BREAK
case 23:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "left_brace\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_LEFT_BRACE);
}
        YY_BREAK
case 24:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "right_brace\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_RIGHT_BRACE);
}
        YY_BREAK
case 25:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "right_brace\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_RIGHT_BRACE);
}
        YY_BREAK
case 26:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "hash\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_HASH);
}
        YY_BREAK
case 27:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "hash\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_HASH);
}
        YY_BREAK
case 28:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "hash_hash\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_HASH_HASH);
}
        YY_BREAK
case 29:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "hash_hash\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_HASH_HASH);
}
        YY_BREAK
case 30:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "left_par\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_LEFT_PAR);
}
        YY_BREAK
case 31:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "right_par\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_RIGHT_PAR);
}
        YY_BREAK
case 32:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "semicolon\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_SEMICOLON);
}
        YY_BREAK
case 33:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "colon\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_COLON);
}
        YY_BREAK
case 34:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "qmark\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_QMARK);
}
        YY_BREAK
case 35:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "dot\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_DOT);
}
        YY_BREAK
case 36:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "plus\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_PLUS);
}
        YY_BREAK
case 37:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "star\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_STAR);
}
        YY_BREAK
case 38:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "percent\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_PERCENT);
}
        YY_BREAK
case 39:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "slash\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_SLASH);
}
        YY_BREAK
case 40:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "hat\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_HAT);
}
        YY_BREAK
case 41:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "hat\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_HAT);
}
        YY_BREAK
case 42:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "amp\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_AMP);
}
        YY_BREAK
case 43:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "amp\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_AMP);
}
        YY_BREAK
case 44:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "vbar\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_VBAR);
}
        YY_BREAK
case 45:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "vbar\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_VBAR);
}
        YY_BREAK
case 46:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "tilde\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_TILDE);
}
        YY_BREAK
case 47:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "tilde\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_TILDE);
}
        YY_BREAK
case 48:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "emark\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_EMARK);
}
        YY_BREAK
case 49:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "emark\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_EMARK);
}
        YY_BREAK
case 50:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_EQ);
}
        YY_BREAK
case 51:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "lt\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_LT);
}
        YY_BREAK
case 52:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "gt\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_GT);
}
        YY_BREAK
case 53:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "comma\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_COMMA);
}
        YY_BREAK
case 54:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "minus\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_MINUS);
}
        YY_BREAK
case 55:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "colon_colon\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_COLON_COLON);
}
        YY_BREAK
case 56:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "dot_star\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_DOT_STAR);
}
        YY_BREAK
case 57:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "plus_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_PLUS_EQ);
}
        YY_BREAK
case 58:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "minus_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_MINUS_EQ);
}
        YY_BREAK
case 59:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "star_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_STAR_EQ);
}
        YY_BREAK
case 60:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "slash_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_SLASH_EQ);
}
        YY_BREAK
case 61:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "percent_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_PERCENT_EQ);
}
        YY_BREAK
case 62:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "hat_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_HAT_EQ);
}
        YY_BREAK
case 63:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "hat_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_HAT_EQ);
}
        YY_BREAK
case 64:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "amp_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_AMP_EQ);
}
        YY_BREAK
case 65:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "amp_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_AMP_EQ);
}
        YY_BREAK
case 66:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "vbar_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_VBAR_EQ);
}
        YY_BREAK
case 67:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "vbar_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_VBAR_EQ);
}
        YY_BREAK
case 68:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "lt_lt\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_LT_LT);
}
        YY_BREAK
case 69:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "gt_gt\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_GT_GT);
}
        YY_BREAK
case 70:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "gt_gt_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_GT_GT_EQ);
}
        YY_BREAK
case 71:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "lt_lt_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_LT_LT_EQ);
}
        YY_BREAK
case 72:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "eq_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_EQ_EQ);
}
        YY_BREAK
case 73:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "emark_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_EMARK_EQ);
}
        YY_BREAK
case 74:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "emark_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_EMARK_EQ);
}
        YY_BREAK
case 75:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "lt_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_LT_EQ);
}
        YY_BREAK
case 76:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "gt_eq\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_GT_EQ);
}
        YY_BREAK
case 77:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "amp_amp\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_AMP_AMP);
}
        YY_BREAK
case 78:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "amp_amp\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_AMP_AMP);
}
        YY_BREAK
case 79:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "vbar_vbar\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_VBAR_VBAR);
}
        YY_BREAK
case 80:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "vbar_vbar\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create_alternative(LOCGET,pp_token::TOK_VBAR_VBAR);
}
        YY_BREAK
case 81:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "plus_plus\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_PLUS_PLUS);
}
        YY_BREAK
case 82:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "minus_minus\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_MINUS_MINUS);
}
        YY_BREAK
case 83:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "minus_gt_star\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_MINUS_GT_STAR);
}
        YY_BREAK
case 84:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "minus_gt\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_MINUS_GT);
}
        YY_BREAK
case 85:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "dot_dot_dot\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_DOT_DOT_DOT);
}
        YY_BREAK
case 86:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "asm\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_ASM);
}
        YY_BREAK
case 87:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "auto\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_AUTO);
}
        YY_BREAK
case 88:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "bool\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_BOOL);
}
        YY_BREAK
case 89:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "break\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_BREAK);
}
        YY_BREAK
case 90:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "case\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_CASE);
}
        YY_BREAK
case 91:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "catch\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_CATCH);
}
        YY_BREAK
case 92:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "char\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_CHAR);
}
        YY_BREAK
case 93:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "class\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_CLASS);
}
        YY_BREAK
case 94:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "const\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_CONST);
}
        YY_BREAK
case 95:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "const_cast\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_CONST_CAST);
}
        YY_BREAK
case 96:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "continue\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_CONTINUE);
}
        YY_BREAK
case 97:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "default\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_DEFAULT);
}
        YY_BREAK
case 98:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "delete\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_DELETE);
}
        YY_BREAK
case 99:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "do\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_DO);
}
        YY_BREAK
case 100:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "double\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_DOUBLE);
}
        YY_BREAK
case 101:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "dynamic_cast\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_DYNAMIC_CAST);
}
        YY_BREAK
case 102:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "else\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_ELSE);
}
        YY_BREAK
case 103:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "enum\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_ENUM);
}
        YY_BREAK
case 104:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "explicit\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_EXPLICIT);
}
        YY_BREAK
case 105:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "export\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_EXPORT);
}
        YY_BREAK
case 106:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "extern\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_EXTERN);
}
        YY_BREAK
case 107:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "float\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_FLOAT);
}
        YY_BREAK
case 108:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "for\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_FOR);
}
        YY_BREAK
case 109:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "friend\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_FRIEND);
}
        YY_BREAK
case 110:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "goto\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_GOTO);
}
        YY_BREAK
case 111:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "if\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_IF);
}
        YY_BREAK
case 112:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "inline\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_INLINE);
}
        YY_BREAK
case 113:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "int\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_INT);
}
        YY_BREAK
case 114:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "long\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_LONG);
}
        YY_BREAK
case 115:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "mutable\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_MUTABLE);
}
        YY_BREAK
case 116:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "namespace\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_NAMESPACE);
}
        YY_BREAK
case 117:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "new\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_NEW);
}
        YY_BREAK
case 118:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "operator\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_OPERATOR);
}
        YY_BREAK
case 119:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "private\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_PRIVATE);
}
        YY_BREAK
case 120:
YY_RULE_SETUP
{
        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_PROTECTED);
        pp_lex_guts_logger << "protected\n" << msg::eolog;
}
        YY_BREAK
case 121:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "public\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_PUBLIC);
}
        YY_BREAK
case 122:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "register\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_REGISTER);
}
        YY_BREAK
case 123:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "reinterpret_cast\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_REINTERPRET_CAST);
}
        YY_BREAK
case 124:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "return\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_RETURN);
}
        YY_BREAK
case 125:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "short\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_SHORT);
}
        YY_BREAK
case 126:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "signed\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_SIGNED);
}
        YY_BREAK
case 127:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "sizeof\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_SIZEOF);
}
        YY_BREAK
case 128:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "static\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_STATIC);
}
        YY_BREAK
case 129:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "static_cast\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_STATIC_CAST);
}
        YY_BREAK
case 130:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "struct\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_STRUCT);
}
        YY_BREAK
case 131:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "switch\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_SWITCH);
}
        YY_BREAK
case 132:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "template\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_TEMPLATE);
}
        YY_BREAK
case 133:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "this\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_THIS);
}
        YY_BREAK
case 134:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "throw\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_THROW);
}
        YY_BREAK
case 135:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "try\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_TRY);
}
        YY_BREAK
case 136:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "typedef\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_TYPEDEF);
}
        YY_BREAK
case 137:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "typeid\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_TYPEID);
}
        YY_BREAK
case 138:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "typename\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_TYPENAME);
}
        YY_BREAK
case 139:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "union\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_UNION);
}
        YY_BREAK
case 140:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "unsigned\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_UNSIGNED);
}
        YY_BREAK
case 141:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "using\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_USING);
}
        YY_BREAK
case 142:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "virtual\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_VIRTUAL);
}
        YY_BREAK
case 143:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "void\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_VOID);
}
        YY_BREAK
case 144:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "volatile\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_VOLATILE);
}
        YY_BREAK
case 145:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "wchar\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_WCHAR);
}
        YY_BREAK
case 146:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "while\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_WHILE);
}
        YY_BREAK
case 147:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "false\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_BOOL_LIT,token_value::create("false"));
}
        YY_BREAK
case 148:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "false\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_BOOL_LIT,token_value::create("true"));
}
        YY_BREAK
/*
{i}{n}{c}{l}{u}{d}{e} {
        pp_lex_guts_logger << "include\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_INCLUDE);
}

{d}{e}{f}{i}{n}{e} {
        pp_lex_guts_logger << "define\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_DEFINE);
}

{u}{n}{d}{e}{f} {
        pp_lex_guts_logger << "undef\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_UNDEF);
}

{l}{i}{n}{e} {
        pp_lex_guts_logger << "line\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_LINE);
}

{p}{r}{a}{g}{m}{a} {
        pp_lex_guts_logger << "pragma\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_PRAGMA);
}

{e}{r}{r}{o}{r} {
        pp_lex_guts_logger << "error\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_ERROR);
}

{d}{e}{f}{i}{n}{e}{d} {
        pp_lex_guts_logger << "defined\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_DEFINED);
}

{i}{f}{d}{e}{f} {
        pp_lex_guts_logger << "ifdef\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_IFDEF);
}

{i}{f}{n}{d}{e}{f} {
        pp_lex_guts_logger << "ifndef\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_IFNDEF);
}

{e}{l}{i}{f} {
        pp_lex_guts_logger << "elif\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_ELIF);
}

{e}{n}{d}{i}{f} {
        pp_lex_guts_logger << "endif\n" << msg::eolog;

        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_ENDIF);
}
   */
/* pp number, can contain underscore */
case 149:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "preprocessing number\n" << msg::eolog;

        LOCSAVE;
        return pp_token::create(LOCGET,pp_token::TOK_NUMBER_LIT,EXTRACT_ORDINARY(yyleng));
}
        YY_BREAK
/* pp number with ucn */
case 150:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "preprocessing number with ucn\n" << msg::eolog;

        LOCSAVE;
        return pp_token::create(LOCGET,pp_token::TOK_NUMBER_LIT,EXTRACT_UCN_NUMBER(yyleng));
}
        YY_BREAK
/* pp number with bad ucn */
case 151:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "preprocessing number with bad ucn\n" << msg::eolog;

        LOCSAVE;
        return pp_token::create(LOCGET,pp_token::TOK_NUMBER_LIT,EXTRACT_BAD_NUMBER(yyleng));
}
        YY_BREAK
/* pp alphanumeric identifier */
case 152:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "identifier without ucn\n" << msg::eolog;

        LOCSAVE;
        return pp_token::create(LOCGET,pp_token::TOK_IDENT,EXTRACT_ORDINARY(yyleng));
}
        YY_BREAK
/* pp identifier with ucn */
case 153:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "identifier with ucn\n" << msg::eolog;

        LOCSAVE;
        return pp_token::create(LOCGET,pp_token::TOK_IDENT,EXTRACT_UCN_IDENTIFIER(yyleng));
}
        YY_BREAK
/* pp identifier ucn */
case 154:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "identifier with bad ucn\n" << msg::eolog;

        LOCSAVE;
        return pp_token::create(LOCGET,pp_token::TOK_IDENT,EXTRACT_BAD_IDENTIFIER(yyleng));
}
        YY_BREAK
/* start of recognition of directives */
case 155:
/* rule 155 can match eol */
YY_RULE_SETUP
{
        pp_lex_guts_logger << "hash in directive\n" << msg::eolog;

   BEGIN(directive_name);
   
   SKIP(yyleng - 1);
   /* save the location of the # */
        LOCSAVE;
   SKIP(1);

        return pp_token::create(LOCGET,pp_token::TOK_HASH);
}
        YY_BREAK
/* ## is longer than # and requires special rule */
case 156:
/* rule 156 can match eol */
YY_RULE_SETUP
{
        pp_lex_guts_logger << "hash_hash in directive\n" << msg::eolog;

   BEGIN(INITIAL);
   /* return the characters */
   yyless(0);

}
        YY_BREAK
/* not a directive */
case 157:
/* rule 157 can match eol */
YY_RULE_SETUP
{
        pp_lex_guts_logger << "any char in directive\n" << msg::eolog;

   BEGIN(INITIAL);
   /* return the character */
   yyless(0);
}
        YY_BREAK
/* skip padding */
case 158:
/* rule 158 can match eol */
YY_RULE_SETUP
{
        pp_lex_guts_logger << "blanks and comments in directive name\n" << msg::eolog;

   ADVANCE;
   /* continue scanning */
}
        YY_BREAK
case 159:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "define in directive name\n" << msg::eolog;

   BEGIN(INITIAL);
        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_DEFINE);
}
        YY_BREAK
case 160:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "undef in directive name\n" << msg::eolog;

   BEGIN(INITIAL);
        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_UNDEF);
}
        YY_BREAK
case 161:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "pragma in directive name\n" << msg::eolog;

   BEGIN(INITIAL);
        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_PRAGMA);
}
        YY_BREAK
case 162:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "error in directive name\n" << msg::eolog;

   BEGIN(INITIAL);
        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_ERROR);
}
        YY_BREAK
case 163:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "defined in directive name\n" << msg::eolog;

   BEGIN(INITIAL);
        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_DEFINED);
}
        YY_BREAK
case 164:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "if in directive name\n" << msg::eolog;

   BEGIN(INITIAL);
        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_IF);
}
        YY_BREAK
case 165:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "ifdef in directive name\n" << msg::eolog;

   BEGIN(INITIAL);
        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_IFDEF);
}
        YY_BREAK
case 166:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "ifndef in directive name\n" << msg::eolog;

   BEGIN(INITIAL);
        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_IFNDEF);
}
        YY_BREAK
case 167:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "elif in directive name\n" << msg::eolog;

   BEGIN(INITIAL);
        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_ELIF);
}
        YY_BREAK
case 168:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "else in directive name\n" << msg::eolog;

   BEGIN(INITIAL);
        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_ELSE);
}
        YY_BREAK
case 169:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "endif in directive name\n" << msg::eolog;

   BEGIN(INITIAL);
        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_ENDIF);
}
        YY_BREAK
case 170:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "include in directive name\n" << msg::eolog;

   BEGIN(include);
        LOCSAVE;
   ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_INCLUDE);
}
        YY_BREAK
case 171:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "line in directive name\n" << msg::eolog;

        LOCSAVE;
   ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_LINE);
}
        YY_BREAK
/* some other or longer identifier */
case 172:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "other identifier in directive name\n" << msg::eolog;

   BEGIN(INITIAL);
   /* return the identifier */
   yyless(0);
}
        YY_BREAK
/* something else than the above */
case 173:
/* rule 173 can match eol */
YY_RULE_SETUP
{
        pp_lex_guts_logger << "any char in directive name\n" << msg::eolog;

   BEGIN(INITIAL);
   /* return the character */
   yyless(0);
}
        YY_BREAK
/* skip spaces and comments to simplify processing of the following */
case 174:
/* rule 174 can match eol */
YY_RULE_SETUP
{
        pp_lex_guts_logger << "blanks and comments in include\n" << msg::eolog;

        ADVANCE;
   /* continue scanning */
}
        YY_BREAK
/* angle bracketed name */
case 175:
/* rule 175 can match eol */
YY_RULE_SETUP
{
        pp_lex_guts_logger << "angle bracketed name in include\n" << msg::eolog;

   BEGIN(INITIAL);
        LOCSAVE;
        
   SKIP(1);
        /* everything between the '<' '>' is significant */
        ptr<token_value> tv(EXTRACT_UNTIL(character::ascii_gt));
   /* skip the '>' and everything but the newline */
        ulint len = yyleng - tv->content_get().size() - 2;
        SKIP(len);
  
   /* return only the newline */
        yyless(yyleng - 1);

        return pp_token::create(LOCGET,pp_token::TOK_INCL_HCHAR,tv);
}
        YY_BREAK
/* double quoted name */
case 176:
/* rule 176 can match eol */
YY_RULE_SETUP
{
        pp_lex_guts_logger << "double quoted name in include\n" << msg::eolog;

   BEGIN(INITIAL);
        LOCSAVE;
   
   SKIP(1);
        /* everything between the "" is significant, no support for escape sequences */
        ptr<token_value> tv(EXTRACT_UNTIL(character::ascii_dquote));
   /* skip the '"' and everything till but the newline */
        ulint len = yyleng - tv->content_get().size() - 2;
        SKIP(len);
  
   /* return only the newline */
        yyless(yyleng - 1);

        return pp_token::create(LOCGET,pp_token::TOK_INCL_QCHAR,tv);
}
        YY_BREAK
/* catches errors and third type include, which is handled by normal parser */
case 177:
/* rule 177 can match eol */
YY_RULE_SETUP
{
        pp_lex_guts_logger << "any char in include\n" << msg::eolog;

   BEGIN(INITIAL);
        LOCSAVE;
   /* return the character */
        yyless(0);
        return pp_token::create(LOCGET,pp_token::TOK_INCL_SIG);
}
        YY_BREAK
/* special end of file class, not the flex <<EOF>> */
case 178:
YY_RULE_SETUP
{
        pp_lex_guts_logger << "eof\n" << msg::eolog;
   
        LOCSAVE;
        ADVANCE;
        return pp_token::create(LOCGET,pp_token::TOK_FILE_END);
}
        YY_BREAK
/* anything which is not a part of a token; " or ' will not appear here */
case 179:
/* rule 179 can match eol */
YY_RULE_SETUP
{
        pp_lex_guts_logger << "other\n" << msg::eolog;
   
        LOCSAVE;
        return pp_token::create(LOCGET,pp_token::TOK_OTHER,EXTRACT_ORDINARY(yyleng));
}
        YY_BREAK
case 180:
YY_RULE_SETUP
ECHO;
        YY_BREAK
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(include):
case YY_STATE_EOF(line):
case YY_STATE_EOF(directive):
case YY_STATE_EOF(directive_name):
        yyterminate();

        case YY_END_OF_BUFFER:
                {
                /* Amount of text matched not including the EOB char. */
                int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;

                /* Undo the effects of YY_DO_BEFORE_ACTION. */
                *yy_cp = (yy_hold_char);
                YY_RESTORE_YY_MORE_OFFSET

                if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
                        {
                        /* We're scanning a new file or input source.  It's
                         * possible that this happened because the user
                         * just pointed yyin at a new source and called
                         * yylex().  If so, then we have to assure
                         * consistency between YY_CURRENT_BUFFER and our
                         * globals.  Here is the right place to do so, because
                         * this is the first action (other than possibly a
                         * back-up) that will match for the new input source.
                         */
                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
                        YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
                        }

                /* Note that here we test for yy_c_buf_p "<=" to the position
                 * of the first EOB in the buffer, since yy_c_buf_p will
                 * already have been incremented past the NUL character
                 * (since all states make transitions on EOB to the
                 * end-of-buffer state).  Contrast this with the test
                 * in input().
                 */
                if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
                        { /* This was really a NUL. */
                        yy_state_type yy_next_state;

                        (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;

                        yy_current_state = yy_get_previous_state(  );

                        /* Okay, we're now positioned to make the NUL
                         * transition.  We couldn't have
                         * yy_get_previous_state() go ahead and do it
                         * for us because it doesn't know how to deal
                         * with the possibility of jamming (and we don't
                         * want to build jamming into it because then it
                         * will run more slowly).
                         */

                        yy_next_state = yy_try_NUL_trans( yy_current_state );

                        yy_bp = (yytext_ptr) + YY_MORE_ADJ;

                        if ( yy_next_state )
                                {
                                /* Consume the NUL. */
                                yy_cp = ++(yy_c_buf_p);
                                yy_current_state = yy_next_state;
                                goto yy_match;
                                }

                        else
                                {
                                yy_cp = (yy_c_buf_p);
                                goto yy_find_action;
                                }
                        }

                else switch ( yy_get_next_buffer(  ) )
                        {
                        case EOB_ACT_END_OF_FILE:
                                {
                                (yy_did_buffer_switch_on_eof) = 0;

                                if ( yywrap( ) )
                                        {
                                        /* Note: because we've taken care in
                                         * yy_get_next_buffer() to have set up
                                         * yytext, we can now set up
                                         * yy_c_buf_p so that if some total
                                         * hoser (like flex itself) wants to
                                         * call the scanner after we return the
                                         * YY_NULL, it'll still work - another
                                         * YY_NULL will get returned.
                                         */
                                        (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;

                                        yy_act = YY_STATE_EOF(YY_START);
                                        goto do_action;
                                        }

                                else
                                        {
                                        if ( ! (yy_did_buffer_switch_on_eof) )
                                                YY_NEW_FILE;
                                        }
                                break;
                                }

                        case EOB_ACT_CONTINUE_SCAN:
                                (yy_c_buf_p) =
                                        (yytext_ptr) + yy_amount_of_matched_text;

                                yy_current_state = yy_get_previous_state(  );

                                yy_cp = (yy_c_buf_p);
                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                                goto yy_match;

                        case EOB_ACT_LAST_MATCH:
                                (yy_c_buf_p) =
                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];

                                yy_current_state = yy_get_previous_state(  );

                                yy_cp = (yy_c_buf_p);
                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                                goto yy_find_action;
                        }
                break;
                }

        default:
                YY_FATAL_ERROR(
                        "fatal flex scanner internal error--no action found" );
        } /* end of action switch */
                } /* end of scanning one token */
} /* 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.

void yy_delete_buffer

(

YY_BUFFER_STATE

b

)

Destroy the buffer.

Parameters:

b

a buffer created with yy_create_buffer()

static void yy_fatal_error

(

char *

msg

)

[static]

Definition at line 7397 of file pp_lex_guts.yy.cc.

References YY_EXIT_FAILURE.

{
        /* (void) fprintf( stderr, "%s\n", msg ); */
        (void)msg;
        exit( YY_EXIT_FAILURE );
}

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.

static int yy_get_next_buffer

(

void

)

[static]

Definition at line 6875 of file pp_lex_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.

{
        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
        register char *source = (yytext_ptr);
        register int number_to_move, i;
        int ret_val;

        if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
                YY_FATAL_ERROR(
                "fatal flex scanner internal error--end of buffer missed" );

        if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
                { /* Don't try to fill the buffer, so this is an EOF. */
                if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
                        {
                        /* We matched a single character, the EOB, so
                         * treat this as a final EOF.
                         */
                        return EOB_ACT_END_OF_FILE;
                        }

                else
                        {
                        /* We matched some text prior to the EOB, first
                         * process it.
                         */
                        return EOB_ACT_LAST_MATCH;
                        }
                }

        /* Try to read more data. */

        /* First move last chars to start of buffer. */
        number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;

        for ( i = 0; i < number_to_move; ++i )
                *(dest++) = *(source++);

        if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
                /* don't do the read, it's not guaranteed to return an EOF,
                 * just force an EOF
                 */
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;

        else
                {
                        int num_to_read =
                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;

                while ( num_to_read <= 0 )
                        { /* Not enough room in the buffer - grow it. */

                        /* just a shorter name for the current buffer */
                        YY_BUFFER_STATE b = YY_CURRENT_BUFFER;

                        int yy_c_buf_p_offset =
                                (int) ((yy_c_buf_p) - b->yy_ch_buf);

                        if ( b->yy_is_our_buffer )
                                {
                                int new_size = b->yy_buf_size * 2;

                                if ( new_size <= 0 )
                                        b->yy_buf_size += b->yy_buf_size / 8;
                                else
                                        b->yy_buf_size *= 2;

                                b->yy_ch_buf = (char *)
                                        /* Include room in for 2 EOB chars. */
                                        yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
                                }
                        else
                                /* Can't grow it, we don't own it. */
                                b->yy_ch_buf = 0;

                        if ( ! b->yy_ch_buf )
                                YY_FATAL_ERROR(
                                "fatal error - scanner input buffer overflow" );

                        (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];

                        num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
                                                number_to_move - 1;

                        }

                if ( num_to_read > YY_READ_BUF_SIZE )
                        num_to_read = YY_READ_BUF_SIZE;

                /* Read in more data. */
                YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
                        (yy_n_chars), num_to_read );

                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }

        if ( (yy_n_chars) == 0 )
                {
                if ( number_to_move == YY_MORE_ADJ )
                        {
                        ret_val = EOB_ACT_END_OF_FILE;
                        yyrestart(yyin  );
                        }

                else
                        {
                        ret_val = EOB_ACT_LAST_MATCH;
                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
                                YY_BUFFER_EOF_PENDING;
                        }
                }

        else
                ret_val = EOB_ACT_CONTINUE_SCAN;

        (yy_n_chars) += number_to_move;
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;

        (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];

        return ret_val;
}

static yy_state_type yy_get_previous_state

(

void

)

[static]

Definition at line 7001 of file pp_lex_guts.yy.cc.

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

{
        register yy_state_type yy_current_state;
        register char *yy_cp;
    
        yy_current_state = (yy_start);

        for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
                {
                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 99);
                if ( yy_accept[yy_current_state] )
                        {
                        (yy_last_accepting_state) = yy_current_state;
                        (yy_last_accepting_cpos) = yy_cp;
                        }
                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                        {
                        yy_current_state = (int) yy_def[yy_current_state];
                        if ( yy_current_state >= 1094 )
                                yy_c = yy_meta[(unsigned int) yy_c];
                        }
                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
                }

        return yy_current_state;
}

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

Definition at line 7244 of file pp_lex_guts.yy.cc.

References b, YY_CURRENT_BUFFER, and yy_flush_buffer().

{
#if 0
        int oerrno = errno;
#endif
    
        yy_flush_buffer(b );

        b->yy_input_file = file;
        b->yy_fill_buffer = 1;

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

        b->yy_is_interactive = 1;

#if 0
        errno = oerrno;
#endif
}

static int yy_init_globals

(

void

)

[static]

Definition at line 7501 of file pp_lex_guts.yy.cc.

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

{
        /* Initialization is the same as for the non-reentrant scanner.
     * This function is called from yylex_destroy(), so don't allocate here.
     */

    (yy_buffer_stack) = 0;
    (yy_buffer_stack_top) = 0;
    (yy_buffer_stack_max) = 0;
    (yy_c_buf_p) = (char *) 0;
    (yy_init) = 0;
    (yy_start) = 0;

/* Defined in main.c */
#ifdef YY_STDINIT
    yyin = stdin;
    yyout = stdout;
#else
    yyin = (FILE *) 0;
    yyout = (FILE *) 0;
#endif

    /* For future reference: Set errno on error, since we are called by
     * yylex_init()
     */
    return 0;
}

static void yy_load_buffer_state

(

void

)

[static]

Definition at line 7183 of file pp_lex_guts.yy.cc.

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

{
        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
        (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
        yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
        (yy_hold_char) = *(yy_c_buf_p);
}

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.

static yy_state_type yy_try_NUL_trans

(

yy_state_type

current_state

)

[static]

Definition at line 7033 of file pp_lex_guts.yy.cc.

References yy_c_buf_p.

{
        register int yy_is_jam;
        register char *yy_cp = (yy_c_buf_p);

        register YY_CHAR yy_c = 99;
        if ( yy_accept[yy_current_state] )
                {
                (yy_last_accepting_state) = yy_current_state;
                (yy_last_accepting_cpos) = yy_cp;
                }
        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                {
                yy_current_state = (int) yy_def[yy_current_state];
                if ( yy_current_state >= 1094 )
                        yy_c = yy_meta[(unsigned int) yy_c];
                }
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
        yy_is_jam = (yy_current_state == 1093);

        return yy_is_jam ? 0 : yy_current_state;
}

void* yyalloc

(

yy_size_t

)

static void yyensure_buffer_stack

(

void

)

[static]

Definition at line 7354 of file pp_lex_guts.yy.cc.

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

{
        int num_to_alloc;
    
        if (!(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;
                (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
                                                                );
                
                memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
                                
                (yy_buffer_stack_max) = num_to_alloc;
                (yy_buffer_stack_top) = 0;
                return;
        }

        if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){

                /* Increase the buffer to prepare for a possible push. */
                int grow_size = 8 /* arbitrary grow size */;

                num_to_alloc = (yy_buffer_stack_max) + grow_size;
                (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
                                                                ((yy_buffer_stack),
                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
                                                                );

                /* zero only the new slots.*/
                memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
                (yy_buffer_stack_max) = num_to_alloc;
        }
}

void yyfree

(

void *

)

int yyget_debug

(

void

)

Definition at line 7491 of file pp_lex_guts.yy.cc.

{
        return yy_flex_debug;
}

FILE* yyget_in

(

void

)

Get the input stream.

Definition at line 7435 of file pp_lex_guts.yy.cc.

References yyin.

{
        return yyin;
}

int yyget_leng

(

void

)

Get the length of the current token.

Definition at line 7451 of file pp_lex_guts.yy.cc.

References yyleng.

{
        return yyleng;
}

int yyget_lineno

(

void

)

Get the current line number.

Definition at line 7426 of file pp_lex_guts.yy.cc.

{
        
    return yylineno;
}

FILE* yyget_out

(

void

)

Get the output stream.

Definition at line 7443 of file pp_lex_guts.yy.cc.

References yyout.

{
        return yyout;
}

char* yyget_text

(

void

)

Get the current token.

Definition at line 7460 of file pp_lex_guts.yy.cc.

{
        return yytext;
}

int yylex_destroy

(

void

)

Definition at line 7530 of file pp_lex_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().

{
    
    /* Pop the buffer stack, destroying each element. */
        while(YY_CURRENT_BUFFER){
                yy_delete_buffer(YY_CURRENT_BUFFER  );
                YY_CURRENT_BUFFER_LVALUE = NULL;
                yypop_buffer_state();
        }

        /* Destroy the stack itself. */
        yyfree((yy_buffer_stack) );
        (yy_buffer_stack) = NULL;

    /* Reset the globals. This is important in a non-reentrant scanner so the next time
     * yylex() is called, initialization will occur. */
    yy_init_globals( );

    return 0;
}

void yypop_buffer_state

(

void

)

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

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.

void* yyrealloc	(	void *	,
		yy_size_t
	)

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 .

void yyset_debug

(

int

bdebug

)

Definition at line 7496 of file pp_lex_guts.yy.cc.

{
        yy_flex_debug = bdebug ;
}

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 7481 of file pp_lex_guts.yy.cc.

References yyin.

{
        yyin = in_str ;
}

void yyset_lineno

(

int

line_number

)

Set the current line number.

Parameters:

line_number

Definition at line 7469 of file pp_lex_guts.yy.cc.

{
    
    yylineno = line_number;
}

void yyset_out

(

FILE *

out_str

)

Definition at line 7486 of file pp_lex_guts.yy.cc.

References yyout.

{
        yyout = out_str ;
}

---

Variable Documentation

pp_lex* current_ppl [static]

Current wrapper class, which will be live when used.

Definition at line 4273 of file pp_lex_guts.yy.cc.

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

ucn_token_buffer* current_utb [static]

Current ucn token buffer, which will be live when used.

Definition at line 4276 of file pp_lex_guts.yy.cc.

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

flex_int16_t yy_accept[1094] [static]

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

flex_int16_t yy_base[1204] [static]

Definition at line 539 of file pp_lex_guts.yy.cc.

YY_BUFFER_STATE* yy_buffer_stack = 0 [static]

Stack as an array.

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

size_t yy_buffer_stack_max = 0 [static]

capacity of stack.

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

size_t yy_buffer_stack_top = 0 [static]

index of top of stack.

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

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

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

flex_int16_t yy_chk[15282] [static]

Definition at line 2498 of file pp_lex_guts.yy.cc.

flex_int16_t yy_def[1204] [static]

Definition at line 676 of file pp_lex_guts.yy.cc.

int yy_did_buffer_switch_on_eof [static]

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

flex_int32_t yy_ec[256] [static]

Definition at line 492 of file pp_lex_guts.yy.cc.

int yy_flex_debug = 0

Definition at line 4187 of file pp_lex_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 pp_lex_guts.yy.cc.

int yy_init = 0 [static]

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

char* yy_last_accepting_cpos [static]

Definition at line 4184 of file pp_lex_guts.yy.cc.

yy_state_type yy_last_accepting_state [static]

Definition at line 4183 of file pp_lex_guts.yy.cc.

flex_int32_t yy_meta[100] [static]

Initial value:

    {   0,
        1,    1,    1,    2,    1,    1,    1,    1,    1,    1,
        1,    1,    3,    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,    4

    }

Definition at line 524 of file pp_lex_guts.yy.cc.

int yy_n_chars [static]

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

flex_int16_t yy_nxt[15282] [static]

Definition at line 813 of file pp_lex_guts.yy.cc.

int yy_start = 0 [static]

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

FILE* yyin = (FILE *) 0

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

FILE* yyin

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

int yyleng

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

int yyleng

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

int yylineno = 1

Definition at line 338 of file pp_lex_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 pp_lex_guts.yy.cc.

FILE * yyout

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

char* yytext

Definition at line 4196 of file pp_lex_guts.yy.cc.

char* yytext

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

---