Basilisk CFD
Adaptive Cartesian mesh PDE framework
Loading...
Searching...
No Matches
errors.c
Go to the documentation of this file.
1/** @file errors.c
2 */
3#line 2 "errors.c"
4
5#line 4 "errors.c"
6
7#define YY_INT_ALIGNED short int
8
9/* A lexical scanner generated by flex */
10
11#define yy_create_buffer gpu_errors_create_buffer
12#define yy_delete_buffer gpu_errors_delete_buffer
13#define yy_scan_buffer gpu_errors_scan_buffer
14#define yy_scan_string gpu_errors_scan_string
15#define yy_scan_bytes gpu_errors_scan_bytes
16#define yy_init_buffer gpu_errors_init_buffer
17#define yy_flush_buffer gpu_errors_flush_buffer
18#define yy_load_buffer_state gpu_errors_load_buffer_state
19#define yy_switch_to_buffer gpu_errors_switch_to_buffer
20#define yypush_buffer_state gpu_errorspush_buffer_state
21#define yypop_buffer_state gpu_errorspop_buffer_state
22#define yyensure_buffer_stack gpu_errorsensure_buffer_stack
23#define yy_flex_debug gpu_errors_flex_debug
24#define yyin gpu_errorsin
25#define yyleng gpu_errorsleng
26#define yylex gpu_errorslex
27#define yylineno gpu_errorslineno
28#define yyout gpu_errorsout
29#define yyrestart gpu_errorsrestart
30#define yytext gpu_errorstext
31#define yywrap gpu_errorswrap
32#define yyalloc gpu_errorsalloc
33#define yyrealloc gpu_errorsrealloc
34#define yyfree gpu_errorsfree
35
36#define FLEX_SCANNER
37#define YY_FLEX_MAJOR_VERSION 2
38#define YY_FLEX_MINOR_VERSION 6
39#define YY_FLEX_SUBMINOR_VERSION 4
40#if YY_FLEX_SUBMINOR_VERSION > 0
41#define FLEX_BETA
42#endif
43
44#ifdef yy_create_buffer
45#define gpu_errors_create_buffer_ALREADY_DEFINED
46#else
47#define yy_create_buffer gpu_errors_create_buffer
48#endif
49
50#ifdef yy_delete_buffer
51#define gpu_errors_delete_buffer_ALREADY_DEFINED
52#else
53#define yy_delete_buffer gpu_errors_delete_buffer
54#endif
55
56#ifdef yy_scan_buffer
57#define gpu_errors_scan_buffer_ALREADY_DEFINED
58#else
59#define yy_scan_buffer gpu_errors_scan_buffer
60#endif
61
62#ifdef yy_scan_string
63#define gpu_errors_scan_string_ALREADY_DEFINED
64#else
65#define yy_scan_string gpu_errors_scan_string
66#endif
67
68#ifdef yy_scan_bytes
69#define gpu_errors_scan_bytes_ALREADY_DEFINED
70#else
71#define yy_scan_bytes gpu_errors_scan_bytes
72#endif
73
74#ifdef yy_init_buffer
75#define gpu_errors_init_buffer_ALREADY_DEFINED
76#else
77#define yy_init_buffer gpu_errors_init_buffer
78#endif
79
80#ifdef yy_flush_buffer
81#define gpu_errors_flush_buffer_ALREADY_DEFINED
82#else
83#define yy_flush_buffer gpu_errors_flush_buffer
84#endif
85
86#ifdef yy_load_buffer_state
87#define gpu_errors_load_buffer_state_ALREADY_DEFINED
88#else
89#define yy_load_buffer_state gpu_errors_load_buffer_state
90#endif
91
92#ifdef yy_switch_to_buffer
93#define gpu_errors_switch_to_buffer_ALREADY_DEFINED
94#else
95#define yy_switch_to_buffer gpu_errors_switch_to_buffer
96#endif
97
98#ifdef yypush_buffer_state
99#define gpu_errorspush_buffer_state_ALREADY_DEFINED
100#else
101#define yypush_buffer_state gpu_errorspush_buffer_state
102#endif
103
104#ifdef yypop_buffer_state
105#define gpu_errorspop_buffer_state_ALREADY_DEFINED
106#else
107#define yypop_buffer_state gpu_errorspop_buffer_state
108#endif
109
110#ifdef yyensure_buffer_stack
111#define gpu_errorsensure_buffer_stack_ALREADY_DEFINED
112#else
113#define yyensure_buffer_stack gpu_errorsensure_buffer_stack
114#endif
115
116#ifdef yylex
117#define gpu_errorslex_ALREADY_DEFINED
118#else
119#define yylex gpu_errorslex
120#endif
121
122#ifdef yyrestart
123#define gpu_errorsrestart_ALREADY_DEFINED
124#else
125#define yyrestart gpu_errorsrestart
126#endif
127
128#ifdef yylex_init
129#define gpu_errorslex_init_ALREADY_DEFINED
130#else
131#define yylex_init gpu_errorslex_init
132#endif
133
134#ifdef yylex_init_extra
135#define gpu_errorslex_init_extra_ALREADY_DEFINED
136#else
137#define yylex_init_extra gpu_errorslex_init_extra
138#endif
139
140#ifdef yylex_destroy
141#define gpu_errorslex_destroy_ALREADY_DEFINED
142#else
143#define yylex_destroy gpu_errorslex_destroy
144#endif
145
146#ifdef yyget_debug
147#define gpu_errorsget_debug_ALREADY_DEFINED
148#else
149#define yyget_debug gpu_errorsget_debug
150#endif
151
152#ifdef yyset_debug
153#define gpu_errorsset_debug_ALREADY_DEFINED
154#else
155#define yyset_debug gpu_errorsset_debug
156#endif
157
158#ifdef yyget_extra
159#define gpu_errorsget_extra_ALREADY_DEFINED
160#else
161#define yyget_extra gpu_errorsget_extra
162#endif
163
164#ifdef yyset_extra
165#define gpu_errorsset_extra_ALREADY_DEFINED
166#else
167#define yyset_extra gpu_errorsset_extra
168#endif
169
170#ifdef yyget_in
171#define gpu_errorsget_in_ALREADY_DEFINED
172#else
173#define yyget_in gpu_errorsget_in
174#endif
175
176#ifdef yyset_in
177#define gpu_errorsset_in_ALREADY_DEFINED
178#else
179#define yyset_in gpu_errorsset_in
180#endif
181
182#ifdef yyget_out
183#define gpu_errorsget_out_ALREADY_DEFINED
184#else
185#define yyget_out gpu_errorsget_out
186#endif
187
188#ifdef yyset_out
189#define gpu_errorsset_out_ALREADY_DEFINED
190#else
191#define yyset_out gpu_errorsset_out
192#endif
193
194#ifdef yyget_leng
195#define gpu_errorsget_leng_ALREADY_DEFINED
196#else
197#define yyget_leng gpu_errorsget_leng
198#endif
199
200#ifdef yyget_text
201#define gpu_errorsget_text_ALREADY_DEFINED
202#else
203#define yyget_text gpu_errorsget_text
204#endif
205
206#ifdef yyget_lineno
207#define gpu_errorsget_lineno_ALREADY_DEFINED
208#else
209#define yyget_lineno gpu_errorsget_lineno
210#endif
211
212#ifdef yyset_lineno
213#define gpu_errorsset_lineno_ALREADY_DEFINED
214#else
215#define yyset_lineno gpu_errorsset_lineno
216#endif
217
218#ifdef yywrap
219#define gpu_errorswrap_ALREADY_DEFINED
220#else
221#define yywrap gpu_errorswrap
222#endif
223
224#ifdef yyalloc
225#define gpu_errorsalloc_ALREADY_DEFINED
226#else
227#define yyalloc gpu_errorsalloc
228#endif
229
230#ifdef yyrealloc
231#define gpu_errorsrealloc_ALREADY_DEFINED
232#else
233#define yyrealloc gpu_errorsrealloc
234#endif
235
236#ifdef yyfree
237#define gpu_errorsfree_ALREADY_DEFINED
238#else
239#define yyfree gpu_errorsfree
240#endif
241
242#ifdef yytext
243#define gpu_errorstext_ALREADY_DEFINED
244#else
245#define yytext gpu_errorstext
246#endif
247
248#ifdef yyleng
249#define gpu_errorsleng_ALREADY_DEFINED
250#else
251#define yyleng gpu_errorsleng
252#endif
253
254#ifdef yyin
255#define gpu_errorsin_ALREADY_DEFINED
256#else
257#define yyin gpu_errorsin
258#endif
259
260#ifdef yyout
261#define gpu_errorsout_ALREADY_DEFINED
262#else
263#define yyout gpu_errorsout
264#endif
265
266#ifdef yy_flex_debug
267#define gpu_errors_flex_debug_ALREADY_DEFINED
268#else
269#define yy_flex_debug gpu_errors_flex_debug
270#endif
271
272#ifdef yylineno
273#define gpu_errorslineno_ALREADY_DEFINED
274#else
275#define yylineno gpu_errorslineno
276#endif
277
278/* First, we deal with platform-specific or compiler-specific issues. */
279
280/* begin standard C headers. */
281#include <stdio.h>
282#include <string.h>
283#include <errno.h>
284#include <stdlib.h>
285
286/* end standard C headers. */
287
288/* flex integer type definitions */
289
290#ifndef FLEXINT_H
291#define FLEXINT_H
292
293/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
294
295#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
296
297/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
298 * if you want the limit (max/min) macros for int types.
299 */
300#ifndef __STDC_LIMIT_MACROS
301#define __STDC_LIMIT_MACROS 1
302#endif
303
304#include <inttypes.h>
305typedef int8_t flex_int8_t;
306typedef uint8_t flex_uint8_t;
307typedef int16_t flex_int16_t;
308typedef uint16_t flex_uint16_t;
309typedef int32_t flex_int32_t;
310typedef uint32_t flex_uint32_t;
311#else
312typedef signed char flex_int8_t;
313typedef short int flex_int16_t;
314typedef int flex_int32_t;
315typedef unsigned char flex_uint8_t;
316typedef unsigned short int flex_uint16_t;
317typedef unsigned int flex_uint32_t;
318
319/* Limits of integral types. */
320#ifndef INT8_MIN
321#define INT8_MIN (-128)
322#endif
323#ifndef INT16_MIN
324#define INT16_MIN (-32767-1)
325#endif
326#ifndef INT32_MIN
327#define INT32_MIN (-2147483647-1)
328#endif
329#ifndef INT8_MAX
330#define INT8_MAX (127)
331#endif
332#ifndef INT16_MAX
333#define INT16_MAX (32767)
334#endif
335#ifndef INT32_MAX
336#define INT32_MAX (2147483647)
337#endif
338#ifndef UINT8_MAX
339#define UINT8_MAX (255U)
340#endif
341#ifndef UINT16_MAX
342#define UINT16_MAX (65535U)
343#endif
344#ifndef UINT32_MAX
345#define UINT32_MAX (4294967295U)
346#endif
347
348#ifndef SIZE_MAX
349#define SIZE_MAX (~(size_t)0)
350#endif
351
352#endif /* ! C99 */
353
354#endif /* ! FLEXINT_H */
355
356/* begin standard C++ headers. */
357
358/* TODO: this is always defined, so inline it */
359#define yyconst const
360
361#if defined(__GNUC__) && __GNUC__ >= 3
362#define yynoreturn __attribute__((__noreturn__))
363#else
364#define yynoreturn
365#endif
366
367/* Returned upon end-of-file. */
368#define YY_NULL 0
369
370/* Promotes a possibly negative, possibly signed char to an
371 * integer in range [0..255] for use as an array index.
372 */
373#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
374
375/* Enter a start condition. This macro really ought to take a parameter,
376 * but we do it the disgusting crufty way forced on us by the ()-less
377 * definition of BEGIN.
378 */
379#define BEGIN (yy_start) = 1 + 2 *
380/* Translate the current start state into a value that can be later handed
381 * to BEGIN to return to the state. The YYSTATE alias is for lex
382 * compatibility.
383 */
384#define YY_START (((yy_start) - 1) / 2)
385#define YYSTATE YY_START
386/* Action number for EOF rule of a given start state. */
387#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
388/* Special action meaning "start processing a new file". */
389#define YY_NEW_FILE yyrestart( yyin )
390#define YY_END_OF_BUFFER_CHAR 0
391
392/* Size of default input buffer. */
393#ifndef YY_BUF_SIZE
394#ifdef __ia64__
395/* On IA-64, the buffer size is 16k, not 8k.
396 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
397 * Ditto for the __ia64__ case accordingly.
398 */
399#define YY_BUF_SIZE 32768
400#else
401#define YY_BUF_SIZE 16384
402#endif /* __ia64__ */
403#endif
404
405/* The state buf must be large enough to hold one state per character in the main buffer.
406 */
407#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
408
409#ifndef YY_TYPEDEF_YY_BUFFER_STATE
410#define YY_TYPEDEF_YY_BUFFER_STATE
412#endif
413
414#ifndef YY_TYPEDEF_YY_SIZE_T
415#define YY_TYPEDEF_YY_SIZE_T
416typedef size_t yy_size_t;
417#endif
418
419extern int yyleng;
420
421extern FILE *yyin, *yyout;
422
423#define EOB_ACT_CONTINUE_SCAN 0
424#define EOB_ACT_END_OF_FILE 1
425#define EOB_ACT_LAST_MATCH 2
426
427 /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
428 * access to the local variable yy_act. Since yyless() is a macro, it would break
429 * existing scanners that call yyless() from OUTSIDE yylex.
430 * One obvious solution it to make yy_act a global. I tried that, and saw
431 * a 5% performance hit in a non-yylineno scanner, because yy_act is
432 * normally declared as a register variable-- so it is not worth it.
433 */
434 #define YY_LESS_LINENO(n) \
435 do { \
436 int yyl;\
437 for ( yyl = n; yyl < yyleng; ++yyl )\
438 if ( yytext[yyl] == '\n' )\
439 --yylineno;\
440 }while(0)
441 #define YY_LINENO_REWIND_TO(dst) \
442 do {\
443 const char *p;\
444 for ( p = yy_cp-1; p >= (dst); --p)\
445 if ( *p == '\n' )\
446 --yylineno;\
447 }while(0)
448
449/* Return all but the first "n" matched characters back to the input stream. */
450#define yyless(n) \
451 do \
452 { \
453 /* Undo effects of setting up yytext. */ \
454 int yyless_macro_arg = (n); \
455 YY_LESS_LINENO(yyless_macro_arg);\
456 *yy_cp = (yy_hold_char); \
457 YY_RESTORE_YY_MORE_OFFSET \
458 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
459 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
460 } \
461 while ( 0 )
462#define unput(c) yyunput( c, (yytext_ptr) )
463
464#ifndef YY_STRUCT_YY_BUFFER_STATE
465#define YY_STRUCT_YY_BUFFER_STATE
467 {
469
470 char *yy_ch_buf; /* input buffer */
471 char *yy_buf_pos; /* current position in input buffer */
472
473 /* Size of input buffer in bytes, not including room for EOB
474 * characters.
475 */
477
478 /* Number of characters read into yy_ch_buf, not including EOB
479 * characters.
480 */
482
483 /* Whether we "own" the buffer - i.e., we know we created it,
484 * and can realloc() it to grow it, and should free() it to
485 * delete it.
486 */
488
489 /* Whether this is an "interactive" input source; if so, and
490 * if we're using stdio for input, then we want to use getc()
491 * instead of fread(), to make sure we stop fetching input after
492 * each newline.
493 */
495
496 /* Whether we're considered to be at the beginning of a line.
497 * If so, '^' rules will be active on the next match, otherwise
498 * not.
499 */
501
502 int yy_bs_lineno; /**< The line count. */
503 int yy_bs_column; /**< The column count. */
504
505 /* Whether to try to fill the input buffer when we reach the
506 * end of it.
507 */
509
511
512#define YY_BUFFER_NEW 0
513#define YY_BUFFER_NORMAL 1
514 /* When an EOF's been seen but there's still some text to process
515 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
516 * shouldn't try reading from the input source any more. We might
517 * still have a bunch of tokens to match, though, because of
518 * possible backing-up.
519 *
520 * When we actually see the EOF, we change the status to "new"
521 * (via yyrestart()), so that the user can continue scanning by
522 * just pointing yyin at a new input file.
523 */
524#define YY_BUFFER_EOF_PENDING 2
525
526 };
527#endif /* !YY_STRUCT_YY_BUFFER_STATE */
528
529/* Stack of input buffers. */
530static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
531static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
532static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
533
534/* We provide macros for accessing buffer states in case in the
535 * future we want to put the buffer states in a more general
536 * "scanner state".
537 *
538 * Returns the top of the stack, or NULL.
539 */
540#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
541 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
542 : NULL)
543/* Same as previous macro, but useful when we know that the buffer stack is not
544 * NULL or when we need an lvalue. For internal use only.
545 */
546#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
547
548/* yy_hold_char holds the character lost when yytext is formed. */
549static char yy_hold_char;
550static int yy_n_chars; /* number of characters read into yy_ch_buf */
552
553/* Points to current character in buffer. */
554static char *yy_c_buf_p = NULL;
555static int yy_init = 0; /* whether we need to initialize */
556static int yy_start = 0; /* start state number */
557
558/* Flag which is used to allow yywrap()'s to do buffer switches
559 * instead of setting up a fresh yyin. A bit of a hack ...
560 */
562
563void yyrestart ( FILE *input_file );
569void yypop_buffer_state ( void );
570
571static void yyensure_buffer_stack ( void );
572static void yy_load_buffer_state ( void );
573static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
574#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
575
578YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
579
580void *yyalloc ( yy_size_t );
581void *yyrealloc ( void *, yy_size_t );
582void yyfree ( void * );
583
584#define yy_new_buffer yy_create_buffer
585#define yy_set_interactive(is_interactive) \
586 { \
587 if ( ! YY_CURRENT_BUFFER ){ \
588 yyensure_buffer_stack (); \
589 YY_CURRENT_BUFFER_LVALUE = \
590 yy_create_buffer( yyin, YY_BUF_SIZE ); \
591 } \
592 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
593 }
594#define yy_set_bol(at_bol) \
595 { \
596 if ( ! YY_CURRENT_BUFFER ){\
597 yyensure_buffer_stack (); \
598 YY_CURRENT_BUFFER_LVALUE = \
599 yy_create_buffer( yyin, YY_BUF_SIZE ); \
600 } \
601 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
602 }
603#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
604
605/* Begin user sect3 */
606
607#define gpu_errorswrap() (/*CONSTCOND*/1)
608#define YY_SKIP_YYWRAP
610
612
613typedef int yy_state_type;
614
615extern int yylineno;
616int yylineno = 1;
617
618extern char *yytext;
619#ifdef yytext_ptr
620#undef yytext_ptr
621#endif
622#define yytext_ptr yytext
623
626static int yy_get_next_buffer ( void );
627static void yynoreturn yy_fatal_error ( const char* msg );
628
629/* Done after the current pattern has been matched and before the
630 * corresponding action - sets up yytext.
631 */
632#define YY_DO_BEFORE_ACTION \
633 (yytext_ptr) = yy_bp; \
634 yyleng = (int) (yy_cp - yy_bp); \
635 (yy_hold_char) = *yy_cp; \
636 *yy_cp = '\0'; \
637 (yy_c_buf_p) = yy_cp;
638#define YY_NUM_RULES 5
639#define YY_END_OF_BUFFER 6
640/* This struct is not used in this scanner,
641 but its presence is necessary. */
647static const flex_int16_t yy_accept[25] =
648 { 0,
649 0, 0, 6, 4, 3, 4, 4, 0, 2, 0,
650 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
651 0, 1, 0, 0
652 } ;
653
654static const YY_CHAR yy_ec[256] =
655 { 0,
656 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
657 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
658 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
659 1, 2, 1, 4, 5, 1, 1, 1, 1, 1,
660 1, 1, 1, 1, 1, 1, 6, 7, 7, 7,
661 7, 7, 7, 7, 7, 7, 7, 1, 1, 1,
662 1, 1, 1, 8, 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 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
666
667 9, 1, 1, 1, 10, 1, 1, 11, 1, 12,
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, 1, 1, 1, 1, 1,
672 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
673 1, 1, 1, 1, 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
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 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
682 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
683 1, 1, 1, 1, 1
684 } ;
685
686static const YY_CHAR yy_meta[13] =
687 { 0,
688 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
689 1, 1
690 } ;
691
692static const flex_int16_t yy_base[28] =
693 { 0,
694 0, 6, 23, 42, 42, 14, 15, 12, 42, 13,
695 0, 17, 10, 6, 27, 1, 33, 1, 3, 4,
696 1, 0, 0, 42, 37, 39, 0
697 } ;
698
699static const flex_int16_t yy_def[28] =
700 { 0,
701 25, 25, 24, 24, 24, 26, 24, 26, 24, 24,
702 10, 24, 12, 24, 24, 24, 24, 24, 27, 24,
703 27, 27, 15, 0, 24, 24, 24
704 } ;
705
706static const flex_int16_t yy_nxt[55] =
707 { 0,
708 21, 23, 5, 22, 22, 23, 22, 6, 5, 20,
709 24, 7, 18, 6, 11, 16, 15, 12, 13, 9,
710 10, 9, 24, 24, 24, 24, 24, 14, 17, 24,
711 24, 24, 24, 15, 17, 24, 19, 4, 4, 8,
712 8, 3, 24, 24, 24, 24, 24, 24, 24, 24,
713 24, 24, 24, 24
714 } ;
715
716static const flex_int16_t yy_chk[55] =
717 { 0,
718 27, 23, 1, 22, 21, 20, 19, 1, 2, 18,
719 0, 2, 16, 2, 10, 14, 13, 10, 12, 8,
720 7, 6, 3, 0, 0, 0, 0, 12, 15, 0,
721 0, 0, 0, 15, 17, 0, 17, 25, 25, 26,
722 26, 24, 24, 24, 24, 24, 24, 24, 24, 24,
723 24, 24, 24, 24
724 } ;
725
726/* Table of booleans, true if rule could match eol. */
728 { 0,
7290, 1, 1, 0, 0, };
730
733
734extern int yy_flex_debug;
736
737/* The intent behind this definition is that it'll catch
738 * any uses of REJECT which flex missed.
739 */
740#define REJECT reject_used_but_not_detected
741#define yymore() yymore_used_but_not_detected
742#define YY_MORE_ADJ 0
743#define YY_RESTORE_YY_MORE_OFFSET
744char *yytext;
745#line 1 "errors.lex"
746#define YY_NO_INPUT 1
747#line 5 "errors.lex"
748
749 /**
750 # Error message parsing for compilation of GLSL code on GPUs
751 */
752 static char * sout;
753 static char * fname;
754 static int line;
755
756 static char * str_append (char * dst, const char * src) {
757 if (dst == NULL) {
758 dst = malloc (strlen(src) + 1);
759 dst[0] = '\0';
760 }
761 else
762 dst = realloc (dst, strlen(dst) + strlen(src) + 1);
763 strcat (dst, src);
764 return dst;
765 }
766
767 static int atoi_check (char * start, char * end)
768 {
769 char * s = start;
770 while (s != end) {
771 if (*s < '0' || *s > '9')
772 return -1;
773 s++;
774 }
775 *end = '\0';
776 return atoi (start);
777 }
778
779 /* parse Intel GPU error messages of the form:
780 0:31(15):... */
781 static int parse_intel (const char * errors, const char ** msg)
782 {
783 char * end = strchr (errors, '\n');
784 char * sline = strchr (errors, ':');
785 if (!sline) return -1; sline++;
786 if (end && end < sline) return -1;
787 char * s1 = strchr (sline, '(');
788 if (!s1) return -1;
789 *msg = strchr (s1, ':');
790 if (!*msg) return -1; (*msg)++;
791 return atoi_check (sline, s1);
792 }
793
794 /* parse Nvidia GPU error messages of the form:
795 0(31) :... */
796 static int parse_nvidia (const char * errors, const char ** msg)
797 {
798 char * end = strchr (errors, '\n');
799 char * sline = strchr (errors, '(');
800 if (!sline) return -1; sline++;
801 if (end && end < sline) return -1;
802 char * s1 = strchr (sline, ')');
803 if (!s1) return -1;
804 *msg = strchr (s1, ':');
805 if (!*msg) return -1; (*msg)++;
806 return atoi_check (sline, s1);
807 }
808
809 static char * next_error (const char * errors, int * line, const char ** msg)
810 {
811 if (!errors || *errors == '\0')
812 return NULL;
813
815 if (*line < 0)
817 if (*line < 0) {
818 // unknown error format: assumes first line
819 *line = 1;
820 *msg = errors;
821 }
822
823 while (strchr (" \t", **msg)) (*msg)++;
824
825 char * s3 = strchr (*msg, '\n');
826 if (s3) {
827 *s3 = '\0';
828 s3++;
829 }
830
831 return s3;
832 }
833
834 static char * merge (const char * source, const char * errors)
835 {
836 char * merged = NULL;
837 const char * msg;
838 int eline, line = 1;
839 char * error = next_error (errors, &eline, &msg);
840 char * src = strdup (source), * s = src;
841 while (*s != '\0') {
842 if (*s == '\n') {
843 while (error && eline <= line) {
844 merged = str_append (merged, "@");
845 if (eline != line)
846 merged = str_append (merged, "!");
848 merged = str_append (merged, "@");
850 }
851 line++;
852 }
853 char c[] = " ";
854 c[0] = *s;
856 s++;
857 }
858 free (src);
859 return merged;
860 }
861#line 860 "errors.c"
862#line 861 "errors.c"
863
864#define INITIAL 0
865
866#ifndef YY_NO_UNISTD_H
867/* Special case for "unistd.h", since it is non-ANSI. We include it way
868 * down here because we want the user's section 1 to have been scanned first.
869 * The user has a chance to override it with an option.
870 */
871#include <unistd.h>
872#endif
873
874#ifndef YY_EXTRA_TYPE
875#define YY_EXTRA_TYPE void *
876#endif
877
878static int yy_init_globals ( void );
879
880/* Accessor methods to globals.
881 These are made visible to non-reentrant scanners for convenience. */
882
883int yylex_destroy ( void );
884
885int yyget_debug ( void );
886
887void yyset_debug ( int debug_flag );
888
890
892
893FILE *yyget_in ( void );
894
895void yyset_in ( FILE * _in_str );
896
897FILE *yyget_out ( void );
898
899void yyset_out ( FILE * _out_str );
900
901 int yyget_leng ( void );
902
903char *yyget_text ( void );
904
905int yyget_lineno ( void );
906
907void yyset_lineno ( int _line_number );
908
909/* Macros after this point can all be overridden by user definitions in
910 * section 1.
911 */
912
913#ifndef YY_SKIP_YYWRAP
914#ifdef __cplusplus
915extern "C" int yywrap ( void );
916#else
917extern int yywrap ( void );
918#endif
919#endif
920
921#ifndef YY_NO_UNPUT
922
923 static void yyunput ( int c, char *buf_ptr );
924
925#endif
926
927#ifndef yytext_ptr
928static void yy_flex_strncpy ( char *, const char *, int );
929#endif
930
931#ifdef YY_NEED_STRLEN
932static int yy_flex_strlen ( const char * );
933#endif
934
935#ifndef YY_NO_INPUT
936#ifdef __cplusplus
937static int yyinput ( void );
938#else
939static int input ( void );
940#endif
941
942#endif
943
944/* Amount of stuff to slurp up with each read. */
945#ifndef YY_READ_BUF_SIZE
946#ifdef __ia64__
947/* On IA-64, the buffer size is 16k, not 8k */
948#define YY_READ_BUF_SIZE 16384
949#else
950#define YY_READ_BUF_SIZE 8192
951#endif /* __ia64__ */
952#endif
953
954/* Copy whatever the last rule matched to the standard output. */
955#ifndef ECHO
956/* This used to be an fputs(), but since the string might contain NUL's,
957 * we now use fwrite().
958 */
959#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
960#endif
961
962/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
963 * is returned in "result".
964 */
965#ifndef YY_INPUT
966#define YY_INPUT(buf,result,max_size) \
967 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
968 { \
969 int c = '*'; \
970 int n; \
971 for ( n = 0; n < max_size && \
972 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
973 buf[n] = (char) c; \
974 if ( c == '\n' ) \
975 buf[n++] = (char) c; \
976 if ( c == EOF && ferror( yyin ) ) \
977 YY_FATAL_ERROR( "input in flex scanner failed" ); \
978 result = n; \
979 } \
980 else \
981 { \
982 errno=0; \
983 while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
984 { \
985 if( errno != EINTR) \
986 { \
987 YY_FATAL_ERROR( "input in flex scanner failed" ); \
988 break; \
989 } \
990 errno=0; \
991 clearerr(yyin); \
992 } \
993 }\
994\
995
996#endif
997
998/* No semi-colon after return; correct usage is to write "yyterminate();" -
999 * we don't want an extra ';' after the "return" because that will cause
1000 * some compilers to complain about unreachable statements.
1001 */
1002#ifndef yyterminate
1003#define yyterminate() return YY_NULL
1004#endif
1005
1006/* Number of entries by which start-condition stack grows. */
1007#ifndef YY_START_STACK_INCR
1008#define YY_START_STACK_INCR 25
1009#endif
1010
1011/* Report a fatal error. */
1012#ifndef YY_FATAL_ERROR
1013#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1014#endif
1015
1016/* end tables serialization structures and prototypes */
1017
1018/* Default declaration of generated scanner - a define so the user can
1019 * easily add parameters.
1020 */
1021#ifndef YY_DECL
1022#define YY_DECL_IS_OURS 1
1023
1024extern int yylex (void);
1025
1026#define YY_DECL int yylex (void)
1027#endif /* !YY_DECL */
1028
1029/* Code executed at the beginning of each rule, after yytext and yyleng
1030 * have been set up.
1031 */
1032#ifndef YY_USER_ACTION
1033#define YY_USER_ACTION
1034#endif
1035
1036/* Code executed at the end of each rule. */
1037#ifndef YY_BREAK
1038#define YY_BREAK /*LINTED*/break;
1039#endif
1040
1041#define YY_RULE_SETUP \
1042 if ( yyleng > 0 ) \
1043 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
1044 (yytext[yyleng - 1] == '\n'); \
1045 YY_USER_ACTION
1046
1047/** The main scanner function which does all the work.
1048 */
1050{
1052 char *yy_cp, *yy_bp;
1053 int yy_act;
1054
1055 if ( !(yy_init) )
1056 {
1057 (yy_init) = 1;
1058
1059#ifdef YY_USER_INIT
1061#endif
1062
1063 if ( ! (yy_start) )
1064 (yy_start) = 1; /* first start state */
1065
1066 if ( ! yyin )
1067 yyin = stdin;
1068
1069 if ( ! yyout )
1070 yyout = stdout;
1071
1072 if ( ! YY_CURRENT_BUFFER ) {
1076 }
1077
1079 }
1080
1081 {
1082#line 125 "errors.lex"
1083
1084
1085#line 1084 "errors.c"
1086
1087 while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
1088 {
1089 yy_cp = (yy_c_buf_p);
1090
1091 /* Support of yytext. */
1092 *yy_cp = (yy_hold_char);
1093
1094 /* yy_bp points to the position in yy_ch_buf of the start of
1095 * the current run.
1096 */
1097 yy_bp = yy_cp;
1098
1101yy_match:
1102 do
1103 {
1106 {
1109 }
1111 {
1113 if ( yy_current_state >= 25 )
1114 yy_c = yy_meta[yy_c];
1115 }
1117 ++yy_cp;
1118 }
1119 while ( yy_base[yy_current_state] != 42 );
1120
1123 if ( yy_act == 0 )
1124 { /* have to back up */
1128 }
1129
1131
1133 {
1134 int yyl;
1135 for ( yyl = 0; yyl < yyleng; ++yyl )
1136 if ( yytext[yyl] == '\n' )
1137
1138 yylineno++;
1139;
1140 }
1141
1142do_action: /* This label is used only to access EOF actions. */
1143
1144 switch ( yy_act )
1145 { /* beginning of action switch */
1146 case 0: /* must back up */
1147 /* undo the effects of YY_DO_BEFORE_ACTION */
1148 *yy_cp = (yy_hold_char);
1151 goto yy_find_action;
1152
1153case 1:
1155#line 127 "errors.lex"
1156{
1157 char * sline = yytext;
1158 while (!strchr ("0123456789", *sline)) sline++;
1159 line = atoi (sline) - 1;
1160
1161 if (strchr (yytext, '"')) {
1162 fname = sline; while (*fname >= '0' && *fname <= '9') fname++;
1163 *fname = '\0'; fname++;
1164 fname = strchr (fname, '"'); fname++;
1165 *strchr (fname, '"') = '\0';
1166 }
1167}
1168 YY_BREAK
1169case 2:
1170/* rule 2 can match eol */
1172#line 140 "errors.lex"
1173{
1174 if (0) // !strncmp (yytext, "@error ", 7))
1175 yytext += 6;
1176 else {
1177 if (fname)
1179 else
1180 sout = str_append (sout, "(fragment shader)");
1181 sout = str_append (sout, ":");
1182 char s[81];
1183 snprintf (s, 80, "%d", line);
1184 sout = str_append (sout, s);
1185 sout = str_append (sout, ": GLSL: ");
1186 }
1187 *strchr (yytext + 1, '@') = '\0';
1188 sout = str_append (sout, yytext + 1);
1189 sout = str_append (sout, "\n");
1190}
1191 YY_BREAK
1192case 3:
1193/* rule 3 can match eol */
1195#line 159 "errors.lex"
1196{ line++; }
1197 YY_BREAK
1198case 4:
1200#line 161 "errors.lex"
1201; // very important!!
1202 YY_BREAK
1203case 5:
1205#line 163 "errors.lex"
1206ECHO;
1207 YY_BREAK
1208#line 1207 "errors.c"
1209case YY_STATE_EOF(INITIAL):
1210 yyterminate();
1211
1212 case YY_END_OF_BUFFER:
1213 {
1214 /* Amount of text matched not including the EOB char. */
1216
1217 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1218 *yy_cp = (yy_hold_char);
1220
1221 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1222 {
1223 /* We're scanning a new file or input source. It's
1224 * possible that this happened because the user
1225 * just pointed yyin at a new source and called
1226 * yylex(). If so, then we have to assure
1227 * consistency between YY_CURRENT_BUFFER and our
1228 * globals. Here is the right place to do so, because
1229 * this is the first action (other than possibly a
1230 * back-up) that will match for the new input source.
1231 */
1232 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1233 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1234 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1235 }
1236
1237 /* Note that here we test for yy_c_buf_p "<=" to the position
1238 * of the first EOB in the buffer, since yy_c_buf_p will
1239 * already have been incremented past the NUL character
1240 * (since all states make transitions on EOB to the
1241 * end-of-buffer state). Contrast this with the test
1242 * in input().
1243 */
1244 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1245 { /* This was really a NUL. */
1247
1249
1251
1252 /* Okay, we're now positioned to make the NUL
1253 * transition. We couldn't have
1254 * yy_get_previous_state() go ahead and do it
1255 * for us because it doesn't know how to deal
1256 * with the possibility of jamming (and we don't
1257 * want to build jamming into it because then it
1258 * will run more slowly).
1259 */
1260
1262
1264
1265 if ( yy_next_state )
1266 {
1267 /* Consume the NUL. */
1268 yy_cp = ++(yy_c_buf_p);
1270 goto yy_match;
1271 }
1272
1273 else
1274 {
1275 yy_cp = (yy_c_buf_p);
1276 goto yy_find_action;
1277 }
1278 }
1279
1280 else switch ( yy_get_next_buffer( ) )
1281 {
1283 {
1285
1286 if ( yywrap( ) )
1287 {
1288 /* Note: because we've taken care in
1289 * yy_get_next_buffer() to have set up
1290 * yytext, we can now set up
1291 * yy_c_buf_p so that if some total
1292 * hoser (like flex itself) wants to
1293 * call the scanner after we return the
1294 * YY_NULL, it'll still work - another
1295 * YY_NULL will get returned.
1296 */
1298
1300 goto do_action;
1301 }
1302
1303 else
1304 {
1307 }
1308 break;
1309 }
1310
1312 (yy_c_buf_p) =
1314
1316
1317 yy_cp = (yy_c_buf_p);
1319 goto yy_match;
1320
1321 case EOB_ACT_LAST_MATCH:
1322 (yy_c_buf_p) =
1323 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1324
1326
1327 yy_cp = (yy_c_buf_p);
1329 goto yy_find_action;
1330 }
1331 break;
1332 }
1333
1334 default:
1336 "fatal flex scanner internal error--no action found" );
1337 } /* end of action switch */
1338 } /* end of scanning one token */
1339 } /* end of user's declarations */
1340} /* end of yylex */
1341
1342/* yy_get_next_buffer - try to read in a new buffer
1343 *
1344 * Returns a code representing an action:
1345 * EOB_ACT_LAST_MATCH -
1346 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1347 * EOB_ACT_END_OF_FILE - end of file
1348 */
1349static int yy_get_next_buffer (void)
1350{
1351 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1352 char *source = (yytext_ptr);
1353 int number_to_move, i;
1354 int ret_val;
1355
1356 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1358 "fatal flex scanner internal error--end of buffer missed" );
1359
1360 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1361 { /* Don't try to fill the buffer, so this is an EOF. */
1362 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1363 {
1364 /* We matched a single character, the EOB, so
1365 * treat this as a final EOF.
1366 */
1367 return EOB_ACT_END_OF_FILE;
1368 }
1369
1370 else
1371 {
1372 /* We matched some text prior to the EOB, first
1373 * process it.
1374 */
1375 return EOB_ACT_LAST_MATCH;
1376 }
1377 }
1378
1379 /* Try to read more data. */
1380
1381 /* First move last chars to start of buffer. */
1382 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1383
1384 for ( i = 0; i < number_to_move; ++i )
1385 *(dest++) = *(source++);
1386
1387 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1388 /* don't do the read, it's not guaranteed to return an EOF,
1389 * just force an EOF
1390 */
1391 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1392
1393 else
1394 {
1395 int num_to_read =
1396 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1397
1398 while ( num_to_read <= 0 )
1399 { /* Not enough room in the buffer - grow it. */
1400
1401 /* just a shorter name for the current buffer */
1403
1404 int yy_c_buf_p_offset =
1405 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1406
1407 if ( b->yy_is_our_buffer )
1408 {
1409 int new_size = b->yy_buf_size * 2;
1410
1411 if ( new_size <= 0 )
1412 b->yy_buf_size += b->yy_buf_size / 8;
1413 else
1414 b->yy_buf_size *= 2;
1415
1416 b->yy_ch_buf = (char *)
1417 /* Include room in for 2 EOB chars. */
1418 yyrealloc( (void *) b->yy_ch_buf,
1419 (yy_size_t) (b->yy_buf_size + 2) );
1420 }
1421 else
1422 /* Can't grow it, we don't own it. */
1423 b->yy_ch_buf = NULL;
1424
1425 if ( ! b->yy_ch_buf )
1427 "fatal error - scanner input buffer overflow" );
1428
1429 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1430
1431 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1432 number_to_move - 1;
1433
1434 }
1435
1438
1439 /* Read in more data. */
1442
1443 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1444 }
1445
1446 if ( (yy_n_chars) == 0 )
1447 {
1448 if ( number_to_move == YY_MORE_ADJ )
1449 {
1451 yyrestart( yyin );
1452 }
1453
1454 else
1455 {
1457 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1459 }
1460 }
1461
1462 else
1464
1465 if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1466 /* Extend the array by 50%, plus the number we really need. */
1467 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1468 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1469 (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
1470 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1471 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1472 /* "- 2" to take care of EOB's */
1473 YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1474 }
1475
1479
1480 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1481
1482 return ret_val;
1483}
1484
1485/* yy_get_previous_state - get the state just before the EOB char was reached */
1486
1488{
1490 char *yy_cp;
1491
1494
1495 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1496 {
1497 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1499 {
1502 }
1504 {
1506 if ( yy_current_state >= 25 )
1507 yy_c = yy_meta[yy_c];
1508 }
1510 }
1511
1512 return yy_current_state;
1513}
1514
1515/* yy_try_NUL_trans - try to make a transition on the NUL character
1516 *
1517 * synopsis
1518 * next_state = yy_try_NUL_trans( current_state );
1519 */
1521{
1522 int yy_is_jam;
1523 char *yy_cp = (yy_c_buf_p);
1524
1525 YY_CHAR yy_c = 1;
1527 {
1530 }
1532 {
1534 if ( yy_current_state >= 25 )
1535 yy_c = yy_meta[yy_c];
1536 }
1538 yy_is_jam = (yy_current_state == 24);
1539
1540 return yy_is_jam ? 0 : yy_current_state;
1541}
1542
1543#ifndef YY_NO_UNPUT
1544
1545 static void yyunput (int c, char * yy_bp )
1546{
1547 char *yy_cp;
1548
1549 yy_cp = (yy_c_buf_p);
1550
1551 /* undo effects of setting up yytext */
1552 *yy_cp = (yy_hold_char);
1553
1554 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1555 { /* need to shift things up to make room */
1556 /* +2 for EOB chars. */
1557 int number_to_move = (yy_n_chars) + 2;
1558 char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1559 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1560 char *source =
1562
1563 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1564 *--dest = *--source;
1565
1566 yy_cp += (int) (dest - source);
1567 yy_bp += (int) (dest - source);
1568 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1569 (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1570
1571 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1572 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1573 }
1574
1575 *--yy_cp = (char) c;
1576
1577 if ( c == '\n' ){
1578 --yylineno;
1579 }
1580
1581 (yytext_ptr) = yy_bp;
1582 (yy_hold_char) = *yy_cp;
1583 (yy_c_buf_p) = yy_cp;
1584}
1585
1586#endif
1587
1588#ifndef YY_NO_INPUT
1589#ifdef __cplusplus
1590 static int yyinput (void)
1591#else
1592 static int input (void)
1593#endif
1594
1595{
1596 int c;
1597
1598 *(yy_c_buf_p) = (yy_hold_char);
1599
1601 {
1602 /* yy_c_buf_p now points to the character we want to return.
1603 * If this occurs *before* the EOB characters, then it's a
1604 * valid NUL; if not, then we've hit the end of the buffer.
1605 */
1606 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1607 /* This was really a NUL. */
1608 *(yy_c_buf_p) = '\0';
1609
1610 else
1611 { /* need more input */
1612 int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
1613 ++(yy_c_buf_p);
1614
1615 switch ( yy_get_next_buffer( ) )
1616 {
1617 case EOB_ACT_LAST_MATCH:
1618 /* This happens because yy_g_n_b()
1619 * sees that we've accumulated a
1620 * token and flags that we need to
1621 * try matching the token before
1622 * proceeding. But for input(),
1623 * there's no matching to consider.
1624 * So convert the EOB_ACT_LAST_MATCH
1625 * to EOB_ACT_END_OF_FILE.
1626 */
1627
1628 /* Reset buffer status. */
1629 yyrestart( yyin );
1630
1631 /*FALLTHROUGH*/
1632
1634 {
1635 if ( yywrap( ) )
1636 return 0;
1637
1640#ifdef __cplusplus
1641 return yyinput();
1642#else
1643 return input();
1644#endif
1645 }
1646
1648 (yy_c_buf_p) = (yytext_ptr) + offset;
1649 break;
1650 }
1651 }
1652 }
1653
1654 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1655 *(yy_c_buf_p) = '\0'; /* preserve yytext */
1656 (yy_hold_char) = *++(yy_c_buf_p);
1657
1658 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
1659 if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )
1660
1661 yylineno++;
1662;
1663
1664 return c;
1665}
1666#endif /* ifndef YY_NO_INPUT */
1667
1668/** Immediately switch to a different input stream.
1669 * @param input_file A readable stream.
1670 *
1671 * @note This function does not reset the start condition to @c INITIAL .
1672 */
1685
1686/** Switch to a different input buffer.
1687 * @param new_buffer The new input buffer.
1688 *
1689 */
1691{
1692
1693 /* TODO. We should be able to replace this entire function body
1694 * with
1695 * yypop_buffer_state();
1696 * yypush_buffer_state(new_buffer);
1697 */
1700 return;
1701
1702 if ( YY_CURRENT_BUFFER )
1703 {
1704 /* Flush out information for old buffer. */
1705 *(yy_c_buf_p) = (yy_hold_char);
1706 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1707 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1708 }
1709
1712
1713 /* We don't actually know whether we did this switch during
1714 * EOF (yywrap()) processing, but the only time this flag
1715 * is looked at is after yywrap() is called, so it's safe
1716 * to go ahead and always set it.
1717 */
1719}
1720
1721static void yy_load_buffer_state (void)
1722{
1723 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1725 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1726 (yy_hold_char) = *(yy_c_buf_p);
1727}
1728
1729/** Allocate and initialize an input buffer state.
1730 * @param file A readable stream.
1731 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1732 *
1733 * @return the allocated buffer state.
1734 */
1736{
1738
1739 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1740 if ( ! b )
1741 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1742
1743 b->yy_buf_size = size;
1744
1745 /* yy_ch_buf has to be 2 characters longer than the size given because
1746 * we need to put in 2 end-of-buffer characters.
1747 */
1748 b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
1749 if ( ! b->yy_ch_buf )
1750 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1751
1752 b->yy_is_our_buffer = 1;
1753
1754 yy_init_buffer( b, file );
1755
1756 return b;
1757}
1758
1759/** Destroy the buffer.
1760 * @param b a buffer created with yy_create_buffer()
1761 *
1762 */
1764{
1765
1766 if ( ! b )
1767 return;
1768
1769 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1771
1772 if ( b->yy_is_our_buffer )
1773 yyfree( (void *) b->yy_ch_buf );
1774
1775 yyfree( (void *) b );
1776}
1777
1778/* Initializes or reinitializes a buffer.
1779 * This function is sometimes called more than once on the same buffer,
1780 * such as during a yyrestart() or at EOF.
1781 */
1783
1784{
1785 int oerrno = errno;
1786
1787 yy_flush_buffer( b );
1788
1789 b->yy_input_file = file;
1790 b->yy_fill_buffer = 1;
1791
1792 /* If b is the current buffer, then yy_init_buffer was _probably_
1793 * called from yyrestart() or through yy_get_next_buffer.
1794 * In that case, we don't want to reset the lineno or column.
1795 */
1796 if (b != YY_CURRENT_BUFFER){
1797 b->yy_bs_lineno = 1;
1798 b->yy_bs_column = 0;
1799 }
1800
1801 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1802
1803 errno = oerrno;
1804}
1805
1806/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1807 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1808 *
1809 */
1811{
1812 if ( ! b )
1813 return;
1814
1815 b->yy_n_chars = 0;
1816
1817 /* We always need two end-of-buffer characters. The first causes
1818 * a transition to the end-of-buffer state. The second causes
1819 * a jam in that state.
1820 */
1821 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1822 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1823
1824 b->yy_buf_pos = &b->yy_ch_buf[0];
1825
1826 b->yy_at_bol = 1;
1827 b->yy_buffer_status = YY_BUFFER_NEW;
1828
1829 if ( b == YY_CURRENT_BUFFER )
1831}
1832
1833/** Pushes the new state onto the stack. The new state becomes
1834 * the current state. This function will allocate the stack
1835 * if necessary.
1836 * @param new_buffer The new state.
1837 *
1838 */
1840{
1841 if (new_buffer == NULL)
1842 return;
1843
1845
1846 /* This block is copied from yy_switch_to_buffer. */
1847 if ( YY_CURRENT_BUFFER )
1848 {
1849 /* Flush out information for old buffer. */
1850 *(yy_c_buf_p) = (yy_hold_char);
1851 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1852 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1853 }
1854
1855 /* Only push if top exists. Otherwise, replace top. */
1859
1860 /* copied from yy_switch_to_buffer. */
1863}
1864
1865/** Removes and deletes the top of the stack, if present.
1866 * The next element becomes the new top.
1867 *
1868 */
1870{
1871 if (!YY_CURRENT_BUFFER)
1872 return;
1873
1876 if ((yy_buffer_stack_top) > 0)
1878
1879 if (YY_CURRENT_BUFFER) {
1882 }
1883}
1884
1885/* Allocates the stack if it does not exist.
1886 * Guarantees space for at least one push.
1887 */
1888static void yyensure_buffer_stack (void)
1889{
1891
1892 if (!(yy_buffer_stack)) {
1893
1894 /* First allocation is just for 2 elements, since we don't know if this
1895 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1896 * immediate realloc on the next call.
1897 */
1898 num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1900 (num_to_alloc * sizeof(struct yy_buffer_state*)
1901 );
1902 if ( ! (yy_buffer_stack) )
1903 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1904
1905 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1906
1908 (yy_buffer_stack_top) = 0;
1909 return;
1910 }
1911
1912 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1913
1914 /* Increase the buffer to prepare for a possible push. */
1915 yy_size_t grow_size = 8 /* arbitrary grow size */;
1916
1919 ((yy_buffer_stack),
1920 num_to_alloc * sizeof(struct yy_buffer_state*)
1921 );
1922 if ( ! (yy_buffer_stack) )
1923 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1924
1925 /* zero only the new slots.*/
1928 }
1929}
1930
1931/** Setup the input buffer state to scan directly from a user-specified character buffer.
1932 * @param base the character buffer
1933 * @param size the size in bytes of the character buffer
1934 *
1935 * @return the newly allocated buffer state object.
1936 */
1938{
1940
1941 if ( size < 2 ||
1944 /* They forgot to leave room for the EOB's. */
1945 return NULL;
1946
1947 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1948 if ( ! b )
1949 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1950
1951 b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
1952 b->yy_buf_pos = b->yy_ch_buf = base;
1953 b->yy_is_our_buffer = 0;
1954 b->yy_input_file = NULL;
1955 b->yy_n_chars = b->yy_buf_size;
1956 b->yy_is_interactive = 0;
1957 b->yy_at_bol = 1;
1958 b->yy_fill_buffer = 0;
1959 b->yy_buffer_status = YY_BUFFER_NEW;
1960
1962
1963 return b;
1964}
1965
1966/** Setup the input buffer state to scan a string. The next call to yylex() will
1967 * scan from a @e copy of @a str.
1968 * @param yystr a NUL-terminated string to scan
1969 *
1970 * @return the newly allocated buffer state object.
1971 * @note If you want to scan bytes that may contain NUL values, then use
1972 * yy_scan_bytes() instead.
1973 */
1975{
1976
1977 return yy_scan_bytes( yystr, (int) strlen(yystr) );
1978}
1979
1980/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1981 * scan from a @e copy of @a bytes.
1982 * @param yybytes the byte buffer to scan
1983 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1984 *
1985 * @return the newly allocated buffer state object.
1986 */
1988{
1990 char *buf;
1991 yy_size_t n;
1992 int i;
1993
1994 /* Get memory for full buffer, including space for trailing EOB's. */
1995 n = (yy_size_t) (_yybytes_len + 2);
1996 buf = (char *) yyalloc( n );
1997 if ( ! buf )
1998 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1999
2000 for ( i = 0; i < _yybytes_len; ++i )
2001 buf[i] = yybytes[i];
2002
2004
2005 b = yy_scan_buffer( buf, n );
2006 if ( ! b )
2007 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2008
2009 /* It's okay to grow etc. this buffer, and we should throw it
2010 * away when we're done.
2011 */
2012 b->yy_is_our_buffer = 1;
2013
2014 return b;
2015}
2016
2017#ifndef YY_EXIT_FAILURE
2018#define YY_EXIT_FAILURE 2
2019#endif
2020
2021static void yynoreturn yy_fatal_error (const char* msg )
2022{
2023 fprintf( stderr, "%s\n", msg );
2025}
2026
2027/* Redefine yyless() so it works in section 3 code. */
2028
2029#undef yyless
2030#define yyless(n) \
2031 do \
2032 { \
2033 /* Undo effects of setting up yytext. */ \
2034 int yyless_macro_arg = (n); \
2035 YY_LESS_LINENO(yyless_macro_arg);\
2036 yytext[yyleng] = (yy_hold_char); \
2037 (yy_c_buf_p) = yytext + yyless_macro_arg; \
2038 (yy_hold_char) = *(yy_c_buf_p); \
2039 *(yy_c_buf_p) = '\0'; \
2040 yyleng = yyless_macro_arg; \
2041 } \
2042 while ( 0 )
2043
2044/* Accessor methods (get/set functions) to struct members. */
2045
2046/** Get the current line number.
2047 *
2048 */
2050{
2051
2052 return yylineno;
2053}
2054
2055/** Get the input stream.
2056 *
2057 */
2059{
2060 return yyin;
2061}
2062
2063/** Get the output stream.
2064 *
2065 */
2067{
2068 return yyout;
2069}
2070
2071/** Get the length of the current token.
2072 *
2073 */
2074int yyget_leng (void)
2075{
2076 return yyleng;
2077}
2078
2079/** Get the current token.
2080 *
2081 */
2082
2083char *yyget_text (void)
2084{
2085 return yytext;
2086}
2087
2088/** Set the current line number.
2089 * @param _line_number line number
2090 *
2091 */
2093{
2094
2096}
2097
2098/** Set the input stream. This does not discard the current
2099 * input buffer.
2100 * @param _in_str A readable stream.
2101 *
2102 * @see yy_switch_to_buffer
2103 */
2105{
2106 yyin = _in_str ;
2107}
2108
2110{
2111 yyout = _out_str ;
2112}
2113
2114int yyget_debug (void)
2115{
2116 return yy_flex_debug;
2117}
2118
2120{
2122}
2123
2124static int yy_init_globals (void)
2125{
2126 /* Initialization is the same as for the non-reentrant scanner.
2127 * This function is called from yylex_destroy(), so don't allocate here.
2128 */
2129
2130 /* We do not touch yylineno unless the option is enabled. */
2131 yylineno = 1;
2132
2134 (yy_buffer_stack_top) = 0;
2135 (yy_buffer_stack_max) = 0;
2136 (yy_c_buf_p) = NULL;
2137 (yy_init) = 0;
2138 (yy_start) = 0;
2139
2140/* Defined in main.c */
2141#ifdef YY_STDINIT
2142 yyin = stdin;
2143 yyout = stdout;
2144#else
2145 yyin = NULL;
2146 yyout = NULL;
2147#endif
2148
2149 /* For future reference: Set errno on error, since we are called by
2150 * yylex_init()
2151 */
2152 return 0;
2153}
2154
2155/* yylex_destroy is for both reentrant and non-reentrant scanners. */
2157{
2158
2159 /* Pop the buffer stack, destroying each element. */
2160 while(YY_CURRENT_BUFFER){
2164 }
2165
2166 /* Destroy the stack itself. */
2169
2170 /* Reset the globals. This is important in a non-reentrant scanner so the next time
2171 * yylex() is called, initialization will occur. */
2172 yy_init_globals( );
2173
2174 return 0;
2175}
2176
2177/*
2178 * Internal utility routines.
2179 */
2180
2181#ifndef yytext_ptr
2182static void yy_flex_strncpy (char* s1, const char * s2, int n )
2183{
2184
2185 int i;
2186 for ( i = 0; i < n; ++i )
2187 s1[i] = s2[i];
2188}
2189#endif
2190
2191#ifdef YY_NEED_STRLEN
2192static int yy_flex_strlen (const char * s )
2193{
2194 int n;
2195 for ( n = 0; s[n]; ++n )
2196 ;
2197
2198 return n;
2199}
2200#endif
2201
2203{
2204 return malloc(size);
2205}
2206
2207void *yyrealloc (void * ptr, yy_size_t size )
2208{
2209
2210 /* The cast to (char *) in the following accommodates both
2211 * implementations that use char* generic pointers, and those
2212 * that use void* generic pointers. It works with the latter
2213 * because both ANSI C and C++ allow castless assignment from
2214 * any pointer type to void*, and deal with argument conversions
2215 * as though doing an assignment.
2216 */
2217 return realloc(ptr, size);
2218}
2219
2220void yyfree (void * ptr )
2221{
2222 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2223}
2224
2225#define YYTABLES_NAME "yytables"
2226
2227#line 163 "errors.lex"
2228
2229
2230char * gpu_errors (const char * errors, const char * source, char * fout)
2231{
2232 if (0) yyunput (0, NULL); // just prevents 'yyunput unused' compiler warning
2233
2234 char * merged = merge (source, errors);
2235 sout = fout;
2236 sout = str_append (NULL, "");
2238 fname = NULL;
2239 line = 1;
2240 yylex();
2242 free (merged);
2243
2244 return sout;
2245}
2246
free(list1)
int x
Definition common.h:76
define sysmalloc malloc define syscalloc calloc define sysrealloc realloc define sysfree free define systrdup strdup define file
Definition config.h:120
define sysmalloc malloc define syscalloc calloc define sysrealloc realloc define sysfree free define systrdup strdup define line line realloc(p, s) @ define pfree(p
define sysmalloc malloc define syscalloc calloc define sysrealloc realloc define sysfree free define systrdup strdup define line line line line strdup(s) @ define tracing(...) @ define end_tracing(...) @define tid() 0 @define pid() 0 @define npe() 1 @define mpi_all_reduce(v
else return n
Definition curvature.h:101
char * error
Definition display.h:101
scalar s
Definition embed-tree.h:56
scalar int i
Definition embed.h:74
#define yy_load_buffer_state
Definition errors.c:18
#define YY_NEW_FILE
Definition errors.c:389
#define yyset_extra
Definition errors.c:167
#define yytext
Definition errors.c:30
unsigned char flex_uint8_t
Definition errors.c:315
#define yyset_lineno
Definition errors.c:215
static char yy_hold_char
Definition errors.c:549
static yy_state_type yy_last_accepting_state
Definition errors.c:731
static const flex_int16_t yy_base[28]
Definition errors.c:692
#define yyrestart
Definition errors.c:29
#define yyset_debug
Definition errors.c:155
static void yyunput(int c, char *buf_ptr)
Definition errors.c:1545
#define YY_EXTRA_TYPE
Definition errors.c:875
static int yy_start
Definition errors.c:556
short int flex_int16_t
Definition errors.c:313
static const flex_int16_t yy_def[28]
Definition errors.c:699
#define yy_flex_debug
Definition errors.c:23
#define yyget_out
Definition errors.c:185
static YY_BUFFER_STATE * yy_buffer_stack
Stack as an array.
Definition errors.c:532
unsigned int flex_uint32_t
Definition errors.c:317
char * gpu_errors(const char *errors, const char *source, char *fout)
Definition errors.c:2230
static const flex_int16_t yy_accept[25]
Definition errors.c:647
static int yy_get_next_buffer(void)
Definition errors.c:1349
#define yy_scan_bytes
Definition errors.c:15
#define YY_BREAK
Definition errors.c:1038
static int line
Definition errors.c:754
static size_t yy_buffer_stack_max
capacity of stack.
Definition errors.c:531
#define yynoreturn
Definition errors.c:364
static yy_state_type yy_try_NUL_trans(yy_state_type current_state)
Definition errors.c:1520
#define yyget_debug
Definition errors.c:149
static int atoi_check(char *start, char *end)
Definition errors.c:767
#define yypush_buffer_state
Definition errors.c:20
struct yy_buffer_state * YY_BUFFER_STATE
Definition errors.c:411
#define yyfree
Definition errors.c:34
#define yyout
Definition errors.c:28
#define YY_BUFFER_NEW
Definition errors.c:512
#define yyget_lineno
Definition errors.c:209
#define yylex
Definition errors.c:26
#define YY_RESTORE_YY_MORE_OFFSET
Definition errors.c:743
static int yy_did_buffer_switch_on_eof
Definition errors.c:561
static int parse_intel(const char *errors, const char **msg)
Definition errors.c:781
static int yy_init_globals(void)
Definition errors.c:2124
#define yywrap
Definition errors.c:31
static const flex_int16_t yy_nxt[55]
Definition errors.c:706
#define yyget_text
Definition errors.c:203
#define YY_BUFFER_NORMAL
Definition errors.c:513
#define yyensure_buffer_stack
Definition errors.c:22
#define yy_scan_buffer
Definition errors.c:13
#define YY_MORE_ADJ
Definition errors.c:742
#define YY_RULE_SETUP
Definition errors.c:1041
static const flex_int32_t yy_rule_can_match_eol[6]
Definition errors.c:727
#define yy_scan_string
Definition errors.c:14
#define YY_AT_BOL()
Definition errors.c:603
#define yytext_ptr
Definition errors.c:622
signed char flex_int8_t
Definition errors.c:312
#define yyget_leng
Definition errors.c:197
#define EOB_ACT_END_OF_FILE
Definition errors.c:424
#define yyalloc
Definition errors.c:32
static void yy_fatal_error(const char *msg)
Definition errors.c:2021
#define yypop_buffer_state
Definition errors.c:21
#define YY_CURRENT_BUFFER_LVALUE
Definition errors.c:546
int flex_int32_t
Definition errors.c:314
#define yylex_destroy
Definition errors.c:143
static char * merge(const char *source, const char *errors)
Definition errors.c:834
#define YY_START
Definition errors.c:384
static const flex_int16_t yy_chk[55]
Definition errors.c:716
#define yy_switch_to_buffer
Definition errors.c:19
int yy_state_type
Definition errors.c:613
#define YY_CURRENT_BUFFER
Definition errors.c:540
#define yy_init_buffer
Definition errors.c:16
#define INITIAL
Definition errors.c:864
#define yyget_extra
Definition errors.c:161
#define yyin
Definition errors.c:24
static int yy_n_chars
Definition errors.c:550
#define YY_READ_BUF_SIZE
Definition errors.c:950
#define YY_INPUT(buf, result, max_size)
Definition errors.c:966
#define ECHO
Definition errors.c:959
#define yy_flush_buffer
Definition errors.c:17
#define yyrealloc
Definition errors.c:33
#define YY_END_OF_BUFFER
Definition errors.c:639
#define YY_STATE_EOF(state)
Definition errors.c:387
static char * sout
Definition errors.c:752
#define YY_END_OF_BUFFER_CHAR
Definition errors.c:390
#define YY_FATAL_ERROR(msg)
Definition errors.c:1013
#define yyterminate()
Definition errors.c:1003
unsigned short int flex_uint16_t
Definition errors.c:316
#define yy_create_buffer
Definition errors.c:11
flex_uint8_t YY_CHAR
Definition errors.c:609
#define YY_DO_BEFORE_ACTION
Definition errors.c:632
static char * next_error(const char *errors, int *line, const char **msg)
Definition errors.c:809
static int parse_nvidia(const char *errors, const char **msg)
Definition errors.c:796
#define yy_delete_buffer
Definition errors.c:12
#define EOB_ACT_LAST_MATCH
Definition errors.c:425
#define yyget_in
Definition errors.c:173
size_t yy_size_t
Definition errors.c:416
#define YY_BUFFER_EOF_PENDING
Definition errors.c:524
#define yylineno
Definition errors.c:27
static yy_state_type yy_get_previous_state(void)
Definition errors.c:1487
static const YY_CHAR yy_ec[256]
Definition errors.c:654
#define yyset_out
Definition errors.c:191
static char * yy_c_buf_p
Definition errors.c:554
#define EOB_ACT_CONTINUE_SCAN
Definition errors.c:423
static size_t yy_buffer_stack_top
index of top of stack.
Definition errors.c:530
#define YY_DECL
Definition errors.c:1026
static const YY_CHAR yy_meta[13]
Definition errors.c:686
#define YY_BUF_SIZE
Definition errors.c:401
#define YY_EXIT_FAILURE
Definition errors.c:2018
static char * fname
Definition errors.c:753
static int yy_init
Definition errors.c:555
#define YY_SC_TO_UI(c)
Definition errors.c:373
#define yyleng
Definition errors.c:25
static char * yy_last_accepting_cpos
Definition errors.c:732
#define yyset_in
Definition errors.c:179
#define str_append(dst,...)
Definition grid.h:404
static int input(void)
Definition include.c:2085
static int
Definition include.c:978
int dst
size_t size
size *double * b
size *double * buf
int flex_int32_t
Definition postproc.c:314
int source
Definition qcc.c:67
char * yy_ch_buf
Definition errors.c:470
int yy_bs_column
The column count.
Definition errors.c:503
FILE * yy_input_file
Definition errors.c:468
int yy_fill_buffer
Definition errors.c:508
int yy_buffer_status
Definition errors.c:510
int yy_is_our_buffer
Definition errors.c:487
int yy_bs_lineno
The line count.
Definition errors.c:502
char * yy_buf_pos
Definition errors.c:471
int yy_is_interactive
Definition errors.c:494
flex_int32_t yy_verify
Definition errors.c:644
flex_int32_t yy_nxt
Definition errors.c:645
scalar c
Definition vof.h:57