lexer.c

   1
   2 #line 3 "<stdout>"
   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 1
  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 #endif /* ! C99 */
  87
  88 #endif /* ! FLEXINT_H */
  89
  90 /* TODO: this is always defined, so inline it */
  91 #define yyconst const
  92
  93 #if defined(__GNUC__) && __GNUC__ >= 3
  94 #define yynoreturn __attribute__((__noreturn__))
  95 #else
  96 #define yynoreturn
  97 #endif
  98
  99 /* Returned upon end-of-file. */
 100 #define YY_NULL 0
 101
 102 /* Promotes a possibly negative, possibly signed char to an unsigned
 103  * integer for use as an array index.  If the signed char is negative,
 104  * we want to instead treat it as an 8-bit unsigned char, hence the
 105  * double cast.
 106  */
 107 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 108
 109 /* Enter a start condition.  This macro really ought to take a parameter,
 110  * but we do it the disgusting crufty way forced on us by the ()-less
 111  * definition of BEGIN.
 112  */
 113 #define BEGIN (yy_start) = 1 + 2 *
 114
 115 /* Translate the current start state into a value that can be later handed
 116  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 117  * compatibility.
 118  */
 119 #define YY_START (((yy_start) - 1) / 2)
 120 #define YYSTATE YY_START
 121
 122 /* Action number for EOF rule of a given start state. */
 123 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 124
 125 /* Special action meaning "start processing a new file". */
 126 #define YY_NEW_FILE yyrestart(yyin  )
 127
 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
 182 #define unput(c) yyunput( c, (yytext_ptr)  )
 183
 184 #ifndef YY_STRUCT_YY_BUFFER_STATE
 185 #define YY_STRUCT_YY_BUFFER_STATE
 186 struct yy_buffer_state
 187         {
 188         FILE *yy_input_file;
 189
 190         char *yy_ch_buf;                /* input buffer */
 191         char *yy_buf_pos;               /* current position in input buffer */
 192
 193         /* Size of input buffer in bytes, not including room for EOB
 194          * characters.
 195          */
 196         int yy_buf_size;
 197
 198         /* Number of characters read into yy_ch_buf, not including EOB
 199          * characters.
 200          */
 201         int yy_n_chars;
 202
 203         /* Whether we "own" the buffer - i.e., we know we created it,
 204          * and can realloc() it to grow it, and should free() it to
 205          * delete it.
 206          */
 207         int yy_is_our_buffer;
 208
 209         /* Whether this is an "interactive" input source; if so, and
 210          * if we're using stdio for input, then we want to use getc()
 211          * instead of fread(), to make sure we stop fetching input after
 212          * each newline.
 213          */
 214         int yy_is_interactive;
 215
 216         /* Whether we're considered to be at the beginning of a line.
 217          * If so, '^' rules will be active on the next match, otherwise
 218          * not.
 219          */
 220         int yy_at_bol;
 221
 222     int yy_bs_lineno; /**< The line count. */
 223     int yy_bs_column; /**< The column count. */
 224
 225         /* Whether to try to fill the input buffer when we reach the
 226          * end of it.
 227          */
 228         int yy_fill_buffer;
 229
 230         int yy_buffer_status;
 231
 232 #define YY_BUFFER_NEW 0
 233 #define YY_BUFFER_NORMAL 1
 234         /* When an EOF's been seen but there's still some text to process
 235          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 236          * shouldn't try reading from the input source any more.  We might
 237          * still have a bunch of tokens to match, though, because of
 238          * possible backing-up.
 239          *
 240          * When we actually see the EOF, we change the status to "new"
 241          * (via yyrestart()), so that the user can continue scanning by
 242          * just pointing yyin at a new input file.
 243          */
 244 #define YY_BUFFER_EOF_PENDING 2
 245
 246         };
 247 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 248
 249 /* Stack of input buffers. */
 250 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 251 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 252 static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
 253
 254 /* We provide macros for accessing buffer states in case in the
 255  * future we want to put the buffer states in a more general
 256  * "scanner state".
 257  *
 258  * Returns the top of the stack, or NULL.
 259  */
 260 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
 261                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
 262                           : NULL)
 263
 264 /* Same as previous macro, but useful when we know that the buffer stack is not
 265  * NULL or when we need an lvalue. For internal use only.
 266  */
 267 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 268
 269 /* yy_hold_char holds the character lost when yytext is formed. */
 270 static char yy_hold_char;
 271 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 272 int yyleng;
 273
 274 /* Points to current character in buffer. */
 275 static char *yy_c_buf_p = NULL;
 276 static int yy_init = 0;         /* whether we need to initialize */
 277 static int yy_start = 0;        /* start state number */
 278
 279 /* Flag which is used to allow yywrap()'s to do buffer switches
 280  * instead of setting up a fresh yyin.  A bit of a hack ...
 281  */
 282 static int yy_did_buffer_switch_on_eof;
 283
 284 void yyrestart (FILE *input_file  );
 285 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 286 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
 287 void yy_delete_buffer (YY_BUFFER_STATE b  );
 288 void yy_flush_buffer (YY_BUFFER_STATE b  );
 289 void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
 290 void yypop_buffer_state (void );
 291
 292 static void yyensure_buffer_stack (void );
 293 static void yy_load_buffer_state (void );
 294 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 295
 296 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
 297
 298 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
 299 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
 300 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
 301
 302 void *yyalloc (yy_size_t  );
 303 void *yyrealloc (void *,yy_size_t  );
 304 void yyfree (void *  );
 305
 306 #define yy_new_buffer yy_create_buffer
 307
 308 #define yy_set_interactive(is_interactive) \
 309         { \
 310         if ( ! YY_CURRENT_BUFFER ){ \
 311         yyensure_buffer_stack (); \
 312                 YY_CURRENT_BUFFER_LVALUE =    \
 313             yy_create_buffer(yyin,YY_BUF_SIZE ); \
 314         } \
 315         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 316         }
 317
 318 #define yy_set_bol(at_bol) \
 319         { \
 320         if ( ! YY_CURRENT_BUFFER ){\
 321         yyensure_buffer_stack (); \
 322                 YY_CURRENT_BUFFER_LVALUE =    \
 323             yy_create_buffer(yyin,YY_BUF_SIZE ); \
 324         } \
 325         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 326         }
 327
 328 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 329
 330 /* Begin user sect3 */
 331
 332 #define yywrap() (/*CONSTCOND*/1)
 333 #define YY_SKIP_YYWRAP
 334
 335 typedef unsigned char YY_CHAR;
 336
 337 FILE *yyin = NULL, *yyout = NULL;
 338
 339 typedef int yy_state_type;
 340
 341 extern int yylineno;
 342
 343 int yylineno = 1;
 344
 345 extern char *yytext;
 346 #ifdef yytext_ptr
 347 #undef yytext_ptr
 348 #endif
 349 #define yytext_ptr yytext
 350
 351 static yy_state_type yy_get_previous_state (void );
 352 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 353 static int yy_get_next_buffer (void );
 354 static void yynoreturn yy_fatal_error (yyconst char* msg  );
 355
 356 /* Done after the current pattern has been matched and before the
 357  * corresponding action - sets up yytext.
 358  */
 359 #define YY_DO_BEFORE_ACTION \
 360         (yytext_ptr) = yy_bp; \
 361         yyleng = (int) (yy_cp - yy_bp); \
 362         (yy_hold_char) = *yy_cp; \
 363         *yy_cp = '\0'; \
 364         (yy_c_buf_p) = yy_cp;
 365
 366 #define YY_NUM_RULES 110
 367 #define YY_END_OF_BUFFER 111
 368 /* This struct is not used in this scanner,
 369    but its presence is necessary. */
 370 struct yy_trans_info
 371         {
 372         flex_int32_t yy_verify;
 373         flex_int32_t yy_nxt;
 374         };
 375 static yyconst flex_int16_t yy_accept[575] =
 376     {   0,
 377         0,    0,  111,  106,  101,  102,   93,  107,  104,   87,
 378        94,   91,   92,   97,  108,  106,  106,  106,  106,  106,
 379       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
 380       106,  106,  106,  106,  106,  106,  106,   95,  106,  101,
 381       102,  104,    0,    0,  105,    0,  104,  104,  103,   99,
 382        97,    0,  100,  106,  106,  106,  106,   19,  106,  106,
 383       106,  106,  106,  106,  106,  106,  106,  106,   37,  106,
 384       106,  106,  106,   32,  106,  106,  106,  106,  106,  106,
 385       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
 386       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
 387
 388       106,    0,    0,    0,   98,   97,  100,  106,  106,  106,
 389       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
 390       106,  106,   31,   63,  106,  106,  106,  106,  106,  106,
 391       106,  106,  106,  106,   71,  106,  106,  106,  106,  106,
 392       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
 393       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
 394       106,  106,  106,  106,    0,    0,   98,   97,  106,  106,
 395       106,   67,  106,  106,   64,   68,  106,  106,  106,   35,
 396        36,  106,  106,  106,  106,   40,   42,  106,   51,  106,
 397       106,   60,   70,  106,   72,  106,   73,  106,  106,  106,
 398
 399       106,  106,  106,  106,   30,  106,   85,  106,  106,  106,
 400       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
 401       106,   75,   76,  106,   62,  106,    0,   98,   97,  106,
 402        65,  106,  106,  106,  106,  106,   59,  106,   66,  106,
 403        96,  106,   38,  106,  106,  106,  106,  106,  106,  106,
 404       106,  106,  106,  106,  106,   41,  106,  106,   49,  106,
 405       106,  106,  106,  106,  106,   88,  106,  106,  106,  106,
 406       106,  106,  106,   86,   98,   97,  106,  106,  106,  106,
 407       106,   69,  106,  106,  106,  106,  106,  106,   70,   77,
 408        78,   79,   80,   81,   82,   83,   84,  106,  106,  106,
 409
 410       106,   61,  106,  106,  106,    1,  106,  106,  106,  106,
 411       106,   39,   90,   89,  106,   74,  106,  106,  106,  106,
 412        98,   97,  106,  106,  106,  106,  106,  106,  106,  106,
 413        50,  106,   21,   26,  106,  106,  106,   10,  106,  106,
 414       106,  106,  106,   52,  106,  106,  106,  106,  106,   45,
 415        62,   98,   97,  106,    9,   67,  106,  106,  106,  106,
 416       106,  106,  106,  106,  106,  106,  106,  106,   47,  106,
 417       106,  106,  106,  106,   48,  106,   46,  106,   98,  106,
 418       106,  106,  106,  106,  106,  106,  106,  106,  106,   12,
 419       106,  106,  106,  106,  106,  106,   44,   11,  106,  106,
 420
 421       106,  106,  106,  106,   98,  106,  106,  106,  106,  106,
 422        33,  106,  106,  106,  106,  106,  106,  106,  106,  106,
 423       106,  106,  106,    8,  106,  106,  106,  106,  106,  106,
 424       106,  106,  106,  106,  106,   43,   34,  106,  106,  106,
 425       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
 426       106,   20,  106,  106,  106,  106,   53,  106,  106,  106,
 427       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
 428        56,  106,  106,  106,  106,  106,   54,  106,  106,  106,
 429       106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
 430        57,  106,  106,   15,  106,  106,  106,  106,   17,    7,
 431
 432       106,  106,  106,  106,  106,  106,  106,   23,  106,  106,
 433       106,  106,  106,  106,  106,  106,  106,  106,  106,    4,
 434       106,  106,  106,   22,  106,  106,  106,  106,  106,   13,
 435       106,  106,  106,  106,    5,    6,  106,  106,  106,  106,
 436       106,  106,   16,  106,  106,  106,  106,  106,  106,    3,
 437        25,  106,   18,  106,  106,  106,   27,  106,   55,  106,
 438        24,   14,   58,  106,  106,  106,  106,   28,  106,  106,
 439       106,   29,    2,    0
 440     } ;
 441
 442 static yyconst YY_CHAR yy_ec[256] =
 443     {   0,
 444         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 445         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 446         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 447         1,    2,    4,    5,    6,    7,    8,    9,    8,   10,
 448        11,    8,    8,    8,   12,    8,    8,   13,   14,   15,
 449        16,   17,   18,   19,   20,   21,   21,    8,    8,    8,
 450         8,    8,    8,    8,   22,   22,   22,   22,   22,   22,
 451         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 452         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 453         8,   23,    8,    8,   24,    8,   25,   26,   27,   28,
 454
 455        29,   30,   31,   32,   33,   34,   35,   36,   37,   38,
 456        39,   40,   41,   42,   43,   44,   45,   46,   47,   48,
 457        49,   50,    8,   51,    8,    8,    1,    1,    1,    1,
 458         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 459         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 460         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 461         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 462         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 463         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 464         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 465
 466         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 467         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 468         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 469         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 470         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 471         1,    1,    1,    1,    1
 472     } ;
 473
 474 static yyconst YY_CHAR yy_meta[52] =
 475     {   0,
 476         1,    2,    3,    1,    2,    1,    1,    1,    1,    1,
 477         1,    1,    4,    4,    4,    4,    4,    4,    4,    4,
 478         4,    1,    2,    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
 482     } ;
 483
 484 static yyconst flex_uint16_t yy_base[581] =
 485     {   0,
 486         0,    0,  789,    0,   50,  790,    0,   49,   55,    0,
 487         0,    0,    0,   67,   59,  755,   19,   49,   34,   56,
 488       754,   29,   39,   59,  757,   30,   71,   70,  739,  759,
 489       738,   76,   74,  743,   65,  752,   82,    0,    0,  111,
 490       790,  777,   73,   97,  790,  134,  123,  776,  790,  170,
 491       179,  109,  119,  740,   93,  733,   94,    0,   94,  747,
 492       749,  731,   98,  744,  726,  741,  728,  740,    0,  729,
 493       738,  722,  729,    0,  726,  113,  721,  735,  719,  727,
 494       716,  711,  120,  721,  727,  119,  722,  716,  133,  118,
 495       708,  713,  723,  710,  706,  708,  718,  719,  703,  702,
 496
 497       710,  163,    0,  196,  214,  223,  157,  715,  699,  701,
 498       707,  702,  710,  692,  697,  697,  688,  705,  701,  701,
 499       687,  695,    0,  688,  699,  699,  684,  698,  682,  682,
 500       684,  680,  680,  692,    0,  680,  672,  671,  135,  680,
 501       676,  669,  677,  684,  664,  676,  678,  676,  659,  674,
 502       657,  655,  688,  655,  656,  140,  657,  660,  659,  652,
 503       653,  649,  653,  646,    0,  232,  250,  259,  653,  644,
 504       640,  646,  652,  652,    0,    0,  644,  651,  642,    0,
 505         0,  649,  637,  636,  632,    0,    0,  649,    0,  633,
 506       629,    0,  644,  636,    0,  646,    0,  637,  175,  642,
 507
 508       656,  625,  639,  628,    0,  635,    0,  636,  629,  617,
 509       618,  626,  629,  629,  614,  613,  616,  608,  610,  612,
 510       621,  637,    0,  615,  614,  617,  276,  287,  296,  600,
 511         0,  632,  601,  604,  629,  602,    0,  601,    0,  599,
 512       594,  592,    0,  606,  606,  597,  305,  601,  588,  586,
 513       589,  599,  597,  593,  596,    0,  580,  581,    0,  589,
 514       594,  582,  580,  589,  575,    0,  572,  586,  583,  567,
 515       570,  572,  572,    0,  313,  322,  581,  578,  574,  575,
 516       564,    0,  566,  565,  590,  572,  588,  570,    0,    0,
 517         0,    0,    0,    0,    0,    0,    0,  569,  570,  584,
 518
 519       555,    0,  566,  565,  548,  579,  561,  545,  559,  541,
 520       539,    0,    0,    0,  542,    0,  555,  556,  544,  550,
 521       331,  340,  551,  551,  532,  565,  531,  546,  537,  128,
 522       561,  542,  559,    0,  531,  540,  526,    0,  538,  537,
 523       535,  552,  514,  550,  528,  522,  516,  522,  527,    0,
 524         0,  349,  544,  543,    0,    0,  251,  521,  526,  523,
 525       506,  511,  145,  521,  255,  510,  509,  517,    0,  503,
 526       516,  513,  253,  500,    0,  529,    0,  507,  358,  353,
 527       497,  495,  493,  492,  497,  491,  521,  487,  489,    0,
 528       497,  499,  489,  489,  480,  482,    0,    0,  496,  481,
 529
 530       479,  482,  495,  483,    0,  482,  468,  473,  476,  485,
 531         0,  501,  468,  479,  351,  477,  470,  466,  478,  467,
 532       476,  471,  460,    0,  463,  472,  462,  457,  469,  464,
 533       453,  466,  449,  451,  460,    0,    0,  458,   95,  454,
 534       452,  459,  439,  451,  458,  442,  471,  437,  439,  443,
 535       448,    0,  449,  450,  434,  435,  462,  428,  436,  443,
 536       427,  425,  456,  440,  433,  420,  420,  424,  437,  421,
 537       448,  430,  415,  419,  417,  443,    0,  411,  413,  423,
 538       422,  414,  416,  257,  404,  404,  406,  433,  406,  401,
 539         0,  399,  403,    0,  396,  401,  396,  405,    0,    0,
 540
 541       394,  396,  396,  400,  407,  392,  386,  417,  396,  390,
 542       395,  393,  380,  411,  392,  394,  391,  377,  387,    0,
 543       375,  372,  373,    0,  380,  356,  371,  354,  366,    0,
 544       366,  359,  361,  354,    0,    0,  360,  356,  338,  350,
 545       345,  346,    0,  347,  343,  264,  261,  257,  265,    0,
 546         0,  254,    0,  245,  251,  248,    0,  220,    0,  211,
 547         0,    0,    0,  178,  178,  167,  172,    0,  161,  171,
 548       132,    0,    0,  790,  398,  402,  406,  410,  173,  166
 549     } ;
 550
 551 static yyconst flex_int16_t yy_def[581] =
 552     {   0,
 553       574,    1,  574,  575,  574,  574,  575,  576,  577,  575,
 554       575,  575,  575,  575,  574,  575,  575,  575,  575,  575,
 555       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 556       575,  575,  575,  575,  575,  575,  575,  575,  575,  574,
 557       574,  578,  574,  576,  574,  576,  577,  578,  574,  575,
 558        14,  574,  574,  575,  575,  575,  575,  575,  575,  575,
 559       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 560       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 561       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 562       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 563
 564       575,  574,  579,  576,  575,   14,  574,  575,  575,  575,
 565       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 566       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 567       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 568       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 569       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 570       575,  575,  575,  575,  580,  104,  575,   14,  575,  575,
 571       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 572       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 573       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 574
 575       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 576       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 577       575,  575,  575,  575,  575,  575,  576,  575,   14,  575,
 578       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 579       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 580       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 581       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 582       575,  575,  575,  575,  575,   14,  575,  575,  575,  575,
 583       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 584       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 585
 586       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 587       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 588       575,   14,  575,  575,  575,  575,  575,  575,  575,  575,
 589       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 590       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 591       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 592       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 593       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 594       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 595       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 596
 597       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 598       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 599       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 600       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 601       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 602       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 603       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 604       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 605       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 606       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 607
 608       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 609       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 610       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 611       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 612       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 613       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 614       575,  575,  575,  575,  575,  575,  575,  575,  575,  575,
 615       575,  575,  575,    0,  574,  574,  574,  574,  574,  574
 616     } ;
 617
 618 static yyconst flex_uint16_t yy_nxt[842] =
 619     {   0,
 620         4,    5,    6,    7,    8,    9,   10,    4,   11,   12,
 621        13,    4,   14,   14,   14,   14,   14,   14,   14,   14,
 622        14,    4,   15,   16,   17,    4,   18,   19,   20,   21,
 623        22,   23,   24,    4,   25,   26,   27,   28,   29,   30,
 624        31,   32,   33,   34,   35,   36,   37,    4,    4,    4,
 625        38,   40,   41,   45,   55,   42,   48,   49,   60,   48,
 626        52,   53,   61,   56,   70,   72,   62,   73,   78,   79,
 627        71,   46,   43,   57,   52,   53,   58,   48,   50,   51,
 628        51,   51,   51,   51,   51,   51,   51,   51,   74,   75,
 629        59,   63,   64,   65,   66,   80,   76,   67,   82,   81,
 630
 631        88,   45,   90,   68,   89,   91,  100,   97,   83,   98,
 632        52,   53,   40,   41,   84,   92,   42,   93,   94,   46,
 633       107,  109,   95,  101,   48,   49,  114,   48,  110,  112,
 634       119,  139,  115,   43,  574,  102,   44,  113,  460,  131,
 635       120,   43,  132,  461,  151,   48,  103,  103,  103,  103,
 636       103,  103,  103,  103,  103,  574,  143,  147,  107,  152,
 637       144,  153,  198,  140,  102,   44,  148,  361,  216,   44,
 638       388,  362,  217,  149,  389,  150,  165,  199,  218,   43,
 639       573,  104,  105,  105,  105,  105,  105,  105,  105,  105,
 640       105,  106,  106,  106,  106,  106,  106,  106,  106,  106,
 641
 642        45,  572,  571,  250,  570,  569,  568,  567,  166,  166,
 643       166,  166,  166,  166,  166,  166,  166,  166,   46,  251,
 644       166,  166,  166,  166,  166,  166,  167,  167,  167,  167,
 645       167,  167,  167,  167,  167,  168,  168,  168,  168,  168,
 646       168,  168,  168,  168,  227,  227,  227,  227,  227,  227,
 647       227,  227,  227,  227,  566,  565,  227,  227,  227,  227,
 648       227,  227,  228,  228,  228,  228,  228,  228,  228,  228,
 649       228,  229,  229,  229,  229,  229,  229,  229,  229,  229,
 650        45,  381,  391,  400,  504,  564,  563,  392,  562,  561,
 651       393,  560,  559,  558,  557,  382,  505,  401,   46,  275,
 652
 653       275,  275,  275,  275,  275,  275,  275,  275,  276,  276,
 654       276,  276,  276,  276,  276,  276,  276,  290,  291,  292,
 655       293,  294,  295,  296,  297,  321,  321,  321,  321,  321,
 656       321,  321,  321,  321,  322,  322,  322,  322,  322,  322,
 657       322,  322,  322,  352,  352,  352,  352,  352,  352,  352,
 658       352,  352,  353,  353,  353,  353,  353,  353,  353,  353,
 659       353,  379,  379,  379,  379,  379,  379,  379,  379,  379,
 660       405,  405,  405,  405,  405,  405,  405,  405,  405,  406,
 661       438,  556,  555,  554,  553,  552,  551,  550,  549,  548,
 662       547,  546,  545,  439,  544,  407,  543,  408,   39,  542,
 663
 664       541,   39,   44,   44,  540,   44,   47,   47,   47,   47,
 665        48,   48,   48,   48,  539,  538,  537,  536,  535,  534,
 666       533,  532,  531,  530,  529,  528,  527,  526,  525,  524,
 667       523,  522,  521,  520,  519,  518,  517,  516,  515,  514,
 668       513,  512,  511,  510,  509,  508,  507,  506,  503,  502,
 669       501,  500,  499,  498,  497,  496,  495,  494,  493,  492,
 670       491,  490,  489,  488,  487,  486,  485,  484,  483,  482,
 671       481,  480,  479,  478,  477,  476,  475,  474,  473,  472,
 672       471,  470,  469,  468,  467,  466,  465,  464,  463,  462,
 673       459,  458,  457,  456,  455,  454,  453,  452,  451,  450,
 674
 675       449,  448,  447,  446,  445,  444,  443,  442,  441,  440,
 676       437,  436,  435,  434,  433,  432,  431,  430,  429,  428,
 677       427,  426,  425,  424,  423,  422,  421,  420,  419,  418,
 678       417,  416,  415,  414,  413,  412,  411,  410,  409,  404,
 679       403,  402,  399,  398,  397,  396,  395,  394,  390,  387,
 680       386,  385,  384,  383,  380,   50,  378,  377,  376,  375,
 681       374,  373,  356,  372,  371,  370,  369,  368,  367,  366,
 682       365,  364,  363,  360,  359,  358,  357,  356,  355,  354,
 683       351,  350,  349,  348,  347,  346,  345,  344,  343,  342,
 684       341,  340,  339,  338,  337,  336,  335,  334,  333,  332,
 685
 686       331,  330,  329,  328,  327,  326,  325,  324,  323,  320,
 687       319,  318,  317,  316,  315,  314,  313,  312,  311,  310,
 688       309,  308,  307,  306,  305,  304,  303,  302,  301,  300,
 689       299,  298,  289,  288,  287,  286,  285,  284,  283,  282,
 690       281,  280,  279,  278,  277,  274,  273,  272,  271,  270,
 691       269,  268,  267,  266,  265,  264,  263,  262,  261,  260,
 692       259,  258,  257,  256,  255,  239,  254,  253,  252,  249,
 693       248,  247,  246,  245,  244,  243,  242,  241,  240,  239,
 694       238,  237,  236,  235,  234,  233,  232,  231,  230,  226,
 695       225,  224,  223,  222,  221,  220,  219,  215,  214,  213,
 696
 697       212,  211,  210,  209,  208,  207,  206,  205,  204,  203,
 698       202,  201,  200,  197,  196,  195,  194,  193,  192,  191,
 699       190,  189,  188,  187,  186,  185,  184,  183,  182,  181,
 700       180,  179,  178,  177,  176,  175,  174,  173,  172,  171,
 701       170,  169,  164,  163,  162,  161,  160,  159,  158,  157,
 702       156,  155,  154,  146,  145,  142,  141,  138,  137,  136,
 703       135,  134,  133,  130,  129,  128,  127,  126,  125,  124,
 704       123,  122,  121,  118,  117,  116,  111,  108,   49,   49,
 705        99,   96,   87,   86,   85,   77,   69,   54,  574,    3,
 706       574,  574,  574,  574,  574,  574,  574,  574,  574,  574,
 707
 708       574,  574,  574,  574,  574,  574,  574,  574,  574,  574,
 709       574,  574,  574,  574,  574,  574,  574,  574,  574,  574,
 710       574,  574,  574,  574,  574,  574,  574,  574,  574,  574,
 711       574,  574,  574,  574,  574,  574,  574,  574,  574,  574,
 712       574
 713     } ;
 714
 715 static yyconst flex_int16_t yy_chk[842] =
 716     {   0,
 717         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 718         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 719         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 720         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 721         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 722         1,    5,    5,    8,   17,    5,    9,    9,   19,    9,
 723        15,   15,   19,   17,   22,   23,   19,   23,   26,   26,
 724        22,    8,    5,   18,   43,   43,   18,    9,   14,   14,
 725        14,   14,   14,   14,   14,   14,   14,   14,   24,   24,
 726        18,   20,   20,   20,   20,   27,   24,   20,   28,   27,
 727
 728        32,   44,   33,   20,   32,   33,   37,   35,   28,   35,
 729        52,   52,   40,   40,   28,   33,   40,   33,   33,   44,
 730        53,   55,   33,   37,   47,   47,   59,   47,   55,   57,
 731        63,   83,   59,   40,   46,   46,   46,   57,  439,   76,
 732        63,   53,   76,  439,   90,   47,   46,   46,   46,   46,
 733        46,   46,   46,   46,   46,   46,   86,   89,  107,   90,
 734        86,   90,  139,   83,  102,  102,   89,  330,  156,  580,
 735       363,  330,  156,   89,  363,   89,  579,  139,  156,  107,
 736       571,   46,   50,   50,   50,   50,   50,   50,   50,   50,
 737        50,   51,   51,   51,   51,   51,   51,   51,   51,   51,
 738
 739       104,  570,  569,  199,  567,  566,  565,  564,  104,  104,
 740       104,  104,  104,  104,  104,  104,  104,  104,  104,  199,
 741       104,  104,  104,  104,  104,  104,  105,  105,  105,  105,
 742       105,  105,  105,  105,  105,  106,  106,  106,  106,  106,
 743       106,  106,  106,  106,  166,  166,  166,  166,  166,  166,
 744       166,  166,  166,  166,  560,  558,  166,  166,  166,  166,
 745       166,  166,  167,  167,  167,  167,  167,  167,  167,  167,
 746       167,  168,  168,  168,  168,  168,  168,  168,  168,  168,
 747       227,  357,  365,  373,  484,  556,  555,  365,  554,  552,
 748       365,  549,  548,  547,  546,  357,  484,  373,  227,  228,
 749
 750       228,  228,  228,  228,  228,  228,  228,  228,  229,  229,
 751       229,  229,  229,  229,  229,  229,  229,  247,  247,  247,
 752       247,  247,  247,  247,  247,  275,  275,  275,  275,  275,
 753       275,  275,  275,  275,  276,  276,  276,  276,  276,  276,
 754       276,  276,  276,  321,  321,  321,  321,  321,  321,  321,
 755       321,  321,  322,  322,  322,  322,  322,  322,  322,  322,
 756       322,  352,  352,  352,  352,  352,  352,  352,  352,  352,
 757       379,  379,  379,  379,  379,  379,  379,  379,  379,  380,
 758       415,  545,  544,  542,  541,  540,  539,  538,  537,  534,
 759       533,  532,  531,  415,  529,  380,  528,  380,  575,  527,
 760
 761       526,  575,  576,  576,  525,  576,  577,  577,  577,  577,
 762       578,  578,  578,  578,  523,  522,  521,  519,  518,  517,
 763       516,  515,  514,  513,  512,  511,  510,  509,  508,  507,
 764       506,  505,  504,  503,  502,  501,  498,  497,  496,  495,
 765       493,  492,  490,  489,  488,  487,  486,  485,  483,  482,
 766       481,  480,  479,  478,  476,  475,  474,  473,  472,  471,
 767       470,  469,  468,  467,  466,  465,  464,  463,  462,  461,
 768       460,  459,  458,  457,  456,  455,  454,  453,  451,  450,
 769       449,  448,  447,  446,  445,  444,  443,  442,  441,  440,
 770       438,  435,  434,  433,  432,  431,  430,  429,  428,  427,
 771
 772       426,  425,  423,  422,  421,  420,  419,  418,  417,  416,
 773       414,  413,  412,  410,  409,  408,  407,  406,  404,  403,
 774       402,  401,  400,  399,  396,  395,  394,  393,  392,  391,
 775       389,  388,  387,  386,  385,  384,  383,  382,  381,  378,
 776       376,  374,  372,  371,  370,  368,  367,  366,  364,  362,
 777       361,  360,  359,  358,  354,  353,  349,  348,  347,  346,
 778       345,  344,  343,  342,  341,  340,  339,  337,  336,  335,
 779       333,  332,  331,  329,  328,  327,  326,  325,  324,  323,
 780       320,  319,  318,  317,  315,  311,  310,  309,  308,  307,
 781       306,  305,  304,  303,  301,  300,  299,  298,  288,  287,
 782
 783       286,  285,  284,  283,  281,  280,  279,  278,  277,  273,
 784       272,  271,  270,  269,  268,  267,  265,  264,  263,  262,
 785       261,  260,  258,  257,  255,  254,  253,  252,  251,  250,
 786       249,  248,  246,  245,  244,  242,  241,  240,  238,  236,
 787       235,  234,  233,  232,  230,  226,  225,  224,  222,  221,
 788       220,  219,  218,  217,  216,  215,  214,  213,  212,  211,
 789       210,  209,  208,  206,  204,  203,  202,  201,  200,  198,
 790       196,  194,  193,  191,  190,  188,  185,  184,  183,  182,
 791       179,  178,  177,  174,  173,  172,  171,  170,  169,  164,
 792       163,  162,  161,  160,  159,  158,  157,  155,  154,  153,
 793
 794       152,  151,  150,  149,  148,  147,  146,  145,  144,  143,
 795       142,  141,  140,  138,  137,  136,  134,  133,  132,  131,
 796       130,  129,  128,  127,  126,  125,  124,  122,  121,  120,
 797       119,  118,  117,  116,  115,  114,  113,  112,  111,  110,
 798       109,  108,  101,  100,   99,   98,   97,   96,   95,   94,
 799        93,   92,   91,   88,   87,   85,   84,   82,   81,   80,
 800        79,   78,   77,   75,   73,   72,   71,   70,   68,   67,
 801        66,   65,   64,   62,   61,   60,   56,   54,   48,   42,
 802        36,   34,   31,   30,   29,   25,   21,   16,    3,  574,
 803       574,  574,  574,  574,  574,  574,  574,  574,  574,  574,
 804
 805       574,  574,  574,  574,  574,  574,  574,  574,  574,  574,
 806       574,  574,  574,  574,  574,  574,  574,  574,  574,  574,
 807       574,  574,  574,  574,  574,  574,  574,  574,  574,  574,
 808       574,  574,  574,  574,  574,  574,  574,  574,  574,  574,
 809       574
 810     } ;
 811
 812 static yy_state_type yy_last_accepting_state;
 813 static char *yy_last_accepting_cpos;
 814
 815 extern int yy_flex_debug;
 816 int yy_flex_debug = 0;
 817
 818 /* The intent behind this definition is that it'll catch
 819  * any uses of REJECT which flex missed.
 820  */
 821 #define REJECT reject_used_but_not_detected
 822 #define yymore() yymore_used_but_not_detected
 823 #define YY_MORE_ADJ 0
 824 #define YY_RESTORE_YY_MORE_OFFSET
 825 char *yytext;
 826 #line 1 "lexer.l"
 827 /*
 828  *   Copyright (C)1996-1997,1999 Ian Jackson
 829  *
 830  *   This is free software; you can redistribute it and/or modify it
 831  *   under the terms of the GNU General Public License as published by
 832  *   the Free Software Foundation; either version 2 of the License, or
 833  *   (at your option) any later version.
 834  *
 835  *   This program is distributed in the hope that it will be useful, but
 836  *   WITHOUT ANY WARRANTY; without even the implied warranty of
 837  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 838  *   General Public License for more details.
 839  *
 840  *   You should have received a copy of the GNU General Public License
 841  *   along with userv; if not, write to the Free Software
 842  *   Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 843  */
 844 #line 20 "lexer.l"
 845
 846
 847
 848
 849
 850 #include <syslog.h>
 851 #include <assert.h>
 852 #include <stdio.h>
 853 #include <stdarg.h>
 854 #include <ctype.h>
 855 #include <string.h>
 856 #include <unistd.h>
 857 #include <pwd.h>
 858 #include <grp.h>
 859 #include <fnmatch.h>
 860 #include <limits.h>
 861 #include <dirent.h>
 862 #include <sys/types.h>
 863 #include <sys/stat.h>
 864 #include <time.h>
 865 #include <errno.h>
 866
 867 #include "config.h"
 868 #include "common.h"
 869 #include "daemon.h"
 870 #include "lib.h"
 871 #include "both.h"
 872 #include "tokens.h"
 873
 874 #define HYPHEN '-'
 875
 876 typedef int directive_fnt(int dtoken);
 877 static directive_fnt df_reject, df_execute, df_executefrompath;
 878 static directive_fnt df_executefromdirectory, df_executebuiltin;
 879 static directive_fnt df_errorstostderr, df_errorstosyslog, df_errorstofile;
 880 static directive_fnt dfg_fdwant, dfg_setflag;
 881 static directive_fnt df_reset, df_cd, df_userrcfile, df_include;
 882 static directive_fnt df_includelookup, df_includedirectory;
 883 static directive_fnt df_message, df_error, df_quit, df_eof;
 884 static directive_fnt df_if, df_catchquit, df_errorspush;
 885 static directive_fnt dfi_includeuserrcfile, dfi_includeclientconfig;
 886 /* directive functions return:
 887  *  0 for success having scanned up to and including end of line but not beyond,
 888  *  or tokv_error or tokv_quit.
 889  * They expect to parse the whitespace before their parameters (if any).
 890  */
 891
 892 typedef int parmcondition_fnt(int ctoken, char *const *parmvalues, int *rtrue);
 893 static parmcondition_fnt pcf_glob, pcf_range, pcf_grep;
 894 /* all conditional functions return tokv_error for failure or 0 for success
 895  *  at parsing and testing, in which case *rtrue is set to 0 or 1.
 896  *  On success they have scanned up to and including the condition's
 897  *  terminating newline; the pcf_... functions expect to parse the whitespace
 898  *  between the parameter name and the condition's arguments.
 899  * Otherwise they return tokv_error.
 900  * The parameter-based conditionals take a list of parameter values
 901  * as obtained from the parameter functions and pa_parameter,
 902  * and do _not_ free it.
 903  */
 904
 905 typedef int parameter_fnt(int ptoken, char ***rvalues);
 906 static parameter_fnt pf_service;
 907 static parameter_fnt pf_callinguser, pf_serviceuser;
 908 static parameter_fnt pf_callinggroup, pf_servicegroup;
 909 static parameter_fnt pf_callingusershell, pf_serviceusershell;
 910 /* Parameter functions return tokv_error or 0 for success at parsing
 911  * and determining the value, in which case *rvalues is made to be
 912  * a mallocd null-terminated array of pointers to mallocd strings.
 913  * freeparm can be used to free such an array.
 914  */
 915
 916 typedef int builtinserviceparse_fnt(char ***rnewargs);
 917 static builtinserviceparse_fnt bispa_none, bispa_parameter;
 918 /* These parse the arguments to a builtin service, including the
 919  * newline at the end of the line.  *rnewargs will initially be
 920  * null, indicating that no arguments are to be set; the function
 921  * may store a mallocd array of mallocd strings in it,
 922  * containing the arguments it wishes to have set (null-pointer
 923  * terminated).
 924  */
 925
 926 static int yylex(void);
 927 /* Returns a token (which may be an eof or error exception) */
 928
 929 static directive_fnt *lr_dir;
 930 static parmcondition_fnt *lr_parmcond;
 931 static builtinserviceparse_fnt *lr_bispa;
 932 static builtinserviceexec_fnt *lr_bisexec;
 933 static parameter_fnt *lr_parameter;
 934 static int lr_loglevel, lr_logfacility, lr_min, lr_max, *lr_flag;
 935 static int lr_flagval, lr_controlend;
 936 static int lr_fdwant_readwrite; /* -1=never, 0=opt, 1=always */
 937
 938 /* Forward declarations of things used in lexer and parser */
 939
 940 struct parser_state {
 941   int lineno, reportlineno, notedreferer, isinternal;
 942   const char *filename;
 943   struct stat filestab;
 944   YY_BUFFER_STATE ybuf;
 945   struct parser_state *upstate;
 946 };
 947
 948 static struct parser_state *cstate;
 949
 950 struct error_handling {
 951   int handling; /* One of the error handling modes tokt_ehandlemode */
 952   int logfacility, loglevel;
 953   int filekeep; /* File is in use by higher-level errors-push, leave it open */
 954   FILE *file;
 955   char *filename;
 956 };
 957
 958 static struct error_handling eh = { tokv_word_errorstostderr, 0,0,0,0,0 };
 959
 960 static int dequote(char *inplace);
 961 static void countnewlines(void);
 962
 963 #line 964 "<stdout>"
 964
 965 #define INITIAL 0
 966
 967 #ifndef YY_NO_UNISTD_H
 968 /* Special case for "unistd.h", since it is non-ANSI. We include it way
 969  * down here because we want the user's section 1 to have been scanned first.
 970  * The user has a chance to override it with an option.
 971  */
 972 #include <unistd.h>
 973 #endif
 974
 975 #ifndef YY_EXTRA_TYPE
 976 #define YY_EXTRA_TYPE void *
 977 #endif
 978
 979 static int yy_init_globals (void );
 980
 981 /* Accessor methods to globals.
 982    These are made visible to non-reentrant scanners for convenience. */
 983
 984 int yylex_destroy (void );
 985
 986 int yyget_debug (void );
 987
 988 void yyset_debug (int debug_flag  );
 989
 990 YY_EXTRA_TYPE yyget_extra (void );
 991
 992 void yyset_extra (YY_EXTRA_TYPE user_defined  );
 993
 994 FILE *yyget_in (void );
 995
 996 void yyset_in  (FILE * _in_str  );
 997
 998 FILE *yyget_out (void );
 999
1000 void yyset_out  (FILE * _out_str  );
1001
1002                         int yyget_leng (void );
1003
1004 char *yyget_text (void );
1005
1006 int yyget_lineno (void );
1007
1008 void yyset_lineno (int _line_number  );
1009
1010 /* Macros after this point can all be overridden by user definitions in
1011  * section 1.
1012  */
1013
1014 #ifndef YY_SKIP_YYWRAP
1015 #ifdef __cplusplus
1016 extern "C" int yywrap (void );
1017 #else
1018 extern int yywrap (void );
1019 #endif
1020 #endif
1021
1022 #ifndef YY_NO_UNPUT
1023
1024 #endif
1025
1026 #ifndef yytext_ptr
1027 static void yy_flex_strncpy (char *,yyconst char *,int );
1028 #endif
1029
1030 #ifdef YY_NEED_STRLEN
1031 static int yy_flex_strlen (yyconst char * );
1032 #endif
1033
1034 #ifndef YY_NO_INPUT
1035
1036 #ifdef __cplusplus
1037 static int yyinput (void );
1038 #else
1039 static int input (void );
1040 #endif
1041
1042 #endif
1043
1044 /* Amount of stuff to slurp up with each read. */
1045 #ifndef YY_READ_BUF_SIZE
1046 #ifdef __ia64__
1047 /* On IA-64, the buffer size is 16k, not 8k */
1048 #define YY_READ_BUF_SIZE 16384
1049 #else
1050 #define YY_READ_BUF_SIZE 8192
1051 #endif /* __ia64__ */
1052 #endif
1053
1054 /* Copy whatever the last rule matched to the standard output. */
1055 #ifndef ECHO
1056 /* This used to be an fputs(), but since the string might contain NUL's,
1057  * we now use fwrite().
1058  */
1059 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
1060 #endif
1061
1062 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1063  * is returned in "result".
1064  */
1065 #ifndef YY_INPUT
1066 #define YY_INPUT(buf,result,max_size) \
1067         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1068                 { \
1069                 int c = '*'; \
1070                 size_t n; \
1071                 for ( n = 0; n < max_size && \
1072                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1073                         buf[n] = (char) c; \
1074                 if ( c == '\n' ) \
1075                         buf[n++] = (char) c; \
1076                 if ( c == EOF && ferror( yyin ) ) \
1077                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1078                 result = n; \
1079                 } \
1080         else \
1081                 { \
1082                 errno=0; \
1083                 while ( (result = (int) fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
1084                         { \
1085                         if( errno != EINTR) \
1086                                 { \
1087                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1088                                 break; \
1089                                 } \
1090                         errno=0; \
1091                         clearerr(yyin); \
1092                         } \
1093                 }\
1094 \
1095
1096 #endif
1097
1098 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1099  * we don't want an extra ';' after the "return" because that will cause
1100  * some compilers to complain about unreachable statements.
1101  */
1102 #ifndef yyterminate
1103 #define yyterminate() return YY_NULL
1104 #endif
1105
1106 /* Number of entries by which start-condition stack grows. */
1107 #ifndef YY_START_STACK_INCR
1108 #define YY_START_STACK_INCR 25
1109 #endif
1110
1111 /* Report a fatal error. */
1112 #ifndef YY_FATAL_ERROR
1113 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1114 #endif
1115
1116 /* end tables serialization structures and prototypes */
1117
1118 /* Default declaration of generated scanner - a define so the user can
1119  * easily add parameters.
1120  */
1121 #ifndef YY_DECL
1122 #define YY_DECL_IS_OURS 1
1123
1124 extern int yylex (void);
1125
1126 #define YY_DECL int yylex (void)
1127 #endif /* !YY_DECL */
1128
1129 /* Code executed at the beginning of each rule, after yytext and yyleng
1130  * have been set up.
1131  */
1132 #ifndef YY_USER_ACTION
1133 #define YY_USER_ACTION
1134 #endif
1135
1136 /* Code executed at the end of each rule. */
1137 #ifndef YY_BREAK
1138 #define YY_BREAK /*LINTED*/break;
1139 #endif
1140
1141 #define YY_RULE_SETUP \
1142         YY_USER_ACTION
1143
1144 /** The main scanner function which does all the work.
1145  */
1146 YY_DECL
1147 {
1148         yy_state_type yy_current_state;
1149         char *yy_cp, *yy_bp;
1150         int yy_act;
1151
1152         if ( !(yy_init) )
1153                 {
1154                 (yy_init) = 1;
1155
1156 #ifdef YY_USER_INIT
1157                 YY_USER_INIT;
1158 #endif
1159
1160                 if ( ! (yy_start) )
1161                         (yy_start) = 1; /* first start state */
1162
1163                 if ( ! yyin )
1164                         yyin = stdin;
1165
1166                 if ( ! yyout )
1167                         yyout = stdout;
1168
1169                 if ( ! YY_CURRENT_BUFFER ) {
1170                         yyensure_buffer_stack ();
1171                         YY_CURRENT_BUFFER_LVALUE =
1172                                 yy_create_buffer(yyin,YY_BUF_SIZE );
1173                 }
1174
1175                 yy_load_buffer_state( );
1176                 }
1177
1178         {
1179 #line 143 "lexer.l"
1180
1181
1182 #line 1183 "<stdout>"
1183
1184         while ( /*CONSTCOND*/1 )                /* loops until end-of-file is reached */
1185                 {
1186                 yy_cp = (yy_c_buf_p);
1187
1188                 /* Support of yytext. */
1189                 *yy_cp = (yy_hold_char);
1190
1191                 /* yy_bp points to the position in yy_ch_buf of the start of
1192                  * the current run.
1193                  */
1194                 yy_bp = yy_cp;
1195
1196                 yy_current_state = (yy_start);
1197 yy_match:
1198                 do
1199                         {
1200                         YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1201                         if ( yy_accept[yy_current_state] )
1202                                 {
1203                                 (yy_last_accepting_state) = yy_current_state;
1204                                 (yy_last_accepting_cpos) = yy_cp;
1205                                 }
1206                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1207                                 {
1208                                 yy_current_state = (int) yy_def[yy_current_state];
1209                                 if ( yy_current_state >= 575 )
1210                                         yy_c = yy_meta[(unsigned int) yy_c];
1211                                 }
1212                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
1213                         ++yy_cp;
1214                         }
1215                 while ( yy_base[yy_current_state] != 790 );
1216
1217 yy_find_action:
1218                 yy_act = yy_accept[yy_current_state];
1219                 if ( yy_act == 0 )
1220                         { /* have to back up */
1221                         yy_cp = (yy_last_accepting_cpos);
1222                         yy_current_state = (yy_last_accepting_state);
1223                         yy_act = yy_accept[yy_current_state];
1224                         }
1225
1226                 YY_DO_BEFORE_ACTION;
1227
1228 do_action:      /* This label is used only to access EOF actions. */
1229
1230                 switch ( yy_act )
1231         { /* beginning of action switch */
1232                         case 0: /* must back up */
1233                         /* undo the effects of YY_DO_BEFORE_ACTION */
1234                         *yy_cp = (yy_hold_char);
1235                         yy_cp = (yy_last_accepting_cpos);
1236                         yy_current_state = (yy_last_accepting_state);
1237                         goto yy_find_action;
1238
1239 case 1:
1240 YY_RULE_SETUP
1241 #line 145 "lexer.l"
1242 { lr_dir= df_reject; return tokv_word_reject; }
1243         YY_BREAK
1244 case 2:
1245 YY_RULE_SETUP
1246 #line 146 "lexer.l"
1247 { lr_dir= df_executefromdirectory; return tokv_word_executefromdirectory; }
1248         YY_BREAK
1249 case 3:
1250 YY_RULE_SETUP
1251 #line 147 "lexer.l"
1252 { lr_dir= df_executefrompath; return tokv_word_executefrompath; }
1253         YY_BREAK
1254 case 4:
1255 YY_RULE_SETUP
1256 #line 148 "lexer.l"
1257 { lr_dir= df_executebuiltin; return tokv_word_executebuiltin; }
1258         YY_BREAK
1259 case 5:
1260 YY_RULE_SETUP
1261 #line 149 "lexer.l"
1262 { lr_dir= df_errorstostderr; return tokv_word_errorstostderr; }
1263         YY_BREAK
1264 case 6:
1265 YY_RULE_SETUP
1266 #line 150 "lexer.l"
1267 { lr_dir= df_errorstosyslog; return tokv_word_errorstosyslog; }
1268         YY_BREAK
1269 case 7:
1270 YY_RULE_SETUP
1271 #line 151 "lexer.l"
1272 { lr_dir= df_errorstofile; return tokv_word_errorstofile; }
1273         YY_BREAK
1274 case 8:
1275 YY_RULE_SETUP
1276 #line 152 "lexer.l"
1277 { lr_dir= dfg_fdwant; lr_fdwant_readwrite=1; return tokv_word_requirefd; }
1278         YY_BREAK
1279 case 9:
1280 YY_RULE_SETUP
1281 #line 153 "lexer.l"
1282 { lr_dir= dfg_fdwant; lr_fdwant_readwrite=0; return tokv_word_allowfd; }
1283         YY_BREAK
1284 case 10:
1285 YY_RULE_SETUP
1286 #line 154 "lexer.l"
1287 { lr_dir= dfg_fdwant; lr_fdwant_readwrite=0; return tokv_word_nullfd; }
1288         YY_BREAK
1289 case 11:
1290 YY_RULE_SETUP
1291 #line 155 "lexer.l"
1292 { lr_dir= dfg_fdwant; lr_fdwant_readwrite=-1; return tokv_word_rejectfd; }
1293         YY_BREAK
1294 case 12:
1295 YY_RULE_SETUP
1296 #line 156 "lexer.l"
1297 { lr_dir= dfg_fdwant; lr_fdwant_readwrite=-1; return tokv_word_ignorefd; }
1298         YY_BREAK
1299 case 13:
1300 YY_RULE_SETUP
1301 #line 157 "lexer.l"
1302 { lr_dir= dfg_setflag; lr_flag= &setenvironment; lr_flagval= 1; return tokv_word_setenvironment; }
1303         YY_BREAK
1304 case 14:
1305 YY_RULE_SETUP
1306 #line 158 "lexer.l"
1307 { lr_dir= dfg_setflag; lr_flag= &setenvironment; lr_flagval= 0; return tokv_word_nosetenvironment; }
1308         YY_BREAK
1309 case 15:
1310 YY_RULE_SETUP
1311 #line 159 "lexer.l"
1312 { lr_dir= dfg_setflag; lr_flag= &suppressargs; lr_flagval= 1; return tokv_word_suppressargs; }
1313         YY_BREAK
1314 case 16:
1315 YY_RULE_SETUP
1316 #line 160 "lexer.l"
1317 { lr_dir= dfg_setflag; lr_flag= &suppressargs; lr_flagval= 0; return tokv_word_nosuppressargs; }
1318         YY_BREAK
1319 case 17:
1320 YY_RULE_SETUP
1321 #line 161 "lexer.l"
1322 { lr_dir= dfg_setflag; lr_flag= &disconnecthup; lr_flagval= 1; return tokv_word_disconnecthup; }
1323         YY_BREAK
1324 case 18:
1325 YY_RULE_SETUP
1326 #line 162 "lexer.l"
1327 { lr_dir= dfg_setflag; lr_flag= &disconnecthup; lr_flagval= 0; return tokv_word_nodisconnecthup; }
1328         YY_BREAK
1329 case 19:
1330 YY_RULE_SETUP
1331 #line 163 "lexer.l"
1332 { lr_dir= df_cd; return tokv_word_cd; }
1333         YY_BREAK
1334 case 20:
1335 YY_RULE_SETUP
1336 #line 164 "lexer.l"
1337 { lr_dir= df_userrcfile; return tokv_word_userrcfile; }
1338         YY_BREAK
1339 case 21:
1340 YY_RULE_SETUP
1341 #line 165 "lexer.l"
1342 { lr_dir= df_include; return tokv_word_include; }
1343         YY_BREAK
1344 case 22:
1345 YY_RULE_SETUP
1346 #line 166 "lexer.l"
1347 { lr_dir= df_include; return tokv_word_includeifexist; }
1348         YY_BREAK
1349 case 23:
1350 YY_RULE_SETUP
1351 #line 167 "lexer.l"
1352 { lr_dir= df_includelookup; return tokv_word_includelookup; }
1353         YY_BREAK
1354 case 24:
1355 YY_RULE_SETUP
1356 #line 168 "lexer.l"
1357 { lr_dir= df_includelookup; return tokv_word_includelookupall; }
1358         YY_BREAK
1359 case 25:
1360 YY_RULE_SETUP
1361 #line 169 "lexer.l"
1362 { lr_dir= df_includedirectory; return tokv_word_includedirectory; }
1363         YY_BREAK
1364 case 26:
1365 YY_RULE_SETUP
1366 #line 170 "lexer.l"
1367 { lr_dir= df_message; return tokv_word_message; }
1368         YY_BREAK
1369 case 27:
1370 YY_RULE_SETUP
1371 #line 171 "lexer.l"
1372 { lr_dir= df_include; return tokv_word_includesysconfig; }
1373         YY_BREAK
1374 case 28:
1375 YY_RULE_SETUP
1376 #line 172 "lexer.l"
1377 { lr_dir= dfi_includeuserrcfile; return tokv_word_includeuserrcfile; }
1378         YY_BREAK
1379 case 29:
1380 YY_RULE_SETUP
1381 #line 173 "lexer.l"
1382 { lr_dir= dfi_includeclientconfig; return tokv_word_includeclientconfig; }
1383         YY_BREAK
1384 case 30:
1385 YY_RULE_SETUP
1386 #line 174 "lexer.l"
1387 { lr_dir= df_quit; return tokv_word_quit; }
1388         YY_BREAK
1389 case 31:
1390 YY_RULE_SETUP
1391 #line 175 "lexer.l"
1392 { lr_dir= df_eof; return tokv_word_eof; }
1393         YY_BREAK
1394 case 32:
1395 YY_RULE_SETUP
1396 #line 176 "lexer.l"
1397 { lr_dir= df_if; return tokv_word_if; }
1398         YY_BREAK
1399 case 33:
1400 YY_RULE_SETUP
1401 #line 177 "lexer.l"
1402 { lr_dir= df_catchquit; return tokv_word_catchquit; }
1403         YY_BREAK
1404 case 34:
1405 YY_RULE_SETUP
1406 #line 178 "lexer.l"
1407 { lr_dir= df_errorspush; return tokv_word_errorspush; }
1408         YY_BREAK
1409 case 35:
1410 YY_RULE_SETUP
1411 #line 179 "lexer.l"
1412 { lr_controlend= tokv_word_if; return tokv_word_elif; }
1413         YY_BREAK
1414 case 36:
1415 YY_RULE_SETUP
1416 #line 180 "lexer.l"
1417 { lr_controlend= tokv_word_if; return tokv_word_else; }
1418         YY_BREAK
1419 case 37:
1420 YY_RULE_SETUP
1421 #line 181 "lexer.l"
1422 { lr_controlend= tokv_word_if; return tokv_word_fi; }
1423         YY_BREAK
1424 case 38:
1425 YY_RULE_SETUP
1426 #line 182 "lexer.l"
1427 { lr_controlend= tokv_word_catchquit; return tokv_word_hctac; }
1428         YY_BREAK
1429 case 39:
1430 YY_RULE_SETUP
1431 #line 183 "lexer.l"
1432 { lr_controlend= tokv_word_errorspush; return tokv_word_srorre; }
1433         YY_BREAK
1434 case 40:
1435 YY_RULE_SETUP
1436 #line 184 "lexer.l"
1437 { lr_parmcond= pcf_glob; return tokv_word_glob; }
1438         YY_BREAK
1439 case 41:
1440 YY_RULE_SETUP
1441 #line 185 "lexer.l"
1442 { lr_parmcond= pcf_range; return tokv_word_range; }
1443         YY_BREAK
1444 case 42:
1445 YY_RULE_SETUP
1446 #line 186 "lexer.l"
1447 { lr_parmcond= pcf_grep; return tokv_word_grep; }
1448         YY_BREAK
1449 case 43:
1450 YY_RULE_SETUP
1451 #line 187 "lexer.l"
1452 { lr_bispa= bispa_none; lr_bisexec= bisexec_environment; return tokv_word_environment; }
1453         YY_BREAK
1454 case 44:
1455 YY_RULE_SETUP
1456 #line 188 "lexer.l"
1457 { lr_bispa= bispa_parameter; lr_bisexec= bisexec_parameter; return tokv_word_parameter; }
1458         YY_BREAK
1459 case 45:
1460 YY_RULE_SETUP
1461 #line 189 "lexer.l"
1462 { lr_bispa= bispa_none; lr_bisexec= bisexec_version; return tokv_word_version; }
1463         YY_BREAK
1464 case 46:
1465 YY_RULE_SETUP
1466 #line 190 "lexer.l"
1467 { lr_bispa= bispa_none; lr_bisexec= bisexec_toplevel; return tokv_word_toplevel; }
1468         YY_BREAK
1469 case 47:
1470 YY_RULE_SETUP
1471 #line 191 "lexer.l"
1472 { lr_bispa= bispa_none; lr_bisexec= bisexec_override; return tokv_word_override; }
1473         YY_BREAK
1474 case 48:
1475 YY_RULE_SETUP
1476 #line 192 "lexer.l"
1477 { lr_bispa= bispa_none; lr_bisexec= bisexec_shutdown; return tokv_word_shutdown; }
1478         YY_BREAK
1479 case 49:
1480 YY_RULE_SETUP
1481 #line 193 "lexer.l"
1482 { lr_bispa= bispa_none; lr_bisexec= bisexec_reset; lr_dir= df_reset; return tokv_word_reset; }
1483         YY_BREAK
1484 case 50:
1485 YY_RULE_SETUP
1486 #line 194 "lexer.l"
1487 { lr_bispa= bispa_none; lr_bisexec= bisexec_execute; lr_dir= df_execute; return tokv_word_execute; }
1488         YY_BREAK
1489 case 51:
1490 YY_RULE_SETUP
1491 #line 195 "lexer.l"
1492 { lr_bispa= bispa_none; lr_bisexec= bisexec_help; return tokv_word_help; }
1493         YY_BREAK
1494 case 52:
1495 YY_RULE_SETUP
1496 #line 196 "lexer.l"
1497 { lr_parameter= pf_service; return tokv_word_service; }
1498         YY_BREAK
1499 case 53:
1500 YY_RULE_SETUP
1501 #line 197 "lexer.l"
1502 { lr_parameter= pf_callinguser; return tokv_word_callinguser; }
1503         YY_BREAK
1504 case 54:
1505 YY_RULE_SETUP
1506 #line 198 "lexer.l"
1507 { lr_parameter= pf_callinggroup; return tokv_word_callinggroup; }
1508         YY_BREAK
1509 case 55:
1510 YY_RULE_SETUP
1511 #line 199 "lexer.l"
1512 { lr_parameter= pf_callingusershell; return tokv_word_callingusershell; }
1513         YY_BREAK
1514 case 56:
1515 YY_RULE_SETUP
1516 #line 200 "lexer.l"
1517 { lr_parameter= pf_serviceuser; return tokv_word_serviceuser; }
1518         YY_BREAK
1519 case 57:
1520 YY_RULE_SETUP
1521 #line 201 "lexer.l"
1522 { lr_parameter= pf_servicegroup; return tokv_word_servicegroup; }
1523         YY_BREAK
1524 case 58:
1525 YY_RULE_SETUP
1526 #line 202 "lexer.l"
1527 { lr_parameter= pf_serviceusershell; return tokv_word_serviceusershell; }
1528         YY_BREAK
1529 case 59:
1530 YY_RULE_SETUP
1531 #line 203 "lexer.l"
1532 { lr_loglevel= LOG_DEBUG; return tokv_syslog_debug; }
1533         YY_BREAK
1534 case 60:
1535 YY_RULE_SETUP
1536 #line 204 "lexer.l"
1537 { lr_loglevel= LOG_INFO; return tokv_syslog_info; }
1538         YY_BREAK
1539 case 61:
1540 YY_RULE_SETUP
1541 #line 205 "lexer.l"
1542 { lr_loglevel= LOG_NOTICE; return tokv_syslog_notice; }
1543         YY_BREAK
1544 case 62:
1545 YY_RULE_SETUP
1546 #line 206 "lexer.l"
1547 { lr_loglevel= LOG_WARNING; return tokv_syslog_warning; }
1548         YY_BREAK
1549 case 63:
1550 YY_RULE_SETUP
1551 #line 207 "lexer.l"
1552 { lr_loglevel= LOG_ERR; return tokv_syslog_err; }
1553         YY_BREAK
1554 case 64:
1555 YY_RULE_SETUP
1556 #line 208 "lexer.l"
1557 { lr_loglevel= LOG_CRIT; return tokv_syslog_crit; }
1558         YY_BREAK
1559 case 65:
1560 YY_RULE_SETUP
1561 #line 209 "lexer.l"
1562 { lr_loglevel= LOG_ALERT; return tokv_syslog_alert; }
1563         YY_BREAK
1564 case 66:
1565 YY_RULE_SETUP
1566 #line 210 "lexer.l"
1567 { lr_loglevel= LOG_EMERG; return tokv_syslog_emerg; }
1568         YY_BREAK
1569 case 67:
1570 YY_RULE_SETUP
1571 #line 211 "lexer.l"
1572 { lr_logfacility= LOG_AUTHPRIV; return tokv_syslog_authpriv; }
1573         YY_BREAK
1574 case 68:
1575 YY_RULE_SETUP
1576 #line 212 "lexer.l"
1577 { lr_logfacility= LOG_CRON; return tokv_syslog_cron; }
1578         YY_BREAK
1579 case 69:
1580 YY_RULE_SETUP
1581 #line 213 "lexer.l"
1582 { lr_logfacility= LOG_DAEMON; return tokv_syslog_daemon; }
1583         YY_BREAK
1584 case 70:
1585 YY_RULE_SETUP
1586 #line 214 "lexer.l"
1587 { lr_logfacility= LOG_KERN; return tokv_syslog_kern; }
1588         YY_BREAK
1589 case 71:
1590 YY_RULE_SETUP
1591 #line 215 "lexer.l"
1592 { lr_logfacility= LOG_LPR; return tokv_syslog_lpr; }
1593         YY_BREAK
1594 case 72:
1595 YY_RULE_SETUP
1596 #line 216 "lexer.l"
1597 { lr_logfacility= LOG_MAIL; return tokv_syslog_mail; }
1598         YY_BREAK
1599 case 73:
1600 YY_RULE_SETUP
1601 #line 217 "lexer.l"
1602 { lr_logfacility= LOG_NEWS; return tokv_syslog_news; }
1603         YY_BREAK
1604 case 74:
1605 YY_RULE_SETUP
1606 #line 218 "lexer.l"
1607 { lr_logfacility= LOG_SYSLOG; return tokv_syslog_syslog; }
1608         YY_BREAK
1609 case 75:
1610 YY_RULE_SETUP
1611 #line 219 "lexer.l"
1612 { lr_logfacility= LOG_USER; return tokv_syslog_user; }
1613         YY_BREAK
1614 case 76:
1615 YY_RULE_SETUP
1616 #line 220 "lexer.l"
1617 { lr_logfacility= LOG_UUCP; return tokv_syslog_uucp; }
1618         YY_BREAK
1619 case 77:
1620 YY_RULE_SETUP
1621 #line 221 "lexer.l"
1622 { lr_logfacility= LOG_LOCAL0; return tokv_syslog_local0; }
1623         YY_BREAK
1624 case 78:
1625 YY_RULE_SETUP
1626 #line 222 "lexer.l"
1627 { lr_logfacility= LOG_LOCAL1; return tokv_syslog_local1; }
1628         YY_BREAK
1629 case 79:
1630 YY_RULE_SETUP
1631 #line 223 "lexer.l"
1632 { lr_logfacility= LOG_LOCAL2; return tokv_syslog_local2; }
1633         YY_BREAK
1634 case 80:
1635 YY_RULE_SETUP
1636 #line 224 "lexer.l"
1637 { lr_logfacility= LOG_LOCAL3; return tokv_syslog_local3; }
1638         YY_BREAK
1639 case 81:
1640 YY_RULE_SETUP
1641 #line 225 "lexer.l"
1642 { lr_logfacility= LOG_LOCAL4; return tokv_syslog_local4; }
1643         YY_BREAK
1644 case 82:
1645 YY_RULE_SETUP
1646 #line 226 "lexer.l"
1647 { lr_logfacility= LOG_LOCAL5; return tokv_syslog_local5; }
1648         YY_BREAK
1649 case 83:
1650 YY_RULE_SETUP
1651 #line 227 "lexer.l"
1652 { lr_logfacility= LOG_LOCAL6; return tokv_syslog_local6; }
1653         YY_BREAK
1654 case 84:
1655 YY_RULE_SETUP
1656 #line 228 "lexer.l"
1657 { lr_logfacility= LOG_LOCAL7; return tokv_syslog_local7; }
1658         YY_BREAK
1659 case 85:
1660 YY_RULE_SETUP
1661 #line 229 "lexer.l"
1662 { return tokv_word_read; }
1663         YY_BREAK
1664 case 86:
1665 YY_RULE_SETUP
1666 #line 230 "lexer.l"
1667 { return tokv_word_write; }
1668         YY_BREAK
1669 case 87:
1670 YY_RULE_SETUP
1671 #line 231 "lexer.l"
1672 { return tokv_dollar; }
1673         YY_BREAK
1674 case 88:
1675 YY_RULE_SETUP
1676 #line 232 "lexer.l"
1677 {  lr_max= lr_min= 0; return tokv_word_stdin; }
1678         YY_BREAK
1679 case 89:
1680 YY_RULE_SETUP
1681 #line 233 "lexer.l"
1682 {  lr_max= lr_min= 1; return tokv_word_stdout; }
1683         YY_BREAK
1684 case 90:
1685 YY_RULE_SETUP
1686 #line 234 "lexer.l"
1687 {  lr_max= lr_min= 2; return tokv_word_stderr; }
1688         YY_BREAK
1689 case 91:
1690 YY_RULE_SETUP
1691 #line 235 "lexer.l"
1692 { return tokv_openparen; }
1693         YY_BREAK
1694 case 92:
1695 YY_RULE_SETUP
1696 #line 236 "lexer.l"
1697 { return tokv_closeparen; }
1698         YY_BREAK
1699 case 93:
1700 YY_RULE_SETUP
1701 #line 237 "lexer.l"
1702 { return tokv_not; }
1703         YY_BREAK
1704 case 94:
1705 YY_RULE_SETUP
1706 #line 238 "lexer.l"
1707 { return tokv_and; }
1708         YY_BREAK
1709 case 95:
1710 YY_RULE_SETUP
1711 #line 239 "lexer.l"
1712 { return tokv_or; }
1713         YY_BREAK
1714 case 96:
1715 YY_RULE_SETUP
1716 #line 240 "lexer.l"
1717 { lr_dir= df_error; lr_loglevel= LOG_ERR; return tokv_word_error; }
1718         YY_BREAK
1719 case 97:
1720 YY_RULE_SETUP
1721 #line 244 "lexer.l"
1722 {
1723                           char *ep;
1724                           lr_min=lr_max= (int)strtoul(yytext,&ep,10);
1725                           assert(!*ep);
1726                           return tokv_ordinal;
1727                         }
1728         YY_BREAK
1729 case 98:
1730 YY_RULE_SETUP
1731 #line 250 "lexer.l"
1732 {
1733                           char *ep;
1734                           lr_min= (int)strtoul(yytext,&ep,10);
1735                           assert(*ep == HYPHEN);
1736                           ep++;  assert(*ep);
1737                           lr_max= (int)strtoul(ep,&ep,10);
1738                           assert(!*ep);
1739                           if (lr_max < lr_min)
1740                             return parseerrprint("fd range has min > max");
1741                           return tokv_fdrange;
1742                         }
1743         YY_BREAK
1744 case 99:
1745 YY_RULE_SETUP
1746 #line 261 "lexer.l"
1747 {
1748                           char *ep;
1749                           lr_min= (int)strtoul(yytext,&ep,10);
1750                           assert(*ep == HYPHEN);
1751                           ep++;  assert(!*ep);
1752                           lr_max=-1;
1753                           return tokv_fdstoend;
1754                         }
1755         YY_BREAK
1756 case 100:
1757 /* rule 100 can match eol */
1758 YY_RULE_SETUP
1759 #line 269 "lexer.l"
1760 countnewlines(); return tokv_lwsp;
1761         YY_BREAK
1762 case 101:
1763 YY_RULE_SETUP
1764 #line 270 "lexer.l"
1765 return tokv_lwsp;
1766         YY_BREAK
1767 case 102:
1768 /* rule 102 can match eol */
1769 YY_RULE_SETUP
1770 #line 271 "lexer.l"
1771 cstate->lineno++; return tokv_newline;
1772         YY_BREAK
1773 case 103:
1774 /* rule 103 can match eol */
1775 YY_RULE_SETUP
1776 #line 272 "lexer.l"
1777 cstate->lineno++; return tokv_newline;
1778         YY_BREAK
1779 case 104:
1780 YY_RULE_SETUP
1781 #line 273 "lexer.l"
1782 return parseerrprint("missing newline at eof after comment");
1783         YY_BREAK
1784 case 105:
1785 /* rule 105 can match eol */
1786 YY_RULE_SETUP
1787 #line 274 "lexer.l"
1788 {
1789                           countnewlines();
1790                           return dequote(yytext);
1791                         }
1792         YY_BREAK
1793 case 106:
1794 YY_RULE_SETUP
1795 #line 278 "lexer.l"
1796 return tokv_barestring;
1797         YY_BREAK
1798 case YY_STATE_EOF(INITIAL):
1799 #line 279 "lexer.l"
1800 return tokv_eof;
1801         YY_BREAK
1802 case 107:
1803 YY_RULE_SETUP
1804 #line 280 "lexer.l"
1805 return parseerrprint("misquoted or unterminated string");
1806         YY_BREAK
1807 case 108:
1808 YY_RULE_SETUP
1809 #line 281 "lexer.l"
1810 return parseerrprint("unexpected backslash");
1811         YY_BREAK
1812 case 109:
1813 YY_RULE_SETUP
1814 #line 282 "lexer.l"
1815 abort(); /* expect lex warning "rule cannot be matched" */
1816         YY_BREAK
1817 case 110:
1818 YY_RULE_SETUP
1819 #line 285 "lexer.l"
1820 ECHO;
1821         YY_BREAK
1822 #line 1823 "<stdout>"
1823
1824         case YY_END_OF_BUFFER:
1825                 {
1826                 /* Amount of text matched not including the EOB char. */
1827                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1828
1829                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1830                 *yy_cp = (yy_hold_char);
1831                 YY_RESTORE_YY_MORE_OFFSET
1832
1833                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1834                         {
1835                         /* We're scanning a new file or input source.  It's
1836                          * possible that this happened because the user
1837                          * just pointed yyin at a new source and called
1838                          * yylex().  If so, then we have to assure
1839                          * consistency between YY_CURRENT_BUFFER and our
1840                          * globals.  Here is the right place to do so, because
1841                          * this is the first action (other than possibly a
1842                          * back-up) that will match for the new input source.
1843                          */
1844                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1845                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1846                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1847                         }
1848
1849                 /* Note that here we test for yy_c_buf_p "<=" to the position
1850                  * of the first EOB in the buffer, since yy_c_buf_p will
1851                  * already have been incremented past the NUL character
1852                  * (since all states make transitions on EOB to the
1853                  * end-of-buffer state).  Contrast this with the test
1854                  * in input().
1855                  */
1856                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1857                         { /* This was really a NUL. */
1858                         yy_state_type yy_next_state;
1859
1860                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1861
1862                         yy_current_state = yy_get_previous_state(  );
1863
1864                         /* Okay, we're now positioned to make the NUL
1865                          * transition.  We couldn't have
1866                          * yy_get_previous_state() go ahead and do it
1867                          * for us because it doesn't know how to deal
1868                          * with the possibility of jamming (and we don't
1869                          * want to build jamming into it because then it
1870                          * will run more slowly).
1871                          */
1872
1873                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1874
1875                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1876
1877                         if ( yy_next_state )
1878                                 {
1879                                 /* Consume the NUL. */
1880                                 yy_cp = ++(yy_c_buf_p);
1881                                 yy_current_state = yy_next_state;
1882                                 goto yy_match;
1883                                 }
1884
1885                         else
1886                                 {
1887                                 yy_cp = (yy_c_buf_p);
1888                                 goto yy_find_action;
1889                                 }
1890                         }
1891
1892                 else switch ( yy_get_next_buffer(  ) )
1893                         {
1894                         case EOB_ACT_END_OF_FILE:
1895                                 {
1896                                 (yy_did_buffer_switch_on_eof) = 0;
1897
1898                                 if ( yywrap( ) )
1899                                         {
1900                                         /* Note: because we've taken care in
1901                                          * yy_get_next_buffer() to have set up
1902                                          * yytext, we can now set up
1903                                          * yy_c_buf_p so that if some total
1904                                          * hoser (like flex itself) wants to
1905                                          * call the scanner after we return the
1906                                          * YY_NULL, it'll still work - another
1907                                          * YY_NULL will get returned.
1908                                          */
1909                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1910
1911                                         yy_act = YY_STATE_EOF(YY_START);
1912                                         goto do_action;
1913                                         }
1914
1915                                 else
1916                                         {
1917                                         if ( ! (yy_did_buffer_switch_on_eof) )
1918                                                 YY_NEW_FILE;
1919                                         }
1920                                 break;
1921                                 }
1922
1923                         case EOB_ACT_CONTINUE_SCAN:
1924                                 (yy_c_buf_p) =
1925                                         (yytext_ptr) + yy_amount_of_matched_text;
1926
1927                                 yy_current_state = yy_get_previous_state(  );
1928
1929                                 yy_cp = (yy_c_buf_p);
1930                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1931                                 goto yy_match;
1932
1933                         case EOB_ACT_LAST_MATCH:
1934                                 (yy_c_buf_p) =
1935                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1936
1937                                 yy_current_state = yy_get_previous_state(  );
1938
1939                                 yy_cp = (yy_c_buf_p);
1940                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1941                                 goto yy_find_action;
1942                         }
1943                 break;
1944                 }
1945
1946         default:
1947                 YY_FATAL_ERROR(
1948                         "fatal flex scanner internal error--no action found" );
1949         } /* end of action switch */
1950                 } /* end of scanning one token */
1951         } /* end of user's declarations */
1952 } /* end of yylex */
1953
1954 /* yy_get_next_buffer - try to read in a new buffer
1955  *
1956  * Returns a code representing an action:
1957  *      EOB_ACT_LAST_MATCH -
1958  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1959  *      EOB_ACT_END_OF_FILE - end of file
1960  */
1961 static int yy_get_next_buffer (void)
1962 {
1963         char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1964         char *source = (yytext_ptr);
1965         int number_to_move, i;
1966         int ret_val;
1967
1968         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1969                 YY_FATAL_ERROR(
1970                 "fatal flex scanner internal error--end of buffer missed" );
1971
1972         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1973                 { /* Don't try to fill the buffer, so this is an EOF. */
1974                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1975                         {
1976                         /* We matched a single character, the EOB, so
1977                          * treat this as a final EOF.
1978                          */
1979                         return EOB_ACT_END_OF_FILE;
1980                         }
1981
1982                 else
1983                         {
1984                         /* We matched some text prior to the EOB, first
1985                          * process it.
1986                          */
1987                         return EOB_ACT_LAST_MATCH;
1988                         }
1989                 }
1990
1991         /* Try to read more data. */
1992
1993         /* First move last chars to start of buffer. */
1994         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1995
1996         for ( i = 0; i < number_to_move; ++i )
1997                 *(dest++) = *(source++);
1998
1999         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2000                 /* don't do the read, it's not guaranteed to return an EOF,
2001                  * just force an EOF
2002                  */
2003                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
2004
2005         else
2006                 {
2007                         int num_to_read =
2008                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2009
2010                 while ( num_to_read <= 0 )
2011                         { /* Not enough room in the buffer - grow it. */
2012
2013                         /* just a shorter name for the current buffer */
2014                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
2015
2016                         int yy_c_buf_p_offset =
2017                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
2018
2019                         if ( b->yy_is_our_buffer )
2020                                 {
2021                                 int new_size = b->yy_buf_size * 2;
2022
2023                                 if ( new_size <= 0 )
2024                                         b->yy_buf_size += b->yy_buf_size / 8;
2025                                 else
2026                                         b->yy_buf_size *= 2;
2027
2028                                 b->yy_ch_buf = (char *)
2029                                         /* Include room in for 2 EOB chars. */
2030                                         yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
2031                                 }
2032                         else
2033                                 /* Can't grow it, we don't own it. */
2034                                 b->yy_ch_buf = NULL;
2035
2036                         if ( ! b->yy_ch_buf )
2037                                 YY_FATAL_ERROR(
2038                                 "fatal error - scanner input buffer overflow" );
2039
2040                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
2041
2042                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
2043                                                 number_to_move - 1;
2044
2045                         }
2046
2047                 if ( num_to_read > YY_READ_BUF_SIZE )
2048                         num_to_read = YY_READ_BUF_SIZE;
2049
2050                 /* Read in more data. */
2051                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2052                         (yy_n_chars), num_to_read );
2053
2054                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2055                 }
2056
2057         if ( (yy_n_chars) == 0 )
2058                 {
2059                 if ( number_to_move == YY_MORE_ADJ )
2060                         {
2061                         ret_val = EOB_ACT_END_OF_FILE;
2062                         yyrestart(yyin  );
2063                         }
2064
2065                 else
2066                         {
2067                         ret_val = EOB_ACT_LAST_MATCH;
2068                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2069                                 YY_BUFFER_EOF_PENDING;
2070                         }
2071                 }
2072
2073         else
2074                 ret_val = EOB_ACT_CONTINUE_SCAN;
2075
2076         if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
2077                 /* Extend the array by 50%, plus the number we really need. */
2078                 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
2079                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
2080                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2081                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
2082         }
2083
2084         (yy_n_chars) += number_to_move;
2085         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
2086         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
2087
2088         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2089
2090         return ret_val;
2091 }
2092
2093 /* yy_get_previous_state - get the state just before the EOB char was reached */
2094
2095     static yy_state_type yy_get_previous_state (void)
2096 {
2097         yy_state_type yy_current_state;
2098         char *yy_cp;
2099
2100         yy_current_state = (yy_start);
2101
2102         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
2103                 {
2104                 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2105                 if ( yy_accept[yy_current_state] )
2106                         {
2107                         (yy_last_accepting_state) = yy_current_state;
2108                         (yy_last_accepting_cpos) = yy_cp;
2109                         }
2110                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2111                         {
2112                         yy_current_state = (int) yy_def[yy_current_state];
2113                         if ( yy_current_state >= 575 )
2114                                 yy_c = yy_meta[(unsigned int) yy_c];
2115                         }
2116                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
2117                 }
2118
2119         return yy_current_state;
2120 }
2121
2122 /* yy_try_NUL_trans - try to make a transition on the NUL character
2123  *
2124  * synopsis
2125  *      next_state = yy_try_NUL_trans( current_state );
2126  */
2127     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
2128 {
2129         int yy_is_jam;
2130         char *yy_cp = (yy_c_buf_p);
2131
2132         YY_CHAR yy_c = 1;
2133         if ( yy_accept[yy_current_state] )
2134                 {
2135                 (yy_last_accepting_state) = yy_current_state;
2136                 (yy_last_accepting_cpos) = yy_cp;
2137                 }
2138         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2139                 {
2140                 yy_current_state = (int) yy_def[yy_current_state];
2141                 if ( yy_current_state >= 575 )
2142                         yy_c = yy_meta[(unsigned int) yy_c];
2143                 }
2144         yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
2145         yy_is_jam = (yy_current_state == 574);
2146
2147                 return yy_is_jam ? 0 : yy_current_state;
2148 }
2149
2150 #ifndef YY_NO_UNPUT
2151
2152 #endif
2153
2154 #ifndef YY_NO_INPUT
2155 #ifdef __cplusplus
2156     static int yyinput (void)
2157 #else
2158     static int input  (void)
2159 #endif
2160
2161 {
2162         int c;
2163
2164         *(yy_c_buf_p) = (yy_hold_char);
2165
2166         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2167                 {
2168                 /* yy_c_buf_p now points to the character we want to return.
2169                  * If this occurs *before* the EOB characters, then it's a
2170                  * valid NUL; if not, then we've hit the end of the buffer.
2171                  */
2172                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2173                         /* This was really a NUL. */
2174                         *(yy_c_buf_p) = '\0';
2175
2176                 else
2177                         { /* need more input */
2178                         int offset = (yy_c_buf_p) - (yytext_ptr);
2179                         ++(yy_c_buf_p);
2180
2181                         switch ( yy_get_next_buffer(  ) )
2182                                 {
2183                                 case EOB_ACT_LAST_MATCH:
2184                                         /* This happens because yy_g_n_b()
2185                                          * sees that we've accumulated a
2186                                          * token and flags that we need to
2187                                          * try matching the token before
2188                                          * proceeding.  But for input(),
2189                                          * there's no matching to consider.
2190                                          * So convert the EOB_ACT_LAST_MATCH
2191                                          * to EOB_ACT_END_OF_FILE.
2192                                          */
2193
2194                                         /* Reset buffer status. */
2195                                         yyrestart(yyin );
2196
2197                                         /*FALLTHROUGH*/
2198
2199                                 case EOB_ACT_END_OF_FILE:
2200                                         {
2201                                         if ( yywrap( ) )
2202                                                 return 0;
2203
2204                                         if ( ! (yy_did_buffer_switch_on_eof) )
2205                                                 YY_NEW_FILE;
2206 #ifdef __cplusplus
2207                                         return yyinput();
2208 #else
2209                                         return input();
2210 #endif
2211                                         }
2212
2213                                 case EOB_ACT_CONTINUE_SCAN:
2214                                         (yy_c_buf_p) = (yytext_ptr) + offset;
2215                                         break;
2216                                 }
2217                         }
2218                 }
2219
2220         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
2221         *(yy_c_buf_p) = '\0';   /* preserve yytext */
2222         (yy_hold_char) = *++(yy_c_buf_p);
2223
2224         return c;
2225 }
2226 #endif  /* ifndef YY_NO_INPUT */
2227
2228 /** Immediately switch to a different input stream.
2229  * @param input_file A readable stream.
2230  *
2231  * @note This function does not reset the start condition to @c INITIAL .
2232  */
2233     void yyrestart  (FILE * input_file )
2234 {
2235
2236         if ( ! YY_CURRENT_BUFFER ){
2237         yyensure_buffer_stack ();
2238                 YY_CURRENT_BUFFER_LVALUE =
2239             yy_create_buffer(yyin,YY_BUF_SIZE );
2240         }
2241
2242         yy_init_buffer(YY_CURRENT_BUFFER,input_file );
2243         yy_load_buffer_state( );
2244 }
2245
2246 /** Switch to a different input buffer.
2247  * @param new_buffer The new input buffer.
2248  *
2249  */
2250     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
2251 {
2252
2253         /* TODO. We should be able to replace this entire function body
2254          * with
2255          *              yypop_buffer_state();
2256          *              yypush_buffer_state(new_buffer);
2257      */
2258         yyensure_buffer_stack ();
2259         if ( YY_CURRENT_BUFFER == new_buffer )
2260                 return;
2261
2262         if ( YY_CURRENT_BUFFER )
2263                 {
2264                 /* Flush out information for old buffer. */
2265                 *(yy_c_buf_p) = (yy_hold_char);
2266                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2267                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2268                 }
2269
2270         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2271         yy_load_buffer_state( );
2272
2273         /* We don't actually know whether we did this switch during
2274          * EOF (yywrap()) processing, but the only time this flag
2275          * is looked at is after yywrap() is called, so it's safe
2276          * to go ahead and always set it.
2277          */
2278         (yy_did_buffer_switch_on_eof) = 1;
2279 }
2280
2281 static void yy_load_buffer_state  (void)
2282 {
2283         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2284         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2285         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2286         (yy_hold_char) = *(yy_c_buf_p);
2287 }
2288
2289 /** Allocate and initialize an input buffer state.
2290  * @param file A readable stream.
2291  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2292  *
2293  * @return the allocated buffer state.
2294  */
2295     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
2296 {
2297         YY_BUFFER_STATE b;
2298
2299         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2300         if ( ! b )
2301                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2302
2303         b->yy_buf_size = (yy_size_t)size;
2304
2305         /* yy_ch_buf has to be 2 characters longer than the size given because
2306          * we need to put in 2 end-of-buffer characters.
2307          */
2308         b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
2309         if ( ! b->yy_ch_buf )
2310                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2311
2312         b->yy_is_our_buffer = 1;
2313
2314         yy_init_buffer(b,file );
2315
2316         return b;
2317 }
2318
2319 /** Destroy the buffer.
2320  * @param b a buffer created with yy_create_buffer()
2321  *
2322  */
2323     void yy_delete_buffer (YY_BUFFER_STATE  b )
2324 {
2325
2326         if ( ! b )
2327                 return;
2328
2329         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2330                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2331
2332         if ( b->yy_is_our_buffer )
2333                 yyfree((void *) b->yy_ch_buf  );
2334
2335         yyfree((void *) b  );
2336 }
2337
2338 /* Initializes or reinitializes a buffer.
2339  * This function is sometimes called more than once on the same buffer,
2340  * such as during a yyrestart() or at EOF.
2341  */
2342     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
2343
2344 {
2345         int oerrno = errno;
2346
2347         yy_flush_buffer(b );
2348
2349         b->yy_input_file = file;
2350         b->yy_fill_buffer = 1;
2351
2352     /* If b is the current buffer, then yy_init_buffer was _probably_
2353      * called from yyrestart() or through yy_get_next_buffer.
2354      * In that case, we don't want to reset the lineno or column.
2355      */
2356     if (b != YY_CURRENT_BUFFER){
2357         b->yy_bs_lineno = 1;
2358         b->yy_bs_column = 0;
2359     }
2360
2361         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2362
2363         errno = oerrno;
2364 }
2365
2366 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2367  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2368  *
2369  */
2370     void yy_flush_buffer (YY_BUFFER_STATE  b )
2371 {
2372         if ( ! b )
2373                 return;
2374
2375         b->yy_n_chars = 0;
2376
2377         /* We always need two end-of-buffer characters.  The first causes
2378          * a transition to the end-of-buffer state.  The second causes
2379          * a jam in that state.
2380          */
2381         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2382         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2383
2384         b->yy_buf_pos = &b->yy_ch_buf[0];
2385
2386         b->yy_at_bol = 1;
2387         b->yy_buffer_status = YY_BUFFER_NEW;
2388
2389         if ( b == YY_CURRENT_BUFFER )
2390                 yy_load_buffer_state( );
2391 }
2392
2393 /** Pushes the new state onto the stack. The new state becomes
2394  *  the current state. This function will allocate the stack
2395  *  if necessary.
2396  *  @param new_buffer The new state.
2397  *
2398  */
2399 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
2400 {
2401         if (new_buffer == NULL)
2402                 return;
2403
2404         yyensure_buffer_stack();
2405
2406         /* This block is copied from yy_switch_to_buffer. */
2407         if ( YY_CURRENT_BUFFER )
2408                 {
2409                 /* Flush out information for old buffer. */
2410                 *(yy_c_buf_p) = (yy_hold_char);
2411                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2412                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2413                 }
2414
2415         /* Only push if top exists. Otherwise, replace top. */
2416         if (YY_CURRENT_BUFFER)
2417                 (yy_buffer_stack_top)++;
2418         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2419
2420         /* copied from yy_switch_to_buffer. */
2421         yy_load_buffer_state( );
2422         (yy_did_buffer_switch_on_eof) = 1;
2423 }
2424
2425 /** Removes and deletes the top of the stack, if present.
2426  *  The next element becomes the new top.
2427  *
2428  */
2429 void yypop_buffer_state (void)
2430 {
2431         if (!YY_CURRENT_BUFFER)
2432                 return;
2433
2434         yy_delete_buffer(YY_CURRENT_BUFFER );
2435         YY_CURRENT_BUFFER_LVALUE = NULL;
2436         if ((yy_buffer_stack_top) > 0)
2437                 --(yy_buffer_stack_top);
2438
2439         if (YY_CURRENT_BUFFER) {
2440                 yy_load_buffer_state( );
2441                 (yy_did_buffer_switch_on_eof) = 1;
2442         }
2443 }
2444
2445 /* Allocates the stack if it does not exist.
2446  *  Guarantees space for at least one push.
2447  */
2448 static void yyensure_buffer_stack (void)
2449 {
2450         int num_to_alloc;
2451
2452         if (!(yy_buffer_stack)) {
2453
2454                 /* First allocation is just for 2 elements, since we don't know if this
2455                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2456                  * immediate realloc on the next call.
2457          */
2458       num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
2459                 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
2460                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
2461                                                                 );
2462                 if ( ! (yy_buffer_stack) )
2463                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2464
2465                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2466
2467                 (yy_buffer_stack_max) = num_to_alloc;
2468                 (yy_buffer_stack_top) = 0;
2469                 return;
2470         }
2471
2472         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2473
2474                 /* Increase the buffer to prepare for a possible push. */
2475                 yy_size_t grow_size = 8 /* arbitrary grow size */;
2476
2477                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
2478                 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
2479                                                                 ((yy_buffer_stack),
2480                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
2481                                                                 );
2482                 if ( ! (yy_buffer_stack) )
2483                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2484
2485                 /* zero only the new slots.*/
2486                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2487                 (yy_buffer_stack_max) = num_to_alloc;
2488         }
2489 }
2490
2491 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2492  * @param base the character buffer
2493  * @param size the size in bytes of the character buffer
2494  *
2495  * @return the newly allocated buffer state object.
2496  */
2497 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
2498 {
2499         YY_BUFFER_STATE b;
2500
2501         if ( size < 2 ||
2502              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2503              base[size-1] != YY_END_OF_BUFFER_CHAR )
2504                 /* They forgot to leave room for the EOB's. */
2505                 return NULL;
2506
2507         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2508         if ( ! b )
2509                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2510
2511         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2512         b->yy_buf_pos = b->yy_ch_buf = base;
2513         b->yy_is_our_buffer = 0;
2514         b->yy_input_file = NULL;
2515         b->yy_n_chars = b->yy_buf_size;
2516         b->yy_is_interactive = 0;
2517         b->yy_at_bol = 1;
2518         b->yy_fill_buffer = 0;
2519         b->yy_buffer_status = YY_BUFFER_NEW;
2520
2521         yy_switch_to_buffer(b  );
2522
2523         return b;
2524 }
2525
2526 /** Setup the input buffer state to scan a string. The next call to yylex() will
2527  * scan from a @e copy of @a str.
2528  * @param yystr a NUL-terminated string to scan
2529  *
2530  * @return the newly allocated buffer state object.
2531  * @note If you want to scan bytes that may contain NUL values, then use
2532  *       yy_scan_bytes() instead.
2533  */
2534 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
2535 {
2536
2537         return yy_scan_bytes(yystr,(int) strlen(yystr) );
2538 }
2539
2540 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2541  * scan from a @e copy of @a bytes.
2542  * @param yybytes the byte buffer to scan
2543  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2544  *
2545  * @return the newly allocated buffer state object.
2546  */
2547 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
2548 {
2549         YY_BUFFER_STATE b;
2550         char *buf;
2551         yy_size_t n;
2552         int i;
2553
2554         /* Get memory for full buffer, including space for trailing EOB's. */
2555         n = (yy_size_t) (_yybytes_len + 2);
2556         buf = (char *) yyalloc(n  );
2557         if ( ! buf )
2558                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2559
2560         for ( i = 0; i < _yybytes_len; ++i )
2561                 buf[i] = yybytes[i];
2562
2563         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2564
2565         b = yy_scan_buffer(buf,n );
2566         if ( ! b )
2567                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2568
2569         /* It's okay to grow etc. this buffer, and we should throw it
2570          * away when we're done.
2571          */
2572         b->yy_is_our_buffer = 1;
2573
2574         return b;
2575 }
2576
2577 #ifndef YY_EXIT_FAILURE
2578 #define YY_EXIT_FAILURE 2
2579 #endif
2580
2581 static void yynoreturn yy_fatal_error (yyconst char* msg )
2582 {
2583                         (void) fprintf( stderr, "%s\n", msg );
2584         exit( YY_EXIT_FAILURE );
2585 }
2586
2587 /* Redefine yyless() so it works in section 3 code. */
2588
2589 #undef yyless
2590 #define yyless(n) \
2591         do \
2592                 { \
2593                 /* Undo effects of setting up yytext. */ \
2594         int yyless_macro_arg = (n); \
2595         YY_LESS_LINENO(yyless_macro_arg);\
2596                 yytext[yyleng] = (yy_hold_char); \
2597                 (yy_c_buf_p) = yytext + yyless_macro_arg; \
2598                 (yy_hold_char) = *(yy_c_buf_p); \
2599                 *(yy_c_buf_p) = '\0'; \
2600                 yyleng = yyless_macro_arg; \
2601                 } \
2602         while ( 0 )
2603
2604 /* Accessor  methods (get/set functions) to struct members. */
2605
2606 /** Get the current line number.
2607  *
2608  */
2609 int yyget_lineno  (void)
2610 {
2611
2612     return yylineno;
2613 }
2614
2615 /** Get the input stream.
2616  *
2617  */
2618 FILE *yyget_in  (void)
2619 {
2620         return yyin;
2621 }
2622
2623 /** Get the output stream.
2624  *
2625  */
2626 FILE *yyget_out  (void)
2627 {
2628         return yyout;
2629 }
2630
2631 /** Get the length of the current token.
2632  *
2633  */
2634 int yyget_leng  (void)
2635 {
2636         return yyleng;
2637 }
2638
2639 /** Get the current token.
2640  *
2641  */
2642
2643 char *yyget_text  (void)
2644 {
2645         return yytext;
2646 }
2647
2648 /** Set the current line number.
2649  * @param _line_number line number
2650  *
2651  */
2652 void yyset_lineno (int  _line_number )
2653 {
2654
2655     yylineno = _line_number;
2656 }
2657
2658 /** Set the input stream. This does not discard the current
2659  * input buffer.
2660  * @param _in_str A readable stream.
2661  *
2662  * @see yy_switch_to_buffer
2663  */
2664 void yyset_in (FILE *  _in_str )
2665 {
2666         yyin = _in_str ;
2667 }
2668
2669 void yyset_out (FILE *  _out_str )
2670 {
2671         yyout = _out_str ;
2672 }
2673
2674 int yyget_debug  (void)
2675 {
2676         return yy_flex_debug;
2677 }
2678
2679 void yyset_debug (int  _bdebug )
2680 {
2681         yy_flex_debug = _bdebug ;
2682 }
2683
2684 static int yy_init_globals (void)
2685 {
2686         /* Initialization is the same as for the non-reentrant scanner.
2687      * This function is called from yylex_destroy(), so don't allocate here.
2688      */
2689
2690     (yy_buffer_stack) = NULL;
2691     (yy_buffer_stack_top) = 0;
2692     (yy_buffer_stack_max) = 0;
2693     (yy_c_buf_p) = NULL;
2694     (yy_init) = 0;
2695     (yy_start) = 0;
2696
2697 /* Defined in main.c */
2698 #ifdef YY_STDINIT
2699     yyin = stdin;
2700     yyout = stdout;
2701 #else
2702     yyin = NULL;
2703     yyout = NULL;
2704 #endif
2705
2706     /* For future reference: Set errno on error, since we are called by
2707      * yylex_init()
2708      */
2709     return 0;
2710 }
2711
2712 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2713 int yylex_destroy  (void)
2714 {
2715
2716     /* Pop the buffer stack, destroying each element. */
2717         while(YY_CURRENT_BUFFER){
2718                 yy_delete_buffer(YY_CURRENT_BUFFER  );
2719                 YY_CURRENT_BUFFER_LVALUE = NULL;
2720                 yypop_buffer_state();
2721         }
2722
2723         /* Destroy the stack itself. */
2724         yyfree((yy_buffer_stack) );
2725         (yy_buffer_stack) = NULL;
2726
2727     /* Reset the globals. This is important in a non-reentrant scanner so the next time
2728      * yylex() is called, initialization will occur. */
2729     yy_init_globals( );
2730
2731     return 0;
2732 }
2733
2734 /*
2735  * Internal utility routines.
2736  */
2737
2738 #ifndef yytext_ptr
2739 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2740 {
2741
2742         int i;
2743         for ( i = 0; i < n; ++i )
2744                 s1[i] = s2[i];
2745 }
2746 #endif
2747
2748 #ifdef YY_NEED_STRLEN
2749 static int yy_flex_strlen (yyconst char * s )
2750 {
2751         int n;
2752         for ( n = 0; s[n]; ++n )
2753                 ;
2754
2755         return n;
2756 }
2757 #endif
2758
2759 void *yyalloc (yy_size_t  size )
2760 {
2761                         return malloc(size);
2762 }
2763
2764 void *yyrealloc  (void * ptr, yy_size_t  size )
2765 {
2766
2767         /* The cast to (char *) in the following accommodates both
2768          * implementations that use char* generic pointers, and those
2769          * that use void* generic pointers.  It works with the latter
2770          * because both ANSI C and C++ allow castless assignment from
2771          * any pointer type to void*, and deal with argument conversions
2772          * as though doing an assignment.
2773          */
2774         return realloc(ptr, size);
2775 }
2776
2777 void yyfree (void * ptr )
2778 {
2779                         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
2780 }
2781
2782 #define YYTABLES_NAME "yytables"
2783
2784 #line 285 "lexer.l"
2785
2786
2787
2788 const char *const builtinservicehelpstrings[]= {
2789   "environment",
2790   "parameter <parameter>",
2791   "version",
2792   "toplevel",
2793   "override",
2794   "shutdown",
2795   "reset",
2796   "execute",
2797   "help",
2798    0
2799 };
2800
2801 #include "parser.c"
2802
2803