diff options
-rw-r--r-- | src/monkey/seaspider/C.jj | 43 | ||||
-rwxr-xr-x | src/monkey/seaspider/Makefile | 4 | ||||
-rw-r--r-- | src/monkey/seaspider/org/gnunet/seaspider/ExpressionDatabaseHandler.java | 15 | ||||
-rw-r--r-- | src/monkey/seaspider/org/gnunet/seaspider/ExpressionExtractorVisitor.java | 578 | ||||
-rw-r--r-- | src/monkey/seaspider/org/gnunet/seaspider/Seaspider.java | 5581 | ||||
-rw-r--r-- | src/monkey/seaspider/org/grothoff/LineNumberInfo.java | 2 |
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 : { | |||
171 | void TranslationUnit() : {} | 171 | void TranslationUnit() : {} |
172 | { | 172 | { |
173 | (ExternalDeclaration())+ | 173 | (ExternalDeclaration())+ |
174 | <EOF> | ||
174 | } | 175 | } |
175 | 176 | ||
176 | void ExternalDeclaration() : {} | 177 | void 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() : {} | |||
288 | void StructOrUnionSpecifier() : {} | 289 | void 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 | ||
295 | void StructOrUnion() : {} | 296 | void StructOrUnion() : {} |
@@ -299,7 +300,7 @@ void StructOrUnion() : {} | |||
299 | 300 | ||
300 | void StructDeclarationList() : {} | 301 | void StructDeclarationList() : {} |
301 | { | 302 | { |
302 | (StructDeclaration())+ | 303 | (StructDeclaration())* |
303 | } | 304 | } |
304 | 305 | ||
305 | void InitDeclaratorList() : {} | 306 | void InitDeclaratorList() : {} |
@@ -337,11 +338,6 @@ void Pointer() : {} | |||
337 | "*" [ <CONST> ] [ Pointer() ] | 338 | "*" [ <CONST> ] [ Pointer() ] |
338 | } | 339 | } |
339 | 340 | ||
340 | void IdentifierList() : {} | ||
341 | { | ||
342 | <IDENTIFIER> ("," <IDENTIFIER>)* | ||
343 | } | ||
344 | |||
345 | void Initializer() : {} | 341 | void Initializer() : {} |
346 | { | 342 | { |
347 | ( AssignmentExpression() | | 343 | ( AssignmentExpression() | |
@@ -390,15 +386,34 @@ void CompoundStatement() : {} | |||
390 | 386 | ||
391 | void SelectionStatement() : {} | 387 | void SelectionStatement() : {} |
392 | { | 388 | { |
393 | ( <IF> "(" Expression() ")" Statement() [ LOOKAHEAD(2) <ELSE> Statement() ] | | 389 | ( IfStatement() | SwitchStatement() ) |
394 | <SWITCH> "(" Expression() ")" Statement() ) | 390 | } |
391 | |||
392 | void IfStatement() : {} | ||
393 | { | ||
394 | <IF> "(" Expression() ")" Statement() [ LOOKAHEAD(2) <ELSE> Statement() ] | ||
395 | } | ||
396 | |||
397 | void SwitchStatement() : {} | ||
398 | { | ||
399 | <SWITCH> "(" Expression() ")" Statement() | ||
395 | } | 400 | } |
396 | 401 | ||
397 | void IterationStatement() : {} | 402 | void IterationStatement() : {} |
398 | { | 403 | { |
399 | ( <WHILE> "(" Expression() ")" Statement() | | 404 | ( WhileStatement() | DoWhileStatement() | ForStatement() ) |
400 | <DO> Statement() <WHILE> "(" Expression() ")" ";" | | 405 | } |
401 | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() ) | 406 | void WhileStatement() : {} |
407 | { | ||
408 | <WHILE> "(" Expression() ")" Statement() | ||
409 | } | ||
410 | void DoWhileStatement() : {} | ||
411 | { | ||
412 | <DO> Statement() <WHILE> "(" Expression() ")" ";" | ||
413 | } | ||
414 | void ForStatement() : {} | ||
415 | { | ||
416 | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() | ||
402 | } | 417 | } |
403 | 418 | ||
404 | void JumpStatement() : {} | 419 | void 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 @@ | |||
1 | all: | 1 | all: |
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 @@ | |||
1 | package org.gnunet.seaspider.parser; | 1 | package org.gnunet.seaspider; |
2 | 2 | ||
3 | import java.io.File; | 3 | import 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 @@ | |||
1 | package org.gnunet.seaspider; | ||
2 | |||
3 | import org.gnunet.seaspider.parser.nodes.ANDExpression; | ||
4 | import org.gnunet.seaspider.parser.nodes.AdditiveExpression; | ||
5 | import org.gnunet.seaspider.parser.nodes.ArgumentExpressionList; | ||
6 | import org.gnunet.seaspider.parser.nodes.AssignmentExpression; | ||
7 | import org.gnunet.seaspider.parser.nodes.AssignmentOperator; | ||
8 | import org.gnunet.seaspider.parser.nodes.CastExpression; | ||
9 | import org.gnunet.seaspider.parser.nodes.CompoundStatement; | ||
10 | import org.gnunet.seaspider.parser.nodes.ConditionalExpression; | ||
11 | import org.gnunet.seaspider.parser.nodes.ConstantExpression; | ||
12 | import org.gnunet.seaspider.parser.nodes.DoWhileStatement; | ||
13 | import org.gnunet.seaspider.parser.nodes.EqualityExpression; | ||
14 | import org.gnunet.seaspider.parser.nodes.ExclusiveORExpression; | ||
15 | import org.gnunet.seaspider.parser.nodes.Expression; | ||
16 | import org.gnunet.seaspider.parser.nodes.ExpressionStatement; | ||
17 | import org.gnunet.seaspider.parser.nodes.ForStatement; | ||
18 | import org.gnunet.seaspider.parser.nodes.FunctionDeclaration; | ||
19 | import org.gnunet.seaspider.parser.nodes.IfStatement; | ||
20 | import org.gnunet.seaspider.parser.nodes.InclusiveORExpression; | ||
21 | import org.gnunet.seaspider.parser.nodes.InitDeclarator; | ||
22 | import org.gnunet.seaspider.parser.nodes.JumpStatement; | ||
23 | import org.gnunet.seaspider.parser.nodes.LogicalANDExpression; | ||
24 | import org.gnunet.seaspider.parser.nodes.LogicalORExpression; | ||
25 | import org.gnunet.seaspider.parser.nodes.MultiplicativeExpression; | ||
26 | import org.gnunet.seaspider.parser.nodes.NodeChoice; | ||
27 | import org.gnunet.seaspider.parser.nodes.NodeSequence; | ||
28 | import org.gnunet.seaspider.parser.nodes.NodeToken; | ||
29 | import org.gnunet.seaspider.parser.nodes.ParameterDeclaration; | ||
30 | import org.gnunet.seaspider.parser.nodes.PostfixExpression; | ||
31 | import org.gnunet.seaspider.parser.nodes.PrimaryExpression; | ||
32 | import org.gnunet.seaspider.parser.nodes.RelationalExpression; | ||
33 | import org.gnunet.seaspider.parser.nodes.ShiftExpression; | ||
34 | import org.gnunet.seaspider.parser.nodes.StructOrUnionSpecifier; | ||
35 | import org.gnunet.seaspider.parser.nodes.SwitchStatement; | ||
36 | import org.gnunet.seaspider.parser.nodes.TranslationUnit; | ||
37 | import org.gnunet.seaspider.parser.nodes.TypeDeclaration; | ||
38 | import org.gnunet.seaspider.parser.nodes.UnaryExpression; | ||
39 | import org.gnunet.seaspider.parser.nodes.UnaryOperator; | ||
40 | import org.gnunet.seaspider.parser.nodes.WhileStatement; | ||
41 | import org.gnunet.seaspider.parser.visitors.DepthFirstVisitor; | ||
42 | import org.grothoff.LineNumberInfo; | ||
43 | |||
44 | /** | ||
45 | * @author grothoff | ||
46 | * | ||
47 | */ | ||
48 | public 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 @@ | |||
1 | package org.gnunet.seaspider.parser; | 1 | package org.gnunet.seaspider; |
2 | /* Generated By:JavaCC: Do not edit this line. CParser.java */ | 2 | |
3 | import java.io.File; | 3 | import java.io.File; |
4 | import java.io.FileFilter; | 4 | import java.io.FileFilter; |
5 | import java.io.FileInputStream; | 5 | import java.io.FileInputStream; |
6 | import java.io.FileNotFoundException; | 6 | import java.io.FileNotFoundException; |
7 | 7 | ||
8 | import org.gnunet.seaspider.parser.nodes.*; | 8 | import org.gnunet.seaspider.parser.CParser; |
9 | import org.gnunet.seaspider.parser.visitors.GNUnetDepthFirstVisitor; | 9 | import org.gnunet.seaspider.parser.ParseException; |
10 | import org.gnunet.seaspider.parser.nodes.Node; | ||
10 | 11 | ||
11 | public class GNUnetParser implements CParserConstants { | 12 | public 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 | |||
5630 | class 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 @@ | |||
1 | package org.gnunet.seaspider.parser; | 1 | package org.grothoff; |
2 | 2 | ||
3 | import java.lang.reflect.Field; | 3 | import java.lang.reflect.Field; |
4 | import java.util.Enumeration; | 4 | import java.util.Enumeration; |