glslang_lex_autogen.cpp (161794B)
1 #line 17 "glslang.l" 2 // GENERATED FILE - DO NOT EDIT. 3 // Generated by generate_parser.py from glslang.l 4 // 5 // Copyright 2019 The ANGLE Project Authors. All rights reserved. 6 // Use of this source code is governed by a BSD-style license that can be 7 // found in the LICENSE file. 8 // 9 // glslang.l: 10 // Lexer for the OpenGL shading language. 11 12 // Ignore errors in auto-generated code. 13 #if defined(__GNUC__) 14 # pragma GCC diagnostic ignored "-Wswitch-enum" 15 # pragma GCC diagnostic ignored "-Wunused-function" 16 # pragma GCC diagnostic ignored "-Wunused-variable" 17 #elif defined(_MSC_VER) 18 # pragma warning(disable : 4005) 19 # pragma warning(disable : 4065) 20 # pragma warning(disable : 4189) 21 # pragma warning(disable : 4244) 22 # pragma warning(disable : 4505) 23 # pragma warning(disable : 4701) 24 # pragma warning(disable : 4702) 25 #endif 26 #if defined(__clang__) 27 # pragma clang diagnostic ignored "-Wimplicit-fallthrough" 28 # if defined(__APPLE__) 29 // Older clang versions don't have -Wextra-semi-stmt, and detecting Apple clang versions is 30 // difficult because they use different yet overlapping version numbers vs. regular clang. 31 # pragma clang diagnostic ignored "-Wunknown-warning-option" 32 # endif 33 // Flex isn't semi-colon clean. 34 # pragma clang diagnostic ignored "-Wextra-semi-stmt" 35 # pragma clang diagnostic ignored "-Wunreachable-code" 36 #endif 37 38 #define YY_INT_ALIGNED short int 39 40 /* A lexical scanner generated by flex */ 41 42 #define FLEX_SCANNER 43 #define YY_FLEX_MAJOR_VERSION 2 44 #define YY_FLEX_MINOR_VERSION 6 45 #define YY_FLEX_SUBMINOR_VERSION 4 46 #if YY_FLEX_SUBMINOR_VERSION > 0 47 # define FLEX_BETA 48 #endif 49 50 #ifdef yyget_lval 51 # define yyget_lval_ALREADY_DEFINED 52 #else 53 # define yyget_lval yyget_lval 54 #endif 55 56 #ifdef yyset_lval 57 # define yyset_lval_ALREADY_DEFINED 58 #else 59 # define yyset_lval yyset_lval 60 #endif 61 62 #ifdef yyget_lloc 63 # define yyget_lloc_ALREADY_DEFINED 64 #else 65 # define yyget_lloc yyget_lloc 66 #endif 67 68 #ifdef yyset_lloc 69 # define yyset_lloc_ALREADY_DEFINED 70 #else 71 # define yyset_lloc yyset_lloc 72 #endif 73 74 /* First, we deal with platform-specific or compiler-specific issues. */ 75 76 /* begin standard C headers. */ 77 #include <errno.h> 78 #include <stdio.h> 79 #include <stdlib.h> 80 #include <string.h> 81 82 /* end standard C headers. */ 83 84 /* flex integer type definitions */ 85 86 #ifndef FLEXINT_H 87 # define FLEXINT_H 88 89 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ 90 91 # if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 92 93 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, 94 * if you want the limit (max/min) macros for int types. 95 */ 96 # ifndef __STDC_LIMIT_MACROS 97 # define __STDC_LIMIT_MACROS 1 98 # endif 99 100 # include <inttypes.h> 101 typedef int8_t flex_int8_t; 102 typedef uint8_t flex_uint8_t; 103 typedef int16_t flex_int16_t; 104 typedef uint16_t flex_uint16_t; 105 typedef int32_t flex_int32_t; 106 typedef uint32_t flex_uint32_t; 107 # else 108 typedef signed char flex_int8_t; 109 typedef short int flex_int16_t; 110 typedef int flex_int32_t; 111 typedef unsigned char flex_uint8_t; 112 typedef unsigned short int flex_uint16_t; 113 typedef unsigned int flex_uint32_t; 114 115 /* Limits of integral types. */ 116 # ifndef INT8_MIN 117 # define INT8_MIN (-128) 118 # endif 119 # ifndef INT16_MIN 120 # define INT16_MIN (-32767 - 1) 121 # endif 122 # ifndef INT32_MIN 123 # define INT32_MIN (-2147483647 - 1) 124 # endif 125 # ifndef INT8_MAX 126 # define INT8_MAX (127) 127 # endif 128 # ifndef INT16_MAX 129 # define INT16_MAX (32767) 130 # endif 131 # ifndef INT32_MAX 132 # define INT32_MAX (2147483647) 133 # endif 134 # ifndef UINT8_MAX 135 # define UINT8_MAX (255U) 136 # endif 137 # ifndef UINT16_MAX 138 # define UINT16_MAX (65535U) 139 # endif 140 # ifndef UINT32_MAX 141 # define UINT32_MAX (4294967295U) 142 # endif 143 144 # ifndef SIZE_MAX 145 # define SIZE_MAX (~(size_t)0) 146 # endif 147 148 # endif /* ! C99 */ 149 150 #endif /* ! FLEXINT_H */ 151 152 /* begin standard C++ headers. */ 153 154 /* TODO: this is always defined, so inline it */ 155 #define yyconst const 156 157 #if defined(__GNUC__) && __GNUC__ >= 3 158 # define yynoreturn __attribute__((__noreturn__)) 159 #else 160 # define yynoreturn 161 #endif 162 163 /* Returned upon end-of-file. */ 164 #define YY_NULL 0 165 166 /* Promotes a possibly negative, possibly signed char to an 167 * integer in range [0..255] for use as an array index. 168 */ 169 #define YY_SC_TO_UI(c) ((YY_CHAR)(c)) 170 171 /* An opaque pointer. */ 172 #ifndef YY_TYPEDEF_YY_SCANNER_T 173 # define YY_TYPEDEF_YY_SCANNER_T 174 typedef void *yyscan_t; 175 #endif 176 177 /* For convenience, these vars (plus the bison vars far below) 178 are macros in the reentrant scanner. */ 179 #define yyin yyg->yyin_r 180 #define yyout yyg->yyout_r 181 #define yyextra yyg->yyextra_r 182 #define yyleng yyg->yyleng_r 183 #define yytext yyg->yytext_r 184 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) 185 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) 186 #define yy_flex_debug yyg->yy_flex_debug_r 187 188 /* Enter a start condition. This macro really ought to take a parameter, 189 * but we do it the disgusting crufty way forced on us by the ()-less 190 * definition of BEGIN. 191 */ 192 #define BEGIN yyg->yy_start = 1 + 2 * 193 /* Translate the current start state into a value that can be later handed 194 * to BEGIN to return to the state. The YYSTATE alias is for lex 195 * compatibility. 196 */ 197 #define YY_START ((yyg->yy_start - 1) / 2) 198 #define YYSTATE YY_START 199 /* Action number for EOF rule of a given start state. */ 200 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 201 /* Special action meaning "start processing a new file". */ 202 #define YY_NEW_FILE yyrestart(yyin, yyscanner) 203 #define YY_END_OF_BUFFER_CHAR 0 204 205 /* Size of default input buffer. */ 206 #ifndef YY_BUF_SIZE 207 # ifdef __ia64__ 208 /* On IA-64, the buffer size is 16k, not 8k. 209 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. 210 * Ditto for the __ia64__ case accordingly. 211 */ 212 # define YY_BUF_SIZE 32768 213 # else 214 # define YY_BUF_SIZE 16384 215 # endif /* __ia64__ */ 216 #endif 217 218 /* The state buf must be large enough to hold one state per character in the main buffer. 219 */ 220 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 221 222 #ifndef YY_TYPEDEF_YY_BUFFER_STATE 223 # define YY_TYPEDEF_YY_BUFFER_STATE 224 typedef struct yy_buffer_state *YY_BUFFER_STATE; 225 #endif 226 227 #ifndef YY_TYPEDEF_YY_SIZE_T 228 # define YY_TYPEDEF_YY_SIZE_T 229 typedef size_t yy_size_t; 230 #endif 231 232 #define EOB_ACT_CONTINUE_SCAN 0 233 #define EOB_ACT_END_OF_FILE 1 234 #define EOB_ACT_LAST_MATCH 2 235 236 /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires 237 * access to the local variable yy_act. Since yyless() is a macro, it would break 238 * existing scanners that call yyless() from OUTSIDE yylex. 239 * One obvious solution it to make yy_act a global. I tried that, and saw 240 * a 5% performance hit in a non-yylineno scanner, because yy_act is 241 * normally declared as a register variable-- so it is not worth it. 242 */ 243 #define YY_LESS_LINENO(n) \ 244 do \ 245 { \ 246 int yyl; \ 247 for (yyl = n; yyl < yyleng; ++yyl) \ 248 if (yytext[yyl] == '\n') \ 249 --yylineno; \ 250 } while (0) 251 #define YY_LINENO_REWIND_TO(dst) \ 252 do \ 253 { \ 254 const char *p; \ 255 for (p = yy_cp - 1; p >= (dst); --p) \ 256 if (*p == '\n') \ 257 --yylineno; \ 258 } while (0) 259 260 /* Return all but the first "n" matched characters back to the input stream. */ 261 #define yyless(n) \ 262 do \ 263 { \ 264 /* Undo effects of setting up yytext. */ \ 265 int yyless_macro_arg = (n); \ 266 YY_LESS_LINENO(yyless_macro_arg); \ 267 *yy_cp = yyg->yy_hold_char; \ 268 YY_RESTORE_YY_MORE_OFFSET \ 269 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 270 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 271 } while (0) 272 #define unput(c) yyunput(c, yyg->yytext_ptr, yyscanner) 273 274 #ifndef YY_STRUCT_YY_BUFFER_STATE 275 # define YY_STRUCT_YY_BUFFER_STATE 276 struct yy_buffer_state 277 { 278 FILE *yy_input_file; 279 280 char *yy_ch_buf; /* input buffer */ 281 char *yy_buf_pos; /* current position in input buffer */ 282 283 /* Size of input buffer in bytes, not including room for EOB 284 * characters. 285 */ 286 int yy_buf_size; 287 288 /* Number of characters read into yy_ch_buf, not including EOB 289 * characters. 290 */ 291 int yy_n_chars; 292 293 /* Whether we "own" the buffer - i.e., we know we created it, 294 * and can realloc() it to grow it, and should free() it to 295 * delete it. 296 */ 297 int yy_is_our_buffer; 298 299 /* Whether this is an "interactive" input source; if so, and 300 * if we're using stdio for input, then we want to use getc() 301 * instead of fread(), to make sure we stop fetching input after 302 * each newline. 303 */ 304 int yy_is_interactive; 305 306 /* Whether we're considered to be at the beginning of a line. 307 * If so, '^' rules will be active on the next match, otherwise 308 * not. 309 */ 310 int yy_at_bol; 311 312 int yy_bs_lineno; /**< The line count. */ 313 int yy_bs_column; /**< The column count. */ 314 315 /* Whether to try to fill the input buffer when we reach the 316 * end of it. 317 */ 318 int yy_fill_buffer; 319 320 int yy_buffer_status; 321 322 # define YY_BUFFER_NEW 0 323 # define YY_BUFFER_NORMAL 1 324 /* When an EOF's been seen but there's still some text to process 325 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 326 * shouldn't try reading from the input source any more. We might 327 * still have a bunch of tokens to match, though, because of 328 * possible backing-up. 329 * 330 * When we actually see the EOF, we change the status to "new" 331 * (via yyrestart()), so that the user can continue scanning by 332 * just pointing yyin at a new input file. 333 */ 334 # define YY_BUFFER_EOF_PENDING 2 335 }; 336 #endif /* !YY_STRUCT_YY_BUFFER_STATE */ 337 338 /* We provide macros for accessing buffer states in case in the 339 * future we want to put the buffer states in a more general 340 * "scanner state". 341 * 342 * Returns the top of the stack, or NULL. 343 */ 344 #define YY_CURRENT_BUFFER \ 345 (yyg->yy_buffer_stack ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] : NULL) 346 /* Same as previous macro, but useful when we know that the buffer stack is not 347 * NULL or when we need an lvalue. For internal use only. 348 */ 349 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] 350 351 void yyrestart(FILE *input_file, yyscan_t yyscanner); 352 void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer, yyscan_t yyscanner); 353 YY_BUFFER_STATE yy_create_buffer(FILE *file, int size, yyscan_t yyscanner); 354 void yy_delete_buffer(YY_BUFFER_STATE b, yyscan_t yyscanner); 355 void yy_flush_buffer(YY_BUFFER_STATE b, yyscan_t yyscanner); 356 void yypush_buffer_state(YY_BUFFER_STATE new_buffer, yyscan_t yyscanner); 357 void yypop_buffer_state(yyscan_t yyscanner); 358 359 static void yyensure_buffer_stack(yyscan_t yyscanner); 360 static void yy_load_buffer_state(yyscan_t yyscanner); 361 static void yy_init_buffer(YY_BUFFER_STATE b, FILE *file, yyscan_t yyscanner); 362 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER, yyscanner) 363 364 YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size, yyscan_t yyscanner); 365 YY_BUFFER_STATE yy_scan_string(const char *yy_str, yyscan_t yyscanner); 366 YY_BUFFER_STATE yy_scan_bytes(const char *bytes, int len, yyscan_t yyscanner); 367 368 void *yyalloc(yy_size_t, yyscan_t yyscanner); 369 void *yyrealloc(void *, yy_size_t, yyscan_t yyscanner); 370 void yyfree(void *, yyscan_t yyscanner); 371 372 #define yy_new_buffer yy_create_buffer 373 #define yy_set_interactive(is_interactive) \ 374 { \ 375 if (!YY_CURRENT_BUFFER) \ 376 { \ 377 yyensure_buffer_stack(yyscanner); \ 378 YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin, YY_BUF_SIZE, yyscanner); \ 379 } \ 380 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 381 } 382 #define yy_set_bol(at_bol) \ 383 { \ 384 if (!YY_CURRENT_BUFFER) \ 385 { \ 386 yyensure_buffer_stack(yyscanner); \ 387 YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin, YY_BUF_SIZE, yyscanner); \ 388 } \ 389 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 390 } 391 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 392 393 /* Begin user sect3 */ 394 395 #define yywrap(yyscanner) (/*CONSTCOND*/ 1) 396 #define YY_SKIP_YYWRAP 397 typedef flex_uint8_t YY_CHAR; 398 399 typedef int yy_state_type; 400 401 #define yytext_ptr yytext_r 402 403 static yy_state_type yy_get_previous_state(yyscan_t yyscanner); 404 static yy_state_type yy_try_NUL_trans(yy_state_type current_state, yyscan_t yyscanner); 405 static int yy_get_next_buffer(yyscan_t yyscanner); 406 static void yynoreturn yy_fatal_error(const char *msg, yyscan_t yyscanner); 407 408 /* Done after the current pattern has been matched and before the 409 * corresponding action - sets up yytext. 410 */ 411 #define YY_DO_BEFORE_ACTION \ 412 yyg->yytext_ptr = yy_bp; \ 413 yyleng = (int)(yy_cp - yy_bp); \ 414 yyg->yy_hold_char = *yy_cp; \ 415 *yy_cp = '\0'; \ 416 yyg->yy_c_buf_p = yy_cp; 417 #define YY_NUM_RULES 259 418 #define YY_END_OF_BUFFER 260 419 /* This struct is not used in this scanner, 420 but its presence is necessary. */ 421 struct yy_trans_info 422 { 423 flex_int32_t yy_verify; 424 flex_int32_t yy_nxt; 425 }; 426 static const flex_int16_t yy_accept[982] = { 427 0, 0, 0, 0, 0, 260, 258, 257, 257, 241, 247, 252, 236, 237, 245, 244, 233, 428 242, 240, 246, 199, 199, 234, 230, 248, 235, 249, 253, 196, 238, 239, 251, 196, 196, 429 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 430 196, 196, 196, 231, 250, 232, 243, 256, 255, 259, 254, 227, 213, 232, 221, 216, 211, 431 219, 209, 220, 210, 205, 212, 204, 198, 199, 0, 202, 0, 239, 231, 238, 228, 224, 432 226, 225, 229, 196, 217, 223, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 433 434 196, 196, 196, 196, 13, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 435 196, 16, 196, 196, 26, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 436 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 437 196, 196, 196, 196, 196, 196, 196, 196, 196, 218, 222, 254, 0, 208, 204, 0, 207, 438 201, 0, 203, 197, 214, 215, 196, 196, 156, 196, 196, 196, 196, 196, 196, 196, 196, 439 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 440 441 196, 14, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 31, 196, 196, 196, 196, 442 196, 196, 196, 196, 196, 196, 196, 196, 196, 27, 196, 196, 196, 196, 196, 196, 196, 443 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 444 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 0, 205, 0, 445 204, 206, 200, 196, 196, 196, 196, 34, 196, 196, 196, 19, 193, 196, 196, 196, 196, 446 196, 196, 196, 196, 196, 196, 17, 159, 196, 196, 196, 196, 22, 196, 196, 447 448 163, 174, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 171, 449 4, 39, 40, 41, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 450 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 162, 35, 196, 196, 451 32, 196, 196, 196, 196, 196, 196, 196, 196, 51, 52, 53, 33, 196, 196, 196, 196, 452 196, 196, 196, 196, 11, 196, 57, 58, 59, 196, 157, 196, 196, 7, 196, 196, 196, 453 196, 183, 184, 185, 196, 36, 196, 175, 30, 186, 187, 188, 2, 180, 181, 454 455 182, 196, 196, 196, 28, 178, 196, 196, 196, 196, 196, 196, 54, 55, 56, 196, 196, 456 196, 196, 196, 196, 196, 196, 196, 196, 196, 25, 196, 196, 196, 196, 196, 196, 196, 457 196, 196, 172, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 158, 196, 196, 458 196, 195, 60, 61, 62, 196, 196, 15, 196, 196, 196, 135, 196, 196, 9, 196, 196, 459 133, 196, 196, 196, 173, 168, 136, 196, 196, 196, 196, 196, 196, 164, 196, 196, 196, 460 196, 196, 196, 97, 42, 45, 47, 46, 43, 49, 48, 50, 44, 196, 196, 461 462 196, 196, 179, 155, 196, 196, 196, 166, 196, 196, 196, 38, 126, 29, 192, 23, 167, 463 96, 196, 177, 18, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 464 196, 196, 196, 196, 20, 37, 196, 196, 196, 196, 196, 196, 137, 102, 108, 196, 196, 465 196, 196, 196, 196, 99, 101, 3, 196, 196, 196, 196, 196, 127, 196, 196, 196, 196, 466 196, 196, 196, 160, 196, 196, 196, 196, 196, 8, 196, 196, 196, 10, 196, 196, 196, 467 196, 196, 196, 21, 122, 12, 169, 138, 103, 110, 196, 196, 196, 196, 196, 468 469 196, 196, 196, 196, 196, 196, 196, 196, 196, 165, 196, 196, 196, 196, 120, 131, 123, 470 196, 196, 196, 196, 196, 196, 196, 196, 161, 139, 104, 109, 196, 196, 176, 196, 196, 471 124, 196, 196, 196, 196, 6, 196, 196, 196, 196, 196, 196, 196, 196, 196, 113, 170, 472 1, 196, 196, 196, 196, 196, 196, 196, 194, 196, 134, 196, 5, 189, 63, 66, 196, 473 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 121, 196, 196, 474 196, 196, 196, 196, 111, 196, 196, 196, 196, 196, 196, 196, 149, 71, 72, 475 476 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 132, 477 196, 196, 196, 112, 196, 151, 76, 77, 196, 196, 196, 196, 125, 196, 196, 196, 196, 478 196, 196, 196, 196, 117, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 479 196, 196, 70, 196, 196, 196, 196, 64, 196, 196, 196, 196, 196, 196, 196, 196, 196, 480 196, 196, 196, 196, 196, 196, 196, 196, 118, 196, 140, 196, 105, 196, 196, 196, 196, 481 196, 75, 196, 196, 73, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 482 483 196, 196, 196, 196, 196, 196, 196, 119, 196, 196, 196, 196, 80, 196, 196, 78, 196, 484 196, 141, 106, 196, 196, 143, 196, 144, 196, 196, 196, 196, 196, 196, 196, 196, 196, 485 24, 196, 196, 196, 196, 196, 68, 196, 67, 89, 196, 196, 196, 196, 142, 107, 196, 486 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 114, 196, 196, 196, 196, 487 153, 92, 196, 196, 196, 147, 196, 69, 196, 196, 196, 196, 196, 196, 196, 196, 196, 488 196, 196, 196, 154, 94, 196, 196, 196, 115, 196, 196, 196, 150, 74, 196, 489 490 196, 196, 128, 196, 190, 196, 196, 196, 81, 196, 196, 196, 196, 116, 196, 152, 79, 491 196, 196, 196, 196, 196, 196, 129, 196, 196, 196, 196, 196, 85, 196, 88, 196, 196, 492 196, 130, 196, 196, 196, 196, 196, 196, 86, 91, 196, 196, 196, 196, 196, 82, 196, 493 95, 87, 93, 98, 196, 145, 146, 100, 196, 196, 196, 196, 65, 196, 196, 196, 191, 494 196, 196, 148, 83, 196, 196, 196, 196, 90, 196, 196, 84, 0}; 495 496 static const YY_CHAR yy_ec[256] = { 497 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 498 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 4, 1, 1, 1, 5, 6, 1, 7, 8, 499 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 500 30, 1, 31, 32, 33, 34, 35, 36, 37, 38, 38, 38, 38, 39, 40, 41, 42, 38, 38, 43, 44, 501 45, 46, 47, 48, 49, 50, 38, 51, 1, 52, 53, 54, 1, 55, 56, 57, 58, 502 503 59, 60, 61, 62, 63, 38, 64, 65, 66, 67, 68, 69, 38, 70, 71, 72, 73, 74, 75, 76, 77, 504 78, 79, 80, 81, 82, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 505 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 506 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 507 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 508 509 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 510 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 511 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; 512 513 static const YY_CHAR yy_meta[83] = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 3, 3, 3, 3, 3, 3, 514 3, 3, 3, 3, 1, 1, 1, 1, 1, 1, 4, 4, 4, 4, 3, 5, 6, 6, 6, 6, 6, 515 6, 6, 6, 6, 7, 6, 6, 6, 6, 1, 1, 1, 6, 4, 4, 4, 4, 3, 5, 6, 6, 516 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 1, 1, 1, 1}; 517 518 static const flex_int16_t yy_base[988] = { 519 0, 0, 0, 82, 0, 1237, 1238, 1238, 1238, 1208, 137, 161, 1238, 1238, 1207, 520 158, 1238, 157, 155, 1206, 177, 168, 1204, 1238, 177, 1204, 155, 1238, 0, 1238, 521 1238, 160, 1177, 149, 160, 170, 148, 143, 177, 1162, 184, 194, 163, 132, 169, 522 1156, 189, 1169, 209, 208, 220, 218, 147, 1154, 1238, 215, 1238, 1238, 1238, 1238, 523 1238, 0, 1238, 1238, 1238, 1238, 1238, 1238, 1238, 1238, 1238, 1238, 220, 1238, 257, 524 250, 263, 322, 1238, 0, 1238, 1238, 1238, 1198, 1238, 1238, 1238, 1197, 0, 1238, 525 1238, 1153, 1151, 1156, 229, 1153, 1161, 1159, 1159, 1146, 1149, 526 527 1160, 238, 1154, 1142, 1139, 1152, 1139, 1136, 1136, 1142, 237, 235, 1136, 1146, 1132, 528 1138, 1141, 1142, 0, 1134, 1144, 246, 1135, 1142, 1123, 1136, 1117, 252, 1121, 1134, 529 1125, 243, 1118, 278, 1113, 1129, 1131, 253, 1120, 292, 1107, 1116, 294, 296, 1120, 530 1116, 1118, 1107, 1110, 182, 258, 1115, 296, 1118, 1106, 1118, 265, 1111, 1110, 1098, 531 1238, 1238, 0, 351, 1238, 318, 369, 1238, 1238, 379, 389, 285, 1238, 1238, 1116, 532 1107, 0, 1103, 1098, 1102, 1111, 1105, 1107, 355, 1091, 1091, 1102, 1094, 284, 1104, 533 1101, 1101, 1099, 1096, 1088, 1094, 1081, 1079, 1091, 1077, 534 535 1093, 0, 1090, 1078, 1085, 1082, 1086, 1087, 1080, 1077, 1066, 1065, 1078, 1081, 1059, 536 1068, 1079, 1075, 1063, 1069, 1060, 398, 1065, 1068, 1059, 1066, 1055, 1059, 1050, 1064, 537 1061, 1062, 1053, 1059, 308, 1043, 1046, 1044, 1043, 1053, 1043, 1038, 1036, 1038, 1048, 538 1034, 1036, 1033, 1044, 1043, 1046, 1028, 358, 1036, 1022, 1031, 1029, 1038, 1017, 402, 539 1035, 1037, 1026, 1018, 1056, 413, 423, 445, 455, 1238, 1238, 1022, 1013, 1023, 1022, 540 0, 1020, 1024, 405, 0, 0, 1012, 1010, 1010, 1011, 1006, 1014, 1003, 1020, 1009, 541 433, 0, 0, 1003, 1013, 1012, 1012, 0, 997, 436, 542 543 0, 0, 999, 439, 1006, 1007, 998, 992, 991, 992, 991, 1001, 990, 361, 463, 544 985, 0, 0, 981, 980, 979, 981, 982, 987, 981, 977, 990, 985, 985, 981, 545 982, 981, 975, 969, 971, 970, 974, 979, 965, 968, 963, 971, 976, 964, 961, 546 973, 964, 0, 0, 970, 966, 0, 958, 958, 963, 964, 953, 960, 467, 957, 547 0, 0, 0, 0, 947, 959, 958, 945, 946, 955, 956, 956, 0, 941, 0, 548 0, 0, 942, 0, 950, 941, 0, 940, 941, 935, 945, 0, 0, 0, 936, 549 0, 932, 0, 0, 0, 0, 0, 0, 0, 0, 550 551 0, 942, 471, 941, 0, 0, 939, 935, 932, 931, 980, 979, 0, 0, 0, 552 921, 475, 478, 481, 926, 922, 927, 918, 916, 929, 914, 0, 946, 913, 926, 553 915, 911, 917, 912, 919, 919, 0, 916, 913, 917, 901, 899, 902, 908, 914, 554 909, 908, 896, 0, 898, 899, 898, 0, 0, 0, 0, 895, 898, 0, 892, 555 902, 893, 0, 903, 883, 0, 892, 887, 0, 880, 880, 893, 0, 895, 0, 556 489, 915, 914, 913, 873, 872, 0, 889, 888, 903, 882, 924, 915, 0, 0, 557 0, 0, 0, 0, 0, 0, 0, 0, 869, 882, 558 559 869, 866, 0, 0, 871, 865, 449, 0, 867, 874, 873, 0, 859, 0, 0, 560 0, 0, 0, 856, 0, 0, 855, 866, 493, 859, 865, 884, 863, 860, 855, 561 852, 874, 858, 843, 843, 856, 841, 853, 0, 0, 846, 876, 875, 874, 834, 562 833, 470, 485, 0, 845, 848, 846, 835, 833, 830, 845, 0, 0, 841, 838, 563 837, 827, 837, 0, 825, 815, 832, 818, 501, 826, 829, 0, 853, 852, 851, 564 811, 810, 0, 824, 813, 810, 0, 820, 813, 805, 806, 812, 815, 0, 0, 565 0, 0, 842, 841, 0, 811, 814, 799, 806, 797, 566 567 804, 805, 805, 804, 790, 804, 514, 800, 800, 0, 801, 790, 801, 788, 0, 568 0, 0, 820, 819, 818, 778, 777, 773, 785, 780, 0, 815, 814, 0, 784, 569 787, 0, 785, 521, 0, 764, 785, 804, 771, 0, 767, 766, 775, 775, 763, 570 777, 761, 775, 770, 797, 0, 0, 772, 792, 791, 790, 750, 749, 748, 0, 571 748, 0, 754, 0, 496, 512, 775, 757, 760, 743, 756, 754, 742, 741, 750, 572 750, 753, 773, 772, 771, 731, 730, 0, 735, 725, 728, 729, 728, 738, 765, 573 740, 736, 738, 734, 721, 720, 724, 757, 518, 0, 574 575 727, 730, 720, 721, 752, 712, 719, 710, 735, 719, 715, 717, 715, 715, 714, 576 713, 0, 701, 700, 710, 737, 702, 735, 519, 0, 705, 708, 705, 690, 0, 577 706, 705, 689, 688, 680, 688, 678, 686, 0, 683, 721, 681, 680, 705, 689, 578 687, 687, 680, 670, 698, 666, 668, 652, 690, 123, 160, 189, 210, 497, 204, 579 220, 252, 255, 263, 287, 331, 378, 420, 458, 454, 460, 464, 469, 476, 465, 580 467, 0, 475, 507, 482, 516, 488, 509, 524, 496, 497, 537, 512, 511, 540, 581 518, 514, 537, 520, 518, 522, 508, 507, 522, 509, 582 583 512, 513, 522, 518, 538, 510, 511, 0, 519, 549, 521, 522, 562, 537, 536, 584 565, 527, 528, 0, 0, 544, 538, 0, 539, 0, 525, 566, 549, 550, 536, 585 535, 538, 539, 540, 0, 572, 535, 545, 537, 545, 572, 549, 0, 0, 548, 586 564, 565, 586, 0, 0, 567, 586, 569, 570, 556, 555, 558, 559, 572, 564, 587 555, 578, 579, 0, 596, 559, 560, 568, 0, 0, 569, 585, 606, 598, 568, 588 600, 590, 584, 572, 593, 591, 585, 619, 575, 614, 577, 578, 586, 0, 0, 589 587, 623, 604, 0, 602, 603, 627, 0, 0, 608, 590 591 609, 598, 0, 604, 0, 605, 591, 614, 0, 593, 603, 630, 636, 0, 639, 592 0, 0, 620, 621, 628, 613, 611, 612, 0, 604, 605, 622, 629, 630, 0, 593 628, 643, 613, 654, 651, 0, 614, 615, 648, 677, 620, 621, 0, 0, 638, 594 640, 641, 632, 639, 0, 658, 0, 0, 0, 0, 669, 0, 0, 0, 636, 595 637, 631, 652, 0, 658, 634, 635, 0, 653, 695, 0, 0, 645, 664, 640, 596 681, 0, 668, 673, 0, 1238, 717, 722, 727, 732, 735, 738}; 597 598 static const flex_int16_t yy_def[988] = { 599 0, 981, 1, 981, 3, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 600 981, 981, 981, 982, 981, 981, 981, 981, 981, 981, 983, 981, 981, 981, 983, 983, 983, 983, 601 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 602 981, 981, 981, 981, 981, 981, 981, 984, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 603 985, 981, 986, 20, 982, 981, 981, 987, 981, 981, 981, 981, 981, 981, 981, 981, 983, 981, 604 981, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 605 606 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 607 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 608 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 609 983, 983, 983, 983, 983, 983, 981, 981, 984, 981, 981, 986, 981, 981, 981, 981, 981, 987, 610 981, 981, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 611 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 612 613 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 614 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 615 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 616 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 981, 981, 981, 981, 981, 981, 983, 617 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 618 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 619 620 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 621 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 622 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 623 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 624 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 625 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 626 627 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 628 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 629 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 630 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 631 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 632 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 633 634 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 635 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 636 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 637 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 638 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 639 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 640 641 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 642 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 643 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 644 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 645 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 646 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 647 648 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 649 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 650 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 651 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 652 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 653 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 654 655 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 656 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 657 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 658 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 659 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 660 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 661 662 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 663 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 664 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 665 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 983, 666 983, 983, 983, 983, 983, 983, 983, 983, 0, 981, 981, 981, 981, 981, 981}; 667 668 static const flex_int16_t yy_nxt[1321] = { 669 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 670 21, 21, 21, 21, 21, 21, 21, 21, 22, 23, 24, 25, 26, 27, 28, 28, 28, 671 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 672 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 28, 42, 43, 44, 673 45, 46, 47, 48, 49, 50, 51, 52, 28, 53, 28, 54, 55, 56, 57, 58, 59, 674 60, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 675 676 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 61, 61, 61, 61, 61, 677 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 58, 58, 678 58, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 679 61, 61, 61, 61, 61, 61, 61, 61, 61, 58, 58, 58, 58, 63, 64, 65, 68, 680 70, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 798, 74, 81, 86, 87, 71, 681 69, 129, 89, 66, 74, 130, 75, 75, 75, 75, 75, 75, 75, 75, 76, 682 683 76, 82, 77, 83, 84, 92, 103, 107, 158, 108, 104, 77, 90, 78, 799, 105, 159, 684 127, 109, 93, 94, 106, 78, 131, 99, 79, 77, 95, 100, 96, 128, 110, 97, 98, 685 101, 77, 132, 102, 116, 111, 78, 112, 161, 134, 113, 800, 117, 251, 252, 78, 114, 686 135, 79, 119, 164, 165, 120, 118, 136, 121, 122, 137, 123, 139, 124, 125, 146, 126, 687 801, 147, 140, 141, 155, 804, 142, 74, 156, 148, 164, 165, 143, 144, 150, 145, 149, 688 157, 151, 805, 152, 200, 153, 167, 168, 154, 162, 169, 178, 77, 981, 187, 689 690 179, 198, 201, 188, 189, 225, 806, 234, 78, 807, 210, 226, 199, 211, 212, 167, 168, 691 213, 220, 214, 253, 77, 169, 235, 236, 981, 221, 261, 254, 262, 271, 170, 808, 170, 692 228, 78, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 238, 229, 242, 230, 256, 693 244, 167, 168, 286, 287, 809, 271, 257, 239, 266, 810, 266, 243, 245, 267, 267, 267, 694 267, 267, 267, 267, 267, 267, 267, 334, 167, 168, 268, 335, 268, 411, 412, 269, 269, 695 269, 269, 269, 269, 269, 269, 269, 269, 171, 171, 171, 171, 171, 171, 171, 696 697 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 280, 319, 320, 321, 698 353, 361, 362, 363, 375, 376, 377, 270, 354, 281, 267, 267, 267, 267, 267, 267, 267, 699 267, 267, 267, 267, 267, 267, 267, 267, 267, 267, 267, 267, 267, 811, 270, 387, 388, 700 389, 395, 396, 397, 399, 400, 401, 165, 269, 269, 269, 269, 269, 269, 269, 269, 269, 701 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 413, 414, 415, 165, 454, 455, 702 456, 477, 478, 479, 812, 168, 490, 491, 492, 493, 494, 495, 496, 497, 498, 703 704 598, 813, 480, 481, 542, 543, 544, 564, 573, 574, 575, 565, 814, 599, 168, 600, 618, 705 619, 620, 815, 545, 546, 816, 817, 576, 577, 706, 802, 601, 654, 655, 656, 621, 622, 706 818, 623, 678, 679, 680, 707, 803, 819, 708, 820, 821, 657, 658, 624, 743, 768, 822, 707 709, 681, 682, 710, 711, 823, 744, 769, 824, 745, 770, 825, 826, 827, 828, 829, 830, 708 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 709 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 710 711 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 712 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, 896, 713 897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 910, 911, 912, 913, 714 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 930, 715 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 716 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 717 718 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 719 980, 76, 76, 797, 796, 795, 76, 88, 88, 88, 88, 88, 163, 163, 163, 163, 163, 720 72, 794, 72, 166, 793, 166, 172, 172, 172, 792, 791, 790, 789, 788, 787, 786, 785, 721 784, 783, 782, 781, 780, 779, 778, 777, 776, 775, 774, 773, 772, 771, 767, 766, 765, 722 764, 763, 762, 761, 760, 759, 758, 757, 756, 755, 754, 753, 752, 751, 750, 749, 748, 723 747, 746, 742, 741, 740, 739, 738, 737, 736, 735, 734, 733, 732, 731, 730, 724 725 729, 728, 727, 726, 725, 724, 723, 722, 721, 720, 719, 718, 717, 716, 715, 714, 713, 726 712, 705, 704, 703, 702, 701, 700, 699, 698, 697, 696, 695, 694, 693, 692, 691, 690, 727 689, 688, 687, 686, 685, 684, 683, 677, 676, 675, 674, 673, 672, 671, 670, 669, 668, 728 667, 666, 665, 664, 663, 662, 661, 660, 659, 653, 652, 651, 650, 649, 648, 647, 646, 729 645, 644, 643, 642, 641, 640, 639, 638, 637, 636, 635, 634, 633, 632, 631, 630, 629, 730 628, 627, 626, 625, 617, 616, 615, 614, 613, 612, 611, 610, 609, 608, 607, 731 732 606, 605, 604, 603, 602, 597, 596, 595, 594, 593, 592, 591, 590, 589, 588, 587, 586, 733 585, 584, 583, 582, 581, 580, 579, 578, 572, 571, 570, 569, 568, 567, 566, 563, 562, 734 561, 560, 559, 558, 557, 556, 555, 554, 553, 552, 551, 550, 549, 548, 547, 541, 540, 735 539, 538, 537, 536, 535, 534, 533, 532, 531, 530, 529, 528, 527, 526, 525, 524, 523, 736 522, 521, 520, 519, 518, 517, 516, 515, 514, 513, 512, 511, 510, 509, 508, 507, 506, 737 505, 504, 503, 502, 501, 500, 499, 489, 488, 487, 486, 485, 484, 483, 482, 738 739 476, 475, 474, 473, 472, 471, 470, 469, 468, 467, 466, 465, 464, 463, 462, 461, 460, 740 459, 458, 457, 453, 452, 451, 450, 449, 448, 447, 446, 445, 444, 443, 442, 441, 440, 741 439, 438, 437, 436, 435, 434, 433, 432, 431, 430, 429, 428, 427, 426, 425, 424, 423, 742 422, 421, 420, 419, 418, 417, 416, 410, 409, 408, 407, 406, 405, 404, 403, 402, 398, 743 394, 393, 392, 391, 390, 386, 385, 384, 383, 382, 381, 380, 379, 378, 374, 373, 372, 744 371, 370, 369, 368, 367, 366, 365, 364, 360, 359, 358, 357, 356, 355, 352, 745 746 351, 350, 349, 348, 347, 346, 345, 344, 343, 342, 341, 340, 339, 338, 337, 336, 333, 747 332, 331, 330, 329, 328, 327, 326, 325, 324, 323, 322, 318, 317, 316, 315, 314, 313, 748 312, 311, 310, 309, 308, 307, 306, 305, 304, 303, 302, 301, 300, 299, 298, 297, 296, 749 295, 294, 293, 292, 291, 290, 289, 288, 285, 284, 283, 282, 279, 278, 277, 276, 275, 750 274, 273, 272, 265, 264, 263, 260, 259, 258, 255, 250, 249, 248, 247, 246, 241, 240, 751 237, 233, 232, 231, 227, 224, 223, 222, 219, 218, 217, 216, 215, 209, 208, 752 753 207, 206, 205, 204, 203, 202, 197, 196, 195, 194, 193, 192, 191, 190, 186, 185, 184, 754 183, 182, 181, 180, 177, 176, 175, 174, 173, 160, 138, 133, 115, 91, 85, 80, 73, 755 67, 62, 981, 5, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 756 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 757 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 758 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 759 760 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 761 981, 981, 981}; 762 763 static const flex_int16_t yy_chk[1321] = { 764 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 765 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 766 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 767 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 768 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 769 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 770 771 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 772 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 773 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 774 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 10, 10, 11, 15, 775 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 755, 21, 24, 26, 26, 17, 776 15, 43, 31, 11, 20, 43, 20, 20, 20, 20, 20, 20, 20, 20, 20, 777 778 20, 24, 21, 24, 24, 33, 36, 37, 52, 37, 36, 20, 31, 21, 756, 36, 52, 779 42, 37, 33, 33, 36, 20, 44, 35, 20, 21, 34, 35, 34, 42, 38, 34, 34, 780 35, 20, 44, 35, 40, 38, 21, 38, 55, 46, 38, 757, 40, 150, 150, 20, 38, 781 46, 20, 41, 72, 72, 41, 40, 46, 41, 41, 46, 41, 48, 41, 41, 49, 41, 782 758, 49, 48, 48, 51, 760, 48, 76, 51, 49, 72, 72, 48, 48, 50, 48, 49, 783 51, 50, 761, 50, 112, 50, 74, 74, 50, 55, 75, 94, 76, 75, 102, 784 785 94, 111, 112, 102, 102, 132, 762, 138, 76, 763, 122, 132, 111, 122, 122, 74, 74, 786 122, 128, 122, 151, 76, 75, 138, 138, 75, 128, 157, 151, 157, 172, 77, 764, 77, 787 134, 76, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 140, 134, 143, 134, 153, 788 144, 166, 166, 189, 189, 765, 172, 153, 140, 164, 766, 164, 143, 144, 164, 164, 164, 789 164, 164, 164, 164, 164, 164, 164, 235, 166, 166, 167, 235, 167, 314, 314, 167, 167, 790 167, 167, 167, 167, 167, 167, 167, 167, 170, 170, 170, 170, 170, 170, 170, 791 792 170, 170, 170, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 184, 222, 222, 222, 793 253, 260, 260, 260, 279, 279, 279, 171, 253, 184, 266, 266, 266, 266, 266, 266, 266, 794 266, 266, 266, 267, 267, 267, 267, 267, 267, 267, 267, 267, 267, 767, 171, 291, 291, 795 291, 300, 300, 300, 304, 304, 304, 267, 268, 268, 268, 268, 268, 268, 268, 268, 268, 796 268, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 315, 315, 315, 267, 359, 359, 797 359, 403, 403, 403, 768, 269, 417, 417, 417, 418, 418, 418, 419, 419, 419, 798 799 547, 769, 403, 403, 476, 476, 476, 507, 524, 524, 524, 507, 770, 547, 269, 548, 569, 800 569, 569, 771, 476, 476, 772, 773, 524, 524, 665, 759, 548, 607, 607, 607, 569, 569, 801 774, 569, 634, 634, 634, 665, 759, 775, 666, 776, 778, 607, 607, 569, 699, 724, 779, 802 666, 634, 634, 666, 666, 780, 699, 724, 781, 699, 724, 782, 783, 784, 785, 786, 787, 803 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 804 805, 806, 807, 809, 810, 811, 812, 813, 814, 815, 816, 817, 818, 821, 822, 805 806 824, 826, 827, 828, 829, 830, 831, 832, 833, 834, 836, 837, 838, 839, 840, 841, 842, 807 845, 846, 847, 848, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 808 865, 866, 867, 868, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 809 884, 885, 886, 887, 888, 891, 892, 893, 895, 896, 897, 900, 901, 902, 904, 906, 907, 810 908, 910, 911, 912, 913, 915, 918, 919, 920, 921, 922, 923, 925, 926, 927, 928, 929, 811 931, 932, 933, 934, 935, 937, 938, 939, 940, 941, 942, 945, 946, 947, 948, 812 813 949, 951, 956, 960, 961, 962, 963, 965, 966, 967, 969, 970, 973, 974, 975, 976, 978, 814 979, 982, 982, 754, 753, 752, 982, 983, 983, 983, 983, 983, 984, 984, 984, 984, 984, 815 985, 751, 985, 986, 750, 986, 987, 987, 987, 749, 748, 747, 746, 745, 744, 743, 742, 816 741, 740, 738, 737, 736, 735, 734, 733, 732, 731, 729, 728, 727, 726, 723, 722, 721, 817 720, 719, 718, 716, 715, 714, 713, 712, 711, 710, 709, 708, 707, 706, 705, 704, 703, 818 702, 701, 698, 697, 696, 695, 694, 693, 692, 691, 690, 689, 688, 687, 686, 819 820 685, 684, 682, 681, 680, 679, 678, 677, 676, 675, 674, 673, 672, 671, 670, 669, 668, 821 667, 663, 661, 659, 658, 657, 656, 655, 654, 653, 650, 649, 648, 647, 646, 645, 644, 822 643, 642, 641, 639, 638, 637, 636, 633, 631, 630, 628, 627, 625, 624, 623, 622, 621, 823 620, 619, 618, 614, 613, 612, 611, 609, 608, 606, 605, 604, 603, 602, 601, 600, 599, 824 598, 597, 596, 594, 593, 588, 587, 586, 585, 584, 583, 581, 580, 579, 577, 576, 575, 825 574, 573, 571, 570, 568, 567, 566, 565, 563, 562, 561, 560, 559, 556, 555, 826 827 554, 553, 552, 551, 550, 546, 545, 544, 543, 542, 541, 538, 537, 536, 535, 534, 533, 828 532, 531, 530, 529, 528, 527, 526, 525, 523, 522, 519, 513, 511, 510, 509, 506, 505, 829 502, 501, 500, 499, 488, 487, 486, 485, 484, 483, 481, 480, 479, 478, 477, 474, 472, 830 471, 470, 468, 467, 465, 464, 462, 461, 460, 458, 457, 452, 451, 450, 448, 447, 446, 831 445, 444, 443, 442, 441, 440, 439, 438, 436, 435, 434, 433, 432, 431, 430, 429, 428, 832 426, 425, 424, 423, 422, 421, 420, 416, 412, 411, 410, 409, 408, 407, 404, 833 834 402, 392, 390, 386, 385, 384, 383, 381, 380, 378, 374, 372, 371, 370, 369, 368, 367, 835 366, 365, 360, 358, 357, 356, 355, 354, 353, 351, 350, 347, 346, 345, 344, 343, 342, 836 341, 340, 339, 338, 337, 336, 335, 334, 333, 332, 331, 330, 329, 328, 327, 326, 325, 837 324, 323, 322, 321, 320, 319, 316, 313, 312, 311, 310, 309, 308, 307, 306, 305, 303, 838 299, 297, 296, 295, 294, 290, 289, 288, 287, 286, 285, 284, 283, 282, 278, 277, 275, 839 274, 273, 272, 265, 264, 263, 262, 261, 259, 258, 257, 256, 255, 254, 252, 840 841 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240, 239, 238, 237, 236, 234, 842 233, 232, 231, 230, 229, 228, 227, 226, 225, 224, 223, 221, 220, 219, 218, 217, 216, 843 215, 214, 213, 212, 211, 210, 209, 208, 207, 206, 205, 204, 203, 201, 200, 199, 198, 844 197, 196, 195, 194, 193, 192, 191, 190, 188, 187, 186, 185, 183, 182, 181, 180, 179, 845 178, 176, 175, 160, 159, 158, 156, 155, 154, 152, 149, 148, 147, 146, 145, 142, 141, 846 139, 137, 136, 135, 133, 131, 130, 129, 127, 126, 125, 124, 123, 121, 120, 847 848 118, 117, 116, 115, 114, 113, 110, 109, 108, 107, 106, 105, 104, 103, 101, 100, 99, 849 98, 97, 96, 95, 93, 92, 91, 87, 83, 53, 47, 45, 39, 32, 25, 22, 19, 850 14, 9, 5, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 851 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 852 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 853 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 854 855 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 981, 856 981, 981, 981}; 857 858 /* Table of booleans, true if rule could match eol. */ 859 static const flex_int32_t yy_rule_can_match_eol[260] = { 860 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 861 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 862 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 863 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 864 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 865 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 866 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 867 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 868 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 869 }; 870 871 /* The intent behind this definition is that it'll catch 872 * any uses of REJECT which flex missed. 873 */ 874 #define REJECT reject_used_but_not_detected 875 #define yymore() yymore_used_but_not_detected 876 #define YY_MORE_ADJ 0 877 #define YY_RESTORE_YY_MORE_OFFSET 878 /* 879 // 880 // Copyright 2002 The ANGLE Project Authors. All rights reserved. 881 // Use of this source code is governed by a BSD-style license that can be 882 // found in the LICENSE file. 883 // 884 885 This file contains the Lex specification for GLSL ES. 886 Based on ANSI C grammar, Lex specification: 887 http://www.lysator.liu.se/c/ANSI-C-grammar-l.html 888 889 IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN scripts/run_code_generation.py 890 WHICH GENERATES THE GLSL ES LEXER (glslang_lex_autogen.cpp). 891 */ 892 893 #include "compiler/preprocessor/Token.h" 894 #include "compiler/translator/ParseContext.h" 895 #include "compiler/translator/glslang.h" 896 #include "compiler/translator/length_limits.h" 897 #include "compiler/translator/util.h" 898 899 using namespace sh; 900 901 #include "glslang_tab_autogen.h" 902 903 /* windows only pragma */ 904 #ifdef _MSC_VER 905 # pragma warning(disable : 4102) 906 #endif 907 908 // Workaround for flex using the register keyword, deprecated in C++11. 909 #ifdef __cplusplus 910 # if __cplusplus > 199711L 911 # define register 912 # endif 913 #endif 914 915 #define YY_NO_INPUT 916 #define YY_USER_ACTION \ 917 yylloc->first_file = yylloc->last_file = yycolumn; \ 918 yylloc->first_line = yylloc->last_line = yylineno; 919 920 #define YY_INPUT(buf, result, max_size) result = string_input(buf, max_size, yyscanner); 921 922 static yy_size_t string_input(char *buf, yy_size_t max_size, yyscan_t yyscanner); 923 static int check_type(yyscan_t yyscanner); 924 static int reserved_word(yyscan_t yyscanner); 925 // Tests if an extension is enabled. If the extension is promoted to core, this function returns 926 // true. 927 static bool is_extension_enabled_or_is_core(TParseContext *context, 928 int extension_version, 929 TExtension extension, 930 int promotion_version); 931 // Helpers to determine if a symbol is reserved, keyword in extension or core, or identifier. 932 // Formatted as: 933 // 934 // [V1_reserved_][V2_extension_][V3_keyword] 935 // 936 // which means in version V1, the symbol is reserved, and remains reserved until V3. From versions 937 // V2 until V3, it's a keyword if the extension is enabled. From version V3 on, it's a keyword in 938 // the spec itself. Prior to V1, the symbol can be used as identifier. 939 static int ES2_extensions_ES3_keyword(TParseContext *context, 940 TExtension extension1, 941 TExtension extension2, 942 TExtension extension3, 943 int token); 944 static int ES2_reserved_ES3_keyword(TParseContext *context, int token); 945 static int ES2_keyword_ES3_reserved(TParseContext *context, int token); 946 static int ES3_keyword(TParseContext *context, int token); 947 static int ES3_reserved_ES3_1_keyword(TParseContext *context, int token); 948 static int ES2_reserved_ES3_1_keyword(TParseContext *context, int token); 949 static int ES3_1_keyword(TParseContext *context, int token); 950 static int ES2_reserved_ES2_extension_ES3_keyword(TParseContext *context, 951 TExtension extension, 952 int token); 953 static int ES3_extension(TParseContext *context, TExtension extension, int token); 954 static int ES3_reserved_ES3_1_extension_ES3_2_keyword(TParseContext *context, 955 TExtension extension, 956 int token); 957 static int ES3_reserved_ES3_extension(TParseContext *context, TExtension extension, int token); 958 static int ES3_reserved_ES3_extension_ES3_1_keyword(TParseContext *context, 959 TExtension extension, 960 int token); 961 static int ES3_reserved_ES3_extension_ES3_2_keyword(TParseContext *context, 962 TExtension extension, 963 int token); 964 static int ES3_1_reserved_ES3_1_extension_ES3_2_keyword(TParseContext *context, 965 TExtension extension, 966 int token); 967 static int ES3_1_reserved_ES3_1_extension_ES3_2_keyword_2(TParseContext *context, 968 TExtension extension1, 969 TExtension extension2, 970 int token1, 971 int token2); 972 static int ES3_and_3_1_reserved_ES3_1_extension_ES3_2_keyword_2(TParseContext *context, 973 TExtension extension1, 974 TExtension extension2, 975 int token1, 976 int token2); 977 static int WEBGL_video_texture_extension(TParseContext *context, int token); 978 static int uint_constant(TParseContext *context); 979 static int int_constant(TParseContext *context); 980 static int float_constant(yyscan_t yyscanner); 981 static int floatsuffix_check(TParseContext *context); 982 static int yuvcscstandardext_constant(TParseContext *context); 983 984 #define INITIAL 0 985 #define FIELDS 1 986 987 #define YY_EXTRA_TYPE TParseContext * 988 989 /* Holds the entire state of the reentrant scanner. */ 990 struct yyguts_t 991 { 992 993 /* User-defined. Not touched by flex. */ 994 YY_EXTRA_TYPE yyextra_r; 995 996 /* The rest are the same as the globals declared in the non-reentrant scanner. */ 997 FILE *yyin_r, *yyout_r; 998 size_t yy_buffer_stack_top; /**< index of top of stack. */ 999 size_t yy_buffer_stack_max; /**< capacity of stack. */ 1000 YY_BUFFER_STATE *yy_buffer_stack; /**< Stack as an array. */ 1001 char yy_hold_char; 1002 int yy_n_chars; 1003 int yyleng_r; 1004 char *yy_c_buf_p; 1005 int yy_init; 1006 int yy_start; 1007 int yy_did_buffer_switch_on_eof; 1008 int yy_start_stack_ptr; 1009 int yy_start_stack_depth; 1010 int *yy_start_stack; 1011 yy_state_type yy_last_accepting_state; 1012 char *yy_last_accepting_cpos; 1013 1014 int yylineno_r; 1015 int yy_flex_debug_r; 1016 1017 char *yytext_r; 1018 int yy_more_flag; 1019 int yy_more_len; 1020 1021 YYSTYPE *yylval_r; 1022 1023 YYLTYPE *yylloc_r; 1024 1025 }; /* end struct yyguts_t */ 1026 1027 static int yy_init_globals(yyscan_t yyscanner); 1028 1029 /* This must go here because YYSTYPE and YYLTYPE are included 1030 * from bison output in section 1.*/ 1031 #define yylval yyg->yylval_r 1032 1033 #define yylloc yyg->yylloc_r 1034 1035 int yylex_init(yyscan_t *scanner); 1036 1037 int yylex_init_extra(YY_EXTRA_TYPE user_defined, yyscan_t *scanner); 1038 1039 /* Accessor methods to globals. 1040 These are made visible to non-reentrant scanners for convenience. */ 1041 1042 int yylex_destroy(yyscan_t yyscanner); 1043 1044 int yyget_debug(yyscan_t yyscanner); 1045 1046 void yyset_debug(int debug_flag, yyscan_t yyscanner); 1047 1048 YY_EXTRA_TYPE yyget_extra(yyscan_t yyscanner); 1049 1050 void yyset_extra(YY_EXTRA_TYPE user_defined, yyscan_t yyscanner); 1051 1052 FILE *yyget_in(yyscan_t yyscanner); 1053 1054 void yyset_in(FILE *_in_str, yyscan_t yyscanner); 1055 1056 FILE *yyget_out(yyscan_t yyscanner); 1057 1058 void yyset_out(FILE *_out_str, yyscan_t yyscanner); 1059 1060 int yyget_leng(yyscan_t yyscanner); 1061 1062 char *yyget_text(yyscan_t yyscanner); 1063 1064 int yyget_lineno(yyscan_t yyscanner); 1065 1066 void yyset_lineno(int _line_number, yyscan_t yyscanner); 1067 1068 int yyget_column(yyscan_t yyscanner); 1069 1070 void yyset_column(int _column_no, yyscan_t yyscanner); 1071 1072 YYSTYPE *yyget_lval(yyscan_t yyscanner); 1073 1074 void yyset_lval(YYSTYPE *yylval_param, yyscan_t yyscanner); 1075 1076 YYLTYPE *yyget_lloc(yyscan_t yyscanner); 1077 1078 void yyset_lloc(YYLTYPE *yylloc_param, yyscan_t yyscanner); 1079 1080 /* Macros after this point can all be overridden by user definitions in 1081 * section 1. 1082 */ 1083 1084 #ifndef YY_SKIP_YYWRAP 1085 # ifdef __cplusplus 1086 extern "C" int yywrap(yyscan_t yyscanner); 1087 # else 1088 extern int yywrap(yyscan_t yyscanner); 1089 # endif 1090 #endif 1091 1092 #ifndef YY_NO_UNPUT 1093 1094 #endif 1095 1096 #ifndef yytext_ptr 1097 static void yy_flex_strncpy(char *, const char *, int, yyscan_t yyscanner); 1098 #endif 1099 1100 #ifdef YY_NEED_STRLEN 1101 static int yy_flex_strlen(const char *, yyscan_t yyscanner); 1102 #endif 1103 1104 #ifndef YY_NO_INPUT 1105 # ifdef __cplusplus 1106 static int yyinput(yyscan_t yyscanner); 1107 # else 1108 static int input(yyscan_t yyscanner); 1109 # endif 1110 1111 #endif 1112 1113 /* Amount of stuff to slurp up with each read. */ 1114 #ifndef YY_READ_BUF_SIZE 1115 # ifdef __ia64__ 1116 /* On IA-64, the buffer size is 16k, not 8k */ 1117 # define YY_READ_BUF_SIZE 16384 1118 # else 1119 # define YY_READ_BUF_SIZE 8192 1120 # endif /* __ia64__ */ 1121 #endif 1122 1123 /* Copy whatever the last rule matched to the standard output. */ 1124 #ifndef ECHO 1125 /* This used to be an fputs(), but since the string might contain NUL's, 1126 * we now use fwrite(). 1127 */ 1128 # define ECHO \ 1129 do \ 1130 { \ 1131 if (fwrite(yytext, (size_t)yyleng, 1, yyout)) \ 1132 {} \ 1133 } while (0) 1134 #endif 1135 1136 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 1137 * is returned in "result". 1138 */ 1139 #ifndef YY_INPUT 1140 # define YY_INPUT(buf, result, max_size) \ 1141 if (YY_CURRENT_BUFFER_LVALUE->yy_is_interactive) \ 1142 { \ 1143 int c = '*'; \ 1144 int n; \ 1145 for (n = 0; n < max_size && (c = getc(yyin)) != EOF && c != '\n'; ++n) \ 1146 buf[n] = (char)c; \ 1147 if (c == '\n') \ 1148 buf[n++] = (char)c; \ 1149 if (c == EOF && ferror(yyin)) \ 1150 YY_FATAL_ERROR("input in flex scanner failed"); \ 1151 result = n; \ 1152 } \ 1153 else \ 1154 { \ 1155 errno = 0; \ 1156 while ((result = (int)fread(buf, 1, (yy_size_t)max_size, yyin)) == 0 && ferror(yyin)) \ 1157 { \ 1158 if (errno != EINTR) \ 1159 { \ 1160 YY_FATAL_ERROR("input in flex scanner failed"); \ 1161 break; \ 1162 } \ 1163 errno = 0; \ 1164 clearerr(yyin); \ 1165 } \ 1166 } 1167 1168 #endif 1169 1170 /* No semi-colon after return; correct usage is to write "yyterminate();" - 1171 * we don't want an extra ';' after the "return" because that will cause 1172 * some compilers to complain about unreachable statements. 1173 */ 1174 #ifndef yyterminate 1175 # define yyterminate() return YY_NULL 1176 #endif 1177 1178 /* Number of entries by which start-condition stack grows. */ 1179 #ifndef YY_START_STACK_INCR 1180 # define YY_START_STACK_INCR 25 1181 #endif 1182 1183 /* Report a fatal error. */ 1184 #ifndef YY_FATAL_ERROR 1185 # define YY_FATAL_ERROR(msg) yy_fatal_error(msg, yyscanner) 1186 #endif 1187 1188 /* end tables serialization structures and prototypes */ 1189 1190 /* Default declaration of generated scanner - a define so the user can 1191 * easily add parameters. 1192 */ 1193 #ifndef YY_DECL 1194 # define YY_DECL_IS_OURS 1 1195 1196 extern int yylex(YYSTYPE *yylval_param, YYLTYPE *yylloc_param, yyscan_t yyscanner); 1197 1198 # define YY_DECL int yylex(YYSTYPE *yylval_param, YYLTYPE *yylloc_param, yyscan_t yyscanner) 1199 #endif /* !YY_DECL */ 1200 1201 /* Code executed at the beginning of each rule, after yytext and yyleng 1202 * have been set up. 1203 */ 1204 #ifndef YY_USER_ACTION 1205 # define YY_USER_ACTION 1206 #endif 1207 1208 /* Code executed at the end of each rule. */ 1209 #ifndef YY_BREAK 1210 # define YY_BREAK /*LINTED*/ break; 1211 #endif 1212 1213 #define YY_RULE_SETUP YY_USER_ACTION 1214 1215 /** The main scanner function which does all the work. 1216 */ 1217 YY_DECL 1218 { 1219 yy_state_type yy_current_state; 1220 char *yy_cp, *yy_bp; 1221 int yy_act; 1222 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 1223 1224 yylval = yylval_param; 1225 1226 yylloc = yylloc_param; 1227 1228 if (!yyg->yy_init) 1229 { 1230 yyg->yy_init = 1; 1231 1232 #ifdef YY_USER_INIT 1233 YY_USER_INIT; 1234 #endif 1235 1236 if (!yyg->yy_start) 1237 yyg->yy_start = 1; /* first start state */ 1238 1239 if (!yyin) 1240 yyin = stdin; 1241 1242 if (!yyout) 1243 yyout = stdout; 1244 1245 if (!YY_CURRENT_BUFFER) 1246 { 1247 yyensure_buffer_stack(yyscanner); 1248 YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin, YY_BUF_SIZE, yyscanner); 1249 } 1250 1251 yy_load_buffer_state(yyscanner); 1252 } 1253 1254 { 1255 1256 TParseContext *context = yyextra; 1257 1258 while (/*CONSTCOND*/ 1) /* loops until end-of-file is reached */ 1259 { 1260 yy_cp = yyg->yy_c_buf_p; 1261 1262 /* Support of yytext. */ 1263 *yy_cp = yyg->yy_hold_char; 1264 1265 /* yy_bp points to the position in yy_ch_buf of the start of 1266 * the current run. 1267 */ 1268 yy_bp = yy_cp; 1269 1270 yy_current_state = yyg->yy_start; 1271 yy_match: 1272 do 1273 { 1274 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 1275 if (yy_accept[yy_current_state]) 1276 { 1277 yyg->yy_last_accepting_state = yy_current_state; 1278 yyg->yy_last_accepting_cpos = yy_cp; 1279 } 1280 while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) 1281 { 1282 yy_current_state = (int)yy_def[yy_current_state]; 1283 if (yy_current_state >= 982) 1284 yy_c = yy_meta[yy_c]; 1285 } 1286 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1287 ++yy_cp; 1288 } while (yy_current_state != 981); 1289 yy_cp = yyg->yy_last_accepting_cpos; 1290 yy_current_state = yyg->yy_last_accepting_state; 1291 1292 yy_find_action: 1293 yy_act = yy_accept[yy_current_state]; 1294 1295 YY_DO_BEFORE_ACTION; 1296 1297 if (yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act]) 1298 { 1299 int yyl; 1300 for (yyl = 0; yyl < yyleng; ++yyl) 1301 if (yytext[yyl] == '\n') 1302 1303 do 1304 { 1305 yylineno++; 1306 yycolumn = 0; 1307 } while (0); 1308 } 1309 1310 do_action: /* This label is used only to access EOF actions. */ 1311 1312 switch (yy_act) 1313 { /* beginning of action switch */ 1314 case 0: /* must back up */ 1315 /* undo the effects of YY_DO_BEFORE_ACTION */ 1316 *yy_cp = yyg->yy_hold_char; 1317 yy_cp = yyg->yy_last_accepting_cpos; 1318 yy_current_state = yyg->yy_last_accepting_state; 1319 goto yy_find_action; 1320 1321 case 1: 1322 YY_RULE_SETUP 1323 { 1324 return INVARIANT; 1325 } 1326 YY_BREAK 1327 case 2: 1328 YY_RULE_SETUP 1329 { 1330 return HIGH_PRECISION; 1331 } 1332 YY_BREAK 1333 case 3: 1334 YY_RULE_SETUP 1335 { 1336 return MEDIUM_PRECISION; 1337 } 1338 YY_BREAK 1339 case 4: 1340 YY_RULE_SETUP 1341 { 1342 return LOW_PRECISION; 1343 } 1344 YY_BREAK 1345 case 5: 1346 YY_RULE_SETUP 1347 { 1348 return PRECISION; 1349 } 1350 YY_BREAK 1351 case 6: 1352 YY_RULE_SETUP 1353 { 1354 return ES2_keyword_ES3_reserved(context, ATTRIBUTE); 1355 } 1356 YY_BREAK 1357 case 7: 1358 YY_RULE_SETUP 1359 { 1360 return CONST_QUAL; 1361 } 1362 YY_BREAK 1363 case 8: 1364 YY_RULE_SETUP 1365 { 1366 return UNIFORM; 1367 } 1368 YY_BREAK 1369 case 9: 1370 YY_RULE_SETUP 1371 { 1372 return ES3_1_keyword(context, BUFFER); 1373 } 1374 YY_BREAK 1375 case 10: 1376 YY_RULE_SETUP 1377 { 1378 return ES2_keyword_ES3_reserved(context, VARYING); 1379 } 1380 YY_BREAK 1381 case 11: 1382 YY_RULE_SETUP 1383 { 1384 return BREAK; 1385 } 1386 YY_BREAK 1387 case 12: 1388 YY_RULE_SETUP 1389 { 1390 return CONTINUE; 1391 } 1392 YY_BREAK 1393 case 13: 1394 YY_RULE_SETUP 1395 { 1396 return DO; 1397 } 1398 YY_BREAK 1399 case 14: 1400 YY_RULE_SETUP 1401 { 1402 return FOR; 1403 } 1404 YY_BREAK 1405 case 15: 1406 YY_RULE_SETUP 1407 { 1408 return WHILE; 1409 } 1410 YY_BREAK 1411 case 16: 1412 YY_RULE_SETUP 1413 { 1414 return IF; 1415 } 1416 YY_BREAK 1417 case 17: 1418 YY_RULE_SETUP 1419 { 1420 return ELSE; 1421 } 1422 YY_BREAK 1423 case 18: 1424 YY_RULE_SETUP 1425 { 1426 return ES2_reserved_ES3_keyword(context, SWITCH); 1427 } 1428 YY_BREAK 1429 case 19: 1430 YY_RULE_SETUP 1431 { 1432 return ES3_keyword(context, CASE); 1433 } 1434 YY_BREAK 1435 case 20: 1436 YY_RULE_SETUP 1437 { 1438 return ES2_reserved_ES3_keyword(context, DEFAULT); 1439 } 1440 YY_BREAK 1441 case 21: 1442 YY_RULE_SETUP 1443 { 1444 return ES3_keyword(context, CENTROID); 1445 } 1446 YY_BREAK 1447 case 22: 1448 YY_RULE_SETUP 1449 { 1450 return ES2_reserved_ES3_keyword(context, FLAT); 1451 } 1452 YY_BREAK 1453 case 23: 1454 YY_RULE_SETUP 1455 { 1456 return ES3_keyword(context, SMOOTH); 1457 } 1458 YY_BREAK 1459 case 24: 1460 YY_RULE_SETUP 1461 { 1462 return ES3_reserved_ES3_extension( 1463 context, TExtension::NV_shader_noperspective_interpolation, 1464 NOPERSPECTIVE); 1465 } 1466 YY_BREAK 1467 case 25: 1468 YY_RULE_SETUP 1469 { 1470 return ES3_reserved_ES3_1_extension_ES3_2_keyword( 1471 context, TExtension::EXT_tessellation_shader, PATCH); 1472 } 1473 YY_BREAK 1474 case 26: 1475 YY_RULE_SETUP 1476 { 1477 return IN_QUAL; 1478 } 1479 YY_BREAK 1480 case 27: 1481 YY_RULE_SETUP 1482 { 1483 return OUT_QUAL; 1484 } 1485 YY_BREAK 1486 case 28: 1487 YY_RULE_SETUP 1488 { 1489 return INOUT_QUAL; 1490 } 1491 YY_BREAK 1492 case 29: 1493 YY_RULE_SETUP 1494 { 1495 return ES3_1_keyword(context, SHARED); 1496 } 1497 YY_BREAK 1498 case 30: 1499 YY_RULE_SETUP 1500 { 1501 return FLOAT_TYPE; 1502 } 1503 YY_BREAK 1504 case 31: 1505 YY_RULE_SETUP 1506 { 1507 return INT_TYPE; 1508 } 1509 YY_BREAK 1510 case 32: 1511 YY_RULE_SETUP 1512 { 1513 return ES3_keyword(context, UINT_TYPE); 1514 } 1515 YY_BREAK 1516 case 33: 1517 YY_RULE_SETUP 1518 { 1519 return VOID_TYPE; 1520 } 1521 YY_BREAK 1522 case 34: 1523 YY_RULE_SETUP 1524 { 1525 return BOOL_TYPE; 1526 } 1527 YY_BREAK 1528 case 35: 1529 YY_RULE_SETUP 1530 { 1531 yylval->lex.b = true; 1532 return BOOLCONSTANT; 1533 } 1534 YY_BREAK 1535 case 36: 1536 YY_RULE_SETUP 1537 { 1538 yylval->lex.b = false; 1539 return BOOLCONSTANT; 1540 } 1541 YY_BREAK 1542 case 37: 1543 YY_RULE_SETUP 1544 { 1545 return DISCARD; 1546 } 1547 YY_BREAK 1548 case 38: 1549 YY_RULE_SETUP 1550 { 1551 return RETURN; 1552 } 1553 YY_BREAK 1554 case 39: 1555 YY_RULE_SETUP 1556 { 1557 return MATRIX2; 1558 } 1559 YY_BREAK 1560 case 40: 1561 YY_RULE_SETUP 1562 { 1563 return MATRIX3; 1564 } 1565 YY_BREAK 1566 case 41: 1567 YY_RULE_SETUP 1568 { 1569 return MATRIX4; 1570 } 1571 YY_BREAK 1572 case 42: 1573 YY_RULE_SETUP 1574 { 1575 return ES3_keyword(context, MATRIX2); 1576 } 1577 YY_BREAK 1578 case 43: 1579 YY_RULE_SETUP 1580 { 1581 return ES3_keyword(context, MATRIX3); 1582 } 1583 YY_BREAK 1584 case 44: 1585 YY_RULE_SETUP 1586 { 1587 return ES3_keyword(context, MATRIX4); 1588 } 1589 YY_BREAK 1590 case 45: 1591 YY_RULE_SETUP 1592 { 1593 return ES3_keyword(context, MATRIX2x3); 1594 } 1595 YY_BREAK 1596 case 46: 1597 YY_RULE_SETUP 1598 { 1599 return ES3_keyword(context, MATRIX3x2); 1600 } 1601 YY_BREAK 1602 case 47: 1603 YY_RULE_SETUP 1604 { 1605 return ES3_keyword(context, MATRIX2x4); 1606 } 1607 YY_BREAK 1608 case 48: 1609 YY_RULE_SETUP 1610 { 1611 return ES3_keyword(context, MATRIX4x2); 1612 } 1613 YY_BREAK 1614 case 49: 1615 YY_RULE_SETUP 1616 { 1617 return ES3_keyword(context, MATRIX3x4); 1618 } 1619 YY_BREAK 1620 case 50: 1621 YY_RULE_SETUP 1622 { 1623 return ES3_keyword(context, MATRIX4x3); 1624 } 1625 YY_BREAK 1626 case 51: 1627 YY_RULE_SETUP 1628 { 1629 return VEC2; 1630 } 1631 YY_BREAK 1632 case 52: 1633 YY_RULE_SETUP 1634 { 1635 return VEC3; 1636 } 1637 YY_BREAK 1638 case 53: 1639 YY_RULE_SETUP 1640 { 1641 return VEC4; 1642 } 1643 YY_BREAK 1644 case 54: 1645 YY_RULE_SETUP 1646 { 1647 return IVEC2; 1648 } 1649 YY_BREAK 1650 case 55: 1651 YY_RULE_SETUP 1652 { 1653 return IVEC3; 1654 } 1655 YY_BREAK 1656 case 56: 1657 YY_RULE_SETUP 1658 { 1659 return IVEC4; 1660 } 1661 YY_BREAK 1662 case 57: 1663 YY_RULE_SETUP 1664 { 1665 return BVEC2; 1666 } 1667 YY_BREAK 1668 case 58: 1669 YY_RULE_SETUP 1670 { 1671 return BVEC3; 1672 } 1673 YY_BREAK 1674 case 59: 1675 YY_RULE_SETUP 1676 { 1677 return BVEC4; 1678 } 1679 YY_BREAK 1680 case 60: 1681 YY_RULE_SETUP 1682 { 1683 return ES3_keyword(context, UVEC2); 1684 } 1685 YY_BREAK 1686 case 61: 1687 YY_RULE_SETUP 1688 { 1689 return ES3_keyword(context, UVEC3); 1690 } 1691 YY_BREAK 1692 case 62: 1693 YY_RULE_SETUP 1694 { 1695 return ES3_keyword(context, UVEC4); 1696 } 1697 YY_BREAK 1698 case 63: 1699 YY_RULE_SETUP 1700 { 1701 return SAMPLER2D; 1702 } 1703 YY_BREAK 1704 case 64: 1705 YY_RULE_SETUP 1706 { 1707 return SAMPLERCUBE; 1708 } 1709 YY_BREAK 1710 case 65: 1711 YY_RULE_SETUP 1712 { 1713 return SAMPLER_EXTERNAL_OES; 1714 } 1715 YY_BREAK 1716 case 66: 1717 YY_RULE_SETUP 1718 { 1719 return ES2_reserved_ES2_extension_ES3_keyword( 1720 context, TExtension::OES_texture_3D, SAMPLER3D); 1721 } 1722 YY_BREAK 1723 case 67: 1724 YY_RULE_SETUP 1725 { 1726 return ES2_reserved_ES3_keyword(context, SAMPLER3DRECT); 1727 } 1728 YY_BREAK 1729 case 68: 1730 YY_RULE_SETUP 1731 { 1732 return SAMPLER2DRECT; 1733 } 1734 YY_BREAK 1735 case 69: 1736 YY_RULE_SETUP 1737 { 1738 return ES3_keyword(context, SAMPLER2DARRAY); 1739 } 1740 YY_BREAK 1741 case 70: 1742 YY_RULE_SETUP 1743 { 1744 return ES3_reserved_ES3_extension_ES3_1_keyword( 1745 context, TExtension::ANGLE_texture_multisample, SAMPLER2DMS); 1746 } 1747 YY_BREAK 1748 case 71: 1749 YY_RULE_SETUP 1750 { 1751 return ES3_keyword(context, ISAMPLER2D); 1752 } 1753 YY_BREAK 1754 case 72: 1755 YY_RULE_SETUP 1756 { 1757 return ES3_keyword(context, ISAMPLER3D); 1758 } 1759 YY_BREAK 1760 case 73: 1761 YY_RULE_SETUP 1762 { 1763 return ES3_keyword(context, ISAMPLERCUBE); 1764 } 1765 YY_BREAK 1766 case 74: 1767 YY_RULE_SETUP 1768 { 1769 return ES3_keyword(context, ISAMPLER2DARRAY); 1770 } 1771 YY_BREAK 1772 case 75: 1773 YY_RULE_SETUP 1774 { 1775 return ES3_reserved_ES3_extension_ES3_1_keyword( 1776 context, TExtension::ANGLE_texture_multisample, ISAMPLER2DMS); 1777 } 1778 YY_BREAK 1779 case 76: 1780 YY_RULE_SETUP 1781 { 1782 return ES3_keyword(context, USAMPLER2D); 1783 } 1784 YY_BREAK 1785 case 77: 1786 YY_RULE_SETUP 1787 { 1788 return ES3_keyword(context, USAMPLER3D); 1789 } 1790 YY_BREAK 1791 case 78: 1792 YY_RULE_SETUP 1793 { 1794 return ES3_keyword(context, USAMPLERCUBE); 1795 } 1796 YY_BREAK 1797 case 79: 1798 YY_RULE_SETUP 1799 { 1800 return ES3_keyword(context, USAMPLER2DARRAY); 1801 } 1802 YY_BREAK 1803 case 80: 1804 YY_RULE_SETUP 1805 { 1806 return ES3_reserved_ES3_extension_ES3_1_keyword( 1807 context, TExtension::ANGLE_texture_multisample, USAMPLER2DMS); 1808 } 1809 YY_BREAK 1810 case 81: 1811 YY_RULE_SETUP 1812 { 1813 return ES2_reserved_ES2_extension_ES3_keyword( 1814 context, TExtension::EXT_shadow_samplers, SAMPLER2DSHADOW); 1815 } 1816 YY_BREAK 1817 case 82: 1818 YY_RULE_SETUP 1819 { 1820 return ES3_keyword(context, SAMPLERCUBESHADOW); 1821 } 1822 YY_BREAK 1823 case 83: 1824 YY_RULE_SETUP 1825 { 1826 return ES3_keyword(context, SAMPLER2DARRAYSHADOW); 1827 } 1828 YY_BREAK 1829 case 84: 1830 YY_RULE_SETUP 1831 { 1832 return ES3_extension(context, TExtension::EXT_YUV_target, 1833 SAMPLEREXTERNAL2DY2YEXT); 1834 } 1835 YY_BREAK 1836 case 85: 1837 YY_RULE_SETUP 1838 { 1839 return ES3_reserved_ES3_1_extension_ES3_2_keyword( 1840 context, TExtension::OES_texture_storage_multisample_2d_array, 1841 SAMPLER2DMSARRAY); 1842 } 1843 YY_BREAK 1844 case 86: 1845 YY_RULE_SETUP 1846 { 1847 return ES3_reserved_ES3_1_extension_ES3_2_keyword( 1848 context, TExtension::OES_texture_storage_multisample_2d_array, 1849 ISAMPLER2DMSARRAY); 1850 } 1851 YY_BREAK 1852 case 87: 1853 YY_RULE_SETUP 1854 { 1855 return ES3_reserved_ES3_1_extension_ES3_2_keyword( 1856 context, TExtension::OES_texture_storage_multisample_2d_array, 1857 USAMPLER2DMSARRAY); 1858 } 1859 YY_BREAK 1860 case 88: 1861 YY_RULE_SETUP 1862 { 1863 return ES3_1_reserved_ES3_1_extension_ES3_2_keyword_2( 1864 context, TExtension::OES_texture_cube_map_array, 1865 TExtension::EXT_texture_cube_map_array, SAMPLERCUBEARRAYOES, 1866 SAMPLERCUBEARRAYEXT); 1867 } 1868 YY_BREAK 1869 case 89: 1870 YY_RULE_SETUP 1871 { 1872 return ES3_and_3_1_reserved_ES3_1_extension_ES3_2_keyword_2( 1873 context, TExtension::OES_texture_buffer, TExtension::EXT_texture_buffer, 1874 SAMPLERBUFFER, SAMPLERBUFFER); 1875 } 1876 YY_BREAK 1877 case 90: 1878 YY_RULE_SETUP 1879 { 1880 return ES3_1_reserved_ES3_1_extension_ES3_2_keyword_2( 1881 context, TExtension::OES_texture_cube_map_array, 1882 TExtension::EXT_texture_cube_map_array, SAMPLERCUBEARRAYSHADOWOES, 1883 SAMPLERCUBEARRAYSHADOWEXT); 1884 } 1885 YY_BREAK 1886 case 91: 1887 YY_RULE_SETUP 1888 { 1889 return ES3_1_reserved_ES3_1_extension_ES3_2_keyword_2( 1890 context, TExtension::OES_texture_cube_map_array, 1891 TExtension::EXT_texture_cube_map_array, ISAMPLERCUBEARRAYOES, 1892 ISAMPLERCUBEARRAYEXT); 1893 } 1894 YY_BREAK 1895 case 92: 1896 YY_RULE_SETUP 1897 { 1898 return ES3_and_3_1_reserved_ES3_1_extension_ES3_2_keyword_2( 1899 context, TExtension::OES_texture_buffer, TExtension::EXT_texture_buffer, 1900 ISAMPLERBUFFER, ISAMPLERBUFFER); 1901 } 1902 YY_BREAK 1903 case 93: 1904 YY_RULE_SETUP 1905 { 1906 return ES3_1_reserved_ES3_1_extension_ES3_2_keyword_2( 1907 context, TExtension::OES_texture_cube_map_array, 1908 TExtension::EXT_texture_cube_map_array, USAMPLERCUBEARRAYOES, 1909 USAMPLERCUBEARRAYEXT); 1910 } 1911 YY_BREAK 1912 case 94: 1913 YY_RULE_SETUP 1914 { 1915 return ES3_and_3_1_reserved_ES3_1_extension_ES3_2_keyword_2( 1916 context, TExtension::OES_texture_buffer, TExtension::EXT_texture_buffer, 1917 USAMPLERBUFFER, USAMPLERBUFFER); 1918 } 1919 YY_BREAK 1920 case 95: 1921 YY_RULE_SETUP 1922 { 1923 return WEBGL_video_texture_extension(context, SAMPLERVIDEOWEBGL); 1924 } 1925 YY_BREAK 1926 case 96: 1927 YY_RULE_SETUP 1928 { 1929 return STRUCT; 1930 } 1931 YY_BREAK 1932 case 97: 1933 YY_RULE_SETUP 1934 { 1935 return ES2_extensions_ES3_keyword( 1936 context, TExtension::EXT_shader_framebuffer_fetch, 1937 TExtension::EXT_shader_framebuffer_fetch_non_coherent, 1938 TExtension::KHR_blend_equation_advanced, LAYOUT); 1939 } 1940 YY_BREAK 1941 case 98: 1942 YY_RULE_SETUP 1943 { 1944 return ES3_extension(context, TExtension::EXT_YUV_target, 1945 YUVCSCSTANDARDEXT); 1946 } 1947 YY_BREAK 1948 case 99: 1949 YY_RULE_SETUP 1950 { 1951 return yuvcscstandardext_constant(context); 1952 } 1953 YY_BREAK 1954 case 100: 1955 YY_RULE_SETUP 1956 { 1957 return yuvcscstandardext_constant(context); 1958 } 1959 YY_BREAK 1960 case 101: 1961 YY_RULE_SETUP 1962 { 1963 return yuvcscstandardext_constant(context); 1964 } 1965 YY_BREAK 1966 case 102: 1967 YY_RULE_SETUP 1968 { 1969 return ES3_reserved_ES3_1_keyword(context, IMAGE2D); 1970 } 1971 YY_BREAK 1972 case 103: 1973 YY_RULE_SETUP 1974 { 1975 return ES3_reserved_ES3_1_keyword(context, IIMAGE2D); 1976 } 1977 YY_BREAK 1978 case 104: 1979 YY_RULE_SETUP 1980 { 1981 return ES3_reserved_ES3_1_keyword(context, UIMAGE2D); 1982 } 1983 YY_BREAK 1984 case 105: 1985 YY_RULE_SETUP 1986 { 1987 return ES3_reserved_ES3_1_keyword(context, IMAGE2DARRAY); 1988 } 1989 YY_BREAK 1990 case 106: 1991 YY_RULE_SETUP 1992 { 1993 return ES3_reserved_ES3_1_keyword(context, IIMAGE2DARRAY); 1994 } 1995 YY_BREAK 1996 case 107: 1997 YY_RULE_SETUP 1998 { 1999 return ES3_reserved_ES3_1_keyword(context, UIMAGE2DARRAY); 2000 } 2001 YY_BREAK 2002 case 108: 2003 YY_RULE_SETUP 2004 { 2005 return ES3_reserved_ES3_1_keyword(context, IMAGE3D); 2006 } 2007 YY_BREAK 2008 case 109: 2009 YY_RULE_SETUP 2010 { 2011 return ES3_reserved_ES3_1_keyword(context, UIMAGE3D); 2012 } 2013 YY_BREAK 2014 case 110: 2015 YY_RULE_SETUP 2016 { 2017 return ES3_reserved_ES3_1_keyword(context, IIMAGE3D); 2018 } 2019 YY_BREAK 2020 case 111: 2021 YY_RULE_SETUP 2022 { 2023 return ES3_reserved_ES3_1_keyword(context, IIMAGECUBE); 2024 } 2025 YY_BREAK 2026 case 112: 2027 YY_RULE_SETUP 2028 { 2029 return ES3_reserved_ES3_1_keyword(context, UIMAGECUBE); 2030 } 2031 YY_BREAK 2032 case 113: 2033 YY_RULE_SETUP 2034 { 2035 return ES3_reserved_ES3_1_keyword(context, IMAGECUBE); 2036 } 2037 YY_BREAK 2038 case 114: 2039 YY_RULE_SETUP 2040 { 2041 return ES3_1_reserved_ES3_1_extension_ES3_2_keyword_2( 2042 context, TExtension::OES_texture_cube_map_array, 2043 TExtension::EXT_texture_cube_map_array, IMAGECUBEARRAYOES, 2044 IMAGECUBEARRAYEXT); 2045 } 2046 YY_BREAK 2047 case 115: 2048 YY_RULE_SETUP 2049 { 2050 return ES3_1_reserved_ES3_1_extension_ES3_2_keyword_2( 2051 context, TExtension::OES_texture_cube_map_array, 2052 TExtension::EXT_texture_cube_map_array, IIMAGECUBEARRAYOES, 2053 IIMAGECUBEARRAYEXT); 2054 } 2055 YY_BREAK 2056 case 116: 2057 YY_RULE_SETUP 2058 { 2059 return ES3_1_reserved_ES3_1_extension_ES3_2_keyword_2( 2060 context, TExtension::OES_texture_cube_map_array, 2061 TExtension::EXT_texture_cube_map_array, UIMAGECUBEARRAYOES, 2062 UIMAGECUBEARRAYEXT); 2063 } 2064 YY_BREAK 2065 case 117: 2066 YY_RULE_SETUP 2067 { 2068 return ES3_and_3_1_reserved_ES3_1_extension_ES3_2_keyword_2( 2069 context, TExtension::OES_texture_buffer, TExtension::EXT_texture_buffer, 2070 IMAGEBUFFER, IMAGEBUFFER); 2071 } 2072 YY_BREAK 2073 case 118: 2074 YY_RULE_SETUP 2075 { 2076 return ES3_and_3_1_reserved_ES3_1_extension_ES3_2_keyword_2( 2077 context, TExtension::OES_texture_buffer, TExtension::EXT_texture_buffer, 2078 IIMAGEBUFFER, IIMAGEBUFFER); 2079 } 2080 YY_BREAK 2081 case 119: 2082 YY_RULE_SETUP 2083 { 2084 return ES3_and_3_1_reserved_ES3_1_extension_ES3_2_keyword_2( 2085 context, TExtension::OES_texture_buffer, TExtension::EXT_texture_buffer, 2086 UIMAGEBUFFER, UIMAGEBUFFER); 2087 } 2088 YY_BREAK 2089 case 120: 2090 YY_RULE_SETUP 2091 { 2092 return ES3_reserved_ES3_1_keyword(context, READONLY); 2093 } 2094 YY_BREAK 2095 case 121: 2096 YY_RULE_SETUP 2097 { 2098 return ES3_reserved_ES3_1_keyword(context, WRITEONLY); 2099 } 2100 YY_BREAK 2101 case 122: 2102 YY_RULE_SETUP 2103 { 2104 return ES3_reserved_ES3_1_keyword(context, COHERENT); 2105 } 2106 YY_BREAK 2107 case 123: 2108 YY_RULE_SETUP 2109 { 2110 return ES3_reserved_ES3_1_keyword(context, RESTRICT); 2111 } 2112 YY_BREAK 2113 case 124: 2114 YY_RULE_SETUP 2115 { 2116 return ES2_reserved_ES3_1_keyword(context, VOLATILE); 2117 } 2118 YY_BREAK 2119 case 125: 2120 YY_RULE_SETUP 2121 { 2122 return ES3_reserved_ES3_1_keyword(context, ATOMICUINT); 2123 } 2124 YY_BREAK 2125 case 126: 2126 YY_RULE_SETUP 2127 { 2128 return ES3_reserved_ES3_extension_ES3_2_keyword( 2129 context, TExtension::OES_shader_multisample_interpolation, SAMPLE); 2130 } 2131 YY_BREAK 2132 case 127: 2133 YY_RULE_SETUP 2134 { 2135 return ES3_1_reserved_ES3_1_extension_ES3_2_keyword( 2136 context, TExtension::EXT_gpu_shader5, PRECISE); 2137 } 2138 YY_BREAK 2139 /* ANGLE_shader_pixel_local_storage */ 2140 case 128: 2141 YY_RULE_SETUP 2142 { 2143 return ES3_extension(context, TExtension::ANGLE_shader_pixel_local_storage, 2144 PIXELLOCALANGLE); 2145 } 2146 YY_BREAK 2147 case 129: 2148 YY_RULE_SETUP 2149 { 2150 return ES3_extension(context, TExtension::ANGLE_shader_pixel_local_storage, 2151 IPIXELLOCALANGLE); 2152 } 2153 YY_BREAK 2154 case 130: 2155 YY_RULE_SETUP 2156 { 2157 return ES3_extension(context, TExtension::ANGLE_shader_pixel_local_storage, 2158 UPIXELLOCALANGLE); 2159 } 2160 YY_BREAK 2161 /* Reserved keywords for GLSL ES 3.00 that are not reserved for GLSL ES 1.00 */ 2162 case 131: 2163 case 132: 2164 case 133: 2165 case 134: 2166 case 135: 2167 case 136: 2168 case 137: 2169 case 138: 2170 case 139: 2171 case 140: 2172 case 141: 2173 case 142: 2174 case 143: 2175 case 144: 2176 case 145: 2177 case 146: 2178 case 147: 2179 case 148: 2180 case 149: 2181 case 150: 2182 case 151: 2183 case 152: 2184 case 153: 2185 case 154: 2186 YY_RULE_SETUP 2187 { 2188 if (context->getShaderVersion() < 300) 2189 { 2190 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 2191 return check_type(yyscanner); 2192 } 2193 return reserved_word(yyscanner); 2194 } 2195 YY_BREAK 2196 /* Reserved keywords in GLSL ES 1.00 that are not reserved in GLSL ES 3.00 */ 2197 case 155: 2198 YY_RULE_SETUP 2199 { 2200 if (context->getShaderVersion() >= 300) 2201 { 2202 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 2203 return check_type(yyscanner); 2204 } 2205 2206 return reserved_word(yyscanner); 2207 } 2208 YY_BREAK 2209 /* Reserved keywords */ 2210 case 156: 2211 case 157: 2212 case 158: 2213 case 159: 2214 case 160: 2215 case 161: 2216 case 162: 2217 case 163: 2218 case 164: 2219 case 165: 2220 case 166: 2221 case 167: 2222 case 168: 2223 case 169: 2224 case 170: 2225 case 171: 2226 case 172: 2227 case 173: 2228 case 174: 2229 case 175: 2230 case 176: 2231 case 177: 2232 case 178: 2233 case 179: 2234 case 180: 2235 case 181: 2236 case 182: 2237 case 183: 2238 case 184: 2239 case 185: 2240 case 186: 2241 case 187: 2242 case 188: 2243 case 189: 2244 case 190: 2245 case 191: 2246 case 192: 2247 case 193: 2248 case 194: 2249 case 195: 2250 YY_RULE_SETUP 2251 { 2252 return reserved_word(yyscanner); 2253 } 2254 YY_BREAK 2255 case 196: 2256 YY_RULE_SETUP 2257 { 2258 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 2259 return check_type(yyscanner); 2260 } 2261 YY_BREAK 2262 case 197: 2263 YY_RULE_SETUP 2264 { 2265 return int_constant(context); 2266 } 2267 YY_BREAK 2268 case 198: 2269 YY_RULE_SETUP 2270 { 2271 return int_constant(context); 2272 } 2273 YY_BREAK 2274 case 199: 2275 YY_RULE_SETUP 2276 { 2277 return int_constant(context); 2278 } 2279 YY_BREAK 2280 case 200: 2281 YY_RULE_SETUP 2282 { 2283 return uint_constant(context); 2284 } 2285 YY_BREAK 2286 case 201: 2287 YY_RULE_SETUP 2288 { 2289 return uint_constant(context); 2290 } 2291 YY_BREAK 2292 case 202: 2293 YY_RULE_SETUP 2294 { 2295 return uint_constant(context); 2296 } 2297 YY_BREAK 2298 case 203: 2299 YY_RULE_SETUP 2300 { 2301 return float_constant(yyscanner); 2302 } 2303 YY_BREAK 2304 case 204: 2305 YY_RULE_SETUP 2306 { 2307 return float_constant(yyscanner); 2308 } 2309 YY_BREAK 2310 case 205: 2311 YY_RULE_SETUP 2312 { 2313 return float_constant(yyscanner); 2314 } 2315 YY_BREAK 2316 case 206: 2317 YY_RULE_SETUP 2318 { 2319 return floatsuffix_check(context); 2320 } 2321 YY_BREAK 2322 case 207: 2323 YY_RULE_SETUP 2324 { 2325 return floatsuffix_check(context); 2326 } 2327 YY_BREAK 2328 case 208: 2329 YY_RULE_SETUP 2330 { 2331 return floatsuffix_check(context); 2332 } 2333 YY_BREAK 2334 case 209: 2335 YY_RULE_SETUP 2336 { 2337 return ADD_ASSIGN; 2338 } 2339 YY_BREAK 2340 case 210: 2341 YY_RULE_SETUP 2342 { 2343 return SUB_ASSIGN; 2344 } 2345 YY_BREAK 2346 case 211: 2347 YY_RULE_SETUP 2348 { 2349 return MUL_ASSIGN; 2350 } 2351 YY_BREAK 2352 case 212: 2353 YY_RULE_SETUP 2354 { 2355 return DIV_ASSIGN; 2356 } 2357 YY_BREAK 2358 case 213: 2359 YY_RULE_SETUP 2360 { 2361 return MOD_ASSIGN; 2362 } 2363 YY_BREAK 2364 case 214: 2365 YY_RULE_SETUP 2366 { 2367 return LEFT_ASSIGN; 2368 } 2369 YY_BREAK 2370 case 215: 2371 YY_RULE_SETUP 2372 { 2373 return RIGHT_ASSIGN; 2374 } 2375 YY_BREAK 2376 case 216: 2377 YY_RULE_SETUP 2378 { 2379 return AND_ASSIGN; 2380 } 2381 YY_BREAK 2382 case 217: 2383 YY_RULE_SETUP 2384 { 2385 return XOR_ASSIGN; 2386 } 2387 YY_BREAK 2388 case 218: 2389 YY_RULE_SETUP 2390 { 2391 return OR_ASSIGN; 2392 } 2393 YY_BREAK 2394 case 219: 2395 YY_RULE_SETUP 2396 { 2397 return INC_OP; 2398 } 2399 YY_BREAK 2400 case 220: 2401 YY_RULE_SETUP 2402 { 2403 return DEC_OP; 2404 } 2405 YY_BREAK 2406 case 221: 2407 YY_RULE_SETUP 2408 { 2409 return AND_OP; 2410 } 2411 YY_BREAK 2412 case 222: 2413 YY_RULE_SETUP 2414 { 2415 return OR_OP; 2416 } 2417 YY_BREAK 2418 case 223: 2419 YY_RULE_SETUP 2420 { 2421 return XOR_OP; 2422 } 2423 YY_BREAK 2424 case 224: 2425 YY_RULE_SETUP 2426 { 2427 return LE_OP; 2428 } 2429 YY_BREAK 2430 case 225: 2431 YY_RULE_SETUP 2432 { 2433 return GE_OP; 2434 } 2435 YY_BREAK 2436 case 226: 2437 YY_RULE_SETUP 2438 { 2439 return EQ_OP; 2440 } 2441 YY_BREAK 2442 case 227: 2443 YY_RULE_SETUP 2444 { 2445 return NE_OP; 2446 } 2447 YY_BREAK 2448 case 228: 2449 YY_RULE_SETUP 2450 { 2451 return LEFT_OP; 2452 } 2453 YY_BREAK 2454 case 229: 2455 YY_RULE_SETUP 2456 { 2457 return RIGHT_OP; 2458 } 2459 YY_BREAK 2460 case 230: 2461 YY_RULE_SETUP 2462 { 2463 return SEMICOLON; 2464 } 2465 YY_BREAK 2466 case 231: 2467 YY_RULE_SETUP 2468 { 2469 return LEFT_BRACE; 2470 } 2471 YY_BREAK 2472 case 232: 2473 YY_RULE_SETUP 2474 { 2475 return RIGHT_BRACE; 2476 } 2477 YY_BREAK 2478 case 233: 2479 YY_RULE_SETUP 2480 { 2481 return COMMA; 2482 } 2483 YY_BREAK 2484 case 234: 2485 YY_RULE_SETUP 2486 { 2487 return COLON; 2488 } 2489 YY_BREAK 2490 case 235: 2491 YY_RULE_SETUP 2492 { 2493 return EQUAL; 2494 } 2495 YY_BREAK 2496 case 236: 2497 YY_RULE_SETUP 2498 { 2499 return LEFT_PAREN; 2500 } 2501 YY_BREAK 2502 case 237: 2503 YY_RULE_SETUP 2504 { 2505 return RIGHT_PAREN; 2506 } 2507 YY_BREAK 2508 case 238: 2509 YY_RULE_SETUP 2510 { 2511 return LEFT_BRACKET; 2512 } 2513 YY_BREAK 2514 case 239: 2515 YY_RULE_SETUP 2516 { 2517 return RIGHT_BRACKET; 2518 } 2519 YY_BREAK 2520 case 240: 2521 YY_RULE_SETUP 2522 { 2523 BEGIN(FIELDS); 2524 return DOT; 2525 } 2526 YY_BREAK 2527 case 241: 2528 YY_RULE_SETUP 2529 { 2530 return BANG; 2531 } 2532 YY_BREAK 2533 case 242: 2534 YY_RULE_SETUP 2535 { 2536 return DASH; 2537 } 2538 YY_BREAK 2539 case 243: 2540 YY_RULE_SETUP 2541 { 2542 return TILDE; 2543 } 2544 YY_BREAK 2545 case 244: 2546 YY_RULE_SETUP 2547 { 2548 return PLUS; 2549 } 2550 YY_BREAK 2551 case 245: 2552 YY_RULE_SETUP 2553 { 2554 return STAR; 2555 } 2556 YY_BREAK 2557 case 246: 2558 YY_RULE_SETUP 2559 { 2560 return SLASH; 2561 } 2562 YY_BREAK 2563 case 247: 2564 YY_RULE_SETUP 2565 { 2566 return PERCENT; 2567 } 2568 YY_BREAK 2569 case 248: 2570 YY_RULE_SETUP 2571 { 2572 return LEFT_ANGLE; 2573 } 2574 YY_BREAK 2575 case 249: 2576 YY_RULE_SETUP 2577 { 2578 return RIGHT_ANGLE; 2579 } 2580 YY_BREAK 2581 case 250: 2582 YY_RULE_SETUP 2583 { 2584 return VERTICAL_BAR; 2585 } 2586 YY_BREAK 2587 case 251: 2588 YY_RULE_SETUP 2589 { 2590 return CARET; 2591 } 2592 YY_BREAK 2593 case 252: 2594 YY_RULE_SETUP 2595 { 2596 return AMPERSAND; 2597 } 2598 YY_BREAK 2599 case 253: 2600 YY_RULE_SETUP 2601 { 2602 return QUESTION; 2603 } 2604 YY_BREAK 2605 case 254: 2606 YY_RULE_SETUP 2607 { 2608 BEGIN(INITIAL); 2609 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 2610 return FIELD_SELECTION; 2611 } 2612 YY_BREAK 2613 case 255: 2614 YY_RULE_SETUP {} 2615 YY_BREAK 2616 case 256: 2617 YY_RULE_SETUP 2618 { 2619 yyextra->error(*yylloc, "Illegal character at fieldname start", yytext); 2620 return 0; 2621 } 2622 YY_BREAK 2623 case 257: 2624 /* rule 257 can match eol */ 2625 YY_RULE_SETUP {} 2626 YY_BREAK 2627 case YY_STATE_EOF(INITIAL): 2628 case YY_STATE_EOF(FIELDS): 2629 { 2630 yyterminate(); 2631 } 2632 YY_BREAK 2633 case 258: 2634 YY_RULE_SETUP 2635 { 2636 assert(false); 2637 return 0; 2638 } 2639 YY_BREAK 2640 case 259: 2641 YY_RULE_SETUP 2642 ECHO; 2643 YY_BREAK 2644 2645 case YY_END_OF_BUFFER: 2646 { 2647 /* Amount of text matched not including the EOB char. */ 2648 int yy_amount_of_matched_text = (int)(yy_cp - yyg->yytext_ptr) - 1; 2649 2650 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 2651 *yy_cp = yyg->yy_hold_char; 2652 YY_RESTORE_YY_MORE_OFFSET 2653 2654 if (YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW) 2655 { 2656 /* We're scanning a new file or input source. It's 2657 * possible that this happened because the user 2658 * just pointed yyin at a new source and called 2659 * yylex(). If so, then we have to assure 2660 * consistency between YY_CURRENT_BUFFER and our 2661 * globals. Here is the right place to do so, because 2662 * this is the first action (other than possibly a 2663 * back-up) that will match for the new input source. 2664 */ 2665 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 2666 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; 2667 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; 2668 } 2669 2670 /* Note that here we test for yy_c_buf_p "<=" to the position 2671 * of the first EOB in the buffer, since yy_c_buf_p will 2672 * already have been incremented past the NUL character 2673 * (since all states make transitions on EOB to the 2674 * end-of-buffer state). Contrast this with the test 2675 * in input(). 2676 */ 2677 if (yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]) 2678 { /* This was really a NUL. */ 2679 yy_state_type yy_next_state; 2680 2681 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; 2682 2683 yy_current_state = yy_get_previous_state(yyscanner); 2684 2685 /* Okay, we're now positioned to make the NUL 2686 * transition. We couldn't have 2687 * yy_get_previous_state() go ahead and do it 2688 * for us because it doesn't know how to deal 2689 * with the possibility of jamming (and we don't 2690 * want to build jamming into it because then it 2691 * will run more slowly). 2692 */ 2693 2694 yy_next_state = yy_try_NUL_trans(yy_current_state, yyscanner); 2695 2696 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; 2697 2698 if (yy_next_state) 2699 { 2700 /* Consume the NUL. */ 2701 yy_cp = ++yyg->yy_c_buf_p; 2702 yy_current_state = yy_next_state; 2703 goto yy_match; 2704 } 2705 2706 else 2707 { 2708 yy_cp = yyg->yy_last_accepting_cpos; 2709 yy_current_state = yyg->yy_last_accepting_state; 2710 goto yy_find_action; 2711 } 2712 } 2713 2714 else 2715 switch (yy_get_next_buffer(yyscanner)) 2716 { 2717 case EOB_ACT_END_OF_FILE: 2718 { 2719 yyg->yy_did_buffer_switch_on_eof = 0; 2720 2721 if (yywrap(yyscanner)) 2722 { 2723 /* Note: because we've taken care in 2724 * yy_get_next_buffer() to have set up 2725 * yytext, we can now set up 2726 * yy_c_buf_p so that if some total 2727 * hoser (like flex itself) wants to 2728 * call the scanner after we return the 2729 * YY_NULL, it'll still work - another 2730 * YY_NULL will get returned. 2731 */ 2732 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; 2733 2734 yy_act = YY_STATE_EOF(YY_START); 2735 goto do_action; 2736 } 2737 2738 else 2739 { 2740 if (!yyg->yy_did_buffer_switch_on_eof) 2741 YY_NEW_FILE; 2742 } 2743 break; 2744 } 2745 2746 case EOB_ACT_CONTINUE_SCAN: 2747 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; 2748 2749 yy_current_state = yy_get_previous_state(yyscanner); 2750 2751 yy_cp = yyg->yy_c_buf_p; 2752 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; 2753 goto yy_match; 2754 2755 case EOB_ACT_LAST_MATCH: 2756 yyg->yy_c_buf_p = 2757 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; 2758 2759 yy_current_state = yy_get_previous_state(yyscanner); 2760 2761 yy_cp = yyg->yy_c_buf_p; 2762 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; 2763 goto yy_find_action; 2764 } 2765 break; 2766 } 2767 2768 default: 2769 YY_FATAL_ERROR("fatal flex scanner internal error--no action found"); 2770 } /* end of action switch */ 2771 } /* end of scanning one token */ 2772 } /* end of user's declarations */ 2773 } /* end of yylex */ 2774 2775 /* yy_get_next_buffer - try to read in a new buffer 2776 * 2777 * Returns a code representing an action: 2778 * EOB_ACT_LAST_MATCH - 2779 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 2780 * EOB_ACT_END_OF_FILE - end of file 2781 */ 2782 static int yy_get_next_buffer(yyscan_t yyscanner) 2783 { 2784 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 2785 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; 2786 char *source = yyg->yytext_ptr; 2787 int number_to_move, i; 2788 int ret_val; 2789 2790 if (yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1]) 2791 YY_FATAL_ERROR("fatal flex scanner internal error--end of buffer missed"); 2792 2793 if (YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0) 2794 { /* Don't try to fill the buffer, so this is an EOF. */ 2795 if (yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1) 2796 { 2797 /* We matched a single character, the EOB, so 2798 * treat this as a final EOF. 2799 */ 2800 return EOB_ACT_END_OF_FILE; 2801 } 2802 2803 else 2804 { 2805 /* We matched some text prior to the EOB, first 2806 * process it. 2807 */ 2808 return EOB_ACT_LAST_MATCH; 2809 } 2810 } 2811 2812 /* Try to read more data. */ 2813 2814 /* First move last chars to start of buffer. */ 2815 number_to_move = (int)(yyg->yy_c_buf_p - yyg->yytext_ptr - 1); 2816 2817 for (i = 0; i < number_to_move; ++i) 2818 *(dest++) = *(source++); 2819 2820 if (YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING) 2821 /* don't do the read, it's not guaranteed to return an EOF, 2822 * just force an EOF 2823 */ 2824 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; 2825 2826 else 2827 { 2828 int num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 2829 2830 while (num_to_read <= 0) 2831 { /* Not enough room in the buffer - grow it. */ 2832 2833 /* just a shorter name for the current buffer */ 2834 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; 2835 2836 int yy_c_buf_p_offset = (int)(yyg->yy_c_buf_p - b->yy_ch_buf); 2837 2838 if (b->yy_is_our_buffer) 2839 { 2840 int new_size = b->yy_buf_size * 2; 2841 2842 if (new_size <= 0) 2843 b->yy_buf_size += b->yy_buf_size / 8; 2844 else 2845 b->yy_buf_size *= 2; 2846 2847 b->yy_ch_buf = (char *) 2848 /* Include room in for 2 EOB chars. */ 2849 yyrealloc((void *)b->yy_ch_buf, (yy_size_t)(b->yy_buf_size + 2), yyscanner); 2850 } 2851 else 2852 /* Can't grow it, we don't own it. */ 2853 b->yy_ch_buf = NULL; 2854 2855 if (!b->yy_ch_buf) 2856 YY_FATAL_ERROR("fatal error - scanner input buffer overflow"); 2857 2858 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 2859 2860 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 2861 } 2862 2863 if (num_to_read > YY_READ_BUF_SIZE) 2864 num_to_read = YY_READ_BUF_SIZE; 2865 2866 /* Read in more data. */ 2867 yy_size_t ret = 0; 2868 YY_INPUT((&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ret, num_to_read); 2869 yyg->yy_n_chars = static_cast<int>(ret); 2870 2871 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; 2872 } 2873 2874 if (yyg->yy_n_chars == 0) 2875 { 2876 if (number_to_move == YY_MORE_ADJ) 2877 { 2878 ret_val = EOB_ACT_END_OF_FILE; 2879 yyrestart(yyin, yyscanner); 2880 } 2881 2882 else 2883 { 2884 ret_val = EOB_ACT_LAST_MATCH; 2885 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_EOF_PENDING; 2886 } 2887 } 2888 2889 else 2890 ret_val = EOB_ACT_CONTINUE_SCAN; 2891 2892 if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) 2893 { 2894 /* Extend the array by 50%, plus the number we really need. */ 2895 int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 2896 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *)yyrealloc( 2897 (void *)YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t)new_size, yyscanner); 2898 if (!YY_CURRENT_BUFFER_LVALUE->yy_ch_buf) 2899 YY_FATAL_ERROR("out of dynamic memory in yy_get_next_buffer()"); 2900 /* "- 2" to take care of EOB's */ 2901 YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int)(new_size - 2); 2902 } 2903 2904 yyg->yy_n_chars += number_to_move; 2905 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; 2906 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; 2907 2908 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; 2909 2910 return ret_val; 2911 } 2912 2913 /* yy_get_previous_state - get the state just before the EOB char was reached */ 2914 2915 static yy_state_type yy_get_previous_state(yyscan_t yyscanner) 2916 { 2917 yy_state_type yy_current_state; 2918 char *yy_cp; 2919 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 2920 2921 yy_current_state = yyg->yy_start; 2922 2923 for (yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp) 2924 { 2925 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 2926 if (yy_accept[yy_current_state]) 2927 { 2928 yyg->yy_last_accepting_state = yy_current_state; 2929 yyg->yy_last_accepting_cpos = yy_cp; 2930 } 2931 while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) 2932 { 2933 yy_current_state = (int)yy_def[yy_current_state]; 2934 if (yy_current_state >= 982) 2935 yy_c = yy_meta[yy_c]; 2936 } 2937 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 2938 } 2939 2940 return yy_current_state; 2941 } 2942 2943 /* yy_try_NUL_trans - try to make a transition on the NUL character 2944 * 2945 * synopsis 2946 * next_state = yy_try_NUL_trans( current_state ); 2947 */ 2948 static yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state, yyscan_t yyscanner) 2949 { 2950 int yy_is_jam; 2951 struct yyguts_t *yyg = 2952 (struct yyguts_t *)yyscanner; /* This var may be unused depending upon options. */ 2953 char *yy_cp = yyg->yy_c_buf_p; 2954 2955 YY_CHAR yy_c = 1; 2956 if (yy_accept[yy_current_state]) 2957 { 2958 yyg->yy_last_accepting_state = yy_current_state; 2959 yyg->yy_last_accepting_cpos = yy_cp; 2960 } 2961 while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) 2962 { 2963 yy_current_state = (int)yy_def[yy_current_state]; 2964 if (yy_current_state >= 982) 2965 yy_c = yy_meta[yy_c]; 2966 } 2967 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 2968 yy_is_jam = (yy_current_state == 981); 2969 2970 (void)yyg; 2971 return yy_is_jam ? 0 : yy_current_state; 2972 } 2973 2974 #ifndef YY_NO_UNPUT 2975 2976 #endif 2977 2978 #ifndef YY_NO_INPUT 2979 # ifdef __cplusplus 2980 static int yyinput(yyscan_t yyscanner) 2981 # else 2982 static int input(yyscan_t yyscanner) 2983 # endif 2984 2985 { 2986 int c; 2987 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 2988 2989 *yyg->yy_c_buf_p = yyg->yy_hold_char; 2990 2991 if (*yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR) 2992 { 2993 /* yy_c_buf_p now points to the character we want to return. 2994 * If this occurs *before* the EOB characters, then it's a 2995 * valid NUL; if not, then we've hit the end of the buffer. 2996 */ 2997 if (yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]) 2998 /* This was really a NUL. */ 2999 *yyg->yy_c_buf_p = '\0'; 3000 3001 else 3002 { /* need more input */ 3003 int offset = (int)(yyg->yy_c_buf_p - yyg->yytext_ptr); 3004 ++yyg->yy_c_buf_p; 3005 3006 switch (yy_get_next_buffer(yyscanner)) 3007 { 3008 case EOB_ACT_LAST_MATCH: 3009 /* This happens because yy_g_n_b() 3010 * sees that we've accumulated a 3011 * token and flags that we need to 3012 * try matching the token before 3013 * proceeding. But for input(), 3014 * there's no matching to consider. 3015 * So convert the EOB_ACT_LAST_MATCH 3016 * to EOB_ACT_END_OF_FILE. 3017 */ 3018 3019 /* Reset buffer status. */ 3020 yyrestart(yyin, yyscanner); 3021 3022 /*FALLTHROUGH*/ 3023 3024 case EOB_ACT_END_OF_FILE: 3025 { 3026 if (yywrap(yyscanner)) 3027 return 0; 3028 3029 if (!yyg->yy_did_buffer_switch_on_eof) 3030 YY_NEW_FILE; 3031 # ifdef __cplusplus 3032 return yyinput(yyscanner); 3033 # else 3034 return input(yyscanner); 3035 # endif 3036 } 3037 3038 case EOB_ACT_CONTINUE_SCAN: 3039 yyg->yy_c_buf_p = yyg->yytext_ptr + offset; 3040 break; 3041 } 3042 } 3043 } 3044 3045 c = *(unsigned char *)yyg->yy_c_buf_p; /* cast for 8-bit char's */ 3046 *yyg->yy_c_buf_p = '\0'; /* preserve yytext */ 3047 yyg->yy_hold_char = *++yyg->yy_c_buf_p; 3048 3049 if (c == '\n') 3050 3051 do 3052 { 3053 yylineno++; 3054 yycolumn = 0; 3055 } while (0); 3056 3057 return c; 3058 } 3059 #endif /* ifndef YY_NO_INPUT */ 3060 3061 /** Immediately switch to a different input stream. 3062 * @param input_file A readable stream. 3063 * @param yyscanner The scanner object. 3064 * @note This function does not reset the start condition to @c INITIAL . 3065 */ 3066 void yyrestart(FILE *input_file, yyscan_t yyscanner) 3067 { 3068 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3069 3070 if (!YY_CURRENT_BUFFER) 3071 { 3072 yyensure_buffer_stack(yyscanner); 3073 YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin, YY_BUF_SIZE, yyscanner); 3074 } 3075 3076 yy_init_buffer(YY_CURRENT_BUFFER, input_file, yyscanner); 3077 yy_load_buffer_state(yyscanner); 3078 } 3079 3080 /** Switch to a different input buffer. 3081 * @param new_buffer The new input buffer. 3082 * @param yyscanner The scanner object. 3083 */ 3084 void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer, yyscan_t yyscanner) 3085 { 3086 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3087 3088 /* TODO. We should be able to replace this entire function body 3089 * with 3090 * yypop_buffer_state(); 3091 * yypush_buffer_state(new_buffer); 3092 */ 3093 yyensure_buffer_stack(yyscanner); 3094 if (YY_CURRENT_BUFFER == new_buffer) 3095 return; 3096 3097 if (YY_CURRENT_BUFFER) 3098 { 3099 /* Flush out information for old buffer. */ 3100 *yyg->yy_c_buf_p = yyg->yy_hold_char; 3101 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; 3102 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; 3103 } 3104 3105 YY_CURRENT_BUFFER_LVALUE = new_buffer; 3106 yy_load_buffer_state(yyscanner); 3107 3108 /* We don't actually know whether we did this switch during 3109 * EOF (yywrap()) processing, but the only time this flag 3110 * is looked at is after yywrap() is called, so it's safe 3111 * to go ahead and always set it. 3112 */ 3113 yyg->yy_did_buffer_switch_on_eof = 1; 3114 } 3115 3116 static void yy_load_buffer_state(yyscan_t yyscanner) 3117 { 3118 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3119 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 3120 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; 3121 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; 3122 yyg->yy_hold_char = *yyg->yy_c_buf_p; 3123 } 3124 3125 /** Allocate and initialize an input buffer state. 3126 * @param file A readable stream. 3127 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. 3128 * @param yyscanner The scanner object. 3129 * @return the allocated buffer state. 3130 */ 3131 YY_BUFFER_STATE yy_create_buffer(FILE *file, int size, yyscan_t yyscanner) 3132 { 3133 YY_BUFFER_STATE b; 3134 3135 b = (YY_BUFFER_STATE)yyalloc(sizeof(struct yy_buffer_state), yyscanner); 3136 if (!b) 3137 YY_FATAL_ERROR("out of dynamic memory in yy_create_buffer()"); 3138 3139 b->yy_buf_size = size; 3140 3141 /* yy_ch_buf has to be 2 characters longer than the size given because 3142 * we need to put in 2 end-of-buffer characters. 3143 */ 3144 b->yy_ch_buf = (char *)yyalloc((yy_size_t)(b->yy_buf_size + 2), yyscanner); 3145 if (!b->yy_ch_buf) 3146 YY_FATAL_ERROR("out of dynamic memory in yy_create_buffer()"); 3147 3148 b->yy_is_our_buffer = 1; 3149 3150 yy_init_buffer(b, file, yyscanner); 3151 3152 return b; 3153 } 3154 3155 /** Destroy the buffer. 3156 * @param b a buffer created with yy_create_buffer() 3157 * @param yyscanner The scanner object. 3158 */ 3159 void yy_delete_buffer(YY_BUFFER_STATE b, yyscan_t yyscanner) 3160 { 3161 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3162 3163 if (!b) 3164 return; 3165 3166 if (b == YY_CURRENT_BUFFER) /* Not sure if we should pop here. */ 3167 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE)0; 3168 3169 if (b->yy_is_our_buffer) 3170 yyfree((void *)b->yy_ch_buf, yyscanner); 3171 3172 yyfree((void *)b, yyscanner); 3173 } 3174 3175 /* Initializes or reinitializes a buffer. 3176 * This function is sometimes called more than once on the same buffer, 3177 * such as during a yyrestart() or at EOF. 3178 */ 3179 static void yy_init_buffer(YY_BUFFER_STATE b, FILE *file, yyscan_t yyscanner) 3180 3181 { 3182 int oerrno = errno; 3183 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3184 3185 yy_flush_buffer(b, yyscanner); 3186 3187 b->yy_input_file = file; 3188 b->yy_fill_buffer = 1; 3189 3190 /* If b is the current buffer, then yy_init_buffer was _probably_ 3191 * called from yyrestart() or through yy_get_next_buffer. 3192 * In that case, we don't want to reset the lineno or column. 3193 */ 3194 if (b != YY_CURRENT_BUFFER) 3195 { 3196 b->yy_bs_lineno = 1; 3197 b->yy_bs_column = 0; 3198 } 3199 3200 b->yy_is_interactive = 0; 3201 3202 errno = oerrno; 3203 } 3204 3205 /** Discard all buffered characters. On the next scan, YY_INPUT will be called. 3206 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. 3207 * @param yyscanner The scanner object. 3208 */ 3209 void yy_flush_buffer(YY_BUFFER_STATE b, yyscan_t yyscanner) 3210 { 3211 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3212 if (!b) 3213 return; 3214 3215 b->yy_n_chars = 0; 3216 3217 /* We always need two end-of-buffer characters. The first causes 3218 * a transition to the end-of-buffer state. The second causes 3219 * a jam in that state. 3220 */ 3221 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 3222 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 3223 3224 b->yy_buf_pos = &b->yy_ch_buf[0]; 3225 3226 b->yy_at_bol = 1; 3227 b->yy_buffer_status = YY_BUFFER_NEW; 3228 3229 if (b == YY_CURRENT_BUFFER) 3230 yy_load_buffer_state(yyscanner); 3231 } 3232 3233 /** Pushes the new state onto the stack. The new state becomes 3234 * the current state. This function will allocate the stack 3235 * if necessary. 3236 * @param new_buffer The new state. 3237 * @param yyscanner The scanner object. 3238 */ 3239 void yypush_buffer_state(YY_BUFFER_STATE new_buffer, yyscan_t yyscanner) 3240 { 3241 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3242 if (new_buffer == NULL) 3243 return; 3244 3245 yyensure_buffer_stack(yyscanner); 3246 3247 /* This block is copied from yy_switch_to_buffer. */ 3248 if (YY_CURRENT_BUFFER) 3249 { 3250 /* Flush out information for old buffer. */ 3251 *yyg->yy_c_buf_p = yyg->yy_hold_char; 3252 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; 3253 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; 3254 } 3255 3256 /* Only push if top exists. Otherwise, replace top. */ 3257 if (YY_CURRENT_BUFFER) 3258 yyg->yy_buffer_stack_top++; 3259 YY_CURRENT_BUFFER_LVALUE = new_buffer; 3260 3261 /* copied from yy_switch_to_buffer. */ 3262 yy_load_buffer_state(yyscanner); 3263 yyg->yy_did_buffer_switch_on_eof = 1; 3264 } 3265 3266 /** Removes and deletes the top of the stack, if present. 3267 * The next element becomes the new top. 3268 * @param yyscanner The scanner object. 3269 */ 3270 void yypop_buffer_state(yyscan_t yyscanner) 3271 { 3272 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3273 if (!YY_CURRENT_BUFFER) 3274 return; 3275 3276 yy_delete_buffer(YY_CURRENT_BUFFER, yyscanner); 3277 YY_CURRENT_BUFFER_LVALUE = NULL; 3278 if (yyg->yy_buffer_stack_top > 0) 3279 --yyg->yy_buffer_stack_top; 3280 3281 if (YY_CURRENT_BUFFER) 3282 { 3283 yy_load_buffer_state(yyscanner); 3284 yyg->yy_did_buffer_switch_on_eof = 1; 3285 } 3286 } 3287 3288 /* Allocates the stack if it does not exist. 3289 * Guarantees space for at least one push. 3290 */ 3291 static void yyensure_buffer_stack(yyscan_t yyscanner) 3292 { 3293 yy_size_t num_to_alloc; 3294 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3295 3296 if (!yyg->yy_buffer_stack) 3297 { 3298 3299 /* First allocation is just for 2 elements, since we don't know if this 3300 * scanner will even need a stack. We use 2 instead of 1 to avoid an 3301 * immediate realloc on the next call. 3302 */ 3303 num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 3304 yyg->yy_buffer_stack = (struct yy_buffer_state **)yyalloc( 3305 num_to_alloc * sizeof(struct yy_buffer_state *), yyscanner); 3306 if (!yyg->yy_buffer_stack) 3307 YY_FATAL_ERROR("out of dynamic memory in yyensure_buffer_stack()"); 3308 3309 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state *)); 3310 3311 yyg->yy_buffer_stack_max = num_to_alloc; 3312 yyg->yy_buffer_stack_top = 0; 3313 return; 3314 } 3315 3316 if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1) 3317 { 3318 3319 /* Increase the buffer to prepare for a possible push. */ 3320 yy_size_t grow_size = 8 /* arbitrary grow size */; 3321 3322 num_to_alloc = yyg->yy_buffer_stack_max + grow_size; 3323 yyg->yy_buffer_stack = (struct yy_buffer_state **)yyrealloc( 3324 yyg->yy_buffer_stack, num_to_alloc * sizeof(struct yy_buffer_state *), yyscanner); 3325 if (!yyg->yy_buffer_stack) 3326 YY_FATAL_ERROR("out of dynamic memory in yyensure_buffer_stack()"); 3327 3328 /* zero only the new slots.*/ 3329 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, 3330 grow_size * sizeof(struct yy_buffer_state *)); 3331 yyg->yy_buffer_stack_max = num_to_alloc; 3332 } 3333 } 3334 3335 /** Setup the input buffer state to scan directly from a user-specified character buffer. 3336 * @param base the character buffer 3337 * @param size the size in bytes of the character buffer 3338 * @param yyscanner The scanner object. 3339 * @return the newly allocated buffer state object. 3340 */ 3341 YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size, yyscan_t yyscanner) 3342 { 3343 YY_BUFFER_STATE b; 3344 3345 if (size < 2 || base[size - 2] != YY_END_OF_BUFFER_CHAR || 3346 base[size - 1] != YY_END_OF_BUFFER_CHAR) 3347 /* They forgot to leave room for the EOB's. */ 3348 return NULL; 3349 3350 b = (YY_BUFFER_STATE)yyalloc(sizeof(struct yy_buffer_state), yyscanner); 3351 if (!b) 3352 YY_FATAL_ERROR("out of dynamic memory in yy_scan_buffer()"); 3353 3354 b->yy_buf_size = (int)(size - 2); /* "- 2" to take care of EOB's */ 3355 b->yy_buf_pos = b->yy_ch_buf = base; 3356 b->yy_is_our_buffer = 0; 3357 b->yy_input_file = NULL; 3358 b->yy_n_chars = b->yy_buf_size; 3359 b->yy_is_interactive = 0; 3360 b->yy_at_bol = 1; 3361 b->yy_fill_buffer = 0; 3362 b->yy_buffer_status = YY_BUFFER_NEW; 3363 3364 yy_switch_to_buffer(b, yyscanner); 3365 3366 return b; 3367 } 3368 3369 /** Setup the input buffer state to scan a string. The next call to yylex() will 3370 * scan from a @e copy of @a str. 3371 * @param yystr a NUL-terminated string to scan 3372 * @param yyscanner The scanner object. 3373 * @return the newly allocated buffer state object. 3374 * @note If you want to scan bytes that may contain NUL values, then use 3375 * yy_scan_bytes() instead. 3376 */ 3377 YY_BUFFER_STATE yy_scan_string(const char *yystr, yyscan_t yyscanner) 3378 { 3379 3380 return yy_scan_bytes(yystr, (int)strlen(yystr), yyscanner); 3381 } 3382 3383 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will 3384 * scan from a @e copy of @a bytes. 3385 * @param yybytes the byte buffer to scan 3386 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. 3387 * @param yyscanner The scanner object. 3388 * @return the newly allocated buffer state object. 3389 */ 3390 YY_BUFFER_STATE yy_scan_bytes(const char *yybytes, int _yybytes_len, yyscan_t yyscanner) 3391 { 3392 YY_BUFFER_STATE b; 3393 char *buf; 3394 yy_size_t n; 3395 int i; 3396 3397 /* Get memory for full buffer, including space for trailing EOB's. */ 3398 n = (yy_size_t)(_yybytes_len + 2); 3399 buf = (char *)yyalloc(n, yyscanner); 3400 if (!buf) 3401 YY_FATAL_ERROR("out of dynamic memory in yy_scan_bytes()"); 3402 3403 for (i = 0; i < _yybytes_len; ++i) 3404 buf[i] = yybytes[i]; 3405 3406 buf[_yybytes_len] = buf[_yybytes_len + 1] = YY_END_OF_BUFFER_CHAR; 3407 3408 b = yy_scan_buffer(buf, n, yyscanner); 3409 if (!b) 3410 YY_FATAL_ERROR("bad buffer in yy_scan_bytes()"); 3411 3412 /* It's okay to grow etc. this buffer, and we should throw it 3413 * away when we're done. 3414 */ 3415 b->yy_is_our_buffer = 1; 3416 3417 return b; 3418 } 3419 3420 #ifndef YY_EXIT_FAILURE 3421 # define YY_EXIT_FAILURE 2 3422 #endif 3423 3424 static void yynoreturn yy_fatal_error(const char *msg, yyscan_t yyscanner) 3425 { 3426 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3427 (void)yyg; 3428 fprintf(stderr, "%s\n", msg); 3429 exit(YY_EXIT_FAILURE); 3430 } 3431 3432 /* Redefine yyless() so it works in section 3 code. */ 3433 3434 #undef yyless 3435 #define yyless(n) \ 3436 do \ 3437 { \ 3438 /* Undo effects of setting up yytext. */ \ 3439 int yyless_macro_arg = (n); \ 3440 YY_LESS_LINENO(yyless_macro_arg); \ 3441 yytext[yyleng] = yyg->yy_hold_char; \ 3442 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \ 3443 yyg->yy_hold_char = *yyg->yy_c_buf_p; \ 3444 *yyg->yy_c_buf_p = '\0'; \ 3445 yyleng = yyless_macro_arg; \ 3446 } while (0) 3447 3448 /* Accessor methods (get/set functions) to struct members. */ 3449 3450 /** Get the user-defined data for this scanner. 3451 * @param yyscanner The scanner object. 3452 */ 3453 YY_EXTRA_TYPE yyget_extra(yyscan_t yyscanner) 3454 { 3455 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3456 return yyextra; 3457 } 3458 3459 /** Get the current line number. 3460 * @param yyscanner The scanner object. 3461 */ 3462 int yyget_lineno(yyscan_t yyscanner) 3463 { 3464 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3465 3466 if (!YY_CURRENT_BUFFER) 3467 return 0; 3468 3469 return yylineno; 3470 } 3471 3472 /** Get the current column number. 3473 * @param yyscanner The scanner object. 3474 */ 3475 int yyget_column(yyscan_t yyscanner) 3476 { 3477 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3478 3479 if (!YY_CURRENT_BUFFER) 3480 return 0; 3481 3482 return yycolumn; 3483 } 3484 3485 /** Get the input stream. 3486 * @param yyscanner The scanner object. 3487 */ 3488 FILE *yyget_in(yyscan_t yyscanner) 3489 { 3490 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3491 return yyin; 3492 } 3493 3494 /** Get the output stream. 3495 * @param yyscanner The scanner object. 3496 */ 3497 FILE *yyget_out(yyscan_t yyscanner) 3498 { 3499 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3500 return yyout; 3501 } 3502 3503 /** Get the length of the current token. 3504 * @param yyscanner The scanner object. 3505 */ 3506 int yyget_leng(yyscan_t yyscanner) 3507 { 3508 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3509 return yyleng; 3510 } 3511 3512 /** Get the current token. 3513 * @param yyscanner The scanner object. 3514 */ 3515 3516 char *yyget_text(yyscan_t yyscanner) 3517 { 3518 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3519 return yytext; 3520 } 3521 3522 /** Set the user-defined data. This data is never touched by the scanner. 3523 * @param user_defined The data to be associated with this scanner. 3524 * @param yyscanner The scanner object. 3525 */ 3526 void yyset_extra(YY_EXTRA_TYPE user_defined, yyscan_t yyscanner) 3527 { 3528 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3529 yyextra = user_defined; 3530 } 3531 3532 /** Set the current line number. 3533 * @param _line_number line number 3534 * @param yyscanner The scanner object. 3535 */ 3536 void yyset_lineno(int _line_number, yyscan_t yyscanner) 3537 { 3538 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3539 3540 /* lineno is only valid if an input buffer exists. */ 3541 if (!YY_CURRENT_BUFFER) 3542 YY_FATAL_ERROR("yyset_lineno called with no buffer"); 3543 3544 yylineno = _line_number; 3545 } 3546 3547 /** Set the current column. 3548 * @param _column_no column number 3549 * @param yyscanner The scanner object. 3550 */ 3551 void yyset_column(int _column_no, yyscan_t yyscanner) 3552 { 3553 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3554 3555 /* column is only valid if an input buffer exists. */ 3556 if (!YY_CURRENT_BUFFER) 3557 YY_FATAL_ERROR("yyset_column called with no buffer"); 3558 3559 yycolumn = _column_no; 3560 } 3561 3562 /** Set the input stream. This does not discard the current 3563 * input buffer. 3564 * @param _in_str A readable stream. 3565 * @param yyscanner The scanner object. 3566 * @see yy_switch_to_buffer 3567 */ 3568 void yyset_in(FILE *_in_str, yyscan_t yyscanner) 3569 { 3570 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3571 yyin = _in_str; 3572 } 3573 3574 void yyset_out(FILE *_out_str, yyscan_t yyscanner) 3575 { 3576 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3577 yyout = _out_str; 3578 } 3579 3580 int yyget_debug(yyscan_t yyscanner) 3581 { 3582 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3583 return yy_flex_debug; 3584 } 3585 3586 void yyset_debug(int _bdebug, yyscan_t yyscanner) 3587 { 3588 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3589 yy_flex_debug = _bdebug; 3590 } 3591 3592 /* Accessor methods for yylval and yylloc */ 3593 3594 YYSTYPE *yyget_lval(yyscan_t yyscanner) 3595 { 3596 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3597 return yylval; 3598 } 3599 3600 void yyset_lval(YYSTYPE *yylval_param, yyscan_t yyscanner) 3601 { 3602 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3603 yylval = yylval_param; 3604 } 3605 3606 YYLTYPE *yyget_lloc(yyscan_t yyscanner) 3607 { 3608 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3609 return yylloc; 3610 } 3611 3612 void yyset_lloc(YYLTYPE *yylloc_param, yyscan_t yyscanner) 3613 { 3614 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3615 yylloc = yylloc_param; 3616 } 3617 3618 /* User-visible API */ 3619 3620 /* yylex_init is special because it creates the scanner itself, so it is 3621 * the ONLY reentrant function that doesn't take the scanner as the last argument. 3622 * That's why we explicitly handle the declaration, instead of using our macros. 3623 */ 3624 int yylex_init(yyscan_t *ptr_yy_globals) 3625 { 3626 if (ptr_yy_globals == NULL) 3627 { 3628 errno = EINVAL; 3629 return 1; 3630 } 3631 3632 *ptr_yy_globals = (yyscan_t)yyalloc(sizeof(struct yyguts_t), NULL); 3633 3634 if (*ptr_yy_globals == NULL) 3635 { 3636 errno = ENOMEM; 3637 return 1; 3638 } 3639 3640 /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ 3641 memset(*ptr_yy_globals, 0x00, sizeof(struct yyguts_t)); 3642 3643 return yy_init_globals(*ptr_yy_globals); 3644 } 3645 3646 /* yylex_init_extra has the same functionality as yylex_init, but follows the 3647 * convention of taking the scanner as the last argument. Note however, that 3648 * this is a *pointer* to a scanner, as it will be allocated by this call (and 3649 * is the reason, too, why this function also must handle its own declaration). 3650 * The user defined value in the first argument will be available to yyalloc in 3651 * the yyextra field. 3652 */ 3653 int yylex_init_extra(YY_EXTRA_TYPE yy_user_defined, yyscan_t *ptr_yy_globals) 3654 { 3655 struct yyguts_t dummy_yyguts; 3656 3657 yyset_extra(yy_user_defined, &dummy_yyguts); 3658 3659 if (ptr_yy_globals == NULL) 3660 { 3661 errno = EINVAL; 3662 return 1; 3663 } 3664 3665 *ptr_yy_globals = (yyscan_t)yyalloc(sizeof(struct yyguts_t), &dummy_yyguts); 3666 3667 if (*ptr_yy_globals == NULL) 3668 { 3669 errno = ENOMEM; 3670 return 1; 3671 } 3672 3673 /* By setting to 0xAA, we expose bugs in 3674 yy_init_globals. Leave at 0x00 for releases. */ 3675 memset(*ptr_yy_globals, 0x00, sizeof(struct yyguts_t)); 3676 3677 yyset_extra(yy_user_defined, *ptr_yy_globals); 3678 3679 return yy_init_globals(*ptr_yy_globals); 3680 } 3681 3682 static int yy_init_globals(yyscan_t yyscanner) 3683 { 3684 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3685 /* Initialization is the same as for the non-reentrant scanner. 3686 * This function is called from yylex_destroy(), so don't allocate here. 3687 */ 3688 3689 yyg->yy_buffer_stack = NULL; 3690 yyg->yy_buffer_stack_top = 0; 3691 yyg->yy_buffer_stack_max = 0; 3692 yyg->yy_c_buf_p = NULL; 3693 yyg->yy_init = 0; 3694 yyg->yy_start = 0; 3695 3696 yyg->yy_start_stack_ptr = 0; 3697 yyg->yy_start_stack_depth = 0; 3698 yyg->yy_start_stack = NULL; 3699 3700 /* Defined in main.c */ 3701 #ifdef YY_STDINIT 3702 yyin = stdin; 3703 yyout = stdout; 3704 #else 3705 yyin = NULL; 3706 yyout = NULL; 3707 #endif 3708 3709 /* For future reference: Set errno on error, since we are called by 3710 * yylex_init() 3711 */ 3712 return 0; 3713 } 3714 3715 /* yylex_destroy is for both reentrant and non-reentrant scanners. */ 3716 int yylex_destroy(yyscan_t yyscanner) 3717 { 3718 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3719 3720 /* Pop the buffer stack, destroying each element. */ 3721 while (YY_CURRENT_BUFFER) 3722 { 3723 yy_delete_buffer(YY_CURRENT_BUFFER, yyscanner); 3724 YY_CURRENT_BUFFER_LVALUE = NULL; 3725 yypop_buffer_state(yyscanner); 3726 } 3727 3728 /* Destroy the stack itself. */ 3729 yyfree(yyg->yy_buffer_stack, yyscanner); 3730 yyg->yy_buffer_stack = NULL; 3731 3732 /* Destroy the start condition stack. */ 3733 yyfree(yyg->yy_start_stack, yyscanner); 3734 yyg->yy_start_stack = NULL; 3735 3736 /* Reset the globals. This is important in a non-reentrant scanner so the next time 3737 * yylex() is called, initialization will occur. */ 3738 yy_init_globals(yyscanner); 3739 3740 /* Destroy the main struct (reentrant only). */ 3741 yyfree(yyscanner, yyscanner); 3742 yyscanner = NULL; 3743 return 0; 3744 } 3745 3746 /* 3747 * Internal utility routines. 3748 */ 3749 3750 #ifndef yytext_ptr 3751 static void yy_flex_strncpy(char *s1, const char *s2, int n, yyscan_t yyscanner) 3752 { 3753 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3754 (void)yyg; 3755 3756 int i; 3757 for (i = 0; i < n; ++i) 3758 s1[i] = s2[i]; 3759 } 3760 #endif 3761 3762 #ifdef YY_NEED_STRLEN 3763 static int yy_flex_strlen(const char *s, yyscan_t yyscanner) 3764 { 3765 int n; 3766 for (n = 0; s[n]; ++n) 3767 ; 3768 3769 return n; 3770 } 3771 #endif 3772 3773 void *yyalloc(yy_size_t size, yyscan_t yyscanner) 3774 { 3775 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3776 (void)yyg; 3777 return malloc(size); 3778 } 3779 3780 void *yyrealloc(void *ptr, yy_size_t size, yyscan_t yyscanner) 3781 { 3782 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3783 (void)yyg; 3784 3785 /* The cast to (char *) in the following accommodates both 3786 * implementations that use char* generic pointers, and those 3787 * that use void* generic pointers. It works with the latter 3788 * because both ANSI C and C++ allow castless assignment from 3789 * any pointer type to void*, and deal with argument conversions 3790 * as though doing an assignment. 3791 */ 3792 return realloc(ptr, size); 3793 } 3794 3795 void yyfree(void *ptr, yyscan_t yyscanner) 3796 { 3797 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3798 (void)yyg; 3799 free((char *)ptr); /* see yyrealloc() for (char *) cast */ 3800 } 3801 3802 #define YYTABLES_NAME "yytables" 3803 3804 yy_size_t string_input(char *buf, yy_size_t max_size, yyscan_t yyscanner) 3805 { 3806 angle::pp::Token token; 3807 yyget_extra(yyscanner)->getPreprocessor().lex(&token); 3808 yy_size_t len = token.type == angle::pp::Token::LAST ? 0 : token.text.size(); 3809 if (len < max_size) 3810 memcpy(buf, token.text.c_str(), len); 3811 yyset_column(token.location.file, yyscanner); 3812 yyset_lineno(token.location.line, yyscanner); 3813 3814 if (len >= max_size) 3815 YY_FATAL_ERROR("Input buffer overflow"); 3816 else if (len > 0) 3817 buf[len++] = ' '; 3818 return len; 3819 } 3820 3821 int check_type(yyscan_t yyscanner) 3822 { 3823 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3824 3825 int token = IDENTIFIER; 3826 // Note that the ImmutableString used here isn't static or pool allocated - but it's fine since 3827 // yytext is valid for the duration of its use. 3828 const TSymbol *symbol = 3829 yyextra->symbolTable.find(ImmutableString(yytext, yyleng), yyextra->getShaderVersion()); 3830 if (symbol && symbol->isStruct()) 3831 { 3832 token = TYPE_NAME; 3833 } 3834 yylval->lex.symbol = symbol; 3835 return token; 3836 } 3837 3838 int reserved_word(yyscan_t yyscanner) 3839 { 3840 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 3841 3842 yyextra->error(*yylloc, "Illegal use of reserved word", yytext); 3843 return 0; 3844 } 3845 3846 static bool is_extension_enabled_or_is_core(TParseContext *context, 3847 int extension_version, 3848 TExtension extension, 3849 int promotion_version) 3850 { 3851 int version = context->getShaderVersion(); 3852 3853 // If version is at least promotion_version, symbol is definitely keyword. Otherwise it's a 3854 // keyword if version is at least extension_version (where the extension was introduced) and 3855 // the extension is enabled. 3856 return version >= promotion_version || 3857 (version >= extension_version && context->isExtensionEnabled(extension)); 3858 } 3859 3860 int ES2_reserved_ES3_keyword(TParseContext *context, int token) 3861 { 3862 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 3863 3864 if (context->getShaderVersion() < 300) 3865 { 3866 return reserved_word(yyscanner); 3867 } 3868 3869 return token; 3870 } 3871 3872 int ES2_keyword_ES3_reserved(TParseContext *context, int token) 3873 { 3874 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 3875 3876 if (context->getShaderVersion() >= 300) 3877 { 3878 return reserved_word(yyscanner); 3879 } 3880 3881 return token; 3882 } 3883 3884 int ES3_reserved_ES3_1_keyword(TParseContext *context, int token) 3885 { 3886 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 3887 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 3888 3889 if (context->getShaderVersion() < 300) 3890 { 3891 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 3892 return check_type(yyscanner); 3893 } 3894 else if (context->getShaderVersion() == 300) 3895 { 3896 return reserved_word(yyscanner); 3897 } 3898 3899 return token; 3900 } 3901 3902 int ES3_keyword(TParseContext *context, int token) 3903 { 3904 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 3905 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 3906 3907 // not a reserved word in GLSL ES 1.00, so could be used as an identifier/type name 3908 if (context->getShaderVersion() < 300) 3909 { 3910 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 3911 return check_type(yyscanner); 3912 } 3913 3914 return token; 3915 } 3916 3917 int ES2_reserved_ES3_1_keyword(TParseContext *context, int token) 3918 { 3919 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 3920 3921 if (context->getShaderVersion() < 310) 3922 { 3923 return reserved_word(yyscanner); 3924 } 3925 3926 return token; 3927 } 3928 3929 int ES3_1_keyword(TParseContext *context, int token) 3930 { 3931 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 3932 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 3933 3934 // A keyword in GLSL ES 3.10. 3935 if (context->getShaderVersion() >= 310) 3936 { 3937 return token; 3938 } 3939 3940 // Otherwise can be used as an identifier/type name 3941 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 3942 return check_type(yyscanner); 3943 } 3944 3945 int WEBGL_video_texture_extension(TParseContext *context, int token) 3946 { 3947 // Available with WEBGL_video_texture_extension 3948 if (context->isExtensionEnabled(TExtension::WEBGL_video_texture)) 3949 { 3950 return token; 3951 } 3952 3953 // Otherwise can be used as an identifier/type name 3954 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 3955 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 3956 3957 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 3958 return check_type(yyscanner); 3959 } 3960 3961 int ES2_extensions_ES3_keyword(TParseContext *context, 3962 TExtension extension1, 3963 TExtension extension2, 3964 TExtension extension3, 3965 int token) 3966 { 3967 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 3968 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 3969 3970 // A keyword in GLSL ES 3.00 or GLSL ES 1.00 with enabled extension. 3971 if (is_extension_enabled_or_is_core(context, 100, extension1, 300)) 3972 { 3973 return token; 3974 } 3975 else if (is_extension_enabled_or_is_core(context, 100, extension2, 300)) 3976 { 3977 return token; 3978 } 3979 else if (is_extension_enabled_or_is_core(context, 100, extension3, 300)) 3980 { 3981 return token; 3982 } 3983 3984 // not a reserved word in GLSL ES 1.00, so could be used as an identifier/type name 3985 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 3986 return check_type(yyscanner); 3987 } 3988 3989 int ES2_reserved_ES2_extension_ES3_keyword(TParseContext *context, TExtension extension, int token) 3990 { 3991 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 3992 3993 // A keyword in GLSL ES 3.00 or GLSL ES 1.00 with enabled extension. 3994 if (is_extension_enabled_or_is_core(context, 100, extension, 300)) 3995 { 3996 return token; 3997 } 3998 3999 // Reserved otherwise. 4000 return reserved_word(yyscanner); 4001 } 4002 4003 int ES3_extension(TParseContext *context, TExtension extension, int token) 4004 { 4005 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 4006 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 4007 4008 // a keyword word in GLSL ES 3.00 with enabled extension. 4009 if (context->getShaderVersion() >= 300 && context->isExtensionEnabled(extension)) 4010 { 4011 return token; 4012 } 4013 4014 // Otherwise can be used as an identifier/type name 4015 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 4016 return check_type(yyscanner); 4017 } 4018 4019 int ES3_reserved_ES3_1_extension_ES3_2_keyword(TParseContext *context, 4020 TExtension extension, 4021 int token) 4022 { 4023 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 4024 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 4025 4026 // a keyword in GLSL ES 3.10 with enabled extension 4027 if (is_extension_enabled_or_is_core(context, 310, extension, 320)) 4028 { 4029 return token; 4030 } 4031 // a reserved word in GLSL ES 3.00+ 4032 if (context->getShaderVersion() >= 300) 4033 { 4034 return reserved_word(yyscanner); 4035 } 4036 4037 // Otherwise can be used as an identifier/type name 4038 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 4039 return check_type(yyscanner); 4040 } 4041 4042 int ES3_reserved_ES3_extension(TParseContext *context, TExtension extension, int token) 4043 { 4044 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 4045 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 4046 4047 if (context->getShaderVersion() >= 300) 4048 { 4049 if (context->isExtensionEnabled(extension)) 4050 { 4051 return token; 4052 } 4053 else 4054 { 4055 return reserved_word(yyscanner); 4056 } 4057 } 4058 4059 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 4060 return check_type(yyscanner); 4061 } 4062 4063 int ES3_reserved_ES3_extension_ES3_1_keyword(TParseContext *context, 4064 TExtension extension, 4065 int token) 4066 { 4067 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 4068 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 4069 4070 // A keyword in GLSL ES 3.00 with enabled extension or in GLSL ES 3.10 4071 if (is_extension_enabled_or_is_core(context, 300, extension, 310)) 4072 { 4073 return token; 4074 } 4075 4076 if (context->getShaderVersion() == 300) 4077 { 4078 return reserved_word(yyscanner); 4079 } 4080 4081 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 4082 return check_type(yyscanner); 4083 } 4084 4085 int ES3_reserved_ES3_extension_ES3_2_keyword(TParseContext *context, 4086 TExtension extension, 4087 int token) 4088 { 4089 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 4090 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 4091 4092 // A keyword in GLSL ES 3.00 with enabled extension or in GLSL ES 3.20 4093 if (is_extension_enabled_or_is_core(context, 300, extension, 320)) 4094 { 4095 return token; 4096 } 4097 4098 if (context->getShaderVersion() == 300 || context->getShaderVersion() == 310) 4099 { 4100 return reserved_word(yyscanner); 4101 } 4102 4103 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 4104 return check_type(yyscanner); 4105 } 4106 4107 static int ES3_1_reserved_ES3_1_extension_ES3_2_keyword(TParseContext *context, 4108 TExtension extension, 4109 int token) 4110 { 4111 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 4112 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 4113 4114 // A keyword in GLSL ES 3.20 or GLSL ES 3.10 with enabled extension. 4115 if (is_extension_enabled_or_is_core(context, 310, extension, 320)) 4116 { 4117 return token; 4118 } 4119 4120 // A reserved word in GLSL ES 3.10 4121 if (context->getShaderVersion() == 310) 4122 { 4123 return reserved_word(yyscanner); 4124 } 4125 4126 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 4127 return check_type(yyscanner); 4128 } 4129 4130 static int ES3_1_reserved_ES3_1_extension_ES3_2_keyword_2(TParseContext *context, 4131 TExtension extension1, 4132 TExtension extension2, 4133 int token1, 4134 int token2) 4135 { 4136 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 4137 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 4138 4139 // A keyword in GLSL ES 3.20 or GLSL ES 3.10 with enabled extension. 4140 if (is_extension_enabled_or_is_core(context, 310, extension1, 320)) 4141 { 4142 return token1; 4143 } 4144 else if (is_extension_enabled_or_is_core(context, 310, extension2, 320)) 4145 { 4146 return token2; 4147 } 4148 4149 // A reserved word in GLSL ES 3.10 4150 if (context->getShaderVersion() == 310) 4151 { 4152 return reserved_word(yyscanner); 4153 } 4154 4155 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 4156 return check_type(yyscanner); 4157 } 4158 4159 static int ES3_and_3_1_reserved_ES3_1_extension_ES3_2_keyword_2(TParseContext *context, 4160 TExtension extension1, 4161 TExtension extension2, 4162 int token1, 4163 int token2) 4164 { 4165 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 4166 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 4167 4168 // A keyword in GLSL ES 3.20 or GLSL ES 3.10 with enabled extension. 4169 if (is_extension_enabled_or_is_core(context, 310, extension1, 320)) 4170 { 4171 return token1; 4172 } 4173 else if (is_extension_enabled_or_is_core(context, 310, extension2, 320)) 4174 { 4175 return token2; 4176 } 4177 4178 // A reserved word in GLSL ES 3.00 and 3.10 4179 if (context->getShaderVersion() >= 300) 4180 { 4181 return reserved_word(yyscanner); 4182 } 4183 4184 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 4185 return check_type(yyscanner); 4186 } 4187 4188 int uint_constant(TParseContext *context) 4189 { 4190 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 4191 4192 if (context->getShaderVersion() < 300) 4193 { 4194 context->error(*yylloc, "Unsigned integers are unsupported prior to GLSL ES 3.00", yytext); 4195 return 0; 4196 } 4197 4198 if (!atoi_clamp(yytext, &(yylval->lex.u))) 4199 yyextra->error(*yylloc, "Integer overflow", yytext); 4200 4201 return UINTCONSTANT; 4202 } 4203 4204 int floatsuffix_check(TParseContext *context) 4205 { 4206 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 4207 4208 if (context->getShaderVersion() < 300) 4209 { 4210 context->error(*yylloc, "Floating-point suffix unsupported prior to GLSL ES 3.00", yytext); 4211 return 0; 4212 } 4213 4214 std::string text = yytext; 4215 text.resize(text.size() - 1); 4216 if (!strtof_clamp(text, &(yylval->lex.f))) 4217 yyextra->warning(*yylloc, "Float overflow", yytext); 4218 4219 return (FLOATCONSTANT); 4220 } 4221 4222 void yyerror(YYLTYPE *lloc, TParseContext *context, void *scanner, const char *reason) 4223 { 4224 context->error(*lloc, reason, yyget_text(scanner)); 4225 } 4226 4227 int int_constant(TParseContext *context) 4228 { 4229 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 4230 4231 unsigned int u; 4232 if (!atoi_clamp(yytext, &u)) 4233 { 4234 if (context->getShaderVersion() >= 300) 4235 yyextra->error(*yylloc, "Integer overflow", yytext); 4236 else 4237 yyextra->warning(*yylloc, "Integer overflow", yytext); 4238 } 4239 yylval->lex.i = static_cast<int>(u); 4240 return INTCONSTANT; 4241 } 4242 4243 int float_constant(yyscan_t yyscanner) 4244 { 4245 struct yyguts_t *yyg = (struct yyguts_t *)yyscanner; 4246 4247 if (!strtof_clamp(yytext, &(yylval->lex.f))) 4248 yyextra->warning(*yylloc, "Float overflow", yytext); 4249 return FLOATCONSTANT; 4250 } 4251 4252 int yuvcscstandardext_constant(TParseContext *context) 4253 { 4254 struct yyguts_t *yyg = (struct yyguts_t *)context->getScanner(); 4255 yyscan_t yyscanner = (yyscan_t)context->getScanner(); 4256 4257 // a reserved word in GLSL ES 3.00 with enabled extension, otherwise could be used as an 4258 // identifier/type name 4259 if (context->getShaderVersion() >= 300 && 4260 context->isExtensionEnabled(TExtension::EXT_YUV_target)) 4261 { 4262 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 4263 return YUVCSCSTANDARDEXTCONSTANT; 4264 } 4265 4266 yylval->lex.string = AllocatePoolCharArray(yytext, yyleng); 4267 return check_type(yyscanner); 4268 } 4269 4270 int glslang_initialize(TParseContext *context) 4271 { 4272 yyscan_t scanner = NULL; 4273 if (yylex_init_extra(context, &scanner)) 4274 return 1; 4275 4276 context->setScanner(scanner); 4277 return 0; 4278 } 4279 4280 int glslang_finalize(TParseContext *context) 4281 { 4282 yyscan_t scanner = context->getScanner(); 4283 if (scanner == NULL) 4284 return 0; 4285 4286 context->setScanner(NULL); 4287 yylex_destroy(scanner); 4288 4289 return 0; 4290 } 4291 4292 int glslang_scan(size_t count, 4293 const char *const string[], 4294 const int length[], 4295 TParseContext *context) 4296 { 4297 yyrestart(NULL, context->getScanner()); 4298 yyset_column(0, context->getScanner()); 4299 yyset_lineno(1, context->getScanner()); 4300 4301 // Initialize preprocessor. 4302 angle::pp::Preprocessor *preprocessor = &context->getPreprocessor(); 4303 4304 if (!preprocessor->init(count, string, length)) 4305 return 1; 4306 4307 // Define extension macros. 4308 const TExtensionBehavior &extBehavior = context->extensionBehavior(); 4309 for (TExtensionBehavior::const_iterator iter = extBehavior.begin(); iter != extBehavior.end(); 4310 ++iter) 4311 { 4312 // OVR_multiview should not be defined for WebGL spec'ed shaders. 4313 if (sh::IsWebGLBasedSpec(context->getShaderSpec()) && 4314 iter->first == TExtension::OVR_multiview) 4315 { 4316 continue; 4317 } 4318 preprocessor->predefineMacro(GetExtensionNameString(iter->first), 1); 4319 } 4320 if (context->getFragmentPrecisionHigh()) 4321 preprocessor->predefineMacro("GL_FRAGMENT_PRECISION_HIGH", 1); 4322 4323 preprocessor->setMaxTokenSize(sh::GetGlobalMaxTokenSize(context->getShaderSpec())); 4324 4325 return 0; 4326 }