nsz Git - libfirm/blob - ir/libcore/lc_config_lexer.c

   1 #line 2 "lc_config_lexer.c"
   2
   3 #line 4 "lc_config_lexer.c"
   4
   5 #define  YY_INT_ALIGNED short int
   6
   7 /* A lexical scanner generated by flex */
   8
   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
  27
  28 #define FLEX_SCANNER
  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
  33 #define FLEX_BETA
  34 #endif
  35
  36 /* First, we deal with  platform-specific or compiler-specific issues. */
  37
  38 /* begin standard C headers. */
  39 #include <stdio.h>
  40 #include <string.h>
  41 #include <errno.h>
  42 #include <stdlib.h>
  43
  44 /* end standard C headers. */
  45
  46 /* flex integer type definitions */
  47
  48 #ifndef FLEXINT_H
  49 #define FLEXINT_H
  50
  51 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  52
  53 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
  54
  55 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  56  * if you want the limit (max/min) macros for int types.
  57  */
  58 #ifndef __STDC_LIMIT_MACROS
  59 #define __STDC_LIMIT_MACROS 1
  60 #endif
  61
  62 #include <inttypes.h>
  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;
  69 #else
  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;
  76
  77 /* Limits of integral types. */
  78 #ifndef INT8_MIN
  79 #define INT8_MIN               (-128)
  80 #endif
  81 #ifndef INT16_MIN
  82 #define INT16_MIN              (-32767-1)
  83 #endif
  84 #ifndef INT32_MIN
  85 #define INT32_MIN              (-2147483647-1)
  86 #endif
  87 #ifndef INT8_MAX
  88 #define INT8_MAX               (127)
  89 #endif
  90 #ifndef INT16_MAX
  91 #define INT16_MAX              (32767)
  92 #endif
  93 #ifndef INT32_MAX
  94 #define INT32_MAX              (2147483647)
  95 #endif
  96 #ifndef UINT8_MAX
  97 #define UINT8_MAX              (255U)
  98 #endif
  99 #ifndef UINT16_MAX
 100 #define UINT16_MAX             (65535U)
 101 #endif
 102 #ifndef UINT32_MAX
 103 #define UINT32_MAX             (4294967295U)
 104 #endif
 105
 106 #endif /* ! C99 */
 107
 108 #endif /* ! FLEXINT_H */
 109
 110 #ifdef __cplusplus
 111
 112 /* The "const" storage-class-modifier is valid. */
 113 #define YY_USE_CONST
 114
 115 #else   /* ! __cplusplus */
 116
 117 /* C99 requires __STDC__ to be defined as 1. */
 118 #if defined (__STDC__)
 119
 120 #define YY_USE_CONST
 121
 122 #endif  /* defined (__STDC__) */
 123 #endif  /* ! __cplusplus */
 124
 125 #ifdef YY_USE_CONST
 126 #define yyconst const
 127 #else
 128 #define yyconst
 129 #endif
 130
 131 /* Returned upon end-of-file. */
 132 #define YY_NULL 0
 133
 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
 137  * double cast.
 138  */
 139 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 140
 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.
 144  */
 145 #define BEGIN (yy_start) = 1 + 2 *
 146
 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
 149  * compatibility.
 150  */
 151 #define YY_START (((yy_start) - 1) / 2)
 152 #define YYSTATE YY_START
 153
 154 /* Action number for EOF rule of a given start state. */
 155 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 156
 157 /* Special action meaning "start processing a new file". */
 158 #define YY_NEW_FILE _lc_opt_restart(_lc_opt_in  )
 159
 160 #define YY_END_OF_BUFFER_CHAR 0
 161
 162 /* Size of default input buffer. */
 163 #ifndef YY_BUF_SIZE
 164 #ifdef __ia64__
 165 /* On IA-64, the buffer size is 16k, not 8k.
 166  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
 167  * Ditto for the __ia64__ case accordingly.
 168  */
 169 #define YY_BUF_SIZE 32768
 170 #else
 171 #define YY_BUF_SIZE 16384
 172 #endif /* __ia64__ */
 173 #endif
 174
 175 /* The state buf must be large enough to hold one state per character in the main buffer.
 176  */
 177 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 178
 179 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 180 #define YY_TYPEDEF_YY_BUFFER_STATE
 181 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 182 #endif
 183
 184 extern int _lc_opt_leng;
 185
 186 extern FILE *_lc_opt_in, *_lc_opt_out;
 187
 188 #define EOB_ACT_CONTINUE_SCAN 0
 189 #define EOB_ACT_END_OF_FILE 1
 190 #define EOB_ACT_LAST_MATCH 2
 191
 192     #define YY_LESS_LINENO(n)
 193
 194 /* Return all but the first "n" matched characters back to the input stream. */
 195 #define yyless(n) \
 196         do \
 197                 { \
 198                 /* Undo effects of setting up _lc_opt_text. */ \
 199         int yyless_macro_arg = (n); \
 200         YY_LESS_LINENO(yyless_macro_arg);\
 201                 *yy_cp = (yy_hold_char); \
 202                 YY_RESTORE_YY_MORE_OFFSET \
 203                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 204                 YY_DO_BEFORE_ACTION; /* set up _lc_opt_text again */ \
 205                 } \
 206         while ( 0 )
 207
 208 #define unput(c) yyunput( c, (yytext_ptr)  )
 209
 210 #ifndef YY_TYPEDEF_YY_SIZE_T
 211 #define YY_TYPEDEF_YY_SIZE_T
 212 typedef size_t yy_size_t;
 213 #endif
 214
 215 #ifndef YY_STRUCT_YY_BUFFER_STATE
 216 #define YY_STRUCT_YY_BUFFER_STATE
 217 struct yy_buffer_state
 218         {
 219         FILE *yy_input_file;
 220
 221         char *yy_ch_buf;                /* input buffer */
 222         char *yy_buf_pos;               /* current position in input buffer */
 223
 224         /* Size of input buffer in bytes, not including room for EOB
 225          * characters.
 226          */
 227         yy_size_t yy_buf_size;
 228
 229         /* Number of characters read into yy_ch_buf, not including EOB
 230          * characters.
 231          */
 232         int yy_n_chars;
 233
 234         /* Whether we "own" the buffer - i.e., we know we created it,
 235          * and can realloc() it to grow it, and should free() it to
 236          * delete it.
 237          */
 238         int yy_is_our_buffer;
 239
 240         /* Whether this is an "interactive" input source; if so, and
 241          * if we're using stdio for input, then we want to use getc()
 242          * instead of fread(), to make sure we stop fetching input after
 243          * each newline.
 244          */
 245         int yy_is_interactive;
 246
 247         /* Whether we're considered to be at the beginning of a line.
 248          * If so, '^' rules will be active on the next match, otherwise
 249          * not.
 250          */
 251         int yy_at_bol;
 252
 253     int yy_bs_lineno; /**< The line count. */
 254     int yy_bs_column; /**< The column count. */
 255
 256         /* Whether to try to fill the input buffer when we reach the
 257          * end of it.
 258          */
 259         int yy_fill_buffer;
 260
 261         int yy_buffer_status;
 262
 263 #define YY_BUFFER_NEW 0
 264 #define YY_BUFFER_NORMAL 1
 265         /* When an EOF's been seen but there's still some text to process
 266          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 267          * shouldn't try reading from the input source any more.  We might
 268          * still have a bunch of tokens to match, though, because of
 269          * possible backing-up.
 270          *
 271          * When we actually see the EOF, we change the status to "new"
 272          * (via _lc_opt_restart()), so that the user can continue scanning by
 273          * just pointing _lc_opt_in at a new input file.
 274          */
 275 #define YY_BUFFER_EOF_PENDING 2
 276
 277         };
 278 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 279
 280 /* Stack of input buffers. */
 281 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 282 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 283 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 284
 285 /* We provide macros for accessing buffer states in case in the
 286  * future we want to put the buffer states in a more general
 287  * "scanner state".
 288  *
 289  * Returns the top of the stack, or NULL.
 290  */
 291 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
 292                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
 293                           : NULL)
 294
 295 /* Same as previous macro, but useful when we know that the buffer stack is not
 296  * NULL or when we need an lvalue. For internal use only.
 297  */
 298 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 299
 300 /* yy_hold_char holds the character lost when _lc_opt_text is formed. */
 301 static char yy_hold_char;
 302 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 303 int _lc_opt_leng;
 304
 305 /* Points to current character in buffer. */
 306 static char *yy_c_buf_p = (char *) 0;
 307 static int yy_init = 0;         /* whether we need to initialize */
 308 static int yy_start = 0;        /* start state number */
 309
 310 /* Flag which is used to allow _lc_opt_wrap()'s to do buffer switches
 311  * instead of setting up a fresh _lc_opt_in.  A bit of a hack ...
 312  */
 313 static int yy_did_buffer_switch_on_eof;
 314
 315 void _lc_opt_restart (FILE *input_file  );
 316 void _lc_opt__switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 317 YY_BUFFER_STATE _lc_opt__create_buffer (FILE *file,int size  );
 318 void _lc_opt__delete_buffer (YY_BUFFER_STATE b  );
 319 void _lc_opt__flush_buffer (YY_BUFFER_STATE b  );
 320 void _lc_opt_push_buffer_state (YY_BUFFER_STATE new_buffer  );
 321 void _lc_opt_pop_buffer_state (void );
 322
 323 static void _lc_opt_ensure_buffer_stack (void );
 324 static void _lc_opt__load_buffer_state (void );
 325 static void _lc_opt__init_buffer (YY_BUFFER_STATE b,FILE *file  );
 326
 327 #define YY_FLUSH_BUFFER _lc_opt__flush_buffer(YY_CURRENT_BUFFER )
 328
 329 YY_BUFFER_STATE _lc_opt__scan_buffer (char *base,yy_size_t size  );
 330 YY_BUFFER_STATE _lc_opt__scan_string (yyconst char *yy_str  );
 331 YY_BUFFER_STATE _lc_opt__scan_bytes (yyconst char *bytes,int len  );
 332
 333 void *_lc_opt_alloc (yy_size_t  );
 334 void *_lc_opt_realloc (void *,yy_size_t  );
 335 void _lc_opt_free (void *  );
 336
 337 #define yy_new_buffer _lc_opt__create_buffer
 338
 339 #define yy_set_interactive(is_interactive) \
 340         { \
 341         if ( ! YY_CURRENT_BUFFER ){ \
 342         _lc_opt_ensure_buffer_stack (); \
 343                 YY_CURRENT_BUFFER_LVALUE =    \
 344             _lc_opt__create_buffer(_lc_opt_in,YY_BUF_SIZE ); \
 345         } \
 346         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 347         }
 348
 349 #define yy_set_bol(at_bol) \
 350         { \
 351         if ( ! YY_CURRENT_BUFFER ){\
 352         _lc_opt_ensure_buffer_stack (); \
 353                 YY_CURRENT_BUFFER_LVALUE =    \
 354             _lc_opt__create_buffer(_lc_opt_in,YY_BUF_SIZE ); \
 355         } \
 356         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 357         }
 358
 359 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 360
 361 /* Begin user sect3 */
 362
 363 typedef unsigned char YY_CHAR;
 364
 365 FILE *_lc_opt_in = (FILE *) 0, *_lc_opt_out = (FILE *) 0;
 366
 367 typedef int yy_state_type;
 368
 369 extern int _lc_opt_lineno;
 370
 371 int _lc_opt_lineno = 1;
 372
 373 extern char *_lc_opt_text;
 374 #define yytext_ptr _lc_opt_text
 375
 376 static yy_state_type yy_get_previous_state (void );
 377 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 378 static int yy_get_next_buffer (void );
 379 static void yy_fatal_error (yyconst char msg[]  );
 380
 381 /* Done after the current pattern has been matched and before the
 382  * corresponding action - sets up _lc_opt_text.
 383  */
 384 #define YY_DO_BEFORE_ACTION \
 385         (yytext_ptr) = yy_bp; \
 386         _lc_opt_leng = (size_t) (yy_cp - yy_bp); \
 387         (yy_hold_char) = *yy_cp; \
 388         *yy_cp = '\0'; \
 389         (yy_c_buf_p) = yy_cp;
 390
 391 #define YY_NUM_RULES 28
 392 #define YY_END_OF_BUFFER 29
 393 /* This struct is not used in this scanner,
 394    but its presence is necessary. */
 395 struct yy_trans_info
 396         {
 397         flex_int32_t yy_verify;
 398         flex_int32_t yy_nxt;
 399         };
 400 static yyconst flex_int16_t yy_accept[49] =
 401     {   0,
 402        25,   25,    0,    0,    0,    0,    0,    0,    0,    0,
 403         0,    0,   29,   27,   25,   26,    5,   23,   24,   24,
 404         8,    7,    6,    4,    3,    4,   11,   12,    9,   10,
 405        14,   13,   22,   15,   22,   25,   23,    1,    5,    8,
 406         2,   21,   19,   20,   16,   17,   18,    0
 407     } ;
 408
 409 static yyconst flex_int32_t yy_ec[256] =
 410     {   0,
 411         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 412         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 413         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 414         1,    2,    1,    4,    5,    6,    1,    1,    1,    1,
 415         1,    7,    1,    1,    1,    8,    9,   10,   10,   10,
 416        10,   10,   10,   10,   10,   10,   10,   11,    1,    1,
 417        11,    1,    1,    1,    6,    6,    6,    6,    6,    6,
 418         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
 419         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
 420         1,   12,    1,    1,    6,    1,    6,   13,    6,    6,
 421
 422         6,   14,    6,    6,    6,    6,    6,    6,    6,   15,
 423         6,    6,    6,   16,    6,   17,    6,    6,    6,    6,
 424         6,    6,    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,
 430         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 431         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 432
 433         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 434         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 435         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 436         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 437         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 438         1,    1,    1,    1,    1
 439     } ;
 440
 441 static yyconst flex_int32_t yy_meta[18] =
 442     {   0,
 443         1,    1,    2,    1,    1,    3,    1,    1,    1,    3,
 444         1,    1,    3,    3,    3,    3,    3
 445     } ;
 446
 447 static yyconst flex_int16_t yy_base[56] =
 448     {   0,
 449         0,    0,   62,   39,   15,   16,   21,   31,   38,   37,
 450        16,   17,   39,   67,   36,   67,   67,    0,   67,   23,
 451        35,   67,   67,   67,   67,   27,   67,   67,   67,   67,
 452        67,   67,   67,   67,   31,   29,    0,   67,   67,   25,
 453        67,   67,   67,   67,   67,   67,   67,   67,   48,   51,
 454        54,   57,   60,   23,   63
 455     } ;
 456
 457 static yyconst flex_int16_t yy_def[56] =
 458     {   0,
 459        48,    1,   49,   49,   50,   50,   51,   51,   52,   52,
 460        53,   53,   48,   48,   48,   48,   48,   54,   48,   48,
 461        48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
 462        48,   48,   48,   48,   55,   48,   54,   48,   48,   48,
 463        48,   48,   48,   48,   48,   48,   48,    0,   48,   48,
 464        48,   48,   48,   48,   48
 465     } ;
 466
 467 static yyconst flex_int16_t yy_nxt[85] =
 468     {   0,
 469        14,   15,   16,   14,   17,   18,   14,   19,   20,   14,
 470        21,   14,   18,   18,   18,   18,   18,   25,   25,   34,
 471        34,   26,   26,   28,   29,   37,   40,   35,   35,   38,
 472        36,   39,   30,   28,   29,   41,   40,   36,   48,   32,
 473        32,   23,   30,   43,   44,   45,   46,   47,   22,   22,
 474        22,   24,   24,   24,   27,   27,   27,   31,   31,   31,
 475        33,   33,   33,   42,   23,   42,   13,   48,   48,   48,
 476        48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
 477        48,   48,   48,   48
 478     } ;
 479
 480 static yyconst flex_int16_t yy_chk[85] =
 481     {   0,
 482         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 483         1,    1,    1,    1,    1,    1,    1,    5,    6,   11,
 484        12,    5,    6,    7,    7,   54,   40,   11,   12,   20,
 485        36,   20,    7,    8,    8,   26,   21,   15,   13,   10,
 486         9,    4,    8,   35,   35,   35,   35,   35,   49,   49,
 487        49,   50,   50,   50,   51,   51,   51,   52,   52,   52,
 488        53,   53,   53,   55,    3,   55,   48,   48,   48,   48,
 489        48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
 490        48,   48,   48,   48
 491     } ;
 492
 493 static yy_state_type yy_last_accepting_state;
 494 static char *yy_last_accepting_cpos;
 495
 496 extern int _lc_opt__flex_debug;
 497 int _lc_opt__flex_debug = 0;
 498
 499 /* The intent behind this definition is that it'll catch
 500  * any uses of REJECT which flex missed.
 501  */
 502 #define REJECT reject_used_but_not_detected
 503 #define yymore() yymore_used_but_not_detected
 504 #define YY_MORE_ADJ 0
 505 #define YY_RESTORE_YY_MORE_OFFSET
 506 char *_lc_opt_text;
 507 #line 1 "lc_config_lexer.l"
 508 #line 5 "lc_config_lexer.l"
 509
 510 /*
 511   libcore: library for basic data structures and algorithms.
 512   Copyright (C) 2005  IPD Goos, Universit"at Karlsruhe, Germany
 513
 514   This library is free software; you can redistribute it and/or
 515   modify it under the terms of the GNU Lesser General Public
 516   License as published by the Free Software Foundation; either
 517   version 2.1 of the License, or (at your option) any later version.
 518
 519   This library is distributed in the hope that it will be useful,
 520   but WITHOUT ANY WARRANTY; without even the implied warranty of
 521   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 522   Lesser General Public License for more details.
 523
 524   You should have received a copy of the GNU Lesser General Public
 525   License along with this library; if not, write to the Free Software
 526   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 527 */
 528 #ifdef HAVE_CONFIG_H
 529 #include "config.h"
 530 #endif
 531
 532 #include <stdio.h>
 533
 534 #include "lc_parser_t.h"
 535 #include "lc_config_parser.h"
 536
 537 static int _lc_opt_wrap(void);
 538
 539
 540
 541
 542
 543
 544 #line 545 "lc_config_lexer.c"
 545
 546 #define INITIAL 0
 547 #define LINE_COMMENT 1
 548 #define BIG_COMMENT 2
 549 #define DAT 3
 550 #define DAT_CONT 4
 551 #define STR 5
 552
 553 #ifndef YY_NO_UNISTD_H
 554 /* Special case for "unistd.h", since it is non-ANSI. We include it way
 555  * down here because we want the user's section 1 to have been scanned first.
 556  * The user has a chance to override it with an option.
 557  */
 558 #include <unistd.h>
 559 #endif
 560
 561 #ifndef YY_EXTRA_TYPE
 562 #define YY_EXTRA_TYPE void *
 563 #endif
 564
 565 static int yy_init_globals (void );
 566
 567 /* Accessor methods to globals.
 568    These are made visible to non-reentrant scanners for convenience. */
 569
 570 int _lc_opt_lex_destroy (void );
 571
 572 int _lc_opt_get_debug (void );
 573
 574 void _lc_opt_set_debug (int debug_flag  );
 575
 576 YY_EXTRA_TYPE _lc_opt_get_extra (void );
 577
 578 void _lc_opt_set_extra (YY_EXTRA_TYPE user_defined  );
 579
 580 FILE *_lc_opt_get_in (void );
 581
 582 void _lc_opt_set_in  (FILE * in_str  );
 583
 584 FILE *_lc_opt_get_out (void );
 585
 586 void _lc_opt_set_out  (FILE * out_str  );
 587
 588 int _lc_opt_get_leng (void );
 589
 590 char *_lc_opt_get_text (void );
 591
 592 int _lc_opt_get_lineno (void );
 593
 594 void _lc_opt_set_lineno (int line_number  );
 595
 596 /* Macros after this point can all be overridden by user definitions in
 597  * section 1.
 598  */
 599
 600 #ifndef YY_SKIP_YYWRAP
 601 #ifdef __cplusplus
 602 extern "C" int _lc_opt_wrap (void );
 603 #else
 604 extern int _lc_opt_wrap (void );
 605 #endif
 606 #endif
 607
 608     static void yyunput (int c,char *buf_ptr  );
 609
 610 #ifndef yytext_ptr
 611 static void yy_flex_strncpy (char *,yyconst char *,int );
 612 #endif
 613
 614 #ifdef YY_NEED_STRLEN
 615 static int yy_flex_strlen (yyconst char * );
 616 #endif
 617
 618 #ifndef YY_NO_INPUT
 619
 620 #ifdef __cplusplus
 621 static int yyinput (void );
 622 #else
 623 static int input (void );
 624 #endif
 625
 626 #endif
 627
 628 /* Amount of stuff to slurp up with each read. */
 629 #ifndef YY_READ_BUF_SIZE
 630 #ifdef __ia64__
 631 /* On IA-64, the buffer size is 16k, not 8k */
 632 #define YY_READ_BUF_SIZE 16384
 633 #else
 634 #define YY_READ_BUF_SIZE 8192
 635 #endif /* __ia64__ */
 636 #endif
 637
 638 /* Copy whatever the last rule matched to the standard output. */
 639 #ifndef ECHO
 640 /* This used to be an fputs(), but since the string might contain NUL's,
 641  * we now use fwrite().
 642  */
 643 #define ECHO do { if (fwrite( _lc_opt_text, _lc_opt_leng, 1, _lc_opt_out )) {} } while (0)
 644 #endif
 645
 646 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 647  * is returned in "result".
 648  */
 649 #ifndef YY_INPUT
 650 #define YY_INPUT(buf,result,max_size) \
 651         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 652                 { \
 653                 int c = '*'; \
 654                 size_t n; \
 655                 for ( n = 0; n < max_size && \
 656                              (c = getc( _lc_opt_in )) != EOF && c != '\n'; ++n ) \
 657                         buf[n] = (char) c; \
 658                 if ( c == '\n' ) \
 659                         buf[n++] = (char) c; \
 660                 if ( c == EOF && ferror( _lc_opt_in ) ) \
 661                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 662                 result = n; \
 663                 } \
 664         else \
 665                 { \
 666                 errno=0; \
 667                 while ( (result = fread(buf, 1, max_size, _lc_opt_in))==0 && ferror(_lc_opt_in)) \
 668                         { \
 669                         if( errno != EINTR) \
 670                                 { \
 671                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
 672                                 break; \
 673                                 } \
 674                         errno=0; \
 675                         clearerr(_lc_opt_in); \
 676                         } \
 677                 }\
 678 \
 679
 680 #endif
 681
 682 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 683  * we don't want an extra ';' after the "return" because that will cause
 684  * some compilers to complain about unreachable statements.
 685  */
 686 #ifndef yyterminate
 687 #define yyterminate() return YY_NULL
 688 #endif
 689
 690 /* Number of entries by which start-condition stack grows. */
 691 #ifndef YY_START_STACK_INCR
 692 #define YY_START_STACK_INCR 25
 693 #endif
 694
 695 /* Report a fatal error. */
 696 #ifndef YY_FATAL_ERROR
 697 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 698 #endif
 699
 700 /* end tables serialization structures and prototypes */
 701
 702 /* Default declaration of generated scanner - a define so the user can
 703  * easily add parameters.
 704  */
 705 #ifndef YY_DECL
 706 #define YY_DECL_IS_OURS 1
 707
 708 extern int _lc_opt_lex (void);
 709
 710 #define YY_DECL int _lc_opt_lex (void)
 711 #endif /* !YY_DECL */
 712
 713 /* Code executed at the beginning of each rule, after _lc_opt_text and _lc_opt_leng
 714  * have been set up.
 715  */
 716 #ifndef YY_USER_ACTION
 717 #define YY_USER_ACTION
 718 #endif
 719
 720 /* Code executed at the end of each rule. */
 721 #ifndef YY_BREAK
 722 #define YY_BREAK break;
 723 #endif
 724
 725 #define YY_RULE_SETUP \
 726         YY_USER_ACTION
 727
 728 /** The main scanner function which does all the work.
 729  */
 730 YY_DECL
 731 {
 732         register yy_state_type yy_current_state;
 733         register char *yy_cp, *yy_bp;
 734         register int yy_act;
 735
 736 #line 52 "lc_config_lexer.l"
 737
 738
 739 #line 740 "lc_config_lexer.c"
 740
 741         if ( !(yy_init) )
 742                 {
 743                 (yy_init) = 1;
 744
 745 #ifdef YY_USER_INIT
 746                 YY_USER_INIT;
 747 #endif
 748
 749                 if ( ! (yy_start) )
 750                         (yy_start) = 1; /* first start state */
 751
 752                 if ( ! _lc_opt_in )
 753                         _lc_opt_in = stdin;
 754
 755                 if ( ! _lc_opt_out )
 756                         _lc_opt_out = stdout;
 757
 758                 if ( ! YY_CURRENT_BUFFER ) {
 759                         _lc_opt_ensure_buffer_stack ();
 760                         YY_CURRENT_BUFFER_LVALUE =
 761                                 _lc_opt__create_buffer(_lc_opt_in,YY_BUF_SIZE );
 762                 }
 763
 764                 _lc_opt__load_buffer_state( );
 765                 }
 766
 767         while ( 1 )             /* loops until end-of-file is reached */
 768                 {
 769                 yy_cp = (yy_c_buf_p);
 770
 771                 /* Support of _lc_opt_text. */
 772                 *yy_cp = (yy_hold_char);
 773
 774                 /* yy_bp points to the position in yy_ch_buf of the start of
 775                  * the current run.
 776                  */
 777                 yy_bp = yy_cp;
 778
 779                 yy_current_state = (yy_start);
 780 yy_match:
 781                 do
 782                         {
 783                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 784                         if ( yy_accept[yy_current_state] )
 785                                 {
 786                                 (yy_last_accepting_state) = yy_current_state;
 787                                 (yy_last_accepting_cpos) = yy_cp;
 788                                 }
 789                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 790                                 {
 791                                 yy_current_state = (int) yy_def[yy_current_state];
 792                                 if ( yy_current_state >= 49 )
 793                                         yy_c = yy_meta[(unsigned int) yy_c];
 794                                 }
 795                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 796                         ++yy_cp;
 797                         }
 798                 while ( yy_base[yy_current_state] != 67 );
 799
 800 yy_find_action:
 801                 yy_act = yy_accept[yy_current_state];
 802                 if ( yy_act == 0 )
 803                         { /* have to back up */
 804                         yy_cp = (yy_last_accepting_cpos);
 805                         yy_current_state = (yy_last_accepting_state);
 806                         yy_act = yy_accept[yy_current_state];
 807                         }
 808
 809                 YY_DO_BEFORE_ACTION;
 810
 811 do_action:      /* This label is used only to access EOF actions. */
 812
 813                 switch ( yy_act )
 814         { /* beginning of action switch */
 815                         case 0: /* must back up */
 816                         /* undo the effects of YY_DO_BEFORE_ACTION */
 817                         *yy_cp = (yy_hold_char);
 818                         yy_cp = (yy_last_accepting_cpos);
 819                         yy_current_state = (yy_last_accepting_state);
 820                         goto yy_find_action;
 821
 822 case 1:
 823 YY_RULE_SETUP
 824 #line 54 "lc_config_lexer.l"
 825 { BEGIN(BIG_COMMENT); }
 826         YY_BREAK
 827 case 2:
 828 YY_RULE_SETUP
 829 #line 55 "lc_config_lexer.l"
 830 { BEGIN(INITIAL); }
 831         YY_BREAK
 832 case 3:
 833 /* rule 3 can match eol */
 834 YY_RULE_SETUP
 835 #line 56 "lc_config_lexer.l"
 836 PMANGLE(linenr)++;
 837         YY_BREAK
 838 case 4:
 839 YY_RULE_SETUP
 840 #line 57 "lc_config_lexer.l"
 841 ;
 842         YY_BREAK
 843 case 5:
 844 YY_RULE_SETUP
 845 #line 59 "lc_config_lexer.l"
 846 { BEGIN(LINE_COMMENT); }
 847         YY_BREAK
 848 case 6:
 849 /* rule 6 can match eol */
 850 YY_RULE_SETUP
 851 #line 60 "lc_config_lexer.l"
 852 { BEGIN(INITIAL); PMANGLE(linenr)++; }
 853         YY_BREAK
 854 case 7:
 855 YY_RULE_SETUP
 856 #line 61 "lc_config_lexer.l"
 857 ;
 858         YY_BREAK
 859 case 8:
 860 YY_RULE_SETUP
 861 #line 64 "lc_config_lexer.l"
 862 { BEGIN(DAT); }
 863         YY_BREAK
 864 case 9:
 865 YY_RULE_SETUP
 866 #line 65 "lc_config_lexer.l"
 867 { BEGIN(STR); }
 868         YY_BREAK
 869 case 10:
 870 YY_RULE_SETUP
 871 #line 66 "lc_config_lexer.l"
 872 { BEGIN(DAT_CONT); }
 873         YY_BREAK
 874 case 11:
 875 YY_RULE_SETUP
 876 #line 67 "lc_config_lexer.l"
 877 { _lc_opt_add_to_data_char(PMANGLE(text)[0]); }
 878         YY_BREAK
 879 case 12:
 880 /* rule 12 can match eol */
 881 YY_RULE_SETUP
 882 #line 68 "lc_config_lexer.l"
 883 {
 884                                                 BEGIN(INITIAL);
 885                                                 PMANGLE(linenr)++;
 886                                                 _lc_opt_add_to_data_char('\0');
 887                                                 return DATA;
 888                                         }
 889         YY_BREAK
 890 case 13:
 891 /* rule 13 can match eol */
 892 YY_RULE_SETUP
 893 #line 74 "lc_config_lexer.l"
 894 { BEGIN(DAT); PMANGLE(linenr)++; }
 895         YY_BREAK
 896 case 14:
 897 YY_RULE_SETUP
 898 #line 75 "lc_config_lexer.l"
 899 ;
 900         YY_BREAK
 901 case 15:
 902 YY_RULE_SETUP
 903 #line 78 "lc_config_lexer.l"
 904 {
 905                                                 BEGIN(INITIAL);
 906                                                 _lc_opt_add_to_data_char('\0');
 907                                                 return DATA;
 908                                         }
 909         YY_BREAK
 910 case 16:
 911 YY_RULE_SETUP
 912 #line 84 "lc_config_lexer.l"
 913 _lc_opt_add_to_data_char('\n');
 914         YY_BREAK
 915 case 17:
 916 YY_RULE_SETUP
 917 #line 85 "lc_config_lexer.l"
 918 _lc_opt_add_to_data_char('\r');
 919         YY_BREAK
 920 case 18:
 921 YY_RULE_SETUP
 922 #line 86 "lc_config_lexer.l"
 923 _lc_opt_add_to_data_char('\t');
 924         YY_BREAK
 925 case 19:
 926 YY_RULE_SETUP
 927 #line 87 "lc_config_lexer.l"
 928 _lc_opt_add_to_data_char('\b');
 929         YY_BREAK
 930 case 20:
 931 YY_RULE_SETUP
 932 #line 88 "lc_config_lexer.l"
 933 _lc_opt_add_to_data_char('\f');
 934         YY_BREAK
 935 case 21:
 936 YY_RULE_SETUP
 937 #line 89 "lc_config_lexer.l"
 938 _lc_opt_add_to_data_char(_lc_opt_text[1]);
 939         YY_BREAK
 940 case 22:
 941 /* rule 22 can match eol */
 942 YY_RULE_SETUP
 943 #line 90 "lc_config_lexer.l"
 944 _lc_opt_add_to_data_char(_lc_opt_text[0]);
 945         YY_BREAK
 946 case 23:
 947 YY_RULE_SETUP
 948 #line 92 "lc_config_lexer.l"
 949 {
 950                                                 PMANGLE(lval).text.str = PMANGLE(text);
 951                                                 PMANGLE(lval).text.len = PMANGLE(leng);
 952                                                 return IDENT;
 953                                         }
 954         YY_BREAK
 955 case 24:
 956 YY_RULE_SETUP
 957 #line 97 "lc_config_lexer.l"
 958 { return SEP; }
 959         YY_BREAK
 960 case 25:
 961 YY_RULE_SETUP
 962 #line 99 "lc_config_lexer.l"
 963 ;
 964         YY_BREAK
 965 case 26:
 966 /* rule 26 can match eol */
 967 YY_RULE_SETUP
 968 #line 100 "lc_config_lexer.l"
 969 PMANGLE(linenr)++;
 970         YY_BREAK
 971 case 27:
 972 YY_RULE_SETUP
 973 #line 102 "lc_config_lexer.l"
 974 return _lc_opt_text[0];
 975         YY_BREAK
 976 case 28:
 977 YY_RULE_SETUP
 978 #line 104 "lc_config_lexer.l"
 979 ECHO;
 980         YY_BREAK
 981 #line 982 "lc_config_lexer.c"
 982 case YY_STATE_EOF(INITIAL):
 983 case YY_STATE_EOF(LINE_COMMENT):
 984 case YY_STATE_EOF(BIG_COMMENT):
 985 case YY_STATE_EOF(DAT):
 986 case YY_STATE_EOF(DAT_CONT):
 987 case YY_STATE_EOF(STR):
 988         yyterminate();
 989
 990         case YY_END_OF_BUFFER:
 991                 {
 992                 /* Amount of text matched not including the EOB char. */
 993                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
 994
 995                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
 996                 *yy_cp = (yy_hold_char);
 997                 YY_RESTORE_YY_MORE_OFFSET
 998
 999                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1000                         {
1001                         /* We're scanning a new file or input source.  It's
1002                          * possible that this happened because the user
1003                          * just pointed _lc_opt_in at a new source and called
1004                          * _lc_opt_lex().  If so, then we have to assure
1005                          * consistency between YY_CURRENT_BUFFER and our
1006                          * globals.  Here is the right place to do so, because
1007                          * this is the first action (other than possibly a
1008                          * back-up) that will match for the new input source.
1009                          */
1010                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1011                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = _lc_opt_in;
1012                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1013                         }
1014
1015                 /* Note that here we test for yy_c_buf_p "<=" to the position
1016                  * of the first EOB in the buffer, since yy_c_buf_p will
1017                  * already have been incremented past the NUL character
1018                  * (since all states make transitions on EOB to the
1019                  * end-of-buffer state).  Contrast this with the test
1020                  * in input().
1021                  */
1022                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1023                         { /* This was really a NUL. */
1024                         yy_state_type yy_next_state;
1025
1026                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1027
1028                         yy_current_state = yy_get_previous_state(  );
1029
1030                         /* Okay, we're now positioned to make the NUL
1031                          * transition.  We couldn't have
1032                          * yy_get_previous_state() go ahead and do it
1033                          * for us because it doesn't know how to deal
1034                          * with the possibility of jamming (and we don't
1035                          * want to build jamming into it because then it
1036                          * will run more slowly).
1037                          */
1038
1039                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1040
1041                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1042
1043                         if ( yy_next_state )
1044                                 {
1045                                 /* Consume the NUL. */
1046                                 yy_cp = ++(yy_c_buf_p);
1047                                 yy_current_state = yy_next_state;
1048                                 goto yy_match;
1049                                 }
1050
1051                         else
1052                                 {
1053                                 yy_cp = (yy_c_buf_p);
1054                                 goto yy_find_action;
1055                                 }
1056                         }
1057
1058                 else switch ( yy_get_next_buffer(  ) )
1059                         {
1060                         case EOB_ACT_END_OF_FILE:
1061                                 {
1062                                 (yy_did_buffer_switch_on_eof) = 0;
1063
1064                                 if ( _lc_opt_wrap( ) )
1065                                         {
1066                                         /* Note: because we've taken care in
1067                                          * yy_get_next_buffer() to have set up
1068                                          * _lc_opt_text, we can now set up
1069                                          * yy_c_buf_p so that if some total
1070                                          * hoser (like flex itself) wants to
1071                                          * call the scanner after we return the
1072                                          * YY_NULL, it'll still work - another
1073                                          * YY_NULL will get returned.
1074                                          */
1075                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1076
1077                                         yy_act = YY_STATE_EOF(YY_START);
1078                                         goto do_action;
1079                                         }
1080
1081                                 else
1082                                         {
1083                                         if ( ! (yy_did_buffer_switch_on_eof) )
1084                                                 YY_NEW_FILE;
1085                                         }
1086                                 break;
1087                                 }
1088
1089                         case EOB_ACT_CONTINUE_SCAN:
1090                                 (yy_c_buf_p) =
1091                                         (yytext_ptr) + yy_amount_of_matched_text;
1092
1093                                 yy_current_state = yy_get_previous_state(  );
1094
1095                                 yy_cp = (yy_c_buf_p);
1096                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1097                                 goto yy_match;
1098
1099                         case EOB_ACT_LAST_MATCH:
1100                                 (yy_c_buf_p) =
1101                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1102
1103                                 yy_current_state = yy_get_previous_state(  );
1104
1105                                 yy_cp = (yy_c_buf_p);
1106                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1107                                 goto yy_find_action;
1108                         }
1109                 break;
1110                 }
1111
1112         default:
1113                 YY_FATAL_ERROR(
1114                         "fatal flex scanner internal error--no action found" );
1115         } /* end of action switch */
1116                 } /* end of scanning one token */
1117 } /* end of _lc_opt_lex */
1118
1119 /* yy_get_next_buffer - try to read in a new buffer
1120  *
1121  * Returns a code representing an action:
1122  *      EOB_ACT_LAST_MATCH -
1123  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1124  *      EOB_ACT_END_OF_FILE - end of file
1125  */
1126 static int yy_get_next_buffer (void)
1127 {
1128         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1129         register char *source = (yytext_ptr);
1130         register int number_to_move, i;
1131         int ret_val;
1132
1133         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1134                 YY_FATAL_ERROR(
1135                 "fatal flex scanner internal error--end of buffer missed" );
1136
1137         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1138                 { /* Don't try to fill the buffer, so this is an EOF. */
1139                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1140                         {
1141                         /* We matched a single character, the EOB, so
1142                          * treat this as a final EOF.
1143                          */
1144                         return EOB_ACT_END_OF_FILE;
1145                         }
1146
1147                 else
1148                         {
1149                         /* We matched some text prior to the EOB, first
1150                          * process it.
1151                          */
1152                         return EOB_ACT_LAST_MATCH;
1153                         }
1154                 }
1155
1156         /* Try to read more data. */
1157
1158         /* First move last chars to start of buffer. */
1159         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1160
1161         for ( i = 0; i < number_to_move; ++i )
1162                 *(dest++) = *(source++);
1163
1164         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1165                 /* don't do the read, it's not guaranteed to return an EOF,
1166                  * just force an EOF
1167                  */
1168                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1169
1170         else
1171                 {
1172                         int num_to_read =
1173                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1174
1175                 while ( num_to_read <= 0 )
1176                         { /* Not enough room in the buffer - grow it. */
1177
1178                         /* just a shorter name for the current buffer */
1179                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1180
1181                         int yy_c_buf_p_offset =
1182                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1183
1184                         if ( b->yy_is_our_buffer )
1185                                 {
1186                                 int new_size = b->yy_buf_size * 2;
1187
1188                                 if ( new_size <= 0 )
1189                                         b->yy_buf_size += b->yy_buf_size / 8;
1190                                 else
1191                                         b->yy_buf_size *= 2;
1192
1193                                 b->yy_ch_buf = (char *)
1194                                         /* Include room in for 2 EOB chars. */
1195                                         _lc_opt_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1196                                 }
1197                         else
1198                                 /* Can't grow it, we don't own it. */
1199                                 b->yy_ch_buf = 0;
1200
1201                         if ( ! b->yy_ch_buf )
1202                                 YY_FATAL_ERROR(
1203                                 "fatal error - scanner input buffer overflow" );
1204
1205                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1206
1207                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1208                                                 number_to_move - 1;
1209
1210                         }
1211
1212                 if ( num_to_read > YY_READ_BUF_SIZE )
1213                         num_to_read = YY_READ_BUF_SIZE;
1214
1215                 /* Read in more data. */
1216                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1217                         (yy_n_chars), (size_t) num_to_read );
1218
1219                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1220                 }
1221
1222         if ( (yy_n_chars) == 0 )
1223                 {
1224                 if ( number_to_move == YY_MORE_ADJ )
1225                         {
1226                         ret_val = EOB_ACT_END_OF_FILE;
1227                         _lc_opt_restart(_lc_opt_in  );
1228                         }
1229
1230                 else
1231                         {
1232                         ret_val = EOB_ACT_LAST_MATCH;
1233                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1234                                 YY_BUFFER_EOF_PENDING;
1235                         }
1236                 }
1237
1238         else
1239                 ret_val = EOB_ACT_CONTINUE_SCAN;
1240
1241         if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1242                 /* Extend the array by 50%, plus the number we really need. */
1243                 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1244                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) _lc_opt_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1245                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1246                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1247         }
1248
1249         (yy_n_chars) += number_to_move;
1250         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1251         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1252
1253         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1254
1255         return ret_val;
1256 }
1257
1258 /* yy_get_previous_state - get the state just before the EOB char was reached */
1259
1260     static yy_state_type yy_get_previous_state (void)
1261 {
1262         register yy_state_type yy_current_state;
1263         register char *yy_cp;
1264
1265         yy_current_state = (yy_start);
1266
1267         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1268                 {
1269                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1270                 if ( yy_accept[yy_current_state] )
1271                         {
1272                         (yy_last_accepting_state) = yy_current_state;
1273                         (yy_last_accepting_cpos) = yy_cp;
1274                         }
1275                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1276                         {
1277                         yy_current_state = (int) yy_def[yy_current_state];
1278                         if ( yy_current_state >= 49 )
1279                                 yy_c = yy_meta[(unsigned int) yy_c];
1280                         }
1281                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1282                 }
1283
1284         return yy_current_state;
1285 }
1286
1287 /* yy_try_NUL_trans - try to make a transition on the NUL character
1288  *
1289  * synopsis
1290  *      next_state = yy_try_NUL_trans( current_state );
1291  */
1292     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1293 {
1294         register int yy_is_jam;
1295         register char *yy_cp = (yy_c_buf_p);
1296
1297         register YY_CHAR yy_c = 1;
1298         if ( yy_accept[yy_current_state] )
1299                 {
1300                 (yy_last_accepting_state) = yy_current_state;
1301                 (yy_last_accepting_cpos) = yy_cp;
1302                 }
1303         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1304                 {
1305                 yy_current_state = (int) yy_def[yy_current_state];
1306                 if ( yy_current_state >= 49 )
1307                         yy_c = yy_meta[(unsigned int) yy_c];
1308                 }
1309         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1310         yy_is_jam = (yy_current_state == 48);
1311
1312         return yy_is_jam ? 0 : yy_current_state;
1313 }
1314
1315     static void yyunput (int c, register char * yy_bp )
1316 {
1317         register char *yy_cp;
1318
1319     yy_cp = (yy_c_buf_p);
1320
1321         /* undo effects of setting up _lc_opt_text */
1322         *yy_cp = (yy_hold_char);
1323
1324         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1325                 { /* need to shift things up to make room */
1326                 /* +2 for EOB chars. */
1327                 register int number_to_move = (yy_n_chars) + 2;
1328                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1329                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1330                 register char *source =
1331                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1332
1333                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1334                         *--dest = *--source;
1335
1336                 yy_cp += (int) (dest - source);
1337                 yy_bp += (int) (dest - source);
1338                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1339                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1340
1341                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1342                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1343                 }
1344
1345         *--yy_cp = (char) c;
1346
1347         (yytext_ptr) = yy_bp;
1348         (yy_hold_char) = *yy_cp;
1349         (yy_c_buf_p) = yy_cp;
1350 }
1351
1352 #ifndef YY_NO_INPUT
1353 #ifdef __cplusplus
1354     static int yyinput (void)
1355 #else
1356     static int input  (void)
1357 #endif
1358
1359 {
1360         int c;
1361
1362         *(yy_c_buf_p) = (yy_hold_char);
1363
1364         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1365                 {
1366                 /* yy_c_buf_p now points to the character we want to return.
1367                  * If this occurs *before* the EOB characters, then it's a
1368                  * valid NUL; if not, then we've hit the end of the buffer.
1369                  */
1370                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1371                         /* This was really a NUL. */
1372                         *(yy_c_buf_p) = '\0';
1373
1374                 else
1375                         { /* need more input */
1376                         int offset = (yy_c_buf_p) - (yytext_ptr);
1377                         ++(yy_c_buf_p);
1378
1379                         switch ( yy_get_next_buffer(  ) )
1380                                 {
1381                                 case EOB_ACT_LAST_MATCH:
1382                                         /* This happens because yy_g_n_b()
1383                                          * sees that we've accumulated a
1384                                          * token and flags that we need to
1385                                          * try matching the token before
1386                                          * proceeding.  But for input(),
1387                                          * there's no matching to consider.
1388                                          * So convert the EOB_ACT_LAST_MATCH
1389                                          * to EOB_ACT_END_OF_FILE.
1390                                          */
1391
1392                                         /* Reset buffer status. */
1393                                         _lc_opt_restart(_lc_opt_in );
1394
1395                                         /*FALLTHROUGH*/
1396
1397                                 case EOB_ACT_END_OF_FILE:
1398                                         {
1399                                         if ( _lc_opt_wrap( ) )
1400                                                 return EOF;
1401
1402                                         if ( ! (yy_did_buffer_switch_on_eof) )
1403                                                 YY_NEW_FILE;
1404 #ifdef __cplusplus
1405                                         return yyinput();
1406 #else
1407                                         return input();
1408 #endif
1409                                         }
1410
1411                                 case EOB_ACT_CONTINUE_SCAN:
1412                                         (yy_c_buf_p) = (yytext_ptr) + offset;
1413                                         break;
1414                                 }
1415                         }
1416                 }
1417
1418         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1419         *(yy_c_buf_p) = '\0';   /* preserve _lc_opt_text */
1420         (yy_hold_char) = *++(yy_c_buf_p);
1421
1422         return c;
1423 }
1424 #endif  /* ifndef YY_NO_INPUT */
1425
1426 /** Immediately switch to a different input stream.
1427  * @param input_file A readable stream.
1428  *
1429  * @note This function does not reset the start condition to @c INITIAL .
1430  */
1431     void _lc_opt_restart  (FILE * input_file )
1432 {
1433
1434         if ( ! YY_CURRENT_BUFFER ){
1435         _lc_opt_ensure_buffer_stack ();
1436                 YY_CURRENT_BUFFER_LVALUE =
1437             _lc_opt__create_buffer(_lc_opt_in,YY_BUF_SIZE );
1438         }
1439
1440         _lc_opt__init_buffer(YY_CURRENT_BUFFER,input_file );
1441         _lc_opt__load_buffer_state( );
1442 }
1443
1444 /** Switch to a different input buffer.
1445  * @param new_buffer The new input buffer.
1446  *
1447  */
1448     void _lc_opt__switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1449 {
1450
1451         /* TODO. We should be able to replace this entire function body
1452          * with
1453          *              _lc_opt_pop_buffer_state();
1454          *              _lc_opt_push_buffer_state(new_buffer);
1455      */
1456         _lc_opt_ensure_buffer_stack ();
1457         if ( YY_CURRENT_BUFFER == new_buffer )
1458                 return;
1459
1460         if ( YY_CURRENT_BUFFER )
1461                 {
1462                 /* Flush out information for old buffer. */
1463                 *(yy_c_buf_p) = (yy_hold_char);
1464                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1465                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1466                 }
1467
1468         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1469         _lc_opt__load_buffer_state( );
1470
1471         /* We don't actually know whether we did this switch during
1472          * EOF (_lc_opt_wrap()) processing, but the only time this flag
1473          * is looked at is after _lc_opt_wrap() is called, so it's safe
1474          * to go ahead and always set it.
1475          */
1476         (yy_did_buffer_switch_on_eof) = 1;
1477 }
1478
1479 static void _lc_opt__load_buffer_state  (void)
1480 {
1481         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1482         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1483         _lc_opt_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1484         (yy_hold_char) = *(yy_c_buf_p);
1485 }
1486
1487 /** Allocate and initialize an input buffer state.
1488  * @param file A readable stream.
1489  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1490  *
1491  * @return the allocated buffer state.
1492  */
1493     YY_BUFFER_STATE _lc_opt__create_buffer  (FILE * file, int  size )
1494 {
1495         YY_BUFFER_STATE b;
1496
1497         b = (YY_BUFFER_STATE) _lc_opt_alloc(sizeof( struct yy_buffer_state )  );
1498         if ( ! b )
1499                 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt__create_buffer()" );
1500
1501         b->yy_buf_size = size;
1502
1503         /* yy_ch_buf has to be 2 characters longer than the size given because
1504          * we need to put in 2 end-of-buffer characters.
1505          */
1506         b->yy_ch_buf = (char *) _lc_opt_alloc(b->yy_buf_size + 2  );
1507         if ( ! b->yy_ch_buf )
1508                 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt__create_buffer()" );
1509
1510         b->yy_is_our_buffer = 1;
1511
1512         _lc_opt__init_buffer(b,file );
1513
1514         return b;
1515 }
1516
1517 /** Destroy the buffer.
1518  * @param b a buffer created with _lc_opt__create_buffer()
1519  *
1520  */
1521     void _lc_opt__delete_buffer (YY_BUFFER_STATE  b )
1522 {
1523
1524         if ( ! b )
1525                 return;
1526
1527         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1528                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1529
1530         if ( b->yy_is_our_buffer )
1531                 _lc_opt_free((void *) b->yy_ch_buf  );
1532
1533         _lc_opt_free((void *) b  );
1534 }
1535
1536 #ifndef __cplusplus
1537 extern int isatty (int );
1538 #endif /* __cplusplus */
1539
1540 /* Initializes or reinitializes a buffer.
1541  * This function is sometimes called more than once on the same buffer,
1542  * such as during a _lc_opt_restart() or at EOF.
1543  */
1544     static void _lc_opt__init_buffer  (YY_BUFFER_STATE  b, FILE * file )
1545
1546 {
1547         int oerrno = errno;
1548
1549         _lc_opt__flush_buffer(b );
1550
1551         b->yy_input_file = file;
1552         b->yy_fill_buffer = 1;
1553
1554     /* If b is the current buffer, then _lc_opt__init_buffer was _probably_
1555      * called from _lc_opt_restart() or through yy_get_next_buffer.
1556      * In that case, we don't want to reset the lineno or column.
1557      */
1558     if (b != YY_CURRENT_BUFFER){
1559         b->yy_bs_lineno = 1;
1560         b->yy_bs_column = 0;
1561     }
1562
1563         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1564
1565         errno = oerrno;
1566 }
1567
1568 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1569  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1570  *
1571  */
1572     void _lc_opt__flush_buffer (YY_BUFFER_STATE  b )
1573 {
1574         if ( ! b )
1575                 return;
1576
1577         b->yy_n_chars = 0;
1578
1579         /* We always need two end-of-buffer characters.  The first causes
1580          * a transition to the end-of-buffer state.  The second causes
1581          * a jam in that state.
1582          */
1583         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1584         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1585
1586         b->yy_buf_pos = &b->yy_ch_buf[0];
1587
1588         b->yy_at_bol = 1;
1589         b->yy_buffer_status = YY_BUFFER_NEW;
1590
1591         if ( b == YY_CURRENT_BUFFER )
1592                 _lc_opt__load_buffer_state( );
1593 }
1594
1595 /** Pushes the new state onto the stack. The new state becomes
1596  *  the current state. This function will allocate the stack
1597  *  if necessary.
1598  *  @param new_buffer The new state.
1599  *
1600  */
1601 void _lc_opt_push_buffer_state (YY_BUFFER_STATE new_buffer )
1602 {
1603         if (new_buffer == NULL)
1604                 return;
1605
1606         _lc_opt_ensure_buffer_stack();
1607
1608         /* This block is copied from _lc_opt__switch_to_buffer. */
1609         if ( YY_CURRENT_BUFFER )
1610                 {
1611                 /* Flush out information for old buffer. */
1612                 *(yy_c_buf_p) = (yy_hold_char);
1613                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1614                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1615                 }
1616
1617         /* Only push if top exists. Otherwise, replace top. */
1618         if (YY_CURRENT_BUFFER)
1619                 (yy_buffer_stack_top)++;
1620         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1621
1622         /* copied from _lc_opt__switch_to_buffer. */
1623         _lc_opt__load_buffer_state( );
1624         (yy_did_buffer_switch_on_eof) = 1;
1625 }
1626
1627 /** Removes and deletes the top of the stack, if present.
1628  *  The next element becomes the new top.
1629  *
1630  */
1631 void _lc_opt_pop_buffer_state (void)
1632 {
1633         if (!YY_CURRENT_BUFFER)
1634                 return;
1635
1636         _lc_opt__delete_buffer(YY_CURRENT_BUFFER );
1637         YY_CURRENT_BUFFER_LVALUE = NULL;
1638         if ((yy_buffer_stack_top) > 0)
1639                 --(yy_buffer_stack_top);
1640
1641         if (YY_CURRENT_BUFFER) {
1642                 _lc_opt__load_buffer_state( );
1643                 (yy_did_buffer_switch_on_eof) = 1;
1644         }
1645 }
1646
1647 /* Allocates the stack if it does not exist.
1648  *  Guarantees space for at least one push.
1649  */
1650 static void _lc_opt_ensure_buffer_stack (void)
1651 {
1652         int num_to_alloc;
1653
1654         if (!(yy_buffer_stack)) {
1655
1656                 /* First allocation is just for 2 elements, since we don't know if this
1657                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1658                  * immediate realloc on the next call.
1659          */
1660                 num_to_alloc = 1;
1661                 (yy_buffer_stack) = (struct yy_buffer_state**)_lc_opt_alloc
1662                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
1663                                                                 );
1664                 if ( ! (yy_buffer_stack) )
1665                         YY_FATAL_ERROR( "out of dynamic memory in _lc_opt_ensure_buffer_stack()" );
1666
1667                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1668
1669                 (yy_buffer_stack_max) = num_to_alloc;
1670                 (yy_buffer_stack_top) = 0;
1671                 return;
1672         }
1673
1674         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1675
1676                 /* Increase the buffer to prepare for a possible push. */
1677                 int grow_size = 8 /* arbitrary grow size */;
1678
1679                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1680                 (yy_buffer_stack) = (struct yy_buffer_state**)_lc_opt_realloc
1681                                                                 ((yy_buffer_stack),
1682                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
1683                                                                 );
1684                 if ( ! (yy_buffer_stack) )
1685                         YY_FATAL_ERROR( "out of dynamic memory in _lc_opt_ensure_buffer_stack()" );
1686
1687                 /* zero only the new slots.*/
1688                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1689                 (yy_buffer_stack_max) = num_to_alloc;
1690         }
1691 }
1692
1693 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1694  * @param base the character buffer
1695  * @param size the size in bytes of the character buffer
1696  *
1697  * @return the newly allocated buffer state object.
1698  */
1699 YY_BUFFER_STATE _lc_opt__scan_buffer  (char * base, yy_size_t  size )
1700 {
1701         YY_BUFFER_STATE b;
1702
1703         if ( size < 2 ||
1704              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1705              base[size-1] != YY_END_OF_BUFFER_CHAR )
1706                 /* They forgot to leave room for the EOB's. */
1707                 return 0;
1708
1709         b = (YY_BUFFER_STATE) _lc_opt_alloc(sizeof( struct yy_buffer_state )  );
1710         if ( ! b )
1711                 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt__scan_buffer()" );
1712
1713         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1714         b->yy_buf_pos = b->yy_ch_buf = base;
1715         b->yy_is_our_buffer = 0;
1716         b->yy_input_file = 0;
1717         b->yy_n_chars = b->yy_buf_size;
1718         b->yy_is_interactive = 0;
1719         b->yy_at_bol = 1;
1720         b->yy_fill_buffer = 0;
1721         b->yy_buffer_status = YY_BUFFER_NEW;
1722
1723         _lc_opt__switch_to_buffer(b  );
1724
1725         return b;
1726 }
1727
1728 /** Setup the input buffer state to scan a string. The next call to _lc_opt_lex() will
1729  * scan from a @e copy of @a str.
1730  * @param yystr a NUL-terminated string to scan
1731  *
1732  * @return the newly allocated buffer state object.
1733  * @note If you want to scan bytes that may contain NUL values, then use
1734  *       _lc_opt__scan_bytes() instead.
1735  */
1736 YY_BUFFER_STATE _lc_opt__scan_string (yyconst char * yystr )
1737 {
1738
1739         return _lc_opt__scan_bytes(yystr,strlen(yystr) );
1740 }
1741
1742 /** Setup the input buffer state to scan the given bytes. The next call to _lc_opt_lex() will
1743  * scan from a @e copy of @a bytes.
1744  * @param yybytes the byte buffer to scan
1745  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1746  *
1747  * @return the newly allocated buffer state object.
1748  */
1749 YY_BUFFER_STATE _lc_opt__scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
1750 {
1751         YY_BUFFER_STATE b;
1752         char *buf;
1753         yy_size_t n;
1754         int i;
1755
1756         /* Get memory for full buffer, including space for trailing EOB's. */
1757         n = _yybytes_len + 2;
1758         buf = (char *) _lc_opt_alloc(n  );
1759         if ( ! buf )
1760                 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt__scan_bytes()" );
1761
1762         for ( i = 0; i < _yybytes_len; ++i )
1763                 buf[i] = yybytes[i];
1764
1765         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1766
1767         b = _lc_opt__scan_buffer(buf,n );
1768         if ( ! b )
1769                 YY_FATAL_ERROR( "bad buffer in _lc_opt__scan_bytes()" );
1770
1771         /* It's okay to grow etc. this buffer, and we should throw it
1772          * away when we're done.
1773          */
1774         b->yy_is_our_buffer = 1;
1775
1776         return b;
1777 }
1778
1779 #ifndef YY_EXIT_FAILURE
1780 #define YY_EXIT_FAILURE 2
1781 #endif
1782
1783 static void yy_fatal_error (yyconst char* msg )
1784 {
1785         (void) fprintf( stderr, "%s\n", msg );
1786         exit( YY_EXIT_FAILURE );
1787 }
1788
1789 /* Redefine yyless() so it works in section 3 code. */
1790
1791 #undef yyless
1792 #define yyless(n) \
1793         do \
1794                 { \
1795                 /* Undo effects of setting up _lc_opt_text. */ \
1796         int yyless_macro_arg = (n); \
1797         YY_LESS_LINENO(yyless_macro_arg);\
1798                 _lc_opt_text[_lc_opt_leng] = (yy_hold_char); \
1799                 (yy_c_buf_p) = _lc_opt_text + yyless_macro_arg; \
1800                 (yy_hold_char) = *(yy_c_buf_p); \
1801                 *(yy_c_buf_p) = '\0'; \
1802                 _lc_opt_leng = yyless_macro_arg; \
1803                 } \
1804         while ( 0 )
1805
1806 /* Accessor  methods (get/set functions) to struct members. */
1807
1808 /** Get the current line number.
1809  *
1810  */
1811 int _lc_opt_get_lineno  (void)
1812 {
1813
1814     return _lc_opt_lineno;
1815 }
1816
1817 /** Get the input stream.
1818  *
1819  */
1820 FILE *_lc_opt_get_in  (void)
1821 {
1822         return _lc_opt_in;
1823 }
1824
1825 /** Get the output stream.
1826  *
1827  */
1828 FILE *_lc_opt_get_out  (void)
1829 {
1830         return _lc_opt_out;
1831 }
1832
1833 /** Get the length of the current token.
1834  *
1835  */
1836 int _lc_opt_get_leng  (void)
1837 {
1838         return _lc_opt_leng;
1839 }
1840
1841 /** Get the current token.
1842  *
1843  */
1844
1845 char *_lc_opt_get_text  (void)
1846 {
1847         return _lc_opt_text;
1848 }
1849
1850 /** Set the current line number.
1851  * @param line_number
1852  *
1853  */
1854 void _lc_opt_set_lineno (int  line_number )
1855 {
1856
1857     _lc_opt_lineno = line_number;
1858 }
1859
1860 /** Set the input stream. This does not discard the current
1861  * input buffer.
1862  * @param in_str A readable stream.
1863  *
1864  * @see _lc_opt__switch_to_buffer
1865  */
1866 void _lc_opt_set_in (FILE *  in_str )
1867 {
1868         _lc_opt_in = in_str ;
1869 }
1870
1871 void _lc_opt_set_out (FILE *  out_str )
1872 {
1873         _lc_opt_out = out_str ;
1874 }
1875
1876 int _lc_opt_get_debug  (void)
1877 {
1878         return _lc_opt__flex_debug;
1879 }
1880
1881 void _lc_opt_set_debug (int  bdebug )
1882 {
1883         _lc_opt__flex_debug = bdebug ;
1884 }
1885
1886 static int yy_init_globals (void)
1887 {
1888         /* Initialization is the same as for the non-reentrant scanner.
1889      * This function is called from _lc_opt_lex_destroy(), so don't allocate here.
1890      */
1891
1892     (yy_buffer_stack) = 0;
1893     (yy_buffer_stack_top) = 0;
1894     (yy_buffer_stack_max) = 0;
1895     (yy_c_buf_p) = (char *) 0;
1896     (yy_init) = 0;
1897     (yy_start) = 0;
1898
1899 /* Defined in main.c */
1900 #ifdef YY_STDINIT
1901     _lc_opt_in = stdin;
1902     _lc_opt_out = stdout;
1903 #else
1904     _lc_opt_in = (FILE *) 0;
1905     _lc_opt_out = (FILE *) 0;
1906 #endif
1907
1908     /* For future reference: Set errno on error, since we are called by
1909      * _lc_opt_lex_init()
1910      */
1911     return 0;
1912 }
1913
1914 /* _lc_opt_lex_destroy is for both reentrant and non-reentrant scanners. */
1915 int _lc_opt_lex_destroy  (void)
1916 {
1917
1918     /* Pop the buffer stack, destroying each element. */
1919         while(YY_CURRENT_BUFFER){
1920                 _lc_opt__delete_buffer(YY_CURRENT_BUFFER  );
1921                 YY_CURRENT_BUFFER_LVALUE = NULL;
1922                 _lc_opt_pop_buffer_state();
1923         }
1924
1925         /* Destroy the stack itself. */
1926         _lc_opt_free((yy_buffer_stack) );
1927         (yy_buffer_stack) = NULL;
1928
1929     /* Reset the globals. This is important in a non-reentrant scanner so the next time
1930      * _lc_opt_lex() is called, initialization will occur. */
1931     yy_init_globals( );
1932
1933     return 0;
1934 }
1935
1936 /*
1937  * Internal utility routines.
1938  */
1939
1940 #ifndef yytext_ptr
1941 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1942 {
1943         register int i;
1944         for ( i = 0; i < n; ++i )
1945                 s1[i] = s2[i];
1946 }
1947 #endif
1948
1949 #ifdef YY_NEED_STRLEN
1950 static int yy_flex_strlen (yyconst char * s )
1951 {
1952         register int n;
1953         for ( n = 0; s[n]; ++n )
1954                 ;
1955
1956         return n;
1957 }
1958 #endif
1959
1960 void *_lc_opt_alloc (yy_size_t  size )
1961 {
1962         return (void *) malloc( size );
1963 }
1964
1965 void *_lc_opt_realloc  (void * ptr, yy_size_t  size )
1966 {
1967         /* The cast to (char *) in the following accommodates both
1968          * implementations that use char* generic pointers, and those
1969          * that use void* generic pointers.  It works with the latter
1970          * because both ANSI C and C++ allow castless assignment from
1971          * any pointer type to void*, and deal with argument conversions
1972          * as though doing an assignment.
1973          */
1974         return (void *) realloc( (char *) ptr, size );
1975 }
1976
1977 void _lc_opt_free (void * ptr )
1978 {
1979         free( (char *) ptr );   /* see _lc_opt_realloc() for (char *) cast */
1980 }
1981
1982 #define YYTABLES_NAME "yytables"
1983
1984 #line 104 "lc_config_lexer.l"
1985
1986
1987
1988 static int _lc_opt_wrap(void)
1989 {
1990         /* avoid warning */
1991         (void) yyunput;
1992         (void) input;
1993         return 1;
1994 }