git.marmaro.de Git - mmh/blob - sbr/dtimep.c

   1 /* A lexical scanner generated by flex */
   2
   3 /* Scanner skeleton version:
   4  * $Header$
   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_RESTORE_YY_MORE_OFFSET \
 130                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
 131                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 132                 } \
 133         while ( 0 )
 134
 135 #define unput(c) yyunput( c, yytext_ptr )
 136
 137 /* The following is because we cannot portably get our hands on size_t
 138  * (without autoconf's help, which isn't available because we want
 139  * flex-generated scanners to compile on their own).
 140  */
 141 typedef unsigned int yy_size_t;
 142
 143
 144 struct yy_buffer_state
 145         {
 146         FILE *yy_input_file;
 147
 148         char *yy_ch_buf;                /* input buffer */
 149         char *yy_buf_pos;               /* current position in input buffer */
 150
 151         /* Size of input buffer in bytes, not including room for EOB
 152          * characters.
 153          */
 154         yy_size_t yy_buf_size;
 155
 156         /* Number of characters read into yy_ch_buf, not including EOB
 157          * characters.
 158          */
 159         int yy_n_chars;
 160
 161         /* Whether we "own" the buffer - i.e., we know we created it,
 162          * and can realloc() it to grow it, and should free() it to
 163          * delete it.
 164          */
 165         int yy_is_our_buffer;
 166
 167         /* Whether this is an "interactive" input source; if so, and
 168          * if we're using stdio for input, then we want to use getc()
 169          * instead of fread(), to make sure we stop fetching input after
 170          * each newline.
 171          */
 172         int yy_is_interactive;
 173
 174         /* Whether we're considered to be at the beginning of a line.
 175          * If so, '^' rules will be active on the next match, otherwise
 176          * not.
 177          */
 178         int yy_at_bol;
 179
 180         /* Whether to try to fill the input buffer when we reach the
 181          * end of it.
 182          */
 183         int yy_fill_buffer;
 184
 185         int yy_buffer_status;
 186 #define YY_BUFFER_NEW 0
 187 #define YY_BUFFER_NORMAL 1
 188         /* When an EOF's been seen but there's still some text to process
 189          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 190          * shouldn't try reading from the input source any more.  We might
 191          * still have a bunch of tokens to match, though, because of
 192          * possible backing-up.
 193          *
 194          * When we actually see the EOF, we change the status to "new"
 195          * (via yyrestart()), so that the user can continue scanning by
 196          * just pointing yyin at a new input file.
 197          */
 198 #define YY_BUFFER_EOF_PENDING 2
 199         };
 200
 201 static YY_BUFFER_STATE yy_current_buffer = 0;
 202
 203 /* We provide macros for accessing buffer states in case in the
 204  * future we want to put the buffer states in a more general
 205  * "scanner state".
 206  */
 207 #define YY_CURRENT_BUFFER yy_current_buffer
 208
 209
 210 /* yy_hold_char holds the character lost when yytext is formed. */
 211 static char yy_hold_char;
 212
 213 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 214
 215
 216 int yyleng;
 217
 218 /* Points to current character in buffer. */
 219 static char *yy_c_buf_p = (char *) 0;
 220 static int yy_init = 1;         /* whether we need to initialize */
 221 static int yy_start = 0;        /* start state number */
 222
 223 /* Flag which is used to allow yywrap()'s to do buffer switches
 224  * instead of setting up a fresh yyin.  A bit of a hack ...
 225  */
 226 static int yy_did_buffer_switch_on_eof;
 227
 228 void yyrestart YY_PROTO(( FILE *input_file ));
 229
 230 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
 231 void yy_load_buffer_state YY_PROTO(( void ));
 232 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
 233 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 234 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
 235 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 236 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
 237
 238 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
 239 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
 240 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
 241
 242 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
 243 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
 244 static void yy_flex_free YY_PROTO(( void * ));
 245
 246 #define yy_new_buffer yy_create_buffer
 247
 248 #define yy_set_interactive(is_interactive) \
 249         { \
 250         if ( ! yy_current_buffer ) \
 251                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 252         yy_current_buffer->yy_is_interactive = is_interactive; \
 253         }
 254
 255 #define yy_set_bol(at_bol) \
 256         { \
 257         if ( ! yy_current_buffer ) \
 258                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 259         yy_current_buffer->yy_at_bol = at_bol; \
 260         }
 261
 262 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
 263
 264 typedef unsigned char YY_CHAR;
 265 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 266 typedef int yy_state_type;
 267 extern char *yytext;
 268 #define yytext_ptr yytext
 269
 270 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
 271 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
 272 static int yy_get_next_buffer YY_PROTO(( void ));
 273 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 274
 275 /* Done after the current pattern has been matched and before the
 276  * corresponding action - sets up yytext.
 277  */
 278 #define YY_DO_BEFORE_ACTION \
 279         yytext_ptr = yy_bp; \
 280         yyleng = (int) (yy_cp - yy_bp); \
 281         yy_hold_char = *yy_cp; \
 282         *yy_cp = '\0'; \
 283         yy_c_buf_p = yy_cp;
 284
 285 #define YY_NUM_RULES 38
 286 #define YY_END_OF_BUFFER 39
 287 static yyconst short int yy_accept[614] =
 288     {   0,
 289         0,    0,   39,   37,   37,   37,   37,   34,   34,   34,
 290        34,   34,   34,   34,   34,   34,   37,   35,   35,   36,
 291        36,   36,   36,   36,   36,   36,   36,   36,   37,   34,
 292        34,   34,   34,   34,   34,   37,   35,   36,   36,   36,
 293        36,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 294         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 295         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 296         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 297         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 298         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 299
 300         0,    0,    0,   14,    0,    0,    0,    0,    0,    0,
 301         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 302         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 303         0,    0,    0,    0,    0,    0,    0,    0,    0,   28,
 304        27,    0,    0,   33,   21,   20,    0,   19,   18,    0,
 305         0,   15,   32,   31,   17,   16,    0,    0,    0,   23,
 306        22,    0,    0,    0,   26,    0,    0,   25,   24,    0,
 307         0,    0,    0,    0,    0,   30,   29,    0,    0,   12,
 308        13,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 309         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 310
 311         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 312         0,    0,    0,    0,    0,    0,   12,   13,    0,    0,
 313         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 314         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 315         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 316         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 317         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 318         0,    0,    9,    9,    0,    0,    0,    0,    0,    0,
 319         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 320         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 321
 322         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 323         0,    0,    0,    0,    0,    0,    0,    0,    9,    0,
 324         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 325         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 326         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 327         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 328         0,    0,    9,    7,    7,    0,    0,    0,    0,    0,
 329         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 330         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 331         0,    0,    0,    0,   10,   11,    0,    0,    0,    0,
 332
 333         0,    0,    0,    0,    0,    0,    0,    0,    0,    7,
 334         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 335         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 336         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 337         0,    0,    0,    0,    0,    0,    7,    0,    0,    0,
 338         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 339         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 340         0,    0,    8,    0,    0,    0,    0,    0,    0,    0,
 341         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 342         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 343
 344         0,    6,    6,    6,    6,    6,    6,    6,    0,    0,
 345         0,    0,    0,    0,    0,    0,    0,    5,    0,    5,
 346         0,    0,    0,    0,    0,    0,    3,    0,    0,    0,
 347         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 348         0,    0,    0,    0,    0,    0,    0,    5,    5,    5,
 349         0,    0,    8,    0,    0,    0,    0,    0,    0,    0,
 350         0,    0,    0,    0,    0,    0,    0,    5,    0,    0,
 351         6,    6,    0,    6,    0,    0,    0,    0,    0,    0,
 352         0,    0,    0,    0,    3,    0,    0,    6,    0,    0,
 353         0,    0,    0,    0,    6,    6,    0,    2,    4,    1,
 354
 355         1,    0,    6,    0,    0,    0,    1,    0,    0,    1,
 356         2,    4,    0
 357     } ;
 358
 359 static yyconst int yy_ec[256] =
 360     {   0,
 361         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 362         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 363         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 364         1,    2,    1,    1,    1,    1,    1,    1,    1,    1,
 365         1,    1,    4,    5,    6,    1,    7,    8,    9,    8,
 366         8,    8,    8,    8,    8,    8,    8,   10,    1,    1,
 367         1,    1,    1,    1,   11,   12,   13,   14,   15,   16,
 368        17,   18,   19,   20,   21,   21,   22,   23,   24,   25,
 369        26,   26,   27,   28,   29,   26,   30,   26,   31,    1,
 370        32,    1,   33,    1,    1,    1,   34,   35,   36,   37,
 371
 372        38,   16,   39,   40,   41,   42,   21,   43,   44,   45,
 373        46,   47,   26,   48,   49,   50,   51,   52,   30,   26,
 374        53,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 375         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 376         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 377         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 378         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 379         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 380         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 381         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 382
 383         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 384         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 385         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 386         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 387         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 388         1,    1,    1,    1,    1
 389     } ;
 390
 391 static yyconst int yy_meta[54] =
 392     {   0,
 393         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 394         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 395         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 396         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 397         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 398         1,    1,    1
 399     } ;
 400
 401 static yyconst short int yy_base[614] =
 402     {   0,
 403         0,    0,  988,  989,   46,   48,   96,   62,  960,   48,
 404       948,   53,   26,  963,   58,  989,   80,  989,   83,   54,
 405       948,   64,  989,   74,   18,  955,  944,   92,  105,   85,
 406       932,   74,   78,  936,   84,  101,  105,   91,  104,  929,
 407       106,  136,  138,  134,  951,  135,  142,  955,  143,  144,
 408       145,  949,  146,  947,  149,  128,  925,  129,  130,  929,
 409       131,  137,  138,  923,  144,  921,  145,  193,  175,  183,
 410       942,  941,  920,  928,  938,  937,  936,  927,  934,  933,
 411       925,  918,  930,  929,  928,  927,  926,  908,   75,  924,
 412       923,  143,  905,  921,  896,  897,  918,  917,  894,  896,
 413
 414       897,  890,  902,  989,  902,  910,  909,  902,  888,  884,
 415       883,  882,  881,  880,  879,  878,  877,  876,  875,  874,
 416       873,  872,  871,  870,  869,  868,  867,  866,  189,  191,
 417        77,  877,  876,  154,  879,  866,  875,  872,  215,  989,
 418       989,  162,  190,  989,  989,  989,  206,  989,  989,  199,
 419       209,  989,  989,  989,  989,  989,  200,  204,  210,  989,
 420       989,  216,  907,  223,  989,  217,  208,  989,  989,  224,
 421       229,  231,  238,  248,  254,  989,  989,  875,  874,  253,
 422       255,  858,  866,  868,  868,  857,  189,  217,  849,  850,
 423       852,  258,  265,  272,  855,  848,  852,  844,  298,  892,
 424
 425       859,  858,  889,  888,  849,  854,  843,  851,  837,  846,
 426       849,  833,  844,  842,  847,  846,  989,  989,  243,  247,
 427       256,  267,  275,  271,  281,  274,  875,  285,  283,  280,
 428       280,  282,  329,  874,  825,  839,  839,  293,  245,  834,
 429       833,  277,  836,  823,  832,  829,  813,  817,  862,  810,
 430       827,  823,  823,  815,  805,  820,  822,  806,  832,  831,
 431       337,  809,  802,  806,  798,  814,  845,  844,  805,  800,
 432       808,  804,  346,  348,  350,  839,  303,  838,  801,  790,
 433       358,  835,  788,  796,  798,  798,  787,  306,  288,  779,
 434       780,  782,  311,  775,  359,  789,  778,  791,  789,  360,
 435
 436       789,  769,  784,  776,  775,  295,  358,  816,  767,  781,
 437       781,  766,  811,  777,  773,  766,  368,  375,  385,  380,
 438       382,  761,  755,  324,  769,  768,  345,  771,  758,  767,
 439       764,  276,  361,  371,  351,  366,  384,  395,  291,  799,
 440       396,  399,  403,  752,  797,  745,  759,  743,  406,  761,
 441       761,  760,  411,  413,  790,  753,  742,  736,  750,  739,
 442       751,  415,  783,  427,  438,  782,  781,  734,  742,  744,
 443       744,  733,  371,  378,  725,  726,  728,  440,  731,  724,
 444       728,  720,  736,  767,  766,  727,  722,  730,  726,  761,
 445       425,  714,  436,  708,  989,  989,  442,  446,  450,  712,
 446
 447       706,  710,  755,  718,  745,  448,  458,  752,  453,  461,
 448       426,  462,  437,  463,  466,  469,  471,  470,  751,  474,
 449       475,  476,  482,  750,  701,  715,  715,  700,  745,  711,
 450       707,  700,  741,  477,  484,  740,  739,  738,  737,  690,
 451       487,  689,  690,  447,  449,  697,  499,  516,  691,  684,
 452       688,  680,  696,  727,  726,  687,  682,  690,  686,  521,
 453       721,  514,  720,  683,  672,  666,  680,  669,  681,  705,
 454       506,  712,  703,  671,  666,  660,  664,  657,  669,  669,
 455       519,  523,  703,  654,  668,  668,  653,  698,  664,  660,
 456       653,  525,  528,  537,  648,  642,  646,  691,  654,  532,
 457
 458       534,  654,  653,  638,  651,  639,  637,  640,  542,  545,
 459       682,  645,  634,  628,  642,  631,  643,  547,  550,  558,
 460       553,  556,  675,  674,  673,  626,  663,  561,  638,  637,
 461       622,  635,  619,  630,  628,  569,  564,  572,  617,  611,
 462       615,  660,  623,  574,  658,  576,  578,  586,  588,  596,
 463       657,  591,  989,  605,  604,  619,  602,  617,  619,  603,
 464       598,  649,  648,  647,  646,  573,  601,  587,  408,  594,
 465       989,  989,  545,  989,  541,  495,  483,  500,  604,  503,
 466       493,  606,  614,  609,  989,  446,  444,  989,  449,  611,
 467       616,  618,  620,  622,  989,  989,  353,  323,  116,  624,
 468
 469       626,   94,  989,  628,  630,  632,  634,  636,  638,  989,
 470       989,  989,  989
 471     } ;
 472
 473 static yyconst short int yy_def[614] =
 474     {   0,
 475       613,    1,  613,  613,  613,  613,  613,  613,  613,  613,
 476       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 477       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 478       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 479       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 480       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 481       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 482       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 483       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 484       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 485
 486       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 487       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 488       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 489       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 490       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 491       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 492       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 493       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 494       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 495       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 496
 497       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 498       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 499       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 500       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 501       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 502       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 503       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 504       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 505       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 506       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 507
 508       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 509       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 510       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 511       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 512       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 513       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 514       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 515       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 516       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 517       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 518
 519       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 520       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 521       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 522       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 523       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 524       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 525       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 526       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 527       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 528       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 529
 530       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 531       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 532       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 533       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 534       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 535       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 536       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 537       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 538       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 539       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 540
 541       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 542       613,  613,    0
 543     } ;
 544
 545 static yyconst short int yy_nxt[1043] =
 546     {   0,
 547         4,    4,    4,    5,    4,    6,    4,    7,    7,    4,
 548         8,    9,   10,   11,   12,   13,   14,   15,   16,   17,
 549        18,   19,   20,   21,   22,   23,   24,   25,   26,   27,
 550        28,   29,    4,   30,   31,   32,   11,   33,   34,   35,
 551        16,   36,   18,   37,   38,   21,   39,   23,   24,   25,
 552        40,   23,   41,   42,   42,   43,   43,  102,   44,   45,
 553        46,   76,   47,   81,   48,   49,   79,   50,  103,   51,
 554        52,   84,   53,   82,   77,   71,   54,   97,   55,   80,
 555        94,   56,   57,   58,   85,   59,   60,   61,   72,   62,
 556        98,   63,   64,   86,   65,  583,   90,   68,   66,   95,
 557
 558        67,   69,   69,   70,   70,  106,   87,   99,   73,   91,
 559       113,  100,   74,   88,  115,  108,   92,  158,  107,  159,
 560       118,  110,  114,  182,  101,  605,  116,  183,   93,  109,
 561        89,   73,  119,  111,   88,   74,   95,  120,   92,  124,
 562       125,  122,  127,  129,  129,  130,  130,   71,   76,  121,
 563        93,   89,  126,  123,  128,   79,   84,   86,   90,   97,
 564        72,   77,  106,  194,  110,  113,  115,  118,   80,   85,
 565        87,   91,   98,  120,  122,  107,  111,  114,  116,  119,
 566       125,  127,  139,  139,   68,  121,  123,  186,   69,   69,
 567       162,  194,  126,  128,   68,  163,  180,  180,  181,  181,
 568
 569       194,  194,  195,  131,  187,  194,  132,  194,  133,  194,
 570       199,  194,  134,  200,  135,  136,  137,  194,  194,  138,
 571       192,  192,  193,  193,  199,  199,  131,  200,  200,  132,
 572       194,  224,  199,  225,  134,  200,  135,  136,  137,  199,
 573       196,  138,  200,  197,  261,  201,  198,  204,  261,  199,
 574       202,  205,  200,  208,  207,  199,  203,  261,  200,  206,
 575       217,  217,  218,  218,  226,  231,  232,  211,  261,  227,
 576       192,  192,  261,  194,  209,  261,  261,  378,  210,  233,
 577       233,  261,  261,  262,  261,  212,  261,  273,  273,  274,
 578       274,  283,  378,  264,  281,  284,  213,  263,  214,  199,
 579
 580       282,  282,  353,  353,  275,  238,  238,  276,  239,  269,
 581       287,  240,  199,  241,  265,  200,  379,  242,  268,  243,
 582       244,  245,  270,  267,  246,  266,  386,  288,  271,  272,
 583       275,  239,  604,  276,  240,  339,  277,  277,  261,  242,
 584       340,  243,  244,  245,  306,  307,  246,  317,  337,  317,
 585       338,  275,  378,  318,  318,  319,  319,  320,  321,  281,
 586       199,  199,  378,  200,  200,  354,  354,  378,  324,  317,
 587       368,  325,  378,  326,  369,  362,  362,  327,  372,  328,
 588       329,  330,  363,  363,  331,  378,  317,  364,  364,  365,
 589       365,  324,  363,  363,  325,  373,  378,  378,  382,  327,
 590
 591       378,  328,  329,  330,  378,  603,  331,  199,  381,  583,
 592       200,  380,  397,  416,  397,  417,  383,  584,  398,  398,
 593       399,  399,  405,  405,  406,  418,  199,  448,  407,  200,
 594       419,  408,  385,  387,  409,  409,  384,  199,  448,  407,
 595       200,  378,  408,  397,  388,  410,  410,  423,  423,  435,
 596       435,  397,  389,  436,  436,  441,  441,  436,  436,  407,
 597       447,  447,  407,  448,  448,  408,  449,  448,  447,  447,
 598       448,  448,  448,  442,  451,  448,  448,  448,  199,  443,
 599       476,  200,  597,  460,  444,  445,  461,  446,  478,  462,
 600       462,  470,  470,  471,  473,  473,  596,  477,  595,  479,
 601
 602       407,  443,  582,  408,  448,  456,  444,  445,  455,  579,
 603       452,  457,  450,  500,  500,  460,  453,  448,  461,  589,
 604       458,  454,  460,  481,  482,  459,  509,  509,  492,  493,
 605       510,  510,  518,  518,  519,  520,  520,  519,  494,  527,
 606       527,  528,  528,  536,  521,  522,  536,  588,  544,  537,
 607       537,  545,  538,  538,  546,  546,  519,  547,  547,  544,
 608       549,  549,  545,  550,  550,  548,  548,  519,  553,  553,
 609       536,  562,  562,  536,  587,  544,  561,  561,  586,  562,
 610       562,  567,  567,  568,  568,  569,  569,  544,  544,  544,
 611       545,  545,  545,  568,  568,  546,  546,  544,  570,  570,
 612
 613       545,  585,  585,  548,  548,  578,  578,  579,  581,  581,
 614       582,  590,  590,  591,  591,  583,  594,  594,  598,  598,
 615       580,  592,  593,  599,  599,  600,  600,  601,  601,  602,
 616       602,  606,  606,  607,  607,  608,  608,  609,  609,  610,
 617       610,  610,  610,  611,  611,  612,  612,  448,  448,  448,
 618       536,  577,  576,  575,  574,  573,  572,  571,  378,  544,
 619       566,  448,  565,  564,  563,  560,  559,  558,  557,  556,
 620       555,  554,  552,  551,  378,  378,  378,  543,  542,  541,
 621       419,  540,  539,  448,  535,  534,  533,  532,  531,  530,
 622       529,  526,  378,  525,  524,  523,  517,  516,  515,  448,
 623
 624       514,  513,  512,  511,  448,  508,  507,  506,  505,  504,
 625       503,  502,  501,  261,  471,  499,  498,  497,  340,  496,
 626       495,  378,  494,  491,  490,  489,  488,  448,  448,  487,
 627       486,  485,  484,  483,  480,  475,  474,  472,  261,  261,
 628       261,  397,  194,  469,  468,  467,  378,  466,  465,  464,
 629       463,  378,  448,  407,  406,  440,  261,  439,  438,  437,
 630       434,  433,  194,  432,  431,  430,  429,  378,  378,  428,
 631       427,  426,  425,  424,  422,  421,  420,  415,  414,  413,
 632       412,  411,  194,  194,  317,  404,  403,  402,  227,  401,
 633       400,  261,  396,  395,  394,  393,  392,  391,  194,  390,
 634
 635       378,  377,  376,  375,  374,  371,  370,  367,  366,  361,
 636       360,  359,  261,  358,  357,  356,  355,  261,  352,  351,
 637       350,  349,  348,  347,  346,  345,  344,  163,  343,  342,
 638       341,  336,  335,  334,  333,  332,  281,  323,  322,  194,
 639       275,  316,  315,  314,  313,  261,  261,  312,  311,  310,
 640       309,  308,  305,  304,  303,  302,  301,  300,  299,  298,
 641       297,  296,  295,  194,  294,  293,  292,  291,  290,  289,
 642       286,  285,  280,  279,  278,  194,  261,  260,  259,  258,
 643       257,  256,  255,  254,  253,  252,  251,  250,  249,  194,
 644       194,  248,  247,  199,  237,  236,  235,  234,  230,  229,
 645
 646       228,  223,  222,  221,  220,  219,  216,  215,  194,  191,
 647       190,  189,  188,  185,  184,  177,  176,  169,  168,  165,
 648       161,  160,  156,  155,  154,  153,  152,  149,  148,  146,
 649       145,  144,  141,  140,  179,  178,  177,  176,  175,  174,
 650       173,  172,  171,  170,  169,  168,  167,  166,  165,  164,
 651       161,  160,  157,  156,  155,  154,  153,  152,  151,  150,
 652       149,  148,  147,  146,  145,  144,  143,  142,  141,  140,
 653       104,  124,  117,  112,  104,   94,   83,   75,  104,  117,
 654       112,  105,  104,   96,   83,   78,   75,  613,    3,  613,
 655       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 656
 657       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 658       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 659       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 660       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 661       613,  613
 662     } ;
 663
 664 static yyconst short int yy_chk[1043] =
 665     {   0,
 666         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 667         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 668         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 669         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 670         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 671         1,    1,    1,    5,    5,    6,    6,   25,    6,    6,
 672         6,   10,    6,   13,    6,    6,   12,    6,   25,    6,
 673         6,   15,    6,   13,   10,    8,    6,   22,    6,   12,
 674        20,    6,    6,    6,   15,    6,    6,    6,    8,    6,
 675        22,    6,    6,   17,    6,  602,   19,    7,    6,   20,
 676
 677         6,    7,    7,    7,    7,   28,   17,   24,    8,   19,
 678        32,   24,    8,   17,   33,   29,   19,   89,   28,   89,
 679        35,   30,   32,  131,   24,  599,   33,  131,   19,   29,
 680        17,   30,   35,   30,   36,   30,   38,   36,   37,   38,
 681        39,   37,   41,   42,   42,   43,   43,   44,   46,   36,
 682        37,   36,   39,   37,   41,   47,   49,   50,   51,   53,
 683        44,   46,   55,  142,   56,   58,   59,   61,   47,   49,
 684        50,   51,   53,   62,   63,   55,   56,   58,   59,   61,
 685        65,   67,   69,   69,   70,   62,   63,  134,   70,   70,
 686        92,  143,   65,   67,   68,   92,  129,  129,  130,  130,
 687
 688       150,  157,  142,   68,  134,  158,   68,  147,   68,  167,
 689       151,  159,   68,  151,   68,   68,   68,  162,  166,   68,
 690       139,  139,  139,  139,  164,  170,   68,  164,  170,   68,
 691       171,  187,  172,  187,   68,  172,   68,   68,   68,  173,
 692       143,   68,  173,  147,  219,  151,  150,  159,  220,  174,
 693       157,  162,  174,  167,  166,  175,  158,  221,  175,  164,
 694       180,  180,  181,  181,  188,  192,  192,  172,  222,  188,
 695       193,  193,  224,  194,  170,  226,  223,  332,  171,  194,
 696       194,  230,  225,  219,  229,  173,  228,  231,  231,  232,
 697       232,  239,  339,  221,  238,  239,  174,  220,  175,  199,
 698
 699       238,  238,  306,  306,  277,  199,  199,  277,  199,  226,
 700       242,  199,  293,  199,  222,  293,  332,  199,  225,  199,
 701       199,  199,  228,  224,  199,  223,  339,  242,  229,  230,
 702       233,  199,  598,  233,  199,  289,  233,  233,  261,  199,
 703       289,  199,  199,  199,  261,  261,  199,  273,  288,  274,
 704       288,  275,  335,  273,  273,  274,  274,  275,  275,  281,
 705       295,  300,  333,  295,  300,  307,  307,  336,  281,  317,
 706       324,  281,  334,  281,  324,  317,  317,  281,  327,  281,
 707       281,  281,  318,  318,  281,  337,  319,  320,  320,  321,
 708       321,  281,  319,  319,  281,  327,  338,  341,  335,  281,
 709
 710       342,  281,  281,  281,  343,  597,  281,  349,  334,  569,
 711       349,  333,  353,  373,  354,  373,  336,  569,  353,  353,
 712       354,  354,  362,  362,  362,  374,  391,  411,  364,  391,
 713       374,  364,  338,  341,  364,  364,  337,  393,  413,  365,
 714       393,  378,  365,  397,  342,  365,  365,  378,  378,  397,
 715       397,  399,  343,  398,  398,  406,  406,  399,  399,  407,
 716       409,  409,  410,  412,  414,  410,  411,  415,  410,  410,
 717       416,  418,  417,  407,  413,  420,  421,  422,  434,  407,
 718       444,  434,  589,  423,  407,  407,  423,  407,  445,  423,
 719       423,  435,  435,  435,  441,  441,  587,  444,  586,  445,
 720
 721       447,  407,  581,  447,  580,  418,  407,  407,  417,  578,
 722       414,  420,  412,  471,  471,  462,  415,  448,  462,  577,
 723       421,  416,  460,  448,  448,  422,  481,  481,  460,  460,
 724       482,  482,  492,  492,  492,  493,  493,  493,  494,  500,
 725       500,  501,  501,  509,  494,  494,  510,  576,  518,  509,
 726       509,  518,  510,  510,  518,  518,  518,  519,  519,  520,
 727       521,  521,  520,  522,  522,  520,  520,  520,  528,  528,
 728       536,  537,  537,  538,  575,  544,  536,  536,  573,  538,
 729       538,  544,  544,  546,  546,  547,  547,  548,  568,  549,
 730       548,  568,  549,  548,  548,  549,  549,  550,  552,  552,
 731
 732       550,  570,  570,  550,  550,  561,  561,  561,  567,  567,
 733       567,  579,  579,  582,  582,  583,  584,  584,  590,  590,
 734       566,  583,  583,  591,  591,  592,  592,  593,  593,  594,
 735       594,  600,  600,  601,  601,  604,  604,  605,  605,  606,
 736       606,  607,  607,  608,  608,  609,  609,  565,  564,  563,
 737       562,  560,  559,  558,  557,  556,  555,  554,  551,  545,
 738       543,  542,  541,  540,  539,  535,  534,  533,  532,  531,
 739       530,  529,  527,  526,  525,  524,  523,  517,  516,  515,
 740       514,  513,  512,  511,  508,  507,  506,  505,  504,  503,
 741       502,  499,  498,  497,  496,  495,  491,  490,  489,  488,
 742
 743       487,  486,  485,  484,  483,  480,  479,  478,  477,  476,
 744       475,  474,  473,  472,  470,  469,  468,  467,  466,  465,
 745       464,  463,  461,  459,  458,  457,  456,  455,  454,  453,
 746       452,  451,  450,  449,  446,  443,  442,  440,  439,  438,
 747       437,  436,  433,  432,  431,  430,  429,  428,  427,  426,
 748       425,  424,  419,  408,  405,  404,  403,  402,  401,  400,
 749       394,  392,  390,  389,  388,  387,  386,  385,  384,  383,
 750       382,  381,  380,  379,  377,  376,  375,  372,  371,  370,
 751       369,  368,  367,  366,  363,  361,  360,  359,  358,  357,
 752       356,  355,  352,  351,  350,  348,  347,  346,  345,  344,
 753
 754       340,  331,  330,  329,  328,  326,  325,  323,  322,  316,
 755       315,  314,  313,  312,  311,  310,  309,  308,  305,  304,
 756       303,  302,  301,  299,  298,  297,  296,  294,  292,  291,
 757       290,  287,  286,  285,  284,  283,  282,  280,  279,  278,
 758       276,  272,  271,  270,  269,  268,  267,  266,  265,  264,
 759       263,  262,  260,  259,  258,  257,  256,  255,  254,  253,
 760       252,  251,  250,  249,  248,  247,  246,  245,  244,  243,
 761       241,  240,  237,  236,  235,  234,  227,  216,  215,  214,
 762       213,  212,  211,  210,  209,  208,  207,  206,  205,  204,
 763       203,  202,  201,  200,  198,  197,  196,  195,  191,  190,
 764
 765       189,  186,  185,  184,  183,  182,  179,  178,  163,  138,
 766       137,  136,  135,  133,  132,  128,  127,  126,  125,  124,
 767       123,  122,  121,  120,  119,  118,  117,  116,  115,  114,
 768       113,  112,  111,  110,  109,  108,  107,  106,  105,  103,
 769       102,  101,  100,   99,   98,   97,   96,   95,   94,   93,
 770        91,   90,   88,   87,   86,   85,   84,   83,   82,   81,
 771        80,   79,   78,   77,   76,   75,   74,   73,   72,   71,
 772        66,   64,   60,   57,   54,   52,   48,   45,   40,   34,
 773        31,   27,   26,   21,   14,   11,    9,    3,  613,  613,
 774       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 775
 776       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 777       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 778       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 779       613,  613,  613,  613,  613,  613,  613,  613,  613,  613,
 780       613,  613
 781     } ;
 782
 783 static yy_state_type yy_last_accepting_state;
 784 static char *yy_last_accepting_cpos;
 785
 786 /* The intent behind this definition is that it'll catch
 787  * any uses of REJECT which flex missed.
 788  */
 789 #define REJECT reject_used_but_not_detected
 790 #define yymore() yymore_used_but_not_detected
 791 #define YY_MORE_ADJ 0
 792 #define YY_RESTORE_YY_MORE_OFFSET
 793 char *yytext;
 794 #line 1 "dtimep.lex"
 795 #define INITIAL 0
 796 #line 6 "dtimep.lex"
 797 #include <h/nmh.h>
 798 #include <h/tws.h>
 799
 800   /* Since we're looking at a string at a time, don't worry about
 801    *  wrapping to the next buffer.
 802    */
 803 #define yywrap() 1
 804 #define YY_SKIP_YYWRAP
 805
 806 #define YY_NO_UNPUT
 807
 808   /* This is the tricky thing that makes this function cool.  We
 809    *  replace the traditional int yylex(void) declaration with our
 810    *  dparsetime() declaration, essentially piggy-backing off the
 811    *  utility of the yylex() function and adding what we need to make
 812    *  the parsing function useful to us.
 813    */
 814 #define YY_DECL struct tws *dparsetime(char *lexstr)
 815
 816   /* yyerminate() is called after the input string is matched to
 817    * completion (actually, when the lexer reaches an EOF).  The only
 818    * thing that really needs to be in this macro function is the
 819    * return call, which must be substituted inline into dparsetime.
 820    */
 821
 822 #define yyterminate() (void)yy_delete_buffer(lexhandle); \
 823   if(!(tw.tw_flags & TW_SUCC)) { \
 824     return (struct tws *)NULL; \
 825   } \
 826   if(tw.tw_year < 1960) \
 827     tw.tw_year += 1900; \
 828   if(tw.tw_year < 1960) \
 829     tw.tw_year += 100; \
 830   return(&tw)
 831
 832 /*
 833  * Patchable flag that says how to interpret NN/NN/NN dates. When
 834  * true, we do it European style: DD/MM/YY. When false, we do it
 835  * American style: MM/DD/YY.  Of course, these are all non-RFC822
 836  * compliant.
 837  */
 838 int europeandate = 0;
 839
 840 /*
 841  * Table to convert month names to numeric month.  We use the
 842  * fact that the low order 5 bits of the sum of the 2nd & 3rd
 843  * characters of the name is a hash with no collisions for the 12
 844  * valid month names.  (The mask to 5 bits maps any combination of
 845  * upper and lower case into the same hash value).
 846  */
 847 static int month_map[] = {
 848         0,
 849         6,      /* 1 - Jul */
 850         3,      /* 2 - Apr */
 851         5,      /* 3 - Jun */
 852         0,
 853         10,     /* 5 - Nov */
 854         0,
 855         1,      /* 7 - Feb */
 856         11,     /* 8 - Dec */
 857         0,
 858         0,
 859         0,
 860         0,
 861         0,
 862         0,
 863         0,      /*15 - Jan */
 864         0,
 865         0,
 866         0,
 867         2,      /*19 - Mar */
 868         0,
 869         8,      /*21 - Sep */
 870         0,
 871         9,      /*23 - Oct */
 872         0,
 873         0,
 874         4,      /*26 - May */
 875         0,
 876         7       /*28 - Aug */
 877 };
 878
 879 /*
 880  * Lookup table for day-of-week using the same hash trick as for above name-of-
 881  * month table, but using the first and second character, not second and third.
 882  *
 883  * Compute index into table using: (day_name[0] & 7) + (day_name[1] & 4)
 884  */
 885 static int day_map[] = {
 886         0,
 887         0,
 888         0,
 889         6,      /* 3 - Sat */
 890         4,      /* 4 - Thu */
 891         0,
 892         5,      /* 6 - Fri */
 893         0,      /* 7 - Sun */
 894         2,      /* 8 - Tue */
 895         1       /* 9 - Mon */,
 896         0,
 897         3       /*11 - Wed */
 898 };
 899
 900 /* The SET* macros will parse for the appropriate field, and leave the
 901  * cp pointer at the first character after the desired field. Be
 902  * careful with variable-length fields or alpha-num mixes.
 903
 904  * The SKIP* macros skip over characters of a particular class and
 905  * leave cp at the position of the first character that doesn't match
 906  * that class. Correspondingly, SKIPTO* skips until it reaches a
 907  * character of a particular class.
 908  */
 909
 910 #define INIT()       { cp = yytext;}
 911 #define SETWDAY()    { tw.tw_wday= day_map[(cp[0] & 7) + (cp[1] & 4)]; \
 912                        tw.tw_flags &= ~TW_SDAY; tw.tw_flags |= TW_SEXP; \
 913                        SKIPA(); }
 914 #define SETMON()     { cp++; \
 915                        tw.tw_mon = month_map[(cp[0] + cp[1]) & 0x1f]; \
 916                        SKIPA(); }
 917 #define SETMON_NUM() { tw.tw_mon = atoi(cp)-1; \
 918                        SKIPD(); }
 919 #define SETYEAR()    { tw.tw_year = atoi(cp); \
 920                        SKIPD(); }
 921 #define SETDAY()     { tw.tw_mday = atoi(cp); \
 922                        tw.tw_flags |= TW_YES; \
 923                        SKIPD(); }
 924 #define SETTIME()    { tw.tw_hour = atoi(cp); \
 925                        cp += 2; \
 926                        SKIPTOD(); \
 927                        tw.tw_min = atoi(cp); \
 928                        cp += 2; \
 929                        if(*cp == ':') { \
 930                           tw.tw_sec = atoi(++cp); SKIPD(); } }
 931 #define SETZONE(x)   { tw.tw_zone = ((x)/100)*60+(x)%100; \
 932                        tw.tw_flags |= TW_SZEXP; \
 933                        SKIPD(); }
 934 #define SETDST()     { tw.tw_flags |= TW_DST; }
 935 #define SKIPD()      { while ( isdigit(*cp++) ) ; \
 936                        --cp; }
 937 #define SKIPTOD()    { while ( !isdigit(*cp++) ) ; \
 938                        --cp; }
 939 #define SKIPA()      { while ( isalpha(*cp++) ) ; \
 940                        --cp; }
 941 #define SKIPTOA()    { while ( !isalpha(*cp++) ) ; \
 942                        --cp; }
 943 #define SKIPSP()     { while ( isspace(*cp++) ) ; \
 944                        --cp; }
 945 #define SKIPTOSP()   { while ( !isspace(*cp++) ) ; \
 946                        --cp; }
 947
 948 #ifdef DSTXXX
 949 # ifdef TIME_WITH_SYS_TIME
 950 #  include <sys/time.h>
 951 #  include <time.h>
 952 # else
 953 #  ifdef HAVE_SYS_TIME_H
 954 #   include <sys/time.h>
 955 #  else
 956 #   include <time.h>
 957 #  endif
 958 # endif
 959
 960 static void
 961 zonehack (struct tws *tw)
 962 {
 963     register struct tm *tm;
 964
 965     if (dmktime (tw) == (time_t) -1)
 966         return;
 967
 968     tm = localtime (&tw->tw_clock);
 969     if (tm->tm_isdst) {
 970         tw->tw_flags |= TW_DST;
 971         tw->tw_zone -= 60;
 972     }
 973 }
 974 #endif  /* DSTXXX */
 975 /* The year can either be 2 digits, or 4. However, after
 976 Y2K, we found that some MUA were reporting the year 100, hence
 977 the middle term here. yyterminate() resolves the actual
 978 issues with 2-digit years.
 979 */
 980
 981 /* Macros after this point can all be overridden by user definitions in
 982  * section 1.
 983  */
 984
 985 #ifndef YY_SKIP_YYWRAP
 986 #ifdef __cplusplus
 987 extern "C" int yywrap YY_PROTO(( void ));
 988 #else
 989 extern int yywrap YY_PROTO(( void ));
 990 #endif
 991 #endif
 992
 993 #ifndef YY_NO_UNPUT
 994 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
 995 #endif
 996
 997 #ifndef yytext_ptr
 998 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
 999 #endif
1000
1001 #ifdef YY_NEED_STRLEN
1002 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
1003 #endif
1004
1005 #ifndef YY_NO_INPUT
1006 #ifdef __cplusplus
1007 static int yyinput YY_PROTO(( void ));
1008 #else
1009 static int input YY_PROTO(( void ));
1010 #endif
1011 #endif
1012
1013 #if YY_STACK_USED
1014 static int yy_start_stack_ptr = 0;
1015 static int yy_start_stack_depth = 0;
1016 static int *yy_start_stack = 0;
1017 #ifndef YY_NO_PUSH_STATE
1018 static void yy_push_state YY_PROTO(( int new_state ));
1019 #endif
1020 #ifndef YY_NO_POP_STATE
1021 static void yy_pop_state YY_PROTO(( void ));
1022 #endif
1023 #ifndef YY_NO_TOP_STATE
1024 static int yy_top_state YY_PROTO(( void ));
1025 #endif
1026
1027 #else
1028 #define YY_NO_PUSH_STATE 1
1029 #define YY_NO_POP_STATE 1
1030 #define YY_NO_TOP_STATE 1
1031 #endif
1032
1033 #ifdef YY_MALLOC_DECL
1034 YY_MALLOC_DECL
1035 #else
1036 #if __STDC__
1037 #ifndef __cplusplus
1038 #include <stdlib.h>
1039 #endif
1040 #else
1041 /* Just try to get by without declaring the routines.  This will fail
1042  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
1043  * or sizeof(void*) != sizeof(int).
1044  */
1045 #endif
1046 #endif
1047
1048 /* Amount of stuff to slurp up with each read. */
1049 #ifndef YY_READ_BUF_SIZE
1050 #define YY_READ_BUF_SIZE 8192
1051 #endif
1052
1053 /* Copy whatever the last rule matched to the standard output. */
1054
1055 #ifndef ECHO
1056 /* This used to be an fputs(), but since the string might contain NUL's,
1057  * we now use fwrite().
1058  */
1059 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
1060 #endif
1061
1062 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1063  * is returned in "result".
1064  */
1065 #ifndef YY_INPUT
1066 #define YY_INPUT(buf,result,max_size) \
1067         if ( yy_current_buffer->yy_is_interactive ) \
1068                 { \
1069                 int c = '*', n; \
1070                 for ( n = 0; n < max_size && \
1071                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1072                         buf[n] = (char) c; \
1073                 if ( c == '\n' ) \
1074                         buf[n++] = (char) c; \
1075                 if ( c == EOF && ferror( yyin ) ) \
1076                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1077                 result = n; \
1078                 } \
1079         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
1080                   && ferror( yyin ) ) \
1081                 YY_FATAL_ERROR( "input in flex scanner failed" );
1082 #endif
1083
1084 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1085  * we don't want an extra ';' after the "return" because that will cause
1086  * some compilers to complain about unreachable statements.
1087  */
1088 #ifndef yyterminate
1089 #define yyterminate() return YY_NULL
1090 #endif
1091
1092 /* Number of entries by which start-condition stack grows. */
1093 #ifndef YY_START_STACK_INCR
1094 #define YY_START_STACK_INCR 25
1095 #endif
1096
1097 /* Report a fatal error. */
1098 #ifndef YY_FATAL_ERROR
1099 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1100 #endif
1101
1102 /* Default declaration of generated scanner - a define so the user can
1103  * easily add parameters.
1104  */
1105 #ifndef YY_DECL
1106 #define YY_DECL int yylex YY_PROTO(( void ))
1107 #endif
1108
1109 /* Code executed at the beginning of each rule, after yytext and yyleng
1110  * have been set up.
1111  */
1112 #ifndef YY_USER_ACTION
1113 #define YY_USER_ACTION
1114 #endif
1115
1116 /* Code executed at the end of each rule. */
1117 #ifndef YY_BREAK
1118 #define YY_BREAK break;
1119 #endif
1120
1121 #define YY_RULE_SETUP \
1122         YY_USER_ACTION
1123
1124 YY_DECL
1125         {
1126         register yy_state_type yy_current_state;
1127         register char *yy_cp, *yy_bp;
1128         register int yy_act;
1129
1130 #line 226 "dtimep.lex"
1131
1132
1133   /* This section begins the definition of dparsetime().
1134      Put here any local variable definitions and initializations */
1135
1136   YY_BUFFER_STATE lexhandle;
1137
1138   register char *cp;
1139   static struct tws tw;
1140
1141   memset(&tw,0,sizeof(struct tws));
1142
1143   lexhandle = yy_scan_string(lexstr);
1144
1145
1146
1147         if ( yy_init )
1148                 {
1149                 yy_init = 0;
1150
1151 #ifdef YY_USER_INIT
1152                 YY_USER_INIT;
1153 #endif
1154
1155                 if ( ! yy_start )
1156                         yy_start = 1;   /* first start state */
1157
1158                 if ( ! yyin )
1159                         yyin = stdin;
1160
1161                 if ( ! yyout )
1162                         yyout = stdout;
1163
1164                 if ( ! yy_current_buffer )
1165                         yy_current_buffer =
1166                                 yy_create_buffer( yyin, YY_BUF_SIZE );
1167
1168                 yy_load_buffer_state();
1169                 }
1170
1171         while ( 1 )             /* loops until end-of-file is reached */
1172                 {
1173                 yy_cp = yy_c_buf_p;
1174
1175                 /* Support of yytext. */
1176                 *yy_cp = yy_hold_char;
1177
1178                 /* yy_bp points to the position in yy_ch_buf of the start of
1179                  * the current run.
1180                  */
1181                 yy_bp = yy_cp;
1182
1183                 yy_current_state = yy_start;
1184 yy_match:
1185                 do
1186                         {
1187                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1188                         if ( yy_accept[yy_current_state] )
1189                                 {
1190                                 yy_last_accepting_state = yy_current_state;
1191                                 yy_last_accepting_cpos = yy_cp;
1192                                 }
1193                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1194                                 {
1195                                 yy_current_state = (int) yy_def[yy_current_state];
1196                                 if ( yy_current_state >= 614 )
1197                                         yy_c = yy_meta[(unsigned int) yy_c];
1198                                 }
1199                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1200                         ++yy_cp;
1201                         }
1202                 while ( yy_base[yy_current_state] != 989 );
1203
1204 yy_find_action:
1205                 yy_act = yy_accept[yy_current_state];
1206                 if ( yy_act == 0 )
1207                         { /* have to back up */
1208                         yy_cp = yy_last_accepting_cpos;
1209                         yy_current_state = yy_last_accepting_state;
1210                         yy_act = yy_accept[yy_current_state];
1211                         }
1212
1213                 YY_DO_BEFORE_ACTION;
1214
1215
1216 do_action:      /* This label is used only to access EOF actions. */
1217
1218
1219                 switch ( yy_act )
1220         { /* beginning of action switch */
1221                         case 0: /* must back up */
1222                         /* undo the effects of YY_DO_BEFORE_ACTION */
1223                         *yy_cp = yy_hold_char;
1224                         yy_cp = yy_last_accepting_cpos;
1225                         yy_current_state = yy_last_accepting_state;
1226                         goto yy_find_action;
1227
1228 case 1:
1229 YY_RULE_SETUP
1230 #line 241 "dtimep.lex"
1231 {
1232                                      INIT();
1233                                      SETWDAY();
1234                                      SKIPTOA();
1235                                      SETMON();
1236                                      SKIPTOD();
1237                                      SETDAY();
1238                                      SKIPTOD();
1239                                      SETTIME();
1240                                      SKIPTOD();
1241                                      SETYEAR();
1242                                      }
1243         YY_BREAK
1244 case 2:
1245 YY_RULE_SETUP
1246 #line 254 "dtimep.lex"
1247 {
1248                                      INIT();
1249                                      SETWDAY();
1250                                      SKIPTOD();
1251                                      SETDAY();
1252                                      SKIPTOA();
1253                                      SETMON();
1254                                      SKIPTOD();
1255                                      SETYEAR();
1256                                      SKIPTOD();
1257                                      SETTIME();
1258                                      }
1259         YY_BREAK
1260 case 3:
1261 YY_RULE_SETUP
1262 #line 266 "dtimep.lex"
1263 {
1264                                      INIT();
1265                                      SETDAY();
1266                                      SKIPTOA();
1267                                      SETMON();
1268                                      SKIPTOD();
1269                                      SETYEAR();
1270                                      SKIPTOD();
1271                                      SETTIME();
1272                                      }
1273         YY_BREAK
1274 case 4:
1275 YY_RULE_SETUP
1276 #line 276 "dtimep.lex"
1277 {
1278                                      INIT();
1279                                      SETWDAY();
1280                                      SKIPTOA();
1281                                      SETMON();
1282                                      SKIPTOD();
1283                                      SETDAY();
1284                                      SKIPTOD();
1285                                      SETYEAR();
1286                                      SKIPTOD();
1287                                      SETTIME();
1288                                      }
1289         YY_BREAK
1290 case 5:
1291 YY_RULE_SETUP
1292 #line 288 "dtimep.lex"
1293 {
1294                                      INIT();
1295                                      SETWDAY();
1296                                      SKIPTOA();
1297                                      SETMON();
1298                                      SKIPTOD();
1299                                      SETDAY();
1300                                      SKIPTOD();
1301                                      SETYEAR();
1302                                      }
1303         YY_BREAK
1304 case 6:
1305 YY_RULE_SETUP
1306 #line 298 "dtimep.lex"
1307 {
1308                                      INIT();
1309                                      SETMON();
1310                                      SKIPTOD();
1311                                      SETDAY();
1312                                      SKIPTOD();
1313                                      SETYEAR();
1314                                      SKIPTOA();
1315                                      SETWDAY();
1316                                      }
1317         YY_BREAK
1318 case 7:
1319 YY_RULE_SETUP
1320 #line 308 "dtimep.lex"
1321 {
1322                                      INIT();
1323                                      SETMON();
1324                                      SKIPTOD();
1325                                      SETDAY();
1326                                      SKIPTOD();
1327                                      SETYEAR();
1328                                      }
1329         YY_BREAK
1330 case 8:
1331 YY_RULE_SETUP
1332 #line 316 "dtimep.lex"
1333 {
1334                                      INIT();
1335                                      if(europeandate) {
1336                                        /* DD/MM/YY */
1337                                      SETDAY();
1338                                      SKIPTOD();
1339                                      SETMON_NUM();
1340                                      } else {
1341                                        /* MM/DD/YY */
1342                                      SETMON_NUM();
1343                                      SKIPTOD();
1344                                      SETDAY();
1345                                      }
1346                                      SKIPTOD();
1347                                      SETYEAR();
1348                                      SKIPTOD();
1349                                      SETTIME();
1350                                      }
1351         YY_BREAK
1352 case 9:
1353 YY_RULE_SETUP
1354 #line 334 "dtimep.lex"
1355 {
1356                                      INIT();
1357                                      if(europeandate) {
1358                                        /* DD/MM/YY */
1359                                      SETDAY();
1360                                      SKIPTOD();
1361                                      SETMON_NUM();
1362                                      } else {
1363                                        /* MM/DD/YY */
1364                                      SETMON_NUM();
1365                                      SKIPTOD();
1366                                      SETDAY();
1367                                      }
1368                                      SKIPTOD();
1369                                      SETYEAR();
1370                                      }
1371         YY_BREAK
1372 case 10:
1373 YY_RULE_SETUP
1374 #line 351 "dtimep.lex"
1375
1376         YY_BREAK
1377 case 11:
1378 YY_RULE_SETUP
1379 #line 352 "dtimep.lex"
1380 tw.tw_hour += 12;
1381         YY_BREAK
1382 case 12:
1383 YY_RULE_SETUP
1384 #line 354 "dtimep.lex"
1385 {
1386                                     INIT();
1387                                     SKIPTOD();
1388                                     SETZONE(atoi(cp));
1389 #ifdef  DSTXXX
1390                                     zonehack (&tw);
1391 #endif  /* DSTXXX */
1392                                     }
1393         YY_BREAK
1394 case 13:
1395 YY_RULE_SETUP
1396 #line 362 "dtimep.lex"
1397 {
1398                                     INIT();
1399                                     SKIPTOD();
1400                                     SETZONE(-atoi(cp));
1401 #ifdef  DSTXXX
1402                                     zonehack (&tw);
1403 #endif  /* DSTXXX */
1404                                     }
1405         YY_BREAK
1406 case 14:
1407 YY_RULE_SETUP
1408 #line 370 "dtimep.lex"
1409 INIT(); SETZONE(0);
1410         YY_BREAK
1411 case 15:
1412 YY_RULE_SETUP
1413 #line 371 "dtimep.lex"
1414 INIT(); SETZONE(0);
1415         YY_BREAK
1416 case 16:
1417 YY_RULE_SETUP
1418 #line 372 "dtimep.lex"
1419 INIT(); SETZONE(200);
1420         YY_BREAK
1421 case 17:
1422 YY_RULE_SETUP
1423 #line 373 "dtimep.lex"
1424 INIT(); SETDST(); SETZONE(2);
1425         YY_BREAK
1426 case 18:
1427 YY_RULE_SETUP
1428 #line 374 "dtimep.lex"
1429 INIT(); SETZONE(-500);
1430         YY_BREAK
1431 case 19:
1432 YY_RULE_SETUP
1433 #line 375 "dtimep.lex"
1434 INIT(); SETDST(); SETZONE(-500);
1435         YY_BREAK
1436 case 20:
1437 YY_RULE_SETUP
1438 #line 376 "dtimep.lex"
1439 INIT(); SETZONE(-600);
1440         YY_BREAK
1441 case 21:
1442 YY_RULE_SETUP
1443 #line 377 "dtimep.lex"
1444 INIT(); SETDST(); SETZONE(-600);
1445         YY_BREAK
1446 case 22:
1447 YY_RULE_SETUP
1448 #line 378 "dtimep.lex"
1449 INIT(); SETZONE(-700);
1450         YY_BREAK
1451 case 23:
1452 YY_RULE_SETUP
1453 #line 379 "dtimep.lex"
1454 INIT(); SETDST(); SETZONE(-700);
1455         YY_BREAK
1456 case 24:
1457 YY_RULE_SETUP
1458 #line 380 "dtimep.lex"
1459 INIT(); SETZONE(-800);
1460         YY_BREAK
1461 case 25:
1462 YY_RULE_SETUP
1463 #line 381 "dtimep.lex"
1464 INIT(); SETDST(); SETZONE(-800);
1465         YY_BREAK
1466 case 26:
1467 YY_RULE_SETUP
1468 #line 382 "dtimep.lex"
1469 INIT(); SETZONE(-330);
1470         YY_BREAK
1471 case 27:
1472 YY_RULE_SETUP
1473 #line 383 "dtimep.lex"
1474 INIT(); SETZONE(-400);
1475         YY_BREAK
1476 case 28:
1477 YY_RULE_SETUP
1478 #line 384 "dtimep.lex"
1479 INIT(); SETDST(); SETZONE(-400);
1480         YY_BREAK
1481 case 29:
1482 YY_RULE_SETUP
1483 #line 385 "dtimep.lex"
1484 INIT(); SETZONE(-900);
1485         YY_BREAK
1486 case 30:
1487 YY_RULE_SETUP
1488 #line 386 "dtimep.lex"
1489 INIT(); SETDST(); SETZONE(-900);
1490         YY_BREAK
1491 case 31:
1492 YY_RULE_SETUP
1493 #line 387 "dtimep.lex"
1494 INIT(); SETZONE(-1000);
1495         YY_BREAK
1496 case 32:
1497 YY_RULE_SETUP
1498 #line 388 "dtimep.lex"
1499 INIT(); SETDST(); SETZONE(-1000);
1500         YY_BREAK
1501 case 33:
1502 YY_RULE_SETUP
1503 #line 389 "dtimep.lex"
1504 INIT(); SETDST(); SETZONE(-100);
1505         YY_BREAK
1506 case 34:
1507 YY_RULE_SETUP
1508 #line 390 "dtimep.lex"
1509 {
1510                                        INIT();
1511                                        SETZONE(100*(('a'-1) - tolower(*cp)));
1512                                     }
1513         YY_BREAK
1514 case 35:
1515 YY_RULE_SETUP
1516 #line 394 "dtimep.lex"
1517 {
1518                                        INIT();
1519                                        SETZONE(100*('a' - tolower(*cp)));
1520                                     }
1521         YY_BREAK
1522 case 36:
1523 YY_RULE_SETUP
1524 #line 398 "dtimep.lex"
1525 {
1526                                        INIT();
1527                                        SETZONE(100*(tolower(*cp) - 'm'));
1528                                     }
1529         YY_BREAK
1530 case 37:
1531 YY_RULE_SETUP
1532 #line 402 "dtimep.lex"
1533
1534         YY_BREAK
1535 case 38:
1536 YY_RULE_SETUP
1537 #line 403 "dtimep.lex"
1538 ECHO;
1539         YY_BREAK
1540 case YY_STATE_EOF(INITIAL):
1541         yyterminate();
1542
1543         case YY_END_OF_BUFFER:
1544                 {
1545                 /* Amount of text matched not including the EOB char. */
1546                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1547
1548                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1549                 *yy_cp = yy_hold_char;
1550                 YY_RESTORE_YY_MORE_OFFSET
1551
1552                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1553                         {
1554                         /* We're scanning a new file or input source.  It's
1555                          * possible that this happened because the user
1556                          * just pointed yyin at a new source and called
1557                          * yylex().  If so, then we have to assure
1558                          * consistency between yy_current_buffer and our
1559                          * globals.  Here is the right place to do so, because
1560                          * this is the first action (other than possibly a
1561                          * back-up) that will match for the new input source.
1562                          */
1563                         yy_n_chars = yy_current_buffer->yy_n_chars;
1564                         yy_current_buffer->yy_input_file = yyin;
1565                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1566                         }
1567
1568                 /* Note that here we test for yy_c_buf_p "<=" to the position
1569                  * of the first EOB in the buffer, since yy_c_buf_p will
1570                  * already have been incremented past the NUL character
1571                  * (since all states make transitions on EOB to the
1572                  * end-of-buffer state).  Contrast this with the test
1573                  * in input().
1574                  */
1575                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1576                         { /* This was really a NUL. */
1577                         yy_state_type yy_next_state;
1578
1579                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1580
1581                         yy_current_state = yy_get_previous_state();
1582
1583                         /* Okay, we're now positioned to make the NUL
1584                          * transition.  We couldn't have
1585                          * yy_get_previous_state() go ahead and do it
1586                          * for us because it doesn't know how to deal
1587                          * with the possibility of jamming (and we don't
1588                          * want to build jamming into it because then it
1589                          * will run more slowly).
1590                          */
1591
1592                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1593
1594                         yy_bp = yytext_ptr + YY_MORE_ADJ;
1595
1596                         if ( yy_next_state )
1597                                 {
1598                                 /* Consume the NUL. */
1599                                 yy_cp = ++yy_c_buf_p;
1600                                 yy_current_state = yy_next_state;
1601                                 goto yy_match;
1602                                 }
1603
1604                         else
1605                                 {
1606                                 yy_cp = yy_c_buf_p;
1607                                 goto yy_find_action;
1608                                 }
1609                         }
1610
1611                 else switch ( yy_get_next_buffer() )
1612                         {
1613                         case EOB_ACT_END_OF_FILE:
1614                                 {
1615                                 yy_did_buffer_switch_on_eof = 0;
1616
1617                                 if ( yywrap() )
1618                                         {
1619                                         /* Note: because we've taken care in
1620                                          * yy_get_next_buffer() to have set up
1621                                          * yytext, we can now set up
1622                                          * yy_c_buf_p so that if some total
1623                                          * hoser (like flex itself) wants to
1624                                          * call the scanner after we return the
1625                                          * YY_NULL, it'll still work - another
1626                                          * YY_NULL will get returned.
1627                                          */
1628                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1629
1630                                         yy_act = YY_STATE_EOF(YY_START);
1631                                         goto do_action;
1632                                         }
1633
1634                                 else
1635                                         {
1636                                         if ( ! yy_did_buffer_switch_on_eof )
1637                                                 YY_NEW_FILE;
1638                                         }
1639                                 break;
1640                                 }
1641
1642                         case EOB_ACT_CONTINUE_SCAN:
1643                                 yy_c_buf_p =
1644                                         yytext_ptr + yy_amount_of_matched_text;
1645
1646                                 yy_current_state = yy_get_previous_state();
1647
1648                                 yy_cp = yy_c_buf_p;
1649                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1650                                 goto yy_match;
1651
1652                         case EOB_ACT_LAST_MATCH:
1653                                 yy_c_buf_p =
1654                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1655
1656                                 yy_current_state = yy_get_previous_state();
1657
1658                                 yy_cp = yy_c_buf_p;
1659                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1660                                 goto yy_find_action;
1661                         }
1662                 break;
1663                 }
1664
1665         default:
1666                 YY_FATAL_ERROR(
1667                         "fatal flex scanner internal error--no action found" );
1668         } /* end of action switch */
1669                 } /* end of scanning one token */
1670         } /* end of yylex */
1671
1672
1673 /* yy_get_next_buffer - try to read in a new buffer
1674  *
1675  * Returns a code representing an action:
1676  *      EOB_ACT_LAST_MATCH -
1677  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1678  *      EOB_ACT_END_OF_FILE - end of file
1679  */
1680
1681 static int yy_get_next_buffer()
1682         {
1683         register char *dest = yy_current_buffer->yy_ch_buf;
1684         register char *source = yytext_ptr;
1685         register int number_to_move, i;
1686         int ret_val;
1687
1688         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1689                 YY_FATAL_ERROR(
1690                 "fatal flex scanner internal error--end of buffer missed" );
1691
1692         if ( yy_current_buffer->yy_fill_buffer == 0 )
1693                 { /* Don't try to fill the buffer, so this is an EOF. */
1694                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1695                         {
1696                         /* We matched a single character, the EOB, so
1697                          * treat this as a final EOF.
1698                          */
1699                         return EOB_ACT_END_OF_FILE;
1700                         }
1701
1702                 else
1703                         {
1704                         /* We matched some text prior to the EOB, first
1705                          * process it.
1706                          */
1707                         return EOB_ACT_LAST_MATCH;
1708                         }
1709                 }
1710
1711         /* Try to read more data. */
1712
1713         /* First move last chars to start of buffer. */
1714         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1715
1716         for ( i = 0; i < number_to_move; ++i )
1717                 *(dest++) = *(source++);
1718
1719         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1720                 /* don't do the read, it's not guaranteed to return an EOF,
1721                  * just force an EOF
1722                  */
1723                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1724
1725         else
1726                 {
1727                 int num_to_read =
1728                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1729
1730                 while ( num_to_read <= 0 )
1731                         { /* Not enough room in the buffer - grow it. */
1732 #ifdef YY_USES_REJECT
1733                         YY_FATAL_ERROR(
1734 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1735 #else
1736
1737                         /* just a shorter name for the current buffer */
1738                         YY_BUFFER_STATE b = yy_current_buffer;
1739
1740                         int yy_c_buf_p_offset =
1741                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1742
1743                         if ( b->yy_is_our_buffer )
1744                                 {
1745                                 int new_size = b->yy_buf_size * 2;
1746
1747                                 if ( new_size <= 0 )
1748                                         b->yy_buf_size += b->yy_buf_size / 8;
1749                                 else
1750                                         b->yy_buf_size *= 2;
1751
1752                                 b->yy_ch_buf = (char *)
1753                                         /* Include room in for 2 EOB chars. */
1754                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1755                                                          b->yy_buf_size + 2 );
1756                                 }
1757                         else
1758                                 /* Can't grow it, we don't own it. */
1759                                 b->yy_ch_buf = 0;
1760
1761                         if ( ! b->yy_ch_buf )
1762                                 YY_FATAL_ERROR(
1763                                 "fatal error - scanner input buffer overflow" );
1764
1765                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1766
1767                         num_to_read = yy_current_buffer->yy_buf_size -
1768                                                 number_to_move - 1;
1769 #endif
1770                         }
1771
1772                 if ( num_to_read > YY_READ_BUF_SIZE )
1773                         num_to_read = YY_READ_BUF_SIZE;
1774
1775                 /* Read in more data. */
1776                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1777                         yy_n_chars, num_to_read );
1778
1779                 yy_current_buffer->yy_n_chars = yy_n_chars;
1780                 }
1781
1782         if ( yy_n_chars == 0 )
1783                 {
1784                 if ( number_to_move == YY_MORE_ADJ )
1785                         {
1786                         ret_val = EOB_ACT_END_OF_FILE;
1787                         yyrestart( yyin );
1788                         }
1789
1790                 else
1791                         {
1792                         ret_val = EOB_ACT_LAST_MATCH;
1793                         yy_current_buffer->yy_buffer_status =
1794                                 YY_BUFFER_EOF_PENDING;
1795                         }
1796                 }
1797
1798         else
1799                 ret_val = EOB_ACT_CONTINUE_SCAN;
1800
1801         yy_n_chars += number_to_move;
1802         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1803         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1804
1805         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1806
1807         return ret_val;
1808         }
1809
1810
1811 /* yy_get_previous_state - get the state just before the EOB char was reached */
1812
1813 static yy_state_type yy_get_previous_state()
1814         {
1815         register yy_state_type yy_current_state;
1816         register char *yy_cp;
1817
1818         yy_current_state = yy_start;
1819
1820         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1821                 {
1822                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1823                 if ( yy_accept[yy_current_state] )
1824                         {
1825                         yy_last_accepting_state = yy_current_state;
1826                         yy_last_accepting_cpos = yy_cp;
1827                         }
1828                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1829                         {
1830                         yy_current_state = (int) yy_def[yy_current_state];
1831                         if ( yy_current_state >= 614 )
1832                                 yy_c = yy_meta[(unsigned int) yy_c];
1833                         }
1834                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1835                 }
1836
1837         return yy_current_state;
1838         }
1839
1840
1841 /* yy_try_NUL_trans - try to make a transition on the NUL character
1842  *
1843  * synopsis
1844  *      next_state = yy_try_NUL_trans( current_state );
1845  */
1846
1847 #ifdef YY_USE_PROTOS
1848 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1849 #else
1850 static yy_state_type yy_try_NUL_trans( yy_current_state )
1851 yy_state_type yy_current_state;
1852 #endif
1853         {
1854         register int yy_is_jam;
1855         register char *yy_cp = yy_c_buf_p;
1856
1857         register YY_CHAR yy_c = 1;
1858         if ( yy_accept[yy_current_state] )
1859                 {
1860                 yy_last_accepting_state = yy_current_state;
1861                 yy_last_accepting_cpos = yy_cp;
1862                 }
1863         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1864                 {
1865                 yy_current_state = (int) yy_def[yy_current_state];
1866                 if ( yy_current_state >= 614 )
1867                         yy_c = yy_meta[(unsigned int) yy_c];
1868                 }
1869         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1870         yy_is_jam = (yy_current_state == 613);
1871
1872         return yy_is_jam ? 0 : yy_current_state;
1873         }
1874
1875
1876 #ifndef YY_NO_UNPUT
1877 #ifdef YY_USE_PROTOS
1878 static void yyunput( int c, register char *yy_bp )
1879 #else
1880 static void yyunput( c, yy_bp )
1881 int c;
1882 register char *yy_bp;
1883 #endif
1884         {
1885         register char *yy_cp = yy_c_buf_p;
1886
1887         /* undo effects of setting up yytext */
1888         *yy_cp = yy_hold_char;
1889
1890         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1891                 { /* need to shift things up to make room */
1892                 /* +2 for EOB chars. */
1893                 register int number_to_move = yy_n_chars + 2;
1894                 register char *dest = &yy_current_buffer->yy_ch_buf[
1895                                         yy_current_buffer->yy_buf_size + 2];
1896                 register char *source =
1897                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1898
1899                 while ( source > yy_current_buffer->yy_ch_buf )
1900                         *--dest = *--source;
1901
1902                 yy_cp += (int) (dest - source);
1903                 yy_bp += (int) (dest - source);
1904                 yy_current_buffer->yy_n_chars =
1905                         yy_n_chars = yy_current_buffer->yy_buf_size;
1906
1907                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1908                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1909                 }
1910
1911         *--yy_cp = (char) c;
1912
1913
1914         yytext_ptr = yy_bp;
1915         yy_hold_char = *yy_cp;
1916         yy_c_buf_p = yy_cp;
1917         }
1918 #endif  /* ifndef YY_NO_UNPUT */
1919
1920
1921 #ifdef __cplusplus
1922 static int yyinput()
1923 #else
1924 static int input()
1925 #endif
1926         {
1927         int c;
1928
1929         *yy_c_buf_p = yy_hold_char;
1930
1931         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1932                 {
1933                 /* yy_c_buf_p now points to the character we want to return.
1934                  * If this occurs *before* the EOB characters, then it's a
1935                  * valid NUL; if not, then we've hit the end of the buffer.
1936                  */
1937                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1938                         /* This was really a NUL. */
1939                         *yy_c_buf_p = '\0';
1940
1941                 else
1942                         { /* need more input */
1943                         int offset = yy_c_buf_p - yytext_ptr;
1944                         ++yy_c_buf_p;
1945
1946                         switch ( yy_get_next_buffer() )
1947                                 {
1948                                 case EOB_ACT_LAST_MATCH:
1949                                         /* This happens because yy_g_n_b()
1950                                          * sees that we've accumulated a
1951                                          * token and flags that we need to
1952                                          * try matching the token before
1953                                          * proceeding.  But for input(),
1954                                          * there's no matching to consider.
1955                                          * So convert the EOB_ACT_LAST_MATCH
1956                                          * to EOB_ACT_END_OF_FILE.
1957                                          */
1958
1959                                         /* Reset buffer status. */
1960                                         yyrestart( yyin );
1961
1962                                         /* fall through */
1963
1964                                 case EOB_ACT_END_OF_FILE:
1965                                         {
1966                                         if ( yywrap() )
1967                                                 return EOF;
1968
1969                                         if ( ! yy_did_buffer_switch_on_eof )
1970                                                 YY_NEW_FILE;
1971 #ifdef __cplusplus
1972                                         return yyinput();
1973 #else
1974                                         return input();
1975 #endif
1976                                         }
1977
1978                                 case EOB_ACT_CONTINUE_SCAN:
1979                                         yy_c_buf_p = yytext_ptr + offset;
1980                                         break;
1981                                 }
1982                         }
1983                 }
1984
1985         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1986         *yy_c_buf_p = '\0';     /* preserve yytext */
1987         yy_hold_char = *++yy_c_buf_p;
1988
1989
1990         return c;
1991         }
1992
1993
1994 #ifdef YY_USE_PROTOS
1995 void yyrestart( FILE *input_file )
1996 #else
1997 void yyrestart( input_file )
1998 FILE *input_file;
1999 #endif
2000         {
2001         if ( ! yy_current_buffer )
2002                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
2003
2004         yy_init_buffer( yy_current_buffer, input_file );
2005         yy_load_buffer_state();
2006         }
2007
2008
2009 #ifdef YY_USE_PROTOS
2010 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2011 #else
2012 void yy_switch_to_buffer( new_buffer )
2013 YY_BUFFER_STATE new_buffer;
2014 #endif
2015         {
2016         if ( yy_current_buffer == new_buffer )
2017                 return;
2018
2019         if ( yy_current_buffer )
2020                 {
2021                 /* Flush out information for old buffer. */
2022                 *yy_c_buf_p = yy_hold_char;
2023                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2024                 yy_current_buffer->yy_n_chars = yy_n_chars;
2025                 }
2026
2027         yy_current_buffer = new_buffer;
2028         yy_load_buffer_state();
2029
2030         /* We don't actually know whether we did this switch during
2031          * EOF (yywrap()) processing, but the only time this flag
2032          * is looked at is after yywrap() is called, so it's safe
2033          * to go ahead and always set it.
2034          */
2035         yy_did_buffer_switch_on_eof = 1;
2036         }
2037
2038
2039 #ifdef YY_USE_PROTOS
2040 void yy_load_buffer_state( void )
2041 #else
2042 void yy_load_buffer_state()
2043 #endif
2044         {
2045         yy_n_chars = yy_current_buffer->yy_n_chars;
2046         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2047         yyin = yy_current_buffer->yy_input_file;
2048         yy_hold_char = *yy_c_buf_p;
2049         }
2050
2051
2052 #ifdef YY_USE_PROTOS
2053 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2054 #else
2055 YY_BUFFER_STATE yy_create_buffer( file, size )
2056 FILE *file;
2057 int size;
2058 #endif
2059         {
2060         YY_BUFFER_STATE b;
2061
2062         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2063         if ( ! b )
2064                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2065
2066         b->yy_buf_size = size;
2067
2068         /* yy_ch_buf has to be 2 characters longer than the size given because
2069          * we need to put in 2 end-of-buffer characters.
2070          */
2071         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2072         if ( ! b->yy_ch_buf )
2073                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2074
2075         b->yy_is_our_buffer = 1;
2076
2077         yy_init_buffer( b, file );
2078
2079         return b;
2080         }
2081
2082
2083 #ifdef YY_USE_PROTOS
2084 void yy_delete_buffer( YY_BUFFER_STATE b )
2085 #else
2086 void yy_delete_buffer( b )
2087 YY_BUFFER_STATE b;
2088 #endif
2089         {
2090         if ( ! b )
2091                 return;
2092
2093         if ( b == yy_current_buffer )
2094                 yy_current_buffer = (YY_BUFFER_STATE) 0;
2095
2096         if ( b->yy_is_our_buffer )
2097                 yy_flex_free( (void *) b->yy_ch_buf );
2098
2099         yy_flex_free( (void *) b );
2100         }
2101
2102
2103 #ifndef YY_ALWAYS_INTERACTIVE
2104 #ifndef YY_NEVER_INTERACTIVE
2105 extern int isatty YY_PROTO(( int ));
2106 #endif
2107 #endif
2108
2109 #ifdef YY_USE_PROTOS
2110 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
2111 #else
2112 void yy_init_buffer( b, file )
2113 YY_BUFFER_STATE b;
2114 FILE *file;
2115 #endif
2116
2117
2118         {
2119         yy_flush_buffer( b );
2120
2121         b->yy_input_file = file;
2122         b->yy_fill_buffer = 1;
2123
2124 #if YY_ALWAYS_INTERACTIVE
2125         b->yy_is_interactive = 1;
2126 #else
2127 #if YY_NEVER_INTERACTIVE
2128         b->yy_is_interactive = 0;
2129 #else
2130         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2131 #endif
2132 #endif
2133         }
2134
2135
2136 #ifdef YY_USE_PROTOS
2137 void yy_flush_buffer( YY_BUFFER_STATE b )
2138 #else
2139 void yy_flush_buffer( b )
2140 YY_BUFFER_STATE b;
2141 #endif
2142
2143         {
2144         if ( ! b )
2145                 return;
2146
2147         b->yy_n_chars = 0;
2148
2149         /* We always need two end-of-buffer characters.  The first causes
2150          * a transition to the end-of-buffer state.  The second causes
2151          * a jam in that state.
2152          */
2153         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2154         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2155
2156         b->yy_buf_pos = &b->yy_ch_buf[0];
2157
2158         b->yy_at_bol = 1;
2159         b->yy_buffer_status = YY_BUFFER_NEW;
2160
2161         if ( b == yy_current_buffer )
2162                 yy_load_buffer_state();
2163         }
2164
2165
2166 #ifndef YY_NO_SCAN_BUFFER
2167 #ifdef YY_USE_PROTOS
2168 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
2169 #else
2170 YY_BUFFER_STATE yy_scan_buffer( base, size )
2171 char *base;
2172 yy_size_t size;
2173 #endif
2174         {
2175         YY_BUFFER_STATE b;
2176
2177         if ( size < 2 ||
2178              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2179              base[size-1] != YY_END_OF_BUFFER_CHAR )
2180                 /* They forgot to leave room for the EOB's. */
2181                 return 0;
2182
2183         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2184         if ( ! b )
2185                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2186
2187         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2188         b->yy_buf_pos = b->yy_ch_buf = base;
2189         b->yy_is_our_buffer = 0;
2190         b->yy_input_file = 0;
2191         b->yy_n_chars = b->yy_buf_size;
2192         b->yy_is_interactive = 0;
2193         b->yy_at_bol = 1;
2194         b->yy_fill_buffer = 0;
2195         b->yy_buffer_status = YY_BUFFER_NEW;
2196
2197         yy_switch_to_buffer( b );
2198
2199         return b;
2200         }
2201 #endif
2202
2203
2204 #ifndef YY_NO_SCAN_STRING
2205 #ifdef YY_USE_PROTOS
2206 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
2207 #else
2208 YY_BUFFER_STATE yy_scan_string( yy_str )
2209 yyconst char *yy_str;
2210 #endif
2211         {
2212         int len;
2213         for ( len = 0; yy_str[len]; ++len )
2214                 ;
2215
2216         return yy_scan_bytes( yy_str, len );
2217         }
2218 #endif
2219
2220
2221 #ifndef YY_NO_SCAN_BYTES
2222 #ifdef YY_USE_PROTOS
2223 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2224 #else
2225 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2226 yyconst char *bytes;
2227 int len;
2228 #endif
2229         {
2230         YY_BUFFER_STATE b;
2231         char *buf;
2232         yy_size_t n;
2233         int i;
2234
2235         /* Get memory for full buffer, including space for trailing EOB's. */
2236         n = len + 2;
2237         buf = (char *) yy_flex_alloc( n );
2238         if ( ! buf )
2239                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2240
2241         for ( i = 0; i < len; ++i )
2242                 buf[i] = bytes[i];
2243
2244         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2245
2246         b = yy_scan_buffer( buf, n );
2247         if ( ! b )
2248                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2249
2250         /* It's okay to grow etc. this buffer, and we should throw it
2251          * away when we're done.
2252          */
2253         b->yy_is_our_buffer = 1;
2254
2255         return b;
2256         }
2257 #endif
2258
2259
2260 #ifndef YY_NO_PUSH_STATE
2261 #ifdef YY_USE_PROTOS
2262 static void yy_push_state( int new_state )
2263 #else
2264 static void yy_push_state( new_state )
2265 int new_state;
2266 #endif
2267         {
2268         if ( yy_start_stack_ptr >= yy_start_stack_depth )
2269                 {
2270                 yy_size_t new_size;
2271
2272                 yy_start_stack_depth += YY_START_STACK_INCR;
2273                 new_size = yy_start_stack_depth * sizeof( int );
2274
2275                 if ( ! yy_start_stack )
2276                         yy_start_stack = (int *) yy_flex_alloc( new_size );
2277
2278                 else
2279                         yy_start_stack = (int *) yy_flex_realloc(
2280                                         (void *) yy_start_stack, new_size );
2281
2282                 if ( ! yy_start_stack )
2283                         YY_FATAL_ERROR(
2284                         "out of memory expanding start-condition stack" );
2285                 }
2286
2287         yy_start_stack[yy_start_stack_ptr++] = YY_START;
2288
2289         BEGIN(new_state);
2290         }
2291 #endif
2292
2293
2294 #ifndef YY_NO_POP_STATE
2295 static void yy_pop_state()
2296         {
2297         if ( --yy_start_stack_ptr < 0 )
2298                 YY_FATAL_ERROR( "start-condition stack underflow" );
2299
2300         BEGIN(yy_start_stack[yy_start_stack_ptr]);
2301         }
2302 #endif
2303
2304
2305 #ifndef YY_NO_TOP_STATE
2306 static int yy_top_state()
2307         {
2308         return yy_start_stack[yy_start_stack_ptr - 1];
2309         }
2310 #endif
2311
2312 #ifndef YY_EXIT_FAILURE
2313 #define YY_EXIT_FAILURE 2
2314 #endif
2315
2316 #ifdef YY_USE_PROTOS
2317 static void yy_fatal_error( yyconst char msg[] )
2318 #else
2319 static void yy_fatal_error( msg )
2320 char msg[];
2321 #endif
2322         {
2323         (void) fprintf( stderr, "%s\n", msg );
2324         exit( YY_EXIT_FAILURE );
2325         }
2326
2327
2328
2329 /* Redefine yyless() so it works in section 3 code. */
2330
2331 #undef yyless
2332 #define yyless(n) \
2333         do \
2334                 { \
2335                 /* Undo effects of setting up yytext. */ \
2336                 yytext[yyleng] = yy_hold_char; \
2337                 yy_c_buf_p = yytext + n; \
2338                 yy_hold_char = *yy_c_buf_p; \
2339                 *yy_c_buf_p = '\0'; \
2340                 yyleng = n; \
2341                 } \
2342         while ( 0 )
2343
2344
2345 /* Internal utility routines. */
2346
2347 #ifndef yytext_ptr
2348 #ifdef YY_USE_PROTOS
2349 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2350 #else
2351 static void yy_flex_strncpy( s1, s2, n )
2352 char *s1;
2353 yyconst char *s2;
2354 int n;
2355 #endif
2356         {
2357         register int i;
2358         for ( i = 0; i < n; ++i )
2359                 s1[i] = s2[i];
2360         }
2361 #endif
2362
2363 #ifdef YY_NEED_STRLEN
2364 #ifdef YY_USE_PROTOS
2365 static int yy_flex_strlen( yyconst char *s )
2366 #else
2367 static int yy_flex_strlen( s )
2368 yyconst char *s;
2369 #endif
2370         {
2371         register int n;
2372         for ( n = 0; s[n]; ++n )
2373                 ;
2374
2375         return n;
2376         }
2377 #endif
2378
2379
2380 #ifdef YY_USE_PROTOS
2381 static void *yy_flex_alloc( yy_size_t size )
2382 #else
2383 static void *yy_flex_alloc( size )
2384 yy_size_t size;
2385 #endif
2386         {
2387         return (void *) malloc( size );
2388         }
2389
2390 #ifdef YY_USE_PROTOS
2391 static void *yy_flex_realloc( void *ptr, yy_size_t size )
2392 #else
2393 static void *yy_flex_realloc( ptr, size )
2394 void *ptr;
2395 yy_size_t size;
2396 #endif
2397         {
2398         /* The cast to (char *) in the following accommodates both
2399          * implementations that use char* generic pointers, and those
2400          * that use void* generic pointers.  It works with the latter
2401          * because both ANSI C and C++ allow castless assignment from
2402          * any pointer type to void*, and deal with argument conversions
2403          * as though doing an assignment.
2404          */
2405         return (void *) realloc( (char *) ptr, size );
2406         }
2407
2408 #ifdef YY_USE_PROTOS
2409 static void yy_flex_free( void *ptr )
2410 #else
2411 static void yy_flex_free( ptr )
2412 void *ptr;
2413 #endif
2414         {
2415         free( ptr );
2416         }
2417
2418 #if YY_MAIN
2419 int main()
2420         {
2421         yylex();
2422         return 0;
2423         }
2424 #endif
2425 #line 403 "dtimep.lex"