"Fossies" - the Fresh Open Source Software Archive

Member "detox-1.4.5/src/config_file_lex.c" (15 Aug 2021, 50736 Bytes) of package /linux/privat/detox-1.4.5.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "config_file_lex.c" see the Fossies "Dox" file reference documentation.

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