Block-Structured AMR Software Framework
 
Loading...
Searching...
No Matches
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>
300typedef int8_t flex_int8_t;
301typedef uint8_t flex_uint8_t;
302typedef int16_t flex_int16_t;
303typedef uint16_t flex_uint16_t;
304typedef int32_t flex_int32_t;
305typedef uint32_t flex_uint32_t;
306#else
307typedef signed char flex_int8_t;
308typedef short int flex_int16_t;
309typedef int flex_int32_t;
310typedef unsigned char flex_uint8_t;
311typedef unsigned short int flex_uint16_t;
312typedef 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
411typedef size_t yy_size_t;
412#endif
413
414extern int yyleng;
415
416extern 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
442struct 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 */
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 */
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
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. */
506static size_t yy_buffer_stack_top = 0;
507static 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. */
525static char yy_hold_char;
526static int yy_n_chars; /* number of characters read into yy_ch_buf */
528
529/* Points to current character in buffer. */
530static char *yy_c_buf_p = NULL;
531static int yy_init = 0; /* whether we need to initialize */
532static 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
539void yyrestart ( FILE *input_file );
541YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
545void yypop_buffer_state ( void );
546
547static void yyensure_buffer_stack ( void );
548static void yy_load_buffer_state ( void );
549static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
550#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
551
553YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
554YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
555
557void *yyrealloc ( void *, yy_size_t );
558void 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
587FILE *yyin = NULL, *yyout = NULL;
588
589typedef int yy_state_type;
590
591extern int yylineno;
592int yylineno = 1;
593
594extern char *yytext;
595#ifdef yytext_ptr
596#undef yytext_ptr
597#endif
598#define yytext_ptr yytext
599
602static int yy_get_next_buffer ( void );
603static 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. */
618struct yy_trans_info
619 {
622 };
623static 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
642static 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
674static 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
683static 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
702static 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
721static 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
753static 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
788extern 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
798char *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
823static int yy_init_globals ( void );
824
825/* Accessor methods to globals.
826 These are made visible to non-reentrant scanners for convenience. */
827
828int yylex_destroy ( void );
829
830int yyget_debug ( void );
831
832void yyset_debug ( int debug_flag );
833
835
836void yyset_extra ( YY_EXTRA_TYPE user_defined );
837
838FILE *yyget_in ( void );
839
840void yyset_in ( FILE * _in_str );
841
842FILE *yyget_out ( void );
843
844void yyset_out ( FILE * _out_str );
845
846 int yyget_leng ( void );
847
848char *yyget_text ( void );
849
850int yyget_lineno ( void );
851
852void 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
860extern "C" int yywrap ( void );
861#else
862extern int yywrap ( void );
863#endif
864#endif
865
866#ifndef YY_NO_UNPUT
867
868#endif
869
870#ifndef yytext_ptr
871static void yy_flex_strncpy ( char *, const char *, int );
872#endif
873
874#ifdef YY_NEED_STRLEN
875static int yy_flex_strlen ( const char * );
876#endif
877
878#ifndef YY_NO_INPUT
879#ifdef __cplusplus
880static int yyinput ( void );
881#else
882static 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
967extern 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;
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);
1036yy_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
1058yy_find_action:
1059 yy_act = yy_accept[yy_current_state];
1060
1062
1063do_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
1074case 1:
1075case 2:
1076case 3:
1077case 4:
1078case 5:
1079case 6:
1080case 7:
1081case 8:
1082case 9:
1083case 10:
1084case 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 */
1090case 12:
1093 YY_BREAK
1094case 13:
1097 YY_BREAK
1098case 14:
1101 YY_BREAK
1102case 15:
1105 YY_BREAK
1106case 16:
1109 YY_BREAK
1110case 17:
1113 YY_BREAK
1114case 18:
1117 YY_BREAK
1118case 19:
1121 YY_BREAK
1122case 20:
1125 YY_BREAK
1126case 21:
1129 YY_BREAK
1130case 22:
1133 YY_BREAK
1134case 23:
1137 YY_BREAK
1138case 24:
1141 YY_BREAK
1142case 25:
1145 YY_BREAK
1146case 26:
1149 YY_BREAK
1150case 27:
1153 YY_BREAK
1154case 28:
1157 YY_BREAK
1158case 29:
1161 YY_BREAK
1162case 30:
1165 YY_BREAK
1166case 31:
1169 YY_BREAK
1170case 32:
1173 YY_BREAK
1174case 33:
1177 YY_BREAK
1178case 34:
1181 YY_BREAK
1182case 35:
1185 YY_BREAK
1186case 36:
1189 YY_BREAK
1190case 37:
1193 YY_BREAK
1194case 38:
1197 YY_BREAK
1198case 39:
1201 YY_BREAK
1202case 40:
1205 YY_BREAK
1206case 41:
1209 YY_BREAK
1210case 42:
1213 YY_BREAK
1214case 43:
1217 YY_BREAK
1218case 44:
1221 YY_BREAK
1222case 45:
1225 YY_BREAK
1226case 46:
1229 YY_BREAK
1230case 47:
1233 YY_BREAK
1234case 48:
1237 YY_BREAK
1238case 49:
1241 YY_BREAK
1242case 50:
1245 YY_BREAK
1246case 51:
1249 YY_BREAK
1250/* We use SYMBOL to hold variables and constants */
1251case 52:
1253{ amrex_parserlval.s = amrex::parser_makesymbol(amrex_parsertext); return SYMBOL; }
1254 YY_BREAK
1255/* Number */
1256case 53:
1257case 54:
1259{ amrex_parserlval.d = std::atof(amrex_parsertext); return NUMBER; }
1260 YY_BREAK
1261/* Special characters */
1262case 55:
1264
1265 YY_BREAK
1266case 56:
1268/* ignore white space */
1269 YY_BREAK
1270case 57:
1271/* rule 57 can match eol */
1273/* ignore line continuation */
1274 YY_BREAK
1275case 58:
1276/* rule 58 can match eol */
1278{ return EOL; }
1279 YY_BREAK
1280/* everything else */
1281case 59:
1283{ amrex_parsererror("Unknown character %c", *amrex_parsertext); }
1284 YY_BREAK
1285case 60:
1287YY_FATAL_ERROR( "flex scanner jammed" );
1288 YY_BREAK
1289case 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 {
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 {
1388 }
1389 break;
1390 }
1391
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 */
1430static 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
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
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
1673 {
1674 if ( yywrap( ) )
1675 return 0;
1676
1679#ifdef __cplusplus
1680 return yyinput();
1681#else
1682 return input();
1683#endif
1684 }
1685
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
1754static void yy_load_buffer_state (void)
1755{
1756 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
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
1872void 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. */
1891 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1892
1893 /* copied from yy_switch_to_buffer. */
1896}
1897
1902void yypop_buffer_state (void)
1903{
1904 if (!YY_CURRENT_BUFFER)
1905 return;
1906
1909 if ((yy_buffer_stack_top) > 0)
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 */
1921static 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
1970YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
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
1995
1996 return b;
1997}
1998
2007YY_BUFFER_STATE yy_scan_string (const char * yystr )
2008{
2009
2010 return yy_scan_bytes( yystr, (int) strlen(yystr) );
2011}
2012
2020YY_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
2054static 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
2082int yyget_lineno (void)
2083{
2084
2085 return yylineno;
2086}
2087
2091FILE *yyget_in (void)
2092{
2093 return yyin;
2094}
2095
2099FILE *yyget_out (void)
2100{
2101 return yyout;
2102}
2103
2107int yyget_leng (void)
2108{
2109 return yyleng;
2110}
2111
2116char *yyget_text (void)
2117{
2118 return yytext;
2119}
2120
2125void yyset_lineno (int _line_number )
2126{
2127
2128 yylineno = _line_number;
2129}
2130
2137void yyset_in (FILE * _in_str )
2138{
2139 yyin = _in_str ;
2140}
2141
2142void yyset_out (FILE * _out_str )
2143{
2144 yyout = _out_str ;
2145}
2146
2147int yyget_debug (void)
2148{
2149 return yy_flex_debug;
2150}
2151
2152void yyset_debug (int _bdebug )
2153{
2154 yy_flex_debug = _bdebug ;
2155}
2156
2157static 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. */
2186int yylex_destroy (void)
2187{
2188
2189 /* Pop the buffer stack, destroying each element. */
2190 while(YY_CURRENT_BUFFER){
2194 }
2195
2196 /* Destroy the stack itself. */
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
2212static 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
2222static 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
2232void *yyalloc (yy_size_t size )
2233{
2234 return malloc(size);
2235}
2236
2237void *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
2250void 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