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