tools/llvm-upgrade/UpgradeLexer.cpp.cvs

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