Block-Structured AMR Software Framework
amrex_iparser.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_iparser_create_buffer
7 #define yy_delete_buffer amrex_iparser_delete_buffer
8 #define yy_scan_buffer amrex_iparser_scan_buffer
9 #define yy_scan_string amrex_iparser_scan_string
10 #define yy_scan_bytes amrex_iparser_scan_bytes
11 #define yy_init_buffer amrex_iparser_init_buffer
12 #define yy_flush_buffer amrex_iparser_flush_buffer
13 #define yy_load_buffer_state amrex_iparser_load_buffer_state
14 #define yy_switch_to_buffer amrex_iparser_switch_to_buffer
15 #define yypush_buffer_state amrex_iparserpush_buffer_state
16 #define yypop_buffer_state amrex_iparserpop_buffer_state
17 #define yyensure_buffer_stack amrex_iparserensure_buffer_stack
18 #define yy_flex_debug amrex_iparser_flex_debug
19 #define yyin amrex_iparserin
20 #define yyleng amrex_iparserleng
21 #define yylex amrex_iparserlex
22 #define yylineno amrex_iparserlineno
23 #define yyout amrex_iparserout
24 #define yyrestart amrex_iparserrestart
25 #define yytext amrex_iparsertext
26 #define yywrap amrex_iparserwrap
27 #define yyalloc amrex_iparseralloc
28 #define yyrealloc amrex_iparserrealloc
29 #define yyfree amrex_iparserfree
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_iparser_create_buffer_ALREADY_DEFINED
41 #else
42 #define yy_create_buffer amrex_iparser_create_buffer
43 #endif
44 
45 #ifdef yy_delete_buffer
46 #define amrex_iparser_delete_buffer_ALREADY_DEFINED
47 #else
48 #define yy_delete_buffer amrex_iparser_delete_buffer
49 #endif
50 
51 #ifdef yy_scan_buffer
52 #define amrex_iparser_scan_buffer_ALREADY_DEFINED
53 #else
54 #define yy_scan_buffer amrex_iparser_scan_buffer
55 #endif
56 
57 #ifdef yy_scan_string
58 #define amrex_iparser_scan_string_ALREADY_DEFINED
59 #else
60 #define yy_scan_string amrex_iparser_scan_string
61 #endif
62 
63 #ifdef yy_scan_bytes
64 #define amrex_iparser_scan_bytes_ALREADY_DEFINED
65 #else
66 #define yy_scan_bytes amrex_iparser_scan_bytes
67 #endif
68 
69 #ifdef yy_init_buffer
70 #define amrex_iparser_init_buffer_ALREADY_DEFINED
71 #else
72 #define yy_init_buffer amrex_iparser_init_buffer
73 #endif
74 
75 #ifdef yy_flush_buffer
76 #define amrex_iparser_flush_buffer_ALREADY_DEFINED
77 #else
78 #define yy_flush_buffer amrex_iparser_flush_buffer
79 #endif
80 
81 #ifdef yy_load_buffer_state
82 #define amrex_iparser_load_buffer_state_ALREADY_DEFINED
83 #else
84 #define yy_load_buffer_state amrex_iparser_load_buffer_state
85 #endif
86 
87 #ifdef yy_switch_to_buffer
88 #define amrex_iparser_switch_to_buffer_ALREADY_DEFINED
89 #else
90 #define yy_switch_to_buffer amrex_iparser_switch_to_buffer
91 #endif
92 
93 #ifdef yypush_buffer_state
94 #define amrex_iparserpush_buffer_state_ALREADY_DEFINED
95 #else
96 #define yypush_buffer_state amrex_iparserpush_buffer_state
97 #endif
98 
99 #ifdef yypop_buffer_state
100 #define amrex_iparserpop_buffer_state_ALREADY_DEFINED
101 #else
102 #define yypop_buffer_state amrex_iparserpop_buffer_state
103 #endif
104 
105 #ifdef yyensure_buffer_stack
106 #define amrex_iparserensure_buffer_stack_ALREADY_DEFINED
107 #else
108 #define yyensure_buffer_stack amrex_iparserensure_buffer_stack
109 #endif
110 
111 #ifdef yylex
112 #define amrex_iparserlex_ALREADY_DEFINED
113 #else
114 #define yylex amrex_iparserlex
115 #endif
116 
117 #ifdef yyrestart
118 #define amrex_iparserrestart_ALREADY_DEFINED
119 #else
120 #define yyrestart amrex_iparserrestart
121 #endif
122 
123 #ifdef yylex_init
124 #define amrex_iparserlex_init_ALREADY_DEFINED
125 #else
126 #define yylex_init amrex_iparserlex_init
127 #endif
128 
129 #ifdef yylex_init_extra
130 #define amrex_iparserlex_init_extra_ALREADY_DEFINED
131 #else
132 #define yylex_init_extra amrex_iparserlex_init_extra
133 #endif
134 
135 #ifdef yylex_destroy
136 #define amrex_iparserlex_destroy_ALREADY_DEFINED
137 #else
138 #define yylex_destroy amrex_iparserlex_destroy
139 #endif
140 
141 #ifdef yyget_debug
142 #define amrex_iparserget_debug_ALREADY_DEFINED
143 #else
144 #define yyget_debug amrex_iparserget_debug
145 #endif
146 
147 #ifdef yyset_debug
148 #define amrex_iparserset_debug_ALREADY_DEFINED
149 #else
150 #define yyset_debug amrex_iparserset_debug
151 #endif
152 
153 #ifdef yyget_extra
154 #define amrex_iparserget_extra_ALREADY_DEFINED
155 #else
156 #define yyget_extra amrex_iparserget_extra
157 #endif
158 
159 #ifdef yyset_extra
160 #define amrex_iparserset_extra_ALREADY_DEFINED
161 #else
162 #define yyset_extra amrex_iparserset_extra
163 #endif
164 
165 #ifdef yyget_in
166 #define amrex_iparserget_in_ALREADY_DEFINED
167 #else
168 #define yyget_in amrex_iparserget_in
169 #endif
170 
171 #ifdef yyset_in
172 #define amrex_iparserset_in_ALREADY_DEFINED
173 #else
174 #define yyset_in amrex_iparserset_in
175 #endif
176 
177 #ifdef yyget_out
178 #define amrex_iparserget_out_ALREADY_DEFINED
179 #else
180 #define yyget_out amrex_iparserget_out
181 #endif
182 
183 #ifdef yyset_out
184 #define amrex_iparserset_out_ALREADY_DEFINED
185 #else
186 #define yyset_out amrex_iparserset_out
187 #endif
188 
189 #ifdef yyget_leng
190 #define amrex_iparserget_leng_ALREADY_DEFINED
191 #else
192 #define yyget_leng amrex_iparserget_leng
193 #endif
194 
195 #ifdef yyget_text
196 #define amrex_iparserget_text_ALREADY_DEFINED
197 #else
198 #define yyget_text amrex_iparserget_text
199 #endif
200 
201 #ifdef yyget_lineno
202 #define amrex_iparserget_lineno_ALREADY_DEFINED
203 #else
204 #define yyget_lineno amrex_iparserget_lineno
205 #endif
206 
207 #ifdef yyset_lineno
208 #define amrex_iparserset_lineno_ALREADY_DEFINED
209 #else
210 #define yyset_lineno amrex_iparserset_lineno
211 #endif
212 
213 #ifdef yywrap
214 #define amrex_iparserwrap_ALREADY_DEFINED
215 #else
216 #define yywrap amrex_iparserwrap
217 #endif
218 
219 #ifdef yyalloc
220 #define amrex_iparseralloc_ALREADY_DEFINED
221 #else
222 #define yyalloc amrex_iparseralloc
223 #endif
224 
225 #ifdef yyrealloc
226 #define amrex_iparserrealloc_ALREADY_DEFINED
227 #else
228 #define yyrealloc amrex_iparserrealloc
229 #endif
230 
231 #ifdef yyfree
232 #define amrex_iparserfree_ALREADY_DEFINED
233 #else
234 #define yyfree amrex_iparserfree
235 #endif
236 
237 #ifdef yytext
238 #define amrex_iparsertext_ALREADY_DEFINED
239 #else
240 #define yytext amrex_iparsertext
241 #endif
242 
243 #ifdef yyleng
244 #define amrex_iparserleng_ALREADY_DEFINED
245 #else
246 #define yyleng amrex_iparserleng
247 #endif
248 
249 #ifdef yyin
250 #define amrex_iparserin_ALREADY_DEFINED
251 #else
252 #define yyin amrex_iparserin
253 #endif
254 
255 #ifdef yyout
256 #define amrex_iparserout_ALREADY_DEFINED
257 #else
258 #define yyout amrex_iparserout
259 #endif
260 
261 #ifdef yy_flex_debug
262 #define amrex_iparser_flex_debug_ALREADY_DEFINED
263 #else
264 #define yy_flex_debug amrex_iparser_flex_debug
265 #endif
266 
267 #ifdef yylineno
268 #define amrex_iparserlineno_ALREADY_DEFINED
269 #else
270 #define yylineno amrex_iparserlineno
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_iparserwrap() (/*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 34
615 #define YY_END_OF_BUFFER 35
616 /* This struct is not used in this scanner,
617  but its presence is necessary. */
619  {
622  };
623 static const flex_int16_t yy_accept[59] =
624  { 0,
625  0, 0, 35, 33, 30, 32, 33, 10, 11, 3,
626  1, 6, 2, 33, 4, 27, 9, 7, 5, 8,
627  26, 33, 16, 26, 26, 26, 26, 20, 15, 29,
628  14, 27, 28, 27, 0, 18, 19, 17, 26, 31,
629  26, 26, 26, 25, 26, 26, 22, 28, 0, 29,
630  12, 21, 26, 24, 23, 28, 13, 0
631  } ;
632 
633 static const YY_CHAR yy_ec[256] =
634  { 0,
635  1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
636  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
637  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
638  1, 2, 4, 1, 1, 1, 1, 1, 5, 6,
639  7, 8, 9, 10, 11, 12, 13, 14, 14, 14,
640  14, 14, 14, 14, 14, 14, 14, 1, 15, 16,
641  17, 18, 1, 1, 19, 19, 19, 19, 20, 19,
642  19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
643  19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
644  1, 21, 1, 22, 19, 1, 23, 24, 19, 25,
645 
646  20, 26, 19, 19, 27, 19, 19, 19, 28, 29,
647  30, 19, 19, 31, 32, 19, 19, 19, 19, 33,
648  19, 19, 1, 1, 1, 1, 1, 1, 1, 1,
649  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
650  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
651  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
652  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
653  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
654  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
655  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
656 
657  1, 1, 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
663  } ;
664 
665 static const YY_CHAR yy_meta[34] =
666  { 0,
667  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
668  1, 2, 1, 2, 1, 1, 1, 1, 2, 2,
669  1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
670  2, 2, 2
671  } ;
672 
673 static const flex_int16_t yy_base[60] =
674  { 0,
675  0, 0, 76, 77, 77, 77, 58, 77, 77, 66,
676  77, 77, 77, 59, 59, 29, 77, 54, 53, 52,
677  0, 65, 77, 11, 13, 15, 36, 77, 77, 30,
678  77, 32, 31, 42, 52, 77, 77, 77, 0, 77,
679  33, 39, 39, 0, 28, 31, 0, 38, 45, 43,
680  0, 0, 23, 0, 0, 39, 0, 77, 46
681  } ;
682 
683 static const flex_int16_t yy_def[60] =
684  { 0,
685  58, 1, 58, 58, 58, 58, 58, 58, 58, 58,
686  58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
687  59, 58, 58, 59, 59, 59, 59, 58, 58, 58,
688  58, 58, 58, 58, 58, 58, 58, 58, 59, 58,
689  59, 59, 59, 59, 59, 59, 59, 58, 58, 58,
690  59, 59, 59, 59, 59, 58, 59, 0, 58
691  } ;
692 
693 static const flex_int16_t yy_nxt[111] =
694  { 0,
695  4, 5, 6, 7, 4, 8, 9, 10, 11, 12,
696  13, 14, 15, 16, 17, 18, 19, 20, 21, 21,
697  22, 23, 24, 21, 21, 21, 25, 26, 21, 27,
698  21, 21, 21, 32, 41, 43, 32, 45, 44, 42,
699  33, 46, 34, 30, 48, 32, 32, 39, 35, 35,
700  49, 48, 56, 33, 57, 34, 50, 49, 56, 55,
701  54, 35, 53, 52, 51, 50, 47, 40, 38, 37,
702  36, 31, 30, 29, 28, 58, 3, 58, 58, 58,
703  58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
704  58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
705 
706  58, 58, 58, 58, 58, 58, 58, 58, 58, 58
707  } ;
708 
709 static const flex_int16_t yy_chk[111] =
710  { 0,
711  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
712  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
713  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
714  1, 1, 1, 16, 24, 25, 32, 26, 25, 24,
715  16, 26, 16, 30, 33, 32, 34, 59, 16, 30,
716  33, 48, 56, 34, 53, 34, 50, 48, 49, 46,
717  45, 34, 43, 42, 41, 35, 27, 22, 20, 19,
718  18, 15, 14, 10, 7, 3, 58, 58, 58, 58,
719  58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
720  58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
721 
722  58, 58, 58, 58, 58, 58, 58, 58, 58, 58
723  } ;
724 
727 
728 extern int yy_flex_debug;
730 
731 /* The intent behind this definition is that it'll catch
732  * any uses of REJECT which flex missed.
733  */
734 #define REJECT reject_used_but_not_detected
735 #define yymore() yymore_used_but_not_detected
736 #define YY_MORE_ADJ 0
737 #define YY_RESTORE_YY_MORE_OFFSET
738 char *yytext;
739 #include "AMReX_IParser_Y.H"
740 #include "amrex_iparser.tab.h"
741 #ifdef _WIN32
742 #define YY_NO_UNISTD_H
743 #endif
744 #define YY_NO_INPUT 1
745  /* Tokens NUMBER, SYMBOL, F1, POW, F2, etc. are defined in amrex_iparser.y. */
746  /* Types IPARSER_ABS, IPARSER_MIN etc. are defined in AMReX_IParser_y.H. */
747  /* Used later to define NUMBER */
748 
749 #define INITIAL 0
750 
751 #ifndef YY_NO_UNISTD_H
752 /* Special case for "unistd.h", since it is non-ANSI. We include it way
753  * down here because we want the user's section 1 to have been scanned first.
754  * The user has a chance to override it with an option.
755  */
756 #include <unistd.h>
757 #endif
758 
759 #ifndef YY_EXTRA_TYPE
760 #define YY_EXTRA_TYPE void *
761 #endif
762 
763 static int yy_init_globals ( void );
764 
765 /* Accessor methods to globals.
766  These are made visible to non-reentrant scanners for convenience. */
767 
768 int yylex_destroy ( void );
769 
770 int yyget_debug ( void );
771 
772 void yyset_debug ( int debug_flag );
773 
774 YY_EXTRA_TYPE yyget_extra ( void );
775 
776 void yyset_extra ( YY_EXTRA_TYPE user_defined );
777 
778 FILE *yyget_in ( void );
779 
780 void yyset_in ( FILE * _in_str );
781 
782 FILE *yyget_out ( void );
783 
784 void yyset_out ( FILE * _out_str );
785 
786  int yyget_leng ( void );
787 
788 char *yyget_text ( void );
789 
790 int yyget_lineno ( void );
791 
792 void yyset_lineno ( int _line_number );
793 
794 /* Macros after this point can all be overridden by user definitions in
795  * section 1.
796  */
797 
798 #ifndef YY_SKIP_YYWRAP
799 #ifdef __cplusplus
800 extern "C" int yywrap ( void );
801 #else
802 extern int yywrap ( void );
803 #endif
804 #endif
805 
806 #ifndef YY_NO_UNPUT
807 
808 #endif
809 
810 #ifndef yytext_ptr
811 static void yy_flex_strncpy ( char *, const char *, int );
812 #endif
813 
814 #ifdef YY_NEED_STRLEN
815 static int yy_flex_strlen ( const char * );
816 #endif
817 
818 #ifndef YY_NO_INPUT
819 #ifdef __cplusplus
820 static int yyinput ( void );
821 #else
822 static int input ( void );
823 #endif
824 
825 #endif
826 
827 /* Amount of stuff to slurp up with each read. */
828 #ifndef YY_READ_BUF_SIZE
829 #ifdef __ia64__
830 /* On IA-64, the buffer size is 16k, not 8k */
831 #define YY_READ_BUF_SIZE 16384
832 #else
833 #define YY_READ_BUF_SIZE 8192
834 #endif /* __ia64__ */
835 #endif
836 
837 /* Copy whatever the last rule matched to the standard output. */
838 #ifndef ECHO
839 /* This used to be an fputs(), but since the string might contain NUL's,
840  * we now use fwrite().
841  */
842 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
843 #endif
844 
845 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
846  * is returned in "result".
847  */
848 #ifndef YY_INPUT
849 #define YY_INPUT(buf,result,max_size) \
850  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
851  { \
852  int c = '*'; \
853  int n; \
854  for ( n = 0; n < max_size && \
855  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
856  buf[n] = (char) c; \
857  if ( c == '\n' ) \
858  buf[n++] = (char) c; \
859  if ( c == EOF && ferror( yyin ) ) \
860  YY_FATAL_ERROR( "input in flex scanner failed" ); \
861  result = n; \
862  } \
863  else \
864  { \
865  errno=0; \
866  while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
867  { \
868  if( errno != EINTR) \
869  { \
870  YY_FATAL_ERROR( "input in flex scanner failed" ); \
871  break; \
872  } \
873  errno=0; \
874  clearerr(yyin); \
875  } \
876  }\
877 \
878 
879 #endif
880 
881 /* No semi-colon after return; correct usage is to write "yyterminate();" -
882  * we don't want an extra ';' after the "return" because that will cause
883  * some compilers to complain about unreachable statements.
884  */
885 #ifndef yyterminate
886 #define yyterminate() return YY_NULL
887 #endif
888 
889 /* Number of entries by which start-condition stack grows. */
890 #ifndef YY_START_STACK_INCR
891 #define YY_START_STACK_INCR 25
892 #endif
893 
894 /* Report a fatal error. */
895 #ifndef YY_FATAL_ERROR
896 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
897 #endif
898 
899 /* end tables serialization structures and prototypes */
900 
901 /* Default declaration of generated scanner - a define so the user can
902  * easily add parameters.
903  */
904 #ifndef YY_DECL
905 #define YY_DECL_IS_OURS 1
906 
907 extern int yylex (void);
908 
909 #define YY_DECL int yylex (void)
910 #endif /* !YY_DECL */
911 
912 /* Code executed at the beginning of each rule, after yytext and yyleng
913  * have been set up.
914  */
915 #ifndef YY_USER_ACTION
916 #define YY_USER_ACTION
917 #endif
918 
919 /* Code executed at the end of each rule. */
920 #ifndef YY_BREAK
921 #define YY_BREAK /*LINTED*/break;
922 #endif
923 
924 #define YY_RULE_SETUP \
925  YY_USER_ACTION
926 
930 {
931  yy_state_type yy_current_state;
932  char *yy_cp, *yy_bp;
933  int yy_act;
934 
935  if ( !(yy_init) )
936  {
937  (yy_init) = 1;
938 
939 #ifdef YY_USER_INIT
940  YY_USER_INIT;
941 #endif
942 
943  if ( ! (yy_start) )
944  (yy_start) = 1; /* first start state */
945 
946  if ( ! yyin )
947  yyin = stdin;
948 
949  if ( ! yyout )
950  yyout = stdout;
951 
952  if ( ! YY_CURRENT_BUFFER ) {
956  }
957 
959  }
960 
961  {
962 
963  while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
964  {
965  yy_cp = (yy_c_buf_p);
966 
967  /* Support of yytext. */
968  *yy_cp = (yy_hold_char);
969 
970  /* yy_bp points to the position in yy_ch_buf of the start of
971  * the current run.
972  */
973  yy_bp = yy_cp;
974 
975  yy_current_state = (yy_start);
976 yy_match:
977  do
978  {
979  YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
980  if ( yy_accept[yy_current_state] )
981  {
982  (yy_last_accepting_state) = yy_current_state;
984  }
985  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
986  {
987  yy_current_state = (int) yy_def[yy_current_state];
988  if ( yy_current_state >= 59 )
989  yy_c = yy_meta[yy_c];
990  }
991  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
992  ++yy_cp;
993  }
994  while ( yy_current_state != 58 );
996  yy_current_state = (yy_last_accepting_state);
997 
998 yy_find_action:
999  yy_act = yy_accept[yy_current_state];
1000 
1002 
1003 do_action: /* This label is used only to access EOF actions. */
1004 
1005  switch ( yy_act )
1006  { /* beginning of action switch */
1007  case 0: /* must back up */
1008  /* undo the effects of YY_DO_BEFORE_ACTION */
1009  *yy_cp = (yy_hold_char);
1011  yy_current_state = (yy_last_accepting_state);
1012  goto yy_find_action;
1013 
1014 case 1:
1015 case 2:
1016 case 3:
1017 case 4:
1018 case 5:
1019 case 6:
1020 case 7:
1021 case 8:
1022 case 9:
1023 case 10:
1024 case 11:
1026 { return amrex_iparsertext[0]; } /* simply pass through */
1027  YY_BREAK
1028 /* amrex_iparserlval is union type defined in amrex_iparser.tab.h that is generated
1029  * by bison with amrex_iparser.y */
1030 case 12:
1033  YY_BREAK
1034 case 13:
1037  YY_BREAK
1038 case 14:
1041  YY_BREAK
1042 case 15:
1045  YY_BREAK
1046 case 16:
1049  YY_BREAK
1050 case 17:
1053  YY_BREAK
1054 case 18:
1057  YY_BREAK
1058 case 19:
1061  YY_BREAK
1062 case 20:
1065  YY_BREAK
1066 case 21:
1069  YY_BREAK
1070 case 22:
1073  YY_BREAK
1074 case 23:
1077  YY_BREAK
1078 case 24:
1081  YY_BREAK
1082 case 25:
1085  YY_BREAK
1086 /* We use SYMBOL to hold variables and constants */
1087 case 26:
1089 { amrex_iparserlval.s = amrex::iparser_makesymbol(amrex_iparsertext); return SYMBOL; }
1090  YY_BREAK
1091 /* Number */
1092 case 27:
1093 case 28:
1094 case 29:
1096 { amrex_iparserlval.d = amrex::iparser_atoll(amrex_iparsertext); return NUMBER; }
1097  YY_BREAK
1098 /* Special characters */
1099 case 30:
1101 /* ignore white space */
1102  YY_BREAK
1103 case 31:
1104 /* rule 31 can match eol */
1106 /* ignore line continuation */
1107  YY_BREAK
1108 case 32:
1109 /* rule 32 can match eol */
1111 { return EOL; }
1112  YY_BREAK
1113 /* everything else */
1114 case 33:
1116 { amrex_iparsererror("Unknown character %c", *amrex_iparsertext); }
1117  YY_BREAK
1118 case 34:
1120 YY_FATAL_ERROR( "flex scanner jammed" );
1121  YY_BREAK
1122 case YY_STATE_EOF(INITIAL):
1123  yyterminate();
1124 
1125  case YY_END_OF_BUFFER:
1126  {
1127  /* Amount of text matched not including the EOB char. */
1128  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1129 
1130  /* Undo the effects of YY_DO_BEFORE_ACTION. */
1131  *yy_cp = (yy_hold_char);
1133 
1134  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1135  {
1136  /* We're scanning a new file or input source. It's
1137  * possible that this happened because the user
1138  * just pointed yyin at a new source and called
1139  * yylex(). If so, then we have to assure
1140  * consistency between YY_CURRENT_BUFFER and our
1141  * globals. Here is the right place to do so, because
1142  * this is the first action (other than possibly a
1143  * back-up) that will match for the new input source.
1144  */
1145  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1146  YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1147  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1148  }
1149 
1150  /* Note that here we test for yy_c_buf_p "<=" to the position
1151  * of the first EOB in the buffer, since yy_c_buf_p will
1152  * already have been incremented past the NUL character
1153  * (since all states make transitions on EOB to the
1154  * end-of-buffer state). Contrast this with the test
1155  * in input().
1156  */
1157  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1158  { /* This was really a NUL. */
1159  yy_state_type yy_next_state;
1160 
1161  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1162 
1163  yy_current_state = yy_get_previous_state( );
1164 
1165  /* Okay, we're now positioned to make the NUL
1166  * transition. We couldn't have
1167  * yy_get_previous_state() go ahead and do it
1168  * for us because it doesn't know how to deal
1169  * with the possibility of jamming (and we don't
1170  * want to build jamming into it because then it
1171  * will run more slowly).
1172  */
1173 
1174  yy_next_state = yy_try_NUL_trans( yy_current_state );
1175 
1177 
1178  if ( yy_next_state )
1179  {
1180  /* Consume the NUL. */
1181  yy_cp = ++(yy_c_buf_p);
1182  yy_current_state = yy_next_state;
1183  goto yy_match;
1184  }
1185 
1186  else
1187  {
1189  yy_current_state = (yy_last_accepting_state);
1190  goto yy_find_action;
1191  }
1192  }
1193 
1194  else switch ( yy_get_next_buffer( ) )
1195  {
1196  case EOB_ACT_END_OF_FILE:
1197  {
1199 
1200  if ( yywrap( ) )
1201  {
1202  /* Note: because we've taken care in
1203  * yy_get_next_buffer() to have set up
1204  * yytext, we can now set up
1205  * yy_c_buf_p so that if some total
1206  * hoser (like flex itself) wants to
1207  * call the scanner after we return the
1208  * YY_NULL, it'll still work - another
1209  * YY_NULL will get returned.
1210  */
1212 
1214  goto do_action;
1215  }
1216 
1217  else
1218  {
1219  if ( ! (yy_did_buffer_switch_on_eof) )
1220  YY_NEW_FILE;
1221  }
1222  break;
1223  }
1224 
1225  case EOB_ACT_CONTINUE_SCAN:
1226  (yy_c_buf_p) =
1227  (yytext_ptr) + yy_amount_of_matched_text;
1228 
1229  yy_current_state = yy_get_previous_state( );
1230 
1231  yy_cp = (yy_c_buf_p);
1233  goto yy_match;
1234 
1235  case EOB_ACT_LAST_MATCH:
1236  (yy_c_buf_p) =
1237  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1238 
1239  yy_current_state = yy_get_previous_state( );
1240 
1241  yy_cp = (yy_c_buf_p);
1243  goto yy_find_action;
1244  }
1245  break;
1246  }
1247 
1248  default:
1250  "fatal flex scanner internal error--no action found" );
1251  } /* end of action switch */
1252  } /* end of scanning one token */
1253  } /* end of user's declarations */
1254 } /* end of yylex */
1255 
1256 /* yy_get_next_buffer - try to read in a new buffer
1257  *
1258  * Returns a code representing an action:
1259  * EOB_ACT_LAST_MATCH -
1260  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1261  * EOB_ACT_END_OF_FILE - end of file
1262  */
1263 static int yy_get_next_buffer (void)
1264 {
1265  char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1266  char *source = (yytext_ptr);
1267  int number_to_move, i;
1268  int ret_val;
1269 
1270  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1272  "fatal flex scanner internal error--end of buffer missed" );
1273 
1274  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1275  { /* Don't try to fill the buffer, so this is an EOF. */
1276  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1277  {
1278  /* We matched a single character, the EOB, so
1279  * treat this as a final EOF.
1280  */
1281  return EOB_ACT_END_OF_FILE;
1282  }
1283 
1284  else
1285  {
1286  /* We matched some text prior to the EOB, first
1287  * process it.
1288  */
1289  return EOB_ACT_LAST_MATCH;
1290  }
1291  }
1292 
1293  /* Try to read more data. */
1294 
1295  /* First move last chars to start of buffer. */
1296  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1297 
1298  for ( i = 0; i < number_to_move; ++i )
1299  *(dest++) = *(source++);
1300 
1301  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1302  /* don't do the read, it's not guaranteed to return an EOF,
1303  * just force an EOF
1304  */
1305  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1306 
1307  else
1308  {
1309  int num_to_read =
1310  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1311 
1312  while ( num_to_read <= 0 )
1313  { /* Not enough room in the buffer - grow it. */
1314 
1315  /* just a shorter name for the current buffer */
1317 
1318  int yy_c_buf_p_offset =
1319  (int) ((yy_c_buf_p) - b->yy_ch_buf);
1320 
1321  if ( b->yy_is_our_buffer )
1322  {
1323  int new_size = b->yy_buf_size * 2;
1324 
1325  if ( new_size <= 0 )
1326  b->yy_buf_size += b->yy_buf_size / 8;
1327  else
1328  b->yy_buf_size *= 2;
1329 
1330  b->yy_ch_buf = (char *)
1331  /* Include room in for 2 EOB chars. */
1332  yyrealloc( (void *) b->yy_ch_buf,
1333  (yy_size_t) (b->yy_buf_size + 2) );
1334  }
1335  else
1336  /* Can't grow it, we don't own it. */
1337  b->yy_ch_buf = NULL;
1338 
1339  if ( ! b->yy_ch_buf )
1341  "fatal error - scanner input buffer overflow" );
1342 
1343  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1344 
1345  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1346  number_to_move - 1;
1347 
1348  }
1349 
1350  if ( num_to_read > YY_READ_BUF_SIZE )
1351  num_to_read = YY_READ_BUF_SIZE;
1352 
1353  /* Read in more data. */
1354  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1355  (yy_n_chars), num_to_read );
1356 
1357  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1358  }
1359 
1360  if ( (yy_n_chars) == 0 )
1361  {
1362  if ( number_to_move == YY_MORE_ADJ )
1363  {
1364  ret_val = EOB_ACT_END_OF_FILE;
1365  yyrestart( yyin );
1366  }
1367 
1368  else
1369  {
1370  ret_val = EOB_ACT_LAST_MATCH;
1371  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1373  }
1374  }
1375 
1376  else
1377  ret_val = EOB_ACT_CONTINUE_SCAN;
1378 
1379  if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1380  /* Extend the array by 50%, plus the number we really need. */
1381  int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1382  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1383  (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
1384  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1385  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1386  /* "- 2" to take care of EOB's */
1387  YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1388  }
1389 
1390  (yy_n_chars) += number_to_move;
1393 
1394  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1395 
1396  return ret_val;
1397 }
1398 
1399 /* yy_get_previous_state - get the state just before the EOB char was reached */
1400 
1401  static yy_state_type yy_get_previous_state (void)
1402 {
1403  yy_state_type yy_current_state;
1404  char *yy_cp;
1405 
1406  yy_current_state = (yy_start);
1407 
1408  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1409  {
1410  YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1411  if ( yy_accept[yy_current_state] )
1412  {
1413  (yy_last_accepting_state) = yy_current_state;
1415  }
1416  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1417  {
1418  yy_current_state = (int) yy_def[yy_current_state];
1419  if ( yy_current_state >= 59 )
1420  yy_c = yy_meta[yy_c];
1421  }
1422  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1423  }
1424 
1425  return yy_current_state;
1426 }
1427 
1428 /* yy_try_NUL_trans - try to make a transition on the NUL character
1429  *
1430  * synopsis
1431  * next_state = yy_try_NUL_trans( current_state );
1432  */
1433  static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1434 {
1435  int yy_is_jam;
1436  char *yy_cp = (yy_c_buf_p);
1437 
1438  YY_CHAR yy_c = 1;
1439  if ( yy_accept[yy_current_state] )
1440  {
1441  (yy_last_accepting_state) = yy_current_state;
1443  }
1444  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1445  {
1446  yy_current_state = (int) yy_def[yy_current_state];
1447  if ( yy_current_state >= 59 )
1448  yy_c = yy_meta[yy_c];
1449  }
1450  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1451  yy_is_jam = (yy_current_state == 58);
1452 
1453  return yy_is_jam ? 0 : yy_current_state;
1454 }
1455 
1456 #ifndef YY_NO_UNPUT
1457 
1458 #endif
1459 
1460 #ifndef YY_NO_INPUT
1461 #ifdef __cplusplus
1462  static int yyinput (void)
1463 #else
1464  static int input (void)
1465 #endif
1466 
1467 {
1468  int c;
1469 
1470  *(yy_c_buf_p) = (yy_hold_char);
1471 
1472  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1473  {
1474  /* yy_c_buf_p now points to the character we want to return.
1475  * If this occurs *before* the EOB characters, then it's a
1476  * valid NUL; if not, then we've hit the end of the buffer.
1477  */
1478  if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1479  /* This was really a NUL. */
1480  *(yy_c_buf_p) = '\0';
1481 
1482  else
1483  { /* need more input */
1484  int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
1485  ++(yy_c_buf_p);
1486 
1487  switch ( yy_get_next_buffer( ) )
1488  {
1489  case EOB_ACT_LAST_MATCH:
1490  /* This happens because yy_g_n_b()
1491  * sees that we've accumulated a
1492  * token and flags that we need to
1493  * try matching the token before
1494  * proceeding. But for input(),
1495  * there's no matching to consider.
1496  * So convert the EOB_ACT_LAST_MATCH
1497  * to EOB_ACT_END_OF_FILE.
1498  */
1499 
1500  /* Reset buffer status. */
1501  yyrestart( yyin );
1502 
1503  /*FALLTHROUGH*/
1504 
1505  case EOB_ACT_END_OF_FILE:
1506  {
1507  if ( yywrap( ) )
1508  return 0;
1509 
1510  if ( ! (yy_did_buffer_switch_on_eof) )
1511  YY_NEW_FILE;
1512 #ifdef __cplusplus
1513  return yyinput();
1514 #else
1515  return input();
1516 #endif
1517  }
1518 
1519  case EOB_ACT_CONTINUE_SCAN:
1520  (yy_c_buf_p) = (yytext_ptr) + offset;
1521  break;
1522  }
1523  }
1524  }
1525 
1526  c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1527  *(yy_c_buf_p) = '\0'; /* preserve yytext */
1528  (yy_hold_char) = *++(yy_c_buf_p);
1529 
1530  return c;
1531 }
1532 #endif /* ifndef YY_NO_INPUT */
1533 
1539  void yyrestart (FILE * input_file )
1540 {
1541 
1542  if ( ! YY_CURRENT_BUFFER ){
1546  }
1547 
1548  yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1550 }
1551 
1556  void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1557 {
1558 
1559  /* TODO. We should be able to replace this entire function body
1560  * with
1561  * yypop_buffer_state();
1562  * yypush_buffer_state(new_buffer);
1563  */
1565  if ( YY_CURRENT_BUFFER == new_buffer )
1566  return;
1567 
1568  if ( YY_CURRENT_BUFFER )
1569  {
1570  /* Flush out information for old buffer. */
1571  *(yy_c_buf_p) = (yy_hold_char);
1572  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1573  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1574  }
1575 
1576  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1578 
1579  /* We don't actually know whether we did this switch during
1580  * EOF (yywrap()) processing, but the only time this flag
1581  * is looked at is after yywrap() is called, so it's safe
1582  * to go ahead and always set it.
1583  */
1585 }
1586 
1587 static void yy_load_buffer_state (void)
1588 {
1589  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1590  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1591  yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1592  (yy_hold_char) = *(yy_c_buf_p);
1593 }
1594 
1601  YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
1602 {
1604 
1605  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1606  if ( ! b )
1607  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1608 
1609  b->yy_buf_size = size;
1610 
1611  /* yy_ch_buf has to be 2 characters longer than the size given because
1612  * we need to put in 2 end-of-buffer characters.
1613  */
1614  b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
1615  if ( ! b->yy_ch_buf )
1616  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1617 
1618  b->yy_is_our_buffer = 1;
1619 
1620  yy_init_buffer( b, file );
1621 
1622  return b;
1623 }
1624 
1630 {
1631 
1632  if ( ! b )
1633  return;
1634 
1635  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1637 
1638  if ( b->yy_is_our_buffer )
1639  yyfree( (void *) b->yy_ch_buf );
1640 
1641  yyfree( (void *) b );
1642 }
1643 
1644 /* Initializes or reinitializes a buffer.
1645  * This function is sometimes called more than once on the same buffer,
1646  * such as during a yyrestart() or at EOF.
1647  */
1648  static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1649 
1650 {
1651  int oerrno = errno;
1652 
1653  yy_flush_buffer( b );
1654 
1655  b->yy_input_file = file;
1656  b->yy_fill_buffer = 1;
1657 
1658  /* If b is the current buffer, then yy_init_buffer was _probably_
1659  * called from yyrestart() or through yy_get_next_buffer.
1660  * In that case, we don't want to reset the lineno or column.
1661  */
1662  if (b != YY_CURRENT_BUFFER){
1663  b->yy_bs_lineno = 1;
1664  b->yy_bs_column = 0;
1665  }
1666 
1667  b->yy_is_interactive = 0;
1668 
1669  errno = oerrno;
1670 }
1671 
1677 {
1678  if ( ! b )
1679  return;
1680 
1681  b->yy_n_chars = 0;
1682 
1683  /* We always need two end-of-buffer characters. The first causes
1684  * a transition to the end-of-buffer state. The second causes
1685  * a jam in that state.
1686  */
1687  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1688  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1689 
1690  b->yy_buf_pos = &b->yy_ch_buf[0];
1691 
1692  b->yy_at_bol = 1;
1693  b->yy_buffer_status = YY_BUFFER_NEW;
1694 
1695  if ( b == YY_CURRENT_BUFFER )
1697 }
1698 
1705 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1706 {
1707  if (new_buffer == NULL)
1708  return;
1709 
1711 
1712  /* This block is copied from yy_switch_to_buffer. */
1713  if ( YY_CURRENT_BUFFER )
1714  {
1715  /* Flush out information for old buffer. */
1716  *(yy_c_buf_p) = (yy_hold_char);
1717  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1718  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1719  }
1720 
1721  /* Only push if top exists. Otherwise, replace top. */
1722  if (YY_CURRENT_BUFFER)
1723  (yy_buffer_stack_top)++;
1724  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1725 
1726  /* copied from yy_switch_to_buffer. */
1729 }
1730 
1735 void yypop_buffer_state (void)
1736 {
1737  if (!YY_CURRENT_BUFFER)
1738  return;
1739 
1741  YY_CURRENT_BUFFER_LVALUE = NULL;
1742  if ((yy_buffer_stack_top) > 0)
1743  --(yy_buffer_stack_top);
1744 
1745  if (YY_CURRENT_BUFFER) {
1748  }
1749 }
1750 
1751 /* Allocates the stack if it does not exist.
1752  * Guarantees space for at least one push.
1753  */
1754 static void yyensure_buffer_stack (void)
1755 {
1756  yy_size_t num_to_alloc;
1757 
1758  if (!(yy_buffer_stack)) {
1759 
1760  /* First allocation is just for 2 elements, since we don't know if this
1761  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1762  * immediate realloc on the next call.
1763  */
1764  num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1766  (num_to_alloc * sizeof(struct yy_buffer_state*)
1767  );
1768  if ( ! (yy_buffer_stack) )
1769  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1770 
1771  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1772 
1773  (yy_buffer_stack_max) = num_to_alloc;
1774  (yy_buffer_stack_top) = 0;
1775  return;
1776  }
1777 
1778  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1779 
1780  /* Increase the buffer to prepare for a possible push. */
1781  yy_size_t grow_size = 8 /* arbitrary grow size */;
1782 
1783  num_to_alloc = (yy_buffer_stack_max) + grow_size;
1785  ((yy_buffer_stack),
1786  num_to_alloc * sizeof(struct yy_buffer_state*)
1787  );
1788  if ( ! (yy_buffer_stack) )
1789  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1790 
1791  /* zero only the new slots.*/
1792  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1793  (yy_buffer_stack_max) = num_to_alloc;
1794  }
1795 }
1796 
1804 {
1806 
1807  if ( size < 2 ||
1808  base[size-2] != YY_END_OF_BUFFER_CHAR ||
1809  base[size-1] != YY_END_OF_BUFFER_CHAR )
1810  /* They forgot to leave room for the EOB's. */
1811  return NULL;
1812 
1813  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1814  if ( ! b )
1815  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1816 
1817  b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
1818  b->yy_buf_pos = b->yy_ch_buf = base;
1819  b->yy_is_our_buffer = 0;
1820  b->yy_input_file = NULL;
1821  b->yy_n_chars = b->yy_buf_size;
1822  b->yy_is_interactive = 0;
1823  b->yy_at_bol = 1;
1824  b->yy_fill_buffer = 0;
1825  b->yy_buffer_status = YY_BUFFER_NEW;
1826 
1827  yy_switch_to_buffer( b );
1828 
1829  return b;
1830 }
1831 
1840 YY_BUFFER_STATE yy_scan_string (const char * yystr )
1841 {
1842 
1843  return yy_scan_bytes( yystr, (int) strlen(yystr) );
1844 }
1845 
1853 YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
1854 {
1856  char *buf;
1857  yy_size_t n;
1858  int i;
1859 
1860  /* Get memory for full buffer, including space for trailing EOB's. */
1861  n = (yy_size_t) (_yybytes_len + 2);
1862  buf = (char *) yyalloc( n );
1863  if ( ! buf )
1864  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1865 
1866  for ( i = 0; i < _yybytes_len; ++i )
1867  buf[i] = yybytes[i];
1868 
1869  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1870 
1871  b = yy_scan_buffer( buf, n );
1872  if ( ! b )
1873  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1874 
1875  /* It's okay to grow etc. this buffer, and we should throw it
1876  * away when we're done.
1877  */
1878  b->yy_is_our_buffer = 1;
1879 
1880  return b;
1881 }
1882 
1883 #ifndef YY_EXIT_FAILURE
1884 #define YY_EXIT_FAILURE 2
1885 #endif
1886 
1887 static void yynoreturn yy_fatal_error (const char* msg )
1888 {
1889  fprintf( stderr, "%s\n", msg );
1890  exit( YY_EXIT_FAILURE );
1891 }
1892 
1893 /* Redefine yyless() so it works in section 3 code. */
1894 
1895 #undef yyless
1896 #define yyless(n) \
1897  do \
1898  { \
1899  /* Undo effects of setting up yytext. */ \
1900  int yyless_macro_arg = (n); \
1901  YY_LESS_LINENO(yyless_macro_arg);\
1902  yytext[yyleng] = (yy_hold_char); \
1903  (yy_c_buf_p) = yytext + yyless_macro_arg; \
1904  (yy_hold_char) = *(yy_c_buf_p); \
1905  *(yy_c_buf_p) = '\0'; \
1906  yyleng = yyless_macro_arg; \
1907  } \
1908  while ( 0 )
1909 
1910 /* Accessor methods (get/set functions) to struct members. */
1911 
1915 int yyget_lineno (void)
1916 {
1917 
1918  return yylineno;
1919 }
1920 
1924 FILE *yyget_in (void)
1925 {
1926  return yyin;
1927 }
1928 
1932 FILE *yyget_out (void)
1933 {
1934  return yyout;
1935 }
1936 
1940 int yyget_leng (void)
1941 {
1942  return yyleng;
1943 }
1944 
1949 char *yyget_text (void)
1950 {
1951  return yytext;
1952 }
1953 
1958 void yyset_lineno (int _line_number )
1959 {
1960 
1961  yylineno = _line_number;
1962 }
1963 
1970 void yyset_in (FILE * _in_str )
1971 {
1972  yyin = _in_str ;
1973 }
1974 
1975 void yyset_out (FILE * _out_str )
1976 {
1977  yyout = _out_str ;
1978 }
1979 
1980 int yyget_debug (void)
1981 {
1982  return yy_flex_debug;
1983 }
1984 
1985 void yyset_debug (int _bdebug )
1986 {
1987  yy_flex_debug = _bdebug ;
1988 }
1989 
1990 static int yy_init_globals (void)
1991 {
1992  /* Initialization is the same as for the non-reentrant scanner.
1993  * This function is called from yylex_destroy(), so don't allocate here.
1994  */
1995 
1996  (yy_buffer_stack) = NULL;
1997  (yy_buffer_stack_top) = 0;
1998  (yy_buffer_stack_max) = 0;
1999  (yy_c_buf_p) = NULL;
2000  (yy_init) = 0;
2001  (yy_start) = 0;
2002 
2003 /* Defined in main.c */
2004 #ifdef YY_STDINIT
2005  yyin = stdin;
2006  yyout = stdout;
2007 #else
2008  yyin = NULL;
2009  yyout = NULL;
2010 #endif
2011 
2012  /* For future reference: Set errno on error, since we are called by
2013  * yylex_init()
2014  */
2015  return 0;
2016 }
2017 
2018 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2019 int yylex_destroy (void)
2020 {
2021 
2022  /* Pop the buffer stack, destroying each element. */
2023  while(YY_CURRENT_BUFFER){
2025  YY_CURRENT_BUFFER_LVALUE = NULL;
2027  }
2028 
2029  /* Destroy the stack itself. */
2030  yyfree((yy_buffer_stack) );
2031  (yy_buffer_stack) = NULL;
2032 
2033  /* Reset the globals. This is important in a non-reentrant scanner so the next time
2034  * yylex() is called, initialization will occur. */
2035  yy_init_globals( );
2036 
2037  return 0;
2038 }
2039 
2040 /*
2041  * Internal utility routines.
2042  */
2043 
2044 #ifndef yytext_ptr
2045 static void yy_flex_strncpy (char* s1, const char * s2, int n )
2046 {
2047 
2048  int i;
2049  for ( i = 0; i < n; ++i )
2050  s1[i] = s2[i];
2051 }
2052 #endif
2053 
2054 #ifdef YY_NEED_STRLEN
2055 static int yy_flex_strlen (const char * s )
2056 {
2057  int n;
2058  for ( n = 0; s[n]; ++n )
2059  ;
2060 
2061  return n;
2062 }
2063 #endif
2064 
2065 void *yyalloc (yy_size_t size )
2066 {
2067  return malloc(size);
2068 }
2069 
2070 void *yyrealloc (void * ptr, yy_size_t size )
2071 {
2072 
2073  /* The cast to (char *) in the following accommodates both
2074  * implementations that use char* generic pointers, and those
2075  * that use void* generic pointers. It works with the latter
2076  * because both ANSI C and C++ allow castless assignment from
2077  * any pointer type to void*, and deal with argument conversions
2078  * as though doing an assignment.
2079  */
2080  return realloc(ptr, size);
2081 }
2082 
2083 void yyfree (void * ptr )
2084 {
2085  free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2086 }
2087 
2088 #define YYTABLES_NAME "yytables"
2089 
Array4< int const > offset
Definition: AMReX_HypreMLABecLap.cpp:1089
void amrex_iparsererror(char const *s,...)
Definition: AMReX_IParser_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
static const flex_int16_t yy_accept[59]
Definition: amrex_iparser.lex.nolint.H:623
#define yy_load_buffer_state
Definition: amrex_iparser.lex.nolint.H:13
#define YY_NEW_FILE
Definition: amrex_iparser.lex.nolint.H:384
#define yyset_extra
Definition: amrex_iparser.lex.nolint.H:162
#define yytext
Definition: amrex_iparser.lex.nolint.H:25
unsigned char flex_uint8_t
Definition: amrex_iparser.lex.nolint.H:310
#define yyset_lineno
Definition: amrex_iparser.lex.nolint.H:210
static char yy_hold_char
Definition: amrex_iparser.lex.nolint.H:525
static yy_state_type yy_last_accepting_state
Definition: amrex_iparser.lex.nolint.H:725
#define yyrestart
Definition: amrex_iparser.lex.nolint.H:24
#define yyset_debug
Definition: amrex_iparser.lex.nolint.H:150
static void yynoreturn yy_fatal_error(const char *msg)
#define YY_EXTRA_TYPE
Definition: amrex_iparser.lex.nolint.H:760
static int yy_start
Definition: amrex_iparser.lex.nolint.H:532
short int flex_int16_t
Definition: amrex_iparser.lex.nolint.H:308
#define yy_flex_debug
Definition: amrex_iparser.lex.nolint.H:18
#define yyget_out
Definition: amrex_iparser.lex.nolint.H:180
static YY_BUFFER_STATE * yy_buffer_stack
Definition: amrex_iparser.lex.nolint.H:508
unsigned int flex_uint32_t
Definition: amrex_iparser.lex.nolint.H:312
static int yy_get_next_buffer(void)
#define yy_scan_bytes
Definition: amrex_iparser.lex.nolint.H:10
#define YY_BREAK
Definition: amrex_iparser.lex.nolint.H:921
static const flex_int16_t yy_base[60]
Definition: amrex_iparser.lex.nolint.H:673
static size_t yy_buffer_stack_max
Definition: amrex_iparser.lex.nolint.H:507
#define yynoreturn
Definition: amrex_iparser.lex.nolint.H:359
static yy_state_type yy_try_NUL_trans(yy_state_type current_state)
#define yyget_debug
Definition: amrex_iparser.lex.nolint.H:144
int yy_act
Definition: amrex_iparser.lex.nolint.H:933
static const flex_int16_t yy_def[60]
Definition: amrex_iparser.lex.nolint.H:683
#define yypush_buffer_state
Definition: amrex_iparser.lex.nolint.H:15
struct yy_buffer_state * YY_BUFFER_STATE
Definition: amrex_iparser.lex.nolint.H:406
#define yyfree
Definition: amrex_iparser.lex.nolint.H:29
#define yyout
Definition: amrex_iparser.lex.nolint.H:23
#define YY_BUFFER_NEW
Definition: amrex_iparser.lex.nolint.H:488
#define yyget_lineno
Definition: amrex_iparser.lex.nolint.H:204
#define yylex
Definition: amrex_iparser.lex.nolint.H:21
#define YY_RESTORE_YY_MORE_OFFSET
Definition: amrex_iparser.lex.nolint.H:737
static int yy_did_buffer_switch_on_eof
Definition: amrex_iparser.lex.nolint.H:537
static int yy_init_globals(void)
#define yywrap
Definition: amrex_iparser.lex.nolint.H:26
#define yyget_text
Definition: amrex_iparser.lex.nolint.H:198
#define YY_BUFFER_NORMAL
Definition: amrex_iparser.lex.nolint.H:489
char * yy_cp
Definition: amrex_iparser.lex.nolint.H:932
#define yyensure_buffer_stack
Definition: amrex_iparser.lex.nolint.H:17
static const YY_CHAR yy_meta[34]
Definition: amrex_iparser.lex.nolint.H:665
#define yy_scan_buffer
Definition: amrex_iparser.lex.nolint.H:8
#define YY_MORE_ADJ
Definition: amrex_iparser.lex.nolint.H:736
#define YY_RULE_SETUP
Definition: amrex_iparser.lex.nolint.H:924
#define yy_scan_string
Definition: amrex_iparser.lex.nolint.H:9
#define yytext_ptr
Definition: amrex_iparser.lex.nolint.H:598
signed char flex_int8_t
Definition: amrex_iparser.lex.nolint.H:307
#define yyget_leng
Definition: amrex_iparser.lex.nolint.H:192
#define EOB_ACT_END_OF_FILE
Definition: amrex_iparser.lex.nolint.H:419
#define yyalloc
Definition: amrex_iparser.lex.nolint.H:27
#define yypop_buffer_state
Definition: amrex_iparser.lex.nolint.H:16
#define YY_CURRENT_BUFFER_LVALUE
Definition: amrex_iparser.lex.nolint.H:522
int flex_int32_t
Definition: amrex_iparser.lex.nolint.H:309
#define yylex_destroy
Definition: amrex_iparser.lex.nolint.H:138
static const flex_int16_t yy_nxt[111]
Definition: amrex_iparser.lex.nolint.H:693
#define YY_START
Definition: amrex_iparser.lex.nolint.H:379
#define yy_switch_to_buffer
Definition: amrex_iparser.lex.nolint.H:14
static const flex_int16_t yy_chk[111]
Definition: amrex_iparser.lex.nolint.H:709
int yy_state_type
Definition: amrex_iparser.lex.nolint.H:589
#define YY_CURRENT_BUFFER
Definition: amrex_iparser.lex.nolint.H:516
#define yy_init_buffer
Definition: amrex_iparser.lex.nolint.H:11
#define INITIAL
Definition: amrex_iparser.lex.nolint.H:749
#define yyget_extra
Definition: amrex_iparser.lex.nolint.H:156
char * yy_bp
Definition: amrex_iparser.lex.nolint.H:932
#define yyin
Definition: amrex_iparser.lex.nolint.H:19
static int yy_n_chars
Definition: amrex_iparser.lex.nolint.H:526
#define YY_READ_BUF_SIZE
Definition: amrex_iparser.lex.nolint.H:833
#define YY_INPUT(buf, result, max_size)
Definition: amrex_iparser.lex.nolint.H:849
#define yy_flush_buffer
Definition: amrex_iparser.lex.nolint.H:12
#define yyrealloc
Definition: amrex_iparser.lex.nolint.H:28
#define YY_END_OF_BUFFER
Definition: amrex_iparser.lex.nolint.H:615
#define YY_STATE_EOF(state)
Definition: amrex_iparser.lex.nolint.H:382
#define YY_END_OF_BUFFER_CHAR
Definition: amrex_iparser.lex.nolint.H:385
#define YY_FATAL_ERROR(msg)
Definition: amrex_iparser.lex.nolint.H:896
#define yyterminate()
Definition: amrex_iparser.lex.nolint.H:886
unsigned short int flex_uint16_t
Definition: amrex_iparser.lex.nolint.H:311
#define yy_create_buffer
Definition: amrex_iparser.lex.nolint.H:6
flex_uint8_t YY_CHAR
Definition: amrex_iparser.lex.nolint.H:585
#define YY_DO_BEFORE_ACTION
Definition: amrex_iparser.lex.nolint.H:608
#define yy_delete_buffer
Definition: amrex_iparser.lex.nolint.H:7
#define EOB_ACT_LAST_MATCH
Definition: amrex_iparser.lex.nolint.H:420
#define yyget_in
Definition: amrex_iparser.lex.nolint.H:168
size_t yy_size_t
Definition: amrex_iparser.lex.nolint.H:411
#define YY_BUFFER_EOF_PENDING
Definition: amrex_iparser.lex.nolint.H:500
#define yylineno
Definition: amrex_iparser.lex.nolint.H:22
static yy_state_type yy_get_previous_state(void)
static const YY_CHAR yy_ec[256]
Definition: amrex_iparser.lex.nolint.H:633
#define yyset_out
Definition: amrex_iparser.lex.nolint.H:186
static char * yy_c_buf_p
Definition: amrex_iparser.lex.nolint.H:530
#define EOB_ACT_CONTINUE_SCAN
Definition: amrex_iparser.lex.nolint.H:418
static size_t yy_buffer_stack_top
Definition: amrex_iparser.lex.nolint.H:506
#define YY_DECL
Definition: amrex_iparser.lex.nolint.H:909
#define YY_BUF_SIZE
Definition: amrex_iparser.lex.nolint.H:396
#define YY_EXIT_FAILURE
static int yy_init
Definition: amrex_iparser.lex.nolint.H:531
#define YY_SC_TO_UI(c)
Definition: amrex_iparser.lex.nolint.H:368
#define yyleng
Definition: amrex_iparser.lex.nolint.H:20
static char * yy_last_accepting_cpos
Definition: amrex_iparser.lex.nolint.H:726
#define yyset_in
Definition: amrex_iparser.lex.nolint.H:174
AMREX_IPARSERSTYPE amrex_iparserlval
@ 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
@ FLRDIV
Definition: amrex_iparser.tab.h:72
@ 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 *)
AMREX_GPU_HOST_DEVICE Long size(T const &b) noexcept
integer version
Definition: AMReX_GpuRange.H:26
long long iparser_atoll(const char *str)
Definition: AMReX_IParser_Y.cpp:1431
@ IPARSER_ABS
Definition: AMReX_IParser_Y.H:23
@ IPARSER_POW
Definition: AMReX_IParser_Y.H:28
@ IPARSER_FLRDIV
Definition: AMReX_IParser_Y.H:27
@ IPARSER_AND
Definition: AMReX_IParser_Y.H:35
@ IPARSER_OR
Definition: AMReX_IParser_Y.H:36
@ IPARSER_MAX
Definition: AMReX_IParser_Y.H:38
@ IPARSER_EQ
Definition: AMReX_IParser_Y.H:33
@ IPARSER_MIN
Definition: AMReX_IParser_Y.H:37
@ IPARSER_GEQ
Definition: AMReX_IParser_Y.H:31
@ IPARSER_LEQ
Definition: AMReX_IParser_Y.H:32
@ IPARSER_NEQ
Definition: AMReX_IParser_Y.H:34
struct iparser_symbol * iparser_makesymbol(char *name)
Definition: AMReX_IParser_Y.cpp:34
const int[]
Definition: AMReX_BLProfiler.cpp:1664
@ IPARSER_IF
Definition: AMReX_IParser_Y.H:42
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
enum amrex::iparser_f3_t f3
Definition: amrex_iparser.tab.h:96
struct amrex::iparser_symbol * s
Definition: amrex_iparser.tab.h:93
enum amrex::iparser_f1_t f1
Definition: amrex_iparser.tab.h:94
enum amrex::iparser_f2_t f2
Definition: amrex_iparser.tab.h:95
long long d
Definition: amrex_iparser.tab.h:92