Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / external / llvm / b9240544d7250ae17b7fc252909562d0a91ea01c / . / tools / llvm-upgrade / UpgradeParser.cpp.cvs
blob: a6c4f2162c0d577ec48ba7730859fd13a65cd571 [file] [log] [blame]
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1/* A Bison parser, made by GNU Bison 2.1. */
2
3/* Skeleton parser for Yacc-like parsing with Bison,
4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
20
21/* As a special exception, when this file is copied by Bison into a
22 Bison output file, you may use that output file without restriction.
23 This special exception was added by the Free Software Foundation
24 in version 1.24 of Bison. */
25
26/* Written by Richard Stallman by simplifying the original so called
27 ``semantic'' parser. */
28
29/* All symbols defined below should begin with yy or YY, to avoid
30 infringing on user name space. This should be done even for local
31 variables, as they might otherwise be expanded by user macros.
32 There are some unavoidable exceptions within include files to
33 define necessary library symbols; they are noted "INFRINGES ON
34 USER NAME SPACE" below. */
35
36/* Identify Bison output. */
37#define YYBISON 1
38
39/* Bison version. */
40#define YYBISON_VERSION "2.1"
41
42/* Skeleton name. */
43#define YYSKELETON_NAME "yacc.c"
44
45/* Pure parsers. */
46#define YYPURE 0
47
48/* Using locations. */
49#define YYLSP_NEEDED 0
50
51/* Substitute the variable and function names. */
52#define yyparse Upgradeparse
53#define yylex Upgradelex
54#define yyerror Upgradeerror
55#define yylval Upgradelval
56#define yychar Upgradechar
57#define yydebug Upgradedebug
58#define yynerrs Upgradenerrs
59
60
61/* Tokens. */
62#ifndef YYTOKENTYPE
63# define YYTOKENTYPE
64 /* Put the tokens into the symbol table, so that GDB and other debuggers
65 know about them. */
66 enum yytokentype {
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]67 VOID = 258,
68 BOOL = 259,
69 SBYTE = 260,
70 UBYTE = 261,
71 SHORT = 262,
72 USHORT = 263,
73 INT = 264,
74 UINT = 265,
75 LONG = 266,
76 ULONG = 267,
77 FLOAT = 268,
78 DOUBLE = 269,
79 LABEL = 270,
80 OPAQUE = 271,
81 ESINT64VAL = 272,
82 EUINT64VAL = 273,
83 SINTVAL = 274,
84 UINTVAL = 275,
85 FPVAL = 276,
86 NULL_TOK = 277,
87 UNDEF = 278,
88 ZEROINITIALIZER = 279,
89 TRUETOK = 280,
90 FALSETOK = 281,
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]91 TYPE = 282,
92 VAR_ID = 283,
93 LABELSTR = 284,
94 STRINGCONSTANT = 285,
95 IMPLEMENTATION = 286,
96 BEGINTOK = 287,
97 ENDTOK = 288,
98 DECLARE = 289,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]99 GLOBAL = 290,
100 CONSTANT = 291,
101 SECTION = 292,
102 VOLATILE = 293,
103 TO = 294,
104 DOTDOTDOT = 295,
105 CONST = 296,
106 INTERNAL = 297,
107 LINKONCE = 298,
108 WEAK = 299,
109 DLLIMPORT = 300,
110 DLLEXPORT = 301,
111 EXTERN_WEAK = 302,
112 APPENDING = 303,
113 NOT = 304,
114 EXTERNAL = 305,
115 TARGET = 306,
116 TRIPLE = 307,
117 ENDIAN = 308,
118 POINTERSIZE = 309,
119 LITTLE = 310,
120 BIG = 311,
121 ALIGN = 312,
122 UNINITIALIZED = 313,
123 DEPLIBS = 314,
124 CALL = 315,
125 TAIL = 316,
126 ASM_TOK = 317,
127 MODULE = 318,
128 SIDEEFFECT = 319,
129 CC_TOK = 320,
130 CCC_TOK = 321,
131 CSRETCC_TOK = 322,
132 FASTCC_TOK = 323,
133 COLDCC_TOK = 324,
134 X86_STDCALLCC_TOK = 325,
135 X86_FASTCALLCC_TOK = 326,
136 DATALAYOUT = 327,
137 RET = 328,
138 BR = 329,
139 SWITCH = 330,
140 INVOKE = 331,
141 EXCEPT = 332,
142 UNWIND = 333,
143 UNREACHABLE = 334,
144 ADD = 335,
145 SUB = 336,
146 MUL = 337,
147 DIV = 338,
148 UDIV = 339,
149 SDIV = 340,
150 FDIV = 341,
151 REM = 342,
152 UREM = 343,
153 SREM = 344,
154 FREM = 345,
155 AND = 346,
156 OR = 347,
157 XOR = 348,
158 SETLE = 349,
159 SETGE = 350,
160 SETLT = 351,
161 SETGT = 352,
162 SETEQ = 353,
163 SETNE = 354,
164 ICMP = 355,
165 FCMP = 356,
166 EQ = 357,
167 NE = 358,
168 SLT = 359,
169 SGT = 360,
170 SLE = 361,
171 SGE = 362,
172 OEQ = 363,
173 ONE = 364,
174 OLT = 365,
175 OGT = 366,
176 OLE = 367,
177 OGE = 368,
178 ORD = 369,
179 UNO = 370,
180 UEQ = 371,
181 UNE = 372,
182 ULT = 373,
183 UGT = 374,
184 ULE = 375,
185 UGE = 376,
186 MALLOC = 377,
187 ALLOCA = 378,
188 FREE = 379,
189 LOAD = 380,
190 STORE = 381,
191 GETELEMENTPTR = 382,
192 PHI_TOK = 383,
193 SELECT = 384,
194 SHL = 385,
195 SHR = 386,
196 ASHR = 387,
197 LSHR = 388,
198 VAARG = 389,
199 EXTRACTELEMENT = 390,
200 INSERTELEMENT = 391,
201 SHUFFLEVECTOR = 392,
202 CAST = 393,
203 TRUNC = 394,
204 ZEXT = 395,
205 SEXT = 396,
206 FPTRUNC = 397,
207 FPEXT = 398,
208 FPTOUI = 399,
209 FPTOSI = 400,
210 UITOFP = 401,
211 SITOFP = 402,
212 PTRTOINT = 403,
213 INTTOPTR = 404,
214 BITCAST = 405
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]215 };
216#endif
217/* Tokens. */
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]218#define VOID 258
219#define BOOL 259
220#define SBYTE 260
221#define UBYTE 261
222#define SHORT 262
223#define USHORT 263
224#define INT 264
225#define UINT 265
226#define LONG 266
227#define ULONG 267
228#define FLOAT 268
229#define DOUBLE 269
230#define LABEL 270
231#define OPAQUE 271
232#define ESINT64VAL 272
233#define EUINT64VAL 273
234#define SINTVAL 274
235#define UINTVAL 275
236#define FPVAL 276
237#define NULL_TOK 277
238#define UNDEF 278
239#define ZEROINITIALIZER 279
240#define TRUETOK 280
241#define FALSETOK 281
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]242#define TYPE 282
243#define VAR_ID 283
244#define LABELSTR 284
245#define STRINGCONSTANT 285
246#define IMPLEMENTATION 286
247#define BEGINTOK 287
248#define ENDTOK 288
249#define DECLARE 289
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]250#define GLOBAL 290
251#define CONSTANT 291
252#define SECTION 292
253#define VOLATILE 293
254#define TO 294
255#define DOTDOTDOT 295
256#define CONST 296
257#define INTERNAL 297
258#define LINKONCE 298
259#define WEAK 299
260#define DLLIMPORT 300
261#define DLLEXPORT 301
262#define EXTERN_WEAK 302
263#define APPENDING 303
264#define NOT 304
265#define EXTERNAL 305
266#define TARGET 306
267#define TRIPLE 307
268#define ENDIAN 308
269#define POINTERSIZE 309
270#define LITTLE 310
271#define BIG 311
272#define ALIGN 312
273#define UNINITIALIZED 313
274#define DEPLIBS 314
275#define CALL 315
276#define TAIL 316
277#define ASM_TOK 317
278#define MODULE 318
279#define SIDEEFFECT 319
280#define CC_TOK 320
281#define CCC_TOK 321
282#define CSRETCC_TOK 322
283#define FASTCC_TOK 323
284#define COLDCC_TOK 324
285#define X86_STDCALLCC_TOK 325
286#define X86_FASTCALLCC_TOK 326
287#define DATALAYOUT 327
288#define RET 328
289#define BR 329
290#define SWITCH 330
291#define INVOKE 331
292#define EXCEPT 332
293#define UNWIND 333
294#define UNREACHABLE 334
295#define ADD 335
296#define SUB 336
297#define MUL 337
298#define DIV 338
299#define UDIV 339
300#define SDIV 340
301#define FDIV 341
302#define REM 342
303#define UREM 343
304#define SREM 344
305#define FREM 345
306#define AND 346
307#define OR 347
308#define XOR 348
309#define SETLE 349
310#define SETGE 350
311#define SETLT 351
312#define SETGT 352
313#define SETEQ 353
314#define SETNE 354
315#define ICMP 355
316#define FCMP 356
317#define EQ 357
318#define NE 358
319#define SLT 359
320#define SGT 360
321#define SLE 361
322#define SGE 362
323#define OEQ 363
324#define ONE 364
325#define OLT 365
326#define OGT 366
327#define OLE 367
328#define OGE 368
329#define ORD 369
330#define UNO 370
331#define UEQ 371
332#define UNE 372
333#define ULT 373
334#define UGT 374
335#define ULE 375
336#define UGE 376
337#define MALLOC 377
338#define ALLOCA 378
339#define FREE 379
340#define LOAD 380
341#define STORE 381
342#define GETELEMENTPTR 382
343#define PHI_TOK 383
344#define SELECT 384
345#define SHL 385
346#define SHR 386
347#define ASHR 387
348#define LSHR 388
349#define VAARG 389
350#define EXTRACTELEMENT 390
351#define INSERTELEMENT 391
352#define SHUFFLEVECTOR 392
353#define CAST 393
354#define TRUNC 394
355#define ZEXT 395
356#define SEXT 396
357#define FPTRUNC 397
358#define FPEXT 398
359#define FPTOUI 399
360#define FPTOSI 400
361#define UITOFP 401
362#define SITOFP 402
363#define PTRTOINT 403
364#define INTTOPTR 404
365#define BITCAST 405
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]366
367
368
369
370/* Copy the first part of user declarations. */
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]371#line 14 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]372
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]373#include "ParserInternals.h"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]374#include <algorithm>
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]375#include <map>
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]376#include <utility>
377#include <iostream>
378
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]379#define YYERROR_VERBOSE 1
Reid Spencer96839be2006-11-30 16:50:26 +0000[diff] [blame]380#define YYINCLUDED_STDLIB_H
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]381#define YYDEBUG 1
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]382
383int yylex(); // declaration" of xxx warnings.
384int yyparse();
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]385extern int yydebug;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]386
387static std::string CurFilename;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]388static std::ostream *O = 0;
Reid Spencer96839be2006-11-30 16:50:26 +0000[diff] [blame]389std::istream* LexInput = 0;
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]390unsigned SizeOfPointer = 32;
Reid Spencerf459d392006-12-02 16:19:52 +0000[diff] [blame]391static uint64_t unique = 1;
Reid Spencer96839be2006-11-30 16:50:26 +0000[diff] [blame]392
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]393// This bool controls whether attributes are ever added to function declarations
394// definitions and calls.
395static bool AddAttributes = false;
396
Reid Spencerf5626a32007-01-01 01:20:41 +0000[diff] [blame]397// This bool is used to communicate between the InstVal and Inst rules about
398// whether or not a cast should be deleted. When the flag is set, InstVal has
399// determined that the cast is a candidate. However, it can only be deleted if
400// the value being casted is the same value name as the instruction. The Inst
401// rule makes that comparison if the flag is set and comments out the
402// instruction if they match.
403static bool deleteUselessCastFlag = false;
404static std::string* deleteUselessCastName = 0;
405
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]406typedef std::vector<TypeInfo> TypeVector;
407static TypeVector EnumeratedTypes;
408typedef std::map<std::string,TypeInfo> TypeMap;
409static TypeMap NamedTypes;
Reid Spencerf12ee422006-12-05 19:21:25 +0000[diff] [blame]410static TypeMap Globals;
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]411
Reid Spencerf8483652006-12-02 15:16:01 +0000[diff] [blame]412void destroy(ValueList* VL) {
413 while (!VL->empty()) {
414 ValueInfo& VI = VL->back();
415 VI.destroy();
416 VL->pop_back();
417 }
418 delete VL;
419}
420
Reid Spencer96839be2006-11-30 16:50:26 +0000[diff] [blame]421void UpgradeAssembly(const std::string &infile, std::istream& in,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]422 std::ostream &out, bool debug, bool addAttrs)
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]423{
424 Upgradelineno = 1;
425 CurFilename = infile;
Reid Spencer96839be2006-11-30 16:50:26 +0000[diff] [blame]426 LexInput = &in;
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]427 yydebug = debug;
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]428 AddAttributes = addAttrs;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]429 O = &out;
430
431 if (yyparse()) {
432 std::cerr << "Parse failed.\n";
433 exit(1);
434 }
435}
436
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]437TypeInfo* ResolveType(TypeInfo*& Ty) {
438 if (Ty->isUnresolved()) {
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]439 if (Ty->getNewTy()[0] == '%' && isdigit(Ty->getNewTy()[1])) {
440 unsigned ref = atoi(&((Ty->getNewTy().c_str())[1])); // skip the %
441 if (ref < EnumeratedTypes.size()) {
442 Ty = &EnumeratedTypes[ref];
443 return Ty;
444 } else {
445 std::string msg("Can't resolve numbered type: ");
446 msg += Ty->getNewTy();
447 yyerror(msg.c_str());
448 }
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]449 } else {
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]450 TypeMap::iterator I = NamedTypes.find(Ty->getNewTy());
451 if (I != NamedTypes.end()) {
452 Ty = &I->second;
453 return Ty;
454 } else {
455 std::string msg("Cannot resolve type: ");
456 msg += Ty->getNewTy();
457 yyerror(msg.c_str());
458 }
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]459 }
Reid Spencer280d8012006-12-01 23:40:53 +0000[diff] [blame]460 }
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]461 // otherwise its already resolved.
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]462 return Ty;
Reid Spencer280d8012006-12-01 23:40:53 +0000[diff] [blame]463}
464
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]465static const char* getCastOpcode(
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]466 std::string& Source, const TypeInfo* SrcTy, const TypeInfo* DstTy)
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]467{
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]468 unsigned SrcBits = SrcTy->getBitWidth();
469 unsigned DstBits = DstTy->getBitWidth();
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]470 const char* opcode = "bitcast";
471 // Run through the possibilities ...
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]472 if (DstTy->isIntegral()) { // Casting to integral
473 if (SrcTy->isIntegral()) { // Casting from integral
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]474 if (DstBits < SrcBits)
475 opcode = "trunc";
476 else if (DstBits > SrcBits) { // its an extension
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]477 if (SrcTy->isSigned())
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]478 opcode ="sext"; // signed -> SEXT
479 else
480 opcode = "zext"; // unsigned -> ZEXT
481 } else {
482 opcode = "bitcast"; // Same size, No-op cast
483 }
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]484 } else if (SrcTy->isFloatingPoint()) { // Casting from floating pt
485 if (DstTy->isSigned())
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]486 opcode = "fptosi"; // FP -> sint
487 else
488 opcode = "fptoui"; // FP -> uint
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]489 } else if (SrcTy->isPacked()) {
490 assert(DstBits == SrcTy->getBitWidth() &&
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]491 "Casting packed to integer of different width");
492 opcode = "bitcast"; // same size, no-op cast
493 } else {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]494 assert(SrcTy->isPointer() &&
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]495 "Casting from a value that is not first-class type");
496 opcode = "ptrtoint"; // ptr -> int
497 }
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]498 } else if (DstTy->isFloatingPoint()) { // Casting to floating pt
499 if (SrcTy->isIntegral()) { // Casting from integral
500 if (SrcTy->isSigned())
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]501 opcode = "sitofp"; // sint -> FP
502 else
503 opcode = "uitofp"; // uint -> FP
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]504 } else if (SrcTy->isFloatingPoint()) { // Casting from floating pt
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]505 if (DstBits < SrcBits) {
506 opcode = "fptrunc"; // FP -> smaller FP
507 } else if (DstBits > SrcBits) {
508 opcode = "fpext"; // FP -> larger FP
509 } else {
510 opcode ="bitcast"; // same size, no-op cast
511 }
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]512 } else if (SrcTy->isPacked()) {
513 assert(DstBits == SrcTy->getBitWidth() &&
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]514 "Casting packed to floating point of different width");
515 opcode = "bitcast"; // same size, no-op cast
516 } else {
517 assert(0 && "Casting pointer or non-first class to float");
518 }
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]519 } else if (DstTy->isPacked()) {
520 if (SrcTy->isPacked()) {
521 assert(DstTy->getBitWidth() == SrcTy->getBitWidth() &&
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]522 "Casting packed to packed of different widths");
523 opcode = "bitcast"; // packed -> packed
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]524 } else if (DstTy->getBitWidth() == SrcBits) {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]525 opcode = "bitcast"; // float/int -> packed
526 } else {
527 assert(!"Illegal cast to packed (wrong type or size)");
528 }
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]529 } else if (DstTy->isPointer()) {
530 if (SrcTy->isPointer()) {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]531 opcode = "bitcast"; // ptr -> ptr
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]532 } else if (SrcTy->isIntegral()) {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]533 opcode = "inttoptr"; // int -> ptr
534 } else {
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]535 assert(!"Casting invalid type to pointer");
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]536 }
537 } else {
538 assert(!"Casting to type that is not first-class");
539 }
540 return opcode;
541}
542
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]543static std::string getCastUpgrade(const std::string& Src, TypeInfo* SrcTy,
544 TypeInfo* DstTy, bool isConst)
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]545{
546 std::string Result;
547 std::string Source = Src;
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]548 if (SrcTy->isFloatingPoint() && DstTy->isPointer()) {
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]549 // fp -> ptr cast is no longer supported but we must upgrade this
550 // by doing a double cast: fp -> int -> ptr
551 if (isConst)
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]552 Source = "i64 fptoui(" + Source + " to i64)";
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]553 else {
Reid Spencerf459d392006-12-02 16:19:52 +0000[diff] [blame]554 *O << " %cast_upgrade" << unique << " = fptoui " << Source
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]555 << " to i64\n";
556 Source = "i64 %cast_upgrade" + llvm::utostr(unique);
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]557 }
558 // Update the SrcTy for the getCastOpcode call below
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]559 delete SrcTy;
560 SrcTy = new TypeInfo("i64", ULongTy);
561 } else if (DstTy->isBool()) {
562 // cast type %x to bool was previously defined as setne type %x, null
563 // The cast semantic is now to truncate, not compare so we must retain
564 // the original intent by replacing the cast with a setne
565 const char* comparator = SrcTy->isPointer() ? ", null" :
566 (SrcTy->isFloatingPoint() ? ", 0.0" :
567 (SrcTy->isBool() ? ", false" : ", 0"));
568 const char* compareOp = SrcTy->isFloatingPoint() ? "fcmp one " : "icmp ne ";
Reid Spencer187ccf82006-12-09 16:57:22 +0000[diff] [blame]569 if (isConst) {
570 Result = "(" + Source + comparator + ")";
571 Result = compareOp + Result;
572 } else
573 Result = compareOp + Source + comparator;
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]574 return Result; // skip cast processing below
575 }
576 ResolveType(SrcTy);
577 ResolveType(DstTy);
578 std::string Opcode(getCastOpcode(Source, SrcTy, DstTy));
579 if (isConst)
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]580 Result += Opcode + "( " + Source + " to " + DstTy->getNewTy() + ")";
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]581 else
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]582 Result += Opcode + " " + Source + " to " + DstTy->getNewTy();
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]583 return Result;
584}
585
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]586const char* getDivRemOpcode(const std::string& opcode, TypeInfo* TI) {
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]587 const char* op = opcode.c_str();
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]588 const TypeInfo* Ty = ResolveType(TI);
589 if (Ty->isPacked())
590 Ty = Ty->getElementType();
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]591 if (opcode == "div")
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]592 if (Ty->isFloatingPoint())
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]593 op = "fdiv";
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]594 else if (Ty->isUnsigned())
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]595 op = "udiv";
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]596 else if (Ty->isSigned())
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]597 op = "sdiv";
598 else
599 yyerror("Invalid type for div instruction");
600 else if (opcode == "rem")
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]601 if (Ty->isFloatingPoint())
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]602 op = "frem";
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]603 else if (Ty->isUnsigned())
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]604 op = "urem";
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]605 else if (Ty->isSigned())
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]606 op = "srem";
607 else
608 yyerror("Invalid type for rem instruction");
609 return op;
610}
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]611
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]612std::string
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]613getCompareOp(const std::string& setcc, const TypeInfo* TI) {
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]614 assert(setcc.length() == 5);
615 char cc1 = setcc[3];
616 char cc2 = setcc[4];
617 assert(cc1 == 'e' || cc1 == 'n' || cc1 == 'l' || cc1 == 'g');
618 assert(cc2 == 'q' || cc2 == 'e' || cc2 == 'e' || cc2 == 't');
619 std::string result("xcmp xxx");
620 result[6] = cc1;
621 result[7] = cc2;
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]622 if (TI->isFloatingPoint()) {
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]623 result[0] = 'f';
Reid Spencere4d87aa2006-12-23 06:05:41 +0000[diff] [blame]624 result[5] = 'o';
Reid Spencerf0cf1322006-12-07 04:23:03 +0000[diff] [blame]625 if (cc1 == 'n')
626 result[5] = 'u'; // NE maps to unordered
627 else
628 result[5] = 'o'; // everything else maps to ordered
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]629 } else if (TI->isIntegral() || TI->isPointer()) {
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]630 result[0] = 'i';
631 if ((cc1 == 'e' && cc2 == 'q') || (cc1 == 'n' && cc2 == 'e'))
632 result.erase(5,1);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]633 else if (TI->isSigned())
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]634 result[5] = 's';
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]635 else if (TI->isUnsigned() || TI->isPointer() || TI->isBool())
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]636 result[5] = 'u';
637 else
638 yyerror("Invalid integral type for setcc");
639 }
640 return result;
641}
642
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]643static TypeInfo* getFunctionReturnType(TypeInfo* PFTy) {
644 ResolveType(PFTy);
645 if (PFTy->isPointer()) {
646 TypeInfo* ElemTy = PFTy->getElementType();
647 ResolveType(ElemTy);
648 if (ElemTy->isFunction())
649 return ElemTy->getResultType()->clone();
650 } else if (PFTy->isFunction()) {
651 return PFTy->getResultType()->clone();
652 }
653 return PFTy->clone();
654}
655
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]656typedef std::vector<TypeInfo*> UpRefStack;
657static TypeInfo* ResolveUpReference(TypeInfo* Ty, UpRefStack* stack) {
658 assert(Ty->isUpReference() && "Can't resolve a non-upreference");
659 unsigned upref = atoi(&((Ty->getNewTy().c_str())[1])); // skip the slash
660 assert(upref < stack->size() && "Invalid up reference");
661 return (*stack)[upref - stack->size() - 1];
662}
663
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]664static TypeInfo* getGEPIndexedType(TypeInfo* PTy, ValueList* idxs) {
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]665 TypeInfo* Result = ResolveType(PTy);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]666 assert(PTy->isPointer() && "GEP Operand is not a pointer?");
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]667 UpRefStack stack;
668 for (unsigned i = 0; i < idxs->size(); ++i) {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]669 if (Result->isComposite()) {
670 Result = Result->getIndexedType((*idxs)[i]);
671 ResolveType(Result);
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]672 stack.push_back(Result);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]673 } else
674 yyerror("Invalid type for index");
675 }
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]676 // Resolve upreferences so we can return a more natural type
677 if (Result->isPointer()) {
678 if (Result->getElementType()->isUpReference()) {
679 stack.push_back(Result);
680 Result = ResolveUpReference(Result->getElementType(), &stack);
681 }
682 } else if (Result->isUpReference()) {
683 Result = ResolveUpReference(Result->getElementType(), &stack);
684 }
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]685 return Result->getPointerType();
686}
687
688static std::string makeUniqueName(const std::string *Name, bool isSigned) {
689 const char *suffix = ".u";
690 if (isSigned)
691 suffix = ".s";
692 if ((*Name)[Name->size()-1] == '"') {
693 std::string Result(*Name);
694 Result.insert(Name->size()-1, suffix);
695 return Result;
696 }
697 return *Name + suffix;
698}
699
700// This function handles appending .u or .s to integer value names that
701// were previously unsigned or signed, respectively. This avoids name
702// collisions since the unsigned and signed type planes have collapsed
703// into a single signless type plane.
704static std::string getUniqueName(const std::string *Name, TypeInfo* Ty) {
705 // If its not a symbolic name, don't modify it, probably a constant val.
706 if ((*Name)[0] != '%' && (*Name)[0] != '"')
707 return *Name;
708 // If its a numeric reference, just leave it alone.
709 if (isdigit((*Name)[1]))
710 return *Name;
711
712 // Resolve the type
713 ResolveType(Ty);
714
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]715 // Remove as many levels of pointer nesting that we have.
716 if (Ty->isPointer()) {
717 // Avoid infinite loops in recursive types
718 TypeInfo* Last = 0;
719 while (Ty->isPointer() && Last != Ty) {
720 Last = Ty;
721 Ty = Ty->getElementType();
722 ResolveType(Ty);
723 }
724 }
725
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]726 // Default the result to the current name
727 std::string Result = *Name;
728
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]729 // Now deal with the underlying type
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]730 if (Ty->isInteger()) {
731 // If its an integer type, make the name unique
732 Result = makeUniqueName(Name, Ty->isSigned());
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]733 } else if (Ty->isArray() || Ty->isPacked()) {
734 Ty = Ty->getElementType();
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]735 if (Ty->isInteger())
736 Result = makeUniqueName(Name, Ty->isSigned());
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]737 } else if (Ty->isStruct()) {
738 // Scan the fields and count the signed and unsigned fields
739 int isSigned = 0;
740 for (unsigned i = 0; i < Ty->getNumStructElements(); ++i) {
741 TypeInfo* Tmp = Ty->getElement(i);
742 if (Tmp->isInteger())
743 if (Tmp->isSigned())
744 isSigned++;
745 else
746 isSigned--;
747 }
748 if (isSigned != 0)
749 Result = makeUniqueName(Name, isSigned > 0);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]750 }
751 return Result;
752}
753
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]754
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]755
756/* Enabling traces. */
757#ifndef YYDEBUG
758# define YYDEBUG 0
759#endif
760
761/* Enabling verbose error messages. */
762#ifdef YYERROR_VERBOSE
763# undef YYERROR_VERBOSE
764# define YYERROR_VERBOSE 1
765#else
766# define YYERROR_VERBOSE 0
767#endif
768
769/* Enabling the token table. */
770#ifndef YYTOKEN_TABLE
771# define YYTOKEN_TABLE 0
772#endif
773
774#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]775#line 400 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]776typedef union YYSTYPE {
777 std::string* String;
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]778 TypeInfo* Type;
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]779 ValueInfo Value;
780 ConstInfo Const;
Reid Spencerf8483652006-12-02 15:16:01 +0000[diff] [blame]781 ValueList* ValList;
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]782 TypeList* TypeVec;
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]783} YYSTYPE;
784/* Line 196 of yacc.c. */
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]785#line 786 "UpgradeParser.tab.c"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]786# define yystype YYSTYPE /* obsolescent; will be withdrawn */
787# define YYSTYPE_IS_DECLARED 1
788# define YYSTYPE_IS_TRIVIAL 1
789#endif
790
791
792
793/* Copy the second part of user declarations. */
794
795
796/* Line 219 of yacc.c. */
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]797#line 798 "UpgradeParser.tab.c"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]798
799#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
800# define YYSIZE_T __SIZE_TYPE__
801#endif
802#if ! defined (YYSIZE_T) && defined (size_t)
803# define YYSIZE_T size_t
804#endif
805#if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
806# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
807# define YYSIZE_T size_t
808#endif
809#if ! defined (YYSIZE_T)
810# define YYSIZE_T unsigned int
811#endif
812
813#ifndef YY_
814# if YYENABLE_NLS
815# if ENABLE_NLS
816# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
817# define YY_(msgid) dgettext ("bison-runtime", msgid)
818# endif
819# endif
820# ifndef YY_
821# define YY_(msgid) msgid
822# endif
823#endif
824
825#if ! defined (yyoverflow) || YYERROR_VERBOSE
826
827/* The parser invokes alloca or malloc; define the necessary symbols. */
828
829# ifdef YYSTACK_USE_ALLOCA
830# if YYSTACK_USE_ALLOCA
831# ifdef __GNUC__
832# define YYSTACK_ALLOC __builtin_alloca
833# else
834# define YYSTACK_ALLOC alloca
835# if defined (__STDC__) || defined (__cplusplus)
836# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
837# define YYINCLUDED_STDLIB_H
838# endif
839# endif
840# endif
841# endif
842
843# ifdef YYSTACK_ALLOC
844 /* Pacify GCC's `empty if-body' warning. */
845# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
846# ifndef YYSTACK_ALLOC_MAXIMUM
847 /* The OS might guarantee only one guard page at the bottom of the stack,
848 and a page size can be as small as 4096 bytes. So we cannot safely
849 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
850 to allow for a few compiler-allocated temporary stack slots. */
851# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
852# endif
853# else
854# define YYSTACK_ALLOC YYMALLOC
855# define YYSTACK_FREE YYFREE
856# ifndef YYSTACK_ALLOC_MAXIMUM
857# define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
858# endif
859# ifdef __cplusplus
860extern "C" {
861# endif
862# ifndef YYMALLOC
863# define YYMALLOC malloc
864# if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
865 && (defined (__STDC__) || defined (__cplusplus)))
866void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
867# endif
868# endif
869# ifndef YYFREE
870# define YYFREE free
871# if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
872 && (defined (__STDC__) || defined (__cplusplus)))
873void free (void *); /* INFRINGES ON USER NAME SPACE */
874# endif
875# endif
876# ifdef __cplusplus
877}
878# endif
879# endif
880#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
881
882
883#if (! defined (yyoverflow) \
884 && (! defined (__cplusplus) \
885 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
886
887/* A type that is properly aligned for any stack member. */
888union yyalloc
889{
890 short int yyss;
891 YYSTYPE yyvs;
892 };
893
894/* The size of the maximum gap between one aligned stack and the next. */
895# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
896
897/* The size of an array large to enough to hold all stacks, each with
898 N elements. */
899# define YYSTACK_BYTES(N) \
900 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
901 + YYSTACK_GAP_MAXIMUM)
902
903/* Copy COUNT objects from FROM to TO. The source and destination do
904 not overlap. */
905# ifndef YYCOPY
906# if defined (__GNUC__) && 1 < __GNUC__
907# define YYCOPY(To, From, Count) \
908 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
909# else
910# define YYCOPY(To, From, Count) \
911 do \
912 { \
913 YYSIZE_T yyi; \
914 for (yyi = 0; yyi < (Count); yyi++) \
915 (To)[yyi] = (From)[yyi]; \
916 } \
917 while (0)
918# endif
919# endif
920
921/* Relocate STACK from its old location to the new one. The
922 local variables YYSIZE and YYSTACKSIZE give the old and new number of
923 elements in the stack, and YYPTR gives the new location of the
924 stack. Advance YYPTR to a properly aligned location for the next
925 stack. */
926# define YYSTACK_RELOCATE(Stack) \
927 do \
928 { \
929 YYSIZE_T yynewbytes; \
930 YYCOPY (&yyptr->Stack, Stack, yysize); \
931 Stack = &yyptr->Stack; \
932 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
933 yyptr += yynewbytes / sizeof (*yyptr); \
934 } \
935 while (0)
936
937#endif
938
939#if defined (__STDC__) || defined (__cplusplus)
940 typedef signed char yysigned_char;
941#else
942 typedef short int yysigned_char;
943#endif
944
945/* YYFINAL -- State number of the termination state. */
946#define YYFINAL 4
947/* YYLAST -- Last index in YYTABLE. */
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]948#define YYLAST 1486
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]949
950/* YYNTOKENS -- Number of terminals. */
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]951#define YYNTOKENS 165
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]952/* YYNNTS -- Number of nonterminals. */
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]953#define YYNNTS 75
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]954/* YYNRULES -- Number of rules. */
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]955#define YYNRULES 301
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]956/* YYNRULES -- Number of states. */
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]957#define YYNSTATES 586
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]958
959/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
960#define YYUNDEFTOK 2
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]961#define YYMAXUTOK 405
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]962
963#define YYTRANSLATE(YYX) \
964 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
965
966/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
967static const unsigned char yytranslate[] =
968{
969 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
970 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
971 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
972 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]973 154, 155, 163, 2, 152, 2, 2, 2, 2, 2,
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]974 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]975 159, 151, 160, 2, 2, 2, 2, 2, 2, 2,
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]976 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
977 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]978 2, 156, 153, 158, 2, 2, 2, 2, 2, 164,
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]979 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
980 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]981 157, 2, 2, 161, 2, 162, 2, 2, 2, 2,
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]982 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
983 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
984 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
985 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
986 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
987 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
988 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
989 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
990 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
991 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
992 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
993 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
994 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
995 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
996 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
997 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
998 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
999 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1000 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1001 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
1002 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
1003 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
1004 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
Reid Spencerfcb5df82006-12-01 22:34:43 +0000[diff] [blame]1005 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]1006 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]1007 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
1008 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1009 145, 146, 147, 148, 149, 150
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1010};
1011
1012#if YYDEBUG
1013/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1014 YYRHS. */
1015static const unsigned short int yyprhs[] =
1016{
1017 0, 0, 3, 5, 7, 9, 11, 13, 15, 17,
1018 19, 21, 23, 25, 27, 29, 31, 33, 35, 37,
1019 39, 41, 43, 45, 47, 49, 51, 53, 55, 57,
1020 59, 61, 63, 65, 67, 69, 71, 73, 75, 77,
Reid Spencerfcb5df82006-12-01 22:34:43 +0000[diff] [blame]1021 79, 81, 83, 85, 87, 89, 91, 93, 95, 97,
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]1022 99, 101, 103, 105, 107, 109, 111, 113, 115, 117,
1023 119, 121, 123, 125, 127, 129, 131, 133, 135, 137,
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]1024 139, 141, 143, 145, 147, 149, 151, 153, 155, 157,
1025 159, 161, 164, 165, 167, 169, 171, 173, 175, 177,
1026 179, 180, 182, 184, 186, 188, 190, 192, 195, 196,
1027 197, 200, 201, 205, 208, 209, 211, 212, 216, 218,
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]1028 221, 223, 225, 227, 229, 231, 233, 235, 237, 239,
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]1029 241, 243, 245, 247, 249, 251, 253, 255, 257, 259,
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]1030 261, 264, 269, 275, 281, 285, 288, 294, 299, 302,
1031 304, 308, 310, 314, 316, 317, 322, 326, 330, 335,
1032 340, 344, 347, 350, 353, 356, 359, 362, 365, 368,
1033 371, 374, 381, 387, 396, 403, 410, 417, 425, 433,
1034 440, 447, 456, 465, 469, 471, 473, 475, 477, 480,
1035 483, 488, 491, 493, 495, 497, 502, 505, 510, 517,
1036 524, 531, 538, 542, 547, 548, 550, 552, 554, 558,
1037 562, 566, 570, 574, 578, 580, 581, 583, 585, 587,
1038 588, 591, 595, 597, 599, 603, 605, 606, 615, 617,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1039 619, 623, 625, 627, 631, 632, 634, 636, 640, 641,
1040 643, 645, 647, 649, 651, 653, 655, 657, 659, 663,
1041 665, 671, 673, 675, 677, 679, 682, 685, 687, 690,
1042 693, 694, 696, 698, 700, 703, 706, 710, 720, 730,
1043 739, 754, 756, 758, 765, 771, 774, 781, 789, 791,
1044 795, 797, 798, 801, 803, 809, 815, 821, 828, 835,
1045 838, 843, 848, 855, 860, 865, 872, 879, 882, 890,
1046 892, 895, 896, 898, 899, 903, 910, 914, 921, 924,
1047 929, 936
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1048};
1049
1050/* YYRHS -- A `-1'-separated list of the rules' RHS. */
1051static const short int yyrhs[] =
1052{
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1053 199, 0, -1, 19, -1, 20, -1, 17, -1, 18,
1054 -1, 80, -1, 81, -1, 82, -1, 83, -1, 84,
1055 -1, 85, -1, 86, -1, 87, -1, 88, -1, 89,
1056 -1, 90, -1, 91, -1, 92, -1, 93, -1, 94,
1057 -1, 95, -1, 96, -1, 97, -1, 98, -1, 99,
1058 -1, 102, -1, 103, -1, 104, -1, 105, -1, 106,
1059 -1, 107, -1, 118, -1, 119, -1, 120, -1, 121,
1060 -1, 108, -1, 109, -1, 110, -1, 111, -1, 112,
1061 -1, 113, -1, 114, -1, 115, -1, 116, -1, 117,
1062 -1, 118, -1, 119, -1, 120, -1, 121, -1, 25,
1063 -1, 26, -1, 130, -1, 131, -1, 132, -1, 133,
1064 -1, 139, -1, 140, -1, 141, -1, 142, -1, 143,
1065 -1, 144, -1, 145, -1, 146, -1, 147, -1, 148,
1066 -1, 149, -1, 150, -1, 138, -1, 11, -1, 9,
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]1067 -1, 7, -1, 5, -1, 12, -1, 10, -1, 8,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1068 -1, 6, -1, 175, -1, 176, -1, 13, -1, 14,
1069 -1, 208, 151, -1, -1, 42, -1, 43, -1, 44,
1070 -1, 48, -1, 45, -1, 46, -1, 47, -1, -1,
1071 66, -1, 67, -1, 68, -1, 69, -1, 70, -1,
1072 71, -1, 65, 18, -1, -1, -1, 57, 18, -1,
1073 -1, 152, 57, 18, -1, 37, 30, -1, -1, 184,
1074 -1, -1, 152, 187, 186, -1, 184, -1, 57, 18,
1075 -1, 190, -1, 3, -1, 192, -1, 3, -1, 192,
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]1076 -1, 4, -1, 5, -1, 6, -1, 7, -1, 8,
1077 -1, 9, -1, 10, -1, 11, -1, 12, -1, 13,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1078 -1, 14, -1, 15, -1, 16, -1, 222, -1, 191,
1079 -1, 153, 18, -1, 189, 154, 194, 155, -1, 156,
1080 18, 157, 192, 158, -1, 159, 18, 157, 192, 160,
1081 -1, 161, 193, 162, -1, 161, 162, -1, 159, 161,
1082 193, 162, 160, -1, 159, 161, 162, 160, -1, 192,
1083 163, -1, 192, -1, 193, 152, 192, -1, 193, -1,
1084 193, 152, 40, -1, 40, -1, -1, 190, 156, 197,
1085 158, -1, 190, 156, 158, -1, 190, 164, 30, -1,
1086 190, 159, 197, 160, -1, 190, 161, 197, 162, -1,
1087 190, 161, 162, -1, 190, 22, -1, 190, 23, -1,
1088 190, 222, -1, 190, 196, -1, 190, 24, -1, 175,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1089 167, -1, 176, 167, -1, 4, 25, -1, 4, 26,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1090 -1, 178, 21, -1, 174, 154, 195, 39, 190, 155,
1091 -1, 127, 154, 195, 237, 155, -1, 129, 154, 195,
1092 152, 195, 152, 195, 155, -1, 168, 154, 195, 152,
1093 195, 155, -1, 169, 154, 195, 152, 195, 155, -1,
1094 170, 154, 195, 152, 195, 155, -1, 100, 171, 154,
1095 195, 152, 195, 155, -1, 101, 172, 154, 195, 152,
1096 195, 155, -1, 173, 154, 195, 152, 195, 155, -1,
1097 135, 154, 195, 152, 195, 155, -1, 136, 154, 195,
1098 152, 195, 152, 195, 155, -1, 137, 154, 195, 152,
1099 195, 152, 195, 155, -1, 197, 152, 195, -1, 195,
1100 -1, 35, -1, 36, -1, 200, -1, 200, 217, -1,
1101 200, 219, -1, 200, 63, 62, 203, -1, 200, 31,
1102 -1, 202, -1, 50, -1, 58, -1, 202, 179, 27,
1103 188, -1, 202, 219, -1, 202, 63, 62, 203, -1,
1104 202, 179, 180, 198, 195, 186, -1, 202, 179, 201,
1105 198, 190, 186, -1, 202, 179, 45, 198, 190, 186,
1106 -1, 202, 179, 47, 198, 190, 186, -1, 202, 51,
1107 205, -1, 202, 59, 151, 206, -1, -1, 30, -1,
1108 56, -1, 55, -1, 53, 151, 204, -1, 54, 151,
1109 18, -1, 52, 151, 30, -1, 72, 151, 30, -1,
1110 156, 207, 158, -1, 207, 152, 30, -1, 30, -1,
1111 -1, 28, -1, 30, -1, 208, -1, -1, 190, 209,
1112 -1, 211, 152, 210, -1, 210, -1, 211, -1, 211,
1113 152, 40, -1, 40, -1, -1, 181, 188, 208, 154,
1114 212, 155, 185, 182, -1, 32, -1, 161, -1, 180,
1115 213, 214, -1, 33, -1, 162, -1, 215, 225, 216,
1116 -1, -1, 45, -1, 47, -1, 34, 218, 213, -1,
1117 -1, 64, -1, 17, -1, 18, -1, 21, -1, 25,
1118 -1, 26, -1, 22, -1, 23, -1, 24, -1, 159,
1119 197, 160, -1, 196, -1, 62, 220, 30, 152, 30,
1120 -1, 166, -1, 208, -1, 222, -1, 221, -1, 190,
1121 223, -1, 225, 226, -1, 226, -1, 227, 229, -1,
1122 227, 231, -1, -1, 29, -1, 78, -1, 77, -1,
1123 73, 224, -1, 73, 3, -1, 74, 15, 223, -1,
1124 74, 4, 223, 152, 15, 223, 152, 15, 223, -1,
1125 75, 177, 223, 152, 15, 223, 156, 230, 158, -1,
1126 75, 177, 223, 152, 15, 223, 156, 158, -1, 179,
1127 76, 181, 188, 223, 154, 234, 155, 39, 15, 223,
1128 228, 15, 223, -1, 228, -1, 79, -1, 230, 177,
1129 221, 152, 15, 223, -1, 177, 221, 152, 15, 223,
1130 -1, 179, 236, -1, 190, 156, 223, 152, 223, 158,
1131 -1, 232, 152, 156, 223, 152, 223, 158, -1, 224,
1132 -1, 233, 152, 224, -1, 233, -1, -1, 61, 60,
1133 -1, 60, -1, 168, 190, 223, 152, 223, -1, 169,
1134 190, 223, 152, 223, -1, 170, 190, 223, 152, 223,
1135 -1, 100, 171, 190, 223, 152, 223, -1, 101, 172,
1136 190, 223, 152, 223, -1, 49, 224, -1, 173, 224,
1137 152, 224, -1, 174, 224, 39, 190, -1, 129, 224,
1138 152, 224, 152, 224, -1, 134, 224, 152, 190, -1,
1139 135, 224, 152, 224, -1, 136, 224, 152, 224, 152,
1140 224, -1, 137, 224, 152, 224, 152, 224, -1, 128,
1141 232, -1, 235, 181, 188, 223, 154, 234, 155, -1,
1142 239, -1, 152, 233, -1, -1, 38, -1, -1, 122,
1143 190, 183, -1, 122, 190, 152, 10, 223, 183, -1,
1144 123, 190, 183, -1, 123, 190, 152, 10, 223, 183,
1145 -1, 124, 224, -1, 238, 125, 190, 223, -1, 238,
1146 126, 224, 152, 190, 223, -1, 127, 190, 223, 237,
1147 -1
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1148};
1149
1150/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1151static const unsigned short int yyrline[] =
1152{
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]1153 0, 465, 465, 465, 466, 466, 470, 470, 470, 470,
1154 470, 470, 470, 471, 471, 471, 471, 472, 472, 472,
1155 473, 473, 473, 473, 473, 473, 474, 474, 474, 474,
1156 474, 474, 474, 474, 474, 474, 475, 475, 475, 475,
1157 475, 475, 475, 475, 475, 475, 476, 476, 476, 476,
1158 476, 476, 477, 477, 477, 477, 478, 478, 478, 478,
1159 478, 478, 478, 479, 479, 479, 479, 479, 479, 484,
1160 484, 484, 484, 485, 485, 485, 485, 486, 486, 487,
1161 487, 490, 493, 498, 498, 498, 498, 498, 498, 499,
1162 500, 503, 503, 503, 503, 503, 504, 505, 510, 515,
1163 516, 519, 520, 528, 534, 535, 538, 539, 548, 549,
1164 562, 562, 563, 563, 564, 568, 568, 568, 568, 568,
1165 568, 568, 569, 569, 569, 569, 569, 571, 574, 577,
1166 580, 584, 597, 603, 609, 619, 622, 632, 635, 643,
1167 647, 654, 655, 660, 665, 675, 681, 686, 692, 698,
1168 704, 709, 715, 721, 728, 734, 740, 746, 752, 758,
1169 764, 772, 785, 797, 802, 808, 813, 819, 824, 829,
1170 837, 842, 847, 857, 862, 867, 867, 877, 882, 885,
1171 890, 894, 898, 900, 900, 903, 913, 918, 923, 933,
1172 943, 953, 963, 968, 973, 978, 980, 980, 983, 988,
1173 995, 1000, 1007, 1014, 1019, 1020, 1028, 1028, 1029, 1029,
1174 1031, 1040, 1044, 1048, 1051, 1056, 1059, 1062, 1080, 1081,
1175 1084, 1095, 1096, 1098, 1107, 1108, 1109, 1113, 1126, 1127,
1176 1130, 1130, 1130, 1130, 1130, 1130, 1130, 1131, 1132, 1137,
1177 1138, 1147, 1147, 1151, 1156, 1166, 1176, 1179, 1187, 1191,
1178 1196, 1199, 1205, 1205, 1207, 1212, 1217, 1222, 1231, 1239,
1179 1246, 1269, 1274, 1280, 1286, 1294, 1312, 1320, 1329, 1333,
1180 1340, 1341, 1345, 1350, 1353, 1362, 1370, 1379, 1387, 1395,
1181 1400, 1409, 1437, 1443, 1449, 1456, 1462, 1468, 1474, 1492,
1182 1497, 1498, 1502, 1503, 1506, 1514, 1523, 1531, 1540, 1546,
1183 1555, 1564
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1184};
1185#endif
1186
1187#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1188/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1189 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1190static const char *const yytname[] =
1191{
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]1192 "$end", "error", "$undefined", "VOID", "BOOL", "SBYTE", "UBYTE",
1193 "SHORT", "USHORT", "INT", "UINT", "LONG", "ULONG", "FLOAT", "DOUBLE",
1194 "LABEL", "OPAQUE", "ESINT64VAL", "EUINT64VAL", "SINTVAL", "UINTVAL",
1195 "FPVAL", "NULL_TOK", "UNDEF", "ZEROINITIALIZER", "TRUETOK", "FALSETOK",
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]1196 "TYPE", "VAR_ID", "LABELSTR", "STRINGCONSTANT", "IMPLEMENTATION",
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1197 "BEGINTOK", "ENDTOK", "DECLARE", "GLOBAL", "CONSTANT", "SECTION",
1198 "VOLATILE", "TO", "DOTDOTDOT", "CONST", "INTERNAL", "LINKONCE", "WEAK",
1199 "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "APPENDING", "NOT", "EXTERNAL",
1200 "TARGET", "TRIPLE", "ENDIAN", "POINTERSIZE", "LITTLE", "BIG", "ALIGN",
1201 "UNINITIALIZED", "DEPLIBS", "CALL", "TAIL", "ASM_TOK", "MODULE",
1202 "SIDEEFFECT", "CC_TOK", "CCC_TOK", "CSRETCC_TOK", "FASTCC_TOK",
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]1203 "COLDCC_TOK", "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT",
1204 "RET", "BR", "SWITCH", "INVOKE", "EXCEPT", "UNWIND", "UNREACHABLE",
1205 "ADD", "SUB", "MUL", "DIV", "UDIV", "SDIV", "FDIV", "REM", "UREM",
1206 "SREM", "FREM", "AND", "OR", "XOR", "SETLE", "SETGE", "SETLT", "SETGT",
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]1207 "SETEQ", "SETNE", "ICMP", "FCMP", "EQ", "NE", "SLT", "SGT", "SLE", "SGE",
1208 "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE", "ORD", "UNO", "UEQ", "UNE",
1209 "ULT", "UGT", "ULE", "UGE", "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE",
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]1210 "GETELEMENTPTR", "PHI_TOK", "SELECT", "SHL", "SHR", "ASHR", "LSHR",
1211 "VAARG", "EXTRACTELEMENT", "INSERTELEMENT", "SHUFFLEVECTOR", "CAST",
1212 "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT", "FPTOUI", "FPTOSI",
1213 "UITOFP", "SITOFP", "PTRTOINT", "INTTOPTR", "BITCAST", "'='", "','",
1214 "'\\\\'", "'('", "')'", "'['", "'x'", "']'", "'<'", "'>'", "'{'", "'}'",
1215 "'*'", "'c'", "$accept", "IntVal", "EInt64Val", "ArithmeticOps",
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]1216 "LogicalOps", "SetCondOps", "IPredicates", "FPredicates", "ShiftOps",
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]1217 "CastOps", "SIntType", "UIntType", "IntType", "FPType", "OptAssign",
1218 "OptLinkage", "OptCallingConv", "OptAlign", "OptCAlign", "SectionString",
1219 "OptSection", "GlobalVarAttributes", "GlobalVarAttribute", "TypesV",
1220 "UpRTypesV", "Types", "PrimType", "UpRTypes", "TypeListI",
1221 "ArgTypeListI", "ConstVal", "ConstExpr", "ConstVector", "GlobalType",
1222 "Module", "DefinitionList", "External", "ConstPool", "AsmBlock",
1223 "BigOrLittle", "TargetDefinition", "LibrariesDefinition", "LibList",
1224 "Name", "OptName", "ArgVal", "ArgListH", "ArgList", "FunctionHeaderH",
1225 "BEGIN", "FunctionHeader", "END", "Function", "FnDeclareLinkage",
1226 "FunctionProto", "OptSideEffect", "ConstValueRef", "SymbolicValueRef",
1227 "ValueRef", "ResolvedVal", "BasicBlockList", "BasicBlock",
1228 "InstructionList", "Unwind", "BBTerminatorInst", "JumpTable", "Inst",
1229 "PHIList", "ValueRefList", "ValueRefListE", "OptTailCall", "InstVal",
1230 "IndexList", "OptVolatile", "MemoryInst", 0
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1231};
1232#endif
1233
1234# ifdef YYPRINT
1235/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1236 token YYLEX-NUM. */
1237static const unsigned short int yytoknum[] =
1238{
1239 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1240 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1241 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1242 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1243 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1244 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1245 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
1246 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
1247 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
1248 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
1249 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
Reid Spencerfcb5df82006-12-01 22:34:43 +0000[diff] [blame]1250 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]1251 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
1252 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
1253 395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1254 405, 61, 44, 92, 40, 41, 91, 120, 93, 60,
1255 62, 123, 125, 42, 99
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1256};
1257# endif
1258
1259/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1260static const unsigned char yyr1[] =
1261{
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1262 0, 165, 166, 166, 167, 167, 168, 168, 168, 168,
1263 168, 168, 168, 168, 168, 168, 168, 169, 169, 169,
1264 170, 170, 170, 170, 170, 170, 171, 171, 171, 171,
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]1265 171, 171, 171, 171, 171, 171, 172, 172, 172, 172,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1266 172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
1267 172, 172, 173, 173, 173, 173, 174, 174, 174, 174,
1268 174, 174, 174, 174, 174, 174, 174, 174, 174, 175,
1269 175, 175, 175, 176, 176, 176, 176, 177, 177, 178,
1270 178, 179, 179, 180, 180, 180, 180, 180, 180, 180,
1271 180, 181, 181, 181, 181, 181, 181, 181, 181, 182,
1272 182, 183, 183, 184, 185, 185, 186, 186, 187, 187,
1273 188, 188, 189, 189, 190, 191, 191, 191, 191, 191,
1274 191, 191, 191, 191, 191, 191, 191, 192, 192, 192,
1275 192, 192, 192, 192, 192, 192, 192, 192, 192, 193,
1276 193, 194, 194, 194, 194, 195, 195, 195, 195, 195,
1277 195, 195, 195, 195, 195, 195, 195, 195, 195, 195,
1278 195, 196, 196, 196, 196, 196, 196, 196, 196, 196,
1279 196, 196, 196, 197, 197, 198, 198, 199, 200, 200,
1280 200, 200, 200, 201, 201, 202, 202, 202, 202, 202,
1281 202, 202, 202, 202, 202, 203, 204, 204, 205, 205,
1282 205, 205, 206, 207, 207, 207, 208, 208, 209, 209,
1283 210, 211, 211, 212, 212, 212, 212, 213, 214, 214,
1284 215, 216, 216, 217, 218, 218, 218, 219, 220, 220,
1285 221, 221, 221, 221, 221, 221, 221, 221, 221, 221,
1286 221, 222, 222, 223, 223, 224, 225, 225, 226, 227,
1287 227, 227, 228, 228, 229, 229, 229, 229, 229, 229,
1288 229, 229, 229, 230, 230, 231, 232, 232, 233, 233,
1289 234, 234, 235, 235, 236, 236, 236, 236, 236, 236,
1290 236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
1291 237, 237, 238, 238, 239, 239, 239, 239, 239, 239,
1292 239, 239
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1293};
1294
1295/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1296static const unsigned char yyr2[] =
1297{
1298 0, 2, 1, 1, 1, 1, 1, 1, 1, 1,
1299 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1300 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1301 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
Reid Spencerf7bde222006-12-01 22:26:37 +0000[diff] [blame]1302 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
Reid Spencerfcb5df82006-12-01 22:34:43 +0000[diff] [blame]1303 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]1304 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]1305 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]1306 1, 2, 0, 1, 1, 1, 1, 1, 1, 1,
1307 0, 1, 1, 1, 1, 1, 1, 2, 0, 0,
1308 2, 0, 3, 2, 0, 1, 0, 3, 1, 2,
1309 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1310 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]1311 2, 4, 5, 5, 3, 2, 5, 4, 2, 1,
1312 3, 1, 3, 1, 0, 4, 3, 3, 4, 4,
1313 3, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1314 2, 6, 5, 8, 6, 6, 6, 7, 7, 6,
1315 6, 8, 8, 3, 1, 1, 1, 1, 2, 2,
1316 4, 2, 1, 1, 1, 4, 2, 4, 6, 6,
1317 6, 6, 3, 4, 0, 1, 1, 1, 3, 3,
1318 3, 3, 3, 3, 1, 0, 1, 1, 1, 0,
1319 2, 3, 1, 1, 3, 1, 0, 8, 1, 1,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1320 3, 1, 1, 3, 0, 1, 1, 3, 0, 1,
1321 1, 1, 1, 1, 1, 1, 1, 1, 3, 1,
1322 5, 1, 1, 1, 1, 2, 2, 1, 2, 2,
1323 0, 1, 1, 1, 2, 2, 3, 9, 9, 8,
1324 14, 1, 1, 6, 5, 2, 6, 7, 1, 3,
1325 1, 0, 2, 1, 5, 5, 5, 6, 6, 2,
1326 4, 4, 6, 4, 4, 6, 6, 2, 7, 1,
1327 2, 0, 1, 0, 3, 6, 3, 6, 2, 4,
1328 6, 4
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1329};
1330
1331/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
1332 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
1333 means the default is an error. */
Reid Spencerfcb5df82006-12-01 22:34:43 +0000[diff] [blame]1334static const unsigned short int yydefact[] =
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1335{
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1336 194, 0, 90, 182, 1, 181, 224, 83, 84, 85,
1337 87, 88, 89, 86, 0, 98, 250, 178, 179, 206,
1338 207, 0, 0, 0, 90, 0, 186, 225, 226, 98,
1339 0, 0, 91, 92, 93, 94, 95, 96, 0, 0,
1340 251, 250, 247, 82, 0, 0, 0, 0, 192, 0,
1341 0, 0, 0, 0, 183, 184, 0, 0, 81, 227,
1342 195, 180, 97, 111, 115, 116, 117, 118, 119, 120,
1343 121, 122, 123, 124, 125, 126, 127, 2, 3, 0,
1344 0, 0, 0, 241, 0, 0, 110, 129, 114, 242,
1345 128, 218, 219, 220, 221, 222, 223, 246, 0, 0,
1346 0, 253, 252, 262, 293, 261, 248, 249, 0, 0,
1347 0, 0, 205, 193, 187, 185, 175, 176, 0, 0,
1348 0, 0, 130, 0, 0, 0, 113, 135, 139, 0,
1349 0, 144, 138, 255, 0, 254, 0, 0, 72, 76,
1350 71, 75, 70, 74, 69, 73, 77, 78, 0, 292,
1351 0, 273, 0, 98, 6, 7, 8, 9, 10, 11,
1352 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1353 22, 23, 24, 25, 0, 0, 0, 0, 0, 0,
1354 0, 0, 52, 53, 54, 55, 0, 0, 0, 0,
1355 68, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1356 65, 66, 67, 0, 0, 0, 0, 0, 98, 265,
1357 0, 289, 200, 197, 196, 198, 199, 201, 204, 0,
1358 106, 106, 115, 116, 117, 118, 119, 120, 121, 122,
1359 123, 124, 125, 0, 0, 0, 0, 106, 106, 0,
1360 0, 0, 0, 0, 134, 216, 143, 141, 0, 230,
1361 231, 232, 235, 236, 237, 233, 234, 228, 0, 0,
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]1362 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1363 0, 239, 244, 243, 245, 0, 256, 0, 279, 272,
1364 0, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1365 35, 0, 50, 51, 36, 37, 38, 39, 40, 41,
1366 42, 43, 44, 45, 46, 47, 48, 49, 0, 101,
1367 101, 298, 0, 0, 287, 0, 0, 0, 0, 0,
1368 0, 0, 0, 0, 0, 0, 0, 0, 0, 202,
1369 0, 190, 191, 158, 159, 4, 5, 156, 157, 160,
1370 151, 152, 155, 0, 0, 0, 0, 154, 153, 188,
1371 189, 112, 112, 137, 0, 140, 215, 209, 212, 213,
1372 0, 0, 131, 229, 0, 0, 0, 0, 0, 0,
1373 0, 0, 174, 0, 0, 0, 0, 0, 0, 0,
1374 0, 0, 0, 0, 0, 294, 0, 296, 291, 0,
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]1375 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1376 0, 0, 0, 0, 203, 0, 0, 108, 106, 146,
1377 0, 0, 150, 0, 147, 132, 133, 136, 208, 210,
1378 0, 104, 142, 0, 0, 0, 291, 0, 0, 0,
1379 0, 0, 238, 0, 0, 0, 0, 0, 0, 0,
1380 0, 0, 0, 0, 0, 0, 0, 301, 0, 0,
1381 0, 283, 284, 0, 0, 0, 0, 0, 280, 281,
1382 0, 299, 0, 103, 109, 107, 145, 148, 149, 214,
1383 211, 105, 99, 0, 0, 0, 0, 0, 0, 0,
1384 0, 173, 0, 0, 0, 0, 0, 0, 0, 271,
1385 0, 0, 101, 102, 101, 268, 290, 0, 0, 0,
1386 0, 0, 274, 275, 276, 271, 0, 0, 217, 240,
1387 0, 0, 162, 0, 0, 0, 0, 0, 0, 0,
1388 0, 0, 0, 0, 270, 0, 277, 278, 0, 295,
1389 297, 0, 0, 0, 282, 285, 286, 0, 300, 100,
1390 0, 0, 0, 170, 0, 0, 164, 165, 166, 169,
1391 161, 0, 259, 0, 0, 0, 269, 266, 0, 288,
1392 167, 168, 0, 0, 0, 257, 0, 258, 0, 0,
1393 267, 163, 171, 172, 0, 0, 0, 0, 0, 0,
1394 264, 0, 0, 263, 0, 260
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1395};
1396
1397/* YYDEFGOTO[NTERM-NUM]. */
1398static const short int yydefgoto[] =
1399{
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1400 -1, 83, 337, 266, 267, 268, 291, 308, 269, 270,
1401 233, 234, 148, 235, 24, 15, 38, 508, 385, 407,
1402 472, 331, 408, 84, 85, 236, 87, 88, 129, 248,
1403 372, 271, 373, 118, 1, 2, 57, 3, 61, 215,
1404 48, 113, 219, 89, 419, 358, 359, 360, 39, 93,
1405 16, 96, 17, 29, 18, 364, 272, 90, 274, 495,
1406 41, 42, 43, 105, 106, 554, 107, 314, 524, 525,
1407 208, 209, 447, 210, 211
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1408};
1409
1410/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1411 STATE-NUM. */
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1412#define YYPACT_NINF -513
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1413static const short int yypact[] =
1414{
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1415 -513, 46, 217, 541, -513, -513, 82, -513, -513, -513,
1416 -513, -513, -513, -513, 16, 111, 25, -513, -513, -513,
1417 -513, 34, -55, 61, 26, -23, -513, -513, -513, 111,
1418 132, 146, -513, -513, -513, -513, -513, -513, 873, -26,
1419 -513, -18, -513, 47, 19, 23, 39, 67, -513, 77,
1420 132, 873, 81, 81, -513, -513, 81, 81, -513, -513,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1421 -513, -513, -513, 89, -513, -513, -513, -513, -513, -513,
1422 -513, -513, -513, -513, -513, -513, -513, -513, -513, 227,
1423 229, -9, 506, -513, 133, 95, -513, -513, -111, -513,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1424 -513, -513, -513, -513, -513, -513, -513, -513, 901, 36,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1425 148, -513, -513, -513, 1336, -513, -513, -513, 222, 76,
1426 250, 239, 241, -513, -513, -513, -513, -513, 933, 933,
1427 963, 933, -513, 115, 116, 614, -513, -513, -111, -104,
1428 120, 216, -513, 89, 1134, -513, 1134, 1134, -513, -513,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1429 -513, -513, -513, -513, -513, -513, -513, -513, 1134, -513,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1430 933, -513, 218, 111, -513, -513, -513, -513, -513, -513,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1431 -513, -513, -513, -513, -513, -513, -513, -513, -513, -513,
1432 -513, -513, -513, -513, 195, 84, 933, 933, 933, 933,
1433 933, 933, -513, -513, -513, -513, 933, 933, 933, 933,
1434 -513, -513, -513, -513, -513, -513, -513, -513, -513, -513,
1435 -513, -513, -513, 933, 933, 933, 933, 933, 111, -513,
1436 11, -513, -513, -513, -513, -513, -513, -513, -513, -93,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1437 129, 129, 121, 166, 169, 191, 193, 220, 223, 237,
1438 240, 261, 263, 249, 249, 264, 1045, 129, 129, 933,
1439 933, 126, -73, 933, -513, 701, -513, 138, 136, -513,
1440 -513, -513, -513, -513, -513, -513, -513, 228, 195, 84,
1441 140, 150, 154, 156, 158, 963, 167, 168, 170, 171,
1442 172, -513, -513, -513, -513, 175, -513, 176, -513, -513,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1443 873, -513, -513, -513, -513, -513, -513, -513, -513, -513,
1444 -513, 933, -513, -513, -513, -513, -513, -513, -513, -513,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1445 -513, -513, -513, -513, -513, -513, -513, -513, 933, 177,
1446 178, -513, 1134, 164, 179, 182, 183, 184, 186, 188,
1447 1134, 1134, 1134, 189, 284, 873, 933, 933, 312, -513,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1448 -8, -513, -513, -513, -513, -513, -513, -513, -513, -513,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1449 -513, -513, -513, 741, 963, 673, 314, -513, -513, -513,
1450 -513, -113, -99, -513, 185, -111, -513, 133, -513, 194,
1451 192, 774, -513, -513, 318, 198, 205, 963, 963, 963,
1452 963, 963, -513, -58, 963, 963, 963, 963, 963, 345,
1453 348, 1134, 1134, 1134, -2, -513, 9, -513, 212, 1134,
1454 209, 933, 933, 933, 933, 933, 214, 215, 219, 933,
1455 933, 1134, 1134, 221, -513, 338, 352, -513, 129, -513,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1456 -61, -57, -513, -70, -513, -513, -513, -513, -513, -513,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1457 833, 337, -513, 224, 963, 963, 212, 231, 235, 236,
1458 238, 963, -513, 242, 243, 244, 245, 342, 1134, 1134,
1459 247, 251, 252, 1134, 371, 1134, 933, -513, 253, 1134,
1460 254, -513, -513, 255, 257, 1134, 1134, 1134, -513, -513,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1461 248, -513, 933, -513, -513, -513, -513, -513, -513, -513,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1462 -513, -513, 335, 363, 258, 262, 260, 963, 963, 963,
1463 963, -513, 963, 963, 963, 963, 933, 265, 266, 933,
1464 1134, 1134, 267, -513, 267, -513, 268, 1134, 269, 933,
1465 933, 933, -513, -513, -513, 933, 1134, 398, -513, -513,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1466 963, 963, -513, 271, 273, 277, 278, 276, 279, 282,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1467 283, 286, 403, 15, 268, 289, -513, -513, 375, -513,
1468 -513, 933, 275, 1134, -513, -513, -513, 292, -513, -513,
1469 294, 295, 963, -513, 963, 963, -513, -513, -513, -513,
1470 -513, 1134, -513, 1223, 27, 400, -513, -513, 297, -513,
1471 -513, -513, 303, 304, 305, -513, 313, -513, 1223, 449,
1472 -513, -513, -513, -513, 451, 316, 1134, 1134, 454, 135,
1473 -513, 1134, 457, -513, 1134, -513
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1474};
1475
1476/* YYPGOTO[NTERM-NUM]. */
1477static const short int yypgoto[] =
1478{
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1479 -513, -513, 246, 369, 370, 372, 225, 226, 373, 377,
1480 -98, -97, -507, -513, 436, 458, -141, -513, -303, 63,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1481 -513, -220, -513, -46, -513, -38, -513, -68, -20, -513,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1482 130, 256, -230, 51, -513, -513, -513, -513, 439, -513,
1483 -513, -513, -513, 1, -513, 66, -513, -513, 461, -513,
1484 -513, -513, -513, -513, 488, -513, -512, -106, -3, -88,
1485 -513, 455, -513, -84, -513, -513, -513, -513, 56, 18,
1486 -513, -513, 98, -513, -513
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1487};
1488
1489/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1490 positive, shift that token. If negative, reduce the rule which
1491 number is the opposite. If zero, do what YYDEFACT says.
1492 If YYTABLE_NINF, syntax error. */
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]1493#define YYTABLE_NINF -178
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1494static const short int yytable[] =
1495{
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1496 86, 332, 146, 147, 25, 115, 91, 387, 443, 124,
1497 135, 40, 280, 86, 128, 94, 553, 349, 350, 445,
1498 138, 139, 140, 141, 142, 143, 144, 145, 273, 405,
1499 273, 273, 138, 139, 140, 141, 142, 143, 144, 145,
1500 136, 566, 273, -112, 25, 415, 4, 568, 243, 406,
1501 132, 137, 132, 51, 40, 444, 575, 128, 244, 328,
1502 134, 416, 278, 128, 132, 329, 444, 325, 7, 8,
1503 9, 52, 11, 53, 13, 19, 54, 20, 30, 243,
1504 220, 221, 431, 238, 55, 130, 44, 45, 46, 354,
1505 311, 431, 468, 315, 431, 431, 49, 466, 316, 317,
1506 318, 319, 432, 467, 119, 242, 47, 120, 121, 292,
1507 293, 247, 134, 410, 411, 413, 116, 117, 323, 324,
1508 98, 99, 100, 50, 101, 102, 103, 27, 58, 28,
1509 348, 213, 214, 275, 276, 92, 326, 327, 309, 310,
1510 134, 312, 313, 134, 95, 277, 333, 334, 134, 134,
1511 134, 134, 125, 138, 139, 140, 141, 142, 143, 144,
1512 145, 19, 60, 20, 62, 320, 321, 322, 134, 134,
1513 108, 351, 352, 552, 109, 355, 31, 32, 33, 34,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1514 35, 36, 37, -72, -72, 567, -76, -76, 465, 529,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1515 110, 530, 294, 295, 296, 297, 298, 299, 300, 301,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1516 302, 303, 304, 305, 306, 307, 273, 357, -71, -71,
1517 -75, -75, 101, 102, 273, 273, 273, -177, 111, 126,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1518 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1519 74, 75, 76, 112, 381, 77, 78, -70, -70, 403,
1520 -74, -74, 86, -113, 19, 122, 20, 123, 5, 131,
1521 237, 6, 212, 382, -69, -69, 246, -73, -73, 7,
1522 8, 9, 10, 11, 12, 13, 335, 336, 216, 217,
1523 383, 218, 239, 240, 245, 273, 273, 273, 279, 401,
1524 14, 330, -79, 273, -80, 339, 353, 86, 402, 134,
1525 361, 362, 363, 355, 367, 273, 273, 281, 282, 283,
1526 284, 285, 286, 450, 368, 452, 453, 454, 369, 388,
1527 370, 458, 371, 287, 288, 289, 290, 396, 397, 398,
1528 389, 374, 375, 400, 376, 377, 378, 379, 380, 384,
1529 386, 390, 273, 273, 391, 392, 393, 273, 394, 273,
1530 395, 399, 404, 273, 414, 417, 420, 421, 423, 273,
1531 273, 273, 424, 134, 451, 134, 134, 134, 418, 425,
1532 438, 134, 459, 439, 446, 449, 455, 456, 463, 79,
1533 464, 457, 80, 462, 405, 81, 473, 82, 440, 441,
1534 442, 486, 357, 477, 273, 273, 448, 478, 479, 493,
1535 480, 273, 507, 509, 482, 483, 484, 485, 460, 461,
1536 273, 489, 505, 490, 491, 497, 499, 500, 134, 501,
1537 510, 534, 535, 536, 511, 512, 539, 522, 551, 528,
1538 531, 533, 523, 542, 506, 146, 147, 273, 543, 544,
1539 545, 546, 444, 557, 547, 487, 488, 548, 549, 569,
1540 492, 550, 494, 556, 555, 273, 498, 559, 521, 560,
1541 561, 134, 502, 503, 504, 570, 146, 147, 571, 572,
1542 573, 134, 134, 134, 576, 574, 577, 134, 578, 581,
1543 273, 273, 584, 203, 204, 273, 205, 206, 273, 104,
1544 338, 207, 56, 365, 471, 366, 470, 526, 527, 114,
1545 59, 26, 347, 134, 532, 582, 97, 426, 427, 428,
1546 429, 430, 496, 538, 433, 434, 435, 436, 437, 126,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1547 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1548 74, 75, 76, 537, 476, 77, 78, 0, 0, 0,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1549 558, 0, 0, 0, 19, 0, 20, 0, 0, 0,
1550 0, 0, 0, 0, 0, 0, 0, 0, 565, 0,
1551 0, 0, 0, 0, 474, 475, 0, 0, 0, 0,
1552 0, 481, 0, 0, 0, 0, 0, 0, -82, 19,
1553 0, 20, 0, 579, 580, 6, -82, -82, 583, 0,
1554 0, 585, 0, -82, -82, -82, -82, -82, -82, -82,
1555 0, -82, 21, 0, 0, 0, 0, 0, 0, -82,
1556 22, 0, 0, 0, 23, 0, 0, 513, 514, 515,
1557 516, 0, 517, 518, 519, 520, 0, 126, 64, 65,
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]1558 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1559 76, 0, 0, 77, 78, 0, 0, 0, 0, 0,
1560 540, 541, 19, 0, 20, 0, 0, 0, 0, 0,
1561 0, 0, 0, 0, 0, 0, 0, 0, 0, 79,
1562 0, 0, 80, 0, 0, 81, 0, 82, 127, 0,
1563 0, 0, 562, 0, 563, 564, 126, 222, 223, 224,
1564 225, 226, 227, 228, 229, 230, 231, 232, 75, 76,
1565 0, 0, 77, 78, 0, 0, 0, 0, 0, 0,
1566 0, 19, 0, 20, 126, 64, 65, 66, 67, 68,
1567 69, 70, 71, 72, 73, 74, 75, 76, 0, 0,
1568 77, 78, 0, 0, 0, 0, 0, 0, 0, 19,
1569 0, 20, 0, 0, 0, 0, 0, 0, 0, 0,
1570 0, 356, 0, 0, 126, 222, 223, 224, 225, 226,
1571 227, 228, 229, 230, 231, 232, 75, 76, 0, 0,
1572 77, 78, 0, 0, 0, 0, 0, 79, 0, 19,
1573 80, 20, 0, 81, 0, 82, 241, 126, 64, 65,
1574 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
1575 76, 0, 0, 77, 78, 0, 0, 0, 0, 0,
1576 0, 0, 19, 0, 20, 0, 0, 0, 0, 0,
1577 0, 0, 0, 0, 422, 0, 0, 0, 0, 0,
1578 0, 0, 0, 0, 0, 0, 79, 0, 0, 80,
1579 0, 0, 81, 0, 82, 412, 126, 64, 65, 66,
1580 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
1581 0, 0, 77, 78, 79, 0, 0, 80, 0, 0,
1582 81, 19, 82, 20, 0, 0, 0, 0, 0, 0,
1583 0, 0, 0, 469, 0, 0, 63, 64, 65, 66,
1584 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
1585 0, 0, 77, 78, 79, 0, 0, 80, 0, 409,
1586 81, 19, 82, 20, 133, 64, 65, 66, 67, 68,
1587 69, 70, 71, 72, 73, 74, 75, 76, 0, 0,
1588 77, 78, 0, 0, 0, 0, 0, 79, 0, 19,
1589 80, 20, 0, 81, 0, 82, 126, 64, 65, 66,
1590 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
1591 0, 0, 77, 78, 0, 0, 0, 0, 0, 0,
1592 0, 19, 0, 20, 0, 0, 126, 222, 223, 224,
1593 225, 226, 227, 228, 229, 230, 231, 232, 75, 76,
1594 0, 0, 77, 78, 0, 0, 79, 0, 0, 80,
1595 0, 19, 81, 20, 82, 0, 0, 0, 0, 0,
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]1596 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1597 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1598 0, 0, 0, 0, 0, 0, 79, 0, 0, 80,
1599 0, 0, 81, 0, 82, 0, 0, 0, 0, 0,
1600 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1601 0, 0, 0, 0, 79, 0, 0, 80, 0, 0,
1602 81, 0, 82, 0, 77, 78, 0, 340, 341, 342,
1603 0, 0, 0, 19, 0, 20, 0, 0, 0, 0,
1604 0, 0, 0, 0, 0, 0, 79, 0, 0, 80,
1605 0, 0, 81, 0, 82, 0, 0, 0, 0, 0,
1606 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1607 0, 0, 0, 0, 0, 0, 79, 0, 0, 80,
1608 0, 0, 81, 0, 82, 154, 155, 156, 157, 158,
1609 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
1610 169, 170, 171, 172, 173, 258, 259, 0, 0, 0,
1611 0, 249, 250, 77, 78, 251, 252, 253, 254, 255,
1612 256, 0, 19, 0, 20, 0, 0, 0, 0, 0,
1613 0, 0, 260, 0, 261, 182, 183, 184, 185, 0,
1614 262, 263, 264, 190, 191, 192, 193, 194, 195, 196,
1615 197, 198, 199, 200, 201, 202, 257, 0, 0, 0,
1616 0, 343, 0, 0, 344, 0, 345, 0, 0, 346,
1617 0, 0, 0, 0, 154, 155, 156, 157, 158, 159,
1618 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
1619 170, 171, 172, 173, 258, 259, 0, 0, 0, 0,
1620 249, 250, 0, 0, 251, 252, 253, 254, 255, 256,
1621 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1622 0, 260, 0, 261, 182, 183, 184, 185, 0, 262,
1623 263, 264, 190, 191, 192, 193, 194, 195, 196, 197,
1624 198, 199, 200, 201, 202, 257, 0, 0, 0, 0,
1625 0, 0, 0, 265, 0, 0, 0, 0, 0, 0,
1626 0, 0, 0, 154, 155, 156, 157, 158, 159, 160,
1627 161, 162, 163, 164, 165, 166, 167, 168, 169, 170,
1628 171, 172, 173, 258, 259, 0, 0, 0, 0, 0,
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]1629 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]1630 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1631 260, 0, 261, 182, 183, 184, 185, 0, 262, 263,
1632 264, 190, 191, 192, 193, 194, 195, 196, 197, 198,
1633 199, 200, 201, 202, 149, 0, 0, 0, 0, 0,
1634 0, 0, 265, 0, 0, 150, 0, 0, 0, 0,
1635 0, 0, 0, 0, 0, 0, 151, 152, 0, 0,
Reid Spencerfcb5df82006-12-01 22:34:43 +0000[diff] [blame]1636 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1637 0, 0, 153, 0, 0, 0, 154, 155, 156, 157,
1638 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
1639 168, 169, 170, 171, 172, 173, 174, 175, 0, 0,
Reid Spencerfcb5df82006-12-01 22:34:43 +0000[diff] [blame]1640 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1641 0, 0, 0, 0, 0, 0, 0, 0, 176, 177,
1642 178, 0, 0, 179, 180, 181, 182, 183, 184, 185,
1643 186, 187, 188, 189, 190, 191, 192, 193, 194, 195,
1644 196, 197, 198, 199, 200, 201, 202
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1645};
1646
1647static const short int yycheck[] =
1648{
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1649 38, 221, 100, 100, 3, 51, 32, 310, 10, 18,
1650 98, 29, 153, 51, 82, 33, 523, 237, 238, 10,
1651 5, 6, 7, 8, 9, 10, 11, 12, 134, 37,
1652 136, 137, 5, 6, 7, 8, 9, 10, 11, 12,
1653 4, 553, 148, 154, 43, 158, 0, 554, 152, 57,
1654 163, 15, 163, 27, 29, 57, 568, 125, 162, 152,
1655 98, 160, 150, 131, 163, 158, 57, 208, 42, 43,
1656 44, 45, 46, 47, 48, 28, 50, 30, 62, 152,
1657 118, 119, 152, 121, 58, 84, 52, 53, 54, 162,
1658 178, 152, 162, 181, 152, 152, 151, 158, 186, 187,
1659 188, 189, 160, 160, 53, 125, 72, 56, 57, 25,
1660 26, 131, 150, 343, 344, 345, 35, 36, 206, 207,
1661 73, 74, 75, 62, 77, 78, 79, 45, 151, 47,
1662 236, 55, 56, 136, 137, 161, 125, 126, 176, 177,
1663 178, 179, 180, 181, 162, 148, 25, 26, 186, 187,
1664 188, 189, 161, 5, 6, 7, 8, 9, 10, 11,
1665 12, 28, 30, 30, 18, 203, 204, 205, 206, 207,
1666 151, 239, 240, 158, 151, 243, 65, 66, 67, 68,
1667 69, 70, 71, 17, 18, 158, 17, 18, 408, 492,
1668 151, 494, 108, 109, 110, 111, 112, 113, 114, 115,
1669 116, 117, 118, 119, 120, 121, 312, 245, 17, 18,
1670 17, 18, 77, 78, 320, 321, 322, 0, 151, 3,
1671 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
1672 14, 15, 16, 156, 280, 19, 20, 17, 18, 327,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1673 17, 18, 280, 154, 28, 18, 30, 18, 31, 154,
1674 120, 34, 30, 291, 17, 18, 40, 17, 18, 42,
1675 43, 44, 45, 46, 47, 48, 17, 18, 18, 30,
1676 308, 30, 157, 157, 154, 381, 382, 383, 60, 325,
1677 63, 152, 21, 389, 21, 21, 160, 325, 326, 327,
1678 152, 155, 64, 361, 154, 401, 402, 102, 103, 104,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1679 105, 106, 107, 391, 154, 393, 394, 395, 154, 312,
1680 154, 399, 154, 118, 119, 120, 121, 320, 321, 322,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1681 156, 154, 154, 39, 154, 154, 154, 152, 152, 152,
1682 152, 152, 438, 439, 152, 152, 152, 443, 152, 445,
1683 152, 152, 30, 449, 30, 160, 152, 155, 30, 455,
1684 456, 457, 154, 391, 392, 393, 394, 395, 357, 154,
1685 15, 399, 400, 15, 152, 156, 152, 152, 30, 153,
1686 18, 152, 156, 152, 37, 159, 152, 161, 381, 382,
1687 383, 39, 420, 152, 490, 491, 389, 152, 152, 18,
1688 152, 497, 57, 30, 152, 152, 152, 152, 401, 402,
1689 506, 154, 154, 152, 152, 152, 152, 152, 446, 152,
1690 152, 499, 500, 501, 152, 155, 18, 152, 15, 152,
1691 152, 152, 156, 152, 462, 523, 523, 533, 155, 152,
1692 152, 155, 57, 158, 155, 438, 439, 155, 155, 39,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1693 443, 155, 445, 531, 155, 551, 449, 155, 486, 155,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1694 155, 489, 455, 456, 457, 158, 554, 554, 155, 155,
1695 155, 499, 500, 501, 15, 152, 15, 505, 152, 15,
1696 576, 577, 15, 104, 104, 581, 104, 104, 584, 43,
1697 234, 104, 24, 258, 421, 259, 420, 490, 491, 50,
1698 29, 3, 236, 531, 497, 579, 41, 367, 368, 369,
1699 370, 371, 446, 506, 374, 375, 376, 377, 378, 3,
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]1700 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1701 14, 15, 16, 505, 426, 19, 20, -1, -1, -1,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1702 533, -1, -1, -1, 28, -1, 30, -1, -1, -1,
1703 -1, -1, -1, -1, -1, -1, -1, -1, 551, -1,
1704 -1, -1, -1, -1, 424, 425, -1, -1, -1, -1,
1705 -1, 431, -1, -1, -1, -1, -1, -1, 27, 28,
1706 -1, 30, -1, 576, 577, 34, 35, 36, 581, -1,
1707 -1, 584, -1, 42, 43, 44, 45, 46, 47, 48,
1708 -1, 50, 51, -1, -1, -1, -1, -1, -1, 58,
1709 59, -1, -1, -1, 63, -1, -1, 477, 478, 479,
1710 480, -1, 482, 483, 484, 485, -1, 3, 4, 5,
1711 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1712 16, -1, -1, 19, 20, -1, -1, -1, -1, -1,
1713 510, 511, 28, -1, 30, -1, -1, -1, -1, -1,
1714 -1, -1, -1, -1, -1, -1, -1, -1, -1, 153,
1715 -1, -1, 156, -1, -1, 159, -1, 161, 162, -1,
1716 -1, -1, 542, -1, 544, 545, 3, 4, 5, 6,
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]1717 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1718 -1, -1, 19, 20, -1, -1, -1, -1, -1, -1,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1719 -1, 28, -1, 30, 3, 4, 5, 6, 7, 8,
1720 9, 10, 11, 12, 13, 14, 15, 16, -1, -1,
1721 19, 20, -1, -1, -1, -1, -1, -1, -1, 28,
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]1722 -1, 30, -1, -1, -1, -1, -1, -1, -1, -1,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1723 -1, 40, -1, -1, 3, 4, 5, 6, 7, 8,
1724 9, 10, 11, 12, 13, 14, 15, 16, -1, -1,
1725 19, 20, -1, -1, -1, -1, -1, 153, -1, 28,
1726 156, 30, -1, 159, -1, 161, 162, 3, 4, 5,
1727 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1728 16, -1, -1, 19, 20, -1, -1, -1, -1, -1,
1729 -1, -1, 28, -1, 30, -1, -1, -1, -1, -1,
1730 -1, -1, -1, -1, 40, -1, -1, -1, -1, -1,
1731 -1, -1, -1, -1, -1, -1, 153, -1, -1, 156,
1732 -1, -1, 159, -1, 161, 162, 3, 4, 5, 6,
1733 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1734 -1, -1, 19, 20, 153, -1, -1, 156, -1, -1,
1735 159, 28, 161, 30, -1, -1, -1, -1, -1, -1,
1736 -1, -1, -1, 40, -1, -1, 3, 4, 5, 6,
1737 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1738 -1, -1, 19, 20, 153, -1, -1, 156, -1, 158,
1739 159, 28, 161, 30, 3, 4, 5, 6, 7, 8,
1740 9, 10, 11, 12, 13, 14, 15, 16, -1, -1,
1741 19, 20, -1, -1, -1, -1, -1, 153, -1, 28,
1742 156, 30, -1, 159, -1, 161, 3, 4, 5, 6,
1743 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1744 -1, -1, 19, 20, -1, -1, -1, -1, -1, -1,
1745 -1, 28, -1, 30, -1, -1, 3, 4, 5, 6,
1746 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1747 -1, -1, 19, 20, -1, -1, 153, -1, -1, 156,
1748 -1, 28, 159, 30, 161, -1, -1, -1, -1, -1,
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]1749 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1750 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1751 -1, -1, -1, -1, -1, -1, 153, -1, -1, 156,
1752 -1, -1, 159, -1, 161, -1, -1, -1, -1, -1,
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]1753 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1754 -1, -1, -1, -1, 153, -1, -1, 156, -1, -1,
1755 159, -1, 161, -1, 19, 20, -1, 22, 23, 24,
1756 -1, -1, -1, 28, -1, 30, -1, -1, -1, -1,
1757 -1, -1, -1, -1, -1, -1, 153, -1, -1, 156,
1758 -1, -1, 159, -1, 161, -1, -1, -1, -1, -1,
Reid Spencerfcb5df82006-12-01 22:34:43 +0000[diff] [blame]1759 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1760 -1, -1, -1, -1, -1, -1, 153, -1, -1, 156,
1761 -1, -1, 159, -1, 161, 80, 81, 82, 83, 84,
1762 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
1763 95, 96, 97, 98, 99, 100, 101, -1, -1, -1,
1764 -1, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1765 26, -1, 28, -1, 30, -1, -1, -1, -1, -1,
1766 -1, -1, 127, -1, 129, 130, 131, 132, 133, -1,
1767 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
1768 145, 146, 147, 148, 149, 150, 62, -1, -1, -1,
1769 -1, 156, -1, -1, 159, -1, 161, -1, -1, 164,
1770 -1, -1, -1, -1, 80, 81, 82, 83, 84, 85,
1771 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
1772 96, 97, 98, 99, 100, 101, -1, -1, -1, -1,
1773 17, 18, -1, -1, 21, 22, 23, 24, 25, 26,
Reid Spencerfcb5df82006-12-01 22:34:43 +0000[diff] [blame]1774 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1775 -1, 127, -1, 129, 130, 131, 132, 133, -1, 135,
1776 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
1777 146, 147, 148, 149, 150, 62, -1, -1, -1, -1,
1778 -1, -1, -1, 159, -1, -1, -1, -1, -1, -1,
1779 -1, -1, -1, 80, 81, 82, 83, 84, 85, 86,
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]1780 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1781 97, 98, 99, 100, 101, -1, -1, -1, -1, -1,
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]1782 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1783 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1784 127, -1, 129, 130, 131, 132, 133, -1, 135, 136,
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]1785 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1786 147, 148, 149, 150, 38, -1, -1, -1, -1, -1,
1787 -1, -1, 159, -1, -1, 49, -1, -1, -1, -1,
1788 -1, -1, -1, -1, -1, -1, 60, 61, -1, -1,
1789 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1790 -1, -1, 76, -1, -1, -1, 80, 81, 82, 83,
1791 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
1792 94, 95, 96, 97, 98, 99, 100, 101, -1, -1,
1793 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1794 -1, -1, -1, -1, -1, -1, -1, -1, 122, 123,
1795 124, -1, -1, 127, 128, 129, 130, 131, 132, 133,
1796 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
1797 144, 145, 146, 147, 148, 149, 150
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1798};
1799
1800/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1801 symbol of state STATE-NUM. */
1802static const unsigned char yystos[] =
1803{
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1804 0, 199, 200, 202, 0, 31, 34, 42, 43, 44,
1805 45, 46, 47, 48, 63, 180, 215, 217, 219, 28,
1806 30, 51, 59, 63, 179, 208, 219, 45, 47, 218,
1807 62, 65, 66, 67, 68, 69, 70, 71, 181, 213,
1808 29, 225, 226, 227, 52, 53, 54, 72, 205, 151,
1809 62, 27, 45, 47, 50, 58, 180, 201, 151, 213,
1810 30, 203, 18, 3, 4, 5, 6, 7, 8, 9,
1811 10, 11, 12, 13, 14, 15, 16, 19, 20, 153,
1812 156, 159, 161, 166, 188, 189, 190, 191, 192, 208,
1813 222, 32, 161, 214, 33, 162, 216, 226, 73, 74,
1814 75, 77, 78, 79, 179, 228, 229, 231, 151, 151,
1815 151, 151, 156, 206, 203, 188, 35, 36, 198, 198,
1816 198, 198, 18, 18, 18, 161, 3, 162, 192, 193,
1817 208, 154, 163, 3, 190, 224, 4, 15, 5, 6,
1818 7, 8, 9, 10, 11, 12, 175, 176, 177, 38,
1819 49, 60, 61, 76, 80, 81, 82, 83, 84, 85,
1820 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
1821 96, 97, 98, 99, 100, 101, 122, 123, 124, 127,
1822 128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
1823 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
1824 148, 149, 150, 168, 169, 170, 173, 174, 235, 236,
1825 238, 239, 30, 55, 56, 204, 18, 30, 30, 207,
1826 190, 190, 4, 5, 6, 7, 8, 9, 10, 11,
1827 12, 13, 14, 175, 176, 178, 190, 195, 190, 157,
1828 157, 162, 193, 152, 162, 154, 40, 193, 194, 17,
1829 18, 21, 22, 23, 24, 25, 26, 62, 100, 101,
1830 127, 129, 135, 136, 137, 159, 168, 169, 170, 173,
1831 174, 196, 221, 222, 223, 223, 223, 223, 224, 60,
1832 181, 102, 103, 104, 105, 106, 107, 118, 119, 120,
1833 121, 171, 25, 26, 108, 109, 110, 111, 112, 113,
1834 114, 115, 116, 117, 118, 119, 120, 121, 172, 190,
1835 190, 224, 190, 190, 232, 224, 224, 224, 224, 224,
1836 190, 190, 190, 224, 224, 181, 125, 126, 152, 158,
Reid Spencer7356ae42007-01-02 06:34:08 +0000[diff] [blame]1837 152, 186, 186, 25, 26, 17, 18, 167, 167, 21,
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]1838 22, 23, 24, 156, 159, 161, 164, 196, 222, 186,
1839 186, 192, 192, 160, 162, 192, 40, 190, 210, 211,
1840 212, 152, 155, 64, 220, 171, 172, 154, 154, 154,
1841 154, 154, 195, 197, 154, 154, 154, 154, 154, 152,
1842 152, 188, 190, 190, 152, 183, 152, 183, 223, 156,
1843 152, 152, 152, 152, 152, 152, 223, 223, 223, 152,
1844 39, 188, 190, 224, 30, 37, 57, 184, 187, 158,
1845 197, 197, 162, 197, 30, 158, 160, 160, 208, 209,
1846 152, 155, 40, 30, 154, 154, 195, 195, 195, 195,
1847 195, 152, 160, 195, 195, 195, 195, 195, 15, 15,
1848 223, 223, 223, 10, 57, 10, 152, 237, 223, 156,
1849 224, 190, 224, 224, 224, 152, 152, 152, 224, 190,
1850 223, 223, 152, 30, 18, 186, 158, 160, 162, 40,
1851 210, 184, 185, 152, 195, 195, 237, 152, 152, 152,
1852 152, 195, 152, 152, 152, 152, 39, 223, 223, 154,
1853 152, 152, 223, 18, 223, 224, 233, 152, 223, 152,
1854 152, 152, 223, 223, 223, 154, 190, 57, 182, 30,
1855 152, 152, 155, 195, 195, 195, 195, 195, 195, 195,
1856 195, 190, 152, 156, 233, 234, 223, 223, 152, 183,
1857 183, 152, 223, 152, 224, 224, 224, 234, 223, 18,
1858 195, 195, 152, 155, 152, 152, 155, 155, 155, 155,
1859 155, 15, 158, 177, 230, 155, 224, 158, 223, 155,
1860 155, 155, 195, 195, 195, 223, 221, 158, 177, 39,
1861 158, 155, 155, 155, 152, 221, 15, 15, 152, 223,
1862 223, 15, 228, 223, 15, 223
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]1863};
1864
1865#define yyerrok (yyerrstatus = 0)
1866#define yyclearin (yychar = YYEMPTY)
1867#define YYEMPTY (-2)
1868#define YYEOF 0
1869
1870#define YYACCEPT goto yyacceptlab
1871#define YYABORT goto yyabortlab
1872#define YYERROR goto yyerrorlab
1873
1874
1875/* Like YYERROR except do call yyerror. This remains here temporarily
1876 to ease the transition to the new meaning of YYERROR, for GCC.
1877 Once GCC version 2 has supplanted version 1, this can go. */
1878
1879#define YYFAIL goto yyerrlab
1880
1881#define YYRECOVERING() (!!yyerrstatus)
1882
1883#define YYBACKUP(Token, Value) \
1884do \
1885 if (yychar == YYEMPTY && yylen == 1) \
1886 { \
1887 yychar = (Token); \
1888 yylval = (Value); \
1889 yytoken = YYTRANSLATE (yychar); \
1890 YYPOPSTACK; \
1891 goto yybackup; \
1892 } \
1893 else \
1894 { \
1895 yyerror (YY_("syntax error: cannot back up")); \
1896 YYERROR; \
1897 } \
1898while (0)
1899
1900
1901#define YYTERROR 1
1902#define YYERRCODE 256
1903
1904
1905/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1906 If N is 0, then set CURRENT to the empty location which ends
1907 the previous symbol: RHS[0] (always defined). */
1908
1909#define YYRHSLOC(Rhs, K) ((Rhs)[K])
1910#ifndef YYLLOC_DEFAULT
1911# define YYLLOC_DEFAULT(Current, Rhs, N) \
1912 do \
1913 if (N) \
1914 { \
1915 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1916 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1917 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1918 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1919 } \
1920 else \
1921 { \
1922 (Current).first_line = (Current).last_line = \
1923 YYRHSLOC (Rhs, 0).last_line; \
1924 (Current).first_column = (Current).last_column = \
1925 YYRHSLOC (Rhs, 0).last_column; \
1926 } \
1927 while (0)
1928#endif
1929
1930
1931/* YY_LOCATION_PRINT -- Print the location on the stream.
1932 This macro was not mandated originally: define only if we know
1933 we won't break user code: when these are the locations we know. */
1934
1935#ifndef YY_LOCATION_PRINT
1936# if YYLTYPE_IS_TRIVIAL
1937# define YY_LOCATION_PRINT(File, Loc) \
1938 fprintf (File, "%d.%d-%d.%d", \
1939 (Loc).first_line, (Loc).first_column, \
1940 (Loc).last_line, (Loc).last_column)
1941# else
1942# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1943# endif
1944#endif
1945
1946
1947/* YYLEX -- calling `yylex' with the right arguments. */
1948
1949#ifdef YYLEX_PARAM
1950# define YYLEX yylex (YYLEX_PARAM)
1951#else
1952# define YYLEX yylex ()
1953#endif
1954
1955/* Enable debugging if requested. */
1956#if YYDEBUG
1957
1958# ifndef YYFPRINTF
1959# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1960# define YYFPRINTF fprintf
1961# endif
1962
1963# define YYDPRINTF(Args) \
1964do { \
1965 if (yydebug) \
1966 YYFPRINTF Args; \
1967} while (0)
1968
1969# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1970do { \
1971 if (yydebug) \
1972 { \
1973 YYFPRINTF (stderr, "%s ", Title); \
1974 yysymprint (stderr, \
1975 Type, Value); \
1976 YYFPRINTF (stderr, "\n"); \
1977 } \
1978} while (0)
1979
1980/*------------------------------------------------------------------.
1981| yy_stack_print -- Print the state stack from its BOTTOM up to its |
1982| TOP (included). |
1983`------------------------------------------------------------------*/
1984
1985#if defined (__STDC__) || defined (__cplusplus)
1986static void
1987yy_stack_print (short int *bottom, short int *top)
1988#else
1989static void
1990yy_stack_print (bottom, top)
1991 short int *bottom;
1992 short int *top;
1993#endif
1994{
1995 YYFPRINTF (stderr, "Stack now");
1996 for (/* Nothing. */; bottom <= top; ++bottom)
1997 YYFPRINTF (stderr, " %d", *bottom);
1998 YYFPRINTF (stderr, "\n");
1999}
2000
2001# define YY_STACK_PRINT(Bottom, Top) \
2002do { \
2003 if (yydebug) \
2004 yy_stack_print ((Bottom), (Top)); \
2005} while (0)
2006
2007
2008/*------------------------------------------------.
2009| Report that the YYRULE is going to be reduced. |
2010`------------------------------------------------*/
2011
2012#if defined (__STDC__) || defined (__cplusplus)
2013static void
2014yy_reduce_print (int yyrule)
2015#else
2016static void
2017yy_reduce_print (yyrule)
2018 int yyrule;
2019#endif
2020{
2021 int yyi;
2022 unsigned long int yylno = yyrline[yyrule];
2023 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
2024 yyrule - 1, yylno);
2025 /* Print the symbols being reduced, and their result. */
2026 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
2027 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
2028 YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
2029}
2030
2031# define YY_REDUCE_PRINT(Rule) \
2032do { \
2033 if (yydebug) \
2034 yy_reduce_print (Rule); \
2035} while (0)
2036
2037/* Nonzero means print parse trace. It is left uninitialized so that
2038 multiple parsers can coexist. */
2039int yydebug;
2040#else /* !YYDEBUG */
2041# define YYDPRINTF(Args)
2042# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
2043# define YY_STACK_PRINT(Bottom, Top)
2044# define YY_REDUCE_PRINT(Rule)
2045#endif /* !YYDEBUG */
2046
2047
2048/* YYINITDEPTH -- initial size of the parser's stacks. */
2049#ifndef YYINITDEPTH
2050# define YYINITDEPTH 200
2051#endif
2052
2053/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
2054 if the built-in stack extension method is used).
2055
2056 Do not make this value too large; the results are undefined if
2057 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
2058 evaluated with infinite-precision integer arithmetic. */
2059
2060#ifndef YYMAXDEPTH
2061# define YYMAXDEPTH 10000
2062#endif
2063
2064
2065
2066#if YYERROR_VERBOSE
2067
2068# ifndef yystrlen
2069# if defined (__GLIBC__) && defined (_STRING_H)
2070# define yystrlen strlen
2071# else
2072/* Return the length of YYSTR. */
2073static YYSIZE_T
2074# if defined (__STDC__) || defined (__cplusplus)
2075yystrlen (const char *yystr)
2076# else
2077yystrlen (yystr)
2078 const char *yystr;
2079# endif
2080{
2081 const char *yys = yystr;
2082
2083 while (*yys++ != '\0')
2084 continue;
2085
2086 return yys - yystr - 1;
2087}
2088# endif
2089# endif
2090
2091# ifndef yystpcpy
2092# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
2093# define yystpcpy stpcpy
2094# else
2095/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
2096 YYDEST. */
2097static char *
2098# if defined (__STDC__) || defined (__cplusplus)
2099yystpcpy (char *yydest, const char *yysrc)
2100# else
2101yystpcpy (yydest, yysrc)
2102 char *yydest;
2103 const char *yysrc;
2104# endif
2105{
2106 char *yyd = yydest;
2107 const char *yys = yysrc;
2108
2109 while ((*yyd++ = *yys++) != '\0')
2110 continue;
2111
2112 return yyd - 1;
2113}
2114# endif
2115# endif
2116
2117# ifndef yytnamerr
2118/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
2119 quotes and backslashes, so that it's suitable for yyerror. The
2120 heuristic is that double-quoting is unnecessary unless the string
2121 contains an apostrophe, a comma, or backslash (other than
2122 backslash-backslash). YYSTR is taken from yytname. If YYRES is
2123 null, do not copy; instead, return the length of what the result
2124 would have been. */
2125static YYSIZE_T
2126yytnamerr (char *yyres, const char *yystr)
2127{
2128 if (*yystr == '"')
2129 {
2130 size_t yyn = 0;
2131 char const *yyp = yystr;
2132
2133 for (;;)
2134 switch (*++yyp)
2135 {
2136 case '\'':
2137 case ',':
2138 goto do_not_strip_quotes;
2139
2140 case '\\':
2141 if (*++yyp != '\\')
2142 goto do_not_strip_quotes;
2143 /* Fall through. */
2144 default:
2145 if (yyres)
2146 yyres[yyn] = *yyp;
2147 yyn++;
2148 break;
2149
2150 case '"':
2151 if (yyres)
2152 yyres[yyn] = '\0';
2153 return yyn;
2154 }
2155 do_not_strip_quotes: ;
2156 }
2157
2158 if (! yyres)
2159 return yystrlen (yystr);
2160
2161 return yystpcpy (yyres, yystr) - yyres;
2162}
2163# endif
2164
2165#endif /* YYERROR_VERBOSE */
2166
2167
2168
2169#if YYDEBUG
2170/*--------------------------------.
2171| Print this symbol on YYOUTPUT. |
2172`--------------------------------*/
2173
2174#if defined (__STDC__) || defined (__cplusplus)
2175static void
2176yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
2177#else
2178static void
2179yysymprint (yyoutput, yytype, yyvaluep)
2180 FILE *yyoutput;
2181 int yytype;
2182 YYSTYPE *yyvaluep;
2183#endif
2184{
2185 /* Pacify ``unused variable'' warnings. */
2186 (void) yyvaluep;
2187
2188 if (yytype < YYNTOKENS)
2189 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
2190 else
2191 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
2192
2193
2194# ifdef YYPRINT
2195 if (yytype < YYNTOKENS)
2196 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
2197# endif
2198 switch (yytype)
2199 {
2200 default:
2201 break;
2202 }
2203 YYFPRINTF (yyoutput, ")");
2204}
2205
2206#endif /* ! YYDEBUG */
2207/*-----------------------------------------------.
2208| Release the memory associated to this symbol. |
2209`-----------------------------------------------*/
2210
2211#if defined (__STDC__) || defined (__cplusplus)
2212static void
2213yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
2214#else
2215static void
2216yydestruct (yymsg, yytype, yyvaluep)
2217 const char *yymsg;
2218 int yytype;
2219 YYSTYPE *yyvaluep;
2220#endif
2221{
2222 /* Pacify ``unused variable'' warnings. */
2223 (void) yyvaluep;
2224
2225 if (!yymsg)
2226 yymsg = "Deleting";
2227 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2228
2229 switch (yytype)
2230 {
2231
2232 default:
2233 break;
2234 }
2235}
2236
2237
2238/* Prevent warnings from -Wmissing-prototypes. */
2239
2240#ifdef YYPARSE_PARAM
2241# if defined (__STDC__) || defined (__cplusplus)
2242int yyparse (void *YYPARSE_PARAM);
2243# else
2244int yyparse ();
2245# endif
2246#else /* ! YYPARSE_PARAM */
2247#if defined (__STDC__) || defined (__cplusplus)
2248int yyparse (void);
2249#else
2250int yyparse ();
2251#endif
2252#endif /* ! YYPARSE_PARAM */
2253
2254
2255
2256/* The look-ahead symbol. */
2257int yychar;
2258
2259/* The semantic value of the look-ahead symbol. */
2260YYSTYPE yylval;
2261
2262/* Number of syntax errors so far. */
2263int yynerrs;
2264
2265
2266
2267/*----------.
2268| yyparse. |
2269`----------*/
2270
2271#ifdef YYPARSE_PARAM
2272# if defined (__STDC__) || defined (__cplusplus)
2273int yyparse (void *YYPARSE_PARAM)
2274# else
2275int yyparse (YYPARSE_PARAM)
2276 void *YYPARSE_PARAM;
2277# endif
2278#else /* ! YYPARSE_PARAM */
2279#if defined (__STDC__) || defined (__cplusplus)
2280int
2281yyparse (void)
2282#else
2283int
2284yyparse ()
2285
2286#endif
2287#endif
2288{
2289
2290 int yystate;
2291 int yyn;
2292 int yyresult;
2293 /* Number of tokens to shift before error messages enabled. */
2294 int yyerrstatus;
2295 /* Look-ahead token as an internal (translated) token number. */
2296 int yytoken = 0;
2297
2298 /* Three stacks and their tools:
2299 `yyss': related to states,
2300 `yyvs': related to semantic values,
2301 `yyls': related to locations.
2302
2303 Refer to the stacks thru separate pointers, to allow yyoverflow
2304 to reallocate them elsewhere. */
2305
2306 /* The state stack. */
2307 short int yyssa[YYINITDEPTH];
2308 short int *yyss = yyssa;
2309 short int *yyssp;
2310
2311 /* The semantic value stack. */
2312 YYSTYPE yyvsa[YYINITDEPTH];
2313 YYSTYPE *yyvs = yyvsa;
2314 YYSTYPE *yyvsp;
2315
2316
2317
2318#define YYPOPSTACK (yyvsp--, yyssp--)
2319
2320 YYSIZE_T yystacksize = YYINITDEPTH;
2321
2322 /* The variables used to return semantic value and location from the
2323 action routines. */
2324 YYSTYPE yyval;
2325
2326
2327 /* When reducing, the number of symbols on the RHS of the reduced
2328 rule. */
2329 int yylen;
2330
2331 YYDPRINTF ((stderr, "Starting parse\n"));
2332
2333 yystate = 0;
2334 yyerrstatus = 0;
2335 yynerrs = 0;
2336 yychar = YYEMPTY; /* Cause a token to be read. */
2337
2338 /* Initialize stack pointers.
2339 Waste one element of value and location stack
2340 so that they stay on the same level as the state stack.
2341 The wasted elements are never initialized. */
2342
2343 yyssp = yyss;
2344 yyvsp = yyvs;
2345
2346 goto yysetstate;
2347
2348/*------------------------------------------------------------.
2349| yynewstate -- Push a new state, which is found in yystate. |
2350`------------------------------------------------------------*/
2351 yynewstate:
2352 /* In all cases, when you get here, the value and location stacks
2353 have just been pushed. so pushing a state here evens the stacks.
2354 */
2355 yyssp++;
2356
2357 yysetstate:
2358 *yyssp = yystate;
2359
2360 if (yyss + yystacksize - 1 <= yyssp)
2361 {
2362 /* Get the current used size of the three stacks, in elements. */
2363 YYSIZE_T yysize = yyssp - yyss + 1;
2364
2365#ifdef yyoverflow
2366 {
2367 /* Give user a chance to reallocate the stack. Use copies of
2368 these so that the &'s don't force the real ones into
2369 memory. */
2370 YYSTYPE *yyvs1 = yyvs;
2371 short int *yyss1 = yyss;
2372
2373
2374 /* Each stack pointer address is followed by the size of the
2375 data in use in that stack, in bytes. This used to be a
2376 conditional around just the two extra args, but that might
2377 be undefined if yyoverflow is a macro. */
2378 yyoverflow (YY_("memory exhausted"),
2379 &yyss1, yysize * sizeof (*yyssp),
2380 &yyvs1, yysize * sizeof (*yyvsp),
2381
2382 &yystacksize);
2383
2384 yyss = yyss1;
2385 yyvs = yyvs1;
2386 }
2387#else /* no yyoverflow */
2388# ifndef YYSTACK_RELOCATE
2389 goto yyexhaustedlab;
2390# else
2391 /* Extend the stack our own way. */
2392 if (YYMAXDEPTH <= yystacksize)
2393 goto yyexhaustedlab;
2394 yystacksize *= 2;
2395 if (YYMAXDEPTH < yystacksize)
2396 yystacksize = YYMAXDEPTH;
2397
2398 {
2399 short int *yyss1 = yyss;
2400 union yyalloc *yyptr =
2401 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2402 if (! yyptr)
2403 goto yyexhaustedlab;
2404 YYSTACK_RELOCATE (yyss);
2405 YYSTACK_RELOCATE (yyvs);
2406
2407# undef YYSTACK_RELOCATE
2408 if (yyss1 != yyssa)
2409 YYSTACK_FREE (yyss1);
2410 }
2411# endif
2412#endif /* no yyoverflow */
2413
2414 yyssp = yyss + yysize - 1;
2415 yyvsp = yyvs + yysize - 1;
2416
2417
2418 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2419 (unsigned long int) yystacksize));
2420
2421 if (yyss + yystacksize - 1 <= yyssp)
2422 YYABORT;
2423 }
2424
2425 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2426
2427 goto yybackup;
2428
2429/*-----------.
2430| yybackup. |
2431`-----------*/
2432yybackup:
2433
2434/* Do appropriate processing given the current state. */
2435/* Read a look-ahead token if we need one and don't already have one. */
2436/* yyresume: */
2437
2438 /* First try to decide what to do without reference to look-ahead token. */
2439
2440 yyn = yypact[yystate];
2441 if (yyn == YYPACT_NINF)
2442 goto yydefault;
2443
2444 /* Not known => get a look-ahead token if don't already have one. */
2445
2446 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
2447 if (yychar == YYEMPTY)
2448 {
2449 YYDPRINTF ((stderr, "Reading a token: "));
2450 yychar = YYLEX;
2451 }
2452
2453 if (yychar <= YYEOF)
2454 {
2455 yychar = yytoken = YYEOF;
2456 YYDPRINTF ((stderr, "Now at end of input.\n"));
2457 }
2458 else
2459 {
2460 yytoken = YYTRANSLATE (yychar);
2461 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2462 }
2463
2464 /* If the proper action on seeing token YYTOKEN is to reduce or to
2465 detect an error, take that action. */
2466 yyn += yytoken;
2467 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2468 goto yydefault;
2469 yyn = yytable[yyn];
2470 if (yyn <= 0)
2471 {
2472 if (yyn == 0 || yyn == YYTABLE_NINF)
2473 goto yyerrlab;
2474 yyn = -yyn;
2475 goto yyreduce;
2476 }
2477
2478 if (yyn == YYFINAL)
2479 YYACCEPT;
2480
2481 /* Shift the look-ahead token. */
2482 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2483
2484 /* Discard the token being shifted unless it is eof. */
2485 if (yychar != YYEOF)
2486 yychar = YYEMPTY;
2487
2488 *++yyvsp = yylval;
2489
2490
2491 /* Count tokens shifted since error; after three, turn off error
2492 status. */
2493 if (yyerrstatus)
2494 yyerrstatus--;
2495
2496 yystate = yyn;
2497 goto yynewstate;
2498
2499
2500/*-----------------------------------------------------------.
2501| yydefault -- do the default action for the current state. |
2502`-----------------------------------------------------------*/
2503yydefault:
2504 yyn = yydefact[yystate];
2505 if (yyn == 0)
2506 goto yyerrlab;
2507 goto yyreduce;
2508
2509
2510/*-----------------------------.
2511| yyreduce -- Do a reduction. |
2512`-----------------------------*/
2513yyreduce:
2514 /* yyn is the number of a rule to reduce with. */
2515 yylen = yyr2[yyn];
2516
2517 /* If YYLEN is nonzero, implement the default value of the action:
2518 `$$ = $1'.
2519
2520 Otherwise, the following line sets YYVAL to garbage.
2521 This behavior is undocumented and Bison
2522 users should not rely upon it. Assigning to YYVAL
2523 unconditionally makes the parser a bit smaller, and it avoids a
2524 GCC warning that YYVAL may be used uninitialized. */
2525 yyval = yyvsp[1-yylen];
2526
2527
2528 YY_REDUCE_PRINT (yyn);
2529 switch (yyn)
2530 {
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2531 case 81:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2532#line 490 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2533 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2534 (yyval.String) = (yyvsp[-1].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2535 ;}
2536 break;
2537
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2538 case 82:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2539#line 493 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2540 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2541 (yyval.String) = new std::string("");
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2542 ;}
2543 break;
2544
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2545 case 90:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2546#line 500 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2547 { (yyval.String) = new std::string(""); ;}
2548 break;
2549
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2550 case 97:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2551#line 505 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer16244f42006-12-01 21:10:07 +0000[diff] [blame]2552 {
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]2553 *(yyvsp[-1].String) += *(yyvsp[0].String);
2554 delete (yyvsp[0].String);
Reid Spencer16244f42006-12-01 21:10:07 +0000[diff] [blame]2555 (yyval.String) = (yyvsp[-1].String);
2556 ;}
2557 break;
2558
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2559 case 98:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2560#line 510 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2561 { (yyval.String) = new std::string(""); ;}
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2562 break;
2563
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2564 case 99:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2565#line 515 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencerfcb5df82006-12-01 22:34:43 +0000[diff] [blame]2566 { (yyval.String) = new std::string(); ;}
2567 break;
2568
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2569 case 100:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2570#line 516 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]2571 { *(yyvsp[-1].String) += " " + *(yyvsp[0].String); delete (yyvsp[0].String); (yyval.String) = (yyvsp[-1].String); ;}
2572 break;
2573
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2574 case 101:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2575#line 519 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]2576 { (yyval.String) = new std::string(); ;}
2577 break;
2578
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2579 case 102:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2580#line 520 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2581 {
2582 (yyvsp[-1].String)->insert(0, ", ");
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]2583 *(yyvsp[-1].String) += " " + *(yyvsp[0].String);
2584 delete (yyvsp[0].String);
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2585 (yyval.String) = (yyvsp[-1].String);
2586 ;}
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2587 break;
2588
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2589 case 103:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2590#line 528 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2591 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2592 *(yyvsp[-1].String) += " " + *(yyvsp[0].String);
2593 delete (yyvsp[0].String);
2594 (yyval.String) = (yyvsp[-1].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2595 ;}
2596 break;
2597
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2598 case 104:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2599#line 534 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencerfcb5df82006-12-01 22:34:43 +0000[diff] [blame]2600 { (yyval.String) = new std::string(); ;}
2601 break;
2602
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2603 case 106:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2604#line 538 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]2605 { (yyval.String) = new std::string(); ;}
2606 break;
2607
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2608 case 107:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2609#line 539 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2610 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2611 (yyvsp[-1].String)->insert(0, ", ");
2612 if (!(yyvsp[0].String)->empty())
2613 *(yyvsp[-1].String) += " " + *(yyvsp[0].String);
2614 delete (yyvsp[0].String);
2615 (yyval.String) = (yyvsp[-1].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2616 ;}
2617 break;
2618
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2619 case 109:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2620#line 549 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2621 {
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]2622 *(yyvsp[-1].String) += " " + *(yyvsp[0].String);
2623 delete (yyvsp[0].String);
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2624 (yyval.String) = (yyvsp[-1].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2625 ;}
2626 break;
2627
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2628 case 127:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2629#line 571 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2630 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2631 (yyval.Type) = new TypeInfo((yyvsp[0].String), OpaqueTy);
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]2632 ;}
2633 break;
2634
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2635 case 128:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2636#line 574 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]2637 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2638 (yyval.Type) = new TypeInfo((yyvsp[0].String), UnresolvedTy);
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]2639 ;}
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2640 break;
2641
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2642 case 129:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2643#line 577 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]2644 {
2645 (yyval.Type) = (yyvsp[0].Type);
2646 ;}
2647 break;
2648
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2649 case 130:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2650#line 580 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2651 { // Type UpReference
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]2652 (yyvsp[0].String)->insert(0, "\\");
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2653 (yyval.Type) = new TypeInfo((yyvsp[0].String), UpRefTy);
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2654 ;}
2655 break;
2656
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2657 case 131:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2658#line 584 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2659 { // Function derived type?
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2660 std::string newTy( (yyvsp[-3].Type)->getNewTy() + "(");
2661 for (unsigned i = 0; i < (yyvsp[-1].TypeVec)->size(); ++i) {
2662 if (i != 0)
2663 newTy += ", ";
2664 if ((*(yyvsp[-1].TypeVec))[i]->isVoid())
2665 newTy += "...";
2666 else
2667 newTy += (*(yyvsp[-1].TypeVec))[i]->getNewTy();
2668 }
2669 newTy += ")";
2670 (yyval.Type) = new TypeInfo(new std::string(newTy), (yyvsp[-3].Type), (yyvsp[-1].TypeVec));
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2671 ;}
2672 break;
2673
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2674 case 132:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2675#line 597 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2676 { // Sized array type?
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]2677 (yyvsp[-3].String)->insert(0,"[ ");
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2678 *(yyvsp[-3].String) += " x " + (yyvsp[-1].Type)->getNewTy() + " ]";
2679 uint64_t elems = atoi((yyvsp[-3].String)->c_str());
2680 (yyval.Type) = new TypeInfo((yyvsp[-3].String), ArrayTy, (yyvsp[-1].Type), elems);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2681 ;}
2682 break;
2683
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2684 case 133:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2685#line 603 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2686 { // Packed array type?
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]2687 (yyvsp[-3].String)->insert(0,"< ");
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2688 *(yyvsp[-3].String) += " x " + (yyvsp[-1].Type)->getNewTy() + " >";
2689 uint64_t elems = atoi((yyvsp[-3].String)->c_str());
2690 (yyval.Type) = new TypeInfo((yyvsp[-3].String), PackedTy, (yyvsp[-1].Type), elems);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2691 ;}
2692 break;
2693
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2694 case 134:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2695#line 609 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2696 { // Structure type?
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2697 std::string newTy("{");
2698 for (unsigned i = 0; i < (yyvsp[-1].TypeVec)->size(); ++i) {
2699 if (i != 0)
2700 newTy += ", ";
2701 newTy += (*(yyvsp[-1].TypeVec))[i]->getNewTy();
2702 }
2703 newTy += "}";
2704 (yyval.Type) = new TypeInfo(new std::string(newTy), StructTy, (yyvsp[-1].TypeVec));
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2705 ;}
2706 break;
2707
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2708 case 135:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2709#line 619 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2710 { // Empty structure type?
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2711 (yyval.Type) = new TypeInfo(new std::string("{}"), StructTy, new TypeList());
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2712 ;}
2713 break;
2714
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2715 case 136:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2716#line 622 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2717 { // Packed Structure type?
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2718 std::string newTy("<{");
2719 for (unsigned i = 0; i < (yyvsp[-2].TypeVec)->size(); ++i) {
2720 if (i != 0)
2721 newTy += ", ";
2722 newTy += (*(yyvsp[-2].TypeVec))[i]->getNewTy();
2723 }
2724 newTy += "}>";
2725 (yyval.Type) = new TypeInfo(new std::string(newTy), PackedStructTy, (yyvsp[-2].TypeVec));
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2726 ;}
2727 break;
2728
2729 case 137:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2730#line 632 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2731 { // Empty packed structure type?
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2732 (yyval.Type) = new TypeInfo(new std::string("<{}>"), PackedStructTy, new TypeList());
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2733 ;}
2734 break;
2735
2736 case 138:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2737#line 635 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2738 { // Pointer type?
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2739 (yyval.Type) = (yyvsp[-1].Type)->getPointerType();
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2740 ;}
2741 break;
2742
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2743 case 139:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2744#line 643 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2745 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2746 (yyval.TypeVec) = new TypeList();
2747 (yyval.TypeVec)->push_back((yyvsp[0].Type));
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2748 ;}
2749 break;
2750
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2751 case 140:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2752#line 647 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2753 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2754 (yyval.TypeVec) = (yyvsp[-2].TypeVec);
2755 (yyval.TypeVec)->push_back((yyvsp[0].Type));
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2756 ;}
2757 break;
2758
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2759 case 142:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2760#line 655 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2761 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2762 (yyval.TypeVec) = (yyvsp[-2].TypeVec);
2763 (yyval.TypeVec)->push_back(new TypeInfo("void",VoidTy));
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2764 delete (yyvsp[0].String);
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2765 ;}
2766 break;
2767
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2768 case 143:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2769#line 660 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2770 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2771 (yyval.TypeVec) = new TypeList();
2772 (yyval.TypeVec)->push_back(new TypeInfo("void",VoidTy));
2773 delete (yyvsp[0].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2774 ;}
2775 break;
2776
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2777 case 144:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2778#line 665 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2779 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2780 (yyval.TypeVec) = new TypeList();
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2781 ;}
2782 break;
2783
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2784 case 145:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2785#line 675 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2786 { // Nonempty unsized arr
2787 (yyval.Const).type = (yyvsp[-3].Type);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2788 (yyval.Const).cnst = new std::string((yyvsp[-3].Type)->getNewTy());
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2789 *(yyval.Const).cnst += " [ " + *(yyvsp[-1].String) + " ]";
2790 delete (yyvsp[-1].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2791 ;}
2792 break;
2793
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2794 case 146:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2795#line 681 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2796 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2797 (yyval.Const).type = (yyvsp[-2].Type);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2798 (yyval.Const).cnst = new std::string((yyvsp[-2].Type)->getNewTy());
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2799 *(yyval.Const).cnst += "[ ]";
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2800 ;}
2801 break;
2802
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2803 case 147:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2804#line 686 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2805 {
2806 (yyval.Const).type = (yyvsp[-2].Type);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2807 (yyval.Const).cnst = new std::string((yyvsp[-2].Type)->getNewTy());
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2808 *(yyval.Const).cnst += " c" + *(yyvsp[0].String);
2809 delete (yyvsp[0].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2810 ;}
2811 break;
2812
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2813 case 148:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2814#line 692 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2815 { // Nonempty unsized arr
2816 (yyval.Const).type = (yyvsp[-3].Type);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2817 (yyval.Const).cnst = new std::string((yyvsp[-3].Type)->getNewTy());
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2818 *(yyval.Const).cnst += " < " + *(yyvsp[-1].String) + " >";
2819 delete (yyvsp[-1].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2820 ;}
2821 break;
2822
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2823 case 149:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2824#line 698 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2825 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2826 (yyval.Const).type = (yyvsp[-3].Type);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2827 (yyval.Const).cnst = new std::string((yyvsp[-3].Type)->getNewTy());
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2828 *(yyval.Const).cnst += " { " + *(yyvsp[-1].String) + " }";
2829 delete (yyvsp[-1].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2830 ;}
2831 break;
2832
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2833 case 150:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2834#line 704 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2835 {
2836 (yyval.Const).type = (yyvsp[-2].Type);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2837 (yyval.Const).cnst = new std::string((yyvsp[-2].Type)->getNewTy());
Reid Spencer0b7e5072006-12-01 22:42:01 +0000[diff] [blame]2838 *(yyval.Const).cnst += " {}";
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2839 ;}
2840 break;
2841
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2842 case 151:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2843#line 709 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2844 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2845 (yyval.Const).type = (yyvsp[-1].Type);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2846 (yyval.Const).cnst = new std::string((yyvsp[-1].Type)->getNewTy());
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]2847 *(yyval.Const).cnst += " " + *(yyvsp[0].String);
2848 delete (yyvsp[0].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2849 ;}
2850 break;
2851
Reid Spencer187ccf82006-12-09 16:57:22 +0000[diff] [blame]2852 case 152:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2853#line 715 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]2854 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2855 (yyval.Const).type = (yyvsp[-1].Type);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2856 (yyval.Const).cnst = new std::string((yyvsp[-1].Type)->getNewTy());
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]2857 *(yyval.Const).cnst += " " + *(yyvsp[0].String);
2858 delete (yyvsp[0].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2859 ;}
2860 break;
2861
Reid Spencer187ccf82006-12-09 16:57:22 +0000[diff] [blame]2862 case 153:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2863#line 721 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer187ccf82006-12-09 16:57:22 +0000[diff] [blame]2864 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2865 std::string Name = getUniqueName((yyvsp[0].String),(yyvsp[-1].Type));
Reid Spencer187ccf82006-12-09 16:57:22 +0000[diff] [blame]2866 (yyval.Const).type = (yyvsp[-1].Type);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2867 (yyval.Const).cnst = new std::string((yyvsp[-1].Type)->getNewTy());
2868 *(yyval.Const).cnst += " " + Name;
Reid Spencer187ccf82006-12-09 16:57:22 +0000[diff] [blame]2869 delete (yyvsp[0].String);
2870 ;}
2871 break;
2872
2873 case 154:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2874#line 728 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2875 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2876 (yyval.Const).type = (yyvsp[-1].Type);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2877 (yyval.Const).cnst = new std::string((yyvsp[-1].Type)->getNewTy());
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]2878 *(yyval.Const).cnst += " " + *(yyvsp[0].String);
2879 delete (yyvsp[0].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2880 ;}
2881 break;
2882
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2883 case 155:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2884#line 734 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2885 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2886 (yyval.Const).type = (yyvsp[-1].Type);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2887 (yyval.Const).cnst = new std::string((yyvsp[-1].Type)->getNewTy());
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]2888 *(yyval.Const).cnst += " " + *(yyvsp[0].String);
2889 delete (yyvsp[0].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2890 ;}
2891 break;
2892
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2893 case 156:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2894#line 740 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2895 { // integral constants
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2896 (yyval.Const).type = (yyvsp[-1].Type);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2897 (yyval.Const).cnst = new std::string((yyvsp[-1].Type)->getNewTy());
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]2898 *(yyval.Const).cnst += " " + *(yyvsp[0].String);
2899 delete (yyvsp[0].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2900 ;}
2901 break;
2902
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2903 case 157:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2904#line 746 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2905 { // integral constants
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]2906 (yyval.Const).type = (yyvsp[-1].Type);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2907 (yyval.Const).cnst = new std::string((yyvsp[-1].Type)->getNewTy());
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]2908 *(yyval.Const).cnst += " " + *(yyvsp[0].String);
2909 delete (yyvsp[0].String);
2910 ;}
2911 break;
2912
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2913 case 158:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2914#line 752 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2915 { // Boolean constants
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]2916 (yyval.Const).type = (yyvsp[-1].Type);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2917 (yyval.Const).cnst = new std::string((yyvsp[-1].Type)->getNewTy());
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]2918 *(yyval.Const).cnst += " " + *(yyvsp[0].String);
2919 delete (yyvsp[0].String);
2920 ;}
2921 break;
2922
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]2923 case 159:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2924#line 758 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2925 { // Boolean constants
2926 (yyval.Const).type = (yyvsp[-1].Type);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2927 (yyval.Const).cnst = new std::string((yyvsp[-1].Type)->getNewTy());
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2928 *(yyval.Const).cnst += " " + *(yyvsp[0].String);
2929 delete (yyvsp[0].String);
2930 ;}
2931 break;
2932
2933 case 160:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2934#line 764 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2935 { // Float & Double constants
2936 (yyval.Const).type = (yyvsp[-1].Type);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2937 (yyval.Const).cnst = new std::string((yyvsp[-1].Type)->getNewTy());
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2938 *(yyval.Const).cnst += " " + *(yyvsp[0].String);
2939 delete (yyvsp[0].String);
2940 ;}
2941 break;
2942
2943 case 161:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2944#line 772 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2945 {
Reid Spencer280d8012006-12-01 23:40:53 +0000[diff] [blame]2946 std::string source = *(yyvsp[-3].Const).cnst;
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2947 TypeInfo* DstTy = ResolveType((yyvsp[-1].Type));
Reid Spencer280d8012006-12-01 23:40:53 +0000[diff] [blame]2948 if (*(yyvsp[-5].String) == "cast") {
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]2949 // Call getCastUpgrade to upgrade the old cast
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2950 (yyval.String) = new std::string(getCastUpgrade(source, (yyvsp[-3].Const).type, DstTy, true));
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]2951 } else {
2952 // Nothing to upgrade, just create the cast constant expr
2953 (yyval.String) = new std::string(*(yyvsp[-5].String));
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]2954 *(yyval.String) += "( " + source + " to " + (yyvsp[-1].Type)->getNewTy() + ")";
Reid Spencer280d8012006-12-01 23:40:53 +0000[diff] [blame]2955 }
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2956 delete (yyvsp[-5].String); (yyvsp[-3].Const).destroy(); delete (yyvsp[-2].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2957 ;}
2958 break;
2959
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2960 case 162:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2961#line 785 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2962 {
Reid Spencerf8483652006-12-02 15:16:01 +0000[diff] [blame]2963 *(yyvsp[-4].String) += "(" + *(yyvsp[-2].Const).cnst;
2964 for (unsigned i = 0; i < (yyvsp[-1].ValList)->size(); ++i) {
2965 ValueInfo& VI = (*(yyvsp[-1].ValList))[i];
2966 *(yyvsp[-4].String) += ", " + *VI.val;
2967 VI.destroy();
2968 }
2969 *(yyvsp[-4].String) += ")";
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2970 (yyval.String) = (yyvsp[-4].String);
2971 (yyvsp[-2].Const).destroy();
Reid Spencerf8483652006-12-02 15:16:01 +0000[diff] [blame]2972 delete (yyvsp[-1].ValList);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2973 ;}
2974 break;
2975
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2976 case 163:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2977#line 797 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2978 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]2979 *(yyvsp[-7].String) += "(" + *(yyvsp[-5].Const).cnst + "," + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")";
2980 (yyvsp[-5].Const).destroy(); (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy();
2981 (yyval.String) = (yyvsp[-7].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2982 ;}
2983 break;
2984
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2985 case 164:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2986#line 802 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2987 {
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]2988 const char* op = getDivRemOpcode(*(yyvsp[-5].String), (yyvsp[-3].Const).type);
2989 (yyval.String) = new std::string(op);
2990 *(yyval.String) += "(" + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")";
2991 delete (yyvsp[-5].String); (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy();
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]2992 ;}
2993 break;
2994
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]2995 case 165:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]2996#line 808 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]2997 {
2998 *(yyvsp[-5].String) += "(" + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")";
2999 (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy();
3000 (yyval.String) = (yyvsp[-5].String);
3001 ;}
3002 break;
3003
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3004 case 166:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3005#line 813 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]3006 {
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]3007 *(yyvsp[-5].String) = getCompareOp(*(yyvsp[-5].String), (yyvsp[-3].Const).type);
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]3008 *(yyvsp[-5].String) += "(" + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")";
3009 (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy();
3010 (yyval.String) = (yyvsp[-5].String);
3011 ;}
3012 break;
3013
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]3014 case 167:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3015#line 819 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3016 {
3017 *(yyvsp[-6].String) += "(" + *(yyvsp[-5].String) + "," + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")";
3018 delete (yyvsp[-5].String); (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy();
3019 (yyval.String) = (yyvsp[-6].String);
3020 ;}
3021 break;
3022
3023 case 168:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3024#line 824 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3025 {
3026 *(yyvsp[-6].String) += "(" + *(yyvsp[-5].String) + "," + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")";
3027 delete (yyvsp[-5].String); (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy();
3028 (yyval.String) = (yyvsp[-6].String);
3029 ;}
3030 break;
3031
3032 case 169:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3033#line 829 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]3034 {
Reid Spencerf7bde222006-12-01 22:26:37 +0000[diff] [blame]3035 const char* shiftop = (yyvsp[-5].String)->c_str();
3036 if (*(yyvsp[-5].String) == "shr")
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3037 shiftop = ((yyvsp[-3].Const).type->isUnsigned()) ? "lshr" : "ashr";
Reid Spencerf7bde222006-12-01 22:26:37 +0000[diff] [blame]3038 (yyval.String) = new std::string(shiftop);
3039 *(yyval.String) += "(" + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")";
3040 delete (yyvsp[-5].String); (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy();
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3041 ;}
3042 break;
3043
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3044 case 170:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3045#line 837 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3046 {
Reid Spencerf7bde222006-12-01 22:26:37 +0000[diff] [blame]3047 *(yyvsp[-5].String) += "(" + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")";
3048 (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy();
3049 (yyval.String) = (yyvsp[-5].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3050 ;}
3051 break;
3052
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]3053 case 171:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3054#line 842 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3055 {
3056 *(yyvsp[-7].String) += "(" + *(yyvsp[-5].Const).cnst + "," + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")";
3057 (yyvsp[-5].Const).destroy(); (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy();
3058 (yyval.String) = (yyvsp[-7].String);
3059 ;}
3060 break;
3061
3062 case 172:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3063#line 847 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3064 {
3065 *(yyvsp[-7].String) += "(" + *(yyvsp[-5].Const).cnst + "," + *(yyvsp[-3].Const).cnst + "," + *(yyvsp[-1].Const).cnst + ")";
3066 (yyvsp[-5].Const).destroy(); (yyvsp[-3].Const).destroy(); (yyvsp[-1].Const).destroy();
3067 (yyval.String) = (yyvsp[-7].String);
3068 ;}
3069 break;
3070
3071 case 173:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3072#line 857 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3073 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3074 *(yyvsp[-2].String) += ", " + *(yyvsp[0].Const).cnst;
3075 (yyvsp[0].Const).destroy();
3076 (yyval.String) = (yyvsp[-2].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3077 ;}
3078 break;
3079
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3080 case 174:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3081#line 862 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3082 { (yyval.String) = new std::string(*(yyvsp[0].Const).cnst); (yyvsp[0].Const).destroy(); ;}
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3083 break;
3084
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3085 case 177:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3086#line 877 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3087 {
3088;}
3089 break;
3090
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]3091 case 178:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3092#line 882 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3093 {
Reid Spencerd154b572006-12-01 20:36:40 +0000[diff] [blame]3094 (yyval.String) = 0;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3095 ;}
3096 break;
3097
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]3098 case 179:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3099#line 885 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3100 {
3101 *O << *(yyvsp[0].String) << '\n';
3102 delete (yyvsp[0].String);
3103 (yyval.String) = 0;
3104 ;}
3105 break;
3106
3107 case 180:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3108#line 890 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3109 {
3110 *O << "module asm " << ' ' << *(yyvsp[0].String) << '\n';
3111 (yyval.String) = 0;
3112 ;}
3113 break;
3114
3115 case 181:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3116#line 894 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3117 {
Reid Spencerd154b572006-12-01 20:36:40 +0000[diff] [blame]3118 *O << "implementation\n";
3119 (yyval.String) = 0;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3120 ;}
3121 break;
3122
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3123 case 182:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3124#line 898 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]3125 { (yyval.String) = 0; ;}
3126 break;
3127
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3128 case 184:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3129#line 900 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]3130 { (yyval.String) = (yyvsp[0].String); *(yyval.String) = "external"; ;}
3131 break;
3132
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3133 case 185:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3134#line 903 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3135 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3136 EnumeratedTypes.push_back(*(yyvsp[0].Type));
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]3137 if (!(yyvsp[-2].String)->empty()) {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3138 NamedTypes[*(yyvsp[-2].String)] = *(yyvsp[0].Type);
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]3139 *O << *(yyvsp[-2].String) << " = ";
3140 }
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3141 *O << "type " << (yyvsp[0].Type)->getNewTy() << '\n';
3142 delete (yyvsp[-2].String); delete (yyvsp[-1].String);
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3143 (yyval.String) = 0;
3144 ;}
3145 break;
3146
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3147 case 186:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3148#line 913 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3149 { // Function prototypes can be in const pool
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3150 *O << *(yyvsp[0].String) << '\n';
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3151 delete (yyvsp[0].String);
3152 (yyval.String) = 0;
3153 ;}
3154 break;
3155
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3156 case 187:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3157#line 918 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3158 { // Asm blocks can be in the const pool
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3159 *O << *(yyvsp[-2].String) << ' ' << *(yyvsp[-1].String) << ' ' << *(yyvsp[0].String) << '\n';
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3160 delete (yyvsp[-2].String); delete (yyvsp[-1].String); delete (yyvsp[0].String);
3161 (yyval.String) = 0;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3162 ;}
3163 break;
3164
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3165 case 188:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3166#line 923 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3167 {
Reid Spencerf12ee422006-12-05 19:21:25 +0000[diff] [blame]3168 if (!(yyvsp[-4].String)->empty()) {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3169 std::string Name = getUniqueName((yyvsp[-4].String),(yyvsp[-1].Const).type);
3170 *O << Name << " = ";
3171 Globals[Name] = *(yyvsp[-1].Const).type;
Reid Spencerf12ee422006-12-05 19:21:25 +0000[diff] [blame]3172 }
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3173 *O << *(yyvsp[-3].String) << ' ' << *(yyvsp[-2].String) << ' ' << *(yyvsp[-1].Const).cnst << ' ' << *(yyvsp[0].String) << '\n';
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3174 delete (yyvsp[-4].String); delete (yyvsp[-3].String); delete (yyvsp[-2].String); delete (yyvsp[0].String);
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3175 (yyval.String) = 0;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3176 ;}
3177 break;
3178
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]3179 case 189:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3180#line 933 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencerfcb5df82006-12-01 22:34:43 +0000[diff] [blame]3181 {
Reid Spencerf12ee422006-12-05 19:21:25 +0000[diff] [blame]3182 if (!(yyvsp[-4].String)->empty()) {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3183 std::string Name = getUniqueName((yyvsp[-4].String),(yyvsp[-1].Type));
3184 *O << Name << " = ";
3185 Globals[Name] = *(yyvsp[-1].Type);
Reid Spencerf12ee422006-12-05 19:21:25 +0000[diff] [blame]3186 }
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3187 *O << *(yyvsp[-3].String) << ' ' << *(yyvsp[-2].String) << ' ' << (yyvsp[-1].Type)->getNewTy() << ' ' << *(yyvsp[0].String) << '\n';
3188 delete (yyvsp[-4].String); delete (yyvsp[-3].String); delete (yyvsp[-2].String); delete (yyvsp[0].String);
Reid Spencerfcb5df82006-12-01 22:34:43 +0000[diff] [blame]3189 (yyval.String) = 0;
3190 ;}
3191 break;
3192
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]3193 case 190:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3194#line 943 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3195 {
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3196 if (!(yyvsp[-4].String)->empty()) {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3197 std::string Name = getUniqueName((yyvsp[-4].String),(yyvsp[-1].Type));
3198 *O << Name << " = ";
3199 Globals[Name] = *(yyvsp[-1].Type);
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3200 }
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3201 *O << *(yyvsp[-3].String) << ' ' << *(yyvsp[-2].String) << ' ' << (yyvsp[-1].Type)->getNewTy() << ' ' << *(yyvsp[0].String) << '\n';
3202 delete (yyvsp[-4].String); delete (yyvsp[-3].String); delete (yyvsp[-2].String); delete (yyvsp[0].String);
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3203 (yyval.String) = 0;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3204 ;}
3205 break;
3206
Reid Spencerf5626a32007-01-01 01:20:41 +0000[diff] [blame]3207 case 191:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3208#line 953 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencerf5626a32007-01-01 01:20:41 +0000[diff] [blame]3209 {
3210 if (!(yyvsp[-4].String)->empty()) {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3211 std::string Name = getUniqueName((yyvsp[-4].String),(yyvsp[-1].Type));
3212 *O << Name << " = ";
3213 Globals[Name] = *(yyvsp[-1].Type);
Reid Spencerf5626a32007-01-01 01:20:41 +0000[diff] [blame]3214 }
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3215 *O << *(yyvsp[-3].String) << ' ' << *(yyvsp[-2].String) << ' ' << (yyvsp[-1].Type)->getNewTy() << ' ' << *(yyvsp[0].String) << '\n';
3216 delete (yyvsp[-4].String); delete (yyvsp[-3].String); delete (yyvsp[-2].String); delete (yyvsp[0].String);
Reid Spencerf5626a32007-01-01 01:20:41 +0000[diff] [blame]3217 (yyval.String) = 0;
3218 ;}
3219 break;
3220
3221 case 192:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3222#line 963 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3223 {
3224 *O << *(yyvsp[-1].String) << ' ' << *(yyvsp[0].String) << '\n';
3225 delete (yyvsp[-1].String); delete (yyvsp[0].String);
3226 (yyval.String) = 0;
3227 ;}
3228 break;
3229
3230 case 193:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3231#line 968 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3232 {
3233 *O << *(yyvsp[-2].String) << " = " << *(yyvsp[0].String) << '\n';
3234 delete (yyvsp[-2].String); delete (yyvsp[0].String);
3235 (yyval.String) = 0;
3236 ;}
3237 break;
3238
3239 case 194:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3240#line 973 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3241 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3242 (yyval.String) = 0;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3243 ;}
3244 break;
3245
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3246 case 198:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3247#line 983 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3248 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3249 *(yyvsp[-2].String) += " = " + *(yyvsp[0].String);
3250 delete (yyvsp[0].String);
3251 (yyval.String) = (yyvsp[-2].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3252 ;}
3253 break;
3254
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3255 case 199:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3256#line 988 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3257 {
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]3258 *(yyvsp[-2].String) += " = " + *(yyvsp[0].String);
3259 if (*(yyvsp[0].String) == "64")
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3260 SizeOfPointer = 64;
Reid Spencerf2d55322006-12-01 21:52:30 +0000[diff] [blame]3261 delete (yyvsp[0].String);
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3262 (yyval.String) = (yyvsp[-2].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3263 ;}
3264 break;
3265
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]3266 case 200:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3267#line 995 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3268 {
3269 *(yyvsp[-2].String) += " = " + *(yyvsp[0].String);
3270 delete (yyvsp[0].String);
3271 (yyval.String) = (yyvsp[-2].String);
3272 ;}
3273 break;
3274
3275 case 201:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3276#line 1000 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3277 {
3278 *(yyvsp[-2].String) += " = " + *(yyvsp[0].String);
3279 delete (yyvsp[0].String);
3280 (yyval.String) = (yyvsp[-2].String);
3281 ;}
3282 break;
3283
3284 case 202:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3285#line 1007 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3286 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3287 (yyvsp[-1].String)->insert(0, "[ ");
3288 *(yyvsp[-1].String) += " ]";
3289 (yyval.String) = (yyvsp[-1].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3290 ;}
3291 break;
3292
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3293 case 203:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3294#line 1014 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3295 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3296 *(yyvsp[-2].String) += ", " + *(yyvsp[0].String);
3297 delete (yyvsp[0].String);
3298 (yyval.String) = (yyvsp[-2].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3299 ;}
3300 break;
3301
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3302 case 205:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3303#line 1020 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3304 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3305 (yyval.String) = new std::string();
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3306 ;}
3307 break;
3308
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3309 case 209:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3310#line 1029 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3311 { (yyval.String) = new std::string(); ;}
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3312 break;
3313
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3314 case 210:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3315#line 1031 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3316 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3317 (yyval.String) = new std::string((yyvsp[-1].Type)->getNewTy());
3318 if (!(yyvsp[0].String)->empty()) {
3319 std::string Name = getUniqueName((yyvsp[0].String), (yyvsp[-1].Type));
3320 *(yyval.String) += " " + Name;
3321 }
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3322 delete (yyvsp[0].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3323;}
3324 break;
3325
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3326 case 211:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3327#line 1040 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3328 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3329 *(yyvsp[-2].String) += ", " + *(yyvsp[0].String);
3330 delete (yyvsp[0].String);
3331 ;}
3332 break;
3333
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]3334 case 212:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3335#line 1044 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3336 {
3337 (yyval.String) = (yyvsp[0].String);
3338 ;}
3339 break;
3340
3341 case 213:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3342#line 1048 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3343 {
3344 (yyval.String) = (yyvsp[0].String);
3345 ;}
3346 break;
3347
3348 case 214:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3349#line 1051 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencerf7bde222006-12-01 22:26:37 +0000[diff] [blame]3350 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3351 *(yyvsp[-2].String) += ", ...";
3352 (yyval.String) = (yyvsp[-2].String);
3353 delete (yyvsp[0].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3354 ;}
3355 break;
3356
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3357 case 215:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3358#line 1056 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3359 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3360 (yyval.String) = (yyvsp[0].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3361 ;}
3362 break;
3363
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3364 case 216:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3365#line 1059 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencerd154b572006-12-01 20:36:40 +0000[diff] [blame]3366 { (yyval.String) = new std::string(); ;}
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3367 break;
3368
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3369 case 217:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3370#line 1062 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3371 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3372 if (!(yyvsp[-7].String)->empty()) {
3373 *(yyvsp[-7].String) += " ";
3374 }
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3375 *(yyvsp[-7].String) += (yyvsp[-6].Type)->getNewTy() + " " + *(yyvsp[-5].String) + "(" + *(yyvsp[-3].String) + ")";
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3376 if (!(yyvsp[-1].String)->empty()) {
3377 *(yyvsp[-7].String) += " " + *(yyvsp[-1].String);
3378 }
3379 if (!(yyvsp[0].String)->empty()) {
3380 *(yyvsp[-7].String) += " " + *(yyvsp[0].String);
3381 }
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3382 delete (yyvsp[-5].String);
3383 delete (yyvsp[-3].String);
3384 delete (yyvsp[-1].String);
3385 delete (yyvsp[0].String);
3386 (yyval.String) = (yyvsp[-7].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3387 ;}
3388 break;
3389
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3390 case 218:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3391#line 1080 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]3392 { (yyval.String) = new std::string("{"); delete (yyvsp[0].String); ;}
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3393 break;
3394
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3395 case 219:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3396#line 1081 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]3397 { (yyval.String) = new std::string ("{"); ;}
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3398 break;
3399
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]3400 case 220:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3401#line 1084 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3402 {
3403 *O << "define ";
3404 if (!(yyvsp[-2].String)->empty()) {
3405 *O << *(yyvsp[-2].String) << ' ';
3406 }
3407 *O << *(yyvsp[-1].String) << ' ' << *(yyvsp[0].String) << '\n';
3408 delete (yyvsp[-2].String); delete (yyvsp[-1].String); delete (yyvsp[0].String);
3409 (yyval.String) = 0;
3410 ;}
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3411 break;
3412
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]3413 case 221:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3414#line 1095 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3415 { (yyval.String) = new std::string("}"); delete (yyvsp[0].String); ;}
3416 break;
3417
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3418 case 222:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3419#line 1096 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3420 { (yyval.String) = new std::string("}"); ;}
3421 break;
3422
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3423 case 223:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3424#line 1098 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3425 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3426 if ((yyvsp[-1].String))
3427 *O << *(yyvsp[-1].String);
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3428 *O << *(yyvsp[0].String) << "\n\n";
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3429 delete (yyvsp[-2].String); delete (yyvsp[-1].String); delete (yyvsp[0].String);
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3430 (yyval.String) = 0;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3431;}
3432 break;
3433
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3434 case 224:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3435#line 1107 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3436 { (yyval.String) = new std::string(); ;}
3437 break;
3438
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3439 case 227:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3440#line 1113 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3441 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3442 if (!(yyvsp[-1].String)->empty())
3443 *(yyvsp[-2].String) += " " + *(yyvsp[-1].String);
3444 *(yyvsp[-2].String) += " " + *(yyvsp[0].String);
3445 delete (yyvsp[-1].String);
3446 delete (yyvsp[0].String);
3447 (yyval.String) = (yyvsp[-2].String);
3448 ;}
3449 break;
3450
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3451 case 228:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3452#line 1126 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencerd154b572006-12-01 20:36:40 +0000[diff] [blame]3453 { (yyval.String) = new std::string(); ;}
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3454 break;
3455
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3456 case 238:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3457#line 1132 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3458 {
3459 (yyvsp[-1].String)->insert(0, "<");
3460 *(yyvsp[-1].String) += ">";
3461 (yyval.String) = (yyvsp[-1].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3462 ;}
3463 break;
3464
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3465 case 240:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3466#line 1138 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3467 {
3468 if (!(yyvsp[-3].String)->empty()) {
3469 *(yyvsp[-4].String) += " " + *(yyvsp[-3].String);
3470 }
3471 *(yyvsp[-4].String) += " " + *(yyvsp[-2].String) + ", " + *(yyvsp[0].String);
3472 delete (yyvsp[-3].String); delete (yyvsp[-2].String); delete (yyvsp[0].String);
3473 (yyval.String) = (yyvsp[-4].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3474 ;}
3475 break;
3476
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3477 case 243:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3478#line 1151 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3479 {
Reid Spencerf459d392006-12-02 16:19:52 +0000[diff] [blame]3480 (yyval.Value).val = (yyvsp[0].String);
3481 (yyval.Value).constant = false;
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3482 (yyval.Value).type = new TypeInfo();
Reid Spencerf459d392006-12-02 16:19:52 +0000[diff] [blame]3483 ;}
3484 break;
3485
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3486 case 244:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3487#line 1156 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencerf459d392006-12-02 16:19:52 +0000[diff] [blame]3488 {
3489 (yyval.Value).val = (yyvsp[0].String);
3490 (yyval.Value).constant = true;
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3491 (yyval.Value).type = new TypeInfo();
Reid Spencerf459d392006-12-02 16:19:52 +0000[diff] [blame]3492 ;}
3493 break;
3494
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3495 case 245:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3496#line 1166 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencerf459d392006-12-02 16:19:52 +0000[diff] [blame]3497 {
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3498 ResolveType((yyvsp[-1].Type));
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3499 std::string Name = getUniqueName((yyvsp[0].Value).val, (yyvsp[-1].Type));
Reid Spencerf459d392006-12-02 16:19:52 +0000[diff] [blame]3500 (yyval.Value) = (yyvsp[0].Value);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3501 delete (yyval.Value).val;
3502 delete (yyval.Value).type;
3503 (yyval.Value).val = new std::string((yyvsp[-1].Type)->getNewTy() + " " + Name);
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3504 (yyval.Value).type = (yyvsp[-1].Type);
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3505 ;}
3506 break;
3507
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3508 case 246:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3509#line 1176 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3510 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3511 (yyval.String) = 0;
3512 ;}
3513 break;
3514
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3515 case 247:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3516#line 1179 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3517 { // Do not allow functions with 0 basic blocks
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3518 (yyval.String) = 0;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3519 ;}
3520 break;
3521
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3522 case 248:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3523#line 1187 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3524 {
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3525 (yyval.String) = 0;
3526 ;}
3527 break;
3528
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3529 case 249:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3530#line 1191 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3531 {
3532 *O << " " << *(yyvsp[0].String) << '\n';
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3533 delete (yyvsp[0].String);
3534 (yyval.String) = 0;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3535 ;}
3536 break;
3537
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3538 case 250:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3539#line 1196 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3540 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3541 (yyval.String) = 0;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3542 ;}
3543 break;
3544
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3545 case 251:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3546#line 1199 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3547 {
3548 *O << *(yyvsp[0].String) << '\n';
3549 delete (yyvsp[0].String);
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3550 (yyval.String) = 0;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3551 ;}
3552 break;
3553
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3554 case 253:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3555#line 1205 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3556 { (yyval.String) = (yyvsp[0].String); *(yyval.String) = "unwind"; ;}
3557 break;
3558
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3559 case 254:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3560#line 1207 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3561 { // Return with a result...
3562 *O << " " << *(yyvsp[-1].String) << ' ' << *(yyvsp[0].Value).val << '\n';
3563 delete (yyvsp[-1].String); (yyvsp[0].Value).destroy();
3564 (yyval.String) = 0;
3565 ;}
3566 break;
3567
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3568 case 255:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3569#line 1212 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3570 { // Return with no result...
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3571 *O << " " << *(yyvsp[-1].String) << ' ' << (yyvsp[0].Type)->getNewTy() << '\n';
3572 delete (yyvsp[-1].String); delete (yyvsp[0].Type);
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3573 (yyval.String) = 0;
3574 ;}
3575 break;
3576
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3577 case 256:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3578#line 1217 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3579 { // Unconditional Branch...
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3580 *O << " " << *(yyvsp[-2].String) << ' ' << (yyvsp[-1].Type)->getNewTy() << ' ' << *(yyvsp[0].Value).val << '\n';
3581 delete (yyvsp[-2].String); delete (yyvsp[-1].Type); (yyvsp[0].Value).destroy();
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3582 (yyval.String) = 0;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3583 ;}
3584 break;
3585
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3586 case 257:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3587#line 1222 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3588 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3589 std::string Name = getUniqueName((yyvsp[-6].Value).val, (yyvsp[-7].Type));
3590 *O << " " << *(yyvsp[-8].String) << ' ' << (yyvsp[-7].Type)->getNewTy() << ' ' << Name << ", "
3591 << (yyvsp[-4].Type)->getNewTy() << ' ' << *(yyvsp[-3].Value).val << ", " << (yyvsp[-1].Type)->getNewTy() << ' '
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3592 << *(yyvsp[0].Value).val << '\n';
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3593 delete (yyvsp[-8].String); delete (yyvsp[-7].Type); (yyvsp[-6].Value).destroy(); delete (yyvsp[-4].Type); (yyvsp[-3].Value).destroy();
3594 delete (yyvsp[-1].Type); (yyvsp[0].Value).destroy();
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3595 (yyval.String) = 0;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3596 ;}
3597 break;
3598
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3599 case 258:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3600#line 1231 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3601 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3602 std::string Name = getUniqueName((yyvsp[-6].Value).val, (yyvsp[-7].Type));
3603 *O << " " << *(yyvsp[-8].String) << ' ' << (yyvsp[-7].Type)->getNewTy() << ' ' << Name << ", "
3604 << (yyvsp[-4].Type)->getNewTy() << ' ' << *(yyvsp[-3].Value).val << " [" << *(yyvsp[-1].String) << " ]\n";
3605 delete (yyvsp[-8].String); delete (yyvsp[-7].Type); (yyvsp[-6].Value).destroy(); delete (yyvsp[-4].Type); (yyvsp[-3].Value).destroy();
Reid Spencerf459d392006-12-02 16:19:52 +0000[diff] [blame]3606 delete (yyvsp[-1].String);
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3607 (yyval.String) = 0;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3608 ;}
3609 break;
3610
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3611 case 259:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3612#line 1239 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3613 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3614 std::string Name = getUniqueName((yyvsp[-5].Value).val, (yyvsp[-6].Type));
3615 *O << " " << *(yyvsp[-7].String) << ' ' << (yyvsp[-6].Type)->getNewTy() << ' ' << Name << ", "
3616 << (yyvsp[-3].Type)->getNewTy() << ' ' << *(yyvsp[-2].Value).val << "[]\n";
3617 delete (yyvsp[-7].String); delete (yyvsp[-6].Type); (yyvsp[-5].Value).destroy(); delete (yyvsp[-3].Type); (yyvsp[-2].Value).destroy();
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3618 (yyval.String) = 0;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3619 ;}
3620 break;
3621
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3622 case 260:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3623#line 1247 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3624 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3625 TypeInfo* ResTy = getFunctionReturnType((yyvsp[-10].Type));
Reid Spencer16244f42006-12-01 21:10:07 +0000[diff] [blame]3626 *O << " ";
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3627 if (!(yyvsp[-13].String)->empty()) {
3628 std::string Name = getUniqueName((yyvsp[-13].String), ResTy);
3629 *O << Name << " = ";
3630 }
3631 *O << *(yyvsp[-12].String) << ' ' << *(yyvsp[-11].String) << ' ' << (yyvsp[-10].Type)->getNewTy() << ' ' << *(yyvsp[-9].Value).val << " (";
Reid Spencerf8483652006-12-02 15:16:01 +0000[diff] [blame]3632 for (unsigned i = 0; i < (yyvsp[-7].ValList)->size(); ++i) {
3633 ValueInfo& VI = (*(yyvsp[-7].ValList))[i];
3634 *O << *VI.val;
3635 if (i+1 < (yyvsp[-7].ValList)->size())
3636 *O << ", ";
3637 VI.destroy();
3638 }
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3639 *O << ") " << *(yyvsp[-5].String) << ' ' << (yyvsp[-4].Type)->getNewTy() << ' ' << *(yyvsp[-3].Value).val << ' '
3640 << *(yyvsp[-2].String) << ' ' << (yyvsp[-1].Type)->getNewTy() << ' ' << *(yyvsp[0].Value).val << '\n';
3641 delete (yyvsp[-13].String); delete (yyvsp[-12].String); delete (yyvsp[-11].String); delete (yyvsp[-10].Type); (yyvsp[-9].Value).destroy(); delete (yyvsp[-7].ValList);
3642 delete (yyvsp[-5].String); delete (yyvsp[-4].Type); (yyvsp[-3].Value).destroy(); delete (yyvsp[-2].String); delete (yyvsp[-1].Type);
Reid Spencerf459d392006-12-02 16:19:52 +0000[diff] [blame]3643 (yyvsp[0].Value).destroy();
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3644 (yyval.String) = 0;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3645 ;}
3646 break;
3647
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3648 case 261:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3649#line 1269 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3650 {
3651 *O << " " << *(yyvsp[0].String) << '\n';
3652 delete (yyvsp[0].String);
3653 (yyval.String) = 0;
3654 ;}
3655 break;
3656
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3657 case 262:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3658#line 1274 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3659 {
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3660 *O << " " << *(yyvsp[0].String) << '\n';
Reid Spencerfcb5df82006-12-01 22:34:43 +0000[diff] [blame]3661 delete (yyvsp[0].String);
3662 (yyval.String) = 0;
3663 ;}
3664 break;
3665
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3666 case 263:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3667#line 1280 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencerfcb5df82006-12-01 22:34:43 +0000[diff] [blame]3668 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3669 *(yyvsp[-5].String) += " " + (yyvsp[-4].Type)->getNewTy() + " " + *(yyvsp[-3].String) + ", " + (yyvsp[-1].Type)->getNewTy() + " " +
3670 *(yyvsp[0].Value).val;
3671 delete (yyvsp[-4].Type); delete (yyvsp[-3].String); delete (yyvsp[-1].Type); (yyvsp[0].Value).destroy();
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3672 (yyval.String) = (yyvsp[-5].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3673 ;}
3674 break;
3675
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3676 case 264:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3677#line 1286 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3678 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3679 (yyvsp[-3].String)->insert(0, (yyvsp[-4].Type)->getNewTy() + " " );
3680 *(yyvsp[-3].String) += ", " + (yyvsp[-1].Type)->getNewTy() + " " + *(yyvsp[0].Value).val;
3681 delete (yyvsp[-4].Type); delete (yyvsp[-1].Type); (yyvsp[0].Value).destroy();
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3682 (yyval.String) = (yyvsp[-3].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3683 ;}
3684 break;
3685
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3686 case 265:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3687#line 1294 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3688 {
Reid Spencerf5626a32007-01-01 01:20:41 +0000[diff] [blame]3689 if (!(yyvsp[-1].String)->empty()) {
3690 if (deleteUselessCastFlag && *deleteUselessCastName == *(yyvsp[-1].String)) {
3691 *(yyvsp[-1].String) += " = ";
3692 (yyvsp[-1].String)->insert(0, "; "); // don't actually delete it, just comment it out
3693 delete deleteUselessCastName;
3694 } else {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3695 // Get a unique name for the name of this value, based on its type.
3696 *(yyvsp[-1].String) = getUniqueName((yyvsp[-1].String), (yyvsp[0].Value).type) + " = ";
Reid Spencerf5626a32007-01-01 01:20:41 +0000[diff] [blame]3697 }
3698 }
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3699 *(yyvsp[-1].String) += *(yyvsp[0].Value).val;
3700 (yyvsp[0].Value).destroy();
Reid Spencerf5626a32007-01-01 01:20:41 +0000[diff] [blame]3701 deleteUselessCastFlag = false;
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3702 (yyval.String) = (yyvsp[-1].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3703 ;}
3704 break;
3705
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3706 case 266:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3707#line 1312 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3708 { // Used for PHI nodes
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3709 std::string Name = getUniqueName((yyvsp[-3].Value).val, (yyvsp[-5].Type));
3710 Name.insert(0, (yyvsp[-5].Type)->getNewTy() + "[");
3711 Name += "," + *(yyvsp[-1].Value).val + "]";
3712 (yyval.Value).val = new std::string(Name);
3713 (yyval.Value).type = (yyvsp[-5].Type);
3714 (yyvsp[-3].Value).destroy(); (yyvsp[-1].Value).destroy();
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3715 ;}
3716 break;
3717
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3718 case 267:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3719#line 1320 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3720 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3721 std::string Name = getUniqueName((yyvsp[-3].Value).val, (yyvsp[-6].Value).type);
3722 *(yyvsp[-6].Value).val += ", [" + Name + "," + *(yyvsp[-1].Value).val + "]";
Reid Spencerf459d392006-12-02 16:19:52 +0000[diff] [blame]3723 (yyvsp[-3].Value).destroy(); (yyvsp[-1].Value).destroy();
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3724 (yyval.Value) = (yyvsp[-6].Value);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3725 ;}
3726 break;
3727
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3728 case 268:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3729#line 1329 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3730 {
Reid Spencerf8483652006-12-02 15:16:01 +0000[diff] [blame]3731 (yyval.ValList) = new ValueList();
3732 (yyval.ValList)->push_back((yyvsp[0].Value));
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3733 ;}
3734 break;
3735
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3736 case 269:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3737#line 1333 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencerf8483652006-12-02 15:16:01 +0000[diff] [blame]3738 {
Reid Spencerf8483652006-12-02 15:16:01 +0000[diff] [blame]3739 (yyval.ValList) = (yyvsp[-2].ValList);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3740 (yyval.ValList)->push_back((yyvsp[0].Value));
Reid Spencerf8483652006-12-02 15:16:01 +0000[diff] [blame]3741 ;}
3742 break;
3743
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3744 case 270:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3745#line 1340 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencerf8483652006-12-02 15:16:01 +0000[diff] [blame]3746 { (yyval.ValList) = (yyvsp[0].ValList); ;}
3747 break;
3748
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3749 case 271:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3750#line 1341 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencerf8483652006-12-02 15:16:01 +0000[diff] [blame]3751 { (yyval.ValList) = new ValueList(); ;}
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3752 break;
3753
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3754 case 272:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3755#line 1345 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3756 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3757 *(yyvsp[-1].String) += " " + *(yyvsp[0].String);
3758 delete (yyvsp[0].String);
3759 (yyval.String) = (yyvsp[-1].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3760 ;}
3761 break;
3762
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3763 case 274:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3764#line 1353 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]3765 {
3766 const char* op = getDivRemOpcode(*(yyvsp[-4].String), (yyvsp[-3].Type));
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3767 std::string Name1 = getUniqueName((yyvsp[-2].Value).val, (yyvsp[-3].Type));
3768 std::string Name2 = getUniqueName((yyvsp[0].Value).val, (yyvsp[-3].Type));
3769 (yyval.Value).val = new std::string(op);
3770 *(yyval.Value).val += " " + (yyvsp[-3].Type)->getNewTy() + " " + Name1 + ", " + Name2;
3771 (yyval.Value).type = (yyvsp[-3].Type);
3772 delete (yyvsp[-4].String); (yyvsp[-2].Value).destroy(); (yyvsp[0].Value).destroy();
Reid Spencer78720742006-12-02 20:21:22 +0000[diff] [blame]3773 ;}
3774 break;
3775
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3776 case 275:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3777#line 1362 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3778 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3779 std::string Name1 = getUniqueName((yyvsp[-2].Value).val, (yyvsp[-3].Type));
3780 std::string Name2 = getUniqueName((yyvsp[0].Value).val, (yyvsp[-3].Type));
3781 *(yyvsp[-4].String) += " " + (yyvsp[-3].Type)->getNewTy() + " " + Name1 + ", " + Name2;
3782 (yyval.Value).val = (yyvsp[-4].String);
3783 (yyval.Value).type = (yyvsp[-3].Type);
3784 (yyvsp[-2].Value).destroy(); (yyvsp[0].Value).destroy();
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3785 ;}
3786 break;
3787
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3788 case 276:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3789#line 1370 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3790 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3791 std::string Name1 = getUniqueName((yyvsp[-2].Value).val, (yyvsp[-3].Type));
3792 std::string Name2 = getUniqueName((yyvsp[0].Value).val, (yyvsp[-3].Type));
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]3793 *(yyvsp[-4].String) = getCompareOp(*(yyvsp[-4].String), (yyvsp[-3].Type));
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3794 *(yyvsp[-4].String) += " " + (yyvsp[-3].Type)->getNewTy() + " " + Name1 + ", " + Name2;
3795 (yyval.Value).val = (yyvsp[-4].String);
3796 (yyval.Value).type = new TypeInfo("bool",BoolTy);
3797 (yyvsp[-2].Value).destroy(); (yyvsp[0].Value).destroy();
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3798 ;}
3799 break;
3800
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3801 case 277:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3802#line 1379 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3803 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3804 std::string Name1 = getUniqueName((yyvsp[-2].Value).val, (yyvsp[-3].Type));
3805 std::string Name2 = getUniqueName((yyvsp[0].Value).val, (yyvsp[-3].Type));
3806 *(yyvsp[-5].String) += " " + *(yyvsp[-4].String) + " " + (yyvsp[-3].Type)->getNewTy() + " " + Name1 + "," + Name2;
3807 (yyval.Value).val = (yyvsp[-5].String);
3808 (yyval.Value).type = new TypeInfo("bool",BoolTy);
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3809 delete (yyvsp[-4].String); (yyvsp[-2].Value).destroy(); (yyvsp[0].Value).destroy();
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3810 ;}
3811 break;
3812
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3813 case 278:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3814#line 1387 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]3815 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3816 std::string Name1 = getUniqueName((yyvsp[-2].Value).val, (yyvsp[-3].Type));
3817 std::string Name2 = getUniqueName((yyvsp[0].Value).val, (yyvsp[-3].Type));
3818 *(yyvsp[-5].String) += " " + *(yyvsp[-4].String) + " " + (yyvsp[-3].Type)->getNewTy() + " " + Name1 + "," + Name2;
3819 (yyval.Value).val = (yyvsp[-5].String);
3820 (yyval.Value).type = new TypeInfo("bool",BoolTy);
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3821 delete (yyvsp[-4].String); (yyvsp[-2].Value).destroy(); (yyvsp[0].Value).destroy();
Reid Spencer229e9362006-12-02 22:14:11 +0000[diff] [blame]3822 ;}
3823 break;
3824
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3825 case 279:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3826#line 1395 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3827 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3828 (yyval.Value) = (yyvsp[0].Value);
3829 (yyval.Value).val->insert(0, *(yyvsp[-1].String) + " ");
3830 delete (yyvsp[-1].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3831 ;}
3832 break;
3833
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3834 case 280:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3835#line 1400 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3836 {
Reid Spencerf7bde222006-12-01 22:26:37 +0000[diff] [blame]3837 const char* shiftop = (yyvsp[-3].String)->c_str();
3838 if (*(yyvsp[-3].String) == "shr")
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3839 shiftop = ((yyvsp[-2].Value).type->isUnsigned()) ? "lshr" : "ashr";
3840 (yyval.Value).val = new std::string(shiftop);
3841 *(yyval.Value).val += " " + *(yyvsp[-2].Value).val + ", " + *(yyvsp[0].Value).val;
3842 (yyval.Value).type = (yyvsp[-2].Value).type;
3843 delete (yyvsp[-3].String); delete (yyvsp[-2].Value).val; (yyvsp[0].Value).destroy();
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3844 ;}
3845 break;
3846
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3847 case 281:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3848#line 1409 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3849 {
Reid Spencer280d8012006-12-01 23:40:53 +0000[diff] [blame]3850 std::string source = *(yyvsp[-2].Value).val;
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3851 TypeInfo* SrcTy = (yyvsp[-2].Value).type;
3852 TypeInfo* DstTy = ResolveType((yyvsp[0].Type));
3853 (yyval.Value).val = new std::string();
Reid Spencer280d8012006-12-01 23:40:53 +0000[diff] [blame]3854 if (*(yyvsp[-3].String) == "cast") {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3855 *(yyval.Value).val += getCastUpgrade(source, SrcTy, DstTy, false);
Reid Spencera50d5962006-12-02 04:11:07 +0000[diff] [blame]3856 } else {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3857 *(yyval.Value).val += *(yyvsp[-3].String) + " " + source + " to " + DstTy->getNewTy();
Reid Spencer280d8012006-12-01 23:40:53 +0000[diff] [blame]3858 }
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3859 (yyval.Value).type = (yyvsp[0].Type);
Reid Spencerf5626a32007-01-01 01:20:41 +0000[diff] [blame]3860 // Check to see if this is a useless cast of a value to the same name
3861 // and the same type. Such casts will probably cause redefinition errors
3862 // when assembled and perform no code gen action so just remove them.
3863 if (*(yyvsp[-3].String) == "cast" || *(yyvsp[-3].String) == "bitcast")
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3864 if ((yyvsp[-2].Value).type->isInteger() && DstTy->isInteger() &&
3865 (yyvsp[-2].Value).type->getBitWidth() == DstTy->getBitWidth()) {
Reid Spencerf5626a32007-01-01 01:20:41 +0000[diff] [blame]3866 deleteUselessCastFlag = true; // Flag the "Inst" rule
3867 deleteUselessCastName = new std::string(*(yyvsp[-2].Value).val); // save the name
3868 size_t pos = deleteUselessCastName->find_first_of("%\"",0);
3869 if (pos != std::string::npos) {
3870 // remove the type portion before val
3871 deleteUselessCastName->erase(0, pos);
3872 }
3873 }
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3874 delete (yyvsp[-3].String); (yyvsp[-2].Value).destroy();
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3875 delete (yyvsp[-1].String);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3876 ;}
3877 break;
3878
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3879 case 282:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3880#line 1437 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3881 {
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]3882 *(yyvsp[-5].String) += " " + *(yyvsp[-4].Value).val + ", " + *(yyvsp[-2].Value).val + ", " + *(yyvsp[0].Value).val;
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3883 (yyval.Value).val = (yyvsp[-5].String);
3884 (yyval.Value).type = (yyvsp[-2].Value).type;
3885 (yyvsp[-4].Value).destroy(); delete (yyvsp[-2].Value).val; (yyvsp[0].Value).destroy();
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]3886 ;}
3887 break;
3888
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3889 case 283:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3890#line 1443 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3891 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3892 *(yyvsp[-3].String) += " " + *(yyvsp[-2].Value).val + ", " + (yyvsp[0].Type)->getNewTy();
3893 (yyval.Value).val = (yyvsp[-3].String);
3894 (yyval.Value).type = (yyvsp[0].Type);
3895 (yyvsp[-2].Value).destroy();
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3896 ;}
3897 break;
3898
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3899 case 284:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3900#line 1449 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3901 {
3902 *(yyvsp[-3].String) += " " + *(yyvsp[-2].Value).val + ", " + *(yyvsp[0].Value).val;
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3903 (yyval.Value).val = (yyvsp[-3].String);
3904 ResolveType((yyvsp[-2].Value).type);
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3905 (yyval.Value).type = (yyvsp[-2].Value).type->getElementType();
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3906 delete (yyvsp[-2].Value).val; (yyvsp[0].Value).destroy();
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3907 ;}
3908 break;
3909
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3910 case 285:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3911#line 1456 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3912 {
3913 *(yyvsp[-5].String) += " " + *(yyvsp[-4].Value).val + ", " + *(yyvsp[-2].Value).val + ", " + *(yyvsp[0].Value).val;
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3914 (yyval.Value).val = (yyvsp[-5].String);
3915 (yyval.Value).type = (yyvsp[-4].Value).type;
3916 delete (yyvsp[-4].Value).val; (yyvsp[-2].Value).destroy(); (yyvsp[0].Value).destroy();
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3917 ;}
3918 break;
3919
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3920 case 286:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3921#line 1462 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]3922 {
3923 *(yyvsp[-5].String) += " " + *(yyvsp[-4].Value).val + ", " + *(yyvsp[-2].Value).val + ", " + *(yyvsp[0].Value).val;
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3924 (yyval.Value).val = (yyvsp[-5].String);
3925 (yyval.Value).type = (yyvsp[-4].Value).type;
3926 delete (yyvsp[-4].Value).val; (yyvsp[-2].Value).destroy(); (yyvsp[0].Value).destroy();
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]3927 ;}
3928 break;
3929
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3930 case 287:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3931#line 1468 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]3932 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3933 *(yyvsp[-1].String) += " " + *(yyvsp[0].Value).val;
3934 (yyval.Value).val = (yyvsp[-1].String);
3935 (yyval.Value).type = (yyvsp[0].Value).type;
3936 delete (yyvsp[0].Value).val;
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3937 ;}
3938 break;
3939
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3940 case 288:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3941#line 1474 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3942 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3943 if (!(yyvsp[-5].String)->empty())
3944 *(yyvsp[-6].String) += " " + *(yyvsp[-5].String);
3945 if (!(yyvsp[-6].String)->empty())
3946 *(yyvsp[-6].String) += " ";
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3947 *(yyvsp[-6].String) += (yyvsp[-4].Type)->getNewTy() + " " + *(yyvsp[-3].Value).val + "(";
Reid Spencerf8483652006-12-02 15:16:01 +0000[diff] [blame]3948 for (unsigned i = 0; i < (yyvsp[-1].ValList)->size(); ++i) {
3949 ValueInfo& VI = (*(yyvsp[-1].ValList))[i];
3950 *(yyvsp[-6].String) += *VI.val;
3951 if (i+1 < (yyvsp[-1].ValList)->size())
3952 *(yyvsp[-6].String) += ", ";
3953 VI.destroy();
3954 }
3955 *(yyvsp[-6].String) += ")";
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3956 (yyval.Value).val = (yyvsp[-6].String);
3957 (yyval.Value).type = getFunctionReturnType((yyvsp[-4].Type));
3958 delete (yyvsp[-5].String); delete (yyvsp[-4].Type); (yyvsp[-3].Value).destroy(); delete (yyvsp[-1].ValList);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3959 ;}
3960 break;
3961
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3962 case 290:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3963#line 1497 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencerf8483652006-12-02 15:16:01 +0000[diff] [blame]3964 { (yyval.ValList) = (yyvsp[0].ValList); ;}
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3965 break;
3966
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3967 case 291:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3968#line 1498 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencerf8483652006-12-02 15:16:01 +0000[diff] [blame]3969 { (yyval.ValList) = new ValueList(); ;}
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]3970 break;
3971
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3972 case 293:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3973#line 1503 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]3974 { (yyval.String) = new std::string(); ;}
3975 break;
3976
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3977 case 294:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3978#line 1506 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencerf7bde222006-12-01 22:26:37 +0000[diff] [blame]3979 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3980 *(yyvsp[-2].String) += " " + (yyvsp[-1].Type)->getNewTy();
Reid Spencerf7bde222006-12-01 22:26:37 +0000[diff] [blame]3981 if (!(yyvsp[0].String)->empty())
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]3982 *(yyvsp[-2].String) += " " + *(yyvsp[0].String);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3983 (yyval.Value).val = (yyvsp[-2].String);
3984 (yyval.Value).type = (yyvsp[-1].Type)->getPointerType();
3985 delete (yyvsp[-1].Type); delete (yyvsp[0].String);
Reid Spencerf7bde222006-12-01 22:26:37 +0000[diff] [blame]3986 ;}
3987 break;
3988
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3989 case 295:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]3990#line 1514 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3991 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3992 std::string Name = getUniqueName((yyvsp[-1].Value).val, (yyvsp[-2].Type));
3993 *(yyvsp[-5].String) += " " + (yyvsp[-4].Type)->getNewTy() + ", " + (yyvsp[-2].Type)->getNewTy() + " " + Name;
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3994 if (!(yyvsp[0].String)->empty())
3995 *(yyvsp[-5].String) += " " + *(yyvsp[0].String);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]3996 (yyval.Value).val = (yyvsp[-5].String);
3997 (yyval.Value).type = (yyvsp[-4].Type)->getPointerType();
3998 delete (yyvsp[-4].Type); delete (yyvsp[-2].Type); (yyvsp[-1].Value).destroy(); delete (yyvsp[0].String);
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]3999 ;}
4000 break;
4001
Reid Spencer57f28f92006-12-03 07:10:26 +0000[diff] [blame]4002 case 296:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]4003#line 1523 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]4004 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]4005 *(yyvsp[-2].String) += " " + (yyvsp[-1].Type)->getNewTy();
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]4006 if (!(yyvsp[0].String)->empty())
4007 *(yyvsp[-2].String) += " " + *(yyvsp[0].String);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]4008 (yyval.Value).val = (yyvsp[-2].String);
4009 (yyval.Value).type = (yyvsp[-1].Type)->getPointerType();
4010 delete (yyvsp[-1].Type); delete (yyvsp[0].String);
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]4011 ;}
4012 break;
4013
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]4014 case 297:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]4015#line 1531 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]4016 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]4017 std::string Name = getUniqueName((yyvsp[-1].Value).val, (yyvsp[-2].Type));
4018 *(yyvsp[-5].String) += " " + (yyvsp[-4].Type)->getNewTy() + ", " + (yyvsp[-2].Type)->getNewTy() + " " + Name;
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]4019 if (!(yyvsp[0].String)->empty())
4020 *(yyvsp[-5].String) += " " + *(yyvsp[0].String);
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]4021 (yyval.Value).val = (yyvsp[-5].String);
4022 (yyval.Value).type = (yyvsp[-4].Type)->getPointerType();
4023 delete (yyvsp[-4].Type); delete (yyvsp[-2].Type); (yyvsp[-1].Value).destroy(); delete (yyvsp[0].String);
Reid Spencer6fd36ab2006-12-29 20:35:03 +0000[diff] [blame]4024 ;}
4025 break;
4026
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]4027 case 298:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]4028#line 1540 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]4029 {
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]4030 *(yyvsp[-1].String) += " " + *(yyvsp[0].Value).val;
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]4031 (yyval.Value).val = (yyvsp[-1].String);
4032 (yyval.Value).type = new TypeInfo("void", VoidTy);
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]4033 (yyvsp[0].Value).destroy();
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]4034 ;}
4035 break;
4036
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]4037 case 299:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]4038#line 1546 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]4039 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]4040 std::string Name = getUniqueName((yyvsp[0].Value).val, (yyvsp[-1].Type));
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]4041 if (!(yyvsp[-3].String)->empty())
4042 *(yyvsp[-3].String) += " ";
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]4043 *(yyvsp[-3].String) += *(yyvsp[-2].String) + " " + (yyvsp[-1].Type)->getNewTy() + " " + Name;
4044 (yyval.Value).val = (yyvsp[-3].String);
4045 (yyval.Value).type = (yyvsp[-1].Type)->getElementType()->clone();
4046 delete (yyvsp[-2].String); delete (yyvsp[-1].Type); (yyvsp[0].Value).destroy();
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]4047 ;}
4048 break;
4049
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]4050 case 300:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]4051#line 1555 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]4052 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]4053 std::string Name = getUniqueName((yyvsp[0].Value).val, (yyvsp[-1].Type));
Reid Spencere77e35e2006-12-01 20:26:20 +0000[diff] [blame]4054 if (!(yyvsp[-5].String)->empty())
4055 *(yyvsp[-5].String) += " ";
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]4056 *(yyvsp[-5].String) += *(yyvsp[-4].String) + " " + *(yyvsp[-3].Value).val + ", " + (yyvsp[-1].Type)->getNewTy() + " " + Name;
4057 (yyval.Value).val = (yyvsp[-5].String);
4058 (yyval.Value).type = new TypeInfo("void", VoidTy);
4059 delete (yyvsp[-4].String); (yyvsp[-3].Value).destroy(); delete (yyvsp[-1].Type); (yyvsp[0].Value).destroy();
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]4060 ;}
4061 break;
4062
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]4063 case 301:
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]4064#line 1564 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]4065 {
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]4066 std::string Name = getUniqueName((yyvsp[-1].Value).val, (yyvsp[-2].Type));
Reid Spencerf459d392006-12-02 16:19:52 +0000[diff] [blame]4067 // Upgrade the indices
4068 for (unsigned i = 0; i < (yyvsp[0].ValList)->size(); ++i) {
4069 ValueInfo& VI = (*(yyvsp[0].ValList))[i];
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]4070 if (VI.type->isUnsigned() && !VI.isConstant() &&
4071 VI.type->getBitWidth() < 64) {
Reid Spencerf459d392006-12-02 16:19:52 +0000[diff] [blame]4072 std::string* old = VI.val;
4073 *O << " %gep_upgrade" << unique << " = zext " << *old
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]4074 << " to i64\n";
4075 VI.val = new std::string("i64 %gep_upgrade" + llvm::utostr(unique++));
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]4076 VI.type->setOldTy(ULongTy);
Reid Spencerf459d392006-12-02 16:19:52 +0000[diff] [blame]4077 }
4078 }
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]4079 *(yyvsp[-3].String) += " " + (yyvsp[-2].Type)->getNewTy() + " " + Name;
Reid Spencerf8483652006-12-02 15:16:01 +0000[diff] [blame]4080 for (unsigned i = 0; i < (yyvsp[0].ValList)->size(); ++i) {
4081 ValueInfo& VI = (*(yyvsp[0].ValList))[i];
4082 *(yyvsp[-3].String) += ", " + *VI.val;
Reid Spencerf8483652006-12-02 15:16:01 +0000[diff] [blame]4083 }
Reid Spencer52402b02007-01-02 05:45:11 +0000[diff] [blame]4084 (yyval.Value).val = (yyvsp[-3].String);
4085 (yyval.Value).type = getGEPIndexedType((yyvsp[-2].Type),(yyvsp[0].ValList));
4086 (yyvsp[-1].Value).destroy(); delete (yyvsp[0].ValList);
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]4087 ;}
4088 break;
4089
4090
4091 default: break;
4092 }
4093
4094/* Line 1126 of yacc.c. */
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]4095#line 4096 "UpgradeParser.tab.c"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]4096
4097 yyvsp -= yylen;
4098 yyssp -= yylen;
4099
4100
4101 YY_STACK_PRINT (yyss, yyssp);
4102
4103 *++yyvsp = yyval;
4104
4105
4106 /* Now `shift' the result of the reduction. Determine what state
4107 that goes to, based on the state we popped back to and the rule
4108 number reduced by. */
4109
4110 yyn = yyr1[yyn];
4111
4112 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4113 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4114 yystate = yytable[yystate];
4115 else
4116 yystate = yydefgoto[yyn - YYNTOKENS];
4117
4118 goto yynewstate;
4119
4120
4121/*------------------------------------.
4122| yyerrlab -- here on detecting error |
4123`------------------------------------*/
4124yyerrlab:
4125 /* If not already recovering from an error, report this error. */
4126 if (!yyerrstatus)
4127 {
4128 ++yynerrs;
4129#if YYERROR_VERBOSE
4130 yyn = yypact[yystate];
4131
4132 if (YYPACT_NINF < yyn && yyn < YYLAST)
4133 {
4134 int yytype = YYTRANSLATE (yychar);
4135 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
4136 YYSIZE_T yysize = yysize0;
4137 YYSIZE_T yysize1;
4138 int yysize_overflow = 0;
4139 char *yymsg = 0;
4140# define YYERROR_VERBOSE_ARGS_MAXIMUM 5
4141 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
4142 int yyx;
4143
4144#if 0
4145 /* This is so xgettext sees the translatable formats that are
4146 constructed on the fly. */
4147 YY_("syntax error, unexpected %s");
4148 YY_("syntax error, unexpected %s, expecting %s");
4149 YY_("syntax error, unexpected %s, expecting %s or %s");
4150 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
4151 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
4152#endif
4153 char *yyfmt;
4154 char const *yyf;
4155 static char const yyunexpected[] = "syntax error, unexpected %s";
4156 static char const yyexpecting[] = ", expecting %s";
4157 static char const yyor[] = " or %s";
4158 char yyformat[sizeof yyunexpected
4159 + sizeof yyexpecting - 1
4160 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
4161 * (sizeof yyor - 1))];
4162 char const *yyprefix = yyexpecting;
4163
4164 /* Start YYX at -YYN if negative to avoid negative indexes in
4165 YYCHECK. */
4166 int yyxbegin = yyn < 0 ? -yyn : 0;
4167
4168 /* Stay within bounds of both yycheck and yytname. */
4169 int yychecklim = YYLAST - yyn;
4170 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4171 int yycount = 1;
4172
4173 yyarg[0] = yytname[yytype];
4174 yyfmt = yystpcpy (yyformat, yyunexpected);
4175
4176 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4177 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
4178 {
4179 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
4180 {
4181 yycount = 1;
4182 yysize = yysize0;
4183 yyformat[sizeof yyunexpected - 1] = '\0';
4184 break;
4185 }
4186 yyarg[yycount++] = yytname[yyx];
4187 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
4188 yysize_overflow |= yysize1 < yysize;
4189 yysize = yysize1;
4190 yyfmt = yystpcpy (yyfmt, yyprefix);
4191 yyprefix = yyor;
4192 }
4193
4194 yyf = YY_(yyformat);
4195 yysize1 = yysize + yystrlen (yyf);
4196 yysize_overflow |= yysize1 < yysize;
4197 yysize = yysize1;
4198
4199 if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
4200 yymsg = (char *) YYSTACK_ALLOC (yysize);
4201 if (yymsg)
4202 {
4203 /* Avoid sprintf, as that infringes on the user's name space.
4204 Don't have undefined behavior even if the translation
4205 produced a string with the wrong number of "%s"s. */
4206 char *yyp = yymsg;
4207 int yyi = 0;
4208 while ((*yyp = *yyf))
4209 {
4210 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
4211 {
4212 yyp += yytnamerr (yyp, yyarg[yyi++]);
4213 yyf += 2;
4214 }
4215 else
4216 {
4217 yyp++;
4218 yyf++;
4219 }
4220 }
4221 yyerror (yymsg);
4222 YYSTACK_FREE (yymsg);
4223 }
4224 else
4225 {
4226 yyerror (YY_("syntax error"));
4227 goto yyexhaustedlab;
4228 }
4229 }
4230 else
4231#endif /* YYERROR_VERBOSE */
4232 yyerror (YY_("syntax error"));
4233 }
4234
4235
4236
4237 if (yyerrstatus == 3)
4238 {
4239 /* If just tried and failed to reuse look-ahead token after an
4240 error, discard it. */
4241
4242 if (yychar <= YYEOF)
4243 {
4244 /* Return failure if at end of input. */
4245 if (yychar == YYEOF)
4246 YYABORT;
4247 }
4248 else
4249 {
4250 yydestruct ("Error: discarding", yytoken, &yylval);
4251 yychar = YYEMPTY;
4252 }
4253 }
4254
4255 /* Else will try to reuse look-ahead token after shifting the error
4256 token. */
4257 goto yyerrlab1;
4258
4259
4260/*---------------------------------------------------.
4261| yyerrorlab -- error raised explicitly by YYERROR. |
4262`---------------------------------------------------*/
4263yyerrorlab:
4264
4265 /* Pacify compilers like GCC when the user code never invokes
4266 YYERROR and the label yyerrorlab therefore never appears in user
4267 code. */
4268 if (0)
4269 goto yyerrorlab;
4270
4271yyvsp -= yylen;
4272 yyssp -= yylen;
4273 yystate = *yyssp;
4274 goto yyerrlab1;
4275
4276
4277/*-------------------------------------------------------------.
4278| yyerrlab1 -- common code for both syntax error and YYERROR. |
4279`-------------------------------------------------------------*/
4280yyerrlab1:
4281 yyerrstatus = 3; /* Each real token shifted decrements this. */
4282
4283 for (;;)
4284 {
4285 yyn = yypact[yystate];
4286 if (yyn != YYPACT_NINF)
4287 {
4288 yyn += YYTERROR;
4289 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4290 {
4291 yyn = yytable[yyn];
4292 if (0 < yyn)
4293 break;
4294 }
4295 }
4296
4297 /* Pop the current state because it cannot handle the error token. */
4298 if (yyssp == yyss)
4299 YYABORT;
4300
4301
4302 yydestruct ("Error: popping", yystos[yystate], yyvsp);
4303 YYPOPSTACK;
4304 yystate = *yyssp;
4305 YY_STACK_PRINT (yyss, yyssp);
4306 }
4307
4308 if (yyn == YYFINAL)
4309 YYACCEPT;
4310
4311 *++yyvsp = yylval;
4312
4313
4314 /* Shift the error token. */
4315 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4316
4317 yystate = yyn;
4318 goto yynewstate;
4319
4320
4321/*-------------------------------------.
4322| yyacceptlab -- YYACCEPT comes here. |
4323`-------------------------------------*/
4324yyacceptlab:
4325 yyresult = 0;
4326 goto yyreturn;
4327
4328/*-----------------------------------.
4329| yyabortlab -- YYABORT comes here. |
4330`-----------------------------------*/
4331yyabortlab:
4332 yyresult = 1;
4333 goto yyreturn;
4334
4335#ifndef yyoverflow
4336/*-------------------------------------------------.
4337| yyexhaustedlab -- memory exhaustion comes here. |
4338`-------------------------------------------------*/
4339yyexhaustedlab:
4340 yyerror (YY_("memory exhausted"));
4341 yyresult = 2;
4342 /* Fall through. */
4343#endif
4344
4345yyreturn:
4346 if (yychar != YYEOF && yychar != YYEMPTY)
4347 yydestruct ("Cleanup: discarding lookahead",
4348 yytoken, &yylval);
4349 while (yyssp != yyss)
4350 {
4351 yydestruct ("Cleanup: popping",
4352 yystos[*yyssp], yyvsp);
4353 YYPOPSTACK;
4354 }
4355#ifndef yyoverflow
4356 if (yyss != yyssa)
4357 YYSTACK_FREE (yyss);
4358#endif
4359 return yyresult;
4360}
4361
4362
Reid Spencereff838e2007-01-03 23:45:42 +0000[diff] [blame]4363#line 1588 "/proj/llvm/llvm-3/tools/llvm-upgrade/UpgradeParser.y"
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]4364
4365
4366int yyerror(const char *ErrorMsg) {
4367 std::string where
4368 = std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
4369 + ":" + llvm::utostr((unsigned) Upgradelineno) + ": ";
4370 std::string errMsg = std::string(ErrorMsg) + "\n" + where + " while reading ";
4371 if (yychar == YYEMPTY || yychar == 0)
4372 errMsg += "end-of-file.";
4373 else
4374 errMsg += "token: '" + std::string(Upgradetext, Upgradeleng) + "'";
Reid Spencer71d2ec92006-12-31 06:02:26 +0000[diff] [blame]4375 std::cerr << "llvm-upgrade: " << errMsg << '\n';
Reid Spencere7c3c602006-11-30 06:36:44 +0000[diff] [blame]4376 exit(1);
4377}
4378