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