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