lib/AsmParser/llvmAsmParser.cpp.cvs

   1 /* A Bison parser, made by GNU Bison 2.3.  */
   2
   3 /* Skeleton implementation for Bison's Yacc-like parsers in C
   4
   5    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   6    Free Software Foundation, Inc.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 /* As a special exception, you may create a larger work that contains
  24    part or all of the Bison parser skeleton and distribute that work
  25    under terms of your choice, so long as that work isn't itself a
  26    parser generator using the skeleton or a modified version thereof
  27    as a parser skeleton.  Alternatively, if you modify or redistribute
  28    the parser skeleton itself, you may (at your option) remove this
  29    special exception, which will cause the skeleton and the resulting
  30    Bison output files to be licensed under the GNU General Public
  31    License without this special exception.
  32
  33    This special exception was added by the Free Software Foundation in
  34    version 2.2 of Bison.  */
  35
  36 /* C LALR(1) parser skeleton written by Richard Stallman, by
  37    simplifying the original so-called "semantic" parser.  */
  38
  39 /* All symbols defined below should begin with yy or YY, to avoid
  40    infringing on user name space.  This should be done even for local
  41    variables, as they might otherwise be expanded by user macros.
  42    There are some unavoidable exceptions within include files to
  43    define necessary library symbols; they are noted "INFRINGES ON
  44    USER NAME SPACE" below.  */
  45
  46 /* Identify Bison output.  */
  47 #define YYBISON 1
  48
  49 /* Bison version.  */
  50 #define YYBISON_VERSION "2.3"
  51
  52 /* Skeleton name.  */
  53 #define YYSKELETON_NAME "yacc.c"
  54
  55 /* Pure parsers.  */
  56 #define YYPURE 0
  57
  58 /* Using locations.  */
  59 #define YYLSP_NEEDED 0
  60
  61 /* Substitute the variable and function names.  */
  62 #define yyparse llvmAsmparse
  63 #define yylex   llvmAsmlex
  64 #define yyerror llvmAsmerror
  65 #define yylval  llvmAsmlval
  66 #define yychar  llvmAsmchar
  67 #define yydebug llvmAsmdebug
  68 #define yynerrs llvmAsmnerrs
  69
  70
  71 /* Tokens.  */
  72 #ifndef YYTOKENTYPE
  73 # define YYTOKENTYPE
  74    /* Put the tokens into the symbol table, so that GDB and other debuggers
  75       know about them.  */
  76    enum yytokentype {
  77      ESINT64VAL = 258,
  78      EUINT64VAL = 259,
  79      ESAPINTVAL = 260,
  80      EUAPINTVAL = 261,
  81      LOCALVAL_ID = 262,
  82      GLOBALVAL_ID = 263,
  83      FPVAL = 264,
  84      VOID = 265,
  85      INTTYPE = 266,
  86      FLOAT = 267,
  87      DOUBLE = 268,
  88      X86_FP80 = 269,
  89      FP128 = 270,
  90      PPC_FP128 = 271,
  91      LABEL = 272,
  92      TYPE = 273,
  93      LOCALVAR = 274,
  94      GLOBALVAR = 275,
  95      LABELSTR = 276,
  96      STRINGCONSTANT = 277,
  97      ATSTRINGCONSTANT = 278,
  98      PCTSTRINGCONSTANT = 279,
  99      ZEROINITIALIZER = 280,
 100      TRUETOK = 281,
 101      FALSETOK = 282,
 102      BEGINTOK = 283,
 103      ENDTOK = 284,
 104      DECLARE = 285,
 105      DEFINE = 286,
 106      GLOBAL = 287,
 107      CONSTANT = 288,
 108      SECTION = 289,
 109      ALIAS = 290,
 110      VOLATILE = 291,
 111      THREAD_LOCAL = 292,
 112      TO = 293,
 113      DOTDOTDOT = 294,
 114      NULL_TOK = 295,
 115      UNDEF = 296,
 116      INTERNAL = 297,
 117      LINKONCE = 298,
 118      WEAK = 299,
 119      APPENDING = 300,
 120      DLLIMPORT = 301,
 121      DLLEXPORT = 302,
 122      EXTERN_WEAK = 303,
 123      COMMON = 304,
 124      OPAQUE = 305,
 125      EXTERNAL = 306,
 126      TARGET = 307,
 127      TRIPLE = 308,
 128      ALIGN = 309,
 129      ADDRSPACE = 310,
 130      DEPLIBS = 311,
 131      CALL = 312,
 132      TAIL = 313,
 133      ASM_TOK = 314,
 134      MODULE = 315,
 135      SIDEEFFECT = 316,
 136      CC_TOK = 317,
 137      CCC_TOK = 318,
 138      FASTCC_TOK = 319,
 139      COLDCC_TOK = 320,
 140      X86_STDCALLCC_TOK = 321,
 141      X86_FASTCALLCC_TOK = 322,
 142      DATALAYOUT = 323,
 143      RET = 324,
 144      BR = 325,
 145      SWITCH = 326,
 146      INVOKE = 327,
 147      UNWIND = 328,
 148      UNREACHABLE = 329,
 149      ADD = 330,
 150      SUB = 331,
 151      MUL = 332,
 152      UDIV = 333,
 153      SDIV = 334,
 154      FDIV = 335,
 155      UREM = 336,
 156      SREM = 337,
 157      FREM = 338,
 158      AND = 339,
 159      OR = 340,
 160      XOR = 341,
 161      SHL = 342,
 162      LSHR = 343,
 163      ASHR = 344,
 164      ICMP = 345,
 165      FCMP = 346,
 166      VICMP = 347,
 167      VFCMP = 348,
 168      EQ = 349,
 169      NE = 350,
 170      SLT = 351,
 171      SGT = 352,
 172      SLE = 353,
 173      SGE = 354,
 174      ULT = 355,
 175      UGT = 356,
 176      ULE = 357,
 177      UGE = 358,
 178      OEQ = 359,
 179      ONE = 360,
 180      OLT = 361,
 181      OGT = 362,
 182      OLE = 363,
 183      OGE = 364,
 184      ORD = 365,
 185      UNO = 366,
 186      UEQ = 367,
 187      UNE = 368,
 188      MALLOC = 369,
 189      ALLOCA = 370,
 190      FREE = 371,
 191      LOAD = 372,
 192      STORE = 373,
 193      GETELEMENTPTR = 374,
 194      TRUNC = 375,
 195      ZEXT = 376,
 196      SEXT = 377,
 197      FPTRUNC = 378,
 198      FPEXT = 379,
 199      BITCAST = 380,
 200      UITOFP = 381,
 201      SITOFP = 382,
 202      FPTOUI = 383,
 203      FPTOSI = 384,
 204      INTTOPTR = 385,
 205      PTRTOINT = 386,
 206      PHI_TOK = 387,
 207      SELECT = 388,
 208      VAARG = 389,
 209      EXTRACTELEMENT = 390,
 210      INSERTELEMENT = 391,
 211      SHUFFLEVECTOR = 392,
 212      GETRESULT = 393,
 213      EXTRACTVALUE = 394,
 214      INSERTVALUE = 395,
 215      SIGNEXT = 396,
 216      ZEROEXT = 397,
 217      NORETURN = 398,
 218      INREG = 399,
 219      SRET = 400,
 220      NOUNWIND = 401,
 221      NOALIAS = 402,
 222      BYVAL = 403,
 223      NEST = 404,
 224      READNONE = 405,
 225      READONLY = 406,
 226      GC = 407,
 227      OPTSIZE = 408,
 228      NOINLINE = 409,
 229      ALWAYSINLINE = 410,
 230      DEFAULT = 411,
 231      HIDDEN = 412,
 232      PROTECTED = 413
 233    };
 234 #endif
 235 /* Tokens.  */
 236 #define ESINT64VAL 258
 237 #define EUINT64VAL 259
 238 #define ESAPINTVAL 260
 239 #define EUAPINTVAL 261
 240 #define LOCALVAL_ID 262
 241 #define GLOBALVAL_ID 263
 242 #define FPVAL 264
 243 #define VOID 265
 244 #define INTTYPE 266
 245 #define FLOAT 267
 246 #define DOUBLE 268
 247 #define X86_FP80 269
 248 #define FP128 270
 249 #define PPC_FP128 271
 250 #define LABEL 272
 251 #define TYPE 273
 252 #define LOCALVAR 274
 253 #define GLOBALVAR 275
 254 #define LABELSTR 276
 255 #define STRINGCONSTANT 277
 256 #define ATSTRINGCONSTANT 278
 257 #define PCTSTRINGCONSTANT 279
 258 #define ZEROINITIALIZER 280
 259 #define TRUETOK 281
 260 #define FALSETOK 282
 261 #define BEGINTOK 283
 262 #define ENDTOK 284
 263 #define DECLARE 285
 264 #define DEFINE 286
 265 #define GLOBAL 287
 266 #define CONSTANT 288
 267 #define SECTION 289
 268 #define ALIAS 290
 269 #define VOLATILE 291
 270 #define THREAD_LOCAL 292
 271 #define TO 293
 272 #define DOTDOTDOT 294
 273 #define NULL_TOK 295
 274 #define UNDEF 296
 275 #define INTERNAL 297
 276 #define LINKONCE 298
 277 #define WEAK 299
 278 #define APPENDING 300
 279 #define DLLIMPORT 301
 280 #define DLLEXPORT 302
 281 #define EXTERN_WEAK 303
 282 #define COMMON 304
 283 #define OPAQUE 305
 284 #define EXTERNAL 306
 285 #define TARGET 307
 286 #define TRIPLE 308
 287 #define ALIGN 309
 288 #define ADDRSPACE 310
 289 #define DEPLIBS 311
 290 #define CALL 312
 291 #define TAIL 313
 292 #define ASM_TOK 314
 293 #define MODULE 315
 294 #define SIDEEFFECT 316
 295 #define CC_TOK 317
 296 #define CCC_TOK 318
 297 #define FASTCC_TOK 319
 298 #define COLDCC_TOK 320
 299 #define X86_STDCALLCC_TOK 321
 300 #define X86_FASTCALLCC_TOK 322
 301 #define DATALAYOUT 323
 302 #define RET 324
 303 #define BR 325
 304 #define SWITCH 326
 305 #define INVOKE 327
 306 #define UNWIND 328
 307 #define UNREACHABLE 329
 308 #define ADD 330
 309 #define SUB 331
 310 #define MUL 332
 311 #define UDIV 333
 312 #define SDIV 334
 313 #define FDIV 335
 314 #define UREM 336
 315 #define SREM 337
 316 #define FREM 338
 317 #define AND 339
 318 #define OR 340
 319 #define XOR 341
 320 #define SHL 342
 321 #define LSHR 343
 322 #define ASHR 344
 323 #define ICMP 345
 324 #define FCMP 346
 325 #define VICMP 347
 326 #define VFCMP 348
 327 #define EQ 349
 328 #define NE 350
 329 #define SLT 351
 330 #define SGT 352
 331 #define SLE 353
 332 #define SGE 354
 333 #define ULT 355
 334 #define UGT 356
 335 #define ULE 357
 336 #define UGE 358
 337 #define OEQ 359
 338 #define ONE 360
 339 #define OLT 361
 340 #define OGT 362
 341 #define OLE 363
 342 #define OGE 364
 343 #define ORD 365
 344 #define UNO 366
 345 #define UEQ 367
 346 #define UNE 368
 347 #define MALLOC 369
 348 #define ALLOCA 370
 349 #define FREE 371
 350 #define LOAD 372
 351 #define STORE 373
 352 #define GETELEMENTPTR 374
 353 #define TRUNC 375
 354 #define ZEXT 376
 355 #define SEXT 377
 356 #define FPTRUNC 378
 357 #define FPEXT 379
 358 #define BITCAST 380
 359 #define UITOFP 381
 360 #define SITOFP 382
 361 #define FPTOUI 383
 362 #define FPTOSI 384
 363 #define INTTOPTR 385
 364 #define PTRTOINT 386
 365 #define PHI_TOK 387
 366 #define SELECT 388
 367 #define VAARG 389
 368 #define EXTRACTELEMENT 390
 369 #define INSERTELEMENT 391
 370 #define SHUFFLEVECTOR 392
 371 #define GETRESULT 393
 372 #define EXTRACTVALUE 394
 373 #define INSERTVALUE 395
 374 #define SIGNEXT 396
 375 #define ZEROEXT 397
 376 #define NORETURN 398
 377 #define INREG 399
 378 #define SRET 400
 379 #define NOUNWIND 401
 380 #define NOALIAS 402
 381 #define BYVAL 403
 382 #define NEST 404
 383 #define READNONE 405
 384 #define READONLY 406
 385 #define GC 407
 386 #define OPTSIZE 408
 387 #define NOINLINE 409
 388 #define ALWAYSINLINE 410
 389 #define DEFAULT 411
 390 #define HIDDEN 412
 391 #define PROTECTED 413
 392
 393
 394
 395
 396 /* Copy the first part of user declarations.  */
 397 #line 14 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
 398
 399 #include "ParserInternals.h"
 400 #include "llvm/CallingConv.h"
 401 #include "llvm/InlineAsm.h"
 402 #include "llvm/Instructions.h"
 403 #include "llvm/Module.h"
 404 #include "llvm/ValueSymbolTable.h"
 405 #include "llvm/AutoUpgrade.h"
 406 #include "llvm/Support/GetElementPtrTypeIterator.h"
 407 #include "llvm/Support/CommandLine.h"
 408 #include "llvm/ADT/SmallVector.h"
 409 #include "llvm/ADT/STLExtras.h"
 410 #include "llvm/Support/MathExtras.h"
 411 #include "llvm/Support/Streams.h"
 412 #include <algorithm>
 413 #include <list>
 414 #include <map>
 415 #include <utility>
 416
 417 // The following is a gross hack. In order to rid the libAsmParser library of
 418 // exceptions, we have to have a way of getting the yyparse function to go into
 419 // an error situation. So, whenever we want an error to occur, the GenerateError
 420 // function (see bottom of file) sets TriggerError. Then, at the end of each
 421 // production in the grammer we use CHECK_FOR_ERROR which will invoke YYERROR
 422 // (a goto) to put YACC in error state. Furthermore, several calls to
 423 // GenerateError are made from inside productions and they must simulate the
 424 // previous exception behavior by exiting the production immediately. We have
 425 // replaced these with the GEN_ERROR macro which calls GeneratError and then
 426 // immediately invokes YYERROR. This would be so much cleaner if it was a
 427 // recursive descent parser.
 428 static bool TriggerError = false;
 429 #define CHECK_FOR_ERROR { if (TriggerError) { TriggerError = false; YYABORT; } }
 430 #define GEN_ERROR(msg) { GenerateError(msg); YYERROR; }
 431
 432 int yyerror(const char *ErrorMsg); // Forward declarations to prevent "implicit
 433 int yylex();                       // declaration" of xxx warnings.
 434 int yyparse();
 435 using namespace llvm;
 436
 437 static Module *ParserResult;
 438
 439 // DEBUG_UPREFS - Define this symbol if you want to enable debugging output
 440 // relating to upreferences in the input stream.
 441 //
 442 //#define DEBUG_UPREFS 1
 443 #ifdef DEBUG_UPREFS
 444 #define UR_OUT(X) cerr << X
 445 #else
 446 #define UR_OUT(X)
 447 #endif
 448
 449 #define YYERROR_VERBOSE 1
 450
 451 static GlobalVariable *CurGV;
 452
 453
 454 // This contains info used when building the body of a function.  It is
 455 // destroyed when the function is completed.
 456 //
 457 typedef std::vector<Value *> ValueList;           // Numbered defs
 458
 459 static void
 460 ResolveDefinitions(ValueList &LateResolvers, ValueList *FutureLateResolvers=0);
 461
 462 static struct PerModuleInfo {
 463   Module *CurrentModule;
 464   ValueList Values; // Module level numbered definitions
 465   ValueList LateResolveValues;
 466   std::vector<PATypeHolder>    Types;
 467   std::map<ValID, PATypeHolder> LateResolveTypes;
 468
 469   /// PlaceHolderInfo - When temporary placeholder objects are created, remember
 470   /// how they were referenced and on which line of the input they came from so
 471   /// that we can resolve them later and print error messages as appropriate.
 472   std::map<Value*, std::pair<ValID, int> > PlaceHolderInfo;
 473
 474   // GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward
 475   // references to global values.  Global values may be referenced before they
 476   // are defined, and if so, the temporary object that they represent is held
 477   // here.  This is used for forward references of GlobalValues.
 478   //
 479   typedef std::map<std::pair<const PointerType *,
 480                              ValID>, GlobalValue*> GlobalRefsType;
 481   GlobalRefsType GlobalRefs;
 482
 483   void ModuleDone() {
 484     // If we could not resolve some functions at function compilation time
 485     // (calls to functions before they are defined), resolve them now...  Types
 486     // are resolved when the constant pool has been completely parsed.
 487     //
 488     ResolveDefinitions(LateResolveValues);
 489     if (TriggerError)
 490       return;
 491
 492     // Check to make sure that all global value forward references have been
 493     // resolved!
 494     //
 495     if (!GlobalRefs.empty()) {
 496       std::string UndefinedReferences = "Unresolved global references exist:\n";
 497
 498       for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end();
 499            I != E; ++I) {
 500         UndefinedReferences += "  " + I->first.first->getDescription() + " " +
 501                                I->first.second.getName() + "\n";
 502       }
 503       GenerateError(UndefinedReferences);
 504       return;
 505     }
 506
 507     // Look for intrinsic functions and CallInst that need to be upgraded
 508     for (Module::iterator FI = CurrentModule->begin(),
 509          FE = CurrentModule->end(); FI != FE; )
 510       UpgradeCallsToIntrinsic(FI++); // must be post-increment, as we remove
 511
 512     Values.clear();         // Clear out function local definitions
 513     Types.clear();
 514     CurrentModule = 0;
 515   }
 516
 517   // GetForwardRefForGlobal - Check to see if there is a forward reference
 518   // for this global.  If so, remove it from the GlobalRefs map and return it.
 519   // If not, just return null.
 520   GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) {
 521     // Check to see if there is a forward reference to this global variable...
 522     // if there is, eliminate it and patch the reference to use the new def'n.
 523     GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID));
 524     GlobalValue *Ret = 0;
 525     if (I != GlobalRefs.end()) {
 526       Ret = I->second;
 527       GlobalRefs.erase(I);
 528     }
 529     return Ret;
 530   }
 531
 532   bool TypeIsUnresolved(PATypeHolder* PATy) {
 533     // If it isn't abstract, its resolved
 534     const Type* Ty = PATy->get();
 535     if (!Ty->isAbstract())
 536       return false;
 537     // Traverse the type looking for abstract types. If it isn't abstract then
 538     // we don't need to traverse that leg of the type.
 539     std::vector<const Type*> WorkList, SeenList;
 540     WorkList.push_back(Ty);
 541     while (!WorkList.empty()) {
 542       const Type* Ty = WorkList.back();
 543       SeenList.push_back(Ty);
 544       WorkList.pop_back();
 545       if (const OpaqueType* OpTy = dyn_cast<OpaqueType>(Ty)) {
 546         // Check to see if this is an unresolved type
 547         std::map<ValID, PATypeHolder>::iterator I = LateResolveTypes.begin();
 548         std::map<ValID, PATypeHolder>::iterator E = LateResolveTypes.end();
 549         for ( ; I != E; ++I) {
 550           if (I->second.get() == OpTy)
 551             return true;
 552         }
 553       } else if (const SequentialType* SeqTy = dyn_cast<SequentialType>(Ty)) {
 554         const Type* TheTy = SeqTy->getElementType();
 555         if (TheTy->isAbstract() && TheTy != Ty) {
 556           std::vector<const Type*>::iterator I = SeenList.begin(),
 557                                              E = SeenList.end();
 558           for ( ; I != E; ++I)
 559             if (*I == TheTy)
 560               break;
 561           if (I == E)
 562             WorkList.push_back(TheTy);
 563         }
 564       } else if (const StructType* StrTy = dyn_cast<StructType>(Ty)) {
 565         for (unsigned i = 0; i < StrTy->getNumElements(); ++i) {
 566           const Type* TheTy = StrTy->getElementType(i);
 567           if (TheTy->isAbstract() && TheTy != Ty) {
 568             std::vector<const Type*>::iterator I = SeenList.begin(),
 569                                                E = SeenList.end();
 570             for ( ; I != E; ++I)
 571               if (*I == TheTy)
 572                 break;
 573             if (I == E)
 574               WorkList.push_back(TheTy);
 575           }
 576         }
 577       }
 578     }
 579     return false;
 580   }
 581 } CurModule;
 582
 583 static struct PerFunctionInfo {
 584   Function *CurrentFunction;     // Pointer to current function being created
 585
 586   ValueList Values; // Keep track of #'d definitions
 587   unsigned NextValNum;
 588   ValueList LateResolveValues;
 589   bool isDeclare;                   // Is this function a forward declararation?
 590   GlobalValue::LinkageTypes Linkage; // Linkage for forward declaration.
 591   GlobalValue::VisibilityTypes Visibility;
 592
 593   /// BBForwardRefs - When we see forward references to basic blocks, keep
 594   /// track of them here.
 595   std::map<ValID, BasicBlock*> BBForwardRefs;
 596
 597   inline PerFunctionInfo() {
 598     CurrentFunction = 0;
 599     isDeclare = false;
 600     Linkage = GlobalValue::ExternalLinkage;
 601     Visibility = GlobalValue::DefaultVisibility;
 602   }
 603
 604   inline void FunctionStart(Function *M) {
 605     CurrentFunction = M;
 606     NextValNum = 0;
 607   }
 608
 609   void FunctionDone() {
 610     // Any forward referenced blocks left?
 611     if (!BBForwardRefs.empty()) {
 612       GenerateError("Undefined reference to label " +
 613                      BBForwardRefs.begin()->second->getName());
 614       return;
 615     }
 616
 617     // Resolve all forward references now.
 618     ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
 619
 620     Values.clear();         // Clear out function local definitions
 621     BBForwardRefs.clear();
 622     CurrentFunction = 0;
 623     isDeclare = false;
 624     Linkage = GlobalValue::ExternalLinkage;
 625     Visibility = GlobalValue::DefaultVisibility;
 626   }
 627 } CurFun;  // Info for the current function...
 628
 629 static bool inFunctionScope() { return CurFun.CurrentFunction != 0; }
 630
 631
 632 //===----------------------------------------------------------------------===//
 633 //               Code to handle definitions of all the types
 634 //===----------------------------------------------------------------------===//
 635
 636 /// InsertValue - Insert a value into the value table.  If it is named, this
 637 /// returns -1, otherwise it returns the slot number for the value.
 638 static int InsertValue(Value *V, ValueList &ValueTab = CurFun.Values) {
 639   // Things that have names or are void typed don't get slot numbers
 640   if (V->hasName() || (V->getType() == Type::VoidTy))
 641     return -1;
 642
 643   // In the case of function values, we have to allow for the forward reference
 644   // of basic blocks, which are included in the numbering. Consequently, we keep
 645   // track of the next insertion location with NextValNum. When a BB gets
 646   // inserted, it could change the size of the CurFun.Values vector.
 647   if (&ValueTab == &CurFun.Values) {
 648     if (ValueTab.size() <= CurFun.NextValNum)
 649       ValueTab.resize(CurFun.NextValNum+1);
 650     ValueTab[CurFun.NextValNum++] = V;
 651     return CurFun.NextValNum-1;
 652   }
 653   // For all other lists, its okay to just tack it on the back of the vector.
 654   ValueTab.push_back(V);
 655   return ValueTab.size()-1;
 656 }
 657
 658 static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
 659   switch (D.Type) {
 660   case ValID::LocalID:               // Is it a numbered definition?
 661     // Module constants occupy the lowest numbered slots...
 662     if (D.Num < CurModule.Types.size())
 663       return CurModule.Types[D.Num];
 664     break;
 665   case ValID::LocalName:                 // Is it a named definition?
 666     if (const Type *N = CurModule.CurrentModule->getTypeByName(D.getName())) {
 667       D.destroy();  // Free old strdup'd memory...
 668       return N;
 669     }
 670     break;
 671   default:
 672     GenerateError("Internal parser error: Invalid symbol type reference");
 673     return 0;
 674   }
 675
 676   // If we reached here, we referenced either a symbol that we don't know about
 677   // or an id number that hasn't been read yet.  We may be referencing something
 678   // forward, so just create an entry to be resolved later and get to it...
 679   //
 680   if (DoNotImprovise) return 0;  // Do we just want a null to be returned?
 681
 682
 683   if (inFunctionScope()) {
 684     if (D.Type == ValID::LocalName) {
 685       GenerateError("Reference to an undefined type: '" + D.getName() + "'");
 686       return 0;
 687     } else {
 688       GenerateError("Reference to an undefined type: #" + utostr(D.Num));
 689       return 0;
 690     }
 691   }
 692
 693   std::map<ValID, PATypeHolder>::iterator I =CurModule.LateResolveTypes.find(D);
 694   if (I != CurModule.LateResolveTypes.end())
 695     return I->second;
 696
 697   Type *Typ = OpaqueType::get();
 698   CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
 699   return Typ;
 700  }
 701
 702 // getExistingVal - Look up the value specified by the provided type and
 703 // the provided ValID.  If the value exists and has already been defined, return
 704 // it.  Otherwise return null.
 705 //
 706 static Value *getExistingVal(const Type *Ty, const ValID &D) {
 707   if (isa<FunctionType>(Ty)) {
 708     GenerateError("Functions are not values and "
 709                    "must be referenced as pointers");
 710     return 0;
 711   }
 712
 713   switch (D.Type) {
 714   case ValID::LocalID: {                 // Is it a numbered definition?
 715     // Check that the number is within bounds.
 716     if (D.Num >= CurFun.Values.size())
 717       return 0;
 718     Value *Result = CurFun.Values[D.Num];
 719     if (Ty != Result->getType()) {
 720       GenerateError("Numbered value (%" + utostr(D.Num) + ") of type '" +
 721                     Result->getType()->getDescription() + "' does not match "
 722                     "expected type, '" + Ty->getDescription() + "'");
 723       return 0;
 724     }
 725     return Result;
 726   }
 727   case ValID::GlobalID: {                 // Is it a numbered definition?
 728     if (D.Num >= CurModule.Values.size())
 729       return 0;
 730     Value *Result = CurModule.Values[D.Num];
 731     if (Ty != Result->getType()) {
 732       GenerateError("Numbered value (@" + utostr(D.Num) + ") of type '" +
 733                     Result->getType()->getDescription() + "' does not match "
 734                     "expected type, '" + Ty->getDescription() + "'");
 735       return 0;
 736     }
 737     return Result;
 738   }
 739
 740   case ValID::LocalName: {                // Is it a named definition?
 741     if (!inFunctionScope())
 742       return 0;
 743     ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
 744     Value *N = SymTab.lookup(D.getName());
 745     if (N == 0)
 746       return 0;
 747     if (N->getType() != Ty)
 748       return 0;
 749
 750     D.destroy();  // Free old strdup'd memory...
 751     return N;
 752   }
 753   case ValID::GlobalName: {                // Is it a named definition?
 754     ValueSymbolTable &SymTab = CurModule.CurrentModule->getValueSymbolTable();
 755     Value *N = SymTab.lookup(D.getName());
 756     if (N == 0)
 757       return 0;
 758     if (N->getType() != Ty)
 759       return 0;
 760
 761     D.destroy();  // Free old strdup'd memory...
 762     return N;
 763   }
 764
 765   // Check to make sure that "Ty" is an integral type, and that our
 766   // value will fit into the specified type...
 767   case ValID::ConstSIntVal:    // Is it a constant pool reference??
 768     if (!isa<IntegerType>(Ty) ||
 769         !ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
 770       GenerateError("Signed integral constant '" +
 771                      itostr(D.ConstPool64) + "' is invalid for type '" +
 772                      Ty->getDescription() + "'");
 773       return 0;
 774     }
 775     return ConstantInt::get(Ty, D.ConstPool64, true);
 776
 777   case ValID::ConstUIntVal:     // Is it an unsigned const pool reference?
 778     if (isa<IntegerType>(Ty) &&
 779         ConstantInt::isValueValidForType(Ty, D.UConstPool64))
 780       return ConstantInt::get(Ty, D.UConstPool64);
 781
 782     if (!isa<IntegerType>(Ty) ||
 783         !ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
 784       GenerateError("Integral constant '" + utostr(D.UConstPool64) +
 785                     "' is invalid or out of range for type '" +
 786                     Ty->getDescription() + "'");
 787       return 0;
 788     }
 789     // This is really a signed reference.  Transmogrify.
 790     return ConstantInt::get(Ty, D.ConstPool64, true);
 791
 792   case ValID::ConstAPInt:     // Is it an unsigned const pool reference?
 793     if (!isa<IntegerType>(Ty)) {
 794       GenerateError("Integral constant '" + D.getName() +
 795                     "' is invalid or out of range for type '" +
 796                     Ty->getDescription() + "'");
 797       return 0;
 798     }
 799
 800     {
 801       APSInt Tmp = *D.ConstPoolInt;
 802       Tmp.extOrTrunc(Ty->getPrimitiveSizeInBits());
 803       return ConstantInt::get(Tmp);
 804     }
 805
 806   case ValID::ConstFPVal:        // Is it a floating point const pool reference?
 807     if (!Ty->isFloatingPoint() ||
 808         !ConstantFP::isValueValidForType(Ty, *D.ConstPoolFP)) {
 809       GenerateError("FP constant invalid for type");
 810       return 0;
 811     }
 812     // Lexer has no type info, so builds all float and double FP constants
 813     // as double.  Fix this here.  Long double does not need this.
 814     if (&D.ConstPoolFP->getSemantics() == &APFloat::IEEEdouble &&
 815         Ty==Type::FloatTy) {
 816       bool ignored;
 817       D.ConstPoolFP->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven,
 818                              &ignored);
 819     }
 820     return ConstantFP::get(*D.ConstPoolFP);
 821
 822   case ValID::ConstNullVal:      // Is it a null value?
 823     if (!isa<PointerType>(Ty)) {
 824       GenerateError("Cannot create a a non pointer null");
 825       return 0;
 826     }
 827     return ConstantPointerNull::get(cast<PointerType>(Ty));
 828
 829   case ValID::ConstUndefVal:      // Is it an undef value?
 830     return UndefValue::get(Ty);
 831
 832   case ValID::ConstZeroVal:      // Is it a zero value?
 833     return Constant::getNullValue(Ty);
 834
 835   case ValID::ConstantVal:       // Fully resolved constant?
 836     if (D.ConstantValue->getType() != Ty) {
 837       GenerateError("Constant expression type different from required type");
 838       return 0;
 839     }
 840     return D.ConstantValue;
 841
 842   case ValID::InlineAsmVal: {    // Inline asm expression
 843     const PointerType *PTy = dyn_cast<PointerType>(Ty);
 844     const FunctionType *FTy =
 845       PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
 846     if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints)) {
 847       GenerateError("Invalid type for asm constraint string");
 848       return 0;
 849     }
 850     InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
 851                                    D.IAD->HasSideEffects);
 852     D.destroy();   // Free InlineAsmDescriptor.
 853     return IA;
 854   }
 855   default:
 856     assert(0 && "Unhandled case!");
 857     return 0;
 858   }   // End of switch
 859
 860   assert(0 && "Unhandled case!");
 861   return 0;
 862 }
 863
 864 // getVal - This function is identical to getExistingVal, except that if a
 865 // value is not already defined, it "improvises" by creating a placeholder var
 866 // that looks and acts just like the requested variable.  When the value is
 867 // defined later, all uses of the placeholder variable are replaced with the
 868 // real thing.
 869 //
 870 static Value *getVal(const Type *Ty, const ValID &ID) {
 871   if (Ty == Type::LabelTy) {
 872     GenerateError("Cannot use a basic block here");
 873     return 0;
 874   }
 875
 876   // See if the value has already been defined.
 877   Value *V = getExistingVal(Ty, ID);
 878   if (V) return V;
 879   if (TriggerError) return 0;
 880
 881   if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty)) {
 882     GenerateError("Invalid use of a non-first-class type");
 883     return 0;
 884   }
 885
 886   // If we reached here, we referenced either a symbol that we don't know about
 887   // or an id number that hasn't been read yet.  We may be referencing something
 888   // forward, so just create an entry to be resolved later and get to it...
 889   //
 890   switch (ID.Type) {
 891   case ValID::GlobalName:
 892   case ValID::GlobalID: {
 893    const PointerType *PTy = dyn_cast<PointerType>(Ty);
 894    if (!PTy) {
 895      GenerateError("Invalid type for reference to global" );
 896      return 0;
 897    }
 898    const Type* ElTy = PTy->getElementType();
 899    if (const FunctionType *FTy = dyn_cast<FunctionType>(ElTy))
 900      V = Function::Create(FTy, GlobalValue::ExternalLinkage);
 901    else
 902      V = new GlobalVariable(ElTy, false, GlobalValue::ExternalLinkage, 0, "",
 903                             (Module*)0, false, PTy->getAddressSpace());
 904    break;
 905   }
 906   default:
 907    V = new Argument(Ty);
 908   }
 909
 910   // Remember where this forward reference came from.  FIXME, shouldn't we try
 911   // to recycle these things??
 912   CurModule.PlaceHolderInfo.insert(std::make_pair(V, std::make_pair(ID,
 913                                                               LLLgetLineNo())));
 914
 915   if (inFunctionScope())
 916     InsertValue(V, CurFun.LateResolveValues);
 917   else
 918     InsertValue(V, CurModule.LateResolveValues);
 919   return V;
 920 }
 921
 922 /// defineBBVal - This is a definition of a new basic block with the specified
 923 /// identifier which must be the same as CurFun.NextValNum, if its numeric.
 924 static BasicBlock *defineBBVal(const ValID &ID) {
 925   assert(inFunctionScope() && "Can't get basic block at global scope!");
 926
 927   BasicBlock *BB = 0;
 928
 929   // First, see if this was forward referenced
 930
 931   std::map<ValID, BasicBlock*>::iterator BBI = CurFun.BBForwardRefs.find(ID);
 932   if (BBI != CurFun.BBForwardRefs.end()) {
 933     BB = BBI->second;
 934     // The forward declaration could have been inserted anywhere in the
 935     // function: insert it into the correct place now.
 936     CurFun.CurrentFunction->getBasicBlockList().remove(BB);
 937     CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
 938
 939     // We're about to erase the entry, save the key so we can clean it up.
 940     ValID Tmp = BBI->first;
 941
 942     // Erase the forward ref from the map as its no longer "forward"
 943     CurFun.BBForwardRefs.erase(ID);
 944
 945     // The key has been removed from the map but so we don't want to leave
 946     // strdup'd memory around so destroy it too.
 947     Tmp.destroy();
 948
 949     // If its a numbered definition, bump the number and set the BB value.
 950     if (ID.Type == ValID::LocalID) {
 951       assert(ID.Num == CurFun.NextValNum && "Invalid new block number");
 952       InsertValue(BB);
 953     }
 954   } else {
 955     // We haven't seen this BB before and its first mention is a definition.
 956     // Just create it and return it.
 957     std::string Name (ID.Type == ValID::LocalName ? ID.getName() : "");
 958     BB = BasicBlock::Create(Name, CurFun.CurrentFunction);
 959     if (ID.Type == ValID::LocalID) {
 960       assert(ID.Num == CurFun.NextValNum && "Invalid new block number");
 961       InsertValue(BB);
 962     }
 963   }
 964
 965   ID.destroy();
 966   return BB;
 967 }
 968
 969 /// getBBVal - get an existing BB value or create a forward reference for it.
 970 ///
 971 static BasicBlock *getBBVal(const ValID &ID) {
 972   assert(inFunctionScope() && "Can't get basic block at global scope!");
 973
 974   BasicBlock *BB =  0;
 975
 976   std::map<ValID, BasicBlock*>::iterator BBI = CurFun.BBForwardRefs.find(ID);
 977   if (BBI != CurFun.BBForwardRefs.end()) {
 978     BB = BBI->second;
 979   } if (ID.Type == ValID::LocalName) {
 980     std::string Name = ID.getName();
 981     Value *N = CurFun.CurrentFunction->getValueSymbolTable().lookup(Name);
 982     if (N) {
 983       if (N->getType()->getTypeID() == Type::LabelTyID)
 984         BB = cast<BasicBlock>(N);
 985       else
 986         GenerateError("Reference to label '" + Name + "' is actually of type '"+
 987           N->getType()->getDescription() + "'");
 988     }
 989   } else if (ID.Type == ValID::LocalID) {
 990     if (ID.Num < CurFun.NextValNum && ID.Num < CurFun.Values.size()) {
 991       if (CurFun.Values[ID.Num]->getType()->getTypeID() == Type::LabelTyID)
 992         BB = cast<BasicBlock>(CurFun.Values[ID.Num]);
 993       else
 994         GenerateError("Reference to label '%" + utostr(ID.Num) +
 995           "' is actually of type '"+
 996           CurFun.Values[ID.Num]->getType()->getDescription() + "'");
 997     }
 998   } else {
 999     GenerateError("Illegal label reference " + ID.getName());
1000     return 0;
1001   }
1002
1003   // If its already been defined, return it now.
1004   if (BB) {
1005     ID.destroy(); // Free strdup'd memory.
1006     return BB;
1007   }
1008
1009   // Otherwise, this block has not been seen before, create it.
1010   std::string Name;
1011   if (ID.Type == ValID::LocalName)
1012     Name = ID.getName();
1013   BB = BasicBlock::Create(Name, CurFun.CurrentFunction);
1014
1015   // Insert it in the forward refs map.
1016   CurFun.BBForwardRefs[ID] = BB;
1017
1018   return BB;
1019 }
1020
1021
1022 //===----------------------------------------------------------------------===//
1023 //              Code to handle forward references in instructions
1024 //===----------------------------------------------------------------------===//
1025 //
1026 // This code handles the late binding needed with statements that reference
1027 // values not defined yet... for example, a forward branch, or the PHI node for
1028 // a loop body.
1029 //
1030 // This keeps a table (CurFun.LateResolveValues) of all such forward references
1031 // and back patchs after we are done.
1032 //
1033
1034 // ResolveDefinitions - If we could not resolve some defs at parsing
1035 // time (forward branches, phi functions for loops, etc...) resolve the
1036 // defs now...
1037 //
1038 static void
1039 ResolveDefinitions(ValueList &LateResolvers, ValueList *FutureLateResolvers) {
1040   // Loop over LateResolveDefs fixing up stuff that couldn't be resolved
1041   while (!LateResolvers.empty()) {
1042     Value *V = LateResolvers.back();
1043     LateResolvers.pop_back();
1044
1045     std::map<Value*, std::pair<ValID, int> >::iterator PHI =
1046       CurModule.PlaceHolderInfo.find(V);
1047     assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error!");
1048
1049     ValID &DID = PHI->second.first;
1050
1051     Value *TheRealValue = getExistingVal(V->getType(), DID);
1052     if (TriggerError)
1053       return;
1054     if (TheRealValue) {
1055       V->replaceAllUsesWith(TheRealValue);
1056       delete V;
1057       CurModule.PlaceHolderInfo.erase(PHI);
1058     } else if (FutureLateResolvers) {
1059       // Functions have their unresolved items forwarded to the module late
1060       // resolver table
1061       InsertValue(V, *FutureLateResolvers);
1062     } else {
1063       if (DID.Type == ValID::LocalName || DID.Type == ValID::GlobalName) {
1064         GenerateError("Reference to an invalid definition: '" +DID.getName()+
1065                        "' of type '" + V->getType()->getDescription() + "'",
1066                        PHI->second.second);
1067         return;
1068       } else {
1069         GenerateError("Reference to an invalid definition: #" +
1070                        itostr(DID.Num) + " of type '" +
1071                        V->getType()->getDescription() + "'",
1072                        PHI->second.second);
1073         return;
1074       }
1075     }
1076   }
1077   LateResolvers.clear();
1078 }
1079
1080 // ResolveTypeTo - A brand new type was just declared.  This means that (if
1081 // name is not null) things referencing Name can be resolved.  Otherwise, things
1082 // refering to the number can be resolved.  Do this now.
1083 //
1084 static void ResolveTypeTo(std::string *Name, const Type *ToTy) {
1085   ValID D;
1086   if (Name)
1087     D = ValID::createLocalName(*Name);
1088   else
1089     D = ValID::createLocalID(CurModule.Types.size());
1090
1091   std::map<ValID, PATypeHolder>::iterator I =
1092     CurModule.LateResolveTypes.find(D);
1093   if (I != CurModule.LateResolveTypes.end()) {
1094     ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy);
1095     I->first.destroy();
1096     CurModule.LateResolveTypes.erase(I);
1097   }
1098   D.destroy();
1099 }
1100
1101 // setValueName - Set the specified value to the name given.  The name may be
1102 // null potentially, in which case this is a noop.  The string passed in is
1103 // assumed to be a malloc'd string buffer, and is free'd by this function.
1104 //
1105 static void setValueName(Value *V, std::string *NameStr) {
1106   if (!NameStr) return;
1107   std::string Name(*NameStr);      // Copy string
1108   delete NameStr;                  // Free old string
1109
1110   if (V->getType() == Type::VoidTy) {
1111     GenerateError("Can't assign name '" + Name+"' to value with void type");
1112     return;
1113   }
1114
1115   assert(inFunctionScope() && "Must be in function scope!");
1116   ValueSymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
1117   if (ST.lookup(Name)) {
1118     GenerateError("Redefinition of value '" + Name + "' of type '" +
1119                    V->getType()->getDescription() + "'");
1120     return;
1121   }
1122
1123   // Set the name.
1124   V->setName(Name);
1125 }
1126
1127 /// ParseGlobalVariable - Handle parsing of a global.  If Initializer is null,
1128 /// this is a declaration, otherwise it is a definition.
1129 static GlobalVariable *
1130 ParseGlobalVariable(std::string *NameStr,
1131                     GlobalValue::LinkageTypes Linkage,
1132                     GlobalValue::VisibilityTypes Visibility,
1133                     bool isConstantGlobal, const Type *Ty,
1134                     Constant *Initializer, bool IsThreadLocal,
1135                     unsigned AddressSpace = 0) {
1136   if (isa<FunctionType>(Ty)) {
1137     GenerateError("Cannot declare global vars of function type");
1138     return 0;
1139   }
1140   if (Ty == Type::LabelTy) {
1141     GenerateError("Cannot declare global vars of label type");
1142     return 0;
1143   }
1144
1145   const PointerType *PTy = PointerType::get(Ty, AddressSpace);
1146
1147   std::string Name;
1148   if (NameStr) {
1149     Name = *NameStr;      // Copy string
1150     delete NameStr;       // Free old string
1151   }
1152
1153   // See if this global value was forward referenced.  If so, recycle the
1154   // object.
1155   ValID ID;
1156   if (!Name.empty()) {
1157     ID = ValID::createGlobalName(Name);
1158   } else {
1159     ID = ValID::createGlobalID(CurModule.Values.size());
1160   }
1161
1162   if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
1163     // Move the global to the end of the list, from whereever it was
1164     // previously inserted.
1165     GlobalVariable *GV = cast<GlobalVariable>(FWGV);
1166     CurModule.CurrentModule->getGlobalList().remove(GV);
1167     CurModule.CurrentModule->getGlobalList().push_back(GV);
1168     GV->setInitializer(Initializer);
1169     GV->setLinkage(Linkage);
1170     GV->setVisibility(Visibility);
1171     GV->setConstant(isConstantGlobal);
1172     GV->setThreadLocal(IsThreadLocal);
1173     InsertValue(GV, CurModule.Values);
1174     ID.destroy();
1175     return GV;
1176   }
1177
1178   ID.destroy();
1179
1180   // If this global has a name
1181   if (!Name.empty()) {
1182     // if the global we're parsing has an initializer (is a definition) and
1183     // has external linkage.
1184     if (Initializer && Linkage != GlobalValue::InternalLinkage)
1185       // If there is already a global with external linkage with this name
1186       if (CurModule.CurrentModule->getGlobalVariable(Name, false)) {
1187         // If we allow this GVar to get created, it will be renamed in the
1188         // symbol table because it conflicts with an existing GVar. We can't
1189         // allow redefinition of GVars whose linking indicates that their name
1190         // must stay the same. Issue the error.
1191         GenerateError("Redefinition of global variable named '" + Name +
1192                        "' of type '" + Ty->getDescription() + "'");
1193         return 0;
1194       }
1195   }
1196
1197   // Otherwise there is no existing GV to use, create one now.
1198   GlobalVariable *GV =
1199     new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
1200                        CurModule.CurrentModule, IsThreadLocal, AddressSpace);
1201   GV->setVisibility(Visibility);
1202   InsertValue(GV, CurModule.Values);
1203   return GV;
1204 }
1205
1206 // setTypeName - Set the specified type to the name given.  The name may be
1207 // null potentially, in which case this is a noop.  The string passed in is
1208 // assumed to be a malloc'd string buffer, and is freed by this function.
1209 //
1210 // This function returns true if the type has already been defined, but is
1211 // allowed to be redefined in the specified context.  If the name is a new name
1212 // for the type plane, it is inserted and false is returned.
1213 static bool setTypeName(const Type *T, std::string *NameStr) {
1214   assert(!inFunctionScope() && "Can't give types function-local names!");
1215   if (NameStr == 0) return false;
1216
1217   std::string Name(*NameStr);      // Copy string
1218   delete NameStr;                  // Free old string
1219
1220   // We don't allow assigning names to void type
1221   if (T == Type::VoidTy) {
1222     GenerateError("Can't assign name '" + Name + "' to the void type");
1223     return false;
1224   }
1225
1226   // Set the type name, checking for conflicts as we do so.
1227   bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T);
1228
1229   if (AlreadyExists) {   // Inserting a name that is already defined???
1230     const Type *Existing = CurModule.CurrentModule->getTypeByName(Name);
1231     assert(Existing && "Conflict but no matching type?!");
1232
1233     // There is only one case where this is allowed: when we are refining an
1234     // opaque type.  In this case, Existing will be an opaque type.
1235     if (const OpaqueType *OpTy = dyn_cast<OpaqueType>(Existing)) {
1236       // We ARE replacing an opaque type!
1237       const_cast<OpaqueType*>(OpTy)->refineAbstractTypeTo(T);
1238       return true;
1239     }
1240
1241     // Otherwise, this is an attempt to redefine a type. That's okay if
1242     // the redefinition is identical to the original. This will be so if
1243     // Existing and T point to the same Type object. In this one case we
1244     // allow the equivalent redefinition.
1245     if (Existing == T) return true;  // Yes, it's equal.
1246
1247     // Any other kind of (non-equivalent) redefinition is an error.
1248     GenerateError("Redefinition of type named '" + Name + "' of type '" +
1249                    T->getDescription() + "'");
1250   }
1251
1252   return false;
1253 }
1254
1255 //===----------------------------------------------------------------------===//
1256 // Code for handling upreferences in type names...
1257 //
1258
1259 // TypeContains - Returns true if Ty directly contains E in it.
1260 //
1261 static bool TypeContains(const Type *Ty, const Type *E) {
1262   return std::find(Ty->subtype_begin(), Ty->subtype_end(),
1263                    E) != Ty->subtype_end();
1264 }
1265
1266 namespace {
1267   struct UpRefRecord {
1268     // NestingLevel - The number of nesting levels that need to be popped before
1269     // this type is resolved.
1270     unsigned NestingLevel;
1271
1272     // LastContainedTy - This is the type at the current binding level for the
1273     // type.  Every time we reduce the nesting level, this gets updated.
1274     const Type *LastContainedTy;
1275
1276     // UpRefTy - This is the actual opaque type that the upreference is
1277     // represented with.
1278     OpaqueType *UpRefTy;
1279
1280     UpRefRecord(unsigned NL, OpaqueType *URTy)
1281       : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {}
1282   };
1283 }
1284
1285 // UpRefs - A list of the outstanding upreferences that need to be resolved.
1286 static std::vector<UpRefRecord> UpRefs;
1287
1288 /// HandleUpRefs - Every time we finish a new layer of types, this function is
1289 /// called.  It loops through the UpRefs vector, which is a list of the
1290 /// currently active types.  For each type, if the up reference is contained in
1291 /// the newly completed type, we decrement the level count.  When the level
1292 /// count reaches zero, the upreferenced type is the type that is passed in:
1293 /// thus we can complete the cycle.
1294 ///
1295 static PATypeHolder HandleUpRefs(const Type *ty) {
1296   // If Ty isn't abstract, or if there are no up-references in it, then there is
1297   // nothing to resolve here.
1298   if (!ty->isAbstract() || UpRefs.empty()) return ty;
1299
1300   PATypeHolder Ty(ty);
1301   UR_OUT("Type '" << Ty->getDescription() <<
1302          "' newly formed.  Resolving upreferences.\n" <<
1303          UpRefs.size() << " upreferences active!\n");
1304
1305   // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
1306   // to zero), we resolve them all together before we resolve them to Ty.  At
1307   // the end of the loop, if there is anything to resolve to Ty, it will be in
1308   // this variable.
1309   OpaqueType *TypeToResolve = 0;
1310
1311   for (unsigned i = 0; i != UpRefs.size(); ++i) {
1312     UR_OUT("  UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
1313            << UpRefs[i].second->getDescription() << ") = "
1314            << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n");
1315     if (TypeContains(Ty, UpRefs[i].LastContainedTy)) {
1316       // Decrement level of upreference
1317       unsigned Level = --UpRefs[i].NestingLevel;
1318       UpRefs[i].LastContainedTy = Ty;
1319       UR_OUT("  Uplevel Ref Level = " << Level << "\n");
1320       if (Level == 0) {                     // Upreference should be resolved!
1321         if (!TypeToResolve) {
1322           TypeToResolve = UpRefs[i].UpRefTy;
1323         } else {
1324           UR_OUT("  * Resolving upreference for "
1325                  << UpRefs[i].second->getDescription() << "\n";
1326                  std::string OldName = UpRefs[i].UpRefTy->getDescription());
1327           UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
1328           UR_OUT("  * Type '" << OldName << "' refined upreference to: "
1329                  << (const void*)Ty << ", " << Ty->getDescription() << "\n");
1330         }
1331         UpRefs.erase(UpRefs.begin()+i);     // Remove from upreference list...
1332         --i;                                // Do not skip the next element...
1333       }
1334     }
1335   }
1336
1337   if (TypeToResolve) {
1338     UR_OUT("  * Resolving upreference for "
1339            << UpRefs[i].second->getDescription() << "\n";
1340            std::string OldName = TypeToResolve->getDescription());
1341     TypeToResolve->refineAbstractTypeTo(Ty);
1342   }
1343
1344   return Ty;
1345 }
1346
1347 //===----------------------------------------------------------------------===//
1348 //            RunVMAsmParser - Define an interface to this parser
1349 //===----------------------------------------------------------------------===//
1350 //
1351 static Module* RunParser(Module * M);
1352
1353 Module *llvm::RunVMAsmParser(llvm::MemoryBuffer *MB) {
1354   InitLLLexer(MB);
1355   Module *M = RunParser(new Module(LLLgetFilename()));
1356   FreeLexer();
1357   return M;
1358 }
1359
1360
1361
1362 /* Enabling traces.  */
1363 #ifndef YYDEBUG
1364 # define YYDEBUG 0
1365 #endif
1366
1367 /* Enabling verbose error messages.  */
1368 #ifdef YYERROR_VERBOSE
1369 # undef YYERROR_VERBOSE
1370 # define YYERROR_VERBOSE 1
1371 #else
1372 # define YYERROR_VERBOSE 0
1373 #endif
1374
1375 /* Enabling the token table.  */
1376 #ifndef YYTOKEN_TABLE
1377 # define YYTOKEN_TABLE 0
1378 #endif
1379
1380 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1381 typedef union YYSTYPE
1382 #line 978 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
1383 {
1384   llvm::Module                           *ModuleVal;
1385   llvm::Function                         *FunctionVal;
1386   llvm::BasicBlock                       *BasicBlockVal;
1387   llvm::TerminatorInst                   *TermInstVal;
1388   llvm::Instruction                      *InstVal;
1389   llvm::Constant                         *ConstVal;
1390
1391   const llvm::Type                       *PrimType;
1392   std::list<llvm::PATypeHolder>          *TypeList;
1393   llvm::PATypeHolder                     *TypeVal;
1394   llvm::Value                            *ValueVal;
1395   std::vector<llvm::Value*>              *ValueList;
1396   std::vector<unsigned>                  *ConstantList;
1397   llvm::ArgListType                      *ArgList;
1398   llvm::TypeWithAttrs                     TypeWithAttrs;
1399   llvm::TypeWithAttrsList                *TypeWithAttrsList;
1400   llvm::ParamList                        *ParamList;
1401
1402   // Represent the RHS of PHI node
1403   std::list<std::pair<llvm::Value*,
1404                       llvm::BasicBlock*> > *PHIList;
1405   std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable;
1406   std::vector<llvm::Constant*>           *ConstVector;
1407
1408   llvm::GlobalValue::LinkageTypes         Linkage;
1409   llvm::GlobalValue::VisibilityTypes      Visibility;
1410   llvm::Attributes                  Attributes;
1411   llvm::APInt                       *APIntVal;
1412   int64_t                           SInt64Val;
1413   uint64_t                          UInt64Val;
1414   int                               SIntVal;
1415   unsigned                          UIntVal;
1416   llvm::APFloat                    *FPVal;
1417   bool                              BoolVal;
1418
1419   std::string                      *StrVal;   // This memory must be deleted
1420   llvm::ValID                       ValIDVal;
1421
1422   llvm::Instruction::BinaryOps      BinaryOpVal;
1423   llvm::Instruction::TermOps        TermOpVal;
1424   llvm::Instruction::MemoryOps      MemOpVal;
1425   llvm::Instruction::CastOps        CastOpVal;
1426   llvm::Instruction::OtherOps       OtherOpVal;
1427   llvm::ICmpInst::Predicate         IPredicate;
1428   llvm::FCmpInst::Predicate         FPredicate;
1429 }
1430 /* Line 187 of yacc.c.  */
1431 #line 1432 "llvmAsmParser.tab.c"
1432         YYSTYPE;
1433 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1434 # define YYSTYPE_IS_DECLARED 1
1435 # define YYSTYPE_IS_TRIVIAL 1
1436 #endif
1437
1438
1439
1440 /* Copy the second part of user declarations.  */
1441
1442
1443 /* Line 216 of yacc.c.  */
1444 #line 1445 "llvmAsmParser.tab.c"
1445
1446 #ifdef short
1447 # undef short
1448 #endif
1449
1450 #ifdef YYTYPE_UINT8
1451 typedef YYTYPE_UINT8 yytype_uint8;
1452 #else
1453 typedef unsigned char yytype_uint8;
1454 #endif
1455
1456 #ifdef YYTYPE_INT8
1457 typedef YYTYPE_INT8 yytype_int8;
1458 #elif (defined __STDC__ || defined __C99__FUNC__ \
1459      || defined __cplusplus || defined _MSC_VER)
1460 typedef signed char yytype_int8;
1461 #else
1462 typedef short int yytype_int8;
1463 #endif
1464
1465 #ifdef YYTYPE_UINT16
1466 typedef YYTYPE_UINT16 yytype_uint16;
1467 #else
1468 typedef unsigned short int yytype_uint16;
1469 #endif
1470
1471 #ifdef YYTYPE_INT16
1472 typedef YYTYPE_INT16 yytype_int16;
1473 #else
1474 typedef short int yytype_int16;
1475 #endif
1476
1477 #ifndef YYSIZE_T
1478 # ifdef __SIZE_TYPE__
1479 #  define YYSIZE_T __SIZE_TYPE__
1480 # elif defined size_t
1481 #  define YYSIZE_T size_t
1482 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
1483      || defined __cplusplus || defined _MSC_VER)
1484 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
1485 #  define YYSIZE_T size_t
1486 # else
1487 #  define YYSIZE_T unsigned int
1488 # endif
1489 #endif
1490
1491 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
1492
1493 #ifndef YY_
1494 # if YYENABLE_NLS
1495 #  if ENABLE_NLS
1496 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
1497 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
1498 #  endif
1499 # endif
1500 # ifndef YY_
1501 #  define YY_(msgid) msgid
1502 # endif
1503 #endif
1504
1505 /* Suppress unused-variable warnings by "using" E.  */
1506 #if ! defined lint || defined __GNUC__
1507 # define YYUSE(e) ((void) (e))
1508 #else
1509 # define YYUSE(e) /* empty */
1510 #endif
1511
1512 /* Identity function, used to suppress warnings about constant conditions.  */
1513 #ifndef lint
1514 # define YYID(n) (n)
1515 #else
1516 #if (defined __STDC__ || defined __C99__FUNC__ \
1517      || defined __cplusplus || defined _MSC_VER)
1518 static int
1519 YYID (int i)
1520 #else
1521 static int
1522 YYID (i)
1523     int i;
1524 #endif
1525 {
1526   return i;
1527 }
1528 #endif
1529
1530 #if ! defined yyoverflow || YYERROR_VERBOSE
1531
1532 /* The parser invokes alloca or malloc; define the necessary symbols.  */
1533
1534 # ifdef YYSTACK_USE_ALLOCA
1535 #  if YYSTACK_USE_ALLOCA
1536 #   ifdef __GNUC__
1537 #    define YYSTACK_ALLOC __builtin_alloca
1538 #   elif defined __BUILTIN_VA_ARG_INCR
1539 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
1540 #   elif defined _AIX
1541 #    define YYSTACK_ALLOC __alloca
1542 #   elif defined _MSC_VER
1543 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
1544 #    define alloca _alloca
1545 #   else
1546 #    define YYSTACK_ALLOC alloca
1547 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1548      || defined __cplusplus || defined _MSC_VER)
1549 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1550 #     ifndef _STDLIB_H
1551 #      define _STDLIB_H 1
1552 #     endif
1553 #    endif
1554 #   endif
1555 #  endif
1556 # endif
1557
1558 # ifdef YYSTACK_ALLOC
1559    /* Pacify GCC's `empty if-body' warning.  */
1560 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
1561 #  ifndef YYSTACK_ALLOC_MAXIMUM
1562     /* The OS might guarantee only one guard page at the bottom of the stack,
1563        and a page size can be as small as 4096 bytes.  So we cannot safely
1564        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
1565        to allow for a few compiler-allocated temporary stack slots.  */
1566 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1567 #  endif
1568 # else
1569 #  define YYSTACK_ALLOC YYMALLOC
1570 #  define YYSTACK_FREE YYFREE
1571 #  ifndef YYSTACK_ALLOC_MAXIMUM
1572 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1573 #  endif
1574 #  if (defined __cplusplus && ! defined _STDLIB_H \
1575        && ! ((defined YYMALLOC || defined malloc) \
1576              && (defined YYFREE || defined free)))
1577 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1578 #   ifndef _STDLIB_H
1579 #    define _STDLIB_H 1
1580 #   endif
1581 #  endif
1582 #  ifndef YYMALLOC
1583 #   define YYMALLOC malloc
1584 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1585      || defined __cplusplus || defined _MSC_VER)
1586 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1587 #   endif
1588 #  endif
1589 #  ifndef YYFREE
1590 #   define YYFREE free
1591 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1592      || defined __cplusplus || defined _MSC_VER)
1593 void free (void *); /* INFRINGES ON USER NAME SPACE */
1594 #   endif
1595 #  endif
1596 # endif
1597 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1598
1599
1600 #if (! defined yyoverflow \
1601      && (! defined __cplusplus \
1602          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1603
1604 /* A type that is properly aligned for any stack member.  */
1605 union yyalloc
1606 {
1607   yytype_int16 yyss;
1608   YYSTYPE yyvs;
1609   };
1610
1611 /* The size of the maximum gap between one aligned stack and the next.  */
1612 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1613
1614 /* The size of an array large to enough to hold all stacks, each with
1615    N elements.  */
1616 # define YYSTACK_BYTES(N) \
1617      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1618       + YYSTACK_GAP_MAXIMUM)
1619
1620 /* Copy COUNT objects from FROM to TO.  The source and destination do
1621    not overlap.  */
1622 # ifndef YYCOPY
1623 #  if defined __GNUC__ && 1 < __GNUC__
1624 #   define YYCOPY(To, From, Count) \
1625       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1626 #  else
1627 #   define YYCOPY(To, From, Count)              \
1628       do                                        \
1629         {                                       \
1630           YYSIZE_T yyi;                         \
1631           for (yyi = 0; yyi < (Count); yyi++)   \
1632             (To)[yyi] = (From)[yyi];            \
1633         }                                       \
1634       while (YYID (0))
1635 #  endif
1636 # endif
1637
1638 /* Relocate STACK from its old location to the new one.  The
1639    local variables YYSIZE and YYSTACKSIZE give the old and new number of
1640    elements in the stack, and YYPTR gives the new location of the
1641    stack.  Advance YYPTR to a properly aligned location for the next
1642    stack.  */
1643 # define YYSTACK_RELOCATE(Stack)                                        \
1644     do                                                                  \
1645       {                                                                 \
1646         YYSIZE_T yynewbytes;                                            \
1647         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
1648         Stack = &yyptr->Stack;                                          \
1649         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1650         yyptr += yynewbytes / sizeof (*yyptr);                          \
1651       }                                                                 \
1652     while (YYID (0))
1653
1654 #endif
1655
1656 /* YYFINAL -- State number of the termination state.  */
1657 #define YYFINAL  44
1658 /* YYLAST -- Last index in YYTABLE.  */
1659 #define YYLAST   2377
1660
1661 /* YYNTOKENS -- Number of terminals.  */
1662 #define YYNTOKENS  173
1663 /* YYNNTS -- Number of nonterminals.  */
1664 #define YYNNTS  87
1665 /* YYNRULES -- Number of rules.  */
1666 #define YYNRULES  348
1667 /* YYNRULES -- Number of states.  */
1668 #define YYNSTATES  708
1669
1670 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
1671 #define YYUNDEFTOK  2
1672 #define YYMAXUTOK   413
1673
1674 #define YYTRANSLATE(YYX)                                                \
1675   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1676
1677 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
1678 static const yytype_uint8 yytranslate[] =
1679 {
1680        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1681        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1682        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1683        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1684      159,   160,   163,     2,   162,     2,     2,     2,     2,     2,
1685        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1686      168,   161,   169,     2,     2,     2,     2,     2,     2,     2,
1687        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1688        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1689        2,   165,   164,   167,     2,     2,     2,     2,     2,   172,
1690        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1691        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1692      166,     2,     2,   170,     2,   171,     2,     2,     2,     2,
1693        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1694        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1695        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1696        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1697        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1698        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1699        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1700        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1701        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1702        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1703        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1704        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1705        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
1706        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
1707       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
1708       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
1709       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
1710       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
1711       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
1712       65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
1713       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
1714       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
1715       95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
1716      105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
1717      115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
1718      125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
1719      135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
1720      145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
1721      155,   156,   157,   158
1722 };
1723
1724 #if YYDEBUG
1725 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1726    YYRHS.  */
1727 static const yytype_uint16 yyprhs[] =
1728 {
1729        0,     0,     3,     5,     7,     9,    11,    13,    15,    17,
1730       19,    21,    23,    25,    27,    29,    31,    33,    35,    37,
1731       39,    41,    43,    45,    47,    49,    51,    53,    55,    57,
1732       59,    61,    63,    65,    67,    69,    71,    73,    75,    77,
1733       79,    81,    83,    85,    87,    89,    91,    93,    95,    97,
1734       99,   101,   103,   105,   107,   109,   111,   113,   115,   117,
1735      118,   123,   124,   127,   128,   131,   133,   135,   137,   138,
1736      141,   143,   145,   147,   149,   151,   153,   155,   157,   159,
1737      160,   162,   164,   166,   167,   169,   171,   172,   174,   176,
1738      178,   180,   181,   183,   185,   186,   188,   190,   192,   194,
1739      196,   199,   201,   203,   205,   207,   209,   211,   213,   215,
1740      217,   220,   221,   224,   226,   228,   230,   231,   234,   236,
1741      238,   240,   242,   244,   246,   248,   250,   252,   254,   255,
1742      258,   259,   262,   263,   266,   267,   271,   274,   275,   277,
1743      278,   282,   284,   287,   289,   291,   293,   295,   297,   299,
1744      301,   303,   305,   309,   311,   314,   320,   326,   332,   338,
1745      342,   345,   351,   356,   359,   361,   363,   365,   369,   371,
1746      375,   377,   378,   380,   384,   389,   393,   397,   402,   407,
1747      411,   418,   424,   427,   430,   433,   436,   439,   442,   445,
1748      448,   451,   454,   457,   460,   467,   473,   482,   489,   496,
1749      504,   512,   520,   528,   535,   544,   553,   559,   567,   571,
1750      573,   575,   577,   579,   580,   583,   590,   592,   593,   595,
1751      598,   599,   603,   604,   608,   612,   616,   620,   621,   630,
1752      631,   641,   642,   652,   658,   661,   665,   667,   671,   675,
1753      679,   683,   685,   686,   692,   696,   698,   702,   704,   705,
1754      717,   719,   721,   726,   728,   730,   733,   737,   738,   740,
1755      742,   744,   746,   748,   750,   752,   754,   756,   758,   760,
1756      764,   768,   771,   774,   778,   781,   787,   792,   794,   800,
1757      802,   804,   806,   808,   810,   812,   815,   817,   821,   824,
1758      827,   831,   835,   838,   839,   841,   844,   847,   851,   861,
1759      871,   880,   896,   898,   900,   907,   913,   916,   919,   926,
1760      934,   939,   944,   951,   958,   959,   960,   964,   967,   971,
1761      974,   976,   982,   988,   995,  1002,  1009,  1016,  1021,  1028,
1762     1033,  1038,  1045,  1052,  1055,  1065,  1067,  1069,  1070,  1074,
1763     1081,  1085,  1092,  1095,  1101,  1109,  1115,  1120,  1125
1764 };
1765
1766 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
1767 static const yytype_int16 yyrhs[] =
1768 {
1769      220,     0,    -1,    75,    -1,    76,    -1,    77,    -1,    78,
1770       -1,    79,    -1,    80,    -1,    81,    -1,    82,    -1,    83,
1771       -1,    87,    -1,    88,    -1,    89,    -1,    84,    -1,    85,
1772       -1,    86,    -1,   120,    -1,   121,    -1,   122,    -1,   123,
1773       -1,   124,    -1,   125,    -1,   126,    -1,   127,    -1,   128,
1774       -1,   129,    -1,   130,    -1,   131,    -1,    94,    -1,    95,
1775       -1,    96,    -1,    97,    -1,    98,    -1,    99,    -1,   100,
1776       -1,   101,    -1,   102,    -1,   103,    -1,   104,    -1,   105,
1777       -1,   106,    -1,   107,    -1,   108,    -1,   109,    -1,   110,
1778       -1,   111,    -1,   112,    -1,   113,    -1,   100,    -1,   101,
1779       -1,   102,    -1,   103,    -1,    26,    -1,    27,    -1,    19,
1780       -1,    22,    -1,    24,    -1,   179,    -1,    -1,    55,   159,
1781        4,   160,    -1,    -1,   179,   161,    -1,    -1,     7,   161,
1782       -1,    20,    -1,    23,    -1,   186,    -1,    -1,   184,   161,
1783       -1,    42,    -1,    44,    -1,    43,    -1,    45,    -1,    47,
1784       -1,    49,    -1,    46,    -1,    48,    -1,    51,    -1,    -1,
1785      156,    -1,   157,    -1,   158,    -1,    -1,    46,    -1,    48,
1786       -1,    -1,    42,    -1,    43,    -1,    44,    -1,    47,    -1,
1787       -1,    44,    -1,    42,    -1,    -1,    63,    -1,    64,    -1,
1788       65,    -1,    66,    -1,    67,    -1,    62,     4,    -1,   142,
1789       -1,   121,    -1,   141,    -1,   122,    -1,   144,    -1,   145,
1790       -1,   147,    -1,   148,    -1,   149,    -1,    54,     4,    -1,
1791       -1,   195,   194,    -1,   144,    -1,   142,    -1,   141,    -1,
1792       -1,   197,   196,    -1,   143,    -1,   146,    -1,   144,    -1,
1793      142,    -1,   141,    -1,   150,    -1,   151,    -1,   154,    -1,
1794      155,    -1,   153,    -1,    -1,   199,   198,    -1,    -1,   152,
1795       22,    -1,    -1,    54,     4,    -1,    -1,   162,    54,     4,
1796       -1,    34,    22,    -1,    -1,   203,    -1,    -1,   162,   206,
1797      205,    -1,   203,    -1,    54,     4,    -1,    11,    -1,    12,
1798       -1,    13,    -1,    16,    -1,    15,    -1,    14,    -1,    17,
1799       -1,    50,    -1,   207,    -1,   208,   181,   163,    -1,   242,
1800       -1,   164,     4,    -1,   208,   159,   212,   160,   199,    -1,
1801       10,   159,   212,   160,   199,    -1,   165,     4,   166,   208,
1802      167,    -1,   168,     4,   166,   208,   169,    -1,   170,   213,
1803      171,    -1,   170,   171,    -1,   168,   170,   213,   171,   169,
1804       -1,   168,   170,   171,   169,    -1,   208,   195,    -1,   208,
1805       -1,    10,    -1,   209,    -1,   211,   162,   209,    -1,   211,
1806       -1,   211,   162,    39,    -1,    39,    -1,    -1,   208,    -1,
1807      213,   162,   208,    -1,   208,   165,   216,   167,    -1,   208,
1808      165,   167,    -1,   208,   172,    22,    -1,   208,   168,   216,
1809      169,    -1,   208,   170,   216,   171,    -1,   208,   170,   171,
1810       -1,   208,   168,   170,   216,   171,   169,    -1,   208,   168,
1811      170,   171,   169,    -1,   208,    40,    -1,   208,    41,    -1,
1812      208,   242,    -1,   208,   215,    -1,   208,    25,    -1,   208,
1813        3,    -1,   208,     5,    -1,   208,     4,    -1,   208,     6,
1814       -1,   208,    26,    -1,   208,    27,    -1,   208,     9,    -1,
1815      176,   159,   214,    38,   208,   160,    -1,   119,   159,   214,
1816      254,   160,    -1,   133,   159,   214,   162,   214,   162,   214,
1817      160,    -1,   174,   159,   214,   162,   214,   160,    -1,   175,
1818      159,   214,   162,   214,   160,    -1,    90,   177,   159,   214,
1819      162,   214,   160,    -1,    91,   178,   159,   214,   162,   214,
1820      160,    -1,    92,   177,   159,   214,   162,   214,   160,    -1,
1821       93,   178,   159,   214,   162,   214,   160,    -1,   135,   159,
1822      214,   162,   214,   160,    -1,   136,   159,   214,   162,   214,
1823      162,   214,   160,    -1,   137,   159,   214,   162,   214,   162,
1824      214,   160,    -1,   139,   159,   214,   255,   160,    -1,   140,
1825      159,   214,   162,   214,   255,   160,    -1,   216,   162,   214,
1826       -1,   214,    -1,    32,    -1,    33,    -1,    37,    -1,    -1,
1827      210,   242,    -1,   125,   159,   219,    38,   208,   160,    -1,
1828      221,    -1,    -1,   222,    -1,   221,   222,    -1,    -1,    31,
1829      223,   238,    -1,    -1,    30,   224,   239,    -1,    60,    59,
1830      228,    -1,   182,    18,   208,    -1,   182,    18,    10,    -1,
1831       -1,   185,   189,   218,   217,   214,   181,   225,   205,    -1,
1832       -1,   185,   187,   189,   218,   217,   214,   181,   226,   205,
1833       -1,    -1,   185,   188,   189,   218,   217,   208,   181,   227,
1834      205,    -1,   185,   189,    35,   192,   219,    -1,    52,   229,
1835       -1,    56,   161,   230,    -1,    22,    -1,    53,   161,    22,
1836       -1,    68,   161,    22,    -1,   165,   231,   167,    -1,   231,
1837      162,    22,    -1,    22,    -1,    -1,   232,   162,   208,   195,
1838      180,    -1,   208,   195,   180,    -1,   232,    -1,   232,   162,
1839       39,    -1,    39,    -1,    -1,   193,   197,   210,   184,   159,
1840      233,   160,   199,   204,   201,   200,    -1,    28,    -1,   170,
1841       -1,   191,   189,   234,   235,    -1,    29,    -1,   171,    -1,
1842      246,   237,    -1,   190,   189,   234,    -1,    -1,    61,    -1,
1843        3,    -1,     4,    -1,     5,    -1,     6,    -1,     9,    -1,
1844       26,    -1,    27,    -1,    40,    -1,    41,    -1,    25,    -1,
1845      168,   216,   169,    -1,   165,   216,   167,    -1,   165,   167,
1846       -1,   172,    22,    -1,   170,   216,   171,    -1,   170,   171,
1847       -1,   168,   170,   216,   171,   169,    -1,   168,   170,   171,
1848      169,    -1,   215,    -1,    59,   240,    22,   162,    22,    -1,
1849        7,    -1,     8,    -1,   179,    -1,   184,    -1,   242,    -1,
1850      241,    -1,   208,   243,    -1,   244,    -1,   245,   162,   244,
1851       -1,   246,   247,    -1,   236,   247,    -1,   248,   182,   249,
1852       -1,   248,   183,   249,    -1,   248,   251,    -1,    -1,    21,
1853       -1,    69,   245,    -1,    69,    10,    -1,    70,    17,   243,
1854       -1,    70,    11,   243,   162,    17,   243,   162,    17,   243,
1855       -1,    71,    11,   243,   162,    17,   243,   165,   250,   167,
1856       -1,    71,    11,   243,   162,    17,   243,   165,   167,    -1,
1857       72,   193,   197,   210,   243,   159,   253,   160,   199,    38,
1858       17,   243,    73,    17,   243,    -1,    73,    -1,    74,    -1,
1859      250,    11,   241,   162,    17,   243,    -1,    11,   241,   162,
1860       17,   243,    -1,   182,   257,    -1,   183,   257,    -1,   208,
1861      165,   243,   162,   243,   167,    -1,   252,   162,   165,   243,
1862      162,   243,   167,    -1,   208,   195,   243,   195,    -1,    17,
1863      195,   243,   195,    -1,   253,   162,   208,   195,   243,   195,
1864       -1,   253,   162,    17,   195,   243,   195,    -1,    -1,    -1,
1865      254,   162,   244,    -1,   162,     4,    -1,   255,   162,     4,
1866       -1,    58,    57,    -1,    57,    -1,   174,   208,   243,   162,
1867      243,    -1,   175,   208,   243,   162,   243,    -1,    90,   177,
1868      208,   243,   162,   243,    -1,    91,   178,   208,   243,   162,
1869      243,    -1,    92,   177,   208,   243,   162,   243,    -1,    93,
1870      178,   208,   243,   162,   243,    -1,   176,   244,    38,   208,
1871       -1,   133,   244,   162,   244,   162,   244,    -1,   134,   244,
1872      162,   208,    -1,   135,   244,   162,   244,    -1,   136,   244,
1873      162,   244,   162,   244,    -1,   137,   244,   162,   244,   162,
1874      244,    -1,   132,   252,    -1,   256,   193,   197,   210,   243,
1875      159,   253,   160,   199,    -1,   259,    -1,    36,    -1,    -1,
1876      114,   208,   202,    -1,   114,   208,   162,    11,   243,   202,
1877       -1,   115,   208,   202,    -1,   115,   208,   162,    11,   243,
1878      202,    -1,   116,   244,    -1,   258,   117,   208,   243,   202,
1879       -1,   258,   118,   244,   162,   208,   243,   202,    -1,   138,
1880      208,   243,   162,     4,    -1,   119,   208,   243,   254,    -1,
1881      139,   208,   243,   255,    -1,   140,   208,   243,   162,   208,
1882      243,   255,    -1
1883 };
1884
1885 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
1886 static const yytype_uint16 yyrline[] =
1887 {
1888        0,  1144,  1144,  1144,  1144,  1144,  1144,  1144,  1144,  1144,
1889     1144,  1145,  1145,  1145,  1145,  1145,  1145,  1146,  1146,  1146,
1890     1146,  1146,  1146,  1147,  1147,  1147,  1147,  1147,  1147,  1150,
1891     1150,  1151,  1151,  1152,  1152,  1153,  1153,  1154,  1154,  1158,
1892     1158,  1159,  1159,  1160,  1160,  1161,  1161,  1162,  1162,  1163,
1893     1163,  1164,  1164,  1165,  1166,  1169,  1169,  1169,  1170,  1170,
1894     1172,  1173,  1177,  1181,  1186,  1192,  1192,  1194,  1195,  1200,
1895     1206,  1207,  1208,  1209,  1210,  1211,  1215,  1216,  1217,  1221,
1896     1222,  1223,  1224,  1228,  1229,  1230,  1234,  1235,  1236,  1237,
1897     1238,  1242,  1243,  1244,  1247,  1248,  1249,  1250,  1251,  1252,
1898     1253,  1260,  1261,  1262,  1263,  1264,  1265,  1266,  1267,  1268,
1899     1269,  1273,  1274,  1279,  1280,  1281,  1284,  1285,  1291,  1292,
1900     1293,  1294,  1295,  1296,  1297,  1298,  1299,  1300,  1303,  1304,
1901     1310,  1311,  1318,  1319,  1325,  1326,  1335,  1343,  1344,  1349,
1902     1350,  1351,  1356,  1369,  1369,  1369,  1369,  1369,  1369,  1369,
1903     1372,  1376,  1380,  1387,  1392,  1400,  1435,  1466,  1471,  1481,
1904     1491,  1495,  1505,  1512,  1521,  1528,  1533,  1538,  1545,  1546,
1905     1553,  1560,  1568,  1574,  1586,  1614,  1630,  1657,  1685,  1711,
1906     1731,  1757,  1777,  1789,  1796,  1862,  1872,  1882,  1893,  1906,
1907     1917,  1931,  1938,  1945,  1963,  1975,  1996,  2004,  2010,  2021,
1908     2026,  2031,  2036,  2041,  2047,  2053,  2059,  2067,  2078,  2082,
1909     2090,  2090,  2093,  2093,  2096,  2108,  2129,  2134,  2142,  2143,
1910     2147,  2147,  2151,  2151,  2154,  2157,  2181,  2193,  2192,  2204,
1911     2203,  2213,  2212,  2223,  2263,  2266,  2272,  2282,  2286,  2291,
1912     2293,  2298,  2303,  2312,  2322,  2333,  2337,  2346,  2355,  2360,
1913     2509,  2509,  2511,  2520,  2520,  2522,  2527,  2539,  2543,  2548,
1914     2552,  2556,  2561,  2566,  2570,  2574,  2578,  2582,  2586,  2590,
1915     2612,  2634,  2640,  2653,  2665,  2670,  2682,  2688,  2692,  2702,
1916     2706,  2710,  2715,  2722,  2722,  2728,  2737,  2742,  2747,  2751,
1917     2760,  2769,  2782,  2791,  2795,  2803,  2823,  2827,  2832,  2843,
1918     2862,  2871,  2975,  2979,  2986,  2997,  3010,  3019,  3032,  3043,
1919     3053,  3064,  3072,  3082,  3089,  3092,  3093,  3101,  3107,  3116,
1920     3120,  3125,  3141,  3158,  3170,  3182,  3196,  3210,  3222,  3243,
1921     3250,  3256,  3262,  3268,  3283,  3393,  3398,  3402,  3409,  3416,
1922     3426,  3433,  3443,  3451,  3465,  3482,  3496,  3511,  3526
1923 };
1924 #endif
1925
1926 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1927 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1928    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
1929 static const char *const yytname[] =
1930 {
1931   "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "ESAPINTVAL",
1932   "EUAPINTVAL", "LOCALVAL_ID", "GLOBALVAL_ID", "FPVAL", "VOID", "INTTYPE",
1933   "FLOAT", "DOUBLE", "X86_FP80", "FP128", "PPC_FP128", "LABEL", "TYPE",
1934   "LOCALVAR", "GLOBALVAR", "LABELSTR", "STRINGCONSTANT",
1935   "ATSTRINGCONSTANT", "PCTSTRINGCONSTANT", "ZEROINITIALIZER", "TRUETOK",
1936   "FALSETOK", "BEGINTOK", "ENDTOK", "DECLARE", "DEFINE", "GLOBAL",
1937   "CONSTANT", "SECTION", "ALIAS", "VOLATILE", "THREAD_LOCAL", "TO",
1938   "DOTDOTDOT", "NULL_TOK", "UNDEF", "INTERNAL", "LINKONCE", "WEAK",
1939   "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "COMMON", "OPAQUE",
1940   "EXTERNAL", "TARGET", "TRIPLE", "ALIGN", "ADDRSPACE", "DEPLIBS", "CALL",
1941   "TAIL", "ASM_TOK", "MODULE", "SIDEEFFECT", "CC_TOK", "CCC_TOK",
1942   "FASTCC_TOK", "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK",
1943   "DATALAYOUT", "RET", "BR", "SWITCH", "INVOKE", "UNWIND", "UNREACHABLE",
1944   "ADD", "SUB", "MUL", "UDIV", "SDIV", "FDIV", "UREM", "SREM", "FREM",
1945   "AND", "OR", "XOR", "SHL", "LSHR", "ASHR", "ICMP", "FCMP", "VICMP",
1946   "VFCMP", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", "ULT", "UGT", "ULE",
1947   "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD", "UNO", "UEQ",
1948   "UNE", "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE", "GETELEMENTPTR",
1949   "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT", "BITCAST", "UITOFP",
1950   "SITOFP", "FPTOUI", "FPTOSI", "INTTOPTR", "PTRTOINT", "PHI_TOK",
1951   "SELECT", "VAARG", "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR",
1952   "GETRESULT", "EXTRACTVALUE", "INSERTVALUE", "SIGNEXT", "ZEROEXT",
1953   "NORETURN", "INREG", "SRET", "NOUNWIND", "NOALIAS", "BYVAL", "NEST",
1954   "READNONE", "READONLY", "GC", "OPTSIZE", "NOINLINE", "ALWAYSINLINE",
1955   "DEFAULT", "HIDDEN", "PROTECTED", "'('", "')'", "'='", "','", "'*'",
1956   "'\\\\'", "'['", "'x'", "']'", "'<'", "'>'", "'{'", "'}'", "'c'",
1957   "$accept", "ArithmeticOps", "LogicalOps", "CastOps", "IPredicates",
1958   "FPredicates", "LocalName", "OptLocalName", "OptAddrSpace",
1959   "OptLocalAssign", "LocalNumber", "GlobalName", "OptGlobalAssign",
1960   "GlobalAssign", "GVInternalLinkage", "GVExternalLinkage",
1961   "GVVisibilityStyle", "FunctionDeclareLinkage", "FunctionDefineLinkage",
1962   "AliasLinkage", "OptCallingConv", "Attribute", "OptAttributes",
1963   "RetAttr", "OptRetAttrs", "FuncAttr", "OptFuncAttrs", "OptGC",
1964   "OptAlign", "OptCAlign", "SectionString", "OptSection",
1965   "GlobalVarAttributes", "GlobalVarAttribute", "PrimType", "Types",
1966   "ArgType", "ResultTypes", "ArgTypeList", "ArgTypeListI", "TypeListI",
1967   "ConstVal", "ConstExpr", "ConstVector", "GlobalType", "ThreadLocal",
1968   "AliaseeRef", "Module", "DefinitionList", "Definition", "@1", "@2", "@3",
1969   "@4", "@5", "AsmBlock", "TargetDefinition", "LibrariesDefinition",
1970   "LibList", "ArgListH", "ArgList", "FunctionHeaderH", "BEGIN",
1971   "FunctionHeader", "END", "Function", "FunctionProto", "OptSideEffect",
1972   "ConstValueRef", "SymbolicValueRef", "ValueRef", "ResolvedVal",
1973   "ReturnedVal", "BasicBlockList", "BasicBlock", "InstructionList",
1974   "BBTerminatorInst", "JumpTable", "Inst", "PHIList", "ParamList",
1975   "IndexList", "ConstantIndexList", "OptTailCall", "InstVal",
1976   "OptVolatile", "MemoryInst", 0
1977 };
1978 #endif
1979
1980 # ifdef YYPRINT
1981 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1982    token YYLEX-NUM.  */
1983 static const yytype_uint16 yytoknum[] =
1984 {
1985        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
1986      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
1987      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
1988      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
1989      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
1990      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
1991      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
1992      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
1993      335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
1994      345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
1995      355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
1996      365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
1997      375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
1998      385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
1999      395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
2000      405,   406,   407,   408,   409,   410,   411,   412,   413,    40,
2001       41,    61,    44,    42,    92,    91,   120,    93,    60,    62,
2002      123,   125,    99
2003 };
2004 # endif
2005
2006 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
2007 static const yytype_uint16 yyr1[] =
2008 {
2009        0,   173,   174,   174,   174,   174,   174,   174,   174,   174,
2010      174,   175,   175,   175,   175,   175,   175,   176,   176,   176,
2011      176,   176,   176,   176,   176,   176,   176,   176,   176,   177,
2012      177,   177,   177,   177,   177,   177,   177,   177,   177,   178,
2013      178,   178,   178,   178,   178,   178,   178,   178,   178,   178,
2014      178,   178,   178,   178,   178,   179,   179,   179,   180,   180,
2015      181,   181,   182,   182,   183,   184,   184,   185,   185,   186,
2016      187,   187,   187,   187,   187,   187,   188,   188,   188,   189,
2017      189,   189,   189,   190,   190,   190,   191,   191,   191,   191,
2018      191,   192,   192,   192,   193,   193,   193,   193,   193,   193,
2019      193,   194,   194,   194,   194,   194,   194,   194,   194,   194,
2020      194,   195,   195,   196,   196,   196,   197,   197,   198,   198,
2021      198,   198,   198,   198,   198,   198,   198,   198,   199,   199,
2022      200,   200,   201,   201,   202,   202,   203,   204,   204,   205,
2023      205,   206,   206,   207,   207,   207,   207,   207,   207,   207,
2024      208,   208,   208,   208,   208,   208,   208,   208,   208,   208,
2025      208,   208,   208,   209,   210,   210,   211,   211,   212,   212,
2026      212,   212,   213,   213,   214,   214,   214,   214,   214,   214,
2027      214,   214,   214,   214,   214,   214,   214,   214,   214,   214,
2028      214,   214,   214,   214,   215,   215,   215,   215,   215,   215,
2029      215,   215,   215,   215,   215,   215,   215,   215,   216,   216,
2030      217,   217,   218,   218,   219,   219,   220,   220,   221,   221,
2031      223,   222,   224,   222,   222,   222,   222,   225,   222,   226,
2032      222,   227,   222,   222,   222,   222,   228,   229,   229,   230,
2033      231,   231,   231,   232,   232,   233,   233,   233,   233,   234,
2034      235,   235,   236,   237,   237,   238,   239,   240,   240,   241,
2035      241,   241,   241,   241,   241,   241,   241,   241,   241,   241,
2036      241,   241,   241,   241,   241,   241,   241,   241,   241,   242,
2037      242,   242,   242,   243,   243,   244,   245,   245,   246,   246,
2038      247,   247,   248,   248,   248,   249,   249,   249,   249,   249,
2039      249,   249,   249,   249,   250,   250,   251,   251,   252,   252,
2040      253,   253,   253,   253,   253,   254,   254,   255,   255,   256,
2041      256,   257,   257,   257,   257,   257,   257,   257,   257,   257,
2042      257,   257,   257,   257,   257,   257,   258,   258,   259,   259,
2043      259,   259,   259,   259,   259,   259,   259,   259,   259
2044 };
2045
2046 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
2047 static const yytype_uint8 yyr2[] =
2048 {
2049        0,     2,     1,     1,     1,     1,     1,     1,     1,     1,
2050        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2051        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2052        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2053        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2054        1,     1,     1,     1,     1,     1,     1,     1,     1,     0,
2055        4,     0,     2,     0,     2,     1,     1,     1,     0,     2,
2056        1,     1,     1,     1,     1,     1,     1,     1,     1,     0,
2057        1,     1,     1,     0,     1,     1,     0,     1,     1,     1,
2058        1,     0,     1,     1,     0,     1,     1,     1,     1,     1,
2059        2,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2060        2,     0,     2,     1,     1,     1,     0,     2,     1,     1,
2061        1,     1,     1,     1,     1,     1,     1,     1,     0,     2,
2062        0,     2,     0,     2,     0,     3,     2,     0,     1,     0,
2063        3,     1,     2,     1,     1,     1,     1,     1,     1,     1,
2064        1,     1,     3,     1,     2,     5,     5,     5,     5,     3,
2065        2,     5,     4,     2,     1,     1,     1,     3,     1,     3,
2066        1,     0,     1,     3,     4,     3,     3,     4,     4,     3,
2067        6,     5,     2,     2,     2,     2,     2,     2,     2,     2,
2068        2,     2,     2,     2,     6,     5,     8,     6,     6,     7,
2069        7,     7,     7,     6,     8,     8,     5,     7,     3,     1,
2070        1,     1,     1,     0,     2,     6,     1,     0,     1,     2,
2071        0,     3,     0,     3,     3,     3,     3,     0,     8,     0,
2072        9,     0,     9,     5,     2,     3,     1,     3,     3,     3,
2073        3,     1,     0,     5,     3,     1,     3,     1,     0,    11,
2074        1,     1,     4,     1,     1,     2,     3,     0,     1,     1,
2075        1,     1,     1,     1,     1,     1,     1,     1,     1,     3,
2076        3,     2,     2,     3,     2,     5,     4,     1,     5,     1,
2077        1,     1,     1,     1,     1,     2,     1,     3,     2,     2,
2078        3,     3,     2,     0,     1,     2,     2,     3,     9,     9,
2079        8,    15,     1,     1,     6,     5,     2,     2,     6,     7,
2080        4,     4,     6,     6,     0,     0,     3,     2,     3,     2,
2081        1,     5,     5,     6,     6,     6,     6,     4,     6,     4,
2082        4,     6,     6,     2,     9,     1,     1,     0,     3,     6,
2083        3,     6,     2,     5,     7,     5,     4,     4,     7
2084 };
2085
2086 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
2087    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
2088    means the default is an error.  */
2089 static const yytype_uint16 yydefact[] =
2090 {
2091       68,    55,    65,    56,    66,    57,   222,   220,     0,     0,
2092        0,     0,     0,     0,    79,    67,     0,    68,   218,    83,
2093       86,     0,     0,   234,     0,     0,    62,     0,    69,    70,
2094       72,    71,    73,    76,    74,    77,    75,    78,    80,    81,
2095       82,    79,    79,   213,     1,   219,    84,    85,    79,   223,
2096       87,    88,    89,    90,    79,   293,   221,   293,     0,     0,
2097      242,   235,   236,   224,   279,   280,   226,   143,   144,   145,
2098      148,   147,   146,   149,   150,     0,     0,     0,     0,   281,
2099      282,   151,   225,   153,   213,   213,    91,   212,     0,    94,
2100       94,   294,   289,    63,   253,   254,   255,   288,   237,   238,
2101      241,     0,   171,   154,     0,     0,     0,     0,   160,   172,
2102        0,     0,   171,     0,     0,     0,    93,    92,     0,   210,
2103      211,     0,     0,    95,    96,    97,    98,    99,   116,   256,
2104        0,     0,   337,   337,   292,     0,   239,   170,   111,   166,
2105      168,     0,     0,     0,     0,     0,     0,   159,     0,     0,
2106      152,     0,     0,   165,     0,   164,     0,   233,    61,    61,
2107      100,     0,   250,   251,   252,    64,   336,   320,     0,     0,
2108        0,     0,    94,   302,   303,     2,     3,     4,     5,     6,
2109        7,     8,     9,    10,    14,    15,    16,    11,    12,    13,
2110        0,     0,     0,     0,     0,     0,     0,     0,    17,    18,
2111       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
2112        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2113        0,     0,   290,    94,   306,     0,   335,   291,   307,   240,
2114      163,     0,   128,    61,    61,   162,     0,   173,     0,   128,
2115       61,    61,     0,   214,   187,   189,   188,   190,   193,   186,
2116      191,   192,   182,   183,     0,     0,     0,     0,     0,     0,
2117        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2118        0,     0,   185,   184,   227,   115,   114,   113,   117,     0,
2119      319,   296,    61,   286,   295,     0,     0,     0,   116,    29,
2120       30,    31,    32,    33,    34,    35,    36,    37,    38,     0,
2121       53,    54,    49,    50,    51,    52,    39,    40,    41,    42,
2122       43,    44,    45,    46,    47,    48,     0,     0,     0,   134,
2123      134,   342,    61,    61,   333,     0,     0,     0,     0,     0,
2124       61,    61,    61,    61,    61,     0,   116,     0,     0,     0,
2125      102,   104,   103,   101,   105,   106,   107,   108,   109,   112,
2126      169,   167,   156,   157,   158,   161,    60,   155,   229,   231,
2127        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2128        0,     0,   175,   209,     0,     0,     0,   179,     0,   176,
2129        0,     0,     0,   139,     0,   259,   260,   261,   262,   263,
2130      268,   264,   265,   266,   267,   257,     0,     0,     0,     0,
2131      277,   284,   283,   285,     0,     0,   297,     0,     0,    61,
2132       61,    61,    61,     0,   338,     0,   340,   315,     0,     0,
2133        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2134        0,     0,    61,     0,   110,   122,   121,   118,   120,   119,
2135      123,   124,   127,   125,   126,   129,   139,   139,     0,     0,
2136        0,     0,     0,   315,     0,     0,     0,     0,     0,     0,
2137        0,   174,   160,   172,     0,   177,   178,     0,     0,     0,
2138        0,   228,   248,   258,     0,   271,     0,     0,     0,   274,
2139        0,   272,   287,     0,     0,     0,     0,     0,     0,     0,
2140        0,     0,     0,   346,     0,     0,     0,   329,   330,     0,
2141        0,     0,     0,   347,     0,     0,     0,   327,     0,   134,
2142        0,   230,   232,    61,     0,     0,     0,     0,     0,     0,
2143        0,     0,     0,     0,     0,   208,   181,     0,     0,     0,
2144        0,     0,     0,   141,   139,   247,   111,   245,     0,     0,
2145      270,   160,     0,   269,   273,     0,     0,     0,     0,     0,
2146        0,     0,   134,   135,   134,     0,     0,     0,     0,     0,
2147        0,   345,   317,     0,    61,   321,   322,     0,     0,   343,
2148       61,   215,     0,     0,     0,     0,   195,     0,     0,     0,
2149        0,   206,     0,   180,     0,     0,    61,   136,   142,   140,
2150       59,     0,   128,     0,   276,     0,     0,     0,   314,   323,
2151      324,   325,   326,   339,   341,   316,     0,     0,   328,   331,
2152      332,   318,     0,   314,   134,     0,     0,     0,     0,     0,
2153      203,     0,     0,     0,   197,   198,   194,    58,   244,   246,
2154      111,   137,   278,   275,     0,     0,   111,   111,     0,   308,
2155        0,   348,     0,   344,   199,   200,   201,   202,     0,     0,
2156        0,   207,    59,   138,   132,     0,     0,   300,     0,     0,
2157        0,   128,     0,   309,   128,   196,   204,   205,   243,     0,
2158      130,   298,     0,     0,   299,   102,   104,   111,   111,     0,
2159      111,   111,   334,   133,     0,   249,     0,     0,   311,   310,
2160        0,     0,     0,   131,     0,     0,     0,   111,   111,   305,
2161        0,     0,   313,   312,   304,     0,     0,   301
2162 };
2163
2164 /* YYDEFGOTO[NTERM-NUM].  */
2165 static const yytype_int16 yydefgoto[] =
2166 {
2167       -1,   269,   270,   271,   299,   316,    79,   628,   113,    12,
2168      133,    80,    14,    15,    41,    42,    43,    48,    54,   118,
2169      128,   349,   230,   278,   161,   445,   352,   685,   670,   414,
2170      533,   654,   471,   534,    81,   158,   139,   156,   140,   141,
2171      110,   373,   400,   374,   121,    88,   157,    16,    17,    18,
2172       20,    19,   383,   446,   447,    63,    23,    61,   101,   537,
2173      538,   129,   164,    55,    96,    56,    49,   474,   401,    83,
2174      403,   283,   284,    57,    92,    93,   222,   658,   134,   324,
2175      638,   493,   503,   223,   224,   225,   226
2176 };
2177
2178 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
2179    STATE-NUM.  */
2180 #define YYPACT_NINF -624
2181 static const yytype_int16 yypact[] =
2182 {
2183      815,  -624,  -624,  -624,  -624,  -624,  -624,  -624,    14,  -114,
2184       16,   -73,    78,   -31,   299,  -624,   163,  2187,  -624,   164,
2185       80,    19,    22,  -624,     2,   179,  -624,  1912,  -624,  -624,
2186     -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,
2187     -624,    68,    68,   201,  -624,  -624,  -624,  -624,    68,  -624,
2188     -624,  -624,  -624,  -624,    68,   200,  -624,     5,   215,   222,
2189      225,  -624,  -624,  -624,  -624,  -624,   117,  -624,  -624,  -624,
2190     -624,  -624,  -624,  -624,  -624,   264,   277,     7,    49,  -624,
2191     -624,  -624,   -12,  -624,   252,   252,   198,  -624,    79,   231,
2192      231,  -624,  -624,    83,  -624,  -624,  -624,  -624,  -624,  -624,
2193     -624,   -21,   649,  -624,   138,   149,   627,   117,  -624,   -12,
2194     -120,   159,   649,   158,    79,    79,  -624,  -624,  1557,  -624,
2195     -624,  2012,   320,  -624,  -624,  -624,  -624,  -624,  -624,  -624,
2196      -13,   173,  2237,  2237,  -624,   313,  -624,  -624,   -12,  -624,
2197      174,   177,  2012,  2012,   169,  -118,  2012,  -624,   336,   191,
2198     -624,  2012,  2012,   117,   193,   -12,   226,  -624,  1296,   308,
2199     -624,  1516,  -624,  -624,  -624,  -624,  -624,  -624,   307,  2031,
2200      108,   357,   231,  -624,  -624,  -624,  -624,  -624,  -624,  -624,
2201     -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,
2202      454,   958,   454,   958,  2012,  2012,  2012,  2012,  -624,  -624,
2203     -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,
2204     2012,  2012,  2012,  2012,  2012,  2012,  2012,  2012,  2012,  2012,
2205     2012,  2012,  -624,   231,  -624,    55,  -624,  -624,  -624,  -624,
2206      161,  1748,  -624,   -23,   -41,  -624,   203,   -12,   214,  -624,
2207      308,   -20,  1557,  -624,  -624,  -624,  -624,  -624,  -624,  -624,
2208     -624,  -624,  -624,  -624,   454,   958,   454,   958,   216,   217,
2209      218,   220,   221,   224,   227,  1789,  2076,   732,   351,   228,
2210      229,   230,  -624,  -624,  -624,  -624,  -624,  -624,  -624,   109,
2211     -624,   117,   956,  -624,   219,  1466,  1466,  1466,  -624,  -624,
2212     -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,  2012,
2213     -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,
2214     -624,  -624,  -624,  -624,  -624,  -624,  2012,  2012,  2012,   -10,
2215        3,  -624,   956,   -17,   223,   237,   238,   239,   240,   241,
2216      956,   956,   956,   956,   956,   352,  -624,  2012,  2012,   387,
2217     -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,
2218     -624,  -624,   539,  -624,  -624,  -624,  -624,   539,  -624,   158,
2219      354,   234,   248,   249,   250,  2012,  2012,  2012,  2012,  2012,
2220     2012,  2012,  -624,  -624,    42,  1006,  -121,  -624,  -116,  -624,
2221     2012,  2012,  2012,   253,   251,  -624,  -624,  -624,  -624,  -624,
2222     -624,  -624,  -624,  -624,  -624,   353,  1807,  2094,  1175,   390,
2223     -624,  -624,  -624,  -624,  2012,   255,  -624,   256,  1516,   956,
2224      956,   956,   956,    20,  -624,    29,  -624,  -624,  1466,   254,
2225     2012,  2012,  2012,  2012,  2012,   258,   259,   261,   262,   263,
2226     2012,  1516,   956,   266,  -624,  -624,  -624,  -624,  -624,  -624,
2227     -624,  -624,  -624,  -624,  -624,  -624,   253,   253,  2012,  2012,
2228     2012,  2012,  2012,  -624,   269,   270,   272,   273,   259,   274,
2229     2012,  -624,   268,  1126,   -84,  -624,  -624,   280,   281,   406,
2230       -5,  -624,  1830,  -624,   423,  -624,    61,  1345,   -56,  -624,
2231      -77,  -624,  -624,   430,   431,  1466,   288,   290,   291,   292,
2232     1466,   455,  1466,   296,   298,  1466,   300,   -12,  -624,   301,
2233      302,   457,   461,   306,  2012,  1466,  1466,   -12,  1466,   311,
2234     2012,  -624,  -624,    -1,   312,   314,   317,   319,   101,  2012,
2235     2012,  2012,  2012,   112,  2012,  -624,  -624,   318,  2012,  2012,
2236     2012,   453,   478,  -624,   253,  -624,   -12,   321,   326,   327,
2237     -624,   323,   -67,  -624,  -624,  1466,  1466,   329,  1466,  1466,
2238     1466,  1466,   311,  -624,   311,  2012,  1466,   328,  2012,  2012,
2239     2012,  -624,  -624,   489,   956,  -624,  -624,   335,   441,  -624,
2240      956,  -624,  2012,  2012,  2012,  2012,  -624,   334,   337,   339,
2241      340,  -624,   259,  -624,   343,   345,    15,  -624,  -624,  -624,
2242      178,  1848,  -624,   484,  -624,   338,   350,   349,  2117,  -624,
2243     -624,  -624,  -624,  -624,  -624,  -624,   348,  1466,  -624,  -624,
2244     -624,  -624,   259,  2117,   311,   356,   359,   360,   361,  2012,
2245     -624,  2012,  2012,   115,  -624,  -624,  -624,  -624,  -624,  -624,
2246      -12,   116,  -624,  -624,   505,    -7,    59,   -12,   118,  -624,
2247      358,   306,   124,  -624,  -624,  -624,  -624,  -624,   363,   364,
2248      366,  -624,   178,  -624,   473,  1466,  1614,  -624,    -6,   802,
2249      802,  -624,  2135,  -624,  -624,  -624,  -624,  -624,  -624,   526,
2250      379,  -624,   374,  1614,  -624,   378,   380,  -624,  -624,   442,
2251       59,   -12,   539,  -624,   516,  -624,   523,   396,   161,   161,
2252      524,   802,   802,  -624,  1466,   525,  1466,  -624,  -624,  -624,
2253     1466,   486,   161,   161,  -624,   543,  1466,  -624
2254 };
2255
2256 /* YYPGOTO[NTERM-NUM].  */
2257 static const yytype_int16 yypgoto[] =
2258 {
2259     -624,   132,   155,   181,  -165,  -154,     0,   -86,  -143,   474,
2260     -624,     6,  -624,  -624,  -624,  -624,    67,  -624,  -624,  -624,
2261     -142,  -624,  -499,  -624,  -252,  -624,  -231,  -624,  -624,  -313,
2262      -63,  -624,  -434,  -624,  -624,   -26,   342,  -152,  -624,   458,
2263      463,   -11,  -156,  -242,   202,   244,   332,  -624,  -624,   554,
2264     -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,  -624,
2265     -624,   485,  -624,  -624,  -624,  -624,  -624,  -624,  -623,   -79,
2266      213,  -193,  -624,  -624,   520,  -624,   445,  -624,  -624,  -624,
2267      -34,   129,  -448,  -624,   456,  -624,  -624
2268 };
2269
2270 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
2271    positive, shift that token.  If negative, reduce the rule which
2272    number is the opposite.  If zero, do what YYDEFACT says.
2273    If YYTABLE_NINF, syntax error.  */
2274 #define YYTABLE_NINF -218
2275 static const yytype_int16 yytable[] =
2276 {
2277       11,    82,   272,   321,   656,   673,    13,   416,   357,   279,
2278      523,   105,   511,   512,   111,   162,   274,    11,   325,   326,
2279      327,   328,   329,    13,   376,   378,    91,   317,   335,   531,
2280      288,   490,   111,   672,    94,   111,   408,   590,   111,   318,
2281      492,   460,   146,   111,   146,   111,   460,    24,   465,   532,
2282      687,   147,   109,   236,   111,   466,    64,    65,   111,   107,
2283       67,    68,    69,    70,    71,    72,    73,    21,     1,     2,
2284      111,     3,     4,     5,   491,    25,   138,   243,   460,   273,
2285      109,   336,    22,   491,   431,   460,   138,   527,    26,   361,
2286      131,   363,   155,    11,   544,   460,    27,   358,   359,    74,
2287      589,   362,     1,   364,   595,     3,   460,     5,    84,    85,
2288      159,   119,   120,   543,  -149,    89,   233,   234,   112,   285,
2289      237,    90,    50,    51,    52,   286,   241,    53,   354,     2,
2290       28,   652,     4,   464,   623,   155,   112,   659,   660,   112,
2291      240,   135,   112,   282,   353,   433,   136,   112,   418,   112,
2292      531,   -61,   413,   -61,   476,   478,   480,   163,   112,   571,
2293      657,   674,   112,    44,   641,   415,   -61,    60,   319,   320,
2294      282,   322,   337,   338,   112,   626,    95,   106,   688,   689,
2295       58,   691,   692,    59,   323,   282,   282,   282,   282,   282,
2296      330,   331,   332,   333,   334,   282,   569,     1,   702,   703,
2297        3,    62,     5,   402,   460,   138,   402,   402,   402,   461,
2298       46,   482,    47,    75,    76,   339,   155,    77,  -149,    78,
2299      108,    91,  -149,   460,    38,    39,    40,   496,   540,   498,
2300      499,   500,   339,    64,    65,   542,    86,    98,    87,   603,
2301      116,   604,   117,   402,    99,     1,     2,   100,     3,     4,
2302        5,   402,   402,   402,   402,   402,   485,   435,   436,   437,
2303      438,   576,   439,   555,   219,   219,   440,   441,   103,   442,
2304      443,   444,   581,   409,   563,   651,   102,   563,   661,   508,
2305      662,   104,   340,   341,   664,   384,   662,   220,   220,    87,
2306      410,   411,   412,   122,   123,   124,   125,   126,   127,   340,
2307      341,   643,   342,   343,   142,   344,   345,   272,   346,   347,
2308      348,   432,   282,   221,   221,   143,   151,   152,   148,   342,
2309      343,   150,   344,   345,   160,   346,   347,   348,   114,   115,
2310      402,   402,   402,   402,   165,   229,   231,   232,   235,   402,
2311      238,    29,    30,    31,    32,    33,    34,    35,    36,   463,
2312       37,   239,   242,   402,   453,   454,   455,   456,   457,   458,
2313      459,   631,   605,   111,   280,   608,   609,   610,   287,   467,
2314      468,   469,   355,   379,   356,   365,   366,   367,   282,   368,
2315      369,   404,   155,   370,   273,   419,   371,   380,   381,   382,
2316      430,   434,   448,   449,   282,   497,   282,   282,   282,   420,
2317      421,   422,   423,   424,   507,   155,   402,   450,   451,   452,
2318      472,   402,   481,   402,   473,   470,   402,   483,   484,   495,
2319      501,   502,   513,   504,   505,   506,   402,   402,   510,   402,
2320      679,   519,   520,   682,   521,   522,   524,   526,   514,   515,
2321      516,   517,   528,   529,   530,   539,   536,   545,   546,   525,
2322      548,   463,   549,   550,   551,    38,    39,    40,   555,   553,
2323      556,   561,   558,   559,   560,   562,   402,   402,   563,   402,
2324      402,   402,   402,   568,   572,   587,   573,   402,   564,   574,
2325      690,   575,   588,   591,   570,   402,   592,   583,   598,   593,
2326      607,   402,   594,   611,   613,   491,   619,   620,   405,   406,
2327      407,   621,   622,   624,   586,   625,   632,   633,   577,   578,
2328      579,   580,   634,   582,   635,   639,   644,   584,   585,   645,
2329      646,   647,   655,   665,   666,   663,   667,   669,   402,   282,
2330      683,   684,   282,   282,   282,   417,   686,   -18,   693,   -19,
2331      694,   696,   700,   425,   426,   427,   428,   429,   289,   290,
2332      291,   292,   293,   294,   295,   296,   297,   298,   695,   705,
2333      706,   615,   616,   617,   618,   630,   668,   132,   653,   145,
2334      149,    45,   637,   351,   360,   130,   402,    97,   227,   642,
2335      402,   402,   518,   435,   436,   437,   438,   637,   439,   228,
2336      627,     0,   440,   441,     0,   442,   443,   444,     0,     0,
2337        0,     0,     0,     0,     0,     0,     0,     0,   648,     0,
2338      649,   650,   402,   402,     0,   402,     0,   402,     0,     0,
2339        0,   402,   486,   487,   488,   489,     0,   402,     0,     0,
2340        0,   494,     0,     0,    64,    65,   681,   107,    67,    68,
2341       69,    70,    71,    72,    73,   509,     1,     2,     0,     3,
2342        4,     5,   627,     0,     0,     0,    64,    65,     0,   107,
2343       67,    68,    69,    70,    71,    72,    73,     0,     1,     2,
2344        0,     3,     4,     5,     0,     0,     0,    74,     0,     0,
2345      435,   436,   437,   438,     0,   439,     0,     0,   137,   440,
2346      441,     0,   442,   443,   444,     0,     0,     0,   547,    74,
2347        0,     0,     0,   552,     0,   554,     0,     0,   557,     0,
2348        0,     0,     0,     0,     0,     0,     0,     0,   565,   566,
2349        0,   567,     0,     0,     0,     0,     0,     0,     0,     0,
2350        0,     0,     0,     0,     0,     0,     0,     0,     0,    64,
2351       65,     0,   107,    67,    68,    69,    70,    71,    72,    73,
2352        0,     1,     2,     0,     3,     4,     5,     0,   596,   597,
2353        0,   599,   600,   601,   602,     0,     0,     0,     0,   606,
2354        0,     0,     0,     0,     0,     0,     0,   612,     0,     0,
2355        0,     0,    74,   614,     0,     0,     0,     0,     0,     0,
2356        0,    75,    76,     0,     0,    77,     0,    78,   144,     0,
2357        0,     0,     0,     0,     0,   385,   386,   387,   388,    64,
2358       65,   389,     0,    75,    76,  -217,     0,    77,     0,    78,
2359      640,     1,     2,     0,     3,     4,     5,   390,   391,   392,
2360        0,     0,     0,   -63,     1,     2,     0,     3,     4,     5,
2361        0,     0,   393,   394,     0,     6,     7,     0,     0,     0,
2362        0,     0,     0,     0,     0,     0,   339,     0,     0,     0,
2363        0,   395,     0,     0,     0,     0,     0,     8,   671,     0,
2364        0,     9,   677,   678,     0,    10,     0,   175,   176,   177,
2365      178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
2366      188,   189,   254,   255,   256,   257,    75,    76,     0,     0,
2367       77,     0,    78,   377,   697,   698,     0,   699,     0,   701,
2368        0,     0,     0,   704,     0,     0,     0,     0,     0,   707,
2369        0,   258,   198,   675,   676,   201,   202,   203,   204,   205,
2370      206,   207,   208,   209,     0,   259,     0,   260,   261,   262,
2371        0,   263,   264,   342,   343,     0,   344,   345,     0,   346,
2372      347,   348,     0,     0,     0,     0,     0,     0,     0,   385,
2373      386,   387,   388,    64,    65,   389,     0,   396,     0,     0,
2374      397,     0,   398,     0,   399,     1,     2,     0,     3,     4,
2375        5,   390,   391,   392,   300,   301,     0,     0,     0,     0,
2376        0,     0,     0,     0,     0,     0,   393,   394,     0,     0,
2377        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2378        0,   111,     0,    64,    65,   395,   107,    67,    68,    69,
2379       70,    71,    72,    73,     0,     1,     2,     0,     3,     4,
2380        5,   175,   176,   177,   178,   179,   180,   181,   182,   183,
2381      184,   185,   186,   187,   188,   189,   254,   255,   256,   257,
2382        0,     0,     0,     0,     0,     0,    74,     0,   302,   303,
2383      304,   305,   306,   307,   308,   309,   310,   311,   312,   313,
2384      314,   315,     0,     0,     0,   258,   198,   199,   200,   201,
2385      202,   203,   204,   205,   206,   207,   208,   209,     0,   259,
2386        0,   260,   261,   262,     0,   263,   264,     0,     0,     0,
2387        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2388        0,     0,     0,     0,     0,   112,     0,     0,     0,     0,
2389        0,   396,     0,     0,   397,     0,   398,     0,   399,   244,
2390      245,   246,   247,    64,    65,   248,     0,     0,     0,     0,
2391        0,     0,     0,     0,     0,     1,     2,     0,     3,     4,
2392        5,   249,   250,   251,     0,     0,     0,     0,     0,     0,
2393        0,     0,     0,     0,     0,     0,   252,   253,     0,     0,
2394       75,    76,     0,     0,    77,     0,    78,   462,     0,     0,
2395        0,   111,    64,    65,     0,   107,    67,    68,    69,    70,
2396       71,    72,    73,     0,     1,     2,     0,     3,     4,     5,
2397        0,   175,   176,   177,   178,   179,   180,   181,   182,   183,
2398      184,   185,   186,   187,   188,   189,   254,   255,   256,   257,
2399        0,     0,     0,     0,     0,    74,     0,     0,     0,     0,
2400        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2401        0,     0,     0,     0,     0,   258,   198,   199,   200,   201,
2402      202,   203,   204,   205,   206,   207,   208,   209,     0,   259,
2403        0,   260,   261,   262,     0,   263,   264,     0,     0,     0,
2404        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2405        0,     0,     0,     0,     0,   112,     0,     0,     0,   -61,
2406        0,   265,     0,     0,   266,     0,   267,     0,   268,   244,
2407      245,   246,   247,    64,    65,   248,     0,     0,     0,     0,
2408        0,     0,     0,     0,     0,     1,     2,     0,     3,     4,
2409        5,   249,   250,   251,     0,     0,     0,     0,     0,     0,
2410        0,     0,     0,     0,     0,     0,   252,   253,     0,    75,
2411       76,     0,     0,    77,     0,    78,   479,     0,     0,     0,
2412        0,   111,    64,    65,     0,   107,    67,    68,    69,    70,
2413       71,    72,    73,     0,     1,     2,     0,     3,     4,     5,
2414        0,   175,   176,   177,   178,   179,   180,   181,   182,   183,
2415      184,   185,   186,   187,   188,   189,   254,   255,   256,   257,
2416        0,     0,     0,     0,     0,    74,     0,     0,     0,     0,
2417        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2418        0,     0,     0,     0,     0,   258,   198,   199,   200,   201,
2419      202,   203,   204,   205,   206,   207,   208,   209,     0,   259,
2420        0,   260,   261,   262,     0,   263,   264,     0,     0,     0,
2421        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2422        0,     0,     0,     0,     0,   112,     0,     0,     0,     0,
2423        0,   265,     0,     0,   266,     0,   267,     0,   268,   385,
2424      386,   387,   388,    64,    65,   389,     0,     0,     0,     0,
2425        0,     0,     0,     0,     0,     1,     2,     0,     3,     4,
2426        5,   390,   391,   392,     0,     0,     0,     0,     0,     0,
2427        0,     0,     0,     0,     0,     0,   393,   394,     0,    75,
2428       76,     0,     0,    77,     0,    78,   541,     0,     0,     0,
2429        0,     0,     0,    64,    65,   395,   153,    67,    68,    69,
2430       70,    71,    72,    73,     0,     1,     2,     0,     3,     4,
2431        5,   175,   176,   177,   178,   179,   180,   181,   182,   183,
2432      184,   185,   186,   187,   188,   189,   254,   255,   256,   257,
2433        0,     0,     0,     0,    64,    65,    74,   153,    67,    68,
2434       69,    70,    71,    72,    73,     0,     1,     2,     0,     3,
2435        4,     5,     0,     0,     0,   258,   198,   199,   200,   201,
2436      202,   203,   204,   205,   206,   207,   208,   209,     0,   259,
2437        0,   260,   261,   262,     0,   263,   264,    74,     0,     0,
2438        0,     0,     0,     0,     0,     0,     0,   385,   386,   387,
2439      388,     0,     0,   389,     0,     0,     0,     0,     0,     0,
2440        0,   396,     0,     0,   397,     0,   398,     0,   399,   390,
2441      391,   392,     0,     0,     0,     0,     0,     0,     0,     0,
2442        0,     0,     0,     0,   393,   394,     0,   275,   276,     0,
2443      277,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2444        0,     0,     0,   395,     0,     0,     0,     0,     0,     0,
2445       75,    76,   154,     0,    77,     0,    78,     0,     0,   175,
2446      176,   177,   178,   179,   180,   181,   182,   183,   184,   185,
2447      186,   187,   188,   189,   254,   255,   256,   257,     0,     0,
2448        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2449        0,    75,    76,     0,     0,    77,     0,    78,     0,     0,
2450        0,     0,     0,   258,   198,   199,   200,   201,   202,   203,
2451      204,   205,   206,   207,   208,   209,     0,   259,     0,   260,
2452      261,   262,     0,   263,   264,    64,    65,     0,   107,    67,
2453       68,    69,    70,    71,    72,    73,     0,     1,     2,     0,
2454        3,     4,     5,     0,     0,     0,     0,     0,     0,   396,
2455        0,     0,   397,     0,   398,     0,   399,   350,     0,     0,
2456        0,     0,     0,     0,     0,     0,    64,    65,    74,   107,
2457       67,    68,    69,    70,    71,    72,    73,     0,     1,     2,
2458        0,     3,     4,     5,    64,    65,     0,   107,    67,    68,
2459       69,    70,    71,    72,    73,     0,     1,     2,     0,     3,
2460        4,     5,     0,     0,     0,     0,     0,    64,    65,    74,
2461      107,    67,    68,    69,    70,    71,    72,    73,     0,     1,
2462        2,     0,     3,     4,     5,    64,    65,    74,   107,    67,
2463       68,    69,    70,    71,    72,    73,     0,     1,     2,   535,
2464        3,     4,     5,     0,     0,     0,     0,     0,     0,     0,
2465       74,     0,     0,     0,     0,     0,     0,   629,     0,     0,
2466        0,     0,     0,     0,     0,     0,     0,     0,    74,     0,
2467        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2468        0,     0,    75,    76,     0,     0,    77,     0,    78,    64,
2469       65,     0,    66,    67,    68,    69,    70,    71,    72,    73,
2470        0,     1,     2,     0,     3,     4,     5,     0,     0,     0,
2471        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2472        0,     0,     0,    75,    76,     0,   372,    77,     0,    78,
2473        0,     0,    74,     0,     0,     0,     0,     0,     0,     0,
2474        0,    75,    76,     0,   475,    77,     0,    78,     0,     0,
2475        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2476        0,     0,     0,     0,    75,    76,     0,     0,    77,     0,
2477       78,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2478        0,     0,    75,    76,     0,     0,    77,     0,    78,    64,
2479       65,     0,   107,    67,    68,    69,    70,    71,    72,    73,
2480        0,     1,     2,     0,     3,     4,     5,     0,    64,    65,
2481        0,   281,    67,    68,    69,    70,    71,    72,    73,     0,
2482        1,     2,     0,     3,     4,     5,     0,     0,     0,     0,
2483        0,     0,    74,     0,     0,     0,     0,     0,     0,     0,
2484        0,     0,     0,     0,     0,     0,    75,    76,     0,     0,
2485       77,    74,    78,    64,    65,     0,   107,    67,    68,    69,
2486       70,    71,    72,    73,     0,     1,     2,     0,     3,     4,
2487        5,    64,    65,     0,   107,    67,    68,    69,    70,    71,
2488       72,    73,     0,     1,     2,     0,     3,     4,     5,     0,
2489        0,     0,     0,     0,    64,    65,    74,   107,    67,    68,
2490       69,    70,    71,    72,   636,     0,     1,     2,     0,     3,
2491        4,     5,    64,    65,    74,   107,    67,    68,    69,    70,
2492       71,    72,   680,     0,     1,     2,     0,     3,     4,     5,
2493        0,     0,     0,     0,     0,     0,     0,    74,     0,     0,
2494        0,     0,     0,     0,     0,     0,    75,    76,     0,     0,
2495       77,     0,    78,     0,     0,    74,     0,  -216,     0,     0,
2496        0,     0,     0,     0,     0,    75,    76,     0,     0,    77,
2497        0,    78,     0,     0,     0,   -63,     1,     2,     0,     3,
2498        4,     5,     0,     0,     0,     0,     0,     6,     7,     0,
2499        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2500        0,     0,     0,     0,     0,     0,     0,     0,     0,     8,
2501       75,    76,     0,     9,    77,     0,   375,    10,     0,     0,
2502        0,     0,     0,     0,     0,     0,     0,     0,    75,    76,
2503        0,     0,    77,     0,   477,     0,     0,     0,     0,     0,
2504        0,     0,     0,   166,     0,     0,     0,     0,     0,     0,
2505        0,    75,    76,     0,     0,    77,     0,    78,     0,     0,
2506        0,     0,     0,     0,   167,   168,     0,     0,     0,    75,
2507       76,     0,     0,    77,     0,    78,   169,   170,   171,   172,
2508      173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
2509      183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
2510      193,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2511        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2512        0,   194,   195,   196,     0,     0,   197,   198,   199,   200,
2513      201,   202,   203,   204,   205,   206,   207,   208,   209,   210,
2514      211,   212,   213,   214,   215,   216,   217,   218
2515 };
2516
2517 static const yytype_int16 yycheck[] =
2518 {
2519        0,    27,   158,   196,    11,    11,     0,   320,   239,   161,
2520      458,     4,   446,   447,    55,    28,   159,    17,   211,   212,
2521      213,   214,   215,    17,   266,   267,    21,   192,   221,    34,
2522      172,    11,    55,   656,    29,    55,   288,   536,    55,   193,
2523       11,   162,   162,    55,   162,    55,   162,   161,   169,    54,
2524      673,   171,    78,   171,    55,   171,     7,     8,    55,    10,
2525       11,    12,    13,    14,    15,    16,    17,    53,    19,    20,
2526       55,    22,    23,    24,    54,    59,   102,   156,   162,   158,
2527      106,   223,    68,    54,   336,   162,   112,   171,   161,   254,
2528        7,   256,   118,    93,   171,   162,    18,   240,   241,    50,
2529      534,   255,    19,   257,   171,    22,   162,    24,    41,    42,
2530      121,    32,    33,   169,    55,    48,   142,   143,   159,    11,
2531      146,    54,    42,    43,    44,    17,   152,    47,   169,    20,
2532      161,   630,    23,   375,   582,   161,   159,   636,   637,   159,
2533      151,   162,   159,   169,   167,   338,   167,   159,   165,   159,
2534       34,   163,   162,   163,   396,   397,   398,   170,   159,   160,
2535      167,   167,   159,     0,   612,   162,   163,   165,   194,   195,
2536      196,   197,   117,   118,   159,   160,   171,   170,   677,   678,
2537      161,   680,   681,   161,   210,   211,   212,   213,   214,   215,
2538      216,   217,   218,   219,   220,   221,   509,    19,   697,   698,
2539       22,    22,    24,   282,   162,   231,   285,   286,   287,   167,
2540       46,   404,    48,   164,   165,    54,   242,   168,   159,   170,
2541      171,    21,   163,   162,   156,   157,   158,   420,   167,   422,
2542      423,   424,    54,     7,     8,   477,    35,    22,    37,   552,
2543       42,   554,    44,   322,    22,    19,    20,    22,    22,    23,
2544       24,   330,   331,   332,   333,   334,   408,   141,   142,   143,
2545      144,   160,   146,   162,   132,   133,   150,   151,     4,   153,
2546      154,   155,   160,   299,   162,   160,   159,   162,   160,   431,
2547      162,     4,   121,   122,   160,   279,   162,   132,   133,    37,
2548      316,   317,   318,    62,    63,    64,    65,    66,    67,   121,
2549      122,   614,   141,   142,   166,   144,   145,   463,   147,   148,
2550      149,   337,   338,   132,   133,   166,   114,   115,   159,   141,
2551      142,   163,   144,   145,     4,   147,   148,   149,    84,    85,
2552      409,   410,   411,   412,   161,    22,   162,   160,   169,   418,
2553        4,    42,    43,    44,    45,    46,    47,    48,    49,   375,
2554       51,   160,   159,   432,   365,   366,   367,   368,   369,   370,
2555      371,   592,   555,    55,    57,   558,   559,   560,    11,   380,
2556      381,   382,   169,    22,   160,   159,   159,   159,   404,   159,
2557      159,   162,   408,   159,   463,   162,   159,   159,   159,   159,
2558       38,     4,    38,   159,   420,   421,   422,   423,   424,   162,
2559      162,   162,   162,   162,   430,   431,   485,   159,   159,   159,
2560      159,   490,    22,   492,    61,   162,   495,   162,   162,   165,
2561      162,   162,   448,   162,   162,   162,   505,   506,   162,   508,
2562      661,   162,   162,   664,   162,   162,   162,   169,   449,   450,
2563      451,   452,   162,   162,    38,    22,   472,    17,    17,   460,
2564      162,   477,   162,   162,   162,   156,   157,   158,   162,     4,
2565      162,     4,   162,   162,   162,     4,   545,   546,   162,   548,
2566      549,   550,   551,   162,   162,    22,   162,   556,   504,   162,
2567       38,   162,     4,   162,   510,   564,   160,   169,   159,   162,
2568      162,   570,   169,     4,   159,    54,   162,   160,   285,   286,
2569      287,   162,   162,   160,   530,   160,    22,   169,   519,   520,
2570      521,   522,   162,   524,   165,   167,   160,   528,   529,   160,
2571      160,   160,    17,   160,   160,   167,   160,    54,   607,   555,
2572        4,   152,   558,   559,   560,   322,   162,   159,    22,   159,
2573       17,    17,    17,   330,   331,   332,   333,   334,    94,    95,
2574       96,    97,    98,    99,   100,   101,   102,   103,   162,    73,
2575       17,   572,   573,   574,   575,   591,   652,    93,   631,   106,
2576      112,    17,   598,   231,   242,    90,   655,    57,   133,   613,
2577      659,   660,   453,   141,   142,   143,   144,   613,   146,   133,
2578      590,    -1,   150,   151,    -1,   153,   154,   155,    -1,    -1,
2579       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   619,    -1,
2580      621,   622,   691,   692,    -1,   694,    -1,   696,    -1,    -1,
2581       -1,   700,   409,   410,   411,   412,    -1,   706,    -1,    -1,
2582       -1,   418,    -1,    -1,     7,     8,   662,    10,    11,    12,
2583       13,    14,    15,    16,    17,   432,    19,    20,    -1,    22,
2584       23,    24,   652,    -1,    -1,    -1,     7,     8,    -1,    10,
2585       11,    12,    13,    14,    15,    16,    17,    -1,    19,    20,
2586       -1,    22,    23,    24,    -1,    -1,    -1,    50,    -1,    -1,
2587      141,   142,   143,   144,    -1,   146,    -1,    -1,    39,   150,
2588      151,    -1,   153,   154,   155,    -1,    -1,    -1,   485,    50,
2589       -1,    -1,    -1,   490,    -1,   492,    -1,    -1,   495,    -1,
2590       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   505,   506,
2591       -1,   508,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2592       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     7,
2593        8,    -1,    10,    11,    12,    13,    14,    15,    16,    17,
2594       -1,    19,    20,    -1,    22,    23,    24,    -1,   545,   546,
2595       -1,   548,   549,   550,   551,    -1,    -1,    -1,    -1,   556,
2596       -1,    -1,    -1,    -1,    -1,    -1,    -1,   564,    -1,    -1,
2597       -1,    -1,    50,   570,    -1,    -1,    -1,    -1,    -1,    -1,
2598       -1,   164,   165,    -1,    -1,   168,    -1,   170,   171,    -1,
2599       -1,    -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,
2600        8,     9,    -1,   164,   165,     0,    -1,   168,    -1,   170,
2601      607,    19,    20,    -1,    22,    23,    24,    25,    26,    27,
2602       -1,    -1,    -1,    18,    19,    20,    -1,    22,    23,    24,
2603       -1,    -1,    40,    41,    -1,    30,    31,    -1,    -1,    -1,
2604       -1,    -1,    -1,    -1,    -1,    -1,    54,    -1,    -1,    -1,
2605       -1,    59,    -1,    -1,    -1,    -1,    -1,    52,   655,    -1,
2606       -1,    56,   659,   660,    -1,    60,    -1,    75,    76,    77,
2607       78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
2608       88,    89,    90,    91,    92,    93,   164,   165,    -1,    -1,
2609      168,    -1,   170,   171,   691,   692,    -1,   694,    -1,   696,
2610       -1,    -1,    -1,   700,    -1,    -1,    -1,    -1,    -1,   706,
2611       -1,   119,   120,   121,   122,   123,   124,   125,   126,   127,
2612      128,   129,   130,   131,    -1,   133,    -1,   135,   136,   137,
2613       -1,   139,   140,   141,   142,    -1,   144,   145,    -1,   147,
2614      148,   149,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
2615        4,     5,     6,     7,     8,     9,    -1,   165,    -1,    -1,
2616      168,    -1,   170,    -1,   172,    19,    20,    -1,    22,    23,
2617       24,    25,    26,    27,    26,    27,    -1,    -1,    -1,    -1,
2618       -1,    -1,    -1,    -1,    -1,    -1,    40,    41,    -1,    -1,
2619       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2620       -1,    55,    -1,     7,     8,    59,    10,    11,    12,    13,
2621       14,    15,    16,    17,    -1,    19,    20,    -1,    22,    23,
2622       24,    75,    76,    77,    78,    79,    80,    81,    82,    83,
2623       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
2624       -1,    -1,    -1,    -1,    -1,    -1,    50,    -1,   100,   101,
2625      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
2626      112,   113,    -1,    -1,    -1,   119,   120,   121,   122,   123,
2627      124,   125,   126,   127,   128,   129,   130,   131,    -1,   133,
2628       -1,   135,   136,   137,    -1,   139,   140,    -1,    -1,    -1,
2629       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2630       -1,    -1,    -1,    -1,    -1,   159,    -1,    -1,    -1,    -1,
2631       -1,   165,    -1,    -1,   168,    -1,   170,    -1,   172,     3,
2632        4,     5,     6,     7,     8,     9,    -1,    -1,    -1,    -1,
2633       -1,    -1,    -1,    -1,    -1,    19,    20,    -1,    22,    23,
2634       24,    25,    26,    27,    -1,    -1,    -1,    -1,    -1,    -1,
2635       -1,    -1,    -1,    -1,    -1,    -1,    40,    41,    -1,    -1,
2636      164,   165,    -1,    -1,   168,    -1,   170,   171,    -1,    -1,
2637       -1,    55,     7,     8,    -1,    10,    11,    12,    13,    14,
2638       15,    16,    17,    -1,    19,    20,    -1,    22,    23,    24,
2639       -1,    75,    76,    77,    78,    79,    80,    81,    82,    83,
2640       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
2641       -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,
2642       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2643       -1,    -1,    -1,    -1,    -1,   119,   120,   121,   122,   123,
2644      124,   125,   126,   127,   128,   129,   130,   131,    -1,   133,
2645       -1,   135,   136,   137,    -1,   139,   140,    -1,    -1,    -1,
2646       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2647       -1,    -1,    -1,    -1,    -1,   159,    -1,    -1,    -1,   163,
2648       -1,   165,    -1,    -1,   168,    -1,   170,    -1,   172,     3,
2649        4,     5,     6,     7,     8,     9,    -1,    -1,    -1,    -1,
2650       -1,    -1,    -1,    -1,    -1,    19,    20,    -1,    22,    23,
2651       24,    25,    26,    27,    -1,    -1,    -1,    -1,    -1,    -1,
2652       -1,    -1,    -1,    -1,    -1,    -1,    40,    41,    -1,   164,
2653      165,    -1,    -1,   168,    -1,   170,   171,    -1,    -1,    -1,
2654       -1,    55,     7,     8,    -1,    10,    11,    12,    13,    14,
2655       15,    16,    17,    -1,    19,    20,    -1,    22,    23,    24,
2656       -1,    75,    76,    77,    78,    79,    80,    81,    82,    83,
2657       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
2658       -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,
2659       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2660       -1,    -1,    -1,    -1,    -1,   119,   120,   121,   122,   123,
2661      124,   125,   126,   127,   128,   129,   130,   131,    -1,   133,
2662       -1,   135,   136,   137,    -1,   139,   140,    -1,    -1,    -1,
2663       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2664       -1,    -1,    -1,    -1,    -1,   159,    -1,    -1,    -1,    -1,
2665       -1,   165,    -1,    -1,   168,    -1,   170,    -1,   172,     3,
2666        4,     5,     6,     7,     8,     9,    -1,    -1,    -1,    -1,
2667       -1,    -1,    -1,    -1,    -1,    19,    20,    -1,    22,    23,
2668       24,    25,    26,    27,    -1,    -1,    -1,    -1,    -1,    -1,
2669       -1,    -1,    -1,    -1,    -1,    -1,    40,    41,    -1,   164,
2670      165,    -1,    -1,   168,    -1,   170,   171,    -1,    -1,    -1,
2671       -1,    -1,    -1,     7,     8,    59,    10,    11,    12,    13,
2672       14,    15,    16,    17,    -1,    19,    20,    -1,    22,    23,
2673       24,    75,    76,    77,    78,    79,    80,    81,    82,    83,
2674       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
2675       -1,    -1,    -1,    -1,     7,     8,    50,    10,    11,    12,
2676       13,    14,    15,    16,    17,    -1,    19,    20,    -1,    22,
2677       23,    24,    -1,    -1,    -1,   119,   120,   121,   122,   123,
2678      124,   125,   126,   127,   128,   129,   130,   131,    -1,   133,
2679       -1,   135,   136,   137,    -1,   139,   140,    50,    -1,    -1,
2680       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
2681        6,    -1,    -1,     9,    -1,    -1,    -1,    -1,    -1,    -1,
2682       -1,   165,    -1,    -1,   168,    -1,   170,    -1,   172,    25,
2683       26,    27,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2684       -1,    -1,    -1,    -1,    40,    41,    -1,   141,   142,    -1,
2685      144,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2686       -1,    -1,    -1,    59,    -1,    -1,    -1,    -1,    -1,    -1,
2687      164,   165,   125,    -1,   168,    -1,   170,    -1,    -1,    75,
2688       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
2689       86,    87,    88,    89,    90,    91,    92,    93,    -1,    -1,
2690       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2691       -1,   164,   165,    -1,    -1,   168,    -1,   170,    -1,    -1,
2692       -1,    -1,    -1,   119,   120,   121,   122,   123,   124,   125,
2693      126,   127,   128,   129,   130,   131,    -1,   133,    -1,   135,
2694      136,   137,    -1,   139,   140,     7,     8,    -1,    10,    11,
2695       12,    13,    14,    15,    16,    17,    -1,    19,    20,    -1,
2696       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    -1,   165,
2697       -1,    -1,   168,    -1,   170,    -1,   172,    39,    -1,    -1,
2698       -1,    -1,    -1,    -1,    -1,    -1,     7,     8,    50,    10,
2699       11,    12,    13,    14,    15,    16,    17,    -1,    19,    20,
2700       -1,    22,    23,    24,     7,     8,    -1,    10,    11,    12,
2701       13,    14,    15,    16,    17,    -1,    19,    20,    -1,    22,
2702       23,    24,    -1,    -1,    -1,    -1,    -1,     7,     8,    50,
2703       10,    11,    12,    13,    14,    15,    16,    17,    -1,    19,
2704       20,    -1,    22,    23,    24,     7,     8,    50,    10,    11,
2705       12,    13,    14,    15,    16,    17,    -1,    19,    20,    39,
2706       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2707       50,    -1,    -1,    -1,    -1,    -1,    -1,    39,    -1,    -1,
2708       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    50,    -1,
2709       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2710       -1,    -1,   164,   165,    -1,    -1,   168,    -1,   170,     7,
2711        8,    -1,    10,    11,    12,    13,    14,    15,    16,    17,
2712       -1,    19,    20,    -1,    22,    23,    24,    -1,    -1,    -1,
2713       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2714       -1,    -1,    -1,   164,   165,    -1,   167,   168,    -1,   170,
2715       -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2716       -1,   164,   165,    -1,   167,   168,    -1,   170,    -1,    -1,
2717       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2718       -1,    -1,    -1,    -1,   164,   165,    -1,    -1,   168,    -1,
2719      170,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2720       -1,    -1,   164,   165,    -1,    -1,   168,    -1,   170,     7,
2721        8,    -1,    10,    11,    12,    13,    14,    15,    16,    17,
2722       -1,    19,    20,    -1,    22,    23,    24,    -1,     7,     8,
2723       -1,    10,    11,    12,    13,    14,    15,    16,    17,    -1,
2724       19,    20,    -1,    22,    23,    24,    -1,    -1,    -1,    -1,
2725       -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2726       -1,    -1,    -1,    -1,    -1,    -1,   164,   165,    -1,    -1,
2727      168,    50,   170,     7,     8,    -1,    10,    11,    12,    13,
2728       14,    15,    16,    17,    -1,    19,    20,    -1,    22,    23,
2729       24,     7,     8,    -1,    10,    11,    12,    13,    14,    15,
2730       16,    17,    -1,    19,    20,    -1,    22,    23,    24,    -1,
2731       -1,    -1,    -1,    -1,     7,     8,    50,    10,    11,    12,
2732       13,    14,    15,    16,    17,    -1,    19,    20,    -1,    22,
2733       23,    24,     7,     8,    50,    10,    11,    12,    13,    14,
2734       15,    16,    17,    -1,    19,    20,    -1,    22,    23,    24,
2735       -1,    -1,    -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,
2736       -1,    -1,    -1,    -1,    -1,    -1,   164,   165,    -1,    -1,
2737      168,    -1,   170,    -1,    -1,    50,    -1,     0,    -1,    -1,
2738       -1,    -1,    -1,    -1,    -1,   164,   165,    -1,    -1,   168,
2739       -1,   170,    -1,    -1,    -1,    18,    19,    20,    -1,    22,
2740       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    -1,
2741       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2742       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,
2743      164,   165,    -1,    56,   168,    -1,   170,    60,    -1,    -1,
2744       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   164,   165,
2745       -1,    -1,   168,    -1,   170,    -1,    -1,    -1,    -1,    -1,
2746       -1,    -1,    -1,    36,    -1,    -1,    -1,    -1,    -1,    -1,
2747       -1,   164,   165,    -1,    -1,   168,    -1,   170,    -1,    -1,
2748       -1,    -1,    -1,    -1,    57,    58,    -1,    -1,    -1,   164,
2749      165,    -1,    -1,   168,    -1,   170,    69,    70,    71,    72,
2750       73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
2751       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
2752       93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2753       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2754       -1,   114,   115,   116,    -1,    -1,   119,   120,   121,   122,
2755      123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
2756      133,   134,   135,   136,   137,   138,   139,   140
2757 };
2758
2759 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
2760    symbol of state STATE-NUM.  */
2761 static const yytype_uint16 yystos[] =
2762 {
2763        0,    19,    20,    22,    23,    24,    30,    31,    52,    56,
2764       60,   179,   182,   184,   185,   186,   220,   221,   222,   224,
2765      223,    53,    68,   229,   161,    59,   161,    18,   161,    42,
2766       43,    44,    45,    46,    47,    48,    49,    51,   156,   157,
2767      158,   187,   188,   189,     0,   222,    46,    48,   190,   239,
2768       42,    43,    44,    47,   191,   236,   238,   246,   161,   161,
2769      165,   230,    22,   228,     7,     8,    10,    11,    12,    13,
2770       14,    15,    16,    17,    50,   164,   165,   168,   170,   179,
2771      184,   207,   208,   242,   189,   189,    35,    37,   218,   189,
2772      189,    21,   247,   248,    29,   171,   237,   247,    22,    22,
2773       22,   231,   159,     4,     4,     4,   170,    10,   171,   208,
2774      213,    55,   159,   181,   218,   218,    42,    44,   192,    32,
2775       33,   217,    62,    63,    64,    65,    66,    67,   193,   234,
2776      234,     7,   182,   183,   251,   162,   167,    39,   208,   209,
2777      211,   212,   166,   166,   171,   213,   162,   171,   159,   212,
2778      163,   217,   217,    10,   125,   208,   210,   219,   208,   214,
2779        4,   197,    28,   170,   235,   161,    36,    57,    58,    69,
2780       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
2781       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
2782       90,    91,    92,    93,   114,   115,   116,   119,   120,   121,
2783      122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
2784      132,   133,   134,   135,   136,   137,   138,   139,   140,   174,
2785      175,   176,   249,   256,   257,   258,   259,   249,   257,    22,
2786      195,   162,   160,   208,   208,   169,   171,   208,     4,   160,
2787      214,   208,   159,   242,     3,     4,     5,     6,     9,    25,
2788       26,    27,    40,    41,    90,    91,    92,    93,   119,   133,
2789      135,   136,   137,   139,   140,   165,   168,   170,   172,   174,
2790      175,   176,   215,   242,   181,   141,   142,   144,   196,   210,
2791       57,    10,   208,   244,   245,    11,    17,    11,   193,    94,
2792       95,    96,    97,    98,    99,   100,   101,   102,   103,   177,
2793       26,    27,   100,   101,   102,   103,   104,   105,   106,   107,
2794      108,   109,   110,   111,   112,   113,   178,   177,   178,   208,
2795      208,   244,   208,   208,   252,   244,   244,   244,   244,   244,
2796      208,   208,   208,   208,   208,   244,   193,   117,   118,    54,
2797      121,   122,   141,   142,   144,   145,   147,   148,   149,   194,
2798       39,   209,   199,   167,   169,   169,   160,   199,   181,   181,
2799      219,   177,   178,   177,   178,   159,   159,   159,   159,   159,
2800      159,   159,   167,   214,   216,   170,   216,   171,   216,    22,
2801      159,   159,   159,   225,   184,     3,     4,     5,     6,     9,
2802       25,    26,    27,    40,    41,    59,   165,   168,   170,   172,
2803      215,   241,   242,   243,   162,   243,   243,   243,   197,   208,
2804      208,   208,   208,   162,   202,   162,   202,   243,   165,   162,
2805      162,   162,   162,   162,   162,   243,   243,   243,   243,   243,
2806       38,   197,   208,   244,     4,   141,   142,   143,   144,   146,
2807      150,   151,   153,   154,   155,   198,   226,   227,    38,   159,
2808      159,   159,   159,   214,   214,   214,   214,   214,   214,   214,
2809      162,   167,   171,   208,   216,   169,   171,   214,   214,   214,
2810      162,   205,   159,    61,   240,   167,   216,   170,   216,   171,
2811      216,    22,   244,   162,   162,   210,   243,   243,   243,   243,
2812       11,    54,    11,   254,   243,   165,   244,   208,   244,   244,
2813      244,   162,   162,   255,   162,   162,   162,   208,   210,   243,
2814      162,   205,   205,   208,   214,   214,   214,   214,   254,   162,
2815      162,   162,   162,   255,   162,   214,   169,   171,   162,   162,
2816       38,    34,    54,   203,   206,    39,   208,   232,   233,    22,
2817      167,   171,   216,   169,   171,    17,    17,   243,   162,   162,
2818      162,   162,   243,     4,   243,   162,   162,   243,   162,   162,
2819      162,     4,     4,   162,   208,   243,   243,   243,   162,   202,
2820      208,   160,   162,   162,   162,   162,   160,   214,   214,   214,
2821      214,   160,   214,   169,   214,   214,   208,    22,     4,   205,
2822      195,   162,   160,   162,   169,   171,   243,   243,   159,   243,
2823      243,   243,   243,   202,   202,   244,   243,   162,   244,   244,
2824      244,     4,   243,   159,   243,   214,   214,   214,   214,   162,
2825      160,   162,   162,   255,   160,   160,   160,   179,   180,    39,
2826      208,   199,    22,   169,   162,   165,    17,   208,   253,   167,
2827      243,   255,   253,   202,   160,   160,   160,   160,   214,   214,
2828      214,   160,   195,   203,   204,    17,    11,   167,   250,   195,
2829      195,   160,   162,   167,   160,   160,   160,   160,   180,    54,
2830      201,   243,   241,    11,   167,   121,   122,   243,   243,   199,
2831       17,   208,   199,     4,   152,   200,   162,   241,   195,   195,
2832       38,   195,   195,    22,    17,   162,    17,   243,   243,   243,
2833       17,   243,   195,   195,   243,    73,    17,   243
2834 };
2835
2836 #define yyerrok         (yyerrstatus = 0)
2837 #define yyclearin       (yychar = YYEMPTY)
2838 #define YYEMPTY         (-2)
2839 #define YYEOF           0
2840
2841 #define YYACCEPT        goto yyacceptlab
2842 #define YYABORT         goto yyabortlab
2843 #define YYERROR         goto yyerrorlab
2844
2845
2846 /* Like YYERROR except do call yyerror.  This remains here temporarily
2847    to ease the transition to the new meaning of YYERROR, for GCC.
2848    Once GCC version 2 has supplanted version 1, this can go.  */
2849
2850 #define YYFAIL          goto yyerrlab
2851
2852 #define YYRECOVERING()  (!!yyerrstatus)
2853
2854 #define YYBACKUP(Token, Value)                                  \
2855 do                                                              \
2856   if (yychar == YYEMPTY && yylen == 1)                          \
2857     {                                                           \
2858       yychar = (Token);                                         \
2859       yylval = (Value);                                         \
2860       yytoken = YYTRANSLATE (yychar);                           \
2861       YYPOPSTACK (1);                                           \
2862       goto yybackup;                                            \
2863     }                                                           \
2864   else                                                          \
2865     {                                                           \
2866       yyerror (YY_("syntax error: cannot back up")); \
2867       YYERROR;                                                  \
2868     }                                                           \
2869 while (YYID (0))
2870
2871
2872 #define YYTERROR        1
2873 #define YYERRCODE       256
2874
2875
2876 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
2877    If N is 0, then set CURRENT to the empty location which ends
2878    the previous symbol: RHS[0] (always defined).  */
2879
2880 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
2881 #ifndef YYLLOC_DEFAULT
2882 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
2883     do                                                                  \
2884       if (YYID (N))                                                    \
2885         {                                                               \
2886           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
2887           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
2888           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
2889           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
2890         }                                                               \
2891       else                                                              \
2892         {                                                               \
2893           (Current).first_line   = (Current).last_line   =              \
2894             YYRHSLOC (Rhs, 0).last_line;                                \
2895           (Current).first_column = (Current).last_column =              \
2896             YYRHSLOC (Rhs, 0).last_column;                              \
2897         }                                                               \
2898     while (YYID (0))
2899 #endif
2900
2901
2902 /* YY_LOCATION_PRINT -- Print the location on the stream.
2903    This macro was not mandated originally: define only if we know
2904    we won't break user code: when these are the locations we know.  */
2905
2906 #ifndef YY_LOCATION_PRINT
2907 # if YYLTYPE_IS_TRIVIAL
2908 #  define YY_LOCATION_PRINT(File, Loc)                  \
2909      fprintf (File, "%d.%d-%d.%d",                      \
2910               (Loc).first_line, (Loc).first_column,     \
2911               (Loc).last_line,  (Loc).last_column)
2912 # else
2913 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
2914 # endif
2915 #endif
2916
2917
2918 /* YYLEX -- calling `yylex' with the right arguments.  */
2919
2920 #ifdef YYLEX_PARAM
2921 # define YYLEX yylex (YYLEX_PARAM)
2922 #else
2923 # define YYLEX yylex ()
2924 #endif
2925
2926 /* Enable debugging if requested.  */
2927 #if YYDEBUG
2928
2929 # ifndef YYFPRINTF
2930 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
2931 #  define YYFPRINTF fprintf
2932 # endif
2933
2934 # define YYDPRINTF(Args)                        \
2935 do {                                            \
2936   if (yydebug)                                  \
2937     YYFPRINTF Args;                             \
2938 } while (YYID (0))
2939
2940 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
2941 do {                                                                      \
2942   if (yydebug)                                                            \
2943     {                                                                     \
2944       YYFPRINTF (stderr, "%s ", Title);                                   \
2945       yy_symbol_print (stderr,                                            \
2946                   Type, Value); \
2947       YYFPRINTF (stderr, "\n");                                           \
2948     }                                                                     \
2949 } while (YYID (0))
2950
2951
2952 /*--------------------------------.
2953 | Print this symbol on YYOUTPUT.  |
2954 `--------------------------------*/
2955
2956 /*ARGSUSED*/
2957 #if (defined __STDC__ || defined __C99__FUNC__ \
2958      || defined __cplusplus || defined _MSC_VER)
2959 static void
2960 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
2961 #else
2962 static void
2963 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
2964     FILE *yyoutput;
2965     int yytype;
2966     YYSTYPE const * const yyvaluep;
2967 #endif
2968 {
2969   if (!yyvaluep)
2970     return;
2971 # ifdef YYPRINT
2972   if (yytype < YYNTOKENS)
2973     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
2974 # else
2975   YYUSE (yyoutput);
2976 # endif
2977   switch (yytype)
2978     {
2979       default:
2980         break;
2981     }
2982 }
2983
2984
2985 /*--------------------------------.
2986 | Print this symbol on YYOUTPUT.  |
2987 `--------------------------------*/
2988
2989 #if (defined __STDC__ || defined __C99__FUNC__ \
2990      || defined __cplusplus || defined _MSC_VER)
2991 static void
2992 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
2993 #else
2994 static void
2995 yy_symbol_print (yyoutput, yytype, yyvaluep)
2996     FILE *yyoutput;
2997     int yytype;
2998     YYSTYPE const * const yyvaluep;
2999 #endif
3000 {
3001   if (yytype < YYNTOKENS)
3002     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
3003   else
3004     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
3005
3006   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
3007   YYFPRINTF (yyoutput, ")");
3008 }
3009
3010 /*------------------------------------------------------------------.
3011 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
3012 | TOP (included).                                                   |
3013 `------------------------------------------------------------------*/
3014
3015 #if (defined __STDC__ || defined __C99__FUNC__ \
3016      || defined __cplusplus || defined _MSC_VER)
3017 static void
3018 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
3019 #else
3020 static void
3021 yy_stack_print (bottom, top)
3022     yytype_int16 *bottom;
3023     yytype_int16 *top;
3024 #endif
3025 {
3026   YYFPRINTF (stderr, "Stack now");
3027   for (; bottom <= top; ++bottom)
3028     YYFPRINTF (stderr, " %d", *bottom);
3029   YYFPRINTF (stderr, "\n");
3030 }
3031
3032 # define YY_STACK_PRINT(Bottom, Top)                            \
3033 do {                                                            \
3034   if (yydebug)                                                  \
3035     yy_stack_print ((Bottom), (Top));                           \
3036 } while (YYID (0))
3037
3038
3039 /*------------------------------------------------.
3040 | Report that the YYRULE is going to be reduced.  |
3041 `------------------------------------------------*/
3042
3043 #if (defined __STDC__ || defined __C99__FUNC__ \
3044      || defined __cplusplus || defined _MSC_VER)
3045 static void
3046 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
3047 #else
3048 static void
3049 yy_reduce_print (yyvsp, yyrule)
3050     YYSTYPE *yyvsp;
3051     int yyrule;
3052 #endif
3053 {
3054   int yynrhs = yyr2[yyrule];
3055   int yyi;
3056   unsigned long int yylno = yyrline[yyrule];
3057   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
3058              yyrule - 1, yylno);
3059   /* The symbols being reduced.  */
3060   for (yyi = 0; yyi < yynrhs; yyi++)
3061     {
3062       fprintf (stderr, "   $%d = ", yyi + 1);
3063       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
3064                        &(yyvsp[(yyi + 1) - (yynrhs)])
3065                                        );
3066       fprintf (stderr, "\n");
3067     }
3068 }
3069
3070 # define YY_REDUCE_PRINT(Rule)          \
3071 do {                                    \
3072   if (yydebug)                          \
3073     yy_reduce_print (yyvsp, Rule); \
3074 } while (YYID (0))
3075
3076 /* Nonzero means print parse trace.  It is left uninitialized so that
3077    multiple parsers can coexist.  */
3078 int yydebug;
3079 #else /* !YYDEBUG */
3080 # define YYDPRINTF(Args)
3081 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
3082 # define YY_STACK_PRINT(Bottom, Top)
3083 # define YY_REDUCE_PRINT(Rule)
3084 #endif /* !YYDEBUG */
3085
3086
3087 /* YYINITDEPTH -- initial size of the parser's stacks.  */
3088 #ifndef YYINITDEPTH
3089 # define YYINITDEPTH 200
3090 #endif
3091
3092 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
3093    if the built-in stack extension method is used).
3094
3095    Do not make this value too large; the results are undefined if
3096    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
3097    evaluated with infinite-precision integer arithmetic.  */
3098
3099 #ifndef YYMAXDEPTH
3100 # define YYMAXDEPTH 10000
3101 #endif
3102
3103 \f
3104
3105 #if YYERROR_VERBOSE
3106
3107 # ifndef yystrlen
3108 #  if defined __GLIBC__ && defined _STRING_H
3109 #   define yystrlen strlen
3110 #  else
3111 /* Return the length of YYSTR.  */
3112 #if (defined __STDC__ || defined __C99__FUNC__ \
3113      || defined __cplusplus || defined _MSC_VER)
3114 static YYSIZE_T
3115 yystrlen (const char *yystr)
3116 #else
3117 static YYSIZE_T
3118 yystrlen (yystr)
3119     const char *yystr;
3120 #endif
3121 {
3122   YYSIZE_T yylen;
3123   for (yylen = 0; yystr[yylen]; yylen++)
3124     continue;
3125   return yylen;
3126 }
3127 #  endif
3128 # endif
3129
3130 # ifndef yystpcpy
3131 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
3132 #   define yystpcpy stpcpy
3133 #  else
3134 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
3135    YYDEST.  */
3136 #if (defined __STDC__ || defined __C99__FUNC__ \
3137      || defined __cplusplus || defined _MSC_VER)
3138 static char *
3139 yystpcpy (char *yydest, const char *yysrc)
3140 #else
3141 static char *
3142 yystpcpy (yydest, yysrc)
3143     char *yydest;
3144     const char *yysrc;
3145 #endif
3146 {
3147   char *yyd = yydest;
3148   const char *yys = yysrc;
3149
3150   while ((*yyd++ = *yys++) != '\0')
3151     continue;
3152
3153   return yyd - 1;
3154 }
3155 #  endif
3156 # endif
3157
3158 # ifndef yytnamerr
3159 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
3160    quotes and backslashes, so that it's suitable for yyerror.  The
3161    heuristic is that double-quoting is unnecessary unless the string
3162    contains an apostrophe, a comma, or backslash (other than
3163    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
3164    null, do not copy; instead, return the length of what the result
3165    would have been.  */
3166 static YYSIZE_T
3167 yytnamerr (char *yyres, const char *yystr)
3168 {
3169   if (*yystr == '"')
3170     {
3171       YYSIZE_T yyn = 0;
3172       char const *yyp = yystr;
3173
3174       for (;;)
3175         switch (*++yyp)
3176           {
3177           case '\'':
3178           case ',':
3179             goto do_not_strip_quotes;
3180
3181           case '\\':
3182             if (*++yyp != '\\')
3183               goto do_not_strip_quotes;
3184             /* Fall through.  */
3185           default:
3186             if (yyres)
3187               yyres[yyn] = *yyp;
3188             yyn++;
3189             break;
3190
3191           case '"':
3192             if (yyres)
3193               yyres[yyn] = '\0';
3194             return yyn;
3195           }
3196     do_not_strip_quotes: ;
3197     }
3198
3199   if (! yyres)
3200     return yystrlen (yystr);
3201
3202   return yystpcpy (yyres, yystr) - yyres;
3203 }
3204 # endif
3205
3206 /* Copy into YYRESULT an error message about the unexpected token
3207    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
3208    including the terminating null byte.  If YYRESULT is null, do not
3209    copy anything; just return the number of bytes that would be
3210    copied.  As a special case, return 0 if an ordinary "syntax error"
3211    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
3212    size calculation.  */
3213 static YYSIZE_T
3214 yysyntax_error (char *yyresult, int yystate, int yychar)
3215 {
3216   int yyn = yypact[yystate];
3217
3218   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
3219     return 0;
3220   else
3221     {
3222       int yytype = YYTRANSLATE (yychar);
3223       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
3224       YYSIZE_T yysize = yysize0;
3225       YYSIZE_T yysize1;
3226       int yysize_overflow = 0;
3227       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
3228       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
3229       int yyx;
3230
3231 # if 0
3232       /* This is so xgettext sees the translatable formats that are
3233          constructed on the fly.  */
3234       YY_("syntax error, unexpected %s");
3235       YY_("syntax error, unexpected %s, expecting %s");
3236       YY_("syntax error, unexpected %s, expecting %s or %s");
3237       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
3238       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
3239 # endif
3240       char *yyfmt;
3241       char const *yyf;
3242       static char const yyunexpected[] = "syntax error, unexpected %s";
3243       static char const yyexpecting[] = ", expecting %s";
3244       static char const yyor[] = " or %s";
3245       char yyformat[sizeof yyunexpected
3246                     + sizeof yyexpecting - 1
3247                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
3248                        * (sizeof yyor - 1))];
3249       char const *yyprefix = yyexpecting;
3250
3251       /* Start YYX at -YYN if negative to avoid negative indexes in
3252          YYCHECK.  */
3253       int yyxbegin = yyn < 0 ? -yyn : 0;
3254
3255       /* Stay within bounds of both yycheck and yytname.  */
3256       int yychecklim = YYLAST - yyn + 1;
3257       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
3258       int yycount = 1;
3259
3260       yyarg[0] = yytname[yytype];
3261       yyfmt = yystpcpy (yyformat, yyunexpected);
3262
3263       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
3264         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
3265           {
3266             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
3267               {
3268                 yycount = 1;
3269                 yysize = yysize0;
3270                 yyformat[sizeof yyunexpected - 1] = '\0';
3271                 break;
3272               }
3273             yyarg[yycount++] = yytname[yyx];
3274             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
3275             yysize_overflow |= (yysize1 < yysize);
3276             yysize = yysize1;
3277             yyfmt = yystpcpy (yyfmt, yyprefix);
3278             yyprefix = yyor;
3279           }
3280
3281       yyf = YY_(yyformat);
3282       yysize1 = yysize + yystrlen (yyf);
3283       yysize_overflow |= (yysize1 < yysize);
3284       yysize = yysize1;
3285
3286       if (yysize_overflow)
3287         return YYSIZE_MAXIMUM;
3288
3289       if (yyresult)
3290         {
3291           /* Avoid sprintf, as that infringes on the user's name space.
3292              Don't have undefined behavior even if the translation
3293              produced a string with the wrong number of "%s"s.  */
3294           char *yyp = yyresult;
3295           int yyi = 0;
3296           while ((*yyp = *yyf) != '\0')
3297             {
3298               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
3299                 {
3300                   yyp += yytnamerr (yyp, yyarg[yyi++]);
3301                   yyf += 2;
3302                 }
3303               else
3304                 {
3305                   yyp++;
3306                   yyf++;
3307                 }
3308             }
3309         }
3310       return yysize;
3311     }
3312 }
3313 #endif /* YYERROR_VERBOSE */
3314 \f
3315
3316 /*-----------------------------------------------.
3317 | Release the memory associated to this symbol.  |
3318 `-----------------------------------------------*/
3319
3320 /*ARGSUSED*/
3321 #if (defined __STDC__ || defined __C99__FUNC__ \
3322      || defined __cplusplus || defined _MSC_VER)
3323 static void
3324 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
3325 #else
3326 static void
3327 yydestruct (yymsg, yytype, yyvaluep)
3328     const char *yymsg;
3329     int yytype;
3330     YYSTYPE *yyvaluep;
3331 #endif
3332 {
3333   YYUSE (yyvaluep);
3334
3335   if (!yymsg)
3336     yymsg = "Deleting";
3337   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
3338
3339   switch (yytype)
3340     {
3341
3342       default:
3343         break;
3344     }
3345 }
3346 \f
3347
3348 /* Prevent warnings from -Wmissing-prototypes.  */
3349
3350 #ifdef YYPARSE_PARAM
3351 #if defined __STDC__ || defined __cplusplus
3352 int yyparse (void *YYPARSE_PARAM);
3353 #else
3354 int yyparse ();
3355 #endif
3356 #else /* ! YYPARSE_PARAM */
3357 #if defined __STDC__ || defined __cplusplus
3358 int yyparse (void);
3359 #else
3360 int yyparse ();
3361 #endif
3362 #endif /* ! YYPARSE_PARAM */
3363
3364
3365
3366 /* The look-ahead symbol.  */
3367 int yychar;
3368
3369 /* The semantic value of the look-ahead symbol.  */
3370 YYSTYPE yylval;
3371
3372 /* Number of syntax errors so far.  */
3373 int yynerrs;
3374
3375
3376
3377 /*----------.
3378 | yyparse.  |
3379 `----------*/
3380
3381 #ifdef YYPARSE_PARAM
3382 #if (defined __STDC__ || defined __C99__FUNC__ \
3383      || defined __cplusplus || defined _MSC_VER)
3384 int
3385 yyparse (void *YYPARSE_PARAM)
3386 #else
3387 int
3388 yyparse (YYPARSE_PARAM)
3389     void *YYPARSE_PARAM;
3390 #endif
3391 #else /* ! YYPARSE_PARAM */
3392 #if (defined __STDC__ || defined __C99__FUNC__ \
3393      || defined __cplusplus || defined _MSC_VER)
3394 int
3395 yyparse (void)
3396 #else
3397 int
3398 yyparse ()
3399
3400 #endif
3401 #endif
3402 {
3403
3404   int yystate;
3405   int yyn;
3406   int yyresult;
3407   /* Number of tokens to shift before error messages enabled.  */
3408   int yyerrstatus;
3409   /* Look-ahead token as an internal (translated) token number.  */
3410   int yytoken = 0;
3411 #if YYERROR_VERBOSE
3412   /* Buffer for error messages, and its allocated size.  */
3413   char yymsgbuf[128];
3414   char *yymsg = yymsgbuf;
3415   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
3416 #endif
3417
3418   /* Three stacks and their tools:
3419      `yyss': related to states,
3420      `yyvs': related to semantic values,
3421      `yyls': related to locations.
3422
3423      Refer to the stacks thru separate pointers, to allow yyoverflow
3424      to reallocate them elsewhere.  */
3425
3426   /* The state stack.  */
3427   yytype_int16 yyssa[YYINITDEPTH];
3428   yytype_int16 *yyss = yyssa;
3429   yytype_int16 *yyssp;
3430
3431   /* The semantic value stack.  */
3432   YYSTYPE yyvsa[YYINITDEPTH];
3433   YYSTYPE *yyvs = yyvsa;
3434   YYSTYPE *yyvsp;
3435
3436
3437
3438 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
3439
3440   YYSIZE_T yystacksize = YYINITDEPTH;
3441
3442   /* The variables used to return semantic value and location from the
3443      action routines.  */
3444   YYSTYPE yyval;
3445
3446
3447   /* The number of symbols on the RHS of the reduced rule.
3448      Keep to zero when no symbol should be popped.  */
3449   int yylen = 0;
3450
3451   YYDPRINTF ((stderr, "Starting parse\n"));
3452
3453   yystate = 0;
3454   yyerrstatus = 0;
3455   yynerrs = 0;
3456   yychar = YYEMPTY;             /* Cause a token to be read.  */
3457
3458   /* Initialize stack pointers.
3459      Waste one element of value and location stack
3460      so that they stay on the same level as the state stack.
3461      The wasted elements are never initialized.  */
3462
3463   yyssp = yyss;
3464   yyvsp = yyvs;
3465
3466   goto yysetstate;
3467
3468 /*------------------------------------------------------------.
3469 | yynewstate -- Push a new state, which is found in yystate.  |
3470 `------------------------------------------------------------*/
3471  yynewstate:
3472   /* In all cases, when you get here, the value and location stacks
3473      have just been pushed.  So pushing a state here evens the stacks.  */
3474   yyssp++;
3475
3476  yysetstate:
3477   *yyssp = yystate;
3478
3479   if (yyss + yystacksize - 1 <= yyssp)
3480     {
3481       /* Get the current used size of the three stacks, in elements.  */
3482       YYSIZE_T yysize = yyssp - yyss + 1;
3483
3484 #ifdef yyoverflow
3485       {
3486         /* Give user a chance to reallocate the stack.  Use copies of
3487            these so that the &'s don't force the real ones into
3488            memory.  */
3489         YYSTYPE *yyvs1 = yyvs;
3490         yytype_int16 *yyss1 = yyss;
3491
3492
3493         /* Each stack pointer address is followed by the size of the
3494            data in use in that stack, in bytes.  This used to be a
3495            conditional around just the two extra args, but that might
3496            be undefined if yyoverflow is a macro.  */
3497         yyoverflow (YY_("memory exhausted"),
3498                     &yyss1, yysize * sizeof (*yyssp),
3499                     &yyvs1, yysize * sizeof (*yyvsp),
3500
3501                     &yystacksize);
3502
3503         yyss = yyss1;
3504         yyvs = yyvs1;
3505       }
3506 #else /* no yyoverflow */
3507 # ifndef YYSTACK_RELOCATE
3508       goto yyexhaustedlab;
3509 # else
3510       /* Extend the stack our own way.  */
3511       if (YYMAXDEPTH <= yystacksize)
3512         goto yyexhaustedlab;
3513       yystacksize *= 2;
3514       if (YYMAXDEPTH < yystacksize)
3515         yystacksize = YYMAXDEPTH;
3516
3517       {
3518         yytype_int16 *yyss1 = yyss;
3519         union yyalloc *yyptr =
3520           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
3521         if (! yyptr)
3522           goto yyexhaustedlab;
3523         YYSTACK_RELOCATE (yyss);
3524         YYSTACK_RELOCATE (yyvs);
3525
3526 #  undef YYSTACK_RELOCATE
3527         if (yyss1 != yyssa)
3528           YYSTACK_FREE (yyss1);
3529       }
3530 # endif
3531 #endif /* no yyoverflow */
3532
3533       yyssp = yyss + yysize - 1;
3534       yyvsp = yyvs + yysize - 1;
3535
3536
3537       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
3538                   (unsigned long int) yystacksize));
3539
3540       if (yyss + yystacksize - 1 <= yyssp)
3541         YYABORT;
3542     }
3543
3544   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
3545
3546   goto yybackup;
3547
3548 /*-----------.
3549 | yybackup.  |
3550 `-----------*/
3551 yybackup:
3552
3553   /* Do appropriate processing given the current state.  Read a
3554      look-ahead token if we need one and don't already have one.  */
3555
3556   /* First try to decide what to do without reference to look-ahead token.  */
3557   yyn = yypact[yystate];
3558   if (yyn == YYPACT_NINF)
3559     goto yydefault;
3560
3561   /* Not known => get a look-ahead token if don't already have one.  */
3562
3563   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
3564   if (yychar == YYEMPTY)
3565     {
3566       YYDPRINTF ((stderr, "Reading a token: "));
3567       yychar = YYLEX;
3568     }
3569
3570   if (yychar <= YYEOF)
3571     {
3572       yychar = yytoken = YYEOF;
3573       YYDPRINTF ((stderr, "Now at end of input.\n"));
3574     }
3575   else
3576     {
3577       yytoken = YYTRANSLATE (yychar);
3578       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
3579     }
3580
3581   /* If the proper action on seeing token YYTOKEN is to reduce or to
3582      detect an error, take that action.  */
3583   yyn += yytoken;
3584   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
3585     goto yydefault;
3586   yyn = yytable[yyn];
3587   if (yyn <= 0)
3588     {
3589       if (yyn == 0 || yyn == YYTABLE_NINF)
3590         goto yyerrlab;
3591       yyn = -yyn;
3592       goto yyreduce;
3593     }
3594
3595   if (yyn == YYFINAL)
3596     YYACCEPT;
3597
3598   /* Count tokens shifted since error; after three, turn off error
3599      status.  */
3600   if (yyerrstatus)
3601     yyerrstatus--;
3602
3603   /* Shift the look-ahead token.  */
3604   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
3605
3606   /* Discard the shifted token unless it is eof.  */
3607   if (yychar != YYEOF)
3608     yychar = YYEMPTY;
3609
3610   yystate = yyn;
3611   *++yyvsp = yylval;
3612
3613   goto yynewstate;
3614
3615
3616 /*-----------------------------------------------------------.
3617 | yydefault -- do the default action for the current state.  |
3618 `-----------------------------------------------------------*/
3619 yydefault:
3620   yyn = yydefact[yystate];
3621   if (yyn == 0)
3622     goto yyerrlab;
3623   goto yyreduce;
3624
3625
3626 /*-----------------------------.
3627 | yyreduce -- Do a reduction.  |
3628 `-----------------------------*/
3629 yyreduce:
3630   /* yyn is the number of a rule to reduce with.  */
3631   yylen = yyr2[yyn];
3632
3633   /* If YYLEN is nonzero, implement the default value of the action:
3634      `$$ = $1'.
3635
3636      Otherwise, the following line sets YYVAL to garbage.
3637      This behavior is undocumented and Bison
3638      users should not rely upon it.  Assigning to YYVAL
3639      unconditionally makes the parser a bit smaller, and it avoids a
3640      GCC warning that YYVAL may be used uninitialized.  */
3641   yyval = yyvsp[1-yylen];
3642
3643
3644   YY_REDUCE_PRINT (yyn);
3645   switch (yyn)
3646     {
3647         case 29:
3648 #line 1150 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3649     { (yyval.IPredicate) = ICmpInst::ICMP_EQ; ;}
3650     break;
3651
3652   case 30:
3653 #line 1150 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3654     { (yyval.IPredicate) = ICmpInst::ICMP_NE; ;}
3655     break;
3656
3657   case 31:
3658 #line 1151 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3659     { (yyval.IPredicate) = ICmpInst::ICMP_SLT; ;}
3660     break;
3661
3662   case 32:
3663 #line 1151 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3664     { (yyval.IPredicate) = ICmpInst::ICMP_SGT; ;}
3665     break;
3666
3667   case 33:
3668 #line 1152 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3669     { (yyval.IPredicate) = ICmpInst::ICMP_SLE; ;}
3670     break;
3671
3672   case 34:
3673 #line 1152 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3674     { (yyval.IPredicate) = ICmpInst::ICMP_SGE; ;}
3675     break;
3676
3677   case 35:
3678 #line 1153 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3679     { (yyval.IPredicate) = ICmpInst::ICMP_ULT; ;}
3680     break;
3681
3682   case 36:
3683 #line 1153 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3684     { (yyval.IPredicate) = ICmpInst::ICMP_UGT; ;}
3685     break;
3686
3687   case 37:
3688 #line 1154 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3689     { (yyval.IPredicate) = ICmpInst::ICMP_ULE; ;}
3690     break;
3691
3692   case 38:
3693 #line 1154 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3694     { (yyval.IPredicate) = ICmpInst::ICMP_UGE; ;}
3695     break;
3696
3697   case 39:
3698 #line 1158 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3699     { (yyval.FPredicate) = FCmpInst::FCMP_OEQ; ;}
3700     break;
3701
3702   case 40:
3703 #line 1158 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3704     { (yyval.FPredicate) = FCmpInst::FCMP_ONE; ;}
3705     break;
3706
3707   case 41:
3708 #line 1159 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3709     { (yyval.FPredicate) = FCmpInst::FCMP_OLT; ;}
3710     break;
3711
3712   case 42:
3713 #line 1159 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3714     { (yyval.FPredicate) = FCmpInst::FCMP_OGT; ;}
3715     break;
3716
3717   case 43:
3718 #line 1160 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3719     { (yyval.FPredicate) = FCmpInst::FCMP_OLE; ;}
3720     break;
3721
3722   case 44:
3723 #line 1160 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3724     { (yyval.FPredicate) = FCmpInst::FCMP_OGE; ;}
3725     break;
3726
3727   case 45:
3728 #line 1161 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3729     { (yyval.FPredicate) = FCmpInst::FCMP_ORD; ;}
3730     break;
3731
3732   case 46:
3733 #line 1161 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3734     { (yyval.FPredicate) = FCmpInst::FCMP_UNO; ;}
3735     break;
3736
3737   case 47:
3738 #line 1162 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3739     { (yyval.FPredicate) = FCmpInst::FCMP_UEQ; ;}
3740     break;
3741
3742   case 48:
3743 #line 1162 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3744     { (yyval.FPredicate) = FCmpInst::FCMP_UNE; ;}
3745     break;
3746
3747   case 49:
3748 #line 1163 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3749     { (yyval.FPredicate) = FCmpInst::FCMP_ULT; ;}
3750     break;
3751
3752   case 50:
3753 #line 1163 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3754     { (yyval.FPredicate) = FCmpInst::FCMP_UGT; ;}
3755     break;
3756
3757   case 51:
3758 #line 1164 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3759     { (yyval.FPredicate) = FCmpInst::FCMP_ULE; ;}
3760     break;
3761
3762   case 52:
3763 #line 1164 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3764     { (yyval.FPredicate) = FCmpInst::FCMP_UGE; ;}
3765     break;
3766
3767   case 53:
3768 #line 1165 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3769     { (yyval.FPredicate) = FCmpInst::FCMP_TRUE; ;}
3770     break;
3771
3772   case 54:
3773 #line 1166 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3774     { (yyval.FPredicate) = FCmpInst::FCMP_FALSE; ;}
3775     break;
3776
3777   case 59:
3778 #line 1170 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3779     { (yyval.StrVal) = 0; ;}
3780     break;
3781
3782   case 60:
3783 #line 1172 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3784     { (yyval.UIntVal)=(yyvsp[(3) - (4)].UInt64Val); ;}
3785     break;
3786
3787   case 61:
3788 #line 1173 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3789     { (yyval.UIntVal)=0; ;}
3790     break;
3791
3792   case 62:
3793 #line 1177 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3794     {
3795     (yyval.StrVal) = (yyvsp[(1) - (2)].StrVal);
3796     CHECK_FOR_ERROR
3797   ;}
3798     break;
3799
3800   case 63:
3801 #line 1181 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3802     {
3803     (yyval.StrVal) = 0;
3804     CHECK_FOR_ERROR
3805   ;}
3806     break;
3807
3808   case 64:
3809 #line 1186 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3810     {
3811   (yyval.UIntVal) = (yyvsp[(1) - (2)].UIntVal);
3812   CHECK_FOR_ERROR
3813 ;}
3814     break;
3815
3816   case 68:
3817 #line 1195 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3818     {
3819     (yyval.StrVal) = 0;
3820     CHECK_FOR_ERROR
3821   ;}
3822     break;
3823
3824   case 69:
3825 #line 1200 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3826     {
3827     (yyval.StrVal) = (yyvsp[(1) - (2)].StrVal);
3828     CHECK_FOR_ERROR
3829   ;}
3830     break;
3831
3832   case 70:
3833 #line 1206 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3834     { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
3835     break;
3836
3837   case 71:
3838 #line 1207 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3839     { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
3840     break;
3841
3842   case 72:
3843 #line 1208 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3844     { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
3845     break;
3846
3847   case 73:
3848 #line 1209 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3849     { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;}
3850     break;
3851
3852   case 74:
3853 #line 1210 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3854     { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
3855     break;
3856
3857   case 75:
3858 #line 1211 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3859     { (yyval.Linkage) = GlobalValue::CommonLinkage; ;}
3860     break;
3861
3862   case 76:
3863 #line 1215 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3864     { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
3865     break;
3866
3867   case 77:
3868 #line 1216 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3869     { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
3870     break;
3871
3872   case 78:
3873 #line 1217 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3874     { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3875     break;
3876
3877   case 79:
3878 #line 1221 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3879     { (yyval.Visibility) = GlobalValue::DefaultVisibility;   ;}
3880     break;
3881
3882   case 80:
3883 #line 1222 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3884     { (yyval.Visibility) = GlobalValue::DefaultVisibility;   ;}
3885     break;
3886
3887   case 81:
3888 #line 1223 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3889     { (yyval.Visibility) = GlobalValue::HiddenVisibility;    ;}
3890     break;
3891
3892   case 82:
3893 #line 1224 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3894     { (yyval.Visibility) = GlobalValue::ProtectedVisibility; ;}
3895     break;
3896
3897   case 83:
3898 #line 1228 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3899     { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3900     break;
3901
3902   case 84:
3903 #line 1229 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3904     { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
3905     break;
3906
3907   case 85:
3908 #line 1230 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3909     { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
3910     break;
3911
3912   case 86:
3913 #line 1234 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3914     { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3915     break;
3916
3917   case 87:
3918 #line 1235 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3919     { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
3920     break;
3921
3922   case 88:
3923 #line 1236 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3924     { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
3925     break;
3926
3927   case 89:
3928 #line 1237 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3929     { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
3930     break;
3931
3932   case 90:
3933 #line 1238 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3934     { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
3935     break;
3936
3937   case 91:
3938 #line 1242 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3939     { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3940     break;
3941
3942   case 92:
3943 #line 1243 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3944     { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
3945     break;
3946
3947   case 93:
3948 #line 1244 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3949     { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
3950     break;
3951
3952   case 94:
3953 #line 1247 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3954     { (yyval.UIntVal) = CallingConv::C; ;}
3955     break;
3956
3957   case 95:
3958 #line 1248 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3959     { (yyval.UIntVal) = CallingConv::C; ;}
3960     break;
3961
3962   case 96:
3963 #line 1249 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3964     { (yyval.UIntVal) = CallingConv::Fast; ;}
3965     break;
3966
3967   case 97:
3968 #line 1250 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3969     { (yyval.UIntVal) = CallingConv::Cold; ;}
3970     break;
3971
3972   case 98:
3973 #line 1251 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3974     { (yyval.UIntVal) = CallingConv::X86_StdCall; ;}
3975     break;
3976
3977   case 99:
3978 #line 1252 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3979     { (yyval.UIntVal) = CallingConv::X86_FastCall; ;}
3980     break;
3981
3982   case 100:
3983 #line 1253 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3984     {
3985                    if ((unsigned)(yyvsp[(2) - (2)].UInt64Val) != (yyvsp[(2) - (2)].UInt64Val))
3986                      GEN_ERROR("Calling conv too large");
3987                    (yyval.UIntVal) = (yyvsp[(2) - (2)].UInt64Val);
3988                   CHECK_FOR_ERROR
3989                  ;}
3990     break;
3991
3992   case 101:
3993 #line 1260 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3994     { (yyval.Attributes) = Attribute::ZExt;      ;}
3995     break;
3996
3997   case 102:
3998 #line 1261 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3999     { (yyval.Attributes) = Attribute::ZExt;      ;}
4000     break;
4001
4002   case 103:
4003 #line 1262 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4004     { (yyval.Attributes) = Attribute::SExt;      ;}
4005     break;
4006
4007   case 104:
4008 #line 1263 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4009     { (yyval.Attributes) = Attribute::SExt;      ;}
4010     break;
4011
4012   case 105:
4013 #line 1264 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4014     { (yyval.Attributes) = Attribute::InReg;     ;}
4015     break;
4016
4017   case 106:
4018 #line 1265 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4019     { (yyval.Attributes) = Attribute::StructRet; ;}
4020     break;
4021
4022   case 107:
4023 #line 1266 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4024     { (yyval.Attributes) = Attribute::NoAlias;   ;}
4025     break;
4026
4027   case 108:
4028 #line 1267 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4029     { (yyval.Attributes) = Attribute::ByVal;     ;}
4030     break;
4031
4032   case 109:
4033 #line 1268 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4034     { (yyval.Attributes) = Attribute::Nest;      ;}
4035     break;
4036
4037   case 110:
4038 #line 1269 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4039     { (yyval.Attributes) =
4040                           Attribute::constructAlignmentFromInt((yyvsp[(2) - (2)].UInt64Val));    ;}
4041     break;
4042
4043   case 111:
4044 #line 1273 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4045     { (yyval.Attributes) = Attribute::None; ;}
4046     break;
4047
4048   case 112:
4049 #line 1274 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4050     {
4051                 (yyval.Attributes) = (yyvsp[(1) - (2)].Attributes) | (yyvsp[(2) - (2)].Attributes);
4052               ;}
4053     break;
4054
4055   case 113:
4056 #line 1279 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4057     { (yyval.Attributes) = Attribute::InReg;     ;}
4058     break;
4059
4060   case 114:
4061 #line 1280 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4062     { (yyval.Attributes) = Attribute::ZExt;     ;}
4063     break;
4064
4065   case 115:
4066 #line 1281 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4067     { (yyval.Attributes) = Attribute::SExt;     ;}
4068     break;
4069
4070   case 116:
4071 #line 1284 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4072     { (yyval.Attributes) = Attribute::None; ;}
4073     break;
4074
4075   case 117:
4076 #line 1285 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4077     {
4078                (yyval.Attributes) = (yyvsp[(1) - (2)].Attributes) | (yyvsp[(2) - (2)].Attributes);
4079              ;}
4080     break;
4081
4082   case 118:
4083 #line 1291 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4084     { (yyval.Attributes) = Attribute::NoReturn; ;}
4085     break;
4086
4087   case 119:
4088 #line 1292 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4089     { (yyval.Attributes) = Attribute::NoUnwind; ;}
4090     break;
4091
4092   case 120:
4093 #line 1293 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4094     { (yyval.Attributes) = Attribute::InReg;     ;}
4095     break;
4096
4097   case 121:
4098 #line 1294 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4099     { (yyval.Attributes) = Attribute::ZExt;     ;}
4100     break;
4101
4102   case 122:
4103 #line 1295 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4104     { (yyval.Attributes) = Attribute::SExt;     ;}
4105     break;
4106
4107   case 123:
4108 #line 1296 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4109     { (yyval.Attributes) = Attribute::ReadNone; ;}
4110     break;
4111
4112   case 124:
4113 #line 1297 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4114     { (yyval.Attributes) = Attribute::ReadOnly; ;}
4115     break;
4116
4117   case 125:
4118 #line 1298 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4119     { (yyval.Attributes) = Attribute::NoInline; ;}
4120     break;
4121
4122   case 126:
4123 #line 1299 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4124     { (yyval.Attributes) = Attribute::AlwaysInline; ;}
4125     break;
4126
4127   case 127:
4128 #line 1300 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4129     { (yyval.Attributes) = Attribute::OptimizeForSize; ;}
4130     break;
4131
4132   case 128:
4133 #line 1303 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4134     { (yyval.Attributes) = Attribute::None; ;}
4135     break;
4136
4137   case 129:
4138 #line 1304 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4139     {
4140                 (yyval.Attributes) = (yyvsp[(1) - (2)].Attributes) | (yyvsp[(2) - (2)].Attributes);
4141               ;}
4142     break;
4143
4144   case 130:
4145 #line 1310 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4146     { (yyval.StrVal) = 0; ;}
4147     break;
4148
4149   case 131:
4150 #line 1311 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4151     {
4152                 (yyval.StrVal) = (yyvsp[(2) - (2)].StrVal);
4153               ;}
4154     break;
4155
4156   case 132:
4157 #line 1318 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4158     { (yyval.UIntVal) = 0; ;}
4159     break;
4160
4161   case 133:
4162 #line 1319 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4163     {
4164   (yyval.UIntVal) = (yyvsp[(2) - (2)].UInt64Val);
4165   if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
4166     GEN_ERROR("Alignment must be a power of two");
4167   CHECK_FOR_ERROR
4168 ;}
4169     break;
4170
4171   case 134:
4172 #line 1325 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4173     { (yyval.UIntVal) = 0; ;}
4174     break;
4175
4176   case 135:
4177 #line 1326 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4178     {
4179   (yyval.UIntVal) = (yyvsp[(3) - (3)].UInt64Val);
4180   if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
4181     GEN_ERROR("Alignment must be a power of two");
4182   CHECK_FOR_ERROR
4183 ;}
4184     break;
4185
4186   case 136:
4187 #line 1335 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4188     {
4189   for (unsigned i = 0, e = (yyvsp[(2) - (2)].StrVal)->length(); i != e; ++i)
4190     if ((*(yyvsp[(2) - (2)].StrVal))[i] == '"' || (*(yyvsp[(2) - (2)].StrVal))[i] == '\\')
4191       GEN_ERROR("Invalid character in section name");
4192   (yyval.StrVal) = (yyvsp[(2) - (2)].StrVal);
4193   CHECK_FOR_ERROR
4194 ;}
4195     break;
4196
4197   case 137:
4198 #line 1343 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4199     { (yyval.StrVal) = 0; ;}
4200     break;
4201
4202   case 138:
4203 #line 1344 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4204     { (yyval.StrVal) = (yyvsp[(1) - (1)].StrVal); ;}
4205     break;
4206
4207   case 139:
4208 #line 1349 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4209     {;}
4210     break;
4211
4212   case 140:
4213 #line 1350 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4214     {;}
4215     break;
4216
4217   case 141:
4218 #line 1351 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4219     {
4220     CurGV->setSection(*(yyvsp[(1) - (1)].StrVal));
4221     delete (yyvsp[(1) - (1)].StrVal);
4222     CHECK_FOR_ERROR
4223   ;}
4224     break;
4225
4226   case 142:
4227 #line 1356 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4228     {
4229     if ((yyvsp[(2) - (2)].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[(2) - (2)].UInt64Val)))
4230       GEN_ERROR("Alignment must be a power of two");
4231     CurGV->setAlignment((yyvsp[(2) - (2)].UInt64Val));
4232     CHECK_FOR_ERROR
4233   ;}
4234     break;
4235
4236   case 150:
4237 #line 1372 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4238     {
4239     (yyval.TypeVal) = new PATypeHolder(OpaqueType::get());
4240     CHECK_FOR_ERROR
4241   ;}
4242     break;
4243
4244   case 151:
4245 #line 1376 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4246     {
4247     (yyval.TypeVal) = new PATypeHolder((yyvsp[(1) - (1)].PrimType));
4248     CHECK_FOR_ERROR
4249   ;}
4250     break;
4251
4252   case 152:
4253 #line 1380 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4254     {                             // Pointer type?
4255     if (*(yyvsp[(1) - (3)].TypeVal) == Type::LabelTy)
4256       GEN_ERROR("Cannot form a pointer to a basic block");
4257     (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(PointerType::get(*(yyvsp[(1) - (3)].TypeVal), (yyvsp[(2) - (3)].UIntVal))));
4258     delete (yyvsp[(1) - (3)].TypeVal);
4259     CHECK_FOR_ERROR
4260   ;}
4261     break;
4262
4263   case 153:
4264 #line 1387 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4265     {            // Named types are also simple types...
4266     const Type* tmp = getTypeVal((yyvsp[(1) - (1)].ValIDVal));
4267     CHECK_FOR_ERROR
4268     (yyval.TypeVal) = new PATypeHolder(tmp);
4269   ;}
4270     break;
4271
4272   case 154:
4273 #line 1392 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4274     {                   // Type UpReference
4275     if ((yyvsp[(2) - (2)].UInt64Val) > (uint64_t)~0U) GEN_ERROR("Value out of range");
4276     OpaqueType *OT = OpaqueType::get();        // Use temporary placeholder
4277     UpRefs.push_back(UpRefRecord((unsigned)(yyvsp[(2) - (2)].UInt64Val), OT));  // Add to vector...
4278     (yyval.TypeVal) = new PATypeHolder(OT);
4279     UR_OUT("New Upreference!\n");
4280     CHECK_FOR_ERROR
4281   ;}
4282     break;
4283
4284   case 155:
4285 #line 1400 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4286     {
4287     // Allow but ignore attributes on function types; this permits auto-upgrade.
4288     // FIXME: remove in LLVM 3.0.
4289     const Type *RetTy = *(yyvsp[(1) - (5)].TypeVal);
4290     if (!FunctionType::isValidReturnType(RetTy))
4291       GEN_ERROR("Invalid result type for LLVM function");
4292
4293     std::vector<const Type*> Params;
4294     TypeWithAttrsList::iterator I = (yyvsp[(3) - (5)].TypeWithAttrsList)->begin(), E = (yyvsp[(3) - (5)].TypeWithAttrsList)->end();
4295     for (; I != E; ++I ) {
4296       const Type *Ty = I->Ty->get();
4297       Params.push_back(Ty);
4298     }
4299
4300     bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
4301     if (isVarArg) Params.pop_back();
4302
4303     for (unsigned i = 0; i != Params.size(); ++i)
4304       if (!(Params[i]->isFirstClassType() || isa<OpaqueType>(Params[i])))
4305         GEN_ERROR("Function arguments must be value types!");
4306
4307     CHECK_FOR_ERROR
4308
4309     FunctionType *FT = FunctionType::get(RetTy, Params, isVarArg);
4310     delete (yyvsp[(1) - (5)].TypeVal);   // Delete the return type handle
4311     (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(FT));
4312
4313     // Delete the argument list
4314     for (I = (yyvsp[(3) - (5)].TypeWithAttrsList)->begin() ; I != E; ++I ) {
4315       delete I->Ty;
4316     }
4317     delete (yyvsp[(3) - (5)].TypeWithAttrsList);
4318
4319     CHECK_FOR_ERROR
4320   ;}
4321     break;
4322
4323   case 156:
4324 #line 1435 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4325     {
4326     // Allow but ignore attributes on function types; this permits auto-upgrade.
4327     // FIXME: remove in LLVM 3.0.
4328     std::vector<const Type*> Params;
4329     TypeWithAttrsList::iterator I = (yyvsp[(3) - (5)].TypeWithAttrsList)->begin(), E = (yyvsp[(3) - (5)].TypeWithAttrsList)->end();
4330     for ( ; I != E; ++I ) {
4331       const Type* Ty = I->Ty->get();
4332       Params.push_back(Ty);
4333     }
4334
4335     bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
4336     if (isVarArg) Params.pop_back();
4337
4338     for (unsigned i = 0; i != Params.size(); ++i)
4339       if (!(Params[i]->isFirstClassType() || isa<OpaqueType>(Params[i])))
4340         GEN_ERROR("Function arguments must be value types!");
4341
4342     CHECK_FOR_ERROR
4343
4344     FunctionType *FT = FunctionType::get((yyvsp[(1) - (5)].PrimType), Params, isVarArg);
4345     (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(FT));
4346
4347     // Delete the argument list
4348     for (I = (yyvsp[(3) - (5)].TypeWithAttrsList)->begin() ; I != E; ++I ) {
4349       delete I->Ty;
4350     }
4351     delete (yyvsp[(3) - (5)].TypeWithAttrsList);
4352
4353     CHECK_FOR_ERROR
4354   ;}
4355     break;
4356
4357   case 157:
4358 #line 1466 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4359     {          // Sized array type?
4360     (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(ArrayType::get(*(yyvsp[(4) - (5)].TypeVal), (yyvsp[(2) - (5)].UInt64Val))));
4361     delete (yyvsp[(4) - (5)].TypeVal);
4362     CHECK_FOR_ERROR
4363   ;}
4364     break;
4365
4366   case 158:
4367 #line 1471 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4368     {          // Vector type?
4369      const llvm::Type* ElemTy = (yyvsp[(4) - (5)].TypeVal)->get();
4370      if ((unsigned)(yyvsp[(2) - (5)].UInt64Val) != (yyvsp[(2) - (5)].UInt64Val))
4371         GEN_ERROR("Unsigned result not equal to signed result");
4372      if (!ElemTy->isFloatingPoint() && !ElemTy->isInteger())
4373         GEN_ERROR("Element type of a VectorType must be primitive");
4374      (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(VectorType::get(*(yyvsp[(4) - (5)].TypeVal), (unsigned)(yyvsp[(2) - (5)].UInt64Val))));
4375      delete (yyvsp[(4) - (5)].TypeVal);
4376      CHECK_FOR_ERROR
4377   ;}
4378     break;
4379
4380   case 159:
4381 #line 1481 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4382     {                        // Structure type?
4383     std::vector<const Type*> Elements;
4384     for (std::list<llvm::PATypeHolder>::iterator I = (yyvsp[(2) - (3)].TypeList)->begin(),
4385            E = (yyvsp[(2) - (3)].TypeList)->end(); I != E; ++I)
4386       Elements.push_back(*I);
4387
4388     (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
4389     delete (yyvsp[(2) - (3)].TypeList);
4390     CHECK_FOR_ERROR
4391   ;}
4392     break;
4393
4394   case 160:
4395 #line 1491 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4396     {                                  // Empty structure type?
4397     (yyval.TypeVal) = new PATypeHolder(StructType::get(std::vector<const Type*>()));
4398     CHECK_FOR_ERROR
4399   ;}
4400     break;
4401
4402   case 161:
4403 #line 1495 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4404     {
4405     std::vector<const Type*> Elements;
4406     for (std::list<llvm::PATypeHolder>::iterator I = (yyvsp[(3) - (5)].TypeList)->begin(),
4407            E = (yyvsp[(3) - (5)].TypeList)->end(); I != E; ++I)
4408       Elements.push_back(*I);
4409
4410     (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
4411     delete (yyvsp[(3) - (5)].TypeList);
4412     CHECK_FOR_ERROR
4413   ;}
4414     break;
4415
4416   case 162:
4417 #line 1505 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4418     {                         // Empty structure type?
4419     (yyval.TypeVal) = new PATypeHolder(StructType::get(std::vector<const Type*>(), true));
4420     CHECK_FOR_ERROR
4421   ;}
4422     break;
4423
4424   case 163:
4425 #line 1512 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4426     {
4427     // Allow but ignore attributes on function types; this permits auto-upgrade.
4428     // FIXME: remove in LLVM 3.0.
4429     (yyval.TypeWithAttrs).Ty = (yyvsp[(1) - (2)].TypeVal);
4430     (yyval.TypeWithAttrs).Attrs = Attribute::None;
4431   ;}
4432     break;
4433
4434   case 164:
4435 #line 1521 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4436     {
4437     if (!UpRefs.empty())
4438       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (1)].TypeVal))->getDescription());
4439     if (!(*(yyvsp[(1) - (1)].TypeVal))->isFirstClassType() && !isa<StructType>((yyvsp[(1) - (1)].TypeVal)->get()))
4440       GEN_ERROR("LLVM functions cannot return aggregate types");
4441     (yyval.TypeVal) = (yyvsp[(1) - (1)].TypeVal);
4442   ;}
4443     break;
4444
4445   case 165:
4446 #line 1528 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4447     {
4448     (yyval.TypeVal) = new PATypeHolder(Type::VoidTy);
4449   ;}
4450     break;
4451
4452   case 166:
4453 #line 1533 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4454     {
4455     (yyval.TypeWithAttrsList) = new TypeWithAttrsList();
4456     (yyval.TypeWithAttrsList)->push_back((yyvsp[(1) - (1)].TypeWithAttrs));
4457     CHECK_FOR_ERROR
4458   ;}
4459     break;
4460
4461   case 167:
4462 #line 1538 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4463     {
4464     ((yyval.TypeWithAttrsList)=(yyvsp[(1) - (3)].TypeWithAttrsList))->push_back((yyvsp[(3) - (3)].TypeWithAttrs));
4465     CHECK_FOR_ERROR
4466   ;}
4467     break;
4468
4469   case 169:
4470 #line 1546 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4471     {
4472     (yyval.TypeWithAttrsList)=(yyvsp[(1) - (3)].TypeWithAttrsList);
4473     TypeWithAttrs TWA; TWA.Attrs = Attribute::None;
4474     TWA.Ty = new PATypeHolder(Type::VoidTy);
4475     (yyval.TypeWithAttrsList)->push_back(TWA);
4476     CHECK_FOR_ERROR
4477   ;}
4478     break;
4479
4480   case 170:
4481 #line 1553 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4482     {
4483     (yyval.TypeWithAttrsList) = new TypeWithAttrsList;
4484     TypeWithAttrs TWA; TWA.Attrs = Attribute::None;
4485     TWA.Ty = new PATypeHolder(Type::VoidTy);
4486     (yyval.TypeWithAttrsList)->push_back(TWA);
4487     CHECK_FOR_ERROR
4488   ;}
4489     break;
4490
4491   case 171:
4492 #line 1560 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4493     {
4494     (yyval.TypeWithAttrsList) = new TypeWithAttrsList();
4495     CHECK_FOR_ERROR
4496   ;}
4497     break;
4498
4499   case 172:
4500 #line 1568 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4501     {
4502     (yyval.TypeList) = new std::list<PATypeHolder>();
4503     (yyval.TypeList)->push_back(*(yyvsp[(1) - (1)].TypeVal));
4504     delete (yyvsp[(1) - (1)].TypeVal);
4505     CHECK_FOR_ERROR
4506   ;}
4507     break;
4508
4509   case 173:
4510 #line 1574 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4511     {
4512     ((yyval.TypeList)=(yyvsp[(1) - (3)].TypeList))->push_back(*(yyvsp[(3) - (3)].TypeVal));
4513     delete (yyvsp[(3) - (3)].TypeVal);
4514     CHECK_FOR_ERROR
4515   ;}
4516     break;
4517
4518   case 174:
4519 #line 1586 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4520     { // Nonempty unsized arr
4521     if (!UpRefs.empty())
4522       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (4)].TypeVal))->getDescription());
4523     const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[(1) - (4)].TypeVal)->get());
4524     if (ATy == 0)
4525       GEN_ERROR("Cannot make array constant with type: '" +
4526                      (*(yyvsp[(1) - (4)].TypeVal))->getDescription() + "'");
4527     const Type *ETy = ATy->getElementType();
4528     uint64_t NumElements = ATy->getNumElements();
4529
4530     // Verify that we have the correct size...
4531     if (NumElements != uint64_t(-1) && NumElements != (yyvsp[(3) - (4)].ConstVector)->size())
4532       GEN_ERROR("Type mismatch: constant sized array initialized with " +
4533                      utostr((yyvsp[(3) - (4)].ConstVector)->size()) +  " arguments, but has size of " +
4534                      utostr(NumElements) + "");
4535
4536     // Verify all elements are correct type!
4537     for (unsigned i = 0; i < (yyvsp[(3) - (4)].ConstVector)->size(); i++) {
4538       if (ETy != (*(yyvsp[(3) - (4)].ConstVector))[i]->getType())
4539         GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
4540                        ETy->getDescription() +"' as required!\nIt is of type '"+
4541                        (*(yyvsp[(3) - (4)].ConstVector))[i]->getType()->getDescription() + "'.");
4542     }
4543
4544     (yyval.ConstVal) = ConstantArray::get(ATy, *(yyvsp[(3) - (4)].ConstVector));
4545     delete (yyvsp[(1) - (4)].TypeVal); delete (yyvsp[(3) - (4)].ConstVector);
4546     CHECK_FOR_ERROR
4547   ;}
4548     break;
4549
4550   case 175:
4551 #line 1614 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4552     {
4553     if (!UpRefs.empty())
4554       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription());
4555     const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[(1) - (3)].TypeVal)->get());
4556     if (ATy == 0)
4557       GEN_ERROR("Cannot make array constant with type: '" +
4558                      (*(yyvsp[(1) - (3)].TypeVal))->getDescription() + "'");
4559
4560     uint64_t NumElements = ATy->getNumElements();
4561     if (NumElements != uint64_t(-1) && NumElements != 0)
4562       GEN_ERROR("Type mismatch: constant sized array initialized with 0"
4563                      " arguments, but has size of " + utostr(NumElements) +"");
4564     (yyval.ConstVal) = ConstantArray::get(ATy, std::vector<Constant*>());
4565     delete (yyvsp[(1) - (3)].TypeVal);
4566     CHECK_FOR_ERROR
4567   ;}
4568     break;
4569
4570   case 176:
4571 #line 1630 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4572     {
4573     if (!UpRefs.empty())
4574       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription());
4575     const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[(1) - (3)].TypeVal)->get());
4576     if (ATy == 0)
4577       GEN_ERROR("Cannot make array constant with type: '" +
4578                      (*(yyvsp[(1) - (3)].TypeVal))->getDescription() + "'");
4579
4580     uint64_t NumElements = ATy->getNumElements();
4581     const Type *ETy = ATy->getElementType();
4582     if (NumElements != uint64_t(-1) && NumElements != (yyvsp[(3) - (3)].StrVal)->length())
4583       GEN_ERROR("Can't build string constant of size " +
4584                      utostr((yyvsp[(3) - (3)].StrVal)->length()) +
4585                      " when array has size " + utostr(NumElements) + "");
4586     std::vector<Constant*> Vals;
4587     if (ETy == Type::Int8Ty) {
4588       for (uint64_t i = 0; i < (yyvsp[(3) - (3)].StrVal)->length(); ++i)
4589         Vals.push_back(ConstantInt::get(ETy, (*(yyvsp[(3) - (3)].StrVal))[i]));
4590     } else {
4591       delete (yyvsp[(3) - (3)].StrVal);
4592       GEN_ERROR("Cannot build string arrays of non byte sized elements");
4593     }
4594     delete (yyvsp[(3) - (3)].StrVal);
4595     (yyval.ConstVal) = ConstantArray::get(ATy, Vals);
4596     delete (yyvsp[(1) - (3)].TypeVal);
4597     CHECK_FOR_ERROR
4598   ;}
4599     break;
4600
4601   case 177:
4602 #line 1657 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4603     { // Nonempty unsized arr
4604     if (!UpRefs.empty())
4605       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (4)].TypeVal))->getDescription());
4606     const VectorType *PTy = dyn_cast<VectorType>((yyvsp[(1) - (4)].TypeVal)->get());
4607     if (PTy == 0)
4608       GEN_ERROR("Cannot make packed constant with type: '" +
4609                      (*(yyvsp[(1) - (4)].TypeVal))->getDescription() + "'");
4610     const Type *ETy = PTy->getElementType();
4611     unsigned NumElements = PTy->getNumElements();
4612
4613     // Verify that we have the correct size...
4614     if (NumElements != unsigned(-1) && NumElements != (unsigned)(yyvsp[(3) - (4)].ConstVector)->size())
4615       GEN_ERROR("Type mismatch: constant sized packed initialized with " +
4616                      utostr((yyvsp[(3) - (4)].ConstVector)->size()) +  " arguments, but has size of " +
4617                      utostr(NumElements) + "");
4618
4619     // Verify all elements are correct type!
4620     for (unsigned i = 0; i < (yyvsp[(3) - (4)].ConstVector)->size(); i++) {
4621       if (ETy != (*(yyvsp[(3) - (4)].ConstVector))[i]->getType())
4622         GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
4623            ETy->getDescription() +"' as required!\nIt is of type '"+
4624            (*(yyvsp[(3) - (4)].ConstVector))[i]->getType()->getDescription() + "'.");
4625     }
4626
4627     (yyval.ConstVal) = ConstantVector::get(PTy, *(yyvsp[(3) - (4)].ConstVector));
4628     delete (yyvsp[(1) - (4)].TypeVal); delete (yyvsp[(3) - (4)].ConstVector);
4629     CHECK_FOR_ERROR
4630   ;}
4631     break;
4632
4633   case 178:
4634 #line 1685 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4635     {
4636     const StructType *STy = dyn_cast<StructType>((yyvsp[(1) - (4)].TypeVal)->get());
4637     if (STy == 0)
4638       GEN_ERROR("Cannot make struct constant with type: '" +
4639                      (*(yyvsp[(1) - (4)].TypeVal))->getDescription() + "'");
4640
4641     if ((yyvsp[(3) - (4)].ConstVector)->size() != STy->getNumContainedTypes())
4642       GEN_ERROR("Illegal number of initializers for structure type");
4643
4644     // Check to ensure that constants are compatible with the type initializer!
4645     for (unsigned i = 0, e = (yyvsp[(3) - (4)].ConstVector)->size(); i != e; ++i)
4646       if ((*(yyvsp[(3) - (4)].ConstVector))[i]->getType() != STy->getElementType(i))
4647         GEN_ERROR("Expected type '" +
4648                        STy->getElementType(i)->getDescription() +
4649                        "' for element #" + utostr(i) +
4650                        " of structure initializer");
4651
4652     // Check to ensure that Type is not packed
4653     if (STy->isPacked())
4654       GEN_ERROR("Unpacked Initializer to vector type '" +
4655                 STy->getDescription() + "'");
4656
4657     (yyval.ConstVal) = ConstantStruct::get(STy, *(yyvsp[(3) - (4)].ConstVector));
4658     delete (yyvsp[(1) - (4)].TypeVal); delete (yyvsp[(3) - (4)].ConstVector);
4659     CHECK_FOR_ERROR
4660   ;}
4661     break;
4662
4663   case 179:
4664 #line 1711 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4665     {
4666     if (!UpRefs.empty())
4667       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription());
4668     const StructType *STy = dyn_cast<StructType>((yyvsp[(1) - (3)].TypeVal)->get());
4669     if (STy == 0)
4670       GEN_ERROR("Cannot make struct constant with type: '" +
4671                      (*(yyvsp[(1) - (3)].TypeVal))->getDescription() + "'");
4672
4673     if (STy->getNumContainedTypes() != 0)
4674       GEN_ERROR("Illegal number of initializers for structure type");
4675
4676     // Check to ensure that Type is not packed
4677     if (STy->isPacked())
4678       GEN_ERROR("Unpacked Initializer to vector type '" +
4679                 STy->getDescription() + "'");
4680
4681     (yyval.ConstVal) = ConstantStruct::get(STy, std::vector<Constant*>());
4682     delete (yyvsp[(1) - (3)].TypeVal);
4683     CHECK_FOR_ERROR
4684   ;}
4685     break;
4686
4687   case 180:
4688 #line 1731 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4689     {
4690     const StructType *STy = dyn_cast<StructType>((yyvsp[(1) - (6)].TypeVal)->get());
4691     if (STy == 0)
4692       GEN_ERROR("Cannot make struct constant with type: '" +
4693                      (*(yyvsp[(1) - (6)].TypeVal))->getDescription() + "'");
4694
4695     if ((yyvsp[(4) - (6)].ConstVector)->size() != STy->getNumContainedTypes())
4696       GEN_ERROR("Illegal number of initializers for structure type");
4697
4698     // Check to ensure that constants are compatible with the type initializer!
4699     for (unsigned i = 0, e = (yyvsp[(4) - (6)].ConstVector)->size(); i != e; ++i)
4700       if ((*(yyvsp[(4) - (6)].ConstVector))[i]->getType() != STy->getElementType(i))
4701         GEN_ERROR("Expected type '" +
4702                        STy->getElementType(i)->getDescription() +
4703                        "' for element #" + utostr(i) +
4704                        " of structure initializer");
4705
4706     // Check to ensure that Type is packed
4707     if (!STy->isPacked())
4708       GEN_ERROR("Vector initializer to non-vector type '" +
4709                 STy->getDescription() + "'");
4710
4711     (yyval.ConstVal) = ConstantStruct::get(STy, *(yyvsp[(4) - (6)].ConstVector));
4712     delete (yyvsp[(1) - (6)].TypeVal); delete (yyvsp[(4) - (6)].ConstVector);
4713     CHECK_FOR_ERROR
4714   ;}
4715     break;
4716
4717   case 181:
4718 #line 1757 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4719     {
4720     if (!UpRefs.empty())
4721       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (5)].TypeVal))->getDescription());
4722     const StructType *STy = dyn_cast<StructType>((yyvsp[(1) - (5)].TypeVal)->get());
4723     if (STy == 0)
4724       GEN_ERROR("Cannot make struct constant with type: '" +
4725                      (*(yyvsp[(1) - (5)].TypeVal))->getDescription() + "'");
4726
4727     if (STy->getNumContainedTypes() != 0)
4728       GEN_ERROR("Illegal number of initializers for structure type");
4729
4730     // Check to ensure that Type is packed
4731     if (!STy->isPacked())
4732       GEN_ERROR("Vector initializer to non-vector type '" +
4733                 STy->getDescription() + "'");
4734
4735     (yyval.ConstVal) = ConstantStruct::get(STy, std::vector<Constant*>());
4736     delete (yyvsp[(1) - (5)].TypeVal);
4737     CHECK_FOR_ERROR
4738   ;}
4739     break;
4740
4741   case 182:
4742 #line 1777 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4743     {
4744     if (!UpRefs.empty())
4745       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
4746     const PointerType *PTy = dyn_cast<PointerType>((yyvsp[(1) - (2)].TypeVal)->get());
4747     if (PTy == 0)
4748       GEN_ERROR("Cannot make null pointer constant with type: '" +
4749                      (*(yyvsp[(1) - (2)].TypeVal))->getDescription() + "'");
4750
4751     (yyval.ConstVal) = ConstantPointerNull::get(PTy);
4752     delete (yyvsp[(1) - (2)].TypeVal);
4753     CHECK_FOR_ERROR
4754   ;}
4755     break;
4756
4757   case 183:
4758 #line 1789 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4759     {
4760     if (!UpRefs.empty())
4761       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
4762     (yyval.ConstVal) = UndefValue::get((yyvsp[(1) - (2)].TypeVal)->get());
4763     delete (yyvsp[(1) - (2)].TypeVal);
4764     CHECK_FOR_ERROR
4765   ;}
4766     break;
4767
4768   case 184:
4769 #line 1796 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4770     {
4771     if (!UpRefs.empty())
4772       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
4773     const PointerType *Ty = dyn_cast<PointerType>((yyvsp[(1) - (2)].TypeVal)->get());
4774     if (Ty == 0)
4775       GEN_ERROR("Global const reference must be a pointer type " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
4776
4777     // ConstExprs can exist in the body of a function, thus creating
4778     // GlobalValues whenever they refer to a variable.  Because we are in
4779     // the context of a function, getExistingVal will search the functions
4780     // symbol table instead of the module symbol table for the global symbol,
4781     // which throws things all off.  To get around this, we just tell
4782     // getExistingVal that we are at global scope here.
4783     //
4784     Function *SavedCurFn = CurFun.CurrentFunction;
4785     CurFun.CurrentFunction = 0;
4786
4787     Value *V = getExistingVal(Ty, (yyvsp[(2) - (2)].ValIDVal));
4788     CHECK_FOR_ERROR
4789
4790     CurFun.CurrentFunction = SavedCurFn;
4791
4792     // If this is an initializer for a constant pointer, which is referencing a
4793     // (currently) undefined variable, create a stub now that shall be replaced
4794     // in the future with the right type of variable.
4795     //
4796     if (V == 0) {
4797       assert(isa<PointerType>(Ty) && "Globals may only be used as pointers!");
4798       const PointerType *PT = cast<PointerType>(Ty);
4799
4800       // First check to see if the forward references value is already created!
4801       PerModuleInfo::GlobalRefsType::iterator I =
4802         CurModule.GlobalRefs.find(std::make_pair(PT, (yyvsp[(2) - (2)].ValIDVal)));
4803
4804       if (I != CurModule.GlobalRefs.end()) {
4805         V = I->second;             // Placeholder already exists, use it...
4806         (yyvsp[(2) - (2)].ValIDVal).destroy();
4807       } else {
4808         std::string Name;
4809         if ((yyvsp[(2) - (2)].ValIDVal).Type == ValID::GlobalName)
4810           Name = (yyvsp[(2) - (2)].ValIDVal).getName();
4811         else if ((yyvsp[(2) - (2)].ValIDVal).Type != ValID::GlobalID)
4812           GEN_ERROR("Invalid reference to global");
4813
4814         // Create the forward referenced global.
4815         GlobalValue *GV;
4816         if (const FunctionType *FTy =
4817                  dyn_cast<FunctionType>(PT->getElementType())) {
4818           GV = Function::Create(FTy, GlobalValue::ExternalWeakLinkage, Name,
4819                                 CurModule.CurrentModule);
4820         } else {
4821           GV = new GlobalVariable(PT->getElementType(), false,
4822                                   GlobalValue::ExternalWeakLinkage, 0,
4823                                   Name, CurModule.CurrentModule);
4824         }
4825
4826         // Keep track of the fact that we have a forward ref to recycle it
4827         CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, (yyvsp[(2) - (2)].ValIDVal)), GV));
4828         V = GV;
4829       }
4830     }
4831
4832     (yyval.ConstVal) = cast<GlobalValue>(V);
4833     delete (yyvsp[(1) - (2)].TypeVal);            // Free the type handle
4834     CHECK_FOR_ERROR
4835   ;}
4836     break;
4837
4838   case 185:
4839 #line 1862 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4840     {
4841     if (!UpRefs.empty())
4842       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
4843     if ((yyvsp[(1) - (2)].TypeVal)->get() != (yyvsp[(2) - (2)].ConstVal)->getType())
4844       GEN_ERROR("Mismatched types for constant expression: " +
4845         (*(yyvsp[(1) - (2)].TypeVal))->getDescription() + " and " + (yyvsp[(2) - (2)].ConstVal)->getType()->getDescription());
4846     (yyval.ConstVal) = (yyvsp[(2) - (2)].ConstVal);
4847     delete (yyvsp[(1) - (2)].TypeVal);
4848     CHECK_FOR_ERROR
4849   ;}
4850     break;
4851
4852   case 186:
4853 #line 1872 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4854     {
4855     if (!UpRefs.empty())
4856       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
4857     const Type *Ty = (yyvsp[(1) - (2)].TypeVal)->get();
4858     if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty))
4859       GEN_ERROR("Cannot create a null initialized value of this type");
4860     (yyval.ConstVal) = Constant::getNullValue(Ty);
4861     delete (yyvsp[(1) - (2)].TypeVal);
4862     CHECK_FOR_ERROR
4863   ;}
4864     break;
4865
4866   case 187:
4867 #line 1882 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4868     {      // integral constants
4869     if (IntegerType *IT = dyn_cast<IntegerType>((yyvsp[(1) - (2)].TypeVal)->get())) {
4870       if (!ConstantInt::isValueValidForType(IT, (yyvsp[(2) - (2)].SInt64Val)))
4871         GEN_ERROR("Constant value doesn't fit in type");
4872       (yyval.ConstVal) = ConstantInt::get(IT, (yyvsp[(2) - (2)].SInt64Val), true);
4873     } else {
4874       GEN_ERROR("integer constant must have integer type");
4875     }
4876     delete (yyvsp[(1) - (2)].TypeVal);
4877     CHECK_FOR_ERROR
4878   ;}
4879     break;
4880
4881   case 188:
4882 #line 1893 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4883     {      // arbitrary precision integer constants
4884     if (IntegerType *IT = dyn_cast<IntegerType>((yyvsp[(1) - (2)].TypeVal)->get())) {
4885       if ((yyvsp[(2) - (2)].APIntVal)->getBitWidth() > IT->getBitWidth())
4886         GEN_ERROR("Constant value does not fit in type");
4887       (yyvsp[(2) - (2)].APIntVal)->sextOrTrunc(IT->getBitWidth());
4888       (yyval.ConstVal) = ConstantInt::get(*(yyvsp[(2) - (2)].APIntVal));
4889     } else {
4890       GEN_ERROR("integer constant must have integer type");
4891     }
4892     delete (yyvsp[(1) - (2)].TypeVal);
4893     delete (yyvsp[(2) - (2)].APIntVal);
4894     CHECK_FOR_ERROR
4895   ;}
4896     break;
4897
4898   case 189:
4899 #line 1906 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4900     {      // integral constants
4901     if (IntegerType *IT = dyn_cast<IntegerType>((yyvsp[(1) - (2)].TypeVal)->get())) {
4902       if (!ConstantInt::isValueValidForType(IT, (yyvsp[(2) - (2)].UInt64Val)))
4903         GEN_ERROR("Constant value doesn't fit in type");
4904       (yyval.ConstVal) = ConstantInt::get(IT, (yyvsp[(2) - (2)].UInt64Val), false);
4905     } else {
4906       GEN_ERROR("integer constant must have integer type");
4907     }
4908     delete (yyvsp[(1) - (2)].TypeVal);
4909     CHECK_FOR_ERROR
4910   ;}
4911     break;
4912
4913   case 190:
4914 #line 1917 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4915     {      // arbitrary precision integer constants
4916     if (IntegerType *IT = dyn_cast<IntegerType>((yyvsp[(1) - (2)].TypeVal)->get())) {
4917       if ((yyvsp[(2) - (2)].APIntVal)->getBitWidth() > IT->getBitWidth())
4918         GEN_ERROR("Constant value does not fit in type");
4919       (yyvsp[(2) - (2)].APIntVal)->zextOrTrunc(IT->getBitWidth());
4920       (yyval.ConstVal) = ConstantInt::get(*(yyvsp[(2) - (2)].APIntVal));
4921     } else {
4922       GEN_ERROR("integer constant must have integer type");
4923     }
4924
4925     delete (yyvsp[(2) - (2)].APIntVal);
4926     delete (yyvsp[(1) - (2)].TypeVal);
4927     CHECK_FOR_ERROR
4928   ;}
4929     break;
4930
4931   case 191:
4932 #line 1931 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4933     {                      // Boolean constants
4934     if ((yyvsp[(1) - (2)].TypeVal)->get() != Type::Int1Ty)
4935       GEN_ERROR("Constant true must have type i1");
4936     (yyval.ConstVal) = ConstantInt::getTrue();
4937     delete (yyvsp[(1) - (2)].TypeVal);
4938     CHECK_FOR_ERROR
4939   ;}
4940     break;
4941
4942   case 192:
4943 #line 1938 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4944     {                     // Boolean constants
4945     if ((yyvsp[(1) - (2)].TypeVal)->get() != Type::Int1Ty)
4946       GEN_ERROR("Constant false must have type i1");
4947     (yyval.ConstVal) = ConstantInt::getFalse();
4948     delete (yyvsp[(1) - (2)].TypeVal);
4949     CHECK_FOR_ERROR
4950   ;}
4951     break;
4952
4953   case 193:
4954 #line 1945 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4955     {                   // Floating point constants
4956     if (!ConstantFP::isValueValidForType((yyvsp[(1) - (2)].TypeVal)->get(), *(yyvsp[(2) - (2)].FPVal)))
4957       GEN_ERROR("Floating point constant invalid for type");
4958
4959     // Lexer has no type info, so builds all float and double FP constants
4960     // as double.  Fix this here.  Long double is done right.
4961     if (&(yyvsp[(2) - (2)].FPVal)->getSemantics()==&APFloat::IEEEdouble && (yyvsp[(1) - (2)].TypeVal)->get()==Type::FloatTy) {
4962       bool ignored;
4963       (yyvsp[(2) - (2)].FPVal)->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven,
4964                   &ignored);
4965     }
4966     (yyval.ConstVal) = ConstantFP::get(*(yyvsp[(2) - (2)].FPVal));
4967     delete (yyvsp[(1) - (2)].TypeVal);
4968     delete (yyvsp[(2) - (2)].FPVal);
4969     CHECK_FOR_ERROR
4970   ;}
4971     break;
4972
4973   case 194:
4974 #line 1963 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4975     {
4976     if (!UpRefs.empty())
4977       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(5) - (6)].TypeVal))->getDescription());
4978     Constant *Val = (yyvsp[(3) - (6)].ConstVal);
4979     const Type *DestTy = (yyvsp[(5) - (6)].TypeVal)->get();
4980     if (!CastInst::castIsValid((yyvsp[(1) - (6)].CastOpVal), (yyvsp[(3) - (6)].ConstVal), DestTy))
4981       GEN_ERROR("invalid cast opcode for cast from '" +
4982                 Val->getType()->getDescription() + "' to '" +
4983                 DestTy->getDescription() + "'");
4984     (yyval.ConstVal) = ConstantExpr::getCast((yyvsp[(1) - (6)].CastOpVal), (yyvsp[(3) - (6)].ConstVal), DestTy);
4985     delete (yyvsp[(5) - (6)].TypeVal);
4986   ;}
4987     break;
4988
4989   case 195:
4990 #line 1975 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4991     {
4992     if (!isa<PointerType>((yyvsp[(3) - (5)].ConstVal)->getType()))
4993       GEN_ERROR("GetElementPtr requires a pointer operand");
4994
4995     const Type *IdxTy =
4996       GetElementPtrInst::getIndexedType((yyvsp[(3) - (5)].ConstVal)->getType(), (yyvsp[(4) - (5)].ValueList)->begin(), (yyvsp[(4) - (5)].ValueList)->end());
4997     if (!IdxTy)
4998       GEN_ERROR("Index list invalid for constant getelementptr");
4999
5000     SmallVector<Constant*, 8> IdxVec;
5001     for (unsigned i = 0, e = (yyvsp[(4) - (5)].ValueList)->size(); i != e; ++i)
5002       if (Constant *C = dyn_cast<Constant>((*(yyvsp[(4) - (5)].ValueList))[i]))
5003         IdxVec.push_back(C);
5004       else
5005         GEN_ERROR("Indices to constant getelementptr must be constants");
5006
5007     delete (yyvsp[(4) - (5)].ValueList);
5008
5009     (yyval.ConstVal) = ConstantExpr::getGetElementPtr((yyvsp[(3) - (5)].ConstVal), &IdxVec[0], IdxVec.size());
5010     CHECK_FOR_ERROR
5011   ;}
5012     break;
5013
5014   case 196:
5015 #line 1996 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5016     {
5017     if ((yyvsp[(3) - (8)].ConstVal)->getType() != Type::Int1Ty)
5018       GEN_ERROR("Select condition must be of boolean type");
5019     if ((yyvsp[(5) - (8)].ConstVal)->getType() != (yyvsp[(7) - (8)].ConstVal)->getType())
5020       GEN_ERROR("Select operand types must match");
5021     (yyval.ConstVal) = ConstantExpr::getSelect((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal));
5022     CHECK_FOR_ERROR
5023   ;}
5024     break;
5025
5026   case 197:
5027 #line 2004 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5028     {
5029     if ((yyvsp[(3) - (6)].ConstVal)->getType() != (yyvsp[(5) - (6)].ConstVal)->getType())
5030       GEN_ERROR("Binary operator types must match");
5031     CHECK_FOR_ERROR;
5032     (yyval.ConstVal) = ConstantExpr::get((yyvsp[(1) - (6)].BinaryOpVal), (yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal));
5033   ;}
5034     break;
5035
5036   case 198:
5037 #line 2010 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5038     {
5039     if ((yyvsp[(3) - (6)].ConstVal)->getType() != (yyvsp[(5) - (6)].ConstVal)->getType())
5040       GEN_ERROR("Logical operator types must match");
5041     if (!(yyvsp[(3) - (6)].ConstVal)->getType()->isInteger()) {
5042       if (!isa<VectorType>((yyvsp[(3) - (6)].ConstVal)->getType()) ||
5043           !cast<VectorType>((yyvsp[(3) - (6)].ConstVal)->getType())->getElementType()->isInteger())
5044         GEN_ERROR("Logical operator requires integral operands");
5045     }
5046     (yyval.ConstVal) = ConstantExpr::get((yyvsp[(1) - (6)].BinaryOpVal), (yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal));
5047     CHECK_FOR_ERROR
5048   ;}
5049     break;
5050
5051   case 199:
5052 #line 2021 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5053     {
5054     if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType())
5055       GEN_ERROR("icmp operand types must match");
5056     (yyval.ConstVal) = ConstantExpr::getICmp((yyvsp[(2) - (7)].IPredicate), (yyvsp[(4) - (7)].ConstVal), (yyvsp[(6) - (7)].ConstVal));
5057   ;}
5058     break;
5059
5060   case 200:
5061 #line 2026 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5062     {
5063     if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType())
5064       GEN_ERROR("fcmp operand types must match");
5065     (yyval.ConstVal) = ConstantExpr::getFCmp((yyvsp[(2) - (7)].FPredicate), (yyvsp[(4) - (7)].ConstVal), (yyvsp[(6) - (7)].ConstVal));
5066   ;}
5067     break;
5068
5069   case 201:
5070 #line 2031 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5071     {
5072     if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType())
5073       GEN_ERROR("vicmp operand types must match");
5074     (yyval.ConstVal) = ConstantExpr::getVICmp((yyvsp[(2) - (7)].IPredicate), (yyvsp[(4) - (7)].ConstVal), (yyvsp[(6) - (7)].ConstVal));
5075   ;}
5076     break;
5077
5078   case 202:
5079 #line 2036 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5080     {
5081     if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType())
5082       GEN_ERROR("vfcmp operand types must match");
5083     (yyval.ConstVal) = ConstantExpr::getVFCmp((yyvsp[(2) - (7)].FPredicate), (yyvsp[(4) - (7)].ConstVal), (yyvsp[(6) - (7)].ConstVal));
5084   ;}
5085     break;
5086
5087   case 203:
5088 #line 2041 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5089     {
5090     if (!ExtractElementInst::isValidOperands((yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal)))
5091       GEN_ERROR("Invalid extractelement operands");
5092     (yyval.ConstVal) = ConstantExpr::getExtractElement((yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal));
5093     CHECK_FOR_ERROR
5094   ;}
5095     break;
5096
5097   case 204:
5098 #line 2047 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5099     {
5100     if (!InsertElementInst::isValidOperands((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal)))
5101       GEN_ERROR("Invalid insertelement operands");
5102     (yyval.ConstVal) = ConstantExpr::getInsertElement((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal));
5103     CHECK_FOR_ERROR
5104   ;}
5105     break;
5106
5107   case 205:
5108 #line 2053 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5109     {
5110     if (!ShuffleVectorInst::isValidOperands((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal)))
5111       GEN_ERROR("Invalid shufflevector operands");
5112     (yyval.ConstVal) = ConstantExpr::getShuffleVector((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal));
5113     CHECK_FOR_ERROR
5114   ;}
5115     break;
5116
5117   case 206:
5118 #line 2059 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5119     {
5120     if (!isa<StructType>((yyvsp[(3) - (5)].ConstVal)->getType()) && !isa<ArrayType>((yyvsp[(3) - (5)].ConstVal)->getType()))
5121       GEN_ERROR("ExtractValue requires an aggregate operand");
5122
5123     (yyval.ConstVal) = ConstantExpr::getExtractValue((yyvsp[(3) - (5)].ConstVal), &(*(yyvsp[(4) - (5)].ConstantList))[0], (yyvsp[(4) - (5)].ConstantList)->size());
5124     delete (yyvsp[(4) - (5)].ConstantList);
5125     CHECK_FOR_ERROR
5126   ;}
5127     break;
5128
5129   case 207:
5130 #line 2067 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5131     {
5132     if (!isa<StructType>((yyvsp[(3) - (7)].ConstVal)->getType()) && !isa<ArrayType>((yyvsp[(3) - (7)].ConstVal)->getType()))
5133       GEN_ERROR("InsertValue requires an aggregate operand");
5134
5135     (yyval.ConstVal) = ConstantExpr::getInsertValue((yyvsp[(3) - (7)].ConstVal), (yyvsp[(5) - (7)].ConstVal), &(*(yyvsp[(6) - (7)].ConstantList))[0], (yyvsp[(6) - (7)].ConstantList)->size());
5136     delete (yyvsp[(6) - (7)].ConstantList);
5137     CHECK_FOR_ERROR
5138   ;}
5139     break;
5140
5141   case 208:
5142 #line 2078 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5143     {
5144     ((yyval.ConstVector) = (yyvsp[(1) - (3)].ConstVector))->push_back((yyvsp[(3) - (3)].ConstVal));
5145     CHECK_FOR_ERROR
5146   ;}
5147     break;
5148
5149   case 209:
5150 #line 2082 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5151     {
5152     (yyval.ConstVector) = new std::vector<Constant*>();
5153     (yyval.ConstVector)->push_back((yyvsp[(1) - (1)].ConstVal));
5154     CHECK_FOR_ERROR
5155   ;}
5156     break;
5157
5158   case 210:
5159 #line 2090 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5160     { (yyval.BoolVal) = false; ;}
5161     break;
5162
5163   case 211:
5164 #line 2090 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5165     { (yyval.BoolVal) = true; ;}
5166     break;
5167
5168   case 212:
5169 #line 2093 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5170     { (yyval.BoolVal) = true; ;}
5171     break;
5172
5173   case 213:
5174 #line 2093 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5175     { (yyval.BoolVal) = false; ;}
5176     break;
5177
5178   case 214:
5179 #line 2096 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5180     {
5181     const Type* VTy = (yyvsp[(1) - (2)].TypeVal)->get();
5182     Value *V = getVal(VTy, (yyvsp[(2) - (2)].ValIDVal));
5183     CHECK_FOR_ERROR
5184     GlobalValue* Aliasee = dyn_cast<GlobalValue>(V);
5185     if (!Aliasee)
5186       GEN_ERROR("Aliases can be created only to global values");
5187
5188     (yyval.ConstVal) = Aliasee;
5189     CHECK_FOR_ERROR
5190     delete (yyvsp[(1) - (2)].TypeVal);
5191    ;}
5192     break;
5193
5194   case 215:
5195 #line 2108 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5196     {
5197     Constant *Val = (yyvsp[(3) - (6)].ConstVal);
5198     const Type *DestTy = (yyvsp[(5) - (6)].TypeVal)->get();
5199     if (!CastInst::castIsValid((yyvsp[(1) - (6)].CastOpVal), (yyvsp[(3) - (6)].ConstVal), DestTy))
5200       GEN_ERROR("invalid cast opcode for cast from '" +
5201                 Val->getType()->getDescription() + "' to '" +
5202                 DestTy->getDescription() + "'");
5203
5204     (yyval.ConstVal) = ConstantExpr::getCast((yyvsp[(1) - (6)].CastOpVal), (yyvsp[(3) - (6)].ConstVal), DestTy);
5205     CHECK_FOR_ERROR
5206     delete (yyvsp[(5) - (6)].TypeVal);
5207    ;}
5208     break;
5209
5210   case 216:
5211 #line 2129 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5212     {
5213     (yyval.ModuleVal) = ParserResult = CurModule.CurrentModule;
5214     CurModule.ModuleDone();
5215     CHECK_FOR_ERROR;
5216   ;}
5217     break;
5218
5219   case 217:
5220 #line 2134 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5221     {
5222     (yyval.ModuleVal) = ParserResult = CurModule.CurrentModule;
5223     CurModule.ModuleDone();
5224     CHECK_FOR_ERROR;
5225   ;}
5226     break;
5227
5228   case 220:
5229 #line 2147 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5230     { CurFun.isDeclare = false; ;}
5231     break;
5232
5233   case 221:
5234 #line 2147 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5235     {
5236     CurFun.FunctionDone();
5237     CHECK_FOR_ERROR
5238   ;}
5239     break;
5240
5241   case 222:
5242 #line 2151 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5243     { CurFun.isDeclare = true; ;}
5244     break;
5245
5246   case 223:
5247 #line 2151 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5248     {
5249     CHECK_FOR_ERROR
5250   ;}
5251     break;
5252
5253   case 224:
5254 #line 2154 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5255     {
5256     CHECK_FOR_ERROR
5257   ;}
5258     break;
5259
5260   case 225:
5261 #line 2157 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5262     {
5263     if (!UpRefs.empty())
5264       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (3)].TypeVal))->getDescription());
5265     // Eagerly resolve types.  This is not an optimization, this is a
5266     // requirement that is due to the fact that we could have this:
5267     //
5268     // %list = type { %list * }
5269     // %list = type { %list * }    ; repeated type decl
5270     //
5271     // If types are not resolved eagerly, then the two types will not be
5272     // determined to be the same type!
5273     //
5274     ResolveTypeTo((yyvsp[(1) - (3)].StrVal), *(yyvsp[(3) - (3)].TypeVal));
5275
5276     if (!setTypeName(*(yyvsp[(3) - (3)].TypeVal), (yyvsp[(1) - (3)].StrVal)) && !(yyvsp[(1) - (3)].StrVal)) {
5277       CHECK_FOR_ERROR
5278       // If this is a named type that is not a redefinition, add it to the slot
5279       // table.
5280       CurModule.Types.push_back(*(yyvsp[(3) - (3)].TypeVal));
5281     }
5282
5283     delete (yyvsp[(3) - (3)].TypeVal);
5284     CHECK_FOR_ERROR
5285   ;}
5286     break;
5287
5288   case 226:
5289 #line 2181 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5290     {
5291     ResolveTypeTo((yyvsp[(1) - (3)].StrVal), (yyvsp[(3) - (3)].PrimType));
5292
5293     if (!setTypeName((yyvsp[(3) - (3)].PrimType), (yyvsp[(1) - (3)].StrVal)) && !(yyvsp[(1) - (3)].StrVal)) {
5294       CHECK_FOR_ERROR
5295       // If this is a named type that is not a redefinition, add it to the slot
5296       // table.
5297       CurModule.Types.push_back((yyvsp[(3) - (3)].PrimType));
5298     }
5299     CHECK_FOR_ERROR
5300   ;}
5301     break;
5302
5303   case 227:
5304 #line 2193 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5305     {
5306     /* "Externally Visible" Linkage */
5307     if ((yyvsp[(5) - (6)].ConstVal) == 0)
5308       GEN_ERROR("Global value initializer is not a constant");
5309     CurGV = ParseGlobalVariable((yyvsp[(1) - (6)].StrVal), GlobalValue::ExternalLinkage,
5310                                 (yyvsp[(2) - (6)].Visibility), (yyvsp[(4) - (6)].BoolVal), (yyvsp[(5) - (6)].ConstVal)->getType(), (yyvsp[(5) - (6)].ConstVal), (yyvsp[(3) - (6)].BoolVal), (yyvsp[(6) - (6)].UIntVal));
5311     CHECK_FOR_ERROR
5312   ;}
5313     break;
5314
5315   case 228:
5316 #line 2200 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5317     {
5318     CurGV = 0;
5319   ;}
5320     break;
5321
5322   case 229:
5323 #line 2204 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5324     {
5325     if ((yyvsp[(6) - (7)].ConstVal) == 0)
5326       GEN_ERROR("Global value initializer is not a constant");
5327     CurGV = ParseGlobalVariable((yyvsp[(1) - (7)].StrVal), (yyvsp[(2) - (7)].Linkage), (yyvsp[(3) - (7)].Visibility), (yyvsp[(5) - (7)].BoolVal), (yyvsp[(6) - (7)].ConstVal)->getType(), (yyvsp[(6) - (7)].ConstVal), (yyvsp[(4) - (7)].BoolVal), (yyvsp[(7) - (7)].UIntVal));
5328     CHECK_FOR_ERROR
5329   ;}
5330     break;
5331
5332   case 230:
5333 #line 2209 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5334     {
5335     CurGV = 0;
5336   ;}
5337     break;
5338
5339   case 231:
5340 #line 2213 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5341     {
5342     if (!UpRefs.empty())
5343       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(6) - (7)].TypeVal))->getDescription());
5344     CurGV = ParseGlobalVariable((yyvsp[(1) - (7)].StrVal), (yyvsp[(2) - (7)].Linkage), (yyvsp[(3) - (7)].Visibility), (yyvsp[(5) - (7)].BoolVal), *(yyvsp[(6) - (7)].TypeVal), 0, (yyvsp[(4) - (7)].BoolVal), (yyvsp[(7) - (7)].UIntVal));
5345     CHECK_FOR_ERROR
5346     delete (yyvsp[(6) - (7)].TypeVal);
5347   ;}
5348     break;
5349
5350   case 232:
5351 #line 2219 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5352     {
5353     CurGV = 0;
5354     CHECK_FOR_ERROR
5355   ;}
5356     break;
5357
5358   case 233:
5359 #line 2223 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5360     {
5361     std::string Name;
5362     if ((yyvsp[(1) - (5)].StrVal)) {
5363       Name = *(yyvsp[(1) - (5)].StrVal);
5364       delete (yyvsp[(1) - (5)].StrVal);
5365     }
5366     if (Name.empty())
5367       GEN_ERROR("Alias name cannot be empty");
5368
5369     Constant* Aliasee = (yyvsp[(5) - (5)].ConstVal);
5370     if (Aliasee == 0)
5371       GEN_ERROR(std::string("Invalid aliasee for alias: ") + Name);
5372
5373     GlobalAlias* GA = new GlobalAlias(Aliasee->getType(), (yyvsp[(4) - (5)].Linkage), Name, Aliasee,
5374                                       CurModule.CurrentModule);
5375     GA->setVisibility((yyvsp[(2) - (5)].Visibility));
5376     InsertValue(GA, CurModule.Values);
5377
5378
5379     // If there was a forward reference of this alias, resolve it now.
5380
5381     ValID ID;
5382     if (!Name.empty())
5383       ID = ValID::createGlobalName(Name);
5384     else
5385       ID = ValID::createGlobalID(CurModule.Values.size()-1);
5386
5387     if (GlobalValue *FWGV =
5388           CurModule.GetForwardRefForGlobal(GA->getType(), ID)) {
5389       // Replace uses of the fwdref with the actual alias.
5390       FWGV->replaceAllUsesWith(GA);
5391       if (GlobalVariable *GV = dyn_cast<GlobalVariable>(FWGV))
5392         GV->eraseFromParent();
5393       else
5394         cast<Function>(FWGV)->eraseFromParent();
5395     }
5396     ID.destroy();
5397
5398     CHECK_FOR_ERROR
5399   ;}
5400     break;
5401
5402   case 234:
5403 #line 2263 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5404     {
5405     CHECK_FOR_ERROR
5406   ;}
5407     break;
5408
5409   case 235:
5410 #line 2266 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5411     {
5412     CHECK_FOR_ERROR
5413   ;}
5414     break;
5415
5416   case 236:
5417 #line 2272 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5418     {
5419   const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
5420   if (AsmSoFar.empty())
5421     CurModule.CurrentModule->setModuleInlineAsm(*(yyvsp[(1) - (1)].StrVal));
5422   else
5423     CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+*(yyvsp[(1) - (1)].StrVal));
5424   delete (yyvsp[(1) - (1)].StrVal);
5425   CHECK_FOR_ERROR
5426 ;}
5427     break;
5428
5429   case 237:
5430 #line 2282 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5431     {
5432     CurModule.CurrentModule->setTargetTriple(*(yyvsp[(3) - (3)].StrVal));
5433     delete (yyvsp[(3) - (3)].StrVal);
5434   ;}
5435     break;
5436
5437   case 238:
5438 #line 2286 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5439     {
5440     CurModule.CurrentModule->setDataLayout(*(yyvsp[(3) - (3)].StrVal));
5441     delete (yyvsp[(3) - (3)].StrVal);
5442   ;}
5443     break;
5444
5445   case 240:
5446 #line 2293 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5447     {
5448           CurModule.CurrentModule->addLibrary(*(yyvsp[(3) - (3)].StrVal));
5449           delete (yyvsp[(3) - (3)].StrVal);
5450           CHECK_FOR_ERROR
5451         ;}
5452     break;
5453
5454   case 241:
5455 #line 2298 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5456     {
5457           CurModule.CurrentModule->addLibrary(*(yyvsp[(1) - (1)].StrVal));
5458           delete (yyvsp[(1) - (1)].StrVal);
5459           CHECK_FOR_ERROR
5460         ;}
5461     break;
5462
5463   case 242:
5464 #line 2303 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5465     {
5466           CHECK_FOR_ERROR
5467         ;}
5468     break;
5469
5470   case 243:
5471 #line 2312 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5472     {
5473     if (!UpRefs.empty())
5474       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (5)].TypeVal))->getDescription());
5475     if (!(*(yyvsp[(3) - (5)].TypeVal))->isFirstClassType())
5476       GEN_ERROR("Argument types must be first-class");
5477     ArgListEntry E; E.Attrs = (yyvsp[(4) - (5)].Attributes); E.Ty = (yyvsp[(3) - (5)].TypeVal); E.Name = (yyvsp[(5) - (5)].StrVal);
5478     (yyval.ArgList) = (yyvsp[(1) - (5)].ArgList);
5479     (yyvsp[(1) - (5)].ArgList)->push_back(E);
5480     CHECK_FOR_ERROR
5481   ;}
5482     break;
5483
5484   case 244:
5485 #line 2322 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5486     {
5487     if (!UpRefs.empty())
5488       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription());
5489     if (!(*(yyvsp[(1) - (3)].TypeVal))->isFirstClassType())
5490       GEN_ERROR("Argument types must be first-class");
5491     ArgListEntry E; E.Attrs = (yyvsp[(2) - (3)].Attributes); E.Ty = (yyvsp[(1) - (3)].TypeVal); E.Name = (yyvsp[(3) - (3)].StrVal);
5492     (yyval.ArgList) = new ArgListType;
5493     (yyval.ArgList)->push_back(E);
5494     CHECK_FOR_ERROR
5495   ;}
5496     break;
5497
5498   case 245:
5499 #line 2333 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5500     {
5501     (yyval.ArgList) = (yyvsp[(1) - (1)].ArgList);
5502     CHECK_FOR_ERROR
5503   ;}
5504     break;
5505
5506   case 246:
5507 #line 2337 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5508     {
5509     (yyval.ArgList) = (yyvsp[(1) - (3)].ArgList);
5510     struct ArgListEntry E;
5511     E.Ty = new PATypeHolder(Type::VoidTy);
5512     E.Name = 0;
5513     E.Attrs = Attribute::None;
5514     (yyval.ArgList)->push_back(E);
5515     CHECK_FOR_ERROR
5516   ;}
5517     break;
5518
5519   case 247:
5520 #line 2346 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5521     {
5522     (yyval.ArgList) = new ArgListType;
5523     struct ArgListEntry E;
5524     E.Ty = new PATypeHolder(Type::VoidTy);
5525     E.Name = 0;
5526     E.Attrs = Attribute::None;
5527     (yyval.ArgList)->push_back(E);
5528     CHECK_FOR_ERROR
5529   ;}
5530     break;
5531
5532   case 248:
5533 #line 2355 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5534     {
5535     (yyval.ArgList) = 0;
5536     CHECK_FOR_ERROR
5537   ;}
5538     break;
5539
5540   case 249:
5541 #line 2361 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5542     {
5543   std::string FunctionName(*(yyvsp[(4) - (11)].StrVal));
5544   delete (yyvsp[(4) - (11)].StrVal);  // Free strdup'd memory!
5545
5546   // Check the function result for abstractness if this is a define. We should
5547   // have no abstract types at this point
5548   if (!CurFun.isDeclare && CurModule.TypeIsUnresolved((yyvsp[(3) - (11)].TypeVal)))
5549     GEN_ERROR("Reference to abstract result: "+ (yyvsp[(3) - (11)].TypeVal)->get()->getDescription());
5550
5551   if (!FunctionType::isValidReturnType(*(yyvsp[(3) - (11)].TypeVal)))
5552     GEN_ERROR("Invalid result type for LLVM function");
5553
5554   std::vector<const Type*> ParamTypeList;
5555   SmallVector<AttributeWithIndex, 8> Attrs;
5556   //FIXME : In 3.0, stop accepting zext, sext and inreg as optional function
5557   //attributes.
5558   Attributes RetAttrs = (yyvsp[(2) - (11)].Attributes);
5559   if ((yyvsp[(8) - (11)].Attributes) != Attribute::None) {
5560     if ((yyvsp[(8) - (11)].Attributes) & Attribute::ZExt) {
5561       RetAttrs = RetAttrs | Attribute::ZExt;
5562       (yyvsp[(8) - (11)].Attributes) = (yyvsp[(8) - (11)].Attributes) ^ Attribute::ZExt;
5563     }
5564     if ((yyvsp[(8) - (11)].Attributes) & Attribute::SExt) {
5565       RetAttrs = RetAttrs | Attribute::SExt;
5566       (yyvsp[(8) - (11)].Attributes) = (yyvsp[(8) - (11)].Attributes) ^ Attribute::SExt;
5567     }
5568     if ((yyvsp[(8) - (11)].Attributes) & Attribute::InReg) {
5569       RetAttrs = RetAttrs | Attribute::InReg;
5570       (yyvsp[(8) - (11)].Attributes) = (yyvsp[(8) - (11)].Attributes) ^ Attribute::InReg;
5571     }
5572   }
5573   if (RetAttrs != Attribute::None)
5574     Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
5575   if ((yyvsp[(6) - (11)].ArgList)) {   // If there are arguments...
5576     unsigned index = 1;
5577     for (ArgListType::iterator I = (yyvsp[(6) - (11)].ArgList)->begin(); I != (yyvsp[(6) - (11)].ArgList)->end(); ++I, ++index) {
5578       const Type* Ty = I->Ty->get();
5579       if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(I->Ty))
5580         GEN_ERROR("Reference to abstract argument: " + Ty->getDescription());
5581       ParamTypeList.push_back(Ty);
5582       if (Ty != Type::VoidTy && I->Attrs != Attribute::None)
5583         Attrs.push_back(AttributeWithIndex::get(index, I->Attrs));
5584     }
5585   }
5586   if ((yyvsp[(8) - (11)].Attributes) != Attribute::None)
5587     Attrs.push_back(AttributeWithIndex::get(~0, (yyvsp[(8) - (11)].Attributes)));
5588
5589   bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
5590   if (isVarArg) ParamTypeList.pop_back();
5591
5592   AttrListPtr PAL;
5593   if (!Attrs.empty())
5594     PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
5595
5596   FunctionType *FT = FunctionType::get(*(yyvsp[(3) - (11)].TypeVal), ParamTypeList, isVarArg);
5597   const PointerType *PFT = PointerType::getUnqual(FT);
5598   delete (yyvsp[(3) - (11)].TypeVal);
5599
5600   ValID ID;
5601   if (!FunctionName.empty()) {
5602     ID = ValID::createGlobalName((char*)FunctionName.c_str());
5603   } else {
5604     ID = ValID::createGlobalID(CurModule.Values.size());
5605   }
5606
5607   Function *Fn = 0;
5608   // See if this function was forward referenced.  If so, recycle the object.
5609   if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
5610     // Move the function to the end of the list, from whereever it was
5611     // previously inserted.
5612     Fn = cast<Function>(FWRef);
5613     assert(Fn->getAttributes().isEmpty() &&
5614            "Forward reference has parameter attributes!");
5615     CurModule.CurrentModule->getFunctionList().remove(Fn);
5616     CurModule.CurrentModule->getFunctionList().push_back(Fn);
5617   } else if (!FunctionName.empty() &&     // Merge with an earlier prototype?
5618              (Fn = CurModule.CurrentModule->getFunction(FunctionName))) {
5619     if (Fn->getFunctionType() != FT ) {
5620       // The existing function doesn't have the same type. This is an overload
5621       // error.
5622       GEN_ERROR("Overload of function '" + FunctionName + "' not permitted.");
5623     } else if (Fn->getAttributes() != PAL) {
5624       // The existing function doesn't have the same parameter attributes.
5625       // This is an overload error.
5626       GEN_ERROR("Overload of function '" + FunctionName + "' not permitted.");
5627     } else if (!CurFun.isDeclare && !Fn->isDeclaration()) {
5628       // Neither the existing or the current function is a declaration and they
5629       // have the same name and same type. Clearly this is a redefinition.
5630       GEN_ERROR("Redefinition of function '" + FunctionName + "'");
5631     } else if (Fn->isDeclaration()) {
5632       // Make sure to strip off any argument names so we can't get conflicts.
5633       for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
5634            AI != AE; ++AI)
5635         AI->setName("");
5636     }
5637   } else  {  // Not already defined?
5638     Fn = Function::Create(FT, GlobalValue::ExternalWeakLinkage, FunctionName,
5639                           CurModule.CurrentModule);
5640     InsertValue(Fn, CurModule.Values);
5641   }
5642
5643   ID.destroy();
5644   CurFun.FunctionStart(Fn);
5645
5646   if (CurFun.isDeclare) {
5647     // If we have declaration, always overwrite linkage.  This will allow us to
5648     // correctly handle cases, when pointer to function is passed as argument to
5649     // another function.
5650     Fn->setLinkage(CurFun.Linkage);
5651     Fn->setVisibility(CurFun.Visibility);
5652   }
5653   Fn->setCallingConv((yyvsp[(1) - (11)].UIntVal));
5654   Fn->setAttributes(PAL);
5655   Fn->setAlignment((yyvsp[(10) - (11)].UIntVal));
5656   if ((yyvsp[(9) - (11)].StrVal)) {
5657     Fn->setSection(*(yyvsp[(9) - (11)].StrVal));
5658     delete (yyvsp[(9) - (11)].StrVal);
5659   }
5660   if ((yyvsp[(11) - (11)].StrVal)) {
5661     Fn->setGC((yyvsp[(11) - (11)].StrVal)->c_str());
5662     delete (yyvsp[(11) - (11)].StrVal);
5663   }
5664
5665   // Add all of the arguments we parsed to the function...
5666   if ((yyvsp[(6) - (11)].ArgList)) {                     // Is null if empty...
5667     if (isVarArg) {  // Nuke the last entry
5668       assert((yyvsp[(6) - (11)].ArgList)->back().Ty->get() == Type::VoidTy && (yyvsp[(6) - (11)].ArgList)->back().Name == 0 &&
5669              "Not a varargs marker!");
5670       delete (yyvsp[(6) - (11)].ArgList)->back().Ty;
5671       (yyvsp[(6) - (11)].ArgList)->pop_back();  // Delete the last entry
5672     }
5673     Function::arg_iterator ArgIt = Fn->arg_begin();
5674     Function::arg_iterator ArgEnd = Fn->arg_end();
5675     unsigned Idx = 1;
5676     for (ArgListType::iterator I = (yyvsp[(6) - (11)].ArgList)->begin();
5677          I != (yyvsp[(6) - (11)].ArgList)->end() && ArgIt != ArgEnd; ++I, ++ArgIt) {
5678       delete I->Ty;                          // Delete the typeholder...
5679       setValueName(ArgIt, I->Name);       // Insert arg into symtab...
5680       CHECK_FOR_ERROR
5681       InsertValue(ArgIt);
5682       Idx++;
5683     }
5684
5685     delete (yyvsp[(6) - (11)].ArgList);                     // We're now done with the argument list
5686   }
5687   CHECK_FOR_ERROR
5688 ;}
5689     break;
5690
5691   case 252:
5692 #line 2511 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5693     {
5694   (yyval.FunctionVal) = CurFun.CurrentFunction;
5695
5696   // Make sure that we keep track of the linkage type even if there was a
5697   // previous "declare".
5698   (yyval.FunctionVal)->setLinkage((yyvsp[(1) - (4)].Linkage));
5699   (yyval.FunctionVal)->setVisibility((yyvsp[(2) - (4)].Visibility));
5700 ;}
5701     break;
5702
5703   case 255:
5704 #line 2522 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5705     {
5706   (yyval.FunctionVal) = (yyvsp[(1) - (2)].FunctionVal);
5707   CHECK_FOR_ERROR
5708 ;}
5709     break;
5710
5711   case 256:
5712 #line 2527 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5713     {
5714     CurFun.CurrentFunction->setLinkage((yyvsp[(1) - (3)].Linkage));
5715     CurFun.CurrentFunction->setVisibility((yyvsp[(2) - (3)].Visibility));
5716     (yyval.FunctionVal) = CurFun.CurrentFunction;
5717     CurFun.FunctionDone();
5718     CHECK_FOR_ERROR
5719   ;}
5720     break;
5721
5722   case 257:
5723 #line 2539 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5724     {
5725     (yyval.BoolVal) = false;
5726     CHECK_FOR_ERROR
5727   ;}
5728     break;
5729
5730   case 258:
5731 #line 2543 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5732     {
5733     (yyval.BoolVal) = true;
5734     CHECK_FOR_ERROR
5735   ;}
5736     break;
5737
5738   case 259:
5739 #line 2548 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5740     {    // A reference to a direct constant
5741     (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].SInt64Val));
5742     CHECK_FOR_ERROR
5743   ;}
5744     break;
5745
5746   case 260:
5747 #line 2552 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5748     {
5749     (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].UInt64Val));
5750     CHECK_FOR_ERROR
5751   ;}
5752     break;
5753
5754   case 261:
5755 #line 2556 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5756     {      // arbitrary precision integer constants
5757     (yyval.ValIDVal) = ValID::create(*(yyvsp[(1) - (1)].APIntVal), true);
5758     delete (yyvsp[(1) - (1)].APIntVal);
5759     CHECK_FOR_ERROR
5760   ;}
5761     break;
5762
5763   case 262:
5764 #line 2561 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5765     {      // arbitrary precision integer constants
5766     (yyval.ValIDVal) = ValID::create(*(yyvsp[(1) - (1)].APIntVal), false);
5767     delete (yyvsp[(1) - (1)].APIntVal);
5768     CHECK_FOR_ERROR
5769   ;}
5770     break;
5771
5772   case 263:
5773 #line 2566 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5774     {                     // Perhaps it's an FP constant?
5775     (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].FPVal));
5776     CHECK_FOR_ERROR
5777   ;}
5778     break;
5779
5780   case 264:
5781 #line 2570 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5782     {
5783     (yyval.ValIDVal) = ValID::create(ConstantInt::getTrue());
5784     CHECK_FOR_ERROR
5785   ;}
5786     break;
5787
5788   case 265:
5789 #line 2574 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5790     {
5791     (yyval.ValIDVal) = ValID::create(ConstantInt::getFalse());
5792     CHECK_FOR_ERROR
5793   ;}
5794     break;
5795
5796   case 266:
5797 #line 2578 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5798     {
5799     (yyval.ValIDVal) = ValID::createNull();
5800     CHECK_FOR_ERROR
5801   ;}
5802     break;
5803
5804   case 267:
5805 #line 2582 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5806     {
5807     (yyval.ValIDVal) = ValID::createUndef();
5808     CHECK_FOR_ERROR
5809   ;}
5810     break;
5811
5812   case 268:
5813 #line 2586 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5814     {     // A vector zero constant.
5815     (yyval.ValIDVal) = ValID::createZeroInit();
5816     CHECK_FOR_ERROR
5817   ;}
5818     break;
5819
5820   case 269:
5821 #line 2590 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5822     { // Nonempty unsized packed vector
5823     const Type *ETy = (*(yyvsp[(2) - (3)].ConstVector))[0]->getType();
5824     unsigned NumElements = (yyvsp[(2) - (3)].ConstVector)->size();
5825
5826     if (!ETy->isInteger() && !ETy->isFloatingPoint())
5827       GEN_ERROR("Invalid vector element type: " + ETy->getDescription());
5828
5829     VectorType* pt = VectorType::get(ETy, NumElements);
5830     PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(pt));
5831
5832     // Verify all elements are correct type!
5833     for (unsigned i = 0; i < (yyvsp[(2) - (3)].ConstVector)->size(); i++) {
5834       if (ETy != (*(yyvsp[(2) - (3)].ConstVector))[i]->getType())
5835         GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
5836                      ETy->getDescription() +"' as required!\nIt is of type '" +
5837                      (*(yyvsp[(2) - (3)].ConstVector))[i]->getType()->getDescription() + "'.");
5838     }
5839
5840     (yyval.ValIDVal) = ValID::create(ConstantVector::get(pt, *(yyvsp[(2) - (3)].ConstVector)));
5841     delete PTy; delete (yyvsp[(2) - (3)].ConstVector);
5842     CHECK_FOR_ERROR
5843   ;}
5844     break;
5845
5846   case 270:
5847 #line 2612 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5848     { // Nonempty unsized arr
5849     const Type *ETy = (*(yyvsp[(2) - (3)].ConstVector))[0]->getType();
5850     uint64_t NumElements = (yyvsp[(2) - (3)].ConstVector)->size();
5851
5852     if (!ETy->isFirstClassType())
5853       GEN_ERROR("Invalid array element type: " + ETy->getDescription());
5854
5855     ArrayType *ATy = ArrayType::get(ETy, NumElements);
5856     PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(ATy));
5857
5858     // Verify all elements are correct type!
5859     for (unsigned i = 0; i < (yyvsp[(2) - (3)].ConstVector)->size(); i++) {
5860       if (ETy != (*(yyvsp[(2) - (3)].ConstVector))[i]->getType())
5861         GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
5862                        ETy->getDescription() +"' as required!\nIt is of type '"+
5863                        (*(yyvsp[(2) - (3)].ConstVector))[i]->getType()->getDescription() + "'.");
5864     }
5865
5866     (yyval.ValIDVal) = ValID::create(ConstantArray::get(ATy, *(yyvsp[(2) - (3)].ConstVector)));
5867     delete PTy; delete (yyvsp[(2) - (3)].ConstVector);
5868     CHECK_FOR_ERROR
5869   ;}
5870     break;
5871
5872   case 271:
5873 #line 2634 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5874     {
5875     // Use undef instead of an array because it's inconvenient to determine
5876     // the element type at this point, there being no elements to examine.
5877     (yyval.ValIDVal) = ValID::createUndef();
5878     CHECK_FOR_ERROR
5879   ;}
5880     break;
5881
5882   case 272:
5883 #line 2640 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5884     {
5885     uint64_t NumElements = (yyvsp[(2) - (2)].StrVal)->length();
5886     const Type *ETy = Type::Int8Ty;
5887
5888     ArrayType *ATy = ArrayType::get(ETy, NumElements);
5889
5890     std::vector<Constant*> Vals;
5891     for (unsigned i = 0; i < (yyvsp[(2) - (2)].StrVal)->length(); ++i)
5892       Vals.push_back(ConstantInt::get(ETy, (*(yyvsp[(2) - (2)].StrVal))[i]));
5893     delete (yyvsp[(2) - (2)].StrVal);
5894     (yyval.ValIDVal) = ValID::create(ConstantArray::get(ATy, Vals));
5895     CHECK_FOR_ERROR
5896   ;}
5897     break;
5898
5899   case 273:
5900 #line 2653 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5901     {
5902     std::vector<const Type*> Elements((yyvsp[(2) - (3)].ConstVector)->size());
5903     for (unsigned i = 0, e = (yyvsp[(2) - (3)].ConstVector)->size(); i != e; ++i)
5904       Elements[i] = (*(yyvsp[(2) - (3)].ConstVector))[i]->getType();
5905
5906     const StructType *STy = StructType::get(Elements);
5907     PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(STy));
5908
5909     (yyval.ValIDVal) = ValID::create(ConstantStruct::get(STy, *(yyvsp[(2) - (3)].ConstVector)));
5910     delete PTy; delete (yyvsp[(2) - (3)].ConstVector);
5911     CHECK_FOR_ERROR
5912   ;}
5913     break;
5914
5915   case 274:
5916 #line 2665 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5917     {
5918     const StructType *STy = StructType::get(std::vector<const Type*>());
5919     (yyval.ValIDVal) = ValID::create(ConstantStruct::get(STy, std::vector<Constant*>()));
5920     CHECK_FOR_ERROR
5921   ;}
5922     break;
5923
5924   case 275:
5925 #line 2670 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5926     {
5927     std::vector<const Type*> Elements((yyvsp[(3) - (5)].ConstVector)->size());
5928     for (unsigned i = 0, e = (yyvsp[(3) - (5)].ConstVector)->size(); i != e; ++i)
5929       Elements[i] = (*(yyvsp[(3) - (5)].ConstVector))[i]->getType();
5930
5931     const StructType *STy = StructType::get(Elements, /*isPacked=*/true);
5932     PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(STy));
5933
5934     (yyval.ValIDVal) = ValID::create(ConstantStruct::get(STy, *(yyvsp[(3) - (5)].ConstVector)));
5935     delete PTy; delete (yyvsp[(3) - (5)].ConstVector);
5936     CHECK_FOR_ERROR
5937   ;}
5938     break;
5939
5940   case 276:
5941 #line 2682 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5942     {
5943     const StructType *STy = StructType::get(std::vector<const Type*>(),
5944                                             /*isPacked=*/true);
5945     (yyval.ValIDVal) = ValID::create(ConstantStruct::get(STy, std::vector<Constant*>()));
5946     CHECK_FOR_ERROR
5947   ;}
5948     break;
5949
5950   case 277:
5951 #line 2688 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5952     {
5953     (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].ConstVal));
5954     CHECK_FOR_ERROR
5955   ;}
5956     break;
5957
5958   case 278:
5959 #line 2692 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5960     {
5961     (yyval.ValIDVal) = ValID::createInlineAsm(*(yyvsp[(3) - (5)].StrVal), *(yyvsp[(5) - (5)].StrVal), (yyvsp[(2) - (5)].BoolVal));
5962     delete (yyvsp[(3) - (5)].StrVal);
5963     delete (yyvsp[(5) - (5)].StrVal);
5964     CHECK_FOR_ERROR
5965   ;}
5966     break;
5967
5968   case 279:
5969 #line 2702 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5970     {  // Is it an integer reference...?
5971     (yyval.ValIDVal) = ValID::createLocalID((yyvsp[(1) - (1)].UIntVal));
5972     CHECK_FOR_ERROR
5973   ;}
5974     break;
5975
5976   case 280:
5977 #line 2706 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5978     {
5979     (yyval.ValIDVal) = ValID::createGlobalID((yyvsp[(1) - (1)].UIntVal));
5980     CHECK_FOR_ERROR
5981   ;}
5982     break;
5983
5984   case 281:
5985 #line 2710 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5986     {                   // Is it a named reference...?
5987     (yyval.ValIDVal) = ValID::createLocalName(*(yyvsp[(1) - (1)].StrVal));
5988     delete (yyvsp[(1) - (1)].StrVal);
5989     CHECK_FOR_ERROR
5990   ;}
5991     break;
5992
5993   case 282:
5994 #line 2715 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5995     {                   // Is it a named reference...?
5996     (yyval.ValIDVal) = ValID::createGlobalName(*(yyvsp[(1) - (1)].StrVal));
5997     delete (yyvsp[(1) - (1)].StrVal);
5998     CHECK_FOR_ERROR
5999   ;}
6000     break;
6001
6002   case 285:
6003 #line 2728 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6004     {
6005     if (!UpRefs.empty())
6006       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
6007     (yyval.ValueVal) = getVal(*(yyvsp[(1) - (2)].TypeVal), (yyvsp[(2) - (2)].ValIDVal));
6008     delete (yyvsp[(1) - (2)].TypeVal);
6009     CHECK_FOR_ERROR
6010   ;}
6011     break;
6012
6013   case 286:
6014 #line 2737 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6015     {
6016     (yyval.ValueList) = new std::vector<Value *>();
6017     (yyval.ValueList)->push_back((yyvsp[(1) - (1)].ValueVal));
6018     CHECK_FOR_ERROR
6019   ;}
6020     break;
6021
6022   case 287:
6023 #line 2742 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6024     {
6025     ((yyval.ValueList)=(yyvsp[(1) - (3)].ValueList))->push_back((yyvsp[(3) - (3)].ValueVal));
6026     CHECK_FOR_ERROR
6027   ;}
6028     break;
6029
6030   case 288:
6031 #line 2747 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6032     {
6033     (yyval.FunctionVal) = (yyvsp[(1) - (2)].FunctionVal);
6034     CHECK_FOR_ERROR
6035   ;}
6036     break;
6037
6038   case 289:
6039 #line 2751 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6040     { // Do not allow functions with 0 basic blocks
6041     (yyval.FunctionVal) = (yyvsp[(1) - (2)].FunctionVal);
6042     CHECK_FOR_ERROR
6043   ;}
6044     break;
6045
6046   case 290:
6047 #line 2760 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6048     {
6049     setValueName((yyvsp[(3) - (3)].TermInstVal), (yyvsp[(2) - (3)].StrVal));
6050     CHECK_FOR_ERROR
6051     InsertValue((yyvsp[(3) - (3)].TermInstVal));
6052     (yyvsp[(1) - (3)].BasicBlockVal)->getInstList().push_back((yyvsp[(3) - (3)].TermInstVal));
6053     (yyval.BasicBlockVal) = (yyvsp[(1) - (3)].BasicBlockVal);
6054     CHECK_FOR_ERROR
6055   ;}
6056     break;
6057
6058   case 291:
6059 #line 2769 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6060     {
6061   CHECK_FOR_ERROR
6062   int ValNum = InsertValue((yyvsp[(3) - (3)].TermInstVal));
6063   if (ValNum != (int)(yyvsp[(2) - (3)].UIntVal))
6064     GEN_ERROR("Result value number %" + utostr((yyvsp[(2) - (3)].UIntVal)) +
6065               " is incorrect, expected %" + utostr((unsigned)ValNum));
6066
6067   (yyvsp[(1) - (3)].BasicBlockVal)->getInstList().push_back((yyvsp[(3) - (3)].TermInstVal));
6068   (yyval.BasicBlockVal) = (yyvsp[(1) - (3)].BasicBlockVal);
6069   CHECK_FOR_ERROR
6070 ;}
6071     break;
6072
6073   case 292:
6074 #line 2782 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6075     {
6076     if (CastInst *CI1 = dyn_cast<CastInst>((yyvsp[(2) - (2)].InstVal)))
6077       if (CastInst *CI2 = dyn_cast<CastInst>(CI1->getOperand(0)))
6078         if (CI2->getParent() == 0)
6079           (yyvsp[(1) - (2)].BasicBlockVal)->getInstList().push_back(CI2);
6080     (yyvsp[(1) - (2)].BasicBlockVal)->getInstList().push_back((yyvsp[(2) - (2)].InstVal));
6081     (yyval.BasicBlockVal) = (yyvsp[(1) - (2)].BasicBlockVal);
6082     CHECK_FOR_ERROR
6083   ;}
6084     break;
6085
6086   case 293:
6087 #line 2791 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6088     {          // Empty space between instruction lists
6089     (yyval.BasicBlockVal) = defineBBVal(ValID::createLocalID(CurFun.NextValNum));
6090     CHECK_FOR_ERROR
6091   ;}
6092     break;
6093
6094   case 294:
6095 #line 2795 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6096     {             // Labelled (named) basic block
6097     (yyval.BasicBlockVal) = defineBBVal(ValID::createLocalName(*(yyvsp[(1) - (1)].StrVal)));
6098     delete (yyvsp[(1) - (1)].StrVal);
6099     CHECK_FOR_ERROR
6100
6101   ;}
6102     break;
6103
6104   case 295:
6105 #line 2803 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6106     { // Return with a result...
6107     ValueList &VL = *(yyvsp[(2) - (2)].ValueList);
6108     assert(!VL.empty() && "Invalid ret operands!");
6109     const Type *ReturnType = CurFun.CurrentFunction->getReturnType();
6110     if (VL.size() > 1 ||
6111         (isa<StructType>(ReturnType) &&
6112          (VL.empty() || VL[0]->getType() != ReturnType))) {
6113       Value *RV = UndefValue::get(ReturnType);
6114       for (unsigned i = 0, e = VL.size(); i != e; ++i) {
6115         Instruction *I = InsertValueInst::Create(RV, VL[i], i, "mrv");
6116         ((yyvsp[(-1) - (2)].BasicBlockVal))->getInstList().push_back(I);
6117         RV = I;
6118       }
6119       (yyval.TermInstVal) = ReturnInst::Create(RV);
6120     } else {
6121       (yyval.TermInstVal) = ReturnInst::Create(VL[0]);
6122     }
6123     delete (yyvsp[(2) - (2)].ValueList);
6124     CHECK_FOR_ERROR
6125   ;}
6126     break;
6127
6128   case 296:
6129 #line 2823 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6130     {                                    // Return with no result...
6131     (yyval.TermInstVal) = ReturnInst::Create();
6132     CHECK_FOR_ERROR
6133   ;}
6134     break;
6135
6136   case 297:
6137 #line 2827 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6138     {                           // Unconditional Branch...
6139     BasicBlock* tmpBB = getBBVal((yyvsp[(3) - (3)].ValIDVal));
6140     CHECK_FOR_ERROR
6141     (yyval.TermInstVal) = BranchInst::Create(tmpBB);
6142   ;}
6143     break;
6144
6145   case 298:
6146 #line 2832 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6147     {
6148     if (cast<IntegerType>((yyvsp[(2) - (9)].PrimType))->getBitWidth() != 1)
6149       GEN_ERROR("Branch condition must have type i1");
6150     BasicBlock* tmpBBA = getBBVal((yyvsp[(6) - (9)].ValIDVal));
6151     CHECK_FOR_ERROR
6152     BasicBlock* tmpBBB = getBBVal((yyvsp[(9) - (9)].ValIDVal));
6153     CHECK_FOR_ERROR
6154     Value* tmpVal = getVal(Type::Int1Ty, (yyvsp[(3) - (9)].ValIDVal));
6155     CHECK_FOR_ERROR
6156     (yyval.TermInstVal) = BranchInst::Create(tmpBBA, tmpBBB, tmpVal);
6157   ;}
6158     break;
6159
6160   case 299:
6161 #line 2843 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6162     {
6163     Value* tmpVal = getVal((yyvsp[(2) - (9)].PrimType), (yyvsp[(3) - (9)].ValIDVal));
6164     CHECK_FOR_ERROR
6165     BasicBlock* tmpBB = getBBVal((yyvsp[(6) - (9)].ValIDVal));
6166     CHECK_FOR_ERROR
6167     SwitchInst *S = SwitchInst::Create(tmpVal, tmpBB, (yyvsp[(8) - (9)].JumpTable)->size());
6168     (yyval.TermInstVal) = S;
6169
6170     std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = (yyvsp[(8) - (9)].JumpTable)->begin(),
6171       E = (yyvsp[(8) - (9)].JumpTable)->end();
6172     for (; I != E; ++I) {
6173       if (ConstantInt *CI = dyn_cast<ConstantInt>(I->first))
6174           S->addCase(CI, I->second);
6175       else
6176         GEN_ERROR("Switch case is constant, but not a simple integer");
6177     }
6178     delete (yyvsp[(8) - (9)].JumpTable);
6179     CHECK_FOR_ERROR
6180   ;}
6181     break;
6182
6183   case 300:
6184 #line 2862 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6185     {
6186     Value* tmpVal = getVal((yyvsp[(2) - (8)].PrimType), (yyvsp[(3) - (8)].ValIDVal));
6187     CHECK_FOR_ERROR
6188     BasicBlock* tmpBB = getBBVal((yyvsp[(6) - (8)].ValIDVal));
6189     CHECK_FOR_ERROR
6190     SwitchInst *S = SwitchInst::Create(tmpVal, tmpBB, 0);
6191     (yyval.TermInstVal) = S;
6192     CHECK_FOR_ERROR
6193   ;}
6194     break;
6195
6196   case 301:
6197 #line 2872 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6198     {
6199
6200     // Handle the short syntax
6201     const PointerType *PFTy = 0;
6202     const FunctionType *Ty = 0;
6203     if (!(PFTy = dyn_cast<PointerType>((yyvsp[(4) - (15)].TypeVal)->get())) ||
6204         !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
6205       // Pull out the types of all of the arguments...
6206       std::vector<const Type*> ParamTypes;
6207       ParamList::iterator I = (yyvsp[(7) - (15)].ParamList)->begin(), E = (yyvsp[(7) - (15)].ParamList)->end();
6208       for (; I != E; ++I) {
6209         const Type *Ty = I->Val->getType();
6210         if (Ty == Type::VoidTy)
6211           GEN_ERROR("Short call syntax cannot be used with varargs");
6212         ParamTypes.push_back(Ty);
6213       }
6214
6215       if (!FunctionType::isValidReturnType(*(yyvsp[(4) - (15)].TypeVal)))
6216         GEN_ERROR("Invalid result type for LLVM function");
6217
6218       Ty = FunctionType::get((yyvsp[(4) - (15)].TypeVal)->get(), ParamTypes, false);
6219       PFTy = PointerType::getUnqual(Ty);
6220     }
6221
6222     delete (yyvsp[(4) - (15)].TypeVal);
6223
6224     Value *V = getVal(PFTy, (yyvsp[(5) - (15)].ValIDVal));   // Get the function we're calling...
6225     CHECK_FOR_ERROR
6226     BasicBlock *Normal = getBBVal((yyvsp[(12) - (15)].ValIDVal));
6227     CHECK_FOR_ERROR
6228     BasicBlock *Except = getBBVal((yyvsp[(15) - (15)].ValIDVal));
6229     CHECK_FOR_ERROR
6230
6231     SmallVector<AttributeWithIndex, 8> Attrs;
6232     //FIXME : In 3.0, stop accepting zext, sext and inreg as optional function
6233     //attributes.
6234     Attributes RetAttrs = (yyvsp[(3) - (15)].Attributes);
6235     if ((yyvsp[(9) - (15)].Attributes) != Attribute::None) {
6236       if ((yyvsp[(9) - (15)].Attributes) & Attribute::ZExt) {
6237         RetAttrs = RetAttrs | Attribute::ZExt;
6238         (yyvsp[(9) - (15)].Attributes) = (yyvsp[(9) - (15)].Attributes) ^ Attribute::ZExt;
6239       }
6240       if ((yyvsp[(9) - (15)].Attributes) & Attribute::SExt) {
6241         RetAttrs = RetAttrs | Attribute::SExt;
6242         (yyvsp[(9) - (15)].Attributes) = (yyvsp[(9) - (15)].Attributes) ^ Attribute::SExt;
6243       }
6244       if ((yyvsp[(9) - (15)].Attributes) & Attribute::InReg) {
6245         RetAttrs = RetAttrs | Attribute::InReg;
6246         (yyvsp[(9) - (15)].Attributes) = (yyvsp[(9) - (15)].Attributes) ^ Attribute::InReg;
6247       }
6248     }
6249     if (RetAttrs != Attribute::None)
6250       Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
6251
6252     // Check the arguments
6253     ValueList Args;
6254     if ((yyvsp[(7) - (15)].ParamList)->empty()) {                                   // Has no arguments?
6255       // Make sure no arguments is a good thing!
6256       if (Ty->getNumParams() != 0)
6257         GEN_ERROR("No arguments passed to a function that "
6258                        "expects arguments");
6259     } else {                                     // Has arguments?
6260       // Loop through FunctionType's arguments and ensure they are specified
6261       // correctly!
6262       FunctionType::param_iterator I = Ty->param_begin();
6263       FunctionType::param_iterator E = Ty->param_end();
6264       ParamList::iterator ArgI = (yyvsp[(7) - (15)].ParamList)->begin(), ArgE = (yyvsp[(7) - (15)].ParamList)->end();
6265       unsigned index = 1;
6266
6267       for (; ArgI != ArgE && I != E; ++ArgI, ++I, ++index) {
6268         if (ArgI->Val->getType() != *I)
6269           GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" +
6270                          (*I)->getDescription() + "'");
6271         Args.push_back(ArgI->Val);
6272         if (ArgI->Attrs != Attribute::None)
6273           Attrs.push_back(AttributeWithIndex::get(index, ArgI->Attrs));
6274       }
6275
6276       if (Ty->isVarArg()) {
6277         if (I == E)
6278           for (; ArgI != ArgE; ++ArgI, ++index) {
6279             Args.push_back(ArgI->Val); // push the remaining varargs
6280             if (ArgI->Attrs != Attribute::None)
6281               Attrs.push_back(AttributeWithIndex::get(index, ArgI->Attrs));
6282           }
6283       } else if (I != E || ArgI != ArgE)
6284         GEN_ERROR("Invalid number of parameters detected");
6285     }
6286     if ((yyvsp[(9) - (15)].Attributes) != Attribute::None)
6287       Attrs.push_back(AttributeWithIndex::get(~0, (yyvsp[(9) - (15)].Attributes)));
6288     AttrListPtr PAL;
6289     if (!Attrs.empty())
6290       PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
6291
6292     // Create the InvokeInst
6293     InvokeInst *II = InvokeInst::Create(V, Normal, Except,
6294                                         Args.begin(), Args.end());
6295     II->setCallingConv((yyvsp[(2) - (15)].UIntVal));
6296     II->setAttributes(PAL);
6297     (yyval.TermInstVal) = II;
6298     delete (yyvsp[(7) - (15)].ParamList);
6299     CHECK_FOR_ERROR
6300   ;}
6301     break;
6302
6303   case 302:
6304 #line 2975 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6305     {
6306     (yyval.TermInstVal) = new UnwindInst();
6307     CHECK_FOR_ERROR
6308   ;}
6309     break;
6310
6311   case 303:
6312 #line 2979 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6313     {
6314     (yyval.TermInstVal) = new UnreachableInst();
6315     CHECK_FOR_ERROR
6316   ;}
6317     break;
6318
6319   case 304:
6320 #line 2986 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6321     {
6322     (yyval.JumpTable) = (yyvsp[(1) - (6)].JumpTable);
6323     Constant *V = cast<Constant>(getExistingVal((yyvsp[(2) - (6)].PrimType), (yyvsp[(3) - (6)].ValIDVal)));
6324     CHECK_FOR_ERROR
6325     if (V == 0)
6326       GEN_ERROR("May only switch on a constant pool value");
6327
6328     BasicBlock* tmpBB = getBBVal((yyvsp[(6) - (6)].ValIDVal));
6329     CHECK_FOR_ERROR
6330     (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
6331   ;}
6332     break;
6333
6334   case 305:
6335 #line 2997 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6336     {
6337     (yyval.JumpTable) = new std::vector<std::pair<Constant*, BasicBlock*> >();
6338     Constant *V = cast<Constant>(getExistingVal((yyvsp[(1) - (5)].PrimType), (yyvsp[(2) - (5)].ValIDVal)));
6339     CHECK_FOR_ERROR
6340
6341     if (V == 0)
6342       GEN_ERROR("May only switch on a constant pool value");
6343
6344     BasicBlock* tmpBB = getBBVal((yyvsp[(5) - (5)].ValIDVal));
6345     CHECK_FOR_ERROR
6346     (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
6347   ;}
6348     break;
6349
6350   case 306:
6351 #line 3010 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6352     {
6353     // Is this definition named?? if so, assign the name...
6354     setValueName((yyvsp[(2) - (2)].InstVal), (yyvsp[(1) - (2)].StrVal));
6355     CHECK_FOR_ERROR
6356     InsertValue((yyvsp[(2) - (2)].InstVal));
6357     (yyval.InstVal) = (yyvsp[(2) - (2)].InstVal);
6358     CHECK_FOR_ERROR
6359   ;}
6360     break;
6361
6362   case 307:
6363 #line 3019 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6364     {
6365     CHECK_FOR_ERROR
6366     int ValNum = InsertValue((yyvsp[(2) - (2)].InstVal));
6367
6368     if (ValNum != (int)(yyvsp[(1) - (2)].UIntVal))
6369       GEN_ERROR("Result value number %" + utostr((yyvsp[(1) - (2)].UIntVal)) +
6370                 " is incorrect, expected %" + utostr((unsigned)ValNum));
6371
6372     (yyval.InstVal) = (yyvsp[(2) - (2)].InstVal);
6373     CHECK_FOR_ERROR
6374   ;}
6375     break;
6376
6377   case 308:
6378 #line 3032 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6379     {    // Used for PHI nodes
6380     if (!UpRefs.empty())
6381       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (6)].TypeVal))->getDescription());
6382     (yyval.PHIList) = new std::list<std::pair<Value*, BasicBlock*> >();
6383     Value* tmpVal = getVal(*(yyvsp[(1) - (6)].TypeVal), (yyvsp[(3) - (6)].ValIDVal));
6384     CHECK_FOR_ERROR
6385     BasicBlock* tmpBB = getBBVal((yyvsp[(5) - (6)].ValIDVal));
6386     CHECK_FOR_ERROR
6387     (yyval.PHIList)->push_back(std::make_pair(tmpVal, tmpBB));
6388     delete (yyvsp[(1) - (6)].TypeVal);
6389   ;}
6390     break;
6391
6392   case 309:
6393 #line 3043 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6394     {
6395     (yyval.PHIList) = (yyvsp[(1) - (7)].PHIList);
6396     Value* tmpVal = getVal((yyvsp[(1) - (7)].PHIList)->front().first->getType(), (yyvsp[(4) - (7)].ValIDVal));
6397     CHECK_FOR_ERROR
6398     BasicBlock* tmpBB = getBBVal((yyvsp[(6) - (7)].ValIDVal));
6399     CHECK_FOR_ERROR
6400     (yyvsp[(1) - (7)].PHIList)->push_back(std::make_pair(tmpVal, tmpBB));
6401   ;}
6402     break;
6403
6404   case 310:
6405 #line 3053 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6406     {
6407     // FIXME: Remove trailing OptAttributes in LLVM 3.0, it was a mistake in 2.0
6408     if (!UpRefs.empty())
6409       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (4)].TypeVal))->getDescription());
6410     // Used for call and invoke instructions
6411     (yyval.ParamList) = new ParamList();
6412     ParamListEntry E; E.Attrs = (yyvsp[(2) - (4)].Attributes) | (yyvsp[(4) - (4)].Attributes); E.Val = getVal((yyvsp[(1) - (4)].TypeVal)->get(), (yyvsp[(3) - (4)].ValIDVal));
6413     (yyval.ParamList)->push_back(E);
6414     delete (yyvsp[(1) - (4)].TypeVal);
6415     CHECK_FOR_ERROR
6416   ;}
6417     break;
6418
6419   case 311:
6420 #line 3064 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6421     {
6422     // FIXME: Remove trailing OptAttributes in LLVM 3.0, it was a mistake in 2.0
6423     // Labels are only valid in ASMs
6424     (yyval.ParamList) = new ParamList();
6425     ParamListEntry E; E.Attrs = (yyvsp[(2) - (4)].Attributes) | (yyvsp[(4) - (4)].Attributes); E.Val = getBBVal((yyvsp[(3) - (4)].ValIDVal));
6426     (yyval.ParamList)->push_back(E);
6427     CHECK_FOR_ERROR
6428   ;}
6429     break;
6430
6431   case 312:
6432 #line 3072 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6433     {
6434     // FIXME: Remove trailing OptAttributes in LLVM 3.0, it was a mistake in 2.0
6435     if (!UpRefs.empty())
6436       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription());
6437     (yyval.ParamList) = (yyvsp[(1) - (6)].ParamList);
6438     ParamListEntry E; E.Attrs = (yyvsp[(4) - (6)].Attributes) | (yyvsp[(6) - (6)].Attributes); E.Val = getVal((yyvsp[(3) - (6)].TypeVal)->get(), (yyvsp[(5) - (6)].ValIDVal));
6439     (yyval.ParamList)->push_back(E);
6440     delete (yyvsp[(3) - (6)].TypeVal);
6441     CHECK_FOR_ERROR
6442   ;}
6443     break;
6444
6445   case 313:
6446 #line 3082 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6447     {
6448     // FIXME: Remove trailing OptAttributes in LLVM 3.0, it was a mistake in 2.0
6449     (yyval.ParamList) = (yyvsp[(1) - (6)].ParamList);
6450     ParamListEntry E; E.Attrs = (yyvsp[(4) - (6)].Attributes) | (yyvsp[(6) - (6)].Attributes); E.Val = getBBVal((yyvsp[(5) - (6)].ValIDVal));
6451     (yyval.ParamList)->push_back(E);
6452     CHECK_FOR_ERROR
6453   ;}
6454     break;
6455
6456   case 314:
6457 #line 3089 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6458     { (yyval.ParamList) = new ParamList(); ;}
6459     break;
6460
6461   case 315:
6462 #line 3092 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6463     { (yyval.ValueList) = new std::vector<Value*>(); ;}
6464     break;
6465
6466   case 316:
6467 #line 3093 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6468     {
6469     (yyval.ValueList) = (yyvsp[(1) - (3)].ValueList);
6470     (yyval.ValueList)->push_back((yyvsp[(3) - (3)].ValueVal));
6471     CHECK_FOR_ERROR
6472   ;}
6473     break;
6474
6475   case 317:
6476 #line 3101 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6477     {
6478     (yyval.ConstantList) = new std::vector<unsigned>();
6479     if ((unsigned)(yyvsp[(2) - (2)].UInt64Val) != (yyvsp[(2) - (2)].UInt64Val))
6480       GEN_ERROR("Index " + utostr((yyvsp[(2) - (2)].UInt64Val)) + " is not valid for insertvalue or extractvalue.");
6481     (yyval.ConstantList)->push_back((yyvsp[(2) - (2)].UInt64Val));
6482   ;}
6483     break;
6484
6485   case 318:
6486 #line 3107 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6487     {
6488     (yyval.ConstantList) = (yyvsp[(1) - (3)].ConstantList);
6489     if ((unsigned)(yyvsp[(3) - (3)].UInt64Val) != (yyvsp[(3) - (3)].UInt64Val))
6490       GEN_ERROR("Index " + utostr((yyvsp[(3) - (3)].UInt64Val)) + " is not valid for insertvalue or extractvalue.");
6491     (yyval.ConstantList)->push_back((yyvsp[(3) - (3)].UInt64Val));
6492     CHECK_FOR_ERROR
6493   ;}
6494     break;
6495
6496   case 319:
6497 #line 3116 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6498     {
6499     (yyval.BoolVal) = true;
6500     CHECK_FOR_ERROR
6501   ;}
6502     break;
6503
6504   case 320:
6505 #line 3120 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6506     {
6507     (yyval.BoolVal) = false;
6508     CHECK_FOR_ERROR
6509   ;}
6510     break;
6511
6512   case 321:
6513 #line 3125 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6514     {
6515     if (!UpRefs.empty())
6516       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (5)].TypeVal))->getDescription());
6517     if (!(*(yyvsp[(2) - (5)].TypeVal))->isInteger() && !(*(yyvsp[(2) - (5)].TypeVal))->isFloatingPoint() &&
6518         !isa<VectorType>((*(yyvsp[(2) - (5)].TypeVal)).get()))
6519       GEN_ERROR(
6520         "Arithmetic operator requires integer, FP, or packed operands");
6521     Value* val1 = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(3) - (5)].ValIDVal));
6522     CHECK_FOR_ERROR
6523     Value* val2 = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(5) - (5)].ValIDVal));
6524     CHECK_FOR_ERROR
6525     (yyval.InstVal) = BinaryOperator::Create((yyvsp[(1) - (5)].BinaryOpVal), val1, val2);
6526     if ((yyval.InstVal) == 0)
6527       GEN_ERROR("binary operator returned null");
6528     delete (yyvsp[(2) - (5)].TypeVal);
6529   ;}
6530     break;
6531
6532   case 322:
6533 #line 3141 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6534     {
6535     if (!UpRefs.empty())
6536       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (5)].TypeVal))->getDescription());
6537     if (!(*(yyvsp[(2) - (5)].TypeVal))->isInteger()) {
6538       if (!isa<VectorType>((yyvsp[(2) - (5)].TypeVal)->get()) ||
6539           !cast<VectorType>((yyvsp[(2) - (5)].TypeVal)->get())->getElementType()->isInteger())
6540         GEN_ERROR("Logical operator requires integral operands");
6541     }
6542     Value* tmpVal1 = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(3) - (5)].ValIDVal));
6543     CHECK_FOR_ERROR
6544     Value* tmpVal2 = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(5) - (5)].ValIDVal));
6545     CHECK_FOR_ERROR
6546     (yyval.InstVal) = BinaryOperator::Create((yyvsp[(1) - (5)].BinaryOpVal), tmpVal1, tmpVal2);
6547     if ((yyval.InstVal) == 0)
6548       GEN_ERROR("binary operator returned null");
6549     delete (yyvsp[(2) - (5)].TypeVal);
6550   ;}
6551     break;
6552
6553   case 323:
6554 #line 3158 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6555     {
6556     if (!UpRefs.empty())
6557       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription());
6558     Value* tmpVal1 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(4) - (6)].ValIDVal));
6559     CHECK_FOR_ERROR
6560     Value* tmpVal2 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(6) - (6)].ValIDVal));
6561     CHECK_FOR_ERROR
6562     (yyval.InstVal) = CmpInst::Create((yyvsp[(1) - (6)].OtherOpVal), (yyvsp[(2) - (6)].IPredicate), tmpVal1, tmpVal2);
6563     if ((yyval.InstVal) == 0)
6564       GEN_ERROR("icmp operator returned null");
6565     delete (yyvsp[(3) - (6)].TypeVal);
6566   ;}
6567     break;
6568
6569   case 324:
6570 #line 3170 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6571     {
6572     if (!UpRefs.empty())
6573       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription());
6574     Value* tmpVal1 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(4) - (6)].ValIDVal));
6575     CHECK_FOR_ERROR
6576     Value* tmpVal2 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(6) - (6)].ValIDVal));
6577     CHECK_FOR_ERROR
6578     (yyval.InstVal) = CmpInst::Create((yyvsp[(1) - (6)].OtherOpVal), (yyvsp[(2) - (6)].FPredicate), tmpVal1, tmpVal2);
6579     if ((yyval.InstVal) == 0)
6580       GEN_ERROR("fcmp operator returned null");
6581     delete (yyvsp[(3) - (6)].TypeVal);
6582   ;}
6583     break;
6584
6585   case 325:
6586 #line 3182 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6587     {
6588     if (!UpRefs.empty())
6589       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription());
6590     if (!isa<VectorType>((*(yyvsp[(3) - (6)].TypeVal)).get()))
6591       GEN_ERROR("Scalar types not supported by vicmp instruction");
6592     Value* tmpVal1 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(4) - (6)].ValIDVal));
6593     CHECK_FOR_ERROR
6594     Value* tmpVal2 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(6) - (6)].ValIDVal));
6595     CHECK_FOR_ERROR
6596     (yyval.InstVal) = CmpInst::Create((yyvsp[(1) - (6)].OtherOpVal), (yyvsp[(2) - (6)].IPredicate), tmpVal1, tmpVal2);
6597     if ((yyval.InstVal) == 0)
6598       GEN_ERROR("vicmp operator returned null");
6599     delete (yyvsp[(3) - (6)].TypeVal);
6600   ;}
6601     break;
6602
6603   case 326:
6604 #line 3196 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6605     {
6606     if (!UpRefs.empty())
6607       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription());
6608     if (!isa<VectorType>((*(yyvsp[(3) - (6)].TypeVal)).get()))
6609       GEN_ERROR("Scalar types not supported by vfcmp instruction");
6610     Value* tmpVal1 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(4) - (6)].ValIDVal));
6611     CHECK_FOR_ERROR
6612     Value* tmpVal2 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(6) - (6)].ValIDVal));
6613     CHECK_FOR_ERROR
6614     (yyval.InstVal) = CmpInst::Create((yyvsp[(1) - (6)].OtherOpVal), (yyvsp[(2) - (6)].FPredicate), tmpVal1, tmpVal2);
6615     if ((yyval.InstVal) == 0)
6616       GEN_ERROR("vfcmp operator returned null");
6617     delete (yyvsp[(3) - (6)].TypeVal);
6618   ;}
6619     break;
6620
6621   case 327:
6622 #line 3210 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6623     {
6624     if (!UpRefs.empty())
6625       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(4) - (4)].TypeVal))->getDescription());
6626     Value* Val = (yyvsp[(2) - (4)].ValueVal);
6627     const Type* DestTy = (yyvsp[(4) - (4)].TypeVal)->get();
6628     if (!CastInst::castIsValid((yyvsp[(1) - (4)].CastOpVal), Val, DestTy))
6629       GEN_ERROR("invalid cast opcode for cast from '" +
6630                 Val->getType()->getDescription() + "' to '" +
6631                 DestTy->getDescription() + "'");
6632     (yyval.InstVal) = CastInst::Create((yyvsp[(1) - (4)].CastOpVal), Val, DestTy);
6633     delete (yyvsp[(4) - (4)].TypeVal);
6634   ;}
6635     break;
6636
6637   case 328:
6638 #line 3222 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6639     {
6640     if (isa<VectorType>((yyvsp[(2) - (6)].ValueVal)->getType())) {
6641       // vector select
6642       if (!isa<VectorType>((yyvsp[(4) - (6)].ValueVal)->getType())
6643       || !isa<VectorType>((yyvsp[(6) - (6)].ValueVal)->getType()) )
6644         GEN_ERROR("vector select value types must be vector types");
6645       const VectorType* cond_type = cast<VectorType>((yyvsp[(2) - (6)].ValueVal)->getType());
6646       const VectorType* select_type = cast<VectorType>((yyvsp[(4) - (6)].ValueVal)->getType());
6647       if (cond_type->getElementType() != Type::Int1Ty)
6648         GEN_ERROR("vector select condition element type must be boolean");
6649       if (cond_type->getNumElements() != select_type->getNumElements())
6650         GEN_ERROR("vector select number of elements must be the same");
6651     } else {
6652       if ((yyvsp[(2) - (6)].ValueVal)->getType() != Type::Int1Ty)
6653         GEN_ERROR("select condition must be boolean");
6654     }
6655     if ((yyvsp[(4) - (6)].ValueVal)->getType() != (yyvsp[(6) - (6)].ValueVal)->getType())
6656       GEN_ERROR("select value types must match");
6657     (yyval.InstVal) = SelectInst::Create((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal));
6658     CHECK_FOR_ERROR
6659   ;}
6660     break;
6661
6662   case 329:
6663 #line 3243 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6664     {
6665     if (!UpRefs.empty())
6666       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(4) - (4)].TypeVal))->getDescription());
6667     (yyval.InstVal) = new VAArgInst((yyvsp[(2) - (4)].ValueVal), *(yyvsp[(4) - (4)].TypeVal));
6668     delete (yyvsp[(4) - (4)].TypeVal);
6669     CHECK_FOR_ERROR
6670   ;}
6671     break;
6672
6673   case 330:
6674 #line 3250 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6675     {
6676     if (!ExtractElementInst::isValidOperands((yyvsp[(2) - (4)].ValueVal), (yyvsp[(4) - (4)].ValueVal)))
6677       GEN_ERROR("Invalid extractelement operands");
6678     (yyval.InstVal) = new ExtractElementInst((yyvsp[(2) - (4)].ValueVal), (yyvsp[(4) - (4)].ValueVal));
6679     CHECK_FOR_ERROR
6680   ;}
6681     break;
6682
6683   case 331:
6684 #line 3256 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6685     {
6686     if (!InsertElementInst::isValidOperands((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal)))
6687       GEN_ERROR("Invalid insertelement operands");
6688     (yyval.InstVal) = InsertElementInst::Create((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal));
6689     CHECK_FOR_ERROR
6690   ;}
6691     break;
6692
6693   case 332:
6694 #line 3262 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6695     {
6696     if (!ShuffleVectorInst::isValidOperands((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal)))
6697       GEN_ERROR("Invalid shufflevector operands");
6698     (yyval.InstVal) = new ShuffleVectorInst((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal));
6699     CHECK_FOR_ERROR
6700   ;}
6701     break;
6702
6703   case 333:
6704 #line 3268 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6705     {
6706     const Type *Ty = (yyvsp[(2) - (2)].PHIList)->front().first->getType();
6707     if (!Ty->isFirstClassType())
6708       GEN_ERROR("PHI node operands must be of first class type");
6709     (yyval.InstVal) = PHINode::Create(Ty);
6710     ((PHINode*)(yyval.InstVal))->reserveOperandSpace((yyvsp[(2) - (2)].PHIList)->size());
6711     while ((yyvsp[(2) - (2)].PHIList)->begin() != (yyvsp[(2) - (2)].PHIList)->end()) {
6712       if ((yyvsp[(2) - (2)].PHIList)->front().first->getType() != Ty)
6713         GEN_ERROR("All elements of a PHI node must be of the same type");
6714       cast<PHINode>((yyval.InstVal))->addIncoming((yyvsp[(2) - (2)].PHIList)->front().first, (yyvsp[(2) - (2)].PHIList)->front().second);
6715       (yyvsp[(2) - (2)].PHIList)->pop_front();
6716     }
6717     delete (yyvsp[(2) - (2)].PHIList);  // Free the list...
6718     CHECK_FOR_ERROR
6719   ;}
6720     break;
6721
6722   case 334:
6723 #line 3284 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6724     {
6725
6726     // Handle the short syntax
6727     const PointerType *PFTy = 0;
6728     const FunctionType *Ty = 0;
6729     if (!(PFTy = dyn_cast<PointerType>((yyvsp[(4) - (9)].TypeVal)->get())) ||
6730         !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
6731       // Pull out the types of all of the arguments...
6732       std::vector<const Type*> ParamTypes;
6733       ParamList::iterator I = (yyvsp[(7) - (9)].ParamList)->begin(), E = (yyvsp[(7) - (9)].ParamList)->end();
6734       for (; I != E; ++I) {
6735         const Type *Ty = I->Val->getType();
6736         if (Ty == Type::VoidTy)
6737           GEN_ERROR("Short call syntax cannot be used with varargs");
6738         ParamTypes.push_back(Ty);
6739       }
6740
6741       if (!FunctionType::isValidReturnType(*(yyvsp[(4) - (9)].TypeVal)))
6742         GEN_ERROR("Invalid result type for LLVM function");
6743
6744       Ty = FunctionType::get((yyvsp[(4) - (9)].TypeVal)->get(), ParamTypes, false);
6745       PFTy = PointerType::getUnqual(Ty);
6746     }
6747
6748     Value *V = getVal(PFTy, (yyvsp[(5) - (9)].ValIDVal));   // Get the function we're calling...
6749     CHECK_FOR_ERROR
6750
6751     // Check for call to invalid intrinsic to avoid crashing later.
6752     if (Function *theF = dyn_cast<Function>(V)) {
6753       if (theF->hasName() && (theF->getValueName()->getKeyLength() >= 5) &&
6754           (0 == strncmp(theF->getValueName()->getKeyData(), "llvm.", 5)) &&
6755           !theF->getIntrinsicID(true))
6756         GEN_ERROR("Call to invalid LLVM intrinsic function '" +
6757                   theF->getName() + "'");
6758     }
6759
6760     // Set up the Attributes for the function
6761     SmallVector<AttributeWithIndex, 8> Attrs;
6762     //FIXME : In 3.0, stop accepting zext, sext and inreg as optional function
6763     //attributes.
6764     Attributes RetAttrs = (yyvsp[(3) - (9)].Attributes);
6765     if ((yyvsp[(9) - (9)].Attributes) != Attribute::None) {
6766       if ((yyvsp[(9) - (9)].Attributes) & Attribute::ZExt) {
6767         RetAttrs = RetAttrs | Attribute::ZExt;
6768         (yyvsp[(9) - (9)].Attributes) = (yyvsp[(9) - (9)].Attributes) ^ Attribute::ZExt;
6769       }
6770       if ((yyvsp[(9) - (9)].Attributes) & Attribute::SExt) {
6771         RetAttrs = RetAttrs | Attribute::SExt;
6772         (yyvsp[(9) - (9)].Attributes) = (yyvsp[(9) - (9)].Attributes) ^ Attribute::SExt;
6773       }
6774       if ((yyvsp[(9) - (9)].Attributes) & Attribute::InReg) {
6775         RetAttrs = RetAttrs | Attribute::InReg;
6776         (yyvsp[(9) - (9)].Attributes) = (yyvsp[(9) - (9)].Attributes) ^ Attribute::InReg;
6777       }
6778     }
6779     if (RetAttrs != Attribute::None)
6780       Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
6781
6782     // Check the arguments
6783     ValueList Args;
6784     if ((yyvsp[(7) - (9)].ParamList)->empty()) {                                   // Has no arguments?
6785       // Make sure no arguments is a good thing!
6786       if (Ty->getNumParams() != 0)
6787         GEN_ERROR("No arguments passed to a function that "
6788                        "expects arguments");
6789     } else {                                     // Has arguments?
6790       // Loop through FunctionType's arguments and ensure they are specified
6791       // correctly.  Also, gather any parameter attributes.
6792       FunctionType::param_iterator I = Ty->param_begin();
6793       FunctionType::param_iterator E = Ty->param_end();
6794       ParamList::iterator ArgI = (yyvsp[(7) - (9)].ParamList)->begin(), ArgE = (yyvsp[(7) - (9)].ParamList)->end();
6795       unsigned index = 1;
6796
6797       for (; ArgI != ArgE && I != E; ++ArgI, ++I, ++index) {
6798         if (ArgI->Val->getType() != *I)
6799           GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" +
6800                          (*I)->getDescription() + "'");
6801         Args.push_back(ArgI->Val);
6802         if (ArgI->Attrs != Attribute::None)
6803           Attrs.push_back(AttributeWithIndex::get(index, ArgI->Attrs));
6804       }
6805       if (Ty->isVarArg()) {
6806         if (I == E)
6807           for (; ArgI != ArgE; ++ArgI, ++index) {
6808             Args.push_back(ArgI->Val); // push the remaining varargs
6809             if (ArgI->Attrs != Attribute::None)
6810               Attrs.push_back(AttributeWithIndex::get(index, ArgI->Attrs));
6811           }
6812       } else if (I != E || ArgI != ArgE)
6813         GEN_ERROR("Invalid number of parameters detected");
6814     }
6815     if ((yyvsp[(9) - (9)].Attributes) != Attribute::None)
6816       Attrs.push_back(AttributeWithIndex::get(~0, (yyvsp[(9) - (9)].Attributes)));
6817
6818     // Finish off the Attributes and check them
6819     AttrListPtr PAL;
6820     if (!Attrs.empty())
6821       PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
6822
6823     // Create the call node
6824     CallInst *CI = CallInst::Create(V, Args.begin(), Args.end());
6825     CI->setTailCall((yyvsp[(1) - (9)].BoolVal));
6826     CI->setCallingConv((yyvsp[(2) - (9)].UIntVal));
6827     CI->setAttributes(PAL);
6828     (yyval.InstVal) = CI;
6829     delete (yyvsp[(7) - (9)].ParamList);
6830     delete (yyvsp[(4) - (9)].TypeVal);
6831     CHECK_FOR_ERROR
6832   ;}
6833     break;
6834
6835   case 335:
6836 #line 3393 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6837     {
6838     (yyval.InstVal) = (yyvsp[(1) - (1)].InstVal);
6839     CHECK_FOR_ERROR
6840   ;}
6841     break;
6842
6843   case 336:
6844 #line 3398 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6845     {
6846     (yyval.BoolVal) = true;
6847     CHECK_FOR_ERROR
6848   ;}
6849     break;
6850
6851   case 337:
6852 #line 3402 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6853     {
6854     (yyval.BoolVal) = false;
6855     CHECK_FOR_ERROR
6856   ;}
6857     break;
6858
6859   case 338:
6860 #line 3409 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6861     {
6862     if (!UpRefs.empty())
6863       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (3)].TypeVal))->getDescription());
6864     (yyval.InstVal) = new MallocInst(*(yyvsp[(2) - (3)].TypeVal), 0, (yyvsp[(3) - (3)].UIntVal));
6865     delete (yyvsp[(2) - (3)].TypeVal);
6866     CHECK_FOR_ERROR
6867   ;}
6868     break;
6869
6870   case 339:
6871 #line 3416 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6872     {
6873     if (!UpRefs.empty())
6874       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (6)].TypeVal))->getDescription());
6875     if ((yyvsp[(4) - (6)].PrimType) != Type::Int32Ty)
6876       GEN_ERROR("Malloc array size is not a 32-bit integer!");
6877     Value* tmpVal = getVal((yyvsp[(4) - (6)].PrimType), (yyvsp[(5) - (6)].ValIDVal));
6878     CHECK_FOR_ERROR
6879     (yyval.InstVal) = new MallocInst(*(yyvsp[(2) - (6)].TypeVal), tmpVal, (yyvsp[(6) - (6)].UIntVal));
6880     delete (yyvsp[(2) - (6)].TypeVal);
6881   ;}
6882     break;
6883
6884   case 340:
6885 #line 3426 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6886     {
6887     if (!UpRefs.empty())
6888       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (3)].TypeVal))->getDescription());
6889     (yyval.InstVal) = new AllocaInst(*(yyvsp[(2) - (3)].TypeVal), 0, (yyvsp[(3) - (3)].UIntVal));
6890     delete (yyvsp[(2) - (3)].TypeVal);
6891     CHECK_FOR_ERROR
6892   ;}
6893     break;
6894
6895   case 341:
6896 #line 3433 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6897     {
6898     if (!UpRefs.empty())
6899       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (6)].TypeVal))->getDescription());
6900     if ((yyvsp[(4) - (6)].PrimType) != Type::Int32Ty)
6901       GEN_ERROR("Alloca array size is not a 32-bit integer!");
6902     Value* tmpVal = getVal((yyvsp[(4) - (6)].PrimType), (yyvsp[(5) - (6)].ValIDVal));
6903     CHECK_FOR_ERROR
6904     (yyval.InstVal) = new AllocaInst(*(yyvsp[(2) - (6)].TypeVal), tmpVal, (yyvsp[(6) - (6)].UIntVal));
6905     delete (yyvsp[(2) - (6)].TypeVal);
6906   ;}
6907     break;
6908
6909   case 342:
6910 #line 3443 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6911     {
6912     if (!isa<PointerType>((yyvsp[(2) - (2)].ValueVal)->getType()))
6913       GEN_ERROR("Trying to free nonpointer type " +
6914                      (yyvsp[(2) - (2)].ValueVal)->getType()->getDescription() + "");
6915     (yyval.InstVal) = new FreeInst((yyvsp[(2) - (2)].ValueVal));
6916     CHECK_FOR_ERROR
6917   ;}
6918     break;
6919
6920   case 343:
6921 #line 3451 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6922     {
6923     if (!UpRefs.empty())
6924       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (5)].TypeVal))->getDescription());
6925     if (!isa<PointerType>((yyvsp[(3) - (5)].TypeVal)->get()))
6926       GEN_ERROR("Can't load from nonpointer type: " +
6927                      (*(yyvsp[(3) - (5)].TypeVal))->getDescription());
6928     if (!cast<PointerType>((yyvsp[(3) - (5)].TypeVal)->get())->getElementType()->isFirstClassType())
6929       GEN_ERROR("Can't load from pointer of non-first-class type: " +
6930                      (*(yyvsp[(3) - (5)].TypeVal))->getDescription());
6931     Value* tmpVal = getVal(*(yyvsp[(3) - (5)].TypeVal), (yyvsp[(4) - (5)].ValIDVal));
6932     CHECK_FOR_ERROR
6933     (yyval.InstVal) = new LoadInst(tmpVal, "", (yyvsp[(1) - (5)].BoolVal), (yyvsp[(5) - (5)].UIntVal));
6934     delete (yyvsp[(3) - (5)].TypeVal);
6935   ;}
6936     break;
6937
6938   case 344:
6939 #line 3465 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6940     {
6941     if (!UpRefs.empty())
6942       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(5) - (7)].TypeVal))->getDescription());
6943     const PointerType *PT = dyn_cast<PointerType>((yyvsp[(5) - (7)].TypeVal)->get());
6944     if (!PT)
6945       GEN_ERROR("Can't store to a nonpointer type: " +
6946                      (*(yyvsp[(5) - (7)].TypeVal))->getDescription());
6947     const Type *ElTy = PT->getElementType();
6948     if (ElTy != (yyvsp[(3) - (7)].ValueVal)->getType())
6949       GEN_ERROR("Can't store '" + (yyvsp[(3) - (7)].ValueVal)->getType()->getDescription() +
6950                      "' into space of type '" + ElTy->getDescription() + "'");
6951
6952     Value* tmpVal = getVal(*(yyvsp[(5) - (7)].TypeVal), (yyvsp[(6) - (7)].ValIDVal));
6953     CHECK_FOR_ERROR
6954     (yyval.InstVal) = new StoreInst((yyvsp[(3) - (7)].ValueVal), tmpVal, (yyvsp[(1) - (7)].BoolVal), (yyvsp[(7) - (7)].UIntVal));
6955     delete (yyvsp[(5) - (7)].TypeVal);
6956   ;}
6957     break;
6958
6959   case 345:
6960 #line 3482 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6961     {
6962     if (!UpRefs.empty())
6963       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (5)].TypeVal))->getDescription());
6964     if (!isa<StructType>((yyvsp[(2) - (5)].TypeVal)->get()) && !isa<ArrayType>((yyvsp[(2) - (5)].TypeVal)->get()))
6965       GEN_ERROR("getresult insn requires an aggregate operand");
6966     if (!ExtractValueInst::getIndexedType(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(5) - (5)].UInt64Val)))
6967       GEN_ERROR("Invalid getresult index for type '" +
6968                      (*(yyvsp[(2) - (5)].TypeVal))->getDescription()+ "'");
6969
6970     Value *tmpVal = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(3) - (5)].ValIDVal));
6971     CHECK_FOR_ERROR
6972     (yyval.InstVal) = ExtractValueInst::Create(tmpVal, (yyvsp[(5) - (5)].UInt64Val));
6973     delete (yyvsp[(2) - (5)].TypeVal);
6974   ;}
6975     break;
6976
6977   case 346:
6978 #line 3496 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6979     {
6980     if (!UpRefs.empty())
6981       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (4)].TypeVal))->getDescription());
6982     if (!isa<PointerType>((yyvsp[(2) - (4)].TypeVal)->get()))
6983       GEN_ERROR("getelementptr insn requires pointer operand");
6984
6985     if (!GetElementPtrInst::getIndexedType(*(yyvsp[(2) - (4)].TypeVal), (yyvsp[(4) - (4)].ValueList)->begin(), (yyvsp[(4) - (4)].ValueList)->end()))
6986       GEN_ERROR("Invalid getelementptr indices for type '" +
6987                      (*(yyvsp[(2) - (4)].TypeVal))->getDescription()+ "'");
6988     Value* tmpVal = getVal(*(yyvsp[(2) - (4)].TypeVal), (yyvsp[(3) - (4)].ValIDVal));
6989     CHECK_FOR_ERROR
6990     (yyval.InstVal) = GetElementPtrInst::Create(tmpVal, (yyvsp[(4) - (4)].ValueList)->begin(), (yyvsp[(4) - (4)].ValueList)->end());
6991     delete (yyvsp[(2) - (4)].TypeVal);
6992     delete (yyvsp[(4) - (4)].ValueList);
6993   ;}
6994     break;
6995
6996   case 347:
6997 #line 3511 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6998     {
6999     if (!UpRefs.empty())
7000       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (4)].TypeVal))->getDescription());
7001     if (!isa<StructType>((yyvsp[(2) - (4)].TypeVal)->get()) && !isa<ArrayType>((yyvsp[(2) - (4)].TypeVal)->get()))
7002       GEN_ERROR("extractvalue insn requires an aggregate operand");
7003
7004     if (!ExtractValueInst::getIndexedType(*(yyvsp[(2) - (4)].TypeVal), (yyvsp[(4) - (4)].ConstantList)->begin(), (yyvsp[(4) - (4)].ConstantList)->end()))
7005       GEN_ERROR("Invalid extractvalue indices for type '" +
7006                      (*(yyvsp[(2) - (4)].TypeVal))->getDescription()+ "'");
7007     Value* tmpVal = getVal(*(yyvsp[(2) - (4)].TypeVal), (yyvsp[(3) - (4)].ValIDVal));
7008     CHECK_FOR_ERROR
7009     (yyval.InstVal) = ExtractValueInst::Create(tmpVal, (yyvsp[(4) - (4)].ConstantList)->begin(), (yyvsp[(4) - (4)].ConstantList)->end());
7010     delete (yyvsp[(2) - (4)].TypeVal);
7011     delete (yyvsp[(4) - (4)].ConstantList);
7012   ;}
7013     break;
7014
7015   case 348:
7016 #line 3526 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
7017     {
7018     if (!UpRefs.empty())
7019       GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (7)].TypeVal))->getDescription());
7020     if (!isa<StructType>((yyvsp[(2) - (7)].TypeVal)->get()) && !isa<ArrayType>((yyvsp[(2) - (7)].TypeVal)->get()))
7021       GEN_ERROR("extractvalue insn requires an aggregate operand");
7022
7023     if (ExtractValueInst::getIndexedType(*(yyvsp[(2) - (7)].TypeVal), (yyvsp[(7) - (7)].ConstantList)->begin(), (yyvsp[(7) - (7)].ConstantList)->end()) != (yyvsp[(5) - (7)].TypeVal)->get())
7024       GEN_ERROR("Invalid insertvalue indices for type '" +
7025                      (*(yyvsp[(2) - (7)].TypeVal))->getDescription()+ "'");
7026     Value* aggVal = getVal(*(yyvsp[(2) - (7)].TypeVal), (yyvsp[(3) - (7)].ValIDVal));
7027     Value* tmpVal = getVal(*(yyvsp[(5) - (7)].TypeVal), (yyvsp[(6) - (7)].ValIDVal));
7028     CHECK_FOR_ERROR
7029     (yyval.InstVal) = InsertValueInst::Create(aggVal, tmpVal, (yyvsp[(7) - (7)].ConstantList)->begin(), (yyvsp[(7) - (7)].ConstantList)->end());
7030     delete (yyvsp[(2) - (7)].TypeVal);
7031     delete (yyvsp[(5) - (7)].TypeVal);
7032     delete (yyvsp[(7) - (7)].ConstantList);
7033   ;}
7034     break;
7035
7036
7037 /* Line 1267 of yacc.c.  */
7038 #line 7039 "llvmAsmParser.tab.c"
7039       default: break;
7040     }
7041   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
7042
7043   YYPOPSTACK (yylen);
7044   yylen = 0;
7045   YY_STACK_PRINT (yyss, yyssp);
7046
7047   *++yyvsp = yyval;
7048
7049
7050   /* Now `shift' the result of the reduction.  Determine what state
7051      that goes to, based on the state we popped back to and the rule
7052      number reduced by.  */
7053
7054   yyn = yyr1[yyn];
7055
7056   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
7057   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
7058     yystate = yytable[yystate];
7059   else
7060     yystate = yydefgoto[yyn - YYNTOKENS];
7061
7062   goto yynewstate;
7063
7064
7065 /*------------------------------------.
7066 | yyerrlab -- here on detecting error |
7067 `------------------------------------*/
7068 yyerrlab:
7069   /* If not already recovering from an error, report this error.  */
7070   if (!yyerrstatus)
7071     {
7072       ++yynerrs;
7073 #if ! YYERROR_VERBOSE
7074       yyerror (YY_("syntax error"));
7075 #else
7076       {
7077         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
7078         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
7079           {
7080             YYSIZE_T yyalloc = 2 * yysize;
7081             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
7082               yyalloc = YYSTACK_ALLOC_MAXIMUM;
7083             if (yymsg != yymsgbuf)
7084               YYSTACK_FREE (yymsg);
7085             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
7086             if (yymsg)
7087               yymsg_alloc = yyalloc;
7088             else
7089               {
7090                 yymsg = yymsgbuf;
7091                 yymsg_alloc = sizeof yymsgbuf;
7092               }
7093           }
7094
7095         if (0 < yysize && yysize <= yymsg_alloc)
7096           {
7097             (void) yysyntax_error (yymsg, yystate, yychar);
7098             yyerror (yymsg);
7099           }
7100         else
7101           {
7102             yyerror (YY_("syntax error"));
7103             if (yysize != 0)
7104               goto yyexhaustedlab;
7105           }
7106       }
7107 #endif
7108     }
7109
7110
7111
7112   if (yyerrstatus == 3)
7113     {
7114       /* If just tried and failed to reuse look-ahead token after an
7115          error, discard it.  */
7116
7117       if (yychar <= YYEOF)
7118         {
7119           /* Return failure if at end of input.  */
7120           if (yychar == YYEOF)
7121             YYABORT;
7122         }
7123       else
7124         {
7125           yydestruct ("Error: discarding",
7126                       yytoken, &yylval);
7127           yychar = YYEMPTY;
7128         }
7129     }
7130
7131   /* Else will try to reuse look-ahead token after shifting the error
7132      token.  */
7133   goto yyerrlab1;
7134
7135
7136 /*---------------------------------------------------.
7137 | yyerrorlab -- error raised explicitly by YYERROR.  |
7138 `---------------------------------------------------*/
7139 yyerrorlab:
7140
7141   /* Pacify compilers like GCC when the user code never invokes
7142      YYERROR and the label yyerrorlab therefore never appears in user
7143      code.  */
7144   if (/*CONSTCOND*/ 0)
7145      goto yyerrorlab;
7146
7147   /* Do not reclaim the symbols of the rule which action triggered
7148      this YYERROR.  */
7149   YYPOPSTACK (yylen);
7150   yylen = 0;
7151   YY_STACK_PRINT (yyss, yyssp);
7152   yystate = *yyssp;
7153   goto yyerrlab1;
7154
7155
7156 /*-------------------------------------------------------------.
7157 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
7158 `-------------------------------------------------------------*/
7159 yyerrlab1:
7160   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
7161
7162   for (;;)
7163     {
7164       yyn = yypact[yystate];
7165       if (yyn != YYPACT_NINF)
7166         {
7167           yyn += YYTERROR;
7168           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
7169             {
7170               yyn = yytable[yyn];
7171               if (0 < yyn)
7172                 break;
7173             }
7174         }
7175
7176       /* Pop the current state because it cannot handle the error token.  */
7177       if (yyssp == yyss)
7178         YYABORT;
7179
7180
7181       yydestruct ("Error: popping",
7182                   yystos[yystate], yyvsp);
7183       YYPOPSTACK (1);
7184       yystate = *yyssp;
7185       YY_STACK_PRINT (yyss, yyssp);
7186     }
7187
7188   if (yyn == YYFINAL)
7189     YYACCEPT;
7190
7191   *++yyvsp = yylval;
7192
7193
7194   /* Shift the error token.  */
7195   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
7196
7197   yystate = yyn;
7198   goto yynewstate;
7199
7200
7201 /*-------------------------------------.
7202 | yyacceptlab -- YYACCEPT comes here.  |
7203 `-------------------------------------*/
7204 yyacceptlab:
7205   yyresult = 0;
7206   goto yyreturn;
7207
7208 /*-----------------------------------.
7209 | yyabortlab -- YYABORT comes here.  |
7210 `-----------------------------------*/
7211 yyabortlab:
7212   yyresult = 1;
7213   goto yyreturn;
7214
7215 #ifndef yyoverflow
7216 /*-------------------------------------------------.
7217 | yyexhaustedlab -- memory exhaustion comes here.  |
7218 `-------------------------------------------------*/
7219 yyexhaustedlab:
7220   yyerror (YY_("memory exhausted"));
7221   yyresult = 2;
7222   /* Fall through.  */
7223 #endif
7224
7225 yyreturn:
7226   if (yychar != YYEOF && yychar != YYEMPTY)
7227      yydestruct ("Cleanup: discarding lookahead",
7228                  yytoken, &yylval);
7229   /* Do not reclaim the symbols of the rule which action triggered
7230      this YYABORT or YYACCEPT.  */
7231   YYPOPSTACK (yylen);
7232   YY_STACK_PRINT (yyss, yyssp);
7233   while (yyssp != yyss)
7234     {
7235       yydestruct ("Cleanup: popping",
7236                   yystos[*yyssp], yyvsp);
7237       YYPOPSTACK (1);
7238     }
7239 #ifndef yyoverflow
7240   if (yyss != yyssa)
7241     YYSTACK_FREE (yyss);
7242 #endif
7243 #if YYERROR_VERBOSE
7244   if (yymsg != yymsgbuf)
7245     YYSTACK_FREE (yymsg);
7246 #endif
7247   /* Make sure YYID is used.  */
7248   return YYID (yyresult);
7249 }
7250
7251
7252 #line 3545 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
7253
7254
7255 // common code from the two 'RunVMAsmParser' functions
7256 static Module* RunParser(Module * M) {
7257   CurModule.CurrentModule = M;
7258   // Check to make sure the parser succeeded
7259   if (yyparse()) {
7260     if (ParserResult)
7261       delete ParserResult;
7262     return 0;
7263   }
7264
7265   // Emit an error if there are any unresolved types left.
7266   if (!CurModule.LateResolveTypes.empty()) {
7267     const ValID &DID = CurModule.LateResolveTypes.begin()->first;
7268     if (DID.Type == ValID::LocalName) {
7269       GenerateError("Undefined type remains at eof: '"+DID.getName() + "'");
7270     } else {
7271       GenerateError("Undefined type remains at eof: #" + itostr(DID.Num));
7272     }
7273     if (ParserResult)
7274       delete ParserResult;
7275     return 0;
7276   }
7277
7278   // Emit an error if there are any unresolved values left.
7279   if (!CurModule.LateResolveValues.empty()) {
7280     Value *V = CurModule.LateResolveValues.back();
7281     std::map<Value*, std::pair<ValID, int> >::iterator I =
7282       CurModule.PlaceHolderInfo.find(V);
7283
7284     if (I != CurModule.PlaceHolderInfo.end()) {
7285       ValID &DID = I->second.first;
7286       if (DID.Type == ValID::LocalName) {
7287         GenerateError("Undefined value remains at eof: "+DID.getName() + "'");
7288       } else {
7289         GenerateError("Undefined value remains at eof: #" + itostr(DID.Num));
7290       }
7291       if (ParserResult)
7292         delete ParserResult;
7293       return 0;
7294     }
7295   }
7296
7297   // Check to make sure that parsing produced a result
7298   if (!ParserResult)
7299     return 0;
7300
7301   // Reset ParserResult variable while saving its value for the result.
7302   Module *Result = ParserResult;
7303   ParserResult = 0;
7304
7305   return Result;
7306 }
7307
7308 void llvm::GenerateError(const std::string &message, int LineNo) {
7309   if (LineNo == -1) LineNo = LLLgetLineNo();
7310   // TODO: column number in exception
7311   if (TheParseError)
7312     TheParseError->setError(LLLgetFilename(), message, LineNo);
7313   TriggerError = 1;
7314 }
7315
7316 int yyerror(const char *ErrorMsg) {
7317   std::string where = LLLgetFilename() + ":" + utostr(LLLgetLineNo()) + ": ";
7318   std::string errMsg = where + "error: " + std::string(ErrorMsg);
7319   if (yychar != YYEMPTY && yychar != 0) {
7320     errMsg += " while reading token: '";
7321     errMsg += std::string(LLLgetTokenStart(),
7322                           LLLgetTokenStart()+LLLgetTokenLength()) + "'";
7323   }
7324   GenerateError(errMsg);
7325   return 0;
7326 }
7327