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