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