pp_lex_guts.yy.cc File Reference

C++ preprocessor lexical analyser. More...

This graph shows which files directly or indirectly include 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_stateYY_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_STATEyy_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

Define Documentation

#define ADVANCE   current_utb->advance(yyleng)

Skips all tokens comprising the current rule.

#define BEGIN   (yy_start) = 1 + 2 *

#define directive   3

#define directive_name   4

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

avoiding implicit rules

#define EOB_ACT_CONTINUE_SCAN   0

#define EOB_ACT_END_OF_FILE   1

#define EOB_ACT_LAST_MATCH   2

#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_LITERAL ( len   )     current_utb->extract_bad_literal(len)

Extracts literal with invalid escape sequences 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_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_LITERAL ( len   )     current_utb->extract_ucn_literal(len)

Extracts literal 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_UNTIL ( stop   )     current_utb->extract_until(stop)

Extracts ordinary sequence until stop character from buffer.

#define FLEX_BETA

#define FLEX_SCANNER

#define include   1

#define INITIAL   0

#define INT16_MAX   (32767)

#define INT16_MIN   (-32767-1)

#define INT32_MAX   (2147483647)

#define INT32_MIN   (-2147483647-1)

#define INT8_MAX   (127)

#define INT8_MIN   (-128)

#define line   2

#define LOCGET   current_ppl->location_create()

Returns the saved location.

#define LOCSAVE   current_ppl->location_save()

Saves location of the next token in buffer.

#define PEEK   current_utb->peek_front()

Returns next token from buffer.

#define REJECT   reject_used_but_not_detected

#define SKIP ( num   )     current_utb->advance(num)

Skips supplied count of tokens.

#define UINT16_MAX   (65535U)

#define UINT32_MAX   (4294967295U)

#define UINT8_MAX   (255U)

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

 
#define YY_AT_BOL (  )     (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

#define YY_BREAK   break;

#define YY_BUF_SIZE   16384

#define YY_BUFFER_EOF_PENDING   2

#define YY_BUFFER_NEW   0

#define YY_BUFFER_NORMAL   1

#define YY_CURRENT_BUFFER

Value:

#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]

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

Defines prototype for flex parser function.

#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;

#define YY_END_OF_BUFFER   181

#define YY_END_OF_BUFFER_CHAR   0

#define YY_EXIT_FAILURE   2

#define YY_EXTRA_TYPE   void *

#define YY_FATAL_ERROR ( msg   )     yy_fatal_error( msg )

#define YY_FLEX_MAJOR_VERSION   2

#define YY_FLEX_MINOR_VERSION   5

#define YY_FLEX_SUBMINOR_VERSION   33

#define YY_FLUSH_BUFFER   yy_flush_buffer(YY_CURRENT_BUFFER )

#define YY_INPUT ( buf,
result,
max_size   ) 

Value:

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

#define YY_INT_ALIGNED   short int

#define YY_LESS_LINENO (  ) 

#define YY_MORE_ADJ   0

#define yy_new_buffer   yy_create_buffer

#define YY_NEW_FILE   yyrestart(yyin )

#define YY_NO_INPUT   1

#define YY_NULL   0

#define YY_NUM_RULES   180

#define YY_READ_BUF_SIZE   8192

#define YY_RESTORE_YY_MORE_OFFSET

#define YY_RULE_SETUP   YY_USER_ACTION

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

#define yy_set_bol ( at_bol   ) 

Value:

#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; \
        }

#define YY_SKIP_YYWRAP

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

#define YY_START_STACK_INCR   25

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

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

#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.

#define yyconst

#define yyless (  ) 

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 )

#define yyless (  ) 

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 )

 
#define yymore (  )     yymore_used_but_not_detected

#define YYSTATE   YY_START

#define YYTABLES_NAME   "yytables"

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

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

#define yytext_ptr   yytext

#define yywrap (  )     1


Typedef Documentation

typedef short int flex_int16_t

typedef int flex_int32_t

typedef signed char flex_int8_t

typedef unsigned short int flex_uint16_t

typedef unsigned int flex_uint32_t

typedef unsigned char flex_uint8_t

typedef struct yy_buffer_state* YY_BUFFER_STATE

typedef unsigned char YY_CHAR

typedef unsigned int yy_size_t

typedef int yy_state_type


Function Documentation

lstring escape_nonprintable ( const lstring &  inp  ) 

ptr< pp_token > lexer_parse ( bool  line_start  ) 

The main scanner function which does all the work.

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]

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]

static yy_state_type yy_get_previous_state ( void   )  [static]

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

static int yy_init_globals ( void   )  [static]

static void yy_load_buffer_state ( void   )  [static]

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]

void* yyalloc ( yy_size_t   ) 

static void yyensure_buffer_stack ( void   )  [static]

void yyfree ( void *   ) 

int yyget_debug ( void   ) 

FILE* yyget_in ( void   ) 

Get the input stream.

int yyget_leng ( void   ) 

Get the length of the current token.

int yyget_lineno ( void   ) 

Get the current line number.

FILE* yyget_out ( void   ) 

Get the output stream.

char* yyget_text ( void   ) 

Get the current token.

int yylex_destroy ( void   ) 

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  ) 

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

void yyset_lineno ( int  line_number  ) 

Set the current line number.

Parameters:
line_number 

void yyset_out ( FILE *  out_str  ) 


Variable Documentation

pp_lex* current_ppl [static]

Current wrapper class, which will be live when used.

ucn_token_buffer* current_utb [static]

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

flex_int16_t yy_accept[1094] [static]

flex_int16_t yy_base[1204] [static]

YY_BUFFER_STATE* yy_buffer_stack = 0 [static]

Stack as an array.

size_t yy_buffer_stack_max = 0 [static]

capacity of stack.

size_t yy_buffer_stack_top = 0 [static]

index of top of stack.

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

flex_int16_t yy_chk[15282] [static]

flex_int16_t yy_def[1204] [static]

int yy_did_buffer_switch_on_eof [static]

flex_int32_t yy_ec[256] [static]

int yy_flex_debug = 0

int yy_flex_debug

char yy_hold_char [static]

int yy_init = 0 [static]

char* yy_last_accepting_cpos [static]

yy_state_type yy_last_accepting_state [static]

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

    }

int yy_n_chars [static]

flex_int16_t yy_nxt[15282] [static]

int yy_start = 0 [static]

FILE* yyin = (FILE *) 0

FILE* yyin

int yyleng

int yyleng

int yylineno = 1

int yylineno

FILE * yyout = (FILE *) 0

FILE * yyout

char* yytext

char* yytext


Generated on Mon Feb 12 18:31:01 2007 for lestes by doxygen 1.5.1-20070107