1 /* A Bison parser, made by GNU Bison 2.3. */
3 /* Skeleton implementation for Bison's Yacc-like parsers in C
5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6 Free Software Foundation, Inc.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
23 /* As a special exception, you may create a larger work that contains
24 part or all of the Bison parser skeleton and distribute that work
25 under terms of your choice, so long as that work isn't itself a
26 parser generator using the skeleton or a modified version thereof
27 as a parser skeleton. Alternatively, if you modify or redistribute
28 the parser skeleton itself, you may (at your option) remove this
29 special exception, which will cause the skeleton and the resulting
30 Bison output files to be licensed under the GNU General Public
31 License without this special exception.
33 This special exception was added by the Free Software Foundation in
34 version 2.2 of Bison. */
36 /* C LALR(1) parser skeleton written by Richard Stallman, by
37 simplifying the original so-called "semantic" parser. */
39 /* All symbols defined below should begin with yy or YY, to avoid
40 infringing on user name space. This should be done even for local
41 variables, as they might otherwise be expanded by user macros.
42 There are some unavoidable exceptions within include files to
43 define necessary library symbols; they are noted "INFRINGES ON
44 USER NAME SPACE" below. */
46 /* Identify Bison output. */
50 #define YYBISON_VERSION "2.3"
53 #define YYSKELETON_NAME "yacc.c"
58 /* Using locations. */
59 #define YYLSP_NEEDED 0
61 /* Substitute the variable and function names. */
62 #define yyparse llvmAsmparse
63 #define yylex llvmAsmlex
64 #define yyerror llvmAsmerror
65 #define yylval llvmAsmlval
66 #define yychar llvmAsmchar
67 #define yydebug llvmAsmdebug
68 #define yynerrs llvmAsmnerrs
74 /* Put the tokens into the symbol table, so that GDB and other debuggers
97 ATSTRINGCONSTANT = 278,
98 PCTSTRINGCONSTANT = 279,
99 ZEROINITIALIZER = 280,
140 X86_STDCALLCC_TOK = 321,
141 X86_FASTCALLCC_TOK = 322,
209 EXTRACTELEMENT = 390,
236 #define ESINT64VAL 258
237 #define EUINT64VAL 259
238 #define ESAPINTVAL 260
239 #define EUAPINTVAL 261
240 #define LOCALVAL_ID 262
241 #define GLOBALVAL_ID 263
249 #define PPC_FP128 271
253 #define GLOBALVAR 275
255 #define STRINGCONSTANT 277
256 #define ATSTRINGCONSTANT 278
257 #define PCTSTRINGCONSTANT 279
258 #define ZEROINITIALIZER 280
270 #define THREAD_LOCAL 292
272 #define DOTDOTDOT 294
278 #define APPENDING 300
279 #define DLLIMPORT 301
280 #define DLLEXPORT 302
281 #define EXTERN_WEAK 303
288 #define ADDRSPACE 310
294 #define SIDEEFFECT 316
297 #define FASTCC_TOK 319
298 #define COLDCC_TOK 320
299 #define X86_STDCALLCC_TOK 321
300 #define X86_FASTCALLCC_TOK 322
301 #define DATALAYOUT 323
307 #define UNREACHABLE 329
352 #define GETELEMENTPTR 374
368 #define EXTRACTELEMENT 390
369 #define INSERTELEMENT 391
370 #define SHUFFLEVECTOR 392
371 #define GETRESULT 393
372 #define EXTRACTVALUE 394
373 #define INSERTVALUE 395
388 #define ALWAYSINLINE 410
391 #define PROTECTED 413
396 /* Copy the first part of user declarations. */
397 #line 14 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
399 #include "ParserInternals.h"
400 #include "llvm/CallingConv.h"
401 #include "llvm/InlineAsm.h"
402 #include "llvm/Instructions.h"
403 #include "llvm/Module.h"
404 #include "llvm/ValueSymbolTable.h"
405 #include "llvm/AutoUpgrade.h"
406 #include "llvm/Support/GetElementPtrTypeIterator.h"
407 #include "llvm/Support/CommandLine.h"
408 #include "llvm/ADT/SmallVector.h"
409 #include "llvm/ADT/STLExtras.h"
410 #include "llvm/Support/MathExtras.h"
411 #include "llvm/Support/Streams.h"
417 // The following is a gross hack. In order to rid the libAsmParser library of
418 // exceptions, we have to have a way of getting the yyparse function to go into
419 // an error situation. So, whenever we want an error to occur, the GenerateError
420 // function (see bottom of file) sets TriggerError. Then, at the end of each
421 // production in the grammer we use CHECK_FOR_ERROR which will invoke YYERROR
422 // (a goto) to put YACC in error state. Furthermore, several calls to
423 // GenerateError are made from inside productions and they must simulate the
424 // previous exception behavior by exiting the production immediately. We have
425 // replaced these with the GEN_ERROR macro which calls GeneratError and then
426 // immediately invokes YYERROR. This would be so much cleaner if it was a
427 // recursive descent parser.
428 static bool TriggerError = false;
429 #define CHECK_FOR_ERROR { if (TriggerError) { TriggerError = false; YYABORT; } }
430 #define GEN_ERROR(msg) { GenerateError(msg); YYERROR; }
432 int yyerror(const char *ErrorMsg); // Forward declarations to prevent "implicit
433 int yylex(); // declaration" of xxx warnings.
435 using namespace llvm;
437 static Module *ParserResult;
439 // DEBUG_UPREFS - Define this symbol if you want to enable debugging output
440 // relating to upreferences in the input stream.
442 //#define DEBUG_UPREFS 1
444 #define UR_OUT(X) cerr << X
449 #define YYERROR_VERBOSE 1
451 static GlobalVariable *CurGV;
454 // This contains info used when building the body of a function. It is
455 // destroyed when the function is completed.
457 typedef std::vector<Value *> ValueList; // Numbered defs
460 ResolveDefinitions(ValueList &LateResolvers, ValueList *FutureLateResolvers=0);
462 static struct PerModuleInfo {
463 Module *CurrentModule;
464 ValueList Values; // Module level numbered definitions
465 ValueList LateResolveValues;
466 std::vector<PATypeHolder> Types;
467 std::map<ValID, PATypeHolder> LateResolveTypes;
469 /// PlaceHolderInfo - When temporary placeholder objects are created, remember
470 /// how they were referenced and on which line of the input they came from so
471 /// that we can resolve them later and print error messages as appropriate.
472 std::map<Value*, std::pair<ValID, int> > PlaceHolderInfo;
474 // GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward
475 // references to global values. Global values may be referenced before they
476 // are defined, and if so, the temporary object that they represent is held
477 // here. This is used for forward references of GlobalValues.
479 typedef std::map<std::pair<const PointerType *,
480 ValID>, GlobalValue*> GlobalRefsType;
481 GlobalRefsType GlobalRefs;
484 // If we could not resolve some functions at function compilation time
485 // (calls to functions before they are defined), resolve them now... Types
486 // are resolved when the constant pool has been completely parsed.
488 ResolveDefinitions(LateResolveValues);
492 // Check to make sure that all global value forward references have been
495 if (!GlobalRefs.empty()) {
496 std::string UndefinedReferences = "Unresolved global references exist:\n";
498 for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end();
500 UndefinedReferences += " " + I->first.first->getDescription() + " " +
501 I->first.second.getName() + "\n";
503 GenerateError(UndefinedReferences);
507 // Look for intrinsic functions and CallInst that need to be upgraded
508 for (Module::iterator FI = CurrentModule->begin(),
509 FE = CurrentModule->end(); FI != FE; )
510 UpgradeCallsToIntrinsic(FI++); // must be post-increment, as we remove
512 Values.clear(); // Clear out function local definitions
517 // GetForwardRefForGlobal - Check to see if there is a forward reference
518 // for this global. If so, remove it from the GlobalRefs map and return it.
519 // If not, just return null.
520 GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) {
521 // Check to see if there is a forward reference to this global variable...
522 // if there is, eliminate it and patch the reference to use the new def'n.
523 GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID));
524 GlobalValue *Ret = 0;
525 if (I != GlobalRefs.end()) {
532 bool TypeIsUnresolved(PATypeHolder* PATy) {
533 // If it isn't abstract, its resolved
534 const Type* Ty = PATy->get();
535 if (!Ty->isAbstract())
537 // Traverse the type looking for abstract types. If it isn't abstract then
538 // we don't need to traverse that leg of the type.
539 std::vector<const Type*> WorkList, SeenList;
540 WorkList.push_back(Ty);
541 while (!WorkList.empty()) {
542 const Type* Ty = WorkList.back();
543 SeenList.push_back(Ty);
545 if (const OpaqueType* OpTy = dyn_cast<OpaqueType>(Ty)) {
546 // Check to see if this is an unresolved type
547 std::map<ValID, PATypeHolder>::iterator I = LateResolveTypes.begin();
548 std::map<ValID, PATypeHolder>::iterator E = LateResolveTypes.end();
549 for ( ; I != E; ++I) {
550 if (I->second.get() == OpTy)
553 } else if (const SequentialType* SeqTy = dyn_cast<SequentialType>(Ty)) {
554 const Type* TheTy = SeqTy->getElementType();
555 if (TheTy->isAbstract() && TheTy != Ty) {
556 std::vector<const Type*>::iterator I = SeenList.begin(),
562 WorkList.push_back(TheTy);
564 } else if (const StructType* StrTy = dyn_cast<StructType>(Ty)) {
565 for (unsigned i = 0; i < StrTy->getNumElements(); ++i) {
566 const Type* TheTy = StrTy->getElementType(i);
567 if (TheTy->isAbstract() && TheTy != Ty) {
568 std::vector<const Type*>::iterator I = SeenList.begin(),
574 WorkList.push_back(TheTy);
583 static struct PerFunctionInfo {
584 Function *CurrentFunction; // Pointer to current function being created
586 ValueList Values; // Keep track of #'d definitions
588 ValueList LateResolveValues;
589 bool isDeclare; // Is this function a forward declararation?
590 GlobalValue::LinkageTypes Linkage; // Linkage for forward declaration.
591 GlobalValue::VisibilityTypes Visibility;
593 /// BBForwardRefs - When we see forward references to basic blocks, keep
594 /// track of them here.
595 std::map<ValID, BasicBlock*> BBForwardRefs;
597 inline PerFunctionInfo() {
600 Linkage = GlobalValue::ExternalLinkage;
601 Visibility = GlobalValue::DefaultVisibility;
604 inline void FunctionStart(Function *M) {
609 void FunctionDone() {
610 // Any forward referenced blocks left?
611 if (!BBForwardRefs.empty()) {
612 GenerateError("Undefined reference to label " +
613 BBForwardRefs.begin()->second->getName());
617 // Resolve all forward references now.
618 ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
620 Values.clear(); // Clear out function local definitions
621 BBForwardRefs.clear();
624 Linkage = GlobalValue::ExternalLinkage;
625 Visibility = GlobalValue::DefaultVisibility;
627 } CurFun; // Info for the current function...
629 static bool inFunctionScope() { return CurFun.CurrentFunction != 0; }
632 //===----------------------------------------------------------------------===//
633 // Code to handle definitions of all the types
634 //===----------------------------------------------------------------------===//
636 /// InsertValue - Insert a value into the value table. If it is named, this
637 /// returns -1, otherwise it returns the slot number for the value.
638 static int InsertValue(Value *V, ValueList &ValueTab = CurFun.Values) {
639 // Things that have names or are void typed don't get slot numbers
640 if (V->hasName() || (V->getType() == Type::VoidTy))
643 // In the case of function values, we have to allow for the forward reference
644 // of basic blocks, which are included in the numbering. Consequently, we keep
645 // track of the next insertion location with NextValNum. When a BB gets
646 // inserted, it could change the size of the CurFun.Values vector.
647 if (&ValueTab == &CurFun.Values) {
648 if (ValueTab.size() <= CurFun.NextValNum)
649 ValueTab.resize(CurFun.NextValNum+1);
650 ValueTab[CurFun.NextValNum++] = V;
651 return CurFun.NextValNum-1;
653 // For all other lists, its okay to just tack it on the back of the vector.
654 ValueTab.push_back(V);
655 return ValueTab.size()-1;
658 static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
660 case ValID::LocalID: // Is it a numbered definition?
661 // Module constants occupy the lowest numbered slots...
662 if (D.Num < CurModule.Types.size())
663 return CurModule.Types[D.Num];
665 case ValID::LocalName: // Is it a named definition?
666 if (const Type *N = CurModule.CurrentModule->getTypeByName(D.getName())) {
667 D.destroy(); // Free old strdup'd memory...
672 GenerateError("Internal parser error: Invalid symbol type reference");
676 // If we reached here, we referenced either a symbol that we don't know about
677 // or an id number that hasn't been read yet. We may be referencing something
678 // forward, so just create an entry to be resolved later and get to it...
680 if (DoNotImprovise) return 0; // Do we just want a null to be returned?
683 if (inFunctionScope()) {
684 if (D.Type == ValID::LocalName) {
685 GenerateError("Reference to an undefined type: '" + D.getName() + "'");
688 GenerateError("Reference to an undefined type: #" + utostr(D.Num));
693 std::map<ValID, PATypeHolder>::iterator I =CurModule.LateResolveTypes.find(D);
694 if (I != CurModule.LateResolveTypes.end()) {
699 Type *Typ = OpaqueType::get();
700 CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
704 // getExistingVal - Look up the value specified by the provided type and
705 // the provided ValID. If the value exists and has already been defined, return
706 // it. Otherwise return null.
708 static Value *getExistingVal(const Type *Ty, const ValID &D) {
709 if (isa<FunctionType>(Ty)) {
710 GenerateError("Functions are not values and "
711 "must be referenced as pointers");
716 case ValID::LocalID: { // Is it a numbered definition?
717 // Check that the number is within bounds.
718 if (D.Num >= CurFun.Values.size())
720 Value *Result = CurFun.Values[D.Num];
721 if (Ty != Result->getType()) {
722 GenerateError("Numbered value (%" + utostr(D.Num) + ") of type '" +
723 Result->getType()->getDescription() + "' does not match "
724 "expected type, '" + Ty->getDescription() + "'");
729 case ValID::GlobalID: { // Is it a numbered definition?
730 if (D.Num >= CurModule.Values.size())
732 Value *Result = CurModule.Values[D.Num];
733 if (Ty != Result->getType()) {
734 GenerateError("Numbered value (@" + utostr(D.Num) + ") of type '" +
735 Result->getType()->getDescription() + "' does not match "
736 "expected type, '" + Ty->getDescription() + "'");
742 case ValID::LocalName: { // Is it a named definition?
743 if (!inFunctionScope())
745 ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
746 Value *N = SymTab.lookup(D.getName());
749 if (N->getType() != Ty)
752 D.destroy(); // Free old strdup'd memory...
755 case ValID::GlobalName: { // Is it a named definition?
756 ValueSymbolTable &SymTab = CurModule.CurrentModule->getValueSymbolTable();
757 Value *N = SymTab.lookup(D.getName());
760 if (N->getType() != Ty)
763 D.destroy(); // Free old strdup'd memory...
767 // Check to make sure that "Ty" is an integral type, and that our
768 // value will fit into the specified type...
769 case ValID::ConstSIntVal: // Is it a constant pool reference??
770 if (!isa<IntegerType>(Ty) ||
771 !ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
772 GenerateError("Signed integral constant '" +
773 itostr(D.ConstPool64) + "' is invalid for type '" +
774 Ty->getDescription() + "'");
777 return ConstantInt::get(Ty, D.ConstPool64, true);
779 case ValID::ConstUIntVal: // Is it an unsigned const pool reference?
780 if (isa<IntegerType>(Ty) &&
781 ConstantInt::isValueValidForType(Ty, D.UConstPool64))
782 return ConstantInt::get(Ty, D.UConstPool64);
784 if (!isa<IntegerType>(Ty) ||
785 !ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
786 GenerateError("Integral constant '" + utostr(D.UConstPool64) +
787 "' is invalid or out of range for type '" +
788 Ty->getDescription() + "'");
791 // This is really a signed reference. Transmogrify.
792 return ConstantInt::get(Ty, D.ConstPool64, true);
794 case ValID::ConstAPInt: // Is it an unsigned const pool reference?
795 if (!isa<IntegerType>(Ty)) {
796 GenerateError("Integral constant '" + D.getName() +
797 "' is invalid or out of range for type '" +
798 Ty->getDescription() + "'");
803 APSInt Tmp = *D.ConstPoolInt;
804 Tmp.extOrTrunc(Ty->getPrimitiveSizeInBits());
805 return ConstantInt::get(Tmp);
808 case ValID::ConstFPVal: // Is it a floating point const pool reference?
809 if (!Ty->isFloatingPoint() ||
810 !ConstantFP::isValueValidForType(Ty, *D.ConstPoolFP)) {
811 GenerateError("FP constant invalid for type");
814 // Lexer has no type info, so builds all float and double FP constants
815 // as double. Fix this here. Long double does not need this.
816 if (&D.ConstPoolFP->getSemantics() == &APFloat::IEEEdouble &&
819 D.ConstPoolFP->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven,
822 return ConstantFP::get(*D.ConstPoolFP);
824 case ValID::ConstNullVal: // Is it a null value?
825 if (!isa<PointerType>(Ty)) {
826 GenerateError("Cannot create a a non pointer null");
829 return ConstantPointerNull::get(cast<PointerType>(Ty));
831 case ValID::ConstUndefVal: // Is it an undef value?
832 return UndefValue::get(Ty);
834 case ValID::ConstZeroVal: // Is it a zero value?
835 return Constant::getNullValue(Ty);
837 case ValID::ConstantVal: // Fully resolved constant?
838 if (D.ConstantValue->getType() != Ty) {
839 GenerateError("Constant expression type different from required type");
842 return D.ConstantValue;
844 case ValID::InlineAsmVal: { // Inline asm expression
845 const PointerType *PTy = dyn_cast<PointerType>(Ty);
846 const FunctionType *FTy =
847 PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
848 if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints)) {
849 GenerateError("Invalid type for asm constraint string");
852 InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
853 D.IAD->HasSideEffects);
854 D.destroy(); // Free InlineAsmDescriptor.
858 assert(0 && "Unhandled case!");
862 assert(0 && "Unhandled case!");
866 // getVal - This function is identical to getExistingVal, except that if a
867 // value is not already defined, it "improvises" by creating a placeholder var
868 // that looks and acts just like the requested variable. When the value is
869 // defined later, all uses of the placeholder variable are replaced with the
872 static Value *getVal(const Type *Ty, const ValID &ID) {
873 if (Ty == Type::LabelTy) {
874 GenerateError("Cannot use a basic block here");
878 // See if the value has already been defined.
879 Value *V = getExistingVal(Ty, ID);
881 if (TriggerError) return 0;
883 if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty)) {
884 GenerateError("Invalid use of a non-first-class type");
888 // If we reached here, we referenced either a symbol that we don't know about
889 // or an id number that hasn't been read yet. We may be referencing something
890 // forward, so just create an entry to be resolved later and get to it...
893 case ValID::GlobalName:
894 case ValID::GlobalID: {
895 const PointerType *PTy = dyn_cast<PointerType>(Ty);
897 GenerateError("Invalid type for reference to global" );
900 const Type* ElTy = PTy->getElementType();
901 if (const FunctionType *FTy = dyn_cast<FunctionType>(ElTy))
902 V = Function::Create(FTy, GlobalValue::ExternalLinkage);
904 V = new GlobalVariable(ElTy, false, GlobalValue::ExternalLinkage, 0, "",
905 (Module*)0, false, PTy->getAddressSpace());
909 V = new Argument(Ty);
912 // Remember where this forward reference came from. FIXME, shouldn't we try
913 // to recycle these things??
914 CurModule.PlaceHolderInfo.insert(std::make_pair(V, std::make_pair(ID,
917 if (inFunctionScope())
918 InsertValue(V, CurFun.LateResolveValues);
920 InsertValue(V, CurModule.LateResolveValues);
924 /// defineBBVal - This is a definition of a new basic block with the specified
925 /// identifier which must be the same as CurFun.NextValNum, if its numeric.
926 static BasicBlock *defineBBVal(const ValID &ID) {
927 assert(inFunctionScope() && "Can't get basic block at global scope!");
931 // First, see if this was forward referenced
933 std::map<ValID, BasicBlock*>::iterator BBI = CurFun.BBForwardRefs.find(ID);
934 if (BBI != CurFun.BBForwardRefs.end()) {
936 // The forward declaration could have been inserted anywhere in the
937 // function: insert it into the correct place now.
938 CurFun.CurrentFunction->getBasicBlockList().remove(BB);
939 CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
941 // We're about to erase the entry, save the key so we can clean it up.
942 ValID Tmp = BBI->first;
944 // Erase the forward ref from the map as its no longer "forward"
945 CurFun.BBForwardRefs.erase(ID);
947 // The key has been removed from the map but so we don't want to leave
948 // strdup'd memory around so destroy it too.
951 // If its a numbered definition, bump the number and set the BB value.
952 if (ID.Type == ValID::LocalID) {
953 assert(ID.Num == CurFun.NextValNum && "Invalid new block number");
957 // We haven't seen this BB before and its first mention is a definition.
958 // Just create it and return it.
959 std::string Name (ID.Type == ValID::LocalName ? ID.getName() : "");
960 BB = BasicBlock::Create(Name, CurFun.CurrentFunction);
961 if (ID.Type == ValID::LocalID) {
962 assert(ID.Num == CurFun.NextValNum && "Invalid new block number");
971 /// getBBVal - get an existing BB value or create a forward reference for it.
973 static BasicBlock *getBBVal(const ValID &ID) {
974 assert(inFunctionScope() && "Can't get basic block at global scope!");
978 std::map<ValID, BasicBlock*>::iterator BBI = CurFun.BBForwardRefs.find(ID);
979 if (BBI != CurFun.BBForwardRefs.end()) {
981 } if (ID.Type == ValID::LocalName) {
982 std::string Name = ID.getName();
983 Value *N = CurFun.CurrentFunction->getValueSymbolTable().lookup(Name);
985 if (N->getType()->getTypeID() == Type::LabelTyID)
986 BB = cast<BasicBlock>(N);
988 GenerateError("Reference to label '" + Name + "' is actually of type '"+
989 N->getType()->getDescription() + "'");
991 } else if (ID.Type == ValID::LocalID) {
992 if (ID.Num < CurFun.NextValNum && ID.Num < CurFun.Values.size()) {
993 if (CurFun.Values[ID.Num]->getType()->getTypeID() == Type::LabelTyID)
994 BB = cast<BasicBlock>(CurFun.Values[ID.Num]);
996 GenerateError("Reference to label '%" + utostr(ID.Num) +
997 "' is actually of type '"+
998 CurFun.Values[ID.Num]->getType()->getDescription() + "'");
1001 GenerateError("Illegal label reference " + ID.getName());
1005 // If its already been defined, return it now.
1007 ID.destroy(); // Free strdup'd memory.
1011 // Otherwise, this block has not been seen before, create it.
1013 if (ID.Type == ValID::LocalName)
1014 Name = ID.getName();
1015 BB = BasicBlock::Create(Name, CurFun.CurrentFunction);
1017 // Insert it in the forward refs map.
1018 CurFun.BBForwardRefs[ID] = BB;
1024 //===----------------------------------------------------------------------===//
1025 // Code to handle forward references in instructions
1026 //===----------------------------------------------------------------------===//
1028 // This code handles the late binding needed with statements that reference
1029 // values not defined yet... for example, a forward branch, or the PHI node for
1032 // This keeps a table (CurFun.LateResolveValues) of all such forward references
1033 // and back patchs after we are done.
1036 // ResolveDefinitions - If we could not resolve some defs at parsing
1037 // time (forward branches, phi functions for loops, etc...) resolve the
1041 ResolveDefinitions(ValueList &LateResolvers, ValueList *FutureLateResolvers) {
1042 // Loop over LateResolveDefs fixing up stuff that couldn't be resolved
1043 while (!LateResolvers.empty()) {
1044 Value *V = LateResolvers.back();
1045 LateResolvers.pop_back();
1047 std::map<Value*, std::pair<ValID, int> >::iterator PHI =
1048 CurModule.PlaceHolderInfo.find(V);
1049 assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error!");
1051 ValID &DID = PHI->second.first;
1053 Value *TheRealValue = getExistingVal(V->getType(), DID);
1057 V->replaceAllUsesWith(TheRealValue);
1059 CurModule.PlaceHolderInfo.erase(PHI);
1060 } else if (FutureLateResolvers) {
1061 // Functions have their unresolved items forwarded to the module late
1063 InsertValue(V, *FutureLateResolvers);
1065 if (DID.Type == ValID::LocalName || DID.Type == ValID::GlobalName) {
1066 GenerateError("Reference to an invalid definition: '" +DID.getName()+
1067 "' of type '" + V->getType()->getDescription() + "'",
1068 PHI->second.second);
1071 GenerateError("Reference to an invalid definition: #" +
1072 itostr(DID.Num) + " of type '" +
1073 V->getType()->getDescription() + "'",
1074 PHI->second.second);
1079 LateResolvers.clear();
1082 // ResolveTypeTo - A brand new type was just declared. This means that (if
1083 // name is not null) things referencing Name can be resolved. Otherwise, things
1084 // refering to the number can be resolved. Do this now.
1086 static void ResolveTypeTo(std::string *Name, const Type *ToTy) {
1089 D = ValID::createLocalName(*Name);
1091 D = ValID::createLocalID(CurModule.Types.size());
1093 std::map<ValID, PATypeHolder>::iterator I =
1094 CurModule.LateResolveTypes.find(D);
1095 if (I != CurModule.LateResolveTypes.end()) {
1096 ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy);
1098 CurModule.LateResolveTypes.erase(I);
1103 // setValueName - Set the specified value to the name given. The name may be
1104 // null potentially, in which case this is a noop. The string passed in is
1105 // assumed to be a malloc'd string buffer, and is free'd by this function.
1107 static void setValueName(Value *V, std::string *NameStr) {
1108 if (!NameStr) return;
1109 std::string Name(*NameStr); // Copy string
1110 delete NameStr; // Free old string
1112 if (V->getType() == Type::VoidTy) {
1113 GenerateError("Can't assign name '" + Name+"' to value with void type");
1117 assert(inFunctionScope() && "Must be in function scope!");
1118 ValueSymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
1119 if (ST.lookup(Name)) {
1120 GenerateError("Redefinition of value '" + Name + "' of type '" +
1121 V->getType()->getDescription() + "'");
1129 /// ParseGlobalVariable - Handle parsing of a global. If Initializer is null,
1130 /// this is a declaration, otherwise it is a definition.
1131 static GlobalVariable *
1132 ParseGlobalVariable(std::string *NameStr,
1133 GlobalValue::LinkageTypes Linkage,
1134 GlobalValue::VisibilityTypes Visibility,
1135 bool isConstantGlobal, const Type *Ty,
1136 Constant *Initializer, bool IsThreadLocal,
1137 unsigned AddressSpace = 0) {
1138 if (isa<FunctionType>(Ty)) {
1139 GenerateError("Cannot declare global vars of function type");
1142 if (Ty == Type::LabelTy) {
1143 GenerateError("Cannot declare global vars of label type");
1147 const PointerType *PTy = PointerType::get(Ty, AddressSpace);
1151 Name = *NameStr; // Copy string
1152 delete NameStr; // Free old string
1155 // See if this global value was forward referenced. If so, recycle the
1158 if (!Name.empty()) {
1159 ID = ValID::createGlobalName(Name);
1161 ID = ValID::createGlobalID(CurModule.Values.size());
1164 if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
1165 // Move the global to the end of the list, from whereever it was
1166 // previously inserted.
1167 GlobalVariable *GV = cast<GlobalVariable>(FWGV);
1168 CurModule.CurrentModule->getGlobalList().remove(GV);
1169 CurModule.CurrentModule->getGlobalList().push_back(GV);
1170 GV->setInitializer(Initializer);
1171 GV->setLinkage(Linkage);
1172 GV->setVisibility(Visibility);
1173 GV->setConstant(isConstantGlobal);
1174 GV->setThreadLocal(IsThreadLocal);
1175 InsertValue(GV, CurModule.Values);
1182 // If this global has a name
1183 if (!Name.empty()) {
1184 // if the global we're parsing has an initializer (is a definition) and
1185 // has external linkage.
1186 if (Initializer && Linkage != GlobalValue::InternalLinkage)
1187 // If there is already a global with external linkage with this name
1188 if (CurModule.CurrentModule->getGlobalVariable(Name, false)) {
1189 // If we allow this GVar to get created, it will be renamed in the
1190 // symbol table because it conflicts with an existing GVar. We can't
1191 // allow redefinition of GVars whose linking indicates that their name
1192 // must stay the same. Issue the error.
1193 GenerateError("Redefinition of global variable named '" + Name +
1194 "' of type '" + Ty->getDescription() + "'");
1199 // Otherwise there is no existing GV to use, create one now.
1200 GlobalVariable *GV =
1201 new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
1202 CurModule.CurrentModule, IsThreadLocal, AddressSpace);
1203 GV->setVisibility(Visibility);
1204 InsertValue(GV, CurModule.Values);
1208 // setTypeName - Set the specified type to the name given. The name may be
1209 // null potentially, in which case this is a noop. The string passed in is
1210 // assumed to be a malloc'd string buffer, and is freed by this function.
1212 // This function returns true if the type has already been defined, but is
1213 // allowed to be redefined in the specified context. If the name is a new name
1214 // for the type plane, it is inserted and false is returned.
1215 static bool setTypeName(const Type *T, std::string *NameStr) {
1216 assert(!inFunctionScope() && "Can't give types function-local names!");
1217 if (NameStr == 0) return false;
1219 std::string Name(*NameStr); // Copy string
1220 delete NameStr; // Free old string
1222 // We don't allow assigning names to void type
1223 if (T == Type::VoidTy) {
1224 GenerateError("Can't assign name '" + Name + "' to the void type");
1228 // Set the type name, checking for conflicts as we do so.
1229 bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T);
1231 if (AlreadyExists) { // Inserting a name that is already defined???
1232 const Type *Existing = CurModule.CurrentModule->getTypeByName(Name);
1233 assert(Existing && "Conflict but no matching type?!");
1235 // There is only one case where this is allowed: when we are refining an
1236 // opaque type. In this case, Existing will be an opaque type.
1237 if (const OpaqueType *OpTy = dyn_cast<OpaqueType>(Existing)) {
1238 // We ARE replacing an opaque type!
1239 const_cast<OpaqueType*>(OpTy)->refineAbstractTypeTo(T);
1243 // Otherwise, this is an attempt to redefine a type. That's okay if
1244 // the redefinition is identical to the original. This will be so if
1245 // Existing and T point to the same Type object. In this one case we
1246 // allow the equivalent redefinition.
1247 if (Existing == T) return true; // Yes, it's equal.
1249 // Any other kind of (non-equivalent) redefinition is an error.
1250 GenerateError("Redefinition of type named '" + Name + "' of type '" +
1251 T->getDescription() + "'");
1257 //===----------------------------------------------------------------------===//
1258 // Code for handling upreferences in type names...
1261 // TypeContains - Returns true if Ty directly contains E in it.
1263 static bool TypeContains(const Type *Ty, const Type *E) {
1264 return std::find(Ty->subtype_begin(), Ty->subtype_end(),
1265 E) != Ty->subtype_end();
1269 struct UpRefRecord {
1270 // NestingLevel - The number of nesting levels that need to be popped before
1271 // this type is resolved.
1272 unsigned NestingLevel;
1274 // LastContainedTy - This is the type at the current binding level for the
1275 // type. Every time we reduce the nesting level, this gets updated.
1276 const Type *LastContainedTy;
1278 // UpRefTy - This is the actual opaque type that the upreference is
1279 // represented with.
1280 OpaqueType *UpRefTy;
1282 UpRefRecord(unsigned NL, OpaqueType *URTy)
1283 : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {}
1287 // UpRefs - A list of the outstanding upreferences that need to be resolved.
1288 static std::vector<UpRefRecord> UpRefs;
1290 /// HandleUpRefs - Every time we finish a new layer of types, this function is
1291 /// called. It loops through the UpRefs vector, which is a list of the
1292 /// currently active types. For each type, if the up reference is contained in
1293 /// the newly completed type, we decrement the level count. When the level
1294 /// count reaches zero, the upreferenced type is the type that is passed in:
1295 /// thus we can complete the cycle.
1297 static PATypeHolder HandleUpRefs(const Type *ty) {
1298 // If Ty isn't abstract, or if there are no up-references in it, then there is
1299 // nothing to resolve here.
1300 if (!ty->isAbstract() || UpRefs.empty()) return ty;
1302 PATypeHolder Ty(ty);
1303 UR_OUT("Type '" << Ty->getDescription() <<
1304 "' newly formed. Resolving upreferences.\n" <<
1305 UpRefs.size() << " upreferences active!\n");
1307 // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
1308 // to zero), we resolve them all together before we resolve them to Ty. At
1309 // the end of the loop, if there is anything to resolve to Ty, it will be in
1311 OpaqueType *TypeToResolve = 0;
1313 for (unsigned i = 0; i != UpRefs.size(); ++i) {
1314 UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
1315 << UpRefs[i].second->getDescription() << ") = "
1316 << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n");
1317 if (TypeContains(Ty, UpRefs[i].LastContainedTy)) {
1318 // Decrement level of upreference
1319 unsigned Level = --UpRefs[i].NestingLevel;
1320 UpRefs[i].LastContainedTy = Ty;
1321 UR_OUT(" Uplevel Ref Level = " << Level << "\n");
1322 if (Level == 0) { // Upreference should be resolved!
1323 if (!TypeToResolve) {
1324 TypeToResolve = UpRefs[i].UpRefTy;
1326 UR_OUT(" * Resolving upreference for "
1327 << UpRefs[i].second->getDescription() << "\n";
1328 std::string OldName = UpRefs[i].UpRefTy->getDescription());
1329 UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
1330 UR_OUT(" * Type '" << OldName << "' refined upreference to: "
1331 << (const void*)Ty << ", " << Ty->getDescription() << "\n");
1333 UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list...
1334 --i; // Do not skip the next element...
1339 if (TypeToResolve) {
1340 UR_OUT(" * Resolving upreference for "
1341 << UpRefs[i].second->getDescription() << "\n";
1342 std::string OldName = TypeToResolve->getDescription());
1343 TypeToResolve->refineAbstractTypeTo(Ty);
1349 //===----------------------------------------------------------------------===//
1350 // RunVMAsmParser - Define an interface to this parser
1351 //===----------------------------------------------------------------------===//
1353 static Module* RunParser(Module * M);
1355 Module *llvm::RunVMAsmParser(llvm::MemoryBuffer *MB) {
1357 Module *M = RunParser(new Module(LLLgetFilename()));
1364 /* Enabling traces. */
1369 /* Enabling verbose error messages. */
1370 #ifdef YYERROR_VERBOSE
1371 # undef YYERROR_VERBOSE
1372 # define YYERROR_VERBOSE 1
1374 # define YYERROR_VERBOSE 0
1377 /* Enabling the token table. */
1378 #ifndef YYTOKEN_TABLE
1379 # define YYTOKEN_TABLE 0
1382 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1383 typedef union YYSTYPE
1384 #line 980 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
1386 llvm::Module *ModuleVal;
1387 llvm::Function *FunctionVal;
1388 llvm::BasicBlock *BasicBlockVal;
1389 llvm::TerminatorInst *TermInstVal;
1390 llvm::Instruction *InstVal;
1391 llvm::Constant *ConstVal;
1393 const llvm::Type *PrimType;
1394 std::list<llvm::PATypeHolder> *TypeList;
1395 llvm::PATypeHolder *TypeVal;
1396 llvm::Value *ValueVal;
1397 std::vector<llvm::Value*> *ValueList;
1398 std::vector<unsigned> *ConstantList;
1399 llvm::ArgListType *ArgList;
1400 llvm::TypeWithAttrs TypeWithAttrs;
1401 llvm::TypeWithAttrsList *TypeWithAttrsList;
1402 llvm::ParamList *ParamList;
1404 // Represent the RHS of PHI node
1405 std::list<std::pair<llvm::Value*,
1406 llvm::BasicBlock*> > *PHIList;
1407 std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable;
1408 std::vector<llvm::Constant*> *ConstVector;
1410 llvm::GlobalValue::LinkageTypes Linkage;
1411 llvm::GlobalValue::VisibilityTypes Visibility;
1412 llvm::Attributes Attributes;
1413 llvm::APInt *APIntVal;
1418 llvm::APFloat *FPVal;
1421 std::string *StrVal; // This memory must be deleted
1422 llvm::ValID ValIDVal;
1424 llvm::Instruction::BinaryOps BinaryOpVal;
1425 llvm::Instruction::TermOps TermOpVal;
1426 llvm::Instruction::MemoryOps MemOpVal;
1427 llvm::Instruction::CastOps CastOpVal;
1428 llvm::Instruction::OtherOps OtherOpVal;
1429 llvm::ICmpInst::Predicate IPredicate;
1430 llvm::FCmpInst::Predicate FPredicate;
1432 /* Line 187 of yacc.c. */
1433 #line 1434 "llvmAsmParser.tab.c"
1435 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1436 # define YYSTYPE_IS_DECLARED 1
1437 # define YYSTYPE_IS_TRIVIAL 1
1442 /* Copy the second part of user declarations. */
1445 /* Line 216 of yacc.c. */
1446 #line 1447 "llvmAsmParser.tab.c"
1453 typedef YYTYPE_UINT8 yytype_uint8;
1455 typedef unsigned char yytype_uint8;
1459 typedef YYTYPE_INT8 yytype_int8;
1460 #elif (defined __STDC__ || defined __C99__FUNC__ \
1461 || defined __cplusplus || defined _MSC_VER)
1462 typedef signed char yytype_int8;
1464 typedef short int yytype_int8;
1467 #ifdef YYTYPE_UINT16
1468 typedef YYTYPE_UINT16 yytype_uint16;
1470 typedef unsigned short int yytype_uint16;
1474 typedef YYTYPE_INT16 yytype_int16;
1476 typedef short int yytype_int16;
1480 # ifdef __SIZE_TYPE__
1481 # define YYSIZE_T __SIZE_TYPE__
1482 # elif defined size_t
1483 # define YYSIZE_T size_t
1484 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
1485 || defined __cplusplus || defined _MSC_VER)
1486 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
1487 # define YYSIZE_T size_t
1489 # define YYSIZE_T unsigned int
1493 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
1498 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
1499 # define YY_(msgid) dgettext ("bison-runtime", msgid)
1503 # define YY_(msgid) msgid
1507 /* Suppress unused-variable warnings by "using" E. */
1508 #if ! defined lint || defined __GNUC__
1509 # define YYUSE(e) ((void) (e))
1511 # define YYUSE(e) /* empty */
1514 /* Identity function, used to suppress warnings about constant conditions. */
1516 # define YYID(n) (n)
1518 #if (defined __STDC__ || defined __C99__FUNC__ \
1519 || defined __cplusplus || defined _MSC_VER)
1532 #if ! defined yyoverflow || YYERROR_VERBOSE
1534 /* The parser invokes alloca or malloc; define the necessary symbols. */
1536 # ifdef YYSTACK_USE_ALLOCA
1537 # if YYSTACK_USE_ALLOCA
1539 # define YYSTACK_ALLOC __builtin_alloca
1540 # elif defined __BUILTIN_VA_ARG_INCR
1541 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
1543 # define YYSTACK_ALLOC __alloca
1544 # elif defined _MSC_VER
1545 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
1546 # define alloca _alloca
1548 # define YYSTACK_ALLOC alloca
1549 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1550 || defined __cplusplus || defined _MSC_VER)
1551 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1553 # define _STDLIB_H 1
1560 # ifdef YYSTACK_ALLOC
1561 /* Pacify GCC's `empty if-body' warning. */
1562 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
1563 # ifndef YYSTACK_ALLOC_MAXIMUM
1564 /* The OS might guarantee only one guard page at the bottom of the stack,
1565 and a page size can be as small as 4096 bytes. So we cannot safely
1566 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1567 to allow for a few compiler-allocated temporary stack slots. */
1568 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1571 # define YYSTACK_ALLOC YYMALLOC
1572 # define YYSTACK_FREE YYFREE
1573 # ifndef YYSTACK_ALLOC_MAXIMUM
1574 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1576 # if (defined __cplusplus && ! defined _STDLIB_H \
1577 && ! ((defined YYMALLOC || defined malloc) \
1578 && (defined YYFREE || defined free)))
1579 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1581 # define _STDLIB_H 1
1585 # define YYMALLOC malloc
1586 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1587 || defined __cplusplus || defined _MSC_VER)
1588 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1592 # define YYFREE free
1593 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1594 || defined __cplusplus || defined _MSC_VER)
1595 void free (void *); /* INFRINGES ON USER NAME SPACE */
1599 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1602 #if (! defined yyoverflow \
1603 && (! defined __cplusplus \
1604 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1606 /* A type that is properly aligned for any stack member. */
1613 /* The size of the maximum gap between one aligned stack and the next. */
1614 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1616 /* The size of an array large to enough to hold all stacks, each with
1618 # define YYSTACK_BYTES(N) \
1619 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1620 + YYSTACK_GAP_MAXIMUM)
1622 /* Copy COUNT objects from FROM to TO. The source and destination do
1625 # if defined __GNUC__ && 1 < __GNUC__
1626 # define YYCOPY(To, From, Count) \
1627 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1629 # define YYCOPY(To, From, Count) \
1633 for (yyi = 0; yyi < (Count); yyi++) \
1634 (To)[yyi] = (From)[yyi]; \
1640 /* Relocate STACK from its old location to the new one. The
1641 local variables YYSIZE and YYSTACKSIZE give the old and new number of
1642 elements in the stack, and YYPTR gives the new location of the
1643 stack. Advance YYPTR to a properly aligned location for the next
1645 # define YYSTACK_RELOCATE(Stack) \
1648 YYSIZE_T yynewbytes; \
1649 YYCOPY (&yyptr->Stack, Stack, yysize); \
1650 Stack = &yyptr->Stack; \
1651 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1652 yyptr += yynewbytes / sizeof (*yyptr); \
1658 /* YYFINAL -- State number of the termination state. */
1660 /* YYLAST -- Last index in YYTABLE. */
1663 /* YYNTOKENS -- Number of terminals. */
1664 #define YYNTOKENS 173
1665 /* YYNNTS -- Number of nonterminals. */
1667 /* YYNRULES -- Number of rules. */
1668 #define YYNRULES 348
1669 /* YYNRULES -- Number of states. */
1670 #define YYNSTATES 708
1672 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1673 #define YYUNDEFTOK 2
1674 #define YYMAXUTOK 413
1676 #define YYTRANSLATE(YYX) \
1677 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1679 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
1680 static const yytype_uint8 yytranslate[] =
1682 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1683 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1684 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1685 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1686 159, 160, 163, 2, 162, 2, 2, 2, 2, 2,
1687 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1688 168, 161, 169, 2, 2, 2, 2, 2, 2, 2,
1689 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1690 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1691 2, 165, 164, 167, 2, 2, 2, 2, 2, 172,
1692 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1693 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1694 166, 2, 2, 170, 2, 171, 2, 2, 2, 2,
1695 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1696 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1697 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1698 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1699 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1700 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1701 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1702 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1703 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1704 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1705 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1706 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1707 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1708 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1709 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1710 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1711 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1712 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1713 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1714 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
1715 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
1716 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
1717 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
1718 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
1719 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
1720 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
1721 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
1722 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
1727 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1729 static const yytype_uint16 yyprhs[] =
1731 0, 0, 3, 5, 7, 9, 11, 13, 15, 17,
1732 19, 21, 23, 25, 27, 29, 31, 33, 35, 37,
1733 39, 41, 43, 45, 47, 49, 51, 53, 55, 57,
1734 59, 61, 63, 65, 67, 69, 71, 73, 75, 77,
1735 79, 81, 83, 85, 87, 89, 91, 93, 95, 97,
1736 99, 101, 103, 105, 107, 109, 111, 113, 115, 117,
1737 118, 123, 124, 127, 128, 131, 133, 135, 137, 138,
1738 141, 143, 145, 147, 149, 151, 153, 155, 157, 159,
1739 160, 162, 164, 166, 167, 169, 171, 172, 174, 176,
1740 178, 180, 181, 183, 185, 186, 188, 190, 192, 194,
1741 196, 199, 201, 203, 205, 207, 209, 211, 213, 215,
1742 217, 220, 221, 224, 226, 228, 230, 231, 234, 236,
1743 238, 240, 242, 244, 246, 248, 250, 252, 254, 255,
1744 258, 259, 262, 263, 266, 267, 271, 274, 275, 277,
1745 278, 282, 284, 287, 289, 291, 293, 295, 297, 299,
1746 301, 303, 305, 309, 311, 314, 320, 326, 332, 338,
1747 342, 345, 351, 356, 359, 361, 363, 365, 369, 371,
1748 375, 377, 378, 380, 384, 389, 393, 397, 402, 407,
1749 411, 418, 424, 427, 430, 433, 436, 439, 442, 445,
1750 448, 451, 454, 457, 460, 467, 473, 482, 489, 496,
1751 504, 512, 520, 528, 535, 544, 553, 559, 567, 571,
1752 573, 575, 577, 579, 580, 583, 590, 592, 593, 595,
1753 598, 599, 603, 604, 608, 612, 616, 620, 621, 630,
1754 631, 641, 642, 652, 658, 661, 665, 667, 671, 675,
1755 679, 683, 685, 686, 692, 696, 698, 702, 704, 705,
1756 717, 719, 721, 726, 728, 730, 733, 737, 738, 740,
1757 742, 744, 746, 748, 750, 752, 754, 756, 758, 760,
1758 764, 768, 771, 774, 778, 781, 787, 792, 794, 800,
1759 802, 804, 806, 808, 810, 812, 815, 817, 821, 824,
1760 827, 831, 835, 838, 839, 841, 844, 847, 851, 861,
1761 871, 880, 896, 898, 900, 907, 913, 916, 919, 926,
1762 934, 939, 944, 951, 958, 959, 960, 964, 967, 971,
1763 974, 976, 982, 988, 995, 1002, 1009, 1016, 1021, 1028,
1764 1033, 1038, 1045, 1052, 1055, 1065, 1067, 1069, 1070, 1074,
1765 1081, 1085, 1092, 1095, 1101, 1109, 1115, 1120, 1125
1768 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1769 static const yytype_int16 yyrhs[] =
1771 220, 0, -1, 75, -1, 76, -1, 77, -1, 78,
1772 -1, 79, -1, 80, -1, 81, -1, 82, -1, 83,
1773 -1, 87, -1, 88, -1, 89, -1, 84, -1, 85,
1774 -1, 86, -1, 120, -1, 121, -1, 122, -1, 123,
1775 -1, 124, -1, 125, -1, 126, -1, 127, -1, 128,
1776 -1, 129, -1, 130, -1, 131, -1, 94, -1, 95,
1777 -1, 96, -1, 97, -1, 98, -1, 99, -1, 100,
1778 -1, 101, -1, 102, -1, 103, -1, 104, -1, 105,
1779 -1, 106, -1, 107, -1, 108, -1, 109, -1, 110,
1780 -1, 111, -1, 112, -1, 113, -1, 100, -1, 101,
1781 -1, 102, -1, 103, -1, 26, -1, 27, -1, 19,
1782 -1, 22, -1, 24, -1, 179, -1, -1, 55, 159,
1783 4, 160, -1, -1, 179, 161, -1, -1, 7, 161,
1784 -1, 20, -1, 23, -1, 186, -1, -1, 184, 161,
1785 -1, 42, -1, 44, -1, 43, -1, 45, -1, 47,
1786 -1, 49, -1, 46, -1, 48, -1, 51, -1, -1,
1787 156, -1, 157, -1, 158, -1, -1, 46, -1, 48,
1788 -1, -1, 42, -1, 43, -1, 44, -1, 47, -1,
1789 -1, 44, -1, 42, -1, -1, 63, -1, 64, -1,
1790 65, -1, 66, -1, 67, -1, 62, 4, -1, 142,
1791 -1, 121, -1, 141, -1, 122, -1, 144, -1, 145,
1792 -1, 147, -1, 148, -1, 149, -1, 54, 4, -1,
1793 -1, 195, 194, -1, 144, -1, 142, -1, 141, -1,
1794 -1, 197, 196, -1, 143, -1, 146, -1, 144, -1,
1795 142, -1, 141, -1, 150, -1, 151, -1, 154, -1,
1796 155, -1, 153, -1, -1, 199, 198, -1, -1, 152,
1797 22, -1, -1, 54, 4, -1, -1, 162, 54, 4,
1798 -1, 34, 22, -1, -1, 203, -1, -1, 162, 206,
1799 205, -1, 203, -1, 54, 4, -1, 11, -1, 12,
1800 -1, 13, -1, 16, -1, 15, -1, 14, -1, 17,
1801 -1, 50, -1, 207, -1, 208, 181, 163, -1, 242,
1802 -1, 164, 4, -1, 208, 159, 212, 160, 199, -1,
1803 10, 159, 212, 160, 199, -1, 165, 4, 166, 208,
1804 167, -1, 168, 4, 166, 208, 169, -1, 170, 213,
1805 171, -1, 170, 171, -1, 168, 170, 213, 171, 169,
1806 -1, 168, 170, 171, 169, -1, 208, 195, -1, 208,
1807 -1, 10, -1, 209, -1, 211, 162, 209, -1, 211,
1808 -1, 211, 162, 39, -1, 39, -1, -1, 208, -1,
1809 213, 162, 208, -1, 208, 165, 216, 167, -1, 208,
1810 165, 167, -1, 208, 172, 22, -1, 208, 168, 216,
1811 169, -1, 208, 170, 216, 171, -1, 208, 170, 171,
1812 -1, 208, 168, 170, 216, 171, 169, -1, 208, 168,
1813 170, 171, 169, -1, 208, 40, -1, 208, 41, -1,
1814 208, 242, -1, 208, 215, -1, 208, 25, -1, 208,
1815 3, -1, 208, 5, -1, 208, 4, -1, 208, 6,
1816 -1, 208, 26, -1, 208, 27, -1, 208, 9, -1,
1817 176, 159, 214, 38, 208, 160, -1, 119, 159, 214,
1818 254, 160, -1, 133, 159, 214, 162, 214, 162, 214,
1819 160, -1, 174, 159, 214, 162, 214, 160, -1, 175,
1820 159, 214, 162, 214, 160, -1, 90, 177, 159, 214,
1821 162, 214, 160, -1, 91, 178, 159, 214, 162, 214,
1822 160, -1, 92, 177, 159, 214, 162, 214, 160, -1,
1823 93, 178, 159, 214, 162, 214, 160, -1, 135, 159,
1824 214, 162, 214, 160, -1, 136, 159, 214, 162, 214,
1825 162, 214, 160, -1, 137, 159, 214, 162, 214, 162,
1826 214, 160, -1, 139, 159, 214, 255, 160, -1, 140,
1827 159, 214, 162, 214, 255, 160, -1, 216, 162, 214,
1828 -1, 214, -1, 32, -1, 33, -1, 37, -1, -1,
1829 210, 242, -1, 125, 159, 219, 38, 208, 160, -1,
1830 221, -1, -1, 222, -1, 221, 222, -1, -1, 31,
1831 223, 238, -1, -1, 30, 224, 239, -1, 60, 59,
1832 228, -1, 182, 18, 208, -1, 182, 18, 10, -1,
1833 -1, 185, 189, 218, 217, 214, 181, 225, 205, -1,
1834 -1, 185, 187, 189, 218, 217, 214, 181, 226, 205,
1835 -1, -1, 185, 188, 189, 218, 217, 208, 181, 227,
1836 205, -1, 185, 189, 35, 192, 219, -1, 52, 229,
1837 -1, 56, 161, 230, -1, 22, -1, 53, 161, 22,
1838 -1, 68, 161, 22, -1, 165, 231, 167, -1, 231,
1839 162, 22, -1, 22, -1, -1, 232, 162, 208, 195,
1840 180, -1, 208, 195, 180, -1, 232, -1, 232, 162,
1841 39, -1, 39, -1, -1, 193, 197, 210, 184, 159,
1842 233, 160, 199, 204, 201, 200, -1, 28, -1, 170,
1843 -1, 191, 189, 234, 235, -1, 29, -1, 171, -1,
1844 246, 237, -1, 190, 189, 234, -1, -1, 61, -1,
1845 3, -1, 4, -1, 5, -1, 6, -1, 9, -1,
1846 26, -1, 27, -1, 40, -1, 41, -1, 25, -1,
1847 168, 216, 169, -1, 165, 216, 167, -1, 165, 167,
1848 -1, 172, 22, -1, 170, 216, 171, -1, 170, 171,
1849 -1, 168, 170, 216, 171, 169, -1, 168, 170, 171,
1850 169, -1, 215, -1, 59, 240, 22, 162, 22, -1,
1851 7, -1, 8, -1, 179, -1, 184, -1, 242, -1,
1852 241, -1, 208, 243, -1, 244, -1, 245, 162, 244,
1853 -1, 246, 247, -1, 236, 247, -1, 248, 182, 249,
1854 -1, 248, 183, 249, -1, 248, 251, -1, -1, 21,
1855 -1, 69, 245, -1, 69, 10, -1, 70, 17, 243,
1856 -1, 70, 11, 243, 162, 17, 243, 162, 17, 243,
1857 -1, 71, 11, 243, 162, 17, 243, 165, 250, 167,
1858 -1, 71, 11, 243, 162, 17, 243, 165, 167, -1,
1859 72, 193, 197, 210, 243, 159, 253, 160, 199, 38,
1860 17, 243, 73, 17, 243, -1, 73, -1, 74, -1,
1861 250, 11, 241, 162, 17, 243, -1, 11, 241, 162,
1862 17, 243, -1, 182, 257, -1, 183, 257, -1, 208,
1863 165, 243, 162, 243, 167, -1, 252, 162, 165, 243,
1864 162, 243, 167, -1, 208, 195, 243, 195, -1, 17,
1865 195, 243, 195, -1, 253, 162, 208, 195, 243, 195,
1866 -1, 253, 162, 17, 195, 243, 195, -1, -1, -1,
1867 254, 162, 244, -1, 162, 4, -1, 255, 162, 4,
1868 -1, 58, 57, -1, 57, -1, 174, 208, 243, 162,
1869 243, -1, 175, 208, 243, 162, 243, -1, 90, 177,
1870 208, 243, 162, 243, -1, 91, 178, 208, 243, 162,
1871 243, -1, 92, 177, 208, 243, 162, 243, -1, 93,
1872 178, 208, 243, 162, 243, -1, 176, 244, 38, 208,
1873 -1, 133, 244, 162, 244, 162, 244, -1, 134, 244,
1874 162, 208, -1, 135, 244, 162, 244, -1, 136, 244,
1875 162, 244, 162, 244, -1, 137, 244, 162, 244, 162,
1876 244, -1, 132, 252, -1, 256, 193, 197, 210, 243,
1877 159, 253, 160, 199, -1, 259, -1, 36, -1, -1,
1878 114, 208, 202, -1, 114, 208, 162, 11, 243, 202,
1879 -1, 115, 208, 202, -1, 115, 208, 162, 11, 243,
1880 202, -1, 116, 244, -1, 258, 117, 208, 243, 202,
1881 -1, 258, 118, 244, 162, 208, 243, 202, -1, 138,
1882 208, 243, 162, 4, -1, 119, 208, 243, 254, -1,
1883 139, 208, 243, 255, -1, 140, 208, 243, 162, 208,
1887 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1888 static const yytype_uint16 yyrline[] =
1890 0, 1146, 1146, 1146, 1146, 1146, 1146, 1146, 1146, 1146,
1891 1146, 1147, 1147, 1147, 1147, 1147, 1147, 1148, 1148, 1148,
1892 1148, 1148, 1148, 1149, 1149, 1149, 1149, 1149, 1149, 1152,
1893 1152, 1153, 1153, 1154, 1154, 1155, 1155, 1156, 1156, 1160,
1894 1160, 1161, 1161, 1162, 1162, 1163, 1163, 1164, 1164, 1165,
1895 1165, 1166, 1166, 1167, 1168, 1171, 1171, 1171, 1172, 1172,
1896 1174, 1175, 1179, 1183, 1188, 1194, 1194, 1196, 1197, 1202,
1897 1208, 1209, 1210, 1211, 1212, 1213, 1217, 1218, 1219, 1223,
1898 1224, 1225, 1226, 1230, 1231, 1232, 1236, 1237, 1238, 1239,
1899 1240, 1244, 1245, 1246, 1249, 1250, 1251, 1252, 1253, 1254,
1900 1255, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270,
1901 1271, 1275, 1276, 1281, 1282, 1283, 1286, 1287, 1293, 1294,
1902 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1305, 1306,
1903 1312, 1313, 1320, 1321, 1327, 1328, 1337, 1345, 1346, 1351,
1904 1352, 1353, 1358, 1371, 1371, 1371, 1371, 1371, 1371, 1371,
1905 1374, 1378, 1382, 1389, 1394, 1402, 1437, 1468, 1473, 1483,
1906 1493, 1497, 1507, 1514, 1523, 1530, 1535, 1540, 1547, 1548,
1907 1555, 1562, 1570, 1576, 1588, 1616, 1632, 1659, 1687, 1713,
1908 1733, 1759, 1779, 1791, 1798, 1864, 1874, 1884, 1895, 1908,
1909 1919, 1933, 1940, 1947, 1965, 1977, 1998, 2006, 2012, 2023,
1910 2028, 2033, 2038, 2043, 2049, 2055, 2061, 2069, 2080, 2084,
1911 2092, 2092, 2095, 2095, 2098, 2110, 2131, 2136, 2144, 2145,
1912 2149, 2149, 2153, 2153, 2156, 2159, 2183, 2195, 2194, 2206,
1913 2205, 2215, 2214, 2225, 2265, 2268, 2274, 2284, 2288, 2293,
1914 2295, 2300, 2305, 2314, 2324, 2335, 2339, 2348, 2357, 2362,
1915 2511, 2511, 2513, 2522, 2522, 2524, 2529, 2541, 2545, 2550,
1916 2554, 2558, 2563, 2568, 2572, 2576, 2580, 2584, 2588, 2592,
1917 2614, 2636, 2642, 2655, 2667, 2672, 2684, 2690, 2694, 2704,
1918 2708, 2712, 2717, 2724, 2724, 2730, 2739, 2744, 2749, 2753,
1919 2762, 2771, 2784, 2793, 2797, 2805, 2825, 2829, 2834, 2845,
1920 2864, 2873, 2977, 2981, 2988, 2999, 3012, 3021, 3034, 3045,
1921 3055, 3066, 3074, 3084, 3091, 3094, 3095, 3103, 3109, 3118,
1922 3122, 3127, 3143, 3160, 3172, 3184, 3198, 3212, 3224, 3245,
1923 3252, 3258, 3264, 3270, 3285, 3395, 3400, 3404, 3411, 3418,
1924 3428, 3435, 3445, 3453, 3467, 3484, 3498, 3513, 3528
1928 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1929 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1930 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1931 static const char *const yytname[] =
1933 "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "ESAPINTVAL",
1934 "EUAPINTVAL", "LOCALVAL_ID", "GLOBALVAL_ID", "FPVAL", "VOID", "INTTYPE",
1935 "FLOAT", "DOUBLE", "X86_FP80", "FP128", "PPC_FP128", "LABEL", "TYPE",
1936 "LOCALVAR", "GLOBALVAR", "LABELSTR", "STRINGCONSTANT",
1937 "ATSTRINGCONSTANT", "PCTSTRINGCONSTANT", "ZEROINITIALIZER", "TRUETOK",
1938 "FALSETOK", "BEGINTOK", "ENDTOK", "DECLARE", "DEFINE", "GLOBAL",
1939 "CONSTANT", "SECTION", "ALIAS", "VOLATILE", "THREAD_LOCAL", "TO",
1940 "DOTDOTDOT", "NULL_TOK", "UNDEF", "INTERNAL", "LINKONCE", "WEAK",
1941 "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "COMMON", "OPAQUE",
1942 "EXTERNAL", "TARGET", "TRIPLE", "ALIGN", "ADDRSPACE", "DEPLIBS", "CALL",
1943 "TAIL", "ASM_TOK", "MODULE", "SIDEEFFECT", "CC_TOK", "CCC_TOK",
1944 "FASTCC_TOK", "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK",
1945 "DATALAYOUT", "RET", "BR", "SWITCH", "INVOKE", "UNWIND", "UNREACHABLE",
1946 "ADD", "SUB", "MUL", "UDIV", "SDIV", "FDIV", "UREM", "SREM", "FREM",
1947 "AND", "OR", "XOR", "SHL", "LSHR", "ASHR", "ICMP", "FCMP", "VICMP",
1948 "VFCMP", "EQ", "NE", "SLT", "SGT", "SLE", "SGE", "ULT", "UGT", "ULE",
1949 "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD", "UNO", "UEQ",
1950 "UNE", "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE", "GETELEMENTPTR",
1951 "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT", "BITCAST", "UITOFP",
1952 "SITOFP", "FPTOUI", "FPTOSI", "INTTOPTR", "PTRTOINT", "PHI_TOK",
1953 "SELECT", "VAARG", "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR",
1954 "GETRESULT", "EXTRACTVALUE", "INSERTVALUE", "SIGNEXT", "ZEROEXT",
1955 "NORETURN", "INREG", "SRET", "NOUNWIND", "NOALIAS", "BYVAL", "NEST",
1956 "READNONE", "READONLY", "GC", "OPTSIZE", "NOINLINE", "ALWAYSINLINE",
1957 "DEFAULT", "HIDDEN", "PROTECTED", "'('", "')'", "'='", "','", "'*'",
1958 "'\\\\'", "'['", "'x'", "']'", "'<'", "'>'", "'{'", "'}'", "'c'",
1959 "$accept", "ArithmeticOps", "LogicalOps", "CastOps", "IPredicates",
1960 "FPredicates", "LocalName", "OptLocalName", "OptAddrSpace",
1961 "OptLocalAssign", "LocalNumber", "GlobalName", "OptGlobalAssign",
1962 "GlobalAssign", "GVInternalLinkage", "GVExternalLinkage",
1963 "GVVisibilityStyle", "FunctionDeclareLinkage", "FunctionDefineLinkage",
1964 "AliasLinkage", "OptCallingConv", "Attribute", "OptAttributes",
1965 "RetAttr", "OptRetAttrs", "FuncAttr", "OptFuncAttrs", "OptGC",
1966 "OptAlign", "OptCAlign", "SectionString", "OptSection",
1967 "GlobalVarAttributes", "GlobalVarAttribute", "PrimType", "Types",
1968 "ArgType", "ResultTypes", "ArgTypeList", "ArgTypeListI", "TypeListI",
1969 "ConstVal", "ConstExpr", "ConstVector", "GlobalType", "ThreadLocal",
1970 "AliaseeRef", "Module", "DefinitionList", "Definition", "@1", "@2", "@3",
1971 "@4", "@5", "AsmBlock", "TargetDefinition", "LibrariesDefinition",
1972 "LibList", "ArgListH", "ArgList", "FunctionHeaderH", "BEGIN",
1973 "FunctionHeader", "END", "Function", "FunctionProto", "OptSideEffect",
1974 "ConstValueRef", "SymbolicValueRef", "ValueRef", "ResolvedVal",
1975 "ReturnedVal", "BasicBlockList", "BasicBlock", "InstructionList",
1976 "BBTerminatorInst", "JumpTable", "Inst", "PHIList", "ParamList",
1977 "IndexList", "ConstantIndexList", "OptTailCall", "InstVal",
1978 "OptVolatile", "MemoryInst", 0
1983 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1985 static const yytype_uint16 yytoknum[] =
1987 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1988 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1989 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1990 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1991 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1992 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1993 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
1994 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
1995 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
1996 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
1997 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
1998 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
1999 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
2000 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
2001 395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
2002 405, 406, 407, 408, 409, 410, 411, 412, 413, 40,
2003 41, 61, 44, 42, 92, 91, 120, 93, 60, 62,
2008 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
2009 static const yytype_uint16 yyr1[] =
2011 0, 173, 174, 174, 174, 174, 174, 174, 174, 174,
2012 174, 175, 175, 175, 175, 175, 175, 176, 176, 176,
2013 176, 176, 176, 176, 176, 176, 176, 176, 176, 177,
2014 177, 177, 177, 177, 177, 177, 177, 177, 177, 178,
2015 178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
2016 178, 178, 178, 178, 178, 179, 179, 179, 180, 180,
2017 181, 181, 182, 182, 183, 184, 184, 185, 185, 186,
2018 187, 187, 187, 187, 187, 187, 188, 188, 188, 189,
2019 189, 189, 189, 190, 190, 190, 191, 191, 191, 191,
2020 191, 192, 192, 192, 193, 193, 193, 193, 193, 193,
2021 193, 194, 194, 194, 194, 194, 194, 194, 194, 194,
2022 194, 195, 195, 196, 196, 196, 197, 197, 198, 198,
2023 198, 198, 198, 198, 198, 198, 198, 198, 199, 199,
2024 200, 200, 201, 201, 202, 202, 203, 204, 204, 205,
2025 205, 206, 206, 207, 207, 207, 207, 207, 207, 207,
2026 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
2027 208, 208, 208, 209, 210, 210, 211, 211, 212, 212,
2028 212, 212, 213, 213, 214, 214, 214, 214, 214, 214,
2029 214, 214, 214, 214, 214, 214, 214, 214, 214, 214,
2030 214, 214, 214, 214, 215, 215, 215, 215, 215, 215,
2031 215, 215, 215, 215, 215, 215, 215, 215, 216, 216,
2032 217, 217, 218, 218, 219, 219, 220, 220, 221, 221,
2033 223, 222, 224, 222, 222, 222, 222, 225, 222, 226,
2034 222, 227, 222, 222, 222, 222, 228, 229, 229, 230,
2035 231, 231, 231, 232, 232, 233, 233, 233, 233, 234,
2036 235, 235, 236, 237, 237, 238, 239, 240, 240, 241,
2037 241, 241, 241, 241, 241, 241, 241, 241, 241, 241,
2038 241, 241, 241, 241, 241, 241, 241, 241, 241, 242,
2039 242, 242, 242, 243, 243, 244, 245, 245, 246, 246,
2040 247, 247, 248, 248, 248, 249, 249, 249, 249, 249,
2041 249, 249, 249, 249, 250, 250, 251, 251, 252, 252,
2042 253, 253, 253, 253, 253, 254, 254, 255, 255, 256,
2043 256, 257, 257, 257, 257, 257, 257, 257, 257, 257,
2044 257, 257, 257, 257, 257, 257, 258, 258, 259, 259,
2045 259, 259, 259, 259, 259, 259, 259, 259, 259
2048 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
2049 static const yytype_uint8 yyr2[] =
2051 0, 2, 1, 1, 1, 1, 1, 1, 1, 1,
2052 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2053 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2054 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2055 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2056 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
2057 4, 0, 2, 0, 2, 1, 1, 1, 0, 2,
2058 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
2059 1, 1, 1, 0, 1, 1, 0, 1, 1, 1,
2060 1, 0, 1, 1, 0, 1, 1, 1, 1, 1,
2061 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2062 2, 0, 2, 1, 1, 1, 0, 2, 1, 1,
2063 1, 1, 1, 1, 1, 1, 1, 1, 0, 2,
2064 0, 2, 0, 2, 0, 3, 2, 0, 1, 0,
2065 3, 1, 2, 1, 1, 1, 1, 1, 1, 1,
2066 1, 1, 3, 1, 2, 5, 5, 5, 5, 3,
2067 2, 5, 4, 2, 1, 1, 1, 3, 1, 3,
2068 1, 0, 1, 3, 4, 3, 3, 4, 4, 3,
2069 6, 5, 2, 2, 2, 2, 2, 2, 2, 2,
2070 2, 2, 2, 2, 6, 5, 8, 6, 6, 7,
2071 7, 7, 7, 6, 8, 8, 5, 7, 3, 1,
2072 1, 1, 1, 0, 2, 6, 1, 0, 1, 2,
2073 0, 3, 0, 3, 3, 3, 3, 0, 8, 0,
2074 9, 0, 9, 5, 2, 3, 1, 3, 3, 3,
2075 3, 1, 0, 5, 3, 1, 3, 1, 0, 11,
2076 1, 1, 4, 1, 1, 2, 3, 0, 1, 1,
2077 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
2078 3, 2, 2, 3, 2, 5, 4, 1, 5, 1,
2079 1, 1, 1, 1, 1, 2, 1, 3, 2, 2,
2080 3, 3, 2, 0, 1, 2, 2, 3, 9, 9,
2081 8, 15, 1, 1, 6, 5, 2, 2, 6, 7,
2082 4, 4, 6, 6, 0, 0, 3, 2, 3, 2,
2083 1, 5, 5, 6, 6, 6, 6, 4, 6, 4,
2084 4, 6, 6, 2, 9, 1, 1, 0, 3, 6,
2085 3, 6, 2, 5, 7, 5, 4, 4, 7
2088 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
2089 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
2090 means the default is an error. */
2091 static const yytype_uint16 yydefact[] =
2093 68, 55, 65, 56, 66, 57, 222, 220, 0, 0,
2094 0, 0, 0, 0, 79, 67, 0, 68, 218, 83,
2095 86, 0, 0, 234, 0, 0, 62, 0, 69, 70,
2096 72, 71, 73, 76, 74, 77, 75, 78, 80, 81,
2097 82, 79, 79, 213, 1, 219, 84, 85, 79, 223,
2098 87, 88, 89, 90, 79, 293, 221, 293, 0, 0,
2099 242, 235, 236, 224, 279, 280, 226, 143, 144, 145,
2100 148, 147, 146, 149, 150, 0, 0, 0, 0, 281,
2101 282, 151, 225, 153, 213, 213, 91, 212, 0, 94,
2102 94, 294, 289, 63, 253, 254, 255, 288, 237, 238,
2103 241, 0, 171, 154, 0, 0, 0, 0, 160, 172,
2104 0, 0, 171, 0, 0, 0, 93, 92, 0, 210,
2105 211, 0, 0, 95, 96, 97, 98, 99, 116, 256,
2106 0, 0, 337, 337, 292, 0, 239, 170, 111, 166,
2107 168, 0, 0, 0, 0, 0, 0, 159, 0, 0,
2108 152, 0, 0, 165, 0, 164, 0, 233, 61, 61,
2109 100, 0, 250, 251, 252, 64, 336, 320, 0, 0,
2110 0, 0, 94, 302, 303, 2, 3, 4, 5, 6,
2111 7, 8, 9, 10, 14, 15, 16, 11, 12, 13,
2112 0, 0, 0, 0, 0, 0, 0, 0, 17, 18,
2113 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
2114 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2115 0, 0, 290, 94, 306, 0, 335, 291, 307, 240,
2116 163, 0, 128, 61, 61, 162, 0, 173, 0, 128,
2117 61, 61, 0, 214, 187, 189, 188, 190, 193, 186,
2118 191, 192, 182, 183, 0, 0, 0, 0, 0, 0,
2119 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2120 0, 0, 185, 184, 227, 115, 114, 113, 117, 0,
2121 319, 296, 61, 286, 295, 0, 0, 0, 116, 29,
2122 30, 31, 32, 33, 34, 35, 36, 37, 38, 0,
2123 53, 54, 49, 50, 51, 52, 39, 40, 41, 42,
2124 43, 44, 45, 46, 47, 48, 0, 0, 0, 134,
2125 134, 342, 61, 61, 333, 0, 0, 0, 0, 0,
2126 61, 61, 61, 61, 61, 0, 116, 0, 0, 0,
2127 102, 104, 103, 101, 105, 106, 107, 108, 109, 112,
2128 169, 167, 156, 157, 158, 161, 60, 155, 229, 231,
2129 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2130 0, 0, 175, 209, 0, 0, 0, 179, 0, 176,
2131 0, 0, 0, 139, 0, 259, 260, 261, 262, 263,
2132 268, 264, 265, 266, 267, 257, 0, 0, 0, 0,
2133 277, 284, 283, 285, 0, 0, 297, 0, 0, 61,
2134 61, 61, 61, 0, 338, 0, 340, 315, 0, 0,
2135 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2136 0, 0, 61, 0, 110, 122, 121, 118, 120, 119,
2137 123, 124, 127, 125, 126, 129, 139, 139, 0, 0,
2138 0, 0, 0, 315, 0, 0, 0, 0, 0, 0,
2139 0, 174, 160, 172, 0, 177, 178, 0, 0, 0,
2140 0, 228, 248, 258, 0, 271, 0, 0, 0, 274,
2141 0, 272, 287, 0, 0, 0, 0, 0, 0, 0,
2142 0, 0, 0, 346, 0, 0, 0, 329, 330, 0,
2143 0, 0, 0, 347, 0, 0, 0, 327, 0, 134,
2144 0, 230, 232, 61, 0, 0, 0, 0, 0, 0,
2145 0, 0, 0, 0, 0, 208, 181, 0, 0, 0,
2146 0, 0, 0, 141, 139, 247, 111, 245, 0, 0,
2147 270, 160, 0, 269, 273, 0, 0, 0, 0, 0,
2148 0, 0, 134, 135, 134, 0, 0, 0, 0, 0,
2149 0, 345, 317, 0, 61, 321, 322, 0, 0, 343,
2150 61, 215, 0, 0, 0, 0, 195, 0, 0, 0,
2151 0, 206, 0, 180, 0, 0, 61, 136, 142, 140,
2152 59, 0, 128, 0, 276, 0, 0, 0, 314, 323,
2153 324, 325, 326, 339, 341, 316, 0, 0, 328, 331,
2154 332, 318, 0, 314, 134, 0, 0, 0, 0, 0,
2155 203, 0, 0, 0, 197, 198, 194, 58, 244, 246,
2156 111, 137, 278, 275, 0, 0, 111, 111, 0, 308,
2157 0, 348, 0, 344, 199, 200, 201, 202, 0, 0,
2158 0, 207, 59, 138, 132, 0, 0, 300, 0, 0,
2159 0, 128, 0, 309, 128, 196, 204, 205, 243, 0,
2160 130, 298, 0, 0, 299, 102, 104, 111, 111, 0,
2161 111, 111, 334, 133, 0, 249, 0, 0, 311, 310,
2162 0, 0, 0, 131, 0, 0, 0, 111, 111, 305,
2163 0, 0, 313, 312, 304, 0, 0, 301
2166 /* YYDEFGOTO[NTERM-NUM]. */
2167 static const yytype_int16 yydefgoto[] =
2169 -1, 269, 270, 271, 299, 316, 79, 628, 113, 12,
2170 133, 80, 14, 15, 41, 42, 43, 48, 54, 118,
2171 128, 349, 230, 278, 161, 445, 352, 685, 670, 414,
2172 533, 654, 471, 534, 81, 158, 139, 156, 140, 141,
2173 110, 373, 400, 374, 121, 88, 157, 16, 17, 18,
2174 20, 19, 383, 446, 447, 63, 23, 61, 101, 537,
2175 538, 129, 164, 55, 96, 56, 49, 474, 401, 83,
2176 403, 283, 284, 57, 92, 93, 222, 658, 134, 324,
2177 638, 493, 503, 223, 224, 225, 226
2180 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
2182 #define YYPACT_NINF -624
2183 static const yytype_int16 yypact[] =
2185 815, -624, -624, -624, -624, -624, -624, -624, 14, -114,
2186 16, -73, 78, -31, 299, -624, 163, 2187, -624, 164,
2187 80, 19, 22, -624, 2, 179, -624, 1912, -624, -624,
2188 -624, -624, -624, -624, -624, -624, -624, -624, -624, -624,
2189 -624, 68, 68, 201, -624, -624, -624, -624, 68, -624,
2190 -624, -624, -624, -624, 68, 200, -624, 5, 215, 222,
2191 225, -624, -624, -624, -624, -624, 117, -624, -624, -624,
2192 -624, -624, -624, -624, -624, 264, 277, 7, 49, -624,
2193 -624, -624, -12, -624, 252, 252, 198, -624, 79, 231,
2194 231, -624, -624, 83, -624, -624, -624, -624, -624, -624,
2195 -624, -21, 649, -624, 138, 149, 627, 117, -624, -12,
2196 -120, 159, 649, 158, 79, 79, -624, -624, 1557, -624,
2197 -624, 2012, 320, -624, -624, -624, -624, -624, -624, -624,
2198 -13, 173, 2237, 2237, -624, 313, -624, -624, -12, -624,
2199 174, 177, 2012, 2012, 169, -118, 2012, -624, 336, 191,
2200 -624, 2012, 2012, 117, 193, -12, 226, -624, 1296, 308,
2201 -624, 1516, -624, -624, -624, -624, -624, -624, 307, 2031,
2202 108, 357, 231, -624, -624, -624, -624, -624, -624, -624,
2203 -624, -624, -624, -624, -624, -624, -624, -624, -624, -624,
2204 454, 958, 454, 958, 2012, 2012, 2012, 2012, -624, -624,
2205 -624, -624, -624, -624, -624, -624, -624, -624, -624, -624,
2206 2012, 2012, 2012, 2012, 2012, 2012, 2012, 2012, 2012, 2012,
2207 2012, 2012, -624, 231, -624, 55, -624, -624, -624, -624,
2208 161, 1748, -624, -23, -41, -624, 203, -12, 214, -624,
2209 308, -20, 1557, -624, -624, -624, -624, -624, -624, -624,
2210 -624, -624, -624, -624, 454, 958, 454, 958, 216, 217,
2211 218, 220, 221, 224, 227, 1789, 2076, 732, 351, 228,
2212 229, 230, -624, -624, -624, -624, -624, -624, -624, 109,
2213 -624, 117, 956, -624, 219, 1466, 1466, 1466, -624, -624,
2214 -624, -624, -624, -624, -624, -624, -624, -624, -624, 2012,
2215 -624, -624, -624, -624, -624, -624, -624, -624, -624, -624,
2216 -624, -624, -624, -624, -624, -624, 2012, 2012, 2012, -10,
2217 3, -624, 956, -17, 223, 237, 238, 239, 240, 241,
2218 956, 956, 956, 956, 956, 352, -624, 2012, 2012, 387,
2219 -624, -624, -624, -624, -624, -624, -624, -624, -624, -624,
2220 -624, -624, 539, -624, -624, -624, -624, 539, -624, 158,
2221 354, 234, 248, 249, 250, 2012, 2012, 2012, 2012, 2012,
2222 2012, 2012, -624, -624, 42, 1006, -121, -624, -116, -624,
2223 2012, 2012, 2012, 253, 251, -624, -624, -624, -624, -624,
2224 -624, -624, -624, -624, -624, 353, 1807, 2094, 1175, 390,
2225 -624, -624, -624, -624, 2012, 255, -624, 256, 1516, 956,
2226 956, 956, 956, 20, -624, 29, -624, -624, 1466, 254,
2227 2012, 2012, 2012, 2012, 2012, 258, 259, 261, 262, 263,
2228 2012, 1516, 956, 266, -624, -624, -624, -624, -624, -624,
2229 -624, -624, -624, -624, -624, -624, 253, 253, 2012, 2012,
2230 2012, 2012, 2012, -624, 269, 270, 272, 273, 259, 274,
2231 2012, -624, 268, 1126, -84, -624, -624, 280, 281, 406,
2232 -5, -624, 1830, -624, 423, -624, 61, 1345, -56, -624,
2233 -77, -624, -624, 430, 431, 1466, 288, 290, 291, 292,
2234 1466, 455, 1466, 296, 298, 1466, 300, -12, -624, 301,
2235 302, 457, 461, 306, 2012, 1466, 1466, -12, 1466, 311,
2236 2012, -624, -624, -1, 312, 314, 317, 319, 101, 2012,
2237 2012, 2012, 2012, 112, 2012, -624, -624, 318, 2012, 2012,
2238 2012, 453, 478, -624, 253, -624, -12, 321, 326, 327,
2239 -624, 323, -67, -624, -624, 1466, 1466, 329, 1466, 1466,
2240 1466, 1466, 311, -624, 311, 2012, 1466, 328, 2012, 2012,
2241 2012, -624, -624, 489, 956, -624, -624, 335, 441, -624,
2242 956, -624, 2012, 2012, 2012, 2012, -624, 334, 337, 339,
2243 340, -624, 259, -624, 343, 345, 15, -624, -624, -624,
2244 178, 1848, -624, 484, -624, 338, 350, 349, 2117, -624,
2245 -624, -624, -624, -624, -624, -624, 348, 1466, -624, -624,
2246 -624, -624, 259, 2117, 311, 356, 359, 360, 361, 2012,
2247 -624, 2012, 2012, 115, -624, -624, -624, -624, -624, -624,
2248 -12, 116, -624, -624, 505, -7, 59, -12, 118, -624,
2249 358, 306, 124, -624, -624, -624, -624, -624, 363, 364,
2250 366, -624, 178, -624, 473, 1466, 1614, -624, -6, 802,
2251 802, -624, 2135, -624, -624, -624, -624, -624, -624, 526,
2252 379, -624, 374, 1614, -624, 378, 380, -624, -624, 442,
2253 59, -12, 539, -624, 516, -624, 523, 396, 161, 161,
2254 524, 802, 802, -624, 1466, 525, 1466, -624, -624, -624,
2255 1466, 486, 161, 161, -624, 543, 1466, -624
2258 /* YYPGOTO[NTERM-NUM]. */
2259 static const yytype_int16 yypgoto[] =
2261 -624, 132, 155, 181, -165, -154, 0, -86, -143, 474,
2262 -624, 6, -624, -624, -624, -624, 67, -624, -624, -624,
2263 -142, -624, -499, -624, -252, -624, -231, -624, -624, -313,
2264 -63, -624, -434, -624, -624, -26, 342, -152, -624, 458,
2265 463, -11, -156, -242, 202, 244, 332, -624, -624, 554,
2266 -624, -624, -624, -624, -624, -624, -624, -624, -624, -624,
2267 -624, 485, -624, -624, -624, -624, -624, -624, -623, -79,
2268 213, -193, -624, -624, 520, -624, 445, -624, -624, -624,
2269 -34, 129, -448, -624, 456, -624, -624
2272 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
2273 positive, shift that token. If negative, reduce the rule which
2274 number is the opposite. If zero, do what YYDEFACT says.
2275 If YYTABLE_NINF, syntax error. */
2276 #define YYTABLE_NINF -218
2277 static const yytype_int16 yytable[] =
2279 11, 82, 272, 321, 656, 673, 13, 416, 357, 279,
2280 523, 105, 511, 512, 111, 162, 274, 11, 325, 326,
2281 327, 328, 329, 13, 376, 378, 91, 317, 335, 531,
2282 288, 490, 111, 672, 94, 111, 408, 590, 111, 318,
2283 492, 460, 146, 111, 146, 111, 460, 24, 465, 532,
2284 687, 147, 109, 236, 111, 466, 64, 65, 111, 107,
2285 67, 68, 69, 70, 71, 72, 73, 21, 1, 2,
2286 111, 3, 4, 5, 491, 25, 138, 243, 460, 273,
2287 109, 336, 22, 491, 431, 460, 138, 527, 26, 361,
2288 131, 363, 155, 11, 544, 460, 27, 358, 359, 74,
2289 589, 362, 1, 364, 595, 3, 460, 5, 84, 85,
2290 159, 119, 120, 543, -149, 89, 233, 234, 112, 285,
2291 237, 90, 50, 51, 52, 286, 241, 53, 354, 2,
2292 28, 652, 4, 464, 623, 155, 112, 659, 660, 112,
2293 240, 135, 112, 282, 353, 433, 136, 112, 418, 112,
2294 531, -61, 413, -61, 476, 478, 480, 163, 112, 571,
2295 657, 674, 112, 44, 641, 415, -61, 60, 319, 320,
2296 282, 322, 337, 338, 112, 626, 95, 106, 688, 689,
2297 58, 691, 692, 59, 323, 282, 282, 282, 282, 282,
2298 330, 331, 332, 333, 334, 282, 569, 1, 702, 703,
2299 3, 62, 5, 402, 460, 138, 402, 402, 402, 461,
2300 46, 482, 47, 75, 76, 339, 155, 77, -149, 78,
2301 108, 91, -149, 460, 38, 39, 40, 496, 540, 498,
2302 499, 500, 339, 64, 65, 542, 86, 98, 87, 603,
2303 116, 604, 117, 402, 99, 1, 2, 100, 3, 4,
2304 5, 402, 402, 402, 402, 402, 485, 435, 436, 437,
2305 438, 576, 439, 555, 219, 219, 440, 441, 103, 442,
2306 443, 444, 581, 409, 563, 651, 102, 563, 661, 508,
2307 662, 104, 340, 341, 664, 384, 662, 220, 220, 87,
2308 410, 411, 412, 122, 123, 124, 125, 126, 127, 340,
2309 341, 643, 342, 343, 142, 344, 345, 272, 346, 347,
2310 348, 432, 282, 221, 221, 143, 151, 152, 148, 342,
2311 343, 150, 344, 345, 160, 346, 347, 348, 114, 115,
2312 402, 402, 402, 402, 165, 229, 231, 232, 235, 402,
2313 238, 29, 30, 31, 32, 33, 34, 35, 36, 463,
2314 37, 239, 242, 402, 453, 454, 455, 456, 457, 458,
2315 459, 631, 605, 111, 280, 608, 609, 610, 287, 467,
2316 468, 469, 355, 379, 356, 365, 366, 367, 282, 368,
2317 369, 404, 155, 370, 273, 419, 371, 380, 381, 382,
2318 430, 434, 448, 449, 282, 497, 282, 282, 282, 420,
2319 421, 422, 423, 424, 507, 155, 402, 450, 451, 452,
2320 472, 402, 481, 402, 473, 470, 402, 483, 484, 495,
2321 501, 502, 513, 504, 505, 506, 402, 402, 510, 402,
2322 679, 519, 520, 682, 521, 522, 524, 526, 514, 515,
2323 516, 517, 528, 529, 530, 539, 536, 545, 546, 525,
2324 548, 463, 549, 550, 551, 38, 39, 40, 555, 553,
2325 556, 561, 558, 559, 560, 562, 402, 402, 563, 402,
2326 402, 402, 402, 568, 572, 587, 573, 402, 564, 574,
2327 690, 575, 588, 591, 570, 402, 592, 583, 598, 593,
2328 607, 402, 594, 611, 613, 491, 619, 620, 405, 406,
2329 407, 621, 622, 624, 586, 625, 632, 633, 577, 578,
2330 579, 580, 634, 582, 635, 639, 644, 584, 585, 645,
2331 646, 647, 655, 665, 666, 663, 667, 669, 402, 282,
2332 683, 684, 282, 282, 282, 417, 686, -18, 693, -19,
2333 694, 696, 700, 425, 426, 427, 428, 429, 289, 290,
2334 291, 292, 293, 294, 295, 296, 297, 298, 695, 705,
2335 706, 615, 616, 617, 618, 630, 668, 132, 653, 145,
2336 149, 45, 637, 351, 360, 130, 402, 97, 227, 642,
2337 402, 402, 518, 435, 436, 437, 438, 637, 439, 228,
2338 627, 0, 440, 441, 0, 442, 443, 444, 0, 0,
2339 0, 0, 0, 0, 0, 0, 0, 0, 648, 0,
2340 649, 650, 402, 402, 0, 402, 0, 402, 0, 0,
2341 0, 402, 486, 487, 488, 489, 0, 402, 0, 0,
2342 0, 494, 0, 0, 64, 65, 681, 107, 67, 68,
2343 69, 70, 71, 72, 73, 509, 1, 2, 0, 3,
2344 4, 5, 627, 0, 0, 0, 64, 65, 0, 107,
2345 67, 68, 69, 70, 71, 72, 73, 0, 1, 2,
2346 0, 3, 4, 5, 0, 0, 0, 74, 0, 0,
2347 435, 436, 437, 438, 0, 439, 0, 0, 137, 440,
2348 441, 0, 442, 443, 444, 0, 0, 0, 547, 74,
2349 0, 0, 0, 552, 0, 554, 0, 0, 557, 0,
2350 0, 0, 0, 0, 0, 0, 0, 0, 565, 566,
2351 0, 567, 0, 0, 0, 0, 0, 0, 0, 0,
2352 0, 0, 0, 0, 0, 0, 0, 0, 0, 64,
2353 65, 0, 107, 67, 68, 69, 70, 71, 72, 73,
2354 0, 1, 2, 0, 3, 4, 5, 0, 596, 597,
2355 0, 599, 600, 601, 602, 0, 0, 0, 0, 606,
2356 0, 0, 0, 0, 0, 0, 0, 612, 0, 0,
2357 0, 0, 74, 614, 0, 0, 0, 0, 0, 0,
2358 0, 75, 76, 0, 0, 77, 0, 78, 144, 0,
2359 0, 0, 0, 0, 0, 385, 386, 387, 388, 64,
2360 65, 389, 0, 75, 76, -217, 0, 77, 0, 78,
2361 640, 1, 2, 0, 3, 4, 5, 390, 391, 392,
2362 0, 0, 0, -63, 1, 2, 0, 3, 4, 5,
2363 0, 0, 393, 394, 0, 6, 7, 0, 0, 0,
2364 0, 0, 0, 0, 0, 0, 339, 0, 0, 0,
2365 0, 395, 0, 0, 0, 0, 0, 8, 671, 0,
2366 0, 9, 677, 678, 0, 10, 0, 175, 176, 177,
2367 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,
2368 188, 189, 254, 255, 256, 257, 75, 76, 0, 0,
2369 77, 0, 78, 377, 697, 698, 0, 699, 0, 701,
2370 0, 0, 0, 704, 0, 0, 0, 0, 0, 707,
2371 0, 258, 198, 675, 676, 201, 202, 203, 204, 205,
2372 206, 207, 208, 209, 0, 259, 0, 260, 261, 262,
2373 0, 263, 264, 342, 343, 0, 344, 345, 0, 346,
2374 347, 348, 0, 0, 0, 0, 0, 0, 0, 385,
2375 386, 387, 388, 64, 65, 389, 0, 396, 0, 0,
2376 397, 0, 398, 0, 399, 1, 2, 0, 3, 4,
2377 5, 390, 391, 392, 300, 301, 0, 0, 0, 0,
2378 0, 0, 0, 0, 0, 0, 393, 394, 0, 0,
2379 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2380 0, 111, 0, 64, 65, 395, 107, 67, 68, 69,
2381 70, 71, 72, 73, 0, 1, 2, 0, 3, 4,
2382 5, 175, 176, 177, 178, 179, 180, 181, 182, 183,
2383 184, 185, 186, 187, 188, 189, 254, 255, 256, 257,
2384 0, 0, 0, 0, 0, 0, 74, 0, 302, 303,
2385 304, 305, 306, 307, 308, 309, 310, 311, 312, 313,
2386 314, 315, 0, 0, 0, 258, 198, 199, 200, 201,
2387 202, 203, 204, 205, 206, 207, 208, 209, 0, 259,
2388 0, 260, 261, 262, 0, 263, 264, 0, 0, 0,
2389 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2390 0, 0, 0, 0, 0, 112, 0, 0, 0, 0,
2391 0, 396, 0, 0, 397, 0, 398, 0, 399, 244,
2392 245, 246, 247, 64, 65, 248, 0, 0, 0, 0,
2393 0, 0, 0, 0, 0, 1, 2, 0, 3, 4,
2394 5, 249, 250, 251, 0, 0, 0, 0, 0, 0,
2395 0, 0, 0, 0, 0, 0, 252, 253, 0, 0,
2396 75, 76, 0, 0, 77, 0, 78, 462, 0, 0,
2397 0, 111, 64, 65, 0, 107, 67, 68, 69, 70,
2398 71, 72, 73, 0, 1, 2, 0, 3, 4, 5,
2399 0, 175, 176, 177, 178, 179, 180, 181, 182, 183,
2400 184, 185, 186, 187, 188, 189, 254, 255, 256, 257,
2401 0, 0, 0, 0, 0, 74, 0, 0, 0, 0,
2402 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2403 0, 0, 0, 0, 0, 258, 198, 199, 200, 201,
2404 202, 203, 204, 205, 206, 207, 208, 209, 0, 259,
2405 0, 260, 261, 262, 0, 263, 264, 0, 0, 0,
2406 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2407 0, 0, 0, 0, 0, 112, 0, 0, 0, -61,
2408 0, 265, 0, 0, 266, 0, 267, 0, 268, 244,
2409 245, 246, 247, 64, 65, 248, 0, 0, 0, 0,
2410 0, 0, 0, 0, 0, 1, 2, 0, 3, 4,
2411 5, 249, 250, 251, 0, 0, 0, 0, 0, 0,
2412 0, 0, 0, 0, 0, 0, 252, 253, 0, 75,
2413 76, 0, 0, 77, 0, 78, 479, 0, 0, 0,
2414 0, 111, 64, 65, 0, 107, 67, 68, 69, 70,
2415 71, 72, 73, 0, 1, 2, 0, 3, 4, 5,
2416 0, 175, 176, 177, 178, 179, 180, 181, 182, 183,
2417 184, 185, 186, 187, 188, 189, 254, 255, 256, 257,
2418 0, 0, 0, 0, 0, 74, 0, 0, 0, 0,
2419 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2420 0, 0, 0, 0, 0, 258, 198, 199, 200, 201,
2421 202, 203, 204, 205, 206, 207, 208, 209, 0, 259,
2422 0, 260, 261, 262, 0, 263, 264, 0, 0, 0,
2423 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2424 0, 0, 0, 0, 0, 112, 0, 0, 0, 0,
2425 0, 265, 0, 0, 266, 0, 267, 0, 268, 385,
2426 386, 387, 388, 64, 65, 389, 0, 0, 0, 0,
2427 0, 0, 0, 0, 0, 1, 2, 0, 3, 4,
2428 5, 390, 391, 392, 0, 0, 0, 0, 0, 0,
2429 0, 0, 0, 0, 0, 0, 393, 394, 0, 75,
2430 76, 0, 0, 77, 0, 78, 541, 0, 0, 0,
2431 0, 0, 0, 64, 65, 395, 153, 67, 68, 69,
2432 70, 71, 72, 73, 0, 1, 2, 0, 3, 4,
2433 5, 175, 176, 177, 178, 179, 180, 181, 182, 183,
2434 184, 185, 186, 187, 188, 189, 254, 255, 256, 257,
2435 0, 0, 0, 0, 64, 65, 74, 153, 67, 68,
2436 69, 70, 71, 72, 73, 0, 1, 2, 0, 3,
2437 4, 5, 0, 0, 0, 258, 198, 199, 200, 201,
2438 202, 203, 204, 205, 206, 207, 208, 209, 0, 259,
2439 0, 260, 261, 262, 0, 263, 264, 74, 0, 0,
2440 0, 0, 0, 0, 0, 0, 0, 385, 386, 387,
2441 388, 0, 0, 389, 0, 0, 0, 0, 0, 0,
2442 0, 396, 0, 0, 397, 0, 398, 0, 399, 390,
2443 391, 392, 0, 0, 0, 0, 0, 0, 0, 0,
2444 0, 0, 0, 0, 393, 394, 0, 275, 276, 0,
2445 277, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2446 0, 0, 0, 395, 0, 0, 0, 0, 0, 0,
2447 75, 76, 154, 0, 77, 0, 78, 0, 0, 175,
2448 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
2449 186, 187, 188, 189, 254, 255, 256, 257, 0, 0,
2450 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2451 0, 75, 76, 0, 0, 77, 0, 78, 0, 0,
2452 0, 0, 0, 258, 198, 199, 200, 201, 202, 203,
2453 204, 205, 206, 207, 208, 209, 0, 259, 0, 260,
2454 261, 262, 0, 263, 264, 64, 65, 0, 107, 67,
2455 68, 69, 70, 71, 72, 73, 0, 1, 2, 0,
2456 3, 4, 5, 0, 0, 0, 0, 0, 0, 396,
2457 0, 0, 397, 0, 398, 0, 399, 350, 0, 0,
2458 0, 0, 0, 0, 0, 0, 64, 65, 74, 107,
2459 67, 68, 69, 70, 71, 72, 73, 0, 1, 2,
2460 0, 3, 4, 5, 64, 65, 0, 107, 67, 68,
2461 69, 70, 71, 72, 73, 0, 1, 2, 0, 3,
2462 4, 5, 0, 0, 0, 0, 0, 64, 65, 74,
2463 107, 67, 68, 69, 70, 71, 72, 73, 0, 1,
2464 2, 0, 3, 4, 5, 64, 65, 74, 107, 67,
2465 68, 69, 70, 71, 72, 73, 0, 1, 2, 535,
2466 3, 4, 5, 0, 0, 0, 0, 0, 0, 0,
2467 74, 0, 0, 0, 0, 0, 0, 629, 0, 0,
2468 0, 0, 0, 0, 0, 0, 0, 0, 74, 0,
2469 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2470 0, 0, 75, 76, 0, 0, 77, 0, 78, 64,
2471 65, 0, 66, 67, 68, 69, 70, 71, 72, 73,
2472 0, 1, 2, 0, 3, 4, 5, 0, 0, 0,
2473 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2474 0, 0, 0, 75, 76, 0, 372, 77, 0, 78,
2475 0, 0, 74, 0, 0, 0, 0, 0, 0, 0,
2476 0, 75, 76, 0, 475, 77, 0, 78, 0, 0,
2477 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2478 0, 0, 0, 0, 75, 76, 0, 0, 77, 0,
2479 78, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2480 0, 0, 75, 76, 0, 0, 77, 0, 78, 64,
2481 65, 0, 107, 67, 68, 69, 70, 71, 72, 73,
2482 0, 1, 2, 0, 3, 4, 5, 0, 64, 65,
2483 0, 281, 67, 68, 69, 70, 71, 72, 73, 0,
2484 1, 2, 0, 3, 4, 5, 0, 0, 0, 0,
2485 0, 0, 74, 0, 0, 0, 0, 0, 0, 0,
2486 0, 0, 0, 0, 0, 0, 75, 76, 0, 0,
2487 77, 74, 78, 64, 65, 0, 107, 67, 68, 69,
2488 70, 71, 72, 73, 0, 1, 2, 0, 3, 4,
2489 5, 64, 65, 0, 107, 67, 68, 69, 70, 71,
2490 72, 73, 0, 1, 2, 0, 3, 4, 5, 0,
2491 0, 0, 0, 0, 64, 65, 74, 107, 67, 68,
2492 69, 70, 71, 72, 636, 0, 1, 2, 0, 3,
2493 4, 5, 64, 65, 74, 107, 67, 68, 69, 70,
2494 71, 72, 680, 0, 1, 2, 0, 3, 4, 5,
2495 0, 0, 0, 0, 0, 0, 0, 74, 0, 0,
2496 0, 0, 0, 0, 0, 0, 75, 76, 0, 0,
2497 77, 0, 78, 0, 0, 74, 0, -216, 0, 0,
2498 0, 0, 0, 0, 0, 75, 76, 0, 0, 77,
2499 0, 78, 0, 0, 0, -63, 1, 2, 0, 3,
2500 4, 5, 0, 0, 0, 0, 0, 6, 7, 0,
2501 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2502 0, 0, 0, 0, 0, 0, 0, 0, 0, 8,
2503 75, 76, 0, 9, 77, 0, 375, 10, 0, 0,
2504 0, 0, 0, 0, 0, 0, 0, 0, 75, 76,
2505 0, 0, 77, 0, 477, 0, 0, 0, 0, 0,
2506 0, 0, 0, 166, 0, 0, 0, 0, 0, 0,
2507 0, 75, 76, 0, 0, 77, 0, 78, 0, 0,
2508 0, 0, 0, 0, 167, 168, 0, 0, 0, 75,
2509 76, 0, 0, 77, 0, 78, 169, 170, 171, 172,
2510 173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
2511 183, 184, 185, 186, 187, 188, 189, 190, 191, 192,
2512 193, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2513 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2514 0, 194, 195, 196, 0, 0, 197, 198, 199, 200,
2515 201, 202, 203, 204, 205, 206, 207, 208, 209, 210,
2516 211, 212, 213, 214, 215, 216, 217, 218
2519 static const yytype_int16 yycheck[] =
2521 0, 27, 158, 196, 11, 11, 0, 320, 239, 161,
2522 458, 4, 446, 447, 55, 28, 159, 17, 211, 212,
2523 213, 214, 215, 17, 266, 267, 21, 192, 221, 34,
2524 172, 11, 55, 656, 29, 55, 288, 536, 55, 193,
2525 11, 162, 162, 55, 162, 55, 162, 161, 169, 54,
2526 673, 171, 78, 171, 55, 171, 7, 8, 55, 10,
2527 11, 12, 13, 14, 15, 16, 17, 53, 19, 20,
2528 55, 22, 23, 24, 54, 59, 102, 156, 162, 158,
2529 106, 223, 68, 54, 336, 162, 112, 171, 161, 254,
2530 7, 256, 118, 93, 171, 162, 18, 240, 241, 50,
2531 534, 255, 19, 257, 171, 22, 162, 24, 41, 42,
2532 121, 32, 33, 169, 55, 48, 142, 143, 159, 11,
2533 146, 54, 42, 43, 44, 17, 152, 47, 169, 20,
2534 161, 630, 23, 375, 582, 161, 159, 636, 637, 159,
2535 151, 162, 159, 169, 167, 338, 167, 159, 165, 159,
2536 34, 163, 162, 163, 396, 397, 398, 170, 159, 160,
2537 167, 167, 159, 0, 612, 162, 163, 165, 194, 195,
2538 196, 197, 117, 118, 159, 160, 171, 170, 677, 678,
2539 161, 680, 681, 161, 210, 211, 212, 213, 214, 215,
2540 216, 217, 218, 219, 220, 221, 509, 19, 697, 698,
2541 22, 22, 24, 282, 162, 231, 285, 286, 287, 167,
2542 46, 404, 48, 164, 165, 54, 242, 168, 159, 170,
2543 171, 21, 163, 162, 156, 157, 158, 420, 167, 422,
2544 423, 424, 54, 7, 8, 477, 35, 22, 37, 552,
2545 42, 554, 44, 322, 22, 19, 20, 22, 22, 23,
2546 24, 330, 331, 332, 333, 334, 408, 141, 142, 143,
2547 144, 160, 146, 162, 132, 133, 150, 151, 4, 153,
2548 154, 155, 160, 299, 162, 160, 159, 162, 160, 431,
2549 162, 4, 121, 122, 160, 279, 162, 132, 133, 37,
2550 316, 317, 318, 62, 63, 64, 65, 66, 67, 121,
2551 122, 614, 141, 142, 166, 144, 145, 463, 147, 148,
2552 149, 337, 338, 132, 133, 166, 114, 115, 159, 141,
2553 142, 163, 144, 145, 4, 147, 148, 149, 84, 85,
2554 409, 410, 411, 412, 161, 22, 162, 160, 169, 418,
2555 4, 42, 43, 44, 45, 46, 47, 48, 49, 375,
2556 51, 160, 159, 432, 365, 366, 367, 368, 369, 370,
2557 371, 592, 555, 55, 57, 558, 559, 560, 11, 380,
2558 381, 382, 169, 22, 160, 159, 159, 159, 404, 159,
2559 159, 162, 408, 159, 463, 162, 159, 159, 159, 159,
2560 38, 4, 38, 159, 420, 421, 422, 423, 424, 162,
2561 162, 162, 162, 162, 430, 431, 485, 159, 159, 159,
2562 159, 490, 22, 492, 61, 162, 495, 162, 162, 165,
2563 162, 162, 448, 162, 162, 162, 505, 506, 162, 508,
2564 661, 162, 162, 664, 162, 162, 162, 169, 449, 450,
2565 451, 452, 162, 162, 38, 22, 472, 17, 17, 460,
2566 162, 477, 162, 162, 162, 156, 157, 158, 162, 4,
2567 162, 4, 162, 162, 162, 4, 545, 546, 162, 548,
2568 549, 550, 551, 162, 162, 22, 162, 556, 504, 162,
2569 38, 162, 4, 162, 510, 564, 160, 169, 159, 162,
2570 162, 570, 169, 4, 159, 54, 162, 160, 285, 286,
2571 287, 162, 162, 160, 530, 160, 22, 169, 519, 520,
2572 521, 522, 162, 524, 165, 167, 160, 528, 529, 160,
2573 160, 160, 17, 160, 160, 167, 160, 54, 607, 555,
2574 4, 152, 558, 559, 560, 322, 162, 159, 22, 159,
2575 17, 17, 17, 330, 331, 332, 333, 334, 94, 95,
2576 96, 97, 98, 99, 100, 101, 102, 103, 162, 73,
2577 17, 572, 573, 574, 575, 591, 652, 93, 631, 106,
2578 112, 17, 598, 231, 242, 90, 655, 57, 133, 613,
2579 659, 660, 453, 141, 142, 143, 144, 613, 146, 133,
2580 590, -1, 150, 151, -1, 153, 154, 155, -1, -1,
2581 -1, -1, -1, -1, -1, -1, -1, -1, 619, -1,
2582 621, 622, 691, 692, -1, 694, -1, 696, -1, -1,
2583 -1, 700, 409, 410, 411, 412, -1, 706, -1, -1,
2584 -1, 418, -1, -1, 7, 8, 662, 10, 11, 12,
2585 13, 14, 15, 16, 17, 432, 19, 20, -1, 22,
2586 23, 24, 652, -1, -1, -1, 7, 8, -1, 10,
2587 11, 12, 13, 14, 15, 16, 17, -1, 19, 20,
2588 -1, 22, 23, 24, -1, -1, -1, 50, -1, -1,
2589 141, 142, 143, 144, -1, 146, -1, -1, 39, 150,
2590 151, -1, 153, 154, 155, -1, -1, -1, 485, 50,
2591 -1, -1, -1, 490, -1, 492, -1, -1, 495, -1,
2592 -1, -1, -1, -1, -1, -1, -1, -1, 505, 506,
2593 -1, 508, -1, -1, -1, -1, -1, -1, -1, -1,
2594 -1, -1, -1, -1, -1, -1, -1, -1, -1, 7,
2595 8, -1, 10, 11, 12, 13, 14, 15, 16, 17,
2596 -1, 19, 20, -1, 22, 23, 24, -1, 545, 546,
2597 -1, 548, 549, 550, 551, -1, -1, -1, -1, 556,
2598 -1, -1, -1, -1, -1, -1, -1, 564, -1, -1,
2599 -1, -1, 50, 570, -1, -1, -1, -1, -1, -1,
2600 -1, 164, 165, -1, -1, 168, -1, 170, 171, -1,
2601 -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
2602 8, 9, -1, 164, 165, 0, -1, 168, -1, 170,
2603 607, 19, 20, -1, 22, 23, 24, 25, 26, 27,
2604 -1, -1, -1, 18, 19, 20, -1, 22, 23, 24,
2605 -1, -1, 40, 41, -1, 30, 31, -1, -1, -1,
2606 -1, -1, -1, -1, -1, -1, 54, -1, -1, -1,
2607 -1, 59, -1, -1, -1, -1, -1, 52, 655, -1,
2608 -1, 56, 659, 660, -1, 60, -1, 75, 76, 77,
2609 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
2610 88, 89, 90, 91, 92, 93, 164, 165, -1, -1,
2611 168, -1, 170, 171, 691, 692, -1, 694, -1, 696,
2612 -1, -1, -1, 700, -1, -1, -1, -1, -1, 706,
2613 -1, 119, 120, 121, 122, 123, 124, 125, 126, 127,
2614 128, 129, 130, 131, -1, 133, -1, 135, 136, 137,
2615 -1, 139, 140, 141, 142, -1, 144, 145, -1, 147,
2616 148, 149, -1, -1, -1, -1, -1, -1, -1, 3,
2617 4, 5, 6, 7, 8, 9, -1, 165, -1, -1,
2618 168, -1, 170, -1, 172, 19, 20, -1, 22, 23,
2619 24, 25, 26, 27, 26, 27, -1, -1, -1, -1,
2620 -1, -1, -1, -1, -1, -1, 40, 41, -1, -1,
2621 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2622 -1, 55, -1, 7, 8, 59, 10, 11, 12, 13,
2623 14, 15, 16, 17, -1, 19, 20, -1, 22, 23,
2624 24, 75, 76, 77, 78, 79, 80, 81, 82, 83,
2625 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
2626 -1, -1, -1, -1, -1, -1, 50, -1, 100, 101,
2627 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
2628 112, 113, -1, -1, -1, 119, 120, 121, 122, 123,
2629 124, 125, 126, 127, 128, 129, 130, 131, -1, 133,
2630 -1, 135, 136, 137, -1, 139, 140, -1, -1, -1,
2631 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2632 -1, -1, -1, -1, -1, 159, -1, -1, -1, -1,
2633 -1, 165, -1, -1, 168, -1, 170, -1, 172, 3,
2634 4, 5, 6, 7, 8, 9, -1, -1, -1, -1,
2635 -1, -1, -1, -1, -1, 19, 20, -1, 22, 23,
2636 24, 25, 26, 27, -1, -1, -1, -1, -1, -1,
2637 -1, -1, -1, -1, -1, -1, 40, 41, -1, -1,
2638 164, 165, -1, -1, 168, -1, 170, 171, -1, -1,
2639 -1, 55, 7, 8, -1, 10, 11, 12, 13, 14,
2640 15, 16, 17, -1, 19, 20, -1, 22, 23, 24,
2641 -1, 75, 76, 77, 78, 79, 80, 81, 82, 83,
2642 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
2643 -1, -1, -1, -1, -1, 50, -1, -1, -1, -1,
2644 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2645 -1, -1, -1, -1, -1, 119, 120, 121, 122, 123,
2646 124, 125, 126, 127, 128, 129, 130, 131, -1, 133,
2647 -1, 135, 136, 137, -1, 139, 140, -1, -1, -1,
2648 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2649 -1, -1, -1, -1, -1, 159, -1, -1, -1, 163,
2650 -1, 165, -1, -1, 168, -1, 170, -1, 172, 3,
2651 4, 5, 6, 7, 8, 9, -1, -1, -1, -1,
2652 -1, -1, -1, -1, -1, 19, 20, -1, 22, 23,
2653 24, 25, 26, 27, -1, -1, -1, -1, -1, -1,
2654 -1, -1, -1, -1, -1, -1, 40, 41, -1, 164,
2655 165, -1, -1, 168, -1, 170, 171, -1, -1, -1,
2656 -1, 55, 7, 8, -1, 10, 11, 12, 13, 14,
2657 15, 16, 17, -1, 19, 20, -1, 22, 23, 24,
2658 -1, 75, 76, 77, 78, 79, 80, 81, 82, 83,
2659 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
2660 -1, -1, -1, -1, -1, 50, -1, -1, -1, -1,
2661 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2662 -1, -1, -1, -1, -1, 119, 120, 121, 122, 123,
2663 124, 125, 126, 127, 128, 129, 130, 131, -1, 133,
2664 -1, 135, 136, 137, -1, 139, 140, -1, -1, -1,
2665 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2666 -1, -1, -1, -1, -1, 159, -1, -1, -1, -1,
2667 -1, 165, -1, -1, 168, -1, 170, -1, 172, 3,
2668 4, 5, 6, 7, 8, 9, -1, -1, -1, -1,
2669 -1, -1, -1, -1, -1, 19, 20, -1, 22, 23,
2670 24, 25, 26, 27, -1, -1, -1, -1, -1, -1,
2671 -1, -1, -1, -1, -1, -1, 40, 41, -1, 164,
2672 165, -1, -1, 168, -1, 170, 171, -1, -1, -1,
2673 -1, -1, -1, 7, 8, 59, 10, 11, 12, 13,
2674 14, 15, 16, 17, -1, 19, 20, -1, 22, 23,
2675 24, 75, 76, 77, 78, 79, 80, 81, 82, 83,
2676 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
2677 -1, -1, -1, -1, 7, 8, 50, 10, 11, 12,
2678 13, 14, 15, 16, 17, -1, 19, 20, -1, 22,
2679 23, 24, -1, -1, -1, 119, 120, 121, 122, 123,
2680 124, 125, 126, 127, 128, 129, 130, 131, -1, 133,
2681 -1, 135, 136, 137, -1, 139, 140, 50, -1, -1,
2682 -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
2683 6, -1, -1, 9, -1, -1, -1, -1, -1, -1,
2684 -1, 165, -1, -1, 168, -1, 170, -1, 172, 25,
2685 26, 27, -1, -1, -1, -1, -1, -1, -1, -1,
2686 -1, -1, -1, -1, 40, 41, -1, 141, 142, -1,
2687 144, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2688 -1, -1, -1, 59, -1, -1, -1, -1, -1, -1,
2689 164, 165, 125, -1, 168, -1, 170, -1, -1, 75,
2690 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
2691 86, 87, 88, 89, 90, 91, 92, 93, -1, -1,
2692 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2693 -1, 164, 165, -1, -1, 168, -1, 170, -1, -1,
2694 -1, -1, -1, 119, 120, 121, 122, 123, 124, 125,
2695 126, 127, 128, 129, 130, 131, -1, 133, -1, 135,
2696 136, 137, -1, 139, 140, 7, 8, -1, 10, 11,
2697 12, 13, 14, 15, 16, 17, -1, 19, 20, -1,
2698 22, 23, 24, -1, -1, -1, -1, -1, -1, 165,
2699 -1, -1, 168, -1, 170, -1, 172, 39, -1, -1,
2700 -1, -1, -1, -1, -1, -1, 7, 8, 50, 10,
2701 11, 12, 13, 14, 15, 16, 17, -1, 19, 20,
2702 -1, 22, 23, 24, 7, 8, -1, 10, 11, 12,
2703 13, 14, 15, 16, 17, -1, 19, 20, -1, 22,
2704 23, 24, -1, -1, -1, -1, -1, 7, 8, 50,
2705 10, 11, 12, 13, 14, 15, 16, 17, -1, 19,
2706 20, -1, 22, 23, 24, 7, 8, 50, 10, 11,
2707 12, 13, 14, 15, 16, 17, -1, 19, 20, 39,
2708 22, 23, 24, -1, -1, -1, -1, -1, -1, -1,
2709 50, -1, -1, -1, -1, -1, -1, 39, -1, -1,
2710 -1, -1, -1, -1, -1, -1, -1, -1, 50, -1,
2711 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2712 -1, -1, 164, 165, -1, -1, 168, -1, 170, 7,
2713 8, -1, 10, 11, 12, 13, 14, 15, 16, 17,
2714 -1, 19, 20, -1, 22, 23, 24, -1, -1, -1,
2715 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2716 -1, -1, -1, 164, 165, -1, 167, 168, -1, 170,
2717 -1, -1, 50, -1, -1, -1, -1, -1, -1, -1,
2718 -1, 164, 165, -1, 167, 168, -1, 170, -1, -1,
2719 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2720 -1, -1, -1, -1, 164, 165, -1, -1, 168, -1,
2721 170, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2722 -1, -1, 164, 165, -1, -1, 168, -1, 170, 7,
2723 8, -1, 10, 11, 12, 13, 14, 15, 16, 17,
2724 -1, 19, 20, -1, 22, 23, 24, -1, 7, 8,
2725 -1, 10, 11, 12, 13, 14, 15, 16, 17, -1,
2726 19, 20, -1, 22, 23, 24, -1, -1, -1, -1,
2727 -1, -1, 50, -1, -1, -1, -1, -1, -1, -1,
2728 -1, -1, -1, -1, -1, -1, 164, 165, -1, -1,
2729 168, 50, 170, 7, 8, -1, 10, 11, 12, 13,
2730 14, 15, 16, 17, -1, 19, 20, -1, 22, 23,
2731 24, 7, 8, -1, 10, 11, 12, 13, 14, 15,
2732 16, 17, -1, 19, 20, -1, 22, 23, 24, -1,
2733 -1, -1, -1, -1, 7, 8, 50, 10, 11, 12,
2734 13, 14, 15, 16, 17, -1, 19, 20, -1, 22,
2735 23, 24, 7, 8, 50, 10, 11, 12, 13, 14,
2736 15, 16, 17, -1, 19, 20, -1, 22, 23, 24,
2737 -1, -1, -1, -1, -1, -1, -1, 50, -1, -1,
2738 -1, -1, -1, -1, -1, -1, 164, 165, -1, -1,
2739 168, -1, 170, -1, -1, 50, -1, 0, -1, -1,
2740 -1, -1, -1, -1, -1, 164, 165, -1, -1, 168,
2741 -1, 170, -1, -1, -1, 18, 19, 20, -1, 22,
2742 23, 24, -1, -1, -1, -1, -1, 30, 31, -1,
2743 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2744 -1, -1, -1, -1, -1, -1, -1, -1, -1, 52,
2745 164, 165, -1, 56, 168, -1, 170, 60, -1, -1,
2746 -1, -1, -1, -1, -1, -1, -1, -1, 164, 165,
2747 -1, -1, 168, -1, 170, -1, -1, -1, -1, -1,
2748 -1, -1, -1, 36, -1, -1, -1, -1, -1, -1,
2749 -1, 164, 165, -1, -1, 168, -1, 170, -1, -1,
2750 -1, -1, -1, -1, 57, 58, -1, -1, -1, 164,
2751 165, -1, -1, 168, -1, 170, 69, 70, 71, 72,
2752 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
2753 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
2754 93, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2755 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2756 -1, 114, 115, 116, -1, -1, 119, 120, 121, 122,
2757 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
2758 133, 134, 135, 136, 137, 138, 139, 140
2761 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
2762 symbol of state STATE-NUM. */
2763 static const yytype_uint16 yystos[] =
2765 0, 19, 20, 22, 23, 24, 30, 31, 52, 56,
2766 60, 179, 182, 184, 185, 186, 220, 221, 222, 224,
2767 223, 53, 68, 229, 161, 59, 161, 18, 161, 42,
2768 43, 44, 45, 46, 47, 48, 49, 51, 156, 157,
2769 158, 187, 188, 189, 0, 222, 46, 48, 190, 239,
2770 42, 43, 44, 47, 191, 236, 238, 246, 161, 161,
2771 165, 230, 22, 228, 7, 8, 10, 11, 12, 13,
2772 14, 15, 16, 17, 50, 164, 165, 168, 170, 179,
2773 184, 207, 208, 242, 189, 189, 35, 37, 218, 189,
2774 189, 21, 247, 248, 29, 171, 237, 247, 22, 22,
2775 22, 231, 159, 4, 4, 4, 170, 10, 171, 208,
2776 213, 55, 159, 181, 218, 218, 42, 44, 192, 32,
2777 33, 217, 62, 63, 64, 65, 66, 67, 193, 234,
2778 234, 7, 182, 183, 251, 162, 167, 39, 208, 209,
2779 211, 212, 166, 166, 171, 213, 162, 171, 159, 212,
2780 163, 217, 217, 10, 125, 208, 210, 219, 208, 214,
2781 4, 197, 28, 170, 235, 161, 36, 57, 58, 69,
2782 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
2783 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
2784 90, 91, 92, 93, 114, 115, 116, 119, 120, 121,
2785 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
2786 132, 133, 134, 135, 136, 137, 138, 139, 140, 174,
2787 175, 176, 249, 256, 257, 258, 259, 249, 257, 22,
2788 195, 162, 160, 208, 208, 169, 171, 208, 4, 160,
2789 214, 208, 159, 242, 3, 4, 5, 6, 9, 25,
2790 26, 27, 40, 41, 90, 91, 92, 93, 119, 133,
2791 135, 136, 137, 139, 140, 165, 168, 170, 172, 174,
2792 175, 176, 215, 242, 181, 141, 142, 144, 196, 210,
2793 57, 10, 208, 244, 245, 11, 17, 11, 193, 94,
2794 95, 96, 97, 98, 99, 100, 101, 102, 103, 177,
2795 26, 27, 100, 101, 102, 103, 104, 105, 106, 107,
2796 108, 109, 110, 111, 112, 113, 178, 177, 178, 208,
2797 208, 244, 208, 208, 252, 244, 244, 244, 244, 244,
2798 208, 208, 208, 208, 208, 244, 193, 117, 118, 54,
2799 121, 122, 141, 142, 144, 145, 147, 148, 149, 194,
2800 39, 209, 199, 167, 169, 169, 160, 199, 181, 181,
2801 219, 177, 178, 177, 178, 159, 159, 159, 159, 159,
2802 159, 159, 167, 214, 216, 170, 216, 171, 216, 22,
2803 159, 159, 159, 225, 184, 3, 4, 5, 6, 9,
2804 25, 26, 27, 40, 41, 59, 165, 168, 170, 172,
2805 215, 241, 242, 243, 162, 243, 243, 243, 197, 208,
2806 208, 208, 208, 162, 202, 162, 202, 243, 165, 162,
2807 162, 162, 162, 162, 162, 243, 243, 243, 243, 243,
2808 38, 197, 208, 244, 4, 141, 142, 143, 144, 146,
2809 150, 151, 153, 154, 155, 198, 226, 227, 38, 159,
2810 159, 159, 159, 214, 214, 214, 214, 214, 214, 214,
2811 162, 167, 171, 208, 216, 169, 171, 214, 214, 214,
2812 162, 205, 159, 61, 240, 167, 216, 170, 216, 171,
2813 216, 22, 244, 162, 162, 210, 243, 243, 243, 243,
2814 11, 54, 11, 254, 243, 165, 244, 208, 244, 244,
2815 244, 162, 162, 255, 162, 162, 162, 208, 210, 243,
2816 162, 205, 205, 208, 214, 214, 214, 214, 254, 162,
2817 162, 162, 162, 255, 162, 214, 169, 171, 162, 162,
2818 38, 34, 54, 203, 206, 39, 208, 232, 233, 22,
2819 167, 171, 216, 169, 171, 17, 17, 243, 162, 162,
2820 162, 162, 243, 4, 243, 162, 162, 243, 162, 162,
2821 162, 4, 4, 162, 208, 243, 243, 243, 162, 202,
2822 208, 160, 162, 162, 162, 162, 160, 214, 214, 214,
2823 214, 160, 214, 169, 214, 214, 208, 22, 4, 205,
2824 195, 162, 160, 162, 169, 171, 243, 243, 159, 243,
2825 243, 243, 243, 202, 202, 244, 243, 162, 244, 244,
2826 244, 4, 243, 159, 243, 214, 214, 214, 214, 162,
2827 160, 162, 162, 255, 160, 160, 160, 179, 180, 39,
2828 208, 199, 22, 169, 162, 165, 17, 208, 253, 167,
2829 243, 255, 253, 202, 160, 160, 160, 160, 214, 214,
2830 214, 160, 195, 203, 204, 17, 11, 167, 250, 195,
2831 195, 160, 162, 167, 160, 160, 160, 160, 180, 54,
2832 201, 243, 241, 11, 167, 121, 122, 243, 243, 199,
2833 17, 208, 199, 4, 152, 200, 162, 241, 195, 195,
2834 38, 195, 195, 22, 17, 162, 17, 243, 243, 243,
2835 17, 243, 195, 195, 243, 73, 17, 243
2838 #define yyerrok (yyerrstatus = 0)
2839 #define yyclearin (yychar = YYEMPTY)
2840 #define YYEMPTY (-2)
2843 #define YYACCEPT goto yyacceptlab
2844 #define YYABORT goto yyabortlab
2845 #define YYERROR goto yyerrorlab
2848 /* Like YYERROR except do call yyerror. This remains here temporarily
2849 to ease the transition to the new meaning of YYERROR, for GCC.
2850 Once GCC version 2 has supplanted version 1, this can go. */
2852 #define YYFAIL goto yyerrlab
2854 #define YYRECOVERING() (!!yyerrstatus)
2856 #define YYBACKUP(Token, Value) \
2858 if (yychar == YYEMPTY && yylen == 1) \
2862 yytoken = YYTRANSLATE (yychar); \
2868 yyerror (YY_("syntax error: cannot back up")); \
2875 #define YYERRCODE 256
2878 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
2879 If N is 0, then set CURRENT to the empty location which ends
2880 the previous symbol: RHS[0] (always defined). */
2882 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
2883 #ifndef YYLLOC_DEFAULT
2884 # define YYLLOC_DEFAULT(Current, Rhs, N) \
2888 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
2889 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
2890 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
2891 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
2895 (Current).first_line = (Current).last_line = \
2896 YYRHSLOC (Rhs, 0).last_line; \
2897 (Current).first_column = (Current).last_column = \
2898 YYRHSLOC (Rhs, 0).last_column; \
2904 /* YY_LOCATION_PRINT -- Print the location on the stream.
2905 This macro was not mandated originally: define only if we know
2906 we won't break user code: when these are the locations we know. */
2908 #ifndef YY_LOCATION_PRINT
2909 # if YYLTYPE_IS_TRIVIAL
2910 # define YY_LOCATION_PRINT(File, Loc) \
2911 fprintf (File, "%d.%d-%d.%d", \
2912 (Loc).first_line, (Loc).first_column, \
2913 (Loc).last_line, (Loc).last_column)
2915 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
2920 /* YYLEX -- calling `yylex' with the right arguments. */
2923 # define YYLEX yylex (YYLEX_PARAM)
2925 # define YYLEX yylex ()
2928 /* Enable debugging if requested. */
2932 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
2933 # define YYFPRINTF fprintf
2936 # define YYDPRINTF(Args) \
2942 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
2946 YYFPRINTF (stderr, "%s ", Title); \
2947 yy_symbol_print (stderr, \
2949 YYFPRINTF (stderr, "\n"); \
2954 /*--------------------------------.
2955 | Print this symbol on YYOUTPUT. |
2956 `--------------------------------*/
2959 #if (defined __STDC__ || defined __C99__FUNC__ \
2960 || defined __cplusplus || defined _MSC_VER)
2962 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
2965 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
2968 YYSTYPE const * const yyvaluep;
2974 if (yytype < YYNTOKENS)
2975 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
2987 /*--------------------------------.
2988 | Print this symbol on YYOUTPUT. |
2989 `--------------------------------*/
2991 #if (defined __STDC__ || defined __C99__FUNC__ \
2992 || defined __cplusplus || defined _MSC_VER)
2994 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
2997 yy_symbol_print (yyoutput, yytype, yyvaluep)
3000 YYSTYPE const * const yyvaluep;
3003 if (yytype < YYNTOKENS)
3004 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
3006 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
3008 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
3009 YYFPRINTF (yyoutput, ")");
3012 /*------------------------------------------------------------------.
3013 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
3015 `------------------------------------------------------------------*/
3017 #if (defined __STDC__ || defined __C99__FUNC__ \
3018 || defined __cplusplus || defined _MSC_VER)
3020 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
3023 yy_stack_print (bottom, top)
3024 yytype_int16 *bottom;
3028 YYFPRINTF (stderr, "Stack now");
3029 for (; bottom <= top; ++bottom)
3030 YYFPRINTF (stderr, " %d", *bottom);
3031 YYFPRINTF (stderr, "\n");
3034 # define YY_STACK_PRINT(Bottom, Top) \
3037 yy_stack_print ((Bottom), (Top)); \
3041 /*------------------------------------------------.
3042 | Report that the YYRULE is going to be reduced. |
3043 `------------------------------------------------*/
3045 #if (defined __STDC__ || defined __C99__FUNC__ \
3046 || defined __cplusplus || defined _MSC_VER)
3048 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
3051 yy_reduce_print (yyvsp, yyrule)
3056 int yynrhs = yyr2[yyrule];
3058 unsigned long int yylno = yyrline[yyrule];
3059 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
3061 /* The symbols being reduced. */
3062 for (yyi = 0; yyi < yynrhs; yyi++)
3064 fprintf (stderr, " $%d = ", yyi + 1);
3065 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
3066 &(yyvsp[(yyi + 1) - (yynrhs)])
3068 fprintf (stderr, "\n");
3072 # define YY_REDUCE_PRINT(Rule) \
3075 yy_reduce_print (yyvsp, Rule); \
3078 /* Nonzero means print parse trace. It is left uninitialized so that
3079 multiple parsers can coexist. */
3081 #else /* !YYDEBUG */
3082 # define YYDPRINTF(Args)
3083 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
3084 # define YY_STACK_PRINT(Bottom, Top)
3085 # define YY_REDUCE_PRINT(Rule)
3086 #endif /* !YYDEBUG */
3089 /* YYINITDEPTH -- initial size of the parser's stacks. */
3091 # define YYINITDEPTH 200
3094 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
3095 if the built-in stack extension method is used).
3097 Do not make this value too large; the results are undefined if
3098 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
3099 evaluated with infinite-precision integer arithmetic. */
3102 # define YYMAXDEPTH 10000
3110 # if defined __GLIBC__ && defined _STRING_H
3111 # define yystrlen strlen
3113 /* Return the length of YYSTR. */
3114 #if (defined __STDC__ || defined __C99__FUNC__ \
3115 || defined __cplusplus || defined _MSC_VER)
3117 yystrlen (const char *yystr)
3125 for (yylen = 0; yystr[yylen]; yylen++)
3133 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
3134 # define yystpcpy stpcpy
3136 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
3138 #if (defined __STDC__ || defined __C99__FUNC__ \
3139 || defined __cplusplus || defined _MSC_VER)
3141 yystpcpy (char *yydest, const char *yysrc)
3144 yystpcpy (yydest, yysrc)
3150 const char *yys = yysrc;
3152 while ((*yyd++ = *yys++) != '\0')
3161 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
3162 quotes and backslashes, so that it's suitable for yyerror. The
3163 heuristic is that double-quoting is unnecessary unless the string
3164 contains an apostrophe, a comma, or backslash (other than
3165 backslash-backslash). YYSTR is taken from yytname. If YYRES is
3166 null, do not copy; instead, return the length of what the result
3169 yytnamerr (char *yyres, const char *yystr)
3174 char const *yyp = yystr;
3181 goto do_not_strip_quotes;
3185 goto do_not_strip_quotes;
3198 do_not_strip_quotes: ;
3202 return yystrlen (yystr);
3204 return yystpcpy (yyres, yystr) - yyres;
3208 /* Copy into YYRESULT an error message about the unexpected token
3209 YYCHAR while in state YYSTATE. Return the number of bytes copied,
3210 including the terminating null byte. If YYRESULT is null, do not
3211 copy anything; just return the number of bytes that would be
3212 copied. As a special case, return 0 if an ordinary "syntax error"
3213 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
3214 size calculation. */
3216 yysyntax_error (char *yyresult, int yystate, int yychar)
3218 int yyn = yypact[yystate];
3220 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
3224 int yytype = YYTRANSLATE (yychar);
3225 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
3226 YYSIZE_T yysize = yysize0;
3228 int yysize_overflow = 0;
3229 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
3230 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
3234 /* This is so xgettext sees the translatable formats that are
3235 constructed on the fly. */
3236 YY_("syntax error, unexpected %s");
3237 YY_("syntax error, unexpected %s, expecting %s");
3238 YY_("syntax error, unexpected %s, expecting %s or %s");
3239 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
3240 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
3244 static char const yyunexpected[] = "syntax error, unexpected %s";
3245 static char const yyexpecting[] = ", expecting %s";
3246 static char const yyor[] = " or %s";
3247 char yyformat[sizeof yyunexpected
3248 + sizeof yyexpecting - 1
3249 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
3250 * (sizeof yyor - 1))];
3251 char const *yyprefix = yyexpecting;
3253 /* Start YYX at -YYN if negative to avoid negative indexes in
3255 int yyxbegin = yyn < 0 ? -yyn : 0;
3257 /* Stay within bounds of both yycheck and yytname. */
3258 int yychecklim = YYLAST - yyn + 1;
3259 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
3262 yyarg[0] = yytname[yytype];
3263 yyfmt = yystpcpy (yyformat, yyunexpected);
3265 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
3266 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
3268 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
3272 yyformat[sizeof yyunexpected - 1] = '\0';
3275 yyarg[yycount++] = yytname[yyx];
3276 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
3277 yysize_overflow |= (yysize1 < yysize);
3279 yyfmt = yystpcpy (yyfmt, yyprefix);
3283 yyf = YY_(yyformat);
3284 yysize1 = yysize + yystrlen (yyf);
3285 yysize_overflow |= (yysize1 < yysize);
3288 if (yysize_overflow)
3289 return YYSIZE_MAXIMUM;
3293 /* Avoid sprintf, as that infringes on the user's name space.
3294 Don't have undefined behavior even if the translation
3295 produced a string with the wrong number of "%s"s. */
3296 char *yyp = yyresult;
3298 while ((*yyp = *yyf) != '\0')
3300 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
3302 yyp += yytnamerr (yyp, yyarg[yyi++]);
3315 #endif /* YYERROR_VERBOSE */
3318 /*-----------------------------------------------.
3319 | Release the memory associated to this symbol. |
3320 `-----------------------------------------------*/
3323 #if (defined __STDC__ || defined __C99__FUNC__ \
3324 || defined __cplusplus || defined _MSC_VER)
3326 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
3329 yydestruct (yymsg, yytype, yyvaluep)
3339 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
3350 /* Prevent warnings from -Wmissing-prototypes. */
3352 #ifdef YYPARSE_PARAM
3353 #if defined __STDC__ || defined __cplusplus
3354 int yyparse (void *YYPARSE_PARAM);
3358 #else /* ! YYPARSE_PARAM */
3359 #if defined __STDC__ || defined __cplusplus
3364 #endif /* ! YYPARSE_PARAM */
3368 /* The look-ahead symbol. */
3371 /* The semantic value of the look-ahead symbol. */
3374 /* Number of syntax errors so far. */
3383 #ifdef YYPARSE_PARAM
3384 #if (defined __STDC__ || defined __C99__FUNC__ \
3385 || defined __cplusplus || defined _MSC_VER)
3387 yyparse (void *YYPARSE_PARAM)
3390 yyparse (YYPARSE_PARAM)
3391 void *YYPARSE_PARAM;
3393 #else /* ! YYPARSE_PARAM */
3394 #if (defined __STDC__ || defined __C99__FUNC__ \
3395 || defined __cplusplus || defined _MSC_VER)
3409 /* Number of tokens to shift before error messages enabled. */
3411 /* Look-ahead token as an internal (translated) token number. */
3414 /* Buffer for error messages, and its allocated size. */
3416 char *yymsg = yymsgbuf;
3417 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
3420 /* Three stacks and their tools:
3421 `yyss': related to states,
3422 `yyvs': related to semantic values,
3423 `yyls': related to locations.
3425 Refer to the stacks thru separate pointers, to allow yyoverflow
3426 to reallocate them elsewhere. */
3428 /* The state stack. */
3429 yytype_int16 yyssa[YYINITDEPTH];
3430 yytype_int16 *yyss = yyssa;
3431 yytype_int16 *yyssp;
3433 /* The semantic value stack. */
3434 YYSTYPE yyvsa[YYINITDEPTH];
3435 YYSTYPE *yyvs = yyvsa;
3440 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
3442 YYSIZE_T yystacksize = YYINITDEPTH;
3444 /* The variables used to return semantic value and location from the
3449 /* The number of symbols on the RHS of the reduced rule.
3450 Keep to zero when no symbol should be popped. */
3453 YYDPRINTF ((stderr, "Starting parse\n"));
3458 yychar = YYEMPTY; /* Cause a token to be read. */
3460 /* Initialize stack pointers.
3461 Waste one element of value and location stack
3462 so that they stay on the same level as the state stack.
3463 The wasted elements are never initialized. */
3470 /*------------------------------------------------------------.
3471 | yynewstate -- Push a new state, which is found in yystate. |
3472 `------------------------------------------------------------*/
3474 /* In all cases, when you get here, the value and location stacks
3475 have just been pushed. So pushing a state here evens the stacks. */
3481 if (yyss + yystacksize - 1 <= yyssp)
3483 /* Get the current used size of the three stacks, in elements. */
3484 YYSIZE_T yysize = yyssp - yyss + 1;
3488 /* Give user a chance to reallocate the stack. Use copies of
3489 these so that the &'s don't force the real ones into
3491 YYSTYPE *yyvs1 = yyvs;
3492 yytype_int16 *yyss1 = yyss;
3495 /* Each stack pointer address is followed by the size of the
3496 data in use in that stack, in bytes. This used to be a
3497 conditional around just the two extra args, but that might
3498 be undefined if yyoverflow is a macro. */
3499 yyoverflow (YY_("memory exhausted"),
3500 &yyss1, yysize * sizeof (*yyssp),
3501 &yyvs1, yysize * sizeof (*yyvsp),
3508 #else /* no yyoverflow */
3509 # ifndef YYSTACK_RELOCATE
3510 goto yyexhaustedlab;
3512 /* Extend the stack our own way. */
3513 if (YYMAXDEPTH <= yystacksize)
3514 goto yyexhaustedlab;
3516 if (YYMAXDEPTH < yystacksize)
3517 yystacksize = YYMAXDEPTH;
3520 yytype_int16 *yyss1 = yyss;
3521 union yyalloc *yyptr =
3522 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
3524 goto yyexhaustedlab;
3525 YYSTACK_RELOCATE (yyss);
3526 YYSTACK_RELOCATE (yyvs);
3528 # undef YYSTACK_RELOCATE
3530 YYSTACK_FREE (yyss1);
3533 #endif /* no yyoverflow */
3535 yyssp = yyss + yysize - 1;
3536 yyvsp = yyvs + yysize - 1;
3539 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
3540 (unsigned long int) yystacksize));
3542 if (yyss + yystacksize - 1 <= yyssp)
3546 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
3555 /* Do appropriate processing given the current state. Read a
3556 look-ahead token if we need one and don't already have one. */
3558 /* First try to decide what to do without reference to look-ahead token. */
3559 yyn = yypact[yystate];
3560 if (yyn == YYPACT_NINF)
3563 /* Not known => get a look-ahead token if don't already have one. */
3565 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
3566 if (yychar == YYEMPTY)
3568 YYDPRINTF ((stderr, "Reading a token: "));
3572 if (yychar <= YYEOF)
3574 yychar = yytoken = YYEOF;
3575 YYDPRINTF ((stderr, "Now at end of input.\n"));
3579 yytoken = YYTRANSLATE (yychar);
3580 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
3583 /* If the proper action on seeing token YYTOKEN is to reduce or to
3584 detect an error, take that action. */
3586 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
3591 if (yyn == 0 || yyn == YYTABLE_NINF)
3600 /* Count tokens shifted since error; after three, turn off error
3605 /* Shift the look-ahead token. */
3606 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
3608 /* Discard the shifted token unless it is eof. */
3609 if (yychar != YYEOF)
3618 /*-----------------------------------------------------------.
3619 | yydefault -- do the default action for the current state. |
3620 `-----------------------------------------------------------*/
3622 yyn = yydefact[yystate];
3628 /*-----------------------------.
3629 | yyreduce -- Do a reduction. |
3630 `-----------------------------*/
3632 /* yyn is the number of a rule to reduce with. */
3635 /* If YYLEN is nonzero, implement the default value of the action:
3638 Otherwise, the following line sets YYVAL to garbage.
3639 This behavior is undocumented and Bison
3640 users should not rely upon it. Assigning to YYVAL
3641 unconditionally makes the parser a bit smaller, and it avoids a
3642 GCC warning that YYVAL may be used uninitialized. */
3643 yyval = yyvsp[1-yylen];
3646 YY_REDUCE_PRINT (yyn);
3650 #line 1152 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3651 { (yyval.IPredicate) = ICmpInst::ICMP_EQ; ;}
3655 #line 1152 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3656 { (yyval.IPredicate) = ICmpInst::ICMP_NE; ;}
3660 #line 1153 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3661 { (yyval.IPredicate) = ICmpInst::ICMP_SLT; ;}
3665 #line 1153 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3666 { (yyval.IPredicate) = ICmpInst::ICMP_SGT; ;}
3670 #line 1154 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3671 { (yyval.IPredicate) = ICmpInst::ICMP_SLE; ;}
3675 #line 1154 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3676 { (yyval.IPredicate) = ICmpInst::ICMP_SGE; ;}
3680 #line 1155 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3681 { (yyval.IPredicate) = ICmpInst::ICMP_ULT; ;}
3685 #line 1155 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3686 { (yyval.IPredicate) = ICmpInst::ICMP_UGT; ;}
3690 #line 1156 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3691 { (yyval.IPredicate) = ICmpInst::ICMP_ULE; ;}
3695 #line 1156 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3696 { (yyval.IPredicate) = ICmpInst::ICMP_UGE; ;}
3700 #line 1160 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3701 { (yyval.FPredicate) = FCmpInst::FCMP_OEQ; ;}
3705 #line 1160 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3706 { (yyval.FPredicate) = FCmpInst::FCMP_ONE; ;}
3710 #line 1161 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3711 { (yyval.FPredicate) = FCmpInst::FCMP_OLT; ;}
3715 #line 1161 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3716 { (yyval.FPredicate) = FCmpInst::FCMP_OGT; ;}
3720 #line 1162 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3721 { (yyval.FPredicate) = FCmpInst::FCMP_OLE; ;}
3725 #line 1162 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3726 { (yyval.FPredicate) = FCmpInst::FCMP_OGE; ;}
3730 #line 1163 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3731 { (yyval.FPredicate) = FCmpInst::FCMP_ORD; ;}
3735 #line 1163 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3736 { (yyval.FPredicate) = FCmpInst::FCMP_UNO; ;}
3740 #line 1164 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3741 { (yyval.FPredicate) = FCmpInst::FCMP_UEQ; ;}
3745 #line 1164 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3746 { (yyval.FPredicate) = FCmpInst::FCMP_UNE; ;}
3750 #line 1165 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3751 { (yyval.FPredicate) = FCmpInst::FCMP_ULT; ;}
3755 #line 1165 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3756 { (yyval.FPredicate) = FCmpInst::FCMP_UGT; ;}
3760 #line 1166 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3761 { (yyval.FPredicate) = FCmpInst::FCMP_ULE; ;}
3765 #line 1166 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3766 { (yyval.FPredicate) = FCmpInst::FCMP_UGE; ;}
3770 #line 1167 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3771 { (yyval.FPredicate) = FCmpInst::FCMP_TRUE; ;}
3775 #line 1168 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3776 { (yyval.FPredicate) = FCmpInst::FCMP_FALSE; ;}
3780 #line 1172 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3781 { (yyval.StrVal) = 0; ;}
3785 #line 1174 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3786 { (yyval.UIntVal)=(yyvsp[(3) - (4)].UInt64Val); ;}
3790 #line 1175 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3791 { (yyval.UIntVal)=0; ;}
3795 #line 1179 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3797 (yyval.StrVal) = (yyvsp[(1) - (2)].StrVal);
3803 #line 1183 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3811 #line 1188 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3813 (yyval.UIntVal) = (yyvsp[(1) - (2)].UIntVal);
3819 #line 1197 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3827 #line 1202 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3829 (yyval.StrVal) = (yyvsp[(1) - (2)].StrVal);
3835 #line 1208 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3836 { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
3840 #line 1209 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3841 { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
3845 #line 1210 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3846 { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
3850 #line 1211 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3851 { (yyval.Linkage) = GlobalValue::AppendingLinkage; ;}
3855 #line 1212 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3856 { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
3860 #line 1213 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3861 { (yyval.Linkage) = GlobalValue::CommonLinkage; ;}
3865 #line 1217 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3866 { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
3870 #line 1218 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3871 { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
3875 #line 1219 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3876 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3880 #line 1223 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3881 { (yyval.Visibility) = GlobalValue::DefaultVisibility; ;}
3885 #line 1224 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3886 { (yyval.Visibility) = GlobalValue::DefaultVisibility; ;}
3890 #line 1225 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3891 { (yyval.Visibility) = GlobalValue::HiddenVisibility; ;}
3895 #line 1226 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3896 { (yyval.Visibility) = GlobalValue::ProtectedVisibility; ;}
3900 #line 1230 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3901 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3905 #line 1231 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3906 { (yyval.Linkage) = GlobalValue::DLLImportLinkage; ;}
3910 #line 1232 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3911 { (yyval.Linkage) = GlobalValue::ExternalWeakLinkage; ;}
3915 #line 1236 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3916 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3920 #line 1237 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3921 { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
3925 #line 1238 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3926 { (yyval.Linkage) = GlobalValue::LinkOnceLinkage; ;}
3930 #line 1239 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3931 { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
3935 #line 1240 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3936 { (yyval.Linkage) = GlobalValue::DLLExportLinkage; ;}
3940 #line 1244 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3941 { (yyval.Linkage) = GlobalValue::ExternalLinkage; ;}
3945 #line 1245 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3946 { (yyval.Linkage) = GlobalValue::WeakLinkage; ;}
3950 #line 1246 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3951 { (yyval.Linkage) = GlobalValue::InternalLinkage; ;}
3955 #line 1249 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3956 { (yyval.UIntVal) = CallingConv::C; ;}
3960 #line 1250 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3961 { (yyval.UIntVal) = CallingConv::C; ;}
3965 #line 1251 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3966 { (yyval.UIntVal) = CallingConv::Fast; ;}
3970 #line 1252 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3971 { (yyval.UIntVal) = CallingConv::Cold; ;}
3975 #line 1253 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3976 { (yyval.UIntVal) = CallingConv::X86_StdCall; ;}
3980 #line 1254 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3981 { (yyval.UIntVal) = CallingConv::X86_FastCall; ;}
3985 #line 1255 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3987 if ((unsigned)(yyvsp[(2) - (2)].UInt64Val) != (yyvsp[(2) - (2)].UInt64Val))
3988 GEN_ERROR("Calling conv too large");
3989 (yyval.UIntVal) = (yyvsp[(2) - (2)].UInt64Val);
3995 #line 1262 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
3996 { (yyval.Attributes) = Attribute::ZExt; ;}
4000 #line 1263 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4001 { (yyval.Attributes) = Attribute::ZExt; ;}
4005 #line 1264 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4006 { (yyval.Attributes) = Attribute::SExt; ;}
4010 #line 1265 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4011 { (yyval.Attributes) = Attribute::SExt; ;}
4015 #line 1266 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4016 { (yyval.Attributes) = Attribute::InReg; ;}
4020 #line 1267 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4021 { (yyval.Attributes) = Attribute::StructRet; ;}
4025 #line 1268 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4026 { (yyval.Attributes) = Attribute::NoAlias; ;}
4030 #line 1269 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4031 { (yyval.Attributes) = Attribute::ByVal; ;}
4035 #line 1270 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4036 { (yyval.Attributes) = Attribute::Nest; ;}
4040 #line 1271 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4041 { (yyval.Attributes) =
4042 Attribute::constructAlignmentFromInt((yyvsp[(2) - (2)].UInt64Val)); ;}
4046 #line 1275 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4047 { (yyval.Attributes) = Attribute::None; ;}
4051 #line 1276 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4053 (yyval.Attributes) = (yyvsp[(1) - (2)].Attributes) | (yyvsp[(2) - (2)].Attributes);
4058 #line 1281 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4059 { (yyval.Attributes) = Attribute::InReg; ;}
4063 #line 1282 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4064 { (yyval.Attributes) = Attribute::ZExt; ;}
4068 #line 1283 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4069 { (yyval.Attributes) = Attribute::SExt; ;}
4073 #line 1286 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4074 { (yyval.Attributes) = Attribute::None; ;}
4078 #line 1287 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4080 (yyval.Attributes) = (yyvsp[(1) - (2)].Attributes) | (yyvsp[(2) - (2)].Attributes);
4085 #line 1293 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4086 { (yyval.Attributes) = Attribute::NoReturn; ;}
4090 #line 1294 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4091 { (yyval.Attributes) = Attribute::NoUnwind; ;}
4095 #line 1295 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4096 { (yyval.Attributes) = Attribute::InReg; ;}
4100 #line 1296 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4101 { (yyval.Attributes) = Attribute::ZExt; ;}
4105 #line 1297 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4106 { (yyval.Attributes) = Attribute::SExt; ;}
4110 #line 1298 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4111 { (yyval.Attributes) = Attribute::ReadNone; ;}
4115 #line 1299 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4116 { (yyval.Attributes) = Attribute::ReadOnly; ;}
4120 #line 1300 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4121 { (yyval.Attributes) = Attribute::NoInline; ;}
4125 #line 1301 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4126 { (yyval.Attributes) = Attribute::AlwaysInline; ;}
4130 #line 1302 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4131 { (yyval.Attributes) = Attribute::OptimizeForSize; ;}
4135 #line 1305 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4136 { (yyval.Attributes) = Attribute::None; ;}
4140 #line 1306 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4142 (yyval.Attributes) = (yyvsp[(1) - (2)].Attributes) | (yyvsp[(2) - (2)].Attributes);
4147 #line 1312 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4148 { (yyval.StrVal) = 0; ;}
4152 #line 1313 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4154 (yyval.StrVal) = (yyvsp[(2) - (2)].StrVal);
4159 #line 1320 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4160 { (yyval.UIntVal) = 0; ;}
4164 #line 1321 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4166 (yyval.UIntVal) = (yyvsp[(2) - (2)].UInt64Val);
4167 if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
4168 GEN_ERROR("Alignment must be a power of two");
4174 #line 1327 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4175 { (yyval.UIntVal) = 0; ;}
4179 #line 1328 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4181 (yyval.UIntVal) = (yyvsp[(3) - (3)].UInt64Val);
4182 if ((yyval.UIntVal) != 0 && !isPowerOf2_32((yyval.UIntVal)))
4183 GEN_ERROR("Alignment must be a power of two");
4189 #line 1337 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4191 for (unsigned i = 0, e = (yyvsp[(2) - (2)].StrVal)->length(); i != e; ++i)
4192 if ((*(yyvsp[(2) - (2)].StrVal))[i] == '"' || (*(yyvsp[(2) - (2)].StrVal))[i] == '\\')
4193 GEN_ERROR("Invalid character in section name");
4194 (yyval.StrVal) = (yyvsp[(2) - (2)].StrVal);
4200 #line 1345 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4201 { (yyval.StrVal) = 0; ;}
4205 #line 1346 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4206 { (yyval.StrVal) = (yyvsp[(1) - (1)].StrVal); ;}
4210 #line 1351 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4215 #line 1352 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4220 #line 1353 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4222 CurGV->setSection(*(yyvsp[(1) - (1)].StrVal));
4223 delete (yyvsp[(1) - (1)].StrVal);
4229 #line 1358 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4231 if ((yyvsp[(2) - (2)].UInt64Val) != 0 && !isPowerOf2_32((yyvsp[(2) - (2)].UInt64Val)))
4232 GEN_ERROR("Alignment must be a power of two");
4233 CurGV->setAlignment((yyvsp[(2) - (2)].UInt64Val));
4239 #line 1374 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4241 (yyval.TypeVal) = new PATypeHolder(OpaqueType::get());
4247 #line 1378 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4249 (yyval.TypeVal) = new PATypeHolder((yyvsp[(1) - (1)].PrimType));
4255 #line 1382 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4257 if (*(yyvsp[(1) - (3)].TypeVal) == Type::LabelTy)
4258 GEN_ERROR("Cannot form a pointer to a basic block");
4259 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(PointerType::get(*(yyvsp[(1) - (3)].TypeVal), (yyvsp[(2) - (3)].UIntVal))));
4260 delete (yyvsp[(1) - (3)].TypeVal);
4266 #line 1389 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4267 { // Named types are also simple types...
4268 const Type* tmp = getTypeVal((yyvsp[(1) - (1)].ValIDVal));
4270 (yyval.TypeVal) = new PATypeHolder(tmp);
4275 #line 1394 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4276 { // Type UpReference
4277 if ((yyvsp[(2) - (2)].UInt64Val) > (uint64_t)~0U) GEN_ERROR("Value out of range");
4278 OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder
4279 UpRefs.push_back(UpRefRecord((unsigned)(yyvsp[(2) - (2)].UInt64Val), OT)); // Add to vector...
4280 (yyval.TypeVal) = new PATypeHolder(OT);
4281 UR_OUT("New Upreference!\n");
4287 #line 1402 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4289 // Allow but ignore attributes on function types; this permits auto-upgrade.
4290 // FIXME: remove in LLVM 3.0.
4291 const Type *RetTy = *(yyvsp[(1) - (5)].TypeVal);
4292 if (!FunctionType::isValidReturnType(RetTy))
4293 GEN_ERROR("Invalid result type for LLVM function");
4295 std::vector<const Type*> Params;
4296 TypeWithAttrsList::iterator I = (yyvsp[(3) - (5)].TypeWithAttrsList)->begin(), E = (yyvsp[(3) - (5)].TypeWithAttrsList)->end();
4297 for (; I != E; ++I ) {
4298 const Type *Ty = I->Ty->get();
4299 Params.push_back(Ty);
4302 bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
4303 if (isVarArg) Params.pop_back();
4305 for (unsigned i = 0; i != Params.size(); ++i)
4306 if (!(Params[i]->isFirstClassType() || isa<OpaqueType>(Params[i])))
4307 GEN_ERROR("Function arguments must be value types!");
4311 FunctionType *FT = FunctionType::get(RetTy, Params, isVarArg);
4312 delete (yyvsp[(1) - (5)].TypeVal); // Delete the return type handle
4313 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(FT));
4315 // Delete the argument list
4316 for (I = (yyvsp[(3) - (5)].TypeWithAttrsList)->begin() ; I != E; ++I ) {
4319 delete (yyvsp[(3) - (5)].TypeWithAttrsList);
4326 #line 1437 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4328 // Allow but ignore attributes on function types; this permits auto-upgrade.
4329 // FIXME: remove in LLVM 3.0.
4330 std::vector<const Type*> Params;
4331 TypeWithAttrsList::iterator I = (yyvsp[(3) - (5)].TypeWithAttrsList)->begin(), E = (yyvsp[(3) - (5)].TypeWithAttrsList)->end();
4332 for ( ; I != E; ++I ) {
4333 const Type* Ty = I->Ty->get();
4334 Params.push_back(Ty);
4337 bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
4338 if (isVarArg) Params.pop_back();
4340 for (unsigned i = 0; i != Params.size(); ++i)
4341 if (!(Params[i]->isFirstClassType() || isa<OpaqueType>(Params[i])))
4342 GEN_ERROR("Function arguments must be value types!");
4346 FunctionType *FT = FunctionType::get((yyvsp[(1) - (5)].PrimType), Params, isVarArg);
4347 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(FT));
4349 // Delete the argument list
4350 for (I = (yyvsp[(3) - (5)].TypeWithAttrsList)->begin() ; I != E; ++I ) {
4353 delete (yyvsp[(3) - (5)].TypeWithAttrsList);
4360 #line 1468 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4361 { // Sized array type?
4362 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(ArrayType::get(*(yyvsp[(4) - (5)].TypeVal), (yyvsp[(2) - (5)].UInt64Val))));
4363 delete (yyvsp[(4) - (5)].TypeVal);
4369 #line 1473 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4371 const llvm::Type* ElemTy = (yyvsp[(4) - (5)].TypeVal)->get();
4372 if ((unsigned)(yyvsp[(2) - (5)].UInt64Val) != (yyvsp[(2) - (5)].UInt64Val))
4373 GEN_ERROR("Unsigned result not equal to signed result");
4374 if (!ElemTy->isFloatingPoint() && !ElemTy->isInteger())
4375 GEN_ERROR("Element type of a VectorType must be primitive");
4376 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(VectorType::get(*(yyvsp[(4) - (5)].TypeVal), (unsigned)(yyvsp[(2) - (5)].UInt64Val))));
4377 delete (yyvsp[(4) - (5)].TypeVal);
4383 #line 1483 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4384 { // Structure type?
4385 std::vector<const Type*> Elements;
4386 for (std::list<llvm::PATypeHolder>::iterator I = (yyvsp[(2) - (3)].TypeList)->begin(),
4387 E = (yyvsp[(2) - (3)].TypeList)->end(); I != E; ++I)
4388 Elements.push_back(*I);
4390 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
4391 delete (yyvsp[(2) - (3)].TypeList);
4397 #line 1493 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4398 { // Empty structure type?
4399 (yyval.TypeVal) = new PATypeHolder(StructType::get(std::vector<const Type*>()));
4405 #line 1497 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4407 std::vector<const Type*> Elements;
4408 for (std::list<llvm::PATypeHolder>::iterator I = (yyvsp[(3) - (5)].TypeList)->begin(),
4409 E = (yyvsp[(3) - (5)].TypeList)->end(); I != E; ++I)
4410 Elements.push_back(*I);
4412 (yyval.TypeVal) = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
4413 delete (yyvsp[(3) - (5)].TypeList);
4419 #line 1507 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4420 { // Empty structure type?
4421 (yyval.TypeVal) = new PATypeHolder(StructType::get(std::vector<const Type*>(), true));
4427 #line 1514 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4429 // Allow but ignore attributes on function types; this permits auto-upgrade.
4430 // FIXME: remove in LLVM 3.0.
4431 (yyval.TypeWithAttrs).Ty = (yyvsp[(1) - (2)].TypeVal);
4432 (yyval.TypeWithAttrs).Attrs = Attribute::None;
4437 #line 1523 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4439 if (!UpRefs.empty())
4440 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (1)].TypeVal))->getDescription());
4441 if (!(*(yyvsp[(1) - (1)].TypeVal))->isFirstClassType() && !isa<StructType>((yyvsp[(1) - (1)].TypeVal)->get()))
4442 GEN_ERROR("LLVM functions cannot return aggregate types");
4443 (yyval.TypeVal) = (yyvsp[(1) - (1)].TypeVal);
4448 #line 1530 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4450 (yyval.TypeVal) = new PATypeHolder(Type::VoidTy);
4455 #line 1535 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4457 (yyval.TypeWithAttrsList) = new TypeWithAttrsList();
4458 (yyval.TypeWithAttrsList)->push_back((yyvsp[(1) - (1)].TypeWithAttrs));
4464 #line 1540 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4466 ((yyval.TypeWithAttrsList)=(yyvsp[(1) - (3)].TypeWithAttrsList))->push_back((yyvsp[(3) - (3)].TypeWithAttrs));
4472 #line 1548 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4474 (yyval.TypeWithAttrsList)=(yyvsp[(1) - (3)].TypeWithAttrsList);
4475 TypeWithAttrs TWA; TWA.Attrs = Attribute::None;
4476 TWA.Ty = new PATypeHolder(Type::VoidTy);
4477 (yyval.TypeWithAttrsList)->push_back(TWA);
4483 #line 1555 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4485 (yyval.TypeWithAttrsList) = new TypeWithAttrsList;
4486 TypeWithAttrs TWA; TWA.Attrs = Attribute::None;
4487 TWA.Ty = new PATypeHolder(Type::VoidTy);
4488 (yyval.TypeWithAttrsList)->push_back(TWA);
4494 #line 1562 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4496 (yyval.TypeWithAttrsList) = new TypeWithAttrsList();
4502 #line 1570 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4504 (yyval.TypeList) = new std::list<PATypeHolder>();
4505 (yyval.TypeList)->push_back(*(yyvsp[(1) - (1)].TypeVal));
4506 delete (yyvsp[(1) - (1)].TypeVal);
4512 #line 1576 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4514 ((yyval.TypeList)=(yyvsp[(1) - (3)].TypeList))->push_back(*(yyvsp[(3) - (3)].TypeVal));
4515 delete (yyvsp[(3) - (3)].TypeVal);
4521 #line 1588 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4522 { // Nonempty unsized arr
4523 if (!UpRefs.empty())
4524 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (4)].TypeVal))->getDescription());
4525 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[(1) - (4)].TypeVal)->get());
4527 GEN_ERROR("Cannot make array constant with type: '" +
4528 (*(yyvsp[(1) - (4)].TypeVal))->getDescription() + "'");
4529 const Type *ETy = ATy->getElementType();
4530 uint64_t NumElements = ATy->getNumElements();
4532 // Verify that we have the correct size...
4533 if (NumElements != uint64_t(-1) && NumElements != (yyvsp[(3) - (4)].ConstVector)->size())
4534 GEN_ERROR("Type mismatch: constant sized array initialized with " +
4535 utostr((yyvsp[(3) - (4)].ConstVector)->size()) + " arguments, but has size of " +
4536 utostr(NumElements) + "");
4538 // Verify all elements are correct type!
4539 for (unsigned i = 0; i < (yyvsp[(3) - (4)].ConstVector)->size(); i++) {
4540 if (ETy != (*(yyvsp[(3) - (4)].ConstVector))[i]->getType())
4541 GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
4542 ETy->getDescription() +"' as required!\nIt is of type '"+
4543 (*(yyvsp[(3) - (4)].ConstVector))[i]->getType()->getDescription() + "'.");
4546 (yyval.ConstVal) = ConstantArray::get(ATy, *(yyvsp[(3) - (4)].ConstVector));
4547 delete (yyvsp[(1) - (4)].TypeVal); delete (yyvsp[(3) - (4)].ConstVector);
4553 #line 1616 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4555 if (!UpRefs.empty())
4556 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription());
4557 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[(1) - (3)].TypeVal)->get());
4559 GEN_ERROR("Cannot make array constant with type: '" +
4560 (*(yyvsp[(1) - (3)].TypeVal))->getDescription() + "'");
4562 uint64_t NumElements = ATy->getNumElements();
4563 if (NumElements != uint64_t(-1) && NumElements != 0)
4564 GEN_ERROR("Type mismatch: constant sized array initialized with 0"
4565 " arguments, but has size of " + utostr(NumElements) +"");
4566 (yyval.ConstVal) = ConstantArray::get(ATy, std::vector<Constant*>());
4567 delete (yyvsp[(1) - (3)].TypeVal);
4573 #line 1632 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4575 if (!UpRefs.empty())
4576 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription());
4577 const ArrayType *ATy = dyn_cast<ArrayType>((yyvsp[(1) - (3)].TypeVal)->get());
4579 GEN_ERROR("Cannot make array constant with type: '" +
4580 (*(yyvsp[(1) - (3)].TypeVal))->getDescription() + "'");
4582 uint64_t NumElements = ATy->getNumElements();
4583 const Type *ETy = ATy->getElementType();
4584 if (NumElements != uint64_t(-1) && NumElements != (yyvsp[(3) - (3)].StrVal)->length())
4585 GEN_ERROR("Can't build string constant of size " +
4586 utostr((yyvsp[(3) - (3)].StrVal)->length()) +
4587 " when array has size " + utostr(NumElements) + "");
4588 std::vector<Constant*> Vals;
4589 if (ETy == Type::Int8Ty) {
4590 for (uint64_t i = 0; i < (yyvsp[(3) - (3)].StrVal)->length(); ++i)
4591 Vals.push_back(ConstantInt::get(ETy, (*(yyvsp[(3) - (3)].StrVal))[i]));
4593 delete (yyvsp[(3) - (3)].StrVal);
4594 GEN_ERROR("Cannot build string arrays of non byte sized elements");
4596 delete (yyvsp[(3) - (3)].StrVal);
4597 (yyval.ConstVal) = ConstantArray::get(ATy, Vals);
4598 delete (yyvsp[(1) - (3)].TypeVal);
4604 #line 1659 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4605 { // Nonempty unsized arr
4606 if (!UpRefs.empty())
4607 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (4)].TypeVal))->getDescription());
4608 const VectorType *PTy = dyn_cast<VectorType>((yyvsp[(1) - (4)].TypeVal)->get());
4610 GEN_ERROR("Cannot make packed constant with type: '" +
4611 (*(yyvsp[(1) - (4)].TypeVal))->getDescription() + "'");
4612 const Type *ETy = PTy->getElementType();
4613 unsigned NumElements = PTy->getNumElements();
4615 // Verify that we have the correct size...
4616 if (NumElements != unsigned(-1) && NumElements != (unsigned)(yyvsp[(3) - (4)].ConstVector)->size())
4617 GEN_ERROR("Type mismatch: constant sized packed initialized with " +
4618 utostr((yyvsp[(3) - (4)].ConstVector)->size()) + " arguments, but has size of " +
4619 utostr(NumElements) + "");
4621 // Verify all elements are correct type!
4622 for (unsigned i = 0; i < (yyvsp[(3) - (4)].ConstVector)->size(); i++) {
4623 if (ETy != (*(yyvsp[(3) - (4)].ConstVector))[i]->getType())
4624 GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
4625 ETy->getDescription() +"' as required!\nIt is of type '"+
4626 (*(yyvsp[(3) - (4)].ConstVector))[i]->getType()->getDescription() + "'.");
4629 (yyval.ConstVal) = ConstantVector::get(PTy, *(yyvsp[(3) - (4)].ConstVector));
4630 delete (yyvsp[(1) - (4)].TypeVal); delete (yyvsp[(3) - (4)].ConstVector);
4636 #line 1687 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4638 const StructType *STy = dyn_cast<StructType>((yyvsp[(1) - (4)].TypeVal)->get());
4640 GEN_ERROR("Cannot make struct constant with type: '" +
4641 (*(yyvsp[(1) - (4)].TypeVal))->getDescription() + "'");
4643 if ((yyvsp[(3) - (4)].ConstVector)->size() != STy->getNumContainedTypes())
4644 GEN_ERROR("Illegal number of initializers for structure type");
4646 // Check to ensure that constants are compatible with the type initializer!
4647 for (unsigned i = 0, e = (yyvsp[(3) - (4)].ConstVector)->size(); i != e; ++i)
4648 if ((*(yyvsp[(3) - (4)].ConstVector))[i]->getType() != STy->getElementType(i))
4649 GEN_ERROR("Expected type '" +
4650 STy->getElementType(i)->getDescription() +
4651 "' for element #" + utostr(i) +
4652 " of structure initializer");
4654 // Check to ensure that Type is not packed
4655 if (STy->isPacked())
4656 GEN_ERROR("Unpacked Initializer to vector type '" +
4657 STy->getDescription() + "'");
4659 (yyval.ConstVal) = ConstantStruct::get(STy, *(yyvsp[(3) - (4)].ConstVector));
4660 delete (yyvsp[(1) - (4)].TypeVal); delete (yyvsp[(3) - (4)].ConstVector);
4666 #line 1713 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4668 if (!UpRefs.empty())
4669 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription());
4670 const StructType *STy = dyn_cast<StructType>((yyvsp[(1) - (3)].TypeVal)->get());
4672 GEN_ERROR("Cannot make struct constant with type: '" +
4673 (*(yyvsp[(1) - (3)].TypeVal))->getDescription() + "'");
4675 if (STy->getNumContainedTypes() != 0)
4676 GEN_ERROR("Illegal number of initializers for structure type");
4678 // Check to ensure that Type is not packed
4679 if (STy->isPacked())
4680 GEN_ERROR("Unpacked Initializer to vector type '" +
4681 STy->getDescription() + "'");
4683 (yyval.ConstVal) = ConstantStruct::get(STy, std::vector<Constant*>());
4684 delete (yyvsp[(1) - (3)].TypeVal);
4690 #line 1733 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4692 const StructType *STy = dyn_cast<StructType>((yyvsp[(1) - (6)].TypeVal)->get());
4694 GEN_ERROR("Cannot make struct constant with type: '" +
4695 (*(yyvsp[(1) - (6)].TypeVal))->getDescription() + "'");
4697 if ((yyvsp[(4) - (6)].ConstVector)->size() != STy->getNumContainedTypes())
4698 GEN_ERROR("Illegal number of initializers for structure type");
4700 // Check to ensure that constants are compatible with the type initializer!
4701 for (unsigned i = 0, e = (yyvsp[(4) - (6)].ConstVector)->size(); i != e; ++i)
4702 if ((*(yyvsp[(4) - (6)].ConstVector))[i]->getType() != STy->getElementType(i))
4703 GEN_ERROR("Expected type '" +
4704 STy->getElementType(i)->getDescription() +
4705 "' for element #" + utostr(i) +
4706 " of structure initializer");
4708 // Check to ensure that Type is packed
4709 if (!STy->isPacked())
4710 GEN_ERROR("Vector initializer to non-vector type '" +
4711 STy->getDescription() + "'");
4713 (yyval.ConstVal) = ConstantStruct::get(STy, *(yyvsp[(4) - (6)].ConstVector));
4714 delete (yyvsp[(1) - (6)].TypeVal); delete (yyvsp[(4) - (6)].ConstVector);
4720 #line 1759 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4722 if (!UpRefs.empty())
4723 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (5)].TypeVal))->getDescription());
4724 const StructType *STy = dyn_cast<StructType>((yyvsp[(1) - (5)].TypeVal)->get());
4726 GEN_ERROR("Cannot make struct constant with type: '" +
4727 (*(yyvsp[(1) - (5)].TypeVal))->getDescription() + "'");
4729 if (STy->getNumContainedTypes() != 0)
4730 GEN_ERROR("Illegal number of initializers for structure type");
4732 // Check to ensure that Type is packed
4733 if (!STy->isPacked())
4734 GEN_ERROR("Vector initializer to non-vector type '" +
4735 STy->getDescription() + "'");
4737 (yyval.ConstVal) = ConstantStruct::get(STy, std::vector<Constant*>());
4738 delete (yyvsp[(1) - (5)].TypeVal);
4744 #line 1779 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4746 if (!UpRefs.empty())
4747 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
4748 const PointerType *PTy = dyn_cast<PointerType>((yyvsp[(1) - (2)].TypeVal)->get());
4750 GEN_ERROR("Cannot make null pointer constant with type: '" +
4751 (*(yyvsp[(1) - (2)].TypeVal))->getDescription() + "'");
4753 (yyval.ConstVal) = ConstantPointerNull::get(PTy);
4754 delete (yyvsp[(1) - (2)].TypeVal);
4760 #line 1791 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4762 if (!UpRefs.empty())
4763 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
4764 (yyval.ConstVal) = UndefValue::get((yyvsp[(1) - (2)].TypeVal)->get());
4765 delete (yyvsp[(1) - (2)].TypeVal);
4771 #line 1798 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4773 if (!UpRefs.empty())
4774 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
4775 const PointerType *Ty = dyn_cast<PointerType>((yyvsp[(1) - (2)].TypeVal)->get());
4777 GEN_ERROR("Global const reference must be a pointer type " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
4779 // ConstExprs can exist in the body of a function, thus creating
4780 // GlobalValues whenever they refer to a variable. Because we are in
4781 // the context of a function, getExistingVal will search the functions
4782 // symbol table instead of the module symbol table for the global symbol,
4783 // which throws things all off. To get around this, we just tell
4784 // getExistingVal that we are at global scope here.
4786 Function *SavedCurFn = CurFun.CurrentFunction;
4787 CurFun.CurrentFunction = 0;
4789 Value *V = getExistingVal(Ty, (yyvsp[(2) - (2)].ValIDVal));
4792 CurFun.CurrentFunction = SavedCurFn;
4794 // If this is an initializer for a constant pointer, which is referencing a
4795 // (currently) undefined variable, create a stub now that shall be replaced
4796 // in the future with the right type of variable.
4799 assert(isa<PointerType>(Ty) && "Globals may only be used as pointers!");
4800 const PointerType *PT = cast<PointerType>(Ty);
4802 // First check to see if the forward references value is already created!
4803 PerModuleInfo::GlobalRefsType::iterator I =
4804 CurModule.GlobalRefs.find(std::make_pair(PT, (yyvsp[(2) - (2)].ValIDVal)));
4806 if (I != CurModule.GlobalRefs.end()) {
4807 V = I->second; // Placeholder already exists, use it...
4808 (yyvsp[(2) - (2)].ValIDVal).destroy();
4811 if ((yyvsp[(2) - (2)].ValIDVal).Type == ValID::GlobalName)
4812 Name = (yyvsp[(2) - (2)].ValIDVal).getName();
4813 else if ((yyvsp[(2) - (2)].ValIDVal).Type != ValID::GlobalID)
4814 GEN_ERROR("Invalid reference to global");
4816 // Create the forward referenced global.
4818 if (const FunctionType *FTy =
4819 dyn_cast<FunctionType>(PT->getElementType())) {
4820 GV = Function::Create(FTy, GlobalValue::ExternalWeakLinkage, Name,
4821 CurModule.CurrentModule);
4823 GV = new GlobalVariable(PT->getElementType(), false,
4824 GlobalValue::ExternalWeakLinkage, 0,
4825 Name, CurModule.CurrentModule);
4828 // Keep track of the fact that we have a forward ref to recycle it
4829 CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, (yyvsp[(2) - (2)].ValIDVal)), GV));
4834 (yyval.ConstVal) = cast<GlobalValue>(V);
4835 delete (yyvsp[(1) - (2)].TypeVal); // Free the type handle
4841 #line 1864 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4843 if (!UpRefs.empty())
4844 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
4845 if ((yyvsp[(1) - (2)].TypeVal)->get() != (yyvsp[(2) - (2)].ConstVal)->getType())
4846 GEN_ERROR("Mismatched types for constant expression: " +
4847 (*(yyvsp[(1) - (2)].TypeVal))->getDescription() + " and " + (yyvsp[(2) - (2)].ConstVal)->getType()->getDescription());
4848 (yyval.ConstVal) = (yyvsp[(2) - (2)].ConstVal);
4849 delete (yyvsp[(1) - (2)].TypeVal);
4855 #line 1874 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4857 if (!UpRefs.empty())
4858 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
4859 const Type *Ty = (yyvsp[(1) - (2)].TypeVal)->get();
4860 if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty))
4861 GEN_ERROR("Cannot create a null initialized value of this type");
4862 (yyval.ConstVal) = Constant::getNullValue(Ty);
4863 delete (yyvsp[(1) - (2)].TypeVal);
4869 #line 1884 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4870 { // integral constants
4871 if (IntegerType *IT = dyn_cast<IntegerType>((yyvsp[(1) - (2)].TypeVal)->get())) {
4872 if (!ConstantInt::isValueValidForType(IT, (yyvsp[(2) - (2)].SInt64Val)))
4873 GEN_ERROR("Constant value doesn't fit in type");
4874 (yyval.ConstVal) = ConstantInt::get(IT, (yyvsp[(2) - (2)].SInt64Val), true);
4876 GEN_ERROR("integer constant must have integer type");
4878 delete (yyvsp[(1) - (2)].TypeVal);
4884 #line 1895 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4885 { // arbitrary precision integer constants
4886 if (IntegerType *IT = dyn_cast<IntegerType>((yyvsp[(1) - (2)].TypeVal)->get())) {
4887 if ((yyvsp[(2) - (2)].APIntVal)->getBitWidth() > IT->getBitWidth())
4888 GEN_ERROR("Constant value does not fit in type");
4889 (yyvsp[(2) - (2)].APIntVal)->sextOrTrunc(IT->getBitWidth());
4890 (yyval.ConstVal) = ConstantInt::get(*(yyvsp[(2) - (2)].APIntVal));
4892 GEN_ERROR("integer constant must have integer type");
4894 delete (yyvsp[(1) - (2)].TypeVal);
4895 delete (yyvsp[(2) - (2)].APIntVal);
4901 #line 1908 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4902 { // integral constants
4903 if (IntegerType *IT = dyn_cast<IntegerType>((yyvsp[(1) - (2)].TypeVal)->get())) {
4904 if (!ConstantInt::isValueValidForType(IT, (yyvsp[(2) - (2)].UInt64Val)))
4905 GEN_ERROR("Constant value doesn't fit in type");
4906 (yyval.ConstVal) = ConstantInt::get(IT, (yyvsp[(2) - (2)].UInt64Val), false);
4908 GEN_ERROR("integer constant must have integer type");
4910 delete (yyvsp[(1) - (2)].TypeVal);
4916 #line 1919 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4917 { // arbitrary precision integer constants
4918 if (IntegerType *IT = dyn_cast<IntegerType>((yyvsp[(1) - (2)].TypeVal)->get())) {
4919 if ((yyvsp[(2) - (2)].APIntVal)->getBitWidth() > IT->getBitWidth())
4920 GEN_ERROR("Constant value does not fit in type");
4921 (yyvsp[(2) - (2)].APIntVal)->zextOrTrunc(IT->getBitWidth());
4922 (yyval.ConstVal) = ConstantInt::get(*(yyvsp[(2) - (2)].APIntVal));
4924 GEN_ERROR("integer constant must have integer type");
4927 delete (yyvsp[(2) - (2)].APIntVal);
4928 delete (yyvsp[(1) - (2)].TypeVal);
4934 #line 1933 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4935 { // Boolean constants
4936 if ((yyvsp[(1) - (2)].TypeVal)->get() != Type::Int1Ty)
4937 GEN_ERROR("Constant true must have type i1");
4938 (yyval.ConstVal) = ConstantInt::getTrue();
4939 delete (yyvsp[(1) - (2)].TypeVal);
4945 #line 1940 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4946 { // Boolean constants
4947 if ((yyvsp[(1) - (2)].TypeVal)->get() != Type::Int1Ty)
4948 GEN_ERROR("Constant false must have type i1");
4949 (yyval.ConstVal) = ConstantInt::getFalse();
4950 delete (yyvsp[(1) - (2)].TypeVal);
4956 #line 1947 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4957 { // Floating point constants
4958 if (!ConstantFP::isValueValidForType((yyvsp[(1) - (2)].TypeVal)->get(), *(yyvsp[(2) - (2)].FPVal)))
4959 GEN_ERROR("Floating point constant invalid for type");
4961 // Lexer has no type info, so builds all float and double FP constants
4962 // as double. Fix this here. Long double is done right.
4963 if (&(yyvsp[(2) - (2)].FPVal)->getSemantics()==&APFloat::IEEEdouble && (yyvsp[(1) - (2)].TypeVal)->get()==Type::FloatTy) {
4965 (yyvsp[(2) - (2)].FPVal)->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven,
4968 (yyval.ConstVal) = ConstantFP::get(*(yyvsp[(2) - (2)].FPVal));
4969 delete (yyvsp[(1) - (2)].TypeVal);
4970 delete (yyvsp[(2) - (2)].FPVal);
4976 #line 1965 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4978 if (!UpRefs.empty())
4979 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(5) - (6)].TypeVal))->getDescription());
4980 Constant *Val = (yyvsp[(3) - (6)].ConstVal);
4981 const Type *DestTy = (yyvsp[(5) - (6)].TypeVal)->get();
4982 if (!CastInst::castIsValid((yyvsp[(1) - (6)].CastOpVal), (yyvsp[(3) - (6)].ConstVal), DestTy))
4983 GEN_ERROR("invalid cast opcode for cast from '" +
4984 Val->getType()->getDescription() + "' to '" +
4985 DestTy->getDescription() + "'");
4986 (yyval.ConstVal) = ConstantExpr::getCast((yyvsp[(1) - (6)].CastOpVal), (yyvsp[(3) - (6)].ConstVal), DestTy);
4987 delete (yyvsp[(5) - (6)].TypeVal);
4992 #line 1977 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
4994 if (!isa<PointerType>((yyvsp[(3) - (5)].ConstVal)->getType()))
4995 GEN_ERROR("GetElementPtr requires a pointer operand");
4998 GetElementPtrInst::getIndexedType((yyvsp[(3) - (5)].ConstVal)->getType(), (yyvsp[(4) - (5)].ValueList)->begin(), (yyvsp[(4) - (5)].ValueList)->end());
5000 GEN_ERROR("Index list invalid for constant getelementptr");
5002 SmallVector<Constant*, 8> IdxVec;
5003 for (unsigned i = 0, e = (yyvsp[(4) - (5)].ValueList)->size(); i != e; ++i)
5004 if (Constant *C = dyn_cast<Constant>((*(yyvsp[(4) - (5)].ValueList))[i]))
5005 IdxVec.push_back(C);
5007 GEN_ERROR("Indices to constant getelementptr must be constants");
5009 delete (yyvsp[(4) - (5)].ValueList);
5011 (yyval.ConstVal) = ConstantExpr::getGetElementPtr((yyvsp[(3) - (5)].ConstVal), &IdxVec[0], IdxVec.size());
5017 #line 1998 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5019 if ((yyvsp[(3) - (8)].ConstVal)->getType() != Type::Int1Ty)
5020 GEN_ERROR("Select condition must be of boolean type");
5021 if ((yyvsp[(5) - (8)].ConstVal)->getType() != (yyvsp[(7) - (8)].ConstVal)->getType())
5022 GEN_ERROR("Select operand types must match");
5023 (yyval.ConstVal) = ConstantExpr::getSelect((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal));
5029 #line 2006 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5031 if ((yyvsp[(3) - (6)].ConstVal)->getType() != (yyvsp[(5) - (6)].ConstVal)->getType())
5032 GEN_ERROR("Binary operator types must match");
5034 (yyval.ConstVal) = ConstantExpr::get((yyvsp[(1) - (6)].BinaryOpVal), (yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal));
5039 #line 2012 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5041 if ((yyvsp[(3) - (6)].ConstVal)->getType() != (yyvsp[(5) - (6)].ConstVal)->getType())
5042 GEN_ERROR("Logical operator types must match");
5043 if (!(yyvsp[(3) - (6)].ConstVal)->getType()->isInteger()) {
5044 if (!isa<VectorType>((yyvsp[(3) - (6)].ConstVal)->getType()) ||
5045 !cast<VectorType>((yyvsp[(3) - (6)].ConstVal)->getType())->getElementType()->isInteger())
5046 GEN_ERROR("Logical operator requires integral operands");
5048 (yyval.ConstVal) = ConstantExpr::get((yyvsp[(1) - (6)].BinaryOpVal), (yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal));
5054 #line 2023 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5056 if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType())
5057 GEN_ERROR("icmp operand types must match");
5058 (yyval.ConstVal) = ConstantExpr::getICmp((yyvsp[(2) - (7)].IPredicate), (yyvsp[(4) - (7)].ConstVal), (yyvsp[(6) - (7)].ConstVal));
5063 #line 2028 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5065 if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType())
5066 GEN_ERROR("fcmp operand types must match");
5067 (yyval.ConstVal) = ConstantExpr::getFCmp((yyvsp[(2) - (7)].FPredicate), (yyvsp[(4) - (7)].ConstVal), (yyvsp[(6) - (7)].ConstVal));
5072 #line 2033 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5074 if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType())
5075 GEN_ERROR("vicmp operand types must match");
5076 (yyval.ConstVal) = ConstantExpr::getVICmp((yyvsp[(2) - (7)].IPredicate), (yyvsp[(4) - (7)].ConstVal), (yyvsp[(6) - (7)].ConstVal));
5081 #line 2038 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5083 if ((yyvsp[(4) - (7)].ConstVal)->getType() != (yyvsp[(6) - (7)].ConstVal)->getType())
5084 GEN_ERROR("vfcmp operand types must match");
5085 (yyval.ConstVal) = ConstantExpr::getVFCmp((yyvsp[(2) - (7)].FPredicate), (yyvsp[(4) - (7)].ConstVal), (yyvsp[(6) - (7)].ConstVal));
5090 #line 2043 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5092 if (!ExtractElementInst::isValidOperands((yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal)))
5093 GEN_ERROR("Invalid extractelement operands");
5094 (yyval.ConstVal) = ConstantExpr::getExtractElement((yyvsp[(3) - (6)].ConstVal), (yyvsp[(5) - (6)].ConstVal));
5100 #line 2049 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5102 if (!InsertElementInst::isValidOperands((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal)))
5103 GEN_ERROR("Invalid insertelement operands");
5104 (yyval.ConstVal) = ConstantExpr::getInsertElement((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal));
5110 #line 2055 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5112 if (!ShuffleVectorInst::isValidOperands((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal)))
5113 GEN_ERROR("Invalid shufflevector operands");
5114 (yyval.ConstVal) = ConstantExpr::getShuffleVector((yyvsp[(3) - (8)].ConstVal), (yyvsp[(5) - (8)].ConstVal), (yyvsp[(7) - (8)].ConstVal));
5120 #line 2061 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5122 if (!isa<StructType>((yyvsp[(3) - (5)].ConstVal)->getType()) && !isa<ArrayType>((yyvsp[(3) - (5)].ConstVal)->getType()))
5123 GEN_ERROR("ExtractValue requires an aggregate operand");
5125 (yyval.ConstVal) = ConstantExpr::getExtractValue((yyvsp[(3) - (5)].ConstVal), &(*(yyvsp[(4) - (5)].ConstantList))[0], (yyvsp[(4) - (5)].ConstantList)->size());
5126 delete (yyvsp[(4) - (5)].ConstantList);
5132 #line 2069 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5134 if (!isa<StructType>((yyvsp[(3) - (7)].ConstVal)->getType()) && !isa<ArrayType>((yyvsp[(3) - (7)].ConstVal)->getType()))
5135 GEN_ERROR("InsertValue requires an aggregate operand");
5137 (yyval.ConstVal) = ConstantExpr::getInsertValue((yyvsp[(3) - (7)].ConstVal), (yyvsp[(5) - (7)].ConstVal), &(*(yyvsp[(6) - (7)].ConstantList))[0], (yyvsp[(6) - (7)].ConstantList)->size());
5138 delete (yyvsp[(6) - (7)].ConstantList);
5144 #line 2080 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5146 ((yyval.ConstVector) = (yyvsp[(1) - (3)].ConstVector))->push_back((yyvsp[(3) - (3)].ConstVal));
5152 #line 2084 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5154 (yyval.ConstVector) = new std::vector<Constant*>();
5155 (yyval.ConstVector)->push_back((yyvsp[(1) - (1)].ConstVal));
5161 #line 2092 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5162 { (yyval.BoolVal) = false; ;}
5166 #line 2092 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5167 { (yyval.BoolVal) = true; ;}
5171 #line 2095 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5172 { (yyval.BoolVal) = true; ;}
5176 #line 2095 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5177 { (yyval.BoolVal) = false; ;}
5181 #line 2098 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5183 const Type* VTy = (yyvsp[(1) - (2)].TypeVal)->get();
5184 Value *V = getVal(VTy, (yyvsp[(2) - (2)].ValIDVal));
5186 GlobalValue* Aliasee = dyn_cast<GlobalValue>(V);
5188 GEN_ERROR("Aliases can be created only to global values");
5190 (yyval.ConstVal) = Aliasee;
5192 delete (yyvsp[(1) - (2)].TypeVal);
5197 #line 2110 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5199 Constant *Val = (yyvsp[(3) - (6)].ConstVal);
5200 const Type *DestTy = (yyvsp[(5) - (6)].TypeVal)->get();
5201 if (!CastInst::castIsValid((yyvsp[(1) - (6)].CastOpVal), (yyvsp[(3) - (6)].ConstVal), DestTy))
5202 GEN_ERROR("invalid cast opcode for cast from '" +
5203 Val->getType()->getDescription() + "' to '" +
5204 DestTy->getDescription() + "'");
5206 (yyval.ConstVal) = ConstantExpr::getCast((yyvsp[(1) - (6)].CastOpVal), (yyvsp[(3) - (6)].ConstVal), DestTy);
5208 delete (yyvsp[(5) - (6)].TypeVal);
5213 #line 2131 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5215 (yyval.ModuleVal) = ParserResult = CurModule.CurrentModule;
5216 CurModule.ModuleDone();
5222 #line 2136 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5224 (yyval.ModuleVal) = ParserResult = CurModule.CurrentModule;
5225 CurModule.ModuleDone();
5231 #line 2149 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5232 { CurFun.isDeclare = false; ;}
5236 #line 2149 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5238 CurFun.FunctionDone();
5244 #line 2153 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5245 { CurFun.isDeclare = true; ;}
5249 #line 2153 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5256 #line 2156 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5263 #line 2159 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5265 if (!UpRefs.empty())
5266 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (3)].TypeVal))->getDescription());
5267 // Eagerly resolve types. This is not an optimization, this is a
5268 // requirement that is due to the fact that we could have this:
5270 // %list = type { %list * }
5271 // %list = type { %list * } ; repeated type decl
5273 // If types are not resolved eagerly, then the two types will not be
5274 // determined to be the same type!
5276 ResolveTypeTo((yyvsp[(1) - (3)].StrVal), *(yyvsp[(3) - (3)].TypeVal));
5278 if (!setTypeName(*(yyvsp[(3) - (3)].TypeVal), (yyvsp[(1) - (3)].StrVal)) && !(yyvsp[(1) - (3)].StrVal)) {
5280 // If this is a named type that is not a redefinition, add it to the slot
5282 CurModule.Types.push_back(*(yyvsp[(3) - (3)].TypeVal));
5285 delete (yyvsp[(3) - (3)].TypeVal);
5291 #line 2183 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5293 ResolveTypeTo((yyvsp[(1) - (3)].StrVal), (yyvsp[(3) - (3)].PrimType));
5295 if (!setTypeName((yyvsp[(3) - (3)].PrimType), (yyvsp[(1) - (3)].StrVal)) && !(yyvsp[(1) - (3)].StrVal)) {
5297 // If this is a named type that is not a redefinition, add it to the slot
5299 CurModule.Types.push_back((yyvsp[(3) - (3)].PrimType));
5306 #line 2195 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5308 /* "Externally Visible" Linkage */
5309 if ((yyvsp[(5) - (6)].ConstVal) == 0)
5310 GEN_ERROR("Global value initializer is not a constant");
5311 CurGV = ParseGlobalVariable((yyvsp[(1) - (6)].StrVal), GlobalValue::ExternalLinkage,
5312 (yyvsp[(2) - (6)].Visibility), (yyvsp[(4) - (6)].BoolVal), (yyvsp[(5) - (6)].ConstVal)->getType(), (yyvsp[(5) - (6)].ConstVal), (yyvsp[(3) - (6)].BoolVal), (yyvsp[(6) - (6)].UIntVal));
5318 #line 2202 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5325 #line 2206 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5327 if ((yyvsp[(6) - (7)].ConstVal) == 0)
5328 GEN_ERROR("Global value initializer is not a constant");
5329 CurGV = ParseGlobalVariable((yyvsp[(1) - (7)].StrVal), (yyvsp[(2) - (7)].Linkage), (yyvsp[(3) - (7)].Visibility), (yyvsp[(5) - (7)].BoolVal), (yyvsp[(6) - (7)].ConstVal)->getType(), (yyvsp[(6) - (7)].ConstVal), (yyvsp[(4) - (7)].BoolVal), (yyvsp[(7) - (7)].UIntVal));
5335 #line 2211 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5342 #line 2215 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5344 if (!UpRefs.empty())
5345 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(6) - (7)].TypeVal))->getDescription());
5346 CurGV = ParseGlobalVariable((yyvsp[(1) - (7)].StrVal), (yyvsp[(2) - (7)].Linkage), (yyvsp[(3) - (7)].Visibility), (yyvsp[(5) - (7)].BoolVal), *(yyvsp[(6) - (7)].TypeVal), 0, (yyvsp[(4) - (7)].BoolVal), (yyvsp[(7) - (7)].UIntVal));
5348 delete (yyvsp[(6) - (7)].TypeVal);
5353 #line 2221 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5361 #line 2225 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5364 if ((yyvsp[(1) - (5)].StrVal)) {
5365 Name = *(yyvsp[(1) - (5)].StrVal);
5366 delete (yyvsp[(1) - (5)].StrVal);
5369 GEN_ERROR("Alias name cannot be empty");
5371 Constant* Aliasee = (yyvsp[(5) - (5)].ConstVal);
5373 GEN_ERROR(std::string("Invalid aliasee for alias: ") + Name);
5375 GlobalAlias* GA = new GlobalAlias(Aliasee->getType(), (yyvsp[(4) - (5)].Linkage), Name, Aliasee,
5376 CurModule.CurrentModule);
5377 GA->setVisibility((yyvsp[(2) - (5)].Visibility));
5378 InsertValue(GA, CurModule.Values);
5381 // If there was a forward reference of this alias, resolve it now.
5385 ID = ValID::createGlobalName(Name);
5387 ID = ValID::createGlobalID(CurModule.Values.size()-1);
5389 if (GlobalValue *FWGV =
5390 CurModule.GetForwardRefForGlobal(GA->getType(), ID)) {
5391 // Replace uses of the fwdref with the actual alias.
5392 FWGV->replaceAllUsesWith(GA);
5393 if (GlobalVariable *GV = dyn_cast<GlobalVariable>(FWGV))
5394 GV->eraseFromParent();
5396 cast<Function>(FWGV)->eraseFromParent();
5405 #line 2265 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5412 #line 2268 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5419 #line 2274 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5421 const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
5422 if (AsmSoFar.empty())
5423 CurModule.CurrentModule->setModuleInlineAsm(*(yyvsp[(1) - (1)].StrVal));
5425 CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+*(yyvsp[(1) - (1)].StrVal));
5426 delete (yyvsp[(1) - (1)].StrVal);
5432 #line 2284 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5434 CurModule.CurrentModule->setTargetTriple(*(yyvsp[(3) - (3)].StrVal));
5435 delete (yyvsp[(3) - (3)].StrVal);
5440 #line 2288 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5442 CurModule.CurrentModule->setDataLayout(*(yyvsp[(3) - (3)].StrVal));
5443 delete (yyvsp[(3) - (3)].StrVal);
5448 #line 2295 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5450 CurModule.CurrentModule->addLibrary(*(yyvsp[(3) - (3)].StrVal));
5451 delete (yyvsp[(3) - (3)].StrVal);
5457 #line 2300 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5459 CurModule.CurrentModule->addLibrary(*(yyvsp[(1) - (1)].StrVal));
5460 delete (yyvsp[(1) - (1)].StrVal);
5466 #line 2305 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5473 #line 2314 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5475 if (!UpRefs.empty())
5476 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (5)].TypeVal))->getDescription());
5477 if (!(*(yyvsp[(3) - (5)].TypeVal))->isFirstClassType())
5478 GEN_ERROR("Argument types must be first-class");
5479 ArgListEntry E; E.Attrs = (yyvsp[(4) - (5)].Attributes); E.Ty = (yyvsp[(3) - (5)].TypeVal); E.Name = (yyvsp[(5) - (5)].StrVal);
5480 (yyval.ArgList) = (yyvsp[(1) - (5)].ArgList);
5481 (yyvsp[(1) - (5)].ArgList)->push_back(E);
5487 #line 2324 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5489 if (!UpRefs.empty())
5490 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (3)].TypeVal))->getDescription());
5491 if (!(*(yyvsp[(1) - (3)].TypeVal))->isFirstClassType())
5492 GEN_ERROR("Argument types must be first-class");
5493 ArgListEntry E; E.Attrs = (yyvsp[(2) - (3)].Attributes); E.Ty = (yyvsp[(1) - (3)].TypeVal); E.Name = (yyvsp[(3) - (3)].StrVal);
5494 (yyval.ArgList) = new ArgListType;
5495 (yyval.ArgList)->push_back(E);
5501 #line 2335 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5503 (yyval.ArgList) = (yyvsp[(1) - (1)].ArgList);
5509 #line 2339 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5511 (yyval.ArgList) = (yyvsp[(1) - (3)].ArgList);
5512 struct ArgListEntry E;
5513 E.Ty = new PATypeHolder(Type::VoidTy);
5515 E.Attrs = Attribute::None;
5516 (yyval.ArgList)->push_back(E);
5522 #line 2348 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5524 (yyval.ArgList) = new ArgListType;
5525 struct ArgListEntry E;
5526 E.Ty = new PATypeHolder(Type::VoidTy);
5528 E.Attrs = Attribute::None;
5529 (yyval.ArgList)->push_back(E);
5535 #line 2357 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5537 (yyval.ArgList) = 0;
5543 #line 2363 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5545 std::string FunctionName(*(yyvsp[(4) - (11)].StrVal));
5546 delete (yyvsp[(4) - (11)].StrVal); // Free strdup'd memory!
5548 // Check the function result for abstractness if this is a define. We should
5549 // have no abstract types at this point
5550 if (!CurFun.isDeclare && CurModule.TypeIsUnresolved((yyvsp[(3) - (11)].TypeVal)))
5551 GEN_ERROR("Reference to abstract result: "+ (yyvsp[(3) - (11)].TypeVal)->get()->getDescription());
5553 if (!FunctionType::isValidReturnType(*(yyvsp[(3) - (11)].TypeVal)))
5554 GEN_ERROR("Invalid result type for LLVM function");
5556 std::vector<const Type*> ParamTypeList;
5557 SmallVector<AttributeWithIndex, 8> Attrs;
5558 //FIXME : In 3.0, stop accepting zext, sext and inreg as optional function
5560 Attributes RetAttrs = (yyvsp[(2) - (11)].Attributes);
5561 if ((yyvsp[(8) - (11)].Attributes) != Attribute::None) {
5562 if ((yyvsp[(8) - (11)].Attributes) & Attribute::ZExt) {
5563 RetAttrs = RetAttrs | Attribute::ZExt;
5564 (yyvsp[(8) - (11)].Attributes) = (yyvsp[(8) - (11)].Attributes) ^ Attribute::ZExt;
5566 if ((yyvsp[(8) - (11)].Attributes) & Attribute::SExt) {
5567 RetAttrs = RetAttrs | Attribute::SExt;
5568 (yyvsp[(8) - (11)].Attributes) = (yyvsp[(8) - (11)].Attributes) ^ Attribute::SExt;
5570 if ((yyvsp[(8) - (11)].Attributes) & Attribute::InReg) {
5571 RetAttrs = RetAttrs | Attribute::InReg;
5572 (yyvsp[(8) - (11)].Attributes) = (yyvsp[(8) - (11)].Attributes) ^ Attribute::InReg;
5575 if (RetAttrs != Attribute::None)
5576 Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
5577 if ((yyvsp[(6) - (11)].ArgList)) { // If there are arguments...
5579 for (ArgListType::iterator I = (yyvsp[(6) - (11)].ArgList)->begin(); I != (yyvsp[(6) - (11)].ArgList)->end(); ++I, ++index) {
5580 const Type* Ty = I->Ty->get();
5581 if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(I->Ty))
5582 GEN_ERROR("Reference to abstract argument: " + Ty->getDescription());
5583 ParamTypeList.push_back(Ty);
5584 if (Ty != Type::VoidTy && I->Attrs != Attribute::None)
5585 Attrs.push_back(AttributeWithIndex::get(index, I->Attrs));
5588 if ((yyvsp[(8) - (11)].Attributes) != Attribute::None)
5589 Attrs.push_back(AttributeWithIndex::get(~0, (yyvsp[(8) - (11)].Attributes)));
5591 bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
5592 if (isVarArg) ParamTypeList.pop_back();
5596 PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
5598 FunctionType *FT = FunctionType::get(*(yyvsp[(3) - (11)].TypeVal), ParamTypeList, isVarArg);
5599 const PointerType *PFT = PointerType::getUnqual(FT);
5600 delete (yyvsp[(3) - (11)].TypeVal);
5603 if (!FunctionName.empty()) {
5604 ID = ValID::createGlobalName((char*)FunctionName.c_str());
5606 ID = ValID::createGlobalID(CurModule.Values.size());
5610 // See if this function was forward referenced. If so, recycle the object.
5611 if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
5612 // Move the function to the end of the list, from whereever it was
5613 // previously inserted.
5614 Fn = cast<Function>(FWRef);
5615 assert(Fn->getAttributes().isEmpty() &&
5616 "Forward reference has parameter attributes!");
5617 CurModule.CurrentModule->getFunctionList().remove(Fn);
5618 CurModule.CurrentModule->getFunctionList().push_back(Fn);
5619 } else if (!FunctionName.empty() && // Merge with an earlier prototype?
5620 (Fn = CurModule.CurrentModule->getFunction(FunctionName))) {
5621 if (Fn->getFunctionType() != FT ) {
5622 // The existing function doesn't have the same type. This is an overload
5624 GEN_ERROR("Overload of function '" + FunctionName + "' not permitted.");
5625 } else if (Fn->getAttributes() != PAL) {
5626 // The existing function doesn't have the same parameter attributes.
5627 // This is an overload error.
5628 GEN_ERROR("Overload of function '" + FunctionName + "' not permitted.");
5629 } else if (!CurFun.isDeclare && !Fn->isDeclaration()) {
5630 // Neither the existing or the current function is a declaration and they
5631 // have the same name and same type. Clearly this is a redefinition.
5632 GEN_ERROR("Redefinition of function '" + FunctionName + "'");
5633 } else if (Fn->isDeclaration()) {
5634 // Make sure to strip off any argument names so we can't get conflicts.
5635 for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
5639 } else { // Not already defined?
5640 Fn = Function::Create(FT, GlobalValue::ExternalWeakLinkage, FunctionName,
5641 CurModule.CurrentModule);
5642 InsertValue(Fn, CurModule.Values);
5646 CurFun.FunctionStart(Fn);
5648 if (CurFun.isDeclare) {
5649 // If we have declaration, always overwrite linkage. This will allow us to
5650 // correctly handle cases, when pointer to function is passed as argument to
5651 // another function.
5652 Fn->setLinkage(CurFun.Linkage);
5653 Fn->setVisibility(CurFun.Visibility);
5655 Fn->setCallingConv((yyvsp[(1) - (11)].UIntVal));
5656 Fn->setAttributes(PAL);
5657 Fn->setAlignment((yyvsp[(10) - (11)].UIntVal));
5658 if ((yyvsp[(9) - (11)].StrVal)) {
5659 Fn->setSection(*(yyvsp[(9) - (11)].StrVal));
5660 delete (yyvsp[(9) - (11)].StrVal);
5662 if ((yyvsp[(11) - (11)].StrVal)) {
5663 Fn->setGC((yyvsp[(11) - (11)].StrVal)->c_str());
5664 delete (yyvsp[(11) - (11)].StrVal);
5667 // Add all of the arguments we parsed to the function...
5668 if ((yyvsp[(6) - (11)].ArgList)) { // Is null if empty...
5669 if (isVarArg) { // Nuke the last entry
5670 assert((yyvsp[(6) - (11)].ArgList)->back().Ty->get() == Type::VoidTy && (yyvsp[(6) - (11)].ArgList)->back().Name == 0 &&
5671 "Not a varargs marker!");
5672 delete (yyvsp[(6) - (11)].ArgList)->back().Ty;
5673 (yyvsp[(6) - (11)].ArgList)->pop_back(); // Delete the last entry
5675 Function::arg_iterator ArgIt = Fn->arg_begin();
5676 Function::arg_iterator ArgEnd = Fn->arg_end();
5678 for (ArgListType::iterator I = (yyvsp[(6) - (11)].ArgList)->begin();
5679 I != (yyvsp[(6) - (11)].ArgList)->end() && ArgIt != ArgEnd; ++I, ++ArgIt) {
5680 delete I->Ty; // Delete the typeholder...
5681 setValueName(ArgIt, I->Name); // Insert arg into symtab...
5687 delete (yyvsp[(6) - (11)].ArgList); // We're now done with the argument list
5694 #line 2513 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5696 (yyval.FunctionVal) = CurFun.CurrentFunction;
5698 // Make sure that we keep track of the linkage type even if there was a
5699 // previous "declare".
5700 (yyval.FunctionVal)->setLinkage((yyvsp[(1) - (4)].Linkage));
5701 (yyval.FunctionVal)->setVisibility((yyvsp[(2) - (4)].Visibility));
5706 #line 2524 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5708 (yyval.FunctionVal) = (yyvsp[(1) - (2)].FunctionVal);
5714 #line 2529 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5716 CurFun.CurrentFunction->setLinkage((yyvsp[(1) - (3)].Linkage));
5717 CurFun.CurrentFunction->setVisibility((yyvsp[(2) - (3)].Visibility));
5718 (yyval.FunctionVal) = CurFun.CurrentFunction;
5719 CurFun.FunctionDone();
5725 #line 2541 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5727 (yyval.BoolVal) = false;
5733 #line 2545 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5735 (yyval.BoolVal) = true;
5741 #line 2550 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5742 { // A reference to a direct constant
5743 (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].SInt64Val));
5749 #line 2554 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5751 (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].UInt64Val));
5757 #line 2558 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5758 { // arbitrary precision integer constants
5759 (yyval.ValIDVal) = ValID::create(*(yyvsp[(1) - (1)].APIntVal), true);
5760 delete (yyvsp[(1) - (1)].APIntVal);
5766 #line 2563 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5767 { // arbitrary precision integer constants
5768 (yyval.ValIDVal) = ValID::create(*(yyvsp[(1) - (1)].APIntVal), false);
5769 delete (yyvsp[(1) - (1)].APIntVal);
5775 #line 2568 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5776 { // Perhaps it's an FP constant?
5777 (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].FPVal));
5783 #line 2572 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5785 (yyval.ValIDVal) = ValID::create(ConstantInt::getTrue());
5791 #line 2576 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5793 (yyval.ValIDVal) = ValID::create(ConstantInt::getFalse());
5799 #line 2580 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5801 (yyval.ValIDVal) = ValID::createNull();
5807 #line 2584 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5809 (yyval.ValIDVal) = ValID::createUndef();
5815 #line 2588 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5816 { // A vector zero constant.
5817 (yyval.ValIDVal) = ValID::createZeroInit();
5823 #line 2592 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5824 { // Nonempty unsized packed vector
5825 const Type *ETy = (*(yyvsp[(2) - (3)].ConstVector))[0]->getType();
5826 unsigned NumElements = (yyvsp[(2) - (3)].ConstVector)->size();
5828 if (!ETy->isInteger() && !ETy->isFloatingPoint())
5829 GEN_ERROR("Invalid vector element type: " + ETy->getDescription());
5831 VectorType* pt = VectorType::get(ETy, NumElements);
5832 PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(pt));
5834 // Verify all elements are correct type!
5835 for (unsigned i = 0; i < (yyvsp[(2) - (3)].ConstVector)->size(); i++) {
5836 if (ETy != (*(yyvsp[(2) - (3)].ConstVector))[i]->getType())
5837 GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
5838 ETy->getDescription() +"' as required!\nIt is of type '" +
5839 (*(yyvsp[(2) - (3)].ConstVector))[i]->getType()->getDescription() + "'.");
5842 (yyval.ValIDVal) = ValID::create(ConstantVector::get(pt, *(yyvsp[(2) - (3)].ConstVector)));
5843 delete PTy; delete (yyvsp[(2) - (3)].ConstVector);
5849 #line 2614 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5850 { // Nonempty unsized arr
5851 const Type *ETy = (*(yyvsp[(2) - (3)].ConstVector))[0]->getType();
5852 uint64_t NumElements = (yyvsp[(2) - (3)].ConstVector)->size();
5854 if (!ETy->isFirstClassType())
5855 GEN_ERROR("Invalid array element type: " + ETy->getDescription());
5857 ArrayType *ATy = ArrayType::get(ETy, NumElements);
5858 PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(ATy));
5860 // Verify all elements are correct type!
5861 for (unsigned i = 0; i < (yyvsp[(2) - (3)].ConstVector)->size(); i++) {
5862 if (ETy != (*(yyvsp[(2) - (3)].ConstVector))[i]->getType())
5863 GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
5864 ETy->getDescription() +"' as required!\nIt is of type '"+
5865 (*(yyvsp[(2) - (3)].ConstVector))[i]->getType()->getDescription() + "'.");
5868 (yyval.ValIDVal) = ValID::create(ConstantArray::get(ATy, *(yyvsp[(2) - (3)].ConstVector)));
5869 delete PTy; delete (yyvsp[(2) - (3)].ConstVector);
5875 #line 2636 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5877 // Use undef instead of an array because it's inconvenient to determine
5878 // the element type at this point, there being no elements to examine.
5879 (yyval.ValIDVal) = ValID::createUndef();
5885 #line 2642 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5887 uint64_t NumElements = (yyvsp[(2) - (2)].StrVal)->length();
5888 const Type *ETy = Type::Int8Ty;
5890 ArrayType *ATy = ArrayType::get(ETy, NumElements);
5892 std::vector<Constant*> Vals;
5893 for (unsigned i = 0; i < (yyvsp[(2) - (2)].StrVal)->length(); ++i)
5894 Vals.push_back(ConstantInt::get(ETy, (*(yyvsp[(2) - (2)].StrVal))[i]));
5895 delete (yyvsp[(2) - (2)].StrVal);
5896 (yyval.ValIDVal) = ValID::create(ConstantArray::get(ATy, Vals));
5902 #line 2655 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5904 std::vector<const Type*> Elements((yyvsp[(2) - (3)].ConstVector)->size());
5905 for (unsigned i = 0, e = (yyvsp[(2) - (3)].ConstVector)->size(); i != e; ++i)
5906 Elements[i] = (*(yyvsp[(2) - (3)].ConstVector))[i]->getType();
5908 const StructType *STy = StructType::get(Elements);
5909 PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(STy));
5911 (yyval.ValIDVal) = ValID::create(ConstantStruct::get(STy, *(yyvsp[(2) - (3)].ConstVector)));
5912 delete PTy; delete (yyvsp[(2) - (3)].ConstVector);
5918 #line 2667 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5920 const StructType *STy = StructType::get(std::vector<const Type*>());
5921 (yyval.ValIDVal) = ValID::create(ConstantStruct::get(STy, std::vector<Constant*>()));
5927 #line 2672 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5929 std::vector<const Type*> Elements((yyvsp[(3) - (5)].ConstVector)->size());
5930 for (unsigned i = 0, e = (yyvsp[(3) - (5)].ConstVector)->size(); i != e; ++i)
5931 Elements[i] = (*(yyvsp[(3) - (5)].ConstVector))[i]->getType();
5933 const StructType *STy = StructType::get(Elements, /*isPacked=*/true);
5934 PATypeHolder* PTy = new PATypeHolder(HandleUpRefs(STy));
5936 (yyval.ValIDVal) = ValID::create(ConstantStruct::get(STy, *(yyvsp[(3) - (5)].ConstVector)));
5937 delete PTy; delete (yyvsp[(3) - (5)].ConstVector);
5943 #line 2684 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5945 const StructType *STy = StructType::get(std::vector<const Type*>(),
5947 (yyval.ValIDVal) = ValID::create(ConstantStruct::get(STy, std::vector<Constant*>()));
5953 #line 2690 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5955 (yyval.ValIDVal) = ValID::create((yyvsp[(1) - (1)].ConstVal));
5961 #line 2694 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5963 (yyval.ValIDVal) = ValID::createInlineAsm(*(yyvsp[(3) - (5)].StrVal), *(yyvsp[(5) - (5)].StrVal), (yyvsp[(2) - (5)].BoolVal));
5964 delete (yyvsp[(3) - (5)].StrVal);
5965 delete (yyvsp[(5) - (5)].StrVal);
5971 #line 2704 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5972 { // Is it an integer reference...?
5973 (yyval.ValIDVal) = ValID::createLocalID((yyvsp[(1) - (1)].UIntVal));
5979 #line 2708 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5981 (yyval.ValIDVal) = ValID::createGlobalID((yyvsp[(1) - (1)].UIntVal));
5987 #line 2712 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5988 { // Is it a named reference...?
5989 (yyval.ValIDVal) = ValID::createLocalName(*(yyvsp[(1) - (1)].StrVal));
5990 delete (yyvsp[(1) - (1)].StrVal);
5996 #line 2717 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
5997 { // Is it a named reference...?
5998 (yyval.ValIDVal) = ValID::createGlobalName(*(yyvsp[(1) - (1)].StrVal));
5999 delete (yyvsp[(1) - (1)].StrVal);
6005 #line 2730 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6007 if (!UpRefs.empty())
6008 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (2)].TypeVal))->getDescription());
6009 (yyval.ValueVal) = getVal(*(yyvsp[(1) - (2)].TypeVal), (yyvsp[(2) - (2)].ValIDVal));
6010 delete (yyvsp[(1) - (2)].TypeVal);
6016 #line 2739 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6018 (yyval.ValueList) = new std::vector<Value *>();
6019 (yyval.ValueList)->push_back((yyvsp[(1) - (1)].ValueVal));
6025 #line 2744 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6027 ((yyval.ValueList)=(yyvsp[(1) - (3)].ValueList))->push_back((yyvsp[(3) - (3)].ValueVal));
6033 #line 2749 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6035 (yyval.FunctionVal) = (yyvsp[(1) - (2)].FunctionVal);
6041 #line 2753 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6042 { // Do not allow functions with 0 basic blocks
6043 (yyval.FunctionVal) = (yyvsp[(1) - (2)].FunctionVal);
6049 #line 2762 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6051 setValueName((yyvsp[(3) - (3)].TermInstVal), (yyvsp[(2) - (3)].StrVal));
6053 InsertValue((yyvsp[(3) - (3)].TermInstVal));
6054 (yyvsp[(1) - (3)].BasicBlockVal)->getInstList().push_back((yyvsp[(3) - (3)].TermInstVal));
6055 (yyval.BasicBlockVal) = (yyvsp[(1) - (3)].BasicBlockVal);
6061 #line 2771 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6064 int ValNum = InsertValue((yyvsp[(3) - (3)].TermInstVal));
6065 if (ValNum != (int)(yyvsp[(2) - (3)].UIntVal))
6066 GEN_ERROR("Result value number %" + utostr((yyvsp[(2) - (3)].UIntVal)) +
6067 " is incorrect, expected %" + utostr((unsigned)ValNum));
6069 (yyvsp[(1) - (3)].BasicBlockVal)->getInstList().push_back((yyvsp[(3) - (3)].TermInstVal));
6070 (yyval.BasicBlockVal) = (yyvsp[(1) - (3)].BasicBlockVal);
6076 #line 2784 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6078 if (CastInst *CI1 = dyn_cast<CastInst>((yyvsp[(2) - (2)].InstVal)))
6079 if (CastInst *CI2 = dyn_cast<CastInst>(CI1->getOperand(0)))
6080 if (CI2->getParent() == 0)
6081 (yyvsp[(1) - (2)].BasicBlockVal)->getInstList().push_back(CI2);
6082 (yyvsp[(1) - (2)].BasicBlockVal)->getInstList().push_back((yyvsp[(2) - (2)].InstVal));
6083 (yyval.BasicBlockVal) = (yyvsp[(1) - (2)].BasicBlockVal);
6089 #line 2793 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6090 { // Empty space between instruction lists
6091 (yyval.BasicBlockVal) = defineBBVal(ValID::createLocalID(CurFun.NextValNum));
6097 #line 2797 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6098 { // Labelled (named) basic block
6099 (yyval.BasicBlockVal) = defineBBVal(ValID::createLocalName(*(yyvsp[(1) - (1)].StrVal)));
6100 delete (yyvsp[(1) - (1)].StrVal);
6107 #line 2805 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6108 { // Return with a result...
6109 ValueList &VL = *(yyvsp[(2) - (2)].ValueList);
6110 assert(!VL.empty() && "Invalid ret operands!");
6111 const Type *ReturnType = CurFun.CurrentFunction->getReturnType();
6112 if (VL.size() > 1 ||
6113 (isa<StructType>(ReturnType) &&
6114 (VL.empty() || VL[0]->getType() != ReturnType))) {
6115 Value *RV = UndefValue::get(ReturnType);
6116 for (unsigned i = 0, e = VL.size(); i != e; ++i) {
6117 Instruction *I = InsertValueInst::Create(RV, VL[i], i, "mrv");
6118 ((yyvsp[(-1) - (2)].BasicBlockVal))->getInstList().push_back(I);
6121 (yyval.TermInstVal) = ReturnInst::Create(RV);
6123 (yyval.TermInstVal) = ReturnInst::Create(VL[0]);
6125 delete (yyvsp[(2) - (2)].ValueList);
6131 #line 2825 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6132 { // Return with no result...
6133 (yyval.TermInstVal) = ReturnInst::Create();
6139 #line 2829 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6140 { // Unconditional Branch...
6141 BasicBlock* tmpBB = getBBVal((yyvsp[(3) - (3)].ValIDVal));
6143 (yyval.TermInstVal) = BranchInst::Create(tmpBB);
6148 #line 2834 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6150 if (cast<IntegerType>((yyvsp[(2) - (9)].PrimType))->getBitWidth() != 1)
6151 GEN_ERROR("Branch condition must have type i1");
6152 BasicBlock* tmpBBA = getBBVal((yyvsp[(6) - (9)].ValIDVal));
6154 BasicBlock* tmpBBB = getBBVal((yyvsp[(9) - (9)].ValIDVal));
6156 Value* tmpVal = getVal(Type::Int1Ty, (yyvsp[(3) - (9)].ValIDVal));
6158 (yyval.TermInstVal) = BranchInst::Create(tmpBBA, tmpBBB, tmpVal);
6163 #line 2845 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6165 Value* tmpVal = getVal((yyvsp[(2) - (9)].PrimType), (yyvsp[(3) - (9)].ValIDVal));
6167 BasicBlock* tmpBB = getBBVal((yyvsp[(6) - (9)].ValIDVal));
6169 SwitchInst *S = SwitchInst::Create(tmpVal, tmpBB, (yyvsp[(8) - (9)].JumpTable)->size());
6170 (yyval.TermInstVal) = S;
6172 std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = (yyvsp[(8) - (9)].JumpTable)->begin(),
6173 E = (yyvsp[(8) - (9)].JumpTable)->end();
6174 for (; I != E; ++I) {
6175 if (ConstantInt *CI = dyn_cast<ConstantInt>(I->first))
6176 S->addCase(CI, I->second);
6178 GEN_ERROR("Switch case is constant, but not a simple integer");
6180 delete (yyvsp[(8) - (9)].JumpTable);
6186 #line 2864 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6188 Value* tmpVal = getVal((yyvsp[(2) - (8)].PrimType), (yyvsp[(3) - (8)].ValIDVal));
6190 BasicBlock* tmpBB = getBBVal((yyvsp[(6) - (8)].ValIDVal));
6192 SwitchInst *S = SwitchInst::Create(tmpVal, tmpBB, 0);
6193 (yyval.TermInstVal) = S;
6199 #line 2874 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6202 // Handle the short syntax
6203 const PointerType *PFTy = 0;
6204 const FunctionType *Ty = 0;
6205 if (!(PFTy = dyn_cast<PointerType>((yyvsp[(4) - (15)].TypeVal)->get())) ||
6206 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
6207 // Pull out the types of all of the arguments...
6208 std::vector<const Type*> ParamTypes;
6209 ParamList::iterator I = (yyvsp[(7) - (15)].ParamList)->begin(), E = (yyvsp[(7) - (15)].ParamList)->end();
6210 for (; I != E; ++I) {
6211 const Type *Ty = I->Val->getType();
6212 if (Ty == Type::VoidTy)
6213 GEN_ERROR("Short call syntax cannot be used with varargs");
6214 ParamTypes.push_back(Ty);
6217 if (!FunctionType::isValidReturnType(*(yyvsp[(4) - (15)].TypeVal)))
6218 GEN_ERROR("Invalid result type for LLVM function");
6220 Ty = FunctionType::get((yyvsp[(4) - (15)].TypeVal)->get(), ParamTypes, false);
6221 PFTy = PointerType::getUnqual(Ty);
6224 delete (yyvsp[(4) - (15)].TypeVal);
6226 Value *V = getVal(PFTy, (yyvsp[(5) - (15)].ValIDVal)); // Get the function we're calling...
6228 BasicBlock *Normal = getBBVal((yyvsp[(12) - (15)].ValIDVal));
6230 BasicBlock *Except = getBBVal((yyvsp[(15) - (15)].ValIDVal));
6233 SmallVector<AttributeWithIndex, 8> Attrs;
6234 //FIXME : In 3.0, stop accepting zext, sext and inreg as optional function
6236 Attributes RetAttrs = (yyvsp[(3) - (15)].Attributes);
6237 if ((yyvsp[(9) - (15)].Attributes) != Attribute::None) {
6238 if ((yyvsp[(9) - (15)].Attributes) & Attribute::ZExt) {
6239 RetAttrs = RetAttrs | Attribute::ZExt;
6240 (yyvsp[(9) - (15)].Attributes) = (yyvsp[(9) - (15)].Attributes) ^ Attribute::ZExt;
6242 if ((yyvsp[(9) - (15)].Attributes) & Attribute::SExt) {
6243 RetAttrs = RetAttrs | Attribute::SExt;
6244 (yyvsp[(9) - (15)].Attributes) = (yyvsp[(9) - (15)].Attributes) ^ Attribute::SExt;
6246 if ((yyvsp[(9) - (15)].Attributes) & Attribute::InReg) {
6247 RetAttrs = RetAttrs | Attribute::InReg;
6248 (yyvsp[(9) - (15)].Attributes) = (yyvsp[(9) - (15)].Attributes) ^ Attribute::InReg;
6251 if (RetAttrs != Attribute::None)
6252 Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
6254 // Check the arguments
6256 if ((yyvsp[(7) - (15)].ParamList)->empty()) { // Has no arguments?
6257 // Make sure no arguments is a good thing!
6258 if (Ty->getNumParams() != 0)
6259 GEN_ERROR("No arguments passed to a function that "
6260 "expects arguments");
6261 } else { // Has arguments?
6262 // Loop through FunctionType's arguments and ensure they are specified
6264 FunctionType::param_iterator I = Ty->param_begin();
6265 FunctionType::param_iterator E = Ty->param_end();
6266 ParamList::iterator ArgI = (yyvsp[(7) - (15)].ParamList)->begin(), ArgE = (yyvsp[(7) - (15)].ParamList)->end();
6269 for (; ArgI != ArgE && I != E; ++ArgI, ++I, ++index) {
6270 if (ArgI->Val->getType() != *I)
6271 GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" +
6272 (*I)->getDescription() + "'");
6273 Args.push_back(ArgI->Val);
6274 if (ArgI->Attrs != Attribute::None)
6275 Attrs.push_back(AttributeWithIndex::get(index, ArgI->Attrs));
6278 if (Ty->isVarArg()) {
6280 for (; ArgI != ArgE; ++ArgI, ++index) {
6281 Args.push_back(ArgI->Val); // push the remaining varargs
6282 if (ArgI->Attrs != Attribute::None)
6283 Attrs.push_back(AttributeWithIndex::get(index, ArgI->Attrs));
6285 } else if (I != E || ArgI != ArgE)
6286 GEN_ERROR("Invalid number of parameters detected");
6288 if ((yyvsp[(9) - (15)].Attributes) != Attribute::None)
6289 Attrs.push_back(AttributeWithIndex::get(~0, (yyvsp[(9) - (15)].Attributes)));
6292 PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
6294 // Create the InvokeInst
6295 InvokeInst *II = InvokeInst::Create(V, Normal, Except,
6296 Args.begin(), Args.end());
6297 II->setCallingConv((yyvsp[(2) - (15)].UIntVal));
6298 II->setAttributes(PAL);
6299 (yyval.TermInstVal) = II;
6300 delete (yyvsp[(7) - (15)].ParamList);
6306 #line 2977 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6308 (yyval.TermInstVal) = new UnwindInst();
6314 #line 2981 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6316 (yyval.TermInstVal) = new UnreachableInst();
6322 #line 2988 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6324 (yyval.JumpTable) = (yyvsp[(1) - (6)].JumpTable);
6325 Constant *V = cast<Constant>(getExistingVal((yyvsp[(2) - (6)].PrimType), (yyvsp[(3) - (6)].ValIDVal)));
6328 GEN_ERROR("May only switch on a constant pool value");
6330 BasicBlock* tmpBB = getBBVal((yyvsp[(6) - (6)].ValIDVal));
6332 (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
6337 #line 2999 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6339 (yyval.JumpTable) = new std::vector<std::pair<Constant*, BasicBlock*> >();
6340 Constant *V = cast<Constant>(getExistingVal((yyvsp[(1) - (5)].PrimType), (yyvsp[(2) - (5)].ValIDVal)));
6344 GEN_ERROR("May only switch on a constant pool value");
6346 BasicBlock* tmpBB = getBBVal((yyvsp[(5) - (5)].ValIDVal));
6348 (yyval.JumpTable)->push_back(std::make_pair(V, tmpBB));
6353 #line 3012 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6355 // Is this definition named?? if so, assign the name...
6356 setValueName((yyvsp[(2) - (2)].InstVal), (yyvsp[(1) - (2)].StrVal));
6358 InsertValue((yyvsp[(2) - (2)].InstVal));
6359 (yyval.InstVal) = (yyvsp[(2) - (2)].InstVal);
6365 #line 3021 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6368 int ValNum = InsertValue((yyvsp[(2) - (2)].InstVal));
6370 if (ValNum != (int)(yyvsp[(1) - (2)].UIntVal))
6371 GEN_ERROR("Result value number %" + utostr((yyvsp[(1) - (2)].UIntVal)) +
6372 " is incorrect, expected %" + utostr((unsigned)ValNum));
6374 (yyval.InstVal) = (yyvsp[(2) - (2)].InstVal);
6380 #line 3034 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6381 { // Used for PHI nodes
6382 if (!UpRefs.empty())
6383 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (6)].TypeVal))->getDescription());
6384 (yyval.PHIList) = new std::list<std::pair<Value*, BasicBlock*> >();
6385 Value* tmpVal = getVal(*(yyvsp[(1) - (6)].TypeVal), (yyvsp[(3) - (6)].ValIDVal));
6387 BasicBlock* tmpBB = getBBVal((yyvsp[(5) - (6)].ValIDVal));
6389 (yyval.PHIList)->push_back(std::make_pair(tmpVal, tmpBB));
6390 delete (yyvsp[(1) - (6)].TypeVal);
6395 #line 3045 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6397 (yyval.PHIList) = (yyvsp[(1) - (7)].PHIList);
6398 Value* tmpVal = getVal((yyvsp[(1) - (7)].PHIList)->front().first->getType(), (yyvsp[(4) - (7)].ValIDVal));
6400 BasicBlock* tmpBB = getBBVal((yyvsp[(6) - (7)].ValIDVal));
6402 (yyvsp[(1) - (7)].PHIList)->push_back(std::make_pair(tmpVal, tmpBB));
6407 #line 3055 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6409 // FIXME: Remove trailing OptAttributes in LLVM 3.0, it was a mistake in 2.0
6410 if (!UpRefs.empty())
6411 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(1) - (4)].TypeVal))->getDescription());
6412 // Used for call and invoke instructions
6413 (yyval.ParamList) = new ParamList();
6414 ParamListEntry E; E.Attrs = (yyvsp[(2) - (4)].Attributes) | (yyvsp[(4) - (4)].Attributes); E.Val = getVal((yyvsp[(1) - (4)].TypeVal)->get(), (yyvsp[(3) - (4)].ValIDVal));
6415 (yyval.ParamList)->push_back(E);
6416 delete (yyvsp[(1) - (4)].TypeVal);
6422 #line 3066 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6424 // FIXME: Remove trailing OptAttributes in LLVM 3.0, it was a mistake in 2.0
6425 // Labels are only valid in ASMs
6426 (yyval.ParamList) = new ParamList();
6427 ParamListEntry E; E.Attrs = (yyvsp[(2) - (4)].Attributes) | (yyvsp[(4) - (4)].Attributes); E.Val = getBBVal((yyvsp[(3) - (4)].ValIDVal));
6428 (yyval.ParamList)->push_back(E);
6434 #line 3074 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6436 // FIXME: Remove trailing OptAttributes in LLVM 3.0, it was a mistake in 2.0
6437 if (!UpRefs.empty())
6438 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription());
6439 (yyval.ParamList) = (yyvsp[(1) - (6)].ParamList);
6440 ParamListEntry E; E.Attrs = (yyvsp[(4) - (6)].Attributes) | (yyvsp[(6) - (6)].Attributes); E.Val = getVal((yyvsp[(3) - (6)].TypeVal)->get(), (yyvsp[(5) - (6)].ValIDVal));
6441 (yyval.ParamList)->push_back(E);
6442 delete (yyvsp[(3) - (6)].TypeVal);
6448 #line 3084 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6450 // FIXME: Remove trailing OptAttributes in LLVM 3.0, it was a mistake in 2.0
6451 (yyval.ParamList) = (yyvsp[(1) - (6)].ParamList);
6452 ParamListEntry E; E.Attrs = (yyvsp[(4) - (6)].Attributes) | (yyvsp[(6) - (6)].Attributes); E.Val = getBBVal((yyvsp[(5) - (6)].ValIDVal));
6453 (yyval.ParamList)->push_back(E);
6459 #line 3091 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6460 { (yyval.ParamList) = new ParamList(); ;}
6464 #line 3094 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6465 { (yyval.ValueList) = new std::vector<Value*>(); ;}
6469 #line 3095 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6471 (yyval.ValueList) = (yyvsp[(1) - (3)].ValueList);
6472 (yyval.ValueList)->push_back((yyvsp[(3) - (3)].ValueVal));
6478 #line 3103 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6480 (yyval.ConstantList) = new std::vector<unsigned>();
6481 if ((unsigned)(yyvsp[(2) - (2)].UInt64Val) != (yyvsp[(2) - (2)].UInt64Val))
6482 GEN_ERROR("Index " + utostr((yyvsp[(2) - (2)].UInt64Val)) + " is not valid for insertvalue or extractvalue.");
6483 (yyval.ConstantList)->push_back((yyvsp[(2) - (2)].UInt64Val));
6488 #line 3109 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6490 (yyval.ConstantList) = (yyvsp[(1) - (3)].ConstantList);
6491 if ((unsigned)(yyvsp[(3) - (3)].UInt64Val) != (yyvsp[(3) - (3)].UInt64Val))
6492 GEN_ERROR("Index " + utostr((yyvsp[(3) - (3)].UInt64Val)) + " is not valid for insertvalue or extractvalue.");
6493 (yyval.ConstantList)->push_back((yyvsp[(3) - (3)].UInt64Val));
6499 #line 3118 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6501 (yyval.BoolVal) = true;
6507 #line 3122 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6509 (yyval.BoolVal) = false;
6515 #line 3127 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6517 if (!UpRefs.empty())
6518 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (5)].TypeVal))->getDescription());
6519 if (!(*(yyvsp[(2) - (5)].TypeVal))->isInteger() && !(*(yyvsp[(2) - (5)].TypeVal))->isFloatingPoint() &&
6520 !isa<VectorType>((*(yyvsp[(2) - (5)].TypeVal)).get()))
6522 "Arithmetic operator requires integer, FP, or packed operands");
6523 Value* val1 = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(3) - (5)].ValIDVal));
6525 Value* val2 = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(5) - (5)].ValIDVal));
6527 (yyval.InstVal) = BinaryOperator::Create((yyvsp[(1) - (5)].BinaryOpVal), val1, val2);
6528 if ((yyval.InstVal) == 0)
6529 GEN_ERROR("binary operator returned null");
6530 delete (yyvsp[(2) - (5)].TypeVal);
6535 #line 3143 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6537 if (!UpRefs.empty())
6538 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (5)].TypeVal))->getDescription());
6539 if (!(*(yyvsp[(2) - (5)].TypeVal))->isInteger()) {
6540 if (!isa<VectorType>((yyvsp[(2) - (5)].TypeVal)->get()) ||
6541 !cast<VectorType>((yyvsp[(2) - (5)].TypeVal)->get())->getElementType()->isInteger())
6542 GEN_ERROR("Logical operator requires integral operands");
6544 Value* tmpVal1 = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(3) - (5)].ValIDVal));
6546 Value* tmpVal2 = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(5) - (5)].ValIDVal));
6548 (yyval.InstVal) = BinaryOperator::Create((yyvsp[(1) - (5)].BinaryOpVal), tmpVal1, tmpVal2);
6549 if ((yyval.InstVal) == 0)
6550 GEN_ERROR("binary operator returned null");
6551 delete (yyvsp[(2) - (5)].TypeVal);
6556 #line 3160 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6558 if (!UpRefs.empty())
6559 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription());
6560 Value* tmpVal1 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(4) - (6)].ValIDVal));
6562 Value* tmpVal2 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(6) - (6)].ValIDVal));
6564 (yyval.InstVal) = CmpInst::Create((yyvsp[(1) - (6)].OtherOpVal), (yyvsp[(2) - (6)].IPredicate), tmpVal1, tmpVal2);
6565 if ((yyval.InstVal) == 0)
6566 GEN_ERROR("icmp operator returned null");
6567 delete (yyvsp[(3) - (6)].TypeVal);
6572 #line 3172 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6574 if (!UpRefs.empty())
6575 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription());
6576 Value* tmpVal1 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(4) - (6)].ValIDVal));
6578 Value* tmpVal2 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(6) - (6)].ValIDVal));
6580 (yyval.InstVal) = CmpInst::Create((yyvsp[(1) - (6)].OtherOpVal), (yyvsp[(2) - (6)].FPredicate), tmpVal1, tmpVal2);
6581 if ((yyval.InstVal) == 0)
6582 GEN_ERROR("fcmp operator returned null");
6583 delete (yyvsp[(3) - (6)].TypeVal);
6588 #line 3184 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6590 if (!UpRefs.empty())
6591 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription());
6592 if (!isa<VectorType>((*(yyvsp[(3) - (6)].TypeVal)).get()))
6593 GEN_ERROR("Scalar types not supported by vicmp instruction");
6594 Value* tmpVal1 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(4) - (6)].ValIDVal));
6596 Value* tmpVal2 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(6) - (6)].ValIDVal));
6598 (yyval.InstVal) = CmpInst::Create((yyvsp[(1) - (6)].OtherOpVal), (yyvsp[(2) - (6)].IPredicate), tmpVal1, tmpVal2);
6599 if ((yyval.InstVal) == 0)
6600 GEN_ERROR("vicmp operator returned null");
6601 delete (yyvsp[(3) - (6)].TypeVal);
6606 #line 3198 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6608 if (!UpRefs.empty())
6609 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (6)].TypeVal))->getDescription());
6610 if (!isa<VectorType>((*(yyvsp[(3) - (6)].TypeVal)).get()))
6611 GEN_ERROR("Scalar types not supported by vfcmp instruction");
6612 Value* tmpVal1 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(4) - (6)].ValIDVal));
6614 Value* tmpVal2 = getVal(*(yyvsp[(3) - (6)].TypeVal), (yyvsp[(6) - (6)].ValIDVal));
6616 (yyval.InstVal) = CmpInst::Create((yyvsp[(1) - (6)].OtherOpVal), (yyvsp[(2) - (6)].FPredicate), tmpVal1, tmpVal2);
6617 if ((yyval.InstVal) == 0)
6618 GEN_ERROR("vfcmp operator returned null");
6619 delete (yyvsp[(3) - (6)].TypeVal);
6624 #line 3212 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6626 if (!UpRefs.empty())
6627 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(4) - (4)].TypeVal))->getDescription());
6628 Value* Val = (yyvsp[(2) - (4)].ValueVal);
6629 const Type* DestTy = (yyvsp[(4) - (4)].TypeVal)->get();
6630 if (!CastInst::castIsValid((yyvsp[(1) - (4)].CastOpVal), Val, DestTy))
6631 GEN_ERROR("invalid cast opcode for cast from '" +
6632 Val->getType()->getDescription() + "' to '" +
6633 DestTy->getDescription() + "'");
6634 (yyval.InstVal) = CastInst::Create((yyvsp[(1) - (4)].CastOpVal), Val, DestTy);
6635 delete (yyvsp[(4) - (4)].TypeVal);
6640 #line 3224 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6642 if (isa<VectorType>((yyvsp[(2) - (6)].ValueVal)->getType())) {
6644 if (!isa<VectorType>((yyvsp[(4) - (6)].ValueVal)->getType())
6645 || !isa<VectorType>((yyvsp[(6) - (6)].ValueVal)->getType()) )
6646 GEN_ERROR("vector select value types must be vector types");
6647 const VectorType* cond_type = cast<VectorType>((yyvsp[(2) - (6)].ValueVal)->getType());
6648 const VectorType* select_type = cast<VectorType>((yyvsp[(4) - (6)].ValueVal)->getType());
6649 if (cond_type->getElementType() != Type::Int1Ty)
6650 GEN_ERROR("vector select condition element type must be boolean");
6651 if (cond_type->getNumElements() != select_type->getNumElements())
6652 GEN_ERROR("vector select number of elements must be the same");
6654 if ((yyvsp[(2) - (6)].ValueVal)->getType() != Type::Int1Ty)
6655 GEN_ERROR("select condition must be boolean");
6657 if ((yyvsp[(4) - (6)].ValueVal)->getType() != (yyvsp[(6) - (6)].ValueVal)->getType())
6658 GEN_ERROR("select value types must match");
6659 (yyval.InstVal) = SelectInst::Create((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal));
6665 #line 3245 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6667 if (!UpRefs.empty())
6668 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(4) - (4)].TypeVal))->getDescription());
6669 (yyval.InstVal) = new VAArgInst((yyvsp[(2) - (4)].ValueVal), *(yyvsp[(4) - (4)].TypeVal));
6670 delete (yyvsp[(4) - (4)].TypeVal);
6676 #line 3252 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6678 if (!ExtractElementInst::isValidOperands((yyvsp[(2) - (4)].ValueVal), (yyvsp[(4) - (4)].ValueVal)))
6679 GEN_ERROR("Invalid extractelement operands");
6680 (yyval.InstVal) = new ExtractElementInst((yyvsp[(2) - (4)].ValueVal), (yyvsp[(4) - (4)].ValueVal));
6686 #line 3258 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6688 if (!InsertElementInst::isValidOperands((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal)))
6689 GEN_ERROR("Invalid insertelement operands");
6690 (yyval.InstVal) = InsertElementInst::Create((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal));
6696 #line 3264 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6698 if (!ShuffleVectorInst::isValidOperands((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal)))
6699 GEN_ERROR("Invalid shufflevector operands");
6700 (yyval.InstVal) = new ShuffleVectorInst((yyvsp[(2) - (6)].ValueVal), (yyvsp[(4) - (6)].ValueVal), (yyvsp[(6) - (6)].ValueVal));
6706 #line 3270 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6708 const Type *Ty = (yyvsp[(2) - (2)].PHIList)->front().first->getType();
6709 if (!Ty->isFirstClassType())
6710 GEN_ERROR("PHI node operands must be of first class type");
6711 (yyval.InstVal) = PHINode::Create(Ty);
6712 ((PHINode*)(yyval.InstVal))->reserveOperandSpace((yyvsp[(2) - (2)].PHIList)->size());
6713 while ((yyvsp[(2) - (2)].PHIList)->begin() != (yyvsp[(2) - (2)].PHIList)->end()) {
6714 if ((yyvsp[(2) - (2)].PHIList)->front().first->getType() != Ty)
6715 GEN_ERROR("All elements of a PHI node must be of the same type");
6716 cast<PHINode>((yyval.InstVal))->addIncoming((yyvsp[(2) - (2)].PHIList)->front().first, (yyvsp[(2) - (2)].PHIList)->front().second);
6717 (yyvsp[(2) - (2)].PHIList)->pop_front();
6719 delete (yyvsp[(2) - (2)].PHIList); // Free the list...
6725 #line 3286 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6728 // Handle the short syntax
6729 const PointerType *PFTy = 0;
6730 const FunctionType *Ty = 0;
6731 if (!(PFTy = dyn_cast<PointerType>((yyvsp[(4) - (9)].TypeVal)->get())) ||
6732 !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
6733 // Pull out the types of all of the arguments...
6734 std::vector<const Type*> ParamTypes;
6735 ParamList::iterator I = (yyvsp[(7) - (9)].ParamList)->begin(), E = (yyvsp[(7) - (9)].ParamList)->end();
6736 for (; I != E; ++I) {
6737 const Type *Ty = I->Val->getType();
6738 if (Ty == Type::VoidTy)
6739 GEN_ERROR("Short call syntax cannot be used with varargs");
6740 ParamTypes.push_back(Ty);
6743 if (!FunctionType::isValidReturnType(*(yyvsp[(4) - (9)].TypeVal)))
6744 GEN_ERROR("Invalid result type for LLVM function");
6746 Ty = FunctionType::get((yyvsp[(4) - (9)].TypeVal)->get(), ParamTypes, false);
6747 PFTy = PointerType::getUnqual(Ty);
6750 Value *V = getVal(PFTy, (yyvsp[(5) - (9)].ValIDVal)); // Get the function we're calling...
6753 // Check for call to invalid intrinsic to avoid crashing later.
6754 if (Function *theF = dyn_cast<Function>(V)) {
6755 if (theF->hasName() && (theF->getValueName()->getKeyLength() >= 5) &&
6756 (0 == strncmp(theF->getValueName()->getKeyData(), "llvm.", 5)) &&
6757 !theF->getIntrinsicID(true))
6758 GEN_ERROR("Call to invalid LLVM intrinsic function '" +
6759 theF->getName() + "'");
6762 // Set up the Attributes for the function
6763 SmallVector<AttributeWithIndex, 8> Attrs;
6764 //FIXME : In 3.0, stop accepting zext, sext and inreg as optional function
6766 Attributes RetAttrs = (yyvsp[(3) - (9)].Attributes);
6767 if ((yyvsp[(9) - (9)].Attributes) != Attribute::None) {
6768 if ((yyvsp[(9) - (9)].Attributes) & Attribute::ZExt) {
6769 RetAttrs = RetAttrs | Attribute::ZExt;
6770 (yyvsp[(9) - (9)].Attributes) = (yyvsp[(9) - (9)].Attributes) ^ Attribute::ZExt;
6772 if ((yyvsp[(9) - (9)].Attributes) & Attribute::SExt) {
6773 RetAttrs = RetAttrs | Attribute::SExt;
6774 (yyvsp[(9) - (9)].Attributes) = (yyvsp[(9) - (9)].Attributes) ^ Attribute::SExt;
6776 if ((yyvsp[(9) - (9)].Attributes) & Attribute::InReg) {
6777 RetAttrs = RetAttrs | Attribute::InReg;
6778 (yyvsp[(9) - (9)].Attributes) = (yyvsp[(9) - (9)].Attributes) ^ Attribute::InReg;
6781 if (RetAttrs != Attribute::None)
6782 Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
6784 // Check the arguments
6786 if ((yyvsp[(7) - (9)].ParamList)->empty()) { // Has no arguments?
6787 // Make sure no arguments is a good thing!
6788 if (Ty->getNumParams() != 0)
6789 GEN_ERROR("No arguments passed to a function that "
6790 "expects arguments");
6791 } else { // Has arguments?
6792 // Loop through FunctionType's arguments and ensure they are specified
6793 // correctly. Also, gather any parameter attributes.
6794 FunctionType::param_iterator I = Ty->param_begin();
6795 FunctionType::param_iterator E = Ty->param_end();
6796 ParamList::iterator ArgI = (yyvsp[(7) - (9)].ParamList)->begin(), ArgE = (yyvsp[(7) - (9)].ParamList)->end();
6799 for (; ArgI != ArgE && I != E; ++ArgI, ++I, ++index) {
6800 if (ArgI->Val->getType() != *I)
6801 GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" +
6802 (*I)->getDescription() + "'");
6803 Args.push_back(ArgI->Val);
6804 if (ArgI->Attrs != Attribute::None)
6805 Attrs.push_back(AttributeWithIndex::get(index, ArgI->Attrs));
6807 if (Ty->isVarArg()) {
6809 for (; ArgI != ArgE; ++ArgI, ++index) {
6810 Args.push_back(ArgI->Val); // push the remaining varargs
6811 if (ArgI->Attrs != Attribute::None)
6812 Attrs.push_back(AttributeWithIndex::get(index, ArgI->Attrs));
6814 } else if (I != E || ArgI != ArgE)
6815 GEN_ERROR("Invalid number of parameters detected");
6817 if ((yyvsp[(9) - (9)].Attributes) != Attribute::None)
6818 Attrs.push_back(AttributeWithIndex::get(~0, (yyvsp[(9) - (9)].Attributes)));
6820 // Finish off the Attributes and check them
6823 PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
6825 // Create the call node
6826 CallInst *CI = CallInst::Create(V, Args.begin(), Args.end());
6827 CI->setTailCall((yyvsp[(1) - (9)].BoolVal));
6828 CI->setCallingConv((yyvsp[(2) - (9)].UIntVal));
6829 CI->setAttributes(PAL);
6830 (yyval.InstVal) = CI;
6831 delete (yyvsp[(7) - (9)].ParamList);
6832 delete (yyvsp[(4) - (9)].TypeVal);
6838 #line 3395 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6840 (yyval.InstVal) = (yyvsp[(1) - (1)].InstVal);
6846 #line 3400 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6848 (yyval.BoolVal) = true;
6854 #line 3404 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6856 (yyval.BoolVal) = false;
6862 #line 3411 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6864 if (!UpRefs.empty())
6865 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (3)].TypeVal))->getDescription());
6866 (yyval.InstVal) = new MallocInst(*(yyvsp[(2) - (3)].TypeVal), 0, (yyvsp[(3) - (3)].UIntVal));
6867 delete (yyvsp[(2) - (3)].TypeVal);
6873 #line 3418 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6875 if (!UpRefs.empty())
6876 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (6)].TypeVal))->getDescription());
6877 if ((yyvsp[(4) - (6)].PrimType) != Type::Int32Ty)
6878 GEN_ERROR("Malloc array size is not a 32-bit integer!");
6879 Value* tmpVal = getVal((yyvsp[(4) - (6)].PrimType), (yyvsp[(5) - (6)].ValIDVal));
6881 (yyval.InstVal) = new MallocInst(*(yyvsp[(2) - (6)].TypeVal), tmpVal, (yyvsp[(6) - (6)].UIntVal));
6882 delete (yyvsp[(2) - (6)].TypeVal);
6887 #line 3428 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6889 if (!UpRefs.empty())
6890 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (3)].TypeVal))->getDescription());
6891 (yyval.InstVal) = new AllocaInst(*(yyvsp[(2) - (3)].TypeVal), 0, (yyvsp[(3) - (3)].UIntVal));
6892 delete (yyvsp[(2) - (3)].TypeVal);
6898 #line 3435 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6900 if (!UpRefs.empty())
6901 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (6)].TypeVal))->getDescription());
6902 if ((yyvsp[(4) - (6)].PrimType) != Type::Int32Ty)
6903 GEN_ERROR("Alloca array size is not a 32-bit integer!");
6904 Value* tmpVal = getVal((yyvsp[(4) - (6)].PrimType), (yyvsp[(5) - (6)].ValIDVal));
6906 (yyval.InstVal) = new AllocaInst(*(yyvsp[(2) - (6)].TypeVal), tmpVal, (yyvsp[(6) - (6)].UIntVal));
6907 delete (yyvsp[(2) - (6)].TypeVal);
6912 #line 3445 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6914 if (!isa<PointerType>((yyvsp[(2) - (2)].ValueVal)->getType()))
6915 GEN_ERROR("Trying to free nonpointer type " +
6916 (yyvsp[(2) - (2)].ValueVal)->getType()->getDescription() + "");
6917 (yyval.InstVal) = new FreeInst((yyvsp[(2) - (2)].ValueVal));
6923 #line 3453 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6925 if (!UpRefs.empty())
6926 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(3) - (5)].TypeVal))->getDescription());
6927 if (!isa<PointerType>((yyvsp[(3) - (5)].TypeVal)->get()))
6928 GEN_ERROR("Can't load from nonpointer type: " +
6929 (*(yyvsp[(3) - (5)].TypeVal))->getDescription());
6930 if (!cast<PointerType>((yyvsp[(3) - (5)].TypeVal)->get())->getElementType()->isFirstClassType())
6931 GEN_ERROR("Can't load from pointer of non-first-class type: " +
6932 (*(yyvsp[(3) - (5)].TypeVal))->getDescription());
6933 Value* tmpVal = getVal(*(yyvsp[(3) - (5)].TypeVal), (yyvsp[(4) - (5)].ValIDVal));
6935 (yyval.InstVal) = new LoadInst(tmpVal, "", (yyvsp[(1) - (5)].BoolVal), (yyvsp[(5) - (5)].UIntVal));
6936 delete (yyvsp[(3) - (5)].TypeVal);
6941 #line 3467 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6943 if (!UpRefs.empty())
6944 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(5) - (7)].TypeVal))->getDescription());
6945 const PointerType *PT = dyn_cast<PointerType>((yyvsp[(5) - (7)].TypeVal)->get());
6947 GEN_ERROR("Can't store to a nonpointer type: " +
6948 (*(yyvsp[(5) - (7)].TypeVal))->getDescription());
6949 const Type *ElTy = PT->getElementType();
6950 if (ElTy != (yyvsp[(3) - (7)].ValueVal)->getType())
6951 GEN_ERROR("Can't store '" + (yyvsp[(3) - (7)].ValueVal)->getType()->getDescription() +
6952 "' into space of type '" + ElTy->getDescription() + "'");
6954 Value* tmpVal = getVal(*(yyvsp[(5) - (7)].TypeVal), (yyvsp[(6) - (7)].ValIDVal));
6956 (yyval.InstVal) = new StoreInst((yyvsp[(3) - (7)].ValueVal), tmpVal, (yyvsp[(1) - (7)].BoolVal), (yyvsp[(7) - (7)].UIntVal));
6957 delete (yyvsp[(5) - (7)].TypeVal);
6962 #line 3484 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6964 if (!UpRefs.empty())
6965 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (5)].TypeVal))->getDescription());
6966 if (!isa<StructType>((yyvsp[(2) - (5)].TypeVal)->get()) && !isa<ArrayType>((yyvsp[(2) - (5)].TypeVal)->get()))
6967 GEN_ERROR("getresult insn requires an aggregate operand");
6968 if (!ExtractValueInst::getIndexedType(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(5) - (5)].UInt64Val)))
6969 GEN_ERROR("Invalid getresult index for type '" +
6970 (*(yyvsp[(2) - (5)].TypeVal))->getDescription()+ "'");
6972 Value *tmpVal = getVal(*(yyvsp[(2) - (5)].TypeVal), (yyvsp[(3) - (5)].ValIDVal));
6974 (yyval.InstVal) = ExtractValueInst::Create(tmpVal, (yyvsp[(5) - (5)].UInt64Val));
6975 delete (yyvsp[(2) - (5)].TypeVal);
6980 #line 3498 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
6982 if (!UpRefs.empty())
6983 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (4)].TypeVal))->getDescription());
6984 if (!isa<PointerType>((yyvsp[(2) - (4)].TypeVal)->get()))
6985 GEN_ERROR("getelementptr insn requires pointer operand");
6987 if (!GetElementPtrInst::getIndexedType(*(yyvsp[(2) - (4)].TypeVal), (yyvsp[(4) - (4)].ValueList)->begin(), (yyvsp[(4) - (4)].ValueList)->end()))
6988 GEN_ERROR("Invalid getelementptr indices for type '" +
6989 (*(yyvsp[(2) - (4)].TypeVal))->getDescription()+ "'");
6990 Value* tmpVal = getVal(*(yyvsp[(2) - (4)].TypeVal), (yyvsp[(3) - (4)].ValIDVal));
6992 (yyval.InstVal) = GetElementPtrInst::Create(tmpVal, (yyvsp[(4) - (4)].ValueList)->begin(), (yyvsp[(4) - (4)].ValueList)->end());
6993 delete (yyvsp[(2) - (4)].TypeVal);
6994 delete (yyvsp[(4) - (4)].ValueList);
6999 #line 3513 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
7001 if (!UpRefs.empty())
7002 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (4)].TypeVal))->getDescription());
7003 if (!isa<StructType>((yyvsp[(2) - (4)].TypeVal)->get()) && !isa<ArrayType>((yyvsp[(2) - (4)].TypeVal)->get()))
7004 GEN_ERROR("extractvalue insn requires an aggregate operand");
7006 if (!ExtractValueInst::getIndexedType(*(yyvsp[(2) - (4)].TypeVal), (yyvsp[(4) - (4)].ConstantList)->begin(), (yyvsp[(4) - (4)].ConstantList)->end()))
7007 GEN_ERROR("Invalid extractvalue indices for type '" +
7008 (*(yyvsp[(2) - (4)].TypeVal))->getDescription()+ "'");
7009 Value* tmpVal = getVal(*(yyvsp[(2) - (4)].TypeVal), (yyvsp[(3) - (4)].ValIDVal));
7011 (yyval.InstVal) = ExtractValueInst::Create(tmpVal, (yyvsp[(4) - (4)].ConstantList)->begin(), (yyvsp[(4) - (4)].ConstantList)->end());
7012 delete (yyvsp[(2) - (4)].TypeVal);
7013 delete (yyvsp[(4) - (4)].ConstantList);
7018 #line 3528 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
7020 if (!UpRefs.empty())
7021 GEN_ERROR("Invalid upreference in type: " + (*(yyvsp[(2) - (7)].TypeVal))->getDescription());
7022 if (!isa<StructType>((yyvsp[(2) - (7)].TypeVal)->get()) && !isa<ArrayType>((yyvsp[(2) - (7)].TypeVal)->get()))
7023 GEN_ERROR("extractvalue insn requires an aggregate operand");
7025 if (ExtractValueInst::getIndexedType(*(yyvsp[(2) - (7)].TypeVal), (yyvsp[(7) - (7)].ConstantList)->begin(), (yyvsp[(7) - (7)].ConstantList)->end()) != (yyvsp[(5) - (7)].TypeVal)->get())
7026 GEN_ERROR("Invalid insertvalue indices for type '" +
7027 (*(yyvsp[(2) - (7)].TypeVal))->getDescription()+ "'");
7028 Value* aggVal = getVal(*(yyvsp[(2) - (7)].TypeVal), (yyvsp[(3) - (7)].ValIDVal));
7029 Value* tmpVal = getVal(*(yyvsp[(5) - (7)].TypeVal), (yyvsp[(6) - (7)].ValIDVal));
7031 (yyval.InstVal) = InsertValueInst::Create(aggVal, tmpVal, (yyvsp[(7) - (7)].ConstantList)->begin(), (yyvsp[(7) - (7)].ConstantList)->end());
7032 delete (yyvsp[(2) - (7)].TypeVal);
7033 delete (yyvsp[(5) - (7)].TypeVal);
7034 delete (yyvsp[(7) - (7)].ConstantList);
7039 /* Line 1267 of yacc.c. */
7040 #line 7041 "llvmAsmParser.tab.c"
7043 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
7047 YY_STACK_PRINT (yyss, yyssp);
7052 /* Now `shift' the result of the reduction. Determine what state
7053 that goes to, based on the state we popped back to and the rule
7054 number reduced by. */
7058 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
7059 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
7060 yystate = yytable[yystate];
7062 yystate = yydefgoto[yyn - YYNTOKENS];
7067 /*------------------------------------.
7068 | yyerrlab -- here on detecting error |
7069 `------------------------------------*/
7071 /* If not already recovering from an error, report this error. */
7075 #if ! YYERROR_VERBOSE
7076 yyerror (YY_("syntax error"));
7079 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
7080 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
7082 YYSIZE_T yyalloc = 2 * yysize;
7083 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
7084 yyalloc = YYSTACK_ALLOC_MAXIMUM;
7085 if (yymsg != yymsgbuf)
7086 YYSTACK_FREE (yymsg);
7087 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
7089 yymsg_alloc = yyalloc;
7093 yymsg_alloc = sizeof yymsgbuf;
7097 if (0 < yysize && yysize <= yymsg_alloc)
7099 (void) yysyntax_error (yymsg, yystate, yychar);
7104 yyerror (YY_("syntax error"));
7106 goto yyexhaustedlab;
7114 if (yyerrstatus == 3)
7116 /* If just tried and failed to reuse look-ahead token after an
7117 error, discard it. */
7119 if (yychar <= YYEOF)
7121 /* Return failure if at end of input. */
7122 if (yychar == YYEOF)
7127 yydestruct ("Error: discarding",
7133 /* Else will try to reuse look-ahead token after shifting the error
7138 /*---------------------------------------------------.
7139 | yyerrorlab -- error raised explicitly by YYERROR. |
7140 `---------------------------------------------------*/
7143 /* Pacify compilers like GCC when the user code never invokes
7144 YYERROR and the label yyerrorlab therefore never appears in user
7146 if (/*CONSTCOND*/ 0)
7149 /* Do not reclaim the symbols of the rule which action triggered
7153 YY_STACK_PRINT (yyss, yyssp);
7158 /*-------------------------------------------------------------.
7159 | yyerrlab1 -- common code for both syntax error and YYERROR. |
7160 `-------------------------------------------------------------*/
7162 yyerrstatus = 3; /* Each real token shifted decrements this. */
7166 yyn = yypact[yystate];
7167 if (yyn != YYPACT_NINF)
7170 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
7178 /* Pop the current state because it cannot handle the error token. */
7183 yydestruct ("Error: popping",
7184 yystos[yystate], yyvsp);
7187 YY_STACK_PRINT (yyss, yyssp);
7196 /* Shift the error token. */
7197 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
7203 /*-------------------------------------.
7204 | yyacceptlab -- YYACCEPT comes here. |
7205 `-------------------------------------*/
7210 /*-----------------------------------.
7211 | yyabortlab -- YYABORT comes here. |
7212 `-----------------------------------*/
7218 /*-------------------------------------------------.
7219 | yyexhaustedlab -- memory exhaustion comes here. |
7220 `-------------------------------------------------*/
7222 yyerror (YY_("memory exhausted"));
7228 if (yychar != YYEOF && yychar != YYEMPTY)
7229 yydestruct ("Cleanup: discarding lookahead",
7231 /* Do not reclaim the symbols of the rule which action triggered
7232 this YYABORT or YYACCEPT. */
7234 YY_STACK_PRINT (yyss, yyssp);
7235 while (yyssp != yyss)
7237 yydestruct ("Cleanup: popping",
7238 yystos[*yyssp], yyvsp);
7243 YYSTACK_FREE (yyss);
7246 if (yymsg != yymsgbuf)
7247 YYSTACK_FREE (yymsg);
7249 /* Make sure YYID is used. */
7250 return YYID (yyresult);
7254 #line 3547 "/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
7257 // common code from the two 'RunVMAsmParser' functions
7258 static Module* RunParser(Module * M) {
7259 CurModule.CurrentModule = M;
7260 // Check to make sure the parser succeeded
7263 delete ParserResult;
7267 // Emit an error if there are any unresolved types left.
7268 if (!CurModule.LateResolveTypes.empty()) {
7269 const ValID &DID = CurModule.LateResolveTypes.begin()->first;
7270 if (DID.Type == ValID::LocalName) {
7271 GenerateError("Undefined type remains at eof: '"+DID.getName() + "'");
7273 GenerateError("Undefined type remains at eof: #" + itostr(DID.Num));
7276 delete ParserResult;
7280 // Emit an error if there are any unresolved values left.
7281 if (!CurModule.LateResolveValues.empty()) {
7282 Value *V = CurModule.LateResolveValues.back();
7283 std::map<Value*, std::pair<ValID, int> >::iterator I =
7284 CurModule.PlaceHolderInfo.find(V);
7286 if (I != CurModule.PlaceHolderInfo.end()) {
7287 ValID &DID = I->second.first;
7288 if (DID.Type == ValID::LocalName) {
7289 GenerateError("Undefined value remains at eof: "+DID.getName() + "'");
7291 GenerateError("Undefined value remains at eof: #" + itostr(DID.Num));
7294 delete ParserResult;
7299 // Check to make sure that parsing produced a result
7303 // Reset ParserResult variable while saving its value for the result.
7304 Module *Result = ParserResult;
7310 void llvm::GenerateError(const std::string &message, int LineNo) {
7311 if (LineNo == -1) LineNo = LLLgetLineNo();
7312 // TODO: column number in exception
7314 TheParseError->setError(LLLgetFilename(), message, LineNo);
7318 int yyerror(const char *ErrorMsg) {
7319 std::string where = LLLgetFilename() + ":" + utostr(LLLgetLineNo()) + ": ";
7320 std::string errMsg = where + "error: " + std::string(ErrorMsg);
7321 if (yychar != YYEMPTY && yychar != 0) {
7322 errMsg += " while reading token: '";
7323 errMsg += std::string(LLLgetTokenStart(),
7324 LLLgetTokenStart()+LLLgetTokenLength()) + "'";
7326 GenerateError(errMsg);
projects / oota-llvm.git / blob