1 | |
|
2 | |
package org.webmacro.parser; |
3 | |
|
4 | |
|
5 | |
public class WMParser_implTokenManager implements WMParser_implConstants |
6 | |
{ |
7 | |
|
8 | 13642 | void backup(int n) { input_stream.backup(n); } |
9 | |
|
10 | |
|
11 | 1678 | public java.io.PrintStream debugStream = System.out; |
12 | |
|
13 | 0 | public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } |
14 | |
private final int jjStopStringLiteralDfa_4(int pos, long active0) |
15 | |
{ |
16 | 5486 | switch (pos) |
17 | |
{ |
18 | |
case 0: |
19 | 5365 | if ((active0 & 0x400000L) != 0L) |
20 | 0 | return 2; |
21 | 5365 | return -1; |
22 | |
default : |
23 | 121 | return -1; |
24 | |
} |
25 | |
} |
26 | |
private final int jjStartNfa_4(int pos, long active0) |
27 | |
{ |
28 | 5486 | return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1); |
29 | |
} |
30 | |
private int jjStopAtPos(int pos, int kind) |
31 | |
{ |
32 | 40332 | jjmatchedKind = kind; |
33 | 40332 | jjmatchedPos = pos; |
34 | 40332 | return pos + 1; |
35 | |
} |
36 | |
private int jjMoveStringLiteralDfa0_4() |
37 | |
{ |
38 | 24275 | switch(curChar) |
39 | |
{ |
40 | |
case 35: |
41 | 7777 | jjmatchedKind = 23; |
42 | 7777 | return jjMoveStringLiteralDfa1_4(0x26000L); |
43 | |
case 36: |
44 | 1534 | return jjStopAtPos(0, 20); |
45 | |
case 92: |
46 | 128 | return jjStartNfaWithStates_4(0, 22, 2); |
47 | |
case 123: |
48 | 3045 | return jjStopAtPos(0, 15); |
49 | |
case 125: |
50 | 3196 | return jjStopAtPos(0, 12); |
51 | |
default : |
52 | 8595 | return jjMoveNfa_4(1, 0); |
53 | |
} |
54 | |
} |
55 | |
private int jjMoveStringLiteralDfa1_4(long active0) |
56 | |
{ |
57 | 7777 | try { curChar = input_stream.readChar(); } |
58 | 0 | catch(java.io.IOException e) { |
59 | 0 | jjStopStringLiteralDfa_4(0, active0); |
60 | 0 | return 1; |
61 | 7777 | } |
62 | 7777 | switch(curChar) |
63 | |
{ |
64 | |
case 35: |
65 | 2118 | if ((active0 & 0x20000L) != 0L) |
66 | 2118 | return jjStopAtPos(1, 17); |
67 | |
break; |
68 | |
case 98: |
69 | 144 | return jjMoveStringLiteralDfa2_4(active0, 0x4000L); |
70 | |
case 101: |
71 | 150 | return jjMoveStringLiteralDfa2_4(active0, 0x2000L); |
72 | |
default : |
73 | |
break; |
74 | |
} |
75 | 5365 | return jjStartNfa_4(0, active0); |
76 | |
} |
77 | |
private int jjMoveStringLiteralDfa2_4(long old0, long active0) |
78 | |
{ |
79 | 294 | if (((active0 &= old0)) == 0L) |
80 | 0 | return jjStartNfa_4(0, old0); |
81 | 294 | try { curChar = input_stream.readChar(); } |
82 | 0 | catch(java.io.IOException e) { |
83 | 0 | jjStopStringLiteralDfa_4(1, active0); |
84 | 0 | return 2; |
85 | 294 | } |
86 | 294 | switch(curChar) |
87 | |
{ |
88 | |
case 101: |
89 | 142 | return jjMoveStringLiteralDfa3_4(active0, 0x4000L); |
90 | |
case 110: |
91 | 108 | return jjMoveStringLiteralDfa3_4(active0, 0x2000L); |
92 | |
default : |
93 | |
break; |
94 | |
} |
95 | 44 | return jjStartNfa_4(1, active0); |
96 | |
} |
97 | |
private int jjMoveStringLiteralDfa3_4(long old0, long active0) |
98 | |
{ |
99 | 250 | if (((active0 &= old0)) == 0L) |
100 | 0 | return jjStartNfa_4(1, old0); |
101 | 250 | try { curChar = input_stream.readChar(); } |
102 | 0 | catch(java.io.IOException e) { |
103 | 0 | jjStopStringLiteralDfa_4(2, active0); |
104 | 0 | return 3; |
105 | 250 | } |
106 | 250 | switch(curChar) |
107 | |
{ |
108 | |
case 100: |
109 | 108 | if ((active0 & 0x2000L) != 0L) |
110 | 108 | return jjStopAtPos(3, 13); |
111 | |
break; |
112 | |
case 103: |
113 | 65 | return jjMoveStringLiteralDfa4_4(active0, 0x4000L); |
114 | |
default : |
115 | |
break; |
116 | |
} |
117 | 77 | return jjStartNfa_4(2, active0); |
118 | |
} |
119 | |
private int jjMoveStringLiteralDfa4_4(long old0, long active0) |
120 | |
{ |
121 | 65 | if (((active0 &= old0)) == 0L) |
122 | 0 | return jjStartNfa_4(2, old0); |
123 | 65 | try { curChar = input_stream.readChar(); } |
124 | 0 | catch(java.io.IOException e) { |
125 | 0 | jjStopStringLiteralDfa_4(3, active0); |
126 | 0 | return 4; |
127 | 65 | } |
128 | 65 | switch(curChar) |
129 | |
{ |
130 | |
case 105: |
131 | 65 | return jjMoveStringLiteralDfa5_4(active0, 0x4000L); |
132 | |
default : |
133 | |
break; |
134 | |
} |
135 | 0 | return jjStartNfa_4(3, active0); |
136 | |
} |
137 | |
private int jjMoveStringLiteralDfa5_4(long old0, long active0) |
138 | |
{ |
139 | 65 | if (((active0 &= old0)) == 0L) |
140 | 0 | return jjStartNfa_4(3, old0); |
141 | 65 | try { curChar = input_stream.readChar(); } |
142 | 0 | catch(java.io.IOException e) { |
143 | 0 | jjStopStringLiteralDfa_4(4, active0); |
144 | 0 | return 5; |
145 | 65 | } |
146 | 65 | switch(curChar) |
147 | |
{ |
148 | |
case 110: |
149 | 65 | if ((active0 & 0x4000L) != 0L) |
150 | 65 | return jjStopAtPos(5, 14); |
151 | |
break; |
152 | |
default : |
153 | |
break; |
154 | |
} |
155 | 0 | return jjStartNfa_4(4, active0); |
156 | |
} |
157 | |
private int jjStartNfaWithStates_4(int pos, int kind, int state) |
158 | |
{ |
159 | 128 | jjmatchedKind = kind; |
160 | 128 | jjmatchedPos = pos; |
161 | 128 | try { curChar = input_stream.readChar(); } |
162 | 128 | catch(java.io.IOException e) { return pos + 1; } |
163 | 128 | return jjMoveNfa_4(state, pos + 1); |
164 | |
} |
165 | 37 | static final long[] jjbitVec0 = { |
166 | |
0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL |
167 | |
}; |
168 | 37 | static final long[] jjbitVec2 = { |
169 | |
0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL |
170 | |
}; |
171 | |
private int jjMoveNfa_4(int startState, int curPos) |
172 | |
{ |
173 | 14209 | int startsAt = 0; |
174 | 14209 | jjnewStateCnt = 5; |
175 | 14209 | int i = 1; |
176 | 14209 | jjstateSet[0] = startState; |
177 | 14209 | int kind = 0x7fffffff; |
178 | |
for (;;) |
179 | |
{ |
180 | 210760 | if (++jjround == 0x7fffffff) |
181 | 0 | ReInitRounds(); |
182 | 210760 | if (curChar < 64) |
183 | |
{ |
184 | 53471 | long l = 1L << curChar; |
185 | |
do |
186 | |
{ |
187 | 53471 | switch(jjstateSet[--i]) |
188 | |
{ |
189 | |
case 1: |
190 | |
case 0: |
191 | 53360 | if ((0xffffffe7ffffffffL & l) == 0L) |
192 | 5845 | break; |
193 | 47515 | if (kind > 11) |
194 | 47515 | kind = 11; |
195 | 47515 | jjCheckNAdd(0); |
196 | 47515 | break; |
197 | |
case 2: |
198 | 105 | if ((0xfc00ffffffffffffL & l) != 0L) |
199 | |
{ |
200 | 105 | if (kind > 21) |
201 | 105 | kind = 21; |
202 | |
} |
203 | 105 | if (curChar == 13) |
204 | 0 | jjstateSet[jjnewStateCnt++] = 3; |
205 | |
break; |
206 | |
case 3: |
207 | 0 | if (curChar == 10 && kind > 21) |
208 | 0 | kind = 21; |
209 | |
break; |
210 | |
case 4: |
211 | 0 | if (curChar == 13) |
212 | 0 | jjstateSet[jjnewStateCnt++] = 3; |
213 | |
break; |
214 | |
default : break; |
215 | |
} |
216 | 53471 | } while(i != startsAt); |
217 | 53471 | } |
218 | 157289 | else if (curChar < 128) |
219 | |
{ |
220 | 157257 | long l = 1L << (curChar & 077); |
221 | |
do |
222 | |
{ |
223 | 157257 | switch(jjstateSet[--i]) |
224 | |
{ |
225 | |
case 1: |
226 | 1841 | if ((0xd7ffffffefffffffL & l) != 0L) |
227 | |
{ |
228 | 1841 | if (kind > 11) |
229 | 1841 | kind = 11; |
230 | 1841 | jjCheckNAdd(0); |
231 | |
} |
232 | 0 | else if (curChar == 92) |
233 | 0 | jjAddStates(0, 1); |
234 | |
break; |
235 | |
case 2: |
236 | 23 | if ((0xf8000001f8000001L & l) != 0L && kind > 21) |
237 | 23 | kind = 21; |
238 | |
break; |
239 | |
case 0: |
240 | 149913 | if ((0xd7ffffffefffffffL & l) == 0L) |
241 | 2649 | break; |
242 | 147264 | if (kind > 11) |
243 | 147264 | kind = 11; |
244 | 147264 | jjCheckNAdd(0); |
245 | 147264 | break; |
246 | |
default : break; |
247 | |
} |
248 | 157257 | } while(i != startsAt); |
249 | 157257 | } |
250 | |
else |
251 | |
{ |
252 | 32 | int hiByte = (int)(curChar >> 8); |
253 | 32 | int i1 = hiByte >> 6; |
254 | 32 | long l1 = 1L << (hiByte & 077); |
255 | 32 | int i2 = (curChar & 0xff) >> 6; |
256 | 32 | long l2 = 1L << (curChar & 077); |
257 | |
do |
258 | |
{ |
259 | 32 | switch(jjstateSet[--i]) |
260 | |
{ |
261 | |
case 1: |
262 | |
case 0: |
263 | 32 | if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) |
264 | 0 | break; |
265 | 32 | if (kind > 11) |
266 | 32 | kind = 11; |
267 | 32 | jjCheckNAdd(0); |
268 | 32 | break; |
269 | |
case 2: |
270 | 0 | if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 21) |
271 | 0 | kind = 21; |
272 | |
break; |
273 | |
default : break; |
274 | |
} |
275 | 32 | } while(i != startsAt); |
276 | |
} |
277 | 210760 | if (kind != 0x7fffffff) |
278 | |
{ |
279 | 196780 | jjmatchedKind = kind; |
280 | 196780 | jjmatchedPos = curPos; |
281 | 196780 | kind = 0x7fffffff; |
282 | |
} |
283 | 210760 | ++curPos; |
284 | 210760 | if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt))) |
285 | 14108 | return curPos; |
286 | 196652 | try { curChar = input_stream.readChar(); } |
287 | 196551 | catch(java.io.IOException e) { return curPos; } |
288 | |
} |
289 | |
} |
290 | |
private int jjMoveStringLiteralDfa0_1() |
291 | |
{ |
292 | 7237 | switch(curChar) |
293 | |
{ |
294 | |
case 34: |
295 | 3097 | return jjStopAtPos(0, 24); |
296 | |
case 36: |
297 | 1167 | return jjStopAtPos(0, 20); |
298 | |
case 92: |
299 | 1 | return jjStartNfaWithStates_1(0, 22, 1); |
300 | |
default : |
301 | 2972 | return jjMoveNfa_1(0, 0); |
302 | |
} |
303 | |
} |
304 | |
private int jjStartNfaWithStates_1(int pos, int kind, int state) |
305 | |
{ |
306 | 1 | jjmatchedKind = kind; |
307 | 1 | jjmatchedPos = pos; |
308 | 1 | try { curChar = input_stream.readChar(); } |
309 | 1 | catch(java.io.IOException e) { return pos + 1; } |
310 | 1 | return jjMoveNfa_1(state, pos + 1); |
311 | |
} |
312 | |
private int jjMoveNfa_1(int startState, int curPos) |
313 | |
{ |
314 | 2973 | int startsAt = 0; |
315 | 2973 | jjnewStateCnt = 5; |
316 | 2973 | int i = 1; |
317 | 2973 | jjstateSet[0] = startState; |
318 | 2973 | int kind = 0x7fffffff; |
319 | |
for (;;) |
320 | |
{ |
321 | 33672 | if (++jjround == 0x7fffffff) |
322 | 0 | ReInitRounds(); |
323 | 33672 | if (curChar < 64) |
324 | |
{ |
325 | 8129 | long l = 1L << curChar; |
326 | |
do |
327 | |
{ |
328 | 8129 | switch(jjstateSet[--i]) |
329 | |
{ |
330 | |
case 1: |
331 | 1 | if ((0xfc00ffffffffffffL & l) != 0L) |
332 | |
{ |
333 | 1 | if (kind > 21) |
334 | 1 | kind = 21; |
335 | |
} |
336 | 1 | if (curChar == 13) |
337 | 0 | jjstateSet[jjnewStateCnt++] = 2; |
338 | |
break; |
339 | |
case 0: |
340 | |
case 4: |
341 | 8128 | if ((0xffffffebffffdbffL & l) == 0L) |
342 | 2972 | break; |
343 | 5156 | if (kind > 57) |
344 | 5156 | kind = 57; |
345 | 5156 | jjCheckNAdd(4); |
346 | 5156 | break; |
347 | |
case 2: |
348 | 0 | if (curChar == 10 && kind > 21) |
349 | 0 | kind = 21; |
350 | |
break; |
351 | |
case 3: |
352 | 0 | if (curChar == 13) |
353 | 0 | jjstateSet[jjnewStateCnt++] = 2; |
354 | |
break; |
355 | |
default : break; |
356 | |
} |
357 | 8129 | } while(i != startsAt); |
358 | 8129 | } |
359 | 25543 | else if (curChar < 128) |
360 | |
{ |
361 | 25543 | long l = 1L << (curChar & 077); |
362 | |
do |
363 | |
{ |
364 | 25543 | switch(jjstateSet[--i]) |
365 | |
{ |
366 | |
case 1: |
367 | 0 | if ((0xf8000001f8000001L & l) != 0L && kind > 21) |
368 | 0 | kind = 21; |
369 | |
break; |
370 | |
case 0: |
371 | 2208 | if ((0xffffffffefffffffL & l) != 0L) |
372 | |
{ |
373 | 2208 | if (kind > 57) |
374 | 2208 | kind = 57; |
375 | 2208 | jjCheckNAdd(4); |
376 | |
} |
377 | 0 | else if (curChar == 92) |
378 | 0 | jjAddStates(2, 3); |
379 | |
break; |
380 | |
case 4: |
381 | 23335 | if ((0xffffffffefffffffL & l) == 0L) |
382 | 0 | break; |
383 | 23335 | if (kind > 57) |
384 | 23335 | kind = 57; |
385 | 23335 | jjCheckNAdd(4); |
386 | 23335 | break; |
387 | |
default : break; |
388 | |
} |
389 | 25543 | } while(i != startsAt); |
390 | 25543 | } |
391 | |
else |
392 | |
{ |
393 | 0 | int hiByte = (int)(curChar >> 8); |
394 | 0 | int i1 = hiByte >> 6; |
395 | 0 | long l1 = 1L << (hiByte & 077); |
396 | 0 | int i2 = (curChar & 0xff) >> 6; |
397 | 0 | long l2 = 1L << (curChar & 077); |
398 | |
do |
399 | |
{ |
400 | 0 | switch(jjstateSet[--i]) |
401 | |
{ |
402 | |
case 1: |
403 | 0 | if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 21) |
404 | 0 | kind = 21; |
405 | |
break; |
406 | |
case 0: |
407 | |
case 4: |
408 | 0 | if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) |
409 | 0 | break; |
410 | 0 | if (kind > 57) |
411 | 0 | kind = 57; |
412 | 0 | jjCheckNAdd(4); |
413 | 0 | break; |
414 | |
default : break; |
415 | |
} |
416 | 0 | } while(i != startsAt); |
417 | |
} |
418 | 33672 | if (kind != 0x7fffffff) |
419 | |
{ |
420 | 30700 | jjmatchedKind = kind; |
421 | 30700 | jjmatchedPos = curPos; |
422 | 30700 | kind = 0x7fffffff; |
423 | |
} |
424 | 33672 | ++curPos; |
425 | 33672 | if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt))) |
426 | 2973 | return curPos; |
427 | 30699 | try { curChar = input_stream.readChar(); } |
428 | 30699 | catch(java.io.IOException e) { return curPos; } |
429 | |
} |
430 | |
} |
431 | |
private int jjMoveStringLiteralDfa0_2() |
432 | |
{ |
433 | 2118 | return jjMoveNfa_2(0, 0); |
434 | |
} |
435 | |
private int jjMoveNfa_2(int startState, int curPos) |
436 | |
{ |
437 | 2118 | int startsAt = 0; |
438 | 2118 | jjnewStateCnt = 1; |
439 | 2118 | int i = 1; |
440 | 2118 | jjstateSet[0] = startState; |
441 | 2118 | int kind = 0x7fffffff; |
442 | |
for (;;) |
443 | |
{ |
444 | 54253 | if (++jjround == 0x7fffffff) |
445 | 0 | ReInitRounds(); |
446 | 54253 | if (curChar < 64) |
447 | |
{ |
448 | 10971 | long l = 1L << curChar; |
449 | |
do |
450 | |
{ |
451 | 10971 | switch(jjstateSet[--i]) |
452 | |
{ |
453 | |
case 0: |
454 | 10971 | if ((0xffffffffffffdbffL & l) == 0L) |
455 | 2116 | break; |
456 | 8855 | kind = 18; |
457 | 8855 | jjstateSet[jjnewStateCnt++] = 0; |
458 | 8855 | break; |
459 | |
default : break; |
460 | |
} |
461 | 10971 | } while(i != startsAt); |
462 | 10971 | } |
463 | 43282 | else if (curChar < 128) |
464 | |
{ |
465 | |
|
466 | |
do |
467 | |
{ |
468 | 43282 | switch(jjstateSet[--i]) |
469 | |
{ |
470 | |
case 0: |
471 | 43282 | kind = 18; |
472 | 43282 | jjstateSet[jjnewStateCnt++] = 0; |
473 | 43282 | break; |
474 | |
default : break; |
475 | |
} |
476 | 43282 | } while(i != startsAt); |
477 | |
} |
478 | |
else |
479 | |
{ |
480 | 0 | int hiByte = (int)(curChar >> 8); |
481 | 0 | int i1 = hiByte >> 6; |
482 | 0 | long l1 = 1L << (hiByte & 077); |
483 | 0 | int i2 = (curChar & 0xff) >> 6; |
484 | 0 | long l2 = 1L << (curChar & 077); |
485 | |
do |
486 | |
{ |
487 | 0 | switch(jjstateSet[--i]) |
488 | |
{ |
489 | |
case 0: |
490 | 0 | if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) |
491 | 0 | break; |
492 | 0 | if (kind > 18) |
493 | 0 | kind = 18; |
494 | 0 | jjstateSet[jjnewStateCnt++] = 0; |
495 | 0 | break; |
496 | |
default : break; |
497 | |
} |
498 | 0 | } while(i != startsAt); |
499 | |
} |
500 | 54253 | if (kind != 0x7fffffff) |
501 | |
{ |
502 | 52137 | jjmatchedKind = kind; |
503 | 52137 | jjmatchedPos = curPos; |
504 | 52137 | kind = 0x7fffffff; |
505 | |
} |
506 | 54253 | ++curPos; |
507 | 54253 | if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt))) |
508 | 2116 | return curPos; |
509 | 52137 | try { curChar = input_stream.readChar(); } |
510 | 52135 | catch(java.io.IOException e) { return curPos; } |
511 | |
} |
512 | |
} |
513 | |
private final int jjStopStringLiteralDfa_3(int pos, long active0) |
514 | |
{ |
515 | 6529 | switch (pos) |
516 | |
{ |
517 | |
case 0: |
518 | 6458 | if ((active0 & 0x400000L) != 0L) |
519 | 0 | return 4; |
520 | 6458 | if ((active0 & 0x804000L) != 0L) |
521 | 1529 | return 0; |
522 | 4929 | if ((active0 & 0x3c000000L) != 0L) |
523 | |
{ |
524 | 2471 | jjmatchedKind = 54; |
525 | 2471 | return 29; |
526 | |
} |
527 | 2458 | if ((active0 & 0xc000000000L) != 0L) |
528 | 191 | return 13; |
529 | 2267 | return -1; |
530 | |
case 1: |
531 | 71 | if ((active0 & 0x3c000000L) != 0L) |
532 | |
{ |
533 | 71 | jjmatchedKind = 54; |
534 | 71 | jjmatchedPos = 1; |
535 | 71 | return 29; |
536 | |
} |
537 | 0 | return -1; |
538 | |
case 2: |
539 | 0 | if ((active0 & 0x3c000000L) != 0L) |
540 | |
{ |
541 | 0 | jjmatchedKind = 54; |
542 | 0 | jjmatchedPos = 2; |
543 | 0 | return 29; |
544 | |
} |
545 | 0 | return -1; |
546 | |
case 3: |
547 | 0 | if ((active0 & 0x30000000L) != 0L) |
548 | |
{ |
549 | 0 | jjmatchedKind = 54; |
550 | 0 | jjmatchedPos = 3; |
551 | 0 | return 29; |
552 | |
} |
553 | 0 | if ((active0 & 0xc000000L) != 0L) |
554 | 0 | return 29; |
555 | 0 | return -1; |
556 | |
case 4: |
557 | 0 | if ((active0 & 0x20000000L) != 0L) |
558 | |
{ |
559 | 0 | jjmatchedKind = 54; |
560 | 0 | jjmatchedPos = 4; |
561 | 0 | return 29; |
562 | |
} |
563 | 0 | if ((active0 & 0x10000000L) != 0L) |
564 | 0 | return 29; |
565 | 0 | return -1; |
566 | |
case 5: |
567 | 0 | if ((active0 & 0x20000000L) != 0L) |
568 | |
{ |
569 | 0 | jjmatchedKind = 54; |
570 | 0 | jjmatchedPos = 5; |
571 | 0 | return 29; |
572 | |
} |
573 | 0 | return -1; |
574 | |
case 6: |
575 | 0 | if ((active0 & 0x20000000L) != 0L) |
576 | |
{ |
577 | 0 | jjmatchedKind = 54; |
578 | 0 | jjmatchedPos = 6; |
579 | 0 | return 29; |
580 | |
} |
581 | 0 | return -1; |
582 | |
case 7: |
583 | 0 | if ((active0 & 0x20000000L) != 0L) |
584 | |
{ |
585 | 0 | jjmatchedKind = 54; |
586 | 0 | jjmatchedPos = 7; |
587 | 0 | return 29; |
588 | |
} |
589 | 0 | return -1; |
590 | |
default : |
591 | 0 | return -1; |
592 | |
} |
593 | |
} |
594 | |
private final int jjStartNfa_3(int pos, long active0) |
595 | |
{ |
596 | 6528 | return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1); |
597 | |
} |
598 | |
private int jjMoveStringLiteralDfa0_3() |
599 | |
{ |
600 | 79861 | switch(curChar) |
601 | |
{ |
602 | |
case 34: |
603 | 3603 | return jjStopAtPos(0, 24); |
604 | |
case 35: |
605 | 1594 | jjmatchedKind = 23; |
606 | 1594 | return jjMoveStringLiteralDfa1_3(0x4000L); |
607 | |
case 36: |
608 | 9705 | return jjStopAtPos(0, 20); |
609 | |
case 39: |
610 | 58 | return jjStopAtPos(0, 25); |
611 | |
case 40: |
612 | 2548 | return jjStopAtPos(0, 32); |
613 | |
case 41: |
614 | 2590 | return jjStopAtPos(0, 33); |
615 | |
case 42: |
616 | 56 | return jjStopAtPos(0, 47); |
617 | |
case 43: |
618 | 287 | return jjStopAtPos(0, 45); |
619 | |
case 44: |
620 | 758 | return jjStopAtPos(0, 52); |
621 | |
case 45: |
622 | 61 | return jjStopAtPos(0, 46); |
623 | |
case 46: |
624 | 1324 | return jjStopAtPos(0, 37); |
625 | |
case 47: |
626 | 363 | return jjStopAtPos(0, 48); |
627 | |
case 58: |
628 | 292 | return jjStopAtPos(0, 36); |
629 | |
case 59: |
630 | 2 | return jjStopAtPos(0, 53); |
631 | |
case 60: |
632 | 240 | jjmatchedKind = 38; |
633 | 240 | return jjMoveStringLiteralDfa1_3(0x8000000000L); |
634 | |
case 61: |
635 | 2676 | jjmatchedKind = 43; |
636 | 2676 | return jjMoveStringLiteralDfa1_3(0x40000000000L); |
637 | |
case 62: |
638 | 127 | jjmatchedKind = 40; |
639 | 127 | return jjMoveStringLiteralDfa1_3(0x20000000000L); |
640 | |
case 91: |
641 | 244 | return jjStopAtPos(0, 34); |
642 | |
case 92: |
643 | 0 | return jjStartNfaWithStates_3(0, 22, 4); |
644 | |
case 93: |
645 | 244 | return jjStopAtPos(0, 35); |
646 | |
case 102: |
647 | 1486 | return jjMoveStringLiteralDfa1_3(0x10000000L); |
648 | |
case 110: |
649 | 124 | return jjMoveStringLiteralDfa1_3(0x4000000L); |
650 | |
case 116: |
651 | 1011 | return jjMoveStringLiteralDfa1_3(0x8000000L); |
652 | |
case 117: |
653 | 49 | return jjMoveStringLiteralDfa1_3(0x20000000L); |
654 | |
case 123: |
655 | 3165 | return jjStopAtPos(0, 15); |
656 | |
default : |
657 | 47254 | return jjMoveNfa_3(2, 0); |
658 | |
} |
659 | |
} |
660 | |
private int jjMoveStringLiteralDfa1_3(long active0) |
661 | |
{ |
662 | 7307 | try { curChar = input_stream.readChar(); } |
663 | 1 | catch(java.io.IOException e) { |
664 | 1 | jjStopStringLiteralDfa_3(0, active0); |
665 | 1 | return 1; |
666 | 7306 | } |
667 | 7306 | switch(curChar) |
668 | |
{ |
669 | |
case 61: |
670 | 585 | if ((active0 & 0x8000000000L) != 0L) |
671 | 49 | return jjStopAtPos(1, 39); |
672 | 536 | else if ((active0 & 0x20000000000L) != 0L) |
673 | 49 | return jjStopAtPos(1, 41); |
674 | 487 | else if ((active0 & 0x40000000000L) != 0L) |
675 | 487 | return jjStopAtPos(1, 42); |
676 | |
break; |
677 | |
case 97: |
678 | 201 | return jjMoveStringLiteralDfa2_3(active0, 0x10000000L); |
679 | |
case 98: |
680 | 69 | return jjMoveStringLiteralDfa2_3(active0, 0x4000L); |
681 | |
case 110: |
682 | 4 | return jjMoveStringLiteralDfa2_3(active0, 0x20000000L); |
683 | |
case 114: |
684 | 380 | return jjMoveStringLiteralDfa2_3(active0, 0x8000000L); |
685 | |
case 117: |
686 | 66 | return jjMoveStringLiteralDfa2_3(active0, 0x4000000L); |
687 | |
default : |
688 | |
break; |
689 | |
} |
690 | 6001 | return jjStartNfa_3(0, active0); |
691 | |
} |
692 | |
private int jjMoveStringLiteralDfa2_3(long old0, long active0) |
693 | |
{ |
694 | 720 | if (((active0 &= old0)) == 0L) |
695 | 456 | return jjStartNfa_3(0, old0); |
696 | 264 | try { curChar = input_stream.readChar(); } |
697 | 0 | catch(java.io.IOException e) { |
698 | 0 | jjStopStringLiteralDfa_3(1, active0); |
699 | 0 | return 2; |
700 | 264 | } |
701 | 264 | switch(curChar) |
702 | |
{ |
703 | |
case 100: |
704 | 4 | return jjMoveStringLiteralDfa3_3(active0, 0x20000000L); |
705 | |
case 101: |
706 | 65 | return jjMoveStringLiteralDfa3_3(active0, 0x4000L); |
707 | |
case 108: |
708 | 32 | return jjMoveStringLiteralDfa3_3(active0, 0x14000000L); |
709 | |
case 117: |
710 | 92 | return jjMoveStringLiteralDfa3_3(active0, 0x8000000L); |
711 | |
default : |
712 | |
break; |
713 | |
} |
714 | 71 | return jjStartNfa_3(1, active0); |
715 | |
} |
716 | |
private int jjMoveStringLiteralDfa3_3(long old0, long active0) |
717 | |
{ |
718 | 193 | if (((active0 &= old0)) == 0L) |
719 | 0 | return jjStartNfa_3(1, old0); |
720 | 193 | try { curChar = input_stream.readChar(); } |
721 | 0 | catch(java.io.IOException e) { |
722 | 0 | jjStopStringLiteralDfa_3(2, active0); |
723 | 0 | return 3; |
724 | 193 | } |
725 | 193 | switch(curChar) |
726 | |
{ |
727 | |
case 101: |
728 | 96 | if ((active0 & 0x8000000L) != 0L) |
729 | 92 | return jjStartNfaWithStates_3(3, 27, 29); |
730 | 4 | return jjMoveStringLiteralDfa4_3(active0, 0x20000000L); |
731 | |
case 103: |
732 | 65 | return jjMoveStringLiteralDfa4_3(active0, 0x4000L); |
733 | |
case 108: |
734 | 23 | if ((active0 & 0x4000000L) != 0L) |
735 | 23 | return jjStartNfaWithStates_3(3, 26, 29); |
736 | |
break; |
737 | |
case 115: |
738 | 9 | return jjMoveStringLiteralDfa4_3(active0, 0x10000000L); |
739 | |
default : |
740 | |
break; |
741 | |
} |
742 | 0 | return jjStartNfa_3(2, active0); |
743 | |
} |
744 | |
private int jjMoveStringLiteralDfa4_3(long old0, long active0) |
745 | |
{ |
746 | 78 | if (((active0 &= old0)) == 0L) |
747 | 0 | return jjStartNfa_3(2, old0); |
748 | 78 | try { curChar = input_stream.readChar(); } |
749 | 0 | catch(java.io.IOException e) { |
750 | 0 | jjStopStringLiteralDfa_3(3, active0); |
751 | 0 | return 4; |
752 | 78 | } |
753 | 78 | switch(curChar) |
754 | |
{ |
755 | |
case 101: |
756 | 9 | if ((active0 & 0x10000000L) != 0L) |
757 | 9 | return jjStartNfaWithStates_3(4, 28, 29); |
758 | |
break; |
759 | |
case 102: |
760 | 4 | return jjMoveStringLiteralDfa5_3(active0, 0x20000000L); |
761 | |
case 105: |
762 | 65 | return jjMoveStringLiteralDfa5_3(active0, 0x4000L); |
763 | |
default : |
764 | |
break; |
765 | |
} |
766 | 0 | return jjStartNfa_3(3, active0); |
767 | |
} |
768 | |
private int jjMoveStringLiteralDfa5_3(long old0, long active0) |
769 | |
{ |
770 | 69 | if (((active0 &= old0)) == 0L) |
771 | 0 | return jjStartNfa_3(3, old0); |
772 | 69 | try { curChar = input_stream.readChar(); } |
773 | 0 | catch(java.io.IOException e) { |
774 | 0 | jjStopStringLiteralDfa_3(4, active0); |
775 | 0 | return 5; |
776 | 69 | } |
777 | 69 | switch(curChar) |
778 | |
{ |
779 | |
case 105: |
780 | 4 | return jjMoveStringLiteralDfa6_3(active0, 0x20000000L); |
781 | |
case 110: |
782 | 65 | if ((active0 & 0x4000L) != 0L) |
783 | 65 | return jjStopAtPos(5, 14); |
784 | |
break; |
785 | |
default : |
786 | |
break; |
787 | |
} |
788 | 0 | return jjStartNfa_3(4, active0); |
789 | |
} |
790 | |
private int jjMoveStringLiteralDfa6_3(long old0, long active0) |
791 | |
{ |
792 | 4 | if (((active0 &= old0)) == 0L) |
793 | 0 | return jjStartNfa_3(4, old0); |
794 | 4 | try { curChar = input_stream.readChar(); } |
795 | 0 | catch(java.io.IOException e) { |
796 | 0 | jjStopStringLiteralDfa_3(5, active0); |
797 | 0 | return 6; |
798 | 4 | } |
799 | 4 | switch(curChar) |
800 | |
{ |
801 | |
case 110: |
802 | 4 | return jjMoveStringLiteralDfa7_3(active0, 0x20000000L); |
803 | |
default : |
804 | |
break; |
805 | |
} |
806 | 0 | return jjStartNfa_3(5, active0); |
807 | |
} |
808 | |
private int jjMoveStringLiteralDfa7_3(long old0, long active0) |
809 | |
{ |
810 | 4 | if (((active0 &= old0)) == 0L) |
811 | 0 | return jjStartNfa_3(5, old0); |
812 | 4 | try { curChar = input_stream.readChar(); } |
813 | 0 | catch(java.io.IOException e) { |
814 | 0 | jjStopStringLiteralDfa_3(6, active0); |
815 | 0 | return 7; |
816 | 4 | } |
817 | 4 | switch(curChar) |
818 | |
{ |
819 | |
case 101: |
820 | 4 | return jjMoveStringLiteralDfa8_3(active0, 0x20000000L); |
821 | |
default : |
822 | |
break; |
823 | |
} |
824 | 0 | return jjStartNfa_3(6, active0); |
825 | |
} |
826 | |
private int jjMoveStringLiteralDfa8_3(long old0, long active0) |
827 | |
{ |
828 | 4 | if (((active0 &= old0)) == 0L) |
829 | 0 | return jjStartNfa_3(6, old0); |
830 | 4 | try { curChar = input_stream.readChar(); } |
831 | 0 | catch(java.io.IOException e) { |
832 | 0 | jjStopStringLiteralDfa_3(7, active0); |
833 | 0 | return 8; |
834 | 4 | } |
835 | 4 | switch(curChar) |
836 | |
{ |
837 | |
case 100: |
838 | 4 | if ((active0 & 0x20000000L) != 0L) |
839 | 4 | return jjStartNfaWithStates_3(8, 29, 29); |
840 | |
break; |
841 | |
default : |
842 | |
break; |
843 | |
} |
844 | 0 | return jjStartNfa_3(7, active0); |
845 | |
} |
846 | |
private int jjStartNfaWithStates_3(int pos, int kind, int state) |
847 | |
{ |
848 | 128 | jjmatchedKind = kind; |
849 | 128 | jjmatchedPos = pos; |
850 | 128 | try { curChar = input_stream.readChar(); } |
851 | 126 | catch(java.io.IOException e) { return pos + 1; } |
852 | 126 | return jjMoveNfa_3(state, pos + 1); |
853 | |
} |
854 | |
private int jjMoveNfa_3(int startState, int curPos) |
855 | |
{ |
856 | 53908 | int startsAt = 0; |
857 | 53908 | jjnewStateCnt = 31; |
858 | 53908 | int i = 1; |
859 | 53908 | jjstateSet[0] = startState; |
860 | 53908 | int kind = 0x7fffffff; |
861 | |
for (;;) |
862 | |
{ |
863 | 171667 | if (++jjround == 0x7fffffff) |
864 | 0 | ReInitRounds(); |
865 | 171667 | if (curChar < 64) |
866 | |
{ |
867 | 70406 | long l = 1L << curChar; |
868 | |
do |
869 | |
{ |
870 | 70409 | switch(jjstateSet[--i]) |
871 | |
{ |
872 | |
case 4: |
873 | 0 | if ((0xfc00ffffffffffffL & l) != 0L) |
874 | |
{ |
875 | 0 | if (kind > 21) |
876 | 0 | kind = 21; |
877 | |
} |
878 | 0 | if (curChar == 13) |
879 | 0 | jjstateSet[jjnewStateCnt++] = 5; |
880 | |
break; |
881 | |
case 2: |
882 | 28987 | if ((0x3ff000000000000L & l) != 0L) |
883 | |
{ |
884 | 1496 | if (kind > 55) |
885 | 1496 | kind = 55; |
886 | 1496 | jjCheckNAdd(30); |
887 | |
} |
888 | 27491 | else if ((0x2400L & l) != 0L) |
889 | |
{ |
890 | 6434 | if (kind > 31) |
891 | 6434 | kind = 31; |
892 | |
} |
893 | 21057 | else if ((0x100000200L & l) != 0L) |
894 | |
{ |
895 | 20486 | if (kind > 30) |
896 | 20486 | kind = 30; |
897 | 20486 | jjCheckNAdd(7); |
898 | |
} |
899 | 571 | else if (curChar == 33) |
900 | |
{ |
901 | 534 | if (kind > 51) |
902 | 534 | kind = 51; |
903 | |
} |
904 | 37 | else if (curChar == 38) |
905 | 37 | jjstateSet[jjnewStateCnt++] = 15; |
906 | 0 | else if (curChar == 60) |
907 | 0 | jjstateSet[jjnewStateCnt++] = 13; |
908 | 0 | else if (curChar == 35) |
909 | 0 | jjstateSet[jjnewStateCnt++] = 0; |
910 | 28987 | if (curChar == 33) |
911 | 534 | jjstateSet[jjnewStateCnt++] = 11; |
912 | 28453 | else if (curChar == 13) |
913 | 163 | jjstateSet[jjnewStateCnt++] = 8; |
914 | |
break; |
915 | |
case 0: |
916 | 321 | if (curChar != 35) |
917 | 1 | break; |
918 | 320 | if (kind > 16) |
919 | 320 | kind = 16; |
920 | 320 | jjCheckNAdd(1); |
921 | 320 | break; |
922 | |
case 1: |
923 | 865 | if ((0xffffffffffffdbffL & l) == 0L) |
924 | 320 | break; |
925 | 545 | if (kind > 16) |
926 | 545 | kind = 16; |
927 | 545 | jjCheckNAdd(1); |
928 | 545 | break; |
929 | |
case 5: |
930 | 0 | if (curChar == 10 && kind > 21) |
931 | 0 | kind = 21; |
932 | |
break; |
933 | |
case 6: |
934 | 0 | if (curChar == 13) |
935 | 0 | jjstateSet[jjnewStateCnt++] = 5; |
936 | |
break; |
937 | |
case 7: |
938 | 15165 | if ((0x100000200L & l) == 0L) |
939 | 14724 | break; |
940 | 441 | if (kind > 30) |
941 | 441 | kind = 30; |
942 | 441 | jjCheckNAdd(7); |
943 | 441 | break; |
944 | |
case 8: |
945 | 163 | if (curChar == 10 && kind > 31) |
946 | 129 | kind = 31; |
947 | |
break; |
948 | |
case 9: |
949 | 0 | if (curChar == 13) |
950 | 0 | jjstateSet[jjnewStateCnt++] = 8; |
951 | |
break; |
952 | |
case 10: |
953 | 0 | if ((0x2400L & l) != 0L && kind > 31) |
954 | 0 | kind = 31; |
955 | |
break; |
956 | |
case 11: |
957 | 534 | if (curChar == 61 && kind > 44) |
958 | 477 | kind = 44; |
959 | |
break; |
960 | |
case 12: |
961 | 0 | if (curChar == 33) |
962 | 0 | jjstateSet[jjnewStateCnt++] = 11; |
963 | |
break; |
964 | |
case 13: |
965 | 154 | if (curChar == 62 && kind > 44) |
966 | 0 | kind = 44; |
967 | |
break; |
968 | |
case 14: |
969 | 0 | if (curChar == 60) |
970 | 0 | jjstateSet[jjnewStateCnt++] = 13; |
971 | |
break; |
972 | |
case 15: |
973 | 31 | if (curChar == 38 && kind > 49) |
974 | 31 | kind = 49; |
975 | |
break; |
976 | |
case 16: |
977 | 0 | if (curChar == 38) |
978 | 0 | jjstateSet[jjnewStateCnt++] = 15; |
979 | |
break; |
980 | |
case 24: |
981 | 0 | if (curChar == 33 && kind > 51) |
982 | 0 | kind = 51; |
983 | |
break; |
984 | |
case 29: |
985 | 20421 | if ((0x3ff000000000000L & l) == 0L) |
986 | 18755 | break; |
987 | 1666 | if (kind > 54) |
988 | 1666 | kind = 54; |
989 | 1666 | jjstateSet[jjnewStateCnt++] = 29; |
990 | 1666 | break; |
991 | |
case 30: |
992 | 1572 | if ((0x3ff000000000000L & l) == 0L) |
993 | 1483 | break; |
994 | 89 | if (kind > 55) |
995 | 89 | kind = 55; |
996 | 89 | jjCheckNAdd(30); |
997 | 89 | break; |
998 | |
default : break; |
999 | |
} |
1000 | 70409 | } while(i != startsAt); |
1001 | 70406 | } |
1002 | 101261 | else if (curChar < 128) |
1003 | |
{ |
1004 | 101261 | long l = 1L << (curChar & 077); |
1005 | |
do |
1006 | |
{ |
1007 | 102217 | switch(jjstateSet[--i]) |
1008 | |
{ |
1009 | |
case 4: |
1010 | 0 | if ((0xf8000001f8000001L & l) != 0L && kind > 21) |
1011 | 0 | kind = 21; |
1012 | |
break; |
1013 | |
case 2: |
1014 | 18267 | if ((0x7fffffe07fffffeL & l) != 0L) |
1015 | |
{ |
1016 | 17771 | if (kind > 54) |
1017 | 17771 | kind = 54; |
1018 | 17771 | jjCheckNAdd(29); |
1019 | |
} |
1020 | 496 | else if (curChar == 124) |
1021 | 178 | jjstateSet[jjnewStateCnt++] = 20; |
1022 | 318 | else if (curChar == 92) |
1023 | 0 | jjAddStates(4, 5); |
1024 | 18267 | if (curChar == 78) |
1025 | 808 | jjstateSet[jjnewStateCnt++] = 26; |
1026 | 17459 | else if (curChar == 79) |
1027 | 41 | jjstateSet[jjnewStateCnt++] = 22; |
1028 | 17418 | else if (curChar == 65) |
1029 | 107 | jjstateSet[jjnewStateCnt++] = 18; |
1030 | |
break; |
1031 | |
case 1: |
1032 | 3224 | if (kind > 16) |
1033 | 3224 | kind = 16; |
1034 | 3224 | jjstateSet[jjnewStateCnt++] = 1; |
1035 | 3224 | break; |
1036 | |
case 3: |
1037 | 0 | if (curChar == 92) |
1038 | 0 | jjAddStates(4, 5); |
1039 | |
break; |
1040 | |
case 17: |
1041 | 4 | if (curChar == 68 && kind > 49) |
1042 | 4 | kind = 49; |
1043 | |
break; |
1044 | |
case 18: |
1045 | 103 | if (curChar == 78) |
1046 | 4 | jjstateSet[jjnewStateCnt++] = 17; |
1047 | |
break; |
1048 | |
case 19: |
1049 | 0 | if (curChar == 65) |
1050 | 0 | jjstateSet[jjnewStateCnt++] = 18; |
1051 | |
break; |
1052 | |
case 20: |
1053 | 178 | if (curChar == 124 && kind > 50) |
1054 | 178 | kind = 50; |
1055 | |
break; |
1056 | |
case 21: |
1057 | 0 | if (curChar == 124) |
1058 | 0 | jjstateSet[jjnewStateCnt++] = 20; |
1059 | |
break; |
1060 | |
case 22: |
1061 | 41 | if (curChar == 82 && kind > 50) |
1062 | 4 | kind = 50; |
1063 | |
break; |
1064 | |
case 23: |
1065 | 0 | if (curChar == 79) |
1066 | 0 | jjstateSet[jjnewStateCnt++] = 22; |
1067 | |
break; |
1068 | |
case 25: |
1069 | 0 | if (curChar == 84 && kind > 51) |
1070 | 0 | kind = 51; |
1071 | |
break; |
1072 | |
case 26: |
1073 | 808 | if (curChar == 79) |
1074 | 0 | jjstateSet[jjnewStateCnt++] = 25; |
1075 | |
break; |
1076 | |
case 27: |
1077 | 0 | if (curChar == 78) |
1078 | 0 | jjstateSet[jjnewStateCnt++] = 26; |
1079 | |
break; |
1080 | |
case 28: |
1081 | 0 | if ((0x7fffffe07fffffeL & l) == 0L) |
1082 | 0 | break; |
1083 | 0 | if (kind > 54) |
1084 | 0 | kind = 54; |
1085 | 0 | jjCheckNAdd(29); |
1086 | 0 | break; |
1087 | |
case 29: |
1088 | 72511 | if ((0x7fffffe87fffffeL & l) == 0L) |
1089 | 1298 | break; |
1090 | 71213 | if (kind > 54) |
1091 | 71209 | kind = 54; |
1092 | 71213 | jjCheckNAdd(29); |
1093 | 71213 | break; |
1094 | |
default : break; |
1095 | |
} |
1096 | 102217 | } while(i != startsAt); |
1097 | 101261 | } |
1098 | |
else |
1099 | |
{ |
1100 | 0 | int hiByte = (int)(curChar >> 8); |
1101 | 0 | int i1 = hiByte >> 6; |
1102 | 0 | long l1 = 1L << (hiByte & 077); |
1103 | 0 | int i2 = (curChar & 0xff) >> 6; |
1104 | 0 | long l2 = 1L << (curChar & 077); |
1105 | |
do |
1106 | |
{ |
1107 | 0 | switch(jjstateSet[--i]) |
1108 | |
{ |
1109 | |
case 4: |
1110 | 0 | if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 21) |
1111 | 0 | kind = 21; |
1112 | |
break; |
1113 | |
case 1: |
1114 | 0 | if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) |
1115 | 0 | break; |
1116 | 0 | if (kind > 16) |
1117 | 0 | kind = 16; |
1118 | 0 | jjstateSet[jjnewStateCnt++] = 1; |
1119 | 0 | break; |
1120 | |
default : break; |
1121 | |
} |
1122 | 0 | } while(i != startsAt); |
1123 | |
} |
1124 | 171667 | if (kind != 0x7fffffff) |
1125 | |
{ |
1126 | 125034 | jjmatchedKind = kind; |
1127 | 125034 | jjmatchedPos = curPos; |
1128 | 125034 | kind = 0x7fffffff; |
1129 | |
} |
1130 | 171667 | ++curPos; |
1131 | 171667 | if ((i = jjnewStateCnt) == (startsAt = 31 - (jjnewStateCnt = startsAt))) |
1132 | 53504 | return curPos; |
1133 | 118163 | try { curChar = input_stream.readChar(); } |
1134 | 117759 | catch(java.io.IOException e) { return curPos; } |
1135 | |
} |
1136 | |
} |
1137 | |
private int jjMoveStringLiteralDfa0_0() |
1138 | |
{ |
1139 | 104 | switch(curChar) |
1140 | |
{ |
1141 | |
case 36: |
1142 | 1 | return jjStopAtPos(0, 20); |
1143 | |
case 39: |
1144 | 51 | return jjStopAtPos(0, 25); |
1145 | |
case 92: |
1146 | 3 | return jjStartNfaWithStates_0(0, 22, 1); |
1147 | |
default : |
1148 | 49 | return jjMoveNfa_0(0, 0); |
1149 | |
} |
1150 | |
} |
1151 | |
private int jjStartNfaWithStates_0(int pos, int kind, int state) |
1152 | |
{ |
1153 | 3 | jjmatchedKind = kind; |
1154 | 3 | jjmatchedPos = pos; |
1155 | 3 | try { curChar = input_stream.readChar(); } |
1156 | 3 | catch(java.io.IOException e) { return pos + 1; } |
1157 | 3 | return jjMoveNfa_0(state, pos + 1); |
1158 | |
} |
1159 | |
private int jjMoveNfa_0(int startState, int curPos) |
1160 | |
{ |
1161 | 52 | int startsAt = 0; |
1162 | 52 | jjnewStateCnt = 5; |
1163 | 52 | int i = 1; |
1164 | 52 | jjstateSet[0] = startState; |
1165 | 52 | int kind = 0x7fffffff; |
1166 | |
for (;;) |
1167 | |
{ |
1168 | 272 | if (++jjround == 0x7fffffff) |
1169 | 0 | ReInitRounds(); |
1170 | 272 | if (curChar < 64) |
1171 | |
{ |
1172 | 66 | long l = 1L << curChar; |
1173 | |
do |
1174 | |
{ |
1175 | 66 | switch(jjstateSet[--i]) |
1176 | |
{ |
1177 | |
case 1: |
1178 | 3 | if ((0xfc00ffffffffffffL & l) != 0L) |
1179 | |
{ |
1180 | 3 | if (kind > 21) |
1181 | 3 | kind = 21; |
1182 | |
} |
1183 | 3 | if (curChar == 13) |
1184 | 0 | jjstateSet[jjnewStateCnt++] = 2; |
1185 | |
break; |
1186 | |
case 0: |
1187 | |
case 4: |
1188 | 63 | if ((0xffffff6fffffdbffL & l) == 0L) |
1189 | 47 | break; |
1190 | 16 | if (kind > 58) |
1191 | 16 | kind = 58; |
1192 | 16 | jjCheckNAdd(4); |
1193 | 16 | break; |
1194 | |
case 2: |
1195 | 0 | if (curChar == 10 && kind > 21) |
1196 | 0 | kind = 21; |
1197 | |
break; |
1198 | |
case 3: |
1199 | 0 | if (curChar == 13) |
1200 | 0 | jjstateSet[jjnewStateCnt++] = 2; |
1201 | |
break; |
1202 | |
default : break; |
1203 | |
} |
1204 | 66 | } while(i != startsAt); |
1205 | 66 | } |
1206 | 206 | else if (curChar < 128) |
1207 | |
{ |
1208 | 206 | long l = 1L << (curChar & 077); |
1209 | |
do |
1210 | |
{ |
1211 | 206 | switch(jjstateSet[--i]) |
1212 | |
{ |
1213 | |
case 1: |
1214 | 0 | if ((0xf8000001f8000001L & l) != 0L && kind > 21) |
1215 | 0 | kind = 21; |
1216 | |
break; |
1217 | |
case 0: |
1218 | 46 | if ((0xffffffffefffffffL & l) != 0L) |
1219 | |
{ |
1220 | 46 | if (kind > 58) |
1221 | 46 | kind = 58; |
1222 | 46 | jjCheckNAdd(4); |
1223 | |
} |
1224 | 0 | else if (curChar == 92) |
1225 | 0 | jjAddStates(2, 3); |
1226 | |
break; |
1227 | |
case 4: |
1228 | 160 | if ((0xffffffffefffffffL & l) == 0L) |
1229 | 2 | break; |
1230 | 158 | if (kind > 58) |
1231 | 158 | kind = 58; |
1232 | 158 | jjCheckNAdd(4); |
1233 | 158 | break; |
1234 | |
default : break; |
1235 | |
} |
1236 | 206 | } while(i != startsAt); |
1237 | 206 | } |
1238 | |
else |
1239 | |
{ |
1240 | 0 | int hiByte = (int)(curChar >> 8); |
1241 | 0 | int i1 = hiByte >> 6; |
1242 | 0 | long l1 = 1L << (hiByte & 077); |
1243 | 0 | int i2 = (curChar & 0xff) >> 6; |
1244 | 0 | long l2 = 1L << (curChar & 077); |
1245 | |
do |
1246 | |
{ |
1247 | 0 | switch(jjstateSet[--i]) |
1248 | |
{ |
1249 | |
case 1: |
1250 | 0 | if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 21) |
1251 | 0 | kind = 21; |
1252 | |
break; |
1253 | |
case 0: |
1254 | |
case 4: |
1255 | 0 | if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) |
1256 | 0 | break; |
1257 | 0 | if (kind > 58) |
1258 | 0 | kind = 58; |
1259 | 0 | jjCheckNAdd(4); |
1260 | 0 | break; |
1261 | |
default : break; |
1262 | |
} |
1263 | 0 | } while(i != startsAt); |
1264 | |
} |
1265 | 272 | if (kind != 0x7fffffff) |
1266 | |
{ |
1267 | 223 | jjmatchedKind = kind; |
1268 | 223 | jjmatchedPos = curPos; |
1269 | 223 | kind = 0x7fffffff; |
1270 | |
} |
1271 | 272 | ++curPos; |
1272 | 272 | if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt))) |
1273 | 52 | return curPos; |
1274 | 220 | try { curChar = input_stream.readChar(); } |
1275 | 220 | catch(java.io.IOException e) { return curPos; } |
1276 | |
} |
1277 | |
} |
1278 | 37 | static final int[] jjnextStates = { |
1279 | |
2, 4, 1, 3, 4, 6, |
1280 | |
}; |
1281 | |
private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) |
1282 | |
{ |
1283 | 32 | switch(hiByte) |
1284 | |
{ |
1285 | |
case 0: |
1286 | 8 | return ((jjbitVec2[i2] & l2) != 0L); |
1287 | |
default : |
1288 | 24 | if ((jjbitVec0[i1] & l1) != 0L) |
1289 | 24 | return true; |
1290 | 0 | return false; |
1291 | |
} |
1292 | |
} |
1293 | |
|
1294 | |
|
1295 | 37 | public static final String[] jjstrLiteralImages = { |
1296 | |
"", null, null, null, null, null, null, null, null, null, null, null, "\175", |
1297 | |
"\43\145\156\144", "\43\142\145\147\151\156", "\173", null, "\43\43", null, null, "\44", null, |
1298 | |
"\134", "\43", "\42", "\47", "\156\165\154\154", "\164\162\165\145", |
1299 | |
"\146\141\154\163\145", "\165\156\144\145\146\151\156\145\144", null, null, "\50", "\51", "\133", |
1300 | |
"\135", "\72", "\56", "\74", "\74\75", "\76", "\76\75", "\75\75", "\75", null, "\53", |
1301 | |
"\55", "\52", "\57", null, null, null, "\54", "\73", null, null, null, null, null, }; |
1302 | |
|
1303 | |
|
1304 | 37 | public static final String[] lexStateNames = { |
1305 | |
"SQS", |
1306 | |
"QS", |
1307 | |
"COMMENT", |
1308 | |
"WM", |
1309 | |
"DEFAULT", |
1310 | |
}; |
1311 | |
|
1312 | |
|
1313 | 37 | public static final int[] jjnewLexState = { |
1314 | |
-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, |
1315 | |
-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, |
1316 | |
-1, -1, -1, -1, -1, -1, -1, -1, -1, |
1317 | |
}; |
1318 | 37 | static final long[] jjtoToken = { |
1319 | |
0x7fffffffffef801L, |
1320 | |
}; |
1321 | 37 | static final long[] jjtoSkip = { |
1322 | |
0x10000L, |
1323 | |
}; |
1324 | 37 | static final long[] jjtoSpecial = { |
1325 | |
0x10000L, |
1326 | |
}; |
1327 | |
protected CharStream input_stream; |
1328 | 1678 | private final int[] jjrounds = new int[31]; |
1329 | 1678 | private final int[] jjstateSet = new int[62]; |
1330 | 1678 | private final StringBuffer jjimage = new StringBuffer(); |
1331 | 1678 | private StringBuffer image = jjimage; |
1332 | |
protected char curChar; |
1333 | |
|
1334 | 1678 | public WMParser_implTokenManager(CharStream stream){ |
1335 | 1678 | input_stream = stream; |
1336 | 1678 | } |
1337 | |
|
1338 | |
|
1339 | |
public WMParser_implTokenManager(CharStream stream, int lexState){ |
1340 | 0 | this(stream); |
1341 | 0 | SwitchTo(lexState); |
1342 | 0 | } |
1343 | |
|
1344 | |
|
1345 | |
public void ReInit(CharStream stream) |
1346 | |
{ |
1347 | 0 | jjmatchedPos = jjnewStateCnt = 0; |
1348 | 0 | curLexState = defaultLexState; |
1349 | 0 | input_stream = stream; |
1350 | 0 | ReInitRounds(); |
1351 | 0 | } |
1352 | |
private void ReInitRounds() |
1353 | |
{ |
1354 | |
int i; |
1355 | 0 | jjround = 0x80000001; |
1356 | 0 | for (i = 31; i-- > 0;) |
1357 | 0 | jjrounds[i] = 0x80000000; |
1358 | 0 | } |
1359 | |
|
1360 | |
|
1361 | |
public void ReInit(CharStream stream, int lexState) |
1362 | |
{ |
1363 | 0 | ReInit(stream); |
1364 | 0 | SwitchTo(lexState); |
1365 | 0 | } |
1366 | |
|
1367 | |
|
1368 | |
public void SwitchTo(int lexState) |
1369 | |
{ |
1370 | 38640 | if (lexState >= 5 || lexState < 0) |
1371 | 0 | throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); |
1372 | |
else |
1373 | 38640 | curLexState = lexState; |
1374 | 38640 | } |
1375 | |
|
1376 | |
protected Token jjFillToken() |
1377 | |
{ |
1378 | |
final Token t; |
1379 | |
final String tokenImage; |
1380 | |
final int beginLine; |
1381 | |
final int endLine; |
1382 | |
final int beginColumn; |
1383 | |
final int endColumn; |
1384 | 116830 | if (jjmatchedPos < 0) |
1385 | |
{ |
1386 | 0 | if (image == null) |
1387 | 0 | tokenImage = ""; |
1388 | |
else |
1389 | 0 | tokenImage = image.toString(); |
1390 | 0 | beginLine = endLine = input_stream.getBeginLine(); |
1391 | 0 | beginColumn = endColumn = input_stream.getBeginColumn(); |
1392 | |
} |
1393 | |
else |
1394 | |
{ |
1395 | 116830 | String im = jjstrLiteralImages[jjmatchedKind]; |
1396 | 116830 | tokenImage = (im == null) ? input_stream.GetImage() : im; |
1397 | 116830 | beginLine = input_stream.getBeginLine(); |
1398 | 116830 | beginColumn = input_stream.getBeginColumn(); |
1399 | 116830 | endLine = input_stream.getEndLine(); |
1400 | 116830 | endColumn = input_stream.getEndColumn(); |
1401 | |
} |
1402 | 116830 | t = Token.newToken(jjmatchedKind, tokenImage); |
1403 | |
|
1404 | 116830 | t.beginLine = beginLine; |
1405 | 116830 | t.endLine = endLine; |
1406 | 116830 | t.beginColumn = beginColumn; |
1407 | 116830 | t.endColumn = endColumn; |
1408 | |
|
1409 | 116830 | return t; |
1410 | |
} |
1411 | |
|
1412 | 1678 | int curLexState = 4; |
1413 | 1678 | int defaultLexState = 4; |
1414 | |
int jjnewStateCnt; |
1415 | |
int jjround; |
1416 | |
int jjmatchedPos; |
1417 | |
int jjmatchedKind; |
1418 | |
|
1419 | |
|
1420 | |
public Token getNextToken() |
1421 | |
{ |
1422 | 116510 | Token specialToken = null; |
1423 | |
Token matchedToken; |
1424 | 116510 | int curPos = 0; |
1425 | |
|
1426 | |
EOFLoop : |
1427 | |
for (;;) |
1428 | |
{ |
1429 | |
try |
1430 | |
{ |
1431 | 116830 | curChar = input_stream.BeginToken(); |
1432 | |
} |
1433 | 3235 | catch(java.io.IOException e) |
1434 | |
{ |
1435 | 3235 | jjmatchedKind = 0; |
1436 | 3235 | matchedToken = jjFillToken(); |
1437 | 3235 | matchedToken.specialToken = specialToken; |
1438 | 3235 | return matchedToken; |
1439 | 113595 | } |
1440 | 113595 | image = jjimage; |
1441 | 113595 | image.setLength(0); |
1442 | |
|
1443 | 113595 | switch(curLexState) |
1444 | |
{ |
1445 | |
case 0: |
1446 | 104 | jjmatchedKind = 0x7fffffff; |
1447 | 104 | jjmatchedPos = 0; |
1448 | 104 | curPos = jjMoveStringLiteralDfa0_0(); |
1449 | 104 | break; |
1450 | |
case 1: |
1451 | 7237 | jjmatchedKind = 0x7fffffff; |
1452 | 7237 | jjmatchedPos = 0; |
1453 | 7237 | curPos = jjMoveStringLiteralDfa0_1(); |
1454 | 7237 | break; |
1455 | |
case 2: |
1456 | 2118 | jjmatchedKind = 18; |
1457 | 2118 | jjmatchedPos = -1; |
1458 | 2118 | curPos = 0; |
1459 | 2118 | curPos = jjMoveStringLiteralDfa0_2(); |
1460 | 2118 | if (jjmatchedPos < 0 || (jjmatchedPos == 0 && jjmatchedKind > 19)) |
1461 | |
{ |
1462 | 707 | jjmatchedKind = 19; |
1463 | 707 | jjmatchedPos = 0; |
1464 | |
} |
1465 | |
break; |
1466 | |
case 3: |
1467 | 79861 | jjmatchedKind = 0x7fffffff; |
1468 | 79861 | jjmatchedPos = 0; |
1469 | 79861 | curPos = jjMoveStringLiteralDfa0_3(); |
1470 | 79861 | if (jjmatchedPos == 0 && jjmatchedKind > 56) |
1471 | |
{ |
1472 | 324 | jjmatchedKind = 56; |
1473 | |
} |
1474 | |
break; |
1475 | |
case 4: |
1476 | 24275 | jjmatchedKind = 0x7fffffff; |
1477 | 24275 | jjmatchedPos = 0; |
1478 | 24275 | curPos = jjMoveStringLiteralDfa0_4(); |
1479 | |
break; |
1480 | |
} |
1481 | 113595 | if (jjmatchedKind != 0x7fffffff) |
1482 | |
{ |
1483 | 113595 | if (jjmatchedPos + 1 < curPos) |
1484 | 64510 | input_stream.backup(curPos - jjmatchedPos - 1); |
1485 | 113595 | if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) |
1486 | |
{ |
1487 | 113275 | matchedToken = jjFillToken(); |
1488 | 113275 | matchedToken.specialToken = specialToken; |
1489 | 113275 | TokenLexicalActions(matchedToken); |
1490 | 113275 | if (jjnewLexState[jjmatchedKind] != -1) |
1491 | 0 | curLexState = jjnewLexState[jjmatchedKind]; |
1492 | 113275 | return matchedToken; |
1493 | |
} |
1494 | |
else |
1495 | |
{ |
1496 | 320 | if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) |
1497 | |
{ |
1498 | 320 | matchedToken = jjFillToken(); |
1499 | 320 | if (specialToken == null) |
1500 | 320 | specialToken = matchedToken; |
1501 | |
else |
1502 | |
{ |
1503 | 0 | matchedToken.specialToken = specialToken; |
1504 | 0 | specialToken = (specialToken.next = matchedToken); |
1505 | |
} |
1506 | |
} |
1507 | 320 | if (jjnewLexState[jjmatchedKind] != -1) |
1508 | 0 | curLexState = jjnewLexState[jjmatchedKind]; |
1509 | |
continue EOFLoop; |
1510 | |
} |
1511 | |
} |
1512 | 0 | int error_line = input_stream.getEndLine(); |
1513 | 0 | int error_column = input_stream.getEndColumn(); |
1514 | 0 | String error_after = null; |
1515 | 0 | boolean EOFSeen = false; |
1516 | 0 | try { input_stream.readChar(); input_stream.backup(1); } |
1517 | 0 | catch (java.io.IOException e1) { |
1518 | 0 | EOFSeen = true; |
1519 | 0 | error_after = curPos <= 1 ? "" : input_stream.GetImage(); |
1520 | 0 | if (curChar == '\n' || curChar == '\r') { |
1521 | 0 | error_line++; |
1522 | 0 | error_column = 0; |
1523 | |
} |
1524 | |
else |
1525 | 0 | error_column++; |
1526 | 0 | } |
1527 | 0 | if (!EOFSeen) { |
1528 | 0 | input_stream.backup(1); |
1529 | 0 | error_after = curPos <= 1 ? "" : input_stream.GetImage(); |
1530 | |
} |
1531 | 0 | throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); |
1532 | |
} |
1533 | |
} |
1534 | |
|
1535 | |
void TokenLexicalActions(Token matchedToken) |
1536 | |
{ |
1537 | 113275 | switch(jjmatchedKind) |
1538 | |
{ |
1539 | |
default : |
1540 | |
break; |
1541 | |
} |
1542 | 113275 | } |
1543 | |
private void jjCheckNAdd(int state) |
1544 | |
{ |
1545 | 339932 | if (jjrounds[state] != jjround) |
1546 | |
{ |
1547 | 339932 | jjstateSet[jjnewStateCnt++] = state; |
1548 | 339932 | jjrounds[state] = jjround; |
1549 | |
} |
1550 | 339932 | } |
1551 | |
private void jjAddStates(int start, int end) |
1552 | |
{ |
1553 | |
do { |
1554 | 0 | jjstateSet[jjnewStateCnt++] = jjnextStates[start]; |
1555 | 0 | } while (start++ != end); |
1556 | 0 | } |
1557 | |
|
1558 | |
} |