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