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