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