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 /* The year can either be 2 digits, or 4. However, after
 948 Y2K, we found that some MUA were reporting the year 100, hence
 949 the middle term here. yyterminate() resolves the actual
 950 issues with 2-digit years.
 951 */
 952
 953 /* Macros after this point can all be overridden by user definitions in
 954  * section 1.
 955  */
 956
 957 #ifndef YY_SKIP_YYWRAP
 958 #ifdef __cplusplus
 959 extern "C" int yywrap YY_PROTO(( void ));
 960 #else
 961 extern int yywrap YY_PROTO(( void ));
 962 #endif
 963 #endif
 964
 965 #ifndef YY_NO_UNPUT
 966 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
 967 #endif
 968
 969 #ifndef yytext_ptr
 970 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
 971 #endif
 972
 973 #ifdef YY_NEED_STRLEN
 974 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
 975 #endif
 976
 977 #ifndef YY_NO_INPUT
 978 #ifdef __cplusplus
 979 static int yyinput YY_PROTO(( void ));
 980 #else
 981 static int input YY_PROTO(( void ));
 982 #endif
 983 #endif
 984
 985 #if YY_STACK_USED
 986 static int yy_start_stack_ptr = 0;
 987 static int yy_start_stack_depth = 0;
 988 static int *yy_start_stack = 0;
 989 #ifndef YY_NO_PUSH_STATE
 990 static void yy_push_state YY_PROTO(( int new_state ));
 991 #endif
 992 #ifndef YY_NO_POP_STATE
 993 static void yy_pop_state YY_PROTO(( void ));
 994 #endif
 995 #ifndef YY_NO_TOP_STATE
 996 static int yy_top_state YY_PROTO(( void ));
 997 #endif
 998
 999 #else
1000 #define YY_NO_PUSH_STATE 1
1001 #define YY_NO_POP_STATE 1
1002 #define YY_NO_TOP_STATE 1
1003 #endif
1004
1005 #ifdef YY_MALLOC_DECL
1006 YY_MALLOC_DECL
1007 #else
1008 #if __STDC__
1009 #ifndef __cplusplus
1010 #include <stdlib.h>
1011 #endif
1012 #else
1013 /* Just try to get by without declaring the routines.  This will fail
1014  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
1015  * or sizeof(void*) != sizeof(int).
1016  */
1017 #endif
1018 #endif
1019
1020 /* Amount of stuff to slurp up with each read. */
1021 #ifndef YY_READ_BUF_SIZE
1022 #define YY_READ_BUF_SIZE 8192
1023 #endif
1024
1025 /* Copy whatever the last rule matched to the standard output. */
1026
1027 #ifndef ECHO
1028 /* This used to be an fputs(), but since the string might contain NUL's,
1029  * we now use fwrite().
1030  */
1031 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
1032 #endif
1033
1034 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1035  * is returned in "result".
1036  */
1037 #ifndef YY_INPUT
1038 #define YY_INPUT(buf,result,max_size) \
1039         if ( yy_current_buffer->yy_is_interactive ) \
1040                 { \
1041                 int c = '*', n; \
1042                 for ( n = 0; n < max_size && \
1043                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1044                         buf[n] = (char) c; \
1045                 if ( c == '\n' ) \
1046                         buf[n++] = (char) c; \
1047                 if ( c == EOF && ferror( yyin ) ) \
1048                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1049                 result = n; \
1050                 } \
1051         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
1052                   && ferror( yyin ) ) \
1053                 YY_FATAL_ERROR( "input in flex scanner failed" );
1054 #endif
1055
1056 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1057  * we don't want an extra ';' after the "return" because that will cause
1058  * some compilers to complain about unreachable statements.
1059  */
1060 #ifndef yyterminate
1061 #define yyterminate() return YY_NULL
1062 #endif
1063
1064 /* Number of entries by which start-condition stack grows. */
1065 #ifndef YY_START_STACK_INCR
1066 #define YY_START_STACK_INCR 25
1067 #endif
1068
1069 /* Report a fatal error. */
1070 #ifndef YY_FATAL_ERROR
1071 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1072 #endif
1073
1074 /* Default declaration of generated scanner - a define so the user can
1075  * easily add parameters.
1076  */
1077 #ifndef YY_DECL
1078 #define YY_DECL int yylex YY_PROTO(( void ))
1079 #endif
1080
1081 /* Code executed at the beginning of each rule, after yytext and yyleng
1082  * have been set up.
1083  */
1084 #ifndef YY_USER_ACTION
1085 #define YY_USER_ACTION
1086 #endif
1087
1088 /* Code executed at the end of each rule. */
1089 #ifndef YY_BREAK
1090 #define YY_BREAK break;
1091 #endif
1092
1093 #define YY_RULE_SETUP \
1094         YY_USER_ACTION
1095
1096 YY_DECL
1097         {
1098         register yy_state_type yy_current_state;
1099         register char *yy_cp, *yy_bp;
1100         register int yy_act;
1101
1102 #line 198 "dtimep.lex"
1103
1104
1105   /* This section begins the definition of dparsetime().
1106      Put here any local variable definitions and initializations */
1107
1108   YY_BUFFER_STATE lexhandle;
1109
1110   register char *cp;
1111   static struct tws tw;
1112
1113   memset(&tw,0,sizeof(struct tws));
1114
1115   lexhandle = yy_scan_string(lexstr);
1116
1117
1118
1119         if ( yy_init )
1120                 {
1121                 yy_init = 0;
1122
1123 #ifdef YY_USER_INIT
1124                 YY_USER_INIT;
1125 #endif
1126
1127                 if ( ! yy_start )
1128                         yy_start = 1;   /* first start state */
1129
1130                 if ( ! yyin )
1131                         yyin = stdin;
1132
1133                 if ( ! yyout )
1134                         yyout = stdout;
1135
1136                 if ( ! yy_current_buffer )
1137                         yy_current_buffer =
1138                                 yy_create_buffer( yyin, YY_BUF_SIZE );
1139
1140                 yy_load_buffer_state();
1141                 }
1142
1143         while ( 1 )             /* loops until end-of-file is reached */
1144                 {
1145                 yy_cp = yy_c_buf_p;
1146
1147                 /* Support of yytext. */
1148                 *yy_cp = yy_hold_char;
1149
1150                 /* yy_bp points to the position in yy_ch_buf of the start of
1151                  * the current run.
1152                  */
1153                 yy_bp = yy_cp;
1154
1155                 yy_current_state = yy_start;
1156 yy_match:
1157                 do
1158                         {
1159                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1160                         if ( yy_accept[yy_current_state] )
1161                                 {
1162                                 yy_last_accepting_state = yy_current_state;
1163                                 yy_last_accepting_cpos = yy_cp;
1164                                 }
1165                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1166                                 {
1167                                 yy_current_state = (int) yy_def[yy_current_state];
1168                                 if ( yy_current_state >= 614 )
1169                                         yy_c = yy_meta[(unsigned int) yy_c];
1170                                 }
1171                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1172                         ++yy_cp;
1173                         }
1174                 while ( yy_base[yy_current_state] != 989 );
1175
1176 yy_find_action:
1177                 yy_act = yy_accept[yy_current_state];
1178                 if ( yy_act == 0 )
1179                         { /* have to back up */
1180                         yy_cp = yy_last_accepting_cpos;
1181                         yy_current_state = yy_last_accepting_state;
1182                         yy_act = yy_accept[yy_current_state];
1183                         }
1184
1185                 YY_DO_BEFORE_ACTION;
1186
1187
1188 do_action:      /* This label is used only to access EOF actions. */
1189
1190
1191                 switch ( yy_act )
1192         { /* beginning of action switch */
1193                         case 0: /* must back up */
1194                         /* undo the effects of YY_DO_BEFORE_ACTION */
1195                         *yy_cp = yy_hold_char;
1196                         yy_cp = yy_last_accepting_cpos;
1197                         yy_current_state = yy_last_accepting_state;
1198                         goto yy_find_action;
1199
1200 case 1:
1201 YY_RULE_SETUP
1202 #line 213 "dtimep.lex"
1203 {
1204                                      INIT();
1205                                      SETWDAY();
1206                                      SKIPTOA();
1207                                      SETMON();
1208                                      SKIPTOD();
1209                                      SETDAY();
1210                                      SKIPTOD();
1211                                      SETTIME();
1212                                      SKIPTOD();
1213                                      SETYEAR();
1214                                      }
1215         YY_BREAK
1216 case 2:
1217 YY_RULE_SETUP
1218 #line 226 "dtimep.lex"
1219 {
1220                                      INIT();
1221                                      SETWDAY();
1222                                      SKIPTOD();
1223                                      SETDAY();
1224                                      SKIPTOA();
1225                                      SETMON();
1226                                      SKIPTOD();
1227                                      SETYEAR();
1228                                      SKIPTOD();
1229                                      SETTIME();
1230                                      }
1231         YY_BREAK
1232 case 3:
1233 YY_RULE_SETUP
1234 #line 238 "dtimep.lex"
1235 {
1236                                      INIT();
1237                                      SETDAY();
1238                                      SKIPTOA();
1239                                      SETMON();
1240                                      SKIPTOD();
1241                                      SETYEAR();
1242                                      SKIPTOD();
1243                                      SETTIME();
1244                                      }
1245         YY_BREAK
1246 case 4:
1247 YY_RULE_SETUP
1248 #line 248 "dtimep.lex"
1249 {
1250                                      INIT();
1251                                      SETWDAY();
1252                                      SKIPTOA();
1253                                      SETMON();
1254                                      SKIPTOD();
1255                                      SETDAY();
1256                                      SKIPTOD();
1257                                      SETYEAR();
1258                                      SKIPTOD();
1259                                      SETTIME();
1260                                      }
1261         YY_BREAK
1262 case 5:
1263 YY_RULE_SETUP
1264 #line 260 "dtimep.lex"
1265 {
1266                                      INIT();
1267                                      SETWDAY();
1268                                      SKIPTOA();
1269                                      SETMON();
1270                                      SKIPTOD();
1271                                      SETDAY();
1272                                      SKIPTOD();
1273                                      SETYEAR();
1274                                      }
1275         YY_BREAK
1276 case 6:
1277 YY_RULE_SETUP
1278 #line 270 "dtimep.lex"
1279 {
1280                                      INIT();
1281                                      SETMON();
1282                                      SKIPTOD();
1283                                      SETDAY();
1284                                      SKIPTOD();
1285                                      SETYEAR();
1286                                      SKIPTOA();
1287                                      SETWDAY();
1288                                      }
1289         YY_BREAK
1290 case 7:
1291 YY_RULE_SETUP
1292 #line 280 "dtimep.lex"
1293 {
1294                                      INIT();
1295                                      SETMON();
1296                                      SKIPTOD();
1297                                      SETDAY();
1298                                      SKIPTOD();
1299                                      SETYEAR();
1300                                      }
1301         YY_BREAK
1302 case 8:
1303 YY_RULE_SETUP
1304 #line 288 "dtimep.lex"
1305 {
1306                                      INIT();
1307                                      if(europeandate) {
1308                                        /* DD/MM/YY */
1309                                      SETDAY();
1310                                      SKIPTOD();
1311                                      SETMON_NUM();
1312                                      } else {
1313                                        /* MM/DD/YY */
1314                                      SETMON_NUM();
1315                                      SKIPTOD();
1316                                      SETDAY();
1317                                      }
1318                                      SKIPTOD();
1319                                      SETYEAR();
1320                                      SKIPTOD();
1321                                      SETTIME();
1322                                      }
1323         YY_BREAK
1324 case 9:
1325 YY_RULE_SETUP
1326 #line 306 "dtimep.lex"
1327 {
1328                                      INIT();
1329                                      if(europeandate) {
1330                                        /* DD/MM/YY */
1331                                      SETDAY();
1332                                      SKIPTOD();
1333                                      SETMON_NUM();
1334                                      } else {
1335                                        /* MM/DD/YY */
1336                                      SETMON_NUM();
1337                                      SKIPTOD();
1338                                      SETDAY();
1339                                      }
1340                                      SKIPTOD();
1341                                      SETYEAR();
1342                                      }
1343         YY_BREAK
1344 case 10:
1345 YY_RULE_SETUP
1346 #line 323 "dtimep.lex"
1347
1348         YY_BREAK
1349 case 11:
1350 YY_RULE_SETUP
1351 #line 324 "dtimep.lex"
1352 tw.tw_hour += 12;
1353         YY_BREAK
1354 case 12:
1355 YY_RULE_SETUP
1356 #line 326 "dtimep.lex"
1357 {
1358                                     INIT();
1359                                     SKIPTOD();
1360                                     SETZONE(atoi(cp));
1361                                     }
1362         YY_BREAK
1363 case 13:
1364 YY_RULE_SETUP
1365 #line 331 "dtimep.lex"
1366 {
1367                                     INIT();
1368                                     SKIPTOD();
1369                                     SETZONE(-atoi(cp));
1370                                     }
1371         YY_BREAK
1372 case 14:
1373 YY_RULE_SETUP
1374 #line 336 "dtimep.lex"
1375 INIT(); SETZONE(0);
1376         YY_BREAK
1377 case 15:
1378 YY_RULE_SETUP
1379 #line 337 "dtimep.lex"
1380 INIT(); SETZONE(0);
1381         YY_BREAK
1382 case 16:
1383 YY_RULE_SETUP
1384 #line 338 "dtimep.lex"
1385 INIT(); SETZONE(200);
1386         YY_BREAK
1387 case 17:
1388 YY_RULE_SETUP
1389 #line 339 "dtimep.lex"
1390 INIT(); SETDST(); SETZONE(2);
1391         YY_BREAK
1392 case 18:
1393 YY_RULE_SETUP
1394 #line 340 "dtimep.lex"
1395 INIT(); SETZONE(-500);
1396         YY_BREAK
1397 case 19:
1398 YY_RULE_SETUP
1399 #line 341 "dtimep.lex"
1400 INIT(); SETDST(); SETZONE(-500);
1401         YY_BREAK
1402 case 20:
1403 YY_RULE_SETUP
1404 #line 342 "dtimep.lex"
1405 INIT(); SETZONE(-600);
1406         YY_BREAK
1407 case 21:
1408 YY_RULE_SETUP
1409 #line 343 "dtimep.lex"
1410 INIT(); SETDST(); SETZONE(-600);
1411         YY_BREAK
1412 case 22:
1413 YY_RULE_SETUP
1414 #line 344 "dtimep.lex"
1415 INIT(); SETZONE(-700);
1416         YY_BREAK
1417 case 23:
1418 YY_RULE_SETUP
1419 #line 345 "dtimep.lex"
1420 INIT(); SETDST(); SETZONE(-700);
1421         YY_BREAK
1422 case 24:
1423 YY_RULE_SETUP
1424 #line 346 "dtimep.lex"
1425 INIT(); SETZONE(-800);
1426         YY_BREAK
1427 case 25:
1428 YY_RULE_SETUP
1429 #line 347 "dtimep.lex"
1430 INIT(); SETDST(); SETZONE(-800);
1431         YY_BREAK
1432 case 26:
1433 YY_RULE_SETUP
1434 #line 348 "dtimep.lex"
1435 INIT(); SETZONE(-330);
1436         YY_BREAK
1437 case 27:
1438 YY_RULE_SETUP
1439 #line 349 "dtimep.lex"
1440 INIT(); SETZONE(-400);
1441         YY_BREAK
1442 case 28:
1443 YY_RULE_SETUP
1444 #line 350 "dtimep.lex"
1445 INIT(); SETDST(); SETZONE(-400);
1446         YY_BREAK
1447 case 29:
1448 YY_RULE_SETUP
1449 #line 351 "dtimep.lex"
1450 INIT(); SETZONE(-900);
1451         YY_BREAK
1452 case 30:
1453 YY_RULE_SETUP
1454 #line 352 "dtimep.lex"
1455 INIT(); SETDST(); SETZONE(-900);
1456         YY_BREAK
1457 case 31:
1458 YY_RULE_SETUP
1459 #line 353 "dtimep.lex"
1460 INIT(); SETZONE(-1000);
1461         YY_BREAK
1462 case 32:
1463 YY_RULE_SETUP
1464 #line 354 "dtimep.lex"
1465 INIT(); SETDST(); SETZONE(-1000);
1466         YY_BREAK
1467 case 33:
1468 YY_RULE_SETUP
1469 #line 355 "dtimep.lex"
1470 INIT(); SETDST(); SETZONE(-100);
1471         YY_BREAK
1472 case 34:
1473 YY_RULE_SETUP
1474 #line 356 "dtimep.lex"
1475 {
1476                                        INIT();
1477                                        SETZONE(100*(('a'-1) - tolower(*cp)));
1478                                     }
1479         YY_BREAK
1480 case 35:
1481 YY_RULE_SETUP
1482 #line 360 "dtimep.lex"
1483 {
1484                                        INIT();
1485                                        SETZONE(100*('a' - tolower(*cp)));
1486                                     }
1487         YY_BREAK
1488 case 36:
1489 YY_RULE_SETUP
1490 #line 364 "dtimep.lex"
1491 {
1492                                        INIT();
1493                                        SETZONE(100*(tolower(*cp) - 'm'));
1494                                     }
1495         YY_BREAK
1496 case 37:
1497 YY_RULE_SETUP
1498 #line 368 "dtimep.lex"
1499
1500         YY_BREAK
1501 case 38:
1502 YY_RULE_SETUP
1503 #line 369 "dtimep.lex"
1504 ECHO;
1505         YY_BREAK
1506 case YY_STATE_EOF(INITIAL):
1507         yyterminate();
1508
1509         case YY_END_OF_BUFFER:
1510                 {
1511                 /* Amount of text matched not including the EOB char. */
1512                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1513
1514                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1515                 *yy_cp = yy_hold_char;
1516                 YY_RESTORE_YY_MORE_OFFSET
1517
1518                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1519                         {
1520                         /* We're scanning a new file or input source.  It's
1521                          * possible that this happened because the user
1522                          * just pointed yyin at a new source and called
1523                          * yylex().  If so, then we have to assure
1524                          * consistency between yy_current_buffer and our
1525                          * globals.  Here is the right place to do so, because
1526                          * this is the first action (other than possibly a
1527                          * back-up) that will match for the new input source.
1528                          */
1529                         yy_n_chars = yy_current_buffer->yy_n_chars;
1530                         yy_current_buffer->yy_input_file = yyin;
1531                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1532                         }
1533
1534                 /* Note that here we test for yy_c_buf_p "<=" to the position
1535                  * of the first EOB in the buffer, since yy_c_buf_p will
1536                  * already have been incremented past the NUL character
1537                  * (since all states make transitions on EOB to the
1538                  * end-of-buffer state).  Contrast this with the test
1539                  * in input().
1540                  */
1541                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1542                         { /* This was really a NUL. */
1543                         yy_state_type yy_next_state;
1544
1545                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1546
1547                         yy_current_state = yy_get_previous_state();
1548
1549                         /* Okay, we're now positioned to make the NUL
1550                          * transition.  We couldn't have
1551                          * yy_get_previous_state() go ahead and do it
1552                          * for us because it doesn't know how to deal
1553                          * with the possibility of jamming (and we don't
1554                          * want to build jamming into it because then it
1555                          * will run more slowly).
1556                          */
1557
1558                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1559
1560                         yy_bp = yytext_ptr + YY_MORE_ADJ;
1561
1562                         if ( yy_next_state )
1563                                 {
1564                                 /* Consume the NUL. */
1565                                 yy_cp = ++yy_c_buf_p;
1566                                 yy_current_state = yy_next_state;
1567                                 goto yy_match;
1568                                 }
1569
1570                         else
1571                                 {
1572                                 yy_cp = yy_c_buf_p;
1573                                 goto yy_find_action;
1574                                 }
1575                         }
1576
1577                 else switch ( yy_get_next_buffer() )
1578                         {
1579                         case EOB_ACT_END_OF_FILE:
1580                                 {
1581                                 yy_did_buffer_switch_on_eof = 0;
1582
1583                                 if ( yywrap() )
1584                                         {
1585                                         /* Note: because we've taken care in
1586                                          * yy_get_next_buffer() to have set up
1587                                          * yytext, we can now set up
1588                                          * yy_c_buf_p so that if some total
1589                                          * hoser (like flex itself) wants to
1590                                          * call the scanner after we return the
1591                                          * YY_NULL, it'll still work - another
1592                                          * YY_NULL will get returned.
1593                                          */
1594                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1595
1596                                         yy_act = YY_STATE_EOF(YY_START);
1597                                         goto do_action;
1598                                         }
1599
1600                                 else
1601                                         {
1602                                         if ( ! yy_did_buffer_switch_on_eof )
1603                                                 YY_NEW_FILE;
1604                                         }
1605                                 break;
1606                                 }
1607
1608                         case EOB_ACT_CONTINUE_SCAN:
1609                                 yy_c_buf_p =
1610                                         yytext_ptr + yy_amount_of_matched_text;
1611
1612                                 yy_current_state = yy_get_previous_state();
1613
1614                                 yy_cp = yy_c_buf_p;
1615                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1616                                 goto yy_match;
1617
1618                         case EOB_ACT_LAST_MATCH:
1619                                 yy_c_buf_p =
1620                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1621
1622                                 yy_current_state = yy_get_previous_state();
1623
1624                                 yy_cp = yy_c_buf_p;
1625                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1626                                 goto yy_find_action;
1627                         }
1628                 break;
1629                 }
1630
1631         default:
1632                 YY_FATAL_ERROR(
1633                         "fatal flex scanner internal error--no action found" );
1634         } /* end of action switch */
1635                 } /* end of scanning one token */
1636         } /* end of yylex */
1637
1638
1639 /* yy_get_next_buffer - try to read in a new buffer
1640  *
1641  * Returns a code representing an action:
1642  *      EOB_ACT_LAST_MATCH -
1643  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1644  *      EOB_ACT_END_OF_FILE - end of file
1645  */
1646
1647 static int yy_get_next_buffer()
1648         {
1649         register char *dest = yy_current_buffer->yy_ch_buf;
1650         register char *source = yytext_ptr;
1651         register int number_to_move, i;
1652         int ret_val;
1653
1654         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1655                 YY_FATAL_ERROR(
1656                 "fatal flex scanner internal error--end of buffer missed" );
1657
1658         if ( yy_current_buffer->yy_fill_buffer == 0 )
1659                 { /* Don't try to fill the buffer, so this is an EOF. */
1660                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1661                         {
1662                         /* We matched a single character, the EOB, so
1663                          * treat this as a final EOF.
1664                          */
1665                         return EOB_ACT_END_OF_FILE;
1666                         }
1667
1668                 else
1669                         {
1670                         /* We matched some text prior to the EOB, first
1671                          * process it.
1672                          */
1673                         return EOB_ACT_LAST_MATCH;
1674                         }
1675                 }
1676
1677         /* Try to read more data. */
1678
1679         /* First move last chars to start of buffer. */
1680         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1681
1682         for ( i = 0; i < number_to_move; ++i )
1683                 *(dest++) = *(source++);
1684
1685         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1686                 /* don't do the read, it's not guaranteed to return an EOF,
1687                  * just force an EOF
1688                  */
1689                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1690
1691         else
1692                 {
1693                 int num_to_read =
1694                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1695
1696                 while ( num_to_read <= 0 )
1697                         { /* Not enough room in the buffer - grow it. */
1698 #ifdef YY_USES_REJECT
1699                         YY_FATAL_ERROR(
1700 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1701 #else
1702
1703                         /* just a shorter name for the current buffer */
1704                         YY_BUFFER_STATE b = yy_current_buffer;
1705
1706                         int yy_c_buf_p_offset =
1707                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1708
1709                         if ( b->yy_is_our_buffer )
1710                                 {
1711                                 int new_size = b->yy_buf_size * 2;
1712
1713                                 if ( new_size <= 0 )
1714                                         b->yy_buf_size += b->yy_buf_size / 8;
1715                                 else
1716                                         b->yy_buf_size *= 2;
1717
1718                                 b->yy_ch_buf = (char *)
1719                                         /* Include room in for 2 EOB chars. */
1720                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1721                                                          b->yy_buf_size + 2 );
1722                                 }
1723                         else
1724                                 /* Can't grow it, we don't own it. */
1725                                 b->yy_ch_buf = 0;
1726
1727                         if ( ! b->yy_ch_buf )
1728                                 YY_FATAL_ERROR(
1729                                 "fatal error - scanner input buffer overflow" );
1730
1731                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1732
1733                         num_to_read = yy_current_buffer->yy_buf_size -
1734                                                 number_to_move - 1;
1735 #endif
1736                         }
1737
1738                 if ( num_to_read > YY_READ_BUF_SIZE )
1739                         num_to_read = YY_READ_BUF_SIZE;
1740
1741                 /* Read in more data. */
1742                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1743                         yy_n_chars, num_to_read );
1744
1745                 yy_current_buffer->yy_n_chars = yy_n_chars;
1746                 }
1747
1748         if ( yy_n_chars == 0 )
1749                 {
1750                 if ( number_to_move == YY_MORE_ADJ )
1751                         {
1752                         ret_val = EOB_ACT_END_OF_FILE;
1753                         yyrestart( yyin );
1754                         }
1755
1756                 else
1757                         {
1758                         ret_val = EOB_ACT_LAST_MATCH;
1759                         yy_current_buffer->yy_buffer_status =
1760                                 YY_BUFFER_EOF_PENDING;
1761                         }
1762                 }
1763
1764         else
1765                 ret_val = EOB_ACT_CONTINUE_SCAN;
1766
1767         yy_n_chars += number_to_move;
1768         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1769         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1770
1771         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1772
1773         return ret_val;
1774         }
1775
1776
1777 /* yy_get_previous_state - get the state just before the EOB char was reached */
1778
1779 static yy_state_type yy_get_previous_state()
1780         {
1781         register yy_state_type yy_current_state;
1782         register char *yy_cp;
1783
1784         yy_current_state = yy_start;
1785
1786         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1787                 {
1788                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1789                 if ( yy_accept[yy_current_state] )
1790                         {
1791                         yy_last_accepting_state = yy_current_state;
1792                         yy_last_accepting_cpos = yy_cp;
1793                         }
1794                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1795                         {
1796                         yy_current_state = (int) yy_def[yy_current_state];
1797                         if ( yy_current_state >= 614 )
1798                                 yy_c = yy_meta[(unsigned int) yy_c];
1799                         }
1800                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1801                 }
1802
1803         return yy_current_state;
1804         }
1805
1806
1807 /* yy_try_NUL_trans - try to make a transition on the NUL character
1808  *
1809  * synopsis
1810  *      next_state = yy_try_NUL_trans( current_state );
1811  */
1812
1813 #ifdef YY_USE_PROTOS
1814 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1815 #else
1816 static yy_state_type yy_try_NUL_trans( yy_current_state )
1817 yy_state_type yy_current_state;
1818 #endif
1819         {
1820         register int yy_is_jam;
1821         register char *yy_cp = yy_c_buf_p;
1822
1823         register YY_CHAR yy_c = 1;
1824         if ( yy_accept[yy_current_state] )
1825                 {
1826                 yy_last_accepting_state = yy_current_state;
1827                 yy_last_accepting_cpos = yy_cp;
1828                 }
1829         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1830                 {
1831                 yy_current_state = (int) yy_def[yy_current_state];
1832                 if ( yy_current_state >= 614 )
1833                         yy_c = yy_meta[(unsigned int) yy_c];
1834                 }
1835         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1836         yy_is_jam = (yy_current_state == 613);
1837
1838         return yy_is_jam ? 0 : yy_current_state;
1839         }
1840
1841
1842 #ifndef YY_NO_UNPUT
1843 #ifdef YY_USE_PROTOS
1844 static void yyunput( int c, register char *yy_bp )
1845 #else
1846 static void yyunput( c, yy_bp )
1847 int c;
1848 register char *yy_bp;
1849 #endif
1850         {
1851         register char *yy_cp = yy_c_buf_p;
1852
1853         /* undo effects of setting up yytext */
1854         *yy_cp = yy_hold_char;
1855
1856         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1857                 { /* need to shift things up to make room */
1858                 /* +2 for EOB chars. */
1859                 register int number_to_move = yy_n_chars + 2;
1860                 register char *dest = &yy_current_buffer->yy_ch_buf[
1861                                         yy_current_buffer->yy_buf_size + 2];
1862                 register char *source =
1863                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1864
1865                 while ( source > yy_current_buffer->yy_ch_buf )
1866                         *--dest = *--source;
1867
1868                 yy_cp += (int) (dest - source);
1869                 yy_bp += (int) (dest - source);
1870                 yy_current_buffer->yy_n_chars =
1871                         yy_n_chars = yy_current_buffer->yy_buf_size;
1872
1873                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1874                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1875                 }
1876
1877         *--yy_cp = (char) c;
1878
1879
1880         yytext_ptr = yy_bp;
1881         yy_hold_char = *yy_cp;
1882         yy_c_buf_p = yy_cp;
1883         }
1884 #endif  /* ifndef YY_NO_UNPUT */
1885
1886
1887 #ifdef __cplusplus
1888 static int yyinput()
1889 #else
1890 static int input()
1891 #endif
1892         {
1893         int c;
1894
1895         *yy_c_buf_p = yy_hold_char;
1896
1897         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1898                 {
1899                 /* yy_c_buf_p now points to the character we want to return.
1900                  * If this occurs *before* the EOB characters, then it's a
1901                  * valid NUL; if not, then we've hit the end of the buffer.
1902                  */
1903                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1904                         /* This was really a NUL. */
1905                         *yy_c_buf_p = '\0';
1906
1907                 else
1908                         { /* need more input */
1909                         int offset = yy_c_buf_p - yytext_ptr;
1910                         ++yy_c_buf_p;
1911
1912                         switch ( yy_get_next_buffer() )
1913                                 {
1914                                 case EOB_ACT_LAST_MATCH:
1915                                         /* This happens because yy_g_n_b()
1916                                          * sees that we've accumulated a
1917                                          * token and flags that we need to
1918                                          * try matching the token before
1919                                          * proceeding.  But for input(),
1920                                          * there's no matching to consider.
1921                                          * So convert the EOB_ACT_LAST_MATCH
1922                                          * to EOB_ACT_END_OF_FILE.
1923                                          */
1924
1925                                         /* Reset buffer status. */
1926                                         yyrestart( yyin );
1927
1928                                         /* fall through */
1929
1930                                 case EOB_ACT_END_OF_FILE:
1931                                         {
1932                                         if ( yywrap() )
1933                                                 return EOF;
1934
1935                                         if ( ! yy_did_buffer_switch_on_eof )
1936                                                 YY_NEW_FILE;
1937 #ifdef __cplusplus
1938                                         return yyinput();
1939 #else
1940                                         return input();
1941 #endif
1942                                         }
1943
1944                                 case EOB_ACT_CONTINUE_SCAN:
1945                                         yy_c_buf_p = yytext_ptr + offset;
1946                                         break;
1947                                 }
1948                         }
1949                 }
1950
1951         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1952         *yy_c_buf_p = '\0';     /* preserve yytext */
1953         yy_hold_char = *++yy_c_buf_p;
1954
1955
1956         return c;
1957         }
1958
1959
1960 #ifdef YY_USE_PROTOS
1961 void yyrestart( FILE *input_file )
1962 #else
1963 void yyrestart( input_file )
1964 FILE *input_file;
1965 #endif
1966         {
1967         if ( ! yy_current_buffer )
1968                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1969
1970         yy_init_buffer( yy_current_buffer, input_file );
1971         yy_load_buffer_state();
1972         }
1973
1974
1975 #ifdef YY_USE_PROTOS
1976 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1977 #else
1978 void yy_switch_to_buffer( new_buffer )
1979 YY_BUFFER_STATE new_buffer;
1980 #endif
1981         {
1982         if ( yy_current_buffer == new_buffer )
1983                 return;
1984
1985         if ( yy_current_buffer )
1986                 {
1987                 /* Flush out information for old buffer. */
1988                 *yy_c_buf_p = yy_hold_char;
1989                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1990                 yy_current_buffer->yy_n_chars = yy_n_chars;
1991                 }
1992
1993         yy_current_buffer = new_buffer;
1994         yy_load_buffer_state();
1995
1996         /* We don't actually know whether we did this switch during
1997          * EOF (yywrap()) processing, but the only time this flag
1998          * is looked at is after yywrap() is called, so it's safe
1999          * to go ahead and always set it.
2000          */
2001         yy_did_buffer_switch_on_eof = 1;
2002         }
2003
2004
2005 #ifdef YY_USE_PROTOS
2006 void yy_load_buffer_state( void )
2007 #else
2008 void yy_load_buffer_state()
2009 #endif
2010         {
2011         yy_n_chars = yy_current_buffer->yy_n_chars;
2012         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2013         yyin = yy_current_buffer->yy_input_file;
2014         yy_hold_char = *yy_c_buf_p;
2015         }
2016
2017
2018 #ifdef YY_USE_PROTOS
2019 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2020 #else
2021 YY_BUFFER_STATE yy_create_buffer( file, size )
2022 FILE *file;
2023 int size;
2024 #endif
2025         {
2026         YY_BUFFER_STATE b;
2027
2028         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2029         if ( ! b )
2030                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2031
2032         b->yy_buf_size = size;
2033
2034         /* yy_ch_buf has to be 2 characters longer than the size given because
2035          * we need to put in 2 end-of-buffer characters.
2036          */
2037         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2038         if ( ! b->yy_ch_buf )
2039                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2040
2041         b->yy_is_our_buffer = 1;
2042
2043         yy_init_buffer( b, file );
2044
2045         return b;
2046         }
2047
2048
2049 #ifdef YY_USE_PROTOS
2050 void yy_delete_buffer( YY_BUFFER_STATE b )
2051 #else
2052 void yy_delete_buffer( b )
2053 YY_BUFFER_STATE b;
2054 #endif
2055         {
2056         if ( ! b )
2057                 return;
2058
2059         if ( b == yy_current_buffer )
2060                 yy_current_buffer = (YY_BUFFER_STATE) 0;
2061
2062         if ( b->yy_is_our_buffer )
2063                 yy_flex_free( (void *) b->yy_ch_buf );
2064
2065         yy_flex_free( (void *) b );
2066         }
2067
2068
2069 #ifndef YY_ALWAYS_INTERACTIVE
2070 #ifndef YY_NEVER_INTERACTIVE
2071 extern int isatty YY_PROTO(( int ));
2072 #endif
2073 #endif
2074
2075 #ifdef YY_USE_PROTOS
2076 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
2077 #else
2078 void yy_init_buffer( b, file )
2079 YY_BUFFER_STATE b;
2080 FILE *file;
2081 #endif
2082
2083
2084         {
2085         yy_flush_buffer( b );
2086
2087         b->yy_input_file = file;
2088         b->yy_fill_buffer = 1;
2089
2090 #if YY_ALWAYS_INTERACTIVE
2091         b->yy_is_interactive = 1;
2092 #else
2093 #if YY_NEVER_INTERACTIVE
2094         b->yy_is_interactive = 0;
2095 #else
2096         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2097 #endif
2098 #endif
2099         }
2100
2101
2102 #ifdef YY_USE_PROTOS
2103 void yy_flush_buffer( YY_BUFFER_STATE b )
2104 #else
2105 void yy_flush_buffer( b )
2106 YY_BUFFER_STATE b;
2107 #endif
2108
2109         {
2110         if ( ! b )
2111                 return;
2112
2113         b->yy_n_chars = 0;
2114
2115         /* We always need two end-of-buffer characters.  The first causes
2116          * a transition to the end-of-buffer state.  The second causes
2117          * a jam in that state.
2118          */
2119         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2120         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2121
2122         b->yy_buf_pos = &b->yy_ch_buf[0];
2123
2124         b->yy_at_bol = 1;
2125         b->yy_buffer_status = YY_BUFFER_NEW;
2126
2127         if ( b == yy_current_buffer )
2128                 yy_load_buffer_state();
2129         }
2130
2131
2132 #ifndef YY_NO_SCAN_BUFFER
2133 #ifdef YY_USE_PROTOS
2134 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
2135 #else
2136 YY_BUFFER_STATE yy_scan_buffer( base, size )
2137 char *base;
2138 yy_size_t size;
2139 #endif
2140         {
2141         YY_BUFFER_STATE b;
2142
2143         if ( size < 2 ||
2144              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2145              base[size-1] != YY_END_OF_BUFFER_CHAR )
2146                 /* They forgot to leave room for the EOB's. */
2147                 return 0;
2148
2149         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2150         if ( ! b )
2151                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2152
2153         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2154         b->yy_buf_pos = b->yy_ch_buf = base;
2155         b->yy_is_our_buffer = 0;
2156         b->yy_input_file = 0;
2157         b->yy_n_chars = b->yy_buf_size;
2158         b->yy_is_interactive = 0;
2159         b->yy_at_bol = 1;
2160         b->yy_fill_buffer = 0;
2161         b->yy_buffer_status = YY_BUFFER_NEW;
2162
2163         yy_switch_to_buffer( b );
2164
2165         return b;
2166         }
2167 #endif
2168
2169
2170 #ifndef YY_NO_SCAN_STRING
2171 #ifdef YY_USE_PROTOS
2172 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
2173 #else
2174 YY_BUFFER_STATE yy_scan_string( yy_str )
2175 yyconst char *yy_str;
2176 #endif
2177         {
2178         int len;
2179         for ( len = 0; yy_str[len]; ++len )
2180                 ;
2181
2182         return yy_scan_bytes( yy_str, len );
2183         }
2184 #endif
2185
2186
2187 #ifndef YY_NO_SCAN_BYTES
2188 #ifdef YY_USE_PROTOS
2189 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2190 #else
2191 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2192 yyconst char *bytes;
2193 int len;
2194 #endif
2195         {
2196         YY_BUFFER_STATE b;
2197         char *buf;
2198         yy_size_t n;
2199         int i;
2200
2201         /* Get memory for full buffer, including space for trailing EOB's. */
2202         n = len + 2;
2203         buf = (char *) yy_flex_alloc( n );
2204         if ( ! buf )
2205                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2206
2207         for ( i = 0; i < len; ++i )
2208                 buf[i] = bytes[i];
2209
2210         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2211
2212         b = yy_scan_buffer( buf, n );
2213         if ( ! b )
2214                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2215
2216         /* It's okay to grow etc. this buffer, and we should throw it
2217          * away when we're done.
2218          */
2219         b->yy_is_our_buffer = 1;
2220
2221         return b;
2222         }
2223 #endif
2224
2225
2226 #ifndef YY_NO_PUSH_STATE
2227 #ifdef YY_USE_PROTOS
2228 static void yy_push_state( int new_state )
2229 #else
2230 static void yy_push_state( new_state )
2231 int new_state;
2232 #endif
2233         {
2234         if ( yy_start_stack_ptr >= yy_start_stack_depth )
2235                 {
2236                 yy_size_t new_size;
2237
2238                 yy_start_stack_depth += YY_START_STACK_INCR;
2239                 new_size = yy_start_stack_depth * sizeof( int );
2240
2241                 if ( ! yy_start_stack )
2242                         yy_start_stack = (int *) yy_flex_alloc( new_size );
2243
2244                 else
2245                         yy_start_stack = (int *) yy_flex_realloc(
2246                                         (void *) yy_start_stack, new_size );
2247
2248                 if ( ! yy_start_stack )
2249                         YY_FATAL_ERROR(
2250                         "out of memory expanding start-condition stack" );
2251                 }
2252
2253         yy_start_stack[yy_start_stack_ptr++] = YY_START;
2254
2255         BEGIN(new_state);
2256         }
2257 #endif
2258
2259
2260 #ifndef YY_NO_POP_STATE
2261 static void yy_pop_state()
2262         {
2263         if ( --yy_start_stack_ptr < 0 )
2264                 YY_FATAL_ERROR( "start-condition stack underflow" );
2265
2266         BEGIN(yy_start_stack[yy_start_stack_ptr]);
2267         }
2268 #endif
2269
2270
2271 #ifndef YY_NO_TOP_STATE
2272 static int yy_top_state()
2273         {
2274         return yy_start_stack[yy_start_stack_ptr - 1];
2275         }
2276 #endif
2277
2278 #ifndef YY_EXIT_FAILURE
2279 #define YY_EXIT_FAILURE 2
2280 #endif
2281
2282 #ifdef YY_USE_PROTOS
2283 static void yy_fatal_error( yyconst char msg[] )
2284 #else
2285 static void yy_fatal_error( msg )
2286 char msg[];
2287 #endif
2288         {
2289         (void) fprintf( stderr, "%s\n", msg );
2290         exit( YY_EXIT_FAILURE );
2291         }
2292
2293
2294
2295 /* Redefine yyless() so it works in section 3 code. */
2296
2297 #undef yyless
2298 #define yyless(n) \
2299         do \
2300                 { \
2301                 /* Undo effects of setting up yytext. */ \
2302                 yytext[yyleng] = yy_hold_char; \
2303                 yy_c_buf_p = yytext + n; \
2304                 yy_hold_char = *yy_c_buf_p; \
2305                 *yy_c_buf_p = '\0'; \
2306                 yyleng = n; \
2307                 } \
2308         while ( 0 )
2309
2310
2311 /* Internal utility routines. */
2312
2313 #ifndef yytext_ptr
2314 #ifdef YY_USE_PROTOS
2315 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2316 #else
2317 static void yy_flex_strncpy( s1, s2, n )
2318 char *s1;
2319 yyconst char *s2;
2320 int n;
2321 #endif
2322         {
2323         register int i;
2324         for ( i = 0; i < n; ++i )
2325                 s1[i] = s2[i];
2326         }
2327 #endif
2328
2329 #ifdef YY_NEED_STRLEN
2330 #ifdef YY_USE_PROTOS
2331 static int yy_flex_strlen( yyconst char *s )
2332 #else
2333 static int yy_flex_strlen( s )
2334 yyconst char *s;
2335 #endif
2336         {
2337         register int n;
2338         for ( n = 0; s[n]; ++n )
2339                 ;
2340
2341         return n;
2342         }
2343 #endif
2344
2345
2346 #ifdef YY_USE_PROTOS
2347 static void *yy_flex_alloc( yy_size_t size )
2348 #else
2349 static void *yy_flex_alloc( size )
2350 yy_size_t size;
2351 #endif
2352         {
2353         return (void *) malloc( size );
2354         }
2355
2356 #ifdef YY_USE_PROTOS
2357 static void *yy_flex_realloc( void *ptr, yy_size_t size )
2358 #else
2359 static void *yy_flex_realloc( ptr, size )
2360 void *ptr;
2361 yy_size_t size;
2362 #endif
2363         {
2364         /* The cast to (char *) in the following accommodates both
2365          * implementations that use char* generic pointers, and those
2366          * that use void* generic pointers.  It works with the latter
2367          * because both ANSI C and C++ allow castless assignment from
2368          * any pointer type to void*, and deal with argument conversions
2369          * as though doing an assignment.
2370          */
2371         return (void *) realloc( (char *) ptr, size );
2372         }
2373
2374 #ifdef YY_USE_PROTOS
2375 static void yy_flex_free( void *ptr )
2376 #else
2377 static void yy_flex_free( ptr )
2378 void *ptr;
2379 #endif
2380         {
2381         free( ptr );
2382         }
2383
2384 #if YY_MAIN
2385 int main()
2386         {
2387         yylex();
2388         return 0;
2389         }
2390 #endif
2391 #line 369 "dtimep.lex"