1 | |
|
2 | |
package org.apache.commons.ognl; |
3 | |
import java.math.*; |
4 | |
|
5 | |
|
6 | |
public class OgnlParserTokenManager implements OgnlParserConstants |
7 | |
{ |
8 | |
|
9 | |
Object literalValue; |
10 | |
|
11 | |
private char charValue; |
12 | |
|
13 | |
private char charLiteralStartQuote; |
14 | |
|
15 | |
private StringBuilder stringBuilder; |
16 | |
|
17 | |
|
18 | |
private char escapeChar() |
19 | |
{ |
20 | 27 | int ofs = image.length() - 1; |
21 | 27 | switch ( image.charAt(ofs) ) { |
22 | 4 | case 'n': return '\u005cn'; |
23 | 2 | case 'r': return '\u005cr'; |
24 | 2 | case 't': return '\u005ct'; |
25 | 2 | case 'b': return '\u005cb'; |
26 | 2 | case 'f': return '\u005cf'; |
27 | 2 | case '\u005c\u005c': return '\u005c\u005c'; |
28 | 2 | case '\u005c'': return '\u005c''; |
29 | 4 | case '\u005c"': return '\u005c"'; |
30 | |
} |
31 | |
|
32 | |
|
33 | 19 | while ( image.charAt(--ofs) != '\u005c\u005c' ) |
34 | |
{} |
35 | 7 | int value = 0; |
36 | 26 | while ( ++ofs < image.length() ) |
37 | 19 | value = (value << 3) | (image.charAt(ofs) - '0'); |
38 | 7 | return (char) value; |
39 | |
} |
40 | |
|
41 | |
private Object makeInt() |
42 | |
{ |
43 | |
Object result; |
44 | 619 | String s = image.toString(); |
45 | 619 | int base = 10; |
46 | |
|
47 | 619 | if ( s.charAt(0) == '0' ) |
48 | 98 | base = (s.length() > 1 && (s.charAt(1) == 'x' || s.charAt(1) == 'X'))? 16 : 8; |
49 | 619 | if ( base == 16 ) |
50 | 4 | s = s.substring(2); |
51 | 619 | switch ( s.charAt(s.length()-1) ) { |
52 | |
case 'l': case 'L': |
53 | 8 | result = Long.valueOf( s.substring(0,s.length()-1), base ); |
54 | 8 | break; |
55 | |
|
56 | |
case 'h': case 'H': |
57 | 40 | result = new BigInteger( s.substring(0,s.length()-1), base ); |
58 | 40 | break; |
59 | |
|
60 | |
default: |
61 | 571 | result = Integer.valueOf( s, base ); |
62 | |
break; |
63 | |
} |
64 | 619 | return result; |
65 | |
} |
66 | |
|
67 | |
private Object makeFloat() |
68 | |
{ |
69 | 76 | String s = image.toString(); |
70 | 76 | switch ( s.charAt(s.length()-1) ) { |
71 | |
case 'f': case 'F': |
72 | 10 | return Float.valueOf( s ); |
73 | |
|
74 | |
case 'b': case 'B': |
75 | 22 | return new BigDecimal( s.substring(0,s.length()-1) ); |
76 | |
|
77 | |
case 'd': case 'D': |
78 | |
default: |
79 | 44 | return Double.valueOf( s ); |
80 | |
} |
81 | |
} |
82 | |
|
83 | |
|
84 | 1148 | public java.io.PrintStream debugStream = System.out; |
85 | |
|
86 | 0 | public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } |
87 | |
private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1) |
88 | |
{ |
89 | 1569 | switch (pos) |
90 | |
{ |
91 | |
case 0: |
92 | 1387 | if ((active0 & 0x201c4055d555540L) != 0L) |
93 | |
{ |
94 | 1111 | jjmatchedKind = 64; |
95 | 1111 | return 1; |
96 | |
} |
97 | 276 | if ((active0 & 0x400000000000000L) != 0L) |
98 | 0 | return 1; |
99 | 276 | if ((active0 & 0x10000000000000L) != 0L) |
100 | 0 | return 3; |
101 | 276 | if ((active0 & 0x80000000000L) != 0L) |
102 | 0 | return 9; |
103 | 276 | return -1; |
104 | |
case 1: |
105 | 182 | if ((active0 & 0x201c00550045500L) != 0L) |
106 | |
{ |
107 | 79 | if (jjmatchedPos != 1) |
108 | |
{ |
109 | 79 | jjmatchedKind = 64; |
110 | 79 | jjmatchedPos = 1; |
111 | |
} |
112 | 79 | return 1; |
113 | |
} |
114 | 103 | if ((active0 & 0x4000d510040L) != 0L) |
115 | 95 | return 1; |
116 | 8 | return -1; |
117 | |
case 2: |
118 | 0 | if ((active0 & 0x1c40400004000L) != 0L) |
119 | |
{ |
120 | 0 | jjmatchedKind = 64; |
121 | 0 | jjmatchedPos = 2; |
122 | 0 | return 1; |
123 | |
} |
124 | 0 | if ((active0 & 0x200000155041500L) != 0L) |
125 | 0 | return 1; |
126 | 0 | return -1; |
127 | |
case 3: |
128 | 0 | if ((active0 & 0x1400400004000L) != 0L) |
129 | 0 | return 1; |
130 | 0 | if ((active0 & 0x840000000000L) != 0L) |
131 | |
{ |
132 | 0 | jjmatchedKind = 64; |
133 | 0 | jjmatchedPos = 3; |
134 | 0 | return 1; |
135 | |
} |
136 | 0 | return -1; |
137 | |
case 4: |
138 | 0 | if ((active0 & 0x800000000000L) != 0L) |
139 | 0 | return 1; |
140 | 0 | if ((active0 & 0x40000000000L) != 0L) |
141 | |
{ |
142 | 0 | jjmatchedKind = 64; |
143 | 0 | jjmatchedPos = 4; |
144 | 0 | return 1; |
145 | |
} |
146 | 0 | return -1; |
147 | |
case 5: |
148 | 0 | if ((active0 & 0x40000000000L) != 0L) |
149 | |
{ |
150 | 0 | jjmatchedKind = 64; |
151 | 0 | jjmatchedPos = 5; |
152 | 0 | return 1; |
153 | |
} |
154 | 0 | return -1; |
155 | |
case 6: |
156 | 0 | if ((active0 & 0x40000000000L) != 0L) |
157 | |
{ |
158 | 0 | jjmatchedKind = 64; |
159 | 0 | jjmatchedPos = 6; |
160 | 0 | return 1; |
161 | |
} |
162 | 0 | return -1; |
163 | |
case 7: |
164 | 0 | if ((active0 & 0x40000000000L) != 0L) |
165 | |
{ |
166 | 0 | jjmatchedKind = 64; |
167 | 0 | jjmatchedPos = 7; |
168 | 0 | return 1; |
169 | |
} |
170 | 0 | return -1; |
171 | |
case 8: |
172 | 0 | if ((active0 & 0x40000000000L) != 0L) |
173 | |
{ |
174 | 0 | jjmatchedKind = 64; |
175 | 0 | jjmatchedPos = 8; |
176 | 0 | return 1; |
177 | |
} |
178 | 0 | return -1; |
179 | |
default : |
180 | 0 | return -1; |
181 | |
} |
182 | |
} |
183 | |
private final int jjStartNfa_0(int pos, long active0, long active1) |
184 | |
{ |
185 | 1555 | return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1); |
186 | |
} |
187 | |
private int jjStopAtPos(int pos, int kind) |
188 | |
{ |
189 | 3046 | jjmatchedKind = kind; |
190 | 3046 | jjmatchedPos = pos; |
191 | 3046 | return pos + 1; |
192 | |
} |
193 | |
private int jjMoveStringLiteralDfa0_0() |
194 | |
{ |
195 | 7136 | switch(curChar) |
196 | |
{ |
197 | |
case 33: |
198 | 50 | jjmatchedKind = 41; |
199 | 50 | return jjMoveStringLiteralDfa1_0(0x20000L); |
200 | |
case 34: |
201 | 237 | return jjStopAtPos(0, 70); |
202 | |
case 35: |
203 | 214 | jjmatchedKind = 51; |
204 | 214 | return jjMoveStringLiteralDfa1_0(0x6000000000000L); |
205 | |
case 36: |
206 | 2 | return jjStartNfaWithStates_0(0, 58, 1); |
207 | |
case 37: |
208 | 12 | return jjStopAtPos(0, 39); |
209 | |
case 38: |
210 | 36 | jjmatchedKind = 13; |
211 | 36 | return jjMoveStringLiteralDfa1_0(0x80L); |
212 | |
case 39: |
213 | 192 | return jjStopAtPos(0, 69); |
214 | |
case 40: |
215 | 365 | return jjStopAtPos(0, 44); |
216 | |
case 41: |
217 | 365 | return jjStopAtPos(0, 45); |
218 | |
case 42: |
219 | 36 | return jjStopAtPos(0, 37); |
220 | |
case 43: |
221 | 144 | return jjStopAtPos(0, 35); |
222 | |
case 44: |
223 | 192 | return jjStopAtPos(0, 1); |
224 | |
case 45: |
225 | 58 | return jjStopAtPos(0, 36); |
226 | |
case 46: |
227 | 901 | return jjStartNfaWithStates_0(0, 43, 9); |
228 | |
case 47: |
229 | 16 | return jjStopAtPos(0, 38); |
230 | |
case 58: |
231 | 88 | return jjStopAtPos(0, 4); |
232 | |
case 60: |
233 | 35 | jjmatchedKind = 19; |
234 | 35 | return jjMoveStringLiteralDfa1_0(0x20800000L); |
235 | |
case 61: |
236 | 94 | jjmatchedKind = 2; |
237 | 94 | return jjMoveStringLiteralDfa1_0(0x8000L); |
238 | |
case 62: |
239 | 62 | jjmatchedKind = 21; |
240 | 62 | return jjMoveStringLiteralDfa1_0(0x282000000L); |
241 | |
case 63: |
242 | 71 | return jjStopAtPos(0, 3); |
243 | |
case 64: |
244 | 128 | return jjStopAtPos(0, 56); |
245 | |
case 91: |
246 | 293 | return jjStartNfaWithStates_0(0, 52, 3); |
247 | |
case 93: |
248 | 251 | return jjStopAtPos(0, 53); |
249 | |
case 94: |
250 | 14 | return jjStopAtPos(0, 11); |
251 | |
case 96: |
252 | 2 | return jjStopAtPos(0, 68); |
253 | |
case 97: |
254 | 163 | return jjMoveStringLiteralDfa1_0(0x100L); |
255 | |
case 98: |
256 | 107 | return jjMoveStringLiteralDfa1_0(0x4400L); |
257 | |
case 101: |
258 | 12 | return jjMoveStringLiteralDfa1_0(0x10000L); |
259 | |
case 102: |
260 | 124 | return jjMoveStringLiteralDfa1_0(0x800000000000L); |
261 | |
case 103: |
262 | 135 | return jjMoveStringLiteralDfa1_0(0x4400000L); |
263 | |
case 105: |
264 | 151 | return jjMoveStringLiteralDfa1_0(0x40008000000L); |
265 | |
case 108: |
266 | 76 | return jjMoveStringLiteralDfa1_0(0x1100000L); |
267 | |
case 110: |
268 | 268 | return jjMoveStringLiteralDfa1_0(0x201000010040000L); |
269 | |
case 111: |
270 | 238 | return jjMoveStringLiteralDfa1_0(0x40L); |
271 | |
case 115: |
272 | 138 | return jjMoveStringLiteralDfa1_0(0x140000000L); |
273 | |
case 116: |
274 | 211 | return jjMoveStringLiteralDfa1_0(0x400000000000L); |
275 | |
case 117: |
276 | 10 | return jjMoveStringLiteralDfa1_0(0x400000000L); |
277 | |
case 120: |
278 | 42 | return jjMoveStringLiteralDfa1_0(0x1000L); |
279 | |
case 123: |
280 | 103 | return jjStopAtPos(0, 54); |
281 | |
case 124: |
282 | 32 | jjmatchedKind = 9; |
283 | 32 | return jjMoveStringLiteralDfa1_0(0x20L); |
284 | |
case 125: |
285 | 102 | return jjStopAtPos(0, 55); |
286 | |
case 126: |
287 | 4 | return jjStopAtPos(0, 40); |
288 | |
default : |
289 | 1362 | return jjMoveNfa_0(0, 0); |
290 | |
} |
291 | |
} |
292 | |
private int jjMoveStringLiteralDfa1_0(long active0) |
293 | |
{ |
294 | 2198 | try { curChar = input_stream.readChar(); } |
295 | 14 | catch(java.io.IOException e) { |
296 | 14 | jjStopStringLiteralDfa_0(0, active0, 0L); |
297 | 14 | return 1; |
298 | 2184 | } |
299 | 2184 | switch(curChar) |
300 | |
{ |
301 | |
case 38: |
302 | 24 | if ((active0 & 0x80L) != 0L) |
303 | 24 | return jjStopAtPos(1, 7); |
304 | |
break; |
305 | |
case 60: |
306 | 4 | if ((active0 & 0x20000000L) != 0L) |
307 | 4 | return jjStopAtPos(1, 29); |
308 | |
break; |
309 | |
case 61: |
310 | 107 | if ((active0 & 0x8000L) != 0L) |
311 | 56 | return jjStopAtPos(1, 15); |
312 | 51 | else if ((active0 & 0x20000L) != 0L) |
313 | 18 | return jjStopAtPos(1, 17); |
314 | 33 | else if ((active0 & 0x800000L) != 0L) |
315 | 13 | return jjStopAtPos(1, 23); |
316 | 20 | else if ((active0 & 0x2000000L) != 0L) |
317 | 10 | return jjStopAtPos(1, 25); |
318 | |
break; |
319 | |
case 62: |
320 | 16 | if ((active0 & 0x80000000L) != 0L) |
321 | |
{ |
322 | 16 | jjmatchedKind = 31; |
323 | 16 | jjmatchedPos = 1; |
324 | |
} |
325 | 16 | return jjMoveStringLiteralDfa2_0(active0, 0x200000000L); |
326 | |
case 97: |
327 | 143 | return jjMoveStringLiteralDfa2_0(active0, 0x800000004000L); |
328 | |
case 101: |
329 | 456 | return jjMoveStringLiteralDfa2_0(active0, 0x200000000040000L); |
330 | |
case 104: |
331 | 33 | return jjMoveStringLiteralDfa2_0(active0, 0x140000000L); |
332 | |
case 110: |
333 | 116 | if ((active0 & 0x8000000L) != 0L) |
334 | |
{ |
335 | 93 | jjmatchedKind = 27; |
336 | 93 | jjmatchedPos = 1; |
337 | |
} |
338 | 116 | return jjMoveStringLiteralDfa2_0(active0, 0x40000000100L); |
339 | |
case 111: |
340 | 134 | return jjMoveStringLiteralDfa2_0(active0, 0x10001400L); |
341 | |
case 113: |
342 | 4 | if ((active0 & 0x10000L) != 0L) |
343 | 4 | return jjStartNfaWithStates_0(1, 16, 1); |
344 | |
break; |
345 | |
case 114: |
346 | 188 | if ((active0 & 0x40L) != 0L) |
347 | 81 | return jjStartNfaWithStates_0(1, 6, 1); |
348 | 107 | return jjMoveStringLiteralDfa2_0(active0, 0x4400000000000L); |
349 | |
case 115: |
350 | 26 | return jjMoveStringLiteralDfa2_0(active0, 0x400000000L); |
351 | |
case 116: |
352 | 135 | if ((active0 & 0x100000L) != 0L) |
353 | |
{ |
354 | 10 | jjmatchedKind = 20; |
355 | 10 | jjmatchedPos = 1; |
356 | |
} |
357 | 125 | else if ((active0 & 0x400000L) != 0L) |
358 | |
{ |
359 | 8 | jjmatchedKind = 22; |
360 | 8 | jjmatchedPos = 1; |
361 | |
} |
362 | 135 | return jjMoveStringLiteralDfa2_0(active0, 0x2000005000000L); |
363 | |
case 117: |
364 | 89 | return jjMoveStringLiteralDfa2_0(active0, 0x1000000000000L); |
365 | |
case 124: |
366 | 24 | if ((active0 & 0x20L) != 0L) |
367 | 24 | return jjStopAtPos(1, 5); |
368 | |
break; |
369 | |
default : |
370 | |
break; |
371 | |
} |
372 | 695 | return jjStartNfa_0(0, active0, 0L); |
373 | |
} |
374 | |
private int jjMoveStringLiteralDfa2_0(long old0, long active0) |
375 | |
{ |
376 | 1255 | if (((active0 &= old0)) == 0L) |
377 | 678 | return jjStartNfa_0(0, old0, 0L); |
378 | 577 | try { curChar = input_stream.readChar(); } |
379 | 0 | catch(java.io.IOException e) { |
380 | 0 | jjStopStringLiteralDfa_0(1, active0, 0L); |
381 | 0 | return 2; |
382 | 577 | } |
383 | 577 | switch(curChar) |
384 | |
{ |
385 | |
case 62: |
386 | 8 | if ((active0 & 0x200000000L) != 0L) |
387 | 8 | return jjStopAtPos(2, 33); |
388 | |
break; |
389 | |
case 100: |
390 | 45 | if ((active0 & 0x100L) != 0L) |
391 | 4 | return jjStartNfaWithStates_0(2, 8, 1); |
392 | |
break; |
393 | |
case 101: |
394 | 8 | if ((active0 & 0x1000000L) != 0L) |
395 | 4 | return jjStartNfaWithStates_0(2, 24, 1); |
396 | 4 | else if ((active0 & 0x4000000L) != 0L) |
397 | 4 | return jjStartNfaWithStates_0(2, 26, 1); |
398 | |
break; |
399 | |
case 104: |
400 | 53 | return jjMoveStringLiteralDfa3_0(active0, 0x2000400000000L); |
401 | |
case 108: |
402 | 108 | if ((active0 & 0x40000000L) != 0L) |
403 | 2 | return jjStartNfaWithStates_0(2, 30, 1); |
404 | 106 | return jjMoveStringLiteralDfa3_0(active0, 0x1800000000000L); |
405 | |
case 110: |
406 | 6 | return jjMoveStringLiteralDfa3_0(active0, 0x4000L); |
407 | |
case 111: |
408 | 63 | return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000L); |
409 | |
case 113: |
410 | 2 | if ((active0 & 0x40000L) != 0L) |
411 | 2 | return jjStartNfaWithStates_0(2, 18, 1); |
412 | |
break; |
413 | |
case 114: |
414 | 9 | if ((active0 & 0x400L) != 0L) |
415 | 2 | return jjStartNfaWithStates_0(2, 10, 1); |
416 | 7 | else if ((active0 & 0x1000L) != 0L) |
417 | 2 | return jjStartNfaWithStates_0(2, 12, 1); |
418 | 5 | else if ((active0 & 0x100000000L) != 0L) |
419 | 2 | return jjStartNfaWithStates_0(2, 32, 1); |
420 | |
break; |
421 | |
case 115: |
422 | 10 | return jjMoveStringLiteralDfa3_0(active0, 0x40000000000L); |
423 | |
case 116: |
424 | 41 | if ((active0 & 0x10000000L) != 0L) |
425 | 8 | return jjStartNfaWithStates_0(2, 28, 1); |
426 | |
break; |
427 | |
case 117: |
428 | 42 | return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L); |
429 | |
case 119: |
430 | 115 | if ((active0 & 0x200000000000000L) != 0L) |
431 | 115 | return jjStartNfaWithStates_0(2, 57, 1); |
432 | |
break; |
433 | |
default : |
434 | |
break; |
435 | |
} |
436 | 144 | return jjStartNfa_0(1, active0, 0L); |
437 | |
} |
438 | |
private int jjMoveStringLiteralDfa3_0(long old0, long active0) |
439 | |
{ |
440 | 280 | if (((active0 &= old0)) == 0L) |
441 | 38 | return jjStartNfa_0(1, old0, 0L); |
442 | 242 | try { curChar = input_stream.readChar(); } |
443 | 0 | catch(java.io.IOException e) { |
444 | 0 | jjStopStringLiteralDfa_0(2, active0, 0L); |
445 | 0 | return 3; |
446 | 242 | } |
447 | 242 | switch(curChar) |
448 | |
{ |
449 | |
case 100: |
450 | 2 | if ((active0 & 0x4000L) != 0L) |
451 | 2 | return jjStartNfaWithStates_0(3, 14, 1); |
452 | |
break; |
453 | |
case 101: |
454 | 42 | if ((active0 & 0x400000000000L) != 0L) |
455 | 42 | return jjStartNfaWithStates_0(3, 46, 1); |
456 | |
break; |
457 | |
case 105: |
458 | 51 | return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L); |
459 | |
case 108: |
460 | 74 | if ((active0 & 0x1000000000000L) != 0L) |
461 | 74 | return jjStartNfaWithStates_0(3, 48, 1); |
462 | |
break; |
463 | |
case 111: |
464 | 31 | return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L); |
465 | |
case 114: |
466 | 2 | if ((active0 & 0x400000000L) != 0L) |
467 | 2 | return jjStartNfaWithStates_0(3, 34, 1); |
468 | |
break; |
469 | |
case 115: |
470 | 32 | return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L); |
471 | |
case 116: |
472 | 8 | return jjMoveStringLiteralDfa4_0(active0, 0x40000000000L); |
473 | |
default : |
474 | |
break; |
475 | |
} |
476 | 0 | return jjStartNfa_0(2, active0, 0L); |
477 | |
} |
478 | |
private int jjMoveStringLiteralDfa4_0(long old0, long active0) |
479 | |
{ |
480 | 122 | if (((active0 &= old0)) == 0L) |
481 | 0 | return jjStartNfa_0(2, old0, 0L); |
482 | 122 | try { curChar = input_stream.readChar(); } |
483 | 0 | catch(java.io.IOException e) { |
484 | 0 | jjStopStringLiteralDfa_0(3, active0, 0L); |
485 | 0 | return 4; |
486 | 122 | } |
487 | 122 | switch(curChar) |
488 | |
{ |
489 | |
case 97: |
490 | 8 | return jjMoveStringLiteralDfa5_0(active0, 0x40000000000L); |
491 | |
case 101: |
492 | 32 | if ((active0 & 0x800000000000L) != 0L) |
493 | 32 | return jjStartNfaWithStates_0(4, 47, 1); |
494 | |
break; |
495 | |
case 115: |
496 | 51 | if ((active0 & 0x2000000000000L) != 0L) |
497 | 51 | return jjStopAtPos(4, 49); |
498 | |
break; |
499 | |
case 116: |
500 | 31 | if ((active0 & 0x4000000000000L) != 0L) |
501 | 31 | return jjStopAtPos(4, 50); |
502 | |
break; |
503 | |
default : |
504 | |
break; |
505 | |
} |
506 | 0 | return jjStartNfa_0(3, active0, 0L); |
507 | |
} |
508 | |
private int jjMoveStringLiteralDfa5_0(long old0, long active0) |
509 | |
{ |
510 | 8 | if (((active0 &= old0)) == 0L) |
511 | 0 | return jjStartNfa_0(3, old0, 0L); |
512 | 8 | try { curChar = input_stream.readChar(); } |
513 | 0 | catch(java.io.IOException e) { |
514 | 0 | jjStopStringLiteralDfa_0(4, active0, 0L); |
515 | 0 | return 5; |
516 | 8 | } |
517 | 8 | switch(curChar) |
518 | |
{ |
519 | |
case 110: |
520 | 8 | return jjMoveStringLiteralDfa6_0(active0, 0x40000000000L); |
521 | |
default : |
522 | |
break; |
523 | |
} |
524 | 0 | return jjStartNfa_0(4, active0, 0L); |
525 | |
} |
526 | |
private int jjMoveStringLiteralDfa6_0(long old0, long active0) |
527 | |
{ |
528 | 8 | if (((active0 &= old0)) == 0L) |
529 | 0 | return jjStartNfa_0(4, old0, 0L); |
530 | 8 | try { curChar = input_stream.readChar(); } |
531 | 0 | catch(java.io.IOException e) { |
532 | 0 | jjStopStringLiteralDfa_0(5, active0, 0L); |
533 | 0 | return 6; |
534 | 8 | } |
535 | 8 | switch(curChar) |
536 | |
{ |
537 | |
case 99: |
538 | 8 | return jjMoveStringLiteralDfa7_0(active0, 0x40000000000L); |
539 | |
default : |
540 | |
break; |
541 | |
} |
542 | 0 | return jjStartNfa_0(5, active0, 0L); |
543 | |
} |
544 | |
private int jjMoveStringLiteralDfa7_0(long old0, long active0) |
545 | |
{ |
546 | 8 | if (((active0 &= old0)) == 0L) |
547 | 0 | return jjStartNfa_0(5, old0, 0L); |
548 | 8 | try { curChar = input_stream.readChar(); } |
549 | 0 | catch(java.io.IOException e) { |
550 | 0 | jjStopStringLiteralDfa_0(6, active0, 0L); |
551 | 0 | return 7; |
552 | 8 | } |
553 | 8 | switch(curChar) |
554 | |
{ |
555 | |
case 101: |
556 | 8 | return jjMoveStringLiteralDfa8_0(active0, 0x40000000000L); |
557 | |
default : |
558 | |
break; |
559 | |
} |
560 | 0 | return jjStartNfa_0(6, active0, 0L); |
561 | |
} |
562 | |
private int jjMoveStringLiteralDfa8_0(long old0, long active0) |
563 | |
{ |
564 | 8 | if (((active0 &= old0)) == 0L) |
565 | 0 | return jjStartNfa_0(6, old0, 0L); |
566 | 8 | try { curChar = input_stream.readChar(); } |
567 | 0 | catch(java.io.IOException e) { |
568 | 0 | jjStopStringLiteralDfa_0(7, active0, 0L); |
569 | 0 | return 8; |
570 | 8 | } |
571 | 8 | switch(curChar) |
572 | |
{ |
573 | |
case 111: |
574 | 8 | return jjMoveStringLiteralDfa9_0(active0, 0x40000000000L); |
575 | |
default : |
576 | |
break; |
577 | |
} |
578 | 0 | return jjStartNfa_0(7, active0, 0L); |
579 | |
} |
580 | |
private int jjMoveStringLiteralDfa9_0(long old0, long active0) |
581 | |
{ |
582 | 8 | if (((active0 &= old0)) == 0L) |
583 | 0 | return jjStartNfa_0(7, old0, 0L); |
584 | 8 | try { curChar = input_stream.readChar(); } |
585 | 0 | catch(java.io.IOException e) { |
586 | 0 | jjStopStringLiteralDfa_0(8, active0, 0L); |
587 | 0 | return 9; |
588 | 8 | } |
589 | 8 | switch(curChar) |
590 | |
{ |
591 | |
case 102: |
592 | 8 | if ((active0 & 0x40000000000L) != 0L) |
593 | 8 | return jjStartNfaWithStates_0(9, 42, 1); |
594 | |
break; |
595 | |
default : |
596 | |
break; |
597 | |
} |
598 | 0 | return jjStartNfa_0(8, active0, 0L); |
599 | |
} |
600 | |
private int jjStartNfaWithStates_0(int pos, int kind, int state) |
601 | |
{ |
602 | 1586 | jjmatchedKind = kind; |
603 | 1586 | jjmatchedPos = pos; |
604 | 1586 | try { curChar = input_stream.readChar(); } |
605 | 1560 | catch(java.io.IOException e) { return pos + 1; } |
606 | 1560 | return jjMoveNfa_0(state, pos + 1); |
607 | |
} |
608 | 1 | static final long[] jjbitVec0 = { |
609 | |
0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L |
610 | |
}; |
611 | 1 | static final long[] jjbitVec2 = { |
612 | |
0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL |
613 | |
}; |
614 | 1 | static final long[] jjbitVec3 = { |
615 | |
0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL |
616 | |
}; |
617 | 1 | static final long[] jjbitVec4 = { |
618 | |
0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L |
619 | |
}; |
620 | 1 | static final long[] jjbitVec5 = { |
621 | |
0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L |
622 | |
}; |
623 | 1 | static final long[] jjbitVec6 = { |
624 | |
0x3fffffffffffL, 0x0L, 0x0L, 0x0L |
625 | |
}; |
626 | |
private int jjMoveNfa_0(int startState, int curPos) |
627 | |
{ |
628 | 4477 | int startsAt = 0; |
629 | 4477 | jjnewStateCnt = 27; |
630 | 4477 | int i = 1; |
631 | 4477 | jjstateSet[0] = startState; |
632 | 4477 | int kind = 0x7fffffff; |
633 | |
for (;;) |
634 | |
{ |
635 | 16742 | if (++jjround == 0x7fffffff) |
636 | 0 | ReInitRounds(); |
637 | 16742 | if (curChar < 64) |
638 | |
{ |
639 | 3227 | long l = 1L << curChar; |
640 | |
do |
641 | |
{ |
642 | 6424 | switch(jjstateSet[--i]) |
643 | |
{ |
644 | |
case 0: |
645 | 693 | if ((0x3ff000000000000L & l) != 0L) |
646 | 693 | jjCheckNAddStates(0, 5); |
647 | 0 | else if (curChar == 46) |
648 | 0 | jjCheckNAdd(9); |
649 | 0 | else if (curChar == 36) |
650 | |
{ |
651 | 0 | if (kind > 64) |
652 | 0 | kind = 64; |
653 | 0 | jjCheckNAdd(1); |
654 | |
} |
655 | 693 | if ((0x3fe000000000000L & l) != 0L) |
656 | |
{ |
657 | 595 | if (kind > 80) |
658 | 595 | kind = 80; |
659 | 595 | jjCheckNAddTwoStates(6, 7); |
660 | |
} |
661 | 98 | else if (curChar == 48) |
662 | |
{ |
663 | 98 | if (kind > 80) |
664 | 98 | kind = 80; |
665 | 98 | jjCheckNAddStates(6, 8); |
666 | |
} |
667 | |
break; |
668 | |
case 1: |
669 | 1694 | if ((0x3ff001000000000L & l) == 0L) |
670 | 1623 | break; |
671 | 71 | if (kind > 64) |
672 | 71 | kind = 64; |
673 | 71 | jjCheckNAdd(1); |
674 | 71 | break; |
675 | |
case 3: |
676 | 180 | if ((0x41000000000L & l) != 0L) |
677 | 22 | jjstateSet[jjnewStateCnt++] = 4; |
678 | |
break; |
679 | |
case 5: |
680 | 0 | if ((0x3fe000000000000L & l) == 0L) |
681 | 0 | break; |
682 | 0 | if (kind > 80) |
683 | 0 | kind = 80; |
684 | 0 | jjCheckNAddTwoStates(6, 7); |
685 | 0 | break; |
686 | |
case 6: |
687 | 403 | if ((0x3ff000000000000L & l) == 0L) |
688 | 308 | break; |
689 | 95 | if (kind > 80) |
690 | 95 | kind = 80; |
691 | 95 | jjCheckNAddTwoStates(6, 7); |
692 | 95 | break; |
693 | |
case 8: |
694 | 0 | if (curChar == 46) |
695 | 0 | jjCheckNAdd(9); |
696 | |
break; |
697 | |
case 9: |
698 | 31 | if ((0x3ff000000000000L & l) == 0L) |
699 | 23 | break; |
700 | 8 | if (kind > 81) |
701 | 8 | kind = 81; |
702 | 8 | jjCheckNAddStates(9, 11); |
703 | 8 | break; |
704 | |
case 11: |
705 | 0 | if ((0x280000000000L & l) != 0L) |
706 | 0 | jjCheckNAdd(12); |
707 | |
break; |
708 | |
case 12: |
709 | 0 | if ((0x3ff000000000000L & l) == 0L) |
710 | 0 | break; |
711 | 0 | if (kind > 81) |
712 | 0 | kind = 81; |
713 | 0 | jjCheckNAddTwoStates(12, 13); |
714 | 0 | break; |
715 | |
case 14: |
716 | 0 | if ((0x3ff000000000000L & l) != 0L) |
717 | 0 | jjCheckNAddStates(0, 5); |
718 | |
break; |
719 | |
case 15: |
720 | 435 | if ((0x3ff000000000000L & l) != 0L) |
721 | 103 | jjCheckNAddTwoStates(15, 16); |
722 | |
break; |
723 | |
case 16: |
724 | 435 | if (curChar != 46) |
725 | 389 | break; |
726 | 46 | if (kind > 81) |
727 | 46 | kind = 81; |
728 | 46 | jjCheckNAddStates(12, 14); |
729 | 46 | break; |
730 | |
case 17: |
731 | 54 | if ((0x3ff000000000000L & l) == 0L) |
732 | 20 | break; |
733 | 34 | if (kind > 81) |
734 | 34 | kind = 81; |
735 | 34 | jjCheckNAddStates(12, 14); |
736 | 34 | break; |
737 | |
case 18: |
738 | 435 | if ((0x3ff000000000000L & l) != 0L) |
739 | 103 | jjCheckNAddTwoStates(18, 19); |
740 | |
break; |
741 | |
case 20: |
742 | 2 | if ((0x280000000000L & l) != 0L) |
743 | 2 | jjCheckNAdd(21); |
744 | |
break; |
745 | |
case 21: |
746 | 4 | if ((0x3ff000000000000L & l) == 0L) |
747 | 2 | break; |
748 | 2 | if (kind > 81) |
749 | 2 | kind = 81; |
750 | 2 | jjCheckNAddTwoStates(21, 13); |
751 | 2 | break; |
752 | |
case 22: |
753 | 435 | if ((0x3ff000000000000L & l) != 0L) |
754 | 103 | jjCheckNAddTwoStates(22, 13); |
755 | |
break; |
756 | |
case 23: |
757 | 0 | if (curChar != 48) |
758 | 0 | break; |
759 | 0 | if (kind > 80) |
760 | 0 | kind = 80; |
761 | 0 | jjCheckNAddStates(6, 8); |
762 | 0 | break; |
763 | |
case 24: |
764 | 32 | if ((0xff000000000000L & l) == 0L) |
765 | 24 | break; |
766 | 8 | if (kind > 80) |
767 | 8 | kind = 80; |
768 | 8 | jjCheckNAddTwoStates(24, 7); |
769 | 8 | break; |
770 | |
case 26: |
771 | 6 | if ((0x3ff000000000000L & l) == 0L) |
772 | 0 | break; |
773 | 6 | if (kind > 80) |
774 | 6 | kind = 80; |
775 | 6 | jjCheckNAddTwoStates(26, 7); |
776 | 6 | break; |
777 | |
default : break; |
778 | |
} |
779 | 6424 | } while(i != startsAt); |
780 | 3227 | } |
781 | 13515 | else if (curChar < 128) |
782 | |
{ |
783 | 13515 | long l = 1L << (curChar & 077); |
784 | |
do |
785 | |
{ |
786 | 14833 | switch(jjstateSet[--i]) |
787 | |
{ |
788 | |
case 0: |
789 | 669 | if ((0x7fffffe87fffffeL & l) != 0L) |
790 | |
{ |
791 | 669 | if (kind > 64) |
792 | 669 | kind = 64; |
793 | 669 | jjCheckNAdd(1); |
794 | |
} |
795 | 0 | else if (curChar == 91) |
796 | 0 | jjstateSet[jjnewStateCnt++] = 3; |
797 | |
break; |
798 | |
case 1: |
799 | 11463 | if ((0x7fffffe87fffffeL & l) == 0L) |
800 | 378 | break; |
801 | 11085 | if (kind > 64) |
802 | 11085 | kind = 64; |
803 | 11085 | jjCheckNAdd(1); |
804 | 11085 | break; |
805 | |
case 2: |
806 | 0 | if (curChar == 91) |
807 | 0 | jjstateSet[jjnewStateCnt++] = 3; |
808 | |
break; |
809 | |
case 3: |
810 | 113 | if ((0x1000000040000000L & l) != 0L) |
811 | 20 | jjstateSet[jjnewStateCnt++] = 4; |
812 | |
break; |
813 | |
case 4: |
814 | 42 | if (curChar == 93) |
815 | 42 | kind = 67; |
816 | |
break; |
817 | |
case 7: |
818 | 182 | if ((0x110000001100L & l) != 0L && kind > 80) |
819 | 48 | kind = 80; |
820 | |
break; |
821 | |
case 10: |
822 | 12 | if ((0x2000000020L & l) != 0L) |
823 | 0 | jjAddStates(15, 16); |
824 | |
break; |
825 | |
case 13: |
826 | 194 | if ((0x5400000054L & l) != 0L && kind > 81) |
827 | 40 | kind = 81; |
828 | |
break; |
829 | |
case 19: |
830 | 180 | if ((0x2000000020L & l) != 0L) |
831 | 2 | jjAddStates(17, 18); |
832 | |
break; |
833 | |
case 25: |
834 | 30 | if ((0x100000001000000L & l) != 0L) |
835 | 4 | jjCheckNAdd(26); |
836 | |
break; |
837 | |
case 26: |
838 | 4 | if ((0x7e0000007eL & l) == 0L) |
839 | 0 | break; |
840 | 4 | if (kind > 80) |
841 | 4 | kind = 80; |
842 | 4 | jjCheckNAddTwoStates(26, 7); |
843 | 4 | break; |
844 | |
default : break; |
845 | |
} |
846 | 14833 | } while(i != startsAt); |
847 | 13515 | } |
848 | |
else |
849 | |
{ |
850 | 0 | int hiByte = (int)(curChar >> 8); |
851 | 0 | int i1 = hiByte >> 6; |
852 | 0 | long l1 = 1L << (hiByte & 077); |
853 | 0 | int i2 = (curChar & 0xff) >> 6; |
854 | 0 | long l2 = 1L << (curChar & 077); |
855 | |
do |
856 | |
{ |
857 | 0 | switch(jjstateSet[--i]) |
858 | |
{ |
859 | |
case 0: |
860 | |
case 1: |
861 | 0 | if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) |
862 | 0 | break; |
863 | 0 | if (kind > 64) |
864 | 0 | kind = 64; |
865 | 0 | jjCheckNAdd(1); |
866 | 0 | break; |
867 | |
default : break; |
868 | |
} |
869 | 0 | } while(i != startsAt); |
870 | |
} |
871 | 16742 | if (kind != 0x7fffffff) |
872 | |
{ |
873 | 12851 | jjmatchedKind = kind; |
874 | 12851 | jjmatchedPos = curPos; |
875 | 12851 | kind = 0x7fffffff; |
876 | |
} |
877 | 16742 | ++curPos; |
878 | 16742 | if ((i = jjnewStateCnt) == (startsAt = 27 - (jjnewStateCnt = startsAt))) |
879 | 3971 | return curPos; |
880 | 12771 | try { curChar = input_stream.readChar(); } |
881 | 12265 | catch(java.io.IOException e) { return curPos; } |
882 | |
} |
883 | |
} |
884 | |
private final int jjStopStringLiteralDfa_2(int pos, long active0, long active1) |
885 | |
{ |
886 | 0 | switch (pos) |
887 | |
{ |
888 | |
default : |
889 | 0 | return -1; |
890 | |
} |
891 | |
} |
892 | |
private final int jjStartNfa_2(int pos, long active0, long active1) |
893 | |
{ |
894 | 0 | return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1); |
895 | |
} |
896 | |
private int jjMoveStringLiteralDfa0_2() |
897 | |
{ |
898 | 4 | switch(curChar) |
899 | |
{ |
900 | |
case 96: |
901 | 2 | return jjStopAtPos(0, 76); |
902 | |
default : |
903 | 2 | return jjMoveNfa_2(0, 0); |
904 | |
} |
905 | |
} |
906 | 1 | static final long[] jjbitVec7 = { |
907 | |
0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL |
908 | |
}; |
909 | 1 | static final long[] jjbitVec8 = { |
910 | |
0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL |
911 | |
}; |
912 | |
private int jjMoveNfa_2(int startState, int curPos) |
913 | |
{ |
914 | 2 | int startsAt = 0; |
915 | 2 | jjnewStateCnt = 6; |
916 | 2 | int i = 1; |
917 | 2 | jjstateSet[0] = startState; |
918 | 2 | int kind = 0x7fffffff; |
919 | |
for (;;) |
920 | |
{ |
921 | 2 | if (++jjround == 0x7fffffff) |
922 | 0 | ReInitRounds(); |
923 | 2 | if (curChar < 64) |
924 | |
{ |
925 | 0 | long l = 1L << curChar; |
926 | |
do |
927 | |
{ |
928 | 0 | switch(jjstateSet[--i]) |
929 | |
{ |
930 | |
case 0: |
931 | 0 | if (kind > 75) |
932 | 0 | kind = 75; |
933 | |
break; |
934 | |
case 1: |
935 | 0 | if ((0x8400000000L & l) != 0L && kind > 74) |
936 | 0 | kind = 74; |
937 | |
break; |
938 | |
case 2: |
939 | 0 | if ((0xf000000000000L & l) != 0L) |
940 | 0 | jjstateSet[jjnewStateCnt++] = 3; |
941 | |
break; |
942 | |
case 3: |
943 | 0 | if ((0xff000000000000L & l) == 0L) |
944 | 0 | break; |
945 | 0 | if (kind > 74) |
946 | 0 | kind = 74; |
947 | 0 | jjstateSet[jjnewStateCnt++] = 4; |
948 | 0 | break; |
949 | |
case 4: |
950 | 0 | if ((0xff000000000000L & l) != 0L && kind > 74) |
951 | 0 | kind = 74; |
952 | |
break; |
953 | |
default : break; |
954 | |
} |
955 | 0 | } while(i != startsAt); |
956 | 0 | } |
957 | 2 | else if (curChar < 128) |
958 | |
{ |
959 | 2 | long l = 1L << (curChar & 077); |
960 | |
do |
961 | |
{ |
962 | 2 | switch(jjstateSet[--i]) |
963 | |
{ |
964 | |
case 0: |
965 | 2 | if ((0xfffffffeefffffffL & l) != 0L) |
966 | |
{ |
967 | 2 | if (kind > 75) |
968 | 2 | kind = 75; |
969 | |
} |
970 | 0 | else if (curChar == 92) |
971 | 0 | jjAddStates(19, 21); |
972 | |
break; |
973 | |
case 1: |
974 | 0 | if ((0x14404510000000L & l) != 0L && kind > 74) |
975 | 0 | kind = 74; |
976 | |
break; |
977 | |
case 5: |
978 | 0 | if ((0xfffffffeefffffffL & l) != 0L && kind > 75) |
979 | 0 | kind = 75; |
980 | |
break; |
981 | |
default : break; |
982 | |
} |
983 | 2 | } while(i != startsAt); |
984 | 2 | } |
985 | |
else |
986 | |
{ |
987 | 0 | int hiByte = (int)(curChar >> 8); |
988 | 0 | int i1 = hiByte >> 6; |
989 | 0 | long l1 = 1L << (hiByte & 077); |
990 | 0 | int i2 = (curChar & 0xff) >> 6; |
991 | 0 | long l2 = 1L << (curChar & 077); |
992 | |
do |
993 | |
{ |
994 | 0 | switch(jjstateSet[--i]) |
995 | |
{ |
996 | |
case 0: |
997 | 0 | if (jjCanMove_1(hiByte, i1, i2, l1, l2) && kind > 75) |
998 | 0 | kind = 75; |
999 | |
break; |
1000 | |
default : break; |
1001 | |
} |
1002 | 0 | } while(i != startsAt); |
1003 | |
} |
1004 | 2 | if (kind != 0x7fffffff) |
1005 | |
{ |
1006 | 2 | jjmatchedKind = kind; |
1007 | 2 | jjmatchedPos = curPos; |
1008 | 2 | kind = 0x7fffffff; |
1009 | |
} |
1010 | 2 | ++curPos; |
1011 | 2 | if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt))) |
1012 | 2 | return curPos; |
1013 | 0 | try { curChar = input_stream.readChar(); } |
1014 | 0 | catch(java.io.IOException e) { return curPos; } |
1015 | |
} |
1016 | |
} |
1017 | |
private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1) |
1018 | |
{ |
1019 | 0 | switch (pos) |
1020 | |
{ |
1021 | |
default : |
1022 | 0 | return -1; |
1023 | |
} |
1024 | |
} |
1025 | |
private final int jjStartNfa_1(int pos, long active0, long active1) |
1026 | |
{ |
1027 | 0 | return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1); |
1028 | |
} |
1029 | |
private int jjMoveStringLiteralDfa0_1() |
1030 | |
{ |
1031 | 1478 | switch(curChar) |
1032 | |
{ |
1033 | |
case 39: |
1034 | 190 | return jjStopAtPos(0, 73); |
1035 | |
default : |
1036 | 1288 | return jjMoveNfa_1(0, 0); |
1037 | |
} |
1038 | |
} |
1039 | |
private int jjMoveNfa_1(int startState, int curPos) |
1040 | |
{ |
1041 | 1288 | int startsAt = 0; |
1042 | 1288 | jjnewStateCnt = 6; |
1043 | 1288 | int i = 1; |
1044 | 1288 | jjstateSet[0] = startState; |
1045 | 1288 | int kind = 0x7fffffff; |
1046 | |
for (;;) |
1047 | |
{ |
1048 | 1304 | if (++jjround == 0x7fffffff) |
1049 | 0 | ReInitRounds(); |
1050 | 1304 | if (curChar < 64) |
1051 | |
{ |
1052 | 152 | long l = 1L << curChar; |
1053 | |
do |
1054 | |
{ |
1055 | 165 | switch(jjstateSet[--i]) |
1056 | |
{ |
1057 | |
case 0: |
1058 | 139 | if ((0xffffff7fffffffffL & l) != 0L && kind > 72) |
1059 | 139 | kind = 72; |
1060 | |
break; |
1061 | |
case 1: |
1062 | 5 | if ((0x8400000000L & l) != 0L && kind > 71) |
1063 | 0 | kind = 71; |
1064 | |
break; |
1065 | |
case 2: |
1066 | 5 | if ((0xf000000000000L & l) != 0L) |
1067 | 3 | jjstateSet[jjnewStateCnt++] = 3; |
1068 | |
break; |
1069 | |
case 3: |
1070 | 8 | if ((0xff000000000000L & l) == 0L) |
1071 | 0 | break; |
1072 | 8 | if (kind > 71) |
1073 | 8 | kind = 71; |
1074 | 8 | jjstateSet[jjnewStateCnt++] = 4; |
1075 | 8 | break; |
1076 | |
case 4: |
1077 | 8 | if ((0xff000000000000L & l) != 0L && kind > 71) |
1078 | 5 | kind = 71; |
1079 | |
break; |
1080 | |
default : break; |
1081 | |
} |
1082 | 165 | } while(i != startsAt); |
1083 | 152 | } |
1084 | 1152 | else if (curChar < 128) |
1085 | |
{ |
1086 | 1146 | long l = 1L << (curChar & 077); |
1087 | |
do |
1088 | |
{ |
1089 | 1152 | switch(jjstateSet[--i]) |
1090 | |
{ |
1091 | |
case 0: |
1092 | 1143 | if ((0xffffffffefffffffL & l) != 0L) |
1093 | |
{ |
1094 | 1135 | if (kind > 72) |
1095 | 1135 | kind = 72; |
1096 | |
} |
1097 | 8 | else if (curChar == 92) |
1098 | 8 | jjAddStates(19, 21); |
1099 | |
break; |
1100 | |
case 1: |
1101 | 3 | if ((0x14404510000000L & l) != 0L && kind > 71) |
1102 | 2 | kind = 71; |
1103 | |
break; |
1104 | |
case 5: |
1105 | 0 | if ((0xffffffffefffffffL & l) != 0L && kind > 72) |
1106 | 0 | kind = 72; |
1107 | |
break; |
1108 | |
default : break; |
1109 | |
} |
1110 | 1152 | } while(i != startsAt); |
1111 | 1146 | } |
1112 | |
else |
1113 | |
{ |
1114 | 6 | int hiByte = (int)(curChar >> 8); |
1115 | 6 | int i1 = hiByte >> 6; |
1116 | 6 | long l1 = 1L << (hiByte & 077); |
1117 | 6 | int i2 = (curChar & 0xff) >> 6; |
1118 | 6 | long l2 = 1L << (curChar & 077); |
1119 | |
do |
1120 | |
{ |
1121 | 6 | switch(jjstateSet[--i]) |
1122 | |
{ |
1123 | |
case 0: |
1124 | 6 | if (jjCanMove_1(hiByte, i1, i2, l1, l2) && kind > 72) |
1125 | 6 | kind = 72; |
1126 | |
break; |
1127 | |
default : break; |
1128 | |
} |
1129 | 6 | } while(i != startsAt); |
1130 | |
} |
1131 | 1304 | if (kind != 0x7fffffff) |
1132 | |
{ |
1133 | 1295 | jjmatchedKind = kind; |
1134 | 1295 | jjmatchedPos = curPos; |
1135 | 1295 | kind = 0x7fffffff; |
1136 | |
} |
1137 | 1304 | ++curPos; |
1138 | 1304 | if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt))) |
1139 | 1288 | return curPos; |
1140 | 16 | try { curChar = input_stream.readChar(); } |
1141 | 16 | catch(java.io.IOException e) { return curPos; } |
1142 | |
} |
1143 | |
} |
1144 | |
private final int jjStopStringLiteralDfa_3(int pos, long active0, long active1) |
1145 | |
{ |
1146 | 0 | switch (pos) |
1147 | |
{ |
1148 | |
default : |
1149 | 0 | return -1; |
1150 | |
} |
1151 | |
} |
1152 | |
private final int jjStartNfa_3(int pos, long active0, long active1) |
1153 | |
{ |
1154 | 0 | return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0, active1), pos + 1); |
1155 | |
} |
1156 | |
private int jjMoveStringLiteralDfa0_3() |
1157 | |
{ |
1158 | 1112 | switch(curChar) |
1159 | |
{ |
1160 | |
case 34: |
1161 | 235 | return jjStopAtPos(0, 79); |
1162 | |
default : |
1163 | 877 | return jjMoveNfa_3(0, 0); |
1164 | |
} |
1165 | |
} |
1166 | |
private int jjMoveNfa_3(int startState, int curPos) |
1167 | |
{ |
1168 | 877 | int startsAt = 0; |
1169 | 877 | jjnewStateCnt = 6; |
1170 | 877 | int i = 1; |
1171 | 877 | jjstateSet[0] = startState; |
1172 | 877 | int kind = 0x7fffffff; |
1173 | |
for (;;) |
1174 | |
{ |
1175 | 902 | if (++jjround == 0x7fffffff) |
1176 | 0 | ReInitRounds(); |
1177 | 902 | if (curChar < 64) |
1178 | |
{ |
1179 | 89 | long l = 1L << curChar; |
1180 | |
do |
1181 | |
{ |
1182 | 107 | switch(jjstateSet[--i]) |
1183 | |
{ |
1184 | |
case 0: |
1185 | 77 | if ((0xfffffffbffffffffL & l) != 0L && kind > 78) |
1186 | 77 | kind = 78; |
1187 | |
break; |
1188 | |
case 1: |
1189 | 8 | if ((0x8400000000L & l) != 0L && kind > 77) |
1190 | 6 | kind = 77; |
1191 | |
break; |
1192 | |
case 2: |
1193 | 8 | if ((0xf000000000000L & l) != 0L) |
1194 | 2 | jjstateSet[jjnewStateCnt++] = 3; |
1195 | |
break; |
1196 | |
case 3: |
1197 | 10 | if ((0xff000000000000L & l) == 0L) |
1198 | 6 | break; |
1199 | 4 | if (kind > 77) |
1200 | 4 | kind = 77; |
1201 | 4 | jjstateSet[jjnewStateCnt++] = 4; |
1202 | 4 | break; |
1203 | |
case 4: |
1204 | 4 | if ((0xff000000000000L & l) != 0L && kind > 77) |
1205 | 2 | kind = 77; |
1206 | |
break; |
1207 | |
default : break; |
1208 | |
} |
1209 | 107 | } while(i != startsAt); |
1210 | 89 | } |
1211 | 813 | else if (curChar < 128) |
1212 | |
{ |
1213 | 811 | long l = 1L << (curChar & 077); |
1214 | |
do |
1215 | |
{ |
1216 | 837 | switch(jjstateSet[--i]) |
1217 | |
{ |
1218 | |
case 0: |
1219 | 798 | if ((0xffffffffefffffffL & l) != 0L) |
1220 | |
{ |
1221 | 777 | if (kind > 78) |
1222 | 777 | kind = 78; |
1223 | |
} |
1224 | 21 | else if (curChar == 92) |
1225 | 21 | jjAddStates(19, 21); |
1226 | |
break; |
1227 | |
case 1: |
1228 | 13 | if ((0x14404510000000L & l) != 0L && kind > 77) |
1229 | 12 | kind = 77; |
1230 | |
break; |
1231 | |
case 5: |
1232 | 0 | if ((0xffffffffefffffffL & l) != 0L && kind > 78) |
1233 | 0 | kind = 78; |
1234 | |
break; |
1235 | |
default : break; |
1236 | |
} |
1237 | 837 | } while(i != startsAt); |
1238 | 811 | } |
1239 | |
else |
1240 | |
{ |
1241 | 2 | int hiByte = (int)(curChar >> 8); |
1242 | 2 | int i1 = hiByte >> 6; |
1243 | 2 | long l1 = 1L << (hiByte & 077); |
1244 | 2 | int i2 = (curChar & 0xff) >> 6; |
1245 | 2 | long l2 = 1L << (curChar & 077); |
1246 | |
do |
1247 | |
{ |
1248 | 2 | switch(jjstateSet[--i]) |
1249 | |
{ |
1250 | |
case 0: |
1251 | 2 | if (jjCanMove_1(hiByte, i1, i2, l1, l2) && kind > 78) |
1252 | 2 | kind = 78; |
1253 | |
break; |
1254 | |
default : break; |
1255 | |
} |
1256 | 2 | } while(i != startsAt); |
1257 | |
} |
1258 | 902 | if (kind != 0x7fffffff) |
1259 | |
{ |
1260 | 880 | jjmatchedKind = kind; |
1261 | 880 | jjmatchedPos = curPos; |
1262 | 880 | kind = 0x7fffffff; |
1263 | |
} |
1264 | 902 | ++curPos; |
1265 | 902 | if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt))) |
1266 | 877 | return curPos; |
1267 | 25 | try { curChar = input_stream.readChar(); } |
1268 | 25 | catch(java.io.IOException e) { return curPos; } |
1269 | |
} |
1270 | |
} |
1271 | 1 | static final int[] jjnextStates = { |
1272 | |
15, 16, 18, 19, 22, 13, 24, 25, 7, 9, 10, 13, 17, 10, 13, 11, |
1273 | |
12, 20, 21, 1, 2, 3, |
1274 | |
}; |
1275 | |
private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) |
1276 | |
{ |
1277 | 0 | switch(hiByte) |
1278 | |
{ |
1279 | |
case 0: |
1280 | 0 | return ((jjbitVec2[i2] & l2) != 0L); |
1281 | |
case 48: |
1282 | 0 | return ((jjbitVec3[i2] & l2) != 0L); |
1283 | |
case 49: |
1284 | 0 | return ((jjbitVec4[i2] & l2) != 0L); |
1285 | |
case 51: |
1286 | 0 | return ((jjbitVec5[i2] & l2) != 0L); |
1287 | |
case 61: |
1288 | 0 | return ((jjbitVec6[i2] & l2) != 0L); |
1289 | |
default : |
1290 | 0 | if ((jjbitVec0[i1] & l1) != 0L) |
1291 | 0 | return true; |
1292 | 0 | return false; |
1293 | |
} |
1294 | |
} |
1295 | |
private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2) |
1296 | |
{ |
1297 | 8 | switch(hiByte) |
1298 | |
{ |
1299 | |
case 0: |
1300 | 2 | return ((jjbitVec8[i2] & l2) != 0L); |
1301 | |
default : |
1302 | 6 | if ((jjbitVec7[i1] & l1) != 0L) |
1303 | 6 | return true; |
1304 | 0 | return false; |
1305 | |
} |
1306 | |
} |
1307 | |
|
1308 | |
|
1309 | 1 | public static final String[] jjstrLiteralImages = { |
1310 | |
"", "\54", "\75", "\77", "\72", "\174\174", "\157\162", "\46\46", |
1311 | |
"\141\156\144", "\174", "\142\157\162", "\136", "\170\157\162", "\46", "\142\141\156\144", |
1312 | |
"\75\75", "\145\161", "\41\75", "\156\145\161", "\74", "\154\164", "\76", "\147\164", |
1313 | |
"\74\75", "\154\164\145", "\76\75", "\147\164\145", "\151\156", "\156\157\164", |
1314 | |
"\74\74", "\163\150\154", "\76\76", "\163\150\162", "\76\76\76", "\165\163\150\162", |
1315 | |
"\53", "\55", "\52", "\57", "\45", "\176", "\41", |
1316 | |
"\151\156\163\164\141\156\143\145\157\146", "\56", "\50", "\51", "\164\162\165\145", "\146\141\154\163\145", |
1317 | |
"\156\165\154\154", "\43\164\150\151\163", "\43\162\157\157\164", "\43", "\133", "\135", "\173", |
1318 | |
"\175", "\100", "\156\145\167", "\44", null, null, null, null, null, null, null, null, |
1319 | |
null, null, null, null, null, null, null, null, null, null, null, null, null, null, |
1320 | |
null, null, null, null, null, }; |
1321 | |
|
1322 | |
|
1323 | 1 | public static final String[] lexStateNames = { |
1324 | |
"DEFAULT", |
1325 | |
"WithinCharLiteral", |
1326 | |
"WithinBackCharLiteral", |
1327 | |
"WithinStringLiteral", |
1328 | |
}; |
1329 | |
|
1330 | |
|
1331 | 1 | public static final int[] jjnewLexState = { |
1332 | |
-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, |
1333 | |
-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, |
1334 | |
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 1, 3, -1, -1, 0, -1, |
1335 | |
-1, 0, -1, -1, 0, -1, -1, -1, -1, -1, -1, |
1336 | |
}; |
1337 | 1 | static final long[] jjtoToken = { |
1338 | |
0x7ffffffffffffffL, 0x39209L, |
1339 | |
}; |
1340 | 1 | static final long[] jjtoSkip = { |
1341 | |
0xf800000000000000L, 0x0L, |
1342 | |
}; |
1343 | 1 | static final long[] jjtoMore = { |
1344 | |
0x0L, 0x6df0L, |
1345 | |
}; |
1346 | |
protected JavaCharStream input_stream; |
1347 | 1148 | private final int[] jjrounds = new int[27]; |
1348 | 1148 | private final int[] jjstateSet = new int[54]; |
1349 | 1148 | private final StringBuilder jjimage = new StringBuilder(); |
1350 | 1148 | private StringBuilder image = jjimage; |
1351 | |
private int jjimageLen; |
1352 | |
private int lengthOfMatch; |
1353 | |
protected char curChar; |
1354 | |
|
1355 | 1148 | public OgnlParserTokenManager(JavaCharStream stream){ |
1356 | |
if (JavaCharStream.staticFlag) |
1357 | |
throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); |
1358 | 1148 | input_stream = stream; |
1359 | 1148 | } |
1360 | |
|
1361 | |
|
1362 | |
public OgnlParserTokenManager(JavaCharStream stream, int lexState){ |
1363 | 0 | this(stream); |
1364 | 0 | SwitchTo(lexState); |
1365 | 0 | } |
1366 | |
|
1367 | |
|
1368 | |
public void ReInit(JavaCharStream stream) |
1369 | |
{ |
1370 | 0 | jjmatchedPos = jjnewStateCnt = 0; |
1371 | 0 | curLexState = defaultLexState; |
1372 | 0 | input_stream = stream; |
1373 | 0 | ReInitRounds(); |
1374 | 0 | } |
1375 | |
private void ReInitRounds() |
1376 | |
{ |
1377 | |
int i; |
1378 | 0 | jjround = 0x80000001; |
1379 | 0 | for (i = 27; i-- > 0;) |
1380 | 0 | jjrounds[i] = 0x80000000; |
1381 | 0 | } |
1382 | |
|
1383 | |
|
1384 | |
public void ReInit(JavaCharStream stream, int lexState) |
1385 | |
{ |
1386 | 0 | ReInit(stream); |
1387 | 0 | SwitchTo(lexState); |
1388 | 0 | } |
1389 | |
|
1390 | |
|
1391 | |
public void SwitchTo(int lexState) |
1392 | |
{ |
1393 | 0 | if (lexState >= 4 || lexState < 0) |
1394 | 0 | throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); |
1395 | |
else |
1396 | 0 | curLexState = lexState; |
1397 | 0 | } |
1398 | |
|
1399 | |
protected Token jjFillToken() |
1400 | |
{ |
1401 | |
final Token t; |
1402 | |
final String curTokenImage; |
1403 | |
final int beginLine; |
1404 | |
final int endLine; |
1405 | |
final int beginColumn; |
1406 | |
final int endColumn; |
1407 | 8275 | String im = jjstrLiteralImages[jjmatchedKind]; |
1408 | 8275 | curTokenImage = (im == null) ? input_stream.GetImage() : im; |
1409 | 8275 | beginLine = input_stream.getBeginLine(); |
1410 | 8275 | beginColumn = input_stream.getBeginColumn(); |
1411 | 8275 | endLine = input_stream.getEndLine(); |
1412 | 8275 | endColumn = input_stream.getEndColumn(); |
1413 | 8275 | t = Token.newToken(jjmatchedKind, curTokenImage); |
1414 | |
|
1415 | 8275 | t.beginLine = beginLine; |
1416 | 8275 | t.endLine = endLine; |
1417 | 8275 | t.beginColumn = beginColumn; |
1418 | 8275 | t.endColumn = endColumn; |
1419 | |
|
1420 | 8275 | return t; |
1421 | |
} |
1422 | |
|
1423 | 1148 | int curLexState = 0; |
1424 | 1148 | int defaultLexState = 0; |
1425 | |
int jjnewStateCnt; |
1426 | |
int jjround; |
1427 | |
int jjmatchedPos; |
1428 | |
int jjmatchedKind; |
1429 | |
|
1430 | |
|
1431 | |
public Token getNextToken() |
1432 | |
{ |
1433 | |
Token matchedToken; |
1434 | 8279 | int curPos = 0; |
1435 | |
|
1436 | |
EOFLoop : |
1437 | |
for (;;) |
1438 | |
{ |
1439 | |
try |
1440 | |
{ |
1441 | 8283 | curChar = input_stream.BeginToken(); |
1442 | |
} |
1443 | 1143 | catch(java.io.IOException e) |
1444 | |
{ |
1445 | 1143 | jjmatchedKind = 0; |
1446 | 1143 | matchedToken = jjFillToken(); |
1447 | 1143 | return matchedToken; |
1448 | 7140 | } |
1449 | 7140 | image = jjimage; |
1450 | 7140 | image.setLength(0); |
1451 | 7140 | jjimageLen = 0; |
1452 | |
|
1453 | |
for (;;) |
1454 | |
{ |
1455 | 9734 | switch(curLexState) |
1456 | |
{ |
1457 | |
case 0: |
1458 | 7140 | try { input_stream.backup(0); |
1459 | 8658 | while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) |
1460 | 1522 | curChar = input_stream.BeginToken(); |
1461 | |
} |
1462 | 7136 | catch (java.io.IOException e1) { continue EOFLoop; } |
1463 | 7136 | jjmatchedKind = 0x7fffffff; |
1464 | 7136 | jjmatchedPos = 0; |
1465 | 7136 | curPos = jjMoveStringLiteralDfa0_0(); |
1466 | 7136 | break; |
1467 | |
case 1: |
1468 | 1478 | jjmatchedKind = 0x7fffffff; |
1469 | 1478 | jjmatchedPos = 0; |
1470 | 1478 | curPos = jjMoveStringLiteralDfa0_1(); |
1471 | 1478 | break; |
1472 | |
case 2: |
1473 | 4 | jjmatchedKind = 0x7fffffff; |
1474 | 4 | jjmatchedPos = 0; |
1475 | 4 | curPos = jjMoveStringLiteralDfa0_2(); |
1476 | 4 | break; |
1477 | |
case 3: |
1478 | 1112 | jjmatchedKind = 0x7fffffff; |
1479 | 1112 | jjmatchedPos = 0; |
1480 | 1112 | curPos = jjMoveStringLiteralDfa0_3(); |
1481 | |
break; |
1482 | |
} |
1483 | 9730 | if (jjmatchedKind != 0x7fffffff) |
1484 | |
{ |
1485 | 9728 | if (jjmatchedPos + 1 < curPos) |
1486 | 3841 | input_stream.backup(curPos - jjmatchedPos - 1); |
1487 | 9728 | if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) |
1488 | |
{ |
1489 | 7132 | matchedToken = jjFillToken(); |
1490 | 7132 | TokenLexicalActions(matchedToken); |
1491 | 7132 | if (jjnewLexState[jjmatchedKind] != -1) |
1492 | 427 | curLexState = jjnewLexState[jjmatchedKind]; |
1493 | 7132 | return matchedToken; |
1494 | |
} |
1495 | 2596 | else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) |
1496 | |
{ |
1497 | 0 | if (jjnewLexState[jjmatchedKind] != -1) |
1498 | 0 | curLexState = jjnewLexState[jjmatchedKind]; |
1499 | |
continue EOFLoop; |
1500 | |
} |
1501 | 2596 | MoreLexicalActions(); |
1502 | 2596 | if (jjnewLexState[jjmatchedKind] != -1) |
1503 | 431 | curLexState = jjnewLexState[jjmatchedKind]; |
1504 | 2596 | curPos = 0; |
1505 | 2596 | jjmatchedKind = 0x7fffffff; |
1506 | |
try { |
1507 | 2596 | curChar = input_stream.readChar(); |
1508 | 2594 | continue; |
1509 | |
} |
1510 | 2 | catch (java.io.IOException e1) { } |
1511 | |
} |
1512 | 4 | int error_line = input_stream.getEndLine(); |
1513 | 4 | int error_column = input_stream.getEndColumn(); |
1514 | 4 | String error_after = null; |
1515 | 4 | boolean EOFSeen = false; |
1516 | 4 | try { input_stream.readChar(); input_stream.backup(1); } |
1517 | 2 | catch (java.io.IOException e1) { |
1518 | 2 | EOFSeen = true; |
1519 | 2 | error_after = curPos <= 1 ? "" : input_stream.GetImage(); |
1520 | 2 | if (curChar == '\n' || curChar == '\r') { |
1521 | 0 | error_line++; |
1522 | 0 | error_column = 0; |
1523 | |
} |
1524 | |
else |
1525 | 2 | error_column++; |
1526 | 2 | } |
1527 | 4 | if (!EOFSeen) { |
1528 | 2 | input_stream.backup(1); |
1529 | 2 | error_after = curPos <= 1 ? "" : input_stream.GetImage(); |
1530 | |
} |
1531 | 4 | throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); |
1532 | |
} |
1533 | |
} |
1534 | |
} |
1535 | |
|
1536 | |
void MoreLexicalActions() |
1537 | |
{ |
1538 | 2596 | jjimageLen += (lengthOfMatch = jjmatchedPos + 1); |
1539 | 2596 | switch(jjmatchedKind) |
1540 | |
{ |
1541 | |
case 69 : |
1542 | 192 | image.append(input_stream.GetSuffix(jjimageLen)); |
1543 | 192 | jjimageLen = 0; |
1544 | 192 | stringBuilder = new StringBuilder(); |
1545 | 192 | break; |
1546 | |
case 70 : |
1547 | 237 | image.append(input_stream.GetSuffix(jjimageLen)); |
1548 | 237 | jjimageLen = 0; |
1549 | 237 | stringBuilder = new StringBuilder(); |
1550 | 237 | break; |
1551 | |
case 71 : |
1552 | 7 | image.append(input_stream.GetSuffix(jjimageLen)); |
1553 | 7 | jjimageLen = 0; |
1554 | 7 | charValue = escapeChar(); stringBuilder.append(charValue); |
1555 | 7 | break; |
1556 | |
case 72 : |
1557 | 1280 | image.append(input_stream.GetSuffix(jjimageLen)); |
1558 | 1280 | jjimageLen = 0; |
1559 | 1280 | charValue = image.charAt( image.length()-1 ); stringBuilder.append(charValue); |
1560 | 1280 | break; |
1561 | |
case 74 : |
1562 | 0 | image.append(input_stream.GetSuffix(jjimageLen)); |
1563 | 0 | jjimageLen = 0; |
1564 | 0 | charValue = escapeChar(); |
1565 | 0 | break; |
1566 | |
case 75 : |
1567 | 2 | image.append(input_stream.GetSuffix(jjimageLen)); |
1568 | 2 | jjimageLen = 0; |
1569 | 2 | charValue = image.charAt( image.length()-1 ); |
1570 | 2 | break; |
1571 | |
case 77 : |
1572 | 20 | image.append(input_stream.GetSuffix(jjimageLen)); |
1573 | 20 | jjimageLen = 0; |
1574 | 20 | stringBuilder.append( escapeChar() ); |
1575 | 20 | break; |
1576 | |
case 78 : |
1577 | 856 | image.append(input_stream.GetSuffix(jjimageLen)); |
1578 | 856 | jjimageLen = 0; |
1579 | 856 | stringBuilder.append( image.charAt(image.length()-1) ); |
1580 | 856 | break; |
1581 | |
default : |
1582 | |
break; |
1583 | |
} |
1584 | 2596 | } |
1585 | |
void TokenLexicalActions(Token matchedToken) |
1586 | |
{ |
1587 | 7132 | switch(jjmatchedKind) |
1588 | |
{ |
1589 | |
case 67 : |
1590 | 42 | image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); |
1591 | 42 | switch (image.charAt(1)) { |
1592 | 12 | case '^': literalValue = DynamicSubscript.first; break; |
1593 | 8 | case '|': literalValue = DynamicSubscript.mid; break; |
1594 | 20 | case '$': literalValue = DynamicSubscript.last; break; |
1595 | 2 | case '*': literalValue = DynamicSubscript.all; break; |
1596 | |
} |
1597 | 42 | break; |
1598 | |
case 73 : |
1599 | 190 | image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); |
1600 | 190 | if (stringBuilder.length() == 1) { |
1601 | 42 | literalValue = new Character( charValue ); |
1602 | |
} else { |
1603 | 148 | literalValue = stringBuilder.toString(); |
1604 | |
} |
1605 | 148 | break; |
1606 | |
case 76 : |
1607 | 2 | image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); |
1608 | 2 | literalValue = new Character( charValue ); |
1609 | 2 | break; |
1610 | |
case 79 : |
1611 | 235 | image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); |
1612 | 235 | literalValue = stringBuilder.toString(); |
1613 | 235 | break; |
1614 | |
case 80 : |
1615 | 619 | image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); |
1616 | 619 | literalValue = |
1617 | |
makeInt(); |
1618 | 619 | break; |
1619 | |
case 81 : |
1620 | 76 | image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))); |
1621 | 76 | literalValue = makeFloat(); |
1622 | 76 | break; |
1623 | |
default : |
1624 | |
break; |
1625 | |
} |
1626 | 7132 | } |
1627 | |
private void jjCheckNAdd(int state) |
1628 | |
{ |
1629 | 18585 | if (jjrounds[state] != jjround) |
1630 | |
{ |
1631 | 18585 | jjstateSet[jjnewStateCnt++] = state; |
1632 | 18585 | jjrounds[state] = jjround; |
1633 | |
} |
1634 | 18585 | } |
1635 | |
private void jjAddStates(int start, int end) |
1636 | |
{ |
1637 | |
do { |
1638 | 91 | jjstateSet[jjnewStateCnt++] = jjnextStates[start]; |
1639 | 91 | } while (start++ != end); |
1640 | 31 | } |
1641 | |
private void jjCheckNAddTwoStates(int state1, int state2) |
1642 | |
{ |
1643 | 1019 | jjCheckNAdd(state1); |
1644 | 1019 | jjCheckNAdd(state2); |
1645 | 1019 | } |
1646 | |
|
1647 | |
private void jjCheckNAddStates(int start, int end) |
1648 | |
{ |
1649 | |
do { |
1650 | 4716 | jjCheckNAdd(jjnextStates[start]); |
1651 | 4716 | } while (start++ != end); |
1652 | 879 | } |
1653 | |
|
1654 | |
} |