git.gag.com Git - fw/sdcc/blob - src/SDCClex.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 123
 286 #define YY_END_OF_BUFFER 124
 287 static yyconst short int yy_accept[767] =
 288     {   0,
 289         0,    0,    0,    0,  124,  122,  121,  120,  122,  103,
 290        69,  109,  102,  122,   97,   98,  107,  106,   94,  105,
 291       101,  108,   64,   64,   95,   91,  110,   96,  111,  114,
 292        61,   99,  100,  112,   61,   61,   61,   61,   61,   61,
 293        61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
 294        61,   61,   61,   92,  113,   93,  104,  122,  121,  120,
 295       122,  103,   69,  122,  109,  102,  122,   98,  107,  106,
 296        94,  105,  101,  108,   64,   64,   95,   91,  110,   96,
 297       111,  114,   61,   99,  100,  112,   61,   61,   61,   61,
 298        61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
 299
 300        61,   61,   61,   61,   61,   92,  113,   93,  104,    3,
 301         4,    3,  119,   90,   76,   85,   77,    0,    0,   74,
 302        82,   72,   83,   73,   84,    0,   67,    5,   75,   68,
 303        63,    0,   64,    0,   64,   81,   87,   89,   88,   80,
 304        61,   78,   61,   61,   61,   61,   61,   61,   61,   61,
 305         6,   61,   61,   61,   61,   61,   61,   61,   61,   61,
 306        18,   61,   61,   61,   61,   61,   61,   61,   61,   28,
 307        61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
 308        61,   61,   61,   61,   61,   61,   61,   79,   86,    0,
 309         0,  119,   90,    0,    0,   76,   85,   77,    0,    0,
 310
 311         0,   74,   82,   72,   83,   73,   84,    0,   67,    5,
 312        75,   68,   63,    0,   64,    0,   64,   81,   87,   89,
 313        88,   80,   61,   78,   61,   61,   61,   61,   61,   61,
 314        61,   61,    6,   61,   61,   61,   61,   61,   61,   61,
 315        61,   61,   18,   61,   61,   61,   61,   61,   61,   61,
 316        61,   28,   61,   61,   61,   61,   61,   61,   61,   61,
 317        61,   61,   61,   61,   61,   61,   61,   61,   61,   79,
 318        86,    0,   65,   60,    0,   67,   67,    0,   68,   63,
 319         0,   66,   62,   71,   70,   61,   61,   61,   61,   61,
 320        61,   61,   61,   61,    8,   61,   61,   61,   61,   61,
 321
 322        61,   61,   61,   61,   61,   61,   61,   23,   61,   25,
 323        61,   61,   29,   61,   61,   61,   61,   61,   61,   61,
 324        37,   61,   61,   61,   61,   61,   61,   61,   61,   61,
 325        61,   61,   61,   61,   61,    0,    0,    0,   65,    0,
 326        60,    0,   67,   67,    0,   68,   63,    0,   66,   62,
 327        71,   70,   61,   61,   61,   61,   61,   61,   61,   61,
 328        61,    8,   61,   61,   61,   61,   61,   61,   61,   61,
 329        61,   61,   61,   61,   23,   61,   25,   61,   61,   29,
 330        61,   61,   61,   61,   61,   61,   61,   37,   61,   61,
 331        61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
 332
 333        61,   61,    0,    0,   67,    0,   67,    0,   68,   66,
 334        62,    1,   61,   61,   61,   61,   61,   61,   61,    7,
 335        61,   10,   11,   12,   61,   61,   61,   16,   61,   61,
 336        20,   21,   61,   61,   26,   61,   61,   31,   32,   61,
 337        61,   61,   61,   38,   61,   61,   61,   61,   61,   61,
 338        61,   61,   61,   61,   48,   61,   61,   61,    0,    0,
 339         0,    0,    0,   67,    0,   67,    0,   68,   66,   62,
 340         1,   61,   61,   61,   61,   61,   61,   61,    7,   61,
 341        10,   11,   12,   61,   61,   61,   16,   61,   61,   20,
 342        21,   61,   61,   26,   61,   61,   31,   32,   61,   61,
 343
 344        61,   61,   38,   61,   61,   61,   61,   61,   61,   61,
 345        61,   61,   61,   48,   61,   61,   61,    0,    0,   67,
 346        54,   53,   61,   61,   56,   61,   61,    9,   13,   61,
 347        61,   61,   61,   61,   24,   27,   61,   33,   61,   61,
 348        61,   39,   61,   61,   61,   61,   61,   61,   46,   61,
 349        50,   61,   51,   52,    0,    0,    0,    0,    0,   67,
 350        54,   53,   61,   61,   56,   61,   61,    9,   13,   61,
 351        61,   61,   61,   61,   24,   27,   61,   33,   61,   61,
 352        61,   39,   61,   61,   61,   61,   61,   61,   46,   61,
 353        50,   61,   51,   52,    0,   61,   59,   58,   57,   61,
 354
 355        61,   61,   19,   22,   61,   61,   61,   36,   40,   41,
 356        42,   43,   44,   61,   61,   61,    0,    0,  115,    0,
 357         0,    0,   61,   59,   58,   57,   61,   61,   61,   19,
 358        22,   61,   61,   61,   36,   40,   41,   42,   43,   44,
 359        61,   61,   61,    0,   61,   61,   61,   17,   61,   61,
 360        61,   45,   61,   61,    0,    0,  115,    0,    0,    0,
 361        61,   61,   61,   17,   61,   61,   61,   45,   61,   61,
 362         2,   55,   14,   15,   61,   61,   35,   47,   49,    0,
 363         0,    0,    0,  116,    0,    0,    0,   55,   14,   15,
 364        61,   61,   35,   47,   49,   30,   34,    0,    0,    0,
 365
 366         0,  116,    0,    0,    0,   30,   34,    0,    0,    0,
 367         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 368         0,    0,    0,    0,    0,    0,  117,    0,    0,    0,
 369         0,  117,   65,  117,    0,    0,    0,    0,    0,    0,
 370         0,  118,    0,    0,    0,    0,  118,   65,  118,    0,
 371         0,    0,    0,  117,    0,    0,    0,    0,    0,    0,
 372       118,  117,    0,    0,  118,    0
 373     } ;
 374
 375 static yyconst int yy_ec[256] =
 376     {   0,
 377         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 378         2,    2,    4,    1,    1,    1,    1,    1,    1,    1,
 379         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 380         1,    5,    6,    7,    8,    1,    9,   10,   11,   12,
 381        13,   14,   15,   16,   17,   18,   19,   20,   21,   21,
 382        21,   21,   21,   21,   21,   21,   21,   22,   23,   24,
 383        25,   26,   27,    1,   28,   28,   28,   28,   29,   30,
 384        31,   31,   31,   31,   31,   32,   31,   31,   31,   31,
 385        31,   31,   31,   31,   33,   31,   31,   34,   31,   31,
 386        35,   36,   37,   38,   39,    1,   40,   41,   42,   43,
 387
 388        44,   45,   46,   47,   48,   31,   49,   50,   51,   52,
 389        53,   54,   31,   55,   56,   57,   58,   59,   60,   61,
 390        62,   63,   64,   65,   66,   67,    1,    1,    1,    1,
 391         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 392         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 393         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 394         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 395         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 396         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 397         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 398
 399         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 400         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 401         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 402         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 403         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 404         1,    1,    1,    1,    1
 405     } ;
 406
 407 static yyconst int yy_meta[68] =
 408     {   0,
 409         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
 410         3,    1,    1,    1,    1,    1,    1,    1,    1,    4,
 411         4,    1,    1,    1,    1,    1,    1,    4,    4,    4,
 412         5,    5,    5,    5,    1,    1,    1,    1,    5,    4,
 413         4,    4,    4,    4,    4,    5,    5,    5,    5,    5,
 414         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
 415         5,    5,    5,    1,    1,    1,    1
 416     } ;
 417
 418 static yyconst short int yy_base[785] =
 419     {   0,
 420         0,   67,  132,  133, 1347, 1348, 1348, 1348, 1343, 1320,
 421      1348, 1319,  127, 1307, 1348, 1348, 1317,  123, 1348,  124,
 422       122,  130,  155,  133, 1348, 1348,  121, 1316,  131, 1348,
 423         0, 1348, 1348, 1315,  150,  101,  112,  154,  142,  118,
 424       168, 1286,  167, 1285, 1293, 1293, 1291,  179, 1272,  122,
 425      1280, 1285, 1288, 1348,  138, 1348, 1348, 1318, 1317, 1316,
 426       194,  203, 1315,  188,  205,  219,  211, 1314,  220,  225,
 427      1313,  229,  231,  244,  258,  253, 1312, 1311,  236,  241,
 428       255, 1310,  319, 1309, 1308,  247,  253,  123,  209,  347,
 429       260,  338,  351, 1266,  232, 1265, 1273, 1273, 1271,  348,
 430
 431      1252,  242, 1260, 1265, 1268, 1298,  385, 1297, 1296, 1348,
 432      1348, 1263, 1348, 1348, 1348, 1348, 1348,  128,  158, 1348,
 433      1348, 1348, 1348, 1348, 1348, 1288,  386, 1348, 1348,  393,
 434       424,  412,  402,    0,  443, 1280, 1348, 1348, 1348, 1279,
 435         0, 1348, 1247, 1249, 1261, 1256, 1256, 1254, 1254, 1253,
 436         0, 1238, 1237, 1249, 1236, 1251,  182, 1242, 1232, 1243,
 437      1229, 1230, 1227, 1227, 1228, 1229, 1226, 1223, 1239,    0,
 438      1221, 1225, 1236, 1235,  382, 1226, 1218, 1219,  243,  228,
 439      1223, 1216,  261, 1221,  185, 1220, 1227, 1348, 1348, 1254,
 440       242, 1253, 1252,  399,  386, 1251, 1250, 1249,  437,  458,
 441
 442       400, 1248, 1247, 1246, 1245, 1244, 1243,  300,  468, 1242,
 443      1241,  487,  509,  450,  478,  556,  531,  434, 1240, 1239,
 444      1238,  471,    0, 1237, 1192, 1194, 1206, 1201, 1201, 1199,
 445      1199, 1198,    0, 1183, 1182, 1194, 1181, 1196,  434, 1187,
 446      1177, 1188, 1174, 1175, 1172, 1172, 1173, 1174, 1171, 1168,
 447      1184,    0, 1166, 1170, 1181, 1180,  458, 1171, 1163, 1164,
 448       346,  400, 1168, 1161,  410, 1166,  369, 1165, 1172, 1199,
 449      1198, 1157, 1348, 1348,  505, 1348,  558,  541, 1348,  507,
 450       400,  562,  522, 1348, 1348, 1157, 1164, 1149, 1153, 1164,
 451      1163, 1162, 1161, 1147,    0, 1159, 1154, 1142, 1152,  428,
 452
 453      1138, 1154, 1153, 1151, 1147, 1139, 1145,    0, 1148,    0,
 454      1134, 1129, 1141, 1138, 1128, 1125, 1129, 1132, 1121, 1121,
 455         0, 1122, 1124, 1131, 1117, 1115, 1115, 1127, 1117, 1121,
 456      1116, 1124, 1126, 1115, 1107,  553,  439,  469, 1151,  593,
 457      1150,  603, 1149,  605,  621, 1148,  598,  607,  631,  670,
 458      1147, 1146, 1106, 1113, 1098, 1102, 1113, 1112, 1111, 1110,
 459      1096,    0, 1108, 1103, 1091, 1101,  449, 1087, 1103, 1102,
 460      1100, 1096, 1088, 1094,    0, 1097,    0, 1083, 1078, 1090,
 461      1087, 1077, 1074, 1078, 1081, 1070, 1070,    0, 1071, 1073,
 462      1080, 1066, 1064, 1064, 1076, 1066, 1070, 1065, 1073, 1075,
 463
 464      1064, 1056, 1069,  503,  638,  645, 1348,  513,  674, 1348,
 465       589,    0, 1067, 1070, 1065, 1051, 1052, 1049, 1048,    0,
 466      1055,    0,    0,    0, 1046, 1054, 1053,    0, 1042, 1049,
 467         0,    0, 1043, 1040,    0, 1056, 1040,    0,    0, 1054,
 468      1036, 1036, 1036,    0, 1033, 1045, 1035, 1039, 1044, 1043,
 469      1041, 1031, 1036, 1035,    0, 1023, 1035, 1038, 1072,  491,
 470       502,  635,  633,  697,  652, 1064,  665,  711, 1063,  675,
 471         0, 1030, 1033, 1028, 1014, 1015, 1012, 1011,    0, 1018,
 472         0,    0,    0, 1009, 1017, 1016,    0, 1005, 1012,    0,
 473         0, 1006, 1003,    0, 1019, 1003,    0,    0, 1017,  999,
 474
 475       999,  999,    0,  996, 1008,  998, 1002, 1007, 1006, 1004,
 476       994,  999,  998,    0,  986,  998, 1001, 1000,  524,  714,
 477         0,    0,  984,  998,    0,  997,  996,    0,    0,  983,
 478       992,  983,  988,  979,    0,    0,  975,    0,  974,  971,
 479       975,    0,  983,  980,  982,  966,  975,  977,    0,  968,
 480         0,  971,    0,    0,  996,  672,  558,  694,  728,  733,
 481         0,    0,  962,  976,    0,  975,  974,    0,    0,  961,
 482       970,  961,  966,  957,    0,    0,  953,    0,  952,  949,
 483       953,    0,  961,  958,  960,  944,  953,  955,    0,  946,
 484         0,  949,    0,    0,  940,  947,    0,    0,    0,  936,
 485
 486       953,  935,    0,    0,  933,  950,  945,    0,    0,    0,
 487         0,    0,    0,  943,  943,  936,  980,  677,  972,  676,
 488       604,  746,  935,    0,    0,    0,  924,  941,  923,    0,
 489         0,  921,  938,  933,    0,    0,    0,    0,    0,    0,
 490       931,  931,  924,  894,  893,  855,  838,    0,  833,  834,
 491       830,    0,  839,  837,  551,  877, 1348,  747,  689,  726,
 492       837,  833,  826,    0,  819,  820,  816,    0,  827,  825,
 493      1348,    0,    0,    0,  810,  808,    0,    0,    0,  806,
 494       820,  566,  763,  846,  718,  741,  744,    0,    0,    0,
 495       799,  796,    0,    0,    0,    0,    0,  797,  796,  671,
 496
 497       847, 1348,  768,  758,  761,    0,    0,  796,  684,  588,
 498       771,  762,  768,  671,  674,  782,  784,  781,  782,    0,
 499       626,  492,  755,  796,  797,  791,    0,  586,  602,  800,
 500       787,  808,    0,  547,  799,    0,  788,  802,  804,  806,
 501       821,    0,  809,  818,  819,  820,  826,    0,  543,  489,
 502       811,  825,  831,  451,  822,  835,  836,  421,  312,  837,
 503       307,  285,  845,  211,  182, 1348,  891,  896,  898,  903,
 504       908,  143,  913,  918,  923,  928,  933,  938,  943,  948,
 505       953,  958,  963,  968
 506     } ;
 507
 508 static yyconst short int yy_def[785] =
 509     {   0,
 510       766,  766,  767,  767,  766,  766,  766,  766,  766,  766,
 511       766,  766,  766,  768,  766,  766,  766,  766,  766,  766,
 512       766,  766,  766,  766,  766,  766,  766,  766,  766,  766,
 513       769,  766,  766,  766,  769,  769,  769,  769,  769,  769,
 514       769,  769,  769,  769,  769,  769,  769,  769,  769,  769,
 515       769,  769,  769,  766,  766,  766,  766,  770,  770,  770,
 516       770,  770,  770,  770,  770,  770,  771,  770,  770,  770,
 517       770,  770,  770,  770,  770,  770,  770,  770,  770,  770,
 518       770,  770,  766,  770,  770,  770,   83,   83,   83,   83,
 519        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 520
 521        83,   83,   83,   83,   83,  770,  770,  770,  770,  766,
 522       766,  766,  766,  766,  766,  766,  766,  768,  768,  766,
 523       766,  766,  766,  766,  766,  766,  766,  766,  766,  766,
 524       766,  766,  766,  772,  766,  766,  766,  766,  766,  766,
 525       769,  766,  769,  769,  769,  769,  769,  769,  769,  769,
 526       769,  769,  769,  769,  769,  769,  769,  769,  769,  769,
 527       769,  769,  769,  769,  769,  769,  769,  769,  769,  769,
 528       769,  769,  769,  769,  769,  769,  769,  769,  769,  769,
 529       769,  769,  769,  769,  769,  769,  769,  766,  766,  770,
 530       766,  770,  770,  770,  770,  770,  770,  770,  771,  768,
 531
 532       771,  770,  770,  770,  770,  770,  770,  770,  770,  770,
 533       770,  770,  770,  770,  770,  770,  770,  770,  770,  770,
 534       770,  770,   83,  770,   83,   83,   83,   83,   83,   83,
 535        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 536        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 537        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 538        83,   83,   83,   83,   83,   83,   83,   83,   83,  770,
 539       770,  766,  766,  766,  766,  766,  766,  766,  766,  766,
 540       766,  766,  772,  766,  766,  769,  769,  769,  769,  769,
 541       769,  769,  769,  769,  769,  769,  769,  769,  769,  769,
 542
 543       769,  769,  769,  769,  769,  769,  769,  769,  769,  769,
 544       769,  769,  769,  769,  769,  769,  769,  769,  769,  769,
 545       769,  769,  769,  769,  769,  769,  769,  769,  769,  769,
 546       769,  769,  769,  769,  769,  766,  770,  770,  770,  768,
 547       770,  770,  770,  770,  770,  770,  770,  770,  770,  770,
 548       770,  770,   83,   83,   83,   83,   83,   83,   83,   83,
 549        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 550        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 551        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 552        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 553
 554        83,   83,  766,  766,  766,  766,  766,  766,  766,  766,
 555       766,  769,  769,  769,  769,  769,  769,  769,  769,  769,
 556       769,  769,  769,  769,  769,  769,  769,  769,  769,  769,
 557       769,  769,  769,  769,  769,  769,  769,  769,  769,  769,
 558       769,  769,  769,  769,  769,  769,  769,  769,  769,  769,
 559       769,  769,  769,  769,  769,  769,  769,  769,  766,  770,
 560       770,  768,  770,  770,  770,  770,  770,  770,  770,  770,
 561        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 562        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 563        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 564
 565        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 566        83,   83,   83,   83,   83,   83,   83,  766,  766,  766,
 567       769,  769,  769,  769,  769,  769,  769,  769,  769,  769,
 568       769,  769,  769,  769,  769,  769,  769,  769,  769,  769,
 569       769,  769,  769,  769,  769,  769,  769,  769,  769,  769,
 570       769,  769,  769,  769,  766,  773,  770,  768,  770,  770,
 571        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 572        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 573        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 574        83,   83,   83,   83,  766,  769,  769,  769,  769,  769,
 575
 576       769,  769,  769,  769,  769,  769,  769,  769,  769,  769,
 577       769,  769,  769,  769,  769,  769,  766,  773,  770,  774,
 578       770,  768,   83,   83,   83,   83,   83,   83,   83,   83,
 579        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 580        83,   83,   83,  766,  769,  769,  769,  769,  769,  769,
 581       769,  769,  769,  769,  766,  774,  766,  774,  775,  768,
 582        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 583       766,  769,  769,  769,  769,  769,  769,  769,  769,  766,
 584       766,  774,  775,  770,  776,  768,  768,   83,   83,   83,
 585        83,   83,   83,   83,   83,  769,  769,  766,  766,  774,
 586
 587       776,  766,  776,  768,  768,   83,   83,  766,  766,  774,
 588       776,  768,  768,  766,  766,  774,  776,  768,  768,  777,
 589       766,  774,  774,  776,  778,  768,  777,  766,  774,  774,
 590       776,  778,  777,  778,  768,  779,  774,  774,  776,  776,
 591       780,  779,  774,  774,  776,  776,  780,  779,  780,  781,
 592       774,  776,  776,  781,  774,  776,  776,  782,  783,  776,
 593       782,  783,  776,  784,  784,    0,  766,  766,  766,  766,
 594       766,  766,  766,  766,  766,  766,  766,  766,  766,  766,
 595       766,  766,  766,  766
 596     } ;
 597
 598 static yyconst short int yy_nxt[1416] =
 599     {   0,
 600         6,    7,    8,    9,    7,   10,   11,    6,   12,   13,
 601        14,   15,   16,   17,   18,   19,   20,   21,   22,   23,
 602        24,   25,   26,   27,   28,   29,   30,   31,   31,   31,
 603        31,   31,   31,   31,   32,    6,   33,   34,   35,   36,
 604        37,   38,   39,   40,   41,   42,   31,   43,   31,   44,
 605        31,   45,   31,   46,   47,   48,   49,   50,   51,   52,
 606        53,   31,   31,   54,   55,   56,   57,   58,   59,   60,
 607        61,   59,   62,   63,   64,   65,   66,   67,   15,   68,
 608        69,   70,   71,   72,   73,   74,   75,   76,   77,   78,
 609        79,   80,   81,   82,   83,   83,   83,   83,   83,   83,
 610
 611        83,   84,   58,   85,   86,   87,   88,   89,   90,   91,
 612        92,   93,   94,   83,   95,   83,   96,   83,   97,   83,
 613        98,   99,  100,  101,  102,  103,  104,  105,   83,   83,
 614       106,  107,  108,  109,  111,  111,  116,  121,  273,  126,
 615       123,  127,  127,  128,  136,  137,  283,  122,  124,  125,
 616       130,  117,  135,  135,  129,  139,  140,  151,  152,  153,
 617       766,  132,  188,  119,  133,  133,  154,  162,  118,  163,
 618       112,  112,  130,  183,  131,  131,  132,  184,  164,  233,
 619       234,  159,  133,  132,  702,  160,  133,  133,  134,  143,
 620       133,  144,  145,  155,  161,  146,  192,  147,  132,  191,
 621
 622       156,  148,  189,  149,  133,  191,  157,  165,  158,  169,
 623       150,  170,  133,  702,  191,  134,  191,  166,  171,  176,
 624       167,  190,  200,  177,  299,  178,  179,  193,  197,  196,
 625       191,  191,  332,  300,  333,  180,  191,  194,  181,  203,
 626       191,  195,  191,  198,  202,  205,  201,  191,  208,  204,
 627       209,  209,  191,  206,  207,  191,  235,  210,  191,  218,
 628       219,  336,  336,  236,  191,  220,  191,  325,  211,  191,
 629       212,  224,  217,  217,  251,  212,  252,  213,  213,  221,
 630       222,  214,  326,  253,  215,  215,  214,  702,  323,  215,
 631       215,  216,  225,  265,  226,  227,  214,  266,  228,  241,
 632
 633       229,  214,  215,  242,  230,  324,  231,  215,  329,  657,
 634       215,  191,  243,  232,  702,  215,  330,  341,  216,  190,
 635       190,  190,  190,  190,  190,  190,  190,  190,  190,  190,
 636       191,  190,  190,  190,  190,  190,  190,  190,  223,  223,
 637       190,  190,  190,  190,  190,  190,  223,  223,  223,  223,
 638       223,  223,  223,  190,  190,  190,  190,  223,  223,  223,
 639       223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
 640       223,  223,  223,  223,  223,  223,  223,  223,  223,  223,
 641       223,  223,  190,  190,  190,  190,  237,  244,  258,  245,
 642       247,  390,  259,  238,  260,  261,  191,  191,  246,  239,
 643
 644       248,  240,  190,  249,  262,  127,  127,  263,  391,  270,
 645       191,  200,  277,  277,  275,  276,  399,  276,  400,  282,
 646       282,  278,  279,  657,  279,  317,  281,  318,  281,  275,
 647       276,  282,  282,  133,  133,  276,  278,  279,  319,  392,
 648       338,  130,  279,  131,  131,  191,  337,  339,  200,  271,
 649       191,  133,  132,  657,  393,  280,  280,  396,  351,  133,
 650       130,  191,  135,  135,  348,  397,  348,  132,  273,  349,
 651       349,  132,  201,  280,  133,  133,  366,  340,  340,  191,
 652       191,  280,  191,  425,  426,  367,  132,  209,  209,  191,
 653       460,  657,  133,  119,  657,  352,  342,  343,  191,  343,
 654
 655       133,  384,  191,  385,  484,  485,  344,  344,  461,  215,
 656       215,  342,  343,  191,  386,  345,  346,  343,  346,  404,
 657       191,  404,  405,  405,  405,  405,  212,  215,  213,  213,
 658       345,  346,  409,  409,  556,  215,  346,  214,  280,  280,
 659       347,  347,  191,  520,  520,  766,  729,  557,  212,  766,
 660       217,  217,  214,  411,  411,  408,  280,  408,  347,  214,
 661       409,  409,  215,  215,  280,  459,  347,  191,  657,  191,
 662       700,  411,  336,  336,  214,  350,  350,  277,  277,  411,
 663       215,  282,  282,  350,  350,  350,  406,  407,  215,  407,
 664       657,  410,  716,  410,  680,  350,  350,  350,  350,  350,
 665
 666       350,  406,  407,  273,  657,  462,  410,  407,  621,  191,
 667       681,  410,  340,  340,  191,  191,  191,  463,  191,  463,
 668       411,  411,  464,  464,  344,  344,  349,  349,  119,  347,
 669       347,  736,  191,  465,  466,  467,  466,  467,  411,  558,
 670       468,  468,  191,  659,  191,  273,  411,  347,  465,  466,
 671       349,  349,  464,  464,  466,  347,  737,  405,  405,  519,
 672       469,  519,  469,  191,  520,  520,  559,  276,  559,  276,
 673       119,  560,  560,  657,  619,  469,  191,  728,  657,  619,
 674       469,  191,  276,  620,  468,  468,  191,  276,  620,  350,
 675       350,  684,  710,  409,  409,  658,  658,  350,  350,  350,
 676
 677       685,  470,  470,  279,  273,  279,  470,  470,  191,  350,
 678       350,  350,  350,  350,  350,  622,  464,  464,  279,  470,
 679       702,  721,  191,  279,  470,  720,  343,  470,  343,  119,
 680       468,  468,  470,  520,  520,  715,  273,  703,  703,  191,
 681       346,  343,  346,  407,  191,  407,  343,  560,  560,  657,
 682       660,  273,  560,  560,  273,  346,  273,  657,  407,  682,
 683       346,  119,  466,  407,  466,  684,  658,  658,  273,  686,
 684       702,  273,  273,  702,  685,  717,  119,  466,  273,  119,
 685       711,  119,  466,  705,  657,  687,  702,  703,  703,  702,
 686       657,  273,  273,  119,  730,  704,  119,  119,  702,  118,
 687
 688       731,  273,  657,  119,  657,  724,  702,  733,  702,  273,
 689       118,  657,  712,  657,  718,  713,  119,  119,  733,  719,
 690       657,  702,  702,  118,  657,  722,  119,  702,  118,  726,
 691       739,  748,  734,  702,  119,  725,  748,  702,  702,  702,
 692       743,  723,  735,  734,  741,  746,  740,  702,  714,  702,
 693       709,  708,  707,  744,  738,  706,  749,  191,  745,  699,
 694       698,  749,  755,  750,  697,  751,  696,  758,  695,  694,
 695       693,  692,  691,  752,  753,  690,  689,  756,  688,  657,
 696       679,  678,  757,  760,  677,  676,  675,  674,  763,  759,
 697       764,  110,  110,  110,  110,  110,  118,  118,  673,  118,
 698
 699       118,  141,  141,  190,  190,  190,  190,  190,  199,  199,
 700       199,  199,  199,  618,  618,  618,  618,  618,  656,  656,
 701       656,  656,  656,  683,  683,  683,  683,  683,  701,  701,
 702       701,  701,  701,  727,  672,  727,  727,  727,  732,  732,
 703       732,  732,  732,  742,  671,  742,  742,  742,  747,  747,
 704       747,  747,  747,  754,  754,  754,  754,  754,  761,  761,
 705       761,  761,  761,  762,  762,  762,  762,  762,  765,  765,
 706       765,  765,  765,  670,  669,  668,  667,  666,  665,  664,
 707       663,  662,  661,  191,  655,  654,  653,  652,  651,  650,
 708       649,  648,  647,  646,  645,  644,  643,  642,  641,  640,
 709
 710       639,  638,  637,  636,  635,  634,  633,  632,  631,  630,
 711       629,  628,  627,  626,  625,  624,  623,  617,  616,  615,
 712       614,  613,  612,  611,  610,  609,  608,  607,  606,  605,
 713       604,  603,  602,  601,  600,  599,  598,  597,  596,  595,
 714       594,  593,  592,  591,  590,  589,  588,  587,  586,  585,
 715       584,  583,  582,  581,  580,  579,  578,  577,  576,  575,
 716       574,  573,  572,  571,  570,  569,  568,  567,  566,  565,
 717       564,  563,  562,  561,  191,  191,  555,  554,  553,  552,
 718       551,  550,  549,  548,  547,  546,  545,  544,  543,  542,
 719       541,  540,  539,  538,  537,  536,  535,  534,  533,  532,
 720
 721       531,  530,  529,  528,  527,  526,  525,  524,  523,  522,
 722       521,  518,  517,  516,  515,  514,  513,  512,  511,  510,
 723       509,  508,  507,  506,  505,  504,  503,  502,  501,  500,
 724       499,  498,  497,  496,  495,  494,  493,  492,  491,  490,
 725       489,  488,  487,  486,  483,  482,  481,  480,  479,  478,
 726       477,  476,  475,  474,  473,  472,  471,  191,  191,  191,
 727       191,  191,  191,  458,  457,  456,  455,  454,  453,  452,
 728       451,  450,  449,  448,  447,  446,  445,  444,  443,  442,
 729       441,  440,  439,  438,  437,  436,  435,  434,  433,  432,
 730       431,  430,  429,  428,  427,  424,  423,  422,  421,  420,
 731
 732       419,  418,  417,  416,  415,  414,  413,  412,  403,  191,
 733       191,  402,  401,  398,  395,  394,  389,  388,  387,  383,
 734       382,  381,  380,  379,  378,  377,  376,  375,  374,  373,
 735       372,  371,  370,  369,  368,  365,  364,  363,  362,  361,
 736       360,  359,  358,  357,  356,  355,  354,  353,  191,  191,
 737       191,  191,  191,  191,  191,  191,  191,  191,  191,  191,
 738       191,  191,  191,  191,  191,  191,  335,  334,  331,  328,
 739       327,  322,  321,  320,  316,  315,  314,  313,  312,  311,
 740       310,  309,  308,  307,  306,  305,  304,  303,  302,  301,
 741       298,  297,  296,  295,  294,  293,  292,  291,  290,  289,
 742
 743       288,  287,  286,  285,  284,  274,  272,  191,  191,  191,
 744       269,  268,  267,  264,  257,  256,  255,  254,  250,  191,
 745       191,  191,  191,  191,  191,  191,  191,  191,  191,  191,
 746       187,  186,  185,  182,  175,  174,  173,  172,  168,  142,
 747       138,  120,  119,  115,  114,  113,  766,    5,  766,  766,
 748       766,  766,  766,  766,  766,  766,  766,  766,  766,  766,
 749       766,  766,  766,  766,  766,  766,  766,  766,  766,  766,
 750       766,  766,  766,  766,  766,  766,  766,  766,  766,  766,
 751       766,  766,  766,  766,  766,  766,  766,  766,  766,  766,
 752       766,  766,  766,  766,  766,  766,  766,  766,  766,  766,
 753
 754       766,  766,  766,  766,  766,  766,  766,  766,  766,  766,
 755       766,  766,  766,  766,  766
 756     } ;
 757
 758 static yyconst short int yy_chk[1416] =
 759     {   0,
 760         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 761         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 762         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 763         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 764         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 765         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 766         1,    1,    1,    1,    1,    1,    1,    2,    2,    2,
 767         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
 768         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
 769         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
 770
 771         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
 772         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
 773         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
 774         2,    2,    2,    2,    3,    4,   13,   18,  118,   21,
 775        20,   21,   21,   22,   27,   27,  772,   18,   20,   20,
 776        24,   13,   24,   24,   22,   29,   29,   36,   36,   37,
 777       119,   24,   55,  118,   24,   24,   37,   40,  119,   40,
 778         3,    4,   23,   50,   23,   23,   24,   50,   40,   88,
 779        88,   39,   24,   23,  765,   39,   23,   23,   23,   35,
 780        24,   35,   35,   38,   39,   35,   61,   35,   23,   64,
 781
 782        38,   35,   55,   35,   23,   61,   38,   41,   38,   43,
 783        35,   43,   23,  764,   62,   23,   65,   41,   43,   48,
 784        41,   67,   67,   48,  157,   48,   48,   62,   66,   65,
 785        66,   69,  185,  157,  185,   48,   70,   64,   48,   70,
 786        72,   64,   73,   66,   69,   72,   67,   79,   73,   70,
 787        73,   73,   80,   72,   72,   74,   89,   74,   86,   79,
 788        79,  191,  191,   89,   76,   80,   81,  180,   74,   75,
 789        76,   86,   76,   76,   95,   75,   95,   75,   75,   81,
 790        81,   76,  180,   95,   76,   76,   75,  762,  179,   75,
 791        75,   75,   87,  102,   87,   87,   76,  102,   87,   91,
 792
 793        87,   75,   76,   91,   87,  179,   87,   75,  183,  761,
 794        76,  208,   91,   87,  759,   75,  183,  208,   75,   83,
 795        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 796        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 797        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 798        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 799        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 800        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 801        83,   83,   83,   83,   83,   83,   90,   92,  100,   92,
 802        93,  261,  100,   90,  100,  100,  107,  195,   92,   90,
 803
 804        93,   90,  201,   93,  100,  127,  127,  100,  261,  107,
 805       194,  201,  130,  130,  127,  127,  267,  127,  267,  281,
 806       281,  130,  130,  758,  130,  175,  132,  175,  132,  127,
 807       127,  132,  132,  133,  133,  127,  130,  130,  175,  262,
 808       195,  131,  130,  131,  131,  218,  194,  199,  199,  107,
 809       337,  133,  131,  754,  262,  131,  131,  265,  218,  133,
 810       135,  214,  135,  135,  214,  265,  214,  131,  200,  214,
 811       214,  135,  199,  131,  135,  135,  239,  200,  200,  209,
 812       338,  131,  222,  300,  300,  239,  135,  209,  209,  215,
 813       337,  750,  135,  200,  722,  222,  209,  209,  212,  209,
 814
 815       135,  257,  460,  257,  367,  367,  212,  212,  338,  215,
 816       215,  209,  209,  461,  257,  212,  212,  209,  212,  275,
 817       213,  275,  404,  404,  275,  275,  213,  215,  213,  213,
 818       212,  212,  408,  408,  460,  215,  212,  213,  280,  280,
 819       213,  213,  217,  519,  519,  749,  722,  461,  217,  734,
 820       217,  217,  213,  283,  283,  278,  280,  278,  213,  217,
 821       278,  278,  217,  217,  280,  336,  213,  216,  682,  557,
 822       682,  283,  336,  336,  217,  216,  216,  277,  277,  283,
 823       217,  282,  282,  216,  216,  216,  277,  277,  217,  277,
 824       710,  282,  710,  282,  655,  216,  216,  216,  216,  216,
 825
 826       216,  277,  277,  340,  729,  340,  282,  277,  557,  347,
 827       655,  282,  340,  340,  342,  621,  344,  342,  348,  342,
 828       411,  411,  342,  342,  344,  344,  348,  348,  340,  347,
 829       347,  728,  345,  344,  344,  345,  344,  345,  411,  462,
 830       345,  345,  349,  621,  463,  462,  411,  347,  344,  344,
 831       349,  349,  463,  463,  344,  347,  729,  405,  405,  406,
 832       349,  406,  349,  465,  406,  406,  465,  405,  465,  405,
 833       462,  465,  465,  700,  556,  349,  467,  721,  620,  618,
 834       349,  350,  405,  556,  467,  467,  470,  405,  618,  350,
 835       350,  659,  700,  409,  409,  620,  620,  350,  350,  350,
 836
 837       659,  350,  350,  409,  558,  409,  470,  470,  464,  350,
 838       350,  350,  350,  350,  350,  558,  464,  464,  409,  350,
 839       685,  715,  468,  409,  470,  714,  464,  350,  464,  558,
 840       468,  468,  470,  520,  520,  709,  660,  685,  685,  559,
 841       468,  464,  468,  520,  560,  520,  464,  559,  559,  658,
 842       622,  686,  560,  560,  687,  468,  622,  723,  520,  658,
 843       468,  660,  560,  520,  560,  683,  658,  658,  704,  660,
 844       703,  705,  712,  711,  683,  711,  686,  560,  713,  687,
 845       703,  622,  560,  687,  716,  660,  717,  703,  703,  731,
 846       737,  718,  719,  704,  723,  686,  705,  712,  724,  725,
 847
 848       724,  726,  730,  713,  738,  717,  739,  725,  740,  735,
 849       732,  743,  704,  751,  712,  705,  718,  719,  732,  713,
 850       744,  745,  746,  741,  755,  716,  726,  752,  747,  719,
 851       731,  741,  725,  753,  735,  718,  747,  756,  757,  760,
 852       737,  716,  726,  732,  735,  740,  731,  763,  708,  701,
 853       699,  698,  692,  738,  730,  691,  741,  684,  739,  681,
 854       680,  747,  751,  743,  676,  744,  675,  755,  670,  669,
 855       667,  666,  665,  745,  746,  663,  662,  752,  661,  656,
 856       654,  653,  753,  757,  651,  650,  649,  647,  760,  756,
 857       763,  767,  767,  767,  767,  767,  768,  768,  646,  768,
 858
 859       768,  769,  769,  770,  770,  770,  770,  770,  771,  771,
 860       771,  771,  771,  773,  773,  773,  773,  773,  774,  774,
 861       774,  774,  774,  775,  775,  775,  775,  775,  776,  776,
 862       776,  776,  776,  777,  645,  777,  777,  777,  778,  778,
 863       778,  778,  778,  779,  644,  779,  779,  779,  780,  780,
 864       780,  780,  780,  781,  781,  781,  781,  781,  782,  782,
 865       782,  782,  782,  783,  783,  783,  783,  783,  784,  784,
 866       784,  784,  784,  643,  642,  641,  634,  633,  632,  629,
 867       628,  627,  623,  619,  617,  616,  615,  614,  607,  606,
 868       605,  602,  601,  600,  596,  595,  592,  590,  588,  587,
 869
 870       586,  585,  584,  583,  581,  580,  579,  577,  574,  573,
 871       572,  571,  570,  567,  566,  564,  563,  555,  552,  550,
 872       548,  547,  546,  545,  544,  543,  541,  540,  539,  537,
 873       534,  533,  532,  531,  530,  527,  526,  524,  523,  518,
 874       517,  516,  515,  513,  512,  511,  510,  509,  508,  507,
 875       506,  505,  504,  502,  501,  500,  499,  496,  495,  493,
 876       492,  489,  488,  486,  485,  484,  480,  478,  477,  476,
 877       475,  474,  473,  472,  469,  466,  459,  458,  457,  456,
 878       454,  453,  452,  451,  450,  449,  448,  447,  446,  445,
 879       443,  442,  441,  440,  437,  436,  434,  433,  430,  429,
 880
 881       427,  426,  425,  421,  419,  418,  417,  416,  415,  414,
 882       413,  403,  402,  401,  400,  399,  398,  397,  396,  395,
 883       394,  393,  392,  391,  390,  389,  387,  386,  385,  384,
 884       383,  382,  381,  380,  379,  378,  376,  374,  373,  372,
 885       371,  370,  369,  368,  366,  365,  364,  363,  361,  360,
 886       359,  358,  357,  356,  355,  354,  353,  352,  351,  346,
 887       343,  341,  339,  335,  334,  333,  332,  331,  330,  329,
 888       328,  327,  326,  325,  324,  323,  322,  320,  319,  318,
 889       317,  316,  315,  314,  313,  312,  311,  309,  307,  306,
 890       305,  304,  303,  302,  301,  299,  298,  297,  296,  294,
 891
 892       293,  292,  291,  290,  289,  288,  287,  286,  272,  271,
 893       270,  269,  268,  266,  264,  263,  260,  259,  258,  256,
 894       255,  254,  253,  251,  250,  249,  248,  247,  246,  245,
 895       244,  243,  242,  241,  240,  238,  237,  236,  235,  234,
 896       232,  231,  230,  229,  228,  227,  226,  225,  224,  221,
 897       220,  219,  211,  210,  207,  206,  205,  204,  203,  202,
 898       198,  197,  196,  193,  192,  190,  187,  186,  184,  182,
 899       181,  178,  177,  176,  174,  173,  172,  171,  169,  168,
 900       167,  166,  165,  164,  163,  162,  161,  160,  159,  158,
 901       156,  155,  154,  153,  152,  150,  149,  148,  147,  146,
 902
 903       145,  144,  143,  140,  136,  126,  112,  109,  108,  106,
 904       105,  104,  103,  101,   99,   98,   97,   96,   94,   85,
 905        84,   82,   78,   77,   71,   68,   63,   60,   59,   58,
 906        53,   52,   51,   49,   47,   46,   45,   44,   42,   34,
 907        28,   17,   14,   12,   10,    9,    5,  766,  766,  766,
 908       766,  766,  766,  766,  766,  766,  766,  766,  766,  766,
 909       766,  766,  766,  766,  766,  766,  766,  766,  766,  766,
 910       766,  766,  766,  766,  766,  766,  766,  766,  766,  766,
 911       766,  766,  766,  766,  766,  766,  766,  766,  766,  766,
 912       766,  766,  766,  766,  766,  766,  766,  766,  766,  766,
 913
 914       766,  766,  766,  766,  766,  766,  766,  766,  766,  766,
 915       766,  766,  766,  766,  766
 916     } ;
 917
 918 static yy_state_type yy_last_accepting_state;
 919 static char *yy_last_accepting_cpos;
 920
 921 /* The intent behind this definition is that it'll catch
 922  * any uses of REJECT which flex missed.
 923  */
 924 #define REJECT reject_used_but_not_detected
 925 #define yymore() yymore_used_but_not_detected
 926 #define YY_MORE_ADJ 0
 927 #define YY_RESTORE_YY_MORE_OFFSET
 928 char *yytext;
 929 #line 1 "SDCC.lex"
 930 #define INITIAL 0
 931 /*-----------------------------------------------------------------------
 932   SDCC.lex - lexical analyser for use with sdcc ( a freeware compiler for
 933   8/16 bit microcontrollers)
 934   Written by : Sandeep Dutta . sandeep.dutta@usa.net (1997)
 935
 936   This program is free software; you can redistribute it and/or modify it
 937   under the terms of the GNU General Public License as published by the
 938    Free Software Foundation; either version 2, or (at your option) any
 939    later version.
 940
 941    This program is distributed in the hope that it will be useful,
 942    but WITHOUT ANY WARRANTY; without even the implied warranty of
 943    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 944    GNU General Public License for more details.
 945
 946    You should have received a copy of the GNU General Public License
 947    along with this program; if not, write to the Free Software
 948    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 949
 950    In other words, you are welcome to use, share and improve this program.
 951    You are forbidden to forbid anyone else to use, share and improve
 952    what you give them.   Help stamp out software-hoarding!
 953 -------------------------------------------------------------------------*/
 954 #line 32 "SDCC.lex"
 955
 956 #include <stdio.h>
 957 #include <string.h>
 958 #include <ctype.h>
 959 #include "SDCCglobl.h"
 960 #include "SDCCsymt.h"
 961 #include "SDCCval.h"
 962 #include "SDCCast.h"
 963 #include "SDCCy.h"
 964 #include "SDCChasht.h"
 965 #include "SDCCmem.h"
 966
 967 char *stringLiteral();
 968 char *currFname;
 969
 970 extern int lineno                       ;
 971 extern char *filename ;
 972 extern char *fullSrcFileName ;
 973 int   yylineno = 1               ;
 974 void count()                     ;
 975 void comment();
 976 int process_pragma(char *);
 977 #undef yywrap
 978
 979 int yywrap YY_PROTO((void))
 980 {
 981    return(1);
 982 }
 983
 984 char asmbuff[MAX_INLINEASM]                     ;
 985 char *asmp ;
 986 extern int check_type           (          );
 987 extern int checkCurrFile        (char *);
 988 extern int processPragma        (char *);
 989 extern int printListing         (int   );
 990 struct optimize save_optimize ;
 991 struct options  save_options  ;
 992
 993  enum {
 994      P_SAVE = 1,
 995      P_RESTORE ,
 996      P_NOINDUCTION,
 997      P_NOINVARIANT,
 998      P_INDUCTION ,
 999      P_STACKAUTO ,
1000      P_NOJTBOUND ,
1001      P_NOOVERLAY ,
1002      P_NOGCSE    ,
1003      P_CALLEE_SAVES,
1004      P_EXCLUDE   ,
1005      P_LOOPREV
1006  };
1007
1008 #define asm 1
1009
1010
1011 /* Macros after this point can all be overridden by user definitions in
1012  * section 1.
1013  */
1014
1015 #ifndef YY_SKIP_YYWRAP
1016 #ifdef __cplusplus
1017 extern "C" int yywrap YY_PROTO(( void ));
1018 #else
1019 extern int yywrap YY_PROTO(( void ));
1020 #endif
1021 #endif
1022
1023 #ifndef YY_NO_UNPUT
1024 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
1025 #endif
1026
1027 #ifndef yytext_ptr
1028 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
1029 #endif
1030
1031 #ifdef YY_NEED_STRLEN
1032 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
1033 #endif
1034
1035 #ifndef YY_NO_INPUT
1036 #ifdef __cplusplus
1037 static int yyinput YY_PROTO(( void ));
1038 #else
1039 static int input YY_PROTO(( void ));
1040 #endif
1041 #endif
1042
1043 #if YY_STACK_USED
1044 static int yy_start_stack_ptr = 0;
1045 static int yy_start_stack_depth = 0;
1046 static int *yy_start_stack = 0;
1047 #ifndef YY_NO_PUSH_STATE
1048 static void yy_push_state YY_PROTO(( int new_state ));
1049 #endif
1050 #ifndef YY_NO_POP_STATE
1051 static void yy_pop_state YY_PROTO(( void ));
1052 #endif
1053 #ifndef YY_NO_TOP_STATE
1054 static int yy_top_state YY_PROTO(( void ));
1055 #endif
1056
1057 #else
1058 #define YY_NO_PUSH_STATE 1
1059 #define YY_NO_POP_STATE 1
1060 #define YY_NO_TOP_STATE 1
1061 #endif
1062
1063 #ifdef YY_MALLOC_DECL
1064 YY_MALLOC_DECL
1065 #else
1066 #if __STDC__
1067 #ifndef __cplusplus
1068 #include <stdlib.h>
1069 #endif
1070 #else
1071 /* Just try to get by without declaring the routines.  This will fail
1072  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
1073  * or sizeof(void*) != sizeof(int).
1074  */
1075 #endif
1076 #endif
1077
1078 /* Amount of stuff to slurp up with each read. */
1079 #ifndef YY_READ_BUF_SIZE
1080 #define YY_READ_BUF_SIZE 8192
1081 #endif
1082
1083 /* Copy whatever the last rule matched to the standard output. */
1084
1085 #ifndef ECHO
1086 /* This used to be an fputs(), but since the string might contain NUL's,
1087  * we now use fwrite().
1088  */
1089 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
1090 #endif
1091
1092 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1093  * is returned in "result".
1094  */
1095 #ifndef YY_INPUT
1096 #define YY_INPUT(buf,result,max_size) \
1097         if ( yy_current_buffer->yy_is_interactive ) \
1098                 { \
1099                 int c = '*', n; \
1100                 for ( n = 0; n < max_size && \
1101                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1102                         buf[n] = (char) c; \
1103                 if ( c == '\n' ) \
1104                         buf[n++] = (char) c; \
1105                 if ( c == EOF && ferror( yyin ) ) \
1106                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1107                 result = n; \
1108                 } \
1109         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
1110                   && ferror( yyin ) ) \
1111                 YY_FATAL_ERROR( "input in flex scanner failed" );
1112 #endif
1113
1114 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1115  * we don't want an extra ';' after the "return" because that will cause
1116  * some compilers to complain about unreachable statements.
1117  */
1118 #ifndef yyterminate
1119 #define yyterminate() return YY_NULL
1120 #endif
1121
1122 /* Number of entries by which start-condition stack grows. */
1123 #ifndef YY_START_STACK_INCR
1124 #define YY_START_STACK_INCR 25
1125 #endif
1126
1127 /* Report a fatal error. */
1128 #ifndef YY_FATAL_ERROR
1129 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1130 #endif
1131
1132 /* Default declaration of generated scanner - a define so the user can
1133  * easily add parameters.
1134  */
1135 #ifndef YY_DECL
1136 #define YY_DECL int yylex YY_PROTO(( void ))
1137 #endif
1138
1139 /* Code executed at the beginning of each rule, after yytext and yyleng
1140  * have been set up.
1141  */
1142 #ifndef YY_USER_ACTION
1143 #define YY_USER_ACTION
1144 #endif
1145
1146 /* Code executed at the end of each rule. */
1147 #ifndef YY_BREAK
1148 #define YY_BREAK break;
1149 #endif
1150
1151 #define YY_RULE_SETUP \
1152         if ( yyleng > 0 ) \
1153                 yy_current_buffer->yy_at_bol = \
1154                                 (yytext[yyleng - 1] == '\n'); \
1155         YY_USER_ACTION
1156
1157 YY_DECL
1158         {
1159         register yy_state_type yy_current_state;
1160         register char *yy_cp, *yy_bp;
1161         register int yy_act;
1162
1163 #line 87 "SDCC.lex"
1164
1165
1166         if ( yy_init )
1167                 {
1168                 yy_init = 0;
1169
1170 #ifdef YY_USER_INIT
1171                 YY_USER_INIT;
1172 #endif
1173
1174                 if ( ! yy_start )
1175                         yy_start = 1;   /* first start state */
1176
1177                 if ( ! yyin )
1178                         yyin = stdin;
1179
1180                 if ( ! yyout )
1181                         yyout = stdout;
1182
1183                 if ( ! yy_current_buffer )
1184                         yy_current_buffer =
1185                                 yy_create_buffer( yyin, YY_BUF_SIZE );
1186
1187                 yy_load_buffer_state();
1188                 }
1189
1190         while ( 1 )             /* loops until end-of-file is reached */
1191                 {
1192                 yy_cp = yy_c_buf_p;
1193
1194                 /* Support of yytext. */
1195                 *yy_cp = yy_hold_char;
1196
1197                 /* yy_bp points to the position in yy_ch_buf of the start of
1198                  * the current run.
1199                  */
1200                 yy_bp = yy_cp;
1201
1202                 yy_current_state = yy_start;
1203                 yy_current_state += YY_AT_BOL();
1204 yy_match:
1205                 do
1206                         {
1207                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1208                         if ( yy_accept[yy_current_state] )
1209                                 {
1210                                 yy_last_accepting_state = yy_current_state;
1211                                 yy_last_accepting_cpos = yy_cp;
1212                                 }
1213                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1214                                 {
1215                                 yy_current_state = (int) yy_def[yy_current_state];
1216                                 if ( yy_current_state >= 767 )
1217                                         yy_c = yy_meta[(unsigned int) yy_c];
1218                                 }
1219                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1220                         ++yy_cp;
1221                         }
1222                 while ( yy_base[yy_current_state] != 1348 );
1223
1224 yy_find_action:
1225                 yy_act = yy_accept[yy_current_state];
1226                 if ( yy_act == 0 )
1227                         { /* have to back up */
1228                         yy_cp = yy_last_accepting_cpos;
1229                         yy_current_state = yy_last_accepting_state;
1230                         yy_act = yy_accept[yy_current_state];
1231                         }
1232
1233                 YY_DO_BEFORE_ACTION;
1234
1235
1236 do_action:      /* This label is used only to access EOF actions. */
1237
1238
1239                 switch ( yy_act )
1240         { /* beginning of action switch */
1241                         case 0: /* must back up */
1242                         /* undo the effects of YY_DO_BEFORE_ACTION */
1243                         *yy_cp = yy_hold_char;
1244                         yy_cp = yy_last_accepting_cpos;
1245                         yy_current_state = yy_last_accepting_state;
1246                         goto yy_find_action;
1247
1248 case 1:
1249 YY_RULE_SETUP
1250 #line 88 "SDCC.lex"
1251 {  count(); asmp = asmbuff ;BEGIN(asm) ;}
1252         YY_BREAK
1253 case 2:
1254 YY_RULE_SETUP
1255 #line 89 "SDCC.lex"
1256 { count()               ;
1257                   *asmp = '\0'                          ;
1258                   strcpy(yylval.yyinline,asmbuff)               ;
1259                   BEGIN(INITIAL)        ;
1260                   return (INLINEASM)                    ; }
1261         YY_BREAK
1262 case 3:
1263 YY_RULE_SETUP
1264 #line 94 "SDCC.lex"
1265 { *asmp++ = yytext[0]   ; }
1266         YY_BREAK
1267 case 4:
1268 YY_RULE_SETUP
1269 #line 95 "SDCC.lex"
1270 { count(); *asmp++ = '\n' ;}
1271         YY_BREAK
1272 case 5:
1273 YY_RULE_SETUP
1274 #line 96 "SDCC.lex"
1275 { comment(); }
1276         YY_BREAK
1277 case 6:
1278 YY_RULE_SETUP
1279 #line 97 "SDCC.lex"
1280 { count(); return(AT)  ; }
1281         YY_BREAK
1282 case 7:
1283 YY_RULE_SETUP
1284 #line 98 "SDCC.lex"
1285 { count(); return(AUTO); }
1286         YY_BREAK
1287 case 8:
1288 YY_RULE_SETUP
1289 #line 99 "SDCC.lex"
1290 { count(); return(BIT) ; }
1291         YY_BREAK
1292 case 9:
1293 YY_RULE_SETUP
1294 #line 100 "SDCC.lex"
1295 { count(); return(BREAK); }
1296         YY_BREAK
1297 case 10:
1298 YY_RULE_SETUP
1299 #line 101 "SDCC.lex"
1300 { count(); return(CASE); }
1301         YY_BREAK
1302 case 11:
1303 YY_RULE_SETUP
1304 #line 102 "SDCC.lex"
1305 { count(); return(CHAR); }
1306         YY_BREAK
1307 case 12:
1308 YY_RULE_SETUP
1309 #line 103 "SDCC.lex"
1310 { count(); return(CODE); }
1311         YY_BREAK
1312 case 13:
1313 YY_RULE_SETUP
1314 #line 104 "SDCC.lex"
1315 { count(); return(CONST); }
1316         YY_BREAK
1317 case 14:
1318 YY_RULE_SETUP
1319 #line 105 "SDCC.lex"
1320 { count(); return(CONTINUE); }
1321         YY_BREAK
1322 case 15:
1323 YY_RULE_SETUP
1324 #line 106 "SDCC.lex"
1325 { count(); return(CRITICAL); }
1326         YY_BREAK
1327 case 16:
1328 YY_RULE_SETUP
1329 #line 107 "SDCC.lex"
1330 { count(); return(DATA);   }
1331         YY_BREAK
1332 case 17:
1333 YY_RULE_SETUP
1334 #line 108 "SDCC.lex"
1335 { count(); return(DEFAULT); }
1336         YY_BREAK
1337 case 18:
1338 YY_RULE_SETUP
1339 #line 109 "SDCC.lex"
1340 { count(); return(DO); }
1341         YY_BREAK
1342 case 19:
1343 YY_RULE_SETUP
1344 #line 110 "SDCC.lex"
1345 { count(); werror(W_DOUBLE_UNSUPPORTED);return(FLOAT); }
1346         YY_BREAK
1347 case 20:
1348 YY_RULE_SETUP
1349 #line 111 "SDCC.lex"
1350 { count(); return(ELSE); }
1351         YY_BREAK
1352 case 21:
1353 YY_RULE_SETUP
1354 #line 112 "SDCC.lex"
1355 { count(); return(ENUM); }
1356         YY_BREAK
1357 case 22:
1358 YY_RULE_SETUP
1359 #line 113 "SDCC.lex"
1360 { count(); return(EXTERN); }
1361         YY_BREAK
1362 case 23:
1363 YY_RULE_SETUP
1364 #line 114 "SDCC.lex"
1365 { count(); return(XDATA);  }
1366         YY_BREAK
1367 case 24:
1368 YY_RULE_SETUP
1369 #line 115 "SDCC.lex"
1370 { count(); return(FLOAT); }
1371         YY_BREAK
1372 case 25:
1373 YY_RULE_SETUP
1374 #line 116 "SDCC.lex"
1375 { count(); return(FOR); }
1376         YY_BREAK
1377 case 26:
1378 YY_RULE_SETUP
1379 #line 117 "SDCC.lex"
1380 { count(); return(GOTO); }
1381         YY_BREAK
1382 case 27:
1383 YY_RULE_SETUP
1384 #line 118 "SDCC.lex"
1385 { count(); return(IDATA);}
1386         YY_BREAK
1387 case 28:
1388 YY_RULE_SETUP
1389 #line 119 "SDCC.lex"
1390 { count(); return(IF); }
1391         YY_BREAK
1392 case 29:
1393 YY_RULE_SETUP
1394 #line 120 "SDCC.lex"
1395 { count(); return(INT); }
1396         YY_BREAK
1397 case 30:
1398 YY_RULE_SETUP
1399 #line 121 "SDCC.lex"
1400 { count(); return(INTERRUPT);}
1401         YY_BREAK
1402 case 31:
1403 YY_RULE_SETUP
1404 #line 122 "SDCC.lex"
1405 { count(); return(LONG); }
1406         YY_BREAK
1407 case 32:
1408 YY_RULE_SETUP
1409 #line 123 "SDCC.lex"
1410 { count(); return(DATA);}
1411         YY_BREAK
1412 case 33:
1413 YY_RULE_SETUP
1414 #line 124 "SDCC.lex"
1415 { count(); return(PDATA); }
1416         YY_BREAK
1417 case 34:
1418 YY_RULE_SETUP
1419 #line 125 "SDCC.lex"
1420 { count(); return(REENTRANT);}
1421         YY_BREAK
1422 case 35:
1423 YY_RULE_SETUP
1424 #line 126 "SDCC.lex"
1425 { count(); return(REGISTER); }
1426         YY_BREAK
1427 case 36:
1428 YY_RULE_SETUP
1429 #line 127 "SDCC.lex"
1430 { count(); return(RETURN); }
1431         YY_BREAK
1432 case 37:
1433 YY_RULE_SETUP
1434 #line 128 "SDCC.lex"
1435 { count(); return(SFR)  ; }
1436         YY_BREAK
1437 case 38:
1438 YY_RULE_SETUP
1439 #line 129 "SDCC.lex"
1440 { count(); return(SBIT) ; }
1441         YY_BREAK
1442 case 39:
1443 YY_RULE_SETUP
1444 #line 130 "SDCC.lex"
1445 { count(); return(SHORT); }
1446         YY_BREAK
1447 case 40:
1448 YY_RULE_SETUP
1449 #line 131 "SDCC.lex"
1450 { count(); return(SIGNED); }
1451         YY_BREAK
1452 case 41:
1453 YY_RULE_SETUP
1454 #line 132 "SDCC.lex"
1455 { count(); return(SIZEOF); }
1456         YY_BREAK
1457 case 42:
1458 YY_RULE_SETUP
1459 #line 133 "SDCC.lex"
1460 { count(); return(STATIC); }
1461         YY_BREAK
1462 case 43:
1463 YY_RULE_SETUP
1464 #line 134 "SDCC.lex"
1465 { count(); return(STRUCT); }
1466         YY_BREAK
1467 case 44:
1468 YY_RULE_SETUP
1469 #line 135 "SDCC.lex"
1470 { count(); return(SWITCH); }
1471         YY_BREAK
1472 case 45:
1473 YY_RULE_SETUP
1474 #line 136 "SDCC.lex"
1475 { count(); return(TYPEDEF); }
1476         YY_BREAK
1477 case 46:
1478 YY_RULE_SETUP
1479 #line 137 "SDCC.lex"
1480 { count(); return(UNION); }
1481         YY_BREAK
1482 case 47:
1483 YY_RULE_SETUP
1484 #line 138 "SDCC.lex"
1485 { count(); return(UNSIGNED); }
1486         YY_BREAK
1487 case 48:
1488 YY_RULE_SETUP
1489 #line 139 "SDCC.lex"
1490 { count(); return(VOID); }
1491         YY_BREAK
1492 case 49:
1493 YY_RULE_SETUP
1494 #line 140 "SDCC.lex"
1495 { count(); return(VOLATILE); }
1496         YY_BREAK
1497 case 50:
1498 YY_RULE_SETUP
1499 #line 141 "SDCC.lex"
1500 { count(); return(USING); }
1501         YY_BREAK
1502 case 51:
1503 YY_RULE_SETUP
1504 #line 142 "SDCC.lex"
1505 { count(); return(WHILE); }
1506         YY_BREAK
1507 case 52:
1508 YY_RULE_SETUP
1509 #line 143 "SDCC.lex"
1510 { count(); return(XDATA); }
1511         YY_BREAK
1512 case 53:
1513 YY_RULE_SETUP
1514 #line 144 "SDCC.lex"
1515 { count(); return(_NEAR); }
1516         YY_BREAK
1517 case 54:
1518 YY_RULE_SETUP
1519 #line 145 "SDCC.lex"
1520 { count(); return(_CODE); }
1521         YY_BREAK
1522 case 55:
1523 YY_RULE_SETUP
1524 #line 146 "SDCC.lex"
1525 { count(); return(_GENERIC); }
1526         YY_BREAK
1527 case 56:
1528 YY_RULE_SETUP
1529 #line 147 "SDCC.lex"
1530 { count(); return(_NEAR); }
1531         YY_BREAK
1532 case 57:
1533 YY_RULE_SETUP
1534 #line 148 "SDCC.lex"
1535 { count(); return(_XDATA);}
1536         YY_BREAK
1537 case 58:
1538 YY_RULE_SETUP
1539 #line 149 "SDCC.lex"
1540 { count () ; return(_PDATA); }
1541         YY_BREAK
1542 case 59:
1543 YY_RULE_SETUP
1544 #line 150 "SDCC.lex"
1545 { count () ; return(_IDATA); }
1546         YY_BREAK
1547 case 60:
1548 YY_RULE_SETUP
1549 #line 151 "SDCC.lex"
1550 { count(); return(VAR_ARGS);}
1551         YY_BREAK
1552 case 61:
1553 YY_RULE_SETUP
1554 #line 152 "SDCC.lex"
1555 { count(); return(check_type()); }
1556         YY_BREAK
1557 case 62:
1558 YY_RULE_SETUP
1559 #line 153 "SDCC.lex"
1560 { count(); yylval.val = constVal(yytext); return(CONSTANT); }
1561         YY_BREAK
1562 case 63:
1563 YY_RULE_SETUP
1564 #line 154 "SDCC.lex"
1565 { count(); yylval.val = constVal(yytext); return(CONSTANT); }
1566         YY_BREAK
1567 case 64:
1568 YY_RULE_SETUP
1569 #line 155 "SDCC.lex"
1570 { count(); yylval.val = constVal(yytext); return(CONSTANT); }
1571         YY_BREAK
1572 case 65:
1573 YY_RULE_SETUP
1574 #line 156 "SDCC.lex"
1575 { count();yylval.val = charVal (yytext); return(CONSTANT); }
1576         YY_BREAK
1577 case 66:
1578 YY_RULE_SETUP
1579 #line 157 "SDCC.lex"
1580 { count(); yylval.val = constFloatVal(yytext);return(CONSTANT); }
1581         YY_BREAK
1582 case 67:
1583 YY_RULE_SETUP
1584 #line 158 "SDCC.lex"
1585 { count(); yylval.val = constFloatVal(yytext);return(CONSTANT); }
1586         YY_BREAK
1587 case 68:
1588 YY_RULE_SETUP
1589 #line 159 "SDCC.lex"
1590 { count(); yylval.val = constFloatVal(yytext);return(CONSTANT); }
1591         YY_BREAK
1592 case 69:
1593 YY_RULE_SETUP
1594 #line 160 "SDCC.lex"
1595 { count(); yylval.val=strVal(stringLiteral()); return(STRING_LITERAL);}
1596         YY_BREAK
1597 case 70:
1598 YY_RULE_SETUP
1599 #line 161 "SDCC.lex"
1600 { count(); yylval.yyint = RIGHT_ASSIGN ; return(RIGHT_ASSIGN); }
1601         YY_BREAK
1602 case 71:
1603 YY_RULE_SETUP
1604 #line 162 "SDCC.lex"
1605 { count(); yylval.yyint = LEFT_ASSIGN  ; return(LEFT_ASSIGN) ; }
1606         YY_BREAK
1607 case 72:
1608 YY_RULE_SETUP
1609 #line 163 "SDCC.lex"
1610 { count(); yylval.yyint = ADD_ASSIGN   ; return(ADD_ASSIGN)  ; }
1611         YY_BREAK
1612 case 73:
1613 YY_RULE_SETUP
1614 #line 164 "SDCC.lex"
1615 { count(); yylval.yyint = SUB_ASSIGN   ; return(SUB_ASSIGN)  ; }
1616         YY_BREAK
1617 case 74:
1618 YY_RULE_SETUP
1619 #line 165 "SDCC.lex"
1620 { count(); yylval.yyint = MUL_ASSIGN   ; return(MUL_ASSIGN)  ; }
1621         YY_BREAK
1622 case 75:
1623 YY_RULE_SETUP
1624 #line 166 "SDCC.lex"
1625 { count(); yylval.yyint = DIV_ASSIGN   ; return(DIV_ASSIGN)  ; }
1626         YY_BREAK
1627 case 76:
1628 YY_RULE_SETUP
1629 #line 167 "SDCC.lex"
1630 { count(); yylval.yyint = MOD_ASSIGN   ; return(MOD_ASSIGN)  ; }
1631         YY_BREAK
1632 case 77:
1633 YY_RULE_SETUP
1634 #line 168 "SDCC.lex"
1635 { count(); yylval.yyint = AND_ASSIGN   ; return(AND_ASSIGN)  ; }
1636         YY_BREAK
1637 case 78:
1638 YY_RULE_SETUP
1639 #line 169 "SDCC.lex"
1640 { count(); yylval.yyint = XOR_ASSIGN   ; return(XOR_ASSIGN)  ; }
1641         YY_BREAK
1642 case 79:
1643 YY_RULE_SETUP
1644 #line 170 "SDCC.lex"
1645 { count(); yylval.yyint = OR_ASSIGN    ; return(OR_ASSIGN)   ; }
1646         YY_BREAK
1647 case 80:
1648 YY_RULE_SETUP
1649 #line 171 "SDCC.lex"
1650 { count(); return(RIGHT_OP); }
1651         YY_BREAK
1652 case 81:
1653 YY_RULE_SETUP
1654 #line 172 "SDCC.lex"
1655 { count(); return(LEFT_OP); }
1656         YY_BREAK
1657 case 82:
1658 YY_RULE_SETUP
1659 #line 173 "SDCC.lex"
1660 { count(); return(INC_OP); }
1661         YY_BREAK
1662 case 83:
1663 YY_RULE_SETUP
1664 #line 174 "SDCC.lex"
1665 { count(); return(DEC_OP); }
1666         YY_BREAK
1667 case 84:
1668 YY_RULE_SETUP
1669 #line 175 "SDCC.lex"
1670 { count(); return(PTR_OP); }
1671         YY_BREAK
1672 case 85:
1673 YY_RULE_SETUP
1674 #line 176 "SDCC.lex"
1675 { count(); return(AND_OP); }
1676         YY_BREAK
1677 case 86:
1678 YY_RULE_SETUP
1679 #line 177 "SDCC.lex"
1680 { count(); return(OR_OP); }
1681         YY_BREAK
1682 case 87:
1683 YY_RULE_SETUP
1684 #line 178 "SDCC.lex"
1685 { count(); return(LE_OP); }
1686         YY_BREAK
1687 case 88:
1688 YY_RULE_SETUP
1689 #line 179 "SDCC.lex"
1690 { count(); return(GE_OP); }
1691         YY_BREAK
1692 case 89:
1693 YY_RULE_SETUP
1694 #line 180 "SDCC.lex"
1695 { count(); return(EQ_OP); }
1696         YY_BREAK
1697 case 90:
1698 YY_RULE_SETUP
1699 #line 181 "SDCC.lex"
1700 { count(); return(NE_OP); }
1701         YY_BREAK
1702 case 91:
1703 YY_RULE_SETUP
1704 #line 182 "SDCC.lex"
1705 { count(); return(';'); }
1706         YY_BREAK
1707 case 92:
1708 YY_RULE_SETUP
1709 #line 183 "SDCC.lex"
1710 { count()       ; NestLevel++ ;  return('{'); }
1711         YY_BREAK
1712 case 93:
1713 YY_RULE_SETUP
1714 #line 184 "SDCC.lex"
1715 { count(); NestLevel--; return('}'); }
1716         YY_BREAK
1717 case 94:
1718 YY_RULE_SETUP
1719 #line 185 "SDCC.lex"
1720 { count(); return(','); }
1721         YY_BREAK
1722 case 95:
1723 YY_RULE_SETUP
1724 #line 186 "SDCC.lex"
1725 { count(); return(':'); }
1726         YY_BREAK
1727 case 96:
1728 YY_RULE_SETUP
1729 #line 187 "SDCC.lex"
1730 { count(); return('='); }
1731         YY_BREAK
1732 case 97:
1733 YY_RULE_SETUP
1734 #line 188 "SDCC.lex"
1735 { count(); return('('); }
1736         YY_BREAK
1737 case 98:
1738 YY_RULE_SETUP
1739 #line 189 "SDCC.lex"
1740 { count(); return(')'); }
1741         YY_BREAK
1742 case 99:
1743 YY_RULE_SETUP
1744 #line 190 "SDCC.lex"
1745 { count(); return('['); }
1746         YY_BREAK
1747 case 100:
1748 YY_RULE_SETUP
1749 #line 191 "SDCC.lex"
1750 { count(); return(']'); }
1751         YY_BREAK
1752 case 101:
1753 YY_RULE_SETUP
1754 #line 192 "SDCC.lex"
1755 { count(); return('.'); }
1756         YY_BREAK
1757 case 102:
1758 YY_RULE_SETUP
1759 #line 193 "SDCC.lex"
1760 { count(); return('&'); }
1761         YY_BREAK
1762 case 103:
1763 YY_RULE_SETUP
1764 #line 194 "SDCC.lex"
1765 { count(); return('!'); }
1766         YY_BREAK
1767 case 104:
1768 YY_RULE_SETUP
1769 #line 195 "SDCC.lex"
1770 { count(); return('~'); }
1771         YY_BREAK
1772 case 105:
1773 YY_RULE_SETUP
1774 #line 196 "SDCC.lex"
1775 { count(); return('-'); }
1776         YY_BREAK
1777 case 106:
1778 YY_RULE_SETUP
1779 #line 197 "SDCC.lex"
1780 { count(); return('+'); }
1781         YY_BREAK
1782 case 107:
1783 YY_RULE_SETUP
1784 #line 198 "SDCC.lex"
1785 { count(); return('*'); }
1786         YY_BREAK
1787 case 108:
1788 YY_RULE_SETUP
1789 #line 199 "SDCC.lex"
1790 { count(); return('/'); }
1791         YY_BREAK
1792 case 109:
1793 YY_RULE_SETUP
1794 #line 200 "SDCC.lex"
1795 { count(); return('%'); }
1796         YY_BREAK
1797 case 110:
1798 YY_RULE_SETUP
1799 #line 201 "SDCC.lex"
1800 { count(); return('<'); }
1801         YY_BREAK
1802 case 111:
1803 YY_RULE_SETUP
1804 #line 202 "SDCC.lex"
1805 { count(); return('>'); }
1806         YY_BREAK
1807 case 112:
1808 YY_RULE_SETUP
1809 #line 203 "SDCC.lex"
1810 { count(); return('^'); }
1811         YY_BREAK
1812 case 113:
1813 YY_RULE_SETUP
1814 #line 204 "SDCC.lex"
1815 { count(); return('|'); }
1816         YY_BREAK
1817 case 114:
1818 YY_RULE_SETUP
1819 #line 205 "SDCC.lex"
1820 { count(); return('?'); }
1821         YY_BREAK
1822 case 115:
1823 YY_RULE_SETUP
1824 #line 206 "SDCC.lex"
1825 { count(); checkCurrFile(yytext); }
1826         YY_BREAK
1827 case 116:
1828 YY_RULE_SETUP
1829 #line 207 "SDCC.lex"
1830 { count(); process_pragma(yytext); }
1831         YY_BREAK
1832 case 117:
1833 YY_RULE_SETUP
1834 #line 209 "SDCC.lex"
1835 { werror(E_PRE_PROC_FAILED,yytext);count(); }
1836         YY_BREAK
1837 case 118:
1838 YY_RULE_SETUP
1839 #line 210 "SDCC.lex"
1840 { werror(W_PRE_PROC_WARNING,yytext);count(); }
1841         YY_BREAK
1842 case 119:
1843 YY_RULE_SETUP
1844 #line 211 "SDCC.lex"
1845 { count(); }
1846         YY_BREAK
1847 case 120:
1848 YY_RULE_SETUP
1849 #line 212 "SDCC.lex"
1850 { count(); }
1851         YY_BREAK
1852 case 121:
1853 YY_RULE_SETUP
1854 #line 213 "SDCC.lex"
1855 { count(); }
1856         YY_BREAK
1857 case 122:
1858 YY_RULE_SETUP
1859 #line 214 "SDCC.lex"
1860 { count()       ; }
1861         YY_BREAK
1862 case 123:
1863 YY_RULE_SETUP
1864 #line 215 "SDCC.lex"
1865 ECHO;
1866         YY_BREAK
1867 case YY_STATE_EOF(INITIAL):
1868 case YY_STATE_EOF(asm):
1869         yyterminate();
1870
1871         case YY_END_OF_BUFFER:
1872                 {
1873                 /* Amount of text matched not including the EOB char. */
1874                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1875
1876                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1877                 *yy_cp = yy_hold_char;
1878                 YY_RESTORE_YY_MORE_OFFSET
1879
1880                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1881                         {
1882                         /* We're scanning a new file or input source.  It's
1883                          * possible that this happened because the user
1884                          * just pointed yyin at a new source and called
1885                          * yylex().  If so, then we have to assure
1886                          * consistency between yy_current_buffer and our
1887                          * globals.  Here is the right place to do so, because
1888                          * this is the first action (other than possibly a
1889                          * back-up) that will match for the new input source.
1890                          */
1891                         yy_n_chars = yy_current_buffer->yy_n_chars;
1892                         yy_current_buffer->yy_input_file = yyin;
1893                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1894                         }
1895
1896                 /* Note that here we test for yy_c_buf_p "<=" to the position
1897                  * of the first EOB in the buffer, since yy_c_buf_p will
1898                  * already have been incremented past the NUL character
1899                  * (since all states make transitions on EOB to the
1900                  * end-of-buffer state).  Contrast this with the test
1901                  * in input().
1902                  */
1903                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1904                         { /* This was really a NUL. */
1905                         yy_state_type yy_next_state;
1906
1907                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1908
1909                         yy_current_state = yy_get_previous_state();
1910
1911                         /* Okay, we're now positioned to make the NUL
1912                          * transition.  We couldn't have
1913                          * yy_get_previous_state() go ahead and do it
1914                          * for us because it doesn't know how to deal
1915                          * with the possibility of jamming (and we don't
1916                          * want to build jamming into it because then it
1917                          * will run more slowly).
1918                          */
1919
1920                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1921
1922                         yy_bp = yytext_ptr + YY_MORE_ADJ;
1923
1924                         if ( yy_next_state )
1925                                 {
1926                                 /* Consume the NUL. */
1927                                 yy_cp = ++yy_c_buf_p;
1928                                 yy_current_state = yy_next_state;
1929                                 goto yy_match;
1930                                 }
1931
1932                         else
1933                                 {
1934                                 yy_cp = yy_c_buf_p;
1935                                 goto yy_find_action;
1936                                 }
1937                         }
1938
1939                 else switch ( yy_get_next_buffer() )
1940                         {
1941                         case EOB_ACT_END_OF_FILE:
1942                                 {
1943                                 yy_did_buffer_switch_on_eof = 0;
1944
1945                                 if ( yywrap() )
1946                                         {
1947                                         /* Note: because we've taken care in
1948                                          * yy_get_next_buffer() to have set up
1949                                          * yytext, we can now set up
1950                                          * yy_c_buf_p so that if some total
1951                                          * hoser (like flex itself) wants to
1952                                          * call the scanner after we return the
1953                                          * YY_NULL, it'll still work - another
1954                                          * YY_NULL will get returned.
1955                                          */
1956                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1957
1958                                         yy_act = YY_STATE_EOF(YY_START);
1959                                         goto do_action;
1960                                         }
1961
1962                                 else
1963                                         {
1964                                         if ( ! yy_did_buffer_switch_on_eof )
1965                                                 YY_NEW_FILE;
1966                                         }
1967                                 break;
1968                                 }
1969
1970                         case EOB_ACT_CONTINUE_SCAN:
1971                                 yy_c_buf_p =
1972                                         yytext_ptr + yy_amount_of_matched_text;
1973
1974                                 yy_current_state = yy_get_previous_state();
1975
1976                                 yy_cp = yy_c_buf_p;
1977                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1978                                 goto yy_match;
1979
1980                         case EOB_ACT_LAST_MATCH:
1981                                 yy_c_buf_p =
1982                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1983
1984                                 yy_current_state = yy_get_previous_state();
1985
1986                                 yy_cp = yy_c_buf_p;
1987                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1988                                 goto yy_find_action;
1989                         }
1990                 break;
1991                 }
1992
1993         default:
1994                 YY_FATAL_ERROR(
1995                         "fatal flex scanner internal error--no action found" );
1996         } /* end of action switch */
1997                 } /* end of scanning one token */
1998         } /* end of yylex */
1999
2000
2001 /* yy_get_next_buffer - try to read in a new buffer
2002  *
2003  * Returns a code representing an action:
2004  *      EOB_ACT_LAST_MATCH -
2005  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2006  *      EOB_ACT_END_OF_FILE - end of file
2007  */
2008
2009 static int yy_get_next_buffer()
2010         {
2011         register char *dest = yy_current_buffer->yy_ch_buf;
2012         register char *source = yytext_ptr;
2013         register int number_to_move, i;
2014         int ret_val;
2015
2016         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
2017                 YY_FATAL_ERROR(
2018                 "fatal flex scanner internal error--end of buffer missed" );
2019
2020         if ( yy_current_buffer->yy_fill_buffer == 0 )
2021                 { /* Don't try to fill the buffer, so this is an EOF. */
2022                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
2023                         {
2024                         /* We matched a single character, the EOB, so
2025                          * treat this as a final EOF.
2026                          */
2027                         return EOB_ACT_END_OF_FILE;
2028                         }
2029
2030                 else
2031                         {
2032                         /* We matched some text prior to the EOB, first
2033                          * process it.
2034                          */
2035                         return EOB_ACT_LAST_MATCH;
2036                         }
2037                 }
2038
2039         /* Try to read more data. */
2040
2041         /* First move last chars to start of buffer. */
2042         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
2043
2044         for ( i = 0; i < number_to_move; ++i )
2045                 *(dest++) = *(source++);
2046
2047         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2048                 /* don't do the read, it's not guaranteed to return an EOF,
2049                  * just force an EOF
2050                  */
2051                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
2052
2053         else
2054                 {
2055                 int num_to_read =
2056                         yy_current_buffer->yy_buf_size - number_to_move - 1;
2057
2058                 while ( num_to_read <= 0 )
2059                         { /* Not enough room in the buffer - grow it. */
2060 #ifdef YY_USES_REJECT
2061                         YY_FATAL_ERROR(
2062 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
2063 #else
2064
2065                         /* just a shorter name for the current buffer */
2066                         YY_BUFFER_STATE b = yy_current_buffer;
2067
2068                         int yy_c_buf_p_offset =
2069                                 (int) (yy_c_buf_p - b->yy_ch_buf);
2070
2071                         if ( b->yy_is_our_buffer )
2072                                 {
2073                                 int new_size = b->yy_buf_size * 2;
2074
2075                                 if ( new_size <= 0 )
2076                                         b->yy_buf_size += b->yy_buf_size / 8;
2077                                 else
2078                                         b->yy_buf_size *= 2;
2079
2080                                 b->yy_ch_buf = (char *)
2081                                         /* Include room in for 2 EOB chars. */
2082                                         yy_flex_realloc( (void *) b->yy_ch_buf,
2083                                                          b->yy_buf_size + 2 );
2084                                 }
2085                         else
2086                                 /* Can't grow it, we don't own it. */
2087                                 b->yy_ch_buf = 0;
2088
2089                         if ( ! b->yy_ch_buf )
2090                                 YY_FATAL_ERROR(
2091                                 "fatal error - scanner input buffer overflow" );
2092
2093                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
2094
2095                         num_to_read = yy_current_buffer->yy_buf_size -
2096                                                 number_to_move - 1;
2097 #endif
2098                         }
2099
2100                 if ( num_to_read > YY_READ_BUF_SIZE )
2101                         num_to_read = YY_READ_BUF_SIZE;
2102
2103                 /* Read in more data. */
2104                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
2105                         yy_n_chars, num_to_read );
2106
2107                 yy_current_buffer->yy_n_chars = yy_n_chars;
2108                 }
2109
2110         if ( yy_n_chars == 0 )
2111                 {
2112                 if ( number_to_move == YY_MORE_ADJ )
2113                         {
2114                         ret_val = EOB_ACT_END_OF_FILE;
2115                         yyrestart( yyin );
2116                         }
2117
2118                 else
2119                         {
2120                         ret_val = EOB_ACT_LAST_MATCH;
2121                         yy_current_buffer->yy_buffer_status =
2122                                 YY_BUFFER_EOF_PENDING;
2123                         }
2124                 }
2125
2126         else
2127                 ret_val = EOB_ACT_CONTINUE_SCAN;
2128
2129         yy_n_chars += number_to_move;
2130         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
2131         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
2132
2133         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
2134
2135         return ret_val;
2136         }
2137
2138
2139 /* yy_get_previous_state - get the state just before the EOB char was reached */
2140
2141 static yy_state_type yy_get_previous_state()
2142         {
2143         register yy_state_type yy_current_state;
2144         register char *yy_cp;
2145
2146         yy_current_state = yy_start;
2147         yy_current_state += YY_AT_BOL();
2148
2149         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
2150                 {
2151                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2152                 if ( yy_accept[yy_current_state] )
2153                         {
2154                         yy_last_accepting_state = yy_current_state;
2155                         yy_last_accepting_cpos = yy_cp;
2156                         }
2157                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2158                         {
2159                         yy_current_state = (int) yy_def[yy_current_state];
2160                         if ( yy_current_state >= 767 )
2161                                 yy_c = yy_meta[(unsigned int) yy_c];
2162                         }
2163                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2164                 }
2165
2166         return yy_current_state;
2167         }
2168
2169
2170 /* yy_try_NUL_trans - try to make a transition on the NUL character
2171  *
2172  * synopsis
2173  *      next_state = yy_try_NUL_trans( current_state );
2174  */
2175
2176 #ifdef YY_USE_PROTOS
2177 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
2178 #else
2179 static yy_state_type yy_try_NUL_trans( yy_current_state )
2180 yy_state_type yy_current_state;
2181 #endif
2182         {
2183         register int yy_is_jam;
2184         register char *yy_cp = yy_c_buf_p;
2185
2186         register YY_CHAR yy_c = 1;
2187         if ( yy_accept[yy_current_state] )
2188                 {
2189                 yy_last_accepting_state = yy_current_state;
2190                 yy_last_accepting_cpos = yy_cp;
2191                 }
2192         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2193                 {
2194                 yy_current_state = (int) yy_def[yy_current_state];
2195                 if ( yy_current_state >= 767 )
2196                         yy_c = yy_meta[(unsigned int) yy_c];
2197                 }
2198         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2199         yy_is_jam = (yy_current_state == 766);
2200
2201         return yy_is_jam ? 0 : yy_current_state;
2202         }
2203
2204
2205 #ifndef YY_NO_UNPUT
2206 #ifdef YY_USE_PROTOS
2207 static void yyunput( int c, register char *yy_bp )
2208 #else
2209 static void yyunput( c, yy_bp )
2210 int c;
2211 register char *yy_bp;
2212 #endif
2213         {
2214         register char *yy_cp = yy_c_buf_p;
2215
2216         /* undo effects of setting up yytext */
2217         *yy_cp = yy_hold_char;
2218
2219         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2220                 { /* need to shift things up to make room */
2221                 /* +2 for EOB chars. */
2222                 register int number_to_move = yy_n_chars + 2;
2223                 register char *dest = &yy_current_buffer->yy_ch_buf[
2224                                         yy_current_buffer->yy_buf_size + 2];
2225                 register char *source =
2226                                 &yy_current_buffer->yy_ch_buf[number_to_move];
2227
2228                 while ( source > yy_current_buffer->yy_ch_buf )
2229                         *--dest = *--source;
2230
2231                 yy_cp += (int) (dest - source);
2232                 yy_bp += (int) (dest - source);
2233                 yy_current_buffer->yy_n_chars =
2234                         yy_n_chars = yy_current_buffer->yy_buf_size;
2235
2236                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2237                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2238                 }
2239
2240         *--yy_cp = (char) c;
2241
2242
2243         yytext_ptr = yy_bp;
2244         yy_hold_char = *yy_cp;
2245         yy_c_buf_p = yy_cp;
2246         }
2247 #endif  /* ifndef YY_NO_UNPUT */
2248
2249
2250 #ifdef __cplusplus
2251 static int yyinput()
2252 #else
2253 static int input()
2254 #endif
2255         {
2256         int c;
2257
2258         *yy_c_buf_p = yy_hold_char;
2259
2260         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2261                 {
2262                 /* yy_c_buf_p now points to the character we want to return.
2263                  * If this occurs *before* the EOB characters, then it's a
2264                  * valid NUL; if not, then we've hit the end of the buffer.
2265                  */
2266                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2267                         /* This was really a NUL. */
2268                         *yy_c_buf_p = '\0';
2269
2270                 else
2271                         { /* need more input */
2272                         int offset = yy_c_buf_p - yytext_ptr;
2273                         ++yy_c_buf_p;
2274
2275                         switch ( yy_get_next_buffer() )
2276                                 {
2277                                 case EOB_ACT_LAST_MATCH:
2278                                         /* This happens because yy_g_n_b()
2279                                          * sees that we've accumulated a
2280                                          * token and flags that we need to
2281                                          * try matching the token before
2282                                          * proceeding.  But for input(),
2283                                          * there's no matching to consider.
2284                                          * So convert the EOB_ACT_LAST_MATCH
2285                                          * to EOB_ACT_END_OF_FILE.
2286                                          */
2287
2288                                         /* Reset buffer status. */
2289                                         yyrestart( yyin );
2290
2291                                         /* fall through */
2292
2293                                 case EOB_ACT_END_OF_FILE:
2294                                         {
2295                                         if ( yywrap() )
2296                                                 return EOF;
2297
2298                                         if ( ! yy_did_buffer_switch_on_eof )
2299                                                 YY_NEW_FILE;
2300 #ifdef __cplusplus
2301                                         return yyinput();
2302 #else
2303                                         return input();
2304 #endif
2305                                         }
2306
2307                                 case EOB_ACT_CONTINUE_SCAN:
2308                                         yy_c_buf_p = yytext_ptr + offset;
2309                                         break;
2310                                 }
2311                         }
2312                 }
2313
2314         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
2315         *yy_c_buf_p = '\0';     /* preserve yytext */
2316         yy_hold_char = *++yy_c_buf_p;
2317
2318         yy_current_buffer->yy_at_bol = (c == '\n');
2319
2320         return c;
2321         }
2322
2323
2324 #ifdef YY_USE_PROTOS
2325 void yyrestart( FILE *input_file )
2326 #else
2327 void yyrestart( input_file )
2328 FILE *input_file;
2329 #endif
2330         {
2331         if ( ! yy_current_buffer )
2332                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
2333
2334         yy_init_buffer( yy_current_buffer, input_file );
2335         yy_load_buffer_state();
2336         }
2337
2338
2339 #ifdef YY_USE_PROTOS
2340 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2341 #else
2342 void yy_switch_to_buffer( new_buffer )
2343 YY_BUFFER_STATE new_buffer;
2344 #endif
2345         {
2346         if ( yy_current_buffer == new_buffer )
2347                 return;
2348
2349         if ( yy_current_buffer )
2350                 {
2351                 /* Flush out information for old buffer. */
2352                 *yy_c_buf_p = yy_hold_char;
2353                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2354                 yy_current_buffer->yy_n_chars = yy_n_chars;
2355                 }
2356
2357         yy_current_buffer = new_buffer;
2358         yy_load_buffer_state();
2359
2360         /* We don't actually know whether we did this switch during
2361          * EOF (yywrap()) processing, but the only time this flag
2362          * is looked at is after yywrap() is called, so it's safe
2363          * to go ahead and always set it.
2364          */
2365         yy_did_buffer_switch_on_eof = 1;
2366         }
2367
2368
2369 #ifdef YY_USE_PROTOS
2370 void yy_load_buffer_state( void )
2371 #else
2372 void yy_load_buffer_state()
2373 #endif
2374         {
2375         yy_n_chars = yy_current_buffer->yy_n_chars;
2376         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2377         yyin = yy_current_buffer->yy_input_file;
2378         yy_hold_char = *yy_c_buf_p;
2379         }
2380
2381
2382 #ifdef YY_USE_PROTOS
2383 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2384 #else
2385 YY_BUFFER_STATE yy_create_buffer( file, size )
2386 FILE *file;
2387 int size;
2388 #endif
2389         {
2390         YY_BUFFER_STATE b;
2391
2392         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2393         if ( ! b )
2394                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2395
2396         b->yy_buf_size = size;
2397
2398         /* yy_ch_buf has to be 2 characters longer than the size given because
2399          * we need to put in 2 end-of-buffer characters.
2400          */
2401         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2402         if ( ! b->yy_ch_buf )
2403                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2404
2405         b->yy_is_our_buffer = 1;
2406
2407         yy_init_buffer( b, file );
2408
2409         return b;
2410         }
2411
2412
2413 #ifdef YY_USE_PROTOS
2414 void yy_delete_buffer( YY_BUFFER_STATE b )
2415 #else
2416 void yy_delete_buffer( b )
2417 YY_BUFFER_STATE b;
2418 #endif
2419         {
2420         if ( ! b )
2421                 return;
2422
2423         if ( b == yy_current_buffer )
2424                 yy_current_buffer = (YY_BUFFER_STATE) 0;
2425
2426         if ( b->yy_is_our_buffer )
2427                 yy_flex_free( (void *) b->yy_ch_buf );
2428
2429         yy_flex_free( (void *) b );
2430         }
2431
2432
2433 #ifndef YY_ALWAYS_INTERACTIVE
2434 #ifndef YY_NEVER_INTERACTIVE
2435 extern int isatty YY_PROTO(( int ));
2436 #endif
2437 #endif
2438
2439 #ifdef YY_USE_PROTOS
2440 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
2441 #else
2442 void yy_init_buffer( b, file )
2443 YY_BUFFER_STATE b;
2444 FILE *file;
2445 #endif
2446
2447
2448         {
2449         yy_flush_buffer( b );
2450
2451         b->yy_input_file = file;
2452         b->yy_fill_buffer = 1;
2453
2454 #if YY_ALWAYS_INTERACTIVE
2455         b->yy_is_interactive = 1;
2456 #else
2457 #if YY_NEVER_INTERACTIVE
2458         b->yy_is_interactive = 0;
2459 #else
2460         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2461 #endif
2462 #endif
2463         }
2464
2465
2466 #ifdef YY_USE_PROTOS
2467 void yy_flush_buffer( YY_BUFFER_STATE b )
2468 #else
2469 void yy_flush_buffer( b )
2470 YY_BUFFER_STATE b;
2471 #endif
2472
2473         {
2474         if ( ! b )
2475                 return;
2476
2477         b->yy_n_chars = 0;
2478
2479         /* We always need two end-of-buffer characters.  The first causes
2480          * a transition to the end-of-buffer state.  The second causes
2481          * a jam in that state.
2482          */
2483         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2484         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2485
2486         b->yy_buf_pos = &b->yy_ch_buf[0];
2487
2488         b->yy_at_bol = 1;
2489         b->yy_buffer_status = YY_BUFFER_NEW;
2490
2491         if ( b == yy_current_buffer )
2492                 yy_load_buffer_state();
2493         }
2494
2495
2496 #ifndef YY_NO_SCAN_BUFFER
2497 #ifdef YY_USE_PROTOS
2498 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
2499 #else
2500 YY_BUFFER_STATE yy_scan_buffer( base, size )
2501 char *base;
2502 yy_size_t size;
2503 #endif
2504         {
2505         YY_BUFFER_STATE b;
2506
2507         if ( size < 2 ||
2508              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2509              base[size-1] != YY_END_OF_BUFFER_CHAR )
2510                 /* They forgot to leave room for the EOB's. */
2511                 return 0;
2512
2513         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2514         if ( ! b )
2515                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2516
2517         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2518         b->yy_buf_pos = b->yy_ch_buf = base;
2519         b->yy_is_our_buffer = 0;
2520         b->yy_input_file = 0;
2521         b->yy_n_chars = b->yy_buf_size;
2522         b->yy_is_interactive = 0;
2523         b->yy_at_bol = 1;
2524         b->yy_fill_buffer = 0;
2525         b->yy_buffer_status = YY_BUFFER_NEW;
2526
2527         yy_switch_to_buffer( b );
2528
2529         return b;
2530         }
2531 #endif
2532
2533
2534 #ifndef YY_NO_SCAN_STRING
2535 #ifdef YY_USE_PROTOS
2536 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
2537 #else
2538 YY_BUFFER_STATE yy_scan_string( yy_str )
2539 yyconst char *yy_str;
2540 #endif
2541         {
2542         int len;
2543         for ( len = 0; yy_str[len]; ++len )
2544                 ;
2545
2546         return yy_scan_bytes( yy_str, len );
2547         }
2548 #endif
2549
2550
2551 #ifndef YY_NO_SCAN_BYTES
2552 #ifdef YY_USE_PROTOS
2553 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2554 #else
2555 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2556 yyconst char *bytes;
2557 int len;
2558 #endif
2559         {
2560         YY_BUFFER_STATE b;
2561         char *buf;
2562         yy_size_t n;
2563         int i;
2564
2565         /* Get memory for full buffer, including space for trailing EOB's. */
2566         n = len + 2;
2567         buf = (char *) yy_flex_alloc( n );
2568         if ( ! buf )
2569                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2570
2571         for ( i = 0; i < len; ++i )
2572                 buf[i] = bytes[i];
2573
2574         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2575
2576         b = yy_scan_buffer( buf, n );
2577         if ( ! b )
2578                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2579
2580         /* It's okay to grow etc. this buffer, and we should throw it
2581          * away when we're done.
2582          */
2583         b->yy_is_our_buffer = 1;
2584
2585         return b;
2586         }
2587 #endif
2588
2589
2590 #ifndef YY_NO_PUSH_STATE
2591 #ifdef YY_USE_PROTOS
2592 static void yy_push_state( int new_state )
2593 #else
2594 static void yy_push_state( new_state )
2595 int new_state;
2596 #endif
2597         {
2598         if ( yy_start_stack_ptr >= yy_start_stack_depth )
2599                 {
2600                 yy_size_t new_size;
2601
2602                 yy_start_stack_depth += YY_START_STACK_INCR;
2603                 new_size = yy_start_stack_depth * sizeof( int );
2604
2605                 if ( ! yy_start_stack )
2606                         yy_start_stack = (int *) yy_flex_alloc( new_size );
2607
2608                 else
2609                         yy_start_stack = (int *) yy_flex_realloc(
2610                                         (void *) yy_start_stack, new_size );
2611
2612                 if ( ! yy_start_stack )
2613                         YY_FATAL_ERROR(
2614                         "out of memory expanding start-condition stack" );
2615                 }
2616
2617         yy_start_stack[yy_start_stack_ptr++] = YY_START;
2618
2619         BEGIN(new_state);
2620         }
2621 #endif
2622
2623
2624 #ifndef YY_NO_POP_STATE
2625 static void yy_pop_state()
2626         {
2627         if ( --yy_start_stack_ptr < 0 )
2628                 YY_FATAL_ERROR( "start-condition stack underflow" );
2629
2630         BEGIN(yy_start_stack[yy_start_stack_ptr]);
2631         }
2632 #endif
2633
2634
2635 #ifndef YY_NO_TOP_STATE
2636 static int yy_top_state()
2637         {
2638         return yy_start_stack[yy_start_stack_ptr - 1];
2639         }
2640 #endif
2641
2642 #ifndef YY_EXIT_FAILURE
2643 #define YY_EXIT_FAILURE 2
2644 #endif
2645
2646 #ifdef YY_USE_PROTOS
2647 static void yy_fatal_error( yyconst char msg[] )
2648 #else
2649 static void yy_fatal_error( msg )
2650 char msg[];
2651 #endif
2652         {
2653         (void) fprintf( stderr, "%s\n", msg );
2654         exit( YY_EXIT_FAILURE );
2655         }
2656
2657
2658
2659 /* Redefine yyless() so it works in section 3 code. */
2660
2661 #undef yyless
2662 #define yyless(n) \
2663         do \
2664                 { \
2665                 /* Undo effects of setting up yytext. */ \
2666                 yytext[yyleng] = yy_hold_char; \
2667                 yy_c_buf_p = yytext + n; \
2668                 yy_hold_char = *yy_c_buf_p; \
2669                 *yy_c_buf_p = '\0'; \
2670                 yyleng = n; \
2671                 } \
2672         while ( 0 )
2673
2674
2675 /* Internal utility routines. */
2676
2677 #ifndef yytext_ptr
2678 #ifdef YY_USE_PROTOS
2679 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2680 #else
2681 static void yy_flex_strncpy( s1, s2, n )
2682 char *s1;
2683 yyconst char *s2;
2684 int n;
2685 #endif
2686         {
2687         register int i;
2688         for ( i = 0; i < n; ++i )
2689                 s1[i] = s2[i];
2690         }
2691 #endif
2692
2693 #ifdef YY_NEED_STRLEN
2694 #ifdef YY_USE_PROTOS
2695 static int yy_flex_strlen( yyconst char *s )
2696 #else
2697 static int yy_flex_strlen( s )
2698 yyconst char *s;
2699 #endif
2700         {
2701         register int n;
2702         for ( n = 0; s[n]; ++n )
2703                 ;
2704
2705         return n;
2706         }
2707 #endif
2708
2709
2710 #ifdef YY_USE_PROTOS
2711 static void *yy_flex_alloc( yy_size_t size )
2712 #else
2713 static void *yy_flex_alloc( size )
2714 yy_size_t size;
2715 #endif
2716         {
2717         return (void *) malloc( size );
2718         }
2719
2720 #ifdef YY_USE_PROTOS
2721 static void *yy_flex_realloc( void *ptr, yy_size_t size )
2722 #else
2723 static void *yy_flex_realloc( ptr, size )
2724 void *ptr;
2725 yy_size_t size;
2726 #endif
2727         {
2728         /* The cast to (char *) in the following accommodates both
2729          * implementations that use char* generic pointers, and those
2730          * that use void* generic pointers.  It works with the latter
2731          * because both ANSI C and C++ allow castless assignment from
2732          * any pointer type to void*, and deal with argument conversions
2733          * as though doing an assignment.
2734          */
2735         return (void *) realloc( (char *) ptr, size );
2736         }
2737
2738 #ifdef YY_USE_PROTOS
2739 static void yy_flex_free( void *ptr )
2740 #else
2741 static void yy_flex_free( ptr )
2742 void *ptr;
2743 #endif
2744         {
2745         free( ptr );
2746         }
2747
2748 #if YY_MAIN
2749 int main()
2750         {
2751         yylex();
2752         return 0;
2753         }
2754 #endif
2755 #line 215 "SDCC.lex"
2756
2757
2758 int checkCurrFile ( char *s)
2759 {
2760     char lineNum[10]                    ;
2761     int  lNum                           ;
2762     char *tptr                          ;
2763
2764     /* first check if this is a #line */
2765     if ( strncmp(s,"#line",5) )
2766         return  0                               ;
2767
2768     /* get to the line number */
2769     while (!isdigit(*s))
2770         s++ ;
2771     tptr = lineNum ;
2772     while (isdigit(*s))
2773         *tptr++ = *s++ ;
2774     *tptr = '\0';
2775     sscanf(lineNum,"%d",&lNum);
2776
2777     /* now see if we have a file name */
2778     while (*s != '\"' && *s)
2779         s++ ;
2780
2781     /* if we don't have a filename then */
2782     /* set the current line number to   */
2783     /* line number if printFlag is on   */
2784     if (!*s) {
2785         yylineno = lNum ;
2786         return 0;
2787     }
2788
2789     /* if we have a filename then check */
2790     /* if it is "standard in" if yes then */
2791     /* get the currentfile name info    */
2792     s++ ;
2793
2794     if ( strncmp(s,fullSrcFileName,strlen(fullSrcFileName)) == 0) {
2795             yylineno = lNum - 2;
2796             currFname = fullSrcFileName ;
2797     }  else {
2798         char *sb = s;
2799         /* mark the end of the filename */
2800         while (*s != '"') s++;
2801         *s = '\0';
2802         ALLOC_ATOMIC(currFname,strlen(sb)+1);
2803         strcpy(currFname,sb);
2804         yylineno = lNum - 2;
2805     }
2806     filename = currFname ;
2807     return 0;
2808 }
2809
2810 void comment()
2811 {
2812         char c, c1;
2813
2814 loop:
2815         while ((c = input()) != '*' && c != 0)
2816                 if ( c == '\n')
2817                         yylineno++ ;
2818
2819         if ((c1 = input()) != '/' && c != 0)  {
2820                 if ( c1 == '\n' )
2821                         yylineno++ ;
2822
2823                 unput(c1);
2824                 goto loop;
2825    }
2826
2827 }
2828
2829
2830
2831 int column = 0;
2832 int plineIdx=0;
2833
2834 void count()
2835 {
2836         int i;
2837         for (i = 0; yytext[i] != '\0'; i++)   {
2838                 if (yytext[i] == '\n')      {
2839                    column = 0;
2840                    lineno = ++yylineno ;
2841                 }
2842                 else
2843                         if (yytext[i] == '\t')
2844                                 column += 8 - (column % 8);
2845                         else
2846                                 column++;
2847    }
2848
2849    /* ECHO; */
2850 }
2851
2852 int check_type()
2853 {
2854         /* check if it is in the typedef table */
2855         if (findSym(TypedefTab,NULL,yytext)) {
2856                 strcpy(yylval.yychar,yytext);
2857                 return (TYPE_NAME) ;
2858         }
2859         else   {
2860                 strcpy (yylval.yychar,yytext);
2861                 return(IDENTIFIER);
2862         }
2863 }
2864
2865 char strLitBuff[2048]                   ;
2866
2867 char *stringLiteral ()
2868 {
2869        int ch;
2870        char *str = strLitBuff                   ;
2871
2872        *str++ = '\"'                    ;
2873        /* put into the buffer till we hit the */
2874        /* first \" */
2875        while (1) {
2876
2877           ch = input()                  ;
2878           if (!ch)          break       ; /* end of input */
2879           /* if it is a \ then everything allowed */
2880           if (ch == '\\') {
2881              *str++ = ch     ; /* backslash in place */
2882              *str++ = input()           ; /* following char in place */
2883              continue                   ;      /* carry on */
2884              }
2885
2886          /* if new line we have a new line break */
2887          if (ch == '\n') break          ;
2888
2889          /* if this is a quote then we have work to do */
2890          /* find the next non whitespace character     */
2891          /* if that is a double quote then carry on    */
2892          if (ch == '\"') {
2893
2894              while ((ch = input()) && isspace(ch)) ;
2895              if (!ch) break             ;
2896              if (ch != '\"') {
2897                   unput(ch)                     ;
2898                   break                 ;
2899                   }
2900
2901                   continue              ;
2902         }
2903         *str++  = ch;
2904      }
2905      *str++ = '\"'                      ;
2906      *str = '\0';
2907      return strLitBuff                  ;
2908 }
2909
2910 void doPragma (int op, char *cp)
2911 {
2912     switch (op) {
2913     case P_SAVE:
2914         memcpy(&save_options,&options,sizeof(options));
2915         memcpy(&save_optimize,&optimize,sizeof(optimize));
2916         break;
2917     case P_RESTORE:
2918         memcpy(&options,&save_options,sizeof(options));
2919         memcpy(&optimize,&save_optimize,sizeof(optimize));
2920         break;
2921     case P_NOINDUCTION:
2922         optimize.loopInduction = 0 ;
2923         break;
2924     case P_NOINVARIANT:
2925         optimize.loopInvariant = 0 ;
2926         break;
2927     case P_INDUCTION:
2928         optimize.loopInduction = 1 ;
2929         break;
2930     case P_STACKAUTO:
2931         options.stackAuto = 1;
2932         break;
2933     case P_NOJTBOUND:
2934         optimize.noJTabBoundary = 1;
2935         break;
2936     case P_NOGCSE:
2937         optimize.global_cse = 0;
2938         break;
2939     case P_NOOVERLAY:
2940         options.noOverlay = 1;
2941         break;
2942     case P_CALLEE_SAVES:
2943         {
2944             int i=0;
2945             /* append to the functions already listed
2946                in callee-saves */
2947             for (; options.calleeSaves[i] ;i++);
2948             parseWithComma(&options.calleeSaves[i],strdup(cp));
2949         }
2950         break;
2951     case P_EXCLUDE:
2952         parseWithComma(options.excludeRegs,strdup(cp));
2953         break;
2954     case P_LOOPREV:
2955         optimize.noLoopReverse = 1;
2956         break;
2957     }
2958 }
2959
2960 int process_pragma(char *s)
2961 {
2962     char *cp ;
2963     /* find the pragma */
2964     while (strncmp(s,"#pragma",7))
2965         s++;
2966     s += 7;
2967
2968     /* look for the directive */
2969     while(isspace(*s)) s++;
2970
2971     cp = s;
2972     /* look for the end of the directive */
2973     while ((! isspace(*s)) &&
2974            (*s != '\n'))
2975         s++ ;
2976
2977     /* now compare and do what needs to be done */
2978     if (strncmp(cp,PRAGMA_SAVE,strlen(PRAGMA_SAVE)) == 0) {
2979         doPragma(P_SAVE,cp+strlen(PRAGMA_SAVE));
2980         return 0;
2981     }
2982
2983     if (strncmp(cp,PRAGMA_RESTORE,strlen(PRAGMA_RESTORE)) == 0) {
2984         doPragma (P_RESTORE,cp+strlen(PRAGMA_RESTORE));
2985         return 0;
2986     }
2987
2988     if (strncmp(cp,PRAGMA_NOINDUCTION,strlen(PRAGMA_NOINDUCTION)) == 0) {
2989         doPragma (P_NOINDUCTION,cp+strlen(PRAGMA_NOINDUCTION))  ;
2990         return 0;
2991     }
2992
2993     if (strncmp(cp,PRAGMA_NOINVARIANT,strlen(PRAGMA_NOINVARIANT)) == 0) {
2994         doPragma (P_NOINVARIANT,NULL)   ;
2995         return 0;
2996     }
2997
2998     if (strncmp(cp,PRAGMA_INDUCTION,strlen(PRAGMA_INDUCTION)) == 0) {
2999         doPragma (P_INDUCTION,NULL)     ;
3000         return 0;
3001     }
3002
3003     if (strncmp(cp,PRAGMA_STACKAUTO,strlen(PRAGMA_STACKAUTO)) == 0) {
3004         doPragma (P_STACKAUTO,NULL);
3005         return 0;
3006     }
3007
3008     if (strncmp(cp,PRAGMA_NOJTBOUND,strlen(PRAGMA_NOJTBOUND)) == 0) {
3009         doPragma (P_NOJTBOUND,NULL);
3010         return 0;
3011     }
3012
3013     if (strncmp(cp,PRAGMA_NOGCSE,strlen(PRAGMA_NOGCSE)) == 0) {
3014         doPragma (P_NOGCSE,NULL);
3015         return 0;
3016     }
3017
3018     if (strncmp(cp,PRAGMA_NOOVERLAY,strlen(PRAGMA_NOOVERLAY)) == 0) {
3019         doPragma (P_NOOVERLAY,NULL);
3020         return 0;
3021     }
3022
3023     if (strncmp(cp,PRAGMA_CALLEESAVES,strlen(PRAGMA_CALLEESAVES)) == 0) {
3024         doPragma(P_CALLEE_SAVES,cp+strlen(PRAGMA_CALLEESAVES));
3025         return 0;
3026     }
3027
3028     if (strncmp(cp,PRAGMA_EXCLUDE,strlen(PRAGMA_EXCLUDE)) == 0) {
3029         doPragma(P_EXCLUDE,cp+strlen(PRAGMA_EXCLUDE));
3030         return 0;
3031     }
3032
3033     if (strncmp(cp,PRAGMA_NOLOOPREV,strlen(PRAGMA_NOLOOPREV)) == 0) {
3034         doPragma(P_EXCLUDE,NULL);
3035         return 0;
3036     }
3037
3038     werror(W_UNKNOWN_PRAGMA,cp);
3039     return 0;
3040 }