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