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