ffe2398a53f7fa0421d469ff31171f41bb3ae9a5
[oota-llvm.git] / lib / AsmParser / llvmAsmParser.cpp.cvs
1 /* A Bison parser, made by GNU Bison 2.3.  */
2
3 /* Skeleton implementation for Bison's Yacc-like parsers in C
4
5    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6    Free Software Foundation, Inc.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2, or (at your option)
11    any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
21    Boston, MA 02110-1301, USA.  */
22
23 /* As a special exception, you may create a larger work that contains
24    part or all of the Bison parser skeleton and distribute that work
25    under terms of your choice, so long as that work isn't itself a
26    parser generator using the skeleton or a modified version thereof
27    as a parser skeleton.  Alternatively, if you modify or redistribute
28    the parser skeleton itself, you may (at your option) remove this
29    special exception, which will cause the skeleton and the resulting
30    Bison output files to be licensed under the GNU General Public
31    License without this special exception.
32
33    This special exception was added by the Free Software Foundation in
34    version 2.2 of Bison.  */
35
36 /* C LALR(1) parser skeleton written by Richard Stallman, by
37    simplifying the original so-called "semantic" parser.  */
38
39 /* All symbols defined below should begin with yy or YY, to avoid
40    infringing on user name space.  This should be done even for local
41    variables, as they might otherwise be expanded by user macros.
42    There are some unavoidable exceptions within include files to
43    define necessary library symbols; they are noted "INFRINGES ON
44    USER NAME SPACE" below.  */
45
46 /* Identify Bison output.  */
47 #define YYBISON 1
48
49 /* Bison version.  */
50 #define YYBISON_VERSION "2.3"
51
52 /* Skeleton name.  */
53 #define YYSKELETON_NAME "yacc.c"
54
55 /* Pure parsers.  */
56 #define YYPURE 0
57
58 /* Using locations.  */
59 #define YYLSP_NEEDED 0
60
61 /* Substitute the variable and function names.  */
62 #define yyparse llvmAsmparse
63 #define yylex   llvmAsmlex
64 #define yyerror llvmAsmerror
65 #define yylval  llvmAsmlval
66 #define yychar  llvmAsmchar
67 #define yydebug llvmAsmdebug
68 #define yynerrs llvmAsmnerrs
69
70
71 /* Tokens.  */
72 #ifndef YYTOKENTYPE
73 # define YYTOKENTYPE
74    /* Put the tokens into the symbol table, so that GDB and other debuggers
75       know about them.  */
76    enum yytokentype {
77      ESINT64VAL = 258,
78      EUINT64VAL = 259,
79      ESAPINTVAL = 260,
80      EUAPINTVAL = 261,
81      LOCALVAL_ID = 262,
82      GLOBALVAL_ID = 263,
83      FPVAL = 264,
84      VOID = 265,
85      INTTYPE = 266,
86      FLOAT = 267,
87      DOUBLE = 268,
88      X86_FP80 = 269,
89      FP128 = 270,
90      PPC_FP128 = 271,
91      LABEL = 272,
92      TYPE = 273,
93      LOCALVAR = 274,
94      GLOBALVAR = 275,
95      LABELSTR = 276,
96      STRINGCONSTANT = 277,
97      ATSTRINGCONSTANT = 278,
98      PCTSTRINGCONSTANT = 279,
99      ZEROINITIALIZER = 280,
100      TRUETOK = 281,
101      FALSETOK = 282,
102      BEGINTOK = 283,
103      ENDTOK = 284,
104      DECLARE = 285,
105      DEFINE = 286,
106      GLOBAL = 287,
107      CONSTANT = 288,
108      SECTION = 289,
109      ALIAS = 290,
110      VOLATILE = 291,
111      THREAD_LOCAL = 292,
112      TO = 293,
113      DOTDOTDOT = 294,
114      NULL_TOK = 295,
115      UNDEF = 296,
116      INTERNAL = 297,
117      LINKONCE = 298,
118      WEAK = 299,
119      APPENDING = 300,
120      DLLIMPORT = 301,
121      DLLEXPORT = 302,
122      EXTERN_WEAK = 303,
123      OPAQUE = 304,
124      EXTERNAL = 305,
125      TARGET = 306,
126      TRIPLE = 307,
127      ALIGN = 308,
128      DEPLIBS = 309,
129      CALL = 310,
130      TAIL = 311,
131      ASM_TOK = 312,
132      MODULE = 313,
133      SIDEEFFECT = 314,
134      CC_TOK = 315,
135      CCC_TOK = 316,
136      FASTCC_TOK = 317,
137      COLDCC_TOK = 318,
138      X86_STDCALLCC_TOK = 319,
139      X86_FASTCALLCC_TOK = 320,
140      DATALAYOUT = 321,
141      RET = 322,
142      BR = 323,
143      SWITCH = 324,
144      INVOKE = 325,
145      UNWIND = 326,
146      UNREACHABLE = 327,
147      ADD = 328,
148      SUB = 329,
149      MUL = 330,
150      UDIV = 331,
151      SDIV = 332,
152      FDIV = 333,
153      UREM = 334,
154      SREM = 335,
155      FREM = 336,
156      AND = 337,
157      OR = 338,
158      XOR = 339,
159      SHL = 340,
160      LSHR = 341,
161      ASHR = 342,
162      ICMP = 343,
163      FCMP = 344,
164      EQ = 345,
165      NE = 346,
166      SLT = 347,
167      SGT = 348,
168      SLE = 349,
169      SGE = 350,
170      ULT = 351,
171      UGT = 352,
172      ULE = 353,
173      UGE = 354,
174      OEQ = 355,
175      ONE = 356,
176      OLT = 357,
177      OGT = 358,
178      OLE = 359,
179      OGE = 360,
180      ORD = 361,
181      UNO = 362,
182      UEQ = 363,
183      UNE = 364,
184      MALLOC = 365,
185      ALLOCA = 366,
186      FREE = 367,
187      LOAD = 368,
188      STORE = 369,
189      GETELEMENTPTR = 370,
190      TRUNC = 371,
191      ZEXT = 372,
192      SEXT = 373,
193      FPTRUNC = 374,
194      FPEXT = 375,
195      BITCAST = 376,
196      UITOFP = 377,
197      SITOFP = 378,
198      FPTOUI = 379,
199      FPTOSI = 380,
200      INTTOPTR = 381,
201      PTRTOINT = 382,
202      PHI_TOK = 383,
203      SELECT = 384,
204      VAARG = 385,
205      EXTRACTELEMENT = 386,
206      INSERTELEMENT = 387,
207      SHUFFLEVECTOR = 388,
208      SIGNEXT = 389,
209      ZEROEXT = 390,
210      NORETURN = 391,
211      INREG = 392,
212      SRET = 393,
213      NOUNWIND = 394,
214      NOALIAS = 395,
215      BYVAL = 396,
216      NEST = 397,
217      READNONE = 398,
218      READONLY = 399,
219      DEFAULT = 400,
220      HIDDEN = 401,
221      PROTECTED = 402
222    };
223 #endif
224 /* Tokens.  */
225 #define ESINT64VAL 258
226 #define EUINT64VAL 259
227 #define ESAPINTVAL 260
228 #define EUAPINTVAL 261
229 #define LOCALVAL_ID 262
230 #define GLOBALVAL_ID 263
231 #define FPVAL 264
232 #define VOID 265
233 #define INTTYPE 266
234 #define FLOAT 267
235 #define DOUBLE 268
236 #define X86_FP80 269
237 #define FP128 270
238 #define PPC_FP128 271
239 #define LABEL 272
240 #define TYPE 273
241 #define LOCALVAR 274
242 #define GLOBALVAR 275
243 #define LABELSTR 276
244 #define STRINGCONSTANT 277
245 #define ATSTRINGCONSTANT 278
246 #define PCTSTRINGCONSTANT 279
247 #define ZEROINITIALIZER 280
248 #define TRUETOK 281
249 #define FALSETOK 282
250 #define BEGINTOK 283
251 #define ENDTOK 284
252 #define DECLARE 285
253 #define DEFINE 286
254 #define GLOBAL 287
255 #define CONSTANT 288
256 #define SECTION 289
257 #define ALIAS 290
258 #define VOLATILE 291
259 #define THREAD_LOCAL 292
260 #define TO 293
261 #define DOTDOTDOT 294
262 #define NULL_TOK 295
263 #define UNDEF 296
264 #define INTERNAL 297
265 #define LINKONCE 298
266 #define WEAK 299
267 #define APPENDING 300
268 #define DLLIMPORT 301
269 #define DLLEXPORT 302
270 #define EXTERN_WEAK 303
271 #define OPAQUE 304
272 #define EXTERNAL 305
273 #define TARGET 306
274 #define TRIPLE 307
275 #define ALIGN 308
276 #define DEPLIBS 309
277 #define CALL 310
278 #define TAIL 311
279 #define ASM_TOK 312
280 #define MODULE 313
281 #define SIDEEFFECT 314
282 #define CC_TOK 315
283 #define CCC_TOK 316
284 #define FASTCC_TOK 317
285 #define COLDCC_TOK 318
286 #define X86_STDCALLCC_TOK 319
287 #define X86_FASTCALLCC_TOK 320
288 #define DATALAYOUT 321
289 #define RET 322
290 #define BR 323
291 #define SWITCH 324
292 #define INVOKE 325
293 #define UNWIND 326
294 #define UNREACHABLE 327
295 #define ADD 328
296 #define SUB 329
297 #define MUL 330
298 #define UDIV 331
299 #define SDIV 332
300 #define FDIV 333
301 #define UREM 334
302 #define SREM 335
303 #define FREM 336
304 #define AND 337
305 #define OR 338
306 #define XOR 339
307 #define SHL 340
308 #define LSHR 341
309 #define ASHR 342
310 #define ICMP 343
311 #define FCMP 344
312 #define EQ 345
313 #define NE 346
314 #define SLT 347
315 #define SGT 348
316 #define SLE 349
317 #define SGE 350
318 #define ULT 351
319 #define UGT 352
320 #define ULE 353
321 #define UGE 354
322 #define OEQ 355
323 #define ONE 356
324 #define OLT 357
325 #define OGT 358
326 #define OLE 359
327 #define OGE 360
328 #define ORD 361
329 #define UNO 362
330 #define UEQ 363
331 #define UNE 364
332 #define MALLOC 365
333 #define ALLOCA 366
334 #define FREE 367
335 #define LOAD 368
336 #define STORE 369
337 #define GETELEMENTPTR 370
338 #define TRUNC 371
339 #define ZEXT 372
340 #define SEXT 373
341 #define FPTRUNC 374
342 #define FPEXT 375
343 #define BITCAST 376
344 #define UITOFP 377
345 #define SITOFP 378
346 #define FPTOUI 379
347 #define FPTOSI 380
348 #define INTTOPTR 381
349 #define PTRTOINT 382
350 #define PHI_TOK 383
351 #define SELECT 384
352 #define VAARG 385
353 #define EXTRACTELEMENT 386
354 #define INSERTELEMENT 387
355 #define SHUFFLEVECTOR 388
356 #define SIGNEXT 389
357 #define ZEROEXT 390
358 #define NORETURN 391
359 #define INREG 392
360 #define SRET 393
361 #define NOUNWIND 394
362 #define NOALIAS 395
363 #define BYVAL 396
364 #define NEST 397
365 #define READNONE 398
366 #define READONLY 399
367 #define DEFAULT 400
368 #define HIDDEN 401
369 #define PROTECTED 402
370
371
372
373
374 /* Copy the first part of user declarations.  */
375 #line 14 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
376
377 #include "ParserInternals.h"
378 #include "llvm/CallingConv.h"
379 #include "llvm/InlineAsm.h"
380 #include "llvm/Instructions.h"
381 #include "llvm/Module.h"
382 #include "llvm/ValueSymbolTable.h"
383 #include "llvm/AutoUpgrade.h"
384 #include "llvm/Support/GetElementPtrTypeIterator.h"
385 #include "llvm/Support/CommandLine.h"
386 #include "llvm/ADT/SmallVector.h"
387 #include "llvm/ADT/STLExtras.h"
388 #include "llvm/Support/MathExtras.h"
389 #include "llvm/Support/Streams.h"
390 #include <algorithm>
391 #include <list>
392 #include <map>
393 #include <utility>
394
395 // The following is a gross hack. In order to rid the libAsmParser library of
396 // exceptions, we have to have a way of getting the yyparse function to go into
397 // an error situation. So, whenever we want an error to occur, the GenerateError
398 // function (see bottom of file) sets TriggerError. Then, at the end of each 
399 // production in the grammer we use CHECK_FOR_ERROR which will invoke YYERROR 
400 // (a goto) to put YACC in error state. Furthermore, several calls to 
401 // GenerateError are made from inside productions and they must simulate the
402 // previous exception behavior by exiting the production immediately. We have
403 // replaced these with the GEN_ERROR macro which calls GeneratError and then
404 // immediately invokes YYERROR. This would be so much cleaner if it was a 
405 // recursive descent parser.
406 static bool TriggerError = false;
407 #define CHECK_FOR_ERROR { if (TriggerError) { TriggerError = false; YYABORT; } }
408 #define GEN_ERROR(msg) { GenerateError(msg); YYERROR; }
409
410 int yyerror(const char *ErrorMsg); // Forward declarations to prevent "implicit
411 int yylex();                       // declaration" of xxx warnings.
412 int yyparse();
413 using namespace llvm;
414
415 static Module *ParserResult;
416
417 // DEBUG_UPREFS - Define this symbol if you want to enable debugging output
418 // relating to upreferences in the input stream.
419 //
420 //#define DEBUG_UPREFS 1
421 #ifdef DEBUG_UPREFS
422 #define UR_OUT(X) cerr << X
423 #else
424 #define UR_OUT(X)
425 #endif
426
427 #define YYERROR_VERBOSE 1
428
429 static GlobalVariable *CurGV;
430
431
432 // This contains info used when building the body of a function.  It is
433 // destroyed when the function is completed.
434 //
435 typedef std::vector<Value *> ValueList;           // Numbered defs
436
437 static void 
438 ResolveDefinitions(ValueList &LateResolvers, ValueList *FutureLateResolvers=0);
439
440 static struct PerModuleInfo {
441   Module *CurrentModule;
442   ValueList Values; // Module level numbered definitions
443   ValueList LateResolveValues;
444   std::vector<PATypeHolder>    Types;
445   std::map<ValID, PATypeHolder> LateResolveTypes;
446
447   /// PlaceHolderInfo - When temporary placeholder objects are created, remember
448   /// how they were referenced and on which line of the input they came from so
449   /// that we can resolve them later and print error messages as appropriate.
450   std::map<Value*, std::pair<ValID, int> > PlaceHolderInfo;
451
452   // GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward
453   // references to global values.  Global values may be referenced before they
454   // are defined, and if so, the temporary object that they represent is held
455   // here.  This is used for forward references of GlobalValues.
456   //
457   typedef std::map<std::pair<const PointerType *,
458                              ValID>, GlobalValue*> GlobalRefsType;
459   GlobalRefsType GlobalRefs;
460
461   void ModuleDone() {
462     // If we could not resolve some functions at function compilation time
463     // (calls to functions before they are defined), resolve them now...  Types
464     // are resolved when the constant pool has been completely parsed.
465     //
466     ResolveDefinitions(LateResolveValues);
467     if (TriggerError)
468       return;
469
470     // Check to make sure that all global value forward references have been
471     // resolved!
472     //
473     if (!GlobalRefs.empty()) {
474       std::string UndefinedReferences = "Unresolved global references exist:\n";
475
476       for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end();
477            I != E; ++I) {
478         UndefinedReferences += "  " + I->first.first->getDescription() + " " +
479                                I->first.second.getName() + "\n";
480       }
481       GenerateError(UndefinedReferences);
482       return;
483     }
484
485     // Look for intrinsic functions and CallInst that need to be upgraded
486     for (Module::iterator FI = CurrentModule->begin(),
487          FE = CurrentModule->end(); FI != FE; )
488       UpgradeCallsToIntrinsic(FI++); // must be post-increment, as we remove
489
490     Values.clear();         // Clear out function local definitions
491     Types.clear();
492     CurrentModule = 0;
493   }
494
495   // GetForwardRefForGlobal - Check to see if there is a forward reference
496   // for this global.  If so, remove it from the GlobalRefs map and return it.
497   // If not, just return null.
498   GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) {
499     // Check to see if there is a forward reference to this global variable...
500     // if there is, eliminate it and patch the reference to use the new def'n.
501     GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID));
502     GlobalValue *Ret = 0;
503     if (I != GlobalRefs.end()) {
504       Ret = I->second;
505       GlobalRefs.erase(I);
506     }
507     return Ret;
508   }
509
510   bool TypeIsUnresolved(PATypeHolder* PATy) {
511     // If it isn't abstract, its resolved
512     const Type* Ty = PATy->get();
513     if (!Ty->isAbstract())
514       return false;
515     // Traverse the type looking for abstract types. If it isn't abstract then
516     // we don't need to traverse that leg of the type. 
517     std::vector<const Type*> WorkList, SeenList;
518     WorkList.push_back(Ty);
519     while (!WorkList.empty()) {
520       const Type* Ty = WorkList.back();
521       SeenList.push_back(Ty);
522       WorkList.pop_back();
523       if (const OpaqueType* OpTy = dyn_cast<OpaqueType>(Ty)) {
524         // Check to see if this is an unresolved type
525         std::map<ValID, PATypeHolder>::iterator I = LateResolveTypes.begin();
526         std::map<ValID, PATypeHolder>::iterator E = LateResolveTypes.end();
527         for ( ; I != E; ++I) {
528           if (I->second.get() == OpTy)
529             return true;
530         }
531       } else if (const SequentialType* SeqTy = dyn_cast<SequentialType>(Ty)) {
532         const Type* TheTy = SeqTy->getElementType();
533         if (TheTy->isAbstract() && TheTy != Ty) {
534           std::vector<const Type*>::iterator I = SeenList.begin(), 
535                                              E = SeenList.end();
536           for ( ; I != E; ++I)
537             if (*I == TheTy)
538               break;
539           if (I == E)
540             WorkList.push_back(TheTy);
541         }
542       } else if (const StructType* StrTy = dyn_cast<StructType>(Ty)) {
543         for (unsigned i = 0; i < StrTy->getNumElements(); ++i) {
544           const Type* TheTy = StrTy->getElementType(i);
545           if (TheTy->isAbstract() && TheTy != Ty) {
546             std::vector<const Type*>::iterator I = SeenList.begin(), 
547                                                E = SeenList.end();
548             for ( ; I != E; ++I)
549               if (*I == TheTy)
550                 break;
551             if (I == E)
552               WorkList.push_back(TheTy);
553           }
554         }
555       }
556     }
557     return false;
558   }
559 } CurModule;
560
561 static struct PerFunctionInfo {
562   Function *CurrentFunction;     // Pointer to current function being created
563
564   ValueList Values; // Keep track of #'d definitions
565   unsigned NextValNum;
566   ValueList LateResolveValues;
567   bool isDeclare;                   // Is this function a forward declararation?
568   GlobalValue::LinkageTypes Linkage; // Linkage for forward declaration.
569   GlobalValue::VisibilityTypes Visibility;
570
571   /// BBForwardRefs - When we see forward references to basic blocks, keep
572   /// track of them here.
573   std::map<ValID, BasicBlock*> BBForwardRefs;
574
575   inline PerFunctionInfo() {
576     CurrentFunction = 0;
577     isDeclare = false;
578     Linkage = GlobalValue::ExternalLinkage;
579     Visibility = GlobalValue::DefaultVisibility;
580   }
581
582   inline void FunctionStart(Function *M) {
583     CurrentFunction = M;
584     NextValNum = 0;
585   }
586
587   void FunctionDone() {
588     // Any forward referenced blocks left?
589     if (!BBForwardRefs.empty()) {
590       GenerateError("Undefined reference to label " +
591                      BBForwardRefs.begin()->second->getName());
592       return;
593     }
594
595     // Resolve all forward references now.
596     ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
597
598     Values.clear();         // Clear out function local definitions
599     BBForwardRefs.clear();
600     CurrentFunction = 0;
601     isDeclare = false;
602     Linkage = GlobalValue::ExternalLinkage;
603     Visibility = GlobalValue::DefaultVisibility;
604   }
605 } CurFun;  // Info for the current function...
606
607 static bool inFunctionScope() { return CurFun.CurrentFunction != 0; }
608
609
610 //===----------------------------------------------------------------------===//
611 //               Code to handle definitions of all the types
612 //===----------------------------------------------------------------------===//
613
614 static void InsertValue(Value *V, ValueList &ValueTab = CurFun.Values) {
615   // Things that have names or are void typed don't get slot numbers
616   if (V->hasName() || (V->getType() == Type::VoidTy))
617     return;
618
619   // In the case of function values, we have to allow for the forward reference
620   // of basic blocks, which are included in the numbering. Consequently, we keep
621   // track of the next insertion location with NextValNum. When a BB gets 
622   // inserted, it could change the size of the CurFun.Values vector.
623   if (&ValueTab == &CurFun.Values) {
624     if (ValueTab.size() <= CurFun.NextValNum)
625       ValueTab.resize(CurFun.NextValNum+1);
626     ValueTab[CurFun.NextValNum++] = V;
627     return;
628   } 
629   // For all other lists, its okay to just tack it on the back of the vector.
630   ValueTab.push_back(V);
631 }
632
633 static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
634   switch (D.Type) {
635   case ValID::LocalID:               // Is it a numbered definition?
636     // Module constants occupy the lowest numbered slots...
637     if (D.Num < CurModule.Types.size())
638       return CurModule.Types[D.Num];
639     break;
640   case ValID::LocalName:                 // Is it a named definition?
641     if (const Type *N = CurModule.CurrentModule->getTypeByName(D.getName())) {
642       D.destroy();  // Free old strdup'd memory...
643       return N;
644     }
645     break;
646   default:
647     GenerateError("Internal parser error: Invalid symbol type reference");
648     return 0;
649   }
650
651   // If we reached here, we referenced either a symbol that we don't know about
652   // or an id number that hasn't been read yet.  We may be referencing something
653   // forward, so just create an entry to be resolved later and get to it...
654   //
655   if (DoNotImprovise) return 0;  // Do we just want a null to be returned?
656
657
658   if (inFunctionScope()) {
659     if (D.Type == ValID::LocalName) {
660       GenerateError("Reference to an undefined type: '" + D.getName() + "'");
661       return 0;
662     } else {
663       GenerateError("Reference to an undefined type: #" + utostr(D.Num));
664       return 0;
665     }
666   }
667
668   std::map<ValID, PATypeHolder>::iterator I =CurModule.LateResolveTypes.find(D);
669   if (I != CurModule.LateResolveTypes.end())
670     return I->second;
671
672   Type *Typ = OpaqueType::get();
673   CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
674   return Typ;
675  }
676
677 // getExistingVal - Look up the value specified by the provided type and
678 // the provided ValID.  If the value exists and has already been defined, return
679 // it.  Otherwise return null.
680 //
681 static Value *getExistingVal(const Type *Ty, const ValID &D) {
682   if (isa<FunctionType>(Ty)) {
683     GenerateError("Functions are not values and "
684                    "must be referenced as pointers");
685     return 0;
686   }
687
688   switch (D.Type) {
689   case ValID::LocalID: {                 // Is it a numbered definition?
690     // Check that the number is within bounds.
691     if (D.Num >= CurFun.Values.size()) 
692       return 0;
693     Value *Result = CurFun.Values[D.Num];
694     if (Ty != Result->getType()) {
695       GenerateError("Numbered value (%" + utostr(D.Num) + ") of type '" +
696                     Result->getType()->getDescription() + "' does not match " 
697                     "expected type, '" + Ty->getDescription() + "'");
698       return 0;
699     }
700     return Result;
701   }
702   case ValID::GlobalID: {                 // Is it a numbered definition?
703     if (D.Num >= CurModule.Values.size()) 
704       return 0;
705     Value *Result = CurModule.Values[D.Num];
706     if (Ty != Result->getType()) {
707       GenerateError("Numbered value (@" + utostr(D.Num) + ") of type '" +
708                     Result->getType()->getDescription() + "' does not match " 
709                     "expected type, '" + Ty->getDescription() + "'");
710       return 0;
711     }
712     return Result;
713   }
714     
715   case ValID::LocalName: {                // Is it a named definition?
716     if (!inFunctionScope()) 
717       return 0;
718     ValueSymbolTable &SymTab = CurFun.CurrentFunction->getValueSymbolTable();
719     Value *N = SymTab.lookup(D.getName());
720     if (N == 0) 
721       return 0;
722     if (N->getType() != Ty)
723       return 0;
724     
725     D.destroy();  // Free old strdup'd memory...
726     return N;
727   }
728   case ValID::GlobalName: {                // Is it a named definition?
729     ValueSymbolTable &SymTab = CurModule.CurrentModule->getValueSymbolTable();
730     Value *N = SymTab.lookup(D.getName());
731     if (N == 0) 
732       return 0;
733     if (N->getType() != Ty)
734       return 0;
735
736     D.destroy();  // Free old strdup'd memory...
737     return N;
738   }
739
740   // Check to make sure that "Ty" is an integral type, and that our
741   // value will fit into the specified type...
742   case ValID::ConstSIntVal:    // Is it a constant pool reference??
743     if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
744       GenerateError("Signed integral constant '" +
745                      itostr(D.ConstPool64) + "' is invalid for type '" +
746                      Ty->getDescription() + "'");
747       return 0;
748     }
749     return ConstantInt::get(Ty, D.ConstPool64, true);
750
751   case ValID::ConstUIntVal:     // Is it an unsigned const pool reference?
752     if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) {
753       if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
754         GenerateError("Integral constant '" + utostr(D.UConstPool64) +
755                        "' is invalid or out of range");
756         return 0;
757       } else {     // This is really a signed reference.  Transmogrify.
758         return ConstantInt::get(Ty, D.ConstPool64, true);
759       }
760     } else {
761       return ConstantInt::get(Ty, D.UConstPool64);
762     }
763
764   case ValID::ConstFPVal:        // Is it a floating point const pool reference?
765     if (!ConstantFP::isValueValidForType(Ty, *D.ConstPoolFP)) {
766       GenerateError("FP constant invalid for type");
767       return 0;
768     }
769     // Lexer has no type info, so builds all float and double  FP constants 
770     // as double.  Fix this here.  Long double does not need this.
771     if (&D.ConstPoolFP->getSemantics() == &APFloat::IEEEdouble &&
772         Ty==Type::FloatTy)
773       D.ConstPoolFP->convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven);
774     return ConstantFP::get(Ty, *D.ConstPoolFP);
775
776   case ValID::ConstNullVal:      // Is it a null value?
777     if (!isa<PointerType>(Ty)) {
778       GenerateError("Cannot create a a non pointer null");
779       return 0;
780     }
781     return ConstantPointerNull::get(cast<PointerType>(Ty));
782
783   case ValID::ConstUndefVal:      // Is it an undef value?
784     return UndefValue::get(Ty);
785
786   case ValID::ConstZeroVal:      // Is it a zero value?
787     return Constant::getNullValue(Ty);
788     
789   case ValID::ConstantVal:       // Fully resolved constant?
790     if (D.ConstantValue->getType() != Ty) {
791       GenerateError("Constant expression type different from required type");
792       return 0;
793     }
794     return D.ConstantValue;
795
796   case ValID::InlineAsmVal: {    // Inline asm expression
797     const PointerType *PTy = dyn_cast<PointerType>(Ty);
798     const FunctionType *FTy =
799       PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
800     if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints)) {
801       GenerateError("Invalid type for asm constraint string");
802       return 0;
803     }
804     InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
805                                    D.IAD->HasSideEffects);
806     D.destroy();   // Free InlineAsmDescriptor.
807     return IA;
808   }
809   default:
810     assert(0 && "Unhandled case!");
811     return 0;
812   }   // End of switch
813
814   assert(0 && "Unhandled case!");
815   return 0;
816 }
817
818 // getVal - This function is identical to getExistingVal, except that if a
819 // value is not already defined, it "improvises" by creating a placeholder var
820 // that looks and acts just like the requested variable.  When the value is
821 // defined later, all uses of the placeholder variable are replaced with the
822 // real thing.
823 //
824 static Value *getVal(const Type *Ty, const ValID &ID) {
825   if (Ty == Type::LabelTy) {
826     GenerateError("Cannot use a basic block here");
827     return 0;
828   }
829
830   // See if the value has already been defined.
831   Value *V = getExistingVal(Ty, ID);
832   if (V) return V;
833   if (TriggerError) return 0;
834
835   if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty)) {
836     GenerateError("Invalid use of a composite type");
837     return 0;
838   }
839
840   // If we reached here, we referenced either a symbol that we don't know about
841   // or an id number that hasn't been read yet.  We may be referencing something
842   // forward, so just create an entry to be resolved later and get to it...
843   //
844   switch (ID.Type) {
845   case ValID::GlobalName:
846   case ValID::GlobalID: {
847    const PointerType *PTy = dyn_cast<PointerType>(Ty);
848    if (!PTy) {
849      GenerateError("Invalid type for reference to global" );
850      return 0;
851    }
852    const Type* ElTy = PTy->getElementType();
853    if (const FunctionType *FTy = dyn_cast<FunctionType>(ElTy))
854      V = new Function(FTy, GlobalValue::ExternalLinkage);
855    else
856      V = new GlobalVariable(ElTy, false, GlobalValue::ExternalLinkage);
857    break;
858   }
859   default:
860    V = new Argument(Ty);
861   }
862   
863   // Remember where this forward reference came from.  FIXME, shouldn't we try
864   // to recycle these things??
865   CurModule.PlaceHolderInfo.insert(std::make_pair(V, std::make_pair(ID,
866                                                               LLLgetLineNo())));
867
868   if (inFunctionScope())
869     InsertValue(V, CurFun.LateResolveValues);
870   else
871     InsertValue(V, CurModule.LateResolveValues);
872   return V;
873 }
874
875 /// defineBBVal - This is a definition of a new basic block with the specified
876 /// identifier which must be the same as CurFun.NextValNum, if its numeric.
877 static BasicBlock *defineBBVal(const ValID &ID) {
878   assert(inFunctionScope() && "Can't get basic block at global scope!");
879
880   BasicBlock *BB = 0;
881
882   // First, see if this was forward referenced
883
884   std::map<ValID, BasicBlock*>::iterator BBI = CurFun.BBForwardRefs.find(ID);
885   if (BBI != CurFun.BBForwardRefs.end()) {
886     BB = BBI->second;
887     // The forward declaration could have been inserted anywhere in the
888     // function: insert it into the correct place now.
889     CurFun.CurrentFunction->getBasicBlockList().remove(BB);
890     CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
891
892     // We're about to erase the entry, save the key so we can clean it up.
893     ValID Tmp = BBI->first;
894
895     // Erase the forward ref from the map as its no longer "forward"
896     CurFun.BBForwardRefs.erase(ID);
897
898     // The key has been removed from the map but so we don't want to leave 
899     // strdup'd memory around so destroy it too.
900     Tmp.destroy();
901
902     // If its a numbered definition, bump the number and set the BB value.
903     if (ID.Type == ValID::LocalID) {
904       assert(ID.Num == CurFun.NextValNum && "Invalid new block number");
905       InsertValue(BB);
906     }
907
908     ID.destroy();
909     return BB;
910   } 
911   
912   // We haven't seen this BB before and its first mention is a definition. 
913   // Just create it and return it.
914   std::string Name (ID.Type == ValID::LocalName ? ID.getName() : "");
915   BB = new BasicBlock(Name, CurFun.CurrentFunction);
916   if (ID.Type == ValID::LocalID) {
917     assert(ID.Num == CurFun.NextValNum && "Invalid new block number");
918     InsertValue(BB);
919   }
920
921   ID.destroy(); // Free strdup'd memory
922   return BB;
923 }
924
925 /// getBBVal - get an existing BB value or create a forward reference for it.
926 /// 
927 static BasicBlock *getBBVal(const ValID &ID) {
928   assert(inFunctionScope() && "Can't get basic block at global scope!");
929
930   BasicBlock *BB =  0;
931
932   std::map<ValID, BasicBlock*>::iterator BBI = CurFun.BBForwardRefs.find(ID);
933   if (BBI != CurFun.BBForwardRefs.end()) {
934     BB = BBI->second;
935   } if (ID.Type == ValID::LocalName) {
936     std::string Name = ID.getName();
937     Value *N = CurFun.CurrentFunction->getValueSymbolTable().lookup(Name);
938     if (N)
939       if (N->getType()->getTypeID() == Type::LabelTyID)
940         BB = cast<BasicBlock>(N);
941       else
942         GenerateError("Reference to label '" + Name + "' is actually of type '"+
943           N->getType()->getDescription() + "'");
944   } else if (ID.Type == ValID::LocalID) {
945     if (ID.Num < CurFun.NextValNum && ID.Num < CurFun.Values.size()) {
946       if (CurFun.Values[ID.Num]->getType()->getTypeID() == Type::LabelTyID)
947         BB = cast<BasicBlock>(CurFun.Values[ID.Num]);
948       else
949         GenerateError("Reference to label '%" + utostr(ID.Num) + 
950           "' is actually of type '"+ 
951           CurFun.Values[ID.Num]->getType()->getDescription() + "'");
952     }
953   } else {
954     GenerateError("Illegal label reference " + ID.getName());
955     return 0;
956   }
957
958   // If its already been defined, return it now.
959   if (BB) {
960     ID.destroy(); // Free strdup'd memory.
961     return BB;
962   }
963
964   // Otherwise, this block has not been seen before, create it.
965   std::string Name;
966   if (ID.Type == ValID::LocalName)
967     Name = ID.getName();
968   BB = new BasicBlock(Name, CurFun.CurrentFunction);
969
970   // Insert it in the forward refs map.
971   CurFun.BBForwardRefs[ID] = BB;
972
973   return BB;
974 }
975
976
977 //===----------------------------------------------------------------------===//
978 //              Code to handle forward references in instructions
979 //===----------------------------------------------------------------------===//
980 //
981 // This code handles the late binding needed with statements that reference
982 // values not defined yet... for example, a forward branch, or the PHI node for
983 // a loop body.
984 //
985 // This keeps a table (CurFun.LateResolveValues) of all such forward references
986 // and back patchs after we are done.
987 //
988
989 // ResolveDefinitions - If we could not resolve some defs at parsing
990 // time (forward branches, phi functions for loops, etc...) resolve the
991 // defs now...
992 //
993 static void 
994 ResolveDefinitions(ValueList &LateResolvers, ValueList *FutureLateResolvers) {
995   // Loop over LateResolveDefs fixing up stuff that couldn't be resolved
996   while (!LateResolvers.empty()) {
997     Value *V = LateResolvers.back();
998     LateResolvers.pop_back();
999
1000     std::map<Value*, std::pair<ValID, int> >::iterator PHI =
1001       CurModule.PlaceHolderInfo.find(V);
1002     assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error!");
1003
1004     ValID &DID = PHI->second.first;
1005
1006     Value *TheRealValue = getExistingVal(V->getType(), DID);
1007     if (TriggerError)
1008       return;
1009     if (TheRealValue) {
1010       V->replaceAllUsesWith(TheRealValue);
1011       delete V;
1012       CurModule.PlaceHolderInfo.erase(PHI);
1013     } else if (FutureLateResolvers) {
1014       // Functions have their unresolved items forwarded to the module late
1015       // resolver table
1016       InsertValue(V, *FutureLateResolvers);
1017     } else {
1018       if (DID.Type == ValID::LocalName || DID.Type == ValID::GlobalName) {
1019         GenerateError("Reference to an invalid definition: '" +DID.getName()+
1020                        "' of type '" + V->getType()->getDescription() + "'",
1021                        PHI->second.second);
1022         return;
1023       } else {
1024         GenerateError("Reference to an invalid definition: #" +
1025                        itostr(DID.Num) + " of type '" +
1026                        V->getType()->getDescription() + "'",
1027                        PHI->second.second);
1028         return;
1029       }
1030     }
1031   }
1032   LateResolvers.clear();
1033 }
1034
1035 // ResolveTypeTo - A brand new type was just declared.  This means that (if
1036 // name is not null) things referencing Name can be resolved.  Otherwise, things
1037 // refering to the number can be resolved.  Do this now.
1038 //
1039 static void ResolveTypeTo(std::string *Name, const Type *ToTy) {
1040   ValID D;
1041   if (Name)
1042     D = ValID::createLocalName(*Name);
1043   else      
1044     D = ValID::createLocalID(CurModule.Types.size());
1045
1046   std::map<ValID, PATypeHolder>::iterator I =
1047     CurModule.LateResolveTypes.find(D);
1048   if (I != CurModule.LateResolveTypes.end()) {
1049     ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy);
1050     CurModule.LateResolveTypes.erase(I);
1051   }
1052 }
1053
1054 // setValueName - Set the specified value to the name given.  The name may be
1055 // null potentially, in which case this is a noop.  The string passed in is
1056 // assumed to be a malloc'd string buffer, and is free'd by this function.
1057 //
1058 static void setValueName(Value *V, std::string *NameStr) {
1059   if (!NameStr) return;
1060   std::string Name(*NameStr);      // Copy string
1061   delete NameStr;                  // Free old string
1062
1063   if (V->getType() == Type::VoidTy) {
1064     GenerateError("Can't assign name '" + Name+"' to value with void type");
1065     return;
1066   }
1067
1068   assert(inFunctionScope() && "Must be in function scope!");
1069   ValueSymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
1070   if (ST.lookup(Name)) {
1071     GenerateError("Redefinition of value '" + Name + "' of type '" +
1072                    V->getType()->getDescription() + "'");
1073     return;
1074   }
1075
1076   // Set the name.
1077   V->setName(Name);
1078 }
1079
1080 /// ParseGlobalVariable - Handle parsing of a global.  If Initializer is null,
1081 /// this is a declaration, otherwise it is a definition.
1082 static GlobalVariable *
1083 ParseGlobalVariable(std::string *NameStr,
1084                     GlobalValue::LinkageTypes Linkage,
1085                     GlobalValue::VisibilityTypes Visibility,
1086                     bool isConstantGlobal, const Type *Ty,
1087                     Constant *Initializer, bool IsThreadLocal) {
1088   if (isa<FunctionType>(Ty)) {
1089     GenerateError("Cannot declare global vars of function type");
1090     return 0;
1091   }
1092
1093   const PointerType *PTy = PointerType::get(Ty);
1094
1095   std::string Name;
1096   if (NameStr) {
1097     Name = *NameStr;      // Copy string
1098     delete NameStr;       // Free old string
1099   }
1100
1101   // See if this global value was forward referenced.  If so, recycle the
1102   // object.
1103   ValID ID;
1104   if (!Name.empty()) {
1105     ID = ValID::createGlobalName(Name);
1106   } else {
1107     ID = ValID::createGlobalID(CurModule.Values.size());
1108   }
1109
1110   if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
1111     // Move the global to the end of the list, from whereever it was
1112     // previously inserted.
1113     GlobalVariable *GV = cast<GlobalVariable>(FWGV);
1114     CurModule.CurrentModule->getGlobalList().remove(GV);
1115     CurModule.CurrentModule->getGlobalList().push_back(GV);
1116     GV->setInitializer(Initializer);
1117     GV->setLinkage(Linkage);
1118     GV->setVisibility(Visibility);
1119     GV->setConstant(isConstantGlobal);
1120     GV->setThreadLocal(IsThreadLocal);
1121     InsertValue(GV, CurModule.Values);
1122     return GV;
1123   }
1124
1125   // If this global has a name
1126   if (!Name.empty()) {
1127     // if the global we're parsing has an initializer (is a definition) and
1128     // has external linkage.
1129     if (Initializer && Linkage != GlobalValue::InternalLinkage)
1130       // If there is already a global with external linkage with this name
1131       if (CurModule.CurrentModule->getGlobalVariable(Name, false)) {
1132         // If we allow this GVar to get created, it will be renamed in the
1133         // symbol table because it conflicts with an existing GVar. We can't
1134         // allow redefinition of GVars whose linking indicates that their name
1135         // must stay the same. Issue the error.
1136         GenerateError("Redefinition of global variable named '" + Name +
1137                        "' of type '" + Ty->getDescription() + "'");
1138         return 0;
1139       }
1140   }
1141
1142   // Otherwise there is no existing GV to use, create one now.
1143   GlobalVariable *GV =
1144     new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
1145                        CurModule.CurrentModule, IsThreadLocal);
1146   GV->setVisibility(Visibility);
1147   InsertValue(GV, CurModule.Values);
1148   return GV;
1149 }
1150
1151 // setTypeName - Set the specified type to the name given.  The name may be
1152 // null potentially, in which case this is a noop.  The string passed in is
1153 // assumed to be a malloc'd string buffer, and is freed by this function.
1154 //
1155 // This function returns true if the type has already been defined, but is
1156 // allowed to be redefined in the specified context.  If the name is a new name
1157 // for the type plane, it is inserted and false is returned.
1158 static bool setTypeName(const Type *T, std::string *NameStr) {
1159   assert(!inFunctionScope() && "Can't give types function-local names!");
1160   if (NameStr == 0) return false;
1161  
1162   std::string Name(*NameStr);      // Copy string
1163   delete NameStr;                  // Free old string
1164
1165   // We don't allow assigning names to void type
1166   if (T == Type::VoidTy) {
1167     GenerateError("Can't assign name '" + Name + "' to the void type");
1168     return false;
1169   }
1170
1171   // Set the type name, checking for conflicts as we do so.
1172   bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T);
1173
1174   if (AlreadyExists) {   // Inserting a name that is already defined???
1175     const Type *Existing = CurModule.CurrentModule->getTypeByName(Name);
1176     assert(Existing && "Conflict but no matching type?!");
1177
1178     // There is only one case where this is allowed: when we are refining an
1179     // opaque type.  In this case, Existing will be an opaque type.
1180     if (const OpaqueType *OpTy = dyn_cast<OpaqueType>(Existing)) {
1181       // We ARE replacing an opaque type!
1182       const_cast<OpaqueType*>(OpTy)->refineAbstractTypeTo(T);
1183       return true;
1184     }
1185
1186     // Otherwise, this is an attempt to redefine a type. That's okay if
1187     // the redefinition is identical to the original. This will be so if
1188     // Existing and T point to the same Type object. In this one case we
1189     // allow the equivalent redefinition.
1190     if (Existing == T) return true;  // Yes, it's equal.
1191
1192     // Any other kind of (non-equivalent) redefinition is an error.
1193     GenerateError("Redefinition of type named '" + Name + "' of type '" +
1194                    T->getDescription() + "'");
1195   }
1196
1197   return false;
1198 }
1199
1200 //===----------------------------------------------------------------------===//
1201 // Code for handling upreferences in type names...
1202 //
1203
1204 // TypeContains - Returns true if Ty directly contains E in it.
1205 //
1206 static bool TypeContains(const Type *Ty, const Type *E) {
1207   return std::find(Ty->subtype_begin(), Ty->subtype_end(),
1208                    E) != Ty->subtype_end();
1209 }
1210
1211 namespace {
1212   struct UpRefRecord {
1213     // NestingLevel - The number of nesting levels that need to be popped before
1214     // this type is resolved.
1215     unsigned NestingLevel;
1216
1217     // LastContainedTy - This is the type at the current binding level for the
1218     // type.  Every time we reduce the nesting level, this gets updated.
1219     const Type *LastContainedTy;
1220
1221     // UpRefTy - This is the actual opaque type that the upreference is
1222     // represented with.
1223     OpaqueType *UpRefTy;
1224
1225     UpRefRecord(unsigned NL, OpaqueType *URTy)
1226       : NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {}
1227   };
1228 }
1229
1230 // UpRefs - A list of the outstanding upreferences that need to be resolved.
1231 static std::vector<UpRefRecord> UpRefs;
1232
1233 /// HandleUpRefs - Every time we finish a new layer of types, this function is
1234 /// called.  It loops through the UpRefs vector, which is a list of the
1235 /// currently active types.  For each type, if the up reference is contained in
1236 /// the newly completed type, we decrement the level count.  When the level
1237 /// count reaches zero, the upreferenced type is the type that is passed in:
1238 /// thus we can complete the cycle.
1239 ///
1240 static PATypeHolder HandleUpRefs(const Type *ty) {
1241   // If Ty isn't abstract, or if there are no up-references in it, then there is
1242   // nothing to resolve here.
1243   if (!ty->isAbstract() || UpRefs.empty()) return ty;
1244   
1245   PATypeHolder Ty(ty);
1246   UR_OUT("Type '" << Ty->getDescription() <<
1247          "' newly formed.  Resolving upreferences.\n" <<
1248          UpRefs.size() << " upreferences active!\n");
1249
1250   // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
1251   // to zero), we resolve them all together before we resolve them to Ty.  At
1252   // the end of the loop, if there is anything to resolve to Ty, it will be in
1253   // this variable.
1254   OpaqueType *TypeToResolve = 0;
1255
1256   for (unsigned i = 0; i != UpRefs.size(); ++i) {
1257     UR_OUT("  UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
1258            << UpRefs[i].second->getDescription() << ") = "
1259            << (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n");
1260     if (TypeContains(Ty, UpRefs[i].LastContainedTy)) {
1261       // Decrement level of upreference
1262       unsigned Level = --UpRefs[i].NestingLevel;
1263       UpRefs[i].LastContainedTy = Ty;
1264       UR_OUT("  Uplevel Ref Level = " << Level << "\n");
1265       if (Level == 0) {                     // Upreference should be resolved!
1266         if (!TypeToResolve) {
1267           TypeToResolve = UpRefs[i].UpRefTy;
1268         } else {
1269           UR_OUT("  * Resolving upreference for "
1270                  << UpRefs[i].second->getDescription() << "\n";
1271                  std::string OldName = UpRefs[i].UpRefTy->getDescription());
1272           UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
1273           UR_OUT("  * Type '" << OldName << "' refined upreference to: "
1274                  << (const void*)Ty << ", " << Ty->getDescription() << "\n");
1275         }
1276         UpRefs.erase(UpRefs.begin()+i);     // Remove from upreference list...
1277         --i;                                // Do not skip the next element...
1278       }
1279     }
1280   }
1281
1282   if (TypeToResolve) {
1283     UR_OUT("  * Resolving upreference for "
1284            << UpRefs[i].second->getDescription() << "\n";
1285            std::string OldName = TypeToResolve->getDescription());
1286     TypeToResolve->refineAbstractTypeTo(Ty);
1287   }
1288
1289   return Ty;
1290 }
1291
1292 //===----------------------------------------------------------------------===//
1293 //            RunVMAsmParser - Define an interface to this parser
1294 //===----------------------------------------------------------------------===//
1295 //
1296 static Module* RunParser(Module * M);
1297
1298 Module *llvm::RunVMAsmParser(llvm::MemoryBuffer *MB) {
1299   InitLLLexer(MB);
1300   Module *M = RunParser(new Module(LLLgetFilename()));
1301   FreeLexer();
1302   return M;
1303 }
1304
1305
1306
1307 /* Enabling traces.  */
1308 #ifndef YYDEBUG
1309 # define YYDEBUG 0
1310 #endif
1311
1312 /* Enabling verbose error messages.  */
1313 #ifdef YYERROR_VERBOSE
1314 # undef YYERROR_VERBOSE
1315 # define YYERROR_VERBOSE 1
1316 #else
1317 # define YYERROR_VERBOSE 0
1318 #endif
1319
1320 /* Enabling the token table.  */
1321 #ifndef YYTOKEN_TABLE
1322 # define YYTOKEN_TABLE 0
1323 #endif
1324
1325 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1326 typedef union YYSTYPE
1327 #line 945 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
1328 {
1329   llvm::Module                           *ModuleVal;
1330   llvm::Function                         *FunctionVal;
1331   llvm::BasicBlock                       *BasicBlockVal;
1332   llvm::TerminatorInst                   *TermInstVal;
1333   llvm::Instruction                      *InstVal;
1334   llvm::Constant                         *ConstVal;
1335
1336   const llvm::Type                       *PrimType;
1337   std::list<llvm::PATypeHolder>          *TypeList;
1338   llvm::PATypeHolder                     *TypeVal;
1339   llvm::Value                            *ValueVal;
1340   std::vector<llvm::Value*>              *ValueList;
1341   llvm::ArgListType                      *ArgList;
1342   llvm::TypeWithAttrs                     TypeWithAttrs;
1343   llvm::TypeWithAttrsList                *TypeWithAttrsList;
1344   llvm::ParamList                        *ParamList;
1345
1346   // Represent the RHS of PHI node
1347   std::list<std::pair<llvm::Value*,
1348                       llvm::BasicBlock*> > *PHIList;
1349   std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable;
1350   std::vector<llvm::Constant*>           *ConstVector;
1351
1352   llvm::GlobalValue::LinkageTypes         Linkage;
1353   llvm::GlobalValue::VisibilityTypes      Visibility;
1354   uint16_t                          ParamAttrs;
1355   llvm::APInt                       *APIntVal;
1356   int64_t                           SInt64Val;
1357   uint64_t                          UInt64Val;
1358   int                               SIntVal;
1359   unsigned                          UIntVal;
1360   llvm::APFloat                    *FPVal;
1361   bool                              BoolVal;
1362
1363   std::string                      *StrVal;   // This memory must be deleted
1364   llvm::ValID                       ValIDVal;
1365
1366   llvm::Instruction::BinaryOps      BinaryOpVal;
1367   llvm::Instruction::TermOps        TermOpVal;
1368   llvm::Instruction::MemoryOps      MemOpVal;
1369   llvm::Instruction::CastOps        CastOpVal;
1370   llvm::Instruction::OtherOps       OtherOpVal;
1371   llvm::ICmpInst::Predicate         IPredicate;
1372   llvm::FCmpInst::Predicate         FPredicate;
1373 }
1374 /* Line 187 of yacc.c.  */
1375 #line 1376 "llvmAsmParser.tab.c"
1376         YYSTYPE;
1377 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1378 # define YYSTYPE_IS_DECLARED 1
1379 # define YYSTYPE_IS_TRIVIAL 1
1380 #endif
1381
1382
1383
1384 /* Copy the second part of user declarations.  */
1385
1386
1387 /* Line 216 of yacc.c.  */
1388 #line 1389 "llvmAsmParser.tab.c"
1389
1390 #ifdef short
1391 # undef short
1392 #endif
1393
1394 #ifdef YYTYPE_UINT8
1395 typedef YYTYPE_UINT8 yytype_uint8;
1396 #else
1397 typedef unsigned char yytype_uint8;
1398 #endif
1399
1400 #ifdef YYTYPE_INT8
1401 typedef YYTYPE_INT8 yytype_int8;
1402 #elif (defined __STDC__ || defined __C99__FUNC__ \
1403      || defined __cplusplus || defined _MSC_VER)
1404 typedef signed char yytype_int8;
1405 #else
1406 typedef short int yytype_int8;
1407 #endif
1408
1409 #ifdef YYTYPE_UINT16
1410 typedef YYTYPE_UINT16 yytype_uint16;
1411 #else
1412 typedef unsigned short int yytype_uint16;
1413 #endif
1414
1415 #ifdef YYTYPE_INT16
1416 typedef YYTYPE_INT16 yytype_int16;
1417 #else
1418 typedef short int yytype_int16;
1419 #endif
1420
1421 #ifndef YYSIZE_T
1422 # ifdef __SIZE_TYPE__
1423 #  define YYSIZE_T __SIZE_TYPE__
1424 # elif defined size_t
1425 #  define YYSIZE_T size_t
1426 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
1427      || defined __cplusplus || defined _MSC_VER)
1428 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
1429 #  define YYSIZE_T size_t
1430 # else
1431 #  define YYSIZE_T unsigned int
1432 # endif
1433 #endif
1434
1435 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
1436
1437 #ifndef YY_
1438 # if YYENABLE_NLS
1439 #  if ENABLE_NLS
1440 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
1441 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
1442 #  endif
1443 # endif
1444 # ifndef YY_
1445 #  define YY_(msgid) msgid
1446 # endif
1447 #endif
1448
1449 /* Suppress unused-variable warnings by "using" E.  */
1450 #if ! defined lint || defined __GNUC__
1451 # define YYUSE(e) ((void) (e))
1452 #else
1453 # define YYUSE(e) /* empty */
1454 #endif
1455
1456 /* Identity function, used to suppress warnings about constant conditions.  */
1457 #ifndef lint
1458 # define YYID(n) (n)
1459 #else
1460 #if (defined __STDC__ || defined __C99__FUNC__ \
1461      || defined __cplusplus || defined _MSC_VER)
1462 static int
1463 YYID (int i)
1464 #else
1465 static int
1466 YYID (i)
1467     int i;
1468 #endif
1469 {
1470   return i;
1471 }
1472 #endif
1473
1474 #if ! defined yyoverflow || YYERROR_VERBOSE
1475
1476 /* The parser invokes alloca or malloc; define the necessary symbols.  */
1477
1478 # ifdef YYSTACK_USE_ALLOCA
1479 #  if YYSTACK_USE_ALLOCA
1480 #   ifdef __GNUC__
1481 #    define YYSTACK_ALLOC __builtin_alloca
1482 #   elif defined __BUILTIN_VA_ARG_INCR
1483 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
1484 #   elif defined _AIX
1485 #    define YYSTACK_ALLOC __alloca
1486 #   elif defined _MSC_VER
1487 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
1488 #    define alloca _alloca
1489 #   else
1490 #    define YYSTACK_ALLOC alloca
1491 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1492      || defined __cplusplus || defined _MSC_VER)
1493 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1494 #     ifndef _STDLIB_H
1495 #      define _STDLIB_H 1
1496 #     endif
1497 #    endif
1498 #   endif
1499 #  endif
1500 # endif
1501
1502 # ifdef YYSTACK_ALLOC
1503    /* Pacify GCC's `empty if-body' warning.  */
1504 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
1505 #  ifndef YYSTACK_ALLOC_MAXIMUM
1506     /* The OS might guarantee only one guard page at the bottom of the stack,
1507        and a page size can be as small as 4096 bytes.  So we cannot safely
1508        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
1509        to allow for a few compiler-allocated temporary stack slots.  */
1510 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1511 #  endif
1512 # else
1513 #  define YYSTACK_ALLOC YYMALLOC
1514 #  define YYSTACK_FREE YYFREE
1515 #  ifndef YYSTACK_ALLOC_MAXIMUM
1516 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1517 #  endif
1518 #  if (defined __cplusplus && ! defined _STDLIB_H \
1519        && ! ((defined YYMALLOC || defined malloc) \
1520              && (defined YYFREE || defined free)))
1521 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1522 #   ifndef _STDLIB_H
1523 #    define _STDLIB_H 1
1524 #   endif
1525 #  endif
1526 #  ifndef YYMALLOC
1527 #   define YYMALLOC malloc
1528 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1529      || defined __cplusplus || defined _MSC_VER)
1530 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1531 #   endif
1532 #  endif
1533 #  ifndef YYFREE
1534 #   define YYFREE free
1535 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1536      || defined __cplusplus || defined _MSC_VER)
1537 void free (void *); /* INFRINGES ON USER NAME SPACE */
1538 #   endif
1539 #  endif
1540 # endif
1541 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1542
1543
1544 #if (! defined yyoverflow \
1545      && (! defined __cplusplus \
1546          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1547
1548 /* A type that is properly aligned for any stack member.  */
1549 union yyalloc
1550 {
1551   yytype_int16 yyss;
1552   YYSTYPE yyvs;
1553   };
1554
1555 /* The size of the maximum gap between one aligned stack and the next.  */
1556 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1557
1558 /* The size of an array large to enough to hold all stacks, each with
1559    N elements.  */
1560 # define YYSTACK_BYTES(N) \
1561      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1562       + YYSTACK_GAP_MAXIMUM)
1563
1564 /* Copy COUNT objects from FROM to TO.  The source and destination do
1565    not overlap.  */
1566 # ifndef YYCOPY
1567 #  if defined __GNUC__ && 1 < __GNUC__
1568 #   define YYCOPY(To, From, Count) \
1569       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1570 #  else
1571 #   define YYCOPY(To, From, Count)              \
1572       do                                        \
1573         {                                       \
1574           YYSIZE_T yyi;                         \
1575           for (yyi = 0; yyi < (Count); yyi++)   \
1576             (To)[yyi] = (From)[yyi];            \
1577         }                                       \
1578       while (YYID (0))
1579 #  endif
1580 # endif
1581
1582 /* Relocate STACK from its old location to the new one.  The
1583    local variables YYSIZE and YYSTACKSIZE give the old and new number of
1584    elements in the stack, and YYPTR gives the new location of the
1585    stack.  Advance YYPTR to a properly aligned location for the next
1586    stack.  */
1587 # define YYSTACK_RELOCATE(Stack)                                        \
1588     do                                                                  \
1589       {                                                                 \
1590         YYSIZE_T yynewbytes;                                            \
1591         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
1592         Stack = &yyptr->Stack;                                          \
1593         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1594         yyptr += yynewbytes / sizeof (*yyptr);                          \
1595       }                                                                 \
1596     while (YYID (0))
1597
1598 #endif
1599
1600 /* YYFINAL -- State number of the termination state.  */
1601 #define YYFINAL  43
1602 /* YYLAST -- Last index in YYTABLE.  */
1603 #define YYLAST   1816
1604
1605 /* YYNTOKENS -- Number of terminals.  */
1606 #define YYNTOKENS  162
1607 /* YYNNTS -- Number of nonterminals.  */
1608 #define YYNNTS  82
1609 /* YYNRULES -- Number of rules.  */
1610 #define YYNRULES  314
1611 /* YYNRULES -- Number of states.  */
1612 #define YYNSTATES  608
1613
1614 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
1615 #define YYUNDEFTOK  2
1616 #define YYMAXUTOK   402
1617
1618 #define YYTRANSLATE(YYX)                                                \
1619   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1620
1621 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
1622 static const yytype_uint8 yytranslate[] =
1623 {
1624        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1625        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1626        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1627        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1628      152,   153,   150,     2,   149,     2,     2,     2,     2,     2,
1629        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1630      157,   148,   158,     2,     2,     2,     2,     2,     2,     2,
1631        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1632        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1633        2,   154,   151,   156,     2,     2,     2,     2,     2,   161,
1634        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1635        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1636      155,     2,     2,   159,     2,   160,     2,     2,     2,     2,
1637        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1638        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1639        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1640        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1641        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1642        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1643        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1644        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1645        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1646        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1647        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1648        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1649        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
1650        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
1651       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
1652       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
1653       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
1654       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
1655       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
1656       65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
1657       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
1658       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
1659       95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
1660      105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
1661      115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
1662      125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
1663      135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
1664      145,   146,   147
1665 };
1666
1667 #if YYDEBUG
1668 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1669    YYRHS.  */
1670 static const yytype_uint16 yyprhs[] =
1671 {
1672        0,     0,     3,     5,     7,     9,    11,    13,    15,    17,
1673       19,    21,    23,    25,    27,    29,    31,    33,    35,    37,
1674       39,    41,    43,    45,    47,    49,    51,    53,    55,    57,
1675       59,    61,    63,    65,    67,    69,    71,    73,    75,    77,
1676       79,    81,    83,    85,    87,    89,    91,    93,    95,    97,
1677       99,   101,   103,   105,   107,   109,   111,   113,   115,   117,
1678      119,   121,   123,   125,   127,   129,   130,   133,   134,   136,
1679      138,   140,   141,   144,   146,   148,   150,   152,   154,   156,
1680      158,   160,   161,   163,   165,   167,   168,   170,   172,   173,
1681      175,   177,   179,   181,   182,   184,   186,   187,   189,   191,
1682      193,   195,   197,   200,   202,   204,   206,   208,   210,   212,
1683      214,   216,   218,   219,   222,   224,   226,   228,   230,   232,
1684      234,   235,   238,   239,   242,   243,   247,   250,   251,   253,
1685      254,   258,   260,   263,   265,   267,   269,   271,   273,   275,
1686      277,   279,   281,   284,   286,   289,   295,   301,   307,   313,
1687      317,   320,   326,   331,   334,   336,   338,   340,   344,   346,
1688      350,   352,   353,   355,   359,   364,   368,   372,   377,   382,
1689      386,   393,   399,   402,   405,   408,   411,   414,   417,   420,
1690      423,   426,   429,   432,   435,   442,   448,   457,   464,   471,
1691      479,   487,   494,   503,   512,   516,   518,   520,   522,   524,
1692      525,   528,   535,   537,   538,   540,   543,   544,   548,   549,
1693      553,   557,   561,   565,   566,   574,   575,   584,   585,   594,
1694      600,   603,   607,   609,   613,   617,   621,   625,   627,   628,
1695      634,   638,   640,   644,   646,   647,   657,   659,   661,   666,
1696      668,   670,   673,   677,   678,   680,   682,   684,   686,   688,
1697      690,   692,   694,   696,   700,   702,   708,   710,   712,   714,
1698      716,   718,   720,   723,   726,   729,   733,   736,   737,   739,
1699      742,   745,   749,   759,   769,   778,   793,   795,   797,   804,
1700      810,   813,   820,   828,   833,   838,   845,   852,   853,   854,
1701      858,   861,   863,   869,   875,   882,   889,   894,   901,   906,
1702      911,   918,   925,   928,   937,   939,   941,   942,   946,   953,
1703      957,   964,   967,   973,   981
1704 };
1705
1706 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
1707 static const yytype_int16 yyrhs[] =
1708 {
1709      206,     0,    -1,    73,    -1,    74,    -1,    75,    -1,    76,
1710       -1,    77,    -1,    78,    -1,    79,    -1,    80,    -1,    81,
1711       -1,    85,    -1,    86,    -1,    87,    -1,    82,    -1,    83,
1712       -1,    84,    -1,   116,    -1,   117,    -1,   118,    -1,   119,
1713       -1,   120,    -1,   121,    -1,   122,    -1,   123,    -1,   124,
1714       -1,   125,    -1,   126,    -1,   127,    -1,    90,    -1,    91,
1715       -1,    92,    -1,    93,    -1,    94,    -1,    95,    -1,    96,
1716       -1,    97,    -1,    98,    -1,    99,    -1,   100,    -1,   101,
1717       -1,   102,    -1,   103,    -1,   104,    -1,   105,    -1,   106,
1718       -1,   107,    -1,   108,    -1,   109,    -1,    96,    -1,    97,
1719       -1,    98,    -1,    99,    -1,    26,    -1,    27,    -1,    11,
1720       -1,    12,    -1,    13,    -1,    16,    -1,    15,    -1,    14,
1721       -1,    19,    -1,    22,    -1,    24,    -1,   170,    -1,    -1,
1722      170,   148,    -1,    -1,    20,    -1,    23,    -1,   175,    -1,
1723       -1,   173,   148,    -1,    42,    -1,    44,    -1,    43,    -1,
1724       45,    -1,    47,    -1,    46,    -1,    48,    -1,    50,    -1,
1725       -1,   145,    -1,   146,    -1,   147,    -1,    -1,    46,    -1,
1726       48,    -1,    -1,    42,    -1,    43,    -1,    44,    -1,    47,
1727       -1,    -1,    44,    -1,    42,    -1,    -1,    61,    -1,    62,
1728       -1,    63,    -1,    64,    -1,    65,    -1,    60,     4,    -1,
1729      135,    -1,   117,    -1,   134,    -1,   118,    -1,   137,    -1,
1730      138,    -1,   140,    -1,   141,    -1,   142,    -1,    -1,   184,
1731      183,    -1,   136,    -1,   139,    -1,   135,    -1,   134,    -1,
1732      143,    -1,   144,    -1,    -1,   186,   185,    -1,    -1,    53,
1733        4,    -1,    -1,   149,    53,     4,    -1,    34,    22,    -1,
1734       -1,   189,    -1,    -1,   149,   192,   191,    -1,   189,    -1,
1735       53,     4,    -1,    11,    -1,    12,    -1,    13,    -1,    16,
1736       -1,    15,    -1,    14,    -1,    17,    -1,    49,    -1,   193,
1737       -1,   194,   150,    -1,   228,    -1,   151,     4,    -1,   194,
1738      152,   198,   153,   186,    -1,    10,   152,   198,   153,   186,
1739       -1,   154,     4,   155,   194,   156,    -1,   157,     4,   155,
1740      194,   158,    -1,   159,   199,   160,    -1,   159,   160,    -1,
1741      157,   159,   199,   160,   158,    -1,   157,   159,   160,   158,
1742       -1,   194,   184,    -1,   194,    -1,    10,    -1,   195,    -1,
1743      197,   149,   195,    -1,   197,    -1,   197,   149,    39,    -1,
1744       39,    -1,    -1,   194,    -1,   199,   149,   194,    -1,   194,
1745      154,   202,   156,    -1,   194,   154,   156,    -1,   194,   161,
1746       22,    -1,   194,   157,   202,   158,    -1,   194,   159,   202,
1747      160,    -1,   194,   159,   160,    -1,   194,   157,   159,   202,
1748      160,   158,    -1,   194,   157,   159,   160,   158,    -1,   194,
1749       40,    -1,   194,    41,    -1,   194,   228,    -1,   194,   201,
1750       -1,   194,    25,    -1,   168,     3,    -1,   168,     5,    -1,
1751      168,     4,    -1,   168,     6,    -1,    11,    26,    -1,    11,
1752       27,    -1,   169,     9,    -1,   165,   152,   200,    38,   194,
1753      153,    -1,   115,   152,   200,   239,   153,    -1,   129,   152,
1754      200,   149,   200,   149,   200,   153,    -1,   163,   152,   200,
1755      149,   200,   153,    -1,   164,   152,   200,   149,   200,   153,
1756       -1,    88,   166,   152,   200,   149,   200,   153,    -1,    89,
1757      167,   152,   200,   149,   200,   153,    -1,   131,   152,   200,
1758      149,   200,   153,    -1,   132,   152,   200,   149,   200,   149,
1759      200,   153,    -1,   133,   152,   200,   149,   200,   149,   200,
1760      153,    -1,   202,   149,   200,    -1,   200,    -1,    32,    -1,
1761       33,    -1,    37,    -1,    -1,   196,   228,    -1,   121,   152,
1762      205,    38,   194,   153,    -1,   207,    -1,    -1,   208,    -1,
1763      207,   208,    -1,    -1,    31,   209,   224,    -1,    -1,    30,
1764      210,   225,    -1,    58,    57,   214,    -1,   172,    18,   194,
1765       -1,   172,    18,    10,    -1,    -1,   174,   178,   204,   203,
1766      200,   211,   191,    -1,    -1,   174,   176,   178,   204,   203,
1767      200,   212,   191,    -1,    -1,   174,   177,   178,   204,   203,
1768      194,   213,   191,    -1,   174,   178,    35,   181,   205,    -1,
1769       51,   215,    -1,    54,   148,   216,    -1,    22,    -1,    52,
1770      148,    22,    -1,    66,   148,    22,    -1,   154,   217,   156,
1771       -1,   217,   149,    22,    -1,    22,    -1,    -1,   218,   149,
1772      194,   184,   171,    -1,   194,   184,   171,    -1,   218,    -1,
1773      218,   149,    39,    -1,    39,    -1,    -1,   182,   196,   173,
1774      152,   219,   153,   186,   190,   187,    -1,    28,    -1,   159,
1775       -1,   180,   178,   220,   221,    -1,    29,    -1,   160,    -1,
1776      231,   223,    -1,   179,   178,   220,    -1,    -1,    59,    -1,
1777        3,    -1,     4,    -1,     9,    -1,    26,    -1,    27,    -1,
1778       40,    -1,    41,    -1,    25,    -1,   157,   202,   158,    -1,
1779      201,    -1,    57,   226,    22,   149,    22,    -1,     7,    -1,
1780        8,    -1,   170,    -1,   173,    -1,   228,    -1,   227,    -1,
1781      194,   229,    -1,   231,   232,    -1,   222,   232,    -1,   233,
1782      172,   234,    -1,   233,   236,    -1,    -1,    21,    -1,    67,
1783      230,    -1,    67,    10,    -1,    68,    17,   229,    -1,    68,
1784       11,   229,   149,    17,   229,   149,    17,   229,    -1,    69,
1785      168,   229,   149,    17,   229,   154,   235,   156,    -1,    69,
1786      168,   229,   149,    17,   229,   154,   156,    -1,    70,   182,
1787      196,   229,   152,   238,   153,   186,    38,    17,   229,    71,
1788       17,   229,    -1,    71,    -1,    72,    -1,   235,   168,   227,
1789      149,    17,   229,    -1,   168,   227,   149,    17,   229,    -1,
1790      172,   241,    -1,   194,   154,   229,   149,   229,   156,    -1,
1791      237,   149,   154,   229,   149,   229,   156,    -1,   194,   184,
1792      229,   184,    -1,    17,   184,   229,   184,    -1,   238,   149,
1793      194,   184,   229,   184,    -1,   238,   149,    17,   184,   229,
1794      184,    -1,    -1,    -1,   239,   149,   230,    -1,    56,    55,
1795       -1,    55,    -1,   163,   194,   229,   149,   229,    -1,   164,
1796      194,   229,   149,   229,    -1,    88,   166,   194,   229,   149,
1797      229,    -1,    89,   167,   194,   229,   149,   229,    -1,   165,
1798      230,    38,   194,    -1,   129,   230,   149,   230,   149,   230,
1799       -1,   130,   230,   149,   194,    -1,   131,   230,   149,   230,
1800       -1,   132,   230,   149,   230,   149,   230,    -1,   133,   230,
1801      149,   230,   149,   230,    -1,   128,   237,    -1,   240,   182,
1802      196,   229,   152,   238,   153,   186,    -1,   243,    -1,    36,
1803       -1,    -1,   110,   194,   188,    -1,   110,   194,   149,    11,
1804      229,   188,    -1,   111,   194,   188,    -1,   111,   194,   149,
1805       11,   229,   188,    -1,   112,   230,    -1,   242,   113,   194,
1806      229,   188,    -1,   242,   114,   230,   149,   194,   229,   188,
1807       -1,   115,   194,   229,   239,    -1
1808 };
1809
1810 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
1811 static const yytype_uint16 yyrline[] =
1812 {
1813        0,  1105,  1105,  1105,  1105,  1105,  1105,  1105,  1105,  1105,
1814     1105,  1106,  1106,  1106,  1106,  1106,  1106,  1107,  1107,  1107,
1815     1107,  1107,  1107,  1108,  1108,  1108,  1108,  1108,  1108,  1111,
1816     1111,  1112,  1112,  1113,  1113,  1114,  1114,  1115,  1115,  1119,
1817     1119,  1120,  1120,  1121,  1121,  1122,  1122,  1123,  1123,  1124,
1818     1124,  1125,  1125,  1126,  1127,  1132,  1133,  1133,  1133,  1133,
1819     1133,  1135,  1135,  1135,  1136,  1136,  1140,  1144,  1149,  1149,
1820     1151,  1152,  1157,  1163,  1164,  1165,  1166,  1167,  1171,  1172,
1821     1173,  1177,  1178,  1179,  1180,  1184,  1185,  1186,  1190,  1191,
1822     1192,  1193,  1194,  1198,  1199,  1200,  1203,  1204,  1205,  1206,
1823     1207,  1208,  1209,  1216,  1217,  1218,  1219,  1220,  1221,  1222,
1824     1223,  1224,  1227,  1228,  1233,  1234,  1235,  1236,  1237,  1238,
1825     1241,  1242,  1249,  1250,  1256,  1257,  1265,  1273,  1274,  1279,
1826     1280,  1281,  1286,  1299,  1299,  1299,  1299,  1299,  1299,  1299,
1827     1302,  1306,  1310,  1317,  1322,  1330,  1360,  1385,  1390,  1400,
1828     1410,  1414,  1424,  1431,  1440,  1447,  1452,  1457,  1464,  1465,
1829     1472,  1479,  1487,  1493,  1505,  1533,  1549,  1576,  1604,  1630,
1830     1650,  1676,  1696,  1708,  1715,  1781,  1791,  1801,  1807,  1817,
1831     1823,  1833,  1838,  1843,  1856,  1868,  1890,  1898,  1904,  1915,
1832     1920,  1925,  1931,  1937,  1946,  1950,  1958,  1958,  1961,  1961,
1833     1964,  1976,  1997,  2002,  2010,  2011,  2015,  2015,  2019,  2019,
1834     2022,  2025,  2049,  2060,  2060,  2071,  2070,  2080,  2079,  2090,
1835     2130,  2133,  2139,  2149,  2153,  2158,  2160,  2165,  2170,  2179,
1836     2189,  2200,  2204,  2213,  2222,  2227,  2357,  2357,  2359,  2368,
1837     2368,  2370,  2375,  2387,  2391,  2396,  2400,  2404,  2408,  2412,
1838     2416,  2420,  2424,  2428,  2453,  2457,  2467,  2471,  2475,  2480,
1839     2487,  2487,  2493,  2502,  2506,  2515,  2524,  2533,  2537,  2544,
1840     2548,  2552,  2557,  2567,  2586,  2595,  2679,  2683,  2690,  2701,
1841     2714,  2724,  2735,  2745,  2756,  2764,  2774,  2781,  2784,  2785,
1842     2792,  2796,  2801,  2817,  2834,  2848,  2862,  2874,  2882,  2889,
1843     2895,  2901,  2907,  2922,  3013,  3018,  3022,  3029,  3036,  3044,
1844     3051,  3059,  3067,  3081,  3098
1845 };
1846 #endif
1847
1848 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1849 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1850    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
1851 static const char *const yytname[] =
1852 {
1853   "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "ESAPINTVAL",
1854   "EUAPINTVAL", "LOCALVAL_ID", "GLOBALVAL_ID", "FPVAL", "VOID", "INTTYPE",
1855   "FLOAT", "DOUBLE", "X86_FP80", "FP128", "PPC_FP128", "LABEL", "TYPE",
1856   "LOCALVAR", "GLOBALVAR", "LABELSTR", "STRINGCONSTANT",
1857   "ATSTRINGCONSTANT", "PCTSTRINGCONSTANT", "ZEROINITIALIZER", "TRUETOK",
1858   "FALSETOK", "BEGINTOK", "ENDTOK", "DECLARE", "DEFINE", "GLOBAL",
1859   "CONSTANT", "SECTION", "ALIAS", "VOLATILE", "THREAD_LOCAL", "TO",
1860   "DOTDOTDOT", "NULL_TOK", "UNDEF", "INTERNAL", "LINKONCE", "WEAK",
1861   "APPENDING", "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "OPAQUE",
1862   "EXTERNAL", "TARGET", "TRIPLE", "ALIGN", "DEPLIBS", "CALL", "TAIL",
1863   "ASM_TOK", "MODULE", "SIDEEFFECT", "CC_TOK", "CCC_TOK", "FASTCC_TOK",
1864   "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT",
1865   "RET", "BR", "SWITCH", "INVOKE", "UNWIND", "UNREACHABLE", "ADD", "SUB",
1866   "MUL", "UDIV", "SDIV", "FDIV", "UREM", "SREM", "FREM", "AND", "OR",
1867   "XOR", "SHL", "LSHR", "ASHR", "ICMP", "FCMP", "EQ", "NE", "SLT", "SGT",
1868   "SLE", "SGE", "ULT", "UGT", "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT",
1869   "OLE", "OGE", "ORD", "UNO", "UEQ", "UNE", "MALLOC", "ALLOCA", "FREE",
1870   "LOAD", "STORE", "GETELEMENTPTR", "TRUNC", "ZEXT", "SEXT", "FPTRUNC",
1871   "FPEXT", "BITCAST", "UITOFP", "SITOFP", "FPTOUI", "FPTOSI", "INTTOPTR",
1872   "PTRTOINT", "PHI_TOK", "SELECT", "VAARG", "EXTRACTELEMENT",
1873   "INSERTELEMENT", "SHUFFLEVECTOR", "SIGNEXT", "ZEROEXT", "NORETURN",
1874   "INREG", "SRET", "NOUNWIND", "NOALIAS", "BYVAL", "NEST", "READNONE",
1875   "READONLY", "DEFAULT", "HIDDEN", "PROTECTED", "'='", "','", "'*'",
1876   "'\\\\'", "'('", "')'", "'['", "'x'", "']'", "'<'", "'>'", "'{'", "'}'",
1877   "'c'", "$accept", "ArithmeticOps", "LogicalOps", "CastOps",
1878   "IPredicates", "FPredicates", "IntType", "FPType", "LocalName",
1879   "OptLocalName", "OptLocalAssign", "GlobalName", "OptGlobalAssign",
1880   "GlobalAssign", "GVInternalLinkage", "GVExternalLinkage",
1881   "GVVisibilityStyle", "FunctionDeclareLinkage", "FunctionDefineLinkage",
1882   "AliasLinkage", "OptCallingConv", "ParamAttr", "OptParamAttrs",
1883   "FuncAttr", "OptFuncAttrs", "OptAlign", "OptCAlign", "SectionString",
1884   "OptSection", "GlobalVarAttributes", "GlobalVarAttribute", "PrimType",
1885   "Types", "ArgType", "ResultTypes", "ArgTypeList", "ArgTypeListI",
1886   "TypeListI", "ConstVal", "ConstExpr", "ConstVector", "GlobalType",
1887   "ThreadLocal", "AliaseeRef", "Module", "DefinitionList", "Definition",
1888   "@1", "@2", "@3", "@4", "@5", "AsmBlock", "TargetDefinition",
1889   "LibrariesDefinition", "LibList", "ArgListH", "ArgList",
1890   "FunctionHeaderH", "BEGIN", "FunctionHeader", "END", "Function",
1891   "FunctionProto", "OptSideEffect", "ConstValueRef", "SymbolicValueRef",
1892   "ValueRef", "ResolvedVal", "BasicBlockList", "BasicBlock",
1893   "InstructionList", "BBTerminatorInst", "JumpTable", "Inst", "PHIList",
1894   "ParamList", "IndexList", "OptTailCall", "InstVal", "OptVolatile",
1895   "MemoryInst", 0
1896 };
1897 #endif
1898
1899 # ifdef YYPRINT
1900 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1901    token YYLEX-NUM.  */
1902 static const yytype_uint16 yytoknum[] =
1903 {
1904        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
1905      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
1906      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
1907      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
1908      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
1909      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
1910      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
1911      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
1912      335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
1913      345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
1914      355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
1915      365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
1916      375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
1917      385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
1918      395,   396,   397,   398,   399,   400,   401,   402,    61,    44,
1919       42,    92,    40,    41,    91,   120,    93,    60,    62,   123,
1920      125,    99
1921 };
1922 # endif
1923
1924 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
1925 static const yytype_uint8 yyr1[] =
1926 {
1927        0,   162,   163,   163,   163,   163,   163,   163,   163,   163,
1928      163,   164,   164,   164,   164,   164,   164,   165,   165,   165,
1929      165,   165,   165,   165,   165,   165,   165,   165,   165,   166,
1930      166,   166,   166,   166,   166,   166,   166,   166,   166,   167,
1931      167,   167,   167,   167,   167,   167,   167,   167,   167,   167,
1932      167,   167,   167,   167,   167,   168,   169,   169,   169,   169,
1933      169,   170,   170,   170,   171,   171,   172,   172,   173,   173,
1934      174,   174,   175,   176,   176,   176,   176,   176,   177,   177,
1935      177,   178,   178,   178,   178,   179,   179,   179,   180,   180,
1936      180,   180,   180,   181,   181,   181,   182,   182,   182,   182,
1937      182,   182,   182,   183,   183,   183,   183,   183,   183,   183,
1938      183,   183,   184,   184,   185,   185,   185,   185,   185,   185,
1939      186,   186,   187,   187,   188,   188,   189,   190,   190,   191,
1940      191,   192,   192,   193,   193,   193,   193,   193,   193,   193,
1941      194,   194,   194,   194,   194,   194,   194,   194,   194,   194,
1942      194,   194,   194,   195,   196,   196,   197,   197,   198,   198,
1943      198,   198,   199,   199,   200,   200,   200,   200,   200,   200,
1944      200,   200,   200,   200,   200,   200,   200,   200,   200,   200,
1945      200,   200,   200,   200,   201,   201,   201,   201,   201,   201,
1946      201,   201,   201,   201,   202,   202,   203,   203,   204,   204,
1947      205,   205,   206,   206,   207,   207,   209,   208,   210,   208,
1948      208,   208,   208,   211,   208,   212,   208,   213,   208,   208,
1949      208,   208,   214,   215,   215,   216,   217,   217,   217,   218,
1950      218,   219,   219,   219,   219,   220,   221,   221,   222,   223,
1951      223,   224,   225,   226,   226,   227,   227,   227,   227,   227,
1952      227,   227,   227,   227,   227,   227,   228,   228,   228,   228,
1953      229,   229,   230,   231,   231,   232,   233,   233,   233,   234,
1954      234,   234,   234,   234,   234,   234,   234,   234,   235,   235,
1955      236,   237,   237,   238,   238,   238,   238,   238,   239,   239,
1956      240,   240,   241,   241,   241,   241,   241,   241,   241,   241,
1957      241,   241,   241,   241,   241,   242,   242,   243,   243,   243,
1958      243,   243,   243,   243,   243
1959 };
1960
1961 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
1962 static const yytype_uint8 yyr2[] =
1963 {
1964        0,     2,     1,     1,     1,     1,     1,     1,     1,     1,
1965        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1966        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1967        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1968        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1969        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1970        1,     1,     1,     1,     1,     0,     2,     0,     1,     1,
1971        1,     0,     2,     1,     1,     1,     1,     1,     1,     1,
1972        1,     0,     1,     1,     1,     0,     1,     1,     0,     1,
1973        1,     1,     1,     0,     1,     1,     0,     1,     1,     1,
1974        1,     1,     2,     1,     1,     1,     1,     1,     1,     1,
1975        1,     1,     0,     2,     1,     1,     1,     1,     1,     1,
1976        0,     2,     0,     2,     0,     3,     2,     0,     1,     0,
1977        3,     1,     2,     1,     1,     1,     1,     1,     1,     1,
1978        1,     1,     2,     1,     2,     5,     5,     5,     5,     3,
1979        2,     5,     4,     2,     1,     1,     1,     3,     1,     3,
1980        1,     0,     1,     3,     4,     3,     3,     4,     4,     3,
1981        6,     5,     2,     2,     2,     2,     2,     2,     2,     2,
1982        2,     2,     2,     2,     6,     5,     8,     6,     6,     7,
1983        7,     6,     8,     8,     3,     1,     1,     1,     1,     0,
1984        2,     6,     1,     0,     1,     2,     0,     3,     0,     3,
1985        3,     3,     3,     0,     7,     0,     8,     0,     8,     5,
1986        2,     3,     1,     3,     3,     3,     3,     1,     0,     5,
1987        3,     1,     3,     1,     0,     9,     1,     1,     4,     1,
1988        1,     2,     3,     0,     1,     1,     1,     1,     1,     1,
1989        1,     1,     1,     3,     1,     5,     1,     1,     1,     1,
1990        1,     1,     2,     2,     2,     3,     2,     0,     1,     2,
1991        2,     3,     9,     9,     8,    14,     1,     1,     6,     5,
1992        2,     6,     7,     4,     4,     6,     6,     0,     0,     3,
1993        2,     1,     5,     5,     6,     6,     4,     6,     4,     4,
1994        6,     6,     2,     8,     1,     1,     0,     3,     6,     3,
1995        6,     2,     5,     7,     4
1996 };
1997
1998 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
1999    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
2000    means the default is an error.  */
2001 static const yytype_uint16 yydefact[] =
2002 {
2003       71,    61,    68,    62,    69,    63,   208,   206,     0,     0,
2004        0,     0,     0,     0,    81,    70,     0,    71,   204,    85,
2005       88,     0,     0,   220,     0,     0,    66,     0,    72,    73,
2006       75,    74,    76,    78,    77,    79,    80,    82,    83,    84,
2007       81,    81,   199,     1,   205,    86,    87,    81,   209,    89,
2008       90,    91,    92,    81,   267,   207,   267,     0,     0,   228,
2009      221,   222,   210,   256,   257,   212,   133,   134,   135,   138,
2010      137,   136,   139,   140,     0,     0,     0,     0,   258,   259,
2011      141,   211,   143,   199,   199,    93,   198,     0,    96,    96,
2012      268,   264,    67,   239,   240,   241,   263,   223,   224,   227,
2013        0,   161,   144,     0,     0,     0,     0,   150,   162,     0,
2014      142,   161,     0,     0,    95,    94,     0,   196,   197,     0,
2015        0,    97,    98,    99,   100,   101,     0,   242,     0,   306,
2016      266,     0,   225,   160,   112,   156,   158,     0,     0,     0,
2017        0,     0,     0,   149,     0,     0,     0,   155,     0,   154,
2018        0,   219,   133,   134,   135,   138,   137,   136,     0,     0,
2019        0,   213,   102,     0,   236,   237,   238,   305,   291,     0,
2020        0,     0,     0,    96,   276,   277,     2,     3,     4,     5,
2021        6,     7,     8,     9,    10,    14,    15,    16,    11,    12,
2022       13,     0,     0,     0,     0,     0,     0,    17,    18,    19,
2023       20,    21,    22,    23,    24,    25,    26,    27,    28,     0,
2024        0,     0,     0,     0,     0,     0,     0,     0,   265,    96,
2025      280,     0,   304,   226,   153,     0,   120,     0,     0,   152,
2026        0,   163,   120,   215,   217,     0,   200,   181,   182,   177,
2027      179,   178,   180,   183,   176,   172,   173,     0,     0,     0,
2028        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2029        0,   175,   174,   129,     0,   290,   270,     0,   269,     0,
2030        0,    55,     0,     0,    29,    30,    31,    32,    33,    34,
2031       35,    36,    37,    38,     0,    53,    54,    49,    50,    51,
2032       52,    39,    40,    41,    42,    43,    44,    45,    46,    47,
2033       48,     0,   124,   124,   311,     0,     0,   302,     0,     0,
2034        0,     0,     0,     0,     0,     0,     0,     0,     0,   104,
2035      106,   105,   103,   107,   108,   109,   110,   111,   113,   159,
2036      157,   146,   147,   148,   151,   145,   129,   129,     0,     0,
2037        0,     0,     0,     0,     0,     0,   165,   195,     0,     0,
2038        0,   169,     0,   166,     0,     0,     0,     0,   214,   234,
2039      245,   246,   247,   252,   248,   249,   250,   251,   243,     0,
2040      254,   261,   260,   262,     0,   271,     0,     0,     0,     0,
2041        0,   307,     0,   309,   288,     0,     0,     0,     0,     0,
2042        0,     0,     0,     0,     0,     0,     0,     0,   117,   116,
2043      114,   115,   118,   119,   121,   216,   218,     0,     0,     0,
2044      288,     0,     0,     0,     0,     0,   164,   150,   162,     0,
2045      167,   168,     0,     0,     0,     0,     0,   131,   129,   233,
2046      112,   231,     0,   244,     0,     0,     0,     0,     0,     0,
2047        0,     0,     0,     0,   314,     0,     0,     0,   298,   299,
2048        0,     0,     0,     0,   296,     0,   124,     0,     0,     0,
2049        0,     0,     0,     0,     0,     0,   194,   171,     0,     0,
2050        0,     0,   126,   132,   130,    65,     0,   120,     0,   253,
2051        0,     0,   287,     0,     0,   124,   125,   124,     0,     0,
2052        0,     0,     0,     0,   292,   293,   287,     0,   312,     0,
2053      201,     0,     0,   185,     0,     0,     0,     0,   170,     0,
2054        0,     0,    64,   230,   232,   112,   127,     0,     0,     0,
2055      112,   112,     0,   294,   295,   308,   310,   289,     0,     0,
2056      297,   300,   301,     0,   124,     0,     0,     0,   191,     0,
2057        0,   187,   188,   184,    65,   128,   122,   255,     0,     0,
2058        0,     0,     0,   120,   281,     0,   120,   313,   189,   190,
2059        0,     0,     0,   229,     0,   235,     0,   274,     0,     0,
2060      104,   106,   112,   112,   112,   112,     0,   282,   303,   186,
2061      192,   193,   123,   272,     0,   273,     0,   284,   283,     0,
2062        0,     0,     0,     0,   112,   112,     0,     0,     0,   286,
2063      285,     0,   279,     0,     0,   278,     0,   275
2064 };
2065
2066 /* YYDEFGOTO[NTERM-NUM].  */
2067 static const yytype_int16 yydefgoto[] =
2068 {
2069       -1,   258,   259,   260,   284,   301,   158,   159,    78,   513,
2070       12,    79,    14,    15,    40,    41,    42,    47,    53,   116,
2071      126,   328,   224,   404,   331,   565,   381,   427,   546,   358,
2072      428,    80,   160,   135,   150,   136,   137,   109,   347,   370,
2073      348,   119,    87,   151,    16,    17,    18,    20,    19,   263,
2074      336,   337,    62,    23,    60,   100,   431,   432,   127,   166,
2075       54,    95,    55,    48,   434,   371,    82,   373,   268,    56,
2076       91,    92,   218,   569,   130,   307,   522,   444,   219,   220,
2077      221,   222
2078 };
2079
2080 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
2081    STATE-NUM.  */
2082 #define YYPACT_NINF -546
2083 static const yytype_int16 yypact[] =
2084 {
2085       47,  -546,  -546,  -546,  -546,  -546,  -546,  -546,   -17,   -95,
2086       52,   -90,    86,    14,   183,  -546,   135,  1758,  -546,   -10,
2087       64,    18,    33,  -546,     5,   180,  -546,  1341,  -546,  -546,
2088     -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,
2089       76,    76,    59,  -546,  -546,  -546,  -546,    76,  -546,  -546,
2090     -546,  -546,  -546,    76,   193,  -546,    13,   202,   224,   233,
2091     -546,  -546,  -546,  -546,  -546,   111,  -546,  -546,  -546,  -546,
2092     -546,  -546,  -546,  -546,   260,   261,     1,   378,  -546,  -546,
2093     -546,    -7,  -546,   231,   231,   150,  -546,    55,   309,   309,
2094     -546,  -546,   100,  -546,  -546,  -546,  -546,  -546,  -546,  -546,
2095      -99,  1088,  -546,   116,   122,   988,   111,  -546,    -7,  -106,
2096     -546,  1088,    55,    55,  -546,  -546,  1142,  -546,  -546,  1359,
2097      274,  -546,  -546,  -546,  -546,  -546,  1414,  -546,   -18,  1624,
2098     -546,   257,  -546,  -546,    -7,  -546,   131,   128,  1454,  1454,
2099      129,  -105,  1454,  -546,   136,  1359,  1454,   111,   141,    -7,
2100      237,  -546,   214,   279,   285,   289,   291,   294,   145,   299,
2101      803,  -546,  -546,   103,  -546,  -546,  -546,  -546,  -546,   254,
2102     1512,    57,   301,   309,  -546,  -546,  -546,  -546,  -546,  -546,
2103     -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,
2104     -546,   596,   646,  1454,  1454,  1454,  1454,  -546,  -546,  -546,
2105     -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,  1454,
2106     1454,  1454,  1454,  1454,  1454,  1454,  1454,  1454,  -546,   309,
2107     -546,    61,  -546,  -546,   132,  1182,  -546,   -57,   -69,  -546,
2108      155,    -7,  -546,  -546,    -7,  1142,  -546,  -546,  -546,  -546,
2109     -546,  -546,  -546,  -546,  -546,  -546,  -546,   596,   646,   162,
2110      163,   164,   166,   167,  1242,  1530,  1028,   303,   169,   174,
2111      179,  -546,  -546,   185,   191,  -546,   111,   644,  -546,   780,
2112      780,  -546,   780,  1414,  -546,  -546,  -546,  -546,  -546,  -546,
2113     -546,  -546,  -546,  -546,  1454,  -546,  -546,  -546,  -546,  -546,
2114     -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,
2115     -546,  1454,    30,    48,  -546,   644,   -21,   197,   199,   203,
2116      204,   205,   206,   644,   644,   313,  1414,  1454,  1454,  -546,
2117     -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,
2118     -546,   201,  -546,  -546,  -546,   201,   185,   185,   320,   207,
2119      208,  1359,  1359,  1359,  1359,  1359,  -546,  -546,   -65,  1068,
2120      -86,  -546,  -104,  -546,  1359,  1359,  1359,   -20,  -546,  1261,
2121     -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,   273,  1359,
2122     -546,  -546,  -546,  -546,   217,  -546,   218,   780,   644,   644,
2123        8,  -546,    11,  -546,  -546,   780,   221,  1454,  1454,  1454,
2124     1454,  1454,   227,   234,  1454,   780,   644,   235,  -546,  -546,
2125     -546,  -546,  -546,  -546,  -546,  -546,  -546,  1454,  1359,  1359,
2126     -546,   247,   258,   263,   265,  1359,  -546,   259,   803,  -101,
2127     -546,  -546,   269,   270,   344,   398,   419,  -546,   185,  -546,
2128       -7,   276,   275,  -546,   404,   -76,   412,   413,   282,   288,
2129      292,   780,   440,   780,   297,   300,   780,   302,    -7,  -546,
2130      304,   308,   780,   780,    -7,   306,   310,  1454,   -35,   311,
2131      314,   -73,  1359,  1359,  1359,  1359,  -546,  -546,   315,  1359,
2132     1359,  1454,  -546,  -546,  -546,   298,  1301,  -546,   319,  -546,
2133      780,   780,  1570,   780,   780,   310,  -546,   310,  1454,   780,
2134      322,  1454,  1454,  1454,  -546,  -546,  1570,   399,  -546,   644,
2135     -546,  1359,  1359,  -546,   323,   316,   325,   327,  -546,   324,
2136      326,    60,  -546,  -546,  -546,    -7,     3,   460,   334,   330,
2137       82,    -7,   -13,  -546,  -546,  -546,  -546,  -546,   332,   780,
2138     -546,  -546,  -546,    12,   310,   336,   337,  1359,  -546,  1359,
2139     1359,  -546,  -546,  -546,   298,  -546,   438,  -546,   475,    -4,
2140      493,   493,  1610,  -546,  -546,   338,  -546,  -546,  -546,  -546,
2141      342,   345,   346,  -546,   501,  -546,   780,  -546,   940,     2,
2142      354,   355,  -546,  -546,    82,    -7,    72,  -546,   201,  -546,
2143     -546,  -546,  -546,  -546,   359,  -546,   940,   132,   132,   493,
2144      493,   492,   494,   361,  -546,  -546,   780,   780,   497,   132,
2145      132,   450,  -546,   780,   505,  -546,   780,  -546
2146 };
2147
2148 /* YYPGOTO[NTERM-NUM].  */
2149 static const yytype_int16 yypgoto[] =
2150 {
2151     -546,   394,   395,   396,   280,   283,  -170,  -546,     0,   -16,
2152      444,    15,  -546,  -546,  -546,  -546,    -1,  -546,  -546,  -546,
2153     -157,  -546,  -418,  -546,  -229,  -546,  -292,    23,  -546,  -307,
2154     -546,  -546,   -26,   305,  -120,  -546,   429,   436,   -59,  -156,
2155     -235,   126,   168,   307,  -546,  -546,   526,  -546,  -546,  -546,
2156     -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,   456,  -546,
2157     -546,  -546,  -546,  -546,  -546,  -545,  -142,   108,  -186,  -546,
2158      490,  -546,  -546,  -546,  -546,  -546,    51,   138,  -546,  -546,
2159     -546,  -546
2160 };
2161
2162 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
2163    positive, shift that token.  If negative, reduce the rule which
2164    number is the opposite.  If zero, do what YYDEFACT says.
2165    If YYTABLE_NINF, syntax error.  */
2166 #define YYTABLE_NINF -204
2167 static const yytype_int16 yytable[] =
2168 {
2169       11,    81,   272,   335,   261,   104,   163,   271,   236,   304,
2170      164,   383,   475,   271,   425,    13,   273,    11,   262,   441,
2171      350,   352,   443,   584,   308,   309,   310,   311,   312,   405,
2172      406,   315,    13,   426,    90,    21,    45,   425,    46,    83,
2173       84,   593,    93,   142,   142,   415,    88,  -203,   415,    22,
2174      131,   108,    89,    24,   143,   230,   421,   132,    26,   468,
2175      161,   442,   316,   415,   442,   -67,     1,     2,   269,     3,
2176        4,     5,   420,   415,   270,   134,   488,     6,     7,   108,
2177      503,   110,   479,   111,   415,   134,   233,   117,   118,   333,
2178      149,   416,    11,   110,    85,   111,    86,   544,     8,   332,
2179      149,     9,   550,   551,    27,    10,    49,    50,    51,    25,
2180      591,    52,   227,   228,   419,   110,   231,   111,   500,     1,
2181      234,   474,     3,     2,     5,   372,     4,   372,   372,   110,
2182      372,   111,   397,   385,   435,    43,   552,   398,   399,   400,
2183      553,   165,   401,   110,   267,   111,   402,   403,   239,   240,
2184      241,   242,   567,   377,   587,   588,   589,   590,   585,    59,
2185      105,   552,    28,   372,   498,   556,    57,   302,   303,   267,
2186      305,   372,   372,    94,   317,   318,   599,   600,   264,   380,
2187      110,    58,   111,   306,   267,   267,   267,   267,   267,   313,
2188      314,   267,   114,   525,   115,   526,   395,   382,   110,   134,
2189      111,   447,    61,   449,   450,   451,   398,   399,   400,   149,
2190      110,   401,   111,   543,    90,   402,   403,   -55,   -55,   -55,
2191      -55,    37,    38,    39,    97,    29,    30,    31,    32,    33,
2192       34,    35,  -139,    36,  -139,   372,   372,   372,   145,   146,
2193      237,   238,   557,   372,    63,    64,    98,   149,   516,   319,
2194      320,   112,   113,   372,   372,    99,     1,     2,   378,     3,
2195        4,     5,   261,   101,   102,   103,   321,   322,    86,   323,
2196      324,   138,   325,   326,   327,   379,   262,   139,   162,   223,
2197      225,   226,   410,   411,   412,   413,   414,   229,   -56,   232,
2198      149,   396,   267,   235,   -57,   422,   423,   424,   -60,   372,
2199      -59,   372,   527,   -58,   372,   530,   531,   532,   243,   265,
2200      372,   372,   271,   334,   341,   342,   343,     1,   344,   345,
2201        3,   354,     5,   418,   576,   353,   355,   578,    37,    38,
2202       39,   356,   433,   430,   357,   398,   399,   400,   372,   372,
2203      401,   372,   372,   359,   402,   403,   386,   372,   387,   459,
2204      460,   394,   388,   389,   390,   391,   466,   372,   407,   408,
2205      409,   267,   448,   267,   267,   267,   436,   437,   454,   120,
2206      121,   122,   123,   124,   125,   446,   452,   374,   375,   568,
2207      376,   458,   471,   453,   457,    63,    64,   372,   106,    66,
2208       67,    68,    69,    70,    71,    72,   462,     1,     2,   586,
2209        3,     4,     5,   504,   505,   506,   507,   463,   372,   372,
2210      509,   510,   464,   384,   465,   319,   320,   467,   469,   470,
2211      472,   392,   393,   473,   372,   476,   478,    73,   477,   480,
2212      481,   499,   321,   322,   482,   323,   324,   483,   325,   326,
2213      327,   484,   535,   536,   486,   511,   488,   372,   372,   489,
2214      515,   491,   442,   492,   372,   372,   521,   493,   496,   497,
2215      501,   372,   267,   502,   372,   267,   267,   267,   517,   538,
2216      521,   529,   537,   508,   539,   512,   540,   541,   560,   542,
2217      561,   562,   547,   548,   549,   438,   439,   440,   554,   558,
2218      559,   564,   566,   445,   577,   579,   360,   361,   580,   581,
2219       63,    64,   362,   455,   456,   582,   -18,   -19,   592,   596,
2220      598,   597,     1,     2,   603,     3,     4,     5,   363,   364,
2221      365,   604,   606,   215,   216,   217,   575,   339,   563,    74,
2222      330,   340,    75,   366,   367,    76,   129,    77,   107,   545,
2223      144,   141,   338,    44,   512,   128,    96,   533,   461,   485,
2224      368,   487,     0,     0,   490,     0,     0,     0,     0,     0,
2225      494,   495,     0,     0,     0,     0,   176,   177,   178,   179,
2226      180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
2227      190,   247,   248,     0,     0,     0,     0,     0,   518,   519,
2228        0,   523,   524,     0,     0,     0,     0,   528,     0,     0,
2229        0,     0,     0,     0,     0,     0,     0,   534,   249,   197,
2230      570,   571,   200,   201,   202,   203,   204,   205,   206,   207,
2231      208,     0,   250,     0,   251,   252,   253,   321,   322,     0,
2232      323,   324,     0,   325,   326,   327,     0,   555,     0,     0,
2233        0,     0,     0,     0,     0,     0,     0,   360,   361,     0,
2234      369,    63,    64,   362,     0,     0,     0,     0,   572,   573,
2235        0,     0,     0,     1,     2,     0,     3,     4,     5,   363,
2236      364,   365,   285,   286,   583,     0,     0,     0,     0,     0,
2237        0,     0,     0,     0,   366,   367,   274,   275,   276,   277,
2238      278,   279,   280,   281,   282,   283,     0,   594,   595,     0,
2239        0,   368,     0,     0,   601,   602,     0,     0,     0,     0,
2240        0,   605,     0,     0,   607,     0,     0,   176,   177,   178,
2241      179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
2242      189,   190,   247,   248,     0,     0,     0,     0,     0,     0,
2243        0,     0,   287,   288,   289,   290,   291,   292,   293,   294,
2244      295,   296,   297,   298,   299,   300,     0,     0,     0,   249,
2245      197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
2246      207,   208,     0,   250,     0,   251,   252,   253,     0,     0,
2247        0,     0,     0,   360,   361,     0,     0,    63,    64,   362,
2248        0,     0,     0,     0,   110,     0,   111,     0,     0,     1,
2249        2,   369,     3,     4,     5,   363,   364,   365,     0,     0,
2250       63,    64,     0,     0,     0,     0,     0,     0,     0,     0,
2251      366,   367,     1,     2,     0,     3,     4,     5,   244,     0,
2252        0,     0,     0,     0,     0,     0,     0,   368,     0,     0,
2253        0,     0,     0,   245,   246,     0,     0,     0,     0,     0,
2254        0,     0,     0,   176,   177,   178,   179,   180,   181,   182,
2255      183,   184,   185,   186,   187,   188,   189,   190,   247,   248,
2256        0,     0,     0,     0,     0,     0,   176,   177,   178,   179,
2257      180,   181,   182,   183,   184,   185,   186,   187,   188,   189,
2258      190,   247,   248,     0,     0,   249,   197,   198,   199,   200,
2259      201,   202,   203,   204,   205,   206,   207,   208,     0,   250,
2260        0,   251,   252,   253,     0,     0,     0,     0,   249,   197,
2261      198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
2262      208,     0,   250,     0,   251,   252,   253,   369,     0,     0,
2263        0,     0,     0,   360,   361,     0,     0,     0,     0,   362,
2264        0,     0,     0,   110,     0,   111,     0,   254,     0,     0,
2265      255,     0,   256,     0,   257,   363,   364,   365,     0,     0,
2266        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2267      366,   367,     0,     0,     0,     0,     0,     0,     0,     0,
2268        0,     0,     0,     0,     0,    63,    64,   368,   106,    66,
2269       67,    68,    69,    70,    71,    72,     0,     1,     2,     0,
2270        3,     4,     5,   176,   177,   178,   179,   180,   181,   182,
2271      183,   184,   185,   186,   187,   188,   189,   190,   247,   248,
2272        0,     0,     0,     0,     0,    63,    64,    73,   106,   152,
2273      153,   154,   155,   156,   157,    72,     0,     1,     2,     0,
2274        3,     4,     5,     0,     0,   249,   197,   198,   199,   200,
2275      201,   202,   203,   204,   205,   206,   207,   208,     0,   250,
2276        0,   251,   252,   253,     0,    63,    64,    73,   106,   152,
2277      153,   154,   155,   156,   157,    72,     0,     1,     2,     0,
2278        3,     4,     5,     0,     0,    63,    64,   369,   106,    66,
2279       67,    68,    69,    70,    71,    72,     0,     1,     2,     0,
2280        3,     4,     5,     0,     0,     0,     0,    73,     0,     0,
2281        0,     0,     0,     0,     0,     0,     0,   133,     0,     0,
2282        0,     0,     0,     0,     0,     0,     0,    73,     0,    74,
2283        0,     0,    75,     0,     0,    76,     0,    77,   140,    63,
2284       64,     0,   147,    66,    67,    68,    69,    70,    71,    72,
2285        0,     1,     2,     0,     3,     4,     5,     0,     0,     0,
2286        0,     0,     0,     0,     0,     0,     0,     0,     0,    74,
2287        0,     0,    75,     0,     0,    76,     0,    77,   351,    63,
2288       64,    73,   106,    66,    67,    68,    69,    70,    71,    72,
2289        0,     1,     2,     0,     3,     4,     5,     0,     0,     0,
2290        0,     0,     0,     0,     0,     0,     0,     0,     0,    74,
2291        0,   329,    75,     0,     0,    76,     0,    77,   417,     0,
2292        0,    73,     0,     0,     0,     0,     0,     0,     0,    74,
2293        0,     0,    75,     0,     0,    76,     0,    77,     0,    63,
2294       64,     0,   106,   152,   153,   154,   155,   156,   157,    72,
2295        0,     1,     2,   148,     3,     4,     5,     0,    63,    64,
2296        0,   106,    66,    67,    68,    69,    70,    71,    72,     0,
2297        1,     2,     0,     3,     4,     5,     0,     0,     0,     0,
2298        0,    73,     0,    74,     0,     0,    75,     0,     0,    76,
2299      429,    77,     0,     0,     0,     0,     0,     0,    63,    64,
2300       73,   106,    66,    67,    68,    69,    70,    71,    72,     0,
2301        1,     2,     0,     3,     4,     5,     0,     0,     0,     0,
2302        0,     0,     0,    74,     0,     0,    75,     0,     0,    76,
2303      514,    77,     0,     0,     0,     0,     0,     0,    63,    64,
2304       73,    65,    66,    67,    68,    69,    70,    71,    72,     0,
2305        1,     2,     0,     3,     4,     5,    63,    64,     0,   106,
2306      152,   153,   154,   155,   156,   157,    72,     0,     1,     2,
2307        0,     3,     4,     5,     0,     0,     0,     0,     0,     0,
2308       73,     0,     0,    74,     0,     0,    75,     0,   346,    76,
2309        0,    77,     0,     0,     0,     0,     0,     0,    73,     0,
2310        0,     0,    74,     0,     0,    75,     0,     0,    76,     0,
2311       77,    63,    64,     0,   147,    66,    67,    68,    69,    70,
2312       71,    72,     0,     1,     2,     0,     3,     4,     5,     0,
2313        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2314        0,     0,    74,     0,     0,    75,     0,     0,    76,     0,
2315       77,    63,    64,    73,   106,    66,    67,    68,    69,    70,
2316       71,    72,     0,     1,     2,     0,     3,     4,     5,     0,
2317        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2318        0,     0,    74,     0,     0,    75,     0,     0,    76,     0,
2319       77,     0,     0,    73,     0,     0,     0,     0,     0,     0,
2320       74,     0,     0,    75,     0,     0,    76,     0,    77,    63,
2321       64,     0,   266,    66,    67,    68,    69,    70,    71,    72,
2322        0,     1,     2,     0,     3,     4,     5,    63,    64,     0,
2323      106,   152,   153,   154,   155,   156,   157,    72,     0,     1,
2324        2,     0,     3,     4,     5,     0,     0,     0,     0,     0,
2325        0,    73,     0,     0,     0,    74,     0,     0,    75,     0,
2326        0,    76,     0,    77,     0,     0,     0,    63,    64,    73,
2327      106,    66,    67,    68,    69,    70,    71,   520,     0,     1,
2328        2,     0,     3,     4,     5,     0,     0,     0,     0,     0,
2329        0,     0,     0,     0,     0,    74,     0,     0,    75,     0,
2330        0,    76,     0,    77,     0,     0,     0,    63,    64,    73,
2331      106,    66,    67,    68,    69,    70,    71,   574,     0,     1,
2332        2,     0,     3,     4,     5,     0,     0,     0,     0,     0,
2333        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2334        0,     0,     0,     0,     0,     0,     0,     0,     0,    73,
2335      167,     0,     0,    74,     0,     0,    75,     0,     0,    76,
2336        0,    77,     0,     0,     0,     0,     0,     0,     0,   168,
2337      169,    74,     0,     0,    75,     0,     0,    76,     0,   349,
2338        0,   170,   171,   172,   173,   174,   175,   176,   177,   178,
2339      179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
2340      189,   190,   191,   192,     0,     0,     0,     0,     0,     0,
2341        0,    74,     0,     0,    75,     0,     0,    76,     0,    77,
2342        0,     0,     0,     0,   193,   194,   195,     0,     0,   196,
2343      197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
2344      207,   208,   209,   210,   211,   212,   213,   214,  -202,     0,
2345        0,    74,     0,     0,    75,     0,     0,    76,     0,    77,
2346        0,     0,     0,     0,     0,     0,   -67,     1,     2,     0,
2347        3,     4,     5,     0,     0,     0,     0,     0,     6,     7,
2348        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2349        0,     0,     0,     0,     0,     0,     0,     0,     0,     8,
2350        0,     0,     9,     0,     0,     0,    10
2351 };
2352
2353 static const yytype_int16 yycheck[] =
2354 {
2355        0,    27,   172,   232,   160,     4,   126,    11,   150,   195,
2356       28,   303,   430,    11,    34,     0,   173,    17,   160,    11,
2357      255,   256,    11,   568,   210,   211,   212,   213,   214,   336,
2358      337,   217,    17,    53,    21,    52,    46,    34,    48,    40,
2359       41,   586,    29,   149,   149,   149,    47,     0,   149,    66,
2360      149,    77,    53,   148,   160,   160,   160,   156,   148,   160,
2361      119,    53,   219,   149,    53,    18,    19,    20,    11,    22,
2362       23,    24,   158,   149,    17,   101,   149,    30,    31,   105,
2363      153,   150,   158,   152,   149,   111,   145,    32,    33,   158,
2364      116,   156,    92,   150,    35,   152,    37,   515,    51,   156,
2365      126,    54,   520,   521,    18,    58,    42,    43,    44,    57,
2366       38,    47,   138,   139,   349,   150,   142,   152,   153,    19,
2367      146,   428,    22,    20,    24,   267,    23,   269,   270,   150,
2368      272,   152,   318,   154,   369,     0,   149,   134,   135,   136,
2369      153,   159,   139,   150,   170,   152,   143,   144,     3,     4,
2370        5,     6,   156,   273,   572,   573,   574,   575,   156,   154,
2371      159,   149,   148,   305,   456,   153,   148,   193,   194,   195,
2372      196,   313,   314,   160,   113,   114,   594,   595,   163,   149,
2373      150,   148,   152,   209,   210,   211,   212,   213,   214,   215,
2374      216,   217,    42,   485,    44,   487,   316,   149,   150,   225,
2375      152,   387,    22,   389,   390,   391,   134,   135,   136,   235,
2376      150,   139,   152,   153,    21,   143,   144,     3,     4,     5,
2377        6,   145,   146,   147,    22,    42,    43,    44,    45,    46,
2378       47,    48,   150,    50,   152,   377,   378,   379,   112,   113,
2379       26,    27,   534,   385,     7,     8,    22,   273,   477,   117,
2380      118,    83,    84,   395,   396,    22,    19,    20,   284,    22,
2381       23,    24,   418,   152,     4,     4,   134,   135,    37,   137,
2382      138,   155,   140,   141,   142,   301,   418,   155,     4,    22,
2383      149,   153,   341,   342,   343,   344,   345,   158,     9,   153,
2384      316,   317,   318,   152,     9,   354,   355,   356,     9,   441,
2385        9,   443,   488,     9,   446,   491,   492,   493,     9,    55,
2386      452,   453,    11,   158,   152,   152,   152,    19,   152,   152,
2387       22,   152,    24,   349,   553,    22,   152,   556,   145,   146,
2388      147,   152,    59,   359,   149,   134,   135,   136,   480,   481,
2389      139,   483,   484,   152,   143,   144,   149,   489,   149,   408,
2390      409,    38,   149,   149,   149,   149,   415,   499,    38,   152,
2391      152,   387,   388,   389,   390,   391,   149,   149,   394,    60,
2392       61,    62,    63,    64,    65,   154,   149,   269,   270,   549,
2393      272,   407,    38,   149,   149,     7,     8,   529,    10,    11,
2394       12,    13,    14,    15,    16,    17,   149,    19,    20,   569,
2395       22,    23,    24,   462,   463,   464,   465,   149,   550,   551,
2396      469,   470,   149,   305,   149,   117,   118,   158,   149,   149,
2397       22,   313,   314,     4,   566,   149,    22,    49,   153,    17,
2398       17,   457,   134,   135,   152,   137,   138,   149,   140,   141,
2399      142,   149,   501,   502,     4,   471,   149,   589,   590,   149,
2400      476,   149,    53,   149,   596,   597,   482,   149,   152,   149,
2401      149,   603,   488,   149,   606,   491,   492,   493,   149,   153,
2402      496,   149,   149,   158,   149,   475,   149,   153,   537,   153,
2403      539,   540,    22,   149,   154,   377,   378,   379,   156,   153,
2404      153,    53,    17,   385,   156,   153,     3,     4,   153,   153,
2405        7,     8,     9,   395,   396,     4,   152,   152,   149,    17,
2406      149,    17,    19,    20,    17,    22,    23,    24,    25,    26,
2407       27,    71,    17,   129,   129,   129,   552,   247,   544,   151,
2408      225,   248,   154,    40,    41,   157,    92,   159,   160,   516,
2409      111,   105,   235,    17,   544,    89,    56,   496,   410,   441,
2410       57,   443,    -1,    -1,   446,    -1,    -1,    -1,    -1,    -1,
2411      452,   453,    -1,    -1,    -1,    -1,    73,    74,    75,    76,
2412       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
2413       87,    88,    89,    -1,    -1,    -1,    -1,    -1,   480,   481,
2414       -1,   483,   484,    -1,    -1,    -1,    -1,   489,    -1,    -1,
2415       -1,    -1,    -1,    -1,    -1,    -1,    -1,   499,   115,   116,
2416      117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
2417      127,    -1,   129,    -1,   131,   132,   133,   134,   135,    -1,
2418      137,   138,    -1,   140,   141,   142,    -1,   529,    -1,    -1,
2419       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,    -1,
2420      157,     7,     8,     9,    -1,    -1,    -1,    -1,   550,   551,
2421       -1,    -1,    -1,    19,    20,    -1,    22,    23,    24,    25,
2422       26,    27,    26,    27,   566,    -1,    -1,    -1,    -1,    -1,
2423       -1,    -1,    -1,    -1,    40,    41,    90,    91,    92,    93,
2424       94,    95,    96,    97,    98,    99,    -1,   589,   590,    -1,
2425       -1,    57,    -1,    -1,   596,   597,    -1,    -1,    -1,    -1,
2426       -1,   603,    -1,    -1,   606,    -1,    -1,    73,    74,    75,
2427       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
2428       86,    87,    88,    89,    -1,    -1,    -1,    -1,    -1,    -1,
2429       -1,    -1,    96,    97,    98,    99,   100,   101,   102,   103,
2430      104,   105,   106,   107,   108,   109,    -1,    -1,    -1,   115,
2431      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
2432      126,   127,    -1,   129,    -1,   131,   132,   133,    -1,    -1,
2433       -1,    -1,    -1,     3,     4,    -1,    -1,     7,     8,     9,
2434       -1,    -1,    -1,    -1,   150,    -1,   152,    -1,    -1,    19,
2435       20,   157,    22,    23,    24,    25,    26,    27,    -1,    -1,
2436        7,     8,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2437       40,    41,    19,    20,    -1,    22,    23,    24,    25,    -1,
2438       -1,    -1,    -1,    -1,    -1,    -1,    -1,    57,    -1,    -1,
2439       -1,    -1,    -1,    40,    41,    -1,    -1,    -1,    -1,    -1,
2440       -1,    -1,    -1,    73,    74,    75,    76,    77,    78,    79,
2441       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
2442       -1,    -1,    -1,    -1,    -1,    -1,    73,    74,    75,    76,
2443       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
2444       87,    88,    89,    -1,    -1,   115,   116,   117,   118,   119,
2445      120,   121,   122,   123,   124,   125,   126,   127,    -1,   129,
2446       -1,   131,   132,   133,    -1,    -1,    -1,    -1,   115,   116,
2447      117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
2448      127,    -1,   129,    -1,   131,   132,   133,   157,    -1,    -1,
2449       -1,    -1,    -1,     3,     4,    -1,    -1,    -1,    -1,     9,
2450       -1,    -1,    -1,   150,    -1,   152,    -1,   154,    -1,    -1,
2451      157,    -1,   159,    -1,   161,    25,    26,    27,    -1,    -1,
2452       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2453       40,    41,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2454       -1,    -1,    -1,    -1,    -1,     7,     8,    57,    10,    11,
2455       12,    13,    14,    15,    16,    17,    -1,    19,    20,    -1,
2456       22,    23,    24,    73,    74,    75,    76,    77,    78,    79,
2457       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
2458       -1,    -1,    -1,    -1,    -1,     7,     8,    49,    10,    11,
2459       12,    13,    14,    15,    16,    17,    -1,    19,    20,    -1,
2460       22,    23,    24,    -1,    -1,   115,   116,   117,   118,   119,
2461      120,   121,   122,   123,   124,   125,   126,   127,    -1,   129,
2462       -1,   131,   132,   133,    -1,     7,     8,    49,    10,    11,
2463       12,    13,    14,    15,    16,    17,    -1,    19,    20,    -1,
2464       22,    23,    24,    -1,    -1,     7,     8,   157,    10,    11,
2465       12,    13,    14,    15,    16,    17,    -1,    19,    20,    -1,
2466       22,    23,    24,    -1,    -1,    -1,    -1,    49,    -1,    -1,
2467       -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    -1,    -1,
2468       -1,    -1,    -1,    -1,    -1,    -1,    -1,    49,    -1,   151,
2469       -1,    -1,   154,    -1,    -1,   157,    -1,   159,   160,     7,
2470        8,    -1,    10,    11,    12,    13,    14,    15,    16,    17,
2471       -1,    19,    20,    -1,    22,    23,    24,    -1,    -1,    -1,
2472       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   151,
2473       -1,    -1,   154,    -1,    -1,   157,    -1,   159,   160,     7,
2474        8,    49,    10,    11,    12,    13,    14,    15,    16,    17,
2475       -1,    19,    20,    -1,    22,    23,    24,    -1,    -1,    -1,
2476       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   151,
2477       -1,    39,   154,    -1,    -1,   157,    -1,   159,   160,    -1,
2478       -1,    49,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   151,
2479       -1,    -1,   154,    -1,    -1,   157,    -1,   159,    -1,     7,
2480        8,    -1,    10,    11,    12,    13,    14,    15,    16,    17,
2481       -1,    19,    20,   121,    22,    23,    24,    -1,     7,     8,
2482       -1,    10,    11,    12,    13,    14,    15,    16,    17,    -1,
2483       19,    20,    -1,    22,    23,    24,    -1,    -1,    -1,    -1,
2484       -1,    49,    -1,   151,    -1,    -1,   154,    -1,    -1,   157,
2485       39,   159,    -1,    -1,    -1,    -1,    -1,    -1,     7,     8,
2486       49,    10,    11,    12,    13,    14,    15,    16,    17,    -1,
2487       19,    20,    -1,    22,    23,    24,    -1,    -1,    -1,    -1,
2488       -1,    -1,    -1,   151,    -1,    -1,   154,    -1,    -1,   157,
2489       39,   159,    -1,    -1,    -1,    -1,    -1,    -1,     7,     8,
2490       49,    10,    11,    12,    13,    14,    15,    16,    17,    -1,
2491       19,    20,    -1,    22,    23,    24,     7,     8,    -1,    10,
2492       11,    12,    13,    14,    15,    16,    17,    -1,    19,    20,
2493       -1,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    -1,
2494       49,    -1,    -1,   151,    -1,    -1,   154,    -1,   156,   157,
2495       -1,   159,    -1,    -1,    -1,    -1,    -1,    -1,    49,    -1,
2496       -1,    -1,   151,    -1,    -1,   154,    -1,    -1,   157,    -1,
2497      159,     7,     8,    -1,    10,    11,    12,    13,    14,    15,
2498       16,    17,    -1,    19,    20,    -1,    22,    23,    24,    -1,
2499       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2500       -1,    -1,   151,    -1,    -1,   154,    -1,    -1,   157,    -1,
2501      159,     7,     8,    49,    10,    11,    12,    13,    14,    15,
2502       16,    17,    -1,    19,    20,    -1,    22,    23,    24,    -1,
2503       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2504       -1,    -1,   151,    -1,    -1,   154,    -1,    -1,   157,    -1,
2505      159,    -1,    -1,    49,    -1,    -1,    -1,    -1,    -1,    -1,
2506      151,    -1,    -1,   154,    -1,    -1,   157,    -1,   159,     7,
2507        8,    -1,    10,    11,    12,    13,    14,    15,    16,    17,
2508       -1,    19,    20,    -1,    22,    23,    24,     7,     8,    -1,
2509       10,    11,    12,    13,    14,    15,    16,    17,    -1,    19,
2510       20,    -1,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
2511       -1,    49,    -1,    -1,    -1,   151,    -1,    -1,   154,    -1,
2512       -1,   157,    -1,   159,    -1,    -1,    -1,     7,     8,    49,
2513       10,    11,    12,    13,    14,    15,    16,    17,    -1,    19,
2514       20,    -1,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
2515       -1,    -1,    -1,    -1,    -1,   151,    -1,    -1,   154,    -1,
2516       -1,   157,    -1,   159,    -1,    -1,    -1,     7,     8,    49,
2517       10,    11,    12,    13,    14,    15,    16,    17,    -1,    19,
2518       20,    -1,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
2519       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2520       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    49,
2521       36,    -1,    -1,   151,    -1,    -1,   154,    -1,    -1,   157,
2522       -1,   159,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    55,
2523       56,   151,    -1,    -1,   154,    -1,    -1,   157,    -1,   159,
2524       -1,    67,    68,    69,    70,    71,    72,    73,    74,    75,
2525       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
2526       86,    87,    88,    89,    -1,    -1,    -1,    -1,    -1,    -1,
2527       -1,   151,    -1,    -1,   154,    -1,    -1,   157,    -1,   159,
2528       -1,    -1,    -1,    -1,   110,   111,   112,    -1,    -1,   115,
2529      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
2530      126,   127,   128,   129,   130,   131,   132,   133,     0,    -1,
2531       -1,   151,    -1,    -1,   154,    -1,    -1,   157,    -1,   159,
2532       -1,    -1,    -1,    -1,    -1,    -1,    18,    19,    20,    -1,
2533       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
2534       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2535       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    51,
2536       -1,    -1,    54,    -1,    -1,    -1,    58
2537 };
2538
2539 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
2540    symbol of state STATE-NUM.  */
2541 static const yytype_uint8 yystos[] =
2542 {
2543        0,    19,    20,    22,    23,    24,    30,    31,    51,    54,
2544       58,   170,   172,   173,   174,   175,   206,   207,   208,   210,
2545      209,    52,    66,   215,   148,    57,   148,    18,   148,    42,
2546       43,    44,    45,    46,    47,    48,    50,   145,   146,   147,
2547      176,   177,   178,     0,   208,    46,    48,   179,   225,    42,
2548       43,    44,    47,   180,   222,   224,   231,   148,   148,   154,
2549      216,    22,   214,     7,     8,    10,    11,    12,    13,    14,
2550       15,    16,    17,    49,   151,   154,   157,   159,   170,   173,
2551      193,   194,   228,   178,   178,    35,    37,   204,   178,   178,
2552       21,   232,   233,    29,   160,   223,   232,    22,    22,    22,
2553      217,   152,     4,     4,     4,   159,    10,   160,   194,   199,
2554      150,   152,   204,   204,    42,    44,   181,    32,    33,   203,
2555       60,    61,    62,    63,    64,    65,   182,   220,   220,   172,
2556      236,   149,   156,    39,   194,   195,   197,   198,   155,   155,
2557      160,   199,   149,   160,   198,   203,   203,    10,   121,   194,
2558      196,   205,    11,    12,    13,    14,    15,    16,   168,   169,
2559      194,   200,     4,   196,    28,   159,   221,    36,    55,    56,
2560       67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
2561       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
2562       87,    88,    89,   110,   111,   112,   115,   116,   117,   118,
2563      119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
2564      129,   130,   131,   132,   133,   163,   164,   165,   234,   240,
2565      241,   242,   243,    22,   184,   149,   153,   194,   194,   158,
2566      160,   194,   153,   200,   194,   152,   228,    26,    27,     3,
2567        4,     5,     6,     9,    25,    40,    41,    88,    89,   115,
2568      129,   131,   132,   133,   154,   157,   159,   161,   163,   164,
2569      165,   201,   228,   211,   173,    55,    10,   194,   230,    11,
2570       17,    11,   168,   182,    90,    91,    92,    93,    94,    95,
2571       96,    97,    98,    99,   166,    26,    27,    96,    97,    98,
2572       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
2573      109,   167,   194,   194,   230,   194,   194,   237,   230,   230,
2574      230,   230,   230,   194,   194,   230,   182,   113,   114,   117,
2575      118,   134,   135,   137,   138,   140,   141,   142,   183,    39,
2576      195,   186,   156,   158,   158,   186,   212,   213,   205,   166,
2577      167,   152,   152,   152,   152,   152,   156,   200,   202,   159,
2578      202,   160,   202,    22,   152,   152,   152,   149,   191,   152,
2579        3,     4,     9,    25,    26,    27,    40,    41,    57,   157,
2580      201,   227,   228,   229,   229,   229,   229,   196,   194,   194,
2581      149,   188,   149,   188,   229,   154,   149,   149,   149,   149,
2582      149,   149,   229,   229,    38,   196,   194,   230,   134,   135,
2583      136,   139,   143,   144,   185,   191,   191,    38,   152,   152,
2584      200,   200,   200,   200,   200,   149,   156,   160,   194,   202,
2585      158,   160,   200,   200,   200,    34,    53,   189,   192,    39,
2586      194,   218,   219,    59,   226,   202,   149,   149,   229,   229,
2587      229,    11,    53,    11,   239,   229,   154,   230,   194,   230,
2588      230,   230,   149,   149,   194,   229,   229,   149,   194,   200,
2589      200,   239,   149,   149,   149,   149,   200,   158,   160,   149,
2590      149,    38,    22,     4,   191,   184,   149,   153,    22,   158,
2591       17,    17,   152,   149,   149,   229,     4,   229,   149,   149,
2592      229,   149,   149,   149,   229,   229,   152,   149,   188,   194,
2593      153,   149,   149,   153,   200,   200,   200,   200,   158,   200,
2594      200,   194,   170,   171,    39,   194,   186,   149,   229,   229,
2595       17,   194,   238,   229,   229,   188,   188,   230,   229,   149,
2596      230,   230,   230,   238,   229,   200,   200,   149,   153,   149,
2597      149,   153,   153,   153,   184,   189,   190,    22,   149,   154,
2598      184,   184,   149,   153,   156,   229,   153,   188,   153,   153,
2599      200,   200,   200,   171,    53,   187,    17,   156,   168,   235,
2600      117,   118,   229,   229,    17,   194,   186,   156,   186,   153,
2601      153,   153,     4,   229,   227,   156,   168,   184,   184,   184,
2602      184,    38,   149,   227,   229,   229,    17,    17,   149,   184,
2603      184,   229,   229,    17,    71,   229,    17,   229
2604 };
2605
2606 #define yyerrok         (yyerrstatus = 0)
2607 #define yyclearin       (yychar = YYEMPTY)
2608 #define YYEMPTY         (-2)
2609 #define YYEOF           0
2610
2611 #define YYACCEPT        goto yyacceptlab
2612 #define YYABORT         goto yyabortlab
2613 #define YYERROR         goto yyerrorlab
2614
2615
2616 /* Like YYERROR except do call yyerror.  This remains here temporarily
2617    to ease the transition to the new meaning of YYERROR, for GCC.
2618    Once GCC version 2 has supplanted version 1, this can go.  */
2619
2620 #define YYFAIL          goto yyerrlab
2621
2622 #define YYRECOVERING()  (!!yyerrstatus)
2623
2624 #define YYBACKUP(Token, Value)                                  \
2625 do                                                              \
2626   if (yychar == YYEMPTY && yylen == 1)                          \
2627     {                                                           \
2628       yychar = (Token);                                         \
2629       yylval = (Value);                                         \
2630       yytoken = YYTRANSLATE (yychar);                           \
2631       YYPOPSTACK (1);                                           \
2632       goto yybackup;                                            \
2633     }                                                           \
2634   else                                                          \
2635     {                                                           \
2636       yyerror (YY_("syntax error: cannot back up")); \
2637       YYERROR;                                                  \
2638     }                                                           \
2639 while (YYID (0))
2640
2641
2642 #define YYTERROR        1
2643 #define YYERRCODE       256
2644
2645
2646 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
2647    If N is 0, then set CURRENT to the empty location which ends
2648    the previous symbol: RHS[0] (always defined).  */
2649
2650 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
2651 #ifndef YYLLOC_DEFAULT
2652 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
2653     do                                                                  \
2654       if (YYID (N))                                                    \
2655         {                                                               \
2656           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
2657           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
2658           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
2659           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
2660         }                                                               \
2661       else                                                              \
2662         {                                                               \
2663           (Current).first_line   = (Current).last_line   =              \
2664             YYRHSLOC (Rhs, 0).last_line;                                \
2665           (Current).first_column = (Current).last_column =              \
2666             YYRHSLOC (Rhs, 0).last_column;                              \
2667         }                                                               \
2668     while (YYID (0))
2669 #endif
2670
2671
2672 /* YY_LOCATION_PRINT -- Print the location on the stream.
2673    This macro was not mandated originally: define only if we know
2674    we won't break user code: when these are the locations we know.  */
2675
2676 #ifndef YY_LOCATION_PRINT
2677 # if YYLTYPE_IS_TRIVIAL
2678 #  define YY_LOCATION_PRINT(File, Loc)                  \
2679      fprintf (File, "%d.%d-%d.%d",                      \
2680               (Loc).first_line, (Loc).first_column,     \
2681               (Loc).last_line,  (Loc).last_column)
2682 # else
2683 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
2684 # endif
2685 #endif
2686
2687
2688 /* YYLEX -- calling `yylex' with the right arguments.  */
2689
2690 #ifdef YYLEX_PARAM
2691 # define YYLEX yylex (YYLEX_PARAM)
2692 #else
2693 # define YYLEX yylex ()
2694 #endif
2695
2696 /* Enable debugging if requested.  */
2697 #if YYDEBUG
2698
2699 # ifndef YYFPRINTF
2700 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
2701 #  define YYFPRINTF fprintf
2702 # endif
2703
2704 # define YYDPRINTF(Args)                        \
2705 do {                                            \
2706   if (yydebug)                                  \
2707     YYFPRINTF Args;                             \
2708 } while (YYID (0))
2709
2710 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
2711 do {                                                                      \
2712   if (yydebug)                                                            \
2713     {                                                                     \
2714       YYFPRINTF (stderr, "%s ", Title);                                   \
2715       yy_symbol_print (stderr,                                            \
2716                   Type, Value); \
2717       YYFPRINTF (stderr, "\n");                                           \
2718     }                                                                     \
2719 } while (YYID (0))
2720
2721
2722 /*--------------------------------.
2723 | Print this symbol on YYOUTPUT.  |
2724 `--------------------------------*/
2725
2726 /*ARGSUSED*/
2727 #if (defined __STDC__ || defined __C99__FUNC__ \
2728      || defined __cplusplus || defined _MSC_VER)
2729 static void
2730 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
2731 #else
2732 static void
2733 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
2734     FILE *yyoutput;
2735     int yytype;
2736     YYSTYPE const * const yyvaluep;
2737 #endif
2738 {
2739   if (!yyvaluep)
2740     return;
2741 # ifdef YYPRINT
2742   if (yytype < YYNTOKENS)
2743     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
2744 # else
2745   YYUSE (yyoutput);
2746 # endif
2747   switch (yytype)
2748     {
2749       default:
2750         break;
2751     }
2752 }
2753
2754
2755 /*--------------------------------.
2756 | Print this symbol on YYOUTPUT.  |
2757 `--------------------------------*/
2758
2759 #if (defined __STDC__ || defined __C99__FUNC__ \
2760      || defined __cplusplus || defined _MSC_VER)
2761 static void
2762 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
2763 #else
2764 static void
2765 yy_symbol_print (yyoutput, yytype, yyvaluep)
2766     FILE *yyoutput;
2767     int yytype;
2768     YYSTYPE const * const yyvaluep;
2769 #endif
2770 {
2771   if (yytype < YYNTOKENS)
2772     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
2773   else
2774     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
2775
2776   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
2777   YYFPRINTF (yyoutput, ")");
2778 }
2779
2780 /*------------------------------------------------------------------.
2781 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
2782 | TOP (included).                                                   |
2783 `------------------------------------------------------------------*/
2784
2785 #if (defined __STDC__ || defined __C99__FUNC__ \
2786      || defined __cplusplus || defined _MSC_VER)
2787 static void
2788 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
2789 #else
2790 static void
2791 yy_stack_print (bottom, top)
2792     yytype_int16 *bottom;
2793     yytype_int16 *top;
2794 #endif
2795 {
2796   YYFPRINTF (stderr, "Stack now");
2797   for (; bottom <= top; ++bottom)
2798     YYFPRINTF (stderr, " %d", *bottom);
2799   YYFPRINTF (stderr, "\n");
2800 }
2801
2802 # define YY_STACK_PRINT(Bottom, Top)                            \
2803 do {                                                            \
2804   if (yydebug)                                                  \
2805     yy_stack_print ((Bottom), (Top));                           \
2806 } while (YYID (0))
2807
2808
2809 /*------------------------------------------------.
2810 | Report that the YYRULE is going to be reduced.  |
2811 `------------------------------------------------*/
2812
2813 #if (defined __STDC__ || defined __C99__FUNC__ \
2814      || defined __cplusplus || defined _MSC_VER)
2815 static void
2816 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
2817 #else
2818 static void
2819 yy_reduce_print (yyvsp, yyrule)
2820     YYSTYPE *yyvsp;
2821     int yyrule;
2822 #endif
2823 {
2824   int yynrhs = yyr2[yyrule];
2825   int yyi;
2826   unsigned long int yylno = yyrline[yyrule];
2827   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
2828              yyrule - 1, yylno);
2829   /* The symbols being reduced.  */
2830   for (yyi = 0; yyi < yynrhs; yyi++)
2831     {
2832       fprintf (stderr, "   $%d = ", yyi + 1);
2833       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
2834                        &(yyvsp[(yyi + 1) - (yynrhs)])
2835                                        );
2836       fprintf (stderr, "\n");
2837     }
2838 }
2839
2840 # define YY_REDUCE_PRINT(Rule)          \
2841 do {                                    \
2842   if (yydebug)                          \
2843     yy_reduce_print (yyvsp, Rule); \
2844 } while (YYID (0))
2845
2846 /* Nonzero means print parse trace.  It is left uninitialized so that
2847    multiple parsers can coexist.  */
2848 int yydebug;
2849 #else /* !YYDEBUG */
2850 # define YYDPRINTF(Args)
2851 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
2852 # define YY_STACK_PRINT(Bottom, Top)
2853 # define YY_REDUCE_PRINT(Rule)
2854 #endif /* !YYDEBUG */
2855
2856
2857 /* YYINITDEPTH -- initial size of the parser's stacks.  */
2858 #ifndef YYINITDEPTH
2859 # define YYINITDEPTH 200
2860 #endif
2861
2862 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
2863    if the built-in stack extension method is used).
2864
2865    Do not make this value too large; the results are undefined if
2866    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
2867    evaluated with infinite-precision integer arithmetic.  */
2868
2869 #ifndef YYMAXDEPTH
2870 # define YYMAXDEPTH 10000
2871 #endif
2872
2873 \f
2874
2875 #if YYERROR_VERBOSE
2876
2877 # ifndef yystrlen
2878 #  if defined __GLIBC__ && defined _STRING_H
2879 #   define yystrlen strlen
2880 #  else
2881 /* Return the length of YYSTR.  */
2882 #if (defined __STDC__ || defined __C99__FUNC__ \
2883      || defined __cplusplus || defined _MSC_VER)
2884 static YYSIZE_T
2885 yystrlen (const char *yystr)
2886 #else
2887 static YYSIZE_T
2888 yystrlen (yystr)
2889     const char *yystr;
2890 #endif
2891 {
2892   YYSIZE_T yylen;
2893   for (yylen = 0; yystr[yylen]; yylen++)
2894     continue;
2895   return yylen;
2896 }
2897 #  endif
2898 # endif
2899
2900 # ifndef yystpcpy
2901 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
2902 #   define yystpcpy stpcpy
2903 #  else
2904 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
2905    YYDEST.  */
2906 #if (defined __STDC__ || defined __C99__FUNC__ \
2907      || defined __cplusplus || defined _MSC_VER)
2908 static char *
2909 yystpcpy (char *yydest, const char *yysrc)
2910 #else
2911 static char *
2912 yystpcpy (yydest, yysrc)
2913     char *yydest;
2914     const char *yysrc;
2915 #endif
2916 {
2917   char *yyd = yydest;
2918   const char *yys = yysrc;
2919
2920   while ((*yyd++ = *yys++) != '\0')
2921     continue;
2922
2923   return yyd - 1;
2924 }
2925 #  endif
2926 # endif
2927
2928 # ifndef yytnamerr
2929 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
2930    quotes and backslashes, so that it's suitable for yyerror.  The
2931    heuristic is that double-quoting is unnecessary unless the string
2932    contains an apostrophe, a comma, or backslash (other than
2933    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
2934    null, do not copy; instead, return the length of what the result
2935    would have been.  */
2936 static YYSIZE_T
2937 yytnamerr (char *yyres, const char *yystr)
2938 {
2939   if (*yystr == '"')
2940     {
2941       YYSIZE_T yyn = 0;
2942       char const *yyp = yystr;
2943
2944       for (;;)
2945         switch (*++yyp)
2946           {
2947           case '\'':
2948           case ',':
2949             goto do_not_strip_quotes;
2950
2951           case '\\':
2952             if (*++yyp != '\\')
2953               goto do_not_strip_quotes;
2954             /* Fall through.  */
2955           default:
2956             if (yyres)
2957               yyres[yyn] = *yyp;
2958             yyn++;
2959             break;
2960
2961           case '"':
2962             if (yyres)
2963               yyres[yyn] = '\0';
2964             return yyn;
2965           }
2966     do_not_strip_quotes: ;
2967     }
2968
2969   if (! yyres)
2970     return yystrlen (yystr);
2971
2972   return yystpcpy (yyres, yystr) - yyres;
2973 }
2974 # endif
2975
2976 /* Copy into YYRESULT an error message about the unexpected token
2977    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
2978    including the terminating null byte.  If YYRESULT is null, do not
2979    copy anything; just return the number of bytes that would be
2980    copied.  As a special case, return 0 if an ordinary "syntax error"
2981    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
2982    size calculation.  */
2983 static YYSIZE_T
2984 yysyntax_error (char *yyresult, int yystate, int yychar)
2985 {
2986   int yyn = yypact[yystate];
2987
2988   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
2989     return 0;
2990   else
2991     {
2992       int yytype = YYTRANSLATE (yychar);
2993       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
2994       YYSIZE_T yysize = yysize0;
2995       YYSIZE_T yysize1;
2996       int yysize_overflow = 0;
2997       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2998       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2999       int yyx;
3000
3001 # if 0
3002       /* This is so xgettext sees the translatable formats that are
3003          constructed on the fly.  */
3004       YY_("syntax error, unexpected %s");
3005       YY_("syntax error, unexpected %s, expecting %s");
3006       YY_("syntax error, unexpected %s, expecting %s or %s");
3007       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
3008       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
3009 # endif
3010       char *yyfmt;
3011       char const *yyf;
3012       static char const yyunexpected[] = "syntax error, unexpected %s";
3013       static char const yyexpecting[] = ", expecting %s";
3014       static char const yyor[] = " or %s";
3015       char yyformat[sizeof yyunexpected
3016                     + sizeof yyexpecting - 1
3017                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
3018                        * (sizeof yyor - 1))];
3019       char const *yyprefix = yyexpecting;
3020
3021       /* Start YYX at -YYN if negative to avoid negative indexes in
3022          YYCHECK.  */
3023       int yyxbegin = yyn < 0 ? -yyn : 0;
3024
3025       /* Stay within bounds of both yycheck and yytname.  */
3026       int yychecklim = YYLAST - yyn + 1;
3027       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
3028       int yycount = 1;
3029
3030       yyarg[0] = yytname[yytype];
3031       yyfmt = yystpcpy (yyformat, yyunexpected);
3032
3033       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
3034         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
3035           {
3036             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
3037               {
3038                 yycount = 1;
3039                 yysize = yysize0;
3040                 yyformat[sizeof yyunexpected - 1] = '\0';
3041                 break;
3042               }
3043             yyarg[yycount++] = yytname[yyx];
3044             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
3045             yysize_overflow |= (yysize1 < yysize);
3046             yysize = yysize1;
3047             yyfmt = yystpcpy (yyfmt, yyprefix);
3048             yyprefix = yyor;
3049           }
3050
3051       yyf = YY_(yyformat);
3052       yysize1 = yysize + yystrlen (yyf);
3053       yysize_overflow |= (yysize1 < yysize);
3054       yysize = yysize1;
3055
3056       if (yysize_overflow)
3057         return YYSIZE_MAXIMUM;
3058
3059       if (yyresult)
3060         {
3061           /* Avoid sprintf, as that infringes on the user's name space.
3062              Don't have undefined behavior even if the translation
3063              produced a string with the wrong number of "%s"s.  */
3064           char *yyp = yyresult;
3065           int yyi = 0;
3066           while ((*yyp = *yyf) != '\0')
3067             {
3068               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
3069                 {
3070                   yyp += yytnamerr (yyp, yyarg[yyi++]);
3071                   yyf += 2;
3072                 }
3073               else
3074                 {
3075                   yyp++;
3076                   yyf++;
3077                 }
3078             }
3079         }
3080       return yysize;
3081     }
3082 }
3083 #endif /* YYERROR_VERBOSE */
3084 \f
3085
3086 /*-----------------------------------------------.
3087 | Release the memory associated to this symbol.  |
3088 `-----------------------------------------------*/
3089
3090 /*ARGSUSED*/
3091 #if (defined __STDC__ || defined __C99__FUNC__ \
3092      || defined __cplusplus || defined _MSC_VER)
3093 static void
3094 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
3095 #else
3096 static void
3097 yydestruct (yymsg, yytype, yyvaluep)
3098     const char *yymsg;
3099     int yytype;
3100     YYSTYPE *yyvaluep;
3101 #endif
3102 {
3103   YYUSE (yyvaluep);
3104
3105   if (!yymsg)
3106     yymsg = "Deleting";
3107   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
3108
3109   switch (yytype)
3110     {
3111
3112       default:
3113         break;
3114     }
3115 }
3116 \f
3117
3118 /* Prevent warnings from -Wmissing-prototypes.  */
3119
3120 #ifdef YYPARSE_PARAM
3121 #if defined __STDC__ || defined __cplusplus
3122 int yyparse (void *YYPARSE_PARAM);
3123 #else
3124 int yyparse ();
3125 #endif
3126 #else /* ! YYPARSE_PARAM */
3127 #if defined __STDC__ || defined __cplusplus
3128 int yyparse (void);
3129 #else
3130 int yyparse ();
3131 #endif
3132 #endif /* ! YYPARSE_PARAM */
3133
3134
3135
3136 /* The look-ahead symbol.  */
3137 int yychar;
3138
3139 /* The semantic value of the look-ahead symbol.  */
3140 YYSTYPE yylval;
3141
3142 /* Number of syntax errors so far.  */
3143 int yynerrs;
3144
3145
3146
3147 /*----------.
3148 | yyparse.  |
3149 `----------*/
3150
3151 #ifdef YYPARSE_PARAM
3152 #if (defined __STDC__ || defined __C99__FUNC__ \
3153      || defined __cplusplus || defined _MSC_VER)
3154 int
3155 yyparse (void *YYPARSE_PARAM)
3156 #else
3157 int
3158 yyparse (YYPARSE_PARAM)
3159     void *YYPARSE_PARAM;
3160 #endif
3161 #else /* ! YYPARSE_PARAM */
3162 #if (defined __STDC__ || defined __C99__FUNC__ \
3163      || defined __cplusplus || defined _MSC_VER)
3164 int
3165 yyparse (void)
3166 #else
3167 int
3168 yyparse ()
3169
3170 #endif
3171 #endif
3172 {
3173   
3174   int yystate;
3175   int yyn;
3176   int yyresult;
3177   /* Number of tokens to shift before error messages enabled.  */
3178   int yyerrstatus;
3179   /* Look-ahead token as an internal (translated) token number.  */
3180   int yytoken = 0;
3181 #if YYERROR_VERBOSE
3182   /* Buffer for error messages, and its allocated size.  */
3183   char yymsgbuf[128];
3184   char *yymsg = yymsgbuf;
3185   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
3186 #endif
3187
3188   /* Three stacks and their tools:
3189      `yyss': related to states,
3190      `yyvs': related to semantic values,
3191      `yyls': related to locations.
3192
3193      Refer to the stacks thru separate pointers, to allow yyoverflow
3194      to reallocate them elsewhere.  */
3195
3196   /* The state stack.  */
3197   yytype_int16 yyssa[YYINITDEPTH];
3198   yytype_int16 *yyss = yyssa;
3199   yytype_int16 *yyssp;
3200
3201   /* The semantic value stack.  */
3202   YYSTYPE yyvsa[YYINITDEPTH];
3203   YYSTYPE *yyvs = yyvsa;
3204   YYSTYPE *yyvsp;
3205
3206
3207
3208 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
3209
3210   YYSIZE_T yystacksize = YYINITDEPTH;
3211
3212   /* The variables used to return semantic value and location from the
3213      action routines.  */
3214   YYSTYPE yyval;
3215
3216
3217   /* The number of symbols on the RHS of the reduced rule.
3218      Keep to zero when no symbol should be popped.  */
3219   int yylen = 0;
3220
3221   YYDPRINTF ((stderr, "Starting parse\n"));
3222
3223   yystate = 0;
3224   yyerrstatus = 0;
3225   yynerrs = 0;
3226   yychar = YYEMPTY;             /* Cause a token to be read.  */
3227
3228   /* Initialize stack pointers.
3229      Waste one element of value and location stack
3230      so that they stay on the same level as the state stack.
3231      The wasted elements are never initialized.  */
3232
3233   yyssp = yyss;
3234   yyvsp = yyvs;
3235
3236   goto yysetstate;
3237
3238 /*------------------------------------------------------------.
3239 | yynewstate -- Push a new state, which is found in yystate.  |
3240 `------------------------------------------------------------*/
3241  yynewstate:
3242   /* In all cases, when you get here, the value and location stacks
3243      have just been pushed.  So pushing a state here evens the stacks.  */
3244   yyssp++;
3245
3246  yysetstate:
3247   *yyssp = yystate;
3248
3249   if (yyss + yystacksize - 1 <= yyssp)
3250     {
3251       /* Get the current used size of the three stacks, in elements.  */
3252       YYSIZE_T yysize = yyssp - yyss + 1;
3253
3254 #ifdef yyoverflow
3255       {
3256         /* Give user a chance to reallocate the stack.  Use copies of
3257            these so that the &'s don't force the real ones into
3258            memory.  */
3259         YYSTYPE *yyvs1 = yyvs;
3260         yytype_int16 *yyss1 = yyss;
3261
3262
3263         /* Each stack pointer address is followed by the size of the
3264            data in use in that stack, in bytes.  This used to be a
3265            conditional around just the two extra args, but that might
3266            be undefined if yyoverflow is a macro.  */
3267         yyoverflow (YY_("memory exhausted"),
3268                     &yyss1, yysize * sizeof (*yyssp),
3269                     &yyvs1, yysize * sizeof (*yyvsp),
3270
3271                     &yystacksize);
3272
3273         yyss = yyss1;
3274         yyvs = yyvs1;
3275       }
3276 #else /* no yyoverflow */
3277 # ifndef YYSTACK_RELOCATE
3278       goto yyexhaustedlab;
3279 # else
3280       /* Extend the stack our own way.  */
3281       if (YYMAXDEPTH <= yystacksize)
3282         goto yyexhaustedlab;
3283       yystacksize *= 2;
3284       if (YYMAXDEPTH < yystacksize)
3285         yystacksize = YYMAXDEPTH;
3286
3287       {
3288         yytype_int16 *yyss1 = yyss;
3289         union yyalloc *yyptr =
3290           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
3291         if (! yyptr)
3292           goto yyexhaustedlab;
3293         YYSTACK_RELOCATE (yyss);
3294         YYSTACK_RELOCATE (yyvs);
3295
3296 #  undef YYSTACK_RELOCATE
3297         if (yyss1 != yyssa)
3298           YYSTACK_FREE (yyss1);
3299       }
3300 # endif
3301 #endif /* no yyoverflow */
3302
3303       yyssp = yyss + yysize - 1;
3304       yyvsp = yyvs + yysize - 1;
3305
3306
3307       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
3308                   (unsigned long int) yystacksize));
3309
3310       if (yyss + yystacksize - 1 <= yyssp)
3311         YYABORT;
3312     }
3313
3314   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
3315
3316   goto yybackup;
3317
3318 /*-----------.
3319 | yybackup.  |
3320 `-----------*/
3321 yybackup:
3322
3323   /* Do appropriate processing given the current state.  Read a
3324      look-ahead token if we need one and don't already have one.  */
3325
3326   /* First try to decide what to do without reference to look-ahead token.  */
3327   yyn = yypact[yystate];
3328   if (yyn == YYPACT_NINF)
3329     goto yydefault;
3330
3331   /* Not known => get a look-ahead token if don't already have one.  */
3332
3333   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
3334   if (yychar == YYEMPTY)
3335     {
3336       YYDPRINTF ((stderr, "Reading a token: "));
3337       yychar = YYLEX;
3338     }
3339
3340   if (yychar <= YYEOF)
3341     {
3342       yychar = yytoken = YYEOF;
3343       YYDPRINTF ((stderr, "Now at end of input.\n"));
3344     }
3345   else
3346     {
3347       yytoken = YYTRANSLATE (yychar);
3348       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
3349     }
3350
3351   /* If the proper action on seeing token YYTOKEN is to reduce or to
3352      detect an error, take that action.  */
3353   yyn += yytoken;
3354   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
3355     goto yydefault;
3356   yyn = yytable[yyn];
3357   if (yyn <= 0)
3358     {
3359       if (yyn == 0 || yyn == YYTABLE_NINF)
3360         goto yyerrlab;
3361       yyn = -yyn;
3362       goto yyreduce;
3363     }
3364
3365   if (yyn == YYFINAL)
3366     YYACCEPT;
3367
3368   /* Count tokens shifted since error; after three, turn off error
3369      status.  */
3370   if (yyerrstatus)
3371     yyerrstatus--;
3372
3373   /* Shift the look-ahead token.  */
3374   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
3375
3376   /* Discard the shifted token unless it is eof.  */
3377   if (yychar != YYEOF)
3378     yychar = YYEMPTY;
3379
3380   yystate = yyn;
3381   *++yyvsp = yylval;
3382
3383   goto yynewstate;
3384
3385
3386 /*-----------------------------------------------------------.
3387 | yydefault -- do the default action for the current state.  |
3388 `-----------------------------------------------------------*/
3389 yydefault:
3390   yyn = yydefact[yystate];
3391   if (yyn == 0)
3392     goto yyerrlab;
3393   goto yyreduce;
3394
3395
3396 /*-----------------------------.
3397 | yyreduce -- Do a reduction.  |
3398 `-----------------------------*/
3399 yyreduce:
3400   /* yyn is the number of a rule to reduce with.  */
3401   yylen = yyr2[yyn];
3402
3403   /* If YYLEN is nonzero, implement the default value of the action:
3404      `$$ = $1'.
3405
3406      Otherwise, the following line sets YYVAL to garbage.
3407      This behavior is undocumented and Bison
3408      users should not rely upon it.  Assigning to YYVAL
3409      unconditionally makes the parser a bit smaller, and it avoids a
3410      GCC warning that YYVAL may be used uninitialized.  */
3411   yyval = yyvsp[1-yylen];
3412
3413
3414   YY_REDUCE_PRINT (yyn);
3415   switch (yyn)
3416     {
3417         case 29:
3418 #line 1111 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
3419     { (yyval.IPredicate) = ICmpInst::ICMP_EQ; ;}
3420     break;
3421
3422   case 30:
3423 #line 1111 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
3424     { (yyval.IPredicate) = ICmpInst::ICMP_NE; ;}
3425     break;
3426
3427   case 31:
3428 #line 1112 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
3429     { (yyval.IPredicate) = ICmpInst::ICMP_SLT; ;}
3430     break;
3431
3432   case 32:
3433 #line 1112 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
3434     { (yyval.IPredicate) = ICmpInst::ICMP_SGT; ;}
3435     break;
3436
3437   case 33:
3438 #line 1113 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
3439     { (yyval.IPredicate) = ICmpInst::ICMP_SLE; ;}
3440     break;
3441
3442   case 34:
3443 #line 1113 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
3444     { (yyval.IPredicate) = ICmpInst::ICMP_SGE; ;}
3445     break;
3446
3447   case 35:
3448 #line 1114 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
3449     { (yyval.IPredicate) = ICmpInst::ICMP_ULT; ;}
3450     break;
3451
3452   case 36:
3453 #line 1114 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
3454     { (yyval.IPredicate) = ICmpInst::ICMP_UGT; ;}
3455     break;
3456
3457   case 37:
3458 #line 1115 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
3459     { (yyval.IPredicate) = ICmpInst::ICMP_ULE; ;}
3460     break;
3461
3462   case 38:
3463 #line 1115 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
3464     { (yyval.IPredicate) = ICmpInst::ICMP_UGE; ;}
3465     break;
3466
3467   case 39:
3468 #line 1119 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
3469     { (yyval.FPredicate) = FCmpInst::FCMP_OEQ; ;}
3470     break;
3471
3472   case 40:
3473 #line 1119 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
3474     { (yyval.FPredicate) = FCmpInst::FCMP_ONE; ;}
3475     break;
3476
3477   case 41:
3478 #line 1120 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"
3479     { (yyval.FPredicate) = FCmpInst::FCMP_OLT; ;}
3480     break;
3481
3482   case 42:
3483 #line 1120 "/home/asl/proj/llvm/src/lib/AsmParser/llvmAsmParser.y"