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