llvm.org GIT mirror llvm / 2330e4d
add support for alignment attributes on load/store instructions git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36301 91177308-0d34-0410-b5e6-96231b3b80d8 Christopher Lamb 12 years ago
19 changed file(s) with 3727 addition(s) and 4608 deletion(s). Raw diff Collapse all Expand all
116116 N: Sumant Kowshik
117117 E: kowshik@uiuc.edu
118118 D: Author of the original C backend
119
120 N: Christopher Lamb
121 E: christopher.lamb@gmail.com
122 D: aligned load/store support
119123
120124 N: Jim Laskey
121125 E: jlaskey@apple.com
15861586
Call+FastCC+TailCall5951.5
15871587
Call+FastCC6051.5
15881588
Call+CCC+TailCall6151.5
1589
Load+Volatile6231.3
1590
Store+Volatile6331.3
1589
Load+Attributes6272.0
1590
Store+Attributes6372.0
15911591
15921592
15931593 15941594

* Note: 15951595 These aren't really opcodes from an LLVM language perspective. They encode 15961596 information into other opcodes without reserving space for that information. 1597 For example, opcode=63 is a Volatile Store. The opcode for this 1597 For example, opcode=63 is an Attributed Store. The opcode for this 15981598 instruction is 25 (Store) but we encode it as 63 to indicate that is a Volatile 15991599 Store. The same is done for the calling conventions and tail calls. 16001600 In each of these entries in range 56-63, the opcode is documented as the base

26082608 Instruction
26092609
26102610
Syntax:
2611
  <result> = load <ty>* <pointer>
<result> = volatile load <ty>* <pointer>

2611
  <result> = load <ty>* <pointer>[, align <alignment>]
<result> = volatile load <ty>* <pointer>[, align <alignment>]

26122612
Overview:
26132613

The 'load' instruction is used to read from memory.

26142614
Arguments:
26332633 Instruction
26342634
26352635
Syntax:
2636
  store <ty> <value>, <ty>* <pointer>                   ; yields {void}

                  
                
2637 volatile store <ty> <value>, <ty>* <pointer> ; yields {void}
2636
  store <ty> <value>, <ty>* <pointer>[, align <alignment>]                   ; yields {void}
                  
                
2637 volatile store <ty> <value>, <ty>* <pointer>[, align <alignment>] ; yields {void}
26382638
26392639
Overview:
26402640

The 'store' instruction is used to write to memory.

310310 /// determined by their operands, and they produce a value AND a token chain.
311311 ///
312312 SDOperand getLoad(MVT::ValueType VT, SDOperand Chain, SDOperand Ptr,
313 const Value *SV, int SVOffset, bool isVolatile=false);
313 const Value *SV, int SVOffset, bool isVolatile=false,
314 unsigned Alignment=0);
314315 SDOperand getExtLoad(ISD::LoadExtType ExtType, MVT::ValueType VT,
315316 SDOperand Chain, SDOperand Ptr, const Value *SV,
316 int SVOffset, MVT::ValueType EVT, bool isVolatile=false);
317 int SVOffset, MVT::ValueType EVT, bool isVolatile=false,
318 unsigned Alignment=0);
317319 SDOperand getIndexedLoad(SDOperand OrigLoad, SDOperand Base,
318320 SDOperand Offset, ISD::MemIndexedMode AM);
319321 SDOperand getVecLoad(unsigned Count, MVT::ValueType VT, SDOperand Chain,
322324 /// getStore - Helper function to build ISD::STORE nodes.
323325 ///
324326 SDOperand getStore(SDOperand Chain, SDOperand Val, SDOperand Ptr,
325 const Value *SV, int SVOffset, bool isVolatile=false);
327 const Value *SV, int SVOffset, bool isVolatile=false,
328 unsigned Alignment=0);
326329 SDOperand getTruncStore(SDOperand Chain, SDOperand Val, SDOperand Ptr,
327330 const Value *SV, int SVOffset, MVT::ValueType TVT,
328 bool isVolatile=false);
331 bool isVolatile=false, unsigned Alignment=0);
329332 SDOperand getIndexedStore(SDOperand OrigStoe, SDOperand Base,
330333 SDOperand Offset, ISD::MemIndexedMode AM);
331334
14471447 friend class SelectionDAG;
14481448 LoadSDNode(SDOperand *ChainPtrOff, SDVTList VTs,
14491449 ISD::MemIndexedMode AM, ISD::LoadExtType ETy, MVT::ValueType LVT,
1450 const Value *SV, int O=0, unsigned Align=1, bool Vol=false)
1450 const Value *SV, int O=0, unsigned Align=0, bool Vol=false)
14511451 : SDNode(ISD::LOAD, VTs),
14521452 AddrMode(AM), ExtType(ETy), LoadedVT(LVT), SrcValue(SV), SVOffset(O),
14531453 Alignment(Align), IsVolatile(Vol) {
14551455 Ops[1] = ChainPtrOff[1]; // Ptr
14561456 Ops[2] = ChainPtrOff[2]; // Off
14571457 InitOperands(Ops, 3);
1458 assert(Align != 0 && "Loads should have non-zero aligment");
14581459 assert((getOffset().getOpcode() == ISD::UNDEF ||
14591460 AddrMode != ISD::UNINDEXED) &&
14601461 "Only indexed load has a non-undef offset operand");
15171518 Ops[2] = ChainValuePtrOff[2]; // Ptr
15181519 Ops[3] = ChainValuePtrOff[3]; // Off
15191520 InitOperands(Ops, 4);
1521 assert(Align != 0 && "Stores should have non-zero aligment");
15201522 assert((getOffset().getOpcode() == ISD::UNDEF ||
15211523 AddrMode != ISD::UNINDEXED) &&
15221524 "Only indexed store has a non-undef offset operand");
210210 /// SubclassData field in Value to store whether or not the load is volatile.
211211 ///
212212 class LoadInst : public UnaryInstruction {
213
213214 LoadInst(const LoadInst &LI)
214215 : UnaryInstruction(LI.getType(), Load, LI.getOperand(0)) {
215216 setVolatile(LI.isVolatile());
217 setAlignment(LI.getAlignment());
216218
217219 #ifndef NDEBUG
218220 AssertOK();
222224 public:
223225 LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBefore);
224226 LoadInst(Value *Ptr, const std::string &Name, BasicBlock *InsertAtEnd);
225 LoadInst(Value *Ptr, const std::string &Name, bool isVolatile = false,
227 LoadInst(Value *Ptr, const std::string &Name, bool isVolatile = false,
228 Instruction *InsertBefore = 0);
229 LoadInst(Value *Ptr, const std::string &Name, bool isVolatile, unsigned Align,
226230 Instruction *InsertBefore = 0);
227231 LoadInst(Value *Ptr, const std::string &Name, bool isVolatile,
228232 BasicBlock *InsertAtEnd);
229233
230234 LoadInst(Value *Ptr, const char *Name, Instruction *InsertBefore);
231235 LoadInst(Value *Ptr, const char *Name, BasicBlock *InsertAtEnd);
232 explicit LoadInst(Value *Ptr, const char *Name = 0, bool isVolatile = false,
236 explicit LoadInst(Value *Ptr, const char *Name = 0, bool isVolatile = false,
233237 Instruction *InsertBefore = 0);
234238 LoadInst(Value *Ptr, const char *Name, bool isVolatile,
235239 BasicBlock *InsertAtEnd);
237241 /// isVolatile - Return true if this is a load from a volatile memory
238242 /// location.
239243 ///
240 bool isVolatile() const { return SubclassData; }
244 bool isVolatile() const { return SubclassData & 1; }
241245
242246 /// setVolatile - Specify whether this is a volatile load or not.
243247 ///
244 void setVolatile(bool V) { SubclassData = V; }
248 void setVolatile(bool V) { SubclassData = (SubclassData & ~1) | (V) ? 1 : 0; }
245249
246250 virtual LoadInst *clone() const;
251
252 /// getAlignment - Return the alignment of the access that is being performed
253 ///
254 unsigned getAlignment() const {
255 signed Log2AlignVal = ((SubclassData>>1)-1);
256 return ((Log2AlignVal < 0) ? 0 : 1<
257 }
258
259 void setAlignment(unsigned Align);
247260
248261 Value *getPointerOperand() { return getOperand(0); }
249262 const Value *getPointerOperand() const { return getOperand(0); }
268281 ///
269282 class StoreInst : public Instruction {
270283 Use Ops[2];
284
271285 StoreInst(const StoreInst &SI) : Instruction(SI.getType(), Store, Ops, 2) {
272286 Ops[0].init(SI.Ops[0], this);
273287 Ops[1].init(SI.Ops[1], this);
274288 setVolatile(SI.isVolatile());
289 setAlignment(SI.getAlignment());
290
275291 #ifndef NDEBUG
276292 AssertOK();
277293 #endif
282298 StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
283299 StoreInst(Value *Val, Value *Ptr, bool isVolatile = false,
284300 Instruction *InsertBefore = 0);
301 StoreInst(Value *Val, Value *Ptr, bool isVolatile,
302 unsigned Align, Instruction *InsertBefore = 0);
285303 StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd);
286304
287305
288306 /// isVolatile - Return true if this is a load from a volatile memory
289307 /// location.
290308 ///
291 bool isVolatile() const { return SubclassData; }
309 bool isVolatile() const { return SubclassData & 1; }
292310
293311 /// setVolatile - Specify whether this is a volatile load or not.
294312 ///
295 void setVolatile(bool V) { SubclassData = V; }
313 void setVolatile(bool V) { SubclassData = (SubclassData & ~1) | (V) ? 1 : 0; }
296314
297315 /// Transparently provide more efficient getOperand methods.
298316 Value *getOperand(unsigned i) const {
305323 }
306324 unsigned getNumOperands() const { return 2; }
307325
308
326 /// getAlignment - Return the alignment of the access that is being performed
327 ///
328 unsigned getAlignment() const {
329 signed Log2AlignVal = ((SubclassData>>1)-1);
330 return ((Log2AlignVal < 0) ? 0 : 1<
331 }
332
333 void setAlignment(unsigned Align);
334
309335 virtual StoreInst *clone() const;
310336
311337 Value *getPointerOperand() { return getOperand(1); }
None /* A Bison parser, made by GNU Bison 2.1. */
1
2 /* Skeleton parser for Yacc-like parsing with Bison,
3 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2, or (at your option)
8 any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 Boston, MA 02110-1301, USA. */
19
20 /* As a special exception, when this file is copied by Bison into a
21 Bison output file, you may use that output file without restriction.
22 This special exception was added by the Free Software Foundation
23 in version 1.24 of Bison. */
24
25 /* Written by Richard Stallman by simplifying the original so called
26 ``semantic'' parser. */
27
28 /* All symbols defined below should begin with yy or YY, to avoid
29 infringing on user name space. This should be done even for local
30 variables, as they might otherwise be expanded by user macros.
31 There are some unavoidable exceptions within include files to
32 define necessary library symbols; they are noted "INFRINGES ON
33 USER NAME SPACE" below. */
34
35 /* Identify Bison output. */
36 #define YYBISON 1
37
38 /* Bison version. */
39 #define YYBISON_VERSION "2.1"
40
41 /* Skeleton name. */
42 #define YYSKELETON_NAME "yacc.c"
43
44 /* Pure parsers. */
45 #define YYPURE 0
46
47 /* Using locations. */
48 #define YYLSP_NEEDED 0
49
50 /* Substitute the variable and function names. */
0
1 /* A Bison parser, made from /Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y
2 by GNU Bison version 1.28 */
3
4 #define YYBISON 1 /* Identify Bison output. */
5
516 #define yyparse llvmAsmparse
52 #define yylex llvmAsmlex
7 #define yylex llvmAsmlex
538 #define yyerror llvmAsmerror
54 #define yylval llvmAsmlval
55 #define yychar llvmAsmchar
9 #define yylval llvmAsmlval
10 #define yychar llvmAsmchar
5611 #define yydebug llvmAsmdebug
5712 #define yynerrs llvmAsmnerrs
58
59
60 /* Tokens. */
61 #ifndef YYTOKENTYPE
62 # define YYTOKENTYPE
63 /* Put the tokens into the symbol table, so that GDB and other debuggers
64 know about them. */
65 enum yytokentype {
66 ESINT64VAL = 258,
67 EUINT64VAL = 259,
68 ESAPINTVAL = 260,
69 EUAPINTVAL = 261,
70 LOCALVAL_ID = 262,
71 GLOBALVAL_ID = 263,
72 FPVAL = 264,
73 VOID = 265,
74 INTTYPE = 266,
75 FLOAT = 267,
76 DOUBLE = 268,
77 LABEL = 269,
78 TYPE = 270,
79 LOCALVAR = 271,
80 GLOBALVAR = 272,
81 LABELSTR = 273,
82 STRINGCONSTANT = 274,
83 ATSTRINGCONSTANT = 275,
84 ZEROINITIALIZER = 276,
85 TRUETOK = 277,
86 FALSETOK = 278,
87 BEGINTOK = 279,
88 ENDTOK = 280,
89 DECLARE = 281,
90 DEFINE = 282,
91 GLOBAL = 283,
92 CONSTANT = 284,
93 SECTION = 285,
94 VOLATILE = 286,
95 THREAD_LOCAL = 287,
96 TO = 288,
97 DOTDOTDOT = 289,
98 NULL_TOK = 290,
99 UNDEF = 291,
100 INTERNAL = 292,
101 LINKONCE = 293,
102 WEAK = 294,
103 APPENDING = 295,
104 DLLIMPORT = 296,
105 DLLEXPORT = 297,
106 EXTERN_WEAK = 298,
107 OPAQUE = 299,
108 EXTERNAL = 300,
109 TARGET = 301,
110 TRIPLE = 302,
111 ALIGN = 303,
112 DEPLIBS = 304,
113 CALL = 305,
114 TAIL = 306,
115 ASM_TOK = 307,
116 MODULE = 308,
117 SIDEEFFECT = 309,
118 CC_TOK = 310,
119 CCC_TOK = 311,
120 FASTCC_TOK = 312,
121 COLDCC_TOK = 313,
122 X86_STDCALLCC_TOK = 314,
123 X86_FASTCALLCC_TOK = 315,
124 DATALAYOUT = 316,
125 RET = 317,
126 BR = 318,
127 SWITCH = 319,
128 INVOKE = 320,
129 UNWIND = 321,
130 UNREACHABLE = 322,
131 ADD = 323,
132 SUB = 324,
133 MUL = 325,
134 UDIV = 326,
135 SDIV = 327,
136 FDIV = 328,
137 UREM = 329,
138 SREM = 330,
139 FREM = 331,
140 AND = 332,
141 OR = 333,
142 XOR = 334,
143 SHL = 335,
144 LSHR = 336,
145 ASHR = 337,
146 ICMP = 338,
147 FCMP = 339,
148 EQ = 340,
149 NE = 341,
150 SLT = 342,
151 SGT = 343,
152 SLE = 344,
153 SGE = 345,
154 ULT = 346,
155 UGT = 347,
156 ULE = 348,
157 UGE = 349,
158 OEQ = 350,
159 ONE = 351,
160 OLT = 352,
161 OGT = 353,
162 OLE = 354,
163 OGE = 355,
164 ORD = 356,
165 UNO = 357,
166 UEQ = 358,
167 UNE = 359,
168 MALLOC = 360,
169 ALLOCA = 361,
170 FREE = 362,
171 LOAD = 363,
172 STORE = 364,
173 GETELEMENTPTR = 365,
174 TRUNC = 366,
175 ZEXT = 367,
176 SEXT = 368,
177 FPTRUNC = 369,
178 FPEXT = 370,
179 BITCAST = 371,
180 UITOFP = 372,
181 SITOFP = 373,
182 FPTOUI = 374,
183 FPTOSI = 375,
184 INTTOPTR = 376,
185 PTRTOINT = 377,
186 PHI_TOK = 378,
187 SELECT = 379,
188 VAARG = 380,
189 EXTRACTELEMENT = 381,
190 INSERTELEMENT = 382,
191 SHUFFLEVECTOR = 383,
192 NORETURN = 384,
193 INREG = 385,
194 SRET = 386,
195 NOUNWIND = 387,
196 DEFAULT = 388,
197 HIDDEN = 389
198 };
199 #endif
200 /* Tokens. */
201 #define ESINT64VAL 258
202 #define EUINT64VAL 259
203 #define ESAPINTVAL 260
204 #define EUAPINTVAL 261
205 #define LOCALVAL_ID 262
206 #define GLOBALVAL_ID 263
207 #define FPVAL 264
208 #define VOID 265
209 #define INTTYPE 266
210 #define FLOAT 267
211 #define DOUBLE 268
212 #define LABEL 269
213 #define TYPE 270
214 #define LOCALVAR 271
215 #define GLOBALVAR 272
216 #define LABELSTR 273
217 #define STRINGCONSTANT 274
218 #define ATSTRINGCONSTANT 275
219 #define ZEROINITIALIZER 276
220 #define TRUETOK 277
221 #define FALSETOK 278
222 #define BEGINTOK 279
223 #define ENDTOK 280
224 #define DECLARE 281
225 #define DEFINE 282
226 #define GLOBAL 283
227 #define CONSTANT 284
228 #define SECTION 285
229 #define VOLATILE 286
230 #define THREAD_LOCAL 287
231 #define TO 288
232 #define DOTDOTDOT 289
233 #define NULL_TOK 290
234 #define UNDEF 291
235 #define INTERNAL 292
236 #define LINKONCE 293
237 #define WEAK 294
238 #define APPENDING 295
239 #define DLLIMPORT 296
240 #define DLLEXPORT 297
241 #define EXTERN_WEAK 298
242 #define OPAQUE 299
243 #define EXTERNAL 300
244 #define TARGET 301
245 #define TRIPLE 302
246 #define ALIGN 303
247 #define DEPLIBS 304
248 #define CALL 305
249 #define TAIL 306
250 #define ASM_TOK 307
251 #define MODULE 308
252 #define SIDEEFFECT 309
253 #define CC_TOK 310
254 #define CCC_TOK 311
255 #define FASTCC_TOK 312
256 #define COLDCC_TOK 313
257 #define X86_STDCALLCC_TOK 314
258 #define X86_FASTCALLCC_TOK 315
259 #define DATALAYOUT 316
260 #define RET 317
261 #define BR 318
262 #define SWITCH 319
263 #define INVOKE 320
264 #define UNWIND 321
265 #define UNREACHABLE 322
266 #define ADD 323
267 #define SUB 324
268 #define MUL 325
269 #define UDIV 326
270 #define SDIV 327
271 #define FDIV 328
272 #define UREM 329
273 #define SREM 330
274 #define FREM 331
275 #define AND 332
276 #define OR 333
277 #define XOR 334
278 #define SHL 335
279 #define LSHR 336
280 #define ASHR 337
281 #define ICMP 338
282 #define FCMP 339
283 #define EQ 340
284 #define NE 341
285 #define SLT 342
286 #define SGT 343
287 #define SLE 344
288 #define SGE 345
289 #define ULT 346
290 #define UGT 347
291 #define ULE 348
292 #define UGE 349
293 #define OEQ 350
294 #define ONE 351
295 #define OLT 352
296 #define OGT 353
297 #define OLE 354
298 #define OGE 355
299 #define ORD 356
300 #define UNO 357
301 #define UEQ 358
302 #define UNE 359
303 #define MALLOC 360
304 #define ALLOCA 361
305 #define FREE 362
306 #define LOAD 363
307 #define STORE 364
308 #define GETELEMENTPTR 365
309 #define TRUNC 366
310 #define ZEXT 367
311 #define SEXT 368
312 #define FPTRUNC 369
313 #define FPEXT 370
314 #define BITCAST 371
315 #define UITOFP 372
316 #define SITOFP 373
317 #define FPTOUI 374
318 #define FPTOSI 375
319 #define INTTOPTR 376
320 #define PTRTOINT 377
321 #define PHI_TOK 378
322 #define SELECT 379
323 #define VAARG 380
324 #define EXTRACTELEMENT 381
325 #define INSERTELEMENT 382
326 #define SHUFFLEVECTOR 383
327 #define NORETURN 384
328 #define INREG 385
329 #define SRET 386
330 #define NOUNWIND 387
331 #define DEFAULT 388
332 #define HIDDEN 389
333
334
335
336
337 /* Copy the first part of user declarations. */
338 #line 14 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
13 #define ESINT64VAL 257
14 #define EUINT64VAL 258
15 #define ESAPINTVAL 259
16 #define EUAPINTVAL 260
17 #define LOCALVAL_ID 261
18 #define GLOBALVAL_ID 262
19 #define FPVAL 263
20 #define VOID 264
21 #define INTTYPE 265
22 #define FLOAT 266
23 #define DOUBLE 267
24 #define LABEL 268
25 #define TYPE 269
26 #define LOCALVAR 270
27 #define GLOBALVAR 271
28 #define LABELSTR 272
29 #define STRINGCONSTANT 273
30 #define ATSTRINGCONSTANT 274
31 #define ZEROINITIALIZER 275
32 #define TRUETOK 276
33 #define FALSETOK 277
34 #define BEGINTOK 278
35 #define ENDTOK 279
36 #define DECLARE 280
37 #define DEFINE 281
38 #define GLOBAL 282
39 #define CONSTANT 283
40 #define SECTION 284
41 #define VOLATILE 285
42 #define THREAD_LOCAL 286
43 #define TO 287
44 #define DOTDOTDOT 288
45 #define NULL_TOK 289
46 #define UNDEF 290
47 #define INTERNAL 291
48 #define LINKONCE 292
49 #define WEAK 293
50 #define APPENDING 294
51 #define DLLIMPORT 295
52 #define DLLEXPORT 296
53 #define EXTERN_WEAK 297
54 #define OPAQUE 298
55 #define EXTERNAL 299
56 #define TARGET 300
57 #define TRIPLE 301
58 #define ALIGN 302
59 #define DEPLIBS 303
60 #define CALL 304
61 #define TAIL 305
62 #define ASM_TOK 306
63 #define MODULE 307
64 #define SIDEEFFECT 308
65 #define CC_TOK 309
66 #define CCC_TOK 310
67 #define FASTCC_TOK 311
68 #define COLDCC_TOK 312
69 #define X86_STDCALLCC_TOK 313
70 #define X86_FASTCALLCC_TOK 314
71 #define DATALAYOUT 315
72 #define RET 316
73 #define BR 317
74 #define SWITCH 318
75 #define INVOKE 319
76 #define UNWIND 320
77 #define UNREACHABLE 321
78 #define ADD 322
79 #define SUB 323
80 #define MUL 324
81 #define UDIV 325
82 #define SDIV 326
83 #define FDIV 327
84 #define UREM 328
85 #define SREM 329
86 #define FREM 330
87 #define AND 331
88 #define OR 332
89 #define XOR 333
90 #define SHL 334
91 #define LSHR 335
92 #define ASHR 336
93 #define ICMP 337
94 #define FCMP 338
95 #define EQ 339
96 #define NE 340
97 #define SLT 341
98 #define SGT 342
99 #define SLE 343
100 #define SGE 344
101 #define ULT 345
102 #define UGT 346
103 #define ULE 347
104 #define UGE 348
105 #define OEQ 349
106 #define ONE 350
107 #define OLT 351
108 #define OGT 352
109 #define OLE 353
110 #define OGE 354
111 #define ORD 355
112 #define UNO 356
113 #define UEQ 357
114 #define UNE 358
115 #define MALLOC 359
116 #define ALLOCA 360
117 #define FREE 361
118 #define LOAD 362
119 #define STORE 363
120 #define GETELEMENTPTR 364
121 #define TRUNC 365
122 #define ZEXT 366
123 #define SEXT 367
124 #define FPTRUNC 368
125 #define FPEXT 369
126 #define BITCAST 370
127 #define UITOFP 371
128 #define SITOFP 372
129 #define FPTOUI 373
130 #define FPTOSI 374
131 #define INTTOPTR 375
132 #define PTRTOINT 376
133 #define PHI_TOK 377
134 #define SELECT 378
135 #define VAARG 379
136 #define EXTRACTELEMENT 380
137 #define INSERTELEMENT 381
138 #define SHUFFLEVECTOR 382
139 #define NORETURN 383
140 #define INREG 384
141 #define SRET 385
142 #define NOUNWIND 386
143 #define DEFAULT 387
144 #define HIDDEN 388
145
146 #line 14 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
339147
340148 #include "ParserInternals.h"
341149 #include "llvm/CallingConv.h"
12591067 }
12601068
12611069
1262
1263 /* Enabling traces. */
1264 #ifndef YYDEBUG
1265 # define YYDEBUG 0
1266 #endif
1267
1268 /* Enabling verbose error messages. */
1269 #ifdef YYERROR_VERBOSE
1270 # undef YYERROR_VERBOSE
1271 # define YYERROR_VERBOSE 1
1272 #else
1273 # define YYERROR_VERBOSE 0
1274 #endif
1275
1276 /* Enabling the token table. */
1277 #ifndef YYTOKEN_TABLE
1278 # define YYTOKEN_TABLE 0
1279 #endif
1280
1281 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
1282 #line 938 "/proj/llvm/llvm-2/lib/AsmParser/llvmAsmParser.y"
1283 typedef union YYSTYPE {
1070 #line 938 "/Users/clamb/Documents/ageia/cvs/llvm/lib/AsmParser/llvmAsmParser.y"
1071 typedef union {
12841072 llvm::Module *ModuleVal;
12851073 llvm::Function *FunctionVal;
12861074 llvm::BasicBlock *BasicBlockVal;
13261114 llvm::ICmpInst::Predicate IPredicate;
13271115 llvm::FCmpInst::Predicate FPredicate;
13281116 } YYSTYPE;
1329 /* Line 196 of yacc.c. */
1330 #line 1332 "llvmAsmParser.tab.c"
1331 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1332 # define YYSTYPE_IS_DECLARED 1
1333 # define YYSTYPE_IS_TRIVIAL 1
1334 #endif
1335
1336
1337
1338 /* Copy the second part of user declarations. */
1339
1340
1341 /* Line 219 of yacc.c. */
1342 #line 1344 "llvmAsmParser.tab.c"
1343
1344 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
1345 # define YYSIZE_T __SIZE_TYPE__
1346 #endif
1347 #if ! defined (YYSIZE_T) && defined (size_t)
1348 # define YYSIZE_T size_t
1349 #endif
1350 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
1351 # include /* INFRINGES ON USER NAME SPACE */
1352 # define YYSIZE_T size_t
1353 #endif
1354 #if ! defined (YYSIZE_T)
1355 # define YYSIZE_T unsigned int
1356 #endif
1357
1358 #ifndef YY_
1359 # if YYENABLE_NLS
1360 # if ENABLE_NLS
1361 # include /* INFRINGES ON USER NAME SPACE */
1362 # define YY_(msgid) dgettext ("bison-runtime", msgid)
1363 # endif
1364 # endif
1365 # ifndef YY_
1366 # define YY_(msgid) msgid
1367 # endif
1368 #endif
1369
1370 #if ! defined (yyoverflow) || YYERROR_VERBOSE
1371
1372 /* The parser invokes alloca or malloc; define the necessary symbols. */
1373
1374 # ifdef YYSTACK_USE_ALLOCA
1375 # if YYSTACK_USE_ALLOCA
1376 # ifdef __GNUC__
1377 # define YYSTACK_ALLOC __builtin_alloca
1378 # else
1379 # define YYSTACK_ALLOC alloca
1380 # if defined (__STDC__) || defined (__cplusplus)
1381 # include /* INFRINGES ON USER NAME SPACE */
1382 # define YYINCLUDED_STDLIB_H
1383 # endif
1384 # endif
1385 # endif
1386 # endif
1387
1388 # ifdef YYSTACK_ALLOC
1389 /* Pacify GCC's `empty if-body' warning. */
1390 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
1391 # ifndef YYSTACK_ALLOC_MAXIMUM
1392 /* The OS might guarantee only one guard page at the bottom of the stack,
1393 and a page size can be as small as 4096 bytes. So we cannot safely
1394 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1395 to allow for a few compiler-allocated temporary stack slots. */
1396 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
1397 # endif
1398 # else
1399 # define YYSTACK_ALLOC YYMALLOC
1400 # define YYSTACK_FREE YYFREE
1401 # ifndef YYSTACK_ALLOC_MAXIMUM
1402 # define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
1403 # endif
1404 # ifdef __cplusplus
1405 extern "C" {
1406 # endif
1407 # ifndef YYMALLOC
1408 # define YYMALLOC malloc
1409 # if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
1410 && (defined (__STDC__) || defined (__cplusplus)))
1411 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1412 # endif
1413 # endif
1414 # ifndef YYFREE
1415 # define YYFREE free
1416 # if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
1417 && (defined (__STDC__) || defined (__cplusplus)))
1418 void free (void *); /* INFRINGES ON USER NAME SPACE */
1419 # endif
1420 # endif
1421 # ifdef __cplusplus
1422 }
1423 # endif
1424 # endif
1425 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
1426
1427
1428 #if (! defined (yyoverflow) \
1429 && (! defined (__cplusplus) \
1430 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
1431
1432 /* A type that is properly aligned for any stack member. */
1433 union yyalloc
1434 {
1435 short int yyss;
1436 YYSTYPE yyvs;
1437 };
1438
1439 /* The size of the maximum gap between one aligned stack and the next. */
1440 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1441
1442 /* The size of an array large to enough to hold all stacks, each with
1443 N elements. */
1444 # define YYSTACK_BYTES(N) \
1445 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
1446 + YYSTACK_GAP_MAXIMUM)
1447
1448 /* Copy COUNT objects from FROM to TO. The source and destination do
1449 not overlap. */
1450 # ifndef YYCOPY
1451 # if defined (__GNUC__) && 1 < __GNUC__
1452 # define YYCOPY(To, From, Count) \
1453 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1454 # else
1455 # define YYCOPY(To, From, Count) \
1456 do \
1457 { \
1458 YYSIZE_T yyi; \
1459 for (yyi = 0; yyi < (Count); yyi++) \
1460 (To)[yyi] = (From)[yyi]; \
1461 } \
1462 while (0)
1463 # endif
1464 # endif
1465
1466 /* Relocate STACK from its old location to the new one. The
1467 local variables YYSIZE and YYSTACKSIZE give the old and new number of
1468 elements in the stack, and YYPTR gives the new location of the
1469 stack. Advance YYPTR to a properly aligned location for the next
1470 stack. */
1471 # define YYSTACK_RELOCATE(Stack) \
1472 do \
1473 { \
1474 YYSIZE_T yynewbytes; \
1475 YYCOPY (&yyptr->Stack, Stack, yysize); \
1476 Stack = &yyptr->Stack; \
1477 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1478 yyptr += yynewbytes / sizeof (*yyptr); \
1479 } \
1480 while (0)
1481
1482 #endif
1483
1484 #if defined (__STDC__) || defined (__cplusplus)
1485 typedef signed char yysigned_char;
1117 #include
1118
1119 #ifndef __cplusplus
1120 #ifndef __STDC__
1121 #define const
1122 #endif
1123 #endif
1124
1125
1126
1127 #define YYFINAL 565
1128 #define YYFLAG -32768
1129 #define YYNTBASE 149
1130
1131 #define YYTRANSLATE(x) ((unsigned)(x) <= 388 ? yytranslate[x] : 227)
1132
1133 static const short yytranslate[] = { 0,
1134 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1135 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1136 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1137 2, 2, 2, 2, 2, 2, 2, 2, 2, 139,
1138 140, 137, 2, 136, 2, 2, 2, 2, 2, 2,
1139 2, 2, 2, 2, 2, 2, 2, 2, 2, 144,
1140 135, 145, 2, 2, 2, 2, 2, 2, 2, 2,
1141 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1142 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1143 141, 138, 143, 2, 2, 2, 2, 2, 148, 2,
1144 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1145 2, 2, 2, 2, 2, 2, 2, 2, 2, 142,
1146 2, 2, 146, 2, 147, 2, 2, 2, 2, 2,
1147 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1148 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1149 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1150 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1151 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1152 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1153 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1154 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1155 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1156 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1157 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1158 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1159 2, 2, 2, 2, 2, 1, 3, 4, 5, 6,
1160 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1161 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
1162 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
1163 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
1164 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1165 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
1166 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
1167 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
1168 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
1169 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
1170 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
1171 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
1172 127, 128, 129, 130, 131, 132, 133, 134
1173 };
1174
1175 #if YYDEBUG != 0
1176 static const short yyprhs[] = { 0,
1177 0, 2, 4, 6, 8, 10, 12, 14, 16, 18,
1178 20, 22, 24, 26, 28, 30, 32, 34, 36, 38,
1179 40, 42, 44, 46, 48, 50, 52, 54, 56, 58,
1180 60, 62, 64, 66, 68, 70, 72, 74, 76, 78,
1181 80, 82, 84, 86, 88, 90, 92, 94, 96, 98,
1182 100, 102, 104, 106, 108, 110, 112, 114, 116, 118,
1183 119, 122, 123, 125, 127, 130, 131, 133, 135, 137,
1184 139, 141, 143, 145, 147, 148, 150, 151, 153, 155,
1185 156, 158, 160, 162, 164, 165, 167, 169, 171, 173,
1186 175, 178, 180, 182, 184, 186, 187, 190, 192, 194,
1187 196, 197, 200, 201, 204, 205, 209, 212, 213, 215,
1188 216, 220, 222, 225, 227, 229, 231, 233, 235, 237,
1189 240, 242, 245, 251, 257, 263, 269, 273, 276, 282,
1190 287, 290, 292, 294, 296, 300, 302, 306, 308, 309,
1191 311, 315, 320, 324, 328, 333, 338, 342, 349, 355,
1192 358, 361, 364, 367, 370, 373, 376, 379, 382, 385,
1193 388, 391, 398, 404, 413, 420, 427, 435, 443, 450,
1194 459, 468, 472, 474, 476, 478, 480, 481, 483, 484,
1195 486, 489, 490, 494, 495, 499, 503, 507, 511, 512,
1196 520, 521, 530, 531, 540, 543, 547, 549, 553, 557,
1197 561, 565, 567, 568, 574, 578, 580, 584, 586, 587,
1198 597, 599, 601, 606, 608, 610, 613, 617, 618, 620,
1199 622, 624, 626, 628, 630, 632, 634, 636, 640, 642,
1200 648, 650, 652, 654, 656, 658, 660, 663, 666, 669,
1201 673, 676, 677, 679, 682, 685, 689, 699, 709, 718,
1202 733, 735, 737, 744, 750, 753, 760, 768, 772, 778,
1203 779, 780, 784, 787, 789, 795, 801, 808, 815, 820,
1204 827, 832, 837, 844, 851, 854, 863, 865, 867, 868,
1205 872, 879, 883, 890, 893, 899, 907
1206 };
1207
1208 static const short yyrhs[] = { 68,
1209 0, 69, 0, 70, 0, 71, 0, 72, 0, 73,
1210 0, 74, 0, 75, 0, 76, 0, 80, 0, 81,
1211 0, 82, 0, 77, 0, 78, 0, 79, 0, 111,
1212 0, 112, 0, 113, 0, 114, 0, 115, 0, 116,
1213 0, 117, 0, 118, 0, 119, 0, 120, 0, 121,
1214 0, 122, 0, 85, 0, 86, 0, 87, 0, 88,
1215 0, 89, 0, 90, 0, 91, 0, 92, 0, 93,
1216 0, 94, 0, 95, 0, 96, 0, 97, 0, 98,
1217 0, 99, 0, 100, 0, 101, 0, 102, 0, 103,
1218 0, 104, 0, 91, 0, 92, 0, 93, 0, 94,
1219 0, 22, 0, 23, 0, 11, 0, 12, 0, 13,
1220 0, 16, 0, 19, 0, 156, 0, 0, 156, 135,
1221 0, 0, 17, 0, 20, 0, 159, 135, 0, 0,
1222 37, 0, 39, 0, 38, 0, 40, 0, 42, 0,
1223 41, 0, 43, 0, 45, 0, 0, 134, 0, 0,
1224 41, 0, 43, 0, 0, 37, 0, 38, 0, 39,
1225 0, 42, 0, 0, 56, 0, 57, 0, 58, 0,
1226 59, 0, 60, 0, 55, 4, 0, 112, 0, 113,
1227 0, 130, 0, 131, 0, 0, 168, 167, 0, 129,
1228 0, 132, 0, 167, 0, 0, 170, 169, 0, 0,
1229 48, 4, 0, 0, 136, 48, 4, 0, 30, 19,
1230 0, 0, 173, 0, 0, 136, 176, 175, 0, 173,
1231 0, 48, 4, 0, 11, 0, 12, 0, 13, 0,
1232 14, 0, 44, 0, 177, 0, 178, 137, 0, 211,
1233 0, 138, 4, 0, 178, 139, 182, 140, 170, 0,
1234 10, 139, 182, 140, 170, 0, 141, 4, 142, 178,
1235 143, 0, 144, 4, 142, 178, 145, 0, 146, 183,
1236 147, 0, 146, 147, 0, 144, 146, 183, 147, 145,
1237 0, 144, 146, 147, 145, 0, 178, 168, 0, 178,
1238 0, 10, 0, 179, 0, 181, 136, 179, 0, 181,
1239 0, 181, 136, 34, 0, 34, 0, 0, 178, 0,
1240 183, 136, 178, 0, 178, 141, 186, 143, 0, 178,
1241 141, 143, 0, 178, 148, 19, 0, 178, 144, 186,
1242 145, 0, 178, 146, 186, 147, 0, 178, 146, 147,
1243 0, 178, 144, 146, 186, 147, 145, 0, 178, 144,
1244 146, 147, 145, 0, 178, 35, 0, 178, 36, 0,
1245 178, 211, 0, 178, 185, 0, 178, 21, 0, 154,
1246 3, 0, 154, 5, 0, 154, 4, 0, 154, 6,
1247 0, 11, 22, 0, 11, 23, 0, 155, 9, 0,
1248 151, 139, 184, 33, 178, 140, 0, 110, 139, 184,
1249 222, 140, 0, 124, 139, 184, 136, 184, 136, 184,
1250 140, 0, 149, 139, 184, 136, 184, 140, 0, 150,
1251 139, 184, 136, 184, 140, 0, 83, 152, 139, 184,
1252 136, 184, 140, 0, 84, 153, 139, 184, 136, 184,
1253 140, 0, 126, 139, 184, 136, 184, 140, 0, 127,
1254 139, 184, 136, 184, 136, 184, 140, 0, 128, 139,
1255 184, 136, 184, 136, 184, 140, 0, 186, 136, 184,
1256 0, 184, 0, 28, 0, 29, 0, 32, 0, 0,
1257 190, 0, 0, 191, 0, 190, 191, 0, 0, 27,
1258 192, 207, 0, 0, 26, 193, 208, 0, 53, 52,
1259 197, 0, 158, 15, 178, 0, 158, 15, 10, 0,
1260 0, 160, 163, 188, 187, 184, 194, 175, 0, 0,
1261 160, 161, 163, 188, 187, 184, 195, 175, 0, 0,
1262 160, 162, 163, 188, 187, 178, 196, 175, 0, 46,
1263 198, 0, 49, 135, 199, 0, 19, 0, 47, 135,
1264 19, 0, 61, 135, 19, 0, 141, 200, 143, 0,
1265 200, 136, 19, 0, 19, 0, 0, 201, 136, 178,
1266 168, 157, 0, 178, 168, 157, 0, 201, 0, 201,
1267 136, 34, 0, 34, 0, 0, 166, 180, 159, 139,
1268 202, 140, 170, 174, 171, 0, 24, 0, 146, 0,
1269 165, 163, 203, 204, 0, 25, 0, 147, 0, 214,
1270 206, 0, 164, 163, 203, 0, 0, 54, 0, 3,
1271 0, 4, 0, 9, 0, 22, 0, 23, 0, 35,
1272 0, 36, 0, 21, 0, 144, 186, 145, 0, 185,
1273 0, 52, 209, 19, 136, 19, 0, 7, 0, 8,
1274 0, 156, 0, 159, 0, 211, 0, 210, 0, 178,
1275 212, 0, 214, 215, 0, 205, 215, 0, 216, 158,
1276 217, 0, 216, 219, 0, 0, 18, 0, 62, 213,
1277 0, 62, 10, 0, 63, 14, 212, 0, 63, 11,
1278 212, 136, 14, 212, 136, 14, 212, 0, 64, 154,
1279 212, 136, 14, 212, 141, 218, 143, 0, 64, 154,
1280 212, 136, 14, 212, 141, 143, 0, 65, 166, 180,
1281 212, 139, 221, 140, 170, 33, 14, 212, 66, 14,
1282 212, 0, 66, 0, 67, 0, 218, 154, 210, 136,
1283 14, 212, 0, 154, 210, 136, 14, 212, 0, 158,
1284 224, 0, 178, 141, 212, 136, 212, 143, 0, 220,
1285 136, 141, 212, 136, 212, 143, 0, 178, 212, 168,
1286 0, 221, 136, 178, 212, 168, 0, 0, 0, 222,
1287 136, 213, 0, 51, 50, 0, 50, 0, 149, 178,
1288 212, 136, 212, 0, 150, 178, 212, 136, 212, 0,
1289 83, 152, 178, 212, 136, 212, 0, 84, 153, 178,
1290 212, 136, 212, 0, 151, 213, 33, 178, 0, 124,
1291 213, 136, 213, 136, 213, 0, 125, 213, 136, 178,
1292 0, 126, 213, 136, 213, 0, 127, 213, 136, 213,
1293 136, 213, 0, 128, 213, 136, 213, 136, 213, 0,
1294 123, 220, 0, 223, 166, 180, 212, 139, 221, 140,
1295 170, 0, 226, 0, 31, 0, 0, 105, 178, 172,
1296 0, 105, 178, 136, 11, 212, 172, 0, 106, 178,
1297 172, 0, 106, 178, 136, 11, 212, 172, 0, 107,
1298 213, 0, 225, 108, 178, 212, 172, 0, 225, 109,
1299 213, 136, 178, 212, 172, 0, 110, 178, 212, 222,
1300 0
1301 };
1302
1303 #endif
1304
1305 #if YYDEBUG != 0
1306 static const short yyrline[] = { 0,
1307 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1094,
1308 1094, 1094, 1094, 1094, 1094, 1095, 1095, 1095, 1095, 1095,
1309 1095, 1095, 1096, 1096, 1096, 1096, 1096, 1099, 1099, 1100,
1310 1100, 1101, 1101, 1102, 1102, 1103, 1103, 1107, 1107, 1108,
1311 1108, 1109, 1109, 1110, 1110, 1111, 1111, 1112, 1112, 1113,
1312 1113, 1114, 1115, 1120, 1121, 1121, 1123, 1123, 1124, 1124,
1313 1128, 1132, 1137, 1137, 1139, 1143, 1149, 1150, 1151, 1152,
1314 1153, 1157, 1158, 1159, 1163, 1164, 1168, 1169, 1170, 1174,
1315 1175, 1176, 1177, 1178, 1181, 1181, 1182, 1183, 1184, 1185,
1316 1186, 1194, 1195, 1196, 1197, 1200, 1201, 1206, 1207, 1208,
1317 1211, 1212, 1219, 1219, 1226, 1226, 1235, 1243, 1243, 1249,
1318 1249, 1251, 1256, 1269, 1269, 1269, 1269, 1272, 1276, 1280,
1319 1287, 1292, 1300, 1326, 1353, 1358, 1370, 1380, 1384, 1394,
1320 1401, 1408, 1415, 1420, 1425, 1432, 1433, 1440, 1447, 1455,
1321 1461, 1473, 1501, 1517, 1546, 1574, 1599, 1618, 1644, 1664,
1322 1676, 1683, 1749, 1759, 1769, 1775, 1785, 1791, 1801, 1806,
1323 1811, 1819, 1831, 1853, 1861, 1867, 1878, 1883, 1888, 1894,
1324 1900, 1909, 1913, 1921, 1921, 1924, 1924, 1935, 1940, 1948,
1325 1949, 1953, 1953, 1957, 1957, 1960, 1963, 1987, 1998, 2005,
1326 2008, 2013, 2016, 2022, 2026, 2029, 2035, 2048, 2052, 2057,
1327 2059, 2064, 2069, 2078, 2088, 2099, 2103, 2112, 2121, 2126,
1328 2245, 2245, 2247, 2256, 2256, 2258, 2263, 2275, 2279, 2284,
1329 2288, 2292, 2296, 2300, 2304, 2308, 2312, 2316, 2341, 2345,
1330 2359, 2363, 2367, 2371, 2377, 2377, 2383, 2392, 2396, 2405,
1331 2414, 2423, 2427, 2432, 2436, 2440, 2445, 2455, 2474, 2483,
1332 2559, 2563, 2570, 2581, 2594, 2604, 2615, 2625, 2634, 2643,
1333 2646, 2647, 2654, 2658, 2663, 2684, 2701, 2715, 2729, 2741,
1334 2749, 2756, 2762, 2768, 2774, 2789, 2870, 2875, 2879, 2886,
1335 2893, 2901, 2908, 2916, 2924, 2938, 2955
1336 };
1337 #endif
1338
1339
1340 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
1341
1342 static const char * const yytname[] = { "$","error","$undefined.","ESINT64VAL",
1343 "EUINT64VAL","ESAPINTVAL","EUAPINTVAL","LOCALVAL_ID","GLOBALVAL_ID","FPVAL",
1344 "VOID","INTTYPE","FLOAT","DOUBLE","LABEL","TYPE","LOCALVAR","GLOBALVAR","LABELSTR",
1345 "STRINGCONSTANT","ATSTRINGCONSTANT","ZEROINITIALIZER","TRUETOK","FALSETOK","BEGINTOK",
1346 "ENDTOK","DECLARE","DEFINE","GLOBAL","CONSTANT","SECTION","VOLATILE","THREAD_LOCAL",
1347 "TO","DOTDOTDOT","NULL_TOK","UNDEF","INTERNAL","LINKONCE","WEAK","APPENDING",
1348 "DLLIMPORT","DLLEXPORT","EXTERN_WEAK","OPAQUE","EXTERNAL","TARGET","TRIPLE",
1349 "ALIGN","DEPLIBS","CALL","TAIL","ASM_TOK","MODULE","SIDEEFFECT","CC_TOK","CCC_TOK",
1350 "FASTCC_TOK","COLDCC_TOK","X86_STDCALLCC_TOK","X86_FASTCALLCC_TOK","DATALAYOUT",
1351 "RET","BR","SWITCH","INVOKE","UNWIND","UNREACHABLE","ADD","SUB","MUL","UDIV",
1352 "SDIV","FDIV","UREM","SREM","FREM","AND","OR","XOR","SHL","LSHR","ASHR","ICMP",
1353 "FCMP","EQ","NE","SLT","SGT","SLE","SGE","ULT","UGT","ULE","UGE","OEQ","ONE",
1354 "OLT","OGT","OLE","OGE","ORD","UNO","UEQ","UNE","MALLOC","ALLOCA","FREE","LOAD",
1355 "STORE","GETELEMENTPTR","TRUNC","ZEXT","SEXT","FPTRUNC","FPEXT","BITCAST","UITOFP",
1356 "SITOFP","FPTOUI","FPTOSI","INTTOPTR","PTRTOINT","PHI_TOK","SELECT","VAARG",
1357 "EXTRACTELEMENT","INSERTELEMENT","SHUFFLEVECTOR","NORETURN","INREG","SRET","NOUNWIND",
1358 "DEFAULT","HIDDEN","'='","','","'*'","'\\\\'","'('","')'","'['","'x'","']'",
1359 "'<'","'>'","'{'","'}'","'c'","ArithmeticOps","LogicalOps","CastOps","IPredicates",
1360 "FPredicates","IntType","FPType","LocalName","OptLocalName","OptLocalAssign",
1361 "GlobalName","OptGlobalAssign","GVInternalLinkage","GVExternalLinkage","GVVisibilityStyle",
1362 "FunctionDeclareLinkage","FunctionDefineLinkage","OptCallingConv","ParamAttr",
1363 "OptParamAttrs","FuncAttr","OptFuncAttrs","OptAlign","OptCAlign","SectionString",
1364 "OptSection","GlobalVarAttributes","GlobalVarAttribute","PrimType","Types","ArgType",
1365 "ResultTypes","ArgTypeList","ArgTypeListI","TypeListI","ConstVal","ConstExpr",
1366 "ConstVector","GlobalType","ThreadLocal","Module","DefinitionList","Definition",
1367 "@1","@2","@3","@4","@5","AsmBlock","TargetDefinition","LibrariesDefinition",
1368 "LibList","ArgListH","ArgList","FunctionHeaderH","BEGIN","FunctionHeader","END",
1369 "Function","FunctionProto","OptSideEffect","ConstValueRef","SymbolicValueRef",
1370 "ValueRef","ResolvedVal","BasicBlockList","BasicBlock","InstructionList","BBTerminatorInst",
1371 "JumpTable","Inst","PHIList","ValueRefList","IndexList","OptTailCall","InstVal",
1372 "OptVolatile","MemoryInst", NULL
1373 };
1374 #endif
1375
1376 static const short yyr1[] = { 0,
1377 149, 149, 149, 149, 149, 149, 149, 149, 149, 150,
1378 150, 150, 150, 150, 150, 151, 151, 151, 151, 151,
1379 151, 151, 151, 151, 151, 151, 151, 152, 152, 152,
1380 152, 152, 152, 152, 152, 152, 152, 153, 153, 153,
1381 153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
1382 153, 153, 153, 154, 155, 155, 156, 156, 157, 157,
1383 158, 158, 159, 159, 160, 160, 161, 161, 161, 161,
1384 161, 162, 162, 162, 163, 163, 164, 164, 164, 165,
1385 165, 165, 165, 165, 166, 166, 166, 166, 166, 166,
1386 166, 167, 167, 167, 167, 168, 168, 169, 169, 169,
1387 170, 170, 171, 171, 172, 172, 173, 174, 174, 175,
1388 175, 176, 176, 177, 177, 177, 177, 178, 178, 178,
1389 178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
1390 179, 180, 180, 181, 181, 182, 182, 182, 182, 183,
1391 183, 184, 184, 184, 184, 184, 184, 184, 184, 184,
1392 184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
1393 184, 185, 185, 185, 185, 185, 185, 185, 185, 185,
1394 185, 186, 186, 187, 187, 188, 188, 189, 189, 190,
1395 190, 192, 191, 193, 191, 191, 191, 191, 194, 191,
1396 195, 191, 196, 191, 191, 191, 197, 198, 198, 199,
1397 200, 200, 200, 201, 201, 202, 202, 202, 202, 203,
1398 204, 204, 205, 206, 206, 207, 208, 209, 209, 210,
1399 210, 210, 210, 210, 210, 210, 210, 210, 210, 210,
1400 211, 211, 211, 211, 212, 212, 213, 214, 214, 215,
1401 216, 216, 216, 217, 217, 217, 217, 217, 217, 217,
1402 217, 217, 218, 218, 219, 220, 220, 221, 221, 221,
1403 222, 222, 223, 223, 224, 224, 224, 224, 224, 224,
1404 224, 224, 224, 224, 224, 224, 224, 225, 225, 226,
1405 226, 226, 226, 226, 226, 226, 226
1406 };
1407
1408 static const short yyr2[] = { 0,
1409 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1410 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1411 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1412 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1413 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1414 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1415 2, 0, 1, 1, 2, 0, 1, 1, 1, 1,
1416 1, 1, 1, 1, 0, 1, 0, 1, 1, 0,
1417 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
1418 2, 1, 1, 1, 1, 0, 2, 1, 1, 1,
1419 0, 2, 0, 2, 0, 3, 2, 0, 1, 0,
1420 3, 1, 2, 1, 1, 1, 1, 1, 1, 2,
1421 1, 2, 5, 5, 5, 5, 3, 2, 5, 4,
1422 2, 1, 1, 1, 3, 1, 3, 1, 0, 1,
1423 3, 4, 3, 3, 4, 4, 3, 6, 5, 2,
1424 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1425 2, 6, 5, 8, 6, 6, 7, 7, 6, 8,
1426 8, 3, 1, 1, 1, 1, 0, 1, 0, 1,
1427 2, 0, 3, 0, 3, 3, 3, 3, 0, 7,
1428 0, 8, 0, 8, 2, 3, 1, 3, 3, 3,
1429 3, 1, 0, 5, 3, 1, 3, 1, 0, 9,
1430 1, 1, 4, 1, 1, 2, 3, 0, 1, 1,
1431 1, 1, 1, 1, 1, 1, 1, 3, 1, 5,
1432 1, 1, 1, 1, 1, 1, 2, 2, 2, 3,
1433 2, 0, 1, 2, 2, 3, 9, 9, 8, 14,
1434 1, 1, 6, 5, 2, 6, 7, 3, 5, 0,
1435 0, 3, 2, 1, 5, 5, 6, 6, 4, 6,
1436 4, 4, 6, 6, 2, 8, 1, 1, 0, 3,
1437 6, 3, 6, 2, 5, 7, 4
1438 };
1439
1440 static const short yydefact[] = { 66,
1441 57, 63, 58, 64, 184, 182, 0, 0, 0, 0,
1442 0, 0, 75, 66, 180, 77, 80, 0, 0, 195,
1443 0, 0, 61, 0, 65, 67, 69, 68, 70, 72,
1444 71, 73, 74, 76, 75, 75, 177, 181, 78, 79,
1445 75, 185, 81, 82, 83, 84, 75, 242, 183, 242,
1446 0, 0, 203, 196, 197, 186, 231, 232, 188, 114,
1447 115, 116, 117, 118, 0, 0, 0, 0, 233, 234,
1448 119, 187, 121, 177, 177, 176, 0, 85, 85, 243,
1449 239, 62, 214, 215, 216, 238, 198, 199, 202, 0,
1450 139, 122, 0, 0, 0, 0, 128, 140, 0, 120,
1451 139, 0, 0, 174, 175, 0, 0, 86, 87, 88,
1452 89, 90, 0, 217, 0, 279, 241, 0, 200, 138,
1453 96, 134, 136, 0, 0, 0, 0, 0, 0, 127,
1454 0, 0, 0, 114, 115, 116, 0, 0, 0, 189,
1455 91, 133, 132, 0, 211, 212, 213, 278, 264, 0,
1456 0, 0, 0, 85, 251, 252, 1, 2, 3, 4,
1457 5, 6, 7, 8, 9, 13, 14, 15, 10, 11,
1458 12, 0, 0, 0, 0, 0, 0, 16, 17, 18,
1459 19, 20, 21, 22, 23, 24, 25, 26, 27, 0,
1460 0, 0, 0, 0, 0, 0, 0, 0, 240, 85,
1461 255, 0, 277, 201, 131, 0, 101, 0, 0, 130,
1462 0, 141, 101, 191, 193, 159, 160, 155, 157, 156,
1463 158, 161, 154, 150, 151, 0, 0, 0, 0, 0,
1464 0, 0, 0, 0, 0, 0, 0, 0, 0, 153,
1465 152, 110, 0, 263, 245, 0, 244, 0, 0, 54,
1466 0, 0, 28, 29, 30, 31, 32, 33, 34, 35,
1467 36, 37, 0, 52, 53, 48, 49, 50, 51, 38,
1468 39, 40, 41, 42, 43, 44, 45, 46, 47, 0,
1469 105, 105, 284, 0, 0, 275, 0, 0, 0, 0,
1470 0, 0, 0, 0, 0, 0, 0, 92, 93, 94,
1471 95, 97, 137, 135, 124, 125, 126, 129, 123, 110,
1472 110, 0, 0, 0, 0, 0, 0, 0, 143, 173,
1473 0, 0, 0, 147, 0, 144, 0, 0, 0, 0,
1474 190, 209, 220, 221, 222, 227, 223, 224, 225, 226,
1475 218, 0, 229, 236, 235, 237, 0, 246, 0, 0,
1476 0, 0, 0, 280, 0, 282, 261, 0, 0, 0,
1477 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1478 98, 99, 100, 102, 192, 194, 0, 0, 261, 0,
1479 0, 0, 0, 0, 142, 128, 140, 0, 145, 146,
1480 0, 0, 0, 0, 0, 112, 110, 208, 96, 206,
1481 0, 219, 0, 0, 0, 0, 0, 0, 0, 0,
1482 0, 0, 287, 0, 0, 0, 271, 272, 0, 0,
1483 0, 0, 269, 0, 105, 0, 0, 0, 0, 0,
1484 0, 0, 0, 172, 149, 0, 0, 0, 0, 107,
1485 113, 111, 60, 0, 101, 0, 228, 0, 0, 260,
1486 0, 0, 105, 106, 105, 0, 0, 0, 0, 0,
1487 0, 265, 266, 260, 0, 285, 0, 0, 0, 163,
1488 0, 0, 0, 0, 148, 0, 0, 0, 59, 205,
1489 207, 96, 108, 0, 0, 0, 0, 0, 267, 268,
1490 281, 283, 262, 0, 0, 270, 273, 274, 0, 105,
1491 0, 0, 0, 169, 0, 0, 165, 166, 162, 60,
1492 109, 103, 230, 0, 0, 96, 0, 101, 256, 0,
1493 101, 286, 167, 168, 0, 0, 0, 204, 0, 210,
1494 0, 249, 0, 0, 258, 0, 0, 257, 276, 164,
1495 170, 171, 104, 247, 0, 248, 0, 96, 0, 0,
1496 0, 259, 0, 0, 0, 0, 254, 0, 0, 253,
1497 0, 250, 0, 0, 0
1498 };
1499
1500 static const short yydefgoto[] = { 237,
1501 238, 239, 263, 280, 137, 138, 69, 480, 11, 70,
1502 13, 35, 36, 37, 41, 47, 113, 302, 205, 374,
1503 305, 530, 354, 396, 512, 331, 397, 71, 139, 122,
1504 144, 123, 124, 99, 320, 343, 321, 106, 77, 563,
1505 14, 15, 17, 16, 242, 310, 311, 56, 20, 54,
1506 90, 400, 401, 114, 147, 48, 85, 49, 42, 403,
1507 344, 73, 346, 247, 50, 81, 82, 199, 534, 117,
1508 286, 488, 413, 200, 201, 202, 203
1509 };
1510
1511 static const short yypact[] = { 593,
1512 -32768,-32768,-32768,-32768,-32768,-32768, -1, -87, 11, -41,
1513 89, -13, 46, 1408,-32768, 185, 82, 13, 55,-32768,
1514 81, 211,-32768, 1122,-32768,-32768,-32768,-32768,-32768,-32768,
1515 -32768,-32768,-32768,-32768, 98, 98, 206,-32768,-32768,-32768,
1516 98,-32768,-32768,-32768,-32768,-32768, 98, 235,-32768, 8,
1517 242, 251, 252,-32768,-32768,-32768,-32768,-32768, 128,-32768,
1518 -32768,-32768,-32768,-32768, 272, 274, 4, 122,-32768,-32768,
1519 -32768, 61,-32768, 206, 206,-32768, 183, 290, 290,-32768,
1520 -32768, 121,-32768,-32768,-32768,-32768,-32768,-32768,-32768, -92,
1521 979,-32768, 137, 139, 284, 128,-32768, 61, -70,-32768,
1522 979, 183, 183,-32768,-32768, 1136, 278,-32768,-32768,-32768,
1523 -32768,-32768, 1178,-32768, -15, 1277,-32768, 264,-32768,-32768,
1524 61,-32768, 148, 153, 1192, 1192, 160, -66, 1192,-32768,
1525 162, 1136, 1192, 32, 297, 298, 215, 301, 761,-32768,
1526 -32768, 128, 61, 145,-32768,-32768,-32768,-32768,-32768, 262,
1527 1234, 248, 304, 290,-32768,-32768,-32768,-32768,-32768,-32768,
1528 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
1529 -32768, 157, 422, 1192, 1192, 1192, 1192,-32768,-32768,-32768,
1530 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 1192,
1531 1192, 1192, 1192, 1192, 1192, 1192, 1192, 1192,-32768, 290,
1532 -32768, -34,-32768,-32768, -33, 1019,-32768, 71, -22,-32768,
1533 173, 61,-32768,-32768, 61,-32768,-32768,-32768,-32768,-32768,
1534 -32768,-32768,-32768,-32768,-32768, 157, 422, 180, 181, 182,
1535 184, 186, 1038, 1276, 448, 305, 187, 188, 191,-32768,
1536 -32768, 193, 192,-32768, 128, 614,-32768, 740, 740,-32768,
1537 740, 1178,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
1538 -32768,-32768, 1192,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
1539 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 1192,
1540 88, 119,-32768, 614, 62, 197, 198, 199, 200, 207,
1541 217, 614, 614, 309, 1178, 1192, 1192,-32768,-32768,-32768,
1542 -32768,-32768,-32768,-32768, -73,-32768,-32768,-32768, -73, 193,
1543 193, 212, 216, 1136, 1136, 1136, 1136, 1136,-32768,-32768,
1544 -44, 933, -69,-32768, -40,-32768, 1136, 1136, 1136, -5,
1545 -32768, 1077,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
1546 300, 1136,-32768,-32768,-32768,-32768, 220,-32768, 221, 740,
1547 614, 614, 17,-32768, 23,-32768,-32768, 740, 218, 1192,
1548 1192, 1192, 1192, 1192, 222, 225, 1192, 740, 614, 226,
1549 -32768,-32768,-32768,-32768,-32768,-32768, 1136, 1136,-32768, 227,
1550 229, 230, 231, 1136,-32768, 228, 761, -35,-32768,-32768,
1551 234, 236, 341, 356, 372,-32768, 193,-32768, 61, 241,
1552 238,-32768, 360, -36, 366, 367, 243, 253, 254, 740,
1553 387, 740, 256, 257, 740, 258, 61,-32768, 259, 266,
1554 740, 740, 61, 261, 269, 1192, 270, 271, -67, 1136,
1555 1136, 1136, 1136,-32768,-32768, 263, 1136, 1136, 1192,-32768,
1556 -32768,-32768, 33, 1093,-32768, 273,-32768, 740, 740, 1192,
1557 740, 740, 269,-32768, 269, 1192, 740, 275, 1192, 1192,
1558 1192,-32768,-32768, 1192, 362,-32768, 614, 1136, 1136,-32768,
1559 279, 277, 288, 293,-32768, 280, 292, 42,-32768,-32768,
1560 -32768, 61, 65, 395, 299, 308, 614, 7,-32768,-32768,
1561 -32768,-32768,-32768, 291, 740,-32768,-32768,-32768, 73, 269,
1562 302, 306, 1136,-32768, 1136, 1136,-32768,-32768,-32768, 33,
1563 -32768, 391,-32768, 426, 1,-32768, 1192,-32768,-32768, 307,
1564 -32768,-32768,-32768,-32768, 311, 312, 313,-32768, 453,-32768,
1565 740,-32768, 890, 18, -33, 614, 75,-32768, -73,-32768,
1566 -32768,-32768,-32768,-32768, 327,-32768, 890,-32768, 452, 455,
1567 337, -33, 740, 740, 460, 409,-32768, 740, 462,-32768,
1568 740,-32768, 477, 479,-32768
1569 };
1570
1571 static const short yypgoto[] = { 364,
1572 365, 368, 260, 255, -151,-32768, 0, -27, 403, 16,
1573 -32768,-32768,-32768, 6,-32768,-32768, -139, -298, -389,-32768,
1574 -210,-32768, -269, 10,-32768, -279,-32768,-32768, -23, 281,
1575 -233,-32768, 389, 396, 70, -133, -217, 134, 190,-32768,
1576 -32768, 481,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
1577 -32768,-32768,-32768, 417,-32768,-32768,-32768,-32768,-32768,-32768,
1578 -483, -135, 120, -171,-32768, 447,-32768,-32768,-32768,-32768,
1579 -32768, 34, 125,-32768,-32768,-32768,-32768
1580 };
1581
1582
1583 #define YYLAST 1461
1584
1585
1586 static const short yytable[] = { 10,
1587 72, 251, 309, 241, 283, 240, 373, 94, 145, 443,
1588 373, 250, 356, 10, 252, 12, 323, 325, 350, 287,
1589 288, 289, 290, 291, 394, 80, 294, 410, 250, 12,
1590 375, 376, 83, 412, -54, -54, -54, -54, 298, 299,
1591 74, 75, 395, 118, 98, 18, 78, 21, 1, 545,
1592 119, 3, 79, 216, 217, 371, 300, 301, 372, 19,
1593 295, 368, 22, 551, 411, 129, 384, 121, 456, 129,
1594 411, 98, 470, 296, 297, 389, 130, 121, 298, 299,
1595 211, 10, 26, 27, 28, 29, 30, 31, 32, 143,
1596 33, 384, 510, 23, 394, 384, 300, 301, 385, 384,
1597 384, 208, 209, 24, 388, 212, 390, 549, 447, 215,
1598 345, 436, 345, 345, 100, 345, 101, 442, 43, 44,
1599 45, 25, 307, 46, 404, 370, 535, 246, 57, 58,
1600 146, 96, 60, 61, 62, 63, 1, 1, 2, 3,
1601 3, 4, 517, 532, 298, 299, 518, 51, 345, 95,
1602 281, 282, 246, 284, 84, 466, 345, 345, 552, 243,
1603 546, 2, 300, 301, 4, 64, 285, 246, 246, 246,
1604 246, 246, 292, 293, 246, 140, 298, 299, 100, 34,
1605 101, 509, 121, 491, 373, 492, 298, 299, 416, 52,
1606 418, 419, 420, 371, 300, 301, 372, 100, 100, 101,
1607 101, 214, 358, 371, 300, 301, 372, 100, 517, 101,
1608 104, 105, 521, 306, 345, 345, 345, 218, 219, 220,
1609 221, 53, 345, 353, 100, 39, 101, 40, 143, 55,
1610 522, 34, 345, 345, 483, 132, 133, 76, 373, 351,
1611 373, 253, 254, 255, 256, 257, 258, 259, 260, 261,
1612 262, 241, 80, 240, 355, 100, 352, 101, 248, 65,
1613 87, 249, 66, 102, 103, 67, 91, 68, 97, 88,
1614 89, 143, 369, 246, 345, 92, 345, 93, 125, 345,
1615 126, 141, 204, 206, 493, 345, 345, 496, 497, 498,
1616 57, 58, 207, 96, 60, 61, 62, 63, 387, 1,
1617 2, 213, 3, 4, 210, -55, -56, 537, 399, 222,
1618 539, 244, 345, 345, 250, 345, 345, 308, 314, 315,
1619 316, 345, 317, 326, 318, 327, 328, 64, 330, 329,
1620 332, 345, 359, 360, 361, 362, 246, 417, 246, 246,
1621 246, 367, 363, 423, 107, 108, 109, 110, 111, 112,
1622 377, 345, 364, 402, 378, 405, 406, 421, 415, 345,
1623 422, 426, 430, 533, 431, 432, 433, 347, 348, 437,
1624 349, 438, 435, 439, 440, 441, 444, 445, 446, 448,
1625 449, 450, 547, 379, 380, 381, 382, 383, 451, 452,
1626 454, 456, 457, 459, 460, 345, 391, 392, 393, 464,
1627 345, 461, 467, 357, 465, 468, 469, 475, 484, 411,
1628 495, 365, 366, 513, 503, 478, 504, 345, 345, 507,
1629 482, 65, 345, 505, 66, 345, 487, 67, 506, 68,
1630 127, 508, 246, 519, 514, 246, 246, 246, 529, 531,
1631 487, 523, 479, 264, 265, 524, 427, 428, 515, 538,
1632 540, 541, 542, 434, 57, 58, 543, 96, 134, 135,
1633 136, 63, 550, 1, 2, 553, 3, 4, 554, 407,
1634 408, 409, 555, 558, 559, 561, 564, 414, 565, 196,
1635 197, 313, 528, 198, 116, 312, 304, 424, 425, 131,
1636 128, 64, 511, 536, 38, 115, 86, 499, 0, 471,
1637 472, 473, 474, 429, 0, 0, 476, 477, 0, 479,
1638 0, 0, 266, 267, 268, 269, 270, 271, 272, 273,
1639 274, 275, 276, 277, 278, 279, 0, 0, 0, 453,
1640 0, 455, 0, 0, 458, 0, 0, 501, 502, 0,
1641 462, 463, 0, 0, 0, 0, 0, 0, 0, 0,
1642 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1643 0, 0, 0, 0, 0, 0, 0, 485, 486, 0,
1644 489, 490, 525, 0, 526, 527, 494, 0, 0, 0,
1645 0, 0, 0, 0, 0, 65, 500, 0, 66, 0,
1646 0, 67, -179, 68, 324, 0, 0, 0, 0, 0,
1647 0, 0, 0, 0, 0, 0, 516, -62, 1, 2,
1648 0, 3, 4, 0, 520, 0, 333, 334, 5, 6,
1649 57, 58, 335, 0, 0, 0, 0, 0, 0, 1,
1650 2, 0, 3, 4, 336, 337, 338, 0, 7, 0,
1651 0, 8, 0, 0, 0, 9, 0, 0, 339, 340,
1652 544, 0, 0, 0, 0, 548, 0, 0, 0, 0,
1653 0, 0, 0, 0, 0, 341, 0, 0, 0, 0,
1654 0, 0, 556, 557, 0, 0, 0, 560, 0, 0,
1655 562, 157, 158, 159, 160, 161, 162, 163, 164, 165,
1656 166, 167, 168, 169, 170, 171, 226, 227, 0, 0,
1657 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1658 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1659 0, 0, 0, 228, 178, 179, 180, 181, 182, 183,
1660 184, 185, 186, 187, 188, 189, 0, 229, 0, 230,
1661 231, 232, 333, 334, 0, 0, 57, 58, 335, 0,
1662 100, 0, 101, 0, 0, 1, 2, 342, 3, 4,
1663 336, 337, 338, 0, 0, 0, 0, 57, 58, 0,
1664 0, 0, 0, 0, 339, 340, 1, 2, 0, 3,
1665 4, 223, 0, 0, 0, 0, 0, 0, 0, 0,
1666 0, 341, 0, 0, 0, 224, 225, 0, 0, 0,
1667 0, 0, 0, 0, 0, 0, 0, 157, 158, 159,
1668 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
1669 170, 171, 226, 227, 0, 0, 0, 0, 157, 158,
1670 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
1671 169, 170, 171, 226, 227, 0, 0, 0, 0, 228,
1672 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,
1673 188, 189, 0, 229, 0, 230, 231, 232, 0, 0,
1674 228, 178, 179, 180, 181, 182, 183, 184, 185, 186,
1675 187, 188, 189, 342, 229, 0, 230, 231, 232, 0,
1676 0, 0, 333, 334, 0, 0, 0, 100, 335, 101,
1677 0, 233, 0, 0, 234, 0, 235, 0, 236, 0,
1678 336, 337, 338, 0, 0, 0, 0, 0, 0, 0,
1679 0, 0, 0, 0, 339, 340, 0, 0, 0, 0,
1680 0, 0, 0, 0, 0, 0, 0, 0, 0, 57,
1681 58, 341, 96, 134, 135, 136, 63, 0, 1, 2,
1682 0, 3, 4, 0, 0, 0, 0, 157, 158, 159,
1683 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
1684 170, 171, 226, 227, 0, 0, 64, 0, 0, 0,
1685 0, 0, 0, 0, 0, 57, 58, 0, 96, 60,
1686 61, 62, 63, 0, 1, 2, 0, 3, 4, 228,
1687 178, 179, 180, 181, 182, 183, 184, 185, 186, 187,
1688 188, 189, 120, 229, 0, 230, 231, 232, 0, 0,
1689 0, 0, 64, 0, 0, 57, 58, 0, 96, 60,
1690 61, 62, 63, 342, 1, 2, 0, 3, 4, 0,
1691 0, 0, 0, 0, 57, 58, 0, 96, 134, 135,
1692 136, 63, 303, 1, 2, 0, 3, 4, 0, 0,
1693 0, 0, 64, 0, 0, 0, 0, 0, 0, 0,
1694 65, 0, 0, 66, 0, 0, 67, 0, 68, 386,
1695 0, 64, 0, 57, 58, 0, 96, 60, 61, 62,
1696 63, 0, 1, 2, 0, 3, 4, 0, 0, 57,
1697 58, 0, 96, 60, 61, 62, 63, 0, 1, 2,
1698 398, 3, 4, 0, 0, 0, 65, 0, 0, 66,
1699 64, 0, 67, 0, 68, 0, 481, 0, 57, 58,
1700 0, 59, 60, 61, 62, 63, 64, 1, 2, 0,
1701 3, 4, 57, 58, 0, 96, 134, 135, 136, 63,
1702 0, 1, 2, 0, 3, 4, 65, 0, 0, 66,
1703 0, 0, 67, 0, 68, 64, 0, 0, 0, 0,
1704 0, 0, 0, 0, 0, 65, 0, 0, 66, 64,
1705 319, 67, 0, 68, 57, 58, 0, 142, 60, 61,
1706 62, 63, 0, 1, 2, 0, 3, 4, 57, 58,
1707 0, 96, 60, 61, 62, 63, 0, 1, 2, 0,
1708 3, 4, 0, 0, 65, 0, 0, 66, 0, 0,
1709 67, 64, 68, 0, 0, 0, 0, 0, 0, 0,
1710 65, 0, 0, 66, 0, 64, 67, 0, 68, 0,
1711 57, 58, 0, 245, 60, 61, 62, 63, 0, 1,
1712 2, 0, 3, 4, 0, 0, 0, 0, 0, 65,
1713 0, 0, 66, 0, 0, 67, 0, 68, 0, 0,
1714 0, 0, 0, 65, 0, 0, 66, 64, 0, 67,
1715 0, 68, 57, 58, 0, 96, 134, 135, 136, 63,
1716 0, 1, 2, 0, 3, 4, 0, 0, 0, 0,
1717 0, 0, 0, 0, 0, 0, 0, 148, 0, 0,
1718 0, 0, 0, 0, 0, 65, 0, 0, 66, 64,
1719 0, 67, 0, 68, 0, 0, 149, 150, 0, 65,
1720 0, 0, 66, 0, 0, 67, 0, 68, 151, 152,
1721 153, 154, 155, 156, 157, 158, 159, 160, 161, 162,
1722 163, 164, 165, 166, 167, 168, 169, 170, 171, 172,
1723 173, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1724 0, 65, 0, 0, 66, 0, 0, 67, 0, 68,
1725 0, 174, 175, 176, 0, 0, 177, 178, 179, 180,
1726 181, 182, 183, 184, 185, 186, 187, 188, 189, 190,
1727 191, 192, 193, 194, 195, 0, 0, -178, 0, 0,
1728 0, 0, 0, 65, 0, 0, 66, 0, 0, 67,
1729 0, 322, -62, 1, 2, 0, 3, 4, 0, 0,
1730 0, 0, 0, 5, 6, 0, 0, 0, 0, 0,
1731 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1732 0, 0, 0, 7, 0, 0, 8, 0, 0, 0,
1733 9
1734 };
1735
1736 static const short yycheck[] = { 0,
1737 24, 153, 213, 139, 176, 139, 305, 4, 24, 399,
1738 309, 11, 282, 14, 154, 0, 234, 235, 252, 191,
1739 192, 193, 194, 195, 30, 18, 198, 11, 11, 14,
1740 310, 311, 25, 11, 3, 4, 5, 6, 112, 113,
1741 35, 36, 48, 136, 68, 47, 41, 135, 16, 533,
1742 143, 19, 47, 22, 23, 129, 130, 131, 132, 61,
1743 200, 295, 52, 547, 48, 136, 136, 91, 136, 136,
1744 48, 95, 140, 108, 109, 145, 147, 101, 112, 113,
1745 147, 82, 37, 38, 39, 40, 41, 42, 43, 113,
1746 45, 136, 482, 135, 30, 136, 130, 131, 143, 136,
1747 136, 125, 126, 15, 322, 129, 147, 33, 145, 133,
1748 246, 147, 248, 249, 137, 251, 139, 397, 37, 38,
1749 39, 135, 145, 42, 342, 297, 516, 151, 7, 8,
1750 146, 10, 11, 12, 13, 14, 16, 16, 17, 19,
1751 19, 20, 136, 143, 112, 113, 140, 135, 284, 146,
1752 174, 175, 176, 177, 147, 425, 292, 293, 548, 144,
1753 143, 17, 130, 131, 20, 44, 190, 191, 192, 193,
1754 194, 195, 196, 197, 198, 106, 112, 113, 137, 134,
1755 139, 140, 206, 453, 483, 455, 112, 113, 360, 135,
1756 362, 363, 364, 129, 130, 131, 132, 137, 137, 139,
1757 139, 132, 141, 129, 130, 131, 132, 137, 136, 139,
1758 28, 29, 140, 143, 350, 351, 352, 3, 4, 5,
1759 6, 141, 358, 136, 137, 41, 139, 43, 252, 19,
1760 500, 134, 368, 369, 445, 102, 103, 32, 537, 263,
1761 539, 85, 86, 87, 88, 89, 90, 91, 92, 93,
1762 94, 387, 18, 387, 136, 137, 280, 139, 11, 138,
1763 19, 14, 141, 74, 75, 144, 139, 146, 147, 19,
1764 19, 295, 296, 297, 410, 4, 412, 4, 142, 415,
1765 142, 4, 19, 136, 456, 421, 422, 459, 460, 461,
1766 7, 8, 140, 10, 11, 12, 13, 14, 322, 16,
1767 17, 140, 19, 20, 145, 9, 9, 518, 332, 9,
1768 521, 50, 448, 449, 11, 451, 452, 145, 139, 139,
1769 139, 457, 139, 19, 139, 139, 139, 44, 136, 139,
1770 139, 467, 136, 136, 136, 136, 360, 361, 362, 363,
1771 364, 33, 136, 367, 55, 56, 57, 58, 59, 60,
1772 139, 487, 136, 54, 139, 136, 136, 136, 141, 495,
1773 136, 136, 136, 515, 136, 136, 136, 248, 249, 136,
1774 251, 136, 145, 33, 19, 4, 136, 140, 19, 14,
1775 14, 139, 534, 314, 315, 316, 317, 318, 136, 136,
1776 4, 136, 136, 136, 136, 531, 327, 328, 329, 139,
1777 536, 136, 426, 284, 136, 136, 136, 145, 136, 48,
1778 136, 292, 293, 19, 136, 439, 140, 553, 554, 140,
1779 444, 138, 558, 136, 141, 561, 450, 144, 136, 146,
1780 147, 140, 456, 143, 136, 459, 460, 461, 48, 14,
1781 464, 140, 443, 22, 23, 140, 377, 378, 141, 143,
1782 140, 140, 140, 384, 7, 8, 4, 10, 11, 12,
1783 13, 14, 136, 16, 17, 14, 19, 20, 14, 350,
1784 351, 352, 136, 14, 66, 14, 0, 358, 0, 116,
1785 116, 227, 510, 116, 82, 226, 206, 368, 369, 101,
1786 95, 44, 483, 517, 14, 79, 50, 464, -1, 430,
1787 431, 432, 433, 379, -1, -1, 437, 438, -1, 510,
1788 -1, -1, 91, 92, 93, 94, 95, 96, 97, 98,
1789 99, 100, 101, 102, 103, 104, -1, -1, -1, 410,
1790 -1, 412, -1, -1, 415, -1, -1, 468, 469, -1,
1791 421, 422, -1, -1, -1, -1, -1, -1, -1, -1,
1792 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1793 -1, -1, -1, -1, -1, -1, -1, 448, 449, -1,
1794 451, 452, 503, -1, 505, 506, 457, -1, -1, -1,
1795 -1, -1, -1, -1, -1, 138, 467, -1, 141, -1,
1796 -1, 144, 0, 146, 147, -1, -1, -1, -1, -1,
1797 -1, -1, -1, -1, -1, -1, 487, 15, 16, 17,
1798 -1, 19, 20, -1, 495, -1, 3, 4, 26, 27,
1799 7, 8, 9, -1, -1, -1, -1, -1, -1, 16,
1800 17, -1, 19, 20, 21, 22, 23, -1, 46, -1,
1801 -1, 49, -1, -1, -1, 53, -1, -1, 35, 36,
1802 531, -1, -1, -1, -1, 536, -1, -1, -1, -1,
1803 -1, -1, -1, -1, -1, 52, -1, -1, -1, -1,
1804 -1, -1, 553, 554, -1, -1, -1, 558, -1, -1,
1805 561, 68, 69, 70, 71, 72, 73, 74, 75, 76,
1806 77, 78, 79, 80, 81, 82, 83, 84, -1, -1,
1807 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1808 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1809 -1, -1, -1, 110, 111, 112, 113, 114, 115, 116,
1810 117, 118, 119, 120, 121, 122, -1, 124, -1, 126,
1811 127, 128, 3, 4, -1, -1, 7, 8, 9, -1,
1812 137, -1, 139, -1, -1, 16, 17, 144, 19, 20,
1813 21, 22, 23, -1, -1, -1, -1, 7, 8, -1,
1814 -1, -1, -1, -1, 35, 36, 16, 17, -1, 19,
1815 20, 21, -1, -1, -1, -1, -1, -1, -1, -1,
1816 -1, 52, -1, -1, -1, 35, 36, -1, -1, -1,
1817 -1, -1, -1, -1, -1, -1, -1, 68, 69, 70,
1818 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
1819 81, 82, 83, 84, -1, -1, -1, -1, 68, 69,
1820 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1821 80, 81, 82, 83, 84, -1, -1, -1, -1, 110,
1822 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
1823 121, 122, -1, 124, -1, 126, 127, 128, -1, -1,
1824 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
1825 120, 121, 122, 144, 124, -1, 126, 127, 128, -1,
1826 -1, -1, 3, 4, -1, -1, -1, 137, 9, 139,
1827 -1, 141, -1, -1, 144, -1, 146, -1, 148, -1,
1828 21, 22, 23, -1, -1, -1, -1, -1, -1, -1,
1829 -1, -1, -1, -1, 35, 36, -1, -1, -1, -1,
1830 -1, -1, -1, -1, -1, -1, -1, -1, -1, 7,
1831 8, 52, 10, 11, 12, 13, 14, -1, 16, 17,
1832 -1, 19, 20, -1, -1, -1, -1, 68, 69, 70,
1833 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
1834 81, 82, 83, 84, -1, -1, 44, -1, -1, -1,
1835 -1, -1, -1, -1, -1, 7, 8, -1, 10, 11,
1836 12, 13, 14, -1, 16, 17, -1, 19, 20, 110,
1837 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
1838 121, 122, 34, 124, -1, 126, 127, 128, -1, -1,
1839 -1, -1, 44, -1, -1, 7, 8, -1, 10, 11,
1840 12, 13, 14, 144, 16, 17, -1, 19, 20, -1,
1841 -1, -1, -1, -1, 7, 8, -1, 10, 11, 12,
1842 13, 14, 34, 16, 17, -1, 19, 20, -1, -1,
1843 -1, -1, 44, -1, -1, -1, -1, -1, -1, -1,
1844 138, -1, -1, 141, -1, -1, 144, -1, 146, 147,
1845 -1, 44, -1, 7, 8, -1, 10, 11, 12, 13,
1846 14, -1, 16, 17, -1, 19, 20, -1, -1, 7,
1847 8, -1, 10, 11, 12, 13, 14, -1, 16, 17,
1848 34, 19, 20, -1, -1, -1, 138, -1, -1, 141,
1849 44, -1, 144, -1, 146, -1, 34, -1, 7, 8,
1850 -1, 10, 11, 12, 13, 14, 44, 16, 17, -1,
1851 19, 20, 7, 8, -1, 10, 11, 12, 13, 14,
1852 -1, 16, 17, -1, 19, 20, 138, -1, -1, 141,
1853 -1, -1, 144, -1, 146, 44, -1, -1, -1, -1,
1854 -1, -1, -1, -1, -1, 138, -1, -1, 141, 44,
1855 143, 144, -1, 146, 7, 8, -1, 10, 11, 12,
1856 13, 14, -1, 16, 17, -1, 19, 20, 7, 8,
1857 -1, 10, 11, 12, 13, 14, -1, 16, 17, -1,
1858 19, 20, -1, -1, 138, -1, -1, 141, -1, -1,
1859 144, 44, 146, -1, -1, -1, -1, -1, -1, -1,
1860 138, -1, -1, 141, -1, 44, 144, -1, 146, -1,
1861 7, 8, -1, 10, 11, 12, 13, 14, -1, 16,
1862 17, -1, 19, 20, -1, -1, -1, -1, -1, 138,
1863 -1, -1, 141, -1, -1, 144, -1, 146, -1, -1,
1864 -1, -1, -1, 138, -1, -1, 141, 44, -1, 144,
1865 -1, 146, 7, 8, -1, 10, 11, 12, 13, 14,
1866 -1, 16, 17, -1, 19, 20, -1, -1, -1, -1,
1867 -1, -1, -1, -1, -1, -1, -1, 31, -1, -1,
1868 -1, -1, -1, -1, -1, 138, -1, -1, 141, 44,
1869 -1, 144, -1, 146, -1, -1, 50, 51, -1, 138,
1870 -1, -1, 141, -1, -1, 144, -1, 146, 62, 63,
1871 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
1872 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1873 84, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1874 -1, 138, -1, -1, 141, -1, -1, 144, -1, 146,
1875 -1, 105, 106, 107, -1, -1, 110, 111, 112, 113,
1876 114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
1877 124, 125, 126, 127, 128, -1, -1, 0, -1, -1,
1878 -1, -1, -1, 138, -1, -1, 141, -1, -1, 144,
1879 -1, 146, 15, 16, 17, -1, 19, 20, -1, -1,
1880 -1, -1, -1, 26, 27, -1, -1, -1, -1, -1,
1881 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1882 -1, -1, -1, 46, -1, -1, 49, -1, -1, -1,
1883 53
1884 };
1885 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
1886 #line 3 "/usr/share/bison.simple"
1887 /* This file comes from bison-1.28. */
1888
1889 /* Skeleton output parser for bison,
1890 Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
1891
1892 This program is free software; you can redistribute it and/or modify
1893 it under the terms of the GNU General Public License as published by
1894 the Free Software Foundation; either version 2, or (at your option)
1895 any later version.
1896
1897 This program is distributed in the hope that it will be useful,
1898 but WITHOUT ANY WARRANTY; without even the implied warranty of
1899 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1900 GNU General Public License for more details.
1901
1902 You should have received a copy of the GNU General Public License
1903 along with this program; if not, write to the Free Software
1904 Foundation, Inc., 59 Temple Place - Suite 330,
1905 Boston, MA 02111-1307, USA. */
1906
1907 /* As a special exception, when this file is copied by Bison into a
1908 Bison output file, you may use that output file without restriction.
1909 This special exception was added by the Free Software Foundation
1910 in version 1.24 of Bison. */
1911
1912 /* This is the parser code that is written into each bison parser
1913 when the %semantic_parser declaration is not specified in the grammar.
1914 It was written by Richard Stallman by simplifying the hairy parser
1915 used when %semantic_parser is specified. */
1916
1917 #ifndef YYSTACK_USE_ALLOCA
1918 #ifdef alloca
1919 #define YYSTACK_USE_ALLOCA
1920 #else /* alloca not defined */
1921 #ifdef __GNUC__
1922 #define YYSTACK_USE_ALLOCA
1923 #define alloca __builtin_alloca
1924 #else /* not GNU C. */
1925 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
1926 #define YYSTACK_USE_ALLOCA
1927 #include
1928 #else /* not sparc */
1929 /* We think this test detects Watcom and Microsoft C. */
1930 /* This used to test MSDOS, but that is a bad idea
1931 since that symbol is in the user namespace. */
1932 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
1933 #if 0 /* No need for malloc.h, which pollutes the namespace;
1934 instead, just don't use alloca. */
1935 #include
1936 #endif
1937 #else /* not MSDOS, or __TURBOC__ */
1938 #if defined(_AIX)
1939 /* I don't know what this was needed for, but it pollutes the namespace.
1940 So I turned it off. rms, 2 May 1997. */
1941 /* #include */
1942 #pragma alloca
1943 #define YYSTACK_USE_ALLOCA
1944 #else /* not MSDOS, or __TURBOC__, or _AIX */
1945 #if 0
1946 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
1947 and on HPUX 10. Eventually we can turn this on. */
1948 #define YYSTACK_USE_ALLOCA
1949 #define alloca __builtin_alloca
1950 #endif /* __hpux */
1951 #endif
1952 #endif /* not _AIX */
1953 #endif /* not MSDOS, or __TURBOC__ */
1954 #endif /* not sparc */
1955 #endif /* not GNU C */
1956 #endif /* alloca not defined */
1957 #endif /* YYSTACK_USE_ALLOCA not defined */
1958
1959 #ifdef YYSTACK_USE_ALLOCA
1960 #define YYSTACK_ALLOC alloca
14861961 #else
1487 typedef short int yysigned_char;
1488 #endif
1489
1490 /* YYFINAL -- State number of the termination state. */
1491 #define YYFINAL 39
1492 /* YYLAST -- Last index in YYTABLE. */
1493 #define YYLAST 1317
1494
1495 /* YYNTOKENS -- Number of terminals. */
1496 #define YYNTOKENS 149
1497 /* YYNNTS -- Number of nonterminals. */
1498 #define YYNNTS 79
1499 /* YYNRULES -- Number of rules. */
1500 #define YYNRULES 288
1501 /* YYNRULES -- Number of states. */
1502 #define YYNSTATES 563
1503
1504 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1505 #define YYUNDEFTOK 2
1506 #define YYMAXUTOK 389
1507
1508 #define YYTRANSLATE(YYX) \
1509 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1510
1511 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
1512 static const unsigned char yytranslate[] =
1513 {
1514 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1515 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1516 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1517 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1518 139, 140, 137, 2, 136, 2, 2, 2, 2, 2,
1519 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1520 144, 135, 145, 2, 2, 2, 2, 2, 2, 2,
1521 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1522 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1523 2, 141, 138, 143, 2, 2, 2, 2, 2, 148,
1524 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1525 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1526 142, 2, 2, 146, 2, 147, 2, 2, 2, 2,
1527 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1528 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1529 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1530 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1531 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1532 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1533 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1534 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1535 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1536 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1537 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1538 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1539 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1540 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1541 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1542 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1543 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1544 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1545 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1546 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
1547 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
1548 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
1549 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
1550 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
1551 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
1552 125, 126, 127, 128, 129, 130, 131, 132, 133, 134
1553 };
1554
1555 #if YYDEBUG
1556 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1557 YYRHS. */
1558 static const unsigned short int yyprhs[] =
1559 {
1560 0, 0, 3, 5, 7, 9, 11, 13, 15, 17,
1561 19, 21, 23, 25, 27, 29, 31, 33, 35, 37,
1562 39, 41, 43, 45, 47, 49, 51, 53, 55, 57,
1563 59, 61, 63, 65, 67, 69, 71, 73, 75, 77,
1564 79, 81, 83, 85, 87, 89, 91, 93, 95, 97,
1565 99, 101, 103, 105, 107, 109, 111, 113, 115, 117,
1566 119, 121, 122, 125, 126, 128, 130, 133, 134, 136,
1567 138, 140, 142, 144, 146, 148, 150, 151, 153, 154,
1568 156, 158, 159, 161, 163, 165, 167, 168, 170, 172,
1569 174, 176, 178, 181, 183, 185, 187, 189, 190, 193,
1570 195, 197, 199, 200, 203, 204, 207, 208, 212, 215,
1571 216, 218, 219, 223, 225, 228, 230, 232, 234, 236,
1572 238, 240, 243, 245, 248, 254, 260, 266, 272, 276,
1573 279, 285, 290, 293, 295, 297, 299, 303, 305, 309,
1574 311, 312, 314, 318, 323, 327, 331, 336, 341, 345,
1575 352, 358, 361, 364, 367, 370, 373, 376, 379, 382,
1576 385, 388, 391, 394, 401, 407, 416, 423, 430, 438,
1577 446, 453, 462, 471, 475, 477, 479, 481, 483, 484,
1578 486, 487, 489, 492, 493, 497, 498, 502, 506, 510,
1579 514, 515, 523, 524, 533, 534, 543, 546, 550, 552,
1580 556, 560, 564, 568, 570, 571, 577, 581, 583, 587,
1581 589, 590, 600, 602, 604, 609, 611, 613, 616, 620,
1582 621, 623, 625, 627, 629, 631, 633, 635, 637, 639,
1583 643, 645, 651, 653, 655, 657, 659, 661, 663, 666,
1584 669, 672, 676, 679, 680, 682, 685, 688, 692, 702,
1585 712, 721, 736, 738, 740, 747, 753, 756, 763, 771,
1586 775, 781, 782, 783, 787, 790, 792, 798, 804, 811,
1587 818, 823, 830, 835, 840, 847, 854, 857, 866, 868,
1588 870, 871, 875, 882, 886, 893, 896, 901, 908
1589 };
1590
1591 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1592 static const short int yyrhs[] =
1593 {
1594 190, 0, -1, 68, -1, 69, -1, 70, -1, 71,
1595 -1, 72, -1, 73, -1, 74, -1, 75, -1, 76,
1596 -1, 80, -1, 81, -1, 82, -1, 77, -1, 78,
1597 -1, 79, -1, 111, -1, 112, -1, 113, -1, 114,
1598 -1, 115, -1, 116, -1, 117, -1, 118, -1, 119,
1599 -1, 120, -1, 121, -1, 122, -1, 85, -1, 86,
1600 -1, 87, -1, 88, -1, 89, -1, 90, -1, 91,
1601 -1, 92, -1, 93, -1, 94, -1, 95, -1, 96,
1602 -1, 97, -1, 98, -1, 99, -1, 100, -1, 101,
1603 -1, 102, -1, 103, -1, 104, -1, 91, -1, 92,
1604 -1, 93, -1, 94, -1, 22, -1, 23, -1, 11,
1605 -1, 12, -1, 13, -1, 16, -1, 19, -1, 157,
1606 -1, -1, 157, 135, -1, -1, 17, -1, 20, -1,
1607 160, 135, -1, -1, 37, -1, 39, -1, 38, -1,
1608 40, -1, 42, -1, 41, -1, 43, -1, 45, -1,
1609 -1, 134, -1, -1, 41, -1, 43, -1, -1, 37,
1610 -1, 38, -1, 39, -1, 42, -1, -1, 56, -1,
1611 57, -1, 58, -1, 59, -1, 60, -1, 55, 4,
1612 -1, 112, -1, 113, -1, 130, -1, 131, -1, -1,
1613 169, 168, -1, 129, -1, 132, -1, 168, -1, -1,
1614 171, 170, -1, -1, 48, 4, -1, -1, 136, 48,
1615 4, -1, 30, 19, -1, -1, 174, -1, -1, 136,
1616 177, 176, -1, 174, -1, 48, 4, -1, 11, -1,
1617 12, -1, 13, -1, 14, -1, 44, -1, 178, -1,
1618 179, 137, -1, 212, -1, 138, 4, -1, 179, 139,
1619 183, 140, 171, -1, 10, 139, 183, 140, 171, -1,
1620 141, 4, 142, 179, 143, -1, 144, 4, 142, 179,
1621 145, -1, 146, 184, 147, -1, 146, 147, -1, 144,
1622 146, 184, 147, 145, -1, 144, 146, 147, 145, -1,
1623 179, 169, -1, 179, -1, 10, -1, 180, -1, 182,
1624 136, 180, -1, 182, -1, 182, 136, 34, -1, 34,
1625 -1, -1, 179, -1, 184, 136, 179, -1, 179, 141,
1626 187, 143, -1, 179, 141, 143, -1, 179, 148, 19,
1627 -1, 179, 144, 187, 145, -1, 179, 146, 187, 147,
1628 -1, 179, 146, 147, -1, 179, 144, 146, 187, 147,
1629 145, -1, 179, 144, 146, 147, 145, -1, 179, 35,
1630 -1, 179, 36, -1, 179, 212, -1, 179, 186, -1,
1631 179, 21, -1, 155, 3, -1, 155, 5, -1, 155,
1632 4, -1, 155, 6, -1, 11, 22, -1, 11, 23,
1633 -1, 156, 9, -1, 152, 139, 185, 33, 179, 140,
1634 -1, 110, 139, 185, 223, 140, -1, 124, 139, 185,
1635 136, 185, 136, 185, 140, -1, 150, 139, 185, 136,
1636 185, 140, -1, 151, 139, 185, 136, 185, 140, -1,
1637 83, 153, 139, 185, 136, 185, 140, -1, 84, 154,
1638 139, 185, 136, 185, 140, -1, 126, 139, 185, 136,
1639 185, 140, -1, 127, 139, 185, 136, 185, 136, 185,
1640 140, -1, 128, 139, 185, 136, 185, 136, 185, 140,
1641 -1, 187, 136, 185, -1, 185, -1, 28, -1, 29,
1642 -1, 32, -1, -1, 191, -1, -1, 192, -1, 191,
1643 192, -1, -1, 27, 193, 208, -1, -1, 26, 194,
1644 209, -1, 53, 52, 198, -1, 159, 15, 179, -1,
1645 159, 15, 10, -1, -1, 161, 164, 189, 188, 185,
1646 195, 176, -1, -1, 161, 162, 164, 189, 188, 185,
1647 196, 176, -1, -1, 161, 163, 164, 189, 188, 179,
1648 197, 176, -1, 46, 199, -1, 49, 135, 200, -1,
1649 19, -1, 47, 135, 19, -1, 61, 135, 19, -1,
1650 141, 201, 143, -1, 201, 136, 19, -1, 19, -1,
1651 -1, 202, 136, 179, 169, 158, -1, 179, 169, 158,
1652 -1, 202, -1, 202, 136, 34, -1, 34, -1, -1,
1653 167, 181, 160, 139, 203, 140, 171, 175, 172, -1,
1654 24, -1, 146, -1, 166, 164, 204, 205, -1, 25,
1655 -1, 147, -1, 215, 207, -1, 165, 164, 204, -1,
1656 -1, 54, -1, 3, -1, 4, -1, 9, -1, 22,
1657 -1, 23, -1, 35, -1, 36, -1, 21, -1, 144,
1658 187, 145, -1, 186, -1, 52, 210, 19, 136, 19,
1659 -1, 7, -1, 8, -1, 157, -1, 160, -1, 212,
1660 -1, 211, -1, 179, 213, -1, 215, 216, -1, 206,
1661 216, -1, 217, 159, 218, -1, 217, 220, -1, -1,
1662 18, -1, 62, 214, -1, 62, 10, -1, 63, 14,
1663 213, -1, 63, 11, 213, 136, 14, 213, 136, 14,
1664 213, -1, 64, 155, 213, 136, 14, 213, 141, 219,
1665 143, -1, 64, 155, 213, 136, 14, 213, 141, 143,
1666 -1, 65, 167, 181, 213, 139, 222, 140, 171, 33,
1667 14, 213, 66, 14, 213, -1, 66, -1, 67, -1,
1668 219, 155, 211, 136, 14, 213, -1, 155, 211, 136,
1669 14, 213, -1, 159, 225, -1, 179, 141, 213, 136,
1670 213, 143, -1, 221, 136, 141, 213, 136, 213, 143,
1671 -1, 179, 213, 169, -1, 222, 136, 179, 213, 169,
1672 -1, -1, -1, 223, 136, 214, -1, 51, 50, -1,
1673 50, -1, 150, 179, 213, 136, 213, -1, 151, 179,
1674 213, 136, 213, -1, 83, 153, 179, 213, 136, 213,
1675 -1, 84, 154, 179, 213, 136, 213, -1, 152, 214,
1676 33, 179, -1, 124, 214, 136, 214, 136, 214, -1,
1677 125, 214, 136, 179, -1, 126, 214, 136, 214, -1,
1678 127, 214, 136, 214, 136, 214, -1, 128, 214, 136,
1679 214, 136, 214, -1, 123, 221, -1, 224, 167, 181,
1680 213, 139, 222, 140, 171, -1, 227, -1, 31, -1,
1681 -1, 105, 179, 173, -1, 105, 179, 136, 11, 213,
1682 173, -1, 106, 179, 173, -1, 106, 179, 136, 11,
1683 213, 173, -1, 107, 214, -1, 226, 108, 179, 213,
1684 -1, 226, 109, 214, 136, 179, 213, -1, 110, 179,
1685 213, 223, -1
1686 };
1687
1688 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1689 static const unsigned short int yyrline[] =
1690 {
1691 0, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093,
1692 1093, 1094, 1094, 1094, 1094, 1094, 1094, 1095, 1095, 1095,
1693 1095, 1095, 1095, 1096, 1096, 1096, 1096, 1096, 1096, 1099,
1694 1099, 1100, 1100, 1101, 1101, 1102, 1102, 1103, 1103, 1107,
1695 1107, 1108, 1108, 1109, 1109, 1110, 1110, 1111, 1111, 1112,
1696 1112, 1113, 1113, 1114, 1115, 1120, 1121, 1121, 1123, 1123,
1697 1124, 1124, 1128, 1132, 1137, 1137, 1139, 1143, 1149, 1150,
1698 1151, 1152, 1153, 1157, 1158, 1159, 1163, 1164, 1168, 1169,
1699 1170, 1174, 1175, 1176, 1177, 1178, 1181, 1182, 1183, 1184,
1700 1185, 1186, 1187, 1194, 1195, 1196, 1197, 1200, 1201, 1206,
1701 1207, 1208, 1211, 1212, 1219, 1220, 1226, 1227, 1235, 1243,
1702 1244, 1249, 1250, 1251, 1256, 1269, 1269, 1269, 1269, 1272,
1703 1276, 1280, 1287, 1292, 1300, 1326, 1353, 1358, 1370, 1380,
1704 1384, 1394, 1401, 1408, 1415, 1420, 1425, 1432, 1433, 1440,
1705 1447, 1455, 1461, 1473, 1501, 1517, 1546, 1574, 1599, 1618,
1706 1644, 1664, 1676, 1683, 1749, 1759, 1769, 1775, 1785, 1791,
1707 1801, 1806, 1811, 1819, 1831, 1853, 1861, 1867, 1878, 1883,
1708 1888, 1894, 1900, 1909, 1913, 1921, 1921, 1924, 1924, 1935,
1709 1940, 1948, 1949, 1953, 1953, 1957, 1957, 1960, 1963, 1987,
1710 1998, 1998, 2008, 2008, 2016, 2016, 2026, 2029, 2035, 2048,
1711 2052, 2057, 2059, 2064, 2069, 2078, 2088, 2099, 2103, 2112,
1712 2121, 2126, 2245, 2245, 2247, 2256, 2256, 2258, 2263, 2275,
1713 2279, 2284, 2288, 2292, 2296, 2300, 2304, 2308, 2312, 2316,
1714 2341, 2345, 2359, 2363, 2367, 2371, 2377, 2377, 2383, 2392,
1715 2396, 2405, 2414, 2423, 2427, 2432, 2436, 2440, 2445, 2455,
1716 2474, 2483, 2559, 2563, 2570, 2581, 2594, 2604, 2615, 2625,
1717 2634, 2643, 2646, 2647, 2654, 2658, 2663, 2684, 2701, 2715,
1718 2729, 2741, 2749, 2756, 2762, 2768, 2774, 2789, 2870, 2875,
1719 2879, 2886, 2893, 2901, 2908, 2916, 2924, 2938, 2955
1720 };
1721 #endif
1722
1723 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1724 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1725 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1726 static const char *const yytname[] =
1727 {
1728 "$end", "error", "$undefined", "ESINT64VAL", "EUINT64VAL", "ESAPINTVAL",
1729 "EUAPINTVAL", "LOCALVAL_ID", "GLOBALVAL_ID", "FPVAL", "VOID", "INTTYPE",
1730 "FLOAT", "DOUBLE", "LABEL", "TYPE", "LOCALVAR", "GLOBALVAR", "LABELSTR",
1731 "STRINGCONSTANT", "ATSTRINGCONSTANT", "ZEROINITIALIZER", "TRUETOK",
1732 "FALSETOK", "BEGINTOK", "ENDTOK", "DECLARE", "DEFINE", "GLOBAL",
1733 "CONSTANT", "SECTION", "VOLATILE", "THREAD_LOCAL", "TO", "DOTDOTDOT",
1734 "NULL_TOK", "UNDEF", "INTERNAL", "LINKONCE", "WEAK", "APPENDING",
1735 "DLLIMPORT", "DLLEXPORT", "EXTERN_WEAK", "OPAQUE", "EXTERNAL", "TARGET",
1736 "TRIPLE", "ALIGN", "DEPLIBS", "CALL", "TAIL", "ASM_TOK", "MODULE",
1737 "SIDEEFFECT", "CC_TOK", "CCC_TOK", "FASTCC_TOK", "COLDCC_TOK",
1738 "X86_STDCALLCC_TOK", "X86_FASTCALLCC_TOK", "DATALAYOUT", "RET", "BR",
1739 "SWITCH", "INVOKE", "UNWIND", "UNREACHABLE", "ADD", "SUB", "MUL", "UDIV",
1740 "SDIV", "FDIV", "UREM", "SREM", "FREM", "AND", "OR", "XOR", "SHL",
1741 "LSHR", "ASHR", "ICMP", "FCMP", "EQ", "NE", "SLT", "SGT", "SLE", "SGE",
1742 "ULT", "UGT", "ULE", "UGE", "OEQ", "ONE", "OLT", "OGT", "OLE", "OGE",
1743 "ORD", "UNO", "UEQ", "UNE", "MALLOC", "ALLOCA", "FREE", "LOAD", "STORE",
1744 "GETELEMENTPTR", "TRUNC", "ZEXT", "SEXT", "FPTRUNC", "FPEXT", "BITCAST",
1745 "UITOFP", "SITOFP", "FPTOUI", "FPTOSI", "INTTOPTR", "PTRTOINT",
1746 "PHI_TOK", "SELECT", "VAARG", "EXTRACTELEMENT", "INSERTELEMENT",
1747 "SHUFFLEVECTOR", "NORETURN", "INREG", "SRET", "NOUNWIND", "DEFAULT",
1748 "HIDDEN", "'='", "','", "'*'", "'\\\\'", "'('", "')'", "'['", "'x'",
1749 "']'", "'<'", "'>'", "'{'", "'}'", "'c'", "$accept", "ArithmeticOps",
1750 "LogicalOps", "CastOps", "IPredicates", "FPredicates", "IntType",
1751 "FPType", "LocalName", "OptLocalName", "OptLocalAssign", "GlobalName",
1752 "OptGlobalAssign", "GVInternalLinkage", "GVExternalLinkage",
1753 "GVVisibilityStyle", "FunctionDeclareLinkage", "FunctionDefineLinkage",
1754 "OptCallingConv", "ParamAttr", "OptParamAttrs", "FuncAttr",
1755 "OptFuncAttrs", "OptAlign", "OptCAlign", "SectionString", "OptSection",
1756 "GlobalVarAttributes", "GlobalVarAttribute", "PrimType", "Types",
1757 "ArgType", "ResultTypes", "ArgTypeList", "ArgTypeListI", "TypeListI",
1758 "ConstVal", "ConstExpr", "ConstVector", "GlobalType", "ThreadLocal",
1759 "Module", "DefinitionList", "Definition", "@1", "@2", "@3", "@4", "@5",
1760 "AsmBlock", "TargetDefinition", "LibrariesDefinition", "LibList",
1761 "ArgListH", "ArgList", "FunctionHeaderH", "BEGIN", "FunctionHeader",
1762 "END", "Function", "FunctionProto", "OptSideEffect", "ConstValueRef",
1763 "SymbolicValueRef", "ValueRef", "ResolvedVal", "BasicBlockList",
1764 "BasicBlock", "InstructionList", "BBTerminatorInst", "JumpTable", "Inst",
1765 "PHIList", "ValueRefList", "IndexList", "OptTailCall", "InstVal",
1766 "OptVolatile", "MemoryInst", 0
1767 };
1768 #endif
1769
1770 # ifdef YYPRINT
1771 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1772 token YYLEX-NUM. */
1773 static const unsigned short int yytoknum[] =
1774 {
1775 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1776 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1777 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1778 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1779 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1780 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1781 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
1782 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
1783 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
1784 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
1785 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
1786 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
1787 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
1788 385, 386, 387, 388, 389, 61, 44, 42, 92, 40,
1789 41, 91, 120, 93, 60, 62, 123, 125, 99
1790 };
1791 # endif
1792
1793 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1794 static const unsigned char yyr1[] =
1795 {
1796 0, 149, 150, 150, 150, 150, 150, 150, 150, 150,
1797 150, 151, 151, 151, 151, 151, 151, 152, 152, 152,
1798 152, 152, 152, 152, 152, 152, 152, 152, 152, 153,
1799 153, 153, 153, 153, 153, 153, 153, 153, 153, 154,
1800 154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1801 154, 154, 154, 154, 154, 155, 156, 156, 157, 157,
1802 158, 158, 159, 159, 160, 160, 161, 161, 162, 162,
1803 162, 162, 162, 163, 163, 163, 164, 164, 165, 165,
1804 165, 166, 166, 166, 166, 166, 167, 167, 167, 167,
1805 167, 167, 167, 168, 168, 168, 168, 169, 169, 170,
1806 170, 170, 171, 171, 172, 172, 173, 173, 174, 175,
1807 175, 176, 176, 177, 177, 178, 178, 178, 178, 179,
1808 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
1809 179, 179, 180, 181, 181, 182, 182, 183, 183, 183,
1810 183, 184, 184, 185, 185, 185, 185, 185, 185, 185,
1811 185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
1812 185, 185, 185, 186, 186, 186, 186, 186, 186, 186,
1813 186, 186, 186, 187, 187, 188, 188, 189, 189, 190,
1814 190, 191, 191, 193, 192, 194, 192, 192, 192, 192,
1815 195, 192, 196, 192, 197, 192, 192, 192, 198, 199,
1816 199, 200, 201, 201, 201, 202, 202, 203, 203, 203,
1817 203, 204, 205, 205, 206, 207, 207, 208, 209, 210,
1818 210, 211, 211, 211, 211, 211, 211, 211, 211, 211,
1819 211, 211, 212, 212, 212, 212, 213, 213, 214, 215,
1820 215, 216, 217, 217, 217, 218, 218, 218, 218, 218,
1821 218, 218, 218, 218, 219, 219, 220, 221, 221, 222,
1822 222, 222, 223, 223, 224, 224, 225, 225, 225, 225,
1823 225, 225, 225, 225, 225, 225, 225, 225, 225, 226,
1824 226, 227, 227, 227, 227, 227, 227, 227, 227
1825 };
1826
1827 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1828 static const unsigned char yyr2[] =
1829 {
1830 0, 2, 1, 1, 1, 1, 1, 1, 1, 1,
1831 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1832 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1833 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1834 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1835 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1836 1, 0, 2, 0, 1, 1, 2, 0, 1, 1,
1837 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,
1838 1, 0, 1, 1, 1, 1, 0, 1, 1, 1,
1839 1, 1, 2, 1, 1, 1, 1, 0, 2, 1,
1840 1, 1, 0, 2, 0, 2, 0, 3, 2, 0,
1841 1, 0, 3, 1, 2, 1, 1, 1, 1, 1,
1842 1, 2, 1, 2, 5, 5, 5, 5, 3, 2,
1843 5, 4, 2, 1, 1, 1, 3, 1, 3, 1,
1844 0, 1, 3, 4, 3, 3, 4, 4, 3, 6,
1845 5, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1846 2, 2, 2, 6, 5, 8, 6, 6, 7, 7,
1847 6, 8, 8, 3, 1, 1, 1, 1, 0, 1,
1848 0, 1, 2, 0, 3, 0, 3, 3, 3, 3,
1849 0, 7, 0, 8, 0, 8, 2, 3, 1, 3,
1850 3, 3, 3, 1, 0, 5, 3, 1, 3, 1,
1851 0, 9, 1, 1, 4, 1, 1, 2, 3, 0,
1852 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
1853 1, 5, 1, 1, 1, 1, 1, 1, 2, 2,
1854 2, 3, 2, 0, 1, 2, 2, 3, 9, 9,
1855 8, 14, 1, 1, 6, 5, 2, 6, 7, 3,
1856 5, 0, 0, 3, 2, 1, 5, 5, 6, 6,
1857 4, 6, 4, 4, 6, 6, 2, 8, 1, 1,
1858 0, 3, 6, 3, 6, 2, 4, 6, 4
1859 };
1860
1861 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
1862 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
1863 means the default is an error. */
1864 static const unsigned short int yydefact[] =
1865 {
1866 67, 58, 64, 59, 65, 185, 183, 0, 0, 0,
1867 0, 0, 0, 76, 0, 67, 181, 78, 81, 0,
1868 0, 196, 0, 0, 62, 0, 66, 68, 70, 69,
1869 71, 73, 72, 74, 75, 77, 76, 76, 178, 1,
1870 182, 79, 80, 76, 186, 82, 83, 84, 85, 76,
1871 243, 184, 243, 0, 0, 204, 197, 198, 187, 232,
1872 233, 189, 115, 116, 117, 118, 119, 0, 0, 0,
1873 0, 234, 235, 120, 188, 122, 178, 178, 177, 0,
1874 86, 86, 244, 240, 63, 215, 216, 217, 239, 199,
1875 200, 203, 0, 140, 123, 0, 0, 0, 0, 129,
1876 141, 0, 121, 140, 0, 0, 175, 176, 0, 0,
1877 87, 88, 89, 90, 91, 0, 218, 0, 280, 242,
1878 0, 201, 139, 97, 135, 137, 0, 0, 0, 0,
1879 0, 0, 128, 0, 0, 0, 115, 116, 117, 0,
1880 0, 0, 190, 92, 134, 133, 0, 212, 213, 214,
1881 279, 265, 0, 0, 0, 0, 86, 252, 253, 2,
1882 3, 4, 5, 6, 7, 8, 9, 10, 14, 15,
1883 16, 11, 12, 13, 0, 0, 0, 0, 0, 0,
1884 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
1885 27, 28, 0, 0, 0, 0, 0, 0, 0, 0,
1886 0, 241, 86, 256, 0, 278, 202, 132, 0, 102,
1887 0, 0, 131, 0, 142, 102, 192, 194, 160, 161,
1888 156, 158, 157, 159, 162, 155, 151, 152, 0, 0,
1889 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1890 0, 0, 154, 153, 111, 0, 264, 246, 0, 245,
1891 0, 0, 55, 0, 0, 29, 30, 31, 32, 33,
1892 34, 35, 36, 37, 38, 0, 53, 54, 49, 50,
1893 51, 52, 39, 40, 41, 42, 43, 44, 45, 46,
1894 47, 48, 0, 106, 106, 285, 0, 0, 276, 0,
1895 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1896 93, 94, 95, 96, 98, 138, 136, 125, 126, 127,
1897 130, 124, 111, 111, 0, 0, 0, 0, 0, 0,
1898 0, 144, 174, 0, 0, 0, 148, 0, 145, 0,
1899 0, 0, 0, 191, 210, 221, 222, 223, 228, 224,
1900 225, 226, 227, 219, 0, 230, 237, 236, 238, 0,
1901 247, 0, 0, 0, 0, 0, 281, 0, 283, 262,
1902 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1903 0, 0, 0, 99, 100, 101, 103, 193, 195, 0,
1904 0, 262, 0, 0, 0, 0, 0, 143, 129, 141,
1905 0, 146, 147, 0, 0, 0, 0, 0, 113, 111,
1906 209, 97, 207, 0, 220, 0, 0, 0, 0, 0,
1907 0, 0, 0, 0, 0, 288, 0, 0, 0, 272,
1908 273, 0, 0, 0, 0, 270, 0, 286, 0, 0,
1909 0, 0, 0, 0, 0, 0, 173, 150, 0, 0,
1910 0, 0, 108, 114, 112, 61, 0, 102, 0, 229,
1911 0, 0, 261, 0, 0, 106, 107, 106, 0, 0,
1912 0, 0, 0, 0, 266, 267, 261, 0, 0, 0,
1913 164, 0, 0, 0, 0, 149, 0, 0, 0, 60,
1914 206, 208, 97, 109, 0, 0, 0, 0, 0, 268,
1915 269, 0, 282, 284, 263, 0, 0, 271, 274, 275,
1916 0, 287, 0, 0, 0, 170, 0, 0, 166, 167,
1917 163, 61, 110, 104, 231, 0, 0, 97, 0, 102,
1918 257, 0, 102, 168, 169, 0, 0, 0, 205, 0,
1919 211, 0, 250, 0, 0, 259, 0, 0, 258, 277,
1920 165, 171, 172, 105, 248, 0, 249, 0, 97, 0,
1921 0, 0, 260, 0, 0, 0, 0, 255, 0, 0,
1922 254, 0, 251
1923 };
1924
1925 /* YYDEFGOTO[NTERM-NUM]. */
1926 static const short int yydefgoto[] =
1927 {
1928 -1, 239, 240, 241, 265, 282, 139, 140, 71, 480,
1929 11, 72, 13, 36, 37, 38, 43, 49, 115, 304,
1930 207, 376, 307, 530, 356, 398, 513, 333, 399, 73,
1931 141, 124, 146, 125, 126, 101, 322, 345, 323, 108,
1932 79, 14, 15, 16, 18, 17, 244, 312, 313, 58,
1933 21, 56, 92, 402, 403, 116, 149, 50, 87, 51,
1934 44, 405, 346, 75, 348, 249, 52, 83, 84, 201,
1935 534, 119, 288, 488, 415, 202, 203, 204, 205
1936 };
1937
1938 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1939 STATE-NUM. */
1940 #define YYPACT_NINF -476
1941 static const short int yypact[] =
1942 {
1943 28, -476, -476, -476, -476, -476, -476, -10, -55, 8,
1944 -33, 97, 3, 55, 167, 394, -476, 172, 210, 86,
1945 98, -476, 102, 219, -476, 1017, -476, -476, -476, -476,
1946 -476, -476, -476, -476, -476, -476, 123, 123, 218, -476,
1947 -476, -476, -476, 123, -476, -476, -476, -476, -476, 123,
1948 241, -476, 2, 242, 251, 253, -476, -476, -476, -476,
1949 -476, 137, -476, -476, -476, -476, -476, 274, 283, 1,
1950 456, -476, -476, -476, 83, -476, 218, 218, -476, 103,
1951 291, 291, -476, -476, 121, -476, -476, -476, -476, -476,
1952 -476, -476, -26, 874, -476, 148, 149, 470, 137, -476,
1953 83, -97, -476, 874, 103, 103, -476, -476, 1031, 288,
1954 -476, -476, -476, -476, -476, 1073, -476, -7, 1172, -476,
1955 282, -476, -476, 83, -476, 157, 162, 1087, 1087, 158,
1956 -61, 1087, -476, 165, 1031, 1087, 60, 297, 298, 201,
1957 299, 656, -476, -476, 137, 83, 217, -476, -476, -476,
1958 -476, -476, 262, 1129, 257, 302, 291, -476, -476, -476,
1959 -476, -476, -476, -476, -476, -476, -476, -476, -476, -476,
1960 -476, -476, -476, -476, 461, 273, 1087, 1087, 1087, 1087,
1961 -476, -476, -476, -476, -476, -476, -476, -476, -476, -476,
1962 -476, -476, 1087, 1087, 1087, 1087, 1087, 1087, 1087, 1087,
1963 1087, -476, 291, -476, 74, -476, -476, -25, 914, -476,
1964 19, 41, -476, 175, 83, -476, -476, 83, -476, -476,
1965 -476, -476, -476, -476, -476, -476, -476, -476, 461, 273,
1966 178, 182, 183, 184, 186, 933, 1171, 552, 309, 190,
1967 191, 194, -476, -476, 199, 197, -476, 137, 509, -476,
1968 635, 635, -476, 635, 1073, -476, -476, -476, -476, -476,
1969 -476, -476, -476, -476, -476, 1087, -476, -476, -476, -476,
1970 -476, -476, -476, -476, -476, -476, -476, -476, -476, -476,
1971 -476, -476, 1087, -17, 92, -476, 509, 75, 207, 208,
1972 220, 221, 222, 223, 509, 509, 304, 1073, 1087, 1087,
1973 -476, -476, -476, -476, -476, -476, -476, 154, -476, -476,
1974 -476, 154, 199, 199, 214, 215, 1031, 1031, 1031, 1031,
1975 1031, -476, -476, -22, 828, -75, -476, -58, -476, 1031,
1976 1031, 1031, 5, -476, 972, -476, -476, -476, -476, -476,
1977 -476, -476, -476, 301, 1031, -476, -476, -476, -476, 224,
1978 -476, 226, 635, 509, 509, 14, -476, 23, -476, -476,
1979 635, 237, 1087, 1087, 1087, 1087, 1087, 243, 244, 1087,
1980 635, 509, 246, -476, -476, -476, -476, -476, -476, 1031,
1981 1031, -476, 247, 248, 254, 255, 1031, -476, 250, 656,
1982 -46, -476, -476, 256, 261, 360, 383, 399, -476, 199,
1983 -476, 83, 269, 266, -476, 388, -60, 398, 401, 277,
1984 272, 289, 635, 420, 635, 293, 294, 635, 295, 83,
1985 -476, 296, 300, 635, 635, 83, 305, -476, 1087, 310,
1986 314, -98, 1031, 1031, 1031, 1031, -476, -476, 290, 1031,
1987 1031, 1087, -476, -476, -476, 33, 988, -476, 315, -476,
1988 635, 635, 1087, 635, 635, 316, -476, 316, 1087, 635,
1989 317, 1087, 1087, 1087, -476, -476, 1087, 509, 1031, 1031,
1990 -476, 318, 287, 320, 321, -476, 319, 322, 116, -476,
1991 -476, -476, 83, 79, 414, 324, 330, 509, 21, -476,
1992 -476, 393, -476, -476, -476, 331, 635, -476, -476, -476,
1993 59, -476, 325, 339, 1031, -476, 1031, 1031, -476, -476,
1994 -476, 33, -476, 410, -476, 447, -2, -476, 1087, -476,
1995 -476, 342, -476, -476, -476, 348, 351, 352, -476, 489,
1996 -476, 635, -476, 785, -1, -25, 509, 133, -476, 154,
1997 -476, -476, -476, -476, -476, 359, -476, 785, -476, 482,
1998 483, 362, -25, 635, 635, 485, 439, -476, 635, 492,
1999 -476, 635, -476
2000 };
2001
2002 /* YYPGOTO[NTERM-NUM]. */
2003 static const short int yypgoto[] =
2004 {
2005 -476, 389, 392, 397, 292, 306, -153, -476, 0, 10,
2006 435, 4, -476, -476, -476, 87, -476, -476, -145, -295,
2007 -383, -476, -208, -476, -276, 39, -476, -291, -476, -476,
2008 -24, 326, -241, -476, 421, 426, 69, -138, -196, 89,
2009 204, -476, -476, 512, -476, -476, -476, -476, -476, -476,
2010 -476, -476, -476, -476, -476, 452, -476, -476, -476, -476,
2011 -476, -476, -475, -135, -227, -164, -476, 484, -476, -476,
2012 -476, -476, -476, 73, 159, -476, -476, -476, -476
2013 };
2014
2015 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
2016 positive, shift that token. If negative, reduce the rule which
2017 number is the opposite. If zero, do what YYDEFACT says.
2018 If YYTABLE_NINF, syntax error. */
2019 #define YYTABLE_NINF -181
2020 static const short int yytable[] =
2021 {
2022 10, 74, 253, 242, 12, 96, 243, 311, 358, 252,
2023 252, 254, 375, 352, 285, 10, 375, 147, 445, 12,
2024 82, 377, 378, 349, 350, 412, 351, 85, -180, 289,
2025 290, 291, 292, 293, 414, 396, 296, 19, 458, 131,
2026 325, 327, 470, -63, 1, 2, 100, 3, 4, 1,
2027 132, 20, 3, 397, 5, 6, 370, 297, 545, 359,
2028 23, 386, 413, -55, -55, -55, -55, 367, 368, 123,
2029 391, 413, 551, 100, 7, 131, 386, 8, 386, 123,
2030 22, 9, 218, 219, 10, 449, 213, 300, 301, 392,
2031 386, 145, 27, 28, 29, 30, 31, 32, 33, 511,
2032 34, 438, 24, 210, 211, 302, 303, 214, 444, 396,
2033 120, 217, 25, 347, 386, 347, 347, 121, 347, 355,
2034 102, 387, 103, 76, 77, 409, 410, 411, 390, 248,
2035 80, 106, 107, 416, 535, 372, 81, 1, 26, 148,
2036 3, 532, 546, 426, 427, 300, 301, 97, 406, 86,
2037 245, 347, 283, 284, 248, 286, 102, 518, 103, 347,
2038 347, 519, 308, 302, 303, 552, 549, 39, 287, 248,
2039 248, 248, 248, 248, 294, 295, 248, 142, 102, 492,
2040 103, 493, 298, 299, 123, 455, 309, 457, 375, 35,
2041 460, 300, 301, 134, 135, 518, 464, 465, 418, 522,
2042 420, 421, 422, 216, 220, 221, 222, 223, 373, 302,
2043 303, 374, 102, 41, 103, 42, 360, 347, 347, 347,
2044 102, 53, 103, 485, 486, 347, 489, 490, 357, 102,
2045 145, 103, 495, 54, 2, 347, 347, 4, 57, 483,
2046 501, 353, 375, 55, 375, 300, 301, 45, 46, 47,
2047 78, 242, 48, 102, 243, 103, 510, 35, 354, 82,
2048 517, 89, 373, 302, 303, 374, 300, 301, 250, 521,
2049 90, 251, 91, 145, 371, 248, 93, 347, 94, 347,
2050 104, 105, 347, 373, 302, 303, 374, 95, 347, 347,
2051 127, 128, 143, 208, 494, 266, 267, 497, 498, 499,
2052 389, 206, 209, 212, 544, 215, -56, -57, 224, 548,
2053 401, 537, 246, 252, 539, 347, 347, 316, 347, 347,
2054 310, 317, 318, 319, 347, 320, 556, 557, 328, 329,
2055 330, 560, 347, 331, 562, 332, 334, 369, 248, 419,
2056 248, 248, 248, 361, 362, 425, 109, 110, 111, 112,
2057 113, 114, 347, 379, 380, 404, 363, 364, 365, 366,
2058 407, 347, 408, 533, 268, 269, 270, 271, 272, 273,
2059 274, 275, 276, 277, 278, 279, 280, 281, 417, 423,
2060 424, 547, 428, 432, 433, 381, 382, 383, 384, 385,
2061 434, 435, 439, 441, -179, 437, 347, 440, 393, 394,
2062 395, 347, 442, 443, 467, 446, 447, 448, 453, -63,
2063 1, 2, 450, 3, 4, 451, 452, 478, 347, 347,
2064 5, 6, 482, 347, 456, 454, 347, 505, 487, 458,
2065 459, 461, 462, 514, 248, 475, 463, 248, 248, 248,
2066 7, 413, 487, 8, 466, 479, 468, 9, 429, 430,
2067 469, 484, 491, 496, 504, 436, 506, 507, 529, 508,
2068 515, 531, 509, 59, 60, 523, 98, 62, 63, 64,
2069 65, 516, 1, 2, 520, 3, 4, 59, 60, 524,
2070 98, 62, 63, 64, 65, 538, 1, 2, 540, 3,
2071 4, 541, 542, 543, 536, 550, 553, 554, 555, 558,
2072 66, 471, 472, 473, 474, 559, 561, 198, 476, 477,
2073 199, 479, 335, 336, 66, 200, 59, 60, 337, 118,
2074 314, 528, 512, 130, 133, 1, 2, 40, 3, 4,
2075 338, 339, 340, 117, 306, 315, 88, 502, 503, 500,
2076 431, 0, 0, 0, 341, 342, 255, 256, 257, 258,
2077 259, 260, 261, 262, 263, 264, 0, 0, 0, 59,
2078 60, 343, 98, 136, 137, 138, 65, 0, 1, 2,
2079 0, 3, 4, 525, 0, 526, 527, 159, 160, 161,
2080 162, 163, 164, 165, 166, 167, 168, 169, 170, 171,
2081 172, 173, 228, 229, 67, 0, 66, 68, 0, 0,
2082 69, 0, 70, 99, 0, 0, 0, 0, 67, 0,
2083 0, 68, 0, 0, 69, 0, 70, 129, 0, 230,
2084 180, 181, 182, 183, 184, 185, 186, 187, 188, 189,
2085 190, 191, 0, 231, 0, 232, 233, 234, 335, 336,
2086 0, 0, 59, 60, 337, 0, 102, 0, 103, 0,
2087 0, 1, 2, 344, 3, 4, 338, 339, 340, 0,
2088 0, 0, 0, 59, 60, 0, 0, 0, 0, 0,
2089 341, 342, 1, 2, 0, 3, 4, 225, 0, 0,
2090 0, 0, 0, 0, 0, 0, 0, 343, 0, 0,
2091 67, 226, 227, 68, 0, 0, 69, 0, 70, 326,
2092 0, 0, 0, 159, 160, 161, 162, 163, 164, 165,
2093 166, 167, 168, 169, 170, 171, 172, 173, 228, 229,
2094 0, 0, 0, 0, 159, 160, 161, 162, 163, 164,
2095 165, 166, 167, 168, 169, 170, 171, 172, 173, 228,
2096 229, 0, 0, 0, 0, 230, 180, 181, 182, 183,
2097 184, 185, 186, 187, 188, 189, 190, 191, 0, 231,
2098 0, 232, 233, 234, 0, 0, 230, 180, 181, 182,
2099 183, 184, 185, 186, 187, 188, 189, 190, 191, 344,
2100 231, 0, 232, 233, 234, 0, 0, 0, 335, 336,
2101 0, 0, 0, 102, 337, 103, 0, 235, 0, 0,
2102 236, 0, 237, 0, 238, 0, 338, 339, 340, 0,
2103 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2104 341, 342, 0, 0, 0, 0, 0, 0, 0, 0,
2105 0, 0, 0, 0, 0, 59, 60, 343, 98, 136,
2106 137, 138, 65, 0, 1, 2, 0, 3, 4, 0,
2107 0, 0, 0, 159, 160, 161, 162, 163, 164, 165,
2108 166, 167, 168, 169, 170, 171, 172, 173, 228, 229,
2109 0, 0, 66, 0, 0, 0, 0, 0, 0, 0,
2110 0, 59, 60, 0, 98, 62, 63, 64, 65, 0,
2111 1, 2, 0, 3, 4, 230, 180, 181, 182, 183,
2112 184, 185, 186, 187, 188, 189, 190, 191, 122, 231,
2113 0, 232, 233, 234, 0, 0, 0, 0, 66, 0,
2114 0, 59, 60, 0, 98, 62, 63, 64, 65, 344,
2115 1, 2, 0, 3, 4, 0, 0, 0, 0, 0,
2116 59, 60, 0, 98, 136, 137, 138, 65, 305, 1,
2117 2, 0, 3, 4, 0, 0, 0, 0, 66, 0,
2118 0, 0, 0, 0, 0, 0, 67, 0, 0, 68,
2119 0, 0, 69, 0, 70, 388, 0, 66, 0, 59,
2120 60, 0, 98, 62, 63, 64, 65, 0, 1, 2,
2121 0, 3, 4, 0, 0, 59, 60, 0, 98, 62,
2122 63, 64, 65, 0, 1, 2, 400, 3, 4, 0,
2123 0, 0, 67, 0, 0, 68, 66, 0, 69, 0,
2124 70, 0, 481, 0, 59, 60, 0, 61, 62, 63,
2125 64, 65, 66, 1, 2, 0, 3, 4, 59, 60,
2126 0, 98, 136, 137, 138, 65, 0, 1, 2, 0,
2127 3, 4, 67, 0, 0, 68, 0, 0, 69, 0,
2128 70, 66, 0, 0, 0, 0, 0, 0, 0, 0,
2129 0, 67, 0, 0, 68, 66, 321, 69, 0, 70,
2130 59, 60, 0, 144, 62, 63, 64, 65, 0, 1,
2131 2, 0, 3, 4, 59, 60, 0, 98, 62, 63,
2132 64, 65, 0, 1, 2, 0, 3, 4, 0, 0,
2133 67, 0, 0, 68, 0, 0, 69, 66, 70, 0,
2134 0, 0, 0, 0, 0, 0, 67, 0, 0, 68,
2135 0, 66, 69, 0, 70, 0, 59, 60, 0, 247,
2136 62, 63, 64, 65, 0, 1, 2, 0, 3, 4,
2137 0, 0, 0, 0, 0, 67, 0, 0, 68, 0,
2138 0, 69, 0, 70, 0, 0, 0, 0, 0, 67,
2139 0, 0, 68, 66, 0, 69, 0, 70, 59, 60,
2140 0, 98, 136, 137, 138, 65, 0, 1, 2, 0,
2141 3, 4, 0, 0, 0, 0, 0, 0, 0, 0,
2142 0, 0, 0, 150, 0, 0, 0, 0, 0, 0,
2143 0, 67, 0, 0, 68, 66, 0, 69, 0, 70,
2144 0, 0, 151, 152, 0, 67, 0, 0, 68, 0,
2145 0, 69, 0, 70, 153, 154, 155, 156, 157, 158,
2146 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
2147 169, 170, 171, 172, 173, 174, 175, 0, 0, 0,
2148 0, 0, 0, 0, 0, 0, 0, 67, 0, 0,
2149 68, 0, 0, 69, 0, 70, 0, 176, 177, 178,
2150 0, 0, 179, 180, 181, 182, 183, 184, 185, 186,
2151 187, 188, 189, 190, 191, 192, 193, 194, 195, 196,
2152 197, 0, 0, 0, 0, 0, 0, 0, 0, 67,
2153 0, 0, 68, 0, 0, 69, 0, 324
2154 };
2155
2156 static const short int yycheck[] =
2157 {
2158 0, 25, 155, 141, 0, 4, 141, 215, 284, 11,
2159 11, 156, 307, 254, 178, 15, 311, 24, 401, 15,
2160 18, 312, 313, 250, 251, 11, 253, 25, 0, 193,
2161 194, 195, 196, 197, 11, 30, 200, 47, 136, 136,
2162 236, 237, 140, 15, 16, 17, 70, 19, 20, 16,
2163 147, 61, 19, 48, 26, 27, 297, 202, 533, 286,
2164 52, 136, 48, 3, 4, 5, 6, 294, 295, 93,
2165 145, 48, 547, 97, 46, 136, 136, 49, 136, 103,
2166 135, 53, 22, 23, 84, 145, 147, 112, 113, 147,
2167 136, 115, 37, 38, 39, 40, 41, 42, 43, 482,
2168 45, 147, 135, 127, 128, 130, 131, 131, 399, 30,
2169 136, 135, 15, 248, 136, 250, 251, 143, 253, 136,
2170 137, 143, 139, 36, 37, 352, 353, 354, 324, 153,
2171 43, 28, 29, 360, 517, 299, 49, 16, 135, 146,
2172 19, 143, 143, 370, 371, 112, 113, 146, 344, 147,
2173 146, 286, 176, 177, 178, 179, 137, 136, 139, 294,
2174 295, 140, 143, 130, 131, 548, 33, 0, 192, 193,
2175 194, 195, 196, 197, 198, 199, 200, 108, 137, 455,
2176 139, 457, 108, 109, 208, 412, 145, 414, 483, 134,
2177 417, 112, 113, 104, 105, 136, 423, 424, 362, 140,
2178 364, 365, 366, 134, 3, 4, 5, 6, 129, 130,
2179 131, 132, 137, 41, 139, 43, 141, 352, 353, 354,
2180 137, 135, 139, 450, 451, 360, 453, 454, 136, 137,
2181 254, 139, 459, 135, 17, 370, 371, 20, 19, 447,
2182 467, 265, 537, 141, 539, 112, 113, 37, 38, 39,
2183 32, 389, 42, 137, 389, 139, 140, 134, 282, 18,
2184 487, 19, 129, 130, 131, 132, 112, 113, 11, 496,
2185 19, 14, 19, 297, 298, 299, 139, 412, 4, 414,
2186 76, 77, 417, 129, 130, 131, 132, 4, 423, 424,
2187 142, 142, 4, 136, 458, 22, 23, 461, 462, 463,
2188 324, 19, 140, 145, 531, 140, 9, 9, 9, 536,
2189 334, 519, 50, 11, 522, 450, 451, 139, 453, 454,
2190 145, 139, 139, 139, 459, 139, 553, 554, 19, 139,
2191 139, 558, 467, 139, 561, 136, 139, 33, 362, 363,
2192 364, 365, 366, 136, 136, 369, 55, 56, 57, 58,
2193 59, 60, 487, 139, 139, 54, 136, 136, 136, 136,
2194 136, 496, 136, 516, 91, 92, 93, 94, 95, 96,
2195 97, 98, 99, 100, 101, 102, 103, 104, 141, 136,
2196 136, 534, 136, 136, 136, 316, 317, 318, 319, 320,
2197 136, 136, 136, 33, 0, 145, 531, 136, 329, 330,
2198 331, 536, 19, 4, 428, 136, 140, 19, 136, 15,
2199 16, 17, 14, 19, 20, 14, 139, 441, 553, 554,
2200 26, 27, 446, 558, 4, 136, 561, 140, 452, 136,
2201 136, 136, 136, 19, 458, 145, 136, 461, 462, 463,
2202 46, 48, 466, 49, 139, 445, 136, 53, 379, 380,
2203 136, 136, 136, 136, 136, 386, 136, 136, 48, 140,
2204 136, 14, 140, 7, 8, 140, 10, 11, 12, 13,
2205 14, 141, 16, 17, 143, 19, 20, 7, 8, 140,
2206 10, 11, 12, 13, 14, 143, 16, 17, 140, 19,
2207 20, 140, 140, 4, 518, 136, 14, 14, 136, 14,
2208 44, 432, 433, 434, 435, 66, 14, 118, 439, 440,
2209 118, 511, 3, 4, 44, 118, 7, 8, 9, 84,
2210 228, 511, 483, 97, 103, 16, 17, 15, 19, 20,
2211 21, 22, 23, 81, 208, 229, 52, 468, 469, 466,
2212 381, -1, -1, -1, 35, 36, 85, 86, 87, 88,
2213 89, 90, 91, 92, 93, 94, -1, -1, -1, 7,
2214 8, 52, 10, 11, 12, 13, 14, -1, 16, 17,
2215 -1, 19, 20, 504, -1, 506, 507, 68, 69, 70,
2216 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2217 81, 82, 83, 84, 138, -1, 44, 141, -1, -1,
2218 144, -1, 146, 147, -1, -1, -1, -1, 138, -1,
2219 -1, 141, -1, -1, 144, -1, 146, 147, -1, 110,
2220 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
2221 121, 122, -1, 124, -1, 126, 127, 128, 3, 4,
2222 -1, -1, 7, 8, 9, -1, 137, -1, 139, -1,
2223 -1, 16, 17, 144, 19, 20, 21, 22, 23, -1,
2224 -1, -1, -1, 7, 8, -1, -1, -1, -1, -1,
2225 35, 36, 16, 17, -1, 19, 20, 21, -1, -1,
2226 -1, -1, -1, -1, -1, -1, -1, 52, -1, -1,
2227 138, 35, 36, 141, -1, -1, 144, -1, 146, 147,
2228 -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
2229 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
2230 -1, -1, -1, -1, 68, 69, 70, 71, 72, 73,
2231 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
2232 84, -1, -1, -1, -1, 110, 111, 112, 113, 114,
2233 115, 116, 117, 118, 119, 120, 121, 122, -1, 124,
2234 -1, 126, 127, 128, -1, -1, 110, 111, 112, 113,
2235 114, 115, 116, 117, 118, 119, 120, 121, 122, 144,
2236 124, -1, 126, 127, 128, -1, -1, -1, 3, 4,
2237 -1, -1, -1, 137, 9, 139, -1, 141, -1, -1,
2238 144, -1, 146, -1, 148, -1, 21, 22, 23, -1,
2239 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2240 35, 36, -1, -1, -1, -1, -1, -1, -1, -1,
2241 -1, -1, -1, -1, -1, 7, 8, 52, 10, 11,
2242 12, 13, 14, -1, 16, 17, -1, 19, 20, -1,
2243 -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
2244 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
2245 -1, -1, 44, -1, -1, -1, -1, -1, -1, -1,
2246 -1, 7, 8, -1, 10, 11, 12, 13, 14, -1,
2247 16, 17, -1, 19, 20, 110, 111, 112, 113, 114,
2248 115, 116, 117, 118, 119, 120, 121, 122, 34, 124,
2249 -1, 126, 127, 128, -1, -1, -1, -1, 44, -1,
2250 -1, 7, 8, -1, 10, 11, 12, 13, 14, 144,
2251 16, 17, -1, 19, 20, -1, -1, -1, -1, -1,
2252 7, 8, -1, 10, 11, 12, 13, 14, 34, 16,
2253 17, -1, 19, 20, -1, -1, -1, -1, 44, -1,
2254 -1, -1, -1, -1, -1, -1, 138, -1, -1, 141,
2255 -1, -1, 144, -1, 146, 147, -1, 44, -1, 7,
2256 8, -1, 10, 11, 12, 13, 14, -1, 16, 17,
2257 -1, 19, 20, -1, -1, 7, 8, -1, 10, 11,
2258 12, 13, 14, -1, 16, 17, 34, 19, 20, -1,
2259 -1, -1, 138, -1, -1, 141, 44, -1, 144, -1,
2260 146, -1, 34, -1, 7, 8, -1, 10, 11, 12,
2261 13, 14, 44, 16, 17, -1, 19, 20, 7, 8,
2262 -1, 10, 11, 12, 13, 14, -1, 16, 17, -1,
2263 19, 20, 138, -1, -1, 141, -1, -1, 144, -1,
2264 146, 44, -1, -1, -1, -1, -1, -1, -1, -1,
2265 -1, 138, -1, -1, 141, 44, 143, 144, -1, 146,
2266 7, 8, -1, 10, 11, 12, 13, 14, -1, 16,
2267 17, -1, 19, 20, 7, 8, -1, 10, 11, 12,
2268 13, 14, -1, 16, 17, -1, 19, 20, -1, -1,
2269 138, -1, -1, 141, -1, -1, 144, 44, 146, -1,
2270 -1, -1, -1, -1, -1, -1, 138, -1, -1, 141,
2271 -1, 44, 144, -1, 146, -1, 7, 8, -1, 10,
2272 11, 12, 13, 14, -1, 16, 17, -1, 19, 20,
2273 -1, -1, -1, -1, -1, 138, -1, -1, 141, -1,
2274 -1, 144, -1, 146, -1, -1, -1, -1, -1, 138,
2275 -1, -1, 141, 44, -1, 144, -1, 146, 7, 8,
2276 -1, 10, 11, 12, 13, 14, -1, 16, 17, -1,
2277 19, 20, -1, -1, -1, -1, -1, -1, -1, -1,
2278 -1, -1, -1, 31, -1, -1, -1, -1, -1, -1,
2279 -1, 138, -1, -1, 141, 44, -1, 144, -1, 146,
2280 -1, -1, 50, 51, -1, 138, -1, -1, 141, -1,
2281 -1, 144, -1, 146, 62, 63, 64, 65, 66, 67,
2282 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
2283 78, 79, 80, 81, 82, 83, 84, -1, -1, -1,
2284 -1, -1, -1, -1, -1, -1, -1, 138, -1, -1,
2285 141, -1, -1, 144, -1, 146, -1, 105, 106, 107,
2286 -1, -1, 110, 111, 112, 113, 114, 115, 116, 117,
2287 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
2288 128, -1, -1, -1, -1, -1, -1, -1, -1, 138,
2289 -1, -1, 141, -1, -1, 144, -1, 146
2290 };
2291
2292 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
2293 symbol of state STATE-NUM. */
2294 static const unsigned char yystos[] =
2295 {
2296 0, 16, 17, 19, 20, 26, 27, 46, 49, 53,
2297 157, 159, 160, 161, 190, 191, 192, 194, 193, 47,
2298 61, 199, 135, 52, 135, 15, 135, 37, 38, 39,
2299 40, 41, 42, 43, 45, 134, 162, 163, 164, 0,
2300 192, 41, 43, 165, 209, 37, 38, 39, 42, 166,
2301 206, 208, 215, 135, 135, 141, 200, 19, 198, 7,
2302 8, 10, 11, 12, 13, 14, 44, 138, 141, 144,
2303 146, 157, 160, 178, 179, 212, 164, 164, 32, 189,
2304 164, 164, 18, 216, 217, 25, 147, 207, 216, 19,
2305 19, 19, 201, 139, 4, 4, 4, 146, 10, 147,
2306 179, 184, 137, 139, 189, 189, 28, 29, 188, 55,
2307 56, 57, 58, 59, 60, 167, 204, 204, 159, 220,
2308 136, 143, 34, 179, 180, 182, 183, 142, 142, 147,
2309 184, 136, 147, 183, 188, 188, 11, 12, 13, 155,
2310 156, 179, 185, 4, 10, 179, 181, 24, 146, 205,
2311 31, 50, 51, 62, 63, 64, 65, 66, 67, 68,
2312 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2313 79, 80, 81, 82, 83, 84, 105, 106, 107, 110,
2314 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
2315 121, 122, 123, 124, 125, 126, 127, 128, 150, 151,
2316 152, 218, 224, 225, 226, 227, 19, 169, 136, 140,
2317 179, 179, 145, 147, 179, 140, 185, 179, 22, 23,
2318 3, 4, 5, 6, 9, 21, 35, 36, 83, 84,
2319 110, 124, 126, 127, 128, 141, 144, 146, 148, 150,
2320 151, 152, 186, 212, 195, 160, 50, 10, 179, 214,
2321 11, 14, 11, 155, 167, 85, 86, 87, 88, 89,
2322 90, 91, 92, 93, 94, 153, 22, 23, 91, 92,
2323 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
2324 103, 104, 154, 179, 179, 214, 179, 179, 221, 214,
2325 214, 214, 214, 214, 179, 179, 214, 167, 108, 109,
2326 112, 113, 130, 131, 168, 34, 180, 171, 143, 145,
2327 145, 171, 196, 197, 153, 154, 139, 139, 139, 139,
2328 139, 143, 185, 187, 146, 187, 147, 187, 19, 139,
2329 139, 139, 136, 176, 139, 3, 4, 9, 21, 22,
2330 23, 35, 36, 52, 144, 186, 211, 212, 213, 213,
2331 213, 213, 181, 179, 179, 136, 173, 136, 173, 213,
2332 141, 136, 136, 136, 136, 136, 136, 213, 213, 33,
2333 181, 179, 214, 129, 132, 168, 170, 176, 176, 139,
2334 139, 185, 185, 185, 185, 185, 136, 143, 147, 179,
2335 187, 145, 147, 185, 185, 185, 30, 48, 174, 177,
2336 34, 179, 202, 203, 54, 210, 187, 136, 136, 213,
2337 213, 213, 11, 48, 11, 223, 213, 141, 214, 179,
2338 214, 214, 214, 136, 136, 179, 213, 213, 136, 185,
2339 185, 223, 136, 136, 136, 136, 185, 145, 147, 136,
2340 136, 33, 19, 4, 176, 169, 136, 140, 19, 145,
2341 14, 14, 139, 136, 136, 213, 4, 213, 136, 136,
2342 213, 136, 136, 136, 213, 213, 139, 179, 136, 136,
2343 140, 185, 185, 185, 185, 145, 185, 185, 179, 157,
2344 158, 34, 179, 171, 136, 213, 213, 179, 222, 213,
2345 213, 136, 173, 173, 214, 213, 136, 214, 214, 214,
2346 222, 213, 185, 185, 136, 140, 136, 136, 140, 140,
2347 140, 169, 174, 175, 19, 136, 141, 213, 136, 140,
2348 143, 213, 140, 140, 140, 185, 185, 185, 158, 48,
2349 172, 14, 143, 155, 219, 169, 179, 171, 143, 171,
2350 140, 140, 140, 4, 213, 211, 143, 155, 213, 33,
2351 136, 211, 169, 14, 14, 136, 213, 213, 14, 66,
2352 213, 14, 213
2353 };
1962 #define YYSTACK_ALLOC malloc
1963 #endif
1964
1965 /* Note: there must be only one dollar sign in this file.
1966 It is replaced by the list of actions, each action
1967 as one case of the switch. */
23541968
23551969 #define yyerrok (yyerrstatus = 0)
23561970 #define yyclearin (yychar = YYEMPTY)
2357 #define YYEMPTY (-2)
1971 #define YYEMPTY -2
23581972 #define YYEOF 0
2359
23601973 #define YYACCEPT goto yyacceptlab
2361 #define YYABORT goto yyabortlab
2362 #define YYERROR goto yyerrorlab
2363
2364
2365 /* Like YYERROR except do call yyerror. This remains here temporarily
2366 to ease the transition to the new meaning of YYERROR, for GCC.
1974 #define YYABORT goto yyabortlab
1975 #define YYERROR goto yyerrlab1
1976 /* Like YYERROR except do call yyerror.
1977 This remains here temporarily to ease the
1978 transition to the new meaning of YYERROR, for GCC.
23671979 Once GCC version 2 has supplanted version 1, this can go. */
2368
23691980 #define YYFAIL goto yyerrlab
2370
23711981 #define YYRECOVERING() (!!yyerrstatus)
2372
2373 #define YYBACKUP(Token, Value) \
1982 #define YYBACKUP(token, value) \
23741983 do \
23751984 if (yychar == YYEMPTY && yylen == 1) \
2376 { \
2377 yychar = (Token); \
2378 yylval = (Value); \
2379 yytoken = YYTRANSLATE (yychar); \
1985 { yychar = (token), yylval = (value); \
1986 yychar1 = YYTRANSLATE (yychar); \
23801987 YYPOPSTACK; \
23811988 goto yybackup; \
23821989 } \
23831990 else \
2384 { \
2385 yyerror (YY_("syntax error: cannot back up")); \
2386 YYERROR; \
2387 } \
1991 { yyerror ("syntax error: cannot back up"); YYERROR; } \
23881992 while (0)
2389
23901993
23911994 #define YYTERROR 1
23921995 #define YYERRCODE 256
23931996
2394
2395 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
2396 If N is 0, then set CURRENT to the empty location which ends
2397 the previous symbol: RHS[0] (always defined). */
2398
2399 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
2400 #ifndef YYLLOC_DEFAULT
2401 # define YYLLOC_DEFAULT(Current, Rhs, N) \
2402 do \
2403 if (N) \
2404 { \
2405 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
2406 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
2407 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
2408 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
2409 } \
2410 else \
2411 { \
2412 (Current).first_line = (Current).last_line = \
2413 YYRHSLOC (Rhs, 0).last_line; \
2414 (Current).first_column = (Current).last_column = \
2415 YYRHSLOC (Rhs, 0).last_column; \
2416 } \
2417 while (0)
2418 #endif
2419
2420
2421 /* YY_LOCATION_PRINT -- Print the location on the stream.
2422 This macro was not mandated originally: define only if we know
2423 we won't break user code: when these are the locations we know. */
2424
2425 #ifndef YY_LOCATION_PRINT
2426 # if YYLTYPE_IS_TRIVIAL
2427 # define YY_LOCATION_PRINT(File, Loc) \
2428 fprintf (File, "%d.%d-%d.%d", \
2429 (Loc).first_line, (Loc).first_column, \
2430 (Loc).last_line, (Loc).last_column)
2431 # else
2432 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
2433 # endif
2434 #endif
2435
2436
2437 /* YYLEX -- calling `yylex' with the right arguments. */
2438
1997 #ifndef YYPURE
1998 #define YYLEX yylex()
1999 #endif
2000
2001 #ifdef YYPURE
2002 #ifdef YYLSP_NEEDED
24392003 #ifdef YYLEX_PARAM
2440 # define YYLEX yylex (YYLEX_PARAM)
2004 #define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
24412005 #else
2442 # define YYLEX yylex ()
2443 #endif
2444
2445 /* Enable debugging if requested. */
2446 #if YYDEBUG
2447
2448 # ifndef YYFPRINTF
2449 # include /* INFRINGES ON USER NAME SPACE */
2450 # define YYFPRINTF fprintf
2451 # endif
2452
2453 # define YYDPRINTF(Args) \
2454 do { \
2455 if (yydebug) \
2456 YYFPRINTF Args; \
2457 } while (0)
2458
2459 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
2460 do { \
2461 if (yydebug) \
2462 { \
2463 YYFPRINTF (stderr, "%s ", Title); \
2464 yysymprint (stderr, \
2465 Type, Value); \
2466 YYFPRINTF (stderr, "\n"); \
2467 } \
2468 } while (0)
2469
2470 /*------------------------------------------------------------------.
2471 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
2472 | TOP (included). |
2473 `------------------------------------------------------------------*/
2474
2475 #if defined (__STDC__) || defined (__cplusplus)
2006 #define YYLEX yylex(&yylval, &yylloc)
2007 #endif
2008 #else /* not YYLSP_NEEDED */
2009 #ifdef YYLEX_PARAM
2010 #define YYLEX yylex(&yylval, YYLEX_PARAM)
2011 #else
2012 #define YYLEX yylex(&yylval)
2013 #endif
2014 #endif /* not YYLSP_NEEDED */
2015 #endif
2016
2017 /* If nonreentrant, generate the variables here */
2018
2019 #ifndef YYPURE
2020
2021 int yychar; /* the lookahead symbol */
2022 YYSTYPE yylval; /* the semantic value of the */
2023 /* lookahead symbol */
2024
2025 #ifdef YYLSP_NEEDED
2026 YYLTYPE yylloc; /* location data for the lookahead */
2027 /* symbol */
2028 #endif
2029
2030 int yynerrs; /* number of parse errors so far */
2031 #endif /* not YYPURE */
2032
2033 #if YYDEBUG != 0
2034 int yydebug; /* nonzero means print parse trace */
2035 /* Since this is uninitialized, it does not stop multiple parsers
2036 from coexisting. */
2037 #endif
2038
2039 /* YYINITDEPTH indicates the initial size of the parser's stacks */
2040
2041 #ifndef YYINITDEPTH
2042 #define YYINITDEPTH 200
2043 #endif
2044
2045 /* YYMAXDEPTH is the maximum size the stacks can grow to
2046 (effective only if the built-in stack extension method is used). */
2047
2048 #if YYMAXDEPTH == 0
2049 #undef YYMAXDEPTH
2050 #endif
2051
2052 #ifndef YYMAXDEPTH
2053 #define YYMAXDEPTH 10000
2054 #endif
2055
2056 /* Define __yy_memcpy. Note that the size argument
2057 should be passed with type unsigned int, because that is what the non-GCC
2058 definitions require. With GCC, __builtin_memcpy takes an arg
2059 of type size_t, but it can handle unsigned int. */
2060
2061 #if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
2062 #define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
2063 #else /* not GNU C or C++ */
2064 #ifndef __cplusplus
2065
2066 /* This is the most reliable way to avoid incompatibilities
2067 in available built-in functions on various systems. */
24762068 static void
2477 yy_stack_print (short int *bottom, short int *top)
2069 __yy_memcpy (to, from, count)
2070 char *to;
2071 char *from;
2072 unsigned int count;
2073 {
2074 register char *f = from;
2075 register char *t = to;
2076 register int i = count;
2077
2078 while (i-- > 0)
2079 *t++ = *f++;
2080 }
2081
2082 #else /* __cplusplus */
2083
2084 /* This is the most reliable way to avoid incompatibilities
2085 in available built-in functions on various systems. */
2086 static void
2087 __yy_memcpy (char *to, char *from, unsigned int count)
2088 {
2089 register char *t = to;
2090 register char *f = from;
2091 register int i = count;
2092
2093 while (i-- > 0)
2094 *t++ = *f++;
2095 }
2096
2097 #endif
2098 #endif
2099
2100 #line 217 "/usr/share/bison.simple"
2101
2102 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
2103 into yyparse. The argument should have type void *.
2104 It should actually point to an object.
2105 Grammar actions can access the variable by casting it
2106 to the proper pointer type. */
2107
2108 #ifdef YYPARSE_PARAM
2109 #ifdef __cplusplus
2110 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
2111 #define YYPARSE_PARAM_DECL
2112 #else /* not __cplusplus */
2113 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
2114 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
2115 #endif /* not __cplusplus */
2116 #else /* not YYPARSE_PARAM */
2117 #define YYPARSE_PARAM_ARG
2118 #define YYPARSE_PARAM_DECL
2119 #endif /* not YYPARSE_PARAM */
2120
2121 /* Prevent warning if -Wstrict-prototypes. */
2122 #ifdef __GNUC__
2123 #ifdef YYPARSE_PARAM
2124 int yyparse (void *);
24782125 #else
2479 static void
2480 yy_stack_print (bottom, top)
2481 short int *bottom;
2482 short int *top;
2483 #endif
2484 {
2485 YYFPRINTF (stderr, "Stack now");
2486 for (/* Nothing. */; bottom <= top; ++bottom)
2487 YYFPRINTF (stderr, " %d", *bottom);
2488 YYFPRINTF (stderr, "\n");
2489 }
2490
2491 # define YY_STACK_PRINT(Bottom, Top) \
2492 do { \
2493 if (yydebug) \
2494 yy_stack_print ((Bottom), (Top)); \
2495 } while (0)
2496
2497
2498 /*------------------------------------------------.
2499 | Report that the YYRULE is going to be reduced. |
2500 `------------------------------------------------*/
2501
2502 #if defined (__STDC__) || defined (__cplusplus)
2503 static void
2504 yy_reduce_print (int yyrule)
2126 int yyparse (void);
2127 #endif
2128 #endif
2129
2130 int
2131 yyparse(YYPARSE_PARAM_ARG)
2132 YYPARSE_PARAM_DECL
2133 {
2134 register int yystate;
2135 register int yyn;
2136 register short *yyssp;
2137 register YYSTYPE *yyvsp;
2138 int yyerrstatus; /* number of tokens to shift before error messages enabled */
2139 int yychar1 = 0; /* lookahead token as an internal (translated) token number */
2140
2141 short yyssa[YYINITDEPTH]; /* the state stack */
2142 YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
2143
2144 short *yyss = yyssa; /* refer to the stacks thru separate pointers */
2145 YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
2146
2147 #ifdef YYLSP_NEEDED
2148 YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
2149 YYLTYPE *yyls = yylsa;
2150 YYLTYPE *yylsp;
2151
2152 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
25052153 #else
2506 static void
2507 yy_reduce_print (yyrule)
2508 int yyrule;
2509 #endif
2510 {
2511 int yyi;
2512 unsigned long int yylno = yyrline[yyrule];
2513 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
2514 yyrule - 1, yylno);
2515 /* Print the symbols being reduced, and their result. */
2516 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
2517 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
2518 YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
2519 }
2520
2521 # define YY_REDUCE_PRINT(Rule) \
2522 do { \
2523 if (yydebug) \
2524 yy_reduce_print (Rule); \
2525 } while (0)
2526
2527 /* Nonzero means print parse trace. It is left uninitialized so that
2528 multiple parsers can coexist. */
2529 int yydebug;
2530 #else /* !YYDEBUG */
2531 # define YYDPRINTF(Args)
2532 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
2533 # define YY_STACK_PRINT(Bottom, Top)
2534 # define YY_REDUCE_PRINT(Rule)
2535 #endif /* !YYDEBUG */
2536
2537
2538 /* YYINITDEPTH -- initial size of the parser's stacks. */
2539 #ifndef YYINITDEPTH
2540 # define YYINITDEPTH 200
2541 #endif
2542
2543 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
2544 if the built-in stack extension method is used).
2545
2546 Do not make this value too large; the results are undefined if
2547 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
2548 evaluated with infinite-precision integer arithmetic. */
2549
2550 #ifndef YYMAXDEPTH
2551 # define YYMAXDEPTH 10000
2552 #endif
2553
2554
2555
2556 #if YYERROR_VERBOSE
2557
2558 # ifndef yystrlen
2559 # if defined (__GLIBC__) && defined (_STRING_H)
2560 # define yystrlen strlen
2561 # else
2562 /* Return the length of YYSTR. */
2563 static YYSIZE_T
2564 # if defined (__STDC__) || defined (__cplusplus)
2565 yystrlen (const char *yystr)
2566 # else
2567 yystrlen (yystr)
2568 const char *yystr;
2569 # endif
2570 {
2571 const char *yys = yystr;
2572
2573 while (*yys++ != '\0')
2574 continue;
2575
2576 return yys - yystr - 1;
2577 }
2578 # endif
2579 # endif
2580
2581 # ifndef yystpcpy
2582 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
2583 # define yystpcpy stpcpy
2584 # else
2585 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
2586 YYDEST. */
2587 static char *
2588 # if defined (__STDC__) || defined (__cplusplus)
2589 yystpcpy (char *yydest, const char *yysrc)
2590 # else
2591 yystpcpy (yydest, yysrc)
2592 char *yydest;
2593 const char *yysrc;
2594 # endif
2595 {
2596 char *yyd = yydest;
2597 const char *yys = yysrc;
2598
2599 while ((*yyd++ = *yys++) != '\0')
2600 continue;
2601
2602 return yyd - 1;
2603 }
2604 # endif
2605 # endif
2606
2607 # ifndef yytnamerr
2608 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
2609 quotes and backslashes, so that it's suitable for yyerror. The
2610 heuristic is that double-quoting is unnecessary unless the string
2611 contains an apostrophe, a comma, or backslash (other than
2612 backslash-backslash). YYSTR is taken from yytname. If YYRES is
2613 null, do not copy; instead, return the length of what the result
2614 would have been. */
2615 static YYSIZE_T
2616 yytnamerr (char *yyres, const char *yystr)
2617 {
2618 if (*yystr == '"')
2619 {
2620 size_t yyn = 0;
2621 char const *yyp = yystr;
2622
2623 for (;;)
2624 switch (*++yyp)
2625 {
2626 case '\'':
2627 case ',':
2628 goto do_not_strip_quotes;
2629
2630 case '\\':
2631 if (*++yyp != '\\')
2632 goto do_not_strip_quotes;
2633 /* Fall through. */
2634 default:
2635 if (yyres)
2636 yyres[yyn] = *yyp;
2637 yyn++;
2638 break;
2639
2640 case '"':
2641 if (yyres)
2642 yyres[yyn] = '\0';
2643 return yyn;
2644 }
2645 do_not_strip_quotes: ;
2646 }
2647
2648 if (! yyres)
2649 return yystrlen (yystr);
2650
2651 return yystpcpy (yyres, yystr) - yyres;
2652 }
2653 # endif
2654
2655 #endif /* YYERROR_VERBOSE */
2656
2657
2658
2659 #if YYDEBUG
2660 /*--------------------------------.
2661 | Print this symbol on YYOUTPUT. |
2662 `--------------------------------*/
2663
2664 #if defined (__STDC__) || defined (__cplusplus)
2665 static void
2666 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
2667 #else
2668 static void
2669 yysymprint (yyoutput, yytype, yyvaluep)
2670 FILE *yyoutput;
2671 int yytype;
2672 YYSTYPE *yyvaluep;
2673 #endif
2674 {
2675 /* Pacify ``unused variable'' warnings. */
2676 (void) yyvaluep;
2677
2678 if (yytype < YYNTOKENS)
2679 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
2680 else
2681 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
2682
2683
2684 # ifdef YYPRINT
2685 if (yytype < YYNTOKENS)
2686 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
2687 # endif
2688 switch (yytype)
2689 {
2690 default:
2691 break;
2692 }
2693 YYFPRINTF (yyoutput, ")");
2694 }
2695
2696 #endif /* ! YYDEBUG */
2697 /*-----------------------------------------------.
2698 | Release the memory associated to this symbol. |
2699 `-----------------------------------------------*/
2700
2701 #if defined (__STDC__) || defined (__cplusplus)
2702 static void
2703 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
2704 #else
2705 static void
2706 yydestruct (yymsg, yytype, yyvaluep)
2707 const char *yymsg;
2708 int yytype;
2709 YYSTYPE *yyvaluep;
2710 #endif
2711 {
2712 /* Pacify ``unused variable'' warnings. */
2713 (void) yyvaluep;
2714
2715 if (!yymsg)
2716 yymsg = "Deleting";
2717 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2718
2719 switch (yytype)
2720 {
2721
2722 default:
2723 break;
2724 }
2725 }
2726
2727
2728 /* Prevent warnings from -Wmissing-prototypes. */
2729
2730 #ifdef YYPARSE_PARAM
2731 # if defined (__STDC__) || defined (__cplusplus)
2732 int yyparse (void *YYPARSE_PARAM);
2733 # else
2734 int yyparse ();
2735 # endif
2736 #else /* ! YYPARSE_PARAM */
2737 #if defined (__STDC__) || defined (__cplusplus)
2738 int yyparse (void);
2739 #else
2740 int yyparse ();
2741 #endif
2742 #endif /* ! YYPARSE_PARAM */
2743
2744
2745
2746 /* The look-ahead symbol. */
2747 int yychar;
2748
2749 /* The semantic value of the look-ahead symbol. */
2750 YYSTYPE yylval;
2751
2752 /* Number of syntax errors so far. */
2753 int yynerrs;
2754
2755
2756
2757 /*----------.
2758 | yyparse. |
2759 `----------*/
2760
2761 #ifdef YYPARSE_PARAM
2762 # if defined (__STDC__) || defined (__cplusplus)
2763 int yyparse (void *YYPARSE_PARAM)
2764 # else
2765 int yyparse (YYPARSE_PARAM)
2766 void *YYPARSE_PARAM;
2767 # endif
2768 #else /* ! YYPARSE_PARAM */
2769 #if defined (__STDC__) || defined (__cplusplus)
2770 int
2771 yyparse (void)
2772 #else
2773 int
2774 yyparse ()
2775
2776 #endif
2777 #endif
2778 {
2779
2780 int yystate;
2781 int yyn;
2782 int yyresult;
2783 /* Number of tokens to shift before error messages enabled. */
2784 int yyerrstatus;
2785 /* Look-ahead token as an internal (translated) token number. */
2786 int yytoken = 0;
2787
2788 /* Three stacks and their tools:
2789 `yyss': related to states,
2790 `yyvs': related to semantic values,
2791 `yyls': related to locations.
2792
2793 Refer to the stacks thru separate pointers, to allow yyoverflow
2794 to reallocate them elsewhere. */
2795
2796 /* The state stack. */
2797 short int yyssa[YYINITDEPTH];
2798 short int *yyss = yyssa;
2799 short int *yyssp;
2800
2801 /* The semantic value stack. */
2802 YYSTYPE yyvsa[YYINITDEPTH];
2803 YYSTYPE *yyvs = yyvsa;
2804 YYSTYPE *yyvsp;
2805
2806
2807
28082154 #define YYPOPSTACK (yyvsp--, yyssp--)
2809
2810 YYSIZE_T yystacksize = YYINITDEPTH;
2811
2812 /* The variables used to return semantic value and location from the
2813 action routines. */
2814 YYSTYPE yyval;
2815
2816
2817 /* When reducing, the number of symbols on the RHS of the reduced
2818 rule. */
2155 #endif
2156
2157 int yystacksize = YYINITDEPTH;
2158 int yyfree_stacks = 0;
2159
2160 #ifdef YYPURE
2161 int yychar;
2162 YYSTYPE yylval;
2163 int yynerrs;
2164 #ifdef YYLSP_NEEDED
2165 YYLTYPE yylloc;
2166 #endif
2167 #endif
2168
2169 YYSTYPE yyval; /* the variable used to return */
2170 /* semantic values from the action */
2171 /* routines */
2172
28192173 int yylen;
28202174
2821 YYDPRINTF ((stderr, "Starting parse\n"));
2175 #if YYDEBUG != 0
2176 if (yydebug)
2177 fprintf(stderr, "Starting parse\n");
2178 #endif
28222179
28232180 yystate = 0;
28242181 yyerrstatus = 0;
28302187 so that they stay on the same level as the state stack.
28312188 The wasted elements are never initialized. */
28322189
2833 yyssp = yyss;
2190 yyssp = yyss - 1;
28342191 yyvsp = yyvs;
2835
2836 goto yysetstate;
2837
2838 /*------------------------------------------------------------.
2839 | yynewstate -- Push a new state, which is found in yystate. |
2840 `------------------------------------------------------------*/
2841 yynewstate:
2842 /* In all cases, when you get here, the value and location stacks
2843 have just been pushed. so pushing a state here evens the stacks.
2844 */
2845 yyssp++;
2846
2847 yysetstate:
2848 *yyssp = yystate;
2849
2850 if (yyss + yystacksize - 1 <= yyssp)
2192 #ifdef YYLSP_NEEDED
2193 yylsp = yyls;
2194 #endif
2195
2196 /* Push a new state, which is found in yystate . */
2197 /* In all cases, when you get here, the value and location stacks
2198 have just been pushed. so pushing a state here evens the stacks. */
2199 yynewstate:
2200
2201 *++yyssp = yystate;
2202
2203 if (yyssp >= yyss + yystacksize - 1)
28512204 {
2205 /* Give user a chance to reallocate the stack */
2206 /* Use copies of these so that the &'s don't force the real ones into memory. */
2207 YYSTYPE *yyvs1 = yyvs;
2208 short *yyss1 = yyss;
2209 #ifdef YYLSP_NEEDED
2210 YYLTYPE *yyls1 = yyls;
2211 #endif
2212
28522213 /* Get the current used size of the three stacks, in elements. */
2853 YYSIZE_T yysize = yyssp - yyss + 1;
2214 int size = yyssp - yyss + 1;
28542215
28552216 #ifdef yyoverflow
2856 {
2857 /* Give user a chance to reallocate the stack. Use copies of
2858 these so that the &'s don't force the real ones into
2859 memory. */
2860 YYSTYPE *yyvs1 = yyvs;
2861 short int *yyss1 = yyss;
2862
2863
2864 /* Each stack pointer address is followed by the size of the
2865 data in use in that stack, in bytes. This used to be a
2866 conditional around just the two extra args, but that might
2867 be undefined if yyoverflow is a macro. */
2868 yyoverflow (YY_("memory exhausted"),
2869 &yyss1, yysize * sizeof (*yyssp),
2870 &yyvs1, yysize * sizeof (*yyvsp),
2871
2872 &yystacksize);
2873
2874 yyss = yyss1;
2875 yyvs = yyvs1;
2876 }
2217 /* Each stack pointer address is followed by the size of
2218 the data in use in that stack, in bytes. */
2219 #ifdef YYLSP_NEEDED
2220 /* This used to be a conditional around just the two extra args,
2221 but that might be undefined if yyoverflow is a macro. */
2222 yyoverflow("parser stack overflow",
2223 &yyss1, size * sizeof (*yyssp),
2224 &yyvs1, size * sizeof (*yyvsp),
2225 &yyls1, size * sizeof (*yylsp),
2226 &yystacksize);
2227 #else
2228 yyoverflow("parser stack overflow",
2229 &yyss1, size * sizeof (*yyssp),
2230 &yyvs1, size * sizeof (*yyvsp),
2231 &yystacksize);
2232 #endif
2233
2234 yyss = yyss1; yyvs = yyvs1;
2235 #ifdef YYLSP_NEEDED
2236 yyls = yyls1;
2237 #endif
28772238 #else /* no yyoverflow */
2878 # ifndef YYSTACK_RELOCATE
2879 goto yyexhaustedlab;
2880 # else
28812239 /* Extend the stack our own way. */
2882 if (YYMAXDEPTH <= yystacksize)
2883 goto yyexhaustedlab;
2240 if (yystacksize >= YYMAXDEPTH)
2241 {
2242 yyerror("parser stack overflow");
2243 if (yyfree_stacks)
2244 {
2245 free (yyss);
2246 free (yyvs);
2247 #ifdef YYLSP_NEEDED
2248 free (yyls);
2249 #endif
2250 }
2251 return 2;
2252 }
28842253 yystacksize *= 2;
2885 if (YYMAXDEPTH < yystacksize)
2254 if (yystacksize > YYMAXDEPTH)
28862255 yystacksize = YYMAXDEPTH;
2887
2888 {
2889 short int *yyss1 = yyss;
2890 union yyalloc *yyptr =
2891 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2892 if (! yyptr)
2893 goto yyexhaustedlab;
2894 YYSTACK_RELOCATE (yyss);
2895 YYSTACK_RELOCATE (yyvs);
2896
2897 # undef YYSTACK_RELOCATE
2898 if (yyss1 != yyssa)
2899 YYSTACK_FREE (yyss1);
2900 }
2901 # endif
2256 #ifndef YYSTACK_USE_ALLOCA
2257 yyfree_stacks = 1;
2258 #endif
2259 yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
2260 __yy_memcpy ((char *)yyss, (char *)yyss1,
2261 size * (unsigned int) sizeof (*yyssp));
2262 yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
2263 __yy_memcpy ((char *)yyvs, (char *)yyvs1,
2264 size * (unsigned int) sizeof (*yyvsp));
2265 #ifdef YYLSP_NEEDED
2266 yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
2267 __yy_memcpy ((char *)yyls, (char *)yyls1,
2268 size * (unsigned int) sizeof (*yylsp));
2269 #endif
29022270 #endif /* no yyoverflow */
29032271
2904 yyssp = yyss + yysize - 1;
2905 yyvsp = yyvs + yysize - 1;
2906
2907
2908 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2909 (unsigned long int) yystacksize));
2910
2911 if (yyss + yystacksize - 1 <= yyssp)
2272 yyssp = yyss + size - 1;
2273 yyvsp = yyvs + size - 1;
2274 #ifdef YYLSP_NEEDED
2275 yylsp = yyls + size - 1;
2276 #endif
2277
2278 #if YYDEBUG != 0
2279 if (yydebug)
2280 fprintf(stderr, "Stack size increased to %d\n", yystacksize);
2281 #endif
2282
2283 if (yyssp >= yyss + yystacksize - 1)
29122284 YYABORT;
29132285 }
29142286
2915 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2287