lib/AsmParser/llvmAsmParser.cpp.cvs

   1
   2 /*  A Bison parser, made from /Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y
   3     by GNU Bison version 1.28  */
   4
   5 #define YYBISON 1  /* Identify Bison output.  */
   6
   7 #define yyparse llvmAsmparse
   8 #define yylex llvmAsmlex
   9 #define yyerror llvmAsmerror
  10 #define yylval llvmAsmlval
  11 #define yychar llvmAsmchar
  12 #define yydebug llvmAsmdebug
  13 #define yynerrs llvmAsmnerrs
  14 #define ESINT64VAL      257
  15 #define EUINT64VAL      258
  16 #define LOCALVAL_ID     259
  17 #define GLOBALVAL_ID    260
  18 #define FPVAL   261
  19 #define VOID    262
  20 #define INTTYPE 263
  21 #define FLOAT   264
  22 #define DOUBLE  265
  23 #define LABEL   266
  24 #define TYPE    267
  25 #define LOCALVAR        268
  26 #define GLOBALVAR       269
  27 #define LABELSTR        270
  28 #define STRINGCONSTANT  271
  29 #define ATSTRINGCONSTANT        272
  30 #define IMPLEMENTATION  273
  31 #define ZEROINITIALIZER 274
  32 #define TRUETOK 275
  33 #define FALSETOK        276
  34 #define BEGINTOK        277
  35 #define ENDTOK  278
  36 #define DECLARE 279
  37 #define DEFINE  280
  38 #define GLOBAL  281
  39 #define CONSTANT        282
  40 #define SECTION 283
  41 #define VOLATILE        284
  42 #define TO      285
  43 #define DOTDOTDOT       286
  44 #define NULL_TOK        287
  45 #define UNDEF   288
  46 #define INTERNAL        289
  47 #define LINKONCE        290
  48 #define WEAK    291
  49 #define APPENDING       292
  50 #define DLLIMPORT       293
  51 #define DLLEXPORT       294
  52 #define EXTERN_WEAK     295
  53 #define OPAQUE  296
  54 #define EXTERNAL        297
  55 #define TARGET  298
  56 #define TRIPLE  299
  57 #define ALIGN   300
  58 #define DEPLIBS 301
  59 #define CALL    302
  60 #define TAIL    303
  61 #define ASM_TOK 304
  62 #define MODULE  305
  63 #define SIDEEFFECT      306
  64 #define CC_TOK  307
  65 #define CCC_TOK 308
  66 #define FASTCC_TOK      309
  67 #define COLDCC_TOK      310
  68 #define X86_STDCALLCC_TOK       311
  69 #define X86_FASTCALLCC_TOK      312
  70 #define DATALAYOUT      313
  71 #define RET     314
  72 #define BR      315
  73 #define SWITCH  316
  74 #define INVOKE  317
  75 #define UNWIND  318
  76 #define UNREACHABLE     319
  77 #define ADD     320
  78 #define SUB     321
  79 #define MUL     322
  80 #define UDIV    323
  81 #define SDIV    324
  82 #define FDIV    325
  83 #define UREM    326
  84 #define SREM    327
  85 #define FREM    328
  86 #define AND     329
  87 #define OR      330
  88 #define XOR     331
  89 #define SHL     332
  90 #define LSHR    333
  91 #define ASHR    334
  92 #define ICMP    335
  93 #define FCMP    336
  94 #define EQ      337
  95 #define NE      338
  96 #define SLT     339
  97 #define SGT     340
  98 #define SLE     341
  99 #define SGE     342
 100 #define ULT     343
 101 #define UGT     344
 102 #define ULE     345
 103 #define UGE     346
 104 #define OEQ     347
 105 #define ONE     348
 106 #define OLT     349
 107 #define OGT     350
 108 #define OLE     351
 109 #define OGE     352
 110 #define ORD     353
 111 #define UNO     354
 112 #define UEQ     355
 113 #define UNE     356
 114 #define MALLOC  357
 115 #define ALLOCA  358
 116 #define FREE    359
 117 #define LOAD    360
 118 #define STORE   361
 119 #define GETELEMENTPTR   362
 120 #define TRUNC   363
 121 #define ZEXT    364
 122 #define SEXT    365
 123 #define FPTRUNC 366
 124 #define FPEXT   367
 125 #define BITCAST 368
 126 #define UITOFP  369
 127 #define SITOFP  370
 128 #define FPTOUI  371
 129 #define FPTOSI  372
 130 #define INTTOPTR        373
 131 #define PTRTOINT        374
 132 #define PHI_TOK 375
 133 #define SELECT  376
 134 #define VAARG   377
 135 #define EXTRACTELEMENT  378
 136 #define INSERTELEMENT   379
 137 #define SHUFFLEVECTOR   380
 138 #define NORETURN        381
 139 #define INREG   382
 140 #define SRET    383
 141 #define DEFAULT 384
 142 #define HIDDEN  385
 143
 144 #line 14 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
 145
 146 #include "ParserInternals.h"
 147 #include "llvm/CallingConv.h"
 148 #include "llvm/InlineAsm.h"
 149 #include "llvm/Instructions.h"
 150 #include "llvm/Module.h"
 151 #include "llvm/ValueSymbolTable.h"
 152 #include "llvm/Support/GetElementPtrTypeIterator.h"
 153 #include "llvm/Support/CommandLine.h"
 154 #include "llvm/ADT/SmallVector.h"
 155 #include "llvm/ADT/STLExtras.h"
 156 #include "llvm/Support/MathExtras.h"
 157 #include "llvm/Support/Streams.h"
 158 #include <algorithm>
 159 #include <list>
 160 #include <map>
 161 #include <utility>
 162 #ifndef NDEBUG
 163 #define YYDEBUG 1
 164 #endif
 165
 166 // The following is a gross hack. In order to rid the libAsmParser library of
 167 // exceptions, we have to have a way of getting the yyparse function to go into
 168 // an error situation. So, whenever we want an error to occur, the GenerateError
 169 // function (see bottom of file) sets TriggerError. Then, at the end of each
 170 // production in the grammer we use CHECK_FOR_ERROR which will invoke YYERROR
 171 // (a goto) to put YACC in error state. Furthermore, several calls to
 172 // GenerateError are made from inside productions and they must simulate the
 173 // previous exception behavior by exiting the production immediately. We have
 174 // replaced these with the GEN_ERROR macro which calls GeneratError and then
 175 // immediately invokes YYERROR. This would be so much cleaner if it was a
 176 // recursive descent parser.
 177 static bool TriggerError = false;
 178 #define CHECK_FOR_ERROR { if (TriggerError) { TriggerError = false; YYABORT; } }
 179 #define GEN_ERROR(msg) { GenerateError(msg); YYERROR; }
 180
 181 int yyerror(const char *ErrorMsg); // Forward declarations to prevent "implicit
 182 int yylex();                       // declaration" of xxx warnings.
 183 int yyparse();
 184
 185 namespace llvm {
 186   std::string CurFilename;
 187 #if YYDEBUG
 188 static cl::opt<bool>
 189 Debug("debug-yacc", cl::desc("Print yacc debug state changes"),
 190       cl::Hidden, cl::init(false));
 191 #endif
 192 }
 193 using namespace llvm;
 194
 195 static Module *ParserResult;
 196
 197 // DEBUG_UPREFS - Define this symbol if you want to enable debugging output
 198 // relating to upreferences in the input stream.
 199 //
 200 //#define DEBUG_UPREFS 1
 201 #ifdef DEBUG_UPREFS
 202 #define UR_OUT(X) cerr << X
 203 #else
 204 #define UR_OUT(X)
 205 #endif
 206
 207 #define YYERROR_VERBOSE 1
 208
 209 static GlobalVariable *CurGV;
 210
 211
 212 // This contains info used when building the body of a function.  It is
 213 // destroyed when the function is completed.
 214 //
 215 typedef std::vector<Value *> ValueList;           // Numbered defs
 216
 217 static void
 218 ResolveDefinitions(std::map<const Type *,ValueList> &LateResolvers,
 219                    std::map<const Type *,ValueList> *FutureLateResolvers = 0);
 220
 221 static struct PerModuleInfo {
 222   Module *CurrentModule;
 223   std::map<const Type *, ValueList> Values; // Module level numbered definitions
 224   std::map<const Type *,ValueList> LateResolveValues;
 225   std::vector<PATypeHolder>    Types;
 226   std::map<ValID, PATypeHolder> LateResolveTypes;
 227
 228   /// PlaceHolderInfo - When temporary placeholder objects are created, remember
 229   /// how they were referenced and on which line of the input they came from so
 230   /// that we can resolve them later and print error messages as appropriate.
 231   std::map<Value*, std::pair<ValID, int> > PlaceHolderInfo;
 232
 233   // GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward
 234   // references to global values.  Global values may be referenced before they
 235   // are defined, and if so, the temporary object that they represent is held
 236   // here.  This is used for forward references of GlobalValues.
 237   //
 238   typedef std::map<std::pair<const PointerType *,
 239                              ValID>, GlobalValue*> GlobalRefsType;
 240   GlobalRefsType GlobalRefs;
 241
 242   void ModuleDone() {
 243     // If we could not resolve some functions at function compilation time
 244     // (calls to functions before they are defined), resolve them now...  Types
 245     // are resolved when the constant pool has been completely parsed.
 246     //
 247     ResolveDefinitions(LateResolveValues);
 248     if (TriggerError)
 249       return;
 250
 251     // Check to make sure that all global value forward references have been
 252     // resolved!
 253     //
 254     if (!GlobalRefs.empty()) {
 255       std::string UndefinedReferences = "Unresolved global references exist:\n";
 256
 257       for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end();
 258            I != E; ++I) {
 259         UndefinedReferences += "  " + I->first.first->getDescription() + " " +
 260                                I->first.second.getName() + "\n";
 261       }
 262       GenerateError(UndefinedReferences);
 263       return;
 264     }
 265
 266     Values.clear();         // Clear out function local definitions
 267     Types.clear();
 268     CurrentModule = 0;
 269   }
 270
 271   // GetForwardRefForGlobal - Check to see if there is a forward reference
 272   // for this global.  If so, remove it from the GlobalRefs map and return it.
 273   // If not, just return null.
 274   GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) {
 275     // Check to see if there is a forward reference to this global variable...
 276     // if there is, eliminate it and patch the reference to use the new def'n.
 277     GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID));
 278     GlobalValue *Ret = 0;
 279     if (I != GlobalRefs.end()) {
 280       Ret = I->second;
 281       GlobalRefs.erase(I);
 282     }
 283     return Ret;
 284   }
 285
 286   bool TypeIsUnresolved(PATypeHolder* PATy) {
 287     // If it isn't abstract, its resolved
 288     const Type* Ty = PATy->get();
 289     if (!Ty->isAbstract())
 290       return false;
 291     // Traverse the type looking for abstract types. If it isn't abstract then
 292     // we don't need to traverse that leg of the type.
 293     std::vector<const Type*> WorkList, SeenList;
 294     WorkList.push_back(Ty);
 295     while (!WorkList.empty()) {
 296       const Type* Ty = WorkList.back();
 297       SeenList.push_back(Ty);
 298       WorkList.pop_back();
 299       if (const OpaqueType* OpTy = dyn_cast<OpaqueType>(Ty)) {
 300         // Check to see if this is an unresolved type
 301         std::map<ValID, PATypeHolder>::iterator I = LateResolveTypes.begin();
 302         std::map<ValID, PATypeHolder>::iterator E = LateResolveTypes.end();
 303         for ( ; I != E; ++I) {
 304           if (I->second.get() == OpTy)
 305             return true;
 306         }
 307       } else if (const SequentialType* SeqTy = dyn_cast<SequentialType>(Ty)) {
 308         const Type* TheTy = SeqTy->getElementType();
 309         if (TheTy->isAbstract() && TheTy != Ty) {
 310           std::vector<const Type*>::iterator I = SeenList.begin(),
 311                                              E = SeenList.end();
 312           for ( ; I != E; ++I)
 313             if (*I == TheTy)
 314               break;
 315           if (I == E)
 316             WorkList.push_back(TheTy);
 317         }
 318       } else if (const StructType* StrTy = dyn_cast<StructType>(Ty)) {
 319         for (unsigned i = 0; i < StrTy->getNumElements(); ++i) {
 320           const Type* TheTy = StrTy->getElementType(i);
 321           if (TheTy->isAbstract() && TheTy != Ty) {
 322             std::vector<const Type*>::iterator I = SeenList.begin(),
 323                                                E = SeenList.end();
 324             for ( ; I != E; ++I)
 325               if (*I == TheTy)
 326                 break;
 327             if (I == E)
 328               WorkList.push_back(TheTy);
 329           }
 330         }
 331       }
 332     }
 333     return false;
 334   }
 335
 336
 337 } CurModule;
 338
 339 static struct PerFunctionInfo {
 340   Function *CurrentFunction;     // Pointer to current function being created
 341
 342   std::map<const Type*, ValueList> Values; // Keep track of #'d definitions
 343   std::map<const Type*, ValueList> LateResolveValues;
 344   bool isDeclare;                   // Is this function a forward declararation?
 345   GlobalValue::LinkageTypes Linkage; // Linkage for forward declaration.
 346   GlobalValue::VisibilityTypes Visibility;
 347
 348   /// BBForwardRefs - When we see forward references to basic blocks, keep
 349   /// track of them here.
 350   std::map<BasicBlock*, std::pair<ValID, int> > BBForwardRefs;
 351   std::vector<BasicBlock*> NumberedBlocks;
 352   unsigned NextBBNum;
 353
 354   inline PerFunctionInfo() {
 355     CurrentFunction = 0;
 356     isDeclare = false;
 357     Linkage = GlobalValue::ExternalLinkage;
 358     Visibility = GlobalValue::DefaultVisibility;
 359   }
 360
 361   inline void FunctionStart(Function *M) {
 362     CurrentFunction = M;
 363     NextBBNum = 0;
 364   }
 365
 366   void FunctionDone() {
 367     NumberedBlocks.clear();
 368
 369     // Any forward referenced blocks left?
 370     if (!BBForwardRefs.empty()) {
 371       GenerateError("Undefined reference to label " +
 372                      BBForwardRefs.begin()->first->getName());
 373       return;
 374     }
 375
 376     // Resolve all forward references now.
 377     ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
 378
 379     Values.clear();         // Clear out function local definitions
 380     CurrentFunction = 0;
 381     isDeclare = false;
 382     Linkage = GlobalValue::ExternalLinkage;
 383     Visibility = GlobalValue::DefaultVisibility;
 384   }
 385 } CurFun;  // Info for the current function...
 386
 387 static bool inFunctionScope() { return CurFun.CurrentFunction != 0; }
 388
 389
 390 //===----------------------------------------------------------------------===//
 391 //               Code to handle definitions of all the types
 392 //===----------------------------------------------------------------------===//
 393
 394 static int InsertValue(Value *V,
 395                   std::map<const Type*,ValueList> &ValueTab = CurFun.Values) {
 396   if (V->hasName()) return -1;           // Is this a numbered definition?
 397
 398   // Yes, insert the value into the value table...
 399   ValueList &List = ValueTab[V->getType()];
 400   List.push_back(V);
 401   return List.size()-1;
 402 }
 403
 404 static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
 405   switch (D.Type) {
 406   case ValID::LocalID:               // Is it a numbered definition?
 407     // Module constants occupy the lowest numbered slots...
 408     if (D.Num < CurModule.Types.size())
 409       return CurModule.Types[D.Num];
 410     break;
 411   case ValID::LocalName:                 // Is it a named definition?
 412     if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
 413       D.destroy();  // Free old strdup'd memory...
 414       return N;
 415     }
 416     break;
 417   default:
 418     GenerateError("Internal parser error: Invalid symbol type reference");
 419     return 0;
 420   }
 421
 422   // If we reached here, we referenced either a symbol that we don't know about
 423   // or an id number that hasn't been read yet.  We may be referencing something
 424   // forward, so just create an entry to be resolved later and get to it...
 425   //
 426   if (DoNotImprovise) return 0;  // Do we just want a null to be returned?
 427
 428
 429   if (inFunctionScope()) {
 430     if (D.Type == ValID::LocalName) {
 431       GenerateError("Reference to an undefined type: '" + D.getName() + "'");
 432       return 0;
 433     } else {
 434       GenerateError("Reference to an undefined type: #" + utostr(D.Num));
 435       return 0;
 436     }
 437   }
 438
 439   std::map<ValID, PATypeHolder>::iterator I =CurModule.LateResolveTypes.find(D);
 440   if (I != CurModule.LateResolveTypes.end())
 441     return I->second;
 442
 443   Type *Typ = OpaqueType::get();
 444   CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
 445   return Typ;
 446  }
 447
 448 // getValNonImprovising - Look up the value specified by the provided type and
 449 // the provided ValID.  If the value exists and has already been defined, return
 450 // it.  Otherwise return null.
 451 //
 452 static Value *getValNonImprovising(const Type *Ty, const ValID &D) {
 453   if (isa<FunctionType>(Ty)) {
 454     GenerateError("Functions are not values and "
 455                    "must be referenced as pointers");
 456     return 0;
 457   }
 458
 459   switch (D.Type) {
 460   case ValID::LocalID: {                 // Is it a numbered definition?
 461     // Module constants occupy the lowest numbered slots.
 462     std::map<const Type*,ValueList>::iterator VI = CurFun.Values.find(Ty);
 463     // Make sure that our type is within bounds.
 464     if (VI == CurFun.Values.end()) return 0;
 465
 466     // Check that the number is within bounds.
 467     if (D.Num >= VI->second.size()) return 0;
 468
 469     return VI->second[D.Num];
 470   }
 471   case ValID::GlobalID: {                 // Is it a numbered definition?
 472     unsigned Num = D.Num;
 473
 474     // Module constants occupy the lowest numbered slots...
 475     std::map<const Type*,ValueList>::iterator VI = CurModule.Values.find(Ty);
 476     if (VI == CurModule.Values.end())
 477       return 0;
 478     if (D.Num >= VI->second.size())
 479       return 0;
 480     return VI->second[Num];
 481   }
 482
 483   case ValID::LocalName: {                // Is it a named definition?
 484     if (!inFunctionScope())
 485       return 0;
 486     ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
 487     Value *N = SymTab.lookup(D.Name);
 488     if (N == 0)
 489       return 0;
 490     if (N->getType() != Ty)
 491       return 0;
 492
 493     D.destroy();  // Free old strdup'd memory...
 494     return N;
 495   }
 496   case ValID::GlobalName: {                // Is it a named definition?
 497     ValueSymbolTable &SymTab = CurModule.CurrentModule->getValueSymbolTable();
 498     Value *N = SymTab.lookup(D.Name);
 499     if (N == 0)
 500       return 0;
 501     if (N->getType() != Ty)
 502       return 0;
 503
 504     D.destroy();  // Free old strdup'd memory...
 505     return N;
 506   }
 507
 508   // Check to make sure that "Ty" is an integral type, and that our
 509   // value will fit into the specified type...
 510   case ValID::ConstSIntVal:    // Is it a constant pool reference??
 511     if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
 512       GenerateError("Signed integral constant '" +
 513                      itostr(D.ConstPool64) + "' is invalid for type '" +
 514                      Ty->getDescription() + "'");
 515       return 0;
 516     }
 517     return ConstantInt::get(Ty, D.ConstPool64);
 518
 519   case ValID::ConstUIntVal:     // Is it an unsigned const pool reference?
 520     if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) {
 521       if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
 522         GenerateError("Integral constant '" + utostr(D.UConstPool64) +
 523                        "' is invalid or out of range");
 524         return 0;
 525       } else {     // This is really a signed reference.  Transmogrify.
 526         return ConstantInt::get(Ty, D.ConstPool64);
 527       }
 528     } else {
 529       return ConstantInt::get(Ty, D.UConstPool64);
 530     }
 531
 532   case ValID::ConstFPVal:        // Is it a floating point const pool reference?
 533     if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP)) {
 534       GenerateError("FP constant invalid for type");
 535       return 0;
 536     }
 537     return ConstantFP::get(Ty, D.ConstPoolFP);
 538
 539   case ValID::ConstNullVal:      // Is it a null value?
 540     if (!isa<PointerType>(Ty)) {
 541       GenerateError("Cannot create a a non pointer null");
 542       return 0;
 543     }
 544     return ConstantPointerNull::get(cast<PointerType>(Ty));
 545
 546   case ValID::ConstUndefVal:      // Is it an undef value?
 547     return UndefValue::get(Ty);
 548
 549   case ValID::ConstZeroVal:      // Is it a zero value?
 550     return Constant::getNullValue(Ty);
 551
 552   case ValID::ConstantVal:       // Fully resolved constant?
 553     if (D.ConstantValue->getType() != Ty) {
 554       GenerateError("Constant expression type different from required type");
 555       return 0;
 556     }
 557     return D.ConstantValue;
 558
 559   case ValID::InlineAsmVal: {    // Inline asm expression
 560     const PointerType *PTy = dyn_cast<PointerType>(Ty);
 561     const FunctionType *FTy =
 562       PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
 563     if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints)) {
 564       GenerateError("Invalid type for asm constraint string");
 565       return 0;
 566     }
 567     InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
 568                                    D.IAD->HasSideEffects);
 569     D.destroy();   // Free InlineAsmDescriptor.
 570     return IA;
 571   }
 572   default:
 573     assert(0 && "Unhandled case!");
 574     return 0;
 575   }   // End of switch
 576
 577   assert(0 && "Unhandled case!");
 578   return 0;
 579 }
 580
 581 // getVal - This function is identical to getValNonImprovising, except that if a
 582 // value is not already defined, it "improvises" by creating a placeholder var
 583 // that looks and acts just like the requested variable.  When the value is
 584 // defined later, all uses of the placeholder variable are replaced with the
 585 // real thing.
 586 //
 587 static Value *getVal(const Type *Ty, const ValID &ID) {
 588   if (Ty == Type::LabelTy) {
 589     GenerateError("Cannot use a basic block here");
 590     return 0;
 591   }
 592
 593   // See if the value has already been defined.
 594   Value *V = getValNonImprovising(Ty, ID);
 595   if (V) return V;
 596   if (TriggerError) return 0;
 597
 598   if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty)) {
 599     GenerateError("Invalid use of a composite type");
 600     return 0;
 601   }
 602
 603   // If we reached here, we referenced either a symbol that we don't know about
 604   // or an id number that hasn't been read yet.  We may be referencing something
 605   // forward, so just create an entry to be resolved later and get to it...
 606   //
 607   V = new Argument(Ty);
 608
 609   // Remember where this forward reference came from.  FIXME, shouldn't we try
 610   // to recycle these things??
 611   CurModule.PlaceHolderInfo.insert(std::make_pair(V, std::make_pair(ID,
 612                                                                llvmAsmlineno)));
 613
 614   if (inFunctionScope())
 615     InsertValue(V, CurFun.LateResolveValues);
 616   else
 617     InsertValue(V, CurModule.LateResolveValues);
 618   return V;
 619 }
 620
 621 /// getBBVal - This is used for two purposes:
 622 ///  * If isDefinition is true, a new basic block with the specified ID is being
 623 ///    defined.
 624 ///  * If isDefinition is true, this is a reference to a basic block, which may
 625 ///    or may not be a forward reference.
 626 ///
 627 static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
 628   assert(inFunctionScope() && "Can't get basic block at global scope!");
 629
 630   std::string Name;
 631   BasicBlock *BB = 0;
 632   switch (ID.Type) {
 633   default:
 634     GenerateError("Illegal label reference " + ID.getName());
 635     return 0;
 636   case ValID::LocalID:                // Is it a numbered definition?
 637     if (ID.Num >= CurFun.NumberedBlocks.size())
 638       CurFun.NumberedBlocks.resize(ID.Num+1);
 639     BB = CurFun.NumberedBlocks[ID.Num];
 640     break;
 641   case ValID::LocalName:                  // Is it a named definition?
 642     Name = ID.Name;
 643     Value *N = CurFun.CurrentFunction->getValueSymbolTable().lookup(Name);
 644     if (N && N->getType()->getTypeID() == Type::LabelTyID)
 645       BB = cast<BasicBlock>(N);
 646     break;
 647   }
 648
 649   // See if the block has already been defined.
 650   if (BB) {
 651     // If this is the definition of the block, make sure the existing value was
 652     // just a forward reference.  If it was a forward reference, there will be
 653     // an entry for it in the PlaceHolderInfo map.
 654     if (isDefinition && !CurFun.BBForwardRefs.erase(BB)) {
 655       // The existing value was a definition, not a forward reference.
 656       GenerateError("Redefinition of label " + ID.getName());
 657       return 0;
 658     }
 659
 660     ID.destroy();                       // Free strdup'd memory.
 661     return BB;
 662   }
 663
 664   // Otherwise this block has not been seen before.
 665   BB = new BasicBlock("", CurFun.CurrentFunction);
 666   if (ID.Type == ValID::LocalName) {
 667     BB->setName(ID.Name);
 668   } else {
 669     CurFun.NumberedBlocks[ID.Num] = BB;
 670   }
 671
 672   // If this is not a definition, keep track of it so we can use it as a forward
 673   // reference.
 674   if (!isDefinition) {
 675     // Remember where this forward reference came from.
 676     CurFun.BBForwardRefs[BB] = std::make_pair(ID, llvmAsmlineno);
 677   } else {
 678     // The forward declaration could have been inserted anywhere in the
 679     // function: insert it into the correct place now.
 680     CurFun.CurrentFunction->getBasicBlockList().remove(BB);
 681     CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
 682   }
 683   ID.destroy();
 684   return BB;
 685 }
 686
 687
 688 //===----------------------------------------------------------------------===//
 689 //              Code to handle forward references in instructions
 690 //===----------------------------------------------------------------------===//
 691 //
 692 // This code handles the late binding needed with statements that reference
 693 // values not defined yet... for example, a forward branch, or the PHI node for
 694 // a loop body.
 695 //
 696 // This keeps a table (CurFun.LateResolveValues) of all such forward references
 697 // and back patchs after we are done.
 698 //
 699
 700 // ResolveDefinitions - If we could not resolve some defs at parsing
 701 // time (forward branches, phi functions for loops, etc...) resolve the
 702 // defs now...
 703 //
 704 static void
 705 ResolveDefinitions(std::map<const Type*,ValueList> &LateResolvers,
 706                    std::map<const Type*,ValueList> *FutureLateResolvers) {
 707   // Loop over LateResolveDefs fixing up stuff that couldn't be resolved
 708   for (std::map<const Type*,ValueList>::iterator LRI = LateResolvers.begin(),
 709          E = LateResolvers.end(); LRI != E; ++LRI) {
 710     ValueList &List = LRI->second;
 711     while (!List.empty()) {
 712       Value *V = List.back();
 713       List.pop_back();
 714
 715       std::map<Value*, std::pair<ValID, int> >::iterator PHI =
 716         CurModule.PlaceHolderInfo.find(V);
 717       assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error!");
 718
 719       ValID &DID = PHI->second.first;
 720
 721       Value *TheRealValue = getValNonImprovising(LRI->first, DID);
 722       if (TriggerError)
 723         return;
 724       if (TheRealValue) {
 725         V->replaceAllUsesWith(TheRealValue);
 726         delete V;
 727         CurModule.PlaceHolderInfo.erase(PHI);
 728       } else if (FutureLateResolvers) {
 729         // Functions have their unresolved items forwarded to the module late
 730         // resolver table
 731         InsertValue(V, *FutureLateResolvers);
 732       } else {
 733         if (DID.Type == ValID::LocalName || DID.Type == ValID::GlobalName) {
 734           GenerateError("Reference to an invalid definition: '" +DID.getName()+
 735                          "' of type '" + V->getType()->getDescription() + "'",
 736                          PHI->second.second);
 737           return;
 738         } else {
 739           GenerateError("Reference to an invalid definition: #" +
 740                          itostr(DID.Num) + " of type '" +
 741                          V->getType()->getDescription() + "'",
 742                          PHI->second.second);
 743           return;
 744         }
 745       }
 746     }
 747   }
 748
 749   LateResolvers.clear();
 750 }
 751
 752 // ResolveTypeTo - A brand new type was just declared.  This means that (if
 753 // name is not null) things referencing Name can be resolved.  Otherwise, things
 754 // refering to the number can be resolved.  Do this now.
 755 //
 756 static void ResolveTypeTo(char *Name, const Type *ToTy) {
 757   ValID D;
 758   if (Name) D = ValID::createLocalName(Name);
 759   else      D = ValID::createLocalID(CurModule.Types.size());
 760
 761   std::map<ValID, PATypeHolder>::iterator I =
 762     CurModule.LateResolveTypes.find(D);
 763   if (I != CurModule.LateResolveTypes.end()) {
 764     ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy);
 765     CurModule.LateResolveTypes.erase(I);
 766   }
 767 }
 768
 769 // setValueName - Set the specified value to the name given.  The name may be
 770 // null potentially, in which case this is a noop.  The string passed in is
 771 // assumed to be a malloc'd string buffer, and is free'd by this function.
 772 //
 773 static void setValueName(Value *V, char *NameStr) {
 774   if (!NameStr) return;
 775   std::string Name(NameStr);      // Copy string
 776   free(NameStr);                  // Free old string
 777
 778   if (V->getType() == Type::VoidTy) {
 779     GenerateError("Can't assign name '" + Name+"' to value with void type");
 780     return;
 781   }
 782
 783   assert(inFunctionScope() && "Must be in function scope!");
 784   ValueSymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
 785   if (ST.lookup(Name)) {
 786     GenerateError("Redefinition of value '" + Name + "' of type '" +
 787                    V->getType()->getDescription() + "'");
 788     return;
 789   }
 790
 791   // Set the name.
 792   V->setName(Name);
 793 }
 794
 795 /// ParseGlobalVariable - Handle parsing of a global.  If Initializer is null,
 796 /// this is a declaration, otherwise it is a definition.
 797 static GlobalVariable *
 798 ParseGlobalVariable(char *NameStr,
 799                     GlobalValue::LinkageTypes Linkage,
 800                     GlobalValue::VisibilityTypes Visibility,
 801                     bool isConstantGlobal, const Type *Ty,
 802                     Constant *Initializer) {
 803   if (isa<FunctionType>(Ty)) {
 804     GenerateError("Cannot declare global vars of function type");
 805     return 0;
 806   }
 807
 808   const PointerType *PTy = PointerType::get(Ty);
 809
 810   std::string Name;
 811   if (NameStr) {
 812     Name = NameStr;      // Copy string
 813     free(NameStr);       // Free old string
 814   }
 815
 816   // See if this global value was forward referenced.  If so, recycle the
 817   // object.
 818   ValID ID;
 819   if (!Name.empty()) {
 820     ID = ValID::createGlobalName((char*)Name.c_str());
 821   } else {
 822     ID = ValID::createGlobalID(CurModule.Values[PTy].size());
 823   }
 824
 825   if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
 826     // Move the global to the end of the list, from whereever it was
 827     // previously inserted.
 828     GlobalVariable *GV = cast<GlobalVariable>(FWGV);
 829     CurModule.CurrentModule->getGlobalList().remove(GV);
 830     CurModule.CurrentModule->getGlobalList().push_back(GV);
 831     GV->setInitializer(Initializer);
 832     GV->setLinkage(Linkage);
 833     GV->setVisibility(Visibility);
 834     GV->setConstant(isConstantGlobal);
 835     InsertValue(GV, CurModule.Values);
 836     return GV;
 837   }
 838
 839   // If this global has a name
 840   if (!Name.empty()) {
 841     // if the global we're parsing has an initializer (is a definition) and
 842     // has external linkage.
 843     if (Initializer && Linkage != GlobalValue::InternalLinkage)
 844       // If there is already a global with external linkage with this name
 845       if (CurModule.CurrentModule->getGlobalVariable(Name, false)) {
 846         // If we allow this GVar to get created, it will be renamed in the
 847         // symbol table because it conflicts with an existing GVar. We can't
 848         // allow redefinition of GVars whose linking indicates that their name
 849         // must stay the same. Issue the error.
 850         GenerateError("Redefinition of global variable named '" + Name +
 851                        "' of type '" + Ty->getDescription() + "'");
 852         return 0;
 853       }
 854   }
 855
 856   // Otherwise there is no existing GV to use, create one now.
 857   GlobalVariable *GV =
 858     new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
 859                        CurModule.CurrentModule);
 860   GV->setVisibility(Visibility);
 861   InsertValue(GV, CurModule.Values);
 862   return GV;
 863 }
 864
 865 // setTypeName - Set the specified type to the name given.  The name may be
 866 // null potentially, in which case this is a noop.  The string passed in is
 867 // assumed to be a malloc'd string buffer, and is freed by this function.
 868 //
 869 // This function returns true if the type has already been defined, but is
 870 // allowed to be redefined in the specified context.  If the name is a new name
 871 // for the type plane, it is inserted and false is returned.
 872 static bool setTypeName(const Type *T, char *NameStr) {
 873   assert(!inFunctionScope() && "Can't give types function-local names!");
 874   if (NameStr == 0) return false;
 875
 876   std::string Name(NameStr);      // Copy string
 877   free(NameStr);                  // Free old string
 878
 879   // We don't allow assigning names to void type
 880   if (T == Type::VoidTy) {
 881     GenerateError("Can't assign name '" + Name + "' to the void type");
 882     return false;
 883   }
 884
 885   // Set the type name, checking for conflicts as we do so.
 886   bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T);
 887
 888   if (AlreadyExists) {   // Inserting a name that is already defined???
 889     const Type *Existing = CurModule.CurrentModule->getTypeByName(Name);
 890     assert(Existing && "Conflict but no matching type?!");
 891
 892     // There is only one case where this is allowed: when we are refining an
 893     // opaque type.  In this case, Existing will be an opaque type.
 894     if (const OpaqueType *OpTy = dyn_cast<OpaqueType>(Existing)) {
 895       // We ARE replacing an opaque type!
 896       const_cast<OpaqueType*>(OpTy)->refineAbstractTypeTo(T);
 897       return true;
 898     }
 899
 900     // Otherwise, this is an attempt to redefine a type. That's okay if
 901     // the redefinition is identical to the original. This will be so if
 902     // Existing and T point to the same Type object. In this one case we
 903     // allow the equivalent redefinition.
 904     if (Existing == T) return true;  // Yes, it's equal.
 905
 906     // Any other kind of (non-equivalent) redefinition is an error.
 907     GenerateError("Redefinition of type named '" + Name + "' of type '" +
 908                    T->getDescription() + "'");
 909   }
 910
 911   return false;
 912 }
 913
 914 //===----------------------------------------------------------------------===//
 915 // Code for handling upreferences in type names...
 916 //
 917
 918 // TypeContains - Returns true if Ty directly contains E in it.
 919 //
 920 static bool TypeContains(const Type *Ty, const Type *E) {
 921   return std::find(Ty->subtype_begin(), Ty->subtype_end(),
 922                    E) != Ty->subtype_end();
 923 }
 924
 925 namespace {
 926   struct UpRefRecord {
 927     // NestingLevel - The number of nesting levels that need to be popped before
 928     // this type is resolved.
 929     unsigned NestingLevel;
 930
 931     // LastContainedTy - This is the type at the current binding level for the
 932     // type.  Every time we reduce the nesting level, this gets updated.
 933     const Type *LastContainedTy;
 934
 935     // UpRefTy - This is the actual opaque type that the upreference is
 936     // represented with.
 937     OpaqueType *UpRefTy;
 938
 939     UpRefRecord(unsigned NL, OpaqueType *URTy)
 940       : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {}
 941   };
 942 }
 943
 944 // UpRefs - A list of the outstanding upreferences that need to be resolved.
 945 static std::vector<UpRefRecord> UpRefs;
 946
 947 /// HandleUpRefs - Every time we finish a new layer of types, this function is
 948 /// called.  It loops through the UpRefs vector, which is a list of the
 949 /// currently active types.  For each type, if the up reference is contained in
 950 /// the newly completed type, we decrement the level count.  When the level
 951 /// count reaches zero, the upreferenced type is the type that is passed in:
 952 /// thus we can complete the cycle.
 953 ///
 954 static PATypeHolder HandleUpRefs(const Type *ty) {
 955   // If Ty isn't abstract, or if there are no up-references in it, then there is
 956   // nothing to resolve here.
 957   if (!ty->isAbstract() || UpRefs.empty()) return ty;
 958
 959   PATypeHolder Ty(ty);
 960   UR_OUT("Type '" << Ty->getDescription() <<
 961          "' newly formed.  Resolving upreferences.\n" <<
 962          UpRefs.size() << " upreferences active!\n");
 963
 964   // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
 965   // to zero), we resolve them all together before we resolve them to Ty.  At
 966   // the end of the loop, if there is anything to resolve to Ty, it will be in
 967   // this variable.
 968   OpaqueType *TypeToResolve = 0;
 969
 970   for (unsigned i = 0; i != UpRefs.size(); ++i) {
 971     UR_OUT("  UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
 972            << UpRefs[i].second->getDescription() << ") = "
 973            << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n");
 974     if (TypeContains(Ty, UpRefs[i].LastContainedTy)) {
 975       // Decrement level of upreference
 976       unsigned Level = --UpRefs[i].NestingLevel;
 977       UpRefs[i].LastContainedTy = Ty;
 978       UR_OUT("  Uplevel Ref Level = " << Level << "\n");
 979       if (Level == 0) {                     // Upreference should be resolved!
 980         if (!TypeToResolve) {
 981           TypeToResolve = UpRefs[i].UpRefTy;
 982         } else {
 983           UR_OUT("  * Resolving upreference for "
 984                  << UpRefs[i].second->getDescription() << "\n";
 985                  std::string OldName = UpRefs[i].UpRefTy->getDescription());
 986           UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
 987           UR_OUT("  * Type '" << OldName << "' refined upreference to: "
 988                  << (const void*)Ty << ", " << Ty->getDescription() << "\n");
 989         }
 990         UpRefs.erase(UpRefs.begin()+i);     // Remove from upreference list...
 991         --i;                                // Do not skip the next element...
 992       }
 993     }
 994   }
 995
 996   if (TypeToResolve) {
 997     UR_OUT("  * Resolving upreference for "
 998            << UpRefs[i].second->getDescription() << "\n";
 999            std::string OldName = TypeToResolve->getDescription());
1000     TypeToResolve->refineAbstractTypeTo(Ty);
1001   }
1002
1003   return Ty;
1004 }
1005
1006 //===----------------------------------------------------------------------===//
1007 //            RunVMAsmParser - Define an interface to this parser
1008 //===----------------------------------------------------------------------===//
1009 //
1010 static Module* RunParser(Module * M);
1011
1012 Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) {
1013   set_scan_file(F);
1014
1015   CurFilename = Filename;
1016   return RunParser(new Module(CurFilename));
1017 }
1018
1019 Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) {
1020   set_scan_string(AsmString);
1021
1022   CurFilename = "from_memory";
1023   if (M == NULL) {
1024     return RunParser(new Module (CurFilename));
1025   } else {
1026     return RunParser(M);
1027   }
1028 }
1029
1030
1031 #line 901 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
1032 typedef union {
1033   llvm::Module                           *ModuleVal;
1034   llvm::Function                         *FunctionVal;
1035   llvm::BasicBlock                       *BasicBlockVal;
1036   llvm::TerminatorInst                   *TermInstVal;
1037   llvm::Instruction                      *InstVal;
1038   llvm::Constant                         *ConstVal;
1039
1040   const llvm::Type                       *PrimType;
1041   std::list<llvm::PATypeHolder>          *TypeList;
1042   llvm::PATypeHolder                     *TypeVal;
1043   llvm::Value                            *ValueVal;
1044   std::vector<llvm::Value*>              *ValueList;
1045   llvm::ArgListType                      *ArgList;
1046   llvm::TypeWithAttrs                     TypeWithAttrs;
1047   llvm::TypeWithAttrsList                *TypeWithAttrsList;
1048   llvm::ValueRefList                     *ValueRefList;
1049
1050   // Represent the RHS of PHI node
1051   std::list<std::pair<llvm::Value*,
1052                       llvm::BasicBlock*> > *PHIList;
1053   std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable;
1054   std::vector<llvm::Constant*>           *ConstVector;
1055
1056   llvm::GlobalValue::LinkageTypes         Linkage;
1057   llvm::GlobalValue::VisibilityTypes      Visibility;
1058   llvm::FunctionType::ParameterAttributes ParamAttrs;
1059   int64_t                           SInt64Val;
1060   uint64_t                          UInt64Val;
1061   int                               SIntVal;
1062   unsigned                          UIntVal;
1063   double                            FPVal;
1064   bool                              BoolVal;
1065
1066   char                             *StrVal;   // This memory is strdup'd!
1067   llvm::ValID                       ValIDVal; // strdup'd memory maybe!
1068
1069   llvm::Instruction::BinaryOps      BinaryOpVal;
1070   llvm::Instruction::TermOps        TermOpVal;
1071   llvm::Instruction::MemoryOps      MemOpVal;
1072   llvm::Instruction::CastOps        CastOpVal;
1073   llvm::Instruction::OtherOps       OtherOpVal;
1074   llvm::ICmpInst::Predicate         IPredicate;
1075   llvm::FCmpInst::Predicate         FPredicate;
1076 } YYSTYPE;
1077 #include <stdio.h>
1078
1079 #ifndef __cplusplus
1080 #ifndef __STDC__
1081 #define const
1082 #endif
1083 #endif
1084
1085
1086
1087 #define YYFINAL         557
1088 #define YYFLAG          -32768
1089 #define YYNTBASE        146
1090
1091 #define YYTRANSLATE(x) ((unsigned)(x) <= 385 ? yytranslate[x] : 223)
1092
1093 static const short yytranslate[] = {     0,
1094      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1095      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1096      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1097      2,     2,     2,     2,     2,     2,     2,     2,     2,   136,
1098    137,   134,     2,   133,     2,     2,     2,     2,     2,     2,
1099      2,     2,     2,     2,     2,     2,     2,     2,     2,   141,
1100    132,   142,     2,     2,     2,     2,     2,     2,     2,     2,
1101      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1102      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1103    138,   135,   140,     2,     2,     2,     2,     2,   145,     2,
1104      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1105      2,     2,     2,     2,     2,     2,     2,     2,     2,   139,
1106      2,     2,   143,     2,   144,     2,     2,     2,     2,     2,
1107      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1108      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1109      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1110      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1111      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1112      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1113      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1114      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1115      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1116      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1117      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1118      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1119      2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
1120      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
1121     17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
1122     27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
1123     37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
1124     47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
1125     57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
1126     67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
1127     77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
1128     87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
1129     97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
1130    107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
1131    117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
1132    127,   128,   129,   130,   131
1133 };
1134
1135 #if YYDEBUG != 0
1136 static const short yyprhs[] = {     0,
1137      0,     2,     4,     6,     8,    10,    12,    14,    16,    18,
1138     20,    22,    24,    26,    28,    30,    32,    34,    36,    38,
1139     40,    42,    44,    46,    48,    50,    52,    54,    56,    58,
1140     60,    62,    64,    66,    68,    70,    72,    74,    76,    78,
1141     80,    82,    84,    86,    88,    90,    92,    94,    96,    98,
1142    100,   102,   104,   106,   108,   110,   112,   114,   116,   118,
1143    119,   122,   123,   125,   127,   130,   131,   133,   135,   137,
1144    139,   141,   143,   145,   147,   148,   150,   151,   153,   155,
1145    156,   158,   160,   162,   164,   165,   167,   169,   171,   173,
1146    175,   178,   180,   182,   184,   186,   187,   190,   192,   194,
1147    195,   198,   199,   202,   203,   207,   210,   211,   213,   214,
1148    218,   220,   223,   225,   227,   229,   231,   233,   235,   238,
1149    240,   243,   249,   255,   261,   267,   271,   274,   280,   285,
1150    288,   290,   292,   294,   298,   300,   304,   306,   307,   309,
1151    313,   318,   322,   326,   331,   336,   340,   347,   353,   356,
1152    359,   362,   365,   368,   371,   374,   377,   380,   383,   390,
1153    396,   405,   412,   419,   427,   435,   442,   451,   460,   464,
1154    466,   468,   470,   472,   473,   475,   478,   479,   483,   484,
1155    488,   492,   494,   498,   502,   503,   510,   511,   519,   520,
1156    528,   531,   535,   537,   541,   545,   549,   553,   555,   556,
1157    562,   566,   568,   572,   574,   575,   585,   587,   589,   594,
1158    596,   598,   601,   605,   606,   608,   610,   612,   614,   616,
1159    618,   620,   622,   624,   628,   630,   636,   638,   640,   642,
1160    644,   646,   648,   651,   654,   657,   661,   664,   665,   667,
1161    670,   673,   677,   687,   697,   706,   721,   723,   725,   732,
1162    738,   741,   748,   756,   760,   766,   767,   768,   772,   775,
1163    777,   783,   789,   796,   803,   808,   815,   820,   825,   832,
1164    839,   842,   851,   853,   855,   856,   860,   867,   871,   878,
1165    881,   886,   893
1166 };
1167
1168 static const short yyrhs[] = {    66,
1169      0,    67,     0,    68,     0,    69,     0,    70,     0,    71,
1170      0,    72,     0,    73,     0,    74,     0,    78,     0,    79,
1171      0,    80,     0,    75,     0,    76,     0,    77,     0,   109,
1172      0,   110,     0,   111,     0,   112,     0,   113,     0,   114,
1173      0,   115,     0,   116,     0,   117,     0,   118,     0,   119,
1174      0,   120,     0,    83,     0,    84,     0,    85,     0,    86,
1175      0,    87,     0,    88,     0,    89,     0,    90,     0,    91,
1176      0,    92,     0,    93,     0,    94,     0,    95,     0,    96,
1177      0,    97,     0,    98,     0,    99,     0,   100,     0,   101,
1178      0,   102,     0,    89,     0,    90,     0,    91,     0,    92,
1179      0,    21,     0,    22,     0,     9,     0,    10,     0,    11,
1180      0,    14,     0,    17,     0,   153,     0,     0,   153,   132,
1181      0,     0,    15,     0,    18,     0,   156,   132,     0,     0,
1182     35,     0,    37,     0,    36,     0,    38,     0,    40,     0,
1183     39,     0,    41,     0,    43,     0,     0,   131,     0,     0,
1184     39,     0,    41,     0,     0,    35,     0,    36,     0,    37,
1185      0,    40,     0,     0,    54,     0,    55,     0,    56,     0,
1186     57,     0,    58,     0,    53,     4,     0,   110,     0,   111,
1187      0,   128,     0,   129,     0,     0,   165,   164,     0,   127,
1188      0,   164,     0,     0,   167,   166,     0,     0,    46,     4,
1189      0,     0,   133,    46,     4,     0,    29,    17,     0,     0,
1190    170,     0,     0,   133,   173,   172,     0,   170,     0,    46,
1191      4,     0,     9,     0,    10,     0,    11,     0,    12,     0,
1192     42,     0,   174,     0,   175,   134,     0,   207,     0,   135,
1193      4,     0,   175,   136,   179,   137,   167,     0,     8,   136,
1194    179,   137,   167,     0,   138,     4,   139,   175,   140,     0,
1195    141,     4,   139,   175,   142,     0,   143,   180,   144,     0,
1196    143,   144,     0,   141,   143,   180,   144,   142,     0,   141,
1197    143,   144,   142,     0,   175,   165,     0,   175,     0,     8,
1198      0,   176,     0,   178,   133,   176,     0,   178,     0,   178,
1199    133,    32,     0,    32,     0,     0,   175,     0,   180,   133,
1200    175,     0,   175,   138,   183,   140,     0,   175,   138,   140,
1201      0,   175,   145,    17,     0,   175,   141,   183,   142,     0,
1202    175,   143,   183,   144,     0,   175,   143,   144,     0,   175,
1203    141,   143,   183,   144,   142,     0,   175,   141,   143,   144,
1204    142,     0,   175,    33,     0,   175,    34,     0,   175,   207,
1205      0,   175,   182,     0,   175,    20,     0,   151,     3,     0,
1206    151,     4,     0,     9,    21,     0,     9,    22,     0,   152,
1207      7,     0,   148,   136,   181,    31,   175,   137,     0,   108,
1208    136,   181,   218,   137,     0,   122,   136,   181,   133,   181,
1209    133,   181,   137,     0,   146,   136,   181,   133,   181,   137,
1210      0,   147,   136,   181,   133,   181,   137,     0,    81,   149,
1211    136,   181,   133,   181,   137,     0,    82,   150,   136,   181,
1212    133,   181,   137,     0,   124,   136,   181,   133,   181,   137,
1213      0,   125,   136,   181,   133,   181,   133,   181,   137,     0,
1214    126,   136,   181,   133,   181,   133,   181,   137,     0,   183,
1215    133,   181,     0,   181,     0,    27,     0,    28,     0,   186,
1216      0,     0,   187,     0,   186,   187,     0,     0,    26,   188,
1217    203,     0,     0,    25,   189,   204,     0,    51,    50,   193,
1218      0,    19,     0,   155,    13,   175,     0,   155,    13,     8,
1219      0,     0,   157,   160,   184,   181,   190,   172,     0,     0,
1220    157,   158,   160,   184,   181,   191,   172,     0,     0,   157,
1221    159,   160,   184,   175,   192,   172,     0,    44,   194,     0,
1222     47,   132,   195,     0,    17,     0,    45,   132,    17,     0,
1223     59,   132,    17,     0,   138,   196,   140,     0,   196,   133,
1224     17,     0,    17,     0,     0,   197,   133,   175,   165,   154,
1225      0,   175,   165,   154,     0,   197,     0,   197,   133,    32,
1226      0,    32,     0,     0,   163,   177,   156,   136,   198,   137,
1227    167,   171,   168,     0,    23,     0,   143,     0,   162,   160,
1228    199,   200,     0,    24,     0,   144,     0,   210,   202,     0,
1229    161,   160,   199,     0,     0,    52,     0,     3,     0,     4,
1230      0,     7,     0,    21,     0,    22,     0,    33,     0,    34,
1231      0,    20,     0,   141,   183,   142,     0,   182,     0,    50,
1232    205,    17,   133,    17,     0,     5,     0,     6,     0,   153,
1233      0,   156,     0,   207,     0,   206,     0,   175,   208,     0,
1234    210,   211,     0,   201,   211,     0,   212,   155,   213,     0,
1235    212,   215,     0,     0,    16,     0,    60,   209,     0,    60,
1236      8,     0,    61,    12,   208,     0,    61,     9,   208,   133,
1237     12,   208,   133,    12,   208,     0,    62,   151,   208,   133,
1238     12,   208,   138,   214,   140,     0,    62,   151,   208,   133,
1239     12,   208,   138,   140,     0,    63,   163,   177,   208,   136,
1240    217,   137,   167,    31,    12,   208,    64,    12,   208,     0,
1241     64,     0,    65,     0,   214,   151,   206,   133,    12,   208,
1242      0,   151,   206,   133,    12,   208,     0,   155,   220,     0,
1243    175,   138,   208,   133,   208,   140,     0,   216,   133,   138,
1244    208,   133,   208,   140,     0,   175,   208,   165,     0,   217,
1245    133,   175,   208,   165,     0,     0,     0,   218,   133,   209,
1246      0,    49,    48,     0,    48,     0,   146,   175,   208,   133,
1247    208,     0,   147,   175,   208,   133,   208,     0,    81,   149,
1248    175,   208,   133,   208,     0,    82,   150,   175,   208,   133,
1249    208,     0,   148,   209,    31,   175,     0,   122,   209,   133,
1250    209,   133,   209,     0,   123,   209,   133,   175,     0,   124,
1251    209,   133,   209,     0,   125,   209,   133,   209,   133,   209,
1252      0,   126,   209,   133,   209,   133,   209,     0,   121,   216,
1253      0,   219,   163,   177,   208,   136,   217,   137,   167,     0,
1254    222,     0,    30,     0,     0,   103,   175,   169,     0,   103,
1255    175,   133,     9,   208,   169,     0,   104,   175,   169,     0,
1256    104,   175,   133,     9,   208,   169,     0,   105,   209,     0,
1257    221,   106,   175,   208,     0,   221,   107,   209,   133,   175,
1258    208,     0,   108,   175,   208,   218,     0
1259 };
1260
1261 #endif
1262
1263 #if YYDEBUG != 0
1264 static const short yyrline[] = { 0,
1265   1048,  1048,  1048,  1048,  1048,  1048,  1048,  1048,  1048,  1049,
1266   1049,  1049,  1049,  1049,  1049,  1050,  1050,  1050,  1050,  1050,
1267   1050,  1050,  1051,  1051,  1051,  1051,  1051,  1054,  1054,  1055,
1268   1055,  1056,  1056,  1057,  1057,  1058,  1058,  1062,  1062,  1063,
1269   1063,  1064,  1064,  1065,  1065,  1066,  1066,  1067,  1067,  1068,
1270   1068,  1069,  1070,  1075,  1076,  1076,  1078,  1078,  1079,  1079,
1271   1083,  1087,  1092,  1092,  1094,  1098,  1104,  1105,  1106,  1107,
1272   1108,  1112,  1113,  1114,  1118,  1119,  1123,  1124,  1125,  1129,
1273   1130,  1131,  1132,  1133,  1136,  1136,  1137,  1138,  1139,  1140,
1274   1141,  1149,  1150,  1151,  1152,  1155,  1156,  1161,  1162,  1165,
1275   1166,  1173,  1173,  1180,  1180,  1189,  1197,  1197,  1203,  1203,
1276   1205,  1210,  1223,  1223,  1223,  1223,  1226,  1230,  1234,  1241,
1277   1246,  1254,  1272,  1290,  1295,  1307,  1317,  1321,  1331,  1338,
1278   1345,  1352,  1357,  1362,  1369,  1370,  1377,  1384,  1392,  1397,
1279   1408,  1436,  1452,  1481,  1509,  1534,  1553,  1579,  1599,  1611,
1280   1618,  1684,  1694,  1704,  1710,  1716,  1721,  1726,  1734,  1746,
1281   1768,  1776,  1782,  1793,  1798,  1803,  1809,  1815,  1824,  1828,
1282   1836,  1836,  1847,  1852,  1860,  1861,  1865,  1865,  1869,  1869,
1283   1872,  1875,  1887,  1911,  1922,  1929,  1932,  1937,  1940,  1946,
1284   1950,  1953,  1959,  1972,  1976,  1981,  1983,  1988,  1993,  2002,
1285   2012,  2023,  2027,  2036,  2045,  2050,  2162,  2162,  2164,  2173,
1286   2173,  2175,  2180,  2192,  2196,  2201,  2205,  2209,  2213,  2217,
1287   2221,  2225,  2229,  2233,  2258,  2262,  2276,  2280,  2284,  2288,
1288   2294,  2294,  2300,  2309,  2313,  2322,  2332,  2341,  2353,  2366,
1289   2370,  2374,  2379,  2389,  2408,  2417,  2484,  2488,  2495,  2506,
1290   2519,  2529,  2540,  2550,  2558,  2566,  2569,  2570,  2577,  2581,
1291   2586,  2607,  2624,  2637,  2650,  2662,  2670,  2677,  2683,  2689,
1292   2695,  2710,  2774,  2779,  2783,  2790,  2797,  2805,  2812,  2820,
1293   2828,  2842,  2859
1294 };
1295 #endif
1296
1297
1298 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
1299
1300 static const char * const yytname[] = {   "$","error","$undefined.","ESINT64VAL",
1301 "EUINT64VAL","LOCALVAL_ID","GLOBALVAL_ID","FPVAL","VOID","INTTYPE","FLOAT","DOUBLE",
1302 "LABEL","TYPE","LOCALVAR","GLOBALVAR","LABELSTR","STRINGCONSTANT","ATSTRINGCONSTANT",
1303 "IMPLEMENTATION","ZEROINITIALIZER","TRUETOK","FALSETOK","BEGINTOK","ENDTOK",
1304 "DECLARE","DEFINE","GLOBAL","CONSTANT","SECTION","VOLATILE","TO","DOTDOTDOT",
1305 "NULL_TOK","UNDEF","INTERNAL","LINKONCE","WEAK","APPENDING","DLLIMPORT","DLLEXPORT",
1306 "EXTERN_WEAK","OPAQUE","EXTERNAL","TARGET","TRIPLE","ALIGN","DEPLIBS","CALL",
1307 "TAIL","ASM_TOK","MODULE","SIDEEFFECT","CC_TOK","CCC_TOK","FASTCC_TOK","COLDCC_TOK",
1308 "X86_STDCALLCC_TOK","X86_FASTCALLCC_TOK","DATALAYOUT","RET","BR","SWITCH","INVOKE",
1309 "UNWIND","UNREACHABLE","ADD","SUB","MUL","UDIV","SDIV","FDIV","UREM","SREM",
1310 "FREM","AND","OR","XOR","SHL","LSHR","ASHR","ICMP","FCMP","EQ","NE","SLT","SGT",
1311 "SLE","SGE","ULT","UGT","ULE","UGE","OEQ","ONE","OLT","OGT","OLE","OGE","ORD",
1312 "UNO","UEQ","UNE","MALLOC","ALLOCA","FREE","LOAD","STORE","GETELEMENTPTR","TRUNC",
1313 "ZEXT","SEXT","FPTRUNC","FPEXT","BITCAST","UITOFP","SITOFP","FPTOUI","FPTOSI",
1314 "INTTOPTR","PTRTOINT","PHI_TOK","SELECT","VAARG","EXTRACTELEMENT","INSERTELEMENT",
1315 "SHUFFLEVECTOR","NORETURN","INREG","SRET","DEFAULT","HIDDEN","'='","','","'*'",
1316 "'\\\\'","'('","')'","'['","'x'","']'","'<'","'>'","'{'","'}'","'c'","ArithmeticOps",
1317 "LogicalOps","CastOps","IPredicates","FPredicates","IntType","FPType","LocalName",
1318 "OptLocalName","OptLocalAssign","GlobalName","OptGlobalAssign","GVInternalLinkage",
1319 "GVExternalLinkage","GVVisibilityStyle","FunctionDeclareLinkage","FunctionDefineLinkage",
1320 "OptCallingConv","ParamAttr","OptParamAttrs","FuncAttr","OptFuncAttrs","OptAlign",
1321 "OptCAlign","SectionString","OptSection","GlobalVarAttributes","GlobalVarAttribute",
1322 "PrimType","Types","ArgType","ResultTypes","ArgTypeList","ArgTypeListI","TypeListI",
1323 "ConstVal","ConstExpr","ConstVector","GlobalType","Module","DefinitionList",
1324 "Definition","@1","@2","@3","@4","@5","AsmBlock","TargetDefinition","LibrariesDefinition",
1325 "LibList","ArgListH","ArgList","FunctionHeaderH","BEGIN","FunctionHeader","END",
1326 "Function","FunctionProto","OptSideEffect","ConstValueRef","SymbolicValueRef",
1327 "ValueRef","ResolvedVal","BasicBlockList","BasicBlock","InstructionList","BBTerminatorInst",
1328 "JumpTable","Inst","PHIList","ValueRefList","IndexList","OptTailCall","InstVal",
1329 "OptVolatile","MemoryInst", NULL
1330 };
1331 #endif
1332
1333 static const short yyr1[] = {     0,
1334    146,   146,   146,   146,   146,   146,   146,   146,   146,   147,
1335    147,   147,   147,   147,   147,   148,   148,   148,   148,   148,
1336    148,   148,   148,   148,   148,   148,   148,   149,   149,   149,
1337    149,   149,   149,   149,   149,   149,   149,   150,   150,   150,
1338    150,   150,   150,   150,   150,   150,   150,   150,   150,   150,
1339    150,   150,   150,   151,   152,   152,   153,   153,   154,   154,
1340    155,   155,   156,   156,   157,   157,   158,   158,   158,   158,
1341    158,   159,   159,   159,   160,   160,   161,   161,   161,   162,
1342    162,   162,   162,   162,   163,   163,   163,   163,   163,   163,
1343    163,   164,   164,   164,   164,   165,   165,   166,   166,   167,
1344    167,   168,   168,   169,   169,   170,   171,   171,   172,   172,
1345    173,   173,   174,   174,   174,   174,   175,   175,   175,   175,
1346    175,   175,   175,   175,   175,   175,   175,   175,   175,   176,
1347    177,   177,   178,   178,   179,   179,   179,   179,   180,   180,
1348    181,   181,   181,   181,   181,   181,   181,   181,   181,   181,
1349    181,   181,   181,   181,   181,   181,   181,   181,   182,   182,
1350    182,   182,   182,   182,   182,   182,   182,   182,   183,   183,
1351    184,   184,   185,   185,   186,   186,   188,   187,   189,   187,
1352    187,   187,   187,   187,   190,   187,   191,   187,   192,   187,
1353    187,   187,   193,   194,   194,   195,   196,   196,   196,   197,
1354    197,   198,   198,   198,   198,   199,   200,   200,   201,   202,
1355    202,   203,   204,   205,   205,   206,   206,   206,   206,   206,
1356    206,   206,   206,   206,   206,   206,   207,   207,   207,   207,
1357    208,   208,   209,   210,   210,   211,   212,   212,   212,   213,
1358    213,   213,   213,   213,   213,   213,   213,   213,   214,   214,
1359    215,   216,   216,   217,   217,   217,   218,   218,   219,   219,
1360    220,   220,   220,   220,   220,   220,   220,   220,   220,   220,
1361    220,   220,   220,   221,   221,   222,   222,   222,   222,   222,
1362    222,   222,   222
1363 };
1364
1365 static const short yyr2[] = {     0,
1366      1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1367      1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1368      1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1369      1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1370      1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1371      1,     1,     1,     1,     1,     1,     1,     1,     1,     0,
1372      2,     0,     1,     1,     2,     0,     1,     1,     1,     1,
1373      1,     1,     1,     1,     0,     1,     0,     1,     1,     0,
1374      1,     1,     1,     1,     0,     1,     1,     1,     1,     1,
1375      2,     1,     1,     1,     1,     0,     2,     1,     1,     0,
1376      2,     0,     2,     0,     3,     2,     0,     1,     0,     3,
1377      1,     2,     1,     1,     1,     1,     1,     1,     2,     1,
1378      2,     5,     5,     5,     5,     3,     2,     5,     4,     2,
1379      1,     1,     1,     3,     1,     3,     1,     0,     1,     3,
1380      4,     3,     3,     4,     4,     3,     6,     5,     2,     2,
1381      2,     2,     2,     2,     2,     2,     2,     2,     6,     5,
1382      8,     6,     6,     7,     7,     6,     8,     8,     3,     1,
1383      1,     1,     1,     0,     1,     2,     0,     3,     0,     3,
1384      3,     1,     3,     3,     0,     6,     0,     7,     0,     7,
1385      2,     3,     1,     3,     3,     3,     3,     1,     0,     5,
1386      3,     1,     3,     1,     0,     9,     1,     1,     4,     1,
1387      1,     2,     3,     0,     1,     1,     1,     1,     1,     1,
1388      1,     1,     1,     3,     1,     5,     1,     1,     1,     1,
1389      1,     1,     2,     2,     2,     3,     2,     0,     1,     2,
1390      2,     3,     9,     9,     8,    14,     1,     1,     6,     5,
1391      2,     6,     7,     3,     5,     0,     0,     3,     2,     1,
1392      5,     5,     6,     6,     4,     6,     4,     4,     6,     6,
1393      2,     8,     1,     1,     0,     3,     6,     3,     6,     2,
1394      4,     6,     4
1395 };
1396
1397 static const short yydefact[] = {    66,
1398     57,    63,    58,    64,   182,   179,   177,     0,     0,     0,
1399      0,     0,     0,    75,    66,   175,    77,    80,     0,     0,
1400    191,     0,     0,    61,     0,    65,    67,    69,    68,    70,
1401     72,    71,    73,    74,    76,    75,    75,     0,   176,    78,
1402     79,    75,   180,    81,    82,    83,    84,    75,   238,   178,
1403    238,     0,     0,   199,   192,   193,   181,   227,   228,   184,
1404    113,   114,   115,   116,   117,     0,     0,     0,     0,   229,
1405    230,   118,   183,   120,     0,     0,   171,   172,     0,    85,
1406     85,   239,   235,    62,   210,   211,   212,   234,   194,   195,
1407    198,     0,   138,   121,     0,     0,     0,     0,   127,   139,
1408      0,   119,   138,     0,     0,   113,   114,   115,     0,     0,
1409      0,   185,     0,    86,    87,    88,    89,    90,     0,   213,
1410      0,   275,   237,     0,   196,   137,    96,   133,   135,     0,
1411      0,     0,     0,     0,     0,   126,     0,   187,   189,   156,
1412    157,   154,   155,   158,   153,   149,   150,     1,     2,     3,
1413      4,     5,     6,     7,     8,     9,    13,    14,    15,    10,
1414     11,    12,     0,     0,     0,    16,    17,    18,    19,    20,
1415     21,    22,    23,    24,    25,    26,    27,     0,     0,     0,
1416      0,     0,     0,     0,     0,     0,     0,     0,   152,   151,
1417    109,    91,   132,   131,     0,   207,   208,   209,   274,   260,
1418      0,     0,     0,     0,    85,   247,   248,     0,     0,     0,
1419      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1420      0,     0,   236,    85,   251,     0,   273,   197,   130,     0,
1421    100,     0,     0,   129,     0,   140,   100,   109,   109,    28,
1422     29,    30,    31,    32,    33,    34,    35,    36,    37,     0,
1423     52,    53,    48,    49,    50,    51,    38,    39,    40,    41,
1424     42,    43,    44,    45,    46,    47,     0,     0,     0,     0,
1425      0,     0,   142,   170,     0,     0,     0,   146,     0,   143,
1426      0,     0,     0,     0,   186,     0,   259,   241,     0,   240,
1427      0,     0,    54,     0,     0,     0,     0,   104,   104,   280,
1428      0,     0,   271,     0,     0,     0,     0,     0,     0,     0,
1429      0,     0,     0,     0,    92,    93,    94,    95,    97,   136,
1430    134,   123,   124,   125,   128,   122,   188,   190,     0,     0,
1431    257,     0,     0,     0,     0,     0,   141,   127,   139,     0,
1432    144,   145,     0,     0,     0,     0,     0,   111,   109,   205,
1433    216,   217,   218,   223,   219,   220,   221,   222,   214,     0,
1434    225,   232,   231,   233,     0,   242,     0,     0,     0,     0,
1435      0,   276,     0,   278,   257,     0,     0,     0,     0,     0,
1436      0,     0,     0,     0,     0,     0,     0,     0,    98,    99,
1437    101,     0,     0,     0,     0,     0,     0,     0,   169,   148,
1438      0,     0,     0,     0,   106,   112,   110,   204,    96,   202,
1439      0,   215,     0,     0,     0,     0,     0,     0,     0,     0,
1440      0,     0,   283,     0,     0,     0,   267,   268,     0,     0,
1441      0,     0,   265,     0,   281,     0,     0,     0,     0,   160,
1442      0,     0,     0,     0,   147,     0,     0,     0,    60,     0,
1443    100,     0,   224,     0,     0,   256,     0,     0,   104,   105,
1444    104,     0,     0,     0,     0,     0,   261,   262,   256,     0,
1445      0,     0,   258,     0,   166,     0,     0,   162,   163,   159,
1446     59,   201,   203,    96,   107,     0,     0,     0,     0,     0,
1447    263,   264,     0,   277,   279,     0,     0,   266,   269,   270,
1448      0,   282,   164,   165,     0,     0,     0,    60,   108,   102,
1449    226,     0,     0,    96,     0,   100,   252,     0,   100,   161,
1450    167,   168,   200,     0,   206,     0,   245,     0,     0,   254,
1451      0,     0,   253,   272,   103,   243,     0,   244,     0,    96,
1452      0,     0,     0,   255,     0,     0,     0,     0,   250,     0,
1453      0,   249,     0,   246,     0,     0,     0
1454 };
1455
1456 static const short yydefgoto[] = {   186,
1457    187,   188,   250,   267,   109,   110,    70,   482,    12,    71,
1458     14,    36,    37,    38,    42,    48,   119,   319,   229,   391,
1459    322,   525,   372,   348,   510,   285,   349,    72,   111,   128,
1460    195,   129,   130,   101,   274,   361,   275,    79,   555,    15,
1461     16,    18,    17,   191,   238,   239,    57,    21,    55,    92,
1462    410,   411,   120,   198,    49,    87,    50,    43,   413,   362,
1463     74,   364,   290,    51,    83,    84,   223,   529,   123,   303,
1464    490,   394,   224,   225,   226,   227
1465 };
1466
1467 static const short yypact[] = {   438,
1468 -32768,-32768,-32768,-32768,-32768,-32768,-32768,    27,  -119,   -29,
1469    -84,    43,   -57,    -6,   525,-32768,   195,   140,   -38,   -27,
1470 -32768,   -39,   112,-32768,   828,-32768,-32768,-32768,-32768,-32768,
1471 -32768,-32768,-32768,-32768,-32768,    32,    32,   227,-32768,-32768,
1472 -32768,    32,-32768,-32768,-32768,-32768,-32768,    32,   119,-32768,
1473     -2,   188,   210,   213,-32768,-32768,-32768,-32768,-32768,    49,
1474 -32768,-32768,-32768,-32768,-32768,   214,   245,     5,   104,-32768,
1475 -32768,-32768,   110,-32768,   227,   227,-32768,-32768,  1043,   154,
1476    154,-32768,-32768,   109,-32768,-32768,-32768,-32768,-32768,-32768,
1477 -32768,   -89,  1085,-32768,   125,   139,   122,    49,-32768,   110,
1478    -55,-32768,  1085,  1043,  1188,    46,   249,   272,   266,   273,
1479    589,-32768,   279,-32768,-32768,-32768,-32768,-32768,  1204,-32768,
1480      2,  1327,-32768,   268,-32768,-32768,   110,-32768,   153,   150,
1481   1188,  1188,   149,   -53,  1188,-32768,   155,-32768,   110,-32768,
1482 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
1483 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
1484 -32768,-32768,   494,   943,   157,-32768,-32768,-32768,-32768,-32768,
1485 -32768,-32768,-32768,-32768,-32768,-32768,-32768,   158,   159,   163,
1486    164,   790,  1226,   495,   284,   166,   167,   169,-32768,-32768,
1487    173,-32768,    49,   110,    28,-32768,-32768,-32768,-32768,-32768,
1488    262,  1243,   142,   302,   154,-32768,-32768,   494,   943,  1188,
1489   1188,  1188,  1188,  1188,  1188,  1188,  1188,  1188,  1188,  1188,
1490   1188,  1188,-32768,   154,-32768,   168,-32768,-32768,   -58,  1124,
1491 -32768,    25,    16,-32768,   170,   110,-32768,   173,   173,-32768,
1492 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   177,
1493 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
1494 -32768,-32768,-32768,-32768,-32768,-32768,   181,  1043,  1043,  1043,
1495   1043,  1043,-32768,-32768,    20,   668,   -40,-32768,   -48,-32768,
1496   1043,  1043,  1043,    18,-32768,   182,-32768,    49,   747,-32768,
1497    872,   872,-32768,   872,  1204,  1188,  1188,    99,   117,-32768,
1498    747,    33,   186,   187,   191,   192,   198,   200,   747,   747,
1499    290,  1204,  1188,  1188,-32768,-32768,-32768,-32768,-32768,-32768,
1500 -32768,   -87,-32768,-32768,-32768,   -87,-32768,-32768,  1043,  1043,
1501 -32768,   203,   204,   205,   209,  1043,-32768,   202,   589,   -43,
1502 -32768,-32768,   216,   218,   312,   328,   342,-32768,   173,  1140,
1503 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   295,  1043,
1504 -32768,-32768,-32768,-32768,   219,-32768,   229,   872,   747,   747,
1505      8,-32768,    17,-32768,-32768,   872,   225,  1188,  1188,  1188,
1506   1188,  1188,   231,   232,  1188,   872,   747,   233,-32768,-32768,
1507 -32768,   234,   235,   -33,  1043,  1043,  1043,  1043,-32768,-32768,
1508    230,  1043,  1043,  1188,-32768,-32768,-32768,-32768,   110,   238,
1509    236,-32768,   357,   -36,   363,   364,   241,   246,   248,   872,
1510    374,   872,   251,   254,   872,   255,   110,-32768,   256,   258,
1511    872,   872,   110,   260,-32768,  1188,  1043,  1043,  1188,-32768,
1512    261,   263,   264,   270,-32768,   267,   276,    47,   130,  1159,
1513 -32768,   274,-32768,   872,   872,  1188,   872,   872,   281,-32768,
1514    281,   872,   283,  1188,  1188,  1188,-32768,-32768,  1188,   747,
1515    282,   285,-32768,  1043,-32768,  1043,  1043,-32768,-32768,-32768,
1516 -32768,-32768,-32768,   110,    45,   382,   287,   280,   747,   -13,
1517 -32768,-32768,   355,-32768,-32768,   265,   872,-32768,-32768,-32768,
1518     29,-32768,-32768,-32768,   286,   291,   292,   130,-32768,   375,
1519 -32768,   412,     1,-32768,  1188,-32768,-32768,   293,-32768,-32768,
1520 -32768,-32768,-32768,   423,-32768,   872,-32768,   996,     9,   -58,
1521    747,   212,-32768,   -87,-32768,-32768,   297,-32768,   996,-32768,
1522    419,   422,   303,   -58,   872,   872,   425,   371,-32768,   872,
1523    427,-32768,   872,-32768,   443,   444,-32768
1524 };
1525
1526 static const short yypgoto[] = {   324,
1527    325,   326,   242,   252,  -197,-32768,     0,   -50,   376,     4,
1528 -32768,-32768,-32768,    40,-32768,-32768,  -167,  -306,  -397,-32768,
1529   -235,-32768,  -291,   -23,-32768,  -211,-32768,-32768,   -24,   237,
1530   -229,-32768,   362,   369,   -68,  -108,  -178,   201,-32768,-32768,
1531    453,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
1532 -32768,-32768,   391,-32768,-32768,-32768,-32768,-32768,-32768,  -436,
1533    -72,   101,  -157,-32768,   424,-32768,-32768,-32768,-32768,-32768,
1534      7,   105,-32768,-32768,-32768,-32768
1535 };
1536
1537
1538 #define YYLAST          1453
1539
1540
1541 static const short yytable[] = {    11,
1542     73,   326,   189,    13,   277,   279,   294,   374,    96,   293,
1543    112,   449,    22,    82,    11,   390,   420,   293,    13,   390,
1544     23,    85,   315,   316,   196,   422,   327,   328,    27,    28,
1545     29,    30,    31,    32,    33,   138,    34,   295,   190,   389,
1546    317,   318,     2,   124,   100,     4,   346,    24,   -54,   -54,
1547    125,   315,   316,   421,   300,    25,   312,   304,   305,   306,
1548    307,   308,   421,   347,   311,   368,   140,   141,   127,   317,
1549    318,    19,   100,   346,    26,    75,    76,   135,   127,   135,
1550    139,    80,   386,    11,   336,    20,   508,    81,   136,   336,
1551    235,   537,   336,    52,   194,   342,   336,   340,    54,   439,
1552    401,   341,   543,   440,    53,   453,   232,   233,    58,    59,
1553    236,    98,    61,    62,    63,    64,   530,     1,     2,   515,
1554      3,     4,     1,   516,    35,     3,    58,    59,    56,    98,
1555     61,    62,    63,    64,    82,     1,     2,   407,     3,     4,
1556    527,    86,   544,     1,   197,    65,     3,    97,   538,   102,
1557    291,   103,   336,   292,   315,   316,   388,   324,   102,   337,
1558    103,   515,    35,    65,   323,   519,   102,   494,   103,   495,
1559    376,   389,   317,   318,    44,    45,    46,   289,   390,    47,
1560    102,   414,   103,   480,    93,   298,   299,   289,   301,   302,
1561    289,   289,   289,   289,   289,   309,   310,   289,   286,   331,
1562    332,   333,   334,   335,    89,   127,   113,   114,   115,   116,
1563    117,   118,   343,   344,   345,   485,   363,    94,   363,   363,
1564    426,   363,   428,   429,   430,   390,    90,   390,   363,    91,
1565    189,   371,   102,    40,   103,    41,   363,   363,    66,   315,
1566    316,    67,   541,   102,    68,   103,    69,    99,    95,   373,
1567    102,   339,   103,    77,    78,   -55,    66,   317,   318,    67,
1568    392,   393,    68,   131,    69,   133,   190,   399,   142,   143,
1569    194,   369,   370,   313,   314,   104,   105,   132,   -56,   144,
1570    532,   473,   192,   534,   228,   230,   231,   194,   387,   289,
1571    234,   237,   268,   269,   270,   363,   363,   363,   271,   272,
1572    280,   281,   282,   363,   283,   284,   498,   499,   500,   287,
1573    293,   325,   329,   363,   363,   528,   330,   350,   377,   378,
1574    385,   315,   316,   379,   380,   409,   441,   442,   443,   444,
1575    381,   539,   382,   446,   447,   395,   396,   397,   389,   317,
1576    318,   398,   404,   400,   405,   406,   412,   363,   402,   363,
1577    403,   415,   363,   289,   427,   289,   289,   289,   363,   363,
1578    433,   416,   425,   431,   432,   436,   437,   438,   471,   472,
1579    450,   445,   451,   452,   454,   455,   456,   460,   457,   448,
1580    458,   363,   363,   439,   363,   363,   462,   464,   465,   363,
1581    466,   365,   366,   474,   367,   469,   476,   363,   511,   475,
1582    421,   375,   477,   478,   517,   505,   486,   506,   507,   383,
1583    384,   470,   479,   493,   289,   497,   363,   513,   503,   512,
1584    524,   504,   520,   526,   363,   484,   535,   521,   522,   542,
1585    545,   489,   533,   546,   551,   547,   550,  -174,   553,   289,
1586    289,   289,   556,   557,   489,   220,   221,   222,   481,   296,
1587    -62,     1,     2,   363,     3,     4,     5,   523,   363,   122,
1588    297,   509,     6,     7,   137,   134,   321,    39,   417,   418,
1589    419,   121,   363,   363,    88,   501,   424,   363,     0,   423,
1590    363,     8,     0,     0,     9,     0,   434,   435,    10,     0,
1591    531,     0,     0,     0,     0,     0,     0,     0,     0,    58,
1592     59,     0,    98,   106,   107,   108,    64,   481,     1,     2,
1593      0,     3,     4,     0,     0,     0,     0,     0,     0,     0,
1594    459,     0,   461,     0,  -173,   463,     0,     0,     0,     0,
1595      0,   467,   468,     0,     0,     0,    65,   -62,     1,     2,
1596      0,     3,     4,     5,     0,     0,     0,     0,     0,     6,
1597      7,     0,     0,     0,   487,   488,     0,   491,   492,     0,
1598      0,     0,   496,     0,     0,     0,     0,     0,     8,     0,
1599    502,     9,     0,     0,     0,    10,   240,   241,   242,   243,
1600    244,   245,   246,   247,   248,   249,     0,     0,     0,   514,
1601      0,     0,     0,    58,    59,     0,     0,   518,     0,     0,
1602      0,     0,     1,     2,     0,     3,     4,     0,   145,     0,
1603      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1604      0,   146,   147,     0,     0,     0,   536,     0,     0,    66,
1605      0,   540,    67,     0,     0,    68,     0,    69,   278,     0,
1606      0,     0,     0,     0,     0,   548,   549,     0,     0,     0,
1607    552,     0,     0,   554,   148,   149,   150,   151,   152,   153,
1608    154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
1609    164,     0,    58,    59,     0,    98,   106,   107,   108,    64,
1610      0,     1,     2,     0,     3,     4,     0,     0,     0,     0,
1611      0,     0,     0,     0,     0,     0,   165,   166,   167,   168,
1612    169,   170,   171,   172,   173,   174,   175,   176,   177,    65,
1613    178,     0,   179,   180,   181,     0,     0,     0,     0,     0,
1614      0,     0,   102,     0,   103,     0,   182,     0,     0,   183,
1615      0,   184,     0,   185,     0,     0,     0,     0,     0,     0,
1616      0,     0,     0,     0,     0,     0,     0,     0,     0,   351,
1617    352,    58,    59,   353,     0,     0,     0,     0,     0,     0,
1618      1,     2,     0,     3,     4,     0,   354,   355,   356,     0,
1619      0,     0,     0,     0,     0,     0,     0,     0,     0,   357,
1620    358,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1621      0,     0,     0,     0,    58,    59,   359,    98,   106,   107,
1622    108,    64,    66,     1,     2,    67,     3,     4,    68,     0,
1623     69,   338,   148,   149,   150,   151,   152,   153,   154,   155,
1624    156,   157,   158,   159,   160,   161,   162,   163,   164,     0,
1625      0,    65,    58,    59,     0,    60,    61,    62,    63,    64,
1626      0,     1,     2,     0,     3,     4,     0,     0,     0,     0,
1627      0,     0,     0,     0,   165,   166,   167,   168,   169,   170,
1628    171,   172,   173,   174,   175,   176,   177,     0,   178,    65,
1629    179,   180,   181,     0,   351,   352,    58,    59,   353,     0,
1630    102,     0,   103,     0,     0,     1,     2,   360,     3,     4,
1631      0,   354,   355,   356,     0,     0,     0,     0,     0,     0,
1632      0,     0,     0,     0,   357,   358,     0,     0,     0,     0,
1633      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1634      0,   359,     0,     0,    66,     0,     0,    67,     0,   273,
1635     68,     0,    69,     0,     0,     0,     0,   148,   149,   150,
1636    151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
1637    161,   162,   163,   164,     0,     0,     0,     0,     0,     0,
1638      0,     0,    66,   251,   252,    67,     0,     0,    68,     0,
1639     69,     0,     0,     0,     0,     0,     0,     0,     0,   165,
1640    166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
1641    176,   177,     0,   178,     0,   179,   180,   181,   351,   352,
1642      0,     0,   353,     0,     0,     0,     0,     0,     0,     0,
1643      0,     0,   360,     0,     0,   354,   355,   356,     0,     0,
1644      0,     0,     0,     0,     0,     0,     0,     0,   357,   358,
1645      0,   253,   254,   255,   256,   257,   258,   259,   260,   261,
1646    262,   263,   264,   265,   266,   359,     0,    58,    59,     0,
1647     98,   106,   107,   108,    64,     0,     1,     2,     0,     3,
1648      4,   148,   149,   150,   151,   152,   153,   154,   155,   156,
1649    157,   158,   159,   160,   161,   162,   163,   164,     0,     0,
1650      0,     0,     0,     0,    65,     0,     0,     0,     0,    58,
1651     59,     0,    98,    61,    62,    63,    64,     0,     1,     2,
1652      0,     3,     4,   165,   166,   167,   168,   169,   170,   171,
1653    172,   173,   174,   175,   176,   177,   126,   178,     0,   179,
1654    180,   181,     0,     0,     0,     0,    65,     0,    58,    59,
1655      0,    98,    61,    62,    63,    64,   360,     1,     2,     0,
1656      3,     4,     0,     0,    58,    59,     0,    98,    61,    62,
1657     63,    64,     0,     1,     2,   320,     3,     4,     0,     0,
1658      0,     0,     0,    58,    59,    65,    98,    61,    62,    63,
1659     64,   408,     1,     2,     0,     3,     4,    66,     0,     0,
1660     67,    65,     0,    68,     0,    69,     0,     0,     0,     0,
1661    483,     0,    58,    59,     0,    98,    61,    62,    63,    64,
1662     65,     1,     2,     0,     3,     4,     0,     0,    58,    59,
1663      0,   193,    61,    62,    63,    64,     0,     1,     2,    66,
1664      3,     4,    67,     0,     0,    68,     0,    69,     0,    65,
1665     58,    59,     0,    98,   106,   107,   108,    64,     0,     1,
1666      2,     0,     3,     4,     0,    65,     0,    58,    59,     0,
1667    288,    61,    62,    63,    64,     0,     1,     2,    66,     3,
1668      4,    67,     0,     0,    68,     0,    69,    65,     0,     0,
1669      0,     0,     0,     0,    66,     0,     0,    67,     0,     0,
1670     68,     0,    69,     0,    65,     0,     0,     0,     0,     0,
1671      0,     0,     0,    66,     0,     0,    67,     0,     0,    68,
1672      0,    69,     0,     0,     0,     0,     0,     0,     0,     0,
1673      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1674      0,     0,    66,     0,     0,    67,     0,     0,    68,     0,
1675     69,     0,     0,     0,     0,     0,     0,     0,    66,     0,
1676      0,    67,     0,     0,    68,     0,    69,     0,     0,     0,
1677      0,     0,     0,     0,     0,     0,   199,     0,     0,     0,
1678     66,     0,     0,    67,     0,     0,    68,     0,   276,     0,
1679      0,     0,     0,     0,   200,   201,     0,    66,     0,     0,
1680     67,     0,     0,    68,     0,    69,   202,   203,   204,   205,
1681    206,   207,   148,   149,   150,   151,   152,   153,   154,   155,
1682    156,   157,   158,   159,   160,   161,   162,   208,   209,     0,
1683      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1684      0,     0,     0,     0,     0,     0,     0,     0,     0,   210,
1685    211,   212,     0,     0,   213,   166,   167,   168,   169,   170,
1686    171,   172,   173,   174,   175,   176,   177,   214,   215,   216,
1687    217,   218,   219
1688 };
1689
1690 static const short yycheck[] = {     0,
1691     25,   237,   111,     0,   183,   184,   204,   299,     4,     9,
1692     79,   409,   132,    16,    15,   322,     9,     9,    15,   326,
1693     50,    24,   110,   111,    23,     9,   238,   239,    35,    36,
1694     37,    38,    39,    40,    41,   104,    43,   205,   111,   127,
1695    128,   129,    15,   133,    69,    18,    29,   132,     3,     4,
1696    140,   110,   111,    46,   212,    13,   224,   215,   216,   217,
1697    218,   219,    46,    46,   222,   295,    21,    22,    93,   128,
1698    129,    45,    97,    29,   132,    36,    37,   133,   103,   133,
1699    105,    42,   312,    84,   133,    59,   484,    48,   144,   133,
1700    144,   528,   133,   132,   119,   144,   133,   276,   138,   133,
1701    144,   142,   539,   137,   132,   142,   131,   132,     5,     6,
1702    135,     8,     9,    10,    11,    12,   514,    14,    15,   133,
1703     17,    18,    14,   137,   131,    17,     5,     6,    17,     8,
1704      9,    10,    11,    12,    16,    14,    15,   349,    17,    18,
1705    140,   144,   540,    14,   143,    42,    17,   143,   140,   134,
1706      9,   136,   133,    12,   110,   111,   314,   142,   134,   140,
1707    136,   133,   131,    42,   140,   137,   134,   459,   136,   461,
1708    138,   127,   128,   129,    35,    36,    37,   202,   485,    40,
1709    134,   360,   136,   137,   136,   210,   211,   212,   213,   214,
1710    215,   216,   217,   218,   219,   220,   221,   222,   195,   268,
1711    269,   270,   271,   272,    17,   230,    53,    54,    55,    56,
1712     57,    58,   281,   282,   283,   451,   289,     4,   291,   292,
1713    378,   294,   380,   381,   382,   532,    17,   534,   301,    17,
1714    339,   133,   134,    39,   136,    41,   309,   310,   135,   110,
1715    111,   138,    31,   134,   141,   136,   143,   144,     4,   133,
1716    134,   276,   136,    27,    28,     7,   135,   128,   129,   138,
1717    329,   330,   141,   139,   143,   144,   339,   336,     3,     4,
1718    295,   296,   297,   106,   107,    75,    76,   139,     7,     7,
1719    516,   439,     4,   519,    17,   133,   137,   312,   313,   314,
1720    142,   137,   136,   136,   136,   368,   369,   370,   136,   136,
1721     17,   136,   136,   376,   136,   133,   464,   465,   466,    48,
1722      9,   142,   136,   386,   387,   513,   136,   136,   133,   133,
1723     31,   110,   111,   133,   133,   350,   395,   396,   397,   398,
1724    133,   529,   133,   402,   403,   133,   133,   133,   127,   128,
1725    129,   133,    31,   142,    17,     4,    52,   420,   133,   422,
1726    133,   133,   425,   378,   379,   380,   381,   382,   431,   432,
1727    385,   133,   138,   133,   133,   133,   133,   133,   437,   438,
1728    133,   142,   137,    17,    12,    12,   136,     4,   133,   404,
1729    133,   454,   455,   133,   457,   458,   133,   133,   133,   462,
1730    133,   291,   292,   133,   294,   136,   133,   470,    17,   137,
1731     46,   301,   133,   137,   140,   474,   133,   476,   477,   309,
1732    310,   436,   137,   133,   439,   133,   489,   138,   137,   133,
1733     46,   137,   137,    12,   497,   450,     4,   137,   137,   133,
1734     12,   456,   140,    12,    64,   133,    12,     0,    12,   464,
1735    465,   466,     0,     0,   469,   122,   122,   122,   449,   208,
1736     13,    14,    15,   526,    17,    18,    19,   508,   531,    84,
1737    209,   485,    25,    26,   103,    97,   230,    15,   368,   369,
1738    370,    81,   545,   546,    51,   469,   376,   550,    -1,   375,
1739    553,    44,    -1,    -1,    47,    -1,   386,   387,    51,    -1,
1740    515,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     5,
1741      6,    -1,     8,     9,    10,    11,    12,   508,    14,    15,
1742     -1,    17,    18,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1743    420,    -1,   422,    -1,     0,   425,    -1,    -1,    -1,    -1,
1744     -1,   431,   432,    -1,    -1,    -1,    42,    13,    14,    15,
1745     -1,    17,    18,    19,    -1,    -1,    -1,    -1,    -1,    25,
1746     26,    -1,    -1,    -1,   454,   455,    -1,   457,   458,    -1,
1747     -1,    -1,   462,    -1,    -1,    -1,    -1,    -1,    44,    -1,
1748    470,    47,    -1,    -1,    -1,    51,    83,    84,    85,    86,
1749     87,    88,    89,    90,    91,    92,    -1,    -1,    -1,   489,
1750     -1,    -1,    -1,     5,     6,    -1,    -1,   497,    -1,    -1,
1751     -1,    -1,    14,    15,    -1,    17,    18,    -1,    20,    -1,
1752     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1753     -1,    33,    34,    -1,    -1,    -1,   526,    -1,    -1,   135,
1754     -1,   531,   138,    -1,    -1,   141,    -1,   143,   144,    -1,
1755     -1,    -1,    -1,    -1,    -1,   545,   546,    -1,    -1,    -1,
1756    550,    -1,    -1,   553,    66,    67,    68,    69,    70,    71,
1757     72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
1758     82,    -1,     5,     6,    -1,     8,     9,    10,    11,    12,
1759     -1,    14,    15,    -1,    17,    18,    -1,    -1,    -1,    -1,
1760     -1,    -1,    -1,    -1,    -1,    -1,   108,   109,   110,   111,
1761    112,   113,   114,   115,   116,   117,   118,   119,   120,    42,
1762    122,    -1,   124,   125,   126,    -1,    -1,    -1,    -1,    -1,
1763     -1,    -1,   134,    -1,   136,    -1,   138,    -1,    -1,   141,
1764     -1,   143,    -1,   145,    -1,    -1,    -1,    -1,    -1,    -1,
1765     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
1766      4,     5,     6,     7,    -1,    -1,    -1,    -1,    -1,    -1,
1767     14,    15,    -1,    17,    18,    -1,    20,    21,    22,    -1,
1768     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    33,
1769     34,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1770     -1,    -1,    -1,    -1,     5,     6,    50,     8,     9,    10,
1771     11,    12,   135,    14,    15,   138,    17,    18,   141,    -1,
1772    143,   144,    66,    67,    68,    69,    70,    71,    72,    73,
1773     74,    75,    76,    77,    78,    79,    80,    81,    82,    -1,
1774     -1,    42,     5,     6,    -1,     8,     9,    10,    11,    12,
1775     -1,    14,    15,    -1,    17,    18,    -1,    -1,    -1,    -1,
1776     -1,    -1,    -1,    -1,   108,   109,   110,   111,   112,   113,
1777    114,   115,   116,   117,   118,   119,   120,    -1,   122,    42,
1778    124,   125,   126,    -1,     3,     4,     5,     6,     7,    -1,
1779    134,    -1,   136,    -1,    -1,    14,    15,   141,    17,    18,
1780     -1,    20,    21,    22,    -1,    -1,    -1,    -1,    -1,    -1,
1781     -1,    -1,    -1,    -1,    33,    34,    -1,    -1,    -1,    -1,
1782     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1783     -1,    50,    -1,    -1,   135,    -1,    -1,   138,    -1,   140,
1784    141,    -1,   143,    -1,    -1,    -1,    -1,    66,    67,    68,
1785     69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
1786     79,    80,    81,    82,    -1,    -1,    -1,    -1,    -1,    -1,
1787     -1,    -1,   135,    21,    22,   138,    -1,    -1,   141,    -1,
1788    143,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   108,
1789    109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
1790    119,   120,    -1,   122,    -1,   124,   125,   126,     3,     4,
1791     -1,    -1,     7,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1792     -1,    -1,   141,    -1,    -1,    20,    21,    22,    -1,    -1,
1793     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    33,    34,
1794     -1,    89,    90,    91,    92,    93,    94,    95,    96,    97,
1795     98,    99,   100,   101,   102,    50,    -1,     5,     6,    -1,
1796      8,     9,    10,    11,    12,    -1,    14,    15,    -1,    17,
1797     18,    66,    67,    68,    69,    70,    71,    72,    73,    74,
1798     75,    76,    77,    78,    79,    80,    81,    82,    -1,    -1,
1799     -1,    -1,    -1,    -1,    42,    -1,    -1,    -1,    -1,     5,
1800      6,    -1,     8,     9,    10,    11,    12,    -1,    14,    15,
1801     -1,    17,    18,   108,   109,   110,   111,   112,   113,   114,
1802    115,   116,   117,   118,   119,   120,    32,   122,    -1,   124,
1803    125,   126,    -1,    -1,    -1,    -1,    42,    -1,     5,     6,
1804     -1,     8,     9,    10,    11,    12,   141,    14,    15,    -1,
1805     17,    18,    -1,    -1,     5,     6,    -1,     8,     9,    10,
1806     11,    12,    -1,    14,    15,    32,    17,    18,    -1,    -1,
1807     -1,    -1,    -1,     5,     6,    42,     8,     9,    10,    11,
1808     12,    32,    14,    15,    -1,    17,    18,   135,    -1,    -1,
1809    138,    42,    -1,   141,    -1,   143,    -1,    -1,    -1,    -1,
1810     32,    -1,     5,     6,    -1,     8,     9,    10,    11,    12,
1811     42,    14,    15,    -1,    17,    18,    -1,    -1,     5,     6,
1812     -1,     8,     9,    10,    11,    12,    -1,    14,    15,   135,
1813     17,    18,   138,    -1,    -1,   141,    -1,   143,    -1,    42,
1814      5,     6,    -1,     8,     9,    10,    11,    12,    -1,    14,
1815     15,    -1,    17,    18,    -1,    42,    -1,     5,     6,    -1,
1816      8,     9,    10,    11,    12,    -1,    14,    15,   135,    17,
1817     18,   138,    -1,    -1,   141,    -1,   143,    42,    -1,    -1,
1818     -1,    -1,    -1,    -1,   135,    -1,    -1,   138,    -1,    -1,
1819    141,    -1,   143,    -1,    42,    -1,    -1,    -1,    -1,    -1,
1820     -1,    -1,    -1,   135,    -1,    -1,   138,    -1,    -1,   141,
1821     -1,   143,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1822     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1823     -1,    -1,   135,    -1,    -1,   138,    -1,    -1,   141,    -1,
1824    143,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   135,    -1,
1825     -1,   138,    -1,    -1,   141,    -1,   143,    -1,    -1,    -1,
1826     -1,    -1,    -1,    -1,    -1,    -1,    30,    -1,    -1,    -1,
1827    135,    -1,    -1,   138,    -1,    -1,   141,    -1,   143,    -1,
1828     -1,    -1,    -1,    -1,    48,    49,    -1,   135,    -1,    -1,
1829    138,    -1,    -1,   141,    -1,   143,    60,    61,    62,    63,
1830     64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
1831     74,    75,    76,    77,    78,    79,    80,    81,    82,    -1,
1832     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1833     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   103,
1834    104,   105,    -1,    -1,   108,   109,   110,   111,   112,   113,
1835    114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
1836    124,   125,   126
1837 };
1838 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
1839 #line 3 "/usr/share/bison.simple"
1840 /* This file comes from bison-1.28.  */
1841
1842 /* Skeleton output parser for bison,
1843    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
1844
1845    This program is free software; you can redistribute it and/or modify
1846    it under the terms of the GNU General Public License as published by
1847    the Free Software Foundation; either version 2, or (at your option)
1848    any later version.
1849
1850    This program is distributed in the hope that it will be useful,
1851    but WITHOUT ANY WARRANTY; without even the implied warranty of
1852    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1853    GNU General Public License for more details.
1854
1855    You should have received a copy of the GNU General Public License
1856    along with this program; if not, write to the Free Software
1857    Foundation, Inc., 59 Temple Place - Suite 330,
1858    Boston, MA 02111-1307, USA.  */
1859
1860 /* As a special exception, when this file is copied by Bison into a
1861    Bison output file, you may use that output file without restriction.
1862    This special exception was added by the Free Software Foundation
1863    in version 1.24 of Bison.  */
1864
1865 /* This is the parser code that is written into each bison parser
1866   when the %semantic_parser declaration is not specified in the grammar.
1867   It was written by Richard Stallman by simplifying the hairy parser
1868   used when %semantic_parser is specified.  */
1869
1870 #ifndef YYSTACK_USE_ALLOCA
1871 #ifdef alloca
1872 #define YYSTACK_USE_ALLOCA
1873 #else /* alloca not defined */
1874 #ifdef __GNUC__
1875 #define YYSTACK_USE_ALLOCA
1876 #define alloca __builtin_alloca
1877 #else /* not GNU C.  */
1878 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
1879 #define YYSTACK_USE_ALLOCA
1880 #include <alloca.h>
1881 #else /* not sparc */
1882 /* We think this test detects Watcom and Microsoft C.  */
1883 /* This used to test MSDOS, but that is a bad idea
1884    since that symbol is in the user namespace.  */
1885 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
1886 #if 0 /* No need for malloc.h, which pollutes the namespace;
1887          instead, just don't use alloca.  */
1888 #include <malloc.h>
1889 #endif
1890 #else /* not MSDOS, or __TURBOC__ */
1891 #if defined(_AIX)
1892 /* I don't know what this was needed for, but it pollutes the namespace.
1893    So I turned it off.   rms, 2 May 1997.  */
1894 /* #include <malloc.h>  */
1895  #pragma alloca
1896 #define YYSTACK_USE_ALLOCA
1897 #else /* not MSDOS, or __TURBOC__, or _AIX */
1898 #if 0
1899 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
1900                  and on HPUX 10.  Eventually we can turn this on.  */
1901 #define YYSTACK_USE_ALLOCA
1902 #define alloca __builtin_alloca
1903 #endif /* __hpux */
1904 #endif
1905 #endif /* not _AIX */
1906 #endif /* not MSDOS, or __TURBOC__ */
1907 #endif /* not sparc */
1908 #endif /* not GNU C */
1909 #endif /* alloca not defined */
1910 #endif /* YYSTACK_USE_ALLOCA not defined */
1911
1912 #ifdef YYSTACK_USE_ALLOCA
1913 #define YYSTACK_ALLOC alloca
1914 #else
1915 #define YYSTACK_ALLOC malloc
1916 #endif
1917
1918 /* Note: there must be only one dollar sign in this file.
1919    It is replaced by the list of actions, each action
1920    as one case of the switch.  */
1921
1922 #define yyerrok         (yyerrstatus = 0)
1923 #define yyclearin       (yychar = YYEMPTY)
1924 #define YYEMPTY         -2
1925 #define YYEOF           0
1926 #define YYACCEPT        goto yyacceptlab
1927 #define YYABORT         goto yyabortlab
1928 #define YYERROR         goto yyerrlab1
1929 /* Like YYERROR except do call yyerror.
1930    This remains here temporarily to ease the
1931    transition to the new meaning of YYERROR, for GCC.
1932    Once GCC version 2 has supplanted version 1, this can go.  */
1933 #define YYFAIL          goto yyerrlab
1934 #define YYRECOVERING()  (!!yyerrstatus)
1935 #define YYBACKUP(token, value) \
1936 do                                                              \
1937   if (yychar == YYEMPTY && yylen == 1)                          \
1938     { yychar = (token), yylval = (value);                       \
1939       yychar1 = YYTRANSLATE (yychar);                           \
1940       YYPOPSTACK;                                               \
1941       goto yybackup;                                            \
1942     }                                                           \
1943   else                                                          \
1944     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
1945 while (0)
1946
1947 #define YYTERROR        1
1948 #define YYERRCODE       256
1949
1950 #ifndef YYPURE
1951 #define YYLEX           yylex()
1952 #endif
1953
1954 #ifdef YYPURE
1955 #ifdef YYLSP_NEEDED
1956 #ifdef YYLEX_PARAM
1957 #define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
1958 #else
1959 #define YYLEX           yylex(&yylval, &yylloc)
1960 #endif
1961 #else /* not YYLSP_NEEDED */
1962 #ifdef YYLEX_PARAM
1963 #define YYLEX           yylex(&yylval, YYLEX_PARAM)
1964 #else
1965 #define YYLEX           yylex(&yylval)
1966 #endif
1967 #endif /* not YYLSP_NEEDED */
1968 #endif
1969
1970 /* If nonreentrant, generate the variables here */
1971
1972 #ifndef YYPURE
1973
1974 int     yychar;                 /*  the lookahead symbol                */
1975 YYSTYPE yylval;                 /*  the semantic value of the           */
1976                                 /*  lookahead symbol                    */
1977
1978 #ifdef YYLSP_NEEDED
1979 YYLTYPE yylloc;                 /*  location data for the lookahead     */
1980                                 /*  symbol                              */
1981 #endif
1982
1983 int yynerrs;                    /*  number of parse errors so far       */
1984 #endif  /* not YYPURE */
1985
1986 #if YYDEBUG != 0
1987 int yydebug;                    /*  nonzero means print parse trace     */
1988 /* Since this is uninitialized, it does not stop multiple parsers
1989    from coexisting.  */
1990 #endif
1991
1992 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
1993
1994 #ifndef YYINITDEPTH
1995 #define YYINITDEPTH 200
1996 #endif
1997
1998 /*  YYMAXDEPTH is the maximum size the stacks can grow to
1999     (effective only if the built-in stack extension method is used).  */
2000
2001 #if YYMAXDEPTH == 0
2002 #undef YYMAXDEPTH
2003 #endif
2004
2005 #ifndef YYMAXDEPTH
2006 #define YYMAXDEPTH 10000
2007 #endif
2008 \f
2009 /* Define __yy_memcpy.  Note that the size argument
2010    should be passed with type unsigned int, because that is what the non-GCC
2011    definitions require.  With GCC, __builtin_memcpy takes an arg
2012    of type size_t, but it can handle unsigned int.  */
2013
2014 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
2015 #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
2016 #else                           /* not GNU C or C++ */
2017 #ifndef __cplusplus
2018
2019 /* This is the most reliable way to avoid incompatibilities
2020    in available built-in functions on various systems.  */
2021 static void
2022 __yy_memcpy (to, from, count)
2023      char *to;
2024      char *from;
2025      unsigned int count;
2026 {
2027   register char *f = from;
2028   register char *t = to;
2029   register int i = count;
2030
2031   while (i-- > 0)
2032     *t++ = *f++;
2033 }
2034
2035 #else /* __cplusplus */
2036
2037 /* This is the most reliable way to avoid incompatibilities
2038    in available built-in functions on various systems.  */
2039 static void
2040 __yy_memcpy (char *to, char *from, unsigned int count)
2041 {
2042   register char *t = to;
2043   register char *f = from;
2044   register int i = count;
2045
2046   while (i-- > 0)
2047     *t++ = *f++;
2048 }
2049
2050 #endif
2051 #endif
2052 \f
2053 #line 217 "/usr/share/bison.simple"
2054
2055 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
2056    into yyparse.  The argument should have type void *.
2057    It should actually point to an object.
2058    Grammar actions can access the variable by casting it
2059    to the proper pointer type.  */
2060
2061 #ifdef YYPARSE_PARAM
2062 #ifdef __cplusplus
2063 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
2064 #define YYPARSE_PARAM_DECL
2065 #else /* not __cplusplus */
2066 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
2067 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
2068 #endif /* not __cplusplus */
2069 #else /* not YYPARSE_PARAM */
2070 #define YYPARSE_PARAM_ARG
2071 #define YYPARSE_PARAM_DECL
2072 #endif /* not YYPARSE_PARAM */
2073
2074 /* Prevent warning if -Wstrict-prototypes.  */
2075 #ifdef __GNUC__
2076 #ifdef YYPARSE_PARAM
2077 int yyparse (void *);
2078 #else
2079 int yyparse (void);
2080 #endif
2081 #endif
2082
2083 int
2084 yyparse(YYPARSE_PARAM_ARG)
2085      YYPARSE_PARAM_DECL
2086 {
2087   register int yystate;
2088   register int yyn;
2089   register short *yyssp;
2090   register YYSTYPE *yyvsp;
2091   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
2092   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
2093
2094   short yyssa[YYINITDEPTH];     /*  the state stack                     */
2095   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
2096
2097   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
2098   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
2099
2100 #ifdef YYLSP_NEEDED
2101   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
2102   YYLTYPE *yyls = yylsa;
2103   YYLTYPE *yylsp;
2104
2105 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
2106 #else
2107 #define YYPOPSTACK   (yyvsp--, yyssp--)
2108 #endif
2109
2110   int yystacksize = YYINITDEPTH;
2111   int yyfree_stacks = 0;
2112
2113 #ifdef YYPURE
2114   int yychar;
2115   YYSTYPE yylval;
2116   int yynerrs;
2117 #ifdef YYLSP_NEEDED
2118   YYLTYPE yylloc;
2119 #endif
2120 #endif
2121
2122   YYSTYPE yyval;                /*  the variable used to return         */
2123                                 /*  semantic values from the action     */
2124                                 /*  routines                            */
2125
2126   int yylen;
2127
2128 #if YYDEBUG != 0
2129   if (yydebug)
2130     fprintf(stderr, "Starting parse\n");
2131 #endif
2132
2133   yystate = 0;
2134   yyerrstatus = 0;
2135   yynerrs = 0;
2136   yychar = YYEMPTY;             /* Cause a token to be read.  */
2137
2138   /* Initialize stack pointers.
2139      Waste one element of value and location stack
2140      so that they stay on the same level as the state stack.
2141      The wasted elements are never initialized.  */
2142
2143   yyssp = yyss - 1;
2144   yyvsp = yyvs;
2145 #ifdef YYLSP_NEEDED
2146   yylsp = yyls;
2147 #endif
2148
2149 /* Push a new state, which is found in  yystate  .  */
2150 /* In all cases, when you get here, the value and location stacks
2151    have just been pushed. so pushing a state here evens the stacks.  */
2152 yynewstate:
2153
2154   *++yyssp = yystate;
2155
2156   if (yyssp >= yyss + yystacksize - 1)
2157     {
2158       /* Give user a chance to reallocate the stack */
2159       /* Use copies of these so that the &'s don't force the real ones into memory. */
2160       YYSTYPE *yyvs1 = yyvs;
2161       short *yyss1 = yyss;
2162 #ifdef YYLSP_NEEDED
2163       YYLTYPE *yyls1 = yyls;
2164 #endif
2165
2166       /* Get the current used size of the three stacks, in elements.  */
2167       int size = yyssp - yyss + 1;
2168
2169 #ifdef yyoverflow
2170       /* Each stack pointer address is followed by the size of
2171          the data in use in that stack, in bytes.  */
2172 #ifdef YYLSP_NEEDED
2173       /* This used to be a conditional around just the two extra args,
2174          but that might be undefined if yyoverflow is a macro.  */
2175       yyoverflow("parser stack overflow",
2176                  &yyss1, size * sizeof (*yyssp),
2177                  &yyvs1, size * sizeof (*yyvsp),
2178                  &yyls1, size * sizeof (*yylsp),
2179                  &yystacksize);
2180 #else
2181       yyoverflow("parser stack overflow",
2182                  &yyss1, size * sizeof (*yyssp),
2183                  &yyvs1, size * sizeof (*yyvsp),
2184                  &yystacksize);
2185 #endif
2186
2187       yyss = yyss1; yyvs = yyvs1;
2188 #ifdef YYLSP_NEEDED
2189       yyls = yyls1;
2190 #endif
2191 #else /* no yyoverflow */
2192       /* Extend the stack our own way.  */
2193       if (yystacksize >= YYMAXDEPTH)
2194         {
2195           yyerror("parser stack overflow");
2196           if (yyfree_stacks)
2197             {
2198               free (yyss);
2199               free (yyvs);
2200 #ifdef YYLSP_NEEDED
2201               free (yyls);
2202 #endif
2203             }
2204           return 2;
2205         }
2206       yystacksize *= 2;
2207       if (yystacksize > YYMAXDEPTH)
2208         yystacksize = YYMAXDEPTH;
2209 #ifndef YYSTACK_USE_ALLOCA
2210       yyfree_stacks = 1;
2211 #endif
2212       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
2213       __yy_memcpy ((char *)yyss, (char *)yyss1,
2214                    size * (unsigned int) sizeof (*yyssp));
2215       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
2216       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
2217                    size * (unsigned int) sizeof (*yyvsp));
2218 #ifdef YYLSP_NEEDED
2219       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
2220       __yy_memcpy ((char *)yyls, (char *)yyls1,
2221                    size * (unsigned int) sizeof (*yylsp));
2222 #endif
2223 #endif /* no yyoverflow */
2224
2225       yyssp = yyss + size - 1;
2226       yyvsp = yyvs + size - 1;
2227 #ifdef YYLSP_NEEDED
2228       yylsp = yyls + size - 1;
2229 #endif
2230
2231 #if YYDEBUG != 0
2232       if (yydebug)
2233         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
2234 #endif
2235
2236       if (yyssp >= yyss + yystacksize - 1)
2237         YYABORT;
2238     }
2239
2240 #if YYDEBUG != 0
2241   if (yydebug)
2242     fprintf(stderr, "Entering state %d\n", yystate);
2243 #endif
2244
2245   goto yybackup;
2246  yybackup:
2247
2248 /* Do appropriate processing given the current state.  */
2249 /* Read a lookahead token if we need one and don't already have one.  */
2250 /* yyresume: */
2251
2252   /* First try to decide what to do without reference to lookahead token.  */
2253
2254   yyn = yypact[yystate];
2255   if (yyn == YYFLAG)
2256     goto yydefault;
2257
2258   /* Not known => get a lookahead token if don't already have one.  */
2259
2260   /* yychar is either YYEMPTY or YYEOF
2261      or a valid token in external form.  */
2262
2263   if (yychar == YYEMPTY)
2264     {
2265 #if YYDEBUG != 0
2266       if (yydebug)
2267         fprintf(stderr, "Reading a token: ");
2268 #endif
2269       yychar = YYLEX;
2270     }
2271
2272   /* Convert token to internal form (in yychar1) for indexing tables with */
2273
2274   if (yychar <= 0)              /* This means end of input. */
2275     {
2276       yychar1 = 0;
2277       yychar = YYEOF;           /* Don't call YYLEX any more */
2278
2279 #if YYDEBUG != 0
2280       if (yydebug)
2281         fprintf(stderr, "Now at end of input.\n");
2282 #endif
2283     }
2284   else
2285     {
2286       yychar1 = YYTRANSLATE(yychar);
2287
2288 #if YYDEBUG != 0
2289       if (yydebug)
2290         {
2291           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
2292           /* Give the individual parser a way to print the precise meaning
2293              of a token, for further debugging info.  */
2294 #ifdef YYPRINT
2295           YYPRINT (stderr, yychar, yylval);
2296 #endif
2297           fprintf (stderr, ")\n");
2298         }
2299 #endif
2300     }
2301
2302   yyn += yychar1;
2303   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
2304     goto yydefault;
2305
2306   yyn = yytable[yyn];
2307
2308   /* yyn is what to do for this token type in this state.
2309      Negative => reduce, -yyn is rule number.
2310      Positive => shift, yyn is new state.
2311        New state is final state => don't bother to shift,
2312        just return success.
2313      0, or most negative number => error.  */
2314
2315   if (yyn < 0)
2316     {
2317       if (yyn == YYFLAG)
2318         goto yyerrlab;
2319       yyn = -yyn;
2320       goto yyreduce;
2321     }
2322   else if (yyn == 0)
2323     goto yyerrlab;
2324
2325   if (yyn == YYFINAL)
2326     YYACCEPT;
2327
2328   /* Shift the lookahead token.  */
2329
2330 #if YYDEBUG != 0
2331   if (yydebug)
2332     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
2333 #endif
2334
2335   /* Discard the token being shifted unless it is eof.  */
2336   if (yychar != YYEOF)
2337     yychar = YYEMPTY;
2338
2339   *++yyvsp = yylval;
2340 #ifdef YYLSP_NEEDED
2341   *++yylsp = yylloc;
2342 #endif
2343
2344   /* count tokens shifted since error; after three, turn off error status.  */
2345   if (yyerrstatus) yyerrstatus--;
2346
2347   yystate = yyn;
2348   goto yynewstate;
2349
2350 /* Do the default action for the current state.  */
2351 yydefault:
2352
2353   yyn = yydefact[yystate];
2354   if (yyn == 0)
2355     goto yyerrlab;
2356
2357 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
2358 yyreduce:
2359   yylen = yyr2[yyn];
2360   if (yylen > 0)
2361     yyval = yyvsp[1-yylen]; /* implement default value of the action */
2362
2363 #if YYDEBUG != 0
2364   if (yydebug)
2365     {
2366       int i;
2367
2368       fprintf (stderr, "Reducing via rule %d (line %d), ",
2369                yyn, yyrline[yyn]);
2370
2371       /* Print the symbols being reduced, and their result.  */
2372       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
2373         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
2374       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
2375     }
2376 #endif
2377
2378
2379   switch (yyn) {
2380
2381 case 28:
2382 #line 1054 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2383 { yyval.IPredicate = ICmpInst::ICMP_EQ; ;
2384     break;}
2385 case 29:
2386 #line 1054 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2387 { yyval.IPredicate = ICmpInst::ICMP_NE; ;
2388     break;}
2389 case 30:
2390 #line 1055 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2391 { yyval.IPredicate = ICmpInst::ICMP_SLT; ;
2392     break;}
2393 case 31:
2394 #line 1055 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2395 { yyval.IPredicate = ICmpInst::ICMP_SGT; ;
2396     break;}
2397 case 32:
2398 #line 1056 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2399 { yyval.IPredicate = ICmpInst::ICMP_SLE; ;
2400     break;}
2401 case 33:
2402 #line 1056 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2403 { yyval.IPredicate = ICmpInst::ICMP_SGE; ;
2404     break;}
2405 case 34:
2406 #line 1057 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2407 { yyval.IPredicate = ICmpInst::ICMP_ULT; ;
2408     break;}
2409 case 35:
2410 #line 1057 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2411 { yyval.IPredicate = ICmpInst::ICMP_UGT; ;
2412     break;}
2413 case 36:
2414 #line 1058 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2415 { yyval.IPredicate = ICmpInst::ICMP_ULE; ;
2416     break;}
2417 case 37:
2418 #line 1058 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2419 { yyval.IPredicate = ICmpInst::ICMP_UGE; ;
2420     break;}
2421 case 38:
2422 #line 1062 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2423 { yyval.FPredicate = FCmpInst::FCMP_OEQ; ;
2424     break;}
2425 case 39:
2426 #line 1062 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2427 { yyval.FPredicate = FCmpInst::FCMP_ONE; ;
2428     break;}
2429 case 40:
2430 #line 1063 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2431 { yyval.FPredicate = FCmpInst::FCMP_OLT; ;
2432     break;}
2433 case 41:
2434 #line 1063 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2435 { yyval.FPredicate = FCmpInst::FCMP_OGT; ;
2436     break;}
2437 case 42:
2438 #line 1064 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2439 { yyval.FPredicate = FCmpInst::FCMP_OLE; ;
2440     break;}
2441 case 43:
2442 #line 1064 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2443 { yyval.FPredicate = FCmpInst::FCMP_OGE; ;
2444     break;}
2445 case 44:
2446 #line 1065 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2447 { yyval.FPredicate = FCmpInst::FCMP_ORD; ;
2448     break;}
2449 case 45:
2450 #line 1065 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2451 { yyval.FPredicate = FCmpInst::FCMP_UNO; ;
2452     break;}
2453 case 46:
2454 #line 1066 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2455 { yyval.FPredicate = FCmpInst::FCMP_UEQ; ;
2456     break;}
2457 case 47:
2458 #line 1066 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2459 { yyval.FPredicate = FCmpInst::FCMP_UNE; ;
2460     break;}
2461 case 48:
2462 #line 1067 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2463 { yyval.FPredicate = FCmpInst::FCMP_ULT; ;
2464     break;}
2465 case 49:
2466 #line 1067 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2467 { yyval.FPredicate = FCmpInst::FCMP_UGT; ;
2468     break;}
2469 case 50:
2470 #line 1068 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2471 { yyval.FPredicate = FCmpInst::FCMP_ULE; ;
2472     break;}
2473 case 51:
2474 #line 1068 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2475 { yyval.FPredicate = FCmpInst::FCMP_UGE; ;
2476     break;}
2477 case 52:
2478 #line 1069 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2479 { yyval.FPredicate = FCmpInst::FCMP_TRUE; ;
2480     break;}
2481 case 53:
2482 #line 1070 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2483 { yyval.FPredicate = FCmpInst::FCMP_FALSE; ;
2484     break;}
2485 case 60:
2486 #line 1079 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2487 { yyval.StrVal = 0; ;
2488     break;}
2489 case 61:
2490 #line 1083 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2491 {
2492     yyval.StrVal = yyvsp[-1].StrVal;
2493     CHECK_FOR_ERROR
2494   ;
2495     break;}
2496 case 62:
2497 #line 1087 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2498 {
2499     yyval.StrVal = 0;
2500     CHECK_FOR_ERROR
2501   ;
2502     break;}
2503 case 65:
2504 #line 1094 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2505 {
2506     yyval.StrVal = yyvsp[-1].StrVal;
2507     CHECK_FOR_ERROR
2508   ;
2509     break;}
2510 case 66:
2511 #line 1098 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2512 {
2513     yyval.StrVal = 0;
2514     CHECK_FOR_ERROR
2515   ;
2516     break;}
2517 case 67:
2518 #line 1104 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2519 { yyval.Linkage = GlobalValue::InternalLinkage; ;
2520     break;}
2521 case 68:
2522 #line 1105 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2523 { yyval.Linkage = GlobalValue::WeakLinkage; ;
2524     break;}
2525 case 69:
2526 #line 1106 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2527 { yyval.Linkage = GlobalValue::LinkOnceLinkage; ;
2528     break;}
2529 case 70:
2530 #line 1107 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2531 { yyval.Linkage = GlobalValue::AppendingLinkage; ;
2532     break;}
2533 case 71:
2534 #line 1108 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2535 { yyval.Linkage = GlobalValue::DLLExportLinkage; ;
2536     break;}
2537 case 72:
2538 #line 1112 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2539 { yyval.Linkage = GlobalValue::DLLImportLinkage; ;
2540     break;}
2541 case 73:
2542 #line 1113 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2543 { yyval.Linkage = GlobalValue::ExternalWeakLinkage; ;
2544     break;}
2545 case 74:
2546 #line 1114 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2547 { yyval.Linkage = GlobalValue::ExternalLinkage; ;
2548     break;}
2549 case 75:
2550 #line 1118 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2551 { yyval.Visibility = GlobalValue::DefaultVisibility; ;
2552     break;}
2553 case 76:
2554 #line 1119 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2555 { yyval.Visibility = GlobalValue::HiddenVisibility;  ;
2556     break;}
2557 case 77:
2558 #line 1123 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2559 { yyval.Linkage = GlobalValue::ExternalLinkage; ;
2560     break;}
2561 case 78:
2562 #line 1124 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2563 { yyval.Linkage = GlobalValue::DLLImportLinkage; ;
2564     break;}
2565 case 79:
2566 #line 1125 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2567 { yyval.Linkage = GlobalValue::ExternalWeakLinkage; ;
2568     break;}
2569 case 80:
2570 #line 1129 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2571 { yyval.Linkage = GlobalValue::ExternalLinkage; ;
2572     break;}
2573 case 81:
2574 #line 1130 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2575 { yyval.Linkage = GlobalValue::InternalLinkage; ;
2576     break;}
2577 case 82:
2578 #line 1131 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2579 { yyval.Linkage = GlobalValue::LinkOnceLinkage; ;
2580     break;}
2581 case 83:
2582 #line 1132 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2583 { yyval.Linkage = GlobalValue::WeakLinkage; ;
2584     break;}
2585 case 84:
2586 #line 1133 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2587 { yyval.Linkage = GlobalValue::DLLExportLinkage; ;
2588     break;}
2589 case 85:
2590 #line 1136 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2591 { yyval.UIntVal = CallingConv::C; ;
2592     break;}
2593 case 86:
2594 #line 1137 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2595 { yyval.UIntVal = CallingConv::C; ;
2596     break;}
2597 case 87:
2598 #line 1138 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2599 { yyval.UIntVal = CallingConv::Fast; ;
2600     break;}
2601 case 88:
2602 #line 1139 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2603 { yyval.UIntVal = CallingConv::Cold; ;
2604     break;}
2605 case 89:
2606 #line 1140 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2607 { yyval.UIntVal = CallingConv::X86_StdCall; ;
2608     break;}
2609 case 90:
2610 #line 1141 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2611 { yyval.UIntVal = CallingConv::X86_FastCall; ;
2612     break;}
2613 case 91:
2614 #line 1142 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2615 {
2616                    if ((unsigned)yyvsp[0].UInt64Val != yyvsp[0].UInt64Val)
2617                      GEN_ERROR("Calling conv too large");
2618                    yyval.UIntVal = yyvsp[0].UInt64Val;
2619                   CHECK_FOR_ERROR
2620                  ;
2621     break;}
2622 case 92:
2623 #line 1149 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2624 { yyval.ParamAttrs = FunctionType::ZExtAttribute;      ;
2625     break;}
2626 case 93:
2627 #line 1150 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2628 { yyval.ParamAttrs = FunctionType::SExtAttribute;      ;
2629     break;}
2630 case 94:
2631 #line 1151 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2632 { yyval.ParamAttrs = FunctionType::InRegAttribute;     ;
2633     break;}
2634 case 95:
2635 #line 1152 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2636 { yyval.ParamAttrs = FunctionType::StructRetAttribute; ;
2637     break;}
2638 case 96:
2639 #line 1155 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2640 { yyval.ParamAttrs = FunctionType::NoAttributeSet; ;
2641     break;}
2642 case 97:
2643 #line 1156 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2644 {
2645                 yyval.ParamAttrs = FunctionType::ParameterAttributes(yyvsp[-1].ParamAttrs | yyvsp[0].ParamAttrs);
2646               ;
2647     break;}
2648 case 98:
2649 #line 1161 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2650 { yyval.ParamAttrs = FunctionType::NoReturnAttribute; ;
2651     break;}
2652 case 100:
2653 #line 1165 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2654 { yyval.ParamAttrs = FunctionType::NoAttributeSet; ;
2655     break;}
2656 case 101:
2657 #line 1166 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2658 {
2659                 yyval.ParamAttrs = FunctionType::ParameterAttributes(yyvsp[-1].ParamAttrs | yyvsp[0].ParamAttrs);
2660               ;
2661     break;}
2662 case 102:
2663 #line 1173 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2664 { yyval.UIntVal = 0; ;
2665     break;}
2666 case 103:
2667 #line 1174 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2668 {
2669   yyval.UIntVal = yyvsp[0].UInt64Val;
2670   if (yyval.UIntVal != 0 && !isPowerOf2_32(yyval.UIntVal))
2671     GEN_ERROR("Alignment must be a power of two");
2672   CHECK_FOR_ERROR
2673 ;
2674     break;}
2675 case 104:
2676 #line 1180 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2677 { yyval.UIntVal = 0; ;
2678     break;}
2679 case 105:
2680 #line 1181 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2681 {
2682   yyval.UIntVal = yyvsp[0].UInt64Val;
2683   if (yyval.UIntVal != 0 && !isPowerOf2_32(yyval.UIntVal))
2684     GEN_ERROR("Alignment must be a power of two");
2685   CHECK_FOR_ERROR
2686 ;
2687     break;}
2688 case 106:
2689 #line 1189 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2690 {
2691   for (unsigned i = 0, e = strlen(yyvsp[0].StrVal); i != e; ++i)
2692     if (yyvsp[0].StrVal[i] == '"' || yyvsp[0].StrVal[i] == '\\')
2693       GEN_ERROR("Invalid character in section name");
2694   yyval.StrVal = yyvsp[0].StrVal;
2695   CHECK_FOR_ERROR
2696 ;
2697     break;}
2698 case 107:
2699 #line 1197 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2700 { yyval.StrVal = 0; ;
2701     break;}
2702 case 108:
2703 #line 1198 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2704 { yyval.StrVal = yyvsp[0].StrVal; ;
2705     break;}
2706 case 109:
2707 #line 1203 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2708 {;
2709     break;}
2710 case 110:
2711 #line 1204 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2712 {;
2713     break;}
2714 case 111:
2715 #line 1205 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2716 {
2717     CurGV->setSection(yyvsp[0].StrVal);
2718     free(yyvsp[0].StrVal);
2719     CHECK_FOR_ERROR
2720   ;
2721     break;}
2722 case 112:
2723 #line 1210 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2724 {
2725     if (yyvsp[0].UInt64Val != 0 && !isPowerOf2_32(yyvsp[0].UInt64Val))
2726       GEN_ERROR("Alignment must be a power of two");
2727     CurGV->setAlignment(yyvsp[0].UInt64Val);
2728     CHECK_FOR_ERROR
2729   ;
2730     break;}
2731 case 117:
2732 #line 1226 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2733 {
2734     yyval.TypeVal = new PATypeHolder(OpaqueType::get());
2735     CHECK_FOR_ERROR
2736   ;
2737     break;}
2738 case 118:
2739 #line 1230 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2740 {
2741     yyval.TypeVal = new PATypeHolder(yyvsp[0].PrimType);
2742     CHECK_FOR_ERROR
2743   ;
2744     break;}
2745 case 119:
2746 #line 1234 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2747 {                             // Pointer type?
2748     if (*yyvsp[-1].TypeVal == Type::LabelTy)
2749       GEN_ERROR("Cannot form a pointer to a basic block");
2750     yyval.TypeVal = new PATypeHolder(HandleUpRefs(PointerType::get(*yyvsp[-1].TypeVal)));
2751     delete yyvsp[-1].TypeVal;
2752     CHECK_FOR_ERROR
2753   ;
2754     break;}
2755 case 120:
2756 #line 1241 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2757 {            // Named types are also simple types...
2758     const Type* tmp = getTypeVal(yyvsp[0].ValIDVal);
2759     CHECK_FOR_ERROR
2760     yyval.TypeVal = new PATypeHolder(tmp);
2761   ;
2762     break;}
2763 case 121:
2764 #line 1246 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2765 {                   // Type UpReference
2766     if (yyvsp[0].UInt64Val > (uint64_t)~0U) GEN_ERROR("Value out of range");
2767     OpaqueType *OT = OpaqueType::get();        // Use temporary placeholder
2768     UpRefs.push_back(UpRefRecord((unsigned)yyvsp[0].UInt64Val, OT));  // Add to vector...
2769     yyval.TypeVal = new PATypeHolder(OT);
2770     UR_OUT("New Upreference!\n");
2771     CHECK_FOR_ERROR
2772   ;
2773     break;}
2774 case 122:
2775 #line 1254 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2776 {
2777     std::vector<const Type*> Params;
2778     std::vector<FunctionType::ParameterAttributes> Attrs;
2779     Attrs.push_back(yyvsp[0].ParamAttrs);
2780     for (TypeWithAttrsList::iterator I=yyvsp[-2].TypeWithAttrsList->begin(), E=yyvsp[-2].TypeWithAttrsList->end(); I != E; ++I) {
2781       Params.push_back(I->Ty->get());
2782       if (I->Ty->get() != Type::VoidTy)
2783         Attrs.push_back(I->Attrs);
2784     }
2785     bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
2786     if (isVarArg) Params.pop_back();
2787
2788     FunctionType *FT = FunctionType::get(*yyvsp[-4].TypeVal, Params, isVarArg, Attrs);
2789     delete yyvsp[-2].TypeWithAttrsList;   // Delete the argument list
2790     delete yyvsp[-4].TypeVal;   // Delete the return type handle
2791     yyval.TypeVal = new PATypeHolder(HandleUpRefs(FT));
2792     CHECK_FOR_ERROR
2793   ;
2794     break;}
2795 case 123:
2796 #line 1272 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2797 {
2798     std::vector<const Type*> Params;
2799     std::vector<FunctionType::ParameterAttributes> Attrs;
2800     Attrs.push_back(yyvsp[0].ParamAttrs);
2801     for (TypeWithAttrsList::iterator I=yyvsp[-2].TypeWithAttrsList->begin(), E=yyvsp[-2].TypeWithAttrsList->end(); I != E; ++I) {
2802       Params.push_back(I->Ty->get());
2803       if (I->Ty->get() != Type::VoidTy)
2804         Attrs.push_back(I->Attrs);
2805     }
2806     bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
2807     if (isVarArg) Params.pop_back();
2808
2809     FunctionType *FT = FunctionType::get(yyvsp[-4].PrimType, Params, isVarArg, Attrs);
2810     delete yyvsp[-2].TypeWithAttrsList;      // Delete the argument list
2811     yyval.TypeVal = new PATypeHolder(HandleUpRefs(FT));
2812     CHECK_FOR_ERROR
2813   ;
2814     break;}
2815 case 124:
2816 #line 1290 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2817 {          // Sized array type?
2818     yyval.TypeVal = new PATypeHolder(HandleUpRefs(ArrayType::get(*yyvsp[-1].TypeVal, (unsigned)yyvsp[-3].UInt64Val)));
2819     delete yyvsp[-1].TypeVal;
2820     CHECK_FOR_ERROR
2821   ;
2822     break;}
2823 case 125:
2824 #line 1295 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2825 {          // Vector type?
2826      const llvm::Type* ElemTy = yyvsp[-1].TypeVal->get();
2827      if ((unsigned)yyvsp[-3].UInt64Val != yyvsp[-3].UInt64Val)
2828         GEN_ERROR("Unsigned result not equal to signed result");
2829      if (!ElemTy->isFloatingPoint() && !ElemTy->isInteger())
2830         GEN_ERROR("Element type of a VectorType must be primitive");
2831      if (!isPowerOf2_32(yyvsp[-3].UInt64Val))
2832        GEN_ERROR("Vector length should be a power of 2");
2833      yyval.TypeVal = new PATypeHolder(HandleUpRefs(VectorType::get(*yyvsp[-1].TypeVal, (unsigned)yyvsp[-3].UInt64Val)));
2834      delete yyvsp[-1].TypeVal;
2835      CHECK_FOR_ERROR
2836   ;
2837     break;}
2838 case 126:
2839 #line 1307 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2840 {                        // Structure type?
2841     std::vector<const Type*> Elements;
2842     for (std::list<llvm::PATypeHolder>::iterator I = yyvsp[-1].TypeList->begin(),
2843            E = yyvsp[-1].TypeList->end(); I != E; ++I)
2844       Elements.push_back(*I);
2845
2846     yyval.TypeVal = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
2847     delete yyvsp[-1].TypeList;
2848     CHECK_FOR_ERROR
2849   ;
2850     break;}
2851 case 127:
2852 #line 1317 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2853 {                                  // Empty structure type?
2854     yyval.TypeVal = new PATypeHolder(StructType::get(std::vector<const Type*>()));
2855     CHECK_FOR_ERROR
2856   ;
2857     break;}
2858 case 128:
2859 #line 1321 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2860 {
2861     std::vector<const Type*> Elements;
2862     for (std::list<llvm::PATypeHolder>::iterator I = yyvsp[-2].TypeList->begin(),
2863            E = yyvsp[-2].TypeList->end(); I != E; ++I)
2864       Elements.push_back(*I);
2865
2866     yyval.TypeVal = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
2867     delete yyvsp[-2].TypeList;
2868     CHECK_FOR_ERROR
2869   ;
2870     break;}
2871 case 129:
2872 #line 1331 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2873 {                         // Empty structure type?
2874     yyval.TypeVal = new PATypeHolder(StructType::get(std::vector<const Type*>(), true));
2875     CHECK_FOR_ERROR
2876   ;
2877     break;}
2878 case 130:
2879 #line 1338 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2880 {
2881     yyval.TypeWithAttrs.Ty = yyvsp[-1].TypeVal;
2882     yyval.TypeWithAttrs.Attrs = yyvsp[0].ParamAttrs;
2883   ;
2884     break;}
2885 case 131:
2886 #line 1345 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2887 {
2888     if (!UpRefs.empty())
2889       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
2890     if (!(*yyvsp[0].TypeVal)->isFirstClassType())
2891       GEN_ERROR("LLVM functions cannot return aggregate types");
2892     yyval.TypeVal = yyvsp[0].TypeVal;
2893   ;
2894     break;}
2895 case 132:
2896 #line 1352 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2897 {
2898     yyval.TypeVal = new PATypeHolder(Type::VoidTy);
2899   ;
2900     break;}
2901 case 133:
2902 #line 1357 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2903 {
2904     yyval.TypeWithAttrsList = new TypeWithAttrsList();
2905     yyval.TypeWithAttrsList->push_back(yyvsp[0].TypeWithAttrs);
2906     CHECK_FOR_ERROR
2907   ;
2908     break;}
2909 case 134:
2910 #line 1362 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2911 {
2912     (yyval.TypeWithAttrsList=yyvsp[-2].TypeWithAttrsList)->push_back(yyvsp[0].TypeWithAttrs);
2913     CHECK_FOR_ERROR
2914   ;
2915     break;}
2916 case 136:
2917 #line 1370 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2918 {
2919     yyval.TypeWithAttrsList=yyvsp[-2].TypeWithAttrsList;
2920     TypeWithAttrs TWA; TWA.Attrs = FunctionType::NoAttributeSet;
2921     TWA.Ty = new PATypeHolder(Type::VoidTy);
2922     yyval.TypeWithAttrsList->push_back(TWA);
2923     CHECK_FOR_ERROR
2924   ;
2925     break;}
2926 case 137:
2927 #line 1377 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2928 {
2929     yyval.TypeWithAttrsList = new TypeWithAttrsList;
2930     TypeWithAttrs TWA; TWA.Attrs = FunctionType::NoAttributeSet;
2931     TWA.Ty = new PATypeHolder(Type::VoidTy);
2932     yyval.TypeWithAttrsList->push_back(TWA);
2933     CHECK_FOR_ERROR
2934   ;
2935     break;}
2936 case 138:
2937 #line 1384 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2938 {
2939     yyval.TypeWithAttrsList = new TypeWithAttrsList();
2940     CHECK_FOR_ERROR
2941   ;
2942     break;}
2943 case 139:
2944 #line 1392 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2945 {
2946     yyval.TypeList = new std::list<PATypeHolder>();
2947     yyval.TypeList->push_back(*yyvsp[0].TypeVal); delete yyvsp[0].TypeVal;
2948     CHECK_FOR_ERROR
2949   ;
2950     break;}
2951 case 140:
2952 #line 1397 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2953 {
2954     (yyval.TypeList=yyvsp[-2].TypeList)->push_back(*yyvsp[0].TypeVal); delete yyvsp[0].TypeVal;
2955     CHECK_FOR_ERROR
2956   ;
2957     break;}
2958 case 141:
2959 #line 1408 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2960 { // Nonempty unsized arr
2961     if (!UpRefs.empty())
2962       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
2963     const ArrayType *ATy = dyn_cast<ArrayType>(yyvsp[-3].TypeVal->get());
2964     if (ATy == 0)
2965       GEN_ERROR("Cannot make array constant with type: '" +
2966                      (*yyvsp[-3].TypeVal)->getDescription() + "'");
2967     const Type *ETy = ATy->getElementType();
2968     int NumElements = ATy->getNumElements();
2969
2970     // Verify that we have the correct size...
2971     if (NumElements != -1 && NumElements != (int)yyvsp[-1].ConstVector->size())
2972       GEN_ERROR("Type mismatch: constant sized array initialized with " +
2973                      utostr(yyvsp[-1].ConstVector->size()) +  " arguments, but has size of " +
2974                      itostr(NumElements) + "");
2975
2976     // Verify all elements are correct type!
2977     for (unsigned i = 0; i < yyvsp[-1].ConstVector->size(); i++) {
2978       if (ETy != (*yyvsp[-1].ConstVector)[i]->getType())
2979         GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
2980                        ETy->getDescription() +"' as required!\nIt is of type '"+
2981                        (*yyvsp[-1].ConstVector)[i]->getType()->getDescription() + "'.");
2982     }
2983
2984     yyval.ConstVal = ConstantArray::get(ATy, *yyvsp[-1].ConstVector);
2985     delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector;
2986     CHECK_FOR_ERROR
2987   ;
2988     break;}
2989 case 142:
2990 #line 1436 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
2991 {
2992     if (!UpRefs.empty())
2993       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
2994     const ArrayType *ATy = dyn_cast<ArrayType>(yyvsp[-2].TypeVal->get());
2995     if (ATy == 0)
2996       GEN_ERROR("Cannot make array constant with type: '" +
2997                      (*yyvsp[-2].TypeVal)->getDescription() + "'");
2998
2999     int NumElements = ATy->getNumElements();
3000     if (NumElements != -1 && NumElements != 0)
3001       GEN_ERROR("Type mismatch: constant sized array initialized with 0"
3002                      " arguments, but has size of " + itostr(NumElements) +"");
3003     yyval.ConstVal = ConstantArray::get(ATy, std::vector<Constant*>());
3004     delete yyvsp[-2].TypeVal;
3005     CHECK_FOR_ERROR
3006   ;
3007     break;}
3008 case 143:
3009 #line 1452 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3010 {
3011     if (!UpRefs.empty())
3012       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
3013     const ArrayType *ATy = dyn_cast<ArrayType>(yyvsp[-2].TypeVal->get());
3014     if (ATy == 0)
3015       GEN_ERROR("Cannot make array constant with type: '" +
3016                      (*yyvsp[-2].TypeVal)->getDescription() + "'");
3017
3018     int NumElements = ATy->getNumElements();
3019     const Type *ETy = ATy->getElementType();
3020     char *EndStr = UnEscapeLexed(yyvsp[0].StrVal, true);
3021     if (NumElements != -1 && NumElements != (EndStr-yyvsp[0].StrVal))
3022       GEN_ERROR("Can't build string constant of size " +
3023                      itostr((int)(EndStr-yyvsp[0].StrVal)) +
3024                      " when array has size " + itostr(NumElements) + "");
3025     std::vector<Constant*> Vals;
3026     if (ETy == Type::Int8Ty) {
3027       for (unsigned char *C = (unsigned char *)yyvsp[0].StrVal;
3028         C != (unsigned char*)EndStr; ++C)
3029       Vals.push_back(ConstantInt::get(ETy, *C));
3030     } else {
3031       free(yyvsp[0].StrVal);
3032       GEN_ERROR("Cannot build string arrays of non byte sized elements");
3033     }
3034     free(yyvsp[0].StrVal);
3035     yyval.ConstVal = ConstantArray::get(ATy, Vals);
3036     delete yyvsp[-2].TypeVal;
3037     CHECK_FOR_ERROR
3038   ;
3039     break;}
3040 case 144:
3041 #line 1481 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3042 { // Nonempty unsized arr
3043     if (!UpRefs.empty())
3044       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
3045     const VectorType *PTy = dyn_cast<VectorType>(yyvsp[-3].TypeVal->get());
3046     if (PTy == 0)
3047       GEN_ERROR("Cannot make packed constant with type: '" +
3048                      (*yyvsp[-3].TypeVal)->getDescription() + "'");
3049     const Type *ETy = PTy->getElementType();
3050     int NumElements = PTy->getNumElements();
3051
3052     // Verify that we have the correct size...
3053     if (NumElements != -1 && NumElements != (int)yyvsp[-1].ConstVector->size())
3054       GEN_ERROR("Type mismatch: constant sized packed initialized with " +
3055                      utostr(yyvsp[-1].ConstVector->size()) +  " arguments, but has size of " +
3056                      itostr(NumElements) + "");
3057
3058     // Verify all elements are correct type!
3059     for (unsigned i = 0; i < yyvsp[-1].ConstVector->size(); i++) {
3060       if (ETy != (*yyvsp[-1].ConstVector)[i]->getType())
3061         GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
3062            ETy->getDescription() +"' as required!\nIt is of type '"+
3063            (*yyvsp[-1].ConstVector)[i]->getType()->getDescription() + "'.");
3064     }
3065
3066     yyval.ConstVal = ConstantVector::get(PTy, *yyvsp[-1].ConstVector);
3067     delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector;
3068     CHECK_FOR_ERROR
3069   ;
3070     break;}
3071 case 145:
3072 #line 1509 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3073 {
3074     const StructType *STy = dyn_cast<StructType>(yyvsp[-3].TypeVal->get());
3075     if (STy == 0)
3076       GEN_ERROR("Cannot make struct constant with type: '" +
3077                      (*yyvsp[-3].TypeVal)->getDescription() + "'");
3078
3079     if (yyvsp[-1].ConstVector->size() != STy->getNumContainedTypes())
3080       GEN_ERROR("Illegal number of initializers for structure type");
3081
3082     // Check to ensure that constants are compatible with the type initializer!
3083     for (unsigned i = 0, e = yyvsp[-1].ConstVector->size(); i != e; ++i)
3084       if ((*yyvsp[-1].ConstVector)[i]->getType() != STy->getElementType(i))
3085         GEN_ERROR("Expected type '" +
3086                        STy->getElementType(i)->getDescription() +
3087                        "' for element #" + utostr(i) +
3088                        " of structure initializer");
3089
3090     // Check to ensure that Type is not packed
3091     if (STy->isPacked())
3092       GEN_ERROR("Unpacked Initializer to vector type '" + STy->getDescription() + "'");
3093
3094     yyval.ConstVal = ConstantStruct::get(STy, *yyvsp[-1].ConstVector);
3095     delete yyvsp[-3].TypeVal; delete yyvsp[-1].ConstVector;
3096     CHECK_FOR_ERROR
3097   ;
3098     break;}
3099 case 146:
3100 #line 1534 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3101 {
3102     if (!UpRefs.empty())
3103       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
3104     const StructType *STy = dyn_cast<StructType>(yyvsp[-2].TypeVal->get());
3105     if (STy == 0)
3106       GEN_ERROR("Cannot make struct constant with type: '" +
3107                      (*yyvsp[-2].TypeVal)->getDescription() + "'");
3108
3109     if (STy->getNumContainedTypes() != 0)
3110       GEN_ERROR("Illegal number of initializers for structure type");
3111
3112     // Check to ensure that Type is not packed
3113     if (STy->isPacked())
3114       GEN_ERROR("Unpacked Initializer to vector type '" + STy->getDescription() + "'");
3115
3116     yyval.ConstVal = ConstantStruct::get(STy, std::vector<Constant*>());
3117     delete yyvsp[-2].TypeVal;
3118     CHECK_FOR_ERROR
3119   ;
3120     break;}
3121 case 147:
3122 #line 1553 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3123 {
3124     const StructType *STy = dyn_cast<StructType>(yyvsp[-5].TypeVal->get());
3125     if (STy == 0)
3126       GEN_ERROR("Cannot make struct constant with type: '" +
3127                      (*yyvsp[-5].TypeVal)->getDescription() + "'");
3128
3129     if (yyvsp[-2].ConstVector->size() != STy->getNumContainedTypes())
3130       GEN_ERROR("Illegal number of initializers for structure type");
3131
3132     // Check to ensure that constants are compatible with the type initializer!
3133     for (unsigned i = 0, e = yyvsp[-2].ConstVector->size(); i != e; ++i)
3134       if ((*yyvsp[-2].ConstVector)[i]->getType() != STy->getElementType(i))
3135         GEN_ERROR("Expected type '" +
3136                        STy->getElementType(i)->getDescription() +
3137                        "' for element #" + utostr(i) +
3138                        " of structure initializer");
3139
3140     // Check to ensure that Type is packed
3141     if (!STy->isPacked())
3142       GEN_ERROR("Vector initializer to non-vector type '" +
3143                 STy->getDescription() + "'");
3144
3145     yyval.ConstVal = ConstantStruct::get(STy, *yyvsp[-2].ConstVector);
3146     delete yyvsp[-5].TypeVal; delete yyvsp[-2].ConstVector;
3147     CHECK_FOR_ERROR
3148   ;
3149     break;}
3150 case 148:
3151 #line 1579 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3152 {
3153     if (!UpRefs.empty())
3154       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription());
3155     const StructType *STy = dyn_cast<StructType>(yyvsp[-4].TypeVal->get());
3156     if (STy == 0)
3157       GEN_ERROR("Cannot make struct constant with type: '" +
3158                      (*yyvsp[-4].TypeVal)->getDescription() + "'");
3159
3160     if (STy->getNumContainedTypes() != 0)
3161       GEN_ERROR("Illegal number of initializers for structure type");
3162
3163     // Check to ensure that Type is packed
3164     if (!STy->isPacked())
3165       GEN_ERROR("Vector initializer to non-vector type '" +
3166                 STy->getDescription() + "'");
3167
3168     yyval.ConstVal = ConstantStruct::get(STy, std::vector<Constant*>());
3169     delete yyvsp[-4].TypeVal;
3170     CHECK_FOR_ERROR
3171   ;
3172     break;}
3173 case 149:
3174 #line 1599 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3175 {
3176     if (!UpRefs.empty())
3177       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
3178     const PointerType *PTy = dyn_cast<PointerType>(yyvsp[-1].TypeVal->get());
3179     if (PTy == 0)
3180       GEN_ERROR("Cannot make null pointer constant with type: '" +
3181                      (*yyvsp[-1].TypeVal)->getDescription() + "'");
3182
3183     yyval.ConstVal = ConstantPointerNull::get(PTy);
3184     delete yyvsp[-1].TypeVal;
3185     CHECK_FOR_ERROR
3186   ;
3187     break;}
3188 case 150:
3189 #line 1611 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3190 {
3191     if (!UpRefs.empty())
3192       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
3193     yyval.ConstVal = UndefValue::get(yyvsp[-1].TypeVal->get());
3194     delete yyvsp[-1].TypeVal;
3195     CHECK_FOR_ERROR
3196   ;
3197     break;}
3198 case 151:
3199 #line 1618 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3200 {
3201     if (!UpRefs.empty())
3202       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
3203     const PointerType *Ty = dyn_cast<PointerType>(yyvsp[-1].TypeVal->get());
3204     if (Ty == 0)
3205       GEN_ERROR("Global const reference must be a pointer type");
3206
3207     // ConstExprs can exist in the body of a function, thus creating
3208     // GlobalValues whenever they refer to a variable.  Because we are in
3209     // the context of a function, getValNonImprovising will search the functions
3210     // symbol table instead of the module symbol table for the global symbol,
3211     // which throws things all off.  To get around this, we just tell
3212     // getValNonImprovising that we are at global scope here.
3213     //
3214     Function *SavedCurFn = CurFun.CurrentFunction;
3215     CurFun.CurrentFunction = 0;
3216
3217     Value *V = getValNonImprovising(Ty, yyvsp[0].ValIDVal);
3218     CHECK_FOR_ERROR
3219
3220     CurFun.CurrentFunction = SavedCurFn;
3221
3222     // If this is an initializer for a constant pointer, which is referencing a
3223     // (currently) undefined variable, create a stub now that shall be replaced
3224     // in the future with the right type of variable.
3225     //
3226     if (V == 0) {
3227       assert(isa<PointerType>(Ty) && "Globals may only be used as pointers!");
3228       const PointerType *PT = cast<PointerType>(Ty);
3229
3230       // First check to see if the forward references value is already created!
3231       PerModuleInfo::GlobalRefsType::iterator I =
3232         CurModule.GlobalRefs.find(std::make_pair(PT, yyvsp[0].ValIDVal));
3233
3234       if (I != CurModule.GlobalRefs.end()) {
3235         V = I->second;             // Placeholder already exists, use it...
3236         yyvsp[0].ValIDVal.destroy();
3237       } else {
3238         std::string Name;
3239         if (yyvsp[0].ValIDVal.Type == ValID::GlobalName)
3240           Name = yyvsp[0].ValIDVal.Name;
3241         else if (yyvsp[0].ValIDVal.Type != ValID::GlobalID)
3242           GEN_ERROR("Invalid reference to global");
3243
3244         // Create the forward referenced global.
3245         GlobalValue *GV;
3246         if (const FunctionType *FTy =
3247                  dyn_cast<FunctionType>(PT->getElementType())) {
3248           GV = new Function(FTy, GlobalValue::ExternalLinkage, Name,
3249                             CurModule.CurrentModule);
3250         } else {
3251           GV = new GlobalVariable(PT->getElementType(), false,
3252                                   GlobalValue::ExternalLinkage, 0,
3253                                   Name, CurModule.CurrentModule);
3254         }
3255
3256         // Keep track of the fact that we have a forward ref to recycle it
3257         CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, yyvsp[0].ValIDVal), GV));
3258         V = GV;
3259       }
3260     }
3261
3262     yyval.ConstVal = cast<GlobalValue>(V);
3263     delete yyvsp[-1].TypeVal;            // Free the type handle
3264     CHECK_FOR_ERROR
3265   ;
3266     break;}
3267 case 152:
3268 #line 1684 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3269 {
3270     if (!UpRefs.empty())
3271       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
3272     if (yyvsp[-1].TypeVal->get() != yyvsp[0].ConstVal->getType())
3273       GEN_ERROR("Mismatched types for constant expression: " +
3274         (*yyvsp[-1].TypeVal)->getDescription() + " and " + yyvsp[0].ConstVal->getType()->getDescription());
3275     yyval.ConstVal = yyvsp[0].ConstVal;
3276     delete yyvsp[-1].TypeVal;
3277     CHECK_FOR_ERROR
3278   ;
3279     break;}
3280 case 153:
3281 #line 1694 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3282 {
3283     if (!UpRefs.empty())
3284       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
3285     const Type *Ty = yyvsp[-1].TypeVal->get();
3286     if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty))
3287       GEN_ERROR("Cannot create a null initialized value of this type");
3288     yyval.ConstVal = Constant::getNullValue(Ty);
3289     delete yyvsp[-1].TypeVal;
3290     CHECK_FOR_ERROR
3291   ;
3292     break;}
3293 case 154:
3294 #line 1704 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3295 {      // integral constants
3296     if (!ConstantInt::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].SInt64Val))
3297       GEN_ERROR("Constant value doesn't fit in type");
3298     yyval.ConstVal = ConstantInt::get(yyvsp[-1].PrimType, yyvsp[0].SInt64Val);
3299     CHECK_FOR_ERROR
3300   ;
3301     break;}
3302 case 155:
3303 #line 1710 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3304 {      // integral constants
3305     if (!ConstantInt::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].UInt64Val))
3306       GEN_ERROR("Constant value doesn't fit in type");
3307     yyval.ConstVal = ConstantInt::get(yyvsp[-1].PrimType, yyvsp[0].UInt64Val);
3308     CHECK_FOR_ERROR
3309   ;
3310     break;}
3311 case 156:
3312 #line 1716 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3313 {                      // Boolean constants
3314     assert(cast<IntegerType>(yyvsp[-1].PrimType)->getBitWidth() == 1 && "Not Bool?");
3315     yyval.ConstVal = ConstantInt::getTrue();
3316     CHECK_FOR_ERROR
3317   ;
3318     break;}
3319 case 157:
3320 #line 1721 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3321 {                     // Boolean constants
3322     assert(cast<IntegerType>(yyvsp[-1].PrimType)->getBitWidth() == 1 && "Not Bool?");
3323     yyval.ConstVal = ConstantInt::getFalse();
3324     CHECK_FOR_ERROR
3325   ;
3326     break;}
3327 case 158:
3328 #line 1726 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3329 {                   // Float & Double constants
3330     if (!ConstantFP::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].FPVal))
3331       GEN_ERROR("Floating point constant invalid for type");
3332     yyval.ConstVal = ConstantFP::get(yyvsp[-1].PrimType, yyvsp[0].FPVal);
3333     CHECK_FOR_ERROR
3334   ;
3335     break;}
3336 case 159:
3337 #line 1734 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3338 {
3339     if (!UpRefs.empty())
3340       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
3341     Constant *Val = yyvsp[-3].ConstVal;
3342     const Type *DestTy = yyvsp[-1].TypeVal->get();
3343     if (!CastInst::castIsValid(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy))
3344       GEN_ERROR("invalid cast opcode for cast from '" +
3345                 Val->getType()->getDescription() + "' to '" +
3346                 DestTy->getDescription() + "'");
3347     yyval.ConstVal = ConstantExpr::getCast(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy);
3348     delete yyvsp[-1].TypeVal;
3349   ;
3350     break;}
3351 case 160:
3352 #line 1746 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3353 {
3354     if (!isa<PointerType>(yyvsp[-2].ConstVal->getType()))
3355       GEN_ERROR("GetElementPtr requires a pointer operand");
3356
3357     const Type *IdxTy =
3358       GetElementPtrInst::getIndexedType(yyvsp[-2].ConstVal->getType(), &(*yyvsp[-1].ValueList)[0], yyvsp[-1].ValueList->size(),
3359                                         true);
3360     if (!IdxTy)
3361       GEN_ERROR("Index list invalid for constant getelementptr");
3362
3363     SmallVector<Constant*, 8> IdxVec;
3364     for (unsigned i = 0, e = yyvsp[-1].ValueList->size(); i != e; ++i)
3365       if (Constant *C = dyn_cast<Constant>((*yyvsp[-1].ValueList)[i]))
3366         IdxVec.push_back(C);
3367       else
3368         GEN_ERROR("Indices to constant getelementptr must be constants");
3369
3370     delete yyvsp[-1].ValueList;
3371
3372     yyval.ConstVal = ConstantExpr::getGetElementPtr(yyvsp[-2].ConstVal, &IdxVec[0], IdxVec.size());
3373     CHECK_FOR_ERROR
3374   ;
3375     break;}
3376 case 161:
3377 #line 1768 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3378 {
3379     if (yyvsp[-5].ConstVal->getType() != Type::Int1Ty)
3380       GEN_ERROR("Select condition must be of boolean type");
3381     if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
3382       GEN_ERROR("Select operand types must match");
3383     yyval.ConstVal = ConstantExpr::getSelect(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
3384     CHECK_FOR_ERROR
3385   ;
3386     break;}
3387 case 162:
3388 #line 1776 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3389 {
3390     if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
3391       GEN_ERROR("Binary operator types must match");
3392     CHECK_FOR_ERROR;
3393     yyval.ConstVal = ConstantExpr::get(yyvsp[-5].BinaryOpVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
3394   ;
3395     break;}
3396 case 163:
3397 #line 1782 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3398 {
3399     if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
3400       GEN_ERROR("Logical operator types must match");
3401     if (!yyvsp[-3].ConstVal->getType()->isInteger()) {
3402       if (Instruction::isShift(yyvsp[-5].BinaryOpVal) || !isa<VectorType>(yyvsp[-3].ConstVal->getType()) ||
3403           !cast<VectorType>(yyvsp[-3].ConstVal->getType())->getElementType()->isInteger())
3404         GEN_ERROR("Logical operator requires integral operands");
3405     }
3406     yyval.ConstVal = ConstantExpr::get(yyvsp[-5].BinaryOpVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
3407     CHECK_FOR_ERROR
3408   ;
3409     break;}
3410 case 164:
3411 #line 1793 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3412 {
3413     if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
3414       GEN_ERROR("icmp operand types must match");
3415     yyval.ConstVal = ConstantExpr::getICmp(yyvsp[-5].IPredicate, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
3416   ;
3417     break;}
3418 case 165:
3419 #line 1798 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3420 {
3421     if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
3422       GEN_ERROR("fcmp operand types must match");
3423     yyval.ConstVal = ConstantExpr::getFCmp(yyvsp[-5].FPredicate, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
3424   ;
3425     break;}
3426 case 166:
3427 #line 1803 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3428 {
3429     if (!ExtractElementInst::isValidOperands(yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
3430       GEN_ERROR("Invalid extractelement operands");
3431     yyval.ConstVal = ConstantExpr::getExtractElement(yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
3432     CHECK_FOR_ERROR
3433   ;
3434     break;}
3435 case 167:
3436 #line 1809 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3437 {
3438     if (!InsertElementInst::isValidOperands(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
3439       GEN_ERROR("Invalid insertelement operands");
3440     yyval.ConstVal = ConstantExpr::getInsertElement(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
3441     CHECK_FOR_ERROR
3442   ;
3443     break;}
3444 case 168:
3445 #line 1815 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3446 {
3447     if (!ShuffleVectorInst::isValidOperands(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
3448       GEN_ERROR("Invalid shufflevector operands");
3449     yyval.ConstVal = ConstantExpr::getShuffleVector(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
3450     CHECK_FOR_ERROR
3451   ;
3452     break;}
3453 case 169:
3454 #line 1824 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3455 {
3456     (yyval.ConstVector = yyvsp[-2].ConstVector)->push_back(yyvsp[0].ConstVal);
3457     CHECK_FOR_ERROR
3458   ;
3459     break;}
3460 case 170:
3461 #line 1828 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3462 {
3463     yyval.ConstVector = new std::vector<Constant*>();
3464     yyval.ConstVector->push_back(yyvsp[0].ConstVal);
3465     CHECK_FOR_ERROR
3466   ;
3467     break;}
3468 case 171:
3469 #line 1836 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3470 { yyval.BoolVal = false; ;
3471     break;}
3472 case 172:
3473 #line 1836 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3474 { yyval.BoolVal = true; ;
3475     break;}
3476 case 173:
3477 #line 1847 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3478 {
3479     yyval.ModuleVal = ParserResult = CurModule.CurrentModule;
3480     CurModule.ModuleDone();
3481     CHECK_FOR_ERROR;
3482   ;
3483     break;}
3484 case 174:
3485 #line 1852 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3486 {
3487     yyval.ModuleVal = ParserResult = CurModule.CurrentModule;
3488     CurModule.ModuleDone();
3489     CHECK_FOR_ERROR;
3490   ;
3491     break;}
3492 case 177:
3493 #line 1865 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3494 { CurFun.isDeclare = false; ;
3495     break;}
3496 case 178:
3497 #line 1865 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3498 {
3499     CurFun.FunctionDone();
3500     CHECK_FOR_ERROR
3501   ;
3502     break;}
3503 case 179:
3504 #line 1869 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3505 { CurFun.isDeclare = true; ;
3506     break;}
3507 case 180:
3508 #line 1869 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3509 {
3510     CHECK_FOR_ERROR
3511   ;
3512     break;}
3513 case 181:
3514 #line 1872 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3515 {
3516     CHECK_FOR_ERROR
3517   ;
3518     break;}
3519 case 182:
3520 #line 1875 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3521 {
3522     // Emit an error if there are any unresolved types left.
3523     if (!CurModule.LateResolveTypes.empty()) {
3524       const ValID &DID = CurModule.LateResolveTypes.begin()->first;
3525       if (DID.Type == ValID::LocalName) {
3526         GEN_ERROR("Reference to an undefined type: '"+DID.getName() + "'");
3527       } else {
3528         GEN_ERROR("Reference to an undefined type: #" + itostr(DID.Num));
3529       }
3530     }
3531     CHECK_FOR_ERROR
3532   ;
3533     break;}
3534 case 183:
3535 #line 1887 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3536 {
3537     if (!UpRefs.empty())
3538       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
3539     // Eagerly resolve types.  This is not an optimization, this is a
3540     // requirement that is due to the fact that we could have this:
3541     //
3542     // %list = type { %list * }
3543     // %list = type { %list * }    ; repeated type decl
3544     //
3545     // If types are not resolved eagerly, then the two types will not be
3546     // determined to be the same type!
3547     //
3548     ResolveTypeTo(yyvsp[-2].StrVal, *yyvsp[0].TypeVal);
3549
3550     if (!setTypeName(*yyvsp[0].TypeVal, yyvsp[-2].StrVal) && !yyvsp[-2].StrVal) {
3551       CHECK_FOR_ERROR
3552       // If this is a named type that is not a redefinition, add it to the slot
3553       // table.
3554       CurModule.Types.push_back(*yyvsp[0].TypeVal);
3555     }
3556
3557     delete yyvsp[0].TypeVal;
3558     CHECK_FOR_ERROR
3559   ;
3560     break;}
3561 case 184:
3562 #line 1911 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3563 {
3564     ResolveTypeTo(yyvsp[-2].StrVal, yyvsp[0].PrimType);
3565
3566     if (!setTypeName(yyvsp[0].PrimType, yyvsp[-2].StrVal) && !yyvsp[-2].StrVal) {
3567       CHECK_FOR_ERROR
3568       // If this is a named type that is not a redefinition, add it to the slot
3569       // table.
3570       CurModule.Types.push_back(yyvsp[0].PrimType);
3571     }
3572     CHECK_FOR_ERROR
3573   ;
3574     break;}
3575 case 185:
3576 #line 1922 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3577 {
3578     /* "Externally Visible" Linkage */
3579     if (yyvsp[0].ConstVal == 0)
3580       GEN_ERROR("Global value initializer is not a constant");
3581     CurGV = ParseGlobalVariable(yyvsp[-3].StrVal, GlobalValue::ExternalLinkage,
3582                                 yyvsp[-2].Visibility, yyvsp[-1].BoolVal, yyvsp[0].ConstVal->getType(), yyvsp[0].ConstVal);
3583     CHECK_FOR_ERROR
3584   ;
3585     break;}
3586 case 186:
3587 #line 1929 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3588 {
3589     CurGV = 0;
3590   ;
3591     break;}
3592 case 187:
3593 #line 1932 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3594 {
3595     if (yyvsp[0].ConstVal == 0)
3596       GEN_ERROR("Global value initializer is not a constant");
3597     CurGV = ParseGlobalVariable(yyvsp[-4].StrVal, yyvsp[-3].Linkage, yyvsp[-2].Visibility, yyvsp[-1].BoolVal, yyvsp[0].ConstVal->getType(), yyvsp[0].ConstVal);
3598     CHECK_FOR_ERROR
3599   ;
3600     break;}
3601 case 188:
3602 #line 1937 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3603 {
3604     CurGV = 0;
3605   ;
3606     break;}
3607 case 189:
3608 #line 1940 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3609 {
3610     if (!UpRefs.empty())
3611       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
3612     CurGV = ParseGlobalVariable(yyvsp[-4].StrVal, yyvsp[-3].Linkage, yyvsp[-2].Visibility, yyvsp[-1].BoolVal, *yyvsp[0].TypeVal, 0);
3613     CHECK_FOR_ERROR
3614     delete yyvsp[0].TypeVal;
3615   ;
3616     break;}
3617 case 190:
3618 #line 1946 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3619 {
3620     CurGV = 0;
3621     CHECK_FOR_ERROR
3622   ;
3623     break;}
3624 case 191:
3625 #line 1950 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3626 {
3627     CHECK_FOR_ERROR
3628   ;
3629     break;}
3630 case 192:
3631 #line 1953 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3632 {
3633     CHECK_FOR_ERROR
3634   ;
3635     break;}
3636 case 193:
3637 #line 1959 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3638 {
3639   const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
3640   char *EndStr = UnEscapeLexed(yyvsp[0].StrVal, true);
3641   std::string NewAsm(yyvsp[0].StrVal, EndStr);
3642   free(yyvsp[0].StrVal);
3643
3644   if (AsmSoFar.empty())
3645     CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
3646   else
3647     CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
3648   CHECK_FOR_ERROR
3649 ;
3650     break;}
3651 case 194:
3652 #line 1972 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3653 {
3654     CurModule.CurrentModule->setTargetTriple(yyvsp[0].StrVal);
3655     free(yyvsp[0].StrVal);
3656   ;
3657     break;}
3658 case 195:
3659 #line 1976 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3660 {
3661     CurModule.CurrentModule->setDataLayout(yyvsp[0].StrVal);
3662     free(yyvsp[0].StrVal);
3663   ;
3664     break;}
3665 case 197:
3666 #line 1983 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3667 {
3668           CurModule.CurrentModule->addLibrary(yyvsp[0].StrVal);
3669           free(yyvsp[0].StrVal);
3670           CHECK_FOR_ERROR
3671         ;
3672     break;}
3673 case 198:
3674 #line 1988 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3675 {
3676           CurModule.CurrentModule->addLibrary(yyvsp[0].StrVal);
3677           free(yyvsp[0].StrVal);
3678           CHECK_FOR_ERROR
3679         ;
3680     break;}
3681 case 199:
3682 #line 1993 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3683 {
3684           CHECK_FOR_ERROR
3685         ;
3686     break;}
3687 case 200:
3688 #line 2002 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3689 {
3690     if (!UpRefs.empty())
3691       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
3692     if (*yyvsp[-2].TypeVal == Type::VoidTy)
3693       GEN_ERROR("void typed arguments are invalid");
3694     ArgListEntry E; E.Attrs = yyvsp[-1].ParamAttrs; E.Ty = yyvsp[-2].TypeVal; E.Name = yyvsp[0].StrVal;
3695     yyval.ArgList = yyvsp[-4].ArgList;
3696     yyvsp[-4].ArgList->push_back(E);
3697     CHECK_FOR_ERROR
3698   ;
3699     break;}
3700 case 201:
3701 #line 2012 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3702 {
3703     if (!UpRefs.empty())
3704       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
3705     if (*yyvsp[-2].TypeVal == Type::VoidTy)
3706       GEN_ERROR("void typed arguments are invalid");
3707     ArgListEntry E; E.Attrs = yyvsp[-1].ParamAttrs; E.Ty = yyvsp[-2].TypeVal; E.Name = yyvsp[0].StrVal;
3708     yyval.ArgList = new ArgListType;
3709     yyval.ArgList->push_back(E);
3710     CHECK_FOR_ERROR
3711   ;
3712     break;}
3713 case 202:
3714 #line 2023 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3715 {
3716     yyval.ArgList = yyvsp[0].ArgList;
3717     CHECK_FOR_ERROR
3718   ;
3719     break;}
3720 case 203:
3721 #line 2027 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3722 {
3723     yyval.ArgList = yyvsp[-2].ArgList;
3724     struct ArgListEntry E;
3725     E.Ty = new PATypeHolder(Type::VoidTy);
3726     E.Name = 0;
3727     E.Attrs = FunctionType::NoAttributeSet;
3728     yyval.ArgList->push_back(E);
3729     CHECK_FOR_ERROR
3730   ;
3731     break;}
3732 case 204:
3733 #line 2036 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3734 {
3735     yyval.ArgList = new ArgListType;
3736     struct ArgListEntry E;
3737     E.Ty = new PATypeHolder(Type::VoidTy);
3738     E.Name = 0;
3739     E.Attrs = FunctionType::NoAttributeSet;
3740     yyval.ArgList->push_back(E);
3741     CHECK_FOR_ERROR
3742   ;
3743     break;}
3744 case 205:
3745 #line 2045 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3746 {
3747     yyval.ArgList = 0;
3748     CHECK_FOR_ERROR
3749   ;
3750     break;}
3751 case 206:
3752 #line 2051 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3753 {
3754   UnEscapeLexed(yyvsp[-6].StrVal);
3755   std::string FunctionName(yyvsp[-6].StrVal);
3756   free(yyvsp[-6].StrVal);  // Free strdup'd memory!
3757
3758   // Check the function result for abstractness if this is a define. We should
3759   // have no abstract types at this point
3760   if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(yyvsp[-7].TypeVal))
3761     GEN_ERROR("Reference to abstract result: "+ yyvsp[-7].TypeVal->get()->getDescription());
3762
3763   std::vector<const Type*> ParamTypeList;
3764   std::vector<FunctionType::ParameterAttributes> ParamAttrs;
3765   ParamAttrs.push_back(yyvsp[-2].ParamAttrs);
3766   if (yyvsp[-4].ArgList) {   // If there are arguments...
3767     for (ArgListType::iterator I = yyvsp[-4].ArgList->begin(); I != yyvsp[-4].ArgList->end(); ++I) {
3768       const Type* Ty = I->Ty->get();
3769       if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(I->Ty))
3770         GEN_ERROR("Reference to abstract argument: " + Ty->getDescription());
3771       ParamTypeList.push_back(Ty);
3772       if (Ty != Type::VoidTy)
3773         ParamAttrs.push_back(I->Attrs);
3774     }
3775   }
3776
3777   bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
3778   if (isVarArg) ParamTypeList.pop_back();
3779
3780   FunctionType *FT = FunctionType::get(*yyvsp[-7].TypeVal, ParamTypeList, isVarArg,
3781                                        ParamAttrs);
3782   const PointerType *PFT = PointerType::get(FT);
3783   delete yyvsp[-7].TypeVal;
3784
3785   ValID ID;
3786   if (!FunctionName.empty()) {
3787     ID = ValID::createGlobalName((char*)FunctionName.c_str());
3788   } else {
3789     ID = ValID::createGlobalID(CurModule.Values[PFT].size());
3790   }
3791
3792   Function *Fn = 0;
3793   // See if this function was forward referenced.  If so, recycle the object.
3794   if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
3795     // Move the function to the end of the list, from whereever it was
3796     // previously inserted.
3797     Fn = cast<Function>(FWRef);
3798     CurModule.CurrentModule->getFunctionList().remove(Fn);
3799     CurModule.CurrentModule->getFunctionList().push_back(Fn);
3800   } else if (!FunctionName.empty() &&     // Merge with an earlier prototype?
3801              (Fn = CurModule.CurrentModule->getFunction(FunctionName))) {
3802     if (Fn->getFunctionType() != FT ) {
3803       // The existing function doesn't have the same type. This is an overload
3804       // error.
3805       GEN_ERROR("Overload of function '" + FunctionName + "' not permitted.");
3806     } else if (!CurFun.isDeclare && !Fn->isDeclaration()) {
3807       // Neither the existing or the current function is a declaration and they
3808       // have the same name and same type. Clearly this is a redefinition.
3809       GEN_ERROR("Redefinition of function '" + FunctionName + "'");
3810     } if (Fn->isDeclaration()) {
3811       // Make sure to strip off any argument names so we can't get conflicts.
3812       for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
3813            AI != AE; ++AI)
3814         AI->setName("");
3815     }
3816   } else  {  // Not already defined?
3817     Fn = new Function(FT, GlobalValue::ExternalLinkage, FunctionName,
3818                       CurModule.CurrentModule);
3819
3820     InsertValue(Fn, CurModule.Values);
3821   }
3822
3823   CurFun.FunctionStart(Fn);
3824
3825   if (CurFun.isDeclare) {
3826     // If we have declaration, always overwrite linkage.  This will allow us to
3827     // correctly handle cases, when pointer to function is passed as argument to
3828     // another function.
3829     Fn->setLinkage(CurFun.Linkage);
3830     Fn->setVisibility(CurFun.Visibility);
3831   }
3832   Fn->setCallingConv(yyvsp[-8].UIntVal);
3833   Fn->setAlignment(yyvsp[0].UIntVal);
3834   if (yyvsp[-1].StrVal) {
3835     Fn->setSection(yyvsp[-1].StrVal);
3836     free(yyvsp[-1].StrVal);
3837   }
3838
3839   // Add all of the arguments we parsed to the function...
3840   if (yyvsp[-4].ArgList) {                     // Is null if empty...
3841     if (isVarArg) {  // Nuke the last entry
3842       assert(yyvsp[-4].ArgList->back().Ty->get() == Type::VoidTy && yyvsp[-4].ArgList->back().Name == 0 &&
3843              "Not a varargs marker!");
3844       delete yyvsp[-4].ArgList->back().Ty;
3845       yyvsp[-4].ArgList->pop_back();  // Delete the last entry
3846     }
3847     Function::arg_iterator ArgIt = Fn->arg_begin();
3848     Function::arg_iterator ArgEnd = Fn->arg_end();
3849     unsigned Idx = 1;
3850     for (ArgListType::iterator I = yyvsp[-4].ArgList->begin();
3851          I != yyvsp[-4].ArgList->end() && ArgIt != ArgEnd; ++I, ++ArgIt) {
3852       delete I->Ty;                          // Delete the typeholder...
3853       setValueName(ArgIt, I->Name);          // Insert arg into symtab...
3854       CHECK_FOR_ERROR
3855       InsertValue(ArgIt);
3856       Idx++;
3857     }
3858
3859     delete yyvsp[-4].ArgList;                     // We're now done with the argument list
3860   }
3861   CHECK_FOR_ERROR
3862 ;
3863     break;}
3864 case 209:
3865 #line 2164 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3866 {
3867   yyval.FunctionVal = CurFun.CurrentFunction;
3868
3869   // Make sure that we keep track of the linkage type even if there was a
3870   // previous "declare".
3871   yyval.FunctionVal->setLinkage(yyvsp[-3].Linkage);
3872   yyval.FunctionVal->setVisibility(yyvsp[-2].Visibility);
3873 ;
3874     break;}
3875 case 212:
3876 #line 2175 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3877 {
3878   yyval.FunctionVal = yyvsp[-1].FunctionVal;
3879   CHECK_FOR_ERROR
3880 ;
3881     break;}
3882 case 213:
3883 #line 2180 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3884 {
3885     CurFun.CurrentFunction->setLinkage(yyvsp[-2].Linkage);
3886     CurFun.CurrentFunction->setVisibility(yyvsp[-1].Visibility);
3887     yyval.FunctionVal = CurFun.CurrentFunction;
3888     CurFun.FunctionDone();
3889     CHECK_FOR_ERROR
3890   ;
3891     break;}
3892 case 214:
3893 #line 2192 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3894 {
3895     yyval.BoolVal = false;
3896     CHECK_FOR_ERROR
3897   ;
3898     break;}
3899 case 215:
3900 #line 2196 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3901 {
3902     yyval.BoolVal = true;
3903     CHECK_FOR_ERROR
3904   ;
3905     break;}
3906 case 216:
3907 #line 2201 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3908 {    // A reference to a direct constant
3909     yyval.ValIDVal = ValID::create(yyvsp[0].SInt64Val);
3910     CHECK_FOR_ERROR
3911   ;
3912     break;}
3913 case 217:
3914 #line 2205 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3915 {
3916     yyval.ValIDVal = ValID::create(yyvsp[0].UInt64Val);
3917     CHECK_FOR_ERROR
3918   ;
3919     break;}
3920 case 218:
3921 #line 2209 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3922 {                     // Perhaps it's an FP constant?
3923     yyval.ValIDVal = ValID::create(yyvsp[0].FPVal);
3924     CHECK_FOR_ERROR
3925   ;
3926     break;}
3927 case 219:
3928 #line 2213 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3929 {
3930     yyval.ValIDVal = ValID::create(ConstantInt::getTrue());
3931     CHECK_FOR_ERROR
3932   ;
3933     break;}
3934 case 220:
3935 #line 2217 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3936 {
3937     yyval.ValIDVal = ValID::create(ConstantInt::getFalse());
3938     CHECK_FOR_ERROR
3939   ;
3940     break;}
3941 case 221:
3942 #line 2221 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3943 {
3944     yyval.ValIDVal = ValID::createNull();
3945     CHECK_FOR_ERROR
3946   ;
3947     break;}
3948 case 222:
3949 #line 2225 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3950 {
3951     yyval.ValIDVal = ValID::createUndef();
3952     CHECK_FOR_ERROR
3953   ;
3954     break;}
3955 case 223:
3956 #line 2229 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3957 {     // A vector zero constant.
3958     yyval.ValIDVal = ValID::createZeroInit();
3959     CHECK_FOR_ERROR
3960   ;
3961     break;}
3962 case 224:
3963 #line 2233 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3964 { // Nonempty unsized packed vector
3965     const Type *ETy = (*yyvsp[-1].ConstVector)[0]->getType();
3966     int NumElements = yyvsp[-1].ConstVector->size();
3967
3968     VectorType* pt = VectorType::get(ETy, NumElements);
3969     PATypeHolder* PTy = new PATypeHolder(
3970                                          HandleUpRefs(
3971                                             VectorType::get(
3972                                                 ETy,
3973                                                 NumElements)
3974                                             )
3975                                          );
3976
3977     // Verify all elements are correct type!
3978     for (unsigned i = 0; i < yyvsp[-1].ConstVector->size(); i++) {
3979       if (ETy != (*yyvsp[-1].ConstVector)[i]->getType())
3980         GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
3981                      ETy->getDescription() +"' as required!\nIt is of type '" +
3982                      (*yyvsp[-1].ConstVector)[i]->getType()->getDescription() + "'.");
3983     }
3984
3985     yyval.ValIDVal = ValID::create(ConstantVector::get(pt, *yyvsp[-1].ConstVector));
3986     delete PTy; delete yyvsp[-1].ConstVector;
3987     CHECK_FOR_ERROR
3988   ;
3989     break;}
3990 case 225:
3991 #line 2258 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3992 {
3993     yyval.ValIDVal = ValID::create(yyvsp[0].ConstVal);
3994     CHECK_FOR_ERROR
3995   ;
3996     break;}
3997 case 226:
3998 #line 2262 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3999 {
4000     char *End = UnEscapeLexed(yyvsp[-2].StrVal, true);
4001     std::string AsmStr = std::string(yyvsp[-2].StrVal, End);
4002     End = UnEscapeLexed(yyvsp[0].StrVal, true);
4003     std::string Constraints = std::string(yyvsp[0].StrVal, End);
4004     yyval.ValIDVal = ValID::createInlineAsm(AsmStr, Constraints, yyvsp[-3].BoolVal);
4005     free(yyvsp[-2].StrVal);
4006     free(yyvsp[0].StrVal);
4007     CHECK_FOR_ERROR
4008   ;
4009     break;}
4010 case 227:
4011 #line 2276 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4012 {  // Is it an integer reference...?
4013     yyval.ValIDVal = ValID::createLocalID(yyvsp[0].UIntVal);
4014     CHECK_FOR_ERROR
4015   ;
4016     break;}
4017 case 228:
4018 #line 2280 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4019 {
4020     yyval.ValIDVal = ValID::createGlobalID(yyvsp[0].UIntVal);
4021     CHECK_FOR_ERROR
4022   ;
4023     break;}
4024 case 229:
4025 #line 2284 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4026 {                   // Is it a named reference...?
4027     yyval.ValIDVal = ValID::createLocalName(yyvsp[0].StrVal);
4028     CHECK_FOR_ERROR
4029   ;
4030     break;}
4031 case 230:
4032 #line 2288 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4033 {                   // Is it a named reference...?
4034     yyval.ValIDVal = ValID::createGlobalName(yyvsp[0].StrVal);
4035     CHECK_FOR_ERROR
4036   ;
4037     break;}
4038 case 233:
4039 #line 2300 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4040 {
4041     if (!UpRefs.empty())
4042       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
4043     yyval.ValueVal = getVal(*yyvsp[-1].TypeVal, yyvsp[0].ValIDVal);
4044     delete yyvsp[-1].TypeVal;
4045     CHECK_FOR_ERROR
4046   ;
4047     break;}
4048 case 234:
4049 #line 2309 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4050 {
4051     yyval.FunctionVal = yyvsp[-1].FunctionVal;
4052     CHECK_FOR_ERROR
4053   ;
4054     break;}
4055 case 235:
4056 #line 2313 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4057 { // Do not allow functions with 0 basic blocks
4058     yyval.FunctionVal = yyvsp[-1].FunctionVal;
4059     CHECK_FOR_ERROR
4060   ;
4061     break;}
4062 case 236:
4063 #line 2322 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4064 {
4065     setValueName(yyvsp[0].TermInstVal, yyvsp[-1].StrVal);
4066     CHECK_FOR_ERROR
4067     InsertValue(yyvsp[0].TermInstVal);
4068     yyvsp[-2].BasicBlockVal->getInstList().push_back(yyvsp[0].TermInstVal);
4069     InsertValue(yyvsp[-2].BasicBlockVal);
4070     yyval.BasicBlockVal = yyvsp[-2].BasicBlockVal;
4071     CHECK_FOR_ERROR
4072   ;
4073     break;}
4074 case 237:
4075 #line 2332 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4076 {
4077     if (CastInst *CI1 = dyn_cast<CastInst>(yyvsp[0].InstVal))
4078       if (CastInst *CI2 = dyn_cast<CastInst>(CI1->getOperand(0)))
4079         if (CI2->getParent() == 0)
4080           yyvsp[-1].BasicBlockVal->getInstList().push_back(CI2);
4081     yyvsp[-1].BasicBlockVal->getInstList().push_back(yyvsp[0].InstVal);
4082     yyval.BasicBlockVal = yyvsp[-1].BasicBlockVal;
4083     CHECK_FOR_ERROR
4084   ;
4085     break;}
4086 case 238:
4087 #line 2341 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4088 {
4089     yyval.BasicBlockVal = getBBVal(ValID::createLocalID(CurFun.NextBBNum++), true);
4090     CHECK_FOR_ERROR
4091
4092     // Make sure to move the basic block to the correct location in the
4093     // function, instead of leaving it inserted wherever it was first
4094     // referenced.
4095     Function::BasicBlockListType &BBL =
4096       CurFun.CurrentFunction->getBasicBlockList();
4097     BBL.splice(BBL.end(), BBL, yyval.BasicBlockVal);
4098     CHECK_FOR_ERROR
4099   ;
4100     break;}
4101 case 239:
4102 #line 2353 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4103 {
4104     yyval.BasicBlockVal = getBBVal(ValID::createLocalName(yyvsp[0].StrVal), true);
4105     CHECK_FOR_ERROR
4106
4107     // Make sure to move the basic block to the correct location in the
4108     // function, instead of leaving it inserted wherever it was first
4109     // referenced.
4110     Function::BasicBlockListType &BBL =
4111       CurFun.CurrentFunction->getBasicBlockList();
4112     BBL.splice(BBL.end(), BBL, yyval.BasicBlockVal);
4113     CHECK_FOR_ERROR
4114   ;
4115     break;}
4116 case 240:
4117 #line 2366 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4118 {              // Return with a result...
4119     yyval.TermInstVal = new ReturnInst(yyvsp[0].ValueVal);
4120     CHECK_FOR_ERROR
4121   ;
4122     break;}
4123 case 241:
4124 #line 2370 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4125 {                                       // Return with no result...
4126     yyval.TermInstVal = new ReturnInst();
4127     CHECK_FOR_ERROR
4128   ;
4129     break;}
4130 case 242:
4131 #line 2374 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4132 {                         // Unconditional Branch...
4133     BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal);
4134     CHECK_FOR_ERROR
4135     yyval.TermInstVal = new BranchInst(tmpBB);
4136   ;
4137     break;}
4138 case 243:
4139 #line 2379 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4140 {
4141     assert(cast<IntegerType>(yyvsp[-7].PrimType)->getBitWidth() == 1 && "Not Bool?");
4142     BasicBlock* tmpBBA = getBBVal(yyvsp[-3].ValIDVal);
4143     CHECK_FOR_ERROR
4144     BasicBlock* tmpBBB = getBBVal(yyvsp[0].ValIDVal);
4145     CHECK_FOR_ERROR
4146     Value* tmpVal = getVal(Type::Int1Ty, yyvsp[-6].ValIDVal);
4147     CHECK_FOR_ERROR
4148     yyval.TermInstVal = new BranchInst(tmpBBA, tmpBBB, tmpVal);
4149   ;
4150     break;}
4151 case 244:
4152 #line 2389 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4153 {
4154     Value* tmpVal = getVal(yyvsp[-7].PrimType, yyvsp[-6].ValIDVal);
4155     CHECK_FOR_ERROR
4156     BasicBlock* tmpBB = getBBVal(yyvsp[-3].ValIDVal);
4157     CHECK_FOR_ERROR
4158     SwitchInst *S = new SwitchInst(tmpVal, tmpBB, yyvsp[-1].JumpTable->size());
4159     yyval.TermInstVal = S;
4160
4161     std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = yyvsp[-1].JumpTable->begin(),
4162       E = yyvsp[-1].JumpTable->end();
4163     for (; I != E; ++I) {
4164       if (ConstantInt *CI = dyn_cast<ConstantInt>(I->first))
4165           S->addCase(CI, I->second);
4166       else
4167         GEN_ERROR("Switch case is constant, but not a simple integer");
4168     }
4169     delete yyvsp[-1].JumpTable;
4170     CHECK_FOR_ERROR
4171   ;
4172     break;}
4173 case 245:
4174 #line 2408 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4175 {
4176     Value* tmpVal = getVal(yyvsp[-6].PrimType, yyvsp[-5].ValIDVal);
4177     CHECK_FOR_ERROR
4178     BasicBlock* tmpBB = getBBVal(yyvsp[-2].ValIDVal);
4179     CHECK_FOR_ERROR
4180     SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
4181     yyval.TermInstVal = S;
4182     CHECK_FOR_ERROR
4183   ;
4184     break;}
4185 case 246:
4186 #line 2418 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4187 {
4188
4189     // Handle the short syntax
4190     const PointerType *PFTy = 0;
4191     const FunctionType *Ty = 0;
4192     if (!(PFTy = dyn_cast<PointerType>(yyvsp[-11].TypeVal->get())) ||
4193         !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
4194       // Pull out the types of all of the arguments...
4195       std::vector<const Type*> ParamTypes;
4196       FunctionType::ParamAttrsList ParamAttrs;
4197       ParamAttrs.push_back(yyvsp[-6].ParamAttrs);
4198       for (ValueRefList::iterator I = yyvsp[-8].ValueRefList->begin(), E = yyvsp[-8].ValueRefList->end(); I != E; ++I) {
4199         const Type *Ty = I->Val->getType();
4200         if (Ty == Type::VoidTy)
4201           GEN_ERROR("Short call syntax cannot be used with varargs");
4202         ParamTypes.push_back(Ty);
4203         ParamAttrs.push_back(I->Attrs);
4204       }
4205
4206       Ty = FunctionType::get(yyvsp[-11].TypeVal->get(), ParamTypes, false, ParamAttrs);
4207       PFTy = PointerType::get(Ty);
4208     }
4209
4210     Value *V = getVal(PFTy, yyvsp[-10].ValIDVal);   // Get the function we're calling...
4211     CHECK_FOR_ERROR
4212     BasicBlock *Normal = getBBVal(yyvsp[-3].ValIDVal);
4213     CHECK_FOR_ERROR
4214     BasicBlock *Except = getBBVal(yyvsp[0].ValIDVal);
4215     CHECK_FOR_ERROR
4216
4217     // Check the arguments
4218     ValueList Args;
4219     if (yyvsp[-8].ValueRefList->empty()) {                                   // Has no arguments?
4220       // Make sure no arguments is a good thing!
4221       if (Ty->getNumParams() != 0)
4222         GEN_ERROR("No arguments passed to a function that "
4223                        "expects arguments");
4224     } else {                                     // Has arguments?
4225       // Loop through FunctionType's arguments and ensure they are specified
4226       // correctly!
4227       FunctionType::param_iterator I = Ty->param_begin();
4228       FunctionType::param_iterator E = Ty->param_end();
4229       ValueRefList::iterator ArgI = yyvsp[-8].ValueRefList->begin(), ArgE = yyvsp[-8].ValueRefList->end();
4230
4231       for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
4232         if (ArgI->Val->getType() != *I)
4233           GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" +
4234                          (*I)->getDescription() + "'");
4235         Args.push_back(ArgI->Val);
4236       }
4237
4238       if (Ty->isVarArg()) {
4239         if (I == E)
4240           for (; ArgI != ArgE; ++ArgI)
4241             Args.push_back(ArgI->Val); // push the remaining varargs
4242       } else if (I != E || ArgI != ArgE)
4243         GEN_ERROR("Invalid number of parameters detected");
4244     }
4245
4246     // Create the InvokeInst
4247     InvokeInst *II = new InvokeInst(V, Normal, Except, &Args[0], Args.size());
4248     II->setCallingConv(yyvsp[-12].UIntVal);
4249     yyval.TermInstVal = II;
4250     delete yyvsp[-8].ValueRefList;
4251     CHECK_FOR_ERROR
4252   ;
4253     break;}
4254 case 247:
4255 #line 2484 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4256 {
4257     yyval.TermInstVal = new UnwindInst();
4258     CHECK_FOR_ERROR
4259   ;
4260     break;}
4261 case 248:
4262 #line 2488 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4263 {
4264     yyval.TermInstVal = new UnreachableInst();
4265     CHECK_FOR_ERROR
4266   ;
4267     break;}
4268 case 249:
4269 #line 2495 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4270 {
4271     yyval.JumpTable = yyvsp[-5].JumpTable;
4272     Constant *V = cast<Constant>(getValNonImprovising(yyvsp[-4].PrimType, yyvsp[-3].ValIDVal));
4273     CHECK_FOR_ERROR
4274     if (V == 0)
4275       GEN_ERROR("May only switch on a constant pool value");
4276
4277     BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal);
4278     CHECK_FOR_ERROR
4279     yyval.JumpTable->push_back(std::make_pair(V, tmpBB));
4280   ;
4281     break;}
4282 case 250:
4283 #line 2506 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4284 {
4285     yyval.JumpTable = new std::vector<std::pair<Constant*, BasicBlock*> >();
4286     Constant *V = cast<Constant>(getValNonImprovising(yyvsp[-4].PrimType, yyvsp[-3].ValIDVal));
4287     CHECK_FOR_ERROR
4288
4289     if (V == 0)
4290       GEN_ERROR("May only switch on a constant pool value");
4291
4292     BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal);
4293     CHECK_FOR_ERROR
4294     yyval.JumpTable->push_back(std::make_pair(V, tmpBB));
4295   ;
4296     break;}
4297 case 251:
4298 #line 2519 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4299 {
4300     // Is this definition named?? if so, assign the name...
4301     setValueName(yyvsp[0].InstVal, yyvsp[-1].StrVal);
4302     CHECK_FOR_ERROR
4303     InsertValue(yyvsp[0].InstVal);
4304     yyval.InstVal = yyvsp[0].InstVal;
4305     CHECK_FOR_ERROR
4306   ;
4307     break;}
4308 case 252:
4309 #line 2529 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4310 {    // Used for PHI nodes
4311     if (!UpRefs.empty())
4312       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-5].TypeVal)->getDescription());
4313     yyval.PHIList = new std::list<std::pair<Value*, BasicBlock*> >();
4314     Value* tmpVal = getVal(*yyvsp[-5].TypeVal, yyvsp[-3].ValIDVal);
4315     CHECK_FOR_ERROR
4316     BasicBlock* tmpBB = getBBVal(yyvsp[-1].ValIDVal);
4317     CHECK_FOR_ERROR
4318     yyval.PHIList->push_back(std::make_pair(tmpVal, tmpBB));
4319     delete yyvsp[-5].TypeVal;
4320   ;
4321     break;}
4322 case 253:
4323 #line 2540 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4324 {
4325     yyval.PHIList = yyvsp[-6].PHIList;
4326     Value* tmpVal = getVal(yyvsp[-6].PHIList->front().first->getType(), yyvsp[-3].ValIDVal);
4327     CHECK_FOR_ERROR
4328     BasicBlock* tmpBB = getBBVal(yyvsp[-1].ValIDVal);
4329     CHECK_FOR_ERROR
4330     yyvsp[-6].PHIList->push_back(std::make_pair(tmpVal, tmpBB));
4331   ;
4332     break;}
4333 case 254:
4334 #line 2550 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4335 {
4336     if (!UpRefs.empty())
4337       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
4338     // Used for call and invoke instructions
4339     yyval.ValueRefList = new ValueRefList();
4340     ValueRefListEntry E; E.Attrs = yyvsp[0].ParamAttrs; E.Val = getVal(yyvsp[-2].TypeVal->get(), yyvsp[-1].ValIDVal);
4341     yyval.ValueRefList->push_back(E);
4342   ;
4343     break;}
4344 case 255:
4345 #line 2558 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4346 {
4347     if (!UpRefs.empty())
4348       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
4349     yyval.ValueRefList = yyvsp[-4].ValueRefList;
4350     ValueRefListEntry E; E.Attrs = yyvsp[0].ParamAttrs; E.Val = getVal(yyvsp[-2].TypeVal->get(), yyvsp[-1].ValIDVal);
4351     yyval.ValueRefList->push_back(E);
4352     CHECK_FOR_ERROR
4353   ;
4354     break;}
4355 case 256:
4356 #line 2566 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4357 { yyval.ValueRefList = new ValueRefList(); ;
4358     break;}
4359 case 257:
4360 #line 2569 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4361 { yyval.ValueList = new std::vector<Value*>(); ;
4362     break;}
4363 case 258:
4364 #line 2570 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4365 {
4366     yyval.ValueList = yyvsp[-2].ValueList;
4367     yyval.ValueList->push_back(yyvsp[0].ValueVal);
4368     CHECK_FOR_ERROR
4369   ;
4370     break;}
4371 case 259:
4372 #line 2577 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4373 {
4374     yyval.BoolVal = true;
4375     CHECK_FOR_ERROR
4376   ;
4377     break;}
4378 case 260:
4379 #line 2581 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4380 {
4381     yyval.BoolVal = false;
4382     CHECK_FOR_ERROR
4383   ;
4384     break;}
4385 case 261:
4386 #line 2586 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4387 {
4388     if (!UpRefs.empty())
4389       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
4390     if (!(*yyvsp[-3].TypeVal)->isInteger() && !(*yyvsp[-3].TypeVal)->isFloatingPoint() &&
4391         !isa<VectorType>((*yyvsp[-3].TypeVal).get()))
4392       GEN_ERROR(
4393         "Arithmetic operator requires integer, FP, or packed operands");
4394     if (isa<VectorType>((*yyvsp[-3].TypeVal).get()) &&
4395         (yyvsp[-4].BinaryOpVal == Instruction::URem ||
4396          yyvsp[-4].BinaryOpVal == Instruction::SRem ||
4397          yyvsp[-4].BinaryOpVal == Instruction::FRem))
4398       GEN_ERROR("Remainder not supported on vector types");
4399     Value* val1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal);
4400     CHECK_FOR_ERROR
4401     Value* val2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal);
4402     CHECK_FOR_ERROR
4403     yyval.InstVal = BinaryOperator::create(yyvsp[-4].BinaryOpVal, val1, val2);
4404     if (yyval.InstVal == 0)
4405       GEN_ERROR("binary operator returned null");
4406     delete yyvsp[-3].TypeVal;
4407   ;
4408     break;}
4409 case 262:
4410 #line 2607 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4411 {
4412     if (!UpRefs.empty())
4413       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
4414     if (!(*yyvsp[-3].TypeVal)->isInteger()) {
4415       if (Instruction::isShift(yyvsp[-4].BinaryOpVal) || !isa<VectorType>(yyvsp[-3].TypeVal->get()) ||
4416           !cast<VectorType>(yyvsp[-3].TypeVal->get())->getElementType()->isInteger())
4417         GEN_ERROR("Logical operator requires integral operands");
4418     }
4419     Value* tmpVal1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal);
4420     CHECK_FOR_ERROR
4421     Value* tmpVal2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal);
4422     CHECK_FOR_ERROR
4423     yyval.InstVal = BinaryOperator::create(yyvsp[-4].BinaryOpVal, tmpVal1, tmpVal2);
4424     if (yyval.InstVal == 0)
4425       GEN_ERROR("binary operator returned null");
4426     delete yyvsp[-3].TypeVal;
4427   ;
4428     break;}
4429 case 263:
4430 #line 2624 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4431 {
4432     if (!UpRefs.empty())
4433       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
4434     if (isa<VectorType>((*yyvsp[-3].TypeVal).get()))
4435       GEN_ERROR("Vector types not supported by icmp instruction");
4436     Value* tmpVal1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal);
4437     CHECK_FOR_ERROR
4438     Value* tmpVal2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal);
4439     CHECK_FOR_ERROR
4440     yyval.InstVal = CmpInst::create(yyvsp[-5].OtherOpVal, yyvsp[-4].IPredicate, tmpVal1, tmpVal2);
4441     if (yyval.InstVal == 0)
4442       GEN_ERROR("icmp operator returned null");
4443   ;
4444     break;}
4445 case 264:
4446 #line 2637 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4447 {
4448     if (!UpRefs.empty())
4449       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
4450     if (isa<VectorType>((*yyvsp[-3].TypeVal).get()))
4451       GEN_ERROR("Vector types not supported by fcmp instruction");
4452     Value* tmpVal1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal);
4453     CHECK_FOR_ERROR
4454     Value* tmpVal2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal);
4455     CHECK_FOR_ERROR
4456     yyval.InstVal = CmpInst::create(yyvsp[-5].OtherOpVal, yyvsp[-4].FPredicate, tmpVal1, tmpVal2);
4457     if (yyval.InstVal == 0)
4458       GEN_ERROR("fcmp operator returned null");
4459   ;
4460     break;}
4461 case 265:
4462 #line 2650 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4463 {
4464     if (!UpRefs.empty())
4465       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
4466     Value* Val = yyvsp[-2].ValueVal;
4467     const Type* DestTy = yyvsp[0].TypeVal->get();
4468     if (!CastInst::castIsValid(yyvsp[-3].CastOpVal, Val, DestTy))
4469       GEN_ERROR("invalid cast opcode for cast from '" +
4470                 Val->getType()->getDescription() + "' to '" +
4471                 DestTy->getDescription() + "'");
4472     yyval.InstVal = CastInst::create(yyvsp[-3].CastOpVal, Val, DestTy);
4473     delete yyvsp[0].TypeVal;
4474   ;
4475     break;}
4476 case 266:
4477 #line 2662 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4478 {
4479     if (yyvsp[-4].ValueVal->getType() != Type::Int1Ty)
4480       GEN_ERROR("select condition must be boolean");
4481     if (yyvsp[-2].ValueVal->getType() != yyvsp[0].ValueVal->getType())
4482       GEN_ERROR("select value types should match");
4483     yyval.InstVal = new SelectInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
4484     CHECK_FOR_ERROR
4485   ;
4486     break;}
4487 case 267:
4488 #line 2670 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4489 {
4490     if (!UpRefs.empty())
4491       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
4492     yyval.InstVal = new VAArgInst(yyvsp[-2].ValueVal, *yyvsp[0].TypeVal);
4493     delete yyvsp[0].TypeVal;
4494     CHECK_FOR_ERROR
4495   ;
4496     break;}
4497 case 268:
4498 #line 2677 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4499 {
4500     if (!ExtractElementInst::isValidOperands(yyvsp[-2].ValueVal, yyvsp[0].ValueVal))
4501       GEN_ERROR("Invalid extractelement operands");
4502     yyval.InstVal = new ExtractElementInst(yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
4503     CHECK_FOR_ERROR
4504   ;
4505     break;}
4506 case 269:
4507 #line 2683 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4508 {
4509     if (!InsertElementInst::isValidOperands(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal))
4510       GEN_ERROR("Invalid insertelement operands");
4511     yyval.InstVal = new InsertElementInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
4512     CHECK_FOR_ERROR
4513   ;
4514     break;}
4515 case 270:
4516 #line 2689 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4517 {
4518     if (!ShuffleVectorInst::isValidOperands(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal))
4519       GEN_ERROR("Invalid shufflevector operands");
4520     yyval.InstVal = new ShuffleVectorInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
4521     CHECK_FOR_ERROR
4522   ;
4523     break;}
4524 case 271:
4525 #line 2695 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4526 {
4527     const Type *Ty = yyvsp[0].PHIList->front().first->getType();
4528     if (!Ty->isFirstClassType())
4529       GEN_ERROR("PHI node operands must be of first class type");
4530     yyval.InstVal = new PHINode(Ty);
4531     ((PHINode*)yyval.InstVal)->reserveOperandSpace(yyvsp[0].PHIList->size());
4532     while (yyvsp[0].PHIList->begin() != yyvsp[0].PHIList->end()) {
4533       if (yyvsp[0].PHIList->front().first->getType() != Ty)
4534         GEN_ERROR("All elements of a PHI node must be of the same type");
4535       cast<PHINode>(yyval.InstVal)->addIncoming(yyvsp[0].PHIList->front().first, yyvsp[0].PHIList->front().second);
4536       yyvsp[0].PHIList->pop_front();
4537     }
4538     delete yyvsp[0].PHIList;  // Free the list...
4539     CHECK_FOR_ERROR
4540   ;
4541     break;}
4542 case 272:
4543 #line 2711 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4544 {
4545
4546     // Handle the short syntax
4547     const PointerType *PFTy = 0;
4548     const FunctionType *Ty = 0;
4549     if (!(PFTy = dyn_cast<PointerType>(yyvsp[-5].TypeVal->get())) ||
4550         !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
4551       // Pull out the types of all of the arguments...
4552       std::vector<const Type*> ParamTypes;
4553       FunctionType::ParamAttrsList ParamAttrs;
4554       ParamAttrs.push_back(yyvsp[0].ParamAttrs);
4555       for (ValueRefList::iterator I = yyvsp[-2].ValueRefList->begin(), E = yyvsp[-2].ValueRefList->end(); I != E; ++I) {
4556         const Type *Ty = I->Val->getType();
4557         if (Ty == Type::VoidTy)
4558           GEN_ERROR("Short call syntax cannot be used with varargs");
4559         ParamTypes.push_back(Ty);
4560         ParamAttrs.push_back(I->Attrs);
4561       }
4562
4563       Ty = FunctionType::get(yyvsp[-5].TypeVal->get(), ParamTypes, false, ParamAttrs);
4564       PFTy = PointerType::get(Ty);
4565     }
4566
4567     Value *V = getVal(PFTy, yyvsp[-4].ValIDVal);   // Get the function we're calling...
4568     CHECK_FOR_ERROR
4569
4570     // Check the arguments
4571     ValueList Args;
4572     if (yyvsp[-2].ValueRefList->empty()) {                                   // Has no arguments?
4573       // Make sure no arguments is a good thing!
4574       if (Ty->getNumParams() != 0)
4575         GEN_ERROR("No arguments passed to a function that "
4576                        "expects arguments");
4577     } else {                                     // Has arguments?
4578       // Loop through FunctionType's arguments and ensure they are specified
4579       // correctly!
4580       //
4581       FunctionType::param_iterator I = Ty->param_begin();
4582       FunctionType::param_iterator E = Ty->param_end();
4583       ValueRefList::iterator ArgI = yyvsp[-2].ValueRefList->begin(), ArgE = yyvsp[-2].ValueRefList->end();
4584
4585       for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
4586         if (ArgI->Val->getType() != *I)
4587           GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" +
4588                          (*I)->getDescription() + "'");
4589         Args.push_back(ArgI->Val);
4590       }
4591       if (Ty->isVarArg()) {
4592         if (I == E)
4593           for (; ArgI != ArgE; ++ArgI)
4594             Args.push_back(ArgI->Val); // push the remaining varargs
4595       } else if (I != E || ArgI != ArgE)
4596         GEN_ERROR("Invalid number of parameters detected");
4597     }
4598     // Create the call node
4599     CallInst *CI = new CallInst(V, &Args[0], Args.size());
4600     CI->setTailCall(yyvsp[-7].BoolVal);
4601     CI->setCallingConv(yyvsp[-6].UIntVal);
4602     yyval.InstVal = CI;
4603     delete yyvsp[-2].ValueRefList;
4604     delete yyvsp[-5].TypeVal;
4605     CHECK_FOR_ERROR
4606   ;
4607     break;}
4608 case 273:
4609 #line 2774 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4610 {
4611     yyval.InstVal = yyvsp[0].InstVal;
4612     CHECK_FOR_ERROR
4613   ;
4614     break;}
4615 case 274:
4616 #line 2779 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4617 {
4618     yyval.BoolVal = true;
4619     CHECK_FOR_ERROR
4620   ;
4621     break;}
4622 case 275:
4623 #line 2783 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4624 {
4625     yyval.BoolVal = false;
4626     CHECK_FOR_ERROR
4627   ;
4628     break;}
4629 case 276:
4630 #line 2790 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4631 {
4632     if (!UpRefs.empty())
4633       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
4634     yyval.InstVal = new MallocInst(*yyvsp[-1].TypeVal, 0, yyvsp[0].UIntVal);
4635     delete yyvsp[-1].TypeVal;
4636     CHECK_FOR_ERROR
4637   ;
4638     break;}
4639 case 277:
4640 #line 2797 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4641 {
4642     if (!UpRefs.empty())
4643       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription());
4644     Value* tmpVal = getVal(yyvsp[-2].PrimType, yyvsp[-1].ValIDVal);
4645     CHECK_FOR_ERROR
4646     yyval.InstVal = new MallocInst(*yyvsp[-4].TypeVal, tmpVal, yyvsp[0].UIntVal);
4647     delete yyvsp[-4].TypeVal;
4648   ;
4649     break;}
4650 case 278:
4651 #line 2805 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4652 {
4653     if (!UpRefs.empty())
4654       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
4655     yyval.InstVal = new AllocaInst(*yyvsp[-1].TypeVal, 0, yyvsp[0].UIntVal);
4656     delete yyvsp[-1].TypeVal;
4657     CHECK_FOR_ERROR
4658   ;
4659     break;}
4660 case 279:
4661 #line 2812 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4662 {
4663     if (!UpRefs.empty())
4664       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription());
4665     Value* tmpVal = getVal(yyvsp[-2].PrimType, yyvsp[-1].ValIDVal);
4666     CHECK_FOR_ERROR
4667     yyval.InstVal = new AllocaInst(*yyvsp[-4].TypeVal, tmpVal, yyvsp[0].UIntVal);
4668     delete yyvsp[-4].TypeVal;
4669   ;
4670     break;}
4671 case 280:
4672 #line 2820 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4673 {
4674     if (!isa<PointerType>(yyvsp[0].ValueVal->getType()))
4675       GEN_ERROR("Trying to free nonpointer type " +
4676                      yyvsp[0].ValueVal->getType()->getDescription() + "");
4677     yyval.InstVal = new FreeInst(yyvsp[0].ValueVal);
4678     CHECK_FOR_ERROR
4679   ;
4680     break;}
4681 case 281:
4682 #line 2828 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4683 {
4684     if (!UpRefs.empty())
4685       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
4686     if (!isa<PointerType>(yyvsp[-1].TypeVal->get()))
4687       GEN_ERROR("Can't load from nonpointer type: " +
4688                      (*yyvsp[-1].TypeVal)->getDescription());
4689     if (!cast<PointerType>(yyvsp[-1].TypeVal->get())->getElementType()->isFirstClassType())
4690       GEN_ERROR("Can't load from pointer of non-first-class type: " +
4691                      (*yyvsp[-1].TypeVal)->getDescription());
4692     Value* tmpVal = getVal(*yyvsp[-1].TypeVal, yyvsp[0].ValIDVal);
4693     CHECK_FOR_ERROR
4694     yyval.InstVal = new LoadInst(tmpVal, "", yyvsp[-3].BoolVal);
4695     delete yyvsp[-1].TypeVal;
4696   ;
4697     break;}
4698 case 282:
4699 #line 2842 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4700 {
4701     if (!UpRefs.empty())
4702       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
4703     const PointerType *PT = dyn_cast<PointerType>(yyvsp[-1].TypeVal->get());
4704     if (!PT)
4705       GEN_ERROR("Can't store to a nonpointer type: " +
4706                      (*yyvsp[-1].TypeVal)->getDescription());
4707     const Type *ElTy = PT->getElementType();
4708     if (ElTy != yyvsp[-3].ValueVal->getType())
4709       GEN_ERROR("Can't store '" + yyvsp[-3].ValueVal->getType()->getDescription() +
4710                      "' into space of type '" + ElTy->getDescription() + "'");
4711
4712     Value* tmpVal = getVal(*yyvsp[-1].TypeVal, yyvsp[0].ValIDVal);
4713     CHECK_FOR_ERROR
4714     yyval.InstVal = new StoreInst(yyvsp[-3].ValueVal, tmpVal, yyvsp[-5].BoolVal);
4715     delete yyvsp[-1].TypeVal;
4716   ;
4717     break;}
4718 case 283:
4719 #line 2859 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4720 {
4721     if (!UpRefs.empty())
4722       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
4723     if (!isa<PointerType>(yyvsp[-2].TypeVal->get()))
4724       GEN_ERROR("getelementptr insn requires pointer operand");
4725
4726     if (!GetElementPtrInst::getIndexedType(*yyvsp[-2].TypeVal, &(*yyvsp[0].ValueList)[0], yyvsp[0].ValueList->size(), true))
4727       GEN_ERROR("Invalid getelementptr indices for type '" +
4728                      (*yyvsp[-2].TypeVal)->getDescription()+ "'");
4729     Value* tmpVal = getVal(*yyvsp[-2].TypeVal, yyvsp[-1].ValIDVal);
4730     CHECK_FOR_ERROR
4731     yyval.InstVal = new GetElementPtrInst(tmpVal, &(*yyvsp[0].ValueList)[0], yyvsp[0].ValueList->size());
4732     delete yyvsp[-2].TypeVal;
4733     delete yyvsp[0].ValueList;
4734   ;
4735     break;}
4736 }
4737    /* the action file gets copied in in place of this dollarsign */
4738 #line 543 "/usr/share/bison.simple"
4739 \f
4740   yyvsp -= yylen;
4741   yyssp -= yylen;
4742 #ifdef YYLSP_NEEDED
4743   yylsp -= yylen;
4744 #endif
4745
4746 #if YYDEBUG != 0
4747   if (yydebug)
4748     {
4749       short *ssp1 = yyss - 1;
4750       fprintf (stderr, "state stack now");
4751       while (ssp1 != yyssp)
4752         fprintf (stderr, " %d", *++ssp1);
4753       fprintf (stderr, "\n");
4754     }
4755 #endif
4756
4757   *++yyvsp = yyval;
4758
4759 #ifdef YYLSP_NEEDED
4760   yylsp++;
4761   if (yylen == 0)
4762     {
4763       yylsp->first_line = yylloc.first_line;
4764       yylsp->first_column = yylloc.first_column;
4765       yylsp->last_line = (yylsp-1)->last_line;
4766       yylsp->last_column = (yylsp-1)->last_column;
4767       yylsp->text = 0;
4768     }
4769   else
4770     {
4771       yylsp->last_line = (yylsp+yylen-1)->last_line;
4772       yylsp->last_column = (yylsp+yylen-1)->last_column;
4773     }
4774 #endif
4775
4776   /* Now "shift" the result of the reduction.
4777      Determine what state that goes to,
4778      based on the state we popped back to
4779      and the rule number reduced by.  */
4780
4781   yyn = yyr1[yyn];
4782
4783   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
4784   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4785     yystate = yytable[yystate];
4786   else
4787     yystate = yydefgoto[yyn - YYNTBASE];
4788
4789   goto yynewstate;
4790
4791 yyerrlab:   /* here on detecting error */
4792
4793   if (! yyerrstatus)
4794     /* If not already recovering from an error, report this error.  */
4795     {
4796       ++yynerrs;
4797
4798 #ifdef YYERROR_VERBOSE
4799       yyn = yypact[yystate];
4800
4801       if (yyn > YYFLAG && yyn < YYLAST)
4802         {
4803           int size = 0;
4804           char *msg;
4805           int x, count;
4806
4807           count = 0;
4808           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
4809           for (x = (yyn < 0 ? -yyn : 0);
4810                x < (sizeof(yytname) / sizeof(char *)); x++)
4811             if (yycheck[x + yyn] == x)
4812               size += strlen(yytname[x]) + 15, count++;
4813           msg = (char *) malloc(size + 15);
4814           if (msg != 0)
4815             {
4816               strcpy(msg, "parse error");
4817
4818               if (count < 5)
4819                 {
4820                   count = 0;
4821                   for (x = (yyn < 0 ? -yyn : 0);
4822                        x < (sizeof(yytname) / sizeof(char *)); x++)
4823                     if (yycheck[x + yyn] == x)
4824                       {
4825                         strcat(msg, count == 0 ? ", expecting `" : " or `");
4826                         strcat(msg, yytname[x]);
4827                         strcat(msg, "'");
4828                         count++;
4829                       }
4830                 }
4831               yyerror(msg);
4832               free(msg);
4833             }
4834           else
4835             yyerror ("parse error; also virtual memory exceeded");
4836         }
4837       else
4838 #endif /* YYERROR_VERBOSE */
4839         yyerror("parse error");
4840     }
4841
4842   goto yyerrlab1;
4843 yyerrlab1:   /* here on error raised explicitly by an action */
4844
4845   if (yyerrstatus == 3)
4846     {
4847       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
4848
4849       /* return failure if at end of input */
4850       if (yychar == YYEOF)
4851         YYABORT;
4852
4853 #if YYDEBUG != 0
4854       if (yydebug)
4855         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
4856 #endif
4857
4858       yychar = YYEMPTY;
4859     }
4860
4861   /* Else will try to reuse lookahead token
4862      after shifting the error token.  */
4863
4864   yyerrstatus = 3;              /* Each real token shifted decrements this */
4865
4866   goto yyerrhandle;
4867
4868 yyerrdefault:  /* current state does not do anything special for the error token. */
4869
4870 #if 0
4871   /* This is wrong; only states that explicitly want error tokens
4872      should shift them.  */
4873   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
4874   if (yyn) goto yydefault;
4875 #endif
4876
4877 yyerrpop:   /* pop the current state because it cannot handle the error token */
4878
4879   if (yyssp == yyss) YYABORT;
4880   yyvsp--;
4881   yystate = *--yyssp;
4882 #ifdef YYLSP_NEEDED
4883   yylsp--;
4884 #endif
4885
4886 #if YYDEBUG != 0
4887   if (yydebug)
4888     {
4889       short *ssp1 = yyss - 1;
4890       fprintf (stderr, "Error: state stack now");
4891       while (ssp1 != yyssp)
4892         fprintf (stderr, " %d", *++ssp1);
4893       fprintf (stderr, "\n");
4894     }
4895 #endif
4896
4897 yyerrhandle:
4898
4899   yyn = yypact[yystate];
4900   if (yyn == YYFLAG)
4901     goto yyerrdefault;
4902
4903   yyn += YYTERROR;
4904   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
4905     goto yyerrdefault;
4906
4907   yyn = yytable[yyn];
4908   if (yyn < 0)
4909     {
4910       if (yyn == YYFLAG)
4911         goto yyerrpop;
4912       yyn = -yyn;
4913       goto yyreduce;
4914     }
4915   else if (yyn == 0)
4916     goto yyerrpop;
4917
4918   if (yyn == YYFINAL)
4919     YYACCEPT;
4920
4921 #if YYDEBUG != 0
4922   if (yydebug)
4923     fprintf(stderr, "Shifting error token, ");
4924 #endif
4925
4926   *++yyvsp = yylval;
4927 #ifdef YYLSP_NEEDED
4928   *++yylsp = yylloc;
4929 #endif
4930
4931   yystate = yyn;
4932   goto yynewstate;
4933
4934  yyacceptlab:
4935   /* YYACCEPT comes here.  */
4936   if (yyfree_stacks)
4937     {
4938       free (yyss);
4939       free (yyvs);
4940 #ifdef YYLSP_NEEDED
4941       free (yyls);
4942 #endif
4943     }
4944   return 0;
4945
4946  yyabortlab:
4947   /* YYABORT comes here.  */
4948   if (yyfree_stacks)
4949     {
4950       free (yyss);
4951       free (yyvs);
4952 #ifdef YYLSP_NEEDED
4953       free (yyls);
4954 #endif
4955     }
4956   return 1;
4957 }
4958 #line 2876 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4959
4960
4961 // common code from the two 'RunVMAsmParser' functions
4962 static Module* RunParser(Module * M) {
4963
4964   llvmAsmlineno = 1;      // Reset the current line number...
4965   CurModule.CurrentModule = M;
4966 #if YYDEBUG
4967   yydebug = Debug;
4968 #endif
4969
4970   // Check to make sure the parser succeeded
4971   if (yyparse()) {
4972     if (ParserResult)
4973       delete ParserResult;
4974     return 0;
4975   }
4976
4977   // Check to make sure that parsing produced a result
4978   if (!ParserResult)
4979     return 0;
4980
4981   // Reset ParserResult variable while saving its value for the result.
4982   Module *Result = ParserResult;
4983   ParserResult = 0;
4984
4985   return Result;
4986 }
4987
4988 void llvm::GenerateError(const std::string &message, int LineNo) {
4989   if (LineNo == -1) LineNo = llvmAsmlineno;
4990   // TODO: column number in exception
4991   if (TheParseError)
4992     TheParseError->setError(CurFilename, message, LineNo);
4993   TriggerError = 1;
4994 }
4995
4996 int yyerror(const char *ErrorMsg) {
4997   std::string where
4998     = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
4999                   + ":" + utostr((unsigned) llvmAsmlineno) + ": ";
5000   std::string errMsg = where + "error: " + std::string(ErrorMsg);
5001   if (yychar != YYEMPTY && yychar != 0)
5002     errMsg += " while reading token: '" + std::string(llvmAsmtext, llvmAsmleng)+
5003               "'";
5004   GenerateError(errMsg);
5005   return 0;
5006 }