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