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,  1578,  1597,  1609,
1280   1616,  1682,  1692,  1702,  1708,  1714,  1719,  1724,  1732,  1744,
1281   1766,  1774,  1780,  1791,  1796,  1801,  1807,  1813,  1822,  1826,
1282   1834,  1834,  1845,  1850,  1858,  1859,  1863,  1863,  1867,  1867,
1283   1870,  1873,  1885,  1909,  1920,  1927,  1930,  1935,  1938,  1944,
1284   1948,  1951,  1957,  1970,  1974,  1979,  1981,  1986,  1991,  2000,
1285   2010,  2021,  2025,  2034,  2043,  2048,  2160,  2160,  2162,  2171,
1286   2171,  2173,  2178,  2190,  2194,  2199,  2203,  2207,  2211,  2215,
1287   2219,  2223,  2227,  2231,  2256,  2260,  2274,  2278,  2282,  2286,
1288   2292,  2292,  2298,  2307,  2311,  2320,  2330,  2339,  2351,  2364,
1289   2368,  2372,  2377,  2387,  2406,  2415,  2482,  2486,  2493,  2504,
1290   2517,  2527,  2538,  2548,  2556,  2564,  2567,  2568,  2575,  2579,
1291   2584,  2605,  2622,  2635,  2648,  2660,  2668,  2675,  2681,  2687,
1292   2693,  2708,  2772,  2777,  2781,  2788,  2795,  2803,  2810,  2818,
1293   2826,  2840,  2857
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 {          // Packed array 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 PackedType 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(PackedType::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 PackedType *PTy = dyn_cast<PackedType>(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 = ConstantPacked::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 packed 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 packed 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("Packed Initializer to unpacked type '" + STy->getDescription() + "'");
3143
3144     yyval.ConstVal = ConstantStruct::get(STy, *yyvsp[-2].ConstVector);
3145     delete yyvsp[-5].TypeVal; delete yyvsp[-2].ConstVector;
3146     CHECK_FOR_ERROR
3147   ;
3148     break;}
3149 case 148:
3150 #line 1578 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3151 {
3152     if (!UpRefs.empty())
3153       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription());
3154     const StructType *STy = dyn_cast<StructType>(yyvsp[-4].TypeVal->get());
3155     if (STy == 0)
3156       GEN_ERROR("Cannot make struct constant with type: '" +
3157                      (*yyvsp[-4].TypeVal)->getDescription() + "'");
3158
3159     if (STy->getNumContainedTypes() != 0)
3160       GEN_ERROR("Illegal number of initializers for structure type");
3161
3162     // Check to ensure that Type is packed
3163     if (!STy->isPacked())
3164       GEN_ERROR("Packed Initializer to unpacked type '" + STy->getDescription() + "'");
3165
3166     yyval.ConstVal = ConstantStruct::get(STy, std::vector<Constant*>());
3167     delete yyvsp[-4].TypeVal;
3168     CHECK_FOR_ERROR
3169   ;
3170     break;}
3171 case 149:
3172 #line 1597 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3173 {
3174     if (!UpRefs.empty())
3175       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
3176     const PointerType *PTy = dyn_cast<PointerType>(yyvsp[-1].TypeVal->get());
3177     if (PTy == 0)
3178       GEN_ERROR("Cannot make null pointer constant with type: '" +
3179                      (*yyvsp[-1].TypeVal)->getDescription() + "'");
3180
3181     yyval.ConstVal = ConstantPointerNull::get(PTy);
3182     delete yyvsp[-1].TypeVal;
3183     CHECK_FOR_ERROR
3184   ;
3185     break;}
3186 case 150:
3187 #line 1609 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3188 {
3189     if (!UpRefs.empty())
3190       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
3191     yyval.ConstVal = UndefValue::get(yyvsp[-1].TypeVal->get());
3192     delete yyvsp[-1].TypeVal;
3193     CHECK_FOR_ERROR
3194   ;
3195     break;}
3196 case 151:
3197 #line 1616 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3198 {
3199     if (!UpRefs.empty())
3200       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
3201     const PointerType *Ty = dyn_cast<PointerType>(yyvsp[-1].TypeVal->get());
3202     if (Ty == 0)
3203       GEN_ERROR("Global const reference must be a pointer type");
3204
3205     // ConstExprs can exist in the body of a function, thus creating
3206     // GlobalValues whenever they refer to a variable.  Because we are in
3207     // the context of a function, getValNonImprovising will search the functions
3208     // symbol table instead of the module symbol table for the global symbol,
3209     // which throws things all off.  To get around this, we just tell
3210     // getValNonImprovising that we are at global scope here.
3211     //
3212     Function *SavedCurFn = CurFun.CurrentFunction;
3213     CurFun.CurrentFunction = 0;
3214
3215     Value *V = getValNonImprovising(Ty, yyvsp[0].ValIDVal);
3216     CHECK_FOR_ERROR
3217
3218     CurFun.CurrentFunction = SavedCurFn;
3219
3220     // If this is an initializer for a constant pointer, which is referencing a
3221     // (currently) undefined variable, create a stub now that shall be replaced
3222     // in the future with the right type of variable.
3223     //
3224     if (V == 0) {
3225       assert(isa<PointerType>(Ty) && "Globals may only be used as pointers!");
3226       const PointerType *PT = cast<PointerType>(Ty);
3227
3228       // First check to see if the forward references value is already created!
3229       PerModuleInfo::GlobalRefsType::iterator I =
3230         CurModule.GlobalRefs.find(std::make_pair(PT, yyvsp[0].ValIDVal));
3231
3232       if (I != CurModule.GlobalRefs.end()) {
3233         V = I->second;             // Placeholder already exists, use it...
3234         yyvsp[0].ValIDVal.destroy();
3235       } else {
3236         std::string Name;
3237         if (yyvsp[0].ValIDVal.Type == ValID::GlobalName)
3238           Name = yyvsp[0].ValIDVal.Name;
3239         else if (yyvsp[0].ValIDVal.Type != ValID::GlobalID)
3240           GEN_ERROR("Invalid reference to global");
3241
3242         // Create the forward referenced global.
3243         GlobalValue *GV;
3244         if (const FunctionType *FTy =
3245                  dyn_cast<FunctionType>(PT->getElementType())) {
3246           GV = new Function(FTy, GlobalValue::ExternalLinkage, Name,
3247                             CurModule.CurrentModule);
3248         } else {
3249           GV = new GlobalVariable(PT->getElementType(), false,
3250                                   GlobalValue::ExternalLinkage, 0,
3251                                   Name, CurModule.CurrentModule);
3252         }
3253
3254         // Keep track of the fact that we have a forward ref to recycle it
3255         CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, yyvsp[0].ValIDVal), GV));
3256         V = GV;
3257       }
3258     }
3259
3260     yyval.ConstVal = cast<GlobalValue>(V);
3261     delete yyvsp[-1].TypeVal;            // Free the type handle
3262     CHECK_FOR_ERROR
3263   ;
3264     break;}
3265 case 152:
3266 #line 1682 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3267 {
3268     if (!UpRefs.empty())
3269       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
3270     if (yyvsp[-1].TypeVal->get() != yyvsp[0].ConstVal->getType())
3271       GEN_ERROR("Mismatched types for constant expression: " +
3272         (*yyvsp[-1].TypeVal)->getDescription() + " and " + yyvsp[0].ConstVal->getType()->getDescription());
3273     yyval.ConstVal = yyvsp[0].ConstVal;
3274     delete yyvsp[-1].TypeVal;
3275     CHECK_FOR_ERROR
3276   ;
3277     break;}
3278 case 153:
3279 #line 1692 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3280 {
3281     if (!UpRefs.empty())
3282       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
3283     const Type *Ty = yyvsp[-1].TypeVal->get();
3284     if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty))
3285       GEN_ERROR("Cannot create a null initialized value of this type");
3286     yyval.ConstVal = Constant::getNullValue(Ty);
3287     delete yyvsp[-1].TypeVal;
3288     CHECK_FOR_ERROR
3289   ;
3290     break;}
3291 case 154:
3292 #line 1702 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3293 {      // integral constants
3294     if (!ConstantInt::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].SInt64Val))
3295       GEN_ERROR("Constant value doesn't fit in type");
3296     yyval.ConstVal = ConstantInt::get(yyvsp[-1].PrimType, yyvsp[0].SInt64Val);
3297     CHECK_FOR_ERROR
3298   ;
3299     break;}
3300 case 155:
3301 #line 1708 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3302 {      // integral constants
3303     if (!ConstantInt::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].UInt64Val))
3304       GEN_ERROR("Constant value doesn't fit in type");
3305     yyval.ConstVal = ConstantInt::get(yyvsp[-1].PrimType, yyvsp[0].UInt64Val);
3306     CHECK_FOR_ERROR
3307   ;
3308     break;}
3309 case 156:
3310 #line 1714 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3311 {                      // Boolean constants
3312     assert(cast<IntegerType>(yyvsp[-1].PrimType)->getBitWidth() == 1 && "Not Bool?");
3313     yyval.ConstVal = ConstantInt::getTrue();
3314     CHECK_FOR_ERROR
3315   ;
3316     break;}
3317 case 157:
3318 #line 1719 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3319 {                     // Boolean constants
3320     assert(cast<IntegerType>(yyvsp[-1].PrimType)->getBitWidth() == 1 && "Not Bool?");
3321     yyval.ConstVal = ConstantInt::getFalse();
3322     CHECK_FOR_ERROR
3323   ;
3324     break;}
3325 case 158:
3326 #line 1724 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3327 {                   // Float & Double constants
3328     if (!ConstantFP::isValueValidForType(yyvsp[-1].PrimType, yyvsp[0].FPVal))
3329       GEN_ERROR("Floating point constant invalid for type");
3330     yyval.ConstVal = ConstantFP::get(yyvsp[-1].PrimType, yyvsp[0].FPVal);
3331     CHECK_FOR_ERROR
3332   ;
3333     break;}
3334 case 159:
3335 #line 1732 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3336 {
3337     if (!UpRefs.empty())
3338       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
3339     Constant *Val = yyvsp[-3].ConstVal;
3340     const Type *DestTy = yyvsp[-1].TypeVal->get();
3341     if (!CastInst::castIsValid(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy))
3342       GEN_ERROR("invalid cast opcode for cast from '" +
3343                 Val->getType()->getDescription() + "' to '" +
3344                 DestTy->getDescription() + "'");
3345     yyval.ConstVal = ConstantExpr::getCast(yyvsp[-5].CastOpVal, yyvsp[-3].ConstVal, DestTy);
3346     delete yyvsp[-1].TypeVal;
3347   ;
3348     break;}
3349 case 160:
3350 #line 1744 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3351 {
3352     if (!isa<PointerType>(yyvsp[-2].ConstVal->getType()))
3353       GEN_ERROR("GetElementPtr requires a pointer operand");
3354
3355     const Type *IdxTy =
3356       GetElementPtrInst::getIndexedType(yyvsp[-2].ConstVal->getType(), &(*yyvsp[-1].ValueList)[0], yyvsp[-1].ValueList->size(),
3357                                         true);
3358     if (!IdxTy)
3359       GEN_ERROR("Index list invalid for constant getelementptr");
3360
3361     SmallVector<Constant*, 8> IdxVec;
3362     for (unsigned i = 0, e = yyvsp[-1].ValueList->size(); i != e; ++i)
3363       if (Constant *C = dyn_cast<Constant>((*yyvsp[-1].ValueList)[i]))
3364         IdxVec.push_back(C);
3365       else
3366         GEN_ERROR("Indices to constant getelementptr must be constants");
3367
3368     delete yyvsp[-1].ValueList;
3369
3370     yyval.ConstVal = ConstantExpr::getGetElementPtr(yyvsp[-2].ConstVal, &IdxVec[0], IdxVec.size());
3371     CHECK_FOR_ERROR
3372   ;
3373     break;}
3374 case 161:
3375 #line 1766 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3376 {
3377     if (yyvsp[-5].ConstVal->getType() != Type::Int1Ty)
3378       GEN_ERROR("Select condition must be of boolean type");
3379     if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
3380       GEN_ERROR("Select operand types must match");
3381     yyval.ConstVal = ConstantExpr::getSelect(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
3382     CHECK_FOR_ERROR
3383   ;
3384     break;}
3385 case 162:
3386 #line 1774 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3387 {
3388     if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
3389       GEN_ERROR("Binary operator types must match");
3390     CHECK_FOR_ERROR;
3391     yyval.ConstVal = ConstantExpr::get(yyvsp[-5].BinaryOpVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
3392   ;
3393     break;}
3394 case 163:
3395 #line 1780 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3396 {
3397     if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
3398       GEN_ERROR("Logical operator types must match");
3399     if (!yyvsp[-3].ConstVal->getType()->isInteger()) {
3400       if (Instruction::isShift(yyvsp[-5].BinaryOpVal) || !isa<PackedType>(yyvsp[-3].ConstVal->getType()) ||
3401           !cast<PackedType>(yyvsp[-3].ConstVal->getType())->getElementType()->isInteger())
3402         GEN_ERROR("Logical operator requires integral operands");
3403     }
3404     yyval.ConstVal = ConstantExpr::get(yyvsp[-5].BinaryOpVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
3405     CHECK_FOR_ERROR
3406   ;
3407     break;}
3408 case 164:
3409 #line 1791 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3410 {
3411     if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
3412       GEN_ERROR("icmp operand types must match");
3413     yyval.ConstVal = ConstantExpr::getICmp(yyvsp[-5].IPredicate, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
3414   ;
3415     break;}
3416 case 165:
3417 #line 1796 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3418 {
3419     if (yyvsp[-3].ConstVal->getType() != yyvsp[-1].ConstVal->getType())
3420       GEN_ERROR("fcmp operand types must match");
3421     yyval.ConstVal = ConstantExpr::getFCmp(yyvsp[-5].FPredicate, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
3422   ;
3423     break;}
3424 case 166:
3425 #line 1801 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3426 {
3427     if (!ExtractElementInst::isValidOperands(yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
3428       GEN_ERROR("Invalid extractelement operands");
3429     yyval.ConstVal = ConstantExpr::getExtractElement(yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
3430     CHECK_FOR_ERROR
3431   ;
3432     break;}
3433 case 167:
3434 #line 1807 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3435 {
3436     if (!InsertElementInst::isValidOperands(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
3437       GEN_ERROR("Invalid insertelement operands");
3438     yyval.ConstVal = ConstantExpr::getInsertElement(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
3439     CHECK_FOR_ERROR
3440   ;
3441     break;}
3442 case 168:
3443 #line 1813 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3444 {
3445     if (!ShuffleVectorInst::isValidOperands(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal))
3446       GEN_ERROR("Invalid shufflevector operands");
3447     yyval.ConstVal = ConstantExpr::getShuffleVector(yyvsp[-5].ConstVal, yyvsp[-3].ConstVal, yyvsp[-1].ConstVal);
3448     CHECK_FOR_ERROR
3449   ;
3450     break;}
3451 case 169:
3452 #line 1822 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3453 {
3454     (yyval.ConstVector = yyvsp[-2].ConstVector)->push_back(yyvsp[0].ConstVal);
3455     CHECK_FOR_ERROR
3456   ;
3457     break;}
3458 case 170:
3459 #line 1826 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3460 {
3461     yyval.ConstVector = new std::vector<Constant*>();
3462     yyval.ConstVector->push_back(yyvsp[0].ConstVal);
3463     CHECK_FOR_ERROR
3464   ;
3465     break;}
3466 case 171:
3467 #line 1834 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3468 { yyval.BoolVal = false; ;
3469     break;}
3470 case 172:
3471 #line 1834 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3472 { yyval.BoolVal = true; ;
3473     break;}
3474 case 173:
3475 #line 1845 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3476 {
3477     yyval.ModuleVal = ParserResult = CurModule.CurrentModule;
3478     CurModule.ModuleDone();
3479     CHECK_FOR_ERROR;
3480   ;
3481     break;}
3482 case 174:
3483 #line 1850 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3484 {
3485     yyval.ModuleVal = ParserResult = CurModule.CurrentModule;
3486     CurModule.ModuleDone();
3487     CHECK_FOR_ERROR;
3488   ;
3489     break;}
3490 case 177:
3491 #line 1863 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3492 { CurFun.isDeclare = false; ;
3493     break;}
3494 case 178:
3495 #line 1863 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3496 {
3497     CurFun.FunctionDone();
3498     CHECK_FOR_ERROR
3499   ;
3500     break;}
3501 case 179:
3502 #line 1867 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3503 { CurFun.isDeclare = true; ;
3504     break;}
3505 case 180:
3506 #line 1867 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3507 {
3508     CHECK_FOR_ERROR
3509   ;
3510     break;}
3511 case 181:
3512 #line 1870 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3513 {
3514     CHECK_FOR_ERROR
3515   ;
3516     break;}
3517 case 182:
3518 #line 1873 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3519 {
3520     // Emit an error if there are any unresolved types left.
3521     if (!CurModule.LateResolveTypes.empty()) {
3522       const ValID &DID = CurModule.LateResolveTypes.begin()->first;
3523       if (DID.Type == ValID::LocalName) {
3524         GEN_ERROR("Reference to an undefined type: '"+DID.getName() + "'");
3525       } else {
3526         GEN_ERROR("Reference to an undefined type: #" + itostr(DID.Num));
3527       }
3528     }
3529     CHECK_FOR_ERROR
3530   ;
3531     break;}
3532 case 183:
3533 #line 1885 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3534 {
3535     if (!UpRefs.empty())
3536       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
3537     // Eagerly resolve types.  This is not an optimization, this is a
3538     // requirement that is due to the fact that we could have this:
3539     //
3540     // %list = type { %list * }
3541     // %list = type { %list * }    ; repeated type decl
3542     //
3543     // If types are not resolved eagerly, then the two types will not be
3544     // determined to be the same type!
3545     //
3546     ResolveTypeTo(yyvsp[-2].StrVal, *yyvsp[0].TypeVal);
3547
3548     if (!setTypeName(*yyvsp[0].TypeVal, yyvsp[-2].StrVal) && !yyvsp[-2].StrVal) {
3549       CHECK_FOR_ERROR
3550       // If this is a named type that is not a redefinition, add it to the slot
3551       // table.
3552       CurModule.Types.push_back(*yyvsp[0].TypeVal);
3553     }
3554
3555     delete yyvsp[0].TypeVal;
3556     CHECK_FOR_ERROR
3557   ;
3558     break;}
3559 case 184:
3560 #line 1909 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3561 {
3562     ResolveTypeTo(yyvsp[-2].StrVal, yyvsp[0].PrimType);
3563
3564     if (!setTypeName(yyvsp[0].PrimType, yyvsp[-2].StrVal) && !yyvsp[-2].StrVal) {
3565       CHECK_FOR_ERROR
3566       // If this is a named type that is not a redefinition, add it to the slot
3567       // table.
3568       CurModule.Types.push_back(yyvsp[0].PrimType);
3569     }
3570     CHECK_FOR_ERROR
3571   ;
3572     break;}
3573 case 185:
3574 #line 1920 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3575 {
3576     /* "Externally Visible" Linkage */
3577     if (yyvsp[0].ConstVal == 0)
3578       GEN_ERROR("Global value initializer is not a constant");
3579     CurGV = ParseGlobalVariable(yyvsp[-3].StrVal, GlobalValue::ExternalLinkage,
3580                                 yyvsp[-2].Visibility, yyvsp[-1].BoolVal, yyvsp[0].ConstVal->getType(), yyvsp[0].ConstVal);
3581     CHECK_FOR_ERROR
3582   ;
3583     break;}
3584 case 186:
3585 #line 1927 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3586 {
3587     CurGV = 0;
3588   ;
3589     break;}
3590 case 187:
3591 #line 1930 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3592 {
3593     if (yyvsp[0].ConstVal == 0)
3594       GEN_ERROR("Global value initializer is not a constant");
3595     CurGV = ParseGlobalVariable(yyvsp[-4].StrVal, yyvsp[-3].Linkage, yyvsp[-2].Visibility, yyvsp[-1].BoolVal, yyvsp[0].ConstVal->getType(), yyvsp[0].ConstVal);
3596     CHECK_FOR_ERROR
3597   ;
3598     break;}
3599 case 188:
3600 #line 1935 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3601 {
3602     CurGV = 0;
3603   ;
3604     break;}
3605 case 189:
3606 #line 1938 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3607 {
3608     if (!UpRefs.empty())
3609       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
3610     CurGV = ParseGlobalVariable(yyvsp[-4].StrVal, yyvsp[-3].Linkage, yyvsp[-2].Visibility, yyvsp[-1].BoolVal, *yyvsp[0].TypeVal, 0);
3611     CHECK_FOR_ERROR
3612     delete yyvsp[0].TypeVal;
3613   ;
3614     break;}
3615 case 190:
3616 #line 1944 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3617 {
3618     CurGV = 0;
3619     CHECK_FOR_ERROR
3620   ;
3621     break;}
3622 case 191:
3623 #line 1948 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3624 {
3625     CHECK_FOR_ERROR
3626   ;
3627     break;}
3628 case 192:
3629 #line 1951 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3630 {
3631     CHECK_FOR_ERROR
3632   ;
3633     break;}
3634 case 193:
3635 #line 1957 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3636 {
3637   const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
3638   char *EndStr = UnEscapeLexed(yyvsp[0].StrVal, true);
3639   std::string NewAsm(yyvsp[0].StrVal, EndStr);
3640   free(yyvsp[0].StrVal);
3641
3642   if (AsmSoFar.empty())
3643     CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
3644   else
3645     CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
3646   CHECK_FOR_ERROR
3647 ;
3648     break;}
3649 case 194:
3650 #line 1970 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3651 {
3652     CurModule.CurrentModule->setTargetTriple(yyvsp[0].StrVal);
3653     free(yyvsp[0].StrVal);
3654   ;
3655     break;}
3656 case 195:
3657 #line 1974 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3658 {
3659     CurModule.CurrentModule->setDataLayout(yyvsp[0].StrVal);
3660     free(yyvsp[0].StrVal);
3661   ;
3662     break;}
3663 case 197:
3664 #line 1981 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3665 {
3666           CurModule.CurrentModule->addLibrary(yyvsp[0].StrVal);
3667           free(yyvsp[0].StrVal);
3668           CHECK_FOR_ERROR
3669         ;
3670     break;}
3671 case 198:
3672 #line 1986 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3673 {
3674           CurModule.CurrentModule->addLibrary(yyvsp[0].StrVal);
3675           free(yyvsp[0].StrVal);
3676           CHECK_FOR_ERROR
3677         ;
3678     break;}
3679 case 199:
3680 #line 1991 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3681 {
3682           CHECK_FOR_ERROR
3683         ;
3684     break;}
3685 case 200:
3686 #line 2000 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3687 {
3688     if (!UpRefs.empty())
3689       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
3690     if (*yyvsp[-2].TypeVal == Type::VoidTy)
3691       GEN_ERROR("void typed arguments are invalid");
3692     ArgListEntry E; E.Attrs = yyvsp[-1].ParamAttrs; E.Ty = yyvsp[-2].TypeVal; E.Name = yyvsp[0].StrVal;
3693     yyval.ArgList = yyvsp[-4].ArgList;
3694     yyvsp[-4].ArgList->push_back(E);
3695     CHECK_FOR_ERROR
3696   ;
3697     break;}
3698 case 201:
3699 #line 2010 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3700 {
3701     if (!UpRefs.empty())
3702       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
3703     if (*yyvsp[-2].TypeVal == Type::VoidTy)
3704       GEN_ERROR("void typed arguments are invalid");
3705     ArgListEntry E; E.Attrs = yyvsp[-1].ParamAttrs; E.Ty = yyvsp[-2].TypeVal; E.Name = yyvsp[0].StrVal;
3706     yyval.ArgList = new ArgListType;
3707     yyval.ArgList->push_back(E);
3708     CHECK_FOR_ERROR
3709   ;
3710     break;}
3711 case 202:
3712 #line 2021 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3713 {
3714     yyval.ArgList = yyvsp[0].ArgList;
3715     CHECK_FOR_ERROR
3716   ;
3717     break;}
3718 case 203:
3719 #line 2025 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3720 {
3721     yyval.ArgList = yyvsp[-2].ArgList;
3722     struct ArgListEntry E;
3723     E.Ty = new PATypeHolder(Type::VoidTy);
3724     E.Name = 0;
3725     E.Attrs = FunctionType::NoAttributeSet;
3726     yyval.ArgList->push_back(E);
3727     CHECK_FOR_ERROR
3728   ;
3729     break;}
3730 case 204:
3731 #line 2034 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3732 {
3733     yyval.ArgList = new ArgListType;
3734     struct ArgListEntry E;
3735     E.Ty = new PATypeHolder(Type::VoidTy);
3736     E.Name = 0;
3737     E.Attrs = FunctionType::NoAttributeSet;
3738     yyval.ArgList->push_back(E);
3739     CHECK_FOR_ERROR
3740   ;
3741     break;}
3742 case 205:
3743 #line 2043 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3744 {
3745     yyval.ArgList = 0;
3746     CHECK_FOR_ERROR
3747   ;
3748     break;}
3749 case 206:
3750 #line 2049 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3751 {
3752   UnEscapeLexed(yyvsp[-6].StrVal);
3753   std::string FunctionName(yyvsp[-6].StrVal);
3754   free(yyvsp[-6].StrVal);  // Free strdup'd memory!
3755
3756   // Check the function result for abstractness if this is a define. We should
3757   // have no abstract types at this point
3758   if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(yyvsp[-7].TypeVal))
3759     GEN_ERROR("Reference to abstract result: "+ yyvsp[-7].TypeVal->get()->getDescription());
3760
3761   std::vector<const Type*> ParamTypeList;
3762   std::vector<FunctionType::ParameterAttributes> ParamAttrs;
3763   ParamAttrs.push_back(yyvsp[-2].ParamAttrs);
3764   if (yyvsp[-4].ArgList) {   // If there are arguments...
3765     for (ArgListType::iterator I = yyvsp[-4].ArgList->begin(); I != yyvsp[-4].ArgList->end(); ++I) {
3766       const Type* Ty = I->Ty->get();
3767       if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(I->Ty))
3768         GEN_ERROR("Reference to abstract argument: " + Ty->getDescription());
3769       ParamTypeList.push_back(Ty);
3770       if (Ty != Type::VoidTy)
3771         ParamAttrs.push_back(I->Attrs);
3772     }
3773   }
3774
3775   bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
3776   if (isVarArg) ParamTypeList.pop_back();
3777
3778   FunctionType *FT = FunctionType::get(*yyvsp[-7].TypeVal, ParamTypeList, isVarArg,
3779                                        ParamAttrs);
3780   const PointerType *PFT = PointerType::get(FT);
3781   delete yyvsp[-7].TypeVal;
3782
3783   ValID ID;
3784   if (!FunctionName.empty()) {
3785     ID = ValID::createGlobalName((char*)FunctionName.c_str());
3786   } else {
3787     ID = ValID::createGlobalID(CurModule.Values[PFT].size());
3788   }
3789
3790   Function *Fn = 0;
3791   // See if this function was forward referenced.  If so, recycle the object.
3792   if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
3793     // Move the function to the end of the list, from whereever it was
3794     // previously inserted.
3795     Fn = cast<Function>(FWRef);
3796     CurModule.CurrentModule->getFunctionList().remove(Fn);
3797     CurModule.CurrentModule->getFunctionList().push_back(Fn);
3798   } else if (!FunctionName.empty() &&     // Merge with an earlier prototype?
3799              (Fn = CurModule.CurrentModule->getFunction(FunctionName))) {
3800     if (Fn->getFunctionType() != FT ) {
3801       // The existing function doesn't have the same type. This is an overload
3802       // error.
3803       GEN_ERROR("Overload of function '" + FunctionName + "' not permitted.");
3804     } else if (!CurFun.isDeclare && !Fn->isDeclaration()) {
3805       // Neither the existing or the current function is a declaration and they
3806       // have the same name and same type. Clearly this is a redefinition.
3807       GEN_ERROR("Redefinition of function '" + FunctionName + "'");
3808     } if (Fn->isDeclaration()) {
3809       // Make sure to strip off any argument names so we can't get conflicts.
3810       for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
3811            AI != AE; ++AI)
3812         AI->setName("");
3813     }
3814   } else  {  // Not already defined?
3815     Fn = new Function(FT, GlobalValue::ExternalLinkage, FunctionName,
3816                       CurModule.CurrentModule);
3817
3818     InsertValue(Fn, CurModule.Values);
3819   }
3820
3821   CurFun.FunctionStart(Fn);
3822
3823   if (CurFun.isDeclare) {
3824     // If we have declaration, always overwrite linkage.  This will allow us to
3825     // correctly handle cases, when pointer to function is passed as argument to
3826     // another function.
3827     Fn->setLinkage(CurFun.Linkage);
3828     Fn->setVisibility(CurFun.Visibility);
3829   }
3830   Fn->setCallingConv(yyvsp[-8].UIntVal);
3831   Fn->setAlignment(yyvsp[0].UIntVal);
3832   if (yyvsp[-1].StrVal) {
3833     Fn->setSection(yyvsp[-1].StrVal);
3834     free(yyvsp[-1].StrVal);
3835   }
3836
3837   // Add all of the arguments we parsed to the function...
3838   if (yyvsp[-4].ArgList) {                     // Is null if empty...
3839     if (isVarArg) {  // Nuke the last entry
3840       assert(yyvsp[-4].ArgList->back().Ty->get() == Type::VoidTy && yyvsp[-4].ArgList->back().Name == 0 &&
3841              "Not a varargs marker!");
3842       delete yyvsp[-4].ArgList->back().Ty;
3843       yyvsp[-4].ArgList->pop_back();  // Delete the last entry
3844     }
3845     Function::arg_iterator ArgIt = Fn->arg_begin();
3846     Function::arg_iterator ArgEnd = Fn->arg_end();
3847     unsigned Idx = 1;
3848     for (ArgListType::iterator I = yyvsp[-4].ArgList->begin();
3849          I != yyvsp[-4].ArgList->end() && ArgIt != ArgEnd; ++I, ++ArgIt) {
3850       delete I->Ty;                          // Delete the typeholder...
3851       setValueName(ArgIt, I->Name);          // Insert arg into symtab...
3852       CHECK_FOR_ERROR
3853       InsertValue(ArgIt);
3854       Idx++;
3855     }
3856
3857     delete yyvsp[-4].ArgList;                     // We're now done with the argument list
3858   }
3859   CHECK_FOR_ERROR
3860 ;
3861     break;}
3862 case 209:
3863 #line 2162 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3864 {
3865   yyval.FunctionVal = CurFun.CurrentFunction;
3866
3867   // Make sure that we keep track of the linkage type even if there was a
3868   // previous "declare".
3869   yyval.FunctionVal->setLinkage(yyvsp[-3].Linkage);
3870   yyval.FunctionVal->setVisibility(yyvsp[-2].Visibility);
3871 ;
3872     break;}
3873 case 212:
3874 #line 2173 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3875 {
3876   yyval.FunctionVal = yyvsp[-1].FunctionVal;
3877   CHECK_FOR_ERROR
3878 ;
3879     break;}
3880 case 213:
3881 #line 2178 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3882 {
3883     CurFun.CurrentFunction->setLinkage(yyvsp[-2].Linkage);
3884     CurFun.CurrentFunction->setVisibility(yyvsp[-1].Visibility);
3885     yyval.FunctionVal = CurFun.CurrentFunction;
3886     CurFun.FunctionDone();
3887     CHECK_FOR_ERROR
3888   ;
3889     break;}
3890 case 214:
3891 #line 2190 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3892 {
3893     yyval.BoolVal = false;
3894     CHECK_FOR_ERROR
3895   ;
3896     break;}
3897 case 215:
3898 #line 2194 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3899 {
3900     yyval.BoolVal = true;
3901     CHECK_FOR_ERROR
3902   ;
3903     break;}
3904 case 216:
3905 #line 2199 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3906 {    // A reference to a direct constant
3907     yyval.ValIDVal = ValID::create(yyvsp[0].SInt64Val);
3908     CHECK_FOR_ERROR
3909   ;
3910     break;}
3911 case 217:
3912 #line 2203 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3913 {
3914     yyval.ValIDVal = ValID::create(yyvsp[0].UInt64Val);
3915     CHECK_FOR_ERROR
3916   ;
3917     break;}
3918 case 218:
3919 #line 2207 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3920 {                     // Perhaps it's an FP constant?
3921     yyval.ValIDVal = ValID::create(yyvsp[0].FPVal);
3922     CHECK_FOR_ERROR
3923   ;
3924     break;}
3925 case 219:
3926 #line 2211 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3927 {
3928     yyval.ValIDVal = ValID::create(ConstantInt::getTrue());
3929     CHECK_FOR_ERROR
3930   ;
3931     break;}
3932 case 220:
3933 #line 2215 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3934 {
3935     yyval.ValIDVal = ValID::create(ConstantInt::getFalse());
3936     CHECK_FOR_ERROR
3937   ;
3938     break;}
3939 case 221:
3940 #line 2219 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3941 {
3942     yyval.ValIDVal = ValID::createNull();
3943     CHECK_FOR_ERROR
3944   ;
3945     break;}
3946 case 222:
3947 #line 2223 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3948 {
3949     yyval.ValIDVal = ValID::createUndef();
3950     CHECK_FOR_ERROR
3951   ;
3952     break;}
3953 case 223:
3954 #line 2227 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3955 {     // A vector zero constant.
3956     yyval.ValIDVal = ValID::createZeroInit();
3957     CHECK_FOR_ERROR
3958   ;
3959     break;}
3960 case 224:
3961 #line 2231 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3962 { // Nonempty unsized packed vector
3963     const Type *ETy = (*yyvsp[-1].ConstVector)[0]->getType();
3964     int NumElements = yyvsp[-1].ConstVector->size();
3965
3966     PackedType* pt = PackedType::get(ETy, NumElements);
3967     PATypeHolder* PTy = new PATypeHolder(
3968                                          HandleUpRefs(
3969                                             PackedType::get(
3970                                                 ETy,
3971                                                 NumElements)
3972                                             )
3973                                          );
3974
3975     // Verify all elements are correct type!
3976     for (unsigned i = 0; i < yyvsp[-1].ConstVector->size(); i++) {
3977       if (ETy != (*yyvsp[-1].ConstVector)[i]->getType())
3978         GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
3979                      ETy->getDescription() +"' as required!\nIt is of type '" +
3980                      (*yyvsp[-1].ConstVector)[i]->getType()->getDescription() + "'.");
3981     }
3982
3983     yyval.ValIDVal = ValID::create(ConstantPacked::get(pt, *yyvsp[-1].ConstVector));
3984     delete PTy; delete yyvsp[-1].ConstVector;
3985     CHECK_FOR_ERROR
3986   ;
3987     break;}
3988 case 225:
3989 #line 2256 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3990 {
3991     yyval.ValIDVal = ValID::create(yyvsp[0].ConstVal);
3992     CHECK_FOR_ERROR
3993   ;
3994     break;}
3995 case 226:
3996 #line 2260 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3997 {
3998     char *End = UnEscapeLexed(yyvsp[-2].StrVal, true);
3999     std::string AsmStr = std::string(yyvsp[-2].StrVal, End);
4000     End = UnEscapeLexed(yyvsp[0].StrVal, true);
4001     std::string Constraints = std::string(yyvsp[0].StrVal, End);
4002     yyval.ValIDVal = ValID::createInlineAsm(AsmStr, Constraints, yyvsp[-3].BoolVal);
4003     free(yyvsp[-2].StrVal);
4004     free(yyvsp[0].StrVal);
4005     CHECK_FOR_ERROR
4006   ;
4007     break;}
4008 case 227:
4009 #line 2274 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4010 {  // Is it an integer reference...?
4011     yyval.ValIDVal = ValID::createLocalID(yyvsp[0].UIntVal);
4012     CHECK_FOR_ERROR
4013   ;
4014     break;}
4015 case 228:
4016 #line 2278 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4017 {
4018     yyval.ValIDVal = ValID::createGlobalID(yyvsp[0].UIntVal);
4019     CHECK_FOR_ERROR
4020   ;
4021     break;}
4022 case 229:
4023 #line 2282 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4024 {                   // Is it a named reference...?
4025     yyval.ValIDVal = ValID::createLocalName(yyvsp[0].StrVal);
4026     CHECK_FOR_ERROR
4027   ;
4028     break;}
4029 case 230:
4030 #line 2286 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4031 {                   // Is it a named reference...?
4032     yyval.ValIDVal = ValID::createGlobalName(yyvsp[0].StrVal);
4033     CHECK_FOR_ERROR
4034   ;
4035     break;}
4036 case 233:
4037 #line 2298 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4038 {
4039     if (!UpRefs.empty())
4040       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
4041     yyval.ValueVal = getVal(*yyvsp[-1].TypeVal, yyvsp[0].ValIDVal);
4042     delete yyvsp[-1].TypeVal;
4043     CHECK_FOR_ERROR
4044   ;
4045     break;}
4046 case 234:
4047 #line 2307 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4048 {
4049     yyval.FunctionVal = yyvsp[-1].FunctionVal;
4050     CHECK_FOR_ERROR
4051   ;
4052     break;}
4053 case 235:
4054 #line 2311 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4055 { // Do not allow functions with 0 basic blocks
4056     yyval.FunctionVal = yyvsp[-1].FunctionVal;
4057     CHECK_FOR_ERROR
4058   ;
4059     break;}
4060 case 236:
4061 #line 2320 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4062 {
4063     setValueName(yyvsp[0].TermInstVal, yyvsp[-1].StrVal);
4064     CHECK_FOR_ERROR
4065     InsertValue(yyvsp[0].TermInstVal);
4066     yyvsp[-2].BasicBlockVal->getInstList().push_back(yyvsp[0].TermInstVal);
4067     InsertValue(yyvsp[-2].BasicBlockVal);
4068     yyval.BasicBlockVal = yyvsp[-2].BasicBlockVal;
4069     CHECK_FOR_ERROR
4070   ;
4071     break;}
4072 case 237:
4073 #line 2330 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4074 {
4075     if (CastInst *CI1 = dyn_cast<CastInst>(yyvsp[0].InstVal))
4076       if (CastInst *CI2 = dyn_cast<CastInst>(CI1->getOperand(0)))
4077         if (CI2->getParent() == 0)
4078           yyvsp[-1].BasicBlockVal->getInstList().push_back(CI2);
4079     yyvsp[-1].BasicBlockVal->getInstList().push_back(yyvsp[0].InstVal);
4080     yyval.BasicBlockVal = yyvsp[-1].BasicBlockVal;
4081     CHECK_FOR_ERROR
4082   ;
4083     break;}
4084 case 238:
4085 #line 2339 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4086 {
4087     yyval.BasicBlockVal = getBBVal(ValID::createLocalID(CurFun.NextBBNum++), true);
4088     CHECK_FOR_ERROR
4089
4090     // Make sure to move the basic block to the correct location in the
4091     // function, instead of leaving it inserted wherever it was first
4092     // referenced.
4093     Function::BasicBlockListType &BBL =
4094       CurFun.CurrentFunction->getBasicBlockList();
4095     BBL.splice(BBL.end(), BBL, yyval.BasicBlockVal);
4096     CHECK_FOR_ERROR
4097   ;
4098     break;}
4099 case 239:
4100 #line 2351 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4101 {
4102     yyval.BasicBlockVal = getBBVal(ValID::createLocalName(yyvsp[0].StrVal), true);
4103     CHECK_FOR_ERROR
4104
4105     // Make sure to move the basic block to the correct location in the
4106     // function, instead of leaving it inserted wherever it was first
4107     // referenced.
4108     Function::BasicBlockListType &BBL =
4109       CurFun.CurrentFunction->getBasicBlockList();
4110     BBL.splice(BBL.end(), BBL, yyval.BasicBlockVal);
4111     CHECK_FOR_ERROR
4112   ;
4113     break;}
4114 case 240:
4115 #line 2364 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4116 {              // Return with a result...
4117     yyval.TermInstVal = new ReturnInst(yyvsp[0].ValueVal);
4118     CHECK_FOR_ERROR
4119   ;
4120     break;}
4121 case 241:
4122 #line 2368 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4123 {                                       // Return with no result...
4124     yyval.TermInstVal = new ReturnInst();
4125     CHECK_FOR_ERROR
4126   ;
4127     break;}
4128 case 242:
4129 #line 2372 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4130 {                         // Unconditional Branch...
4131     BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal);
4132     CHECK_FOR_ERROR
4133     yyval.TermInstVal = new BranchInst(tmpBB);
4134   ;
4135     break;}
4136 case 243:
4137 #line 2377 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4138 {
4139     assert(cast<IntegerType>(yyvsp[-7].PrimType)->getBitWidth() == 1 && "Not Bool?");
4140     BasicBlock* tmpBBA = getBBVal(yyvsp[-3].ValIDVal);
4141     CHECK_FOR_ERROR
4142     BasicBlock* tmpBBB = getBBVal(yyvsp[0].ValIDVal);
4143     CHECK_FOR_ERROR
4144     Value* tmpVal = getVal(Type::Int1Ty, yyvsp[-6].ValIDVal);
4145     CHECK_FOR_ERROR
4146     yyval.TermInstVal = new BranchInst(tmpBBA, tmpBBB, tmpVal);
4147   ;
4148     break;}
4149 case 244:
4150 #line 2387 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4151 {
4152     Value* tmpVal = getVal(yyvsp[-7].PrimType, yyvsp[-6].ValIDVal);
4153     CHECK_FOR_ERROR
4154     BasicBlock* tmpBB = getBBVal(yyvsp[-3].ValIDVal);
4155     CHECK_FOR_ERROR
4156     SwitchInst *S = new SwitchInst(tmpVal, tmpBB, yyvsp[-1].JumpTable->size());
4157     yyval.TermInstVal = S;
4158
4159     std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = yyvsp[-1].JumpTable->begin(),
4160       E = yyvsp[-1].JumpTable->end();
4161     for (; I != E; ++I) {
4162       if (ConstantInt *CI = dyn_cast<ConstantInt>(I->first))
4163           S->addCase(CI, I->second);
4164       else
4165         GEN_ERROR("Switch case is constant, but not a simple integer");
4166     }
4167     delete yyvsp[-1].JumpTable;
4168     CHECK_FOR_ERROR
4169   ;
4170     break;}
4171 case 245:
4172 #line 2406 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4173 {
4174     Value* tmpVal = getVal(yyvsp[-6].PrimType, yyvsp[-5].ValIDVal);
4175     CHECK_FOR_ERROR
4176     BasicBlock* tmpBB = getBBVal(yyvsp[-2].ValIDVal);
4177     CHECK_FOR_ERROR
4178     SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
4179     yyval.TermInstVal = S;
4180     CHECK_FOR_ERROR
4181   ;
4182     break;}
4183 case 246:
4184 #line 2416 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4185 {
4186
4187     // Handle the short syntax
4188     const PointerType *PFTy = 0;
4189     const FunctionType *Ty = 0;
4190     if (!(PFTy = dyn_cast<PointerType>(yyvsp[-11].TypeVal->get())) ||
4191         !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
4192       // Pull out the types of all of the arguments...
4193       std::vector<const Type*> ParamTypes;
4194       FunctionType::ParamAttrsList ParamAttrs;
4195       ParamAttrs.push_back(yyvsp[-6].ParamAttrs);
4196       for (ValueRefList::iterator I = yyvsp[-8].ValueRefList->begin(), E = yyvsp[-8].ValueRefList->end(); I != E; ++I) {
4197         const Type *Ty = I->Val->getType();
4198         if (Ty == Type::VoidTy)
4199           GEN_ERROR("Short call syntax cannot be used with varargs");
4200         ParamTypes.push_back(Ty);
4201         ParamAttrs.push_back(I->Attrs);
4202       }
4203
4204       Ty = FunctionType::get(yyvsp[-11].TypeVal->get(), ParamTypes, false, ParamAttrs);
4205       PFTy = PointerType::get(Ty);
4206     }
4207
4208     Value *V = getVal(PFTy, yyvsp[-10].ValIDVal);   // Get the function we're calling...
4209     CHECK_FOR_ERROR
4210     BasicBlock *Normal = getBBVal(yyvsp[-3].ValIDVal);
4211     CHECK_FOR_ERROR
4212     BasicBlock *Except = getBBVal(yyvsp[0].ValIDVal);
4213     CHECK_FOR_ERROR
4214
4215     // Check the arguments
4216     ValueList Args;
4217     if (yyvsp[-8].ValueRefList->empty()) {                                   // Has no arguments?
4218       // Make sure no arguments is a good thing!
4219       if (Ty->getNumParams() != 0)
4220         GEN_ERROR("No arguments passed to a function that "
4221                        "expects arguments");
4222     } else {                                     // Has arguments?
4223       // Loop through FunctionType's arguments and ensure they are specified
4224       // correctly!
4225       FunctionType::param_iterator I = Ty->param_begin();
4226       FunctionType::param_iterator E = Ty->param_end();
4227       ValueRefList::iterator ArgI = yyvsp[-8].ValueRefList->begin(), ArgE = yyvsp[-8].ValueRefList->end();
4228
4229       for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
4230         if (ArgI->Val->getType() != *I)
4231           GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" +
4232                          (*I)->getDescription() + "'");
4233         Args.push_back(ArgI->Val);
4234       }
4235
4236       if (Ty->isVarArg()) {
4237         if (I == E)
4238           for (; ArgI != ArgE; ++ArgI)
4239             Args.push_back(ArgI->Val); // push the remaining varargs
4240       } else if (I != E || ArgI != ArgE)
4241         GEN_ERROR("Invalid number of parameters detected");
4242     }
4243
4244     // Create the InvokeInst
4245     InvokeInst *II = new InvokeInst(V, Normal, Except, &Args[0], Args.size());
4246     II->setCallingConv(yyvsp[-12].UIntVal);
4247     yyval.TermInstVal = II;
4248     delete yyvsp[-8].ValueRefList;
4249     CHECK_FOR_ERROR
4250   ;
4251     break;}
4252 case 247:
4253 #line 2482 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4254 {
4255     yyval.TermInstVal = new UnwindInst();
4256     CHECK_FOR_ERROR
4257   ;
4258     break;}
4259 case 248:
4260 #line 2486 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4261 {
4262     yyval.TermInstVal = new UnreachableInst();
4263     CHECK_FOR_ERROR
4264   ;
4265     break;}
4266 case 249:
4267 #line 2493 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4268 {
4269     yyval.JumpTable = yyvsp[-5].JumpTable;
4270     Constant *V = cast<Constant>(getValNonImprovising(yyvsp[-4].PrimType, yyvsp[-3].ValIDVal));
4271     CHECK_FOR_ERROR
4272     if (V == 0)
4273       GEN_ERROR("May only switch on a constant pool value");
4274
4275     BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal);
4276     CHECK_FOR_ERROR
4277     yyval.JumpTable->push_back(std::make_pair(V, tmpBB));
4278   ;
4279     break;}
4280 case 250:
4281 #line 2504 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4282 {
4283     yyval.JumpTable = new std::vector<std::pair<Constant*, BasicBlock*> >();
4284     Constant *V = cast<Constant>(getValNonImprovising(yyvsp[-4].PrimType, yyvsp[-3].ValIDVal));
4285     CHECK_FOR_ERROR
4286
4287     if (V == 0)
4288       GEN_ERROR("May only switch on a constant pool value");
4289
4290     BasicBlock* tmpBB = getBBVal(yyvsp[0].ValIDVal);
4291     CHECK_FOR_ERROR
4292     yyval.JumpTable->push_back(std::make_pair(V, tmpBB));
4293   ;
4294     break;}
4295 case 251:
4296 #line 2517 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4297 {
4298     // Is this definition named?? if so, assign the name...
4299     setValueName(yyvsp[0].InstVal, yyvsp[-1].StrVal);
4300     CHECK_FOR_ERROR
4301     InsertValue(yyvsp[0].InstVal);
4302     yyval.InstVal = yyvsp[0].InstVal;
4303     CHECK_FOR_ERROR
4304   ;
4305     break;}
4306 case 252:
4307 #line 2527 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4308 {    // Used for PHI nodes
4309     if (!UpRefs.empty())
4310       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-5].TypeVal)->getDescription());
4311     yyval.PHIList = new std::list<std::pair<Value*, BasicBlock*> >();
4312     Value* tmpVal = getVal(*yyvsp[-5].TypeVal, yyvsp[-3].ValIDVal);
4313     CHECK_FOR_ERROR
4314     BasicBlock* tmpBB = getBBVal(yyvsp[-1].ValIDVal);
4315     CHECK_FOR_ERROR
4316     yyval.PHIList->push_back(std::make_pair(tmpVal, tmpBB));
4317     delete yyvsp[-5].TypeVal;
4318   ;
4319     break;}
4320 case 253:
4321 #line 2538 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4322 {
4323     yyval.PHIList = yyvsp[-6].PHIList;
4324     Value* tmpVal = getVal(yyvsp[-6].PHIList->front().first->getType(), yyvsp[-3].ValIDVal);
4325     CHECK_FOR_ERROR
4326     BasicBlock* tmpBB = getBBVal(yyvsp[-1].ValIDVal);
4327     CHECK_FOR_ERROR
4328     yyvsp[-6].PHIList->push_back(std::make_pair(tmpVal, tmpBB));
4329   ;
4330     break;}
4331 case 254:
4332 #line 2548 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4333 {
4334     if (!UpRefs.empty())
4335       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
4336     // Used for call and invoke instructions
4337     yyval.ValueRefList = new ValueRefList();
4338     ValueRefListEntry E; E.Attrs = yyvsp[0].ParamAttrs; E.Val = getVal(yyvsp[-2].TypeVal->get(), yyvsp[-1].ValIDVal);
4339     yyval.ValueRefList->push_back(E);
4340   ;
4341     break;}
4342 case 255:
4343 #line 2556 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4344 {
4345     if (!UpRefs.empty())
4346       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
4347     yyval.ValueRefList = yyvsp[-4].ValueRefList;
4348     ValueRefListEntry E; E.Attrs = yyvsp[0].ParamAttrs; E.Val = getVal(yyvsp[-2].TypeVal->get(), yyvsp[-1].ValIDVal);
4349     yyval.ValueRefList->push_back(E);
4350     CHECK_FOR_ERROR
4351   ;
4352     break;}
4353 case 256:
4354 #line 2564 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4355 { yyval.ValueRefList = new ValueRefList(); ;
4356     break;}
4357 case 257:
4358 #line 2567 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4359 { yyval.ValueList = new std::vector<Value*>(); ;
4360     break;}
4361 case 258:
4362 #line 2568 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4363 {
4364     yyval.ValueList = yyvsp[-2].ValueList;
4365     yyval.ValueList->push_back(yyvsp[0].ValueVal);
4366     CHECK_FOR_ERROR
4367   ;
4368     break;}
4369 case 259:
4370 #line 2575 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4371 {
4372     yyval.BoolVal = true;
4373     CHECK_FOR_ERROR
4374   ;
4375     break;}
4376 case 260:
4377 #line 2579 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4378 {
4379     yyval.BoolVal = false;
4380     CHECK_FOR_ERROR
4381   ;
4382     break;}
4383 case 261:
4384 #line 2584 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4385 {
4386     if (!UpRefs.empty())
4387       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
4388     if (!(*yyvsp[-3].TypeVal)->isInteger() && !(*yyvsp[-3].TypeVal)->isFloatingPoint() &&
4389         !isa<PackedType>((*yyvsp[-3].TypeVal).get()))
4390       GEN_ERROR(
4391         "Arithmetic operator requires integer, FP, or packed operands");
4392     if (isa<PackedType>((*yyvsp[-3].TypeVal).get()) &&
4393         (yyvsp[-4].BinaryOpVal == Instruction::URem ||
4394          yyvsp[-4].BinaryOpVal == Instruction::SRem ||
4395          yyvsp[-4].BinaryOpVal == Instruction::FRem))
4396       GEN_ERROR("Remainder not supported on packed types");
4397     Value* val1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal);
4398     CHECK_FOR_ERROR
4399     Value* val2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal);
4400     CHECK_FOR_ERROR
4401     yyval.InstVal = BinaryOperator::create(yyvsp[-4].BinaryOpVal, val1, val2);
4402     if (yyval.InstVal == 0)
4403       GEN_ERROR("binary operator returned null");
4404     delete yyvsp[-3].TypeVal;
4405   ;
4406     break;}
4407 case 262:
4408 #line 2605 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4409 {
4410     if (!UpRefs.empty())
4411       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
4412     if (!(*yyvsp[-3].TypeVal)->isInteger()) {
4413       if (Instruction::isShift(yyvsp[-4].BinaryOpVal) || !isa<PackedType>(yyvsp[-3].TypeVal->get()) ||
4414           !cast<PackedType>(yyvsp[-3].TypeVal->get())->getElementType()->isInteger())
4415         GEN_ERROR("Logical operator requires integral operands");
4416     }
4417     Value* tmpVal1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal);
4418     CHECK_FOR_ERROR
4419     Value* tmpVal2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal);
4420     CHECK_FOR_ERROR
4421     yyval.InstVal = BinaryOperator::create(yyvsp[-4].BinaryOpVal, tmpVal1, tmpVal2);
4422     if (yyval.InstVal == 0)
4423       GEN_ERROR("binary operator returned null");
4424     delete yyvsp[-3].TypeVal;
4425   ;
4426     break;}
4427 case 263:
4428 #line 2622 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4429 {
4430     if (!UpRefs.empty())
4431       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
4432     if (isa<PackedType>((*yyvsp[-3].TypeVal).get()))
4433       GEN_ERROR("Packed types not supported by icmp instruction");
4434     Value* tmpVal1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal);
4435     CHECK_FOR_ERROR
4436     Value* tmpVal2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal);
4437     CHECK_FOR_ERROR
4438     yyval.InstVal = CmpInst::create(yyvsp[-5].OtherOpVal, yyvsp[-4].IPredicate, tmpVal1, tmpVal2);
4439     if (yyval.InstVal == 0)
4440       GEN_ERROR("icmp operator returned null");
4441   ;
4442     break;}
4443 case 264:
4444 #line 2635 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4445 {
4446     if (!UpRefs.empty())
4447       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-3].TypeVal)->getDescription());
4448     if (isa<PackedType>((*yyvsp[-3].TypeVal).get()))
4449       GEN_ERROR("Packed types not supported by fcmp instruction");
4450     Value* tmpVal1 = getVal(*yyvsp[-3].TypeVal, yyvsp[-2].ValIDVal);
4451     CHECK_FOR_ERROR
4452     Value* tmpVal2 = getVal(*yyvsp[-3].TypeVal, yyvsp[0].ValIDVal);
4453     CHECK_FOR_ERROR
4454     yyval.InstVal = CmpInst::create(yyvsp[-5].OtherOpVal, yyvsp[-4].FPredicate, tmpVal1, tmpVal2);
4455     if (yyval.InstVal == 0)
4456       GEN_ERROR("fcmp operator returned null");
4457   ;
4458     break;}
4459 case 265:
4460 #line 2648 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4461 {
4462     if (!UpRefs.empty())
4463       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
4464     Value* Val = yyvsp[-2].ValueVal;
4465     const Type* DestTy = yyvsp[0].TypeVal->get();
4466     if (!CastInst::castIsValid(yyvsp[-3].CastOpVal, Val, DestTy))
4467       GEN_ERROR("invalid cast opcode for cast from '" +
4468                 Val->getType()->getDescription() + "' to '" +
4469                 DestTy->getDescription() + "'");
4470     yyval.InstVal = CastInst::create(yyvsp[-3].CastOpVal, Val, DestTy);
4471     delete yyvsp[0].TypeVal;
4472   ;
4473     break;}
4474 case 266:
4475 #line 2660 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4476 {
4477     if (yyvsp[-4].ValueVal->getType() != Type::Int1Ty)
4478       GEN_ERROR("select condition must be boolean");
4479     if (yyvsp[-2].ValueVal->getType() != yyvsp[0].ValueVal->getType())
4480       GEN_ERROR("select value types should match");
4481     yyval.InstVal = new SelectInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
4482     CHECK_FOR_ERROR
4483   ;
4484     break;}
4485 case 267:
4486 #line 2668 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4487 {
4488     if (!UpRefs.empty())
4489       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[0].TypeVal)->getDescription());
4490     yyval.InstVal = new VAArgInst(yyvsp[-2].ValueVal, *yyvsp[0].TypeVal);
4491     delete yyvsp[0].TypeVal;
4492     CHECK_FOR_ERROR
4493   ;
4494     break;}
4495 case 268:
4496 #line 2675 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4497 {
4498     if (!ExtractElementInst::isValidOperands(yyvsp[-2].ValueVal, yyvsp[0].ValueVal))
4499       GEN_ERROR("Invalid extractelement operands");
4500     yyval.InstVal = new ExtractElementInst(yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
4501     CHECK_FOR_ERROR
4502   ;
4503     break;}
4504 case 269:
4505 #line 2681 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4506 {
4507     if (!InsertElementInst::isValidOperands(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal))
4508       GEN_ERROR("Invalid insertelement operands");
4509     yyval.InstVal = new InsertElementInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
4510     CHECK_FOR_ERROR
4511   ;
4512     break;}
4513 case 270:
4514 #line 2687 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4515 {
4516     if (!ShuffleVectorInst::isValidOperands(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal))
4517       GEN_ERROR("Invalid shufflevector operands");
4518     yyval.InstVal = new ShuffleVectorInst(yyvsp[-4].ValueVal, yyvsp[-2].ValueVal, yyvsp[0].ValueVal);
4519     CHECK_FOR_ERROR
4520   ;
4521     break;}
4522 case 271:
4523 #line 2693 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4524 {
4525     const Type *Ty = yyvsp[0].PHIList->front().first->getType();
4526     if (!Ty->isFirstClassType())
4527       GEN_ERROR("PHI node operands must be of first class type");
4528     yyval.InstVal = new PHINode(Ty);
4529     ((PHINode*)yyval.InstVal)->reserveOperandSpace(yyvsp[0].PHIList->size());
4530     while (yyvsp[0].PHIList->begin() != yyvsp[0].PHIList->end()) {
4531       if (yyvsp[0].PHIList->front().first->getType() != Ty)
4532         GEN_ERROR("All elements of a PHI node must be of the same type");
4533       cast<PHINode>(yyval.InstVal)->addIncoming(yyvsp[0].PHIList->front().first, yyvsp[0].PHIList->front().second);
4534       yyvsp[0].PHIList->pop_front();
4535     }
4536     delete yyvsp[0].PHIList;  // Free the list...
4537     CHECK_FOR_ERROR
4538   ;
4539     break;}
4540 case 272:
4541 #line 2709 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4542 {
4543
4544     // Handle the short syntax
4545     const PointerType *PFTy = 0;
4546     const FunctionType *Ty = 0;
4547     if (!(PFTy = dyn_cast<PointerType>(yyvsp[-5].TypeVal->get())) ||
4548         !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
4549       // Pull out the types of all of the arguments...
4550       std::vector<const Type*> ParamTypes;
4551       FunctionType::ParamAttrsList ParamAttrs;
4552       ParamAttrs.push_back(yyvsp[0].ParamAttrs);
4553       for (ValueRefList::iterator I = yyvsp[-2].ValueRefList->begin(), E = yyvsp[-2].ValueRefList->end(); I != E; ++I) {
4554         const Type *Ty = I->Val->getType();
4555         if (Ty == Type::VoidTy)
4556           GEN_ERROR("Short call syntax cannot be used with varargs");
4557         ParamTypes.push_back(Ty);
4558         ParamAttrs.push_back(I->Attrs);
4559       }
4560
4561       Ty = FunctionType::get(yyvsp[-5].TypeVal->get(), ParamTypes, false, ParamAttrs);
4562       PFTy = PointerType::get(Ty);
4563     }
4564
4565     Value *V = getVal(PFTy, yyvsp[-4].ValIDVal);   // Get the function we're calling...
4566     CHECK_FOR_ERROR
4567
4568     // Check the arguments
4569     ValueList Args;
4570     if (yyvsp[-2].ValueRefList->empty()) {                                   // Has no arguments?
4571       // Make sure no arguments is a good thing!
4572       if (Ty->getNumParams() != 0)
4573         GEN_ERROR("No arguments passed to a function that "
4574                        "expects arguments");
4575     } else {                                     // Has arguments?
4576       // Loop through FunctionType's arguments and ensure they are specified
4577       // correctly!
4578       //
4579       FunctionType::param_iterator I = Ty->param_begin();
4580       FunctionType::param_iterator E = Ty->param_end();
4581       ValueRefList::iterator ArgI = yyvsp[-2].ValueRefList->begin(), ArgE = yyvsp[-2].ValueRefList->end();
4582
4583       for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
4584         if (ArgI->Val->getType() != *I)
4585           GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" +
4586                          (*I)->getDescription() + "'");
4587         Args.push_back(ArgI->Val);
4588       }
4589       if (Ty->isVarArg()) {
4590         if (I == E)
4591           for (; ArgI != ArgE; ++ArgI)
4592             Args.push_back(ArgI->Val); // push the remaining varargs
4593       } else if (I != E || ArgI != ArgE)
4594         GEN_ERROR("Invalid number of parameters detected");
4595     }
4596     // Create the call node
4597     CallInst *CI = new CallInst(V, &Args[0], Args.size());
4598     CI->setTailCall(yyvsp[-7].BoolVal);
4599     CI->setCallingConv(yyvsp[-6].UIntVal);
4600     yyval.InstVal = CI;
4601     delete yyvsp[-2].ValueRefList;
4602     delete yyvsp[-5].TypeVal;
4603     CHECK_FOR_ERROR
4604   ;
4605     break;}
4606 case 273:
4607 #line 2772 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4608 {
4609     yyval.InstVal = yyvsp[0].InstVal;
4610     CHECK_FOR_ERROR
4611   ;
4612     break;}
4613 case 274:
4614 #line 2777 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4615 {
4616     yyval.BoolVal = true;
4617     CHECK_FOR_ERROR
4618   ;
4619     break;}
4620 case 275:
4621 #line 2781 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4622 {
4623     yyval.BoolVal = false;
4624     CHECK_FOR_ERROR
4625   ;
4626     break;}
4627 case 276:
4628 #line 2788 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4629 {
4630     if (!UpRefs.empty())
4631       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
4632     yyval.InstVal = new MallocInst(*yyvsp[-1].TypeVal, 0, yyvsp[0].UIntVal);
4633     delete yyvsp[-1].TypeVal;
4634     CHECK_FOR_ERROR
4635   ;
4636     break;}
4637 case 277:
4638 #line 2795 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4639 {
4640     if (!UpRefs.empty())
4641       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription());
4642     Value* tmpVal = getVal(yyvsp[-2].PrimType, yyvsp[-1].ValIDVal);
4643     CHECK_FOR_ERROR
4644     yyval.InstVal = new MallocInst(*yyvsp[-4].TypeVal, tmpVal, yyvsp[0].UIntVal);
4645     delete yyvsp[-4].TypeVal;
4646   ;
4647     break;}
4648 case 278:
4649 #line 2803 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4650 {
4651     if (!UpRefs.empty())
4652       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
4653     yyval.InstVal = new AllocaInst(*yyvsp[-1].TypeVal, 0, yyvsp[0].UIntVal);
4654     delete yyvsp[-1].TypeVal;
4655     CHECK_FOR_ERROR
4656   ;
4657     break;}
4658 case 279:
4659 #line 2810 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4660 {
4661     if (!UpRefs.empty())
4662       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-4].TypeVal)->getDescription());
4663     Value* tmpVal = getVal(yyvsp[-2].PrimType, yyvsp[-1].ValIDVal);
4664     CHECK_FOR_ERROR
4665     yyval.InstVal = new AllocaInst(*yyvsp[-4].TypeVal, tmpVal, yyvsp[0].UIntVal);
4666     delete yyvsp[-4].TypeVal;
4667   ;
4668     break;}
4669 case 280:
4670 #line 2818 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4671 {
4672     if (!isa<PointerType>(yyvsp[0].ValueVal->getType()))
4673       GEN_ERROR("Trying to free nonpointer type " +
4674                      yyvsp[0].ValueVal->getType()->getDescription() + "");
4675     yyval.InstVal = new FreeInst(yyvsp[0].ValueVal);
4676     CHECK_FOR_ERROR
4677   ;
4678     break;}
4679 case 281:
4680 #line 2826 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4681 {
4682     if (!UpRefs.empty())
4683       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
4684     if (!isa<PointerType>(yyvsp[-1].TypeVal->get()))
4685       GEN_ERROR("Can't load from nonpointer type: " +
4686                      (*yyvsp[-1].TypeVal)->getDescription());
4687     if (!cast<PointerType>(yyvsp[-1].TypeVal->get())->getElementType()->isFirstClassType())
4688       GEN_ERROR("Can't load from pointer of non-first-class type: " +
4689                      (*yyvsp[-1].TypeVal)->getDescription());
4690     Value* tmpVal = getVal(*yyvsp[-1].TypeVal, yyvsp[0].ValIDVal);
4691     CHECK_FOR_ERROR
4692     yyval.InstVal = new LoadInst(tmpVal, "", yyvsp[-3].BoolVal);
4693     delete yyvsp[-1].TypeVal;
4694   ;
4695     break;}
4696 case 282:
4697 #line 2840 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4698 {
4699     if (!UpRefs.empty())
4700       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-1].TypeVal)->getDescription());
4701     const PointerType *PT = dyn_cast<PointerType>(yyvsp[-1].TypeVal->get());
4702     if (!PT)
4703       GEN_ERROR("Can't store to a nonpointer type: " +
4704                      (*yyvsp[-1].TypeVal)->getDescription());
4705     const Type *ElTy = PT->getElementType();
4706     if (ElTy != yyvsp[-3].ValueVal->getType())
4707       GEN_ERROR("Can't store '" + yyvsp[-3].ValueVal->getType()->getDescription() +
4708                      "' into space of type '" + ElTy->getDescription() + "'");
4709
4710     Value* tmpVal = getVal(*yyvsp[-1].TypeVal, yyvsp[0].ValIDVal);
4711     CHECK_FOR_ERROR
4712     yyval.InstVal = new StoreInst(yyvsp[-3].ValueVal, tmpVal, yyvsp[-5].BoolVal);
4713     delete yyvsp[-1].TypeVal;
4714   ;
4715     break;}
4716 case 283:
4717 #line 2857 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4718 {
4719     if (!UpRefs.empty())
4720       GEN_ERROR("Invalid upreference in type: " + (*yyvsp[-2].TypeVal)->getDescription());
4721     if (!isa<PointerType>(yyvsp[-2].TypeVal->get()))
4722       GEN_ERROR("getelementptr insn requires pointer operand");
4723
4724     if (!GetElementPtrInst::getIndexedType(*yyvsp[-2].TypeVal, &(*yyvsp[0].ValueList)[0], yyvsp[0].ValueList->size(), true))
4725       GEN_ERROR("Invalid getelementptr indices for type '" +
4726                      (*yyvsp[-2].TypeVal)->getDescription()+ "'");
4727     Value* tmpVal = getVal(*yyvsp[-2].TypeVal, yyvsp[-1].ValIDVal);
4728     CHECK_FOR_ERROR
4729     yyval.InstVal = new GetElementPtrInst(tmpVal, &(*yyvsp[0].ValueList)[0], yyvsp[0].ValueList->size());
4730     delete yyvsp[-2].TypeVal;
4731     delete yyvsp[0].ValueList;
4732   ;
4733     break;}
4734 }
4735    /* the action file gets copied in in place of this dollarsign */
4736 #line 543 "/usr/share/bison.simple"
4737 \f
4738   yyvsp -= yylen;
4739   yyssp -= yylen;
4740 #ifdef YYLSP_NEEDED
4741   yylsp -= yylen;
4742 #endif
4743
4744 #if YYDEBUG != 0
4745   if (yydebug)
4746     {
4747       short *ssp1 = yyss - 1;
4748       fprintf (stderr, "state stack now");
4749       while (ssp1 != yyssp)
4750         fprintf (stderr, " %d", *++ssp1);
4751       fprintf (stderr, "\n");
4752     }
4753 #endif
4754
4755   *++yyvsp = yyval;
4756
4757 #ifdef YYLSP_NEEDED
4758   yylsp++;
4759   if (yylen == 0)
4760     {
4761       yylsp->first_line = yylloc.first_line;
4762       yylsp->first_column = yylloc.first_column;
4763       yylsp->last_line = (yylsp-1)->last_line;
4764       yylsp->last_column = (yylsp-1)->last_column;
4765       yylsp->text = 0;
4766     }
4767   else
4768     {
4769       yylsp->last_line = (yylsp+yylen-1)->last_line;
4770       yylsp->last_column = (yylsp+yylen-1)->last_column;
4771     }
4772 #endif
4773
4774   /* Now "shift" the result of the reduction.
4775      Determine what state that goes to,
4776      based on the state we popped back to
4777      and the rule number reduced by.  */
4778
4779   yyn = yyr1[yyn];
4780
4781   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
4782   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4783     yystate = yytable[yystate];
4784   else
4785     yystate = yydefgoto[yyn - YYNTBASE];
4786
4787   goto yynewstate;
4788
4789 yyerrlab:   /* here on detecting error */
4790
4791   if (! yyerrstatus)
4792     /* If not already recovering from an error, report this error.  */
4793     {
4794       ++yynerrs;
4795
4796 #ifdef YYERROR_VERBOSE
4797       yyn = yypact[yystate];
4798
4799       if (yyn > YYFLAG && yyn < YYLAST)
4800         {
4801           int size = 0;
4802           char *msg;
4803           int x, count;
4804
4805           count = 0;
4806           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
4807           for (x = (yyn < 0 ? -yyn : 0);
4808                x < (sizeof(yytname) / sizeof(char *)); x++)
4809             if (yycheck[x + yyn] == x)
4810               size += strlen(yytname[x]) + 15, count++;
4811           msg = (char *) malloc(size + 15);
4812           if (msg != 0)
4813             {
4814               strcpy(msg, "parse error");
4815
4816               if (count < 5)
4817                 {
4818                   count = 0;
4819                   for (x = (yyn < 0 ? -yyn : 0);
4820                        x < (sizeof(yytname) / sizeof(char *)); x++)
4821                     if (yycheck[x + yyn] == x)
4822                       {
4823                         strcat(msg, count == 0 ? ", expecting `" : " or `");
4824                         strcat(msg, yytname[x]);
4825                         strcat(msg, "'");
4826                         count++;
4827                       }
4828                 }
4829               yyerror(msg);
4830               free(msg);
4831             }
4832           else
4833             yyerror ("parse error; also virtual memory exceeded");
4834         }
4835       else
4836 #endif /* YYERROR_VERBOSE */
4837         yyerror("parse error");
4838     }
4839
4840   goto yyerrlab1;
4841 yyerrlab1:   /* here on error raised explicitly by an action */
4842
4843   if (yyerrstatus == 3)
4844     {
4845       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
4846
4847       /* return failure if at end of input */
4848       if (yychar == YYEOF)
4849         YYABORT;
4850
4851 #if YYDEBUG != 0
4852       if (yydebug)
4853         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
4854 #endif
4855
4856       yychar = YYEMPTY;
4857     }
4858
4859   /* Else will try to reuse lookahead token
4860      after shifting the error token.  */
4861
4862   yyerrstatus = 3;              /* Each real token shifted decrements this */
4863
4864   goto yyerrhandle;
4865
4866 yyerrdefault:  /* current state does not do anything special for the error token. */
4867
4868 #if 0
4869   /* This is wrong; only states that explicitly want error tokens
4870      should shift them.  */
4871   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
4872   if (yyn) goto yydefault;
4873 #endif
4874
4875 yyerrpop:   /* pop the current state because it cannot handle the error token */
4876
4877   if (yyssp == yyss) YYABORT;
4878   yyvsp--;
4879   yystate = *--yyssp;
4880 #ifdef YYLSP_NEEDED
4881   yylsp--;
4882 #endif
4883
4884 #if YYDEBUG != 0
4885   if (yydebug)
4886     {
4887       short *ssp1 = yyss - 1;
4888       fprintf (stderr, "Error: state stack now");
4889       while (ssp1 != yyssp)
4890         fprintf (stderr, " %d", *++ssp1);
4891       fprintf (stderr, "\n");
4892     }
4893 #endif
4894
4895 yyerrhandle:
4896
4897   yyn = yypact[yystate];
4898   if (yyn == YYFLAG)
4899     goto yyerrdefault;
4900
4901   yyn += YYTERROR;
4902   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
4903     goto yyerrdefault;
4904
4905   yyn = yytable[yyn];
4906   if (yyn < 0)
4907     {
4908       if (yyn == YYFLAG)
4909         goto yyerrpop;
4910       yyn = -yyn;
4911       goto yyreduce;
4912     }
4913   else if (yyn == 0)
4914     goto yyerrpop;
4915
4916   if (yyn == YYFINAL)
4917     YYACCEPT;
4918
4919 #if YYDEBUG != 0
4920   if (yydebug)
4921     fprintf(stderr, "Shifting error token, ");
4922 #endif
4923
4924   *++yyvsp = yylval;
4925 #ifdef YYLSP_NEEDED
4926   *++yylsp = yylloc;
4927 #endif
4928
4929   yystate = yyn;
4930   goto yynewstate;
4931
4932  yyacceptlab:
4933   /* YYACCEPT comes here.  */
4934   if (yyfree_stacks)
4935     {
4936       free (yyss);
4937       free (yyvs);
4938 #ifdef YYLSP_NEEDED
4939       free (yyls);
4940 #endif
4941     }
4942   return 0;
4943
4944  yyabortlab:
4945   /* YYABORT comes here.  */
4946   if (yyfree_stacks)
4947     {
4948       free (yyss);
4949       free (yyvs);
4950 #ifdef YYLSP_NEEDED
4951       free (yyls);
4952 #endif
4953     }
4954   return 1;
4955 }
4956 #line 2874 "/Users/sabre/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4957
4958
4959 // common code from the two 'RunVMAsmParser' functions
4960 static Module* RunParser(Module * M) {
4961
4962   llvmAsmlineno = 1;      // Reset the current line number...
4963   CurModule.CurrentModule = M;
4964 #if YYDEBUG
4965   yydebug = Debug;
4966 #endif
4967
4968   // Check to make sure the parser succeeded
4969   if (yyparse()) {
4970     if (ParserResult)
4971       delete ParserResult;
4972     return 0;
4973   }
4974
4975   // Check to make sure that parsing produced a result
4976   if (!ParserResult)
4977     return 0;
4978
4979   // Reset ParserResult variable while saving its value for the result.
4980   Module *Result = ParserResult;
4981   ParserResult = 0;
4982
4983   return Result;
4984 }
4985
4986 void llvm::GenerateError(const std::string &message, int LineNo) {
4987   if (LineNo == -1) LineNo = llvmAsmlineno;
4988   // TODO: column number in exception
4989   if (TheParseError)
4990     TheParseError->setError(CurFilename, message, LineNo);
4991   TriggerError = 1;
4992 }
4993
4994 int yyerror(const char *ErrorMsg) {
4995   std::string where
4996     = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
4997                   + ":" + utostr((unsigned) llvmAsmlineno) + ": ";
4998   std::string errMsg = where + "error: " + std::string(ErrorMsg);
4999   if (yychar != YYEMPTY && yychar != 0)
5000     errMsg += " while reading token: '" + std::string(llvmAsmtext, llvmAsmleng)+
5001               "'";
5002   GenerateError(errMsg);
5003   return 0;
5004 }