git.gag.com Git - debian/amanda/blob - recover-src/uscan.c

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