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