1#line 17 "compiler/glslang.l" 2// 3// Copyright (c) 2010 The ANGLE Project Authors. All rights reserved. 4// Use of this source code is governed by a BSD-style license that can be 5// found in the LICENSE file. 6// 7 8// This file is auto-generated by generate_glslang_lexer.sh. DO NOT EDIT! 9 10 11 12#line 13 "compiler/glslang_lex.cpp" 13 14#define YY_INT_ALIGNED short int 15 16/* A lexical scanner generated by flex */ 17 18#define FLEX_SCANNER 19#define YY_FLEX_MAJOR_VERSION 2 20#define YY_FLEX_MINOR_VERSION 5 21#define YY_FLEX_SUBMINOR_VERSION 35 22#if YY_FLEX_SUBMINOR_VERSION > 0 23#define FLEX_BETA 24#endif 25 26/* First, we deal with platform-specific or compiler-specific issues. */ 27 28/* begin standard C headers. */ 29#include <stdio.h> 30#include <string.h> 31#include <errno.h> 32#include <stdlib.h> 33 34/* end standard C headers. */ 35 36/* flex integer type definitions */ 37 38#ifndef FLEXINT_H 39#define FLEXINT_H 40 41/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ 42 43#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 44 45/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, 46 * if you want the limit (max/min) macros for int types. 47 */ 48#ifndef __STDC_LIMIT_MACROS 49#define __STDC_LIMIT_MACROS 1 50#endif 51 52#include <inttypes.h> 53typedef int8_t flex_int8_t; 54typedef uint8_t flex_uint8_t; 55typedef int16_t flex_int16_t; 56typedef uint16_t flex_uint16_t; 57typedef int32_t flex_int32_t; 58typedef uint32_t flex_uint32_t; 59#else 60typedef signed char flex_int8_t; 61typedef short int flex_int16_t; 62typedef int flex_int32_t; 63typedef unsigned char flex_uint8_t; 64typedef unsigned short int flex_uint16_t; 65typedef unsigned int flex_uint32_t; 66#endif /* ! C99 */ 67 68/* Limits of integral types. */ 69#ifndef INT8_MIN 70#define INT8_MIN (-128) 71#endif 72#ifndef INT16_MIN 73#define INT16_MIN (-32767-1) 74#endif 75#ifndef INT32_MIN 76#define INT32_MIN (-2147483647-1) 77#endif 78#ifndef INT8_MAX 79#define INT8_MAX (127) 80#endif 81#ifndef INT16_MAX 82#define INT16_MAX (32767) 83#endif 84#ifndef INT32_MAX 85#define INT32_MAX (2147483647) 86#endif 87#ifndef UINT8_MAX 88#define UINT8_MAX (255U) 89#endif 90#ifndef UINT16_MAX 91#define UINT16_MAX (65535U) 92#endif 93#ifndef UINT32_MAX 94#define UINT32_MAX (4294967295U) 95#endif 96 97#endif /* ! FLEXINT_H */ 98 99#ifdef __cplusplus 100 101/* The "const" storage-class-modifier is valid. */ 102#define YY_USE_CONST 103 104#else /* ! __cplusplus */ 105 106/* C99 requires __STDC__ to be defined as 1. */ 107#if defined (__STDC__) 108 109#define YY_USE_CONST 110 111#endif /* defined (__STDC__) */ 112#endif /* ! __cplusplus */ 113 114#ifdef YY_USE_CONST 115#define yyconst const 116#else 117#define yyconst 118#endif 119 120/* Returned upon end-of-file. */ 121#define YY_NULL 0 122 123/* Promotes a possibly negative, possibly signed char to an unsigned 124 * integer for use as an array index. If the signed char is negative, 125 * we want to instead treat it as an 8-bit unsigned char, hence the 126 * double cast. 127 */ 128#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 129 130/* An opaque pointer. */ 131#ifndef YY_TYPEDEF_YY_SCANNER_T 132#define YY_TYPEDEF_YY_SCANNER_T 133typedef void* yyscan_t; 134#endif 135 136/* For convenience, these vars (plus the bison vars far below) 137 are macros in the reentrant scanner. */ 138#define yyin yyg->yyin_r 139#define yyout yyg->yyout_r 140#define yyextra yyg->yyextra_r 141#define yyleng yyg->yyleng_r 142#define yytext yyg->yytext_r 143#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) 144#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) 145#define yy_flex_debug yyg->yy_flex_debug_r 146 147/* Enter a start condition. This macro really ought to take a parameter, 148 * but we do it the disgusting crufty way forced on us by the ()-less 149 * definition of BEGIN. 150 */ 151#define BEGIN yyg->yy_start = 1 + 2 * 152 153/* Translate the current start state into a value that can be later handed 154 * to BEGIN to return to the state. The YYSTATE alias is for lex 155 * compatibility. 156 */ 157#define YY_START ((yyg->yy_start - 1) / 2) 158#define YYSTATE YY_START 159 160/* Action number for EOF rule of a given start state. */ 161#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 162 163/* Special action meaning "start processing a new file". */ 164#define YY_NEW_FILE yyrestart(yyin ,yyscanner ) 165 166#define YY_END_OF_BUFFER_CHAR 0 167 168/* Size of default input buffer. */ 169#ifndef YY_BUF_SIZE 170#define YY_BUF_SIZE 16384 171#endif 172 173/* The state buf must be large enough to hold one state per character in the main buffer. 174 */ 175#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 176 177#ifndef YY_TYPEDEF_YY_BUFFER_STATE 178#define YY_TYPEDEF_YY_BUFFER_STATE 179typedef struct yy_buffer_state *YY_BUFFER_STATE; 180#endif 181 182#define EOB_ACT_CONTINUE_SCAN 0 183#define EOB_ACT_END_OF_FILE 1 184#define EOB_ACT_LAST_MATCH 2 185 186 /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires 187 * access to the local variable yy_act. Since yyless() is a macro, it would break 188 * existing scanners that call yyless() from OUTSIDE yylex. 189 * One obvious solution it to make yy_act a global. I tried that, and saw 190 * a 5% performance hit in a non-yylineno scanner, because yy_act is 191 * normally declared as a register variable-- so it is not worth it. 192 */ 193 #define YY_LESS_LINENO(n) \ 194 do { \ 195 int yyl;\ 196 for ( yyl = n; yyl < yyleng; ++yyl )\ 197 if ( yytext[yyl] == '\n' )\ 198 --yylineno;\ 199 }while(0) 200 201/* Return all but the first "n" matched characters back to the input stream. */ 202#define yyless(n) \ 203 do \ 204 { \ 205 /* Undo effects of setting up yytext. */ \ 206 int yyless_macro_arg = (n); \ 207 YY_LESS_LINENO(yyless_macro_arg);\ 208 *yy_cp = yyg->yy_hold_char; \ 209 YY_RESTORE_YY_MORE_OFFSET \ 210 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 211 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 212 } \ 213 while ( 0 ) 214 215#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner ) 216 217#ifndef YY_TYPEDEF_YY_SIZE_T 218#define YY_TYPEDEF_YY_SIZE_T 219typedef size_t yy_size_t; 220#endif 221 222#ifndef YY_STRUCT_YY_BUFFER_STATE 223#define YY_STRUCT_YY_BUFFER_STATE 224struct yy_buffer_state 225 { 226 FILE *yy_input_file; 227 228 char *yy_ch_buf; /* input buffer */ 229 char *yy_buf_pos; /* current position in input buffer */ 230 231 /* Size of input buffer in bytes, not including room for EOB 232 * characters. 233 */ 234 yy_size_t yy_buf_size; 235 236 /* Number of characters read into yy_ch_buf, not including EOB 237 * characters. 238 */ 239 int yy_n_chars; 240 241 /* Whether we "own" the buffer - i.e., we know we created it, 242 * and can realloc() it to grow it, and should free() it to 243 * delete it. 244 */ 245 int yy_is_our_buffer; 246 247 /* Whether this is an "interactive" input source; if so, and 248 * if we're using stdio for input, then we want to use getc() 249 * instead of fread(), to make sure we stop fetching input after 250 * each newline. 251 */ 252 int yy_is_interactive; 253 254 /* Whether we're considered to be at the beginning of a line. 255 * If so, '^' rules will be active on the next match, otherwise 256 * not. 257 */ 258 int yy_at_bol; 259 260 int yy_bs_lineno; /**< The line count. */ 261 int yy_bs_column; /**< The column count. */ 262 263 /* Whether to try to fill the input buffer when we reach the 264 * end of it. 265 */ 266 int yy_fill_buffer; 267 268 int yy_buffer_status; 269 270#define YY_BUFFER_NEW 0 271#define YY_BUFFER_NORMAL 1 272 /* When an EOF's been seen but there's still some text to process 273 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 274 * shouldn't try reading from the input source any more. We might 275 * still have a bunch of tokens to match, though, because of 276 * possible backing-up. 277 * 278 * When we actually see the EOF, we change the status to "new" 279 * (via yyrestart()), so that the user can continue scanning by 280 * just pointing yyin at a new input file. 281 */ 282#define YY_BUFFER_EOF_PENDING 2 283 284 }; 285#endif /* !YY_STRUCT_YY_BUFFER_STATE */ 286 287/* We provide macros for accessing buffer states in case in the 288 * future we want to put the buffer states in a more general 289 * "scanner state". 290 * 291 * Returns the top of the stack, or NULL. 292 */ 293#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ 294 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ 295 : NULL) 296 297/* Same as previous macro, but useful when we know that the buffer stack is not 298 * NULL or when we need an lvalue. For internal use only. 299 */ 300#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] 301 302void yyrestart (FILE *input_file ,yyscan_t yyscanner ); 303void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner ); 304YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner ); 305void yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner ); 306void yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner ); 307void yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner ); 308void yypop_buffer_state (yyscan_t yyscanner ); 309 310static void yyensure_buffer_stack (yyscan_t yyscanner ); 311static void yy_load_buffer_state (yyscan_t yyscanner ); 312static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner ); 313 314#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner) 315 316YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner ); 317YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner ); 318YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner ); 319 320void *yyalloc (yy_size_t ,yyscan_t yyscanner ); 321void *yyrealloc (void *,yy_size_t ,yyscan_t yyscanner ); 322void yyfree (void * ,yyscan_t yyscanner ); 323 324#define yy_new_buffer yy_create_buffer 325 326#define yy_set_interactive(is_interactive) \ 327 { \ 328 if ( ! YY_CURRENT_BUFFER ){ \ 329 yyensure_buffer_stack (yyscanner); \ 330 YY_CURRENT_BUFFER_LVALUE = \ 331 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ 332 } \ 333 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 334 } 335 336#define yy_set_bol(at_bol) \ 337 { \ 338 if ( ! YY_CURRENT_BUFFER ){\ 339 yyensure_buffer_stack (yyscanner); \ 340 YY_CURRENT_BUFFER_LVALUE = \ 341 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ 342 } \ 343 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 344 } 345 346#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 347 348/* Begin user sect3 */ 349 350#define yywrap(n) 1 351#define YY_SKIP_YYWRAP 352 353typedef unsigned char YY_CHAR; 354 355typedef int yy_state_type; 356 357#define yytext_ptr yytext_r 358 359static yy_state_type yy_get_previous_state (yyscan_t yyscanner ); 360static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner); 361static int yy_get_next_buffer (yyscan_t yyscanner ); 362static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); 363 364/* Done after the current pattern has been matched and before the 365 * corresponding action - sets up yytext. 366 */ 367#define YY_DO_BEFORE_ACTION \ 368 yyg->yytext_ptr = yy_bp; \ 369 yyleng = (size_t) (yy_cp - yy_bp); \ 370 yyg->yy_hold_char = *yy_cp; \ 371 *yy_cp = '\0'; \ 372 yyg->yy_c_buf_p = yy_cp; 373 374#define YY_NUM_RULES 145 375#define YY_END_OF_BUFFER 146 376/* This struct is not used in this scanner, 377 but its presence is necessary. */ 378struct yy_trans_info 379 { 380 flex_int32_t yy_verify; 381 flex_int32_t yy_nxt; 382 }; 383static yyconst flex_int16_t yy_accept[411] = 384 { 0, 385 0, 0, 0, 0, 0, 0, 146, 144, 143, 143, 386 128, 134, 139, 123, 124, 132, 131, 120, 129, 127, 387 133, 92, 92, 121, 117, 135, 122, 136, 140, 88, 388 125, 126, 138, 88, 88, 88, 88, 88, 88, 88, 389 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 390 88, 88, 88, 118, 137, 119, 130, 3, 4, 3, 391 142, 145, 141, 114, 100, 119, 108, 103, 98, 106, 392 96, 107, 97, 95, 2, 1, 99, 94, 90, 91, 393 0, 0, 92, 126, 118, 125, 115, 111, 113, 112, 394 116, 88, 104, 110, 88, 88, 88, 88, 88, 88, 395 396 88, 88, 88, 88, 17, 88, 88, 88, 88, 88, 397 88, 88, 88, 88, 88, 88, 88, 88, 20, 22, 398 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 399 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 400 88, 88, 88, 88, 88, 88, 105, 109, 5, 141, 401 0, 1, 94, 0, 0, 93, 89, 101, 102, 48, 402 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 403 88, 88, 88, 88, 88, 88, 88, 18, 88, 88, 404 88, 88, 88, 88, 88, 88, 26, 88, 88, 88, 405 88, 88, 88, 88, 88, 23, 88, 88, 88, 88, 406 407 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 408 88, 88, 88, 88, 88, 88, 88, 88, 0, 95, 409 0, 94, 88, 28, 88, 88, 85, 88, 88, 88, 410 88, 88, 88, 88, 21, 51, 88, 88, 88, 88, 411 88, 56, 70, 88, 88, 88, 88, 88, 88, 88, 412 88, 67, 9, 33, 34, 35, 88, 88, 88, 88, 413 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 414 88, 54, 29, 88, 88, 88, 88, 88, 88, 36, 415 37, 38, 27, 88, 88, 88, 15, 42, 43, 44, 416 49, 12, 88, 88, 88, 88, 81, 82, 83, 88, 417 418 30, 71, 25, 78, 79, 80, 7, 75, 76, 77, 419 88, 24, 73, 88, 88, 39, 40, 41, 88, 88, 420 88, 88, 88, 88, 88, 88, 88, 68, 88, 88, 421 88, 88, 88, 88, 88, 50, 88, 87, 88, 88, 422 19, 88, 88, 88, 88, 69, 64, 59, 88, 88, 423 88, 88, 88, 74, 55, 88, 62, 32, 88, 84, 424 63, 47, 57, 88, 88, 88, 88, 88, 88, 88, 425 88, 58, 31, 88, 88, 88, 8, 88, 88, 88, 426 88, 88, 52, 13, 88, 14, 88, 88, 16, 65, 427 88, 88, 88, 60, 88, 88, 88, 53, 72, 61, 428 429 11, 66, 6, 86, 10, 45, 88, 88, 46, 0 430 } ; 431 432static yyconst flex_int32_t yy_ec[256] = 433 { 0, 434 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 435 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 436 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 437 1, 2, 4, 1, 1, 1, 5, 6, 1, 7, 438 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 439 18, 19, 16, 16, 16, 20, 20, 21, 22, 23, 440 24, 25, 26, 1, 27, 27, 28, 29, 30, 27, 441 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 442 31, 31, 31, 31, 31, 31, 31, 32, 31, 31, 443 33, 1, 34, 35, 31, 1, 36, 37, 38, 39, 444 445 40, 41, 42, 43, 44, 31, 45, 46, 47, 48, 446 49, 50, 31, 51, 52, 53, 54, 55, 56, 57, 447 58, 59, 60, 61, 62, 63, 1, 1, 1, 1, 448 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 449 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 450 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 451 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 452 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 453 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 454 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 455 456 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 457 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 458 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 459 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 460 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 461 1, 1, 1, 1, 1 462 } ; 463 464static yyconst flex_int32_t yy_meta[64] = 465 { 0, 466 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 467 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 468 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 469 4, 4, 1, 1, 1, 3, 3, 3, 3, 3, 470 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 471 4, 4, 4, 4, 4, 4, 4, 4, 4, 1, 472 1, 1, 1 473 } ; 474 475static yyconst flex_int16_t yy_base[416] = 476 { 0, 477 0, 0, 61, 62, 71, 0, 606, 607, 607, 607, 478 581, 42, 129, 607, 607, 580, 126, 607, 125, 123, 479 137, 149, 157, 578, 607, 175, 578, 44, 607, 0, 480 607, 607, 120, 95, 103, 142, 146, 136, 156, 552, 481 168, 162, 551, 120, 158, 545, 173, 558, 172, 178, 482 111, 186, 554, 607, 159, 607, 607, 607, 607, 582, 483 607, 607, 0, 607, 607, 607, 607, 607, 607, 607, 484 607, 607, 607, 222, 607, 0, 607, 228, 254, 262, 485 281, 0, 290, 607, 607, 607, 571, 607, 607, 607, 486 570, 0, 607, 607, 546, 539, 542, 550, 549, 536, 487 488 551, 538, 544, 532, 529, 542, 529, 526, 526, 532, 489 520, 527, 524, 534, 520, 526, 529, 530, 0, 204, 490 529, 207, 515, 528, 519, 521, 511, 525, 522, 524, 491 507, 512, 509, 498, 183, 512, 508, 510, 499, 502, 492 212, 507, 499, 511, 186, 504, 607, 607, 607, 0, 493 306, 0, 316, 332, 270, 342, 0, 607, 607, 0, 494 496, 500, 509, 506, 490, 490, 161, 505, 502, 502, 495 500, 497, 489, 495, 482, 493, 496, 0, 493, 481, 496 488, 485, 489, 482, 471, 470, 483, 486, 483, 478, 497 469, 294, 474, 477, 468, 465, 469, 475, 466, 457, 498 499 460, 458, 468, 454, 452, 452, 454, 451, 462, 461, 500 278, 456, 451, 440, 320, 458, 460, 449, 348, 354, 501 360, 366, 450, 0, 448, 336, 0, 440, 438, 446, 502 435, 452, 441, 370, 0, 0, 435, 445, 445, 430, 503 373, 0, 0, 432, 376, 433, 427, 426, 427, 426, 504 379, 0, 0, 0, 0, 0, 422, 423, 428, 419, 505 432, 427, 426, 418, 422, 414, 417, 421, 426, 425, 506 416, 0, 0, 422, 411, 411, 416, 415, 412, 0, 507 0, 0, 0, 402, 414, 416, 0, 0, 0, 0, 508 0, 0, 404, 405, 399, 409, 0, 0, 0, 400, 509 510 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 511 407, 0, 0, 405, 401, 0, 0, 0, 397, 393, 512 398, 388, 401, 387, 400, 389, 396, 0, 394, 396, 513 380, 389, 395, 390, 378, 0, 380, 0, 379, 382, 514 0, 371, 370, 370, 383, 0, 385, 0, 384, 383, 515 368, 381, 368, 0, 0, 371, 0, 0, 363, 0, 516 0, 0, 0, 360, 371, 364, 368, 303, 297, 288, 517 300, 0, 0, 283, 290, 269, 0, 277, 274, 255, 518 232, 255, 0, 0, 244, 0, 236, 226, 0, 0, 519 225, 208, 211, 0, 185, 202, 131, 0, 0, 0, 520 521 0, 0, 0, 0, 0, 0, 134, 117, 0, 607, 522 398, 400, 402, 406, 142 523 } ; 524 525static yyconst flex_int16_t yy_def[416] = 526 { 0, 527 410, 1, 411, 411, 410, 5, 410, 410, 410, 410, 528 410, 410, 410, 410, 410, 410, 410, 410, 410, 410, 529 410, 410, 410, 410, 410, 410, 410, 410, 410, 412, 530 410, 410, 410, 412, 412, 412, 412, 412, 412, 412, 531 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 532 412, 412, 412, 410, 410, 410, 410, 410, 410, 410, 533 410, 410, 413, 410, 410, 410, 410, 410, 410, 410, 534 410, 410, 410, 410, 410, 414, 410, 410, 410, 410, 535 410, 415, 410, 410, 410, 410, 410, 410, 410, 410, 536 410, 412, 410, 410, 412, 412, 412, 412, 412, 412, 537 538 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 539 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 540 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 541 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 542 412, 412, 412, 412, 412, 412, 410, 410, 410, 413, 543 410, 414, 410, 410, 410, 410, 415, 410, 410, 412, 544 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 545 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 546 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 547 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 548 549 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 550 412, 412, 412, 412, 412, 412, 412, 412, 410, 410, 551 410, 410, 412, 412, 412, 412, 412, 412, 412, 412, 552 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 553 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 554 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 555 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 556 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 557 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 558 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 559 560 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 561 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 562 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 563 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 564 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 565 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 566 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 567 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 568 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 569 412, 412, 412, 412, 412, 412, 412, 412, 412, 412, 570 571 412, 412, 412, 412, 412, 412, 412, 412, 412, 0, 572 410, 410, 410, 410, 410 573 } ; 574 575static yyconst flex_int16_t yy_nxt[671] = 576 { 0, 577 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 578 18, 19, 20, 21, 22, 23, 23, 23, 23, 23, 579 24, 25, 26, 27, 28, 29, 30, 30, 30, 30, 580 30, 30, 31, 32, 33, 34, 35, 36, 37, 38, 581 39, 40, 41, 42, 30, 43, 44, 45, 46, 47, 582 48, 49, 50, 51, 52, 53, 30, 30, 30, 54, 583 55, 56, 57, 59, 59, 65, 66, 90, 91, 60, 584 60, 8, 61, 62, 8, 8, 8, 8, 8, 8, 585 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 586 8, 8, 8, 8, 8, 8, 8, 63, 63, 63, 587 588 63, 63, 63, 8, 8, 8, 63, 63, 63, 63, 589 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 590 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 591 8, 8, 8, 8, 67, 70, 72, 74, 74, 74, 592 74, 74, 74, 93, 157, 75, 95, 96, 73, 71, 593 76, 97, 68, 98, 94, 123, 409, 99, 141, 124, 594 77, 78, 142, 79, 79, 79, 79, 79, 80, 78, 595 408, 83, 83, 83, 83, 83, 83, 100, 81, 85, 596 82, 107, 147, 108, 407, 103, 81, 101, 81, 104, 597 102, 110, 109, 125, 105, 86, 81, 87, 88, 111, 598 599 106, 112, 119, 116, 113, 82, 126, 132, 128, 120, 600 114, 117, 229, 230, 133, 134, 121, 137, 204, 148, 601 138, 143, 118, 129, 135, 144, 130, 136, 139, 216, 602 406, 217, 405, 205, 145, 140, 74, 74, 74, 74, 603 74, 74, 153, 153, 153, 153, 153, 153, 396, 184, 604 404, 151, 185, 186, 190, 211, 187, 154, 188, 397, 605 403, 151, 191, 212, 402, 401, 78, 154, 79, 79, 606 79, 79, 79, 80, 78, 400, 80, 80, 80, 80, 607 80, 80, 399, 81, 156, 156, 156, 156, 156, 156, 608 155, 81, 155, 81, 398, 156, 156, 156, 156, 156, 609 610 156, 81, 78, 395, 83, 83, 83, 83, 83, 83, 611 254, 255, 256, 394, 393, 219, 392, 219, 275, 81, 612 220, 220, 220, 220, 220, 220, 276, 391, 390, 81, 613 153, 153, 153, 153, 153, 153, 280, 281, 282, 389, 614 388, 221, 387, 221, 386, 154, 222, 222, 222, 222, 615 222, 222, 288, 289, 290, 154, 156, 156, 156, 156, 616 156, 156, 220, 220, 220, 220, 220, 220, 220, 220, 617 220, 220, 220, 220, 222, 222, 222, 222, 222, 222, 618 222, 222, 222, 222, 222, 222, 297, 298, 299, 304, 619 305, 306, 308, 309, 310, 316, 317, 318, 58, 58, 620 621 58, 58, 92, 92, 150, 150, 152, 385, 152, 152, 622 384, 383, 382, 381, 380, 379, 378, 377, 376, 375, 623 374, 373, 372, 371, 370, 369, 368, 367, 366, 365, 624 364, 363, 362, 361, 360, 359, 358, 357, 356, 355, 625 354, 353, 352, 351, 350, 349, 348, 347, 346, 345, 626 344, 343, 342, 341, 340, 339, 338, 337, 336, 335, 627 334, 333, 332, 331, 330, 329, 328, 327, 326, 325, 628 324, 323, 322, 321, 320, 319, 315, 314, 313, 312, 629 311, 307, 303, 302, 301, 300, 296, 295, 294, 293, 630 292, 291, 287, 286, 285, 284, 283, 279, 278, 277, 631 632 274, 273, 272, 271, 270, 269, 268, 267, 266, 265, 633 264, 263, 262, 261, 260, 259, 258, 257, 253, 252, 634 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 635 241, 240, 239, 238, 237, 236, 235, 234, 233, 232, 636 231, 228, 227, 226, 225, 224, 223, 218, 215, 214, 637 213, 210, 209, 208, 207, 206, 203, 202, 201, 200, 638 199, 198, 197, 196, 195, 194, 193, 192, 189, 183, 639 182, 181, 180, 179, 178, 177, 176, 175, 174, 173, 640 172, 171, 170, 169, 168, 167, 166, 165, 164, 163, 641 162, 161, 160, 159, 158, 149, 146, 131, 127, 122, 642 643 115, 89, 84, 69, 64, 410, 7, 410, 410, 410, 644 410, 410, 410, 410, 410, 410, 410, 410, 410, 410, 645 410, 410, 410, 410, 410, 410, 410, 410, 410, 410, 646 410, 410, 410, 410, 410, 410, 410, 410, 410, 410, 647 410, 410, 410, 410, 410, 410, 410, 410, 410, 410, 648 410, 410, 410, 410, 410, 410, 410, 410, 410, 410, 649 410, 410, 410, 410, 410, 410, 410, 410, 410, 410 650 } ; 651 652static yyconst flex_int16_t yy_chk[671] = 653 { 0, 654 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 655 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 656 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 657 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 658 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 659 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 660 1, 1, 1, 3, 4, 12, 12, 28, 28, 3, 661 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 662 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 663 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 664 665 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 666 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 667 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 668 5, 5, 5, 5, 13, 17, 19, 20, 20, 20, 669 20, 20, 20, 33, 415, 21, 34, 34, 19, 17, 670 21, 35, 13, 35, 33, 44, 408, 35, 51, 44, 671 21, 22, 51, 22, 22, 22, 22, 22, 22, 23, 672 407, 23, 23, 23, 23, 23, 23, 36, 22, 26, 673 22, 38, 55, 38, 397, 37, 23, 36, 22, 37, 674 36, 39, 38, 45, 37, 26, 23, 26, 26, 39, 675 676 37, 39, 42, 41, 39, 22, 45, 49, 47, 42, 677 39, 41, 167, 167, 49, 49, 42, 50, 135, 55, 678 50, 52, 41, 47, 49, 52, 47, 49, 50, 145, 679 396, 145, 395, 135, 52, 50, 74, 74, 74, 74, 680 74, 74, 78, 78, 78, 78, 78, 78, 381, 120, 681 393, 74, 120, 120, 122, 141, 120, 78, 120, 381, 682 392, 74, 122, 141, 391, 388, 79, 78, 79, 79, 683 79, 79, 79, 79, 80, 387, 80, 80, 80, 80, 684 80, 80, 385, 79, 155, 155, 155, 155, 155, 155, 685 81, 80, 81, 79, 382, 81, 81, 81, 81, 81, 686 687 81, 80, 83, 380, 83, 83, 83, 83, 83, 83, 688 192, 192, 192, 379, 378, 151, 376, 151, 211, 83, 689 151, 151, 151, 151, 151, 151, 211, 375, 374, 83, 690 153, 153, 153, 153, 153, 153, 215, 215, 215, 371, 691 370, 154, 369, 154, 368, 153, 154, 154, 154, 154, 692 154, 154, 226, 226, 226, 153, 156, 156, 156, 156, 693 156, 156, 219, 219, 219, 219, 219, 219, 220, 220, 694 220, 220, 220, 220, 221, 221, 221, 221, 221, 221, 695 222, 222, 222, 222, 222, 222, 234, 234, 234, 241, 696 241, 241, 245, 245, 245, 251, 251, 251, 411, 411, 697 698 411, 411, 412, 412, 413, 413, 414, 367, 414, 414, 699 366, 365, 364, 359, 356, 353, 352, 351, 350, 349, 700 347, 345, 344, 343, 342, 340, 339, 337, 335, 334, 701 333, 332, 331, 330, 329, 327, 326, 325, 324, 323, 702 322, 321, 320, 319, 315, 314, 311, 300, 296, 295, 703 294, 293, 286, 285, 284, 279, 278, 277, 276, 275, 704 274, 271, 270, 269, 268, 267, 266, 265, 264, 263, 705 262, 261, 260, 259, 258, 257, 250, 249, 248, 247, 706 246, 244, 240, 239, 238, 237, 233, 232, 231, 230, 707 229, 228, 225, 223, 218, 217, 216, 214, 213, 212, 708 709 210, 209, 208, 207, 206, 205, 204, 203, 202, 201, 710 200, 199, 198, 197, 196, 195, 194, 193, 191, 190, 711 189, 188, 187, 186, 185, 184, 183, 182, 181, 180, 712 179, 177, 176, 175, 174, 173, 172, 171, 170, 169, 713 168, 166, 165, 164, 163, 162, 161, 146, 144, 143, 714 142, 140, 139, 138, 137, 136, 134, 133, 132, 131, 715 130, 129, 128, 127, 126, 125, 124, 123, 121, 118, 716 117, 116, 115, 114, 113, 112, 111, 110, 109, 108, 717 107, 106, 105, 104, 103, 102, 101, 100, 99, 98, 718 97, 96, 95, 91, 87, 60, 53, 48, 46, 43, 719 720 40, 27, 24, 16, 11, 7, 410, 410, 410, 410, 721 410, 410, 410, 410, 410, 410, 410, 410, 410, 410, 722 410, 410, 410, 410, 410, 410, 410, 410, 410, 410, 723 410, 410, 410, 410, 410, 410, 410, 410, 410, 410, 724 410, 410, 410, 410, 410, 410, 410, 410, 410, 410, 725 410, 410, 410, 410, 410, 410, 410, 410, 410, 410, 726 410, 410, 410, 410, 410, 410, 410, 410, 410, 410 727 } ; 728 729/* Table of booleans, true if rule could match eol. */ 730static yyconst flex_int32_t yy_rule_can_match_eol[146] = 731 { 0, 7320, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 733 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 734 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 735 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 736 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 737 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 738 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 739 0, 0, 0, 1, 0, 0, }; 740 741/* The intent behind this definition is that it'll catch 742 * any uses of REJECT which flex missed. 743 */ 744#define REJECT reject_used_but_not_detected 745#define yymore() yymore_used_but_not_detected 746#define YY_MORE_ADJ 0 747#define YY_RESTORE_YY_MORE_OFFSET 748/* 749// 750// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved. 751// Use of this source code is governed by a BSD-style license that can be 752// found in the LICENSE file. 753// 754 755This file contains the Lex specification for GLSL ES. 756Based on ANSI C grammar, Lex specification: 757http://www.lysator.liu.se/c/ANSI-C-grammar-l.html 758 759IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_glslang_lexer.sh, 760WHICH GENERATES THE GLSL ES LEXER (glslang_lex.cpp). 761*/ 762 763#include "compiler/glslang.h" 764#include "compiler/ParseHelper.h" 765#include "compiler/util.h" 766#include "glslang_tab.h" 767 768/* windows only pragma */ 769#ifdef _MSC_VER 770#pragma warning(disable : 4102) 771#endif 772 773#define YY_USER_ACTION yylval->lex.line = yylineno; 774#define YY_INPUT(buf, result, max_size) \ 775 result = string_input(buf, max_size, yyscanner); 776 777static int string_input(char* buf, int max_size, yyscan_t yyscanner); 778static int check_type(yyscan_t yyscanner); 779static int reserved_word(yyscan_t yyscanner); 780 781#define INITIAL 0 782#define COMMENT 1 783#define FIELDS 2 784 785#define YY_EXTRA_TYPE TParseContext* 786 787/* Holds the entire state of the reentrant scanner. */ 788struct yyguts_t 789 { 790 791 /* User-defined. Not touched by flex. */ 792 YY_EXTRA_TYPE yyextra_r; 793 794 /* The rest are the same as the globals declared in the non-reentrant scanner. */ 795 FILE *yyin_r, *yyout_r; 796 size_t yy_buffer_stack_top; /**< index of top of stack. */ 797 size_t yy_buffer_stack_max; /**< capacity of stack. */ 798 YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ 799 char yy_hold_char; 800 int yy_n_chars; 801 int yyleng_r; 802 char *yy_c_buf_p; 803 int yy_init; 804 int yy_start; 805 int yy_did_buffer_switch_on_eof; 806 int yy_start_stack_ptr; 807 int yy_start_stack_depth; 808 int *yy_start_stack; 809 yy_state_type yy_last_accepting_state; 810 char* yy_last_accepting_cpos; 811 812 int yylineno_r; 813 int yy_flex_debug_r; 814 815 char *yytext_r; 816 int yy_more_flag; 817 int yy_more_len; 818 819 YYSTYPE * yylval_r; 820 821 }; /* end struct yyguts_t */ 822 823static int yy_init_globals (yyscan_t yyscanner ); 824 825 /* This must go here because YYSTYPE and YYLTYPE are included 826 * from bison output in section 1.*/ 827 # define yylval yyg->yylval_r 828 829int yylex_init (yyscan_t* scanner); 830 831int yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner); 832 833/* Accessor methods to globals. 834 These are made visible to non-reentrant scanners for convenience. */ 835 836int yylex_destroy (yyscan_t yyscanner ); 837 838int yyget_debug (yyscan_t yyscanner ); 839 840void yyset_debug (int debug_flag ,yyscan_t yyscanner ); 841 842YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner ); 843 844void yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner ); 845 846FILE *yyget_in (yyscan_t yyscanner ); 847 848void yyset_in (FILE * in_str ,yyscan_t yyscanner ); 849 850FILE *yyget_out (yyscan_t yyscanner ); 851 852void yyset_out (FILE * out_str ,yyscan_t yyscanner ); 853 854int yyget_leng (yyscan_t yyscanner ); 855 856char *yyget_text (yyscan_t yyscanner ); 857 858int yyget_lineno (yyscan_t yyscanner ); 859 860void yyset_lineno (int line_number ,yyscan_t yyscanner ); 861 862YYSTYPE * yyget_lval (yyscan_t yyscanner ); 863 864void yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner ); 865 866/* Macros after this point can all be overridden by user definitions in 867 * section 1. 868 */ 869 870#ifndef YY_SKIP_YYWRAP 871#ifdef __cplusplus 872extern "C" int yywrap (yyscan_t yyscanner ); 873#else 874extern int yywrap (yyscan_t yyscanner ); 875#endif 876#endif 877 878#ifndef yytext_ptr 879static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner); 880#endif 881 882#ifdef YY_NEED_STRLEN 883static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner); 884#endif 885 886#ifndef YY_NO_INPUT 887 888#ifdef __cplusplus 889static int yyinput (yyscan_t yyscanner ); 890#else 891static int input (yyscan_t yyscanner ); 892#endif 893 894#endif 895 896 static void yy_push_state (int new_state ,yyscan_t yyscanner); 897 898 static void yy_pop_state (yyscan_t yyscanner ); 899 900 static int yy_top_state (yyscan_t yyscanner ); 901 902/* Amount of stuff to slurp up with each read. */ 903#ifndef YY_READ_BUF_SIZE 904#define YY_READ_BUF_SIZE 8192 905#endif 906 907/* Copy whatever the last rule matched to the standard output. */ 908#ifndef ECHO 909/* This used to be an fputs(), but since the string might contain NUL's, 910 * we now use fwrite(). 911 */ 912#define ECHO fwrite( yytext, yyleng, 1, yyout ) 913#endif 914 915/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 916 * is returned in "result". 917 */ 918#ifndef YY_INPUT 919#define YY_INPUT(buf,result,max_size) \ 920 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 921 { \ 922 int c = '*'; \ 923 int n; \ 924 for ( n = 0; n < max_size && \ 925 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 926 buf[n] = (char) c; \ 927 if ( c == '\n' ) \ 928 buf[n++] = (char) c; \ 929 if ( c == EOF && ferror( yyin ) ) \ 930 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 931 result = n; \ 932 } \ 933 else \ 934 { \ 935 errno=0; \ 936 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ 937 { \ 938 if( errno != EINTR) \ 939 { \ 940 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 941 break; \ 942 } \ 943 errno=0; \ 944 clearerr(yyin); \ 945 } \ 946 }\ 947\ 948 949#endif 950 951/* No semi-colon after return; correct usage is to write "yyterminate();" - 952 * we don't want an extra ';' after the "return" because that will cause 953 * some compilers to complain about unreachable statements. 954 */ 955#ifndef yyterminate 956#define yyterminate() return YY_NULL 957#endif 958 959/* Number of entries by which start-condition stack grows. */ 960#ifndef YY_START_STACK_INCR 961#define YY_START_STACK_INCR 25 962#endif 963 964/* Report a fatal error. */ 965#ifndef YY_FATAL_ERROR 966#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) 967#endif 968 969/* end tables serialization structures and prototypes */ 970 971/* Default declaration of generated scanner - a define so the user can 972 * easily add parameters. 973 */ 974#ifndef YY_DECL 975#define YY_DECL_IS_OURS 1 976 977extern int yylex \ 978 (YYSTYPE * yylval_param ,yyscan_t yyscanner); 979 980#define YY_DECL int yylex \ 981 (YYSTYPE * yylval_param , yyscan_t yyscanner) 982#endif /* !YY_DECL */ 983 984/* Code executed at the beginning of each rule, after yytext and yyleng 985 * have been set up. 986 */ 987#ifndef YY_USER_ACTION 988#define YY_USER_ACTION 989#endif 990 991/* Code executed at the end of each rule. */ 992#ifndef YY_BREAK 993#define YY_BREAK break; 994#endif 995 996#define YY_RULE_SETUP \ 997 YY_USER_ACTION 998 999/** The main scanner function which does all the work. 1000 */ 1001YY_DECL 1002{ 1003 register yy_state_type yy_current_state; 1004 register char *yy_cp, *yy_bp; 1005 register int yy_act; 1006 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1007 1008 TParseContext* context = yyextra; 1009 1010 /* Single-line comments */ 1011 1012 yylval = yylval_param; 1013 1014 if ( !yyg->yy_init ) 1015 { 1016 yyg->yy_init = 1; 1017 1018#ifdef YY_USER_INIT 1019 YY_USER_INIT; 1020#endif 1021 1022 if ( ! yyg->yy_start ) 1023 yyg->yy_start = 1; /* first start state */ 1024 1025 if ( ! yyin ) 1026 yyin = stdin; 1027 1028 if ( ! yyout ) 1029 yyout = stdout; 1030 1031 if ( ! YY_CURRENT_BUFFER ) { 1032 yyensure_buffer_stack (yyscanner); 1033 YY_CURRENT_BUFFER_LVALUE = 1034 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); 1035 } 1036 1037 yy_load_buffer_state(yyscanner ); 1038 } 1039 1040 while ( 1 ) /* loops until end-of-file is reached */ 1041 { 1042 yy_cp = yyg->yy_c_buf_p; 1043 1044 /* Support of yytext. */ 1045 *yy_cp = yyg->yy_hold_char; 1046 1047 /* yy_bp points to the position in yy_ch_buf of the start of 1048 * the current run. 1049 */ 1050 yy_bp = yy_cp; 1051 1052 yy_current_state = yyg->yy_start; 1053yy_match: 1054 do 1055 { 1056 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 1057 if ( yy_accept[yy_current_state] ) 1058 { 1059 yyg->yy_last_accepting_state = yy_current_state; 1060 yyg->yy_last_accepting_cpos = yy_cp; 1061 } 1062 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1063 { 1064 yy_current_state = (int) yy_def[yy_current_state]; 1065 if ( yy_current_state >= 411 ) 1066 yy_c = yy_meta[(unsigned int) yy_c]; 1067 } 1068 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1069 ++yy_cp; 1070 } 1071 while ( yy_current_state != 410 ); 1072 yy_cp = yyg->yy_last_accepting_cpos; 1073 yy_current_state = yyg->yy_last_accepting_state; 1074 1075yy_find_action: 1076 yy_act = yy_accept[yy_current_state]; 1077 1078 YY_DO_BEFORE_ACTION; 1079 1080 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) 1081 { 1082 int yyl; 1083 for ( yyl = 0; yyl < yyleng; ++yyl ) 1084 if ( yytext[yyl] == '\n' ) 1085 1086 do{ yylineno++; 1087 yycolumn=0; 1088 }while(0) 1089; 1090 } 1091 1092do_action: /* This label is used only to access EOF actions. */ 1093 1094 switch ( yy_act ) 1095 { /* beginning of action switch */ 1096 case 0: /* must back up */ 1097 /* undo the effects of YY_DO_BEFORE_ACTION */ 1098 *yy_cp = yyg->yy_hold_char; 1099 yy_cp = yyg->yy_last_accepting_cpos; 1100 yy_current_state = yyg->yy_last_accepting_state; 1101 goto yy_find_action; 1102 1103case 1: 1104YY_RULE_SETUP 1105; 1106 YY_BREAK 1107/* Multi-line comments */ 1108case 2: 1109YY_RULE_SETUP 1110{ yy_push_state(COMMENT, yyscanner); } 1111 YY_BREAK 1112case 3: 1113case 4: 1114/* rule 4 can match eol */ 1115YY_RULE_SETUP 1116; 1117 YY_BREAK 1118case 5: 1119YY_RULE_SETUP 1120{ yy_pop_state(yyscanner); } 1121 YY_BREAK 1122case 6: 1123YY_RULE_SETUP 1124{ return(INVARIANT); } 1125 YY_BREAK 1126case 7: 1127YY_RULE_SETUP 1128{ return(HIGH_PRECISION); } 1129 YY_BREAK 1130case 8: 1131YY_RULE_SETUP 1132{ return(MEDIUM_PRECISION); } 1133 YY_BREAK 1134case 9: 1135YY_RULE_SETUP 1136{ return(LOW_PRECISION); } 1137 YY_BREAK 1138case 10: 1139YY_RULE_SETUP 1140{ return(PRECISION); } 1141 YY_BREAK 1142case 11: 1143YY_RULE_SETUP 1144{ return(ATTRIBUTE); } 1145 YY_BREAK 1146case 12: 1147YY_RULE_SETUP 1148{ return(CONST_QUAL); } 1149 YY_BREAK 1150case 13: 1151YY_RULE_SETUP 1152{ return(UNIFORM); } 1153 YY_BREAK 1154case 14: 1155YY_RULE_SETUP 1156{ return(VARYING); } 1157 YY_BREAK 1158case 15: 1159YY_RULE_SETUP 1160{ return(BREAK); } 1161 YY_BREAK 1162case 16: 1163YY_RULE_SETUP 1164{ return(CONTINUE); } 1165 YY_BREAK 1166case 17: 1167YY_RULE_SETUP 1168{ return(DO); } 1169 YY_BREAK 1170case 18: 1171YY_RULE_SETUP 1172{ return(FOR); } 1173 YY_BREAK 1174case 19: 1175YY_RULE_SETUP 1176{ return(WHILE); } 1177 YY_BREAK 1178case 20: 1179YY_RULE_SETUP 1180{ return(IF); } 1181 YY_BREAK 1182case 21: 1183YY_RULE_SETUP 1184{ return(ELSE); } 1185 YY_BREAK 1186case 22: 1187YY_RULE_SETUP 1188{ return(IN_QUAL); } 1189 YY_BREAK 1190case 23: 1191YY_RULE_SETUP 1192{ return(OUT_QUAL); } 1193 YY_BREAK 1194case 24: 1195YY_RULE_SETUP 1196{ return(INOUT_QUAL); } 1197 YY_BREAK 1198case 25: 1199YY_RULE_SETUP 1200{ context->lexAfterType = true; return(FLOAT_TYPE); } 1201 YY_BREAK 1202case 26: 1203YY_RULE_SETUP 1204{ context->lexAfterType = true; return(INT_TYPE); } 1205 YY_BREAK 1206case 27: 1207YY_RULE_SETUP 1208{ context->lexAfterType = true; return(VOID_TYPE); } 1209 YY_BREAK 1210case 28: 1211YY_RULE_SETUP 1212{ context->lexAfterType = true; return(BOOL_TYPE); } 1213 YY_BREAK 1214case 29: 1215YY_RULE_SETUP 1216{ yylval->lex.b = true; return(BOOLCONSTANT); } 1217 YY_BREAK 1218case 30: 1219YY_RULE_SETUP 1220{ yylval->lex.b = false; return(BOOLCONSTANT); } 1221 YY_BREAK 1222case 31: 1223YY_RULE_SETUP 1224{ return(DISCARD); } 1225 YY_BREAK 1226case 32: 1227YY_RULE_SETUP 1228{ return(RETURN); } 1229 YY_BREAK 1230case 33: 1231YY_RULE_SETUP 1232{ context->lexAfterType = true; return(MATRIX2); } 1233 YY_BREAK 1234case 34: 1235YY_RULE_SETUP 1236{ context->lexAfterType = true; return(MATRIX3); } 1237 YY_BREAK 1238case 35: 1239YY_RULE_SETUP 1240{ context->lexAfterType = true; return(MATRIX4); } 1241 YY_BREAK 1242case 36: 1243YY_RULE_SETUP 1244{ context->lexAfterType = true; return (VEC2); } 1245 YY_BREAK 1246case 37: 1247YY_RULE_SETUP 1248{ context->lexAfterType = true; return (VEC3); } 1249 YY_BREAK 1250case 38: 1251YY_RULE_SETUP 1252{ context->lexAfterType = true; return (VEC4); } 1253 YY_BREAK 1254case 39: 1255YY_RULE_SETUP 1256{ context->lexAfterType = true; return (IVEC2); } 1257 YY_BREAK 1258case 40: 1259YY_RULE_SETUP 1260{ context->lexAfterType = true; return (IVEC3); } 1261 YY_BREAK 1262case 41: 1263YY_RULE_SETUP 1264{ context->lexAfterType = true; return (IVEC4); } 1265 YY_BREAK 1266case 42: 1267YY_RULE_SETUP 1268{ context->lexAfterType = true; return (BVEC2); } 1269 YY_BREAK 1270case 43: 1271YY_RULE_SETUP 1272{ context->lexAfterType = true; return (BVEC3); } 1273 YY_BREAK 1274case 44: 1275YY_RULE_SETUP 1276{ context->lexAfterType = true; return (BVEC4); } 1277 YY_BREAK 1278case 45: 1279YY_RULE_SETUP 1280{ context->lexAfterType = true; return SAMPLER2D; } 1281 YY_BREAK 1282case 46: 1283YY_RULE_SETUP 1284{ context->lexAfterType = true; return SAMPLERCUBE; } 1285 YY_BREAK 1286case 47: 1287YY_RULE_SETUP 1288{ context->lexAfterType = true; return(STRUCT); } 1289 YY_BREAK 1290case 48: 1291YY_RULE_SETUP 1292{ return reserved_word(yyscanner); } 1293 YY_BREAK 1294case 49: 1295YY_RULE_SETUP 1296{ return reserved_word(yyscanner); } 1297 YY_BREAK 1298case 50: 1299YY_RULE_SETUP 1300{ return reserved_word(yyscanner); } 1301 YY_BREAK 1302case 51: 1303YY_RULE_SETUP 1304{ return reserved_word(yyscanner); } 1305 YY_BREAK 1306case 52: 1307YY_RULE_SETUP 1308{ return reserved_word(yyscanner); } 1309 YY_BREAK 1310case 53: 1311YY_RULE_SETUP 1312{ return reserved_word(yyscanner); } 1313 YY_BREAK 1314case 54: 1315YY_RULE_SETUP 1316{ return reserved_word(yyscanner); } 1317 YY_BREAK 1318case 55: 1319YY_RULE_SETUP 1320{ return reserved_word(yyscanner); } 1321 YY_BREAK 1322case 56: 1323YY_RULE_SETUP 1324{ return reserved_word(yyscanner); } 1325 YY_BREAK 1326case 57: 1327YY_RULE_SETUP 1328{ return reserved_word(yyscanner); } 1329 YY_BREAK 1330case 58: 1331YY_RULE_SETUP 1332{ return reserved_word(yyscanner); } 1333 YY_BREAK 1334case 59: 1335YY_RULE_SETUP 1336{ return reserved_word(yyscanner); } 1337 YY_BREAK 1338case 60: 1339YY_RULE_SETUP 1340{ return reserved_word(yyscanner); } 1341 YY_BREAK 1342case 61: 1343YY_RULE_SETUP 1344{ return reserved_word(yyscanner); } 1345 YY_BREAK 1346case 62: 1347YY_RULE_SETUP 1348{ return reserved_word(yyscanner); } 1349 YY_BREAK 1350case 63: 1351YY_RULE_SETUP 1352{ return reserved_word(yyscanner); } 1353 YY_BREAK 1354case 64: 1355YY_RULE_SETUP 1356{ return reserved_word(yyscanner); } 1357 YY_BREAK 1358case 65: 1359YY_RULE_SETUP 1360{ return reserved_word(yyscanner); } 1361 YY_BREAK 1362case 66: 1363YY_RULE_SETUP 1364{ return reserved_word(yyscanner); } 1365 YY_BREAK 1366case 67: 1367YY_RULE_SETUP 1368{ return reserved_word(yyscanner); } 1369 YY_BREAK 1370case 68: 1371YY_RULE_SETUP 1372{ return reserved_word(yyscanner); } 1373 YY_BREAK 1374case 69: 1375YY_RULE_SETUP 1376{ return reserved_word(yyscanner); } 1377 YY_BREAK 1378case 70: 1379YY_RULE_SETUP 1380{ return reserved_word(yyscanner); } 1381 YY_BREAK 1382case 71: 1383YY_RULE_SETUP 1384{ return reserved_word(yyscanner); } 1385 YY_BREAK 1386case 72: 1387YY_RULE_SETUP 1388{ return reserved_word(yyscanner); } 1389 YY_BREAK 1390case 73: 1391YY_RULE_SETUP 1392{ return reserved_word(yyscanner); } 1393 YY_BREAK 1394case 74: 1395YY_RULE_SETUP 1396{ return reserved_word(yyscanner); } 1397 YY_BREAK 1398case 75: 1399YY_RULE_SETUP 1400{ return reserved_word(yyscanner); } 1401 YY_BREAK 1402case 76: 1403YY_RULE_SETUP 1404{ return reserved_word(yyscanner); } 1405 YY_BREAK 1406case 77: 1407YY_RULE_SETUP 1408{ return reserved_word(yyscanner); } 1409 YY_BREAK 1410case 78: 1411YY_RULE_SETUP 1412{ return reserved_word(yyscanner); } 1413 YY_BREAK 1414case 79: 1415YY_RULE_SETUP 1416{ return reserved_word(yyscanner); } 1417 YY_BREAK 1418case 80: 1419YY_RULE_SETUP 1420{ return reserved_word(yyscanner); } 1421 YY_BREAK 1422case 81: 1423YY_RULE_SETUP 1424{ return reserved_word(yyscanner); } 1425 YY_BREAK 1426case 82: 1427YY_RULE_SETUP 1428{ return reserved_word(yyscanner); } 1429 YY_BREAK 1430case 83: 1431YY_RULE_SETUP 1432{ return reserved_word(yyscanner); } 1433 YY_BREAK 1434case 84: 1435YY_RULE_SETUP 1436{ return reserved_word(yyscanner); } 1437 YY_BREAK 1438case 85: 1439YY_RULE_SETUP 1440{ return reserved_word(yyscanner); } 1441 YY_BREAK 1442case 86: 1443YY_RULE_SETUP 1444{ return reserved_word(yyscanner); } 1445 YY_BREAK 1446case 87: 1447YY_RULE_SETUP 1448{ return reserved_word(yyscanner); } 1449 YY_BREAK 1450case 88: 1451YY_RULE_SETUP 1452{ 1453 yylval->lex.string = NewPoolTString(yytext); 1454 return check_type(yyscanner); 1455} 1456 YY_BREAK 1457case 89: 1458YY_RULE_SETUP 1459{ yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); } 1460 YY_BREAK 1461case 90: 1462YY_RULE_SETUP 1463{ yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); } 1464 YY_BREAK 1465case 91: 1466YY_RULE_SETUP 1467{ context->error(yylineno, "Invalid Octal number.", yytext, "", ""); context->recover(); return 0;} 1468 YY_BREAK 1469case 92: 1470YY_RULE_SETUP 1471{ yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); } 1472 YY_BREAK 1473case 93: 1474YY_RULE_SETUP 1475{ yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); } 1476 YY_BREAK 1477case 94: 1478YY_RULE_SETUP 1479{ yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); } 1480 YY_BREAK 1481case 95: 1482YY_RULE_SETUP 1483{ yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); } 1484 YY_BREAK 1485case 96: 1486YY_RULE_SETUP 1487{ return(ADD_ASSIGN); } 1488 YY_BREAK 1489case 97: 1490YY_RULE_SETUP 1491{ return(SUB_ASSIGN); } 1492 YY_BREAK 1493case 98: 1494YY_RULE_SETUP 1495{ return(MUL_ASSIGN); } 1496 YY_BREAK 1497case 99: 1498YY_RULE_SETUP 1499{ return(DIV_ASSIGN); } 1500 YY_BREAK 1501case 100: 1502YY_RULE_SETUP 1503{ return(MOD_ASSIGN); } 1504 YY_BREAK 1505case 101: 1506YY_RULE_SETUP 1507{ return(LEFT_ASSIGN); } 1508 YY_BREAK 1509case 102: 1510YY_RULE_SETUP 1511{ return(RIGHT_ASSIGN); } 1512 YY_BREAK 1513case 103: 1514YY_RULE_SETUP 1515{ return(AND_ASSIGN); } 1516 YY_BREAK 1517case 104: 1518YY_RULE_SETUP 1519{ return(XOR_ASSIGN); } 1520 YY_BREAK 1521case 105: 1522YY_RULE_SETUP 1523{ return(OR_ASSIGN); } 1524 YY_BREAK 1525case 106: 1526YY_RULE_SETUP 1527{ return(INC_OP); } 1528 YY_BREAK 1529case 107: 1530YY_RULE_SETUP 1531{ return(DEC_OP); } 1532 YY_BREAK 1533case 108: 1534YY_RULE_SETUP 1535{ return(AND_OP); } 1536 YY_BREAK 1537case 109: 1538YY_RULE_SETUP 1539{ return(OR_OP); } 1540 YY_BREAK 1541case 110: 1542YY_RULE_SETUP 1543{ return(XOR_OP); } 1544 YY_BREAK 1545case 111: 1546YY_RULE_SETUP 1547{ return(LE_OP); } 1548 YY_BREAK 1549case 112: 1550YY_RULE_SETUP 1551{ return(GE_OP); } 1552 YY_BREAK 1553case 113: 1554YY_RULE_SETUP 1555{ return(EQ_OP); } 1556 YY_BREAK 1557case 114: 1558YY_RULE_SETUP 1559{ return(NE_OP); } 1560 YY_BREAK 1561case 115: 1562YY_RULE_SETUP 1563{ return(LEFT_OP); } 1564 YY_BREAK 1565case 116: 1566YY_RULE_SETUP 1567{ return(RIGHT_OP); } 1568 YY_BREAK 1569case 117: 1570YY_RULE_SETUP 1571{ context->lexAfterType = false; return(SEMICOLON); } 1572 YY_BREAK 1573case 118: 1574YY_RULE_SETUP 1575{ context->lexAfterType = false; return(LEFT_BRACE); } 1576 YY_BREAK 1577case 119: 1578YY_RULE_SETUP 1579{ return(RIGHT_BRACE); } 1580 YY_BREAK 1581case 120: 1582YY_RULE_SETUP 1583{ if (context->inTypeParen) context->lexAfterType = false; return(COMMA); } 1584 YY_BREAK 1585case 121: 1586YY_RULE_SETUP 1587{ return(COLON); } 1588 YY_BREAK 1589case 122: 1590YY_RULE_SETUP 1591{ context->lexAfterType = false; return(EQUAL); } 1592 YY_BREAK 1593case 123: 1594YY_RULE_SETUP 1595{ context->lexAfterType = false; context->inTypeParen = true; return(LEFT_PAREN); } 1596 YY_BREAK 1597case 124: 1598YY_RULE_SETUP 1599{ context->inTypeParen = false; return(RIGHT_PAREN); } 1600 YY_BREAK 1601case 125: 1602YY_RULE_SETUP 1603{ return(LEFT_BRACKET); } 1604 YY_BREAK 1605case 126: 1606YY_RULE_SETUP 1607{ return(RIGHT_BRACKET); } 1608 YY_BREAK 1609case 127: 1610YY_RULE_SETUP 1611{ BEGIN(FIELDS); return(DOT); } 1612 YY_BREAK 1613case 128: 1614YY_RULE_SETUP 1615{ return(BANG); } 1616 YY_BREAK 1617case 129: 1618YY_RULE_SETUP 1619{ return(DASH); } 1620 YY_BREAK 1621case 130: 1622YY_RULE_SETUP 1623{ return(TILDE); } 1624 YY_BREAK 1625case 131: 1626YY_RULE_SETUP 1627{ return(PLUS); } 1628 YY_BREAK 1629case 132: 1630YY_RULE_SETUP 1631{ return(STAR); } 1632 YY_BREAK 1633case 133: 1634YY_RULE_SETUP 1635{ return(SLASH); } 1636 YY_BREAK 1637case 134: 1638YY_RULE_SETUP 1639{ return(PERCENT); } 1640 YY_BREAK 1641case 135: 1642YY_RULE_SETUP 1643{ return(LEFT_ANGLE); } 1644 YY_BREAK 1645case 136: 1646YY_RULE_SETUP 1647{ return(RIGHT_ANGLE); } 1648 YY_BREAK 1649case 137: 1650YY_RULE_SETUP 1651{ return(VERTICAL_BAR); } 1652 YY_BREAK 1653case 138: 1654YY_RULE_SETUP 1655{ return(CARET); } 1656 YY_BREAK 1657case 139: 1658YY_RULE_SETUP 1659{ return(AMPERSAND); } 1660 YY_BREAK 1661case 140: 1662YY_RULE_SETUP 1663{ return(QUESTION); } 1664 YY_BREAK 1665case 141: 1666YY_RULE_SETUP 1667{ 1668 BEGIN(INITIAL); 1669 yylval->lex.string = NewPoolTString(yytext); 1670 return FIELD_SELECTION; 1671} 1672 YY_BREAK 1673case 142: 1674YY_RULE_SETUP 1675{} 1676 YY_BREAK 1677case 143: 1678/* rule 143 can match eol */ 1679YY_RULE_SETUP 1680{ } 1681 YY_BREAK 1682case YY_STATE_EOF(INITIAL): 1683case YY_STATE_EOF(COMMENT): 1684case YY_STATE_EOF(FIELDS): 1685{ context->AfterEOF = true; yyterminate(); } 1686 YY_BREAK 1687case 144: 1688YY_RULE_SETUP 1689{ context->warning(yylineno, "Unknown char", yytext, ""); return 0; } 1690 YY_BREAK 1691case 145: 1692YY_RULE_SETUP 1693ECHO; 1694 YY_BREAK 1695 1696 case YY_END_OF_BUFFER: 1697 { 1698 /* Amount of text matched not including the EOB char. */ 1699 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; 1700 1701 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1702 *yy_cp = yyg->yy_hold_char; 1703 YY_RESTORE_YY_MORE_OFFSET 1704 1705 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) 1706 { 1707 /* We're scanning a new file or input source. It's 1708 * possible that this happened because the user 1709 * just pointed yyin at a new source and called 1710 * yylex(). If so, then we have to assure 1711 * consistency between YY_CURRENT_BUFFER and our 1712 * globals. Here is the right place to do so, because 1713 * this is the first action (other than possibly a 1714 * back-up) that will match for the new input source. 1715 */ 1716 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 1717 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; 1718 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; 1719 } 1720 1721 /* Note that here we test for yy_c_buf_p "<=" to the position 1722 * of the first EOB in the buffer, since yy_c_buf_p will 1723 * already have been incremented past the NUL character 1724 * (since all states make transitions on EOB to the 1725 * end-of-buffer state). Contrast this with the test 1726 * in input(). 1727 */ 1728 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) 1729 { /* This was really a NUL. */ 1730 yy_state_type yy_next_state; 1731 1732 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; 1733 1734 yy_current_state = yy_get_previous_state( yyscanner ); 1735 1736 /* Okay, we're now positioned to make the NUL 1737 * transition. We couldn't have 1738 * yy_get_previous_state() go ahead and do it 1739 * for us because it doesn't know how to deal 1740 * with the possibility of jamming (and we don't 1741 * want to build jamming into it because then it 1742 * will run more slowly). 1743 */ 1744 1745 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 1746 1747 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; 1748 1749 if ( yy_next_state ) 1750 { 1751 /* Consume the NUL. */ 1752 yy_cp = ++yyg->yy_c_buf_p; 1753 yy_current_state = yy_next_state; 1754 goto yy_match; 1755 } 1756 1757 else 1758 { 1759 yy_cp = yyg->yy_last_accepting_cpos; 1760 yy_current_state = yyg->yy_last_accepting_state; 1761 goto yy_find_action; 1762 } 1763 } 1764 1765 else switch ( yy_get_next_buffer( yyscanner ) ) 1766 { 1767 case EOB_ACT_END_OF_FILE: 1768 { 1769 yyg->yy_did_buffer_switch_on_eof = 0; 1770 1771 if ( yywrap(yyscanner ) ) 1772 { 1773 /* Note: because we've taken care in 1774 * yy_get_next_buffer() to have set up 1775 * yytext, we can now set up 1776 * yy_c_buf_p so that if some total 1777 * hoser (like flex itself) wants to 1778 * call the scanner after we return the 1779 * YY_NULL, it'll still work - another 1780 * YY_NULL will get returned. 1781 */ 1782 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; 1783 1784 yy_act = YY_STATE_EOF(YY_START); 1785 goto do_action; 1786 } 1787 1788 else 1789 { 1790 if ( ! yyg->yy_did_buffer_switch_on_eof ) 1791 YY_NEW_FILE; 1792 } 1793 break; 1794 } 1795 1796 case EOB_ACT_CONTINUE_SCAN: 1797 yyg->yy_c_buf_p = 1798 yyg->yytext_ptr + yy_amount_of_matched_text; 1799 1800 yy_current_state = yy_get_previous_state( yyscanner ); 1801 1802 yy_cp = yyg->yy_c_buf_p; 1803 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; 1804 goto yy_match; 1805 1806 case EOB_ACT_LAST_MATCH: 1807 yyg->yy_c_buf_p = 1808 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; 1809 1810 yy_current_state = yy_get_previous_state( yyscanner ); 1811 1812 yy_cp = yyg->yy_c_buf_p; 1813 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; 1814 goto yy_find_action; 1815 } 1816 break; 1817 } 1818 1819 default: 1820 YY_FATAL_ERROR( 1821 "fatal flex scanner internal error--no action found" ); 1822 } /* end of action switch */ 1823 } /* end of scanning one token */ 1824} /* end of yylex */ 1825 1826/* yy_get_next_buffer - try to read in a new buffer 1827 * 1828 * Returns a code representing an action: 1829 * EOB_ACT_LAST_MATCH - 1830 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 1831 * EOB_ACT_END_OF_FILE - end of file 1832 */ 1833static int yy_get_next_buffer (yyscan_t yyscanner) 1834{ 1835 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1836 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; 1837 register char *source = yyg->yytext_ptr; 1838 register int number_to_move, i; 1839 int ret_val; 1840 1841 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) 1842 YY_FATAL_ERROR( 1843 "fatal flex scanner internal error--end of buffer missed" ); 1844 1845 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) 1846 { /* Don't try to fill the buffer, so this is an EOF. */ 1847 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) 1848 { 1849 /* We matched a single character, the EOB, so 1850 * treat this as a final EOF. 1851 */ 1852 return EOB_ACT_END_OF_FILE; 1853 } 1854 1855 else 1856 { 1857 /* We matched some text prior to the EOB, first 1858 * process it. 1859 */ 1860 return EOB_ACT_LAST_MATCH; 1861 } 1862 } 1863 1864 /* Try to read more data. */ 1865 1866 /* First move last chars to start of buffer. */ 1867 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1; 1868 1869 for ( i = 0; i < number_to_move; ++i ) 1870 *(dest++) = *(source++); 1871 1872 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1873 /* don't do the read, it's not guaranteed to return an EOF, 1874 * just force an EOF 1875 */ 1876 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; 1877 1878 else 1879 { 1880 int num_to_read = 1881 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 1882 1883 while ( num_to_read <= 0 ) 1884 { /* Not enough room in the buffer - grow it. */ 1885 1886 /* just a shorter name for the current buffer */ 1887 YY_BUFFER_STATE b = YY_CURRENT_BUFFER; 1888 1889 int yy_c_buf_p_offset = 1890 (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 1891 1892 if ( b->yy_is_our_buffer ) 1893 { 1894 int new_size = b->yy_buf_size * 2; 1895 1896 if ( new_size <= 0 ) 1897 b->yy_buf_size += b->yy_buf_size / 8; 1898 else 1899 b->yy_buf_size *= 2; 1900 1901 b->yy_ch_buf = (char *) 1902 /* Include room in for 2 EOB chars. */ 1903 yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner ); 1904 } 1905 else 1906 /* Can't grow it, we don't own it. */ 1907 b->yy_ch_buf = 0; 1908 1909 if ( ! b->yy_ch_buf ) 1910 YY_FATAL_ERROR( 1911 "fatal error - scanner input buffer overflow" ); 1912 1913 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1914 1915 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - 1916 number_to_move - 1; 1917 1918 } 1919 1920 if ( num_to_read > YY_READ_BUF_SIZE ) 1921 num_to_read = YY_READ_BUF_SIZE; 1922 1923 /* Read in more data. */ 1924 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), 1925 yyg->yy_n_chars, (size_t) num_to_read ); 1926 1927 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; 1928 } 1929 1930 if ( yyg->yy_n_chars == 0 ) 1931 { 1932 if ( number_to_move == YY_MORE_ADJ ) 1933 { 1934 ret_val = EOB_ACT_END_OF_FILE; 1935 yyrestart(yyin ,yyscanner); 1936 } 1937 1938 else 1939 { 1940 ret_val = EOB_ACT_LAST_MATCH; 1941 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = 1942 YY_BUFFER_EOF_PENDING; 1943 } 1944 } 1945 1946 else 1947 ret_val = EOB_ACT_CONTINUE_SCAN; 1948 1949 if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { 1950 /* Extend the array by 50%, plus the number we really need. */ 1951 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 1952 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner ); 1953 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 1954 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); 1955 } 1956 1957 yyg->yy_n_chars += number_to_move; 1958 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; 1959 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; 1960 1961 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; 1962 1963 return ret_val; 1964} 1965 1966/* yy_get_previous_state - get the state just before the EOB char was reached */ 1967 1968 static yy_state_type yy_get_previous_state (yyscan_t yyscanner) 1969{ 1970 register yy_state_type yy_current_state; 1971 register char *yy_cp; 1972 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1973 1974 yy_current_state = yyg->yy_start; 1975 1976 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) 1977 { 1978 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 1979 if ( yy_accept[yy_current_state] ) 1980 { 1981 yyg->yy_last_accepting_state = yy_current_state; 1982 yyg->yy_last_accepting_cpos = yy_cp; 1983 } 1984 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1985 { 1986 yy_current_state = (int) yy_def[yy_current_state]; 1987 if ( yy_current_state >= 411 ) 1988 yy_c = yy_meta[(unsigned int) yy_c]; 1989 } 1990 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1991 } 1992 1993 return yy_current_state; 1994} 1995 1996/* yy_try_NUL_trans - try to make a transition on the NUL character 1997 * 1998 * synopsis 1999 * next_state = yy_try_NUL_trans( current_state ); 2000 */ 2001 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner) 2002{ 2003 register int yy_is_jam; 2004 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ 2005 register char *yy_cp = yyg->yy_c_buf_p; 2006 2007 register YY_CHAR yy_c = 1; 2008 if ( yy_accept[yy_current_state] ) 2009 { 2010 yyg->yy_last_accepting_state = yy_current_state; 2011 yyg->yy_last_accepting_cpos = yy_cp; 2012 } 2013 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 2014 { 2015 yy_current_state = (int) yy_def[yy_current_state]; 2016 if ( yy_current_state >= 411 ) 2017 yy_c = yy_meta[(unsigned int) yy_c]; 2018 } 2019 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 2020 yy_is_jam = (yy_current_state == 410); 2021 2022 return yy_is_jam ? 0 : yy_current_state; 2023} 2024 2025#ifndef YY_NO_INPUT 2026#ifdef __cplusplus 2027 static int yyinput (yyscan_t yyscanner) 2028#else 2029 static int input (yyscan_t yyscanner) 2030#endif 2031 2032{ 2033 int c; 2034 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2035 2036 *yyg->yy_c_buf_p = yyg->yy_hold_char; 2037 2038 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) 2039 { 2040 /* yy_c_buf_p now points to the character we want to return. 2041 * If this occurs *before* the EOB characters, then it's a 2042 * valid NUL; if not, then we've hit the end of the buffer. 2043 */ 2044 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) 2045 /* This was really a NUL. */ 2046 *yyg->yy_c_buf_p = '\0'; 2047 2048 else 2049 { /* need more input */ 2050 int offset = yyg->yy_c_buf_p - yyg->yytext_ptr; 2051 ++yyg->yy_c_buf_p; 2052 2053 switch ( yy_get_next_buffer( yyscanner ) ) 2054 { 2055 case EOB_ACT_LAST_MATCH: 2056 /* This happens because yy_g_n_b() 2057 * sees that we've accumulated a 2058 * token and flags that we need to 2059 * try matching the token before 2060 * proceeding. But for input(), 2061 * there's no matching to consider. 2062 * So convert the EOB_ACT_LAST_MATCH 2063 * to EOB_ACT_END_OF_FILE. 2064 */ 2065 2066 /* Reset buffer status. */ 2067 yyrestart(yyin ,yyscanner); 2068 2069 /*FALLTHROUGH*/ 2070 2071 case EOB_ACT_END_OF_FILE: 2072 { 2073 if ( yywrap(yyscanner ) ) 2074 return EOF; 2075 2076 if ( ! yyg->yy_did_buffer_switch_on_eof ) 2077 YY_NEW_FILE; 2078#ifdef __cplusplus 2079 return yyinput(yyscanner); 2080#else 2081 return input(yyscanner); 2082#endif 2083 } 2084 2085 case EOB_ACT_CONTINUE_SCAN: 2086 yyg->yy_c_buf_p = yyg->yytext_ptr + offset; 2087 break; 2088 } 2089 } 2090 } 2091 2092 c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */ 2093 *yyg->yy_c_buf_p = '\0'; /* preserve yytext */ 2094 yyg->yy_hold_char = *++yyg->yy_c_buf_p; 2095 2096 if ( c == '\n' ) 2097 2098 do{ yylineno++; 2099 yycolumn=0; 2100 }while(0) 2101; 2102 2103 return c; 2104} 2105#endif /* ifndef YY_NO_INPUT */ 2106 2107/** Immediately switch to a different input stream. 2108 * @param input_file A readable stream. 2109 * @param yyscanner The scanner object. 2110 * @note This function does not reset the start condition to @c INITIAL . 2111 */ 2112 void yyrestart (FILE * input_file , yyscan_t yyscanner) 2113{ 2114 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2115 2116 if ( ! YY_CURRENT_BUFFER ){ 2117 yyensure_buffer_stack (yyscanner); 2118 YY_CURRENT_BUFFER_LVALUE = 2119 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); 2120 } 2121 2122 yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner); 2123 yy_load_buffer_state(yyscanner ); 2124} 2125 2126/** Switch to a different input buffer. 2127 * @param new_buffer The new input buffer. 2128 * @param yyscanner The scanner object. 2129 */ 2130 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) 2131{ 2132 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2133 2134 /* TODO. We should be able to replace this entire function body 2135 * with 2136 * yypop_buffer_state(); 2137 * yypush_buffer_state(new_buffer); 2138 */ 2139 yyensure_buffer_stack (yyscanner); 2140 if ( YY_CURRENT_BUFFER == new_buffer ) 2141 return; 2142 2143 if ( YY_CURRENT_BUFFER ) 2144 { 2145 /* Flush out information for old buffer. */ 2146 *yyg->yy_c_buf_p = yyg->yy_hold_char; 2147 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; 2148 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; 2149 } 2150 2151 YY_CURRENT_BUFFER_LVALUE = new_buffer; 2152 yy_load_buffer_state(yyscanner ); 2153 2154 /* We don't actually know whether we did this switch during 2155 * EOF (yywrap()) processing, but the only time this flag 2156 * is looked at is after yywrap() is called, so it's safe 2157 * to go ahead and always set it. 2158 */ 2159 yyg->yy_did_buffer_switch_on_eof = 1; 2160} 2161 2162static void yy_load_buffer_state (yyscan_t yyscanner) 2163{ 2164 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2165 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 2166 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; 2167 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; 2168 yyg->yy_hold_char = *yyg->yy_c_buf_p; 2169} 2170 2171/** Allocate and initialize an input buffer state. 2172 * @param file A readable stream. 2173 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. 2174 * @param yyscanner The scanner object. 2175 * @return the allocated buffer state. 2176 */ 2177 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner) 2178{ 2179 YY_BUFFER_STATE b; 2180 2181 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner ); 2182 if ( ! b ) 2183 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 2184 2185 b->yy_buf_size = size; 2186 2187 /* yy_ch_buf has to be 2 characters longer than the size given because 2188 * we need to put in 2 end-of-buffer characters. 2189 */ 2190 b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ,yyscanner ); 2191 if ( ! b->yy_ch_buf ) 2192 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 2193 2194 b->yy_is_our_buffer = 1; 2195 2196 yy_init_buffer(b,file ,yyscanner); 2197 2198 return b; 2199} 2200 2201/** Destroy the buffer. 2202 * @param b a buffer created with yy_create_buffer() 2203 * @param yyscanner The scanner object. 2204 */ 2205 void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) 2206{ 2207 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2208 2209 if ( ! b ) 2210 return; 2211 2212 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ 2213 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; 2214 2215 if ( b->yy_is_our_buffer ) 2216 yyfree((void *) b->yy_ch_buf ,yyscanner ); 2217 2218 yyfree((void *) b ,yyscanner ); 2219} 2220 2221/* Initializes or reinitializes a buffer. 2222 * This function is sometimes called more than once on the same buffer, 2223 * such as during a yyrestart() or at EOF. 2224 */ 2225 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner) 2226 2227{ 2228 int oerrno = errno; 2229 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2230 2231 yy_flush_buffer(b ,yyscanner); 2232 2233 b->yy_input_file = file; 2234 b->yy_fill_buffer = 1; 2235 2236 /* If b is the current buffer, then yy_init_buffer was _probably_ 2237 * called from yyrestart() or through yy_get_next_buffer. 2238 * In that case, we don't want to reset the lineno or column. 2239 */ 2240 if (b != YY_CURRENT_BUFFER){ 2241 b->yy_bs_lineno = 1; 2242 b->yy_bs_column = 0; 2243 } 2244 2245 b->yy_is_interactive = 0; 2246 2247 errno = oerrno; 2248} 2249 2250/** Discard all buffered characters. On the next scan, YY_INPUT will be called. 2251 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. 2252 * @param yyscanner The scanner object. 2253 */ 2254 void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) 2255{ 2256 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2257 if ( ! b ) 2258 return; 2259 2260 b->yy_n_chars = 0; 2261 2262 /* We always need two end-of-buffer characters. The first causes 2263 * a transition to the end-of-buffer state. The second causes 2264 * a jam in that state. 2265 */ 2266 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 2267 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 2268 2269 b->yy_buf_pos = &b->yy_ch_buf[0]; 2270 2271 b->yy_at_bol = 1; 2272 b->yy_buffer_status = YY_BUFFER_NEW; 2273 2274 if ( b == YY_CURRENT_BUFFER ) 2275 yy_load_buffer_state(yyscanner ); 2276} 2277 2278/** Pushes the new state onto the stack. The new state becomes 2279 * the current state. This function will allocate the stack 2280 * if necessary. 2281 * @param new_buffer The new state. 2282 * @param yyscanner The scanner object. 2283 */ 2284void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) 2285{ 2286 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2287 if (new_buffer == NULL) 2288 return; 2289 2290 yyensure_buffer_stack(yyscanner); 2291 2292 /* This block is copied from yy_switch_to_buffer. */ 2293 if ( YY_CURRENT_BUFFER ) 2294 { 2295 /* Flush out information for old buffer. */ 2296 *yyg->yy_c_buf_p = yyg->yy_hold_char; 2297 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; 2298 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; 2299 } 2300 2301 /* Only push if top exists. Otherwise, replace top. */ 2302 if (YY_CURRENT_BUFFER) 2303 yyg->yy_buffer_stack_top++; 2304 YY_CURRENT_BUFFER_LVALUE = new_buffer; 2305 2306 /* copied from yy_switch_to_buffer. */ 2307 yy_load_buffer_state(yyscanner ); 2308 yyg->yy_did_buffer_switch_on_eof = 1; 2309} 2310 2311/** Removes and deletes the top of the stack, if present. 2312 * The next element becomes the new top. 2313 * @param yyscanner The scanner object. 2314 */ 2315void yypop_buffer_state (yyscan_t yyscanner) 2316{ 2317 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2318 if (!YY_CURRENT_BUFFER) 2319 return; 2320 2321 yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner); 2322 YY_CURRENT_BUFFER_LVALUE = NULL; 2323 if (yyg->yy_buffer_stack_top > 0) 2324 --yyg->yy_buffer_stack_top; 2325 2326 if (YY_CURRENT_BUFFER) { 2327 yy_load_buffer_state(yyscanner ); 2328 yyg->yy_did_buffer_switch_on_eof = 1; 2329 } 2330} 2331 2332/* Allocates the stack if it does not exist. 2333 * Guarantees space for at least one push. 2334 */ 2335static void yyensure_buffer_stack (yyscan_t yyscanner) 2336{ 2337 int num_to_alloc; 2338 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2339 2340 if (!yyg->yy_buffer_stack) { 2341 2342 /* First allocation is just for 2 elements, since we don't know if this 2343 * scanner will even need a stack. We use 2 instead of 1 to avoid an 2344 * immediate realloc on the next call. 2345 */ 2346 num_to_alloc = 1; 2347 yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc 2348 (num_to_alloc * sizeof(struct yy_buffer_state*) 2349 , yyscanner); 2350 if ( ! yyg->yy_buffer_stack ) 2351 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 2352 2353 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 2354 2355 yyg->yy_buffer_stack_max = num_to_alloc; 2356 yyg->yy_buffer_stack_top = 0; 2357 return; 2358 } 2359 2360 if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ 2361 2362 /* Increase the buffer to prepare for a possible push. */ 2363 int grow_size = 8 /* arbitrary grow size */; 2364 2365 num_to_alloc = yyg->yy_buffer_stack_max + grow_size; 2366 yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc 2367 (yyg->yy_buffer_stack, 2368 num_to_alloc * sizeof(struct yy_buffer_state*) 2369 , yyscanner); 2370 if ( ! yyg->yy_buffer_stack ) 2371 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 2372 2373 /* zero only the new slots.*/ 2374 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); 2375 yyg->yy_buffer_stack_max = num_to_alloc; 2376 } 2377} 2378 2379/** Setup the input buffer state to scan directly from a user-specified character buffer. 2380 * @param base the character buffer 2381 * @param size the size in bytes of the character buffer 2382 * @param yyscanner The scanner object. 2383 * @return the newly allocated buffer state object. 2384 */ 2385YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner) 2386{ 2387 YY_BUFFER_STATE b; 2388 2389 if ( size < 2 || 2390 base[size-2] != YY_END_OF_BUFFER_CHAR || 2391 base[size-1] != YY_END_OF_BUFFER_CHAR ) 2392 /* They forgot to leave room for the EOB's. */ 2393 return 0; 2394 2395 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner ); 2396 if ( ! b ) 2397 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 2398 2399 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 2400 b->yy_buf_pos = b->yy_ch_buf = base; 2401 b->yy_is_our_buffer = 0; 2402 b->yy_input_file = 0; 2403 b->yy_n_chars = b->yy_buf_size; 2404 b->yy_is_interactive = 0; 2405 b->yy_at_bol = 1; 2406 b->yy_fill_buffer = 0; 2407 b->yy_buffer_status = YY_BUFFER_NEW; 2408 2409 yy_switch_to_buffer(b ,yyscanner ); 2410 2411 return b; 2412} 2413 2414/** Setup the input buffer state to scan a string. The next call to yylex() will 2415 * scan from a @e copy of @a str. 2416 * @param yystr a NUL-terminated string to scan 2417 * @param yyscanner The scanner object. 2418 * @return the newly allocated buffer state object. 2419 * @note If you want to scan bytes that may contain NUL values, then use 2420 * yy_scan_bytes() instead. 2421 */ 2422YY_BUFFER_STATE yy_scan_string (yyconst char * yystr , yyscan_t yyscanner) 2423{ 2424 2425 return yy_scan_bytes(yystr,strlen(yystr) ,yyscanner); 2426} 2427 2428/** Setup the input buffer state to scan the given bytes. The next call to yylex() will 2429 * scan from a @e copy of @a bytes. 2430 * @param bytes the byte buffer to scan 2431 * @param len the number of bytes in the buffer pointed to by @a bytes. 2432 * @param yyscanner The scanner object. 2433 * @return the newly allocated buffer state object. 2434 */ 2435YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len , yyscan_t yyscanner) 2436{ 2437 YY_BUFFER_STATE b; 2438 char *buf; 2439 yy_size_t n; 2440 int i; 2441 2442 /* Get memory for full buffer, including space for trailing EOB's. */ 2443 n = _yybytes_len + 2; 2444 buf = (char *) yyalloc(n ,yyscanner ); 2445 if ( ! buf ) 2446 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 2447 2448 for ( i = 0; i < _yybytes_len; ++i ) 2449 buf[i] = yybytes[i]; 2450 2451 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; 2452 2453 b = yy_scan_buffer(buf,n ,yyscanner); 2454 if ( ! b ) 2455 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 2456 2457 /* It's okay to grow etc. this buffer, and we should throw it 2458 * away when we're done. 2459 */ 2460 b->yy_is_our_buffer = 1; 2461 2462 return b; 2463} 2464 2465 static void yy_push_state (int new_state , yyscan_t yyscanner) 2466{ 2467 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2468 if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth ) 2469 { 2470 yy_size_t new_size; 2471 2472 yyg->yy_start_stack_depth += YY_START_STACK_INCR; 2473 new_size = yyg->yy_start_stack_depth * sizeof( int ); 2474 2475 if ( ! yyg->yy_start_stack ) 2476 yyg->yy_start_stack = (int *) yyalloc(new_size ,yyscanner ); 2477 2478 else 2479 yyg->yy_start_stack = (int *) yyrealloc((void *) yyg->yy_start_stack,new_size ,yyscanner ); 2480 2481 if ( ! yyg->yy_start_stack ) 2482 YY_FATAL_ERROR( "out of memory expanding start-condition stack" ); 2483 } 2484 2485 yyg->yy_start_stack[yyg->yy_start_stack_ptr++] = YY_START; 2486 2487 BEGIN(new_state); 2488} 2489 2490 static void yy_pop_state (yyscan_t yyscanner) 2491{ 2492 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2493 if ( --yyg->yy_start_stack_ptr < 0 ) 2494 YY_FATAL_ERROR( "start-condition stack underflow" ); 2495 2496 BEGIN(yyg->yy_start_stack[yyg->yy_start_stack_ptr]); 2497} 2498 2499 static int yy_top_state (yyscan_t yyscanner) 2500{ 2501 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2502 return yyg->yy_start_stack[yyg->yy_start_stack_ptr - 1]; 2503} 2504 2505#ifndef YY_EXIT_FAILURE 2506#define YY_EXIT_FAILURE 2 2507#endif 2508 2509static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner) 2510{ 2511 (void) fprintf( stderr, "%s\n", msg ); 2512 exit( YY_EXIT_FAILURE ); 2513} 2514 2515/* Redefine yyless() so it works in section 3 code. */ 2516 2517#undef yyless 2518#define yyless(n) \ 2519 do \ 2520 { \ 2521 /* Undo effects of setting up yytext. */ \ 2522 int yyless_macro_arg = (n); \ 2523 YY_LESS_LINENO(yyless_macro_arg);\ 2524 yytext[yyleng] = yyg->yy_hold_char; \ 2525 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \ 2526 yyg->yy_hold_char = *yyg->yy_c_buf_p; \ 2527 *yyg->yy_c_buf_p = '\0'; \ 2528 yyleng = yyless_macro_arg; \ 2529 } \ 2530 while ( 0 ) 2531 2532/* Accessor methods (get/set functions) to struct members. */ 2533 2534/** Get the user-defined data for this scanner. 2535 * @param yyscanner The scanner object. 2536 */ 2537YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner) 2538{ 2539 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2540 return yyextra; 2541} 2542 2543/** Get the current line number. 2544 * @param yyscanner The scanner object. 2545 */ 2546int yyget_lineno (yyscan_t yyscanner) 2547{ 2548 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2549 2550 if (! YY_CURRENT_BUFFER) 2551 return 0; 2552 2553 return yylineno; 2554} 2555 2556/** Get the current column number. 2557 * @param yyscanner The scanner object. 2558 */ 2559int yyget_column (yyscan_t yyscanner) 2560{ 2561 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2562 2563 if (! YY_CURRENT_BUFFER) 2564 return 0; 2565 2566 return yycolumn; 2567} 2568 2569/** Get the input stream. 2570 * @param yyscanner The scanner object. 2571 */ 2572FILE *yyget_in (yyscan_t yyscanner) 2573{ 2574 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2575 return yyin; 2576} 2577 2578/** Get the output stream. 2579 * @param yyscanner The scanner object. 2580 */ 2581FILE *yyget_out (yyscan_t yyscanner) 2582{ 2583 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2584 return yyout; 2585} 2586 2587/** Get the length of the current token. 2588 * @param yyscanner The scanner object. 2589 */ 2590int yyget_leng (yyscan_t yyscanner) 2591{ 2592 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2593 return yyleng; 2594} 2595 2596/** Get the current token. 2597 * @param yyscanner The scanner object. 2598 */ 2599 2600char *yyget_text (yyscan_t yyscanner) 2601{ 2602 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2603 return yytext; 2604} 2605 2606/** Set the user-defined data. This data is never touched by the scanner. 2607 * @param user_defined The data to be associated with this scanner. 2608 * @param yyscanner The scanner object. 2609 */ 2610void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner) 2611{ 2612 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2613 yyextra = user_defined ; 2614} 2615 2616/** Set the current line number. 2617 * @param line_number 2618 * @param yyscanner The scanner object. 2619 */ 2620void yyset_lineno (int line_number , yyscan_t yyscanner) 2621{ 2622 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2623 2624 /* lineno is only valid if an input buffer exists. */ 2625 if (! YY_CURRENT_BUFFER ) 2626 yy_fatal_error( "yyset_lineno called with no buffer" , yyscanner); 2627 2628 yylineno = line_number; 2629} 2630 2631/** Set the current column. 2632 * @param line_number 2633 * @param yyscanner The scanner object. 2634 */ 2635void yyset_column (int column_no , yyscan_t yyscanner) 2636{ 2637 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2638 2639 /* column is only valid if an input buffer exists. */ 2640 if (! YY_CURRENT_BUFFER ) 2641 yy_fatal_error( "yyset_column called with no buffer" , yyscanner); 2642 2643 yycolumn = column_no; 2644} 2645 2646/** Set the input stream. This does not discard the current 2647 * input buffer. 2648 * @param in_str A readable stream. 2649 * @param yyscanner The scanner object. 2650 * @see yy_switch_to_buffer 2651 */ 2652void yyset_in (FILE * in_str , yyscan_t yyscanner) 2653{ 2654 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2655 yyin = in_str ; 2656} 2657 2658void yyset_out (FILE * out_str , yyscan_t yyscanner) 2659{ 2660 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2661 yyout = out_str ; 2662} 2663 2664int yyget_debug (yyscan_t yyscanner) 2665{ 2666 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2667 return yy_flex_debug; 2668} 2669 2670void yyset_debug (int bdebug , yyscan_t yyscanner) 2671{ 2672 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2673 yy_flex_debug = bdebug ; 2674} 2675 2676/* Accessor methods for yylval and yylloc */ 2677 2678YYSTYPE * yyget_lval (yyscan_t yyscanner) 2679{ 2680 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2681 return yylval; 2682} 2683 2684void yyset_lval (YYSTYPE * yylval_param , yyscan_t yyscanner) 2685{ 2686 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2687 yylval = yylval_param; 2688} 2689 2690/* User-visible API */ 2691 2692/* yylex_init is special because it creates the scanner itself, so it is 2693 * the ONLY reentrant function that doesn't take the scanner as the last argument. 2694 * That's why we explicitly handle the declaration, instead of using our macros. 2695 */ 2696 2697int yylex_init(yyscan_t* ptr_yy_globals) 2698 2699{ 2700 if (ptr_yy_globals == NULL){ 2701 errno = EINVAL; 2702 return 1; 2703 } 2704 2705 *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL ); 2706 2707 if (*ptr_yy_globals == NULL){ 2708 errno = ENOMEM; 2709 return 1; 2710 } 2711 2712 /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ 2713 memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2714 2715 return yy_init_globals ( *ptr_yy_globals ); 2716} 2717 2718/* yylex_init_extra has the same functionality as yylex_init, but follows the 2719 * convention of taking the scanner as the last argument. Note however, that 2720 * this is a *pointer* to a scanner, as it will be allocated by this call (and 2721 * is the reason, too, why this function also must handle its own declaration). 2722 * The user defined value in the first argument will be available to yyalloc in 2723 * the yyextra field. 2724 */ 2725 2726int yylex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals ) 2727 2728{ 2729 struct yyguts_t dummy_yyguts; 2730 2731 yyset_extra (yy_user_defined, &dummy_yyguts); 2732 2733 if (ptr_yy_globals == NULL){ 2734 errno = EINVAL; 2735 return 1; 2736 } 2737 2738 *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); 2739 2740 if (*ptr_yy_globals == NULL){ 2741 errno = ENOMEM; 2742 return 1; 2743 } 2744 2745 /* By setting to 0xAA, we expose bugs in 2746 yy_init_globals. Leave at 0x00 for releases. */ 2747 memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2748 2749 yyset_extra (yy_user_defined, *ptr_yy_globals); 2750 2751 return yy_init_globals ( *ptr_yy_globals ); 2752} 2753 2754static int yy_init_globals (yyscan_t yyscanner) 2755{ 2756 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2757 /* Initialization is the same as for the non-reentrant scanner. 2758 * This function is called from yylex_destroy(), so don't allocate here. 2759 */ 2760 2761 yyg->yy_buffer_stack = 0; 2762 yyg->yy_buffer_stack_top = 0; 2763 yyg->yy_buffer_stack_max = 0; 2764 yyg->yy_c_buf_p = (char *) 0; 2765 yyg->yy_init = 0; 2766 yyg->yy_start = 0; 2767 2768 yyg->yy_start_stack_ptr = 0; 2769 yyg->yy_start_stack_depth = 0; 2770 yyg->yy_start_stack = NULL; 2771 2772/* Defined in main.c */ 2773#ifdef YY_STDINIT 2774 yyin = stdin; 2775 yyout = stdout; 2776#else 2777 yyin = (FILE *) 0; 2778 yyout = (FILE *) 0; 2779#endif 2780 2781 /* For future reference: Set errno on error, since we are called by 2782 * yylex_init() 2783 */ 2784 return 0; 2785} 2786 2787/* yylex_destroy is for both reentrant and non-reentrant scanners. */ 2788int yylex_destroy (yyscan_t yyscanner) 2789{ 2790 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2791 2792 /* Pop the buffer stack, destroying each element. */ 2793 while(YY_CURRENT_BUFFER){ 2794 yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner ); 2795 YY_CURRENT_BUFFER_LVALUE = NULL; 2796 yypop_buffer_state(yyscanner); 2797 } 2798 2799 /* Destroy the stack itself. */ 2800 yyfree(yyg->yy_buffer_stack ,yyscanner); 2801 yyg->yy_buffer_stack = NULL; 2802 2803 /* Destroy the start condition stack. */ 2804 yyfree(yyg->yy_start_stack ,yyscanner ); 2805 yyg->yy_start_stack = NULL; 2806 2807 /* Reset the globals. This is important in a non-reentrant scanner so the next time 2808 * yylex() is called, initialization will occur. */ 2809 yy_init_globals( yyscanner); 2810 2811 /* Destroy the main struct (reentrant only). */ 2812 yyfree ( yyscanner , yyscanner ); 2813 yyscanner = NULL; 2814 return 0; 2815} 2816 2817/* 2818 * Internal utility routines. 2819 */ 2820 2821#ifndef yytext_ptr 2822static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner) 2823{ 2824 register int i; 2825 for ( i = 0; i < n; ++i ) 2826 s1[i] = s2[i]; 2827} 2828#endif 2829 2830#ifdef YY_NEED_STRLEN 2831static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner) 2832{ 2833 register int n; 2834 for ( n = 0; s[n]; ++n ) 2835 ; 2836 2837 return n; 2838} 2839#endif 2840 2841void *yyalloc (yy_size_t size , yyscan_t yyscanner) 2842{ 2843 return (void *) malloc( size ); 2844} 2845 2846void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) 2847{ 2848 /* The cast to (char *) in the following accommodates both 2849 * implementations that use char* generic pointers, and those 2850 * that use void* generic pointers. It works with the latter 2851 * because both ANSI C and C++ allow castless assignment from 2852 * any pointer type to void*, and deal with argument conversions 2853 * as though doing an assignment. 2854 */ 2855 return (void *) realloc( (char *) ptr, size ); 2856} 2857 2858void yyfree (void * ptr , yyscan_t yyscanner) 2859{ 2860 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 2861} 2862 2863#define YYTABLES_NAME "yytables" 2864 2865extern "C" { 2866// Preprocessor interface. 2867#include "compiler/preprocessor/preprocess.h" 2868 2869#define SETUP_CONTEXT(pp) \ 2870 TParseContext* context = (TParseContext*) pp->pC; \ 2871 struct yyguts_t* yyg = (struct yyguts_t*) context->scanner; 2872 2873// Preprocessor callbacks. 2874void CPPDebugLogMsg(const char *msg) 2875{ 2876 SETUP_CONTEXT(cpp); 2877 context->infoSink.debug.message(EPrefixNone, msg); 2878} 2879 2880void CPPWarningToInfoLog(const char *msg) 2881{ 2882 SETUP_CONTEXT(cpp); 2883 context->warning(yylineno, msg, "", ""); 2884} 2885 2886void CPPShInfoLogMsg(const char *msg) 2887{ 2888 SETUP_CONTEXT(cpp); 2889 context->error(yylineno, msg, "", ""); 2890 context->recover(); 2891} 2892 2893void CPPErrorToInfoLog(char *msg) 2894{ 2895 SETUP_CONTEXT(cpp); 2896 context->error(yylineno, msg, "", ""); 2897 context->recover(); 2898} 2899 2900void SetLineNumber(int line) 2901{ 2902 SETUP_CONTEXT(cpp); 2903 int string = 0; 2904 DecodeSourceLoc(yylineno, &string, NULL); 2905 yylineno = EncodeSourceLoc(string, line); 2906} 2907 2908void SetStringNumber(int string) 2909{ 2910 SETUP_CONTEXT(cpp); 2911 int line = 0; 2912 DecodeSourceLoc(yylineno, NULL, &line); 2913 yylineno = EncodeSourceLoc(string, line); 2914} 2915 2916int GetStringNumber() 2917{ 2918 SETUP_CONTEXT(cpp); 2919 int string = 0; 2920 DecodeSourceLoc(yylineno, &string, NULL); 2921 return string; 2922} 2923 2924int GetLineNumber() 2925{ 2926 SETUP_CONTEXT(cpp); 2927 int line = 0; 2928 DecodeSourceLoc(yylineno, NULL, &line); 2929 return line; 2930} 2931 2932void IncLineNumber() 2933{ 2934 SETUP_CONTEXT(cpp); 2935 int string = 0, line = 0; 2936 DecodeSourceLoc(yylineno, &string, &line); 2937 yylineno = EncodeSourceLoc(string, ++line); 2938} 2939 2940void DecLineNumber() 2941{ 2942 SETUP_CONTEXT(cpp); 2943 int string = 0, line = 0; 2944 DecodeSourceLoc(yylineno, &string, &line); 2945 yylineno = EncodeSourceLoc(string, --line); 2946} 2947 2948void HandlePragma(const char **tokens, int numTokens) 2949{ 2950 SETUP_CONTEXT(cpp); 2951 if (!strcmp(tokens[0], "optimize")) { 2952 if (numTokens != 4) { 2953 CPPShInfoLogMsg("optimize pragma syntax is incorrect"); 2954 return; 2955 } 2956 2957 if (strcmp(tokens[1], "(")) { 2958 CPPShInfoLogMsg("\"(\" expected after 'optimize' keyword"); 2959 return; 2960 } 2961 2962 if (!strcmp(tokens[2], "on")) 2963 context->contextPragma.optimize = true; 2964 else if (!strcmp(tokens[2], "off")) 2965 context->contextPragma.optimize = false; 2966 else { 2967 CPPShInfoLogMsg("\"on\" or \"off\" expected after '(' for 'optimize' pragma"); 2968 return; 2969 } 2970 2971 if (strcmp(tokens[3], ")")) { 2972 CPPShInfoLogMsg("\")\" expected to end 'optimize' pragma"); 2973 return; 2974 } 2975 } else if (!strcmp(tokens[0], "debug")) { 2976 if (numTokens != 4) { 2977 CPPShInfoLogMsg("debug pragma syntax is incorrect"); 2978 return; 2979 } 2980 2981 if (strcmp(tokens[1], "(")) { 2982 CPPShInfoLogMsg("\"(\" expected after 'debug' keyword"); 2983 return; 2984 } 2985 2986 if (!strcmp(tokens[2], "on")) 2987 context->contextPragma.debug = true; 2988 else if (!strcmp(tokens[2], "off")) 2989 context->contextPragma.debug = false; 2990 else { 2991 CPPShInfoLogMsg("\"on\" or \"off\" expected after '(' for 'debug' pragma"); 2992 return; 2993 } 2994 2995 if (strcmp(tokens[3], ")")) { 2996 CPPShInfoLogMsg("\")\" expected to end 'debug' pragma"); 2997 return; 2998 } 2999 } else { 3000#ifdef PRAGMA_TABLE 3001 // 3002 // implementation specific pragma 3003 // use ((TParseContext *)cpp->pC)->contextPragma.pragmaTable to store the information about pragma 3004 // For now, just ignore the pragma that the implementation cannot recognize 3005 // An Example of one such implementation for a pragma that has a syntax like 3006 // #pragma pragmaname(pragmavalue) 3007 // This implementation stores the current pragmavalue against the pragma name in pragmaTable. 3008 // 3009 if (numTokens == 4 && !strcmp(tokens[1], "(") && !strcmp(tokens[3], ")")) { 3010 TPragmaTable& pragmaTable = ((TParseContext *)cpp->pC)->contextPragma.pragmaTable; 3011 TPragmaTable::iterator iter; 3012 iter = pragmaTable.find(TString(tokens[0])); 3013 if (iter != pragmaTable.end()) { 3014 iter->second = tokens[2]; 3015 } else { 3016 pragmaTable[ tokens[0] ] = tokens[2]; 3017 } 3018 } else if (numTokens >= 2) { 3019 TPragmaTable& pragmaTable = ((TParseContext *)cpp->pC)->contextPragma.pragmaTable; 3020 TPragmaTable::iterator iter; 3021 iter = pragmaTable.find(TString(tokens[0])); 3022 if (iter != pragmaTable.end()) { 3023 iter->second = tokens[1]; 3024 } else { 3025 pragmaTable[ tokens[0] ] = tokens[1]; 3026 } 3027 } 3028#endif // PRAGMA_TABLE 3029 } 3030} 3031 3032void StoreStr(char *string) 3033{ 3034 SETUP_CONTEXT(cpp); 3035 TString strSrc; 3036 strSrc = TString(string); 3037 3038 context->HashErrMsg = context->HashErrMsg + " " + strSrc; 3039} 3040 3041const char* GetStrfromTStr(void) 3042{ 3043 SETUP_CONTEXT(cpp); 3044 cpp->ErrMsg = context->HashErrMsg.c_str(); 3045 return cpp->ErrMsg; 3046} 3047 3048void ResetTString(void) 3049{ 3050 SETUP_CONTEXT(cpp); 3051 context->HashErrMsg = ""; 3052} 3053 3054TBehavior GetBehavior(const char* behavior) 3055{ 3056 if (!strcmp("require", behavior)) 3057 return EBhRequire; 3058 else if (!strcmp("enable", behavior)) 3059 return EBhEnable; 3060 else if (!strcmp("disable", behavior)) 3061 return EBhDisable; 3062 else if (!strcmp("warn", behavior)) 3063 return EBhWarn; 3064 else { 3065 CPPShInfoLogMsg((TString("behavior '") + behavior + "' is not supported").c_str()); 3066 return EBhDisable; 3067 } 3068} 3069 3070void updateExtensionBehavior(const char* extName, const char* behavior) 3071{ 3072 SETUP_CONTEXT(cpp); 3073 TBehavior behaviorVal = GetBehavior(behavior); 3074 TMap<TString, TBehavior>:: iterator iter; 3075 TString msg; 3076 3077 // special cased for all extension 3078 if (!strcmp(extName, "all")) { 3079 if (behaviorVal == EBhRequire || behaviorVal == EBhEnable) { 3080 CPPShInfoLogMsg("extension 'all' cannot have 'require' or 'enable' behavior"); 3081 return; 3082 } else { 3083 for (iter = context->extensionBehavior.begin(); iter != context->extensionBehavior.end(); ++iter) 3084 iter->second = behaviorVal; 3085 } 3086 } else { 3087 iter = context->extensionBehavior.find(TString(extName)); 3088 if (iter == context->extensionBehavior.end()) { 3089 switch (behaviorVal) { 3090 case EBhRequire: 3091 CPPShInfoLogMsg((TString("extension '") + extName + "' is not supported").c_str()); 3092 break; 3093 case EBhEnable: 3094 case EBhWarn: 3095 case EBhDisable: 3096 msg = TString("extension '") + extName + "' is not supported"; 3097 context->infoSink.info.message(EPrefixWarning, msg.c_str(), yylineno); 3098 break; 3099 } 3100 return; 3101 } else 3102 iter->second = behaviorVal; 3103 } 3104} 3105} // extern "C" 3106 3107int string_input(char* buf, int max_size, yyscan_t yyscanner) { 3108 int len; 3109 3110 if ((len = yylex_CPP(buf, max_size)) == 0) 3111 return 0; 3112 if (len >= max_size) 3113 YY_FATAL_ERROR("input buffer overflow, can't enlarge buffer because scanner uses REJECT"); 3114 3115 buf[len] = ' '; 3116 return len+1; 3117} 3118 3119int check_type(yyscan_t yyscanner) { 3120 struct yyguts_t* yyg = (struct yyguts_t*) yyscanner; 3121 3122 int token = IDENTIFIER; 3123 TSymbol* symbol = yyextra->symbolTable.find(yytext); 3124 if (yyextra->lexAfterType == false && symbol && symbol->isVariable()) { 3125 TVariable* variable = static_cast<TVariable*>(symbol); 3126 if (variable->isUserType()) { 3127 yyextra->lexAfterType = true; 3128 token = TYPE_NAME; 3129 } 3130 } 3131 yylval->lex.symbol = symbol; 3132 return token; 3133} 3134 3135int reserved_word(yyscan_t yyscanner) { 3136 struct yyguts_t* yyg = (struct yyguts_t*) yyscanner; 3137 3138 yyextra->error(yylineno, "Illegal use of reserved word", yytext, ""); 3139 yyextra->recover(); 3140 return 0; 3141} 3142 3143void yyerror(TParseContext* context, const char* reason) { 3144 struct yyguts_t* yyg = (struct yyguts_t*) context->scanner; 3145 3146 if (context->AfterEOF) { 3147 context->error(yylineno, reason, "unexpected EOF", ""); 3148 } else { 3149 context->error(yylineno, reason, yytext, ""); 3150 } 3151 context->recover(); 3152} 3153 3154int glslang_initialize(TParseContext* context) { 3155 yyscan_t scanner = NULL; 3156 if (yylex_init_extra(context,&scanner)) 3157 return 1; 3158 3159 context->scanner = scanner; 3160 return 0; 3161} 3162 3163int glslang_finalize(TParseContext* context) { 3164 yyscan_t scanner = context->scanner; 3165 if (scanner == NULL) return 0; 3166 3167 context->scanner = NULL; 3168 return yylex_destroy(scanner); 3169} 3170 3171void glslang_scan(int count, const char* const string[], const int length[], 3172 TParseContext* context) { 3173 yyrestart(NULL,context->scanner); 3174 yyset_lineno(EncodeSourceLoc(0, 1),context->scanner); 3175 context->AfterEOF = false; 3176 3177 // Init preprocessor. 3178 cpp->pC = context; 3179 cpp->PaWhichStr = 0; 3180 cpp->PaArgv = string; 3181 cpp->PaArgc = count; 3182 cpp->PaStrLen = length; 3183 cpp->pastFirstStatement = 0; 3184 ScanFromString(string[0]); 3185} 3186 3187