diff options
Diffstat (limited to 'contrib/gnunet-tree-builder')
-rw-r--r-- | contrib/gnunet-tree-builder/GNUnetParser.java | 5616 | ||||
-rwxr-xr-x | contrib/gnunet-tree-builder/gtb | 6 | ||||
-rwxr-xr-x | contrib/gnunet-tree-builder/regenerate | 20 |
3 files changed, 0 insertions, 5642 deletions
diff --git a/contrib/gnunet-tree-builder/GNUnetParser.java b/contrib/gnunet-tree-builder/GNUnetParser.java deleted file mode 100644 index d1b204c7d..000000000 --- a/contrib/gnunet-tree-builder/GNUnetParser.java +++ /dev/null | |||
@@ -1,5616 +0,0 @@ | |||
1 | package org.gnunet.monkey.parser; | ||
2 | /* Generated By:JavaCC: Do not edit this line. CParser.java */ | ||
3 | import java.io.File; | ||
4 | import java.io.FileFilter; | ||
5 | import java.io.FileInputStream; | ||
6 | import java.io.FileNotFoundException; | ||
7 | import org.gnunet.monkey.parser.nodes.*; | ||
8 | |||
9 | public class GNUnetParser implements CParserConstants { | ||
10 | private static final boolean DEBUG = false; | ||
11 | |||
12 | public static void main(String args[]) | ||
13 | { | ||
14 | GNUnetParser parser = null; | ||
15 | boolean isFirstFile = true; | ||
16 | int fileNotFoundCount = 0; | ||
17 | int successCount = 0; | ||
18 | int failureCount = 0; | ||
19 | System.out.println("C Parser Version 0.1Alpha: Reading from GNUnet source directory . . ."); | ||
20 | String gnunetSourcePath = System.getenv("MAINDIR") + "/src"; | ||
21 | |||
22 | /* Filtering out files */ | ||
23 | FileFilter filter = new FileFilter() { | ||
24 | public boolean accept(File file) { | ||
25 | return file.isDirectory(); | ||
26 | } | ||
27 | }; | ||
28 | |||
29 | /* File filter to get only source and header files */ | ||
30 | FileFilter sourceFilter = new FileFilter() { | ||
31 | public boolean accept(File file) { | ||
32 | String fileName = file.getName(); | ||
33 | return (fileName.endsWith(".c") || fileName.endsWith(".h")); | ||
34 | } | ||
35 | }; | ||
36 | |||
37 | File[] dirArr = (new File(gnunetSourcePath)).listFiles(filter); | ||
38 | for (int i = 0; i < dirArr.length; i++) { | ||
39 | File dir = dirArr[i]; | ||
40 | File[] fileArr = dir.listFiles(sourceFilter); | ||
41 | for (int j = 0; j < fileArr.length; j++) { | ||
42 | try { | ||
43 | if (isFirstFile) { | ||
44 | parser = new GNUnetParser(new FileInputStream(fileArr[j].getPath())); | ||
45 | isFirstFile = false; | ||
46 | } | ||
47 | else | ||
48 | parser.ReInit(new FileInputStream(fileArr[j].getPath())); | ||
49 | } | ||
50 | catch (FileNotFoundException e) { | ||
51 | fileNotFoundCount++; | ||
52 | e.printStackTrace(); | ||
53 | } | ||
54 | try { | ||
55 | parser.TranslationUnit(); | ||
56 | System.out.println("File " + fileArr[j].getName() + " parsed successfully."); | ||
57 | successCount++; | ||
58 | } | ||
59 | catch (ParseException e) { | ||
60 | System.out.println("Encountered errors during parsing file " + fileArr[j].getName()); | ||
61 | failureCount++; | ||
62 | if (DEBUG) | ||
63 | e.printStackTrace(); | ||
64 | } | ||
65 | } | ||
66 | } | ||
67 | System.out.println(successCount + " parsed successfully."); | ||
68 | System.out.println("Failed to parse " + failureCount + " files."); | ||
69 | System.out.println(fileNotFoundCount + " files not found."); | ||
70 | } | ||
71 | |||
72 | final public TranslationUnit TranslationUnit() throws ParseException { | ||
73 | NodeList n0 = new NodeList(); | ||
74 | ExternalDeclaration n1; | ||
75 | label_1: | ||
76 | while (true) { | ||
77 | n1 = ExternalDeclaration(); | ||
78 | n0.addNode(n1); | ||
79 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
80 | case REGISTER: | ||
81 | case UNSIGNED: | ||
82 | case TYPEDEF: | ||
83 | case DOUBLE: | ||
84 | case EXTERN: | ||
85 | case STRUCT: | ||
86 | case STATIC: | ||
87 | case SIGNED: | ||
88 | case UNION: | ||
89 | case CONST: | ||
90 | case FLOAT: | ||
91 | case SHORT: | ||
92 | case LONG: | ||
93 | case ENUM: | ||
94 | case AUTO: | ||
95 | case VOID: | ||
96 | case CHAR: | ||
97 | case INT: | ||
98 | case IDENTIFIER: | ||
99 | ; | ||
100 | break; | ||
101 | default: | ||
102 | jj_la1[0] = jj_gen; | ||
103 | break label_1; | ||
104 | } | ||
105 | } | ||
106 | n0.nodes.trimToSize(); | ||
107 | {if (true) return new TranslationUnit(n0);} | ||
108 | throw new Error("Missing return statement in function"); | ||
109 | } | ||
110 | |||
111 | final public ExternalDeclaration ExternalDeclaration() throws ParseException { | ||
112 | NodeListOptional n0 = new NodeListOptional(); | ||
113 | StorageClassSpecifier n1; | ||
114 | NodeChoice n2; | ||
115 | FunctionDeclaration n3; | ||
116 | StructOrUnionSpecifier n4; | ||
117 | VariableDeclaration n5; | ||
118 | TypeDeclaration n6; | ||
119 | label_2: | ||
120 | while (true) { | ||
121 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
122 | case EXTERN: | ||
123 | case STATIC: | ||
124 | ; | ||
125 | break; | ||
126 | default: | ||
127 | jj_la1[1] = jj_gen; | ||
128 | break label_2; | ||
129 | } | ||
130 | n1 = StorageClassSpecifier(); | ||
131 | n0.addNode(n1); | ||
132 | } | ||
133 | n0.nodes.trimToSize(); | ||
134 | if (jj_2_1(2147483647)) { | ||
135 | n3 = FunctionDeclaration(); | ||
136 | n2 = new NodeChoice(n3, 0); | ||
137 | } else if (jj_2_2(2147483647)) { | ||
138 | n4 = StructOrUnionSpecifier(); | ||
139 | n2 = new NodeChoice(n4, 1); | ||
140 | } else if (jj_2_3(2147483647)) { | ||
141 | n5 = VariableDeclaration(); | ||
142 | n2 = new NodeChoice(n5, 2); | ||
143 | } else if (jj_2_4(2147483647)) { | ||
144 | n6 = TypeDeclaration(); | ||
145 | n2 = new NodeChoice(n6, 3); | ||
146 | } else { | ||
147 | jj_consume_token(-1); | ||
148 | throw new ParseException(); | ||
149 | } | ||
150 | {if (true) return new ExternalDeclaration(n0,n2);} | ||
151 | throw new Error("Missing return statement in function"); | ||
152 | } | ||
153 | |||
154 | final public FunctionDeclaration FunctionDeclaration() throws ParseException { | ||
155 | TypeSpecifier n0; | ||
156 | NodeToken n1; | ||
157 | Token n2; | ||
158 | NodeToken n3; | ||
159 | Token n4; | ||
160 | NodeOptional n5 = new NodeOptional(); | ||
161 | ParameterList n6; | ||
162 | NodeToken n7; | ||
163 | Token n8; | ||
164 | NodeChoice n9; | ||
165 | NodeToken n10; | ||
166 | Token n11; | ||
167 | CompoundStatement n12; | ||
168 | n0 = TypeSpecifier(); | ||
169 | n2 = jj_consume_token(IDENTIFIER); | ||
170 | n1 = JTBToolkit.makeNodeToken(n2); | ||
171 | n4 = jj_consume_token(55); | ||
172 | n3 = JTBToolkit.makeNodeToken(n4); | ||
173 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
174 | case UNSIGNED: | ||
175 | case DOUBLE: | ||
176 | case STRUCT: | ||
177 | case SIGNED: | ||
178 | case UNION: | ||
179 | case CONST: | ||
180 | case FLOAT: | ||
181 | case SHORT: | ||
182 | case LONG: | ||
183 | case ENUM: | ||
184 | case VOID: | ||
185 | case CHAR: | ||
186 | case INT: | ||
187 | case IDENTIFIER: | ||
188 | n6 = ParameterList(); | ||
189 | n5.addNode(n6); | ||
190 | break; | ||
191 | default: | ||
192 | jj_la1[2] = jj_gen; | ||
193 | ; | ||
194 | } | ||
195 | n8 = jj_consume_token(56); | ||
196 | n7 = JTBToolkit.makeNodeToken(n8); | ||
197 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
198 | case 57: | ||
199 | n11 = jj_consume_token(57); | ||
200 | n10 = JTBToolkit.makeNodeToken(n11); | ||
201 | n9 = new NodeChoice(n10, 0); | ||
202 | break; | ||
203 | case 61: | ||
204 | n12 = CompoundStatement(); | ||
205 | n9 = new NodeChoice(n12, 1); | ||
206 | break; | ||
207 | default: | ||
208 | jj_la1[3] = jj_gen; | ||
209 | jj_consume_token(-1); | ||
210 | throw new ParseException(); | ||
211 | } | ||
212 | {if (true) return new FunctionDeclaration(n0,n1,n3,n5,n7,n9);} | ||
213 | throw new Error("Missing return statement in function"); | ||
214 | } | ||
215 | |||
216 | final public StorageClassSpecifier StorageClassSpecifier() throws ParseException { | ||
217 | NodeChoice n0; | ||
218 | NodeToken n1; | ||
219 | Token n2; | ||
220 | NodeToken n3; | ||
221 | Token n4; | ||
222 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
223 | case STATIC: | ||
224 | n2 = jj_consume_token(STATIC); | ||
225 | n1 = JTBToolkit.makeNodeToken(n2); | ||
226 | n0 = new NodeChoice(n1, 0); | ||
227 | break; | ||
228 | case EXTERN: | ||
229 | n4 = jj_consume_token(EXTERN); | ||
230 | n3 = JTBToolkit.makeNodeToken(n4); | ||
231 | n0 = new NodeChoice(n3, 1); | ||
232 | break; | ||
233 | default: | ||
234 | jj_la1[4] = jj_gen; | ||
235 | jj_consume_token(-1); | ||
236 | throw new ParseException(); | ||
237 | } | ||
238 | {if (true) return new StorageClassSpecifier(n0);} | ||
239 | throw new Error("Missing return statement in function"); | ||
240 | } | ||
241 | |||
242 | final public TypeDeclaration TypeDeclaration() throws ParseException { | ||
243 | NodeToken n0; | ||
244 | Token n1; | ||
245 | NodeChoice n2; | ||
246 | DataType n3; | ||
247 | FunctionType n4; | ||
248 | NodeToken n5; | ||
249 | Token n6; | ||
250 | n1 = jj_consume_token(TYPEDEF); | ||
251 | n0 = JTBToolkit.makeNodeToken(n1); | ||
252 | if (jj_2_5(2147483647)) { | ||
253 | n3 = DataType(); | ||
254 | n2 = new NodeChoice(n3, 0); | ||
255 | } else { | ||
256 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
257 | case UNSIGNED: | ||
258 | case DOUBLE: | ||
259 | case STRUCT: | ||
260 | case SIGNED: | ||
261 | case UNION: | ||
262 | case CONST: | ||
263 | case FLOAT: | ||
264 | case SHORT: | ||
265 | case LONG: | ||
266 | case ENUM: | ||
267 | case VOID: | ||
268 | case CHAR: | ||
269 | case INT: | ||
270 | case IDENTIFIER: | ||
271 | n4 = FunctionType(); | ||
272 | n2 = new NodeChoice(n4, 1); | ||
273 | break; | ||
274 | default: | ||
275 | jj_la1[5] = jj_gen; | ||
276 | jj_consume_token(-1); | ||
277 | throw new ParseException(); | ||
278 | } | ||
279 | } | ||
280 | n6 = jj_consume_token(57); | ||
281 | n5 = JTBToolkit.makeNodeToken(n6); | ||
282 | {if (true) return new TypeDeclaration(n0,n2,n5);} | ||
283 | throw new Error("Missing return statement in function"); | ||
284 | } | ||
285 | |||
286 | final public DataType DataType() throws ParseException { | ||
287 | StructOrUnionSpecifier n0; | ||
288 | NodeToken n1; | ||
289 | Token n2; | ||
290 | n0 = StructOrUnionSpecifier(); | ||
291 | n2 = jj_consume_token(IDENTIFIER); | ||
292 | n1 = JTBToolkit.makeNodeToken(n2); | ||
293 | {if (true) return new DataType(n0,n1);} | ||
294 | throw new Error("Missing return statement in function"); | ||
295 | } | ||
296 | |||
297 | final public FunctionType FunctionType() throws ParseException { | ||
298 | TypeSpecifier n0; | ||
299 | NodeToken n1; | ||
300 | Token n2; | ||
301 | NodeToken n3; | ||
302 | Token n4; | ||
303 | NodeToken n5; | ||
304 | Token n6; | ||
305 | NodeToken n7; | ||
306 | Token n8; | ||
307 | NodeToken n9; | ||
308 | Token n10; | ||
309 | NodeOptional n11 = new NodeOptional(); | ||
310 | ParameterList n12; | ||
311 | NodeToken n13; | ||
312 | Token n14; | ||
313 | n0 = TypeSpecifier(); | ||
314 | n2 = jj_consume_token(55); | ||
315 | n1 = JTBToolkit.makeNodeToken(n2); | ||
316 | n4 = jj_consume_token(58); | ||
317 | n3 = JTBToolkit.makeNodeToken(n4); | ||
318 | n6 = jj_consume_token(IDENTIFIER); | ||
319 | n5 = JTBToolkit.makeNodeToken(n6); | ||
320 | n8 = jj_consume_token(56); | ||
321 | n7 = JTBToolkit.makeNodeToken(n8); | ||
322 | n10 = jj_consume_token(55); | ||
323 | n9 = JTBToolkit.makeNodeToken(n10); | ||
324 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
325 | case UNSIGNED: | ||
326 | case DOUBLE: | ||
327 | case STRUCT: | ||
328 | case SIGNED: | ||
329 | case UNION: | ||
330 | case CONST: | ||
331 | case FLOAT: | ||
332 | case SHORT: | ||
333 | case LONG: | ||
334 | case ENUM: | ||
335 | case VOID: | ||
336 | case CHAR: | ||
337 | case INT: | ||
338 | case IDENTIFIER: | ||
339 | n12 = ParameterList(); | ||
340 | n11.addNode(n12); | ||
341 | break; | ||
342 | default: | ||
343 | jj_la1[6] = jj_gen; | ||
344 | ; | ||
345 | } | ||
346 | n14 = jj_consume_token(56); | ||
347 | n13 = JTBToolkit.makeNodeToken(n14); | ||
348 | {if (true) return new FunctionType(n0,n1,n3,n5,n7,n9,n11,n13);} | ||
349 | throw new Error("Missing return statement in function"); | ||
350 | } | ||
351 | |||
352 | final public ParameterList ParameterList() throws ParseException { | ||
353 | ParameterDeclaration n0; | ||
354 | NodeListOptional n1 = new NodeListOptional(); | ||
355 | NodeSequence n2; | ||
356 | NodeToken n3; | ||
357 | Token n4; | ||
358 | ParameterDeclaration n5; | ||
359 | NodeOptional n6 = new NodeOptional(); | ||
360 | NodeSequence n7; | ||
361 | NodeToken n8; | ||
362 | Token n9; | ||
363 | NodeToken n10; | ||
364 | Token n11; | ||
365 | n0 = ParameterDeclaration(); | ||
366 | label_3: | ||
367 | while (true) { | ||
368 | if (jj_2_6(2)) { | ||
369 | ; | ||
370 | } else { | ||
371 | break label_3; | ||
372 | } | ||
373 | n2 = new NodeSequence(2); | ||
374 | n4 = jj_consume_token(59); | ||
375 | n3 = JTBToolkit.makeNodeToken(n4); | ||
376 | n2.addNode(n3); | ||
377 | n5 = ParameterDeclaration(); | ||
378 | n2.addNode(n5); | ||
379 | n1.addNode(n2); | ||
380 | } | ||
381 | n1.nodes.trimToSize(); | ||
382 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
383 | case 59: | ||
384 | n7 = new NodeSequence(2); | ||
385 | n9 = jj_consume_token(59); | ||
386 | n8 = JTBToolkit.makeNodeToken(n9); | ||
387 | n7.addNode(n8); | ||
388 | n11 = jj_consume_token(60); | ||
389 | n10 = JTBToolkit.makeNodeToken(n11); | ||
390 | n7.addNode(n10); | ||
391 | n6.addNode(n7); | ||
392 | break; | ||
393 | default: | ||
394 | jj_la1[7] = jj_gen; | ||
395 | ; | ||
396 | } | ||
397 | {if (true) return new ParameterList(n0,n1,n6);} | ||
398 | throw new Error("Missing return statement in function"); | ||
399 | } | ||
400 | |||
401 | final public ParameterDeclaration ParameterDeclaration() throws ParseException { | ||
402 | TypeSpecifier n0; | ||
403 | NodeToken n1; | ||
404 | Token n2; | ||
405 | NodeOptional n3 = new NodeOptional(); | ||
406 | Array n4; | ||
407 | n0 = TypeSpecifier(); | ||
408 | n2 = jj_consume_token(IDENTIFIER); | ||
409 | n1 = JTBToolkit.makeNodeToken(n2); | ||
410 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
411 | case 65: | ||
412 | n4 = Array(); | ||
413 | n3.addNode(n4); | ||
414 | break; | ||
415 | default: | ||
416 | jj_la1[8] = jj_gen; | ||
417 | ; | ||
418 | } | ||
419 | {if (true) return new ParameterDeclaration(n0,n1,n3);} | ||
420 | throw new Error("Missing return statement in function"); | ||
421 | } | ||
422 | |||
423 | final public VariableDeclaration VariableDeclaration() throws ParseException { | ||
424 | VariableClassSpecifier n0; | ||
425 | TypeSpecifier n1; | ||
426 | InitDeclaratorList n2; | ||
427 | NodeToken n3; | ||
428 | Token n4; | ||
429 | n0 = VariableClassSpecifier(); | ||
430 | n1 = TypeSpecifier(); | ||
431 | n2 = InitDeclaratorList(); | ||
432 | n4 = jj_consume_token(57); | ||
433 | n3 = JTBToolkit.makeNodeToken(n4); | ||
434 | {if (true) return new VariableDeclaration(n0,n1,n2,n3);} | ||
435 | throw new Error("Missing return statement in function"); | ||
436 | } | ||
437 | |||
438 | final public LocalVariableDeclaration LocalVariableDeclaration() throws ParseException { | ||
439 | NodeOptional n0 = new NodeOptional(); | ||
440 | NodeToken n1; | ||
441 | Token n2; | ||
442 | VariableDeclaration n3; | ||
443 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
444 | case STATIC: | ||
445 | n2 = jj_consume_token(STATIC); | ||
446 | n1 = JTBToolkit.makeNodeToken(n2); | ||
447 | n0.addNode(n1); | ||
448 | break; | ||
449 | default: | ||
450 | jj_la1[9] = jj_gen; | ||
451 | ; | ||
452 | } | ||
453 | n3 = VariableDeclaration(); | ||
454 | {if (true) return new LocalVariableDeclaration(n0,n3);} | ||
455 | throw new Error("Missing return statement in function"); | ||
456 | } | ||
457 | |||
458 | final public VariableClassSpecifier VariableClassSpecifier() throws ParseException { | ||
459 | NodeListOptional n0 = new NodeListOptional(); | ||
460 | NodeChoice n1; | ||
461 | NodeToken n2; | ||
462 | Token n3; | ||
463 | NodeToken n4; | ||
464 | Token n5; | ||
465 | label_4: | ||
466 | while (true) { | ||
467 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
468 | case REGISTER: | ||
469 | case AUTO: | ||
470 | ; | ||
471 | break; | ||
472 | default: | ||
473 | jj_la1[10] = jj_gen; | ||
474 | break label_4; | ||
475 | } | ||
476 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
477 | case AUTO: | ||
478 | n3 = jj_consume_token(AUTO); | ||
479 | n2 = JTBToolkit.makeNodeToken(n3); | ||
480 | n1 = new NodeChoice(n2, 0); | ||
481 | break; | ||
482 | case REGISTER: | ||
483 | n5 = jj_consume_token(REGISTER); | ||
484 | n4 = JTBToolkit.makeNodeToken(n5); | ||
485 | n1 = new NodeChoice(n4, 1); | ||
486 | break; | ||
487 | default: | ||
488 | jj_la1[11] = jj_gen; | ||
489 | jj_consume_token(-1); | ||
490 | throw new ParseException(); | ||
491 | } | ||
492 | n0.addNode(n1); | ||
493 | } | ||
494 | n0.nodes.trimToSize(); | ||
495 | {if (true) return new VariableClassSpecifier(n0);} | ||
496 | throw new Error("Missing return statement in function"); | ||
497 | } | ||
498 | |||
499 | final public TypeSpecifier TypeSpecifier() throws ParseException { | ||
500 | NodeOptional n0 = new NodeOptional(); | ||
501 | NodeToken n1; | ||
502 | Token n2; | ||
503 | NodeChoice n3; | ||
504 | NodeToken n4; | ||
505 | Token n5; | ||
506 | NodeToken n6; | ||
507 | Token n7; | ||
508 | NodeSequence n8; | ||
509 | NodeToken n9; | ||
510 | Token n10; | ||
511 | NodeOptional n11 = new NodeOptional(); | ||
512 | NodeToken n12; | ||
513 | Token n13; | ||
514 | NodeToken n14; | ||
515 | Token n15; | ||
516 | NodeSequence n16; | ||
517 | NodeToken n17; | ||
518 | Token n18; | ||
519 | NodeOptional n19 = new NodeOptional(); | ||
520 | NodeToken n20; | ||
521 | Token n21; | ||
522 | NodeToken n22; | ||
523 | Token n23; | ||
524 | NodeToken n24; | ||
525 | Token n25; | ||
526 | NodeSequence n26; | ||
527 | NodeChoice n27; | ||
528 | NodeToken n28; | ||
529 | Token n29; | ||
530 | NodeToken n30; | ||
531 | Token n31; | ||
532 | NodeOptional n32 = new NodeOptional(); | ||
533 | NodeChoice n33; | ||
534 | NodeToken n34; | ||
535 | Token n35; | ||
536 | NodeSequence n36; | ||
537 | NodeToken n37; | ||
538 | Token n38; | ||
539 | NodeOptional n39; | ||
540 | NodeToken n40; | ||
541 | Token n41; | ||
542 | NodeToken n42; | ||
543 | Token n43; | ||
544 | NodeSequence n44; | ||
545 | NodeToken n45; | ||
546 | Token n46; | ||
547 | NodeOptional n47; | ||
548 | NodeToken n48; | ||
549 | Token n49; | ||
550 | StructOrUnionSpecifier n50; | ||
551 | EnumSpecifier n51; | ||
552 | NodeToken n52; | ||
553 | Token n53; | ||
554 | NodeOptional n54 = new NodeOptional(); | ||
555 | Pointer n55; | ||
556 | NodeOptional n56 = new NodeOptional(); | ||
557 | Array n57; | ||
558 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
559 | case CONST: | ||
560 | n2 = jj_consume_token(CONST); | ||
561 | n1 = JTBToolkit.makeNodeToken(n2); | ||
562 | n0.addNode(n1); | ||
563 | break; | ||
564 | default: | ||
565 | jj_la1[12] = jj_gen; | ||
566 | ; | ||
567 | } | ||
568 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
569 | case VOID: | ||
570 | n5 = jj_consume_token(VOID); | ||
571 | n4 = JTBToolkit.makeNodeToken(n5); | ||
572 | n3 = new NodeChoice(n4, 0); | ||
573 | break; | ||
574 | case CHAR: | ||
575 | n7 = jj_consume_token(CHAR); | ||
576 | n6 = JTBToolkit.makeNodeToken(n7); | ||
577 | n3 = new NodeChoice(n6, 1); | ||
578 | break; | ||
579 | case SHORT: | ||
580 | n8 = new NodeSequence(2); | ||
581 | n10 = jj_consume_token(SHORT); | ||
582 | n9 = JTBToolkit.makeNodeToken(n10); | ||
583 | n8.addNode(n9); | ||
584 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
585 | case INT: | ||
586 | n13 = jj_consume_token(INT); | ||
587 | n12 = JTBToolkit.makeNodeToken(n13); | ||
588 | n11.addNode(n12); | ||
589 | break; | ||
590 | default: | ||
591 | jj_la1[13] = jj_gen; | ||
592 | ; | ||
593 | } | ||
594 | n8.addNode(n11); | ||
595 | n3 = new NodeChoice(n8, 2); | ||
596 | break; | ||
597 | case INT: | ||
598 | n15 = jj_consume_token(INT); | ||
599 | n14 = JTBToolkit.makeNodeToken(n15); | ||
600 | n3 = new NodeChoice(n14, 3); | ||
601 | break; | ||
602 | case LONG: | ||
603 | n16 = new NodeSequence(2); | ||
604 | n18 = jj_consume_token(LONG); | ||
605 | n17 = JTBToolkit.makeNodeToken(n18); | ||
606 | n16.addNode(n17); | ||
607 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
608 | case LONG: | ||
609 | n21 = jj_consume_token(LONG); | ||
610 | n20 = JTBToolkit.makeNodeToken(n21); | ||
611 | n19.addNode(n20); | ||
612 | break; | ||
613 | default: | ||
614 | jj_la1[14] = jj_gen; | ||
615 | ; | ||
616 | } | ||
617 | n16.addNode(n19); | ||
618 | n3 = new NodeChoice(n16, 4); | ||
619 | break; | ||
620 | case FLOAT: | ||
621 | n23 = jj_consume_token(FLOAT); | ||
622 | n22 = JTBToolkit.makeNodeToken(n23); | ||
623 | n3 = new NodeChoice(n22, 5); | ||
624 | break; | ||
625 | case DOUBLE: | ||
626 | n25 = jj_consume_token(DOUBLE); | ||
627 | n24 = JTBToolkit.makeNodeToken(n25); | ||
628 | n3 = new NodeChoice(n24, 6); | ||
629 | break; | ||
630 | case UNSIGNED: | ||
631 | case SIGNED: | ||
632 | n26 = new NodeSequence(2); | ||
633 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
634 | case SIGNED: | ||
635 | n29 = jj_consume_token(SIGNED); | ||
636 | n28 = JTBToolkit.makeNodeToken(n29); | ||
637 | n27 = new NodeChoice(n28, 0); | ||
638 | break; | ||
639 | case UNSIGNED: | ||
640 | n31 = jj_consume_token(UNSIGNED); | ||
641 | n30 = JTBToolkit.makeNodeToken(n31); | ||
642 | n27 = new NodeChoice(n30, 1); | ||
643 | break; | ||
644 | default: | ||
645 | jj_la1[15] = jj_gen; | ||
646 | jj_consume_token(-1); | ||
647 | throw new ParseException(); | ||
648 | } | ||
649 | n26.addNode(n27); | ||
650 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
651 | case SHORT: | ||
652 | case LONG: | ||
653 | case CHAR: | ||
654 | case INT: | ||
655 | n39 = new NodeOptional(); | ||
656 | n47 = new NodeOptional(); | ||
657 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
658 | case CHAR: | ||
659 | n35 = jj_consume_token(CHAR); | ||
660 | n34 = JTBToolkit.makeNodeToken(n35); | ||
661 | n33 = new NodeChoice(n34, 0); | ||
662 | break; | ||
663 | case SHORT: | ||
664 | n36 = new NodeSequence(2); | ||
665 | n38 = jj_consume_token(SHORT); | ||
666 | n37 = JTBToolkit.makeNodeToken(n38); | ||
667 | n36.addNode(n37); | ||
668 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
669 | case INT: | ||
670 | n41 = jj_consume_token(INT); | ||
671 | n40 = JTBToolkit.makeNodeToken(n41); | ||
672 | n39.addNode(n40); | ||
673 | break; | ||
674 | default: | ||
675 | jj_la1[16] = jj_gen; | ||
676 | ; | ||
677 | } | ||
678 | n36.addNode(n39); | ||
679 | n33 = new NodeChoice(n36, 1); | ||
680 | break; | ||
681 | case INT: | ||
682 | n43 = jj_consume_token(INT); | ||
683 | n42 = JTBToolkit.makeNodeToken(n43); | ||
684 | n33 = new NodeChoice(n42, 2); | ||
685 | break; | ||
686 | case LONG: | ||
687 | n44 = new NodeSequence(2); | ||
688 | n46 = jj_consume_token(LONG); | ||
689 | n45 = JTBToolkit.makeNodeToken(n46); | ||
690 | n44.addNode(n45); | ||
691 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
692 | case LONG: | ||
693 | n49 = jj_consume_token(LONG); | ||
694 | n48 = JTBToolkit.makeNodeToken(n49); | ||
695 | n47.addNode(n48); | ||
696 | break; | ||
697 | default: | ||
698 | jj_la1[17] = jj_gen; | ||
699 | ; | ||
700 | } | ||
701 | n44.addNode(n47); | ||
702 | n33 = new NodeChoice(n44, 3); | ||
703 | break; | ||
704 | default: | ||
705 | jj_la1[18] = jj_gen; | ||
706 | jj_consume_token(-1); | ||
707 | throw new ParseException(); | ||
708 | } | ||
709 | n32.addNode(n33); | ||
710 | break; | ||
711 | default: | ||
712 | jj_la1[19] = jj_gen; | ||
713 | ; | ||
714 | } | ||
715 | n26.addNode(n32); | ||
716 | n3 = new NodeChoice(n26, 7); | ||
717 | break; | ||
718 | case STRUCT: | ||
719 | case UNION: | ||
720 | n50 = StructOrUnionSpecifier(); | ||
721 | n3 = new NodeChoice(n50, 8); | ||
722 | break; | ||
723 | case ENUM: | ||
724 | n51 = EnumSpecifier(); | ||
725 | n3 = new NodeChoice(n51, 9); | ||
726 | break; | ||
727 | case IDENTIFIER: | ||
728 | n53 = jj_consume_token(IDENTIFIER); | ||
729 | n52 = JTBToolkit.makeNodeToken(n53); | ||
730 | n3 = new NodeChoice(n52, 10); | ||
731 | break; | ||
732 | default: | ||
733 | jj_la1[20] = jj_gen; | ||
734 | jj_consume_token(-1); | ||
735 | throw new ParseException(); | ||
736 | } | ||
737 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
738 | case 58: | ||
739 | n55 = Pointer(); | ||
740 | n54.addNode(n55); | ||
741 | break; | ||
742 | default: | ||
743 | jj_la1[21] = jj_gen; | ||
744 | ; | ||
745 | } | ||
746 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
747 | case 65: | ||
748 | n57 = Array(); | ||
749 | n56.addNode(n57); | ||
750 | break; | ||
751 | default: | ||
752 | jj_la1[22] = jj_gen; | ||
753 | ; | ||
754 | } | ||
755 | {if (true) return new TypeSpecifier(n0,n3,n54,n56);} | ||
756 | throw new Error("Missing return statement in function"); | ||
757 | } | ||
758 | |||
759 | final public NoIdentifierTypeSpecifier NoIdentifierTypeSpecifier() throws ParseException { | ||
760 | NodeOptional n0 = new NodeOptional(); | ||
761 | NodeToken n1; | ||
762 | Token n2; | ||
763 | NodeChoice n3; | ||
764 | NodeToken n4; | ||
765 | Token n5; | ||
766 | NodeToken n6; | ||
767 | Token n7; | ||
768 | NodeSequence n8; | ||
769 | NodeToken n9; | ||
770 | Token n10; | ||
771 | NodeOptional n11 = new NodeOptional(); | ||
772 | NodeToken n12; | ||
773 | Token n13; | ||
774 | NodeToken n14; | ||
775 | Token n15; | ||
776 | NodeSequence n16; | ||
777 | NodeToken n17; | ||
778 | Token n18; | ||
779 | NodeOptional n19 = new NodeOptional(); | ||
780 | NodeToken n20; | ||
781 | Token n21; | ||
782 | NodeToken n22; | ||
783 | Token n23; | ||
784 | NodeToken n24; | ||
785 | Token n25; | ||
786 | NodeSequence n26; | ||
787 | NodeChoice n27; | ||
788 | NodeToken n28; | ||
789 | Token n29; | ||
790 | NodeToken n30; | ||
791 | Token n31; | ||
792 | NodeOptional n32 = new NodeOptional(); | ||
793 | NodeChoice n33; | ||
794 | NodeToken n34; | ||
795 | Token n35; | ||
796 | NodeSequence n36; | ||
797 | NodeToken n37; | ||
798 | Token n38; | ||
799 | NodeOptional n39; | ||
800 | NodeToken n40; | ||
801 | Token n41; | ||
802 | NodeToken n42; | ||
803 | Token n43; | ||
804 | NodeSequence n44; | ||
805 | NodeToken n45; | ||
806 | Token n46; | ||
807 | NodeOptional n47; | ||
808 | NodeToken n48; | ||
809 | Token n49; | ||
810 | StructOrUnionSpecifier n50; | ||
811 | EnumSpecifier n51; | ||
812 | NodeOptional n52 = new NodeOptional(); | ||
813 | Pointer n53; | ||
814 | NodeOptional n54 = new NodeOptional(); | ||
815 | Array n55; | ||
816 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
817 | case CONST: | ||
818 | n2 = jj_consume_token(CONST); | ||
819 | n1 = JTBToolkit.makeNodeToken(n2); | ||
820 | n0.addNode(n1); | ||
821 | break; | ||
822 | default: | ||
823 | jj_la1[23] = jj_gen; | ||
824 | ; | ||
825 | } | ||
826 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
827 | case VOID: | ||
828 | n5 = jj_consume_token(VOID); | ||
829 | n4 = JTBToolkit.makeNodeToken(n5); | ||
830 | n3 = new NodeChoice(n4, 0); | ||
831 | break; | ||
832 | case CHAR: | ||
833 | n7 = jj_consume_token(CHAR); | ||
834 | n6 = JTBToolkit.makeNodeToken(n7); | ||
835 | n3 = new NodeChoice(n6, 1); | ||
836 | break; | ||
837 | case SHORT: | ||
838 | n8 = new NodeSequence(2); | ||
839 | n10 = jj_consume_token(SHORT); | ||
840 | n9 = JTBToolkit.makeNodeToken(n10); | ||
841 | n8.addNode(n9); | ||
842 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
843 | case INT: | ||
844 | n13 = jj_consume_token(INT); | ||
845 | n12 = JTBToolkit.makeNodeToken(n13); | ||
846 | n11.addNode(n12); | ||
847 | break; | ||
848 | default: | ||
849 | jj_la1[24] = jj_gen; | ||
850 | ; | ||
851 | } | ||
852 | n8.addNode(n11); | ||
853 | n3 = new NodeChoice(n8, 2); | ||
854 | break; | ||
855 | case INT: | ||
856 | n15 = jj_consume_token(INT); | ||
857 | n14 = JTBToolkit.makeNodeToken(n15); | ||
858 | n3 = new NodeChoice(n14, 3); | ||
859 | break; | ||
860 | case LONG: | ||
861 | n16 = new NodeSequence(2); | ||
862 | n18 = jj_consume_token(LONG); | ||
863 | n17 = JTBToolkit.makeNodeToken(n18); | ||
864 | n16.addNode(n17); | ||
865 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
866 | case LONG: | ||
867 | n21 = jj_consume_token(LONG); | ||
868 | n20 = JTBToolkit.makeNodeToken(n21); | ||
869 | n19.addNode(n20); | ||
870 | break; | ||
871 | default: | ||
872 | jj_la1[25] = jj_gen; | ||
873 | ; | ||
874 | } | ||
875 | n16.addNode(n19); | ||
876 | n3 = new NodeChoice(n16, 4); | ||
877 | break; | ||
878 | case FLOAT: | ||
879 | n23 = jj_consume_token(FLOAT); | ||
880 | n22 = JTBToolkit.makeNodeToken(n23); | ||
881 | n3 = new NodeChoice(n22, 5); | ||
882 | break; | ||
883 | case DOUBLE: | ||
884 | n25 = jj_consume_token(DOUBLE); | ||
885 | n24 = JTBToolkit.makeNodeToken(n25); | ||
886 | n3 = new NodeChoice(n24, 6); | ||
887 | break; | ||
888 | case UNSIGNED: | ||
889 | case SIGNED: | ||
890 | n26 = new NodeSequence(2); | ||
891 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
892 | case SIGNED: | ||
893 | n29 = jj_consume_token(SIGNED); | ||
894 | n28 = JTBToolkit.makeNodeToken(n29); | ||
895 | n27 = new NodeChoice(n28, 0); | ||
896 | break; | ||
897 | case UNSIGNED: | ||
898 | n31 = jj_consume_token(UNSIGNED); | ||
899 | n30 = JTBToolkit.makeNodeToken(n31); | ||
900 | n27 = new NodeChoice(n30, 1); | ||
901 | break; | ||
902 | default: | ||
903 | jj_la1[26] = jj_gen; | ||
904 | jj_consume_token(-1); | ||
905 | throw new ParseException(); | ||
906 | } | ||
907 | n26.addNode(n27); | ||
908 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
909 | case SHORT: | ||
910 | case LONG: | ||
911 | case CHAR: | ||
912 | case INT: | ||
913 | n39 = new NodeOptional(); | ||
914 | n47 = new NodeOptional(); | ||
915 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
916 | case CHAR: | ||
917 | n35 = jj_consume_token(CHAR); | ||
918 | n34 = JTBToolkit.makeNodeToken(n35); | ||
919 | n33 = new NodeChoice(n34, 0); | ||
920 | break; | ||
921 | case SHORT: | ||
922 | n36 = new NodeSequence(2); | ||
923 | n38 = jj_consume_token(SHORT); | ||
924 | n37 = JTBToolkit.makeNodeToken(n38); | ||
925 | n36.addNode(n37); | ||
926 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
927 | case INT: | ||
928 | n41 = jj_consume_token(INT); | ||
929 | n40 = JTBToolkit.makeNodeToken(n41); | ||
930 | n39.addNode(n40); | ||
931 | break; | ||
932 | default: | ||
933 | jj_la1[27] = jj_gen; | ||
934 | ; | ||
935 | } | ||
936 | n36.addNode(n39); | ||
937 | n33 = new NodeChoice(n36, 1); | ||
938 | break; | ||
939 | case INT: | ||
940 | n43 = jj_consume_token(INT); | ||
941 | n42 = JTBToolkit.makeNodeToken(n43); | ||
942 | n33 = new NodeChoice(n42, 2); | ||
943 | break; | ||
944 | case LONG: | ||
945 | n44 = new NodeSequence(2); | ||
946 | n46 = jj_consume_token(LONG); | ||
947 | n45 = JTBToolkit.makeNodeToken(n46); | ||
948 | n44.addNode(n45); | ||
949 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
950 | case LONG: | ||
951 | n49 = jj_consume_token(LONG); | ||
952 | n48 = JTBToolkit.makeNodeToken(n49); | ||
953 | n47.addNode(n48); | ||
954 | break; | ||
955 | default: | ||
956 | jj_la1[28] = jj_gen; | ||
957 | ; | ||
958 | } | ||
959 | n44.addNode(n47); | ||
960 | n33 = new NodeChoice(n44, 3); | ||
961 | break; | ||
962 | default: | ||
963 | jj_la1[29] = jj_gen; | ||
964 | jj_consume_token(-1); | ||
965 | throw new ParseException(); | ||
966 | } | ||
967 | n32.addNode(n33); | ||
968 | break; | ||
969 | default: | ||
970 | jj_la1[30] = jj_gen; | ||
971 | ; | ||
972 | } | ||
973 | n26.addNode(n32); | ||
974 | n3 = new NodeChoice(n26, 7); | ||
975 | break; | ||
976 | case STRUCT: | ||
977 | case UNION: | ||
978 | n50 = StructOrUnionSpecifier(); | ||
979 | n3 = new NodeChoice(n50, 8); | ||
980 | break; | ||
981 | case ENUM: | ||
982 | n51 = EnumSpecifier(); | ||
983 | n3 = new NodeChoice(n51, 9); | ||
984 | break; | ||
985 | default: | ||
986 | jj_la1[31] = jj_gen; | ||
987 | jj_consume_token(-1); | ||
988 | throw new ParseException(); | ||
989 | } | ||
990 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
991 | case 58: | ||
992 | n53 = Pointer(); | ||
993 | n52.addNode(n53); | ||
994 | break; | ||
995 | default: | ||
996 | jj_la1[32] = jj_gen; | ||
997 | ; | ||
998 | } | ||
999 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1000 | case 65: | ||
1001 | n55 = Array(); | ||
1002 | n54.addNode(n55); | ||
1003 | break; | ||
1004 | default: | ||
1005 | jj_la1[33] = jj_gen; | ||
1006 | ; | ||
1007 | } | ||
1008 | {if (true) return new NoIdentifierTypeSpecifier(n0,n3,n52,n54);} | ||
1009 | throw new Error("Missing return statement in function"); | ||
1010 | } | ||
1011 | |||
1012 | final public StructOrUnionSpecifier StructOrUnionSpecifier() throws ParseException { | ||
1013 | NodeChoice n0; | ||
1014 | NodeSequence n1; | ||
1015 | StructOrUnion n2; | ||
1016 | NodeOptional n3 = new NodeOptional(); | ||
1017 | NodeToken n4; | ||
1018 | Token n5; | ||
1019 | NodeToken n6; | ||
1020 | Token n7; | ||
1021 | StructDeclarationList n8; | ||
1022 | NodeToken n9; | ||
1023 | Token n10; | ||
1024 | NodeSequence n11; | ||
1025 | StructOrUnion n12; | ||
1026 | NodeToken n13; | ||
1027 | Token n14; | ||
1028 | if (jj_2_7(3)) { | ||
1029 | n1 = new NodeSequence(6); | ||
1030 | n2 = StructOrUnion(); | ||
1031 | n1.addNode(n2); | ||
1032 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1033 | case IDENTIFIER: | ||
1034 | n5 = jj_consume_token(IDENTIFIER); | ||
1035 | n4 = JTBToolkit.makeNodeToken(n5); | ||
1036 | n3.addNode(n4); | ||
1037 | break; | ||
1038 | default: | ||
1039 | jj_la1[34] = jj_gen; | ||
1040 | ; | ||
1041 | } | ||
1042 | n1.addNode(n3); | ||
1043 | n7 = jj_consume_token(61); | ||
1044 | n6 = JTBToolkit.makeNodeToken(n7); | ||
1045 | n1.addNode(n6); | ||
1046 | n8 = StructDeclarationList(); | ||
1047 | n1.addNode(n8); | ||
1048 | n10 = jj_consume_token(62); | ||
1049 | n9 = JTBToolkit.makeNodeToken(n10); | ||
1050 | n1.addNode(n9); | ||
1051 | n0 = new NodeChoice(n1, 0); | ||
1052 | } else { | ||
1053 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1054 | case STRUCT: | ||
1055 | case UNION: | ||
1056 | n11 = new NodeSequence(2); | ||
1057 | n12 = StructOrUnion(); | ||
1058 | n11.addNode(n12); | ||
1059 | n14 = jj_consume_token(IDENTIFIER); | ||
1060 | n13 = JTBToolkit.makeNodeToken(n14); | ||
1061 | n11.addNode(n13); | ||
1062 | n0 = new NodeChoice(n11, 1); | ||
1063 | break; | ||
1064 | default: | ||
1065 | jj_la1[35] = jj_gen; | ||
1066 | jj_consume_token(-1); | ||
1067 | throw new ParseException(); | ||
1068 | } | ||
1069 | } | ||
1070 | {if (true) return new StructOrUnionSpecifier(n0);} | ||
1071 | throw new Error("Missing return statement in function"); | ||
1072 | } | ||
1073 | |||
1074 | final public StructOrUnion StructOrUnion() throws ParseException { | ||
1075 | NodeChoice n0; | ||
1076 | NodeToken n1; | ||
1077 | Token n2; | ||
1078 | NodeToken n3; | ||
1079 | Token n4; | ||
1080 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1081 | case STRUCT: | ||
1082 | n2 = jj_consume_token(STRUCT); | ||
1083 | n1 = JTBToolkit.makeNodeToken(n2); | ||
1084 | n0 = new NodeChoice(n1, 0); | ||
1085 | break; | ||
1086 | case UNION: | ||
1087 | n4 = jj_consume_token(UNION); | ||
1088 | n3 = JTBToolkit.makeNodeToken(n4); | ||
1089 | n0 = new NodeChoice(n3, 1); | ||
1090 | break; | ||
1091 | default: | ||
1092 | jj_la1[36] = jj_gen; | ||
1093 | jj_consume_token(-1); | ||
1094 | throw new ParseException(); | ||
1095 | } | ||
1096 | {if (true) return new StructOrUnion(n0);} | ||
1097 | throw new Error("Missing return statement in function"); | ||
1098 | } | ||
1099 | |||
1100 | final public StructDeclarationList StructDeclarationList() throws ParseException { | ||
1101 | NodeList n0 = new NodeList(); | ||
1102 | StructDeclaration n1; | ||
1103 | label_5: | ||
1104 | while (true) { | ||
1105 | n1 = StructDeclaration(); | ||
1106 | n0.addNode(n1); | ||
1107 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1108 | case UNSIGNED: | ||
1109 | case DOUBLE: | ||
1110 | case STRUCT: | ||
1111 | case SIGNED: | ||
1112 | case UNION: | ||
1113 | case CONST: | ||
1114 | case FLOAT: | ||
1115 | case SHORT: | ||
1116 | case LONG: | ||
1117 | case ENUM: | ||
1118 | case VOID: | ||
1119 | case CHAR: | ||
1120 | case INT: | ||
1121 | case IDENTIFIER: | ||
1122 | ; | ||
1123 | break; | ||
1124 | default: | ||
1125 | jj_la1[37] = jj_gen; | ||
1126 | break label_5; | ||
1127 | } | ||
1128 | } | ||
1129 | n0.nodes.trimToSize(); | ||
1130 | {if (true) return new StructDeclarationList(n0);} | ||
1131 | throw new Error("Missing return statement in function"); | ||
1132 | } | ||
1133 | |||
1134 | final public InitDeclaratorList InitDeclaratorList() throws ParseException { | ||
1135 | InitDeclarator n0; | ||
1136 | NodeListOptional n1 = new NodeListOptional(); | ||
1137 | NodeSequence n2; | ||
1138 | NodeToken n3; | ||
1139 | Token n4; | ||
1140 | InitDeclarator n5; | ||
1141 | n0 = InitDeclarator(); | ||
1142 | label_6: | ||
1143 | while (true) { | ||
1144 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1145 | case 59: | ||
1146 | ; | ||
1147 | break; | ||
1148 | default: | ||
1149 | jj_la1[38] = jj_gen; | ||
1150 | break label_6; | ||
1151 | } | ||
1152 | n2 = new NodeSequence(2); | ||
1153 | n4 = jj_consume_token(59); | ||
1154 | n3 = JTBToolkit.makeNodeToken(n4); | ||
1155 | n2.addNode(n3); | ||
1156 | n5 = InitDeclarator(); | ||
1157 | n2.addNode(n5); | ||
1158 | n1.addNode(n2); | ||
1159 | } | ||
1160 | n1.nodes.trimToSize(); | ||
1161 | {if (true) return new InitDeclaratorList(n0,n1);} | ||
1162 | throw new Error("Missing return statement in function"); | ||
1163 | } | ||
1164 | |||
1165 | final public InitDeclarator InitDeclarator() throws ParseException { | ||
1166 | NodeToken n0; | ||
1167 | Token n1; | ||
1168 | NodeOptional n2 = new NodeOptional(); | ||
1169 | Array n3; | ||
1170 | NodeOptional n4 = new NodeOptional(); | ||
1171 | NodeSequence n5; | ||
1172 | NodeToken n6; | ||
1173 | Token n7; | ||
1174 | Initializer n8; | ||
1175 | n1 = jj_consume_token(IDENTIFIER); | ||
1176 | n0 = JTBToolkit.makeNodeToken(n1); | ||
1177 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1178 | case 65: | ||
1179 | n3 = Array(); | ||
1180 | n2.addNode(n3); | ||
1181 | break; | ||
1182 | default: | ||
1183 | jj_la1[39] = jj_gen; | ||
1184 | ; | ||
1185 | } | ||
1186 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1187 | case 63: | ||
1188 | n5 = new NodeSequence(2); | ||
1189 | n7 = jj_consume_token(63); | ||
1190 | n6 = JTBToolkit.makeNodeToken(n7); | ||
1191 | n5.addNode(n6); | ||
1192 | n8 = Initializer(); | ||
1193 | n5.addNode(n8); | ||
1194 | n4.addNode(n5); | ||
1195 | break; | ||
1196 | default: | ||
1197 | jj_la1[40] = jj_gen; | ||
1198 | ; | ||
1199 | } | ||
1200 | {if (true) return new InitDeclarator(n0,n2,n4);} | ||
1201 | throw new Error("Missing return statement in function"); | ||
1202 | } | ||
1203 | |||
1204 | final public StructDeclaration StructDeclaration() throws ParseException { | ||
1205 | TypeSpecifier n0; | ||
1206 | NodeToken n1; | ||
1207 | Token n2; | ||
1208 | NodeOptional n3 = new NodeOptional(); | ||
1209 | NodeChoice n4; | ||
1210 | Array n5; | ||
1211 | NodeSequence n6; | ||
1212 | NodeToken n7; | ||
1213 | Token n8; | ||
1214 | ConstantExpression n9; | ||
1215 | NodeOptional n10 = new NodeOptional(); | ||
1216 | NodeToken n11; | ||
1217 | Token n12; | ||
1218 | NodeToken n13; | ||
1219 | Token n14; | ||
1220 | n0 = TypeSpecifier(); | ||
1221 | n2 = jj_consume_token(IDENTIFIER); | ||
1222 | n1 = JTBToolkit.makeNodeToken(n2); | ||
1223 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1224 | case 64: | ||
1225 | case 65: | ||
1226 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1227 | case 65: | ||
1228 | n5 = Array(); | ||
1229 | n4 = new NodeChoice(n5, 0); | ||
1230 | break; | ||
1231 | case 64: | ||
1232 | n6 = new NodeSequence(2); | ||
1233 | n8 = jj_consume_token(64); | ||
1234 | n7 = JTBToolkit.makeNodeToken(n8); | ||
1235 | n6.addNode(n7); | ||
1236 | n9 = ConstantExpression(); | ||
1237 | n6.addNode(n9); | ||
1238 | n4 = new NodeChoice(n6, 1); | ||
1239 | break; | ||
1240 | default: | ||
1241 | jj_la1[41] = jj_gen; | ||
1242 | jj_consume_token(-1); | ||
1243 | throw new ParseException(); | ||
1244 | } | ||
1245 | n3.addNode(n4); | ||
1246 | break; | ||
1247 | default: | ||
1248 | jj_la1[42] = jj_gen; | ||
1249 | ; | ||
1250 | } | ||
1251 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1252 | case IDENTIFIER: | ||
1253 | n12 = jj_consume_token(IDENTIFIER); | ||
1254 | n11 = JTBToolkit.makeNodeToken(n12); | ||
1255 | n10.addNode(n11); | ||
1256 | break; | ||
1257 | default: | ||
1258 | jj_la1[43] = jj_gen; | ||
1259 | ; | ||
1260 | } | ||
1261 | n14 = jj_consume_token(57); | ||
1262 | n13 = JTBToolkit.makeNodeToken(n14); | ||
1263 | {if (true) return new StructDeclaration(n0,n1,n3,n10,n13);} | ||
1264 | throw new Error("Missing return statement in function"); | ||
1265 | } | ||
1266 | |||
1267 | final public EnumSpecifier EnumSpecifier() throws ParseException { | ||
1268 | NodeToken n0; | ||
1269 | Token n1; | ||
1270 | NodeChoice n2; | ||
1271 | NodeSequence n3; | ||
1272 | NodeOptional n4 = new NodeOptional(); | ||
1273 | NodeToken n5; | ||
1274 | Token n6; | ||
1275 | NodeToken n7; | ||
1276 | Token n8; | ||
1277 | EnumeratorList n9; | ||
1278 | NodeToken n10; | ||
1279 | Token n11; | ||
1280 | NodeToken n12; | ||
1281 | Token n13; | ||
1282 | n1 = jj_consume_token(ENUM); | ||
1283 | n0 = JTBToolkit.makeNodeToken(n1); | ||
1284 | if (jj_2_8(3)) { | ||
1285 | n3 = new NodeSequence(5); | ||
1286 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1287 | case IDENTIFIER: | ||
1288 | n6 = jj_consume_token(IDENTIFIER); | ||
1289 | n5 = JTBToolkit.makeNodeToken(n6); | ||
1290 | n4.addNode(n5); | ||
1291 | break; | ||
1292 | default: | ||
1293 | jj_la1[44] = jj_gen; | ||
1294 | ; | ||
1295 | } | ||
1296 | n3.addNode(n4); | ||
1297 | n8 = jj_consume_token(61); | ||
1298 | n7 = JTBToolkit.makeNodeToken(n8); | ||
1299 | n3.addNode(n7); | ||
1300 | n9 = EnumeratorList(); | ||
1301 | n3.addNode(n9); | ||
1302 | n11 = jj_consume_token(62); | ||
1303 | n10 = JTBToolkit.makeNodeToken(n11); | ||
1304 | n3.addNode(n10); | ||
1305 | n2 = new NodeChoice(n3, 0); | ||
1306 | } else { | ||
1307 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1308 | case IDENTIFIER: | ||
1309 | n13 = jj_consume_token(IDENTIFIER); | ||
1310 | n12 = JTBToolkit.makeNodeToken(n13); | ||
1311 | n2 = new NodeChoice(n12, 1); | ||
1312 | break; | ||
1313 | default: | ||
1314 | jj_la1[45] = jj_gen; | ||
1315 | jj_consume_token(-1); | ||
1316 | throw new ParseException(); | ||
1317 | } | ||
1318 | } | ||
1319 | {if (true) return new EnumSpecifier(n0,n2);} | ||
1320 | throw new Error("Missing return statement in function"); | ||
1321 | } | ||
1322 | |||
1323 | final public EnumeratorList EnumeratorList() throws ParseException { | ||
1324 | Enumerator n0; | ||
1325 | NodeListOptional n1 = new NodeListOptional(); | ||
1326 | NodeSequence n2; | ||
1327 | NodeToken n3; | ||
1328 | Token n4; | ||
1329 | Enumerator n5; | ||
1330 | n0 = Enumerator(); | ||
1331 | label_7: | ||
1332 | while (true) { | ||
1333 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1334 | case 59: | ||
1335 | ; | ||
1336 | break; | ||
1337 | default: | ||
1338 | jj_la1[46] = jj_gen; | ||
1339 | break label_7; | ||
1340 | } | ||
1341 | n2 = new NodeSequence(2); | ||
1342 | n4 = jj_consume_token(59); | ||
1343 | n3 = JTBToolkit.makeNodeToken(n4); | ||
1344 | n2.addNode(n3); | ||
1345 | n5 = Enumerator(); | ||
1346 | n2.addNode(n5); | ||
1347 | n1.addNode(n2); | ||
1348 | } | ||
1349 | n1.nodes.trimToSize(); | ||
1350 | {if (true) return new EnumeratorList(n0,n1);} | ||
1351 | throw new Error("Missing return statement in function"); | ||
1352 | } | ||
1353 | |||
1354 | final public Enumerator Enumerator() throws ParseException { | ||
1355 | NodeToken n0; | ||
1356 | Token n1; | ||
1357 | NodeOptional n2 = new NodeOptional(); | ||
1358 | NodeSequence n3; | ||
1359 | NodeToken n4; | ||
1360 | Token n5; | ||
1361 | ConstantExpression n6; | ||
1362 | n1 = jj_consume_token(IDENTIFIER); | ||
1363 | n0 = JTBToolkit.makeNodeToken(n1); | ||
1364 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1365 | case 63: | ||
1366 | n3 = new NodeSequence(2); | ||
1367 | n5 = jj_consume_token(63); | ||
1368 | n4 = JTBToolkit.makeNodeToken(n5); | ||
1369 | n3.addNode(n4); | ||
1370 | n6 = ConstantExpression(); | ||
1371 | n3.addNode(n6); | ||
1372 | n2.addNode(n3); | ||
1373 | break; | ||
1374 | default: | ||
1375 | jj_la1[47] = jj_gen; | ||
1376 | ; | ||
1377 | } | ||
1378 | {if (true) return new Enumerator(n0,n2);} | ||
1379 | throw new Error("Missing return statement in function"); | ||
1380 | } | ||
1381 | |||
1382 | final public Pointer Pointer() throws ParseException { | ||
1383 | NodeToken n0; | ||
1384 | Token n1; | ||
1385 | NodeOptional n2 = new NodeOptional(); | ||
1386 | NodeToken n3; | ||
1387 | Token n4; | ||
1388 | NodeOptional n5 = new NodeOptional(); | ||
1389 | Pointer n6; | ||
1390 | n1 = jj_consume_token(58); | ||
1391 | n0 = JTBToolkit.makeNodeToken(n1); | ||
1392 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1393 | case CONST: | ||
1394 | n4 = jj_consume_token(CONST); | ||
1395 | n3 = JTBToolkit.makeNodeToken(n4); | ||
1396 | n2.addNode(n3); | ||
1397 | break; | ||
1398 | default: | ||
1399 | jj_la1[48] = jj_gen; | ||
1400 | ; | ||
1401 | } | ||
1402 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1403 | case 58: | ||
1404 | n6 = Pointer(); | ||
1405 | n5.addNode(n6); | ||
1406 | break; | ||
1407 | default: | ||
1408 | jj_la1[49] = jj_gen; | ||
1409 | ; | ||
1410 | } | ||
1411 | {if (true) return new Pointer(n0,n2,n5);} | ||
1412 | throw new Error("Missing return statement in function"); | ||
1413 | } | ||
1414 | |||
1415 | final public IdentifierList IdentifierList() throws ParseException { | ||
1416 | NodeToken n0; | ||
1417 | Token n1; | ||
1418 | NodeListOptional n2 = new NodeListOptional(); | ||
1419 | NodeSequence n3; | ||
1420 | NodeToken n4; | ||
1421 | Token n5; | ||
1422 | NodeToken n6; | ||
1423 | Token n7; | ||
1424 | n1 = jj_consume_token(IDENTIFIER); | ||
1425 | n0 = JTBToolkit.makeNodeToken(n1); | ||
1426 | label_8: | ||
1427 | while (true) { | ||
1428 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1429 | case 59: | ||
1430 | ; | ||
1431 | break; | ||
1432 | default: | ||
1433 | jj_la1[50] = jj_gen; | ||
1434 | break label_8; | ||
1435 | } | ||
1436 | n3 = new NodeSequence(2); | ||
1437 | n5 = jj_consume_token(59); | ||
1438 | n4 = JTBToolkit.makeNodeToken(n5); | ||
1439 | n3.addNode(n4); | ||
1440 | n7 = jj_consume_token(IDENTIFIER); | ||
1441 | n6 = JTBToolkit.makeNodeToken(n7); | ||
1442 | n3.addNode(n6); | ||
1443 | n2.addNode(n3); | ||
1444 | } | ||
1445 | n2.nodes.trimToSize(); | ||
1446 | {if (true) return new IdentifierList(n0,n2);} | ||
1447 | throw new Error("Missing return statement in function"); | ||
1448 | } | ||
1449 | |||
1450 | final public Initializer Initializer() throws ParseException { | ||
1451 | NodeChoice n0; | ||
1452 | AssignmentExpression n1; | ||
1453 | NodeSequence n2; | ||
1454 | NodeToken n3; | ||
1455 | Token n4; | ||
1456 | InitializerList n5; | ||
1457 | NodeOptional n6 = new NodeOptional(); | ||
1458 | NodeToken n7; | ||
1459 | Token n8; | ||
1460 | NodeToken n9; | ||
1461 | Token n10; | ||
1462 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1463 | case INTEGER_LITERAL: | ||
1464 | case FLOATING_POINT_LITERAL: | ||
1465 | case CHARACTER_LITERAL: | ||
1466 | case STRING_LITERAL: | ||
1467 | case SIZEOF: | ||
1468 | case IDENTIFIER: | ||
1469 | case 55: | ||
1470 | case 58: | ||
1471 | case 82: | ||
1472 | case 91: | ||
1473 | case 92: | ||
1474 | case 95: | ||
1475 | case 96: | ||
1476 | case 97: | ||
1477 | case 98: | ||
1478 | n1 = AssignmentExpression(); | ||
1479 | n0 = new NodeChoice(n1, 0); | ||
1480 | break; | ||
1481 | case 61: | ||
1482 | n2 = new NodeSequence(4); | ||
1483 | n4 = jj_consume_token(61); | ||
1484 | n3 = JTBToolkit.makeNodeToken(n4); | ||
1485 | n2.addNode(n3); | ||
1486 | n5 = InitializerList(); | ||
1487 | n2.addNode(n5); | ||
1488 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1489 | case 59: | ||
1490 | n8 = jj_consume_token(59); | ||
1491 | n7 = JTBToolkit.makeNodeToken(n8); | ||
1492 | n6.addNode(n7); | ||
1493 | break; | ||
1494 | default: | ||
1495 | jj_la1[51] = jj_gen; | ||
1496 | ; | ||
1497 | } | ||
1498 | n2.addNode(n6); | ||
1499 | n10 = jj_consume_token(62); | ||
1500 | n9 = JTBToolkit.makeNodeToken(n10); | ||
1501 | n2.addNode(n9); | ||
1502 | n0 = new NodeChoice(n2, 1); | ||
1503 | break; | ||
1504 | default: | ||
1505 | jj_la1[52] = jj_gen; | ||
1506 | jj_consume_token(-1); | ||
1507 | throw new ParseException(); | ||
1508 | } | ||
1509 | {if (true) return new Initializer(n0);} | ||
1510 | throw new Error("Missing return statement in function"); | ||
1511 | } | ||
1512 | |||
1513 | final public InitializerList InitializerList() throws ParseException { | ||
1514 | Initializer n0; | ||
1515 | NodeListOptional n1 = new NodeListOptional(); | ||
1516 | NodeSequence n2; | ||
1517 | NodeToken n3; | ||
1518 | Token n4; | ||
1519 | Initializer n5; | ||
1520 | n0 = Initializer(); | ||
1521 | label_9: | ||
1522 | while (true) { | ||
1523 | if (jj_2_9(2)) { | ||
1524 | ; | ||
1525 | } else { | ||
1526 | break label_9; | ||
1527 | } | ||
1528 | n2 = new NodeSequence(2); | ||
1529 | n4 = jj_consume_token(59); | ||
1530 | n3 = JTBToolkit.makeNodeToken(n4); | ||
1531 | n2.addNode(n3); | ||
1532 | n5 = Initializer(); | ||
1533 | n2.addNode(n5); | ||
1534 | n1.addNode(n2); | ||
1535 | } | ||
1536 | n1.nodes.trimToSize(); | ||
1537 | {if (true) return new InitializerList(n0,n1);} | ||
1538 | throw new Error("Missing return statement in function"); | ||
1539 | } | ||
1540 | |||
1541 | final public Array Array() throws ParseException { | ||
1542 | NodeToken n0; | ||
1543 | Token n1; | ||
1544 | NodeOptional n2 = new NodeOptional(); | ||
1545 | ConstantExpression n3; | ||
1546 | NodeToken n4; | ||
1547 | Token n5; | ||
1548 | n1 = jj_consume_token(65); | ||
1549 | n0 = JTBToolkit.makeNodeToken(n1); | ||
1550 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1551 | case INTEGER_LITERAL: | ||
1552 | case FLOATING_POINT_LITERAL: | ||
1553 | case CHARACTER_LITERAL: | ||
1554 | case STRING_LITERAL: | ||
1555 | case SIZEOF: | ||
1556 | case IDENTIFIER: | ||
1557 | case 55: | ||
1558 | case 58: | ||
1559 | case 82: | ||
1560 | case 91: | ||
1561 | case 92: | ||
1562 | case 95: | ||
1563 | case 96: | ||
1564 | case 97: | ||
1565 | case 98: | ||
1566 | n3 = ConstantExpression(); | ||
1567 | n2.addNode(n3); | ||
1568 | break; | ||
1569 | default: | ||
1570 | jj_la1[53] = jj_gen; | ||
1571 | ; | ||
1572 | } | ||
1573 | n5 = jj_consume_token(66); | ||
1574 | n4 = JTBToolkit.makeNodeToken(n5); | ||
1575 | {if (true) return new Array(n0,n2,n4);} | ||
1576 | throw new Error("Missing return statement in function"); | ||
1577 | } | ||
1578 | |||
1579 | final public Statement Statement() throws ParseException { | ||
1580 | NodeChoice n0; | ||
1581 | LabeledStatement n1; | ||
1582 | ExpressionStatement n2; | ||
1583 | CompoundStatement n3; | ||
1584 | SelectionStatement n4; | ||
1585 | IterationStatement n5; | ||
1586 | JumpStatement n6; | ||
1587 | if (jj_2_10(2)) { | ||
1588 | n1 = LabeledStatement(); | ||
1589 | n0 = new NodeChoice(n1, 0); | ||
1590 | } else { | ||
1591 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1592 | case INTEGER_LITERAL: | ||
1593 | case FLOATING_POINT_LITERAL: | ||
1594 | case CHARACTER_LITERAL: | ||
1595 | case STRING_LITERAL: | ||
1596 | case SIZEOF: | ||
1597 | case IDENTIFIER: | ||
1598 | case 55: | ||
1599 | case 57: | ||
1600 | case 58: | ||
1601 | case 82: | ||
1602 | case 91: | ||
1603 | case 92: | ||
1604 | case 95: | ||
1605 | case 96: | ||
1606 | case 97: | ||
1607 | case 98: | ||
1608 | n2 = ExpressionStatement(); | ||
1609 | n0 = new NodeChoice(n2, 1); | ||
1610 | break; | ||
1611 | case 61: | ||
1612 | n3 = CompoundStatement(); | ||
1613 | n0 = new NodeChoice(n3, 2); | ||
1614 | break; | ||
1615 | case SWITCH: | ||
1616 | case IF: | ||
1617 | n4 = SelectionStatement(); | ||
1618 | n0 = new NodeChoice(n4, 3); | ||
1619 | break; | ||
1620 | case WHILE: | ||
1621 | case FOR: | ||
1622 | case DO: | ||
1623 | n5 = IterationStatement(); | ||
1624 | n0 = new NodeChoice(n5, 4); | ||
1625 | break; | ||
1626 | case CONTINUE: | ||
1627 | case RETURN: | ||
1628 | case BREAK: | ||
1629 | case GOTO: | ||
1630 | n6 = JumpStatement(); | ||
1631 | n0 = new NodeChoice(n6, 5); | ||
1632 | break; | ||
1633 | default: | ||
1634 | jj_la1[54] = jj_gen; | ||
1635 | jj_consume_token(-1); | ||
1636 | throw new ParseException(); | ||
1637 | } | ||
1638 | } | ||
1639 | {if (true) return new Statement(n0);} | ||
1640 | throw new Error("Missing return statement in function"); | ||
1641 | } | ||
1642 | |||
1643 | final public LabeledStatement LabeledStatement() throws ParseException { | ||
1644 | NodeChoice n0; | ||
1645 | NodeSequence n1; | ||
1646 | NodeToken n2; | ||
1647 | Token n3; | ||
1648 | NodeToken n4; | ||
1649 | Token n5; | ||
1650 | Statement n6; | ||
1651 | NodeSequence n7; | ||
1652 | NodeToken n8; | ||
1653 | Token n9; | ||
1654 | ConstantExpression n10; | ||
1655 | NodeToken n11; | ||
1656 | Token n12; | ||
1657 | Statement n13; | ||
1658 | NodeSequence n14; | ||
1659 | NodeToken n15; | ||
1660 | Token n16; | ||
1661 | NodeToken n17; | ||
1662 | Token n18; | ||
1663 | Statement n19; | ||
1664 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1665 | case IDENTIFIER: | ||
1666 | n1 = new NodeSequence(3); | ||
1667 | n3 = jj_consume_token(IDENTIFIER); | ||
1668 | n2 = JTBToolkit.makeNodeToken(n3); | ||
1669 | n1.addNode(n2); | ||
1670 | n5 = jj_consume_token(64); | ||
1671 | n4 = JTBToolkit.makeNodeToken(n5); | ||
1672 | n1.addNode(n4); | ||
1673 | n6 = Statement(); | ||
1674 | n1.addNode(n6); | ||
1675 | n0 = new NodeChoice(n1, 0); | ||
1676 | break; | ||
1677 | case CASE: | ||
1678 | n7 = new NodeSequence(4); | ||
1679 | n9 = jj_consume_token(CASE); | ||
1680 | n8 = JTBToolkit.makeNodeToken(n9); | ||
1681 | n7.addNode(n8); | ||
1682 | n10 = ConstantExpression(); | ||
1683 | n7.addNode(n10); | ||
1684 | n12 = jj_consume_token(64); | ||
1685 | n11 = JTBToolkit.makeNodeToken(n12); | ||
1686 | n7.addNode(n11); | ||
1687 | n13 = Statement(); | ||
1688 | n7.addNode(n13); | ||
1689 | n0 = new NodeChoice(n7, 1); | ||
1690 | break; | ||
1691 | case DFLT: | ||
1692 | n14 = new NodeSequence(3); | ||
1693 | n16 = jj_consume_token(DFLT); | ||
1694 | n15 = JTBToolkit.makeNodeToken(n16); | ||
1695 | n14.addNode(n15); | ||
1696 | n18 = jj_consume_token(64); | ||
1697 | n17 = JTBToolkit.makeNodeToken(n18); | ||
1698 | n14.addNode(n17); | ||
1699 | n19 = Statement(); | ||
1700 | n14.addNode(n19); | ||
1701 | n0 = new NodeChoice(n14, 2); | ||
1702 | break; | ||
1703 | default: | ||
1704 | jj_la1[55] = jj_gen; | ||
1705 | jj_consume_token(-1); | ||
1706 | throw new ParseException(); | ||
1707 | } | ||
1708 | {if (true) return new LabeledStatement(n0);} | ||
1709 | throw new Error("Missing return statement in function"); | ||
1710 | } | ||
1711 | |||
1712 | final public ExpressionStatement ExpressionStatement() throws ParseException { | ||
1713 | NodeOptional n0 = new NodeOptional(); | ||
1714 | Expression n1; | ||
1715 | NodeToken n2; | ||
1716 | Token n3; | ||
1717 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1718 | case INTEGER_LITERAL: | ||
1719 | case FLOATING_POINT_LITERAL: | ||
1720 | case CHARACTER_LITERAL: | ||
1721 | case STRING_LITERAL: | ||
1722 | case SIZEOF: | ||
1723 | case IDENTIFIER: | ||
1724 | case 55: | ||
1725 | case 58: | ||
1726 | case 82: | ||
1727 | case 91: | ||
1728 | case 92: | ||
1729 | case 95: | ||
1730 | case 96: | ||
1731 | case 97: | ||
1732 | case 98: | ||
1733 | n1 = Expression(); | ||
1734 | n0.addNode(n1); | ||
1735 | break; | ||
1736 | default: | ||
1737 | jj_la1[56] = jj_gen; | ||
1738 | ; | ||
1739 | } | ||
1740 | n3 = jj_consume_token(57); | ||
1741 | n2 = JTBToolkit.makeNodeToken(n3); | ||
1742 | {if (true) return new ExpressionStatement(n0,n2);} | ||
1743 | throw new Error("Missing return statement in function"); | ||
1744 | } | ||
1745 | |||
1746 | final public CompoundStatement CompoundStatement() throws ParseException { | ||
1747 | NodeToken n0; | ||
1748 | Token n1; | ||
1749 | NodeListOptional n2 = new NodeListOptional(); | ||
1750 | NodeChoice n3; | ||
1751 | LocalVariableDeclaration n4; | ||
1752 | Statement n5; | ||
1753 | NodeToken n6; | ||
1754 | Token n7; | ||
1755 | n1 = jj_consume_token(61); | ||
1756 | n0 = JTBToolkit.makeNodeToken(n1); | ||
1757 | label_10: | ||
1758 | while (true) { | ||
1759 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1760 | case INTEGER_LITERAL: | ||
1761 | case FLOATING_POINT_LITERAL: | ||
1762 | case CHARACTER_LITERAL: | ||
1763 | case STRING_LITERAL: | ||
1764 | case CONTINUE: | ||
1765 | case REGISTER: | ||
1766 | case UNSIGNED: | ||
1767 | case DFLT: | ||
1768 | case DOUBLE: | ||
1769 | case SIZEOF: | ||
1770 | case SWITCH: | ||
1771 | case RETURN: | ||
1772 | case STRUCT: | ||
1773 | case STATIC: | ||
1774 | case SIGNED: | ||
1775 | case WHILE: | ||
1776 | case BREAK: | ||
1777 | case UNION: | ||
1778 | case CONST: | ||
1779 | case FLOAT: | ||
1780 | case SHORT: | ||
1781 | case CASE: | ||
1782 | case LONG: | ||
1783 | case ENUM: | ||
1784 | case AUTO: | ||
1785 | case VOID: | ||
1786 | case CHAR: | ||
1787 | case GOTO: | ||
1788 | case FOR: | ||
1789 | case INT: | ||
1790 | case IF: | ||
1791 | case DO: | ||
1792 | case IDENTIFIER: | ||
1793 | case 55: | ||
1794 | case 57: | ||
1795 | case 58: | ||
1796 | case 61: | ||
1797 | case 82: | ||
1798 | case 91: | ||
1799 | case 92: | ||
1800 | case 95: | ||
1801 | case 96: | ||
1802 | case 97: | ||
1803 | case 98: | ||
1804 | ; | ||
1805 | break; | ||
1806 | default: | ||
1807 | jj_la1[57] = jj_gen; | ||
1808 | break label_10; | ||
1809 | } | ||
1810 | if (jj_2_11(2147483647)) { | ||
1811 | n4 = LocalVariableDeclaration(); | ||
1812 | n3 = new NodeChoice(n4, 0); | ||
1813 | } else { | ||
1814 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1815 | case INTEGER_LITERAL: | ||
1816 | case FLOATING_POINT_LITERAL: | ||
1817 | case CHARACTER_LITERAL: | ||
1818 | case STRING_LITERAL: | ||
1819 | case CONTINUE: | ||
1820 | case DFLT: | ||
1821 | case SIZEOF: | ||
1822 | case SWITCH: | ||
1823 | case RETURN: | ||
1824 | case WHILE: | ||
1825 | case BREAK: | ||
1826 | case CASE: | ||
1827 | case GOTO: | ||
1828 | case FOR: | ||
1829 | case IF: | ||
1830 | case DO: | ||
1831 | case IDENTIFIER: | ||
1832 | case 55: | ||
1833 | case 57: | ||
1834 | case 58: | ||
1835 | case 61: | ||
1836 | case 82: | ||
1837 | case 91: | ||
1838 | case 92: | ||
1839 | case 95: | ||
1840 | case 96: | ||
1841 | case 97: | ||
1842 | case 98: | ||
1843 | n5 = Statement(); | ||
1844 | n3 = new NodeChoice(n5, 1); | ||
1845 | break; | ||
1846 | default: | ||
1847 | jj_la1[58] = jj_gen; | ||
1848 | jj_consume_token(-1); | ||
1849 | throw new ParseException(); | ||
1850 | } | ||
1851 | } | ||
1852 | n2.addNode(n3); | ||
1853 | } | ||
1854 | n2.nodes.trimToSize(); | ||
1855 | n7 = jj_consume_token(62); | ||
1856 | n6 = JTBToolkit.makeNodeToken(n7); | ||
1857 | {if (true) return new CompoundStatement(n0,n2,n6);} | ||
1858 | throw new Error("Missing return statement in function"); | ||
1859 | } | ||
1860 | |||
1861 | final public SelectionStatement SelectionStatement() throws ParseException { | ||
1862 | NodeChoice n0; | ||
1863 | NodeSequence n1; | ||
1864 | NodeToken n2; | ||
1865 | Token n3; | ||
1866 | NodeToken n4; | ||
1867 | Token n5; | ||
1868 | Expression n6; | ||
1869 | NodeToken n7; | ||
1870 | Token n8; | ||
1871 | Statement n9; | ||
1872 | NodeOptional n10 = new NodeOptional(); | ||
1873 | NodeSequence n11; | ||
1874 | NodeToken n12; | ||
1875 | Token n13; | ||
1876 | Statement n14; | ||
1877 | NodeSequence n15; | ||
1878 | NodeToken n16; | ||
1879 | Token n17; | ||
1880 | NodeToken n18; | ||
1881 | Token n19; | ||
1882 | Expression n20; | ||
1883 | NodeToken n21; | ||
1884 | Token n22; | ||
1885 | Statement n23; | ||
1886 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1887 | case IF: | ||
1888 | n1 = new NodeSequence(6); | ||
1889 | n3 = jj_consume_token(IF); | ||
1890 | n2 = JTBToolkit.makeNodeToken(n3); | ||
1891 | n1.addNode(n2); | ||
1892 | n5 = jj_consume_token(55); | ||
1893 | n4 = JTBToolkit.makeNodeToken(n5); | ||
1894 | n1.addNode(n4); | ||
1895 | n6 = Expression(); | ||
1896 | n1.addNode(n6); | ||
1897 | n8 = jj_consume_token(56); | ||
1898 | n7 = JTBToolkit.makeNodeToken(n8); | ||
1899 | n1.addNode(n7); | ||
1900 | n9 = Statement(); | ||
1901 | n1.addNode(n9); | ||
1902 | if (jj_2_12(2)) { | ||
1903 | n11 = new NodeSequence(2); | ||
1904 | n13 = jj_consume_token(ELSE); | ||
1905 | n12 = JTBToolkit.makeNodeToken(n13); | ||
1906 | n11.addNode(n12); | ||
1907 | n14 = Statement(); | ||
1908 | n11.addNode(n14); | ||
1909 | n10.addNode(n11); | ||
1910 | } else { | ||
1911 | ; | ||
1912 | } | ||
1913 | n1.addNode(n10); | ||
1914 | n0 = new NodeChoice(n1, 0); | ||
1915 | break; | ||
1916 | case SWITCH: | ||
1917 | n15 = new NodeSequence(5); | ||
1918 | n17 = jj_consume_token(SWITCH); | ||
1919 | n16 = JTBToolkit.makeNodeToken(n17); | ||
1920 | n15.addNode(n16); | ||
1921 | n19 = jj_consume_token(55); | ||
1922 | n18 = JTBToolkit.makeNodeToken(n19); | ||
1923 | n15.addNode(n18); | ||
1924 | n20 = Expression(); | ||
1925 | n15.addNode(n20); | ||
1926 | n22 = jj_consume_token(56); | ||
1927 | n21 = JTBToolkit.makeNodeToken(n22); | ||
1928 | n15.addNode(n21); | ||
1929 | n23 = Statement(); | ||
1930 | n15.addNode(n23); | ||
1931 | n0 = new NodeChoice(n15, 1); | ||
1932 | break; | ||
1933 | default: | ||
1934 | jj_la1[59] = jj_gen; | ||
1935 | jj_consume_token(-1); | ||
1936 | throw new ParseException(); | ||
1937 | } | ||
1938 | {if (true) return new SelectionStatement(n0);} | ||
1939 | throw new Error("Missing return statement in function"); | ||
1940 | } | ||
1941 | |||
1942 | final public IterationStatement IterationStatement() throws ParseException { | ||
1943 | NodeChoice n0; | ||
1944 | NodeSequence n1; | ||
1945 | NodeToken n2; | ||
1946 | Token n3; | ||
1947 | NodeToken n4; | ||
1948 | Token n5; | ||
1949 | Expression n6; | ||
1950 | NodeToken n7; | ||
1951 | Token n8; | ||
1952 | Statement n9; | ||
1953 | NodeSequence n10; | ||
1954 | NodeToken n11; | ||
1955 | Token n12; | ||
1956 | Statement n13; | ||
1957 | NodeToken n14; | ||
1958 | Token n15; | ||
1959 | NodeToken n16; | ||
1960 | Token n17; | ||
1961 | Expression n18; | ||
1962 | NodeToken n19; | ||
1963 | Token n20; | ||
1964 | NodeToken n21; | ||
1965 | Token n22; | ||
1966 | NodeSequence n23; | ||
1967 | NodeToken n24; | ||
1968 | Token n25; | ||
1969 | NodeToken n26; | ||
1970 | Token n27; | ||
1971 | NodeOptional n28 = new NodeOptional(); | ||
1972 | Expression n29; | ||
1973 | NodeToken n30; | ||
1974 | Token n31; | ||
1975 | NodeOptional n32 = new NodeOptional(); | ||
1976 | Expression n33; | ||
1977 | NodeToken n34; | ||
1978 | Token n35; | ||
1979 | NodeOptional n36 = new NodeOptional(); | ||
1980 | Expression n37; | ||
1981 | NodeToken n38; | ||
1982 | Token n39; | ||
1983 | Statement n40; | ||
1984 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1985 | case WHILE: | ||
1986 | n1 = new NodeSequence(5); | ||
1987 | n3 = jj_consume_token(WHILE); | ||
1988 | n2 = JTBToolkit.makeNodeToken(n3); | ||
1989 | n1.addNode(n2); | ||
1990 | n5 = jj_consume_token(55); | ||
1991 | n4 = JTBToolkit.makeNodeToken(n5); | ||
1992 | n1.addNode(n4); | ||
1993 | n6 = Expression(); | ||
1994 | n1.addNode(n6); | ||
1995 | n8 = jj_consume_token(56); | ||
1996 | n7 = JTBToolkit.makeNodeToken(n8); | ||
1997 | n1.addNode(n7); | ||
1998 | n9 = Statement(); | ||
1999 | n1.addNode(n9); | ||
2000 | n0 = new NodeChoice(n1, 0); | ||
2001 | break; | ||
2002 | case DO: | ||
2003 | n10 = new NodeSequence(7); | ||
2004 | n12 = jj_consume_token(DO); | ||
2005 | n11 = JTBToolkit.makeNodeToken(n12); | ||
2006 | n10.addNode(n11); | ||
2007 | n13 = Statement(); | ||
2008 | n10.addNode(n13); | ||
2009 | n15 = jj_consume_token(WHILE); | ||
2010 | n14 = JTBToolkit.makeNodeToken(n15); | ||
2011 | n10.addNode(n14); | ||
2012 | n17 = jj_consume_token(55); | ||
2013 | n16 = JTBToolkit.makeNodeToken(n17); | ||
2014 | n10.addNode(n16); | ||
2015 | n18 = Expression(); | ||
2016 | n10.addNode(n18); | ||
2017 | n20 = jj_consume_token(56); | ||
2018 | n19 = JTBToolkit.makeNodeToken(n20); | ||
2019 | n10.addNode(n19); | ||
2020 | n22 = jj_consume_token(57); | ||
2021 | n21 = JTBToolkit.makeNodeToken(n22); | ||
2022 | n10.addNode(n21); | ||
2023 | n0 = new NodeChoice(n10, 1); | ||
2024 | break; | ||
2025 | case FOR: | ||
2026 | n23 = new NodeSequence(9); | ||
2027 | n25 = jj_consume_token(FOR); | ||
2028 | n24 = JTBToolkit.makeNodeToken(n25); | ||
2029 | n23.addNode(n24); | ||
2030 | n27 = jj_consume_token(55); | ||
2031 | n26 = JTBToolkit.makeNodeToken(n27); | ||
2032 | n23.addNode(n26); | ||
2033 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2034 | case INTEGER_LITERAL: | ||
2035 | case FLOATING_POINT_LITERAL: | ||
2036 | case CHARACTER_LITERAL: | ||
2037 | case STRING_LITERAL: | ||
2038 | case SIZEOF: | ||
2039 | case IDENTIFIER: | ||
2040 | case 55: | ||
2041 | case 58: | ||
2042 | case 82: | ||
2043 | case 91: | ||
2044 | case 92: | ||
2045 | case 95: | ||
2046 | case 96: | ||
2047 | case 97: | ||
2048 | case 98: | ||
2049 | n29 = Expression(); | ||
2050 | n28.addNode(n29); | ||
2051 | break; | ||
2052 | default: | ||
2053 | jj_la1[60] = jj_gen; | ||
2054 | ; | ||
2055 | } | ||
2056 | n23.addNode(n28); | ||
2057 | n31 = jj_consume_token(57); | ||
2058 | n30 = JTBToolkit.makeNodeToken(n31); | ||
2059 | n23.addNode(n30); | ||
2060 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2061 | case INTEGER_LITERAL: | ||
2062 | case FLOATING_POINT_LITERAL: | ||
2063 | case CHARACTER_LITERAL: | ||
2064 | case STRING_LITERAL: | ||
2065 | case SIZEOF: | ||
2066 | case IDENTIFIER: | ||
2067 | case 55: | ||
2068 | case 58: | ||
2069 | case 82: | ||
2070 | case 91: | ||
2071 | case 92: | ||
2072 | case 95: | ||
2073 | case 96: | ||
2074 | case 97: | ||
2075 | case 98: | ||
2076 | n33 = Expression(); | ||
2077 | n32.addNode(n33); | ||
2078 | break; | ||
2079 | default: | ||
2080 | jj_la1[61] = jj_gen; | ||
2081 | ; | ||
2082 | } | ||
2083 | n23.addNode(n32); | ||
2084 | n35 = jj_consume_token(57); | ||
2085 | n34 = JTBToolkit.makeNodeToken(n35); | ||
2086 | n23.addNode(n34); | ||
2087 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2088 | case INTEGER_LITERAL: | ||
2089 | case FLOATING_POINT_LITERAL: | ||
2090 | case CHARACTER_LITERAL: | ||
2091 | case STRING_LITERAL: | ||
2092 | case SIZEOF: | ||
2093 | case IDENTIFIER: | ||
2094 | case 55: | ||
2095 | case 58: | ||
2096 | case 82: | ||
2097 | case 91: | ||
2098 | case 92: | ||
2099 | case 95: | ||
2100 | case 96: | ||
2101 | case 97: | ||
2102 | case 98: | ||
2103 | n37 = Expression(); | ||
2104 | n36.addNode(n37); | ||
2105 | break; | ||
2106 | default: | ||
2107 | jj_la1[62] = jj_gen; | ||
2108 | ; | ||
2109 | } | ||
2110 | n23.addNode(n36); | ||
2111 | n39 = jj_consume_token(56); | ||
2112 | n38 = JTBToolkit.makeNodeToken(n39); | ||
2113 | n23.addNode(n38); | ||
2114 | n40 = Statement(); | ||
2115 | n23.addNode(n40); | ||
2116 | n0 = new NodeChoice(n23, 2); | ||
2117 | break; | ||
2118 | default: | ||
2119 | jj_la1[63] = jj_gen; | ||
2120 | jj_consume_token(-1); | ||
2121 | throw new ParseException(); | ||
2122 | } | ||
2123 | {if (true) return new IterationStatement(n0);} | ||
2124 | throw new Error("Missing return statement in function"); | ||
2125 | } | ||
2126 | |||
2127 | final public JumpStatement JumpStatement() throws ParseException { | ||
2128 | NodeChoice n0; | ||
2129 | NodeSequence n1; | ||
2130 | NodeToken n2; | ||
2131 | Token n3; | ||
2132 | NodeToken n4; | ||
2133 | Token n5; | ||
2134 | NodeToken n6; | ||
2135 | Token n7; | ||
2136 | NodeSequence n8; | ||
2137 | NodeToken n9; | ||
2138 | Token n10; | ||
2139 | NodeToken n11; | ||
2140 | Token n12; | ||
2141 | NodeSequence n13; | ||
2142 | NodeToken n14; | ||
2143 | Token n15; | ||
2144 | NodeToken n16; | ||
2145 | Token n17; | ||
2146 | NodeSequence n18; | ||
2147 | NodeToken n19; | ||
2148 | Token n20; | ||
2149 | NodeOptional n21 = new NodeOptional(); | ||
2150 | Expression n22; | ||
2151 | NodeToken n23; | ||
2152 | Token n24; | ||
2153 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2154 | case GOTO: | ||
2155 | n1 = new NodeSequence(3); | ||
2156 | n3 = jj_consume_token(GOTO); | ||
2157 | n2 = JTBToolkit.makeNodeToken(n3); | ||
2158 | n1.addNode(n2); | ||
2159 | n5 = jj_consume_token(IDENTIFIER); | ||
2160 | n4 = JTBToolkit.makeNodeToken(n5); | ||
2161 | n1.addNode(n4); | ||
2162 | n7 = jj_consume_token(57); | ||
2163 | n6 = JTBToolkit.makeNodeToken(n7); | ||
2164 | n1.addNode(n6); | ||
2165 | n0 = new NodeChoice(n1, 0); | ||
2166 | break; | ||
2167 | case CONTINUE: | ||
2168 | n8 = new NodeSequence(2); | ||
2169 | n10 = jj_consume_token(CONTINUE); | ||
2170 | n9 = JTBToolkit.makeNodeToken(n10); | ||
2171 | n8.addNode(n9); | ||
2172 | n12 = jj_consume_token(57); | ||
2173 | n11 = JTBToolkit.makeNodeToken(n12); | ||
2174 | n8.addNode(n11); | ||
2175 | n0 = new NodeChoice(n8, 1); | ||
2176 | break; | ||
2177 | case BREAK: | ||
2178 | n13 = new NodeSequence(2); | ||
2179 | n15 = jj_consume_token(BREAK); | ||
2180 | n14 = JTBToolkit.makeNodeToken(n15); | ||
2181 | n13.addNode(n14); | ||
2182 | n17 = jj_consume_token(57); | ||
2183 | n16 = JTBToolkit.makeNodeToken(n17); | ||
2184 | n13.addNode(n16); | ||
2185 | n0 = new NodeChoice(n13, 2); | ||
2186 | break; | ||
2187 | case RETURN: | ||
2188 | n18 = new NodeSequence(3); | ||
2189 | n20 = jj_consume_token(RETURN); | ||
2190 | n19 = JTBToolkit.makeNodeToken(n20); | ||
2191 | n18.addNode(n19); | ||
2192 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2193 | case INTEGER_LITERAL: | ||
2194 | case FLOATING_POINT_LITERAL: | ||
2195 | case CHARACTER_LITERAL: | ||
2196 | case STRING_LITERAL: | ||
2197 | case SIZEOF: | ||
2198 | case IDENTIFIER: | ||
2199 | case 55: | ||
2200 | case 58: | ||
2201 | case 82: | ||
2202 | case 91: | ||
2203 | case 92: | ||
2204 | case 95: | ||
2205 | case 96: | ||
2206 | case 97: | ||
2207 | case 98: | ||
2208 | n22 = Expression(); | ||
2209 | n21.addNode(n22); | ||
2210 | break; | ||
2211 | default: | ||
2212 | jj_la1[64] = jj_gen; | ||
2213 | ; | ||
2214 | } | ||
2215 | n18.addNode(n21); | ||
2216 | n24 = jj_consume_token(57); | ||
2217 | n23 = JTBToolkit.makeNodeToken(n24); | ||
2218 | n18.addNode(n23); | ||
2219 | n0 = new NodeChoice(n18, 3); | ||
2220 | break; | ||
2221 | default: | ||
2222 | jj_la1[65] = jj_gen; | ||
2223 | jj_consume_token(-1); | ||
2224 | throw new ParseException(); | ||
2225 | } | ||
2226 | {if (true) return new JumpStatement(n0);} | ||
2227 | throw new Error("Missing return statement in function"); | ||
2228 | } | ||
2229 | |||
2230 | final public Expression Expression() throws ParseException { | ||
2231 | AssignmentExpression n0; | ||
2232 | NodeListOptional n1 = new NodeListOptional(); | ||
2233 | NodeSequence n2; | ||
2234 | NodeToken n3; | ||
2235 | Token n4; | ||
2236 | AssignmentExpression n5; | ||
2237 | n0 = AssignmentExpression(); | ||
2238 | label_11: | ||
2239 | while (true) { | ||
2240 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2241 | case 59: | ||
2242 | ; | ||
2243 | break; | ||
2244 | default: | ||
2245 | jj_la1[66] = jj_gen; | ||
2246 | break label_11; | ||
2247 | } | ||
2248 | n2 = new NodeSequence(2); | ||
2249 | n4 = jj_consume_token(59); | ||
2250 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2251 | n2.addNode(n3); | ||
2252 | n5 = AssignmentExpression(); | ||
2253 | n2.addNode(n5); | ||
2254 | n1.addNode(n2); | ||
2255 | } | ||
2256 | n1.nodes.trimToSize(); | ||
2257 | {if (true) return new Expression(n0,n1);} | ||
2258 | throw new Error("Missing return statement in function"); | ||
2259 | } | ||
2260 | |||
2261 | final public AssignmentExpression AssignmentExpression() throws ParseException { | ||
2262 | NodeChoice n0; | ||
2263 | NodeSequence n1; | ||
2264 | UnaryExpression n2; | ||
2265 | AssignmentOperator n3; | ||
2266 | AssignmentExpression n4; | ||
2267 | ConditionalExpression n5; | ||
2268 | if (jj_2_13(2147483647)) { | ||
2269 | n1 = new NodeSequence(4); | ||
2270 | n2 = UnaryExpression(); | ||
2271 | n1.addNode(n2); | ||
2272 | n3 = AssignmentOperator(); | ||
2273 | n1.addNode(n3); | ||
2274 | n4 = AssignmentExpression(); | ||
2275 | n1.addNode(n4); | ||
2276 | n0 = new NodeChoice(n1, 0); | ||
2277 | } else if (jj_2_14(3)) { | ||
2278 | n5 = ConditionalExpression(); | ||
2279 | n0 = new NodeChoice(n5, 1); | ||
2280 | } else { | ||
2281 | jj_consume_token(-1); | ||
2282 | throw new ParseException(); | ||
2283 | } | ||
2284 | {if (true) return new AssignmentExpression(n0);} | ||
2285 | throw new Error("Missing return statement in function"); | ||
2286 | } | ||
2287 | |||
2288 | final public AssignmentOperator AssignmentOperator() throws ParseException { | ||
2289 | NodeChoice n0; | ||
2290 | NodeToken n1; | ||
2291 | Token n2; | ||
2292 | NodeToken n3; | ||
2293 | Token n4; | ||
2294 | NodeToken n5; | ||
2295 | Token n6; | ||
2296 | NodeToken n7; | ||
2297 | Token n8; | ||
2298 | NodeToken n9; | ||
2299 | Token n10; | ||
2300 | NodeToken n11; | ||
2301 | Token n12; | ||
2302 | NodeToken n13; | ||
2303 | Token n14; | ||
2304 | NodeToken n15; | ||
2305 | Token n16; | ||
2306 | NodeToken n17; | ||
2307 | Token n18; | ||
2308 | NodeToken n19; | ||
2309 | Token n20; | ||
2310 | NodeToken n21; | ||
2311 | Token n22; | ||
2312 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2313 | case 63: | ||
2314 | n2 = jj_consume_token(63); | ||
2315 | n1 = JTBToolkit.makeNodeToken(n2); | ||
2316 | n0 = new NodeChoice(n1, 0); | ||
2317 | break; | ||
2318 | case 67: | ||
2319 | n4 = jj_consume_token(67); | ||
2320 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2321 | n0 = new NodeChoice(n3, 1); | ||
2322 | break; | ||
2323 | case 68: | ||
2324 | n6 = jj_consume_token(68); | ||
2325 | n5 = JTBToolkit.makeNodeToken(n6); | ||
2326 | n0 = new NodeChoice(n5, 2); | ||
2327 | break; | ||
2328 | case 69: | ||
2329 | n8 = jj_consume_token(69); | ||
2330 | n7 = JTBToolkit.makeNodeToken(n8); | ||
2331 | n0 = new NodeChoice(n7, 3); | ||
2332 | break; | ||
2333 | case 70: | ||
2334 | n10 = jj_consume_token(70); | ||
2335 | n9 = JTBToolkit.makeNodeToken(n10); | ||
2336 | n0 = new NodeChoice(n9, 4); | ||
2337 | break; | ||
2338 | case 71: | ||
2339 | n12 = jj_consume_token(71); | ||
2340 | n11 = JTBToolkit.makeNodeToken(n12); | ||
2341 | n0 = new NodeChoice(n11, 5); | ||
2342 | break; | ||
2343 | case 72: | ||
2344 | n14 = jj_consume_token(72); | ||
2345 | n13 = JTBToolkit.makeNodeToken(n14); | ||
2346 | n0 = new NodeChoice(n13, 6); | ||
2347 | break; | ||
2348 | case 73: | ||
2349 | n16 = jj_consume_token(73); | ||
2350 | n15 = JTBToolkit.makeNodeToken(n16); | ||
2351 | n0 = new NodeChoice(n15, 7); | ||
2352 | break; | ||
2353 | case 74: | ||
2354 | n18 = jj_consume_token(74); | ||
2355 | n17 = JTBToolkit.makeNodeToken(n18); | ||
2356 | n0 = new NodeChoice(n17, 8); | ||
2357 | break; | ||
2358 | case 75: | ||
2359 | n20 = jj_consume_token(75); | ||
2360 | n19 = JTBToolkit.makeNodeToken(n20); | ||
2361 | n0 = new NodeChoice(n19, 9); | ||
2362 | break; | ||
2363 | case 76: | ||
2364 | n22 = jj_consume_token(76); | ||
2365 | n21 = JTBToolkit.makeNodeToken(n22); | ||
2366 | n0 = new NodeChoice(n21, 10); | ||
2367 | break; | ||
2368 | default: | ||
2369 | jj_la1[67] = jj_gen; | ||
2370 | jj_consume_token(-1); | ||
2371 | throw new ParseException(); | ||
2372 | } | ||
2373 | {if (true) return new AssignmentOperator(n0);} | ||
2374 | throw new Error("Missing return statement in function"); | ||
2375 | } | ||
2376 | |||
2377 | final public ConditionalExpression ConditionalExpression() throws ParseException { | ||
2378 | LogicalORExpression n0; | ||
2379 | NodeOptional n1 = new NodeOptional(); | ||
2380 | NodeSequence n2; | ||
2381 | NodeToken n3; | ||
2382 | Token n4; | ||
2383 | Expression n5; | ||
2384 | NodeToken n6; | ||
2385 | Token n7; | ||
2386 | ConditionalExpression n8; | ||
2387 | n0 = LogicalORExpression(); | ||
2388 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2389 | case 77: | ||
2390 | n2 = new NodeSequence(4); | ||
2391 | n4 = jj_consume_token(77); | ||
2392 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2393 | n2.addNode(n3); | ||
2394 | n5 = Expression(); | ||
2395 | n2.addNode(n5); | ||
2396 | n7 = jj_consume_token(64); | ||
2397 | n6 = JTBToolkit.makeNodeToken(n7); | ||
2398 | n2.addNode(n6); | ||
2399 | n8 = ConditionalExpression(); | ||
2400 | n2.addNode(n8); | ||
2401 | n1.addNode(n2); | ||
2402 | break; | ||
2403 | default: | ||
2404 | jj_la1[68] = jj_gen; | ||
2405 | ; | ||
2406 | } | ||
2407 | {if (true) return new ConditionalExpression(n0,n1);} | ||
2408 | throw new Error("Missing return statement in function"); | ||
2409 | } | ||
2410 | |||
2411 | final public ConstantExpression ConstantExpression() throws ParseException { | ||
2412 | ConditionalExpression n0; | ||
2413 | n0 = ConditionalExpression(); | ||
2414 | {if (true) return new ConstantExpression(n0);} | ||
2415 | throw new Error("Missing return statement in function"); | ||
2416 | } | ||
2417 | |||
2418 | final public LogicalORExpression LogicalORExpression() throws ParseException { | ||
2419 | LogicalANDExpression n0; | ||
2420 | NodeOptional n1 = new NodeOptional(); | ||
2421 | NodeSequence n2; | ||
2422 | NodeToken n3; | ||
2423 | Token n4; | ||
2424 | LogicalORExpression n5; | ||
2425 | n0 = LogicalANDExpression(); | ||
2426 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2427 | case 78: | ||
2428 | n2 = new NodeSequence(2); | ||
2429 | n4 = jj_consume_token(78); | ||
2430 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2431 | n2.addNode(n3); | ||
2432 | n5 = LogicalORExpression(); | ||
2433 | n2.addNode(n5); | ||
2434 | n1.addNode(n2); | ||
2435 | break; | ||
2436 | default: | ||
2437 | jj_la1[69] = jj_gen; | ||
2438 | ; | ||
2439 | } | ||
2440 | {if (true) return new LogicalORExpression(n0,n1);} | ||
2441 | throw new Error("Missing return statement in function"); | ||
2442 | } | ||
2443 | |||
2444 | final public LogicalANDExpression LogicalANDExpression() throws ParseException { | ||
2445 | InclusiveORExpression n0; | ||
2446 | NodeOptional n1 = new NodeOptional(); | ||
2447 | NodeSequence n2; | ||
2448 | NodeToken n3; | ||
2449 | Token n4; | ||
2450 | LogicalANDExpression n5; | ||
2451 | n0 = InclusiveORExpression(); | ||
2452 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2453 | case 79: | ||
2454 | n2 = new NodeSequence(2); | ||
2455 | n4 = jj_consume_token(79); | ||
2456 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2457 | n2.addNode(n3); | ||
2458 | n5 = LogicalANDExpression(); | ||
2459 | n2.addNode(n5); | ||
2460 | n1.addNode(n2); | ||
2461 | break; | ||
2462 | default: | ||
2463 | jj_la1[70] = jj_gen; | ||
2464 | ; | ||
2465 | } | ||
2466 | {if (true) return new LogicalANDExpression(n0,n1);} | ||
2467 | throw new Error("Missing return statement in function"); | ||
2468 | } | ||
2469 | |||
2470 | final public InclusiveORExpression InclusiveORExpression() throws ParseException { | ||
2471 | ExclusiveORExpression n0; | ||
2472 | NodeOptional n1 = new NodeOptional(); | ||
2473 | NodeSequence n2; | ||
2474 | NodeToken n3; | ||
2475 | Token n4; | ||
2476 | InclusiveORExpression n5; | ||
2477 | n0 = ExclusiveORExpression(); | ||
2478 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2479 | case 80: | ||
2480 | n2 = new NodeSequence(2); | ||
2481 | n4 = jj_consume_token(80); | ||
2482 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2483 | n2.addNode(n3); | ||
2484 | n5 = InclusiveORExpression(); | ||
2485 | n2.addNode(n5); | ||
2486 | n1.addNode(n2); | ||
2487 | break; | ||
2488 | default: | ||
2489 | jj_la1[71] = jj_gen; | ||
2490 | ; | ||
2491 | } | ||
2492 | {if (true) return new InclusiveORExpression(n0,n1);} | ||
2493 | throw new Error("Missing return statement in function"); | ||
2494 | } | ||
2495 | |||
2496 | final public ExclusiveORExpression ExclusiveORExpression() throws ParseException { | ||
2497 | ANDExpression n0; | ||
2498 | NodeOptional n1 = new NodeOptional(); | ||
2499 | NodeSequence n2; | ||
2500 | NodeToken n3; | ||
2501 | Token n4; | ||
2502 | ExclusiveORExpression n5; | ||
2503 | n0 = ANDExpression(); | ||
2504 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2505 | case 81: | ||
2506 | n2 = new NodeSequence(2); | ||
2507 | n4 = jj_consume_token(81); | ||
2508 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2509 | n2.addNode(n3); | ||
2510 | n5 = ExclusiveORExpression(); | ||
2511 | n2.addNode(n5); | ||
2512 | n1.addNode(n2); | ||
2513 | break; | ||
2514 | default: | ||
2515 | jj_la1[72] = jj_gen; | ||
2516 | ; | ||
2517 | } | ||
2518 | {if (true) return new ExclusiveORExpression(n0,n1);} | ||
2519 | throw new Error("Missing return statement in function"); | ||
2520 | } | ||
2521 | |||
2522 | final public ANDExpression ANDExpression() throws ParseException { | ||
2523 | EqualityExpression n0; | ||
2524 | NodeOptional n1 = new NodeOptional(); | ||
2525 | NodeSequence n2; | ||
2526 | NodeToken n3; | ||
2527 | Token n4; | ||
2528 | ANDExpression n5; | ||
2529 | n0 = EqualityExpression(); | ||
2530 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2531 | case 82: | ||
2532 | n2 = new NodeSequence(2); | ||
2533 | n4 = jj_consume_token(82); | ||
2534 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2535 | n2.addNode(n3); | ||
2536 | n5 = ANDExpression(); | ||
2537 | n2.addNode(n5); | ||
2538 | n1.addNode(n2); | ||
2539 | break; | ||
2540 | default: | ||
2541 | jj_la1[73] = jj_gen; | ||
2542 | ; | ||
2543 | } | ||
2544 | {if (true) return new ANDExpression(n0,n1);} | ||
2545 | throw new Error("Missing return statement in function"); | ||
2546 | } | ||
2547 | |||
2548 | final public EqualityExpression EqualityExpression() throws ParseException { | ||
2549 | RelationalExpression n0; | ||
2550 | NodeOptional n1 = new NodeOptional(); | ||
2551 | NodeSequence n2; | ||
2552 | NodeChoice n3; | ||
2553 | NodeToken n4; | ||
2554 | Token n5; | ||
2555 | NodeToken n6; | ||
2556 | Token n7; | ||
2557 | EqualityExpression n8; | ||
2558 | n0 = RelationalExpression(); | ||
2559 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2560 | case 83: | ||
2561 | case 84: | ||
2562 | n2 = new NodeSequence(2); | ||
2563 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2564 | case 83: | ||
2565 | n5 = jj_consume_token(83); | ||
2566 | n4 = JTBToolkit.makeNodeToken(n5); | ||
2567 | n3 = new NodeChoice(n4, 0); | ||
2568 | break; | ||
2569 | case 84: | ||
2570 | n7 = jj_consume_token(84); | ||
2571 | n6 = JTBToolkit.makeNodeToken(n7); | ||
2572 | n3 = new NodeChoice(n6, 1); | ||
2573 | break; | ||
2574 | default: | ||
2575 | jj_la1[74] = jj_gen; | ||
2576 | jj_consume_token(-1); | ||
2577 | throw new ParseException(); | ||
2578 | } | ||
2579 | n2.addNode(n3); | ||
2580 | n8 = EqualityExpression(); | ||
2581 | n2.addNode(n8); | ||
2582 | n1.addNode(n2); | ||
2583 | break; | ||
2584 | default: | ||
2585 | jj_la1[75] = jj_gen; | ||
2586 | ; | ||
2587 | } | ||
2588 | {if (true) return new EqualityExpression(n0,n1);} | ||
2589 | throw new Error("Missing return statement in function"); | ||
2590 | } | ||
2591 | |||
2592 | final public RelationalExpression RelationalExpression() throws ParseException { | ||
2593 | ShiftExpression n0; | ||
2594 | NodeOptional n1 = new NodeOptional(); | ||
2595 | NodeSequence n2; | ||
2596 | NodeChoice n3; | ||
2597 | NodeToken n4; | ||
2598 | Token n5; | ||
2599 | NodeToken n6; | ||
2600 | Token n7; | ||
2601 | NodeToken n8; | ||
2602 | Token n9; | ||
2603 | NodeToken n10; | ||
2604 | Token n11; | ||
2605 | RelationalExpression n12; | ||
2606 | n0 = ShiftExpression(); | ||
2607 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2608 | case 85: | ||
2609 | case 86: | ||
2610 | case 87: | ||
2611 | case 88: | ||
2612 | n2 = new NodeSequence(2); | ||
2613 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2614 | case 85: | ||
2615 | n5 = jj_consume_token(85); | ||
2616 | n4 = JTBToolkit.makeNodeToken(n5); | ||
2617 | n3 = new NodeChoice(n4, 0); | ||
2618 | break; | ||
2619 | case 86: | ||
2620 | n7 = jj_consume_token(86); | ||
2621 | n6 = JTBToolkit.makeNodeToken(n7); | ||
2622 | n3 = new NodeChoice(n6, 1); | ||
2623 | break; | ||
2624 | case 87: | ||
2625 | n9 = jj_consume_token(87); | ||
2626 | n8 = JTBToolkit.makeNodeToken(n9); | ||
2627 | n3 = new NodeChoice(n8, 2); | ||
2628 | break; | ||
2629 | case 88: | ||
2630 | n11 = jj_consume_token(88); | ||
2631 | n10 = JTBToolkit.makeNodeToken(n11); | ||
2632 | n3 = new NodeChoice(n10, 3); | ||
2633 | break; | ||
2634 | default: | ||
2635 | jj_la1[76] = jj_gen; | ||
2636 | jj_consume_token(-1); | ||
2637 | throw new ParseException(); | ||
2638 | } | ||
2639 | n2.addNode(n3); | ||
2640 | n12 = RelationalExpression(); | ||
2641 | n2.addNode(n12); | ||
2642 | n1.addNode(n2); | ||
2643 | break; | ||
2644 | default: | ||
2645 | jj_la1[77] = jj_gen; | ||
2646 | ; | ||
2647 | } | ||
2648 | {if (true) return new RelationalExpression(n0,n1);} | ||
2649 | throw new Error("Missing return statement in function"); | ||
2650 | } | ||
2651 | |||
2652 | final public ShiftExpression ShiftExpression() throws ParseException { | ||
2653 | AdditiveExpression n0; | ||
2654 | NodeOptional n1 = new NodeOptional(); | ||
2655 | NodeSequence n2; | ||
2656 | NodeChoice n3; | ||
2657 | NodeToken n4; | ||
2658 | Token n5; | ||
2659 | NodeToken n6; | ||
2660 | Token n7; | ||
2661 | ShiftExpression n8; | ||
2662 | n0 = AdditiveExpression(); | ||
2663 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2664 | case 89: | ||
2665 | case 90: | ||
2666 | n2 = new NodeSequence(2); | ||
2667 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2668 | case 89: | ||
2669 | n5 = jj_consume_token(89); | ||
2670 | n4 = JTBToolkit.makeNodeToken(n5); | ||
2671 | n3 = new NodeChoice(n4, 0); | ||
2672 | break; | ||
2673 | case 90: | ||
2674 | n7 = jj_consume_token(90); | ||
2675 | n6 = JTBToolkit.makeNodeToken(n7); | ||
2676 | n3 = new NodeChoice(n6, 1); | ||
2677 | break; | ||
2678 | default: | ||
2679 | jj_la1[78] = jj_gen; | ||
2680 | jj_consume_token(-1); | ||
2681 | throw new ParseException(); | ||
2682 | } | ||
2683 | n2.addNode(n3); | ||
2684 | n8 = ShiftExpression(); | ||
2685 | n2.addNode(n8); | ||
2686 | n1.addNode(n2); | ||
2687 | break; | ||
2688 | default: | ||
2689 | jj_la1[79] = jj_gen; | ||
2690 | ; | ||
2691 | } | ||
2692 | {if (true) return new ShiftExpression(n0,n1);} | ||
2693 | throw new Error("Missing return statement in function"); | ||
2694 | } | ||
2695 | |||
2696 | final public AdditiveExpression AdditiveExpression() throws ParseException { | ||
2697 | MultiplicativeExpression n0; | ||
2698 | NodeOptional n1 = new NodeOptional(); | ||
2699 | NodeSequence n2; | ||
2700 | NodeChoice n3; | ||
2701 | NodeToken n4; | ||
2702 | Token n5; | ||
2703 | NodeToken n6; | ||
2704 | Token n7; | ||
2705 | AdditiveExpression n8; | ||
2706 | n0 = MultiplicativeExpression(); | ||
2707 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2708 | case 91: | ||
2709 | case 92: | ||
2710 | n2 = new NodeSequence(2); | ||
2711 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2712 | case 91: | ||
2713 | n5 = jj_consume_token(91); | ||
2714 | n4 = JTBToolkit.makeNodeToken(n5); | ||
2715 | n3 = new NodeChoice(n4, 0); | ||
2716 | break; | ||
2717 | case 92: | ||
2718 | n7 = jj_consume_token(92); | ||
2719 | n6 = JTBToolkit.makeNodeToken(n7); | ||
2720 | n3 = new NodeChoice(n6, 1); | ||
2721 | break; | ||
2722 | default: | ||
2723 | jj_la1[80] = jj_gen; | ||
2724 | jj_consume_token(-1); | ||
2725 | throw new ParseException(); | ||
2726 | } | ||
2727 | n2.addNode(n3); | ||
2728 | n8 = AdditiveExpression(); | ||
2729 | n2.addNode(n8); | ||
2730 | n1.addNode(n2); | ||
2731 | break; | ||
2732 | default: | ||
2733 | jj_la1[81] = jj_gen; | ||
2734 | ; | ||
2735 | } | ||
2736 | {if (true) return new AdditiveExpression(n0,n1);} | ||
2737 | throw new Error("Missing return statement in function"); | ||
2738 | } | ||
2739 | |||
2740 | final public MultiplicativeExpression MultiplicativeExpression() throws ParseException { | ||
2741 | CastExpression n0; | ||
2742 | NodeOptional n1 = new NodeOptional(); | ||
2743 | NodeSequence n2; | ||
2744 | NodeChoice n3; | ||
2745 | NodeToken n4; | ||
2746 | Token n5; | ||
2747 | NodeToken n6; | ||
2748 | Token n7; | ||
2749 | NodeToken n8; | ||
2750 | Token n9; | ||
2751 | MultiplicativeExpression n10; | ||
2752 | n0 = CastExpression(); | ||
2753 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2754 | case 58: | ||
2755 | case 93: | ||
2756 | case 94: | ||
2757 | n2 = new NodeSequence(2); | ||
2758 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2759 | case 58: | ||
2760 | n5 = jj_consume_token(58); | ||
2761 | n4 = JTBToolkit.makeNodeToken(n5); | ||
2762 | n3 = new NodeChoice(n4, 0); | ||
2763 | break; | ||
2764 | case 93: | ||
2765 | n7 = jj_consume_token(93); | ||
2766 | n6 = JTBToolkit.makeNodeToken(n7); | ||
2767 | n3 = new NodeChoice(n6, 1); | ||
2768 | break; | ||
2769 | case 94: | ||
2770 | n9 = jj_consume_token(94); | ||
2771 | n8 = JTBToolkit.makeNodeToken(n9); | ||
2772 | n3 = new NodeChoice(n8, 2); | ||
2773 | break; | ||
2774 | default: | ||
2775 | jj_la1[82] = jj_gen; | ||
2776 | jj_consume_token(-1); | ||
2777 | throw new ParseException(); | ||
2778 | } | ||
2779 | n2.addNode(n3); | ||
2780 | n10 = MultiplicativeExpression(); | ||
2781 | n2.addNode(n10); | ||
2782 | n1.addNode(n2); | ||
2783 | break; | ||
2784 | default: | ||
2785 | jj_la1[83] = jj_gen; | ||
2786 | ; | ||
2787 | } | ||
2788 | {if (true) return new MultiplicativeExpression(n0,n1);} | ||
2789 | throw new Error("Missing return statement in function"); | ||
2790 | } | ||
2791 | |||
2792 | final public CastExpression CastExpression() throws ParseException { | ||
2793 | NodeChoice n0; | ||
2794 | NodeSequence n1; | ||
2795 | NodeToken n2; | ||
2796 | Token n3; | ||
2797 | TypeSpecifier n4; | ||
2798 | NodeToken n5; | ||
2799 | Token n6; | ||
2800 | CastExpression n7; | ||
2801 | UnaryExpression n8; | ||
2802 | if (jj_2_15(2147483647)) { | ||
2803 | n1 = new NodeSequence(5); | ||
2804 | n3 = jj_consume_token(55); | ||
2805 | n2 = JTBToolkit.makeNodeToken(n3); | ||
2806 | n1.addNode(n2); | ||
2807 | n4 = TypeSpecifier(); | ||
2808 | n1.addNode(n4); | ||
2809 | n6 = jj_consume_token(56); | ||
2810 | n5 = JTBToolkit.makeNodeToken(n6); | ||
2811 | n1.addNode(n5); | ||
2812 | n7 = CastExpression(); | ||
2813 | n1.addNode(n7); | ||
2814 | n0 = new NodeChoice(n1, 0); | ||
2815 | } else { | ||
2816 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2817 | case INTEGER_LITERAL: | ||
2818 | case FLOATING_POINT_LITERAL: | ||
2819 | case CHARACTER_LITERAL: | ||
2820 | case STRING_LITERAL: | ||
2821 | case SIZEOF: | ||
2822 | case IDENTIFIER: | ||
2823 | case 55: | ||
2824 | case 58: | ||
2825 | case 82: | ||
2826 | case 91: | ||
2827 | case 92: | ||
2828 | case 95: | ||
2829 | case 96: | ||
2830 | case 97: | ||
2831 | case 98: | ||
2832 | n8 = UnaryExpression(); | ||
2833 | n0 = new NodeChoice(n8, 1); | ||
2834 | break; | ||
2835 | default: | ||
2836 | jj_la1[84] = jj_gen; | ||
2837 | jj_consume_token(-1); | ||
2838 | throw new ParseException(); | ||
2839 | } | ||
2840 | } | ||
2841 | {if (true) return new CastExpression(n0);} | ||
2842 | throw new Error("Missing return statement in function"); | ||
2843 | } | ||
2844 | |||
2845 | final public UnaryExpression UnaryExpression() throws ParseException { | ||
2846 | NodeChoice n0; | ||
2847 | PostfixExpression n1; | ||
2848 | NodeSequence n2; | ||
2849 | NodeToken n3; | ||
2850 | Token n4; | ||
2851 | UnaryExpression n5; | ||
2852 | NodeSequence n6; | ||
2853 | NodeToken n7; | ||
2854 | Token n8; | ||
2855 | UnaryExpression n9; | ||
2856 | NodeSequence n10; | ||
2857 | UnaryOperator n11; | ||
2858 | CastExpression n12; | ||
2859 | NodeSequence n13; | ||
2860 | NodeToken n14; | ||
2861 | Token n15; | ||
2862 | NodeChoice n16; | ||
2863 | UnaryExpression n17; | ||
2864 | NodeSequence n18; | ||
2865 | NodeToken n19; | ||
2866 | Token n20; | ||
2867 | TypeSpecifier n21; | ||
2868 | NodeToken n22; | ||
2869 | Token n23; | ||
2870 | if (jj_2_17(3)) { | ||
2871 | n1 = PostfixExpression(); | ||
2872 | n0 = new NodeChoice(n1, 0); | ||
2873 | } else { | ||
2874 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2875 | case 95: | ||
2876 | n2 = new NodeSequence(2); | ||
2877 | n4 = jj_consume_token(95); | ||
2878 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2879 | n2.addNode(n3); | ||
2880 | n5 = UnaryExpression(); | ||
2881 | n2.addNode(n5); | ||
2882 | n0 = new NodeChoice(n2, 1); | ||
2883 | break; | ||
2884 | case 96: | ||
2885 | n6 = new NodeSequence(2); | ||
2886 | n8 = jj_consume_token(96); | ||
2887 | n7 = JTBToolkit.makeNodeToken(n8); | ||
2888 | n6.addNode(n7); | ||
2889 | n9 = UnaryExpression(); | ||
2890 | n6.addNode(n9); | ||
2891 | n0 = new NodeChoice(n6, 2); | ||
2892 | break; | ||
2893 | case 58: | ||
2894 | case 82: | ||
2895 | case 91: | ||
2896 | case 92: | ||
2897 | case 97: | ||
2898 | case 98: | ||
2899 | n10 = new NodeSequence(2); | ||
2900 | n11 = UnaryOperator(); | ||
2901 | n10.addNode(n11); | ||
2902 | n12 = CastExpression(); | ||
2903 | n10.addNode(n12); | ||
2904 | n0 = new NodeChoice(n10, 3); | ||
2905 | break; | ||
2906 | case SIZEOF: | ||
2907 | n13 = new NodeSequence(2); | ||
2908 | n15 = jj_consume_token(SIZEOF); | ||
2909 | n14 = JTBToolkit.makeNodeToken(n15); | ||
2910 | n13.addNode(n14); | ||
2911 | if (jj_2_16(2147483647)) { | ||
2912 | n17 = UnaryExpression(); | ||
2913 | n16 = new NodeChoice(n17, 0); | ||
2914 | } else { | ||
2915 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2916 | case 55: | ||
2917 | n18 = new NodeSequence(3); | ||
2918 | n20 = jj_consume_token(55); | ||
2919 | n19 = JTBToolkit.makeNodeToken(n20); | ||
2920 | n18.addNode(n19); | ||
2921 | n21 = TypeSpecifier(); | ||
2922 | n18.addNode(n21); | ||
2923 | n23 = jj_consume_token(56); | ||
2924 | n22 = JTBToolkit.makeNodeToken(n23); | ||
2925 | n18.addNode(n22); | ||
2926 | n16 = new NodeChoice(n18, 1); | ||
2927 | break; | ||
2928 | default: | ||
2929 | jj_la1[85] = jj_gen; | ||
2930 | jj_consume_token(-1); | ||
2931 | throw new ParseException(); | ||
2932 | } | ||
2933 | } | ||
2934 | n13.addNode(n16); | ||
2935 | n0 = new NodeChoice(n13, 4); | ||
2936 | break; | ||
2937 | default: | ||
2938 | jj_la1[86] = jj_gen; | ||
2939 | jj_consume_token(-1); | ||
2940 | throw new ParseException(); | ||
2941 | } | ||
2942 | } | ||
2943 | {if (true) return new UnaryExpression(n0);} | ||
2944 | throw new Error("Missing return statement in function"); | ||
2945 | } | ||
2946 | |||
2947 | final public UnaryOperator UnaryOperator() throws ParseException { | ||
2948 | NodeChoice n0; | ||
2949 | NodeToken n1; | ||
2950 | Token n2; | ||
2951 | NodeToken n3; | ||
2952 | Token n4; | ||
2953 | NodeToken n5; | ||
2954 | Token n6; | ||
2955 | NodeToken n7; | ||
2956 | Token n8; | ||
2957 | NodeToken n9; | ||
2958 | Token n10; | ||
2959 | NodeToken n11; | ||
2960 | Token n12; | ||
2961 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2962 | case 82: | ||
2963 | n2 = jj_consume_token(82); | ||
2964 | n1 = JTBToolkit.makeNodeToken(n2); | ||
2965 | n0 = new NodeChoice(n1, 0); | ||
2966 | break; | ||
2967 | case 58: | ||
2968 | n4 = jj_consume_token(58); | ||
2969 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2970 | n0 = new NodeChoice(n3, 1); | ||
2971 | break; | ||
2972 | case 91: | ||
2973 | n6 = jj_consume_token(91); | ||
2974 | n5 = JTBToolkit.makeNodeToken(n6); | ||
2975 | n0 = new NodeChoice(n5, 2); | ||
2976 | break; | ||
2977 | case 92: | ||
2978 | n8 = jj_consume_token(92); | ||
2979 | n7 = JTBToolkit.makeNodeToken(n8); | ||
2980 | n0 = new NodeChoice(n7, 3); | ||
2981 | break; | ||
2982 | case 97: | ||
2983 | n10 = jj_consume_token(97); | ||
2984 | n9 = JTBToolkit.makeNodeToken(n10); | ||
2985 | n0 = new NodeChoice(n9, 4); | ||
2986 | break; | ||
2987 | case 98: | ||
2988 | n12 = jj_consume_token(98); | ||
2989 | n11 = JTBToolkit.makeNodeToken(n12); | ||
2990 | n0 = new NodeChoice(n11, 5); | ||
2991 | break; | ||
2992 | default: | ||
2993 | jj_la1[87] = jj_gen; | ||
2994 | jj_consume_token(-1); | ||
2995 | throw new ParseException(); | ||
2996 | } | ||
2997 | {if (true) return new UnaryOperator(n0);} | ||
2998 | throw new Error("Missing return statement in function"); | ||
2999 | } | ||
3000 | |||
3001 | final public PostfixExpression PostfixExpression() throws ParseException { | ||
3002 | PrimaryExpression n0; | ||
3003 | NodeListOptional n1 = new NodeListOptional(); | ||
3004 | NodeChoice n2; | ||
3005 | NodeSequence n3; | ||
3006 | NodeToken n4; | ||
3007 | Token n5; | ||
3008 | Expression n6; | ||
3009 | NodeToken n7; | ||
3010 | Token n8; | ||
3011 | NodeSequence n9; | ||
3012 | NodeToken n10; | ||
3013 | Token n11; | ||
3014 | NodeOptional n12; | ||
3015 | ArgumentExpressionList n13; | ||
3016 | NodeToken n14; | ||
3017 | Token n15; | ||
3018 | NodeSequence n16; | ||
3019 | NodeToken n17; | ||
3020 | Token n18; | ||
3021 | NodeToken n19; | ||
3022 | Token n20; | ||
3023 | NodeSequence n21; | ||
3024 | NodeToken n22; | ||
3025 | Token n23; | ||
3026 | NodeToken n24; | ||
3027 | Token n25; | ||
3028 | NodeToken n26; | ||
3029 | Token n27; | ||
3030 | NodeToken n28; | ||
3031 | Token n29; | ||
3032 | n0 = PrimaryExpression(); | ||
3033 | label_12: | ||
3034 | while (true) { | ||
3035 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
3036 | case 55: | ||
3037 | case 65: | ||
3038 | case 95: | ||
3039 | case 96: | ||
3040 | case 99: | ||
3041 | case 100: | ||
3042 | ; | ||
3043 | break; | ||
3044 | default: | ||
3045 | jj_la1[88] = jj_gen; | ||
3046 | break label_12; | ||
3047 | } | ||
3048 | n12 = new NodeOptional(); | ||
3049 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
3050 | case 65: | ||
3051 | n3 = new NodeSequence(3); | ||
3052 | n5 = jj_consume_token(65); | ||
3053 | n4 = JTBToolkit.makeNodeToken(n5); | ||
3054 | n3.addNode(n4); | ||
3055 | n6 = Expression(); | ||
3056 | n3.addNode(n6); | ||
3057 | n8 = jj_consume_token(66); | ||
3058 | n7 = JTBToolkit.makeNodeToken(n8); | ||
3059 | n3.addNode(n7); | ||
3060 | n2 = new NodeChoice(n3, 0); | ||
3061 | break; | ||
3062 | case 55: | ||
3063 | n9 = new NodeSequence(3); | ||
3064 | n11 = jj_consume_token(55); | ||
3065 | n10 = JTBToolkit.makeNodeToken(n11); | ||
3066 | n9.addNode(n10); | ||
3067 | if (jj_2_18(2147483647)) { | ||
3068 | n13 = ArgumentExpressionList(); | ||
3069 | n12.addNode(n13); | ||
3070 | } else { | ||
3071 | ; | ||
3072 | } | ||
3073 | n9.addNode(n12); | ||
3074 | n15 = jj_consume_token(56); | ||
3075 | n14 = JTBToolkit.makeNodeToken(n15); | ||
3076 | n9.addNode(n14); | ||
3077 | n2 = new NodeChoice(n9, 1); | ||
3078 | break; | ||
3079 | case 99: | ||
3080 | n16 = new NodeSequence(2); | ||
3081 | n18 = jj_consume_token(99); | ||
3082 | n17 = JTBToolkit.makeNodeToken(n18); | ||
3083 | n16.addNode(n17); | ||
3084 | n20 = jj_consume_token(IDENTIFIER); | ||
3085 | n19 = JTBToolkit.makeNodeToken(n20); | ||
3086 | n16.addNode(n19); | ||
3087 | n2 = new NodeChoice(n16, 2); | ||
3088 | break; | ||
3089 | case 100: | ||
3090 | n21 = new NodeSequence(2); | ||
3091 | n23 = jj_consume_token(100); | ||
3092 | n22 = JTBToolkit.makeNodeToken(n23); | ||
3093 | n21.addNode(n22); | ||
3094 | n25 = jj_consume_token(IDENTIFIER); | ||
3095 | n24 = JTBToolkit.makeNodeToken(n25); | ||
3096 | n21.addNode(n24); | ||
3097 | n2 = new NodeChoice(n21, 3); | ||
3098 | break; | ||
3099 | case 95: | ||
3100 | n27 = jj_consume_token(95); | ||
3101 | n26 = JTBToolkit.makeNodeToken(n27); | ||
3102 | n2 = new NodeChoice(n26, 4); | ||
3103 | break; | ||
3104 | case 96: | ||
3105 | n29 = jj_consume_token(96); | ||
3106 | n28 = JTBToolkit.makeNodeToken(n29); | ||
3107 | n2 = new NodeChoice(n28, 5); | ||
3108 | break; | ||
3109 | default: | ||
3110 | jj_la1[89] = jj_gen; | ||
3111 | jj_consume_token(-1); | ||
3112 | throw new ParseException(); | ||
3113 | } | ||
3114 | n1.addNode(n2); | ||
3115 | } | ||
3116 | n1.nodes.trimToSize(); | ||
3117 | {if (true) return new PostfixExpression(n0,n1);} | ||
3118 | throw new Error("Missing return statement in function"); | ||
3119 | } | ||
3120 | |||
3121 | final public PrimaryExpression PrimaryExpression() throws ParseException { | ||
3122 | NodeChoice n0; | ||
3123 | NodeToken n1; | ||
3124 | Token n2; | ||
3125 | Constant n3; | ||
3126 | NodeSequence n4; | ||
3127 | NodeToken n5; | ||
3128 | Token n6; | ||
3129 | Expression n7; | ||
3130 | NodeToken n8; | ||
3131 | Token n9; | ||
3132 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
3133 | case IDENTIFIER: | ||
3134 | n2 = jj_consume_token(IDENTIFIER); | ||
3135 | n1 = JTBToolkit.makeNodeToken(n2); | ||
3136 | n0 = new NodeChoice(n1, 0); | ||
3137 | break; | ||
3138 | case INTEGER_LITERAL: | ||
3139 | case FLOATING_POINT_LITERAL: | ||
3140 | case CHARACTER_LITERAL: | ||
3141 | case STRING_LITERAL: | ||
3142 | n3 = Constant(); | ||
3143 | n0 = new NodeChoice(n3, 1); | ||
3144 | break; | ||
3145 | case 55: | ||
3146 | n4 = new NodeSequence(3); | ||
3147 | n6 = jj_consume_token(55); | ||
3148 | n5 = JTBToolkit.makeNodeToken(n6); | ||
3149 | n4.addNode(n5); | ||
3150 | n7 = Expression(); | ||
3151 | n4.addNode(n7); | ||
3152 | n9 = jj_consume_token(56); | ||
3153 | n8 = JTBToolkit.makeNodeToken(n9); | ||
3154 | n4.addNode(n8); | ||
3155 | n0 = new NodeChoice(n4, 2); | ||
3156 | break; | ||
3157 | default: | ||
3158 | jj_la1[90] = jj_gen; | ||
3159 | jj_consume_token(-1); | ||
3160 | throw new ParseException(); | ||
3161 | } | ||
3162 | {if (true) return new PrimaryExpression(n0);} | ||
3163 | throw new Error("Missing return statement in function"); | ||
3164 | } | ||
3165 | |||
3166 | final public ArgumentExpressionList ArgumentExpressionList() throws ParseException { | ||
3167 | AssignmentOrTypeExpression n0; | ||
3168 | NodeListOptional n1 = new NodeListOptional(); | ||
3169 | NodeSequence n2; | ||
3170 | NodeToken n3; | ||
3171 | Token n4; | ||
3172 | AssignmentOrTypeExpression n5; | ||
3173 | n0 = AssignmentOrTypeExpression(); | ||
3174 | label_13: | ||
3175 | while (true) { | ||
3176 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
3177 | case 59: | ||
3178 | ; | ||
3179 | break; | ||
3180 | default: | ||
3181 | jj_la1[91] = jj_gen; | ||
3182 | break label_13; | ||
3183 | } | ||
3184 | n2 = new NodeSequence(2); | ||
3185 | n4 = jj_consume_token(59); | ||
3186 | n3 = JTBToolkit.makeNodeToken(n4); | ||
3187 | n2.addNode(n3); | ||
3188 | n5 = AssignmentOrTypeExpression(); | ||
3189 | n2.addNode(n5); | ||
3190 | n1.addNode(n2); | ||
3191 | } | ||
3192 | n1.nodes.trimToSize(); | ||
3193 | {if (true) return new ArgumentExpressionList(n0,n1);} | ||
3194 | throw new Error("Missing return statement in function"); | ||
3195 | } | ||
3196 | |||
3197 | final public AssignmentOrTypeExpression AssignmentOrTypeExpression() throws ParseException { | ||
3198 | NodeChoice n0; | ||
3199 | NoIdentifierTypeSpecifier n1; | ||
3200 | AssignmentExpression n2; | ||
3201 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
3202 | case UNSIGNED: | ||
3203 | case DOUBLE: | ||
3204 | case STRUCT: | ||
3205 | case SIGNED: | ||
3206 | case UNION: | ||
3207 | case CONST: | ||
3208 | case FLOAT: | ||
3209 | case SHORT: | ||
3210 | case LONG: | ||
3211 | case ENUM: | ||
3212 | case VOID: | ||
3213 | case CHAR: | ||
3214 | case INT: | ||
3215 | n1 = NoIdentifierTypeSpecifier(); | ||
3216 | n0 = new NodeChoice(n1, 0); | ||
3217 | break; | ||
3218 | case INTEGER_LITERAL: | ||
3219 | case FLOATING_POINT_LITERAL: | ||
3220 | case CHARACTER_LITERAL: | ||
3221 | case STRING_LITERAL: | ||
3222 | case SIZEOF: | ||
3223 | case IDENTIFIER: | ||
3224 | case 55: | ||
3225 | case 58: | ||
3226 | case 82: | ||
3227 | case 91: | ||
3228 | case 92: | ||
3229 | case 95: | ||
3230 | case 96: | ||
3231 | case 97: | ||
3232 | case 98: | ||
3233 | n2 = AssignmentExpression(); | ||
3234 | n0 = new NodeChoice(n2, 1); | ||
3235 | break; | ||
3236 | default: | ||
3237 | jj_la1[92] = jj_gen; | ||
3238 | jj_consume_token(-1); | ||
3239 | throw new ParseException(); | ||
3240 | } | ||
3241 | {if (true) return new AssignmentOrTypeExpression(n0);} | ||
3242 | throw new Error("Missing return statement in function"); | ||
3243 | } | ||
3244 | |||
3245 | final public Constant Constant() throws ParseException { | ||
3246 | NodeChoice n0; | ||
3247 | NodeToken n1; | ||
3248 | Token n2; | ||
3249 | NodeToken n3; | ||
3250 | Token n4; | ||
3251 | NodeToken n5; | ||
3252 | Token n6; | ||
3253 | NodeToken n7; | ||
3254 | Token n8; | ||
3255 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
3256 | case INTEGER_LITERAL: | ||
3257 | n2 = jj_consume_token(INTEGER_LITERAL); | ||
3258 | n1 = JTBToolkit.makeNodeToken(n2); | ||
3259 | n0 = new NodeChoice(n1, 0); | ||
3260 | break; | ||
3261 | case FLOATING_POINT_LITERAL: | ||
3262 | n4 = jj_consume_token(FLOATING_POINT_LITERAL); | ||
3263 | n3 = JTBToolkit.makeNodeToken(n4); | ||
3264 | n0 = new NodeChoice(n3, 1); | ||
3265 | break; | ||
3266 | case CHARACTER_LITERAL: | ||
3267 | n6 = jj_consume_token(CHARACTER_LITERAL); | ||
3268 | n5 = JTBToolkit.makeNodeToken(n6); | ||
3269 | n0 = new NodeChoice(n5, 2); | ||
3270 | break; | ||
3271 | case STRING_LITERAL: | ||
3272 | n8 = jj_consume_token(STRING_LITERAL); | ||
3273 | n7 = JTBToolkit.makeNodeToken(n8); | ||
3274 | n0 = new NodeChoice(n7, 3); | ||
3275 | break; | ||
3276 | default: | ||
3277 | jj_la1[93] = jj_gen; | ||
3278 | jj_consume_token(-1); | ||
3279 | throw new ParseException(); | ||
3280 | } | ||
3281 | {if (true) return new Constant(n0);} | ||
3282 | throw new Error("Missing return statement in function"); | ||
3283 | } | ||
3284 | |||
3285 | private boolean jj_2_1(int xla) { | ||
3286 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3287 | try { return !jj_3_1(); } | ||
3288 | catch(LookaheadSuccess ls) { return true; } | ||
3289 | finally { jj_save(0, xla); } | ||
3290 | } | ||
3291 | |||
3292 | private boolean jj_2_2(int xla) { | ||
3293 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3294 | try { return !jj_3_2(); } | ||
3295 | catch(LookaheadSuccess ls) { return true; } | ||
3296 | finally { jj_save(1, xla); } | ||
3297 | } | ||
3298 | |||
3299 | private boolean jj_2_3(int xla) { | ||
3300 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3301 | try { return !jj_3_3(); } | ||
3302 | catch(LookaheadSuccess ls) { return true; } | ||
3303 | finally { jj_save(2, xla); } | ||
3304 | } | ||
3305 | |||
3306 | private boolean jj_2_4(int xla) { | ||
3307 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3308 | try { return !jj_3_4(); } | ||
3309 | catch(LookaheadSuccess ls) { return true; } | ||
3310 | finally { jj_save(3, xla); } | ||
3311 | } | ||
3312 | |||
3313 | private boolean jj_2_5(int xla) { | ||
3314 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3315 | try { return !jj_3_5(); } | ||
3316 | catch(LookaheadSuccess ls) { return true; } | ||
3317 | finally { jj_save(4, xla); } | ||
3318 | } | ||
3319 | |||
3320 | private boolean jj_2_6(int xla) { | ||
3321 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3322 | try { return !jj_3_6(); } | ||
3323 | catch(LookaheadSuccess ls) { return true; } | ||
3324 | finally { jj_save(5, xla); } | ||
3325 | } | ||
3326 | |||
3327 | private boolean jj_2_7(int xla) { | ||
3328 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3329 | try { return !jj_3_7(); } | ||
3330 | catch(LookaheadSuccess ls) { return true; } | ||
3331 | finally { jj_save(6, xla); } | ||
3332 | } | ||
3333 | |||
3334 | private boolean jj_2_8(int xla) { | ||
3335 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3336 | try { return !jj_3_8(); } | ||
3337 | catch(LookaheadSuccess ls) { return true; } | ||
3338 | finally { jj_save(7, xla); } | ||
3339 | } | ||
3340 | |||
3341 | private boolean jj_2_9(int xla) { | ||
3342 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3343 | try { return !jj_3_9(); } | ||
3344 | catch(LookaheadSuccess ls) { return true; } | ||
3345 | finally { jj_save(8, xla); } | ||
3346 | } | ||
3347 | |||
3348 | private boolean jj_2_10(int xla) { | ||
3349 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3350 | try { return !jj_3_10(); } | ||
3351 | catch(LookaheadSuccess ls) { return true; } | ||
3352 | finally { jj_save(9, xla); } | ||
3353 | } | ||
3354 | |||
3355 | private boolean jj_2_11(int xla) { | ||
3356 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3357 | try { return !jj_3_11(); } | ||
3358 | catch(LookaheadSuccess ls) { return true; } | ||
3359 | finally { jj_save(10, xla); } | ||
3360 | } | ||
3361 | |||
3362 | private boolean jj_2_12(int xla) { | ||
3363 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3364 | try { return !jj_3_12(); } | ||
3365 | catch(LookaheadSuccess ls) { return true; } | ||
3366 | finally { jj_save(11, xla); } | ||
3367 | } | ||
3368 | |||
3369 | private boolean jj_2_13(int xla) { | ||
3370 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3371 | try { return !jj_3_13(); } | ||
3372 | catch(LookaheadSuccess ls) { return true; } | ||
3373 | finally { jj_save(12, xla); } | ||
3374 | } | ||
3375 | |||
3376 | private boolean jj_2_14(int xla) { | ||
3377 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3378 | try { return !jj_3_14(); } | ||
3379 | catch(LookaheadSuccess ls) { return true; } | ||
3380 | finally { jj_save(13, xla); } | ||
3381 | } | ||
3382 | |||
3383 | private boolean jj_2_15(int xla) { | ||
3384 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3385 | try { return !jj_3_15(); } | ||
3386 | catch(LookaheadSuccess ls) { return true; } | ||
3387 | finally { jj_save(14, xla); } | ||
3388 | } | ||
3389 | |||
3390 | private boolean jj_2_16(int xla) { | ||
3391 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3392 | try { return !jj_3_16(); } | ||
3393 | catch(LookaheadSuccess ls) { return true; } | ||
3394 | finally { jj_save(15, xla); } | ||
3395 | } | ||
3396 | |||
3397 | private boolean jj_2_17(int xla) { | ||
3398 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3399 | try { return !jj_3_17(); } | ||
3400 | catch(LookaheadSuccess ls) { return true; } | ||
3401 | finally { jj_save(16, xla); } | ||
3402 | } | ||
3403 | |||
3404 | private boolean jj_2_18(int xla) { | ||
3405 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3406 | try { return !jj_3_18(); } | ||
3407 | catch(LookaheadSuccess ls) { return true; } | ||
3408 | finally { jj_save(17, xla); } | ||
3409 | } | ||
3410 | |||
3411 | private boolean jj_3R_113() { | ||
3412 | if (jj_scan_token(55)) return true; | ||
3413 | if (jj_3R_32()) return true; | ||
3414 | if (jj_scan_token(56)) return true; | ||
3415 | return false; | ||
3416 | } | ||
3417 | |||
3418 | private boolean jj_3R_192() { | ||
3419 | if (jj_scan_token(DOUBLE)) return true; | ||
3420 | return false; | ||
3421 | } | ||
3422 | |||
3423 | private boolean jj_3R_168() { | ||
3424 | if (jj_3R_123()) return true; | ||
3425 | return false; | ||
3426 | } | ||
3427 | |||
3428 | private boolean jj_3_6() { | ||
3429 | if (jj_scan_token(59)) return true; | ||
3430 | if (jj_3R_19()) return true; | ||
3431 | return false; | ||
3432 | } | ||
3433 | |||
3434 | private boolean jj_3R_191() { | ||
3435 | if (jj_scan_token(FLOAT)) return true; | ||
3436 | return false; | ||
3437 | } | ||
3438 | |||
3439 | private boolean jj_3R_112() { | ||
3440 | if (jj_3R_29()) return true; | ||
3441 | return false; | ||
3442 | } | ||
3443 | |||
3444 | private boolean jj_3R_203() { | ||
3445 | if (jj_scan_token(LONG)) return true; | ||
3446 | return false; | ||
3447 | } | ||
3448 | |||
3449 | private boolean jj_3R_167() { | ||
3450 | if (jj_scan_token(CONST)) return true; | ||
3451 | return false; | ||
3452 | } | ||
3453 | |||
3454 | private boolean jj_3R_97() { | ||
3455 | if (jj_3R_19()) return true; | ||
3456 | Token xsp; | ||
3457 | while (true) { | ||
3458 | xsp = jj_scanpos; | ||
3459 | if (jj_3_6()) { jj_scanpos = xsp; break; } | ||
3460 | } | ||
3461 | xsp = jj_scanpos; | ||
3462 | if (jj_3R_136()) jj_scanpos = xsp; | ||
3463 | return false; | ||
3464 | } | ||
3465 | |||
3466 | private boolean jj_3R_123() { | ||
3467 | if (jj_scan_token(58)) return true; | ||
3468 | Token xsp; | ||
3469 | xsp = jj_scanpos; | ||
3470 | if (jj_3R_167()) jj_scanpos = xsp; | ||
3471 | xsp = jj_scanpos; | ||
3472 | if (jj_3R_168()) jj_scanpos = xsp; | ||
3473 | return false; | ||
3474 | } | ||
3475 | |||
3476 | private boolean jj_3R_190() { | ||
3477 | if (jj_scan_token(LONG)) return true; | ||
3478 | Token xsp; | ||
3479 | xsp = jj_scanpos; | ||
3480 | if (jj_3R_203()) jj_scanpos = xsp; | ||
3481 | return false; | ||
3482 | } | ||
3483 | |||
3484 | private boolean jj_3R_63() { | ||
3485 | if (jj_scan_token(SIZEOF)) return true; | ||
3486 | Token xsp; | ||
3487 | xsp = jj_scanpos; | ||
3488 | if (jj_3R_112()) { | ||
3489 | jj_scanpos = xsp; | ||
3490 | if (jj_3R_113()) return true; | ||
3491 | } | ||
3492 | return false; | ||
3493 | } | ||
3494 | |||
3495 | private boolean jj_3R_161() { | ||
3496 | if (jj_scan_token(79)) return true; | ||
3497 | if (jj_3R_114()) return true; | ||
3498 | return false; | ||
3499 | } | ||
3500 | |||
3501 | private boolean jj_3R_189() { | ||
3502 | if (jj_scan_token(INT)) return true; | ||
3503 | return false; | ||
3504 | } | ||
3505 | |||
3506 | private boolean jj_3R_202() { | ||
3507 | if (jj_scan_token(INT)) return true; | ||
3508 | return false; | ||
3509 | } | ||
3510 | |||
3511 | private boolean jj_3R_114() { | ||
3512 | if (jj_3R_160()) return true; | ||
3513 | Token xsp; | ||
3514 | xsp = jj_scanpos; | ||
3515 | if (jj_3R_161()) jj_scanpos = xsp; | ||
3516 | return false; | ||
3517 | } | ||
3518 | |||
3519 | private boolean jj_3R_62() { | ||
3520 | if (jj_3R_111()) return true; | ||
3521 | if (jj_3R_33()) return true; | ||
3522 | return false; | ||
3523 | } | ||
3524 | |||
3525 | private boolean jj_3R_188() { | ||
3526 | if (jj_scan_token(SHORT)) return true; | ||
3527 | Token xsp; | ||
3528 | xsp = jj_scanpos; | ||
3529 | if (jj_3R_202()) jj_scanpos = xsp; | ||
3530 | return false; | ||
3531 | } | ||
3532 | |||
3533 | private boolean jj_3R_61() { | ||
3534 | if (jj_scan_token(96)) return true; | ||
3535 | if (jj_3R_29()) return true; | ||
3536 | return false; | ||
3537 | } | ||
3538 | |||
3539 | private boolean jj_3R_187() { | ||
3540 | if (jj_scan_token(CHAR)) return true; | ||
3541 | return false; | ||
3542 | } | ||
3543 | |||
3544 | private boolean jj_3R_142() { | ||
3545 | if (jj_3R_97()) return true; | ||
3546 | return false; | ||
3547 | } | ||
3548 | |||
3549 | private boolean jj_3R_186() { | ||
3550 | if (jj_scan_token(VOID)) return true; | ||
3551 | return false; | ||
3552 | } | ||
3553 | |||
3554 | private boolean jj_3R_104() { | ||
3555 | if (jj_scan_token(63)) return true; | ||
3556 | if (jj_3R_106()) return true; | ||
3557 | return false; | ||
3558 | } | ||
3559 | |||
3560 | private boolean jj_3R_60() { | ||
3561 | if (jj_scan_token(95)) return true; | ||
3562 | if (jj_3R_29()) return true; | ||
3563 | return false; | ||
3564 | } | ||
3565 | |||
3566 | private boolean jj_3R_47() { | ||
3567 | if (jj_scan_token(IDENTIFIER)) return true; | ||
3568 | Token xsp; | ||
3569 | xsp = jj_scanpos; | ||
3570 | if (jj_3R_104()) jj_scanpos = xsp; | ||
3571 | return false; | ||
3572 | } | ||
3573 | |||
3574 | private boolean jj_3_17() { | ||
3575 | if (jj_3R_34()) return true; | ||
3576 | return false; | ||
3577 | } | ||
3578 | |||
3579 | private boolean jj_3R_185() { | ||
3580 | if (jj_scan_token(CONST)) return true; | ||
3581 | return false; | ||
3582 | } | ||
3583 | |||
3584 | private boolean jj_3R_102() { | ||
3585 | if (jj_3R_32()) return true; | ||
3586 | if (jj_scan_token(55)) return true; | ||
3587 | if (jj_scan_token(58)) return true; | ||
3588 | if (jj_scan_token(IDENTIFIER)) return true; | ||
3589 | if (jj_scan_token(56)) return true; | ||
3590 | if (jj_scan_token(55)) return true; | ||
3591 | Token xsp; | ||
3592 | xsp = jj_scanpos; | ||
3593 | if (jj_3R_142()) jj_scanpos = xsp; | ||
3594 | if (jj_scan_token(56)) return true; | ||
3595 | return false; | ||
3596 | } | ||
3597 | |||
3598 | private boolean jj_3R_115() { | ||
3599 | if (jj_scan_token(78)) return true; | ||
3600 | if (jj_3R_75()) return true; | ||
3601 | return false; | ||
3602 | } | ||
3603 | |||
3604 | private boolean jj_3R_172() { | ||
3605 | Token xsp; | ||
3606 | xsp = jj_scanpos; | ||
3607 | if (jj_3R_185()) jj_scanpos = xsp; | ||
3608 | xsp = jj_scanpos; | ||
3609 | if (jj_3R_186()) { | ||
3610 | jj_scanpos = xsp; | ||
3611 | if (jj_3R_187()) { | ||
3612 | jj_scanpos = xsp; | ||
3613 | if (jj_3R_188()) { | ||
3614 | jj_scanpos = xsp; | ||
3615 | if (jj_3R_189()) { | ||
3616 | jj_scanpos = xsp; | ||
3617 | if (jj_3R_190()) { | ||
3618 | jj_scanpos = xsp; | ||
3619 | if (jj_3R_191()) { | ||
3620 | jj_scanpos = xsp; | ||
3621 | if (jj_3R_192()) { | ||
3622 | jj_scanpos = xsp; | ||
3623 | if (jj_3R_193()) { | ||
3624 | jj_scanpos = xsp; | ||
3625 | if (jj_3R_194()) { | ||
3626 | jj_scanpos = xsp; | ||
3627 | if (jj_3R_195()) return true; | ||
3628 | } | ||
3629 | } | ||
3630 | } | ||
3631 | } | ||
3632 | } | ||
3633 | } | ||
3634 | } | ||
3635 | } | ||
3636 | } | ||
3637 | xsp = jj_scanpos; | ||
3638 | if (jj_3R_196()) jj_scanpos = xsp; | ||
3639 | xsp = jj_scanpos; | ||
3640 | if (jj_3R_197()) jj_scanpos = xsp; | ||
3641 | return false; | ||
3642 | } | ||
3643 | |||
3644 | private boolean jj_3R_75() { | ||
3645 | if (jj_3R_114()) return true; | ||
3646 | Token xsp; | ||
3647 | xsp = jj_scanpos; | ||
3648 | if (jj_3R_115()) jj_scanpos = xsp; | ||
3649 | return false; | ||
3650 | } | ||
3651 | |||
3652 | private boolean jj_3R_146() { | ||
3653 | if (jj_scan_token(SWITCH)) return true; | ||
3654 | if (jj_scan_token(55)) return true; | ||
3655 | if (jj_3R_116()) return true; | ||
3656 | if (jj_scan_token(56)) return true; | ||
3657 | if (jj_3R_28()) return true; | ||
3658 | return false; | ||
3659 | } | ||
3660 | |||
3661 | private boolean jj_3R_29() { | ||
3662 | Token xsp; | ||
3663 | xsp = jj_scanpos; | ||
3664 | if (jj_3_17()) { | ||
3665 | jj_scanpos = xsp; | ||
3666 | if (jj_3R_60()) { | ||
3667 | jj_scanpos = xsp; | ||
3668 | if (jj_3R_61()) { | ||
3669 | jj_scanpos = xsp; | ||
3670 | if (jj_3R_62()) { | ||
3671 | jj_scanpos = xsp; | ||
3672 | if (jj_3R_63()) return true; | ||
3673 | } | ||
3674 | } | ||
3675 | } | ||
3676 | } | ||
3677 | return false; | ||
3678 | } | ||
3679 | |||
3680 | private boolean jj_3_12() { | ||
3681 | if (jj_scan_token(ELSE)) return true; | ||
3682 | if (jj_3R_28()) return true; | ||
3683 | return false; | ||
3684 | } | ||
3685 | |||
3686 | private boolean jj_3R_48() { | ||
3687 | if (jj_scan_token(59)) return true; | ||
3688 | if (jj_3R_47()) return true; | ||
3689 | return false; | ||
3690 | } | ||
3691 | |||
3692 | private boolean jj_3R_106() { | ||
3693 | if (jj_3R_31()) return true; | ||
3694 | return false; | ||
3695 | } | ||
3696 | |||
3697 | private boolean jj_3R_24() { | ||
3698 | if (jj_3R_47()) return true; | ||
3699 | Token xsp; | ||
3700 | while (true) { | ||
3701 | xsp = jj_scanpos; | ||
3702 | if (jj_3R_48()) { jj_scanpos = xsp; break; } | ||
3703 | } | ||
3704 | return false; | ||
3705 | } | ||
3706 | |||
3707 | private boolean jj_3R_18() { | ||
3708 | if (jj_3R_15()) return true; | ||
3709 | if (jj_scan_token(IDENTIFIER)) return true; | ||
3710 | return false; | ||
3711 | } | ||
3712 | |||
3713 | private boolean jj_3R_145() { | ||
3714 | if (jj_scan_token(IF)) return true; | ||
3715 | if (jj_scan_token(55)) return true; | ||
3716 | if (jj_3R_116()) return true; | ||
3717 | if (jj_scan_token(56)) return true; | ||
3718 | if (jj_3R_28()) return true; | ||
3719 | Token xsp; | ||
3720 | xsp = jj_scanpos; | ||
3721 | if (jj_3_12()) jj_scanpos = xsp; | ||
3722 | return false; | ||
3723 | } | ||
3724 | |||
3725 | private boolean jj_3_5() { | ||
3726 | if (jj_3R_18()) return true; | ||
3727 | if (jj_scan_token(57)) return true; | ||
3728 | return false; | ||
3729 | } | ||
3730 | |||
3731 | private boolean jj_3R_108() { | ||
3732 | Token xsp; | ||
3733 | xsp = jj_scanpos; | ||
3734 | if (jj_3R_145()) { | ||
3735 | jj_scanpos = xsp; | ||
3736 | if (jj_3R_146()) return true; | ||
3737 | } | ||
3738 | return false; | ||
3739 | } | ||
3740 | |||
3741 | private boolean jj_3R_166() { | ||
3742 | if (jj_scan_token(IDENTIFIER)) return true; | ||
3743 | return false; | ||
3744 | } | ||
3745 | |||
3746 | private boolean jj_3R_43() { | ||
3747 | if (jj_3R_102()) return true; | ||
3748 | return false; | ||
3749 | } | ||
3750 | |||
3751 | private boolean jj_3R_92() { | ||
3752 | if (jj_3R_29()) return true; | ||
3753 | return false; | ||
3754 | } | ||
3755 | |||
3756 | private boolean jj_3R_76() { | ||
3757 | if (jj_scan_token(77)) return true; | ||
3758 | if (jj_3R_116()) return true; | ||
3759 | if (jj_scan_token(64)) return true; | ||
3760 | if (jj_3R_31()) return true; | ||
3761 | return false; | ||
3762 | } | ||
3763 | |||
3764 | private boolean jj_3_15() { | ||
3765 | if (jj_scan_token(55)) return true; | ||
3766 | if (jj_3R_32()) return true; | ||
3767 | if (jj_scan_token(56)) return true; | ||
3768 | if (jj_3R_33()) return true; | ||
3769 | return false; | ||
3770 | } | ||
3771 | |||
3772 | private boolean jj_3R_42() { | ||
3773 | if (jj_3R_18()) return true; | ||
3774 | return false; | ||
3775 | } | ||
3776 | |||
3777 | private boolean jj_3R_31() { | ||
3778 | if (jj_3R_75()) return true; | ||
3779 | Token xsp; | ||
3780 | xsp = jj_scanpos; | ||
3781 | if (jj_3R_76()) jj_scanpos = xsp; | ||
3782 | return false; | ||
3783 | } | ||
3784 | |||
3785 | private boolean jj_3R_23() { | ||
3786 | if (jj_scan_token(IDENTIFIER)) return true; | ||
3787 | return false; | ||
3788 | } | ||
3789 | |||
3790 | private boolean jj_3R_91() { | ||
3791 | if (jj_scan_token(55)) return true; | ||
3792 | if (jj_3R_32()) return true; | ||
3793 | if (jj_scan_token(56)) return true; | ||
3794 | if (jj_3R_33()) return true; | ||
3795 | return false; | ||
3796 | } | ||
3797 | |||
3798 | private boolean jj_3R_17() { | ||
3799 | if (jj_scan_token(TYPEDEF)) return true; | ||
3800 | Token xsp; | ||
3801 | xsp = jj_scanpos; | ||
3802 | if (jj_3R_42()) { | ||
3803 | jj_scanpos = xsp; | ||
3804 | if (jj_3R_43()) return true; | ||
3805 | } | ||
3806 | if (jj_scan_token(57)) return true; | ||
3807 | return false; | ||
3808 | } | ||
3809 | |||
3810 | private boolean jj_3_8() { | ||
3811 | Token xsp; | ||
3812 | xsp = jj_scanpos; | ||
3813 | if (jj_3R_23()) jj_scanpos = xsp; | ||
3814 | if (jj_scan_token(61)) return true; | ||
3815 | if (jj_3R_24()) return true; | ||
3816 | if (jj_scan_token(62)) return true; | ||
3817 | return false; | ||
3818 | } | ||
3819 | |||
3820 | private boolean jj_3R_33() { | ||
3821 | Token xsp; | ||
3822 | xsp = jj_scanpos; | ||
3823 | if (jj_3R_91()) { | ||
3824 | jj_scanpos = xsp; | ||
3825 | if (jj_3R_92()) return true; | ||
3826 | } | ||
3827 | return false; | ||
3828 | } | ||
3829 | |||
3830 | private boolean jj_3R_122() { | ||
3831 | if (jj_scan_token(ENUM)) return true; | ||
3832 | Token xsp; | ||
3833 | xsp = jj_scanpos; | ||
3834 | if (jj_3_8()) { | ||
3835 | jj_scanpos = xsp; | ||
3836 | if (jj_3R_166()) return true; | ||
3837 | } | ||
3838 | return false; | ||
3839 | } | ||
3840 | |||
3841 | private boolean jj_3R_74() { | ||
3842 | if (jj_scan_token(76)) return true; | ||
3843 | return false; | ||
3844 | } | ||
3845 | |||
3846 | private boolean jj_3_11() { | ||
3847 | if (jj_3R_27()) return true; | ||
3848 | return false; | ||
3849 | } | ||
3850 | |||
3851 | private boolean jj_3R_73() { | ||
3852 | if (jj_scan_token(75)) return true; | ||
3853 | return false; | ||
3854 | } | ||
3855 | |||
3856 | private boolean jj_3R_90() { | ||
3857 | if (jj_3R_124()) return true; | ||
3858 | return false; | ||
3859 | } | ||
3860 | |||
3861 | private boolean jj_3R_72() { | ||
3862 | if (jj_scan_token(74)) return true; | ||
3863 | return false; | ||
3864 | } | ||
3865 | |||
3866 | private boolean jj_3R_175() { | ||
3867 | if (jj_3R_28()) return true; | ||
3868 | return false; | ||
3869 | } | ||
3870 | |||
3871 | private boolean jj_3R_71() { | ||
3872 | if (jj_scan_token(73)) return true; | ||
3873 | return false; | ||
3874 | } | ||
3875 | |||
3876 | private boolean jj_3R_89() { | ||
3877 | if (jj_3R_123()) return true; | ||
3878 | return false; | ||
3879 | } | ||
3880 | |||
3881 | private boolean jj_3R_70() { | ||
3882 | if (jj_scan_token(72)) return true; | ||
3883 | return false; | ||
3884 | } | ||
3885 | |||
3886 | private boolean jj_3R_174() { | ||
3887 | if (jj_3R_27()) return true; | ||
3888 | return false; | ||
3889 | } | ||
3890 | |||
3891 | private boolean jj_3R_88() { | ||
3892 | if (jj_scan_token(IDENTIFIER)) return true; | ||
3893 | return false; | ||
3894 | } | ||
3895 | |||
3896 | private boolean jj_3R_69() { | ||
3897 | if (jj_scan_token(71)) return true; | ||
3898 | return false; | ||
3899 | } | ||
3900 | |||
3901 | private boolean jj_3R_244() { | ||
3902 | if (jj_scan_token(94)) return true; | ||
3903 | return false; | ||
3904 | } | ||
3905 | |||
3906 | private boolean jj_3R_87() { | ||
3907 | if (jj_3R_122()) return true; | ||
3908 | return false; | ||
3909 | } | ||
3910 | |||
3911 | private boolean jj_3R_137() { | ||
3912 | Token xsp; | ||
3913 | xsp = jj_scanpos; | ||
3914 | if (jj_3R_174()) { | ||
3915 | jj_scanpos = xsp; | ||
3916 | if (jj_3R_175()) return true; | ||
3917 | } | ||
3918 | return false; | ||
3919 | } | ||
3920 | |||
3921 | private boolean jj_3R_68() { | ||
3922 | if (jj_scan_token(70)) return true; | ||
3923 | return false; | ||
3924 | } | ||
3925 | |||
3926 | private boolean jj_3R_243() { | ||
3927 | if (jj_scan_token(93)) return true; | ||
3928 | return false; | ||
3929 | } | ||
3930 | |||
3931 | private boolean jj_3R_86() { | ||
3932 | if (jj_3R_15()) return true; | ||
3933 | return false; | ||
3934 | } | ||
3935 | |||
3936 | private boolean jj_3R_179() { | ||
3937 | if (jj_scan_token(LONG)) return true; | ||
3938 | return false; | ||
3939 | } | ||
3940 | |||
3941 | private boolean jj_3R_67() { | ||
3942 | if (jj_scan_token(69)) return true; | ||
3943 | return false; | ||
3944 | } | ||
3945 | |||
3946 | private boolean jj_3R_242() { | ||
3947 | if (jj_scan_token(58)) return true; | ||
3948 | return false; | ||
3949 | } | ||
3950 | |||
3951 | private boolean jj_3R_98() { | ||
3952 | if (jj_scan_token(61)) return true; | ||
3953 | Token xsp; | ||
3954 | while (true) { | ||
3955 | xsp = jj_scanpos; | ||
3956 | if (jj_3R_137()) { jj_scanpos = xsp; break; } | ||
3957 | } | ||
3958 | if (jj_scan_token(62)) return true; | ||
3959 | return false; | ||
3960 | } | ||
3961 | |||
3962 | private boolean jj_3R_199() { | ||
3963 | if (jj_scan_token(IDENTIFIER)) return true; | ||
3964 | return false; | ||
3965 | } | ||
3966 | |||
3967 | private boolean jj_3R_66() { | ||
3968 | if (jj_scan_token(68)) return true; | ||
3969 | return false; | ||
3970 | } | ||
3971 | |||
3972 | private boolean jj_3R_183() { | ||
3973 | if (jj_scan_token(STRING_LITERAL)) return true; | ||
3974 | return false; | ||
3975 | } | ||
3976 | |||
3977 | private boolean jj_3R_65() { | ||
3978 | if (jj_scan_token(67)) return true; | ||
3979 | return false; | ||
3980 | } | ||
3981 | |||
3982 | private boolean jj_3R_165() { | ||
3983 | if (jj_scan_token(LONG)) return true; | ||
3984 | Token xsp; | ||
3985 | xsp = jj_scanpos; | ||
3986 | if (jj_3R_179()) jj_scanpos = xsp; | ||
3987 | return false; | ||
3988 | } | ||
3989 | |||
3990 | private boolean jj_3R_182() { | ||
3991 | if (jj_scan_token(CHARACTER_LITERAL)) return true; | ||
3992 | return false; | ||
3993 | } | ||
3994 | |||
3995 | private boolean jj_3R_38() { | ||
3996 | if (jj_3R_98()) return true; | ||
3997 | return false; | ||
3998 | } | ||
3999 | |||
4000 | private boolean jj_3R_64() { | ||
4001 | if (jj_scan_token(63)) return true; | ||
4002 | return false; | ||
4003 | } | ||
4004 | |||
4005 | private boolean jj_3R_239() { | ||
4006 | Token xsp; | ||
4007 | xsp = jj_scanpos; | ||
4008 | if (jj_3R_242()) { | ||
4009 | jj_scanpos = xsp; | ||
4010 | if (jj_3R_243()) { | ||
4011 | jj_scanpos = xsp; | ||
4012 | if (jj_3R_244()) return true; | ||
4013 | } | ||
4014 | } | ||
4015 | if (jj_3R_235()) return true; | ||
4016 | return false; | ||
4017 | } | ||
4018 | |||
4019 | private boolean jj_3R_208() { | ||
4020 | if (jj_scan_token(64)) return true; | ||
4021 | if (jj_3R_106()) return true; | ||
4022 | return false; | ||
4023 | } | ||
4024 | |||
4025 | private boolean jj_3R_164() { | ||
4026 | if (jj_scan_token(INT)) return true; | ||
4027 | return false; | ||
4028 | } | ||
4029 | |||
4030 | private boolean jj_3R_181() { | ||
4031 | if (jj_scan_token(FLOATING_POINT_LITERAL)) return true; | ||
4032 | return false; | ||
4033 | } | ||
4034 | |||
4035 | private boolean jj_3R_37() { | ||
4036 | if (jj_scan_token(57)) return true; | ||
4037 | return false; | ||
4038 | } | ||
4039 | |||
4040 | private boolean jj_3R_207() { | ||
4041 | if (jj_3R_124()) return true; | ||
4042 | return false; | ||
4043 | } | ||
4044 | |||
4045 | private boolean jj_3R_178() { | ||
4046 | if (jj_scan_token(INT)) return true; | ||
4047 | return false; | ||
4048 | } | ||
4049 | |||
4050 | private boolean jj_3R_180() { | ||
4051 | if (jj_scan_token(INTEGER_LITERAL)) return true; | ||
4052 | return false; | ||
4053 | } | ||
4054 | |||
4055 | private boolean jj_3R_235() { | ||
4056 | if (jj_3R_33()) return true; | ||
4057 | Token xsp; | ||
4058 | xsp = jj_scanpos; | ||
4059 | if (jj_3R_239()) jj_scanpos = xsp; | ||
4060 | return false; | ||
4061 | } | ||
4062 | |||
4063 | private boolean jj_3R_198() { | ||
4064 | Token xsp; | ||
4065 | xsp = jj_scanpos; | ||
4066 | if (jj_3R_207()) { | ||
4067 | jj_scanpos = xsp; | ||
4068 | if (jj_3R_208()) return true; | ||
4069 | } | ||
4070 | return false; | ||
4071 | } | ||
4072 | |||
4073 | private boolean jj_3R_30() { | ||
4074 | Token xsp; | ||
4075 | xsp = jj_scanpos; | ||
4076 | if (jj_3R_64()) { | ||
4077 | jj_scanpos = xsp; | ||
4078 | if (jj_3R_65()) { | ||
4079 | jj_scanpos = xsp; | ||
4080 | if (jj_3R_66()) { | ||
4081 | jj_scanpos = xsp; | ||
4082 | if (jj_3R_67()) { | ||
4083 | jj_scanpos = xsp; | ||
4084 | if (jj_3R_68()) { | ||
4085 | jj_scanpos = xsp; | ||
4086 | if (jj_3R_69()) { | ||
4087 | jj_scanpos = xsp; | ||
4088 | if (jj_3R_70()) { | ||
4089 | jj_scanpos = xsp; | ||
4090 | if (jj_3R_71()) { | ||
4091 | jj_scanpos = xsp; | ||
4092 | if (jj_3R_72()) { | ||
4093 | jj_scanpos = xsp; | ||
4094 | if (jj_3R_73()) { | ||
4095 | jj_scanpos = xsp; | ||
4096 | if (jj_3R_74()) return true; | ||
4097 | } | ||
4098 | } | ||
4099 | } | ||
4100 | } | ||
4101 | } | ||
4102 | } | ||
4103 | } | ||
4104 | } | ||
4105 | } | ||
4106 | } | ||
4107 | return false; | ||
4108 | } | ||
4109 | |||
4110 | private boolean jj_3R_170() { | ||
4111 | Token xsp; | ||
4112 | xsp = jj_scanpos; | ||
4113 | if (jj_3R_180()) { | ||
4114 | jj_scanpos = xsp; | ||
4115 | if (jj_3R_181()) { | ||
4116 | jj_scanpos = xsp; | ||
4117 | if (jj_3R_182()) { | ||
4118 | jj_scanpos = xsp; | ||
4119 | if (jj_3R_183()) return true; | ||
4120 | } | ||
4121 | } | ||
4122 | } | ||
4123 | return false; | ||
4124 | } | ||
4125 | |||
4126 | private boolean jj_3R_163() { | ||
4127 | if (jj_scan_token(SHORT)) return true; | ||
4128 | Token xsp; | ||
4129 | xsp = jj_scanpos; | ||
4130 | if (jj_3R_178()) jj_scanpos = xsp; | ||
4131 | return false; | ||
4132 | } | ||
4133 | |||
4134 | private boolean jj_3R_144() { | ||
4135 | if (jj_3R_116()) return true; | ||
4136 | return false; | ||
4137 | } | ||
4138 | |||
4139 | private boolean jj_3R_36() { | ||
4140 | if (jj_3R_97()) return true; | ||
4141 | return false; | ||
4142 | } | ||
4143 | |||
4144 | private boolean jj_3R_162() { | ||
4145 | if (jj_scan_token(CHAR)) return true; | ||
4146 | return false; | ||
4147 | } | ||
4148 | |||
4149 | private boolean jj_3R_103() { | ||
4150 | if (jj_3R_32()) return true; | ||
4151 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4152 | Token xsp; | ||
4153 | xsp = jj_scanpos; | ||
4154 | if (jj_3R_198()) jj_scanpos = xsp; | ||
4155 | xsp = jj_scanpos; | ||
4156 | if (jj_3R_199()) jj_scanpos = xsp; | ||
4157 | if (jj_scan_token(57)) return true; | ||
4158 | return false; | ||
4159 | } | ||
4160 | |||
4161 | private boolean jj_3R_107() { | ||
4162 | Token xsp; | ||
4163 | xsp = jj_scanpos; | ||
4164 | if (jj_3R_144()) jj_scanpos = xsp; | ||
4165 | if (jj_scan_token(57)) return true; | ||
4166 | return false; | ||
4167 | } | ||
4168 | |||
4169 | private boolean jj_3R_14() { | ||
4170 | if (jj_3R_32()) return true; | ||
4171 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4172 | if (jj_scan_token(55)) return true; | ||
4173 | Token xsp; | ||
4174 | xsp = jj_scanpos; | ||
4175 | if (jj_3R_36()) jj_scanpos = xsp; | ||
4176 | if (jj_scan_token(56)) return true; | ||
4177 | xsp = jj_scanpos; | ||
4178 | if (jj_3R_37()) { | ||
4179 | jj_scanpos = xsp; | ||
4180 | if (jj_3R_38()) return true; | ||
4181 | } | ||
4182 | return false; | ||
4183 | } | ||
4184 | |||
4185 | private boolean jj_3R_121() { | ||
4186 | Token xsp; | ||
4187 | xsp = jj_scanpos; | ||
4188 | if (jj_3R_162()) { | ||
4189 | jj_scanpos = xsp; | ||
4190 | if (jj_3R_163()) { | ||
4191 | jj_scanpos = xsp; | ||
4192 | if (jj_3R_164()) { | ||
4193 | jj_scanpos = xsp; | ||
4194 | if (jj_3R_165()) return true; | ||
4195 | } | ||
4196 | } | ||
4197 | } | ||
4198 | return false; | ||
4199 | } | ||
4200 | |||
4201 | private boolean jj_3R_120() { | ||
4202 | if (jj_scan_token(UNSIGNED)) return true; | ||
4203 | return false; | ||
4204 | } | ||
4205 | |||
4206 | private boolean jj_3R_119() { | ||
4207 | if (jj_scan_token(SIGNED)) return true; | ||
4208 | return false; | ||
4209 | } | ||
4210 | |||
4211 | private boolean jj_3R_241() { | ||
4212 | if (jj_scan_token(92)) return true; | ||
4213 | return false; | ||
4214 | } | ||
4215 | |||
4216 | private boolean jj_3R_135() { | ||
4217 | if (jj_3R_105()) return true; | ||
4218 | return false; | ||
4219 | } | ||
4220 | |||
4221 | private boolean jj_3R_240() { | ||
4222 | if (jj_scan_token(91)) return true; | ||
4223 | return false; | ||
4224 | } | ||
4225 | |||
4226 | private boolean jj_3R_134() { | ||
4227 | if (jj_3R_172()) return true; | ||
4228 | return false; | ||
4229 | } | ||
4230 | |||
4231 | private boolean jj_3_4() { | ||
4232 | if (jj_3R_17()) return true; | ||
4233 | return false; | ||
4234 | } | ||
4235 | |||
4236 | private boolean jj_3R_53() { | ||
4237 | if (jj_scan_token(DFLT)) return true; | ||
4238 | if (jj_scan_token(64)) return true; | ||
4239 | if (jj_3R_28()) return true; | ||
4240 | return false; | ||
4241 | } | ||
4242 | |||
4243 | private boolean jj_3R_95() { | ||
4244 | Token xsp; | ||
4245 | xsp = jj_scanpos; | ||
4246 | if (jj_3R_134()) { | ||
4247 | jj_scanpos = xsp; | ||
4248 | if (jj_3R_135()) return true; | ||
4249 | } | ||
4250 | return false; | ||
4251 | } | ||
4252 | |||
4253 | private boolean jj_3_3() { | ||
4254 | if (jj_3R_16()) return true; | ||
4255 | return false; | ||
4256 | } | ||
4257 | |||
4258 | private boolean jj_3R_85() { | ||
4259 | Token xsp; | ||
4260 | xsp = jj_scanpos; | ||
4261 | if (jj_3R_119()) { | ||
4262 | jj_scanpos = xsp; | ||
4263 | if (jj_3R_120()) return true; | ||
4264 | } | ||
4265 | xsp = jj_scanpos; | ||
4266 | if (jj_3R_121()) jj_scanpos = xsp; | ||
4267 | return false; | ||
4268 | } | ||
4269 | |||
4270 | private boolean jj_3R_84() { | ||
4271 | if (jj_scan_token(DOUBLE)) return true; | ||
4272 | return false; | ||
4273 | } | ||
4274 | |||
4275 | private boolean jj_3R_236() { | ||
4276 | Token xsp; | ||
4277 | xsp = jj_scanpos; | ||
4278 | if (jj_3R_240()) { | ||
4279 | jj_scanpos = xsp; | ||
4280 | if (jj_3R_241()) return true; | ||
4281 | } | ||
4282 | if (jj_3R_229()) return true; | ||
4283 | return false; | ||
4284 | } | ||
4285 | |||
4286 | private boolean jj_3_2() { | ||
4287 | if (jj_3R_15()) return true; | ||
4288 | return false; | ||
4289 | } | ||
4290 | |||
4291 | private boolean jj_3R_83() { | ||
4292 | if (jj_scan_token(FLOAT)) return true; | ||
4293 | return false; | ||
4294 | } | ||
4295 | |||
4296 | private boolean jj_3_14() { | ||
4297 | if (jj_3R_31()) return true; | ||
4298 | return false; | ||
4299 | } | ||
4300 | |||
4301 | private boolean jj_3_13() { | ||
4302 | if (jj_3R_29()) return true; | ||
4303 | if (jj_3R_30()) return true; | ||
4304 | return false; | ||
4305 | } | ||
4306 | |||
4307 | private boolean jj_3R_141() { | ||
4308 | if (jj_scan_token(63)) return true; | ||
4309 | if (jj_3R_25()) return true; | ||
4310 | return false; | ||
4311 | } | ||
4312 | |||
4313 | private boolean jj_3_1() { | ||
4314 | if (jj_3R_14()) return true; | ||
4315 | return false; | ||
4316 | } | ||
4317 | |||
4318 | private boolean jj_3R_229() { | ||
4319 | if (jj_3R_235()) return true; | ||
4320 | Token xsp; | ||
4321 | xsp = jj_scanpos; | ||
4322 | if (jj_3R_236()) jj_scanpos = xsp; | ||
4323 | return false; | ||
4324 | } | ||
4325 | |||
4326 | private boolean jj_3R_118() { | ||
4327 | if (jj_scan_token(LONG)) return true; | ||
4328 | return false; | ||
4329 | } | ||
4330 | |||
4331 | private boolean jj_3R_52() { | ||
4332 | if (jj_scan_token(CASE)) return true; | ||
4333 | if (jj_3R_106()) return true; | ||
4334 | if (jj_scan_token(64)) return true; | ||
4335 | if (jj_3R_28()) return true; | ||
4336 | return false; | ||
4337 | } | ||
4338 | |||
4339 | private boolean jj_3R_140() { | ||
4340 | if (jj_3R_124()) return true; | ||
4341 | return false; | ||
4342 | } | ||
4343 | |||
4344 | private boolean jj_3R_143() { | ||
4345 | if (jj_3R_29()) return true; | ||
4346 | if (jj_3R_30()) return true; | ||
4347 | if (jj_3R_105()) return true; | ||
4348 | return false; | ||
4349 | } | ||
4350 | |||
4351 | private boolean jj_3R_82() { | ||
4352 | if (jj_scan_token(LONG)) return true; | ||
4353 | Token xsp; | ||
4354 | xsp = jj_scanpos; | ||
4355 | if (jj_3R_118()) jj_scanpos = xsp; | ||
4356 | return false; | ||
4357 | } | ||
4358 | |||
4359 | private boolean jj_3R_100() { | ||
4360 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4361 | Token xsp; | ||
4362 | xsp = jj_scanpos; | ||
4363 | if (jj_3R_140()) jj_scanpos = xsp; | ||
4364 | xsp = jj_scanpos; | ||
4365 | if (jj_3R_141()) jj_scanpos = xsp; | ||
4366 | return false; | ||
4367 | } | ||
4368 | |||
4369 | private boolean jj_3R_96() { | ||
4370 | if (jj_scan_token(59)) return true; | ||
4371 | if (jj_3R_95()) return true; | ||
4372 | return false; | ||
4373 | } | ||
4374 | |||
4375 | private boolean jj_3R_51() { | ||
4376 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4377 | if (jj_scan_token(64)) return true; | ||
4378 | if (jj_3R_28()) return true; | ||
4379 | return false; | ||
4380 | } | ||
4381 | |||
4382 | private boolean jj_3R_81() { | ||
4383 | if (jj_scan_token(INT)) return true; | ||
4384 | return false; | ||
4385 | } | ||
4386 | |||
4387 | private boolean jj_3R_105() { | ||
4388 | Token xsp; | ||
4389 | xsp = jj_scanpos; | ||
4390 | if (jj_3R_143()) { | ||
4391 | jj_scanpos = xsp; | ||
4392 | if (jj_3_14()) return true; | ||
4393 | } | ||
4394 | return false; | ||
4395 | } | ||
4396 | |||
4397 | private boolean jj_3R_35() { | ||
4398 | if (jj_3R_95()) return true; | ||
4399 | Token xsp; | ||
4400 | while (true) { | ||
4401 | xsp = jj_scanpos; | ||
4402 | if (jj_3R_96()) { jj_scanpos = xsp; break; } | ||
4403 | } | ||
4404 | return false; | ||
4405 | } | ||
4406 | |||
4407 | private boolean jj_3R_117() { | ||
4408 | if (jj_scan_token(INT)) return true; | ||
4409 | return false; | ||
4410 | } | ||
4411 | |||
4412 | private boolean jj_3R_26() { | ||
4413 | Token xsp; | ||
4414 | xsp = jj_scanpos; | ||
4415 | if (jj_3R_51()) { | ||
4416 | jj_scanpos = xsp; | ||
4417 | if (jj_3R_52()) { | ||
4418 | jj_scanpos = xsp; | ||
4419 | if (jj_3R_53()) return true; | ||
4420 | } | ||
4421 | } | ||
4422 | return false; | ||
4423 | } | ||
4424 | |||
4425 | private boolean jj_3R_238() { | ||
4426 | if (jj_scan_token(90)) return true; | ||
4427 | return false; | ||
4428 | } | ||
4429 | |||
4430 | private boolean jj_3R_80() { | ||
4431 | if (jj_scan_token(SHORT)) return true; | ||
4432 | Token xsp; | ||
4433 | xsp = jj_scanpos; | ||
4434 | if (jj_3R_117()) jj_scanpos = xsp; | ||
4435 | return false; | ||
4436 | } | ||
4437 | |||
4438 | private boolean jj_3R_237() { | ||
4439 | if (jj_scan_token(89)) return true; | ||
4440 | return false; | ||
4441 | } | ||
4442 | |||
4443 | private boolean jj_3R_79() { | ||
4444 | if (jj_scan_token(CHAR)) return true; | ||
4445 | return false; | ||
4446 | } | ||
4447 | |||
4448 | private boolean jj_3R_78() { | ||
4449 | if (jj_scan_token(VOID)) return true; | ||
4450 | return false; | ||
4451 | } | ||
4452 | |||
4453 | private boolean jj_3R_101() { | ||
4454 | if (jj_scan_token(59)) return true; | ||
4455 | if (jj_3R_100()) return true; | ||
4456 | return false; | ||
4457 | } | ||
4458 | |||
4459 | private boolean jj_3R_230() { | ||
4460 | Token xsp; | ||
4461 | xsp = jj_scanpos; | ||
4462 | if (jj_3R_237()) { | ||
4463 | jj_scanpos = xsp; | ||
4464 | if (jj_3R_238()) return true; | ||
4465 | } | ||
4466 | if (jj_3R_221()) return true; | ||
4467 | return false; | ||
4468 | } | ||
4469 | |||
4470 | private boolean jj_3R_184() { | ||
4471 | if (jj_scan_token(59)) return true; | ||
4472 | if (jj_3R_105()) return true; | ||
4473 | return false; | ||
4474 | } | ||
4475 | |||
4476 | private boolean jj_3R_77() { | ||
4477 | if (jj_scan_token(CONST)) return true; | ||
4478 | return false; | ||
4479 | } | ||
4480 | |||
4481 | private boolean jj_3R_127() { | ||
4482 | if (jj_scan_token(55)) return true; | ||
4483 | if (jj_3R_116()) return true; | ||
4484 | if (jj_scan_token(56)) return true; | ||
4485 | return false; | ||
4486 | } | ||
4487 | |||
4488 | private boolean jj_3R_41() { | ||
4489 | if (jj_3R_100()) return true; | ||
4490 | Token xsp; | ||
4491 | while (true) { | ||
4492 | xsp = jj_scanpos; | ||
4493 | if (jj_3R_101()) { jj_scanpos = xsp; break; } | ||
4494 | } | ||
4495 | return false; | ||
4496 | } | ||
4497 | |||
4498 | private boolean jj_3R_221() { | ||
4499 | if (jj_3R_229()) return true; | ||
4500 | Token xsp; | ||
4501 | xsp = jj_scanpos; | ||
4502 | if (jj_3R_230()) jj_scanpos = xsp; | ||
4503 | return false; | ||
4504 | } | ||
4505 | |||
4506 | private boolean jj_3R_116() { | ||
4507 | if (jj_3R_105()) return true; | ||
4508 | Token xsp; | ||
4509 | while (true) { | ||
4510 | xsp = jj_scanpos; | ||
4511 | if (jj_3R_184()) { jj_scanpos = xsp; break; } | ||
4512 | } | ||
4513 | return false; | ||
4514 | } | ||
4515 | |||
4516 | private boolean jj_3R_32() { | ||
4517 | Token xsp; | ||
4518 | xsp = jj_scanpos; | ||
4519 | if (jj_3R_77()) jj_scanpos = xsp; | ||
4520 | xsp = jj_scanpos; | ||
4521 | if (jj_3R_78()) { | ||
4522 | jj_scanpos = xsp; | ||
4523 | if (jj_3R_79()) { | ||
4524 | jj_scanpos = xsp; | ||
4525 | if (jj_3R_80()) { | ||
4526 | jj_scanpos = xsp; | ||
4527 | if (jj_3R_81()) { | ||
4528 | jj_scanpos = xsp; | ||
4529 | if (jj_3R_82()) { | ||
4530 | jj_scanpos = xsp; | ||
4531 | if (jj_3R_83()) { | ||
4532 | jj_scanpos = xsp; | ||
4533 | if (jj_3R_84()) { | ||
4534 | jj_scanpos = xsp; | ||
4535 | if (jj_3R_85()) { | ||
4536 | jj_scanpos = xsp; | ||
4537 | if (jj_3R_86()) { | ||
4538 | jj_scanpos = xsp; | ||
4539 | if (jj_3R_87()) { | ||
4540 | jj_scanpos = xsp; | ||
4541 | if (jj_3R_88()) return true; | ||
4542 | } | ||
4543 | } | ||
4544 | } | ||
4545 | } | ||
4546 | } | ||
4547 | } | ||
4548 | } | ||
4549 | } | ||
4550 | } | ||
4551 | } | ||
4552 | xsp = jj_scanpos; | ||
4553 | if (jj_3R_89()) jj_scanpos = xsp; | ||
4554 | xsp = jj_scanpos; | ||
4555 | if (jj_3R_90()) jj_scanpos = xsp; | ||
4556 | return false; | ||
4557 | } | ||
4558 | |||
4559 | private boolean jj_3R_126() { | ||
4560 | if (jj_3R_170()) return true; | ||
4561 | return false; | ||
4562 | } | ||
4563 | |||
4564 | private boolean jj_3R_125() { | ||
4565 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4566 | return false; | ||
4567 | } | ||
4568 | |||
4569 | private boolean jj_3R_93() { | ||
4570 | Token xsp; | ||
4571 | xsp = jj_scanpos; | ||
4572 | if (jj_3R_125()) { | ||
4573 | jj_scanpos = xsp; | ||
4574 | if (jj_3R_126()) { | ||
4575 | jj_scanpos = xsp; | ||
4576 | if (jj_3R_127()) return true; | ||
4577 | } | ||
4578 | } | ||
4579 | return false; | ||
4580 | } | ||
4581 | |||
4582 | private boolean jj_3R_59() { | ||
4583 | if (jj_3R_110()) return true; | ||
4584 | return false; | ||
4585 | } | ||
4586 | |||
4587 | private boolean jj_3R_58() { | ||
4588 | if (jj_3R_109()) return true; | ||
4589 | return false; | ||
4590 | } | ||
4591 | |||
4592 | private boolean jj_3R_57() { | ||
4593 | if (jj_3R_108()) return true; | ||
4594 | return false; | ||
4595 | } | ||
4596 | |||
4597 | private boolean jj_3R_46() { | ||
4598 | if (jj_3R_103()) return true; | ||
4599 | return false; | ||
4600 | } | ||
4601 | |||
4602 | private boolean jj_3R_228() { | ||
4603 | if (jj_3R_116()) return true; | ||
4604 | return false; | ||
4605 | } | ||
4606 | |||
4607 | private boolean jj_3R_56() { | ||
4608 | if (jj_3R_98()) return true; | ||
4609 | return false; | ||
4610 | } | ||
4611 | |||
4612 | private boolean jj_3R_234() { | ||
4613 | if (jj_scan_token(88)) return true; | ||
4614 | return false; | ||
4615 | } | ||
4616 | |||
4617 | private boolean jj_3R_22() { | ||
4618 | Token xsp; | ||
4619 | if (jj_3R_46()) return true; | ||
4620 | while (true) { | ||
4621 | xsp = jj_scanpos; | ||
4622 | if (jj_3R_46()) { jj_scanpos = xsp; break; } | ||
4623 | } | ||
4624 | return false; | ||
4625 | } | ||
4626 | |||
4627 | private boolean jj_3R_55() { | ||
4628 | if (jj_3R_107()) return true; | ||
4629 | return false; | ||
4630 | } | ||
4631 | |||
4632 | private boolean jj_3R_233() { | ||
4633 | if (jj_scan_token(87)) return true; | ||
4634 | return false; | ||
4635 | } | ||
4636 | |||
4637 | private boolean jj_3R_153() { | ||
4638 | if (jj_scan_token(RETURN)) return true; | ||
4639 | Token xsp; | ||
4640 | xsp = jj_scanpos; | ||
4641 | if (jj_3R_228()) jj_scanpos = xsp; | ||
4642 | if (jj_scan_token(57)) return true; | ||
4643 | return false; | ||
4644 | } | ||
4645 | |||
4646 | private boolean jj_3_10() { | ||
4647 | if (jj_3R_26()) return true; | ||
4648 | return false; | ||
4649 | } | ||
4650 | |||
4651 | private boolean jj_3R_232() { | ||
4652 | if (jj_scan_token(86)) return true; | ||
4653 | return false; | ||
4654 | } | ||
4655 | |||
4656 | private boolean jj_3R_133() { | ||
4657 | if (jj_scan_token(96)) return true; | ||
4658 | return false; | ||
4659 | } | ||
4660 | |||
4661 | private boolean jj_3R_231() { | ||
4662 | if (jj_scan_token(85)) return true; | ||
4663 | return false; | ||
4664 | } | ||
4665 | |||
4666 | private boolean jj_3R_152() { | ||
4667 | if (jj_scan_token(BREAK)) return true; | ||
4668 | if (jj_scan_token(57)) return true; | ||
4669 | return false; | ||
4670 | } | ||
4671 | |||
4672 | private boolean jj_3R_45() { | ||
4673 | if (jj_scan_token(UNION)) return true; | ||
4674 | return false; | ||
4675 | } | ||
4676 | |||
4677 | private boolean jj_3R_132() { | ||
4678 | if (jj_scan_token(95)) return true; | ||
4679 | return false; | ||
4680 | } | ||
4681 | |||
4682 | private boolean jj_3R_28() { | ||
4683 | Token xsp; | ||
4684 | xsp = jj_scanpos; | ||
4685 | if (jj_3_10()) { | ||
4686 | jj_scanpos = xsp; | ||
4687 | if (jj_3R_55()) { | ||
4688 | jj_scanpos = xsp; | ||
4689 | if (jj_3R_56()) { | ||
4690 | jj_scanpos = xsp; | ||
4691 | if (jj_3R_57()) { | ||
4692 | jj_scanpos = xsp; | ||
4693 | if (jj_3R_58()) { | ||
4694 | jj_scanpos = xsp; | ||
4695 | if (jj_3R_59()) return true; | ||
4696 | } | ||
4697 | } | ||
4698 | } | ||
4699 | } | ||
4700 | } | ||
4701 | return false; | ||
4702 | } | ||
4703 | |||
4704 | private boolean jj_3R_44() { | ||
4705 | if (jj_scan_token(STRUCT)) return true; | ||
4706 | return false; | ||
4707 | } | ||
4708 | |||
4709 | private boolean jj_3R_222() { | ||
4710 | Token xsp; | ||
4711 | xsp = jj_scanpos; | ||
4712 | if (jj_3R_231()) { | ||
4713 | jj_scanpos = xsp; | ||
4714 | if (jj_3R_232()) { | ||
4715 | jj_scanpos = xsp; | ||
4716 | if (jj_3R_233()) { | ||
4717 | jj_scanpos = xsp; | ||
4718 | if (jj_3R_234()) return true; | ||
4719 | } | ||
4720 | } | ||
4721 | } | ||
4722 | if (jj_3R_217()) return true; | ||
4723 | return false; | ||
4724 | } | ||
4725 | |||
4726 | private boolean jj_3R_151() { | ||
4727 | if (jj_scan_token(CONTINUE)) return true; | ||
4728 | if (jj_scan_token(57)) return true; | ||
4729 | return false; | ||
4730 | } | ||
4731 | |||
4732 | private boolean jj_3R_131() { | ||
4733 | if (jj_scan_token(100)) return true; | ||
4734 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4735 | return false; | ||
4736 | } | ||
4737 | |||
4738 | private boolean jj_3_18() { | ||
4739 | if (jj_3R_35()) return true; | ||
4740 | return false; | ||
4741 | } | ||
4742 | |||
4743 | private boolean jj_3R_20() { | ||
4744 | Token xsp; | ||
4745 | xsp = jj_scanpos; | ||
4746 | if (jj_3R_44()) { | ||
4747 | jj_scanpos = xsp; | ||
4748 | if (jj_3R_45()) return true; | ||
4749 | } | ||
4750 | return false; | ||
4751 | } | ||
4752 | |||
4753 | private boolean jj_3R_217() { | ||
4754 | if (jj_3R_221()) return true; | ||
4755 | Token xsp; | ||
4756 | xsp = jj_scanpos; | ||
4757 | if (jj_3R_222()) jj_scanpos = xsp; | ||
4758 | return false; | ||
4759 | } | ||
4760 | |||
4761 | private boolean jj_3R_130() { | ||
4762 | if (jj_scan_token(99)) return true; | ||
4763 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4764 | return false; | ||
4765 | } | ||
4766 | |||
4767 | private boolean jj_3R_150() { | ||
4768 | if (jj_scan_token(GOTO)) return true; | ||
4769 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4770 | if (jj_scan_token(57)) return true; | ||
4771 | return false; | ||
4772 | } | ||
4773 | |||
4774 | private boolean jj_3R_171() { | ||
4775 | if (jj_3R_35()) return true; | ||
4776 | return false; | ||
4777 | } | ||
4778 | |||
4779 | private boolean jj_3R_169() { | ||
4780 | if (jj_3R_106()) return true; | ||
4781 | return false; | ||
4782 | } | ||
4783 | |||
4784 | private boolean jj_3R_110() { | ||
4785 | Token xsp; | ||
4786 | xsp = jj_scanpos; | ||
4787 | if (jj_3R_150()) { | ||
4788 | jj_scanpos = xsp; | ||
4789 | if (jj_3R_151()) { | ||
4790 | jj_scanpos = xsp; | ||
4791 | if (jj_3R_152()) { | ||
4792 | jj_scanpos = xsp; | ||
4793 | if (jj_3R_153()) return true; | ||
4794 | } | ||
4795 | } | ||
4796 | } | ||
4797 | return false; | ||
4798 | } | ||
4799 | |||
4800 | private boolean jj_3R_124() { | ||
4801 | if (jj_scan_token(65)) return true; | ||
4802 | Token xsp; | ||
4803 | xsp = jj_scanpos; | ||
4804 | if (jj_3R_169()) jj_scanpos = xsp; | ||
4805 | if (jj_scan_token(66)) return true; | ||
4806 | return false; | ||
4807 | } | ||
4808 | |||
4809 | private boolean jj_3R_129() { | ||
4810 | if (jj_scan_token(55)) return true; | ||
4811 | Token xsp; | ||
4812 | xsp = jj_scanpos; | ||
4813 | if (jj_3R_171()) jj_scanpos = xsp; | ||
4814 | if (jj_scan_token(56)) return true; | ||
4815 | return false; | ||
4816 | } | ||
4817 | |||
4818 | private boolean jj_3R_39() { | ||
4819 | if (jj_3R_20()) return true; | ||
4820 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4821 | return false; | ||
4822 | } | ||
4823 | |||
4824 | private boolean jj_3R_224() { | ||
4825 | if (jj_scan_token(84)) return true; | ||
4826 | return false; | ||
4827 | } | ||
4828 | |||
4829 | private boolean jj_3R_128() { | ||
4830 | if (jj_scan_token(65)) return true; | ||
4831 | if (jj_3R_116()) return true; | ||
4832 | if (jj_scan_token(66)) return true; | ||
4833 | return false; | ||
4834 | } | ||
4835 | |||
4836 | private boolean jj_3R_139() { | ||
4837 | if (jj_scan_token(REGISTER)) return true; | ||
4838 | return false; | ||
4839 | } | ||
4840 | |||
4841 | private boolean jj_3R_223() { | ||
4842 | if (jj_scan_token(83)) return true; | ||
4843 | return false; | ||
4844 | } | ||
4845 | |||
4846 | private boolean jj_3R_21() { | ||
4847 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4848 | return false; | ||
4849 | } | ||
4850 | |||
4851 | private boolean jj_3R_138() { | ||
4852 | if (jj_scan_token(AUTO)) return true; | ||
4853 | return false; | ||
4854 | } | ||
4855 | |||
4856 | private boolean jj_3R_94() { | ||
4857 | Token xsp; | ||
4858 | xsp = jj_scanpos; | ||
4859 | if (jj_3R_128()) { | ||
4860 | jj_scanpos = xsp; | ||
4861 | if (jj_3R_129()) { | ||
4862 | jj_scanpos = xsp; | ||
4863 | if (jj_3R_130()) { | ||
4864 | jj_scanpos = xsp; | ||
4865 | if (jj_3R_131()) { | ||
4866 | jj_scanpos = xsp; | ||
4867 | if (jj_3R_132()) { | ||
4868 | jj_scanpos = xsp; | ||
4869 | if (jj_3R_133()) return true; | ||
4870 | } | ||
4871 | } | ||
4872 | } | ||
4873 | } | ||
4874 | } | ||
4875 | return false; | ||
4876 | } | ||
4877 | |||
4878 | private boolean jj_3R_99() { | ||
4879 | Token xsp; | ||
4880 | xsp = jj_scanpos; | ||
4881 | if (jj_3R_138()) { | ||
4882 | jj_scanpos = xsp; | ||
4883 | if (jj_3R_139()) return true; | ||
4884 | } | ||
4885 | return false; | ||
4886 | } | ||
4887 | |||
4888 | private boolean jj_3R_34() { | ||
4889 | if (jj_3R_93()) return true; | ||
4890 | Token xsp; | ||
4891 | while (true) { | ||
4892 | xsp = jj_scanpos; | ||
4893 | if (jj_3R_94()) { jj_scanpos = xsp; break; } | ||
4894 | } | ||
4895 | return false; | ||
4896 | } | ||
4897 | |||
4898 | private boolean jj_3_7() { | ||
4899 | if (jj_3R_20()) return true; | ||
4900 | Token xsp; | ||
4901 | xsp = jj_scanpos; | ||
4902 | if (jj_3R_21()) jj_scanpos = xsp; | ||
4903 | if (jj_scan_token(61)) return true; | ||
4904 | if (jj_3R_22()) return true; | ||
4905 | if (jj_scan_token(62)) return true; | ||
4906 | return false; | ||
4907 | } | ||
4908 | |||
4909 | private boolean jj_3_9() { | ||
4910 | if (jj_scan_token(59)) return true; | ||
4911 | if (jj_3R_25()) return true; | ||
4912 | return false; | ||
4913 | } | ||
4914 | |||
4915 | private boolean jj_3R_218() { | ||
4916 | Token xsp; | ||
4917 | xsp = jj_scanpos; | ||
4918 | if (jj_3R_223()) { | ||
4919 | jj_scanpos = xsp; | ||
4920 | if (jj_3R_224()) return true; | ||
4921 | } | ||
4922 | if (jj_3R_211()) return true; | ||
4923 | return false; | ||
4924 | } | ||
4925 | |||
4926 | private boolean jj_3R_40() { | ||
4927 | Token xsp; | ||
4928 | while (true) { | ||
4929 | xsp = jj_scanpos; | ||
4930 | if (jj_3R_99()) { jj_scanpos = xsp; break; } | ||
4931 | } | ||
4932 | return false; | ||
4933 | } | ||
4934 | |||
4935 | private boolean jj_3R_15() { | ||
4936 | Token xsp; | ||
4937 | xsp = jj_scanpos; | ||
4938 | if (jj_3_7()) { | ||
4939 | jj_scanpos = xsp; | ||
4940 | if (jj_3R_39()) return true; | ||
4941 | } | ||
4942 | return false; | ||
4943 | } | ||
4944 | |||
4945 | private boolean jj_3R_209() { | ||
4946 | if (jj_3R_25()) return true; | ||
4947 | Token xsp; | ||
4948 | while (true) { | ||
4949 | xsp = jj_scanpos; | ||
4950 | if (jj_3_9()) { jj_scanpos = xsp; break; } | ||
4951 | } | ||
4952 | return false; | ||
4953 | } | ||
4954 | |||
4955 | private boolean jj_3R_211() { | ||
4956 | if (jj_3R_217()) return true; | ||
4957 | Token xsp; | ||
4958 | xsp = jj_scanpos; | ||
4959 | if (jj_3R_218()) jj_scanpos = xsp; | ||
4960 | return false; | ||
4961 | } | ||
4962 | |||
4963 | private boolean jj_3R_227() { | ||
4964 | if (jj_3R_116()) return true; | ||
4965 | return false; | ||
4966 | } | ||
4967 | |||
4968 | private boolean jj_3R_54() { | ||
4969 | if (jj_scan_token(STATIC)) return true; | ||
4970 | return false; | ||
4971 | } | ||
4972 | |||
4973 | private boolean jj_3R_226() { | ||
4974 | if (jj_3R_116()) return true; | ||
4975 | return false; | ||
4976 | } | ||
4977 | |||
4978 | private boolean jj_3R_210() { | ||
4979 | if (jj_scan_token(59)) return true; | ||
4980 | return false; | ||
4981 | } | ||
4982 | |||
4983 | private boolean jj_3R_27() { | ||
4984 | Token xsp; | ||
4985 | xsp = jj_scanpos; | ||
4986 | if (jj_3R_54()) jj_scanpos = xsp; | ||
4987 | if (jj_3R_16()) return true; | ||
4988 | return false; | ||
4989 | } | ||
4990 | |||
4991 | private boolean jj_3R_225() { | ||
4992 | if (jj_3R_116()) return true; | ||
4993 | return false; | ||
4994 | } | ||
4995 | |||
4996 | private boolean jj_3R_212() { | ||
4997 | if (jj_scan_token(82)) return true; | ||
4998 | if (jj_3R_200()) return true; | ||
4999 | return false; | ||
5000 | } | ||
5001 | |||
5002 | private boolean jj_3R_197() { | ||
5003 | if (jj_3R_124()) return true; | ||
5004 | return false; | ||
5005 | } | ||
5006 | |||
5007 | private boolean jj_3R_50() { | ||
5008 | if (jj_scan_token(61)) return true; | ||
5009 | if (jj_3R_209()) return true; | ||
5010 | Token xsp; | ||
5011 | xsp = jj_scanpos; | ||
5012 | if (jj_3R_210()) jj_scanpos = xsp; | ||
5013 | if (jj_scan_token(62)) return true; | ||
5014 | return false; | ||
5015 | } | ||
5016 | |||
5017 | private boolean jj_3R_196() { | ||
5018 | if (jj_3R_123()) return true; | ||
5019 | return false; | ||
5020 | } | ||
5021 | |||
5022 | private boolean jj_3R_200() { | ||
5023 | if (jj_3R_211()) return true; | ||
5024 | Token xsp; | ||
5025 | xsp = jj_scanpos; | ||
5026 | if (jj_3R_212()) jj_scanpos = xsp; | ||
5027 | return false; | ||
5028 | } | ||
5029 | |||
5030 | private boolean jj_3R_49() { | ||
5031 | if (jj_3R_105()) return true; | ||
5032 | return false; | ||
5033 | } | ||
5034 | |||
5035 | private boolean jj_3R_195() { | ||
5036 | if (jj_3R_122()) return true; | ||
5037 | return false; | ||
5038 | } | ||
5039 | |||
5040 | private boolean jj_3R_159() { | ||
5041 | if (jj_scan_token(98)) return true; | ||
5042 | return false; | ||
5043 | } | ||
5044 | |||
5045 | private boolean jj_3R_149() { | ||
5046 | if (jj_scan_token(FOR)) return true; | ||
5047 | if (jj_scan_token(55)) return true; | ||
5048 | Token xsp; | ||
5049 | xsp = jj_scanpos; | ||
5050 | if (jj_3R_225()) jj_scanpos = xsp; | ||
5051 | if (jj_scan_token(57)) return true; | ||
5052 | xsp = jj_scanpos; | ||
5053 | if (jj_3R_226()) jj_scanpos = xsp; | ||
5054 | if (jj_scan_token(57)) return true; | ||
5055 | xsp = jj_scanpos; | ||
5056 | if (jj_3R_227()) jj_scanpos = xsp; | ||
5057 | if (jj_scan_token(56)) return true; | ||
5058 | if (jj_3R_28()) return true; | ||
5059 | return false; | ||
5060 | } | ||
5061 | |||
5062 | private boolean jj_3R_194() { | ||
5063 | if (jj_3R_15()) return true; | ||
5064 | return false; | ||
5065 | } | ||
5066 | |||
5067 | private boolean jj_3R_220() { | ||
5068 | if (jj_scan_token(LONG)) return true; | ||
5069 | return false; | ||
5070 | } | ||
5071 | |||
5072 | private boolean jj_3R_158() { | ||
5073 | if (jj_scan_token(97)) return true; | ||
5074 | return false; | ||
5075 | } | ||
5076 | |||
5077 | private boolean jj_3R_16() { | ||
5078 | if (jj_3R_40()) return true; | ||
5079 | if (jj_3R_32()) return true; | ||
5080 | if (jj_3R_41()) return true; | ||
5081 | if (jj_scan_token(57)) return true; | ||
5082 | return false; | ||
5083 | } | ||
5084 | |||
5085 | private boolean jj_3R_25() { | ||
5086 | Token xsp; | ||
5087 | xsp = jj_scanpos; | ||
5088 | if (jj_3R_49()) { | ||
5089 | jj_scanpos = xsp; | ||
5090 | if (jj_3R_50()) return true; | ||
5091 | } | ||
5092 | return false; | ||
5093 | } | ||
5094 | |||
5095 | private boolean jj_3R_157() { | ||
5096 | if (jj_scan_token(92)) return true; | ||
5097 | return false; | ||
5098 | } | ||
5099 | |||
5100 | private boolean jj_3R_156() { | ||
5101 | if (jj_scan_token(91)) return true; | ||
5102 | return false; | ||
5103 | } | ||
5104 | |||
5105 | private boolean jj_3R_216() { | ||
5106 | if (jj_scan_token(LONG)) return true; | ||
5107 | Token xsp; | ||
5108 | xsp = jj_scanpos; | ||
5109 | if (jj_3R_220()) jj_scanpos = xsp; | ||
5110 | return false; | ||
5111 | } | ||
5112 | |||
5113 | private boolean jj_3R_155() { | ||
5114 | if (jj_scan_token(58)) return true; | ||
5115 | return false; | ||
5116 | } | ||
5117 | |||
5118 | private boolean jj_3R_215() { | ||
5119 | if (jj_scan_token(INT)) return true; | ||
5120 | return false; | ||
5121 | } | ||
5122 | |||
5123 | private boolean jj_3R_154() { | ||
5124 | if (jj_scan_token(82)) return true; | ||
5125 | return false; | ||
5126 | } | ||
5127 | |||
5128 | private boolean jj_3R_219() { | ||
5129 | if (jj_scan_token(INT)) return true; | ||
5130 | return false; | ||
5131 | } | ||
5132 | |||
5133 | private boolean jj_3R_201() { | ||
5134 | if (jj_scan_token(81)) return true; | ||
5135 | if (jj_3R_176()) return true; | ||
5136 | return false; | ||
5137 | } | ||
5138 | |||
5139 | private boolean jj_3R_148() { | ||
5140 | if (jj_scan_token(DO)) return true; | ||
5141 | if (jj_3R_28()) return true; | ||
5142 | if (jj_scan_token(WHILE)) return true; | ||
5143 | if (jj_scan_token(55)) return true; | ||
5144 | if (jj_3R_116()) return true; | ||
5145 | if (jj_scan_token(56)) return true; | ||
5146 | if (jj_scan_token(57)) return true; | ||
5147 | return false; | ||
5148 | } | ||
5149 | |||
5150 | private boolean jj_3R_173() { | ||
5151 | if (jj_3R_124()) return true; | ||
5152 | return false; | ||
5153 | } | ||
5154 | |||
5155 | private boolean jj_3R_176() { | ||
5156 | if (jj_3R_200()) return true; | ||
5157 | Token xsp; | ||
5158 | xsp = jj_scanpos; | ||
5159 | if (jj_3R_201()) jj_scanpos = xsp; | ||
5160 | return false; | ||
5161 | } | ||
5162 | |||
5163 | private boolean jj_3R_214() { | ||
5164 | if (jj_scan_token(SHORT)) return true; | ||
5165 | Token xsp; | ||
5166 | xsp = jj_scanpos; | ||
5167 | if (jj_3R_219()) jj_scanpos = xsp; | ||
5168 | return false; | ||
5169 | } | ||
5170 | |||
5171 | private boolean jj_3R_111() { | ||
5172 | Token xsp; | ||
5173 | xsp = jj_scanpos; | ||
5174 | if (jj_3R_154()) { | ||
5175 | jj_scanpos = xsp; | ||
5176 | if (jj_3R_155()) { | ||
5177 | jj_scanpos = xsp; | ||
5178 | if (jj_3R_156()) { | ||
5179 | jj_scanpos = xsp; | ||
5180 | if (jj_3R_157()) { | ||
5181 | jj_scanpos = xsp; | ||
5182 | if (jj_3R_158()) { | ||
5183 | jj_scanpos = xsp; | ||
5184 | if (jj_3R_159()) return true; | ||
5185 | } | ||
5186 | } | ||
5187 | } | ||
5188 | } | ||
5189 | } | ||
5190 | return false; | ||
5191 | } | ||
5192 | |||
5193 | private boolean jj_3R_19() { | ||
5194 | if (jj_3R_32()) return true; | ||
5195 | if (jj_scan_token(IDENTIFIER)) return true; | ||
5196 | Token xsp; | ||
5197 | xsp = jj_scanpos; | ||
5198 | if (jj_3R_173()) jj_scanpos = xsp; | ||
5199 | return false; | ||
5200 | } | ||
5201 | |||
5202 | private boolean jj_3R_213() { | ||
5203 | if (jj_scan_token(CHAR)) return true; | ||
5204 | return false; | ||
5205 | } | ||
5206 | |||
5207 | private boolean jj_3R_147() { | ||
5208 | if (jj_scan_token(WHILE)) return true; | ||
5209 | if (jj_scan_token(55)) return true; | ||
5210 | if (jj_3R_116()) return true; | ||
5211 | if (jj_scan_token(56)) return true; | ||
5212 | if (jj_3R_28()) return true; | ||
5213 | return false; | ||
5214 | } | ||
5215 | |||
5216 | private boolean jj_3R_206() { | ||
5217 | Token xsp; | ||
5218 | xsp = jj_scanpos; | ||
5219 | if (jj_3R_213()) { | ||
5220 | jj_scanpos = xsp; | ||
5221 | if (jj_3R_214()) { | ||
5222 | jj_scanpos = xsp; | ||
5223 | if (jj_3R_215()) { | ||
5224 | jj_scanpos = xsp; | ||
5225 | if (jj_3R_216()) return true; | ||
5226 | } | ||
5227 | } | ||
5228 | } | ||
5229 | return false; | ||
5230 | } | ||
5231 | |||
5232 | private boolean jj_3R_205() { | ||
5233 | if (jj_scan_token(UNSIGNED)) return true; | ||
5234 | return false; | ||
5235 | } | ||
5236 | |||
5237 | private boolean jj_3R_109() { | ||
5238 | Token xsp; | ||
5239 | xsp = jj_scanpos; | ||
5240 | if (jj_3R_147()) { | ||
5241 | jj_scanpos = xsp; | ||
5242 | if (jj_3R_148()) { | ||
5243 | jj_scanpos = xsp; | ||
5244 | if (jj_3R_149()) return true; | ||
5245 | } | ||
5246 | } | ||
5247 | return false; | ||
5248 | } | ||
5249 | |||
5250 | private boolean jj_3R_204() { | ||
5251 | if (jj_scan_token(SIGNED)) return true; | ||
5252 | return false; | ||
5253 | } | ||
5254 | |||
5255 | private boolean jj_3R_177() { | ||
5256 | if (jj_scan_token(80)) return true; | ||
5257 | if (jj_3R_160()) return true; | ||
5258 | return false; | ||
5259 | } | ||
5260 | |||
5261 | private boolean jj_3R_136() { | ||
5262 | if (jj_scan_token(59)) return true; | ||
5263 | if (jj_scan_token(60)) return true; | ||
5264 | return false; | ||
5265 | } | ||
5266 | |||
5267 | private boolean jj_3_16() { | ||
5268 | if (jj_3R_29()) return true; | ||
5269 | return false; | ||
5270 | } | ||
5271 | |||
5272 | private boolean jj_3R_160() { | ||
5273 | if (jj_3R_176()) return true; | ||
5274 | Token xsp; | ||
5275 | xsp = jj_scanpos; | ||
5276 | if (jj_3R_177()) jj_scanpos = xsp; | ||
5277 | return false; | ||
5278 | } | ||
5279 | |||
5280 | private boolean jj_3R_193() { | ||
5281 | Token xsp; | ||
5282 | xsp = jj_scanpos; | ||
5283 | if (jj_3R_204()) { | ||
5284 | jj_scanpos = xsp; | ||
5285 | if (jj_3R_205()) return true; | ||
5286 | } | ||
5287 | xsp = jj_scanpos; | ||
5288 | if (jj_3R_206()) jj_scanpos = xsp; | ||
5289 | return false; | ||
5290 | } | ||
5291 | |||
5292 | /** Generated Token Manager. */ | ||
5293 | public CParserTokenManager token_source; | ||
5294 | SimpleCharStream jj_input_stream; | ||
5295 | /** Current token. */ | ||
5296 | public Token token; | ||
5297 | /** Next token. */ | ||
5298 | public Token jj_nt; | ||
5299 | private int jj_ntk; | ||
5300 | private Token jj_scanpos, jj_lastpos; | ||
5301 | private int jj_la; | ||
5302 | private int jj_gen; | ||
5303 | final private int[] jj_la1 = new int[94]; | ||
5304 | static private int[] jj_la1_0; | ||
5305 | static private int[] jj_la1_1; | ||
5306 | static private int[] jj_la1_2; | ||
5307 | static private int[] jj_la1_3; | ||
5308 | static { | ||
5309 | jj_la1_init_0(); | ||
5310 | jj_la1_init_1(); | ||
5311 | jj_la1_init_2(); | ||
5312 | jj_la1_init_3(); | ||
5313 | } | ||
5314 | private static void jj_la1_init_0() { | ||
5315 | jj_la1_0 = new int[] {0xc5c00000,0x40000000,0x84800000,0x0,0x40000000,0x84800000,0x84800000,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0x0,0x84800000,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0x0,0x84800000,0x0,0x0,0x0,0x80000000,0x80000000,0x84800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80d1000,0x80d1000,0x381d1000,0x2000000,0x80d1000,0xbedd1000,0x3a1d1000,0x10000000,0x80d1000,0x80d1000,0x80d1000,0x0,0x80d1000,0x20100000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80d1000,0x0,0x8000000,0x0,0x0,0x0,0xd1000,0x0,0x8c8d1000,0xd1000,}; | ||
5316 | } | ||
5317 | private static void jj_la1_init_1() { | ||
5318 | jj_la1_1 = new int[] {0x127cf3,0x1,0x126cf2,0x22000000,0x1,0x126cf2,0x126cf2,0x8000000,0x0,0x1,0x1000,0x1000,0x20,0x20000,0x400,0x2,0x20000,0x400,0x24480,0x24480,0x126cd2,0x4000000,0x0,0x20,0x20000,0x400,0x2,0x20000,0x400,0x24480,0x24480,0x26cd2,0x4000000,0x0,0x100000,0x10,0x10,0x126cf2,0x8000000,0x0,0x80000000,0x0,0x0,0x100000,0x100000,0x100000,0x8000000,0x80000000,0x20,0x4000000,0x8000000,0x8000000,0x24900000,0x4900000,0x269d800c,0x100200,0x4900000,0x269ffeff,0x269d820c,0x40000,0x4900000,0x4900000,0x4900000,0x90004,0x4900000,0x8008,0x8000000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x4000000,0x4900000,0x800000,0x4000000,0x4000000,0x800000,0x800000,0x900000,0x8000000,0x4926cf2,0x0,}; | ||
5319 | } | ||
5320 | private static void jj_la1_init_2() { | ||
5321 | jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x3,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x98040000,0x98040000,0x98040000,0x0,0x98040000,0x98040000,0x98040000,0x0,0x98040000,0x98040000,0x98040000,0x0,0x98040000,0x0,0x0,0x1ff8,0x2000,0x4000,0x8000,0x10000,0x20000,0x40000,0x180000,0x180000,0x1e00000,0x1e00000,0x6000000,0x6000000,0x18000000,0x18000000,0x60000000,0x60000000,0x98040000,0x0,0x98040000,0x18040000,0x80000002,0x80000002,0x0,0x0,0x98040000,0x0,}; | ||
5322 | } | ||
5323 | private static void jj_la1_init_3() { | ||
5324 | jj_la1_3 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0x7,0x7,0x0,0x7,0x7,0x7,0x0,0x7,0x7,0x7,0x0,0x7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0x0,0x7,0x6,0x19,0x19,0x0,0x0,0x7,0x0,}; | ||
5325 | } | ||
5326 | final private JJCalls[] jj_2_rtns = new JJCalls[18]; | ||
5327 | private boolean jj_rescan = false; | ||
5328 | private int jj_gc = 0; | ||
5329 | |||
5330 | /** Constructor with InputStream. */ | ||
5331 | public GNUnetParser(java.io.InputStream stream) { | ||
5332 | this(stream, null); | ||
5333 | } | ||
5334 | /** Constructor with InputStream and supplied encoding */ | ||
5335 | public GNUnetParser(java.io.InputStream stream, String encoding) { | ||
5336 | try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } | ||
5337 | token_source = new CParserTokenManager(jj_input_stream); | ||
5338 | token = new Token(); | ||
5339 | jj_ntk = -1; | ||
5340 | jj_gen = 0; | ||
5341 | for (int i = 0; i < 94; i++) jj_la1[i] = -1; | ||
5342 | for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); | ||
5343 | } | ||
5344 | |||
5345 | /** Reinitialise. */ | ||
5346 | public void ReInit(java.io.InputStream stream) { | ||
5347 | ReInit(stream, null); | ||
5348 | } | ||
5349 | /** Reinitialise. */ | ||
5350 | public void ReInit(java.io.InputStream stream, String encoding) { | ||
5351 | try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } | ||
5352 | token_source.ReInit(jj_input_stream); | ||
5353 | token = new Token(); | ||
5354 | jj_ntk = -1; | ||
5355 | jj_gen = 0; | ||
5356 | for (int i = 0; i < 94; i++) jj_la1[i] = -1; | ||
5357 | for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); | ||
5358 | } | ||
5359 | |||
5360 | /** Constructor. */ | ||
5361 | public GNUnetParser(java.io.Reader stream) { | ||
5362 | jj_input_stream = new SimpleCharStream(stream, 1, 1); | ||
5363 | token_source = new CParserTokenManager(jj_input_stream); | ||
5364 | token = new Token(); | ||
5365 | jj_ntk = -1; | ||
5366 | jj_gen = 0; | ||
5367 | for (int i = 0; i < 94; i++) jj_la1[i] = -1; | ||
5368 | for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); | ||
5369 | } | ||
5370 | |||
5371 | /** Reinitialise. */ | ||
5372 | public void ReInit(java.io.Reader stream) { | ||
5373 | jj_input_stream.ReInit(stream, 1, 1); | ||
5374 | token_source.ReInit(jj_input_stream); | ||
5375 | token = new Token(); | ||
5376 | jj_ntk = -1; | ||
5377 | jj_gen = 0; | ||
5378 | for (int i = 0; i < 94; i++) jj_la1[i] = -1; | ||
5379 | for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); | ||
5380 | } | ||
5381 | |||
5382 | /** Constructor with generated Token Manager. */ | ||
5383 | public GNUnetParser(CParserTokenManager tm) { | ||
5384 | token_source = tm; | ||
5385 | token = new Token(); | ||
5386 | jj_ntk = -1; | ||
5387 | jj_gen = 0; | ||
5388 | for (int i = 0; i < 94; i++) jj_la1[i] = -1; | ||
5389 | for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); | ||
5390 | } | ||
5391 | |||
5392 | /** Reinitialise. */ | ||
5393 | public void ReInit(CParserTokenManager tm) { | ||
5394 | token_source = tm; | ||
5395 | token = new Token(); | ||
5396 | jj_ntk = -1; | ||
5397 | jj_gen = 0; | ||
5398 | for (int i = 0; i < 94; i++) jj_la1[i] = -1; | ||
5399 | for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); | ||
5400 | } | ||
5401 | |||
5402 | private Token jj_consume_token(int kind) throws ParseException { | ||
5403 | Token oldToken; | ||
5404 | if ((oldToken = token).next != null) token = token.next; | ||
5405 | else token = token.next = token_source.getNextToken(); | ||
5406 | jj_ntk = -1; | ||
5407 | if (token.kind == kind) { | ||
5408 | jj_gen++; | ||
5409 | if (++jj_gc > 100) { | ||
5410 | jj_gc = 0; | ||
5411 | for (int i = 0; i < jj_2_rtns.length; i++) { | ||
5412 | JJCalls c = jj_2_rtns[i]; | ||
5413 | while (c != null) { | ||
5414 | if (c.gen < jj_gen) c.first = null; | ||
5415 | c = c.next; | ||
5416 | } | ||
5417 | } | ||
5418 | } | ||
5419 | return token; | ||
5420 | } | ||
5421 | token = oldToken; | ||
5422 | jj_kind = kind; | ||
5423 | throw generateParseException(); | ||
5424 | } | ||
5425 | |||
5426 | static private final class LookaheadSuccess extends java.lang.Error { } | ||
5427 | final private LookaheadSuccess jj_ls = new LookaheadSuccess(); | ||
5428 | private boolean jj_scan_token(int kind) { | ||
5429 | if (jj_scanpos == jj_lastpos) { | ||
5430 | jj_la--; | ||
5431 | if (jj_scanpos.next == null) { | ||
5432 | jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken(); | ||
5433 | } else { | ||
5434 | jj_lastpos = jj_scanpos = jj_scanpos.next; | ||
5435 | } | ||
5436 | } else { | ||
5437 | jj_scanpos = jj_scanpos.next; | ||
5438 | } | ||
5439 | if (jj_rescan) { | ||
5440 | int i = 0; Token tok = token; | ||
5441 | while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; } | ||
5442 | if (tok != null) jj_add_error_token(kind, i); | ||
5443 | } | ||
5444 | if (jj_scanpos.kind != kind) return true; | ||
5445 | if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls; | ||
5446 | return false; | ||
5447 | } | ||
5448 | |||
5449 | |||
5450 | /** Get the next Token. */ | ||
5451 | final public Token getNextToken() { | ||
5452 | if (token.next != null) token = token.next; | ||
5453 | else token = token.next = token_source.getNextToken(); | ||
5454 | jj_ntk = -1; | ||
5455 | jj_gen++; | ||
5456 | return token; | ||
5457 | } | ||
5458 | |||
5459 | /** Get the specific Token. */ | ||
5460 | final public Token getToken(int index) { | ||
5461 | Token t = token; | ||
5462 | for (int i = 0; i < index; i++) { | ||
5463 | if (t.next != null) t = t.next; | ||
5464 | else t = t.next = token_source.getNextToken(); | ||
5465 | } | ||
5466 | return t; | ||
5467 | } | ||
5468 | |||
5469 | private int jj_ntk() { | ||
5470 | if ((jj_nt=token.next) == null) | ||
5471 | return (jj_ntk = (token.next=token_source.getNextToken()).kind); | ||
5472 | else | ||
5473 | return (jj_ntk = jj_nt.kind); | ||
5474 | } | ||
5475 | |||
5476 | private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>(); | ||
5477 | private int[] jj_expentry; | ||
5478 | private int jj_kind = -1; | ||
5479 | private int[] jj_lasttokens = new int[100]; | ||
5480 | private int jj_endpos; | ||
5481 | |||
5482 | private void jj_add_error_token(int kind, int pos) { | ||
5483 | if (pos >= 100) return; | ||
5484 | if (pos == jj_endpos + 1) { | ||
5485 | jj_lasttokens[jj_endpos++] = kind; | ||
5486 | } else if (jj_endpos != 0) { | ||
5487 | jj_expentry = new int[jj_endpos]; | ||
5488 | for (int i = 0; i < jj_endpos; i++) { | ||
5489 | jj_expentry[i] = jj_lasttokens[i]; | ||
5490 | } | ||
5491 | jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) { | ||
5492 | int[] oldentry = (int[])(it.next()); | ||
5493 | if (oldentry.length == jj_expentry.length) { | ||
5494 | for (int i = 0; i < jj_expentry.length; i++) { | ||
5495 | if (oldentry[i] != jj_expentry[i]) { | ||
5496 | continue jj_entries_loop; | ||
5497 | } | ||
5498 | } | ||
5499 | jj_expentries.add(jj_expentry); | ||
5500 | break jj_entries_loop; | ||
5501 | } | ||
5502 | } | ||
5503 | if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind; | ||
5504 | } | ||
5505 | } | ||
5506 | |||
5507 | /** Generate ParseException. */ | ||
5508 | public ParseException generateParseException() { | ||
5509 | jj_expentries.clear(); | ||
5510 | boolean[] la1tokens = new boolean[101]; | ||
5511 | if (jj_kind >= 0) { | ||
5512 | la1tokens[jj_kind] = true; | ||
5513 | jj_kind = -1; | ||
5514 | } | ||
5515 | for (int i = 0; i < 94; i++) { | ||
5516 | if (jj_la1[i] == jj_gen) { | ||
5517 | for (int j = 0; j < 32; j++) { | ||
5518 | if ((jj_la1_0[i] & (1<<j)) != 0) { | ||
5519 | la1tokens[j] = true; | ||
5520 | } | ||
5521 | if ((jj_la1_1[i] & (1<<j)) != 0) { | ||
5522 | la1tokens[32+j] = true; | ||
5523 | } | ||
5524 | if ((jj_la1_2[i] & (1<<j)) != 0) { | ||
5525 | la1tokens[64+j] = true; | ||
5526 | } | ||
5527 | if ((jj_la1_3[i] & (1<<j)) != 0) { | ||
5528 | la1tokens[96+j] = true; | ||
5529 | } | ||
5530 | } | ||
5531 | } | ||
5532 | } | ||
5533 | for (int i = 0; i < 101; i++) { | ||
5534 | if (la1tokens[i]) { | ||
5535 | jj_expentry = new int[1]; | ||
5536 | jj_expentry[0] = i; | ||
5537 | jj_expentries.add(jj_expentry); | ||
5538 | } | ||
5539 | } | ||
5540 | jj_endpos = 0; | ||
5541 | jj_rescan_token(); | ||
5542 | jj_add_error_token(0, 0); | ||
5543 | int[][] exptokseq = new int[jj_expentries.size()][]; | ||
5544 | for (int i = 0; i < jj_expentries.size(); i++) { | ||
5545 | exptokseq[i] = jj_expentries.get(i); | ||
5546 | } | ||
5547 | return new ParseException(token, exptokseq, tokenImage); | ||
5548 | } | ||
5549 | |||
5550 | /** Enable tracing. */ | ||
5551 | final public void enable_tracing() { | ||
5552 | } | ||
5553 | |||
5554 | /** Disable tracing. */ | ||
5555 | final public void disable_tracing() { | ||
5556 | } | ||
5557 | |||
5558 | private void jj_rescan_token() { | ||
5559 | jj_rescan = true; | ||
5560 | for (int i = 0; i < 18; i++) { | ||
5561 | try { | ||
5562 | JJCalls p = jj_2_rtns[i]; | ||
5563 | do { | ||
5564 | if (p.gen > jj_gen) { | ||
5565 | jj_la = p.arg; jj_lastpos = jj_scanpos = p.first; | ||
5566 | switch (i) { | ||
5567 | case 0: jj_3_1(); break; | ||
5568 | case 1: jj_3_2(); break; | ||
5569 | case 2: jj_3_3(); break; | ||
5570 | case 3: jj_3_4(); break; | ||
5571 | case 4: jj_3_5(); break; | ||
5572 | case 5: jj_3_6(); break; | ||
5573 | case 6: jj_3_7(); break; | ||
5574 | case 7: jj_3_8(); break; | ||
5575 | case 8: jj_3_9(); break; | ||
5576 | case 9: jj_3_10(); break; | ||
5577 | case 10: jj_3_11(); break; | ||
5578 | case 11: jj_3_12(); break; | ||
5579 | case 12: jj_3_13(); break; | ||
5580 | case 13: jj_3_14(); break; | ||
5581 | case 14: jj_3_15(); break; | ||
5582 | case 15: jj_3_16(); break; | ||
5583 | case 16: jj_3_17(); break; | ||
5584 | case 17: jj_3_18(); break; | ||
5585 | } | ||
5586 | } | ||
5587 | p = p.next; | ||
5588 | } while (p != null); | ||
5589 | } catch(LookaheadSuccess ls) { } | ||
5590 | } | ||
5591 | jj_rescan = false; | ||
5592 | } | ||
5593 | |||
5594 | private void jj_save(int index, int xla) { | ||
5595 | JJCalls p = jj_2_rtns[index]; | ||
5596 | while (p.gen > jj_gen) { | ||
5597 | if (p.next == null) { p = p.next = new JJCalls(); break; } | ||
5598 | p = p.next; | ||
5599 | } | ||
5600 | p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla; | ||
5601 | } | ||
5602 | |||
5603 | static final class JJCalls { | ||
5604 | int gen; | ||
5605 | Token first; | ||
5606 | int arg; | ||
5607 | JJCalls next; | ||
5608 | } | ||
5609 | |||
5610 | } | ||
5611 | |||
5612 | class JTBToolkit { | ||
5613 | static NodeToken makeNodeToken(Token t) { | ||
5614 | return new NodeToken(t.image.intern(), t.kind, t.beginLine, t.beginColumn, t.endLine, t.endColumn); | ||
5615 | } | ||
5616 | } | ||
diff --git a/contrib/gnunet-tree-builder/gtb b/contrib/gnunet-tree-builder/gtb deleted file mode 100755 index d57dfdc3f..000000000 --- a/contrib/gnunet-tree-builder/gtb +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #!/bin/sh | ||
2 | # gtb: gnunet tree builder | ||
3 | # Script for automating the generation of GNUnet syntax tree | ||
4 | # MAINDIR: GNUnet workspace | ||
5 | |||
6 | $MAINDIR/contrib/gnunet-tree-builder/regenerate \ No newline at end of file | ||
diff --git a/contrib/gnunet-tree-builder/regenerate b/contrib/gnunet-tree-builder/regenerate deleted file mode 100755 index fd5696a2a..000000000 --- a/contrib/gnunet-tree-builder/regenerate +++ /dev/null | |||
@@ -1,20 +0,0 @@ | |||
1 | #!/bin/sh | ||
2 | # MAINDIR: Environment Variable for GNUnet workspace | ||
3 | # Note: The script will generate the grammar file C.out.jj under src/monkey | ||
4 | |||
5 | rm -f *.java | ||
6 | mkdir -p org/gnunet/monkey/parser | ||
7 | cd org/gnunet/monkey/parser | ||
8 | jtb -printer -jd -np org.gnunet.monkey.parser.nodes -vp org.gnunet.monkey.parser.visitors -o $MAINDIR/src/monkey/C.out.jj $MAINDIR/src/monkey/C.jj | ||
9 | javacc -STATIC=false $MAINDIR/src/monkey/C.out.jj | ||
10 | |||
11 | echo 'package org.gnunet.monkey.parser;' > PACKAGE | ||
12 | for n in *.java | ||
13 | do | ||
14 | cat $n >> PACKAGE | ||
15 | mv PACKAGE $n | ||
16 | echo 'package org.gnunet.monkey.parser;' > PACKAGE | ||
17 | done | ||
18 | |||
19 | rm -f PACKAGE | ||
20 | \ No newline at end of file | ||