1 /* A lexical scanner generated by flex */
3 /* Scanner skeleton version:
8 #define YY_FLEX_MAJOR_VERSION 2
9 #define YY_FLEX_MINOR_VERSION 5
14 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
29 /* Use prototypes in function declarations. */
32 /* The "const" storage-class-modifier is valid. */
35 #else /* ! __cplusplus */
43 #endif /* ! __cplusplus */
62 #define YY_PROTO(proto) proto
64 #define YY_PROTO(proto) ()
67 /* Returned upon end-of-file. */
70 /* Promotes a possibly negative, possibly signed char to an unsigned
71 * integer for use as an array index. If the signed char is negative,
72 * we want to instead treat it as an 8-bit unsigned char, hence the
75 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
77 /* Enter a start condition. This macro really ought to take a parameter,
78 * but we do it the disgusting crufty way forced on us by the ()-less
79 * definition of BEGIN.
81 #define BEGIN yy_start = 1 + 2 *
83 /* Translate the current start state into a value that can be later handed
84 * to BEGIN to return to the state. The YYSTATE alias is for lex
87 #define YY_START ((yy_start - 1) / 2)
88 #define YYSTATE YY_START
90 /* Action number for EOF rule of a given start state. */
91 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
93 /* Special action meaning "start processing a new file". */
94 #define YY_NEW_FILE yyrestart( yyin )
96 #define YY_END_OF_BUFFER_CHAR 0
98 /* Size of default input buffer. */
99 #define YY_BUF_SIZE 16384
101 typedef struct yy_buffer_state *YY_BUFFER_STATE;
104 extern FILE *yyin, *yyout;
106 #define EOB_ACT_CONTINUE_SCAN 0
107 #define EOB_ACT_END_OF_FILE 1
108 #define EOB_ACT_LAST_MATCH 2
110 /* The funky do-while in the following #define is used to turn the definition
111 * int a single C statement (which needs a semi-colon terminator). This
112 * avoids problems with code like:
114 * if ( condition_holds )
117 * do_something_else();
119 * Prior to using the do-while the compiler would get upset at the
120 * "else" because it interpreted the "if" statement as being all
121 * done when it reached the ';' after the yyless() call.
124 /* Return all but the first 'n' matched characters back to the input stream. */
129 /* Undo effects of setting up yytext. */ \
130 *yy_cp = yy_hold_char; \
131 YY_RESTORE_YY_MORE_OFFSET \
132 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
133 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
137 #define unput(c) yyunput( c, yytext_ptr )
139 /* The following is because we cannot portably get our hands on size_t
140 * (without autoconf's help, which isn't available because we want
141 * flex-generated scanners to compile on their own).
143 typedef unsigned int yy_size_t;
146 struct yy_buffer_state
150 char *yy_ch_buf; /* input buffer */
151 char *yy_buf_pos; /* current position in input buffer */
153 /* Size of input buffer in bytes, not including room for EOB
156 yy_size_t yy_buf_size;
158 /* Number of characters read into yy_ch_buf, not including EOB
163 /* Whether we "own" the buffer - i.e., we know we created it,
164 * and can realloc() it to grow it, and should free() it to
167 int yy_is_our_buffer;
169 /* Whether this is an "interactive" input source; if so, and
170 * if we're using stdio for input, then we want to use getc()
171 * instead of fread(), to make sure we stop fetching input after
174 int yy_is_interactive;
176 /* Whether we're considered to be at the beginning of a line.
177 * If so, '^' rules will be active on the next match, otherwise
182 /* Whether to try to fill the input buffer when we reach the
187 int yy_buffer_status;
188 #define YY_BUFFER_NEW 0
189 #define YY_BUFFER_NORMAL 1
190 /* When an EOF's been seen but there's still some text to process
191 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
192 * shouldn't try reading from the input source any more. We might
193 * still have a bunch of tokens to match, though, because of
194 * possible backing-up.
196 * When we actually see the EOF, we change the status to "new"
197 * (via yyrestart()), so that the user can continue scanning by
198 * just pointing yyin at a new input file.
200 #define YY_BUFFER_EOF_PENDING 2
203 static YY_BUFFER_STATE yy_current_buffer = 0;
205 /* We provide macros for accessing buffer states in case in the
206 * future we want to put the buffer states in a more general
209 #define YY_CURRENT_BUFFER yy_current_buffer
212 /* yy_hold_char holds the character lost when yytext is formed. */
213 static char yy_hold_char;
215 static int yy_n_chars; /* number of characters read into yy_ch_buf */
220 /* Points to current character in buffer. */
221 static char *yy_c_buf_p = (char *) 0;
222 static int yy_init = 1; /* whether we need to initialize */
223 static int yy_start = 0; /* start state number */
225 /* Flag which is used to allow yywrap()'s to do buffer switches
226 * instead of setting up a fresh yyin. A bit of a hack ...
228 static int yy_did_buffer_switch_on_eof;
230 void yyrestart YY_PROTO(( FILE *input_file ));
232 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
233 void yy_load_buffer_state YY_PROTO(( void ));
234 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
235 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
236 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
237 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
238 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
240 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
241 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
242 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
244 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
245 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
246 static void yy_flex_free YY_PROTO(( void * ));
248 #define yy_new_buffer yy_create_buffer
250 #define yy_set_interactive(is_interactive) \
252 if ( ! yy_current_buffer ) \
253 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
254 yy_current_buffer->yy_is_interactive = is_interactive; \
257 #define yy_set_bol(at_bol) \
259 if ( ! yy_current_buffer ) \
260 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
261 yy_current_buffer->yy_at_bol = at_bol; \
264 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
267 #define YY_USES_REJECT
268 typedef unsigned char YY_CHAR;
269 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
270 typedef int yy_state_type;
272 #define yytext_ptr yytext
274 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
275 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
276 static int yy_get_next_buffer YY_PROTO(( void ));
277 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
279 /* Done after the current pattern has been matched and before the
280 * corresponding action - sets up yytext.
282 #define YY_DO_BEFORE_ACTION \
283 yytext_ptr = yy_bp; \
284 yyleng = (int) (yy_cp - yy_bp); \
285 yy_hold_char = *yy_cp; \
289 #define YY_NUM_RULES 8
290 #define YY_END_OF_BUFFER 9
291 static yyconst short int yy_acclist[27] =
293 9, 7, 8, 6, 7, 8, 4, 8, 7, 8,
294 7, 8,16386, 5, 7, 8, 7, 8,16387,16385,
295 8194,16386,16387, 8195, 8193, 8195
298 static yyconst short int yy_accept[24] =
300 1, 1, 1, 2, 4, 7, 9, 11, 14, 17,
301 20, 20, 21, 21, 22, 23, 23, 24, 25, 25,
305 static yyconst int yy_ec[256] =
307 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
308 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
309 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
310 1, 2, 1, 4, 1, 1, 1, 1, 1, 1,
311 1, 1, 1, 1, 1, 1, 1, 5, 5, 5,
312 5, 5, 5, 5, 5, 5, 5, 1, 1, 1,
313 6, 1, 1, 1, 7, 7, 7, 7, 7, 7,
314 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
315 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
316 1, 1, 1, 1, 8, 1, 7, 7, 7, 7,
318 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
319 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
320 7, 7, 1, 1, 1, 1, 1, 1, 1, 1,
321 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
322 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
323 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
324 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
325 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
326 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
327 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
329 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
330 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
331 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
332 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
333 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
337 static yyconst int yy_meta[9] =
339 1, 2, 3, 1, 2, 2, 2, 2
342 static yyconst short int yy_base[25] =
344 0, 19, 23, 32, 32, 32, 18, 7, 32, 11,
345 17, 16, 11, 32, 0, 18, 23, 13, 0, 32,
349 static yyconst short int yy_def[25] =
351 22, 1, 22, 22, 22, 22, 23, 22, 22, 24,
352 23, 22, 8, 22, 8, 22, 24, 22, 12, 22,
356 static yyconst short int yy_nxt[41] =
358 4, 5, 6, 7, 8, 9, 4, 4, 13, 14,
359 17, 15, 16, 21, 21, 22, 18, 19, 20, 16,
360 12, 12, 22, 18, 16, 10, 22, 22, 18, 11,
361 11, 3, 22, 22, 22, 22, 22, 22, 22, 22
364 static yyconst short int yy_chk[41] =
366 1, 1, 1, 1, 1, 1, 1, 1, 8, 8,
367 24, 8, 10, 21, 18, 13, 10, 12, 12, 16,
368 11, 7, 3, 16, 17, 2, 0, 0, 17, 23,
369 23, 22, 22, 22, 22, 22, 22, 22, 22, 22
372 static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
373 static char *yy_full_match;
375 static int yy_looking_for_trail_begin = 0;
376 static int yy_full_lp;
377 static int *yy_full_state;
378 #define YY_TRAILING_MASK 0x2000
379 #define YY_TRAILING_HEAD_MASK 0x4000
382 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
383 yy_cp = yy_full_match; /* restore poss. backed-over text */ \
384 yy_lp = yy_full_lp; /* restore orig. accepting pos. */ \
385 yy_state_ptr = yy_full_state; /* restore orig. state */ \
386 yy_current_state = *yy_state_ptr; /* restore curr. state */ \
390 #define yymore() yymore_used_but_not_detected
391 #define YY_MORE_ADJ 0
392 #define YY_RESTORE_YY_MORE_OFFSET
400 static int yylineno = 1;
401 static gboolean haserror = FALSE;
402 static ConfigEntry entry = { NULL, -1 };
404 static void stringvalue();
405 static void numbervalue();
406 static void identifier();
407 static void newline();
411 /* Macros after this point can all be overridden by user definitions in
415 #ifndef YY_SKIP_YYWRAP
417 extern "C" int yywrap YY_PROTO(( void ));
419 extern int yywrap YY_PROTO(( void ));
424 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
428 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
431 #ifdef YY_NEED_STRLEN
432 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
437 static int yyinput YY_PROTO(( void ));
439 static int input YY_PROTO(( void ));
444 static int yy_start_stack_ptr = 0;
445 static int yy_start_stack_depth = 0;
446 static int *yy_start_stack = 0;
447 #ifndef YY_NO_PUSH_STATE
448 static void yy_push_state YY_PROTO(( int new_state ));
450 #ifndef YY_NO_POP_STATE
451 static void yy_pop_state YY_PROTO(( void ));
453 #ifndef YY_NO_TOP_STATE
454 static int yy_top_state YY_PROTO(( void ));
458 #define YY_NO_PUSH_STATE 1
459 #define YY_NO_POP_STATE 1
460 #define YY_NO_TOP_STATE 1
463 #ifdef YY_MALLOC_DECL
471 /* Just try to get by without declaring the routines. This will fail
472 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
473 * or sizeof(void*) != sizeof(int).
478 /* Amount of stuff to slurp up with each read. */
479 #ifndef YY_READ_BUF_SIZE
480 #define YY_READ_BUF_SIZE 8192
483 /* Copy whatever the last rule matched to the standard output. */
486 /* This used to be an fputs(), but since the string might contain NUL's,
487 * we now use fwrite().
489 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
492 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
493 * is returned in "result".
496 #define YY_INPUT(buf,result,max_size) \
497 if ( yy_current_buffer->yy_is_interactive ) \
500 for ( n = 0; n < max_size && \
501 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
504 buf[n++] = (char) c; \
505 if ( c == EOF && ferror( yyin ) ) \
506 YY_FATAL_ERROR( "input in flex scanner failed" ); \
512 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
514 if( errno != EINTR) \
516 YY_FATAL_ERROR( "input in flex scanner failed" ); \
525 /* No semi-colon after return; correct usage is to write "yyterminate();" -
526 * we don't want an extra ';' after the "return" because that will cause
527 * some compilers to complain about unreachable statements.
530 #define yyterminate() return YY_NULL
533 /* Number of entries by which start-condition stack grows. */
534 #ifndef YY_START_STACK_INCR
535 #define YY_START_STACK_INCR 25
538 /* Report a fatal error. */
539 #ifndef YY_FATAL_ERROR
540 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
543 /* Default declaration of generated scanner - a define so the user can
544 * easily add parameters.
547 #define YY_DECL int yylex YY_PROTO(( void ))
550 /* Code executed at the beginning of each rule, after yytext and yyleng
553 #ifndef YY_USER_ACTION
554 #define YY_USER_ACTION
557 /* Code executed at the end of each rule. */
559 #define YY_BREAK break;
562 #define YY_RULE_SETUP \
564 yy_current_buffer->yy_at_bol = \
565 (yytext[yyleng - 1] == '\n'); \
570 register yy_state_type yy_current_state;
571 register char *yy_cp, *yy_bp;
588 yy_start = 1; /* first start state */
596 if ( ! yy_current_buffer )
598 yy_create_buffer( yyin, YY_BUF_SIZE );
600 yy_load_buffer_state();
603 while ( 1 ) /* loops until end-of-file is reached */
607 /* Support of yytext. */
608 *yy_cp = yy_hold_char;
610 /* yy_bp points to the position in yy_ch_buf of the start of
615 yy_current_state = yy_start;
616 yy_current_state += YY_AT_BOL();
617 yy_state_ptr = yy_state_buf;
618 *yy_state_ptr++ = yy_current_state;
622 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
623 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
625 yy_current_state = (int) yy_def[yy_current_state];
626 if ( yy_current_state >= 23 )
627 yy_c = yy_meta[(unsigned int) yy_c];
629 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
630 *yy_state_ptr++ = yy_current_state;
633 while ( yy_base[yy_current_state] != 32 );
636 yy_current_state = *--yy_state_ptr;
637 yy_lp = yy_accept[yy_current_state];
638 find_rule: /* we branch to this label when backing up */
639 for ( ; ; ) /* until we find what rule we matched */
641 if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
643 yy_act = yy_acclist[yy_lp];
644 if ( yy_act & YY_TRAILING_HEAD_MASK ||
645 yy_looking_for_trail_begin )
647 if ( yy_act == yy_looking_for_trail_begin )
649 yy_looking_for_trail_begin = 0;
650 yy_act &= ~YY_TRAILING_HEAD_MASK;
654 else if ( yy_act & YY_TRAILING_MASK )
656 yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;
657 yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;
661 yy_full_match = yy_cp;
662 yy_full_state = yy_state_ptr;
670 yy_current_state = *--yy_state_ptr;
671 yy_lp = yy_accept[yy_current_state];
677 do_action: /* This label is used only to access EOF actions. */
681 { /* beginning of action switch */
723 case YY_STATE_EOF(INITIAL):
726 case YY_END_OF_BUFFER:
728 /* Amount of text matched not including the EOB char. */
729 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
731 /* Undo the effects of YY_DO_BEFORE_ACTION. */
732 *yy_cp = yy_hold_char;
733 YY_RESTORE_YY_MORE_OFFSET
735 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
737 /* We're scanning a new file or input source. It's
738 * possible that this happened because the user
739 * just pointed yyin at a new source and called
740 * yylex(). If so, then we have to assure
741 * consistency between yy_current_buffer and our
742 * globals. Here is the right place to do so, because
743 * this is the first action (other than possibly a
744 * back-up) that will match for the new input source.
746 yy_n_chars = yy_current_buffer->yy_n_chars;
747 yy_current_buffer->yy_input_file = yyin;
748 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
751 /* Note that here we test for yy_c_buf_p "<=" to the position
752 * of the first EOB in the buffer, since yy_c_buf_p will
753 * already have been incremented past the NUL character
754 * (since all states make transitions on EOB to the
755 * end-of-buffer state). Contrast this with the test
758 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
759 { /* This was really a NUL. */
760 yy_state_type yy_next_state;
762 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
764 yy_current_state = yy_get_previous_state();
766 /* Okay, we're now positioned to make the NUL
767 * transition. We couldn't have
768 * yy_get_previous_state() go ahead and do it
769 * for us because it doesn't know how to deal
770 * with the possibility of jamming (and we don't
771 * want to build jamming into it because then it
772 * will run more slowly).
775 yy_next_state = yy_try_NUL_trans( yy_current_state );
777 yy_bp = yytext_ptr + YY_MORE_ADJ;
781 /* Consume the NUL. */
782 yy_cp = ++yy_c_buf_p;
783 yy_current_state = yy_next_state;
794 else switch ( yy_get_next_buffer() )
796 case EOB_ACT_END_OF_FILE:
798 yy_did_buffer_switch_on_eof = 0;
802 /* Note: because we've taken care in
803 * yy_get_next_buffer() to have set up
804 * yytext, we can now set up
805 * yy_c_buf_p so that if some total
806 * hoser (like flex itself) wants to
807 * call the scanner after we return the
808 * YY_NULL, it'll still work - another
809 * YY_NULL will get returned.
811 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
813 yy_act = YY_STATE_EOF(YY_START);
819 if ( ! yy_did_buffer_switch_on_eof )
825 case EOB_ACT_CONTINUE_SCAN:
827 yytext_ptr + yy_amount_of_matched_text;
829 yy_current_state = yy_get_previous_state();
832 yy_bp = yytext_ptr + YY_MORE_ADJ;
835 case EOB_ACT_LAST_MATCH:
837 &yy_current_buffer->yy_ch_buf[yy_n_chars];
839 yy_current_state = yy_get_previous_state();
842 yy_bp = yytext_ptr + YY_MORE_ADJ;
850 "fatal flex scanner internal error--no action found" );
851 } /* end of action switch */
852 } /* end of scanning one token */
856 /* yy_get_next_buffer - try to read in a new buffer
858 * Returns a code representing an action:
859 * EOB_ACT_LAST_MATCH -
860 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
861 * EOB_ACT_END_OF_FILE - end of file
864 static int yy_get_next_buffer()
866 register char *dest = yy_current_buffer->yy_ch_buf;
867 register char *source = yytext_ptr;
868 register int number_to_move, i;
871 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
873 "fatal flex scanner internal error--end of buffer missed" );
875 if ( yy_current_buffer->yy_fill_buffer == 0 )
876 { /* Don't try to fill the buffer, so this is an EOF. */
877 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
879 /* We matched a single character, the EOB, so
880 * treat this as a final EOF.
882 return EOB_ACT_END_OF_FILE;
887 /* We matched some text prior to the EOB, first
890 return EOB_ACT_LAST_MATCH;
894 /* Try to read more data. */
896 /* First move last chars to start of buffer. */
897 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
899 for ( i = 0; i < number_to_move; ++i )
900 *(dest++) = *(source++);
902 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
903 /* don't do the read, it's not guaranteed to return an EOF,
906 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
911 yy_current_buffer->yy_buf_size - number_to_move - 1;
913 while ( num_to_read <= 0 )
914 { /* Not enough room in the buffer - grow it. */
915 #ifdef YY_USES_REJECT
917 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
920 /* just a shorter name for the current buffer */
921 YY_BUFFER_STATE b = yy_current_buffer;
923 int yy_c_buf_p_offset =
924 (int) (yy_c_buf_p - b->yy_ch_buf);
926 if ( b->yy_is_our_buffer )
928 int new_size = b->yy_buf_size * 2;
931 b->yy_buf_size += b->yy_buf_size / 8;
935 b->yy_ch_buf = (char *)
936 /* Include room in for 2 EOB chars. */
937 yy_flex_realloc( (void *) b->yy_ch_buf,
938 b->yy_buf_size + 2 );
941 /* Can't grow it, we don't own it. */
944 if ( ! b->yy_ch_buf )
946 "fatal error - scanner input buffer overflow" );
948 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
950 num_to_read = yy_current_buffer->yy_buf_size -
955 if ( num_to_read > YY_READ_BUF_SIZE )
956 num_to_read = YY_READ_BUF_SIZE;
958 /* Read in more data. */
959 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
960 yy_n_chars, num_to_read );
962 yy_current_buffer->yy_n_chars = yy_n_chars;
965 if ( yy_n_chars == 0 )
967 if ( number_to_move == YY_MORE_ADJ )
969 ret_val = EOB_ACT_END_OF_FILE;
975 ret_val = EOB_ACT_LAST_MATCH;
976 yy_current_buffer->yy_buffer_status =
977 YY_BUFFER_EOF_PENDING;
982 ret_val = EOB_ACT_CONTINUE_SCAN;
984 yy_n_chars += number_to_move;
985 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
986 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
988 yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
994 /* yy_get_previous_state - get the state just before the EOB char was reached */
996 static yy_state_type yy_get_previous_state()
998 register yy_state_type yy_current_state;
999 register char *yy_cp;
1001 yy_current_state = yy_start;
1002 yy_current_state += YY_AT_BOL();
1003 yy_state_ptr = yy_state_buf;
1004 *yy_state_ptr++ = yy_current_state;
1006 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1008 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1009 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1011 yy_current_state = (int) yy_def[yy_current_state];
1012 if ( yy_current_state >= 23 )
1013 yy_c = yy_meta[(unsigned int) yy_c];
1015 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1016 *yy_state_ptr++ = yy_current_state;
1019 return yy_current_state;
1023 /* yy_try_NUL_trans - try to make a transition on the NUL character
1026 * next_state = yy_try_NUL_trans( current_state );
1029 #ifdef YY_USE_PROTOS
1030 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1032 static yy_state_type yy_try_NUL_trans( yy_current_state )
1033 yy_state_type yy_current_state;
1036 register int yy_is_jam;
1038 register YY_CHAR yy_c = 1;
1039 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1041 yy_current_state = (int) yy_def[yy_current_state];
1042 if ( yy_current_state >= 23 )
1043 yy_c = yy_meta[(unsigned int) yy_c];
1045 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1046 yy_is_jam = (yy_current_state == 22);
1048 *yy_state_ptr++ = yy_current_state;
1050 return yy_is_jam ? 0 : yy_current_state;
1055 #ifdef YY_USE_PROTOS
1056 static void yyunput( int c, register char *yy_bp )
1058 static void yyunput( c, yy_bp )
1060 register char *yy_bp;
1063 register char *yy_cp = yy_c_buf_p;
1065 /* undo effects of setting up yytext */
1066 *yy_cp = yy_hold_char;
1068 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1069 { /* need to shift things up to make room */
1070 /* +2 for EOB chars. */
1071 register int number_to_move = yy_n_chars + 2;
1072 register char *dest = &yy_current_buffer->yy_ch_buf[
1073 yy_current_buffer->yy_buf_size + 2];
1074 register char *source =
1075 &yy_current_buffer->yy_ch_buf[number_to_move];
1077 while ( source > yy_current_buffer->yy_ch_buf )
1078 *--dest = *--source;
1080 yy_cp += (int) (dest - source);
1081 yy_bp += (int) (dest - source);
1082 yy_current_buffer->yy_n_chars =
1083 yy_n_chars = yy_current_buffer->yy_buf_size;
1085 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1086 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1089 *--yy_cp = (char) c;
1093 yy_hold_char = *yy_cp;
1096 #endif /* ifndef YY_NO_UNPUT */
1100 static int yyinput()
1107 *yy_c_buf_p = yy_hold_char;
1109 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1111 /* yy_c_buf_p now points to the character we want to return.
1112 * If this occurs *before* the EOB characters, then it's a
1113 * valid NUL; if not, then we've hit the end of the buffer.
1115 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1116 /* This was really a NUL. */
1120 { /* need more input */
1121 int offset = yy_c_buf_p - yytext_ptr;
1124 switch ( yy_get_next_buffer() )
1126 case EOB_ACT_LAST_MATCH:
1127 /* This happens because yy_g_n_b()
1128 * sees that we've accumulated a
1129 * token and flags that we need to
1130 * try matching the token before
1131 * proceeding. But for input(),
1132 * there's no matching to consider.
1133 * So convert the EOB_ACT_LAST_MATCH
1134 * to EOB_ACT_END_OF_FILE.
1137 /* Reset buffer status. */
1142 case EOB_ACT_END_OF_FILE:
1147 if ( ! yy_did_buffer_switch_on_eof )
1156 case EOB_ACT_CONTINUE_SCAN:
1157 yy_c_buf_p = yytext_ptr + offset;
1163 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
1164 *yy_c_buf_p = '\0'; /* preserve yytext */
1165 yy_hold_char = *++yy_c_buf_p;
1167 yy_current_buffer->yy_at_bol = (c == '\n');
1173 #ifdef YY_USE_PROTOS
1174 void yyrestart( FILE *input_file )
1176 void yyrestart( input_file )
1180 if ( ! yy_current_buffer )
1181 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1183 yy_init_buffer( yy_current_buffer, input_file );
1184 yy_load_buffer_state();
1188 #ifdef YY_USE_PROTOS
1189 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1191 void yy_switch_to_buffer( new_buffer )
1192 YY_BUFFER_STATE new_buffer;
1195 if ( yy_current_buffer == new_buffer )
1198 if ( yy_current_buffer )
1200 /* Flush out information for old buffer. */
1201 *yy_c_buf_p = yy_hold_char;
1202 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1203 yy_current_buffer->yy_n_chars = yy_n_chars;
1206 yy_current_buffer = new_buffer;
1207 yy_load_buffer_state();
1209 /* We don't actually know whether we did this switch during
1210 * EOF (yywrap()) processing, but the only time this flag
1211 * is looked at is after yywrap() is called, so it's safe
1212 * to go ahead and always set it.
1214 yy_did_buffer_switch_on_eof = 1;
1218 #ifdef YY_USE_PROTOS
1219 void yy_load_buffer_state( void )
1221 void yy_load_buffer_state()
1224 yy_n_chars = yy_current_buffer->yy_n_chars;
1225 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1226 yyin = yy_current_buffer->yy_input_file;
1227 yy_hold_char = *yy_c_buf_p;
1231 #ifdef YY_USE_PROTOS
1232 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1234 YY_BUFFER_STATE yy_create_buffer( file, size )
1241 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1243 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1245 b->yy_buf_size = size;
1247 /* yy_ch_buf has to be 2 characters longer than the size given because
1248 * we need to put in 2 end-of-buffer characters.
1250 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1251 if ( ! b->yy_ch_buf )
1252 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1254 b->yy_is_our_buffer = 1;
1256 yy_init_buffer( b, file );
1262 #ifdef YY_USE_PROTOS
1263 void yy_delete_buffer( YY_BUFFER_STATE b )
1265 void yy_delete_buffer( b )
1272 if ( b == yy_current_buffer )
1273 yy_current_buffer = (YY_BUFFER_STATE) 0;
1275 if ( b->yy_is_our_buffer )
1276 yy_flex_free( (void *) b->yy_ch_buf );
1278 yy_flex_free( (void *) b );
1285 #ifndef YY_ALWAYS_INTERACTIVE
1286 #ifndef YY_NEVER_INTERACTIVE
1287 extern int isatty YY_PROTO(( int ));
1292 #ifdef YY_USE_PROTOS
1293 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1295 void yy_init_buffer( b, file )
1302 yy_flush_buffer( b );
1304 b->yy_input_file = file;
1305 b->yy_fill_buffer = 1;
1307 #if YY_ALWAYS_INTERACTIVE
1308 b->yy_is_interactive = 1;
1310 #if YY_NEVER_INTERACTIVE
1311 b->yy_is_interactive = 0;
1313 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1319 #ifdef YY_USE_PROTOS
1320 void yy_flush_buffer( YY_BUFFER_STATE b )
1322 void yy_flush_buffer( b )
1332 /* We always need two end-of-buffer characters. The first causes
1333 * a transition to the end-of-buffer state. The second causes
1334 * a jam in that state.
1336 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1337 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1339 b->yy_buf_pos = &b->yy_ch_buf[0];
1342 b->yy_buffer_status = YY_BUFFER_NEW;
1344 if ( b == yy_current_buffer )
1345 yy_load_buffer_state();
1349 #ifndef YY_NO_SCAN_BUFFER
1350 #ifdef YY_USE_PROTOS
1351 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1353 YY_BUFFER_STATE yy_scan_buffer( base, size )
1361 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1362 base[size-1] != YY_END_OF_BUFFER_CHAR )
1363 /* They forgot to leave room for the EOB's. */
1366 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1368 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1370 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1371 b->yy_buf_pos = b->yy_ch_buf = base;
1372 b->yy_is_our_buffer = 0;
1373 b->yy_input_file = 0;
1374 b->yy_n_chars = b->yy_buf_size;
1375 b->yy_is_interactive = 0;
1377 b->yy_fill_buffer = 0;
1378 b->yy_buffer_status = YY_BUFFER_NEW;
1380 yy_switch_to_buffer( b );
1387 #ifndef YY_NO_SCAN_STRING
1388 #ifdef YY_USE_PROTOS
1389 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1391 YY_BUFFER_STATE yy_scan_string( yy_str )
1392 yyconst char *yy_str;
1396 for ( len = 0; yy_str[len]; ++len )
1399 return yy_scan_bytes( yy_str, len );
1404 #ifndef YY_NO_SCAN_BYTES
1405 #ifdef YY_USE_PROTOS
1406 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1408 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1409 yyconst char *bytes;
1418 /* Get memory for full buffer, including space for trailing EOB's. */
1420 buf = (char *) yy_flex_alloc( n );
1422 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1424 for ( i = 0; i < len; ++i )
1427 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1429 b = yy_scan_buffer( buf, n );
1431 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1433 /* It's okay to grow etc. this buffer, and we should throw it
1434 * away when we're done.
1436 b->yy_is_our_buffer = 1;
1443 #ifndef YY_NO_PUSH_STATE
1444 #ifdef YY_USE_PROTOS
1445 static void yy_push_state( int new_state )
1447 static void yy_push_state( new_state )
1451 if ( yy_start_stack_ptr >= yy_start_stack_depth )
1455 yy_start_stack_depth += YY_START_STACK_INCR;
1456 new_size = yy_start_stack_depth * sizeof( int );
1458 if ( ! yy_start_stack )
1459 yy_start_stack = (int *) yy_flex_alloc( new_size );
1462 yy_start_stack = (int *) yy_flex_realloc(
1463 (void *) yy_start_stack, new_size );
1465 if ( ! yy_start_stack )
1467 "out of memory expanding start-condition stack" );
1470 yy_start_stack[yy_start_stack_ptr++] = YY_START;
1477 #ifndef YY_NO_POP_STATE
1478 static void yy_pop_state()
1480 if ( --yy_start_stack_ptr < 0 )
1481 YY_FATAL_ERROR( "start-condition stack underflow" );
1483 BEGIN(yy_start_stack[yy_start_stack_ptr]);
1488 #ifndef YY_NO_TOP_STATE
1489 static int yy_top_state()
1491 return yy_start_stack[yy_start_stack_ptr - 1];
1495 #ifndef YY_EXIT_FAILURE
1496 #define YY_EXIT_FAILURE 2
1499 #ifdef YY_USE_PROTOS
1500 static void yy_fatal_error( yyconst char msg[] )
1502 static void yy_fatal_error( msg )
1506 (void) fprintf( stderr, "%s\n", msg );
1507 exit( YY_EXIT_FAILURE );
1512 /* Redefine yyless() so it works in section 3 code. */
1518 /* Undo effects of setting up yytext. */ \
1519 yytext[yyleng] = yy_hold_char; \
1520 yy_c_buf_p = yytext + n; \
1521 yy_hold_char = *yy_c_buf_p; \
1522 *yy_c_buf_p = '\0'; \
1528 /* Internal utility routines. */
1531 #ifdef YY_USE_PROTOS
1532 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1534 static void yy_flex_strncpy( s1, s2, n )
1541 for ( i = 0; i < n; ++i )
1546 #ifdef YY_NEED_STRLEN
1547 #ifdef YY_USE_PROTOS
1548 static int yy_flex_strlen( yyconst char *s )
1550 static int yy_flex_strlen( s )
1555 for ( n = 0; s[n]; ++n )
1563 #ifdef YY_USE_PROTOS
1564 static void *yy_flex_alloc( yy_size_t size )
1566 static void *yy_flex_alloc( size )
1570 return (void *) malloc( size );
1573 #ifdef YY_USE_PROTOS
1574 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1576 static void *yy_flex_realloc( ptr, size )
1581 /* The cast to (char *) in the following accommodates both
1582 * implementations that use char* generic pointers, and those
1583 * that use void* generic pointers. It works with the latter
1584 * because both ANSI C and C++ allow castless assignment from
1585 * any pointer type to void*, and deal with argument conversions
1586 * as though doing an assignment.
1588 return (void *) realloc( (char *) ptr, size );
1591 #ifdef YY_USE_PROTOS
1592 static void yy_flex_free( void *ptr )
1594 static void yy_flex_free( ptr )
1611 static void stringvalue()
1613 if (!haserror && entry.name != NULL && (signed)entry.type < 0) {
1614 entry.type = Config_String;
1615 entry.value.string = g_strdup(yytext+1); /* drop the left quote */
1616 if (entry.value.string[yyleng-2] != '"')
1617 printf("warning: improperly terminated string on line %d\n",
1620 entry.value.string[yyleng-2] = '\0';
1625 static void numbervalue()
1627 if (!haserror && entry.name != NULL && (signed)entry.type < 0) {
1628 entry.type = Config_Integer;
1629 entry.value.integer = atoi(yytext);
1634 static void identifier()
1636 g_print("identifier: %s\n", yytext);
1637 entry.name = g_strdup(yytext);
1641 static void newline()
1643 if (!haserror && entry.name != NULL && (signed)entry.type >= 0) {
1644 if (!config_set(entry.name, entry.type, entry.value))
1645 g_warning("Invalid option in config file: '%s'\n", entry.name);
1647 printf("Parser error in config file on line %d\n", yylineno);
1651 if (entry.type == Config_String)
1652 g_free(entry.value.string);
1663 if (entry.type == Config_String)
1664 g_free(entry.value.string);
1668 void cparse_go(FILE *file)