|
|
@ -8,7 +8,7 @@ |
|
|
|
#define FLEX_SCANNER |
|
|
|
#define YY_FLEX_MAJOR_VERSION 2 |
|
|
|
#define YY_FLEX_MINOR_VERSION 6 |
|
|
|
#define YY_FLEX_SUBMINOR_VERSION 0 |
|
|
|
#define YY_FLEX_SUBMINOR_VERSION 1 |
|
|
|
#if YY_FLEX_SUBMINOR_VERSION > 0 |
|
|
|
#define FLEX_BETA |
|
|
|
#endif |
|
|
@ -87,25 +87,13 @@ typedef unsigned int flex_uint32_t; |
|
|
|
|
|
|
|
#endif /* ! FLEXINT_H */ |
|
|
|
|
|
|
|
#ifdef __cplusplus |
|
|
|
|
|
|
|
/* The "const" storage-class-modifier is valid. */ |
|
|
|
#define YY_USE_CONST |
|
|
|
|
|
|
|
#else /* ! __cplusplus */ |
|
|
|
|
|
|
|
/* C99 requires __STDC__ to be defined as 1. */ |
|
|
|
#if defined (__STDC__) |
|
|
|
|
|
|
|
#define YY_USE_CONST |
|
|
|
|
|
|
|
#endif /* defined (__STDC__) */ |
|
|
|
#endif /* ! __cplusplus */ |
|
|
|
|
|
|
|
#ifdef YY_USE_CONST |
|
|
|
/* TODO: this is always defined, so inline it */ |
|
|
|
#define yyconst const |
|
|
|
|
|
|
|
#if defined(__GNUC__) && __GNUC__ >= 3 |
|
|
|
#define yynoreturn __attribute__((__noreturn__)) |
|
|
|
#else |
|
|
|
#define yyconst |
|
|
|
#define yynoreturn |
|
|
|
#endif |
|
|
|
|
|
|
|
/* Returned upon end-of-file. */ |
|
|
@ -166,7 +154,7 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE; |
|
|
|
typedef size_t yy_size_t; |
|
|
|
#endif |
|
|
|
|
|
|
|
extern yy_size_t yyleng; |
|
|
|
extern int yyleng; |
|
|
|
|
|
|
|
extern FILE *yyin, *yyout; |
|
|
|
|
|
|
@ -205,12 +193,12 @@ struct yy_buffer_state |
|
|
|
/* Size of input buffer in bytes, not including room for EOB |
|
|
|
* characters. |
|
|
|
*/ |
|
|
|
yy_size_t yy_buf_size; |
|
|
|
int yy_buf_size; |
|
|
|
|
|
|
|
/* Number of characters read into yy_ch_buf, not including EOB |
|
|
|
* characters. |
|
|
|
*/ |
|
|
|
yy_size_t yy_n_chars; |
|
|
|
int yy_n_chars; |
|
|
|
|
|
|
|
/* Whether we "own" the buffer - i.e., we know we created it, |
|
|
|
* and can realloc() it to grow it, and should free() it to |
|
|
@ -261,7 +249,7 @@ struct yy_buffer_state |
|
|
|
/* Stack of input buffers. */ |
|
|
|
static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ |
|
|
|
static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ |
|
|
|
static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ |
|
|
|
static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ |
|
|
|
|
|
|
|
/* We provide macros for accessing buffer states in case in the |
|
|
|
* future we want to put the buffer states in a more general |
|
|
@ -280,11 +268,11 @@ static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ |
|
|
|
|
|
|
|
/* yy_hold_char holds the character lost when yytext is formed. */ |
|
|
|
static char yy_hold_char; |
|
|
|
static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */ |
|
|
|
yy_size_t yyleng; |
|
|
|
static int yy_n_chars; /* number of characters read into yy_ch_buf */ |
|
|
|
int yyleng; |
|
|
|
|
|
|
|
/* Points to current character in buffer. */ |
|
|
|
static char *yy_c_buf_p = (char *) 0; |
|
|
|
static char *yy_c_buf_p = NULL; |
|
|
|
static int yy_init = 0; /* whether we need to initialize */ |
|
|
|
static int yy_start = 0; /* start state number */ |
|
|
|
|
|
|
@ -309,7 +297,7 @@ 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 (yyconst char *yy_str ); |
|
|
|
YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len ); |
|
|
|
YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ); |
|
|
|
|
|
|
|
void *yyalloc (yy_size_t ); |
|
|
|
void *yyrealloc (void *,yy_size_t ); |
|
|
@ -343,7 +331,7 @@ void yyfree (void * ); |
|
|
|
|
|
|
|
typedef unsigned char YY_CHAR; |
|
|
|
|
|
|
|
FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; |
|
|
|
FILE *yyin = NULL, *yyout = NULL; |
|
|
|
|
|
|
|
typedef int yy_state_type; |
|
|
|
|
|
|
@ -360,17 +348,14 @@ extern char *yytext; |
|
|
|
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 ); |
|
|
|
#if defined(__GNUC__) && __GNUC__ >= 3 |
|
|
|
__attribute__((__noreturn__)) |
|
|
|
#endif |
|
|
|
static void yy_fatal_error (yyconst char msg[] ); |
|
|
|
static void yynoreturn yy_fatal_error (yyconst char* msg ); |
|
|
|
|
|
|
|
/* Done after the current pattern has been matched and before the |
|
|
|
* corresponding action - sets up yytext. |
|
|
|
*/ |
|
|
|
#define YY_DO_BEFORE_ACTION \ |
|
|
|
(yytext_ptr) = yy_bp; \ |
|
|
|
yyleng = (size_t) (yy_cp - yy_bp); \ |
|
|
|
yyleng = (int) (yy_cp - yy_bp); \ |
|
|
|
(yy_hold_char) = *yy_cp; \ |
|
|
|
*yy_cp = '\0'; \ |
|
|
|
(yy_c_buf_p) = yy_cp; |
|
|
@ -633,7 +618,7 @@ static void update_loc(YYLTYPE *yylloc, char *yytext){ |
|
|
|
<STRING>. { str_putc(*yytext); } |
|
|
|
|
|
|
|
*/ |
|
|
|
#line 637 "lex.yy.c" |
|
|
|
#line 622 "lex.yy.c" |
|
|
|
|
|
|
|
#define INITIAL 0 |
|
|
|
|
|
|
@ -672,7 +657,7 @@ FILE *yyget_out (void ); |
|
|
|
|
|
|
|
void yyset_out (FILE * _out_str ); |
|
|
|
|
|
|
|
yy_size_t yyget_leng (void ); |
|
|
|
int yyget_leng (void ); |
|
|
|
|
|
|
|
char *yyget_text (void ); |
|
|
|
|
|
|
@ -739,7 +724,7 @@ static int input (void ); |
|
|
|
/* This used to be an fputs(), but since the string might contain NUL's, |
|
|
|
* we now use fwrite(). |
|
|
|
*/ |
|
|
|
#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) |
|
|
|
#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) |
|
|
|
#endif |
|
|
|
|
|
|
|
/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, |
|
|
@ -763,7 +748,7 @@ static int input (void ); |
|
|
|
else \ |
|
|
|
{ \ |
|
|
|
errno=0; \ |
|
|
|
while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ |
|
|
|
while ( (result = (int) fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ |
|
|
|
{ \ |
|
|
|
if( errno != EINTR) \ |
|
|
|
{ \ |
|
|
@ -872,7 +857,7 @@ YY_DECL |
|
|
|
#line 85 "tokenizer.lex" |
|
|
|
|
|
|
|
|
|
|
|
#line 876 "lex.yy.c" |
|
|
|
#line 861 "lex.yy.c" |
|
|
|
|
|
|
|
while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ |
|
|
|
{ |
|
|
@ -902,7 +887,7 @@ yy_match: |
|
|
|
if ( yy_current_state >= 148 ) |
|
|
|
yy_c = yy_meta[(unsigned int) yy_c]; |
|
|
|
} |
|
|
|
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; |
|
|
|
yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; |
|
|
|
++yy_cp; |
|
|
|
} |
|
|
|
while ( yy_base[yy_current_state] != 162 ); |
|
|
@ -1293,7 +1278,7 @@ YY_RULE_SETUP |
|
|
|
#line 229 "tokenizer.lex" |
|
|
|
ECHO; |
|
|
|
YY_BREAK |
|
|
|
#line 1297 "lex.yy.c" |
|
|
|
#line 1282 "lex.yy.c" |
|
|
|
case YY_STATE_EOF(INITIAL): |
|
|
|
yyterminate(); |
|
|
|
|
|
|
@ -1480,7 +1465,7 @@ static int yy_get_next_buffer (void) |
|
|
|
|
|
|
|
else |
|
|
|
{ |
|
|
|
yy_size_t num_to_read = |
|
|
|
int num_to_read = |
|
|
|
YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; |
|
|
|
|
|
|
|
while ( num_to_read <= 0 ) |
|
|
@ -1494,7 +1479,7 @@ static int yy_get_next_buffer (void) |
|
|
|
|
|
|
|
if ( b->yy_is_our_buffer ) |
|
|
|
{ |
|
|
|
yy_size_t new_size = b->yy_buf_size * 2; |
|
|
|
int new_size = b->yy_buf_size * 2; |
|
|
|
|
|
|
|
if ( new_size <= 0 ) |
|
|
|
b->yy_buf_size += b->yy_buf_size / 8; |
|
|
@ -1507,7 +1492,7 @@ static int yy_get_next_buffer (void) |
|
|
|
} |
|
|
|
else |
|
|
|
/* Can't grow it, we don't own it. */ |
|
|
|
b->yy_ch_buf = 0; |
|
|
|
b->yy_ch_buf = NULL; |
|
|
|
|
|
|
|
if ( ! b->yy_ch_buf ) |
|
|
|
YY_FATAL_ERROR( |
|
|
@ -1549,9 +1534,9 @@ static int yy_get_next_buffer (void) |
|
|
|
else |
|
|
|
ret_val = EOB_ACT_CONTINUE_SCAN; |
|
|
|
|
|
|
|
if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { |
|
|
|
if ((int) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { |
|
|
|
/* Extend the array by 50%, plus the number we really need. */ |
|
|
|
yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); |
|
|
|
int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); |
|
|
|
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); |
|
|
|
if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) |
|
|
|
YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); |
|
|
@ -1589,7 +1574,7 @@ static int yy_get_next_buffer (void) |
|
|
|
if ( yy_current_state >= 148 ) |
|
|
|
yy_c = yy_meta[(unsigned int) yy_c]; |
|
|
|
} |
|
|
|
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; |
|
|
|
yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; |
|
|
|
} |
|
|
|
|
|
|
|
return yy_current_state; |
|
|
@ -1617,7 +1602,7 @@ static int yy_get_next_buffer (void) |
|
|
|
if ( yy_current_state >= 148 ) |
|
|
|
yy_c = yy_meta[(unsigned int) yy_c]; |
|
|
|
} |
|
|
|
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; |
|
|
|
yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; |
|
|
|
yy_is_jam = (yy_current_state == 147); |
|
|
|
|
|
|
|
return yy_is_jam ? 0 : yy_current_state; |
|
|
@ -1637,7 +1622,7 @@ static int yy_get_next_buffer (void) |
|
|
|
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) |
|
|
|
{ /* need to shift things up to make room */ |
|
|
|
/* +2 for EOB chars. */ |
|
|
|
yy_size_t number_to_move = (yy_n_chars) + 2; |
|
|
|
int number_to_move = (yy_n_chars) + 2; |
|
|
|
char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ |
|
|
|
YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; |
|
|
|
char *source = |
|
|
@ -1649,7 +1634,7 @@ static int yy_get_next_buffer (void) |
|
|
|
yy_cp += (int) (dest - source); |
|
|
|
yy_bp += (int) (dest - source); |
|
|
|
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = |
|
|
|
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; |
|
|
|
(yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; |
|
|
|
|
|
|
|
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) |
|
|
|
YY_FATAL_ERROR( "flex scanner push-back overflow" ); |
|
|
@ -1688,7 +1673,7 @@ static int yy_get_next_buffer (void) |
|
|
|
|
|
|
|
else |
|
|
|
{ /* need more input */ |
|
|
|
yy_size_t offset = (yy_c_buf_p) - (yytext_ptr); |
|
|
|
int offset = (yy_c_buf_p) - (yytext_ptr); |
|
|
|
++(yy_c_buf_p); |
|
|
|
|
|
|
|
switch ( yy_get_next_buffer( ) ) |
|
|
@ -1712,7 +1697,7 @@ static int yy_get_next_buffer (void) |
|
|
|
case EOB_ACT_END_OF_FILE: |
|
|
|
{ |
|
|
|
if ( yywrap( ) ) |
|
|
|
return EOF; |
|
|
|
return 0; |
|
|
|
|
|
|
|
if ( ! (yy_did_buffer_switch_on_eof) ) |
|
|
|
YY_NEW_FILE; |
|
|
@ -1960,7 +1945,7 @@ void yypop_buffer_state (void) |
|
|
|
*/ |
|
|
|
static void yyensure_buffer_stack (void) |
|
|
|
{ |
|
|
|
yy_size_t num_to_alloc; |
|
|
|
int num_to_alloc; |
|
|
|
|
|
|
|
if (!(yy_buffer_stack)) { |
|
|
|
|
|
|
@ -1968,7 +1953,7 @@ static void yyensure_buffer_stack (void) |
|
|
|
* 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; // After all that talk, this was set to 1 anyways... |
|
|
|
num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ |
|
|
|
(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc |
|
|
|
(num_to_alloc * sizeof(struct yy_buffer_state*) |
|
|
|
); |
|
|
@ -2015,7 +2000,7 @@ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) |
|
|
|
base[size-2] != YY_END_OF_BUFFER_CHAR || |
|
|
|
base[size-1] != YY_END_OF_BUFFER_CHAR ) |
|
|
|
/* They forgot to leave room for the EOB's. */ |
|
|
|
return 0; |
|
|
|
return NULL; |
|
|
|
|
|
|
|
b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); |
|
|
|
if ( ! b ) |
|
|
@ -2024,7 +2009,7 @@ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) |
|
|
|
b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ |
|
|
|
b->yy_buf_pos = b->yy_ch_buf = base; |
|
|
|
b->yy_is_our_buffer = 0; |
|
|
|
b->yy_input_file = 0; |
|
|
|
b->yy_input_file = NULL; |
|
|
|
b->yy_n_chars = b->yy_buf_size; |
|
|
|
b->yy_is_interactive = 0; |
|
|
|
b->yy_at_bol = 1; |
|
|
@ -2047,7 +2032,7 @@ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) |
|
|
|
YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) |
|
|
|
{ |
|
|
|
|
|
|
|
return yy_scan_bytes(yystr,strlen(yystr) ); |
|
|
|
return yy_scan_bytes(yystr,(int) strlen(yystr) ); |
|
|
|
} |
|
|
|
|
|
|
|
/** Setup the input buffer state to scan the given bytes. The next call to yylex() will |
|
|
@ -2057,7 +2042,7 @@ YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) |
|
|
|
* |
|
|
|
* @return the newly allocated buffer state object. |
|
|
|
*/ |
|
|
|
YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len ) |
|
|
|
YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len ) |
|
|
|
{ |
|
|
|
YY_BUFFER_STATE b; |
|
|
|
char *buf; |
|
|
@ -2065,7 +2050,7 @@ YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len |
|
|
|
yy_size_t i; |
|
|
|
|
|
|
|
/* Get memory for full buffer, including space for trailing EOB's. */ |
|
|
|
n = _yybytes_len + 2; |
|
|
|
n = (yy_size_t) _yybytes_len + 2; |
|
|
|
buf = (char *) yyalloc(n ); |
|
|
|
if ( ! buf ) |
|
|
|
YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); |
|
|
@ -2091,7 +2076,7 @@ YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len |
|
|
|
#define YY_EXIT_FAILURE 2 |
|
|
|
#endif |
|
|
|
|
|
|
|
static void yy_fatal_error (yyconst char* msg ) |
|
|
|
static void yynoreturn yy_fatal_error (yyconst char* msg ) |
|
|
|
{ |
|
|
|
(void) fprintf( stderr, "%s\n", msg ); |
|
|
|
exit( YY_EXIT_FAILURE ); |
|
|
@ -2144,7 +2129,7 @@ FILE *yyget_out (void) |
|
|
|
/** Get the length of the current token. |
|
|
|
* |
|
|
|
*/ |
|
|
|
yy_size_t yyget_leng (void) |
|
|
|
int yyget_leng (void) |
|
|
|
{ |
|
|
|
return yyleng; |
|
|
|
} |
|
|
@ -2200,10 +2185,10 @@ static int yy_init_globals (void) |
|
|
|
* This function is called from yylex_destroy(), so don't allocate here. |
|
|
|
*/ |
|
|
|
|
|
|
|
(yy_buffer_stack) = 0; |
|
|
|
(yy_buffer_stack) = NULL; |
|
|
|
(yy_buffer_stack_top) = 0; |
|
|
|
(yy_buffer_stack_max) = 0; |
|
|
|
(yy_c_buf_p) = (char *) 0; |
|
|
|
(yy_c_buf_p) = NULL; |
|
|
|
(yy_init) = 0; |
|
|
|
(yy_start) = 0; |
|
|
|
|
|
|
@ -2212,8 +2197,8 @@ static int yy_init_globals (void) |
|
|
|
yyin = stdin; |
|
|
|
yyout = stdout; |
|
|
|
#else |
|
|
|
yyin = (FILE *) 0; |
|
|
|
yyout = (FILE *) 0; |
|
|
|
yyin = NULL; |
|
|
|
yyout = NULL; |
|
|
|
#endif |
|
|
|
|
|
|
|
/* For future reference: Set errno on error, since we are called by |
|
|
@ -2271,7 +2256,7 @@ static int yy_flex_strlen (yyconst char * s ) |
|
|
|
|
|
|
|
void *yyalloc (yy_size_t size ) |
|
|
|
{ |
|
|
|
return (void *) malloc( size ); |
|
|
|
return malloc(size); |
|
|
|
} |
|
|
|
|
|
|
|
void *yyrealloc (void * ptr, yy_size_t size ) |
|
|
@ -2284,7 +2269,7 @@ void *yyrealloc (void * ptr, yy_size_t size ) |
|
|
|
* any pointer type to void*, and deal with argument conversions |
|
|
|
* as though doing an assignment. |
|
|
|
*/ |
|
|
|
return (void *) realloc( (char *) ptr, size ); |
|
|
|
return realloc(ptr, size); |
|
|
|
} |
|
|
|
|
|
|
|
void yyfree (void * ptr ) |
|
|
|