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