1 /* Integration test for compiling the output of a minimal "flex"
2 script. */
3
4 /* { dg-additional-options "-fno-analyzer-call-summaries" } */
5
6 /* { dg-additional-options "-Wno-analyzer-too-complex" } */
7
8
9 /* A lexical scanner generated by flex */
10
11 #define YY_INT_ALIGNED short int
12
13 /* First, we deal with platform-specific or compiler-specific issues. */
14
15 /* begin standard C headers. */
16 #include <stdio.h>
17 #include <string.h>
18 #include <errno.h>
19 #include <stdlib.h>
20
21 /* end standard C headers. */
22
23 /* flex integer type definitions */
24
25 #ifndef FLEXINT_H
26 #define FLEXINT_H
27
28 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
29
30 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
31
32 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
33 * if you want the limit (max/min) macros for int types.
34 */
35 #ifndef __STDC_LIMIT_MACROS
36 #define __STDC_LIMIT_MACROS 1
37 #endif
38
39 #include <inttypes.h>
40 typedef int8_t flex_int8_t;
41 typedef uint8_t flex_uint8_t;
42 typedef int16_t flex_int16_t;
43 typedef uint16_t flex_uint16_t;
44 typedef int32_t flex_int32_t;
45 typedef uint32_t flex_uint32_t;
46 #else
47 typedef signed char flex_int8_t;
48 typedef short int flex_int16_t;
49 typedef int flex_int32_t;
50 typedef unsigned char flex_uint8_t;
51 typedef unsigned short int flex_uint16_t;
52 typedef unsigned int flex_uint32_t;
53
54 #endif /* ! C99 */
55
56 #endif /* ! FLEXINT_H */
57
58 /* begin standard C++ headers. */
59
60 /* TODO: this is always defined, so inline it */
61 #define yyconst const
62
63 #define yynoreturn __attribute__((__noreturn__))
64
65 /* Returned upon end-of-file. */
66 #define YY_NULL 0
67
68 /* Promotes a possibly negative, possibly signed char to an
69 * integer in range [0..255] for use as an array index.
70 */
71 #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
72
73 /* Enter a start condition. This macro really ought to take a parameter,
74 * but we do it the disgusting crufty way forced on us by the ()-less
75 * definition of BEGIN.
76 */
77 #define BEGIN (yy_start) = 1 + 2 *
78 /* Translate the current start state into a value that can be later handed
79 * to BEGIN to return to the state. The YYSTATE alias is for lex
80 * compatibility.
81 */
82 #define YY_START (((yy_start) - 1) / 2)
83 #define YYSTATE YY_START
84 /* Action number for EOF rule of a given start state. */
85 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
86 /* Special action meaning "start processing a new file". */
87 #define YY_NEW_FILE yyrestart( yyin )
88 #define YY_END_OF_BUFFER_CHAR 0
89
90 /* Size of default input buffer. */
91 #ifndef YY_BUF_SIZE
92 #ifdef __ia64__
93 /* On IA-64, the buffer size is 16k, not 8k.
94 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
95 * Ditto for the __ia64__ case accordingly.
96 */
97 #define YY_BUF_SIZE 32768
98 #else
99 #define YY_BUF_SIZE 16384
100 #endif /* __ia64__ */
101 #endif
102
103 /* The state buf must be large enough to hold one state per character in the main buffer.
104 */
105 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
106
107 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
108 #define YY_TYPEDEF_YY_BUFFER_STATE
109 typedef struct yy_buffer_state *YY_BUFFER_STATE;
110 #endif
111
112 #ifndef YY_TYPEDEF_YY_SIZE_T
113 #define YY_TYPEDEF_YY_SIZE_T
114 typedef size_t yy_size_t;
115 #endif
116
117 extern int yyleng;
118
119 extern FILE *yyin, *yyout;
120
121 #define EOB_ACT_CONTINUE_SCAN 0
122 #define EOB_ACT_END_OF_FILE 1
123 #define EOB_ACT_LAST_MATCH 2
124
125 #define YY_LESS_LINENO(n)
126 #define YY_LINENO_REWIND_TO(ptr)
127
128 /* Return all but the first "n" matched characters back to the input stream. */
129 #define yyless(n) \
130 do \
131 { \
132 /* Undo effects of setting up yytext. */ \
133 int yyless_macro_arg = (n); \
134 YY_LESS_LINENO(yyless_macro_arg);\
135 *yy_cp = (yy_hold_char); \
136 YY_RESTORE_YY_MORE_OFFSET \
137 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
138 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
139 } \
140 while ( 0 )
141 #define unput(c) yyunput( c, (yytext_ptr) )
142
143 #ifndef YY_STRUCT_YY_BUFFER_STATE
144 #define YY_STRUCT_YY_BUFFER_STATE
145 struct yy_buffer_state
146 {
147 FILE *yy_input_file;
148
149 char *yy_ch_buf; /* input buffer */
150 char *yy_buf_pos; /* current position in input buffer */
151
152 /* Size of input buffer in bytes, not including room for EOB
153 * characters.
154 */
155 int yy_buf_size;
156
157 /* Number of characters read into yy_ch_buf, not including EOB
158 * characters.
159 */
160 int yy_n_chars;
161
162 /* Whether we "own" the buffer - i.e., we know we created it,
163 * and can realloc() it to grow it, and should free() it to
164 * delete it.
165 */
166 int yy_is_our_buffer;
167
168 /* Whether this is an "interactive" input source; if so, and
169 * if we're using stdio for input, then we want to use getc()
170 * instead of fread(), to make sure we stop fetching input after
171 * each newline.
172 */
173 int yy_is_interactive;
174
175 /* Whether we're considered to be at the beginning of a line.
176 * If so, '^' rules will be active on the next match, otherwise
177 * not.
178 */
179 int yy_at_bol;
180
181 int yy_bs_lineno; /**< The line count. */
182 int yy_bs_column; /**< The column count. */
183
184 /* Whether to try to fill the input buffer when we reach the
185 * end of it.
186 */
187 int yy_fill_buffer;
188
189 int yy_buffer_status;
190
191 #define YY_BUFFER_NEW 0
192 #define YY_BUFFER_NORMAL 1
193 /* When an EOF's been seen but there's still some text to process
194 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
195 * shouldn't try reading from the input source any more. We might
196 * still have a bunch of tokens to match, though, because of
197 * possible backing-up.
198 *
199 * When we actually see the EOF, we change the status to "new"
200 * (via yyrestart()), so that the user can continue scanning by
201 * just pointing yyin at a new input file.
202 */
203 #define YY_BUFFER_EOF_PENDING 2
204
205 };
206 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
207
208 /* Stack of input buffers. */
209 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
210 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
211 static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
212
213 /* We provide macros for accessing buffer states in case in the
214 * future we want to put the buffer states in a more general
215 * "scanner state".
216 *
217 * Returns the top of the stack, or NULL.
218 */
219 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
220 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
221 : NULL)
222 /* Same as previous macro, but useful when we know that the buffer stack is not
223 * NULL or when we need an lvalue. For internal use only.
224 */
225 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
226
227 /* yy_hold_char holds the character lost when yytext is formed. */
228 static char yy_hold_char;
229 static int yy_n_chars; /* number of characters read into yy_ch_buf */
230 int yyleng;
231
232 /* Points to current character in buffer. */
233 static char *yy_c_buf_p = NULL;
234 static int yy_init = 0; /* whether we need to initialize */
235 static int yy_start = 0; /* start state number */
236
237 /* Flag which is used to allow yywrap()'s to do buffer switches
238 * instead of setting up a fresh yyin. A bit of a hack ...
239 */
240 static int yy_did_buffer_switch_on_eof;
241
242 void yyrestart ( FILE *input_file );
243 void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
244 YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
245 void yy_delete_buffer ( YY_BUFFER_STATE b );
246 void yy_flush_buffer ( YY_BUFFER_STATE b );
247 void yypush_buffer_state ( YY_BUFFER_STATE new_buffer );
248 void yypop_buffer_state ( void );
249
250 static void yyensure_buffer_stack ( void );
251 static void yy_load_buffer_state ( void );
252 static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
253 #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
254
255 YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size );
256 YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
257 YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
258
259 void *yyalloc ( yy_size_t );
260 void *yyrealloc ( void *, yy_size_t );
261 void yyfree ( void * );
262
263 #define yy_new_buffer yy_create_buffer
264 #define yy_set_interactive(is_interactive) \
265 { \
266 if ( ! YY_CURRENT_BUFFER ){ \
267 yyensure_buffer_stack (); \
268 YY_CURRENT_BUFFER_LVALUE = \
269 yy_create_buffer( yyin, YY_BUF_SIZE ); \
270 } \
271 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
272 }
273 #define yy_set_bol(at_bol) \
274 { \
275 if ( ! YY_CURRENT_BUFFER ){\
276 yyensure_buffer_stack (); \
277 YY_CURRENT_BUFFER_LVALUE = \
278 yy_create_buffer( yyin, YY_BUF_SIZE ); \
279 } \
280 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
281 }
282 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
283
284 typedef flex_uint8_t YY_CHAR;
285
286 FILE *yyin = NULL, *yyout = NULL;
287
288 typedef int yy_state_type;
289
290 extern int yylineno;
291 int yylineno = 1;
292
293 extern char *yytext;
294 #ifdef yytext_ptr
295 #undef yytext_ptr
296 #endif
297 #define yytext_ptr yytext
298
299 static yy_state_type yy_get_previous_state ( void );
300 static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
301 static int yy_get_next_buffer ( void );
302 static void yynoreturn yy_fatal_error ( const char* msg );
303
304 /* Done after the current pattern has been matched and before the
305 * corresponding action - sets up yytext.
306 */
307 #define YY_DO_BEFORE_ACTION \
308 (yytext_ptr) = yy_bp; \
309 yyleng = (int) (yy_cp - yy_bp); \
310 (yy_hold_char) = *yy_cp; \
311 *yy_cp = '\0'; \
312 (yy_c_buf_p) = yy_cp;
313 #define YY_NUM_RULES 1
314 #define YY_END_OF_BUFFER 2
315 /* This struct is not used in this scanner,
316 but its presence is necessary. */
317 struct yy_trans_info
318 {
319 flex_int32_t yy_verify;
320 flex_int32_t yy_nxt;
321 };
322 static const flex_int16_t yy_accept[6] =
323 { 0,
324 0, 0, 2, 1, 0
325 } ;
326
327 static const YY_CHAR yy_ec[256] =
328 { 0,
329 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
330 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
331 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
332 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
333 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
334 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
335 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
336 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
337 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
338 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
339
340 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
341 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
342 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
343 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
344 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
345 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
346 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
347 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
348 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
349 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
350
351 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
352 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
353 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
354 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
355 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
356 1, 1, 1, 1, 1
357 } ;
358
359 static const YY_CHAR yy_meta[2] =
360 { 0,
361 1
362 } ;
363
364 static const flex_int16_t yy_base[7] =
365 { 0,
366 0, 0, 2, 3, 3, 0
367 } ;
368
369 static const flex_int16_t yy_def[7] =
370 { 0,
371 6, 6, 5, 5, 0, 5
372 } ;
373
374 static const flex_int16_t yy_nxt[5] =
375 { 0,
376 4, 5, 3, 5
377 } ;
378
379 static const flex_int16_t yy_chk[5] =
380 { 0,
381 6, 3, 5, 5
382 } ;
383
384 static yy_state_type yy_last_accepting_state;
385 static char *yy_last_accepting_cpos;
386
387 extern int yy_flex_debug;
388 int yy_flex_debug = 0;
389
390 /* The intent behind this definition is that it'll catch
391 * any uses of REJECT which flex missed.
392 */
393 #define REJECT reject_used_but_not_detected
394 #define yymore() yymore_used_but_not_detected
395 #define YY_MORE_ADJ 0
396 #define YY_RESTORE_YY_MORE_OFFSET
397 char *yytext;
398
399 #define INITIAL 0
400
401 #ifndef YY_NO_UNISTD_H
402 /* Special case for "unistd.h", since it is non-ANSI. We include it way
403 * down here because we want the user's section 1 to have been scanned first.
404 * The user has a chance to override it with an option.
405 */
406 #include <unistd.h>
407 #endif
408
409 #ifndef YY_EXTRA_TYPE
410 #define YY_EXTRA_TYPE void *
411 #endif
412
413 static int yy_init_globals ( void );
414
415 /* Accessor methods to globals.
416 These are made visible to non-reentrant scanners for convenience. */
417
418 int yylex_destroy ( void );
419
420 int yyget_debug ( void );
421
422 void yyset_debug ( int debug_flag );
423
424 YY_EXTRA_TYPE yyget_extra ( void );
425
426 void yyset_extra ( YY_EXTRA_TYPE user_defined );
427
428 FILE *yyget_in ( void );
429
430 void yyset_in ( FILE * _in_str );
431
432 FILE *yyget_out ( void );
433
434 void yyset_out ( FILE * _out_str );
435
436 int yyget_leng ( void );
437
438 char *yyget_text ( void );
439
440 int yyget_lineno ( void );
441
442 void yyset_lineno ( int _line_number );
443
444 /* Macros after this point can all be overridden by user definitions in
445 * section 1.
446 */
447
448 #ifndef YY_SKIP_YYWRAP
449 #ifdef __cplusplus
450 extern "C" int yywrap ( void );
451 #else
452 extern int yywrap ( void );
453 #endif
454 #endif
455
456 #ifndef YY_NO_UNPUT
457
458 static void yyunput ( int c, char *buf_ptr );
459
460 #endif
461
462 #ifndef yytext_ptr
463 static void yy_flex_strncpy ( char *, const char *, int );
464 #endif
465
466 #ifdef YY_NEED_STRLEN
467 static int yy_flex_strlen ( const char * );
468 #endif
469
470 #ifndef YY_NO_INPUT
471 #ifdef __cplusplus
472 static int yyinput ( void );
473 #else
474 static int input ( void );
475 #endif
476
477 #endif
478
479 /* Amount of stuff to slurp up with each read. */
480 #ifndef YY_READ_BUF_SIZE
481 #ifdef __ia64__
482 /* On IA-64, the buffer size is 16k, not 8k */
483 #define YY_READ_BUF_SIZE 16384
484 #else
485 #define YY_READ_BUF_SIZE 8192
486 #endif /* __ia64__ */
487 #endif
488
489 /* Copy whatever the last rule matched to the standard output. */
490 #ifndef ECHO
491 /* This used to be an fputs(), but since the string might contain NUL's,
492 * we now use fwrite().
493 */
494 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
495 #endif
496
497 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
498 * is returned in "result".
499 */
500 #ifndef YY_INPUT
501 #define YY_INPUT(buf,result,max_size) \
502 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
503 { \
504 int c = '*'; \
505 int n; \
506 for ( n = 0; n < max_size && \
507 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
508 buf[n] = (char) c; \
509 if ( c == '\n' ) \
510 buf[n++] = (char) c; \
511 if ( c == EOF && ferror( yyin ) ) \
512 YY_FATAL_ERROR( "input in flex scanner failed" ); \
513 result = n; \
514 } \
515 else \
516 { \
517 errno=0; \
518 while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
519 { \
520 if( errno != EINTR) \
521 { \
522 YY_FATAL_ERROR( "input in flex scanner failed" ); \
523 break; \
524 } \
525 errno=0; \
526 clearerr(yyin); \
527 } \
528 }\
529 \
530
531 #endif
532
533 /* No semi-colon after return; correct usage is to write "yyterminate();" -
534 * we don't want an extra ';' after the "return" because that will cause
535 * some compilers to complain about unreachable statements.
536 */
537 #ifndef yyterminate
538 #define yyterminate() return YY_NULL
539 #endif
540
541 /* Number of entries by which start-condition stack grows. */
542 #ifndef YY_START_STACK_INCR
543 #define YY_START_STACK_INCR 25
544 #endif
545
546 /* Report a fatal error. */
547 #ifndef YY_FATAL_ERROR
548 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
549 #endif
550
551 /* end tables serialization structures and prototypes */
552
553 /* Default declaration of generated scanner - a define so the user can
554 * easily add parameters.
555 */
556 #ifndef YY_DECL
557 #define YY_DECL_IS_OURS 1
558
559 extern int yylex (void);
560
561 #define YY_DECL int yylex (void)
562 #endif /* !YY_DECL */
563
564 /* Code executed at the beginning of each rule, after yytext and yyleng
565 * have been set up.
566 */
567 #ifndef YY_USER_ACTION
568 #define YY_USER_ACTION
569 #endif
570
571 /* Code executed at the end of each rule. */
572 #ifndef YY_BREAK
573 #define YY_BREAK /*LINTED*/break;
574 #endif
575
576 #define YY_RULE_SETUP \
577 YY_USER_ACTION
578
579 /** The main scanner function which does all the work.
580 */
581 YY_DECL
582 {
583 yy_state_type yy_current_state;
584 char *yy_cp, *yy_bp;
585 int yy_act;
586
587 if ( !(yy_init) )
588 {
589 (yy_init) = 1;
590
591 #ifdef YY_USER_INIT
592 YY_USER_INIT;
593 #endif
594
595 if ( ! (yy_start) )
596 (yy_start) = 1; /* first start state */
597
598 if ( ! yyin )
599 yyin = stdin;
600
601 if ( ! yyout )
602 yyout = stdout;
603
604 if ( ! YY_CURRENT_BUFFER ) {
605 yyensure_buffer_stack ();
606 YY_CURRENT_BUFFER_LVALUE =
607 yy_create_buffer( yyin, YY_BUF_SIZE );
608 }
609
610 yy_load_buffer_state( );
611 }
612
613 {
614
615 while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
616 {
617 yy_cp = (yy_c_buf_p);
618
619 /* Support of yytext. */
620 *yy_cp = (yy_hold_char);
621
622 /* yy_bp points to the position in yy_ch_buf of the start of
623 * the current run.
624 */
625 yy_bp = yy_cp;
626
627 yy_current_state = (yy_start);
628 yy_match:
629 do
630 {
631 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
632 if ( yy_accept[yy_current_state] )
633 {
634 (yy_last_accepting_state) = yy_current_state;
635 (yy_last_accepting_cpos) = yy_cp;
636 }
637 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
638 {
639 yy_current_state = (int) yy_def[yy_current_state];
640 if ( yy_current_state >= 6 )
641 yy_c = yy_meta[yy_c];
642 }
643 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
644 ++yy_cp;
645 }
646 while ( yy_base[yy_current_state] != 3 );
647
648 yy_find_action:
649 yy_act = yy_accept[yy_current_state];
650 if ( yy_act == 0 )
651 { /* have to back up */
652 yy_cp = (yy_last_accepting_cpos);
653 yy_current_state = (yy_last_accepting_state);
654 yy_act = yy_accept[yy_current_state];
655 }
656
657 YY_DO_BEFORE_ACTION;
658
659 do_action: /* This label is used only to access EOF actions. */
660
661 switch ( yy_act )
662 { /* beginning of action switch */
663 case 0: /* must back up */
664 /* undo the effects of YY_DO_BEFORE_ACTION */
665 *yy_cp = (yy_hold_char);
666 yy_cp = (yy_last_accepting_cpos);
667 yy_current_state = (yy_last_accepting_state);
668 goto yy_find_action;
669
670 case 1:
671 YY_RULE_SETUP
672 ECHO;
673 YY_BREAK
674 case YY_STATE_EOF(INITIAL):
675 yyterminate();
676
677 case YY_END_OF_BUFFER:
678 {
679 /* Amount of text matched not including the EOB char. */
680 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
681
682 /* Undo the effects of YY_DO_BEFORE_ACTION. */
683 *yy_cp = (yy_hold_char);
684 YY_RESTORE_YY_MORE_OFFSET
685
686 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
687 {
688 /* We're scanning a new file or input source. It's
689 * possible that this happened because the user
690 * just pointed yyin at a new source and called
691 * yylex(). If so, then we have to assure
692 * consistency between YY_CURRENT_BUFFER and our
693 * globals. Here is the right place to do so, because
694 * this is the first action (other than possibly a
695 * back-up) that will match for the new input source.
696 */
697 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
698 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
699 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
700 }
701
702 /* Note that here we test for yy_c_buf_p "<=" to the position
703 * of the first EOB in the buffer, since yy_c_buf_p will
704 * already have been incremented past the NUL character
705 * (since all states make transitions on EOB to the
706 * end-of-buffer state). Contrast this with the test
707 * in input().
708 */
709 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
710 { /* This was really a NUL. */
711 yy_state_type yy_next_state;
712
713 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
714
715 yy_current_state = yy_get_previous_state( );
716
717 /* Okay, we're now positioned to make the NUL
718 * transition. We couldn't have
719 * yy_get_previous_state() go ahead and do it
720 * for us because it doesn't know how to deal
721 * with the possibility of jamming (and we don't
722 * want to build jamming into it because then it
723 * will run more slowly).
724 */
725
726 yy_next_state = yy_try_NUL_trans( yy_current_state );
727
728 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
729
730 if ( yy_next_state )
731 {
732 /* Consume the NUL. */
733 yy_cp = ++(yy_c_buf_p);
734 yy_current_state = yy_next_state;
735 goto yy_match;
736 }
737
738 else
739 {
740 yy_cp = (yy_c_buf_p);
741 goto yy_find_action;
742 }
743 }
744
745 else switch ( yy_get_next_buffer( ) )
746 {
747 case EOB_ACT_END_OF_FILE:
748 {
749 (yy_did_buffer_switch_on_eof) = 0;
750
751 if ( yywrap( ) )
752 {
753 /* Note: because we've taken care in
754 * yy_get_next_buffer() to have set up
755 * yytext, we can now set up
756 * yy_c_buf_p so that if some total
757 * hoser (like flex itself) wants to
758 * call the scanner after we return the
759 * YY_NULL, it'll still work - another
760 * YY_NULL will get returned.
761 */
762 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
763
764 yy_act = YY_STATE_EOF(YY_START);
765 goto do_action;
766 }
767
768 else
769 {
770 if ( ! (yy_did_buffer_switch_on_eof) )
771 YY_NEW_FILE;
772 }
773 break;
774 }
775
776 case EOB_ACT_CONTINUE_SCAN:
777 (yy_c_buf_p) =
778 (yytext_ptr) + yy_amount_of_matched_text;
779
780 yy_current_state = yy_get_previous_state( );
781
782 yy_cp = (yy_c_buf_p);
783 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
784 goto yy_match;
785
786 case EOB_ACT_LAST_MATCH:
787 (yy_c_buf_p) =
788 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
789
790 yy_current_state = yy_get_previous_state( );
791
792 yy_cp = (yy_c_buf_p);
793 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
794 goto yy_find_action;
795 }
796 break;
797 }
798
799 default:
800 YY_FATAL_ERROR(
801 "fatal flex scanner internal error--no action found" );
802 } /* end of action switch */
803 } /* end of scanning one token */
804 } /* end of user's declarations */
805 } /* end of yylex */
806
807 /* yy_get_next_buffer - try to read in a new buffer
808 *
809 * Returns a code representing an action:
810 * EOB_ACT_LAST_MATCH -
811 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
812 * EOB_ACT_END_OF_FILE - end of file
813 */
814 static int yy_get_next_buffer (void)
815 {
816 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
817 char *source = (yytext_ptr);
818 int number_to_move, i;
819 int ret_val;
820
821 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
822 YY_FATAL_ERROR(
823 "fatal flex scanner internal error--end of buffer missed" );
824
825 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
826 { /* Don't try to fill the buffer, so this is an EOF. */
827 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
828 {
829 /* We matched a single character, the EOB, so
830 * treat this as a final EOF.
831 */
832 return EOB_ACT_END_OF_FILE;
833 }
834
835 else
836 {
837 /* We matched some text prior to the EOB, first
838 * process it.
839 */
840 return EOB_ACT_LAST_MATCH;
841 }
842 }
843
844 /* Try to read more data. */
845
846 /* First move last chars to start of buffer. */
847 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
848
849 for ( i = 0; i < number_to_move; ++i )
850 *(dest++) = *(source++);
851
852 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
853 /* don't do the read, it's not guaranteed to return an EOF,
854 * just force an EOF
855 */
856 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
857
858 else
859 {
860 int num_to_read =
861 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
862
863 while ( num_to_read <= 0 )
864 { /* Not enough room in the buffer - grow it. */
865
866 /* just a shorter name for the current buffer */
867 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
868
869 int yy_c_buf_p_offset =
870 (int) ((yy_c_buf_p) - b->yy_ch_buf);
871
872 if ( b->yy_is_our_buffer )
873 {
874 int new_size = b->yy_buf_size * 2;
875
876 if ( new_size <= 0 )
877 b->yy_buf_size += b->yy_buf_size / 8;
878 else
879 b->yy_buf_size *= 2;
880
881 b->yy_ch_buf = (char *) /* { dg-warning "leak of '\\*b.yy_ch_buf'" } */
882 /* Include room in for 2 EOB chars. */
883 yyrealloc( (void *) b->yy_ch_buf,
884 (yy_size_t) (b->yy_buf_size + 2) );
885 }
886 else
887 /* Can't grow it, we don't own it. */
888 b->yy_ch_buf = NULL; /* { dg-bogus "leak" "" { xfail *-*-* } } */
889 /* TODO: leak false positive: PR analyzer/103546. */
890
891 if ( ! b->yy_ch_buf )
892 YY_FATAL_ERROR(
893 "fatal error - scanner input buffer overflow" );
894
895 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
896
897 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
898 number_to_move - 1;
899
900 }
901
902 if ( num_to_read > YY_READ_BUF_SIZE )
903 num_to_read = YY_READ_BUF_SIZE;
904
905 /* Read in more data. */
906 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
907 (yy_n_chars), num_to_read );
908
909 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
910 }
911
912 if ( (yy_n_chars) == 0 )
913 {
914 if ( number_to_move == YY_MORE_ADJ )
915 {
916 ret_val = EOB_ACT_END_OF_FILE;
917 yyrestart( yyin );
918 }
919
920 else
921 {
922 ret_val = EOB_ACT_LAST_MATCH;
923 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
924 YY_BUFFER_EOF_PENDING;
925 }
926 }
927
928 else
929 ret_val = EOB_ACT_CONTINUE_SCAN;
930
931 if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
932 /* Extend the array by 50%, plus the number we really need. */
933 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
934 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
935 (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
936 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
937 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
938 /* "- 2" to take care of EOB's */
939 YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
940 }
941
942 (yy_n_chars) += number_to_move;
943 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
944 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
945
946 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
947
948 return ret_val;
949 }
950
951 /* yy_get_previous_state - get the state just before the EOB char was reached */
952
953 static yy_state_type yy_get_previous_state (void)
954 {
955 yy_state_type yy_current_state;
956 char *yy_cp;
957
958 yy_current_state = (yy_start);
959
960 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
961 {
962 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
963 if ( yy_accept[yy_current_state] )
964 {
965 (yy_last_accepting_state) = yy_current_state;
966 (yy_last_accepting_cpos) = yy_cp;
967 }
968 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
969 {
970 yy_current_state = (int) yy_def[yy_current_state];
971 if ( yy_current_state >= 6 )
972 yy_c = yy_meta[yy_c];
973 }
974 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
975 }
976
977 return yy_current_state;
978 }
979
980 /* yy_try_NUL_trans - try to make a transition on the NUL character
981 *
982 * synopsis
983 * next_state = yy_try_NUL_trans( current_state );
984 */
985 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
986 {
987 int yy_is_jam;
988 char *yy_cp = (yy_c_buf_p);
989
990 YY_CHAR yy_c = 1;
991 if ( yy_accept[yy_current_state] )
992 {
993 (yy_last_accepting_state) = yy_current_state;
994 (yy_last_accepting_cpos) = yy_cp;
995 }
996 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
997 {
998 yy_current_state = (int) yy_def[yy_current_state];
999 if ( yy_current_state >= 6 )
1000 yy_c = yy_meta[yy_c];
1001 }
1002 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1003 yy_is_jam = (yy_current_state == 5);
1004
1005 return yy_is_jam ? 0 : yy_current_state;
1006 }
1007
1008 #ifndef YY_NO_UNPUT
1009
1010 static void yyunput (int c, char * yy_bp )
1011 {
1012 char *yy_cp;
1013
1014 yy_cp = (yy_c_buf_p);
1015
1016 /* undo effects of setting up yytext */
1017 *yy_cp = (yy_hold_char);
1018
1019 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1020 { /* need to shift things up to make room */
1021 /* +2 for EOB chars. */
1022 int number_to_move = (yy_n_chars) + 2;
1023 char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1024 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1025 char *source =
1026 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1027
1028 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1029 *--dest = *--source;
1030
1031 yy_cp += (int) (dest - source);
1032 yy_bp += (int) (dest - source);
1033 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1034 (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1035
1036 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1037 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1038 }
1039
1040 *--yy_cp = (char) c;
1041
1042 (yytext_ptr) = yy_bp;
1043 (yy_hold_char) = *yy_cp;
1044 (yy_c_buf_p) = yy_cp;
1045 }
1046
1047 #endif
1048
1049 #ifndef YY_NO_INPUT
1050 #ifdef __cplusplus
1051 static int yyinput (void)
1052 #else
1053 static int input (void)
1054 #endif
1055
1056 {
1057 int c;
1058
1059 *(yy_c_buf_p) = (yy_hold_char);
1060
1061 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1062 {
1063 /* yy_c_buf_p now points to the character we want to return.
1064 * If this occurs *before* the EOB characters, then it's a
1065 * valid NUL; if not, then we've hit the end of the buffer.
1066 */
1067 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1068 /* This was really a NUL. */
1069 *(yy_c_buf_p) = '\0';
1070
1071 else
1072 { /* need more input */
1073 int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
1074 ++(yy_c_buf_p);
1075
1076 switch ( yy_get_next_buffer( ) )
1077 {
1078 case EOB_ACT_LAST_MATCH:
1079 /* This happens because yy_g_n_b()
1080 * sees that we've accumulated a
1081 * token and flags that we need to
1082 * try matching the token before
1083 * proceeding. But for input(),
1084 * there's no matching to consider.
1085 * So convert the EOB_ACT_LAST_MATCH
1086 * to EOB_ACT_END_OF_FILE.
1087 */
1088
1089 /* Reset buffer status. */
1090 yyrestart( yyin );
1091
1092 /*FALLTHROUGH*/
1093
1094 case EOB_ACT_END_OF_FILE:
1095 {
1096 if ( yywrap( ) )
1097 return 0;
1098
1099 if ( ! (yy_did_buffer_switch_on_eof) )
1100 YY_NEW_FILE;
1101 #ifdef __cplusplus
1102 return yyinput();
1103 #else
1104 return input();
1105 #endif
1106 }
1107
1108 case EOB_ACT_CONTINUE_SCAN:
1109 (yy_c_buf_p) = (yytext_ptr) + offset;
1110 break;
1111 }
1112 }
1113 }
1114
1115 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1116 *(yy_c_buf_p) = '\0'; /* preserve yytext */
1117 (yy_hold_char) = *++(yy_c_buf_p);
1118
1119 return c;
1120 }
1121 #endif /* ifndef YY_NO_INPUT */
1122
1123 /** Immediately switch to a different input stream.
1124 * @param input_file A readable stream.
1125 *
1126 * @note This function does not reset the start condition to @c INITIAL .
1127 */
1128
1129 void yyrestart (FILE * input_file )
1130 {
1131
1132 if ( ! YY_CURRENT_BUFFER ){
1133 yyensure_buffer_stack ();
1134 YY_CURRENT_BUFFER_LVALUE = yy_create_buffer( yyin, YY_BUF_SIZE );
1135 }
1136
1137 yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1138 yy_load_buffer_state( );
1139 }
1140
1141 /** Switch to a different input buffer.
1142 * @param new_buffer The new input buffer.
1143 *
1144 */
1145 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1146 {
1147
1148 /* TODO. We should be able to replace this entire function body
1149 * with
1150 * yypop_buffer_state();
1151 * yypush_buffer_state(new_buffer);
1152 */
1153 yyensure_buffer_stack ();
1154 if ( YY_CURRENT_BUFFER == new_buffer )
1155 return;
1156
1157 if ( YY_CURRENT_BUFFER )
1158 {
1159 /* Flush out information for old buffer. */
1160 *(yy_c_buf_p) = (yy_hold_char);
1161 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1162 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1163 }
1164
1165 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1166 yy_load_buffer_state( );
1167
1168 /* We don't actually know whether we did this switch during
1169 * EOF (yywrap()) processing, but the only time this flag
1170 * is looked at is after yywrap() is called, so it's safe
1171 * to go ahead and always set it.
1172 */
1173 (yy_did_buffer_switch_on_eof) = 1;
1174 }
1175
1176 static void yy_load_buffer_state (void)
1177 {
1178 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1179 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1180 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1181 (yy_hold_char) = *(yy_c_buf_p);
1182 }
1183
1184 /** Allocate and initialize an input buffer state.
1185 * @param file A readable stream.
1186 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1187 *
1188 * @return the allocated buffer state.
1189 */
1190
1191 YY_BUFFER_STATE
1192 yy_create_buffer (FILE * file, int size )
1193 {
1194 YY_BUFFER_STATE b;
1195
1196 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1197 if ( ! b )
1198 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1199
1200 b->yy_buf_size = size;
1201
1202 /* yy_ch_buf has to be 2 characters longer than the size given because
1203 * we need to put in 2 end-of-buffer characters.
1204 */
1205 b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
1206 if ( ! b->yy_ch_buf )
1207 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1208
1209 b->yy_is_our_buffer = 1;
1210
1211 yy_init_buffer( b, file );
1212
1213 return b;
1214 }
1215
1216 /** Destroy the buffer.
1217 * @param b a buffer created with yy_create_buffer()
1218 *
1219 */
1220
1221 void yy_delete_buffer (YY_BUFFER_STATE b )
1222 {
1223
1224 if ( ! b )
1225 return;
1226
1227 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1228 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1229
1230 if ( b->yy_is_our_buffer )
1231 yyfree( (void *) b->yy_ch_buf );
1232
1233 yyfree( (void *) b );
1234 }
1235
1236 /* Initializes or reinitializes a buffer.
1237 * This function is sometimes called more than once on the same buffer,
1238 * such as during a yyrestart() or at EOF.
1239 */
1240
1241 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1242 {
1243 int oerrno = errno;
1244
1245 yy_flush_buffer( b );
1246
1247 b->yy_input_file = file;
1248 b->yy_fill_buffer = 1;
1249
1250 /* If b is the current buffer, then yy_init_buffer was _probably_
1251 * called from yyrestart() or through yy_get_next_buffer.
1252 * In that case, we don't want to reset the lineno or column.
1253 */
1254 if (b != YY_CURRENT_BUFFER){
1255 b->yy_bs_lineno = 1;
1256 b->yy_bs_column = 0;
1257 }
1258
1259 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1260
1261 errno = oerrno;
1262 }
1263
1264 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1265 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1266 *
1267 */
1268 void yy_flush_buffer (YY_BUFFER_STATE b )
1269 {
1270 if ( ! b )
1271 return;
1272
1273 b->yy_n_chars = 0;
1274
1275 /* We always need two end-of-buffer characters. The first causes
1276 * a transition to the end-of-buffer state. The second causes
1277 * a jam in that state.
1278 */
1279 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1280 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1281
1282 b->yy_buf_pos = &b->yy_ch_buf[0];
1283
1284 b->yy_at_bol = 1;
1285 b->yy_buffer_status = YY_BUFFER_NEW;
1286
1287 if ( b == YY_CURRENT_BUFFER )
1288 yy_load_buffer_state( );
1289 }
1290
1291 /** Pushes the new state onto the stack. The new state becomes
1292 * the current state. This function will allocate the stack
1293 * if necessary.
1294 * @param new_buffer The new state.
1295 *
1296 */
1297 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1298 {
1299 if (new_buffer == NULL)
1300 return;
1301
1302 yyensure_buffer_stack();
1303
1304 /* This block is copied from yy_switch_to_buffer. */
1305 if ( YY_CURRENT_BUFFER )
1306 {
1307 /* Flush out information for old buffer. */
1308 *(yy_c_buf_p) = (yy_hold_char);
1309 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1310 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1311 }
1312
1313 /* Only push if top exists. Otherwise, replace top. */
1314 if (YY_CURRENT_BUFFER)
1315 (yy_buffer_stack_top)++;
1316 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1317
1318 /* copied from yy_switch_to_buffer. */
1319 yy_load_buffer_state( );
1320 (yy_did_buffer_switch_on_eof) = 1;
1321 }
1322
1323 /** Removes and deletes the top of the stack, if present.
1324 * The next element becomes the new top.
1325 *
1326 */
1327 void yypop_buffer_state (void)
1328 {
1329 if (!YY_CURRENT_BUFFER)
1330 return;
1331
1332 yy_delete_buffer(YY_CURRENT_BUFFER );
1333 YY_CURRENT_BUFFER_LVALUE = NULL;
1334 if ((yy_buffer_stack_top) > 0)
1335 --(yy_buffer_stack_top);
1336
1337 if (YY_CURRENT_BUFFER) {
1338 yy_load_buffer_state( );
1339 (yy_did_buffer_switch_on_eof) = 1;
1340 }
1341 }
1342
1343 /* Allocates the stack if it does not exist.
1344 * Guarantees space for at least one push.
1345 */
1346 static void yyensure_buffer_stack (void)
1347 {
1348 yy_size_t num_to_alloc;
1349
1350 if (!(yy_buffer_stack)) {
1351
1352 /* First allocation is just for 2 elements, since we don't know if this
1353 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1354 * immediate realloc on the next call.
1355 */
1356 num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1357 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
1358 (num_to_alloc * sizeof(struct yy_buffer_state*)
1359 );
1360 if ( ! (yy_buffer_stack) )
1361 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1362
1363 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1364
1365 (yy_buffer_stack_max) = num_to_alloc;
1366 (yy_buffer_stack_top) = 0;
1367 return;
1368 }
1369
1370 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1371
1372 /* Increase the buffer to prepare for a possible push. */
1373 yy_size_t grow_size = 8 /* arbitrary grow size */;
1374
1375 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1376 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
1377 ((yy_buffer_stack),
1378 num_to_alloc * sizeof(struct yy_buffer_state*)
1379 );
1380 if ( ! (yy_buffer_stack) )
1381 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1382
1383 /* zero only the new slots.*/
1384 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1385 (yy_buffer_stack_max) = num_to_alloc;
1386 }
1387 }
1388
1389 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1390 * @param base the character buffer
1391 * @param size the size in bytes of the character buffer
1392 *
1393 * @return the newly allocated buffer state object.
1394 */
1395 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
1396 {
1397 YY_BUFFER_STATE b;
1398
1399 if ( size < 2 ||
1400 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1401 base[size-1] != YY_END_OF_BUFFER_CHAR )
1402 /* They forgot to leave room for the EOB's. */
1403 return NULL;
1404
1405 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1406 if ( ! b )
1407 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1408
1409 b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
1410 b->yy_buf_pos = b->yy_ch_buf = base;
1411 b->yy_is_our_buffer = 0;
1412 b->yy_input_file = NULL;
1413 b->yy_n_chars = b->yy_buf_size;
1414 b->yy_is_interactive = 0;
1415 b->yy_at_bol = 1;
1416 b->yy_fill_buffer = 0;
1417 b->yy_buffer_status = YY_BUFFER_NEW;
1418
1419 yy_switch_to_buffer( b );
1420
1421 return b;
1422 }
1423
1424 /** Setup the input buffer state to scan a string. The next call to yylex() will
1425 * scan from a @e copy of @a str.
1426 * @param yystr a NUL-terminated string to scan
1427 *
1428 * @return the newly allocated buffer state object.
1429 * @note If you want to scan bytes that may contain NUL values, then use
1430 * yy_scan_bytes() instead.
1431 */
1432 YY_BUFFER_STATE yy_scan_string (const char * yystr )
1433 {
1434
1435 return yy_scan_bytes( yystr, (int) strlen(yystr) );
1436 }
1437
1438 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1439 * scan from a @e copy of @a bytes.
1440 * @param yybytes the byte buffer to scan
1441 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1442 *
1443 * @return the newly allocated buffer state object.
1444 */
1445 YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
1446 {
1447 YY_BUFFER_STATE b;
1448 char *buf;
1449 yy_size_t n;
1450 int i;
1451
1452 /* Get memory for full buffer, including space for trailing EOB's. */
1453 n = (yy_size_t) (_yybytes_len + 2);
1454 buf = (char *) yyalloc( n );
1455 if ( ! buf )
1456 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1457
1458 for ( i = 0; i < _yybytes_len; ++i )
1459 buf[i] = yybytes[i];
1460
1461 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1462
1463 b = yy_scan_buffer( buf, n );
1464 if ( ! b )
1465 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1466
1467 /* It's okay to grow etc. this buffer, and we should throw it
1468 * away when we're done.
1469 */
1470 b->yy_is_our_buffer = 1;
1471
1472 return b;
1473 }
1474
1475 #ifndef YY_EXIT_FAILURE
1476 #define YY_EXIT_FAILURE 2
1477 #endif
1478
1479 static void yynoreturn yy_fatal_error (const char* msg )
1480 {
1481 fprintf( stderr, "%s\n", msg );
1482 exit( YY_EXIT_FAILURE );
1483 }
1484
1485 /* Redefine yyless() so it works in section 3 code. */
1486
1487 #undef yyless
1488 #define yyless(n) \
1489 do \
1490 { \
1491 /* Undo effects of setting up yytext. */ \
1492 int yyless_macro_arg = (n); \
1493 YY_LESS_LINENO(yyless_macro_arg);\
1494 yytext[yyleng] = (yy_hold_char); \
1495 (yy_c_buf_p) = yytext + yyless_macro_arg; \
1496 (yy_hold_char) = *(yy_c_buf_p); \
1497 *(yy_c_buf_p) = '\0'; \
1498 yyleng = yyless_macro_arg; \
1499 } \
1500 while ( 0 )
1501
1502 /* Accessor methods (get/set functions) to struct members. */
1503
1504 /** Get the current line number.
1505 *
1506 */
1507 int yyget_lineno (void)
1508 {
1509
1510 return yylineno;
1511 }
1512
1513 /** Get the input stream.
1514 *
1515 */
1516 FILE *yyget_in (void)
1517 {
1518 return yyin;
1519 }
1520
1521 /** Get the output stream.
1522 *
1523 */
1524 FILE *yyget_out (void)
1525 {
1526 return yyout;
1527 }
1528
1529 /** Get the length of the current token.
1530 *
1531 */
1532 int yyget_leng (void)
1533 {
1534 return yyleng;
1535 }
1536
1537 /** Get the current token.
1538 *
1539 */
1540
1541 char *yyget_text (void)
1542 {
1543 return yytext;
1544 }
1545
1546 /** Set the current line number.
1547 * @param _line_number line number
1548 *
1549 */
1550 void yyset_lineno (int _line_number )
1551 {
1552
1553 yylineno = _line_number;
1554 }
1555
1556 /** Set the input stream. This does not discard the current
1557 * input buffer.
1558 * @param _in_str A readable stream.
1559 *
1560 * @see yy_switch_to_buffer
1561 */
1562 void yyset_in (FILE * _in_str )
1563 {
1564 yyin = _in_str ;
1565 }
1566
1567 void yyset_out (FILE * _out_str )
1568 {
1569 yyout = _out_str ;
1570 }
1571
1572 int yyget_debug (void)
1573 {
1574 return yy_flex_debug;
1575 }
1576
1577 void yyset_debug (int _bdebug )
1578 {
1579 yy_flex_debug = _bdebug ;
1580 }
1581
1582 static int yy_init_globals (void)
1583 {
1584 /* Initialization is the same as for the non-reentrant scanner.
1585 * This function is called from yylex_destroy(), so don't allocate here.
1586 */
1587
1588 (yy_buffer_stack) = NULL;
1589 (yy_buffer_stack_top) = 0;
1590 (yy_buffer_stack_max) = 0;
1591 (yy_c_buf_p) = NULL;
1592 (yy_init) = 0;
1593 (yy_start) = 0;
1594
1595 /* Defined in main.c */
1596 #ifdef YY_STDINIT
1597 yyin = stdin;
1598 yyout = stdout;
1599 #else
1600 yyin = NULL;
1601 yyout = NULL;
1602 #endif
1603
1604 /* For future reference: Set errno on error, since we are called by
1605 * yylex_init()
1606 */
1607 return 0;
1608 }
1609
1610 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
1611 int yylex_destroy (void)
1612 {
1613
1614 /* Pop the buffer stack, destroying each element. */
1615 while(YY_CURRENT_BUFFER){
1616 yy_delete_buffer( YY_CURRENT_BUFFER );
1617 YY_CURRENT_BUFFER_LVALUE = NULL;
1618 yypop_buffer_state();
1619 }
1620
1621 /* Destroy the stack itself. */
1622 yyfree((yy_buffer_stack) );
1623 (yy_buffer_stack) = NULL;
1624
1625 /* Reset the globals. This is important in a non-reentrant scanner so the next time
1626 * yylex() is called, initialization will occur. */
1627 yy_init_globals( );
1628
1629 return 0;
1630 }
1631
1632 /*
1633 * Internal utility routines.
1634 */
1635
1636 #ifndef yytext_ptr
1637 static void yy_flex_strncpy (char* s1, const char * s2, int n )
1638 {
1639
1640 int i;
1641 for ( i = 0; i < n; ++i )
1642 s1[i] = s2[i];
1643 }
1644 #endif
1645
1646 #ifdef YY_NEED_STRLEN
1647 static int yy_flex_strlen (const char * s )
1648 {
1649 int n;
1650 for ( n = 0; s[n]; ++n )
1651 ;
1652
1653 return n;
1654 }
1655 #endif
1656
1657 void *yyalloc (yy_size_t size )
1658 {
1659 return malloc(size);
1660 }
1661
1662 void *yyrealloc (void * ptr, yy_size_t size )
1663 {
1664
1665 /* The cast to (char *) in the following accommodates both
1666 * implementations that use char* generic pointers, and those
1667 * that use void* generic pointers. It works with the latter
1668 * because both ANSI C and C++ allow castless assignment from
1669 * any pointer type to void*, and deal with argument conversions
1670 * as though doing an assignment.
1671 */
1672 return realloc(ptr, size);
1673 }
1674
1675 void yyfree (void * ptr )
1676 {
1677 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
1678 }
1679
1680 #define YYTABLES_NAME "yytables"