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