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 #define YY_NO_UNISTD_H
 538
 539 static int _lc_opt_wrap(void);
 540
 541
 542
 543
 544
 545
 546 #line 547 "lc_config_lexer.c"
 547
 548 #define INITIAL 0
 549 #define LINE_COMMENT 1
 550 #define BIG_COMMENT 2
 551 #define DAT 3
 552 #define DAT_CONT 4
 553 #define STR 5
 554
 555 #ifndef YY_NO_UNISTD_H
 556 /* Special case for "unistd.h", since it is non-ANSI. We include it way
 557  * down here because we want the user's section 1 to have been scanned first.
 558  * The user has a chance to override it with an option.
 559  */
 560 #include <unistd.h>
 561 #endif
 562
 563 #ifndef YY_EXTRA_TYPE
 564 #define YY_EXTRA_TYPE void *
 565 #endif
 566
 567 static int yy_init_globals (void );
 568
 569 /* Accessor methods to globals.
 570    These are made visible to non-reentrant scanners for convenience. */
 571
 572 int _lc_opt_lex_destroy (void );
 573
 574 int _lc_opt_get_debug (void );
 575
 576 void _lc_opt_set_debug (int debug_flag  );
 577
 578 YY_EXTRA_TYPE _lc_opt_get_extra (void );
 579
 580 void _lc_opt_set_extra (YY_EXTRA_TYPE user_defined  );
 581
 582 FILE *_lc_opt_get_in (void );
 583
 584 void _lc_opt_set_in  (FILE * in_str  );
 585
 586 FILE *_lc_opt_get_out (void );
 587
 588 void _lc_opt_set_out  (FILE * out_str  );
 589
 590 int _lc_opt_get_leng (void );
 591
 592 char *_lc_opt_get_text (void );
 593
 594 int _lc_opt_get_lineno (void );
 595
 596 void _lc_opt_set_lineno (int line_number  );
 597
 598 /* Macros after this point can all be overridden by user definitions in
 599  * section 1.
 600  */
 601
 602 #ifndef YY_SKIP_YYWRAP
 603 #ifdef __cplusplus
 604 extern "C" int _lc_opt_wrap (void );
 605 #else
 606 extern int _lc_opt_wrap (void );
 607 #endif
 608 #endif
 609
 610     static void yyunput (int c,char *buf_ptr  );
 611
 612 #ifndef yytext_ptr
 613 static void yy_flex_strncpy (char *,yyconst char *,int );
 614 #endif
 615
 616 #ifdef YY_NEED_STRLEN
 617 static int yy_flex_strlen (yyconst char * );
 618 #endif
 619
 620 #ifndef YY_NO_INPUT
 621
 622 #ifdef __cplusplus
 623 static int yyinput (void );
 624 #else
 625 static int input (void );
 626 #endif
 627
 628 #endif
 629
 630 /* Amount of stuff to slurp up with each read. */
 631 #ifndef YY_READ_BUF_SIZE
 632 #ifdef __ia64__
 633 /* On IA-64, the buffer size is 16k, not 8k */
 634 #define YY_READ_BUF_SIZE 16384
 635 #else
 636 #define YY_READ_BUF_SIZE 8192
 637 #endif /* __ia64__ */
 638 #endif
 639
 640 /* Copy whatever the last rule matched to the standard output. */
 641 #ifndef ECHO
 642 /* This used to be an fputs(), but since the string might contain NUL's,
 643  * we now use fwrite().
 644  */
 645 #define ECHO do { if (fwrite( _lc_opt_text, _lc_opt_leng, 1, _lc_opt_out )) {} } while (0)
 646 #endif
 647
 648 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 649  * is returned in "result".
 650  */
 651 #ifndef YY_INPUT
 652 #define YY_INPUT(buf,result,max_size) \
 653         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 654                 { \
 655                 int c = '*'; \
 656                 size_t n; \
 657                 for ( n = 0; n < max_size && \
 658                              (c = getc( _lc_opt_in )) != EOF && c != '\n'; ++n ) \
 659                         buf[n] = (char) c; \
 660                 if ( c == '\n' ) \
 661                         buf[n++] = (char) c; \
 662                 if ( c == EOF && ferror( _lc_opt_in ) ) \
 663                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 664                 result = n; \
 665                 } \
 666         else \
 667                 { \
 668                 errno=0; \
 669                 while ( (result = fread(buf, 1, max_size, _lc_opt_in))==0 && ferror(_lc_opt_in)) \
 670                         { \
 671                         if( errno != EINTR) \
 672                                 { \
 673                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
 674                                 break; \
 675                                 } \
 676                         errno=0; \
 677                         clearerr(_lc_opt_in); \
 678                         } \
 679                 }\
 680 \
 681
 682 #endif
 683
 684 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 685  * we don't want an extra ';' after the "return" because that will cause
 686  * some compilers to complain about unreachable statements.
 687  */
 688 #ifndef yyterminate
 689 #define yyterminate() return YY_NULL
 690 #endif
 691
 692 /* Number of entries by which start-condition stack grows. */
 693 #ifndef YY_START_STACK_INCR
 694 #define YY_START_STACK_INCR 25
 695 #endif
 696
 697 /* Report a fatal error. */
 698 #ifndef YY_FATAL_ERROR
 699 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 700 #endif
 701
 702 /* end tables serialization structures and prototypes */
 703
 704 /* Default declaration of generated scanner - a define so the user can
 705  * easily add parameters.
 706  */
 707 #ifndef YY_DECL
 708 #define YY_DECL_IS_OURS 1
 709
 710 extern int _lc_opt_lex (void);
 711
 712 #define YY_DECL int _lc_opt_lex (void)
 713 #endif /* !YY_DECL */
 714
 715 /* Code executed at the beginning of each rule, after _lc_opt_text and _lc_opt_leng
 716  * have been set up.
 717  */
 718 #ifndef YY_USER_ACTION
 719 #define YY_USER_ACTION
 720 #endif
 721
 722 /* Code executed at the end of each rule. */
 723 #ifndef YY_BREAK
 724 #define YY_BREAK break;
 725 #endif
 726
 727 #define YY_RULE_SETUP \
 728         YY_USER_ACTION
 729
 730 /** The main scanner function which does all the work.
 731  */
 732 YY_DECL
 733 {
 734         register yy_state_type yy_current_state;
 735         register char *yy_cp, *yy_bp;
 736         register int yy_act;
 737
 738 #line 54 "lc_config_lexer.l"
 739
 740
 741 #line 742 "lc_config_lexer.c"
 742
 743         if ( !(yy_init) )
 744                 {
 745                 (yy_init) = 1;
 746
 747 #ifdef YY_USER_INIT
 748                 YY_USER_INIT;
 749 #endif
 750
 751                 if ( ! (yy_start) )
 752                         (yy_start) = 1; /* first start state */
 753
 754                 if ( ! _lc_opt_in )
 755                         _lc_opt_in = stdin;
 756
 757                 if ( ! _lc_opt_out )
 758                         _lc_opt_out = stdout;
 759
 760                 if ( ! YY_CURRENT_BUFFER ) {
 761                         _lc_opt_ensure_buffer_stack ();
 762                         YY_CURRENT_BUFFER_LVALUE =
 763                                 _lc_opt__create_buffer(_lc_opt_in,YY_BUF_SIZE );
 764                 }
 765
 766                 _lc_opt__load_buffer_state( );
 767                 }
 768
 769         while ( 1 )             /* loops until end-of-file is reached */
 770                 {
 771                 yy_cp = (yy_c_buf_p);
 772
 773                 /* Support of _lc_opt_text. */
 774                 *yy_cp = (yy_hold_char);
 775
 776                 /* yy_bp points to the position in yy_ch_buf of the start of
 777                  * the current run.
 778                  */
 779                 yy_bp = yy_cp;
 780
 781                 yy_current_state = (yy_start);
 782 yy_match:
 783                 do
 784                         {
 785                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 786                         if ( yy_accept[yy_current_state] )
 787                                 {
 788                                 (yy_last_accepting_state) = yy_current_state;
 789                                 (yy_last_accepting_cpos) = yy_cp;
 790                                 }
 791                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 792                                 {
 793                                 yy_current_state = (int) yy_def[yy_current_state];
 794                                 if ( yy_current_state >= 49 )
 795                                         yy_c = yy_meta[(unsigned int) yy_c];
 796                                 }
 797                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 798                         ++yy_cp;
 799                         }
 800                 while ( yy_base[yy_current_state] != 67 );
 801
 802 yy_find_action:
 803                 yy_act = yy_accept[yy_current_state];
 804                 if ( yy_act == 0 )
 805                         { /* have to back up */
 806                         yy_cp = (yy_last_accepting_cpos);
 807                         yy_current_state = (yy_last_accepting_state);
 808                         yy_act = yy_accept[yy_current_state];
 809                         }
 810
 811                 YY_DO_BEFORE_ACTION;
 812
 813 do_action:      /* This label is used only to access EOF actions. */
 814
 815                 switch ( yy_act )
 816         { /* beginning of action switch */
 817                         case 0: /* must back up */
 818                         /* undo the effects of YY_DO_BEFORE_ACTION */
 819                         *yy_cp = (yy_hold_char);
 820                         yy_cp = (yy_last_accepting_cpos);
 821                         yy_current_state = (yy_last_accepting_state);
 822                         goto yy_find_action;
 823
 824 case 1:
 825 YY_RULE_SETUP
 826 #line 56 "lc_config_lexer.l"
 827 { BEGIN(BIG_COMMENT); }
 828         YY_BREAK
 829 case 2:
 830 YY_RULE_SETUP
 831 #line 57 "lc_config_lexer.l"
 832 { BEGIN(INITIAL); }
 833         YY_BREAK
 834 case 3:
 835 /* rule 3 can match eol */
 836 YY_RULE_SETUP
 837 #line 58 "lc_config_lexer.l"
 838 PMANGLE(linenr)++;
 839         YY_BREAK
 840 case 4:
 841 YY_RULE_SETUP
 842 #line 59 "lc_config_lexer.l"
 843 ;
 844         YY_BREAK
 845 case 5:
 846 YY_RULE_SETUP
 847 #line 61 "lc_config_lexer.l"
 848 { BEGIN(LINE_COMMENT); }
 849         YY_BREAK
 850 case 6:
 851 /* rule 6 can match eol */
 852 YY_RULE_SETUP
 853 #line 62 "lc_config_lexer.l"
 854 { BEGIN(INITIAL); PMANGLE(linenr)++; }
 855         YY_BREAK
 856 case 7:
 857 YY_RULE_SETUP
 858 #line 63 "lc_config_lexer.l"
 859 ;
 860         YY_BREAK
 861 case 8:
 862 YY_RULE_SETUP
 863 #line 66 "lc_config_lexer.l"
 864 { BEGIN(DAT); }
 865         YY_BREAK
 866 case 9:
 867 YY_RULE_SETUP
 868 #line 67 "lc_config_lexer.l"
 869 { BEGIN(STR); }
 870         YY_BREAK
 871 case 10:
 872 YY_RULE_SETUP
 873 #line 68 "lc_config_lexer.l"
 874 { BEGIN(DAT_CONT); }
 875         YY_BREAK
 876 case 11:
 877 YY_RULE_SETUP
 878 #line 69 "lc_config_lexer.l"
 879 { _lc_opt_add_to_data_char(PMANGLE(text)[0]); }
 880         YY_BREAK
 881 case 12:
 882 /* rule 12 can match eol */
 883 YY_RULE_SETUP
 884 #line 70 "lc_config_lexer.l"
 885 {
 886                                                 BEGIN(INITIAL);
 887                                                 PMANGLE(linenr)++;
 888                                                 _lc_opt_add_to_data_char('\0');
 889                                                 return DATA;
 890                                         }
 891         YY_BREAK
 892 case 13:
 893 /* rule 13 can match eol */
 894 YY_RULE_SETUP
 895 #line 76 "lc_config_lexer.l"
 896 { BEGIN(DAT); PMANGLE(linenr)++; }
 897         YY_BREAK
 898 case 14:
 899 YY_RULE_SETUP
 900 #line 77 "lc_config_lexer.l"
 901 ;
 902         YY_BREAK
 903 case 15:
 904 YY_RULE_SETUP
 905 #line 80 "lc_config_lexer.l"
 906 {
 907                                                 BEGIN(INITIAL);
 908                                                 _lc_opt_add_to_data_char('\0');
 909                                                 return DATA;
 910                                         }
 911         YY_BREAK
 912 case 16:
 913 YY_RULE_SETUP
 914 #line 86 "lc_config_lexer.l"
 915 _lc_opt_add_to_data_char('\n');
 916         YY_BREAK
 917 case 17:
 918 YY_RULE_SETUP
 919 #line 87 "lc_config_lexer.l"
 920 _lc_opt_add_to_data_char('\r');
 921         YY_BREAK
 922 case 18:
 923 YY_RULE_SETUP
 924 #line 88 "lc_config_lexer.l"
 925 _lc_opt_add_to_data_char('\t');
 926         YY_BREAK
 927 case 19:
 928 YY_RULE_SETUP
 929 #line 89 "lc_config_lexer.l"
 930 _lc_opt_add_to_data_char('\b');
 931         YY_BREAK
 932 case 20:
 933 YY_RULE_SETUP
 934 #line 90 "lc_config_lexer.l"
 935 _lc_opt_add_to_data_char('\f');
 936         YY_BREAK
 937 case 21:
 938 YY_RULE_SETUP
 939 #line 91 "lc_config_lexer.l"
 940 _lc_opt_add_to_data_char(_lc_opt_text[1]);
 941         YY_BREAK
 942 case 22:
 943 /* rule 22 can match eol */
 944 YY_RULE_SETUP
 945 #line 92 "lc_config_lexer.l"
 946 _lc_opt_add_to_data_char(_lc_opt_text[0]);
 947         YY_BREAK
 948 case 23:
 949 YY_RULE_SETUP
 950 #line 94 "lc_config_lexer.l"
 951 {
 952                                                 PMANGLE(lval).text.str = PMANGLE(text);
 953                                                 PMANGLE(lval).text.len = PMANGLE(leng);
 954                                                 return IDENT;
 955                                         }
 956         YY_BREAK
 957 case 24:
 958 YY_RULE_SETUP
 959 #line 99 "lc_config_lexer.l"
 960 { return SEP; }
 961         YY_BREAK
 962 case 25:
 963 YY_RULE_SETUP
 964 #line 101 "lc_config_lexer.l"
 965 ;
 966         YY_BREAK
 967 case 26:
 968 /* rule 26 can match eol */
 969 YY_RULE_SETUP
 970 #line 102 "lc_config_lexer.l"
 971 PMANGLE(linenr)++;
 972         YY_BREAK
 973 case 27:
 974 YY_RULE_SETUP
 975 #line 104 "lc_config_lexer.l"
 976 return _lc_opt_text[0];
 977         YY_BREAK
 978 case 28:
 979 YY_RULE_SETUP
 980 #line 106 "lc_config_lexer.l"
 981 ECHO;
 982         YY_BREAK
 983 #line 984 "lc_config_lexer.c"
 984 case YY_STATE_EOF(INITIAL):
 985 case YY_STATE_EOF(LINE_COMMENT):
 986 case YY_STATE_EOF(BIG_COMMENT):
 987 case YY_STATE_EOF(DAT):
 988 case YY_STATE_EOF(DAT_CONT):
 989 case YY_STATE_EOF(STR):
 990         yyterminate();
 991
 992         case YY_END_OF_BUFFER:
 993                 {
 994                 /* Amount of text matched not including the EOB char. */
 995                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
 996
 997                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
 998                 *yy_cp = (yy_hold_char);
 999                 YY_RESTORE_YY_MORE_OFFSET
1000
1001                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1002                         {
1003                         /* We're scanning a new file or input source.  It's
1004                          * possible that this happened because the user
1005                          * just pointed _lc_opt_in at a new source and called
1006                          * _lc_opt_lex().  If so, then we have to assure
1007                          * consistency between YY_CURRENT_BUFFER and our
1008                          * globals.  Here is the right place to do so, because
1009                          * this is the first action (other than possibly a
1010                          * back-up) that will match for the new input source.
1011                          */
1012                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1013                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = _lc_opt_in;
1014                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1015                         }
1016
1017                 /* Note that here we test for yy_c_buf_p "<=" to the position
1018                  * of the first EOB in the buffer, since yy_c_buf_p will
1019                  * already have been incremented past the NUL character
1020                  * (since all states make transitions on EOB to the
1021                  * end-of-buffer state).  Contrast this with the test
1022                  * in input().
1023                  */
1024                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1025                         { /* This was really a NUL. */
1026                         yy_state_type yy_next_state;
1027
1028                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1029
1030                         yy_current_state = yy_get_previous_state(  );
1031
1032                         /* Okay, we're now positioned to make the NUL
1033                          * transition.  We couldn't have
1034                          * yy_get_previous_state() go ahead and do it
1035                          * for us because it doesn't know how to deal
1036                          * with the possibility of jamming (and we don't
1037                          * want to build jamming into it because then it
1038                          * will run more slowly).
1039                          */
1040
1041                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1042
1043                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1044
1045                         if ( yy_next_state )
1046                                 {
1047                                 /* Consume the NUL. */
1048                                 yy_cp = ++(yy_c_buf_p);
1049                                 yy_current_state = yy_next_state;
1050                                 goto yy_match;
1051                                 }
1052
1053                         else
1054                                 {
1055                                 yy_cp = (yy_c_buf_p);
1056                                 goto yy_find_action;
1057                                 }
1058                         }
1059
1060                 else switch ( yy_get_next_buffer(  ) )
1061                         {
1062                         case EOB_ACT_END_OF_FILE:
1063                                 {
1064                                 (yy_did_buffer_switch_on_eof) = 0;
1065
1066                                 if ( _lc_opt_wrap( ) )
1067                                         {
1068                                         /* Note: because we've taken care in
1069                                          * yy_get_next_buffer() to have set up
1070                                          * _lc_opt_text, we can now set up
1071                                          * yy_c_buf_p so that if some total
1072                                          * hoser (like flex itself) wants to
1073                                          * call the scanner after we return the
1074                                          * YY_NULL, it'll still work - another
1075                                          * YY_NULL will get returned.
1076                                          */
1077                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1078
1079                                         yy_act = YY_STATE_EOF(YY_START);
1080                                         goto do_action;
1081                                         }
1082
1083                                 else
1084                                         {
1085                                         if ( ! (yy_did_buffer_switch_on_eof) )
1086                                                 YY_NEW_FILE;
1087                                         }
1088                                 break;
1089                                 }
1090
1091                         case EOB_ACT_CONTINUE_SCAN:
1092                                 (yy_c_buf_p) =
1093                                         (yytext_ptr) + yy_amount_of_matched_text;
1094
1095                                 yy_current_state = yy_get_previous_state(  );
1096
1097                                 yy_cp = (yy_c_buf_p);
1098                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1099                                 goto yy_match;
1100
1101                         case EOB_ACT_LAST_MATCH:
1102                                 (yy_c_buf_p) =
1103                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1104
1105                                 yy_current_state = yy_get_previous_state(  );
1106
1107                                 yy_cp = (yy_c_buf_p);
1108                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1109                                 goto yy_find_action;
1110                         }
1111                 break;
1112                 }
1113
1114         default:
1115                 YY_FATAL_ERROR(
1116                         "fatal flex scanner internal error--no action found" );
1117         } /* end of action switch */
1118                 } /* end of scanning one token */
1119 } /* end of _lc_opt_lex */
1120
1121 /* yy_get_next_buffer - try to read in a new buffer
1122  *
1123  * Returns a code representing an action:
1124  *      EOB_ACT_LAST_MATCH -
1125  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1126  *      EOB_ACT_END_OF_FILE - end of file
1127  */
1128 static int yy_get_next_buffer (void)
1129 {
1130         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1131         register char *source = (yytext_ptr);
1132         register int number_to_move, i;
1133         int ret_val;
1134
1135         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1136                 YY_FATAL_ERROR(
1137                 "fatal flex scanner internal error--end of buffer missed" );
1138
1139         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1140                 { /* Don't try to fill the buffer, so this is an EOF. */
1141                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1142                         {
1143                         /* We matched a single character, the EOB, so
1144                          * treat this as a final EOF.
1145                          */
1146                         return EOB_ACT_END_OF_FILE;
1147                         }
1148
1149                 else
1150                         {
1151                         /* We matched some text prior to the EOB, first
1152                          * process it.
1153                          */
1154                         return EOB_ACT_LAST_MATCH;
1155                         }
1156                 }
1157
1158         /* Try to read more data. */
1159
1160         /* First move last chars to start of buffer. */
1161         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1162
1163         for ( i = 0; i < number_to_move; ++i )
1164                 *(dest++) = *(source++);
1165
1166         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1167                 /* don't do the read, it's not guaranteed to return an EOF,
1168                  * just force an EOF
1169                  */
1170                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1171
1172         else
1173                 {
1174                         int num_to_read =
1175                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1176
1177                 while ( num_to_read <= 0 )
1178                         { /* Not enough room in the buffer - grow it. */
1179
1180                         /* just a shorter name for the current buffer */
1181                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1182
1183                         int yy_c_buf_p_offset =
1184                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1185
1186                         if ( b->yy_is_our_buffer )
1187                                 {
1188                                 int new_size = b->yy_buf_size * 2;
1189
1190                                 if ( new_size <= 0 )
1191                                         b->yy_buf_size += b->yy_buf_size / 8;
1192                                 else
1193                                         b->yy_buf_size *= 2;
1194
1195                                 b->yy_ch_buf = (char *)
1196                                         /* Include room in for 2 EOB chars. */
1197                                         _lc_opt_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1198                                 }
1199                         else
1200                                 /* Can't grow it, we don't own it. */
1201                                 b->yy_ch_buf = 0;
1202
1203                         if ( ! b->yy_ch_buf )
1204                                 YY_FATAL_ERROR(
1205                                 "fatal error - scanner input buffer overflow" );
1206
1207                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1208
1209                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1210                                                 number_to_move - 1;
1211
1212                         }
1213
1214                 if ( num_to_read > YY_READ_BUF_SIZE )
1215                         num_to_read = YY_READ_BUF_SIZE;
1216
1217                 /* Read in more data. */
1218                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1219                         (yy_n_chars), (size_t) num_to_read );
1220
1221                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1222                 }
1223
1224         if ( (yy_n_chars) == 0 )
1225                 {
1226                 if ( number_to_move == YY_MORE_ADJ )
1227                         {
1228                         ret_val = EOB_ACT_END_OF_FILE;
1229                         _lc_opt_restart(_lc_opt_in  );
1230                         }
1231
1232                 else
1233                         {
1234                         ret_val = EOB_ACT_LAST_MATCH;
1235                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1236                                 YY_BUFFER_EOF_PENDING;
1237                         }
1238                 }
1239
1240         else
1241                 ret_val = EOB_ACT_CONTINUE_SCAN;
1242
1243         if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1244                 /* Extend the array by 50%, plus the number we really need. */
1245                 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1246                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) _lc_opt_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1247                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1248                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1249         }
1250
1251         (yy_n_chars) += number_to_move;
1252         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1253         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1254
1255         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1256
1257         return ret_val;
1258 }
1259
1260 /* yy_get_previous_state - get the state just before the EOB char was reached */
1261
1262     static yy_state_type yy_get_previous_state (void)
1263 {
1264         register yy_state_type yy_current_state;
1265         register char *yy_cp;
1266
1267         yy_current_state = (yy_start);
1268
1269         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1270                 {
1271                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1272                 if ( yy_accept[yy_current_state] )
1273                         {
1274                         (yy_last_accepting_state) = yy_current_state;
1275                         (yy_last_accepting_cpos) = yy_cp;
1276                         }
1277                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1278                         {
1279                         yy_current_state = (int) yy_def[yy_current_state];
1280                         if ( yy_current_state >= 49 )
1281                                 yy_c = yy_meta[(unsigned int) yy_c];
1282                         }
1283                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1284                 }
1285
1286         return yy_current_state;
1287 }
1288
1289 /* yy_try_NUL_trans - try to make a transition on the NUL character
1290  *
1291  * synopsis
1292  *      next_state = yy_try_NUL_trans( current_state );
1293  */
1294     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1295 {
1296         register int yy_is_jam;
1297         register char *yy_cp = (yy_c_buf_p);
1298
1299         register YY_CHAR yy_c = 1;
1300         if ( yy_accept[yy_current_state] )
1301                 {
1302                 (yy_last_accepting_state) = yy_current_state;
1303                 (yy_last_accepting_cpos) = yy_cp;
1304                 }
1305         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1306                 {
1307                 yy_current_state = (int) yy_def[yy_current_state];
1308                 if ( yy_current_state >= 49 )
1309                         yy_c = yy_meta[(unsigned int) yy_c];
1310                 }
1311         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1312         yy_is_jam = (yy_current_state == 48);
1313
1314         return yy_is_jam ? 0 : yy_current_state;
1315 }
1316
1317     static void yyunput (int c, register char * yy_bp )
1318 {
1319         register char *yy_cp;
1320
1321     yy_cp = (yy_c_buf_p);
1322
1323         /* undo effects of setting up _lc_opt_text */
1324         *yy_cp = (yy_hold_char);
1325
1326         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1327                 { /* need to shift things up to make room */
1328                 /* +2 for EOB chars. */
1329                 register int number_to_move = (yy_n_chars) + 2;
1330                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1331                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1332                 register char *source =
1333                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1334
1335                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1336                         *--dest = *--source;
1337
1338                 yy_cp += (int) (dest - source);
1339                 yy_bp += (int) (dest - source);
1340                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1341                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1342
1343                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1344                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1345                 }
1346
1347         *--yy_cp = (char) c;
1348
1349         (yytext_ptr) = yy_bp;
1350         (yy_hold_char) = *yy_cp;
1351         (yy_c_buf_p) = yy_cp;
1352 }
1353
1354 #ifndef YY_NO_INPUT
1355 #ifdef __cplusplus
1356     static int yyinput (void)
1357 #else
1358     static int input  (void)
1359 #endif
1360
1361 {
1362         int c;
1363
1364         *(yy_c_buf_p) = (yy_hold_char);
1365
1366         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1367                 {
1368                 /* yy_c_buf_p now points to the character we want to return.
1369                  * If this occurs *before* the EOB characters, then it's a
1370                  * valid NUL; if not, then we've hit the end of the buffer.
1371                  */
1372                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1373                         /* This was really a NUL. */
1374                         *(yy_c_buf_p) = '\0';
1375
1376                 else
1377                         { /* need more input */
1378                         int offset = (yy_c_buf_p) - (yytext_ptr);
1379                         ++(yy_c_buf_p);
1380
1381                         switch ( yy_get_next_buffer(  ) )
1382                                 {
1383                                 case EOB_ACT_LAST_MATCH:
1384                                         /* This happens because yy_g_n_b()
1385                                          * sees that we've accumulated a
1386                                          * token and flags that we need to
1387                                          * try matching the token before
1388                                          * proceeding.  But for input(),
1389                                          * there's no matching to consider.
1390                                          * So convert the EOB_ACT_LAST_MATCH
1391                                          * to EOB_ACT_END_OF_FILE.
1392                                          */
1393
1394                                         /* Reset buffer status. */
1395                                         _lc_opt_restart(_lc_opt_in );
1396
1397                                         /*FALLTHROUGH*/
1398
1399                                 case EOB_ACT_END_OF_FILE:
1400                                         {
1401                                         if ( _lc_opt_wrap( ) )
1402                                                 return EOF;
1403
1404                                         if ( ! (yy_did_buffer_switch_on_eof) )
1405                                                 YY_NEW_FILE;
1406 #ifdef __cplusplus
1407                                         return yyinput();
1408 #else
1409                                         return input();
1410 #endif
1411                                         }
1412
1413                                 case EOB_ACT_CONTINUE_SCAN:
1414                                         (yy_c_buf_p) = (yytext_ptr) + offset;
1415                                         break;
1416                                 }
1417                         }
1418                 }
1419
1420         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1421         *(yy_c_buf_p) = '\0';   /* preserve _lc_opt_text */
1422         (yy_hold_char) = *++(yy_c_buf_p);
1423
1424         return c;
1425 }
1426 #endif  /* ifndef YY_NO_INPUT */
1427
1428 /** Immediately switch to a different input stream.
1429  * @param input_file A readable stream.
1430  *
1431  * @note This function does not reset the start condition to @c INITIAL .
1432  */
1433     void _lc_opt_restart  (FILE * input_file )
1434 {
1435
1436         if ( ! YY_CURRENT_BUFFER ){
1437         _lc_opt_ensure_buffer_stack ();
1438                 YY_CURRENT_BUFFER_LVALUE =
1439             _lc_opt__create_buffer(_lc_opt_in,YY_BUF_SIZE );
1440         }
1441
1442         _lc_opt__init_buffer(YY_CURRENT_BUFFER,input_file );
1443         _lc_opt__load_buffer_state( );
1444 }
1445
1446 /** Switch to a different input buffer.
1447  * @param new_buffer The new input buffer.
1448  *
1449  */
1450     void _lc_opt__switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1451 {
1452
1453         /* TODO. We should be able to replace this entire function body
1454          * with
1455          *              _lc_opt_pop_buffer_state();
1456          *              _lc_opt_push_buffer_state(new_buffer);
1457      */
1458         _lc_opt_ensure_buffer_stack ();
1459         if ( YY_CURRENT_BUFFER == new_buffer )
1460                 return;
1461
1462         if ( YY_CURRENT_BUFFER )
1463                 {
1464                 /* Flush out information for old buffer. */
1465                 *(yy_c_buf_p) = (yy_hold_char);
1466                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1467                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1468                 }
1469
1470         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1471         _lc_opt__load_buffer_state( );
1472
1473         /* We don't actually know whether we did this switch during
1474          * EOF (_lc_opt_wrap()) processing, but the only time this flag
1475          * is looked at is after _lc_opt_wrap() is called, so it's safe
1476          * to go ahead and always set it.
1477          */
1478         (yy_did_buffer_switch_on_eof) = 1;
1479 }
1480
1481 static void _lc_opt__load_buffer_state  (void)
1482 {
1483         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1484         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1485         _lc_opt_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1486         (yy_hold_char) = *(yy_c_buf_p);
1487 }
1488
1489 /** Allocate and initialize an input buffer state.
1490  * @param file A readable stream.
1491  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1492  *
1493  * @return the allocated buffer state.
1494  */
1495     YY_BUFFER_STATE _lc_opt__create_buffer  (FILE * file, int  size )
1496 {
1497         YY_BUFFER_STATE b;
1498
1499         b = (YY_BUFFER_STATE) _lc_opt_alloc(sizeof( struct yy_buffer_state )  );
1500         if ( ! b )
1501                 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt__create_buffer()" );
1502
1503         b->yy_buf_size = size;
1504
1505         /* yy_ch_buf has to be 2 characters longer than the size given because
1506          * we need to put in 2 end-of-buffer characters.
1507          */
1508         b->yy_ch_buf = (char *) _lc_opt_alloc(b->yy_buf_size + 2  );
1509         if ( ! b->yy_ch_buf )
1510                 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt__create_buffer()" );
1511
1512         b->yy_is_our_buffer = 1;
1513
1514         _lc_opt__init_buffer(b,file );
1515
1516         return b;
1517 }
1518
1519 /** Destroy the buffer.
1520  * @param b a buffer created with _lc_opt__create_buffer()
1521  *
1522  */
1523     void _lc_opt__delete_buffer (YY_BUFFER_STATE  b )
1524 {
1525
1526         if ( ! b )
1527                 return;
1528
1529         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1530                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1531
1532         if ( b->yy_is_our_buffer )
1533                 _lc_opt_free((void *) b->yy_ch_buf  );
1534
1535         _lc_opt_free((void *) b  );
1536 }
1537
1538 #ifndef __cplusplus
1539 extern int isatty (int );
1540 #endif /* __cplusplus */
1541
1542 /* Initializes or reinitializes a buffer.
1543  * This function is sometimes called more than once on the same buffer,
1544  * such as during a _lc_opt_restart() or at EOF.
1545  */
1546     static void _lc_opt__init_buffer  (YY_BUFFER_STATE  b, FILE * file )
1547
1548 {
1549         int oerrno = errno;
1550
1551         _lc_opt__flush_buffer(b );
1552
1553         b->yy_input_file = file;
1554         b->yy_fill_buffer = 1;
1555
1556     /* If b is the current buffer, then _lc_opt__init_buffer was _probably_
1557      * called from _lc_opt_restart() or through yy_get_next_buffer.
1558      * In that case, we don't want to reset the lineno or column.
1559      */
1560     if (b != YY_CURRENT_BUFFER){
1561         b->yy_bs_lineno = 1;
1562         b->yy_bs_column = 0;
1563     }
1564
1565         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1566
1567         errno = oerrno;
1568 }
1569
1570 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1571  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1572  *
1573  */
1574     void _lc_opt__flush_buffer (YY_BUFFER_STATE  b )
1575 {
1576         if ( ! b )
1577                 return;
1578
1579         b->yy_n_chars = 0;
1580
1581         /* We always need two end-of-buffer characters.  The first causes
1582          * a transition to the end-of-buffer state.  The second causes
1583          * a jam in that state.
1584          */
1585         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1586         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1587
1588         b->yy_buf_pos = &b->yy_ch_buf[0];
1589
1590         b->yy_at_bol = 1;
1591         b->yy_buffer_status = YY_BUFFER_NEW;
1592
1593         if ( b == YY_CURRENT_BUFFER )
1594                 _lc_opt__load_buffer_state( );
1595 }
1596
1597 /** Pushes the new state onto the stack. The new state becomes
1598  *  the current state. This function will allocate the stack
1599  *  if necessary.
1600  *  @param new_buffer The new state.
1601  *
1602  */
1603 void _lc_opt_push_buffer_state (YY_BUFFER_STATE new_buffer )
1604 {
1605         if (new_buffer == NULL)
1606                 return;
1607
1608         _lc_opt_ensure_buffer_stack();
1609
1610         /* This block is copied from _lc_opt__switch_to_buffer. */
1611         if ( YY_CURRENT_BUFFER )
1612                 {
1613                 /* Flush out information for old buffer. */
1614                 *(yy_c_buf_p) = (yy_hold_char);
1615                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1616                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1617                 }
1618
1619         /* Only push if top exists. Otherwise, replace top. */
1620         if (YY_CURRENT_BUFFER)
1621                 (yy_buffer_stack_top)++;
1622         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1623
1624         /* copied from _lc_opt__switch_to_buffer. */
1625         _lc_opt__load_buffer_state( );
1626         (yy_did_buffer_switch_on_eof) = 1;
1627 }
1628
1629 /** Removes and deletes the top of the stack, if present.
1630  *  The next element becomes the new top.
1631  *
1632  */
1633 void _lc_opt_pop_buffer_state (void)
1634 {
1635         if (!YY_CURRENT_BUFFER)
1636                 return;
1637
1638         _lc_opt__delete_buffer(YY_CURRENT_BUFFER );
1639         YY_CURRENT_BUFFER_LVALUE = NULL;
1640         if ((yy_buffer_stack_top) > 0)
1641                 --(yy_buffer_stack_top);
1642
1643         if (YY_CURRENT_BUFFER) {
1644                 _lc_opt__load_buffer_state( );
1645                 (yy_did_buffer_switch_on_eof) = 1;
1646         }
1647 }
1648
1649 /* Allocates the stack if it does not exist.
1650  *  Guarantees space for at least one push.
1651  */
1652 static void _lc_opt_ensure_buffer_stack (void)
1653 {
1654         int num_to_alloc;
1655
1656         if (!(yy_buffer_stack)) {
1657
1658                 /* First allocation is just for 2 elements, since we don't know if this
1659                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1660                  * immediate realloc on the next call.
1661          */
1662                 num_to_alloc = 1;
1663                 (yy_buffer_stack) = (struct yy_buffer_state**)_lc_opt_alloc
1664                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
1665                                                                 );
1666                 if ( ! (yy_buffer_stack) )
1667                         YY_FATAL_ERROR( "out of dynamic memory in _lc_opt_ensure_buffer_stack()" );
1668
1669                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1670
1671                 (yy_buffer_stack_max) = num_to_alloc;
1672                 (yy_buffer_stack_top) = 0;
1673                 return;
1674         }
1675
1676         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1677
1678                 /* Increase the buffer to prepare for a possible push. */
1679                 int grow_size = 8 /* arbitrary grow size */;
1680
1681                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1682                 (yy_buffer_stack) = (struct yy_buffer_state**)_lc_opt_realloc
1683                                                                 ((yy_buffer_stack),
1684                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
1685                                                                 );
1686                 if ( ! (yy_buffer_stack) )
1687                         YY_FATAL_ERROR( "out of dynamic memory in _lc_opt_ensure_buffer_stack()" );
1688
1689                 /* zero only the new slots.*/
1690                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1691                 (yy_buffer_stack_max) = num_to_alloc;
1692         }
1693 }
1694
1695 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1696  * @param base the character buffer
1697  * @param size the size in bytes of the character buffer
1698  *
1699  * @return the newly allocated buffer state object.
1700  */
1701 YY_BUFFER_STATE _lc_opt__scan_buffer  (char * base, yy_size_t  size )
1702 {
1703         YY_BUFFER_STATE b;
1704
1705         if ( size < 2 ||
1706              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1707              base[size-1] != YY_END_OF_BUFFER_CHAR )
1708                 /* They forgot to leave room for the EOB's. */
1709                 return 0;
1710
1711         b = (YY_BUFFER_STATE) _lc_opt_alloc(sizeof( struct yy_buffer_state )  );
1712         if ( ! b )
1713                 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt__scan_buffer()" );
1714
1715         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1716         b->yy_buf_pos = b->yy_ch_buf = base;
1717         b->yy_is_our_buffer = 0;
1718         b->yy_input_file = 0;
1719         b->yy_n_chars = b->yy_buf_size;
1720         b->yy_is_interactive = 0;
1721         b->yy_at_bol = 1;
1722         b->yy_fill_buffer = 0;
1723         b->yy_buffer_status = YY_BUFFER_NEW;
1724
1725         _lc_opt__switch_to_buffer(b  );
1726
1727         return b;
1728 }
1729
1730 /** Setup the input buffer state to scan a string. The next call to _lc_opt_lex() will
1731  * scan from a @e copy of @a str.
1732  * @param yystr a NUL-terminated string to scan
1733  *
1734  * @return the newly allocated buffer state object.
1735  * @note If you want to scan bytes that may contain NUL values, then use
1736  *       _lc_opt__scan_bytes() instead.
1737  */
1738 YY_BUFFER_STATE _lc_opt__scan_string (yyconst char * yystr )
1739 {
1740
1741         return _lc_opt__scan_bytes(yystr,strlen(yystr) );
1742 }
1743
1744 /** Setup the input buffer state to scan the given bytes. The next call to _lc_opt_lex() will
1745  * scan from a @e copy of @a bytes.
1746  * @param yybytes the byte buffer to scan
1747  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1748  *
1749  * @return the newly allocated buffer state object.
1750  */
1751 YY_BUFFER_STATE _lc_opt__scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
1752 {
1753         YY_BUFFER_STATE b;
1754         char *buf;
1755         yy_size_t n;
1756         int i;
1757
1758         /* Get memory for full buffer, including space for trailing EOB's. */
1759         n = _yybytes_len + 2;
1760         buf = (char *) _lc_opt_alloc(n  );
1761         if ( ! buf )
1762                 YY_FATAL_ERROR( "out of dynamic memory in _lc_opt__scan_bytes()" );
1763
1764         for ( i = 0; i < _yybytes_len; ++i )
1765                 buf[i] = yybytes[i];
1766
1767         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1768
1769         b = _lc_opt__scan_buffer(buf,n );
1770         if ( ! b )
1771                 YY_FATAL_ERROR( "bad buffer in _lc_opt__scan_bytes()" );
1772
1773         /* It's okay to grow etc. this buffer, and we should throw it
1774          * away when we're done.
1775          */
1776         b->yy_is_our_buffer = 1;
1777
1778         return b;
1779 }
1780
1781 #ifndef YY_EXIT_FAILURE
1782 #define YY_EXIT_FAILURE 2
1783 #endif
1784
1785 static void yy_fatal_error (yyconst char* msg )
1786 {
1787         (void) fprintf( stderr, "%s\n", msg );
1788         exit( YY_EXIT_FAILURE );
1789 }
1790
1791 /* Redefine yyless() so it works in section 3 code. */
1792
1793 #undef yyless
1794 #define yyless(n) \
1795         do \
1796                 { \
1797                 /* Undo effects of setting up _lc_opt_text. */ \
1798         int yyless_macro_arg = (n); \
1799         YY_LESS_LINENO(yyless_macro_arg);\
1800                 _lc_opt_text[_lc_opt_leng] = (yy_hold_char); \
1801                 (yy_c_buf_p) = _lc_opt_text + yyless_macro_arg; \
1802                 (yy_hold_char) = *(yy_c_buf_p); \
1803                 *(yy_c_buf_p) = '\0'; \
1804                 _lc_opt_leng = yyless_macro_arg; \
1805                 } \
1806         while ( 0 )
1807
1808 /* Accessor  methods (get/set functions) to struct members. */
1809
1810 /** Get the current line number.
1811  *
1812  */
1813 int _lc_opt_get_lineno  (void)
1814 {
1815
1816     return _lc_opt_lineno;
1817 }
1818
1819 /** Get the input stream.
1820  *
1821  */
1822 FILE *_lc_opt_get_in  (void)
1823 {
1824         return _lc_opt_in;
1825 }
1826
1827 /** Get the output stream.
1828  *
1829  */
1830 FILE *_lc_opt_get_out  (void)
1831 {
1832         return _lc_opt_out;
1833 }
1834
1835 /** Get the length of the current token.
1836  *
1837  */
1838 int _lc_opt_get_leng  (void)
1839 {
1840         return _lc_opt_leng;
1841 }
1842
1843 /** Get the current token.
1844  *
1845  */
1846
1847 char *_lc_opt_get_text  (void)
1848 {
1849         return _lc_opt_text;
1850 }
1851
1852 /** Set the current line number.
1853  * @param line_number
1854  *
1855  */
1856 void _lc_opt_set_lineno (int  line_number )
1857 {
1858
1859     _lc_opt_lineno = line_number;
1860 }
1861
1862 /** Set the input stream. This does not discard the current
1863  * input buffer.
1864  * @param in_str A readable stream.
1865  *
1866  * @see _lc_opt__switch_to_buffer
1867  */
1868 void _lc_opt_set_in (FILE *  in_str )
1869 {
1870         _lc_opt_in = in_str ;
1871 }
1872
1873 void _lc_opt_set_out (FILE *  out_str )
1874 {
1875         _lc_opt_out = out_str ;
1876 }
1877
1878 int _lc_opt_get_debug  (void)
1879 {
1880         return _lc_opt__flex_debug;
1881 }
1882
1883 void _lc_opt_set_debug (int  bdebug )
1884 {
1885         _lc_opt__flex_debug = bdebug ;
1886 }
1887
1888 static int yy_init_globals (void)
1889 {
1890         /* Initialization is the same as for the non-reentrant scanner.
1891      * This function is called from _lc_opt_lex_destroy(), so don't allocate here.
1892      */
1893
1894     (yy_buffer_stack) = 0;
1895     (yy_buffer_stack_top) = 0;
1896     (yy_buffer_stack_max) = 0;
1897     (yy_c_buf_p) = (char *) 0;
1898     (yy_init) = 0;
1899     (yy_start) = 0;
1900
1901 /* Defined in main.c */
1902 #ifdef YY_STDINIT
1903     _lc_opt_in = stdin;
1904     _lc_opt_out = stdout;
1905 #else
1906     _lc_opt_in = (FILE *) 0;
1907     _lc_opt_out = (FILE *) 0;
1908 #endif
1909
1910     /* For future reference: Set errno on error, since we are called by
1911      * _lc_opt_lex_init()
1912      */
1913     return 0;
1914 }
1915
1916 /* _lc_opt_lex_destroy is for both reentrant and non-reentrant scanners. */
1917 int _lc_opt_lex_destroy  (void)
1918 {
1919
1920     /* Pop the buffer stack, destroying each element. */
1921         while(YY_CURRENT_BUFFER){
1922                 _lc_opt__delete_buffer(YY_CURRENT_BUFFER  );
1923                 YY_CURRENT_BUFFER_LVALUE = NULL;
1924                 _lc_opt_pop_buffer_state();
1925         }
1926
1927         /* Destroy the stack itself. */
1928         _lc_opt_free((yy_buffer_stack) );
1929         (yy_buffer_stack) = NULL;
1930
1931     /* Reset the globals. This is important in a non-reentrant scanner so the next time
1932      * _lc_opt_lex() is called, initialization will occur. */
1933     yy_init_globals( );
1934
1935     return 0;
1936 }
1937
1938 /*
1939  * Internal utility routines.
1940  */
1941
1942 #ifndef yytext_ptr
1943 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1944 {
1945         register int i;
1946         for ( i = 0; i < n; ++i )
1947                 s1[i] = s2[i];
1948 }
1949 #endif
1950
1951 #ifdef YY_NEED_STRLEN
1952 static int yy_flex_strlen (yyconst char * s )
1953 {
1954         register int n;
1955         for ( n = 0; s[n]; ++n )
1956                 ;
1957
1958         return n;
1959 }
1960 #endif
1961
1962 void *_lc_opt_alloc (yy_size_t  size )
1963 {
1964         return (void *) malloc( size );
1965 }
1966
1967 void *_lc_opt_realloc  (void * ptr, yy_size_t  size )
1968 {
1969         /* The cast to (char *) in the following accommodates both
1970          * implementations that use char* generic pointers, and those
1971          * that use void* generic pointers.  It works with the latter
1972          * because both ANSI C and C++ allow castless assignment from
1973          * any pointer type to void*, and deal with argument conversions
1974          * as though doing an assignment.
1975          */
1976         return (void *) realloc( (char *) ptr, size );
1977 }
1978
1979 void _lc_opt_free (void * ptr )
1980 {
1981         free( (char *) ptr );   /* see _lc_opt_realloc() for (char *) cast */
1982 }
1983
1984 #define YYTABLES_NAME "yytables"
1985
1986 #line 106 "lc_config_lexer.l"
1987
1988
1989
1990 static int _lc_opt_wrap(void)
1991 {
1992         /* avoid warning */
1993         (void) yyunput;
1994         (void) input;
1995         return 1;
1996 }