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 #define YY_BUF_SIZE 16384
 165 #endif
 166
 167 /* The state buf must be large enough to hold one state per character in the main buffer.
 168  */
 169 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 170
 171 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 172 #define YY_TYPEDEF_YY_BUFFER_STATE
 173 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 174 #endif
 175
 176 extern int _lc_opt_leng;
 177
 178 extern FILE *_lc_opt_in, *_lc_opt_out;
 179
 180 #define EOB_ACT_CONTINUE_SCAN 0
 181 #define EOB_ACT_END_OF_FILE 1
 182 #define EOB_ACT_LAST_MATCH 2
 183
 184     #define YY_LESS_LINENO(n)
 185
 186 /* Return all but the first "n" matched characters back to the input stream. */
 187 #define yyless(n) \
 188         do \
 189                 { \
 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 */ \
 197                 } \
 198         while ( 0 )
 199
 200 #define unput(c) yyunput( c, (yytext_ptr)  )
 201
 202 #ifndef YY_TYPEDEF_YY_SIZE_T
 203 #define YY_TYPEDEF_YY_SIZE_T
 204 typedef size_t yy_size_t;
 205 #endif
 206
 207 #ifndef YY_STRUCT_YY_BUFFER_STATE
 208 #define YY_STRUCT_YY_BUFFER_STATE
 209 struct yy_buffer_state
 210         {
 211         FILE *yy_input_file;
 212
 213         char *yy_ch_buf;                /* input buffer */
 214         char *yy_buf_pos;               /* current position in input buffer */
 215
 216         /* Size of input buffer in bytes, not including room for EOB
 217          * characters.
 218          */
 219         yy_size_t yy_buf_size;
 220
 221         /* Number of characters read into yy_ch_buf, not including EOB
 222          * characters.
 223          */
 224         int yy_n_chars;
 225
 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
 228          * delete it.
 229          */
 230         int yy_is_our_buffer;
 231
 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
 235          * each newline.
 236          */
 237         int yy_is_interactive;
 238
 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
 241          * not.
 242          */
 243         int yy_at_bol;
 244
 245     int yy_bs_lineno; /**< The line count. */
 246     int yy_bs_column; /**< The column count. */
 247
 248         /* Whether to try to fill the input buffer when we reach the
 249          * end of it.
 250          */
 251         int yy_fill_buffer;
 252
 253         int yy_buffer_status;
 254
 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.
 262          *
 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.
 266          */
 267 #define YY_BUFFER_EOF_PENDING 2
 268
 269         };
 270 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 271
 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. */
 276
 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
 279  * "scanner state".
 280  *
 281  * Returns the top of the stack, or NULL.
 282  */
 283 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
 284                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
 285                           : NULL)
 286
 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.
 289  */
 290 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 291
 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 */
 295 int _lc_opt_leng;
 296
 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 */
 301
 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 ...
 304  */
 305 static int yy_did_buffer_switch_on_eof;
 306
 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 );
 314
 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  );
 318
 319 #define YY_FLUSH_BUFFER _lc_opt__flush_buffer(YY_CURRENT_BUFFER )
 320
 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  );
 324
 325 void *_lc_opt_alloc (yy_size_t  );
 326 void *_lc_opt_realloc (void *,yy_size_t  );
 327 void _lc_opt_free (void *  );
 328
 329 #define yy_new_buffer _lc_opt__create_buffer
 330
 331 #define yy_set_interactive(is_interactive) \
 332         { \
 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 ); \
 337         } \
 338         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 339         }
 340
 341 #define yy_set_bol(at_bol) \
 342         { \
 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 ); \
 347         } \
 348         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 349         }
 350
 351 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 352
 353 /* Begin user sect3 */
 354
 355 typedef unsigned char YY_CHAR;
 356
 357 FILE *_lc_opt_in = (FILE *) 0, *_lc_opt_out = (FILE *) 0;
 358
 359 typedef int yy_state_type;
 360
 361 extern int _lc_opt_lineno;
 362
 363 int _lc_opt_lineno = 1;
 364
 365 extern char *_lc_opt_text;
 366 #define yytext_ptr _lc_opt_text
 367
 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[]  );
 372
 373 /* Done after the current pattern has been matched and before the
 374  * corresponding action - sets up _lc_opt_text.
 375  */
 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; \
 380         *yy_cp = '\0'; \
 381         (yy_c_buf_p) = yy_cp;
 382
 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. */
 387 struct yy_trans_info
 388         {
 389         flex_int32_t yy_verify;
 390         flex_int32_t yy_nxt;
 391         };
 392 static yyconst flex_int16_t yy_accept[49] =
 393     {   0,
 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
 399     } ;
 400
 401 static yyconst flex_int32_t yy_ec[256] =
 402     {   0,
 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,
 413
 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,
 424
 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
 431     } ;
 432
 433 static yyconst flex_int32_t yy_meta[18] =
 434     {   0,
 435         1,    1,    2,    1,    1,    3,    1,    1,    1,    3,
 436         1,    1,    3,    3,    3,    3,    3
 437     } ;
 438
 439 static yyconst flex_int16_t yy_base[56] =
 440     {   0,
 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,
 446        54,   57,   60,   23,   63
 447     } ;
 448
 449 static yyconst flex_int16_t yy_def[56] =
 450     {   0,
 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,
 456        48,   48,   48,   48,   48
 457     } ;
 458
 459 static yyconst flex_int16_t yy_nxt[85] =
 460     {   0,
 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,
 469        48,   48,   48,   48
 470     } ;
 471
 472 static yyconst flex_int16_t yy_chk[85] =
 473     {   0,
 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,
 482        48,   48,   48,   48
 483     } ;
 484
 485 static yy_state_type yy_last_accepting_state;
 486 static char *yy_last_accepting_cpos;
 487
 488 extern int _lc_opt__flex_debug;
 489 int _lc_opt__flex_debug = 0;
 490
 491 /* The intent behind this definition is that it'll catch
 492  * any uses of REJECT which flex missed.
 493  */
 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
 498 char *_lc_opt_text;
 499 #line 1 "lc_config_lexer.l"
 500 #line 5 "lc_config_lexer.l"
 501
 502 /*
 503   libcore: library for basic data structures and algorithms.
 504   Copyright (C) 2005  IPD Goos, Universit"at Karlsruhe, Germany
 505
 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.
 510
 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.
 515
 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
 519 */
 520 #include "config.h"
 521
 522 #include <stdio.h>
 523
 524 #include "lc_parser_t.h"
 525 #include "lc_config_parser.h"
 526
 527 static int _lc_opt_wrap(void)
 528 {
 529         return 1;
 530 }
 531
 532
 533
 534
 535
 536
 537 #line 540 "lc_config_lexer.c"
 538
 539 #define INITIAL 0
 540 #define LINE_COMMENT 1
 541 #define BIG_COMMENT 2
 542 #define DAT 3
 543 #define DAT_CONT 4
 544 #define STR 5
 545
 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.
 550  */
 551 #include <unistd.h>
 552 #endif
 553
 554 #ifndef YY_EXTRA_TYPE
 555 #define YY_EXTRA_TYPE void *
 556 #endif
 557
 558 static int yy_init_globals (void );
 559
 560 /* Accessor methods to globals.
 561    These are made visible to non-reentrant scanners for convenience. */
 562
 563 int _lc_opt_lex_destroy (void );
 564
 565 int _lc_opt_get_debug (void );
 566
 567 void _lc_opt_set_debug (int debug_flag  );
 568
 569 YY_EXTRA_TYPE _lc_opt_get_extra (void );
 570
 571 void _lc_opt_set_extra (YY_EXTRA_TYPE user_defined  );
 572
 573 FILE *_lc_opt_get_in (void );
 574
 575 void _lc_opt_set_in  (FILE * in_str  );
 576
 577 FILE *_lc_opt_get_out (void );
 578
 579 void _lc_opt_set_out  (FILE * out_str  );
 580
 581 int _lc_opt_get_leng (void );
 582
 583 char *_lc_opt_get_text (void );
 584
 585 int _lc_opt_get_lineno (void );
 586
 587 void _lc_opt_set_lineno (int line_number  );
 588
 589 /* Macros after this point can all be overridden by user definitions in
 590  * section 1.
 591  */
 592
 593 #ifndef YY_SKIP_YYWRAP
 594 #ifdef __cplusplus
 595 extern "C" int _lc_opt_wrap (void );
 596 #else
 597 extern int _lc_opt_wrap (void );
 598 #endif
 599 #endif
 600
 601     static void yyunput (int c,char *buf_ptr  );
 602
 603 #ifndef yytext_ptr
 604 static void yy_flex_strncpy (char *,yyconst char *,int );
 605 #endif
 606
 607 #ifdef YY_NEED_STRLEN
 608 static int yy_flex_strlen (yyconst char * );
 609 #endif
 610
 611 #ifndef YY_NO_INPUT
 612
 613 #ifdef __cplusplus
 614 static int yyinput (void );
 615 #else
 616 static int input (void );
 617 #endif
 618
 619 #endif
 620
 621 /* Amount of stuff to slurp up with each read. */
 622 #ifndef YY_READ_BUF_SIZE
 623 #define YY_READ_BUF_SIZE 8192
 624 #endif
 625
 626 /* Copy whatever the last rule matched to the standard output. */
 627 #ifndef ECHO
 628 /* This used to be an fputs(), but since the string might contain NUL's,
 629  * we now use fwrite().
 630  */
 631 #define ECHO fwrite( _lc_opt_text, _lc_opt_leng, 1, _lc_opt_out )
 632 #endif
 633
 634 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 635  * is returned in "result".
 636  */
 637 #ifndef YY_INPUT
 638 #define YY_INPUT(buf,result,max_size) \
 639         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 640                 { \
 641                 int c = '*'; \
 642                 size_t n; \
 643                 for ( n = 0; n < max_size && \
 644                              (c = getc( _lc_opt_in )) != EOF && c != '\n'; ++n ) \
 645                         buf[n] = (char) c; \
 646                 if ( c == '\n' ) \
 647                         buf[n++] = (char) c; \
 648                 if ( c == EOF && ferror( _lc_opt_in ) ) \
 649                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 650                 result = n; \
 651                 } \
 652         else \
 653                 { \
 654                 errno=0; \
 655                 while ( (result = fread(buf, 1, max_size, _lc_opt_in))==0 && ferror(_lc_opt_in)) \
 656                         { \
 657                         if( errno != EINTR) \
 658                                 { \
 659                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
 660                                 break; \
 661                                 } \
 662                         errno=0; \
 663                         clearerr(_lc_opt_in); \
 664                         } \
 665                 }\
 666 \
 667
 668 #endif
 669
 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.
 673  */
 674 #ifndef yyterminate
 675 #define yyterminate() return YY_NULL
 676 #endif
 677
 678 /* Number of entries by which start-condition stack grows. */
 679 #ifndef YY_START_STACK_INCR
 680 #define YY_START_STACK_INCR 25
 681 #endif
 682
 683 /* Report a fatal error. */
 684 #ifndef YY_FATAL_ERROR
 685 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 686 #endif
 687
 688 /* end tables serialization structures and prototypes */
 689
 690 /* Default declaration of generated scanner - a define so the user can
 691  * easily add parameters.
 692  */
 693 #ifndef YY_DECL
 694 #define YY_DECL_IS_OURS 1
 695
 696 extern int _lc_opt_lex (void);
 697
 698 #define YY_DECL int _lc_opt_lex (void)
 699 #endif /* !YY_DECL */
 700
 701 /* Code executed at the beginning of each rule, after _lc_opt_text and _lc_opt_leng
 702  * have been set up.
 703  */
 704 #ifndef YY_USER_ACTION
 705 #define YY_USER_ACTION
 706 #endif
 707
 708 /* Code executed at the end of each rule. */
 709 #ifndef YY_BREAK
 710 #define YY_BREAK break;
 711 #endif
 712
 713 #define YY_RULE_SETUP \
 714         YY_USER_ACTION
 715
 716 /** The main scanner function which does all the work.
 717  */
 718 YY_DECL
 719 {
 720         register yy_state_type yy_current_state;
 721         register char *yy_cp, *yy_bp;
 722         register int yy_act;
 723
 724 #line 55 "lc_config_lexer.l"
 725
 726
 727 #line 730 "lc_config_lexer.c"
 728
 729         if ( !(yy_init) )
 730                 {
 731                 (yy_init) = 1;
 732
 733 #ifdef YY_USER_INIT
 734                 YY_USER_INIT;
 735 #endif
 736
 737                 if ( ! (yy_start) )
 738                         (yy_start) = 1; /* first start state */
 739
 740                 if ( ! _lc_opt_in )
 741                         _lc_opt_in = stdin;
 742
 743                 if ( ! _lc_opt_out )
 744                         _lc_opt_out = stdout;
 745
 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 );
 750                 }
 751
 752                 _lc_opt__load_buffer_state( );
 753                 }
 754
 755         while ( 1 )             /* loops until end-of-file is reached */
 756                 {
 757                 yy_cp = (yy_c_buf_p);
 758
 759                 /* Support of _lc_opt_text. */
 760                 *yy_cp = (yy_hold_char);
 761
 762                 /* yy_bp points to the position in yy_ch_buf of the start of
 763                  * the current run.
 764                  */
 765                 yy_bp = yy_cp;
 766
 767                 yy_current_state = (yy_start);
 768 yy_match:
 769                 do
 770                         {
 771                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 772                         if ( yy_accept[yy_current_state] )
 773                                 {
 774                                 (yy_last_accepting_state) = yy_current_state;
 775                                 (yy_last_accepting_cpos) = yy_cp;
 776                                 }
 777                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 778                                 {
 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];
 782                                 }
 783                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 784                         ++yy_cp;
 785                         }
 786                 while ( yy_base[yy_current_state] != 67 );
 787
 788 yy_find_action:
 789                 yy_act = yy_accept[yy_current_state];
 790                 if ( yy_act == 0 )
 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];
 795                         }
 796
 797                 YY_DO_BEFORE_ACTION;
 798
 799 do_action:      /* This label is used only to access EOF actions. */
 800
 801                 switch ( yy_act )
 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);
 808                         goto yy_find_action;
 809
 810 case 1:
 811 YY_RULE_SETUP
 812 #line 57 "lc_config_lexer.l"
 813 { BEGIN(BIG_COMMENT); }
 814         YY_BREAK
 815 case 2:
 816 YY_RULE_SETUP
 817 #line 58 "lc_config_lexer.l"
 818 { BEGIN(INITIAL); }
 819         YY_BREAK
 820 case 3:
 821 /* rule 3 can match eol */
 822 YY_RULE_SETUP
 823 #line 59 "lc_config_lexer.l"
 824 PMANGLE(linenr)++;
 825         YY_BREAK
 826 case 4:
 827 YY_RULE_SETUP
 828 #line 60 "lc_config_lexer.l"
 829 ;
 830         YY_BREAK
 831 case 5:
 832 YY_RULE_SETUP
 833 #line 62 "lc_config_lexer.l"
 834 { BEGIN(LINE_COMMENT); }
 835         YY_BREAK
 836 case 6:
 837 /* rule 6 can match eol */
 838 YY_RULE_SETUP
 839 #line 63 "lc_config_lexer.l"
 840 { BEGIN(INITIAL); PMANGLE(linenr)++; }
 841         YY_BREAK
 842 case 7:
 843 YY_RULE_SETUP
 844 #line 64 "lc_config_lexer.l"
 845 ;
 846         YY_BREAK
 847 case 8:
 848 YY_RULE_SETUP
 849 #line 67 "lc_config_lexer.l"
 850 { BEGIN(DAT); }
 851         YY_BREAK
 852 case 9:
 853 YY_RULE_SETUP
 854 #line 68 "lc_config_lexer.l"
 855 { BEGIN(STR); }
 856         YY_BREAK
 857 case 10:
 858 YY_RULE_SETUP
 859 #line 69 "lc_config_lexer.l"
 860 { BEGIN(DAT_CONT); }
 861         YY_BREAK
 862 case 11:
 863 YY_RULE_SETUP
 864 #line 70 "lc_config_lexer.l"
 865 { _lc_opt_add_to_data_char(PMANGLE(text)[0]); }
 866         YY_BREAK
 867 case 12:
 868 /* rule 12 can match eol */
 869 YY_RULE_SETUP
 870 #line 71 "lc_config_lexer.l"
 871 {
 872                                                 BEGIN(INITIAL);
 873                                                 PMANGLE(linenr)++;
 874                                                 _lc_opt_add_to_data_char('\0');
 875                                                 return DATA;
 876                                         }
 877         YY_BREAK
 878 case 13:
 879 /* rule 13 can match eol */
 880 YY_RULE_SETUP
 881 #line 77 "lc_config_lexer.l"
 882 { BEGIN(DAT); PMANGLE(linenr)++; }
 883         YY_BREAK
 884 case 14:
 885 YY_RULE_SETUP
 886 #line 78 "lc_config_lexer.l"
 887 ;
 888         YY_BREAK
 889 case 15:
 890 YY_RULE_SETUP
 891 #line 81 "lc_config_lexer.l"
 892 {
 893                                                 BEGIN(INITIAL);
 894                                                 _lc_opt_add_to_data_char('\0');
 895                                                 return DATA;
 896                                         }
 897         YY_BREAK
 898 case 16:
 899 YY_RULE_SETUP
 900 #line 87 "lc_config_lexer.l"
 901 _lc_opt_add_to_data_char('\n');
 902         YY_BREAK
 903 case 17:
 904 YY_RULE_SETUP
 905 #line 88 "lc_config_lexer.l"
 906 _lc_opt_add_to_data_char('\r');
 907         YY_BREAK
 908 case 18:
 909 YY_RULE_SETUP
 910 #line 89 "lc_config_lexer.l"
 911 _lc_opt_add_to_data_char('\t');
 912         YY_BREAK
 913 case 19:
 914 YY_RULE_SETUP
 915 #line 90 "lc_config_lexer.l"
 916 _lc_opt_add_to_data_char('\b');
 917         YY_BREAK
 918 case 20:
 919 YY_RULE_SETUP
 920 #line 91 "lc_config_lexer.l"
 921 _lc_opt_add_to_data_char('\f');
 922         YY_BREAK
 923 case 21:
 924 YY_RULE_SETUP
 925 #line 92 "lc_config_lexer.l"
 926 _lc_opt_add_to_data_char(_lc_opt_text[1]);
 927         YY_BREAK
 928 case 22:
 929 /* rule 22 can match eol */
 930 YY_RULE_SETUP
 931 #line 93 "lc_config_lexer.l"
 932 _lc_opt_add_to_data_char(_lc_opt_text[0]);
 933         YY_BREAK
 934 case 23:
 935 YY_RULE_SETUP
 936 #line 95 "lc_config_lexer.l"
 937 {
 938                                                 PMANGLE(lval).text.str = PMANGLE(text);
 939                                                 PMANGLE(lval).text.len = PMANGLE(leng);
 940                                                 return IDENT;
 941                                         }
 942         YY_BREAK
 943 case 24:
 944 YY_RULE_SETUP
 945 #line 100 "lc_config_lexer.l"
 946 { return SEP; }
 947         YY_BREAK
 948 case 25:
 949 YY_RULE_SETUP
 950 #line 102 "lc_config_lexer.l"
 951 ;
 952         YY_BREAK
 953 case 26:
 954 /* rule 26 can match eol */
 955 YY_RULE_SETUP
 956 #line 103 "lc_config_lexer.l"
 957 PMANGLE(linenr)++;
 958         YY_BREAK
 959 case 27:
 960 YY_RULE_SETUP
 961 #line 105 "lc_config_lexer.l"
 962 return _lc_opt_text[0];
 963         YY_BREAK
 964 case 28:
 965 YY_RULE_SETUP
 966 #line 107 "lc_config_lexer.l"
 967 ECHO;
 968         YY_BREAK
 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):
 976         yyterminate();
 977
 978         case YY_END_OF_BUFFER:
 979                 {
 980                 /* Amount of text matched not including the EOB char. */
 981                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
 982
 983                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
 984                 *yy_cp = (yy_hold_char);
 985                 YY_RESTORE_YY_MORE_OFFSET
 986
 987                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
 988                         {
 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.
 997                          */
 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;
1001                         }
1002
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
1008                  * in input().
1009                  */
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;
1013
1014                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1015
1016                         yy_current_state = yy_get_previous_state(  );
1017
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).
1025                          */
1026
1027                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1028
1029                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1030
1031                         if ( yy_next_state )
1032                                 {
1033                                 /* Consume the NUL. */
1034                                 yy_cp = ++(yy_c_buf_p);
1035                                 yy_current_state = yy_next_state;
1036                                 goto yy_match;
1037                                 }
1038
1039                         else
1040                                 {
1041                                 yy_cp = (yy_c_buf_p);
1042                                 goto yy_find_action;
1043                                 }
1044                         }
1045
1046                 else switch ( yy_get_next_buffer(  ) )
1047                         {
1048                         case EOB_ACT_END_OF_FILE:
1049                                 {
1050                                 (yy_did_buffer_switch_on_eof) = 0;
1051
1052                                 if ( _lc_opt_wrap( ) )
1053                                         {
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.
1062                                          */
1063                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1064
1065                                         yy_act = YY_STATE_EOF(YY_START);
1066                                         goto do_action;
1067                                         }
1068
1069                                 else
1070                                         {
1071                                         if ( ! (yy_did_buffer_switch_on_eof) )
1072                                                 YY_NEW_FILE;
1073                                         }
1074                                 break;
1075                                 }
1076
1077                         case EOB_ACT_CONTINUE_SCAN:
1078                                 (yy_c_buf_p) =
1079                                         (yytext_ptr) + yy_amount_of_matched_text;
1080
1081                                 yy_current_state = yy_get_previous_state(  );
1082
1083                                 yy_cp = (yy_c_buf_p);
1084                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1085                                 goto yy_match;
1086
1087                         case EOB_ACT_LAST_MATCH:
1088                                 (yy_c_buf_p) =
1089                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1090
1091                                 yy_current_state = yy_get_previous_state(  );
1092
1093                                 yy_cp = (yy_c_buf_p);
1094                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1095                                 goto yy_find_action;
1096                         }
1097                 break;
1098                 }
1099
1100         default:
1101                 YY_FATAL_ERROR(
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 */
1106
1107 /* yy_get_next_buffer - try to read in a new buffer
1108  *
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
1113  */
1114 static int yy_get_next_buffer (void)
1115 {
1116         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1117         register char *source = (yytext_ptr);
1118         register int number_to_move, i;
1119         int ret_val;
1120
1121         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1122                 YY_FATAL_ERROR(
1123                 "fatal flex scanner internal error--end of buffer missed" );
1124
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 )
1128                         {
1129                         /* We matched a single character, the EOB, so
1130                          * treat this as a final EOF.
1131                          */
1132                         return EOB_ACT_END_OF_FILE;
1133                         }
1134
1135                 else
1136                         {
1137                         /* We matched some text prior to the EOB, first
1138                          * process it.
1139                          */
1140                         return EOB_ACT_LAST_MATCH;
1141                         }
1142                 }
1143
1144         /* Try to read more data. */
1145
1146         /* First move last chars to start of buffer. */
1147         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1148
1149         for ( i = 0; i < number_to_move; ++i )
1150                 *(dest++) = *(source++);
1151
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,
1154                  * just force an EOF
1155                  */
1156                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1157
1158         else
1159                 {
1160                         int num_to_read =
1161                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1162
1163                 while ( num_to_read <= 0 )
1164                         { /* Not enough room in the buffer - grow it. */
1165
1166                         /* just a shorter name for the current buffer */
1167                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1168
1169                         int yy_c_buf_p_offset =
1170                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1171
1172                         if ( b->yy_is_our_buffer )
1173                                 {
1174                                 int new_size = b->yy_buf_size * 2;
1175
1176                                 if ( new_size <= 0 )
1177                                         b->yy_buf_size += b->yy_buf_size / 8;
1178                                 else
1179                                         b->yy_buf_size *= 2;
1180
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  );
1184                                 }
1185                         else
1186                                 /* Can't grow it, we don't own it. */
1187                                 b->yy_ch_buf = 0;
1188
1189                         if ( ! b->yy_ch_buf )
1190                                 YY_FATAL_ERROR(
1191                                 "fatal error - scanner input buffer overflow" );
1192
1193                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1194
1195                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1196                                                 number_to_move - 1;
1197
1198                         }
1199
1200                 if ( num_to_read > YY_READ_BUF_SIZE )
1201                         num_to_read = YY_READ_BUF_SIZE;
1202
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 );
1206
1207                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1208                 }
1209
1210         if ( (yy_n_chars) == 0 )
1211                 {
1212                 if ( number_to_move == YY_MORE_ADJ )
1213                         {
1214                         ret_val = EOB_ACT_END_OF_FILE;
1215                         _lc_opt_restart(_lc_opt_in  );
1216                         }
1217
1218                 else
1219                         {
1220                         ret_val = EOB_ACT_LAST_MATCH;
1221                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1222                                 YY_BUFFER_EOF_PENDING;
1223                         }
1224                 }
1225
1226         else
1227                 ret_val = EOB_ACT_CONTINUE_SCAN;
1228
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()" );
1235         }
1236
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;
1240
1241         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1242
1243         return ret_val;
1244 }
1245
1246 /* yy_get_previous_state - get the state just before the EOB char was reached */
1247
1248     static yy_state_type yy_get_previous_state (void)
1249 {
1250         register yy_state_type yy_current_state;
1251         register char *yy_cp;
1252
1253         yy_current_state = (yy_start);
1254
1255         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1256                 {
1257                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1258                 if ( yy_accept[yy_current_state] )
1259                         {
1260                         (yy_last_accepting_state) = yy_current_state;
1261                         (yy_last_accepting_cpos) = yy_cp;
1262                         }
1263                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1264                         {
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];
1268                         }
1269                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1270                 }
1271
1272         return yy_current_state;
1273 }
1274
1275 /* yy_try_NUL_trans - try to make a transition on the NUL character
1276  *
1277  * synopsis
1278  *      next_state = yy_try_NUL_trans( current_state );
1279  */
1280     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1281 {
1282         register int yy_is_jam;
1283         register char *yy_cp = (yy_c_buf_p);
1284
1285         register YY_CHAR yy_c = 1;
1286         if ( yy_accept[yy_current_state] )
1287                 {
1288                 (yy_last_accepting_state) = yy_current_state;
1289                 (yy_last_accepting_cpos) = yy_cp;
1290                 }
1291         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1292                 {
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];
1296                 }
1297         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1298         yy_is_jam = (yy_current_state == 48);
1299
1300         return yy_is_jam ? 0 : yy_current_state;
1301 }
1302
1303     static void yyunput (int c, register char * yy_bp )
1304 {
1305         register char *yy_cp;
1306
1307     yy_cp = (yy_c_buf_p);
1308
1309         /* undo effects of setting up _lc_opt_text */
1310         *yy_cp = (yy_hold_char);
1311
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];
1320
1321                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1322                         *--dest = *--source;
1323
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;
1328
1329                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1330                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1331                 }
1332
1333         *--yy_cp = (char) c;
1334
1335         (yytext_ptr) = yy_bp;
1336         (yy_hold_char) = *yy_cp;
1337         (yy_c_buf_p) = yy_cp;
1338 }
1339
1340 #ifndef YY_NO_INPUT
1341 #ifdef __cplusplus
1342     static int yyinput (void)
1343 #else
1344     static int input  (void)
1345 #endif
1346
1347 {
1348         int c;
1349
1350         *(yy_c_buf_p) = (yy_hold_char);
1351
1352         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1353                 {
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.
1357                  */
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';
1361
1362                 else
1363                         { /* need more input */
1364                         int offset = (yy_c_buf_p) - (yytext_ptr);
1365                         ++(yy_c_buf_p);
1366
1367                         switch ( yy_get_next_buffer(  ) )
1368                                 {
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.
1378                                          */
1379
1380                                         /* Reset buffer status. */
1381                                         _lc_opt_restart(_lc_opt_in );
1382
1383                                         /*FALLTHROUGH*/
1384
1385                                 case EOB_ACT_END_OF_FILE:
1386                                         {
1387                                         if ( _lc_opt_wrap( ) )
1388                                                 return EOF;
1389
1390                                         if ( ! (yy_did_buffer_switch_on_eof) )
1391                                                 YY_NEW_FILE;
1392 #ifdef __cplusplus
1393                                         return yyinput();
1394 #else
1395                                         return input();
1396 #endif
1397                                         }
1398
1399                                 case EOB_ACT_CONTINUE_SCAN:
1400                                         (yy_c_buf_p) = (yytext_ptr) + offset;
1401                                         break;
1402                                 }
1403                         }
1404                 }
1405
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);
1409
1410         return c;
1411 }
1412 #endif  /* ifndef YY_NO_INPUT */
1413
1414 /** Immediately switch to a different input stream.
1415  * @param input_file A readable stream.
1416  *
1417  * @note This function does not reset the start condition to @c INITIAL .
1418  */
1419     void _lc_opt_restart  (FILE * input_file )
1420 {
1421
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 );
1426         }
1427
1428         _lc_opt__init_buffer(YY_CURRENT_BUFFER,input_file );
1429         _lc_opt__load_buffer_state( );
1430 }
1431
1432 /** Switch to a different input buffer.
1433  * @param new_buffer The new input buffer.
1434  *
1435  */
1436     void _lc_opt__switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1437 {
1438
1439         /* TODO. We should be able to replace this entire function body
1440          * with
1441          *              _lc_opt_pop_buffer_state();
1442          *              _lc_opt_push_buffer_state(new_buffer);
1443      */
1444         _lc_opt_ensure_buffer_stack ();
1445         if ( YY_CURRENT_BUFFER == new_buffer )
1446                 return;
1447
1448         if ( YY_CURRENT_BUFFER )
1449                 {
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);
1454                 }
1455
1456         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1457         _lc_opt__load_buffer_state( );
1458
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.
1463          */
1464         (yy_did_buffer_switch_on_eof) = 1;
1465 }
1466
1467 static void _lc_opt__load_buffer_state  (void)
1468 {
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);
1473 }
1474
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.
1478  *
1479  * @return the allocated buffer state.
1480  */
1481     YY_BUFFER_STATE _lc_opt__create_buffer  (FILE * file, int  size )
1482 {
1483         YY_BUFFER_STATE b;
1484
1485         b = (YY_BUFFER_STATE) _lc_opt_alloc(sizeof( struct yy_buffer_state )  );
1486         if ( ! b )
1487                 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt__create_buffer()" );
1488
1489         b->yy_buf_size = size;
1490
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.
1493          */
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()" );
1497
1498         b->yy_is_our_buffer = 1;
1499
1500         _lc_opt__init_buffer(b,file );
1501
1502         return b;
1503 }
1504
1505 /** Destroy the buffer.
1506  * @param b a buffer created with _lc_opt__create_buffer()
1507  *
1508  */
1509     void _lc_opt__delete_buffer (YY_BUFFER_STATE  b )
1510 {
1511
1512         if ( ! b )
1513                 return;
1514
1515         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1516                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1517
1518         if ( b->yy_is_our_buffer )
1519                 _lc_opt_free((void *) b->yy_ch_buf  );
1520
1521         _lc_opt_free((void *) b  );
1522 }
1523
1524 #ifndef __cplusplus
1525 extern int isatty (int );
1526 #endif /* __cplusplus */
1527
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.
1531  */
1532     static void _lc_opt__init_buffer  (YY_BUFFER_STATE  b, FILE * file )
1533
1534 {
1535         int oerrno = errno;
1536
1537         _lc_opt__flush_buffer(b );
1538
1539         b->yy_input_file = file;
1540         b->yy_fill_buffer = 1;
1541
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.
1545      */
1546     if (b != YY_CURRENT_BUFFER){
1547         b->yy_bs_lineno = 1;
1548         b->yy_bs_column = 0;
1549     }
1550
1551         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1552
1553         errno = oerrno;
1554 }
1555
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.
1558  *
1559  */
1560     void _lc_opt__flush_buffer (YY_BUFFER_STATE  b )
1561 {
1562         if ( ! b )
1563                 return;
1564
1565         b->yy_n_chars = 0;
1566
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.
1570          */
1571         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1572         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1573
1574         b->yy_buf_pos = &b->yy_ch_buf[0];
1575
1576         b->yy_at_bol = 1;
1577         b->yy_buffer_status = YY_BUFFER_NEW;
1578
1579         if ( b == YY_CURRENT_BUFFER )
1580                 _lc_opt__load_buffer_state( );
1581 }
1582
1583 /** Pushes the new state onto the stack. The new state becomes
1584  *  the current state. This function will allocate the stack
1585  *  if necessary.
1586  *  @param new_buffer The new state.
1587  *
1588  */
1589 void _lc_opt_push_buffer_state (YY_BUFFER_STATE new_buffer )
1590 {
1591         if (new_buffer == NULL)
1592                 return;
1593
1594         _lc_opt_ensure_buffer_stack();
1595
1596         /* This block is copied from _lc_opt__switch_to_buffer. */
1597         if ( YY_CURRENT_BUFFER )
1598                 {
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);
1603                 }
1604
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;
1609
1610         /* copied from _lc_opt__switch_to_buffer. */
1611         _lc_opt__load_buffer_state( );
1612         (yy_did_buffer_switch_on_eof) = 1;
1613 }
1614
1615 /** Removes and deletes the top of the stack, if present.
1616  *  The next element becomes the new top.
1617  *
1618  */
1619 void _lc_opt_pop_buffer_state (void)
1620 {
1621         if (!YY_CURRENT_BUFFER)
1622                 return;
1623
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);
1628
1629         if (YY_CURRENT_BUFFER) {
1630                 _lc_opt__load_buffer_state( );
1631                 (yy_did_buffer_switch_on_eof) = 1;
1632         }
1633 }
1634
1635 /* Allocates the stack if it does not exist.
1636  *  Guarantees space for at least one push.
1637  */
1638 static void _lc_opt_ensure_buffer_stack (void)
1639 {
1640         int num_to_alloc;
1641
1642         if (!(yy_buffer_stack)) {
1643
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.
1647          */
1648                 num_to_alloc = 1;
1649                 (yy_buffer_stack) = (struct yy_buffer_state**)_lc_opt_alloc
1650                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
1651                                                                 );
1652                 if ( ! (yy_buffer_stack) )
1653                         YY_FATAL_ERROR( "out of dynamic memory in _lc_opt_ensure_buffer_stack()" );
1654
1655                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1656
1657                 (yy_buffer_stack_max) = num_to_alloc;
1658                 (yy_buffer_stack_top) = 0;
1659                 return;
1660         }
1661
1662         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1663
1664                 /* Increase the buffer to prepare for a possible push. */
1665                 int grow_size = 8 /* arbitrary grow size */;
1666
1667                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1668                 (yy_buffer_stack) = (struct yy_buffer_state**)_lc_opt_realloc
1669                                                                 ((yy_buffer_stack),
1670                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
1671                                                                 );
1672                 if ( ! (yy_buffer_stack) )
1673                         YY_FATAL_ERROR( "out of dynamic memory in _lc_opt_ensure_buffer_stack()" );
1674
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;
1678         }
1679 }
1680
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
1684  *
1685  * @return the newly allocated buffer state object.
1686  */
1687 YY_BUFFER_STATE _lc_opt__scan_buffer  (char * base, yy_size_t  size )
1688 {
1689         YY_BUFFER_STATE b;
1690
1691         if ( size < 2 ||
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. */
1695                 return 0;
1696
1697         b = (YY_BUFFER_STATE) _lc_opt_alloc(sizeof( struct yy_buffer_state )  );
1698         if ( ! b )
1699                 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt__scan_buffer()" );
1700
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;
1707         b->yy_at_bol = 1;
1708         b->yy_fill_buffer = 0;
1709         b->yy_buffer_status = YY_BUFFER_NEW;
1710
1711         _lc_opt__switch_to_buffer(b  );
1712
1713         return b;
1714 }
1715
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
1719  *
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.
1723  */
1724 YY_BUFFER_STATE _lc_opt__scan_string (yyconst char * yystr )
1725 {
1726
1727         return _lc_opt__scan_bytes(yystr,strlen(yystr) );
1728 }
1729
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.
1734  *
1735  * @return the newly allocated buffer state object.
1736  */
1737 YY_BUFFER_STATE _lc_opt__scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
1738 {
1739         YY_BUFFER_STATE b;
1740         char *buf;
1741         yy_size_t n;
1742         int i;
1743
1744         /* Get memory for full buffer, including space for trailing EOB's. */
1745         n = _yybytes_len + 2;
1746         buf = (char *) _lc_opt_alloc(n  );
1747         if ( ! buf )
1748                 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt__scan_bytes()" );
1749
1750         for ( i = 0; i < _yybytes_len; ++i )
1751                 buf[i] = yybytes[i];
1752
1753         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1754
1755         b = _lc_opt__scan_buffer(buf,n );
1756         if ( ! b )
1757                 YY_FATAL_ERROR( "bad buffer in _lc_opt__scan_bytes()" );
1758
1759         /* It's okay to grow etc. this buffer, and we should throw it
1760          * away when we're done.
1761          */
1762         b->yy_is_our_buffer = 1;
1763
1764         return b;
1765 }
1766
1767 #ifndef YY_EXIT_FAILURE
1768 #define YY_EXIT_FAILURE 2
1769 #endif
1770
1771 static void yy_fatal_error (yyconst char* msg )
1772 {
1773         (void) fprintf( stderr, "%s\n", msg );
1774         exit( YY_EXIT_FAILURE );
1775 }
1776
1777 /* Redefine yyless() so it works in section 3 code. */
1778
1779 #undef yyless
1780 #define yyless(n) \
1781         do \
1782                 { \
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; \
1791                 } \
1792         while ( 0 )
1793
1794 /* Accessor  methods (get/set functions) to struct members. */
1795
1796 /** Get the current line number.
1797  *
1798  */
1799 int _lc_opt_get_lineno  (void)
1800 {
1801
1802     return _lc_opt_lineno;
1803 }
1804
1805 /** Get the input stream.
1806  *
1807  */
1808 FILE *_lc_opt_get_in  (void)
1809 {
1810         return _lc_opt_in;
1811 }
1812
1813 /** Get the output stream.
1814  *
1815  */
1816 FILE *_lc_opt_get_out  (void)
1817 {
1818         return _lc_opt_out;
1819 }
1820
1821 /** Get the length of the current token.
1822  *
1823  */
1824 int _lc_opt_get_leng  (void)
1825 {
1826         return _lc_opt_leng;
1827 }
1828
1829 /** Get the current token.
1830  *
1831  */
1832
1833 char *_lc_opt_get_text  (void)
1834 {
1835         return _lc_opt_text;
1836 }
1837
1838 /** Set the current line number.
1839  * @param line_number
1840  *
1841  */
1842 void _lc_opt_set_lineno (int  line_number )
1843 {
1844
1845     _lc_opt_lineno = line_number;
1846 }
1847
1848 /** Set the input stream. This does not discard the current
1849  * input buffer.
1850  * @param in_str A readable stream.
1851  *
1852  * @see _lc_opt__switch_to_buffer
1853  */
1854 void _lc_opt_set_in (FILE *  in_str )
1855 {
1856         _lc_opt_in = in_str ;
1857 }
1858
1859 void _lc_opt_set_out (FILE *  out_str )
1860 {
1861         _lc_opt_out = out_str ;
1862 }
1863
1864 int _lc_opt_get_debug  (void)
1865 {
1866         return _lc_opt__flex_debug;
1867 }
1868
1869 void _lc_opt_set_debug (int  bdebug )
1870 {
1871         _lc_opt__flex_debug = bdebug ;
1872 }
1873
1874 static int yy_init_globals (void)
1875 {
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.
1878      */
1879
1880     (yy_buffer_stack) = 0;
1881     (yy_buffer_stack_top) = 0;
1882     (yy_buffer_stack_max) = 0;
1883     (yy_c_buf_p) = (char *) 0;
1884     (yy_init) = 0;
1885     (yy_start) = 0;
1886
1887 /* Defined in main.c */
1888 #ifdef YY_STDINIT
1889     _lc_opt_in = stdin;
1890     _lc_opt_out = stdout;
1891 #else
1892     _lc_opt_in = (FILE *) 0;
1893     _lc_opt_out = (FILE *) 0;
1894 #endif
1895
1896     /* For future reference: Set errno on error, since we are called by
1897      * _lc_opt_lex_init()
1898      */
1899     return 0;
1900 }
1901
1902 /* _lc_opt_lex_destroy is for both reentrant and non-reentrant scanners. */
1903 int _lc_opt_lex_destroy  (void)
1904 {
1905
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();
1911         }
1912
1913         /* Destroy the stack itself. */
1914         _lc_opt_free((yy_buffer_stack) );
1915         (yy_buffer_stack) = NULL;
1916
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. */
1919     yy_init_globals( );
1920
1921     return 0;
1922 }
1923
1924 /*
1925  * Internal utility routines.
1926  */
1927
1928 #ifndef yytext_ptr
1929 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1930 {
1931         register int i;
1932         for ( i = 0; i < n; ++i )
1933                 s1[i] = s2[i];
1934 }
1935 #endif
1936
1937 #ifdef YY_NEED_STRLEN
1938 static int yy_flex_strlen (yyconst char * s )
1939 {
1940         register int n;
1941         for ( n = 0; s[n]; ++n )
1942                 ;
1943
1944         return n;
1945 }
1946 #endif
1947
1948 void *_lc_opt_alloc (yy_size_t  size )
1949 {
1950         return (void *) malloc( size );
1951 }
1952
1953 void *_lc_opt_realloc  (void * ptr, yy_size_t  size )
1954 {
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.
1961          */
1962         return (void *) realloc( (char *) ptr, size );
1963 }
1964
1965 void _lc_opt_free (void * ptr )
1966 {
1967         free( (char *) ptr );   /* see _lc_opt_realloc() for (char *) cast */
1968 }
1969
1970 #define YYTABLES_NAME "yytables"
1971
1972 #line 107 "lc_config_lexer.l"