1 #line 2 "lc_config_lexer.c"
3 #line 4 "lc_config_lexer.c"
5 #define YY_INT_ALIGNED short int
7 /* A lexical scanner generated by flex */
9 #define yy_create_buffer _lc_opt__create_buffer
10 #define yy_delete_buffer _lc_opt__delete_buffer
11 #define yy_flex_debug _lc_opt__flex_debug
12 #define yy_init_buffer _lc_opt__init_buffer
13 #define yy_flush_buffer _lc_opt__flush_buffer
14 #define yy_load_buffer_state _lc_opt__load_buffer_state
15 #define yy_switch_to_buffer _lc_opt__switch_to_buffer
16 #define yyin _lc_opt_in
17 #define yyleng _lc_opt_leng
18 #define yylex _lc_opt_lex
19 #define yylineno _lc_opt_lineno
20 #define yyout _lc_opt_out
21 #define yyrestart _lc_opt_restart
22 #define yytext _lc_opt_text
23 #define yywrap _lc_opt_wrap
24 #define yyalloc _lc_opt_alloc
25 #define yyrealloc _lc_opt_realloc
26 #define yyfree _lc_opt_free
29 #define YY_FLEX_MAJOR_VERSION 2
30 #define YY_FLEX_MINOR_VERSION 5
31 #define YY_FLEX_SUBMINOR_VERSION 35
32 #if YY_FLEX_SUBMINOR_VERSION > 0
36 /* First, we deal with platform-specific or compiler-specific issues. */
38 /* begin standard C headers. */
44 /* end standard C headers. */
46 /* flex integer type definitions */
51 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
53 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
55 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
56 * if you want the limit (max/min) macros for int types.
58 #ifndef __STDC_LIMIT_MACROS
59 #define __STDC_LIMIT_MACROS 1
63 typedef int8_t flex_int8_t;
64 typedef uint8_t flex_uint8_t;
65 typedef int16_t flex_int16_t;
66 typedef uint16_t flex_uint16_t;
67 typedef int32_t flex_int32_t;
68 typedef uint32_t flex_uint32_t;
70 typedef signed char flex_int8_t;
71 typedef short int flex_int16_t;
72 typedef int flex_int32_t;
73 typedef unsigned char flex_uint8_t;
74 typedef unsigned short int flex_uint16_t;
75 typedef unsigned int flex_uint32_t;
77 /* Limits of integral types. */
79 #define INT8_MIN (-128)
82 #define INT16_MIN (-32767-1)
85 #define INT32_MIN (-2147483647-1)
88 #define INT8_MAX (127)
91 #define INT16_MAX (32767)
94 #define INT32_MAX (2147483647)
97 #define UINT8_MAX (255U)
100 #define UINT16_MAX (65535U)
103 #define UINT32_MAX (4294967295U)
108 #endif /* ! FLEXINT_H */
112 /* The "const" storage-class-modifier is valid. */
115 #else /* ! __cplusplus */
117 /* C99 requires __STDC__ to be defined as 1. */
118 #if defined (__STDC__)
122 #endif /* defined (__STDC__) */
123 #endif /* ! __cplusplus */
126 #define yyconst const
131 /* Returned upon end-of-file. */
134 /* Promotes a possibly negative, possibly signed char to an unsigned
135 * integer for use as an array index. If the signed char is negative,
136 * we want to instead treat it as an 8-bit unsigned char, hence the
139 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
141 /* Enter a start condition. This macro really ought to take a parameter,
142 * but we do it the disgusting crufty way forced on us by the ()-less
143 * definition of BEGIN.
145 #define BEGIN (yy_start) = 1 + 2 *
147 /* Translate the current start state into a value that can be later handed
148 * to BEGIN to return to the state. The YYSTATE alias is for lex
151 #define YY_START (((yy_start) - 1) / 2)
152 #define YYSTATE YY_START
154 /* Action number for EOF rule of a given start state. */
155 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
157 /* Special action meaning "start processing a new file". */
158 #define YY_NEW_FILE _lc_opt_restart(_lc_opt_in )
160 #define YY_END_OF_BUFFER_CHAR 0
162 /* Size of default input buffer. */
164 #define YY_BUF_SIZE 16384
167 /* The state buf must be large enough to hold one state per character in the main buffer.
169 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
171 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
172 #define YY_TYPEDEF_YY_BUFFER_STATE
173 typedef struct yy_buffer_state *YY_BUFFER_STATE;
176 extern int _lc_opt_leng;
178 extern FILE *_lc_opt_in, *_lc_opt_out;
180 #define EOB_ACT_CONTINUE_SCAN 0
181 #define EOB_ACT_END_OF_FILE 1
182 #define EOB_ACT_LAST_MATCH 2
184 #define YY_LESS_LINENO(n)
186 /* Return all but the first "n" matched characters back to the input stream. */
190 /* Undo effects of setting up _lc_opt_text. */ \
191 int yyless_macro_arg = (n); \
192 YY_LESS_LINENO(yyless_macro_arg);\
193 *yy_cp = (yy_hold_char); \
194 YY_RESTORE_YY_MORE_OFFSET \
195 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
196 YY_DO_BEFORE_ACTION; /* set up _lc_opt_text again */ \
200 #define unput(c) yyunput( c, (yytext_ptr) )
202 #ifndef YY_TYPEDEF_YY_SIZE_T
203 #define YY_TYPEDEF_YY_SIZE_T
204 typedef size_t yy_size_t;
207 #ifndef YY_STRUCT_YY_BUFFER_STATE
208 #define YY_STRUCT_YY_BUFFER_STATE
209 struct yy_buffer_state
213 char *yy_ch_buf; /* input buffer */
214 char *yy_buf_pos; /* current position in input buffer */
216 /* Size of input buffer in bytes, not including room for EOB
219 yy_size_t yy_buf_size;
221 /* Number of characters read into yy_ch_buf, not including EOB
226 /* Whether we "own" the buffer - i.e., we know we created it,
227 * and can realloc() it to grow it, and should free() it to
230 int yy_is_our_buffer;
232 /* Whether this is an "interactive" input source; if so, and
233 * if we're using stdio for input, then we want to use getc()
234 * instead of fread(), to make sure we stop fetching input after
237 int yy_is_interactive;
239 /* Whether we're considered to be at the beginning of a line.
240 * If so, '^' rules will be active on the next match, otherwise
245 int yy_bs_lineno; /**< The line count. */
246 int yy_bs_column; /**< The column count. */
248 /* Whether to try to fill the input buffer when we reach the
253 int yy_buffer_status;
255 #define YY_BUFFER_NEW 0
256 #define YY_BUFFER_NORMAL 1
257 /* When an EOF's been seen but there's still some text to process
258 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
259 * shouldn't try reading from the input source any more. We might
260 * still have a bunch of tokens to match, though, because of
261 * possible backing-up.
263 * When we actually see the EOF, we change the status to "new"
264 * (via _lc_opt_restart()), so that the user can continue scanning by
265 * just pointing _lc_opt_in at a new input file.
267 #define YY_BUFFER_EOF_PENDING 2
270 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
272 /* Stack of input buffers. */
273 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
274 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
275 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
277 /* We provide macros for accessing buffer states in case in the
278 * future we want to put the buffer states in a more general
281 * Returns the top of the stack, or NULL.
283 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
284 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
287 /* Same as previous macro, but useful when we know that the buffer stack is not
288 * NULL or when we need an lvalue. For internal use only.
290 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
292 /* yy_hold_char holds the character lost when _lc_opt_text is formed. */
293 static char yy_hold_char;
294 static int yy_n_chars; /* number of characters read into yy_ch_buf */
297 /* Points to current character in buffer. */
298 static char *yy_c_buf_p = (char *) 0;
299 static int yy_init = 0; /* whether we need to initialize */
300 static int yy_start = 0; /* start state number */
302 /* Flag which is used to allow _lc_opt_wrap()'s to do buffer switches
303 * instead of setting up a fresh _lc_opt_in. A bit of a hack ...
305 static int yy_did_buffer_switch_on_eof;
307 void _lc_opt_restart (FILE *input_file );
308 void _lc_opt__switch_to_buffer (YY_BUFFER_STATE new_buffer );
309 YY_BUFFER_STATE _lc_opt__create_buffer (FILE *file,int size );
310 void _lc_opt__delete_buffer (YY_BUFFER_STATE b );
311 void _lc_opt__flush_buffer (YY_BUFFER_STATE b );
312 void _lc_opt_push_buffer_state (YY_BUFFER_STATE new_buffer );
313 void _lc_opt_pop_buffer_state (void );
315 static void _lc_opt_ensure_buffer_stack (void );
316 static void _lc_opt__load_buffer_state (void );
317 static void _lc_opt__init_buffer (YY_BUFFER_STATE b,FILE *file );
319 #define YY_FLUSH_BUFFER _lc_opt__flush_buffer(YY_CURRENT_BUFFER )
321 YY_BUFFER_STATE _lc_opt__scan_buffer (char *base,yy_size_t size );
322 YY_BUFFER_STATE _lc_opt__scan_string (yyconst char *yy_str );
323 YY_BUFFER_STATE _lc_opt__scan_bytes (yyconst char *bytes,int len );
325 void *_lc_opt_alloc (yy_size_t );
326 void *_lc_opt_realloc (void *,yy_size_t );
327 void _lc_opt_free (void * );
329 #define yy_new_buffer _lc_opt__create_buffer
331 #define yy_set_interactive(is_interactive) \
333 if ( ! YY_CURRENT_BUFFER ){ \
334 _lc_opt_ensure_buffer_stack (); \
335 YY_CURRENT_BUFFER_LVALUE = \
336 _lc_opt__create_buffer(_lc_opt_in,YY_BUF_SIZE ); \
338 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
341 #define yy_set_bol(at_bol) \
343 if ( ! YY_CURRENT_BUFFER ){\
344 _lc_opt_ensure_buffer_stack (); \
345 YY_CURRENT_BUFFER_LVALUE = \
346 _lc_opt__create_buffer(_lc_opt_in,YY_BUF_SIZE ); \
348 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
351 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
353 /* Begin user sect3 */
355 typedef unsigned char YY_CHAR;
357 FILE *_lc_opt_in = (FILE *) 0, *_lc_opt_out = (FILE *) 0;
359 typedef int yy_state_type;
361 extern int _lc_opt_lineno;
363 int _lc_opt_lineno = 1;
365 extern char *_lc_opt_text;
366 #define yytext_ptr _lc_opt_text
368 static yy_state_type yy_get_previous_state (void );
369 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
370 static int yy_get_next_buffer (void );
371 static void yy_fatal_error (yyconst char msg[] );
373 /* Done after the current pattern has been matched and before the
374 * corresponding action - sets up _lc_opt_text.
376 #define YY_DO_BEFORE_ACTION \
377 (yytext_ptr) = yy_bp; \
378 _lc_opt_leng = (size_t) (yy_cp - yy_bp); \
379 (yy_hold_char) = *yy_cp; \
381 (yy_c_buf_p) = yy_cp;
383 #define YY_NUM_RULES 28
384 #define YY_END_OF_BUFFER 29
385 /* This struct is not used in this scanner,
386 but its presence is necessary. */
389 flex_int32_t yy_verify;
392 static yyconst flex_int16_t yy_accept[49] =
394 25, 25, 0, 0, 0, 0, 0, 0, 0, 0,
395 0, 0, 29, 27, 25, 26, 5, 23, 24, 24,
396 8, 7, 6, 4, 3, 4, 11, 12, 9, 10,
397 14, 13, 22, 15, 22, 25, 23, 1, 5, 8,
398 2, 21, 19, 20, 16, 17, 18, 0
401 static yyconst flex_int32_t yy_ec[256] =
403 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
404 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
405 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
406 1, 2, 1, 4, 5, 6, 1, 1, 1, 1,
407 1, 7, 1, 1, 1, 8, 9, 10, 10, 10,
408 10, 10, 10, 10, 10, 10, 10, 11, 1, 1,
409 11, 1, 1, 1, 6, 6, 6, 6, 6, 6,
410 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
411 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
412 1, 12, 1, 1, 6, 1, 6, 13, 6, 6,
414 6, 14, 6, 6, 6, 6, 6, 6, 6, 15,
415 6, 6, 6, 16, 6, 17, 6, 6, 6, 6,
416 6, 6, 1, 1, 1, 1, 1, 1, 1, 1,
417 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
418 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
419 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
420 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
421 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
422 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
423 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
425 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
426 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
427 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
428 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
429 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
433 static yyconst flex_int32_t yy_meta[18] =
435 1, 1, 2, 1, 1, 3, 1, 1, 1, 3,
439 static yyconst flex_int16_t yy_base[56] =
441 0, 0, 62, 39, 15, 16, 21, 31, 38, 37,
442 16, 17, 39, 67, 36, 67, 67, 0, 67, 23,
443 35, 67, 67, 67, 67, 27, 67, 67, 67, 67,
444 67, 67, 67, 67, 31, 29, 0, 67, 67, 25,
445 67, 67, 67, 67, 67, 67, 67, 67, 48, 51,
449 static yyconst flex_int16_t yy_def[56] =
451 48, 1, 49, 49, 50, 50, 51, 51, 52, 52,
452 53, 53, 48, 48, 48, 48, 48, 54, 48, 48,
453 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
454 48, 48, 48, 48, 55, 48, 54, 48, 48, 48,
455 48, 48, 48, 48, 48, 48, 48, 0, 48, 48,
459 static yyconst flex_int16_t yy_nxt[85] =
461 14, 15, 16, 14, 17, 18, 14, 19, 20, 14,
462 21, 14, 18, 18, 18, 18, 18, 25, 25, 34,
463 34, 26, 26, 28, 29, 37, 40, 35, 35, 38,
464 36, 39, 30, 28, 29, 41, 40, 36, 48, 32,
465 32, 23, 30, 43, 44, 45, 46, 47, 22, 22,
466 22, 24, 24, 24, 27, 27, 27, 31, 31, 31,
467 33, 33, 33, 42, 23, 42, 13, 48, 48, 48,
468 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
472 static yyconst flex_int16_t yy_chk[85] =
474 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
475 1, 1, 1, 1, 1, 1, 1, 5, 6, 11,
476 12, 5, 6, 7, 7, 54, 40, 11, 12, 20,
477 36, 20, 7, 8, 8, 26, 21, 15, 13, 10,
478 9, 4, 8, 35, 35, 35, 35, 35, 49, 49,
479 49, 50, 50, 50, 51, 51, 51, 52, 52, 52,
480 53, 53, 53, 55, 3, 55, 48, 48, 48, 48,
481 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
485 static yy_state_type yy_last_accepting_state;
486 static char *yy_last_accepting_cpos;
488 extern int _lc_opt__flex_debug;
489 int _lc_opt__flex_debug = 0;
491 /* The intent behind this definition is that it'll catch
492 * any uses of REJECT which flex missed.
494 #define REJECT reject_used_but_not_detected
495 #define yymore() yymore_used_but_not_detected
496 #define YY_MORE_ADJ 0
497 #define YY_RESTORE_YY_MORE_OFFSET
499 #line 1 "lc_config_lexer.l"
500 #line 5 "lc_config_lexer.l"
503 libcore: library for basic data structures and algorithms.
504 Copyright (C) 2005 IPD Goos, Universit"at Karlsruhe, Germany
506 This library is free software; you can redistribute it and/or
507 modify it under the terms of the GNU Lesser General Public
508 License as published by the Free Software Foundation; either
509 version 2.1 of the License, or (at your option) any later version.
511 This library is distributed in the hope that it will be useful,
512 but WITHOUT ANY WARRANTY; without even the implied warranty of
513 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
514 Lesser General Public License for more details.
516 You should have received a copy of the GNU Lesser General Public
517 License along with this library; if not, write to the Free Software
518 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
524 #include "lc_parser_t.h"
525 #include "lc_config_parser.h"
527 static int _lc_opt_wrap(void)
537 #line 540 "lc_config_lexer.c"
540 #define LINE_COMMENT 1
541 #define BIG_COMMENT 2
546 #ifndef YY_NO_UNISTD_H
547 /* Special case for "unistd.h", since it is non-ANSI. We include it way
548 * down here because we want the user's section 1 to have been scanned first.
549 * The user has a chance to override it with an option.
554 #ifndef YY_EXTRA_TYPE
555 #define YY_EXTRA_TYPE void *
558 static int yy_init_globals (void );
560 /* Accessor methods to globals.
561 These are made visible to non-reentrant scanners for convenience. */
563 int _lc_opt_lex_destroy (void );
565 int _lc_opt_get_debug (void );
567 void _lc_opt_set_debug (int debug_flag );
569 YY_EXTRA_TYPE _lc_opt_get_extra (void );
571 void _lc_opt_set_extra (YY_EXTRA_TYPE user_defined );
573 FILE *_lc_opt_get_in (void );
575 void _lc_opt_set_in (FILE * in_str );
577 FILE *_lc_opt_get_out (void );
579 void _lc_opt_set_out (FILE * out_str );
581 int _lc_opt_get_leng (void );
583 char *_lc_opt_get_text (void );
585 int _lc_opt_get_lineno (void );
587 void _lc_opt_set_lineno (int line_number );
589 /* Macros after this point can all be overridden by user definitions in
593 #ifndef YY_SKIP_YYWRAP
595 extern "C" int _lc_opt_wrap (void );
597 extern int _lc_opt_wrap (void );
601 static void yyunput (int c,char *buf_ptr );
604 static void yy_flex_strncpy (char *,yyconst char *,int );
607 #ifdef YY_NEED_STRLEN
608 static int yy_flex_strlen (yyconst char * );
614 static int yyinput (void );
616 static int input (void );
621 /* Amount of stuff to slurp up with each read. */
622 #ifndef YY_READ_BUF_SIZE
623 #define YY_READ_BUF_SIZE 8192
626 /* Copy whatever the last rule matched to the standard output. */
628 /* This used to be an fputs(), but since the string might contain NUL's,
629 * we now use fwrite().
631 #define ECHO fwrite( _lc_opt_text, _lc_opt_leng, 1, _lc_opt_out )
634 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
635 * is returned in "result".
638 #define YY_INPUT(buf,result,max_size) \
639 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
643 for ( n = 0; n < max_size && \
644 (c = getc( _lc_opt_in )) != EOF && c != '\n'; ++n ) \
647 buf[n++] = (char) c; \
648 if ( c == EOF && ferror( _lc_opt_in ) ) \
649 YY_FATAL_ERROR( "input in flex scanner failed" ); \
655 while ( (result = fread(buf, 1, max_size, _lc_opt_in))==0 && ferror(_lc_opt_in)) \
657 if( errno != EINTR) \
659 YY_FATAL_ERROR( "input in flex scanner failed" ); \
663 clearerr(_lc_opt_in); \
670 /* No semi-colon after return; correct usage is to write "yyterminate();" -
671 * we don't want an extra ';' after the "return" because that will cause
672 * some compilers to complain about unreachable statements.
675 #define yyterminate() return YY_NULL
678 /* Number of entries by which start-condition stack grows. */
679 #ifndef YY_START_STACK_INCR
680 #define YY_START_STACK_INCR 25
683 /* Report a fatal error. */
684 #ifndef YY_FATAL_ERROR
685 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
688 /* end tables serialization structures and prototypes */
690 /* Default declaration of generated scanner - a define so the user can
691 * easily add parameters.
694 #define YY_DECL_IS_OURS 1
696 extern int _lc_opt_lex (void);
698 #define YY_DECL int _lc_opt_lex (void)
699 #endif /* !YY_DECL */
701 /* Code executed at the beginning of each rule, after _lc_opt_text and _lc_opt_leng
704 #ifndef YY_USER_ACTION
705 #define YY_USER_ACTION
708 /* Code executed at the end of each rule. */
710 #define YY_BREAK break;
713 #define YY_RULE_SETUP \
716 /** The main scanner function which does all the work.
720 register yy_state_type yy_current_state;
721 register char *yy_cp, *yy_bp;
724 #line 55 "lc_config_lexer.l"
727 #line 730 "lc_config_lexer.c"
738 (yy_start) = 1; /* first start state */
744 _lc_opt_out = stdout;
746 if ( ! YY_CURRENT_BUFFER ) {
747 _lc_opt_ensure_buffer_stack ();
748 YY_CURRENT_BUFFER_LVALUE =
749 _lc_opt__create_buffer(_lc_opt_in,YY_BUF_SIZE );
752 _lc_opt__load_buffer_state( );
755 while ( 1 ) /* loops until end-of-file is reached */
757 yy_cp = (yy_c_buf_p);
759 /* Support of _lc_opt_text. */
760 *yy_cp = (yy_hold_char);
762 /* yy_bp points to the position in yy_ch_buf of the start of
767 yy_current_state = (yy_start);
771 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
772 if ( yy_accept[yy_current_state] )
774 (yy_last_accepting_state) = yy_current_state;
775 (yy_last_accepting_cpos) = yy_cp;
777 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
779 yy_current_state = (int) yy_def[yy_current_state];
780 if ( yy_current_state >= 49 )
781 yy_c = yy_meta[(unsigned int) yy_c];
783 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
786 while ( yy_base[yy_current_state] != 67 );
789 yy_act = yy_accept[yy_current_state];
791 { /* have to back up */
792 yy_cp = (yy_last_accepting_cpos);
793 yy_current_state = (yy_last_accepting_state);
794 yy_act = yy_accept[yy_current_state];
799 do_action: /* This label is used only to access EOF actions. */
802 { /* beginning of action switch */
803 case 0: /* must back up */
804 /* undo the effects of YY_DO_BEFORE_ACTION */
805 *yy_cp = (yy_hold_char);
806 yy_cp = (yy_last_accepting_cpos);
807 yy_current_state = (yy_last_accepting_state);
812 #line 57 "lc_config_lexer.l"
813 { BEGIN(BIG_COMMENT); }
817 #line 58 "lc_config_lexer.l"
821 /* rule 3 can match eol */
823 #line 59 "lc_config_lexer.l"
828 #line 60 "lc_config_lexer.l"
833 #line 62 "lc_config_lexer.l"
834 { BEGIN(LINE_COMMENT); }
837 /* rule 6 can match eol */
839 #line 63 "lc_config_lexer.l"
840 { BEGIN(INITIAL); PMANGLE(linenr)++; }
844 #line 64 "lc_config_lexer.l"
849 #line 67 "lc_config_lexer.l"
854 #line 68 "lc_config_lexer.l"
859 #line 69 "lc_config_lexer.l"
864 #line 70 "lc_config_lexer.l"
865 { _lc_opt_add_to_data_char(PMANGLE(text)[0]); }
868 /* rule 12 can match eol */
870 #line 71 "lc_config_lexer.l"
874 _lc_opt_add_to_data_char('\0');
879 /* rule 13 can match eol */
881 #line 77 "lc_config_lexer.l"
882 { BEGIN(DAT); PMANGLE(linenr)++; }
886 #line 78 "lc_config_lexer.l"
891 #line 81 "lc_config_lexer.l"
894 _lc_opt_add_to_data_char('\0');
900 #line 87 "lc_config_lexer.l"
901 _lc_opt_add_to_data_char('\n');
905 #line 88 "lc_config_lexer.l"
906 _lc_opt_add_to_data_char('\r');
910 #line 89 "lc_config_lexer.l"
911 _lc_opt_add_to_data_char('\t');
915 #line 90 "lc_config_lexer.l"
916 _lc_opt_add_to_data_char('\b');
920 #line 91 "lc_config_lexer.l"
921 _lc_opt_add_to_data_char('\f');
925 #line 92 "lc_config_lexer.l"
926 _lc_opt_add_to_data_char(_lc_opt_text[1]);
929 /* rule 22 can match eol */
931 #line 93 "lc_config_lexer.l"
932 _lc_opt_add_to_data_char(_lc_opt_text[0]);
936 #line 95 "lc_config_lexer.l"
938 PMANGLE(lval).text.str = PMANGLE(text);
939 PMANGLE(lval).text.len = PMANGLE(leng);
945 #line 100 "lc_config_lexer.l"
950 #line 102 "lc_config_lexer.l"
954 /* rule 26 can match eol */
956 #line 103 "lc_config_lexer.l"
961 #line 105 "lc_config_lexer.l"
962 return _lc_opt_text[0];
966 #line 107 "lc_config_lexer.l"
969 #line 972 "lc_config_lexer.c"
970 case YY_STATE_EOF(INITIAL):
971 case YY_STATE_EOF(LINE_COMMENT):
972 case YY_STATE_EOF(BIG_COMMENT):
973 case YY_STATE_EOF(DAT):
974 case YY_STATE_EOF(DAT_CONT):
975 case YY_STATE_EOF(STR):
978 case YY_END_OF_BUFFER:
980 /* Amount of text matched not including the EOB char. */
981 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
983 /* Undo the effects of YY_DO_BEFORE_ACTION. */
984 *yy_cp = (yy_hold_char);
985 YY_RESTORE_YY_MORE_OFFSET
987 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
989 /* We're scanning a new file or input source. It's
990 * possible that this happened because the user
991 * just pointed _lc_opt_in at a new source and called
992 * _lc_opt_lex(). If so, then we have to assure
993 * consistency between YY_CURRENT_BUFFER and our
994 * globals. Here is the right place to do so, because
995 * this is the first action (other than possibly a
996 * back-up) that will match for the new input source.
998 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
999 YY_CURRENT_BUFFER_LVALUE->yy_input_file = _lc_opt_in;
1000 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1003 /* Note that here we test for yy_c_buf_p "<=" to the position
1004 * of the first EOB in the buffer, since yy_c_buf_p will
1005 * already have been incremented past the NUL character
1006 * (since all states make transitions on EOB to the
1007 * end-of-buffer state). Contrast this with the test
1010 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1011 { /* This was really a NUL. */
1012 yy_state_type yy_next_state;
1014 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1016 yy_current_state = yy_get_previous_state( );
1018 /* Okay, we're now positioned to make the NUL
1019 * transition. We couldn't have
1020 * yy_get_previous_state() go ahead and do it
1021 * for us because it doesn't know how to deal
1022 * with the possibility of jamming (and we don't
1023 * want to build jamming into it because then it
1024 * will run more slowly).
1027 yy_next_state = yy_try_NUL_trans( yy_current_state );
1029 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1031 if ( yy_next_state )
1033 /* Consume the NUL. */
1034 yy_cp = ++(yy_c_buf_p);
1035 yy_current_state = yy_next_state;
1041 yy_cp = (yy_c_buf_p);
1042 goto yy_find_action;
1046 else switch ( yy_get_next_buffer( ) )
1048 case EOB_ACT_END_OF_FILE:
1050 (yy_did_buffer_switch_on_eof) = 0;
1052 if ( _lc_opt_wrap( ) )
1054 /* Note: because we've taken care in
1055 * yy_get_next_buffer() to have set up
1056 * _lc_opt_text, we can now set up
1057 * yy_c_buf_p so that if some total
1058 * hoser (like flex itself) wants to
1059 * call the scanner after we return the
1060 * YY_NULL, it'll still work - another
1061 * YY_NULL will get returned.
1063 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1065 yy_act = YY_STATE_EOF(YY_START);
1071 if ( ! (yy_did_buffer_switch_on_eof) )
1077 case EOB_ACT_CONTINUE_SCAN:
1079 (yytext_ptr) + yy_amount_of_matched_text;
1081 yy_current_state = yy_get_previous_state( );
1083 yy_cp = (yy_c_buf_p);
1084 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1087 case EOB_ACT_LAST_MATCH:
1089 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1091 yy_current_state = yy_get_previous_state( );
1093 yy_cp = (yy_c_buf_p);
1094 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1095 goto yy_find_action;
1102 "fatal flex scanner internal error--no action found" );
1103 } /* end of action switch */
1104 } /* end of scanning one token */
1105 } /* end of _lc_opt_lex */
1107 /* yy_get_next_buffer - try to read in a new buffer
1109 * Returns a code representing an action:
1110 * EOB_ACT_LAST_MATCH -
1111 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1112 * EOB_ACT_END_OF_FILE - end of file
1114 static int yy_get_next_buffer (void)
1116 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1117 register char *source = (yytext_ptr);
1118 register int number_to_move, i;
1121 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1123 "fatal flex scanner internal error--end of buffer missed" );
1125 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1126 { /* Don't try to fill the buffer, so this is an EOF. */
1127 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1129 /* We matched a single character, the EOB, so
1130 * treat this as a final EOF.
1132 return EOB_ACT_END_OF_FILE;
1137 /* We matched some text prior to the EOB, first
1140 return EOB_ACT_LAST_MATCH;
1144 /* Try to read more data. */
1146 /* First move last chars to start of buffer. */
1147 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1149 for ( i = 0; i < number_to_move; ++i )
1150 *(dest++) = *(source++);
1152 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1153 /* don't do the read, it's not guaranteed to return an EOF,
1156 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1161 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1163 while ( num_to_read <= 0 )
1164 { /* Not enough room in the buffer - grow it. */
1166 /* just a shorter name for the current buffer */
1167 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1169 int yy_c_buf_p_offset =
1170 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1172 if ( b->yy_is_our_buffer )
1174 int new_size = b->yy_buf_size * 2;
1176 if ( new_size <= 0 )
1177 b->yy_buf_size += b->yy_buf_size / 8;
1179 b->yy_buf_size *= 2;
1181 b->yy_ch_buf = (char *)
1182 /* Include room in for 2 EOB chars. */
1183 _lc_opt_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1186 /* Can't grow it, we don't own it. */
1189 if ( ! b->yy_ch_buf )
1191 "fatal error - scanner input buffer overflow" );
1193 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1195 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1200 if ( num_to_read > YY_READ_BUF_SIZE )
1201 num_to_read = YY_READ_BUF_SIZE;
1203 /* Read in more data. */
1204 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1205 (yy_n_chars), (size_t) num_to_read );
1207 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1210 if ( (yy_n_chars) == 0 )
1212 if ( number_to_move == YY_MORE_ADJ )
1214 ret_val = EOB_ACT_END_OF_FILE;
1215 _lc_opt_restart(_lc_opt_in );
1220 ret_val = EOB_ACT_LAST_MATCH;
1221 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1222 YY_BUFFER_EOF_PENDING;
1227 ret_val = EOB_ACT_CONTINUE_SCAN;
1229 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1230 /* Extend the array by 50%, plus the number we really need. */
1231 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1232 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) _lc_opt_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1233 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1234 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1237 (yy_n_chars) += number_to_move;
1238 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1239 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1241 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1246 /* yy_get_previous_state - get the state just before the EOB char was reached */
1248 static yy_state_type yy_get_previous_state (void)
1250 register yy_state_type yy_current_state;
1251 register char *yy_cp;
1253 yy_current_state = (yy_start);
1255 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1257 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1258 if ( yy_accept[yy_current_state] )
1260 (yy_last_accepting_state) = yy_current_state;
1261 (yy_last_accepting_cpos) = yy_cp;
1263 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1265 yy_current_state = (int) yy_def[yy_current_state];
1266 if ( yy_current_state >= 49 )
1267 yy_c = yy_meta[(unsigned int) yy_c];
1269 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1272 return yy_current_state;
1275 /* yy_try_NUL_trans - try to make a transition on the NUL character
1278 * next_state = yy_try_NUL_trans( current_state );
1280 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1282 register int yy_is_jam;
1283 register char *yy_cp = (yy_c_buf_p);
1285 register YY_CHAR yy_c = 1;
1286 if ( yy_accept[yy_current_state] )
1288 (yy_last_accepting_state) = yy_current_state;
1289 (yy_last_accepting_cpos) = yy_cp;
1291 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1293 yy_current_state = (int) yy_def[yy_current_state];
1294 if ( yy_current_state >= 49 )
1295 yy_c = yy_meta[(unsigned int) yy_c];
1297 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1298 yy_is_jam = (yy_current_state == 48);
1300 return yy_is_jam ? 0 : yy_current_state;
1303 static void yyunput (int c, register char * yy_bp )
1305 register char *yy_cp;
1307 yy_cp = (yy_c_buf_p);
1309 /* undo effects of setting up _lc_opt_text */
1310 *yy_cp = (yy_hold_char);
1312 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1313 { /* need to shift things up to make room */
1314 /* +2 for EOB chars. */
1315 register int number_to_move = (yy_n_chars) + 2;
1316 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1317 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1318 register char *source =
1319 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1321 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1322 *--dest = *--source;
1324 yy_cp += (int) (dest - source);
1325 yy_bp += (int) (dest - source);
1326 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1327 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1329 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1330 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1333 *--yy_cp = (char) c;
1335 (yytext_ptr) = yy_bp;
1336 (yy_hold_char) = *yy_cp;
1337 (yy_c_buf_p) = yy_cp;
1342 static int yyinput (void)
1344 static int input (void)
1350 *(yy_c_buf_p) = (yy_hold_char);
1352 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1354 /* yy_c_buf_p now points to the character we want to return.
1355 * If this occurs *before* the EOB characters, then it's a
1356 * valid NUL; if not, then we've hit the end of the buffer.
1358 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1359 /* This was really a NUL. */
1360 *(yy_c_buf_p) = '\0';
1363 { /* need more input */
1364 int offset = (yy_c_buf_p) - (yytext_ptr);
1367 switch ( yy_get_next_buffer( ) )
1369 case EOB_ACT_LAST_MATCH:
1370 /* This happens because yy_g_n_b()
1371 * sees that we've accumulated a
1372 * token and flags that we need to
1373 * try matching the token before
1374 * proceeding. But for input(),
1375 * there's no matching to consider.
1376 * So convert the EOB_ACT_LAST_MATCH
1377 * to EOB_ACT_END_OF_FILE.
1380 /* Reset buffer status. */
1381 _lc_opt_restart(_lc_opt_in );
1385 case EOB_ACT_END_OF_FILE:
1387 if ( _lc_opt_wrap( ) )
1390 if ( ! (yy_did_buffer_switch_on_eof) )
1399 case EOB_ACT_CONTINUE_SCAN:
1400 (yy_c_buf_p) = (yytext_ptr) + offset;
1406 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1407 *(yy_c_buf_p) = '\0'; /* preserve _lc_opt_text */
1408 (yy_hold_char) = *++(yy_c_buf_p);
1412 #endif /* ifndef YY_NO_INPUT */
1414 /** Immediately switch to a different input stream.
1415 * @param input_file A readable stream.
1417 * @note This function does not reset the start condition to @c INITIAL .
1419 void _lc_opt_restart (FILE * input_file )
1422 if ( ! YY_CURRENT_BUFFER ){
1423 _lc_opt_ensure_buffer_stack ();
1424 YY_CURRENT_BUFFER_LVALUE =
1425 _lc_opt__create_buffer(_lc_opt_in,YY_BUF_SIZE );
1428 _lc_opt__init_buffer(YY_CURRENT_BUFFER,input_file );
1429 _lc_opt__load_buffer_state( );
1432 /** Switch to a different input buffer.
1433 * @param new_buffer The new input buffer.
1436 void _lc_opt__switch_to_buffer (YY_BUFFER_STATE new_buffer )
1439 /* TODO. We should be able to replace this entire function body
1441 * _lc_opt_pop_buffer_state();
1442 * _lc_opt_push_buffer_state(new_buffer);
1444 _lc_opt_ensure_buffer_stack ();
1445 if ( YY_CURRENT_BUFFER == new_buffer )
1448 if ( YY_CURRENT_BUFFER )
1450 /* Flush out information for old buffer. */
1451 *(yy_c_buf_p) = (yy_hold_char);
1452 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1453 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1456 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1457 _lc_opt__load_buffer_state( );
1459 /* We don't actually know whether we did this switch during
1460 * EOF (_lc_opt_wrap()) processing, but the only time this flag
1461 * is looked at is after _lc_opt_wrap() is called, so it's safe
1462 * to go ahead and always set it.
1464 (yy_did_buffer_switch_on_eof) = 1;
1467 static void _lc_opt__load_buffer_state (void)
1469 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1470 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1471 _lc_opt_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1472 (yy_hold_char) = *(yy_c_buf_p);
1475 /** Allocate and initialize an input buffer state.
1476 * @param file A readable stream.
1477 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1479 * @return the allocated buffer state.
1481 YY_BUFFER_STATE _lc_opt__create_buffer (FILE * file, int size )
1485 b = (YY_BUFFER_STATE) _lc_opt_alloc(sizeof( struct yy_buffer_state ) );
1487 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt__create_buffer()" );
1489 b->yy_buf_size = size;
1491 /* yy_ch_buf has to be 2 characters longer than the size given because
1492 * we need to put in 2 end-of-buffer characters.
1494 b->yy_ch_buf = (char *) _lc_opt_alloc(b->yy_buf_size + 2 );
1495 if ( ! b->yy_ch_buf )
1496 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt__create_buffer()" );
1498 b->yy_is_our_buffer = 1;
1500 _lc_opt__init_buffer(b,file );
1505 /** Destroy the buffer.
1506 * @param b a buffer created with _lc_opt__create_buffer()
1509 void _lc_opt__delete_buffer (YY_BUFFER_STATE b )
1515 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1516 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1518 if ( b->yy_is_our_buffer )
1519 _lc_opt_free((void *) b->yy_ch_buf );
1521 _lc_opt_free((void *) b );
1525 extern int isatty (int );
1526 #endif /* __cplusplus */
1528 /* Initializes or reinitializes a buffer.
1529 * This function is sometimes called more than once on the same buffer,
1530 * such as during a _lc_opt_restart() or at EOF.
1532 static void _lc_opt__init_buffer (YY_BUFFER_STATE b, FILE * file )
1537 _lc_opt__flush_buffer(b );
1539 b->yy_input_file = file;
1540 b->yy_fill_buffer = 1;
1542 /* If b is the current buffer, then _lc_opt__init_buffer was _probably_
1543 * called from _lc_opt_restart() or through yy_get_next_buffer.
1544 * In that case, we don't want to reset the lineno or column.
1546 if (b != YY_CURRENT_BUFFER){
1547 b->yy_bs_lineno = 1;
1548 b->yy_bs_column = 0;
1551 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1556 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1557 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1560 void _lc_opt__flush_buffer (YY_BUFFER_STATE b )
1567 /* We always need two end-of-buffer characters. The first causes
1568 * a transition to the end-of-buffer state. The second causes
1569 * a jam in that state.
1571 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1572 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1574 b->yy_buf_pos = &b->yy_ch_buf[0];
1577 b->yy_buffer_status = YY_BUFFER_NEW;
1579 if ( b == YY_CURRENT_BUFFER )
1580 _lc_opt__load_buffer_state( );
1583 /** Pushes the new state onto the stack. The new state becomes
1584 * the current state. This function will allocate the stack
1586 * @param new_buffer The new state.
1589 void _lc_opt_push_buffer_state (YY_BUFFER_STATE new_buffer )
1591 if (new_buffer == NULL)
1594 _lc_opt_ensure_buffer_stack();
1596 /* This block is copied from _lc_opt__switch_to_buffer. */
1597 if ( YY_CURRENT_BUFFER )
1599 /* Flush out information for old buffer. */
1600 *(yy_c_buf_p) = (yy_hold_char);
1601 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1602 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1605 /* Only push if top exists. Otherwise, replace top. */
1606 if (YY_CURRENT_BUFFER)
1607 (yy_buffer_stack_top)++;
1608 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1610 /* copied from _lc_opt__switch_to_buffer. */
1611 _lc_opt__load_buffer_state( );
1612 (yy_did_buffer_switch_on_eof) = 1;
1615 /** Removes and deletes the top of the stack, if present.
1616 * The next element becomes the new top.
1619 void _lc_opt_pop_buffer_state (void)
1621 if (!YY_CURRENT_BUFFER)
1624 _lc_opt__delete_buffer(YY_CURRENT_BUFFER );
1625 YY_CURRENT_BUFFER_LVALUE = NULL;
1626 if ((yy_buffer_stack_top) > 0)
1627 --(yy_buffer_stack_top);
1629 if (YY_CURRENT_BUFFER) {
1630 _lc_opt__load_buffer_state( );
1631 (yy_did_buffer_switch_on_eof) = 1;
1635 /* Allocates the stack if it does not exist.
1636 * Guarantees space for at least one push.
1638 static void _lc_opt_ensure_buffer_stack (void)
1642 if (!(yy_buffer_stack)) {
1644 /* First allocation is just for 2 elements, since we don't know if this
1645 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1646 * immediate realloc on the next call.
1649 (yy_buffer_stack) = (struct yy_buffer_state**)_lc_opt_alloc
1650 (num_to_alloc * sizeof(struct yy_buffer_state*)
1652 if ( ! (yy_buffer_stack) )
1653 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt_ensure_buffer_stack()" );
1655 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1657 (yy_buffer_stack_max) = num_to_alloc;
1658 (yy_buffer_stack_top) = 0;
1662 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1664 /* Increase the buffer to prepare for a possible push. */
1665 int grow_size = 8 /* arbitrary grow size */;
1667 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1668 (yy_buffer_stack) = (struct yy_buffer_state**)_lc_opt_realloc
1670 num_to_alloc * sizeof(struct yy_buffer_state*)
1672 if ( ! (yy_buffer_stack) )
1673 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt_ensure_buffer_stack()" );
1675 /* zero only the new slots.*/
1676 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1677 (yy_buffer_stack_max) = num_to_alloc;
1681 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1682 * @param base the character buffer
1683 * @param size the size in bytes of the character buffer
1685 * @return the newly allocated buffer state object.
1687 YY_BUFFER_STATE _lc_opt__scan_buffer (char * base, yy_size_t size )
1692 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1693 base[size-1] != YY_END_OF_BUFFER_CHAR )
1694 /* They forgot to leave room for the EOB's. */
1697 b = (YY_BUFFER_STATE) _lc_opt_alloc(sizeof( struct yy_buffer_state ) );
1699 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt__scan_buffer()" );
1701 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1702 b->yy_buf_pos = b->yy_ch_buf = base;
1703 b->yy_is_our_buffer = 0;
1704 b->yy_input_file = 0;
1705 b->yy_n_chars = b->yy_buf_size;
1706 b->yy_is_interactive = 0;
1708 b->yy_fill_buffer = 0;
1709 b->yy_buffer_status = YY_BUFFER_NEW;
1711 _lc_opt__switch_to_buffer(b );
1716 /** Setup the input buffer state to scan a string. The next call to _lc_opt_lex() will
1717 * scan from a @e copy of @a str.
1718 * @param yystr a NUL-terminated string to scan
1720 * @return the newly allocated buffer state object.
1721 * @note If you want to scan bytes that may contain NUL values, then use
1722 * _lc_opt__scan_bytes() instead.
1724 YY_BUFFER_STATE _lc_opt__scan_string (yyconst char * yystr )
1727 return _lc_opt__scan_bytes(yystr,strlen(yystr) );
1730 /** Setup the input buffer state to scan the given bytes. The next call to _lc_opt_lex() will
1731 * scan from a @e copy of @a bytes.
1732 * @param bytes the byte buffer to scan
1733 * @param len the number of bytes in the buffer pointed to by @a bytes.
1735 * @return the newly allocated buffer state object.
1737 YY_BUFFER_STATE _lc_opt__scan_bytes (yyconst char * yybytes, int _yybytes_len )
1744 /* Get memory for full buffer, including space for trailing EOB's. */
1745 n = _yybytes_len + 2;
1746 buf = (char *) _lc_opt_alloc(n );
1748 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt__scan_bytes()" );
1750 for ( i = 0; i < _yybytes_len; ++i )
1751 buf[i] = yybytes[i];
1753 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1755 b = _lc_opt__scan_buffer(buf,n );
1757 YY_FATAL_ERROR( "bad buffer in _lc_opt__scan_bytes()" );
1759 /* It's okay to grow etc. this buffer, and we should throw it
1760 * away when we're done.
1762 b->yy_is_our_buffer = 1;
1767 #ifndef YY_EXIT_FAILURE
1768 #define YY_EXIT_FAILURE 2
1771 static void yy_fatal_error (yyconst char* msg )
1773 (void) fprintf( stderr, "%s\n", msg );
1774 exit( YY_EXIT_FAILURE );
1777 /* Redefine yyless() so it works in section 3 code. */
1783 /* Undo effects of setting up _lc_opt_text. */ \
1784 int yyless_macro_arg = (n); \
1785 YY_LESS_LINENO(yyless_macro_arg);\
1786 _lc_opt_text[_lc_opt_leng] = (yy_hold_char); \
1787 (yy_c_buf_p) = _lc_opt_text + yyless_macro_arg; \
1788 (yy_hold_char) = *(yy_c_buf_p); \
1789 *(yy_c_buf_p) = '\0'; \
1790 _lc_opt_leng = yyless_macro_arg; \
1794 /* Accessor methods (get/set functions) to struct members. */
1796 /** Get the current line number.
1799 int _lc_opt_get_lineno (void)
1802 return _lc_opt_lineno;
1805 /** Get the input stream.
1808 FILE *_lc_opt_get_in (void)
1813 /** Get the output stream.
1816 FILE *_lc_opt_get_out (void)
1821 /** Get the length of the current token.
1824 int _lc_opt_get_leng (void)
1826 return _lc_opt_leng;
1829 /** Get the current token.
1833 char *_lc_opt_get_text (void)
1835 return _lc_opt_text;
1838 /** Set the current line number.
1839 * @param line_number
1842 void _lc_opt_set_lineno (int line_number )
1845 _lc_opt_lineno = line_number;
1848 /** Set the input stream. This does not discard the current
1850 * @param in_str A readable stream.
1852 * @see _lc_opt__switch_to_buffer
1854 void _lc_opt_set_in (FILE * in_str )
1856 _lc_opt_in = in_str ;
1859 void _lc_opt_set_out (FILE * out_str )
1861 _lc_opt_out = out_str ;
1864 int _lc_opt_get_debug (void)
1866 return _lc_opt__flex_debug;
1869 void _lc_opt_set_debug (int bdebug )
1871 _lc_opt__flex_debug = bdebug ;
1874 static int yy_init_globals (void)
1876 /* Initialization is the same as for the non-reentrant scanner.
1877 * This function is called from _lc_opt_lex_destroy(), so don't allocate here.
1880 (yy_buffer_stack) = 0;
1881 (yy_buffer_stack_top) = 0;
1882 (yy_buffer_stack_max) = 0;
1883 (yy_c_buf_p) = (char *) 0;
1887 /* Defined in main.c */
1890 _lc_opt_out = stdout;
1892 _lc_opt_in = (FILE *) 0;
1893 _lc_opt_out = (FILE *) 0;
1896 /* For future reference: Set errno on error, since we are called by
1897 * _lc_opt_lex_init()
1902 /* _lc_opt_lex_destroy is for both reentrant and non-reentrant scanners. */
1903 int _lc_opt_lex_destroy (void)
1906 /* Pop the buffer stack, destroying each element. */
1907 while(YY_CURRENT_BUFFER){
1908 _lc_opt__delete_buffer(YY_CURRENT_BUFFER );
1909 YY_CURRENT_BUFFER_LVALUE = NULL;
1910 _lc_opt_pop_buffer_state();
1913 /* Destroy the stack itself. */
1914 _lc_opt_free((yy_buffer_stack) );
1915 (yy_buffer_stack) = NULL;
1917 /* Reset the globals. This is important in a non-reentrant scanner so the next time
1918 * _lc_opt_lex() is called, initialization will occur. */
1925 * Internal utility routines.
1929 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1932 for ( i = 0; i < n; ++i )
1937 #ifdef YY_NEED_STRLEN
1938 static int yy_flex_strlen (yyconst char * s )
1941 for ( n = 0; s[n]; ++n )
1948 void *_lc_opt_alloc (yy_size_t size )
1950 return (void *) malloc( size );
1953 void *_lc_opt_realloc (void * ptr, yy_size_t size )
1955 /* The cast to (char *) in the following accommodates both
1956 * implementations that use char* generic pointers, and those
1957 * that use void* generic pointers. It works with the latter
1958 * because both ANSI C and C++ allow castless assignment from
1959 * any pointer type to void*, and deal with argument conversions
1960 * as though doing an assignment.
1962 return (void *) realloc( (char *) ptr, size );
1965 void _lc_opt_free (void * ptr )
1967 free( (char *) ptr ); /* see _lc_opt_realloc() for (char *) cast */
1970 #define YYTABLES_NAME "yytables"
1972 #line 107 "lc_config_lexer.l"