Line data Source code
1 : #line 2 "omp_exprparser_lexer.cc"
2 :
3 : #line 4 "omp_exprparser_lexer.cc"
4 :
5 : #define YY_INT_ALIGNED short int
6 :
7 : /* A lexical scanner generated by flex */
8 :
9 : #define yy_create_buffer omp_exprparser__create_buffer
10 : #define yy_delete_buffer omp_exprparser__delete_buffer
11 : #define yy_scan_buffer omp_exprparser__scan_buffer
12 : #define yy_scan_string omp_exprparser__scan_string
13 : #define yy_scan_bytes omp_exprparser__scan_bytes
14 : #define yy_init_buffer omp_exprparser__init_buffer
15 : #define yy_flush_buffer omp_exprparser__flush_buffer
16 : #define yy_load_buffer_state omp_exprparser__load_buffer_state
17 : #define yy_switch_to_buffer omp_exprparser__switch_to_buffer
18 : #define yypush_buffer_state omp_exprparser_push_buffer_state
19 : #define yypop_buffer_state omp_exprparser_pop_buffer_state
20 : #define yyensure_buffer_stack omp_exprparser_ensure_buffer_stack
21 : #define yy_flex_debug omp_exprparser__flex_debug
22 : #define yyin omp_exprparser_in
23 : #define yyleng omp_exprparser_leng
24 : #define yylex omp_exprparser_lex
25 : #define yylineno omp_exprparser_lineno
26 : #define yyout omp_exprparser_out
27 : #define yyrestart omp_exprparser_restart
28 : #define yytext omp_exprparser_text
29 : #define yywrap omp_exprparser_wrap
30 : #define yyalloc omp_exprparser_alloc
31 : #define yyrealloc omp_exprparser_realloc
32 : #define yyfree omp_exprparser_free
33 :
34 : #define FLEX_SCANNER
35 : #define YY_FLEX_MAJOR_VERSION 2
36 : #define YY_FLEX_MINOR_VERSION 6
37 : #define YY_FLEX_SUBMINOR_VERSION 4
38 : #if YY_FLEX_SUBMINOR_VERSION > 0
39 : #define FLEX_BETA
40 : #endif
41 :
42 : #ifdef yy_create_buffer
43 : #define omp_exprparser__create_buffer_ALREADY_DEFINED
44 : #else
45 : #define yy_create_buffer omp_exprparser__create_buffer
46 : #endif
47 :
48 : #ifdef yy_delete_buffer
49 : #define omp_exprparser__delete_buffer_ALREADY_DEFINED
50 : #else
51 : #define yy_delete_buffer omp_exprparser__delete_buffer
52 : #endif
53 :
54 : #ifdef yy_scan_buffer
55 : #define omp_exprparser__scan_buffer_ALREADY_DEFINED
56 : #else
57 : #define yy_scan_buffer omp_exprparser__scan_buffer
58 : #endif
59 :
60 : #ifdef yy_scan_string
61 : #define omp_exprparser__scan_string_ALREADY_DEFINED
62 : #else
63 : #define yy_scan_string omp_exprparser__scan_string
64 : #endif
65 :
66 : #ifdef yy_scan_bytes
67 : #define omp_exprparser__scan_bytes_ALREADY_DEFINED
68 : #else
69 : #define yy_scan_bytes omp_exprparser__scan_bytes
70 : #endif
71 :
72 : #ifdef yy_init_buffer
73 : #define omp_exprparser__init_buffer_ALREADY_DEFINED
74 : #else
75 : #define yy_init_buffer omp_exprparser__init_buffer
76 : #endif
77 :
78 : #ifdef yy_flush_buffer
79 : #define omp_exprparser__flush_buffer_ALREADY_DEFINED
80 : #else
81 : #define yy_flush_buffer omp_exprparser__flush_buffer
82 : #endif
83 :
84 : #ifdef yy_load_buffer_state
85 : #define omp_exprparser__load_buffer_state_ALREADY_DEFINED
86 : #else
87 : #define yy_load_buffer_state omp_exprparser__load_buffer_state
88 : #endif
89 :
90 : #ifdef yy_switch_to_buffer
91 : #define omp_exprparser__switch_to_buffer_ALREADY_DEFINED
92 : #else
93 : #define yy_switch_to_buffer omp_exprparser__switch_to_buffer
94 : #endif
95 :
96 : #ifdef yypush_buffer_state
97 : #define omp_exprparser_push_buffer_state_ALREADY_DEFINED
98 : #else
99 : #define yypush_buffer_state omp_exprparser_push_buffer_state
100 : #endif
101 :
102 : #ifdef yypop_buffer_state
103 : #define omp_exprparser_pop_buffer_state_ALREADY_DEFINED
104 : #else
105 : #define yypop_buffer_state omp_exprparser_pop_buffer_state
106 : #endif
107 :
108 : #ifdef yyensure_buffer_stack
109 : #define omp_exprparser_ensure_buffer_stack_ALREADY_DEFINED
110 : #else
111 : #define yyensure_buffer_stack omp_exprparser_ensure_buffer_stack
112 : #endif
113 :
114 : #ifdef yylex
115 : #define omp_exprparser_lex_ALREADY_DEFINED
116 : #else
117 : #define yylex omp_exprparser_lex
118 : #endif
119 :
120 : #ifdef yyrestart
121 : #define omp_exprparser_restart_ALREADY_DEFINED
122 : #else
123 : #define yyrestart omp_exprparser_restart
124 : #endif
125 :
126 : #ifdef yylex_init
127 : #define omp_exprparser_lex_init_ALREADY_DEFINED
128 : #else
129 : #define yylex_init omp_exprparser_lex_init
130 : #endif
131 :
132 : #ifdef yylex_init_extra
133 : #define omp_exprparser_lex_init_extra_ALREADY_DEFINED
134 : #else
135 : #define yylex_init_extra omp_exprparser_lex_init_extra
136 : #endif
137 :
138 : #ifdef yylex_destroy
139 : #define omp_exprparser_lex_destroy_ALREADY_DEFINED
140 : #else
141 : #define yylex_destroy omp_exprparser_lex_destroy
142 : #endif
143 :
144 : #ifdef yyget_debug
145 : #define omp_exprparser_get_debug_ALREADY_DEFINED
146 : #else
147 : #define yyget_debug omp_exprparser_get_debug
148 : #endif
149 :
150 : #ifdef yyset_debug
151 : #define omp_exprparser_set_debug_ALREADY_DEFINED
152 : #else
153 : #define yyset_debug omp_exprparser_set_debug
154 : #endif
155 :
156 : #ifdef yyget_extra
157 : #define omp_exprparser_get_extra_ALREADY_DEFINED
158 : #else
159 : #define yyget_extra omp_exprparser_get_extra
160 : #endif
161 :
162 : #ifdef yyset_extra
163 : #define omp_exprparser_set_extra_ALREADY_DEFINED
164 : #else
165 : #define yyset_extra omp_exprparser_set_extra
166 : #endif
167 :
168 : #ifdef yyget_in
169 : #define omp_exprparser_get_in_ALREADY_DEFINED
170 : #else
171 : #define yyget_in omp_exprparser_get_in
172 : #endif
173 :
174 : #ifdef yyset_in
175 : #define omp_exprparser_set_in_ALREADY_DEFINED
176 : #else
177 : #define yyset_in omp_exprparser_set_in
178 : #endif
179 :
180 : #ifdef yyget_out
181 : #define omp_exprparser_get_out_ALREADY_DEFINED
182 : #else
183 : #define yyget_out omp_exprparser_get_out
184 : #endif
185 :
186 : #ifdef yyset_out
187 : #define omp_exprparser_set_out_ALREADY_DEFINED
188 : #else
189 : #define yyset_out omp_exprparser_set_out
190 : #endif
191 :
192 : #ifdef yyget_leng
193 : #define omp_exprparser_get_leng_ALREADY_DEFINED
194 : #else
195 : #define yyget_leng omp_exprparser_get_leng
196 : #endif
197 :
198 : #ifdef yyget_text
199 : #define omp_exprparser_get_text_ALREADY_DEFINED
200 : #else
201 : #define yyget_text omp_exprparser_get_text
202 : #endif
203 :
204 : #ifdef yyget_lineno
205 : #define omp_exprparser_get_lineno_ALREADY_DEFINED
206 : #else
207 : #define yyget_lineno omp_exprparser_get_lineno
208 : #endif
209 :
210 : #ifdef yyset_lineno
211 : #define omp_exprparser_set_lineno_ALREADY_DEFINED
212 : #else
213 : #define yyset_lineno omp_exprparser_set_lineno
214 : #endif
215 :
216 : #ifdef yywrap
217 : #define omp_exprparser_wrap_ALREADY_DEFINED
218 : #else
219 : #define yywrap omp_exprparser_wrap
220 : #endif
221 :
222 : #ifdef yyalloc
223 : #define omp_exprparser_alloc_ALREADY_DEFINED
224 : #else
225 : #define yyalloc omp_exprparser_alloc
226 : #endif
227 :
228 : #ifdef yyrealloc
229 : #define omp_exprparser_realloc_ALREADY_DEFINED
230 : #else
231 : #define yyrealloc omp_exprparser_realloc
232 : #endif
233 :
234 : #ifdef yyfree
235 : #define omp_exprparser_free_ALREADY_DEFINED
236 : #else
237 : #define yyfree omp_exprparser_free
238 : #endif
239 :
240 : #ifdef yytext
241 : #define omp_exprparser_text_ALREADY_DEFINED
242 : #else
243 : #define yytext omp_exprparser_text
244 : #endif
245 :
246 : #ifdef yyleng
247 : #define omp_exprparser_leng_ALREADY_DEFINED
248 : #else
249 : #define yyleng omp_exprparser_leng
250 : #endif
251 :
252 : #ifdef yyin
253 : #define omp_exprparser_in_ALREADY_DEFINED
254 : #else
255 : #define yyin omp_exprparser_in
256 : #endif
257 :
258 : #ifdef yyout
259 : #define omp_exprparser_out_ALREADY_DEFINED
260 : #else
261 : #define yyout omp_exprparser_out
262 : #endif
263 :
264 : #ifdef yy_flex_debug
265 : #define omp_exprparser__flex_debug_ALREADY_DEFINED
266 : #else
267 : #define yy_flex_debug omp_exprparser__flex_debug
268 : #endif
269 :
270 : #ifdef yylineno
271 : #define omp_exprparser_lineno_ALREADY_DEFINED
272 : #else
273 : #define yylineno omp_exprparser_lineno
274 : #endif
275 :
276 : /* First, we deal with platform-specific or compiler-specific issues. */
277 :
278 : /* begin standard C headers. */
279 : #include <stdio.h>
280 : #include <string.h>
281 : #include <errno.h>
282 : #include <stdlib.h>
283 :
284 : /* end standard C headers. */
285 :
286 : /* flex integer type definitions */
287 :
288 : #ifndef FLEXINT_H
289 : #define FLEXINT_H
290 :
291 : /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
292 :
293 : #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
294 :
295 : /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
296 : * if you want the limit (max/min) macros for int types.
297 : */
298 : #ifndef __STDC_LIMIT_MACROS
299 : #define __STDC_LIMIT_MACROS 1
300 : #endif
301 :
302 : #include <inttypes.h>
303 : typedef int8_t flex_int8_t;
304 : typedef uint8_t flex_uint8_t;
305 : typedef int16_t flex_int16_t;
306 : typedef uint16_t flex_uint16_t;
307 : typedef int32_t flex_int32_t;
308 : typedef uint32_t flex_uint32_t;
309 : #else
310 : typedef signed char flex_int8_t;
311 : typedef short int flex_int16_t;
312 : typedef int flex_int32_t;
313 : typedef unsigned char flex_uint8_t;
314 : typedef unsigned short int flex_uint16_t;
315 : typedef unsigned int flex_uint32_t;
316 :
317 : /* Limits of integral types. */
318 : #ifndef INT8_MIN
319 : #define INT8_MIN (-128)
320 : #endif
321 : #ifndef INT16_MIN
322 : #define INT16_MIN (-32767-1)
323 : #endif
324 : #ifndef INT32_MIN
325 : #define INT32_MIN (-2147483647-1)
326 : #endif
327 : #ifndef INT8_MAX
328 : #define INT8_MAX (127)
329 : #endif
330 : #ifndef INT16_MAX
331 : #define INT16_MAX (32767)
332 : #endif
333 : #ifndef INT32_MAX
334 : #define INT32_MAX (2147483647)
335 : #endif
336 : #ifndef UINT8_MAX
337 : #define UINT8_MAX (255U)
338 : #endif
339 : #ifndef UINT16_MAX
340 : #define UINT16_MAX (65535U)
341 : #endif
342 : #ifndef UINT32_MAX
343 : #define UINT32_MAX (4294967295U)
344 : #endif
345 :
346 : #ifndef SIZE_MAX
347 : #define SIZE_MAX (~(size_t)0)
348 : #endif
349 :
350 : #endif /* ! C99 */
351 :
352 : #endif /* ! FLEXINT_H */
353 :
354 : /* begin standard C++ headers. */
355 :
356 : /* TODO: this is always defined, so inline it */
357 : #define yyconst const
358 :
359 : #if defined(__GNUC__) && __GNUC__ >= 3
360 : #define yynoreturn __attribute__((__noreturn__))
361 : #else
362 : #define yynoreturn
363 : #endif
364 :
365 : /* Returned upon end-of-file. */
366 : #define YY_NULL 0
367 :
368 : /* Promotes a possibly negative, possibly signed char to an
369 : * integer in range [0..255] for use as an array index.
370 : */
371 : #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
372 :
373 : /* Enter a start condition. This macro really ought to take a parameter,
374 : * but we do it the disgusting crufty way forced on us by the ()-less
375 : * definition of BEGIN.
376 : */
377 : #define BEGIN (yy_start) = 1 + 2 *
378 : /* Translate the current start state into a value that can be later handed
379 : * to BEGIN to return to the state. The YYSTATE alias is for lex
380 : * compatibility.
381 : */
382 : #define YY_START (((yy_start) - 1) / 2)
383 : #define YYSTATE YY_START
384 : /* Action number for EOF rule of a given start state. */
385 : #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
386 : /* Special action meaning "start processing a new file". */
387 : #define YY_NEW_FILE yyrestart( yyin )
388 : #define YY_END_OF_BUFFER_CHAR 0
389 :
390 : /* Size of default input buffer. */
391 : #ifndef YY_BUF_SIZE
392 : #ifdef __ia64__
393 : /* On IA-64, the buffer size is 16k, not 8k.
394 : * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
395 : * Ditto for the __ia64__ case accordingly.
396 : */
397 : #define YY_BUF_SIZE 32768
398 : #else
399 : #define YY_BUF_SIZE 16384
400 : #endif /* __ia64__ */
401 : #endif
402 :
403 : /* The state buf must be large enough to hold one state per character in the main buffer.
404 : */
405 : #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
406 :
407 : #ifndef YY_TYPEDEF_YY_BUFFER_STATE
408 : #define YY_TYPEDEF_YY_BUFFER_STATE
409 : typedef struct yy_buffer_state *YY_BUFFER_STATE;
410 : #endif
411 :
412 : #ifndef YY_TYPEDEF_YY_SIZE_T
413 : #define YY_TYPEDEF_YY_SIZE_T
414 : typedef size_t yy_size_t;
415 : #endif
416 :
417 : extern int yyleng;
418 :
419 : extern FILE *yyin, *yyout;
420 :
421 : #define EOB_ACT_CONTINUE_SCAN 0
422 : #define EOB_ACT_END_OF_FILE 1
423 : #define EOB_ACT_LAST_MATCH 2
424 :
425 : #define YY_LESS_LINENO(n)
426 : #define YY_LINENO_REWIND_TO(ptr)
427 :
428 : /* Return all but the first "n" matched characters back to the input stream. */
429 : #define yyless(n) \
430 : do \
431 : { \
432 : /* Undo effects of setting up yytext. */ \
433 : int yyless_macro_arg = (n); \
434 : YY_LESS_LINENO(yyless_macro_arg);\
435 : *yy_cp = (yy_hold_char); \
436 : YY_RESTORE_YY_MORE_OFFSET \
437 : (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
438 : YY_DO_BEFORE_ACTION; /* set up yytext again */ \
439 : } \
440 : while ( 0 )
441 : #define unput(c) yyunput( c, (yytext_ptr) )
442 :
443 : #ifndef YY_STRUCT_YY_BUFFER_STATE
444 : #define YY_STRUCT_YY_BUFFER_STATE
445 : struct yy_buffer_state
446 : {
447 : FILE *yy_input_file;
448 :
449 : char *yy_ch_buf; /* input buffer */
450 : char *yy_buf_pos; /* current position in input buffer */
451 :
452 : /* Size of input buffer in bytes, not including room for EOB
453 : * characters.
454 : */
455 : int yy_buf_size;
456 :
457 : /* Number of characters read into yy_ch_buf, not including EOB
458 : * characters.
459 : */
460 : int yy_n_chars;
461 :
462 : /* Whether we "own" the buffer - i.e., we know we created it,
463 : * and can realloc() it to grow it, and should free() it to
464 : * delete it.
465 : */
466 : int yy_is_our_buffer;
467 :
468 : /* Whether this is an "interactive" input source; if so, and
469 : * if we're using stdio for input, then we want to use getc()
470 : * instead of fread(), to make sure we stop fetching input after
471 : * each newline.
472 : */
473 : int yy_is_interactive;
474 :
475 : /* Whether we're considered to be at the beginning of a line.
476 : * If so, '^' rules will be active on the next match, otherwise
477 : * not.
478 : */
479 : int yy_at_bol;
480 :
481 : int yy_bs_lineno; /**< The line count. */
482 : int yy_bs_column; /**< The column count. */
483 :
484 : /* Whether to try to fill the input buffer when we reach the
485 : * end of it.
486 : */
487 : int yy_fill_buffer;
488 :
489 : int yy_buffer_status;
490 :
491 : #define YY_BUFFER_NEW 0
492 : #define YY_BUFFER_NORMAL 1
493 : /* When an EOF's been seen but there's still some text to process
494 : * then we mark the buffer as YY_EOF_PENDING, to indicate that we
495 : * shouldn't try reading from the input source any more. We might
496 : * still have a bunch of tokens to match, though, because of
497 : * possible backing-up.
498 : *
499 : * When we actually see the EOF, we change the status to "new"
500 : * (via yyrestart()), so that the user can continue scanning by
501 : * just pointing yyin at a new input file.
502 : */
503 : #define YY_BUFFER_EOF_PENDING 2
504 :
505 : };
506 : #endif /* !YY_STRUCT_YY_BUFFER_STATE */
507 :
508 : /* Stack of input buffers. */
509 : static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
510 : static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
511 : static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
512 :
513 : /* We provide macros for accessing buffer states in case in the
514 : * future we want to put the buffer states in a more general
515 : * "scanner state".
516 : *
517 : * Returns the top of the stack, or NULL.
518 : */
519 : #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
520 : ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
521 : : NULL)
522 : /* Same as previous macro, but useful when we know that the buffer stack is not
523 : * NULL or when we need an lvalue. For internal use only.
524 : */
525 : #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
526 :
527 : /* yy_hold_char holds the character lost when yytext is formed. */
528 : static char yy_hold_char;
529 : static int yy_n_chars; /* number of characters read into yy_ch_buf */
530 : int yyleng;
531 :
532 : /* Points to current character in buffer. */
533 : static char *yy_c_buf_p = NULL;
534 : static int yy_init = 0; /* whether we need to initialize */
535 : static int yy_start = 0; /* start state number */
536 :
537 : /* Flag which is used to allow yywrap()'s to do buffer switches
538 : * instead of setting up a fresh yyin. A bit of a hack ...
539 : */
540 : static int yy_did_buffer_switch_on_eof;
541 :
542 : void yyrestart ( FILE *input_file );
543 : void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
544 : YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
545 : void yy_delete_buffer ( YY_BUFFER_STATE b );
546 : void yy_flush_buffer ( YY_BUFFER_STATE b );
547 : void yypush_buffer_state ( YY_BUFFER_STATE new_buffer );
548 : void yypop_buffer_state ( void );
549 :
550 : static void yyensure_buffer_stack ( void );
551 : static void yy_load_buffer_state ( void );
552 : static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
553 : #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
554 :
555 : YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size );
556 : YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
557 : YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
558 :
559 : void *yyalloc ( yy_size_t );
560 : void *yyrealloc ( void *, yy_size_t );
561 : void yyfree ( void * );
562 :
563 : #define yy_new_buffer yy_create_buffer
564 : #define yy_set_interactive(is_interactive) \
565 : { \
566 : if ( ! YY_CURRENT_BUFFER ){ \
567 : yyensure_buffer_stack (); \
568 : YY_CURRENT_BUFFER_LVALUE = \
569 : yy_create_buffer( yyin, YY_BUF_SIZE ); \
570 : } \
571 : YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
572 : }
573 : #define yy_set_bol(at_bol) \
574 : { \
575 : if ( ! YY_CURRENT_BUFFER ){\
576 : yyensure_buffer_stack (); \
577 : YY_CURRENT_BUFFER_LVALUE = \
578 : yy_create_buffer( yyin, YY_BUF_SIZE ); \
579 : } \
580 : YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
581 : }
582 : #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
583 :
584 : /* Begin user sect3 */
585 : typedef flex_uint8_t YY_CHAR;
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 :
600 : static yy_state_type yy_get_previous_state ( void );
601 : static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
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 50
615 : #define YY_END_OF_BUFFER 51
616 : /* This struct is not used in this scanner,
617 : but its presence is necessary. */
618 : struct yy_trans_info
619 : {
620 : flex_int32_t yy_verify;
621 : flex_int32_t yy_nxt;
622 : };
623 : static const flex_int16_t yy_acclist[148] =
624 : { 0,
625 : 48, 48, 51, 49, 50, 41, 50, 48, 49, 50,
626 : 49, 50, 49, 50, 13, 49, 50, 3, 49, 50,
627 : 4, 49, 50, 10, 49, 50, 9, 49, 50, 7,
628 : 49, 50, 12, 49, 50, 40, 49, 50, 11, 49,
629 : 50, 1, 49, 50, 8, 49, 50, 32, 49, 50,
630 : 2, 49, 50, 33, 49, 50, 46, 49, 50, 5,
631 : 49, 50, 38, 49, 50, 6, 49, 50, 14, 49,
632 : 50, 46, 49, 50, 46, 49, 50, 46, 49, 50,
633 : 46, 49, 50, 15, 49, 50, 48, 37, 28, 16,
634 : 29, 26, 20, 24, 21, 25, 39, 27, 1, 18,
635 :
636 : 34, 36, 35, 19, 46, 30, 46, 46, 46, 46,
637 : 31, 17,16431, 23, 22, 46, 46, 46, 46, 8239,
638 : 8239, 46, 42, 46, 46, 46, 46, 46, 46, 46,
639 : 46, 46, 46, 46, 43, 46, 46, 46, 46, 46,
640 : 46, 44, 46, 46, 46, 45, 46
641 : } ;
642 :
643 : static const flex_int16_t yy_accept[94] =
644 : { 0,
645 : 1, 2, 3, 4, 6, 8, 11, 13, 15, 18,
646 : 21, 24, 27, 30, 33, 36, 39, 42, 45, 48,
647 : 51, 54, 57, 60, 63, 66, 69, 72, 75, 78,
648 : 81, 84, 87, 88, 89, 90, 91, 92, 93, 94,
649 : 95, 96, 97, 98, 99, 99, 100, 101, 102, 103,
650 : 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
651 : 114, 114, 115, 116, 117, 118, 119, 120, 121, 122,
652 : 123, 125, 126, 127, 128, 129, 130, 131, 132, 133,
653 : 134, 135, 137, 138, 139, 140, 141, 142, 144, 145,
654 : 146, 148, 148
655 :
656 : } ;
657 :
658 : static const YY_CHAR yy_ec[256] =
659 : { 0,
660 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
661 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
662 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
663 : 1, 3, 4, 1, 1, 1, 5, 6, 1, 7,
664 : 8, 9, 10, 11, 12, 13, 14, 15, 15, 15,
665 : 15, 15, 15, 15, 15, 15, 15, 16, 1, 17,
666 : 18, 19, 1, 1, 20, 20, 20, 20, 20, 20,
667 : 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
668 : 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
669 : 21, 22, 23, 24, 25, 1, 26, 20, 27, 28,
670 :
671 : 29, 30, 20, 20, 31, 20, 20, 32, 20, 33,
672 : 34, 35, 20, 36, 37, 38, 20, 39, 20, 40,
673 : 41, 20, 1, 42, 1, 1, 1, 1, 1, 1,
674 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
675 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
676 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
677 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
678 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
679 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
680 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
681 :
682 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
683 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
684 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
685 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
686 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
687 : 1, 1, 1, 1, 1
688 : } ;
689 :
690 : static const YY_CHAR yy_meta[43] =
691 : { 0,
692 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
693 : 1, 1, 1, 2, 3, 1, 1, 4, 1, 5,
694 : 1, 1, 1, 1, 5, 5, 5, 5, 5, 5,
695 : 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
696 : 5, 1
697 : } ;
698 :
699 : static const flex_int16_t yy_base[97] =
700 : { 0,
701 : 0, 0, 112, 113, 113, 108, 92, 91, 37, 113,
702 : 113, 90, 34, 113, 35, 113, 89, 91, 113, 28,
703 : 87, 30, 0, 113, 113, 113, 86, 67, 62, 73,
704 : 74, 32, 96, 113, 113, 113, 113, 113, 113, 113,
705 : 113, 113, 113, 113, 84, 82, 78, 113, 113, 113,
706 : 77, 0, 113, 58, 58, 63, 55, 113, 113, 87,
707 : 75, 113, 113, 62, 50, 49, 46, 113, 70, 31,
708 : 0, 33, 39, 44, 37, 30, 29, 35, 26, 34,
709 : 31, 0, 34, 31, 21, 22, 26, 0, 22, 18,
710 : 0, 113, 71, 74, 78, 83
711 :
712 : } ;
713 :
714 : static const flex_int16_t yy_def[97] =
715 : { 0,
716 : 92, 1, 92, 92, 92, 92, 92, 92, 92, 92,
717 : 92, 92, 92, 92, 92, 92, 93, 92, 92, 92,
718 : 92, 92, 94, 92, 92, 92, 92, 94, 94, 94,
719 : 94, 92, 92, 92, 92, 92, 92, 92, 92, 92,
720 : 92, 92, 92, 92, 95, 92, 92, 92, 92, 92,
721 : 92, 94, 92, 94, 94, 94, 94, 92, 92, 96,
722 : 95, 92, 92, 94, 94, 94, 94, 92, 96, 94,
723 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
724 : 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
725 : 94, 0, 92, 92, 92, 92
726 :
727 : } ;
728 :
729 : static const flex_int16_t yy_nxt[156] =
730 : { 0,
731 : 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
732 : 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
733 : 24, 25, 26, 27, 23, 28, 23, 23, 29, 23,
734 : 30, 23, 23, 23, 23, 23, 23, 23, 31, 23,
735 : 23, 32, 36, 39, 47, 48, 41, 50, 51, 58,
736 : 91, 40, 42, 43, 37, 90, 89, 88, 87, 86,
737 : 85, 84, 83, 82, 81, 80, 79, 78, 77, 76,
738 : 75, 74, 69, 59, 45, 45, 52, 73, 52, 61,
739 : 61, 72, 61, 68, 68, 71, 68, 70, 60, 69,
740 : 67, 66, 65, 64, 63, 62, 46, 60, 33, 57,
741 :
742 : 56, 55, 54, 53, 49, 46, 44, 38, 35, 34,
743 : 33, 92, 3, 92, 92, 92, 92, 92, 92, 92,
744 : 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
745 : 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
746 : 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
747 : 92, 92, 92, 92, 92
748 : } ;
749 :
750 : static const flex_int16_t yy_chk[156] =
751 : { 0,
752 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
753 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
754 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
755 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
756 : 1, 1, 9, 13, 20, 20, 15, 22, 22, 32,
757 : 90, 13, 15, 15, 9, 89, 87, 86, 85, 84,
758 : 83, 81, 80, 79, 78, 77, 76, 75, 74, 73,
759 : 72, 70, 69, 32, 93, 93, 94, 67, 94, 95,
760 : 95, 66, 95, 96, 96, 65, 96, 64, 61, 60,
761 : 57, 56, 55, 54, 51, 47, 46, 45, 33, 31,
762 :
763 : 30, 29, 28, 27, 21, 18, 17, 12, 8, 7,
764 : 6, 3, 92, 92, 92, 92, 92, 92, 92, 92,
765 : 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
766 : 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
767 : 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
768 : 92, 92, 92, 92, 92
769 : } ;
770 :
771 : extern int yy_flex_debug;
772 : int yy_flex_debug = 0;
773 :
774 : static yy_state_type *yy_state_buf=0, *yy_state_ptr=0;
775 : static char *yy_full_match;
776 : static int yy_lp;
777 : static int yy_looking_for_trail_begin = 0;
778 : static int yy_full_lp;
779 : static int *yy_full_state;
780 : #define YY_TRAILING_MASK 0x2000
781 : #define YY_TRAILING_HEAD_MASK 0x4000
782 : #define REJECT \
783 : { \
784 : *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ \
785 : yy_cp = (yy_full_match); /* restore poss. backed-over text */ \
786 : (yy_lp) = (yy_full_lp); /* restore orig. accepting pos. */ \
787 : (yy_state_ptr) = (yy_full_state); /* restore orig. state */ \
788 : yy_current_state = *(yy_state_ptr); /* restore curr. state */ \
789 : ++(yy_lp); \
790 : goto find_rule; \
791 : }
792 :
793 : #define yymore() yymore_used_but_not_detected
794 : #define YY_MORE_ADJ 0
795 : #define YY_RESTORE_YY_MORE_OFFSET
796 : char *yytext;
797 : #line 1 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
798 : #line 11 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
799 :
800 : /* DQ (12/10/2016): This is a technique to suppress warnings in generated code that we want to be an error elsewhere in ROSE.
801 : See https://gcc.gnu.org/onlinedocs/gcc/Diagnostic-Pragmas.html for more detail.
802 : */
803 : #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
804 : #pragma GCC diagnostic ignored "-Wsign-compare"
805 : #endif
806 :
807 : /* lex requires me to use extern "C" here */
808 : extern "C" int omp_exprparser_wrap() { return 1; }
809 :
810 : extern int omp_exprparser_lex();
811 :
812 : #include <stdio.h>
813 : #include <string>
814 : #include <string.h>
815 : #include "omp_exprparser_parser.hh"
816 :
817 : static const char* ompparserinput = NULL;
818 : static std::string gExpressionString;
819 :
820 : /* pass user specified string to buf, indicate the size using 'result',
821 : and shift the current position pointer of user input afterwards
822 : to prepare next round of token recognition!!
823 : */
824 : #define YY_INPUT(buf, result, max_size) { \
825 : if (*ompparserinput == '\0') result = 0; \
826 : else { strncpy(buf, ompparserinput, max_size); \
827 : buf[max_size] = 0; \
828 : result = strlen(buf); \
829 : ompparserinput += result; \
830 : } \
831 : }
832 :
833 : #line 834 "omp_exprparser_lexer.cc"
834 : #line 835 "omp_exprparser_lexer.cc"
835 :
836 : #define INITIAL 0
837 :
838 : #ifndef YY_NO_UNISTD_H
839 : /* Special case for "unistd.h", since it is non-ANSI. We include it way
840 : * down here because we want the user's section 1 to have been scanned first.
841 : * The user has a chance to override it with an option.
842 : */
843 : #include <unistd.h>
844 : #endif
845 :
846 : #ifndef YY_EXTRA_TYPE
847 : #define YY_EXTRA_TYPE void *
848 : #endif
849 :
850 : static int yy_init_globals ( void );
851 :
852 : /* Accessor methods to globals.
853 : These are made visible to non-reentrant scanners for convenience. */
854 :
855 : int yylex_destroy ( void );
856 :
857 : int yyget_debug ( void );
858 :
859 : void yyset_debug ( int debug_flag );
860 :
861 : YY_EXTRA_TYPE yyget_extra ( void );
862 :
863 : void yyset_extra ( YY_EXTRA_TYPE user_defined );
864 :
865 : FILE *yyget_in ( void );
866 :
867 : void yyset_in ( FILE * _in_str );
868 :
869 : FILE *yyget_out ( void );
870 :
871 : void yyset_out ( FILE * _out_str );
872 :
873 : int yyget_leng ( void );
874 :
875 : char *yyget_text ( void );
876 :
877 : int yyget_lineno ( void );
878 :
879 : void yyset_lineno ( int _line_number );
880 :
881 : /* Macros after this point can all be overridden by user definitions in
882 : * section 1.
883 : */
884 :
885 : #ifndef YY_SKIP_YYWRAP
886 : #ifdef __cplusplus
887 : extern "C" int yywrap ( void );
888 : #else
889 : extern int yywrap ( void );
890 : #endif
891 : #endif
892 :
893 : #ifndef YY_NO_UNPUT
894 :
895 : #endif
896 :
897 : #ifndef yytext_ptr
898 : static void yy_flex_strncpy ( char *, const char *, int );
899 : #endif
900 :
901 : #ifdef YY_NEED_STRLEN
902 : static int yy_flex_strlen ( const char * );
903 : #endif
904 :
905 : #ifndef YY_NO_INPUT
906 : #ifdef __cplusplus
907 : static int yyinput ( void );
908 : #else
909 : static int input ( void );
910 : #endif
911 :
912 : #endif
913 :
914 : static int yy_start_stack_ptr = 0;
915 : static int yy_start_stack_depth = 0;
916 : static int *yy_start_stack = NULL;
917 :
918 : /* Amount of stuff to slurp up with each read. */
919 : #ifndef YY_READ_BUF_SIZE
920 : #ifdef __ia64__
921 : /* On IA-64, the buffer size is 16k, not 8k */
922 : #define YY_READ_BUF_SIZE 16384
923 : #else
924 : #define YY_READ_BUF_SIZE 8192
925 : #endif /* __ia64__ */
926 : #endif
927 :
928 : /* Copy whatever the last rule matched to the standard output. */
929 : #ifndef ECHO
930 : /* This used to be an fputs(), but since the string might contain NUL's,
931 : * we now use fwrite().
932 : */
933 : #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
934 : #endif
935 :
936 : /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
937 : * is returned in "result".
938 : */
939 : #ifndef YY_INPUT
940 : #define YY_INPUT(buf,result,max_size) \
941 : if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
942 : { \
943 : int c = '*'; \
944 : int n; \
945 : for ( n = 0; n < max_size && \
946 : (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
947 : buf[n] = (char) c; \
948 : if ( c == '\n' ) \
949 : buf[n++] = (char) c; \
950 : if ( c == EOF && ferror( yyin ) ) \
951 : YY_FATAL_ERROR( "input in flex scanner failed" ); \
952 : result = n; \
953 : } \
954 : else \
955 : { \
956 : errno=0; \
957 : while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
958 : { \
959 : if( errno != EINTR) \
960 : { \
961 : YY_FATAL_ERROR( "input in flex scanner failed" ); \
962 : break; \
963 : } \
964 : errno=0; \
965 : clearerr(yyin); \
966 : } \
967 : }\
968 : \
969 :
970 : #endif
971 :
972 : /* No semi-colon after return; correct usage is to write "yyterminate();" -
973 : * we don't want an extra ';' after the "return" because that will cause
974 : * some compilers to complain about unreachable statements.
975 : */
976 : #ifndef yyterminate
977 : #define yyterminate() return YY_NULL
978 : #endif
979 :
980 : /* Number of entries by which start-condition stack grows. */
981 : #ifndef YY_START_STACK_INCR
982 : #define YY_START_STACK_INCR 25
983 : #endif
984 :
985 : /* Report a fatal error. */
986 : #ifndef YY_FATAL_ERROR
987 : #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
988 : #endif
989 :
990 : /* end tables serialization structures and prototypes */
991 :
992 : /* Default declaration of generated scanner - a define so the user can
993 : * easily add parameters.
994 : */
995 : #ifndef YY_DECL
996 : #define YY_DECL_IS_OURS 1
997 :
998 : extern int yylex (void);
999 :
1000 : #define YY_DECL int yylex (void)
1001 : #endif /* !YY_DECL */
1002 :
1003 : /* Code executed at the beginning of each rule, after yytext and yyleng
1004 : * have been set up.
1005 : */
1006 : #ifndef YY_USER_ACTION
1007 : #define YY_USER_ACTION
1008 : #endif
1009 :
1010 : /* Code executed at the end of each rule. */
1011 : #ifndef YY_BREAK
1012 : #define YY_BREAK /*LINTED*/break;
1013 : #endif
1014 :
1015 : #define YY_RULE_SETUP \
1016 : YY_USER_ACTION
1017 :
1018 : /** The main scanner function which does all the work.
1019 : */
1020 4048 : YY_DECL
1021 : {
1022 4048 : yy_state_type yy_current_state;
1023 4048 : char *yy_cp, *yy_bp;
1024 4048 : int yy_act;
1025 :
1026 4048 : if ( !(yy_init) )
1027 : {
1028 178 : (yy_init) = 1;
1029 :
1030 : #ifdef YY_USER_INIT
1031 : YY_USER_INIT;
1032 : #endif
1033 :
1034 : /* Create the reject buffer large enough to save one state per allowed character. */
1035 178 : if ( ! (yy_state_buf) )
1036 178 : (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE );
1037 178 : if ( ! (yy_state_buf) )
1038 0 : YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
1039 :
1040 178 : if ( ! (yy_start) )
1041 178 : (yy_start) = 1; /* first start state */
1042 :
1043 178 : if ( ! yyin )
1044 178 : yyin = stdin;
1045 :
1046 178 : if ( ! yyout )
1047 178 : yyout = stdout;
1048 :
1049 178 : if ( ! YY_CURRENT_BUFFER ) {
1050 0 : yyensure_buffer_stack ();
1051 0 : YY_CURRENT_BUFFER_LVALUE =
1052 0 : yy_create_buffer( yyin, YY_BUF_SIZE );
1053 : }
1054 :
1055 178 : yy_load_buffer_state( );
1056 : }
1057 :
1058 5966 : {
1059 : #line 54 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1060 :
1061 : #line 1062 "omp_exprparser_lexer.cc"
1062 :
1063 5966 : while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
1064 : {
1065 5966 : yy_cp = (yy_c_buf_p);
1066 :
1067 : /* Support of yytext. */
1068 5966 : *yy_cp = (yy_hold_char);
1069 :
1070 : /* yy_bp points to the position in yy_ch_buf of the start of
1071 : * the current run.
1072 : */
1073 5966 : yy_bp = yy_cp;
1074 :
1075 5966 : yy_current_state = (yy_start);
1076 :
1077 5966 : (yy_state_ptr) = (yy_state_buf);
1078 5966 : *(yy_state_ptr)++ = yy_current_state;
1079 :
1080 19211 : yy_match:
1081 19211 : do
1082 : {
1083 19211 : YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1084 27389 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1085 : {
1086 8178 : yy_current_state = (int) yy_def[yy_current_state];
1087 8178 : if ( yy_current_state >= 93 )
1088 3190 : yy_c = yy_meta[yy_c];
1089 : }
1090 19211 : yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1091 19211 : *(yy_state_ptr)++ = yy_current_state;
1092 19211 : ++yy_cp;
1093 : }
1094 19211 : while ( yy_base[yy_current_state] != 113 );
1095 :
1096 6925 : yy_find_action:
1097 6925 : yy_current_state = *--(yy_state_ptr);
1098 6925 : (yy_lp) = yy_accept[yy_current_state];
1099 11915 : find_rule: /* we branch to this label when backing up */
1100 16904 : for ( ; ; ) /* until we find what rule we matched */
1101 : {
1102 11915 : if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )
1103 : {
1104 6926 : yy_act = yy_acclist[(yy_lp)];
1105 6926 : if ( yy_act & YY_TRAILING_HEAD_MASK ||
1106 6925 : (yy_looking_for_trail_begin) )
1107 : {
1108 1 : if ( yy_act == (yy_looking_for_trail_begin) )
1109 : {
1110 1 : (yy_looking_for_trail_begin) = 0;
1111 1 : yy_act &= ~YY_TRAILING_HEAD_MASK;
1112 1 : break;
1113 : }
1114 : }
1115 6925 : else if ( yy_act & YY_TRAILING_MASK )
1116 : {
1117 1 : (yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;
1118 1 : (yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK;
1119 : }
1120 : else
1121 : {
1122 6924 : (yy_full_match) = yy_cp;
1123 6924 : (yy_full_state) = (yy_state_ptr);
1124 6924 : (yy_full_lp) = (yy_lp);
1125 6924 : break;
1126 : }
1127 1 : ++(yy_lp);
1128 1 : goto find_rule;
1129 : }
1130 4989 : --yy_cp;
1131 4989 : yy_current_state = *--(yy_state_ptr);
1132 4989 : (yy_lp) = yy_accept[yy_current_state];
1133 : }
1134 :
1135 6925 : YY_DO_BEFORE_ACTION;
1136 :
1137 7884 : do_action: /* This label is used only to access EOF actions. */
1138 :
1139 7884 : switch ( yy_act )
1140 : { /* beginning of action switch */
1141 241 : case 1:
1142 : YY_RULE_SETUP
1143 : #line 55 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1144 : { omp_exprparser_lval.itype = atoi(strdup(yytext)); return (ICONSTANT); }
1145 : YY_BREAK
1146 : case 2:
1147 : YY_RULE_SETUP
1148 : #line 57 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1149 : { return ('='); }
1150 : YY_BREAK
1151 : case 3:
1152 : YY_RULE_SETUP
1153 : #line 58 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1154 : { return ('('); }
1155 : YY_BREAK
1156 : case 4:
1157 : YY_RULE_SETUP
1158 : #line 59 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1159 : { return (')'); }
1160 : YY_BREAK
1161 : case 5:
1162 : YY_RULE_SETUP
1163 : #line 60 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1164 : { return ('['); }
1165 : YY_BREAK
1166 : case 6:
1167 : YY_RULE_SETUP
1168 : #line 61 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1169 : { return (']'); }
1170 : YY_BREAK
1171 : case 7:
1172 : YY_RULE_SETUP
1173 : #line 62 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1174 : { return (','); }
1175 : YY_BREAK
1176 : case 8:
1177 : YY_RULE_SETUP
1178 : #line 63 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1179 : { return (':'); }
1180 : YY_BREAK
1181 : case 9:
1182 : YY_RULE_SETUP
1183 : #line 64 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1184 : { return ('+'); }
1185 : YY_BREAK
1186 : case 10:
1187 : YY_RULE_SETUP
1188 : #line 65 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1189 : { return ('*'); }
1190 : YY_BREAK
1191 : case 11:
1192 : YY_RULE_SETUP
1193 : #line 66 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1194 : { return ('/'); }
1195 : YY_BREAK
1196 : case 12:
1197 : YY_RULE_SETUP
1198 : #line 67 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1199 : { return ('-'); }
1200 : YY_BREAK
1201 : case 13:
1202 : YY_RULE_SETUP
1203 : #line 68 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1204 : { return ('&'); }
1205 : YY_BREAK
1206 : case 14:
1207 : YY_RULE_SETUP
1208 : #line 69 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1209 : { return ('^'); }
1210 : YY_BREAK
1211 : case 15:
1212 : YY_RULE_SETUP
1213 : #line 70 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1214 : { return ('|'); }
1215 : YY_BREAK
1216 : case 16:
1217 : YY_RULE_SETUP
1218 : #line 71 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1219 : { return (LOGAND); }
1220 : YY_BREAK
1221 : case 17:
1222 : YY_RULE_SETUP
1223 : #line 72 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1224 : { return (LOGOR); }
1225 : YY_BREAK
1226 : case 18:
1227 : YY_RULE_SETUP
1228 : #line 73 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1229 : { return (SHLEFT); }
1230 : YY_BREAK
1231 : case 19:
1232 : YY_RULE_SETUP
1233 : #line 74 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1234 : { return (SHRIGHT); }
1235 : YY_BREAK
1236 : case 20:
1237 : YY_RULE_SETUP
1238 : #line 75 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1239 : { return (PLUSPLUS); }
1240 : YY_BREAK
1241 : case 21:
1242 : YY_RULE_SETUP
1243 : #line 76 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1244 : { return (MINUSMINUS); }
1245 : YY_BREAK
1246 : case 22:
1247 : YY_RULE_SETUP
1248 : #line 78 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1249 : { return (RIGHT_ASSIGN2); }
1250 : YY_BREAK
1251 : case 23:
1252 : YY_RULE_SETUP
1253 : #line 79 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1254 : { return (LEFT_ASSIGN2); }
1255 : YY_BREAK
1256 : case 24:
1257 : YY_RULE_SETUP
1258 : #line 80 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1259 : { return (ADD_ASSIGN2); }
1260 : YY_BREAK
1261 : case 25:
1262 : YY_RULE_SETUP
1263 : #line 81 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1264 : { return (SUB_ASSIGN2); }
1265 : YY_BREAK
1266 : case 26:
1267 : YY_RULE_SETUP
1268 : #line 82 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1269 : { return (MUL_ASSIGN2); }
1270 : YY_BREAK
1271 : case 27:
1272 : YY_RULE_SETUP
1273 : #line 83 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1274 : { return (DIV_ASSIGN2); }
1275 : YY_BREAK
1276 : case 28:
1277 : YY_RULE_SETUP
1278 : #line 84 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1279 : { return (MOD_ASSIGN2); }
1280 : YY_BREAK
1281 : case 29:
1282 : YY_RULE_SETUP
1283 : #line 85 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1284 : { return (AND_ASSIGN2); }
1285 : YY_BREAK
1286 : case 30:
1287 : YY_RULE_SETUP
1288 : #line 86 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1289 : { return (XOR_ASSIGN2); }
1290 : YY_BREAK
1291 : case 31:
1292 : YY_RULE_SETUP
1293 : #line 87 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1294 : { return (OR_ASSIGN2); }
1295 : YY_BREAK
1296 : case 32:
1297 : YY_RULE_SETUP
1298 : #line 89 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1299 : { return ('<'); }
1300 : YY_BREAK
1301 : case 33:
1302 : YY_RULE_SETUP
1303 : #line 90 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1304 : { return ('>'); }
1305 : YY_BREAK
1306 : case 34:
1307 : YY_RULE_SETUP
1308 : #line 91 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1309 : { return (LE_OP2);}
1310 : YY_BREAK
1311 : case 35:
1312 : YY_RULE_SETUP
1313 : #line 92 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1314 : { return (GE_OP2);}
1315 : YY_BREAK
1316 : case 36:
1317 : YY_RULE_SETUP
1318 : #line 93 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1319 : { return (EQ_OP2);}
1320 : YY_BREAK
1321 : case 37:
1322 : YY_RULE_SETUP
1323 : #line 94 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1324 : { return (NE_OP2);}
1325 : YY_BREAK
1326 : case 38:
1327 : YY_RULE_SETUP
1328 : #line 95 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1329 : { /*printf("found a backslash\n"); This does not work properly but can be ignored*/}
1330 : YY_BREAK
1331 : case 39:
1332 : YY_RULE_SETUP
1333 : #line 97 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1334 : { return (PTR_TO); }
1335 : YY_BREAK
1336 : case 40:
1337 : YY_RULE_SETUP
1338 : #line 98 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1339 : { return ('.'); }
1340 : YY_BREAK
1341 : case 41:
1342 : /* rule 41 can match eol */
1343 : YY_RULE_SETUP
1344 : #line 100 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1345 : { /* printf("found a new line\n"); */ /* return (NEWLINE); We ignore NEWLINE since we only care about the pragma string , We relax the syntax check by allowing it as part of line continuation */ }
1346 : YY_BREAK
1347 : case 42:
1348 : YY_RULE_SETUP
1349 : #line 102 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1350 : { return (EXPRESSION); }
1351 : YY_BREAK
1352 : case 43:
1353 : YY_RULE_SETUP
1354 : #line 103 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1355 : { return (VARLIST); }
1356 : YY_BREAK
1357 : case 44:
1358 : YY_RULE_SETUP
1359 : #line 104 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1360 : { return (IDENTIFIER); /*not in use for now*/ }
1361 : YY_BREAK
1362 : case 45:
1363 : YY_RULE_SETUP
1364 : #line 105 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1365 : { return (ARRAY_SECTION); }
1366 : YY_BREAK
1367 : case 46:
1368 : YY_RULE_SETUP
1369 : #line 106 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1370 : { omp_exprparser_lval.stype = strdup(yytext);
1371 : return (ID_EXPRESSION); }
1372 : YY_BREAK
1373 : case 47:
1374 : /* rule 47 can match eol */
1375 : YY_RULE_SETUP
1376 : #line 109 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1377 : { omp_exprparser_lval.stype = strdup(yytext); return (ID_EXPRESSION); }
1378 : YY_BREAK
1379 : case 48:
1380 : YY_RULE_SETUP
1381 : #line 110 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1382 : ;
1383 : YY_BREAK
1384 : case 49:
1385 : YY_RULE_SETUP
1386 : #line 111 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1387 : { return (LEXICALERROR);}
1388 : YY_BREAK
1389 : case 50:
1390 : YY_RULE_SETUP
1391 : #line 113 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
1392 : ECHO;
1393 : YY_BREAK
1394 : #line 1395 "omp_exprparser_lexer.cc"
1395 959 : case YY_STATE_EOF(INITIAL):
1396 959 : yyterminate();
1397 :
1398 1918 : case YY_END_OF_BUFFER:
1399 1918 : {
1400 : /* Amount of text matched not including the EOB char. */
1401 1918 : int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1402 :
1403 : /* Undo the effects of YY_DO_BEFORE_ACTION. */
1404 1918 : *yy_cp = (yy_hold_char);
1405 : YY_RESTORE_YY_MORE_OFFSET
1406 :
1407 1918 : if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1408 : {
1409 : /* We're scanning a new file or input source. It's
1410 : * possible that this happened because the user
1411 : * just pointed yyin at a new source and called
1412 : * yylex(). If so, then we have to assure
1413 : * consistency between YY_CURRENT_BUFFER and our
1414 : * globals. Here is the right place to do so, because
1415 : * this is the first action (other than possibly a
1416 : * back-up) that will match for the new input source.
1417 : */
1418 959 : (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1419 959 : YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1420 959 : YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1421 : }
1422 :
1423 : /* Note that here we test for yy_c_buf_p "<=" to the position
1424 : * of the first EOB in the buffer, since yy_c_buf_p will
1425 : * already have been incremented past the NUL character
1426 : * (since all states make transitions on EOB to the
1427 : * end-of-buffer state). Contrast this with the test
1428 : * in input().
1429 : */
1430 1918 : if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1431 : { /* This was really a NUL. */
1432 0 : yy_state_type yy_next_state;
1433 :
1434 0 : (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1435 :
1436 0 : yy_current_state = yy_get_previous_state( );
1437 :
1438 : /* Okay, we're now positioned to make the NUL
1439 : * transition. We couldn't have
1440 : * yy_get_previous_state() go ahead and do it
1441 : * for us because it doesn't know how to deal
1442 : * with the possibility of jamming (and we don't
1443 : * want to build jamming into it because then it
1444 : * will run more slowly).
1445 : */
1446 :
1447 0 : yy_next_state = yy_try_NUL_trans( yy_current_state );
1448 :
1449 0 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1450 :
1451 0 : if ( yy_next_state )
1452 : {
1453 : /* Consume the NUL. */
1454 0 : yy_cp = ++(yy_c_buf_p);
1455 0 : yy_current_state = yy_next_state;
1456 0 : goto yy_match;
1457 : }
1458 :
1459 : else
1460 : {
1461 0 : yy_cp = (yy_c_buf_p);
1462 0 : goto yy_find_action;
1463 : }
1464 : }
1465 :
1466 1918 : else switch ( yy_get_next_buffer( ) )
1467 : {
1468 959 : case EOB_ACT_END_OF_FILE:
1469 959 : {
1470 959 : (yy_did_buffer_switch_on_eof) = 0;
1471 :
1472 959 : if ( yywrap( ) )
1473 : {
1474 : /* Note: because we've taken care in
1475 : * yy_get_next_buffer() to have set up
1476 : * yytext, we can now set up
1477 : * yy_c_buf_p so that if some total
1478 : * hoser (like flex itself) wants to
1479 : * call the scanner after we return the
1480 : * YY_NULL, it'll still work - another
1481 : * YY_NULL will get returned.
1482 : */
1483 959 : (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1484 :
1485 959 : yy_act = YY_STATE_EOF(YY_START);
1486 959 : goto do_action;
1487 : }
1488 :
1489 : else
1490 : {
1491 0 : if ( ! (yy_did_buffer_switch_on_eof) )
1492 0 : YY_NEW_FILE;
1493 : }
1494 : break;
1495 : }
1496 :
1497 959 : case EOB_ACT_CONTINUE_SCAN:
1498 959 : (yy_c_buf_p) =
1499 959 : (yytext_ptr) + yy_amount_of_matched_text;
1500 :
1501 959 : yy_current_state = yy_get_previous_state( );
1502 :
1503 959 : yy_cp = (yy_c_buf_p);
1504 959 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1505 959 : goto yy_match;
1506 :
1507 0 : case EOB_ACT_LAST_MATCH:
1508 0 : (yy_c_buf_p) =
1509 0 : &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1510 :
1511 0 : yy_current_state = yy_get_previous_state( );
1512 :
1513 0 : yy_cp = (yy_c_buf_p);
1514 0 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1515 0 : goto yy_find_action;
1516 : }
1517 : break;
1518 : }
1519 :
1520 0 : default:
1521 0 : YY_FATAL_ERROR(
1522 : "fatal flex scanner internal error--no action found" );
1523 : } /* end of action switch */
1524 : } /* end of scanning one token */
1525 : } /* end of user's declarations */
1526 : } /* end of yylex */
1527 :
1528 : /* yy_get_next_buffer - try to read in a new buffer
1529 : *
1530 : * Returns a code representing an action:
1531 : * EOB_ACT_LAST_MATCH -
1532 : * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1533 : * EOB_ACT_END_OF_FILE - end of file
1534 : */
1535 1918 : static int yy_get_next_buffer (void)
1536 : {
1537 1918 : char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1538 1918 : char *source = (yytext_ptr);
1539 1918 : int number_to_move, i;
1540 1918 : int ret_val;
1541 :
1542 1918 : if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1543 0 : YY_FATAL_ERROR(
1544 : "fatal flex scanner internal error--end of buffer missed" );
1545 :
1546 1918 : if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1547 : { /* Don't try to fill the buffer, so this is an EOF. */
1548 0 : if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1549 : {
1550 : /* We matched a single character, the EOB, so
1551 : * treat this as a final EOF.
1552 : */
1553 : return EOB_ACT_END_OF_FILE;
1554 : }
1555 :
1556 : else
1557 : {
1558 : /* We matched some text prior to the EOB, first
1559 : * process it.
1560 : */
1561 0 : return EOB_ACT_LAST_MATCH;
1562 : }
1563 : }
1564 :
1565 : /* Try to read more data. */
1566 :
1567 : /* First move last chars to start of buffer. */
1568 1918 : number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1569 :
1570 1918 : for ( i = 0; i < number_to_move; ++i )
1571 0 : *(dest++) = *(source++);
1572 :
1573 1918 : if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1574 : /* don't do the read, it's not guaranteed to return an EOF,
1575 : * just force an EOF
1576 : */
1577 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1578 :
1579 : else
1580 : {
1581 1918 : int num_to_read =
1582 1918 : YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1583 :
1584 1918 : while ( num_to_read <= 0 )
1585 : { /* Not enough room in the buffer - grow it. */
1586 :
1587 0 : YY_FATAL_ERROR(
1588 : "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1589 :
1590 : }
1591 :
1592 1918 : if ( num_to_read > YY_READ_BUF_SIZE )
1593 : num_to_read = YY_READ_BUF_SIZE;
1594 :
1595 : /* Read in more data. */
1596 1918 : YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1597 1918 : (yy_n_chars), num_to_read );
1598 :
1599 1918 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1600 : }
1601 :
1602 1918 : if ( (yy_n_chars) == 0 )
1603 : {
1604 959 : if ( number_to_move == YY_MORE_ADJ )
1605 : {
1606 959 : ret_val = EOB_ACT_END_OF_FILE;
1607 959 : yyrestart( yyin );
1608 : }
1609 :
1610 : else
1611 : {
1612 0 : ret_val = EOB_ACT_LAST_MATCH;
1613 0 : YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1614 : YY_BUFFER_EOF_PENDING;
1615 : }
1616 : }
1617 :
1618 : else
1619 : ret_val = EOB_ACT_CONTINUE_SCAN;
1620 :
1621 1918 : if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1622 : /* Extend the array by 50%, plus the number we really need. */
1623 0 : int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1624 0 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1625 0 : (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
1626 0 : if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1627 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1628 : /* "- 2" to take care of EOB's */
1629 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1630 : }
1631 :
1632 1918 : (yy_n_chars) += number_to_move;
1633 1918 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1634 1918 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1635 :
1636 1918 : (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1637 :
1638 1918 : return ret_val;
1639 : }
1640 :
1641 : /* yy_get_previous_state - get the state just before the EOB char was reached */
1642 :
1643 959 : static yy_state_type yy_get_previous_state (void)
1644 : {
1645 959 : yy_state_type yy_current_state;
1646 959 : char *yy_cp;
1647 :
1648 959 : yy_current_state = (yy_start);
1649 :
1650 959 : (yy_state_ptr) = (yy_state_buf);
1651 959 : *(yy_state_ptr)++ = yy_current_state;
1652 :
1653 959 : for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1654 : {
1655 0 : YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1656 0 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1657 : {
1658 0 : yy_current_state = (int) yy_def[yy_current_state];
1659 0 : if ( yy_current_state >= 93 )
1660 0 : yy_c = yy_meta[yy_c];
1661 : }
1662 0 : yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1663 0 : *(yy_state_ptr)++ = yy_current_state;
1664 : }
1665 :
1666 959 : return yy_current_state;
1667 : }
1668 :
1669 : /* yy_try_NUL_trans - try to make a transition on the NUL character
1670 : *
1671 : * synopsis
1672 : * next_state = yy_try_NUL_trans( current_state );
1673 : */
1674 0 : static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1675 : {
1676 0 : int yy_is_jam;
1677 :
1678 0 : YY_CHAR yy_c = 1;
1679 0 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1680 : {
1681 0 : yy_current_state = (int) yy_def[yy_current_state];
1682 0 : if ( yy_current_state >= 93 )
1683 : yy_c = yy_meta[yy_c];
1684 : }
1685 0 : yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1686 0 : yy_is_jam = (yy_current_state == 92);
1687 0 : if ( ! yy_is_jam )
1688 0 : *(yy_state_ptr)++ = yy_current_state;
1689 :
1690 0 : return yy_is_jam ? 0 : yy_current_state;
1691 : }
1692 :
1693 : #ifndef YY_NO_UNPUT
1694 :
1695 : #endif
1696 :
1697 : #ifndef YY_NO_INPUT
1698 : #ifdef __cplusplus
1699 : static int yyinput (void)
1700 : #else
1701 : static int input (void)
1702 : #endif
1703 :
1704 : {
1705 : int c;
1706 :
1707 : *(yy_c_buf_p) = (yy_hold_char);
1708 :
1709 : if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1710 : {
1711 : /* yy_c_buf_p now points to the character we want to return.
1712 : * If this occurs *before* the EOB characters, then it's a
1713 : * valid NUL; if not, then we've hit the end of the buffer.
1714 : */
1715 : if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1716 : /* This was really a NUL. */
1717 : *(yy_c_buf_p) = '\0';
1718 :
1719 : else
1720 : { /* need more input */
1721 : int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
1722 : ++(yy_c_buf_p);
1723 :
1724 : switch ( yy_get_next_buffer( ) )
1725 : {
1726 : case EOB_ACT_LAST_MATCH:
1727 : /* This happens because yy_g_n_b()
1728 : * sees that we've accumulated a
1729 : * token and flags that we need to
1730 : * try matching the token before
1731 : * proceeding. But for input(),
1732 : * there's no matching to consider.
1733 : * So convert the EOB_ACT_LAST_MATCH
1734 : * to EOB_ACT_END_OF_FILE.
1735 : */
1736 :
1737 : /* Reset buffer status. */
1738 : yyrestart( yyin );
1739 :
1740 : /*FALLTHROUGH*/
1741 :
1742 : case EOB_ACT_END_OF_FILE:
1743 : {
1744 : if ( yywrap( ) )
1745 : return 0;
1746 :
1747 : if ( ! (yy_did_buffer_switch_on_eof) )
1748 : YY_NEW_FILE;
1749 : #ifdef __cplusplus
1750 : return yyinput();
1751 : #else
1752 : return input();
1753 : #endif
1754 : }
1755 :
1756 : case EOB_ACT_CONTINUE_SCAN:
1757 : (yy_c_buf_p) = (yytext_ptr) + offset;
1758 : break;
1759 : }
1760 : }
1761 : }
1762 :
1763 : c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1764 : *(yy_c_buf_p) = '\0'; /* preserve yytext */
1765 : (yy_hold_char) = *++(yy_c_buf_p);
1766 :
1767 : return c;
1768 : }
1769 : #endif /* ifndef YY_NO_INPUT */
1770 :
1771 : /** Immediately switch to a different input stream.
1772 : * @param input_file A readable stream.
1773 : *
1774 : * @note This function does not reset the start condition to @c INITIAL .
1775 : */
1776 1918 : void yyrestart (FILE * input_file )
1777 : {
1778 :
1779 1918 : if ( ! YY_CURRENT_BUFFER ){
1780 178 : yyensure_buffer_stack ();
1781 178 : YY_CURRENT_BUFFER_LVALUE =
1782 178 : yy_create_buffer( yyin, YY_BUF_SIZE );
1783 : }
1784 :
1785 1918 : yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1786 1918 : yy_load_buffer_state( );
1787 1918 : }
1788 :
1789 : /** Switch to a different input buffer.
1790 : * @param new_buffer The new input buffer.
1791 : *
1792 : */
1793 0 : void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1794 : {
1795 :
1796 : /* TODO. We should be able to replace this entire function body
1797 : * with
1798 : * yypop_buffer_state();
1799 : * yypush_buffer_state(new_buffer);
1800 : */
1801 0 : yyensure_buffer_stack ();
1802 0 : if ( YY_CURRENT_BUFFER == new_buffer )
1803 : return;
1804 :
1805 0 : if ( YY_CURRENT_BUFFER )
1806 : {
1807 : /* Flush out information for old buffer. */
1808 0 : *(yy_c_buf_p) = (yy_hold_char);
1809 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1810 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1811 : }
1812 :
1813 0 : YY_CURRENT_BUFFER_LVALUE = new_buffer;
1814 0 : yy_load_buffer_state( );
1815 :
1816 : /* We don't actually know whether we did this switch during
1817 : * EOF (yywrap()) processing, but the only time this flag
1818 : * is looked at is after yywrap() is called, so it's safe
1819 : * to go ahead and always set it.
1820 : */
1821 0 : (yy_did_buffer_switch_on_eof) = 1;
1822 : }
1823 :
1824 4014 : static void yy_load_buffer_state (void)
1825 : {
1826 4014 : (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1827 4014 : (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1828 4014 : yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1829 0 : (yy_hold_char) = *(yy_c_buf_p);
1830 178 : }
1831 :
1832 : /** Allocate and initialize an input buffer state.
1833 : * @param file A readable stream.
1834 : * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1835 : *
1836 : * @return the allocated buffer state.
1837 : */
1838 178 : YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
1839 : {
1840 178 : YY_BUFFER_STATE b;
1841 :
1842 178 : b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1843 178 : if ( ! b )
1844 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1845 :
1846 178 : b->yy_buf_size = size;
1847 :
1848 : /* yy_ch_buf has to be 2 characters longer than the size given because
1849 : * we need to put in 2 end-of-buffer characters.
1850 : */
1851 178 : b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
1852 178 : if ( ! b->yy_ch_buf )
1853 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1854 :
1855 178 : b->yy_is_our_buffer = 1;
1856 :
1857 178 : yy_init_buffer( b, file );
1858 :
1859 178 : return b;
1860 : }
1861 :
1862 : /** Destroy the buffer.
1863 : * @param b a buffer created with yy_create_buffer()
1864 : *
1865 : */
1866 0 : void yy_delete_buffer (YY_BUFFER_STATE b )
1867 : {
1868 :
1869 0 : if ( ! b )
1870 : return;
1871 :
1872 0 : if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1873 0 : YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1874 :
1875 0 : if ( b->yy_is_our_buffer )
1876 0 : yyfree( (void *) b->yy_ch_buf );
1877 :
1878 0 : yyfree( (void *) b );
1879 : }
1880 :
1881 : /* Initializes or reinitializes a buffer.
1882 : * This function is sometimes called more than once on the same buffer,
1883 : * such as during a yyrestart() or at EOF.
1884 : */
1885 2096 : static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1886 :
1887 : {
1888 2096 : int oerrno = errno;
1889 :
1890 2096 : yy_flush_buffer( b );
1891 :
1892 2096 : b->yy_input_file = file;
1893 2096 : b->yy_fill_buffer = 1;
1894 :
1895 : /* If b is the current buffer, then yy_init_buffer was _probably_
1896 : * called from yyrestart() or through yy_get_next_buffer.
1897 : * In that case, we don't want to reset the lineno or column.
1898 : */
1899 2096 : if (b != YY_CURRENT_BUFFER){
1900 178 : b->yy_bs_lineno = 1;
1901 178 : b->yy_bs_column = 0;
1902 : }
1903 :
1904 2096 : b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1905 :
1906 2096 : errno = oerrno;
1907 2096 : }
1908 :
1909 : /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1910 : * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1911 : *
1912 : */
1913 2096 : void yy_flush_buffer (YY_BUFFER_STATE b )
1914 : {
1915 2096 : if ( ! b )
1916 : return;
1917 :
1918 2096 : b->yy_n_chars = 0;
1919 :
1920 : /* We always need two end-of-buffer characters. The first causes
1921 : * a transition to the end-of-buffer state. The second causes
1922 : * a jam in that state.
1923 : */
1924 2096 : b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1925 2096 : b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1926 :
1927 2096 : b->yy_buf_pos = &b->yy_ch_buf[0];
1928 :
1929 2096 : b->yy_at_bol = 1;
1930 2096 : b->yy_buffer_status = YY_BUFFER_NEW;
1931 :
1932 2096 : if ( b == YY_CURRENT_BUFFER )
1933 1918 : yy_load_buffer_state( );
1934 : }
1935 :
1936 : /** Pushes the new state onto the stack. The new state becomes
1937 : * the current state. This function will allocate the stack
1938 : * if necessary.
1939 : * @param new_buffer The new state.
1940 : *
1941 : */
1942 0 : void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1943 : {
1944 0 : if (new_buffer == NULL)
1945 : return;
1946 :
1947 0 : yyensure_buffer_stack();
1948 :
1949 : /* This block is copied from yy_switch_to_buffer. */
1950 0 : if ( YY_CURRENT_BUFFER )
1951 : {
1952 : /* Flush out information for old buffer. */
1953 0 : *(yy_c_buf_p) = (yy_hold_char);
1954 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1955 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1956 : }
1957 :
1958 : /* Only push if top exists. Otherwise, replace top. */
1959 0 : if (YY_CURRENT_BUFFER)
1960 0 : (yy_buffer_stack_top)++;
1961 0 : YY_CURRENT_BUFFER_LVALUE = new_buffer;
1962 :
1963 : /* copied from yy_switch_to_buffer. */
1964 0 : yy_load_buffer_state( );
1965 0 : (yy_did_buffer_switch_on_eof) = 1;
1966 : }
1967 :
1968 : /** Removes and deletes the top of the stack, if present.
1969 : * The next element becomes the new top.
1970 : *
1971 : */
1972 0 : void yypop_buffer_state (void)
1973 : {
1974 0 : if (!YY_CURRENT_BUFFER)
1975 : return;
1976 :
1977 0 : yy_delete_buffer(YY_CURRENT_BUFFER );
1978 0 : YY_CURRENT_BUFFER_LVALUE = NULL;
1979 0 : if ((yy_buffer_stack_top) > 0)
1980 0 : --(yy_buffer_stack_top);
1981 :
1982 0 : if (YY_CURRENT_BUFFER) {
1983 0 : yy_load_buffer_state( );
1984 0 : (yy_did_buffer_switch_on_eof) = 1;
1985 : }
1986 : }
1987 :
1988 : /* Allocates the stack if it does not exist.
1989 : * Guarantees space for at least one push.
1990 : */
1991 178 : static void yyensure_buffer_stack (void)
1992 : {
1993 178 : yy_size_t num_to_alloc;
1994 :
1995 178 : if (!(yy_buffer_stack)) {
1996 :
1997 : /* First allocation is just for 2 elements, since we don't know if this
1998 : * scanner will even need a stack. We use 2 instead of 1 to avoid an
1999 : * immediate realloc on the next call.
2000 : */
2001 178 : num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
2002 356 : (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
2003 178 : (num_to_alloc * sizeof(struct yy_buffer_state*)
2004 : );
2005 178 : if ( ! (yy_buffer_stack) )
2006 0 : YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2007 :
2008 178 : memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2009 :
2010 178 : (yy_buffer_stack_max) = num_to_alloc;
2011 178 : (yy_buffer_stack_top) = 0;
2012 178 : return;
2013 : }
2014 :
2015 0 : if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2016 :
2017 : /* Increase the buffer to prepare for a possible push. */
2018 0 : yy_size_t grow_size = 8 /* arbitrary grow size */;
2019 :
2020 0 : num_to_alloc = (yy_buffer_stack_max) + grow_size;
2021 0 : (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
2022 0 : ((yy_buffer_stack),
2023 : num_to_alloc * sizeof(struct yy_buffer_state*)
2024 : );
2025 0 : if ( ! (yy_buffer_stack) )
2026 0 : YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2027 :
2028 : /* zero only the new slots.*/
2029 0 : memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2030 0 : (yy_buffer_stack_max) = num_to_alloc;
2031 : }
2032 : }
2033 :
2034 : /** Setup the input buffer state to scan directly from a user-specified character buffer.
2035 : * @param base the character buffer
2036 : * @param size the size in bytes of the character buffer
2037 : *
2038 : * @return the newly allocated buffer state object.
2039 : */
2040 0 : YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
2041 : {
2042 0 : YY_BUFFER_STATE b;
2043 :
2044 0 : if ( size < 2 ||
2045 0 : base[size-2] != YY_END_OF_BUFFER_CHAR ||
2046 0 : base[size-1] != YY_END_OF_BUFFER_CHAR )
2047 : /* They forgot to leave room for the EOB's. */
2048 : return NULL;
2049 :
2050 0 : b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
2051 0 : if ( ! b )
2052 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2053 :
2054 0 : b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
2055 0 : b->yy_buf_pos = b->yy_ch_buf = base;
2056 0 : b->yy_is_our_buffer = 0;
2057 0 : b->yy_input_file = NULL;
2058 0 : b->yy_n_chars = b->yy_buf_size;
2059 0 : b->yy_is_interactive = 0;
2060 0 : b->yy_at_bol = 1;
2061 0 : b->yy_fill_buffer = 0;
2062 0 : b->yy_buffer_status = YY_BUFFER_NEW;
2063 :
2064 0 : yy_switch_to_buffer( b );
2065 :
2066 0 : return b;
2067 : }
2068 :
2069 : /** Setup the input buffer state to scan a string. The next call to yylex() will
2070 : * scan from a @e copy of @a str.
2071 : * @param yystr a NUL-terminated string to scan
2072 : *
2073 : * @return the newly allocated buffer state object.
2074 : * @note If you want to scan bytes that may contain NUL values, then use
2075 : * yy_scan_bytes() instead.
2076 : */
2077 0 : YY_BUFFER_STATE yy_scan_string (const char * yystr )
2078 : {
2079 :
2080 0 : return yy_scan_bytes( yystr, (int) strlen(yystr) );
2081 : }
2082 :
2083 : /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2084 : * scan from a @e copy of @a bytes.
2085 : * @param yybytes the byte buffer to scan
2086 : * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2087 : *
2088 : * @return the newly allocated buffer state object.
2089 : */
2090 0 : YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
2091 : {
2092 0 : YY_BUFFER_STATE b;
2093 0 : char *buf;
2094 0 : yy_size_t n;
2095 0 : int i;
2096 :
2097 : /* Get memory for full buffer, including space for trailing EOB's. */
2098 0 : n = (yy_size_t) (_yybytes_len + 2);
2099 0 : buf = (char *) yyalloc( n );
2100 0 : if ( ! buf )
2101 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2102 :
2103 0 : for ( i = 0; i < _yybytes_len; ++i )
2104 0 : buf[i] = yybytes[i];
2105 :
2106 0 : buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2107 :
2108 0 : b = yy_scan_buffer( buf, n );
2109 0 : if ( ! b )
2110 0 : YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2111 :
2112 : /* It's okay to grow etc. this buffer, and we should throw it
2113 : * away when we're done.
2114 : */
2115 0 : b->yy_is_our_buffer = 1;
2116 :
2117 0 : return b;
2118 : }
2119 :
2120 : #ifndef YY_EXIT_FAILURE
2121 : #define YY_EXIT_FAILURE 2
2122 : #endif
2123 :
2124 0 : static void yynoreturn yy_fatal_error (const char* msg )
2125 : {
2126 0 : fprintf( stderr, "%s\n", msg );
2127 0 : exit( YY_EXIT_FAILURE );
2128 : }
2129 :
2130 : /* Redefine yyless() so it works in section 3 code. */
2131 :
2132 : #undef yyless
2133 : #define yyless(n) \
2134 : do \
2135 : { \
2136 : /* Undo effects of setting up yytext. */ \
2137 : int yyless_macro_arg = (n); \
2138 : YY_LESS_LINENO(yyless_macro_arg);\
2139 : yytext[yyleng] = (yy_hold_char); \
2140 : (yy_c_buf_p) = yytext + yyless_macro_arg; \
2141 : (yy_hold_char) = *(yy_c_buf_p); \
2142 : *(yy_c_buf_p) = '\0'; \
2143 : yyleng = yyless_macro_arg; \
2144 : } \
2145 : while ( 0 )
2146 :
2147 : /* Accessor methods (get/set functions) to struct members. */
2148 :
2149 : /** Get the current line number.
2150 : *
2151 : */
2152 0 : int yyget_lineno (void)
2153 : {
2154 :
2155 0 : return yylineno;
2156 : }
2157 :
2158 : /** Get the input stream.
2159 : *
2160 : */
2161 0 : FILE *yyget_in (void)
2162 : {
2163 0 : return yyin;
2164 : }
2165 :
2166 : /** Get the output stream.
2167 : *
2168 : */
2169 0 : FILE *yyget_out (void)
2170 : {
2171 0 : return yyout;
2172 : }
2173 :
2174 : /** Get the length of the current token.
2175 : *
2176 : */
2177 0 : int yyget_leng (void)
2178 : {
2179 0 : return yyleng;
2180 : }
2181 :
2182 : /** Get the current token.
2183 : *
2184 : */
2185 :
2186 0 : char *yyget_text (void)
2187 : {
2188 0 : return yytext;
2189 : }
2190 :
2191 : /** Set the current line number.
2192 : * @param _line_number line number
2193 : *
2194 : */
2195 0 : void yyset_lineno (int _line_number )
2196 : {
2197 :
2198 0 : yylineno = _line_number;
2199 0 : }
2200 :
2201 : /** Set the input stream. This does not discard the current
2202 : * input buffer.
2203 : * @param _in_str A readable stream.
2204 : *
2205 : * @see yy_switch_to_buffer
2206 : */
2207 0 : void yyset_in (FILE * _in_str )
2208 : {
2209 0 : yyin = _in_str ;
2210 0 : }
2211 :
2212 0 : void yyset_out (FILE * _out_str )
2213 : {
2214 0 : yyout = _out_str ;
2215 0 : }
2216 :
2217 0 : int yyget_debug (void)
2218 : {
2219 0 : return yy_flex_debug;
2220 : }
2221 :
2222 0 : void yyset_debug (int _bdebug )
2223 : {
2224 0 : yy_flex_debug = _bdebug ;
2225 0 : }
2226 :
2227 0 : static int yy_init_globals (void)
2228 : {
2229 : /* Initialization is the same as for the non-reentrant scanner.
2230 : * This function is called from yylex_destroy(), so don't allocate here.
2231 : */
2232 :
2233 0 : (yy_buffer_stack) = NULL;
2234 0 : (yy_buffer_stack_top) = 0;
2235 0 : (yy_buffer_stack_max) = 0;
2236 0 : (yy_c_buf_p) = NULL;
2237 0 : (yy_init) = 0;
2238 0 : (yy_start) = 0;
2239 :
2240 0 : (yy_start_stack_ptr) = 0;
2241 0 : (yy_start_stack_depth) = 0;
2242 0 : (yy_start_stack) = NULL;
2243 :
2244 0 : (yy_state_buf) = 0;
2245 0 : (yy_state_ptr) = 0;
2246 0 : (yy_full_match) = 0;
2247 0 : (yy_lp) = 0;
2248 :
2249 : /* Defined in main.c */
2250 : #ifdef YY_STDINIT
2251 : yyin = stdin;
2252 : yyout = stdout;
2253 : #else
2254 0 : yyin = NULL;
2255 0 : yyout = NULL;
2256 : #endif
2257 :
2258 : /* For future reference: Set errno on error, since we are called by
2259 : * yylex_init()
2260 : */
2261 0 : return 0;
2262 : }
2263 :
2264 : /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2265 0 : int yylex_destroy (void)
2266 : {
2267 :
2268 : /* Pop the buffer stack, destroying each element. */
2269 0 : while(YY_CURRENT_BUFFER){
2270 0 : yy_delete_buffer( YY_CURRENT_BUFFER );
2271 0 : YY_CURRENT_BUFFER_LVALUE = NULL;
2272 0 : yypop_buffer_state();
2273 : }
2274 :
2275 : /* Destroy the stack itself. */
2276 0 : yyfree((yy_buffer_stack) );
2277 0 : (yy_buffer_stack) = NULL;
2278 :
2279 : /* Destroy the start condition stack. */
2280 0 : yyfree( (yy_start_stack) );
2281 0 : (yy_start_stack) = NULL;
2282 :
2283 0 : yyfree ( (yy_state_buf) );
2284 0 : (yy_state_buf) = NULL;
2285 :
2286 : /* Reset the globals. This is important in a non-reentrant scanner so the next time
2287 : * yylex() is called, initialization will occur. */
2288 0 : yy_init_globals( );
2289 :
2290 0 : return 0;
2291 : }
2292 :
2293 : /*
2294 : * Internal utility routines.
2295 : */
2296 :
2297 : #ifndef yytext_ptr
2298 : static void yy_flex_strncpy (char* s1, const char * s2, int n )
2299 : {
2300 :
2301 : int i;
2302 : for ( i = 0; i < n; ++i )
2303 : s1[i] = s2[i];
2304 : }
2305 : #endif
2306 :
2307 : #ifdef YY_NEED_STRLEN
2308 : static int yy_flex_strlen (const char * s )
2309 : {
2310 : int n;
2311 : for ( n = 0; s[n]; ++n )
2312 : ;
2313 :
2314 : return n;
2315 : }
2316 : #endif
2317 :
2318 712 : void *yyalloc (yy_size_t size )
2319 : {
2320 712 : return malloc(size);
2321 : }
2322 :
2323 0 : void *yyrealloc (void * ptr, yy_size_t size )
2324 : {
2325 :
2326 : /* The cast to (char *) in the following accommodates both
2327 : * implementations that use char* generic pointers, and those
2328 : * that use void* generic pointers. It works with the latter
2329 : * because both ANSI C and C++ allow castless assignment from
2330 : * any pointer type to void*, and deal with argument conversions
2331 : * as though doing an assignment.
2332 : */
2333 0 : return realloc(ptr, size);
2334 : }
2335 :
2336 0 : void yyfree (void * ptr )
2337 : {
2338 0 : free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2339 0 : }
2340 :
2341 : #define YYTABLES_NAME "yytables"
2342 :
2343 : #line 113 "../../../../rexompiler/src/frontend/SageIII/omp_exprparser_lexer.ll"
2344 :
2345 :
2346 : /* entry point invoked by callers to start scanning for a string */
2347 : extern void omp_exprparser_lexer_init(const char* str) {
2348 : ompparserinput = str;
2349 : /* We have omp_ suffix for all flex functions */
2350 : omp_exprparser_restart(omp_exprparser_in);
2351 : }
2352 : /**
2353 : * @file
2354 : * Lexer for OpenMP-pragmas.
2355 : */
2356 :
|
