source4/heimdal/lib/asn1/lex.c

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