1 #line 16 "./Tokenizer.l" 2 // 3 // Copyright (c) 2011-2013 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_parser.sh. DO NOT EDIT! 9 10 11 12 #line 13 "./Tokenizer.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> 53 typedef int8_t flex_int8_t; 54 typedef uint8_t flex_uint8_t; 55 typedef int16_t flex_int16_t; 56 typedef uint16_t flex_uint16_t; 57 typedef int32_t flex_int32_t; 58 typedef uint32_t flex_uint32_t; 59 typedef uint64_t flex_uint64_t; 60 #else 61 typedef signed char flex_int8_t; 62 typedef short int flex_int16_t; 63 typedef int flex_int32_t; 64 typedef unsigned char flex_uint8_t; 65 typedef unsigned short int flex_uint16_t; 66 typedef unsigned int flex_uint32_t; 67 #endif /* ! C99 */ 68 69 /* Limits of integral types. */ 70 #ifndef INT8_MIN 71 #define INT8_MIN (-128) 72 #endif 73 #ifndef INT16_MIN 74 #define INT16_MIN (-32767-1) 75 #endif 76 #ifndef INT32_MIN 77 #define INT32_MIN (-2147483647-1) 78 #endif 79 #ifndef INT8_MAX 80 #define INT8_MAX (127) 81 #endif 82 #ifndef INT16_MAX 83 #define INT16_MAX (32767) 84 #endif 85 #ifndef INT32_MAX 86 #define INT32_MAX (2147483647) 87 #endif 88 #ifndef UINT8_MAX 89 #define UINT8_MAX (255U) 90 #endif 91 #ifndef UINT16_MAX 92 #define UINT16_MAX (65535U) 93 #endif 94 #ifndef UINT32_MAX 95 #define UINT32_MAX (4294967295U) 96 #endif 97 98 #endif /* ! FLEXINT_H */ 99 100 #ifdef __cplusplus 101 102 /* The "const" storage-class-modifier is valid. */ 103 #define YY_USE_CONST 104 105 #else /* ! __cplusplus */ 106 107 /* C99 requires __STDC__ to be defined as 1. */ 108 #if defined (__STDC__) 109 110 #define YY_USE_CONST 111 112 #endif /* defined (__STDC__) */ 113 #endif /* ! __cplusplus */ 114 115 #ifdef YY_USE_CONST 116 #define yyconst const 117 #else 118 #define yyconst 119 #endif 120 121 /* Returned upon end-of-file. */ 122 #define YY_NULL 0 123 124 /* Promotes a possibly negative, possibly signed char to an unsigned 125 * integer for use as an array index. If the signed char is negative, 126 * we want to instead treat it as an 8-bit unsigned char, hence the 127 * double cast. 128 */ 129 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 130 131 /* An opaque pointer. */ 132 #ifndef YY_TYPEDEF_YY_SCANNER_T 133 #define YY_TYPEDEF_YY_SCANNER_T 134 typedef void* yyscan_t; 135 #endif 136 137 /* For convenience, these vars (plus the bison vars far below) 138 are macros in the reentrant scanner. */ 139 #define yyin yyg->yyin_r 140 #define yyout yyg->yyout_r 141 #define yyextra yyg->yyextra_r 142 #define yyleng yyg->yyleng_r 143 #define yytext yyg->yytext_r 144 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) 145 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) 146 #define yy_flex_debug yyg->yy_flex_debug_r 147 148 /* Enter a start condition. This macro really ought to take a parameter, 149 * but we do it the disgusting crufty way forced on us by the ()-less 150 * definition of BEGIN. 151 */ 152 #define BEGIN yyg->yy_start = 1 + 2 * 153 154 /* Translate the current start state into a value that can be later handed 155 * to BEGIN to return to the state. The YYSTATE alias is for lex 156 * compatibility. 157 */ 158 #define YY_START ((yyg->yy_start - 1) / 2) 159 #define YYSTATE YY_START 160 161 /* Action number for EOF rule of a given start state. */ 162 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 163 164 /* Special action meaning "start processing a new file". */ 165 #define YY_NEW_FILE pprestart(yyin ,yyscanner ) 166 167 #define YY_END_OF_BUFFER_CHAR 0 168 169 /* Size of default input buffer. */ 170 #ifndef YY_BUF_SIZE 171 #define YY_BUF_SIZE 16384 172 #endif 173 174 /* The state buf must be large enough to hold one state per character in the main buffer. 175 */ 176 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 177 178 #ifndef YY_TYPEDEF_YY_BUFFER_STATE 179 #define YY_TYPEDEF_YY_BUFFER_STATE 180 typedef struct yy_buffer_state *YY_BUFFER_STATE; 181 #endif 182 183 #ifndef YY_TYPEDEF_YY_SIZE_T 184 #define YY_TYPEDEF_YY_SIZE_T 185 typedef size_t yy_size_t; 186 #endif 187 188 #define EOB_ACT_CONTINUE_SCAN 0 189 #define EOB_ACT_END_OF_FILE 1 190 #define EOB_ACT_LAST_MATCH 2 191 192 #define YY_LESS_LINENO(n) 193 194 /* Return all but the first "n" matched characters back to the input stream. */ 195 #define yyless(n) \ 196 do \ 197 { \ 198 /* Undo effects of setting up yytext. */ \ 199 int yyless_macro_arg = (n); \ 200 YY_LESS_LINENO(yyless_macro_arg);\ 201 *yy_cp = yyg->yy_hold_char; \ 202 YY_RESTORE_YY_MORE_OFFSET \ 203 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 204 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 205 } \ 206 while ( 0 ) 207 208 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner ) 209 210 #ifndef YY_STRUCT_YY_BUFFER_STATE 211 #define YY_STRUCT_YY_BUFFER_STATE 212 struct yy_buffer_state 213 { 214 FILE *yy_input_file; 215 216 char *yy_ch_buf; /* input buffer */ 217 char *yy_buf_pos; /* current position in input buffer */ 218 219 /* Size of input buffer in bytes, not including room for EOB 220 * characters. 221 */ 222 yy_size_t yy_buf_size; 223 224 /* Number of characters read into yy_ch_buf, not including EOB 225 * characters. 226 */ 227 yy_size_t yy_n_chars; 228 229 /* Whether we "own" the buffer - i.e., we know we created it, 230 * and can realloc() it to grow it, and should free() it to 231 * delete it. 232 */ 233 int yy_is_our_buffer; 234 235 /* Whether this is an "interactive" input source; if so, and 236 * if we're using stdio for input, then we want to use getc() 237 * instead of fread(), to make sure we stop fetching input after 238 * each newline. 239 */ 240 int yy_is_interactive; 241 242 /* Whether we're considered to be at the beginning of a line. 243 * If so, '^' rules will be active on the next match, otherwise 244 * not. 245 */ 246 int yy_at_bol; 247 248 int yy_bs_lineno; /**< The line count. */ 249 int yy_bs_column; /**< The column count. */ 250 251 /* Whether to try to fill the input buffer when we reach the 252 * end of it. 253 */ 254 int yy_fill_buffer; 255 256 int yy_buffer_status; 257 258 #define YY_BUFFER_NEW 0 259 #define YY_BUFFER_NORMAL 1 260 /* When an EOF's been seen but there's still some text to process 261 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 262 * shouldn't try reading from the input source any more. We might 263 * still have a bunch of tokens to match, though, because of 264 * possible backing-up. 265 * 266 * When we actually see the EOF, we change the status to "new" 267 * (via pprestart()), so that the user can continue scanning by 268 * just pointing yyin at a new input file. 269 */ 270 #define YY_BUFFER_EOF_PENDING 2 271 272 }; 273 #endif /* !YY_STRUCT_YY_BUFFER_STATE */ 274 275 /* We provide macros for accessing buffer states in case in the 276 * future we want to put the buffer states in a more general 277 * "scanner state". 278 * 279 * Returns the top of the stack, or NULL. 280 */ 281 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ 282 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ 283 : NULL) 284 285 /* Same as previous macro, but useful when we know that the buffer stack is not 286 * NULL or when we need an lvalue. For internal use only. 287 */ 288 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] 289 290 void pprestart (FILE *input_file ,yyscan_t yyscanner ); 291 void pp_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner ); 292 YY_BUFFER_STATE pp_create_buffer (FILE *file,int size ,yyscan_t yyscanner ); 293 void pp_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner ); 294 void pp_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner ); 295 void pppush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner ); 296 void pppop_buffer_state (yyscan_t yyscanner ); 297 298 static void ppensure_buffer_stack (yyscan_t yyscanner ); 299 static void pp_load_buffer_state (yyscan_t yyscanner ); 300 static void pp_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner ); 301 302 #define YY_FLUSH_BUFFER pp_flush_buffer(YY_CURRENT_BUFFER ,yyscanner) 303 304 YY_BUFFER_STATE pp_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner ); 305 YY_BUFFER_STATE pp_scan_string (yyconst char *yy_str ,yyscan_t yyscanner ); 306 YY_BUFFER_STATE pp_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner ); 307 308 void *ppalloc (yy_size_t ,yyscan_t yyscanner ); 309 void *pprealloc (void *,yy_size_t ,yyscan_t yyscanner ); 310 void ppfree (void * ,yyscan_t yyscanner ); 311 312 #define yy_new_buffer pp_create_buffer 313 314 #define yy_set_interactive(is_interactive) \ 315 { \ 316 if ( ! YY_CURRENT_BUFFER ){ \ 317 ppensure_buffer_stack (yyscanner); \ 318 YY_CURRENT_BUFFER_LVALUE = \ 319 pp_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ 320 } \ 321 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 322 } 323 324 #define yy_set_bol(at_bol) \ 325 { \ 326 if ( ! YY_CURRENT_BUFFER ){\ 327 ppensure_buffer_stack (yyscanner); \ 328 YY_CURRENT_BUFFER_LVALUE = \ 329 pp_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \ 330 } \ 331 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 332 } 333 334 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 335 336 /* Begin user sect3 */ 337 338 #define ppwrap(n) 1 339 #define YY_SKIP_YYWRAP 340 341 typedef unsigned char YY_CHAR; 342 343 typedef int yy_state_type; 344 345 #define yytext_ptr yytext_r 346 347 static yy_state_type yy_get_previous_state (yyscan_t yyscanner ); 348 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner); 349 static int yy_get_next_buffer (yyscan_t yyscanner ); 350 static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner ); 351 352 /* Done after the current pattern has been matched and before the 353 * corresponding action - sets up yytext. 354 */ 355 #define YY_DO_BEFORE_ACTION \ 356 yyg->yytext_ptr = yy_bp; \ 357 yyleng = (yy_size_t) (yy_cp - yy_bp); \ 358 yyg->yy_hold_char = *yy_cp; \ 359 *yy_cp = '\0'; \ 360 yyg->yy_c_buf_p = yy_cp; 361 362 #define YY_NUM_RULES 38 363 #define YY_END_OF_BUFFER 39 364 /* This struct is not used in this scanner, 365 but its presence is necessary. */ 366 struct yy_trans_info 367 { 368 flex_int32_t yy_verify; 369 flex_int32_t yy_nxt; 370 }; 371 static yyconst flex_int16_t yy_accept[87] = 372 { 0, 373 0, 0, 0, 0, 39, 37, 34, 35, 35, 33, 374 7, 33, 33, 33, 33, 33, 33, 33, 33, 9, 375 9, 33, 33, 33, 8, 37, 33, 33, 3, 5, 376 5, 4, 34, 35, 19, 27, 20, 30, 25, 12, 377 23, 13, 24, 10, 2, 1, 26, 10, 9, 11, 378 11, 11, 11, 9, 14, 16, 18, 17, 15, 8, 379 36, 36, 31, 21, 32, 22, 3, 5, 6, 11, 380 10, 11, 1, 10, 11, 0, 10, 9, 28, 29, 381 0, 10, 10, 10, 10, 0 382 } ; 383 384 static yyconst flex_int32_t yy_ec[256] = 385 { 0, 386 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 387 2, 2, 4, 1, 1, 1, 1, 1, 1, 1, 388 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 389 1, 2, 5, 1, 6, 1, 7, 8, 1, 9, 390 9, 10, 11, 9, 12, 13, 14, 15, 16, 16, 391 16, 16, 16, 16, 16, 17, 17, 9, 9, 18, 392 19, 20, 9, 1, 21, 21, 21, 21, 22, 21, 393 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 394 23, 23, 23, 23, 23, 23, 23, 24, 23, 23, 395 9, 25, 9, 26, 23, 1, 21, 21, 21, 21, 396 397 22, 21, 23, 23, 23, 23, 23, 23, 23, 23, 398 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 399 23, 23, 9, 27, 9, 9, 1, 1, 1, 1, 400 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 401 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 402 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 403 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 404 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 405 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 406 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 407 408 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 409 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 410 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 411 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 412 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 413 1, 1, 1, 1, 1 414 } ; 415 416 static yyconst flex_int32_t yy_meta[28] = 417 { 0, 418 1, 1, 2, 2, 1, 1, 1, 1, 1, 3, 419 1, 1, 4, 1, 5, 5, 5, 1, 1, 1, 420 5, 5, 5, 5, 1, 1, 1 421 } ; 422 423 static yyconst flex_int16_t yy_base[92] = 424 { 0, 425 0, 0, 25, 27, 162, 163, 159, 163, 152, 132, 426 163, 131, 24, 163, 116, 22, 26, 31, 30, 37, 427 40, 44, 115, 46, 0, 64, 50, 15, 0, 163, 428 124, 91, 88, 163, 163, 163, 163, 163, 163, 163, 429 163, 163, 163, 64, 163, 0, 163, 76, 54, 58, 430 79, 91, 91, 0, 56, 163, 163, 163, 32, 0, 431 163, 36, 163, 163, 163, 163, 0, 163, 163, 94, 432 0, 106, 0, 0, 113, 55, 72, 113, 163, 163, 433 116, 101, 108, 123, 126, 163, 143, 31, 148, 153, 434 155 435 436 } ; 437 438 static yyconst flex_int16_t yy_def[92] = 439 { 0, 440 86, 1, 87, 87, 86, 86, 86, 86, 86, 86, 441 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 442 20, 86, 86, 86, 88, 86, 86, 86, 89, 86, 443 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 444 86, 86, 86, 86, 86, 90, 86, 86, 20, 20, 445 48, 51, 91, 21, 86, 86, 86, 86, 86, 88, 446 86, 86, 86, 86, 86, 86, 89, 86, 86, 44, 447 44, 70, 90, 48, 51, 86, 52, 91, 86, 86, 448 86, 72, 75, 86, 86, 0, 86, 86, 86, 86, 449 86 450 451 } ; 452 453 static yyconst flex_int16_t yy_nxt[191] = 454 { 0, 455 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 456 16, 17, 18, 19, 20, 21, 21, 22, 23, 24, 457 25, 25, 25, 25, 26, 27, 28, 30, 31, 30, 458 31, 37, 40, 65, 32, 60, 32, 42, 61, 45, 459 41, 66, 38, 46, 43, 44, 44, 44, 47, 48, 460 80, 49, 49, 50, 54, 54, 54, 51, 52, 51, 461 53, 55, 56, 51, 58, 59, 61, 62, 63, 84, 462 84, 84, 50, 50, 79, 64, 70, 51, 71, 71, 463 71, 51, 86, 86, 70, 72, 70, 70, 51, 33, 464 74, 74, 74, 51, 51, 51, 51, 75, 51, 51, 465 466 51, 76, 76, 51, 69, 77, 77, 77, 70, 70, 467 70, 86, 86, 51, 51, 70, 81, 81, 86, 86, 468 82, 82, 82, 81, 81, 51, 68, 83, 83, 83, 469 85, 85, 85, 57, 39, 51, 51, 84, 84, 84, 470 85, 85, 85, 29, 29, 29, 29, 29, 67, 36, 471 35, 67, 67, 73, 34, 73, 73, 73, 78, 78, 472 33, 86, 5, 86, 86, 86, 86, 86, 86, 86, 473 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 474 86, 86, 86, 86, 86, 86, 86, 86, 86, 86 475 } ; 476 477 static yyconst flex_int16_t yy_chk[191] = 478 { 0, 479 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 480 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 481 1, 1, 1, 1, 1, 1, 1, 3, 3, 4, 482 4, 13, 16, 28, 3, 88, 4, 17, 62, 19, 483 16, 28, 13, 19, 17, 18, 18, 18, 19, 20, 484 59, 20, 20, 20, 21, 21, 21, 20, 20, 20, 485 20, 22, 22, 21, 24, 24, 26, 26, 27, 76, 486 76, 76, 50, 50, 55, 27, 44, 49, 44, 44, 487 44, 50, 77, 77, 44, 44, 44, 44, 48, 33, 488 48, 48, 48, 51, 51, 51, 48, 48, 48, 48, 489 490 51, 52, 52, 53, 32, 52, 52, 52, 70, 70, 491 70, 82, 82, 53, 53, 70, 72, 72, 83, 83, 492 72, 72, 72, 75, 75, 78, 31, 75, 75, 75, 493 81, 81, 81, 23, 15, 78, 78, 84, 84, 84, 494 85, 85, 85, 87, 87, 87, 87, 87, 89, 12, 495 10, 89, 89, 90, 9, 90, 90, 90, 91, 91, 496 7, 5, 86, 86, 86, 86, 86, 86, 86, 86, 497 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 498 86, 86, 86, 86, 86, 86, 86, 86, 86, 86 499 } ; 500 501 /* The intent behind this definition is that it'll catch 502 * any uses of REJECT which flex missed. 503 */ 504 #define REJECT reject_used_but_not_detected 505 #define yymore() yymore_used_but_not_detected 506 #define YY_MORE_ADJ 0 507 #define YY_RESTORE_YY_MORE_OFFSET 508 /* 509 // 510 // Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved. 511 // Use of this source code is governed by a BSD-style license that can be 512 // found in the LICENSE file. 513 // 514 515 This file contains the Lex specification for GLSL ES preprocessor. 516 Based on Microsoft Visual Studio 2010 Preprocessor Grammar: 517 http://msdn.microsoft.com/en-us/library/2scxys89.aspx 518 519 IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_parser.sh. 520 */ 521 522 #include "Tokenizer.h" 523 524 #include "DiagnosticsBase.h" 525 #include "Token.h" 526 527 #if defined(__GNUC__) 528 // Triggered by the auto-generated yy_fatal_error function. 529 #pragma GCC diagnostic ignored "-Wmissing-noreturn" 530 #endif 531 532 typedef std::string YYSTYPE; 533 typedef pp::SourceLocation YYLTYPE; 534 535 // Use the unused yycolumn variable to track file (string) number. 536 #define yyfileno yycolumn 537 538 #define YY_USER_INIT \ 539 do { \ 540 yyfileno = 0; \ 541 yylineno = 1; \ 542 yyextra->leadingSpace = false; \ 543 yyextra->lineStart = true; \ 544 } while(0); 545 546 #define YY_USER_ACTION \ 547 do \ 548 { \ 549 pp::Input* input = &yyextra->input; \ 550 pp::Input::Location* scanLoc = &yyextra->scanLoc; \ 551 while ((scanLoc->sIndex < input->count()) && \ 552 (scanLoc->cIndex >= input->length(scanLoc->sIndex))) \ 553 { \ 554 scanLoc->cIndex -= input->length(scanLoc->sIndex++); \ 555 ++yyfileno; yylineno = 1; \ 556 } \ 557 yylloc->file = yyfileno; \ 558 yylloc->line = yylineno; \ 559 scanLoc->cIndex += yyleng; \ 560 } while(0); 561 562 #define YY_INPUT(buf, result, maxSize) \ 563 result = yyextra->input.read(buf, maxSize); 564 565 #define INITIAL 0 566 #define COMMENT 1 567 568 #define YY_EXTRA_TYPE pp::Tokenizer::Context* 569 570 /* Holds the entire state of the reentrant scanner. */ 571 struct yyguts_t 572 { 573 574 /* User-defined. Not touched by flex. */ 575 YY_EXTRA_TYPE yyextra_r; 576 577 /* The rest are the same as the globals declared in the non-reentrant scanner. */ 578 FILE *yyin_r, *yyout_r; 579 size_t yy_buffer_stack_top; /**< index of top of stack. */ 580 size_t yy_buffer_stack_max; /**< capacity of stack. */ 581 YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ 582 char yy_hold_char; 583 yy_size_t yy_n_chars; 584 yy_size_t yyleng_r; 585 char *yy_c_buf_p; 586 int yy_init; 587 int yy_start; 588 int yy_did_buffer_switch_on_eof; 589 int yy_start_stack_ptr; 590 int yy_start_stack_depth; 591 int *yy_start_stack; 592 yy_state_type yy_last_accepting_state; 593 char* yy_last_accepting_cpos; 594 595 int yylineno_r; 596 int yy_flex_debug_r; 597 598 char *yytext_r; 599 int yy_more_flag; 600 int yy_more_len; 601 602 YYSTYPE * yylval_r; 603 604 YYLTYPE * yylloc_r; 605 606 }; /* end struct yyguts_t */ 607 608 static int yy_init_globals (yyscan_t yyscanner ); 609 610 /* This must go here because YYSTYPE and YYLTYPE are included 611 * from bison output in section 1.*/ 612 # define yylval yyg->yylval_r 613 614 # define yylloc yyg->yylloc_r 615 616 int pplex_init (yyscan_t* scanner); 617 618 int pplex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner); 619 620 /* Accessor methods to globals. 621 These are made visible to non-reentrant scanners for convenience. */ 622 623 int pplex_destroy (yyscan_t yyscanner ); 624 625 int ppget_debug (yyscan_t yyscanner ); 626 627 void ppset_debug (int debug_flag ,yyscan_t yyscanner ); 628 629 YY_EXTRA_TYPE ppget_extra (yyscan_t yyscanner ); 630 631 void ppset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner ); 632 633 FILE *ppget_in (yyscan_t yyscanner ); 634 635 void ppset_in (FILE * in_str ,yyscan_t yyscanner ); 636 637 FILE *ppget_out (yyscan_t yyscanner ); 638 639 void ppset_out (FILE * out_str ,yyscan_t yyscanner ); 640 641 yy_size_t ppget_leng (yyscan_t yyscanner ); 642 643 char *ppget_text (yyscan_t yyscanner ); 644 645 int ppget_lineno (yyscan_t yyscanner ); 646 647 void ppset_lineno (int line_number ,yyscan_t yyscanner ); 648 649 YYSTYPE * ppget_lval (yyscan_t yyscanner ); 650 651 void ppset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner ); 652 653 YYLTYPE *ppget_lloc (yyscan_t yyscanner ); 654 655 void ppset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner ); 656 657 /* Macros after this point can all be overridden by user definitions in 658 * section 1. 659 */ 660 661 #ifndef YY_SKIP_YYWRAP 662 #ifdef __cplusplus 663 extern "C" int ppwrap (yyscan_t yyscanner ); 664 #else 665 extern int ppwrap (yyscan_t yyscanner ); 666 #endif 667 #endif 668 669 #ifndef yytext_ptr 670 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner); 671 #endif 672 673 #ifdef YY_NEED_STRLEN 674 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner); 675 #endif 676 677 #ifndef YY_NO_INPUT 678 679 #ifdef __cplusplus 680 static int yyinput (yyscan_t yyscanner ); 681 #else 682 static int input (yyscan_t yyscanner ); 683 #endif 684 685 #endif 686 687 /* Amount of stuff to slurp up with each read. */ 688 #ifndef YY_READ_BUF_SIZE 689 #define YY_READ_BUF_SIZE 8192 690 #endif 691 692 /* Copy whatever the last rule matched to the standard output. */ 693 #ifndef ECHO 694 /* This used to be an fputs(), but since the string might contain NUL's, 695 * we now use fwrite(). 696 */ 697 #define ECHO fwrite( yytext, yyleng, 1, yyout ) 698 #endif 699 700 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 701 * is returned in "result". 702 */ 703 #ifndef YY_INPUT 704 #define YY_INPUT(buf,result,max_size) \ 705 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 706 { \ 707 int c = '*'; \ 708 yy_size_t n; \ 709 for ( n = 0; n < max_size && \ 710 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 711 buf[n] = (char) c; \ 712 if ( c == '\n' ) \ 713 buf[n++] = (char) c; \ 714 if ( c == EOF && ferror( yyin ) ) \ 715 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 716 result = n; \ 717 } \ 718 else \ 719 { \ 720 errno=0; \ 721 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ 722 { \ 723 if( errno != EINTR) \ 724 { \ 725 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 726 break; \ 727 } \ 728 errno=0; \ 729 clearerr(yyin); \ 730 } \ 731 }\ 732 \ 733 734 #endif 735 736 /* No semi-colon after return; correct usage is to write "yyterminate();" - 737 * we don't want an extra ';' after the "return" because that will cause 738 * some compilers to complain about unreachable statements. 739 */ 740 #ifndef yyterminate 741 #define yyterminate() return YY_NULL 742 #endif 743 744 /* Number of entries by which start-condition stack grows. */ 745 #ifndef YY_START_STACK_INCR 746 #define YY_START_STACK_INCR 25 747 #endif 748 749 /* Report a fatal error. */ 750 #ifndef YY_FATAL_ERROR 751 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) 752 #endif 753 754 /* end tables serialization structures and prototypes */ 755 756 /* Default declaration of generated scanner - a define so the user can 757 * easily add parameters. 758 */ 759 #ifndef YY_DECL 760 #define YY_DECL_IS_OURS 1 761 762 extern int pplex \ 763 (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner); 764 765 #define YY_DECL int pplex \ 766 (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner) 767 #endif /* !YY_DECL */ 768 769 /* Code executed at the beginning of each rule, after yytext and yyleng 770 * have been set up. 771 */ 772 #ifndef YY_USER_ACTION 773 #define YY_USER_ACTION 774 #endif 775 776 /* Code executed at the end of each rule. */ 777 #ifndef YY_BREAK 778 #define YY_BREAK break; 779 #endif 780 781 #define YY_RULE_SETUP \ 782 YY_USER_ACTION 783 784 /** The main scanner function which does all the work. 785 */ 786 YY_DECL 787 { 788 register yy_state_type yy_current_state; 789 register char *yy_cp, *yy_bp; 790 register int yy_act; 791 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 792 793 /* Line comment */ 794 795 yylval = yylval_param; 796 797 yylloc = yylloc_param; 798 799 if ( !yyg->yy_init ) 800 { 801 yyg->yy_init = 1; 802 803 #ifdef YY_USER_INIT 804 YY_USER_INIT; 805 #endif 806 807 if ( ! yyg->yy_start ) 808 yyg->yy_start = 1; /* first start state */ 809 810 if ( ! yyin ) 811 yyin = stdin; 812 813 if ( ! yyout ) 814 yyout = stdout; 815 816 if ( ! YY_CURRENT_BUFFER ) { 817 ppensure_buffer_stack (yyscanner); 818 YY_CURRENT_BUFFER_LVALUE = 819 pp_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); 820 } 821 822 pp_load_buffer_state(yyscanner ); 823 } 824 825 while ( 1 ) /* loops until end-of-file is reached */ 826 { 827 yy_cp = yyg->yy_c_buf_p; 828 829 /* Support of yytext. */ 830 *yy_cp = yyg->yy_hold_char; 831 832 /* yy_bp points to the position in yy_ch_buf of the start of 833 * the current run. 834 */ 835 yy_bp = yy_cp; 836 837 yy_current_state = yyg->yy_start; 838 yy_match: 839 do 840 { 841 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 842 if ( yy_accept[yy_current_state] ) 843 { 844 yyg->yy_last_accepting_state = yy_current_state; 845 yyg->yy_last_accepting_cpos = yy_cp; 846 } 847 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 848 { 849 yy_current_state = (int) yy_def[yy_current_state]; 850 if ( yy_current_state >= 87 ) 851 yy_c = yy_meta[(unsigned int) yy_c]; 852 } 853 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 854 ++yy_cp; 855 } 856 while ( yy_current_state != 86 ); 857 yy_cp = yyg->yy_last_accepting_cpos; 858 yy_current_state = yyg->yy_last_accepting_state; 859 860 yy_find_action: 861 yy_act = yy_accept[yy_current_state]; 862 863 YY_DO_BEFORE_ACTION; 864 865 do_action: /* This label is used only to access EOF actions. */ 866 867 switch ( yy_act ) 868 { /* beginning of action switch */ 869 case 0: /* must back up */ 870 /* undo the effects of YY_DO_BEFORE_ACTION */ 871 *yy_cp = yyg->yy_hold_char; 872 yy_cp = yyg->yy_last_accepting_cpos; 873 yy_current_state = yyg->yy_last_accepting_state; 874 goto yy_find_action; 875 876 case 1: 877 YY_RULE_SETUP 878 879 YY_BREAK 880 /* Block comment */ 881 /* Line breaks are just counted - not returned. */ 882 /* The comment is replaced by a single space. */ 883 case 2: 884 YY_RULE_SETUP 885 { BEGIN(COMMENT); } 886 YY_BREAK 887 case 3: 888 YY_RULE_SETUP 889 890 YY_BREAK 891 case 4: 892 YY_RULE_SETUP 893 894 YY_BREAK 895 case 5: 896 /* rule 5 can match eol */ 897 YY_RULE_SETUP 898 { ++yylineno; } 899 YY_BREAK 900 case 6: 901 YY_RULE_SETUP 902 { 903 yyextra->leadingSpace = true; 904 BEGIN(INITIAL); 905 } 906 YY_BREAK 907 case 7: 908 YY_RULE_SETUP 909 { 910 // # is only valid at start of line for preprocessor directives. 911 yylval->assign(1, yytext[0]); 912 return yyextra->lineStart ? pp::Token::PP_HASH : pp::Token::PP_OTHER; 913 } 914 YY_BREAK 915 case 8: 916 YY_RULE_SETUP 917 { 918 yylval->assign(yytext, yyleng); 919 return pp::Token::IDENTIFIER; 920 } 921 YY_BREAK 922 case 9: 923 YY_RULE_SETUP 924 { 925 yylval->assign(yytext, yyleng); 926 return pp::Token::CONST_INT; 927 } 928 YY_BREAK 929 case 10: 930 YY_RULE_SETUP 931 { 932 yylval->assign(yytext, yyleng); 933 return pp::Token::CONST_FLOAT; 934 } 935 YY_BREAK 936 /* Anything that starts with a {DIGIT} or .{DIGIT} must be a number. */ 937 /* Rule to catch all invalid integers and floats. */ 938 case 11: 939 YY_RULE_SETUP 940 { 941 yylval->assign(yytext, yyleng); 942 return pp::Token::PP_NUMBER; 943 } 944 YY_BREAK 945 case 12: 946 YY_RULE_SETUP 947 { 948 yylval->assign(yytext, yyleng); 949 return pp::Token::OP_INC; 950 } 951 YY_BREAK 952 case 13: 953 YY_RULE_SETUP 954 { 955 yylval->assign(yytext, yyleng); 956 return pp::Token::OP_DEC; 957 } 958 YY_BREAK 959 case 14: 960 YY_RULE_SETUP 961 { 962 yylval->assign(yytext, yyleng); 963 return pp::Token::OP_LEFT; 964 } 965 YY_BREAK 966 case 15: 967 YY_RULE_SETUP 968 { 969 yylval->assign(yytext, yyleng); 970 return pp::Token::OP_RIGHT; 971 } 972 YY_BREAK 973 case 16: 974 YY_RULE_SETUP 975 { 976 yylval->assign(yytext, yyleng); 977 return pp::Token::OP_LE; 978 } 979 YY_BREAK 980 case 17: 981 YY_RULE_SETUP 982 { 983 yylval->assign(yytext, yyleng); 984 return pp::Token::OP_GE; 985 } 986 YY_BREAK 987 case 18: 988 YY_RULE_SETUP 989 { 990 yylval->assign(yytext, yyleng); 991 return pp::Token::OP_EQ; 992 } 993 YY_BREAK 994 case 19: 995 YY_RULE_SETUP 996 { 997 yylval->assign(yytext, yyleng); 998 return pp::Token::OP_NE; 999 } 1000 YY_BREAK 1001 case 20: 1002 YY_RULE_SETUP 1003 { 1004 yylval->assign(yytext, yyleng); 1005 return pp::Token::OP_AND; 1006 } 1007 YY_BREAK 1008 case 21: 1009 YY_RULE_SETUP 1010 { 1011 yylval->assign(yytext, yyleng); 1012 return pp::Token::OP_XOR; 1013 } 1014 YY_BREAK 1015 case 22: 1016 YY_RULE_SETUP 1017 { 1018 yylval->assign(yytext, yyleng); 1019 return pp::Token::OP_OR; 1020 } 1021 YY_BREAK 1022 case 23: 1023 YY_RULE_SETUP 1024 { 1025 yylval->assign(yytext, yyleng); 1026 return pp::Token::OP_ADD_ASSIGN; 1027 } 1028 YY_BREAK 1029 case 24: 1030 YY_RULE_SETUP 1031 { 1032 yylval->assign(yytext, yyleng); 1033 return pp::Token::OP_SUB_ASSIGN; 1034 } 1035 YY_BREAK 1036 case 25: 1037 YY_RULE_SETUP 1038 { 1039 yylval->assign(yytext, yyleng); 1040 return pp::Token::OP_MUL_ASSIGN; 1041 } 1042 YY_BREAK 1043 case 26: 1044 YY_RULE_SETUP 1045 { 1046 yylval->assign(yytext, yyleng); 1047 return pp::Token::OP_DIV_ASSIGN; 1048 } 1049 YY_BREAK 1050 case 27: 1051 YY_RULE_SETUP 1052 { 1053 yylval->assign(yytext, yyleng); 1054 return pp::Token::OP_MOD_ASSIGN; 1055 } 1056 YY_BREAK 1057 case 28: 1058 YY_RULE_SETUP 1059 { 1060 yylval->assign(yytext, yyleng); 1061 return pp::Token::OP_LEFT_ASSIGN; 1062 } 1063 YY_BREAK 1064 case 29: 1065 YY_RULE_SETUP 1066 { 1067 yylval->assign(yytext, yyleng); 1068 return pp::Token::OP_RIGHT_ASSIGN; 1069 } 1070 YY_BREAK 1071 case 30: 1072 YY_RULE_SETUP 1073 { 1074 yylval->assign(yytext, yyleng); 1075 return pp::Token::OP_AND_ASSIGN; 1076 } 1077 YY_BREAK 1078 case 31: 1079 YY_RULE_SETUP 1080 { 1081 yylval->assign(yytext, yyleng); 1082 return pp::Token::OP_XOR_ASSIGN; 1083 } 1084 YY_BREAK 1085 case 32: 1086 YY_RULE_SETUP 1087 { 1088 yylval->assign(yytext, yyleng); 1089 return pp::Token::OP_OR_ASSIGN; 1090 } 1091 YY_BREAK 1092 case 33: 1093 YY_RULE_SETUP 1094 { 1095 yylval->assign(1, yytext[0]); 1096 return yytext[0]; 1097 } 1098 YY_BREAK 1099 case 34: 1100 YY_RULE_SETUP 1101 { yyextra->leadingSpace = true; } 1102 YY_BREAK 1103 case 35: 1104 /* rule 35 can match eol */ 1105 YY_RULE_SETUP 1106 { 1107 ++yylineno; 1108 yylval->assign(1, '\n'); 1109 return '\n'; 1110 } 1111 YY_BREAK 1112 case 36: 1113 /* rule 36 can match eol */ 1114 YY_RULE_SETUP 1115 { ++yylineno; } 1116 YY_BREAK 1117 case 37: 1118 YY_RULE_SETUP 1119 { 1120 yylval->assign(1, yytext[0]); 1121 return pp::Token::PP_OTHER; 1122 } 1123 YY_BREAK 1124 case YY_STATE_EOF(INITIAL): 1125 case YY_STATE_EOF(COMMENT): 1126 { 1127 // YY_USER_ACTION is not invoked for handling EOF. 1128 // Set the location for EOF token manually. 1129 pp::Input* input = &yyextra->input; 1130 pp::Input::Location* scanLoc = &yyextra->scanLoc; 1131 yy_size_t sIndexMax = input->count() ? input->count() - 1 : 0; 1132 if (scanLoc->sIndex != sIndexMax) 1133 { 1134 // We can only reach here if there are empty strings at the 1135 // end of the input. 1136 scanLoc->sIndex = sIndexMax; scanLoc->cIndex = 0; 1137 // FIXME: this is not 64-bit clean. 1138 yyfileno = static_cast<int>(sIndexMax); yylineno = 1; 1139 } 1140 yylloc->file = yyfileno; 1141 yylloc->line = yylineno; 1142 yylval->clear(); 1143 1144 if (YY_START == COMMENT) 1145 { 1146 yyextra->diagnostics->report(pp::Diagnostics::EOF_IN_COMMENT, 1147 pp::SourceLocation(yyfileno, yylineno), 1148 ""); 1149 } 1150 yyterminate(); 1151 } 1152 YY_BREAK 1153 case 38: 1154 YY_RULE_SETUP 1155 ECHO; 1156 YY_BREAK 1157 1158 case YY_END_OF_BUFFER: 1159 { 1160 /* Amount of text matched not including the EOB char. */ 1161 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; 1162 1163 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1164 *yy_cp = yyg->yy_hold_char; 1165 YY_RESTORE_YY_MORE_OFFSET 1166 1167 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) 1168 { 1169 /* We're scanning a new file or input source. It's 1170 * possible that this happened because the user 1171 * just pointed yyin at a new source and called 1172 * pplex(). If so, then we have to assure 1173 * consistency between YY_CURRENT_BUFFER and our 1174 * globals. Here is the right place to do so, because 1175 * this is the first action (other than possibly a 1176 * back-up) that will match for the new input source. 1177 */ 1178 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 1179 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; 1180 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; 1181 } 1182 1183 /* Note that here we test for yy_c_buf_p "<=" to the position 1184 * of the first EOB in the buffer, since yy_c_buf_p will 1185 * already have been incremented past the NUL character 1186 * (since all states make transitions on EOB to the 1187 * end-of-buffer state). Contrast this with the test 1188 * in input(). 1189 */ 1190 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) 1191 { /* This was really a NUL. */ 1192 yy_state_type yy_next_state; 1193 1194 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; 1195 1196 yy_current_state = yy_get_previous_state( yyscanner ); 1197 1198 /* Okay, we're now positioned to make the NUL 1199 * transition. We couldn't have 1200 * yy_get_previous_state() go ahead and do it 1201 * for us because it doesn't know how to deal 1202 * with the possibility of jamming (and we don't 1203 * want to build jamming into it because then it 1204 * will run more slowly). 1205 */ 1206 1207 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 1208 1209 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; 1210 1211 if ( yy_next_state ) 1212 { 1213 /* Consume the NUL. */ 1214 yy_cp = ++yyg->yy_c_buf_p; 1215 yy_current_state = yy_next_state; 1216 goto yy_match; 1217 } 1218 1219 else 1220 { 1221 yy_cp = yyg->yy_last_accepting_cpos; 1222 yy_current_state = yyg->yy_last_accepting_state; 1223 goto yy_find_action; 1224 } 1225 } 1226 1227 else switch ( yy_get_next_buffer( yyscanner ) ) 1228 { 1229 case EOB_ACT_END_OF_FILE: 1230 { 1231 yyg->yy_did_buffer_switch_on_eof = 0; 1232 1233 if ( ppwrap(yyscanner ) ) 1234 { 1235 /* Note: because we've taken care in 1236 * yy_get_next_buffer() to have set up 1237 * yytext, we can now set up 1238 * yy_c_buf_p so that if some total 1239 * hoser (like flex itself) wants to 1240 * call the scanner after we return the 1241 * YY_NULL, it'll still work - another 1242 * YY_NULL will get returned. 1243 */ 1244 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; 1245 1246 yy_act = YY_STATE_EOF(YY_START); 1247 goto do_action; 1248 } 1249 1250 else 1251 { 1252 if ( ! yyg->yy_did_buffer_switch_on_eof ) 1253 YY_NEW_FILE; 1254 } 1255 break; 1256 } 1257 1258 case EOB_ACT_CONTINUE_SCAN: 1259 yyg->yy_c_buf_p = 1260 yyg->yytext_ptr + yy_amount_of_matched_text; 1261 1262 yy_current_state = yy_get_previous_state( yyscanner ); 1263 1264 yy_cp = yyg->yy_c_buf_p; 1265 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; 1266 goto yy_match; 1267 1268 case EOB_ACT_LAST_MATCH: 1269 yyg->yy_c_buf_p = 1270 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; 1271 1272 yy_current_state = yy_get_previous_state( yyscanner ); 1273 1274 yy_cp = yyg->yy_c_buf_p; 1275 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; 1276 goto yy_find_action; 1277 } 1278 break; 1279 } 1280 1281 default: 1282 YY_FATAL_ERROR( 1283 "fatal flex scanner internal error--no action found" ); 1284 } /* end of action switch */ 1285 } /* end of scanning one token */ 1286 } /* end of pplex */ 1287 1288 /* yy_get_next_buffer - try to read in a new buffer 1289 * 1290 * Returns a code representing an action: 1291 * EOB_ACT_LAST_MATCH - 1292 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 1293 * EOB_ACT_END_OF_FILE - end of file 1294 */ 1295 static int yy_get_next_buffer (yyscan_t yyscanner) 1296 { 1297 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1298 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; 1299 register char *source = yyg->yytext_ptr; 1300 register int number_to_move, i; 1301 int ret_val; 1302 1303 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) 1304 YY_FATAL_ERROR( 1305 "fatal flex scanner internal error--end of buffer missed" ); 1306 1307 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) 1308 { /* Don't try to fill the buffer, so this is an EOF. */ 1309 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) 1310 { 1311 /* We matched a single character, the EOB, so 1312 * treat this as a final EOF. 1313 */ 1314 return EOB_ACT_END_OF_FILE; 1315 } 1316 1317 else 1318 { 1319 /* We matched some text prior to the EOB, first 1320 * process it. 1321 */ 1322 return EOB_ACT_LAST_MATCH; 1323 } 1324 } 1325 1326 /* Try to read more data. */ 1327 1328 /* First move last chars to start of buffer. */ 1329 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1; 1330 1331 for ( i = 0; i < number_to_move; ++i ) 1332 *(dest++) = *(source++); 1333 1334 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1335 /* don't do the read, it's not guaranteed to return an EOF, 1336 * just force an EOF 1337 */ 1338 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; 1339 1340 else 1341 { 1342 yy_size_t num_to_read = 1343 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 1344 1345 while ( num_to_read <= 0 ) 1346 { /* Not enough room in the buffer - grow it. */ 1347 1348 /* just a shorter name for the current buffer */ 1349 YY_BUFFER_STATE b = YY_CURRENT_BUFFER; 1350 1351 int yy_c_buf_p_offset = 1352 (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 1353 1354 if ( b->yy_is_our_buffer ) 1355 { 1356 yy_size_t new_size = b->yy_buf_size * 2; 1357 1358 if ( new_size <= 0 ) 1359 b->yy_buf_size += b->yy_buf_size / 8; 1360 else 1361 b->yy_buf_size *= 2; 1362 1363 b->yy_ch_buf = (char *) 1364 /* Include room in for 2 EOB chars. */ 1365 pprealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner ); 1366 } 1367 else 1368 /* Can't grow it, we don't own it. */ 1369 b->yy_ch_buf = 0; 1370 1371 if ( ! b->yy_ch_buf ) 1372 YY_FATAL_ERROR( 1373 "fatal error - scanner input buffer overflow" ); 1374 1375 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1376 1377 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - 1378 number_to_move - 1; 1379 1380 } 1381 1382 if ( num_to_read > YY_READ_BUF_SIZE ) 1383 num_to_read = YY_READ_BUF_SIZE; 1384 1385 /* Read in more data. */ 1386 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), 1387 yyg->yy_n_chars, num_to_read ); 1388 1389 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; 1390 } 1391 1392 if ( yyg->yy_n_chars == 0 ) 1393 { 1394 if ( number_to_move == YY_MORE_ADJ ) 1395 { 1396 ret_val = EOB_ACT_END_OF_FILE; 1397 pprestart(yyin ,yyscanner); 1398 } 1399 1400 else 1401 { 1402 ret_val = EOB_ACT_LAST_MATCH; 1403 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = 1404 YY_BUFFER_EOF_PENDING; 1405 } 1406 } 1407 1408 else 1409 ret_val = EOB_ACT_CONTINUE_SCAN; 1410 1411 if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { 1412 /* Extend the array by 50%, plus the number we really need. */ 1413 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 1414 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) pprealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner ); 1415 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 1416 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); 1417 } 1418 1419 yyg->yy_n_chars += number_to_move; 1420 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; 1421 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; 1422 1423 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; 1424 1425 return ret_val; 1426 } 1427 1428 /* yy_get_previous_state - get the state just before the EOB char was reached */ 1429 1430 static yy_state_type yy_get_previous_state (yyscan_t yyscanner) 1431 { 1432 register yy_state_type yy_current_state; 1433 register char *yy_cp; 1434 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1435 1436 yy_current_state = yyg->yy_start; 1437 1438 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) 1439 { 1440 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 1441 if ( yy_accept[yy_current_state] ) 1442 { 1443 yyg->yy_last_accepting_state = yy_current_state; 1444 yyg->yy_last_accepting_cpos = yy_cp; 1445 } 1446 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1447 { 1448 yy_current_state = (int) yy_def[yy_current_state]; 1449 if ( yy_current_state >= 87 ) 1450 yy_c = yy_meta[(unsigned int) yy_c]; 1451 } 1452 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1453 } 1454 1455 return yy_current_state; 1456 } 1457 1458 /* yy_try_NUL_trans - try to make a transition on the NUL character 1459 * 1460 * synopsis 1461 * next_state = yy_try_NUL_trans( current_state ); 1462 */ 1463 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner) 1464 { 1465 register int yy_is_jam; 1466 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ 1467 register char *yy_cp = yyg->yy_c_buf_p; 1468 1469 register YY_CHAR yy_c = 1; 1470 if ( yy_accept[yy_current_state] ) 1471 { 1472 yyg->yy_last_accepting_state = yy_current_state; 1473 yyg->yy_last_accepting_cpos = yy_cp; 1474 } 1475 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1476 { 1477 yy_current_state = (int) yy_def[yy_current_state]; 1478 if ( yy_current_state >= 87 ) 1479 yy_c = yy_meta[(unsigned int) yy_c]; 1480 } 1481 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1482 yy_is_jam = (yy_current_state == 86); 1483 1484 return yy_is_jam ? 0 : yy_current_state; 1485 } 1486 1487 #ifndef YY_NO_INPUT 1488 #ifdef __cplusplus 1489 static int yyinput (yyscan_t yyscanner) 1490 #else 1491 static int input (yyscan_t yyscanner) 1492 #endif 1493 1494 { 1495 int c; 1496 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1497 1498 *yyg->yy_c_buf_p = yyg->yy_hold_char; 1499 1500 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) 1501 { 1502 /* yy_c_buf_p now points to the character we want to return. 1503 * If this occurs *before* the EOB characters, then it's a 1504 * valid NUL; if not, then we've hit the end of the buffer. 1505 */ 1506 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) 1507 /* This was really a NUL. */ 1508 *yyg->yy_c_buf_p = '\0'; 1509 1510 else 1511 { /* need more input */ 1512 yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr; 1513 ++yyg->yy_c_buf_p; 1514 1515 switch ( yy_get_next_buffer( yyscanner ) ) 1516 { 1517 case EOB_ACT_LAST_MATCH: 1518 /* This happens because yy_g_n_b() 1519 * sees that we've accumulated a 1520 * token and flags that we need to 1521 * try matching the token before 1522 * proceeding. But for input(), 1523 * there's no matching to consider. 1524 * So convert the EOB_ACT_LAST_MATCH 1525 * to EOB_ACT_END_OF_FILE. 1526 */ 1527 1528 /* Reset buffer status. */ 1529 pprestart(yyin ,yyscanner); 1530 1531 /*FALLTHROUGH*/ 1532 1533 case EOB_ACT_END_OF_FILE: 1534 { 1535 if ( ppwrap(yyscanner ) ) 1536 return EOF; 1537 1538 if ( ! yyg->yy_did_buffer_switch_on_eof ) 1539 YY_NEW_FILE; 1540 #ifdef __cplusplus 1541 return yyinput(yyscanner); 1542 #else 1543 return input(yyscanner); 1544 #endif 1545 } 1546 1547 case EOB_ACT_CONTINUE_SCAN: 1548 yyg->yy_c_buf_p = yyg->yytext_ptr + offset; 1549 break; 1550 } 1551 } 1552 } 1553 1554 c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */ 1555 *yyg->yy_c_buf_p = '\0'; /* preserve yytext */ 1556 yyg->yy_hold_char = *++yyg->yy_c_buf_p; 1557 1558 return c; 1559 } 1560 #endif /* ifndef YY_NO_INPUT */ 1561 1562 /** Immediately switch to a different input stream. 1563 * @param input_file A readable stream. 1564 * @param yyscanner The scanner object. 1565 * @note This function does not reset the start condition to @c INITIAL . 1566 */ 1567 void pprestart (FILE * input_file , yyscan_t yyscanner) 1568 { 1569 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1570 1571 if ( ! YY_CURRENT_BUFFER ){ 1572 ppensure_buffer_stack (yyscanner); 1573 YY_CURRENT_BUFFER_LVALUE = 1574 pp_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); 1575 } 1576 1577 pp_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner); 1578 pp_load_buffer_state(yyscanner ); 1579 } 1580 1581 /** Switch to a different input buffer. 1582 * @param new_buffer The new input buffer. 1583 * @param yyscanner The scanner object. 1584 */ 1585 void pp_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) 1586 { 1587 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1588 1589 /* TODO. We should be able to replace this entire function body 1590 * with 1591 * pppop_buffer_state(); 1592 * pppush_buffer_state(new_buffer); 1593 */ 1594 ppensure_buffer_stack (yyscanner); 1595 if ( YY_CURRENT_BUFFER == new_buffer ) 1596 return; 1597 1598 if ( YY_CURRENT_BUFFER ) 1599 { 1600 /* Flush out information for old buffer. */ 1601 *yyg->yy_c_buf_p = yyg->yy_hold_char; 1602 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; 1603 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; 1604 } 1605 1606 YY_CURRENT_BUFFER_LVALUE = new_buffer; 1607 pp_load_buffer_state(yyscanner ); 1608 1609 /* We don't actually know whether we did this switch during 1610 * EOF (ppwrap()) processing, but the only time this flag 1611 * is looked at is after ppwrap() is called, so it's safe 1612 * to go ahead and always set it. 1613 */ 1614 yyg->yy_did_buffer_switch_on_eof = 1; 1615 } 1616 1617 static void pp_load_buffer_state (yyscan_t yyscanner) 1618 { 1619 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1620 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 1621 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; 1622 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; 1623 yyg->yy_hold_char = *yyg->yy_c_buf_p; 1624 } 1625 1626 /** Allocate and initialize an input buffer state. 1627 * @param file A readable stream. 1628 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. 1629 * @param yyscanner The scanner object. 1630 * @return the allocated buffer state. 1631 */ 1632 YY_BUFFER_STATE pp_create_buffer (FILE * file, int size , yyscan_t yyscanner) 1633 { 1634 YY_BUFFER_STATE b; 1635 1636 b = (YY_BUFFER_STATE) ppalloc(sizeof( struct yy_buffer_state ) ,yyscanner ); 1637 if ( ! b ) 1638 YY_FATAL_ERROR( "out of dynamic memory in pp_create_buffer()" ); 1639 1640 b->yy_buf_size = size; 1641 1642 /* yy_ch_buf has to be 2 characters longer than the size given because 1643 * we need to put in 2 end-of-buffer characters. 1644 */ 1645 b->yy_ch_buf = (char *) ppalloc(b->yy_buf_size + 2 ,yyscanner ); 1646 if ( ! b->yy_ch_buf ) 1647 YY_FATAL_ERROR( "out of dynamic memory in pp_create_buffer()" ); 1648 1649 b->yy_is_our_buffer = 1; 1650 1651 pp_init_buffer(b,file ,yyscanner); 1652 1653 return b; 1654 } 1655 1656 /** Destroy the buffer. 1657 * @param b a buffer created with pp_create_buffer() 1658 * @param yyscanner The scanner object. 1659 */ 1660 void pp_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) 1661 { 1662 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1663 1664 if ( ! b ) 1665 return; 1666 1667 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ 1668 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; 1669 1670 if ( b->yy_is_our_buffer ) 1671 ppfree((void *) b->yy_ch_buf ,yyscanner ); 1672 1673 ppfree((void *) b ,yyscanner ); 1674 } 1675 1676 /* Initializes or reinitializes a buffer. 1677 * This function is sometimes called more than once on the same buffer, 1678 * such as during a pprestart() or at EOF. 1679 */ 1680 static void pp_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner) 1681 1682 { 1683 int oerrno = errno; 1684 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1685 1686 pp_flush_buffer(b ,yyscanner); 1687 1688 b->yy_input_file = file; 1689 b->yy_fill_buffer = 1; 1690 1691 /* If b is the current buffer, then pp_init_buffer was _probably_ 1692 * called from pprestart() or through yy_get_next_buffer. 1693 * In that case, we don't want to reset the lineno or column. 1694 */ 1695 if (b != YY_CURRENT_BUFFER){ 1696 b->yy_bs_lineno = 1; 1697 b->yy_bs_column = 0; 1698 } 1699 1700 b->yy_is_interactive = 0; 1701 1702 errno = oerrno; 1703 } 1704 1705 /** Discard all buffered characters. On the next scan, YY_INPUT will be called. 1706 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. 1707 * @param yyscanner The scanner object. 1708 */ 1709 void pp_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) 1710 { 1711 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1712 if ( ! b ) 1713 return; 1714 1715 b->yy_n_chars = 0; 1716 1717 /* We always need two end-of-buffer characters. The first causes 1718 * a transition to the end-of-buffer state. The second causes 1719 * a jam in that state. 1720 */ 1721 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 1722 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 1723 1724 b->yy_buf_pos = &b->yy_ch_buf[0]; 1725 1726 b->yy_at_bol = 1; 1727 b->yy_buffer_status = YY_BUFFER_NEW; 1728 1729 if ( b == YY_CURRENT_BUFFER ) 1730 pp_load_buffer_state(yyscanner ); 1731 } 1732 1733 /** Pushes the new state onto the stack. The new state becomes 1734 * the current state. This function will allocate the stack 1735 * if necessary. 1736 * @param new_buffer The new state. 1737 * @param yyscanner The scanner object. 1738 */ 1739 void pppush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) 1740 { 1741 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1742 if (new_buffer == NULL) 1743 return; 1744 1745 ppensure_buffer_stack(yyscanner); 1746 1747 /* This block is copied from pp_switch_to_buffer. */ 1748 if ( YY_CURRENT_BUFFER ) 1749 { 1750 /* Flush out information for old buffer. */ 1751 *yyg->yy_c_buf_p = yyg->yy_hold_char; 1752 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; 1753 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; 1754 } 1755 1756 /* Only push if top exists. Otherwise, replace top. */ 1757 if (YY_CURRENT_BUFFER) 1758 yyg->yy_buffer_stack_top++; 1759 YY_CURRENT_BUFFER_LVALUE = new_buffer; 1760 1761 /* copied from pp_switch_to_buffer. */ 1762 pp_load_buffer_state(yyscanner ); 1763 yyg->yy_did_buffer_switch_on_eof = 1; 1764 } 1765 1766 /** Removes and deletes the top of the stack, if present. 1767 * The next element becomes the new top. 1768 * @param yyscanner The scanner object. 1769 */ 1770 void pppop_buffer_state (yyscan_t yyscanner) 1771 { 1772 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1773 if (!YY_CURRENT_BUFFER) 1774 return; 1775 1776 pp_delete_buffer(YY_CURRENT_BUFFER ,yyscanner); 1777 YY_CURRENT_BUFFER_LVALUE = NULL; 1778 if (yyg->yy_buffer_stack_top > 0) 1779 --yyg->yy_buffer_stack_top; 1780 1781 if (YY_CURRENT_BUFFER) { 1782 pp_load_buffer_state(yyscanner ); 1783 yyg->yy_did_buffer_switch_on_eof = 1; 1784 } 1785 } 1786 1787 /* Allocates the stack if it does not exist. 1788 * Guarantees space for at least one push. 1789 */ 1790 static void ppensure_buffer_stack (yyscan_t yyscanner) 1791 { 1792 yy_size_t num_to_alloc; 1793 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1794 1795 if (!yyg->yy_buffer_stack) { 1796 1797 /* First allocation is just for 2 elements, since we don't know if this 1798 * scanner will even need a stack. We use 2 instead of 1 to avoid an 1799 * immediate realloc on the next call. 1800 */ 1801 num_to_alloc = 1; 1802 yyg->yy_buffer_stack = (struct yy_buffer_state**)ppalloc 1803 (num_to_alloc * sizeof(struct yy_buffer_state*) 1804 , yyscanner); 1805 if ( ! yyg->yy_buffer_stack ) 1806 YY_FATAL_ERROR( "out of dynamic memory in ppensure_buffer_stack()" ); 1807 1808 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 1809 1810 yyg->yy_buffer_stack_max = num_to_alloc; 1811 yyg->yy_buffer_stack_top = 0; 1812 return; 1813 } 1814 1815 if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ 1816 1817 /* Increase the buffer to prepare for a possible push. */ 1818 int grow_size = 8 /* arbitrary grow size */; 1819 1820 num_to_alloc = yyg->yy_buffer_stack_max + grow_size; 1821 yyg->yy_buffer_stack = (struct yy_buffer_state**)pprealloc 1822 (yyg->yy_buffer_stack, 1823 num_to_alloc * sizeof(struct yy_buffer_state*) 1824 , yyscanner); 1825 if ( ! yyg->yy_buffer_stack ) 1826 YY_FATAL_ERROR( "out of dynamic memory in ppensure_buffer_stack()" ); 1827 1828 /* zero only the new slots.*/ 1829 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); 1830 yyg->yy_buffer_stack_max = num_to_alloc; 1831 } 1832 } 1833 1834 /** Setup the input buffer state to scan directly from a user-specified character buffer. 1835 * @param base the character buffer 1836 * @param size the size in bytes of the character buffer 1837 * @param yyscanner The scanner object. 1838 * @return the newly allocated buffer state object. 1839 */ 1840 YY_BUFFER_STATE pp_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner) 1841 { 1842 YY_BUFFER_STATE b; 1843 1844 if ( size < 2 || 1845 base[size-2] != YY_END_OF_BUFFER_CHAR || 1846 base[size-1] != YY_END_OF_BUFFER_CHAR ) 1847 /* They forgot to leave room for the EOB's. */ 1848 return 0; 1849 1850 b = (YY_BUFFER_STATE) ppalloc(sizeof( struct yy_buffer_state ) ,yyscanner ); 1851 if ( ! b ) 1852 YY_FATAL_ERROR( "out of dynamic memory in pp_scan_buffer()" ); 1853 1854 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 1855 b->yy_buf_pos = b->yy_ch_buf = base; 1856 b->yy_is_our_buffer = 0; 1857 b->yy_input_file = 0; 1858 b->yy_n_chars = b->yy_buf_size; 1859 b->yy_is_interactive = 0; 1860 b->yy_at_bol = 1; 1861 b->yy_fill_buffer = 0; 1862 b->yy_buffer_status = YY_BUFFER_NEW; 1863 1864 pp_switch_to_buffer(b ,yyscanner ); 1865 1866 return b; 1867 } 1868 1869 /** Setup the input buffer state to scan a string. The next call to pplex() will 1870 * scan from a @e copy of @a str. 1871 * @param yystr a NUL-terminated string to scan 1872 * @param yyscanner The scanner object. 1873 * @return the newly allocated buffer state object. 1874 * @note If you want to scan bytes that may contain NUL values, then use 1875 * pp_scan_bytes() instead. 1876 */ 1877 YY_BUFFER_STATE pp_scan_string (yyconst char * yystr , yyscan_t yyscanner) 1878 { 1879 1880 return pp_scan_bytes(yystr,strlen(yystr) ,yyscanner); 1881 } 1882 1883 /** Setup the input buffer state to scan the given bytes. The next call to pplex() will 1884 * scan from a @e copy of @a bytes. 1885 * @param bytes the byte buffer to scan 1886 * @param len the number of bytes in the buffer pointed to by @a bytes. 1887 * @param yyscanner The scanner object. 1888 * @return the newly allocated buffer state object. 1889 */ 1890 YY_BUFFER_STATE pp_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len , yyscan_t yyscanner) 1891 { 1892 YY_BUFFER_STATE b; 1893 char *buf; 1894 yy_size_t n, i; 1895 1896 /* Get memory for full buffer, including space for trailing EOB's. */ 1897 n = _yybytes_len + 2; 1898 buf = (char *) ppalloc(n ,yyscanner ); 1899 if ( ! buf ) 1900 YY_FATAL_ERROR( "out of dynamic memory in pp_scan_bytes()" ); 1901 1902 for ( i = 0; i < _yybytes_len; ++i ) 1903 buf[i] = yybytes[i]; 1904 1905 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; 1906 1907 b = pp_scan_buffer(buf,n ,yyscanner); 1908 if ( ! b ) 1909 YY_FATAL_ERROR( "bad buffer in pp_scan_bytes()" ); 1910 1911 /* It's okay to grow etc. this buffer, and we should throw it 1912 * away when we're done. 1913 */ 1914 b->yy_is_our_buffer = 1; 1915 1916 return b; 1917 } 1918 1919 #ifndef YY_EXIT_FAILURE 1920 #define YY_EXIT_FAILURE 2 1921 #endif 1922 1923 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner) 1924 { 1925 (void) fprintf( stderr, "%s\n", msg ); 1926 exit( YY_EXIT_FAILURE ); 1927 } 1928 1929 /* Redefine yyless() so it works in section 3 code. */ 1930 1931 #undef yyless 1932 #define yyless(n) \ 1933 do \ 1934 { \ 1935 /* Undo effects of setting up yytext. */ \ 1936 int yyless_macro_arg = (n); \ 1937 YY_LESS_LINENO(yyless_macro_arg);\ 1938 yytext[yyleng] = yyg->yy_hold_char; \ 1939 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \ 1940 yyg->yy_hold_char = *yyg->yy_c_buf_p; \ 1941 *yyg->yy_c_buf_p = '\0'; \ 1942 yyleng = yyless_macro_arg; \ 1943 } \ 1944 while ( 0 ) 1945 1946 /* Accessor methods (get/set functions) to struct members. */ 1947 1948 /** Get the user-defined data for this scanner. 1949 * @param yyscanner The scanner object. 1950 */ 1951 YY_EXTRA_TYPE ppget_extra (yyscan_t yyscanner) 1952 { 1953 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1954 return yyextra; 1955 } 1956 1957 /** Get the current line number. 1958 * @param yyscanner The scanner object. 1959 */ 1960 int ppget_lineno (yyscan_t yyscanner) 1961 { 1962 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1963 1964 if (! YY_CURRENT_BUFFER) 1965 return 0; 1966 1967 return yylineno; 1968 } 1969 1970 /** Get the current column number. 1971 * @param yyscanner The scanner object. 1972 */ 1973 int ppget_column (yyscan_t yyscanner) 1974 { 1975 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1976 1977 if (! YY_CURRENT_BUFFER) 1978 return 0; 1979 1980 return yycolumn; 1981 } 1982 1983 /** Get the input stream. 1984 * @param yyscanner The scanner object. 1985 */ 1986 FILE *ppget_in (yyscan_t yyscanner) 1987 { 1988 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1989 return yyin; 1990 } 1991 1992 /** Get the output stream. 1993 * @param yyscanner The scanner object. 1994 */ 1995 FILE *ppget_out (yyscan_t yyscanner) 1996 { 1997 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1998 return yyout; 1999 } 2000 2001 /** Get the length of the current token. 2002 * @param yyscanner The scanner object. 2003 */ 2004 yy_size_t ppget_leng (yyscan_t yyscanner) 2005 { 2006 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2007 return yyleng; 2008 } 2009 2010 /** Get the current token. 2011 * @param yyscanner The scanner object. 2012 */ 2013 2014 char *ppget_text (yyscan_t yyscanner) 2015 { 2016 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2017 return yytext; 2018 } 2019 2020 /** Set the user-defined data. This data is never touched by the scanner. 2021 * @param user_defined The data to be associated with this scanner. 2022 * @param yyscanner The scanner object. 2023 */ 2024 void ppset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner) 2025 { 2026 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2027 yyextra = user_defined ; 2028 } 2029 2030 /** Set the current line number. 2031 * @param line_number 2032 * @param yyscanner The scanner object. 2033 */ 2034 void ppset_lineno (int line_number , yyscan_t yyscanner) 2035 { 2036 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2037 2038 /* lineno is only valid if an input buffer exists. */ 2039 if (! YY_CURRENT_BUFFER ) 2040 yy_fatal_error( "ppset_lineno called with no buffer" , yyscanner); 2041 2042 yylineno = line_number; 2043 } 2044 2045 /** Set the current column. 2046 * @param line_number 2047 * @param yyscanner The scanner object. 2048 */ 2049 void ppset_column (int column_no , yyscan_t yyscanner) 2050 { 2051 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2052 2053 /* column is only valid if an input buffer exists. */ 2054 if (! YY_CURRENT_BUFFER ) 2055 yy_fatal_error( "ppset_column called with no buffer" , yyscanner); 2056 2057 yycolumn = column_no; 2058 } 2059 2060 /** Set the input stream. This does not discard the current 2061 * input buffer. 2062 * @param in_str A readable stream. 2063 * @param yyscanner The scanner object. 2064 * @see pp_switch_to_buffer 2065 */ 2066 void ppset_in (FILE * in_str , yyscan_t yyscanner) 2067 { 2068 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2069 yyin = in_str ; 2070 } 2071 2072 void ppset_out (FILE * out_str , yyscan_t yyscanner) 2073 { 2074 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2075 yyout = out_str ; 2076 } 2077 2078 int ppget_debug (yyscan_t yyscanner) 2079 { 2080 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2081 return yy_flex_debug; 2082 } 2083 2084 void ppset_debug (int bdebug , yyscan_t yyscanner) 2085 { 2086 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2087 yy_flex_debug = bdebug ; 2088 } 2089 2090 /* Accessor methods for yylval and yylloc */ 2091 2092 YYSTYPE * ppget_lval (yyscan_t yyscanner) 2093 { 2094 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2095 return yylval; 2096 } 2097 2098 void ppset_lval (YYSTYPE * yylval_param , yyscan_t yyscanner) 2099 { 2100 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2101 yylval = yylval_param; 2102 } 2103 2104 YYLTYPE *ppget_lloc (yyscan_t yyscanner) 2105 { 2106 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2107 return yylloc; 2108 } 2109 2110 void ppset_lloc (YYLTYPE * yylloc_param , yyscan_t yyscanner) 2111 { 2112 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2113 yylloc = yylloc_param; 2114 } 2115 2116 /* User-visible API */ 2117 2118 /* pplex_init is special because it creates the scanner itself, so it is 2119 * the ONLY reentrant function that doesn't take the scanner as the last argument. 2120 * That's why we explicitly handle the declaration, instead of using our macros. 2121 */ 2122 2123 int pplex_init(yyscan_t* ptr_yy_globals) 2124 2125 { 2126 if (ptr_yy_globals == NULL){ 2127 errno = EINVAL; 2128 return 1; 2129 } 2130 2131 *ptr_yy_globals = (yyscan_t) ppalloc ( sizeof( struct yyguts_t ), NULL ); 2132 2133 if (*ptr_yy_globals == NULL){ 2134 errno = ENOMEM; 2135 return 1; 2136 } 2137 2138 /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ 2139 memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2140 2141 return yy_init_globals ( *ptr_yy_globals ); 2142 } 2143 2144 /* pplex_init_extra has the same functionality as pplex_init, but follows the 2145 * convention of taking the scanner as the last argument. Note however, that 2146 * this is a *pointer* to a scanner, as it will be allocated by this call (and 2147 * is the reason, too, why this function also must handle its own declaration). 2148 * The user defined value in the first argument will be available to ppalloc in 2149 * the yyextra field. 2150 */ 2151 2152 int pplex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals ) 2153 2154 { 2155 struct yyguts_t dummy_yyguts; 2156 2157 ppset_extra (yy_user_defined, &dummy_yyguts); 2158 2159 if (ptr_yy_globals == NULL){ 2160 errno = EINVAL; 2161 return 1; 2162 } 2163 2164 *ptr_yy_globals = (yyscan_t) ppalloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); 2165 2166 if (*ptr_yy_globals == NULL){ 2167 errno = ENOMEM; 2168 return 1; 2169 } 2170 2171 /* By setting to 0xAA, we expose bugs in 2172 yy_init_globals. Leave at 0x00 for releases. */ 2173 memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2174 2175 ppset_extra (yy_user_defined, *ptr_yy_globals); 2176 2177 return yy_init_globals ( *ptr_yy_globals ); 2178 } 2179 2180 static int yy_init_globals (yyscan_t yyscanner) 2181 { 2182 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2183 /* Initialization is the same as for the non-reentrant scanner. 2184 * This function is called from pplex_destroy(), so don't allocate here. 2185 */ 2186 2187 yyg->yy_buffer_stack = 0; 2188 yyg->yy_buffer_stack_top = 0; 2189 yyg->yy_buffer_stack_max = 0; 2190 yyg->yy_c_buf_p = (char *) 0; 2191 yyg->yy_init = 0; 2192 yyg->yy_start = 0; 2193 2194 yyg->yy_start_stack_ptr = 0; 2195 yyg->yy_start_stack_depth = 0; 2196 yyg->yy_start_stack = NULL; 2197 2198 /* Defined in main.c */ 2199 #ifdef YY_STDINIT 2200 yyin = stdin; 2201 yyout = stdout; 2202 #else 2203 yyin = (FILE *) 0; 2204 yyout = (FILE *) 0; 2205 #endif 2206 2207 /* For future reference: Set errno on error, since we are called by 2208 * pplex_init() 2209 */ 2210 return 0; 2211 } 2212 2213 /* pplex_destroy is for both reentrant and non-reentrant scanners. */ 2214 int pplex_destroy (yyscan_t yyscanner) 2215 { 2216 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2217 2218 /* Pop the buffer stack, destroying each element. */ 2219 while(YY_CURRENT_BUFFER){ 2220 pp_delete_buffer(YY_CURRENT_BUFFER ,yyscanner ); 2221 YY_CURRENT_BUFFER_LVALUE = NULL; 2222 pppop_buffer_state(yyscanner); 2223 } 2224 2225 /* Destroy the stack itself. */ 2226 ppfree(yyg->yy_buffer_stack ,yyscanner); 2227 yyg->yy_buffer_stack = NULL; 2228 2229 /* Destroy the start condition stack. */ 2230 ppfree(yyg->yy_start_stack ,yyscanner ); 2231 yyg->yy_start_stack = NULL; 2232 2233 /* Reset the globals. This is important in a non-reentrant scanner so the next time 2234 * pplex() is called, initialization will occur. */ 2235 yy_init_globals( yyscanner); 2236 2237 /* Destroy the main struct (reentrant only). */ 2238 ppfree ( yyscanner , yyscanner ); 2239 yyscanner = NULL; 2240 return 0; 2241 } 2242 2243 /* 2244 * Internal utility routines. 2245 */ 2246 2247 #ifndef yytext_ptr 2248 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner) 2249 { 2250 register int i; 2251 for ( i = 0; i < n; ++i ) 2252 s1[i] = s2[i]; 2253 } 2254 #endif 2255 2256 #ifdef YY_NEED_STRLEN 2257 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner) 2258 { 2259 register int n; 2260 for ( n = 0; s[n]; ++n ) 2261 ; 2262 2263 return n; 2264 } 2265 #endif 2266 2267 void *ppalloc (yy_size_t size , yyscan_t yyscanner) 2268 { 2269 return (void *) malloc( size ); 2270 } 2271 2272 void *pprealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) 2273 { 2274 /* The cast to (char *) in the following accommodates both 2275 * implementations that use char* generic pointers, and those 2276 * that use void* generic pointers. It works with the latter 2277 * because both ANSI C and C++ allow castless assignment from 2278 * any pointer type to void*, and deal with argument conversions 2279 * as though doing an assignment. 2280 */ 2281 return (void *) realloc( (char *) ptr, size ); 2282 } 2283 2284 void ppfree (void * ptr , yyscan_t yyscanner) 2285 { 2286 free( (char *) ptr ); /* see pprealloc() for (char *) cast */ 2287 } 2288 2289 #define YYTABLES_NAME "yytables" 2290 2291 namespace pp { 2292 2293 // TODO(alokp): Maximum token length should ideally be specified by 2294 // the preprocessor client, i.e., the compiler. 2295 const size_t Tokenizer::kMaxTokenLength = 256; 2296 2297 Tokenizer::Tokenizer(Diagnostics* diagnostics) : mHandle(0) 2298 { 2299 mContext.diagnostics = diagnostics; 2300 } 2301 2302 Tokenizer::~Tokenizer() 2303 { 2304 destroyScanner(); 2305 } 2306 2307 bool Tokenizer::init(size_t count, const char* const string[], const int length[]) 2308 { 2309 if ((count > 0) && (string == 0)) return false; 2310 2311 mContext.input = Input(count, string, length); 2312 return initScanner(); 2313 } 2314 2315 void Tokenizer::setFileNumber(int file) 2316 { 2317 // We use column number as file number. 2318 // See macro yyfileno. 2319 ppset_column(file,mHandle); 2320 } 2321 2322 void Tokenizer::setLineNumber(int line) 2323 { 2324 ppset_lineno(line,mHandle); 2325 } 2326 2327 void Tokenizer::lex(Token* token) 2328 { 2329 token->type = pplex(&token->text,&token->location,mHandle); 2330 if (token->text.size() > kMaxTokenLength) 2331 { 2332 mContext.diagnostics->report(Diagnostics::TOKEN_TOO_LONG, 2333 token->location, token->text); 2334 token->text.erase(kMaxTokenLength); 2335 } 2336 2337 token->flags = 0; 2338 2339 token->setAtStartOfLine(mContext.lineStart); 2340 mContext.lineStart = token->type == '\n'; 2341 2342 token->setHasLeadingSpace(mContext.leadingSpace); 2343 mContext.leadingSpace = false; 2344 } 2345 2346 bool Tokenizer::initScanner() 2347 { 2348 if ((mHandle == NULL) && pplex_init_extra(&mContext,&mHandle)) 2349 return false; 2350 2351 pprestart(0,mHandle); 2352 return true; 2353 } 2354 2355 void Tokenizer::destroyScanner() 2356 { 2357 if (mHandle == NULL) 2358 return; 2359 2360 pplex_destroy(mHandle); 2361 mHandle = NULL; 2362 } 2363 2364 } // namespace pp 2365 2366
