diff options
Diffstat (limited to 'src')
85 files changed, 17043 insertions, 0 deletions
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/CParserConstants.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/CParserConstants.java new file mode 100644 index 000000000..44bd0d411 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/CParserConstants.java | |||
@@ -0,0 +1,209 @@ | |||
1 | package org.gnunet.seaspider.parser; | ||
2 | /* Generated By:JavaCC: Do not edit this line. CParserConstants.java */ | ||
3 | |||
4 | /** | ||
5 | * Token literal values and constants. | ||
6 | * Generated by org.javacc.parser.OtherFilesGen#start() | ||
7 | */ | ||
8 | public interface CParserConstants { | ||
9 | |||
10 | /** End of File. */ | ||
11 | int EOF = 0; | ||
12 | /** RegularExpression Id. */ | ||
13 | int INTEGER_LITERAL = 12; | ||
14 | /** RegularExpression Id. */ | ||
15 | int DECIMAL_LITERAL = 13; | ||
16 | /** RegularExpression Id. */ | ||
17 | int HEX_LITERAL = 14; | ||
18 | /** RegularExpression Id. */ | ||
19 | int OCTAL_LITERAL = 15; | ||
20 | /** RegularExpression Id. */ | ||
21 | int FLOATING_POINT_LITERAL = 16; | ||
22 | /** RegularExpression Id. */ | ||
23 | int EXPONENT = 17; | ||
24 | /** RegularExpression Id. */ | ||
25 | int CHARACTER_LITERAL = 18; | ||
26 | /** RegularExpression Id. */ | ||
27 | int STRING_LITERAL = 19; | ||
28 | /** RegularExpression Id. */ | ||
29 | int CONTINUE = 20; | ||
30 | /** RegularExpression Id. */ | ||
31 | int VOLATILE = 21; | ||
32 | /** RegularExpression Id. */ | ||
33 | int REGISTER = 22; | ||
34 | /** RegularExpression Id. */ | ||
35 | int UNSIGNED = 23; | ||
36 | /** RegularExpression Id. */ | ||
37 | int TYPEDEF = 24; | ||
38 | /** RegularExpression Id. */ | ||
39 | int DFLT = 25; | ||
40 | /** RegularExpression Id. */ | ||
41 | int DOUBLE = 26; | ||
42 | /** RegularExpression Id. */ | ||
43 | int SIZEOF = 27; | ||
44 | /** RegularExpression Id. */ | ||
45 | int SWITCH = 28; | ||
46 | /** RegularExpression Id. */ | ||
47 | int RETURN = 29; | ||
48 | /** RegularExpression Id. */ | ||
49 | int EXTERN = 30; | ||
50 | /** RegularExpression Id. */ | ||
51 | int STRUCT = 31; | ||
52 | /** RegularExpression Id. */ | ||
53 | int STATIC = 32; | ||
54 | /** RegularExpression Id. */ | ||
55 | int SIGNED = 33; | ||
56 | /** RegularExpression Id. */ | ||
57 | int WHILE = 34; | ||
58 | /** RegularExpression Id. */ | ||
59 | int BREAK = 35; | ||
60 | /** RegularExpression Id. */ | ||
61 | int UNION = 36; | ||
62 | /** RegularExpression Id. */ | ||
63 | int CONST = 37; | ||
64 | /** RegularExpression Id. */ | ||
65 | int FLOAT = 38; | ||
66 | /** RegularExpression Id. */ | ||
67 | int SHORT = 39; | ||
68 | /** RegularExpression Id. */ | ||
69 | int ELSE = 40; | ||
70 | /** RegularExpression Id. */ | ||
71 | int CASE = 41; | ||
72 | /** RegularExpression Id. */ | ||
73 | int LONG = 42; | ||
74 | /** RegularExpression Id. */ | ||
75 | int ENUM = 43; | ||
76 | /** RegularExpression Id. */ | ||
77 | int AUTO = 44; | ||
78 | /** RegularExpression Id. */ | ||
79 | int VOID = 45; | ||
80 | /** RegularExpression Id. */ | ||
81 | int CHAR = 46; | ||
82 | /** RegularExpression Id. */ | ||
83 | int GOTO = 47; | ||
84 | /** RegularExpression Id. */ | ||
85 | int FOR = 48; | ||
86 | /** RegularExpression Id. */ | ||
87 | int INT = 49; | ||
88 | /** RegularExpression Id. */ | ||
89 | int IF = 50; | ||
90 | /** RegularExpression Id. */ | ||
91 | int DO = 51; | ||
92 | /** RegularExpression Id. */ | ||
93 | int IDENTIFIER = 52; | ||
94 | /** RegularExpression Id. */ | ||
95 | int LETTER = 53; | ||
96 | /** RegularExpression Id. */ | ||
97 | int DIGIT = 54; | ||
98 | |||
99 | /** Lexical state. */ | ||
100 | int DEFAULT = 0; | ||
101 | /** Lexical state. */ | ||
102 | int PREPROCESSOR_OUTPUT = 1; | ||
103 | |||
104 | /** Literal token values. */ | ||
105 | String[] tokenImage = { | ||
106 | "<EOF>", | ||
107 | "\" \"", | ||
108 | "\"\\t\"", | ||
109 | "\"\\n\"", | ||
110 | "\"\\r\"", | ||
111 | "<token of kind 5>", | ||
112 | "<token of kind 6>", | ||
113 | "\"#\"", | ||
114 | "\"\\n\"", | ||
115 | "\"\\\\\\n\"", | ||
116 | "\"\\\\\\r\\n\"", | ||
117 | "<token of kind 11>", | ||
118 | "<INTEGER_LITERAL>", | ||
119 | "<DECIMAL_LITERAL>", | ||
120 | "<HEX_LITERAL>", | ||
121 | "<OCTAL_LITERAL>", | ||
122 | "<FLOATING_POINT_LITERAL>", | ||
123 | "<EXPONENT>", | ||
124 | "<CHARACTER_LITERAL>", | ||
125 | "<STRING_LITERAL>", | ||
126 | "\"continue\"", | ||
127 | "\"volatile\"", | ||
128 | "\"register\"", | ||
129 | "\"unsigned\"", | ||
130 | "\"typedef\"", | ||
131 | "\"default\"", | ||
132 | "\"double\"", | ||
133 | "\"sizeof\"", | ||
134 | "\"switch\"", | ||
135 | "\"return\"", | ||
136 | "\"extern\"", | ||
137 | "\"struct\"", | ||
138 | "\"static\"", | ||
139 | "\"signed\"", | ||
140 | "\"while\"", | ||
141 | "\"break\"", | ||
142 | "\"union\"", | ||
143 | "\"const\"", | ||
144 | "\"float\"", | ||
145 | "\"short\"", | ||
146 | "\"else\"", | ||
147 | "\"case\"", | ||
148 | "\"long\"", | ||
149 | "\"enum\"", | ||
150 | "\"auto\"", | ||
151 | "\"void\"", | ||
152 | "\"char\"", | ||
153 | "\"goto\"", | ||
154 | "\"for\"", | ||
155 | "\"int\"", | ||
156 | "\"if\"", | ||
157 | "\"do\"", | ||
158 | "<IDENTIFIER>", | ||
159 | "<LETTER>", | ||
160 | "<DIGIT>", | ||
161 | "\"(\"", | ||
162 | "\")\"", | ||
163 | "\";\"", | ||
164 | "\"*\"", | ||
165 | "\",\"", | ||
166 | "\"...\"", | ||
167 | "\"{\"", | ||
168 | "\"}\"", | ||
169 | "\"=\"", | ||
170 | "\":\"", | ||
171 | "\"[\"", | ||
172 | "\"]\"", | ||
173 | "\"*=\"", | ||
174 | "\"/=\"", | ||
175 | "\"%=\"", | ||
176 | "\"+=\"", | ||
177 | "\"-=\"", | ||
178 | "\"<<=\"", | ||
179 | "\">>=\"", | ||
180 | "\"&=\"", | ||
181 | "\"^=\"", | ||
182 | "\"|=\"", | ||
183 | "\"?\"", | ||
184 | "\"||\"", | ||
185 | "\"&&\"", | ||
186 | "\"|\"", | ||
187 | "\"^\"", | ||
188 | "\"&\"", | ||
189 | "\"==\"", | ||
190 | "\"!=\"", | ||
191 | "\"<\"", | ||
192 | "\">\"", | ||
193 | "\"<=\"", | ||
194 | "\">=\"", | ||
195 | "\"<<\"", | ||
196 | "\">>\"", | ||
197 | "\"+\"", | ||
198 | "\"-\"", | ||
199 | "\"/\"", | ||
200 | "\"%\"", | ||
201 | "\"++\"", | ||
202 | "\"--\"", | ||
203 | "\"~\"", | ||
204 | "\"!\"", | ||
205 | "\".\"", | ||
206 | "\"->\"", | ||
207 | }; | ||
208 | |||
209 | } | ||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/CParserTokenManager.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/CParserTokenManager.java new file mode 100644 index 000000000..41930bf36 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/CParserTokenManager.java | |||
@@ -0,0 +1,1413 @@ | |||
1 | package org.gnunet.seaspider.parser; | ||
2 | /* Generated By:JavaCC: Do not edit this line. CParserTokenManager.java */ | ||
3 | import java.util.*; | ||
4 | |||
5 | import org.gnunet.seaspider.parser.nodes.*; | ||
6 | |||
7 | import java.util.Vector; | ||
8 | |||
9 | /** Token Manager. */ | ||
10 | public class CParserTokenManager implements CParserConstants | ||
11 | { | ||
12 | |||
13 | /** Debug output. */ | ||
14 | public java.io.PrintStream debugStream = System.out; | ||
15 | /** Set debug output. */ | ||
16 | public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } | ||
17 | private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1) | ||
18 | { | ||
19 | switch (pos) | ||
20 | { | ||
21 | case 0: | ||
22 | if ((active1 & 0x20000010L) != 0L) | ||
23 | return 65; | ||
24 | if ((active0 & 0xffffffff00000L) != 0L) | ||
25 | { | ||
26 | jjmatchedKind = 52; | ||
27 | return 42; | ||
28 | } | ||
29 | if ((active0 & 0x1000000000000000L) != 0L || (active1 & 0x800000000L) != 0L) | ||
30 | return 5; | ||
31 | return -1; | ||
32 | case 1: | ||
33 | if ((active0 & 0xc000004000000L) != 0L) | ||
34 | return 42; | ||
35 | if ((active0 & 0x3fffffbf00000L) != 0L) | ||
36 | { | ||
37 | if (jjmatchedPos != 1) | ||
38 | { | ||
39 | jjmatchedKind = 52; | ||
40 | jjmatchedPos = 1; | ||
41 | } | ||
42 | return 42; | ||
43 | } | ||
44 | return -1; | ||
45 | case 2: | ||
46 | if ((active0 & 0xfffffff00000L) != 0L) | ||
47 | { | ||
48 | jjmatchedKind = 52; | ||
49 | jjmatchedPos = 2; | ||
50 | return 42; | ||
51 | } | ||
52 | if ((active0 & 0x3000000000000L) != 0L) | ||
53 | return 42; | ||
54 | return -1; | ||
55 | case 3: | ||
56 | if ((active0 & 0xfffff00000L) != 0L) | ||
57 | { | ||
58 | jjmatchedKind = 52; | ||
59 | jjmatchedPos = 3; | ||
60 | return 42; | ||
61 | } | ||
62 | if ((active0 & 0xff0000000000L) != 0L) | ||
63 | return 42; | ||
64 | return -1; | ||
65 | case 4: | ||
66 | if ((active0 & 0x3fff00000L) != 0L) | ||
67 | { | ||
68 | jjmatchedKind = 52; | ||
69 | jjmatchedPos = 4; | ||
70 | return 42; | ||
71 | } | ||
72 | if ((active0 & 0xfc00000000L) != 0L) | ||
73 | return 42; | ||
74 | return -1; | ||
75 | case 5: | ||
76 | if ((active0 & 0x3fc000000L) != 0L) | ||
77 | return 42; | ||
78 | if ((active0 & 0x3f00000L) != 0L) | ||
79 | { | ||
80 | jjmatchedKind = 52; | ||
81 | jjmatchedPos = 5; | ||
82 | return 42; | ||
83 | } | ||
84 | return -1; | ||
85 | case 6: | ||
86 | if ((active0 & 0xf00000L) != 0L) | ||
87 | { | ||
88 | jjmatchedKind = 52; | ||
89 | jjmatchedPos = 6; | ||
90 | return 42; | ||
91 | } | ||
92 | if ((active0 & 0x3000000L) != 0L) | ||
93 | return 42; | ||
94 | return -1; | ||
95 | default : | ||
96 | return -1; | ||
97 | } | ||
98 | } | ||
99 | private final int jjStartNfa_0(int pos, long active0, long active1) | ||
100 | { | ||
101 | return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1); | ||
102 | } | ||
103 | private int jjStopAtPos(int pos, int kind) | ||
104 | { | ||
105 | jjmatchedKind = kind; | ||
106 | jjmatchedPos = pos; | ||
107 | return pos + 1; | ||
108 | } | ||
109 | private int jjMoveStringLiteralDfa0_0() | ||
110 | { | ||
111 | switch(curChar) | ||
112 | { | ||
113 | case 33: | ||
114 | jjmatchedKind = 98; | ||
115 | return jjMoveStringLiteralDfa1_0(0x0L, 0x100000L); | ||
116 | case 35: | ||
117 | return jjStopAtPos(0, 7); | ||
118 | case 37: | ||
119 | jjmatchedKind = 94; | ||
120 | return jjMoveStringLiteralDfa1_0(0x0L, 0x20L); | ||
121 | case 38: | ||
122 | jjmatchedKind = 82; | ||
123 | return jjMoveStringLiteralDfa1_0(0x0L, 0x8400L); | ||
124 | case 40: | ||
125 | return jjStopAtPos(0, 55); | ||
126 | case 41: | ||
127 | return jjStopAtPos(0, 56); | ||
128 | case 42: | ||
129 | jjmatchedKind = 58; | ||
130 | return jjMoveStringLiteralDfa1_0(0x0L, 0x8L); | ||
131 | case 43: | ||
132 | jjmatchedKind = 91; | ||
133 | return jjMoveStringLiteralDfa1_0(0x0L, 0x80000040L); | ||
134 | case 44: | ||
135 | return jjStopAtPos(0, 59); | ||
136 | case 45: | ||
137 | jjmatchedKind = 92; | ||
138 | return jjMoveStringLiteralDfa1_0(0x0L, 0x1100000080L); | ||
139 | case 46: | ||
140 | jjmatchedKind = 99; | ||
141 | return jjMoveStringLiteralDfa1_0(0x1000000000000000L, 0x0L); | ||
142 | case 47: | ||
143 | jjmatchedKind = 93; | ||
144 | return jjMoveStringLiteralDfa1_0(0x0L, 0x10L); | ||
145 | case 58: | ||
146 | return jjStopAtPos(0, 64); | ||
147 | case 59: | ||
148 | return jjStopAtPos(0, 57); | ||
149 | case 60: | ||
150 | jjmatchedKind = 85; | ||
151 | return jjMoveStringLiteralDfa1_0(0x0L, 0x2800100L); | ||
152 | case 61: | ||
153 | jjmatchedKind = 63; | ||
154 | return jjMoveStringLiteralDfa1_0(0x0L, 0x80000L); | ||
155 | case 62: | ||
156 | jjmatchedKind = 86; | ||
157 | return jjMoveStringLiteralDfa1_0(0x0L, 0x5000200L); | ||
158 | case 63: | ||
159 | return jjStopAtPos(0, 77); | ||
160 | case 91: | ||
161 | return jjStopAtPos(0, 65); | ||
162 | case 93: | ||
163 | return jjStopAtPos(0, 66); | ||
164 | case 94: | ||
165 | jjmatchedKind = 81; | ||
166 | return jjMoveStringLiteralDfa1_0(0x0L, 0x800L); | ||
167 | case 97: | ||
168 | return jjMoveStringLiteralDfa1_0(0x100000000000L, 0x0L); | ||
169 | case 98: | ||
170 | return jjMoveStringLiteralDfa1_0(0x800000000L, 0x0L); | ||
171 | case 99: | ||
172 | return jjMoveStringLiteralDfa1_0(0x422000100000L, 0x0L); | ||
173 | case 100: | ||
174 | return jjMoveStringLiteralDfa1_0(0x8000006000000L, 0x0L); | ||
175 | case 101: | ||
176 | return jjMoveStringLiteralDfa1_0(0x90040000000L, 0x0L); | ||
177 | case 102: | ||
178 | return jjMoveStringLiteralDfa1_0(0x1004000000000L, 0x0L); | ||
179 | case 103: | ||
180 | return jjMoveStringLiteralDfa1_0(0x800000000000L, 0x0L); | ||
181 | case 105: | ||
182 | return jjMoveStringLiteralDfa1_0(0x6000000000000L, 0x0L); | ||
183 | case 108: | ||
184 | return jjMoveStringLiteralDfa1_0(0x40000000000L, 0x0L); | ||
185 | case 114: | ||
186 | return jjMoveStringLiteralDfa1_0(0x20400000L, 0x0L); | ||
187 | case 115: | ||
188 | return jjMoveStringLiteralDfa1_0(0x8398000000L, 0x0L); | ||
189 | case 116: | ||
190 | return jjMoveStringLiteralDfa1_0(0x1000000L, 0x0L); | ||
191 | case 117: | ||
192 | return jjMoveStringLiteralDfa1_0(0x1000800000L, 0x0L); | ||
193 | case 118: | ||
194 | return jjMoveStringLiteralDfa1_0(0x200000200000L, 0x0L); | ||
195 | case 119: | ||
196 | return jjMoveStringLiteralDfa1_0(0x400000000L, 0x0L); | ||
197 | case 123: | ||
198 | return jjStopAtPos(0, 61); | ||
199 | case 124: | ||
200 | jjmatchedKind = 80; | ||
201 | return jjMoveStringLiteralDfa1_0(0x0L, 0x5000L); | ||
202 | case 125: | ||
203 | return jjStopAtPos(0, 62); | ||
204 | case 126: | ||
205 | return jjStopAtPos(0, 97); | ||
206 | default : | ||
207 | return jjMoveNfa_0(0, 0); | ||
208 | } | ||
209 | } | ||
210 | private int jjMoveStringLiteralDfa1_0(long active0, long active1) | ||
211 | { | ||
212 | try { curChar = input_stream.readChar(); } | ||
213 | catch(java.io.IOException e) { | ||
214 | jjStopStringLiteralDfa_0(0, active0, active1); | ||
215 | return 1; | ||
216 | } | ||
217 | switch(curChar) | ||
218 | { | ||
219 | case 38: | ||
220 | if ((active1 & 0x8000L) != 0L) | ||
221 | return jjStopAtPos(1, 79); | ||
222 | break; | ||
223 | case 43: | ||
224 | if ((active1 & 0x80000000L) != 0L) | ||
225 | return jjStopAtPos(1, 95); | ||
226 | break; | ||
227 | case 45: | ||
228 | if ((active1 & 0x100000000L) != 0L) | ||
229 | return jjStopAtPos(1, 96); | ||
230 | break; | ||
231 | case 46: | ||
232 | return jjMoveStringLiteralDfa2_0(active0, 0x1000000000000000L, active1, 0L); | ||
233 | case 60: | ||
234 | if ((active1 & 0x2000000L) != 0L) | ||
235 | { | ||
236 | jjmatchedKind = 89; | ||
237 | jjmatchedPos = 1; | ||
238 | } | ||
239 | return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x100L); | ||
240 | case 61: | ||
241 | if ((active1 & 0x8L) != 0L) | ||
242 | return jjStopAtPos(1, 67); | ||
243 | else if ((active1 & 0x10L) != 0L) | ||
244 | return jjStopAtPos(1, 68); | ||
245 | else if ((active1 & 0x20L) != 0L) | ||
246 | return jjStopAtPos(1, 69); | ||
247 | else if ((active1 & 0x40L) != 0L) | ||
248 | return jjStopAtPos(1, 70); | ||
249 | else if ((active1 & 0x80L) != 0L) | ||
250 | return jjStopAtPos(1, 71); | ||
251 | else if ((active1 & 0x400L) != 0L) | ||
252 | return jjStopAtPos(1, 74); | ||
253 | else if ((active1 & 0x800L) != 0L) | ||
254 | return jjStopAtPos(1, 75); | ||
255 | else if ((active1 & 0x1000L) != 0L) | ||
256 | return jjStopAtPos(1, 76); | ||
257 | else if ((active1 & 0x80000L) != 0L) | ||
258 | return jjStopAtPos(1, 83); | ||
259 | else if ((active1 & 0x100000L) != 0L) | ||
260 | return jjStopAtPos(1, 84); | ||
261 | else if ((active1 & 0x800000L) != 0L) | ||
262 | return jjStopAtPos(1, 87); | ||
263 | else if ((active1 & 0x1000000L) != 0L) | ||
264 | return jjStopAtPos(1, 88); | ||
265 | break; | ||
266 | case 62: | ||
267 | if ((active1 & 0x4000000L) != 0L) | ||
268 | { | ||
269 | jjmatchedKind = 90; | ||
270 | jjmatchedPos = 1; | ||
271 | } | ||
272 | else if ((active1 & 0x1000000000L) != 0L) | ||
273 | return jjStopAtPos(1, 100); | ||
274 | return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x200L); | ||
275 | case 97: | ||
276 | return jjMoveStringLiteralDfa2_0(active0, 0x20000000000L, active1, 0L); | ||
277 | case 101: | ||
278 | return jjMoveStringLiteralDfa2_0(active0, 0x22400000L, active1, 0L); | ||
279 | case 102: | ||
280 | if ((active0 & 0x4000000000000L) != 0L) | ||
281 | return jjStartNfaWithStates_0(1, 50, 42); | ||
282 | break; | ||
283 | case 104: | ||
284 | return jjMoveStringLiteralDfa2_0(active0, 0x408400000000L, active1, 0L); | ||
285 | case 105: | ||
286 | return jjMoveStringLiteralDfa2_0(active0, 0x208000000L, active1, 0L); | ||
287 | case 108: | ||
288 | return jjMoveStringLiteralDfa2_0(active0, 0x14000000000L, active1, 0L); | ||
289 | case 110: | ||
290 | return jjMoveStringLiteralDfa2_0(active0, 0x2081000800000L, active1, 0L); | ||
291 | case 111: | ||
292 | if ((active0 & 0x8000000000000L) != 0L) | ||
293 | { | ||
294 | jjmatchedKind = 51; | ||
295 | jjmatchedPos = 1; | ||
296 | } | ||
297 | return jjMoveStringLiteralDfa2_0(active0, 0x1a42004300000L, active1, 0L); | ||
298 | case 114: | ||
299 | return jjMoveStringLiteralDfa2_0(active0, 0x800000000L, active1, 0L); | ||
300 | case 116: | ||
301 | return jjMoveStringLiteralDfa2_0(active0, 0x180000000L, active1, 0L); | ||
302 | case 117: | ||
303 | return jjMoveStringLiteralDfa2_0(active0, 0x100000000000L, active1, 0L); | ||
304 | case 119: | ||
305 | return jjMoveStringLiteralDfa2_0(active0, 0x10000000L, active1, 0L); | ||
306 | case 120: | ||
307 | return jjMoveStringLiteralDfa2_0(active0, 0x40000000L, active1, 0L); | ||
308 | case 121: | ||
309 | return jjMoveStringLiteralDfa2_0(active0, 0x1000000L, active1, 0L); | ||
310 | case 124: | ||
311 | if ((active1 & 0x4000L) != 0L) | ||
312 | return jjStopAtPos(1, 78); | ||
313 | break; | ||
314 | default : | ||
315 | break; | ||
316 | } | ||
317 | return jjStartNfa_0(0, active0, active1); | ||
318 | } | ||
319 | private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1) | ||
320 | { | ||
321 | if (((active0 &= old0) | (active1 &= old1)) == 0L) | ||
322 | return jjStartNfa_0(0, old0, old1); | ||
323 | try { curChar = input_stream.readChar(); } | ||
324 | catch(java.io.IOException e) { | ||
325 | jjStopStringLiteralDfa_0(1, active0, active1); | ||
326 | return 2; | ||
327 | } | ||
328 | switch(curChar) | ||
329 | { | ||
330 | case 46: | ||
331 | if ((active0 & 0x1000000000000000L) != 0L) | ||
332 | return jjStopAtPos(2, 60); | ||
333 | break; | ||
334 | case 61: | ||
335 | if ((active1 & 0x100L) != 0L) | ||
336 | return jjStopAtPos(2, 72); | ||
337 | else if ((active1 & 0x200L) != 0L) | ||
338 | return jjStopAtPos(2, 73); | ||
339 | break; | ||
340 | case 97: | ||
341 | return jjMoveStringLiteralDfa3_0(active0, 0x400100000000L, active1, 0L); | ||
342 | case 101: | ||
343 | return jjMoveStringLiteralDfa3_0(active0, 0x800000000L, active1, 0L); | ||
344 | case 102: | ||
345 | return jjMoveStringLiteralDfa3_0(active0, 0x2000000L, active1, 0L); | ||
346 | case 103: | ||
347 | return jjMoveStringLiteralDfa3_0(active0, 0x200400000L, active1, 0L); | ||
348 | case 105: | ||
349 | return jjMoveStringLiteralDfa3_0(active0, 0x201410000000L, active1, 0L); | ||
350 | case 108: | ||
351 | return jjMoveStringLiteralDfa3_0(active0, 0x200000L, active1, 0L); | ||
352 | case 110: | ||
353 | return jjMoveStringLiteralDfa3_0(active0, 0x42000100000L, active1, 0L); | ||
354 | case 111: | ||
355 | return jjMoveStringLiteralDfa3_0(active0, 0xc000000000L, active1, 0L); | ||
356 | case 112: | ||
357 | return jjMoveStringLiteralDfa3_0(active0, 0x1000000L, active1, 0L); | ||
358 | case 114: | ||
359 | if ((active0 & 0x1000000000000L) != 0L) | ||
360 | return jjStartNfaWithStates_0(2, 48, 42); | ||
361 | return jjMoveStringLiteralDfa3_0(active0, 0x80000000L, active1, 0L); | ||
362 | case 115: | ||
363 | return jjMoveStringLiteralDfa3_0(active0, 0x30000800000L, active1, 0L); | ||
364 | case 116: | ||
365 | if ((active0 & 0x2000000000000L) != 0L) | ||
366 | return jjStartNfaWithStates_0(2, 49, 42); | ||
367 | return jjMoveStringLiteralDfa3_0(active0, 0x900060000000L, active1, 0L); | ||
368 | case 117: | ||
369 | return jjMoveStringLiteralDfa3_0(active0, 0x80004000000L, active1, 0L); | ||
370 | case 122: | ||
371 | return jjMoveStringLiteralDfa3_0(active0, 0x8000000L, active1, 0L); | ||
372 | default : | ||
373 | break; | ||
374 | } | ||
375 | return jjStartNfa_0(1, active0, active1); | ||
376 | } | ||
377 | private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1) | ||
378 | { | ||
379 | if (((active0 &= old0) | (active1 &= old1)) == 0L) | ||
380 | return jjStartNfa_0(1, old0, old1); | ||
381 | try { curChar = input_stream.readChar(); } | ||
382 | catch(java.io.IOException e) { | ||
383 | jjStopStringLiteralDfa_0(2, active0, 0L); | ||
384 | return 3; | ||
385 | } | ||
386 | switch(curChar) | ||
387 | { | ||
388 | case 97: | ||
389 | return jjMoveStringLiteralDfa4_0(active0, 0x4802200000L); | ||
390 | case 98: | ||
391 | return jjMoveStringLiteralDfa4_0(active0, 0x4000000L); | ||
392 | case 100: | ||
393 | if ((active0 & 0x200000000000L) != 0L) | ||
394 | return jjStartNfaWithStates_0(3, 45, 42); | ||
395 | break; | ||
396 | case 101: | ||
397 | if ((active0 & 0x10000000000L) != 0L) | ||
398 | return jjStartNfaWithStates_0(3, 40, 42); | ||
399 | else if ((active0 & 0x20000000000L) != 0L) | ||
400 | return jjStartNfaWithStates_0(3, 41, 42); | ||
401 | return jjMoveStringLiteralDfa4_0(active0, 0x49000000L); | ||
402 | case 103: | ||
403 | if ((active0 & 0x40000000000L) != 0L) | ||
404 | return jjStartNfaWithStates_0(3, 42, 42); | ||
405 | break; | ||
406 | case 105: | ||
407 | return jjMoveStringLiteralDfa4_0(active0, 0xc00000L); | ||
408 | case 108: | ||
409 | return jjMoveStringLiteralDfa4_0(active0, 0x400000000L); | ||
410 | case 109: | ||
411 | if ((active0 & 0x80000000000L) != 0L) | ||
412 | return jjStartNfaWithStates_0(3, 43, 42); | ||
413 | break; | ||
414 | case 110: | ||
415 | return jjMoveStringLiteralDfa4_0(active0, 0x200000000L); | ||
416 | case 111: | ||
417 | if ((active0 & 0x100000000000L) != 0L) | ||
418 | return jjStartNfaWithStates_0(3, 44, 42); | ||
419 | else if ((active0 & 0x800000000000L) != 0L) | ||
420 | return jjStartNfaWithStates_0(3, 47, 42); | ||
421 | return jjMoveStringLiteralDfa4_0(active0, 0x1000000000L); | ||
422 | case 114: | ||
423 | if ((active0 & 0x400000000000L) != 0L) | ||
424 | return jjStartNfaWithStates_0(3, 46, 42); | ||
425 | return jjMoveStringLiteralDfa4_0(active0, 0x8000000000L); | ||
426 | case 115: | ||
427 | return jjMoveStringLiteralDfa4_0(active0, 0x2000000000L); | ||
428 | case 116: | ||
429 | return jjMoveStringLiteralDfa4_0(active0, 0x110100000L); | ||
430 | case 117: | ||
431 | return jjMoveStringLiteralDfa4_0(active0, 0xa0000000L); | ||
432 | default : | ||
433 | break; | ||
434 | } | ||
435 | return jjStartNfa_0(2, active0, 0L); | ||
436 | } | ||
437 | private int jjMoveStringLiteralDfa4_0(long old0, long active0) | ||
438 | { | ||
439 | if (((active0 &= old0)) == 0L) | ||
440 | return jjStartNfa_0(2, old0, 0L); | ||
441 | try { curChar = input_stream.readChar(); } | ||
442 | catch(java.io.IOException e) { | ||
443 | jjStopStringLiteralDfa_0(3, active0, 0L); | ||
444 | return 4; | ||
445 | } | ||
446 | switch(curChar) | ||
447 | { | ||
448 | case 99: | ||
449 | return jjMoveStringLiteralDfa5_0(active0, 0x90000000L); | ||
450 | case 100: | ||
451 | return jjMoveStringLiteralDfa5_0(active0, 0x1000000L); | ||
452 | case 101: | ||
453 | if ((active0 & 0x400000000L) != 0L) | ||
454 | return jjStartNfaWithStates_0(4, 34, 42); | ||
455 | return jjMoveStringLiteralDfa5_0(active0, 0x200000000L); | ||
456 | case 103: | ||
457 | return jjMoveStringLiteralDfa5_0(active0, 0x800000L); | ||
458 | case 105: | ||
459 | return jjMoveStringLiteralDfa5_0(active0, 0x100100000L); | ||
460 | case 107: | ||
461 | if ((active0 & 0x800000000L) != 0L) | ||
462 | return jjStartNfaWithStates_0(4, 35, 42); | ||
463 | break; | ||
464 | case 108: | ||
465 | return jjMoveStringLiteralDfa5_0(active0, 0x4000000L); | ||
466 | case 110: | ||
467 | if ((active0 & 0x1000000000L) != 0L) | ||
468 | return jjStartNfaWithStates_0(4, 36, 42); | ||
469 | break; | ||
470 | case 111: | ||
471 | return jjMoveStringLiteralDfa5_0(active0, 0x8000000L); | ||
472 | case 114: | ||
473 | return jjMoveStringLiteralDfa5_0(active0, 0x60000000L); | ||
474 | case 115: | ||
475 | return jjMoveStringLiteralDfa5_0(active0, 0x400000L); | ||
476 | case 116: | ||
477 | if ((active0 & 0x2000000000L) != 0L) | ||
478 | return jjStartNfaWithStates_0(4, 37, 42); | ||
479 | else if ((active0 & 0x4000000000L) != 0L) | ||
480 | return jjStartNfaWithStates_0(4, 38, 42); | ||
481 | else if ((active0 & 0x8000000000L) != 0L) | ||
482 | return jjStartNfaWithStates_0(4, 39, 42); | ||
483 | return jjMoveStringLiteralDfa5_0(active0, 0x200000L); | ||
484 | case 117: | ||
485 | return jjMoveStringLiteralDfa5_0(active0, 0x2000000L); | ||
486 | default : | ||
487 | break; | ||
488 | } | ||
489 | return jjStartNfa_0(3, active0, 0L); | ||
490 | } | ||
491 | private int jjMoveStringLiteralDfa5_0(long old0, long active0) | ||
492 | { | ||
493 | if (((active0 &= old0)) == 0L) | ||
494 | return jjStartNfa_0(3, old0, 0L); | ||
495 | try { curChar = input_stream.readChar(); } | ||
496 | catch(java.io.IOException e) { | ||
497 | jjStopStringLiteralDfa_0(4, active0, 0L); | ||
498 | return 5; | ||
499 | } | ||
500 | switch(curChar) | ||
501 | { | ||
502 | case 99: | ||
503 | if ((active0 & 0x100000000L) != 0L) | ||
504 | return jjStartNfaWithStates_0(5, 32, 42); | ||
505 | break; | ||
506 | case 100: | ||
507 | if ((active0 & 0x200000000L) != 0L) | ||
508 | return jjStartNfaWithStates_0(5, 33, 42); | ||
509 | break; | ||
510 | case 101: | ||
511 | if ((active0 & 0x4000000L) != 0L) | ||
512 | return jjStartNfaWithStates_0(5, 26, 42); | ||
513 | return jjMoveStringLiteralDfa6_0(active0, 0x1000000L); | ||
514 | case 102: | ||
515 | if ((active0 & 0x8000000L) != 0L) | ||
516 | return jjStartNfaWithStates_0(5, 27, 42); | ||
517 | break; | ||
518 | case 104: | ||
519 | if ((active0 & 0x10000000L) != 0L) | ||
520 | return jjStartNfaWithStates_0(5, 28, 42); | ||
521 | break; | ||
522 | case 105: | ||
523 | return jjMoveStringLiteralDfa6_0(active0, 0x200000L); | ||
524 | case 108: | ||
525 | return jjMoveStringLiteralDfa6_0(active0, 0x2000000L); | ||
526 | case 110: | ||
527 | if ((active0 & 0x20000000L) != 0L) | ||
528 | return jjStartNfaWithStates_0(5, 29, 42); | ||
529 | else if ((active0 & 0x40000000L) != 0L) | ||
530 | return jjStartNfaWithStates_0(5, 30, 42); | ||
531 | return jjMoveStringLiteralDfa6_0(active0, 0x900000L); | ||
532 | case 116: | ||
533 | if ((active0 & 0x80000000L) != 0L) | ||
534 | return jjStartNfaWithStates_0(5, 31, 42); | ||
535 | return jjMoveStringLiteralDfa6_0(active0, 0x400000L); | ||
536 | default : | ||
537 | break; | ||
538 | } | ||
539 | return jjStartNfa_0(4, active0, 0L); | ||
540 | } | ||
541 | private int jjMoveStringLiteralDfa6_0(long old0, long active0) | ||
542 | { | ||
543 | if (((active0 &= old0)) == 0L) | ||
544 | return jjStartNfa_0(4, old0, 0L); | ||
545 | try { curChar = input_stream.readChar(); } | ||
546 | catch(java.io.IOException e) { | ||
547 | jjStopStringLiteralDfa_0(5, active0, 0L); | ||
548 | return 6; | ||
549 | } | ||
550 | switch(curChar) | ||
551 | { | ||
552 | case 101: | ||
553 | return jjMoveStringLiteralDfa7_0(active0, 0xc00000L); | ||
554 | case 102: | ||
555 | if ((active0 & 0x1000000L) != 0L) | ||
556 | return jjStartNfaWithStates_0(6, 24, 42); | ||
557 | break; | ||
558 | case 108: | ||
559 | return jjMoveStringLiteralDfa7_0(active0, 0x200000L); | ||
560 | case 116: | ||
561 | if ((active0 & 0x2000000L) != 0L) | ||
562 | return jjStartNfaWithStates_0(6, 25, 42); | ||
563 | break; | ||
564 | case 117: | ||
565 | return jjMoveStringLiteralDfa7_0(active0, 0x100000L); | ||
566 | default : | ||
567 | break; | ||
568 | } | ||
569 | return jjStartNfa_0(5, active0, 0L); | ||
570 | } | ||
571 | private int jjMoveStringLiteralDfa7_0(long old0, long active0) | ||
572 | { | ||
573 | if (((active0 &= old0)) == 0L) | ||
574 | return jjStartNfa_0(5, old0, 0L); | ||
575 | try { curChar = input_stream.readChar(); } | ||
576 | catch(java.io.IOException e) { | ||
577 | jjStopStringLiteralDfa_0(6, active0, 0L); | ||
578 | return 7; | ||
579 | } | ||
580 | switch(curChar) | ||
581 | { | ||
582 | case 100: | ||
583 | if ((active0 & 0x800000L) != 0L) | ||
584 | return jjStartNfaWithStates_0(7, 23, 42); | ||
585 | break; | ||
586 | case 101: | ||
587 | if ((active0 & 0x100000L) != 0L) | ||
588 | return jjStartNfaWithStates_0(7, 20, 42); | ||
589 | else if ((active0 & 0x200000L) != 0L) | ||
590 | return jjStartNfaWithStates_0(7, 21, 42); | ||
591 | break; | ||
592 | case 114: | ||
593 | if ((active0 & 0x400000L) != 0L) | ||
594 | return jjStartNfaWithStates_0(7, 22, 42); | ||
595 | break; | ||
596 | default : | ||
597 | break; | ||
598 | } | ||
599 | return jjStartNfa_0(6, active0, 0L); | ||
600 | } | ||
601 | private int jjStartNfaWithStates_0(int pos, int kind, int state) | ||
602 | { | ||
603 | jjmatchedKind = kind; | ||
604 | jjmatchedPos = pos; | ||
605 | try { curChar = input_stream.readChar(); } | ||
606 | catch(java.io.IOException e) { return pos + 1; } | ||
607 | return jjMoveNfa_0(state, pos + 1); | ||
608 | } | ||
609 | static final long[] jjbitVec0 = { | ||
610 | 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL | ||
611 | }; | ||
612 | private int jjMoveNfa_0(int startState, int curPos) | ||
613 | { | ||
614 | int startsAt = 0; | ||
615 | jjnewStateCnt = 76; | ||
616 | int i = 1; | ||
617 | jjstateSet[0] = startState; | ||
618 | int kind = 0x7fffffff; | ||
619 | for (;;) | ||
620 | { | ||
621 | if (++jjround == 0x7fffffff) | ||
622 | ReInitRounds(); | ||
623 | if (curChar < 64) | ||
624 | { | ||
625 | long l = 1L << curChar; | ||
626 | do | ||
627 | { | ||
628 | switch(jjstateSet[--i]) | ||
629 | { | ||
630 | case 65: | ||
631 | if (curChar == 42) | ||
632 | jjCheckNAddTwoStates(71, 72); | ||
633 | else if (curChar == 47) | ||
634 | jjCheckNAddStates(0, 2); | ||
635 | break; | ||
636 | case 0: | ||
637 | if ((0x3ff000000000000L & l) != 0L) | ||
638 | jjCheckNAddStates(3, 9); | ||
639 | else if (curChar == 47) | ||
640 | jjAddStates(10, 11); | ||
641 | else if (curChar == 36) | ||
642 | { | ||
643 | if (kind > 52) | ||
644 | kind = 52; | ||
645 | jjCheckNAdd(42); | ||
646 | } | ||
647 | else if (curChar == 34) | ||
648 | jjCheckNAddStates(12, 14); | ||
649 | else if (curChar == 39) | ||
650 | jjAddStates(15, 16); | ||
651 | else if (curChar == 46) | ||
652 | jjCheckNAdd(5); | ||
653 | if ((0x3fe000000000000L & l) != 0L) | ||
654 | { | ||
655 | if (kind > 12) | ||
656 | kind = 12; | ||
657 | jjCheckNAddTwoStates(1, 2); | ||
658 | } | ||
659 | else if (curChar == 48) | ||
660 | { | ||
661 | if (kind > 12) | ||
662 | kind = 12; | ||
663 | jjCheckNAddStates(17, 19); | ||
664 | } | ||
665 | break; | ||
666 | case 1: | ||
667 | if ((0x3ff000000000000L & l) == 0L) | ||
668 | break; | ||
669 | if (kind > 12) | ||
670 | kind = 12; | ||
671 | jjCheckNAddTwoStates(1, 2); | ||
672 | break; | ||
673 | case 4: | ||
674 | if (curChar == 46) | ||
675 | jjCheckNAdd(5); | ||
676 | break; | ||
677 | case 5: | ||
678 | if ((0x3ff000000000000L & l) == 0L) | ||
679 | break; | ||
680 | if (kind > 16) | ||
681 | kind = 16; | ||
682 | jjCheckNAddStates(20, 22); | ||
683 | break; | ||
684 | case 7: | ||
685 | if ((0x280000000000L & l) != 0L) | ||
686 | jjCheckNAdd(8); | ||
687 | break; | ||
688 | case 8: | ||
689 | if ((0x3ff000000000000L & l) == 0L) | ||
690 | break; | ||
691 | if (kind > 16) | ||
692 | kind = 16; | ||
693 | jjCheckNAddTwoStates(8, 9); | ||
694 | break; | ||
695 | case 10: | ||
696 | if (curChar == 39) | ||
697 | jjAddStates(15, 16); | ||
698 | break; | ||
699 | case 11: | ||
700 | if ((0xffffff7fffffdbffL & l) != 0L) | ||
701 | jjCheckNAdd(12); | ||
702 | break; | ||
703 | case 12: | ||
704 | if (curChar == 39 && kind > 18) | ||
705 | kind = 18; | ||
706 | break; | ||
707 | case 14: | ||
708 | if ((0x8400000000L & l) != 0L) | ||
709 | jjCheckNAdd(12); | ||
710 | break; | ||
711 | case 15: | ||
712 | if ((0xff000000000000L & l) != 0L) | ||
713 | jjCheckNAddTwoStates(16, 12); | ||
714 | break; | ||
715 | case 16: | ||
716 | if ((0xff000000000000L & l) != 0L) | ||
717 | jjCheckNAdd(12); | ||
718 | break; | ||
719 | case 17: | ||
720 | if ((0xf000000000000L & l) != 0L) | ||
721 | jjstateSet[jjnewStateCnt++] = 18; | ||
722 | break; | ||
723 | case 18: | ||
724 | if ((0xff000000000000L & l) != 0L) | ||
725 | jjCheckNAdd(16); | ||
726 | break; | ||
727 | case 19: | ||
728 | if (curChar == 34) | ||
729 | jjCheckNAddStates(12, 14); | ||
730 | break; | ||
731 | case 20: | ||
732 | if ((0xfffffffbffffdbffL & l) != 0L) | ||
733 | jjCheckNAddStates(12, 14); | ||
734 | break; | ||
735 | case 22: | ||
736 | if ((0x8400002400L & l) != 0L) | ||
737 | jjCheckNAddStates(12, 14); | ||
738 | break; | ||
739 | case 23: | ||
740 | if (curChar != 34) | ||
741 | break; | ||
742 | if (kind > 19) | ||
743 | kind = 19; | ||
744 | jjCheckNAddTwoStates(24, 25); | ||
745 | break; | ||
746 | case 24: | ||
747 | if ((0x100002400L & l) != 0L) | ||
748 | jjCheckNAddTwoStates(24, 25); | ||
749 | break; | ||
750 | case 25: | ||
751 | if (curChar == 34) | ||
752 | jjCheckNAddStates(23, 25); | ||
753 | break; | ||
754 | case 26: | ||
755 | if ((0xfffffffbffffdbffL & l) != 0L) | ||
756 | jjCheckNAddStates(23, 25); | ||
757 | break; | ||
758 | case 28: | ||
759 | if ((0x8400002400L & l) != 0L) | ||
760 | jjCheckNAddStates(23, 25); | ||
761 | break; | ||
762 | case 29: | ||
763 | if ((0xff000000000000L & l) != 0L) | ||
764 | jjCheckNAddStates(26, 29); | ||
765 | break; | ||
766 | case 30: | ||
767 | if ((0xff000000000000L & l) != 0L) | ||
768 | jjCheckNAddStates(23, 25); | ||
769 | break; | ||
770 | case 31: | ||
771 | if ((0xf000000000000L & l) != 0L) | ||
772 | jjstateSet[jjnewStateCnt++] = 32; | ||
773 | break; | ||
774 | case 32: | ||
775 | if ((0xff000000000000L & l) != 0L) | ||
776 | jjCheckNAdd(30); | ||
777 | break; | ||
778 | case 33: | ||
779 | if (curChar == 10) | ||
780 | jjCheckNAddStates(23, 25); | ||
781 | break; | ||
782 | case 34: | ||
783 | if (curChar == 13) | ||
784 | jjstateSet[jjnewStateCnt++] = 33; | ||
785 | break; | ||
786 | case 35: | ||
787 | if ((0xff000000000000L & l) != 0L) | ||
788 | jjCheckNAddStates(30, 33); | ||
789 | break; | ||
790 | case 36: | ||
791 | if ((0xff000000000000L & l) != 0L) | ||
792 | jjCheckNAddStates(12, 14); | ||
793 | break; | ||
794 | case 37: | ||
795 | if ((0xf000000000000L & l) != 0L) | ||
796 | jjstateSet[jjnewStateCnt++] = 38; | ||
797 | break; | ||
798 | case 38: | ||
799 | if ((0xff000000000000L & l) != 0L) | ||
800 | jjCheckNAdd(36); | ||
801 | break; | ||
802 | case 39: | ||
803 | if (curChar == 10) | ||
804 | jjCheckNAddStates(12, 14); | ||
805 | break; | ||
806 | case 40: | ||
807 | if (curChar == 13) | ||
808 | jjstateSet[jjnewStateCnt++] = 39; | ||
809 | break; | ||
810 | case 41: | ||
811 | if (curChar != 36) | ||
812 | break; | ||
813 | if (kind > 52) | ||
814 | kind = 52; | ||
815 | jjCheckNAdd(42); | ||
816 | break; | ||
817 | case 42: | ||
818 | if ((0x3ff001000000000L & l) == 0L) | ||
819 | break; | ||
820 | if (kind > 52) | ||
821 | kind = 52; | ||
822 | jjCheckNAdd(42); | ||
823 | break; | ||
824 | case 43: | ||
825 | if ((0x3ff000000000000L & l) != 0L) | ||
826 | jjCheckNAddStates(3, 9); | ||
827 | break; | ||
828 | case 44: | ||
829 | if ((0x3ff000000000000L & l) != 0L) | ||
830 | jjCheckNAddTwoStates(44, 45); | ||
831 | break; | ||
832 | case 45: | ||
833 | if (curChar != 46) | ||
834 | break; | ||
835 | if (kind > 16) | ||
836 | kind = 16; | ||
837 | jjCheckNAddStates(34, 36); | ||
838 | break; | ||
839 | case 46: | ||
840 | if ((0x3ff000000000000L & l) == 0L) | ||
841 | break; | ||
842 | if (kind > 16) | ||
843 | kind = 16; | ||
844 | jjCheckNAddStates(34, 36); | ||
845 | break; | ||
846 | case 48: | ||
847 | if ((0x280000000000L & l) != 0L) | ||
848 | jjCheckNAdd(49); | ||
849 | break; | ||
850 | case 49: | ||
851 | if ((0x3ff000000000000L & l) == 0L) | ||
852 | break; | ||
853 | if (kind > 16) | ||
854 | kind = 16; | ||
855 | jjCheckNAddTwoStates(49, 9); | ||
856 | break; | ||
857 | case 50: | ||
858 | if ((0x3ff000000000000L & l) != 0L) | ||
859 | jjCheckNAddTwoStates(50, 51); | ||
860 | break; | ||
861 | case 52: | ||
862 | if ((0x280000000000L & l) != 0L) | ||
863 | jjCheckNAdd(53); | ||
864 | break; | ||
865 | case 53: | ||
866 | if ((0x3ff000000000000L & l) == 0L) | ||
867 | break; | ||
868 | if (kind > 16) | ||
869 | kind = 16; | ||
870 | jjCheckNAddTwoStates(53, 9); | ||
871 | break; | ||
872 | case 54: | ||
873 | if ((0x3ff000000000000L & l) != 0L) | ||
874 | jjCheckNAddStates(37, 39); | ||
875 | break; | ||
876 | case 56: | ||
877 | if ((0x280000000000L & l) != 0L) | ||
878 | jjCheckNAdd(57); | ||
879 | break; | ||
880 | case 57: | ||
881 | if ((0x3ff000000000000L & l) != 0L) | ||
882 | jjCheckNAddTwoStates(57, 9); | ||
883 | break; | ||
884 | case 58: | ||
885 | if (curChar != 48) | ||
886 | break; | ||
887 | if (kind > 12) | ||
888 | kind = 12; | ||
889 | jjCheckNAddStates(17, 19); | ||
890 | break; | ||
891 | case 60: | ||
892 | if ((0x3ff000000000000L & l) == 0L) | ||
893 | break; | ||
894 | if (kind > 12) | ||
895 | kind = 12; | ||
896 | jjAddStates(40, 41); | ||
897 | break; | ||
898 | case 62: | ||
899 | if ((0xff000000000000L & l) == 0L) | ||
900 | break; | ||
901 | if (kind > 12) | ||
902 | kind = 12; | ||
903 | jjCheckNAddTwoStates(62, 63); | ||
904 | break; | ||
905 | case 64: | ||
906 | if (curChar == 47) | ||
907 | jjAddStates(10, 11); | ||
908 | break; | ||
909 | case 66: | ||
910 | if ((0xffffffffffffdbffL & l) != 0L) | ||
911 | jjCheckNAddStates(0, 2); | ||
912 | break; | ||
913 | case 67: | ||
914 | if ((0x2400L & l) != 0L && kind > 5) | ||
915 | kind = 5; | ||
916 | break; | ||
917 | case 68: | ||
918 | if (curChar == 10 && kind > 5) | ||
919 | kind = 5; | ||
920 | break; | ||
921 | case 69: | ||
922 | if (curChar == 13) | ||
923 | jjstateSet[jjnewStateCnt++] = 68; | ||
924 | break; | ||
925 | case 70: | ||
926 | if (curChar == 42) | ||
927 | jjCheckNAddTwoStates(71, 72); | ||
928 | break; | ||
929 | case 71: | ||
930 | if ((0xfffffbffffffffffL & l) != 0L) | ||
931 | jjCheckNAddTwoStates(71, 72); | ||
932 | break; | ||
933 | case 72: | ||
934 | if (curChar == 42) | ||
935 | jjCheckNAddStates(42, 44); | ||
936 | break; | ||
937 | case 73: | ||
938 | if ((0xffff7bffffffffffL & l) != 0L) | ||
939 | jjCheckNAddTwoStates(74, 72); | ||
940 | break; | ||
941 | case 74: | ||
942 | if ((0xfffffbffffffffffL & l) != 0L) | ||
943 | jjCheckNAddTwoStates(74, 72); | ||
944 | break; | ||
945 | case 75: | ||
946 | if (curChar == 47 && kind > 6) | ||
947 | kind = 6; | ||
948 | break; | ||
949 | default : break; | ||
950 | } | ||
951 | } while(i != startsAt); | ||
952 | } | ||
953 | else if (curChar < 128) | ||
954 | { | ||
955 | long l = 1L << (curChar & 077); | ||
956 | do | ||
957 | { | ||
958 | switch(jjstateSet[--i]) | ||
959 | { | ||
960 | case 0: | ||
961 | case 42: | ||
962 | if ((0x7fffffe87fffffeL & l) == 0L) | ||
963 | break; | ||
964 | if (kind > 52) | ||
965 | kind = 52; | ||
966 | jjCheckNAdd(42); | ||
967 | break; | ||
968 | case 2: | ||
969 | case 61: | ||
970 | case 63: | ||
971 | if ((0x100000001000L & l) == 0L) | ||
972 | break; | ||
973 | if (kind > 12) | ||
974 | kind = 12; | ||
975 | jjCheckNAdd(3); | ||
976 | break; | ||
977 | case 3: | ||
978 | if ((0x100000001000L & l) != 0L && kind > 12) | ||
979 | kind = 12; | ||
980 | break; | ||
981 | case 6: | ||
982 | if ((0x2000000020L & l) != 0L) | ||
983 | jjAddStates(45, 46); | ||
984 | break; | ||
985 | case 9: | ||
986 | if ((0x5000000050L & l) != 0L && kind > 16) | ||
987 | kind = 16; | ||
988 | break; | ||
989 | case 11: | ||
990 | if ((0xffffffffefffffffL & l) != 0L) | ||
991 | jjCheckNAdd(12); | ||
992 | break; | ||
993 | case 13: | ||
994 | if (curChar == 92) | ||
995 | jjAddStates(47, 49); | ||
996 | break; | ||
997 | case 14: | ||
998 | if ((0x14404410000000L & l) != 0L) | ||
999 | jjCheckNAdd(12); | ||
1000 | break; | ||
1001 | case 20: | ||
1002 | if ((0xffffffffefffffffL & l) != 0L) | ||
1003 | jjCheckNAddStates(12, 14); | ||
1004 | break; | ||
1005 | case 21: | ||
1006 | if (curChar == 92) | ||
1007 | jjAddStates(50, 53); | ||
1008 | break; | ||
1009 | case 22: | ||
1010 | if ((0x14404410000000L & l) != 0L) | ||
1011 | jjCheckNAddStates(12, 14); | ||
1012 | break; | ||
1013 | case 26: | ||
1014 | if ((0xffffffffefffffffL & l) != 0L) | ||
1015 | jjCheckNAddStates(23, 25); | ||
1016 | break; | ||
1017 | case 27: | ||
1018 | if (curChar == 92) | ||
1019 | jjAddStates(54, 57); | ||
1020 | break; | ||
1021 | case 28: | ||
1022 | if ((0x14404410000000L & l) != 0L) | ||
1023 | jjCheckNAddStates(23, 25); | ||
1024 | break; | ||
1025 | case 47: | ||
1026 | if ((0x2000000020L & l) != 0L) | ||
1027 | jjAddStates(58, 59); | ||
1028 | break; | ||
1029 | case 51: | ||
1030 | if ((0x2000000020L & l) != 0L) | ||
1031 | jjAddStates(60, 61); | ||
1032 | break; | ||
1033 | case 55: | ||
1034 | if ((0x2000000020L & l) != 0L) | ||
1035 | jjAddStates(62, 63); | ||
1036 | break; | ||
1037 | case 59: | ||
1038 | if ((0x100000001000000L & l) != 0L) | ||
1039 | jjCheckNAdd(60); | ||
1040 | break; | ||
1041 | case 60: | ||
1042 | if ((0x7e0000007eL & l) == 0L) | ||
1043 | break; | ||
1044 | if (kind > 12) | ||
1045 | kind = 12; | ||
1046 | jjCheckNAddTwoStates(60, 61); | ||
1047 | break; | ||
1048 | case 66: | ||
1049 | jjAddStates(0, 2); | ||
1050 | break; | ||
1051 | case 71: | ||
1052 | jjCheckNAddTwoStates(71, 72); | ||
1053 | break; | ||
1054 | case 73: | ||
1055 | case 74: | ||
1056 | jjCheckNAddTwoStates(74, 72); | ||
1057 | break; | ||
1058 | default : break; | ||
1059 | } | ||
1060 | } while(i != startsAt); | ||
1061 | } | ||
1062 | else | ||
1063 | { | ||
1064 | int i2 = (curChar & 0xff) >> 6; | ||
1065 | long l2 = 1L << (curChar & 077); | ||
1066 | do | ||
1067 | { | ||
1068 | switch(jjstateSet[--i]) | ||
1069 | { | ||
1070 | case 11: | ||
1071 | if ((jjbitVec0[i2] & l2) != 0L) | ||
1072 | jjstateSet[jjnewStateCnt++] = 12; | ||
1073 | break; | ||
1074 | case 20: | ||
1075 | if ((jjbitVec0[i2] & l2) != 0L) | ||
1076 | jjCheckNAddStates(12, 14); | ||
1077 | break; | ||
1078 | case 26: | ||
1079 | if ((jjbitVec0[i2] & l2) != 0L) | ||
1080 | jjCheckNAddStates(23, 25); | ||
1081 | break; | ||
1082 | case 66: | ||
1083 | if ((jjbitVec0[i2] & l2) != 0L) | ||
1084 | jjAddStates(0, 2); | ||
1085 | break; | ||
1086 | case 71: | ||
1087 | if ((jjbitVec0[i2] & l2) != 0L) | ||
1088 | jjCheckNAddTwoStates(71, 72); | ||
1089 | break; | ||
1090 | case 73: | ||
1091 | case 74: | ||
1092 | if ((jjbitVec0[i2] & l2) != 0L) | ||
1093 | jjCheckNAddTwoStates(74, 72); | ||
1094 | break; | ||
1095 | default : break; | ||
1096 | } | ||
1097 | } while(i != startsAt); | ||
1098 | } | ||
1099 | if (kind != 0x7fffffff) | ||
1100 | { | ||
1101 | jjmatchedKind = kind; | ||
1102 | jjmatchedPos = curPos; | ||
1103 | kind = 0x7fffffff; | ||
1104 | } | ||
1105 | ++curPos; | ||
1106 | if ((i = jjnewStateCnt) == (startsAt = 76 - (jjnewStateCnt = startsAt))) | ||
1107 | return curPos; | ||
1108 | try { curChar = input_stream.readChar(); } | ||
1109 | catch(java.io.IOException e) { return curPos; } | ||
1110 | } | ||
1111 | } | ||
1112 | private int jjMoveStringLiteralDfa0_1() | ||
1113 | { | ||
1114 | switch(curChar) | ||
1115 | { | ||
1116 | case 10: | ||
1117 | return jjStopAtPos(0, 8); | ||
1118 | case 92: | ||
1119 | return jjMoveStringLiteralDfa1_1(0x600L); | ||
1120 | default : | ||
1121 | return 1; | ||
1122 | } | ||
1123 | } | ||
1124 | private int jjMoveStringLiteralDfa1_1(long active0) | ||
1125 | { | ||
1126 | try { curChar = input_stream.readChar(); } | ||
1127 | catch(java.io.IOException e) { | ||
1128 | return 1; | ||
1129 | } | ||
1130 | switch(curChar) | ||
1131 | { | ||
1132 | case 10: | ||
1133 | if ((active0 & 0x200L) != 0L) | ||
1134 | return jjStopAtPos(1, 9); | ||
1135 | break; | ||
1136 | case 13: | ||
1137 | return jjMoveStringLiteralDfa2_1(active0, 0x400L); | ||
1138 | default : | ||
1139 | return 2; | ||
1140 | } | ||
1141 | return 2; | ||
1142 | } | ||
1143 | private int jjMoveStringLiteralDfa2_1(long old0, long active0) | ||
1144 | { | ||
1145 | if (((active0 &= old0)) == 0L) | ||
1146 | return 2; | ||
1147 | try { curChar = input_stream.readChar(); } | ||
1148 | catch(java.io.IOException e) { | ||
1149 | return 2; | ||
1150 | } | ||
1151 | switch(curChar) | ||
1152 | { | ||
1153 | case 10: | ||
1154 | if ((active0 & 0x400L) != 0L) | ||
1155 | return jjStopAtPos(2, 10); | ||
1156 | break; | ||
1157 | default : | ||
1158 | return 3; | ||
1159 | } | ||
1160 | return 3; | ||
1161 | } | ||
1162 | static final int[] jjnextStates = { | ||
1163 | 66, 67, 69, 44, 45, 50, 51, 54, 55, 9, 65, 70, 20, 21, 23, 11, | ||
1164 | 13, 59, 62, 63, 5, 6, 9, 26, 27, 23, 26, 27, 30, 23, 20, 21, | ||
1165 | 36, 23, 46, 47, 9, 54, 55, 9, 60, 61, 72, 73, 75, 7, 8, 14, | ||
1166 | 15, 17, 22, 35, 37, 40, 28, 29, 31, 34, 48, 49, 52, 53, 56, 57, | ||
1167 | }; | ||
1168 | |||
1169 | /** Token literal values. */ | ||
1170 | public static final String[] jjstrLiteralImages = { | ||
1171 | "", null, null, null, null, null, null, null, null, null, null, null, null, | ||
1172 | null, null, null, null, null, null, null, "\143\157\156\164\151\156\165\145", | ||
1173 | "\166\157\154\141\164\151\154\145", "\162\145\147\151\163\164\145\162", "\165\156\163\151\147\156\145\144", | ||
1174 | "\164\171\160\145\144\145\146", "\144\145\146\141\165\154\164", "\144\157\165\142\154\145", | ||
1175 | "\163\151\172\145\157\146", "\163\167\151\164\143\150", "\162\145\164\165\162\156", | ||
1176 | "\145\170\164\145\162\156", "\163\164\162\165\143\164", "\163\164\141\164\151\143", | ||
1177 | "\163\151\147\156\145\144", "\167\150\151\154\145", "\142\162\145\141\153", "\165\156\151\157\156", | ||
1178 | "\143\157\156\163\164", "\146\154\157\141\164", "\163\150\157\162\164", "\145\154\163\145", | ||
1179 | "\143\141\163\145", "\154\157\156\147", "\145\156\165\155", "\141\165\164\157", | ||
1180 | "\166\157\151\144", "\143\150\141\162", "\147\157\164\157", "\146\157\162", "\151\156\164", | ||
1181 | "\151\146", "\144\157", null, null, null, "\50", "\51", "\73", "\52", "\54", "\56\56\56", | ||
1182 | "\173", "\175", "\75", "\72", "\133", "\135", "\52\75", "\57\75", "\45\75", "\53\75", | ||
1183 | "\55\75", "\74\74\75", "\76\76\75", "\46\75", "\136\75", "\174\75", "\77", "\174\174", | ||
1184 | "\46\46", "\174", "\136", "\46", "\75\75", "\41\75", "\74", "\76", "\74\75", "\76\75", | ||
1185 | "\74\74", "\76\76", "\53", "\55", "\57", "\45", "\53\53", "\55\55", "\176", "\41", | ||
1186 | "\56", "\55\76", }; | ||
1187 | |||
1188 | /** Lexer state names. */ | ||
1189 | public static final String[] lexStateNames = { | ||
1190 | "DEFAULT", | ||
1191 | "PREPROCESSOR_OUTPUT", | ||
1192 | }; | ||
1193 | |||
1194 | /** Lex State array. */ | ||
1195 | public static final int[] jjnewLexState = { | ||
1196 | -1, -1, -1, -1, -1, -1, -1, 1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | ||
1197 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | ||
1198 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | ||
1199 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | ||
1200 | -1, | ||
1201 | }; | ||
1202 | static final long[] jjtoToken = { | ||
1203 | 0xff9ffffffffd1001L, 0x1fffffffffL, | ||
1204 | }; | ||
1205 | static final long[] jjtoSkip = { | ||
1206 | 0x1feL, 0x0L, | ||
1207 | }; | ||
1208 | static final long[] jjtoMore = { | ||
1209 | 0xe00L, 0x0L, | ||
1210 | }; | ||
1211 | protected SimpleCharStream input_stream; | ||
1212 | private final int[] jjrounds = new int[76]; | ||
1213 | private final int[] jjstateSet = new int[152]; | ||
1214 | protected char curChar; | ||
1215 | /** Constructor. */ | ||
1216 | public CParserTokenManager(SimpleCharStream stream){ | ||
1217 | if (SimpleCharStream.staticFlag) | ||
1218 | throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); | ||
1219 | input_stream = stream; | ||
1220 | } | ||
1221 | |||
1222 | /** Constructor. */ | ||
1223 | public CParserTokenManager(SimpleCharStream stream, int lexState){ | ||
1224 | this(stream); | ||
1225 | SwitchTo(lexState); | ||
1226 | } | ||
1227 | |||
1228 | /** Reinitialise parser. */ | ||
1229 | public void ReInit(SimpleCharStream stream) | ||
1230 | { | ||
1231 | jjmatchedPos = jjnewStateCnt = 0; | ||
1232 | curLexState = defaultLexState; | ||
1233 | input_stream = stream; | ||
1234 | ReInitRounds(); | ||
1235 | } | ||
1236 | private void ReInitRounds() | ||
1237 | { | ||
1238 | int i; | ||
1239 | jjround = 0x80000001; | ||
1240 | for (i = 76; i-- > 0;) | ||
1241 | jjrounds[i] = 0x80000000; | ||
1242 | } | ||
1243 | |||
1244 | /** Reinitialise parser. */ | ||
1245 | public void ReInit(SimpleCharStream stream, int lexState) | ||
1246 | { | ||
1247 | ReInit(stream); | ||
1248 | SwitchTo(lexState); | ||
1249 | } | ||
1250 | |||
1251 | /** Switch to specified lex state. */ | ||
1252 | public void SwitchTo(int lexState) | ||
1253 | { | ||
1254 | if (lexState >= 2 || lexState < 0) | ||
1255 | throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); | ||
1256 | else | ||
1257 | curLexState = lexState; | ||
1258 | } | ||
1259 | |||
1260 | protected Token jjFillToken() | ||
1261 | { | ||
1262 | final Token t; | ||
1263 | final String curTokenImage; | ||
1264 | final int beginLine; | ||
1265 | final int endLine; | ||
1266 | final int beginColumn; | ||
1267 | final int endColumn; | ||
1268 | String im = jjstrLiteralImages[jjmatchedKind]; | ||
1269 | curTokenImage = (im == null) ? input_stream.GetImage() : im; | ||
1270 | beginLine = input_stream.getBeginLine(); | ||
1271 | beginColumn = input_stream.getBeginColumn(); | ||
1272 | endLine = input_stream.getEndLine(); | ||
1273 | endColumn = input_stream.getEndColumn(); | ||
1274 | t = Token.newToken(jjmatchedKind, curTokenImage); | ||
1275 | |||
1276 | t.beginLine = beginLine; | ||
1277 | t.endLine = endLine; | ||
1278 | t.beginColumn = beginColumn; | ||
1279 | t.endColumn = endColumn; | ||
1280 | |||
1281 | return t; | ||
1282 | } | ||
1283 | |||
1284 | int curLexState = 0; | ||
1285 | int defaultLexState = 0; | ||
1286 | int jjnewStateCnt; | ||
1287 | int jjround; | ||
1288 | int jjmatchedPos; | ||
1289 | int jjmatchedKind; | ||
1290 | |||
1291 | /** Get the next Token. */ | ||
1292 | public Token getNextToken() | ||
1293 | { | ||
1294 | Token matchedToken; | ||
1295 | int curPos = 0; | ||
1296 | |||
1297 | EOFLoop : | ||
1298 | for (;;) | ||
1299 | { | ||
1300 | try | ||
1301 | { | ||
1302 | curChar = input_stream.BeginToken(); | ||
1303 | } | ||
1304 | catch(java.io.IOException e) | ||
1305 | { | ||
1306 | jjmatchedKind = 0; | ||
1307 | matchedToken = jjFillToken(); | ||
1308 | return matchedToken; | ||
1309 | } | ||
1310 | |||
1311 | for (;;) | ||
1312 | { | ||
1313 | switch(curLexState) | ||
1314 | { | ||
1315 | case 0: | ||
1316 | try { input_stream.backup(0); | ||
1317 | while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L) | ||
1318 | curChar = input_stream.BeginToken(); | ||
1319 | } | ||
1320 | catch (java.io.IOException e1) { continue EOFLoop; } | ||
1321 | jjmatchedKind = 0x7fffffff; | ||
1322 | jjmatchedPos = 0; | ||
1323 | curPos = jjMoveStringLiteralDfa0_0(); | ||
1324 | break; | ||
1325 | case 1: | ||
1326 | jjmatchedKind = 0x7fffffff; | ||
1327 | jjmatchedPos = 0; | ||
1328 | curPos = jjMoveStringLiteralDfa0_1(); | ||
1329 | if (jjmatchedPos == 0 && jjmatchedKind > 11) | ||
1330 | { | ||
1331 | jjmatchedKind = 11; | ||
1332 | } | ||
1333 | break; | ||
1334 | } | ||
1335 | if (jjmatchedKind != 0x7fffffff) | ||
1336 | { | ||
1337 | if (jjmatchedPos + 1 < curPos) | ||
1338 | input_stream.backup(curPos - jjmatchedPos - 1); | ||
1339 | if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) | ||
1340 | { | ||
1341 | matchedToken = jjFillToken(); | ||
1342 | if (jjnewLexState[jjmatchedKind] != -1) | ||
1343 | curLexState = jjnewLexState[jjmatchedKind]; | ||
1344 | return matchedToken; | ||
1345 | } | ||
1346 | else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) | ||
1347 | { | ||
1348 | if (jjnewLexState[jjmatchedKind] != -1) | ||
1349 | curLexState = jjnewLexState[jjmatchedKind]; | ||
1350 | continue EOFLoop; | ||
1351 | } | ||
1352 | if (jjnewLexState[jjmatchedKind] != -1) | ||
1353 | curLexState = jjnewLexState[jjmatchedKind]; | ||
1354 | curPos = 0; | ||
1355 | jjmatchedKind = 0x7fffffff; | ||
1356 | try { | ||
1357 | curChar = input_stream.readChar(); | ||
1358 | continue; | ||
1359 | } | ||
1360 | catch (java.io.IOException e1) { } | ||
1361 | } | ||
1362 | int error_line = input_stream.getEndLine(); | ||
1363 | int error_column = input_stream.getEndColumn(); | ||
1364 | String error_after = null; | ||
1365 | boolean EOFSeen = false; | ||
1366 | try { input_stream.readChar(); input_stream.backup(1); } | ||
1367 | catch (java.io.IOException e1) { | ||
1368 | EOFSeen = true; | ||
1369 | error_after = curPos <= 1 ? "" : input_stream.GetImage(); | ||
1370 | if (curChar == '\n' || curChar == '\r') { | ||
1371 | error_line++; | ||
1372 | error_column = 0; | ||
1373 | } | ||
1374 | else | ||
1375 | error_column++; | ||
1376 | } | ||
1377 | if (!EOFSeen) { | ||
1378 | input_stream.backup(1); | ||
1379 | error_after = curPos <= 1 ? "" : input_stream.GetImage(); | ||
1380 | } | ||
1381 | throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); | ||
1382 | } | ||
1383 | } | ||
1384 | } | ||
1385 | |||
1386 | private void jjCheckNAdd(int state) | ||
1387 | { | ||
1388 | if (jjrounds[state] != jjround) | ||
1389 | { | ||
1390 | jjstateSet[jjnewStateCnt++] = state; | ||
1391 | jjrounds[state] = jjround; | ||
1392 | } | ||
1393 | } | ||
1394 | private void jjAddStates(int start, int end) | ||
1395 | { | ||
1396 | do { | ||
1397 | jjstateSet[jjnewStateCnt++] = jjnextStates[start]; | ||
1398 | } while (start++ != end); | ||
1399 | } | ||
1400 | private void jjCheckNAddTwoStates(int state1, int state2) | ||
1401 | { | ||
1402 | jjCheckNAdd(state1); | ||
1403 | jjCheckNAdd(state2); | ||
1404 | } | ||
1405 | |||
1406 | private void jjCheckNAddStates(int start, int end) | ||
1407 | { | ||
1408 | do { | ||
1409 | jjCheckNAdd(jjnextStates[start]); | ||
1410 | } while (start++ != end); | ||
1411 | } | ||
1412 | |||
1413 | } | ||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/ExpressionDatabaseHandler.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/ExpressionDatabaseHandler.java new file mode 100644 index 000000000..36c34d1de --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/ExpressionDatabaseHandler.java | |||
@@ -0,0 +1,75 @@ | |||
1 | package org.gnunet.seaspider.parser; | ||
2 | |||
3 | import java.io.File; | ||
4 | |||
5 | import org.tmatesoft.sqljet.core.SqlJetException; | ||
6 | import org.tmatesoft.sqljet.core.SqlJetTransactionMode; | ||
7 | import org.tmatesoft.sqljet.core.table.ISqlJetTable; | ||
8 | import org.tmatesoft.sqljet.core.table.SqlJetDb; | ||
9 | |||
10 | public class ExpressionDatabaseHandler { | ||
11 | |||
12 | private static SqlJetDb db = null; | ||
13 | |||
14 | public static void createExpressionDatabase(String databasePath) { | ||
15 | String createTableQuery = "CREATE TABLE Expression ( expr_ID INT NOT NULL PRIMARY KEY , " + | ||
16 | "file_name TEXT NOT NULL , expr_syntax TEXT NOT NULL ," + | ||
17 | " start_lineno INT NOT NULL , end_lineno INT NOT NULL , " + | ||
18 | "scope_start_lineno INT NOT NULL , scope_end_lineno INT NOT NULL)"; | ||
19 | |||
20 | File dbFile = new File(databasePath + "/GNUnetExpressions.db"); | ||
21 | dbFile.delete();/* Delete it if already existent */ | ||
22 | |||
23 | /* Create Expressions database */ | ||
24 | try { | ||
25 | db = SqlJetDb.open(dbFile, true); | ||
26 | db.getOptions().setAutovacuum(true); | ||
27 | db.beginTransaction(SqlJetTransactionMode.WRITE); | ||
28 | try { | ||
29 | db.getOptions().setUserVersion(1);/* Sets the user's cookie */ | ||
30 | } finally { | ||
31 | db.commit(); | ||
32 | } | ||
33 | /* Create table Expression */ | ||
34 | db.createTable(createTableQuery); | ||
35 | } | ||
36 | catch (SqlJetException e) { | ||
37 | e.printStackTrace(); | ||
38 | } | ||
39 | } | ||
40 | |||
41 | |||
42 | public static void closeDatabase() | ||
43 | { | ||
44 | try { | ||
45 | db.close(); | ||
46 | } catch (SqlJetException e) { | ||
47 | e.printStackTrace(); | ||
48 | } | ||
49 | } | ||
50 | |||
51 | |||
52 | public static void insertIntoExpressionTable(String fileName, String expressionSyntax, | ||
53 | int startLineNo, int endLineNo, int scopeStartLineNo, | ||
54 | int scopeEndLineNo) | ||
55 | { | ||
56 | if (db == null) { | ||
57 | System.out.println("Error:Database handle is not initialized. Program will exit now!"); | ||
58 | System.exit(1); | ||
59 | } | ||
60 | |||
61 | ISqlJetTable table; | ||
62 | try { | ||
63 | table = db.getTable("Expression"); | ||
64 | db.beginTransaction(SqlJetTransactionMode.WRITE); | ||
65 | try { | ||
66 | table.insert(fileName, expressionSyntax, startLineNo, endLineNo, scopeStartLineNo, scopeEndLineNo); | ||
67 | } finally { | ||
68 | db.commit(); | ||
69 | } | ||
70 | } | ||
71 | catch (SqlJetException e) { | ||
72 | e.printStackTrace(); | ||
73 | } | ||
74 | } | ||
75 | } | ||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/GNUnetDepthFirstVisitor.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/GNUnetDepthFirstVisitor.java new file mode 100644 index 000000000..17592b8a8 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/GNUnetDepthFirstVisitor.java | |||
@@ -0,0 +1,36 @@ | |||
1 | package org.gnunet.seaspider.parser; | ||
2 | import org.gnunet.seaspider.parser.nodes.AssignmentOperator; | ||
3 | import org.gnunet.seaspider.parser.nodes.CompoundStatement; | ||
4 | import org.gnunet.seaspider.parser.nodes.Expression; | ||
5 | import org.gnunet.seaspider.parser.nodes.NodeToken; | ||
6 | import org.gnunet.seaspider.parser.visitors.DepthFirstVisitor; | ||
7 | |||
8 | public class GNUnetDepthFirstVisitor extends DepthFirstVisitor { | ||
9 | private int current_endline; | ||
10 | private int blockStart; | ||
11 | private int blockEnd; | ||
12 | |||
13 | public void visit(Expression n) { | ||
14 | n.f0.accept(this); | ||
15 | } | ||
16 | public void visit(AssignmentOperator n) { | ||
17 | n.f0.accept(this); | ||
18 | } | ||
19 | |||
20 | /** | ||
21 | * <PRE> | ||
22 | * f0 -> "{" | ||
23 | * f1 -> ( LocalVariableDeclaration() | Statement() )* | ||
24 | * f2 -> "}" | ||
25 | * </PRE> | ||
26 | */ | ||
27 | public void visit(CompoundStatement n) { | ||
28 | int old_ll = current_endline; | ||
29 | current_endline = n.f2.endLine; | ||
30 | System.out.println("Scope starts at line:" + n.f0.endLine + " and ends at line:" + n.f2.endLine); | ||
31 | n.f0.accept(this); | ||
32 | n.f1.accept(this); | ||
33 | n.f2.accept(this); | ||
34 | current_endline = old_ll; | ||
35 | } | ||
36 | } | ||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/GNUnetParser.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/GNUnetParser.java new file mode 100644 index 000000000..d0a6a94f0 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/GNUnetParser.java | |||
@@ -0,0 +1,5633 @@ | |||
1 | package org.gnunet.seaspider.parser; | ||
2 | /* Generated By:JavaCC: Do not edit this line. CParser.java */ | ||
3 | import java.io.File; | ||
4 | import java.io.FileFilter; | ||
5 | import java.io.FileInputStream; | ||
6 | import java.io.FileNotFoundException; | ||
7 | |||
8 | import org.gnunet.seaspider.parser.nodes.*; | ||
9 | |||
10 | public class GNUnetParser implements CParserConstants { | ||
11 | private static final boolean DEBUG = false; | ||
12 | |||
13 | public static void main(String args[]) | ||
14 | { | ||
15 | GNUnetParser parser = null; | ||
16 | boolean isFirstFile = true; | ||
17 | int fileNotFoundCount = 0; | ||
18 | int successCount = 0; | ||
19 | int failureCount = 0; | ||
20 | String databasePath; | ||
21 | |||
22 | if (null == (databasePath = args[0])) { | ||
23 | System.out.println("Error: Missing Database Path argument. Program will exit now!"); | ||
24 | System.exit(1); | ||
25 | } | ||
26 | |||
27 | System.out.println("C Parser Version 0.1Alpha: Reading from GNUnet source directory . . ."); | ||
28 | String gnunetSourcePath = System.getenv("MAINDIR") + "/src"; | ||
29 | |||
30 | /* Filtering out files */ | ||
31 | FileFilter filter = new FileFilter() { | ||
32 | public boolean accept(File file) { | ||
33 | return file.isDirectory(); | ||
34 | } | ||
35 | }; | ||
36 | |||
37 | /* File filter to get only source and header files */ | ||
38 | FileFilter sourceFilter = new FileFilter() { | ||
39 | public boolean accept(File file) { | ||
40 | String fileName = file.getName(); | ||
41 | return (fileName.endsWith(".c") || fileName.endsWith(".h")); | ||
42 | } | ||
43 | }; | ||
44 | |||
45 | /* Create the Expressions Database */ | ||
46 | ExpressionDatabaseHandler.createExpressionDatabase(databasePath); | ||
47 | |||
48 | File[] dirArr = (new File(gnunetSourcePath)).listFiles(filter); | ||
49 | for (int i = 0; i < dirArr.length; i++) { | ||
50 | File dir = dirArr[i]; | ||
51 | File[] fileArr = dir.listFiles(sourceFilter); | ||
52 | for (int j = 0; j < fileArr.length; j++) { | ||
53 | try { | ||
54 | if (isFirstFile) { | ||
55 | parser = new GNUnetParser(new FileInputStream(fileArr[j].getPath())); | ||
56 | isFirstFile = false; | ||
57 | } | ||
58 | else | ||
59 | parser.ReInit(new FileInputStream(fileArr[j].getPath())); | ||
60 | } | ||
61 | catch (FileNotFoundException e) { | ||
62 | fileNotFoundCount++; | ||
63 | e.printStackTrace(); | ||
64 | } | ||
65 | try { | ||
66 | System.out.println("Parsing file: " + dir + "/" + fileArr[j].getName()); | ||
67 | Node root = parser.TranslationUnit(); | ||
68 | root.accept(new GNUnetDepthFirstVisitor()); | ||
69 | System.out.println("File " + dir + "/" + fileArr[j].getName() + " parsed successfully."); | ||
70 | successCount++; | ||
71 | } | ||
72 | catch (ParseException e) { | ||
73 | System.out.println("Encountered errors during parsing file " + fileArr[j].getName()); | ||
74 | failureCount++; | ||
75 | if (DEBUG) | ||
76 | e.printStackTrace(); | ||
77 | } | ||
78 | } | ||
79 | } | ||
80 | |||
81 | /* We're done with the Expression Database, close it */ | ||
82 | ExpressionDatabaseHandler.closeDatabase(); | ||
83 | |||
84 | System.out.println(successCount + " parsed successfully."); | ||
85 | System.out.println("Failed to parse " + failureCount + " files."); | ||
86 | System.out.println(fileNotFoundCount + " files not found."); | ||
87 | } | ||
88 | |||
89 | final public TranslationUnit TranslationUnit() throws ParseException { | ||
90 | NodeList n0 = new NodeList(); | ||
91 | ExternalDeclaration n1; | ||
92 | label_1: | ||
93 | while (true) { | ||
94 | n1 = ExternalDeclaration(); | ||
95 | n0.addNode(n1); | ||
96 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
97 | case REGISTER: | ||
98 | case UNSIGNED: | ||
99 | case TYPEDEF: | ||
100 | case DOUBLE: | ||
101 | case EXTERN: | ||
102 | case STRUCT: | ||
103 | case STATIC: | ||
104 | case SIGNED: | ||
105 | case UNION: | ||
106 | case CONST: | ||
107 | case FLOAT: | ||
108 | case SHORT: | ||
109 | case LONG: | ||
110 | case ENUM: | ||
111 | case AUTO: | ||
112 | case VOID: | ||
113 | case CHAR: | ||
114 | case INT: | ||
115 | case IDENTIFIER: | ||
116 | ; | ||
117 | break; | ||
118 | default: | ||
119 | jj_la1[0] = jj_gen; | ||
120 | break label_1; | ||
121 | } | ||
122 | } | ||
123 | n0.nodes.trimToSize(); | ||
124 | {if (true) return new TranslationUnit(n0);} | ||
125 | throw new Error("Missing return statement in function"); | ||
126 | } | ||
127 | |||
128 | final public ExternalDeclaration ExternalDeclaration() throws ParseException { | ||
129 | NodeListOptional n0 = new NodeListOptional(); | ||
130 | StorageClassSpecifier n1; | ||
131 | NodeChoice n2; | ||
132 | FunctionDeclaration n3; | ||
133 | StructOrUnionSpecifier n4; | ||
134 | VariableDeclaration n5; | ||
135 | TypeDeclaration n6; | ||
136 | label_2: | ||
137 | while (true) { | ||
138 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
139 | case EXTERN: | ||
140 | case STATIC: | ||
141 | ; | ||
142 | break; | ||
143 | default: | ||
144 | jj_la1[1] = jj_gen; | ||
145 | break label_2; | ||
146 | } | ||
147 | n1 = StorageClassSpecifier(); | ||
148 | n0.addNode(n1); | ||
149 | } | ||
150 | n0.nodes.trimToSize(); | ||
151 | if (jj_2_1(2147483647)) { | ||
152 | n3 = FunctionDeclaration(); | ||
153 | n2 = new NodeChoice(n3, 0); | ||
154 | } else if (jj_2_2(2147483647)) { | ||
155 | n4 = StructOrUnionSpecifier(); | ||
156 | n2 = new NodeChoice(n4, 1); | ||
157 | } else if (jj_2_3(2147483647)) { | ||
158 | n5 = VariableDeclaration(); | ||
159 | n2 = new NodeChoice(n5, 2); | ||
160 | } else if (jj_2_4(2147483647)) { | ||
161 | n6 = TypeDeclaration(); | ||
162 | n2 = new NodeChoice(n6, 3); | ||
163 | } else { | ||
164 | jj_consume_token(-1); | ||
165 | throw new ParseException(); | ||
166 | } | ||
167 | {if (true) return new ExternalDeclaration(n0,n2);} | ||
168 | throw new Error("Missing return statement in function"); | ||
169 | } | ||
170 | |||
171 | final public FunctionDeclaration FunctionDeclaration() throws ParseException { | ||
172 | TypeSpecifier n0; | ||
173 | NodeToken n1; | ||
174 | Token n2; | ||
175 | NodeToken n3; | ||
176 | Token n4; | ||
177 | NodeOptional n5 = new NodeOptional(); | ||
178 | ParameterList n6; | ||
179 | NodeToken n7; | ||
180 | Token n8; | ||
181 | NodeChoice n9; | ||
182 | NodeToken n10; | ||
183 | Token n11; | ||
184 | CompoundStatement n12; | ||
185 | n0 = TypeSpecifier(); | ||
186 | n2 = jj_consume_token(IDENTIFIER); | ||
187 | n1 = JTBToolkit.makeNodeToken(n2); | ||
188 | n4 = jj_consume_token(55); | ||
189 | n3 = JTBToolkit.makeNodeToken(n4); | ||
190 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
191 | case UNSIGNED: | ||
192 | case DOUBLE: | ||
193 | case STRUCT: | ||
194 | case SIGNED: | ||
195 | case UNION: | ||
196 | case CONST: | ||
197 | case FLOAT: | ||
198 | case SHORT: | ||
199 | case LONG: | ||
200 | case ENUM: | ||
201 | case VOID: | ||
202 | case CHAR: | ||
203 | case INT: | ||
204 | case IDENTIFIER: | ||
205 | n6 = ParameterList(); | ||
206 | n5.addNode(n6); | ||
207 | break; | ||
208 | default: | ||
209 | jj_la1[2] = jj_gen; | ||
210 | ; | ||
211 | } | ||
212 | n8 = jj_consume_token(56); | ||
213 | n7 = JTBToolkit.makeNodeToken(n8); | ||
214 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
215 | case 57: | ||
216 | n11 = jj_consume_token(57); | ||
217 | n10 = JTBToolkit.makeNodeToken(n11); | ||
218 | n9 = new NodeChoice(n10, 0); | ||
219 | break; | ||
220 | case 61: | ||
221 | n12 = CompoundStatement(); | ||
222 | n9 = new NodeChoice(n12, 1); | ||
223 | break; | ||
224 | default: | ||
225 | jj_la1[3] = jj_gen; | ||
226 | jj_consume_token(-1); | ||
227 | throw new ParseException(); | ||
228 | } | ||
229 | {if (true) return new FunctionDeclaration(n0,n1,n3,n5,n7,n9);} | ||
230 | throw new Error("Missing return statement in function"); | ||
231 | } | ||
232 | |||
233 | final public StorageClassSpecifier StorageClassSpecifier() throws ParseException { | ||
234 | NodeChoice n0; | ||
235 | NodeToken n1; | ||
236 | Token n2; | ||
237 | NodeToken n3; | ||
238 | Token n4; | ||
239 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
240 | case STATIC: | ||
241 | n2 = jj_consume_token(STATIC); | ||
242 | n1 = JTBToolkit.makeNodeToken(n2); | ||
243 | n0 = new NodeChoice(n1, 0); | ||
244 | break; | ||
245 | case EXTERN: | ||
246 | n4 = jj_consume_token(EXTERN); | ||
247 | n3 = JTBToolkit.makeNodeToken(n4); | ||
248 | n0 = new NodeChoice(n3, 1); | ||
249 | break; | ||
250 | default: | ||
251 | jj_la1[4] = jj_gen; | ||
252 | jj_consume_token(-1); | ||
253 | throw new ParseException(); | ||
254 | } | ||
255 | {if (true) return new StorageClassSpecifier(n0);} | ||
256 | throw new Error("Missing return statement in function"); | ||
257 | } | ||
258 | |||
259 | final public TypeDeclaration TypeDeclaration() throws ParseException { | ||
260 | NodeToken n0; | ||
261 | Token n1; | ||
262 | NodeChoice n2; | ||
263 | DataType n3; | ||
264 | FunctionType n4; | ||
265 | NodeToken n5; | ||
266 | Token n6; | ||
267 | n1 = jj_consume_token(TYPEDEF); | ||
268 | n0 = JTBToolkit.makeNodeToken(n1); | ||
269 | if (jj_2_5(2147483647)) { | ||
270 | n3 = DataType(); | ||
271 | n2 = new NodeChoice(n3, 0); | ||
272 | } else { | ||
273 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
274 | case UNSIGNED: | ||
275 | case DOUBLE: | ||
276 | case STRUCT: | ||
277 | case SIGNED: | ||
278 | case UNION: | ||
279 | case CONST: | ||
280 | case FLOAT: | ||
281 | case SHORT: | ||
282 | case LONG: | ||
283 | case ENUM: | ||
284 | case VOID: | ||
285 | case CHAR: | ||
286 | case INT: | ||
287 | case IDENTIFIER: | ||
288 | n4 = FunctionType(); | ||
289 | n2 = new NodeChoice(n4, 1); | ||
290 | break; | ||
291 | default: | ||
292 | jj_la1[5] = jj_gen; | ||
293 | jj_consume_token(-1); | ||
294 | throw new ParseException(); | ||
295 | } | ||
296 | } | ||
297 | n6 = jj_consume_token(57); | ||
298 | n5 = JTBToolkit.makeNodeToken(n6); | ||
299 | {if (true) return new TypeDeclaration(n0,n2,n5);} | ||
300 | throw new Error("Missing return statement in function"); | ||
301 | } | ||
302 | |||
303 | final public DataType DataType() throws ParseException { | ||
304 | StructOrUnionSpecifier n0; | ||
305 | NodeToken n1; | ||
306 | Token n2; | ||
307 | n0 = StructOrUnionSpecifier(); | ||
308 | n2 = jj_consume_token(IDENTIFIER); | ||
309 | n1 = JTBToolkit.makeNodeToken(n2); | ||
310 | {if (true) return new DataType(n0,n1);} | ||
311 | throw new Error("Missing return statement in function"); | ||
312 | } | ||
313 | |||
314 | final public FunctionType FunctionType() throws ParseException { | ||
315 | TypeSpecifier n0; | ||
316 | NodeToken n1; | ||
317 | Token n2; | ||
318 | NodeToken n3; | ||
319 | Token n4; | ||
320 | NodeToken n5; | ||
321 | Token n6; | ||
322 | NodeToken n7; | ||
323 | Token n8; | ||
324 | NodeToken n9; | ||
325 | Token n10; | ||
326 | NodeOptional n11 = new NodeOptional(); | ||
327 | ParameterList n12; | ||
328 | NodeToken n13; | ||
329 | Token n14; | ||
330 | n0 = TypeSpecifier(); | ||
331 | n2 = jj_consume_token(55); | ||
332 | n1 = JTBToolkit.makeNodeToken(n2); | ||
333 | n4 = jj_consume_token(58); | ||
334 | n3 = JTBToolkit.makeNodeToken(n4); | ||
335 | n6 = jj_consume_token(IDENTIFIER); | ||
336 | n5 = JTBToolkit.makeNodeToken(n6); | ||
337 | n8 = jj_consume_token(56); | ||
338 | n7 = JTBToolkit.makeNodeToken(n8); | ||
339 | n10 = jj_consume_token(55); | ||
340 | n9 = JTBToolkit.makeNodeToken(n10); | ||
341 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
342 | case UNSIGNED: | ||
343 | case DOUBLE: | ||
344 | case STRUCT: | ||
345 | case SIGNED: | ||
346 | case UNION: | ||
347 | case CONST: | ||
348 | case FLOAT: | ||
349 | case SHORT: | ||
350 | case LONG: | ||
351 | case ENUM: | ||
352 | case VOID: | ||
353 | case CHAR: | ||
354 | case INT: | ||
355 | case IDENTIFIER: | ||
356 | n12 = ParameterList(); | ||
357 | n11.addNode(n12); | ||
358 | break; | ||
359 | default: | ||
360 | jj_la1[6] = jj_gen; | ||
361 | ; | ||
362 | } | ||
363 | n14 = jj_consume_token(56); | ||
364 | n13 = JTBToolkit.makeNodeToken(n14); | ||
365 | {if (true) return new FunctionType(n0,n1,n3,n5,n7,n9,n11,n13);} | ||
366 | throw new Error("Missing return statement in function"); | ||
367 | } | ||
368 | |||
369 | final public ParameterList ParameterList() throws ParseException { | ||
370 | ParameterDeclaration n0; | ||
371 | NodeListOptional n1 = new NodeListOptional(); | ||
372 | NodeSequence n2; | ||
373 | NodeToken n3; | ||
374 | Token n4; | ||
375 | ParameterDeclaration n5; | ||
376 | NodeOptional n6 = new NodeOptional(); | ||
377 | NodeSequence n7; | ||
378 | NodeToken n8; | ||
379 | Token n9; | ||
380 | NodeToken n10; | ||
381 | Token n11; | ||
382 | n0 = ParameterDeclaration(); | ||
383 | label_3: | ||
384 | while (true) { | ||
385 | if (jj_2_6(2)) { | ||
386 | ; | ||
387 | } else { | ||
388 | break label_3; | ||
389 | } | ||
390 | n2 = new NodeSequence(2); | ||
391 | n4 = jj_consume_token(59); | ||
392 | n3 = JTBToolkit.makeNodeToken(n4); | ||
393 | n2.addNode(n3); | ||
394 | n5 = ParameterDeclaration(); | ||
395 | n2.addNode(n5); | ||
396 | n1.addNode(n2); | ||
397 | } | ||
398 | n1.nodes.trimToSize(); | ||
399 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
400 | case 59: | ||
401 | n7 = new NodeSequence(2); | ||
402 | n9 = jj_consume_token(59); | ||
403 | n8 = JTBToolkit.makeNodeToken(n9); | ||
404 | n7.addNode(n8); | ||
405 | n11 = jj_consume_token(60); | ||
406 | n10 = JTBToolkit.makeNodeToken(n11); | ||
407 | n7.addNode(n10); | ||
408 | n6.addNode(n7); | ||
409 | break; | ||
410 | default: | ||
411 | jj_la1[7] = jj_gen; | ||
412 | ; | ||
413 | } | ||
414 | {if (true) return new ParameterList(n0,n1,n6);} | ||
415 | throw new Error("Missing return statement in function"); | ||
416 | } | ||
417 | |||
418 | final public ParameterDeclaration ParameterDeclaration() throws ParseException { | ||
419 | TypeSpecifier n0; | ||
420 | NodeToken n1; | ||
421 | Token n2; | ||
422 | NodeOptional n3 = new NodeOptional(); | ||
423 | Array n4; | ||
424 | n0 = TypeSpecifier(); | ||
425 | n2 = jj_consume_token(IDENTIFIER); | ||
426 | n1 = JTBToolkit.makeNodeToken(n2); | ||
427 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
428 | case 65: | ||
429 | n4 = Array(); | ||
430 | n3.addNode(n4); | ||
431 | break; | ||
432 | default: | ||
433 | jj_la1[8] = jj_gen; | ||
434 | ; | ||
435 | } | ||
436 | {if (true) return new ParameterDeclaration(n0,n1,n3);} | ||
437 | throw new Error("Missing return statement in function"); | ||
438 | } | ||
439 | |||
440 | final public VariableDeclaration VariableDeclaration() throws ParseException { | ||
441 | VariableClassSpecifier n0; | ||
442 | TypeSpecifier n1; | ||
443 | InitDeclaratorList n2; | ||
444 | NodeToken n3; | ||
445 | Token n4; | ||
446 | n0 = VariableClassSpecifier(); | ||
447 | n1 = TypeSpecifier(); | ||
448 | n2 = InitDeclaratorList(); | ||
449 | n4 = jj_consume_token(57); | ||
450 | n3 = JTBToolkit.makeNodeToken(n4); | ||
451 | {if (true) return new VariableDeclaration(n0,n1,n2,n3);} | ||
452 | throw new Error("Missing return statement in function"); | ||
453 | } | ||
454 | |||
455 | final public LocalVariableDeclaration LocalVariableDeclaration() throws ParseException { | ||
456 | NodeOptional n0 = new NodeOptional(); | ||
457 | NodeToken n1; | ||
458 | Token n2; | ||
459 | VariableDeclaration n3; | ||
460 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
461 | case STATIC: | ||
462 | n2 = jj_consume_token(STATIC); | ||
463 | n1 = JTBToolkit.makeNodeToken(n2); | ||
464 | n0.addNode(n1); | ||
465 | break; | ||
466 | default: | ||
467 | jj_la1[9] = jj_gen; | ||
468 | ; | ||
469 | } | ||
470 | n3 = VariableDeclaration(); | ||
471 | {if (true) return new LocalVariableDeclaration(n0,n3);} | ||
472 | throw new Error("Missing return statement in function"); | ||
473 | } | ||
474 | |||
475 | final public VariableClassSpecifier VariableClassSpecifier() throws ParseException { | ||
476 | NodeListOptional n0 = new NodeListOptional(); | ||
477 | NodeChoice n1; | ||
478 | NodeToken n2; | ||
479 | Token n3; | ||
480 | NodeToken n4; | ||
481 | Token n5; | ||
482 | label_4: | ||
483 | while (true) { | ||
484 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
485 | case REGISTER: | ||
486 | case AUTO: | ||
487 | ; | ||
488 | break; | ||
489 | default: | ||
490 | jj_la1[10] = jj_gen; | ||
491 | break label_4; | ||
492 | } | ||
493 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
494 | case AUTO: | ||
495 | n3 = jj_consume_token(AUTO); | ||
496 | n2 = JTBToolkit.makeNodeToken(n3); | ||
497 | n1 = new NodeChoice(n2, 0); | ||
498 | break; | ||
499 | case REGISTER: | ||
500 | n5 = jj_consume_token(REGISTER); | ||
501 | n4 = JTBToolkit.makeNodeToken(n5); | ||
502 | n1 = new NodeChoice(n4, 1); | ||
503 | break; | ||
504 | default: | ||
505 | jj_la1[11] = jj_gen; | ||
506 | jj_consume_token(-1); | ||
507 | throw new ParseException(); | ||
508 | } | ||
509 | n0.addNode(n1); | ||
510 | } | ||
511 | n0.nodes.trimToSize(); | ||
512 | {if (true) return new VariableClassSpecifier(n0);} | ||
513 | throw new Error("Missing return statement in function"); | ||
514 | } | ||
515 | |||
516 | final public TypeSpecifier TypeSpecifier() throws ParseException { | ||
517 | NodeOptional n0 = new NodeOptional(); | ||
518 | NodeToken n1; | ||
519 | Token n2; | ||
520 | NodeChoice n3; | ||
521 | NodeToken n4; | ||
522 | Token n5; | ||
523 | NodeToken n6; | ||
524 | Token n7; | ||
525 | NodeSequence n8; | ||
526 | NodeToken n9; | ||
527 | Token n10; | ||
528 | NodeOptional n11 = new NodeOptional(); | ||
529 | NodeToken n12; | ||
530 | Token n13; | ||
531 | NodeToken n14; | ||
532 | Token n15; | ||
533 | NodeSequence n16; | ||
534 | NodeToken n17; | ||
535 | Token n18; | ||
536 | NodeOptional n19 = new NodeOptional(); | ||
537 | NodeToken n20; | ||
538 | Token n21; | ||
539 | NodeToken n22; | ||
540 | Token n23; | ||
541 | NodeToken n24; | ||
542 | Token n25; | ||
543 | NodeSequence n26; | ||
544 | NodeChoice n27; | ||
545 | NodeToken n28; | ||
546 | Token n29; | ||
547 | NodeToken n30; | ||
548 | Token n31; | ||
549 | NodeOptional n32 = new NodeOptional(); | ||
550 | NodeChoice n33; | ||
551 | NodeToken n34; | ||
552 | Token n35; | ||
553 | NodeSequence n36; | ||
554 | NodeToken n37; | ||
555 | Token n38; | ||
556 | NodeOptional n39; | ||
557 | NodeToken n40; | ||
558 | Token n41; | ||
559 | NodeToken n42; | ||
560 | Token n43; | ||
561 | NodeSequence n44; | ||
562 | NodeToken n45; | ||
563 | Token n46; | ||
564 | NodeOptional n47; | ||
565 | NodeToken n48; | ||
566 | Token n49; | ||
567 | StructOrUnionSpecifier n50; | ||
568 | EnumSpecifier n51; | ||
569 | NodeToken n52; | ||
570 | Token n53; | ||
571 | NodeOptional n54 = new NodeOptional(); | ||
572 | Pointer n55; | ||
573 | NodeOptional n56 = new NodeOptional(); | ||
574 | Array n57; | ||
575 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
576 | case CONST: | ||
577 | n2 = jj_consume_token(CONST); | ||
578 | n1 = JTBToolkit.makeNodeToken(n2); | ||
579 | n0.addNode(n1); | ||
580 | break; | ||
581 | default: | ||
582 | jj_la1[12] = jj_gen; | ||
583 | ; | ||
584 | } | ||
585 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
586 | case VOID: | ||
587 | n5 = jj_consume_token(VOID); | ||
588 | n4 = JTBToolkit.makeNodeToken(n5); | ||
589 | n3 = new NodeChoice(n4, 0); | ||
590 | break; | ||
591 | case CHAR: | ||
592 | n7 = jj_consume_token(CHAR); | ||
593 | n6 = JTBToolkit.makeNodeToken(n7); | ||
594 | n3 = new NodeChoice(n6, 1); | ||
595 | break; | ||
596 | case SHORT: | ||
597 | n8 = new NodeSequence(2); | ||
598 | n10 = jj_consume_token(SHORT); | ||
599 | n9 = JTBToolkit.makeNodeToken(n10); | ||
600 | n8.addNode(n9); | ||
601 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
602 | case INT: | ||
603 | n13 = jj_consume_token(INT); | ||
604 | n12 = JTBToolkit.makeNodeToken(n13); | ||
605 | n11.addNode(n12); | ||
606 | break; | ||
607 | default: | ||
608 | jj_la1[13] = jj_gen; | ||
609 | ; | ||
610 | } | ||
611 | n8.addNode(n11); | ||
612 | n3 = new NodeChoice(n8, 2); | ||
613 | break; | ||
614 | case INT: | ||
615 | n15 = jj_consume_token(INT); | ||
616 | n14 = JTBToolkit.makeNodeToken(n15); | ||
617 | n3 = new NodeChoice(n14, 3); | ||
618 | break; | ||
619 | case LONG: | ||
620 | n16 = new NodeSequence(2); | ||
621 | n18 = jj_consume_token(LONG); | ||
622 | n17 = JTBToolkit.makeNodeToken(n18); | ||
623 | n16.addNode(n17); | ||
624 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
625 | case LONG: | ||
626 | n21 = jj_consume_token(LONG); | ||
627 | n20 = JTBToolkit.makeNodeToken(n21); | ||
628 | n19.addNode(n20); | ||
629 | break; | ||
630 | default: | ||
631 | jj_la1[14] = jj_gen; | ||
632 | ; | ||
633 | } | ||
634 | n16.addNode(n19); | ||
635 | n3 = new NodeChoice(n16, 4); | ||
636 | break; | ||
637 | case FLOAT: | ||
638 | n23 = jj_consume_token(FLOAT); | ||
639 | n22 = JTBToolkit.makeNodeToken(n23); | ||
640 | n3 = new NodeChoice(n22, 5); | ||
641 | break; | ||
642 | case DOUBLE: | ||
643 | n25 = jj_consume_token(DOUBLE); | ||
644 | n24 = JTBToolkit.makeNodeToken(n25); | ||
645 | n3 = new NodeChoice(n24, 6); | ||
646 | break; | ||
647 | case UNSIGNED: | ||
648 | case SIGNED: | ||
649 | n26 = new NodeSequence(2); | ||
650 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
651 | case SIGNED: | ||
652 | n29 = jj_consume_token(SIGNED); | ||
653 | n28 = JTBToolkit.makeNodeToken(n29); | ||
654 | n27 = new NodeChoice(n28, 0); | ||
655 | break; | ||
656 | case UNSIGNED: | ||
657 | n31 = jj_consume_token(UNSIGNED); | ||
658 | n30 = JTBToolkit.makeNodeToken(n31); | ||
659 | n27 = new NodeChoice(n30, 1); | ||
660 | break; | ||
661 | default: | ||
662 | jj_la1[15] = jj_gen; | ||
663 | jj_consume_token(-1); | ||
664 | throw new ParseException(); | ||
665 | } | ||
666 | n26.addNode(n27); | ||
667 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
668 | case SHORT: | ||
669 | case LONG: | ||
670 | case CHAR: | ||
671 | case INT: | ||
672 | n39 = new NodeOptional(); | ||
673 | n47 = new NodeOptional(); | ||
674 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
675 | case CHAR: | ||
676 | n35 = jj_consume_token(CHAR); | ||
677 | n34 = JTBToolkit.makeNodeToken(n35); | ||
678 | n33 = new NodeChoice(n34, 0); | ||
679 | break; | ||
680 | case SHORT: | ||
681 | n36 = new NodeSequence(2); | ||
682 | n38 = jj_consume_token(SHORT); | ||
683 | n37 = JTBToolkit.makeNodeToken(n38); | ||
684 | n36.addNode(n37); | ||
685 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
686 | case INT: | ||
687 | n41 = jj_consume_token(INT); | ||
688 | n40 = JTBToolkit.makeNodeToken(n41); | ||
689 | n39.addNode(n40); | ||
690 | break; | ||
691 | default: | ||
692 | jj_la1[16] = jj_gen; | ||
693 | ; | ||
694 | } | ||
695 | n36.addNode(n39); | ||
696 | n33 = new NodeChoice(n36, 1); | ||
697 | break; | ||
698 | case INT: | ||
699 | n43 = jj_consume_token(INT); | ||
700 | n42 = JTBToolkit.makeNodeToken(n43); | ||
701 | n33 = new NodeChoice(n42, 2); | ||
702 | break; | ||
703 | case LONG: | ||
704 | n44 = new NodeSequence(2); | ||
705 | n46 = jj_consume_token(LONG); | ||
706 | n45 = JTBToolkit.makeNodeToken(n46); | ||
707 | n44.addNode(n45); | ||
708 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
709 | case LONG: | ||
710 | n49 = jj_consume_token(LONG); | ||
711 | n48 = JTBToolkit.makeNodeToken(n49); | ||
712 | n47.addNode(n48); | ||
713 | break; | ||
714 | default: | ||
715 | jj_la1[17] = jj_gen; | ||
716 | ; | ||
717 | } | ||
718 | n44.addNode(n47); | ||
719 | n33 = new NodeChoice(n44, 3); | ||
720 | break; | ||
721 | default: | ||
722 | jj_la1[18] = jj_gen; | ||
723 | jj_consume_token(-1); | ||
724 | throw new ParseException(); | ||
725 | } | ||
726 | n32.addNode(n33); | ||
727 | break; | ||
728 | default: | ||
729 | jj_la1[19] = jj_gen; | ||
730 | ; | ||
731 | } | ||
732 | n26.addNode(n32); | ||
733 | n3 = new NodeChoice(n26, 7); | ||
734 | break; | ||
735 | case STRUCT: | ||
736 | case UNION: | ||
737 | n50 = StructOrUnionSpecifier(); | ||
738 | n3 = new NodeChoice(n50, 8); | ||
739 | break; | ||
740 | case ENUM: | ||
741 | n51 = EnumSpecifier(); | ||
742 | n3 = new NodeChoice(n51, 9); | ||
743 | break; | ||
744 | case IDENTIFIER: | ||
745 | n53 = jj_consume_token(IDENTIFIER); | ||
746 | n52 = JTBToolkit.makeNodeToken(n53); | ||
747 | n3 = new NodeChoice(n52, 10); | ||
748 | break; | ||
749 | default: | ||
750 | jj_la1[20] = jj_gen; | ||
751 | jj_consume_token(-1); | ||
752 | throw new ParseException(); | ||
753 | } | ||
754 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
755 | case 58: | ||
756 | n55 = Pointer(); | ||
757 | n54.addNode(n55); | ||
758 | break; | ||
759 | default: | ||
760 | jj_la1[21] = jj_gen; | ||
761 | ; | ||
762 | } | ||
763 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
764 | case 65: | ||
765 | n57 = Array(); | ||
766 | n56.addNode(n57); | ||
767 | break; | ||
768 | default: | ||
769 | jj_la1[22] = jj_gen; | ||
770 | ; | ||
771 | } | ||
772 | {if (true) return new TypeSpecifier(n0,n3,n54,n56);} | ||
773 | throw new Error("Missing return statement in function"); | ||
774 | } | ||
775 | |||
776 | final public NoIdentifierTypeSpecifier NoIdentifierTypeSpecifier() throws ParseException { | ||
777 | NodeOptional n0 = new NodeOptional(); | ||
778 | NodeToken n1; | ||
779 | Token n2; | ||
780 | NodeChoice n3; | ||
781 | NodeToken n4; | ||
782 | Token n5; | ||
783 | NodeToken n6; | ||
784 | Token n7; | ||
785 | NodeSequence n8; | ||
786 | NodeToken n9; | ||
787 | Token n10; | ||
788 | NodeOptional n11 = new NodeOptional(); | ||
789 | NodeToken n12; | ||
790 | Token n13; | ||
791 | NodeToken n14; | ||
792 | Token n15; | ||
793 | NodeSequence n16; | ||
794 | NodeToken n17; | ||
795 | Token n18; | ||
796 | NodeOptional n19 = new NodeOptional(); | ||
797 | NodeToken n20; | ||
798 | Token n21; | ||
799 | NodeToken n22; | ||
800 | Token n23; | ||
801 | NodeToken n24; | ||
802 | Token n25; | ||
803 | NodeSequence n26; | ||
804 | NodeChoice n27; | ||
805 | NodeToken n28; | ||
806 | Token n29; | ||
807 | NodeToken n30; | ||
808 | Token n31; | ||
809 | NodeOptional n32 = new NodeOptional(); | ||
810 | NodeChoice n33; | ||
811 | NodeToken n34; | ||
812 | Token n35; | ||
813 | NodeSequence n36; | ||
814 | NodeToken n37; | ||
815 | Token n38; | ||
816 | NodeOptional n39; | ||
817 | NodeToken n40; | ||
818 | Token n41; | ||
819 | NodeToken n42; | ||
820 | Token n43; | ||
821 | NodeSequence n44; | ||
822 | NodeToken n45; | ||
823 | Token n46; | ||
824 | NodeOptional n47; | ||
825 | NodeToken n48; | ||
826 | Token n49; | ||
827 | StructOrUnionSpecifier n50; | ||
828 | EnumSpecifier n51; | ||
829 | NodeOptional n52 = new NodeOptional(); | ||
830 | Pointer n53; | ||
831 | NodeOptional n54 = new NodeOptional(); | ||
832 | Array n55; | ||
833 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
834 | case CONST: | ||
835 | n2 = jj_consume_token(CONST); | ||
836 | n1 = JTBToolkit.makeNodeToken(n2); | ||
837 | n0.addNode(n1); | ||
838 | break; | ||
839 | default: | ||
840 | jj_la1[23] = jj_gen; | ||
841 | ; | ||
842 | } | ||
843 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
844 | case VOID: | ||
845 | n5 = jj_consume_token(VOID); | ||
846 | n4 = JTBToolkit.makeNodeToken(n5); | ||
847 | n3 = new NodeChoice(n4, 0); | ||
848 | break; | ||
849 | case CHAR: | ||
850 | n7 = jj_consume_token(CHAR); | ||
851 | n6 = JTBToolkit.makeNodeToken(n7); | ||
852 | n3 = new NodeChoice(n6, 1); | ||
853 | break; | ||
854 | case SHORT: | ||
855 | n8 = new NodeSequence(2); | ||
856 | n10 = jj_consume_token(SHORT); | ||
857 | n9 = JTBToolkit.makeNodeToken(n10); | ||
858 | n8.addNode(n9); | ||
859 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
860 | case INT: | ||
861 | n13 = jj_consume_token(INT); | ||
862 | n12 = JTBToolkit.makeNodeToken(n13); | ||
863 | n11.addNode(n12); | ||
864 | break; | ||
865 | default: | ||
866 | jj_la1[24] = jj_gen; | ||
867 | ; | ||
868 | } | ||
869 | n8.addNode(n11); | ||
870 | n3 = new NodeChoice(n8, 2); | ||
871 | break; | ||
872 | case INT: | ||
873 | n15 = jj_consume_token(INT); | ||
874 | n14 = JTBToolkit.makeNodeToken(n15); | ||
875 | n3 = new NodeChoice(n14, 3); | ||
876 | break; | ||
877 | case LONG: | ||
878 | n16 = new NodeSequence(2); | ||
879 | n18 = jj_consume_token(LONG); | ||
880 | n17 = JTBToolkit.makeNodeToken(n18); | ||
881 | n16.addNode(n17); | ||
882 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
883 | case LONG: | ||
884 | n21 = jj_consume_token(LONG); | ||
885 | n20 = JTBToolkit.makeNodeToken(n21); | ||
886 | n19.addNode(n20); | ||
887 | break; | ||
888 | default: | ||
889 | jj_la1[25] = jj_gen; | ||
890 | ; | ||
891 | } | ||
892 | n16.addNode(n19); | ||
893 | n3 = new NodeChoice(n16, 4); | ||
894 | break; | ||
895 | case FLOAT: | ||
896 | n23 = jj_consume_token(FLOAT); | ||
897 | n22 = JTBToolkit.makeNodeToken(n23); | ||
898 | n3 = new NodeChoice(n22, 5); | ||
899 | break; | ||
900 | case DOUBLE: | ||
901 | n25 = jj_consume_token(DOUBLE); | ||
902 | n24 = JTBToolkit.makeNodeToken(n25); | ||
903 | n3 = new NodeChoice(n24, 6); | ||
904 | break; | ||
905 | case UNSIGNED: | ||
906 | case SIGNED: | ||
907 | n26 = new NodeSequence(2); | ||
908 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
909 | case SIGNED: | ||
910 | n29 = jj_consume_token(SIGNED); | ||
911 | n28 = JTBToolkit.makeNodeToken(n29); | ||
912 | n27 = new NodeChoice(n28, 0); | ||
913 | break; | ||
914 | case UNSIGNED: | ||
915 | n31 = jj_consume_token(UNSIGNED); | ||
916 | n30 = JTBToolkit.makeNodeToken(n31); | ||
917 | n27 = new NodeChoice(n30, 1); | ||
918 | break; | ||
919 | default: | ||
920 | jj_la1[26] = jj_gen; | ||
921 | jj_consume_token(-1); | ||
922 | throw new ParseException(); | ||
923 | } | ||
924 | n26.addNode(n27); | ||
925 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
926 | case SHORT: | ||
927 | case LONG: | ||
928 | case CHAR: | ||
929 | case INT: | ||
930 | n39 = new NodeOptional(); | ||
931 | n47 = new NodeOptional(); | ||
932 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
933 | case CHAR: | ||
934 | n35 = jj_consume_token(CHAR); | ||
935 | n34 = JTBToolkit.makeNodeToken(n35); | ||
936 | n33 = new NodeChoice(n34, 0); | ||
937 | break; | ||
938 | case SHORT: | ||
939 | n36 = new NodeSequence(2); | ||
940 | n38 = jj_consume_token(SHORT); | ||
941 | n37 = JTBToolkit.makeNodeToken(n38); | ||
942 | n36.addNode(n37); | ||
943 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
944 | case INT: | ||
945 | n41 = jj_consume_token(INT); | ||
946 | n40 = JTBToolkit.makeNodeToken(n41); | ||
947 | n39.addNode(n40); | ||
948 | break; | ||
949 | default: | ||
950 | jj_la1[27] = jj_gen; | ||
951 | ; | ||
952 | } | ||
953 | n36.addNode(n39); | ||
954 | n33 = new NodeChoice(n36, 1); | ||
955 | break; | ||
956 | case INT: | ||
957 | n43 = jj_consume_token(INT); | ||
958 | n42 = JTBToolkit.makeNodeToken(n43); | ||
959 | n33 = new NodeChoice(n42, 2); | ||
960 | break; | ||
961 | case LONG: | ||
962 | n44 = new NodeSequence(2); | ||
963 | n46 = jj_consume_token(LONG); | ||
964 | n45 = JTBToolkit.makeNodeToken(n46); | ||
965 | n44.addNode(n45); | ||
966 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
967 | case LONG: | ||
968 | n49 = jj_consume_token(LONG); | ||
969 | n48 = JTBToolkit.makeNodeToken(n49); | ||
970 | n47.addNode(n48); | ||
971 | break; | ||
972 | default: | ||
973 | jj_la1[28] = jj_gen; | ||
974 | ; | ||
975 | } | ||
976 | n44.addNode(n47); | ||
977 | n33 = new NodeChoice(n44, 3); | ||
978 | break; | ||
979 | default: | ||
980 | jj_la1[29] = jj_gen; | ||
981 | jj_consume_token(-1); | ||
982 | throw new ParseException(); | ||
983 | } | ||
984 | n32.addNode(n33); | ||
985 | break; | ||
986 | default: | ||
987 | jj_la1[30] = jj_gen; | ||
988 | ; | ||
989 | } | ||
990 | n26.addNode(n32); | ||
991 | n3 = new NodeChoice(n26, 7); | ||
992 | break; | ||
993 | case STRUCT: | ||
994 | case UNION: | ||
995 | n50 = StructOrUnionSpecifier(); | ||
996 | n3 = new NodeChoice(n50, 8); | ||
997 | break; | ||
998 | case ENUM: | ||
999 | n51 = EnumSpecifier(); | ||
1000 | n3 = new NodeChoice(n51, 9); | ||
1001 | break; | ||
1002 | default: | ||
1003 | jj_la1[31] = jj_gen; | ||
1004 | jj_consume_token(-1); | ||
1005 | throw new ParseException(); | ||
1006 | } | ||
1007 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1008 | case 58: | ||
1009 | n53 = Pointer(); | ||
1010 | n52.addNode(n53); | ||
1011 | break; | ||
1012 | default: | ||
1013 | jj_la1[32] = jj_gen; | ||
1014 | ; | ||
1015 | } | ||
1016 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1017 | case 65: | ||
1018 | n55 = Array(); | ||
1019 | n54.addNode(n55); | ||
1020 | break; | ||
1021 | default: | ||
1022 | jj_la1[33] = jj_gen; | ||
1023 | ; | ||
1024 | } | ||
1025 | {if (true) return new NoIdentifierTypeSpecifier(n0,n3,n52,n54);} | ||
1026 | throw new Error("Missing return statement in function"); | ||
1027 | } | ||
1028 | |||
1029 | final public StructOrUnionSpecifier StructOrUnionSpecifier() throws ParseException { | ||
1030 | NodeChoice n0; | ||
1031 | NodeSequence n1; | ||
1032 | StructOrUnion n2; | ||
1033 | NodeOptional n3 = new NodeOptional(); | ||
1034 | NodeToken n4; | ||
1035 | Token n5; | ||
1036 | NodeToken n6; | ||
1037 | Token n7; | ||
1038 | StructDeclarationList n8; | ||
1039 | NodeToken n9; | ||
1040 | Token n10; | ||
1041 | NodeSequence n11; | ||
1042 | StructOrUnion n12; | ||
1043 | NodeToken n13; | ||
1044 | Token n14; | ||
1045 | if (jj_2_7(3)) { | ||
1046 | n1 = new NodeSequence(6); | ||
1047 | n2 = StructOrUnion(); | ||
1048 | n1.addNode(n2); | ||
1049 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1050 | case IDENTIFIER: | ||
1051 | n5 = jj_consume_token(IDENTIFIER); | ||
1052 | n4 = JTBToolkit.makeNodeToken(n5); | ||
1053 | n3.addNode(n4); | ||
1054 | break; | ||
1055 | default: | ||
1056 | jj_la1[34] = jj_gen; | ||
1057 | ; | ||
1058 | } | ||
1059 | n1.addNode(n3); | ||
1060 | n7 = jj_consume_token(61); | ||
1061 | n6 = JTBToolkit.makeNodeToken(n7); | ||
1062 | n1.addNode(n6); | ||
1063 | n8 = StructDeclarationList(); | ||
1064 | n1.addNode(n8); | ||
1065 | n10 = jj_consume_token(62); | ||
1066 | n9 = JTBToolkit.makeNodeToken(n10); | ||
1067 | n1.addNode(n9); | ||
1068 | n0 = new NodeChoice(n1, 0); | ||
1069 | } else { | ||
1070 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1071 | case STRUCT: | ||
1072 | case UNION: | ||
1073 | n11 = new NodeSequence(2); | ||
1074 | n12 = StructOrUnion(); | ||
1075 | n11.addNode(n12); | ||
1076 | n14 = jj_consume_token(IDENTIFIER); | ||
1077 | n13 = JTBToolkit.makeNodeToken(n14); | ||
1078 | n11.addNode(n13); | ||
1079 | n0 = new NodeChoice(n11, 1); | ||
1080 | break; | ||
1081 | default: | ||
1082 | jj_la1[35] = jj_gen; | ||
1083 | jj_consume_token(-1); | ||
1084 | throw new ParseException(); | ||
1085 | } | ||
1086 | } | ||
1087 | {if (true) return new StructOrUnionSpecifier(n0);} | ||
1088 | throw new Error("Missing return statement in function"); | ||
1089 | } | ||
1090 | |||
1091 | final public StructOrUnion StructOrUnion() throws ParseException { | ||
1092 | NodeChoice n0; | ||
1093 | NodeToken n1; | ||
1094 | Token n2; | ||
1095 | NodeToken n3; | ||
1096 | Token n4; | ||
1097 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1098 | case STRUCT: | ||
1099 | n2 = jj_consume_token(STRUCT); | ||
1100 | n1 = JTBToolkit.makeNodeToken(n2); | ||
1101 | n0 = new NodeChoice(n1, 0); | ||
1102 | break; | ||
1103 | case UNION: | ||
1104 | n4 = jj_consume_token(UNION); | ||
1105 | n3 = JTBToolkit.makeNodeToken(n4); | ||
1106 | n0 = new NodeChoice(n3, 1); | ||
1107 | break; | ||
1108 | default: | ||
1109 | jj_la1[36] = jj_gen; | ||
1110 | jj_consume_token(-1); | ||
1111 | throw new ParseException(); | ||
1112 | } | ||
1113 | {if (true) return new StructOrUnion(n0);} | ||
1114 | throw new Error("Missing return statement in function"); | ||
1115 | } | ||
1116 | |||
1117 | final public StructDeclarationList StructDeclarationList() throws ParseException { | ||
1118 | NodeList n0 = new NodeList(); | ||
1119 | StructDeclaration n1; | ||
1120 | label_5: | ||
1121 | while (true) { | ||
1122 | n1 = StructDeclaration(); | ||
1123 | n0.addNode(n1); | ||
1124 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1125 | case UNSIGNED: | ||
1126 | case DOUBLE: | ||
1127 | case STRUCT: | ||
1128 | case SIGNED: | ||
1129 | case UNION: | ||
1130 | case CONST: | ||
1131 | case FLOAT: | ||
1132 | case SHORT: | ||
1133 | case LONG: | ||
1134 | case ENUM: | ||
1135 | case VOID: | ||
1136 | case CHAR: | ||
1137 | case INT: | ||
1138 | case IDENTIFIER: | ||
1139 | ; | ||
1140 | break; | ||
1141 | default: | ||
1142 | jj_la1[37] = jj_gen; | ||
1143 | break label_5; | ||
1144 | } | ||
1145 | } | ||
1146 | n0.nodes.trimToSize(); | ||
1147 | {if (true) return new StructDeclarationList(n0);} | ||
1148 | throw new Error("Missing return statement in function"); | ||
1149 | } | ||
1150 | |||
1151 | final public InitDeclaratorList InitDeclaratorList() throws ParseException { | ||
1152 | InitDeclarator n0; | ||
1153 | NodeListOptional n1 = new NodeListOptional(); | ||
1154 | NodeSequence n2; | ||
1155 | NodeToken n3; | ||
1156 | Token n4; | ||
1157 | InitDeclarator n5; | ||
1158 | n0 = InitDeclarator(); | ||
1159 | label_6: | ||
1160 | while (true) { | ||
1161 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1162 | case 59: | ||
1163 | ; | ||
1164 | break; | ||
1165 | default: | ||
1166 | jj_la1[38] = jj_gen; | ||
1167 | break label_6; | ||
1168 | } | ||
1169 | n2 = new NodeSequence(2); | ||
1170 | n4 = jj_consume_token(59); | ||
1171 | n3 = JTBToolkit.makeNodeToken(n4); | ||
1172 | n2.addNode(n3); | ||
1173 | n5 = InitDeclarator(); | ||
1174 | n2.addNode(n5); | ||
1175 | n1.addNode(n2); | ||
1176 | } | ||
1177 | n1.nodes.trimToSize(); | ||
1178 | {if (true) return new InitDeclaratorList(n0,n1);} | ||
1179 | throw new Error("Missing return statement in function"); | ||
1180 | } | ||
1181 | |||
1182 | final public InitDeclarator InitDeclarator() throws ParseException { | ||
1183 | NodeToken n0; | ||
1184 | Token n1; | ||
1185 | NodeOptional n2 = new NodeOptional(); | ||
1186 | Array n3; | ||
1187 | NodeOptional n4 = new NodeOptional(); | ||
1188 | NodeSequence n5; | ||
1189 | NodeToken n6; | ||
1190 | Token n7; | ||
1191 | Initializer n8; | ||
1192 | n1 = jj_consume_token(IDENTIFIER); | ||
1193 | n0 = JTBToolkit.makeNodeToken(n1); | ||
1194 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1195 | case 65: | ||
1196 | n3 = Array(); | ||
1197 | n2.addNode(n3); | ||
1198 | break; | ||
1199 | default: | ||
1200 | jj_la1[39] = jj_gen; | ||
1201 | ; | ||
1202 | } | ||
1203 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1204 | case 63: | ||
1205 | n5 = new NodeSequence(2); | ||
1206 | n7 = jj_consume_token(63); | ||
1207 | n6 = JTBToolkit.makeNodeToken(n7); | ||
1208 | n5.addNode(n6); | ||
1209 | n8 = Initializer(); | ||
1210 | n5.addNode(n8); | ||
1211 | n4.addNode(n5); | ||
1212 | break; | ||
1213 | default: | ||
1214 | jj_la1[40] = jj_gen; | ||
1215 | ; | ||
1216 | } | ||
1217 | {if (true) return new InitDeclarator(n0,n2,n4);} | ||
1218 | throw new Error("Missing return statement in function"); | ||
1219 | } | ||
1220 | |||
1221 | final public StructDeclaration StructDeclaration() throws ParseException { | ||
1222 | TypeSpecifier n0; | ||
1223 | NodeToken n1; | ||
1224 | Token n2; | ||
1225 | NodeOptional n3 = new NodeOptional(); | ||
1226 | NodeChoice n4; | ||
1227 | Array n5; | ||
1228 | NodeSequence n6; | ||
1229 | NodeToken n7; | ||
1230 | Token n8; | ||
1231 | ConstantExpression n9; | ||
1232 | NodeOptional n10 = new NodeOptional(); | ||
1233 | NodeToken n11; | ||
1234 | Token n12; | ||
1235 | NodeToken n13; | ||
1236 | Token n14; | ||
1237 | n0 = TypeSpecifier(); | ||
1238 | n2 = jj_consume_token(IDENTIFIER); | ||
1239 | n1 = JTBToolkit.makeNodeToken(n2); | ||
1240 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1241 | case 64: | ||
1242 | case 65: | ||
1243 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1244 | case 65: | ||
1245 | n5 = Array(); | ||
1246 | n4 = new NodeChoice(n5, 0); | ||
1247 | break; | ||
1248 | case 64: | ||
1249 | n6 = new NodeSequence(2); | ||
1250 | n8 = jj_consume_token(64); | ||
1251 | n7 = JTBToolkit.makeNodeToken(n8); | ||
1252 | n6.addNode(n7); | ||
1253 | n9 = ConstantExpression(); | ||
1254 | n6.addNode(n9); | ||
1255 | n4 = new NodeChoice(n6, 1); | ||
1256 | break; | ||
1257 | default: | ||
1258 | jj_la1[41] = jj_gen; | ||
1259 | jj_consume_token(-1); | ||
1260 | throw new ParseException(); | ||
1261 | } | ||
1262 | n3.addNode(n4); | ||
1263 | break; | ||
1264 | default: | ||
1265 | jj_la1[42] = jj_gen; | ||
1266 | ; | ||
1267 | } | ||
1268 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1269 | case IDENTIFIER: | ||
1270 | n12 = jj_consume_token(IDENTIFIER); | ||
1271 | n11 = JTBToolkit.makeNodeToken(n12); | ||
1272 | n10.addNode(n11); | ||
1273 | break; | ||
1274 | default: | ||
1275 | jj_la1[43] = jj_gen; | ||
1276 | ; | ||
1277 | } | ||
1278 | n14 = jj_consume_token(57); | ||
1279 | n13 = JTBToolkit.makeNodeToken(n14); | ||
1280 | {if (true) return new StructDeclaration(n0,n1,n3,n10,n13);} | ||
1281 | throw new Error("Missing return statement in function"); | ||
1282 | } | ||
1283 | |||
1284 | final public EnumSpecifier EnumSpecifier() throws ParseException { | ||
1285 | NodeToken n0; | ||
1286 | Token n1; | ||
1287 | NodeChoice n2; | ||
1288 | NodeSequence n3; | ||
1289 | NodeOptional n4 = new NodeOptional(); | ||
1290 | NodeToken n5; | ||
1291 | Token n6; | ||
1292 | NodeToken n7; | ||
1293 | Token n8; | ||
1294 | EnumeratorList n9; | ||
1295 | NodeToken n10; | ||
1296 | Token n11; | ||
1297 | NodeToken n12; | ||
1298 | Token n13; | ||
1299 | n1 = jj_consume_token(ENUM); | ||
1300 | n0 = JTBToolkit.makeNodeToken(n1); | ||
1301 | if (jj_2_8(3)) { | ||
1302 | n3 = new NodeSequence(5); | ||
1303 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1304 | case IDENTIFIER: | ||
1305 | n6 = jj_consume_token(IDENTIFIER); | ||
1306 | n5 = JTBToolkit.makeNodeToken(n6); | ||
1307 | n4.addNode(n5); | ||
1308 | break; | ||
1309 | default: | ||
1310 | jj_la1[44] = jj_gen; | ||
1311 | ; | ||
1312 | } | ||
1313 | n3.addNode(n4); | ||
1314 | n8 = jj_consume_token(61); | ||
1315 | n7 = JTBToolkit.makeNodeToken(n8); | ||
1316 | n3.addNode(n7); | ||
1317 | n9 = EnumeratorList(); | ||
1318 | n3.addNode(n9); | ||
1319 | n11 = jj_consume_token(62); | ||
1320 | n10 = JTBToolkit.makeNodeToken(n11); | ||
1321 | n3.addNode(n10); | ||
1322 | n2 = new NodeChoice(n3, 0); | ||
1323 | } else { | ||
1324 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1325 | case IDENTIFIER: | ||
1326 | n13 = jj_consume_token(IDENTIFIER); | ||
1327 | n12 = JTBToolkit.makeNodeToken(n13); | ||
1328 | n2 = new NodeChoice(n12, 1); | ||
1329 | break; | ||
1330 | default: | ||
1331 | jj_la1[45] = jj_gen; | ||
1332 | jj_consume_token(-1); | ||
1333 | throw new ParseException(); | ||
1334 | } | ||
1335 | } | ||
1336 | {if (true) return new EnumSpecifier(n0,n2);} | ||
1337 | throw new Error("Missing return statement in function"); | ||
1338 | } | ||
1339 | |||
1340 | final public EnumeratorList EnumeratorList() throws ParseException { | ||
1341 | Enumerator n0; | ||
1342 | NodeListOptional n1 = new NodeListOptional(); | ||
1343 | NodeSequence n2; | ||
1344 | NodeToken n3; | ||
1345 | Token n4; | ||
1346 | Enumerator n5; | ||
1347 | n0 = Enumerator(); | ||
1348 | label_7: | ||
1349 | while (true) { | ||
1350 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1351 | case 59: | ||
1352 | ; | ||
1353 | break; | ||
1354 | default: | ||
1355 | jj_la1[46] = jj_gen; | ||
1356 | break label_7; | ||
1357 | } | ||
1358 | n2 = new NodeSequence(2); | ||
1359 | n4 = jj_consume_token(59); | ||
1360 | n3 = JTBToolkit.makeNodeToken(n4); | ||
1361 | n2.addNode(n3); | ||
1362 | n5 = Enumerator(); | ||
1363 | n2.addNode(n5); | ||
1364 | n1.addNode(n2); | ||
1365 | } | ||
1366 | n1.nodes.trimToSize(); | ||
1367 | {if (true) return new EnumeratorList(n0,n1);} | ||
1368 | throw new Error("Missing return statement in function"); | ||
1369 | } | ||
1370 | |||
1371 | final public Enumerator Enumerator() throws ParseException { | ||
1372 | NodeToken n0; | ||
1373 | Token n1; | ||
1374 | NodeOptional n2 = new NodeOptional(); | ||
1375 | NodeSequence n3; | ||
1376 | NodeToken n4; | ||
1377 | Token n5; | ||
1378 | ConstantExpression n6; | ||
1379 | n1 = jj_consume_token(IDENTIFIER); | ||
1380 | n0 = JTBToolkit.makeNodeToken(n1); | ||
1381 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1382 | case 63: | ||
1383 | n3 = new NodeSequence(2); | ||
1384 | n5 = jj_consume_token(63); | ||
1385 | n4 = JTBToolkit.makeNodeToken(n5); | ||
1386 | n3.addNode(n4); | ||
1387 | n6 = ConstantExpression(); | ||
1388 | n3.addNode(n6); | ||
1389 | n2.addNode(n3); | ||
1390 | break; | ||
1391 | default: | ||
1392 | jj_la1[47] = jj_gen; | ||
1393 | ; | ||
1394 | } | ||
1395 | {if (true) return new Enumerator(n0,n2);} | ||
1396 | throw new Error("Missing return statement in function"); | ||
1397 | } | ||
1398 | |||
1399 | final public Pointer Pointer() throws ParseException { | ||
1400 | NodeToken n0; | ||
1401 | Token n1; | ||
1402 | NodeOptional n2 = new NodeOptional(); | ||
1403 | NodeToken n3; | ||
1404 | Token n4; | ||
1405 | NodeOptional n5 = new NodeOptional(); | ||
1406 | Pointer n6; | ||
1407 | n1 = jj_consume_token(58); | ||
1408 | n0 = JTBToolkit.makeNodeToken(n1); | ||
1409 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1410 | case CONST: | ||
1411 | n4 = jj_consume_token(CONST); | ||
1412 | n3 = JTBToolkit.makeNodeToken(n4); | ||
1413 | n2.addNode(n3); | ||
1414 | break; | ||
1415 | default: | ||
1416 | jj_la1[48] = jj_gen; | ||
1417 | ; | ||
1418 | } | ||
1419 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1420 | case 58: | ||
1421 | n6 = Pointer(); | ||
1422 | n5.addNode(n6); | ||
1423 | break; | ||
1424 | default: | ||
1425 | jj_la1[49] = jj_gen; | ||
1426 | ; | ||
1427 | } | ||
1428 | {if (true) return new Pointer(n0,n2,n5);} | ||
1429 | throw new Error("Missing return statement in function"); | ||
1430 | } | ||
1431 | |||
1432 | final public IdentifierList IdentifierList() throws ParseException { | ||
1433 | NodeToken n0; | ||
1434 | Token n1; | ||
1435 | NodeListOptional n2 = new NodeListOptional(); | ||
1436 | NodeSequence n3; | ||
1437 | NodeToken n4; | ||
1438 | Token n5; | ||
1439 | NodeToken n6; | ||
1440 | Token n7; | ||
1441 | n1 = jj_consume_token(IDENTIFIER); | ||
1442 | n0 = JTBToolkit.makeNodeToken(n1); | ||
1443 | label_8: | ||
1444 | while (true) { | ||
1445 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1446 | case 59: | ||
1447 | ; | ||
1448 | break; | ||
1449 | default: | ||
1450 | jj_la1[50] = jj_gen; | ||
1451 | break label_8; | ||
1452 | } | ||
1453 | n3 = new NodeSequence(2); | ||
1454 | n5 = jj_consume_token(59); | ||
1455 | n4 = JTBToolkit.makeNodeToken(n5); | ||
1456 | n3.addNode(n4); | ||
1457 | n7 = jj_consume_token(IDENTIFIER); | ||
1458 | n6 = JTBToolkit.makeNodeToken(n7); | ||
1459 | n3.addNode(n6); | ||
1460 | n2.addNode(n3); | ||
1461 | } | ||
1462 | n2.nodes.trimToSize(); | ||
1463 | {if (true) return new IdentifierList(n0,n2);} | ||
1464 | throw new Error("Missing return statement in function"); | ||
1465 | } | ||
1466 | |||
1467 | final public Initializer Initializer() throws ParseException { | ||
1468 | NodeChoice n0; | ||
1469 | AssignmentExpression n1; | ||
1470 | NodeSequence n2; | ||
1471 | NodeToken n3; | ||
1472 | Token n4; | ||
1473 | InitializerList n5; | ||
1474 | NodeOptional n6 = new NodeOptional(); | ||
1475 | NodeToken n7; | ||
1476 | Token n8; | ||
1477 | NodeToken n9; | ||
1478 | Token n10; | ||
1479 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1480 | case INTEGER_LITERAL: | ||
1481 | case FLOATING_POINT_LITERAL: | ||
1482 | case CHARACTER_LITERAL: | ||
1483 | case STRING_LITERAL: | ||
1484 | case SIZEOF: | ||
1485 | case IDENTIFIER: | ||
1486 | case 55: | ||
1487 | case 58: | ||
1488 | case 82: | ||
1489 | case 91: | ||
1490 | case 92: | ||
1491 | case 95: | ||
1492 | case 96: | ||
1493 | case 97: | ||
1494 | case 98: | ||
1495 | n1 = AssignmentExpression(); | ||
1496 | n0 = new NodeChoice(n1, 0); | ||
1497 | break; | ||
1498 | case 61: | ||
1499 | n2 = new NodeSequence(4); | ||
1500 | n4 = jj_consume_token(61); | ||
1501 | n3 = JTBToolkit.makeNodeToken(n4); | ||
1502 | n2.addNode(n3); | ||
1503 | n5 = InitializerList(); | ||
1504 | n2.addNode(n5); | ||
1505 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1506 | case 59: | ||
1507 | n8 = jj_consume_token(59); | ||
1508 | n7 = JTBToolkit.makeNodeToken(n8); | ||
1509 | n6.addNode(n7); | ||
1510 | break; | ||
1511 | default: | ||
1512 | jj_la1[51] = jj_gen; | ||
1513 | ; | ||
1514 | } | ||
1515 | n2.addNode(n6); | ||
1516 | n10 = jj_consume_token(62); | ||
1517 | n9 = JTBToolkit.makeNodeToken(n10); | ||
1518 | n2.addNode(n9); | ||
1519 | n0 = new NodeChoice(n2, 1); | ||
1520 | break; | ||
1521 | default: | ||
1522 | jj_la1[52] = jj_gen; | ||
1523 | jj_consume_token(-1); | ||
1524 | throw new ParseException(); | ||
1525 | } | ||
1526 | {if (true) return new Initializer(n0);} | ||
1527 | throw new Error("Missing return statement in function"); | ||
1528 | } | ||
1529 | |||
1530 | final public InitializerList InitializerList() throws ParseException { | ||
1531 | Initializer n0; | ||
1532 | NodeListOptional n1 = new NodeListOptional(); | ||
1533 | NodeSequence n2; | ||
1534 | NodeToken n3; | ||
1535 | Token n4; | ||
1536 | Initializer n5; | ||
1537 | n0 = Initializer(); | ||
1538 | label_9: | ||
1539 | while (true) { | ||
1540 | if (jj_2_9(2)) { | ||
1541 | ; | ||
1542 | } else { | ||
1543 | break label_9; | ||
1544 | } | ||
1545 | n2 = new NodeSequence(2); | ||
1546 | n4 = jj_consume_token(59); | ||
1547 | n3 = JTBToolkit.makeNodeToken(n4); | ||
1548 | n2.addNode(n3); | ||
1549 | n5 = Initializer(); | ||
1550 | n2.addNode(n5); | ||
1551 | n1.addNode(n2); | ||
1552 | } | ||
1553 | n1.nodes.trimToSize(); | ||
1554 | {if (true) return new InitializerList(n0,n1);} | ||
1555 | throw new Error("Missing return statement in function"); | ||
1556 | } | ||
1557 | |||
1558 | final public Array Array() throws ParseException { | ||
1559 | NodeToken n0; | ||
1560 | Token n1; | ||
1561 | NodeOptional n2 = new NodeOptional(); | ||
1562 | ConstantExpression n3; | ||
1563 | NodeToken n4; | ||
1564 | Token n5; | ||
1565 | n1 = jj_consume_token(65); | ||
1566 | n0 = JTBToolkit.makeNodeToken(n1); | ||
1567 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1568 | case INTEGER_LITERAL: | ||
1569 | case FLOATING_POINT_LITERAL: | ||
1570 | case CHARACTER_LITERAL: | ||
1571 | case STRING_LITERAL: | ||
1572 | case SIZEOF: | ||
1573 | case IDENTIFIER: | ||
1574 | case 55: | ||
1575 | case 58: | ||
1576 | case 82: | ||
1577 | case 91: | ||
1578 | case 92: | ||
1579 | case 95: | ||
1580 | case 96: | ||
1581 | case 97: | ||
1582 | case 98: | ||
1583 | n3 = ConstantExpression(); | ||
1584 | n2.addNode(n3); | ||
1585 | break; | ||
1586 | default: | ||
1587 | jj_la1[53] = jj_gen; | ||
1588 | ; | ||
1589 | } | ||
1590 | n5 = jj_consume_token(66); | ||
1591 | n4 = JTBToolkit.makeNodeToken(n5); | ||
1592 | {if (true) return new Array(n0,n2,n4);} | ||
1593 | throw new Error("Missing return statement in function"); | ||
1594 | } | ||
1595 | |||
1596 | final public Statement Statement() throws ParseException { | ||
1597 | NodeChoice n0; | ||
1598 | LabeledStatement n1; | ||
1599 | ExpressionStatement n2; | ||
1600 | CompoundStatement n3; | ||
1601 | SelectionStatement n4; | ||
1602 | IterationStatement n5; | ||
1603 | JumpStatement n6; | ||
1604 | if (jj_2_10(2)) { | ||
1605 | n1 = LabeledStatement(); | ||
1606 | n0 = new NodeChoice(n1, 0); | ||
1607 | } else { | ||
1608 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1609 | case INTEGER_LITERAL: | ||
1610 | case FLOATING_POINT_LITERAL: | ||
1611 | case CHARACTER_LITERAL: | ||
1612 | case STRING_LITERAL: | ||
1613 | case SIZEOF: | ||
1614 | case IDENTIFIER: | ||
1615 | case 55: | ||
1616 | case 57: | ||
1617 | case 58: | ||
1618 | case 82: | ||
1619 | case 91: | ||
1620 | case 92: | ||
1621 | case 95: | ||
1622 | case 96: | ||
1623 | case 97: | ||
1624 | case 98: | ||
1625 | n2 = ExpressionStatement(); | ||
1626 | n0 = new NodeChoice(n2, 1); | ||
1627 | break; | ||
1628 | case 61: | ||
1629 | n3 = CompoundStatement(); | ||
1630 | n0 = new NodeChoice(n3, 2); | ||
1631 | break; | ||
1632 | case SWITCH: | ||
1633 | case IF: | ||
1634 | n4 = SelectionStatement(); | ||
1635 | n0 = new NodeChoice(n4, 3); | ||
1636 | break; | ||
1637 | case WHILE: | ||
1638 | case FOR: | ||
1639 | case DO: | ||
1640 | n5 = IterationStatement(); | ||
1641 | n0 = new NodeChoice(n5, 4); | ||
1642 | break; | ||
1643 | case CONTINUE: | ||
1644 | case RETURN: | ||
1645 | case BREAK: | ||
1646 | case GOTO: | ||
1647 | n6 = JumpStatement(); | ||
1648 | n0 = new NodeChoice(n6, 5); | ||
1649 | break; | ||
1650 | default: | ||
1651 | jj_la1[54] = jj_gen; | ||
1652 | jj_consume_token(-1); | ||
1653 | throw new ParseException(); | ||
1654 | } | ||
1655 | } | ||
1656 | {if (true) return new Statement(n0);} | ||
1657 | throw new Error("Missing return statement in function"); | ||
1658 | } | ||
1659 | |||
1660 | final public LabeledStatement LabeledStatement() throws ParseException { | ||
1661 | NodeChoice n0; | ||
1662 | NodeSequence n1; | ||
1663 | NodeToken n2; | ||
1664 | Token n3; | ||
1665 | NodeToken n4; | ||
1666 | Token n5; | ||
1667 | Statement n6; | ||
1668 | NodeSequence n7; | ||
1669 | NodeToken n8; | ||
1670 | Token n9; | ||
1671 | ConstantExpression n10; | ||
1672 | NodeToken n11; | ||
1673 | Token n12; | ||
1674 | Statement n13; | ||
1675 | NodeSequence n14; | ||
1676 | NodeToken n15; | ||
1677 | Token n16; | ||
1678 | NodeToken n17; | ||
1679 | Token n18; | ||
1680 | Statement n19; | ||
1681 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1682 | case IDENTIFIER: | ||
1683 | n1 = new NodeSequence(3); | ||
1684 | n3 = jj_consume_token(IDENTIFIER); | ||
1685 | n2 = JTBToolkit.makeNodeToken(n3); | ||
1686 | n1.addNode(n2); | ||
1687 | n5 = jj_consume_token(64); | ||
1688 | n4 = JTBToolkit.makeNodeToken(n5); | ||
1689 | n1.addNode(n4); | ||
1690 | n6 = Statement(); | ||
1691 | n1.addNode(n6); | ||
1692 | n0 = new NodeChoice(n1, 0); | ||
1693 | break; | ||
1694 | case CASE: | ||
1695 | n7 = new NodeSequence(4); | ||
1696 | n9 = jj_consume_token(CASE); | ||
1697 | n8 = JTBToolkit.makeNodeToken(n9); | ||
1698 | n7.addNode(n8); | ||
1699 | n10 = ConstantExpression(); | ||
1700 | n7.addNode(n10); | ||
1701 | n12 = jj_consume_token(64); | ||
1702 | n11 = JTBToolkit.makeNodeToken(n12); | ||
1703 | n7.addNode(n11); | ||
1704 | n13 = Statement(); | ||
1705 | n7.addNode(n13); | ||
1706 | n0 = new NodeChoice(n7, 1); | ||
1707 | break; | ||
1708 | case DFLT: | ||
1709 | n14 = new NodeSequence(3); | ||
1710 | n16 = jj_consume_token(DFLT); | ||
1711 | n15 = JTBToolkit.makeNodeToken(n16); | ||
1712 | n14.addNode(n15); | ||
1713 | n18 = jj_consume_token(64); | ||
1714 | n17 = JTBToolkit.makeNodeToken(n18); | ||
1715 | n14.addNode(n17); | ||
1716 | n19 = Statement(); | ||
1717 | n14.addNode(n19); | ||
1718 | n0 = new NodeChoice(n14, 2); | ||
1719 | break; | ||
1720 | default: | ||
1721 | jj_la1[55] = jj_gen; | ||
1722 | jj_consume_token(-1); | ||
1723 | throw new ParseException(); | ||
1724 | } | ||
1725 | {if (true) return new LabeledStatement(n0);} | ||
1726 | throw new Error("Missing return statement in function"); | ||
1727 | } | ||
1728 | |||
1729 | final public ExpressionStatement ExpressionStatement() throws ParseException { | ||
1730 | NodeOptional n0 = new NodeOptional(); | ||
1731 | Expression n1; | ||
1732 | NodeToken n2; | ||
1733 | Token n3; | ||
1734 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1735 | case INTEGER_LITERAL: | ||
1736 | case FLOATING_POINT_LITERAL: | ||
1737 | case CHARACTER_LITERAL: | ||
1738 | case STRING_LITERAL: | ||
1739 | case SIZEOF: | ||
1740 | case IDENTIFIER: | ||
1741 | case 55: | ||
1742 | case 58: | ||
1743 | case 82: | ||
1744 | case 91: | ||
1745 | case 92: | ||
1746 | case 95: | ||
1747 | case 96: | ||
1748 | case 97: | ||
1749 | case 98: | ||
1750 | n1 = Expression(); | ||
1751 | n0.addNode(n1); | ||
1752 | break; | ||
1753 | default: | ||
1754 | jj_la1[56] = jj_gen; | ||
1755 | ; | ||
1756 | } | ||
1757 | n3 = jj_consume_token(57); | ||
1758 | n2 = JTBToolkit.makeNodeToken(n3); | ||
1759 | {if (true) return new ExpressionStatement(n0,n2);} | ||
1760 | throw new Error("Missing return statement in function"); | ||
1761 | } | ||
1762 | |||
1763 | final public CompoundStatement CompoundStatement() throws ParseException { | ||
1764 | NodeToken n0; | ||
1765 | Token n1; | ||
1766 | NodeListOptional n2 = new NodeListOptional(); | ||
1767 | NodeChoice n3; | ||
1768 | LocalVariableDeclaration n4; | ||
1769 | Statement n5; | ||
1770 | NodeToken n6; | ||
1771 | Token n7; | ||
1772 | n1 = jj_consume_token(61); | ||
1773 | n0 = JTBToolkit.makeNodeToken(n1); | ||
1774 | label_10: | ||
1775 | while (true) { | ||
1776 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1777 | case INTEGER_LITERAL: | ||
1778 | case FLOATING_POINT_LITERAL: | ||
1779 | case CHARACTER_LITERAL: | ||
1780 | case STRING_LITERAL: | ||
1781 | case CONTINUE: | ||
1782 | case REGISTER: | ||
1783 | case UNSIGNED: | ||
1784 | case DFLT: | ||
1785 | case DOUBLE: | ||
1786 | case SIZEOF: | ||
1787 | case SWITCH: | ||
1788 | case RETURN: | ||
1789 | case STRUCT: | ||
1790 | case STATIC: | ||
1791 | case SIGNED: | ||
1792 | case WHILE: | ||
1793 | case BREAK: | ||
1794 | case UNION: | ||
1795 | case CONST: | ||
1796 | case FLOAT: | ||
1797 | case SHORT: | ||
1798 | case CASE: | ||
1799 | case LONG: | ||
1800 | case ENUM: | ||
1801 | case AUTO: | ||
1802 | case VOID: | ||
1803 | case CHAR: | ||
1804 | case GOTO: | ||
1805 | case FOR: | ||
1806 | case INT: | ||
1807 | case IF: | ||
1808 | case DO: | ||
1809 | case IDENTIFIER: | ||
1810 | case 55: | ||
1811 | case 57: | ||
1812 | case 58: | ||
1813 | case 61: | ||
1814 | case 82: | ||
1815 | case 91: | ||
1816 | case 92: | ||
1817 | case 95: | ||
1818 | case 96: | ||
1819 | case 97: | ||
1820 | case 98: | ||
1821 | ; | ||
1822 | break; | ||
1823 | default: | ||
1824 | jj_la1[57] = jj_gen; | ||
1825 | break label_10; | ||
1826 | } | ||
1827 | if (jj_2_11(2147483647)) { | ||
1828 | n4 = LocalVariableDeclaration(); | ||
1829 | n3 = new NodeChoice(n4, 0); | ||
1830 | } else { | ||
1831 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1832 | case INTEGER_LITERAL: | ||
1833 | case FLOATING_POINT_LITERAL: | ||
1834 | case CHARACTER_LITERAL: | ||
1835 | case STRING_LITERAL: | ||
1836 | case CONTINUE: | ||
1837 | case DFLT: | ||
1838 | case SIZEOF: | ||
1839 | case SWITCH: | ||
1840 | case RETURN: | ||
1841 | case WHILE: | ||
1842 | case BREAK: | ||
1843 | case CASE: | ||
1844 | case GOTO: | ||
1845 | case FOR: | ||
1846 | case IF: | ||
1847 | case DO: | ||
1848 | case IDENTIFIER: | ||
1849 | case 55: | ||
1850 | case 57: | ||
1851 | case 58: | ||
1852 | case 61: | ||
1853 | case 82: | ||
1854 | case 91: | ||
1855 | case 92: | ||
1856 | case 95: | ||
1857 | case 96: | ||
1858 | case 97: | ||
1859 | case 98: | ||
1860 | n5 = Statement(); | ||
1861 | n3 = new NodeChoice(n5, 1); | ||
1862 | break; | ||
1863 | default: | ||
1864 | jj_la1[58] = jj_gen; | ||
1865 | jj_consume_token(-1); | ||
1866 | throw new ParseException(); | ||
1867 | } | ||
1868 | } | ||
1869 | n2.addNode(n3); | ||
1870 | } | ||
1871 | n2.nodes.trimToSize(); | ||
1872 | n7 = jj_consume_token(62); | ||
1873 | n6 = JTBToolkit.makeNodeToken(n7); | ||
1874 | {if (true) return new CompoundStatement(n0,n2,n6);} | ||
1875 | throw new Error("Missing return statement in function"); | ||
1876 | } | ||
1877 | |||
1878 | final public SelectionStatement SelectionStatement() throws ParseException { | ||
1879 | NodeChoice n0; | ||
1880 | NodeSequence n1; | ||
1881 | NodeToken n2; | ||
1882 | Token n3; | ||
1883 | NodeToken n4; | ||
1884 | Token n5; | ||
1885 | Expression n6; | ||
1886 | NodeToken n7; | ||
1887 | Token n8; | ||
1888 | Statement n9; | ||
1889 | NodeOptional n10 = new NodeOptional(); | ||
1890 | NodeSequence n11; | ||
1891 | NodeToken n12; | ||
1892 | Token n13; | ||
1893 | Statement n14; | ||
1894 | NodeSequence n15; | ||
1895 | NodeToken n16; | ||
1896 | Token n17; | ||
1897 | NodeToken n18; | ||
1898 | Token n19; | ||
1899 | Expression n20; | ||
1900 | NodeToken n21; | ||
1901 | Token n22; | ||
1902 | Statement n23; | ||
1903 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
1904 | case IF: | ||
1905 | n1 = new NodeSequence(6); | ||
1906 | n3 = jj_consume_token(IF); | ||
1907 | n2 = JTBToolkit.makeNodeToken(n3); | ||
1908 | n1.addNode(n2); | ||
1909 | n5 = jj_consume_token(55); | ||
1910 | n4 = JTBToolkit.makeNodeToken(n5); | ||
1911 | n1.addNode(n4); | ||
1912 | n6 = Expression(); | ||
1913 | n1.addNode(n6); | ||
1914 | n8 = jj_consume_token(56); | ||
1915 | n7 = JTBToolkit.makeNodeToken(n8); | ||
1916 | n1.addNode(n7); | ||
1917 | n9 = Statement(); | ||
1918 | n1.addNode(n9); | ||
1919 | if (jj_2_12(2)) { | ||
1920 | n11 = new NodeSequence(2); | ||
1921 | n13 = jj_consume_token(ELSE); | ||
1922 | n12 = JTBToolkit.makeNodeToken(n13); | ||
1923 | n11.addNode(n12); | ||
1924 | n14 = Statement(); | ||
1925 | n11.addNode(n14); | ||
1926 | n10.addNode(n11); | ||
1927 | } else { | ||
1928 | ; | ||
1929 | } | ||
1930 | n1.addNode(n10); | ||
1931 | n0 = new NodeChoice(n1, 0); | ||
1932 | break; | ||
1933 | case SWITCH: | ||
1934 | n15 = new NodeSequence(5); | ||
1935 | n17 = jj_consume_token(SWITCH); | ||
1936 | n16 = JTBToolkit.makeNodeToken(n17); | ||
1937 | n15.addNode(n16); | ||
1938 | n19 = jj_consume_token(55); | ||
1939 | n18 = JTBToolkit.makeNodeToken(n19); | ||
1940 | n15.addNode(n18); | ||
1941 | n20 = Expression(); | ||
1942 | n15.addNode(n20); | ||
1943 | n22 = jj_consume_token(56); | ||
1944 | n21 = JTBToolkit.makeNodeToken(n22); | ||
1945 | n15.addNode(n21); | ||
1946 | n23 = Statement(); | ||
1947 | n15.addNode(n23); | ||
1948 | n0 = new NodeChoice(n15, 1); | ||
1949 | break; | ||
1950 | default: | ||
1951 | jj_la1[59] = jj_gen; | ||
1952 | jj_consume_token(-1); | ||
1953 | throw new ParseException(); | ||
1954 | } | ||
1955 | {if (true) return new SelectionStatement(n0);} | ||
1956 | throw new Error("Missing return statement in function"); | ||
1957 | } | ||
1958 | |||
1959 | final public IterationStatement IterationStatement() throws ParseException { | ||
1960 | NodeChoice n0; | ||
1961 | NodeSequence n1; | ||
1962 | NodeToken n2; | ||
1963 | Token n3; | ||
1964 | NodeToken n4; | ||
1965 | Token n5; | ||
1966 | Expression n6; | ||
1967 | NodeToken n7; | ||
1968 | Token n8; | ||
1969 | Statement n9; | ||
1970 | NodeSequence n10; | ||
1971 | NodeToken n11; | ||
1972 | Token n12; | ||
1973 | Statement n13; | ||
1974 | NodeToken n14; | ||
1975 | Token n15; | ||
1976 | NodeToken n16; | ||
1977 | Token n17; | ||
1978 | Expression n18; | ||
1979 | NodeToken n19; | ||
1980 | Token n20; | ||
1981 | NodeToken n21; | ||
1982 | Token n22; | ||
1983 | NodeSequence n23; | ||
1984 | NodeToken n24; | ||
1985 | Token n25; | ||
1986 | NodeToken n26; | ||
1987 | Token n27; | ||
1988 | NodeOptional n28 = new NodeOptional(); | ||
1989 | Expression n29; | ||
1990 | NodeToken n30; | ||
1991 | Token n31; | ||
1992 | NodeOptional n32 = new NodeOptional(); | ||
1993 | Expression n33; | ||
1994 | NodeToken n34; | ||
1995 | Token n35; | ||
1996 | NodeOptional n36 = new NodeOptional(); | ||
1997 | Expression n37; | ||
1998 | NodeToken n38; | ||
1999 | Token n39; | ||
2000 | Statement n40; | ||
2001 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2002 | case WHILE: | ||
2003 | n1 = new NodeSequence(5); | ||
2004 | n3 = jj_consume_token(WHILE); | ||
2005 | n2 = JTBToolkit.makeNodeToken(n3); | ||
2006 | n1.addNode(n2); | ||
2007 | n5 = jj_consume_token(55); | ||
2008 | n4 = JTBToolkit.makeNodeToken(n5); | ||
2009 | n1.addNode(n4); | ||
2010 | n6 = Expression(); | ||
2011 | n1.addNode(n6); | ||
2012 | n8 = jj_consume_token(56); | ||
2013 | n7 = JTBToolkit.makeNodeToken(n8); | ||
2014 | n1.addNode(n7); | ||
2015 | n9 = Statement(); | ||
2016 | n1.addNode(n9); | ||
2017 | n0 = new NodeChoice(n1, 0); | ||
2018 | break; | ||
2019 | case DO: | ||
2020 | n10 = new NodeSequence(7); | ||
2021 | n12 = jj_consume_token(DO); | ||
2022 | n11 = JTBToolkit.makeNodeToken(n12); | ||
2023 | n10.addNode(n11); | ||
2024 | n13 = Statement(); | ||
2025 | n10.addNode(n13); | ||
2026 | n15 = jj_consume_token(WHILE); | ||
2027 | n14 = JTBToolkit.makeNodeToken(n15); | ||
2028 | n10.addNode(n14); | ||
2029 | n17 = jj_consume_token(55); | ||
2030 | n16 = JTBToolkit.makeNodeToken(n17); | ||
2031 | n10.addNode(n16); | ||
2032 | n18 = Expression(); | ||
2033 | n10.addNode(n18); | ||
2034 | n20 = jj_consume_token(56); | ||
2035 | n19 = JTBToolkit.makeNodeToken(n20); | ||
2036 | n10.addNode(n19); | ||
2037 | n22 = jj_consume_token(57); | ||
2038 | n21 = JTBToolkit.makeNodeToken(n22); | ||
2039 | n10.addNode(n21); | ||
2040 | n0 = new NodeChoice(n10, 1); | ||
2041 | break; | ||
2042 | case FOR: | ||
2043 | n23 = new NodeSequence(9); | ||
2044 | n25 = jj_consume_token(FOR); | ||
2045 | n24 = JTBToolkit.makeNodeToken(n25); | ||
2046 | n23.addNode(n24); | ||
2047 | n27 = jj_consume_token(55); | ||
2048 | n26 = JTBToolkit.makeNodeToken(n27); | ||
2049 | n23.addNode(n26); | ||
2050 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2051 | case INTEGER_LITERAL: | ||
2052 | case FLOATING_POINT_LITERAL: | ||
2053 | case CHARACTER_LITERAL: | ||
2054 | case STRING_LITERAL: | ||
2055 | case SIZEOF: | ||
2056 | case IDENTIFIER: | ||
2057 | case 55: | ||
2058 | case 58: | ||
2059 | case 82: | ||
2060 | case 91: | ||
2061 | case 92: | ||
2062 | case 95: | ||
2063 | case 96: | ||
2064 | case 97: | ||
2065 | case 98: | ||
2066 | n29 = Expression(); | ||
2067 | n28.addNode(n29); | ||
2068 | break; | ||
2069 | default: | ||
2070 | jj_la1[60] = jj_gen; | ||
2071 | ; | ||
2072 | } | ||
2073 | n23.addNode(n28); | ||
2074 | n31 = jj_consume_token(57); | ||
2075 | n30 = JTBToolkit.makeNodeToken(n31); | ||
2076 | n23.addNode(n30); | ||
2077 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2078 | case INTEGER_LITERAL: | ||
2079 | case FLOATING_POINT_LITERAL: | ||
2080 | case CHARACTER_LITERAL: | ||
2081 | case STRING_LITERAL: | ||
2082 | case SIZEOF: | ||
2083 | case IDENTIFIER: | ||
2084 | case 55: | ||
2085 | case 58: | ||
2086 | case 82: | ||
2087 | case 91: | ||
2088 | case 92: | ||
2089 | case 95: | ||
2090 | case 96: | ||
2091 | case 97: | ||
2092 | case 98: | ||
2093 | n33 = Expression(); | ||
2094 | n32.addNode(n33); | ||
2095 | break; | ||
2096 | default: | ||
2097 | jj_la1[61] = jj_gen; | ||
2098 | ; | ||
2099 | } | ||
2100 | n23.addNode(n32); | ||
2101 | n35 = jj_consume_token(57); | ||
2102 | n34 = JTBToolkit.makeNodeToken(n35); | ||
2103 | n23.addNode(n34); | ||
2104 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2105 | case INTEGER_LITERAL: | ||
2106 | case FLOATING_POINT_LITERAL: | ||
2107 | case CHARACTER_LITERAL: | ||
2108 | case STRING_LITERAL: | ||
2109 | case SIZEOF: | ||
2110 | case IDENTIFIER: | ||
2111 | case 55: | ||
2112 | case 58: | ||
2113 | case 82: | ||
2114 | case 91: | ||
2115 | case 92: | ||
2116 | case 95: | ||
2117 | case 96: | ||
2118 | case 97: | ||
2119 | case 98: | ||
2120 | n37 = Expression(); | ||
2121 | n36.addNode(n37); | ||
2122 | break; | ||
2123 | default: | ||
2124 | jj_la1[62] = jj_gen; | ||
2125 | ; | ||
2126 | } | ||
2127 | n23.addNode(n36); | ||
2128 | n39 = jj_consume_token(56); | ||
2129 | n38 = JTBToolkit.makeNodeToken(n39); | ||
2130 | n23.addNode(n38); | ||
2131 | n40 = Statement(); | ||
2132 | n23.addNode(n40); | ||
2133 | n0 = new NodeChoice(n23, 2); | ||
2134 | break; | ||
2135 | default: | ||
2136 | jj_la1[63] = jj_gen; | ||
2137 | jj_consume_token(-1); | ||
2138 | throw new ParseException(); | ||
2139 | } | ||
2140 | {if (true) return new IterationStatement(n0);} | ||
2141 | throw new Error("Missing return statement in function"); | ||
2142 | } | ||
2143 | |||
2144 | final public JumpStatement JumpStatement() throws ParseException { | ||
2145 | NodeChoice n0; | ||
2146 | NodeSequence n1; | ||
2147 | NodeToken n2; | ||
2148 | Token n3; | ||
2149 | NodeToken n4; | ||
2150 | Token n5; | ||
2151 | NodeToken n6; | ||
2152 | Token n7; | ||
2153 | NodeSequence n8; | ||
2154 | NodeToken n9; | ||
2155 | Token n10; | ||
2156 | NodeToken n11; | ||
2157 | Token n12; | ||
2158 | NodeSequence n13; | ||
2159 | NodeToken n14; | ||
2160 | Token n15; | ||
2161 | NodeToken n16; | ||
2162 | Token n17; | ||
2163 | NodeSequence n18; | ||
2164 | NodeToken n19; | ||
2165 | Token n20; | ||
2166 | NodeOptional n21 = new NodeOptional(); | ||
2167 | Expression n22; | ||
2168 | NodeToken n23; | ||
2169 | Token n24; | ||
2170 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2171 | case GOTO: | ||
2172 | n1 = new NodeSequence(3); | ||
2173 | n3 = jj_consume_token(GOTO); | ||
2174 | n2 = JTBToolkit.makeNodeToken(n3); | ||
2175 | n1.addNode(n2); | ||
2176 | n5 = jj_consume_token(IDENTIFIER); | ||
2177 | n4 = JTBToolkit.makeNodeToken(n5); | ||
2178 | n1.addNode(n4); | ||
2179 | n7 = jj_consume_token(57); | ||
2180 | n6 = JTBToolkit.makeNodeToken(n7); | ||
2181 | n1.addNode(n6); | ||
2182 | n0 = new NodeChoice(n1, 0); | ||
2183 | break; | ||
2184 | case CONTINUE: | ||
2185 | n8 = new NodeSequence(2); | ||
2186 | n10 = jj_consume_token(CONTINUE); | ||
2187 | n9 = JTBToolkit.makeNodeToken(n10); | ||
2188 | n8.addNode(n9); | ||
2189 | n12 = jj_consume_token(57); | ||
2190 | n11 = JTBToolkit.makeNodeToken(n12); | ||
2191 | n8.addNode(n11); | ||
2192 | n0 = new NodeChoice(n8, 1); | ||
2193 | break; | ||
2194 | case BREAK: | ||
2195 | n13 = new NodeSequence(2); | ||
2196 | n15 = jj_consume_token(BREAK); | ||
2197 | n14 = JTBToolkit.makeNodeToken(n15); | ||
2198 | n13.addNode(n14); | ||
2199 | n17 = jj_consume_token(57); | ||
2200 | n16 = JTBToolkit.makeNodeToken(n17); | ||
2201 | n13.addNode(n16); | ||
2202 | n0 = new NodeChoice(n13, 2); | ||
2203 | break; | ||
2204 | case RETURN: | ||
2205 | n18 = new NodeSequence(3); | ||
2206 | n20 = jj_consume_token(RETURN); | ||
2207 | n19 = JTBToolkit.makeNodeToken(n20); | ||
2208 | n18.addNode(n19); | ||
2209 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2210 | case INTEGER_LITERAL: | ||
2211 | case FLOATING_POINT_LITERAL: | ||
2212 | case CHARACTER_LITERAL: | ||
2213 | case STRING_LITERAL: | ||
2214 | case SIZEOF: | ||
2215 | case IDENTIFIER: | ||
2216 | case 55: | ||
2217 | case 58: | ||
2218 | case 82: | ||
2219 | case 91: | ||
2220 | case 92: | ||
2221 | case 95: | ||
2222 | case 96: | ||
2223 | case 97: | ||
2224 | case 98: | ||
2225 | n22 = Expression(); | ||
2226 | n21.addNode(n22); | ||
2227 | break; | ||
2228 | default: | ||
2229 | jj_la1[64] = jj_gen; | ||
2230 | ; | ||
2231 | } | ||
2232 | n18.addNode(n21); | ||
2233 | n24 = jj_consume_token(57); | ||
2234 | n23 = JTBToolkit.makeNodeToken(n24); | ||
2235 | n18.addNode(n23); | ||
2236 | n0 = new NodeChoice(n18, 3); | ||
2237 | break; | ||
2238 | default: | ||
2239 | jj_la1[65] = jj_gen; | ||
2240 | jj_consume_token(-1); | ||
2241 | throw new ParseException(); | ||
2242 | } | ||
2243 | {if (true) return new JumpStatement(n0);} | ||
2244 | throw new Error("Missing return statement in function"); | ||
2245 | } | ||
2246 | |||
2247 | final public Expression Expression() throws ParseException { | ||
2248 | AssignmentExpression n0; | ||
2249 | NodeListOptional n1 = new NodeListOptional(); | ||
2250 | NodeSequence n2; | ||
2251 | NodeToken n3; | ||
2252 | Token n4; | ||
2253 | AssignmentExpression n5; | ||
2254 | n0 = AssignmentExpression(); | ||
2255 | label_11: | ||
2256 | while (true) { | ||
2257 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2258 | case 59: | ||
2259 | ; | ||
2260 | break; | ||
2261 | default: | ||
2262 | jj_la1[66] = jj_gen; | ||
2263 | break label_11; | ||
2264 | } | ||
2265 | n2 = new NodeSequence(2); | ||
2266 | n4 = jj_consume_token(59); | ||
2267 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2268 | n2.addNode(n3); | ||
2269 | n5 = AssignmentExpression(); | ||
2270 | n2.addNode(n5); | ||
2271 | n1.addNode(n2); | ||
2272 | } | ||
2273 | n1.nodes.trimToSize(); | ||
2274 | {if (true) return new Expression(n0,n1);} | ||
2275 | throw new Error("Missing return statement in function"); | ||
2276 | } | ||
2277 | |||
2278 | final public AssignmentExpression AssignmentExpression() throws ParseException { | ||
2279 | NodeChoice n0; | ||
2280 | NodeSequence n1; | ||
2281 | UnaryExpression n2; | ||
2282 | AssignmentOperator n3; | ||
2283 | AssignmentExpression n4; | ||
2284 | ConditionalExpression n5; | ||
2285 | if (jj_2_13(2147483647)) { | ||
2286 | n1 = new NodeSequence(4); | ||
2287 | n2 = UnaryExpression(); | ||
2288 | n1.addNode(n2); | ||
2289 | n3 = AssignmentOperator(); | ||
2290 | n1.addNode(n3); | ||
2291 | n4 = AssignmentExpression(); | ||
2292 | n1.addNode(n4); | ||
2293 | n0 = new NodeChoice(n1, 0); | ||
2294 | } else if (jj_2_14(3)) { | ||
2295 | n5 = ConditionalExpression(); | ||
2296 | n0 = new NodeChoice(n5, 1); | ||
2297 | } else { | ||
2298 | jj_consume_token(-1); | ||
2299 | throw new ParseException(); | ||
2300 | } | ||
2301 | {if (true) return new AssignmentExpression(n0);} | ||
2302 | throw new Error("Missing return statement in function"); | ||
2303 | } | ||
2304 | |||
2305 | final public AssignmentOperator AssignmentOperator() throws ParseException { | ||
2306 | NodeChoice n0; | ||
2307 | NodeToken n1; | ||
2308 | Token n2; | ||
2309 | NodeToken n3; | ||
2310 | Token n4; | ||
2311 | NodeToken n5; | ||
2312 | Token n6; | ||
2313 | NodeToken n7; | ||
2314 | Token n8; | ||
2315 | NodeToken n9; | ||
2316 | Token n10; | ||
2317 | NodeToken n11; | ||
2318 | Token n12; | ||
2319 | NodeToken n13; | ||
2320 | Token n14; | ||
2321 | NodeToken n15; | ||
2322 | Token n16; | ||
2323 | NodeToken n17; | ||
2324 | Token n18; | ||
2325 | NodeToken n19; | ||
2326 | Token n20; | ||
2327 | NodeToken n21; | ||
2328 | Token n22; | ||
2329 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2330 | case 63: | ||
2331 | n2 = jj_consume_token(63); | ||
2332 | n1 = JTBToolkit.makeNodeToken(n2); | ||
2333 | n0 = new NodeChoice(n1, 0); | ||
2334 | break; | ||
2335 | case 67: | ||
2336 | n4 = jj_consume_token(67); | ||
2337 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2338 | n0 = new NodeChoice(n3, 1); | ||
2339 | break; | ||
2340 | case 68: | ||
2341 | n6 = jj_consume_token(68); | ||
2342 | n5 = JTBToolkit.makeNodeToken(n6); | ||
2343 | n0 = new NodeChoice(n5, 2); | ||
2344 | break; | ||
2345 | case 69: | ||
2346 | n8 = jj_consume_token(69); | ||
2347 | n7 = JTBToolkit.makeNodeToken(n8); | ||
2348 | n0 = new NodeChoice(n7, 3); | ||
2349 | break; | ||
2350 | case 70: | ||
2351 | n10 = jj_consume_token(70); | ||
2352 | n9 = JTBToolkit.makeNodeToken(n10); | ||
2353 | n0 = new NodeChoice(n9, 4); | ||
2354 | break; | ||
2355 | case 71: | ||
2356 | n12 = jj_consume_token(71); | ||
2357 | n11 = JTBToolkit.makeNodeToken(n12); | ||
2358 | n0 = new NodeChoice(n11, 5); | ||
2359 | break; | ||
2360 | case 72: | ||
2361 | n14 = jj_consume_token(72); | ||
2362 | n13 = JTBToolkit.makeNodeToken(n14); | ||
2363 | n0 = new NodeChoice(n13, 6); | ||
2364 | break; | ||
2365 | case 73: | ||
2366 | n16 = jj_consume_token(73); | ||
2367 | n15 = JTBToolkit.makeNodeToken(n16); | ||
2368 | n0 = new NodeChoice(n15, 7); | ||
2369 | break; | ||
2370 | case 74: | ||
2371 | n18 = jj_consume_token(74); | ||
2372 | n17 = JTBToolkit.makeNodeToken(n18); | ||
2373 | n0 = new NodeChoice(n17, 8); | ||
2374 | break; | ||
2375 | case 75: | ||
2376 | n20 = jj_consume_token(75); | ||
2377 | n19 = JTBToolkit.makeNodeToken(n20); | ||
2378 | n0 = new NodeChoice(n19, 9); | ||
2379 | break; | ||
2380 | case 76: | ||
2381 | n22 = jj_consume_token(76); | ||
2382 | n21 = JTBToolkit.makeNodeToken(n22); | ||
2383 | n0 = new NodeChoice(n21, 10); | ||
2384 | break; | ||
2385 | default: | ||
2386 | jj_la1[67] = jj_gen; | ||
2387 | jj_consume_token(-1); | ||
2388 | throw new ParseException(); | ||
2389 | } | ||
2390 | {if (true) return new AssignmentOperator(n0);} | ||
2391 | throw new Error("Missing return statement in function"); | ||
2392 | } | ||
2393 | |||
2394 | final public ConditionalExpression ConditionalExpression() throws ParseException { | ||
2395 | LogicalORExpression n0; | ||
2396 | NodeOptional n1 = new NodeOptional(); | ||
2397 | NodeSequence n2; | ||
2398 | NodeToken n3; | ||
2399 | Token n4; | ||
2400 | Expression n5; | ||
2401 | NodeToken n6; | ||
2402 | Token n7; | ||
2403 | ConditionalExpression n8; | ||
2404 | n0 = LogicalORExpression(); | ||
2405 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2406 | case 77: | ||
2407 | n2 = new NodeSequence(4); | ||
2408 | n4 = jj_consume_token(77); | ||
2409 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2410 | n2.addNode(n3); | ||
2411 | n5 = Expression(); | ||
2412 | n2.addNode(n5); | ||
2413 | n7 = jj_consume_token(64); | ||
2414 | n6 = JTBToolkit.makeNodeToken(n7); | ||
2415 | n2.addNode(n6); | ||
2416 | n8 = ConditionalExpression(); | ||
2417 | n2.addNode(n8); | ||
2418 | n1.addNode(n2); | ||
2419 | break; | ||
2420 | default: | ||
2421 | jj_la1[68] = jj_gen; | ||
2422 | ; | ||
2423 | } | ||
2424 | {if (true) return new ConditionalExpression(n0,n1);} | ||
2425 | throw new Error("Missing return statement in function"); | ||
2426 | } | ||
2427 | |||
2428 | final public ConstantExpression ConstantExpression() throws ParseException { | ||
2429 | ConditionalExpression n0; | ||
2430 | n0 = ConditionalExpression(); | ||
2431 | {if (true) return new ConstantExpression(n0);} | ||
2432 | throw new Error("Missing return statement in function"); | ||
2433 | } | ||
2434 | |||
2435 | final public LogicalORExpression LogicalORExpression() throws ParseException { | ||
2436 | LogicalANDExpression n0; | ||
2437 | NodeOptional n1 = new NodeOptional(); | ||
2438 | NodeSequence n2; | ||
2439 | NodeToken n3; | ||
2440 | Token n4; | ||
2441 | LogicalORExpression n5; | ||
2442 | n0 = LogicalANDExpression(); | ||
2443 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2444 | case 78: | ||
2445 | n2 = new NodeSequence(2); | ||
2446 | n4 = jj_consume_token(78); | ||
2447 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2448 | n2.addNode(n3); | ||
2449 | n5 = LogicalORExpression(); | ||
2450 | n2.addNode(n5); | ||
2451 | n1.addNode(n2); | ||
2452 | break; | ||
2453 | default: | ||
2454 | jj_la1[69] = jj_gen; | ||
2455 | ; | ||
2456 | } | ||
2457 | {if (true) return new LogicalORExpression(n0,n1);} | ||
2458 | throw new Error("Missing return statement in function"); | ||
2459 | } | ||
2460 | |||
2461 | final public LogicalANDExpression LogicalANDExpression() throws ParseException { | ||
2462 | InclusiveORExpression n0; | ||
2463 | NodeOptional n1 = new NodeOptional(); | ||
2464 | NodeSequence n2; | ||
2465 | NodeToken n3; | ||
2466 | Token n4; | ||
2467 | LogicalANDExpression n5; | ||
2468 | n0 = InclusiveORExpression(); | ||
2469 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2470 | case 79: | ||
2471 | n2 = new NodeSequence(2); | ||
2472 | n4 = jj_consume_token(79); | ||
2473 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2474 | n2.addNode(n3); | ||
2475 | n5 = LogicalANDExpression(); | ||
2476 | n2.addNode(n5); | ||
2477 | n1.addNode(n2); | ||
2478 | break; | ||
2479 | default: | ||
2480 | jj_la1[70] = jj_gen; | ||
2481 | ; | ||
2482 | } | ||
2483 | {if (true) return new LogicalANDExpression(n0,n1);} | ||
2484 | throw new Error("Missing return statement in function"); | ||
2485 | } | ||
2486 | |||
2487 | final public InclusiveORExpression InclusiveORExpression() throws ParseException { | ||
2488 | ExclusiveORExpression n0; | ||
2489 | NodeOptional n1 = new NodeOptional(); | ||
2490 | NodeSequence n2; | ||
2491 | NodeToken n3; | ||
2492 | Token n4; | ||
2493 | InclusiveORExpression n5; | ||
2494 | n0 = ExclusiveORExpression(); | ||
2495 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2496 | case 80: | ||
2497 | n2 = new NodeSequence(2); | ||
2498 | n4 = jj_consume_token(80); | ||
2499 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2500 | n2.addNode(n3); | ||
2501 | n5 = InclusiveORExpression(); | ||
2502 | n2.addNode(n5); | ||
2503 | n1.addNode(n2); | ||
2504 | break; | ||
2505 | default: | ||
2506 | jj_la1[71] = jj_gen; | ||
2507 | ; | ||
2508 | } | ||
2509 | {if (true) return new InclusiveORExpression(n0,n1);} | ||
2510 | throw new Error("Missing return statement in function"); | ||
2511 | } | ||
2512 | |||
2513 | final public ExclusiveORExpression ExclusiveORExpression() throws ParseException { | ||
2514 | ANDExpression n0; | ||
2515 | NodeOptional n1 = new NodeOptional(); | ||
2516 | NodeSequence n2; | ||
2517 | NodeToken n3; | ||
2518 | Token n4; | ||
2519 | ExclusiveORExpression n5; | ||
2520 | n0 = ANDExpression(); | ||
2521 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2522 | case 81: | ||
2523 | n2 = new NodeSequence(2); | ||
2524 | n4 = jj_consume_token(81); | ||
2525 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2526 | n2.addNode(n3); | ||
2527 | n5 = ExclusiveORExpression(); | ||
2528 | n2.addNode(n5); | ||
2529 | n1.addNode(n2); | ||
2530 | break; | ||
2531 | default: | ||
2532 | jj_la1[72] = jj_gen; | ||
2533 | ; | ||
2534 | } | ||
2535 | {if (true) return new ExclusiveORExpression(n0,n1);} | ||
2536 | throw new Error("Missing return statement in function"); | ||
2537 | } | ||
2538 | |||
2539 | final public ANDExpression ANDExpression() throws ParseException { | ||
2540 | EqualityExpression n0; | ||
2541 | NodeOptional n1 = new NodeOptional(); | ||
2542 | NodeSequence n2; | ||
2543 | NodeToken n3; | ||
2544 | Token n4; | ||
2545 | ANDExpression n5; | ||
2546 | n0 = EqualityExpression(); | ||
2547 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2548 | case 82: | ||
2549 | n2 = new NodeSequence(2); | ||
2550 | n4 = jj_consume_token(82); | ||
2551 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2552 | n2.addNode(n3); | ||
2553 | n5 = ANDExpression(); | ||
2554 | n2.addNode(n5); | ||
2555 | n1.addNode(n2); | ||
2556 | break; | ||
2557 | default: | ||
2558 | jj_la1[73] = jj_gen; | ||
2559 | ; | ||
2560 | } | ||
2561 | {if (true) return new ANDExpression(n0,n1);} | ||
2562 | throw new Error("Missing return statement in function"); | ||
2563 | } | ||
2564 | |||
2565 | final public EqualityExpression EqualityExpression() throws ParseException { | ||
2566 | RelationalExpression n0; | ||
2567 | NodeOptional n1 = new NodeOptional(); | ||
2568 | NodeSequence n2; | ||
2569 | NodeChoice n3; | ||
2570 | NodeToken n4; | ||
2571 | Token n5; | ||
2572 | NodeToken n6; | ||
2573 | Token n7; | ||
2574 | EqualityExpression n8; | ||
2575 | n0 = RelationalExpression(); | ||
2576 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2577 | case 83: | ||
2578 | case 84: | ||
2579 | n2 = new NodeSequence(2); | ||
2580 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2581 | case 83: | ||
2582 | n5 = jj_consume_token(83); | ||
2583 | n4 = JTBToolkit.makeNodeToken(n5); | ||
2584 | n3 = new NodeChoice(n4, 0); | ||
2585 | break; | ||
2586 | case 84: | ||
2587 | n7 = jj_consume_token(84); | ||
2588 | n6 = JTBToolkit.makeNodeToken(n7); | ||
2589 | n3 = new NodeChoice(n6, 1); | ||
2590 | break; | ||
2591 | default: | ||
2592 | jj_la1[74] = jj_gen; | ||
2593 | jj_consume_token(-1); | ||
2594 | throw new ParseException(); | ||
2595 | } | ||
2596 | n2.addNode(n3); | ||
2597 | n8 = EqualityExpression(); | ||
2598 | n2.addNode(n8); | ||
2599 | n1.addNode(n2); | ||
2600 | break; | ||
2601 | default: | ||
2602 | jj_la1[75] = jj_gen; | ||
2603 | ; | ||
2604 | } | ||
2605 | {if (true) return new EqualityExpression(n0,n1);} | ||
2606 | throw new Error("Missing return statement in function"); | ||
2607 | } | ||
2608 | |||
2609 | final public RelationalExpression RelationalExpression() throws ParseException { | ||
2610 | ShiftExpression n0; | ||
2611 | NodeOptional n1 = new NodeOptional(); | ||
2612 | NodeSequence n2; | ||
2613 | NodeChoice n3; | ||
2614 | NodeToken n4; | ||
2615 | Token n5; | ||
2616 | NodeToken n6; | ||
2617 | Token n7; | ||
2618 | NodeToken n8; | ||
2619 | Token n9; | ||
2620 | NodeToken n10; | ||
2621 | Token n11; | ||
2622 | RelationalExpression n12; | ||
2623 | n0 = ShiftExpression(); | ||
2624 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2625 | case 85: | ||
2626 | case 86: | ||
2627 | case 87: | ||
2628 | case 88: | ||
2629 | n2 = new NodeSequence(2); | ||
2630 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2631 | case 85: | ||
2632 | n5 = jj_consume_token(85); | ||
2633 | n4 = JTBToolkit.makeNodeToken(n5); | ||
2634 | n3 = new NodeChoice(n4, 0); | ||
2635 | break; | ||
2636 | case 86: | ||
2637 | n7 = jj_consume_token(86); | ||
2638 | n6 = JTBToolkit.makeNodeToken(n7); | ||
2639 | n3 = new NodeChoice(n6, 1); | ||
2640 | break; | ||
2641 | case 87: | ||
2642 | n9 = jj_consume_token(87); | ||
2643 | n8 = JTBToolkit.makeNodeToken(n9); | ||
2644 | n3 = new NodeChoice(n8, 2); | ||
2645 | break; | ||
2646 | case 88: | ||
2647 | n11 = jj_consume_token(88); | ||
2648 | n10 = JTBToolkit.makeNodeToken(n11); | ||
2649 | n3 = new NodeChoice(n10, 3); | ||
2650 | break; | ||
2651 | default: | ||
2652 | jj_la1[76] = jj_gen; | ||
2653 | jj_consume_token(-1); | ||
2654 | throw new ParseException(); | ||
2655 | } | ||
2656 | n2.addNode(n3); | ||
2657 | n12 = RelationalExpression(); | ||
2658 | n2.addNode(n12); | ||
2659 | n1.addNode(n2); | ||
2660 | break; | ||
2661 | default: | ||
2662 | jj_la1[77] = jj_gen; | ||
2663 | ; | ||
2664 | } | ||
2665 | {if (true) return new RelationalExpression(n0,n1);} | ||
2666 | throw new Error("Missing return statement in function"); | ||
2667 | } | ||
2668 | |||
2669 | final public ShiftExpression ShiftExpression() throws ParseException { | ||
2670 | AdditiveExpression n0; | ||
2671 | NodeOptional n1 = new NodeOptional(); | ||
2672 | NodeSequence n2; | ||
2673 | NodeChoice n3; | ||
2674 | NodeToken n4; | ||
2675 | Token n5; | ||
2676 | NodeToken n6; | ||
2677 | Token n7; | ||
2678 | ShiftExpression n8; | ||
2679 | n0 = AdditiveExpression(); | ||
2680 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2681 | case 89: | ||
2682 | case 90: | ||
2683 | n2 = new NodeSequence(2); | ||
2684 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2685 | case 89: | ||
2686 | n5 = jj_consume_token(89); | ||
2687 | n4 = JTBToolkit.makeNodeToken(n5); | ||
2688 | n3 = new NodeChoice(n4, 0); | ||
2689 | break; | ||
2690 | case 90: | ||
2691 | n7 = jj_consume_token(90); | ||
2692 | n6 = JTBToolkit.makeNodeToken(n7); | ||
2693 | n3 = new NodeChoice(n6, 1); | ||
2694 | break; | ||
2695 | default: | ||
2696 | jj_la1[78] = jj_gen; | ||
2697 | jj_consume_token(-1); | ||
2698 | throw new ParseException(); | ||
2699 | } | ||
2700 | n2.addNode(n3); | ||
2701 | n8 = ShiftExpression(); | ||
2702 | n2.addNode(n8); | ||
2703 | n1.addNode(n2); | ||
2704 | break; | ||
2705 | default: | ||
2706 | jj_la1[79] = jj_gen; | ||
2707 | ; | ||
2708 | } | ||
2709 | {if (true) return new ShiftExpression(n0,n1);} | ||
2710 | throw new Error("Missing return statement in function"); | ||
2711 | } | ||
2712 | |||
2713 | final public AdditiveExpression AdditiveExpression() throws ParseException { | ||
2714 | MultiplicativeExpression n0; | ||
2715 | NodeOptional n1 = new NodeOptional(); | ||
2716 | NodeSequence n2; | ||
2717 | NodeChoice n3; | ||
2718 | NodeToken n4; | ||
2719 | Token n5; | ||
2720 | NodeToken n6; | ||
2721 | Token n7; | ||
2722 | AdditiveExpression n8; | ||
2723 | n0 = MultiplicativeExpression(); | ||
2724 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2725 | case 91: | ||
2726 | case 92: | ||
2727 | n2 = new NodeSequence(2); | ||
2728 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2729 | case 91: | ||
2730 | n5 = jj_consume_token(91); | ||
2731 | n4 = JTBToolkit.makeNodeToken(n5); | ||
2732 | n3 = new NodeChoice(n4, 0); | ||
2733 | break; | ||
2734 | case 92: | ||
2735 | n7 = jj_consume_token(92); | ||
2736 | n6 = JTBToolkit.makeNodeToken(n7); | ||
2737 | n3 = new NodeChoice(n6, 1); | ||
2738 | break; | ||
2739 | default: | ||
2740 | jj_la1[80] = jj_gen; | ||
2741 | jj_consume_token(-1); | ||
2742 | throw new ParseException(); | ||
2743 | } | ||
2744 | n2.addNode(n3); | ||
2745 | n8 = AdditiveExpression(); | ||
2746 | n2.addNode(n8); | ||
2747 | n1.addNode(n2); | ||
2748 | break; | ||
2749 | default: | ||
2750 | jj_la1[81] = jj_gen; | ||
2751 | ; | ||
2752 | } | ||
2753 | {if (true) return new AdditiveExpression(n0,n1);} | ||
2754 | throw new Error("Missing return statement in function"); | ||
2755 | } | ||
2756 | |||
2757 | final public MultiplicativeExpression MultiplicativeExpression() throws ParseException { | ||
2758 | CastExpression n0; | ||
2759 | NodeOptional n1 = new NodeOptional(); | ||
2760 | NodeSequence n2; | ||
2761 | NodeChoice n3; | ||
2762 | NodeToken n4; | ||
2763 | Token n5; | ||
2764 | NodeToken n6; | ||
2765 | Token n7; | ||
2766 | NodeToken n8; | ||
2767 | Token n9; | ||
2768 | MultiplicativeExpression n10; | ||
2769 | n0 = CastExpression(); | ||
2770 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2771 | case 58: | ||
2772 | case 93: | ||
2773 | case 94: | ||
2774 | n2 = new NodeSequence(2); | ||
2775 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2776 | case 58: | ||
2777 | n5 = jj_consume_token(58); | ||
2778 | n4 = JTBToolkit.makeNodeToken(n5); | ||
2779 | n3 = new NodeChoice(n4, 0); | ||
2780 | break; | ||
2781 | case 93: | ||
2782 | n7 = jj_consume_token(93); | ||
2783 | n6 = JTBToolkit.makeNodeToken(n7); | ||
2784 | n3 = new NodeChoice(n6, 1); | ||
2785 | break; | ||
2786 | case 94: | ||
2787 | n9 = jj_consume_token(94); | ||
2788 | n8 = JTBToolkit.makeNodeToken(n9); | ||
2789 | n3 = new NodeChoice(n8, 2); | ||
2790 | break; | ||
2791 | default: | ||
2792 | jj_la1[82] = jj_gen; | ||
2793 | jj_consume_token(-1); | ||
2794 | throw new ParseException(); | ||
2795 | } | ||
2796 | n2.addNode(n3); | ||
2797 | n10 = MultiplicativeExpression(); | ||
2798 | n2.addNode(n10); | ||
2799 | n1.addNode(n2); | ||
2800 | break; | ||
2801 | default: | ||
2802 | jj_la1[83] = jj_gen; | ||
2803 | ; | ||
2804 | } | ||
2805 | {if (true) return new MultiplicativeExpression(n0,n1);} | ||
2806 | throw new Error("Missing return statement in function"); | ||
2807 | } | ||
2808 | |||
2809 | final public CastExpression CastExpression() throws ParseException { | ||
2810 | NodeChoice n0; | ||
2811 | NodeSequence n1; | ||
2812 | NodeToken n2; | ||
2813 | Token n3; | ||
2814 | TypeSpecifier n4; | ||
2815 | NodeToken n5; | ||
2816 | Token n6; | ||
2817 | CastExpression n7; | ||
2818 | UnaryExpression n8; | ||
2819 | if (jj_2_15(2147483647)) { | ||
2820 | n1 = new NodeSequence(5); | ||
2821 | n3 = jj_consume_token(55); | ||
2822 | n2 = JTBToolkit.makeNodeToken(n3); | ||
2823 | n1.addNode(n2); | ||
2824 | n4 = TypeSpecifier(); | ||
2825 | n1.addNode(n4); | ||
2826 | n6 = jj_consume_token(56); | ||
2827 | n5 = JTBToolkit.makeNodeToken(n6); | ||
2828 | n1.addNode(n5); | ||
2829 | n7 = CastExpression(); | ||
2830 | n1.addNode(n7); | ||
2831 | n0 = new NodeChoice(n1, 0); | ||
2832 | } else { | ||
2833 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2834 | case INTEGER_LITERAL: | ||
2835 | case FLOATING_POINT_LITERAL: | ||
2836 | case CHARACTER_LITERAL: | ||
2837 | case STRING_LITERAL: | ||
2838 | case SIZEOF: | ||
2839 | case IDENTIFIER: | ||
2840 | case 55: | ||
2841 | case 58: | ||
2842 | case 82: | ||
2843 | case 91: | ||
2844 | case 92: | ||
2845 | case 95: | ||
2846 | case 96: | ||
2847 | case 97: | ||
2848 | case 98: | ||
2849 | n8 = UnaryExpression(); | ||
2850 | n0 = new NodeChoice(n8, 1); | ||
2851 | break; | ||
2852 | default: | ||
2853 | jj_la1[84] = jj_gen; | ||
2854 | jj_consume_token(-1); | ||
2855 | throw new ParseException(); | ||
2856 | } | ||
2857 | } | ||
2858 | {if (true) return new CastExpression(n0);} | ||
2859 | throw new Error("Missing return statement in function"); | ||
2860 | } | ||
2861 | |||
2862 | final public UnaryExpression UnaryExpression() throws ParseException { | ||
2863 | NodeChoice n0; | ||
2864 | PostfixExpression n1; | ||
2865 | NodeSequence n2; | ||
2866 | NodeToken n3; | ||
2867 | Token n4; | ||
2868 | UnaryExpression n5; | ||
2869 | NodeSequence n6; | ||
2870 | NodeToken n7; | ||
2871 | Token n8; | ||
2872 | UnaryExpression n9; | ||
2873 | NodeSequence n10; | ||
2874 | UnaryOperator n11; | ||
2875 | CastExpression n12; | ||
2876 | NodeSequence n13; | ||
2877 | NodeToken n14; | ||
2878 | Token n15; | ||
2879 | NodeChoice n16; | ||
2880 | UnaryExpression n17; | ||
2881 | NodeSequence n18; | ||
2882 | NodeToken n19; | ||
2883 | Token n20; | ||
2884 | TypeSpecifier n21; | ||
2885 | NodeToken n22; | ||
2886 | Token n23; | ||
2887 | if (jj_2_17(3)) { | ||
2888 | n1 = PostfixExpression(); | ||
2889 | n0 = new NodeChoice(n1, 0); | ||
2890 | } else { | ||
2891 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2892 | case 95: | ||
2893 | n2 = new NodeSequence(2); | ||
2894 | n4 = jj_consume_token(95); | ||
2895 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2896 | n2.addNode(n3); | ||
2897 | n5 = UnaryExpression(); | ||
2898 | n2.addNode(n5); | ||
2899 | n0 = new NodeChoice(n2, 1); | ||
2900 | break; | ||
2901 | case 96: | ||
2902 | n6 = new NodeSequence(2); | ||
2903 | n8 = jj_consume_token(96); | ||
2904 | n7 = JTBToolkit.makeNodeToken(n8); | ||
2905 | n6.addNode(n7); | ||
2906 | n9 = UnaryExpression(); | ||
2907 | n6.addNode(n9); | ||
2908 | n0 = new NodeChoice(n6, 2); | ||
2909 | break; | ||
2910 | case 58: | ||
2911 | case 82: | ||
2912 | case 91: | ||
2913 | case 92: | ||
2914 | case 97: | ||
2915 | case 98: | ||
2916 | n10 = new NodeSequence(2); | ||
2917 | n11 = UnaryOperator(); | ||
2918 | n10.addNode(n11); | ||
2919 | n12 = CastExpression(); | ||
2920 | n10.addNode(n12); | ||
2921 | n0 = new NodeChoice(n10, 3); | ||
2922 | break; | ||
2923 | case SIZEOF: | ||
2924 | n13 = new NodeSequence(2); | ||
2925 | n15 = jj_consume_token(SIZEOF); | ||
2926 | n14 = JTBToolkit.makeNodeToken(n15); | ||
2927 | n13.addNode(n14); | ||
2928 | if (jj_2_16(2147483647)) { | ||
2929 | n17 = UnaryExpression(); | ||
2930 | n16 = new NodeChoice(n17, 0); | ||
2931 | } else { | ||
2932 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2933 | case 55: | ||
2934 | n18 = new NodeSequence(3); | ||
2935 | n20 = jj_consume_token(55); | ||
2936 | n19 = JTBToolkit.makeNodeToken(n20); | ||
2937 | n18.addNode(n19); | ||
2938 | n21 = TypeSpecifier(); | ||
2939 | n18.addNode(n21); | ||
2940 | n23 = jj_consume_token(56); | ||
2941 | n22 = JTBToolkit.makeNodeToken(n23); | ||
2942 | n18.addNode(n22); | ||
2943 | n16 = new NodeChoice(n18, 1); | ||
2944 | break; | ||
2945 | default: | ||
2946 | jj_la1[85] = jj_gen; | ||
2947 | jj_consume_token(-1); | ||
2948 | throw new ParseException(); | ||
2949 | } | ||
2950 | } | ||
2951 | n13.addNode(n16); | ||
2952 | n0 = new NodeChoice(n13, 4); | ||
2953 | break; | ||
2954 | default: | ||
2955 | jj_la1[86] = jj_gen; | ||
2956 | jj_consume_token(-1); | ||
2957 | throw new ParseException(); | ||
2958 | } | ||
2959 | } | ||
2960 | {if (true) return new UnaryExpression(n0);} | ||
2961 | throw new Error("Missing return statement in function"); | ||
2962 | } | ||
2963 | |||
2964 | final public UnaryOperator UnaryOperator() throws ParseException { | ||
2965 | NodeChoice n0; | ||
2966 | NodeToken n1; | ||
2967 | Token n2; | ||
2968 | NodeToken n3; | ||
2969 | Token n4; | ||
2970 | NodeToken n5; | ||
2971 | Token n6; | ||
2972 | NodeToken n7; | ||
2973 | Token n8; | ||
2974 | NodeToken n9; | ||
2975 | Token n10; | ||
2976 | NodeToken n11; | ||
2977 | Token n12; | ||
2978 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
2979 | case 82: | ||
2980 | n2 = jj_consume_token(82); | ||
2981 | n1 = JTBToolkit.makeNodeToken(n2); | ||
2982 | n0 = new NodeChoice(n1, 0); | ||
2983 | break; | ||
2984 | case 58: | ||
2985 | n4 = jj_consume_token(58); | ||
2986 | n3 = JTBToolkit.makeNodeToken(n4); | ||
2987 | n0 = new NodeChoice(n3, 1); | ||
2988 | break; | ||
2989 | case 91: | ||
2990 | n6 = jj_consume_token(91); | ||
2991 | n5 = JTBToolkit.makeNodeToken(n6); | ||
2992 | n0 = new NodeChoice(n5, 2); | ||
2993 | break; | ||
2994 | case 92: | ||
2995 | n8 = jj_consume_token(92); | ||
2996 | n7 = JTBToolkit.makeNodeToken(n8); | ||
2997 | n0 = new NodeChoice(n7, 3); | ||
2998 | break; | ||
2999 | case 97: | ||
3000 | n10 = jj_consume_token(97); | ||
3001 | n9 = JTBToolkit.makeNodeToken(n10); | ||
3002 | n0 = new NodeChoice(n9, 4); | ||
3003 | break; | ||
3004 | case 98: | ||
3005 | n12 = jj_consume_token(98); | ||
3006 | n11 = JTBToolkit.makeNodeToken(n12); | ||
3007 | n0 = new NodeChoice(n11, 5); | ||
3008 | break; | ||
3009 | default: | ||
3010 | jj_la1[87] = jj_gen; | ||
3011 | jj_consume_token(-1); | ||
3012 | throw new ParseException(); | ||
3013 | } | ||
3014 | {if (true) return new UnaryOperator(n0);} | ||
3015 | throw new Error("Missing return statement in function"); | ||
3016 | } | ||
3017 | |||
3018 | final public PostfixExpression PostfixExpression() throws ParseException { | ||
3019 | PrimaryExpression n0; | ||
3020 | NodeListOptional n1 = new NodeListOptional(); | ||
3021 | NodeChoice n2; | ||
3022 | NodeSequence n3; | ||
3023 | NodeToken n4; | ||
3024 | Token n5; | ||
3025 | Expression n6; | ||
3026 | NodeToken n7; | ||
3027 | Token n8; | ||
3028 | NodeSequence n9; | ||
3029 | NodeToken n10; | ||
3030 | Token n11; | ||
3031 | NodeOptional n12; | ||
3032 | ArgumentExpressionList n13; | ||
3033 | NodeToken n14; | ||
3034 | Token n15; | ||
3035 | NodeSequence n16; | ||
3036 | NodeToken n17; | ||
3037 | Token n18; | ||
3038 | NodeToken n19; | ||
3039 | Token n20; | ||
3040 | NodeSequence n21; | ||
3041 | NodeToken n22; | ||
3042 | Token n23; | ||
3043 | NodeToken n24; | ||
3044 | Token n25; | ||
3045 | NodeToken n26; | ||
3046 | Token n27; | ||
3047 | NodeToken n28; | ||
3048 | Token n29; | ||
3049 | n0 = PrimaryExpression(); | ||
3050 | label_12: | ||
3051 | while (true) { | ||
3052 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
3053 | case 55: | ||
3054 | case 65: | ||
3055 | case 95: | ||
3056 | case 96: | ||
3057 | case 99: | ||
3058 | case 100: | ||
3059 | ; | ||
3060 | break; | ||
3061 | default: | ||
3062 | jj_la1[88] = jj_gen; | ||
3063 | break label_12; | ||
3064 | } | ||
3065 | n12 = new NodeOptional(); | ||
3066 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
3067 | case 65: | ||
3068 | n3 = new NodeSequence(3); | ||
3069 | n5 = jj_consume_token(65); | ||
3070 | n4 = JTBToolkit.makeNodeToken(n5); | ||
3071 | n3.addNode(n4); | ||
3072 | n6 = Expression(); | ||
3073 | n3.addNode(n6); | ||
3074 | n8 = jj_consume_token(66); | ||
3075 | n7 = JTBToolkit.makeNodeToken(n8); | ||
3076 | n3.addNode(n7); | ||
3077 | n2 = new NodeChoice(n3, 0); | ||
3078 | break; | ||
3079 | case 55: | ||
3080 | n9 = new NodeSequence(3); | ||
3081 | n11 = jj_consume_token(55); | ||
3082 | n10 = JTBToolkit.makeNodeToken(n11); | ||
3083 | n9.addNode(n10); | ||
3084 | if (jj_2_18(2147483647)) { | ||
3085 | n13 = ArgumentExpressionList(); | ||
3086 | n12.addNode(n13); | ||
3087 | } else { | ||
3088 | ; | ||
3089 | } | ||
3090 | n9.addNode(n12); | ||
3091 | n15 = jj_consume_token(56); | ||
3092 | n14 = JTBToolkit.makeNodeToken(n15); | ||
3093 | n9.addNode(n14); | ||
3094 | n2 = new NodeChoice(n9, 1); | ||
3095 | break; | ||
3096 | case 99: | ||
3097 | n16 = new NodeSequence(2); | ||
3098 | n18 = jj_consume_token(99); | ||
3099 | n17 = JTBToolkit.makeNodeToken(n18); | ||
3100 | n16.addNode(n17); | ||
3101 | n20 = jj_consume_token(IDENTIFIER); | ||
3102 | n19 = JTBToolkit.makeNodeToken(n20); | ||
3103 | n16.addNode(n19); | ||
3104 | n2 = new NodeChoice(n16, 2); | ||
3105 | break; | ||
3106 | case 100: | ||
3107 | n21 = new NodeSequence(2); | ||
3108 | n23 = jj_consume_token(100); | ||
3109 | n22 = JTBToolkit.makeNodeToken(n23); | ||
3110 | n21.addNode(n22); | ||
3111 | n25 = jj_consume_token(IDENTIFIER); | ||
3112 | n24 = JTBToolkit.makeNodeToken(n25); | ||
3113 | n21.addNode(n24); | ||
3114 | n2 = new NodeChoice(n21, 3); | ||
3115 | break; | ||
3116 | case 95: | ||
3117 | n27 = jj_consume_token(95); | ||
3118 | n26 = JTBToolkit.makeNodeToken(n27); | ||
3119 | n2 = new NodeChoice(n26, 4); | ||
3120 | break; | ||
3121 | case 96: | ||
3122 | n29 = jj_consume_token(96); | ||
3123 | n28 = JTBToolkit.makeNodeToken(n29); | ||
3124 | n2 = new NodeChoice(n28, 5); | ||
3125 | break; | ||
3126 | default: | ||
3127 | jj_la1[89] = jj_gen; | ||
3128 | jj_consume_token(-1); | ||
3129 | throw new ParseException(); | ||
3130 | } | ||
3131 | n1.addNode(n2); | ||
3132 | } | ||
3133 | n1.nodes.trimToSize(); | ||
3134 | {if (true) return new PostfixExpression(n0,n1);} | ||
3135 | throw new Error("Missing return statement in function"); | ||
3136 | } | ||
3137 | |||
3138 | final public PrimaryExpression PrimaryExpression() throws ParseException { | ||
3139 | NodeChoice n0; | ||
3140 | NodeToken n1; | ||
3141 | Token n2; | ||
3142 | Constant n3; | ||
3143 | NodeSequence n4; | ||
3144 | NodeToken n5; | ||
3145 | Token n6; | ||
3146 | Expression n7; | ||
3147 | NodeToken n8; | ||
3148 | Token n9; | ||
3149 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
3150 | case IDENTIFIER: | ||
3151 | n2 = jj_consume_token(IDENTIFIER); | ||
3152 | n1 = JTBToolkit.makeNodeToken(n2); | ||
3153 | n0 = new NodeChoice(n1, 0); | ||
3154 | break; | ||
3155 | case INTEGER_LITERAL: | ||
3156 | case FLOATING_POINT_LITERAL: | ||
3157 | case CHARACTER_LITERAL: | ||
3158 | case STRING_LITERAL: | ||
3159 | n3 = Constant(); | ||
3160 | n0 = new NodeChoice(n3, 1); | ||
3161 | break; | ||
3162 | case 55: | ||
3163 | n4 = new NodeSequence(3); | ||
3164 | n6 = jj_consume_token(55); | ||
3165 | n5 = JTBToolkit.makeNodeToken(n6); | ||
3166 | n4.addNode(n5); | ||
3167 | n7 = Expression(); | ||
3168 | n4.addNode(n7); | ||
3169 | n9 = jj_consume_token(56); | ||
3170 | n8 = JTBToolkit.makeNodeToken(n9); | ||
3171 | n4.addNode(n8); | ||
3172 | n0 = new NodeChoice(n4, 2); | ||
3173 | break; | ||
3174 | default: | ||
3175 | jj_la1[90] = jj_gen; | ||
3176 | jj_consume_token(-1); | ||
3177 | throw new ParseException(); | ||
3178 | } | ||
3179 | {if (true) return new PrimaryExpression(n0);} | ||
3180 | throw new Error("Missing return statement in function"); | ||
3181 | } | ||
3182 | |||
3183 | final public ArgumentExpressionList ArgumentExpressionList() throws ParseException { | ||
3184 | AssignmentOrTypeExpression n0; | ||
3185 | NodeListOptional n1 = new NodeListOptional(); | ||
3186 | NodeSequence n2; | ||
3187 | NodeToken n3; | ||
3188 | Token n4; | ||
3189 | AssignmentOrTypeExpression n5; | ||
3190 | n0 = AssignmentOrTypeExpression(); | ||
3191 | label_13: | ||
3192 | while (true) { | ||
3193 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
3194 | case 59: | ||
3195 | ; | ||
3196 | break; | ||
3197 | default: | ||
3198 | jj_la1[91] = jj_gen; | ||
3199 | break label_13; | ||
3200 | } | ||
3201 | n2 = new NodeSequence(2); | ||
3202 | n4 = jj_consume_token(59); | ||
3203 | n3 = JTBToolkit.makeNodeToken(n4); | ||
3204 | n2.addNode(n3); | ||
3205 | n5 = AssignmentOrTypeExpression(); | ||
3206 | n2.addNode(n5); | ||
3207 | n1.addNode(n2); | ||
3208 | } | ||
3209 | n1.nodes.trimToSize(); | ||
3210 | {if (true) return new ArgumentExpressionList(n0,n1);} | ||
3211 | throw new Error("Missing return statement in function"); | ||
3212 | } | ||
3213 | |||
3214 | final public AssignmentOrTypeExpression AssignmentOrTypeExpression() throws ParseException { | ||
3215 | NodeChoice n0; | ||
3216 | NoIdentifierTypeSpecifier n1; | ||
3217 | AssignmentExpression n2; | ||
3218 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
3219 | case UNSIGNED: | ||
3220 | case DOUBLE: | ||
3221 | case STRUCT: | ||
3222 | case SIGNED: | ||
3223 | case UNION: | ||
3224 | case CONST: | ||
3225 | case FLOAT: | ||
3226 | case SHORT: | ||
3227 | case LONG: | ||
3228 | case ENUM: | ||
3229 | case VOID: | ||
3230 | case CHAR: | ||
3231 | case INT: | ||
3232 | n1 = NoIdentifierTypeSpecifier(); | ||
3233 | n0 = new NodeChoice(n1, 0); | ||
3234 | break; | ||
3235 | case INTEGER_LITERAL: | ||
3236 | case FLOATING_POINT_LITERAL: | ||
3237 | case CHARACTER_LITERAL: | ||
3238 | case STRING_LITERAL: | ||
3239 | case SIZEOF: | ||
3240 | case IDENTIFIER: | ||
3241 | case 55: | ||
3242 | case 58: | ||
3243 | case 82: | ||
3244 | case 91: | ||
3245 | case 92: | ||
3246 | case 95: | ||
3247 | case 96: | ||
3248 | case 97: | ||
3249 | case 98: | ||
3250 | n2 = AssignmentExpression(); | ||
3251 | n0 = new NodeChoice(n2, 1); | ||
3252 | break; | ||
3253 | default: | ||
3254 | jj_la1[92] = jj_gen; | ||
3255 | jj_consume_token(-1); | ||
3256 | throw new ParseException(); | ||
3257 | } | ||
3258 | {if (true) return new AssignmentOrTypeExpression(n0);} | ||
3259 | throw new Error("Missing return statement in function"); | ||
3260 | } | ||
3261 | |||
3262 | final public Constant Constant() throws ParseException { | ||
3263 | NodeChoice n0; | ||
3264 | NodeToken n1; | ||
3265 | Token n2; | ||
3266 | NodeToken n3; | ||
3267 | Token n4; | ||
3268 | NodeToken n5; | ||
3269 | Token n6; | ||
3270 | NodeToken n7; | ||
3271 | Token n8; | ||
3272 | switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { | ||
3273 | case INTEGER_LITERAL: | ||
3274 | n2 = jj_consume_token(INTEGER_LITERAL); | ||
3275 | n1 = JTBToolkit.makeNodeToken(n2); | ||
3276 | n0 = new NodeChoice(n1, 0); | ||
3277 | break; | ||
3278 | case FLOATING_POINT_LITERAL: | ||
3279 | n4 = jj_consume_token(FLOATING_POINT_LITERAL); | ||
3280 | n3 = JTBToolkit.makeNodeToken(n4); | ||
3281 | n0 = new NodeChoice(n3, 1); | ||
3282 | break; | ||
3283 | case CHARACTER_LITERAL: | ||
3284 | n6 = jj_consume_token(CHARACTER_LITERAL); | ||
3285 | n5 = JTBToolkit.makeNodeToken(n6); | ||
3286 | n0 = new NodeChoice(n5, 2); | ||
3287 | break; | ||
3288 | case STRING_LITERAL: | ||
3289 | n8 = jj_consume_token(STRING_LITERAL); | ||
3290 | n7 = JTBToolkit.makeNodeToken(n8); | ||
3291 | n0 = new NodeChoice(n7, 3); | ||
3292 | break; | ||
3293 | default: | ||
3294 | jj_la1[93] = jj_gen; | ||
3295 | jj_consume_token(-1); | ||
3296 | throw new ParseException(); | ||
3297 | } | ||
3298 | {if (true) return new Constant(n0);} | ||
3299 | throw new Error("Missing return statement in function"); | ||
3300 | } | ||
3301 | |||
3302 | private boolean jj_2_1(int xla) { | ||
3303 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3304 | try { return !jj_3_1(); } | ||
3305 | catch(LookaheadSuccess ls) { return true; } | ||
3306 | finally { jj_save(0, xla); } | ||
3307 | } | ||
3308 | |||
3309 | private boolean jj_2_2(int xla) { | ||
3310 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3311 | try { return !jj_3_2(); } | ||
3312 | catch(LookaheadSuccess ls) { return true; } | ||
3313 | finally { jj_save(1, xla); } | ||
3314 | } | ||
3315 | |||
3316 | private boolean jj_2_3(int xla) { | ||
3317 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3318 | try { return !jj_3_3(); } | ||
3319 | catch(LookaheadSuccess ls) { return true; } | ||
3320 | finally { jj_save(2, xla); } | ||
3321 | } | ||
3322 | |||
3323 | private boolean jj_2_4(int xla) { | ||
3324 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3325 | try { return !jj_3_4(); } | ||
3326 | catch(LookaheadSuccess ls) { return true; } | ||
3327 | finally { jj_save(3, xla); } | ||
3328 | } | ||
3329 | |||
3330 | private boolean jj_2_5(int xla) { | ||
3331 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3332 | try { return !jj_3_5(); } | ||
3333 | catch(LookaheadSuccess ls) { return true; } | ||
3334 | finally { jj_save(4, xla); } | ||
3335 | } | ||
3336 | |||
3337 | private boolean jj_2_6(int xla) { | ||
3338 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3339 | try { return !jj_3_6(); } | ||
3340 | catch(LookaheadSuccess ls) { return true; } | ||
3341 | finally { jj_save(5, xla); } | ||
3342 | } | ||
3343 | |||
3344 | private boolean jj_2_7(int xla) { | ||
3345 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3346 | try { return !jj_3_7(); } | ||
3347 | catch(LookaheadSuccess ls) { return true; } | ||
3348 | finally { jj_save(6, xla); } | ||
3349 | } | ||
3350 | |||
3351 | private boolean jj_2_8(int xla) { | ||
3352 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3353 | try { return !jj_3_8(); } | ||
3354 | catch(LookaheadSuccess ls) { return true; } | ||
3355 | finally { jj_save(7, xla); } | ||
3356 | } | ||
3357 | |||
3358 | private boolean jj_2_9(int xla) { | ||
3359 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3360 | try { return !jj_3_9(); } | ||
3361 | catch(LookaheadSuccess ls) { return true; } | ||
3362 | finally { jj_save(8, xla); } | ||
3363 | } | ||
3364 | |||
3365 | private boolean jj_2_10(int xla) { | ||
3366 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3367 | try { return !jj_3_10(); } | ||
3368 | catch(LookaheadSuccess ls) { return true; } | ||
3369 | finally { jj_save(9, xla); } | ||
3370 | } | ||
3371 | |||
3372 | private boolean jj_2_11(int xla) { | ||
3373 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3374 | try { return !jj_3_11(); } | ||
3375 | catch(LookaheadSuccess ls) { return true; } | ||
3376 | finally { jj_save(10, xla); } | ||
3377 | } | ||
3378 | |||
3379 | private boolean jj_2_12(int xla) { | ||
3380 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3381 | try { return !jj_3_12(); } | ||
3382 | catch(LookaheadSuccess ls) { return true; } | ||
3383 | finally { jj_save(11, xla); } | ||
3384 | } | ||
3385 | |||
3386 | private boolean jj_2_13(int xla) { | ||
3387 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3388 | try { return !jj_3_13(); } | ||
3389 | catch(LookaheadSuccess ls) { return true; } | ||
3390 | finally { jj_save(12, xla); } | ||
3391 | } | ||
3392 | |||
3393 | private boolean jj_2_14(int xla) { | ||
3394 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3395 | try { return !jj_3_14(); } | ||
3396 | catch(LookaheadSuccess ls) { return true; } | ||
3397 | finally { jj_save(13, xla); } | ||
3398 | } | ||
3399 | |||
3400 | private boolean jj_2_15(int xla) { | ||
3401 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3402 | try { return !jj_3_15(); } | ||
3403 | catch(LookaheadSuccess ls) { return true; } | ||
3404 | finally { jj_save(14, xla); } | ||
3405 | } | ||
3406 | |||
3407 | private boolean jj_2_16(int xla) { | ||
3408 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3409 | try { return !jj_3_16(); } | ||
3410 | catch(LookaheadSuccess ls) { return true; } | ||
3411 | finally { jj_save(15, xla); } | ||
3412 | } | ||
3413 | |||
3414 | private boolean jj_2_17(int xla) { | ||
3415 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3416 | try { return !jj_3_17(); } | ||
3417 | catch(LookaheadSuccess ls) { return true; } | ||
3418 | finally { jj_save(16, xla); } | ||
3419 | } | ||
3420 | |||
3421 | private boolean jj_2_18(int xla) { | ||
3422 | jj_la = xla; jj_lastpos = jj_scanpos = token; | ||
3423 | try { return !jj_3_18(); } | ||
3424 | catch(LookaheadSuccess ls) { return true; } | ||
3425 | finally { jj_save(17, xla); } | ||
3426 | } | ||
3427 | |||
3428 | private boolean jj_3R_113() { | ||
3429 | if (jj_scan_token(55)) return true; | ||
3430 | if (jj_3R_32()) return true; | ||
3431 | if (jj_scan_token(56)) return true; | ||
3432 | return false; | ||
3433 | } | ||
3434 | |||
3435 | private boolean jj_3R_192() { | ||
3436 | if (jj_scan_token(DOUBLE)) return true; | ||
3437 | return false; | ||
3438 | } | ||
3439 | |||
3440 | private boolean jj_3R_168() { | ||
3441 | if (jj_3R_123()) return true; | ||
3442 | return false; | ||
3443 | } | ||
3444 | |||
3445 | private boolean jj_3_6() { | ||
3446 | if (jj_scan_token(59)) return true; | ||
3447 | if (jj_3R_19()) return true; | ||
3448 | return false; | ||
3449 | } | ||
3450 | |||
3451 | private boolean jj_3R_191() { | ||
3452 | if (jj_scan_token(FLOAT)) return true; | ||
3453 | return false; | ||
3454 | } | ||
3455 | |||
3456 | private boolean jj_3R_112() { | ||
3457 | if (jj_3R_29()) return true; | ||
3458 | return false; | ||
3459 | } | ||
3460 | |||
3461 | private boolean jj_3R_203() { | ||
3462 | if (jj_scan_token(LONG)) return true; | ||
3463 | return false; | ||
3464 | } | ||
3465 | |||
3466 | private boolean jj_3R_167() { | ||
3467 | if (jj_scan_token(CONST)) return true; | ||
3468 | return false; | ||
3469 | } | ||
3470 | |||
3471 | private boolean jj_3R_97() { | ||
3472 | if (jj_3R_19()) return true; | ||
3473 | Token xsp; | ||
3474 | while (true) { | ||
3475 | xsp = jj_scanpos; | ||
3476 | if (jj_3_6()) { jj_scanpos = xsp; break; } | ||
3477 | } | ||
3478 | xsp = jj_scanpos; | ||
3479 | if (jj_3R_136()) jj_scanpos = xsp; | ||
3480 | return false; | ||
3481 | } | ||
3482 | |||
3483 | private boolean jj_3R_123() { | ||
3484 | if (jj_scan_token(58)) return true; | ||
3485 | Token xsp; | ||
3486 | xsp = jj_scanpos; | ||
3487 | if (jj_3R_167()) jj_scanpos = xsp; | ||
3488 | xsp = jj_scanpos; | ||
3489 | if (jj_3R_168()) jj_scanpos = xsp; | ||
3490 | return false; | ||
3491 | } | ||
3492 | |||
3493 | private boolean jj_3R_190() { | ||
3494 | if (jj_scan_token(LONG)) return true; | ||
3495 | Token xsp; | ||
3496 | xsp = jj_scanpos; | ||
3497 | if (jj_3R_203()) jj_scanpos = xsp; | ||
3498 | return false; | ||
3499 | } | ||
3500 | |||
3501 | private boolean jj_3R_63() { | ||
3502 | if (jj_scan_token(SIZEOF)) return true; | ||
3503 | Token xsp; | ||
3504 | xsp = jj_scanpos; | ||
3505 | if (jj_3R_112()) { | ||
3506 | jj_scanpos = xsp; | ||
3507 | if (jj_3R_113()) return true; | ||
3508 | } | ||
3509 | return false; | ||
3510 | } | ||
3511 | |||
3512 | private boolean jj_3R_161() { | ||
3513 | if (jj_scan_token(79)) return true; | ||
3514 | if (jj_3R_114()) return true; | ||
3515 | return false; | ||
3516 | } | ||
3517 | |||
3518 | private boolean jj_3R_189() { | ||
3519 | if (jj_scan_token(INT)) return true; | ||
3520 | return false; | ||
3521 | } | ||
3522 | |||
3523 | private boolean jj_3R_202() { | ||
3524 | if (jj_scan_token(INT)) return true; | ||
3525 | return false; | ||
3526 | } | ||
3527 | |||
3528 | private boolean jj_3R_114() { | ||
3529 | if (jj_3R_160()) return true; | ||
3530 | Token xsp; | ||
3531 | xsp = jj_scanpos; | ||
3532 | if (jj_3R_161()) jj_scanpos = xsp; | ||
3533 | return false; | ||
3534 | } | ||
3535 | |||
3536 | private boolean jj_3R_62() { | ||
3537 | if (jj_3R_111()) return true; | ||
3538 | if (jj_3R_33()) return true; | ||
3539 | return false; | ||
3540 | } | ||
3541 | |||
3542 | private boolean jj_3R_188() { | ||
3543 | if (jj_scan_token(SHORT)) return true; | ||
3544 | Token xsp; | ||
3545 | xsp = jj_scanpos; | ||
3546 | if (jj_3R_202()) jj_scanpos = xsp; | ||
3547 | return false; | ||
3548 | } | ||
3549 | |||
3550 | private boolean jj_3R_61() { | ||
3551 | if (jj_scan_token(96)) return true; | ||
3552 | if (jj_3R_29()) return true; | ||
3553 | return false; | ||
3554 | } | ||
3555 | |||
3556 | private boolean jj_3R_187() { | ||
3557 | if (jj_scan_token(CHAR)) return true; | ||
3558 | return false; | ||
3559 | } | ||
3560 | |||
3561 | private boolean jj_3R_142() { | ||
3562 | if (jj_3R_97()) return true; | ||
3563 | return false; | ||
3564 | } | ||
3565 | |||
3566 | private boolean jj_3R_186() { | ||
3567 | if (jj_scan_token(VOID)) return true; | ||
3568 | return false; | ||
3569 | } | ||
3570 | |||
3571 | private boolean jj_3R_104() { | ||
3572 | if (jj_scan_token(63)) return true; | ||
3573 | if (jj_3R_106()) return true; | ||
3574 | return false; | ||
3575 | } | ||
3576 | |||
3577 | private boolean jj_3R_60() { | ||
3578 | if (jj_scan_token(95)) return true; | ||
3579 | if (jj_3R_29()) return true; | ||
3580 | return false; | ||
3581 | } | ||
3582 | |||
3583 | private boolean jj_3R_47() { | ||
3584 | if (jj_scan_token(IDENTIFIER)) return true; | ||
3585 | Token xsp; | ||
3586 | xsp = jj_scanpos; | ||
3587 | if (jj_3R_104()) jj_scanpos = xsp; | ||
3588 | return false; | ||
3589 | } | ||
3590 | |||
3591 | private boolean jj_3_17() { | ||
3592 | if (jj_3R_34()) return true; | ||
3593 | return false; | ||
3594 | } | ||
3595 | |||
3596 | private boolean jj_3R_185() { | ||
3597 | if (jj_scan_token(CONST)) return true; | ||
3598 | return false; | ||
3599 | } | ||
3600 | |||
3601 | private boolean jj_3R_102() { | ||
3602 | if (jj_3R_32()) return true; | ||
3603 | if (jj_scan_token(55)) return true; | ||
3604 | if (jj_scan_token(58)) return true; | ||
3605 | if (jj_scan_token(IDENTIFIER)) return true; | ||
3606 | if (jj_scan_token(56)) return true; | ||
3607 | if (jj_scan_token(55)) return true; | ||
3608 | Token xsp; | ||
3609 | xsp = jj_scanpos; | ||
3610 | if (jj_3R_142()) jj_scanpos = xsp; | ||
3611 | if (jj_scan_token(56)) return true; | ||
3612 | return false; | ||
3613 | } | ||
3614 | |||
3615 | private boolean jj_3R_115() { | ||
3616 | if (jj_scan_token(78)) return true; | ||
3617 | if (jj_3R_75()) return true; | ||
3618 | return false; | ||
3619 | } | ||
3620 | |||
3621 | private boolean jj_3R_172() { | ||
3622 | Token xsp; | ||
3623 | xsp = jj_scanpos; | ||
3624 | if (jj_3R_185()) jj_scanpos = xsp; | ||
3625 | xsp = jj_scanpos; | ||
3626 | if (jj_3R_186()) { | ||
3627 | jj_scanpos = xsp; | ||
3628 | if (jj_3R_187()) { | ||
3629 | jj_scanpos = xsp; | ||
3630 | if (jj_3R_188()) { | ||
3631 | jj_scanpos = xsp; | ||
3632 | if (jj_3R_189()) { | ||
3633 | jj_scanpos = xsp; | ||
3634 | if (jj_3R_190()) { | ||
3635 | jj_scanpos = xsp; | ||
3636 | if (jj_3R_191()) { | ||
3637 | jj_scanpos = xsp; | ||
3638 | if (jj_3R_192()) { | ||
3639 | jj_scanpos = xsp; | ||
3640 | if (jj_3R_193()) { | ||
3641 | jj_scanpos = xsp; | ||
3642 | if (jj_3R_194()) { | ||
3643 | jj_scanpos = xsp; | ||
3644 | if (jj_3R_195()) return true; | ||
3645 | } | ||
3646 | } | ||
3647 | } | ||
3648 | } | ||
3649 | } | ||
3650 | } | ||
3651 | } | ||
3652 | } | ||
3653 | } | ||
3654 | xsp = jj_scanpos; | ||
3655 | if (jj_3R_196()) jj_scanpos = xsp; | ||
3656 | xsp = jj_scanpos; | ||
3657 | if (jj_3R_197()) jj_scanpos = xsp; | ||
3658 | return false; | ||
3659 | } | ||
3660 | |||
3661 | private boolean jj_3R_75() { | ||
3662 | if (jj_3R_114()) return true; | ||
3663 | Token xsp; | ||
3664 | xsp = jj_scanpos; | ||
3665 | if (jj_3R_115()) jj_scanpos = xsp; | ||
3666 | return false; | ||
3667 | } | ||
3668 | |||
3669 | private boolean jj_3R_146() { | ||
3670 | if (jj_scan_token(SWITCH)) return true; | ||
3671 | if (jj_scan_token(55)) return true; | ||
3672 | if (jj_3R_116()) return true; | ||
3673 | if (jj_scan_token(56)) return true; | ||
3674 | if (jj_3R_28()) return true; | ||
3675 | return false; | ||
3676 | } | ||
3677 | |||
3678 | private boolean jj_3R_29() { | ||
3679 | Token xsp; | ||
3680 | xsp = jj_scanpos; | ||
3681 | if (jj_3_17()) { | ||
3682 | jj_scanpos = xsp; | ||
3683 | if (jj_3R_60()) { | ||
3684 | jj_scanpos = xsp; | ||
3685 | if (jj_3R_61()) { | ||
3686 | jj_scanpos = xsp; | ||
3687 | if (jj_3R_62()) { | ||
3688 | jj_scanpos = xsp; | ||
3689 | if (jj_3R_63()) return true; | ||
3690 | } | ||
3691 | } | ||
3692 | } | ||
3693 | } | ||
3694 | return false; | ||
3695 | } | ||
3696 | |||
3697 | private boolean jj_3_12() { | ||
3698 | if (jj_scan_token(ELSE)) return true; | ||
3699 | if (jj_3R_28()) return true; | ||
3700 | return false; | ||
3701 | } | ||
3702 | |||
3703 | private boolean jj_3R_48() { | ||
3704 | if (jj_scan_token(59)) return true; | ||
3705 | if (jj_3R_47()) return true; | ||
3706 | return false; | ||
3707 | } | ||
3708 | |||
3709 | private boolean jj_3R_106() { | ||
3710 | if (jj_3R_31()) return true; | ||
3711 | return false; | ||
3712 | } | ||
3713 | |||
3714 | private boolean jj_3R_24() { | ||
3715 | if (jj_3R_47()) return true; | ||
3716 | Token xsp; | ||
3717 | while (true) { | ||
3718 | xsp = jj_scanpos; | ||
3719 | if (jj_3R_48()) { jj_scanpos = xsp; break; } | ||
3720 | } | ||
3721 | return false; | ||
3722 | } | ||
3723 | |||
3724 | private boolean jj_3R_18() { | ||
3725 | if (jj_3R_15()) return true; | ||
3726 | if (jj_scan_token(IDENTIFIER)) return true; | ||
3727 | return false; | ||
3728 | } | ||
3729 | |||
3730 | private boolean jj_3R_145() { | ||
3731 | if (jj_scan_token(IF)) return true; | ||
3732 | if (jj_scan_token(55)) return true; | ||
3733 | if (jj_3R_116()) return true; | ||
3734 | if (jj_scan_token(56)) return true; | ||
3735 | if (jj_3R_28()) return true; | ||
3736 | Token xsp; | ||
3737 | xsp = jj_scanpos; | ||
3738 | if (jj_3_12()) jj_scanpos = xsp; | ||
3739 | return false; | ||
3740 | } | ||
3741 | |||
3742 | private boolean jj_3_5() { | ||
3743 | if (jj_3R_18()) return true; | ||
3744 | if (jj_scan_token(57)) return true; | ||
3745 | return false; | ||
3746 | } | ||
3747 | |||
3748 | private boolean jj_3R_108() { | ||
3749 | Token xsp; | ||
3750 | xsp = jj_scanpos; | ||
3751 | if (jj_3R_145()) { | ||
3752 | jj_scanpos = xsp; | ||
3753 | if (jj_3R_146()) return true; | ||
3754 | } | ||
3755 | return false; | ||
3756 | } | ||
3757 | |||
3758 | private boolean jj_3R_166() { | ||
3759 | if (jj_scan_token(IDENTIFIER)) return true; | ||
3760 | return false; | ||
3761 | } | ||
3762 | |||
3763 | private boolean jj_3R_43() { | ||
3764 | if (jj_3R_102()) return true; | ||
3765 | return false; | ||
3766 | } | ||
3767 | |||
3768 | private boolean jj_3R_92() { | ||
3769 | if (jj_3R_29()) return true; | ||
3770 | return false; | ||
3771 | } | ||
3772 | |||
3773 | private boolean jj_3R_76() { | ||
3774 | if (jj_scan_token(77)) return true; | ||
3775 | if (jj_3R_116()) return true; | ||
3776 | if (jj_scan_token(64)) return true; | ||
3777 | if (jj_3R_31()) return true; | ||
3778 | return false; | ||
3779 | } | ||
3780 | |||
3781 | private boolean jj_3_15() { | ||
3782 | if (jj_scan_token(55)) return true; | ||
3783 | if (jj_3R_32()) return true; | ||
3784 | if (jj_scan_token(56)) return true; | ||
3785 | if (jj_3R_33()) return true; | ||
3786 | return false; | ||
3787 | } | ||
3788 | |||
3789 | private boolean jj_3R_42() { | ||
3790 | if (jj_3R_18()) return true; | ||
3791 | return false; | ||
3792 | } | ||
3793 | |||
3794 | private boolean jj_3R_31() { | ||
3795 | if (jj_3R_75()) return true; | ||
3796 | Token xsp; | ||
3797 | xsp = jj_scanpos; | ||
3798 | if (jj_3R_76()) jj_scanpos = xsp; | ||
3799 | return false; | ||
3800 | } | ||
3801 | |||
3802 | private boolean jj_3R_23() { | ||
3803 | if (jj_scan_token(IDENTIFIER)) return true; | ||
3804 | return false; | ||
3805 | } | ||
3806 | |||
3807 | private boolean jj_3R_91() { | ||
3808 | if (jj_scan_token(55)) return true; | ||
3809 | if (jj_3R_32()) return true; | ||
3810 | if (jj_scan_token(56)) return true; | ||
3811 | if (jj_3R_33()) return true; | ||
3812 | return false; | ||
3813 | } | ||
3814 | |||
3815 | private boolean jj_3R_17() { | ||
3816 | if (jj_scan_token(TYPEDEF)) return true; | ||
3817 | Token xsp; | ||
3818 | xsp = jj_scanpos; | ||
3819 | if (jj_3R_42()) { | ||
3820 | jj_scanpos = xsp; | ||
3821 | if (jj_3R_43()) return true; | ||
3822 | } | ||
3823 | if (jj_scan_token(57)) return true; | ||
3824 | return false; | ||
3825 | } | ||
3826 | |||
3827 | private boolean jj_3_8() { | ||
3828 | Token xsp; | ||
3829 | xsp = jj_scanpos; | ||
3830 | if (jj_3R_23()) jj_scanpos = xsp; | ||
3831 | if (jj_scan_token(61)) return true; | ||
3832 | if (jj_3R_24()) return true; | ||
3833 | if (jj_scan_token(62)) return true; | ||
3834 | return false; | ||
3835 | } | ||
3836 | |||
3837 | private boolean jj_3R_33() { | ||
3838 | Token xsp; | ||
3839 | xsp = jj_scanpos; | ||
3840 | if (jj_3R_91()) { | ||
3841 | jj_scanpos = xsp; | ||
3842 | if (jj_3R_92()) return true; | ||
3843 | } | ||
3844 | return false; | ||
3845 | } | ||
3846 | |||
3847 | private boolean jj_3R_122() { | ||
3848 | if (jj_scan_token(ENUM)) return true; | ||
3849 | Token xsp; | ||
3850 | xsp = jj_scanpos; | ||
3851 | if (jj_3_8()) { | ||
3852 | jj_scanpos = xsp; | ||
3853 | if (jj_3R_166()) return true; | ||
3854 | } | ||
3855 | return false; | ||
3856 | } | ||
3857 | |||
3858 | private boolean jj_3R_74() { | ||
3859 | if (jj_scan_token(76)) return true; | ||
3860 | return false; | ||
3861 | } | ||
3862 | |||
3863 | private boolean jj_3_11() { | ||
3864 | if (jj_3R_27()) return true; | ||
3865 | return false; | ||
3866 | } | ||
3867 | |||
3868 | private boolean jj_3R_73() { | ||
3869 | if (jj_scan_token(75)) return true; | ||
3870 | return false; | ||
3871 | } | ||
3872 | |||
3873 | private boolean jj_3R_90() { | ||
3874 | if (jj_3R_124()) return true; | ||
3875 | return false; | ||
3876 | } | ||
3877 | |||
3878 | private boolean jj_3R_72() { | ||
3879 | if (jj_scan_token(74)) return true; | ||
3880 | return false; | ||
3881 | } | ||
3882 | |||
3883 | private boolean jj_3R_175() { | ||
3884 | if (jj_3R_28()) return true; | ||
3885 | return false; | ||
3886 | } | ||
3887 | |||
3888 | private boolean jj_3R_71() { | ||
3889 | if (jj_scan_token(73)) return true; | ||
3890 | return false; | ||
3891 | } | ||
3892 | |||
3893 | private boolean jj_3R_89() { | ||
3894 | if (jj_3R_123()) return true; | ||
3895 | return false; | ||
3896 | } | ||
3897 | |||
3898 | private boolean jj_3R_70() { | ||
3899 | if (jj_scan_token(72)) return true; | ||
3900 | return false; | ||
3901 | } | ||
3902 | |||
3903 | private boolean jj_3R_174() { | ||
3904 | if (jj_3R_27()) return true; | ||
3905 | return false; | ||
3906 | } | ||
3907 | |||
3908 | private boolean jj_3R_88() { | ||
3909 | if (jj_scan_token(IDENTIFIER)) return true; | ||
3910 | return false; | ||
3911 | } | ||
3912 | |||
3913 | private boolean jj_3R_69() { | ||
3914 | if (jj_scan_token(71)) return true; | ||
3915 | return false; | ||
3916 | } | ||
3917 | |||
3918 | private boolean jj_3R_244() { | ||
3919 | if (jj_scan_token(94)) return true; | ||
3920 | return false; | ||
3921 | } | ||
3922 | |||
3923 | private boolean jj_3R_87() { | ||
3924 | if (jj_3R_122()) return true; | ||
3925 | return false; | ||
3926 | } | ||
3927 | |||
3928 | private boolean jj_3R_137() { | ||
3929 | Token xsp; | ||
3930 | xsp = jj_scanpos; | ||
3931 | if (jj_3R_174()) { | ||
3932 | jj_scanpos = xsp; | ||
3933 | if (jj_3R_175()) return true; | ||
3934 | } | ||
3935 | return false; | ||
3936 | } | ||
3937 | |||
3938 | private boolean jj_3R_68() { | ||
3939 | if (jj_scan_token(70)) return true; | ||
3940 | return false; | ||
3941 | } | ||
3942 | |||
3943 | private boolean jj_3R_243() { | ||
3944 | if (jj_scan_token(93)) return true; | ||
3945 | return false; | ||
3946 | } | ||
3947 | |||
3948 | private boolean jj_3R_86() { | ||
3949 | if (jj_3R_15()) return true; | ||
3950 | return false; | ||
3951 | } | ||
3952 | |||
3953 | private boolean jj_3R_179() { | ||
3954 | if (jj_scan_token(LONG)) return true; | ||
3955 | return false; | ||
3956 | } | ||
3957 | |||
3958 | private boolean jj_3R_67() { | ||
3959 | if (jj_scan_token(69)) return true; | ||
3960 | return false; | ||
3961 | } | ||
3962 | |||
3963 | private boolean jj_3R_242() { | ||
3964 | if (jj_scan_token(58)) return true; | ||
3965 | return false; | ||
3966 | } | ||
3967 | |||
3968 | private boolean jj_3R_98() { | ||
3969 | if (jj_scan_token(61)) return true; | ||
3970 | Token xsp; | ||
3971 | while (true) { | ||
3972 | xsp = jj_scanpos; | ||
3973 | if (jj_3R_137()) { jj_scanpos = xsp; break; } | ||
3974 | } | ||
3975 | if (jj_scan_token(62)) return true; | ||
3976 | return false; | ||
3977 | } | ||
3978 | |||
3979 | private boolean jj_3R_199() { | ||
3980 | if (jj_scan_token(IDENTIFIER)) return true; | ||
3981 | return false; | ||
3982 | } | ||
3983 | |||
3984 | private boolean jj_3R_66() { | ||
3985 | if (jj_scan_token(68)) return true; | ||
3986 | return false; | ||
3987 | } | ||
3988 | |||
3989 | private boolean jj_3R_183() { | ||
3990 | if (jj_scan_token(STRING_LITERAL)) return true; | ||
3991 | return false; | ||
3992 | } | ||
3993 | |||
3994 | private boolean jj_3R_65() { | ||
3995 | if (jj_scan_token(67)) return true; | ||
3996 | return false; | ||
3997 | } | ||
3998 | |||
3999 | private boolean jj_3R_165() { | ||
4000 | if (jj_scan_token(LONG)) return true; | ||
4001 | Token xsp; | ||
4002 | xsp = jj_scanpos; | ||
4003 | if (jj_3R_179()) jj_scanpos = xsp; | ||
4004 | return false; | ||
4005 | } | ||
4006 | |||
4007 | private boolean jj_3R_182() { | ||
4008 | if (jj_scan_token(CHARACTER_LITERAL)) return true; | ||
4009 | return false; | ||
4010 | } | ||
4011 | |||
4012 | private boolean jj_3R_38() { | ||
4013 | if (jj_3R_98()) return true; | ||
4014 | return false; | ||
4015 | } | ||
4016 | |||
4017 | private boolean jj_3R_64() { | ||
4018 | if (jj_scan_token(63)) return true; | ||
4019 | return false; | ||
4020 | } | ||
4021 | |||
4022 | private boolean jj_3R_239() { | ||
4023 | Token xsp; | ||
4024 | xsp = jj_scanpos; | ||
4025 | if (jj_3R_242()) { | ||
4026 | jj_scanpos = xsp; | ||
4027 | if (jj_3R_243()) { | ||
4028 | jj_scanpos = xsp; | ||
4029 | if (jj_3R_244()) return true; | ||
4030 | } | ||
4031 | } | ||
4032 | if (jj_3R_235()) return true; | ||
4033 | return false; | ||
4034 | } | ||
4035 | |||
4036 | private boolean jj_3R_208() { | ||
4037 | if (jj_scan_token(64)) return true; | ||
4038 | if (jj_3R_106()) return true; | ||
4039 | return false; | ||
4040 | } | ||
4041 | |||
4042 | private boolean jj_3R_164() { | ||
4043 | if (jj_scan_token(INT)) return true; | ||
4044 | return false; | ||
4045 | } | ||
4046 | |||
4047 | private boolean jj_3R_181() { | ||
4048 | if (jj_scan_token(FLOATING_POINT_LITERAL)) return true; | ||
4049 | return false; | ||
4050 | } | ||
4051 | |||
4052 | private boolean jj_3R_37() { | ||
4053 | if (jj_scan_token(57)) return true; | ||
4054 | return false; | ||
4055 | } | ||
4056 | |||
4057 | private boolean jj_3R_207() { | ||
4058 | if (jj_3R_124()) return true; | ||
4059 | return false; | ||
4060 | } | ||
4061 | |||
4062 | private boolean jj_3R_178() { | ||
4063 | if (jj_scan_token(INT)) return true; | ||
4064 | return false; | ||
4065 | } | ||
4066 | |||
4067 | private boolean jj_3R_180() { | ||
4068 | if (jj_scan_token(INTEGER_LITERAL)) return true; | ||
4069 | return false; | ||
4070 | } | ||
4071 | |||
4072 | private boolean jj_3R_235() { | ||
4073 | if (jj_3R_33()) return true; | ||
4074 | Token xsp; | ||
4075 | xsp = jj_scanpos; | ||
4076 | if (jj_3R_239()) jj_scanpos = xsp; | ||
4077 | return false; | ||
4078 | } | ||
4079 | |||
4080 | private boolean jj_3R_198() { | ||
4081 | Token xsp; | ||
4082 | xsp = jj_scanpos; | ||
4083 | if (jj_3R_207()) { | ||
4084 | jj_scanpos = xsp; | ||
4085 | if (jj_3R_208()) return true; | ||
4086 | } | ||
4087 | return false; | ||
4088 | } | ||
4089 | |||
4090 | private boolean jj_3R_30() { | ||
4091 | Token xsp; | ||
4092 | xsp = jj_scanpos; | ||
4093 | if (jj_3R_64()) { | ||
4094 | jj_scanpos = xsp; | ||
4095 | if (jj_3R_65()) { | ||
4096 | jj_scanpos = xsp; | ||
4097 | if (jj_3R_66()) { | ||
4098 | jj_scanpos = xsp; | ||
4099 | if (jj_3R_67()) { | ||
4100 | jj_scanpos = xsp; | ||
4101 | if (jj_3R_68()) { | ||
4102 | jj_scanpos = xsp; | ||
4103 | if (jj_3R_69()) { | ||
4104 | jj_scanpos = xsp; | ||
4105 | if (jj_3R_70()) { | ||
4106 | jj_scanpos = xsp; | ||
4107 | if (jj_3R_71()) { | ||
4108 | jj_scanpos = xsp; | ||
4109 | if (jj_3R_72()) { | ||
4110 | jj_scanpos = xsp; | ||
4111 | if (jj_3R_73()) { | ||
4112 | jj_scanpos = xsp; | ||
4113 | if (jj_3R_74()) return true; | ||
4114 | } | ||
4115 | } | ||
4116 | } | ||
4117 | } | ||
4118 | } | ||
4119 | } | ||
4120 | } | ||
4121 | } | ||
4122 | } | ||
4123 | } | ||
4124 | return false; | ||
4125 | } | ||
4126 | |||
4127 | private boolean jj_3R_170() { | ||
4128 | Token xsp; | ||
4129 | xsp = jj_scanpos; | ||
4130 | if (jj_3R_180()) { | ||
4131 | jj_scanpos = xsp; | ||
4132 | if (jj_3R_181()) { | ||
4133 | jj_scanpos = xsp; | ||
4134 | if (jj_3R_182()) { | ||
4135 | jj_scanpos = xsp; | ||
4136 | if (jj_3R_183()) return true; | ||
4137 | } | ||
4138 | } | ||
4139 | } | ||
4140 | return false; | ||
4141 | } | ||
4142 | |||
4143 | private boolean jj_3R_163() { | ||
4144 | if (jj_scan_token(SHORT)) return true; | ||
4145 | Token xsp; | ||
4146 | xsp = jj_scanpos; | ||
4147 | if (jj_3R_178()) jj_scanpos = xsp; | ||
4148 | return false; | ||
4149 | } | ||
4150 | |||
4151 | private boolean jj_3R_144() { | ||
4152 | if (jj_3R_116()) return true; | ||
4153 | return false; | ||
4154 | } | ||
4155 | |||
4156 | private boolean jj_3R_36() { | ||
4157 | if (jj_3R_97()) return true; | ||
4158 | return false; | ||
4159 | } | ||
4160 | |||
4161 | private boolean jj_3R_162() { | ||
4162 | if (jj_scan_token(CHAR)) return true; | ||
4163 | return false; | ||
4164 | } | ||
4165 | |||
4166 | private boolean jj_3R_103() { | ||
4167 | if (jj_3R_32()) return true; | ||
4168 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4169 | Token xsp; | ||
4170 | xsp = jj_scanpos; | ||
4171 | if (jj_3R_198()) jj_scanpos = xsp; | ||
4172 | xsp = jj_scanpos; | ||
4173 | if (jj_3R_199()) jj_scanpos = xsp; | ||
4174 | if (jj_scan_token(57)) return true; | ||
4175 | return false; | ||
4176 | } | ||
4177 | |||
4178 | private boolean jj_3R_107() { | ||
4179 | Token xsp; | ||
4180 | xsp = jj_scanpos; | ||
4181 | if (jj_3R_144()) jj_scanpos = xsp; | ||
4182 | if (jj_scan_token(57)) return true; | ||
4183 | return false; | ||
4184 | } | ||
4185 | |||
4186 | private boolean jj_3R_14() { | ||
4187 | if (jj_3R_32()) return true; | ||
4188 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4189 | if (jj_scan_token(55)) return true; | ||
4190 | Token xsp; | ||
4191 | xsp = jj_scanpos; | ||
4192 | if (jj_3R_36()) jj_scanpos = xsp; | ||
4193 | if (jj_scan_token(56)) return true; | ||
4194 | xsp = jj_scanpos; | ||
4195 | if (jj_3R_37()) { | ||
4196 | jj_scanpos = xsp; | ||
4197 | if (jj_3R_38()) return true; | ||
4198 | } | ||
4199 | return false; | ||
4200 | } | ||
4201 | |||
4202 | private boolean jj_3R_121() { | ||
4203 | Token xsp; | ||
4204 | xsp = jj_scanpos; | ||
4205 | if (jj_3R_162()) { | ||
4206 | jj_scanpos = xsp; | ||
4207 | if (jj_3R_163()) { | ||
4208 | jj_scanpos = xsp; | ||
4209 | if (jj_3R_164()) { | ||
4210 | jj_scanpos = xsp; | ||
4211 | if (jj_3R_165()) return true; | ||
4212 | } | ||
4213 | } | ||
4214 | } | ||
4215 | return false; | ||
4216 | } | ||
4217 | |||
4218 | private boolean jj_3R_120() { | ||
4219 | if (jj_scan_token(UNSIGNED)) return true; | ||
4220 | return false; | ||
4221 | } | ||
4222 | |||
4223 | private boolean jj_3R_119() { | ||
4224 | if (jj_scan_token(SIGNED)) return true; | ||
4225 | return false; | ||
4226 | } | ||
4227 | |||
4228 | private boolean jj_3R_241() { | ||
4229 | if (jj_scan_token(92)) return true; | ||
4230 | return false; | ||
4231 | } | ||
4232 | |||
4233 | private boolean jj_3R_135() { | ||
4234 | if (jj_3R_105()) return true; | ||
4235 | return false; | ||
4236 | } | ||
4237 | |||
4238 | private boolean jj_3R_240() { | ||
4239 | if (jj_scan_token(91)) return true; | ||
4240 | return false; | ||
4241 | } | ||
4242 | |||
4243 | private boolean jj_3R_134() { | ||
4244 | if (jj_3R_172()) return true; | ||
4245 | return false; | ||
4246 | } | ||
4247 | |||
4248 | private boolean jj_3_4() { | ||
4249 | if (jj_3R_17()) return true; | ||
4250 | return false; | ||
4251 | } | ||
4252 | |||
4253 | private boolean jj_3R_53() { | ||
4254 | if (jj_scan_token(DFLT)) return true; | ||
4255 | if (jj_scan_token(64)) return true; | ||
4256 | if (jj_3R_28()) return true; | ||
4257 | return false; | ||
4258 | } | ||
4259 | |||
4260 | private boolean jj_3R_95() { | ||
4261 | Token xsp; | ||
4262 | xsp = jj_scanpos; | ||
4263 | if (jj_3R_134()) { | ||
4264 | jj_scanpos = xsp; | ||
4265 | if (jj_3R_135()) return true; | ||
4266 | } | ||
4267 | return false; | ||
4268 | } | ||
4269 | |||
4270 | private boolean jj_3_3() { | ||
4271 | if (jj_3R_16()) return true; | ||
4272 | return false; | ||
4273 | } | ||
4274 | |||
4275 | private boolean jj_3R_85() { | ||
4276 | Token xsp; | ||
4277 | xsp = jj_scanpos; | ||
4278 | if (jj_3R_119()) { | ||
4279 | jj_scanpos = xsp; | ||
4280 | if (jj_3R_120()) return true; | ||
4281 | } | ||
4282 | xsp = jj_scanpos; | ||
4283 | if (jj_3R_121()) jj_scanpos = xsp; | ||
4284 | return false; | ||
4285 | } | ||
4286 | |||
4287 | private boolean jj_3R_84() { | ||
4288 | if (jj_scan_token(DOUBLE)) return true; | ||
4289 | return false; | ||
4290 | } | ||
4291 | |||
4292 | private boolean jj_3R_236() { | ||
4293 | Token xsp; | ||
4294 | xsp = jj_scanpos; | ||
4295 | if (jj_3R_240()) { | ||
4296 | jj_scanpos = xsp; | ||
4297 | if (jj_3R_241()) return true; | ||
4298 | } | ||
4299 | if (jj_3R_229()) return true; | ||
4300 | return false; | ||
4301 | } | ||
4302 | |||
4303 | private boolean jj_3_2() { | ||
4304 | if (jj_3R_15()) return true; | ||
4305 | return false; | ||
4306 | } | ||
4307 | |||
4308 | private boolean jj_3R_83() { | ||
4309 | if (jj_scan_token(FLOAT)) return true; | ||
4310 | return false; | ||
4311 | } | ||
4312 | |||
4313 | private boolean jj_3_14() { | ||
4314 | if (jj_3R_31()) return true; | ||
4315 | return false; | ||
4316 | } | ||
4317 | |||
4318 | private boolean jj_3_13() { | ||
4319 | if (jj_3R_29()) return true; | ||
4320 | if (jj_3R_30()) return true; | ||
4321 | return false; | ||
4322 | } | ||
4323 | |||
4324 | private boolean jj_3R_141() { | ||
4325 | if (jj_scan_token(63)) return true; | ||
4326 | if (jj_3R_25()) return true; | ||
4327 | return false; | ||
4328 | } | ||
4329 | |||
4330 | private boolean jj_3_1() { | ||
4331 | if (jj_3R_14()) return true; | ||
4332 | return false; | ||
4333 | } | ||
4334 | |||
4335 | private boolean jj_3R_229() { | ||
4336 | if (jj_3R_235()) return true; | ||
4337 | Token xsp; | ||
4338 | xsp = jj_scanpos; | ||
4339 | if (jj_3R_236()) jj_scanpos = xsp; | ||
4340 | return false; | ||
4341 | } | ||
4342 | |||
4343 | private boolean jj_3R_118() { | ||
4344 | if (jj_scan_token(LONG)) return true; | ||
4345 | return false; | ||
4346 | } | ||
4347 | |||
4348 | private boolean jj_3R_52() { | ||
4349 | if (jj_scan_token(CASE)) return true; | ||
4350 | if (jj_3R_106()) return true; | ||
4351 | if (jj_scan_token(64)) return true; | ||
4352 | if (jj_3R_28()) return true; | ||
4353 | return false; | ||
4354 | } | ||
4355 | |||
4356 | private boolean jj_3R_140() { | ||
4357 | if (jj_3R_124()) return true; | ||
4358 | return false; | ||
4359 | } | ||
4360 | |||
4361 | private boolean jj_3R_143() { | ||
4362 | if (jj_3R_29()) return true; | ||
4363 | if (jj_3R_30()) return true; | ||
4364 | if (jj_3R_105()) return true; | ||
4365 | return false; | ||
4366 | } | ||
4367 | |||
4368 | private boolean jj_3R_82() { | ||
4369 | if (jj_scan_token(LONG)) return true; | ||
4370 | Token xsp; | ||
4371 | xsp = jj_scanpos; | ||
4372 | if (jj_3R_118()) jj_scanpos = xsp; | ||
4373 | return false; | ||
4374 | } | ||
4375 | |||
4376 | private boolean jj_3R_100() { | ||
4377 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4378 | Token xsp; | ||
4379 | xsp = jj_scanpos; | ||
4380 | if (jj_3R_140()) jj_scanpos = xsp; | ||
4381 | xsp = jj_scanpos; | ||
4382 | if (jj_3R_141()) jj_scanpos = xsp; | ||
4383 | return false; | ||
4384 | } | ||
4385 | |||
4386 | private boolean jj_3R_96() { | ||
4387 | if (jj_scan_token(59)) return true; | ||
4388 | if (jj_3R_95()) return true; | ||
4389 | return false; | ||
4390 | } | ||
4391 | |||
4392 | private boolean jj_3R_51() { | ||
4393 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4394 | if (jj_scan_token(64)) return true; | ||
4395 | if (jj_3R_28()) return true; | ||
4396 | return false; | ||
4397 | } | ||
4398 | |||
4399 | private boolean jj_3R_81() { | ||
4400 | if (jj_scan_token(INT)) return true; | ||
4401 | return false; | ||
4402 | } | ||
4403 | |||
4404 | private boolean jj_3R_105() { | ||
4405 | Token xsp; | ||
4406 | xsp = jj_scanpos; | ||
4407 | if (jj_3R_143()) { | ||
4408 | jj_scanpos = xsp; | ||
4409 | if (jj_3_14()) return true; | ||
4410 | } | ||
4411 | return false; | ||
4412 | } | ||
4413 | |||
4414 | private boolean jj_3R_35() { | ||
4415 | if (jj_3R_95()) return true; | ||
4416 | Token xsp; | ||
4417 | while (true) { | ||
4418 | xsp = jj_scanpos; | ||
4419 | if (jj_3R_96()) { jj_scanpos = xsp; break; } | ||
4420 | } | ||
4421 | return false; | ||
4422 | } | ||
4423 | |||
4424 | private boolean jj_3R_117() { | ||
4425 | if (jj_scan_token(INT)) return true; | ||
4426 | return false; | ||
4427 | } | ||
4428 | |||
4429 | private boolean jj_3R_26() { | ||
4430 | Token xsp; | ||
4431 | xsp = jj_scanpos; | ||
4432 | if (jj_3R_51()) { | ||
4433 | jj_scanpos = xsp; | ||
4434 | if (jj_3R_52()) { | ||
4435 | jj_scanpos = xsp; | ||
4436 | if (jj_3R_53()) return true; | ||
4437 | } | ||
4438 | } | ||
4439 | return false; | ||
4440 | } | ||
4441 | |||
4442 | private boolean jj_3R_238() { | ||
4443 | if (jj_scan_token(90)) return true; | ||
4444 | return false; | ||
4445 | } | ||
4446 | |||
4447 | private boolean jj_3R_80() { | ||
4448 | if (jj_scan_token(SHORT)) return true; | ||
4449 | Token xsp; | ||
4450 | xsp = jj_scanpos; | ||
4451 | if (jj_3R_117()) jj_scanpos = xsp; | ||
4452 | return false; | ||
4453 | } | ||
4454 | |||
4455 | private boolean jj_3R_237() { | ||
4456 | if (jj_scan_token(89)) return true; | ||
4457 | return false; | ||
4458 | } | ||
4459 | |||
4460 | private boolean jj_3R_79() { | ||
4461 | if (jj_scan_token(CHAR)) return true; | ||
4462 | return false; | ||
4463 | } | ||
4464 | |||
4465 | private boolean jj_3R_78() { | ||
4466 | if (jj_scan_token(VOID)) return true; | ||
4467 | return false; | ||
4468 | } | ||
4469 | |||
4470 | private boolean jj_3R_101() { | ||
4471 | if (jj_scan_token(59)) return true; | ||
4472 | if (jj_3R_100()) return true; | ||
4473 | return false; | ||
4474 | } | ||
4475 | |||
4476 | private boolean jj_3R_230() { | ||
4477 | Token xsp; | ||
4478 | xsp = jj_scanpos; | ||
4479 | if (jj_3R_237()) { | ||
4480 | jj_scanpos = xsp; | ||
4481 | if (jj_3R_238()) return true; | ||
4482 | } | ||
4483 | if (jj_3R_221()) return true; | ||
4484 | return false; | ||
4485 | } | ||
4486 | |||
4487 | private boolean jj_3R_184() { | ||
4488 | if (jj_scan_token(59)) return true; | ||
4489 | if (jj_3R_105()) return true; | ||
4490 | return false; | ||
4491 | } | ||
4492 | |||
4493 | private boolean jj_3R_77() { | ||
4494 | if (jj_scan_token(CONST)) return true; | ||
4495 | return false; | ||
4496 | } | ||
4497 | |||
4498 | private boolean jj_3R_127() { | ||
4499 | if (jj_scan_token(55)) return true; | ||
4500 | if (jj_3R_116()) return true; | ||
4501 | if (jj_scan_token(56)) return true; | ||
4502 | return false; | ||
4503 | } | ||
4504 | |||
4505 | private boolean jj_3R_41() { | ||
4506 | if (jj_3R_100()) return true; | ||
4507 | Token xsp; | ||
4508 | while (true) { | ||
4509 | xsp = jj_scanpos; | ||
4510 | if (jj_3R_101()) { jj_scanpos = xsp; break; } | ||
4511 | } | ||
4512 | return false; | ||
4513 | } | ||
4514 | |||
4515 | private boolean jj_3R_221() { | ||
4516 | if (jj_3R_229()) return true; | ||
4517 | Token xsp; | ||
4518 | xsp = jj_scanpos; | ||
4519 | if (jj_3R_230()) jj_scanpos = xsp; | ||
4520 | return false; | ||
4521 | } | ||
4522 | |||
4523 | private boolean jj_3R_116() { | ||
4524 | if (jj_3R_105()) return true; | ||
4525 | Token xsp; | ||
4526 | while (true) { | ||
4527 | xsp = jj_scanpos; | ||
4528 | if (jj_3R_184()) { jj_scanpos = xsp; break; } | ||
4529 | } | ||
4530 | return false; | ||
4531 | } | ||
4532 | |||
4533 | private boolean jj_3R_32() { | ||
4534 | Token xsp; | ||
4535 | xsp = jj_scanpos; | ||
4536 | if (jj_3R_77()) jj_scanpos = xsp; | ||
4537 | xsp = jj_scanpos; | ||
4538 | if (jj_3R_78()) { | ||
4539 | jj_scanpos = xsp; | ||
4540 | if (jj_3R_79()) { | ||
4541 | jj_scanpos = xsp; | ||
4542 | if (jj_3R_80()) { | ||
4543 | jj_scanpos = xsp; | ||
4544 | if (jj_3R_81()) { | ||
4545 | jj_scanpos = xsp; | ||
4546 | if (jj_3R_82()) { | ||
4547 | jj_scanpos = xsp; | ||
4548 | if (jj_3R_83()) { | ||
4549 | jj_scanpos = xsp; | ||
4550 | if (jj_3R_84()) { | ||
4551 | jj_scanpos = xsp; | ||
4552 | if (jj_3R_85()) { | ||
4553 | jj_scanpos = xsp; | ||
4554 | if (jj_3R_86()) { | ||
4555 | jj_scanpos = xsp; | ||
4556 | if (jj_3R_87()) { | ||
4557 | jj_scanpos = xsp; | ||
4558 | if (jj_3R_88()) return true; | ||
4559 | } | ||
4560 | } | ||
4561 | } | ||
4562 | } | ||
4563 | } | ||
4564 | } | ||
4565 | } | ||
4566 | } | ||
4567 | } | ||
4568 | } | ||
4569 | xsp = jj_scanpos; | ||
4570 | if (jj_3R_89()) jj_scanpos = xsp; | ||
4571 | xsp = jj_scanpos; | ||
4572 | if (jj_3R_90()) jj_scanpos = xsp; | ||
4573 | return false; | ||
4574 | } | ||
4575 | |||
4576 | private boolean jj_3R_126() { | ||
4577 | if (jj_3R_170()) return true; | ||
4578 | return false; | ||
4579 | } | ||
4580 | |||
4581 | private boolean jj_3R_125() { | ||
4582 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4583 | return false; | ||
4584 | } | ||
4585 | |||
4586 | private boolean jj_3R_93() { | ||
4587 | Token xsp; | ||
4588 | xsp = jj_scanpos; | ||
4589 | if (jj_3R_125()) { | ||
4590 | jj_scanpos = xsp; | ||
4591 | if (jj_3R_126()) { | ||
4592 | jj_scanpos = xsp; | ||
4593 | if (jj_3R_127()) return true; | ||
4594 | } | ||
4595 | } | ||
4596 | return false; | ||
4597 | } | ||
4598 | |||
4599 | private boolean jj_3R_59() { | ||
4600 | if (jj_3R_110()) return true; | ||
4601 | return false; | ||
4602 | } | ||
4603 | |||
4604 | private boolean jj_3R_58() { | ||
4605 | if (jj_3R_109()) return true; | ||
4606 | return false; | ||
4607 | } | ||
4608 | |||
4609 | private boolean jj_3R_57() { | ||
4610 | if (jj_3R_108()) return true; | ||
4611 | return false; | ||
4612 | } | ||
4613 | |||
4614 | private boolean jj_3R_46() { | ||
4615 | if (jj_3R_103()) return true; | ||
4616 | return false; | ||
4617 | } | ||
4618 | |||
4619 | private boolean jj_3R_228() { | ||
4620 | if (jj_3R_116()) return true; | ||
4621 | return false; | ||
4622 | } | ||
4623 | |||
4624 | private boolean jj_3R_56() { | ||
4625 | if (jj_3R_98()) return true; | ||
4626 | return false; | ||
4627 | } | ||
4628 | |||
4629 | private boolean jj_3R_234() { | ||
4630 | if (jj_scan_token(88)) return true; | ||
4631 | return false; | ||
4632 | } | ||
4633 | |||
4634 | private boolean jj_3R_22() { | ||
4635 | Token xsp; | ||
4636 | if (jj_3R_46()) return true; | ||
4637 | while (true) { | ||
4638 | xsp = jj_scanpos; | ||
4639 | if (jj_3R_46()) { jj_scanpos = xsp; break; } | ||
4640 | } | ||
4641 | return false; | ||
4642 | } | ||
4643 | |||
4644 | private boolean jj_3R_55() { | ||
4645 | if (jj_3R_107()) return true; | ||
4646 | return false; | ||
4647 | } | ||
4648 | |||
4649 | private boolean jj_3R_233() { | ||
4650 | if (jj_scan_token(87)) return true; | ||
4651 | return false; | ||
4652 | } | ||
4653 | |||
4654 | private boolean jj_3R_153() { | ||
4655 | if (jj_scan_token(RETURN)) return true; | ||
4656 | Token xsp; | ||
4657 | xsp = jj_scanpos; | ||
4658 | if (jj_3R_228()) jj_scanpos = xsp; | ||
4659 | if (jj_scan_token(57)) return true; | ||
4660 | return false; | ||
4661 | } | ||
4662 | |||
4663 | private boolean jj_3_10() { | ||
4664 | if (jj_3R_26()) return true; | ||
4665 | return false; | ||
4666 | } | ||
4667 | |||
4668 | private boolean jj_3R_232() { | ||
4669 | if (jj_scan_token(86)) return true; | ||
4670 | return false; | ||
4671 | } | ||
4672 | |||
4673 | private boolean jj_3R_133() { | ||
4674 | if (jj_scan_token(96)) return true; | ||
4675 | return false; | ||
4676 | } | ||
4677 | |||
4678 | private boolean jj_3R_231() { | ||
4679 | if (jj_scan_token(85)) return true; | ||
4680 | return false; | ||
4681 | } | ||
4682 | |||
4683 | private boolean jj_3R_152() { | ||
4684 | if (jj_scan_token(BREAK)) return true; | ||
4685 | if (jj_scan_token(57)) return true; | ||
4686 | return false; | ||
4687 | } | ||
4688 | |||
4689 | private boolean jj_3R_45() { | ||
4690 | if (jj_scan_token(UNION)) return true; | ||
4691 | return false; | ||
4692 | } | ||
4693 | |||
4694 | private boolean jj_3R_132() { | ||
4695 | if (jj_scan_token(95)) return true; | ||
4696 | return false; | ||
4697 | } | ||
4698 | |||
4699 | private boolean jj_3R_28() { | ||
4700 | Token xsp; | ||
4701 | xsp = jj_scanpos; | ||
4702 | if (jj_3_10()) { | ||
4703 | jj_scanpos = xsp; | ||
4704 | if (jj_3R_55()) { | ||
4705 | jj_scanpos = xsp; | ||
4706 | if (jj_3R_56()) { | ||
4707 | jj_scanpos = xsp; | ||
4708 | if (jj_3R_57()) { | ||
4709 | jj_scanpos = xsp; | ||
4710 | if (jj_3R_58()) { | ||
4711 | jj_scanpos = xsp; | ||
4712 | if (jj_3R_59()) return true; | ||
4713 | } | ||
4714 | } | ||
4715 | } | ||
4716 | } | ||
4717 | } | ||
4718 | return false; | ||
4719 | } | ||
4720 | |||
4721 | private boolean jj_3R_44() { | ||
4722 | if (jj_scan_token(STRUCT)) return true; | ||
4723 | return false; | ||
4724 | } | ||
4725 | |||
4726 | private boolean jj_3R_222() { | ||
4727 | Token xsp; | ||
4728 | xsp = jj_scanpos; | ||
4729 | if (jj_3R_231()) { | ||
4730 | jj_scanpos = xsp; | ||
4731 | if (jj_3R_232()) { | ||
4732 | jj_scanpos = xsp; | ||
4733 | if (jj_3R_233()) { | ||
4734 | jj_scanpos = xsp; | ||
4735 | if (jj_3R_234()) return true; | ||
4736 | } | ||
4737 | } | ||
4738 | } | ||
4739 | if (jj_3R_217()) return true; | ||
4740 | return false; | ||
4741 | } | ||
4742 | |||
4743 | private boolean jj_3R_151() { | ||
4744 | if (jj_scan_token(CONTINUE)) return true; | ||
4745 | if (jj_scan_token(57)) return true; | ||
4746 | return false; | ||
4747 | } | ||
4748 | |||
4749 | private boolean jj_3R_131() { | ||
4750 | if (jj_scan_token(100)) return true; | ||
4751 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4752 | return false; | ||
4753 | } | ||
4754 | |||
4755 | private boolean jj_3_18() { | ||
4756 | if (jj_3R_35()) return true; | ||
4757 | return false; | ||
4758 | } | ||
4759 | |||
4760 | private boolean jj_3R_20() { | ||
4761 | Token xsp; | ||
4762 | xsp = jj_scanpos; | ||
4763 | if (jj_3R_44()) { | ||
4764 | jj_scanpos = xsp; | ||
4765 | if (jj_3R_45()) return true; | ||
4766 | } | ||
4767 | return false; | ||
4768 | } | ||
4769 | |||
4770 | private boolean jj_3R_217() { | ||
4771 | if (jj_3R_221()) return true; | ||
4772 | Token xsp; | ||
4773 | xsp = jj_scanpos; | ||
4774 | if (jj_3R_222()) jj_scanpos = xsp; | ||
4775 | return false; | ||
4776 | } | ||
4777 | |||
4778 | private boolean jj_3R_130() { | ||
4779 | if (jj_scan_token(99)) return true; | ||
4780 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4781 | return false; | ||
4782 | } | ||
4783 | |||
4784 | private boolean jj_3R_150() { | ||
4785 | if (jj_scan_token(GOTO)) return true; | ||
4786 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4787 | if (jj_scan_token(57)) return true; | ||
4788 | return false; | ||
4789 | } | ||
4790 | |||
4791 | private boolean jj_3R_171() { | ||
4792 | if (jj_3R_35()) return true; | ||
4793 | return false; | ||
4794 | } | ||
4795 | |||
4796 | private boolean jj_3R_169() { | ||
4797 | if (jj_3R_106()) return true; | ||
4798 | return false; | ||
4799 | } | ||
4800 | |||
4801 | private boolean jj_3R_110() { | ||
4802 | Token xsp; | ||
4803 | xsp = jj_scanpos; | ||
4804 | if (jj_3R_150()) { | ||
4805 | jj_scanpos = xsp; | ||
4806 | if (jj_3R_151()) { | ||
4807 | jj_scanpos = xsp; | ||
4808 | if (jj_3R_152()) { | ||
4809 | jj_scanpos = xsp; | ||
4810 | if (jj_3R_153()) return true; | ||
4811 | } | ||
4812 | } | ||
4813 | } | ||
4814 | return false; | ||
4815 | } | ||
4816 | |||
4817 | private boolean jj_3R_124() { | ||
4818 | if (jj_scan_token(65)) return true; | ||
4819 | Token xsp; | ||
4820 | xsp = jj_scanpos; | ||
4821 | if (jj_3R_169()) jj_scanpos = xsp; | ||
4822 | if (jj_scan_token(66)) return true; | ||
4823 | return false; | ||
4824 | } | ||
4825 | |||
4826 | private boolean jj_3R_129() { | ||
4827 | if (jj_scan_token(55)) return true; | ||
4828 | Token xsp; | ||
4829 | xsp = jj_scanpos; | ||
4830 | if (jj_3R_171()) jj_scanpos = xsp; | ||
4831 | if (jj_scan_token(56)) return true; | ||
4832 | return false; | ||
4833 | } | ||
4834 | |||
4835 | private boolean jj_3R_39() { | ||
4836 | if (jj_3R_20()) return true; | ||
4837 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4838 | return false; | ||
4839 | } | ||
4840 | |||
4841 | private boolean jj_3R_224() { | ||
4842 | if (jj_scan_token(84)) return true; | ||
4843 | return false; | ||
4844 | } | ||
4845 | |||
4846 | private boolean jj_3R_128() { | ||
4847 | if (jj_scan_token(65)) return true; | ||
4848 | if (jj_3R_116()) return true; | ||
4849 | if (jj_scan_token(66)) return true; | ||
4850 | return false; | ||
4851 | } | ||
4852 | |||
4853 | private boolean jj_3R_139() { | ||
4854 | if (jj_scan_token(REGISTER)) return true; | ||
4855 | return false; | ||
4856 | } | ||
4857 | |||
4858 | private boolean jj_3R_223() { | ||
4859 | if (jj_scan_token(83)) return true; | ||
4860 | return false; | ||
4861 | } | ||
4862 | |||
4863 | private boolean jj_3R_21() { | ||
4864 | if (jj_scan_token(IDENTIFIER)) return true; | ||
4865 | return false; | ||
4866 | } | ||
4867 | |||
4868 | private boolean jj_3R_138() { | ||
4869 | if (jj_scan_token(AUTO)) return true; | ||
4870 | return false; | ||
4871 | } | ||
4872 | |||
4873 | private boolean jj_3R_94() { | ||
4874 | Token xsp; | ||
4875 | xsp = jj_scanpos; | ||
4876 | if (jj_3R_128()) { | ||
4877 | jj_scanpos = xsp; | ||
4878 | if (jj_3R_129()) { | ||
4879 | jj_scanpos = xsp; | ||
4880 | if (jj_3R_130()) { | ||
4881 | jj_scanpos = xsp; | ||
4882 | if (jj_3R_131()) { | ||
4883 | jj_scanpos = xsp; | ||
4884 | if (jj_3R_132()) { | ||
4885 | jj_scanpos = xsp; | ||
4886 | if (jj_3R_133()) return true; | ||
4887 | } | ||
4888 | } | ||
4889 | } | ||
4890 | } | ||
4891 | } | ||
4892 | return false; | ||
4893 | } | ||
4894 | |||
4895 | private boolean jj_3R_99() { | ||
4896 | Token xsp; | ||
4897 | xsp = jj_scanpos; | ||
4898 | if (jj_3R_138()) { | ||
4899 | jj_scanpos = xsp; | ||
4900 | if (jj_3R_139()) return true; | ||
4901 | } | ||
4902 | return false; | ||
4903 | } | ||
4904 | |||
4905 | private boolean jj_3R_34() { | ||
4906 | if (jj_3R_93()) return true; | ||
4907 | Token xsp; | ||
4908 | while (true) { | ||
4909 | xsp = jj_scanpos; | ||
4910 | if (jj_3R_94()) { jj_scanpos = xsp; break; } | ||
4911 | } | ||
4912 | return false; | ||
4913 | } | ||
4914 | |||
4915 | private boolean jj_3_7() { | ||
4916 | if (jj_3R_20()) return true; | ||
4917 | Token xsp; | ||
4918 | xsp = jj_scanpos; | ||
4919 | if (jj_3R_21()) jj_scanpos = xsp; | ||
4920 | if (jj_scan_token(61)) return true; | ||
4921 | if (jj_3R_22()) return true; | ||
4922 | if (jj_scan_token(62)) return true; | ||
4923 | return false; | ||
4924 | } | ||
4925 | |||
4926 | private boolean jj_3_9() { | ||
4927 | if (jj_scan_token(59)) return true; | ||
4928 | if (jj_3R_25()) return true; | ||
4929 | return false; | ||
4930 | } | ||
4931 | |||
4932 | private boolean jj_3R_218() { | ||
4933 | Token xsp; | ||
4934 | xsp = jj_scanpos; | ||
4935 | if (jj_3R_223()) { | ||
4936 | jj_scanpos = xsp; | ||
4937 | if (jj_3R_224()) return true; | ||
4938 | } | ||
4939 | if (jj_3R_211()) return true; | ||
4940 | return false; | ||
4941 | } | ||
4942 | |||
4943 | private boolean jj_3R_40() { | ||
4944 | Token xsp; | ||
4945 | while (true) { | ||
4946 | xsp = jj_scanpos; | ||
4947 | if (jj_3R_99()) { jj_scanpos = xsp; break; } | ||
4948 | } | ||
4949 | return false; | ||
4950 | } | ||
4951 | |||
4952 | private boolean jj_3R_15() { | ||
4953 | Token xsp; | ||
4954 | xsp = jj_scanpos; | ||
4955 | if (jj_3_7()) { | ||
4956 | jj_scanpos = xsp; | ||
4957 | if (jj_3R_39()) return true; | ||
4958 | } | ||
4959 | return false; | ||
4960 | } | ||
4961 | |||
4962 | private boolean jj_3R_209() { | ||
4963 | if (jj_3R_25()) return true; | ||
4964 | Token xsp; | ||
4965 | while (true) { | ||
4966 | xsp = jj_scanpos; | ||
4967 | if (jj_3_9()) { jj_scanpos = xsp; break; } | ||
4968 | } | ||
4969 | return false; | ||
4970 | } | ||
4971 | |||
4972 | private boolean jj_3R_211() { | ||
4973 | if (jj_3R_217()) return true; | ||
4974 | Token xsp; | ||
4975 | xsp = jj_scanpos; | ||
4976 | if (jj_3R_218()) jj_scanpos = xsp; | ||
4977 | return false; | ||
4978 | } | ||
4979 | |||
4980 | private boolean jj_3R_227() { | ||
4981 | if (jj_3R_116()) return true; | ||
4982 | return false; | ||
4983 | } | ||
4984 | |||
4985 | private boolean jj_3R_54() { | ||
4986 | if (jj_scan_token(STATIC)) return true; | ||
4987 | return false; | ||
4988 | } | ||
4989 | |||
4990 | private boolean jj_3R_226() { | ||
4991 | if (jj_3R_116()) return true; | ||
4992 | return false; | ||
4993 | } | ||
4994 | |||
4995 | private boolean jj_3R_210() { | ||
4996 | if (jj_scan_token(59)) return true; | ||
4997 | return false; | ||
4998 | } | ||
4999 | |||
5000 | private boolean jj_3R_27() { | ||
5001 | Token xsp; | ||
5002 | xsp = jj_scanpos; | ||
5003 | if (jj_3R_54()) jj_scanpos = xsp; | ||
5004 | if (jj_3R_16()) return true; | ||
5005 | return false; | ||
5006 | } | ||
5007 | |||
5008 | private boolean jj_3R_225() { | ||
5009 | if (jj_3R_116()) return true; | ||
5010 | return false; | ||
5011 | } | ||
5012 | |||
5013 | private boolean jj_3R_212() { | ||
5014 | if (jj_scan_token(82)) return true; | ||
5015 | if (jj_3R_200()) return true; | ||
5016 | return false; | ||
5017 | } | ||
5018 | |||
5019 | private boolean jj_3R_197() { | ||
5020 | if (jj_3R_124()) return true; | ||
5021 | return false; | ||
5022 | } | ||
5023 | |||
5024 | private boolean jj_3R_50() { | ||
5025 | if (jj_scan_token(61)) return true; | ||
5026 | if (jj_3R_209()) return true; | ||
5027 | Token xsp; | ||
5028 | xsp = jj_scanpos; | ||
5029 | if (jj_3R_210()) jj_scanpos = xsp; | ||
5030 | if (jj_scan_token(62)) return true; | ||
5031 | return false; | ||
5032 | } | ||
5033 | |||
5034 | private boolean jj_3R_196() { | ||
5035 | if (jj_3R_123()) return true; | ||
5036 | return false; | ||
5037 | } | ||
5038 | |||
5039 | private boolean jj_3R_200() { | ||
5040 | if (jj_3R_211()) return true; | ||
5041 | Token xsp; | ||
5042 | xsp = jj_scanpos; | ||
5043 | if (jj_3R_212()) jj_scanpos = xsp; | ||
5044 | return false; | ||
5045 | } | ||
5046 | |||
5047 | private boolean jj_3R_49() { | ||
5048 | if (jj_3R_105()) return true; | ||
5049 | return false; | ||
5050 | } | ||
5051 | |||
5052 | private boolean jj_3R_195() { | ||
5053 | if (jj_3R_122()) return true; | ||
5054 | return false; | ||
5055 | } | ||
5056 | |||
5057 | private boolean jj_3R_159() { | ||
5058 | if (jj_scan_token(98)) return true; | ||
5059 | return false; | ||
5060 | } | ||
5061 | |||
5062 | private boolean jj_3R_149() { | ||
5063 | if (jj_scan_token(FOR)) return true; | ||
5064 | if (jj_scan_token(55)) return true; | ||
5065 | Token xsp; | ||
5066 | xsp = jj_scanpos; | ||
5067 | if (jj_3R_225()) jj_scanpos = xsp; | ||
5068 | if (jj_scan_token(57)) return true; | ||
5069 | xsp = jj_scanpos; | ||
5070 | if (jj_3R_226()) jj_scanpos = xsp; | ||
5071 | if (jj_scan_token(57)) return true; | ||
5072 | xsp = jj_scanpos; | ||
5073 | if (jj_3R_227()) jj_scanpos = xsp; | ||
5074 | if (jj_scan_token(56)) return true; | ||
5075 | if (jj_3R_28()) return true; | ||
5076 | return false; | ||
5077 | } | ||
5078 | |||
5079 | private boolean jj_3R_194() { | ||
5080 | if (jj_3R_15()) return true; | ||
5081 | return false; | ||
5082 | } | ||
5083 | |||
5084 | private boolean jj_3R_220() { | ||
5085 | if (jj_scan_token(LONG)) return true; | ||
5086 | return false; | ||
5087 | } | ||
5088 | |||
5089 | private boolean jj_3R_158() { | ||
5090 | if (jj_scan_token(97)) return true; | ||
5091 | return false; | ||
5092 | } | ||
5093 | |||
5094 | private boolean jj_3R_16() { | ||
5095 | if (jj_3R_40()) return true; | ||
5096 | if (jj_3R_32()) return true; | ||
5097 | if (jj_3R_41()) return true; | ||
5098 | if (jj_scan_token(57)) return true; | ||
5099 | return false; | ||
5100 | } | ||
5101 | |||
5102 | private boolean jj_3R_25() { | ||
5103 | Token xsp; | ||
5104 | xsp = jj_scanpos; | ||
5105 | if (jj_3R_49()) { | ||
5106 | jj_scanpos = xsp; | ||
5107 | if (jj_3R_50()) return true; | ||
5108 | } | ||
5109 | return false; | ||
5110 | } | ||
5111 | |||
5112 | private boolean jj_3R_157() { | ||
5113 | if (jj_scan_token(92)) return true; | ||
5114 | return false; | ||
5115 | } | ||
5116 | |||
5117 | private boolean jj_3R_156() { | ||
5118 | if (jj_scan_token(91)) return true; | ||
5119 | return false; | ||
5120 | } | ||
5121 | |||
5122 | private boolean jj_3R_216() { | ||
5123 | if (jj_scan_token(LONG)) return true; | ||
5124 | Token xsp; | ||
5125 | xsp = jj_scanpos; | ||
5126 | if (jj_3R_220()) jj_scanpos = xsp; | ||
5127 | return false; | ||
5128 | } | ||
5129 | |||
5130 | private boolean jj_3R_155() { | ||
5131 | if (jj_scan_token(58)) return true; | ||
5132 | return false; | ||
5133 | } | ||
5134 | |||
5135 | private boolean jj_3R_215() { | ||
5136 | if (jj_scan_token(INT)) return true; | ||
5137 | return false; | ||
5138 | } | ||
5139 | |||
5140 | private boolean jj_3R_154() { | ||
5141 | if (jj_scan_token(82)) return true; | ||
5142 | return false; | ||
5143 | } | ||
5144 | |||
5145 | private boolean jj_3R_219() { | ||
5146 | if (jj_scan_token(INT)) return true; | ||
5147 | return false; | ||
5148 | } | ||
5149 | |||
5150 | private boolean jj_3R_201() { | ||
5151 | if (jj_scan_token(81)) return true; | ||
5152 | if (jj_3R_176()) return true; | ||
5153 | return false; | ||
5154 | } | ||
5155 | |||
5156 | private boolean jj_3R_148() { | ||
5157 | if (jj_scan_token(DO)) return true; | ||
5158 | if (jj_3R_28()) return true; | ||
5159 | if (jj_scan_token(WHILE)) return true; | ||
5160 | if (jj_scan_token(55)) return true; | ||
5161 | if (jj_3R_116()) return true; | ||
5162 | if (jj_scan_token(56)) return true; | ||
5163 | if (jj_scan_token(57)) return true; | ||
5164 | return false; | ||
5165 | } | ||
5166 | |||
5167 | private boolean jj_3R_173() { | ||
5168 | if (jj_3R_124()) return true; | ||
5169 | return false; | ||
5170 | } | ||
5171 | |||
5172 | private boolean jj_3R_176() { | ||
5173 | if (jj_3R_200()) return true; | ||
5174 | Token xsp; | ||
5175 | xsp = jj_scanpos; | ||
5176 | if (jj_3R_201()) jj_scanpos = xsp; | ||
5177 | return false; | ||
5178 | } | ||
5179 | |||
5180 | private boolean jj_3R_214() { | ||
5181 | if (jj_scan_token(SHORT)) return true; | ||
5182 | Token xsp; | ||
5183 | xsp = jj_scanpos; | ||
5184 | if (jj_3R_219()) jj_scanpos = xsp; | ||
5185 | return false; | ||
5186 | } | ||
5187 | |||
5188 | private boolean jj_3R_111() { | ||
5189 | Token xsp; | ||
5190 | xsp = jj_scanpos; | ||
5191 | if (jj_3R_154()) { | ||
5192 | jj_scanpos = xsp; | ||
5193 | if (jj_3R_155()) { | ||
5194 | jj_scanpos = xsp; | ||
5195 | if (jj_3R_156()) { | ||
5196 | jj_scanpos = xsp; | ||
5197 | if (jj_3R_157()) { | ||
5198 | jj_scanpos = xsp; | ||
5199 | if (jj_3R_158()) { | ||
5200 | jj_scanpos = xsp; | ||
5201 | if (jj_3R_159()) return true; | ||
5202 | } | ||
5203 | } | ||
5204 | } | ||
5205 | } | ||
5206 | } | ||
5207 | return false; | ||
5208 | } | ||
5209 | |||
5210 | private boolean jj_3R_19() { | ||
5211 | if (jj_3R_32()) return true; | ||
5212 | if (jj_scan_token(IDENTIFIER)) return true; | ||
5213 | Token xsp; | ||
5214 | xsp = jj_scanpos; | ||
5215 | if (jj_3R_173()) jj_scanpos = xsp; | ||
5216 | return false; | ||
5217 | } | ||
5218 | |||
5219 | private boolean jj_3R_213() { | ||
5220 | if (jj_scan_token(CHAR)) return true; | ||
5221 | return false; | ||
5222 | } | ||
5223 | |||
5224 | private boolean jj_3R_147() { | ||
5225 | if (jj_scan_token(WHILE)) return true; | ||
5226 | if (jj_scan_token(55)) return true; | ||
5227 | if (jj_3R_116()) return true; | ||
5228 | if (jj_scan_token(56)) return true; | ||
5229 | if (jj_3R_28()) return true; | ||
5230 | return false; | ||
5231 | } | ||
5232 | |||
5233 | private boolean jj_3R_206() { | ||
5234 | Token xsp; | ||
5235 | xsp = jj_scanpos; | ||
5236 | if (jj_3R_213()) { | ||
5237 | jj_scanpos = xsp; | ||
5238 | if (jj_3R_214()) { | ||
5239 | jj_scanpos = xsp; | ||
5240 | if (jj_3R_215()) { | ||
5241 | jj_scanpos = xsp; | ||
5242 | if (jj_3R_216()) return true; | ||
5243 | } | ||
5244 | } | ||
5245 | } | ||
5246 | return false; | ||
5247 | } | ||
5248 | |||
5249 | private boolean jj_3R_205() { | ||
5250 | if (jj_scan_token(UNSIGNED)) return true; | ||
5251 | return false; | ||
5252 | } | ||
5253 | |||
5254 | private boolean jj_3R_109() { | ||
5255 | Token xsp; | ||
5256 | xsp = jj_scanpos; | ||
5257 | if (jj_3R_147()) { | ||
5258 | jj_scanpos = xsp; | ||
5259 | if (jj_3R_148()) { | ||
5260 | jj_scanpos = xsp; | ||
5261 | if (jj_3R_149()) return true; | ||
5262 | } | ||
5263 | } | ||
5264 | return false; | ||
5265 | } | ||
5266 | |||
5267 | private boolean jj_3R_204() { | ||
5268 | if (jj_scan_token(SIGNED)) return true; | ||
5269 | return false; | ||
5270 | } | ||
5271 | |||
5272 | private boolean jj_3R_177() { | ||
5273 | if (jj_scan_token(80)) return true; | ||
5274 | if (jj_3R_160()) return true; | ||
5275 | return false; | ||
5276 | } | ||
5277 | |||
5278 | private boolean jj_3R_136() { | ||
5279 | if (jj_scan_token(59)) return true; | ||
5280 | if (jj_scan_token(60)) return true; | ||
5281 | return false; | ||
5282 | } | ||
5283 | |||
5284 | private boolean jj_3_16() { | ||
5285 | if (jj_3R_29()) return true; | ||
5286 | return false; | ||
5287 | } | ||
5288 | |||
5289 | private boolean jj_3R_160() { | ||
5290 | if (jj_3R_176()) return true; | ||
5291 | Token xsp; | ||
5292 | xsp = jj_scanpos; | ||
5293 | if (jj_3R_177()) jj_scanpos = xsp; | ||
5294 | return false; | ||
5295 | } | ||
5296 | |||
5297 | private boolean jj_3R_193() { | ||
5298 | Token xsp; | ||
5299 | xsp = jj_scanpos; | ||
5300 | if (jj_3R_204()) { | ||
5301 | jj_scanpos = xsp; | ||
5302 | if (jj_3R_205()) return true; | ||
5303 | } | ||
5304 | xsp = jj_scanpos; | ||
5305 | if (jj_3R_206()) jj_scanpos = xsp; | ||
5306 | return false; | ||
5307 | } | ||
5308 | |||
5309 | /** Generated Token Manager. */ | ||
5310 | public CParserTokenManager token_source; | ||
5311 | SimpleCharStream jj_input_stream; | ||
5312 | /** Current token. */ | ||
5313 | public Token token; | ||
5314 | /** Next token. */ | ||
5315 | public Token jj_nt; | ||
5316 | private int jj_ntk; | ||
5317 | private Token jj_scanpos, jj_lastpos; | ||
5318 | private int jj_la; | ||
5319 | private int jj_gen; | ||
5320 | final private int[] jj_la1 = new int[94]; | ||
5321 | static private int[] jj_la1_0; | ||
5322 | static private int[] jj_la1_1; | ||
5323 | static private int[] jj_la1_2; | ||
5324 | static private int[] jj_la1_3; | ||
5325 | static { | ||
5326 | jj_la1_init_0(); | ||
5327 | jj_la1_init_1(); | ||
5328 | jj_la1_init_2(); | ||
5329 | jj_la1_init_3(); | ||
5330 | } | ||
5331 | private static void jj_la1_init_0() { | ||
5332 | 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,}; | ||
5333 | } | ||
5334 | private static void jj_la1_init_1() { | ||
5335 | 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,}; | ||
5336 | } | ||
5337 | private static void jj_la1_init_2() { | ||
5338 | 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,}; | ||
5339 | } | ||
5340 | private static void jj_la1_init_3() { | ||
5341 | 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,}; | ||
5342 | } | ||
5343 | final private JJCalls[] jj_2_rtns = new JJCalls[18]; | ||
5344 | private boolean jj_rescan = false; | ||
5345 | private int jj_gc = 0; | ||
5346 | |||
5347 | /** Constructor with InputStream. */ | ||
5348 | public GNUnetParser(java.io.InputStream stream) { | ||
5349 | this(stream, null); | ||
5350 | } | ||
5351 | /** Constructor with InputStream and supplied encoding */ | ||
5352 | public GNUnetParser(java.io.InputStream stream, String encoding) { | ||
5353 | try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } | ||
5354 | token_source = new CParserTokenManager(jj_input_stream); | ||
5355 | token = new Token(); | ||
5356 | jj_ntk = -1; | ||
5357 | jj_gen = 0; | ||
5358 | for (int i = 0; i < 94; i++) jj_la1[i] = -1; | ||
5359 | for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); | ||
5360 | } | ||
5361 | |||
5362 | /** Reinitialise. */ | ||
5363 | public void ReInit(java.io.InputStream stream) { | ||
5364 | ReInit(stream, null); | ||
5365 | } | ||
5366 | /** Reinitialise. */ | ||
5367 | public void ReInit(java.io.InputStream stream, String encoding) { | ||
5368 | try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } | ||
5369 | token_source.ReInit(jj_input_stream); | ||
5370 | token = new Token(); | ||
5371 | jj_ntk = -1; | ||
5372 | jj_gen = 0; | ||
5373 | for (int i = 0; i < 94; i++) jj_la1[i] = -1; | ||
5374 | for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); | ||
5375 | } | ||
5376 | |||
5377 | /** Constructor. */ | ||
5378 | public GNUnetParser(java.io.Reader stream) { | ||
5379 | jj_input_stream = new SimpleCharStream(stream, 1, 1); | ||
5380 | token_source = new CParserTokenManager(jj_input_stream); | ||
5381 | token = new Token(); | ||
5382 | jj_ntk = -1; | ||
5383 | jj_gen = 0; | ||
5384 | for (int i = 0; i < 94; i++) jj_la1[i] = -1; | ||
5385 | for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); | ||
5386 | } | ||
5387 | |||
5388 | /** Reinitialise. */ | ||
5389 | public void ReInit(java.io.Reader stream) { | ||
5390 | jj_input_stream.ReInit(stream, 1, 1); | ||
5391 | token_source.ReInit(jj_input_stream); | ||
5392 | token = new Token(); | ||
5393 | jj_ntk = -1; | ||
5394 | jj_gen = 0; | ||
5395 | for (int i = 0; i < 94; i++) jj_la1[i] = -1; | ||
5396 | for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); | ||
5397 | } | ||
5398 | |||
5399 | /** Constructor with generated Token Manager. */ | ||
5400 | public GNUnetParser(CParserTokenManager tm) { | ||
5401 | token_source = tm; | ||
5402 | token = new Token(); | ||
5403 | jj_ntk = -1; | ||
5404 | jj_gen = 0; | ||
5405 | for (int i = 0; i < 94; i++) jj_la1[i] = -1; | ||
5406 | for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); | ||
5407 | } | ||
5408 | |||
5409 | /** Reinitialise. */ | ||
5410 | public void ReInit(CParserTokenManager tm) { | ||
5411 | token_source = tm; | ||
5412 | token = new Token(); | ||
5413 | jj_ntk = -1; | ||
5414 | jj_gen = 0; | ||
5415 | for (int i = 0; i < 94; i++) jj_la1[i] = -1; | ||
5416 | for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); | ||
5417 | } | ||
5418 | |||
5419 | private Token jj_consume_token(int kind) throws ParseException { | ||
5420 | Token oldToken; | ||
5421 | if ((oldToken = token).next != null) token = token.next; | ||
5422 | else token = token.next = token_source.getNextToken(); | ||
5423 | jj_ntk = -1; | ||
5424 | if (token.kind == kind) { | ||
5425 | jj_gen++; | ||
5426 | if (++jj_gc > 100) { | ||
5427 | jj_gc = 0; | ||
5428 | for (int i = 0; i < jj_2_rtns.length; i++) { | ||
5429 | JJCalls c = jj_2_rtns[i]; | ||
5430 | while (c != null) { | ||
5431 | if (c.gen < jj_gen) c.first = null; | ||
5432 | c = c.next; | ||
5433 | } | ||
5434 | } | ||
5435 | } | ||
5436 | return token; | ||
5437 | } | ||
5438 | token = oldToken; | ||
5439 | jj_kind = kind; | ||
5440 | throw generateParseException(); | ||
5441 | } | ||
5442 | |||
5443 | static private final class LookaheadSuccess extends java.lang.Error { } | ||
5444 | final private LookaheadSuccess jj_ls = new LookaheadSuccess(); | ||
5445 | private boolean jj_scan_token(int kind) { | ||
5446 | if (jj_scanpos == jj_lastpos) { | ||
5447 | jj_la--; | ||
5448 | if (jj_scanpos.next == null) { | ||
5449 | jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken(); | ||
5450 | } else { | ||
5451 | jj_lastpos = jj_scanpos = jj_scanpos.next; | ||
5452 | } | ||
5453 | } else { | ||
5454 | jj_scanpos = jj_scanpos.next; | ||
5455 | } | ||
5456 | if (jj_rescan) { | ||
5457 | int i = 0; Token tok = token; | ||
5458 | while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; } | ||
5459 | if (tok != null) jj_add_error_token(kind, i); | ||
5460 | } | ||
5461 | if (jj_scanpos.kind != kind) return true; | ||
5462 | if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls; | ||
5463 | return false; | ||
5464 | } | ||
5465 | |||
5466 | |||
5467 | /** Get the next Token. */ | ||
5468 | final public Token getNextToken() { | ||
5469 | if (token.next != null) token = token.next; | ||
5470 | else token = token.next = token_source.getNextToken(); | ||
5471 | jj_ntk = -1; | ||
5472 | jj_gen++; | ||
5473 | return token; | ||
5474 | } | ||
5475 | |||
5476 | /** Get the specific Token. */ | ||
5477 | final public Token getToken(int index) { | ||
5478 | Token t = token; | ||
5479 | for (int i = 0; i < index; i++) { | ||
5480 | if (t.next != null) t = t.next; | ||
5481 | else t = t.next = token_source.getNextToken(); | ||
5482 | } | ||
5483 | return t; | ||
5484 | } | ||
5485 | |||
5486 | private int jj_ntk() { | ||
5487 | if ((jj_nt=token.next) == null) | ||
5488 | return (jj_ntk = (token.next=token_source.getNextToken()).kind); | ||
5489 | else | ||
5490 | return (jj_ntk = jj_nt.kind); | ||
5491 | } | ||
5492 | |||
5493 | private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>(); | ||
5494 | private int[] jj_expentry; | ||
5495 | private int jj_kind = -1; | ||
5496 | private int[] jj_lasttokens = new int[100]; | ||
5497 | private int jj_endpos; | ||
5498 | |||
5499 | private void jj_add_error_token(int kind, int pos) { | ||
5500 | if (pos >= 100) return; | ||
5501 | if (pos == jj_endpos + 1) { | ||
5502 | jj_lasttokens[jj_endpos++] = kind; | ||
5503 | } else if (jj_endpos != 0) { | ||
5504 | jj_expentry = new int[jj_endpos]; | ||
5505 | for (int i = 0; i < jj_endpos; i++) { | ||
5506 | jj_expentry[i] = jj_lasttokens[i]; | ||
5507 | } | ||
5508 | jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) { | ||
5509 | int[] oldentry = (int[])(it.next()); | ||
5510 | if (oldentry.length == jj_expentry.length) { | ||
5511 | for (int i = 0; i < jj_expentry.length; i++) { | ||
5512 | if (oldentry[i] != jj_expentry[i]) { | ||
5513 | continue jj_entries_loop; | ||
5514 | } | ||
5515 | } | ||
5516 | jj_expentries.add(jj_expentry); | ||
5517 | break jj_entries_loop; | ||
5518 | } | ||
5519 | } | ||
5520 | if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind; | ||
5521 | } | ||
5522 | } | ||
5523 | |||
5524 | /** Generate ParseException. */ | ||
5525 | public ParseException generateParseException() { | ||
5526 | jj_expentries.clear(); | ||
5527 | boolean[] la1tokens = new boolean[101]; | ||
5528 | if (jj_kind >= 0) { | ||
5529 | la1tokens[jj_kind] = true; | ||
5530 | jj_kind = -1; | ||
5531 | } | ||
5532 | for (int i = 0; i < 94; i++) { | ||
5533 | if (jj_la1[i] == jj_gen) { | ||
5534 | for (int j = 0; j < 32; j++) { | ||
5535 | if ((jj_la1_0[i] & (1<<j)) != 0) { | ||
5536 | la1tokens[j] = true; | ||
5537 | } | ||
5538 | if ((jj_la1_1[i] & (1<<j)) != 0) { | ||
5539 | la1tokens[32+j] = true; | ||
5540 | } | ||
5541 | if ((jj_la1_2[i] & (1<<j)) != 0) { | ||
5542 | la1tokens[64+j] = true; | ||
5543 | } | ||
5544 | if ((jj_la1_3[i] & (1<<j)) != 0) { | ||
5545 | la1tokens[96+j] = true; | ||
5546 | } | ||
5547 | } | ||
5548 | } | ||
5549 | } | ||
5550 | for (int i = 0; i < 101; i++) { | ||
5551 | if (la1tokens[i]) { | ||
5552 | jj_expentry = new int[1]; | ||
5553 | jj_expentry[0] = i; | ||
5554 | jj_expentries.add(jj_expentry); | ||
5555 | } | ||
5556 | } | ||
5557 | jj_endpos = 0; | ||
5558 | jj_rescan_token(); | ||
5559 | jj_add_error_token(0, 0); | ||
5560 | int[][] exptokseq = new int[jj_expentries.size()][]; | ||
5561 | for (int i = 0; i < jj_expentries.size(); i++) { | ||
5562 | exptokseq[i] = jj_expentries.get(i); | ||
5563 | } | ||
5564 | return new ParseException(token, exptokseq, tokenImage); | ||
5565 | } | ||
5566 | |||
5567 | /** Enable tracing. */ | ||
5568 | final public void enable_tracing() { | ||
5569 | } | ||
5570 | |||
5571 | /** Disable tracing. */ | ||
5572 | final public void disable_tracing() { | ||
5573 | } | ||
5574 | |||
5575 | private void jj_rescan_token() { | ||
5576 | jj_rescan = true; | ||
5577 | for (int i = 0; i < 18; i++) { | ||
5578 | try { | ||
5579 | JJCalls p = jj_2_rtns[i]; | ||
5580 | do { | ||
5581 | if (p.gen > jj_gen) { | ||
5582 | jj_la = p.arg; jj_lastpos = jj_scanpos = p.first; | ||
5583 | switch (i) { | ||
5584 | case 0: jj_3_1(); break; | ||
5585 | case 1: jj_3_2(); break; | ||
5586 | case 2: jj_3_3(); break; | ||
5587 | case 3: jj_3_4(); break; | ||
5588 | case 4: jj_3_5(); break; | ||
5589 | case 5: jj_3_6(); break; | ||
5590 | case 6: jj_3_7(); break; | ||
5591 | case 7: jj_3_8(); break; | ||
5592 | case 8: jj_3_9(); break; | ||
5593 | case 9: jj_3_10(); break; | ||
5594 | case 10: jj_3_11(); break; | ||
5595 | case 11: jj_3_12(); break; | ||
5596 | case 12: jj_3_13(); break; | ||
5597 | case 13: jj_3_14(); break; | ||
5598 | case 14: jj_3_15(); break; | ||
5599 | case 15: jj_3_16(); break; | ||
5600 | case 16: jj_3_17(); break; | ||
5601 | case 17: jj_3_18(); break; | ||
5602 | } | ||
5603 | } | ||
5604 | p = p.next; | ||
5605 | } while (p != null); | ||
5606 | } catch(LookaheadSuccess ls) { } | ||
5607 | } | ||
5608 | jj_rescan = false; | ||
5609 | } | ||
5610 | |||
5611 | private void jj_save(int index, int xla) { | ||
5612 | JJCalls p = jj_2_rtns[index]; | ||
5613 | while (p.gen > jj_gen) { | ||
5614 | if (p.next == null) { p = p.next = new JJCalls(); break; } | ||
5615 | p = p.next; | ||
5616 | } | ||
5617 | p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla; | ||
5618 | } | ||
5619 | |||
5620 | static final class JJCalls { | ||
5621 | int gen; | ||
5622 | Token first; | ||
5623 | int arg; | ||
5624 | JJCalls next; | ||
5625 | } | ||
5626 | |||
5627 | } | ||
5628 | |||
5629 | class JTBToolkit { | ||
5630 | static NodeToken makeNodeToken(Token t) { | ||
5631 | return new NodeToken(t.image.intern(), t.kind, t.beginLine, t.beginColumn, t.endLine, t.endColumn); | ||
5632 | } | ||
5633 | } | ||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/ParseException.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/ParseException.java new file mode 100644 index 000000000..44162fe6e --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/ParseException.java | |||
@@ -0,0 +1,186 @@ | |||
1 | package org.gnunet.seaspider.parser; | ||
2 | /* Generated By:JavaCC: Do not edit this line. ParseException.java Version 5.0 */ | ||
3 | /* JavaCCOptions:KEEP_LINE_COL=null */ | ||
4 | /** | ||
5 | * This exception is thrown when parse errors are encountered. | ||
6 | * You can explicitly create objects of this exception type by | ||
7 | * calling the method generateParseException in the generated | ||
8 | * parser. | ||
9 | * | ||
10 | * You can modify this class to customize your error reporting | ||
11 | * mechanisms so long as you retain the public fields. | ||
12 | */ | ||
13 | public class ParseException extends Exception { | ||
14 | |||
15 | /** | ||
16 | * The version identifier for this Serializable class. | ||
17 | * Increment only if the <i>serialized</i> form of the | ||
18 | * class changes. | ||
19 | */ | ||
20 | private static final long serialVersionUID = 1L; | ||
21 | |||
22 | /** | ||
23 | * This constructor is used by the method "generateParseException" | ||
24 | * in the generated parser. Calling this constructor generates | ||
25 | * a new object of this type with the fields "currentToken", | ||
26 | * "expectedTokenSequences", and "tokenImage" set. | ||
27 | */ | ||
28 | public ParseException(Token currentTokenVal, | ||
29 | int[][] expectedTokenSequencesVal, | ||
30 | String[] tokenImageVal | ||
31 | ) | ||
32 | { | ||
33 | super(initialise(currentTokenVal, expectedTokenSequencesVal, tokenImageVal)); | ||
34 | currentToken = currentTokenVal; | ||
35 | expectedTokenSequences = expectedTokenSequencesVal; | ||
36 | tokenImage = tokenImageVal; | ||
37 | } | ||
38 | |||
39 | /** | ||
40 | * The following constructors are for use by you for whatever | ||
41 | * purpose you can think of. Constructing the exception in this | ||
42 | * manner makes the exception behave in the normal way - i.e., as | ||
43 | * documented in the class "Throwable". The fields "errorToken", | ||
44 | * "expectedTokenSequences", and "tokenImage" do not contain | ||
45 | * relevant information. The JavaCC generated code does not use | ||
46 | * these constructors. | ||
47 | */ | ||
48 | |||
49 | public ParseException() { | ||
50 | super(); | ||
51 | } | ||
52 | |||
53 | /** Constructor with message. */ | ||
54 | public ParseException(String message) { | ||
55 | super(message); | ||
56 | } | ||
57 | |||
58 | |||
59 | /** | ||
60 | * This is the last token that has been consumed successfully. If | ||
61 | * this object has been created due to a parse error, the token | ||
62 | * followng this token will (therefore) be the first error token. | ||
63 | */ | ||
64 | public Token currentToken; | ||
65 | |||
66 | /** | ||
67 | * Each entry in this array is an array of integers. Each array | ||
68 | * of integers represents a sequence of tokens (by their ordinal | ||
69 | * values) that is expected at this point of the parse. | ||
70 | */ | ||
71 | public int[][] expectedTokenSequences; | ||
72 | |||
73 | /** | ||
74 | * This is a reference to the "tokenImage" array of the generated | ||
75 | * parser within which the parse error occurred. This array is | ||
76 | * defined in the generated ...Constants interface. | ||
77 | */ | ||
78 | public String[] tokenImage; | ||
79 | |||
80 | /** | ||
81 | * It uses "currentToken" and "expectedTokenSequences" to generate a parse | ||
82 | * error message and returns it. If this object has been created | ||
83 | * due to a parse error, and you do not catch it (it gets thrown | ||
84 | * from the parser) the correct error message | ||
85 | * gets displayed. | ||
86 | */ | ||
87 | private static String initialise(Token currentToken, | ||
88 | int[][] expectedTokenSequences, | ||
89 | String[] tokenImage) { | ||
90 | String eol = System.getProperty("line.separator", "\n"); | ||
91 | StringBuffer expected = new StringBuffer(); | ||
92 | int maxSize = 0; | ||
93 | for (int i = 0; i < expectedTokenSequences.length; i++) { | ||
94 | if (maxSize < expectedTokenSequences[i].length) { | ||
95 | maxSize = expectedTokenSequences[i].length; | ||
96 | } | ||
97 | for (int j = 0; j < expectedTokenSequences[i].length; j++) { | ||
98 | expected.append(tokenImage[expectedTokenSequences[i][j]]).append(' '); | ||
99 | } | ||
100 | if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) { | ||
101 | expected.append("..."); | ||
102 | } | ||
103 | expected.append(eol).append(" "); | ||
104 | } | ||
105 | String retval = "Encountered \""; | ||
106 | Token tok = currentToken.next; | ||
107 | for (int i = 0; i < maxSize; i++) { | ||
108 | if (i != 0) retval += " "; | ||
109 | if (tok.kind == 0) { | ||
110 | retval += tokenImage[0]; | ||
111 | break; | ||
112 | } | ||
113 | retval += " " + tokenImage[tok.kind]; | ||
114 | retval += " \""; | ||
115 | retval += add_escapes(tok.image); | ||
116 | retval += " \""; | ||
117 | tok = tok.next; | ||
118 | } | ||
119 | retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn; | ||
120 | retval += "." + eol; | ||
121 | if (expectedTokenSequences.length == 1) { | ||
122 | retval += "Was expecting:" + eol + " "; | ||
123 | } else { | ||
124 | retval += "Was expecting one of:" + eol + " "; | ||
125 | } | ||
126 | retval += expected.toString(); | ||
127 | return retval; | ||
128 | } | ||
129 | |||
130 | /** | ||
131 | * The end of line string for this machine. | ||
132 | */ | ||
133 | protected String eol = System.getProperty("line.separator", "\n"); | ||
134 | |||
135 | /** | ||
136 | * Used to convert raw characters to their escaped version | ||
137 | * when these raw version cannot be used as part of an ASCII | ||
138 | * string literal. | ||
139 | */ | ||
140 | static String add_escapes(String str) { | ||
141 | StringBuffer retval = new StringBuffer(); | ||
142 | char ch; | ||
143 | for (int i = 0; i < str.length(); i++) { | ||
144 | switch (str.charAt(i)) | ||
145 | { | ||
146 | case 0 : | ||
147 | continue; | ||
148 | case '\b': | ||
149 | retval.append("\\b"); | ||
150 | continue; | ||
151 | case '\t': | ||
152 | retval.append("\\t"); | ||
153 | continue; | ||
154 | case '\n': | ||
155 | retval.append("\\n"); | ||
156 | continue; | ||
157 | case '\f': | ||
158 | retval.append("\\f"); | ||
159 | continue; | ||
160 | case '\r': | ||
161 | retval.append("\\r"); | ||
162 | continue; | ||
163 | case '\"': | ||
164 | retval.append("\\\""); | ||
165 | continue; | ||
166 | case '\'': | ||
167 | retval.append("\\\'"); | ||
168 | continue; | ||
169 | case '\\': | ||
170 | retval.append("\\\\"); | ||
171 | continue; | ||
172 | default: | ||
173 | if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) { | ||
174 | String s = "0000" + Integer.toString(ch, 16); | ||
175 | retval.append("\\u" + s.substring(s.length() - 4, s.length())); | ||
176 | } else { | ||
177 | retval.append(ch); | ||
178 | } | ||
179 | continue; | ||
180 | } | ||
181 | } | ||
182 | return retval.toString(); | ||
183 | } | ||
184 | |||
185 | } | ||
186 | /* JavaCC - OriginalChecksum=c5a983a229aa877dc2b3b3b9933cdd6b (do not edit this line) */ | ||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/SimpleCharStream.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/SimpleCharStream.java new file mode 100644 index 000000000..8f115d519 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/SimpleCharStream.java | |||
@@ -0,0 +1,470 @@ | |||
1 | package org.gnunet.seaspider.parser; | ||
2 | /* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 5.0 */ | ||
3 | /* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */ | ||
4 | /** | ||
5 | * An implementation of interface CharStream, where the stream is assumed to | ||
6 | * contain only ASCII characters (without unicode processing). | ||
7 | */ | ||
8 | |||
9 | public class SimpleCharStream | ||
10 | { | ||
11 | /** Whether parser is static. */ | ||
12 | public static final boolean staticFlag = false; | ||
13 | int bufsize; | ||
14 | int available; | ||
15 | int tokenBegin; | ||
16 | /** Position in buffer. */ | ||
17 | public int bufpos = -1; | ||
18 | protected int bufline[]; | ||
19 | protected int bufcolumn[]; | ||
20 | |||
21 | protected int column = 0; | ||
22 | protected int line = 1; | ||
23 | |||
24 | protected boolean prevCharIsCR = false; | ||
25 | protected boolean prevCharIsLF = false; | ||
26 | |||
27 | protected java.io.Reader inputStream; | ||
28 | |||
29 | protected char[] buffer; | ||
30 | protected int maxNextCharInd = 0; | ||
31 | protected int inBuf = 0; | ||
32 | protected int tabSize = 8; | ||
33 | |||
34 | protected void setTabSize(int i) { tabSize = i; } | ||
35 | protected int getTabSize(int i) { return tabSize; } | ||
36 | |||
37 | |||
38 | protected void ExpandBuff(boolean wrapAround) | ||
39 | { | ||
40 | char[] newbuffer = new char[bufsize + 2048]; | ||
41 | int newbufline[] = new int[bufsize + 2048]; | ||
42 | int newbufcolumn[] = new int[bufsize + 2048]; | ||
43 | |||
44 | try | ||
45 | { | ||
46 | if (wrapAround) | ||
47 | { | ||
48 | System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin); | ||
49 | System.arraycopy(buffer, 0, newbuffer, bufsize - tokenBegin, bufpos); | ||
50 | buffer = newbuffer; | ||
51 | |||
52 | System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin); | ||
53 | System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos); | ||
54 | bufline = newbufline; | ||
55 | |||
56 | System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin); | ||
57 | System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos); | ||
58 | bufcolumn = newbufcolumn; | ||
59 | |||
60 | maxNextCharInd = (bufpos += (bufsize - tokenBegin)); | ||
61 | } | ||
62 | else | ||
63 | { | ||
64 | System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin); | ||
65 | buffer = newbuffer; | ||
66 | |||
67 | System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin); | ||
68 | bufline = newbufline; | ||
69 | |||
70 | System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin); | ||
71 | bufcolumn = newbufcolumn; | ||
72 | |||
73 | maxNextCharInd = (bufpos -= tokenBegin); | ||
74 | } | ||
75 | } | ||
76 | catch (Throwable t) | ||
77 | { | ||
78 | throw new Error(t.getMessage()); | ||
79 | } | ||
80 | |||
81 | |||
82 | bufsize += 2048; | ||
83 | available = bufsize; | ||
84 | tokenBegin = 0; | ||
85 | } | ||
86 | |||
87 | protected void FillBuff() throws java.io.IOException | ||
88 | { | ||
89 | if (maxNextCharInd == available) | ||
90 | { | ||
91 | if (available == bufsize) | ||
92 | { | ||
93 | if (tokenBegin > 2048) | ||
94 | { | ||
95 | bufpos = maxNextCharInd = 0; | ||
96 | available = tokenBegin; | ||
97 | } | ||
98 | else if (tokenBegin < 0) | ||
99 | bufpos = maxNextCharInd = 0; | ||
100 | else | ||
101 | ExpandBuff(false); | ||
102 | } | ||
103 | else if (available > tokenBegin) | ||
104 | available = bufsize; | ||
105 | else if ((tokenBegin - available) < 2048) | ||
106 | ExpandBuff(true); | ||
107 | else | ||
108 | available = tokenBegin; | ||
109 | } | ||
110 | |||
111 | int i; | ||
112 | try { | ||
113 | if ((i = inputStream.read(buffer, maxNextCharInd, available - maxNextCharInd)) == -1) | ||
114 | { | ||
115 | inputStream.close(); | ||
116 | throw new java.io.IOException(); | ||
117 | } | ||
118 | else | ||
119 | maxNextCharInd += i; | ||
120 | return; | ||
121 | } | ||
122 | catch(java.io.IOException e) { | ||
123 | --bufpos; | ||
124 | backup(0); | ||
125 | if (tokenBegin == -1) | ||
126 | tokenBegin = bufpos; | ||
127 | throw e; | ||
128 | } | ||
129 | } | ||
130 | |||
131 | /** Start. */ | ||
132 | public char BeginToken() throws java.io.IOException | ||
133 | { | ||
134 | tokenBegin = -1; | ||
135 | char c = readChar(); | ||
136 | tokenBegin = bufpos; | ||
137 | |||
138 | return c; | ||
139 | } | ||
140 | |||
141 | protected void UpdateLineColumn(char c) | ||
142 | { | ||
143 | column++; | ||
144 | |||
145 | if (prevCharIsLF) | ||
146 | { | ||
147 | prevCharIsLF = false; | ||
148 | line += (column = 1); | ||
149 | } | ||
150 | else if (prevCharIsCR) | ||
151 | { | ||
152 | prevCharIsCR = false; | ||
153 | if (c == '\n') | ||
154 | { | ||
155 | prevCharIsLF = true; | ||
156 | } | ||
157 | else | ||
158 | line += (column = 1); | ||
159 | } | ||
160 | |||
161 | switch (c) | ||
162 | { | ||
163 | case '\r' : | ||
164 | prevCharIsCR = true; | ||
165 | break; | ||
166 | case '\n' : | ||
167 | prevCharIsLF = true; | ||
168 | break; | ||
169 | case '\t' : | ||
170 | column--; | ||
171 | column += (tabSize - (column % tabSize)); | ||
172 | break; | ||
173 | default : | ||
174 | break; | ||
175 | } | ||
176 | |||
177 | bufline[bufpos] = line; | ||
178 | bufcolumn[bufpos] = column; | ||
179 | } | ||
180 | |||
181 | /** Read a character. */ | ||
182 | public char readChar() throws java.io.IOException | ||
183 | { | ||
184 | if (inBuf > 0) | ||
185 | { | ||
186 | --inBuf; | ||
187 | |||
188 | if (++bufpos == bufsize) | ||
189 | bufpos = 0; | ||
190 | |||
191 | return buffer[bufpos]; | ||
192 | } | ||
193 | |||
194 | if (++bufpos >= maxNextCharInd) | ||
195 | FillBuff(); | ||
196 | |||
197 | char c = buffer[bufpos]; | ||
198 | |||
199 | UpdateLineColumn(c); | ||
200 | return c; | ||
201 | } | ||
202 | |||
203 | @Deprecated | ||
204 | /** | ||
205 | * @deprecated | ||
206 | * @see #getEndColumn | ||
207 | */ | ||
208 | |||
209 | public int getColumn() { | ||
210 | return bufcolumn[bufpos]; | ||
211 | } | ||
212 | |||
213 | @Deprecated | ||
214 | /** | ||
215 | * @deprecated | ||
216 | * @see #getEndLine | ||
217 | */ | ||
218 | |||
219 | public int getLine() { | ||
220 | return bufline[bufpos]; | ||
221 | } | ||
222 | |||
223 | /** Get token end column number. */ | ||
224 | public int getEndColumn() { | ||
225 | return bufcolumn[bufpos]; | ||
226 | } | ||
227 | |||
228 | /** Get token end line number. */ | ||
229 | public int getEndLine() { | ||
230 | return bufline[bufpos]; | ||
231 | } | ||
232 | |||
233 | /** Get token beginning column number. */ | ||
234 | public int getBeginColumn() { | ||
235 | return bufcolumn[tokenBegin]; | ||
236 | } | ||
237 | |||
238 | /** Get token beginning line number. */ | ||
239 | public int getBeginLine() { | ||
240 | return bufline[tokenBegin]; | ||
241 | } | ||
242 | |||
243 | /** Backup a number of characters. */ | ||
244 | public void backup(int amount) { | ||
245 | |||
246 | inBuf += amount; | ||
247 | if ((bufpos -= amount) < 0) | ||
248 | bufpos += bufsize; | ||
249 | } | ||
250 | |||
251 | /** Constructor. */ | ||
252 | public SimpleCharStream(java.io.Reader dstream, int startline, | ||
253 | int startcolumn, int buffersize) | ||
254 | { | ||
255 | inputStream = dstream; | ||
256 | line = startline; | ||
257 | column = startcolumn - 1; | ||
258 | |||
259 | available = bufsize = buffersize; | ||
260 | buffer = new char[buffersize]; | ||
261 | bufline = new int[buffersize]; | ||
262 | bufcolumn = new int[buffersize]; | ||
263 | } | ||
264 | |||
265 | /** Constructor. */ | ||
266 | public SimpleCharStream(java.io.Reader dstream, int startline, | ||
267 | int startcolumn) | ||
268 | { | ||
269 | this(dstream, startline, startcolumn, 4096); | ||
270 | } | ||
271 | |||
272 | /** Constructor. */ | ||
273 | public SimpleCharStream(java.io.Reader dstream) | ||
274 | { | ||
275 | this(dstream, 1, 1, 4096); | ||
276 | } | ||
277 | |||
278 | /** Reinitialise. */ | ||
279 | public void ReInit(java.io.Reader dstream, int startline, | ||
280 | int startcolumn, int buffersize) | ||
281 | { | ||
282 | inputStream = dstream; | ||
283 | line = startline; | ||
284 | column = startcolumn - 1; | ||
285 | |||
286 | if (buffer == null || buffersize != buffer.length) | ||
287 | { | ||
288 | available = bufsize = buffersize; | ||
289 | buffer = new char[buffersize]; | ||
290 | bufline = new int[buffersize]; | ||
291 | bufcolumn = new int[buffersize]; | ||
292 | } | ||
293 | prevCharIsLF = prevCharIsCR = false; | ||
294 | tokenBegin = inBuf = maxNextCharInd = 0; | ||
295 | bufpos = -1; | ||
296 | } | ||
297 | |||
298 | /** Reinitialise. */ | ||
299 | public void ReInit(java.io.Reader dstream, int startline, | ||
300 | int startcolumn) | ||
301 | { | ||
302 | ReInit(dstream, startline, startcolumn, 4096); | ||
303 | } | ||
304 | |||
305 | /** Reinitialise. */ | ||
306 | public void ReInit(java.io.Reader dstream) | ||
307 | { | ||
308 | ReInit(dstream, 1, 1, 4096); | ||
309 | } | ||
310 | /** Constructor. */ | ||
311 | public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline, | ||
312 | int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException | ||
313 | { | ||
314 | this(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize); | ||
315 | } | ||
316 | |||
317 | /** Constructor. */ | ||
318 | public SimpleCharStream(java.io.InputStream dstream, int startline, | ||
319 | int startcolumn, int buffersize) | ||
320 | { | ||
321 | this(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize); | ||
322 | } | ||
323 | |||
324 | /** Constructor. */ | ||
325 | public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline, | ||
326 | int startcolumn) throws java.io.UnsupportedEncodingException | ||
327 | { | ||
328 | this(dstream, encoding, startline, startcolumn, 4096); | ||
329 | } | ||
330 | |||
331 | /** Constructor. */ | ||
332 | public SimpleCharStream(java.io.InputStream dstream, int startline, | ||
333 | int startcolumn) | ||
334 | { | ||
335 | this(dstream, startline, startcolumn, 4096); | ||
336 | } | ||
337 | |||
338 | /** Constructor. */ | ||
339 | public SimpleCharStream(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException | ||
340 | { | ||
341 | this(dstream, encoding, 1, 1, 4096); | ||
342 | } | ||
343 | |||
344 | /** Constructor. */ | ||
345 | public SimpleCharStream(java.io.InputStream dstream) | ||
346 | { | ||
347 | this(dstream, 1, 1, 4096); | ||
348 | } | ||
349 | |||
350 | /** Reinitialise. */ | ||
351 | public void ReInit(java.io.InputStream dstream, String encoding, int startline, | ||
352 | int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException | ||
353 | { | ||
354 | ReInit(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize); | ||
355 | } | ||
356 | |||
357 | /** Reinitialise. */ | ||
358 | public void ReInit(java.io.InputStream dstream, int startline, | ||
359 | int startcolumn, int buffersize) | ||
360 | { | ||
361 | ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize); | ||
362 | } | ||
363 | |||
364 | /** Reinitialise. */ | ||
365 | public void ReInit(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException | ||
366 | { | ||
367 | ReInit(dstream, encoding, 1, 1, 4096); | ||
368 | } | ||
369 | |||
370 | /** Reinitialise. */ | ||
371 | public void ReInit(java.io.InputStream dstream) | ||
372 | { | ||
373 | ReInit(dstream, 1, 1, 4096); | ||
374 | } | ||
375 | /** Reinitialise. */ | ||
376 | public void ReInit(java.io.InputStream dstream, String encoding, int startline, | ||
377 | int startcolumn) throws java.io.UnsupportedEncodingException | ||
378 | { | ||
379 | ReInit(dstream, encoding, startline, startcolumn, 4096); | ||
380 | } | ||
381 | /** Reinitialise. */ | ||
382 | public void ReInit(java.io.InputStream dstream, int startline, | ||
383 | int startcolumn) | ||
384 | { | ||
385 | ReInit(dstream, startline, startcolumn, 4096); | ||
386 | } | ||
387 | /** Get token literal value. */ | ||
388 | public String GetImage() | ||
389 | { | ||
390 | if (bufpos >= tokenBegin) | ||
391 | return new String(buffer, tokenBegin, bufpos - tokenBegin + 1); | ||
392 | else | ||
393 | return new String(buffer, tokenBegin, bufsize - tokenBegin) + | ||
394 | new String(buffer, 0, bufpos + 1); | ||
395 | } | ||
396 | |||
397 | /** Get the suffix. */ | ||
398 | public char[] GetSuffix(int len) | ||
399 | { | ||
400 | char[] ret = new char[len]; | ||
401 | |||
402 | if ((bufpos + 1) >= len) | ||
403 | System.arraycopy(buffer, bufpos - len + 1, ret, 0, len); | ||
404 | else | ||
405 | { | ||
406 | System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0, | ||
407 | len - bufpos - 1); | ||
408 | System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1); | ||
409 | } | ||
410 | |||
411 | return ret; | ||
412 | } | ||
413 | |||
414 | /** Reset buffer when finished. */ | ||
415 | public void Done() | ||
416 | { | ||
417 | buffer = null; | ||
418 | bufline = null; | ||
419 | bufcolumn = null; | ||
420 | } | ||
421 | |||
422 | /** | ||
423 | * Method to adjust line and column numbers for the start of a token. | ||
424 | */ | ||
425 | public void adjustBeginLineColumn(int newLine, int newCol) | ||
426 | { | ||
427 | int start = tokenBegin; | ||
428 | int len; | ||
429 | |||
430 | if (bufpos >= tokenBegin) | ||
431 | { | ||
432 | len = bufpos - tokenBegin + inBuf + 1; | ||
433 | } | ||
434 | else | ||
435 | { | ||
436 | len = bufsize - tokenBegin + bufpos + 1 + inBuf; | ||
437 | } | ||
438 | |||
439 | int i = 0, j = 0, k = 0; | ||
440 | int nextColDiff = 0, columnDiff = 0; | ||
441 | |||
442 | while (i < len && bufline[j = start % bufsize] == bufline[k = ++start % bufsize]) | ||
443 | { | ||
444 | bufline[j] = newLine; | ||
445 | nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j]; | ||
446 | bufcolumn[j] = newCol + columnDiff; | ||
447 | columnDiff = nextColDiff; | ||
448 | i++; | ||
449 | } | ||
450 | |||
451 | if (i < len) | ||
452 | { | ||
453 | bufline[j] = newLine++; | ||
454 | bufcolumn[j] = newCol + columnDiff; | ||
455 | |||
456 | while (i++ < len) | ||
457 | { | ||
458 | if (bufline[j = start % bufsize] != bufline[++start % bufsize]) | ||
459 | bufline[j] = newLine++; | ||
460 | else | ||
461 | bufline[j] = newLine; | ||
462 | } | ||
463 | } | ||
464 | |||
465 | line = bufline[j]; | ||
466 | column = bufcolumn[j]; | ||
467 | } | ||
468 | |||
469 | } | ||
470 | /* JavaCC - OriginalChecksum=b0bce35239226f00f9dd0fa14ab3ad17 (do not edit this line) */ | ||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/Token.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/Token.java new file mode 100644 index 000000000..468572c5b --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/Token.java | |||
@@ -0,0 +1,130 @@ | |||
1 | package org.gnunet.seaspider.parser; | ||
2 | /* Generated By:JavaCC: Do not edit this line. Token.java Version 5.0 */ | ||
3 | /* JavaCCOptions:TOKEN_EXTENDS=,KEEP_LINE_COL=null,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */ | ||
4 | /** | ||
5 | * Describes the input token stream. | ||
6 | */ | ||
7 | |||
8 | public class Token implements java.io.Serializable { | ||
9 | |||
10 | /** | ||
11 | * The version identifier for this Serializable class. | ||
12 | * Increment only if the <i>serialized</i> form of the | ||
13 | * class changes. | ||
14 | */ | ||
15 | private static final long serialVersionUID = 1L; | ||
16 | |||
17 | /** | ||
18 | * An integer that describes the kind of this token. This numbering | ||
19 | * system is determined by JavaCCParser, and a table of these numbers is | ||
20 | * stored in the file ...Constants.java. | ||
21 | */ | ||
22 | public int kind; | ||
23 | |||
24 | /** The line number of the first character of this Token. */ | ||
25 | public int beginLine; | ||
26 | /** The column number of the first character of this Token. */ | ||
27 | public int beginColumn; | ||
28 | /** The line number of the last character of this Token. */ | ||
29 | public int endLine; | ||
30 | /** The column number of the last character of this Token. */ | ||
31 | public int endColumn; | ||
32 | |||
33 | /** | ||
34 | * The string image of the token. | ||
35 | */ | ||
36 | public String image; | ||
37 | |||
38 | /** | ||
39 | * A reference to the next regular (non-special) token from the input | ||
40 | * stream. If this is the last token from the input stream, or if the | ||
41 | * token manager has not read tokens beyond this one, this field is | ||
42 | * set to null. This is true only if this token is also a regular | ||
43 | * token. Otherwise, see below for a description of the contents of | ||
44 | * this field. | ||
45 | */ | ||
46 | public Token next; | ||
47 | |||
48 | /** | ||
49 | * This field is used to access special tokens that occur prior to this | ||
50 | * token, but after the immediately preceding regular (non-special) token. | ||
51 | * If there are no such special tokens, this field is set to null. | ||
52 | * When there are more than one such special token, this field refers | ||
53 | * to the last of these special tokens, which in turn refers to the next | ||
54 | * previous special token through its specialToken field, and so on | ||
55 | * until the first special token (whose specialToken field is null). | ||
56 | * The next fields of special tokens refer to other special tokens that | ||
57 | * immediately follow it (without an intervening regular token). If there | ||
58 | * is no such token, this field is null. | ||
59 | */ | ||
60 | public Token specialToken; | ||
61 | |||
62 | /** | ||
63 | * An optional attribute value of the Token. | ||
64 | * Tokens which are not used as syntactic sugar will often contain | ||
65 | * meaningful values that will be used later on by the compiler or | ||
66 | * interpreter. This attribute value is often different from the image. | ||
67 | * Any subclass of Token that actually wants to return a non-null value can | ||
68 | * override this method as appropriate. | ||
69 | */ | ||
70 | public Object getValue() { | ||
71 | return null; | ||
72 | } | ||
73 | |||
74 | /** | ||
75 | * No-argument constructor | ||
76 | */ | ||
77 | public Token() {} | ||
78 | |||
79 | /** | ||
80 | * Constructs a new token for the specified Image. | ||
81 | */ | ||
82 | public Token(int kind) | ||
83 | { | ||
84 | this(kind, null); | ||
85 | } | ||
86 | |||
87 | /** | ||
88 | * Constructs a new token for the specified Image and Kind. | ||
89 | */ | ||
90 | public Token(int kind, String image) | ||
91 | { | ||
92 | this.kind = kind; | ||
93 | this.image = image; | ||
94 | } | ||
95 | |||
96 | /** | ||
97 | * Returns the image. | ||
98 | */ | ||
99 | public String toString() | ||
100 | { | ||
101 | return image; | ||
102 | } | ||
103 | |||
104 | /** | ||
105 | * Returns a new Token object, by default. However, if you want, you | ||
106 | * can create and return subclass objects based on the value of ofKind. | ||
107 | * Simply add the cases to the switch for all those special cases. | ||
108 | * For example, if you have a subclass of Token called IDToken that | ||
109 | * you want to create if ofKind is ID, simply add something like : | ||
110 | * | ||
111 | * case MyParserConstants.ID : return new IDToken(ofKind, image); | ||
112 | * | ||
113 | * to the following switch statement. Then you can cast matchedToken | ||
114 | * variable to the appropriate type and use sit in your lexical actions. | ||
115 | */ | ||
116 | public static Token newToken(int ofKind, String image) | ||
117 | { | ||
118 | switch(ofKind) | ||
119 | { | ||
120 | default : return new Token(ofKind, image); | ||
121 | } | ||
122 | } | ||
123 | |||
124 | public static Token newToken(int ofKind) | ||
125 | { | ||
126 | return newToken(ofKind, null); | ||
127 | } | ||
128 | |||
129 | } | ||
130 | /* JavaCC - OriginalChecksum=6145f5d5b504ccb4f95e09f2ce3e748a (do not edit this line) */ | ||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/TokenMgrError.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/TokenMgrError.java new file mode 100644 index 000000000..3e46dcfc5 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/TokenMgrError.java | |||
@@ -0,0 +1,146 @@ | |||
1 | package org.gnunet.seaspider.parser; | ||
2 | /* Generated By:JavaCC: Do not edit this line. TokenMgrError.java Version 5.0 */ | ||
3 | /* JavaCCOptions: */ | ||
4 | /** Token Manager Error. */ | ||
5 | public class TokenMgrError extends Error | ||
6 | { | ||
7 | |||
8 | /** | ||
9 | * The version identifier for this Serializable class. | ||
10 | * Increment only if the <i>serialized</i> form of the | ||
11 | * class changes. | ||
12 | */ | ||
13 | private static final long serialVersionUID = 1L; | ||
14 | |||
15 | /* | ||
16 | * Ordinals for various reasons why an Error of this type can be thrown. | ||
17 | */ | ||
18 | |||
19 | /** | ||
20 | * Lexical error occurred. | ||
21 | */ | ||
22 | static final int LEXICAL_ERROR = 0; | ||
23 | |||
24 | /** | ||
25 | * An attempt was made to create a second instance of a static token manager. | ||
26 | */ | ||
27 | static final int STATIC_LEXER_ERROR = 1; | ||
28 | |||
29 | /** | ||
30 | * Tried to change to an invalid lexical state. | ||
31 | */ | ||
32 | static final int INVALID_LEXICAL_STATE = 2; | ||
33 | |||
34 | /** | ||
35 | * Detected (and bailed out of) an infinite loop in the token manager. | ||
36 | */ | ||
37 | static final int LOOP_DETECTED = 3; | ||
38 | |||
39 | /** | ||
40 | * Indicates the reason why the exception is thrown. It will have | ||
41 | * one of the above 4 values. | ||
42 | */ | ||
43 | int errorCode; | ||
44 | |||
45 | /** | ||
46 | * Replaces unprintable characters by their escaped (or unicode escaped) | ||
47 | * equivalents in the given string | ||
48 | */ | ||
49 | protected static final String addEscapes(String str) { | ||
50 | StringBuffer retval = new StringBuffer(); | ||
51 | char ch; | ||
52 | for (int i = 0; i < str.length(); i++) { | ||
53 | switch (str.charAt(i)) | ||
54 | { | ||
55 | case 0 : | ||
56 | continue; | ||
57 | case '\b': | ||
58 | retval.append("\\b"); | ||
59 | continue; | ||
60 | case '\t': | ||
61 | retval.append("\\t"); | ||
62 | continue; | ||
63 | case '\n': | ||
64 | retval.append("\\n"); | ||
65 | continue; | ||
66 | case '\f': | ||
67 | retval.append("\\f"); | ||
68 | continue; | ||
69 | case '\r': | ||
70 | retval.append("\\r"); | ||
71 | continue; | ||
72 | case '\"': | ||
73 | retval.append("\\\""); | ||
74 | continue; | ||
75 | case '\'': | ||
76 | retval.append("\\\'"); | ||
77 | continue; | ||
78 | case '\\': | ||
79 | retval.append("\\\\"); | ||
80 | continue; | ||
81 | default: | ||
82 | if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) { | ||
83 | String s = "0000" + Integer.toString(ch, 16); | ||
84 | retval.append("\\u" + s.substring(s.length() - 4, s.length())); | ||
85 | } else { | ||
86 | retval.append(ch); | ||
87 | } | ||
88 | continue; | ||
89 | } | ||
90 | } | ||
91 | return retval.toString(); | ||
92 | } | ||
93 | |||
94 | /** | ||
95 | * Returns a detailed message for the Error when it is thrown by the | ||
96 | * token manager to indicate a lexical error. | ||
97 | * Parameters : | ||
98 | * EOFSeen : indicates if EOF caused the lexical error | ||
99 | * curLexState : lexical state in which this error occurred | ||
100 | * errorLine : line number when the error occurred | ||
101 | * errorColumn : column number when the error occurred | ||
102 | * errorAfter : prefix that was seen before this error occurred | ||
103 | * curchar : the offending character | ||
104 | * Note: You can customize the lexical error message by modifying this method. | ||
105 | */ | ||
106 | protected static String LexicalError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar) { | ||
107 | return("Lexical error at line " + | ||
108 | errorLine + ", column " + | ||
109 | errorColumn + ". Encountered: " + | ||
110 | (EOFSeen ? "<EOF> " : ("\"" + addEscapes(String.valueOf(curChar)) + "\"") + " (" + (int)curChar + "), ") + | ||
111 | "after : \"" + addEscapes(errorAfter) + "\""); | ||
112 | } | ||
113 | |||
114 | /** | ||
115 | * You can also modify the body of this method to customize your error messages. | ||
116 | * For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not | ||
117 | * of end-users concern, so you can return something like : | ||
118 | * | ||
119 | * "Internal Error : Please file a bug report .... " | ||
120 | * | ||
121 | * from this method for such cases in the release version of your parser. | ||
122 | */ | ||
123 | public String getMessage() { | ||
124 | return super.getMessage(); | ||
125 | } | ||
126 | |||
127 | /* | ||
128 | * Constructors of various flavors follow. | ||
129 | */ | ||
130 | |||
131 | /** No arg constructor. */ | ||
132 | public TokenMgrError() { | ||
133 | } | ||
134 | |||
135 | /** Constructor with message and reason. */ | ||
136 | public TokenMgrError(String message, int reason) { | ||
137 | super(message); | ||
138 | errorCode = reason; | ||
139 | } | ||
140 | |||
141 | /** Full Constructor. */ | ||
142 | public TokenMgrError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar, int reason) { | ||
143 | this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason); | ||
144 | } | ||
145 | } | ||
146 | /* JavaCC - OriginalChecksum=3f827858bf5c87e5502cccca67d9b325 (do not edit this line) */ | ||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ANDExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ANDExpression.java new file mode 100644 index 000000000..8ced2c188 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ANDExpression.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> EqualityExpression() | ||
11 | * f1 -> [ "&" ANDExpression() ] | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class ANDExpression implements Node { | ||
15 | public EqualityExpression f0; | ||
16 | public NodeOptional f1; | ||
17 | |||
18 | public ANDExpression(EqualityExpression n0, NodeOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AdditiveExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AdditiveExpression.java new file mode 100644 index 000000000..f0c2f33ab --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AdditiveExpression.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> MultiplicativeExpression() | ||
11 | * f1 -> [ ( "+" | "-" ) AdditiveExpression() ] | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class AdditiveExpression implements Node { | ||
15 | public MultiplicativeExpression f0; | ||
16 | public NodeOptional f1; | ||
17 | |||
18 | public AdditiveExpression(MultiplicativeExpression n0, NodeOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ArgumentExpressionList.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ArgumentExpressionList.java new file mode 100644 index 000000000..0d93ab689 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ArgumentExpressionList.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> AssignmentOrTypeExpression() | ||
11 | * f1 -> ( "," AssignmentOrTypeExpression() )* | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class ArgumentExpressionList implements Node { | ||
15 | public AssignmentOrTypeExpression f0; | ||
16 | public NodeListOptional f1; | ||
17 | |||
18 | public ArgumentExpressionList(AssignmentOrTypeExpression n0, NodeListOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Array.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Array.java new file mode 100644 index 000000000..2d2798d7b --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Array.java | |||
@@ -0,0 +1,45 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> "[" | ||
11 | * f1 -> [ ConstantExpression() ] | ||
12 | * f2 -> "]" | ||
13 | * </PRE> | ||
14 | */ | ||
15 | public class Array implements Node { | ||
16 | public NodeToken f0; | ||
17 | public NodeOptional f1; | ||
18 | public NodeToken f2; | ||
19 | |||
20 | public Array(NodeToken n0, NodeOptional n1, NodeToken n2) { | ||
21 | f0 = n0; | ||
22 | f1 = n1; | ||
23 | f2 = n2; | ||
24 | } | ||
25 | |||
26 | public Array(NodeOptional n0) { | ||
27 | f0 = new NodeToken("["); | ||
28 | f1 = n0; | ||
29 | f2 = new NodeToken("]"); | ||
30 | } | ||
31 | |||
32 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
33 | v.visit(this); | ||
34 | } | ||
35 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
36 | return v.visit(this,argu); | ||
37 | } | ||
38 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
39 | return v.visit(this); | ||
40 | } | ||
41 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
42 | v.visit(this,argu); | ||
43 | } | ||
44 | } | ||
45 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentExpression.java new file mode 100644 index 000000000..1dc2606df --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentExpression.java | |||
@@ -0,0 +1,34 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression() | ||
11 | * | ConditionalExpression() | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class AssignmentExpression implements Node { | ||
15 | public NodeChoice f0; | ||
16 | |||
17 | public AssignmentExpression(NodeChoice n0) { | ||
18 | f0 = n0; | ||
19 | } | ||
20 | |||
21 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
22 | v.visit(this); | ||
23 | } | ||
24 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
25 | return v.visit(this,argu); | ||
26 | } | ||
27 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
28 | return v.visit(this); | ||
29 | } | ||
30 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
31 | v.visit(this,argu); | ||
32 | } | ||
33 | } | ||
34 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentOperator.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentOperator.java new file mode 100644 index 000000000..76b5bfb12 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentOperator.java | |||
@@ -0,0 +1,33 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" ) | ||
11 | * </PRE> | ||
12 | */ | ||
13 | public class AssignmentOperator implements Node { | ||
14 | public NodeChoice f0; | ||
15 | |||
16 | public AssignmentOperator(NodeChoice n0) { | ||
17 | f0 = n0; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | v.visit(this); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return v.visit(this,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return v.visit(this); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | v.visit(this,argu); | ||
31 | } | ||
32 | } | ||
33 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentOrTypeExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentOrTypeExpression.java new file mode 100644 index 000000000..2d118d221 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentOrTypeExpression.java | |||
@@ -0,0 +1,34 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> NoIdentifierTypeSpecifier() | ||
11 | * | AssignmentExpression() | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class AssignmentOrTypeExpression implements Node { | ||
15 | public NodeChoice f0; | ||
16 | |||
17 | public AssignmentOrTypeExpression(NodeChoice n0) { | ||
18 | f0 = n0; | ||
19 | } | ||
20 | |||
21 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
22 | v.visit(this); | ||
23 | } | ||
24 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
25 | return v.visit(this,argu); | ||
26 | } | ||
27 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
28 | return v.visit(this); | ||
29 | } | ||
30 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
31 | v.visit(this,argu); | ||
32 | } | ||
33 | } | ||
34 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/CastExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/CastExpression.java new file mode 100644 index 000000000..8a420c55f --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/CastExpression.java | |||
@@ -0,0 +1,33 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() ) | ||
11 | * </PRE> | ||
12 | */ | ||
13 | public class CastExpression implements Node { | ||
14 | public NodeChoice f0; | ||
15 | |||
16 | public CastExpression(NodeChoice n0) { | ||
17 | f0 = n0; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | v.visit(this); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return v.visit(this,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return v.visit(this); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | v.visit(this,argu); | ||
31 | } | ||
32 | } | ||
33 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/CompoundStatement.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/CompoundStatement.java new file mode 100644 index 000000000..18e7e6d8a --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/CompoundStatement.java | |||
@@ -0,0 +1,45 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> "{" | ||
11 | * f1 -> ( LocalVariableDeclaration() | Statement() )* | ||
12 | * f2 -> "}" | ||
13 | * </PRE> | ||
14 | */ | ||
15 | public class CompoundStatement implements Node { | ||
16 | public NodeToken f0; | ||
17 | public NodeListOptional f1; | ||
18 | public NodeToken f2; | ||
19 | |||
20 | public CompoundStatement(NodeToken n0, NodeListOptional n1, NodeToken n2) { | ||
21 | f0 = n0; | ||
22 | f1 = n1; | ||
23 | f2 = n2; | ||
24 | } | ||
25 | |||
26 | public CompoundStatement(NodeListOptional n0) { | ||
27 | f0 = new NodeToken("{"); | ||
28 | f1 = n0; | ||
29 | f2 = new NodeToken("}"); | ||
30 | } | ||
31 | |||
32 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
33 | v.visit(this); | ||
34 | } | ||
35 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
36 | return v.visit(this,argu); | ||
37 | } | ||
38 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
39 | return v.visit(this); | ||
40 | } | ||
41 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
42 | v.visit(this,argu); | ||
43 | } | ||
44 | } | ||
45 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ConditionalExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ConditionalExpression.java new file mode 100644 index 000000000..404ec903a --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ConditionalExpression.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> LogicalORExpression() | ||
11 | * f1 -> [ "?" Expression() ":" ConditionalExpression() ] | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class ConditionalExpression implements Node { | ||
15 | public LogicalORExpression f0; | ||
16 | public NodeOptional f1; | ||
17 | |||
18 | public ConditionalExpression(LogicalORExpression n0, NodeOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Constant.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Constant.java new file mode 100644 index 000000000..6ccd64ae4 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Constant.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> <INTEGER_LITERAL> | ||
11 | * | <FLOATING_POINT_LITERAL> | ||
12 | * | <CHARACTER_LITERAL> | ||
13 | * | <STRING_LITERAL> | ||
14 | * </PRE> | ||
15 | */ | ||
16 | public class Constant implements Node { | ||
17 | public NodeChoice f0; | ||
18 | |||
19 | public Constant(NodeChoice n0) { | ||
20 | f0 = n0; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ConstantExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ConstantExpression.java new file mode 100644 index 000000000..e1024c4ad --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ConstantExpression.java | |||
@@ -0,0 +1,33 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ConditionalExpression() | ||
11 | * </PRE> | ||
12 | */ | ||
13 | public class ConstantExpression implements Node { | ||
14 | public ConditionalExpression f0; | ||
15 | |||
16 | public ConstantExpression(ConditionalExpression n0) { | ||
17 | f0 = n0; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | v.visit(this); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return v.visit(this,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return v.visit(this); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | v.visit(this,argu); | ||
31 | } | ||
32 | } | ||
33 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/DataType.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/DataType.java new file mode 100644 index 000000000..e99a46a9c --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/DataType.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> StructOrUnionSpecifier() | ||
11 | * f1 -> <IDENTIFIER> | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class DataType implements Node { | ||
15 | public StructOrUnionSpecifier f0; | ||
16 | public NodeToken f1; | ||
17 | |||
18 | public DataType(StructOrUnionSpecifier n0, NodeToken n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EnumSpecifier.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EnumSpecifier.java new file mode 100644 index 000000000..5bb08faca --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EnumSpecifier.java | |||
@@ -0,0 +1,41 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> <ENUM> | ||
11 | * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> ) | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class EnumSpecifier implements Node { | ||
15 | public NodeToken f0; | ||
16 | public NodeChoice f1; | ||
17 | |||
18 | public EnumSpecifier(NodeToken n0, NodeChoice n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public EnumSpecifier(NodeChoice n0) { | ||
24 | f0 = new NodeToken("enum"); | ||
25 | f1 = n0; | ||
26 | } | ||
27 | |||
28 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
29 | v.visit(this); | ||
30 | } | ||
31 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
32 | return v.visit(this,argu); | ||
33 | } | ||
34 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
35 | return v.visit(this); | ||
36 | } | ||
37 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
38 | v.visit(this,argu); | ||
39 | } | ||
40 | } | ||
41 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Enumerator.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Enumerator.java new file mode 100644 index 000000000..305cf697a --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Enumerator.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> <IDENTIFIER> | ||
11 | * f1 -> [ "=" ConstantExpression() ] | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class Enumerator implements Node { | ||
15 | public NodeToken f0; | ||
16 | public NodeOptional f1; | ||
17 | |||
18 | public Enumerator(NodeToken n0, NodeOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EnumeratorList.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EnumeratorList.java new file mode 100644 index 000000000..ba72c0668 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EnumeratorList.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> Enumerator() | ||
11 | * f1 -> ( "," Enumerator() )* | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class EnumeratorList implements Node { | ||
15 | public Enumerator f0; | ||
16 | public NodeListOptional f1; | ||
17 | |||
18 | public EnumeratorList(Enumerator n0, NodeListOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EqualityExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EqualityExpression.java new file mode 100644 index 000000000..44157bb00 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EqualityExpression.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> RelationalExpression() | ||
11 | * f1 -> [ ( "==" | "!=" ) EqualityExpression() ] | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class EqualityExpression implements Node { | ||
15 | public RelationalExpression f0; | ||
16 | public NodeOptional f1; | ||
17 | |||
18 | public EqualityExpression(RelationalExpression n0, NodeOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExclusiveORExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExclusiveORExpression.java new file mode 100644 index 000000000..d80f4099a --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExclusiveORExpression.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ANDExpression() | ||
11 | * f1 -> [ "^" ExclusiveORExpression() ] | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class ExclusiveORExpression implements Node { | ||
15 | public ANDExpression f0; | ||
16 | public NodeOptional f1; | ||
17 | |||
18 | public ExclusiveORExpression(ANDExpression n0, NodeOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Expression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Expression.java new file mode 100644 index 000000000..e8f021a7d --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Expression.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> AssignmentExpression() | ||
11 | * f1 -> ( "," AssignmentExpression() )* | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class Expression implements Node { | ||
15 | public AssignmentExpression f0; | ||
16 | public NodeListOptional f1; | ||
17 | |||
18 | public Expression(AssignmentExpression n0, NodeListOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExpressionStatement.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExpressionStatement.java new file mode 100644 index 000000000..d6f23828d --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExpressionStatement.java | |||
@@ -0,0 +1,41 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> [ Expression() ] | ||
11 | * f1 -> ";" | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class ExpressionStatement implements Node { | ||
15 | public NodeOptional f0; | ||
16 | public NodeToken f1; | ||
17 | |||
18 | public ExpressionStatement(NodeOptional n0, NodeToken n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public ExpressionStatement(NodeOptional n0) { | ||
24 | f0 = n0; | ||
25 | f1 = new NodeToken(";"); | ||
26 | } | ||
27 | |||
28 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
29 | v.visit(this); | ||
30 | } | ||
31 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
32 | return v.visit(this,argu); | ||
33 | } | ||
34 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
35 | return v.visit(this); | ||
36 | } | ||
37 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
38 | v.visit(this,argu); | ||
39 | } | ||
40 | } | ||
41 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExternalDeclaration.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExternalDeclaration.java new file mode 100644 index 000000000..9d359285d --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExternalDeclaration.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ( StorageClassSpecifier() )* | ||
11 | * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() ) | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class ExternalDeclaration implements Node { | ||
15 | public NodeListOptional f0; | ||
16 | public NodeChoice f1; | ||
17 | |||
18 | public ExternalDeclaration(NodeListOptional n0, NodeChoice n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/FunctionDeclaration.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/FunctionDeclaration.java new file mode 100644 index 000000000..54da9f7ed --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/FunctionDeclaration.java | |||
@@ -0,0 +1,57 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> TypeSpecifier() | ||
11 | * f1 -> <IDENTIFIER> | ||
12 | * f2 -> "(" | ||
13 | * f3 -> [ ParameterList() ] | ||
14 | * f4 -> ")" | ||
15 | * f5 -> ( ";" | CompoundStatement() ) | ||
16 | * </PRE> | ||
17 | */ | ||
18 | public class FunctionDeclaration implements Node { | ||
19 | public TypeSpecifier f0; | ||
20 | public NodeToken f1; | ||
21 | public NodeToken f2; | ||
22 | public NodeOptional f3; | ||
23 | public NodeToken f4; | ||
24 | public NodeChoice f5; | ||
25 | |||
26 | public FunctionDeclaration(TypeSpecifier n0, NodeToken n1, NodeToken n2, NodeOptional n3, NodeToken n4, NodeChoice n5) { | ||
27 | f0 = n0; | ||
28 | f1 = n1; | ||
29 | f2 = n2; | ||
30 | f3 = n3; | ||
31 | f4 = n4; | ||
32 | f5 = n5; | ||
33 | } | ||
34 | |||
35 | public FunctionDeclaration(TypeSpecifier n0, NodeToken n1, NodeOptional n2, NodeChoice n3) { | ||
36 | f0 = n0; | ||
37 | f1 = n1; | ||
38 | f2 = new NodeToken("("); | ||
39 | f3 = n2; | ||
40 | f4 = new NodeToken(")"); | ||
41 | f5 = n3; | ||
42 | } | ||
43 | |||
44 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
45 | v.visit(this); | ||
46 | } | ||
47 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
48 | return v.visit(this,argu); | ||
49 | } | ||
50 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
51 | return v.visit(this); | ||
52 | } | ||
53 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
54 | v.visit(this,argu); | ||
55 | } | ||
56 | } | ||
57 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/FunctionType.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/FunctionType.java new file mode 100644 index 000000000..263e73e2f --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/FunctionType.java | |||
@@ -0,0 +1,65 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> TypeSpecifier() | ||
11 | * f1 -> "(" | ||
12 | * f2 -> "*" | ||
13 | * f3 -> <IDENTIFIER> | ||
14 | * f4 -> ")" | ||
15 | * f5 -> "(" | ||
16 | * f6 -> [ ParameterList() ] | ||
17 | * f7 -> ")" | ||
18 | * </PRE> | ||
19 | */ | ||
20 | public class FunctionType implements Node { | ||
21 | public TypeSpecifier f0; | ||
22 | public NodeToken f1; | ||
23 | public NodeToken f2; | ||
24 | public NodeToken f3; | ||
25 | public NodeToken f4; | ||
26 | public NodeToken f5; | ||
27 | public NodeOptional f6; | ||
28 | public NodeToken f7; | ||
29 | |||
30 | public FunctionType(TypeSpecifier n0, NodeToken n1, NodeToken n2, NodeToken n3, NodeToken n4, NodeToken n5, NodeOptional n6, NodeToken n7) { | ||
31 | f0 = n0; | ||
32 | f1 = n1; | ||
33 | f2 = n2; | ||
34 | f3 = n3; | ||
35 | f4 = n4; | ||
36 | f5 = n5; | ||
37 | f6 = n6; | ||
38 | f7 = n7; | ||
39 | } | ||
40 | |||
41 | public FunctionType(TypeSpecifier n0, NodeToken n1, NodeOptional n2) { | ||
42 | f0 = n0; | ||
43 | f1 = new NodeToken("("); | ||
44 | f2 = new NodeToken("*"); | ||
45 | f3 = n1; | ||
46 | f4 = new NodeToken(")"); | ||
47 | f5 = new NodeToken("("); | ||
48 | f6 = n2; | ||
49 | f7 = new NodeToken(")"); | ||
50 | } | ||
51 | |||
52 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
53 | v.visit(this); | ||
54 | } | ||
55 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
56 | return v.visit(this,argu); | ||
57 | } | ||
58 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
59 | return v.visit(this); | ||
60 | } | ||
61 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
62 | v.visit(this,argu); | ||
63 | } | ||
64 | } | ||
65 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/IdentifierList.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/IdentifierList.java new file mode 100644 index 000000000..7df6de807 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/IdentifierList.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> <IDENTIFIER> | ||
11 | * f1 -> ( "," <IDENTIFIER> )* | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class IdentifierList implements Node { | ||
15 | public NodeToken f0; | ||
16 | public NodeListOptional f1; | ||
17 | |||
18 | public IdentifierList(NodeToken n0, NodeListOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InclusiveORExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InclusiveORExpression.java new file mode 100644 index 000000000..9d972377d --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InclusiveORExpression.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ExclusiveORExpression() | ||
11 | * f1 -> [ "|" InclusiveORExpression() ] | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class InclusiveORExpression implements Node { | ||
15 | public ExclusiveORExpression f0; | ||
16 | public NodeOptional f1; | ||
17 | |||
18 | public InclusiveORExpression(ExclusiveORExpression n0, NodeOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitDeclarator.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitDeclarator.java new file mode 100644 index 000000000..27cd735fa --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitDeclarator.java | |||
@@ -0,0 +1,39 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> <IDENTIFIER> | ||
11 | * f1 -> [ Array() ] | ||
12 | * f2 -> [ "=" Initializer() ] | ||
13 | * </PRE> | ||
14 | */ | ||
15 | public class InitDeclarator implements Node { | ||
16 | public NodeToken f0; | ||
17 | public NodeOptional f1; | ||
18 | public NodeOptional f2; | ||
19 | |||
20 | public InitDeclarator(NodeToken n0, NodeOptional n1, NodeOptional n2) { | ||
21 | f0 = n0; | ||
22 | f1 = n1; | ||
23 | f2 = n2; | ||
24 | } | ||
25 | |||
26 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
27 | v.visit(this); | ||
28 | } | ||
29 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
30 | return v.visit(this,argu); | ||
31 | } | ||
32 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
33 | return v.visit(this); | ||
34 | } | ||
35 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
36 | v.visit(this,argu); | ||
37 | } | ||
38 | } | ||
39 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitDeclaratorList.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitDeclaratorList.java new file mode 100644 index 000000000..0323a1826 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitDeclaratorList.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> InitDeclarator() | ||
11 | * f1 -> ( "," InitDeclarator() )* | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class InitDeclaratorList implements Node { | ||
15 | public InitDeclarator f0; | ||
16 | public NodeListOptional f1; | ||
17 | |||
18 | public InitDeclaratorList(InitDeclarator n0, NodeListOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Initializer.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Initializer.java new file mode 100644 index 000000000..e7e03b967 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Initializer.java | |||
@@ -0,0 +1,33 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" ) | ||
11 | * </PRE> | ||
12 | */ | ||
13 | public class Initializer implements Node { | ||
14 | public NodeChoice f0; | ||
15 | |||
16 | public Initializer(NodeChoice n0) { | ||
17 | f0 = n0; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | v.visit(this); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return v.visit(this,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return v.visit(this); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | v.visit(this,argu); | ||
31 | } | ||
32 | } | ||
33 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitializerList.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitializerList.java new file mode 100644 index 000000000..921602582 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitializerList.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> Initializer() | ||
11 | * f1 -> ( "," Initializer() )* | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class InitializerList implements Node { | ||
15 | public Initializer f0; | ||
16 | public NodeListOptional f1; | ||
17 | |||
18 | public InitializerList(Initializer n0, NodeListOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/IterationStatement.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/IterationStatement.java new file mode 100644 index 000000000..c9ba91916 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/IterationStatement.java | |||
@@ -0,0 +1,33 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() ) | ||
11 | * </PRE> | ||
12 | */ | ||
13 | public class IterationStatement implements Node { | ||
14 | public NodeChoice f0; | ||
15 | |||
16 | public IterationStatement(NodeChoice n0) { | ||
17 | f0 = n0; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | v.visit(this); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return v.visit(this,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return v.visit(this); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | v.visit(this,argu); | ||
31 | } | ||
32 | } | ||
33 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/JumpStatement.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/JumpStatement.java new file mode 100644 index 000000000..7341aadf2 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/JumpStatement.java | |||
@@ -0,0 +1,33 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" ) | ||
11 | * </PRE> | ||
12 | */ | ||
13 | public class JumpStatement implements Node { | ||
14 | public NodeChoice f0; | ||
15 | |||
16 | public JumpStatement(NodeChoice n0) { | ||
17 | f0 = n0; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | v.visit(this); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return v.visit(this,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return v.visit(this); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | v.visit(this,argu); | ||
31 | } | ||
32 | } | ||
33 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LabeledStatement.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LabeledStatement.java new file mode 100644 index 000000000..5f4ef4f98 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LabeledStatement.java | |||
@@ -0,0 +1,33 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() ) | ||
11 | * </PRE> | ||
12 | */ | ||
13 | public class LabeledStatement implements Node { | ||
14 | public NodeChoice f0; | ||
15 | |||
16 | public LabeledStatement(NodeChoice n0) { | ||
17 | f0 = n0; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | v.visit(this); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return v.visit(this,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return v.visit(this); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | v.visit(this,argu); | ||
31 | } | ||
32 | } | ||
33 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LocalVariableDeclaration.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LocalVariableDeclaration.java new file mode 100644 index 000000000..8337772a4 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LocalVariableDeclaration.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> [ <STATIC> ] | ||
11 | * f1 -> VariableDeclaration() | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class LocalVariableDeclaration implements Node { | ||
15 | public NodeOptional f0; | ||
16 | public VariableDeclaration f1; | ||
17 | |||
18 | public LocalVariableDeclaration(NodeOptional n0, VariableDeclaration n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LogicalANDExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LogicalANDExpression.java new file mode 100644 index 000000000..b353bb7f6 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LogicalANDExpression.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> InclusiveORExpression() | ||
11 | * f1 -> [ "&&" LogicalANDExpression() ] | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class LogicalANDExpression implements Node { | ||
15 | public InclusiveORExpression f0; | ||
16 | public NodeOptional f1; | ||
17 | |||
18 | public LogicalANDExpression(InclusiveORExpression n0, NodeOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LogicalORExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LogicalORExpression.java new file mode 100644 index 000000000..87f8d0d11 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LogicalORExpression.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> LogicalANDExpression() | ||
11 | * f1 -> [ "||" LogicalORExpression() ] | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class LogicalORExpression implements Node { | ||
15 | public LogicalANDExpression f0; | ||
16 | public NodeOptional f1; | ||
17 | |||
18 | public LogicalORExpression(LogicalANDExpression n0, NodeOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/MultiplicativeExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/MultiplicativeExpression.java new file mode 100644 index 000000000..9b801d12f --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/MultiplicativeExpression.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> CastExpression() | ||
11 | * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ] | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class MultiplicativeExpression implements Node { | ||
15 | public CastExpression f0; | ||
16 | public NodeOptional f1; | ||
17 | |||
18 | public MultiplicativeExpression(CastExpression n0, NodeOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NoIdentifierTypeSpecifier.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NoIdentifierTypeSpecifier.java new file mode 100644 index 000000000..ff4fc4108 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NoIdentifierTypeSpecifier.java | |||
@@ -0,0 +1,42 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> [ <CONST> ] | ||
11 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() ) | ||
12 | * f2 -> [ Pointer() ] | ||
13 | * f3 -> [ Array() ] | ||
14 | * </PRE> | ||
15 | */ | ||
16 | public class NoIdentifierTypeSpecifier implements Node { | ||
17 | public NodeOptional f0; | ||
18 | public NodeChoice f1; | ||
19 | public NodeOptional f2; | ||
20 | public NodeOptional f3; | ||
21 | |||
22 | public NoIdentifierTypeSpecifier(NodeOptional n0, NodeChoice n1, NodeOptional n2, NodeOptional n3) { | ||
23 | f0 = n0; | ||
24 | f1 = n1; | ||
25 | f2 = n2; | ||
26 | f3 = n3; | ||
27 | } | ||
28 | |||
29 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
30 | v.visit(this); | ||
31 | } | ||
32 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
33 | return v.visit(this,argu); | ||
34 | } | ||
35 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
36 | return v.visit(this); | ||
37 | } | ||
38 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
39 | v.visit(this,argu); | ||
40 | } | ||
41 | } | ||
42 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Node.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Node.java new file mode 100644 index 000000000..4ea3904db --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Node.java | |||
@@ -0,0 +1,16 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * The interface which all syntax tree classes must implement. | ||
9 | */ | ||
10 | public interface Node extends java.io.Serializable { | ||
11 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v); | ||
12 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu); | ||
13 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v); | ||
14 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu); | ||
15 | } | ||
16 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeChoice.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeChoice.java new file mode 100644 index 000000000..ff9a66d1b --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeChoice.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Represents a grammar choice, e.g. ( A | B ) | ||
9 | */ | ||
10 | public class NodeChoice implements Node { | ||
11 | public NodeChoice(Node node) { | ||
12 | this(node, -1); | ||
13 | } | ||
14 | |||
15 | public NodeChoice(Node node, int whichChoice) { | ||
16 | choice = node; | ||
17 | which = whichChoice; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | choice.accept(v); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return choice.accept(v,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return choice.accept(v); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | choice.accept(v,argu); | ||
31 | } | ||
32 | |||
33 | public Node choice; | ||
34 | public int which; | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeList.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeList.java new file mode 100644 index 000000000..36352b0f5 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeList.java | |||
@@ -0,0 +1,44 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | import java.util.*; | ||
8 | |||
9 | /** | ||
10 | * Represents a grammar list, e.g. ( A )+ | ||
11 | */ | ||
12 | public class NodeList implements NodeListInterface { | ||
13 | public NodeList() { | ||
14 | nodes = new Vector<Node>(); | ||
15 | } | ||
16 | |||
17 | public NodeList(Node firstNode) { | ||
18 | nodes = new Vector<Node>(); | ||
19 | addNode(firstNode); | ||
20 | } | ||
21 | |||
22 | public void addNode(Node n) { | ||
23 | nodes.addElement(n); | ||
24 | } | ||
25 | |||
26 | public Enumeration<Node> elements() { return nodes.elements(); } | ||
27 | public Node elementAt(int i) { return nodes.elementAt(i); } | ||
28 | public int size() { return nodes.size(); } | ||
29 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
30 | v.visit(this); | ||
31 | } | ||
32 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
33 | return v.visit(this,argu); | ||
34 | } | ||
35 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
36 | return v.visit(this); | ||
37 | } | ||
38 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
39 | v.visit(this,argu); | ||
40 | } | ||
41 | |||
42 | public Vector<Node> nodes; | ||
43 | } | ||
44 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeListInterface.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeListInterface.java new file mode 100644 index 000000000..5b37ab566 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeListInterface.java | |||
@@ -0,0 +1,22 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * The interface which NodeList, NodeListOptional, and NodeSequence | ||
9 | * implement. | ||
10 | */ | ||
11 | public interface NodeListInterface extends Node { | ||
12 | public void addNode(Node n); | ||
13 | public Node elementAt(int i); | ||
14 | public java.util.Enumeration<Node> elements(); | ||
15 | public int size(); | ||
16 | |||
17 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v); | ||
18 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu); | ||
19 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v); | ||
20 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu); | ||
21 | } | ||
22 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeListOptional.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeListOptional.java new file mode 100644 index 000000000..73ca45fd4 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeListOptional.java | |||
@@ -0,0 +1,45 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | import java.util.*; | ||
8 | |||
9 | /** | ||
10 | * Represents an optional grammar list, e.g. ( A )* | ||
11 | */ | ||
12 | public class NodeListOptional implements NodeListInterface { | ||
13 | public NodeListOptional() { | ||
14 | nodes = new Vector<Node>(); | ||
15 | } | ||
16 | |||
17 | public NodeListOptional(Node firstNode) { | ||
18 | nodes = new Vector<Node>(); | ||
19 | addNode(firstNode); | ||
20 | } | ||
21 | |||
22 | public void addNode(Node n) { | ||
23 | nodes.addElement(n); | ||
24 | } | ||
25 | |||
26 | public Enumeration<Node> elements() { return nodes.elements(); } | ||
27 | public Node elementAt(int i) { return nodes.elementAt(i); } | ||
28 | public int size() { return nodes.size(); } | ||
29 | public boolean present() { return nodes.size() != 0; } | ||
30 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
31 | v.visit(this); | ||
32 | } | ||
33 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
34 | return v.visit(this,argu); | ||
35 | } | ||
36 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
37 | return v.visit(this); | ||
38 | } | ||
39 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
40 | v.visit(this,argu); | ||
41 | } | ||
42 | |||
43 | public Vector<Node> nodes; | ||
44 | } | ||
45 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeOptional.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeOptional.java new file mode 100644 index 000000000..364c7c6c2 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeOptional.java | |||
@@ -0,0 +1,41 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Represents an grammar optional node, e.g. ( A )? or [ A ] | ||
9 | */ | ||
10 | public class NodeOptional implements Node { | ||
11 | public NodeOptional() { | ||
12 | node = null; | ||
13 | } | ||
14 | |||
15 | public NodeOptional(Node n) { | ||
16 | addNode(n); | ||
17 | } | ||
18 | |||
19 | public void addNode(Node n) { | ||
20 | if ( node != null) // Oh oh! | ||
21 | throw new Error("Attempt to set optional node twice"); | ||
22 | |||
23 | node = n; | ||
24 | } | ||
25 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
26 | v.visit(this); | ||
27 | } | ||
28 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
29 | return v.visit(this,argu); | ||
30 | } | ||
31 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
32 | return v.visit(this); | ||
33 | } | ||
34 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
35 | v.visit(this,argu); | ||
36 | } | ||
37 | public boolean present() { return node != null; } | ||
38 | |||
39 | public Node node; | ||
40 | } | ||
41 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeSequence.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeSequence.java new file mode 100644 index 000000000..63c09786a --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeSequence.java | |||
@@ -0,0 +1,45 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | import java.util.*; | ||
8 | |||
9 | /** | ||
10 | * Represents a sequence of nodes nested within a choice, list, | ||
11 | * optional list, or optional, e.g. ( A B )+ or [ C D E ] | ||
12 | */ | ||
13 | public class NodeSequence implements NodeListInterface { | ||
14 | public NodeSequence(int n) { | ||
15 | nodes = new Vector<Node>(n); | ||
16 | } | ||
17 | |||
18 | public NodeSequence(Node firstNode) { | ||
19 | nodes = new Vector<Node>(); | ||
20 | addNode(firstNode); | ||
21 | } | ||
22 | |||
23 | public void addNode(Node n) { | ||
24 | nodes.addElement(n); | ||
25 | } | ||
26 | |||
27 | public Node elementAt(int i) { return nodes.elementAt(i); } | ||
28 | public Enumeration<Node> elements() { return nodes.elements(); } | ||
29 | public int size() { return nodes.size(); } | ||
30 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
31 | v.visit(this); | ||
32 | } | ||
33 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
34 | return v.visit(this,argu); | ||
35 | } | ||
36 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
37 | return v.visit(this); | ||
38 | } | ||
39 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
40 | v.visit(this,argu); | ||
41 | } | ||
42 | |||
43 | public Vector<Node> nodes; | ||
44 | } | ||
45 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeToken.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeToken.java new file mode 100644 index 000000000..90db44d7a --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeToken.java | |||
@@ -0,0 +1,87 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | import java.util.*; | ||
8 | /** | ||
9 | * Represents a single token in the grammar. If the "-tk" option | ||
10 | * is used, also contains a Vector of preceding special tokens. | ||
11 | */ | ||
12 | public class NodeToken implements Node { | ||
13 | public NodeToken(String s) { | ||
14 | this(s, -1, -1, -1, -1, -1); } | ||
15 | |||
16 | public NodeToken(String s, int kind, int beginLine, int beginColumn, int endLine, int endColumn) { | ||
17 | tokenImage = s; | ||
18 | specialTokens = null; | ||
19 | this.kind = kind; | ||
20 | this.beginLine = beginLine; | ||
21 | this.beginColumn = beginColumn; | ||
22 | this.endLine = endLine; | ||
23 | this.endColumn = endColumn; | ||
24 | } | ||
25 | |||
26 | public NodeToken getSpecialAt(int i) { | ||
27 | if ( specialTokens == null ) | ||
28 | throw new java.util.NoSuchElementException("No specials in token"); | ||
29 | return specialTokens.elementAt(i); | ||
30 | } | ||
31 | |||
32 | public int numSpecials() { | ||
33 | if ( specialTokens == null ) return 0; | ||
34 | return specialTokens.size(); | ||
35 | } | ||
36 | |||
37 | public void addSpecial(NodeToken s) { | ||
38 | if ( specialTokens == null ) specialTokens = new Vector<NodeToken>(); | ||
39 | specialTokens.addElement(s); | ||
40 | } | ||
41 | |||
42 | public void trimSpecials() { | ||
43 | if ( specialTokens == null ) return; | ||
44 | specialTokens.trimToSize(); | ||
45 | } | ||
46 | |||
47 | public String toString() { return tokenImage; } | ||
48 | |||
49 | public String withSpecials() { | ||
50 | if ( specialTokens == null ) | ||
51 | return tokenImage; | ||
52 | |||
53 | StringBuffer buf = new StringBuffer(); | ||
54 | |||
55 | for ( Enumeration<NodeToken> e = specialTokens.elements(); e.hasMoreElements(); ) | ||
56 | buf.append(e.nextElement().toString()); | ||
57 | |||
58 | buf.append(tokenImage); | ||
59 | return buf.toString(); | ||
60 | } | ||
61 | |||
62 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
63 | v.visit(this); | ||
64 | } | ||
65 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
66 | return v.visit(this,argu); | ||
67 | } | ||
68 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
69 | return v.visit(this); | ||
70 | } | ||
71 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
72 | v.visit(this,argu); | ||
73 | } | ||
74 | |||
75 | public String tokenImage; | ||
76 | |||
77 | // Stores a list of NodeTokens | ||
78 | public Vector<NodeToken> specialTokens; | ||
79 | |||
80 | // -1 for these ints means no position info is available. | ||
81 | public int beginLine, beginColumn, endLine, endColumn; | ||
82 | |||
83 | // Equal to the JavaCC token "kind" integer. | ||
84 | // -1 if not available. | ||
85 | public int kind; | ||
86 | } | ||
87 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ParameterDeclaration.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ParameterDeclaration.java new file mode 100644 index 000000000..da7a71d44 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ParameterDeclaration.java | |||
@@ -0,0 +1,39 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> TypeSpecifier() | ||
11 | * f1 -> <IDENTIFIER> | ||
12 | * f2 -> [ Array() ] | ||
13 | * </PRE> | ||
14 | */ | ||
15 | public class ParameterDeclaration implements Node { | ||
16 | public TypeSpecifier f0; | ||
17 | public NodeToken f1; | ||
18 | public NodeOptional f2; | ||
19 | |||
20 | public ParameterDeclaration(TypeSpecifier n0, NodeToken n1, NodeOptional n2) { | ||
21 | f0 = n0; | ||
22 | f1 = n1; | ||
23 | f2 = n2; | ||
24 | } | ||
25 | |||
26 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
27 | v.visit(this); | ||
28 | } | ||
29 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
30 | return v.visit(this,argu); | ||
31 | } | ||
32 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
33 | return v.visit(this); | ||
34 | } | ||
35 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
36 | v.visit(this,argu); | ||
37 | } | ||
38 | } | ||
39 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ParameterList.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ParameterList.java new file mode 100644 index 000000000..d92fd41ff --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ParameterList.java | |||
@@ -0,0 +1,39 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ParameterDeclaration() | ||
11 | * f1 -> ( "," ParameterDeclaration() )* | ||
12 | * f2 -> [ "," "..." ] | ||
13 | * </PRE> | ||
14 | */ | ||
15 | public class ParameterList implements Node { | ||
16 | public ParameterDeclaration f0; | ||
17 | public NodeListOptional f1; | ||
18 | public NodeOptional f2; | ||
19 | |||
20 | public ParameterList(ParameterDeclaration n0, NodeListOptional n1, NodeOptional n2) { | ||
21 | f0 = n0; | ||
22 | f1 = n1; | ||
23 | f2 = n2; | ||
24 | } | ||
25 | |||
26 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
27 | v.visit(this); | ||
28 | } | ||
29 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
30 | return v.visit(this,argu); | ||
31 | } | ||
32 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
33 | return v.visit(this); | ||
34 | } | ||
35 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
36 | v.visit(this,argu); | ||
37 | } | ||
38 | } | ||
39 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Pointer.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Pointer.java new file mode 100644 index 000000000..56f175eb1 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Pointer.java | |||
@@ -0,0 +1,45 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> "*" | ||
11 | * f1 -> [ <CONST> ] | ||
12 | * f2 -> [ Pointer() ] | ||
13 | * </PRE> | ||
14 | */ | ||
15 | public class Pointer implements Node { | ||
16 | public NodeToken f0; | ||
17 | public NodeOptional f1; | ||
18 | public NodeOptional f2; | ||
19 | |||
20 | public Pointer(NodeToken n0, NodeOptional n1, NodeOptional n2) { | ||
21 | f0 = n0; | ||
22 | f1 = n1; | ||
23 | f2 = n2; | ||
24 | } | ||
25 | |||
26 | public Pointer(NodeOptional n0, NodeOptional n1) { | ||
27 | f0 = new NodeToken("*"); | ||
28 | f1 = n0; | ||
29 | f2 = n1; | ||
30 | } | ||
31 | |||
32 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
33 | v.visit(this); | ||
34 | } | ||
35 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
36 | return v.visit(this,argu); | ||
37 | } | ||
38 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
39 | return v.visit(this); | ||
40 | } | ||
41 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
42 | v.visit(this,argu); | ||
43 | } | ||
44 | } | ||
45 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/PostfixExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/PostfixExpression.java new file mode 100644 index 000000000..52e141504 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/PostfixExpression.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> PrimaryExpression() | ||
11 | * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )* | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class PostfixExpression implements Node { | ||
15 | public PrimaryExpression f0; | ||
16 | public NodeListOptional f1; | ||
17 | |||
18 | public PostfixExpression(PrimaryExpression n0, NodeListOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/PrimaryExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/PrimaryExpression.java new file mode 100644 index 000000000..fb953dccd --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/PrimaryExpression.java | |||
@@ -0,0 +1,35 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> <IDENTIFIER> | ||
11 | * | Constant() | ||
12 | * | "(" Expression() ")" | ||
13 | * </PRE> | ||
14 | */ | ||
15 | public class PrimaryExpression implements Node { | ||
16 | public NodeChoice f0; | ||
17 | |||
18 | public PrimaryExpression(NodeChoice n0) { | ||
19 | f0 = n0; | ||
20 | } | ||
21 | |||
22 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
23 | v.visit(this); | ||
24 | } | ||
25 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
26 | return v.visit(this,argu); | ||
27 | } | ||
28 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
29 | return v.visit(this); | ||
30 | } | ||
31 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
32 | v.visit(this,argu); | ||
33 | } | ||
34 | } | ||
35 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/RelationalExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/RelationalExpression.java new file mode 100644 index 000000000..5b823077b --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/RelationalExpression.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ShiftExpression() | ||
11 | * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ] | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class RelationalExpression implements Node { | ||
15 | public ShiftExpression f0; | ||
16 | public NodeOptional f1; | ||
17 | |||
18 | public RelationalExpression(ShiftExpression n0, NodeOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/SelectionStatement.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/SelectionStatement.java new file mode 100644 index 000000000..e3da4cf34 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/SelectionStatement.java | |||
@@ -0,0 +1,33 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() ) | ||
11 | * </PRE> | ||
12 | */ | ||
13 | public class SelectionStatement implements Node { | ||
14 | public NodeChoice f0; | ||
15 | |||
16 | public SelectionStatement(NodeChoice n0) { | ||
17 | f0 = n0; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | v.visit(this); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return v.visit(this,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return v.visit(this); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | v.visit(this,argu); | ||
31 | } | ||
32 | } | ||
33 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ShiftExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ShiftExpression.java new file mode 100644 index 000000000..b3c9e5b0f --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ShiftExpression.java | |||
@@ -0,0 +1,36 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> AdditiveExpression() | ||
11 | * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ] | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class ShiftExpression implements Node { | ||
15 | public AdditiveExpression f0; | ||
16 | public NodeOptional f1; | ||
17 | |||
18 | public ShiftExpression(AdditiveExpression n0, NodeOptional n1) { | ||
19 | f0 = n0; | ||
20 | f1 = n1; | ||
21 | } | ||
22 | |||
23 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
24 | v.visit(this); | ||
25 | } | ||
26 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
27 | return v.visit(this,argu); | ||
28 | } | ||
29 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
30 | return v.visit(this); | ||
31 | } | ||
32 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
33 | v.visit(this,argu); | ||
34 | } | ||
35 | } | ||
36 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Statement.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Statement.java new file mode 100644 index 000000000..27148dfe7 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Statement.java | |||
@@ -0,0 +1,33 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() ) | ||
11 | * </PRE> | ||
12 | */ | ||
13 | public class Statement implements Node { | ||
14 | public NodeChoice f0; | ||
15 | |||
16 | public Statement(NodeChoice n0) { | ||
17 | f0 = n0; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | v.visit(this); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return v.visit(this,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return v.visit(this); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | v.visit(this,argu); | ||
31 | } | ||
32 | } | ||
33 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StorageClassSpecifier.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StorageClassSpecifier.java new file mode 100644 index 000000000..223839f96 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StorageClassSpecifier.java | |||
@@ -0,0 +1,33 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ( <STATIC> | <EXTERN> ) | ||
11 | * </PRE> | ||
12 | */ | ||
13 | public class StorageClassSpecifier implements Node { | ||
14 | public NodeChoice f0; | ||
15 | |||
16 | public StorageClassSpecifier(NodeChoice n0) { | ||
17 | f0 = n0; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | v.visit(this); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return v.visit(this,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return v.visit(this); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | v.visit(this,argu); | ||
31 | } | ||
32 | } | ||
33 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructDeclaration.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructDeclaration.java new file mode 100644 index 000000000..074ec4266 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructDeclaration.java | |||
@@ -0,0 +1,53 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> TypeSpecifier() | ||
11 | * f1 -> <IDENTIFIER> | ||
12 | * f2 -> [ Array() | ":" ConstantExpression() ] | ||
13 | * f3 -> [ <IDENTIFIER> ] | ||
14 | * f4 -> ";" | ||
15 | * </PRE> | ||
16 | */ | ||
17 | public class StructDeclaration implements Node { | ||
18 | public TypeSpecifier f0; | ||
19 | public NodeToken f1; | ||
20 | public NodeOptional f2; | ||
21 | public NodeOptional f3; | ||
22 | public NodeToken f4; | ||
23 | |||
24 | public StructDeclaration(TypeSpecifier n0, NodeToken n1, NodeOptional n2, NodeOptional n3, NodeToken n4) { | ||
25 | f0 = n0; | ||
26 | f1 = n1; | ||
27 | f2 = n2; | ||
28 | f3 = n3; | ||
29 | f4 = n4; | ||
30 | } | ||
31 | |||
32 | public StructDeclaration(TypeSpecifier n0, NodeToken n1, NodeOptional n2, NodeOptional n3) { | ||
33 | f0 = n0; | ||
34 | f1 = n1; | ||
35 | f2 = n2; | ||
36 | f3 = n3; | ||
37 | f4 = new NodeToken(";"); | ||
38 | } | ||
39 | |||
40 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
41 | v.visit(this); | ||
42 | } | ||
43 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
44 | return v.visit(this,argu); | ||
45 | } | ||
46 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
47 | return v.visit(this); | ||
48 | } | ||
49 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
50 | v.visit(this,argu); | ||
51 | } | ||
52 | } | ||
53 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructDeclarationList.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructDeclarationList.java new file mode 100644 index 000000000..32d081495 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructDeclarationList.java | |||
@@ -0,0 +1,33 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ( StructDeclaration() )+ | ||
11 | * </PRE> | ||
12 | */ | ||
13 | public class StructDeclarationList implements Node { | ||
14 | public NodeList f0; | ||
15 | |||
16 | public StructDeclarationList(NodeList n0) { | ||
17 | f0 = n0; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | v.visit(this); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return v.visit(this,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return v.visit(this); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | v.visit(this,argu); | ||
31 | } | ||
32 | } | ||
33 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructOrUnion.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructOrUnion.java new file mode 100644 index 000000000..2131d7a6b --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructOrUnion.java | |||
@@ -0,0 +1,33 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ( <STRUCT> | <UNION> ) | ||
11 | * </PRE> | ||
12 | */ | ||
13 | public class StructOrUnion implements Node { | ||
14 | public NodeChoice f0; | ||
15 | |||
16 | public StructOrUnion(NodeChoice n0) { | ||
17 | f0 = n0; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | v.visit(this); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return v.visit(this,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return v.visit(this); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | v.visit(this,argu); | ||
31 | } | ||
32 | } | ||
33 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructOrUnionSpecifier.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructOrUnionSpecifier.java new file mode 100644 index 000000000..aa64929be --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructOrUnionSpecifier.java | |||
@@ -0,0 +1,34 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}" | ||
11 | * | StructOrUnion() <IDENTIFIER> | ||
12 | * </PRE> | ||
13 | */ | ||
14 | public class StructOrUnionSpecifier implements Node { | ||
15 | public NodeChoice f0; | ||
16 | |||
17 | public StructOrUnionSpecifier(NodeChoice n0) { | ||
18 | f0 = n0; | ||
19 | } | ||
20 | |||
21 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
22 | v.visit(this); | ||
23 | } | ||
24 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
25 | return v.visit(this,argu); | ||
26 | } | ||
27 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
28 | return v.visit(this); | ||
29 | } | ||
30 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
31 | v.visit(this,argu); | ||
32 | } | ||
33 | } | ||
34 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TranslationUnit.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TranslationUnit.java new file mode 100644 index 000000000..feb48f646 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TranslationUnit.java | |||
@@ -0,0 +1,33 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ( ExternalDeclaration() )+ | ||
11 | * </PRE> | ||
12 | */ | ||
13 | public class TranslationUnit implements Node { | ||
14 | public NodeList f0; | ||
15 | |||
16 | public TranslationUnit(NodeList n0) { | ||
17 | f0 = n0; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | v.visit(this); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return v.visit(this,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return v.visit(this); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | v.visit(this,argu); | ||
31 | } | ||
32 | } | ||
33 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TypeDeclaration.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TypeDeclaration.java new file mode 100644 index 000000000..500aecaf3 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TypeDeclaration.java | |||
@@ -0,0 +1,45 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> <TYPEDEF> | ||
11 | * f1 -> ( DataType() | FunctionType() ) | ||
12 | * f2 -> ";" | ||
13 | * </PRE> | ||
14 | */ | ||
15 | public class TypeDeclaration implements Node { | ||
16 | public NodeToken f0; | ||
17 | public NodeChoice f1; | ||
18 | public NodeToken f2; | ||
19 | |||
20 | public TypeDeclaration(NodeToken n0, NodeChoice n1, NodeToken n2) { | ||
21 | f0 = n0; | ||
22 | f1 = n1; | ||
23 | f2 = n2; | ||
24 | } | ||
25 | |||
26 | public TypeDeclaration(NodeChoice n0) { | ||
27 | f0 = new NodeToken("typedef"); | ||
28 | f1 = n0; | ||
29 | f2 = new NodeToken(";"); | ||
30 | } | ||
31 | |||
32 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
33 | v.visit(this); | ||
34 | } | ||
35 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
36 | return v.visit(this,argu); | ||
37 | } | ||
38 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
39 | return v.visit(this); | ||
40 | } | ||
41 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
42 | v.visit(this,argu); | ||
43 | } | ||
44 | } | ||
45 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TypeSpecifier.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TypeSpecifier.java new file mode 100644 index 000000000..6d1607d1a --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TypeSpecifier.java | |||
@@ -0,0 +1,42 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> [ <CONST> ] | ||
11 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> ) | ||
12 | * f2 -> [ Pointer() ] | ||
13 | * f3 -> [ Array() ] | ||
14 | * </PRE> | ||
15 | */ | ||
16 | public class TypeSpecifier implements Node { | ||
17 | public NodeOptional f0; | ||
18 | public NodeChoice f1; | ||
19 | public NodeOptional f2; | ||
20 | public NodeOptional f3; | ||
21 | |||
22 | public TypeSpecifier(NodeOptional n0, NodeChoice n1, NodeOptional n2, NodeOptional n3) { | ||
23 | f0 = n0; | ||
24 | f1 = n1; | ||
25 | f2 = n2; | ||
26 | f3 = n3; | ||
27 | } | ||
28 | |||
29 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
30 | v.visit(this); | ||
31 | } | ||
32 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
33 | return v.visit(this,argu); | ||
34 | } | ||
35 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
36 | return v.visit(this); | ||
37 | } | ||
38 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
39 | v.visit(this,argu); | ||
40 | } | ||
41 | } | ||
42 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/UnaryExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/UnaryExpression.java new file mode 100644 index 000000000..1e7894e23 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/UnaryExpression.java | |||
@@ -0,0 +1,33 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) ) | ||
11 | * </PRE> | ||
12 | */ | ||
13 | public class UnaryExpression implements Node { | ||
14 | public NodeChoice f0; | ||
15 | |||
16 | public UnaryExpression(NodeChoice n0) { | ||
17 | f0 = n0; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | v.visit(this); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return v.visit(this,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return v.visit(this); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | v.visit(this,argu); | ||
31 | } | ||
32 | } | ||
33 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/UnaryOperator.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/UnaryOperator.java new file mode 100644 index 000000000..630af9d21 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/UnaryOperator.java | |||
@@ -0,0 +1,33 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" ) | ||
11 | * </PRE> | ||
12 | */ | ||
13 | public class UnaryOperator implements Node { | ||
14 | public NodeChoice f0; | ||
15 | |||
16 | public UnaryOperator(NodeChoice n0) { | ||
17 | f0 = n0; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | v.visit(this); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return v.visit(this,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return v.visit(this); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | v.visit(this,argu); | ||
31 | } | ||
32 | } | ||
33 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/VariableClassSpecifier.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/VariableClassSpecifier.java new file mode 100644 index 000000000..5a9101937 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/VariableClassSpecifier.java | |||
@@ -0,0 +1,33 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> ( <AUTO> | <REGISTER> )* | ||
11 | * </PRE> | ||
12 | */ | ||
13 | public class VariableClassSpecifier implements Node { | ||
14 | public NodeListOptional f0; | ||
15 | |||
16 | public VariableClassSpecifier(NodeListOptional n0) { | ||
17 | f0 = n0; | ||
18 | } | ||
19 | |||
20 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
21 | v.visit(this); | ||
22 | } | ||
23 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
24 | return v.visit(this,argu); | ||
25 | } | ||
26 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
27 | return v.visit(this); | ||
28 | } | ||
29 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
30 | v.visit(this,argu); | ||
31 | } | ||
32 | } | ||
33 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/VariableDeclaration.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/VariableDeclaration.java new file mode 100644 index 000000000..aa7cf6e32 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/VariableDeclaration.java | |||
@@ -0,0 +1,49 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.nodes; | ||
6 | |||
7 | /** | ||
8 | * Grammar production: | ||
9 | * <PRE> | ||
10 | * f0 -> VariableClassSpecifier() | ||
11 | * f1 -> TypeSpecifier() | ||
12 | * f2 -> InitDeclaratorList() | ||
13 | * f3 -> ";" | ||
14 | * </PRE> | ||
15 | */ | ||
16 | public class VariableDeclaration implements Node { | ||
17 | public VariableClassSpecifier f0; | ||
18 | public TypeSpecifier f1; | ||
19 | public InitDeclaratorList f2; | ||
20 | public NodeToken f3; | ||
21 | |||
22 | public VariableDeclaration(VariableClassSpecifier n0, TypeSpecifier n1, InitDeclaratorList n2, NodeToken n3) { | ||
23 | f0 = n0; | ||
24 | f1 = n1; | ||
25 | f2 = n2; | ||
26 | f3 = n3; | ||
27 | } | ||
28 | |||
29 | public VariableDeclaration(VariableClassSpecifier n0, TypeSpecifier n1, InitDeclaratorList n2) { | ||
30 | f0 = n0; | ||
31 | f1 = n1; | ||
32 | f2 = n2; | ||
33 | f3 = new NodeToken(";"); | ||
34 | } | ||
35 | |||
36 | public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { | ||
37 | v.visit(this); | ||
38 | } | ||
39 | public <R,A> R accept(org.gnunet.seaspider.parser.visitors.GJVisitor<R,A> v, A argu) { | ||
40 | return v.visit(this,argu); | ||
41 | } | ||
42 | public <R> R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor<R> v) { | ||
43 | return v.visit(this); | ||
44 | } | ||
45 | public <A> void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor<A> v, A argu) { | ||
46 | v.visit(this,argu); | ||
47 | } | ||
48 | } | ||
49 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/DepthFirstVisitor.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/DepthFirstVisitor.java new file mode 100644 index 000000000..57c92b752 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/DepthFirstVisitor.java | |||
@@ -0,0 +1,701 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.visitors; | ||
6 | import org.gnunet.seaspider.parser.nodes.*; | ||
7 | |||
8 | import java.util.*; | ||
9 | |||
10 | /** | ||
11 | * Provides default methods which visit each node in the tree in depth-first | ||
12 | * order. Your visitors may extend this class. | ||
13 | */ | ||
14 | public class DepthFirstVisitor implements Visitor { | ||
15 | // | ||
16 | // Auto class visitors--probably don't need to be overridden. | ||
17 | // | ||
18 | public void visit(NodeList n) { | ||
19 | for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) | ||
20 | e.nextElement().accept(this); | ||
21 | } | ||
22 | |||
23 | public void visit(NodeListOptional n) { | ||
24 | if ( n.present() ) | ||
25 | for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) | ||
26 | e.nextElement().accept(this); | ||
27 | } | ||
28 | |||
29 | public void visit(NodeOptional n) { | ||
30 | if ( n.present() ) | ||
31 | n.node.accept(this); | ||
32 | } | ||
33 | |||
34 | public void visit(NodeSequence n) { | ||
35 | for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) | ||
36 | e.nextElement().accept(this); | ||
37 | } | ||
38 | |||
39 | public void visit(NodeToken n) { } | ||
40 | |||
41 | // | ||
42 | // User-generated visitor methods below | ||
43 | // | ||
44 | |||
45 | /** | ||
46 | * <PRE> | ||
47 | * f0 -> ( ExternalDeclaration() )+ | ||
48 | * </PRE> | ||
49 | */ | ||
50 | public void visit(TranslationUnit n) { | ||
51 | n.f0.accept(this); | ||
52 | } | ||
53 | |||
54 | /** | ||
55 | * <PRE> | ||
56 | * f0 -> ( StorageClassSpecifier() )* | ||
57 | * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() ) | ||
58 | * </PRE> | ||
59 | */ | ||
60 | public void visit(ExternalDeclaration n) { | ||
61 | n.f0.accept(this); | ||
62 | n.f1.accept(this); | ||
63 | } | ||
64 | |||
65 | /** | ||
66 | * <PRE> | ||
67 | * f0 -> TypeSpecifier() | ||
68 | * f1 -> <IDENTIFIER> | ||
69 | * f2 -> "(" | ||
70 | * f3 -> [ ParameterList() ] | ||
71 | * f4 -> ")" | ||
72 | * f5 -> ( ";" | CompoundStatement() ) | ||
73 | * </PRE> | ||
74 | */ | ||
75 | public void visit(FunctionDeclaration n) { | ||
76 | n.f0.accept(this); | ||
77 | n.f1.accept(this); | ||
78 | n.f2.accept(this); | ||
79 | n.f3.accept(this); | ||
80 | n.f4.accept(this); | ||
81 | n.f5.accept(this); | ||
82 | } | ||
83 | |||
84 | /** | ||
85 | * <PRE> | ||
86 | * f0 -> ( <STATIC> | <EXTERN> ) | ||
87 | * </PRE> | ||
88 | */ | ||
89 | public void visit(StorageClassSpecifier n) { | ||
90 | n.f0.accept(this); | ||
91 | } | ||
92 | |||
93 | /** | ||
94 | * <PRE> | ||
95 | * f0 -> <TYPEDEF> | ||
96 | * f1 -> ( DataType() | FunctionType() ) | ||
97 | * f2 -> ";" | ||
98 | * </PRE> | ||
99 | */ | ||
100 | public void visit(TypeDeclaration n) { | ||
101 | n.f0.accept(this); | ||
102 | n.f1.accept(this); | ||
103 | n.f2.accept(this); | ||
104 | } | ||
105 | |||
106 | /** | ||
107 | * <PRE> | ||
108 | * f0 -> StructOrUnionSpecifier() | ||
109 | * f1 -> <IDENTIFIER> | ||
110 | * </PRE> | ||
111 | */ | ||
112 | public void visit(DataType n) { | ||
113 | n.f0.accept(this); | ||
114 | n.f1.accept(this); | ||
115 | } | ||
116 | |||
117 | /** | ||
118 | * <PRE> | ||
119 | * f0 -> TypeSpecifier() | ||
120 | * f1 -> "(" | ||
121 | * f2 -> "*" | ||
122 | * f3 -> <IDENTIFIER> | ||
123 | * f4 -> ")" | ||
124 | * f5 -> "(" | ||
125 | * f6 -> [ ParameterList() ] | ||
126 | * f7 -> ")" | ||
127 | * </PRE> | ||
128 | */ | ||
129 | public void visit(FunctionType n) { | ||
130 | n.f0.accept(this); | ||
131 | n.f1.accept(this); | ||
132 | n.f2.accept(this); | ||
133 | n.f3.accept(this); | ||
134 | n.f4.accept(this); | ||
135 | n.f5.accept(this); | ||
136 | n.f6.accept(this); | ||
137 | n.f7.accept(this); | ||
138 | } | ||
139 | |||
140 | /** | ||
141 | * <PRE> | ||
142 | * f0 -> ParameterDeclaration() | ||
143 | * f1 -> ( "," ParameterDeclaration() )* | ||
144 | * f2 -> [ "," "..." ] | ||
145 | * </PRE> | ||
146 | */ | ||
147 | public void visit(ParameterList n) { | ||
148 | n.f0.accept(this); | ||
149 | n.f1.accept(this); | ||
150 | n.f2.accept(this); | ||
151 | } | ||
152 | |||
153 | /** | ||
154 | * <PRE> | ||
155 | * f0 -> TypeSpecifier() | ||
156 | * f1 -> <IDENTIFIER> | ||
157 | * f2 -> [ Array() ] | ||
158 | * </PRE> | ||
159 | */ | ||
160 | public void visit(ParameterDeclaration n) { | ||
161 | n.f0.accept(this); | ||
162 | n.f1.accept(this); | ||
163 | n.f2.accept(this); | ||
164 | } | ||
165 | |||
166 | /** | ||
167 | * <PRE> | ||
168 | * f0 -> VariableClassSpecifier() | ||
169 | * f1 -> TypeSpecifier() | ||
170 | * f2 -> InitDeclaratorList() | ||
171 | * f3 -> ";" | ||
172 | * </PRE> | ||
173 | */ | ||
174 | public void visit(VariableDeclaration n) { | ||
175 | n.f0.accept(this); | ||
176 | n.f1.accept(this); | ||
177 | n.f2.accept(this); | ||
178 | n.f3.accept(this); | ||
179 | } | ||
180 | |||
181 | /** | ||
182 | * <PRE> | ||
183 | * f0 -> [ <STATIC> ] | ||
184 | * f1 -> VariableDeclaration() | ||
185 | * </PRE> | ||
186 | */ | ||
187 | public void visit(LocalVariableDeclaration n) { | ||
188 | n.f0.accept(this); | ||
189 | n.f1.accept(this); | ||
190 | } | ||
191 | |||
192 | /** | ||
193 | * <PRE> | ||
194 | * f0 -> ( <AUTO> | <REGISTER> )* | ||
195 | * </PRE> | ||
196 | */ | ||
197 | public void visit(VariableClassSpecifier n) { | ||
198 | n.f0.accept(this); | ||
199 | } | ||
200 | |||
201 | /** | ||
202 | * <PRE> | ||
203 | * f0 -> [ <CONST> ] | ||
204 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> ) | ||
205 | * f2 -> [ Pointer() ] | ||
206 | * f3 -> [ Array() ] | ||
207 | * </PRE> | ||
208 | */ | ||
209 | public void visit(TypeSpecifier n) { | ||
210 | n.f0.accept(this); | ||
211 | n.f1.accept(this); | ||
212 | n.f2.accept(this); | ||
213 | n.f3.accept(this); | ||
214 | } | ||
215 | |||
216 | /** | ||
217 | * <PRE> | ||
218 | * f0 -> [ <CONST> ] | ||
219 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() ) | ||
220 | * f2 -> [ Pointer() ] | ||
221 | * f3 -> [ Array() ] | ||
222 | * </PRE> | ||
223 | */ | ||
224 | public void visit(NoIdentifierTypeSpecifier n) { | ||
225 | n.f0.accept(this); | ||
226 | n.f1.accept(this); | ||
227 | n.f2.accept(this); | ||
228 | n.f3.accept(this); | ||
229 | } | ||
230 | |||
231 | /** | ||
232 | * <PRE> | ||
233 | * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}" | ||
234 | * | StructOrUnion() <IDENTIFIER> | ||
235 | * </PRE> | ||
236 | */ | ||
237 | public void visit(StructOrUnionSpecifier n) { | ||
238 | n.f0.accept(this); | ||
239 | } | ||
240 | |||
241 | /** | ||
242 | * <PRE> | ||
243 | * f0 -> ( <STRUCT> | <UNION> ) | ||
244 | * </PRE> | ||
245 | */ | ||
246 | public void visit(StructOrUnion n) { | ||
247 | n.f0.accept(this); | ||
248 | } | ||
249 | |||
250 | /** | ||
251 | * <PRE> | ||
252 | * f0 -> ( StructDeclaration() )+ | ||
253 | * </PRE> | ||
254 | */ | ||
255 | public void visit(StructDeclarationList n) { | ||
256 | n.f0.accept(this); | ||
257 | } | ||
258 | |||
259 | /** | ||
260 | * <PRE> | ||
261 | * f0 -> InitDeclarator() | ||
262 | * f1 -> ( "," InitDeclarator() )* | ||
263 | * </PRE> | ||
264 | */ | ||
265 | public void visit(InitDeclaratorList n) { | ||
266 | n.f0.accept(this); | ||
267 | n.f1.accept(this); | ||
268 | } | ||
269 | |||
270 | /** | ||
271 | * <PRE> | ||
272 | * f0 -> <IDENTIFIER> | ||
273 | * f1 -> [ Array() ] | ||
274 | * f2 -> [ "=" Initializer() ] | ||
275 | * </PRE> | ||
276 | */ | ||
277 | public void visit(InitDeclarator n) { | ||
278 | n.f0.accept(this); | ||
279 | n.f1.accept(this); | ||
280 | n.f2.accept(this); | ||
281 | } | ||
282 | |||
283 | /** | ||
284 | * <PRE> | ||
285 | * f0 -> TypeSpecifier() | ||
286 | * f1 -> <IDENTIFIER> | ||
287 | * f2 -> [ Array() | ":" ConstantExpression() ] | ||
288 | * f3 -> [ <IDENTIFIER> ] | ||
289 | * f4 -> ";" | ||
290 | * </PRE> | ||
291 | */ | ||
292 | public void visit(StructDeclaration n) { | ||
293 | n.f0.accept(this); | ||
294 | n.f1.accept(this); | ||
295 | n.f2.accept(this); | ||
296 | n.f3.accept(this); | ||
297 | n.f4.accept(this); | ||
298 | } | ||
299 | |||
300 | /** | ||
301 | * <PRE> | ||
302 | * f0 -> <ENUM> | ||
303 | * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> ) | ||
304 | * </PRE> | ||
305 | */ | ||
306 | public void visit(EnumSpecifier n) { | ||
307 | n.f0.accept(this); | ||
308 | n.f1.accept(this); | ||
309 | } | ||
310 | |||
311 | /** | ||
312 | * <PRE> | ||
313 | * f0 -> Enumerator() | ||
314 | * f1 -> ( "," Enumerator() )* | ||
315 | * </PRE> | ||
316 | */ | ||
317 | public void visit(EnumeratorList n) { | ||
318 | n.f0.accept(this); | ||
319 | n.f1.accept(this); | ||
320 | } | ||
321 | |||
322 | /** | ||
323 | * <PRE> | ||
324 | * f0 -> <IDENTIFIER> | ||
325 | * f1 -> [ "=" ConstantExpression() ] | ||
326 | * </PRE> | ||
327 | */ | ||
328 | public void visit(Enumerator n) { | ||
329 | n.f0.accept(this); | ||
330 | n.f1.accept(this); | ||
331 | } | ||
332 | |||
333 | /** | ||
334 | * <PRE> | ||
335 | * f0 -> "*" | ||
336 | * f1 -> [ <CONST> ] | ||
337 | * f2 -> [ Pointer() ] | ||
338 | * </PRE> | ||
339 | */ | ||
340 | public void visit(Pointer n) { | ||
341 | n.f0.accept(this); | ||
342 | n.f1.accept(this); | ||
343 | n.f2.accept(this); | ||
344 | } | ||
345 | |||
346 | /** | ||
347 | * <PRE> | ||
348 | * f0 -> <IDENTIFIER> | ||
349 | * f1 -> ( "," <IDENTIFIER> )* | ||
350 | * </PRE> | ||
351 | */ | ||
352 | public void visit(IdentifierList n) { | ||
353 | n.f0.accept(this); | ||
354 | n.f1.accept(this); | ||
355 | } | ||
356 | |||
357 | /** | ||
358 | * <PRE> | ||
359 | * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" ) | ||
360 | * </PRE> | ||
361 | */ | ||
362 | public void visit(Initializer n) { | ||
363 | n.f0.accept(this); | ||
364 | } | ||
365 | |||
366 | /** | ||
367 | * <PRE> | ||
368 | * f0 -> Initializer() | ||
369 | * f1 -> ( "," Initializer() )* | ||
370 | * </PRE> | ||
371 | */ | ||
372 | public void visit(InitializerList n) { | ||
373 | n.f0.accept(this); | ||
374 | n.f1.accept(this); | ||
375 | } | ||
376 | |||
377 | /** | ||
378 | * <PRE> | ||
379 | * f0 -> "[" | ||
380 | * f1 -> [ ConstantExpression() ] | ||
381 | * f2 -> "]" | ||
382 | * </PRE> | ||
383 | */ | ||
384 | public void visit(Array n) { | ||
385 | n.f0.accept(this); | ||
386 | n.f1.accept(this); | ||
387 | n.f2.accept(this); | ||
388 | } | ||
389 | |||
390 | /** | ||
391 | * <PRE> | ||
392 | * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() ) | ||
393 | * </PRE> | ||
394 | */ | ||
395 | public void visit(Statement n) { | ||
396 | n.f0.accept(this); | ||
397 | } | ||
398 | |||
399 | /** | ||
400 | * <PRE> | ||
401 | * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() ) | ||
402 | * </PRE> | ||
403 | */ | ||
404 | public void visit(LabeledStatement n) { | ||
405 | n.f0.accept(this); | ||
406 | } | ||
407 | |||
408 | /** | ||
409 | * <PRE> | ||
410 | * f0 -> [ Expression() ] | ||
411 | * f1 -> ";" | ||
412 | * </PRE> | ||
413 | */ | ||
414 | public void visit(ExpressionStatement n) { | ||
415 | n.f0.accept(this); | ||
416 | n.f1.accept(this); | ||
417 | } | ||
418 | |||
419 | /** | ||
420 | * <PRE> | ||
421 | * f0 -> "{" | ||
422 | * f1 -> ( LocalVariableDeclaration() | Statement() )* | ||
423 | * f2 -> "}" | ||
424 | * </PRE> | ||
425 | */ | ||
426 | public void visit(CompoundStatement n) { | ||
427 | n.f0.accept(this); | ||
428 | n.f1.accept(this); | ||
429 | n.f2.accept(this); | ||
430 | } | ||
431 | |||
432 | /** | ||
433 | * <PRE> | ||
434 | * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() ) | ||
435 | * </PRE> | ||
436 | */ | ||
437 | public void visit(SelectionStatement n) { | ||
438 | n.f0.accept(this); | ||
439 | } | ||
440 | |||
441 | /** | ||
442 | * <PRE> | ||
443 | * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() ) | ||
444 | * </PRE> | ||
445 | */ | ||
446 | public void visit(IterationStatement n) { | ||
447 | n.f0.accept(this); | ||
448 | } | ||
449 | |||
450 | /** | ||
451 | * <PRE> | ||
452 | * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" ) | ||
453 | * </PRE> | ||
454 | */ | ||
455 | public void visit(JumpStatement n) { | ||
456 | n.f0.accept(this); | ||
457 | } | ||
458 | |||
459 | /** | ||
460 | * <PRE> | ||
461 | * f0 -> AssignmentExpression() | ||
462 | * f1 -> ( "," AssignmentExpression() )* | ||
463 | * </PRE> | ||
464 | */ | ||
465 | public void visit(Expression n) { | ||
466 | n.f0.accept(this); | ||
467 | n.f1.accept(this); | ||
468 | } | ||
469 | |||
470 | /** | ||
471 | * <PRE> | ||
472 | * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression() | ||
473 | * | ConditionalExpression() | ||
474 | * </PRE> | ||
475 | */ | ||
476 | public void visit(AssignmentExpression n) { | ||
477 | n.f0.accept(this); | ||
478 | } | ||
479 | |||
480 | /** | ||
481 | * <PRE> | ||
482 | * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" ) | ||
483 | * </PRE> | ||
484 | */ | ||
485 | public void visit(AssignmentOperator n) { | ||
486 | n.f0.accept(this); | ||
487 | } | ||
488 | |||
489 | /** | ||
490 | * <PRE> | ||
491 | * f0 -> LogicalORExpression() | ||
492 | * f1 -> [ "?" Expression() ":" ConditionalExpression() ] | ||
493 | * </PRE> | ||
494 | */ | ||
495 | public void visit(ConditionalExpression n) { | ||
496 | n.f0.accept(this); | ||
497 | n.f1.accept(this); | ||
498 | } | ||
499 | |||
500 | /** | ||
501 | * <PRE> | ||
502 | * f0 -> ConditionalExpression() | ||
503 | * </PRE> | ||
504 | */ | ||
505 | public void visit(ConstantExpression n) { | ||
506 | n.f0.accept(this); | ||
507 | } | ||
508 | |||
509 | /** | ||
510 | * <PRE> | ||
511 | * f0 -> LogicalANDExpression() | ||
512 | * f1 -> [ "||" LogicalORExpression() ] | ||
513 | * </PRE> | ||
514 | */ | ||
515 | public void visit(LogicalORExpression n) { | ||
516 | n.f0.accept(this); | ||
517 | n.f1.accept(this); | ||
518 | } | ||
519 | |||
520 | /** | ||
521 | * <PRE> | ||
522 | * f0 -> InclusiveORExpression() | ||
523 | * f1 -> [ "&&" LogicalANDExpression() ] | ||
524 | * </PRE> | ||
525 | */ | ||
526 | public void visit(LogicalANDExpression n) { | ||
527 | n.f0.accept(this); | ||
528 | n.f1.accept(this); | ||
529 | } | ||
530 | |||
531 | /** | ||
532 | * <PRE> | ||
533 | * f0 -> ExclusiveORExpression() | ||
534 | * f1 -> [ "|" InclusiveORExpression() ] | ||
535 | * </PRE> | ||
536 | */ | ||
537 | public void visit(InclusiveORExpression n) { | ||
538 | n.f0.accept(this); | ||
539 | n.f1.accept(this); | ||
540 | } | ||
541 | |||
542 | /** | ||
543 | * <PRE> | ||
544 | * f0 -> ANDExpression() | ||
545 | * f1 -> [ "^" ExclusiveORExpression() ] | ||
546 | * </PRE> | ||
547 | */ | ||
548 | public void visit(ExclusiveORExpression n) { | ||
549 | n.f0.accept(this); | ||
550 | n.f1.accept(this); | ||
551 | } | ||
552 | |||
553 | /** | ||
554 | * <PRE> | ||
555 | * f0 -> EqualityExpression() | ||
556 | * f1 -> [ "&" ANDExpression() ] | ||
557 | * </PRE> | ||
558 | */ | ||
559 | public void visit(ANDExpression n) { | ||
560 | n.f0.accept(this); | ||
561 | n.f1.accept(this); | ||
562 | } | ||
563 | |||
564 | /** | ||
565 | * <PRE> | ||
566 | * f0 -> RelationalExpression() | ||
567 | * f1 -> [ ( "==" | "!=" ) EqualityExpression() ] | ||
568 | * </PRE> | ||
569 | */ | ||
570 | public void visit(EqualityExpression n) { | ||
571 | n.f0.accept(this); | ||
572 | n.f1.accept(this); | ||
573 | } | ||
574 | |||
575 | /** | ||
576 | * <PRE> | ||
577 | * f0 -> ShiftExpression() | ||
578 | * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ] | ||
579 | * </PRE> | ||
580 | */ | ||
581 | public void visit(RelationalExpression n) { | ||
582 | n.f0.accept(this); | ||
583 | n.f1.accept(this); | ||
584 | } | ||
585 | |||
586 | /** | ||
587 | * <PRE> | ||
588 | * f0 -> AdditiveExpression() | ||
589 | * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ] | ||
590 | * </PRE> | ||
591 | */ | ||
592 | public void visit(ShiftExpression n) { | ||
593 | n.f0.accept(this); | ||
594 | n.f1.accept(this); | ||
595 | } | ||
596 | |||
597 | /** | ||
598 | * <PRE> | ||
599 | * f0 -> MultiplicativeExpression() | ||
600 | * f1 -> [ ( "+" | "-" ) AdditiveExpression() ] | ||
601 | * </PRE> | ||
602 | */ | ||
603 | public void visit(AdditiveExpression n) { | ||
604 | n.f0.accept(this); | ||
605 | n.f1.accept(this); | ||
606 | } | ||
607 | |||
608 | /** | ||
609 | * <PRE> | ||
610 | * f0 -> CastExpression() | ||
611 | * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ] | ||
612 | * </PRE> | ||
613 | */ | ||
614 | public void visit(MultiplicativeExpression n) { | ||
615 | n.f0.accept(this); | ||
616 | n.f1.accept(this); | ||
617 | } | ||
618 | |||
619 | /** | ||
620 | * <PRE> | ||
621 | * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() ) | ||
622 | * </PRE> | ||
623 | */ | ||
624 | public void visit(CastExpression n) { | ||
625 | n.f0.accept(this); | ||
626 | } | ||
627 | |||
628 | /** | ||
629 | * <PRE> | ||
630 | * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) ) | ||
631 | * </PRE> | ||
632 | */ | ||
633 | public void visit(UnaryExpression n) { | ||
634 | n.f0.accept(this); | ||
635 | } | ||
636 | |||
637 | /** | ||
638 | * <PRE> | ||
639 | * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" ) | ||
640 | * </PRE> | ||
641 | */ | ||
642 | public void visit(UnaryOperator n) { | ||
643 | n.f0.accept(this); | ||
644 | } | ||
645 | |||
646 | /** | ||
647 | * <PRE> | ||
648 | * f0 -> PrimaryExpression() | ||
649 | * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )* | ||
650 | * </PRE> | ||
651 | */ | ||
652 | public void visit(PostfixExpression n) { | ||
653 | n.f0.accept(this); | ||
654 | n.f1.accept(this); | ||
655 | } | ||
656 | |||
657 | /** | ||
658 | * <PRE> | ||
659 | * f0 -> <IDENTIFIER> | ||
660 | * | Constant() | ||
661 | * | "(" Expression() ")" | ||
662 | * </PRE> | ||
663 | */ | ||
664 | public void visit(PrimaryExpression n) { | ||
665 | n.f0.accept(this); | ||
666 | } | ||
667 | |||
668 | /** | ||
669 | * <PRE> | ||
670 | * f0 -> AssignmentOrTypeExpression() | ||
671 | * f1 -> ( "," AssignmentOrTypeExpression() )* | ||
672 | * </PRE> | ||
673 | */ | ||
674 | public void visit(ArgumentExpressionList n) { | ||
675 | n.f0.accept(this); | ||
676 | n.f1.accept(this); | ||
677 | } | ||
678 | |||
679 | /** | ||
680 | * <PRE> | ||
681 | * f0 -> NoIdentifierTypeSpecifier() | ||
682 | * | AssignmentExpression() | ||
683 | * </PRE> | ||
684 | */ | ||
685 | public void visit(AssignmentOrTypeExpression n) { | ||
686 | n.f0.accept(this); | ||
687 | } | ||
688 | |||
689 | /** | ||
690 | * <PRE> | ||
691 | * f0 -> <INTEGER_LITERAL> | ||
692 | * | <FLOATING_POINT_LITERAL> | ||
693 | * | <CHARACTER_LITERAL> | ||
694 | * | <STRING_LITERAL> | ||
695 | * </PRE> | ||
696 | */ | ||
697 | public void visit(Constant n) { | ||
698 | n.f0.accept(this); | ||
699 | } | ||
700 | |||
701 | } | ||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJDepthFirst.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJDepthFirst.java new file mode 100644 index 000000000..2ac3fd812 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJDepthFirst.java | |||
@@ -0,0 +1,837 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.visitors; | ||
6 | import org.gnunet.seaspider.parser.nodes.*; | ||
7 | |||
8 | import java.util.*; | ||
9 | |||
10 | /** | ||
11 | * Provides default methods which visit each node in the tree in depth-first | ||
12 | * order. Your visitors may extend this class. | ||
13 | */ | ||
14 | public class GJDepthFirst<R,A> implements GJVisitor<R,A> { | ||
15 | // | ||
16 | // Auto class visitors--probably don't need to be overridden. | ||
17 | // | ||
18 | public R visit(NodeList n, A argu) { | ||
19 | R _ret=null; | ||
20 | int _count=0; | ||
21 | for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) { | ||
22 | e.nextElement().accept(this,argu); | ||
23 | _count++; | ||
24 | } | ||
25 | return _ret; | ||
26 | } | ||
27 | |||
28 | public R visit(NodeListOptional n, A argu) { | ||
29 | if ( n.present() ) { | ||
30 | R _ret=null; | ||
31 | int _count=0; | ||
32 | for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) { | ||
33 | e.nextElement().accept(this,argu); | ||
34 | _count++; | ||
35 | } | ||
36 | return _ret; | ||
37 | } | ||
38 | else | ||
39 | return null; | ||
40 | } | ||
41 | |||
42 | public R visit(NodeOptional n, A argu) { | ||
43 | if ( n.present() ) | ||
44 | return n.node.accept(this,argu); | ||
45 | else | ||
46 | return null; | ||
47 | } | ||
48 | |||
49 | public R visit(NodeSequence n, A argu) { | ||
50 | R _ret=null; | ||
51 | int _count=0; | ||
52 | for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) { | ||
53 | e.nextElement().accept(this,argu); | ||
54 | _count++; | ||
55 | } | ||
56 | return _ret; | ||
57 | } | ||
58 | |||
59 | public R visit(NodeToken n, A argu) { return null; } | ||
60 | |||
61 | // | ||
62 | // User-generated visitor methods below | ||
63 | // | ||
64 | |||
65 | /** | ||
66 | * <PRE> | ||
67 | * f0 -> ( ExternalDeclaration() )+ | ||
68 | * </PRE> | ||
69 | */ | ||
70 | public R visit(TranslationUnit n, A argu) { | ||
71 | R _ret=null; | ||
72 | n.f0.accept(this, argu); | ||
73 | return _ret; | ||
74 | } | ||
75 | |||
76 | /** | ||
77 | * <PRE> | ||
78 | * f0 -> ( StorageClassSpecifier() )* | ||
79 | * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() ) | ||
80 | * </PRE> | ||
81 | */ | ||
82 | public R visit(ExternalDeclaration n, A argu) { | ||
83 | R _ret=null; | ||
84 | n.f0.accept(this, argu); | ||
85 | n.f1.accept(this, argu); | ||
86 | return _ret; | ||
87 | } | ||
88 | |||
89 | /** | ||
90 | * <PRE> | ||
91 | * f0 -> TypeSpecifier() | ||
92 | * f1 -> <IDENTIFIER> | ||
93 | * f2 -> "(" | ||
94 | * f3 -> [ ParameterList() ] | ||
95 | * f4 -> ")" | ||
96 | * f5 -> ( ";" | CompoundStatement() ) | ||
97 | * </PRE> | ||
98 | */ | ||
99 | public R visit(FunctionDeclaration n, A argu) { | ||
100 | R _ret=null; | ||
101 | n.f0.accept(this, argu); | ||
102 | n.f1.accept(this, argu); | ||
103 | n.f2.accept(this, argu); | ||
104 | n.f3.accept(this, argu); | ||
105 | n.f4.accept(this, argu); | ||
106 | n.f5.accept(this, argu); | ||
107 | return _ret; | ||
108 | } | ||
109 | |||
110 | /** | ||
111 | * <PRE> | ||
112 | * f0 -> ( <STATIC> | <EXTERN> ) | ||
113 | * </PRE> | ||
114 | */ | ||
115 | public R visit(StorageClassSpecifier n, A argu) { | ||
116 | R _ret=null; | ||
117 | n.f0.accept(this, argu); | ||
118 | return _ret; | ||
119 | } | ||
120 | |||
121 | /** | ||
122 | * <PRE> | ||
123 | * f0 -> <TYPEDEF> | ||
124 | * f1 -> ( DataType() | FunctionType() ) | ||
125 | * f2 -> ";" | ||
126 | * </PRE> | ||
127 | */ | ||
128 | public R visit(TypeDeclaration n, A argu) { | ||
129 | R _ret=null; | ||
130 | n.f0.accept(this, argu); | ||
131 | n.f1.accept(this, argu); | ||
132 | n.f2.accept(this, argu); | ||
133 | return _ret; | ||
134 | } | ||
135 | |||
136 | /** | ||
137 | * <PRE> | ||
138 | * f0 -> StructOrUnionSpecifier() | ||
139 | * f1 -> <IDENTIFIER> | ||
140 | * </PRE> | ||
141 | */ | ||
142 | public R visit(DataType n, A argu) { | ||
143 | R _ret=null; | ||
144 | n.f0.accept(this, argu); | ||
145 | n.f1.accept(this, argu); | ||
146 | return _ret; | ||
147 | } | ||
148 | |||
149 | /** | ||
150 | * <PRE> | ||
151 | * f0 -> TypeSpecifier() | ||
152 | * f1 -> "(" | ||
153 | * f2 -> "*" | ||
154 | * f3 -> <IDENTIFIER> | ||
155 | * f4 -> ")" | ||
156 | * f5 -> "(" | ||
157 | * f6 -> [ ParameterList() ] | ||
158 | * f7 -> ")" | ||
159 | * </PRE> | ||
160 | */ | ||
161 | public R visit(FunctionType n, A argu) { | ||
162 | R _ret=null; | ||
163 | n.f0.accept(this, argu); | ||
164 | n.f1.accept(this, argu); | ||
165 | n.f2.accept(this, argu); | ||
166 | n.f3.accept(this, argu); | ||
167 | n.f4.accept(this, argu); | ||
168 | n.f5.accept(this, argu); | ||
169 | n.f6.accept(this, argu); | ||
170 | n.f7.accept(this, argu); | ||
171 | return _ret; | ||
172 | } | ||
173 | |||
174 | /** | ||
175 | * <PRE> | ||
176 | * f0 -> ParameterDeclaration() | ||
177 | * f1 -> ( "," ParameterDeclaration() )* | ||
178 | * f2 -> [ "," "..." ] | ||
179 | * </PRE> | ||
180 | */ | ||
181 | public R visit(ParameterList n, A argu) { | ||
182 | R _ret=null; | ||
183 | n.f0.accept(this, argu); | ||
184 | n.f1.accept(this, argu); | ||
185 | n.f2.accept(this, argu); | ||
186 | return _ret; | ||
187 | } | ||
188 | |||
189 | /** | ||
190 | * <PRE> | ||
191 | * f0 -> TypeSpecifier() | ||
192 | * f1 -> <IDENTIFIER> | ||
193 | * f2 -> [ Array() ] | ||
194 | * </PRE> | ||
195 | */ | ||
196 | public R visit(ParameterDeclaration n, A argu) { | ||
197 | R _ret=null; | ||
198 | n.f0.accept(this, argu); | ||
199 | n.f1.accept(this, argu); | ||
200 | n.f2.accept(this, argu); | ||
201 | return _ret; | ||
202 | } | ||
203 | |||
204 | /** | ||
205 | * <PRE> | ||
206 | * f0 -> VariableClassSpecifier() | ||
207 | * f1 -> TypeSpecifier() | ||
208 | * f2 -> InitDeclaratorList() | ||
209 | * f3 -> ";" | ||
210 | * </PRE> | ||
211 | */ | ||
212 | public R visit(VariableDeclaration n, A argu) { | ||
213 | R _ret=null; | ||
214 | n.f0.accept(this, argu); | ||
215 | n.f1.accept(this, argu); | ||
216 | n.f2.accept(this, argu); | ||
217 | n.f3.accept(this, argu); | ||
218 | return _ret; | ||
219 | } | ||
220 | |||
221 | /** | ||
222 | * <PRE> | ||
223 | * f0 -> [ <STATIC> ] | ||
224 | * f1 -> VariableDeclaration() | ||
225 | * </PRE> | ||
226 | */ | ||
227 | public R visit(LocalVariableDeclaration n, A argu) { | ||
228 | R _ret=null; | ||
229 | n.f0.accept(this, argu); | ||
230 | n.f1.accept(this, argu); | ||
231 | return _ret; | ||
232 | } | ||
233 | |||
234 | /** | ||
235 | * <PRE> | ||
236 | * f0 -> ( <AUTO> | <REGISTER> )* | ||
237 | * </PRE> | ||
238 | */ | ||
239 | public R visit(VariableClassSpecifier n, A argu) { | ||
240 | R _ret=null; | ||
241 | n.f0.accept(this, argu); | ||
242 | return _ret; | ||
243 | } | ||
244 | |||
245 | /** | ||
246 | * <PRE> | ||
247 | * f0 -> [ <CONST> ] | ||
248 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> ) | ||
249 | * f2 -> [ Pointer() ] | ||
250 | * f3 -> [ Array() ] | ||
251 | * </PRE> | ||
252 | */ | ||
253 | public R visit(TypeSpecifier n, A argu) { | ||
254 | R _ret=null; | ||
255 | n.f0.accept(this, argu); | ||
256 | n.f1.accept(this, argu); | ||
257 | n.f2.accept(this, argu); | ||
258 | n.f3.accept(this, argu); | ||
259 | return _ret; | ||
260 | } | ||
261 | |||
262 | /** | ||
263 | * <PRE> | ||
264 | * f0 -> [ <CONST> ] | ||
265 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() ) | ||
266 | * f2 -> [ Pointer() ] | ||
267 | * f3 -> [ Array() ] | ||
268 | * </PRE> | ||
269 | */ | ||
270 | public R visit(NoIdentifierTypeSpecifier n, A argu) { | ||
271 | R _ret=null; | ||
272 | n.f0.accept(this, argu); | ||
273 | n.f1.accept(this, argu); | ||
274 | n.f2.accept(this, argu); | ||
275 | n.f3.accept(this, argu); | ||
276 | return _ret; | ||
277 | } | ||
278 | |||
279 | /** | ||
280 | * <PRE> | ||
281 | * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}" | ||
282 | * | StructOrUnion() <IDENTIFIER> | ||
283 | * </PRE> | ||
284 | */ | ||
285 | public R visit(StructOrUnionSpecifier n, A argu) { | ||
286 | R _ret=null; | ||
287 | n.f0.accept(this, argu); | ||
288 | return _ret; | ||
289 | } | ||
290 | |||
291 | /** | ||
292 | * <PRE> | ||
293 | * f0 -> ( <STRUCT> | <UNION> ) | ||
294 | * </PRE> | ||
295 | */ | ||
296 | public R visit(StructOrUnion n, A argu) { | ||
297 | R _ret=null; | ||
298 | n.f0.accept(this, argu); | ||
299 | return _ret; | ||
300 | } | ||
301 | |||
302 | /** | ||
303 | * <PRE> | ||
304 | * f0 -> ( StructDeclaration() )+ | ||
305 | * </PRE> | ||
306 | */ | ||
307 | public R visit(StructDeclarationList n, A argu) { | ||
308 | R _ret=null; | ||
309 | n.f0.accept(this, argu); | ||
310 | return _ret; | ||
311 | } | ||
312 | |||
313 | /** | ||
314 | * <PRE> | ||
315 | * f0 -> InitDeclarator() | ||
316 | * f1 -> ( "," InitDeclarator() )* | ||
317 | * </PRE> | ||
318 | */ | ||
319 | public R visit(InitDeclaratorList n, A argu) { | ||
320 | R _ret=null; | ||
321 | n.f0.accept(this, argu); | ||
322 | n.f1.accept(this, argu); | ||
323 | return _ret; | ||
324 | } | ||
325 | |||
326 | /** | ||
327 | * <PRE> | ||
328 | * f0 -> <IDENTIFIER> | ||
329 | * f1 -> [ Array() ] | ||
330 | * f2 -> [ "=" Initializer() ] | ||
331 | * </PRE> | ||
332 | */ | ||
333 | public R visit(InitDeclarator n, A argu) { | ||
334 | R _ret=null; | ||
335 | n.f0.accept(this, argu); | ||
336 | n.f1.accept(this, argu); | ||
337 | n.f2.accept(this, argu); | ||
338 | return _ret; | ||
339 | } | ||
340 | |||
341 | /** | ||
342 | * <PRE> | ||
343 | * f0 -> TypeSpecifier() | ||
344 | * f1 -> <IDENTIFIER> | ||
345 | * f2 -> [ Array() | ":" ConstantExpression() ] | ||
346 | * f3 -> [ <IDENTIFIER> ] | ||
347 | * f4 -> ";" | ||
348 | * </PRE> | ||
349 | */ | ||
350 | public R visit(StructDeclaration n, A argu) { | ||
351 | R _ret=null; | ||
352 | n.f0.accept(this, argu); | ||
353 | n.f1.accept(this, argu); | ||
354 | n.f2.accept(this, argu); | ||
355 | n.f3.accept(this, argu); | ||
356 | n.f4.accept(this, argu); | ||
357 | return _ret; | ||
358 | } | ||
359 | |||
360 | /** | ||
361 | * <PRE> | ||
362 | * f0 -> <ENUM> | ||
363 | * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> ) | ||
364 | * </PRE> | ||
365 | */ | ||
366 | public R visit(EnumSpecifier n, A argu) { | ||
367 | R _ret=null; | ||
368 | n.f0.accept(this, argu); | ||
369 | n.f1.accept(this, argu); | ||
370 | return _ret; | ||
371 | } | ||
372 | |||
373 | /** | ||
374 | * <PRE> | ||
375 | * f0 -> Enumerator() | ||
376 | * f1 -> ( "," Enumerator() )* | ||
377 | * </PRE> | ||
378 | */ | ||
379 | public R visit(EnumeratorList n, A argu) { | ||
380 | R _ret=null; | ||
381 | n.f0.accept(this, argu); | ||
382 | n.f1.accept(this, argu); | ||
383 | return _ret; | ||
384 | } | ||
385 | |||
386 | /** | ||
387 | * <PRE> | ||
388 | * f0 -> <IDENTIFIER> | ||
389 | * f1 -> [ "=" ConstantExpression() ] | ||
390 | * </PRE> | ||
391 | */ | ||
392 | public R visit(Enumerator n, A argu) { | ||
393 | R _ret=null; | ||
394 | n.f0.accept(this, argu); | ||
395 | n.f1.accept(this, argu); | ||
396 | return _ret; | ||
397 | } | ||
398 | |||
399 | /** | ||
400 | * <PRE> | ||
401 | * f0 -> "*" | ||
402 | * f1 -> [ <CONST> ] | ||
403 | * f2 -> [ Pointer() ] | ||
404 | * </PRE> | ||
405 | */ | ||
406 | public R visit(Pointer n, A argu) { | ||
407 | R _ret=null; | ||
408 | n.f0.accept(this, argu); | ||
409 | n.f1.accept(this, argu); | ||
410 | n.f2.accept(this, argu); | ||
411 | return _ret; | ||
412 | } | ||
413 | |||
414 | /** | ||
415 | * <PRE> | ||
416 | * f0 -> <IDENTIFIER> | ||
417 | * f1 -> ( "," <IDENTIFIER> )* | ||
418 | * </PRE> | ||
419 | */ | ||
420 | public R visit(IdentifierList n, A argu) { | ||
421 | R _ret=null; | ||
422 | n.f0.accept(this, argu); | ||
423 | n.f1.accept(this, argu); | ||
424 | return _ret; | ||
425 | } | ||
426 | |||
427 | /** | ||
428 | * <PRE> | ||
429 | * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" ) | ||
430 | * </PRE> | ||
431 | */ | ||
432 | public R visit(Initializer n, A argu) { | ||
433 | R _ret=null; | ||
434 | n.f0.accept(this, argu); | ||
435 | return _ret; | ||
436 | } | ||
437 | |||
438 | /** | ||
439 | * <PRE> | ||
440 | * f0 -> Initializer() | ||
441 | * f1 -> ( "," Initializer() )* | ||
442 | * </PRE> | ||
443 | */ | ||
444 | public R visit(InitializerList n, A argu) { | ||
445 | R _ret=null; | ||
446 | n.f0.accept(this, argu); | ||
447 | n.f1.accept(this, argu); | ||
448 | return _ret; | ||
449 | } | ||
450 | |||
451 | /** | ||
452 | * <PRE> | ||
453 | * f0 -> "[" | ||
454 | * f1 -> [ ConstantExpression() ] | ||
455 | * f2 -> "]" | ||
456 | * </PRE> | ||
457 | */ | ||
458 | public R visit(Array n, A argu) { | ||
459 | R _ret=null; | ||
460 | n.f0.accept(this, argu); | ||
461 | n.f1.accept(this, argu); | ||
462 | n.f2.accept(this, argu); | ||
463 | return _ret; | ||
464 | } | ||
465 | |||
466 | /** | ||
467 | * <PRE> | ||
468 | * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() ) | ||
469 | * </PRE> | ||
470 | */ | ||
471 | public R visit(Statement n, A argu) { | ||
472 | R _ret=null; | ||
473 | n.f0.accept(this, argu); | ||
474 | return _ret; | ||
475 | } | ||
476 | |||
477 | /** | ||
478 | * <PRE> | ||
479 | * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() ) | ||
480 | * </PRE> | ||
481 | */ | ||
482 | public R visit(LabeledStatement n, A argu) { | ||
483 | R _ret=null; | ||
484 | n.f0.accept(this, argu); | ||
485 | return _ret; | ||
486 | } | ||
487 | |||
488 | /** | ||
489 | * <PRE> | ||
490 | * f0 -> [ Expression() ] | ||
491 | * f1 -> ";" | ||
492 | * </PRE> | ||
493 | */ | ||
494 | public R visit(ExpressionStatement n, A argu) { | ||
495 | R _ret=null; | ||
496 | n.f0.accept(this, argu); | ||
497 | n.f1.accept(this, argu); | ||
498 | return _ret; | ||
499 | } | ||
500 | |||
501 | /** | ||
502 | * <PRE> | ||
503 | * f0 -> "{" | ||
504 | * f1 -> ( LocalVariableDeclaration() | Statement() )* | ||
505 | * f2 -> "}" | ||
506 | * </PRE> | ||
507 | */ | ||
508 | public R visit(CompoundStatement n, A argu) { | ||
509 | R _ret=null; | ||
510 | n.f0.accept(this, argu); | ||
511 | n.f1.accept(this, argu); | ||
512 | n.f2.accept(this, argu); | ||
513 | return _ret; | ||
514 | } | ||
515 | |||
516 | /** | ||
517 | * <PRE> | ||
518 | * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() ) | ||
519 | * </PRE> | ||
520 | */ | ||
521 | public R visit(SelectionStatement n, A argu) { | ||
522 | R _ret=null; | ||
523 | n.f0.accept(this, argu); | ||
524 | return _ret; | ||
525 | } | ||
526 | |||
527 | /** | ||
528 | * <PRE> | ||
529 | * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() ) | ||
530 | * </PRE> | ||
531 | */ | ||
532 | public R visit(IterationStatement n, A argu) { | ||
533 | R _ret=null; | ||
534 | n.f0.accept(this, argu); | ||
535 | return _ret; | ||
536 | } | ||
537 | |||
538 | /** | ||
539 | * <PRE> | ||
540 | * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" ) | ||
541 | * </PRE> | ||
542 | */ | ||
543 | public R visit(JumpStatement n, A argu) { | ||
544 | R _ret=null; | ||
545 | n.f0.accept(this, argu); | ||
546 | return _ret; | ||
547 | } | ||
548 | |||
549 | /** | ||
550 | * <PRE> | ||
551 | * f0 -> AssignmentExpression() | ||
552 | * f1 -> ( "," AssignmentExpression() )* | ||
553 | * </PRE> | ||
554 | */ | ||
555 | public R visit(Expression n, A argu) { | ||
556 | R _ret=null; | ||
557 | n.f0.accept(this, argu); | ||
558 | n.f1.accept(this, argu); | ||
559 | return _ret; | ||
560 | } | ||
561 | |||
562 | /** | ||
563 | * <PRE> | ||
564 | * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression() | ||
565 | * | ConditionalExpression() | ||
566 | * </PRE> | ||
567 | */ | ||
568 | public R visit(AssignmentExpression n, A argu) { | ||
569 | R _ret=null; | ||
570 | n.f0.accept(this, argu); | ||
571 | return _ret; | ||
572 | } | ||
573 | |||
574 | /** | ||
575 | * <PRE> | ||
576 | * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" ) | ||
577 | * </PRE> | ||
578 | */ | ||
579 | public R visit(AssignmentOperator n, A argu) { | ||
580 | R _ret=null; | ||
581 | n.f0.accept(this, argu); | ||
582 | return _ret; | ||
583 | } | ||
584 | |||
585 | /** | ||
586 | * <PRE> | ||
587 | * f0 -> LogicalORExpression() | ||
588 | * f1 -> [ "?" Expression() ":" ConditionalExpression() ] | ||
589 | * </PRE> | ||
590 | */ | ||
591 | public R visit(ConditionalExpression n, A argu) { | ||
592 | R _ret=null; | ||
593 | n.f0.accept(this, argu); | ||
594 | n.f1.accept(this, argu); | ||
595 | return _ret; | ||
596 | } | ||
597 | |||
598 | /** | ||
599 | * <PRE> | ||
600 | * f0 -> ConditionalExpression() | ||
601 | * </PRE> | ||
602 | */ | ||
603 | public R visit(ConstantExpression n, A argu) { | ||
604 | R _ret=null; | ||
605 | n.f0.accept(this, argu); | ||
606 | return _ret; | ||
607 | } | ||
608 | |||
609 | /** | ||
610 | * <PRE> | ||
611 | * f0 -> LogicalANDExpression() | ||
612 | * f1 -> [ "||" LogicalORExpression() ] | ||
613 | * </PRE> | ||
614 | */ | ||
615 | public R visit(LogicalORExpression n, A argu) { | ||
616 | R _ret=null; | ||
617 | n.f0.accept(this, argu); | ||
618 | n.f1.accept(this, argu); | ||
619 | return _ret; | ||
620 | } | ||
621 | |||
622 | /** | ||
623 | * <PRE> | ||
624 | * f0 -> InclusiveORExpression() | ||
625 | * f1 -> [ "&&" LogicalANDExpression() ] | ||
626 | * </PRE> | ||
627 | */ | ||
628 | public R visit(LogicalANDExpression n, A argu) { | ||
629 | R _ret=null; | ||
630 | n.f0.accept(this, argu); | ||
631 | n.f1.accept(this, argu); | ||
632 | return _ret; | ||
633 | } | ||
634 | |||
635 | /** | ||
636 | * <PRE> | ||
637 | * f0 -> ExclusiveORExpression() | ||
638 | * f1 -> [ "|" InclusiveORExpression() ] | ||
639 | * </PRE> | ||
640 | */ | ||
641 | public R visit(InclusiveORExpression n, A argu) { | ||
642 | R _ret=null; | ||
643 | n.f0.accept(this, argu); | ||
644 | n.f1.accept(this, argu); | ||
645 | return _ret; | ||
646 | } | ||
647 | |||
648 | /** | ||
649 | * <PRE> | ||
650 | * f0 -> ANDExpression() | ||
651 | * f1 -> [ "^" ExclusiveORExpression() ] | ||
652 | * </PRE> | ||
653 | */ | ||
654 | public R visit(ExclusiveORExpression n, A argu) { | ||
655 | R _ret=null; | ||
656 | n.f0.accept(this, argu); | ||
657 | n.f1.accept(this, argu); | ||
658 | return _ret; | ||
659 | } | ||
660 | |||
661 | /** | ||
662 | * <PRE> | ||
663 | * f0 -> EqualityExpression() | ||
664 | * f1 -> [ "&" ANDExpression() ] | ||
665 | * </PRE> | ||
666 | */ | ||
667 | public R visit(ANDExpression n, A argu) { | ||
668 | R _ret=null; | ||
669 | n.f0.accept(this, argu); | ||
670 | n.f1.accept(this, argu); | ||
671 | return _ret; | ||
672 | } | ||
673 | |||
674 | /** | ||
675 | * <PRE> | ||
676 | * f0 -> RelationalExpression() | ||
677 | * f1 -> [ ( "==" | "!=" ) EqualityExpression() ] | ||
678 | * </PRE> | ||
679 | */ | ||
680 | public R visit(EqualityExpression n, A argu) { | ||
681 | R _ret=null; | ||
682 | n.f0.accept(this, argu); | ||
683 | n.f1.accept(this, argu); | ||
684 | return _ret; | ||
685 | } | ||
686 | |||
687 | /** | ||
688 | * <PRE> | ||
689 | * f0 -> ShiftExpression() | ||
690 | * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ] | ||
691 | * </PRE> | ||
692 | */ | ||
693 | public R visit(RelationalExpression n, A argu) { | ||
694 | R _ret=null; | ||
695 | n.f0.accept(this, argu); | ||
696 | n.f1.accept(this, argu); | ||
697 | return _ret; | ||
698 | } | ||
699 | |||
700 | /** | ||
701 | * <PRE> | ||
702 | * f0 -> AdditiveExpression() | ||
703 | * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ] | ||
704 | * </PRE> | ||
705 | */ | ||
706 | public R visit(ShiftExpression n, A argu) { | ||
707 | R _ret=null; | ||
708 | n.f0.accept(this, argu); | ||
709 | n.f1.accept(this, argu); | ||
710 | return _ret; | ||
711 | } | ||
712 | |||
713 | /** | ||
714 | * <PRE> | ||
715 | * f0 -> MultiplicativeExpression() | ||
716 | * f1 -> [ ( "+" | "-" ) AdditiveExpression() ] | ||
717 | * </PRE> | ||
718 | */ | ||
719 | public R visit(AdditiveExpression n, A argu) { | ||
720 | R _ret=null; | ||
721 | n.f0.accept(this, argu); | ||
722 | n.f1.accept(this, argu); | ||
723 | return _ret; | ||
724 | } | ||
725 | |||
726 | /** | ||
727 | * <PRE> | ||
728 | * f0 -> CastExpression() | ||
729 | * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ] | ||
730 | * </PRE> | ||
731 | */ | ||
732 | public R visit(MultiplicativeExpression n, A argu) { | ||
733 | R _ret=null; | ||
734 | n.f0.accept(this, argu); | ||
735 | n.f1.accept(this, argu); | ||
736 | return _ret; | ||
737 | } | ||
738 | |||
739 | /** | ||
740 | * <PRE> | ||
741 | * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() ) | ||
742 | * </PRE> | ||
743 | */ | ||
744 | public R visit(CastExpression n, A argu) { | ||
745 | R _ret=null; | ||
746 | n.f0.accept(this, argu); | ||
747 | return _ret; | ||
748 | } | ||
749 | |||
750 | /** | ||
751 | * <PRE> | ||
752 | * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) ) | ||
753 | * </PRE> | ||
754 | */ | ||
755 | public R visit(UnaryExpression n, A argu) { | ||
756 | R _ret=null; | ||
757 | n.f0.accept(this, argu); | ||
758 | return _ret; | ||
759 | } | ||
760 | |||
761 | /** | ||
762 | * <PRE> | ||
763 | * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" ) | ||
764 | * </PRE> | ||
765 | */ | ||
766 | public R visit(UnaryOperator n, A argu) { | ||
767 | R _ret=null; | ||
768 | n.f0.accept(this, argu); | ||
769 | return _ret; | ||
770 | } | ||
771 | |||
772 | /** | ||
773 | * <PRE> | ||
774 | * f0 -> PrimaryExpression() | ||
775 | * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )* | ||
776 | * </PRE> | ||
777 | */ | ||
778 | public R visit(PostfixExpression n, A argu) { | ||
779 | R _ret=null; | ||
780 | n.f0.accept(this, argu); | ||
781 | n.f1.accept(this, argu); | ||
782 | return _ret; | ||
783 | } | ||
784 | |||
785 | /** | ||
786 | * <PRE> | ||
787 | * f0 -> <IDENTIFIER> | ||
788 | * | Constant() | ||
789 | * | "(" Expression() ")" | ||
790 | * </PRE> | ||
791 | */ | ||
792 | public R visit(PrimaryExpression n, A argu) { | ||
793 | R _ret=null; | ||
794 | n.f0.accept(this, argu); | ||
795 | return _ret; | ||
796 | } | ||
797 | |||
798 | /** | ||
799 | * <PRE> | ||
800 | * f0 -> AssignmentOrTypeExpression() | ||
801 | * f1 -> ( "," AssignmentOrTypeExpression() )* | ||
802 | * </PRE> | ||
803 | */ | ||
804 | public R visit(ArgumentExpressionList n, A argu) { | ||
805 | R _ret=null; | ||
806 | n.f0.accept(this, argu); | ||
807 | n.f1.accept(this, argu); | ||
808 | return _ret; | ||
809 | } | ||
810 | |||
811 | /** | ||
812 | * <PRE> | ||
813 | * f0 -> NoIdentifierTypeSpecifier() | ||
814 | * | AssignmentExpression() | ||
815 | * </PRE> | ||
816 | */ | ||
817 | public R visit(AssignmentOrTypeExpression n, A argu) { | ||
818 | R _ret=null; | ||
819 | n.f0.accept(this, argu); | ||
820 | return _ret; | ||
821 | } | ||
822 | |||
823 | /** | ||
824 | * <PRE> | ||
825 | * f0 -> <INTEGER_LITERAL> | ||
826 | * | <FLOATING_POINT_LITERAL> | ||
827 | * | <CHARACTER_LITERAL> | ||
828 | * | <STRING_LITERAL> | ||
829 | * </PRE> | ||
830 | */ | ||
831 | public R visit(Constant n, A argu) { | ||
832 | R _ret=null; | ||
833 | n.f0.accept(this, argu); | ||
834 | return _ret; | ||
835 | } | ||
836 | |||
837 | } | ||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJNoArguDepthFirst.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJNoArguDepthFirst.java new file mode 100644 index 000000000..fb13e7a2c --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJNoArguDepthFirst.java | |||
@@ -0,0 +1,837 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.visitors; | ||
6 | import org.gnunet.seaspider.parser.nodes.*; | ||
7 | |||
8 | import java.util.*; | ||
9 | |||
10 | /** | ||
11 | * Provides default methods which visit each node in the tree in depth-first | ||
12 | * order. Your visitors may extend this class. | ||
13 | */ | ||
14 | public class GJNoArguDepthFirst<R> implements GJNoArguVisitor<R> { | ||
15 | // | ||
16 | // Auto class visitors--probably don't need to be overridden. | ||
17 | // | ||
18 | public R visit(NodeList n) { | ||
19 | R _ret=null; | ||
20 | int _count=0; | ||
21 | for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) { | ||
22 | e.nextElement().accept(this); | ||
23 | _count++; | ||
24 | } | ||
25 | return _ret; | ||
26 | } | ||
27 | |||
28 | public R visit(NodeListOptional n) { | ||
29 | if ( n.present() ) { | ||
30 | R _ret=null; | ||
31 | int _count=0; | ||
32 | for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) { | ||
33 | e.nextElement().accept(this); | ||
34 | _count++; | ||
35 | } | ||
36 | return _ret; | ||
37 | } | ||
38 | else | ||
39 | return null; | ||
40 | } | ||
41 | |||
42 | public R visit(NodeOptional n) { | ||
43 | if ( n.present() ) | ||
44 | return n.node.accept(this); | ||
45 | else | ||
46 | return null; | ||
47 | } | ||
48 | |||
49 | public R visit(NodeSequence n) { | ||
50 | R _ret=null; | ||
51 | int _count=0; | ||
52 | for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) { | ||
53 | e.nextElement().accept(this); | ||
54 | _count++; | ||
55 | } | ||
56 | return _ret; | ||
57 | } | ||
58 | |||
59 | public R visit(NodeToken n) { return null; } | ||
60 | |||
61 | // | ||
62 | // User-generated visitor methods below | ||
63 | // | ||
64 | |||
65 | /** | ||
66 | * <PRE> | ||
67 | * f0 -> ( ExternalDeclaration() )+ | ||
68 | * </PRE> | ||
69 | */ | ||
70 | public R visit(TranslationUnit n) { | ||
71 | R _ret=null; | ||
72 | n.f0.accept(this); | ||
73 | return _ret; | ||
74 | } | ||
75 | |||
76 | /** | ||
77 | * <PRE> | ||
78 | * f0 -> ( StorageClassSpecifier() )* | ||
79 | * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() ) | ||
80 | * </PRE> | ||
81 | */ | ||
82 | public R visit(ExternalDeclaration n) { | ||
83 | R _ret=null; | ||
84 | n.f0.accept(this); | ||
85 | n.f1.accept(this); | ||
86 | return _ret; | ||
87 | } | ||
88 | |||
89 | /** | ||
90 | * <PRE> | ||
91 | * f0 -> TypeSpecifier() | ||
92 | * f1 -> <IDENTIFIER> | ||
93 | * f2 -> "(" | ||
94 | * f3 -> [ ParameterList() ] | ||
95 | * f4 -> ")" | ||
96 | * f5 -> ( ";" | CompoundStatement() ) | ||
97 | * </PRE> | ||
98 | */ | ||
99 | public R visit(FunctionDeclaration n) { | ||
100 | R _ret=null; | ||
101 | n.f0.accept(this); | ||
102 | n.f1.accept(this); | ||
103 | n.f2.accept(this); | ||
104 | n.f3.accept(this); | ||
105 | n.f4.accept(this); | ||
106 | n.f5.accept(this); | ||
107 | return _ret; | ||
108 | } | ||
109 | |||
110 | /** | ||
111 | * <PRE> | ||
112 | * f0 -> ( <STATIC> | <EXTERN> ) | ||
113 | * </PRE> | ||
114 | */ | ||
115 | public R visit(StorageClassSpecifier n) { | ||
116 | R _ret=null; | ||
117 | n.f0.accept(this); | ||
118 | return _ret; | ||
119 | } | ||
120 | |||
121 | /** | ||
122 | * <PRE> | ||
123 | * f0 -> <TYPEDEF> | ||
124 | * f1 -> ( DataType() | FunctionType() ) | ||
125 | * f2 -> ";" | ||
126 | * </PRE> | ||
127 | */ | ||
128 | public R visit(TypeDeclaration n) { | ||
129 | R _ret=null; | ||
130 | n.f0.accept(this); | ||
131 | n.f1.accept(this); | ||
132 | n.f2.accept(this); | ||
133 | return _ret; | ||
134 | } | ||
135 | |||
136 | /** | ||
137 | * <PRE> | ||
138 | * f0 -> StructOrUnionSpecifier() | ||
139 | * f1 -> <IDENTIFIER> | ||
140 | * </PRE> | ||
141 | */ | ||
142 | public R visit(DataType n) { | ||
143 | R _ret=null; | ||
144 | n.f0.accept(this); | ||
145 | n.f1.accept(this); | ||
146 | return _ret; | ||
147 | } | ||
148 | |||
149 | /** | ||
150 | * <PRE> | ||
151 | * f0 -> TypeSpecifier() | ||
152 | * f1 -> "(" | ||
153 | * f2 -> "*" | ||
154 | * f3 -> <IDENTIFIER> | ||
155 | * f4 -> ")" | ||
156 | * f5 -> "(" | ||
157 | * f6 -> [ ParameterList() ] | ||
158 | * f7 -> ")" | ||
159 | * </PRE> | ||
160 | */ | ||
161 | public R visit(FunctionType n) { | ||
162 | R _ret=null; | ||
163 | n.f0.accept(this); | ||
164 | n.f1.accept(this); | ||
165 | n.f2.accept(this); | ||
166 | n.f3.accept(this); | ||
167 | n.f4.accept(this); | ||
168 | n.f5.accept(this); | ||
169 | n.f6.accept(this); | ||
170 | n.f7.accept(this); | ||
171 | return _ret; | ||
172 | } | ||
173 | |||
174 | /** | ||
175 | * <PRE> | ||
176 | * f0 -> ParameterDeclaration() | ||
177 | * f1 -> ( "," ParameterDeclaration() )* | ||
178 | * f2 -> [ "," "..." ] | ||
179 | * </PRE> | ||
180 | */ | ||
181 | public R visit(ParameterList n) { | ||
182 | R _ret=null; | ||
183 | n.f0.accept(this); | ||
184 | n.f1.accept(this); | ||
185 | n.f2.accept(this); | ||
186 | return _ret; | ||
187 | } | ||
188 | |||
189 | /** | ||
190 | * <PRE> | ||
191 | * f0 -> TypeSpecifier() | ||
192 | * f1 -> <IDENTIFIER> | ||
193 | * f2 -> [ Array() ] | ||
194 | * </PRE> | ||
195 | */ | ||
196 | public R visit(ParameterDeclaration n) { | ||
197 | R _ret=null; | ||
198 | n.f0.accept(this); | ||
199 | n.f1.accept(this); | ||
200 | n.f2.accept(this); | ||
201 | return _ret; | ||
202 | } | ||
203 | |||
204 | /** | ||
205 | * <PRE> | ||
206 | * f0 -> VariableClassSpecifier() | ||
207 | * f1 -> TypeSpecifier() | ||
208 | * f2 -> InitDeclaratorList() | ||
209 | * f3 -> ";" | ||
210 | * </PRE> | ||
211 | */ | ||
212 | public R visit(VariableDeclaration n) { | ||
213 | R _ret=null; | ||
214 | n.f0.accept(this); | ||
215 | n.f1.accept(this); | ||
216 | n.f2.accept(this); | ||
217 | n.f3.accept(this); | ||
218 | return _ret; | ||
219 | } | ||
220 | |||
221 | /** | ||
222 | * <PRE> | ||
223 | * f0 -> [ <STATIC> ] | ||
224 | * f1 -> VariableDeclaration() | ||
225 | * </PRE> | ||
226 | */ | ||
227 | public R visit(LocalVariableDeclaration n) { | ||
228 | R _ret=null; | ||
229 | n.f0.accept(this); | ||
230 | n.f1.accept(this); | ||
231 | return _ret; | ||
232 | } | ||
233 | |||
234 | /** | ||
235 | * <PRE> | ||
236 | * f0 -> ( <AUTO> | <REGISTER> )* | ||
237 | * </PRE> | ||
238 | */ | ||
239 | public R visit(VariableClassSpecifier n) { | ||
240 | R _ret=null; | ||
241 | n.f0.accept(this); | ||
242 | return _ret; | ||
243 | } | ||
244 | |||
245 | /** | ||
246 | * <PRE> | ||
247 | * f0 -> [ <CONST> ] | ||
248 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> ) | ||
249 | * f2 -> [ Pointer() ] | ||
250 | * f3 -> [ Array() ] | ||
251 | * </PRE> | ||
252 | */ | ||
253 | public R visit(TypeSpecifier n) { | ||
254 | R _ret=null; | ||
255 | n.f0.accept(this); | ||
256 | n.f1.accept(this); | ||
257 | n.f2.accept(this); | ||
258 | n.f3.accept(this); | ||
259 | return _ret; | ||
260 | } | ||
261 | |||
262 | /** | ||
263 | * <PRE> | ||
264 | * f0 -> [ <CONST> ] | ||
265 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() ) | ||
266 | * f2 -> [ Pointer() ] | ||
267 | * f3 -> [ Array() ] | ||
268 | * </PRE> | ||
269 | */ | ||
270 | public R visit(NoIdentifierTypeSpecifier n) { | ||
271 | R _ret=null; | ||
272 | n.f0.accept(this); | ||
273 | n.f1.accept(this); | ||
274 | n.f2.accept(this); | ||
275 | n.f3.accept(this); | ||
276 | return _ret; | ||
277 | } | ||
278 | |||
279 | /** | ||
280 | * <PRE> | ||
281 | * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}" | ||
282 | * | StructOrUnion() <IDENTIFIER> | ||
283 | * </PRE> | ||
284 | */ | ||
285 | public R visit(StructOrUnionSpecifier n) { | ||
286 | R _ret=null; | ||
287 | n.f0.accept(this); | ||
288 | return _ret; | ||
289 | } | ||
290 | |||
291 | /** | ||
292 | * <PRE> | ||
293 | * f0 -> ( <STRUCT> | <UNION> ) | ||
294 | * </PRE> | ||
295 | */ | ||
296 | public R visit(StructOrUnion n) { | ||
297 | R _ret=null; | ||
298 | n.f0.accept(this); | ||
299 | return _ret; | ||
300 | } | ||
301 | |||
302 | /** | ||
303 | * <PRE> | ||
304 | * f0 -> ( StructDeclaration() )+ | ||
305 | * </PRE> | ||
306 | */ | ||
307 | public R visit(StructDeclarationList n) { | ||
308 | R _ret=null; | ||
309 | n.f0.accept(this); | ||
310 | return _ret; | ||
311 | } | ||
312 | |||
313 | /** | ||
314 | * <PRE> | ||
315 | * f0 -> InitDeclarator() | ||
316 | * f1 -> ( "," InitDeclarator() )* | ||
317 | * </PRE> | ||
318 | */ | ||
319 | public R visit(InitDeclaratorList n) { | ||
320 | R _ret=null; | ||
321 | n.f0.accept(this); | ||
322 | n.f1.accept(this); | ||
323 | return _ret; | ||
324 | } | ||
325 | |||
326 | /** | ||
327 | * <PRE> | ||
328 | * f0 -> <IDENTIFIER> | ||
329 | * f1 -> [ Array() ] | ||
330 | * f2 -> [ "=" Initializer() ] | ||
331 | * </PRE> | ||
332 | */ | ||
333 | public R visit(InitDeclarator n) { | ||
334 | R _ret=null; | ||
335 | n.f0.accept(this); | ||
336 | n.f1.accept(this); | ||
337 | n.f2.accept(this); | ||
338 | return _ret; | ||
339 | } | ||
340 | |||
341 | /** | ||
342 | * <PRE> | ||
343 | * f0 -> TypeSpecifier() | ||
344 | * f1 -> <IDENTIFIER> | ||
345 | * f2 -> [ Array() | ":" ConstantExpression() ] | ||
346 | * f3 -> [ <IDENTIFIER> ] | ||
347 | * f4 -> ";" | ||
348 | * </PRE> | ||
349 | */ | ||
350 | public R visit(StructDeclaration n) { | ||
351 | R _ret=null; | ||
352 | n.f0.accept(this); | ||
353 | n.f1.accept(this); | ||
354 | n.f2.accept(this); | ||
355 | n.f3.accept(this); | ||
356 | n.f4.accept(this); | ||
357 | return _ret; | ||
358 | } | ||
359 | |||
360 | /** | ||
361 | * <PRE> | ||
362 | * f0 -> <ENUM> | ||
363 | * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> ) | ||
364 | * </PRE> | ||
365 | */ | ||
366 | public R visit(EnumSpecifier n) { | ||
367 | R _ret=null; | ||
368 | n.f0.accept(this); | ||
369 | n.f1.accept(this); | ||
370 | return _ret; | ||
371 | } | ||
372 | |||
373 | /** | ||
374 | * <PRE> | ||
375 | * f0 -> Enumerator() | ||
376 | * f1 -> ( "," Enumerator() )* | ||
377 | * </PRE> | ||
378 | */ | ||
379 | public R visit(EnumeratorList n) { | ||
380 | R _ret=null; | ||
381 | n.f0.accept(this); | ||
382 | n.f1.accept(this); | ||
383 | return _ret; | ||
384 | } | ||
385 | |||
386 | /** | ||
387 | * <PRE> | ||
388 | * f0 -> <IDENTIFIER> | ||
389 | * f1 -> [ "=" ConstantExpression() ] | ||
390 | * </PRE> | ||
391 | */ | ||
392 | public R visit(Enumerator n) { | ||
393 | R _ret=null; | ||
394 | n.f0.accept(this); | ||
395 | n.f1.accept(this); | ||
396 | return _ret; | ||
397 | } | ||
398 | |||
399 | /** | ||
400 | * <PRE> | ||
401 | * f0 -> "*" | ||
402 | * f1 -> [ <CONST> ] | ||
403 | * f2 -> [ Pointer() ] | ||
404 | * </PRE> | ||
405 | */ | ||
406 | public R visit(Pointer n) { | ||
407 | R _ret=null; | ||
408 | n.f0.accept(this); | ||
409 | n.f1.accept(this); | ||
410 | n.f2.accept(this); | ||
411 | return _ret; | ||
412 | } | ||
413 | |||
414 | /** | ||
415 | * <PRE> | ||
416 | * f0 -> <IDENTIFIER> | ||
417 | * f1 -> ( "," <IDENTIFIER> )* | ||
418 | * </PRE> | ||
419 | */ | ||
420 | public R visit(IdentifierList n) { | ||
421 | R _ret=null; | ||
422 | n.f0.accept(this); | ||
423 | n.f1.accept(this); | ||
424 | return _ret; | ||
425 | } | ||
426 | |||
427 | /** | ||
428 | * <PRE> | ||
429 | * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" ) | ||
430 | * </PRE> | ||
431 | */ | ||
432 | public R visit(Initializer n) { | ||
433 | R _ret=null; | ||
434 | n.f0.accept(this); | ||
435 | return _ret; | ||
436 | } | ||
437 | |||
438 | /** | ||
439 | * <PRE> | ||
440 | * f0 -> Initializer() | ||
441 | * f1 -> ( "," Initializer() )* | ||
442 | * </PRE> | ||
443 | */ | ||
444 | public R visit(InitializerList n) { | ||
445 | R _ret=null; | ||
446 | n.f0.accept(this); | ||
447 | n.f1.accept(this); | ||
448 | return _ret; | ||
449 | } | ||
450 | |||
451 | /** | ||
452 | * <PRE> | ||
453 | * f0 -> "[" | ||
454 | * f1 -> [ ConstantExpression() ] | ||
455 | * f2 -> "]" | ||
456 | * </PRE> | ||
457 | */ | ||
458 | public R visit(Array n) { | ||
459 | R _ret=null; | ||
460 | n.f0.accept(this); | ||
461 | n.f1.accept(this); | ||
462 | n.f2.accept(this); | ||
463 | return _ret; | ||
464 | } | ||
465 | |||
466 | /** | ||
467 | * <PRE> | ||
468 | * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() ) | ||
469 | * </PRE> | ||
470 | */ | ||
471 | public R visit(Statement n) { | ||
472 | R _ret=null; | ||
473 | n.f0.accept(this); | ||
474 | return _ret; | ||
475 | } | ||
476 | |||
477 | /** | ||
478 | * <PRE> | ||
479 | * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() ) | ||
480 | * </PRE> | ||
481 | */ | ||
482 | public R visit(LabeledStatement n) { | ||
483 | R _ret=null; | ||
484 | n.f0.accept(this); | ||
485 | return _ret; | ||
486 | } | ||
487 | |||
488 | /** | ||
489 | * <PRE> | ||
490 | * f0 -> [ Expression() ] | ||
491 | * f1 -> ";" | ||
492 | * </PRE> | ||
493 | */ | ||
494 | public R visit(ExpressionStatement n) { | ||
495 | R _ret=null; | ||
496 | n.f0.accept(this); | ||
497 | n.f1.accept(this); | ||
498 | return _ret; | ||
499 | } | ||
500 | |||
501 | /** | ||
502 | * <PRE> | ||
503 | * f0 -> "{" | ||
504 | * f1 -> ( LocalVariableDeclaration() | Statement() )* | ||
505 | * f2 -> "}" | ||
506 | * </PRE> | ||
507 | */ | ||
508 | public R visit(CompoundStatement n) { | ||
509 | R _ret=null; | ||
510 | n.f0.accept(this); | ||
511 | n.f1.accept(this); | ||
512 | n.f2.accept(this); | ||
513 | return _ret; | ||
514 | } | ||
515 | |||
516 | /** | ||
517 | * <PRE> | ||
518 | * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() ) | ||
519 | * </PRE> | ||
520 | */ | ||
521 | public R visit(SelectionStatement n) { | ||
522 | R _ret=null; | ||
523 | n.f0.accept(this); | ||
524 | return _ret; | ||
525 | } | ||
526 | |||
527 | /** | ||
528 | * <PRE> | ||
529 | * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() ) | ||
530 | * </PRE> | ||
531 | */ | ||
532 | public R visit(IterationStatement n) { | ||
533 | R _ret=null; | ||
534 | n.f0.accept(this); | ||
535 | return _ret; | ||
536 | } | ||
537 | |||
538 | /** | ||
539 | * <PRE> | ||
540 | * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" ) | ||
541 | * </PRE> | ||
542 | */ | ||
543 | public R visit(JumpStatement n) { | ||
544 | R _ret=null; | ||
545 | n.f0.accept(this); | ||
546 | return _ret; | ||
547 | } | ||
548 | |||
549 | /** | ||
550 | * <PRE> | ||
551 | * f0 -> AssignmentExpression() | ||
552 | * f1 -> ( "," AssignmentExpression() )* | ||
553 | * </PRE> | ||
554 | */ | ||
555 | public R visit(Expression n) { | ||
556 | R _ret=null; | ||
557 | n.f0.accept(this); | ||
558 | n.f1.accept(this); | ||
559 | return _ret; | ||
560 | } | ||
561 | |||
562 | /** | ||
563 | * <PRE> | ||
564 | * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression() | ||
565 | * | ConditionalExpression() | ||
566 | * </PRE> | ||
567 | */ | ||
568 | public R visit(AssignmentExpression n) { | ||
569 | R _ret=null; | ||
570 | n.f0.accept(this); | ||
571 | return _ret; | ||
572 | } | ||
573 | |||
574 | /** | ||
575 | * <PRE> | ||
576 | * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" ) | ||
577 | * </PRE> | ||
578 | */ | ||
579 | public R visit(AssignmentOperator n) { | ||
580 | R _ret=null; | ||
581 | n.f0.accept(this); | ||
582 | return _ret; | ||
583 | } | ||
584 | |||
585 | /** | ||
586 | * <PRE> | ||
587 | * f0 -> LogicalORExpression() | ||
588 | * f1 -> [ "?" Expression() ":" ConditionalExpression() ] | ||
589 | * </PRE> | ||
590 | */ | ||
591 | public R visit(ConditionalExpression n) { | ||
592 | R _ret=null; | ||
593 | n.f0.accept(this); | ||
594 | n.f1.accept(this); | ||
595 | return _ret; | ||
596 | } | ||
597 | |||
598 | /** | ||
599 | * <PRE> | ||
600 | * f0 -> ConditionalExpression() | ||
601 | * </PRE> | ||
602 | */ | ||
603 | public R visit(ConstantExpression n) { | ||
604 | R _ret=null; | ||
605 | n.f0.accept(this); | ||
606 | return _ret; | ||
607 | } | ||
608 | |||
609 | /** | ||
610 | * <PRE> | ||
611 | * f0 -> LogicalANDExpression() | ||
612 | * f1 -> [ "||" LogicalORExpression() ] | ||
613 | * </PRE> | ||
614 | */ | ||
615 | public R visit(LogicalORExpression n) { | ||
616 | R _ret=null; | ||
617 | n.f0.accept(this); | ||
618 | n.f1.accept(this); | ||
619 | return _ret; | ||
620 | } | ||
621 | |||
622 | /** | ||
623 | * <PRE> | ||
624 | * f0 -> InclusiveORExpression() | ||
625 | * f1 -> [ "&&" LogicalANDExpression() ] | ||
626 | * </PRE> | ||
627 | */ | ||
628 | public R visit(LogicalANDExpression n) { | ||
629 | R _ret=null; | ||
630 | n.f0.accept(this); | ||
631 | n.f1.accept(this); | ||
632 | return _ret; | ||
633 | } | ||
634 | |||
635 | /** | ||
636 | * <PRE> | ||
637 | * f0 -> ExclusiveORExpression() | ||
638 | * f1 -> [ "|" InclusiveORExpression() ] | ||
639 | * </PRE> | ||
640 | */ | ||
641 | public R visit(InclusiveORExpression n) { | ||
642 | R _ret=null; | ||
643 | n.f0.accept(this); | ||
644 | n.f1.accept(this); | ||
645 | return _ret; | ||
646 | } | ||
647 | |||
648 | /** | ||
649 | * <PRE> | ||
650 | * f0 -> ANDExpression() | ||
651 | * f1 -> [ "^" ExclusiveORExpression() ] | ||
652 | * </PRE> | ||
653 | */ | ||
654 | public R visit(ExclusiveORExpression n) { | ||
655 | R _ret=null; | ||
656 | n.f0.accept(this); | ||
657 | n.f1.accept(this); | ||
658 | return _ret; | ||
659 | } | ||
660 | |||
661 | /** | ||
662 | * <PRE> | ||
663 | * f0 -> EqualityExpression() | ||
664 | * f1 -> [ "&" ANDExpression() ] | ||
665 | * </PRE> | ||
666 | */ | ||
667 | public R visit(ANDExpression n) { | ||
668 | R _ret=null; | ||
669 | n.f0.accept(this); | ||
670 | n.f1.accept(this); | ||
671 | return _ret; | ||
672 | } | ||
673 | |||
674 | /** | ||
675 | * <PRE> | ||
676 | * f0 -> RelationalExpression() | ||
677 | * f1 -> [ ( "==" | "!=" ) EqualityExpression() ] | ||
678 | * </PRE> | ||
679 | */ | ||
680 | public R visit(EqualityExpression n) { | ||
681 | R _ret=null; | ||
682 | n.f0.accept(this); | ||
683 | n.f1.accept(this); | ||
684 | return _ret; | ||
685 | } | ||
686 | |||
687 | /** | ||
688 | * <PRE> | ||
689 | * f0 -> ShiftExpression() | ||
690 | * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ] | ||
691 | * </PRE> | ||
692 | */ | ||
693 | public R visit(RelationalExpression n) { | ||
694 | R _ret=null; | ||
695 | n.f0.accept(this); | ||
696 | n.f1.accept(this); | ||
697 | return _ret; | ||
698 | } | ||
699 | |||
700 | /** | ||
701 | * <PRE> | ||
702 | * f0 -> AdditiveExpression() | ||
703 | * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ] | ||
704 | * </PRE> | ||
705 | */ | ||
706 | public R visit(ShiftExpression n) { | ||
707 | R _ret=null; | ||
708 | n.f0.accept(this); | ||
709 | n.f1.accept(this); | ||
710 | return _ret; | ||
711 | } | ||
712 | |||
713 | /** | ||
714 | * <PRE> | ||
715 | * f0 -> MultiplicativeExpression() | ||
716 | * f1 -> [ ( "+" | "-" ) AdditiveExpression() ] | ||
717 | * </PRE> | ||
718 | */ | ||
719 | public R visit(AdditiveExpression n) { | ||
720 | R _ret=null; | ||
721 | n.f0.accept(this); | ||
722 | n.f1.accept(this); | ||
723 | return _ret; | ||
724 | } | ||
725 | |||
726 | /** | ||
727 | * <PRE> | ||
728 | * f0 -> CastExpression() | ||
729 | * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ] | ||
730 | * </PRE> | ||
731 | */ | ||
732 | public R visit(MultiplicativeExpression n) { | ||
733 | R _ret=null; | ||
734 | n.f0.accept(this); | ||
735 | n.f1.accept(this); | ||
736 | return _ret; | ||
737 | } | ||
738 | |||
739 | /** | ||
740 | * <PRE> | ||
741 | * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() ) | ||
742 | * </PRE> | ||
743 | */ | ||
744 | public R visit(CastExpression n) { | ||
745 | R _ret=null; | ||
746 | n.f0.accept(this); | ||
747 | return _ret; | ||
748 | } | ||
749 | |||
750 | /** | ||
751 | * <PRE> | ||
752 | * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) ) | ||
753 | * </PRE> | ||
754 | */ | ||
755 | public R visit(UnaryExpression n) { | ||
756 | R _ret=null; | ||
757 | n.f0.accept(this); | ||
758 | return _ret; | ||
759 | } | ||
760 | |||
761 | /** | ||
762 | * <PRE> | ||
763 | * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" ) | ||
764 | * </PRE> | ||
765 | */ | ||
766 | public R visit(UnaryOperator n) { | ||
767 | R _ret=null; | ||
768 | n.f0.accept(this); | ||
769 | return _ret; | ||
770 | } | ||
771 | |||
772 | /** | ||
773 | * <PRE> | ||
774 | * f0 -> PrimaryExpression() | ||
775 | * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )* | ||
776 | * </PRE> | ||
777 | */ | ||
778 | public R visit(PostfixExpression n) { | ||
779 | R _ret=null; | ||
780 | n.f0.accept(this); | ||
781 | n.f1.accept(this); | ||
782 | return _ret; | ||
783 | } | ||
784 | |||
785 | /** | ||
786 | * <PRE> | ||
787 | * f0 -> <IDENTIFIER> | ||
788 | * | Constant() | ||
789 | * | "(" Expression() ")" | ||
790 | * </PRE> | ||
791 | */ | ||
792 | public R visit(PrimaryExpression n) { | ||
793 | R _ret=null; | ||
794 | n.f0.accept(this); | ||
795 | return _ret; | ||
796 | } | ||
797 | |||
798 | /** | ||
799 | * <PRE> | ||
800 | * f0 -> AssignmentOrTypeExpression() | ||
801 | * f1 -> ( "," AssignmentOrTypeExpression() )* | ||
802 | * </PRE> | ||
803 | */ | ||
804 | public R visit(ArgumentExpressionList n) { | ||
805 | R _ret=null; | ||
806 | n.f0.accept(this); | ||
807 | n.f1.accept(this); | ||
808 | return _ret; | ||
809 | } | ||
810 | |||
811 | /** | ||
812 | * <PRE> | ||
813 | * f0 -> NoIdentifierTypeSpecifier() | ||
814 | * | AssignmentExpression() | ||
815 | * </PRE> | ||
816 | */ | ||
817 | public R visit(AssignmentOrTypeExpression n) { | ||
818 | R _ret=null; | ||
819 | n.f0.accept(this); | ||
820 | return _ret; | ||
821 | } | ||
822 | |||
823 | /** | ||
824 | * <PRE> | ||
825 | * f0 -> <INTEGER_LITERAL> | ||
826 | * | <FLOATING_POINT_LITERAL> | ||
827 | * | <CHARACTER_LITERAL> | ||
828 | * | <STRING_LITERAL> | ||
829 | * </PRE> | ||
830 | */ | ||
831 | public R visit(Constant n) { | ||
832 | R _ret=null; | ||
833 | n.f0.accept(this); | ||
834 | return _ret; | ||
835 | } | ||
836 | |||
837 | } | ||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJNoArguVisitor.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJNoArguVisitor.java new file mode 100644 index 000000000..0e32ab25d --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJNoArguVisitor.java | |||
@@ -0,0 +1,508 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.visitors; | ||
6 | import org.gnunet.seaspider.parser.nodes.*; | ||
7 | |||
8 | import java.util.*; | ||
9 | |||
10 | /** | ||
11 | * All GJ visitors with no argument must implement this interface. | ||
12 | */ | ||
13 | |||
14 | public interface GJNoArguVisitor<R> { | ||
15 | |||
16 | // | ||
17 | // GJ Auto class visitors with no argument | ||
18 | // | ||
19 | |||
20 | public R visit(NodeList n); | ||
21 | public R visit(NodeListOptional n); | ||
22 | public R visit(NodeOptional n); | ||
23 | public R visit(NodeSequence n); | ||
24 | public R visit(NodeToken n); | ||
25 | |||
26 | // | ||
27 | // User-generated visitor methods below | ||
28 | // | ||
29 | |||
30 | /** | ||
31 | * <PRE> | ||
32 | * f0 -> ( ExternalDeclaration() )+ | ||
33 | * </PRE> | ||
34 | */ | ||
35 | public R visit(TranslationUnit n); | ||
36 | |||
37 | /** | ||
38 | * <PRE> | ||
39 | * f0 -> ( StorageClassSpecifier() )* | ||
40 | * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() ) | ||
41 | * </PRE> | ||
42 | */ | ||
43 | public R visit(ExternalDeclaration n); | ||
44 | |||
45 | /** | ||
46 | * <PRE> | ||
47 | * f0 -> TypeSpecifier() | ||
48 | * f1 -> <IDENTIFIER> | ||
49 | * f2 -> "(" | ||
50 | * f3 -> [ ParameterList() ] | ||
51 | * f4 -> ")" | ||
52 | * f5 -> ( ";" | CompoundStatement() ) | ||
53 | * </PRE> | ||
54 | */ | ||
55 | public R visit(FunctionDeclaration n); | ||
56 | |||
57 | /** | ||
58 | * <PRE> | ||
59 | * f0 -> ( <STATIC> | <EXTERN> ) | ||
60 | * </PRE> | ||
61 | */ | ||
62 | public R visit(StorageClassSpecifier n); | ||
63 | |||
64 | /** | ||
65 | * <PRE> | ||
66 | * f0 -> <TYPEDEF> | ||
67 | * f1 -> ( DataType() | FunctionType() ) | ||
68 | * f2 -> ";" | ||
69 | * </PRE> | ||
70 | */ | ||
71 | public R visit(TypeDeclaration n); | ||
72 | |||
73 | /** | ||
74 | * <PRE> | ||
75 | * f0 -> StructOrUnionSpecifier() | ||
76 | * f1 -> <IDENTIFIER> | ||
77 | * </PRE> | ||
78 | */ | ||
79 | public R visit(DataType n); | ||
80 | |||
81 | /** | ||
82 | * <PRE> | ||
83 | * f0 -> TypeSpecifier() | ||
84 | * f1 -> "(" | ||
85 | * f2 -> "*" | ||
86 | * f3 -> <IDENTIFIER> | ||
87 | * f4 -> ")" | ||
88 | * f5 -> "(" | ||
89 | * f6 -> [ ParameterList() ] | ||
90 | * f7 -> ")" | ||
91 | * </PRE> | ||
92 | */ | ||
93 | public R visit(FunctionType n); | ||
94 | |||
95 | /** | ||
96 | * <PRE> | ||
97 | * f0 -> ParameterDeclaration() | ||
98 | * f1 -> ( "," ParameterDeclaration() )* | ||
99 | * f2 -> [ "," "..." ] | ||
100 | * </PRE> | ||
101 | */ | ||
102 | public R visit(ParameterList n); | ||
103 | |||
104 | /** | ||
105 | * <PRE> | ||
106 | * f0 -> TypeSpecifier() | ||
107 | * f1 -> <IDENTIFIER> | ||
108 | * f2 -> [ Array() ] | ||
109 | * </PRE> | ||
110 | */ | ||
111 | public R visit(ParameterDeclaration n); | ||
112 | |||
113 | /** | ||
114 | * <PRE> | ||
115 | * f0 -> VariableClassSpecifier() | ||
116 | * f1 -> TypeSpecifier() | ||
117 | * f2 -> InitDeclaratorList() | ||
118 | * f3 -> ";" | ||
119 | * </PRE> | ||
120 | */ | ||
121 | public R visit(VariableDeclaration n); | ||
122 | |||
123 | /** | ||
124 | * <PRE> | ||
125 | * f0 -> [ <STATIC> ] | ||
126 | * f1 -> VariableDeclaration() | ||
127 | * </PRE> | ||
128 | */ | ||
129 | public R visit(LocalVariableDeclaration n); | ||
130 | |||
131 | /** | ||
132 | * <PRE> | ||
133 | * f0 -> ( <AUTO> | <REGISTER> )* | ||
134 | * </PRE> | ||
135 | */ | ||
136 | public R visit(VariableClassSpecifier n); | ||
137 | |||
138 | /** | ||
139 | * <PRE> | ||
140 | * f0 -> [ <CONST> ] | ||
141 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> ) | ||
142 | * f2 -> [ Pointer() ] | ||
143 | * f3 -> [ Array() ] | ||
144 | * </PRE> | ||
145 | */ | ||
146 | public R visit(TypeSpecifier n); | ||
147 | |||
148 | /** | ||
149 | * <PRE> | ||
150 | * f0 -> [ <CONST> ] | ||
151 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() ) | ||
152 | * f2 -> [ Pointer() ] | ||
153 | * f3 -> [ Array() ] | ||
154 | * </PRE> | ||
155 | */ | ||
156 | public R visit(NoIdentifierTypeSpecifier n); | ||
157 | |||
158 | /** | ||
159 | * <PRE> | ||
160 | * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}" | ||
161 | * | StructOrUnion() <IDENTIFIER> | ||
162 | * </PRE> | ||
163 | */ | ||
164 | public R visit(StructOrUnionSpecifier n); | ||
165 | |||
166 | /** | ||
167 | * <PRE> | ||
168 | * f0 -> ( <STRUCT> | <UNION> ) | ||
169 | * </PRE> | ||
170 | */ | ||
171 | public R visit(StructOrUnion n); | ||
172 | |||
173 | /** | ||
174 | * <PRE> | ||
175 | * f0 -> ( StructDeclaration() )+ | ||
176 | * </PRE> | ||
177 | */ | ||
178 | public R visit(StructDeclarationList n); | ||
179 | |||
180 | /** | ||
181 | * <PRE> | ||
182 | * f0 -> InitDeclarator() | ||
183 | * f1 -> ( "," InitDeclarator() )* | ||
184 | * </PRE> | ||
185 | */ | ||
186 | public R visit(InitDeclaratorList n); | ||
187 | |||
188 | /** | ||
189 | * <PRE> | ||
190 | * f0 -> <IDENTIFIER> | ||
191 | * f1 -> [ Array() ] | ||
192 | * f2 -> [ "=" Initializer() ] | ||
193 | * </PRE> | ||
194 | */ | ||
195 | public R visit(InitDeclarator n); | ||
196 | |||
197 | /** | ||
198 | * <PRE> | ||
199 | * f0 -> TypeSpecifier() | ||
200 | * f1 -> <IDENTIFIER> | ||
201 | * f2 -> [ Array() | ":" ConstantExpression() ] | ||
202 | * f3 -> [ <IDENTIFIER> ] | ||
203 | * f4 -> ";" | ||
204 | * </PRE> | ||
205 | */ | ||
206 | public R visit(StructDeclaration n); | ||
207 | |||
208 | /** | ||
209 | * <PRE> | ||
210 | * f0 -> <ENUM> | ||
211 | * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> ) | ||
212 | * </PRE> | ||
213 | */ | ||
214 | public R visit(EnumSpecifier n); | ||
215 | |||
216 | /** | ||
217 | * <PRE> | ||
218 | * f0 -> Enumerator() | ||
219 | * f1 -> ( "," Enumerator() )* | ||
220 | * </PRE> | ||
221 | */ | ||
222 | public R visit(EnumeratorList n); | ||
223 | |||
224 | /** | ||
225 | * <PRE> | ||
226 | * f0 -> <IDENTIFIER> | ||
227 | * f1 -> [ "=" ConstantExpression() ] | ||
228 | * </PRE> | ||
229 | */ | ||
230 | public R visit(Enumerator n); | ||
231 | |||
232 | /** | ||
233 | * <PRE> | ||
234 | * f0 -> "*" | ||
235 | * f1 -> [ <CONST> ] | ||
236 | * f2 -> [ Pointer() ] | ||
237 | * </PRE> | ||
238 | */ | ||
239 | public R visit(Pointer n); | ||
240 | |||
241 | /** | ||
242 | * <PRE> | ||
243 | * f0 -> <IDENTIFIER> | ||
244 | * f1 -> ( "," <IDENTIFIER> )* | ||
245 | * </PRE> | ||
246 | */ | ||
247 | public R visit(IdentifierList n); | ||
248 | |||
249 | /** | ||
250 | * <PRE> | ||
251 | * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" ) | ||
252 | * </PRE> | ||
253 | */ | ||
254 | public R visit(Initializer n); | ||
255 | |||
256 | /** | ||
257 | * <PRE> | ||
258 | * f0 -> Initializer() | ||
259 | * f1 -> ( "," Initializer() )* | ||
260 | * </PRE> | ||
261 | */ | ||
262 | public R visit(InitializerList n); | ||
263 | |||
264 | /** | ||
265 | * <PRE> | ||
266 | * f0 -> "[" | ||
267 | * f1 -> [ ConstantExpression() ] | ||
268 | * f2 -> "]" | ||
269 | * </PRE> | ||
270 | */ | ||
271 | public R visit(Array n); | ||
272 | |||
273 | /** | ||
274 | * <PRE> | ||
275 | * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() ) | ||
276 | * </PRE> | ||
277 | */ | ||
278 | public R visit(Statement n); | ||
279 | |||
280 | /** | ||
281 | * <PRE> | ||
282 | * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() ) | ||
283 | * </PRE> | ||
284 | */ | ||
285 | public R visit(LabeledStatement n); | ||
286 | |||
287 | /** | ||
288 | * <PRE> | ||
289 | * f0 -> [ Expression() ] | ||
290 | * f1 -> ";" | ||
291 | * </PRE> | ||
292 | */ | ||
293 | public R visit(ExpressionStatement n); | ||
294 | |||
295 | /** | ||
296 | * <PRE> | ||
297 | * f0 -> "{" | ||
298 | * f1 -> ( LocalVariableDeclaration() | Statement() )* | ||
299 | * f2 -> "}" | ||
300 | * </PRE> | ||
301 | */ | ||
302 | public R visit(CompoundStatement n); | ||
303 | |||
304 | /** | ||
305 | * <PRE> | ||
306 | * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() ) | ||
307 | * </PRE> | ||
308 | */ | ||
309 | public R visit(SelectionStatement n); | ||
310 | |||
311 | /** | ||
312 | * <PRE> | ||
313 | * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() ) | ||
314 | * </PRE> | ||
315 | */ | ||
316 | public R visit(IterationStatement n); | ||
317 | |||
318 | /** | ||
319 | * <PRE> | ||
320 | * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" ) | ||
321 | * </PRE> | ||
322 | */ | ||
323 | public R visit(JumpStatement n); | ||
324 | |||
325 | /** | ||
326 | * <PRE> | ||
327 | * f0 -> AssignmentExpression() | ||
328 | * f1 -> ( "," AssignmentExpression() )* | ||
329 | * </PRE> | ||
330 | */ | ||
331 | public R visit(Expression n); | ||
332 | |||
333 | /** | ||
334 | * <PRE> | ||
335 | * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression() | ||
336 | * | ConditionalExpression() | ||
337 | * </PRE> | ||
338 | */ | ||
339 | public R visit(AssignmentExpression n); | ||
340 | |||
341 | /** | ||
342 | * <PRE> | ||
343 | * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" ) | ||
344 | * </PRE> | ||
345 | */ | ||
346 | public R visit(AssignmentOperator n); | ||
347 | |||
348 | /** | ||
349 | * <PRE> | ||
350 | * f0 -> LogicalORExpression() | ||
351 | * f1 -> [ "?" Expression() ":" ConditionalExpression() ] | ||
352 | * </PRE> | ||
353 | */ | ||
354 | public R visit(ConditionalExpression n); | ||
355 | |||
356 | /** | ||
357 | * <PRE> | ||
358 | * f0 -> ConditionalExpression() | ||
359 | * </PRE> | ||
360 | */ | ||
361 | public R visit(ConstantExpression n); | ||
362 | |||
363 | /** | ||
364 | * <PRE> | ||
365 | * f0 -> LogicalANDExpression() | ||
366 | * f1 -> [ "||" LogicalORExpression() ] | ||
367 | * </PRE> | ||
368 | */ | ||
369 | public R visit(LogicalORExpression n); | ||
370 | |||
371 | /** | ||
372 | * <PRE> | ||
373 | * f0 -> InclusiveORExpression() | ||
374 | * f1 -> [ "&&" LogicalANDExpression() ] | ||
375 | * </PRE> | ||
376 | */ | ||
377 | public R visit(LogicalANDExpression n); | ||
378 | |||
379 | /** | ||
380 | * <PRE> | ||
381 | * f0 -> ExclusiveORExpression() | ||
382 | * f1 -> [ "|" InclusiveORExpression() ] | ||
383 | * </PRE> | ||
384 | */ | ||
385 | public R visit(InclusiveORExpression n); | ||
386 | |||
387 | /** | ||
388 | * <PRE> | ||
389 | * f0 -> ANDExpression() | ||
390 | * f1 -> [ "^" ExclusiveORExpression() ] | ||
391 | * </PRE> | ||
392 | */ | ||
393 | public R visit(ExclusiveORExpression n); | ||
394 | |||
395 | /** | ||
396 | * <PRE> | ||
397 | * f0 -> EqualityExpression() | ||
398 | * f1 -> [ "&" ANDExpression() ] | ||
399 | * </PRE> | ||
400 | */ | ||
401 | public R visit(ANDExpression n); | ||
402 | |||
403 | /** | ||
404 | * <PRE> | ||
405 | * f0 -> RelationalExpression() | ||
406 | * f1 -> [ ( "==" | "!=" ) EqualityExpression() ] | ||
407 | * </PRE> | ||
408 | */ | ||
409 | public R visit(EqualityExpression n); | ||
410 | |||
411 | /** | ||
412 | * <PRE> | ||
413 | * f0 -> ShiftExpression() | ||
414 | * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ] | ||
415 | * </PRE> | ||
416 | */ | ||
417 | public R visit(RelationalExpression n); | ||
418 | |||
419 | /** | ||
420 | * <PRE> | ||
421 | * f0 -> AdditiveExpression() | ||
422 | * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ] | ||
423 | * </PRE> | ||
424 | */ | ||
425 | public R visit(ShiftExpression n); | ||
426 | |||
427 | /** | ||
428 | * <PRE> | ||
429 | * f0 -> MultiplicativeExpression() | ||
430 | * f1 -> [ ( "+" | "-" ) AdditiveExpression() ] | ||
431 | * </PRE> | ||
432 | */ | ||
433 | public R visit(AdditiveExpression n); | ||
434 | |||
435 | /** | ||
436 | * <PRE> | ||
437 | * f0 -> CastExpression() | ||
438 | * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ] | ||
439 | * </PRE> | ||
440 | */ | ||
441 | public R visit(MultiplicativeExpression n); | ||
442 | |||
443 | /** | ||
444 | * <PRE> | ||
445 | * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() ) | ||
446 | * </PRE> | ||
447 | */ | ||
448 | public R visit(CastExpression n); | ||
449 | |||
450 | /** | ||
451 | * <PRE> | ||
452 | * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) ) | ||
453 | * </PRE> | ||
454 | */ | ||
455 | public R visit(UnaryExpression n); | ||
456 | |||
457 | /** | ||
458 | * <PRE> | ||
459 | * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" ) | ||
460 | * </PRE> | ||
461 | */ | ||
462 | public R visit(UnaryOperator n); | ||
463 | |||
464 | /** | ||
465 | * <PRE> | ||
466 | * f0 -> PrimaryExpression() | ||
467 | * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )* | ||
468 | * </PRE> | ||
469 | */ | ||
470 | public R visit(PostfixExpression n); | ||
471 | |||
472 | /** | ||
473 | * <PRE> | ||
474 | * f0 -> <IDENTIFIER> | ||
475 | * | Constant() | ||
476 | * | "(" Expression() ")" | ||
477 | * </PRE> | ||
478 | */ | ||
479 | public R visit(PrimaryExpression n); | ||
480 | |||
481 | /** | ||
482 | * <PRE> | ||
483 | * f0 -> AssignmentOrTypeExpression() | ||
484 | * f1 -> ( "," AssignmentOrTypeExpression() )* | ||
485 | * </PRE> | ||
486 | */ | ||
487 | public R visit(ArgumentExpressionList n); | ||
488 | |||
489 | /** | ||
490 | * <PRE> | ||
491 | * f0 -> NoIdentifierTypeSpecifier() | ||
492 | * | AssignmentExpression() | ||
493 | * </PRE> | ||
494 | */ | ||
495 | public R visit(AssignmentOrTypeExpression n); | ||
496 | |||
497 | /** | ||
498 | * <PRE> | ||
499 | * f0 -> <INTEGER_LITERAL> | ||
500 | * | <FLOATING_POINT_LITERAL> | ||
501 | * | <CHARACTER_LITERAL> | ||
502 | * | <STRING_LITERAL> | ||
503 | * </PRE> | ||
504 | */ | ||
505 | public R visit(Constant n); | ||
506 | |||
507 | } | ||
508 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVisitor.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVisitor.java new file mode 100644 index 000000000..431c1953a --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVisitor.java | |||
@@ -0,0 +1,507 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.visitors; | ||
6 | import org.gnunet.seaspider.parser.nodes.*; | ||
7 | |||
8 | import java.util.*; | ||
9 | |||
10 | /** | ||
11 | * All GJ visitors must implement this interface. | ||
12 | */ | ||
13 | |||
14 | public interface GJVisitor<R,A> { | ||
15 | |||
16 | // | ||
17 | // GJ Auto class visitors | ||
18 | // | ||
19 | |||
20 | public R visit(NodeList n, A argu); | ||
21 | public R visit(NodeListOptional n, A argu); | ||
22 | public R visit(NodeOptional n, A argu); | ||
23 | public R visit(NodeSequence n, A argu); | ||
24 | public R visit(NodeToken n, A argu); | ||
25 | |||
26 | // | ||
27 | // User-generated visitor methods below | ||
28 | // | ||
29 | |||
30 | /** | ||
31 | * <PRE> | ||
32 | * f0 -> ( ExternalDeclaration() )+ | ||
33 | * </PRE> | ||
34 | */ | ||
35 | public R visit(TranslationUnit n, A argu); | ||
36 | |||
37 | /** | ||
38 | * <PRE> | ||
39 | * f0 -> ( StorageClassSpecifier() )* | ||
40 | * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() ) | ||
41 | * </PRE> | ||
42 | */ | ||
43 | public R visit(ExternalDeclaration n, A argu); | ||
44 | |||
45 | /** | ||
46 | * <PRE> | ||
47 | * f0 -> TypeSpecifier() | ||
48 | * f1 -> <IDENTIFIER> | ||
49 | * f2 -> "(" | ||
50 | * f3 -> [ ParameterList() ] | ||
51 | * f4 -> ")" | ||
52 | * f5 -> ( ";" | CompoundStatement() ) | ||
53 | * </PRE> | ||
54 | */ | ||
55 | public R visit(FunctionDeclaration n, A argu); | ||
56 | |||
57 | /** | ||
58 | * <PRE> | ||
59 | * f0 -> ( <STATIC> | <EXTERN> ) | ||
60 | * </PRE> | ||
61 | */ | ||
62 | public R visit(StorageClassSpecifier n, A argu); | ||
63 | |||
64 | /** | ||
65 | * <PRE> | ||
66 | * f0 -> <TYPEDEF> | ||
67 | * f1 -> ( DataType() | FunctionType() ) | ||
68 | * f2 -> ";" | ||
69 | * </PRE> | ||
70 | */ | ||
71 | public R visit(TypeDeclaration n, A argu); | ||
72 | |||
73 | /** | ||
74 | * <PRE> | ||
75 | * f0 -> StructOrUnionSpecifier() | ||
76 | * f1 -> <IDENTIFIER> | ||
77 | * </PRE> | ||
78 | */ | ||
79 | public R visit(DataType n, A argu); | ||
80 | |||
81 | /** | ||
82 | * <PRE> | ||
83 | * f0 -> TypeSpecifier() | ||
84 | * f1 -> "(" | ||
85 | * f2 -> "*" | ||
86 | * f3 -> <IDENTIFIER> | ||
87 | * f4 -> ")" | ||
88 | * f5 -> "(" | ||
89 | * f6 -> [ ParameterList() ] | ||
90 | * f7 -> ")" | ||
91 | * </PRE> | ||
92 | */ | ||
93 | public R visit(FunctionType n, A argu); | ||
94 | |||
95 | /** | ||
96 | * <PRE> | ||
97 | * f0 -> ParameterDeclaration() | ||
98 | * f1 -> ( "," ParameterDeclaration() )* | ||
99 | * f2 -> [ "," "..." ] | ||
100 | * </PRE> | ||
101 | */ | ||
102 | public R visit(ParameterList n, A argu); | ||
103 | |||
104 | /** | ||
105 | * <PRE> | ||
106 | * f0 -> TypeSpecifier() | ||
107 | * f1 -> <IDENTIFIER> | ||
108 | * f2 -> [ Array() ] | ||
109 | * </PRE> | ||
110 | */ | ||
111 | public R visit(ParameterDeclaration n, A argu); | ||
112 | |||
113 | /** | ||
114 | * <PRE> | ||
115 | * f0 -> VariableClassSpecifier() | ||
116 | * f1 -> TypeSpecifier() | ||
117 | * f2 -> InitDeclaratorList() | ||
118 | * f3 -> ";" | ||
119 | * </PRE> | ||
120 | */ | ||
121 | public R visit(VariableDeclaration n, A argu); | ||
122 | |||
123 | /** | ||
124 | * <PRE> | ||
125 | * f0 -> [ <STATIC> ] | ||
126 | * f1 -> VariableDeclaration() | ||
127 | * </PRE> | ||
128 | */ | ||
129 | public R visit(LocalVariableDeclaration n, A argu); | ||
130 | |||
131 | /** | ||
132 | * <PRE> | ||
133 | * f0 -> ( <AUTO> | <REGISTER> )* | ||
134 | * </PRE> | ||
135 | */ | ||
136 | public R visit(VariableClassSpecifier n, A argu); | ||
137 | |||
138 | /** | ||
139 | * <PRE> | ||
140 | * f0 -> [ <CONST> ] | ||
141 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> ) | ||
142 | * f2 -> [ Pointer() ] | ||
143 | * f3 -> [ Array() ] | ||
144 | * </PRE> | ||
145 | */ | ||
146 | public R visit(TypeSpecifier n, A argu); | ||
147 | |||
148 | /** | ||
149 | * <PRE> | ||
150 | * f0 -> [ <CONST> ] | ||
151 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() ) | ||
152 | * f2 -> [ Pointer() ] | ||
153 | * f3 -> [ Array() ] | ||
154 | * </PRE> | ||
155 | */ | ||
156 | public R visit(NoIdentifierTypeSpecifier n, A argu); | ||
157 | |||
158 | /** | ||
159 | * <PRE> | ||
160 | * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}" | ||
161 | * | StructOrUnion() <IDENTIFIER> | ||
162 | * </PRE> | ||
163 | */ | ||
164 | public R visit(StructOrUnionSpecifier n, A argu); | ||
165 | |||
166 | /** | ||
167 | * <PRE> | ||
168 | * f0 -> ( <STRUCT> | <UNION> ) | ||
169 | * </PRE> | ||
170 | */ | ||
171 | public R visit(StructOrUnion n, A argu); | ||
172 | |||
173 | /** | ||
174 | * <PRE> | ||
175 | * f0 -> ( StructDeclaration() )+ | ||
176 | * </PRE> | ||
177 | */ | ||
178 | public R visit(StructDeclarationList n, A argu); | ||
179 | |||
180 | /** | ||
181 | * <PRE> | ||
182 | * f0 -> InitDeclarator() | ||
183 | * f1 -> ( "," InitDeclarator() )* | ||
184 | * </PRE> | ||
185 | */ | ||
186 | public R visit(InitDeclaratorList n, A argu); | ||
187 | |||
188 | /** | ||
189 | * <PRE> | ||
190 | * f0 -> <IDENTIFIER> | ||
191 | * f1 -> [ Array() ] | ||
192 | * f2 -> [ "=" Initializer() ] | ||
193 | * </PRE> | ||
194 | */ | ||
195 | public R visit(InitDeclarator n, A argu); | ||
196 | |||
197 | /** | ||
198 | * <PRE> | ||
199 | * f0 -> TypeSpecifier() | ||
200 | * f1 -> <IDENTIFIER> | ||
201 | * f2 -> [ Array() | ":" ConstantExpression() ] | ||
202 | * f3 -> [ <IDENTIFIER> ] | ||
203 | * f4 -> ";" | ||
204 | * </PRE> | ||
205 | */ | ||
206 | public R visit(StructDeclaration n, A argu); | ||
207 | |||
208 | /** | ||
209 | * <PRE> | ||
210 | * f0 -> <ENUM> | ||
211 | * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> ) | ||
212 | * </PRE> | ||
213 | */ | ||
214 | public R visit(EnumSpecifier n, A argu); | ||
215 | |||
216 | /** | ||
217 | * <PRE> | ||
218 | * f0 -> Enumerator() | ||
219 | * f1 -> ( "," Enumerator() )* | ||
220 | * </PRE> | ||
221 | */ | ||
222 | public R visit(EnumeratorList n, A argu); | ||
223 | |||
224 | /** | ||
225 | * <PRE> | ||
226 | * f0 -> <IDENTIFIER> | ||
227 | * f1 -> [ "=" ConstantExpression() ] | ||
228 | * </PRE> | ||
229 | */ | ||
230 | public R visit(Enumerator n, A argu); | ||
231 | |||
232 | /** | ||
233 | * <PRE> | ||
234 | * f0 -> "*" | ||
235 | * f1 -> [ <CONST> ] | ||
236 | * f2 -> [ Pointer() ] | ||
237 | * </PRE> | ||
238 | */ | ||
239 | public R visit(Pointer n, A argu); | ||
240 | |||
241 | /** | ||
242 | * <PRE> | ||
243 | * f0 -> <IDENTIFIER> | ||
244 | * f1 -> ( "," <IDENTIFIER> )* | ||
245 | * </PRE> | ||
246 | */ | ||
247 | public R visit(IdentifierList n, A argu); | ||
248 | |||
249 | /** | ||
250 | * <PRE> | ||
251 | * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" ) | ||
252 | * </PRE> | ||
253 | */ | ||
254 | public R visit(Initializer n, A argu); | ||
255 | |||
256 | /** | ||
257 | * <PRE> | ||
258 | * f0 -> Initializer() | ||
259 | * f1 -> ( "," Initializer() )* | ||
260 | * </PRE> | ||
261 | */ | ||
262 | public R visit(InitializerList n, A argu); | ||
263 | |||
264 | /** | ||
265 | * <PRE> | ||
266 | * f0 -> "[" | ||
267 | * f1 -> [ ConstantExpression() ] | ||
268 | * f2 -> "]" | ||
269 | * </PRE> | ||
270 | */ | ||
271 | public R visit(Array n, A argu); | ||
272 | |||
273 | /** | ||
274 | * <PRE> | ||
275 | * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() ) | ||
276 | * </PRE> | ||
277 | */ | ||
278 | public R visit(Statement n, A argu); | ||
279 | |||
280 | /** | ||
281 | * <PRE> | ||
282 | * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() ) | ||
283 | * </PRE> | ||
284 | */ | ||
285 | public R visit(LabeledStatement n, A argu); | ||
286 | |||
287 | /** | ||
288 | * <PRE> | ||
289 | * f0 -> [ Expression() ] | ||
290 | * f1 -> ";" | ||
291 | * </PRE> | ||
292 | */ | ||
293 | public R visit(ExpressionStatement n, A argu); | ||
294 | |||
295 | /** | ||
296 | * <PRE> | ||
297 | * f0 -> "{" | ||
298 | * f1 -> ( LocalVariableDeclaration() | Statement() )* | ||
299 | * f2 -> "}" | ||
300 | * </PRE> | ||
301 | */ | ||
302 | public R visit(CompoundStatement n, A argu); | ||
303 | |||
304 | /** | ||
305 | * <PRE> | ||
306 | * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() ) | ||
307 | * </PRE> | ||
308 | */ | ||
309 | public R visit(SelectionStatement n, A argu); | ||
310 | |||
311 | /** | ||
312 | * <PRE> | ||
313 | * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() ) | ||
314 | * </PRE> | ||
315 | */ | ||
316 | public R visit(IterationStatement n, A argu); | ||
317 | |||
318 | /** | ||
319 | * <PRE> | ||
320 | * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" ) | ||
321 | * </PRE> | ||
322 | */ | ||
323 | public R visit(JumpStatement n, A argu); | ||
324 | |||
325 | /** | ||
326 | * <PRE> | ||
327 | * f0 -> AssignmentExpression() | ||
328 | * f1 -> ( "," AssignmentExpression() )* | ||
329 | * </PRE> | ||
330 | */ | ||
331 | public R visit(Expression n, A argu); | ||
332 | |||
333 | /** | ||
334 | * <PRE> | ||
335 | * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression() | ||
336 | * | ConditionalExpression() | ||
337 | * </PRE> | ||
338 | */ | ||
339 | public R visit(AssignmentExpression n, A argu); | ||
340 | |||
341 | /** | ||
342 | * <PRE> | ||
343 | * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" ) | ||
344 | * </PRE> | ||
345 | */ | ||
346 | public R visit(AssignmentOperator n, A argu); | ||
347 | |||
348 | /** | ||
349 | * <PRE> | ||
350 | * f0 -> LogicalORExpression() | ||
351 | * f1 -> [ "?" Expression() ":" ConditionalExpression() ] | ||
352 | * </PRE> | ||
353 | */ | ||
354 | public R visit(ConditionalExpression n, A argu); | ||
355 | |||
356 | /** | ||
357 | * <PRE> | ||
358 | * f0 -> ConditionalExpression() | ||
359 | * </PRE> | ||
360 | */ | ||
361 | public R visit(ConstantExpression n, A argu); | ||
362 | |||
363 | /** | ||
364 | * <PRE> | ||
365 | * f0 -> LogicalANDExpression() | ||
366 | * f1 -> [ "||" LogicalORExpression() ] | ||
367 | * </PRE> | ||
368 | */ | ||
369 | public R visit(LogicalORExpression n, A argu); | ||
370 | |||
371 | /** | ||
372 | * <PRE> | ||
373 | * f0 -> InclusiveORExpression() | ||
374 | * f1 -> [ "&&" LogicalANDExpression() ] | ||
375 | * </PRE> | ||
376 | */ | ||
377 | public R visit(LogicalANDExpression n, A argu); | ||
378 | |||
379 | /** | ||
380 | * <PRE> | ||
381 | * f0 -> ExclusiveORExpression() | ||
382 | * f1 -> [ "|" InclusiveORExpression() ] | ||
383 | * </PRE> | ||
384 | */ | ||
385 | public R visit(InclusiveORExpression n, A argu); | ||
386 | |||
387 | /** | ||
388 | * <PRE> | ||
389 | * f0 -> ANDExpression() | ||
390 | * f1 -> [ "^" ExclusiveORExpression() ] | ||
391 | * </PRE> | ||
392 | */ | ||
393 | public R visit(ExclusiveORExpression n, A argu); | ||
394 | |||
395 | /** | ||
396 | * <PRE> | ||
397 | * f0 -> EqualityExpression() | ||
398 | * f1 -> [ "&" ANDExpression() ] | ||
399 | * </PRE> | ||
400 | */ | ||
401 | public R visit(ANDExpression n, A argu); | ||
402 | |||
403 | /** | ||
404 | * <PRE> | ||
405 | * f0 -> RelationalExpression() | ||
406 | * f1 -> [ ( "==" | "!=" ) EqualityExpression() ] | ||
407 | * </PRE> | ||
408 | */ | ||
409 | public R visit(EqualityExpression n, A argu); | ||
410 | |||
411 | /** | ||
412 | * <PRE> | ||
413 | * f0 -> ShiftExpression() | ||
414 | * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ] | ||
415 | * </PRE> | ||
416 | */ | ||
417 | public R visit(RelationalExpression n, A argu); | ||
418 | |||
419 | /** | ||
420 | * <PRE> | ||
421 | * f0 -> AdditiveExpression() | ||
422 | * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ] | ||
423 | * </PRE> | ||
424 | */ | ||
425 | public R visit(ShiftExpression n, A argu); | ||
426 | |||
427 | /** | ||
428 | * <PRE> | ||
429 | * f0 -> MultiplicativeExpression() | ||
430 | * f1 -> [ ( "+" | "-" ) AdditiveExpression() ] | ||
431 | * </PRE> | ||
432 | */ | ||
433 | public R visit(AdditiveExpression n, A argu); | ||
434 | |||
435 | /** | ||
436 | * <PRE> | ||
437 | * f0 -> CastExpression() | ||
438 | * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ] | ||
439 | * </PRE> | ||
440 | */ | ||
441 | public R visit(MultiplicativeExpression n, A argu); | ||
442 | |||
443 | /** | ||
444 | * <PRE> | ||
445 | * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() ) | ||
446 | * </PRE> | ||
447 | */ | ||
448 | public R visit(CastExpression n, A argu); | ||
449 | |||
450 | /** | ||
451 | * <PRE> | ||
452 | * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) ) | ||
453 | * </PRE> | ||
454 | */ | ||
455 | public R visit(UnaryExpression n, A argu); | ||
456 | |||
457 | /** | ||
458 | * <PRE> | ||
459 | * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" ) | ||
460 | * </PRE> | ||
461 | */ | ||
462 | public R visit(UnaryOperator n, A argu); | ||
463 | |||
464 | /** | ||
465 | * <PRE> | ||
466 | * f0 -> PrimaryExpression() | ||
467 | * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )* | ||
468 | * </PRE> | ||
469 | */ | ||
470 | public R visit(PostfixExpression n, A argu); | ||
471 | |||
472 | /** | ||
473 | * <PRE> | ||
474 | * f0 -> <IDENTIFIER> | ||
475 | * | Constant() | ||
476 | * | "(" Expression() ")" | ||
477 | * </PRE> | ||
478 | */ | ||
479 | public R visit(PrimaryExpression n, A argu); | ||
480 | |||
481 | /** | ||
482 | * <PRE> | ||
483 | * f0 -> AssignmentOrTypeExpression() | ||
484 | * f1 -> ( "," AssignmentOrTypeExpression() )* | ||
485 | * </PRE> | ||
486 | */ | ||
487 | public R visit(ArgumentExpressionList n, A argu); | ||
488 | |||
489 | /** | ||
490 | * <PRE> | ||
491 | * f0 -> NoIdentifierTypeSpecifier() | ||
492 | * | AssignmentExpression() | ||
493 | * </PRE> | ||
494 | */ | ||
495 | public R visit(AssignmentOrTypeExpression n, A argu); | ||
496 | |||
497 | /** | ||
498 | * <PRE> | ||
499 | * f0 -> <INTEGER_LITERAL> | ||
500 | * | <FLOATING_POINT_LITERAL> | ||
501 | * | <CHARACTER_LITERAL> | ||
502 | * | <STRING_LITERAL> | ||
503 | * </PRE> | ||
504 | */ | ||
505 | public R visit(Constant n, A argu); | ||
506 | |||
507 | } | ||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVoidDepthFirst.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVoidDepthFirst.java new file mode 100644 index 000000000..eb49d3698 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVoidDepthFirst.java | |||
@@ -0,0 +1,711 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.visitors; | ||
6 | import org.gnunet.seaspider.parser.nodes.*; | ||
7 | |||
8 | import java.util.*; | ||
9 | |||
10 | /** | ||
11 | * Provides default methods which visit each node in the tree in depth-first | ||
12 | * order. Your visitors may extend this class. | ||
13 | */ | ||
14 | public class GJVoidDepthFirst<A> implements GJVoidVisitor<A> { | ||
15 | // | ||
16 | // Auto class visitors--probably don't need to be overridden. | ||
17 | // | ||
18 | public void visit(NodeList n, A argu) { | ||
19 | int _count=0; | ||
20 | for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) { | ||
21 | e.nextElement().accept(this,argu); | ||
22 | _count++; | ||
23 | } | ||
24 | } | ||
25 | |||
26 | public void visit(NodeListOptional n, A argu) { | ||
27 | if ( n.present() ) { | ||
28 | int _count=0; | ||
29 | for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) { | ||
30 | e.nextElement().accept(this,argu); | ||
31 | _count++; | ||
32 | } | ||
33 | } | ||
34 | } | ||
35 | |||
36 | public void visit(NodeOptional n, A argu) { | ||
37 | if ( n.present() ) | ||
38 | n.node.accept(this,argu); | ||
39 | } | ||
40 | |||
41 | public void visit(NodeSequence n, A argu) { | ||
42 | int _count=0; | ||
43 | for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) { | ||
44 | e.nextElement().accept(this,argu); | ||
45 | _count++; | ||
46 | } | ||
47 | } | ||
48 | |||
49 | public void visit(NodeToken n, A argu) {} | ||
50 | |||
51 | // | ||
52 | // User-generated visitor methods below | ||
53 | // | ||
54 | |||
55 | /** | ||
56 | * <PRE> | ||
57 | * f0 -> ( ExternalDeclaration() )+ | ||
58 | * </PRE> | ||
59 | */ | ||
60 | public void visit(TranslationUnit n, A argu) { | ||
61 | n.f0.accept(this, argu); | ||
62 | } | ||
63 | |||
64 | /** | ||
65 | * <PRE> | ||
66 | * f0 -> ( StorageClassSpecifier() )* | ||
67 | * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() ) | ||
68 | * </PRE> | ||
69 | */ | ||
70 | public void visit(ExternalDeclaration n, A argu) { | ||
71 | n.f0.accept(this, argu); | ||
72 | n.f1.accept(this, argu); | ||
73 | } | ||
74 | |||
75 | /** | ||
76 | * <PRE> | ||
77 | * f0 -> TypeSpecifier() | ||
78 | * f1 -> <IDENTIFIER> | ||
79 | * f2 -> "(" | ||
80 | * f3 -> [ ParameterList() ] | ||
81 | * f4 -> ")" | ||
82 | * f5 -> ( ";" | CompoundStatement() ) | ||
83 | * </PRE> | ||
84 | */ | ||
85 | public void visit(FunctionDeclaration n, A argu) { | ||
86 | n.f0.accept(this, argu); | ||
87 | n.f1.accept(this, argu); | ||
88 | n.f2.accept(this, argu); | ||
89 | n.f3.accept(this, argu); | ||
90 | n.f4.accept(this, argu); | ||
91 | n.f5.accept(this, argu); | ||
92 | } | ||
93 | |||
94 | /** | ||
95 | * <PRE> | ||
96 | * f0 -> ( <STATIC> | <EXTERN> ) | ||
97 | * </PRE> | ||
98 | */ | ||
99 | public void visit(StorageClassSpecifier n, A argu) { | ||
100 | n.f0.accept(this, argu); | ||
101 | } | ||
102 | |||
103 | /** | ||
104 | * <PRE> | ||
105 | * f0 -> <TYPEDEF> | ||
106 | * f1 -> ( DataType() | FunctionType() ) | ||
107 | * f2 -> ";" | ||
108 | * </PRE> | ||
109 | */ | ||
110 | public void visit(TypeDeclaration n, A argu) { | ||
111 | n.f0.accept(this, argu); | ||
112 | n.f1.accept(this, argu); | ||
113 | n.f2.accept(this, argu); | ||
114 | } | ||
115 | |||
116 | /** | ||
117 | * <PRE> | ||
118 | * f0 -> StructOrUnionSpecifier() | ||
119 | * f1 -> <IDENTIFIER> | ||
120 | * </PRE> | ||
121 | */ | ||
122 | public void visit(DataType n, A argu) { | ||
123 | n.f0.accept(this, argu); | ||
124 | n.f1.accept(this, argu); | ||
125 | } | ||
126 | |||
127 | /** | ||
128 | * <PRE> | ||
129 | * f0 -> TypeSpecifier() | ||
130 | * f1 -> "(" | ||
131 | * f2 -> "*" | ||
132 | * f3 -> <IDENTIFIER> | ||
133 | * f4 -> ")" | ||
134 | * f5 -> "(" | ||
135 | * f6 -> [ ParameterList() ] | ||
136 | * f7 -> ")" | ||
137 | * </PRE> | ||
138 | */ | ||
139 | public void visit(FunctionType n, A argu) { | ||
140 | n.f0.accept(this, argu); | ||
141 | n.f1.accept(this, argu); | ||
142 | n.f2.accept(this, argu); | ||
143 | n.f3.accept(this, argu); | ||
144 | n.f4.accept(this, argu); | ||
145 | n.f5.accept(this, argu); | ||
146 | n.f6.accept(this, argu); | ||
147 | n.f7.accept(this, argu); | ||
148 | } | ||
149 | |||
150 | /** | ||
151 | * <PRE> | ||
152 | * f0 -> ParameterDeclaration() | ||
153 | * f1 -> ( "," ParameterDeclaration() )* | ||
154 | * f2 -> [ "," "..." ] | ||
155 | * </PRE> | ||
156 | */ | ||
157 | public void visit(ParameterList n, A argu) { | ||
158 | n.f0.accept(this, argu); | ||
159 | n.f1.accept(this, argu); | ||
160 | n.f2.accept(this, argu); | ||
161 | } | ||
162 | |||
163 | /** | ||
164 | * <PRE> | ||
165 | * f0 -> TypeSpecifier() | ||
166 | * f1 -> <IDENTIFIER> | ||
167 | * f2 -> [ Array() ] | ||
168 | * </PRE> | ||
169 | */ | ||
170 | public void visit(ParameterDeclaration n, A argu) { | ||
171 | n.f0.accept(this, argu); | ||
172 | n.f1.accept(this, argu); | ||
173 | n.f2.accept(this, argu); | ||
174 | } | ||
175 | |||
176 | /** | ||
177 | * <PRE> | ||
178 | * f0 -> VariableClassSpecifier() | ||
179 | * f1 -> TypeSpecifier() | ||
180 | * f2 -> InitDeclaratorList() | ||
181 | * f3 -> ";" | ||
182 | * </PRE> | ||
183 | */ | ||
184 | public void visit(VariableDeclaration n, A argu) { | ||
185 | n.f0.accept(this, argu); | ||
186 | n.f1.accept(this, argu); | ||
187 | n.f2.accept(this, argu); | ||
188 | n.f3.accept(this, argu); | ||
189 | } | ||
190 | |||
191 | /** | ||
192 | * <PRE> | ||
193 | * f0 -> [ <STATIC> ] | ||
194 | * f1 -> VariableDeclaration() | ||
195 | * </PRE> | ||
196 | */ | ||
197 | public void visit(LocalVariableDeclaration n, A argu) { | ||
198 | n.f0.accept(this, argu); | ||
199 | n.f1.accept(this, argu); | ||
200 | } | ||
201 | |||
202 | /** | ||
203 | * <PRE> | ||
204 | * f0 -> ( <AUTO> | <REGISTER> )* | ||
205 | * </PRE> | ||
206 | */ | ||
207 | public void visit(VariableClassSpecifier n, A argu) { | ||
208 | n.f0.accept(this, argu); | ||
209 | } | ||
210 | |||
211 | /** | ||
212 | * <PRE> | ||
213 | * f0 -> [ <CONST> ] | ||
214 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> ) | ||
215 | * f2 -> [ Pointer() ] | ||
216 | * f3 -> [ Array() ] | ||
217 | * </PRE> | ||
218 | */ | ||
219 | public void visit(TypeSpecifier n, A argu) { | ||
220 | n.f0.accept(this, argu); | ||
221 | n.f1.accept(this, argu); | ||
222 | n.f2.accept(this, argu); | ||
223 | n.f3.accept(this, argu); | ||
224 | } | ||
225 | |||
226 | /** | ||
227 | * <PRE> | ||
228 | * f0 -> [ <CONST> ] | ||
229 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() ) | ||
230 | * f2 -> [ Pointer() ] | ||
231 | * f3 -> [ Array() ] | ||
232 | * </PRE> | ||
233 | */ | ||
234 | public void visit(NoIdentifierTypeSpecifier n, A argu) { | ||
235 | n.f0.accept(this, argu); | ||
236 | n.f1.accept(this, argu); | ||
237 | n.f2.accept(this, argu); | ||
238 | n.f3.accept(this, argu); | ||
239 | } | ||
240 | |||
241 | /** | ||
242 | * <PRE> | ||
243 | * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}" | ||
244 | * | StructOrUnion() <IDENTIFIER> | ||
245 | * </PRE> | ||
246 | */ | ||
247 | public void visit(StructOrUnionSpecifier n, A argu) { | ||
248 | n.f0.accept(this, argu); | ||
249 | } | ||
250 | |||
251 | /** | ||
252 | * <PRE> | ||
253 | * f0 -> ( <STRUCT> | <UNION> ) | ||
254 | * </PRE> | ||
255 | */ | ||
256 | public void visit(StructOrUnion n, A argu) { | ||
257 | n.f0.accept(this, argu); | ||
258 | } | ||
259 | |||
260 | /** | ||
261 | * <PRE> | ||
262 | * f0 -> ( StructDeclaration() )+ | ||
263 | * </PRE> | ||
264 | */ | ||
265 | public void visit(StructDeclarationList n, A argu) { | ||
266 | n.f0.accept(this, argu); | ||
267 | } | ||
268 | |||
269 | /** | ||
270 | * <PRE> | ||
271 | * f0 -> InitDeclarator() | ||
272 | * f1 -> ( "," InitDeclarator() )* | ||
273 | * </PRE> | ||
274 | */ | ||
275 | public void visit(InitDeclaratorList n, A argu) { | ||
276 | n.f0.accept(this, argu); | ||
277 | n.f1.accept(this, argu); | ||
278 | } | ||
279 | |||
280 | /** | ||
281 | * <PRE> | ||
282 | * f0 -> <IDENTIFIER> | ||
283 | * f1 -> [ Array() ] | ||
284 | * f2 -> [ "=" Initializer() ] | ||
285 | * </PRE> | ||
286 | */ | ||
287 | public void visit(InitDeclarator n, A argu) { | ||
288 | n.f0.accept(this, argu); | ||
289 | n.f1.accept(this, argu); | ||
290 | n.f2.accept(this, argu); | ||
291 | } | ||
292 | |||
293 | /** | ||
294 | * <PRE> | ||
295 | * f0 -> TypeSpecifier() | ||
296 | * f1 -> <IDENTIFIER> | ||
297 | * f2 -> [ Array() | ":" ConstantExpression() ] | ||
298 | * f3 -> [ <IDENTIFIER> ] | ||
299 | * f4 -> ";" | ||
300 | * </PRE> | ||
301 | */ | ||
302 | public void visit(StructDeclaration n, A argu) { | ||
303 | n.f0.accept(this, argu); | ||
304 | n.f1.accept(this, argu); | ||
305 | n.f2.accept(this, argu); | ||
306 | n.f3.accept(this, argu); | ||
307 | n.f4.accept(this, argu); | ||
308 | } | ||
309 | |||
310 | /** | ||
311 | * <PRE> | ||
312 | * f0 -> <ENUM> | ||
313 | * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> ) | ||
314 | * </PRE> | ||
315 | */ | ||
316 | public void visit(EnumSpecifier n, A argu) { | ||
317 | n.f0.accept(this, argu); | ||
318 | n.f1.accept(this, argu); | ||
319 | } | ||
320 | |||
321 | /** | ||
322 | * <PRE> | ||
323 | * f0 -> Enumerator() | ||
324 | * f1 -> ( "," Enumerator() )* | ||
325 | * </PRE> | ||
326 | */ | ||
327 | public void visit(EnumeratorList n, A argu) { | ||
328 | n.f0.accept(this, argu); | ||
329 | n.f1.accept(this, argu); | ||
330 | } | ||
331 | |||
332 | /** | ||
333 | * <PRE> | ||
334 | * f0 -> <IDENTIFIER> | ||
335 | * f1 -> [ "=" ConstantExpression() ] | ||
336 | * </PRE> | ||
337 | */ | ||
338 | public void visit(Enumerator n, A argu) { | ||
339 | n.f0.accept(this, argu); | ||
340 | n.f1.accept(this, argu); | ||
341 | } | ||
342 | |||
343 | /** | ||
344 | * <PRE> | ||
345 | * f0 -> "*" | ||
346 | * f1 -> [ <CONST> ] | ||
347 | * f2 -> [ Pointer() ] | ||
348 | * </PRE> | ||
349 | */ | ||
350 | public void visit(Pointer n, A argu) { | ||
351 | n.f0.accept(this, argu); | ||
352 | n.f1.accept(this, argu); | ||
353 | n.f2.accept(this, argu); | ||
354 | } | ||
355 | |||
356 | /** | ||
357 | * <PRE> | ||
358 | * f0 -> <IDENTIFIER> | ||
359 | * f1 -> ( "," <IDENTIFIER> )* | ||
360 | * </PRE> | ||
361 | */ | ||
362 | public void visit(IdentifierList n, A argu) { | ||
363 | n.f0.accept(this, argu); | ||
364 | n.f1.accept(this, argu); | ||
365 | } | ||
366 | |||
367 | /** | ||
368 | * <PRE> | ||
369 | * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" ) | ||
370 | * </PRE> | ||
371 | */ | ||
372 | public void visit(Initializer n, A argu) { | ||
373 | n.f0.accept(this, argu); | ||
374 | } | ||
375 | |||
376 | /** | ||
377 | * <PRE> | ||
378 | * f0 -> Initializer() | ||
379 | * f1 -> ( "," Initializer() )* | ||
380 | * </PRE> | ||
381 | */ | ||
382 | public void visit(InitializerList n, A argu) { | ||
383 | n.f0.accept(this, argu); | ||
384 | n.f1.accept(this, argu); | ||
385 | } | ||
386 | |||
387 | /** | ||
388 | * <PRE> | ||
389 | * f0 -> "[" | ||
390 | * f1 -> [ ConstantExpression() ] | ||
391 | * f2 -> "]" | ||
392 | * </PRE> | ||
393 | */ | ||
394 | public void visit(Array n, A argu) { | ||
395 | n.f0.accept(this, argu); | ||
396 | n.f1.accept(this, argu); | ||
397 | n.f2.accept(this, argu); | ||
398 | } | ||
399 | |||
400 | /** | ||
401 | * <PRE> | ||
402 | * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() ) | ||
403 | * </PRE> | ||
404 | */ | ||
405 | public void visit(Statement n, A argu) { | ||
406 | n.f0.accept(this, argu); | ||
407 | } | ||
408 | |||
409 | /** | ||
410 | * <PRE> | ||
411 | * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() ) | ||
412 | * </PRE> | ||
413 | */ | ||
414 | public void visit(LabeledStatement n, A argu) { | ||
415 | n.f0.accept(this, argu); | ||
416 | } | ||
417 | |||
418 | /** | ||
419 | * <PRE> | ||
420 | * f0 -> [ Expression() ] | ||
421 | * f1 -> ";" | ||
422 | * </PRE> | ||
423 | */ | ||
424 | public void visit(ExpressionStatement n, A argu) { | ||
425 | n.f0.accept(this, argu); | ||
426 | n.f1.accept(this, argu); | ||
427 | } | ||
428 | |||
429 | /** | ||
430 | * <PRE> | ||
431 | * f0 -> "{" | ||
432 | * f1 -> ( LocalVariableDeclaration() | Statement() )* | ||
433 | * f2 -> "}" | ||
434 | * </PRE> | ||
435 | */ | ||
436 | public void visit(CompoundStatement n, A argu) { | ||
437 | n.f0.accept(this, argu); | ||
438 | n.f1.accept(this, argu); | ||
439 | n.f2.accept(this, argu); | ||
440 | } | ||
441 | |||
442 | /** | ||
443 | * <PRE> | ||
444 | * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() ) | ||
445 | * </PRE> | ||
446 | */ | ||
447 | public void visit(SelectionStatement n, A argu) { | ||
448 | n.f0.accept(this, argu); | ||
449 | } | ||
450 | |||
451 | /** | ||
452 | * <PRE> | ||
453 | * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() ) | ||
454 | * </PRE> | ||
455 | */ | ||
456 | public void visit(IterationStatement n, A argu) { | ||
457 | n.f0.accept(this, argu); | ||
458 | } | ||
459 | |||
460 | /** | ||
461 | * <PRE> | ||
462 | * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" ) | ||
463 | * </PRE> | ||
464 | */ | ||
465 | public void visit(JumpStatement n, A argu) { | ||
466 | n.f0.accept(this, argu); | ||
467 | } | ||
468 | |||
469 | /** | ||
470 | * <PRE> | ||
471 | * f0 -> AssignmentExpression() | ||
472 | * f1 -> ( "," AssignmentExpression() )* | ||
473 | * </PRE> | ||
474 | */ | ||
475 | public void visit(Expression n, A argu) { | ||
476 | n.f0.accept(this, argu); | ||
477 | n.f1.accept(this, argu); | ||
478 | } | ||
479 | |||
480 | /** | ||
481 | * <PRE> | ||
482 | * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression() | ||
483 | * | ConditionalExpression() | ||
484 | * </PRE> | ||
485 | */ | ||
486 | public void visit(AssignmentExpression n, A argu) { | ||
487 | n.f0.accept(this, argu); | ||
488 | } | ||
489 | |||
490 | /** | ||
491 | * <PRE> | ||
492 | * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" ) | ||
493 | * </PRE> | ||
494 | */ | ||
495 | public void visit(AssignmentOperator n, A argu) { | ||
496 | n.f0.accept(this, argu); | ||
497 | } | ||
498 | |||
499 | /** | ||
500 | * <PRE> | ||
501 | * f0 -> LogicalORExpression() | ||
502 | * f1 -> [ "?" Expression() ":" ConditionalExpression() ] | ||
503 | * </PRE> | ||
504 | */ | ||
505 | public void visit(ConditionalExpression n, A argu) { | ||
506 | n.f0.accept(this, argu); | ||
507 | n.f1.accept(this, argu); | ||
508 | } | ||
509 | |||
510 | /** | ||
511 | * <PRE> | ||
512 | * f0 -> ConditionalExpression() | ||
513 | * </PRE> | ||
514 | */ | ||
515 | public void visit(ConstantExpression n, A argu) { | ||
516 | n.f0.accept(this, argu); | ||
517 | } | ||
518 | |||
519 | /** | ||
520 | * <PRE> | ||
521 | * f0 -> LogicalANDExpression() | ||
522 | * f1 -> [ "||" LogicalORExpression() ] | ||
523 | * </PRE> | ||
524 | */ | ||
525 | public void visit(LogicalORExpression n, A argu) { | ||
526 | n.f0.accept(this, argu); | ||
527 | n.f1.accept(this, argu); | ||
528 | } | ||
529 | |||
530 | /** | ||
531 | * <PRE> | ||
532 | * f0 -> InclusiveORExpression() | ||
533 | * f1 -> [ "&&" LogicalANDExpression() ] | ||
534 | * </PRE> | ||
535 | */ | ||
536 | public void visit(LogicalANDExpression n, A argu) { | ||
537 | n.f0.accept(this, argu); | ||
538 | n.f1.accept(this, argu); | ||
539 | } | ||
540 | |||
541 | /** | ||
542 | * <PRE> | ||
543 | * f0 -> ExclusiveORExpression() | ||
544 | * f1 -> [ "|" InclusiveORExpression() ] | ||
545 | * </PRE> | ||
546 | */ | ||
547 | public void visit(InclusiveORExpression n, A argu) { | ||
548 | n.f0.accept(this, argu); | ||
549 | n.f1.accept(this, argu); | ||
550 | } | ||
551 | |||
552 | /** | ||
553 | * <PRE> | ||
554 | * f0 -> ANDExpression() | ||
555 | * f1 -> [ "^" ExclusiveORExpression() ] | ||
556 | * </PRE> | ||
557 | */ | ||
558 | public void visit(ExclusiveORExpression n, A argu) { | ||
559 | n.f0.accept(this, argu); | ||
560 | n.f1.accept(this, argu); | ||
561 | } | ||
562 | |||
563 | /** | ||
564 | * <PRE> | ||
565 | * f0 -> EqualityExpression() | ||
566 | * f1 -> [ "&" ANDExpression() ] | ||
567 | * </PRE> | ||
568 | */ | ||
569 | public void visit(ANDExpression n, A argu) { | ||
570 | n.f0.accept(this, argu); | ||
571 | n.f1.accept(this, argu); | ||
572 | } | ||
573 | |||
574 | /** | ||
575 | * <PRE> | ||
576 | * f0 -> RelationalExpression() | ||
577 | * f1 -> [ ( "==" | "!=" ) EqualityExpression() ] | ||
578 | * </PRE> | ||
579 | */ | ||
580 | public void visit(EqualityExpression n, A argu) { | ||
581 | n.f0.accept(this, argu); | ||
582 | n.f1.accept(this, argu); | ||
583 | } | ||
584 | |||
585 | /** | ||
586 | * <PRE> | ||
587 | * f0 -> ShiftExpression() | ||
588 | * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ] | ||
589 | * </PRE> | ||
590 | */ | ||
591 | public void visit(RelationalExpression n, A argu) { | ||
592 | n.f0.accept(this, argu); | ||
593 | n.f1.accept(this, argu); | ||
594 | } | ||
595 | |||
596 | /** | ||
597 | * <PRE> | ||
598 | * f0 -> AdditiveExpression() | ||
599 | * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ] | ||
600 | * </PRE> | ||
601 | */ | ||
602 | public void visit(ShiftExpression n, A argu) { | ||
603 | n.f0.accept(this, argu); | ||
604 | n.f1.accept(this, argu); | ||
605 | } | ||
606 | |||
607 | /** | ||
608 | * <PRE> | ||
609 | * f0 -> MultiplicativeExpression() | ||
610 | * f1 -> [ ( "+" | "-" ) AdditiveExpression() ] | ||
611 | * </PRE> | ||
612 | */ | ||
613 | public void visit(AdditiveExpression n, A argu) { | ||
614 | n.f0.accept(this, argu); | ||
615 | n.f1.accept(this, argu); | ||
616 | } | ||
617 | |||
618 | /** | ||
619 | * <PRE> | ||
620 | * f0 -> CastExpression() | ||
621 | * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ] | ||
622 | * </PRE> | ||
623 | */ | ||
624 | public void visit(MultiplicativeExpression n, A argu) { | ||
625 | n.f0.accept(this, argu); | ||
626 | n.f1.accept(this, argu); | ||
627 | } | ||
628 | |||
629 | /** | ||
630 | * <PRE> | ||
631 | * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() ) | ||
632 | * </PRE> | ||
633 | */ | ||
634 | public void visit(CastExpression n, A argu) { | ||
635 | n.f0.accept(this, argu); | ||
636 | } | ||
637 | |||
638 | /** | ||
639 | * <PRE> | ||
640 | * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) ) | ||
641 | * </PRE> | ||
642 | */ | ||
643 | public void visit(UnaryExpression n, A argu) { | ||
644 | n.f0.accept(this, argu); | ||
645 | } | ||
646 | |||
647 | /** | ||
648 | * <PRE> | ||
649 | * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" ) | ||
650 | * </PRE> | ||
651 | */ | ||
652 | public void visit(UnaryOperator n, A argu) { | ||
653 | n.f0.accept(this, argu); | ||
654 | } | ||
655 | |||
656 | /** | ||
657 | * <PRE> | ||
658 | * f0 -> PrimaryExpression() | ||
659 | * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )* | ||
660 | * </PRE> | ||
661 | */ | ||
662 | public void visit(PostfixExpression n, A argu) { | ||
663 | n.f0.accept(this, argu); | ||
664 | n.f1.accept(this, argu); | ||
665 | } | ||
666 | |||
667 | /** | ||
668 | * <PRE> | ||
669 | * f0 -> <IDENTIFIER> | ||
670 | * | Constant() | ||
671 | * | "(" Expression() ")" | ||
672 | * </PRE> | ||
673 | */ | ||
674 | public void visit(PrimaryExpression n, A argu) { | ||
675 | n.f0.accept(this, argu); | ||
676 | } | ||
677 | |||
678 | /** | ||
679 | * <PRE> | ||
680 | * f0 -> AssignmentOrTypeExpression() | ||
681 | * f1 -> ( "," AssignmentOrTypeExpression() )* | ||
682 | * </PRE> | ||
683 | */ | ||
684 | public void visit(ArgumentExpressionList n, A argu) { | ||
685 | n.f0.accept(this, argu); | ||
686 | n.f1.accept(this, argu); | ||
687 | } | ||
688 | |||
689 | /** | ||
690 | * <PRE> | ||
691 | * f0 -> NoIdentifierTypeSpecifier() | ||
692 | * | AssignmentExpression() | ||
693 | * </PRE> | ||
694 | */ | ||
695 | public void visit(AssignmentOrTypeExpression n, A argu) { | ||
696 | n.f0.accept(this, argu); | ||
697 | } | ||
698 | |||
699 | /** | ||
700 | * <PRE> | ||
701 | * f0 -> <INTEGER_LITERAL> | ||
702 | * | <FLOATING_POINT_LITERAL> | ||
703 | * | <CHARACTER_LITERAL> | ||
704 | * | <STRING_LITERAL> | ||
705 | * </PRE> | ||
706 | */ | ||
707 | public void visit(Constant n, A argu) { | ||
708 | n.f0.accept(this, argu); | ||
709 | } | ||
710 | |||
711 | } | ||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVoidVisitor.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVoidVisitor.java new file mode 100644 index 000000000..13176c4e8 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVoidVisitor.java | |||
@@ -0,0 +1,508 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.visitors; | ||
6 | import org.gnunet.seaspider.parser.nodes.*; | ||
7 | |||
8 | import java.util.*; | ||
9 | |||
10 | /** | ||
11 | * All GJ void visitors must implement this interface. | ||
12 | */ | ||
13 | |||
14 | public interface GJVoidVisitor<A> { | ||
15 | |||
16 | // | ||
17 | // GJ void Auto class visitors | ||
18 | // | ||
19 | |||
20 | public void visit(NodeList n, A argu); | ||
21 | public void visit(NodeListOptional n, A argu); | ||
22 | public void visit(NodeOptional n, A argu); | ||
23 | public void visit(NodeSequence n, A argu); | ||
24 | public void visit(NodeToken n, A argu); | ||
25 | |||
26 | // | ||
27 | // User-generated visitor methods below | ||
28 | // | ||
29 | |||
30 | /** | ||
31 | * <PRE> | ||
32 | * f0 -> ( ExternalDeclaration() )+ | ||
33 | * </PRE> | ||
34 | */ | ||
35 | public void visit(TranslationUnit n, A argu); | ||
36 | |||
37 | /** | ||
38 | * <PRE> | ||
39 | * f0 -> ( StorageClassSpecifier() )* | ||
40 | * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() ) | ||
41 | * </PRE> | ||
42 | */ | ||
43 | public void visit(ExternalDeclaration n, A argu); | ||
44 | |||
45 | /** | ||
46 | * <PRE> | ||
47 | * f0 -> TypeSpecifier() | ||
48 | * f1 -> <IDENTIFIER> | ||
49 | * f2 -> "(" | ||
50 | * f3 -> [ ParameterList() ] | ||
51 | * f4 -> ")" | ||
52 | * f5 -> ( ";" | CompoundStatement() ) | ||
53 | * </PRE> | ||
54 | */ | ||
55 | public void visit(FunctionDeclaration n, A argu); | ||
56 | |||
57 | /** | ||
58 | * <PRE> | ||
59 | * f0 -> ( <STATIC> | <EXTERN> ) | ||
60 | * </PRE> | ||
61 | */ | ||
62 | public void visit(StorageClassSpecifier n, A argu); | ||
63 | |||
64 | /** | ||
65 | * <PRE> | ||
66 | * f0 -> <TYPEDEF> | ||
67 | * f1 -> ( DataType() | FunctionType() ) | ||
68 | * f2 -> ";" | ||
69 | * </PRE> | ||
70 | */ | ||
71 | public void visit(TypeDeclaration n, A argu); | ||
72 | |||
73 | /** | ||
74 | * <PRE> | ||
75 | * f0 -> StructOrUnionSpecifier() | ||
76 | * f1 -> <IDENTIFIER> | ||
77 | * </PRE> | ||
78 | */ | ||
79 | public void visit(DataType n, A argu); | ||
80 | |||
81 | /** | ||
82 | * <PRE> | ||
83 | * f0 -> TypeSpecifier() | ||
84 | * f1 -> "(" | ||
85 | * f2 -> "*" | ||
86 | * f3 -> <IDENTIFIER> | ||
87 | * f4 -> ")" | ||
88 | * f5 -> "(" | ||
89 | * f6 -> [ ParameterList() ] | ||
90 | * f7 -> ")" | ||
91 | * </PRE> | ||
92 | */ | ||
93 | public void visit(FunctionType n, A argu); | ||
94 | |||
95 | /** | ||
96 | * <PRE> | ||
97 | * f0 -> ParameterDeclaration() | ||
98 | * f1 -> ( "," ParameterDeclaration() )* | ||
99 | * f2 -> [ "," "..." ] | ||
100 | * </PRE> | ||
101 | */ | ||
102 | public void visit(ParameterList n, A argu); | ||
103 | |||
104 | /** | ||
105 | * <PRE> | ||
106 | * f0 -> TypeSpecifier() | ||
107 | * f1 -> <IDENTIFIER> | ||
108 | * f2 -> [ Array() ] | ||
109 | * </PRE> | ||
110 | */ | ||
111 | public void visit(ParameterDeclaration n, A argu); | ||
112 | |||
113 | /** | ||
114 | * <PRE> | ||
115 | * f0 -> VariableClassSpecifier() | ||
116 | * f1 -> TypeSpecifier() | ||
117 | * f2 -> InitDeclaratorList() | ||
118 | * f3 -> ";" | ||
119 | * </PRE> | ||
120 | */ | ||
121 | public void visit(VariableDeclaration n, A argu); | ||
122 | |||
123 | /** | ||
124 | * <PRE> | ||
125 | * f0 -> [ <STATIC> ] | ||
126 | * f1 -> VariableDeclaration() | ||
127 | * </PRE> | ||
128 | */ | ||
129 | public void visit(LocalVariableDeclaration n, A argu); | ||
130 | |||
131 | /** | ||
132 | * <PRE> | ||
133 | * f0 -> ( <AUTO> | <REGISTER> )* | ||
134 | * </PRE> | ||
135 | */ | ||
136 | public void visit(VariableClassSpecifier n, A argu); | ||
137 | |||
138 | /** | ||
139 | * <PRE> | ||
140 | * f0 -> [ <CONST> ] | ||
141 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> ) | ||
142 | * f2 -> [ Pointer() ] | ||
143 | * f3 -> [ Array() ] | ||
144 | * </PRE> | ||
145 | */ | ||
146 | public void visit(TypeSpecifier n, A argu); | ||
147 | |||
148 | /** | ||
149 | * <PRE> | ||
150 | * f0 -> [ <CONST> ] | ||
151 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() ) | ||
152 | * f2 -> [ Pointer() ] | ||
153 | * f3 -> [ Array() ] | ||
154 | * </PRE> | ||
155 | */ | ||
156 | public void visit(NoIdentifierTypeSpecifier n, A argu); | ||
157 | |||
158 | /** | ||
159 | * <PRE> | ||
160 | * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}" | ||
161 | * | StructOrUnion() <IDENTIFIER> | ||
162 | * </PRE> | ||
163 | */ | ||
164 | public void visit(StructOrUnionSpecifier n, A argu); | ||
165 | |||
166 | /** | ||
167 | * <PRE> | ||
168 | * f0 -> ( <STRUCT> | <UNION> ) | ||
169 | * </PRE> | ||
170 | */ | ||
171 | public void visit(StructOrUnion n, A argu); | ||
172 | |||
173 | /** | ||
174 | * <PRE> | ||
175 | * f0 -> ( StructDeclaration() )+ | ||
176 | * </PRE> | ||
177 | */ | ||
178 | public void visit(StructDeclarationList n, A argu); | ||
179 | |||
180 | /** | ||
181 | * <PRE> | ||
182 | * f0 -> InitDeclarator() | ||
183 | * f1 -> ( "," InitDeclarator() )* | ||
184 | * </PRE> | ||
185 | */ | ||
186 | public void visit(InitDeclaratorList n, A argu); | ||
187 | |||
188 | /** | ||
189 | * <PRE> | ||
190 | * f0 -> <IDENTIFIER> | ||
191 | * f1 -> [ Array() ] | ||
192 | * f2 -> [ "=" Initializer() ] | ||
193 | * </PRE> | ||
194 | */ | ||
195 | public void visit(InitDeclarator n, A argu); | ||
196 | |||
197 | /** | ||
198 | * <PRE> | ||
199 | * f0 -> TypeSpecifier() | ||
200 | * f1 -> <IDENTIFIER> | ||
201 | * f2 -> [ Array() | ":" ConstantExpression() ] | ||
202 | * f3 -> [ <IDENTIFIER> ] | ||
203 | * f4 -> ";" | ||
204 | * </PRE> | ||
205 | */ | ||
206 | public void visit(StructDeclaration n, A argu); | ||
207 | |||
208 | /** | ||
209 | * <PRE> | ||
210 | * f0 -> <ENUM> | ||
211 | * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> ) | ||
212 | * </PRE> | ||
213 | */ | ||
214 | public void visit(EnumSpecifier n, A argu); | ||
215 | |||
216 | /** | ||
217 | * <PRE> | ||
218 | * f0 -> Enumerator() | ||
219 | * f1 -> ( "," Enumerator() )* | ||
220 | * </PRE> | ||
221 | */ | ||
222 | public void visit(EnumeratorList n, A argu); | ||
223 | |||
224 | /** | ||
225 | * <PRE> | ||
226 | * f0 -> <IDENTIFIER> | ||
227 | * f1 -> [ "=" ConstantExpression() ] | ||
228 | * </PRE> | ||
229 | */ | ||
230 | public void visit(Enumerator n, A argu); | ||
231 | |||
232 | /** | ||
233 | * <PRE> | ||
234 | * f0 -> "*" | ||
235 | * f1 -> [ <CONST> ] | ||
236 | * f2 -> [ Pointer() ] | ||
237 | * </PRE> | ||
238 | */ | ||
239 | public void visit(Pointer n, A argu); | ||
240 | |||
241 | /** | ||
242 | * <PRE> | ||
243 | * f0 -> <IDENTIFIER> | ||
244 | * f1 -> ( "," <IDENTIFIER> )* | ||
245 | * </PRE> | ||
246 | */ | ||
247 | public void visit(IdentifierList n, A argu); | ||
248 | |||
249 | /** | ||
250 | * <PRE> | ||
251 | * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" ) | ||
252 | * </PRE> | ||
253 | */ | ||
254 | public void visit(Initializer n, A argu); | ||
255 | |||
256 | /** | ||
257 | * <PRE> | ||
258 | * f0 -> Initializer() | ||
259 | * f1 -> ( "," Initializer() )* | ||
260 | * </PRE> | ||
261 | */ | ||
262 | public void visit(InitializerList n, A argu); | ||
263 | |||
264 | /** | ||
265 | * <PRE> | ||
266 | * f0 -> "[" | ||
267 | * f1 -> [ ConstantExpression() ] | ||
268 | * f2 -> "]" | ||
269 | * </PRE> | ||
270 | */ | ||
271 | public void visit(Array n, A argu); | ||
272 | |||
273 | /** | ||
274 | * <PRE> | ||
275 | * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() ) | ||
276 | * </PRE> | ||
277 | */ | ||
278 | public void visit(Statement n, A argu); | ||
279 | |||
280 | /** | ||
281 | * <PRE> | ||
282 | * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() ) | ||
283 | * </PRE> | ||
284 | */ | ||
285 | public void visit(LabeledStatement n, A argu); | ||
286 | |||
287 | /** | ||
288 | * <PRE> | ||
289 | * f0 -> [ Expression() ] | ||
290 | * f1 -> ";" | ||
291 | * </PRE> | ||
292 | */ | ||
293 | public void visit(ExpressionStatement n, A argu); | ||
294 | |||
295 | /** | ||
296 | * <PRE> | ||
297 | * f0 -> "{" | ||
298 | * f1 -> ( LocalVariableDeclaration() | Statement() )* | ||
299 | * f2 -> "}" | ||
300 | * </PRE> | ||
301 | */ | ||
302 | public void visit(CompoundStatement n, A argu); | ||
303 | |||
304 | /** | ||
305 | * <PRE> | ||
306 | * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() ) | ||
307 | * </PRE> | ||
308 | */ | ||
309 | public void visit(SelectionStatement n, A argu); | ||
310 | |||
311 | /** | ||
312 | * <PRE> | ||
313 | * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() ) | ||
314 | * </PRE> | ||
315 | */ | ||
316 | public void visit(IterationStatement n, A argu); | ||
317 | |||
318 | /** | ||
319 | * <PRE> | ||
320 | * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" ) | ||
321 | * </PRE> | ||
322 | */ | ||
323 | public void visit(JumpStatement n, A argu); | ||
324 | |||
325 | /** | ||
326 | * <PRE> | ||
327 | * f0 -> AssignmentExpression() | ||
328 | * f1 -> ( "," AssignmentExpression() )* | ||
329 | * </PRE> | ||
330 | */ | ||
331 | public void visit(Expression n, A argu); | ||
332 | |||
333 | /** | ||
334 | * <PRE> | ||
335 | * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression() | ||
336 | * | ConditionalExpression() | ||
337 | * </PRE> | ||
338 | */ | ||
339 | public void visit(AssignmentExpression n, A argu); | ||
340 | |||
341 | /** | ||
342 | * <PRE> | ||
343 | * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" ) | ||
344 | * </PRE> | ||
345 | */ | ||
346 | public void visit(AssignmentOperator n, A argu); | ||
347 | |||
348 | /** | ||
349 | * <PRE> | ||
350 | * f0 -> LogicalORExpression() | ||
351 | * f1 -> [ "?" Expression() ":" ConditionalExpression() ] | ||
352 | * </PRE> | ||
353 | */ | ||
354 | public void visit(ConditionalExpression n, A argu); | ||
355 | |||
356 | /** | ||
357 | * <PRE> | ||
358 | * f0 -> ConditionalExpression() | ||
359 | * </PRE> | ||
360 | */ | ||
361 | public void visit(ConstantExpression n, A argu); | ||
362 | |||
363 | /** | ||
364 | * <PRE> | ||
365 | * f0 -> LogicalANDExpression() | ||
366 | * f1 -> [ "||" LogicalORExpression() ] | ||
367 | * </PRE> | ||
368 | */ | ||
369 | public void visit(LogicalORExpression n, A argu); | ||
370 | |||
371 | /** | ||
372 | * <PRE> | ||
373 | * f0 -> InclusiveORExpression() | ||
374 | * f1 -> [ "&&" LogicalANDExpression() ] | ||
375 | * </PRE> | ||
376 | */ | ||
377 | public void visit(LogicalANDExpression n, A argu); | ||
378 | |||
379 | /** | ||
380 | * <PRE> | ||
381 | * f0 -> ExclusiveORExpression() | ||
382 | * f1 -> [ "|" InclusiveORExpression() ] | ||
383 | * </PRE> | ||
384 | */ | ||
385 | public void visit(InclusiveORExpression n, A argu); | ||
386 | |||
387 | /** | ||
388 | * <PRE> | ||
389 | * f0 -> ANDExpression() | ||
390 | * f1 -> [ "^" ExclusiveORExpression() ] | ||
391 | * </PRE> | ||
392 | */ | ||
393 | public void visit(ExclusiveORExpression n, A argu); | ||
394 | |||
395 | /** | ||
396 | * <PRE> | ||
397 | * f0 -> EqualityExpression() | ||
398 | * f1 -> [ "&" ANDExpression() ] | ||
399 | * </PRE> | ||
400 | */ | ||
401 | public void visit(ANDExpression n, A argu); | ||
402 | |||
403 | /** | ||
404 | * <PRE> | ||
405 | * f0 -> RelationalExpression() | ||
406 | * f1 -> [ ( "==" | "!=" ) EqualityExpression() ] | ||
407 | * </PRE> | ||
408 | */ | ||
409 | public void visit(EqualityExpression n, A argu); | ||
410 | |||
411 | /** | ||
412 | * <PRE> | ||
413 | * f0 -> ShiftExpression() | ||
414 | * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ] | ||
415 | * </PRE> | ||
416 | */ | ||
417 | public void visit(RelationalExpression n, A argu); | ||
418 | |||
419 | /** | ||
420 | * <PRE> | ||
421 | * f0 -> AdditiveExpression() | ||
422 | * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ] | ||
423 | * </PRE> | ||
424 | */ | ||
425 | public void visit(ShiftExpression n, A argu); | ||
426 | |||
427 | /** | ||
428 | * <PRE> | ||
429 | * f0 -> MultiplicativeExpression() | ||
430 | * f1 -> [ ( "+" | "-" ) AdditiveExpression() ] | ||
431 | * </PRE> | ||
432 | */ | ||
433 | public void visit(AdditiveExpression n, A argu); | ||
434 | |||
435 | /** | ||
436 | * <PRE> | ||
437 | * f0 -> CastExpression() | ||
438 | * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ] | ||
439 | * </PRE> | ||
440 | */ | ||
441 | public void visit(MultiplicativeExpression n, A argu); | ||
442 | |||
443 | /** | ||
444 | * <PRE> | ||
445 | * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() ) | ||
446 | * </PRE> | ||
447 | */ | ||
448 | public void visit(CastExpression n, A argu); | ||
449 | |||
450 | /** | ||
451 | * <PRE> | ||
452 | * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) ) | ||
453 | * </PRE> | ||
454 | */ | ||
455 | public void visit(UnaryExpression n, A argu); | ||
456 | |||
457 | /** | ||
458 | * <PRE> | ||
459 | * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" ) | ||
460 | * </PRE> | ||
461 | */ | ||
462 | public void visit(UnaryOperator n, A argu); | ||
463 | |||
464 | /** | ||
465 | * <PRE> | ||
466 | * f0 -> PrimaryExpression() | ||
467 | * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )* | ||
468 | * </PRE> | ||
469 | */ | ||
470 | public void visit(PostfixExpression n, A argu); | ||
471 | |||
472 | /** | ||
473 | * <PRE> | ||
474 | * f0 -> <IDENTIFIER> | ||
475 | * | Constant() | ||
476 | * | "(" Expression() ")" | ||
477 | * </PRE> | ||
478 | */ | ||
479 | public void visit(PrimaryExpression n, A argu); | ||
480 | |||
481 | /** | ||
482 | * <PRE> | ||
483 | * f0 -> AssignmentOrTypeExpression() | ||
484 | * f1 -> ( "," AssignmentOrTypeExpression() )* | ||
485 | * </PRE> | ||
486 | */ | ||
487 | public void visit(ArgumentExpressionList n, A argu); | ||
488 | |||
489 | /** | ||
490 | * <PRE> | ||
491 | * f0 -> NoIdentifierTypeSpecifier() | ||
492 | * | AssignmentExpression() | ||
493 | * </PRE> | ||
494 | */ | ||
495 | public void visit(AssignmentOrTypeExpression n, A argu); | ||
496 | |||
497 | /** | ||
498 | * <PRE> | ||
499 | * f0 -> <INTEGER_LITERAL> | ||
500 | * | <FLOATING_POINT_LITERAL> | ||
501 | * | <CHARACTER_LITERAL> | ||
502 | * | <STRING_LITERAL> | ||
503 | * </PRE> | ||
504 | */ | ||
505 | public void visit(Constant n, A argu); | ||
506 | |||
507 | } | ||
508 | |||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/TreeDumper.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/TreeDumper.java new file mode 100644 index 000000000..c2e7c1558 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/TreeDumper.java | |||
@@ -0,0 +1,132 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | package org.gnunet.seaspider.parser.visitors; | ||
5 | |||
6 | import org.gnunet.seaspider.parser.nodes.*; | ||
7 | |||
8 | import java.util.*; | ||
9 | import java.io.*; | ||
10 | |||
11 | /** | ||
12 | * Dumps the syntax tree to a Writer using the location information in | ||
13 | * each NodeToken. | ||
14 | */ | ||
15 | public class TreeDumper extends DepthFirstVisitor { | ||
16 | protected PrintWriter out; | ||
17 | private int curLine = 1; | ||
18 | private int curColumn = 1; | ||
19 | private boolean startAtNextToken = false; | ||
20 | private boolean printSpecials = true; | ||
21 | |||
22 | /** | ||
23 | * The default constructor uses System.out as its output location. | ||
24 | * You may specify your own Writer or OutputStream using one of the | ||
25 | * other constructors. | ||
26 | */ | ||
27 | public TreeDumper() { out = new PrintWriter(System.out, true); } | ||
28 | public TreeDumper(Writer o) { out = new PrintWriter(o, true); } | ||
29 | public TreeDumper(OutputStream o) { out = new PrintWriter(o, true); } | ||
30 | |||
31 | /** | ||
32 | * Flushes the OutputStream or Writer that this TreeDumper is using. | ||
33 | */ | ||
34 | public void flushWriter() { out.flush(); } | ||
35 | |||
36 | /** | ||
37 | * Allows you to specify whether or not to print special tokens. | ||
38 | */ | ||
39 | public void printSpecials(boolean b) { printSpecials = b; } | ||
40 | |||
41 | /** | ||
42 | * Starts the tree dumper on the line containing the next token | ||
43 | * visited. For example, if the next token begins on line 50 and the | ||
44 | * dumper is currently on line 1 of the file, it will set its current | ||
45 | * line to 50 and continue printing from there, as opposed to | ||
46 | * printing 49 blank lines and then printing the token. | ||
47 | */ | ||
48 | public void startAtNextToken() { startAtNextToken = true; } | ||
49 | |||
50 | /** | ||
51 | * Resets the position of the output "cursor" to the first line and | ||
52 | * column. When using a dumper on a syntax tree more than once, you | ||
53 | * either need to call this method or startAtNextToken() between each | ||
54 | * dump. | ||
55 | */ | ||
56 | public void resetPosition() { curLine = curColumn = 1; } | ||
57 | |||
58 | /** | ||
59 | * Dumps the current NodeToken to the output stream being used. | ||
60 | * | ||
61 | * @throws IllegalStateException if the token position is invalid | ||
62 | * relative to the current position, i.e. its location places it | ||
63 | * before the previous token. | ||
64 | */ | ||
65 | public void visit(NodeToken n) { | ||
66 | if ( n.beginLine == -1 || n.beginColumn == -1 ) { | ||
67 | printToken(n.tokenImage); | ||
68 | return; | ||
69 | } | ||
70 | |||
71 | // | ||
72 | // Handle special tokens | ||
73 | // | ||
74 | if ( printSpecials && n.numSpecials() > 0 ) | ||
75 | for ( Enumeration<NodeToken> e = n.specialTokens.elements(); e.hasMoreElements(); ) | ||
76 | visit(e.nextElement()); | ||
77 | |||
78 | // | ||
79 | // Handle startAtNextToken option | ||
80 | // | ||
81 | if ( startAtNextToken ) { | ||
82 | curLine = n.beginLine; | ||
83 | curColumn = 1; | ||
84 | startAtNextToken = false; | ||
85 | |||
86 | if ( n.beginColumn < curColumn ) | ||
87 | out.println(); | ||
88 | } | ||
89 | |||
90 | // | ||
91 | // Check for invalid token position relative to current position. | ||
92 | // | ||
93 | if ( n.beginLine < curLine ) | ||
94 | throw new IllegalStateException("at token \"" + n.tokenImage + | ||
95 | "\", n.beginLine = " + Integer.toString(n.beginLine) + | ||
96 | ", curLine = " + Integer.toString(curLine)); | ||
97 | else if ( n.beginLine == curLine && n.beginColumn < curColumn ) | ||
98 | throw new IllegalStateException("at token \"" + n.tokenImage + | ||
99 | "\", n.beginColumn = " + | ||
100 | Integer.toString(n.beginColumn) + ", curColumn = " + | ||
101 | Integer.toString(curColumn)); | ||
102 | |||
103 | // | ||
104 | // Move output "cursor" to proper location, then print the token | ||
105 | // | ||
106 | if ( curLine < n.beginLine ) { | ||
107 | curColumn = 1; | ||
108 | for ( ; curLine < n.beginLine; ++curLine ) | ||
109 | out.println(); | ||
110 | } | ||
111 | |||
112 | for ( ; curColumn < n.beginColumn; ++curColumn ) | ||
113 | out.print(" "); | ||
114 | |||
115 | printToken(n.tokenImage); | ||
116 | } | ||
117 | |||
118 | private void printToken(String s) { | ||
119 | for ( int i = 0; i < s.length(); ++i ) { | ||
120 | if ( s.charAt(i) == '\n' ) { | ||
121 | ++curLine; | ||
122 | curColumn = 1; | ||
123 | } | ||
124 | else | ||
125 | curColumn++; | ||
126 | |||
127 | out.print(s.charAt(i)); | ||
128 | } | ||
129 | |||
130 | out.flush(); | ||
131 | } | ||
132 | } | ||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/TreeFormatter.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/TreeFormatter.java new file mode 100644 index 000000000..7cb5ae051 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/TreeFormatter.java | |||
@@ -0,0 +1,980 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | package org.gnunet.seaspider.parser.visitors; | ||
5 | |||
6 | import org.gnunet.seaspider.parser.nodes.*; | ||
7 | |||
8 | import java.util.*; | ||
9 | |||
10 | /** | ||
11 | * A skeleton output formatter for your language grammar. Using the | ||
12 | * add() method along with force(), indent(), and outdent(), you can | ||
13 | * easily specify how this visitor will format the given syntax tree. | ||
14 | * See the JTB documentation for more details. | ||
15 | * | ||
16 | * Pass your syntax tree to this visitor, and then to the TreeDumper | ||
17 | * visitor in order to "pretty print" your tree. | ||
18 | */ | ||
19 | public class TreeFormatter extends DepthFirstVisitor { | ||
20 | private Vector<FormatCommand> cmdQueue = new Vector<FormatCommand>(); | ||
21 | private boolean lineWrap; | ||
22 | private int wrapWidth; | ||
23 | private int indentAmt; | ||
24 | private int curLine = 1; | ||
25 | private int curColumn = 1; | ||
26 | private int curIndent = 0; | ||
27 | |||
28 | /** | ||
29 | * The default constructor assumes an indentation amount of 3 spaces | ||
30 | * and no line-wrap. You may alternately use the other constructor to | ||
31 | * specify your own indentation amount and line width. | ||
32 | */ | ||
33 | public TreeFormatter() { this(3, 0); } | ||
34 | |||
35 | /** | ||
36 | * This constructor accepts an indent amount and a line width which is | ||
37 | * used to wrap long lines. If a token's beginColumn value is greater | ||
38 | * than the specified wrapWidth, it will be moved to the next line and | ||
39 | * indented one extra level. To turn off line-wrapping, specify a | ||
40 | * wrapWidth of 0. | ||
41 | * | ||
42 | * @param indentAmt Amount of spaces per indentation level. | ||
43 | * @param wrapWidth Wrap lines longer than wrapWidth. 0 for no wrap. | ||
44 | */ | ||
45 | public TreeFormatter(int indentAmt, int wrapWidth) { | ||
46 | this.indentAmt = indentAmt; | ||
47 | this.wrapWidth = wrapWidth; | ||
48 | |||
49 | if ( wrapWidth > 0 ) | ||
50 | lineWrap = true; | ||
51 | else | ||
52 | lineWrap = false; | ||
53 | } | ||
54 | |||
55 | /** | ||
56 | * Accepts a NodeListInterface object and performs an optional format | ||
57 | * command between each node in the list (but not after the last node). | ||
58 | */ | ||
59 | protected void processList(NodeListInterface n) { | ||
60 | processList(n, null); | ||
61 | } | ||
62 | |||
63 | protected void processList(NodeListInterface n, FormatCommand cmd) { | ||
64 | for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) { | ||
65 | e.nextElement().accept(this); | ||
66 | if ( cmd != null && e.hasMoreElements() ) | ||
67 | cmdQueue.addElement(cmd); | ||
68 | } | ||
69 | } | ||
70 | |||
71 | /** | ||
72 | * A Force command inserts a line break and indents the next line to | ||
73 | * the current indentation level. Use "add(force());". | ||
74 | */ | ||
75 | protected FormatCommand force() { return force(1); } | ||
76 | protected FormatCommand force(int i) { | ||
77 | return new FormatCommand(FormatCommand.FORCE, i); | ||
78 | } | ||
79 | |||
80 | /** | ||
81 | * An Indent command increases the indentation level by one (or a | ||
82 | * user-specified amount). Use "add(indent());". | ||
83 | */ | ||
84 | protected FormatCommand indent() { return indent(1); } | ||
85 | protected FormatCommand indent(int i) { | ||
86 | return new FormatCommand(FormatCommand.INDENT, i); | ||
87 | } | ||
88 | |||
89 | /** | ||
90 | * An Outdent command is the reverse of the Indent command: it reduces | ||
91 | * the indentation level. Use "add(outdent());". | ||
92 | */ | ||
93 | protected FormatCommand outdent() { return outdent(1); } | ||
94 | protected FormatCommand outdent(int i) { | ||
95 | return new FormatCommand(FormatCommand.OUTDENT, i); | ||
96 | } | ||
97 | |||
98 | /** | ||
99 | * A Space command simply adds one or a user-specified number of | ||
100 | * spaces between tokens. Use "add(space());". | ||
101 | */ | ||
102 | protected FormatCommand space() { return space(1); } | ||
103 | protected FormatCommand space(int i) { | ||
104 | return new FormatCommand(FormatCommand.SPACE, i); | ||
105 | } | ||
106 | |||
107 | /** | ||
108 | * Use this method to add FormatCommands to the command queue to be | ||
109 | * executed when the next token in the tree is visited. | ||
110 | */ | ||
111 | protected void add(FormatCommand cmd) { | ||
112 | cmdQueue.addElement(cmd); | ||
113 | } | ||
114 | |||
115 | /** | ||
116 | * Executes the commands waiting in the command queue, then inserts the | ||
117 | * proper location information into the current NodeToken. | ||
118 | * | ||
119 | * If there are any special tokens preceding this token, they will be | ||
120 | * given the current location information. The token will follow on | ||
121 | * the next line, at the proper indentation level. If this is not the | ||
122 | * behavior you want from special tokens, feel free to modify this | ||
123 | * method. | ||
124 | */ | ||
125 | public void visit(NodeToken n) { | ||
126 | for ( Enumeration<FormatCommand> e = cmdQueue.elements(); e.hasMoreElements(); ) { | ||
127 | FormatCommand cmd = e.nextElement(); | ||
128 | switch ( cmd.getCommand() ) { | ||
129 | case FormatCommand.FORCE : | ||
130 | curLine += cmd.getNumCommands(); | ||
131 | curColumn = curIndent + 1; | ||
132 | break; | ||
133 | case FormatCommand.INDENT : | ||
134 | curIndent += indentAmt * cmd.getNumCommands(); | ||
135 | break; | ||
136 | case FormatCommand.OUTDENT : | ||
137 | if ( curIndent >= indentAmt ) | ||
138 | curIndent -= indentAmt * cmd.getNumCommands(); | ||
139 | break; | ||
140 | case FormatCommand.SPACE : | ||
141 | curColumn += cmd.getNumCommands(); | ||
142 | break; | ||
143 | default : | ||
144 | throw new TreeFormatterException( | ||
145 | "Invalid value in command queue."); | ||
146 | } | ||
147 | } | ||
148 | |||
149 | cmdQueue.removeAllElements(); | ||
150 | |||
151 | // | ||
152 | // Handle all special tokens preceding this NodeToken | ||
153 | // | ||
154 | if ( n.numSpecials() > 0 ) | ||
155 | for ( Enumeration<NodeToken> e = n.specialTokens.elements(); | ||
156 | e.hasMoreElements(); ) { | ||
157 | NodeToken special = e.nextElement(); | ||
158 | |||
159 | // | ||
160 | // -Place the token. | ||
161 | // -Move cursor to next line after the special token. | ||
162 | // -Don't update curColumn--want to keep current indent level. | ||
163 | // | ||
164 | placeToken(special, curLine, curColumn); | ||
165 | curLine = special.endLine + 1; | ||
166 | } | ||
167 | |||
168 | placeToken(n, curLine, curColumn); | ||
169 | curLine = n.endLine; | ||
170 | curColumn = n.endColumn; | ||
171 | } | ||
172 | |||
173 | /** | ||
174 | * Inserts token location (beginLine, beginColumn, endLine, endColumn) | ||
175 | * information into the NodeToken. Takes into account line-wrap. | ||
176 | * Does not update curLine and curColumn. | ||
177 | */ | ||
178 | private void placeToken(NodeToken n, int line, int column) { | ||
179 | int length = n.tokenImage.length(); | ||
180 | |||
181 | // | ||
182 | // Find beginning of token. Only line-wrap for single-line tokens | ||
183 | // | ||
184 | if ( !lineWrap || n.tokenImage.indexOf('\n') != -1 || | ||
185 | column + length <= wrapWidth ) | ||
186 | n.beginColumn = column; | ||
187 | else { | ||
188 | ++line; | ||
189 | column = curIndent + indentAmt + 1; | ||
190 | n.beginColumn = column; | ||
191 | } | ||
192 | |||
193 | n.beginLine = line; | ||
194 | |||
195 | // | ||
196 | // Find end of token; don't count \n if it's the last character | ||
197 | // | ||
198 | for ( int i = 0; i < length; ++i ) { | ||
199 | if ( n.tokenImage.charAt(i) == '\n' && i < length - 1 ) { | ||
200 | ++line; | ||
201 | column = 1; | ||
202 | } | ||
203 | else | ||
204 | ++column; | ||
205 | } | ||
206 | |||
207 | n.endLine = line; | ||
208 | n.endColumn = column; | ||
209 | } | ||
210 | |||
211 | // | ||
212 | // User-generated visitor methods below | ||
213 | // | ||
214 | |||
215 | /** | ||
216 | * <PRE> | ||
217 | * f0 -> ( ExternalDeclaration() )+ | ||
218 | * </PRE> | ||
219 | */ | ||
220 | public void visit(TranslationUnit n) { | ||
221 | processList(n.f0); | ||
222 | } | ||
223 | |||
224 | /** | ||
225 | * <PRE> | ||
226 | * f0 -> ( StorageClassSpecifier() )* | ||
227 | * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() ) | ||
228 | * </PRE> | ||
229 | */ | ||
230 | public void visit(ExternalDeclaration n) { | ||
231 | if ( n.f0.present() ) { | ||
232 | processList(n.f0); | ||
233 | } | ||
234 | n.f1.accept(this); | ||
235 | } | ||
236 | |||
237 | /** | ||
238 | * <PRE> | ||
239 | * f0 -> TypeSpecifier() | ||
240 | * f1 -> <IDENTIFIER> | ||
241 | * f2 -> "(" | ||
242 | * f3 -> [ ParameterList() ] | ||
243 | * f4 -> ")" | ||
244 | * f5 -> ( ";" | CompoundStatement() ) | ||
245 | * </PRE> | ||
246 | */ | ||
247 | public void visit(FunctionDeclaration n) { | ||
248 | n.f0.accept(this); | ||
249 | n.f1.accept(this); | ||
250 | n.f2.accept(this); | ||
251 | if ( n.f3.present() ) { | ||
252 | n.f3.accept(this); | ||
253 | } | ||
254 | n.f4.accept(this); | ||
255 | n.f5.accept(this); | ||
256 | } | ||
257 | |||
258 | /** | ||
259 | * <PRE> | ||
260 | * f0 -> ( <STATIC> | <EXTERN> ) | ||
261 | * </PRE> | ||
262 | */ | ||
263 | public void visit(StorageClassSpecifier n) { | ||
264 | n.f0.accept(this); | ||
265 | } | ||
266 | |||
267 | /** | ||
268 | * <PRE> | ||
269 | * f0 -> <TYPEDEF> | ||
270 | * f1 -> ( DataType() | FunctionType() ) | ||
271 | * f2 -> ";" | ||
272 | * </PRE> | ||
273 | */ | ||
274 | public void visit(TypeDeclaration n) { | ||
275 | n.f0.accept(this); | ||
276 | n.f1.accept(this); | ||
277 | n.f2.accept(this); | ||
278 | } | ||
279 | |||
280 | /** | ||
281 | * <PRE> | ||
282 | * f0 -> StructOrUnionSpecifier() | ||
283 | * f1 -> <IDENTIFIER> | ||
284 | * </PRE> | ||
285 | */ | ||
286 | public void visit(DataType n) { | ||
287 | n.f0.accept(this); | ||
288 | n.f1.accept(this); | ||
289 | } | ||
290 | |||
291 | /** | ||
292 | * <PRE> | ||
293 | * f0 -> TypeSpecifier() | ||
294 | * f1 -> "(" | ||
295 | * f2 -> "*" | ||
296 | * f3 -> <IDENTIFIER> | ||
297 | * f4 -> ")" | ||
298 | * f5 -> "(" | ||
299 | * f6 -> [ ParameterList() ] | ||
300 | * f7 -> ")" | ||
301 | * </PRE> | ||
302 | */ | ||
303 | public void visit(FunctionType n) { | ||
304 | n.f0.accept(this); | ||
305 | n.f1.accept(this); | ||
306 | n.f2.accept(this); | ||
307 | n.f3.accept(this); | ||
308 | n.f4.accept(this); | ||
309 | n.f5.accept(this); | ||
310 | if ( n.f6.present() ) { | ||
311 | n.f6.accept(this); | ||
312 | } | ||
313 | n.f7.accept(this); | ||
314 | } | ||
315 | |||
316 | /** | ||
317 | * <PRE> | ||
318 | * f0 -> ParameterDeclaration() | ||
319 | * f1 -> ( "," ParameterDeclaration() )* | ||
320 | * f2 -> [ "," "..." ] | ||
321 | * </PRE> | ||
322 | */ | ||
323 | public void visit(ParameterList n) { | ||
324 | n.f0.accept(this); | ||
325 | if ( n.f1.present() ) { | ||
326 | processList(n.f1); | ||
327 | } | ||
328 | if ( n.f2.present() ) { | ||
329 | n.f2.accept(this); | ||
330 | } | ||
331 | } | ||
332 | |||
333 | /** | ||
334 | * <PRE> | ||
335 | * f0 -> TypeSpecifier() | ||
336 | * f1 -> <IDENTIFIER> | ||
337 | * f2 -> [ Array() ] | ||
338 | * </PRE> | ||
339 | */ | ||
340 | public void visit(ParameterDeclaration n) { | ||
341 | n.f0.accept(this); | ||
342 | n.f1.accept(this); | ||
343 | if ( n.f2.present() ) { | ||
344 | n.f2.accept(this); | ||
345 | } | ||
346 | } | ||
347 | |||
348 | /** | ||
349 | * <PRE> | ||
350 | * f0 -> VariableClassSpecifier() | ||
351 | * f1 -> TypeSpecifier() | ||
352 | * f2 -> InitDeclaratorList() | ||
353 | * f3 -> ";" | ||
354 | * </PRE> | ||
355 | */ | ||
356 | public void visit(VariableDeclaration n) { | ||
357 | n.f0.accept(this); | ||
358 | n.f1.accept(this); | ||
359 | n.f2.accept(this); | ||
360 | n.f3.accept(this); | ||
361 | } | ||
362 | |||
363 | /** | ||
364 | * <PRE> | ||
365 | * f0 -> [ <STATIC> ] | ||
366 | * f1 -> VariableDeclaration() | ||
367 | * </PRE> | ||
368 | */ | ||
369 | public void visit(LocalVariableDeclaration n) { | ||
370 | if ( n.f0.present() ) { | ||
371 | n.f0.accept(this); | ||
372 | } | ||
373 | n.f1.accept(this); | ||
374 | } | ||
375 | |||
376 | /** | ||
377 | * <PRE> | ||
378 | * f0 -> ( <AUTO> | <REGISTER> )* | ||
379 | * </PRE> | ||
380 | */ | ||
381 | public void visit(VariableClassSpecifier n) { | ||
382 | if ( n.f0.present() ) { | ||
383 | processList(n.f0); | ||
384 | } | ||
385 | } | ||
386 | |||
387 | /** | ||
388 | * <PRE> | ||
389 | * f0 -> [ <CONST> ] | ||
390 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> ) | ||
391 | * f2 -> [ Pointer() ] | ||
392 | * f3 -> [ Array() ] | ||
393 | * </PRE> | ||
394 | */ | ||
395 | public void visit(TypeSpecifier n) { | ||
396 | if ( n.f0.present() ) { | ||
397 | n.f0.accept(this); | ||
398 | } | ||
399 | n.f1.accept(this); | ||
400 | if ( n.f2.present() ) { | ||
401 | n.f2.accept(this); | ||
402 | } | ||
403 | if ( n.f3.present() ) { | ||
404 | n.f3.accept(this); | ||
405 | } | ||
406 | } | ||
407 | |||
408 | /** | ||
409 | * <PRE> | ||
410 | * f0 -> [ <CONST> ] | ||
411 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() ) | ||
412 | * f2 -> [ Pointer() ] | ||
413 | * f3 -> [ Array() ] | ||
414 | * </PRE> | ||
415 | */ | ||
416 | public void visit(NoIdentifierTypeSpecifier n) { | ||
417 | if ( n.f0.present() ) { | ||
418 | n.f0.accept(this); | ||
419 | } | ||
420 | n.f1.accept(this); | ||
421 | if ( n.f2.present() ) { | ||
422 | n.f2.accept(this); | ||
423 | } | ||
424 | if ( n.f3.present() ) { | ||
425 | n.f3.accept(this); | ||
426 | } | ||
427 | } | ||
428 | |||
429 | /** | ||
430 | * <PRE> | ||
431 | * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}" | ||
432 | * | StructOrUnion() <IDENTIFIER> | ||
433 | * </PRE> | ||
434 | */ | ||
435 | public void visit(StructOrUnionSpecifier n) { | ||
436 | n.f0.accept(this); | ||
437 | } | ||
438 | |||
439 | /** | ||
440 | * <PRE> | ||
441 | * f0 -> ( <STRUCT> | <UNION> ) | ||
442 | * </PRE> | ||
443 | */ | ||
444 | public void visit(StructOrUnion n) { | ||
445 | n.f0.accept(this); | ||
446 | } | ||
447 | |||
448 | /** | ||
449 | * <PRE> | ||
450 | * f0 -> ( StructDeclaration() )+ | ||
451 | * </PRE> | ||
452 | */ | ||
453 | public void visit(StructDeclarationList n) { | ||
454 | processList(n.f0); | ||
455 | } | ||
456 | |||
457 | /** | ||
458 | * <PRE> | ||
459 | * f0 -> InitDeclarator() | ||
460 | * f1 -> ( "," InitDeclarator() )* | ||
461 | * </PRE> | ||
462 | */ | ||
463 | public void visit(InitDeclaratorList n) { | ||
464 | n.f0.accept(this); | ||
465 | if ( n.f1.present() ) { | ||
466 | processList(n.f1); | ||
467 | } | ||
468 | } | ||
469 | |||
470 | /** | ||
471 | * <PRE> | ||
472 | * f0 -> <IDENTIFIER> | ||
473 | * f1 -> [ Array() ] | ||
474 | * f2 -> [ "=" Initializer() ] | ||
475 | * </PRE> | ||
476 | */ | ||
477 | public void visit(InitDeclarator n) { | ||
478 | n.f0.accept(this); | ||
479 | if ( n.f1.present() ) { | ||
480 | n.f1.accept(this); | ||
481 | } | ||
482 | if ( n.f2.present() ) { | ||
483 | n.f2.accept(this); | ||
484 | } | ||
485 | } | ||
486 | |||
487 | /** | ||
488 | * <PRE> | ||
489 | * f0 -> TypeSpecifier() | ||
490 | * f1 -> <IDENTIFIER> | ||
491 | * f2 -> [ Array() | ":" ConstantExpression() ] | ||
492 | * f3 -> [ <IDENTIFIER> ] | ||
493 | * f4 -> ";" | ||
494 | * </PRE> | ||
495 | */ | ||
496 | public void visit(StructDeclaration n) { | ||
497 | n.f0.accept(this); | ||
498 | n.f1.accept(this); | ||
499 | if ( n.f2.present() ) { | ||
500 | n.f2.accept(this); | ||
501 | } | ||
502 | if ( n.f3.present() ) { | ||
503 | n.f3.accept(this); | ||
504 | } | ||
505 | n.f4.accept(this); | ||
506 | } | ||
507 | |||
508 | /** | ||
509 | * <PRE> | ||
510 | * f0 -> <ENUM> | ||
511 | * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> ) | ||
512 | * </PRE> | ||
513 | */ | ||
514 | public void visit(EnumSpecifier n) { | ||
515 | n.f0.accept(this); | ||
516 | n.f1.accept(this); | ||
517 | } | ||
518 | |||
519 | /** | ||
520 | * <PRE> | ||
521 | * f0 -> Enumerator() | ||
522 | * f1 -> ( "," Enumerator() )* | ||
523 | * </PRE> | ||
524 | */ | ||
525 | public void visit(EnumeratorList n) { | ||
526 | n.f0.accept(this); | ||
527 | if ( n.f1.present() ) { | ||
528 | processList(n.f1); | ||
529 | } | ||
530 | } | ||
531 | |||
532 | /** | ||
533 | * <PRE> | ||
534 | * f0 -> <IDENTIFIER> | ||
535 | * f1 -> [ "=" ConstantExpression() ] | ||
536 | * </PRE> | ||
537 | */ | ||
538 | public void visit(Enumerator n) { | ||
539 | n.f0.accept(this); | ||
540 | if ( n.f1.present() ) { | ||
541 | n.f1.accept(this); | ||
542 | } | ||
543 | } | ||
544 | |||
545 | /** | ||
546 | * <PRE> | ||
547 | * f0 -> "*" | ||
548 | * f1 -> [ <CONST> ] | ||
549 | * f2 -> [ Pointer() ] | ||
550 | * </PRE> | ||
551 | */ | ||
552 | public void visit(Pointer n) { | ||
553 | n.f0.accept(this); | ||
554 | if ( n.f1.present() ) { | ||
555 | n.f1.accept(this); | ||
556 | } | ||
557 | if ( n.f2.present() ) { | ||
558 | n.f2.accept(this); | ||
559 | } | ||
560 | } | ||
561 | |||
562 | /** | ||
563 | * <PRE> | ||
564 | * f0 -> <IDENTIFIER> | ||
565 | * f1 -> ( "," <IDENTIFIER> )* | ||
566 | * </PRE> | ||
567 | */ | ||
568 | public void visit(IdentifierList n) { | ||
569 | n.f0.accept(this); | ||
570 | if ( n.f1.present() ) { | ||
571 | processList(n.f1); | ||
572 | } | ||
573 | } | ||
574 | |||
575 | /** | ||
576 | * <PRE> | ||
577 | * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" ) | ||
578 | * </PRE> | ||
579 | */ | ||
580 | public void visit(Initializer n) { | ||
581 | n.f0.accept(this); | ||
582 | } | ||
583 | |||
584 | /** | ||
585 | * <PRE> | ||
586 | * f0 -> Initializer() | ||
587 | * f1 -> ( "," Initializer() )* | ||
588 | * </PRE> | ||
589 | */ | ||
590 | public void visit(InitializerList n) { | ||
591 | n.f0.accept(this); | ||
592 | if ( n.f1.present() ) { | ||
593 | processList(n.f1); | ||
594 | } | ||
595 | } | ||
596 | |||
597 | /** | ||
598 | * <PRE> | ||
599 | * f0 -> "[" | ||
600 | * f1 -> [ ConstantExpression() ] | ||
601 | * f2 -> "]" | ||
602 | * </PRE> | ||
603 | */ | ||
604 | public void visit(Array n) { | ||
605 | n.f0.accept(this); | ||
606 | if ( n.f1.present() ) { | ||
607 | n.f1.accept(this); | ||
608 | } | ||
609 | n.f2.accept(this); | ||
610 | } | ||
611 | |||
612 | /** | ||
613 | * <PRE> | ||
614 | * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() ) | ||
615 | * </PRE> | ||
616 | */ | ||
617 | public void visit(Statement n) { | ||
618 | n.f0.accept(this); | ||
619 | } | ||
620 | |||
621 | /** | ||
622 | * <PRE> | ||
623 | * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() ) | ||
624 | * </PRE> | ||
625 | */ | ||
626 | public void visit(LabeledStatement n) { | ||
627 | n.f0.accept(this); | ||
628 | } | ||
629 | |||
630 | /** | ||
631 | * <PRE> | ||
632 | * f0 -> [ Expression() ] | ||
633 | * f1 -> ";" | ||
634 | * </PRE> | ||
635 | */ | ||
636 | public void visit(ExpressionStatement n) { | ||
637 | if ( n.f0.present() ) { | ||
638 | n.f0.accept(this); | ||
639 | } | ||
640 | n.f1.accept(this); | ||
641 | } | ||
642 | |||
643 | /** | ||
644 | * <PRE> | ||
645 | * f0 -> "{" | ||
646 | * f1 -> ( LocalVariableDeclaration() | Statement() )* | ||
647 | * f2 -> "}" | ||
648 | * </PRE> | ||
649 | */ | ||
650 | public void visit(CompoundStatement n) { | ||
651 | n.f0.accept(this); | ||
652 | if ( n.f1.present() ) { | ||
653 | processList(n.f1); | ||
654 | } | ||
655 | n.f2.accept(this); | ||
656 | } | ||
657 | |||
658 | /** | ||
659 | * <PRE> | ||
660 | * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() ) | ||
661 | * </PRE> | ||
662 | */ | ||
663 | public void visit(SelectionStatement n) { | ||
664 | n.f0.accept(this); | ||
665 | } | ||
666 | |||
667 | /** | ||
668 | * <PRE> | ||
669 | * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() ) | ||
670 | * </PRE> | ||
671 | */ | ||
672 | public void visit(IterationStatement n) { | ||
673 | n.f0.accept(this); | ||
674 | } | ||
675 | |||
676 | /** | ||
677 | * <PRE> | ||
678 | * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" ) | ||
679 | * </PRE> | ||
680 | */ | ||
681 | public void visit(JumpStatement n) { | ||
682 | n.f0.accept(this); | ||
683 | } | ||
684 | |||
685 | /** | ||
686 | * <PRE> | ||
687 | * f0 -> AssignmentExpression() | ||
688 | * f1 -> ( "," AssignmentExpression() )* | ||
689 | * </PRE> | ||
690 | */ | ||
691 | public void visit(Expression n) { | ||
692 | n.f0.accept(this); | ||
693 | if ( n.f1.present() ) { | ||
694 | processList(n.f1); | ||
695 | } | ||
696 | } | ||
697 | |||
698 | /** | ||
699 | * <PRE> | ||
700 | * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression() | ||
701 | * | ConditionalExpression() | ||
702 | * </PRE> | ||
703 | */ | ||
704 | public void visit(AssignmentExpression n) { | ||
705 | n.f0.accept(this); | ||
706 | } | ||
707 | |||
708 | /** | ||
709 | * <PRE> | ||
710 | * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" ) | ||
711 | * </PRE> | ||
712 | */ | ||
713 | public void visit(AssignmentOperator n) { | ||
714 | n.f0.accept(this); | ||
715 | } | ||
716 | |||
717 | /** | ||
718 | * <PRE> | ||
719 | * f0 -> LogicalORExpression() | ||
720 | * f1 -> [ "?" Expression() ":" ConditionalExpression() ] | ||
721 | * </PRE> | ||
722 | */ | ||
723 | public void visit(ConditionalExpression n) { | ||
724 | n.f0.accept(this); | ||
725 | if ( n.f1.present() ) { | ||
726 | n.f1.accept(this); | ||
727 | } | ||
728 | } | ||
729 | |||
730 | /** | ||
731 | * <PRE> | ||
732 | * f0 -> ConditionalExpression() | ||
733 | * </PRE> | ||
734 | */ | ||
735 | public void visit(ConstantExpression n) { | ||
736 | n.f0.accept(this); | ||
737 | } | ||
738 | |||
739 | /** | ||
740 | * <PRE> | ||
741 | * f0 -> LogicalANDExpression() | ||
742 | * f1 -> [ "||" LogicalORExpression() ] | ||
743 | * </PRE> | ||
744 | */ | ||
745 | public void visit(LogicalORExpression n) { | ||
746 | n.f0.accept(this); | ||
747 | if ( n.f1.present() ) { | ||
748 | n.f1.accept(this); | ||
749 | } | ||
750 | } | ||
751 | |||
752 | /** | ||
753 | * <PRE> | ||
754 | * f0 -> InclusiveORExpression() | ||
755 | * f1 -> [ "&&" LogicalANDExpression() ] | ||
756 | * </PRE> | ||
757 | */ | ||
758 | public void visit(LogicalANDExpression n) { | ||
759 | n.f0.accept(this); | ||
760 | if ( n.f1.present() ) { | ||
761 | n.f1.accept(this); | ||
762 | } | ||
763 | } | ||
764 | |||
765 | /** | ||
766 | * <PRE> | ||
767 | * f0 -> ExclusiveORExpression() | ||
768 | * f1 -> [ "|" InclusiveORExpression() ] | ||
769 | * </PRE> | ||
770 | */ | ||
771 | public void visit(InclusiveORExpression n) { | ||
772 | n.f0.accept(this); | ||
773 | if ( n.f1.present() ) { | ||
774 | n.f1.accept(this); | ||
775 | } | ||
776 | } | ||
777 | |||
778 | /** | ||
779 | * <PRE> | ||
780 | * f0 -> ANDExpression() | ||
781 | * f1 -> [ "^" ExclusiveORExpression() ] | ||
782 | * </PRE> | ||
783 | */ | ||
784 | public void visit(ExclusiveORExpression n) { | ||
785 | n.f0.accept(this); | ||
786 | if ( n.f1.present() ) { | ||
787 | n.f1.accept(this); | ||
788 | } | ||
789 | } | ||
790 | |||
791 | /** | ||
792 | * <PRE> | ||
793 | * f0 -> EqualityExpression() | ||
794 | * f1 -> [ "&" ANDExpression() ] | ||
795 | * </PRE> | ||
796 | */ | ||
797 | public void visit(ANDExpression n) { | ||
798 | n.f0.accept(this); | ||
799 | if ( n.f1.present() ) { | ||
800 | n.f1.accept(this); | ||
801 | } | ||
802 | } | ||
803 | |||
804 | /** | ||
805 | * <PRE> | ||
806 | * f0 -> RelationalExpression() | ||
807 | * f1 -> [ ( "==" | "!=" ) EqualityExpression() ] | ||
808 | * </PRE> | ||
809 | */ | ||
810 | public void visit(EqualityExpression n) { | ||
811 | n.f0.accept(this); | ||
812 | if ( n.f1.present() ) { | ||
813 | n.f1.accept(this); | ||
814 | } | ||
815 | } | ||
816 | |||
817 | /** | ||
818 | * <PRE> | ||
819 | * f0 -> ShiftExpression() | ||
820 | * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ] | ||
821 | * </PRE> | ||
822 | */ | ||
823 | public void visit(RelationalExpression n) { | ||
824 | n.f0.accept(this); | ||
825 | if ( n.f1.present() ) { | ||
826 | n.f1.accept(this); | ||
827 | } | ||
828 | } | ||
829 | |||
830 | /** | ||
831 | * <PRE> | ||
832 | * f0 -> AdditiveExpression() | ||
833 | * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ] | ||
834 | * </PRE> | ||
835 | */ | ||
836 | public void visit(ShiftExpression n) { | ||
837 | n.f0.accept(this); | ||
838 | if ( n.f1.present() ) { | ||
839 | n.f1.accept(this); | ||
840 | } | ||
841 | } | ||
842 | |||
843 | /** | ||
844 | * <PRE> | ||
845 | * f0 -> MultiplicativeExpression() | ||
846 | * f1 -> [ ( "+" | "-" ) AdditiveExpression() ] | ||
847 | * </PRE> | ||
848 | */ | ||
849 | public void visit(AdditiveExpression n) { | ||
850 | n.f0.accept(this); | ||
851 | if ( n.f1.present() ) { | ||
852 | n.f1.accept(this); | ||
853 | } | ||
854 | } | ||
855 | |||
856 | /** | ||
857 | * <PRE> | ||
858 | * f0 -> CastExpression() | ||
859 | * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ] | ||
860 | * </PRE> | ||
861 | */ | ||
862 | public void visit(MultiplicativeExpression n) { | ||
863 | n.f0.accept(this); | ||
864 | if ( n.f1.present() ) { | ||
865 | n.f1.accept(this); | ||
866 | } | ||
867 | } | ||
868 | |||
869 | /** | ||
870 | * <PRE> | ||
871 | * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() ) | ||
872 | * </PRE> | ||
873 | */ | ||
874 | public void visit(CastExpression n) { | ||
875 | n.f0.accept(this); | ||
876 | } | ||
877 | |||
878 | /** | ||
879 | * <PRE> | ||
880 | * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) ) | ||
881 | * </PRE> | ||
882 | */ | ||
883 | public void visit(UnaryExpression n) { | ||
884 | n.f0.accept(this); | ||
885 | } | ||
886 | |||
887 | /** | ||
888 | * <PRE> | ||
889 | * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" ) | ||
890 | * </PRE> | ||
891 | */ | ||
892 | public void visit(UnaryOperator n) { | ||
893 | n.f0.accept(this); | ||
894 | } | ||
895 | |||
896 | /** | ||
897 | * <PRE> | ||
898 | * f0 -> PrimaryExpression() | ||
899 | * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )* | ||
900 | * </PRE> | ||
901 | */ | ||
902 | public void visit(PostfixExpression n) { | ||
903 | n.f0.accept(this); | ||
904 | if ( n.f1.present() ) { | ||
905 | processList(n.f1); | ||
906 | } | ||
907 | } | ||
908 | |||
909 | /** | ||
910 | * <PRE> | ||
911 | * f0 -> <IDENTIFIER> | ||
912 | * | Constant() | ||
913 | * | "(" Expression() ")" | ||
914 | * </PRE> | ||
915 | */ | ||
916 | public void visit(PrimaryExpression n) { | ||
917 | n.f0.accept(this); | ||
918 | } | ||
919 | |||
920 | /** | ||
921 | * <PRE> | ||
922 | * f0 -> AssignmentOrTypeExpression() | ||
923 | * f1 -> ( "," AssignmentOrTypeExpression() )* | ||
924 | * </PRE> | ||
925 | */ | ||
926 | public void visit(ArgumentExpressionList n) { | ||
927 | n.f0.accept(this); | ||
928 | if ( n.f1.present() ) { | ||
929 | processList(n.f1); | ||
930 | } | ||
931 | } | ||
932 | |||
933 | /** | ||
934 | * <PRE> | ||
935 | * f0 -> NoIdentifierTypeSpecifier() | ||
936 | * | AssignmentExpression() | ||
937 | * </PRE> | ||
938 | */ | ||
939 | public void visit(AssignmentOrTypeExpression n) { | ||
940 | n.f0.accept(this); | ||
941 | } | ||
942 | |||
943 | /** | ||
944 | * <PRE> | ||
945 | * f0 -> <INTEGER_LITERAL> | ||
946 | * | <FLOATING_POINT_LITERAL> | ||
947 | * | <CHARACTER_LITERAL> | ||
948 | * | <STRING_LITERAL> | ||
949 | * </PRE> | ||
950 | */ | ||
951 | public void visit(Constant n) { | ||
952 | n.f0.accept(this); | ||
953 | } | ||
954 | |||
955 | } | ||
956 | |||
957 | class FormatCommand { | ||
958 | public static final int FORCE = 0; | ||
959 | public static final int INDENT = 1; | ||
960 | public static final int OUTDENT = 2; | ||
961 | public static final int SPACE = 3; | ||
962 | |||
963 | private int command; | ||
964 | private int numCommands; | ||
965 | |||
966 | FormatCommand(int command, int numCommands) { | ||
967 | this.command = command; | ||
968 | this.numCommands = numCommands; | ||
969 | } | ||
970 | |||
971 | public int getCommand() { return command; } | ||
972 | public int getNumCommands() { return numCommands; } | ||
973 | public void setCommand(int i) { command = i; } | ||
974 | public void setNumCommands(int i) { numCommands = i; } | ||
975 | } | ||
976 | |||
977 | class TreeFormatterException extends RuntimeException { | ||
978 | TreeFormatterException() { super(); } | ||
979 | TreeFormatterException(String s) { super(s); } | ||
980 | } | ||
diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/Visitor.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/Visitor.java new file mode 100644 index 000000000..456698aec --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/Visitor.java | |||
@@ -0,0 +1,508 @@ | |||
1 | // | ||
2 | // Generated by JTB 1.3.2 | ||
3 | // | ||
4 | |||
5 | package org.gnunet.seaspider.parser.visitors; | ||
6 | import org.gnunet.seaspider.parser.nodes.*; | ||
7 | |||
8 | import java.util.*; | ||
9 | |||
10 | /** | ||
11 | * All void visitors must implement this interface. | ||
12 | */ | ||
13 | |||
14 | public interface Visitor { | ||
15 | |||
16 | // | ||
17 | // void Auto class visitors | ||
18 | // | ||
19 | |||
20 | public void visit(NodeList n); | ||
21 | public void visit(NodeListOptional n); | ||
22 | public void visit(NodeOptional n); | ||
23 | public void visit(NodeSequence n); | ||
24 | public void visit(NodeToken n); | ||
25 | |||
26 | // | ||
27 | // User-generated visitor methods below | ||
28 | // | ||
29 | |||
30 | /** | ||
31 | * <PRE> | ||
32 | * f0 -> ( ExternalDeclaration() )+ | ||
33 | * </PRE> | ||
34 | */ | ||
35 | public void visit(TranslationUnit n); | ||
36 | |||
37 | /** | ||
38 | * <PRE> | ||
39 | * f0 -> ( StorageClassSpecifier() )* | ||
40 | * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() ) | ||
41 | * </PRE> | ||
42 | */ | ||
43 | public void visit(ExternalDeclaration n); | ||
44 | |||
45 | /** | ||
46 | * <PRE> | ||
47 | * f0 -> TypeSpecifier() | ||
48 | * f1 -> <IDENTIFIER> | ||
49 | * f2 -> "(" | ||
50 | * f3 -> [ ParameterList() ] | ||
51 | * f4 -> ")" | ||
52 | * f5 -> ( ";" | CompoundStatement() ) | ||
53 | * </PRE> | ||
54 | */ | ||
55 | public void visit(FunctionDeclaration n); | ||
56 | |||
57 | /** | ||
58 | * <PRE> | ||
59 | * f0 -> ( <STATIC> | <EXTERN> ) | ||
60 | * </PRE> | ||
61 | */ | ||
62 | public void visit(StorageClassSpecifier n); | ||
63 | |||
64 | /** | ||
65 | * <PRE> | ||
66 | * f0 -> <TYPEDEF> | ||
67 | * f1 -> ( DataType() | FunctionType() ) | ||
68 | * f2 -> ";" | ||
69 | * </PRE> | ||
70 | */ | ||
71 | public void visit(TypeDeclaration n); | ||
72 | |||
73 | /** | ||
74 | * <PRE> | ||
75 | * f0 -> StructOrUnionSpecifier() | ||
76 | * f1 -> <IDENTIFIER> | ||
77 | * </PRE> | ||
78 | */ | ||
79 | public void visit(DataType n); | ||
80 | |||
81 | /** | ||
82 | * <PRE> | ||
83 | * f0 -> TypeSpecifier() | ||
84 | * f1 -> "(" | ||
85 | * f2 -> "*" | ||
86 | * f3 -> <IDENTIFIER> | ||
87 | * f4 -> ")" | ||
88 | * f5 -> "(" | ||
89 | * f6 -> [ ParameterList() ] | ||
90 | * f7 -> ")" | ||
91 | * </PRE> | ||
92 | */ | ||
93 | public void visit(FunctionType n); | ||
94 | |||
95 | /** | ||
96 | * <PRE> | ||
97 | * f0 -> ParameterDeclaration() | ||
98 | * f1 -> ( "," ParameterDeclaration() )* | ||
99 | * f2 -> [ "," "..." ] | ||
100 | * </PRE> | ||
101 | */ | ||
102 | public void visit(ParameterList n); | ||
103 | |||
104 | /** | ||
105 | * <PRE> | ||
106 | * f0 -> TypeSpecifier() | ||
107 | * f1 -> <IDENTIFIER> | ||
108 | * f2 -> [ Array() ] | ||
109 | * </PRE> | ||
110 | */ | ||
111 | public void visit(ParameterDeclaration n); | ||
112 | |||
113 | /** | ||
114 | * <PRE> | ||
115 | * f0 -> VariableClassSpecifier() | ||
116 | * f1 -> TypeSpecifier() | ||
117 | * f2 -> InitDeclaratorList() | ||
118 | * f3 -> ";" | ||
119 | * </PRE> | ||
120 | */ | ||
121 | public void visit(VariableDeclaration n); | ||
122 | |||
123 | /** | ||
124 | * <PRE> | ||
125 | * f0 -> [ <STATIC> ] | ||
126 | * f1 -> VariableDeclaration() | ||
127 | * </PRE> | ||
128 | */ | ||
129 | public void visit(LocalVariableDeclaration n); | ||
130 | |||
131 | /** | ||
132 | * <PRE> | ||
133 | * f0 -> ( <AUTO> | <REGISTER> )* | ||
134 | * </PRE> | ||
135 | */ | ||
136 | public void visit(VariableClassSpecifier n); | ||
137 | |||
138 | /** | ||
139 | * <PRE> | ||
140 | * f0 -> [ <CONST> ] | ||
141 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> ) | ||
142 | * f2 -> [ Pointer() ] | ||
143 | * f3 -> [ Array() ] | ||
144 | * </PRE> | ||
145 | */ | ||
146 | public void visit(TypeSpecifier n); | ||
147 | |||
148 | /** | ||
149 | * <PRE> | ||
150 | * f0 -> [ <CONST> ] | ||
151 | * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() ) | ||
152 | * f2 -> [ Pointer() ] | ||
153 | * f3 -> [ Array() ] | ||
154 | * </PRE> | ||
155 | */ | ||
156 | public void visit(NoIdentifierTypeSpecifier n); | ||
157 | |||
158 | /** | ||
159 | * <PRE> | ||
160 | * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}" | ||
161 | * | StructOrUnion() <IDENTIFIER> | ||
162 | * </PRE> | ||
163 | */ | ||
164 | public void visit(StructOrUnionSpecifier n); | ||
165 | |||
166 | /** | ||
167 | * <PRE> | ||
168 | * f0 -> ( <STRUCT> | <UNION> ) | ||
169 | * </PRE> | ||
170 | */ | ||
171 | public void visit(StructOrUnion n); | ||
172 | |||
173 | /** | ||
174 | * <PRE> | ||
175 | * f0 -> ( StructDeclaration() )+ | ||
176 | * </PRE> | ||
177 | */ | ||
178 | public void visit(StructDeclarationList n); | ||
179 | |||
180 | /** | ||
181 | * <PRE> | ||
182 | * f0 -> InitDeclarator() | ||
183 | * f1 -> ( "," InitDeclarator() )* | ||
184 | * </PRE> | ||
185 | */ | ||
186 | public void visit(InitDeclaratorList n); | ||
187 | |||
188 | /** | ||
189 | * <PRE> | ||
190 | * f0 -> <IDENTIFIER> | ||
191 | * f1 -> [ Array() ] | ||
192 | * f2 -> [ "=" Initializer() ] | ||
193 | * </PRE> | ||
194 | */ | ||
195 | public void visit(InitDeclarator n); | ||
196 | |||
197 | /** | ||
198 | * <PRE> | ||
199 | * f0 -> TypeSpecifier() | ||
200 | * f1 -> <IDENTIFIER> | ||
201 | * f2 -> [ Array() | ":" ConstantExpression() ] | ||
202 | * f3 -> [ <IDENTIFIER> ] | ||
203 | * f4 -> ";" | ||
204 | * </PRE> | ||
205 | */ | ||
206 | public void visit(StructDeclaration n); | ||
207 | |||
208 | /** | ||
209 | * <PRE> | ||
210 | * f0 -> <ENUM> | ||
211 | * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> ) | ||
212 | * </PRE> | ||
213 | */ | ||
214 | public void visit(EnumSpecifier n); | ||
215 | |||
216 | /** | ||
217 | * <PRE> | ||
218 | * f0 -> Enumerator() | ||
219 | * f1 -> ( "," Enumerator() )* | ||
220 | * </PRE> | ||
221 | */ | ||
222 | public void visit(EnumeratorList n); | ||
223 | |||
224 | /** | ||
225 | * <PRE> | ||
226 | * f0 -> <IDENTIFIER> | ||
227 | * f1 -> [ "=" ConstantExpression() ] | ||
228 | * </PRE> | ||
229 | */ | ||
230 | public void visit(Enumerator n); | ||
231 | |||
232 | /** | ||
233 | * <PRE> | ||
234 | * f0 -> "*" | ||
235 | * f1 -> [ <CONST> ] | ||
236 | * f2 -> [ Pointer() ] | ||
237 | * </PRE> | ||
238 | */ | ||
239 | public void visit(Pointer n); | ||
240 | |||
241 | /** | ||
242 | * <PRE> | ||
243 | * f0 -> <IDENTIFIER> | ||
244 | * f1 -> ( "," <IDENTIFIER> )* | ||
245 | * </PRE> | ||
246 | */ | ||
247 | public void visit(IdentifierList n); | ||
248 | |||
249 | /** | ||
250 | * <PRE> | ||
251 | * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" ) | ||
252 | * </PRE> | ||
253 | */ | ||
254 | public void visit(Initializer n); | ||
255 | |||
256 | /** | ||
257 | * <PRE> | ||
258 | * f0 -> Initializer() | ||
259 | * f1 -> ( "," Initializer() )* | ||
260 | * </PRE> | ||
261 | */ | ||
262 | public void visit(InitializerList n); | ||
263 | |||
264 | /** | ||
265 | * <PRE> | ||
266 | * f0 -> "[" | ||
267 | * f1 -> [ ConstantExpression() ] | ||
268 | * f2 -> "]" | ||
269 | * </PRE> | ||
270 | */ | ||
271 | public void visit(Array n); | ||
272 | |||
273 | /** | ||
274 | * <PRE> | ||
275 | * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() ) | ||
276 | * </PRE> | ||
277 | */ | ||
278 | public void visit(Statement n); | ||
279 | |||
280 | /** | ||
281 | * <PRE> | ||
282 | * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() ) | ||
283 | * </PRE> | ||
284 | */ | ||
285 | public void visit(LabeledStatement n); | ||
286 | |||
287 | /** | ||
288 | * <PRE> | ||
289 | * f0 -> [ Expression() ] | ||
290 | * f1 -> ";" | ||
291 | * </PRE> | ||
292 | */ | ||
293 | public void visit(ExpressionStatement n); | ||
294 | |||
295 | /** | ||
296 | * <PRE> | ||
297 | * f0 -> "{" | ||
298 | * f1 -> ( LocalVariableDeclaration() | Statement() )* | ||
299 | * f2 -> "}" | ||
300 | * </PRE> | ||
301 | */ | ||
302 | public void visit(CompoundStatement n); | ||
303 | |||
304 | /** | ||
305 | * <PRE> | ||
306 | * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() ) | ||
307 | * </PRE> | ||
308 | */ | ||
309 | public void visit(SelectionStatement n); | ||
310 | |||
311 | /** | ||
312 | * <PRE> | ||
313 | * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() ) | ||
314 | * </PRE> | ||
315 | */ | ||
316 | public void visit(IterationStatement n); | ||
317 | |||
318 | /** | ||
319 | * <PRE> | ||
320 | * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" ) | ||
321 | * </PRE> | ||
322 | */ | ||
323 | public void visit(JumpStatement n); | ||
324 | |||
325 | /** | ||
326 | * <PRE> | ||
327 | * f0 -> AssignmentExpression() | ||
328 | * f1 -> ( "," AssignmentExpression() )* | ||
329 | * </PRE> | ||
330 | */ | ||
331 | public void visit(Expression n); | ||
332 | |||
333 | /** | ||
334 | * <PRE> | ||
335 | * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression() | ||
336 | * | ConditionalExpression() | ||
337 | * </PRE> | ||
338 | */ | ||
339 | public void visit(AssignmentExpression n); | ||
340 | |||
341 | /** | ||
342 | * <PRE> | ||
343 | * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" ) | ||
344 | * </PRE> | ||
345 | */ | ||
346 | public void visit(AssignmentOperator n); | ||
347 | |||
348 | /** | ||
349 | * <PRE> | ||
350 | * f0 -> LogicalORExpression() | ||
351 | * f1 -> [ "?" Expression() ":" ConditionalExpression() ] | ||
352 | * </PRE> | ||
353 | */ | ||
354 | public void visit(ConditionalExpression n); | ||
355 | |||
356 | /** | ||
357 | * <PRE> | ||
358 | * f0 -> ConditionalExpression() | ||
359 | * </PRE> | ||
360 | */ | ||
361 | public void visit(ConstantExpression n); | ||
362 | |||
363 | /** | ||
364 | * <PRE> | ||
365 | * f0 -> LogicalANDExpression() | ||
366 | * f1 -> [ "||" LogicalORExpression() ] | ||
367 | * </PRE> | ||
368 | */ | ||
369 | public void visit(LogicalORExpression n); | ||
370 | |||
371 | /** | ||
372 | * <PRE> | ||
373 | * f0 -> InclusiveORExpression() | ||
374 | * f1 -> [ "&&" LogicalANDExpression() ] | ||
375 | * </PRE> | ||
376 | */ | ||
377 | public void visit(LogicalANDExpression n); | ||
378 | |||
379 | /** | ||
380 | * <PRE> | ||
381 | * f0 -> ExclusiveORExpression() | ||
382 | * f1 -> [ "|" InclusiveORExpression() ] | ||
383 | * </PRE> | ||
384 | */ | ||
385 | public void visit(InclusiveORExpression n); | ||
386 | |||
387 | /** | ||
388 | * <PRE> | ||
389 | * f0 -> ANDExpression() | ||
390 | * f1 -> [ "^" ExclusiveORExpression() ] | ||
391 | * </PRE> | ||
392 | */ | ||
393 | public void visit(ExclusiveORExpression n); | ||
394 | |||
395 | /** | ||
396 | * <PRE> | ||
397 | * f0 -> EqualityExpression() | ||
398 | * f1 -> [ "&" ANDExpression() ] | ||
399 | * </PRE> | ||
400 | */ | ||
401 | public void visit(ANDExpression n); | ||
402 | |||
403 | /** | ||
404 | * <PRE> | ||
405 | * f0 -> RelationalExpression() | ||
406 | * f1 -> [ ( "==" | "!=" ) EqualityExpression() ] | ||
407 | * </PRE> | ||
408 | */ | ||
409 | public void visit(EqualityExpression n); | ||
410 | |||
411 | /** | ||
412 | * <PRE> | ||
413 | * f0 -> ShiftExpression() | ||
414 | * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ] | ||
415 | * </PRE> | ||
416 | */ | ||
417 | public void visit(RelationalExpression n); | ||
418 | |||
419 | /** | ||
420 | * <PRE> | ||
421 | * f0 -> AdditiveExpression() | ||
422 | * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ] | ||
423 | * </PRE> | ||
424 | */ | ||
425 | public void visit(ShiftExpression n); | ||
426 | |||
427 | /** | ||
428 | * <PRE> | ||
429 | * f0 -> MultiplicativeExpression() | ||
430 | * f1 -> [ ( "+" | "-" ) AdditiveExpression() ] | ||
431 | * </PRE> | ||
432 | */ | ||
433 | public void visit(AdditiveExpression n); | ||
434 | |||
435 | /** | ||
436 | * <PRE> | ||
437 | * f0 -> CastExpression() | ||
438 | * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ] | ||
439 | * </PRE> | ||
440 | */ | ||
441 | public void visit(MultiplicativeExpression n); | ||
442 | |||
443 | /** | ||
444 | * <PRE> | ||
445 | * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() ) | ||
446 | * </PRE> | ||
447 | */ | ||
448 | public void visit(CastExpression n); | ||
449 | |||
450 | /** | ||
451 | * <PRE> | ||
452 | * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) ) | ||
453 | * </PRE> | ||
454 | */ | ||
455 | public void visit(UnaryExpression n); | ||
456 | |||
457 | /** | ||
458 | * <PRE> | ||
459 | * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" ) | ||
460 | * </PRE> | ||
461 | */ | ||
462 | public void visit(UnaryOperator n); | ||
463 | |||
464 | /** | ||
465 | * <PRE> | ||
466 | * f0 -> PrimaryExpression() | ||
467 | * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )* | ||
468 | * </PRE> | ||
469 | */ | ||
470 | public void visit(PostfixExpression n); | ||
471 | |||
472 | /** | ||
473 | * <PRE> | ||
474 | * f0 -> <IDENTIFIER> | ||
475 | * | Constant() | ||
476 | * | "(" Expression() ")" | ||
477 | * </PRE> | ||
478 | */ | ||
479 | public void visit(PrimaryExpression n); | ||
480 | |||
481 | /** | ||
482 | * <PRE> | ||
483 | * f0 -> AssignmentOrTypeExpression() | ||
484 | * f1 -> ( "," AssignmentOrTypeExpression() )* | ||
485 | * </PRE> | ||
486 | */ | ||
487 | public void visit(ArgumentExpressionList n); | ||
488 | |||
489 | /** | ||
490 | * <PRE> | ||
491 | * f0 -> NoIdentifierTypeSpecifier() | ||
492 | * | AssignmentExpression() | ||
493 | * </PRE> | ||
494 | */ | ||
495 | public void visit(AssignmentOrTypeExpression n); | ||
496 | |||
497 | /** | ||
498 | * <PRE> | ||
499 | * f0 -> <INTEGER_LITERAL> | ||
500 | * | <FLOATING_POINT_LITERAL> | ||
501 | * | <CHARACTER_LITERAL> | ||
502 | * | <STRING_LITERAL> | ||
503 | * </PRE> | ||
504 | */ | ||
505 | public void visit(Constant n); | ||
506 | |||
507 | } | ||
508 | |||