user/at/lex.yy.c

   1 /* A lexical scanner generated by flex */
   2
   3 /* Scanner skeleton version:
   4  * $Header: /home/ig25/at-3.1.7/RCS/lex.yy.c,v 1.3 1997/05/26 08:31:37 ig25 Exp ig25 $
   5  */
   6
   7 #define FLEX_SCANNER
   8 #define YY_FLEX_MAJOR_VERSION 2
   9 #define YY_FLEX_MINOR_VERSION 5
  10
  11 #include <stdio.h>
  12
  13
  14 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  15 #ifdef c_plusplus
  16 #ifndef __cplusplus
  17 #define __cplusplus
  18 #endif
  19 #endif
  20
  21
  22 #ifdef __cplusplus
  23
  24 #include <stdlib.h>
  25 #include <unistd.h>
  26
  27 /* Use prototypes in function declarations. */
  28 #define YY_USE_PROTOS
  29
  30 /* The "const" storage-class-modifier is valid. */
  31 #define YY_USE_CONST
  32
  33 #else   /* ! __cplusplus */
  34
  35 #if __STDC__
  36
  37 #define YY_USE_PROTOS
  38 #define YY_USE_CONST
  39
  40 #endif  /* __STDC__ */
  41 #endif  /* ! __cplusplus */
  42
  43 #ifdef __TURBOC__
  44  #pragma warn -rch
  45  #pragma warn -use
  46 #include <io.h>
  47 #include <stdlib.h>
  48 #define YY_USE_CONST
  49 #define YY_USE_PROTOS
  50 #endif
  51
  52 #ifdef YY_USE_CONST
  53 #define yyconst const
  54 #else
  55 #define yyconst
  56 #endif
  57
  58
  59 #ifdef YY_USE_PROTOS
  60 #define YY_PROTO(proto) proto
  61 #else
  62 #define YY_PROTO(proto) ()
  63 #endif
  64
  65 /* Returned upon end-of-file. */
  66 #define YY_NULL 0
  67
  68 /* Promotes a possibly negative, possibly signed char to an unsigned
  69  * integer for use as an array index.  If the signed char is negative,
  70  * we want to instead treat it as an 8-bit unsigned char, hence the
  71  * double cast.
  72  */
  73 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  74
  75 /* Enter a start condition.  This macro really ought to take a parameter,
  76  * but we do it the disgusting crufty way forced on us by the ()-less
  77  * definition of BEGIN.
  78  */
  79 #define BEGIN yy_start = 1 + 2 *
  80
  81 /* Translate the current start state into a value that can be later handed
  82  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  83  * compatibility.
  84  */
  85 #define YY_START ((yy_start - 1) / 2)
  86 #define YYSTATE YY_START
  87
  88 /* Action number for EOF rule of a given start state. */
  89 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  90
  91 /* Special action meaning "start processing a new file". */
  92 #define YY_NEW_FILE yyrestart( yyin )
  93
  94 #define YY_END_OF_BUFFER_CHAR 0
  95
  96 /* Size of default input buffer. */
  97 #define YY_BUF_SIZE 16384
  98
  99 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 100
 101 extern int yyleng;
 102 extern FILE *yyin, *yyout;
 103
 104 #define EOB_ACT_CONTINUE_SCAN 0
 105 #define EOB_ACT_END_OF_FILE 1
 106 #define EOB_ACT_LAST_MATCH 2
 107
 108 /* The funky do-while in the following #define is used to turn the definition
 109  * int a single C statement (which needs a semi-colon terminator).  This
 110  * avoids problems with code like:
 111  *
 112  *      if ( condition_holds )
 113  *              yyless( 5 );
 114  *      else
 115  *              do_something_else();
 116  *
 117  * Prior to using the do-while the compiler would get upset at the
 118  * "else" because it interpreted the "if" statement as being all
 119  * done when it reached the ';' after the yyless() call.
 120  */
 121
 122 /* Return all but the first 'n' matched characters back to the input stream. */
 123
 124 #define yyless(n) \
 125         do \
 126                 { \
 127                 /* Undo effects of setting up yytext. */ \
 128                 *yy_cp = yy_hold_char; \
 129                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
 130                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 131                 } \
 132         while ( 0 )
 133
 134 #define unput(c) yyunput( c, yytext_ptr )
 135
 136 /* The following is because we cannot portably get our hands on size_t
 137  * (without autoconf's help, which isn't available because we want
 138  * flex-generated scanners to compile on their own).
 139  */
 140 typedef unsigned int yy_size_t;
 141
 142
 143 struct yy_buffer_state
 144         {
 145         FILE *yy_input_file;
 146
 147         char *yy_ch_buf;                /* input buffer */
 148         char *yy_buf_pos;               /* current position in input buffer */
 149
 150         /* Size of input buffer in bytes, not including room for EOB
 151          * characters.
 152          */
 153         yy_size_t yy_buf_size;
 154
 155         /* Number of characters read into yy_ch_buf, not including EOB
 156          * characters.
 157          */
 158         int yy_n_chars;
 159
 160         /* Whether we "own" the buffer - i.e., we know we created it,
 161          * and can realloc() it to grow it, and should free() it to
 162          * delete it.
 163          */
 164         int yy_is_our_buffer;
 165
 166         /* Whether this is an "interactive" input source; if so, and
 167          * if we're using stdio for input, then we want to use getc()
 168          * instead of fread(), to make sure we stop fetching input after
 169          * each newline.
 170          */
 171         int yy_is_interactive;
 172
 173         /* Whether we're considered to be at the beginning of a line.
 174          * If so, '^' rules will be active on the next match, otherwise
 175          * not.
 176          */
 177         int yy_at_bol;
 178
 179         /* Whether to try to fill the input buffer when we reach the
 180          * end of it.
 181          */
 182         int yy_fill_buffer;
 183
 184         int yy_buffer_status;
 185 #define YY_BUFFER_NEW 0
 186 #define YY_BUFFER_NORMAL 1
 187         /* When an EOF's been seen but there's still some text to process
 188          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 189          * shouldn't try reading from the input source any more.  We might
 190          * still have a bunch of tokens to match, though, because of
 191          * possible backing-up.
 192          *
 193          * When we actually see the EOF, we change the status to "new"
 194          * (via yyrestart()), so that the user can continue scanning by
 195          * just pointing yyin at a new input file.
 196          */
 197 #define YY_BUFFER_EOF_PENDING 2
 198         };
 199
 200 static YY_BUFFER_STATE yy_current_buffer = 0;
 201
 202 /* We provide macros for accessing buffer states in case in the
 203  * future we want to put the buffer states in a more general
 204  * "scanner state".
 205  */
 206 #define YY_CURRENT_BUFFER yy_current_buffer
 207
 208
 209 /* yy_hold_char holds the character lost when yytext is formed. */
 210 static char yy_hold_char;
 211
 212 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 213
 214
 215 int yyleng;
 216
 217 /* Points to current character in buffer. */
 218 static char *yy_c_buf_p = (char *) 0;
 219 static int yy_init = 1;         /* whether we need to initialize */
 220 static int yy_start = 0;        /* start state number */
 221
 222 /* Flag which is used to allow yywrap()'s to do buffer switches
 223  * instead of setting up a fresh yyin.  A bit of a hack ...
 224  */
 225 static int yy_did_buffer_switch_on_eof;
 226
 227 void yyrestart YY_PROTO(( FILE *input_file ));
 228
 229 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
 230 void yy_load_buffer_state YY_PROTO(( void ));
 231 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
 232 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 233 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
 234 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 235 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
 236
 237 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
 238 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *str ));
 239 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
 240
 241 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
 242 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
 243 static void yy_flex_free YY_PROTO(( void * ));
 244
 245 #define yy_new_buffer yy_create_buffer
 246
 247 #define yy_set_interactive(is_interactive) \
 248         { \
 249         if ( ! yy_current_buffer ) \
 250                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 251         yy_current_buffer->yy_is_interactive = is_interactive; \
 252         }
 253
 254 #define yy_set_bol(at_bol) \
 255         { \
 256         if ( ! yy_current_buffer ) \
 257                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 258         yy_current_buffer->yy_at_bol = at_bol; \
 259         }
 260
 261 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
 262
 263 typedef unsigned char YY_CHAR;
 264 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 265 typedef int yy_state_type;
 266 extern char *yytext;
 267 #define yytext_ptr yytext
 268
 269 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
 270 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
 271 static int yy_get_next_buffer YY_PROTO(( void ));
 272 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 273
 274 /* Done after the current pattern has been matched and before the
 275  * corresponding action - sets up yytext.
 276  */
 277 #define YY_DO_BEFORE_ACTION \
 278         yytext_ptr = yy_bp; \
 279         yyleng = (int) (yy_cp - yy_bp); \
 280         yy_hold_char = *yy_cp; \
 281         *yy_cp = '\0'; \
 282         yy_c_buf_p = yy_cp;
 283
 284 #define YY_NUM_RULES 39
 285 #define YY_END_OF_BUFFER 40
 286 static yyconst short int yy_accept[175] =
 287     {   0,
 288         0,    0,   40,   38,   36,   36,   35,   38,   38,   38,
 289        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
 290        35,   37,    2,   37,   37,   37,   37,   37,   37,   37,
 291        37,   37,   37,   37,   37,   37,   37,   37,    3,   37,
 292        37,   37,   37,   37,   37,   37,   37,   26,   30,   20,
 293        34,   24,   12,   37,   23,   29,   28,   25,   27,   37,
 294        17,    8,   37,   37,   33,    1,   32,   13,   31,    7,
 295        37,   11,   37,   37,    9,   10,   37,   37,   37,   20,
 296        37,   37,   37,   19,   37,   29,   28,   37,   37,   37,
 297        37,   37,   16,    4,   37,   37,   37,   37,   37,   37,
 298
 299        37,   37,   37,   37,   37,   21,   26,   37,   37,   37,
 300        37,   19,   37,   25,   37,   37,   37,   22,   37,   37,
 301        37,   37,   37,   37,   37,   14,   37,   37,   37,   21,
 302        30,   37,   37,   12,   37,   37,   18,    8,   22,   37,
 303        37,   37,   37,    7,   37,   37,   37,   37,   37,   37,
 304        24,   23,   37,   18,   37,   32,   37,   37,    6,   37,
 305        37,    9,   37,   34,    5,   33,   13,   37,   11,   15,
 306        37,   31,   10,    0
 307     } ;
 308
 309 static yyconst int yy_ec[256] =
 310     {   0,
 311         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 312         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 313         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 314         1,    2,    1,    1,    1,    1,    1,    1,    1,    1,
 315         1,    1,    1,    1,    1,    1,    1,    4,    4,    4,
 316         4,    4,    4,    4,    4,    4,    4,    1,    1,    1,
 317         1,    1,    1,    1,    5,    6,    7,    8,    9,   10,
 318        11,   12,   13,   14,   15,   16,   17,   18,   19,   20,
 319        21,   22,   23,   24,   25,   26,   27,   28,   29,   21,
 320         1,    1,    1,    1,    1,    1,    5,    6,    7,    8,
 321
 322         9,   10,   11,   12,   13,   14,   15,   16,   17,   18,
 323        19,   20,   21,   22,   23,   24,   25,   26,   27,   28,
 324        29,   21,    1,    1,    1,    1,    1,    1,    1,    1,
 325         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 326         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 327         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 328         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 329         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 330         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 331         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 332
 333         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 334         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 335         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 336         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 337         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 338         1,    1,    1,    1,    1
 339     } ;
 340
 341 static yyconst int yy_meta[30] =
 342     {   0,
 343         1,    1,    1,    2,    2,    2,    2,    2,    2,    2,
 344         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
 345         2,    2,    2,    2,    2,    2,    2,    2,    2
 346     } ;
 347
 348 static yyconst short int yy_base[176] =
 349     {   0,
 350         0,    0,  184,  185,  185,  185,  179,   13,    0,   26,
 351        23,  163,   29,   31,   28,  174,  163,   34,   37,  170,
 352       174,    0,    0,  155,  165,  146,  167,  167,  159,  146,
 353       152,   24,   19,   43,  151,  140,   38,  143,    0,  142,
 354       145,  146,  158,  137,   50,  152,   44,  147,  134,  135,
 355       148,  131,  147,  132,  128,  123,  142,  143,    0,  131,
 356       123,   47,  123,  128,  136,    0,  125,  118,  118,  133,
 357       116,  117,  133,  118,  113,  117,  119,  117,  109,    0,
 358       114,  125,  124,  105,  122,    0,    0,  114,  112,  100,
 359       118,  110,    0,    0,  104,  114,   97,  109,  112,  103,
 360
 361        92,   85,   91,  104,  102,   87,    0,   85,  102,   85,
 362        77,    0,   83,    0,   93,   94,   73,   78,   94,   90,
 363        90,   80,   67,   78,   86,    0,   71,   87,   68,    0,
 364         0,   81,   60,    0,   59,   75,   63,    0,    0,   76,
 365        62,   78,   76,    0,   72,   75,   60,   49,   69,   54,
 366         0,    0,   51,    0,   52,    0,   44,   63,    0,   41,
 367        42,    0,   63,    0,    0,    0,    0,   44,    0,    0,
 368        34,    0,    0,  185,   58
 369     } ;
 370
 371 static yyconst short int yy_def[176] =
 372     {   0,
 373       174,    1,  174,  174,  174,  174,  174,  175,  175,  175,
 374       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
 375       174,  175,  175,  175,  175,  175,  175,  175,  175,  175,
 376       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
 377       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
 378       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
 379       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
 380       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
 381       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
 382       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
 383
 384       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
 385       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
 386       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
 387       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
 388       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
 389       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
 390       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
 391       175,  175,  175,    0,  174
 392     } ;
 393
 394 static yyconst short int yy_nxt[215] =
 395     {   0,
 396         4,    5,    6,    7,    8,    9,    9,   10,    9,   11,
 397         9,   12,    9,   13,    9,    9,   14,   15,   16,   17,
 398         9,    9,   18,   19,    9,    9,   20,    9,    9,   23,
 399        26,   28,   24,   31,   27,   33,   36,   25,   40,   56,
 400        58,   57,   41,   34,   29,   43,   37,   59,   44,   35,
 401        60,   76,   77,   32,   91,   45,   64,   73,   42,   22,
 402        61,   46,  173,   65,   66,  172,   74,  171,  170,  169,
 403        92,  168,  167,  166,  165,  164,  163,  162,  161,  160,
 404       159,  158,  157,  156,  155,  154,  153,  152,  151,  150,
 405       149,  148,  147,  146,  145,  144,  143,  142,  141,  140,
 406
 407       139,  138,  137,  136,  135,  134,  133,  132,  131,  130,
 408       129,  128,  127,  126,  125,  124,  123,  122,  121,  120,
 409       119,  118,  117,  116,  115,  114,  113,  112,  111,  110,
 410       109,  108,  107,  106,  105,  104,  103,  102,  101,  100,
 411        99,   98,   97,   96,   95,   94,   93,   90,   89,   88,
 412        87,   86,   85,   84,   83,   82,   81,   80,   79,   78,
 413        75,   72,   71,   70,   69,   68,   67,   63,   62,   55,
 414        54,   53,   52,   51,   50,   49,   48,   21,   47,   39,
 415        38,   30,   21,  174,    3,  174,  174,  174,  174,  174,
 416       174,  174,  174,  174,  174,  174,  174,  174,  174,  174,
 417
 418       174,  174,  174,  174,  174,  174,  174,  174,  174,  174,
 419       174,  174,  174,  174
 420     } ;
 421
 422 static yyconst short int yy_chk[215] =
 423     {   0,
 424         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 425         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 426         1,    1,    1,    1,    1,    1,    1,    1,    1,    8,
 427        10,   11,    8,   13,   10,   14,   15,    8,   18,   32,
 428        33,   32,   18,   14,   11,   19,   15,   33,   19,   14,
 429        34,   47,   47,   13,   62,   19,   37,   45,   18,  175,
 430        34,   19,  171,   37,   37,  168,   45,  163,  161,  160,
 431        62,  158,  157,  155,  153,  150,  149,  148,  147,  146,
 432       145,  143,  142,  141,  140,  137,  136,  135,  133,  132,
 433       129,  128,  127,  125,  124,  123,  122,  121,  120,  119,
 434
 435       118,  117,  116,  115,  113,  111,  110,  109,  108,  106,
 436       105,  104,  103,  102,  101,  100,   99,   98,   97,   96,
 437        95,   92,   91,   90,   89,   88,   85,   84,   83,   82,
 438        81,   79,   78,   77,   76,   75,   74,   73,   72,   71,
 439        70,   69,   68,   67,   65,   64,   63,   61,   60,   58,
 440        57,   56,   55,   54,   53,   52,   51,   50,   49,   48,
 441        46,   44,   43,   42,   41,   40,   38,   36,   35,   31,
 442        30,   29,   28,   27,   26,   25,   24,   21,   20,   17,
 443        16,   12,    7,    3,  174,  174,  174,  174,  174,  174,
 444       174,  174,  174,  174,  174,  174,  174,  174,  174,  174,
 445
 446       174,  174,  174,  174,  174,  174,  174,  174,  174,  174,
 447       174,  174,  174,  174
 448     } ;
 449
 450 static yy_state_type yy_last_accepting_state;
 451 static char *yy_last_accepting_cpos;
 452
 453 /* The intent behind this definition is that it'll catch
 454  * any uses of REJECT which flex missed.
 455  */
 456 #define REJECT reject_used_but_not_detected
 457 #define yymore() yymore_used_but_not_detected
 458 #define YY_MORE_ADJ 0
 459 char *yytext;
 460 #line 1 "parsetime.l"
 461 #define INITIAL 0
 462 #line 2 "parsetime.l"
 463
 464 #include <string.h>
 465 #include <time.h>
 466 #include "y.tab.h"
 467 #include "parsetime.h"
 468
 469 char *last_token = NULL;
 470 char **my_argv;
 471
 472 #define COPY_TOK do { last_token = strdup(yytext); } while(0)
 473
 474 #define COPY_VAL do { yylval.charval = strdup(yytext); } while(0)
 475
 476 #define YY_INPUT(buf,result,max_size) \
 477     do { \
 478         if (*my_argv == NULL) { \
 479             result = YY_NULL ;\
 480             buf[0] = 0; \
 481         } \
 482         else { \
 483             if (**my_argv == '\0') { \
 484                 buf[0] = ' ' ; \
 485                 my_argv ++; \
 486             } \
 487             else { \
 488                 buf[0] = **my_argv; \
 489                 (*my_argv) ++; \
 490             } \
 491         result = 1; \
 492         } \
 493     } while(0)
 494 #line 495 "lex.yy.c"
 495
 496 /* Macros after this point can all be overridden by user definitions in
 497  * section 1.
 498  */
 499
 500 #ifndef YY_SKIP_YYWRAP
 501 #ifdef __cplusplus
 502 extern "C" int yywrap YY_PROTO(( void ));
 503 #else
 504 extern int yywrap YY_PROTO(( void ));
 505 #endif
 506 #endif
 507
 508 #ifndef YY_NO_UNPUT
 509 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
 510 #endif
 511
 512 #ifndef yytext_ptr
 513 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
 514 #endif
 515
 516 #ifndef YY_NO_INPUT
 517 #ifdef __cplusplus
 518 static int yyinput YY_PROTO(( void ));
 519 #else
 520 static int input YY_PROTO(( void ));
 521 #endif
 522 #endif
 523
 524 #if YY_STACK_USED
 525 static int yy_start_stack_ptr = 0;
 526 static int yy_start_stack_depth = 0;
 527 static int *yy_start_stack = 0;
 528 #ifndef YY_NO_PUSH_STATE
 529 static void yy_push_state YY_PROTO(( int new_state ));
 530 #endif
 531 #ifndef YY_NO_POP_STATE
 532 static void yy_pop_state YY_PROTO(( void ));
 533 #endif
 534 #ifndef YY_NO_TOP_STATE
 535 static int yy_top_state YY_PROTO(( void ));
 536 #endif
 537
 538 #else
 539 #define YY_NO_PUSH_STATE 1
 540 #define YY_NO_POP_STATE 1
 541 #define YY_NO_TOP_STATE 1
 542 #endif
 543
 544 #ifdef YY_MALLOC_DECL
 545 YY_MALLOC_DECL
 546 #else
 547 #if __STDC__
 548 #ifndef __cplusplus
 549 #include <stdlib.h>
 550 #endif
 551 #else
 552 /* Just try to get by without declaring the routines.  This will fail
 553  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
 554  * or sizeof(void*) != sizeof(int).
 555  */
 556 #endif
 557 #endif
 558
 559 /* Amount of stuff to slurp up with each read. */
 560 #ifndef YY_READ_BUF_SIZE
 561 #define YY_READ_BUF_SIZE 8192
 562 #endif
 563
 564 /* Copy whatever the last rule matched to the standard output. */
 565
 566 #ifndef ECHO
 567 /* This used to be an fputs(), but since the string might contain NUL's,
 568  * we now use fwrite().
 569  */
 570 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 571 #endif
 572
 573 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 574  * is returned in "result".
 575  */
 576 #ifndef YY_INPUT
 577 #define YY_INPUT(buf,result,max_size) \
 578         if ( yy_current_buffer->yy_is_interactive ) \
 579                 { \
 580                 int c = '*', n; \
 581                 for ( n = 0; n < max_size && \
 582                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 583                         buf[n] = (char) c; \
 584                 if ( c == '\n' ) \
 585                         buf[n++] = (char) c; \
 586                 if ( c == EOF && ferror( yyin ) ) \
 587                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 588                 result = n; \
 589                 } \
 590         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
 591                   && ferror( yyin ) ) \
 592                 YY_FATAL_ERROR( "input in flex scanner failed" );
 593 #endif
 594
 595 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 596  * we don't want an extra ';' after the "return" because that will cause
 597  * some compilers to complain about unreachable statements.
 598  */
 599 #ifndef yyterminate
 600 #define yyterminate() return YY_NULL
 601 #endif
 602
 603 /* Number of entries by which start-condition stack grows. */
 604 #ifndef YY_START_STACK_INCR
 605 #define YY_START_STACK_INCR 25
 606 #endif
 607
 608 /* Report a fatal error. */
 609 #ifndef YY_FATAL_ERROR
 610 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 611 #endif
 612
 613 /* Default declaration of generated scanner - a define so the user can
 614  * easily add parameters.
 615  */
 616 #ifndef YY_DECL
 617 #define YY_DECL int yylex YY_PROTO(( void ))
 618 #endif
 619
 620 /* Code executed at the beginning of each rule, after yytext and yyleng
 621  * have been set up.
 622  */
 623 #ifndef YY_USER_ACTION
 624 #define YY_USER_ACTION
 625 #endif
 626
 627 /* Code executed at the end of each rule. */
 628 #ifndef YY_BREAK
 629 #define YY_BREAK break;
 630 #endif
 631
 632 #define YY_RULE_SETUP \
 633         YY_USER_ACTION
 634
 635 YY_DECL
 636         {
 637         register yy_state_type yy_current_state;
 638         register char *yy_cp, *yy_bp;
 639         register int yy_act;
 640
 641 #line 36 "parsetime.l"
 642
 643
 644 #line 645 "lex.yy.c"
 645
 646         if ( yy_init )
 647                 {
 648                 yy_init = 0;
 649
 650 #ifdef YY_USER_INIT
 651                 YY_USER_INIT;
 652 #endif
 653
 654                 if ( ! yy_start )
 655                         yy_start = 1;   /* first start state */
 656
 657                 if ( ! yyin )
 658                         yyin = stdin;
 659
 660                 if ( ! yyout )
 661                         yyout = stdout;
 662
 663                 if ( ! yy_current_buffer )
 664                         yy_current_buffer =
 665                                 yy_create_buffer( yyin, YY_BUF_SIZE );
 666
 667                 yy_load_buffer_state();
 668                 }
 669
 670         while ( 1 )             /* loops until end-of-file is reached */
 671                 {
 672                 yy_cp = yy_c_buf_p;
 673
 674                 /* Support of yytext. */
 675                 *yy_cp = yy_hold_char;
 676
 677                 /* yy_bp points to the position in yy_ch_buf of the start of
 678                  * the current run.
 679                  */
 680                 yy_bp = yy_cp;
 681
 682                 yy_current_state = yy_start;
 683 yy_match:
 684                 do
 685                         {
 686                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 687                         if ( yy_accept[yy_current_state] )
 688                                 {
 689                                 yy_last_accepting_state = yy_current_state;
 690                                 yy_last_accepting_cpos = yy_cp;
 691                                 }
 692                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 693                                 {
 694                                 yy_current_state = (int) yy_def[yy_current_state];
 695                                 if ( yy_current_state >= 175 )
 696                                         yy_c = yy_meta[(unsigned int) yy_c];
 697                                 }
 698                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 699                         ++yy_cp;
 700                         }
 701                 while ( yy_base[yy_current_state] != 185 );
 702
 703 yy_find_action:
 704                 yy_act = yy_accept[yy_current_state];
 705                 if ( yy_act == 0 )
 706                         { /* have to back up */
 707                         yy_cp = yy_last_accepting_cpos;
 708                         yy_current_state = yy_last_accepting_state;
 709                         yy_act = yy_accept[yy_current_state];
 710                         }
 711
 712                 YY_DO_BEFORE_ACTION;
 713
 714
 715 do_action:      /* This label is used only to access EOF actions. */
 716
 717
 718                 switch ( yy_act )
 719         { /* beginning of action switch */
 720                         case 0: /* must back up */
 721                         /* undo the effects of YY_DO_BEFORE_ACTION */
 722                         *yy_cp = yy_hold_char;
 723                         yy_cp = yy_last_accepting_cpos;
 724                         yy_current_state = yy_last_accepting_state;
 725                         goto yy_find_action;
 726
 727 case 1:
 728 YY_RULE_SETUP
 729 #line 38 "parsetime.l"
 730 { COPY_TOK ; return NOW; }
 731         YY_BREAK
 732 case 2:
 733 YY_RULE_SETUP
 734 #line 39 "parsetime.l"
 735 { COPY_TOK ; return AM; }
 736         YY_BREAK
 737 case 3:
 738 YY_RULE_SETUP
 739 #line 40 "parsetime.l"
 740 { COPY_TOK ; return PM; }
 741         YY_BREAK
 742 case 4:
 743 YY_RULE_SETUP
 744 #line 41 "parsetime.l"
 745 { COPY_TOK ; return NOON; }
 746         YY_BREAK
 747 case 5:
 748 YY_RULE_SETUP
 749 #line 42 "parsetime.l"
 750 { COPY_TOK ; return MIDNIGHT; }
 751         YY_BREAK
 752 case 6:
 753 YY_RULE_SETUP
 754 #line 43 "parsetime.l"
 755 { COPY_TOK ; return TEATIME; }
 756         YY_BREAK
 757 case 7:
 758 YY_RULE_SETUP
 759 #line 44 "parsetime.l"
 760 { COPY_TOK ; return SUN; }
 761         YY_BREAK
 762 case 8:
 763 YY_RULE_SETUP
 764 #line 45 "parsetime.l"
 765 { COPY_TOK ; return MON; }
 766         YY_BREAK
 767 case 9:
 768 YY_RULE_SETUP
 769 #line 46 "parsetime.l"
 770 { COPY_TOK ; return TUE; }
 771         YY_BREAK
 772 case 10:
 773 YY_RULE_SETUP
 774 #line 47 "parsetime.l"
 775 { COPY_TOK ; return WED; }
 776         YY_BREAK
 777 case 11:
 778 YY_RULE_SETUP
 779 #line 48 "parsetime.l"
 780 { COPY_TOK ; return THU; }
 781         YY_BREAK
 782 case 12:
 783 YY_RULE_SETUP
 784 #line 49 "parsetime.l"
 785 { COPY_TOK ; return FRI; }
 786         YY_BREAK
 787 case 13:
 788 YY_RULE_SETUP
 789 #line 50 "parsetime.l"
 790 { COPY_TOK ; return SAT; }
 791         YY_BREAK
 792 case 14:
 793 YY_RULE_SETUP
 794 #line 51 "parsetime.l"
 795 { COPY_TOK ; return TODAY; }
 796         YY_BREAK
 797 case 15:
 798 YY_RULE_SETUP
 799 #line 52 "parsetime.l"
 800 { COPY_TOK ; return TOMORROW; }
 801         YY_BREAK
 802 case 16:
 803 YY_RULE_SETUP
 804 #line 53 "parsetime.l"
 805 { COPY_TOK ; return NEXT; }
 806         YY_BREAK
 807 case 17:
 808 YY_RULE_SETUP
 809 #line 54 "parsetime.l"
 810 { COPY_TOK ; return MINUTE; }
 811         YY_BREAK
 812 case 18:
 813 YY_RULE_SETUP
 814 #line 55 "parsetime.l"
 815 { COPY_TOK ; return MINUTE; }
 816         YY_BREAK
 817 case 19:
 818 YY_RULE_SETUP
 819 #line 56 "parsetime.l"
 820 { COPY_TOK ; return HOUR; }
 821         YY_BREAK
 822 case 20:
 823 YY_RULE_SETUP
 824 #line 57 "parsetime.l"
 825 { COPY_TOK ; return DAY; }
 826         YY_BREAK
 827 case 21:
 828 YY_RULE_SETUP
 829 #line 58 "parsetime.l"
 830 { COPY_TOK ; return WEEK; }
 831         YY_BREAK
 832 case 22:
 833 YY_RULE_SETUP
 834 #line 59 "parsetime.l"
 835 { COPY_TOK ; return MONTH; }
 836         YY_BREAK
 837 case 23:
 838 YY_RULE_SETUP
 839 #line 60 "parsetime.l"
 840 { COPY_TOK ; return JAN; }
 841         YY_BREAK
 842 case 24:
 843 YY_RULE_SETUP
 844 #line 61 "parsetime.l"
 845 { COPY_TOK ; return FEB; }
 846         YY_BREAK
 847 case 25:
 848 YY_RULE_SETUP
 849 #line 62 "parsetime.l"
 850 { COPY_TOK ; return MAR; }
 851         YY_BREAK
 852 case 26:
 853 YY_RULE_SETUP
 854 #line 63 "parsetime.l"
 855 { COPY_TOK ; return APR; }
 856         YY_BREAK
 857 case 27:
 858 YY_RULE_SETUP
 859 #line 64 "parsetime.l"
 860 { COPY_TOK ; return MAY; }
 861         YY_BREAK
 862 case 28:
 863 YY_RULE_SETUP
 864 #line 65 "parsetime.l"
 865 { COPY_TOK ; return JUN; }
 866         YY_BREAK
 867 case 29:
 868 YY_RULE_SETUP
 869 #line 66 "parsetime.l"
 870 { COPY_TOK ; return JUL; }
 871         YY_BREAK
 872 case 30:
 873 YY_RULE_SETUP
 874 #line 67 "parsetime.l"
 875 { COPY_TOK ; return AUG; }
 876         YY_BREAK
 877 case 31:
 878 YY_RULE_SETUP
 879 #line 68 "parsetime.l"
 880 { COPY_TOK ; return SEP; }
 881         YY_BREAK
 882 case 32:
 883 YY_RULE_SETUP
 884 #line 69 "parsetime.l"
 885 { COPY_TOK ; return OCT; }
 886         YY_BREAK
 887 case 33:
 888 YY_RULE_SETUP
 889 #line 70 "parsetime.l"
 890 { COPY_TOK ; return NOV; }
 891         YY_BREAK
 892 case 34:
 893 YY_RULE_SETUP
 894 #line 71 "parsetime.l"
 895 { COPY_TOK ; return DEC; }
 896         YY_BREAK
 897 case 35:
 898 YY_RULE_SETUP
 899 #line 72 "parsetime.l"
 900 { COPY_TOK ; COPY_VAL; return INT; }
 901         YY_BREAK
 902 case 36:
 903 YY_RULE_SETUP
 904 #line 73 "parsetime.l"
 905 ;
 906         YY_BREAK
 907 case 37:
 908 YY_RULE_SETUP
 909 #line 74 "parsetime.l"
 910 { COPY_TOK ; COPY_VAL; return WORD; }
 911         YY_BREAK
 912 case 38:
 913 YY_RULE_SETUP
 914 #line 75 "parsetime.l"
 915 { COPY_TOK ; return yytext[0]; }
 916         YY_BREAK
 917 case 39:
 918 YY_RULE_SETUP
 919 #line 77 "parsetime.l"
 920 ECHO;
 921         YY_BREAK
 922 #line 923 "lex.yy.c"
 923 case YY_STATE_EOF(INITIAL):
 924         yyterminate();
 925
 926         case YY_END_OF_BUFFER:
 927                 {
 928                 /* Amount of text matched not including the EOB char. */
 929                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
 930
 931                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
 932                 *yy_cp = yy_hold_char;
 933
 934                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
 935                         {
 936                         /* We're scanning a new file or input source.  It's
 937                          * possible that this happened because the user
 938                          * just pointed yyin at a new source and called
 939                          * yylex().  If so, then we have to assure
 940                          * consistency between yy_current_buffer and our
 941                          * globals.  Here is the right place to do so, because
 942                          * this is the first action (other than possibly a
 943                          * back-up) that will match for the new input source.
 944                          */
 945                         yy_n_chars = yy_current_buffer->yy_n_chars;
 946                         yy_current_buffer->yy_input_file = yyin;
 947                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
 948                         }
 949
 950                 /* Note that here we test for yy_c_buf_p "<=" to the position
 951                  * of the first EOB in the buffer, since yy_c_buf_p will
 952                  * already have been incremented past the NUL character
 953                  * (since all states make transitions on EOB to the
 954                  * end-of-buffer state).  Contrast this with the test
 955                  * in input().
 956                  */
 957                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
 958                         { /* This was really a NUL. */
 959                         yy_state_type yy_next_state;
 960
 961                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
 962
 963                         yy_current_state = yy_get_previous_state();
 964
 965                         /* Okay, we're now positioned to make the NUL
 966                          * transition.  We couldn't have
 967                          * yy_get_previous_state() go ahead and do it
 968                          * for us because it doesn't know how to deal
 969                          * with the possibility of jamming (and we don't
 970                          * want to build jamming into it because then it
 971                          * will run more slowly).
 972                          */
 973
 974                         yy_next_state = yy_try_NUL_trans( yy_current_state );
 975
 976                         yy_bp = yytext_ptr + YY_MORE_ADJ;
 977
 978                         if ( yy_next_state )
 979                                 {
 980                                 /* Consume the NUL. */
 981                                 yy_cp = ++yy_c_buf_p;
 982                                 yy_current_state = yy_next_state;
 983                                 goto yy_match;
 984                                 }
 985
 986                         else
 987                                 {
 988                                 yy_cp = yy_c_buf_p;
 989                                 goto yy_find_action;
 990                                 }
 991                         }
 992
 993                 else switch ( yy_get_next_buffer() )
 994                         {
 995                         case EOB_ACT_END_OF_FILE:
 996                                 {
 997                                 yy_did_buffer_switch_on_eof = 0;
 998
 999                                 if ( yywrap() )
1000                                         {
1001                                         /* Note: because we've taken care in
1002                                          * yy_get_next_buffer() to have set up
1003                                          * yytext, we can now set up
1004                                          * yy_c_buf_p so that if some total
1005                                          * hoser (like flex itself) wants to
1006                                          * call the scanner after we return the
1007                                          * YY_NULL, it'll still work - another
1008                                          * YY_NULL will get returned.
1009                                          */
1010                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1011
1012                                         yy_act = YY_STATE_EOF(YY_START);
1013                                         goto do_action;
1014                                         }
1015
1016                                 else
1017                                         {
1018                                         if ( ! yy_did_buffer_switch_on_eof )
1019                                                 YY_NEW_FILE;
1020                                         }
1021                                 break;
1022                                 }
1023
1024                         case EOB_ACT_CONTINUE_SCAN:
1025                                 yy_c_buf_p =
1026                                         yytext_ptr + yy_amount_of_matched_text;
1027
1028                                 yy_current_state = yy_get_previous_state();
1029
1030                                 yy_cp = yy_c_buf_p;
1031                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1032                                 goto yy_match;
1033
1034                         case EOB_ACT_LAST_MATCH:
1035                                 yy_c_buf_p =
1036                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1037
1038                                 yy_current_state = yy_get_previous_state();
1039
1040                                 yy_cp = yy_c_buf_p;
1041                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1042                                 goto yy_find_action;
1043                         }
1044                 break;
1045                 }
1046
1047         default:
1048                 YY_FATAL_ERROR(
1049                         "fatal flex scanner internal error--no action found" );
1050         } /* end of action switch */
1051                 } /* end of scanning one token */
1052         } /* end of yylex */
1053
1054
1055 /* yy_get_next_buffer - try to read in a new buffer
1056  *
1057  * Returns a code representing an action:
1058  *      EOB_ACT_LAST_MATCH -
1059  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1060  *      EOB_ACT_END_OF_FILE - end of file
1061  */
1062
1063 static int yy_get_next_buffer()
1064         {
1065         register char *dest = yy_current_buffer->yy_ch_buf;
1066         register char *source = yytext_ptr;
1067         register int number_to_move, i;
1068         int ret_val;
1069
1070         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1071                 YY_FATAL_ERROR(
1072                 "fatal flex scanner internal error--end of buffer missed" );
1073
1074         if ( yy_current_buffer->yy_fill_buffer == 0 )
1075                 { /* Don't try to fill the buffer, so this is an EOF. */
1076                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1077                         {
1078                         /* We matched a singled characater, the EOB, so
1079                          * treat this as a final EOF.
1080                          */
1081                         return EOB_ACT_END_OF_FILE;
1082                         }
1083
1084                 else
1085                         {
1086                         /* We matched some text prior to the EOB, first
1087                          * process it.
1088                          */
1089                         return EOB_ACT_LAST_MATCH;
1090                         }
1091                 }
1092
1093         /* Try to read more data. */
1094
1095         /* First move last chars to start of buffer. */
1096         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1097
1098         for ( i = 0; i < number_to_move; ++i )
1099                 *(dest++) = *(source++);
1100
1101         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1102                 /* don't do the read, it's not guaranteed to return an EOF,
1103                  * just force an EOF
1104                  */
1105                 yy_n_chars = 0;
1106
1107         else
1108                 {
1109                 int num_to_read =
1110                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1111
1112                 while ( num_to_read <= 0 )
1113                         { /* Not enough room in the buffer - grow it. */
1114 #ifdef YY_USES_REJECT
1115                         YY_FATAL_ERROR(
1116 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1117 #else
1118
1119                         /* just a shorter name for the current buffer */
1120                         YY_BUFFER_STATE b = yy_current_buffer;
1121
1122                         int yy_c_buf_p_offset =
1123                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1124
1125                         if ( b->yy_is_our_buffer )
1126                                 {
1127                                 int new_size = b->yy_buf_size * 2;
1128
1129                                 if ( new_size <= 0 )
1130                                         b->yy_buf_size += b->yy_buf_size / 8;
1131                                 else
1132                                         b->yy_buf_size *= 2;
1133
1134                                 b->yy_ch_buf = (char *)
1135                                         /* Include room in for 2 EOB chars. */
1136                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1137                                                          b->yy_buf_size + 2 );
1138                                 }
1139                         else
1140                                 /* Can't grow it, we don't own it. */
1141                                 b->yy_ch_buf = 0;
1142
1143                         if ( ! b->yy_ch_buf )
1144                                 YY_FATAL_ERROR(
1145                                 "fatal error - scanner input buffer overflow" );
1146
1147                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1148
1149                         num_to_read = yy_current_buffer->yy_buf_size -
1150                                                 number_to_move - 1;
1151 #endif
1152                         }
1153
1154                 if ( num_to_read > YY_READ_BUF_SIZE )
1155                         num_to_read = YY_READ_BUF_SIZE;
1156
1157                 /* Read in more data. */
1158                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1159                         yy_n_chars, num_to_read );
1160                 }
1161
1162         if ( yy_n_chars == 0 )
1163                 {
1164                 if ( number_to_move == YY_MORE_ADJ )
1165                         {
1166                         ret_val = EOB_ACT_END_OF_FILE;
1167                         yyrestart( yyin );
1168                         }
1169
1170                 else
1171                         {
1172                         ret_val = EOB_ACT_LAST_MATCH;
1173                         yy_current_buffer->yy_buffer_status =
1174                                 YY_BUFFER_EOF_PENDING;
1175                         }
1176                 }
1177
1178         else
1179                 ret_val = EOB_ACT_CONTINUE_SCAN;
1180
1181         yy_n_chars += number_to_move;
1182         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1183         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1184
1185         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1186
1187         return ret_val;
1188         }
1189
1190
1191 /* yy_get_previous_state - get the state just before the EOB char was reached */
1192
1193 static yy_state_type yy_get_previous_state()
1194         {
1195         register yy_state_type yy_current_state;
1196         register char *yy_cp;
1197
1198         yy_current_state = yy_start;
1199
1200         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1201                 {
1202                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1203                 if ( yy_accept[yy_current_state] )
1204                         {
1205                         yy_last_accepting_state = yy_current_state;
1206                         yy_last_accepting_cpos = yy_cp;
1207                         }
1208                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1209                         {
1210                         yy_current_state = (int) yy_def[yy_current_state];
1211                         if ( yy_current_state >= 175 )
1212                                 yy_c = yy_meta[(unsigned int) yy_c];
1213                         }
1214                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1215                 }
1216
1217         return yy_current_state;
1218         }
1219
1220
1221 /* yy_try_NUL_trans - try to make a transition on the NUL character
1222  *
1223  * synopsis
1224  *      next_state = yy_try_NUL_trans( current_state );
1225  */
1226
1227 #ifdef YY_USE_PROTOS
1228 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1229 #else
1230 static yy_state_type yy_try_NUL_trans( yy_current_state )
1231 yy_state_type yy_current_state;
1232 #endif
1233         {
1234         register int yy_is_jam;
1235         register char *yy_cp = yy_c_buf_p;
1236
1237         register YY_CHAR yy_c = 1;
1238         if ( yy_accept[yy_current_state] )
1239                 {
1240                 yy_last_accepting_state = yy_current_state;
1241                 yy_last_accepting_cpos = yy_cp;
1242                 }
1243         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1244                 {
1245                 yy_current_state = (int) yy_def[yy_current_state];
1246                 if ( yy_current_state >= 175 )
1247                         yy_c = yy_meta[(unsigned int) yy_c];
1248                 }
1249         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1250         yy_is_jam = (yy_current_state == 174);
1251
1252         return yy_is_jam ? 0 : yy_current_state;
1253         }
1254
1255
1256 #ifndef YY_NO_UNPUT
1257 #ifdef YY_USE_PROTOS
1258 static void yyunput( int c, register char *yy_bp )
1259 #else
1260 static void yyunput( c, yy_bp )
1261 int c;
1262 register char *yy_bp;
1263 #endif
1264         {
1265         register char *yy_cp = yy_c_buf_p;
1266
1267         /* undo effects of setting up yytext */
1268         *yy_cp = yy_hold_char;
1269
1270         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1271                 { /* need to shift things up to make room */
1272                 /* +2 for EOB chars. */
1273                 register int number_to_move = yy_n_chars + 2;
1274                 register char *dest = &yy_current_buffer->yy_ch_buf[
1275                                         yy_current_buffer->yy_buf_size + 2];
1276                 register char *source =
1277                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1278
1279                 while ( source > yy_current_buffer->yy_ch_buf )
1280                         *--dest = *--source;
1281
1282                 yy_cp += (int) (dest - source);
1283                 yy_bp += (int) (dest - source);
1284                 yy_n_chars = yy_current_buffer->yy_buf_size;
1285
1286                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1287                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1288                 }
1289
1290         *--yy_cp = (char) c;
1291
1292
1293         yytext_ptr = yy_bp;
1294         yy_hold_char = *yy_cp;
1295         yy_c_buf_p = yy_cp;
1296         }
1297 #endif  /* ifndef YY_NO_UNPUT */
1298
1299
1300 #ifdef __cplusplus
1301 static int yyinput()
1302 #else
1303 static int input()
1304 #endif
1305         {
1306         int c;
1307
1308         *yy_c_buf_p = yy_hold_char;
1309
1310         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1311                 {
1312                 /* yy_c_buf_p now points to the character we want to return.
1313                  * If this occurs *before* the EOB characters, then it's a
1314                  * valid NUL; if not, then we've hit the end of the buffer.
1315                  */
1316                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1317                         /* This was really a NUL. */
1318                         *yy_c_buf_p = '\0';
1319
1320                 else
1321                         { /* need more input */
1322                         yytext_ptr = yy_c_buf_p;
1323                         ++yy_c_buf_p;
1324
1325                         switch ( yy_get_next_buffer() )
1326                                 {
1327                                 case EOB_ACT_END_OF_FILE:
1328                                         {
1329                                         if ( yywrap() )
1330                                                 {
1331                                                 yy_c_buf_p =
1332                                                 yytext_ptr + YY_MORE_ADJ;
1333                                                 return EOF;
1334                                                 }
1335
1336                                         if ( ! yy_did_buffer_switch_on_eof )
1337                                                 YY_NEW_FILE;
1338 #ifdef __cplusplus
1339                                         return yyinput();
1340 #else
1341                                         return input();
1342 #endif
1343                                         }
1344
1345                                 case EOB_ACT_CONTINUE_SCAN:
1346                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1347                                         break;
1348
1349                                 case EOB_ACT_LAST_MATCH:
1350 #ifdef __cplusplus
1351                                         YY_FATAL_ERROR(
1352                                         "unexpected last match in yyinput()" );
1353 #else
1354                                         YY_FATAL_ERROR(
1355                                         "unexpected last match in input()" );
1356 #endif
1357                                 }
1358                         }
1359                 }
1360
1361         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1362         *yy_c_buf_p = '\0';     /* preserve yytext */
1363         yy_hold_char = *++yy_c_buf_p;
1364
1365
1366         return c;
1367         }
1368
1369
1370 #ifdef YY_USE_PROTOS
1371 void yyrestart( FILE *input_file )
1372 #else
1373 void yyrestart( input_file )
1374 FILE *input_file;
1375 #endif
1376         {
1377         if ( ! yy_current_buffer )
1378                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1379
1380         yy_init_buffer( yy_current_buffer, input_file );
1381         yy_load_buffer_state();
1382         }
1383
1384
1385 #ifdef YY_USE_PROTOS
1386 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1387 #else
1388 void yy_switch_to_buffer( new_buffer )
1389 YY_BUFFER_STATE new_buffer;
1390 #endif
1391         {
1392         if ( yy_current_buffer == new_buffer )
1393                 return;
1394
1395         if ( yy_current_buffer )
1396                 {
1397                 /* Flush out information for old buffer. */
1398                 *yy_c_buf_p = yy_hold_char;
1399                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1400                 yy_current_buffer->yy_n_chars = yy_n_chars;
1401                 }
1402
1403         yy_current_buffer = new_buffer;
1404         yy_load_buffer_state();
1405
1406         /* We don't actually know whether we did this switch during
1407          * EOF (yywrap()) processing, but the only time this flag
1408          * is looked at is after yywrap() is called, so it's safe
1409          * to go ahead and always set it.
1410          */
1411         yy_did_buffer_switch_on_eof = 1;
1412         }
1413
1414
1415 #ifdef YY_USE_PROTOS
1416 void yy_load_buffer_state( void )
1417 #else
1418 void yy_load_buffer_state()
1419 #endif
1420         {
1421         yy_n_chars = yy_current_buffer->yy_n_chars;
1422         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1423         yyin = yy_current_buffer->yy_input_file;
1424         yy_hold_char = *yy_c_buf_p;
1425         }
1426
1427
1428 #ifdef YY_USE_PROTOS
1429 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1430 #else
1431 YY_BUFFER_STATE yy_create_buffer( file, size )
1432 FILE *file;
1433 int size;
1434 #endif
1435         {
1436         YY_BUFFER_STATE b;
1437
1438         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1439         if ( ! b )
1440                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1441
1442         b->yy_buf_size = size;
1443
1444         /* yy_ch_buf has to be 2 characters longer than the size given because
1445          * we need to put in 2 end-of-buffer characters.
1446          */
1447         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1448         if ( ! b->yy_ch_buf )
1449                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1450
1451         b->yy_is_our_buffer = 1;
1452
1453         yy_init_buffer( b, file );
1454
1455         return b;
1456         }
1457
1458
1459 #ifdef YY_USE_PROTOS
1460 void yy_delete_buffer( YY_BUFFER_STATE b )
1461 #else
1462 void yy_delete_buffer( b )
1463 YY_BUFFER_STATE b;
1464 #endif
1465         {
1466         if ( ! b )
1467                 return;
1468
1469         if ( b == yy_current_buffer )
1470                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1471
1472         if ( b->yy_is_our_buffer )
1473                 yy_flex_free( (void *) b->yy_ch_buf );
1474
1475         yy_flex_free( (void *) b );
1476         }
1477
1478
1479 #ifndef YY_ALWAYS_INTERACTIVE
1480 #ifndef YY_NEVER_INTERACTIVE
1481 extern int isatty YY_PROTO(( int ));
1482 #endif
1483 #endif
1484
1485 #ifdef YY_USE_PROTOS
1486 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1487 #else
1488 void yy_init_buffer( b, file )
1489 YY_BUFFER_STATE b;
1490 FILE *file;
1491 #endif
1492
1493
1494         {
1495         yy_flush_buffer( b );
1496
1497         b->yy_input_file = file;
1498         b->yy_fill_buffer = 1;
1499
1500 #if YY_ALWAYS_INTERACTIVE
1501         b->yy_is_interactive = 1;
1502 #else
1503 #if YY_NEVER_INTERACTIVE
1504         b->yy_is_interactive = 0;
1505 #else
1506         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1507 #endif
1508 #endif
1509         }
1510
1511
1512 #ifdef YY_USE_PROTOS
1513 void yy_flush_buffer( YY_BUFFER_STATE b )
1514 #else
1515 void yy_flush_buffer( b )
1516 YY_BUFFER_STATE b;
1517 #endif
1518
1519         {
1520         b->yy_n_chars = 0;
1521
1522         /* We always need two end-of-buffer characters.  The first causes
1523          * a transition to the end-of-buffer state.  The second causes
1524          * a jam in that state.
1525          */
1526         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1527         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1528
1529         b->yy_buf_pos = &b->yy_ch_buf[0];
1530
1531         b->yy_at_bol = 1;
1532         b->yy_buffer_status = YY_BUFFER_NEW;
1533
1534         if ( b == yy_current_buffer )
1535                 yy_load_buffer_state();
1536         }
1537
1538
1539 #ifndef YY_NO_SCAN_BUFFER
1540 #ifdef YY_USE_PROTOS
1541 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1542 #else
1543 YY_BUFFER_STATE yy_scan_buffer( base, size )
1544 char *base;
1545 yy_size_t size;
1546 #endif
1547         {
1548         YY_BUFFER_STATE b;
1549
1550         if ( size < 2 ||
1551              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1552              base[size-1] != YY_END_OF_BUFFER_CHAR )
1553                 /* They forgot to leave room for the EOB's. */
1554                 return 0;
1555
1556         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1557         if ( ! b )
1558                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1559
1560         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1561         b->yy_buf_pos = b->yy_ch_buf = base;
1562         b->yy_is_our_buffer = 0;
1563         b->yy_input_file = 0;
1564         b->yy_n_chars = b->yy_buf_size;
1565         b->yy_is_interactive = 0;
1566         b->yy_at_bol = 1;
1567         b->yy_fill_buffer = 0;
1568         b->yy_buffer_status = YY_BUFFER_NEW;
1569
1570         yy_switch_to_buffer( b );
1571
1572         return b;
1573         }
1574 #endif
1575
1576
1577 #ifndef YY_NO_SCAN_STRING
1578 #ifdef YY_USE_PROTOS
1579 YY_BUFFER_STATE yy_scan_string( yyconst char *str )
1580 #else
1581 YY_BUFFER_STATE yy_scan_string( str )
1582 yyconst char *str;
1583 #endif
1584         {
1585         int len;
1586         for ( len = 0; str[len]; ++len )
1587                 ;
1588
1589         return yy_scan_bytes( str, len );
1590         }
1591 #endif
1592
1593
1594 #ifndef YY_NO_SCAN_BYTES
1595 #ifdef YY_USE_PROTOS
1596 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1597 #else
1598 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1599 yyconst char *bytes;
1600 int len;
1601 #endif
1602         {
1603         YY_BUFFER_STATE b;
1604         char *buf;
1605         yy_size_t n;
1606         int i;
1607
1608         /* Get memory for full buffer, including space for trailing EOB's. */
1609         n = len + 2;
1610         buf = (char *) yy_flex_alloc( n );
1611         if ( ! buf )
1612                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1613
1614         for ( i = 0; i < len; ++i )
1615                 buf[i] = bytes[i];
1616
1617         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1618
1619         b = yy_scan_buffer( buf, n );
1620         if ( ! b )
1621                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1622
1623         /* It's okay to grow etc. this buffer, and we should throw it
1624          * away when we're done.
1625          */
1626         b->yy_is_our_buffer = 1;
1627
1628         return b;
1629         }
1630 #endif
1631
1632
1633 #ifndef YY_NO_PUSH_STATE
1634 #ifdef YY_USE_PROTOS
1635 static void yy_push_state( int new_state )
1636 #else
1637 static void yy_push_state( new_state )
1638 int new_state;
1639 #endif
1640         {
1641         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1642                 {
1643                 yy_size_t new_size;
1644
1645                 yy_start_stack_depth += YY_START_STACK_INCR;
1646                 new_size = yy_start_stack_depth * sizeof( int );
1647
1648                 if ( ! yy_start_stack )
1649                         yy_start_stack = (int *) yy_flex_alloc( new_size );
1650
1651                 else
1652                         yy_start_stack = (int *) yy_flex_realloc(
1653                                         (void *) yy_start_stack, new_size );
1654
1655                 if ( ! yy_start_stack )
1656                         YY_FATAL_ERROR(
1657                         "out of memory expanding start-condition stack" );
1658                 }
1659
1660         yy_start_stack[yy_start_stack_ptr++] = YY_START;
1661
1662         BEGIN(new_state);
1663         }
1664 #endif
1665
1666
1667 #ifndef YY_NO_POP_STATE
1668 static void yy_pop_state()
1669         {
1670         if ( --yy_start_stack_ptr < 0 )
1671                 YY_FATAL_ERROR( "start-condition stack underflow" );
1672
1673         BEGIN(yy_start_stack[yy_start_stack_ptr]);
1674         }
1675 #endif
1676
1677
1678 #ifndef YY_NO_TOP_STATE
1679 static int yy_top_state()
1680         {
1681         return yy_start_stack[yy_start_stack_ptr - 1];
1682         }
1683 #endif
1684
1685 #ifndef YY_EXIT_FAILURE
1686 #define YY_EXIT_FAILURE 2
1687 #endif
1688
1689 #ifdef YY_USE_PROTOS
1690 static void yy_fatal_error( yyconst char msg[] )
1691 #else
1692 static void yy_fatal_error( msg )
1693 char msg[];
1694 #endif
1695         {
1696         (void) fprintf( stderr, "%s\n", msg );
1697         exit( YY_EXIT_FAILURE );
1698         }
1699
1700
1701
1702 /* Redefine yyless() so it works in section 3 code. */
1703
1704 #undef yyless
1705 #define yyless(n) \
1706         do \
1707                 { \
1708                 /* Undo effects of setting up yytext. */ \
1709                 yytext[yyleng] = yy_hold_char; \
1710                 yy_c_buf_p = yytext + n - YY_MORE_ADJ; \
1711                 yy_hold_char = *yy_c_buf_p; \
1712                 *yy_c_buf_p = '\0'; \
1713                 yyleng = n; \
1714                 } \
1715         while ( 0 )
1716
1717
1718 /* Internal utility routines. */
1719
1720 #ifndef yytext_ptr
1721 #ifdef YY_USE_PROTOS
1722 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1723 #else
1724 static void yy_flex_strncpy( s1, s2, n )
1725 char *s1;
1726 yyconst char *s2;
1727 int n;
1728 #endif
1729         {
1730         register int i;
1731         for ( i = 0; i < n; ++i )
1732                 s1[i] = s2[i];
1733         }
1734 #endif
1735
1736
1737 #ifdef YY_USE_PROTOS
1738 static void *yy_flex_alloc( yy_size_t size )
1739 #else
1740 static void *yy_flex_alloc( size )
1741 yy_size_t size;
1742 #endif
1743         {
1744         return (void *) malloc( size );
1745         }
1746
1747 #ifdef YY_USE_PROTOS
1748 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1749 #else
1750 static void *yy_flex_realloc( ptr, size )
1751 void *ptr;
1752 yy_size_t size;
1753 #endif
1754         {
1755         /* The cast to (char *) in the following accommodates both
1756          * implementations that use char* generic pointers, and those
1757          * that use void* generic pointers.  It works with the latter
1758          * because both ANSI C and C++ allow castless assignment from
1759          * any pointer type to void*, and deal with argument conversions
1760          * as though doing an assignment.
1761          */
1762         return (void *) realloc( (char *) ptr, size );
1763         }
1764
1765 #ifdef YY_USE_PROTOS
1766 static void yy_flex_free( void *ptr )
1767 #else
1768 static void yy_flex_free( ptr )
1769 void *ptr;
1770 #endif
1771         {
1772         free( ptr );
1773         }
1774
1775 #if YY_MAIN
1776 int main()
1777         {
1778         yylex();
1779         return 0;
1780         }
1781 #endif
1782 #line 77 "parsetime.l"
1783
1784
1785 #ifdef NEED_YYWRAP
1786 int yywrap()
1787 {
1788     return 1;
1789 }
1790 #endif