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