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