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