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 case 29:
1011 YY_RULE_SETUP
1012 #line 99 "uscan.l"
1013 { return TAR; }
1014         YY_BREAK
1015 case 30:
1016 YY_RULE_SETUP
1017 #line 100 "uscan.l"
1018 { return MODE; }
1019         YY_BREAK
1020
1021     /* dates */
1022
1023 case 31:
1024 YY_RULE_SETUP
1025 #line 106 "uscan.l"
1026 { return ll_parse_date(1, yytext); }
1027         YY_BREAK
1028 case 32:
1029 YY_RULE_SETUP
1030 #line 107 "uscan.l"
1031 { return ll_parse_date(2, yytext); }
1032         YY_BREAK
1033 case 33:
1034 YY_RULE_SETUP
1035 #line 108 "uscan.l"
1036 { return ll_parse_date(3, yytext); }
1037         YY_BREAK
1038 case 34:
1039 YY_RULE_SETUP
1040 #line 109 "uscan.l"
1041 { return ll_parse_date(4, yytext); }
1042         YY_BREAK
1043 case 35:
1044 YY_RULE_SETUP
1045 #line 110 "uscan.l"
1046 { return ll_parse_date(5, yytext); }
1047         YY_BREAK
1048
1049     /* quoted file names */
1050
1051 case 36:
1052 YY_RULE_SETUP
1053 #line 116 "uscan.l"
1054 {
1055     if(string_buf != NULL) {
1056         g_printf("ERROR:string_buf != NULL: %s\n",string_buf);
1057     }
1058     BEGIN(quotedpath);
1059     strappend(string_buf, yytext);
1060 }
1061         YY_BREAK
1062 case 37:
1063 /* rule 37 can match eol */
1064 YY_RULE_SETUP
1065 #line 124 "uscan.l"
1066 {
1067     strappend(string_buf, yytext);
1068 }
1069         YY_BREAK
1070 case 38:
1071 YY_RULE_SETUP
1072 #line 128 "uscan.l"
1073 {
1074     /* escaped character (including quote) */
1075     strappend(string_buf, yytext);
1076 }
1077         YY_BREAK
1078 case 39:
1079 YY_RULE_SETUP
1080 #line 133 "uscan.l"
1081 { /* saw closing quote - all done */
1082     strappend(string_buf, yytext);
1083     yylval.strval = string_buf;
1084     string_buf = NULL;
1085     BEGIN(INITIAL);
1086     return PATH;
1087 }
1088         YY_BREAK
1089
1090     /* file names */
1091
1092 case 40:
1093 YY_RULE_SETUP
1094 #line 145 "uscan.l"
1095 {
1096     yylval.strval = stralloc(yytext);
1097     return PATH;
1098 }
1099         YY_BREAK
1100
1101     /* whitespace */
1102
1103 case 41:
1104 /* rule 41 can match eol */
1105 YY_RULE_SETUP
1106 #line 154 "uscan.l"
1107 ;     /* whitespace */
1108         YY_BREAK
1109
1110     /* anything else */
1111     /* everything should have been handled by now, so this rule is disabled */
1112
1113
1114 #if 0
1115 .       { yyerror("invalid character"); }
1116 #endif
1117
1118 case 42:
1119 YY_RULE_SETUP
1120 #line 167 "uscan.l"
1121 ECHO;
1122         YY_BREAK
1123 #line 1124 "uscan.c"
1124 case YY_STATE_EOF(INITIAL):
1125 case YY_STATE_EOF(quotedpath):
1126         yyterminate();
1127
1128         case YY_END_OF_BUFFER:
1129                 {
1130                 /* Amount of text matched not including the EOB char. */
1131                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1132
1133                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1134                 *yy_cp = (yy_hold_char);
1135                 YY_RESTORE_YY_MORE_OFFSET
1136
1137                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1138                         {
1139                         /* We're scanning a new file or input source.  It's
1140                          * possible that this happened because the user
1141                          * just pointed yyin at a new source and called
1142                          * yylex().  If so, then we have to assure
1143                          * consistency between YY_CURRENT_BUFFER and our
1144                          * globals.  Here is the right place to do so, because
1145                          * this is the first action (other than possibly a
1146                          * back-up) that will match for the new input source.
1147                          */
1148                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1149                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1150                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1151                         }
1152
1153                 /* Note that here we test for yy_c_buf_p "<=" to the position
1154                  * of the first EOB in the buffer, since yy_c_buf_p will
1155                  * already have been incremented past the NUL character
1156                  * (since all states make transitions on EOB to the
1157                  * end-of-buffer state).  Contrast this with the test
1158                  * in input().
1159                  */
1160                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1161                         { /* This was really a NUL. */
1162                         yy_state_type yy_next_state;
1163
1164                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1165
1166                         yy_current_state = yy_get_previous_state(  );
1167
1168                         /* Okay, we're now positioned to make the NUL
1169                          * transition.  We couldn't have
1170                          * yy_get_previous_state() go ahead and do it
1171                          * for us because it doesn't know how to deal
1172                          * with the possibility of jamming (and we don't
1173                          * want to build jamming into it because then it
1174                          * will run more slowly).
1175                          */
1176
1177                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1178
1179                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1180
1181                         if ( yy_next_state )
1182                                 {
1183                                 /* Consume the NUL. */
1184                                 yy_cp = ++(yy_c_buf_p);
1185                                 yy_current_state = yy_next_state;
1186                                 goto yy_match;
1187                                 }
1188
1189                         else
1190                                 {
1191                                 yy_cp = (yy_c_buf_p);
1192                                 goto yy_find_action;
1193                                 }
1194                         }
1195
1196                 else switch ( yy_get_next_buffer(  ) )
1197                         {
1198                         case EOB_ACT_END_OF_FILE:
1199                                 {
1200                                 (yy_did_buffer_switch_on_eof) = 0;
1201
1202                                 if ( yywrap( ) )
1203                                         {
1204                                         /* Note: because we've taken care in
1205                                          * yy_get_next_buffer() to have set up
1206                                          * yytext, we can now set up
1207                                          * yy_c_buf_p so that if some total
1208                                          * hoser (like flex itself) wants to
1209                                          * call the scanner after we return the
1210                                          * YY_NULL, it'll still work - another
1211                                          * YY_NULL will get returned.
1212                                          */
1213                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1214
1215                                         yy_act = YY_STATE_EOF(YY_START);
1216                                         goto do_action;
1217                                         }
1218
1219                                 else
1220                                         {
1221                                         if ( ! (yy_did_buffer_switch_on_eof) )
1222                                                 YY_NEW_FILE;
1223                                         }
1224                                 break;
1225                                 }
1226
1227                         case EOB_ACT_CONTINUE_SCAN:
1228                                 (yy_c_buf_p) =
1229                                         (yytext_ptr) + yy_amount_of_matched_text;
1230
1231                                 yy_current_state = yy_get_previous_state(  );
1232
1233                                 yy_cp = (yy_c_buf_p);
1234                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1235                                 goto yy_match;
1236
1237                         case EOB_ACT_LAST_MATCH:
1238                                 (yy_c_buf_p) =
1239                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1240
1241                                 yy_current_state = yy_get_previous_state(  );
1242
1243                                 yy_cp = (yy_c_buf_p);
1244                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1245                                 goto yy_find_action;
1246                         }
1247                 break;
1248                 }
1249
1250         default:
1251                 YY_FATAL_ERROR(
1252                         "fatal flex scanner internal error--no action found" );
1253         } /* end of action switch */
1254                 } /* end of scanning one token */
1255 } /* end of yylex */
1256
1257 /* yy_get_next_buffer - try to read in a new buffer
1258  *
1259  * Returns a code representing an action:
1260  *      EOB_ACT_LAST_MATCH -
1261  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1262  *      EOB_ACT_END_OF_FILE - end of file
1263  */
1264 static int yy_get_next_buffer (void)
1265 {
1266         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1267         register char *source = (yytext_ptr);
1268         register int number_to_move, i;
1269         int ret_val;
1270
1271         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1272                 YY_FATAL_ERROR(
1273                 "fatal flex scanner internal error--end of buffer missed" );
1274
1275         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1276                 { /* Don't try to fill the buffer, so this is an EOF. */
1277                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1278                         {
1279                         /* We matched a single character, the EOB, so
1280                          * treat this as a final EOF.
1281                          */
1282                         return EOB_ACT_END_OF_FILE;
1283                         }
1284
1285                 else
1286                         {
1287                         /* We matched some text prior to the EOB, first
1288                          * process it.
1289                          */
1290                         return EOB_ACT_LAST_MATCH;
1291                         }
1292                 }
1293
1294         /* Try to read more data. */
1295
1296         /* First move last chars to start of buffer. */
1297         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1298
1299         for ( i = 0; i < number_to_move; ++i )
1300                 *(dest++) = *(source++);
1301
1302         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1303                 /* don't do the read, it's not guaranteed to return an EOF,
1304                  * just force an EOF
1305                  */
1306                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1307
1308         else
1309                 {
1310                         int num_to_read =
1311                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1312
1313                 while ( num_to_read <= 0 )
1314                         { /* Not enough room in the buffer - grow it. */
1315
1316                         /* just a shorter name for the current buffer */
1317                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1318
1319                         int yy_c_buf_p_offset =
1320                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1321
1322                         if ( b->yy_is_our_buffer )
1323                                 {
1324                                 int new_size = b->yy_buf_size * 2;
1325
1326                                 if ( new_size <= 0 )
1327                                         b->yy_buf_size += b->yy_buf_size / 8;
1328                                 else
1329                                         b->yy_buf_size *= 2;
1330
1331                                 b->yy_ch_buf = (char *)
1332                                         /* Include room in for 2 EOB chars. */
1333                                         yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1334                                 }
1335                         else
1336                                 /* Can't grow it, we don't own it. */
1337                                 b->yy_ch_buf = 0;
1338
1339                         if ( ! b->yy_ch_buf )
1340                                 YY_FATAL_ERROR(
1341                                 "fatal error - scanner input buffer overflow" );
1342
1343                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1344
1345                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1346                                                 number_to_move - 1;
1347
1348                         }
1349
1350                 if ( num_to_read > YY_READ_BUF_SIZE )
1351                         num_to_read = YY_READ_BUF_SIZE;
1352
1353                 /* Read in more data. */
1354                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1355                         (yy_n_chars), num_to_read );
1356
1357                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1358                 }
1359
1360         if ( (yy_n_chars) == 0 )
1361                 {
1362                 if ( number_to_move == YY_MORE_ADJ )
1363                         {
1364                         ret_val = EOB_ACT_END_OF_FILE;
1365                         yyrestart(yyin  );
1366                         }
1367
1368                 else
1369                         {
1370                         ret_val = EOB_ACT_LAST_MATCH;
1371                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1372                                 YY_BUFFER_EOF_PENDING;
1373                         }
1374                 }
1375
1376         else
1377                 ret_val = EOB_ACT_CONTINUE_SCAN;
1378
1379         (yy_n_chars) += number_to_move;
1380         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1381         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1382
1383         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1384
1385         return ret_val;
1386 }
1387
1388 /* yy_get_previous_state - get the state just before the EOB char was reached */
1389
1390     static yy_state_type yy_get_previous_state (void)
1391 {
1392         register yy_state_type yy_current_state;
1393         register char *yy_cp;
1394
1395         yy_current_state = (yy_start);
1396
1397         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1398                 {
1399                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1400                 if ( yy_accept[yy_current_state] )
1401                         {
1402                         (yy_last_accepting_state) = yy_current_state;
1403                         (yy_last_accepting_cpos) = yy_cp;
1404                         }
1405                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1406                         {
1407                         yy_current_state = (int) yy_def[yy_current_state];
1408                         if ( yy_current_state >= 137 )
1409                                 yy_c = yy_meta[(unsigned int) yy_c];
1410                         }
1411                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1412                 }
1413
1414         return yy_current_state;
1415 }
1416
1417 /* yy_try_NUL_trans - try to make a transition on the NUL character
1418  *
1419  * synopsis
1420  *      next_state = yy_try_NUL_trans( current_state );
1421  */
1422     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1423 {
1424         register int yy_is_jam;
1425         register char *yy_cp = (yy_c_buf_p);
1426
1427         register YY_CHAR yy_c = 1;
1428         if ( yy_accept[yy_current_state] )
1429                 {
1430                 (yy_last_accepting_state) = yy_current_state;
1431                 (yy_last_accepting_cpos) = yy_cp;
1432                 }
1433         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1434                 {
1435                 yy_current_state = (int) yy_def[yy_current_state];
1436                 if ( yy_current_state >= 137 )
1437                         yy_c = yy_meta[(unsigned int) yy_c];
1438                 }
1439         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1440         yy_is_jam = (yy_current_state == 136);
1441
1442         return yy_is_jam ? 0 : yy_current_state;
1443 }
1444
1445     static void yyunput (int c, register char * yy_bp )
1446 {
1447         register char *yy_cp;
1448
1449     yy_cp = (yy_c_buf_p);
1450
1451         /* undo effects of setting up yytext */
1452         *yy_cp = (yy_hold_char);
1453
1454         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1455                 { /* need to shift things up to make room */
1456                 /* +2 for EOB chars. */
1457                 register int number_to_move = (yy_n_chars) + 2;
1458                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1459                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1460                 register char *source =
1461                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1462
1463                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1464                         *--dest = *--source;
1465
1466                 yy_cp += (int) (dest - source);
1467                 yy_bp += (int) (dest - source);
1468                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1469                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1470
1471                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1472                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1473                 }
1474
1475         *--yy_cp = (char) c;
1476
1477         (yytext_ptr) = yy_bp;
1478         (yy_hold_char) = *yy_cp;
1479         (yy_c_buf_p) = yy_cp;
1480 }
1481
1482 #ifndef YY_NO_INPUT
1483 #ifdef __cplusplus
1484     static int yyinput (void)
1485 #else
1486     static int input  (void)
1487 #endif
1488
1489 {
1490         int c;
1491
1492         *(yy_c_buf_p) = (yy_hold_char);
1493
1494         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1495                 {
1496                 /* yy_c_buf_p now points to the character we want to return.
1497                  * If this occurs *before* the EOB characters, then it's a
1498                  * valid NUL; if not, then we've hit the end of the buffer.
1499                  */
1500                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1501                         /* This was really a NUL. */
1502                         *(yy_c_buf_p) = '\0';
1503
1504                 else
1505                         { /* need more input */
1506                         int offset = (yy_c_buf_p) - (yytext_ptr);
1507                         ++(yy_c_buf_p);
1508
1509                         switch ( yy_get_next_buffer(  ) )
1510                                 {
1511                                 case EOB_ACT_LAST_MATCH:
1512                                         /* This happens because yy_g_n_b()
1513                                          * sees that we've accumulated a
1514                                          * token and flags that we need to
1515                                          * try matching the token before
1516                                          * proceeding.  But for input(),
1517                                          * there's no matching to consider.
1518                                          * So convert the EOB_ACT_LAST_MATCH
1519                                          * to EOB_ACT_END_OF_FILE.
1520                                          */
1521
1522                                         /* Reset buffer status. */
1523                                         yyrestart(yyin );
1524
1525                                         /*FALLTHROUGH*/
1526
1527                                 case EOB_ACT_END_OF_FILE:
1528                                         {
1529                                         if ( yywrap( ) )
1530                                                 return EOF;
1531
1532                                         if ( ! (yy_did_buffer_switch_on_eof) )
1533                                                 YY_NEW_FILE;
1534 #ifdef __cplusplus
1535                                         return yyinput();
1536 #else
1537                                         return input();
1538 #endif
1539                                         }
1540
1541                                 case EOB_ACT_CONTINUE_SCAN:
1542                                         (yy_c_buf_p) = (yytext_ptr) + offset;
1543                                         break;
1544                                 }
1545                         }
1546                 }
1547
1548         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1549         *(yy_c_buf_p) = '\0';   /* preserve yytext */
1550         (yy_hold_char) = *++(yy_c_buf_p);
1551
1552         return c;
1553 }
1554 #endif  /* ifndef YY_NO_INPUT */
1555
1556 /** Immediately switch to a different input stream.
1557  * @param input_file A readable stream.
1558  *
1559  * @note This function does not reset the start condition to @c INITIAL .
1560  */
1561     void yyrestart  (FILE * input_file )
1562 {
1563
1564         if ( ! YY_CURRENT_BUFFER ){
1565         yyensure_buffer_stack ();
1566                 YY_CURRENT_BUFFER_LVALUE =
1567             yy_create_buffer(yyin,YY_BUF_SIZE );
1568         }
1569
1570         yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1571         yy_load_buffer_state( );
1572 }
1573
1574 /** Switch to a different input buffer.
1575  * @param new_buffer The new input buffer.
1576  *
1577  */
1578     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1579 {
1580
1581         /* TODO. We should be able to replace this entire function body
1582          * with
1583          *              yypop_buffer_state();
1584          *              yypush_buffer_state(new_buffer);
1585      */
1586         yyensure_buffer_stack ();
1587         if ( YY_CURRENT_BUFFER == new_buffer )
1588                 return;
1589
1590         if ( YY_CURRENT_BUFFER )
1591                 {
1592                 /* Flush out information for old buffer. */
1593                 *(yy_c_buf_p) = (yy_hold_char);
1594                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1595                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1596                 }
1597
1598         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1599         yy_load_buffer_state( );
1600
1601         /* We don't actually know whether we did this switch during
1602          * EOF (yywrap()) processing, but the only time this flag
1603          * is looked at is after yywrap() is called, so it's safe
1604          * to go ahead and always set it.
1605          */
1606         (yy_did_buffer_switch_on_eof) = 1;
1607 }
1608
1609 static void yy_load_buffer_state  (void)
1610 {
1611         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1612         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1613         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1614         (yy_hold_char) = *(yy_c_buf_p);
1615 }
1616
1617 /** Allocate and initialize an input buffer state.
1618  * @param file A readable stream.
1619  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1620  *
1621  * @return the allocated buffer state.
1622  */
1623     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
1624 {
1625         YY_BUFFER_STATE b;
1626
1627         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
1628         if ( ! b )
1629                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1630
1631         b->yy_buf_size = size;
1632
1633         /* yy_ch_buf has to be 2 characters longer than the size given because
1634          * we need to put in 2 end-of-buffer characters.
1635          */
1636         b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
1637         if ( ! b->yy_ch_buf )
1638                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1639
1640         b->yy_is_our_buffer = 1;
1641
1642         yy_init_buffer(b,file );
1643
1644         return b;
1645 }
1646
1647 /** Destroy the buffer.
1648  * @param b a buffer created with yy_create_buffer()
1649  *
1650  */
1651     void yy_delete_buffer (YY_BUFFER_STATE  b )
1652 {
1653
1654         if ( ! b )
1655                 return;
1656
1657         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1658                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1659
1660         if ( b->yy_is_our_buffer )
1661                 yyfree((void *) b->yy_ch_buf  );
1662
1663         yyfree((void *) b  );
1664 }
1665
1666 #ifndef __cplusplus
1667 extern int isatty (int );
1668 #endif /* __cplusplus */
1669
1670 /* Initializes or reinitializes a buffer.
1671  * This function is sometimes called more than once on the same buffer,
1672  * such as during a yyrestart() or at EOF.
1673  */
1674     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
1675
1676 {
1677         int oerrno = errno;
1678
1679         yy_flush_buffer(b );
1680
1681         b->yy_input_file = file;
1682         b->yy_fill_buffer = 1;
1683
1684     /* If b is the current buffer, then yy_init_buffer was _probably_
1685      * called from yyrestart() or through yy_get_next_buffer.
1686      * In that case, we don't want to reset the lineno or column.
1687      */
1688     if (b != YY_CURRENT_BUFFER){
1689         b->yy_bs_lineno = 1;
1690         b->yy_bs_column = 0;
1691     }
1692
1693         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1694
1695         errno = oerrno;
1696 }
1697
1698 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1699  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1700  *
1701  */
1702     void yy_flush_buffer (YY_BUFFER_STATE  b )
1703 {
1704         if ( ! b )
1705                 return;
1706
1707         b->yy_n_chars = 0;
1708
1709         /* We always need two end-of-buffer characters.  The first causes
1710          * a transition to the end-of-buffer state.  The second causes
1711          * a jam in that state.
1712          */
1713         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1714         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1715
1716         b->yy_buf_pos = &b->yy_ch_buf[0];
1717
1718         b->yy_at_bol = 1;
1719         b->yy_buffer_status = YY_BUFFER_NEW;
1720
1721         if ( b == YY_CURRENT_BUFFER )
1722                 yy_load_buffer_state( );
1723 }
1724
1725 /** Pushes the new state onto the stack. The new state becomes
1726  *  the current state. This function will allocate the stack
1727  *  if necessary.
1728  *  @param new_buffer The new state.
1729  *
1730  */
1731 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1732 {
1733         if (new_buffer == NULL)
1734                 return;
1735
1736         yyensure_buffer_stack();
1737
1738         /* This block is copied from yy_switch_to_buffer. */
1739         if ( YY_CURRENT_BUFFER )
1740                 {
1741                 /* Flush out information for old buffer. */
1742                 *(yy_c_buf_p) = (yy_hold_char);
1743                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1744                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1745                 }
1746
1747         /* Only push if top exists. Otherwise, replace top. */
1748         if (YY_CURRENT_BUFFER)
1749                 (yy_buffer_stack_top)++;
1750         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1751
1752         /* copied from yy_switch_to_buffer. */
1753         yy_load_buffer_state( );
1754         (yy_did_buffer_switch_on_eof) = 1;
1755 }
1756
1757 /** Removes and deletes the top of the stack, if present.
1758  *  The next element becomes the new top.
1759  *
1760  */
1761 void yypop_buffer_state (void)
1762 {
1763         if (!YY_CURRENT_BUFFER)
1764                 return;
1765
1766         yy_delete_buffer(YY_CURRENT_BUFFER );
1767         YY_CURRENT_BUFFER_LVALUE = NULL;
1768         if ((yy_buffer_stack_top) > 0)
1769                 --(yy_buffer_stack_top);
1770
1771         if (YY_CURRENT_BUFFER) {
1772                 yy_load_buffer_state( );
1773                 (yy_did_buffer_switch_on_eof) = 1;
1774         }
1775 }
1776
1777 /* Allocates the stack if it does not exist.
1778  *  Guarantees space for at least one push.
1779  */
1780 static void yyensure_buffer_stack (void)
1781 {
1782         int num_to_alloc;
1783
1784         if (!(yy_buffer_stack)) {
1785
1786                 /* First allocation is just for 2 elements, since we don't know if this
1787                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1788                  * immediate realloc on the next call.
1789          */
1790                 num_to_alloc = 1;
1791                 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
1792                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
1793                                                                 );
1794
1795                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1796
1797                 (yy_buffer_stack_max) = num_to_alloc;
1798                 (yy_buffer_stack_top) = 0;
1799                 return;
1800         }
1801
1802         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1803
1804                 /* Increase the buffer to prepare for a possible push. */
1805                 int grow_size = 8 /* arbitrary grow size */;
1806
1807                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1808                 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
1809                                                                 ((yy_buffer_stack),
1810                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
1811                                                                 );
1812
1813                 /* zero only the new slots.*/
1814                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1815                 (yy_buffer_stack_max) = num_to_alloc;
1816         }
1817 }
1818
1819 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1820  * @param base the character buffer
1821  * @param size the size in bytes of the character buffer
1822  *
1823  * @return the newly allocated buffer state object.
1824  */
1825 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
1826 {
1827         YY_BUFFER_STATE b;
1828
1829         if ( size < 2 ||
1830              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1831              base[size-1] != YY_END_OF_BUFFER_CHAR )
1832                 /* They forgot to leave room for the EOB's. */
1833                 return 0;
1834
1835         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
1836         if ( ! b )
1837                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1838
1839         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1840         b->yy_buf_pos = b->yy_ch_buf = base;
1841         b->yy_is_our_buffer = 0;
1842         b->yy_input_file = 0;
1843         b->yy_n_chars = b->yy_buf_size;
1844         b->yy_is_interactive = 0;
1845         b->yy_at_bol = 1;
1846         b->yy_fill_buffer = 0;
1847         b->yy_buffer_status = YY_BUFFER_NEW;
1848
1849         yy_switch_to_buffer(b  );
1850
1851         return b;
1852 }
1853
1854 /** Setup the input buffer state to scan a string. The next call to yylex() will
1855  * scan from a @e copy of @a str.
1856  * @param str a NUL-terminated string to scan
1857  *
1858  * @return the newly allocated buffer state object.
1859  * @note If you want to scan bytes that may contain NUL values, then use
1860  *       yy_scan_bytes() instead.
1861  */
1862 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
1863 {
1864
1865         return yy_scan_bytes(yystr,strlen(yystr) );
1866 }
1867
1868 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1869  * scan from a @e copy of @a bytes.
1870  * @param bytes the byte buffer to scan
1871  * @param len the number of bytes in the buffer pointed to by @a bytes.
1872  *
1873  * @return the newly allocated buffer state object.
1874  */
1875 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
1876 {
1877         YY_BUFFER_STATE b;
1878         char *buf;
1879         yy_size_t n;
1880         int i;
1881
1882         /* Get memory for full buffer, including space for trailing EOB's. */
1883         n = _yybytes_len + 2;
1884         buf = (char *) yyalloc(n  );
1885         if ( ! buf )
1886                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1887
1888         for ( i = 0; i < _yybytes_len; ++i )
1889                 buf[i] = yybytes[i];
1890
1891         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1892
1893         b = yy_scan_buffer(buf,n );
1894         if ( ! b )
1895                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1896
1897         /* It's okay to grow etc. this buffer, and we should throw it
1898          * away when we're done.
1899          */
1900         b->yy_is_our_buffer = 1;
1901
1902         return b;
1903 }
1904
1905 #ifndef YY_EXIT_FAILURE
1906 #define YY_EXIT_FAILURE 2
1907 #endif
1908
1909 static void yy_fatal_error (yyconst char* msg )
1910 {
1911         (void) fprintf( stderr, "%s\n", msg );
1912         exit( YY_EXIT_FAILURE );
1913 }
1914
1915 /* Redefine yyless() so it works in section 3 code. */
1916
1917 #undef yyless
1918 #define yyless(n) \
1919         do \
1920                 { \
1921                 /* Undo effects of setting up yytext. */ \
1922         int yyless_macro_arg = (n); \
1923         YY_LESS_LINENO(yyless_macro_arg);\
1924                 yytext[yyleng] = (yy_hold_char); \
1925                 (yy_c_buf_p) = yytext + yyless_macro_arg; \
1926                 (yy_hold_char) = *(yy_c_buf_p); \
1927                 *(yy_c_buf_p) = '\0'; \
1928                 yyleng = yyless_macro_arg; \
1929                 } \
1930         while ( 0 )
1931
1932 /* Accessor  methods (get/set functions) to struct members. */
1933
1934 /** Get the current line number.
1935  *
1936  */
1937 int yyget_lineno  (void)
1938 {
1939
1940     return yylineno;
1941 }
1942
1943 /** Get the input stream.
1944  *
1945  */
1946 FILE *yyget_in  (void)
1947 {
1948         return yyin;
1949 }
1950
1951 /** Get the output stream.
1952  *
1953  */
1954 FILE *yyget_out  (void)
1955 {
1956         return yyout;
1957 }
1958
1959 /** Get the length of the current token.
1960  *
1961  */
1962 int yyget_leng  (void)
1963 {
1964         return yyleng;
1965 }
1966
1967 /** Get the current token.
1968  *
1969  */
1970
1971 char *yyget_text  (void)
1972 {
1973         return yytext;
1974 }
1975
1976 /** Set the current line number.
1977  * @param line_number
1978  *
1979  */
1980 void yyset_lineno (int  line_number )
1981 {
1982
1983     yylineno = line_number;
1984 }
1985
1986 /** Set the input stream. This does not discard the current
1987  * input buffer.
1988  * @param in_str A readable stream.
1989  *
1990  * @see yy_switch_to_buffer
1991  */
1992 void yyset_in (FILE *  in_str )
1993 {
1994         yyin = in_str ;
1995 }
1996
1997 void yyset_out (FILE *  out_str )
1998 {
1999         yyout = out_str ;
2000 }
2001
2002 int yyget_debug  (void)
2003 {
2004         return yy_flex_debug;
2005 }
2006
2007 void yyset_debug (int  bdebug )
2008 {
2009         yy_flex_debug = bdebug ;
2010 }
2011
2012 static int yy_init_globals (void)
2013 {
2014         /* Initialization is the same as for the non-reentrant scanner.
2015      * This function is called from yylex_destroy(), so don't allocate here.
2016      */
2017
2018     (yy_buffer_stack) = 0;
2019     (yy_buffer_stack_top) = 0;
2020     (yy_buffer_stack_max) = 0;
2021     (yy_c_buf_p) = (char *) 0;
2022     (yy_init) = 0;
2023     (yy_start) = 0;
2024
2025 /* Defined in main.c */
2026 #ifdef YY_STDINIT
2027     yyin = stdin;
2028     yyout = stdout;
2029 #else
2030     yyin = (FILE *) 0;
2031     yyout = (FILE *) 0;
2032 #endif
2033
2034     /* For future reference: Set errno on error, since we are called by
2035      * yylex_init()
2036      */
2037     return 0;
2038 }
2039
2040 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2041 int yylex_destroy  (void)
2042 {
2043
2044     /* Pop the buffer stack, destroying each element. */
2045         while(YY_CURRENT_BUFFER){
2046                 yy_delete_buffer(YY_CURRENT_BUFFER  );
2047                 YY_CURRENT_BUFFER_LVALUE = NULL;
2048                 yypop_buffer_state();
2049         }
2050
2051         /* Destroy the stack itself. */
2052         yyfree((yy_buffer_stack) );
2053         (yy_buffer_stack) = NULL;
2054
2055     /* Reset the globals. This is important in a non-reentrant scanner so the next time
2056      * yylex() is called, initialization will occur. */
2057     yy_init_globals( );
2058
2059     return 0;
2060 }
2061
2062 /*
2063  * Internal utility routines.
2064  */
2065
2066 #ifndef yytext_ptr
2067 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2068 {
2069         register int i;
2070         for ( i = 0; i < n; ++i )
2071                 s1[i] = s2[i];
2072 }
2073 #endif
2074
2075 #ifdef YY_NEED_STRLEN
2076 static int yy_flex_strlen (yyconst char * s )
2077 {
2078         register int n;
2079         for ( n = 0; s[n]; ++n )
2080                 ;
2081
2082         return n;
2083 }
2084 #endif
2085
2086 void *yyalloc (yy_size_t  size )
2087 {
2088         return (void *) malloc( size );
2089 }
2090
2091 void *yyrealloc  (void * ptr, yy_size_t  size )
2092 {
2093         /* The cast to (char *) in the following accommodates both
2094          * implementations that use char* generic pointers, and those
2095          * that use void* generic pointers.  It works with the latter
2096          * because both ANSI C and C++ allow castless assignment from
2097          * any pointer type to void*, and deal with argument conversions
2098          * as though doing an assignment.
2099          */
2100         return (void *) realloc( (char *) ptr, size );
2101 }
2102
2103 void yyfree (void * ptr )
2104 {
2105         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
2106 }
2107
2108 #define YYTABLES_NAME "yytables"
2109
2110 #line 167 "uscan.l"
2111
2112
2113
2114 int
2115 process_line(
2116     char *      line)
2117 {
2118     YY_BUFFER_STATE b;
2119     int result;
2120
2121     b = yy_scan_string(line);           /* tell lex to scan lineread */
2122     result = yyparse();                 /* parse lineread and act */
2123     yy_delete_buffer(b);
2124     return result;
2125 }
2126
2127 static int
2128 ll_parse_date(
2129     int         type,
2130     char *      text)
2131 {
2132     time_t now;
2133     struct tm *t;
2134     int y=2000, m=0, d=1, h=0, mi=0, s=0;
2135     int ret;
2136
2137     now = time((time_t *)NULL);
2138     t = localtime(&now);
2139     if (t) {
2140         y = 1900+t->tm_year;
2141         m = t->tm_mon+1;
2142         d = t->tm_mday;
2143     }
2144     switch(type) {
2145     case 1:
2146         if (sscanf(text, "---%d", &d) != 1) {
2147             yyerror("invalid date");
2148         }
2149         break;
2150     case 2:
2151         if (sscanf(text, "--%d-%d", &m, &d) != 2) {
2152             yyerror("invalid date");
2153         }
2154         break;
2155     case 3:
2156         if (sscanf(text, "%d-%d-%d", &y, &m, &d) != 3) {
2157             yyerror("invalid date");
2158         }
2159         break;
2160     case 4:
2161         if (sscanf(text, "%d-%d-%d-%d-%d-%d", &y, &m, &d, &h, &mi, &s) != 6) {
2162             yyerror("invalid date");
2163         }
2164         break;
2165     case 5:
2166         if (sscanf(text, "%d-%d-%d-%d-%d", &y, &m, &d, &h, &mi) != 5) {
2167             yyerror("invalid date");
2168         }
2169         break;
2170     }
2171
2172     ret = PATH;                         /* cause a parse error */
2173     if(y < 70) {
2174         y += 2000;
2175     } else if(y < 100) {
2176         y += 1900;
2177     }
2178     if(y < 1000 || y > 9999) {
2179         yyerror("invalid year");
2180     } else if(m < 1 || m > 12) {
2181         yyerror("invalid month");
2182     } else if(d < 1 || d > 31) {
2183         yyerror("invalid day");
2184     } else if(h < 0 || h > 24) {
2185         yyerror("invalid hour");
2186     } else if(mi < 0 || mi > 59) {
2187         yyerror("invalid minute");
2188     } else if(s < 0 || s > 59) {
2189         yyerror("invalid second");
2190     } else if(type < 4) {
2191         yylval.strval = alloc(DATE_ALLOC_SIZE);
2192         g_snprintf(yylval.strval, DATE_ALLOC_SIZE, "%04d-%02d-%02d", y, m, d);
2193         ret = DATE;
2194     } else {
2195         yylval.strval = alloc(DATE_ALLOC_SIZE);
2196         g_snprintf(yylval.strval, DATE_ALLOC_SIZE, "%04d-%02d-%02d-%02d-%02d-%02d", y, m, d, h, mi, s);
2197         ret = DATE;
2198     }
2199     return ret;
2200 }
2201
2202 int
2203 yywrap(void)
2204 {
2205   return 1;
2206 }
2207
2208