From 667173e36293d781e145f40e0d6919cb847af318 Mon Sep 17 00:00:00 2001 From: Carl Worth Date: Wed, 28 Jul 2010 12:33:56 -0700 Subject: glcpp: Add generated source files. This is now consistent with other usage of flex/bison througout mesa, (which is that these generated files are added to source control so that the build system does not require external tools like flex/bison for non-developers). --- src/glsl/glcpp/glcpp-lex.c | 2636 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2636 insertions(+) create mode 100644 src/glsl/glcpp/glcpp-lex.c (limited to 'src/glsl/glcpp/glcpp-lex.c') diff --git a/src/glsl/glcpp/glcpp-lex.c b/src/glsl/glcpp/glcpp-lex.c new file mode 100644 index 0000000000..edf98a4afd --- /dev/null +++ b/src/glsl/glcpp/glcpp-lex.c @@ -0,0 +1,2636 @@ +#line 2 "glcpp/glcpp-lex.c" + +#line 4 "glcpp/glcpp-lex.c" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 +#define YY_FLEX_SUBMINOR_VERSION 35 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include +#include +#include +#include + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +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; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#endif /* ! C99 */ + +#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 +#define yyconst const +#else +#define yyconst +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* An opaque pointer. */ +#ifndef YY_TYPEDEF_YY_SCANNER_T +#define YY_TYPEDEF_YY_SCANNER_T +typedef void* yyscan_t; +#endif + +/* For convenience, these vars (plus the bison vars far below) + are macros in the reentrant scanner. */ +#define yyin yyg->yyin_r +#define yyout yyg->yyout_r +#define yyextra yyg->yyextra_r +#define yyleng yyg->yyleng_r +#define yytext yyg->yytext_r +#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) +#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) +#define yy_flex_debug yyg->yy_flex_debug_r + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yyg->yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yyg->yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE glcpp_restart(yyin ,yyscanner ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + + #define YY_LESS_LINENO(n) + +/* Return all but the first "n" matched characters back to the input stream. */ +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + *yy_cp = yyg->yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yyg->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 unput(c) yyunput( c, yyg->yytext_ptr , yyscanner ) + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + 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 + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via glcpp_restart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + * + * Returns the top of the stack, or NULL. + */ +#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ + ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ + : NULL) + +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] + +void glcpp_restart (FILE *input_file ,yyscan_t yyscanner ); +void glcpp__switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner ); +YY_BUFFER_STATE glcpp__create_buffer (FILE *file,int size ,yyscan_t yyscanner ); +void glcpp__delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner ); +void glcpp__flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner ); +void glcpp_push_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner ); +void glcpp_pop_buffer_state (yyscan_t yyscanner ); + +static void glcpp_ensure_buffer_stack (yyscan_t yyscanner ); +static void glcpp__load_buffer_state (yyscan_t yyscanner ); +static void glcpp__init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner ); + +#define YY_FLUSH_BUFFER glcpp__flush_buffer(YY_CURRENT_BUFFER ,yyscanner) + +YY_BUFFER_STATE glcpp__scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner ); +YY_BUFFER_STATE glcpp__scan_string (yyconst char *yy_str ,yyscan_t yyscanner ); +YY_BUFFER_STATE glcpp__scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner ); + +void *glcpp_alloc (yy_size_t ,yyscan_t yyscanner ); +void *glcpp_realloc (void *,yy_size_t ,yyscan_t yyscanner ); +void glcpp_free (void * ,yyscan_t yyscanner ); + +#define yy_new_buffer glcpp__create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! YY_CURRENT_BUFFER ){ \ + glcpp_ensure_buffer_stack (yyscanner); \ + YY_CURRENT_BUFFER_LVALUE = \ + glcpp__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! YY_CURRENT_BUFFER ){\ + glcpp_ensure_buffer_stack (yyscanner); \ + YY_CURRENT_BUFFER_LVALUE = \ + glcpp__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +/* Begin user sect3 */ + +#define glcpp_wrap(n) 1 +#define YY_SKIP_YYWRAP + +typedef unsigned char YY_CHAR; + +typedef int yy_state_type; + +#define yytext_ptr yytext_r + +static yy_state_type yy_get_previous_state (yyscan_t yyscanner ); +static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner); +static int yy_get_next_buffer (yyscan_t yyscanner ); +static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yyg->yytext_ptr = yy_bp; \ + yyleng = (size_t) (yy_cp - yy_bp); \ + yyg->yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yyg->yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 40 +#define YY_END_OF_BUFFER 41 +/* This struct is not used in this scanner, + but its presence is necessary. */ +struct yy_trans_info + { + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +static yyconst flex_int16_t yy_acclist[132] = + { 0, + 3, 3, 41, 36, 40, 37, 40, 38, 40, 40, + 35, 40, 40, 35, 40, 35, 40, 35, 40, 22, + 36, 40, 21, 36, 40, 35, 40, 35, 40, 35, + 40, 34, 36, 40, 34, 36, 40, 35, 40, 37, + 40, 20, 40, 40, 3, 40, 4, 40, 5, 40, + 39, 40, 36, 15, 37, 29, 32, 30, 2, 22, + 36, 22, 36, 36, 21, 36, 21, 36, 24, 26, + 28, 27, 25, 34, 36, 34, 36, 31, 37, 20, + 20, 3, 4, 5, 6, 5, 7, 1, 15, 23, + 36, 34, 36,16395, 23, 36, 34, 36, 15, 34, + + 36,16396,16397, 8203, 15, 8203, 34, 36, 8204, 15, + 8205, 15,16398, 16,16393, 19, 33, 34, 36, 18, + 8206, 15, 16, 8201, 15,16394,16401, 8202, 15, 8, + 8209 + } ; + +static yyconst flex_int16_t yy_accept[151] = + { 0, + 1, 1, 1, 1, 1, 2, 3, 3, 3, 4, + 6, 8, 10, 11, 13, 14, 16, 18, 20, 23, + 26, 28, 30, 32, 35, 38, 40, 42, 44, 45, + 47, 49, 51, 53, 54, 54, 55, 56, 57, 58, + 59, 60, 60, 62, 64, 65, 67, 69, 70, 71, + 72, 73, 74, 76, 78, 79, 80, 81, 82, 82, + 82, 82, 82, 82, 82, 83, 84, 85, 86, 87, + 88, 88, 90, 92, 94, 94, 94, 94, 94, 94, + 95, 95, 95, 95, 97, 99, 99, 99, 99, 99, + 99, 99, 99, 100, 100, 100, 100, 100, 100, 102, + + 102, 103, 104, 104, 104, 104, 104, 106, 106, 107, + 107, 107, 107, 107, 107, 109, 109, 109, 111, 111, + 113, 114, 115, 115, 116, 116, 116, 117, 117, 120, + 121, 121, 123, 124, 124, 124, 126, 127, 127, 127, + 128, 128, 128, 130, 131, 131, 131, 132, 132, 132 + } ; + +static yyconst flex_int32_t yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 5, 1, 6, 1, 7, 8, 1, 9, + 7, 10, 7, 7, 7, 7, 11, 12, 13, 13, + 13, 13, 13, 13, 13, 14, 14, 1, 7, 15, + 16, 17, 1, 1, 18, 18, 18, 18, 18, 18, + 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, + 19, 19, 19, 19, 20, 19, 19, 21, 19, 19, + 7, 1, 7, 7, 19, 1, 22, 18, 18, 23, + + 24, 25, 26, 19, 27, 19, 19, 28, 29, 30, + 31, 32, 19, 33, 34, 35, 36, 37, 19, 38, + 19, 19, 7, 39, 7, 7, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 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 + } ; + +static yyconst flex_int32_t yy_meta[40] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1 + } ; + +static yyconst flex_int16_t yy_base[169] = + { 0, + 0, 38, 0, 0, 38, 39, 426, 425, 427, 48, + 43, 549, 423, 44, 63, 422, 59, 65, 87, 125, + 58, 67, 68, 164, 203, 40, 75, 241, 549, 421, + 549, 140, 549, 140, 420, 549, 144, 419, 418, 417, + 415, 414, 156, 179, 267, 0, 209, 413, 412, 411, + 410, 409, 387, 124, 407, 153, 403, 402, 154, 198, + 159, 155, 160, 192, 404, 549, 186, 549, 214, 549, + 359, 549, 162, 159, 227, 229, 230, 234, 199, 303, + 232, 235, 236, 262, 56, 243, 237, 247, 245, 252, + 291, 358, 357, 292, 238, 296, 293, 254, 335, 256, + + 355, 354, 298, 294, 263, 352, 549, 350, 549, 299, + 297, 322, 325, 257, 306, 328, 346, 549, 345, 549, + 344, 343, 329, 342, 331, 332, 341, 333, 319, 335, + 337, 549, 248, 338, 246, 549, 197, 184, 336, 366, + 403, 182, 549, 141, 434, 416, 79, 473, 549, 512, + 514, 516, 518, 520, 522, 71, 524, 526, 528, 530, + 532, 534, 536, 538, 540, 542, 544, 546 + } ; + +static yyconst flex_int16_t yy_def[169] = + { 0, + 149, 1, 150, 150, 151, 151, 152, 152, 149, 153, + 154, 149, 154, 154, 154, 154, 154, 154, 149, 153, + 154, 154, 154, 155, 155, 154, 154, 154, 149, 156, + 149, 157, 149, 20, 154, 149, 154, 154, 154, 154, + 154, 158, 19, 20, 20, 20, 20, 154, 154, 154, + 154, 154, 25, 25, 154, 154, 28, 28, 154, 154, + 154, 154, 154, 154, 156, 149, 157, 149, 157, 149, + 158, 149, 45, 25, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 20, 25, 154, 154, 154, 154, 154, + 154, 159, 160, 154, 154, 154, 154, 154, 25, 154, + + 161, 162, 154, 154, 154, 159, 149, 160, 149, 154, + 154, 154, 154, 154, 25, 154, 161, 149, 162, 149, + 163, 164, 154, 165, 154, 154, 154, 154, 25, 154, + 163, 149, 164, 154, 165, 149, 166, 167, 154, 149, + 154, 166, 149, 167, 168, 154, 154, 168, 0, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149 + } ; + +static yyconst flex_int16_t yy_nxt[589] = + { 0, + 10, 11, 12, 13, 14, 15, 16, 17, 16, 16, + 18, 19, 20, 20, 21, 22, 23, 24, 24, 24, + 24, 24, 25, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 26, 27, + 31, 31, 36, 28, 37, 36, 36, 32, 32, 35, + 36, 35, 35, 35, 35, 35, 35, 35, 35, 38, + 36, 36, 35, 35, 35, 36, 40, 36, 39, 36, + 36, 65, 48, 49, 41, 42, 56, 36, 55, 53, + 57, 36, 50, 51, 52, 99, 35, 34, 35, 36, + 35, 35, 35, 35, 35, 35, 35, 35, 43, 43, + + 34, 35, 35, 35, 34, 34, 44, 45, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 44, 34, 45, 35, 35, 36, 35, 35, + 35, 35, 35, 35, 35, 35, 46, 46, 46, 35, + 35, 35, 68, 36, 47, 37, 36, 53, 74, 69, + 70, 34, 34, 34, 56, 36, 36, 36, 57, 34, + 47, 36, 36, 35, 34, 35, 36, 35, 35, 35, + 35, 35, 35, 35, 35, 34, 34, 75, 35, 35, + 35, 84, 53, 80, 143, 85, 36, 81, 68, 82, + 34, 34, 34, 34, 36, 149, 149, 84, 34, 143, + + 36, 36, 35, 34, 35, 36, 35, 35, 35, 35, + 35, 35, 35, 35, 34, 83, 68, 35, 35, 35, + 34, 34, 34, 69, 70, 76, 54, 77, 34, 36, + 78, 36, 36, 91, 36, 79, 36, 36, 36, 36, + 36, 35, 58, 36, 34, 36, 39, 36, 136, 36, + 36, 86, 89, 96, 36, 87, 36, 97, 36, 36, + 111, 101, 88, 59, 60, 36, 90, 61, 98, 100, + 102, 103, 62, 34, 34, 34, 63, 64, 73, 73, + 73, 34, 104, 128, 73, 116, 34, 114, 73, 73, + 73, 73, 123, 36, 36, 36, 36, 34, 36, 36, + + 36, 36, 34, 92, 92, 93, 92, 92, 92, 92, + 92, 92, 92, 92, 105, 110, 113, 92, 92, 92, + 125, 112, 121, 124, 36, 94, 122, 36, 129, 53, + 36, 36, 95, 36, 36, 36, 140, 36, 36, 132, + 36, 92, 53, 36, 136, 36, 132, 120, 118, 127, + 126, 130, 109, 138, 107, 137, 120, 118, 115, 109, + 107, 72, 134, 139, 141, 138, 35, 140, 36, 35, + 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, + 35, 35, 35, 145, 145, 145, 145, 145, 145, 145, + 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, + + 145, 145, 145, 145, 35, 36, 66, 35, 35, 36, + 53, 36, 36, 36, 36, 36, 72, 36, 36, 36, + 36, 36, 36, 66, 36, 36, 149, 29, 29, 149, + 149, 149, 149, 146, 35, 35, 36, 35, 35, 35, + 35, 35, 147, 35, 35, 138, 149, 149, 35, 35, + 35, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 35, 35, 35, 36, 35, 35, 35, 35, + 35, 147, 35, 35, 149, 149, 149, 35, 35, 35, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 35, 29, 29, 30, 30, 33, 33, 34, 34, + 35, 35, 53, 53, 67, 67, 71, 71, 106, 106, + 108, 108, 117, 117, 119, 119, 131, 131, 133, 133, + 135, 135, 142, 142, 144, 144, 148, 148, 9, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149 + } ; + +static yyconst flex_int16_t yy_chk[589] = + { 0, + 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, 2, + 5, 6, 26, 2, 11, 11, 14, 5, 6, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 14, + 21, 17, 10, 10, 10, 15, 17, 18, 15, 22, + 23, 156, 21, 21, 18, 18, 27, 27, 26, 85, + 27, 147, 22, 23, 23, 85, 10, 19, 19, 19, + 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, + + 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, + 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, + 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, + 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, + 20, 20, 32, 144, 20, 37, 37, 54, 54, 32, + 32, 34, 34, 34, 56, 56, 59, 62, 56, 34, + 20, 61, 63, 20, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 34, 43, 59, 24, 24, + 24, 73, 74, 61, 142, 74, 138, 62, 67, 63, + 44, 44, 44, 43, 64, 67, 67, 73, 44, 137, + + 60, 79, 24, 25, 25, 25, 25, 25, 25, 25, + 25, 25, 25, 25, 44, 64, 69, 25, 25, 25, + 47, 47, 47, 69, 69, 60, 25, 60, 47, 75, + 60, 76, 77, 79, 81, 60, 78, 82, 83, 87, + 95, 25, 28, 28, 47, 86, 28, 89, 135, 88, + 133, 75, 77, 81, 90, 76, 98, 82, 100, 114, + 95, 87, 76, 28, 28, 105, 78, 28, 83, 86, + 88, 89, 28, 84, 84, 84, 28, 28, 45, 45, + 45, 84, 90, 114, 45, 100, 45, 98, 45, 45, + 45, 45, 105, 91, 94, 97, 104, 84, 96, 111, + + 103, 110, 45, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 91, 94, 97, 80, 80, 80, + 111, 96, 103, 110, 112, 80, 104, 113, 115, 115, + 116, 123, 80, 125, 126, 128, 130, 130, 139, 131, + 134, 80, 129, 127, 124, 122, 121, 119, 117, 113, + 112, 116, 108, 126, 106, 125, 102, 101, 99, 93, + 92, 71, 123, 128, 134, 139, 140, 140, 140, 140, + 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, + 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, + 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, + + 140, 140, 140, 140, 140, 141, 65, 58, 57, 55, + 53, 52, 51, 50, 49, 48, 42, 41, 146, 40, + 39, 38, 35, 30, 16, 13, 9, 8, 7, 0, + 0, 0, 0, 141, 145, 145, 145, 145, 145, 145, + 145, 145, 145, 145, 145, 146, 0, 0, 145, 145, + 145, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 145, 148, 148, 148, 148, 148, 148, 148, + 148, 148, 148, 148, 0, 0, 0, 148, 148, 148, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 148, 150, 150, 151, 151, 152, 152, 153, 153, + 154, 154, 155, 155, 157, 157, 158, 158, 159, 159, + 160, 160, 161, 161, 162, 162, 163, 163, 164, 164, + 165, 165, 166, 166, 167, 167, 168, 168, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149 + } ; + +#define YY_TRAILING_MASK 0x2000 +#define YY_TRAILING_HEAD_MASK 0x4000 +#define REJECT \ +{ \ +*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */ \ +yy_cp = yyg->yy_full_match; /* restore poss. backed-over text */ \ +yyg->yy_lp = yyg->yy_full_lp; /* restore orig. accepting pos. */ \ +yyg->yy_state_ptr = yyg->yy_full_state; /* restore orig. state */ \ +yy_current_state = *yyg->yy_state_ptr; /* restore curr. state */ \ +++yyg->yy_lp; \ +goto find_rule; \ +} + +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +#line 1 "glcpp/glcpp-lex.l" +#line 2 "glcpp/glcpp-lex.l" +/* + * Copyright © 2010 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include +#include +#include + +#include "glcpp.h" +#include "glcpp-parse.h" + +/* Flex annoyingly generates some functions without making them + * static. Let's declare them here. */ +int glcpp_get_column (yyscan_t yyscanner); +void glcpp_set_column (int column_no , yyscan_t yyscanner); + +#define YY_NO_INPUT + +#define YY_USER_ACTION \ + do { \ + yylloc->source = 0; \ + yylloc->first_column = yycolumn + 1; \ + yylloc->first_line = yylineno; \ + yycolumn += yyleng; \ + } while(0); +#define YY_USER_INIT yylineno = 0; yycolumn = 0; + +#line 694 "glcpp/glcpp-lex.c" + +#define INITIAL 0 +#define DONE 1 +#define COMMENT 2 +#define UNREACHABLE 3 + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include +#endif + +#define YY_EXTRA_TYPE glcpp_parser_t * + +/* Holds the entire state of the reentrant scanner. */ +struct yyguts_t + { + + /* User-defined. Not touched by flex. */ + YY_EXTRA_TYPE yyextra_r; + + /* The rest are the same as the globals declared in the non-reentrant scanner. */ + FILE *yyin_r, *yyout_r; + size_t yy_buffer_stack_top; /**< index of top of stack. */ + size_t yy_buffer_stack_max; /**< capacity of stack. */ + YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ + char yy_hold_char; + int yy_n_chars; + int yyleng_r; + char *yy_c_buf_p; + int yy_init; + int yy_start; + int yy_did_buffer_switch_on_eof; + int yy_start_stack_ptr; + int yy_start_stack_depth; + int *yy_start_stack; + yy_state_type yy_last_accepting_state; + char* yy_last_accepting_cpos; + + int yylineno_r; + int yy_flex_debug_r; + + yy_state_type *yy_state_buf; + yy_state_type *yy_state_ptr; + char *yy_full_match; + int yy_lp; + + /* These are only needed for trailing context rules, + * but there's no conditional variable for that yet. */ + int yy_looking_for_trail_begin; + int yy_full_lp; + int *yy_full_state; + + char *yytext_r; + int yy_more_flag; + int yy_more_len; + + YYSTYPE * yylval_r; + + YYLTYPE * yylloc_r; + + }; /* end struct yyguts_t */ + +static int yy_init_globals (yyscan_t yyscanner ); + + /* This must go here because YYSTYPE and YYLTYPE are included + * from bison output in section 1.*/ + # define yylval yyg->yylval_r + + # define yylloc yyg->yylloc_r + +int glcpp_lex_init (yyscan_t* scanner); + +int glcpp_lex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int glcpp_lex_destroy (yyscan_t yyscanner ); + +int glcpp_get_debug (yyscan_t yyscanner ); + +void glcpp_set_debug (int debug_flag ,yyscan_t yyscanner ); + +YY_EXTRA_TYPE glcpp_get_extra (yyscan_t yyscanner ); + +void glcpp_set_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner ); + +FILE *glcpp_get_in (yyscan_t yyscanner ); + +void glcpp_set_in (FILE * in_str ,yyscan_t yyscanner ); + +FILE *glcpp_get_out (yyscan_t yyscanner ); + +void glcpp_set_out (FILE * out_str ,yyscan_t yyscanner ); + +int glcpp_get_leng (yyscan_t yyscanner ); + +char *glcpp_get_text (yyscan_t yyscanner ); + +int glcpp_get_lineno (yyscan_t yyscanner ); + +void glcpp_set_lineno (int line_number ,yyscan_t yyscanner ); + +YYSTYPE * glcpp_get_lval (yyscan_t yyscanner ); + +void glcpp_set_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner ); + + YYLTYPE *glcpp_get_lloc (yyscan_t yyscanner ); + + void glcpp_set_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int glcpp_wrap (yyscan_t yyscanner ); +#else +extern int glcpp_wrap (yyscan_t yyscanner ); +#endif +#endif + + static void yyunput (int c,char *buf_ptr ,yyscan_t yyscanner); + +#ifndef yytext_ptr +static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner); +#endif + +#ifndef YY_NO_INPUT + +#ifdef __cplusplus +static int yyinput (yyscan_t yyscanner ); +#else +static int input (yyscan_t yyscanner ); +#endif + +#endif + + static void yy_push_state (int new_state ,yyscan_t yyscanner); + + static void yy_pop_state (yyscan_t yyscanner ); + + static int yy_top_state (yyscan_t yyscanner ); + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +/* 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) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ + { \ + int c = '*'; \ + size_t n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + }\ +\ + +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) +#endif + +/* end tables serialization structures and prototypes */ + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int glcpp_lex \ + (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner); + +#define YY_DECL int glcpp_lex \ + (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner) +#endif /* !YY_DECL */ + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + if ( yyleng > 0 ) \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ + (yytext[yyleng - 1] == '\n'); \ + YY_USER_ACTION + +/** The main scanner function which does all the work. + */ +YY_DECL +{ + register yy_state_type yy_current_state; + register char *yy_cp, *yy_bp; + register int yy_act; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + +#line 69 "glcpp/glcpp-lex.l" + + + /* Single-line comments */ +#line 965 "glcpp/glcpp-lex.c" + + yylval = yylval_param; + + yylloc = yylloc_param; + + if ( !yyg->yy_init ) + { + yyg->yy_init = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + /* Create the reject buffer large enough to save one state per allowed character. */ + if ( ! yyg->yy_state_buf ) + yyg->yy_state_buf = (yy_state_type *)glcpp_alloc(YY_STATE_BUF_SIZE ,yyscanner); + if ( ! yyg->yy_state_buf ) + YY_FATAL_ERROR( "out of dynamic memory in glcpp_lex()" ); + + if ( ! yyg->yy_start ) + yyg->yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! YY_CURRENT_BUFFER ) { + glcpp_ensure_buffer_stack (yyscanner); + YY_CURRENT_BUFFER_LVALUE = + glcpp__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); + } + + glcpp__load_buffer_state(yyscanner ); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yyg->yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yyg->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 = yyg->yy_start; + yy_current_state += YY_AT_BOL(); + + yyg->yy_state_ptr = yyg->yy_state_buf; + *yyg->yy_state_ptr++ = yy_current_state; + +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*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 >= 150 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + *yyg->yy_state_ptr++ = yy_current_state; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 549 ); + +yy_find_action: + yy_current_state = *--yyg->yy_state_ptr; + yyg->yy_lp = yy_accept[yy_current_state]; +find_rule: /* we branch to this label when backing up */ + for ( ; ; ) /* until we find what rule we matched */ + { + if ( yyg->yy_lp && yyg->yy_lp < yy_accept[yy_current_state + 1] ) + { + yy_act = yy_acclist[yyg->yy_lp]; + if ( yy_act & YY_TRAILING_HEAD_MASK || + yyg->yy_looking_for_trail_begin ) + { + if ( yy_act == yyg->yy_looking_for_trail_begin ) + { + yyg->yy_looking_for_trail_begin = 0; + yy_act &= ~YY_TRAILING_HEAD_MASK; + break; + } + } + else if ( yy_act & YY_TRAILING_MASK ) + { + yyg->yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK; + yyg->yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK; + yyg->yy_full_match = yy_cp; + yyg->yy_full_state = yyg->yy_state_ptr; + yyg->yy_full_lp = yyg->yy_lp; + } + else + { + yyg->yy_full_match = yy_cp; + yyg->yy_full_state = yyg->yy_state_ptr; + yyg->yy_full_lp = yyg->yy_lp; + break; + } + ++yyg->yy_lp; + goto find_rule; + } + --yy_cp; + yy_current_state = *--yyg->yy_state_ptr; + yyg->yy_lp = 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 1: +/* rule 1 can match eol */ +YY_RULE_SETUP +#line 72 "glcpp/glcpp-lex.l" +{ + yylineno++; + yycolumn = 0; + return NEWLINE; +} + YY_BREAK +/* Multi-line comments */ +case 2: +YY_RULE_SETUP +#line 79 "glcpp/glcpp-lex.l" +{ yy_push_state(COMMENT, yyscanner); } + YY_BREAK +case 3: +YY_RULE_SETUP +#line 80 "glcpp/glcpp-lex.l" + + YY_BREAK +case 4: +/* rule 4 can match eol */ +YY_RULE_SETUP +#line 81 "glcpp/glcpp-lex.l" +{ yylineno++; yycolumn = 0; } + YY_BREAK +case 5: +YY_RULE_SETUP +#line 82 "glcpp/glcpp-lex.l" + + YY_BREAK +case 6: +/* rule 6 can match eol */ +YY_RULE_SETUP +#line 83 "glcpp/glcpp-lex.l" +{ yylineno++; yycolumn = 0; } + YY_BREAK +case 7: +YY_RULE_SETUP +#line 84 "glcpp/glcpp-lex.l" +{ + yy_pop_state(yyscanner); + if (yyextra->space_tokens) + return SPACE; +} + YY_BREAK +/* glcpp doesn't handle #extension, #version, or #pragma directives. + * Simply pass them through to the main compiler's lexer/parser. */ +case 8: +YY_RULE_SETUP +#line 92 "glcpp/glcpp-lex.l" +{ + yylval->str = xtalloc_strdup (yyextra, yytext); + yylineno++; + yycolumn = 0; + return OTHER; +} + YY_BREAK +case 9: +/* rule 9 can match eol */ +YY_RULE_SETUP +#line 99 "glcpp/glcpp-lex.l" +{ + yyextra->lexing_if = 1; + yyextra->space_tokens = 0; + return HASH_IFDEF; +} + YY_BREAK +case 10: +/* rule 10 can match eol */ +YY_RULE_SETUP +#line 105 "glcpp/glcpp-lex.l" +{ + yyextra->lexing_if = 1; + yyextra->space_tokens = 0; + return HASH_IFNDEF; +} + YY_BREAK +case 11: +/* rule 11 can match eol */ +YY_RULE_SETUP +#line 111 "glcpp/glcpp-lex.l" +{ + yyextra->lexing_if = 1; + yyextra->space_tokens = 0; + return HASH_IF; +} + YY_BREAK +case 12: +/* rule 12 can match eol */ +YY_RULE_SETUP +#line 117 "glcpp/glcpp-lex.l" +{ + yyextra->lexing_if = 1; + yyextra->space_tokens = 0; + return HASH_ELIF; +} + YY_BREAK +case 13: +/* rule 13 can match eol */ +YY_RULE_SETUP +#line 123 "glcpp/glcpp-lex.l" +{ + yyextra->space_tokens = 0; + return HASH_ELSE; +} + YY_BREAK +case 14: +/* rule 14 can match eol */ +YY_RULE_SETUP +#line 128 "glcpp/glcpp-lex.l" +{ + yyextra->space_tokens = 0; + return HASH_ENDIF; +} + YY_BREAK +/* When skipping (due to an #if 0 or similar) consume anything + * up to a newline. We do this with less priority than any + * #if-related directive (#if, #elif, #else, #endif), but with + * more priority than any other directive or token to avoid + * any side-effects from skipped content. + * + * We use the lexing_if flag to avoid skipping any part of an + * if conditional expression. */ +case 15: +/* rule 15 can match eol */ +*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */ +yyg->yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 141 "glcpp/glcpp-lex.l" +{ + /* Since this rule always matches, YY_USER_ACTION gets called for it, + * wrongly incrementing yycolumn. We undo that effect here. */ + yycolumn -= yyleng; + if (yyextra->lexing_if || + yyextra->skip_stack == NULL || + yyextra->skip_stack->type == SKIP_NO_SKIP) + { + REJECT; + } +} + YY_BREAK +case 16: +YY_RULE_SETUP +#line 153 "glcpp/glcpp-lex.l" +{ + char *p; + for (p = yytext; !isalpha(p[0]); p++); /* skip " # " */ + p += 5; /* skip "error" */ + glcpp_error(yylloc, yyextra, "#error%s", p); +} + YY_BREAK +case 17: +YY_RULE_SETUP +#line 160 "glcpp/glcpp-lex.l" +{ + yyextra->space_tokens = 0; + return HASH_DEFINE_FUNC; +} + YY_BREAK +case 18: +YY_RULE_SETUP +#line 165 "glcpp/glcpp-lex.l" +{ + yyextra->space_tokens = 0; + return HASH_DEFINE_OBJ; +} + YY_BREAK +case 19: +YY_RULE_SETUP +#line 170 "glcpp/glcpp-lex.l" +{ + yyextra->space_tokens = 0; + return HASH_UNDEF; +} + YY_BREAK +case 20: +YY_RULE_SETUP +#line 175 "glcpp/glcpp-lex.l" +{ + yyextra->space_tokens = 0; + return HASH; +} + YY_BREAK +case 21: +YY_RULE_SETUP +#line 180 "glcpp/glcpp-lex.l" +{ + yylval->str = xtalloc_strdup (yyextra, yytext); + return INTEGER_STRING; +} + YY_BREAK +case 22: +YY_RULE_SETUP +#line 185 "glcpp/glcpp-lex.l" +{ + yylval->str = xtalloc_strdup (yyextra, yytext); + return INTEGER_STRING; +} + YY_BREAK +case 23: +YY_RULE_SETUP +#line 190 "glcpp/glcpp-lex.l" +{ + yylval->str = xtalloc_strdup (yyextra, yytext); + return INTEGER_STRING; +} + YY_BREAK +case 24: +YY_RULE_SETUP +#line 195 "glcpp/glcpp-lex.l" +{ + return LEFT_SHIFT; +} + YY_BREAK +case 25: +YY_RULE_SETUP +#line 199 "glcpp/glcpp-lex.l" +{ + return RIGHT_SHIFT; +} + YY_BREAK +case 26: +YY_RULE_SETUP +#line 203 "glcpp/glcpp-lex.l" +{ + return LESS_OR_EQUAL; +} + YY_BREAK +case 27: +YY_RULE_SETUP +#line 207 "glcpp/glcpp-lex.l" +{ + return GREATER_OR_EQUAL; +} + YY_BREAK +case 28: +YY_RULE_SETUP +#line 211 "glcpp/glcpp-lex.l" +{ + return EQUAL; +} + YY_BREAK +case 29: +YY_RULE_SETUP +#line 215 "glcpp/glcpp-lex.l" +{ + return NOT_EQUAL; +} + YY_BREAK +case 30: +YY_RULE_SETUP +#line 219 "glcpp/glcpp-lex.l" +{ + return AND; +} + YY_BREAK +case 31: +YY_RULE_SETUP +#line 223 "glcpp/glcpp-lex.l" +{ + return OR; +} + YY_BREAK +case 32: +YY_RULE_SETUP +#line 227 "glcpp/glcpp-lex.l" +{ + return PASTE; +} + YY_BREAK +case 33: +YY_RULE_SETUP +#line 231 "glcpp/glcpp-lex.l" +{ + return DEFINED; +} + YY_BREAK +case 34: +YY_RULE_SETUP +#line 235 "glcpp/glcpp-lex.l" +{ + yylval->str = xtalloc_strdup (yyextra, yytext); + return IDENTIFIER; +} + YY_BREAK +case 35: +YY_RULE_SETUP +#line 240 "glcpp/glcpp-lex.l" +{ + return yytext[0]; +} + YY_BREAK +case 36: +YY_RULE_SETUP +#line 244 "glcpp/glcpp-lex.l" +{ + yylval->str = xtalloc_strdup (yyextra, yytext); + return OTHER; +} + YY_BREAK +case 37: +YY_RULE_SETUP +#line 249 "glcpp/glcpp-lex.l" +{ + if (yyextra->space_tokens) { + return SPACE; + } +} + YY_BREAK +case 38: +/* rule 38 can match eol */ +YY_RULE_SETUP +#line 255 "glcpp/glcpp-lex.l" +{ + yyextra->lexing_if = 0; + yylineno++; + yycolumn = 0; + return NEWLINE; +} + YY_BREAK +/* Handle missing newline at EOF. */ +case YY_STATE_EOF(INITIAL): +#line 263 "glcpp/glcpp-lex.l" +{ + BEGIN DONE; /* Don't keep matching this rule forever. */ + yyextra->lexing_if = 0; + return NEWLINE; +} + YY_BREAK +/* We don't actually use the UNREACHABLE start condition. We + only have this action here so that we can pretend to call some + generated functions, (to avoid "defined but not used" + warnings. */ +case 39: +YY_RULE_SETUP +#line 273 "glcpp/glcpp-lex.l" +{ + unput('.'); + yy_top_state(yyextra); +} + YY_BREAK +case 40: +YY_RULE_SETUP +#line 278 "glcpp/glcpp-lex.l" +ECHO; + YY_BREAK +#line 1434 "glcpp/glcpp-lex.c" + case YY_STATE_EOF(DONE): + case YY_STATE_EOF(COMMENT): + case YY_STATE_EOF(UNREACHABLE): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yyg->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 + * glcpp_lex(). 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. + */ + yyg->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 ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( yyscanner ); + + /* 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 , yyscanner); + + yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yyg->yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yyg->yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( yyscanner ) ) + { + case EOB_ACT_END_OF_FILE: + { + yyg->yy_did_buffer_switch_on_eof = 0; + + if ( glcpp_wrap(yyscanner ) ) + { + /* 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. + */ + yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yyg->yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yyg->yy_c_buf_p = + yyg->yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( yyscanner ); + + yy_cp = yyg->yy_c_buf_p; + yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yyg->yy_c_buf_p = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; + + yy_current_state = yy_get_previous_state( yyscanner ); + + yy_cp = yyg->yy_c_buf_p; + yy_bp = yyg->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 glcpp_lex */ + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +static int yy_get_next_buffer (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + register char *source = yyg->yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->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 ( yyg->yy_c_buf_p - yyg->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) (yyg->yy_c_buf_p - yyg->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 = yyg->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. */ + + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); + + } + + 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]), + yyg->yy_n_chars, (size_t) num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; + } + + if ( yyg->yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + glcpp_restart(yyin ,yyscanner); + } + + 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; + + if ((yy_size_t) (yyg->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 = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) glcpp_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + } + + yyg->yy_n_chars += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + + static yy_state_type yy_get_previous_state (yyscan_t yyscanner) +{ + register yy_state_type yy_current_state; + register char *yy_cp; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + yy_current_state = yyg->yy_start; + yy_current_state += YY_AT_BOL(); + + yyg->yy_state_ptr = yyg->yy_state_buf; + *yyg->yy_state_ptr++ = yy_current_state; + + for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + 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 >= 150 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + *yyg->yy_state_ptr++ = yy_current_state; + } + + return yy_current_state; +} + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner) +{ + register int yy_is_jam; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ + + register YY_CHAR yy_c = 1; + 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 >= 150 ) + 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 == 149); + if ( ! yy_is_jam ) + *yyg->yy_state_ptr++ = yy_current_state; + + return yy_is_jam ? 0 : yy_current_state; +} + + static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner) +{ + register char *yy_cp; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + yy_cp = yyg->yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yyg->yy_hold_char; + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yyg->yy_n_chars + 2; + register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; + register char *source = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; + + while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = + yyg->yy_n_chars = 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" ); + } + + *--yy_cp = (char) c; + + yyg->yytext_ptr = yy_bp; + yyg->yy_hold_char = *yy_cp; + yyg->yy_c_buf_p = yy_cp; +} + +#ifndef YY_NO_INPUT +#ifdef __cplusplus + static int yyinput (yyscan_t yyscanner) +#else + static int input (yyscan_t yyscanner) +#endif + +{ + int c; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + *yyg->yy_c_buf_p = yyg->yy_hold_char; + + if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) + /* This was really a NUL. */ + *yyg->yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yyg->yy_c_buf_p - yyg->yytext_ptr; + ++yyg->yy_c_buf_p; + + switch ( yy_get_next_buffer( yyscanner ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + glcpp_restart(yyin ,yyscanner); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( glcpp_wrap(yyscanner ) ) + return EOF; + + if ( ! yyg->yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(yyscanner); +#else + return input(yyscanner); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yyg->yy_c_buf_p = yyg->yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */ + *yyg->yy_c_buf_p = '\0'; /* preserve yytext */ + yyg->yy_hold_char = *++yyg->yy_c_buf_p; + + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n'); + + return c; +} +#endif /* ifndef YY_NO_INPUT */ + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * @param yyscanner The scanner object. + * @note This function does not reset the start condition to @c INITIAL . + */ + void glcpp_restart (FILE * input_file , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if ( ! YY_CURRENT_BUFFER ){ + glcpp_ensure_buffer_stack (yyscanner); + YY_CURRENT_BUFFER_LVALUE = + glcpp__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); + } + + glcpp__init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner); + glcpp__load_buffer_state(yyscanner ); +} + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * @param yyscanner The scanner object. + */ + void glcpp__switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* TODO. We should be able to replace this entire function body + * with + * glcpp_pop_buffer_state(); + * glcpp_push_buffer_state(new_buffer); + */ + glcpp_ensure_buffer_stack (yyscanner); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *yyg->yy_c_buf_p = yyg->yy_hold_char; + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + glcpp__load_buffer_state(yyscanner ); + + /* We don't actually know whether we did this switch during + * EOF (glcpp_wrap()) processing, but the only time this flag + * is looked at is after glcpp_wrap() is called, so it's safe + * to go ahead and always set it. + */ + yyg->yy_did_buffer_switch_on_eof = 1; +} + +static void glcpp__load_buffer_state (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + yyg->yy_hold_char = *yyg->yy_c_buf_p; +} + +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * @param yyscanner The scanner object. + * @return the allocated buffer state. + */ + YY_BUFFER_STATE glcpp__create_buffer (FILE * file, int size , yyscan_t yyscanner) +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) glcpp_alloc(sizeof( struct yy_buffer_state ) ,yyscanner ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in glcpp__create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) glcpp_alloc(b->yy_buf_size + 2 ,yyscanner ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in glcpp__create_buffer()" ); + + b->yy_is_our_buffer = 1; + + glcpp__init_buffer(b,file ,yyscanner); + + return b; +} + +/** Destroy the buffer. + * @param b a buffer created with glcpp__create_buffer() + * @param yyscanner The scanner object. + */ + void glcpp__delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if ( ! b ) + return; + + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + glcpp_free((void *) b->yy_ch_buf ,yyscanner ); + + glcpp_free((void *) b ,yyscanner ); +} + +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a glcpp_restart() or at EOF. + */ + static void glcpp__init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner) + +{ + int oerrno = errno; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + glcpp__flush_buffer(b ,yyscanner); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + + /* If b is the current buffer, then glcpp__init_buffer was _probably_ + * called from glcpp_restart() 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 = 0; + + errno = oerrno; +} + +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * @param yyscanner The scanner object. + */ + void glcpp__flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) + glcpp__load_buffer_state(yyscanner ); +} + +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * @param yyscanner The scanner object. + */ +void glcpp_push_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + if (new_buffer == NULL) + return; + + glcpp_ensure_buffer_stack(yyscanner); + + /* This block is copied from glcpp__switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *yyg->yy_c_buf_p = yyg->yy_hold_char; + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + yyg->yy_buffer_stack_top++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from glcpp__switch_to_buffer. */ + glcpp__load_buffer_state(yyscanner ); + yyg->yy_did_buffer_switch_on_eof = 1; +} + +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * @param yyscanner The scanner object. + */ +void glcpp_pop_buffer_state (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + if (!YY_CURRENT_BUFFER) + return; + + glcpp__delete_buffer(YY_CURRENT_BUFFER ,yyscanner); + YY_CURRENT_BUFFER_LVALUE = NULL; + if (yyg->yy_buffer_stack_top > 0) + --yyg->yy_buffer_stack_top; + + if (YY_CURRENT_BUFFER) { + glcpp__load_buffer_state(yyscanner ); + yyg->yy_did_buffer_switch_on_eof = 1; + } +} + +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +static void glcpp_ensure_buffer_stack (yyscan_t yyscanner) +{ + int num_to_alloc; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if (!yyg->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; + yyg->yy_buffer_stack = (struct yy_buffer_state**)glcpp_alloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + , yyscanner); + if ( ! yyg->yy_buffer_stack ) + YY_FATAL_ERROR( "out of dynamic memory in glcpp_ensure_buffer_stack()" ); + + memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + yyg->yy_buffer_stack_max = num_to_alloc; + yyg->yy_buffer_stack_top = 0; + return; + } + + if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + int grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = yyg->yy_buffer_stack_max + grow_size; + yyg->yy_buffer_stack = (struct yy_buffer_state**)glcpp_realloc + (yyg->yy_buffer_stack, + num_to_alloc * sizeof(struct yy_buffer_state*) + , yyscanner); + if ( ! yyg->yy_buffer_stack ) + YY_FATAL_ERROR( "out of dynamic memory in glcpp_ensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); + yyg->yy_buffer_stack_max = num_to_alloc; + } +} + +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * @param yyscanner The scanner object. + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE glcpp__scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner) +{ + YY_BUFFER_STATE b; + + if ( size < 2 || + 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; + + b = (YY_BUFFER_STATE) glcpp_alloc(sizeof( struct yy_buffer_state ) ,yyscanner ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in glcpp__scan_buffer()" ); + + 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_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + glcpp__switch_to_buffer(b ,yyscanner ); + + return b; +} + +/** Setup the input buffer state to scan a string. The next call to glcpp_lex() will + * scan from a @e copy of @a str. + * @param yystr a NUL-terminated string to scan + * @param yyscanner The scanner object. + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * glcpp__scan_bytes() instead. + */ +YY_BUFFER_STATE glcpp__scan_string (yyconst char * yystr , yyscan_t yyscanner) +{ + + return glcpp__scan_bytes(yystr,strlen(yystr) ,yyscanner); +} + +/** Setup the input buffer state to scan the given bytes. The next call to glcpp_lex() will + * scan from a @e copy of @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * @param yyscanner The scanner object. + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE glcpp__scan_bytes (yyconst char * yybytes, int _yybytes_len , yyscan_t yyscanner) +{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = _yybytes_len + 2; + buf = (char *) glcpp_alloc(n ,yyscanner ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in glcpp__scan_bytes()" ); + + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + + b = glcpp__scan_buffer(buf,n ,yyscanner); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in glcpp__scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; +} + + static void yy_push_state (int new_state , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth ) + { + yy_size_t new_size; + + yyg->yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yyg->yy_start_stack_depth * sizeof( int ); + + if ( ! yyg->yy_start_stack ) + yyg->yy_start_stack = (int *) glcpp_alloc(new_size ,yyscanner ); + + else + yyg->yy_start_stack = (int *) glcpp_realloc((void *) yyg->yy_start_stack,new_size ,yyscanner ); + + if ( ! yyg->yy_start_stack ) + YY_FATAL_ERROR( "out of memory expanding start-condition stack" ); + } + + yyg->yy_start_stack[yyg->yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); +} + + static void yy_pop_state (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + if ( --yyg->yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yyg->yy_start_stack[yyg->yy_start_stack_ptr]); +} + + static int yy_top_state (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyg->yy_start_stack[yyg->yy_start_stack_ptr - 1]; +} + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner) +{ + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + yytext[yyleng] = yyg->yy_hold_char; \ + yyg->yy_c_buf_p = yytext + yyless_macro_arg; \ + yyg->yy_hold_char = *yyg->yy_c_buf_p; \ + *yyg->yy_c_buf_p = '\0'; \ + yyleng = yyless_macro_arg; \ + } \ + while ( 0 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/** Get the user-defined data for this scanner. + * @param yyscanner The scanner object. + */ +YY_EXTRA_TYPE glcpp_get_extra (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyextra; +} + +/** Get the current line number. + * @param yyscanner The scanner object. + */ +int glcpp_get_lineno (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if (! YY_CURRENT_BUFFER) + return 0; + + return yylineno; +} + +/** Get the current column number. + * @param yyscanner The scanner object. + */ +int glcpp_get_column (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if (! YY_CURRENT_BUFFER) + return 0; + + return yycolumn; +} + +/** Get the input stream. + * @param yyscanner The scanner object. + */ +FILE *glcpp_get_in (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyin; +} + +/** Get the output stream. + * @param yyscanner The scanner object. + */ +FILE *glcpp_get_out (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyout; +} + +/** Get the length of the current token. + * @param yyscanner The scanner object. + */ +int glcpp_get_leng (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyleng; +} + +/** Get the current token. + * @param yyscanner The scanner object. + */ + +char *glcpp_get_text (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yytext; +} + +/** Set the user-defined data. This data is never touched by the scanner. + * @param user_defined The data to be associated with this scanner. + * @param yyscanner The scanner object. + */ +void glcpp_set_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyextra = user_defined ; +} + +/** Set the current line number. + * @param line_number + * @param yyscanner The scanner object. + */ +void glcpp_set_lineno (int line_number , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* lineno is only valid if an input buffer exists. */ + if (! YY_CURRENT_BUFFER ) + yy_fatal_error( "glcpp_set_lineno called with no buffer" , yyscanner); + + yylineno = line_number; +} + +/** Set the current column. + * @param line_number + * @param yyscanner The scanner object. + */ +void glcpp_set_column (int column_no , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* column is only valid if an input buffer exists. */ + if (! YY_CURRENT_BUFFER ) + yy_fatal_error( "glcpp_set_column called with no buffer" , yyscanner); + + yycolumn = column_no; +} + +/** Set the input stream. This does not discard the current + * input buffer. + * @param in_str A readable stream. + * @param yyscanner The scanner object. + * @see glcpp__switch_to_buffer + */ +void glcpp_set_in (FILE * in_str , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyin = in_str ; +} + +void glcpp_set_out (FILE * out_str , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyout = out_str ; +} + +int glcpp_get_debug (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yy_flex_debug; +} + +void glcpp_set_debug (int bdebug , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yy_flex_debug = bdebug ; +} + +/* Accessor methods for yylval and yylloc */ + +YYSTYPE * glcpp_get_lval (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yylval; +} + +void glcpp_set_lval (YYSTYPE * yylval_param , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yylval = yylval_param; +} + +YYLTYPE *glcpp_get_lloc (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yylloc; +} + +void glcpp_set_lloc (YYLTYPE * yylloc_param , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yylloc = yylloc_param; +} + +/* User-visible API */ + +/* glcpp_lex_init is special because it creates the scanner itself, so it is + * the ONLY reentrant function that doesn't take the scanner as the last argument. + * That's why we explicitly handle the declaration, instead of using our macros. + */ + +int glcpp_lex_init(yyscan_t* ptr_yy_globals) + +{ + if (ptr_yy_globals == NULL){ + errno = EINVAL; + return 1; + } + + *ptr_yy_globals = (yyscan_t) glcpp_alloc ( sizeof( struct yyguts_t ), NULL ); + + if (*ptr_yy_globals == NULL){ + errno = ENOMEM; + return 1; + } + + /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ + memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); + + return yy_init_globals ( *ptr_yy_globals ); +} + +/* glcpp_lex_init_extra has the same functionality as glcpp_lex_init, but follows the + * convention of taking the scanner as the last argument. Note however, that + * this is a *pointer* to a scanner, as it will be allocated by this call (and + * is the reason, too, why this function also must handle its own declaration). + * The user defined value in the first argument will be available to glcpp_alloc in + * the yyextra field. + */ + +int glcpp_lex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals ) + +{ + struct yyguts_t dummy_yyguts; + + glcpp_set_extra (yy_user_defined, &dummy_yyguts); + + if (ptr_yy_globals == NULL){ + errno = EINVAL; + return 1; + } + + *ptr_yy_globals = (yyscan_t) glcpp_alloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); + + if (*ptr_yy_globals == NULL){ + errno = ENOMEM; + return 1; + } + + /* By setting to 0xAA, we expose bugs in + yy_init_globals. Leave at 0x00 for releases. */ + memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); + + glcpp_set_extra (yy_user_defined, *ptr_yy_globals); + + return yy_init_globals ( *ptr_yy_globals ); +} + +static int yy_init_globals (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from glcpp_lex_destroy(), so don't allocate here. + */ + + yyg->yy_buffer_stack = 0; + yyg->yy_buffer_stack_top = 0; + yyg->yy_buffer_stack_max = 0; + yyg->yy_c_buf_p = (char *) 0; + yyg->yy_init = 0; + yyg->yy_start = 0; + + yyg->yy_start_stack_ptr = 0; + yyg->yy_start_stack_depth = 0; + yyg->yy_start_stack = NULL; + + yyg->yy_state_buf = 0; + yyg->yy_state_ptr = 0; + yyg->yy_full_match = 0; + yyg->yy_lp = 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 + * glcpp_lex_init() + */ + return 0; +} + +/* glcpp_lex_destroy is for both reentrant and non-reentrant scanners. */ +int glcpp_lex_destroy (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + glcpp__delete_buffer(YY_CURRENT_BUFFER ,yyscanner ); + YY_CURRENT_BUFFER_LVALUE = NULL; + glcpp_pop_buffer_state(yyscanner); + } + + /* Destroy the stack itself. */ + glcpp_free(yyg->yy_buffer_stack ,yyscanner); + yyg->yy_buffer_stack = NULL; + + /* Destroy the start condition stack. */ + glcpp_free(yyg->yy_start_stack ,yyscanner ); + yyg->yy_start_stack = NULL; + + glcpp_free ( yyg->yy_state_buf , yyscanner); + yyg->yy_state_buf = NULL; + + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * glcpp_lex() is called, initialization will occur. */ + yy_init_globals( yyscanner); + + /* Destroy the main struct (reentrant only). */ + glcpp_free ( yyscanner , yyscanner ); + yyscanner = NULL; + return 0; +} + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner) +{ + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +} +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner) +{ + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *glcpp_alloc (yy_size_t size , yyscan_t yyscanner) +{ + return (void *) malloc( size ); +} + +void *glcpp_realloc (void * ptr, yy_size_t size , yyscan_t yyscanner) +{ + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); +} + +void glcpp_free (void * ptr , yyscan_t yyscanner) +{ + free( (char *) ptr ); /* see glcpp_realloc() for (char *) cast */ +} + +#define YYTABLES_NAME "yytables" + +#line 278 "glcpp/glcpp-lex.l" + + + +void +glcpp_lex_set_source_string(glcpp_parser_t *parser, const char *shader) +{ + glcpp__scan_string(shader,parser->scanner); +} + -- cgit v1.2.3 From d4a04f315560704bf1103df0b93723e468725df7 Mon Sep 17 00:00:00 2001 From: Eric Anholt Date: Wed, 28 Jul 2010 16:58:39 -0700 Subject: glcpp: Add __VERSION__ define to the current language version. Fixes: glsl-version-define glsl-version-define-110 glsl-version-define-120 --- src/glsl/glcpp/glcpp-lex.c | 400 +++++++++--------- src/glsl/glcpp/glcpp-lex.l | 10 +- src/glsl/glcpp/glcpp-parse.c | 968 ++++++++++++++++++++++--------------------- src/glsl/glcpp/glcpp-parse.h | 37 +- src/glsl/glcpp/glcpp-parse.y | 73 ++-- 5 files changed, 774 insertions(+), 714 deletions(-) (limited to 'src/glsl/glcpp/glcpp-lex.c') diff --git a/src/glsl/glcpp/glcpp-lex.c b/src/glsl/glcpp/glcpp-lex.c index edf98a4afd..40db2c27c5 100644 --- a/src/glsl/glcpp/glcpp-lex.c +++ b/src/glsl/glcpp/glcpp-lex.c @@ -358,8 +358,8 @@ static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); *yy_cp = '\0'; \ yyg->yy_c_buf_p = yy_cp; -#define YY_NUM_RULES 40 -#define YY_END_OF_BUFFER 41 +#define YY_NUM_RULES 41 +#define YY_END_OF_BUFFER 42 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -367,26 +367,26 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static yyconst flex_int16_t yy_acclist[132] = +static yyconst flex_int16_t yy_acclist[133] = { 0, - 3, 3, 41, 36, 40, 37, 40, 38, 40, 40, - 35, 40, 40, 35, 40, 35, 40, 35, 40, 22, - 36, 40, 21, 36, 40, 35, 40, 35, 40, 35, - 40, 34, 36, 40, 34, 36, 40, 35, 40, 37, - 40, 20, 40, 40, 3, 40, 4, 40, 5, 40, - 39, 40, 36, 15, 37, 29, 32, 30, 2, 22, - 36, 22, 36, 36, 21, 36, 21, 36, 24, 26, - 28, 27, 25, 34, 36, 34, 36, 31, 37, 20, - 20, 3, 4, 5, 6, 5, 7, 1, 15, 23, - 36, 34, 36,16395, 23, 36, 34, 36, 15, 34, - - 36,16396,16397, 8203, 15, 8203, 34, 36, 8204, 15, - 8205, 15,16398, 16,16393, 19, 33, 34, 36, 18, - 8206, 15, 16, 8201, 15,16394,16401, 8202, 15, 8, - 8209 + 3, 3, 42, 37, 41, 38, 41, 39, 41, 41, + 36, 41, 41, 36, 41, 36, 41, 36, 41, 23, + 37, 41, 22, 37, 41, 36, 41, 36, 41, 36, + 41, 35, 37, 41, 35, 37, 41, 36, 41, 38, + 41, 21, 41, 41, 3, 41, 4, 41, 5, 41, + 40, 41, 37, 16, 38, 30, 33, 31, 2, 23, + 37, 23, 37, 37, 22, 37, 22, 37, 25, 27, + 29, 28, 26, 35, 37, 35, 37, 32, 38, 21, + 21, 3, 4, 5, 6, 5, 7, 1, 16, 24, + 37, 35, 37,16396, 24, 37, 35, 37, 16, 35, + + 37,16397,16398, 8204, 16, 8204, 35, 37, 8205, 16, + 8206, 16,16399, 17,16394, 20, 34, 35, 37, 19, + 8207, 16, 17, 8202, 16,16395,16402, 8203, 16, 9, + 8, 8210 } ; -static yyconst flex_int16_t yy_accept[151] = +static yyconst flex_int16_t yy_accept[152] = { 0, 1, 1, 1, 1, 1, 2, 3, 3, 3, 4, 6, 8, 10, 11, 13, 14, 16, 18, 20, 23, @@ -403,7 +403,8 @@ static yyconst flex_int16_t yy_accept[151] = 107, 107, 107, 107, 107, 109, 109, 109, 111, 111, 113, 114, 115, 115, 116, 116, 116, 117, 117, 120, 121, 121, 123, 124, 124, 124, 126, 127, 127, 127, - 128, 128, 128, 130, 131, 131, 131, 132, 132, 132 + 128, 128, 128, 130, 131, 132, 132, 132, 133, 133, + 133 } ; static yyconst flex_int32_t yy_ec[256] = @@ -446,48 +447,48 @@ static yyconst flex_int32_t yy_meta[40] = 1, 1, 1, 1, 1, 1, 1, 1, 1 } ; -static yyconst flex_int16_t yy_base[169] = +static yyconst flex_int16_t yy_base[170] = { 0, - 0, 38, 0, 0, 38, 39, 426, 425, 427, 48, - 43, 549, 423, 44, 63, 422, 59, 65, 87, 125, - 58, 67, 68, 164, 203, 40, 75, 241, 549, 421, - 549, 140, 549, 140, 420, 549, 144, 419, 418, 417, - 415, 414, 156, 179, 267, 0, 209, 413, 412, 411, - 410, 409, 387, 124, 407, 153, 403, 402, 154, 198, - 159, 155, 160, 192, 404, 549, 186, 549, 214, 549, - 359, 549, 162, 159, 227, 229, 230, 234, 199, 303, + 0, 38, 0, 0, 38, 39, 427, 426, 428, 48, + 43, 549, 424, 44, 63, 423, 59, 65, 87, 125, + 58, 67, 68, 164, 203, 40, 75, 241, 549, 422, + 549, 140, 549, 140, 421, 549, 144, 420, 419, 418, + 417, 415, 156, 179, 267, 0, 209, 414, 413, 412, + 411, 410, 388, 124, 408, 153, 404, 403, 154, 198, + 159, 155, 160, 192, 405, 549, 186, 549, 214, 549, + 404, 549, 162, 159, 227, 229, 230, 234, 199, 303, 232, 235, 236, 262, 56, 243, 237, 247, 245, 252, - 291, 358, 357, 292, 238, 296, 293, 254, 335, 256, - - 355, 354, 298, 294, 263, 352, 549, 350, 549, 299, - 297, 322, 325, 257, 306, 328, 346, 549, 345, 549, - 344, 343, 329, 342, 331, 332, 341, 333, 319, 335, - 337, 549, 248, 338, 246, 549, 197, 184, 336, 366, - 403, 182, 549, 141, 434, 416, 79, 473, 549, 512, - 514, 516, 518, 520, 522, 71, 524, 526, 528, 530, - 532, 534, 536, 538, 540, 542, 544, 546 + 291, 359, 358, 292, 238, 296, 293, 254, 336, 256, + + 356, 355, 298, 294, 263, 354, 549, 352, 549, 299, + 297, 322, 325, 257, 306, 328, 350, 549, 346, 549, + 345, 344, 329, 343, 331, 332, 342, 333, 320, 335, + 340, 549, 337, 338, 248, 549, 246, 197, 336, 366, + 403, 184, 549, 182, 141, 434, 416, 79, 473, 549, + 512, 514, 516, 518, 520, 522, 71, 524, 526, 528, + 530, 532, 534, 536, 538, 540, 542, 544, 546 } ; -static yyconst flex_int16_t yy_def[169] = +static yyconst flex_int16_t yy_def[170] = { 0, - 149, 1, 150, 150, 151, 151, 152, 152, 149, 153, - 154, 149, 154, 154, 154, 154, 154, 154, 149, 153, - 154, 154, 154, 155, 155, 154, 154, 154, 149, 156, - 149, 157, 149, 20, 154, 149, 154, 154, 154, 154, - 154, 158, 19, 20, 20, 20, 20, 154, 154, 154, - 154, 154, 25, 25, 154, 154, 28, 28, 154, 154, - 154, 154, 154, 154, 156, 149, 157, 149, 157, 149, - 158, 149, 45, 25, 154, 154, 154, 154, 154, 154, - 154, 154, 154, 20, 25, 154, 154, 154, 154, 154, - 154, 159, 160, 154, 154, 154, 154, 154, 25, 154, - - 161, 162, 154, 154, 154, 159, 149, 160, 149, 154, - 154, 154, 154, 154, 25, 154, 161, 149, 162, 149, - 163, 164, 154, 165, 154, 154, 154, 154, 25, 154, - 163, 149, 164, 154, 165, 149, 166, 167, 154, 149, - 154, 166, 149, 167, 168, 154, 154, 168, 0, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149 + 150, 1, 151, 151, 152, 152, 153, 153, 150, 154, + 155, 150, 155, 155, 155, 155, 155, 155, 150, 154, + 155, 155, 155, 156, 156, 155, 155, 155, 150, 157, + 150, 158, 150, 20, 155, 150, 155, 155, 155, 155, + 155, 159, 19, 20, 20, 20, 20, 155, 155, 155, + 155, 155, 25, 25, 155, 155, 28, 28, 155, 155, + 155, 155, 155, 155, 157, 150, 158, 150, 158, 150, + 159, 150, 45, 25, 155, 155, 155, 155, 155, 155, + 155, 155, 155, 20, 25, 155, 155, 155, 155, 155, + 155, 160, 161, 155, 155, 155, 155, 155, 25, 155, + + 162, 163, 155, 155, 155, 160, 150, 161, 150, 155, + 155, 155, 155, 155, 25, 155, 162, 150, 163, 150, + 164, 165, 155, 166, 155, 155, 155, 155, 25, 155, + 164, 150, 165, 155, 166, 150, 167, 168, 155, 150, + 155, 167, 150, 168, 155, 169, 155, 155, 169, 0, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150 } ; static yyconst flex_int16_t yy_nxt[589] = @@ -511,15 +512,15 @@ static yyconst flex_int16_t yy_nxt[589] = 70, 34, 34, 34, 56, 36, 36, 36, 57, 34, 47, 36, 36, 35, 34, 35, 36, 35, 35, 35, 35, 35, 35, 35, 35, 34, 34, 75, 35, 35, - 35, 84, 53, 80, 143, 85, 36, 81, 68, 82, - 34, 34, 34, 34, 36, 149, 149, 84, 34, 143, + 35, 84, 53, 80, 36, 85, 143, 81, 68, 82, + 34, 34, 34, 34, 36, 150, 150, 84, 34, 36, 36, 36, 35, 34, 35, 36, 35, 35, 35, 35, 35, 35, 35, 35, 34, 83, 68, 35, 35, 35, 34, 34, 34, 69, 70, 76, 54, 77, 34, 36, 78, 36, 36, 91, 36, 79, 36, 36, 36, 36, - 36, 35, 58, 36, 34, 36, 39, 36, 136, 36, - 36, 86, 89, 96, 36, 87, 36, 97, 36, 36, + 36, 35, 58, 36, 34, 36, 39, 36, 143, 36, + 136, 86, 89, 96, 36, 87, 36, 97, 36, 36, 111, 101, 88, 59, 60, 36, 90, 61, 98, 100, 102, 103, 62, 34, 34, 34, 63, 64, 73, 73, 73, 34, 104, 128, 73, 116, 34, 114, 73, 73, @@ -528,34 +529,34 @@ static yyconst flex_int16_t yy_nxt[589] = 36, 36, 34, 92, 92, 93, 92, 92, 92, 92, 92, 92, 92, 92, 105, 110, 113, 92, 92, 92, 125, 112, 121, 124, 36, 94, 122, 36, 129, 53, - 36, 36, 95, 36, 36, 36, 140, 36, 36, 132, - 36, 92, 53, 36, 136, 36, 132, 120, 118, 127, - 126, 130, 109, 138, 107, 137, 120, 118, 115, 109, - 107, 72, 134, 139, 141, 138, 35, 140, 36, 35, + 36, 36, 95, 36, 36, 36, 140, 36, 36, 36, + 36, 92, 132, 53, 36, 136, 36, 132, 120, 127, + 126, 130, 118, 138, 109, 137, 107, 120, 118, 115, + 109, 107, 134, 139, 141, 145, 35, 140, 36, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, - 35, 35, 35, 145, 145, 145, 145, 145, 145, 145, - 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, - - 145, 145, 145, 145, 35, 36, 66, 35, 35, 36, - 53, 36, 36, 36, 36, 36, 72, 36, 36, 36, - 36, 36, 36, 66, 36, 36, 149, 29, 29, 149, - 149, 149, 149, 146, 35, 35, 36, 35, 35, 35, - 35, 35, 147, 35, 35, 138, 149, 149, 35, 35, - 35, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 35, 35, 35, 36, 35, 35, 35, 35, - 35, 147, 35, 35, 149, 149, 149, 35, 35, 35, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 35, 29, 29, 30, 30, 33, 33, 34, 34, + 35, 35, 35, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + + 146, 146, 146, 146, 35, 36, 72, 66, 35, 35, + 36, 53, 36, 36, 36, 36, 36, 72, 36, 36, + 36, 36, 36, 36, 66, 36, 36, 150, 29, 29, + 150, 150, 150, 147, 35, 35, 36, 35, 35, 35, + 35, 35, 148, 35, 35, 138, 150, 150, 35, 35, + 35, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 35, 35, 35, 36, 35, 35, 35, 35, + 35, 148, 35, 35, 150, 150, 150, 35, 35, 35, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 35, 29, 29, 30, 30, 33, 33, 34, 34, 35, 35, 53, 53, 67, 67, 71, 71, 106, 106, 108, 108, 117, 117, 119, 119, 131, 131, 133, 133, - 135, 135, 142, 142, 144, 144, 148, 148, 9, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149 + 135, 135, 142, 142, 144, 144, 149, 149, 9, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150 } ; static yyconst flex_int16_t yy_chk[589] = @@ -567,27 +568,27 @@ static yyconst flex_int16_t yy_chk[589] = 5, 6, 26, 2, 11, 11, 14, 5, 6, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 14, 21, 17, 10, 10, 10, 15, 17, 18, 15, 22, - 23, 156, 21, 21, 18, 18, 27, 27, 26, 85, - 27, 147, 22, 23, 23, 85, 10, 19, 19, 19, + 23, 157, 21, 21, 18, 18, 27, 27, 26, 85, + 27, 148, 22, 23, 23, 85, 10, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, - 20, 20, 32, 144, 20, 37, 37, 54, 54, 32, + 20, 20, 32, 145, 20, 37, 37, 54, 54, 32, 32, 34, 34, 34, 56, 56, 59, 62, 56, 34, 20, 61, 63, 20, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 34, 43, 59, 24, 24, - 24, 73, 74, 61, 142, 74, 138, 62, 67, 63, - 44, 44, 44, 43, 64, 67, 67, 73, 44, 137, + 24, 73, 74, 61, 144, 74, 142, 62, 67, 63, + 44, 44, 44, 43, 64, 67, 67, 73, 44, 138, 60, 79, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 44, 64, 69, 25, 25, 25, 47, 47, 47, 69, 69, 60, 25, 60, 47, 75, 60, 76, 77, 79, 81, 60, 78, 82, 83, 87, - 95, 25, 28, 28, 47, 86, 28, 89, 135, 88, - 133, 75, 77, 81, 90, 76, 98, 82, 100, 114, + 95, 25, 28, 28, 47, 86, 28, 89, 137, 88, + 135, 75, 77, 81, 90, 76, 98, 82, 100, 114, 95, 87, 76, 28, 28, 105, 78, 28, 83, 86, 88, 89, 28, 84, 84, 84, 28, 28, 45, 45, 45, 84, 90, 114, 45, 100, 45, 98, 45, 45, @@ -596,34 +597,34 @@ static yyconst flex_int16_t yy_chk[589] = 103, 110, 45, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 91, 94, 97, 80, 80, 80, 111, 96, 103, 110, 112, 80, 104, 113, 115, 115, - 116, 123, 80, 125, 126, 128, 130, 130, 139, 131, - 134, 80, 129, 127, 124, 122, 121, 119, 117, 113, - 112, 116, 108, 126, 106, 125, 102, 101, 99, 93, - 92, 71, 123, 128, 134, 139, 140, 140, 140, 140, + 116, 123, 80, 125, 126, 128, 130, 130, 139, 133, + 134, 80, 131, 129, 127, 124, 122, 121, 119, 113, + 112, 116, 117, 126, 108, 125, 106, 102, 101, 99, + 93, 92, 123, 128, 134, 139, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, - 140, 140, 140, 140, 140, 141, 65, 58, 57, 55, - 53, 52, 51, 50, 49, 48, 42, 41, 146, 40, - 39, 38, 35, 30, 16, 13, 9, 8, 7, 0, - 0, 0, 0, 141, 145, 145, 145, 145, 145, 145, - 145, 145, 145, 145, 145, 146, 0, 0, 145, 145, - 145, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 140, 140, 140, 140, 140, 141, 71, 65, 58, 57, + 55, 53, 52, 51, 50, 49, 48, 42, 147, 41, + 40, 39, 38, 35, 30, 16, 13, 9, 8, 7, + 0, 0, 0, 141, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 147, 0, 0, 146, 146, + 146, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 145, 148, 148, 148, 148, 148, 148, 148, - 148, 148, 148, 148, 0, 0, 0, 148, 148, 148, + 0, 0, 146, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 0, 0, 0, 149, 149, 149, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 148, 150, 150, 151, 151, 152, 152, 153, 153, - 154, 154, 155, 155, 157, 157, 158, 158, 159, 159, - 160, 160, 161, 161, 162, 162, 163, 163, 164, 164, - 165, 165, 166, 166, 167, 167, 168, 168, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149 + 0, 149, 151, 151, 152, 152, 153, 153, 154, 154, + 155, 155, 156, 156, 158, 158, 159, 159, 160, 160, + 161, 161, 162, 162, 163, 163, 164, 164, 165, 165, + 166, 166, 167, 167, 168, 168, 169, 169, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150 } ; #define YY_TRAILING_MASK 0x2000 @@ -690,7 +691,7 @@ void glcpp_set_column (int column_no , yyscan_t yyscanner); } while(0); #define YY_USER_INIT yylineno = 0; yycolumn = 0; -#line 694 "glcpp/glcpp-lex.c" +#line 695 "glcpp/glcpp-lex.c" #define INITIAL 0 #define DONE 1 @@ -961,7 +962,7 @@ YY_DECL /* Single-line comments */ -#line 965 "glcpp/glcpp-lex.c" +#line 966 "glcpp/glcpp-lex.c" yylval = yylval_param; @@ -1024,7 +1025,7 @@ yy_match: 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 >= 150 ) + if ( yy_current_state >= 151 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; @@ -1128,71 +1129,82 @@ YY_RULE_SETUP return SPACE; } YY_BREAK -/* glcpp doesn't handle #extension, #version, or #pragma directives. - * Simply pass them through to the main compiler's lexer/parser. */ case 8: YY_RULE_SETUP -#line 92 "glcpp/glcpp-lex.l" +#line 90 "glcpp/glcpp-lex.l" { yylval->str = xtalloc_strdup (yyextra, yytext); yylineno++; yycolumn = 0; - return OTHER; + yyextra->space_tokens = 0; + return HASH_VERSION; } YY_BREAK +/* glcpp doesn't handle #extension, #version, or #pragma directives. + * Simply pass them through to the main compiler's lexer/parser. */ case 9: -/* rule 9 can match eol */ YY_RULE_SETUP -#line 99 "glcpp/glcpp-lex.l" +#line 100 "glcpp/glcpp-lex.l" { - yyextra->lexing_if = 1; - yyextra->space_tokens = 0; - return HASH_IFDEF; + yylval->str = xtalloc_strdup (yyextra, yytext); + yylineno++; + yycolumn = 0; + return OTHER; } YY_BREAK case 10: /* rule 10 can match eol */ YY_RULE_SETUP -#line 105 "glcpp/glcpp-lex.l" +#line 107 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; - return HASH_IFNDEF; + return HASH_IFDEF; } YY_BREAK case 11: /* rule 11 can match eol */ YY_RULE_SETUP -#line 111 "glcpp/glcpp-lex.l" +#line 113 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; - return HASH_IF; + return HASH_IFNDEF; } YY_BREAK case 12: /* rule 12 can match eol */ YY_RULE_SETUP -#line 117 "glcpp/glcpp-lex.l" +#line 119 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; - return HASH_ELIF; + return HASH_IF; } YY_BREAK case 13: /* rule 13 can match eol */ YY_RULE_SETUP -#line 123 "glcpp/glcpp-lex.l" +#line 125 "glcpp/glcpp-lex.l" { + yyextra->lexing_if = 1; yyextra->space_tokens = 0; - return HASH_ELSE; + return HASH_ELIF; } YY_BREAK case 14: /* rule 14 can match eol */ YY_RULE_SETUP -#line 128 "glcpp/glcpp-lex.l" +#line 131 "glcpp/glcpp-lex.l" +{ + yyextra->space_tokens = 0; + return HASH_ELSE; +} + YY_BREAK +case 15: +/* rule 15 can match eol */ +YY_RULE_SETUP +#line 136 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_ENDIF; @@ -1206,13 +1218,13 @@ YY_RULE_SETUP * * We use the lexing_if flag to avoid skipping any part of an * if conditional expression. */ -case 15: -/* rule 15 can match eol */ +case 16: +/* rule 16 can match eol */ *yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */ yyg->yy_c_buf_p = yy_cp -= 1; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 141 "glcpp/glcpp-lex.l" +#line 149 "glcpp/glcpp-lex.l" { /* Since this rule always matches, YY_USER_ACTION gets called for it, * wrongly incrementing yycolumn. We undo that effect here. */ @@ -1225,9 +1237,9 @@ YY_RULE_SETUP } } YY_BREAK -case 16: +case 17: YY_RULE_SETUP -#line 153 "glcpp/glcpp-lex.l" +#line 161 "glcpp/glcpp-lex.l" { char *p; for (p = yytext; !isalpha(p[0]); p++); /* skip " # " */ @@ -1235,168 +1247,168 @@ YY_RULE_SETUP glcpp_error(yylloc, yyextra, "#error%s", p); } YY_BREAK -case 17: +case 18: YY_RULE_SETUP -#line 160 "glcpp/glcpp-lex.l" +#line 168 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_DEFINE_FUNC; } YY_BREAK -case 18: +case 19: YY_RULE_SETUP -#line 165 "glcpp/glcpp-lex.l" +#line 173 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_DEFINE_OBJ; } YY_BREAK -case 19: +case 20: YY_RULE_SETUP -#line 170 "glcpp/glcpp-lex.l" +#line 178 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_UNDEF; } YY_BREAK -case 20: +case 21: YY_RULE_SETUP -#line 175 "glcpp/glcpp-lex.l" +#line 183 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH; } YY_BREAK -case 21: +case 22: YY_RULE_SETUP -#line 180 "glcpp/glcpp-lex.l" +#line 188 "glcpp/glcpp-lex.l" { yylval->str = xtalloc_strdup (yyextra, yytext); return INTEGER_STRING; } YY_BREAK -case 22: +case 23: YY_RULE_SETUP -#line 185 "glcpp/glcpp-lex.l" +#line 193 "glcpp/glcpp-lex.l" { yylval->str = xtalloc_strdup (yyextra, yytext); return INTEGER_STRING; } YY_BREAK -case 23: +case 24: YY_RULE_SETUP -#line 190 "glcpp/glcpp-lex.l" +#line 198 "glcpp/glcpp-lex.l" { yylval->str = xtalloc_strdup (yyextra, yytext); return INTEGER_STRING; } YY_BREAK -case 24: +case 25: YY_RULE_SETUP -#line 195 "glcpp/glcpp-lex.l" +#line 203 "glcpp/glcpp-lex.l" { return LEFT_SHIFT; } YY_BREAK -case 25: +case 26: YY_RULE_SETUP -#line 199 "glcpp/glcpp-lex.l" +#line 207 "glcpp/glcpp-lex.l" { return RIGHT_SHIFT; } YY_BREAK -case 26: +case 27: YY_RULE_SETUP -#line 203 "glcpp/glcpp-lex.l" +#line 211 "glcpp/glcpp-lex.l" { return LESS_OR_EQUAL; } YY_BREAK -case 27: +case 28: YY_RULE_SETUP -#line 207 "glcpp/glcpp-lex.l" +#line 215 "glcpp/glcpp-lex.l" { return GREATER_OR_EQUAL; } YY_BREAK -case 28: +case 29: YY_RULE_SETUP -#line 211 "glcpp/glcpp-lex.l" +#line 219 "glcpp/glcpp-lex.l" { return EQUAL; } YY_BREAK -case 29: +case 30: YY_RULE_SETUP -#line 215 "glcpp/glcpp-lex.l" +#line 223 "glcpp/glcpp-lex.l" { return NOT_EQUAL; } YY_BREAK -case 30: +case 31: YY_RULE_SETUP -#line 219 "glcpp/glcpp-lex.l" +#line 227 "glcpp/glcpp-lex.l" { return AND; } YY_BREAK -case 31: +case 32: YY_RULE_SETUP -#line 223 "glcpp/glcpp-lex.l" +#line 231 "glcpp/glcpp-lex.l" { return OR; } YY_BREAK -case 32: +case 33: YY_RULE_SETUP -#line 227 "glcpp/glcpp-lex.l" +#line 235 "glcpp/glcpp-lex.l" { return PASTE; } YY_BREAK -case 33: +case 34: YY_RULE_SETUP -#line 231 "glcpp/glcpp-lex.l" +#line 239 "glcpp/glcpp-lex.l" { return DEFINED; } YY_BREAK -case 34: +case 35: YY_RULE_SETUP -#line 235 "glcpp/glcpp-lex.l" +#line 243 "glcpp/glcpp-lex.l" { yylval->str = xtalloc_strdup (yyextra, yytext); return IDENTIFIER; } YY_BREAK -case 35: +case 36: YY_RULE_SETUP -#line 240 "glcpp/glcpp-lex.l" +#line 248 "glcpp/glcpp-lex.l" { return yytext[0]; } YY_BREAK -case 36: +case 37: YY_RULE_SETUP -#line 244 "glcpp/glcpp-lex.l" +#line 252 "glcpp/glcpp-lex.l" { yylval->str = xtalloc_strdup (yyextra, yytext); return OTHER; } YY_BREAK -case 37: +case 38: YY_RULE_SETUP -#line 249 "glcpp/glcpp-lex.l" +#line 257 "glcpp/glcpp-lex.l" { if (yyextra->space_tokens) { return SPACE; } } YY_BREAK -case 38: -/* rule 38 can match eol */ +case 39: +/* rule 39 can match eol */ YY_RULE_SETUP -#line 255 "glcpp/glcpp-lex.l" +#line 263 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 0; yylineno++; @@ -1406,7 +1418,7 @@ YY_RULE_SETUP YY_BREAK /* Handle missing newline at EOF. */ case YY_STATE_EOF(INITIAL): -#line 263 "glcpp/glcpp-lex.l" +#line 271 "glcpp/glcpp-lex.l" { BEGIN DONE; /* Don't keep matching this rule forever. */ yyextra->lexing_if = 0; @@ -1417,20 +1429,20 @@ case YY_STATE_EOF(INITIAL): only have this action here so that we can pretend to call some generated functions, (to avoid "defined but not used" warnings. */ -case 39: +case 40: YY_RULE_SETUP -#line 273 "glcpp/glcpp-lex.l" +#line 281 "glcpp/glcpp-lex.l" { unput('.'); yy_top_state(yyextra); } YY_BREAK -case 40: +case 41: YY_RULE_SETUP -#line 278 "glcpp/glcpp-lex.l" +#line 286 "glcpp/glcpp-lex.l" ECHO; YY_BREAK -#line 1434 "glcpp/glcpp-lex.c" +#line 1446 "glcpp/glcpp-lex.c" case YY_STATE_EOF(DONE): case YY_STATE_EOF(COMMENT): case YY_STATE_EOF(UNREACHABLE): @@ -1696,7 +1708,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) 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 >= 150 ) + if ( yy_current_state >= 151 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; @@ -1720,11 +1732,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner) 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 >= 150 ) + if ( yy_current_state >= 151 ) 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 == 149); + yy_is_jam = (yy_current_state == 150); if ( ! yy_is_jam ) *yyg->yy_state_ptr++ = yy_current_state; @@ -2624,7 +2636,7 @@ void glcpp_free (void * ptr , yyscan_t yyscanner) #define YYTABLES_NAME "yytables" -#line 278 "glcpp/glcpp-lex.l" +#line 286 "glcpp/glcpp-lex.l" diff --git a/src/glsl/glcpp/glcpp-lex.l b/src/glsl/glcpp/glcpp-lex.l index a4c891bdc6..17a097e633 100644 --- a/src/glsl/glcpp/glcpp-lex.l +++ b/src/glsl/glcpp/glcpp-lex.l @@ -87,9 +87,17 @@ HEXADECIMAL_INTEGER 0[xX][0-9a-fA-F]+[uU]? return SPACE; } +{HASH}(version) { + yylval->str = xtalloc_strdup (yyextra, yytext); + yylineno++; + yycolumn = 0; + yyextra->space_tokens = 0; + return HASH_VERSION; +} + /* glcpp doesn't handle #extension, #version, or #pragma directives. * Simply pass them through to the main compiler's lexer/parser. */ -{HASH}(extension|version|pragma)[^\n]+ { +{HASH}(extension|pragma)[^\n]+ { yylval->str = xtalloc_strdup (yyextra, yytext); yylineno++; yycolumn = 0; diff --git a/src/glsl/glcpp/glcpp-parse.c b/src/glsl/glcpp/glcpp-parse.c index bfbd97f3d8..f0ad4a08ec 100644 --- a/src/glsl/glcpp/glcpp-parse.c +++ b/src/glsl/glcpp/glcpp-parse.c @@ -203,10 +203,13 @@ glcpp_parser_lex (YYSTYPE *yylval, YYLTYPE *yylloc, glcpp_parser_t *parser); static void glcpp_parser_lex_from (glcpp_parser_t *parser, token_list_t *list); +static void +add_builtin_define(glcpp_parser_t *parser, const char *name, int value); + /* Line 189 of yacc.c */ -#line 210 "glcpp/glcpp-parse.c" +#line 213 "glcpp/glcpp-parse.c" /* Enabling traces. */ #ifndef YYDEBUG @@ -246,24 +249,25 @@ glcpp_parser_lex_from (glcpp_parser_t *parser, token_list_t *list); HASH_IFDEF = 268, HASH_IFNDEF = 269, HASH_UNDEF = 270, - IDENTIFIER = 271, - IF_EXPANDED = 272, - INTEGER = 273, - INTEGER_STRING = 274, - NEWLINE = 275, - OTHER = 276, - PLACEHOLDER = 277, - SPACE = 278, - PASTE = 279, - OR = 280, - AND = 281, - NOT_EQUAL = 282, - EQUAL = 283, - GREATER_OR_EQUAL = 284, - LESS_OR_EQUAL = 285, - RIGHT_SHIFT = 286, - LEFT_SHIFT = 287, - UNARY = 288 + HASH_VERSION = 271, + IDENTIFIER = 272, + IF_EXPANDED = 273, + INTEGER = 274, + INTEGER_STRING = 275, + NEWLINE = 276, + OTHER = 277, + PLACEHOLDER = 278, + SPACE = 279, + PASTE = 280, + OR = 281, + AND = 282, + NOT_EQUAL = 283, + EQUAL = 284, + GREATER_OR_EQUAL = 285, + LESS_OR_EQUAL = 286, + RIGHT_SHIFT = 287, + LEFT_SHIFT = 288, + UNARY = 289 }; #endif @@ -293,7 +297,7 @@ typedef struct YYLTYPE /* Line 264 of yacc.c */ -#line 297 "glcpp/glcpp-parse.c" +#line 301 "glcpp/glcpp-parse.c" #ifdef short # undef short @@ -510,20 +514,20 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 2 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 673 +#define YYLAST 604 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 56 +#define YYNTOKENS 57 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 16 +#define YYNNTS 17 /* YYNRULES -- Number of rules. */ -#define YYNRULES 98 +#define YYNRULES 100 /* YYNRULES -- Number of states. */ -#define YYNSTATES 157 +#define YYNSTATES 161 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ #define YYUNDEFTOK 2 -#define YYMAXUTOK 288 +#define YYMAXUTOK 289 #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) @@ -534,16 +538,16 @@ static const yytype_uint8 yytranslate[] = 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 46, 2, 2, 2, 42, 29, 2, - 44, 45, 40, 38, 48, 39, 53, 41, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 54, - 32, 55, 33, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 47, 2, 2, 2, 43, 30, 2, + 45, 46, 41, 39, 49, 40, 54, 42, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 55, + 33, 56, 34, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 49, 2, 50, 28, 2, 2, 2, 2, 2, + 2, 50, 2, 51, 29, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 51, 27, 52, 47, 2, 2, 2, + 2, 2, 2, 52, 28, 53, 48, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, @@ -559,7 +563,7 @@ static const yytype_uint8 yytranslate[] = 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 30, 31, 34, 35, 36, 37, 43 + 25, 26, 27, 31, 32, 35, 36, 37, 38, 44 }; #if YYDEBUG @@ -569,63 +573,65 @@ static const yytype_uint16 yyprhs[] = { 0, 0, 3, 4, 7, 9, 11, 13, 16, 20, 24, 29, 36, 44, 48, 52, 57, 62, 66, 69, - 72, 75, 78, 80, 82, 86, 90, 94, 98, 102, - 106, 110, 114, 118, 122, 126, 130, 134, 138, 142, - 146, 150, 154, 157, 160, 163, 166, 170, 172, 176, - 178, 181, 184, 185, 187, 188, 190, 193, 198, 200, - 202, 205, 207, 210, 212, 214, 216, 218, 220, 222, - 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, - 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, - 264, 266, 268, 270, 272, 274, 276, 278, 280 + 72, 75, 79, 82, 84, 86, 88, 92, 96, 100, + 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, + 144, 148, 152, 156, 160, 163, 166, 169, 172, 176, + 178, 182, 184, 187, 190, 191, 193, 194, 196, 199, + 204, 206, 208, 211, 213, 216, 218, 220, 222, 224, + 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, + 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, + 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, + 286 }; /* YYRHS -- A `-1'-separated list of the rules' RHS. */ static const yytype_int8 yyrhs[] = { - 57, 0, -1, -1, 57, 58, -1, 60, -1, 63, - -1, 59, -1, 6, 64, -1, 17, 61, 20, -1, - 5, 61, 20, -1, 8, 16, 65, 20, -1, 7, - 16, 44, 45, 65, 20, -1, 7, 16, 44, 62, - 45, 65, 20, -1, 15, 16, 20, -1, 12, 68, - 20, -1, 13, 16, 66, 20, -1, 14, 16, 66, - 20, -1, 9, 68, 20, -1, 9, 20, -1, 10, - 20, -1, 11, 20, -1, 6, 20, -1, 19, -1, - 18, -1, 61, 25, 61, -1, 61, 26, 61, -1, - 61, 27, 61, -1, 61, 28, 61, -1, 61, 29, - 61, -1, 61, 30, 61, -1, 61, 31, 61, -1, - 61, 34, 61, -1, 61, 35, 61, -1, 61, 33, - 61, -1, 61, 32, 61, -1, 61, 36, 61, -1, - 61, 37, 61, -1, 61, 39, 61, -1, 61, 38, - 61, -1, 61, 42, 61, -1, 61, 41, 61, -1, - 61, 40, 61, -1, 46, 61, -1, 47, 61, -1, - 39, 61, -1, 38, 61, -1, 44, 61, 45, -1, - 16, -1, 62, 48, 16, -1, 20, -1, 69, 20, - -1, 69, 20, -1, -1, 69, -1, -1, 69, -1, - 4, 16, -1, 4, 44, 16, 45, -1, 70, -1, - 67, -1, 68, 67, -1, 70, -1, 69, 70, -1, - 16, -1, 19, -1, 71, -1, 21, -1, 23, -1, - 49, -1, 50, -1, 44, -1, 45, -1, 51, -1, - 52, -1, 53, -1, 29, -1, 40, -1, 38, -1, - 39, -1, 47, -1, 46, -1, 41, -1, 42, -1, - 37, -1, 36, -1, 32, -1, 33, -1, 35, -1, - 34, -1, 31, -1, 30, -1, 28, -1, 27, -1, - 26, -1, 25, -1, 54, -1, 48, -1, 55, -1, - 24, -1 + 58, 0, -1, -1, 58, 59, -1, 61, -1, 65, + -1, 60, -1, 6, 66, -1, 18, 63, 21, -1, + 5, 63, 21, -1, 8, 17, 67, 21, -1, 7, + 17, 45, 46, 67, 21, -1, 7, 17, 45, 64, + 46, 67, 21, -1, 15, 17, 21, -1, 12, 70, + 21, -1, 13, 17, 68, 21, -1, 14, 17, 68, + 21, -1, 9, 70, 21, -1, 9, 21, -1, 10, + 21, -1, 11, 21, -1, 16, 62, 21, -1, 6, + 21, -1, 20, -1, 19, -1, 62, -1, 63, 26, + 63, -1, 63, 27, 63, -1, 63, 28, 63, -1, + 63, 29, 63, -1, 63, 30, 63, -1, 63, 31, + 63, -1, 63, 32, 63, -1, 63, 35, 63, -1, + 63, 36, 63, -1, 63, 34, 63, -1, 63, 33, + 63, -1, 63, 37, 63, -1, 63, 38, 63, -1, + 63, 40, 63, -1, 63, 39, 63, -1, 63, 43, + 63, -1, 63, 42, 63, -1, 63, 41, 63, -1, + 47, 63, -1, 48, 63, -1, 40, 63, -1, 39, + 63, -1, 45, 63, 46, -1, 17, -1, 64, 49, + 17, -1, 21, -1, 71, 21, -1, 71, 21, -1, + -1, 71, -1, -1, 71, -1, 4, 17, -1, 4, + 45, 17, 46, -1, 72, -1, 69, -1, 70, 69, + -1, 72, -1, 71, 72, -1, 17, -1, 20, -1, + 73, -1, 22, -1, 24, -1, 50, -1, 51, -1, + 45, -1, 46, -1, 52, -1, 53, -1, 54, -1, + 30, -1, 41, -1, 39, -1, 40, -1, 48, -1, + 47, -1, 42, -1, 43, -1, 38, -1, 37, -1, + 33, -1, 34, -1, 36, -1, 35, -1, 32, -1, + 31, -1, 29, -1, 28, -1, 27, -1, 26, -1, + 55, -1, 49, -1, 56, -1, 25, -1 }; /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ static const yytype_uint16 yyrline[] = { - 0, 166, 166, 168, 172, 175, 180, 181, 185, 188, - 194, 197, 200, 203, 211, 223, 228, 233, 245, 256, - 259, 262, 266, 275, 278, 281, 284, 287, 290, 293, - 296, 299, 302, 305, 308, 311, 314, 317, 320, 323, - 326, 329, 332, 335, 338, 341, 344, 350, 355, 363, - 364, 368, 374, 375, 378, 380, 387, 391, 395, 400, - 406, 414, 420, 428, 432, 436, 440, 444, 451, 452, - 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, - 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, - 473, 474, 475, 476, 477, 478, 479, 480, 481 + 0, 169, 169, 171, 175, 178, 183, 184, 188, 191, + 197, 200, 203, 206, 214, 226, 231, 236, 248, 259, + 262, 265, 274, 278, 287, 292, 293, 296, 299, 302, + 305, 308, 311, 314, 317, 320, 323, 326, 329, 332, + 335, 338, 341, 344, 347, 350, 353, 356, 359, 365, + 370, 378, 379, 383, 389, 390, 393, 395, 402, 406, + 410, 415, 421, 429, 435, 443, 447, 451, 455, 459, + 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, + 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496 }; #endif @@ -637,16 +643,16 @@ static const char *const yytname[] = "$end", "error", "$undefined", "COMMA_FINAL", "DEFINED", "ELIF_EXPANDED", "HASH", "HASH_DEFINE_FUNC", "HASH_DEFINE_OBJ", "HASH_ELIF", "HASH_ELSE", "HASH_ENDIF", "HASH_IF", "HASH_IFDEF", - "HASH_IFNDEF", "HASH_UNDEF", "IDENTIFIER", "IF_EXPANDED", "INTEGER", - "INTEGER_STRING", "NEWLINE", "OTHER", "PLACEHOLDER", "SPACE", "PASTE", - "OR", "AND", "'|'", "'^'", "'&'", "NOT_EQUAL", "EQUAL", "'<'", "'>'", - "GREATER_OR_EQUAL", "LESS_OR_EQUAL", "RIGHT_SHIFT", "LEFT_SHIFT", "'+'", - "'-'", "'*'", "'/'", "'%'", "UNARY", "'('", "')'", "'!'", "'~'", "','", - "'['", "']'", "'{'", "'}'", "'.'", "';'", "'='", "$accept", "input", - "line", "expanded_line", "control_line", "expression", "identifier_list", - "text_line", "non_directive", "replacement_list", "junk", - "conditional_token", "conditional_tokens", "pp_tokens", - "preprocessing_token", "operator", 0 + "HASH_IFNDEF", "HASH_UNDEF", "HASH_VERSION", "IDENTIFIER", "IF_EXPANDED", + "INTEGER", "INTEGER_STRING", "NEWLINE", "OTHER", "PLACEHOLDER", "SPACE", + "PASTE", "OR", "AND", "'|'", "'^'", "'&'", "NOT_EQUAL", "EQUAL", "'<'", + "'>'", "GREATER_OR_EQUAL", "LESS_OR_EQUAL", "RIGHT_SHIFT", "LEFT_SHIFT", + "'+'", "'-'", "'*'", "'/'", "'%'", "UNARY", "'('", "')'", "'!'", "'~'", + "','", "'['", "']'", "'{'", "'}'", "'.'", "';'", "'='", "$accept", + "input", "line", "expanded_line", "control_line", "integer_constant", + "expression", "identifier_list", "text_line", "non_directive", + "replacement_list", "junk", "conditional_token", "conditional_tokens", + "pp_tokens", "preprocessing_token", "operator", 0 }; #endif @@ -657,26 +663,27 @@ static const yytype_uint16 yytoknum[] = { 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 124, 94, 38, - 282, 283, 60, 62, 284, 285, 286, 287, 43, 45, - 42, 47, 37, 288, 40, 41, 33, 126, 44, 91, - 93, 123, 125, 46, 59, 61 + 275, 276, 277, 278, 279, 280, 281, 282, 124, 94, + 38, 283, 284, 60, 62, 285, 286, 287, 288, 43, + 45, 42, 47, 37, 289, 40, 41, 33, 126, 44, + 91, 93, 123, 125, 46, 59, 61 }; # endif /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const yytype_uint8 yyr1[] = { - 0, 56, 57, 57, 58, 58, 58, 58, 59, 59, - 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, - 60, 60, 61, 61, 61, 61, 61, 61, 61, 61, + 0, 57, 58, 58, 59, 59, 59, 59, 60, 60, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, - 61, 61, 61, 61, 61, 61, 61, 62, 62, 63, - 63, 64, 65, 65, 66, 66, 67, 67, 67, 68, - 68, 69, 69, 70, 70, 70, 70, 70, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71 + 61, 61, 61, 62, 62, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63, 63, 63, 64, + 64, 65, 65, 66, 67, 67, 68, 68, 69, 69, + 69, 70, 70, 71, 71, 72, 72, 72, 72, 72, + 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, + 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, + 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, + 73 }; /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ @@ -684,14 +691,15 @@ static const yytype_uint8 yyr2[] = { 0, 2, 0, 2, 1, 1, 1, 2, 3, 3, 4, 6, 7, 3, 3, 4, 4, 3, 2, 2, - 2, 2, 1, 1, 3, 3, 3, 3, 3, 3, + 2, 3, 2, 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 2, 2, 2, 2, 3, 1, 3, 1, - 2, 2, 0, 1, 0, 1, 2, 4, 1, 1, - 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 3, 3, 3, 3, 2, 2, 2, 2, 3, 1, + 3, 1, 2, 2, 0, 1, 0, 1, 2, 4, + 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1 + 1 }; /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state @@ -700,58 +708,60 @@ static const yytype_uint8 yyr2[] = static const yytype_uint8 yydefact[] = { 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 63, 0, 64, 49, 66, 67, - 98, 94, 93, 92, 91, 75, 90, 89, 85, 86, - 88, 87, 84, 83, 77, 78, 76, 81, 82, 70, - 71, 80, 79, 96, 68, 69, 72, 73, 74, 95, - 97, 3, 6, 4, 5, 0, 61, 65, 23, 22, - 0, 0, 0, 0, 0, 0, 21, 7, 0, 0, - 52, 0, 18, 59, 0, 58, 19, 20, 0, 54, - 54, 0, 0, 50, 62, 45, 44, 0, 42, 43, - 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 51, - 0, 0, 53, 56, 0, 17, 60, 14, 0, 55, - 0, 13, 8, 46, 24, 25, 26, 27, 28, 29, - 30, 34, 33, 31, 32, 35, 36, 38, 37, 41, - 40, 39, 47, 52, 0, 10, 0, 15, 16, 0, - 52, 0, 57, 11, 0, 48, 12 + 0, 0, 0, 0, 0, 65, 0, 66, 51, 68, + 69, 100, 96, 95, 94, 93, 77, 92, 91, 87, + 88, 90, 89, 86, 85, 79, 80, 78, 83, 84, + 72, 73, 82, 81, 98, 70, 71, 74, 75, 76, + 97, 99, 3, 6, 4, 5, 0, 63, 67, 24, + 23, 0, 0, 0, 0, 0, 25, 0, 22, 7, + 0, 0, 54, 0, 18, 61, 0, 60, 19, 20, + 0, 56, 56, 0, 0, 0, 52, 64, 47, 46, + 0, 44, 45, 9, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 53, 0, 0, 55, 58, 0, 17, 62, + 14, 0, 57, 0, 13, 21, 8, 48, 26, 27, + 28, 29, 30, 31, 32, 36, 35, 33, 34, 37, + 38, 40, 39, 43, 42, 41, 49, 54, 0, 10, + 0, 15, 16, 0, 54, 0, 59, 11, 0, 50, + 12 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - -1, 1, 51, 52, 53, 65, 144, 54, 67, 111, - 118, 73, 74, 112, 56, 57 + -1, 1, 52, 53, 54, 66, 67, 148, 55, 69, + 114, 121, 75, 76, 115, 57, 58 }; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ -#define YYPACT_NINF -120 +#define YYPACT_NINF -146 static const yytype_int16 yypact[] = { - -120, 108, -120, -17, 356, -9, 9, 160, -15, 6, - 316, 17, 18, 29, -120, -17, -120, -120, -120, -120, - -120, -120, -120, -120, -120, -120, -120, -120, -120, -120, - -120, -120, -120, -120, -120, -120, -120, -120, -120, -120, - -120, -120, -120, -120, -120, -120, -120, -120, -120, -120, - -120, -120, -120, -120, -120, 396, -120, -120, -120, -120, - -17, -17, -17, -17, -17, 512, -120, -120, 436, 2, - 476, -8, -120, -120, 212, -120, -120, -120, 264, 476, - 476, 39, 535, -120, -120, -120, -120, 553, -120, -120, - -120, -17, -17, -17, -17, -17, -17, -17, -17, -17, - -17, -17, -17, -17, -17, -17, -17, -17, -17, -120, - -10, 40, 476, -120, 49, -120, -120, -120, 46, 476, - 48, -120, -120, -120, 573, 589, 604, 618, 631, -23, - -23, 1, 1, 1, 1, 16, 16, 22, 22, -120, - -120, -120, -120, 476, -1, -120, 24, -120, -120, 50, - 476, 56, -120, -120, 53, -120, -120 + -146, 111, -146, 429, -10, -9, -4, 151, -15, 27, + 271, 54, 63, 86, 82, -146, 429, -146, -146, -146, + -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, + -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, + -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, + -146, -146, -146, -146, -146, -146, 311, -146, -146, -146, + -146, 429, 429, 429, 429, 429, -146, 452, -146, -146, + 351, 59, 391, 17, -146, -146, 191, -146, -146, -146, + 231, 391, 391, 84, 85, 475, -146, -146, -146, -146, + 424, -146, -146, -146, 429, 429, 429, 429, 429, 429, + 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, + 429, 429, -146, 30, 88, 391, -146, 90, -146, -146, + -146, 89, 391, 91, -146, -146, -146, -146, 492, 508, + 523, 537, 550, 561, 561, 18, 18, 18, 18, 25, + 25, 36, 36, -146, -146, -146, -146, 391, 26, -146, + 67, -146, -146, 93, 391, 113, -146, -146, 148, -146, + -146 }; /* YYPGOTO[NTERM-NUM]. */ -static const yytype_int8 yypgoto[] = +static const yytype_int16 yypgoto[] = { - -120, -120, -120, -120, -120, -11, -120, -120, -120, -119, - -6, -46, 65, 19, -7, -120 + -146, -146, -146, -146, -146, 120, -11, -146, -146, -146, + -145, 92, -6, 160, 0, -7, -146 }; /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If @@ -761,168 +771,155 @@ static const yytype_int8 yypgoto[] = #define YYTABLE_NINF -1 static const yytype_uint8 yytable[] = { - 75, 58, 59, 75, 82, 76, 142, 69, 113, 98, - 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, - 55, 60, 61, 68, 149, 70, 77, 62, 116, 63, - 64, 154, 116, 79, 80, 143, 114, 102, 103, 104, - 105, 106, 107, 108, 150, 81, 110, 151, 84, 85, - 86, 87, 88, 89, 104, 105, 106, 107, 108, 121, - 145, 84, 106, 107, 108, 146, 147, 75, 148, 152, - 153, 75, 155, 156, 120, 78, 0, 0, 0, 0, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 119, 119, - 0, 0, 0, 0, 0, 84, 0, 0, 2, 0, - 0, 0, 84, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 0, 16, 17, 18, - 0, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 0, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 71, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 14, 0, 0, 16, - 72, 18, 0, 19, 20, 21, 22, 23, 24, 25, + 77, 56, 153, 77, 70, 85, 78, 15, 71, 158, + 17, 68, 19, 72, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 0, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 71, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, - 0, 16, 115, 18, 0, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 0, 39, 40, 41, 42, - 43, 44, 45, 46, 47, 48, 49, 50, 71, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 14, 0, 0, 16, 117, 18, 0, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 0, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 71, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 14, 0, 0, 16, 0, 18, 0, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 0, - 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 14, 0, 0, 16, 66, 18, 0, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 0, - 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 14, 0, 0, 16, 83, 18, 0, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 0, - 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 14, 0, 0, 16, 109, 18, 0, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 0, - 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 14, 0, 0, 16, 0, 18, 0, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 0, - 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 90, 0, 0, 0, 0, 91, 92, 93, + 36, 37, 38, 39, 116, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 146, 79, 87, + 88, 89, 90, 91, 92, 105, 106, 107, 108, 109, + 110, 111, 117, 87, 107, 108, 109, 110, 111, 77, + 119, 81, 154, 77, 119, 155, 147, 109, 110, 111, + 82, 122, 122, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 59, 60, 83, 113, 124, 125, 150, 87, 149, + 151, 2, 152, 156, 157, 87, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 159, 17, 18, 19, 84, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 73, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 15, 160, + 80, 17, 74, 19, 123, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 73, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 15, 0, + 0, 17, 118, 19, 0, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 73, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 15, 0, + 0, 17, 120, 19, 0, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 73, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 15, 0, + 0, 17, 0, 19, 0, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 0, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 15, 0, + 0, 17, 86, 19, 0, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 0, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 15, 0, + 0, 17, 112, 19, 0, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 0, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 15, 0, + 0, 17, 0, 19, 0, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 0, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 59, 60, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 122, 0, 0, 0, 0, - 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 91, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 106, 107, 108, 0, 0, 123, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 106, 107, 108, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108 + 104, 105, 106, 107, 108, 109, 110, 111, 61, 62, + 127, 0, 0, 93, 63, 0, 64, 65, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 126, 0, 0, 0, + 0, 94, 95, 96, 97, 98, 99, 100, 101, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111 }; static const yytype_int16 yycheck[] = { - 7, 18, 19, 10, 15, 20, 16, 16, 16, 32, - 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, - 1, 38, 39, 4, 143, 16, 20, 44, 74, 46, - 47, 150, 78, 16, 16, 45, 44, 36, 37, 38, - 39, 40, 41, 42, 45, 16, 44, 48, 55, 60, - 61, 62, 63, 64, 38, 39, 40, 41, 42, 20, - 20, 68, 40, 41, 42, 16, 20, 74, 20, 45, - 20, 78, 16, 20, 80, 10, -1, -1, -1, -1, - 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 79, 80, - -1, -1, -1, -1, -1, 112, -1, -1, 0, -1, - -1, -1, 119, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, -1, 19, 20, 21, - -1, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, -1, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 4, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 16, -1, -1, 19, - 20, 21, -1, 23, 24, 25, 26, 27, 28, 29, + 7, 1, 147, 10, 4, 16, 21, 17, 17, 154, + 20, 21, 22, 17, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, -1, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 4, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 16, -1, - -1, 19, 20, 21, -1, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, -1, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 4, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 16, -1, -1, 19, 20, 21, -1, 23, 24, 25, + 40, 41, 42, 43, 17, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 17, 21, 56, + 61, 62, 63, 64, 65, 37, 38, 39, 40, 41, + 42, 43, 45, 70, 39, 40, 41, 42, 43, 76, + 76, 17, 46, 80, 80, 49, 46, 41, 42, 43, + 17, 81, 82, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 19, 20, 17, 45, 21, 21, 17, 115, 21, + 21, 0, 21, 46, 21, 122, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 17, 20, 21, 22, 14, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 4, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 17, 21, + 10, 20, 21, 22, 82, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 4, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 17, -1, + -1, 20, 21, 22, -1, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 4, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 17, -1, + -1, 20, 21, 22, -1, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 4, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 17, -1, + -1, 20, -1, 22, -1, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, -1, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 17, -1, + -1, 20, 21, 22, -1, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, -1, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 17, -1, + -1, 20, 21, 22, -1, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, -1, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 17, -1, + -1, 20, -1, 22, -1, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, -1, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 19, 20, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, -1, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 16, -1, -1, 19, -1, 21, -1, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 16, -1, -1, 19, 20, 21, -1, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 16, -1, -1, 19, 20, 21, -1, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 16, -1, -1, 19, 20, 21, -1, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 16, -1, -1, 19, -1, 21, -1, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, -1, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 20, -1, -1, -1, -1, 25, 26, 27, + 36, 37, 38, 39, 40, 41, 42, 43, 39, 40, + 46, -1, -1, 21, 45, -1, 47, 48, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 20, -1, -1, -1, -1, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, -1, -1, 45, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 27, 28, 29, 30, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 29, 30, 31, + 38, 39, 40, 41, 42, 43, 21, -1, -1, -1, + -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 30, 31, 32, 33, 34, 35, 36, 37, 38, - 39, 40, 41, 42 + 42, 43, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ static const yytype_uint8 yystos[] = { - 0, 57, 0, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 19, 20, 21, 23, + 0, 58, 0, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 58, 59, 60, 63, 69, 70, 71, 18, 19, - 38, 39, 44, 46, 47, 61, 20, 64, 69, 16, - 16, 4, 20, 67, 68, 70, 20, 20, 68, 16, - 16, 16, 61, 20, 70, 61, 61, 61, 61, 61, - 20, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 20, - 44, 65, 69, 16, 44, 20, 67, 20, 66, 69, - 66, 20, 20, 45, 61, 61, 61, 61, 61, 61, - 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, - 61, 61, 16, 45, 62, 20, 16, 20, 20, 65, - 45, 48, 45, 20, 65, 16, 20 + 55, 56, 59, 60, 61, 65, 71, 72, 73, 19, + 20, 39, 40, 45, 47, 48, 62, 63, 21, 66, + 71, 17, 17, 4, 21, 69, 70, 72, 21, 21, + 70, 17, 17, 17, 62, 63, 21, 72, 63, 63, + 63, 63, 63, 21, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 21, 45, 67, 71, 17, 45, 21, 69, + 21, 68, 71, 68, 21, 21, 21, 46, 63, 63, + 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 17, 46, 64, 21, + 17, 21, 21, 67, 46, 49, 46, 21, 67, 17, + 21 }; #define yyerrok (yyerrstatus = 0) @@ -1776,7 +1773,7 @@ yyreduce: case 4: /* Line 1455 of yacc.c */ -#line 172 "glcpp/glcpp-parse.y" +#line 175 "glcpp/glcpp-parse.y" { glcpp_print(parser->output, "\n"); ;} @@ -1785,7 +1782,7 @@ yyreduce: case 5: /* Line 1455 of yacc.c */ -#line 175 "glcpp/glcpp-parse.y" +#line 178 "glcpp/glcpp-parse.y" { _glcpp_parser_print_expanded_token_list (parser, (yyvsp[(1) - (1)].token_list)); glcpp_print(parser->output, "\n"); @@ -1796,7 +1793,7 @@ yyreduce: case 8: /* Line 1455 of yacc.c */ -#line 185 "glcpp/glcpp-parse.y" +#line 188 "glcpp/glcpp-parse.y" { _glcpp_parser_skip_stack_push_if (parser, & (yylsp[(1) - (3)]), (yyvsp[(2) - (3)].ival)); ;} @@ -1805,7 +1802,7 @@ yyreduce: case 9: /* Line 1455 of yacc.c */ -#line 188 "glcpp/glcpp-parse.y" +#line 191 "glcpp/glcpp-parse.y" { _glcpp_parser_skip_stack_change_if (parser, & (yylsp[(1) - (3)]), "elif", (yyvsp[(2) - (3)].ival)); ;} @@ -1814,7 +1811,7 @@ yyreduce: case 10: /* Line 1455 of yacc.c */ -#line 194 "glcpp/glcpp-parse.y" +#line 197 "glcpp/glcpp-parse.y" { _define_object_macro (parser, & (yylsp[(2) - (4)]), (yyvsp[(2) - (4)].str), (yyvsp[(3) - (4)].token_list)); ;} @@ -1823,7 +1820,7 @@ yyreduce: case 11: /* Line 1455 of yacc.c */ -#line 197 "glcpp/glcpp-parse.y" +#line 200 "glcpp/glcpp-parse.y" { _define_function_macro (parser, & (yylsp[(2) - (6)]), (yyvsp[(2) - (6)].str), NULL, (yyvsp[(5) - (6)].token_list)); ;} @@ -1832,7 +1829,7 @@ yyreduce: case 12: /* Line 1455 of yacc.c */ -#line 200 "glcpp/glcpp-parse.y" +#line 203 "glcpp/glcpp-parse.y" { _define_function_macro (parser, & (yylsp[(2) - (7)]), (yyvsp[(2) - (7)].str), (yyvsp[(4) - (7)].string_list), (yyvsp[(6) - (7)].token_list)); ;} @@ -1841,7 +1838,7 @@ yyreduce: case 13: /* Line 1455 of yacc.c */ -#line 203 "glcpp/glcpp-parse.y" +#line 206 "glcpp/glcpp-parse.y" { macro_t *macro = hash_table_find (parser->defines, (yyvsp[(2) - (3)].str)); if (macro) { @@ -1855,7 +1852,7 @@ yyreduce: case 14: /* Line 1455 of yacc.c */ -#line 211 "glcpp/glcpp-parse.y" +#line 214 "glcpp/glcpp-parse.y" { token_list_t *expanded; token_t *token; @@ -1873,7 +1870,7 @@ yyreduce: case 15: /* Line 1455 of yacc.c */ -#line 223 "glcpp/glcpp-parse.y" +#line 226 "glcpp/glcpp-parse.y" { macro_t *macro = hash_table_find (parser->defines, (yyvsp[(2) - (4)].str)); talloc_free ((yyvsp[(2) - (4)].str)); @@ -1884,7 +1881,7 @@ yyreduce: case 16: /* Line 1455 of yacc.c */ -#line 228 "glcpp/glcpp-parse.y" +#line 231 "glcpp/glcpp-parse.y" { macro_t *macro = hash_table_find (parser->defines, (yyvsp[(2) - (4)].str)); talloc_free ((yyvsp[(2) - (4)].str)); @@ -1895,7 +1892,7 @@ yyreduce: case 17: /* Line 1455 of yacc.c */ -#line 233 "glcpp/glcpp-parse.y" +#line 236 "glcpp/glcpp-parse.y" { token_list_t *expanded; token_t *token; @@ -1913,7 +1910,7 @@ yyreduce: case 18: /* Line 1455 of yacc.c */ -#line 245 "glcpp/glcpp-parse.y" +#line 248 "glcpp/glcpp-parse.y" { /* #elif without an expression results in a warning if the * condition doesn't matter (we just handled #if 1 or such) @@ -1930,7 +1927,7 @@ yyreduce: case 19: /* Line 1455 of yacc.c */ -#line 256 "glcpp/glcpp-parse.y" +#line 259 "glcpp/glcpp-parse.y" { _glcpp_parser_skip_stack_change_if (parser, & (yylsp[(1) - (2)]), "else", 1); ;} @@ -1939,16 +1936,31 @@ yyreduce: case 20: /* Line 1455 of yacc.c */ -#line 259 "glcpp/glcpp-parse.y" +#line 262 "glcpp/glcpp-parse.y" { _glcpp_parser_skip_stack_pop (parser, & (yylsp[(1) - (2)])); ;} break; - case 22: + case 21: /* Line 1455 of yacc.c */ -#line 266 "glcpp/glcpp-parse.y" +#line 265 "glcpp/glcpp-parse.y" + { + macro_t *macro = hash_table_find (parser->defines, "__VERSION__"); + if (macro) { + hash_table_remove (parser->defines, "__VERSION__"); + talloc_free (macro); + } + add_builtin_define (parser, "__VERSION__", (yyvsp[(2) - (3)].ival)); + glcpp_printf(parser->output, "#version %" PRIiMAX "\n", (yyvsp[(2) - (3)].ival)); + ;} + break; + + case 23: + +/* Line 1455 of yacc.c */ +#line 278 "glcpp/glcpp-parse.y" { if (strlen ((yyvsp[(1) - (1)].str)) >= 3 && strncmp ((yyvsp[(1) - (1)].str), "0x", 2) == 0) { (yyval.ival) = strtoll ((yyvsp[(1) - (1)].str) + 2, NULL, 16); @@ -1960,226 +1972,226 @@ yyreduce: ;} break; - case 23: + case 24: /* Line 1455 of yacc.c */ -#line 275 "glcpp/glcpp-parse.y" +#line 287 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;} break; - case 24: + case 26: /* Line 1455 of yacc.c */ -#line 278 "glcpp/glcpp-parse.y" +#line 293 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) || (yyvsp[(3) - (3)].ival); ;} break; - case 25: + case 27: /* Line 1455 of yacc.c */ -#line 281 "glcpp/glcpp-parse.y" +#line 296 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) && (yyvsp[(3) - (3)].ival); ;} break; - case 26: + case 28: /* Line 1455 of yacc.c */ -#line 284 "glcpp/glcpp-parse.y" +#line 299 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival); ;} break; - case 27: + case 29: /* Line 1455 of yacc.c */ -#line 287 "glcpp/glcpp-parse.y" +#line 302 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) ^ (yyvsp[(3) - (3)].ival); ;} break; - case 28: + case 30: /* Line 1455 of yacc.c */ -#line 290 "glcpp/glcpp-parse.y" +#line 305 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) & (yyvsp[(3) - (3)].ival); ;} break; - case 29: + case 31: /* Line 1455 of yacc.c */ -#line 293 "glcpp/glcpp-parse.y" +#line 308 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) != (yyvsp[(3) - (3)].ival); ;} break; - case 30: + case 32: /* Line 1455 of yacc.c */ -#line 296 "glcpp/glcpp-parse.y" +#line 311 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) == (yyvsp[(3) - (3)].ival); ;} break; - case 31: + case 33: /* Line 1455 of yacc.c */ -#line 299 "glcpp/glcpp-parse.y" +#line 314 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) >= (yyvsp[(3) - (3)].ival); ;} break; - case 32: + case 34: /* Line 1455 of yacc.c */ -#line 302 "glcpp/glcpp-parse.y" +#line 317 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) <= (yyvsp[(3) - (3)].ival); ;} break; - case 33: + case 35: /* Line 1455 of yacc.c */ -#line 305 "glcpp/glcpp-parse.y" +#line 320 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) > (yyvsp[(3) - (3)].ival); ;} break; - case 34: + case 36: /* Line 1455 of yacc.c */ -#line 308 "glcpp/glcpp-parse.y" +#line 323 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) < (yyvsp[(3) - (3)].ival); ;} break; - case 35: + case 37: /* Line 1455 of yacc.c */ -#line 311 "glcpp/glcpp-parse.y" +#line 326 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) >> (yyvsp[(3) - (3)].ival); ;} break; - case 36: + case 38: /* Line 1455 of yacc.c */ -#line 314 "glcpp/glcpp-parse.y" +#line 329 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) << (yyvsp[(3) - (3)].ival); ;} break; - case 37: + case 39: /* Line 1455 of yacc.c */ -#line 317 "glcpp/glcpp-parse.y" +#line 332 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) - (yyvsp[(3) - (3)].ival); ;} break; - case 38: + case 40: /* Line 1455 of yacc.c */ -#line 320 "glcpp/glcpp-parse.y" +#line 335 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) + (yyvsp[(3) - (3)].ival); ;} break; - case 39: + case 41: /* Line 1455 of yacc.c */ -#line 323 "glcpp/glcpp-parse.y" +#line 338 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) % (yyvsp[(3) - (3)].ival); ;} break; - case 40: + case 42: /* Line 1455 of yacc.c */ -#line 326 "glcpp/glcpp-parse.y" +#line 341 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) / (yyvsp[(3) - (3)].ival); ;} break; - case 41: + case 43: /* Line 1455 of yacc.c */ -#line 329 "glcpp/glcpp-parse.y" +#line 344 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) * (yyvsp[(3) - (3)].ival); ;} break; - case 42: + case 44: /* Line 1455 of yacc.c */ -#line 332 "glcpp/glcpp-parse.y" +#line 347 "glcpp/glcpp-parse.y" { (yyval.ival) = ! (yyvsp[(2) - (2)].ival); ;} break; - case 43: + case 45: /* Line 1455 of yacc.c */ -#line 335 "glcpp/glcpp-parse.y" +#line 350 "glcpp/glcpp-parse.y" { (yyval.ival) = ~ (yyvsp[(2) - (2)].ival); ;} break; - case 44: + case 46: /* Line 1455 of yacc.c */ -#line 338 "glcpp/glcpp-parse.y" +#line 353 "glcpp/glcpp-parse.y" { (yyval.ival) = - (yyvsp[(2) - (2)].ival); ;} break; - case 45: + case 47: /* Line 1455 of yacc.c */ -#line 341 "glcpp/glcpp-parse.y" +#line 356 "glcpp/glcpp-parse.y" { (yyval.ival) = + (yyvsp[(2) - (2)].ival); ;} break; - case 46: + case 48: /* Line 1455 of yacc.c */ -#line 344 "glcpp/glcpp-parse.y" +#line 359 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(2) - (3)].ival); ;} break; - case 47: + case 49: /* Line 1455 of yacc.c */ -#line 350 "glcpp/glcpp-parse.y" +#line 365 "glcpp/glcpp-parse.y" { (yyval.string_list) = _string_list_create (parser); _string_list_append_item ((yyval.string_list), (yyvsp[(1) - (1)].str)); @@ -2187,10 +2199,10 @@ yyreduce: ;} break; - case 48: + case 50: /* Line 1455 of yacc.c */ -#line 355 "glcpp/glcpp-parse.y" +#line 370 "glcpp/glcpp-parse.y" { (yyval.string_list) = (yyvsp[(1) - (3)].string_list); _string_list_append_item ((yyval.string_list), (yyvsp[(3) - (3)].str)); @@ -2198,62 +2210,62 @@ yyreduce: ;} break; - case 49: + case 51: /* Line 1455 of yacc.c */ -#line 363 "glcpp/glcpp-parse.y" +#line 378 "glcpp/glcpp-parse.y" { (yyval.token_list) = NULL; ;} break; - case 51: + case 53: /* Line 1455 of yacc.c */ -#line 368 "glcpp/glcpp-parse.y" +#line 383 "glcpp/glcpp-parse.y" { yyerror (& (yylsp[(1) - (2)]), parser, "Invalid tokens after #"); ;} break; - case 52: + case 54: /* Line 1455 of yacc.c */ -#line 374 "glcpp/glcpp-parse.y" +#line 389 "glcpp/glcpp-parse.y" { (yyval.token_list) = NULL; ;} break; - case 55: + case 57: /* Line 1455 of yacc.c */ -#line 380 "glcpp/glcpp-parse.y" +#line 395 "glcpp/glcpp-parse.y" { glcpp_warning(&(yylsp[(1) - (1)]), parser, "extra tokens at end of directive"); ;} break; - case 56: + case 58: /* Line 1455 of yacc.c */ -#line 387 "glcpp/glcpp-parse.y" +#line 402 "glcpp/glcpp-parse.y" { int v = hash_table_find (parser->defines, (yyvsp[(2) - (2)].str)) ? 1 : 0; (yyval.token) = _token_create_ival (parser, INTEGER, v); ;} break; - case 57: + case 59: /* Line 1455 of yacc.c */ -#line 391 "glcpp/glcpp-parse.y" +#line 406 "glcpp/glcpp-parse.y" { int v = hash_table_find (parser->defines, (yyvsp[(3) - (4)].str)) ? 1 : 0; (yyval.token) = _token_create_ival (parser, INTEGER, v); ;} break; - case 59: + case 61: /* Line 1455 of yacc.c */ -#line 400 "glcpp/glcpp-parse.y" +#line 415 "glcpp/glcpp-parse.y" { parser->space_tokens = 1; (yyval.token_list) = _token_list_create (parser); @@ -2262,10 +2274,10 @@ yyreduce: ;} break; - case 60: + case 62: /* Line 1455 of yacc.c */ -#line 406 "glcpp/glcpp-parse.y" +#line 421 "glcpp/glcpp-parse.y" { (yyval.token_list) = (yyvsp[(1) - (2)].token_list); _token_list_append ((yyval.token_list), (yyvsp[(2) - (2)].token)); @@ -2273,10 +2285,10 @@ yyreduce: ;} break; - case 61: + case 63: /* Line 1455 of yacc.c */ -#line 414 "glcpp/glcpp-parse.y" +#line 429 "glcpp/glcpp-parse.y" { parser->space_tokens = 1; (yyval.token_list) = _token_list_create (parser); @@ -2285,10 +2297,10 @@ yyreduce: ;} break; - case 62: + case 64: /* Line 1455 of yacc.c */ -#line 420 "glcpp/glcpp-parse.y" +#line 435 "glcpp/glcpp-parse.y" { (yyval.token_list) = (yyvsp[(1) - (2)].token_list); _token_list_append ((yyval.token_list), (yyvsp[(2) - (2)].token)); @@ -2296,277 +2308,277 @@ yyreduce: ;} break; - case 63: + case 65: /* Line 1455 of yacc.c */ -#line 428 "glcpp/glcpp-parse.y" +#line 443 "glcpp/glcpp-parse.y" { (yyval.token) = _token_create_str (parser, IDENTIFIER, (yyvsp[(1) - (1)].str)); (yyval.token)->location = yylloc; ;} break; - case 64: + case 66: /* Line 1455 of yacc.c */ -#line 432 "glcpp/glcpp-parse.y" +#line 447 "glcpp/glcpp-parse.y" { (yyval.token) = _token_create_str (parser, INTEGER_STRING, (yyvsp[(1) - (1)].str)); (yyval.token)->location = yylloc; ;} break; - case 65: + case 67: /* Line 1455 of yacc.c */ -#line 436 "glcpp/glcpp-parse.y" +#line 451 "glcpp/glcpp-parse.y" { (yyval.token) = _token_create_ival (parser, (yyvsp[(1) - (1)].ival), (yyvsp[(1) - (1)].ival)); (yyval.token)->location = yylloc; ;} break; - case 66: + case 68: /* Line 1455 of yacc.c */ -#line 440 "glcpp/glcpp-parse.y" +#line 455 "glcpp/glcpp-parse.y" { (yyval.token) = _token_create_str (parser, OTHER, (yyvsp[(1) - (1)].str)); (yyval.token)->location = yylloc; ;} break; - case 67: + case 69: /* Line 1455 of yacc.c */ -#line 444 "glcpp/glcpp-parse.y" +#line 459 "glcpp/glcpp-parse.y" { (yyval.token) = _token_create_ival (parser, SPACE, SPACE); (yyval.token)->location = yylloc; ;} break; - case 68: + case 70: /* Line 1455 of yacc.c */ -#line 451 "glcpp/glcpp-parse.y" +#line 466 "glcpp/glcpp-parse.y" { (yyval.ival) = '['; ;} break; - case 69: + case 71: /* Line 1455 of yacc.c */ -#line 452 "glcpp/glcpp-parse.y" +#line 467 "glcpp/glcpp-parse.y" { (yyval.ival) = ']'; ;} break; - case 70: + case 72: /* Line 1455 of yacc.c */ -#line 453 "glcpp/glcpp-parse.y" +#line 468 "glcpp/glcpp-parse.y" { (yyval.ival) = '('; ;} break; - case 71: + case 73: /* Line 1455 of yacc.c */ -#line 454 "glcpp/glcpp-parse.y" +#line 469 "glcpp/glcpp-parse.y" { (yyval.ival) = ')'; ;} break; - case 72: + case 74: /* Line 1455 of yacc.c */ -#line 455 "glcpp/glcpp-parse.y" +#line 470 "glcpp/glcpp-parse.y" { (yyval.ival) = '{'; ;} break; - case 73: + case 75: /* Line 1455 of yacc.c */ -#line 456 "glcpp/glcpp-parse.y" +#line 471 "glcpp/glcpp-parse.y" { (yyval.ival) = '}'; ;} break; - case 74: + case 76: /* Line 1455 of yacc.c */ -#line 457 "glcpp/glcpp-parse.y" +#line 472 "glcpp/glcpp-parse.y" { (yyval.ival) = '.'; ;} break; - case 75: + case 77: /* Line 1455 of yacc.c */ -#line 458 "glcpp/glcpp-parse.y" +#line 473 "glcpp/glcpp-parse.y" { (yyval.ival) = '&'; ;} break; - case 76: + case 78: /* Line 1455 of yacc.c */ -#line 459 "glcpp/glcpp-parse.y" +#line 474 "glcpp/glcpp-parse.y" { (yyval.ival) = '*'; ;} break; - case 77: + case 79: /* Line 1455 of yacc.c */ -#line 460 "glcpp/glcpp-parse.y" +#line 475 "glcpp/glcpp-parse.y" { (yyval.ival) = '+'; ;} break; - case 78: + case 80: /* Line 1455 of yacc.c */ -#line 461 "glcpp/glcpp-parse.y" +#line 476 "glcpp/glcpp-parse.y" { (yyval.ival) = '-'; ;} break; - case 79: + case 81: /* Line 1455 of yacc.c */ -#line 462 "glcpp/glcpp-parse.y" +#line 477 "glcpp/glcpp-parse.y" { (yyval.ival) = '~'; ;} break; - case 80: + case 82: /* Line 1455 of yacc.c */ -#line 463 "glcpp/glcpp-parse.y" +#line 478 "glcpp/glcpp-parse.y" { (yyval.ival) = '!'; ;} break; - case 81: + case 83: /* Line 1455 of yacc.c */ -#line 464 "glcpp/glcpp-parse.y" +#line 479 "glcpp/glcpp-parse.y" { (yyval.ival) = '/'; ;} break; - case 82: + case 84: /* Line 1455 of yacc.c */ -#line 465 "glcpp/glcpp-parse.y" +#line 480 "glcpp/glcpp-parse.y" { (yyval.ival) = '%'; ;} break; - case 83: + case 85: /* Line 1455 of yacc.c */ -#line 466 "glcpp/glcpp-parse.y" +#line 481 "glcpp/glcpp-parse.y" { (yyval.ival) = LEFT_SHIFT; ;} break; - case 84: + case 86: /* Line 1455 of yacc.c */ -#line 467 "glcpp/glcpp-parse.y" +#line 482 "glcpp/glcpp-parse.y" { (yyval.ival) = RIGHT_SHIFT; ;} break; - case 85: + case 87: /* Line 1455 of yacc.c */ -#line 468 "glcpp/glcpp-parse.y" +#line 483 "glcpp/glcpp-parse.y" { (yyval.ival) = '<'; ;} break; - case 86: + case 88: /* Line 1455 of yacc.c */ -#line 469 "glcpp/glcpp-parse.y" +#line 484 "glcpp/glcpp-parse.y" { (yyval.ival) = '>'; ;} break; - case 87: + case 89: /* Line 1455 of yacc.c */ -#line 470 "glcpp/glcpp-parse.y" +#line 485 "glcpp/glcpp-parse.y" { (yyval.ival) = LESS_OR_EQUAL; ;} break; - case 88: + case 90: /* Line 1455 of yacc.c */ -#line 471 "glcpp/glcpp-parse.y" +#line 486 "glcpp/glcpp-parse.y" { (yyval.ival) = GREATER_OR_EQUAL; ;} break; - case 89: + case 91: /* Line 1455 of yacc.c */ -#line 472 "glcpp/glcpp-parse.y" +#line 487 "glcpp/glcpp-parse.y" { (yyval.ival) = EQUAL; ;} break; - case 90: + case 92: /* Line 1455 of yacc.c */ -#line 473 "glcpp/glcpp-parse.y" +#line 488 "glcpp/glcpp-parse.y" { (yyval.ival) = NOT_EQUAL; ;} break; - case 91: + case 93: /* Line 1455 of yacc.c */ -#line 474 "glcpp/glcpp-parse.y" +#line 489 "glcpp/glcpp-parse.y" { (yyval.ival) = '^'; ;} break; - case 92: + case 94: /* Line 1455 of yacc.c */ -#line 475 "glcpp/glcpp-parse.y" +#line 490 "glcpp/glcpp-parse.y" { (yyval.ival) = '|'; ;} break; - case 93: + case 95: /* Line 1455 of yacc.c */ -#line 476 "glcpp/glcpp-parse.y" +#line 491 "glcpp/glcpp-parse.y" { (yyval.ival) = AND; ;} break; - case 94: + case 96: /* Line 1455 of yacc.c */ -#line 477 "glcpp/glcpp-parse.y" +#line 492 "glcpp/glcpp-parse.y" { (yyval.ival) = OR; ;} break; - case 95: + case 97: /* Line 1455 of yacc.c */ -#line 478 "glcpp/glcpp-parse.y" +#line 493 "glcpp/glcpp-parse.y" { (yyval.ival) = ';'; ;} break; - case 96: + case 98: /* Line 1455 of yacc.c */ -#line 479 "glcpp/glcpp-parse.y" +#line 494 "glcpp/glcpp-parse.y" { (yyval.ival) = ','; ;} break; - case 97: + case 99: /* Line 1455 of yacc.c */ -#line 480 "glcpp/glcpp-parse.y" +#line 495 "glcpp/glcpp-parse.y" { (yyval.ival) = '='; ;} break; - case 98: + case 100: /* Line 1455 of yacc.c */ -#line 481 "glcpp/glcpp-parse.y" +#line 496 "glcpp/glcpp-parse.y" { (yyval.ival) = PASTE; ;} break; /* Line 1455 of yacc.c */ -#line 2570 "glcpp/glcpp-parse.c" +#line 2582 "glcpp/glcpp-parse.c" default: break; } YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); @@ -2785,7 +2797,7 @@ yyreturn: /* Line 1675 of yacc.c */ -#line 484 "glcpp/glcpp-parse.y" +#line 499 "glcpp/glcpp-parse.y" string_list_t * @@ -3196,12 +3208,26 @@ yyerror (YYLTYPE *locp, glcpp_parser_t *parser, const char *error) glcpp_error(locp, parser, "%s", error); } +static void add_builtin_define(glcpp_parser_t *parser, + const char *name, int value) +{ + token_t *tok; + token_list_t *list; + + tok = _token_create_ival (parser, INTEGER, value); + + list = _token_list_create(parser); + _token_list_append(list, tok); + _define_object_macro(parser, NULL, name, list); + + talloc_unlink(parser, tok); +} + glcpp_parser_t * glcpp_parser_create (const struct gl_extensions *extensions) { glcpp_parser_t *parser; - token_t *tok; - token_list_t *list; + int language_version; parser = xtalloc (NULL, glcpp_parser_t); @@ -3225,32 +3251,24 @@ glcpp_parser_create (const struct gl_extensions *extensions) parser->error = 0; /* Add pre-defined macros. */ - tok = _token_create_ival (parser, INTEGER, 1); + add_builtin_define(parser, "GL_ARB_draw_buffers", 1); + add_builtin_define(parser, "GL_ARB_texture_rectangle", 1); - list = _token_list_create(parser); - _token_list_append(list, tok); - _define_object_macro(parser, NULL, "GL_ARB_draw_buffers", list); + if (extensions != NULL) { + if (extensions->EXT_texture_array) { + add_builtin_define(parser, "GL_EXT_texture_array", 1); + } - list = _token_list_create(parser); - _token_list_append(list, tok); - _define_object_macro(parser, NULL, "GL_ARB_texture_rectangle", list); - - if ((extensions != NULL) && extensions->EXT_texture_array) { - list = _token_list_create(parser); - _token_list_append(list, tok); - _define_object_macro(parser, NULL, - "GL_EXT_texture_array", list); + if (extensions->ARB_fragment_coord_conventions) + add_builtin_define(parser, "GL_ARB_fragment_coord_conventions", + 1); } - if ((extensions != NULL) && - extensions->ARB_fragment_coord_conventions) { - list = _token_list_create(parser); - _token_list_append(list, tok); - _define_object_macro(parser, NULL, - "GL_ARB_fragment_coord_conventions", list); + language_version = 110; + if (extensions && extensions->ARB_shading_language_120) { + language_version = 120; } - - talloc_unlink(parser, tok); + add_builtin_define(parser, "__VERSION__", language_version); return parser; } diff --git a/src/glsl/glcpp/glcpp-parse.h b/src/glsl/glcpp/glcpp-parse.h index 6365068ad0..50758930e9 100644 --- a/src/glsl/glcpp/glcpp-parse.h +++ b/src/glsl/glcpp/glcpp-parse.h @@ -52,24 +52,25 @@ HASH_IFDEF = 268, HASH_IFNDEF = 269, HASH_UNDEF = 270, - IDENTIFIER = 271, - IF_EXPANDED = 272, - INTEGER = 273, - INTEGER_STRING = 274, - NEWLINE = 275, - OTHER = 276, - PLACEHOLDER = 277, - SPACE = 278, - PASTE = 279, - OR = 280, - AND = 281, - NOT_EQUAL = 282, - EQUAL = 283, - GREATER_OR_EQUAL = 284, - LESS_OR_EQUAL = 285, - RIGHT_SHIFT = 286, - LEFT_SHIFT = 287, - UNARY = 288 + HASH_VERSION = 271, + IDENTIFIER = 272, + IF_EXPANDED = 273, + INTEGER = 274, + INTEGER_STRING = 275, + NEWLINE = 276, + OTHER = 277, + PLACEHOLDER = 278, + SPACE = 279, + PASTE = 280, + OR = 281, + AND = 282, + NOT_EQUAL = 283, + EQUAL = 284, + GREATER_OR_EQUAL = 285, + LESS_OR_EQUAL = 286, + RIGHT_SHIFT = 287, + LEFT_SHIFT = 288, + UNARY = 289 }; #endif diff --git a/src/glsl/glcpp/glcpp-parse.y b/src/glsl/glcpp/glcpp-parse.y index 2009aeaf8a..e82fc92c8c 100644 --- a/src/glsl/glcpp/glcpp-parse.y +++ b/src/glsl/glcpp/glcpp-parse.y @@ -132,6 +132,9 @@ glcpp_parser_lex (YYSTYPE *yylval, YYLTYPE *yylloc, glcpp_parser_t *parser); static void glcpp_parser_lex_from (glcpp_parser_t *parser, token_list_t *list); +static void +add_builtin_define(glcpp_parser_t *parser, const char *name, int value); + %} %pure-parser @@ -142,9 +145,9 @@ glcpp_parser_lex_from (glcpp_parser_t *parser, token_list_t *list); %lex-param {glcpp_parser_t *parser} %expect 0 -%token COMMA_FINAL DEFINED ELIF_EXPANDED HASH HASH_DEFINE_FUNC HASH_DEFINE_OBJ HASH_ELIF HASH_ELSE HASH_ENDIF HASH_IF HASH_IFDEF HASH_IFNDEF HASH_UNDEF IDENTIFIER IF_EXPANDED INTEGER INTEGER_STRING NEWLINE OTHER PLACEHOLDER SPACE +%token COMMA_FINAL DEFINED ELIF_EXPANDED HASH HASH_DEFINE_FUNC HASH_DEFINE_OBJ HASH_ELIF HASH_ELSE HASH_ENDIF HASH_IF HASH_IFDEF HASH_IFNDEF HASH_UNDEF HASH_VERSION IDENTIFIER IF_EXPANDED INTEGER INTEGER_STRING NEWLINE OTHER PLACEHOLDER SPACE %token PASTE -%type expression INTEGER operator SPACE +%type expression INTEGER operator SPACE integer_constant %type IDENTIFIER INTEGER_STRING OTHER %type identifier_list %type preprocessing_token conditional_token @@ -259,10 +262,19 @@ control_line: | HASH_ENDIF NEWLINE { _glcpp_parser_skip_stack_pop (parser, & @1); } +| HASH_VERSION integer_constant NEWLINE { + macro_t *macro = hash_table_find (parser->defines, "__VERSION__"); + if (macro) { + hash_table_remove (parser->defines, "__VERSION__"); + talloc_free (macro); + } + add_builtin_define (parser, "__VERSION__", $2); + glcpp_printf(parser->output, "#version %" PRIiMAX "\n", $2); + } | HASH NEWLINE ; -expression: +integer_constant: INTEGER_STRING { if (strlen ($1) >= 3 && strncmp ($1, "0x", 2) == 0) { $$ = strtoll ($1 + 2, NULL, 16); @@ -275,6 +287,9 @@ expression: | INTEGER { $$ = $1; } + +expression: + integer_constant | expression OR expression { $$ = $1 || $3; } @@ -891,12 +906,26 @@ yyerror (YYLTYPE *locp, glcpp_parser_t *parser, const char *error) glcpp_error(locp, parser, "%s", error); } +static void add_builtin_define(glcpp_parser_t *parser, + const char *name, int value) +{ + token_t *tok; + token_list_t *list; + + tok = _token_create_ival (parser, INTEGER, value); + + list = _token_list_create(parser); + _token_list_append(list, tok); + _define_object_macro(parser, NULL, name, list); + + talloc_unlink(parser, tok); +} + glcpp_parser_t * glcpp_parser_create (const struct gl_extensions *extensions) { glcpp_parser_t *parser; - token_t *tok; - token_list_t *list; + int language_version; parser = xtalloc (NULL, glcpp_parser_t); @@ -920,32 +949,24 @@ glcpp_parser_create (const struct gl_extensions *extensions) parser->error = 0; /* Add pre-defined macros. */ - tok = _token_create_ival (parser, INTEGER, 1); + add_builtin_define(parser, "GL_ARB_draw_buffers", 1); + add_builtin_define(parser, "GL_ARB_texture_rectangle", 1); - list = _token_list_create(parser); - _token_list_append(list, tok); - _define_object_macro(parser, NULL, "GL_ARB_draw_buffers", list); + if (extensions != NULL) { + if (extensions->EXT_texture_array) { + add_builtin_define(parser, "GL_EXT_texture_array", 1); + } - list = _token_list_create(parser); - _token_list_append(list, tok); - _define_object_macro(parser, NULL, "GL_ARB_texture_rectangle", list); - - if ((extensions != NULL) && extensions->EXT_texture_array) { - list = _token_list_create(parser); - _token_list_append(list, tok); - _define_object_macro(parser, NULL, - "GL_EXT_texture_array", list); + if (extensions->ARB_fragment_coord_conventions) + add_builtin_define(parser, "GL_ARB_fragment_coord_conventions", + 1); } - if ((extensions != NULL) && - extensions->ARB_fragment_coord_conventions) { - list = _token_list_create(parser); - _token_list_append(list, tok); - _define_object_macro(parser, NULL, - "GL_ARB_fragment_coord_conventions", list); + language_version = 110; + if (extensions && extensions->ARB_shading_language_120) { + language_version = 120; } - - talloc_unlink(parser, tok); + add_builtin_define(parser, "__VERSION__", language_version); return parser; } -- cgit v1.2.3 From 0ef79a5f115659b3719a330d01a365e8ca8144c4 Mon Sep 17 00:00:00 2001 From: Kenneth Graunke Date: Tue, 3 Aug 2010 20:25:13 -0700 Subject: glcpp: Refresh autogenerated lexer and parser. --- src/glsl/glcpp/glcpp-lex.c | 44 +++----- src/glsl/glcpp/glcpp-parse.c | 252 ++++++++++++++++++++++--------------------- src/glsl/glcpp/glcpp-parse.h | 7 +- 3 files changed, 148 insertions(+), 155 deletions(-) (limited to 'src/glsl/glcpp/glcpp-lex.c') diff --git a/src/glsl/glcpp/glcpp-lex.c b/src/glsl/glcpp/glcpp-lex.c index 40db2c27c5..d976904135 100644 --- a/src/glsl/glcpp/glcpp-lex.c +++ b/src/glsl/glcpp/glcpp-lex.c @@ -54,6 +54,7 @@ typedef int flex_int32_t; typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t; typedef unsigned int flex_uint32_t; +#endif /* ! C99 */ /* Limits of integral types. */ #ifndef INT8_MIN @@ -84,8 +85,6 @@ typedef unsigned int flex_uint32_t; #define UINT32_MAX (4294967295U) #endif -#endif /* ! C99 */ - #endif /* ! FLEXINT_H */ #ifdef __cplusplus @@ -159,15 +158,7 @@ typedef void* yyscan_t; /* Size of default input buffer. */ #ifndef YY_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k. - * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. - * Ditto for the __ia64__ case accordingly. - */ -#define YY_BUF_SIZE 32768 -#else #define YY_BUF_SIZE 16384 -#endif /* __ia64__ */ #endif /* The state buf must be large enough to hold one state per character in the main buffer. @@ -691,7 +682,7 @@ void glcpp_set_column (int column_no , yyscan_t yyscanner); } while(0); #define YY_USER_INIT yylineno = 0; yycolumn = 0; -#line 695 "glcpp/glcpp-lex.c" +#line 686 "glcpp/glcpp-lex.c" #define INITIAL 0 #define DONE 1 @@ -846,12 +837,7 @@ static int input (yyscan_t yyscanner ); /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k */ -#define YY_READ_BUF_SIZE 16384 -#else #define YY_READ_BUF_SIZE 8192 -#endif /* __ia64__ */ #endif /* Copy whatever the last rule matched to the standard output. */ @@ -859,7 +845,7 @@ static int input (yyscan_t yyscanner ); /* 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 fwrite( yytext, yyleng, 1, yyout ) #endif /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, @@ -870,7 +856,7 @@ static int input (yyscan_t yyscanner ); if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ - size_t n; \ + int n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ @@ -962,7 +948,7 @@ YY_DECL /* Single-line comments */ -#line 966 "glcpp/glcpp-lex.c" +#line 952 "glcpp/glcpp-lex.c" yylval = yylval_param; @@ -1133,7 +1119,7 @@ case 8: YY_RULE_SETUP #line 90 "glcpp/glcpp-lex.l" { - yylval->str = xtalloc_strdup (yyextra, yytext); + yylval->str = talloc_strdup (yyextra, yytext); yylineno++; yycolumn = 0; yyextra->space_tokens = 0; @@ -1146,7 +1132,7 @@ case 9: YY_RULE_SETUP #line 100 "glcpp/glcpp-lex.l" { - yylval->str = xtalloc_strdup (yyextra, yytext); + yylval->str = talloc_strdup (yyextra, yytext); yylineno++; yycolumn = 0; return OTHER; @@ -1283,7 +1269,7 @@ case 22: YY_RULE_SETUP #line 188 "glcpp/glcpp-lex.l" { - yylval->str = xtalloc_strdup (yyextra, yytext); + yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; } YY_BREAK @@ -1291,7 +1277,7 @@ case 23: YY_RULE_SETUP #line 193 "glcpp/glcpp-lex.l" { - yylval->str = xtalloc_strdup (yyextra, yytext); + yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; } YY_BREAK @@ -1299,7 +1285,7 @@ case 24: YY_RULE_SETUP #line 198 "glcpp/glcpp-lex.l" { - yylval->str = xtalloc_strdup (yyextra, yytext); + yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; } YY_BREAK @@ -1377,7 +1363,7 @@ case 35: YY_RULE_SETUP #line 243 "glcpp/glcpp-lex.l" { - yylval->str = xtalloc_strdup (yyextra, yytext); + yylval->str = talloc_strdup (yyextra, yytext); return IDENTIFIER; } YY_BREAK @@ -1392,7 +1378,7 @@ case 37: YY_RULE_SETUP #line 252 "glcpp/glcpp-lex.l" { - yylval->str = xtalloc_strdup (yyextra, yytext); + yylval->str = talloc_strdup (yyextra, yytext); return OTHER; } YY_BREAK @@ -1442,7 +1428,7 @@ YY_RULE_SETUP #line 286 "glcpp/glcpp-lex.l" ECHO; YY_BREAK -#line 1446 "glcpp/glcpp-lex.c" +#line 1432 "glcpp/glcpp-lex.c" case YY_STATE_EOF(DONE): case YY_STATE_EOF(COMMENT): case YY_STATE_EOF(UNREACHABLE): @@ -2181,8 +2167,8 @@ YY_BUFFER_STATE glcpp__scan_string (yyconst char * yystr , yyscan_t yyscanner) /** Setup the input buffer state to scan the given bytes. The next call to glcpp_lex() will * scan from a @e copy of @a bytes. - * @param yybytes the byte buffer to scan - * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * @param bytes the byte buffer to scan + * @param len the number of bytes in the buffer pointed to by @a bytes. * @param yyscanner The scanner object. * @return the newly allocated buffer state object. */ diff --git a/src/glsl/glcpp/glcpp-parse.c b/src/glsl/glcpp/glcpp-parse.c index 9dc4bfb3ab..5ea07c2555 100644 --- a/src/glsl/glcpp/glcpp-parse.c +++ b/src/glsl/glcpp/glcpp-parse.c @@ -1,10 +1,9 @@ - -/* A Bison parser, made by GNU Bison 2.4.1. */ +/* A Bison parser, made by GNU Bison 2.4.2. */ /* Skeleton implementation for Bison's Yacc-like parsers in C - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 - Free Software Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2006, 2009-2010 Free Software + Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -46,7 +45,7 @@ #define YYBISON 1 /* Bison version. */ -#define YYBISON_VERSION "2.4.1" +#define YYBISON_VERSION "2.4.2" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" @@ -209,7 +208,7 @@ add_builtin_define(glcpp_parser_t *parser, const char *name, int value); /* Line 189 of yacc.c */ -#line 213 "glcpp/glcpp-parse.c" +#line 212 "glcpp/glcpp-parse.c" /* Enabling traces. */ #ifndef YYDEBUG @@ -297,7 +296,7 @@ typedef struct YYLTYPE /* Line 264 of yacc.c */ -#line 301 "glcpp/glcpp-parse.c" +#line 300 "glcpp/glcpp-parse.c" #ifdef short # undef short @@ -347,7 +346,7 @@ typedef short int yytype_int16; #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) #ifndef YY_ -# if YYENABLE_NLS +# if defined YYENABLE_NLS && YYENABLE_NLS # if ENABLE_NLS # include /* INFRINGES ON USER NAME SPACE */ # define YY_(msgid) dgettext ("bison-runtime", msgid) @@ -934,9 +933,18 @@ static const yytype_uint8 yystos[] = /* Like YYERROR except do call yyerror. This remains here temporarily to ease the transition to the new meaning of YYERROR, for GCC. - Once GCC version 2 has supplanted version 1, this can go. */ + Once GCC version 2 has supplanted version 1, this can go. However, + YYFAIL appears to be in use. Nevertheless, it is formally deprecated + in Bison 2.4.2's NEWS entry, where a plan to phase it out is + discussed. */ #define YYFAIL goto yyerrlab +#if defined YYFAIL + /* This is here to suppress warnings from the GCC cpp's + -Wunused-macros. Normally we don't worry about that warning, but + some users do, and we want to make it easy for users to remove + YYFAIL uses, which will produce warnings from Bison 2.5. */ +#endif #define YYRECOVERING() (!!yyerrstatus) @@ -993,7 +1001,7 @@ while (YYID (0)) we won't break user code: when these are the locations we know. */ #ifndef YY_LOCATION_PRINT -# if YYLTYPE_IS_TRIVIAL +# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL # define YY_LOCATION_PRINT(File, Loc) \ fprintf (File, "%d.%d-%d.%d", \ (Loc).first_line, (Loc).first_column, \ @@ -1582,7 +1590,7 @@ YYLTYPE yylloc; yyvsp = yyvs; yylsp = yyls; -#if YYLTYPE_IS_TRIVIAL +#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL /* Initialize the default location before parsing starts. */ yylloc.first_line = yylloc.last_line = 1; yylloc.first_column = yylloc.last_column = 1; @@ -1772,7 +1780,7 @@ yyreduce: { case 4: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 175 "glcpp/glcpp-parse.y" { glcpp_print(parser->output, "\n"); @@ -1781,7 +1789,7 @@ yyreduce: case 5: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 178 "glcpp/glcpp-parse.y" { _glcpp_parser_print_expanded_token_list (parser, (yyvsp[(1) - (1)].token_list)); @@ -1792,7 +1800,7 @@ yyreduce: case 8: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 188 "glcpp/glcpp-parse.y" { _glcpp_parser_skip_stack_push_if (parser, & (yylsp[(1) - (3)]), (yyvsp[(2) - (3)].ival)); @@ -1801,7 +1809,7 @@ yyreduce: case 9: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 191 "glcpp/glcpp-parse.y" { _glcpp_parser_skip_stack_change_if (parser, & (yylsp[(1) - (3)]), "elif", (yyvsp[(2) - (3)].ival)); @@ -1810,7 +1818,7 @@ yyreduce: case 10: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 197 "glcpp/glcpp-parse.y" { _define_object_macro (parser, & (yylsp[(2) - (4)]), (yyvsp[(2) - (4)].str), (yyvsp[(3) - (4)].token_list)); @@ -1819,7 +1827,7 @@ yyreduce: case 11: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 200 "glcpp/glcpp-parse.y" { _define_function_macro (parser, & (yylsp[(2) - (6)]), (yyvsp[(2) - (6)].str), NULL, (yyvsp[(5) - (6)].token_list)); @@ -1828,7 +1836,7 @@ yyreduce: case 12: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 203 "glcpp/glcpp-parse.y" { _define_function_macro (parser, & (yylsp[(2) - (7)]), (yyvsp[(2) - (7)].str), (yyvsp[(4) - (7)].string_list), (yyvsp[(6) - (7)].token_list)); @@ -1837,7 +1845,7 @@ yyreduce: case 13: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 206 "glcpp/glcpp-parse.y" { macro_t *macro = hash_table_find (parser->defines, (yyvsp[(2) - (3)].str)); @@ -1851,7 +1859,7 @@ yyreduce: case 14: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 214 "glcpp/glcpp-parse.y" { token_list_t *expanded; @@ -1869,7 +1877,7 @@ yyreduce: case 15: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 226 "glcpp/glcpp-parse.y" { macro_t *macro = hash_table_find (parser->defines, (yyvsp[(2) - (4)].str)); @@ -1880,7 +1888,7 @@ yyreduce: case 16: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 231 "glcpp/glcpp-parse.y" { macro_t *macro = hash_table_find (parser->defines, (yyvsp[(2) - (4)].str)); @@ -1891,7 +1899,7 @@ yyreduce: case 17: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 236 "glcpp/glcpp-parse.y" { token_list_t *expanded; @@ -1909,7 +1917,7 @@ yyreduce: case 18: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 248 "glcpp/glcpp-parse.y" { /* #elif without an expression results in a warning if the @@ -1926,7 +1934,7 @@ yyreduce: case 19: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 259 "glcpp/glcpp-parse.y" { _glcpp_parser_skip_stack_change_if (parser, & (yylsp[(1) - (2)]), "else", 1); @@ -1935,7 +1943,7 @@ yyreduce: case 20: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 262 "glcpp/glcpp-parse.y" { _glcpp_parser_skip_stack_pop (parser, & (yylsp[(1) - (2)])); @@ -1944,7 +1952,7 @@ yyreduce: case 21: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 265 "glcpp/glcpp-parse.y" { macro_t *macro = hash_table_find (parser->defines, "__VERSION__"); @@ -1959,7 +1967,7 @@ yyreduce: case 23: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 278 "glcpp/glcpp-parse.y" { if (strlen ((yyvsp[(1) - (1)].str)) >= 3 && strncmp ((yyvsp[(1) - (1)].str), "0x", 2) == 0) { @@ -1974,7 +1982,7 @@ yyreduce: case 24: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 287 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (1)].ival); @@ -1983,7 +1991,7 @@ yyreduce: case 26: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 293 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) || (yyvsp[(3) - (3)].ival); @@ -1992,7 +2000,7 @@ yyreduce: case 27: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 296 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) && (yyvsp[(3) - (3)].ival); @@ -2001,7 +2009,7 @@ yyreduce: case 28: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 299 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival); @@ -2010,7 +2018,7 @@ yyreduce: case 29: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 302 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) ^ (yyvsp[(3) - (3)].ival); @@ -2019,7 +2027,7 @@ yyreduce: case 30: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 305 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) & (yyvsp[(3) - (3)].ival); @@ -2028,7 +2036,7 @@ yyreduce: case 31: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 308 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) != (yyvsp[(3) - (3)].ival); @@ -2037,7 +2045,7 @@ yyreduce: case 32: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 311 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) == (yyvsp[(3) - (3)].ival); @@ -2046,7 +2054,7 @@ yyreduce: case 33: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 314 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) >= (yyvsp[(3) - (3)].ival); @@ -2055,7 +2063,7 @@ yyreduce: case 34: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 317 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) <= (yyvsp[(3) - (3)].ival); @@ -2064,7 +2072,7 @@ yyreduce: case 35: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 320 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) > (yyvsp[(3) - (3)].ival); @@ -2073,7 +2081,7 @@ yyreduce: case 36: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 323 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) < (yyvsp[(3) - (3)].ival); @@ -2082,7 +2090,7 @@ yyreduce: case 37: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 326 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) >> (yyvsp[(3) - (3)].ival); @@ -2091,7 +2099,7 @@ yyreduce: case 38: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 329 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) << (yyvsp[(3) - (3)].ival); @@ -2100,7 +2108,7 @@ yyreduce: case 39: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 332 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) - (yyvsp[(3) - (3)].ival); @@ -2109,7 +2117,7 @@ yyreduce: case 40: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 335 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) + (yyvsp[(3) - (3)].ival); @@ -2118,7 +2126,7 @@ yyreduce: case 41: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 338 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) % (yyvsp[(3) - (3)].ival); @@ -2127,7 +2135,7 @@ yyreduce: case 42: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 341 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) / (yyvsp[(3) - (3)].ival); @@ -2136,7 +2144,7 @@ yyreduce: case 43: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 344 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) * (yyvsp[(3) - (3)].ival); @@ -2145,7 +2153,7 @@ yyreduce: case 44: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 347 "glcpp/glcpp-parse.y" { (yyval.ival) = ! (yyvsp[(2) - (2)].ival); @@ -2154,7 +2162,7 @@ yyreduce: case 45: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 350 "glcpp/glcpp-parse.y" { (yyval.ival) = ~ (yyvsp[(2) - (2)].ival); @@ -2163,7 +2171,7 @@ yyreduce: case 46: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 353 "glcpp/glcpp-parse.y" { (yyval.ival) = - (yyvsp[(2) - (2)].ival); @@ -2172,7 +2180,7 @@ yyreduce: case 47: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 356 "glcpp/glcpp-parse.y" { (yyval.ival) = + (yyvsp[(2) - (2)].ival); @@ -2181,7 +2189,7 @@ yyreduce: case 48: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 359 "glcpp/glcpp-parse.y" { (yyval.ival) = (yyvsp[(2) - (3)].ival); @@ -2190,7 +2198,7 @@ yyreduce: case 49: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 365 "glcpp/glcpp-parse.y" { (yyval.string_list) = _string_list_create (parser); @@ -2201,7 +2209,7 @@ yyreduce: case 50: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 370 "glcpp/glcpp-parse.y" { (yyval.string_list) = (yyvsp[(1) - (3)].string_list); @@ -2212,14 +2220,14 @@ yyreduce: case 51: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 378 "glcpp/glcpp-parse.y" { (yyval.token_list) = NULL; ;} break; case 53: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 383 "glcpp/glcpp-parse.y" { yyerror (& (yylsp[(1) - (2)]), parser, "Invalid tokens after #"); @@ -2228,14 +2236,14 @@ yyreduce: case 54: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 389 "glcpp/glcpp-parse.y" { (yyval.token_list) = NULL; ;} break; case 57: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 395 "glcpp/glcpp-parse.y" { glcpp_warning(&(yylsp[(1) - (1)]), parser, "extra tokens at end of directive"); @@ -2244,7 +2252,7 @@ yyreduce: case 58: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 402 "glcpp/glcpp-parse.y" { int v = hash_table_find (parser->defines, (yyvsp[(2) - (2)].str)) ? 1 : 0; @@ -2254,7 +2262,7 @@ yyreduce: case 59: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 406 "glcpp/glcpp-parse.y" { int v = hash_table_find (parser->defines, (yyvsp[(3) - (4)].str)) ? 1 : 0; @@ -2264,7 +2272,7 @@ yyreduce: case 61: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 415 "glcpp/glcpp-parse.y" { parser->space_tokens = 1; @@ -2276,7 +2284,7 @@ yyreduce: case 62: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 421 "glcpp/glcpp-parse.y" { (yyval.token_list) = (yyvsp[(1) - (2)].token_list); @@ -2287,7 +2295,7 @@ yyreduce: case 63: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 429 "glcpp/glcpp-parse.y" { parser->space_tokens = 1; @@ -2299,7 +2307,7 @@ yyreduce: case 64: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 435 "glcpp/glcpp-parse.y" { (yyval.token_list) = (yyvsp[(1) - (2)].token_list); @@ -2310,7 +2318,7 @@ yyreduce: case 65: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 443 "glcpp/glcpp-parse.y" { (yyval.token) = _token_create_str (parser, IDENTIFIER, (yyvsp[(1) - (1)].str)); @@ -2320,7 +2328,7 @@ yyreduce: case 66: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 447 "glcpp/glcpp-parse.y" { (yyval.token) = _token_create_str (parser, INTEGER_STRING, (yyvsp[(1) - (1)].str)); @@ -2330,7 +2338,7 @@ yyreduce: case 67: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 451 "glcpp/glcpp-parse.y" { (yyval.token) = _token_create_ival (parser, (yyvsp[(1) - (1)].ival), (yyvsp[(1) - (1)].ival)); @@ -2340,7 +2348,7 @@ yyreduce: case 68: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 455 "glcpp/glcpp-parse.y" { (yyval.token) = _token_create_str (parser, OTHER, (yyvsp[(1) - (1)].str)); @@ -2350,7 +2358,7 @@ yyreduce: case 69: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 459 "glcpp/glcpp-parse.y" { (yyval.token) = _token_create_ival (parser, SPACE, SPACE); @@ -2360,225 +2368,225 @@ yyreduce: case 70: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 466 "glcpp/glcpp-parse.y" { (yyval.ival) = '['; ;} break; case 71: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 467 "glcpp/glcpp-parse.y" { (yyval.ival) = ']'; ;} break; case 72: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 468 "glcpp/glcpp-parse.y" { (yyval.ival) = '('; ;} break; case 73: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 469 "glcpp/glcpp-parse.y" { (yyval.ival) = ')'; ;} break; case 74: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 470 "glcpp/glcpp-parse.y" { (yyval.ival) = '{'; ;} break; case 75: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 471 "glcpp/glcpp-parse.y" { (yyval.ival) = '}'; ;} break; case 76: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 472 "glcpp/glcpp-parse.y" { (yyval.ival) = '.'; ;} break; case 77: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 473 "glcpp/glcpp-parse.y" { (yyval.ival) = '&'; ;} break; case 78: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 474 "glcpp/glcpp-parse.y" { (yyval.ival) = '*'; ;} break; case 79: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 475 "glcpp/glcpp-parse.y" { (yyval.ival) = '+'; ;} break; case 80: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 476 "glcpp/glcpp-parse.y" { (yyval.ival) = '-'; ;} break; case 81: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 477 "glcpp/glcpp-parse.y" { (yyval.ival) = '~'; ;} break; case 82: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 478 "glcpp/glcpp-parse.y" { (yyval.ival) = '!'; ;} break; case 83: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 479 "glcpp/glcpp-parse.y" { (yyval.ival) = '/'; ;} break; case 84: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 480 "glcpp/glcpp-parse.y" { (yyval.ival) = '%'; ;} break; case 85: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 481 "glcpp/glcpp-parse.y" { (yyval.ival) = LEFT_SHIFT; ;} break; case 86: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 482 "glcpp/glcpp-parse.y" { (yyval.ival) = RIGHT_SHIFT; ;} break; case 87: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 483 "glcpp/glcpp-parse.y" { (yyval.ival) = '<'; ;} break; case 88: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 484 "glcpp/glcpp-parse.y" { (yyval.ival) = '>'; ;} break; case 89: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 485 "glcpp/glcpp-parse.y" { (yyval.ival) = LESS_OR_EQUAL; ;} break; case 90: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 486 "glcpp/glcpp-parse.y" { (yyval.ival) = GREATER_OR_EQUAL; ;} break; case 91: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 487 "glcpp/glcpp-parse.y" { (yyval.ival) = EQUAL; ;} break; case 92: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 488 "glcpp/glcpp-parse.y" { (yyval.ival) = NOT_EQUAL; ;} break; case 93: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 489 "glcpp/glcpp-parse.y" { (yyval.ival) = '^'; ;} break; case 94: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 490 "glcpp/glcpp-parse.y" { (yyval.ival) = '|'; ;} break; case 95: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 491 "glcpp/glcpp-parse.y" { (yyval.ival) = AND; ;} break; case 96: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 492 "glcpp/glcpp-parse.y" { (yyval.ival) = OR; ;} break; case 97: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 493 "glcpp/glcpp-parse.y" { (yyval.ival) = ';'; ;} break; case 98: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 494 "glcpp/glcpp-parse.y" { (yyval.ival) = ','; ;} break; case 99: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 495 "glcpp/glcpp-parse.y" { (yyval.ival) = '='; ;} break; case 100: -/* Line 1455 of yacc.c */ +/* Line 1464 of yacc.c */ #line 496 "glcpp/glcpp-parse.y" { (yyval.ival) = PASTE; ;} break; -/* Line 1455 of yacc.c */ -#line 2582 "glcpp/glcpp-parse.c" +/* Line 1464 of yacc.c */ +#line 2590 "glcpp/glcpp-parse.c" default: break; } YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); @@ -2796,7 +2804,7 @@ yyreturn: -/* Line 1675 of yacc.c */ +/* Line 1684 of yacc.c */ #line 499 "glcpp/glcpp-parse.y" @@ -2805,7 +2813,7 @@ _string_list_create (void *ctx) { string_list_t *list; - list = xtalloc (ctx, string_list_t); + list = talloc (ctx, string_list_t); list->head = NULL; list->tail = NULL; @@ -2817,8 +2825,8 @@ _string_list_append_item (string_list_t *list, const char *str) { string_node_t *node; - node = xtalloc (list, string_node_t); - node->str = xtalloc_strdup (node, str); + node = talloc (list, string_node_t); + node->str = talloc_strdup (node, str); node->next = NULL; @@ -2871,7 +2879,7 @@ _argument_list_create (void *ctx) { argument_list_t *list; - list = xtalloc (ctx, argument_list_t); + list = talloc (ctx, argument_list_t); list->head = NULL; list->tail = NULL; @@ -2883,7 +2891,7 @@ _argument_list_append (argument_list_t *list, token_list_t *argument) { argument_node_t *node; - node = xtalloc (list, argument_node_t); + node = talloc (list, argument_node_t); node->argument = argument; node->next = NULL; @@ -2940,7 +2948,7 @@ _token_create_str (void *ctx, int type, char *str) { token_t *token; - token = xtalloc (ctx, token_t); + token = talloc (ctx, token_t); token->type = type; token->value.str = talloc_steal (token, str); @@ -2952,7 +2960,7 @@ _token_create_ival (void *ctx, int type, int ival) { token_t *token; - token = xtalloc (ctx, token_t); + token = talloc (ctx, token_t); token->type = type; token->value.ival = ival; @@ -2964,7 +2972,7 @@ _token_list_create (void *ctx) { token_list_t *list; - list = xtalloc (ctx, token_list_t); + list = talloc (ctx, token_list_t); list->head = NULL; list->tail = NULL; list->non_space_tail = NULL; @@ -2977,8 +2985,8 @@ _token_list_append (token_list_t *list, token_t *token) { token_node_t *node; - node = xtalloc (list, token_node_t); - node->token = xtalloc_reference (list, token); + node = talloc (list, token_node_t); + node->token = talloc_reference (list, token); node->next = NULL; @@ -3173,8 +3181,8 @@ _token_paste (glcpp_parser_t *parser, token_t *token, token_t *other) { char *str; - str = xtalloc_asprintf (token, "%s%s", - token->value.str, other->value.str); + str = talloc_asprintf (token, "%s%s", token->value.str, + other->value.str); combined = _token_create_str (token, token->type, str); combined->location = token->location; return combined; @@ -3229,7 +3237,7 @@ glcpp_parser_create (const struct gl_extensions *extensions) glcpp_parser_t *parser; int language_version; - parser = xtalloc (NULL, glcpp_parser_t); + parser = talloc (NULL, glcpp_parser_t); glcpp_lex_init_extra (parser, &parser->scanner); parser->defines = hash_table_ctor (32, hash_table_string_hash, @@ -3596,7 +3604,7 @@ _glcpp_parser_expand_node (glcpp_parser_t *parser, token_list_t *expansion; token_t *final; - str = xtalloc_strdup (parser, token->value.str); + str = talloc_strdup (parser, token->value.str); final = _token_create_str (parser, OTHER, str); expansion = _token_list_create (parser); _token_list_append (expansion, final); @@ -3632,8 +3640,8 @@ _active_list_push (active_list_t *list, { active_list_t *node; - node = xtalloc (list, active_list_t); - node->identifier = xtalloc_strdup (node, identifier); + node = talloc (list, active_list_t); + node->identifier = talloc_strdup (node, identifier); node->marker = marker; node->next = list; @@ -3783,7 +3791,7 @@ _define_object_macro (glcpp_parser_t *parser, if (loc != NULL) _check_for_reserved_macro_name(parser, loc, identifier); - macro = xtalloc (parser, macro_t); + macro = talloc (parser, macro_t); macro->is_function = 0; macro->parameters = NULL; @@ -3804,7 +3812,7 @@ _define_function_macro (glcpp_parser_t *parser, _check_for_reserved_macro_name(parser, loc, identifier); - macro = xtalloc (parser, macro_t); + macro = talloc (parser, macro_t); macro->is_function = 1; macro->parameters = talloc_steal (macro, parameters); @@ -3930,7 +3938,7 @@ _glcpp_parser_skip_stack_push_if (glcpp_parser_t *parser, YYLTYPE *loc, if (parser->skip_stack) current = parser->skip_stack->type; - node = xtalloc (parser, skip_node_t); + node = talloc (parser, skip_node_t); node->loc = *loc; if (current == SKIP_NO_SKIP) { diff --git a/src/glsl/glcpp/glcpp-parse.h b/src/glsl/glcpp/glcpp-parse.h index 50758930e9..53e7af0305 100644 --- a/src/glsl/glcpp/glcpp-parse.h +++ b/src/glsl/glcpp/glcpp-parse.h @@ -1,10 +1,9 @@ - -/* A Bison parser, made by GNU Bison 2.4.1. */ +/* A Bison parser, made by GNU Bison 2.4.2. */ /* Skeleton interface for Bison's Yacc-like parsers in C - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 - Free Software Foundation, Inc. + Copyright (C) 1984, 1989-1990, 2000-2006, 2009-2010 Free Software + Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by -- cgit v1.2.3 From 5a6285cc862df35ef5275c3858f833e0807dee14 Mon Sep 17 00:00:00 2001 From: Carl Worth Date: Wed, 11 Aug 2010 13:13:41 -0700 Subject: glcpp: Regenerate glcpp-lex.c After a recent change to glcpp-lex.l --- src/glsl/glcpp/glcpp-lex.c | 32 +++++++++++++++++++++++--------- 1 file changed, 23 insertions(+), 9 deletions(-) (limited to 'src/glsl/glcpp/glcpp-lex.c') diff --git a/src/glsl/glcpp/glcpp-lex.c b/src/glsl/glcpp/glcpp-lex.c index d976904135..bdb3b2c11b 100644 --- a/src/glsl/glcpp/glcpp-lex.c +++ b/src/glsl/glcpp/glcpp-lex.c @@ -54,7 +54,6 @@ typedef int flex_int32_t; typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t; typedef unsigned int flex_uint32_t; -#endif /* ! C99 */ /* Limits of integral types. */ #ifndef INT8_MIN @@ -85,6 +84,8 @@ typedef unsigned int flex_uint32_t; #define UINT32_MAX (4294967295U) #endif +#endif /* ! C99 */ + #endif /* ! FLEXINT_H */ #ifdef __cplusplus @@ -158,7 +159,15 @@ typedef void* yyscan_t; /* Size of default input buffer. */ #ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else #define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ #endif /* The state buf must be large enough to hold one state per character in the main buffer. @@ -680,9 +689,9 @@ void glcpp_set_column (int column_no , yyscan_t yyscanner); yylloc->first_line = yylineno; \ yycolumn += yyleng; \ } while(0); -#define YY_USER_INIT yylineno = 0; yycolumn = 0; +#define YY_USER_INIT yylineno = 1; yycolumn = 1; -#line 686 "glcpp/glcpp-lex.c" +#line 695 "glcpp/glcpp-lex.c" #define INITIAL 0 #define DONE 1 @@ -837,7 +846,12 @@ static int input (yyscan_t yyscanner ); /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else #define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ #endif /* Copy whatever the last rule matched to the standard output. */ @@ -845,7 +859,7 @@ static int input (yyscan_t yyscanner ); /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ -#define ECHO fwrite( yytext, yyleng, 1, yyout ) +#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) #endif /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, @@ -856,7 +870,7 @@ static int input (yyscan_t yyscanner ); if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ - int n; \ + size_t n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ @@ -948,7 +962,7 @@ YY_DECL /* Single-line comments */ -#line 952 "glcpp/glcpp-lex.c" +#line 966 "glcpp/glcpp-lex.c" yylval = yylval_param; @@ -1428,7 +1442,7 @@ YY_RULE_SETUP #line 286 "glcpp/glcpp-lex.l" ECHO; YY_BREAK -#line 1432 "glcpp/glcpp-lex.c" +#line 1446 "glcpp/glcpp-lex.c" case YY_STATE_EOF(DONE): case YY_STATE_EOF(COMMENT): case YY_STATE_EOF(UNREACHABLE): @@ -2167,8 +2181,8 @@ YY_BUFFER_STATE glcpp__scan_string (yyconst char * yystr , yyscan_t yyscanner) /** Setup the input buffer state to scan the given bytes. The next call to glcpp_lex() will * scan from a @e copy of @a bytes. - * @param bytes the byte buffer to scan - * @param len the number of bytes in the buffer pointed to by @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. * @param yyscanner The scanner object. * @return the newly allocated buffer state object. */ -- cgit v1.2.3 From 23f6017d70a705479b9bc3a1bf2ef401ac519fb9 Mon Sep 17 00:00:00 2001 From: Ian Romanick Date: Fri, 13 Aug 2010 13:13:24 -0700 Subject: glsl2: Commit generated file changed by previous commit --- src/glsl/glcpp/glcpp-lex.c | 102 +++++++++++++++++++++------------------------ 1 file changed, 47 insertions(+), 55 deletions(-) (limited to 'src/glsl/glcpp/glcpp-lex.c') diff --git a/src/glsl/glcpp/glcpp-lex.c b/src/glsl/glcpp/glcpp-lex.c index bdb3b2c11b..6b6aa12d8f 100644 --- a/src/glsl/glcpp/glcpp-lex.c +++ b/src/glsl/glcpp/glcpp-lex.c @@ -698,14 +698,6 @@ void glcpp_set_column (int column_no , yyscan_t yyscanner); #define COMMENT 2 #define UNREACHABLE 3 -#ifndef YY_NO_UNISTD_H -/* Special case for "unistd.h", since it is non-ANSI. We include it way - * down here because we want the user's section 1 to have been scanned first. - * The user has a chance to override it with an option. - */ -#include -#endif - #define YY_EXTRA_TYPE glcpp_parser_t * /* Holds the entire state of the reentrant scanner. */ @@ -958,11 +950,11 @@ YY_DECL register int yy_act; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; -#line 69 "glcpp/glcpp-lex.l" +#line 70 "glcpp/glcpp-lex.l" /* Single-line comments */ -#line 966 "glcpp/glcpp-lex.c" +#line 958 "glcpp/glcpp-lex.c" yylval = yylval_param; @@ -1032,7 +1024,7 @@ yy_match: *yyg->yy_state_ptr++ = yy_current_state; ++yy_cp; } - while ( yy_base[yy_current_state] != 549 ); + while ( yy_current_state != 150 ); yy_find_action: yy_current_state = *--yyg->yy_state_ptr; @@ -1085,7 +1077,7 @@ do_action: /* This label is used only to access EOF actions. */ case 1: /* rule 1 can match eol */ YY_RULE_SETUP -#line 72 "glcpp/glcpp-lex.l" +#line 73 "glcpp/glcpp-lex.l" { yylineno++; yycolumn = 0; @@ -1095,34 +1087,34 @@ YY_RULE_SETUP /* Multi-line comments */ case 2: YY_RULE_SETUP -#line 79 "glcpp/glcpp-lex.l" +#line 80 "glcpp/glcpp-lex.l" { yy_push_state(COMMENT, yyscanner); } YY_BREAK case 3: YY_RULE_SETUP -#line 80 "glcpp/glcpp-lex.l" +#line 81 "glcpp/glcpp-lex.l" YY_BREAK case 4: /* rule 4 can match eol */ YY_RULE_SETUP -#line 81 "glcpp/glcpp-lex.l" +#line 82 "glcpp/glcpp-lex.l" { yylineno++; yycolumn = 0; } YY_BREAK case 5: YY_RULE_SETUP -#line 82 "glcpp/glcpp-lex.l" +#line 83 "glcpp/glcpp-lex.l" YY_BREAK case 6: /* rule 6 can match eol */ YY_RULE_SETUP -#line 83 "glcpp/glcpp-lex.l" +#line 84 "glcpp/glcpp-lex.l" { yylineno++; yycolumn = 0; } YY_BREAK case 7: YY_RULE_SETUP -#line 84 "glcpp/glcpp-lex.l" +#line 85 "glcpp/glcpp-lex.l" { yy_pop_state(yyscanner); if (yyextra->space_tokens) @@ -1131,7 +1123,7 @@ YY_RULE_SETUP YY_BREAK case 8: YY_RULE_SETUP -#line 90 "glcpp/glcpp-lex.l" +#line 91 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); yylineno++; @@ -1144,7 +1136,7 @@ YY_RULE_SETUP * Simply pass them through to the main compiler's lexer/parser. */ case 9: YY_RULE_SETUP -#line 100 "glcpp/glcpp-lex.l" +#line 101 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); yylineno++; @@ -1155,7 +1147,7 @@ YY_RULE_SETUP case 10: /* rule 10 can match eol */ YY_RULE_SETUP -#line 107 "glcpp/glcpp-lex.l" +#line 108 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; @@ -1165,7 +1157,7 @@ YY_RULE_SETUP case 11: /* rule 11 can match eol */ YY_RULE_SETUP -#line 113 "glcpp/glcpp-lex.l" +#line 114 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; @@ -1175,7 +1167,7 @@ YY_RULE_SETUP case 12: /* rule 12 can match eol */ YY_RULE_SETUP -#line 119 "glcpp/glcpp-lex.l" +#line 120 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; @@ -1185,7 +1177,7 @@ YY_RULE_SETUP case 13: /* rule 13 can match eol */ YY_RULE_SETUP -#line 125 "glcpp/glcpp-lex.l" +#line 126 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; @@ -1195,7 +1187,7 @@ YY_RULE_SETUP case 14: /* rule 14 can match eol */ YY_RULE_SETUP -#line 131 "glcpp/glcpp-lex.l" +#line 132 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_ELSE; @@ -1204,7 +1196,7 @@ YY_RULE_SETUP case 15: /* rule 15 can match eol */ YY_RULE_SETUP -#line 136 "glcpp/glcpp-lex.l" +#line 137 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_ENDIF; @@ -1224,7 +1216,7 @@ case 16: yyg->yy_c_buf_p = yy_cp -= 1; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 149 "glcpp/glcpp-lex.l" +#line 150 "glcpp/glcpp-lex.l" { /* Since this rule always matches, YY_USER_ACTION gets called for it, * wrongly incrementing yycolumn. We undo that effect here. */ @@ -1239,7 +1231,7 @@ YY_RULE_SETUP YY_BREAK case 17: YY_RULE_SETUP -#line 161 "glcpp/glcpp-lex.l" +#line 162 "glcpp/glcpp-lex.l" { char *p; for (p = yytext; !isalpha(p[0]); p++); /* skip " # " */ @@ -1249,7 +1241,7 @@ YY_RULE_SETUP YY_BREAK case 18: YY_RULE_SETUP -#line 168 "glcpp/glcpp-lex.l" +#line 169 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_DEFINE_FUNC; @@ -1257,7 +1249,7 @@ YY_RULE_SETUP YY_BREAK case 19: YY_RULE_SETUP -#line 173 "glcpp/glcpp-lex.l" +#line 174 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_DEFINE_OBJ; @@ -1265,7 +1257,7 @@ YY_RULE_SETUP YY_BREAK case 20: YY_RULE_SETUP -#line 178 "glcpp/glcpp-lex.l" +#line 179 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_UNDEF; @@ -1273,7 +1265,7 @@ YY_RULE_SETUP YY_BREAK case 21: YY_RULE_SETUP -#line 183 "glcpp/glcpp-lex.l" +#line 184 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH; @@ -1281,7 +1273,7 @@ YY_RULE_SETUP YY_BREAK case 22: YY_RULE_SETUP -#line 188 "glcpp/glcpp-lex.l" +#line 189 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; @@ -1289,7 +1281,7 @@ YY_RULE_SETUP YY_BREAK case 23: YY_RULE_SETUP -#line 193 "glcpp/glcpp-lex.l" +#line 194 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; @@ -1297,7 +1289,7 @@ YY_RULE_SETUP YY_BREAK case 24: YY_RULE_SETUP -#line 198 "glcpp/glcpp-lex.l" +#line 199 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; @@ -1305,77 +1297,77 @@ YY_RULE_SETUP YY_BREAK case 25: YY_RULE_SETUP -#line 203 "glcpp/glcpp-lex.l" +#line 204 "glcpp/glcpp-lex.l" { return LEFT_SHIFT; } YY_BREAK case 26: YY_RULE_SETUP -#line 207 "glcpp/glcpp-lex.l" +#line 208 "glcpp/glcpp-lex.l" { return RIGHT_SHIFT; } YY_BREAK case 27: YY_RULE_SETUP -#line 211 "glcpp/glcpp-lex.l" +#line 212 "glcpp/glcpp-lex.l" { return LESS_OR_EQUAL; } YY_BREAK case 28: YY_RULE_SETUP -#line 215 "glcpp/glcpp-lex.l" +#line 216 "glcpp/glcpp-lex.l" { return GREATER_OR_EQUAL; } YY_BREAK case 29: YY_RULE_SETUP -#line 219 "glcpp/glcpp-lex.l" +#line 220 "glcpp/glcpp-lex.l" { return EQUAL; } YY_BREAK case 30: YY_RULE_SETUP -#line 223 "glcpp/glcpp-lex.l" +#line 224 "glcpp/glcpp-lex.l" { return NOT_EQUAL; } YY_BREAK case 31: YY_RULE_SETUP -#line 227 "glcpp/glcpp-lex.l" +#line 228 "glcpp/glcpp-lex.l" { return AND; } YY_BREAK case 32: YY_RULE_SETUP -#line 231 "glcpp/glcpp-lex.l" +#line 232 "glcpp/glcpp-lex.l" { return OR; } YY_BREAK case 33: YY_RULE_SETUP -#line 235 "glcpp/glcpp-lex.l" +#line 236 "glcpp/glcpp-lex.l" { return PASTE; } YY_BREAK case 34: YY_RULE_SETUP -#line 239 "glcpp/glcpp-lex.l" +#line 240 "glcpp/glcpp-lex.l" { return DEFINED; } YY_BREAK case 35: YY_RULE_SETUP -#line 243 "glcpp/glcpp-lex.l" +#line 244 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return IDENTIFIER; @@ -1383,14 +1375,14 @@ YY_RULE_SETUP YY_BREAK case 36: YY_RULE_SETUP -#line 248 "glcpp/glcpp-lex.l" +#line 249 "glcpp/glcpp-lex.l" { return yytext[0]; } YY_BREAK case 37: YY_RULE_SETUP -#line 252 "glcpp/glcpp-lex.l" +#line 253 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return OTHER; @@ -1398,7 +1390,7 @@ YY_RULE_SETUP YY_BREAK case 38: YY_RULE_SETUP -#line 257 "glcpp/glcpp-lex.l" +#line 258 "glcpp/glcpp-lex.l" { if (yyextra->space_tokens) { return SPACE; @@ -1408,7 +1400,7 @@ YY_RULE_SETUP case 39: /* rule 39 can match eol */ YY_RULE_SETUP -#line 263 "glcpp/glcpp-lex.l" +#line 264 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 0; yylineno++; @@ -1418,7 +1410,7 @@ YY_RULE_SETUP YY_BREAK /* Handle missing newline at EOF. */ case YY_STATE_EOF(INITIAL): -#line 271 "glcpp/glcpp-lex.l" +#line 272 "glcpp/glcpp-lex.l" { BEGIN DONE; /* Don't keep matching this rule forever. */ yyextra->lexing_if = 0; @@ -1431,7 +1423,7 @@ case YY_STATE_EOF(INITIAL): warnings. */ case 40: YY_RULE_SETUP -#line 281 "glcpp/glcpp-lex.l" +#line 282 "glcpp/glcpp-lex.l" { unput('.'); yy_top_state(yyextra); @@ -1439,10 +1431,10 @@ YY_RULE_SETUP YY_BREAK case 41: YY_RULE_SETUP -#line 286 "glcpp/glcpp-lex.l" +#line 287 "glcpp/glcpp-lex.l" ECHO; YY_BREAK -#line 1446 "glcpp/glcpp-lex.c" +#line 1438 "glcpp/glcpp-lex.c" case YY_STATE_EOF(DONE): case YY_STATE_EOF(COMMENT): case YY_STATE_EOF(UNREACHABLE): @@ -2636,7 +2628,7 @@ void glcpp_free (void * ptr , yyscan_t yyscanner) #define YYTABLES_NAME "yytables" -#line 286 "glcpp/glcpp-lex.l" +#line 287 "glcpp/glcpp-lex.l" -- cgit v1.2.3 From 2e2614586225b3fff3c21f37817064a90dd320ad Mon Sep 17 00:00:00 2001 From: Kenneth Graunke Date: Mon, 16 Aug 2010 13:43:10 -0700 Subject: glcpp: Refresh autogenerated lexer and parser. --- src/glsl/glcpp/glcpp-lex.c | 102 ++++++++++++++++++------------------------- src/glsl/glcpp/glcpp-parse.c | 2 +- 2 files changed, 44 insertions(+), 60 deletions(-) (limited to 'src/glsl/glcpp/glcpp-lex.c') diff --git a/src/glsl/glcpp/glcpp-lex.c b/src/glsl/glcpp/glcpp-lex.c index 6b6aa12d8f..de37c11be8 100644 --- a/src/glsl/glcpp/glcpp-lex.c +++ b/src/glsl/glcpp/glcpp-lex.c @@ -54,6 +54,7 @@ typedef int flex_int32_t; typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t; typedef unsigned int flex_uint32_t; +#endif /* ! C99 */ /* Limits of integral types. */ #ifndef INT8_MIN @@ -84,8 +85,6 @@ typedef unsigned int flex_uint32_t; #define UINT32_MAX (4294967295U) #endif -#endif /* ! C99 */ - #endif /* ! FLEXINT_H */ #ifdef __cplusplus @@ -159,15 +158,7 @@ typedef void* yyscan_t; /* Size of default input buffer. */ #ifndef YY_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k. - * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. - * Ditto for the __ia64__ case accordingly. - */ -#define YY_BUF_SIZE 32768 -#else #define YY_BUF_SIZE 16384 -#endif /* __ia64__ */ #endif /* The state buf must be large enough to hold one state per character in the main buffer. @@ -691,7 +682,7 @@ void glcpp_set_column (int column_no , yyscan_t yyscanner); } while(0); #define YY_USER_INIT yylineno = 1; yycolumn = 1; -#line 695 "glcpp/glcpp-lex.c" +#line 686 "glcpp/glcpp-lex.c" #define INITIAL 0 #define DONE 1 @@ -838,12 +829,7 @@ static int input (yyscan_t yyscanner ); /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k */ -#define YY_READ_BUF_SIZE 16384 -#else #define YY_READ_BUF_SIZE 8192 -#endif /* __ia64__ */ #endif /* Copy whatever the last rule matched to the standard output. */ @@ -851,7 +837,7 @@ static int input (yyscan_t yyscanner ); /* 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 fwrite( yytext, yyleng, 1, yyout ) #endif /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, @@ -862,7 +848,7 @@ static int input (yyscan_t yyscanner ); if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ - size_t n; \ + int n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ @@ -954,7 +940,7 @@ YY_DECL /* Single-line comments */ -#line 958 "glcpp/glcpp-lex.c" +#line 944 "glcpp/glcpp-lex.c" yylval = yylval_param; @@ -1126,8 +1112,6 @@ YY_RULE_SETUP #line 91 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); - yylineno++; - yycolumn = 0; yyextra->space_tokens = 0; return HASH_VERSION; } @@ -1136,7 +1120,7 @@ YY_RULE_SETUP * Simply pass them through to the main compiler's lexer/parser. */ case 9: YY_RULE_SETUP -#line 101 "glcpp/glcpp-lex.l" +#line 99 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); yylineno++; @@ -1147,7 +1131,7 @@ YY_RULE_SETUP case 10: /* rule 10 can match eol */ YY_RULE_SETUP -#line 108 "glcpp/glcpp-lex.l" +#line 106 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; @@ -1157,7 +1141,7 @@ YY_RULE_SETUP case 11: /* rule 11 can match eol */ YY_RULE_SETUP -#line 114 "glcpp/glcpp-lex.l" +#line 112 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; @@ -1167,7 +1151,7 @@ YY_RULE_SETUP case 12: /* rule 12 can match eol */ YY_RULE_SETUP -#line 120 "glcpp/glcpp-lex.l" +#line 118 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; @@ -1177,7 +1161,7 @@ YY_RULE_SETUP case 13: /* rule 13 can match eol */ YY_RULE_SETUP -#line 126 "glcpp/glcpp-lex.l" +#line 124 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; @@ -1187,7 +1171,7 @@ YY_RULE_SETUP case 14: /* rule 14 can match eol */ YY_RULE_SETUP -#line 132 "glcpp/glcpp-lex.l" +#line 130 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_ELSE; @@ -1196,7 +1180,7 @@ YY_RULE_SETUP case 15: /* rule 15 can match eol */ YY_RULE_SETUP -#line 137 "glcpp/glcpp-lex.l" +#line 135 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_ENDIF; @@ -1216,7 +1200,7 @@ case 16: yyg->yy_c_buf_p = yy_cp -= 1; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 150 "glcpp/glcpp-lex.l" +#line 148 "glcpp/glcpp-lex.l" { /* Since this rule always matches, YY_USER_ACTION gets called for it, * wrongly incrementing yycolumn. We undo that effect here. */ @@ -1231,7 +1215,7 @@ YY_RULE_SETUP YY_BREAK case 17: YY_RULE_SETUP -#line 162 "glcpp/glcpp-lex.l" +#line 160 "glcpp/glcpp-lex.l" { char *p; for (p = yytext; !isalpha(p[0]); p++); /* skip " # " */ @@ -1241,7 +1225,7 @@ YY_RULE_SETUP YY_BREAK case 18: YY_RULE_SETUP -#line 169 "glcpp/glcpp-lex.l" +#line 167 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_DEFINE_FUNC; @@ -1249,7 +1233,7 @@ YY_RULE_SETUP YY_BREAK case 19: YY_RULE_SETUP -#line 174 "glcpp/glcpp-lex.l" +#line 172 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_DEFINE_OBJ; @@ -1257,7 +1241,7 @@ YY_RULE_SETUP YY_BREAK case 20: YY_RULE_SETUP -#line 179 "glcpp/glcpp-lex.l" +#line 177 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_UNDEF; @@ -1265,7 +1249,7 @@ YY_RULE_SETUP YY_BREAK case 21: YY_RULE_SETUP -#line 184 "glcpp/glcpp-lex.l" +#line 182 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH; @@ -1273,7 +1257,7 @@ YY_RULE_SETUP YY_BREAK case 22: YY_RULE_SETUP -#line 189 "glcpp/glcpp-lex.l" +#line 187 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; @@ -1281,7 +1265,7 @@ YY_RULE_SETUP YY_BREAK case 23: YY_RULE_SETUP -#line 194 "glcpp/glcpp-lex.l" +#line 192 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; @@ -1289,7 +1273,7 @@ YY_RULE_SETUP YY_BREAK case 24: YY_RULE_SETUP -#line 199 "glcpp/glcpp-lex.l" +#line 197 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; @@ -1297,77 +1281,77 @@ YY_RULE_SETUP YY_BREAK case 25: YY_RULE_SETUP -#line 204 "glcpp/glcpp-lex.l" +#line 202 "glcpp/glcpp-lex.l" { return LEFT_SHIFT; } YY_BREAK case 26: YY_RULE_SETUP -#line 208 "glcpp/glcpp-lex.l" +#line 206 "glcpp/glcpp-lex.l" { return RIGHT_SHIFT; } YY_BREAK case 27: YY_RULE_SETUP -#line 212 "glcpp/glcpp-lex.l" +#line 210 "glcpp/glcpp-lex.l" { return LESS_OR_EQUAL; } YY_BREAK case 28: YY_RULE_SETUP -#line 216 "glcpp/glcpp-lex.l" +#line 214 "glcpp/glcpp-lex.l" { return GREATER_OR_EQUAL; } YY_BREAK case 29: YY_RULE_SETUP -#line 220 "glcpp/glcpp-lex.l" +#line 218 "glcpp/glcpp-lex.l" { return EQUAL; } YY_BREAK case 30: YY_RULE_SETUP -#line 224 "glcpp/glcpp-lex.l" +#line 222 "glcpp/glcpp-lex.l" { return NOT_EQUAL; } YY_BREAK case 31: YY_RULE_SETUP -#line 228 "glcpp/glcpp-lex.l" +#line 226 "glcpp/glcpp-lex.l" { return AND; } YY_BREAK case 32: YY_RULE_SETUP -#line 232 "glcpp/glcpp-lex.l" +#line 230 "glcpp/glcpp-lex.l" { return OR; } YY_BREAK case 33: YY_RULE_SETUP -#line 236 "glcpp/glcpp-lex.l" +#line 234 "glcpp/glcpp-lex.l" { return PASTE; } YY_BREAK case 34: YY_RULE_SETUP -#line 240 "glcpp/glcpp-lex.l" +#line 238 "glcpp/glcpp-lex.l" { return DEFINED; } YY_BREAK case 35: YY_RULE_SETUP -#line 244 "glcpp/glcpp-lex.l" +#line 242 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return IDENTIFIER; @@ -1375,14 +1359,14 @@ YY_RULE_SETUP YY_BREAK case 36: YY_RULE_SETUP -#line 249 "glcpp/glcpp-lex.l" +#line 247 "glcpp/glcpp-lex.l" { return yytext[0]; } YY_BREAK case 37: YY_RULE_SETUP -#line 253 "glcpp/glcpp-lex.l" +#line 251 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return OTHER; @@ -1390,7 +1374,7 @@ YY_RULE_SETUP YY_BREAK case 38: YY_RULE_SETUP -#line 258 "glcpp/glcpp-lex.l" +#line 256 "glcpp/glcpp-lex.l" { if (yyextra->space_tokens) { return SPACE; @@ -1400,7 +1384,7 @@ YY_RULE_SETUP case 39: /* rule 39 can match eol */ YY_RULE_SETUP -#line 264 "glcpp/glcpp-lex.l" +#line 262 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 0; yylineno++; @@ -1410,7 +1394,7 @@ YY_RULE_SETUP YY_BREAK /* Handle missing newline at EOF. */ case YY_STATE_EOF(INITIAL): -#line 272 "glcpp/glcpp-lex.l" +#line 270 "glcpp/glcpp-lex.l" { BEGIN DONE; /* Don't keep matching this rule forever. */ yyextra->lexing_if = 0; @@ -1423,7 +1407,7 @@ case YY_STATE_EOF(INITIAL): warnings. */ case 40: YY_RULE_SETUP -#line 282 "glcpp/glcpp-lex.l" +#line 280 "glcpp/glcpp-lex.l" { unput('.'); yy_top_state(yyextra); @@ -1431,10 +1415,10 @@ YY_RULE_SETUP YY_BREAK case 41: YY_RULE_SETUP -#line 287 "glcpp/glcpp-lex.l" +#line 285 "glcpp/glcpp-lex.l" ECHO; YY_BREAK -#line 1438 "glcpp/glcpp-lex.c" +#line 1422 "glcpp/glcpp-lex.c" case YY_STATE_EOF(DONE): case YY_STATE_EOF(COMMENT): case YY_STATE_EOF(UNREACHABLE): @@ -2173,8 +2157,8 @@ YY_BUFFER_STATE glcpp__scan_string (yyconst char * yystr , yyscan_t yyscanner) /** Setup the input buffer state to scan the given bytes. The next call to glcpp_lex() will * scan from a @e copy of @a bytes. - * @param yybytes the byte buffer to scan - * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * @param bytes the byte buffer to scan + * @param len the number of bytes in the buffer pointed to by @a bytes. * @param yyscanner The scanner object. * @return the newly allocated buffer state object. */ @@ -2628,7 +2612,7 @@ void glcpp_free (void * ptr , yyscan_t yyscanner) #define YYTABLES_NAME "yytables" -#line 287 "glcpp/glcpp-lex.l" +#line 285 "glcpp/glcpp-lex.l" diff --git a/src/glsl/glcpp/glcpp-parse.c b/src/glsl/glcpp/glcpp-parse.c index bd0fbc4fcf..a19a02a867 100644 --- a/src/glsl/glcpp/glcpp-parse.c +++ b/src/glsl/glcpp/glcpp-parse.c @@ -2016,7 +2016,7 @@ yyreduce: talloc_free (macro); } add_builtin_define (parser, "__VERSION__", (yyvsp[(2) - (3)].ival)); - glcpp_printf(parser->output, "#version %" PRIiMAX "\n", (yyvsp[(2) - (3)].ival)); + glcpp_printf(parser->output, "#version %" PRIiMAX, (yyvsp[(2) - (3)].ival)); ;} break; -- cgit v1.2.3 From b9892f22d18400db2f20f20b05c301248209bf48 Mon Sep 17 00:00:00 2001 From: Carl Worth Date: Tue, 17 Aug 2010 22:22:13 -0700 Subject: glcpp: Regenerated glcpp-lex.c from previous commit. The previous commit changed glcpp-lex.l so we commit the resulting generated file here. --- src/glsl/glcpp/glcpp-lex.c | 397 +++++++++++++++++++++++---------------------- 1 file changed, 203 insertions(+), 194 deletions(-) (limited to 'src/glsl/glcpp/glcpp-lex.c') diff --git a/src/glsl/glcpp/glcpp-lex.c b/src/glsl/glcpp/glcpp-lex.c index de37c11be8..a0de91a634 100644 --- a/src/glsl/glcpp/glcpp-lex.c +++ b/src/glsl/glcpp/glcpp-lex.c @@ -54,7 +54,6 @@ typedef int flex_int32_t; typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t; typedef unsigned int flex_uint32_t; -#endif /* ! C99 */ /* Limits of integral types. */ #ifndef INT8_MIN @@ -85,6 +84,8 @@ typedef unsigned int flex_uint32_t; #define UINT32_MAX (4294967295U) #endif +#endif /* ! C99 */ + #endif /* ! FLEXINT_H */ #ifdef __cplusplus @@ -158,7 +159,15 @@ typedef void* yyscan_t; /* Size of default input buffer. */ #ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else #define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ #endif /* The state buf must be large enough to hold one state per character in the main buffer. @@ -365,10 +374,10 @@ static yyconst flex_int16_t yy_acclist[133] = 37, 41, 22, 37, 41, 36, 41, 36, 41, 36, 41, 35, 37, 41, 35, 37, 41, 36, 41, 38, 41, 21, 41, 41, 3, 41, 4, 41, 5, 41, - 40, 41, 37, 16, 38, 30, 33, 31, 2, 23, - 37, 23, 37, 37, 22, 37, 22, 37, 25, 27, - 29, 28, 26, 35, 37, 35, 37, 32, 38, 21, - 21, 3, 4, 5, 6, 5, 7, 1, 16, 24, + 40, 41, 37, 16, 38, 30, 33, 31, 2, 1, + 23, 37, 23, 37, 37, 22, 37, 22, 37, 25, + 27, 29, 28, 26, 35, 37, 35, 37, 32, 38, + 21, 21, 3, 4, 5, 6, 5, 7, 1, 24, 37, 35, 37,16396, 24, 37, 35, 37, 16, 35, 37,16397,16398, 8204, 16, 8204, 35, 37, 8205, 16, @@ -377,25 +386,24 @@ static yyconst flex_int16_t yy_acclist[133] = 8, 8210 } ; -static yyconst flex_int16_t yy_accept[152] = +static yyconst flex_int16_t yy_accept[151] = { 0, 1, 1, 1, 1, 1, 2, 3, 3, 3, 4, 6, 8, 10, 11, 13, 14, 16, 18, 20, 23, 26, 28, 30, 32, 35, 38, 40, 42, 44, 45, 47, 49, 51, 53, 54, 54, 55, 56, 57, 58, - 59, 60, 60, 62, 64, 65, 67, 69, 70, 71, - 72, 73, 74, 76, 78, 79, 80, 81, 82, 82, - 82, 82, 82, 82, 82, 83, 84, 85, 86, 87, - 88, 88, 90, 92, 94, 94, 94, 94, 94, 94, - 95, 95, 95, 95, 97, 99, 99, 99, 99, 99, - 99, 99, 99, 100, 100, 100, 100, 100, 100, 102, - - 102, 103, 104, 104, 104, 104, 104, 106, 106, 107, - 107, 107, 107, 107, 107, 109, 109, 109, 111, 111, - 113, 114, 115, 115, 116, 116, 116, 117, 117, 120, - 121, 121, 123, 124, 124, 124, 126, 127, 127, 127, - 128, 128, 128, 130, 131, 132, 132, 132, 133, 133, - 133 + 59, 60, 61, 63, 65, 66, 68, 70, 71, 72, + 73, 74, 75, 77, 79, 80, 81, 82, 83, 83, + 83, 83, 83, 83, 83, 84, 85, 86, 87, 88, + 89, 90, 92, 94, 94, 94, 94, 94, 94, 95, + 95, 95, 95, 97, 99, 99, 99, 99, 99, 99, + 99, 99, 100, 100, 100, 100, 100, 100, 102, 102, + + 103, 104, 104, 104, 104, 104, 106, 106, 107, 107, + 107, 107, 107, 107, 109, 109, 109, 111, 111, 113, + 114, 115, 115, 116, 116, 116, 117, 117, 120, 121, + 121, 123, 124, 124, 124, 126, 127, 127, 127, 128, + 128, 128, 130, 131, 132, 132, 132, 133, 133, 133 } ; static yyconst flex_int32_t yy_ec[256] = @@ -438,7 +446,7 @@ static yyconst flex_int32_t yy_meta[40] = 1, 1, 1, 1, 1, 1, 1, 1, 1 } ; -static yyconst flex_int16_t yy_base[170] = +static yyconst flex_int16_t yy_base[169] = { 0, 0, 38, 0, 0, 38, 39, 427, 426, 428, 48, 43, 549, 424, 44, 63, 423, 59, 65, 87, 125, @@ -447,39 +455,39 @@ static yyconst flex_int16_t yy_base[170] = 417, 415, 156, 179, 267, 0, 209, 414, 413, 412, 411, 410, 388, 124, 408, 153, 404, 403, 154, 198, 159, 155, 160, 192, 405, 549, 186, 549, 214, 549, - 404, 549, 162, 159, 227, 229, 230, 234, 199, 303, - 232, 235, 236, 262, 56, 243, 237, 247, 245, 252, - 291, 359, 358, 292, 238, 296, 293, 254, 336, 256, - - 356, 355, 298, 294, 263, 354, 549, 352, 549, 299, - 297, 322, 325, 257, 306, 328, 350, 549, 346, 549, - 345, 344, 329, 343, 331, 332, 342, 333, 320, 335, - 340, 549, 337, 338, 248, 549, 246, 197, 336, 366, - 403, 184, 549, 182, 141, 434, 416, 79, 473, 549, - 512, 514, 516, 518, 520, 522, 71, 524, 526, 528, - 530, 532, 534, 536, 538, 540, 542, 544, 546 + 404, 162, 159, 227, 229, 230, 234, 199, 303, 232, + 235, 236, 262, 56, 243, 237, 247, 245, 252, 291, + 359, 358, 292, 238, 296, 293, 254, 336, 256, 356, + + 355, 298, 294, 263, 354, 549, 352, 549, 299, 297, + 322, 325, 257, 306, 328, 350, 549, 346, 549, 345, + 344, 329, 343, 331, 332, 342, 333, 320, 335, 340, + 549, 337, 338, 248, 549, 246, 197, 336, 366, 403, + 184, 549, 182, 141, 434, 416, 79, 473, 549, 512, + 514, 516, 518, 520, 522, 71, 524, 526, 528, 530, + 532, 534, 536, 538, 540, 542, 544, 546 } ; -static yyconst flex_int16_t yy_def[170] = +static yyconst flex_int16_t yy_def[169] = { 0, - 150, 1, 151, 151, 152, 152, 153, 153, 150, 154, - 155, 150, 155, 155, 155, 155, 155, 155, 150, 154, - 155, 155, 155, 156, 156, 155, 155, 155, 150, 157, - 150, 158, 150, 20, 155, 150, 155, 155, 155, 155, - 155, 159, 19, 20, 20, 20, 20, 155, 155, 155, - 155, 155, 25, 25, 155, 155, 28, 28, 155, 155, - 155, 155, 155, 155, 157, 150, 158, 150, 158, 150, - 159, 150, 45, 25, 155, 155, 155, 155, 155, 155, - 155, 155, 155, 20, 25, 155, 155, 155, 155, 155, - 155, 160, 161, 155, 155, 155, 155, 155, 25, 155, - - 162, 163, 155, 155, 155, 160, 150, 161, 150, 155, - 155, 155, 155, 155, 25, 155, 162, 150, 163, 150, - 164, 165, 155, 166, 155, 155, 155, 155, 25, 155, - 164, 150, 165, 155, 166, 150, 167, 168, 155, 150, - 155, 167, 150, 168, 155, 169, 155, 155, 169, 0, - 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, - 150, 150, 150, 150, 150, 150, 150, 150, 150 + 149, 1, 150, 150, 151, 151, 152, 152, 149, 153, + 154, 149, 154, 154, 154, 154, 154, 154, 149, 153, + 154, 154, 154, 155, 155, 154, 154, 154, 149, 156, + 149, 157, 149, 20, 154, 149, 154, 154, 154, 154, + 154, 158, 19, 20, 20, 20, 20, 154, 154, 154, + 154, 154, 25, 25, 154, 154, 28, 28, 154, 154, + 154, 154, 154, 154, 156, 149, 157, 149, 157, 149, + 158, 45, 25, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 20, 25, 154, 154, 154, 154, 154, 154, + 159, 160, 154, 154, 154, 154, 154, 25, 154, 161, + + 162, 154, 154, 154, 159, 149, 160, 149, 154, 154, + 154, 154, 154, 25, 154, 161, 149, 162, 149, 163, + 164, 154, 165, 154, 154, 154, 154, 25, 154, 163, + 149, 164, 154, 165, 149, 166, 167, 154, 149, 154, + 166, 149, 167, 154, 168, 154, 154, 168, 0, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149 } ; static yyconst flex_int16_t yy_nxt[589] = @@ -492,62 +500,62 @@ static yyconst flex_int16_t yy_nxt[589] = 36, 35, 35, 35, 35, 35, 35, 35, 35, 38, 36, 36, 35, 35, 35, 36, 40, 36, 39, 36, 36, 65, 48, 49, 41, 42, 56, 36, 55, 53, - 57, 36, 50, 51, 52, 99, 35, 34, 35, 36, + 57, 36, 50, 51, 52, 98, 35, 34, 35, 36, 35, 35, 35, 35, 35, 35, 35, 35, 43, 43, 34, 35, 35, 35, 34, 34, 44, 45, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 44, 34, 45, 35, 35, 36, 35, 35, 35, 35, 35, 35, 35, 35, 46, 46, 46, 35, - 35, 35, 68, 36, 47, 37, 36, 53, 74, 69, + 35, 35, 68, 36, 47, 37, 36, 53, 73, 69, 70, 34, 34, 34, 56, 36, 36, 36, 57, 34, 47, 36, 36, 35, 34, 35, 36, 35, 35, 35, - 35, 35, 35, 35, 35, 34, 34, 75, 35, 35, - 35, 84, 53, 80, 36, 85, 143, 81, 68, 82, - 34, 34, 34, 34, 36, 150, 150, 84, 34, 36, + 35, 35, 35, 35, 35, 34, 34, 74, 35, 35, + 35, 83, 53, 79, 36, 84, 142, 80, 68, 81, + 34, 34, 34, 34, 36, 149, 149, 83, 34, 36, 36, 36, 35, 34, 35, 36, 35, 35, 35, 35, - 35, 35, 35, 35, 34, 83, 68, 35, 35, 35, - 34, 34, 34, 69, 70, 76, 54, 77, 34, 36, - 78, 36, 36, 91, 36, 79, 36, 36, 36, 36, - 36, 35, 58, 36, 34, 36, 39, 36, 143, 36, - 136, 86, 89, 96, 36, 87, 36, 97, 36, 36, - 111, 101, 88, 59, 60, 36, 90, 61, 98, 100, - 102, 103, 62, 34, 34, 34, 63, 64, 73, 73, - 73, 34, 104, 128, 73, 116, 34, 114, 73, 73, - 73, 73, 123, 36, 36, 36, 36, 34, 36, 36, - - 36, 36, 34, 92, 92, 93, 92, 92, 92, 92, - 92, 92, 92, 92, 105, 110, 113, 92, 92, 92, - 125, 112, 121, 124, 36, 94, 122, 36, 129, 53, - 36, 36, 95, 36, 36, 36, 140, 36, 36, 36, - 36, 92, 132, 53, 36, 136, 36, 132, 120, 127, - 126, 130, 118, 138, 109, 137, 107, 120, 118, 115, - 109, 107, 134, 139, 141, 145, 35, 140, 36, 35, + 35, 35, 35, 35, 34, 82, 68, 35, 35, 35, + 34, 34, 34, 69, 70, 75, 54, 76, 34, 36, + 77, 36, 36, 90, 36, 78, 36, 36, 36, 36, + 36, 35, 58, 36, 34, 36, 39, 36, 142, 36, + 135, 85, 88, 95, 36, 86, 36, 96, 36, 36, + 110, 100, 87, 59, 60, 36, 89, 61, 97, 99, + 101, 102, 62, 34, 34, 34, 63, 64, 72, 72, + 72, 34, 103, 127, 72, 115, 34, 113, 72, 72, + 72, 72, 122, 36, 36, 36, 36, 34, 36, 36, + + 36, 36, 34, 91, 91, 92, 91, 91, 91, 91, + 91, 91, 91, 91, 104, 109, 112, 91, 91, 91, + 124, 111, 120, 123, 36, 93, 121, 36, 128, 53, + 36, 36, 94, 36, 36, 36, 139, 36, 36, 36, + 36, 91, 131, 53, 36, 135, 36, 131, 119, 126, + 125, 129, 117, 137, 108, 136, 106, 119, 117, 114, + 108, 106, 133, 138, 140, 144, 35, 139, 36, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, - 35, 35, 35, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - - 146, 146, 146, 146, 35, 36, 72, 66, 35, 35, - 36, 53, 36, 36, 36, 36, 36, 72, 36, 36, - 36, 36, 36, 36, 66, 36, 36, 150, 29, 29, - 150, 150, 150, 147, 35, 35, 36, 35, 35, 35, - 35, 35, 148, 35, 35, 138, 150, 150, 35, 35, - 35, 150, 150, 150, 150, 150, 150, 150, 150, 150, - 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, - 150, 150, 35, 35, 35, 36, 35, 35, 35, 35, - 35, 148, 35, 35, 150, 150, 150, 35, 35, 35, - 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, - - 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, - 150, 35, 29, 29, 30, 30, 33, 33, 34, 34, - 35, 35, 53, 53, 67, 67, 71, 71, 106, 106, - 108, 108, 117, 117, 119, 119, 131, 131, 133, 133, - 135, 135, 142, 142, 144, 144, 149, 149, 9, 150, - 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, - 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, - 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, - 150, 150, 150, 150, 150, 150, 150, 150 + 35, 35, 35, 145, 145, 145, 145, 145, 145, 145, + 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, + + 145, 145, 145, 145, 35, 36, 36, 66, 35, 35, + 36, 53, 36, 36, 36, 36, 36, 36, 36, 36, + 36, 36, 36, 36, 66, 36, 36, 149, 29, 29, + 149, 149, 149, 146, 35, 35, 36, 35, 35, 35, + 35, 35, 147, 35, 35, 137, 149, 149, 35, 35, + 35, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 35, 35, 35, 36, 35, 35, 35, 35, + 35, 147, 35, 35, 149, 149, 149, 35, 35, 35, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 35, 29, 29, 30, 30, 33, 33, 34, 34, + 35, 35, 53, 53, 67, 67, 71, 71, 105, 105, + 107, 107, 116, 116, 118, 118, 130, 130, 132, 132, + 134, 134, 141, 141, 143, 143, 148, 148, 9, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149 } ; static yyconst flex_int16_t yy_chk[589] = @@ -559,63 +567,63 @@ static yyconst flex_int16_t yy_chk[589] = 5, 6, 26, 2, 11, 11, 14, 5, 6, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 14, 21, 17, 10, 10, 10, 15, 17, 18, 15, 22, - 23, 157, 21, 21, 18, 18, 27, 27, 26, 85, - 27, 148, 22, 23, 23, 85, 10, 19, 19, 19, + 23, 156, 21, 21, 18, 18, 27, 27, 26, 84, + 27, 147, 22, 23, 23, 84, 10, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, - 20, 20, 32, 145, 20, 37, 37, 54, 54, 32, + 20, 20, 32, 144, 20, 37, 37, 54, 54, 32, 32, 34, 34, 34, 56, 56, 59, 62, 56, 34, 20, 61, 63, 20, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 34, 43, 59, 24, 24, - 24, 73, 74, 61, 144, 74, 142, 62, 67, 63, - 44, 44, 44, 43, 64, 67, 67, 73, 44, 138, + 24, 72, 73, 61, 143, 73, 141, 62, 67, 63, + 44, 44, 44, 43, 64, 67, 67, 72, 44, 137, - 60, 79, 24, 25, 25, 25, 25, 25, 25, 25, + 60, 78, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 44, 64, 69, 25, 25, 25, - 47, 47, 47, 69, 69, 60, 25, 60, 47, 75, - 60, 76, 77, 79, 81, 60, 78, 82, 83, 87, - 95, 25, 28, 28, 47, 86, 28, 89, 137, 88, - 135, 75, 77, 81, 90, 76, 98, 82, 100, 114, - 95, 87, 76, 28, 28, 105, 78, 28, 83, 86, - 88, 89, 28, 84, 84, 84, 28, 28, 45, 45, - 45, 84, 90, 114, 45, 100, 45, 98, 45, 45, - 45, 45, 105, 91, 94, 97, 104, 84, 96, 111, - - 103, 110, 45, 80, 80, 80, 80, 80, 80, 80, - 80, 80, 80, 80, 91, 94, 97, 80, 80, 80, - 111, 96, 103, 110, 112, 80, 104, 113, 115, 115, - 116, 123, 80, 125, 126, 128, 130, 130, 139, 133, - 134, 80, 131, 129, 127, 124, 122, 121, 119, 113, - 112, 116, 117, 126, 108, 125, 106, 102, 101, 99, - 93, 92, 123, 128, 134, 139, 140, 140, 140, 140, - 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, - 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, - 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, - - 140, 140, 140, 140, 140, 141, 71, 65, 58, 57, - 55, 53, 52, 51, 50, 49, 48, 42, 147, 41, + 47, 47, 47, 69, 69, 60, 25, 60, 47, 74, + 60, 75, 76, 78, 80, 60, 77, 81, 82, 86, + 94, 25, 28, 28, 47, 85, 28, 88, 136, 87, + 134, 74, 76, 80, 89, 75, 97, 81, 99, 113, + 94, 86, 75, 28, 28, 104, 77, 28, 82, 85, + 87, 88, 28, 83, 83, 83, 28, 28, 45, 45, + 45, 83, 89, 113, 45, 99, 45, 97, 45, 45, + 45, 45, 104, 90, 93, 96, 103, 83, 95, 110, + + 102, 109, 45, 79, 79, 79, 79, 79, 79, 79, + 79, 79, 79, 79, 90, 93, 96, 79, 79, 79, + 110, 95, 102, 109, 111, 79, 103, 112, 114, 114, + 115, 122, 79, 124, 125, 127, 129, 129, 138, 132, + 133, 79, 130, 128, 126, 123, 121, 120, 118, 112, + 111, 115, 116, 125, 107, 124, 105, 101, 100, 98, + 92, 91, 122, 127, 133, 138, 139, 139, 139, 139, + 139, 139, 139, 139, 139, 139, 139, 139, 139, 139, + 139, 139, 139, 139, 139, 139, 139, 139, 139, 139, + 139, 139, 139, 139, 139, 139, 139, 139, 139, 139, + + 139, 139, 139, 139, 139, 140, 71, 65, 58, 57, + 55, 53, 52, 51, 50, 49, 48, 42, 146, 41, 40, 39, 38, 35, 30, 16, 13, 9, 8, 7, - 0, 0, 0, 141, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 147, 0, 0, 146, 146, - 146, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 140, 145, 145, 145, 145, 145, 145, + 145, 145, 145, 145, 145, 146, 0, 0, 145, 145, + 145, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 146, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 0, 0, 0, 149, 149, 149, + 0, 0, 145, 148, 148, 148, 148, 148, 148, 148, + 148, 148, 148, 148, 0, 0, 0, 148, 148, 148, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 149, 151, 151, 152, 152, 153, 153, 154, 154, - 155, 155, 156, 156, 158, 158, 159, 159, 160, 160, - 161, 161, 162, 162, 163, 163, 164, 164, 165, 165, - 166, 166, 167, 167, 168, 168, 169, 169, 150, 150, - 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, - 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, - 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, - 150, 150, 150, 150, 150, 150, 150, 150 + 0, 148, 150, 150, 151, 151, 152, 152, 153, 153, + 154, 154, 155, 155, 157, 157, 158, 158, 159, 159, + 160, 160, 161, 161, 162, 162, 163, 163, 164, 164, + 165, 165, 166, 166, 167, 167, 168, 168, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149 } ; #define YY_TRAILING_MASK 0x2000 @@ -682,7 +690,7 @@ void glcpp_set_column (int column_no , yyscan_t yyscanner); } while(0); #define YY_USER_INIT yylineno = 1; yycolumn = 1; -#line 686 "glcpp/glcpp-lex.c" +#line 694 "glcpp/glcpp-lex.c" #define INITIAL 0 #define DONE 1 @@ -829,7 +837,12 @@ static int input (yyscan_t yyscanner ); /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else #define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ #endif /* Copy whatever the last rule matched to the standard output. */ @@ -837,7 +850,7 @@ static int input (yyscan_t yyscanner ); /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ -#define ECHO fwrite( yytext, yyleng, 1, yyout ) +#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) #endif /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, @@ -848,7 +861,7 @@ static int input (yyscan_t yyscanner ); if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ - int n; \ + size_t n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ @@ -940,7 +953,7 @@ YY_DECL /* Single-line comments */ -#line 944 "glcpp/glcpp-lex.c" +#line 957 "glcpp/glcpp-lex.c" yylval = yylval_param; @@ -1003,14 +1016,14 @@ yy_match: 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 >= 151 ) + if ( yy_current_state >= 150 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; *yyg->yy_state_ptr++ = yy_current_state; ++yy_cp; } - while ( yy_current_state != 150 ); + while ( yy_current_state != 149 ); yy_find_action: yy_current_state = *--yyg->yy_state_ptr; @@ -1061,46 +1074,42 @@ do_action: /* This label is used only to access EOF actions. */ switch ( yy_act ) { /* beginning of action switch */ case 1: -/* rule 1 can match eol */ YY_RULE_SETUP #line 73 "glcpp/glcpp-lex.l" { - yylineno++; - yycolumn = 0; - return NEWLINE; } YY_BREAK /* Multi-line comments */ case 2: YY_RULE_SETUP -#line 80 "glcpp/glcpp-lex.l" +#line 77 "glcpp/glcpp-lex.l" { yy_push_state(COMMENT, yyscanner); } YY_BREAK case 3: YY_RULE_SETUP -#line 81 "glcpp/glcpp-lex.l" +#line 78 "glcpp/glcpp-lex.l" YY_BREAK case 4: /* rule 4 can match eol */ YY_RULE_SETUP -#line 82 "glcpp/glcpp-lex.l" +#line 79 "glcpp/glcpp-lex.l" { yylineno++; yycolumn = 0; } YY_BREAK case 5: YY_RULE_SETUP -#line 83 "glcpp/glcpp-lex.l" +#line 80 "glcpp/glcpp-lex.l" YY_BREAK case 6: /* rule 6 can match eol */ YY_RULE_SETUP -#line 84 "glcpp/glcpp-lex.l" +#line 81 "glcpp/glcpp-lex.l" { yylineno++; yycolumn = 0; } YY_BREAK case 7: YY_RULE_SETUP -#line 85 "glcpp/glcpp-lex.l" +#line 82 "glcpp/glcpp-lex.l" { yy_pop_state(yyscanner); if (yyextra->space_tokens) @@ -1109,7 +1118,7 @@ YY_RULE_SETUP YY_BREAK case 8: YY_RULE_SETUP -#line 91 "glcpp/glcpp-lex.l" +#line 88 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); yyextra->space_tokens = 0; @@ -1120,7 +1129,7 @@ YY_RULE_SETUP * Simply pass them through to the main compiler's lexer/parser. */ case 9: YY_RULE_SETUP -#line 99 "glcpp/glcpp-lex.l" +#line 96 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); yylineno++; @@ -1131,7 +1140,7 @@ YY_RULE_SETUP case 10: /* rule 10 can match eol */ YY_RULE_SETUP -#line 106 "glcpp/glcpp-lex.l" +#line 103 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; @@ -1141,7 +1150,7 @@ YY_RULE_SETUP case 11: /* rule 11 can match eol */ YY_RULE_SETUP -#line 112 "glcpp/glcpp-lex.l" +#line 109 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; @@ -1151,7 +1160,7 @@ YY_RULE_SETUP case 12: /* rule 12 can match eol */ YY_RULE_SETUP -#line 118 "glcpp/glcpp-lex.l" +#line 115 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; @@ -1161,7 +1170,7 @@ YY_RULE_SETUP case 13: /* rule 13 can match eol */ YY_RULE_SETUP -#line 124 "glcpp/glcpp-lex.l" +#line 121 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; @@ -1171,7 +1180,7 @@ YY_RULE_SETUP case 14: /* rule 14 can match eol */ YY_RULE_SETUP -#line 130 "glcpp/glcpp-lex.l" +#line 127 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_ELSE; @@ -1180,7 +1189,7 @@ YY_RULE_SETUP case 15: /* rule 15 can match eol */ YY_RULE_SETUP -#line 135 "glcpp/glcpp-lex.l" +#line 132 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_ENDIF; @@ -1200,7 +1209,7 @@ case 16: yyg->yy_c_buf_p = yy_cp -= 1; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 148 "glcpp/glcpp-lex.l" +#line 145 "glcpp/glcpp-lex.l" { /* Since this rule always matches, YY_USER_ACTION gets called for it, * wrongly incrementing yycolumn. We undo that effect here. */ @@ -1215,7 +1224,7 @@ YY_RULE_SETUP YY_BREAK case 17: YY_RULE_SETUP -#line 160 "glcpp/glcpp-lex.l" +#line 157 "glcpp/glcpp-lex.l" { char *p; for (p = yytext; !isalpha(p[0]); p++); /* skip " # " */ @@ -1225,7 +1234,7 @@ YY_RULE_SETUP YY_BREAK case 18: YY_RULE_SETUP -#line 167 "glcpp/glcpp-lex.l" +#line 164 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_DEFINE_FUNC; @@ -1233,7 +1242,7 @@ YY_RULE_SETUP YY_BREAK case 19: YY_RULE_SETUP -#line 172 "glcpp/glcpp-lex.l" +#line 169 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_DEFINE_OBJ; @@ -1241,7 +1250,7 @@ YY_RULE_SETUP YY_BREAK case 20: YY_RULE_SETUP -#line 177 "glcpp/glcpp-lex.l" +#line 174 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_UNDEF; @@ -1249,7 +1258,7 @@ YY_RULE_SETUP YY_BREAK case 21: YY_RULE_SETUP -#line 182 "glcpp/glcpp-lex.l" +#line 179 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH; @@ -1257,7 +1266,7 @@ YY_RULE_SETUP YY_BREAK case 22: YY_RULE_SETUP -#line 187 "glcpp/glcpp-lex.l" +#line 184 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; @@ -1265,7 +1274,7 @@ YY_RULE_SETUP YY_BREAK case 23: YY_RULE_SETUP -#line 192 "glcpp/glcpp-lex.l" +#line 189 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; @@ -1273,7 +1282,7 @@ YY_RULE_SETUP YY_BREAK case 24: YY_RULE_SETUP -#line 197 "glcpp/glcpp-lex.l" +#line 194 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; @@ -1281,77 +1290,77 @@ YY_RULE_SETUP YY_BREAK case 25: YY_RULE_SETUP -#line 202 "glcpp/glcpp-lex.l" +#line 199 "glcpp/glcpp-lex.l" { return LEFT_SHIFT; } YY_BREAK case 26: YY_RULE_SETUP -#line 206 "glcpp/glcpp-lex.l" +#line 203 "glcpp/glcpp-lex.l" { return RIGHT_SHIFT; } YY_BREAK case 27: YY_RULE_SETUP -#line 210 "glcpp/glcpp-lex.l" +#line 207 "glcpp/glcpp-lex.l" { return LESS_OR_EQUAL; } YY_BREAK case 28: YY_RULE_SETUP -#line 214 "glcpp/glcpp-lex.l" +#line 211 "glcpp/glcpp-lex.l" { return GREATER_OR_EQUAL; } YY_BREAK case 29: YY_RULE_SETUP -#line 218 "glcpp/glcpp-lex.l" +#line 215 "glcpp/glcpp-lex.l" { return EQUAL; } YY_BREAK case 30: YY_RULE_SETUP -#line 222 "glcpp/glcpp-lex.l" +#line 219 "glcpp/glcpp-lex.l" { return NOT_EQUAL; } YY_BREAK case 31: YY_RULE_SETUP -#line 226 "glcpp/glcpp-lex.l" +#line 223 "glcpp/glcpp-lex.l" { return AND; } YY_BREAK case 32: YY_RULE_SETUP -#line 230 "glcpp/glcpp-lex.l" +#line 227 "glcpp/glcpp-lex.l" { return OR; } YY_BREAK case 33: YY_RULE_SETUP -#line 234 "glcpp/glcpp-lex.l" +#line 231 "glcpp/glcpp-lex.l" { return PASTE; } YY_BREAK case 34: YY_RULE_SETUP -#line 238 "glcpp/glcpp-lex.l" +#line 235 "glcpp/glcpp-lex.l" { return DEFINED; } YY_BREAK case 35: YY_RULE_SETUP -#line 242 "glcpp/glcpp-lex.l" +#line 239 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return IDENTIFIER; @@ -1359,14 +1368,14 @@ YY_RULE_SETUP YY_BREAK case 36: YY_RULE_SETUP -#line 247 "glcpp/glcpp-lex.l" +#line 244 "glcpp/glcpp-lex.l" { return yytext[0]; } YY_BREAK case 37: YY_RULE_SETUP -#line 251 "glcpp/glcpp-lex.l" +#line 248 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return OTHER; @@ -1374,7 +1383,7 @@ YY_RULE_SETUP YY_BREAK case 38: YY_RULE_SETUP -#line 256 "glcpp/glcpp-lex.l" +#line 253 "glcpp/glcpp-lex.l" { if (yyextra->space_tokens) { return SPACE; @@ -1384,7 +1393,7 @@ YY_RULE_SETUP case 39: /* rule 39 can match eol */ YY_RULE_SETUP -#line 262 "glcpp/glcpp-lex.l" +#line 259 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 0; yylineno++; @@ -1394,7 +1403,7 @@ YY_RULE_SETUP YY_BREAK /* Handle missing newline at EOF. */ case YY_STATE_EOF(INITIAL): -#line 270 "glcpp/glcpp-lex.l" +#line 267 "glcpp/glcpp-lex.l" { BEGIN DONE; /* Don't keep matching this rule forever. */ yyextra->lexing_if = 0; @@ -1407,7 +1416,7 @@ case YY_STATE_EOF(INITIAL): warnings. */ case 40: YY_RULE_SETUP -#line 280 "glcpp/glcpp-lex.l" +#line 277 "glcpp/glcpp-lex.l" { unput('.'); yy_top_state(yyextra); @@ -1415,10 +1424,10 @@ YY_RULE_SETUP YY_BREAK case 41: YY_RULE_SETUP -#line 285 "glcpp/glcpp-lex.l" +#line 282 "glcpp/glcpp-lex.l" ECHO; YY_BREAK -#line 1422 "glcpp/glcpp-lex.c" +#line 1431 "glcpp/glcpp-lex.c" case YY_STATE_EOF(DONE): case YY_STATE_EOF(COMMENT): case YY_STATE_EOF(UNREACHABLE): @@ -1684,7 +1693,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) 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 >= 151 ) + if ( yy_current_state >= 150 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; @@ -1708,11 +1717,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner) 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 >= 151 ) + if ( yy_current_state >= 150 ) 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 == 150); + yy_is_jam = (yy_current_state == 149); if ( ! yy_is_jam ) *yyg->yy_state_ptr++ = yy_current_state; @@ -2157,8 +2166,8 @@ YY_BUFFER_STATE glcpp__scan_string (yyconst char * yystr , yyscan_t yyscanner) /** Setup the input buffer state to scan the given bytes. The next call to glcpp_lex() will * scan from a @e copy of @a bytes. - * @param bytes the byte buffer to scan - * @param len the number of bytes in the buffer pointed to by @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. * @param yyscanner The scanner object. * @return the newly allocated buffer state object. */ @@ -2612,7 +2621,7 @@ void glcpp_free (void * ptr , yyscan_t yyscanner) #define YYTABLES_NAME "yytables" -#line 285 "glcpp/glcpp-lex.l" +#line 282 "glcpp/glcpp-lex.l" -- cgit v1.2.3 From bd7853768dd7ad52604e3b636ae71dacaa7352fe Mon Sep 17 00:00:00 2001 From: Kenneth Graunke Date: Wed, 18 Aug 2010 17:38:24 -0700 Subject: glcpp: Refresh autogenerated lexer. --- src/glsl/glcpp/glcpp-lex.c | 589 +++++++++++++++++++++++++-------------------- 1 file changed, 326 insertions(+), 263 deletions(-) (limited to 'src/glsl/glcpp/glcpp-lex.c') diff --git a/src/glsl/glcpp/glcpp-lex.c b/src/glsl/glcpp/glcpp-lex.c index a0de91a634..1f0a77be8e 100644 --- a/src/glsl/glcpp/glcpp-lex.c +++ b/src/glsl/glcpp/glcpp-lex.c @@ -54,6 +54,7 @@ typedef int flex_int32_t; typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t; typedef unsigned int flex_uint32_t; +#endif /* ! C99 */ /* Limits of integral types. */ #ifndef INT8_MIN @@ -84,8 +85,6 @@ typedef unsigned int flex_uint32_t; #define UINT32_MAX (4294967295U) #endif -#endif /* ! C99 */ - #endif /* ! FLEXINT_H */ #ifdef __cplusplus @@ -159,15 +158,7 @@ typedef void* yyscan_t; /* Size of default input buffer. */ #ifndef YY_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k. - * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. - * Ditto for the __ia64__ case accordingly. - */ -#define YY_BUF_SIZE 32768 -#else #define YY_BUF_SIZE 16384 -#endif /* __ia64__ */ #endif /* The state buf must be large enough to hold one state per character in the main buffer. @@ -358,8 +349,8 @@ static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); *yy_cp = '\0'; \ yyg->yy_c_buf_p = yy_cp; -#define YY_NUM_RULES 41 -#define YY_END_OF_BUFFER 42 +#define YY_NUM_RULES 43 +#define YY_END_OF_BUFFER 44 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -367,26 +358,26 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static yyconst flex_int16_t yy_acclist[133] = +static yyconst flex_int16_t yy_acclist[137] = { 0, - 3, 3, 42, 37, 41, 38, 41, 39, 41, 41, - 36, 41, 41, 36, 41, 36, 41, 36, 41, 23, - 37, 41, 22, 37, 41, 36, 41, 36, 41, 36, - 41, 35, 37, 41, 35, 37, 41, 36, 41, 38, - 41, 21, 41, 41, 3, 41, 4, 41, 5, 41, - 40, 41, 37, 16, 38, 30, 33, 31, 2, 1, - 23, 37, 23, 37, 37, 22, 37, 22, 37, 25, - 27, 29, 28, 26, 35, 37, 35, 37, 32, 38, - 21, 21, 3, 4, 5, 6, 5, 7, 1, 24, - 37, 35, 37,16396, 24, 37, 35, 37, 16, 35, - - 37,16397,16398, 8204, 16, 8204, 35, 37, 8205, 16, - 8206, 16,16399, 17,16394, 20, 34, 35, 37, 19, - 8207, 16, 17, 8202, 16,16395,16402, 8203, 16, 9, - 8, 8210 + 3, 3, 44, 39, 43, 40, 43, 41, 43, 43, + 38, 43, 43, 38, 43, 38, 43, 38, 43, 25, + 39, 43, 24, 39, 43, 38, 43, 38, 43, 38, + 43, 37, 39, 43, 37, 39, 43, 38, 43, 40, + 43, 23, 43, 43, 3, 43, 4, 43, 5, 43, + 42, 43, 39, 18, 40, 32, 35, 33, 2, 1, + 25, 39, 25, 39, 39, 24, 39, 24, 39, 27, + 29, 31, 30, 28, 37, 39, 37, 39, 34, 40, + 23, 23, 3, 4, 5, 6, 5, 7, 1, 26, + 39, 37, 39,16398, 26, 39, 37, 39, 18, 37, + + 39,16399,16400, 8206, 18, 8206, 37, 39, 8207, 18, + 8208, 18,16401, 19,16396, 22, 36, 37, 39, 21, + 8209, 18, 19, 8204, 18,16397,16404, 8205, 18, 11, + 18, 9, 8, 8212, 10, 18 } ; -static yyconst flex_int16_t yy_accept[151] = +static yyconst flex_int16_t yy_accept[166] = { 0, 1, 1, 1, 1, 1, 2, 3, 3, 3, 4, 6, 8, 10, 11, 13, 14, 16, 18, 20, 23, @@ -394,16 +385,18 @@ static yyconst flex_int16_t yy_accept[151] = 47, 49, 51, 53, 54, 54, 55, 56, 57, 58, 59, 60, 61, 63, 65, 66, 68, 70, 71, 72, 73, 74, 75, 77, 79, 80, 81, 82, 83, 83, - 83, 83, 83, 83, 83, 84, 85, 86, 87, 88, - 89, 90, 92, 94, 94, 94, 94, 94, 94, 95, - 95, 95, 95, 97, 99, 99, 99, 99, 99, 99, - 99, 99, 100, 100, 100, 100, 100, 100, 102, 102, - - 103, 104, 104, 104, 104, 104, 106, 106, 107, 107, - 107, 107, 107, 107, 109, 109, 109, 111, 111, 113, - 114, 115, 115, 116, 116, 116, 117, 117, 120, 121, - 121, 123, 124, 124, 124, 126, 127, 127, 127, 128, - 128, 128, 130, 131, 132, 132, 132, 133, 133, 133 + 83, 83, 83, 83, 83, 83, 84, 85, 86, 87, + 88, 89, 90, 92, 94, 94, 94, 94, 94, 94, + 95, 95, 95, 95, 95, 97, 99, 99, 99, 99, + 99, 99, 99, 99, 100, 100, 100, 100, 100, 100, + + 100, 102, 102, 103, 104, 104, 104, 104, 104, 106, + 106, 107, 107, 107, 107, 107, 107, 107, 109, 109, + 109, 111, 111, 113, 114, 115, 115, 116, 116, 116, + 116, 117, 117, 120, 121, 121, 123, 124, 124, 124, + 126, 127, 127, 127, 127, 128, 128, 128, 130, 130, + 132, 132, 132, 133, 134, 134, 134, 134, 135, 135, + 135, 137, 137, 137, 137 } ; static yyconst flex_int32_t yy_ec[256] = @@ -446,51 +439,55 @@ static yyconst flex_int32_t yy_meta[40] = 1, 1, 1, 1, 1, 1, 1, 1, 1 } ; -static yyconst flex_int16_t yy_base[169] = +static yyconst flex_int16_t yy_base[184] = { 0, - 0, 38, 0, 0, 38, 39, 427, 426, 428, 48, - 43, 549, 424, 44, 63, 423, 59, 65, 87, 125, - 58, 67, 68, 164, 203, 40, 75, 241, 549, 422, - 549, 140, 549, 140, 421, 549, 144, 420, 419, 418, - 417, 415, 156, 179, 267, 0, 209, 414, 413, 412, - 411, 410, 388, 124, 408, 153, 404, 403, 154, 198, - 159, 155, 160, 192, 405, 549, 186, 549, 214, 549, - 404, 162, 159, 227, 229, 230, 234, 199, 303, 232, - 235, 236, 262, 56, 243, 237, 247, 245, 252, 291, - 359, 358, 292, 238, 296, 293, 254, 336, 256, 356, - - 355, 298, 294, 263, 354, 549, 352, 549, 299, 297, - 322, 325, 257, 306, 328, 350, 549, 346, 549, 345, - 344, 329, 343, 331, 332, 342, 333, 320, 335, 340, - 549, 337, 338, 248, 549, 246, 197, 336, 366, 403, - 184, 549, 182, 141, 434, 416, 79, 473, 549, 512, - 514, 516, 518, 520, 522, 71, 524, 526, 528, 530, - 532, 534, 536, 538, 540, 542, 544, 546 + 0, 38, 0, 0, 38, 39, 465, 464, 466, 48, + 43, 665, 462, 44, 63, 460, 59, 65, 87, 125, + 58, 67, 68, 164, 203, 40, 75, 241, 665, 459, + 665, 140, 665, 140, 458, 665, 144, 457, 456, 452, + 451, 450, 156, 179, 267, 0, 209, 449, 448, 447, + 446, 445, 381, 124, 401, 153, 397, 396, 154, 198, + 159, 155, 183, 160, 193, 398, 665, 222, 665, 227, + 665, 397, 204, 161, 231, 232, 238, 243, 236, 303, + 245, 180, 247, 249, 281, 56, 257, 271, 248, 259, + 252, 264, 396, 395, 297, 299, 312, 313, 320, 294, + + 373, 295, 393, 391, 321, 296, 324, 390, 665, 389, + 665, 327, 329, 195, 328, 331, 332, 230, 334, 388, + 665, 386, 665, 378, 372, 335, 367, 337, 347, 342, + 360, 340, 331, 255, 348, 665, 260, 338, 246, 665, + 197, 370, 192, 344, 406, 345, 186, 665, 364, 665, + 444, 377, 184, 141, 480, 365, 518, 79, 554, 383, + 665, 592, 385, 665, 628, 630, 632, 634, 636, 638, + 71, 640, 642, 644, 646, 648, 650, 652, 654, 656, + 658, 660, 662 } ; -static yyconst flex_int16_t yy_def[169] = +static yyconst flex_int16_t yy_def[184] = { 0, - 149, 1, 150, 150, 151, 151, 152, 152, 149, 153, - 154, 149, 154, 154, 154, 154, 154, 154, 149, 153, - 154, 154, 154, 155, 155, 154, 154, 154, 149, 156, - 149, 157, 149, 20, 154, 149, 154, 154, 154, 154, - 154, 158, 19, 20, 20, 20, 20, 154, 154, 154, - 154, 154, 25, 25, 154, 154, 28, 28, 154, 154, - 154, 154, 154, 154, 156, 149, 157, 149, 157, 149, - 158, 45, 25, 154, 154, 154, 154, 154, 154, 154, - 154, 154, 20, 25, 154, 154, 154, 154, 154, 154, - 159, 160, 154, 154, 154, 154, 154, 25, 154, 161, - - 162, 154, 154, 154, 159, 149, 160, 149, 154, 154, - 154, 154, 154, 25, 154, 161, 149, 162, 149, 163, - 164, 154, 165, 154, 154, 154, 154, 25, 154, 163, - 149, 164, 154, 165, 149, 166, 167, 154, 149, 154, - 166, 149, 167, 154, 168, 154, 154, 168, 0, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149 + 164, 1, 165, 165, 166, 166, 167, 167, 164, 168, + 169, 164, 169, 169, 169, 169, 169, 169, 164, 168, + 169, 169, 169, 170, 170, 169, 169, 169, 164, 171, + 164, 172, 164, 20, 169, 164, 169, 169, 169, 169, + 169, 173, 19, 20, 20, 20, 20, 169, 169, 169, + 169, 169, 25, 25, 169, 169, 28, 28, 169, 169, + 169, 169, 169, 169, 169, 171, 164, 172, 164, 172, + 164, 173, 45, 25, 169, 169, 169, 169, 169, 169, + 169, 169, 169, 169, 20, 25, 169, 169, 169, 169, + 169, 169, 174, 175, 169, 169, 169, 169, 169, 169, + + 25, 169, 176, 177, 169, 169, 169, 174, 164, 175, + 164, 169, 169, 169, 169, 169, 169, 25, 169, 176, + 164, 177, 164, 178, 179, 169, 180, 169, 169, 169, + 169, 169, 25, 169, 178, 164, 179, 169, 180, 164, + 181, 169, 182, 169, 164, 169, 181, 164, 169, 164, + 169, 169, 182, 169, 183, 169, 169, 169, 183, 169, + 164, 169, 169, 0, 164, 164, 164, 164, 164, 164, + 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, + 164, 164, 164 } ; -static yyconst flex_int16_t yy_nxt[589] = +static yyconst flex_int16_t yy_nxt[705] = { 0, 10, 11, 12, 13, 14, 15, 16, 17, 16, 16, 18, 19, 20, 20, 21, 22, 23, 24, 24, 24, @@ -499,66 +496,80 @@ static yyconst flex_int16_t yy_nxt[589] = 31, 31, 36, 28, 37, 36, 36, 32, 32, 35, 36, 35, 35, 35, 35, 35, 35, 35, 35, 38, 36, 36, 35, 35, 35, 36, 40, 36, 39, 36, - 36, 65, 48, 49, 41, 42, 56, 36, 55, 53, - 57, 36, 50, 51, 52, 98, 35, 34, 35, 36, + 36, 66, 48, 49, 41, 42, 56, 36, 55, 53, + 57, 36, 50, 51, 52, 101, 35, 34, 35, 36, 35, 35, 35, 35, 35, 35, 35, 35, 43, 43, 34, 35, 35, 35, 34, 34, 44, 45, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 44, 34, 45, 35, 35, 36, 35, 35, 35, 35, 35, 35, 35, 35, 46, 46, 46, 35, - 35, 35, 68, 36, 47, 37, 36, 53, 73, 69, - 70, 34, 34, 34, 56, 36, 36, 36, 57, 34, + 35, 35, 69, 36, 47, 37, 36, 53, 74, 70, + 71, 34, 34, 34, 56, 36, 36, 36, 57, 34, 47, 36, 36, 35, 34, 35, 36, 35, 35, 35, - 35, 35, 35, 35, 35, 34, 34, 74, 35, 35, - 35, 83, 53, 79, 36, 84, 142, 80, 68, 81, - 34, 34, 34, 34, 36, 149, 149, 83, 34, 36, - - 36, 36, 35, 34, 35, 36, 35, 35, 35, 35, - 35, 35, 35, 35, 34, 82, 68, 35, 35, 35, - 34, 34, 34, 69, 70, 75, 54, 76, 34, 36, - 77, 36, 36, 90, 36, 78, 36, 36, 36, 36, - 36, 35, 58, 36, 34, 36, 39, 36, 142, 36, - 135, 85, 88, 95, 36, 86, 36, 96, 36, 36, - 110, 100, 87, 59, 60, 36, 89, 61, 97, 99, - 101, 102, 62, 34, 34, 34, 63, 64, 72, 72, - 72, 34, 103, 127, 72, 115, 34, 113, 72, 72, - 72, 72, 122, 36, 36, 36, 36, 34, 36, 36, - - 36, 36, 34, 91, 91, 92, 91, 91, 91, 91, - 91, 91, 91, 91, 104, 109, 112, 91, 91, 91, - 124, 111, 120, 123, 36, 93, 121, 36, 128, 53, - 36, 36, 94, 36, 36, 36, 139, 36, 36, 36, - 36, 91, 131, 53, 36, 135, 36, 131, 119, 126, - 125, 129, 117, 137, 108, 136, 106, 119, 117, 114, - 108, 106, 133, 138, 140, 144, 35, 139, 36, 35, + 35, 35, 35, 35, 35, 34, 34, 75, 35, 35, + 35, 81, 36, 80, 53, 36, 36, 86, 148, 83, + 34, 34, 34, 34, 36, 36, 129, 36, 34, 148, + + 36, 98, 35, 34, 35, 36, 35, 35, 35, 35, + 35, 35, 35, 35, 34, 82, 84, 35, 35, 35, + 34, 34, 34, 85, 69, 76, 54, 77, 34, 69, + 78, 164, 164, 36, 36, 79, 70, 71, 36, 85, + 36, 35, 58, 36, 34, 36, 39, 36, 140, 36, + 36, 36, 133, 53, 36, 87, 145, 36, 88, 36, + 90, 36, 36, 59, 60, 89, 36, 61, 62, 99, + 92, 104, 63, 36, 97, 91, 64, 65, 73, 73, + 73, 100, 106, 102, 73, 105, 34, 107, 73, 73, + 73, 73, 34, 34, 34, 103, 36, 36, 36, 36, + + 34, 36, 34, 93, 93, 94, 93, 93, 93, 93, + 93, 93, 93, 93, 36, 36, 34, 93, 93, 93, + 112, 113, 36, 36, 119, 95, 36, 117, 125, 36, + 36, 36, 96, 36, 36, 114, 36, 36, 115, 36, + 36, 93, 36, 116, 36, 124, 36, 36, 129, 36, + 136, 127, 128, 126, 53, 131, 130, 134, 132, 142, + 142, 141, 36, 143, 146, 149, 150, 36, 138, 140, + 144, 149, 150, 154, 36, 156, 157, 157, 149, 150, + 136, 151, 151, 151, 160, 161, 160, 161, 123, 152, + 121, 111, 109, 123, 143, 121, 118, 111, 109, 36, + + 67, 35, 35, 36, 53, 152, 35, 145, 36, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, - 35, 35, 35, 145, 145, 145, 145, 145, 145, 145, - 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, - - 145, 145, 145, 145, 35, 36, 36, 66, 35, 35, - 36, 53, 36, 36, 36, 36, 36, 36, 36, 36, - 36, 36, 36, 36, 66, 36, 36, 149, 29, 29, - 149, 149, 149, 146, 35, 35, 36, 35, 35, 35, - 35, 35, 147, 35, 35, 137, 149, 149, 35, 35, - 35, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 35, 35, 35, 36, 35, 35, 35, 35, - 35, 147, 35, 35, 149, 149, 149, 35, 35, 35, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 35, 29, 29, 30, 30, 33, 33, 34, 34, - 35, 35, 53, 53, 67, 67, 71, 71, 105, 105, - 107, 107, 116, 116, 118, 118, 130, 130, 132, 132, - 134, 134, 141, 141, 143, 143, 148, 148, 9, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149 + 35, 35, 35, 155, 155, 155, 155, 155, 155, 155, + 155, 155, 155, 155, 155, 155, 155, 155, 155, 155, + 155, 155, 155, 155, 35, 149, 150, 36, 36, 36, + 36, 36, 36, 36, 36, 151, 151, 151, 36, 36, + 36, 67, 36, 152, 36, 164, 29, 29, 164, 164, + 164, 164, 164, 164, 164, 164, 164, 164, 164, 152, + 35, 35, 36, 35, 35, 35, 35, 35, 158, 35, + 35, 164, 164, 164, 35, 35, 35, 164, 164, 164, + + 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, + 164, 164, 164, 164, 164, 164, 164, 164, 35, 160, + 161, 164, 164, 164, 164, 164, 164, 164, 164, 162, + 162, 162, 164, 164, 164, 164, 164, 163, 164, 164, + 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, + 164, 164, 164, 163, 35, 35, 36, 35, 35, 35, + 35, 35, 158, 35, 35, 164, 164, 164, 35, 35, + 35, 164, 164, 164, 164, 164, 164, 164, 164, 164, + 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, + 164, 164, 35, 160, 161, 164, 164, 164, 164, 164, + + 164, 164, 164, 162, 162, 162, 164, 164, 164, 164, + 164, 163, 164, 164, 164, 164, 164, 164, 164, 164, + 164, 164, 164, 164, 164, 164, 164, 163, 29, 29, + 30, 30, 33, 33, 34, 34, 35, 35, 53, 53, + 68, 68, 72, 72, 108, 108, 110, 110, 120, 120, + 122, 122, 135, 135, 137, 137, 139, 139, 147, 147, + 153, 153, 159, 159, 9, 164, 164, 164, 164, 164, + 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, + 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, + 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, + + 164, 164, 164, 164 } ; -static yyconst flex_int16_t yy_chk[589] = +static yyconst flex_int16_t yy_chk[705] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -567,63 +578,77 @@ static yyconst flex_int16_t yy_chk[589] = 5, 6, 26, 2, 11, 11, 14, 5, 6, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 14, 21, 17, 10, 10, 10, 15, 17, 18, 15, 22, - 23, 156, 21, 21, 18, 18, 27, 27, 26, 84, - 27, 147, 22, 23, 23, 84, 10, 19, 19, 19, + 23, 171, 21, 21, 18, 18, 27, 27, 26, 86, + 27, 158, 22, 23, 23, 86, 10, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, - 20, 20, 32, 144, 20, 37, 37, 54, 54, 32, + 20, 20, 32, 154, 20, 37, 37, 54, 54, 32, 32, 34, 34, 34, 56, 56, 59, 62, 56, 34, - 20, 61, 63, 20, 24, 24, 24, 24, 24, 24, + 20, 61, 64, 20, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 34, 43, 59, 24, 24, - 24, 72, 73, 61, 143, 73, 141, 62, 67, 63, - 44, 44, 44, 43, 64, 67, 67, 72, 44, 137, - - 60, 78, 24, 25, 25, 25, 25, 25, 25, 25, - 25, 25, 25, 25, 44, 64, 69, 25, 25, 25, - 47, 47, 47, 69, 69, 60, 25, 60, 47, 74, - 60, 75, 76, 78, 80, 60, 77, 81, 82, 86, - 94, 25, 28, 28, 47, 85, 28, 88, 136, 87, - 134, 74, 76, 80, 89, 75, 97, 81, 99, 113, - 94, 86, 75, 28, 28, 104, 77, 28, 82, 85, - 87, 88, 28, 83, 83, 83, 28, 28, 45, 45, - 45, 83, 89, 113, 45, 99, 45, 97, 45, 45, - 45, 45, 104, 90, 93, 96, 103, 83, 95, 110, - - 102, 109, 45, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 90, 93, 96, 79, 79, 79, - 110, 95, 102, 109, 111, 79, 103, 112, 114, 114, - 115, 122, 79, 124, 125, 127, 129, 129, 138, 132, - 133, 79, 130, 128, 126, 123, 121, 120, 118, 112, - 111, 115, 116, 125, 107, 124, 105, 101, 100, 98, - 92, 91, 122, 127, 133, 138, 139, 139, 139, 139, - 139, 139, 139, 139, 139, 139, 139, 139, 139, 139, - 139, 139, 139, 139, 139, 139, 139, 139, 139, 139, - 139, 139, 139, 139, 139, 139, 139, 139, 139, 139, - - 139, 139, 139, 139, 139, 140, 71, 65, 58, 57, - 55, 53, 52, 51, 50, 49, 48, 42, 146, 41, - 40, 39, 38, 35, 30, 16, 13, 9, 8, 7, - 0, 0, 0, 140, 145, 145, 145, 145, 145, 145, - 145, 145, 145, 145, 145, 146, 0, 0, 145, 145, - 145, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 24, 62, 82, 61, 74, 63, 153, 74, 147, 64, + 44, 44, 44, 43, 143, 65, 114, 114, 44, 141, + + 60, 82, 24, 25, 25, 25, 25, 25, 25, 25, + 25, 25, 25, 25, 44, 63, 65, 25, 25, 25, + 47, 47, 47, 73, 68, 60, 25, 60, 47, 70, + 60, 68, 68, 75, 76, 60, 70, 70, 79, 73, + 77, 25, 28, 28, 47, 78, 28, 81, 139, 83, + 89, 84, 118, 118, 91, 75, 134, 134, 76, 87, + 77, 90, 137, 28, 28, 76, 92, 28, 28, 83, + 79, 89, 28, 88, 81, 78, 28, 28, 45, 45, + 45, 84, 91, 87, 45, 90, 45, 92, 45, 45, + 45, 45, 85, 85, 85, 88, 100, 102, 106, 95, + + 85, 96, 45, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 97, 98, 85, 80, 80, 80, + 95, 96, 99, 105, 102, 80, 107, 100, 106, 112, + 115, 113, 80, 116, 117, 97, 119, 126, 98, 128, + 138, 80, 132, 99, 130, 105, 144, 146, 129, 129, + 135, 112, 113, 107, 133, 116, 115, 119, 117, 129, + 129, 128, 131, 130, 138, 149, 149, 156, 126, 127, + 132, 142, 142, 144, 125, 146, 149, 149, 152, 152, + 124, 142, 142, 142, 160, 160, 163, 163, 122, 142, + 120, 110, 108, 104, 156, 103, 101, 94, 93, 72, + + 66, 58, 57, 55, 53, 142, 145, 145, 145, 145, + 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, + 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, + 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, + 145, 145, 145, 145, 145, 151, 151, 52, 51, 50, + 49, 48, 42, 41, 40, 151, 151, 151, 39, 38, + 35, 30, 16, 151, 13, 9, 8, 7, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 151, + 155, 155, 155, 155, 155, 155, 155, 155, 155, 155, + 155, 0, 0, 0, 155, 155, 155, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 145, 148, 148, 148, 148, 148, 148, 148, - 148, 148, 148, 148, 0, 0, 0, 148, 148, 148, + 0, 0, 0, 0, 0, 0, 0, 0, 155, 157, + 157, 0, 0, 0, 0, 0, 0, 0, 0, 157, + 157, 157, 0, 0, 0, 0, 0, 157, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - + 0, 0, 0, 157, 159, 159, 159, 159, 159, 159, + 159, 159, 159, 159, 159, 0, 0, 0, 159, 159, + 159, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 148, 150, 150, 151, 151, 152, 152, 153, 153, - 154, 154, 155, 155, 157, 157, 158, 158, 159, 159, - 160, 160, 161, 161, 162, 162, 163, 163, 164, 164, - 165, 165, 166, 166, 167, 167, 168, 168, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149 + 0, 0, 159, 162, 162, 0, 0, 0, 0, 0, + + 0, 0, 0, 162, 162, 162, 0, 0, 0, 0, + 0, 162, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 162, 165, 165, + 166, 166, 167, 167, 168, 168, 169, 169, 170, 170, + 172, 172, 173, 173, 174, 174, 175, 175, 176, 176, + 177, 177, 178, 178, 179, 179, 180, 180, 181, 181, + 182, 182, 183, 183, 164, 164, 164, 164, 164, 164, + 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, + 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, + 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, + + 164, 164, 164, 164 } ; #define YY_TRAILING_MASK 0x2000 @@ -690,7 +715,7 @@ void glcpp_set_column (int column_no , yyscan_t yyscanner); } while(0); #define YY_USER_INIT yylineno = 1; yycolumn = 1; -#line 694 "glcpp/glcpp-lex.c" +#line 719 "glcpp/glcpp-lex.c" #define INITIAL 0 #define DONE 1 @@ -837,12 +862,7 @@ static int input (yyscan_t yyscanner ); /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k */ -#define YY_READ_BUF_SIZE 16384 -#else #define YY_READ_BUF_SIZE 8192 -#endif /* __ia64__ */ #endif /* Copy whatever the last rule matched to the standard output. */ @@ -850,7 +870,7 @@ static int input (yyscan_t yyscanner ); /* 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 fwrite( yytext, yyleng, 1, yyout ) #endif /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, @@ -861,7 +881,7 @@ static int input (yyscan_t yyscanner ); if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ - size_t n; \ + int n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ @@ -953,7 +973,7 @@ YY_DECL /* Single-line comments */ -#line 957 "glcpp/glcpp-lex.c" +#line 977 "glcpp/glcpp-lex.c" yylval = yylval_param; @@ -1016,14 +1036,14 @@ yy_match: 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 >= 150 ) + if ( yy_current_state >= 165 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; *yyg->yy_state_ptr++ = yy_current_state; ++yy_cp; } - while ( yy_current_state != 149 ); + while ( yy_current_state != 164 ); yy_find_action: yy_current_state = *--yyg->yy_state_ptr; @@ -1138,58 +1158,101 @@ YY_RULE_SETUP } YY_BREAK case 10: -/* rule 10 can match eol */ +*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */ +yyg->yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP #line 103 "glcpp/glcpp-lex.l" { - yyextra->lexing_if = 1; - yyextra->space_tokens = 0; - return HASH_IFDEF; + /* Eat characters until the first digit is + * encountered + */ + char *ptr = yytext; + while (!isdigit(*ptr)) + ptr++; + + /* Subtract one from the line number because + * yylineno is zero-based instead of + * one-based. + */ + yylineno = strtol(ptr, &ptr, 0) - 1; + yylloc->source = strtol(ptr, NULL, 0); } YY_BREAK case 11: -/* rule 11 can match eol */ +*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */ +yyg->yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 109 "glcpp/glcpp-lex.l" +#line 119 "glcpp/glcpp-lex.l" { - yyextra->lexing_if = 1; - yyextra->space_tokens = 0; - return HASH_IFNDEF; + /* Eat characters until the first digit is + * encountered + */ + char *ptr = yytext; + while (!isdigit(*ptr)) + ptr++; + + /* Subtract one from the line number because + * yylineno is zero-based instead of + * one-based. + */ + yylineno = strtol(ptr, &ptr, 0) - 1; } YY_BREAK case 12: /* rule 12 can match eol */ YY_RULE_SETUP -#line 115 "glcpp/glcpp-lex.l" +#line 134 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; - return HASH_IF; + return HASH_IFDEF; } YY_BREAK case 13: /* rule 13 can match eol */ YY_RULE_SETUP -#line 121 "glcpp/glcpp-lex.l" +#line 140 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; - return HASH_ELIF; + return HASH_IFNDEF; } YY_BREAK case 14: /* rule 14 can match eol */ YY_RULE_SETUP -#line 127 "glcpp/glcpp-lex.l" +#line 146 "glcpp/glcpp-lex.l" { + yyextra->lexing_if = 1; yyextra->space_tokens = 0; - return HASH_ELSE; + return HASH_IF; } YY_BREAK case 15: /* rule 15 can match eol */ YY_RULE_SETUP -#line 132 "glcpp/glcpp-lex.l" +#line 152 "glcpp/glcpp-lex.l" +{ + yyextra->lexing_if = 1; + yyextra->space_tokens = 0; + return HASH_ELIF; +} + YY_BREAK +case 16: +/* rule 16 can match eol */ +YY_RULE_SETUP +#line 158 "glcpp/glcpp-lex.l" +{ + yyextra->space_tokens = 0; + return HASH_ELSE; +} + YY_BREAK +case 17: +/* rule 17 can match eol */ +YY_RULE_SETUP +#line 163 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_ENDIF; @@ -1203,13 +1266,13 @@ YY_RULE_SETUP * * We use the lexing_if flag to avoid skipping any part of an * if conditional expression. */ -case 16: -/* rule 16 can match eol */ +case 18: +/* rule 18 can match eol */ *yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */ yyg->yy_c_buf_p = yy_cp -= 1; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 145 "glcpp/glcpp-lex.l" +#line 176 "glcpp/glcpp-lex.l" { /* Since this rule always matches, YY_USER_ACTION gets called for it, * wrongly incrementing yycolumn. We undo that effect here. */ @@ -1222,9 +1285,9 @@ YY_RULE_SETUP } } YY_BREAK -case 17: +case 19: YY_RULE_SETUP -#line 157 "glcpp/glcpp-lex.l" +#line 188 "glcpp/glcpp-lex.l" { char *p; for (p = yytext; !isalpha(p[0]); p++); /* skip " # " */ @@ -1232,168 +1295,168 @@ YY_RULE_SETUP glcpp_error(yylloc, yyextra, "#error%s", p); } YY_BREAK -case 18: +case 20: YY_RULE_SETUP -#line 164 "glcpp/glcpp-lex.l" +#line 195 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_DEFINE_FUNC; } YY_BREAK -case 19: +case 21: YY_RULE_SETUP -#line 169 "glcpp/glcpp-lex.l" +#line 200 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_DEFINE_OBJ; } YY_BREAK -case 20: +case 22: YY_RULE_SETUP -#line 174 "glcpp/glcpp-lex.l" +#line 205 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_UNDEF; } YY_BREAK -case 21: +case 23: YY_RULE_SETUP -#line 179 "glcpp/glcpp-lex.l" +#line 210 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH; } YY_BREAK -case 22: +case 24: YY_RULE_SETUP -#line 184 "glcpp/glcpp-lex.l" +#line 215 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; } YY_BREAK -case 23: +case 25: YY_RULE_SETUP -#line 189 "glcpp/glcpp-lex.l" +#line 220 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; } YY_BREAK -case 24: +case 26: YY_RULE_SETUP -#line 194 "glcpp/glcpp-lex.l" +#line 225 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; } YY_BREAK -case 25: +case 27: YY_RULE_SETUP -#line 199 "glcpp/glcpp-lex.l" +#line 230 "glcpp/glcpp-lex.l" { return LEFT_SHIFT; } YY_BREAK -case 26: +case 28: YY_RULE_SETUP -#line 203 "glcpp/glcpp-lex.l" +#line 234 "glcpp/glcpp-lex.l" { return RIGHT_SHIFT; } YY_BREAK -case 27: +case 29: YY_RULE_SETUP -#line 207 "glcpp/glcpp-lex.l" +#line 238 "glcpp/glcpp-lex.l" { return LESS_OR_EQUAL; } YY_BREAK -case 28: +case 30: YY_RULE_SETUP -#line 211 "glcpp/glcpp-lex.l" +#line 242 "glcpp/glcpp-lex.l" { return GREATER_OR_EQUAL; } YY_BREAK -case 29: +case 31: YY_RULE_SETUP -#line 215 "glcpp/glcpp-lex.l" +#line 246 "glcpp/glcpp-lex.l" { return EQUAL; } YY_BREAK -case 30: +case 32: YY_RULE_SETUP -#line 219 "glcpp/glcpp-lex.l" +#line 250 "glcpp/glcpp-lex.l" { return NOT_EQUAL; } YY_BREAK -case 31: +case 33: YY_RULE_SETUP -#line 223 "glcpp/glcpp-lex.l" +#line 254 "glcpp/glcpp-lex.l" { return AND; } YY_BREAK -case 32: +case 34: YY_RULE_SETUP -#line 227 "glcpp/glcpp-lex.l" +#line 258 "glcpp/glcpp-lex.l" { return OR; } YY_BREAK -case 33: +case 35: YY_RULE_SETUP -#line 231 "glcpp/glcpp-lex.l" +#line 262 "glcpp/glcpp-lex.l" { return PASTE; } YY_BREAK -case 34: +case 36: YY_RULE_SETUP -#line 235 "glcpp/glcpp-lex.l" +#line 266 "glcpp/glcpp-lex.l" { return DEFINED; } YY_BREAK -case 35: +case 37: YY_RULE_SETUP -#line 239 "glcpp/glcpp-lex.l" +#line 270 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return IDENTIFIER; } YY_BREAK -case 36: +case 38: YY_RULE_SETUP -#line 244 "glcpp/glcpp-lex.l" +#line 275 "glcpp/glcpp-lex.l" { return yytext[0]; } YY_BREAK -case 37: +case 39: YY_RULE_SETUP -#line 248 "glcpp/glcpp-lex.l" +#line 279 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return OTHER; } YY_BREAK -case 38: +case 40: YY_RULE_SETUP -#line 253 "glcpp/glcpp-lex.l" +#line 284 "glcpp/glcpp-lex.l" { if (yyextra->space_tokens) { return SPACE; } } YY_BREAK -case 39: -/* rule 39 can match eol */ +case 41: +/* rule 41 can match eol */ YY_RULE_SETUP -#line 259 "glcpp/glcpp-lex.l" +#line 290 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 0; yylineno++; @@ -1403,7 +1466,7 @@ YY_RULE_SETUP YY_BREAK /* Handle missing newline at EOF. */ case YY_STATE_EOF(INITIAL): -#line 267 "glcpp/glcpp-lex.l" +#line 298 "glcpp/glcpp-lex.l" { BEGIN DONE; /* Don't keep matching this rule forever. */ yyextra->lexing_if = 0; @@ -1414,20 +1477,20 @@ case YY_STATE_EOF(INITIAL): only have this action here so that we can pretend to call some generated functions, (to avoid "defined but not used" warnings. */ -case 40: +case 42: YY_RULE_SETUP -#line 277 "glcpp/glcpp-lex.l" +#line 308 "glcpp/glcpp-lex.l" { unput('.'); yy_top_state(yyextra); } YY_BREAK -case 41: +case 43: YY_RULE_SETUP -#line 282 "glcpp/glcpp-lex.l" +#line 313 "glcpp/glcpp-lex.l" ECHO; YY_BREAK -#line 1431 "glcpp/glcpp-lex.c" +#line 1494 "glcpp/glcpp-lex.c" case YY_STATE_EOF(DONE): case YY_STATE_EOF(COMMENT): case YY_STATE_EOF(UNREACHABLE): @@ -1693,7 +1756,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) 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 >= 150 ) + if ( yy_current_state >= 165 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; @@ -1717,11 +1780,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner) 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 >= 150 ) + if ( yy_current_state >= 165 ) 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 == 149); + yy_is_jam = (yy_current_state == 164); if ( ! yy_is_jam ) *yyg->yy_state_ptr++ = yy_current_state; @@ -2166,8 +2229,8 @@ YY_BUFFER_STATE glcpp__scan_string (yyconst char * yystr , yyscan_t yyscanner) /** Setup the input buffer state to scan the given bytes. The next call to glcpp_lex() will * scan from a @e copy of @a bytes. - * @param yybytes the byte buffer to scan - * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * @param bytes the byte buffer to scan + * @param len the number of bytes in the buffer pointed to by @a bytes. * @param yyscanner The scanner object. * @return the newly allocated buffer state object. */ @@ -2621,7 +2684,7 @@ void glcpp_free (void * ptr , yyscan_t yyscanner) #define YYTABLES_NAME "yytables" -#line 282 "glcpp/glcpp-lex.l" +#line 313 "glcpp/glcpp-lex.l" -- cgit v1.2.3 From eab206510fc76407ee8b18aacafadd0d5406e483 Mon Sep 17 00:00:00 2001 From: Carl Worth Date: Mon, 23 Aug 2010 09:35:24 -0700 Subject: glcpp: Update generated glcpp-lex.c for the last two changes. This fixes both "#line 0" and "#line XXX YYY" as described in the two most recent commits. --- src/glsl/glcpp/glcpp-lex.c | 377 ++++++++++++++++++++++----------------------- 1 file changed, 186 insertions(+), 191 deletions(-) (limited to 'src/glsl/glcpp/glcpp-lex.c') diff --git a/src/glsl/glcpp/glcpp-lex.c b/src/glsl/glcpp/glcpp-lex.c index 1f0a77be8e..0f99ea1bbb 100644 --- a/src/glsl/glcpp/glcpp-lex.c +++ b/src/glsl/glcpp/glcpp-lex.c @@ -54,7 +54,6 @@ typedef int flex_int32_t; typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t; typedef unsigned int flex_uint32_t; -#endif /* ! C99 */ /* Limits of integral types. */ #ifndef INT8_MIN @@ -85,6 +84,8 @@ typedef unsigned int flex_uint32_t; #define UINT32_MAX (4294967295U) #endif +#endif /* ! C99 */ + #endif /* ! FLEXINT_H */ #ifdef __cplusplus @@ -158,7 +159,15 @@ typedef void* yyscan_t; /* Size of default input buffer. */ #ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else #define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ #endif /* The state buf must be large enough to hold one state per character in the main buffer. @@ -377,7 +386,7 @@ static yyconst flex_int16_t yy_acclist[137] = 18, 9, 8, 8212, 10, 18 } ; -static yyconst flex_int16_t yy_accept[166] = +static yyconst flex_int16_t yy_accept[164] = { 0, 1, 1, 1, 1, 1, 2, 3, 3, 3, 4, 6, 8, 10, 11, 13, 14, 16, 18, 20, 23, @@ -395,8 +404,8 @@ static yyconst flex_int16_t yy_accept[166] = 109, 111, 111, 113, 114, 115, 115, 116, 116, 116, 116, 117, 117, 120, 121, 121, 123, 124, 124, 124, 126, 127, 127, 127, 127, 128, 128, 128, 130, 130, - 132, 132, 132, 133, 134, 134, 134, 134, 135, 135, - 135, 137, 137, 137, 137 + 132, 132, 133, 134, 134, 134, 134, 135, 135, 135, + 137, 137, 137 } ; static yyconst flex_int32_t yy_ec[256] = @@ -439,55 +448,55 @@ static yyconst flex_int32_t yy_meta[40] = 1, 1, 1, 1, 1, 1, 1, 1, 1 } ; -static yyconst flex_int16_t yy_base[184] = +static yyconst flex_int16_t yy_base[182] = { 0, - 0, 38, 0, 0, 38, 39, 465, 464, 466, 48, - 43, 665, 462, 44, 63, 460, 59, 65, 87, 125, - 58, 67, 68, 164, 203, 40, 75, 241, 665, 459, - 665, 140, 665, 140, 458, 665, 144, 457, 456, 452, - 451, 450, 156, 179, 267, 0, 209, 449, 448, 447, - 446, 445, 381, 124, 401, 153, 397, 396, 154, 198, - 159, 155, 183, 160, 193, 398, 665, 222, 665, 227, - 665, 397, 204, 161, 231, 232, 238, 243, 236, 303, + 0, 38, 0, 0, 38, 39, 499, 498, 500, 48, + 43, 552, 496, 44, 63, 495, 59, 65, 87, 125, + 58, 67, 68, 164, 203, 40, 75, 241, 552, 494, + 552, 140, 552, 140, 493, 552, 144, 492, 491, 487, + 486, 485, 156, 179, 267, 0, 209, 472, 471, 470, + 469, 468, 446, 124, 466, 153, 462, 458, 154, 198, + 159, 155, 183, 160, 193, 460, 552, 222, 552, 227, + 552, 459, 204, 161, 231, 232, 238, 243, 236, 303, 245, 180, 247, 249, 281, 56, 257, 271, 248, 259, - 252, 264, 396, 395, 297, 299, 312, 313, 320, 294, - - 373, 295, 393, 391, 321, 296, 324, 390, 665, 389, - 665, 327, 329, 195, 328, 331, 332, 230, 334, 388, - 665, 386, 665, 378, 372, 335, 367, 337, 347, 342, - 360, 340, 331, 255, 348, 665, 260, 338, 246, 665, - 197, 370, 192, 344, 406, 345, 186, 665, 364, 665, - 444, 377, 184, 141, 480, 365, 518, 79, 554, 383, - 665, 592, 385, 665, 628, 630, 632, 634, 636, 638, - 71, 640, 642, 644, 646, 648, 650, 652, 654, 656, - 658, 660, 662 + 252, 264, 455, 454, 297, 299, 312, 313, 320, 294, + + 407, 295, 427, 426, 321, 296, 324, 425, 552, 424, + 552, 327, 329, 195, 328, 331, 332, 230, 334, 378, + 552, 377, 552, 371, 370, 335, 365, 337, 358, 342, + 360, 344, 326, 255, 340, 552, 260, 338, 246, 552, + 197, 364, 192, 352, 382, 348, 186, 552, 420, 552, + 423, 184, 141, 437, 421, 447, 79, 476, 346, 552, + 453, 552, 515, 517, 519, 521, 523, 525, 71, 527, + 529, 531, 533, 535, 537, 539, 541, 543, 545, 547, + 549 } ; -static yyconst flex_int16_t yy_def[184] = +static yyconst flex_int16_t yy_def[182] = { 0, - 164, 1, 165, 165, 166, 166, 167, 167, 164, 168, - 169, 164, 169, 169, 169, 169, 169, 169, 164, 168, - 169, 169, 169, 170, 170, 169, 169, 169, 164, 171, - 164, 172, 164, 20, 169, 164, 169, 169, 169, 169, - 169, 173, 19, 20, 20, 20, 20, 169, 169, 169, - 169, 169, 25, 25, 169, 169, 28, 28, 169, 169, - 169, 169, 169, 169, 169, 171, 164, 172, 164, 172, - 164, 173, 45, 25, 169, 169, 169, 169, 169, 169, - 169, 169, 169, 169, 20, 25, 169, 169, 169, 169, - 169, 169, 174, 175, 169, 169, 169, 169, 169, 169, - - 25, 169, 176, 177, 169, 169, 169, 174, 164, 175, - 164, 169, 169, 169, 169, 169, 169, 25, 169, 176, - 164, 177, 164, 178, 179, 169, 180, 169, 169, 169, - 169, 169, 25, 169, 178, 164, 179, 169, 180, 164, - 181, 169, 182, 169, 164, 169, 181, 164, 169, 164, - 169, 169, 182, 169, 183, 169, 169, 169, 183, 169, - 164, 169, 169, 0, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164 + 162, 1, 163, 163, 164, 164, 165, 165, 162, 166, + 167, 162, 167, 167, 167, 167, 167, 167, 162, 166, + 167, 167, 167, 168, 168, 167, 167, 167, 162, 169, + 162, 170, 162, 20, 167, 162, 167, 167, 167, 167, + 167, 171, 19, 20, 20, 20, 20, 167, 167, 167, + 167, 167, 25, 25, 167, 167, 28, 28, 167, 167, + 167, 167, 167, 167, 167, 169, 162, 170, 162, 170, + 162, 171, 45, 25, 167, 167, 167, 167, 167, 167, + 167, 167, 167, 167, 20, 25, 167, 167, 167, 167, + 167, 167, 172, 173, 167, 167, 167, 167, 167, 167, + + 25, 167, 174, 175, 167, 167, 167, 172, 162, 173, + 162, 167, 167, 167, 167, 167, 167, 25, 167, 174, + 162, 175, 162, 176, 177, 167, 178, 167, 167, 167, + 167, 167, 25, 167, 176, 162, 177, 167, 178, 162, + 179, 167, 180, 167, 162, 167, 179, 162, 167, 162, + 167, 180, 167, 181, 167, 167, 167, 181, 167, 162, + 167, 0, 162, 162, 162, 162, 162, 162, 162, 162, + 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, + 162 } ; -static yyconst flex_int16_t yy_nxt[705] = +static yyconst flex_int16_t yy_nxt[592] = { 0, 10, 11, 12, 13, 14, 15, 16, 17, 16, 16, 18, 19, 20, 20, 21, 22, 23, 24, 24, 24, @@ -514,7 +523,7 @@ static yyconst flex_int16_t yy_nxt[705] = 36, 98, 35, 34, 35, 36, 35, 35, 35, 35, 35, 35, 35, 35, 34, 82, 84, 35, 35, 35, 34, 34, 34, 85, 69, 76, 54, 77, 34, 69, - 78, 164, 164, 36, 36, 79, 70, 71, 36, 85, + 78, 162, 162, 36, 36, 79, 70, 71, 36, 85, 36, 35, 58, 36, 34, 36, 39, 36, 140, 36, 36, 36, 133, 53, 36, 87, 145, 36, 88, 36, 90, 36, 36, 59, 60, 89, 36, 61, 62, 99, @@ -526,50 +535,38 @@ static yyconst flex_int16_t yy_nxt[705] = 93, 93, 93, 93, 36, 36, 34, 93, 93, 93, 112, 113, 36, 36, 119, 95, 36, 117, 125, 36, 36, 36, 96, 36, 36, 114, 36, 36, 115, 36, - 36, 93, 36, 116, 36, 124, 36, 36, 129, 36, - 136, 127, 128, 126, 53, 131, 130, 134, 132, 142, - 142, 141, 36, 143, 146, 149, 150, 36, 138, 140, - 144, 149, 150, 154, 36, 156, 157, 157, 149, 150, - 136, 151, 151, 151, 160, 161, 160, 161, 123, 152, - 121, 111, 109, 123, 143, 121, 118, 111, 109, 36, - - 67, 35, 35, 36, 53, 152, 35, 145, 36, 35, - 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, - 35, 35, 35, 155, 155, 155, 155, 155, 155, 155, - 155, 155, 155, 155, 155, 155, 155, 155, 155, 155, - 155, 155, 155, 155, 35, 149, 150, 36, 36, 36, - 36, 36, 36, 36, 36, 151, 151, 151, 36, 36, - 36, 67, 36, 152, 36, 164, 29, 29, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 152, - 35, 35, 36, 35, 35, 35, 35, 35, 158, 35, - 35, 164, 164, 164, 35, 35, 35, 164, 164, 164, - - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 35, 160, - 161, 164, 164, 164, 164, 164, 164, 164, 164, 162, - 162, 162, 164, 164, 164, 164, 164, 163, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 163, 35, 35, 36, 35, 35, 35, - 35, 35, 158, 35, 35, 164, 164, 164, 35, 35, - 35, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 35, 160, 161, 164, 164, 164, 164, 164, - - 164, 164, 164, 162, 162, 162, 164, 164, 164, 164, - 164, 163, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 163, 29, 29, - 30, 30, 33, 33, 34, 34, 35, 35, 53, 53, - 68, 68, 72, 72, 108, 108, 110, 110, 120, 120, - 122, 122, 135, 135, 137, 137, 139, 139, 147, 147, - 153, 153, 159, 159, 9, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - - 164, 164, 164, 164 + 36, 93, 136, 116, 36, 124, 36, 159, 160, 53, + 36, 127, 128, 126, 36, 131, 130, 134, 132, 129, + 36, 141, 36, 143, 146, 149, 150, 140, 138, 142, + 142, 142, 36, 136, 144, 151, 151, 151, 155, 123, + 121, 153, 35, 145, 36, 35, 35, 35, 35, 35, + 35, 35, 35, 35, 35, 35, 35, 35, 35, 154, + + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, + 35, 149, 150, 36, 149, 150, 111, 109, 123, 121, + 118, 156, 156, 156, 151, 151, 151, 35, 35, 36, + 35, 35, 35, 35, 35, 157, 35, 35, 159, 160, + 143, 35, 35, 35, 159, 160, 111, 109, 161, 161, + 161, 36, 67, 35, 161, 161, 161, 35, 36, 53, + 36, 36, 36, 36, 36, 35, 35, 35, 36, 35, + 35, 35, 35, 35, 157, 35, 35, 36, 36, 36, + 35, 35, 35, 36, 36, 36, 67, 36, 36, 162, + + 29, 29, 162, 162, 162, 162, 162, 162, 162, 162, + 162, 162, 162, 162, 35, 29, 29, 30, 30, 33, + 33, 34, 34, 35, 35, 53, 53, 68, 68, 72, + 72, 108, 108, 110, 110, 120, 120, 122, 122, 135, + 135, 137, 137, 139, 139, 147, 147, 152, 152, 158, + 158, 9, 162, 162, 162, 162, 162, 162, 162, 162, + 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, + 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, + 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, + 162 + } ; -static yyconst flex_int16_t yy_chk[705] = +static yyconst flex_int16_t yy_chk[592] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -578,19 +575,19 @@ static yyconst flex_int16_t yy_chk[705] = 5, 6, 26, 2, 11, 11, 14, 5, 6, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 14, 21, 17, 10, 10, 10, 15, 17, 18, 15, 22, - 23, 171, 21, 21, 18, 18, 27, 27, 26, 86, - 27, 158, 22, 23, 23, 86, 10, 19, 19, 19, + 23, 169, 21, 21, 18, 18, 27, 27, 26, 86, + 27, 157, 22, 23, 23, 86, 10, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, - 20, 20, 32, 154, 20, 37, 37, 54, 54, 32, + 20, 20, 32, 153, 20, 37, 37, 54, 54, 32, 32, 34, 34, 34, 56, 56, 59, 62, 56, 34, 20, 61, 64, 20, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 34, 43, 59, 24, 24, - 24, 62, 82, 61, 74, 63, 153, 74, 147, 64, + 24, 62, 82, 61, 74, 63, 152, 74, 147, 64, 44, 44, 44, 43, 143, 65, 114, 114, 44, 141, 60, 82, 24, 25, 25, 25, 25, 25, 25, 25, @@ -608,47 +605,35 @@ static yyconst flex_int16_t yy_chk[705] = 80, 80, 80, 80, 97, 98, 85, 80, 80, 80, 95, 96, 99, 105, 102, 80, 107, 100, 106, 112, 115, 113, 80, 116, 117, 97, 119, 126, 98, 128, - 138, 80, 132, 99, 130, 105, 144, 146, 129, 129, - 135, 112, 113, 107, 133, 116, 115, 119, 117, 129, - 129, 128, 131, 130, 138, 149, 149, 156, 126, 127, - 132, 142, 142, 144, 125, 146, 149, 149, 152, 152, - 124, 142, 142, 142, 160, 160, 163, 163, 122, 142, - 120, 110, 108, 104, 156, 103, 101, 94, 93, 72, - - 66, 58, 57, 55, 53, 142, 145, 145, 145, 145, + 138, 80, 135, 99, 130, 105, 132, 159, 159, 133, + 146, 112, 113, 107, 144, 116, 115, 119, 117, 129, + 129, 128, 131, 130, 138, 142, 142, 127, 126, 129, + 129, 129, 125, 124, 132, 142, 142, 142, 146, 122, + 120, 144, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, + 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, - 145, 145, 145, 145, 145, 151, 151, 52, 51, 50, - 49, 48, 42, 41, 40, 151, 151, 151, 39, 38, - 35, 30, 16, 151, 13, 9, 8, 7, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 151, - 155, 155, 155, 155, 155, 155, 155, 155, 155, 155, - 155, 0, 0, 0, 155, 155, 155, 0, 0, 0, - - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 155, 157, - 157, 0, 0, 0, 0, 0, 0, 0, 0, 157, - 157, 157, 0, 0, 0, 0, 0, 157, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 157, 159, 159, 159, 159, 159, 159, - 159, 159, 159, 159, 159, 0, 0, 0, 159, 159, - 159, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 159, 162, 162, 0, 0, 0, 0, 0, - - 0, 0, 0, 162, 162, 162, 0, 0, 0, 0, - 0, 162, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 162, 165, 165, - 166, 166, 167, 167, 168, 168, 169, 169, 170, 170, - 172, 172, 173, 173, 174, 174, 175, 175, 176, 176, - 177, 177, 178, 178, 179, 179, 180, 180, 181, 181, - 182, 182, 183, 183, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, - - 164, 164, 164, 164 + 145, 149, 149, 155, 151, 151, 110, 108, 104, 103, + 101, 149, 149, 149, 151, 151, 151, 154, 154, 154, + 154, 154, 154, 154, 154, 154, 154, 154, 156, 156, + 155, 154, 154, 154, 161, 161, 94, 93, 156, 156, + 156, 72, 66, 58, 161, 161, 161, 57, 55, 53, + 52, 51, 50, 49, 48, 154, 158, 158, 158, 158, + 158, 158, 158, 158, 158, 158, 158, 42, 41, 40, + 158, 158, 158, 39, 38, 35, 30, 16, 13, 9, + + 8, 7, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 158, 163, 163, 164, 164, 165, + 165, 166, 166, 167, 167, 168, 168, 170, 170, 171, + 171, 172, 172, 173, 173, 174, 174, 175, 175, 176, + 176, 177, 177, 178, 178, 179, 179, 180, 180, 181, + 181, 162, 162, 162, 162, 162, 162, 162, 162, 162, + 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, + 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, + 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, + 162 + } ; #define YY_TRAILING_MASK 0x2000 @@ -708,14 +693,19 @@ void glcpp_set_column (int column_no , yyscan_t yyscanner); #define YY_USER_ACTION \ do { \ - yylloc->source = 0; \ yylloc->first_column = yycolumn + 1; \ yylloc->first_line = yylineno; \ yycolumn += yyleng; \ } while(0); -#define YY_USER_INIT yylineno = 1; yycolumn = 1; -#line 719 "glcpp/glcpp-lex.c" +#define YY_USER_INIT \ + do { \ + yylineno = 1; \ + yycolumn = 1; \ + yylloc->source = 0; \ + } while(0) + +#line 709 "glcpp/glcpp-lex.c" #define INITIAL 0 #define DONE 1 @@ -862,7 +852,12 @@ static int input (yyscan_t yyscanner ); /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else #define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ #endif /* Copy whatever the last rule matched to the standard output. */ @@ -870,7 +865,7 @@ static int input (yyscan_t yyscanner ); /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ -#define ECHO fwrite( yytext, yyleng, 1, yyout ) +#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) #endif /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, @@ -881,7 +876,7 @@ static int input (yyscan_t yyscanner ); if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ - int n; \ + size_t n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ @@ -969,11 +964,11 @@ YY_DECL register int yy_act; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; -#line 70 "glcpp/glcpp-lex.l" +#line 76 "glcpp/glcpp-lex.l" /* Single-line comments */ -#line 977 "glcpp/glcpp-lex.c" +#line 972 "glcpp/glcpp-lex.c" yylval = yylval_param; @@ -1036,14 +1031,14 @@ yy_match: 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 >= 165 ) + if ( yy_current_state >= 163 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; *yyg->yy_state_ptr++ = yy_current_state; ++yy_cp; } - while ( yy_current_state != 164 ); + while ( yy_current_state != 162 ); yy_find_action: yy_current_state = *--yyg->yy_state_ptr; @@ -1095,41 +1090,41 @@ do_action: /* This label is used only to access EOF actions. */ { /* beginning of action switch */ case 1: YY_RULE_SETUP -#line 73 "glcpp/glcpp-lex.l" +#line 79 "glcpp/glcpp-lex.l" { } YY_BREAK /* Multi-line comments */ case 2: YY_RULE_SETUP -#line 77 "glcpp/glcpp-lex.l" +#line 83 "glcpp/glcpp-lex.l" { yy_push_state(COMMENT, yyscanner); } YY_BREAK case 3: YY_RULE_SETUP -#line 78 "glcpp/glcpp-lex.l" +#line 84 "glcpp/glcpp-lex.l" YY_BREAK case 4: /* rule 4 can match eol */ YY_RULE_SETUP -#line 79 "glcpp/glcpp-lex.l" +#line 85 "glcpp/glcpp-lex.l" { yylineno++; yycolumn = 0; } YY_BREAK case 5: YY_RULE_SETUP -#line 80 "glcpp/glcpp-lex.l" +#line 86 "glcpp/glcpp-lex.l" YY_BREAK case 6: /* rule 6 can match eol */ YY_RULE_SETUP -#line 81 "glcpp/glcpp-lex.l" +#line 87 "glcpp/glcpp-lex.l" { yylineno++; yycolumn = 0; } YY_BREAK case 7: YY_RULE_SETUP -#line 82 "glcpp/glcpp-lex.l" +#line 88 "glcpp/glcpp-lex.l" { yy_pop_state(yyscanner); if (yyextra->space_tokens) @@ -1138,7 +1133,7 @@ YY_RULE_SETUP YY_BREAK case 8: YY_RULE_SETUP -#line 88 "glcpp/glcpp-lex.l" +#line 94 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); yyextra->space_tokens = 0; @@ -1149,7 +1144,7 @@ YY_RULE_SETUP * Simply pass them through to the main compiler's lexer/parser. */ case 9: YY_RULE_SETUP -#line 96 "glcpp/glcpp-lex.l" +#line 102 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); yylineno++; @@ -1162,7 +1157,7 @@ case 10: yyg->yy_c_buf_p = yy_cp -= 1; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 103 "glcpp/glcpp-lex.l" +#line 109 "glcpp/glcpp-lex.l" { /* Eat characters until the first digit is * encountered @@ -1184,7 +1179,7 @@ case 11: yyg->yy_c_buf_p = yy_cp -= 1; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 119 "glcpp/glcpp-lex.l" +#line 125 "glcpp/glcpp-lex.l" { /* Eat characters until the first digit is * encountered @@ -1203,7 +1198,7 @@ YY_RULE_SETUP case 12: /* rule 12 can match eol */ YY_RULE_SETUP -#line 134 "glcpp/glcpp-lex.l" +#line 140 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; @@ -1213,7 +1208,7 @@ YY_RULE_SETUP case 13: /* rule 13 can match eol */ YY_RULE_SETUP -#line 140 "glcpp/glcpp-lex.l" +#line 146 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; @@ -1223,7 +1218,7 @@ YY_RULE_SETUP case 14: /* rule 14 can match eol */ YY_RULE_SETUP -#line 146 "glcpp/glcpp-lex.l" +#line 152 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; @@ -1233,7 +1228,7 @@ YY_RULE_SETUP case 15: /* rule 15 can match eol */ YY_RULE_SETUP -#line 152 "glcpp/glcpp-lex.l" +#line 158 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 1; yyextra->space_tokens = 0; @@ -1243,7 +1238,7 @@ YY_RULE_SETUP case 16: /* rule 16 can match eol */ YY_RULE_SETUP -#line 158 "glcpp/glcpp-lex.l" +#line 164 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_ELSE; @@ -1252,7 +1247,7 @@ YY_RULE_SETUP case 17: /* rule 17 can match eol */ YY_RULE_SETUP -#line 163 "glcpp/glcpp-lex.l" +#line 169 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_ENDIF; @@ -1272,7 +1267,7 @@ case 18: yyg->yy_c_buf_p = yy_cp -= 1; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 176 "glcpp/glcpp-lex.l" +#line 182 "glcpp/glcpp-lex.l" { /* Since this rule always matches, YY_USER_ACTION gets called for it, * wrongly incrementing yycolumn. We undo that effect here. */ @@ -1287,7 +1282,7 @@ YY_RULE_SETUP YY_BREAK case 19: YY_RULE_SETUP -#line 188 "glcpp/glcpp-lex.l" +#line 194 "glcpp/glcpp-lex.l" { char *p; for (p = yytext; !isalpha(p[0]); p++); /* skip " # " */ @@ -1297,7 +1292,7 @@ YY_RULE_SETUP YY_BREAK case 20: YY_RULE_SETUP -#line 195 "glcpp/glcpp-lex.l" +#line 201 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_DEFINE_FUNC; @@ -1305,7 +1300,7 @@ YY_RULE_SETUP YY_BREAK case 21: YY_RULE_SETUP -#line 200 "glcpp/glcpp-lex.l" +#line 206 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_DEFINE_OBJ; @@ -1313,7 +1308,7 @@ YY_RULE_SETUP YY_BREAK case 22: YY_RULE_SETUP -#line 205 "glcpp/glcpp-lex.l" +#line 211 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH_UNDEF; @@ -1321,7 +1316,7 @@ YY_RULE_SETUP YY_BREAK case 23: YY_RULE_SETUP -#line 210 "glcpp/glcpp-lex.l" +#line 216 "glcpp/glcpp-lex.l" { yyextra->space_tokens = 0; return HASH; @@ -1329,7 +1324,7 @@ YY_RULE_SETUP YY_BREAK case 24: YY_RULE_SETUP -#line 215 "glcpp/glcpp-lex.l" +#line 221 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; @@ -1337,7 +1332,7 @@ YY_RULE_SETUP YY_BREAK case 25: YY_RULE_SETUP -#line 220 "glcpp/glcpp-lex.l" +#line 226 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; @@ -1345,7 +1340,7 @@ YY_RULE_SETUP YY_BREAK case 26: YY_RULE_SETUP -#line 225 "glcpp/glcpp-lex.l" +#line 231 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return INTEGER_STRING; @@ -1353,77 +1348,77 @@ YY_RULE_SETUP YY_BREAK case 27: YY_RULE_SETUP -#line 230 "glcpp/glcpp-lex.l" +#line 236 "glcpp/glcpp-lex.l" { return LEFT_SHIFT; } YY_BREAK case 28: YY_RULE_SETUP -#line 234 "glcpp/glcpp-lex.l" +#line 240 "glcpp/glcpp-lex.l" { return RIGHT_SHIFT; } YY_BREAK case 29: YY_RULE_SETUP -#line 238 "glcpp/glcpp-lex.l" +#line 244 "glcpp/glcpp-lex.l" { return LESS_OR_EQUAL; } YY_BREAK case 30: YY_RULE_SETUP -#line 242 "glcpp/glcpp-lex.l" +#line 248 "glcpp/glcpp-lex.l" { return GREATER_OR_EQUAL; } YY_BREAK case 31: YY_RULE_SETUP -#line 246 "glcpp/glcpp-lex.l" +#line 252 "glcpp/glcpp-lex.l" { return EQUAL; } YY_BREAK case 32: YY_RULE_SETUP -#line 250 "glcpp/glcpp-lex.l" +#line 256 "glcpp/glcpp-lex.l" { return NOT_EQUAL; } YY_BREAK case 33: YY_RULE_SETUP -#line 254 "glcpp/glcpp-lex.l" +#line 260 "glcpp/glcpp-lex.l" { return AND; } YY_BREAK case 34: YY_RULE_SETUP -#line 258 "glcpp/glcpp-lex.l" +#line 264 "glcpp/glcpp-lex.l" { return OR; } YY_BREAK case 35: YY_RULE_SETUP -#line 262 "glcpp/glcpp-lex.l" +#line 268 "glcpp/glcpp-lex.l" { return PASTE; } YY_BREAK case 36: YY_RULE_SETUP -#line 266 "glcpp/glcpp-lex.l" +#line 272 "glcpp/glcpp-lex.l" { return DEFINED; } YY_BREAK case 37: YY_RULE_SETUP -#line 270 "glcpp/glcpp-lex.l" +#line 276 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return IDENTIFIER; @@ -1431,14 +1426,14 @@ YY_RULE_SETUP YY_BREAK case 38: YY_RULE_SETUP -#line 275 "glcpp/glcpp-lex.l" +#line 281 "glcpp/glcpp-lex.l" { return yytext[0]; } YY_BREAK case 39: YY_RULE_SETUP -#line 279 "glcpp/glcpp-lex.l" +#line 285 "glcpp/glcpp-lex.l" { yylval->str = talloc_strdup (yyextra, yytext); return OTHER; @@ -1446,7 +1441,7 @@ YY_RULE_SETUP YY_BREAK case 40: YY_RULE_SETUP -#line 284 "glcpp/glcpp-lex.l" +#line 290 "glcpp/glcpp-lex.l" { if (yyextra->space_tokens) { return SPACE; @@ -1456,7 +1451,7 @@ YY_RULE_SETUP case 41: /* rule 41 can match eol */ YY_RULE_SETUP -#line 290 "glcpp/glcpp-lex.l" +#line 296 "glcpp/glcpp-lex.l" { yyextra->lexing_if = 0; yylineno++; @@ -1466,7 +1461,7 @@ YY_RULE_SETUP YY_BREAK /* Handle missing newline at EOF. */ case YY_STATE_EOF(INITIAL): -#line 298 "glcpp/glcpp-lex.l" +#line 304 "glcpp/glcpp-lex.l" { BEGIN DONE; /* Don't keep matching this rule forever. */ yyextra->lexing_if = 0; @@ -1479,7 +1474,7 @@ case YY_STATE_EOF(INITIAL): warnings. */ case 42: YY_RULE_SETUP -#line 308 "glcpp/glcpp-lex.l" +#line 314 "glcpp/glcpp-lex.l" { unput('.'); yy_top_state(yyextra); @@ -1487,10 +1482,10 @@ YY_RULE_SETUP YY_BREAK case 43: YY_RULE_SETUP -#line 313 "glcpp/glcpp-lex.l" +#line 319 "glcpp/glcpp-lex.l" ECHO; YY_BREAK -#line 1494 "glcpp/glcpp-lex.c" +#line 1489 "glcpp/glcpp-lex.c" case YY_STATE_EOF(DONE): case YY_STATE_EOF(COMMENT): case YY_STATE_EOF(UNREACHABLE): @@ -1756,7 +1751,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) 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 >= 165 ) + if ( yy_current_state >= 163 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; @@ -1780,11 +1775,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner) 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 >= 165 ) + if ( yy_current_state >= 163 ) 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 == 164); + yy_is_jam = (yy_current_state == 162); if ( ! yy_is_jam ) *yyg->yy_state_ptr++ = yy_current_state; @@ -2229,8 +2224,8 @@ YY_BUFFER_STATE glcpp__scan_string (yyconst char * yystr , yyscan_t yyscanner) /** Setup the input buffer state to scan the given bytes. The next call to glcpp_lex() will * scan from a @e copy of @a bytes. - * @param bytes the byte buffer to scan - * @param len the number of bytes in the buffer pointed to by @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. * @param yyscanner The scanner object. * @return the newly allocated buffer state object. */ @@ -2684,7 +2679,7 @@ void glcpp_free (void * ptr , yyscan_t yyscanner) #define YYTABLES_NAME "yytables" -#line 313 "glcpp/glcpp-lex.l" +#line 319 "glcpp/glcpp-lex.l" -- cgit v1.2.3