1
2 package org.glassbox.dotparser;
3 import java.io.*;
4
5 public class DOTParserTokenManager implements DOTParserConstants
6 {
7 public java.io.PrintStream debugStream = System.out;
8 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
9 private final int jjStopAtPos(int pos, int kind)
10 {
11 jjmatchedKind = kind;
12 jjmatchedPos = pos;
13 return pos + 1;
14 }
15 private final int jjMoveStringLiteralDfa0_0()
16 {
17 switch(curChar)
18 {
19 case 9:
20 jjmatchedKind = 2;
21 return jjMoveNfa_0(0, 0);
22 case 10:
23 jjmatchedKind = 3;
24 return jjMoveNfa_0(0, 0);
25 case 12:
26 jjmatchedKind = 5;
27 return jjMoveNfa_0(0, 0);
28 case 13:
29 jjmatchedKind = 4;
30 return jjMoveNfa_0(0, 0);
31 case 32:
32 jjmatchedKind = 1;
33 return jjMoveNfa_0(0, 0);
34 case 44:
35 jjmatchedKind = 24;
36 return jjMoveNfa_0(0, 0);
37 case 45:
38 return jjMoveStringLiteralDfa1_0(0x300000L);
39 case 47:
40 return jjMoveStringLiteralDfa1_0(0xc0L);
41 case 58:
42 jjmatchedKind = 26;
43 return jjMoveNfa_0(0, 0);
44 case 59:
45 jjmatchedKind = 25;
46 return jjMoveNfa_0(0, 0);
47 case 61:
48 jjmatchedKind = 17;
49 return jjMoveNfa_0(0, 0);
50 case 68:
51 return jjMoveStringLiteralDfa1_0(0x800L);
52 case 69:
53 return jjMoveStringLiteralDfa1_0(0x1000L);
54 case 71:
55 return jjMoveStringLiteralDfa1_0(0x2000L);
56 case 78:
57 return jjMoveStringLiteralDfa1_0(0x4000L);
58 case 83:
59 return jjMoveStringLiteralDfa1_0(0x18000L);
60 case 91:
61 jjmatchedKind = 22;
62 return jjMoveNfa_0(0, 0);
63 case 93:
64 jjmatchedKind = 23;
65 return jjMoveNfa_0(0, 0);
66 case 100:
67 return jjMoveStringLiteralDfa1_0(0x800L);
68 case 101:
69 return jjMoveStringLiteralDfa1_0(0x1000L);
70 case 103:
71 return jjMoveStringLiteralDfa1_0(0x2000L);
72 case 110:
73 return jjMoveStringLiteralDfa1_0(0x4000L);
74 case 115:
75 return jjMoveStringLiteralDfa1_0(0x18000L);
76 case 123:
77 jjmatchedKind = 18;
78 return jjMoveNfa_0(0, 0);
79 case 125:
80 jjmatchedKind = 19;
81 return jjMoveNfa_0(0, 0);
82 default :
83 return jjMoveNfa_0(0, 0);
84 }
85 }
86 private final int jjMoveStringLiteralDfa1_0(long active0)
87 {
88 try { curChar = input_stream.readChar(); }
89 catch(java.io.IOException e) {
90 return jjMoveNfa_0(0, 0);
91 }
92 switch(curChar)
93 {
94 case 42:
95 if ((active0 & 0x80L) != 0L)
96 {
97 jjmatchedKind = 7;
98 jjmatchedPos = 1;
99 }
100 break;
101 case 45:
102 if ((active0 & 0x100000L) != 0L)
103 {
104 jjmatchedKind = 20;
105 jjmatchedPos = 1;
106 }
107 break;
108 case 47:
109 if ((active0 & 0x40L) != 0L)
110 {
111 jjmatchedKind = 6;
112 jjmatchedPos = 1;
113 }
114 break;
115 case 62:
116 if ((active0 & 0x200000L) != 0L)
117 {
118 jjmatchedKind = 21;
119 jjmatchedPos = 1;
120 }
121 break;
122 case 68:
123 return jjMoveStringLiteralDfa2_0(active0, 0x1000L);
124 case 73:
125 return jjMoveStringLiteralDfa2_0(active0, 0x800L);
126 case 79:
127 return jjMoveStringLiteralDfa2_0(active0, 0x4000L);
128 case 82:
129 return jjMoveStringLiteralDfa2_0(active0, 0x2000L);
130 case 84:
131 return jjMoveStringLiteralDfa2_0(active0, 0x8000L);
132 case 85:
133 return jjMoveStringLiteralDfa2_0(active0, 0x10000L);
134 case 100:
135 return jjMoveStringLiteralDfa2_0(active0, 0x1000L);
136 case 105:
137 return jjMoveStringLiteralDfa2_0(active0, 0x800L);
138 case 111:
139 return jjMoveStringLiteralDfa2_0(active0, 0x4000L);
140 case 114:
141 return jjMoveStringLiteralDfa2_0(active0, 0x2000L);
142 case 116:
143 return jjMoveStringLiteralDfa2_0(active0, 0x8000L);
144 case 117:
145 return jjMoveStringLiteralDfa2_0(active0, 0x10000L);
146 default :
147 break;
148 }
149 return jjMoveNfa_0(0, 1);
150 }
151 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
152 {
153 if (((active0 &= old0)) == 0L)
154 return jjMoveNfa_0(0, 1);
155 try { curChar = input_stream.readChar(); }
156 catch(java.io.IOException e) {
157 return jjMoveNfa_0(0, 1);
158 }
159 switch(curChar)
160 {
161 case 65:
162 return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
163 case 66:
164 return jjMoveStringLiteralDfa3_0(active0, 0x10000L);
165 case 68:
166 return jjMoveStringLiteralDfa3_0(active0, 0x4000L);
167 case 71:
168 return jjMoveStringLiteralDfa3_0(active0, 0x1800L);
169 case 82:
170 return jjMoveStringLiteralDfa3_0(active0, 0x8000L);
171 case 97:
172 return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
173 case 98:
174 return jjMoveStringLiteralDfa3_0(active0, 0x10000L);
175 case 100:
176 return jjMoveStringLiteralDfa3_0(active0, 0x4000L);
177 case 103:
178 return jjMoveStringLiteralDfa3_0(active0, 0x1800L);
179 case 114:
180 return jjMoveStringLiteralDfa3_0(active0, 0x8000L);
181 default :
182 break;
183 }
184 return jjMoveNfa_0(0, 2);
185 }
186 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
187 {
188 if (((active0 &= old0)) == 0L)
189 return jjMoveNfa_0(0, 2);
190 try { curChar = input_stream.readChar(); }
191 catch(java.io.IOException e) {
192 return jjMoveNfa_0(0, 2);
193 }
194 switch(curChar)
195 {
196 case 69:
197 if ((active0 & 0x1000L) != 0L)
198 {
199 jjmatchedKind = 12;
200 jjmatchedPos = 3;
201 }
202 else if ((active0 & 0x4000L) != 0L)
203 {
204 jjmatchedKind = 14;
205 jjmatchedPos = 3;
206 }
207 break;
208 case 71:
209 return jjMoveStringLiteralDfa4_0(active0, 0x10000L);
210 case 73:
211 return jjMoveStringLiteralDfa4_0(active0, 0x8000L);
212 case 80:
213 return jjMoveStringLiteralDfa4_0(active0, 0x2000L);
214 case 82:
215 return jjMoveStringLiteralDfa4_0(active0, 0x800L);
216 case 101:
217 if ((active0 & 0x1000L) != 0L)
218 {
219 jjmatchedKind = 12;
220 jjmatchedPos = 3;
221 }
222 else if ((active0 & 0x4000L) != 0L)
223 {
224 jjmatchedKind = 14;
225 jjmatchedPos = 3;
226 }
227 break;
228 case 103:
229 return jjMoveStringLiteralDfa4_0(active0, 0x10000L);
230 case 105:
231 return jjMoveStringLiteralDfa4_0(active0, 0x8000L);
232 case 112:
233 return jjMoveStringLiteralDfa4_0(active0, 0x2000L);
234 case 114:
235 return jjMoveStringLiteralDfa4_0(active0, 0x800L);
236 default :
237 break;
238 }
239 return jjMoveNfa_0(0, 3);
240 }
241 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
242 {
243 if (((active0 &= old0)) == 0L)
244 return jjMoveNfa_0(0, 3);
245 try { curChar = input_stream.readChar(); }
246 catch(java.io.IOException e) {
247 return jjMoveNfa_0(0, 3);
248 }
249 switch(curChar)
250 {
251 case 65:
252 return jjMoveStringLiteralDfa5_0(active0, 0x800L);
253 case 67:
254 return jjMoveStringLiteralDfa5_0(active0, 0x8000L);
255 case 72:
256 if ((active0 & 0x2000L) != 0L)
257 {
258 jjmatchedKind = 13;
259 jjmatchedPos = 4;
260 }
261 break;
262 case 82:
263 return jjMoveStringLiteralDfa5_0(active0, 0x10000L);
264 case 97:
265 return jjMoveStringLiteralDfa5_0(active0, 0x800L);
266 case 99:
267 return jjMoveStringLiteralDfa5_0(active0, 0x8000L);
268 case 104:
269 if ((active0 & 0x2000L) != 0L)
270 {
271 jjmatchedKind = 13;
272 jjmatchedPos = 4;
273 }
274 break;
275 case 114:
276 return jjMoveStringLiteralDfa5_0(active0, 0x10000L);
277 default :
278 break;
279 }
280 return jjMoveNfa_0(0, 4);
281 }
282 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
283 {
284 if (((active0 &= old0)) == 0L)
285 return jjMoveNfa_0(0, 4);
286 try { curChar = input_stream.readChar(); }
287 catch(java.io.IOException e) {
288 return jjMoveNfa_0(0, 4);
289 }
290 switch(curChar)
291 {
292 case 65:
293 return jjMoveStringLiteralDfa6_0(active0, 0x10000L);
294 case 80:
295 return jjMoveStringLiteralDfa6_0(active0, 0x800L);
296 case 84:
297 if ((active0 & 0x8000L) != 0L)
298 {
299 jjmatchedKind = 15;
300 jjmatchedPos = 5;
301 }
302 break;
303 case 97:
304 return jjMoveStringLiteralDfa6_0(active0, 0x10000L);
305 case 112:
306 return jjMoveStringLiteralDfa6_0(active0, 0x800L);
307 case 116:
308 if ((active0 & 0x8000L) != 0L)
309 {
310 jjmatchedKind = 15;
311 jjmatchedPos = 5;
312 }
313 break;
314 default :
315 break;
316 }
317 return jjMoveNfa_0(0, 5);
318 }
319 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
320 {
321 if (((active0 &= old0)) == 0L)
322 return jjMoveNfa_0(0, 5);
323 try { curChar = input_stream.readChar(); }
324 catch(java.io.IOException e) {
325 return jjMoveNfa_0(0, 5);
326 }
327 switch(curChar)
328 {
329 case 72:
330 if ((active0 & 0x800L) != 0L)
331 {
332 jjmatchedKind = 11;
333 jjmatchedPos = 6;
334 }
335 break;
336 case 80:
337 return jjMoveStringLiteralDfa7_0(active0, 0x10000L);
338 case 104:
339 if ((active0 & 0x800L) != 0L)
340 {
341 jjmatchedKind = 11;
342 jjmatchedPos = 6;
343 }
344 break;
345 case 112:
346 return jjMoveStringLiteralDfa7_0(active0, 0x10000L);
347 default :
348 break;
349 }
350 return jjMoveNfa_0(0, 6);
351 }
352 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
353 {
354 if (((active0 &= old0)) == 0L)
355 return jjMoveNfa_0(0, 6);
356 try { curChar = input_stream.readChar(); }
357 catch(java.io.IOException e) {
358 return jjMoveNfa_0(0, 6);
359 }
360 switch(curChar)
361 {
362 case 72:
363 if ((active0 & 0x10000L) != 0L)
364 {
365 jjmatchedKind = 16;
366 jjmatchedPos = 7;
367 }
368 break;
369 case 104:
370 if ((active0 & 0x10000L) != 0L)
371 {
372 jjmatchedKind = 16;
373 jjmatchedPos = 7;
374 }
375 break;
376 default :
377 break;
378 }
379 return jjMoveNfa_0(0, 7);
380 }
381 private final void jjCheckNAdd(int state)
382 {
383 if (jjrounds[state] != jjround)
384 {
385 jjstateSet[jjnewStateCnt++] = state;
386 jjrounds[state] = jjround;
387 }
388 }
389 private final void jjAddStates(int start, int end)
390 {
391 do {
392 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
393 } while (start++ != end);
394 }
395 private final void jjCheckNAddTwoStates(int state1, int state2)
396 {
397 jjCheckNAdd(state1);
398 jjCheckNAdd(state2);
399 }
400 private final void jjCheckNAddStates(int start, int end)
401 {
402 do {
403 jjCheckNAdd(jjnextStates[start]);
404 } while (start++ != end);
405 }
406 private final void jjCheckNAddStates(int start)
407 {
408 jjCheckNAdd(jjnextStates[start]);
409 jjCheckNAdd(jjnextStates[start + 1]);
410 }
411 static final long[] jjbitVec0 = {
412 0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL
413 };
414 static final long[] jjbitVec2 = {
415 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
416 };
417 static final long[] jjbitVec3 = {
418 0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL
419 };
420 static final long[] jjbitVec4 = {
421 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L
422 };
423 static final long[] jjbitVec5 = {
424 0x0L, 0x0L, 0xfffffffbffffd740L, 0xffffd547f7fffL
425 };
426 static final long[] jjbitVec6 = {
427 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff0003L, 0x33fcfffffff199fL
428 };
429 static final long[] jjbitVec7 = {
430 0xfffe000000000000L, 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L
431 };
432 static final long[] jjbitVec8 = {
433 0x7fffffe00000000L, 0xfffe03ff000007feL, 0x7cffffffffffffffL, 0x3ff0060002f7fffL
434 };
435 static final long[] jjbitVec9 = {
436 0x23ffffffffffffe0L, 0xffc3ff000000L, 0x3c5fdfffff99fe0L, 0x3ffc3b0000000L
437 };
438 static final long[] jjbitVec10 = {
439 0x36dfdfffff987e0L, 0x1cffc05e000000L, 0x23edfdfffffbafe0L, 0xffc100000000L
440 };
441 static final long[] jjbitVec11 = {
442 0x23cdfdfffff99fe0L, 0xffc3b0000000L, 0x3bfc718d63dc7e0L, 0xff8000000000L
443 };
444 static final long[] jjbitVec12 = {
445 0x3effdfffffddfe0L, 0xffc300000000L, 0x3effdfffffddfe0L, 0xffc340000000L
446 };
447 static final long[] jjbitVec13 = {
448 0x3fffdfffffddfe0L, 0xffc300000000L, 0x0L, 0x0L
449 };
450 static final long[] jjbitVec14 = {
451 0xd7ffffffffffeL, 0x3ff003fL, 0x200d6caefef02596L, 0x3ff001fL
452 };
453 static final long[] jjbitVec15 = {
454 0x3ff00000000L, 0x3fffffffeffL, 0x0L, 0x0L
455 };
456 static final long[] jjbitVec16 = {
457 0x0L, 0x0L, 0xffffffff00000000L, 0x7fffffffff003fL
458 };
459 static final long[] jjbitVec17 = {
460 0x500000000007daedL, 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L
461 };
462 static final long[] jjbitVec18 = {
463 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
464 };
465 static final long[] jjbitVec19 = {
466 0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
467 };
468 static final long[] jjbitVec20 = {
469 0x4c4000000000L, 0x0L, 0x7L, 0x0L
470 };
471 static final long[] jjbitVec21 = {
472 0x3fe00000080L, 0xfffffffffffffffeL, 0xfffffffe001fffffL, 0x7ffffffffffffffL
473 };
474 static final long[] jjbitVec22 = {
475 0x1fffffffffe0L, 0x0L, 0x0L, 0x0L
476 };
477 static final long[] jjbitVec23 = {
478 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
479 };
480 static final long[] jjbitVec24 = {
481 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
482 };
483 static final long[] jjbitVec25 = {
484 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
485 };
486 static final long[] jjbitVec26 = {
487 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
488 };
489 static final long[] jjbitVec27 = {
490 0x1600L, 0x0L, 0x0L, 0x0L
491 };
492 static final long[] jjbitVec28 = {
493 0x0L, 0xffc000000000L, 0x0L, 0xffc000000000L
494 };
495 static final long[] jjbitVec29 = {
496 0x0L, 0x3ff00000000L, 0x0L, 0x3ff000000000000L
497 };
498 static final long[] jjbitVec30 = {
499 0x0L, 0xffc000000000L, 0x0L, 0xff8000000000L
500 };
501 static final long[] jjbitVec31 = {
502 0x0L, 0xffc000000000L, 0x0L, 0x0L
503 };
504 static final long[] jjbitVec32 = {
505 0x0L, 0x3ff0000L, 0x0L, 0x3ff0000L
506 };
507 static final long[] jjbitVec33 = {
508 0x3ff00000000L, 0x0L, 0x0L, 0x0L
509 };
510 private final int jjMoveNfa_0(int startState, int curPos)
511 {
512 int strKind = jjmatchedKind;
513 int strPos = jjmatchedPos;
514 int seenUpto;
515 input_stream.backup(seenUpto = curPos + 1);
516 try { curChar = input_stream.readChar(); }
517 catch(java.io.IOException e) { throw new Error("Internal Error"); }
518 curPos = 0;
519 int[] nextStates;
520 int startsAt = 0;
521 jjnewStateCnt = 31;
522 int i = 1;
523 jjstateSet[0] = startState;
524 int j, kind = 0x7fffffff;
525 for (;;)
526 {
527 if (++jjround == 0x7fffffff)
528 ReInitRounds();
529 if (curChar < 64)
530 {
531 long l = 1L << curChar;
532 MatchLoop: do
533 {
534 switch(jjstateSet[--i])
535 {
536 case 0:
537 if ((0x3ff000000000000L & l) != 0L)
538 {
539 if (kind > 28)
540 kind = 28;
541 jjCheckNAddTwoStates(10, 11);
542 }
543 else if (curChar == 60)
544 jjCheckNAddStates(0, 3);
545 else if (curChar == 46)
546 jjCheckNAdd(15);
547 else if (curChar == 45)
548 jjstateSet[jjnewStateCnt++] = 14;
549 else if (curChar == 34)
550 jjCheckNAddStates(4, 6);
551 if ((0x3ff000000000000L & l) != 0L)
552 {
553 if (kind > 28)
554 kind = 28;
555 jjCheckNAdd(2);
556 }
557 break;
558 case 1:
559 case 2:
560 if ((0x3ff000000000000L & l) == 0L)
561 break;
562 if (kind > 28)
563 kind = 28;
564 jjCheckNAdd(2);
565 break;
566 case 3:
567 if (curChar == 34)
568 jjCheckNAddStates(4, 6);
569 break;
570 case 4:
571 if ((0xfffffffbffffdbffL & l) != 0L)
572 jjCheckNAddStates(4, 6);
573 break;
574 case 6:
575 if ((0xffffffff00002400L & l) != 0L)
576 jjCheckNAddStates(4, 6);
577 break;
578 case 7:
579 if (curChar == 34 && kind > 28)
580 kind = 28;
581 break;
582 case 8:
583 if (curChar == 10)
584 jjCheckNAddStates(4, 6);
585 break;
586 case 9:
587 if (curChar == 13)
588 jjstateSet[jjnewStateCnt++] = 8;
589 break;
590 case 10:
591 if ((0x3ff000000000000L & l) == 0L)
592 break;
593 if (kind > 28)
594 kind = 28;
595 jjCheckNAddTwoStates(10, 11);
596 break;
597 case 11:
598 if (curChar != 46)
599 break;
600 if (kind > 28)
601 kind = 28;
602 jjCheckNAdd(12);
603 break;
604 case 12:
605 if ((0x3ff000000000000L & l) == 0L)
606 break;
607 if (kind > 28)
608 kind = 28;
609 jjCheckNAdd(12);
610 break;
611 case 13:
612 if (curChar == 45)
613 jjstateSet[jjnewStateCnt++] = 14;
614 break;
615 case 14:
616 if (curChar == 46)
617 jjCheckNAdd(15);
618 break;
619 case 15:
620 if ((0x3ff000000000000L & l) == 0L)
621 break;
622 if (kind > 28)
623 kind = 28;
624 jjCheckNAdd(15);
625 break;
626 case 20:
627 if (curChar == 60)
628 jjCheckNAddStates(0, 3);
629 break;
630 case 21:
631 if (curChar == 60)
632 jjCheckNAddTwoStates(22, 23);
633 break;
634 case 22:
635 if ((0xbfffffffffffffffL & l) != 0L)
636 jjCheckNAddTwoStates(22, 23);
637 break;
638 case 23:
639 if (curChar == 62)
640 jjCheckNAddStates(7, 9);
641 break;
642 case 24:
643 if ((0xafffffffffffffffL & l) != 0L)
644 jjCheckNAddStates(7, 9);
645 break;
646 case 25:
647 if (curChar == 62 && kind > 28)
648 kind = 28;
649 break;
650 case 26:
651 if (curChar == 60)
652 jjCheckNAddTwoStates(27, 28);
653 break;
654 case 27:
655 if ((0xbfffffffffffffffL & l) != 0L)
656 jjCheckNAddTwoStates(27, 28);
657 break;
658 case 28:
659 if (curChar == 62)
660 jjCheckNAddStates(10, 12);
661 break;
662 case 29:
663 if ((0xafffffffffffffffL & l) != 0L)
664 jjCheckNAddStates(10, 12);
665 break;
666 case 30:
667 if (curChar == 62 && kind > 29)
668 kind = 29;
669 break;
670 default : break;
671 }
672 } while(i != startsAt);
673 }
674 else if (curChar < 128)
675 {
676 long l = 1L << (curChar & 077);
677 MatchLoop: do
678 {
679 switch(jjstateSet[--i])
680 {
681 case 0:
682 if ((0x7fffffe07fffffeL & l) != 0L)
683 {
684 if (kind > 28)
685 kind = 28;
686 jjCheckNAdd(2);
687 }
688 if ((0x88402000000000L & l) != 0L)
689 {
690 if (kind > 27)
691 kind = 27;
692 }
693 if (curChar == 115)
694 jjCheckNAddTwoStates(17, 18);
695 else if (curChar == 110)
696 jjCheckNAddTwoStates(17, 18);
697 break;
698 case 1:
699 if ((0x7fffffe07fffffeL & l) == 0L)
700 break;
701 if (kind > 28)
702 kind = 28;
703 jjCheckNAdd(2);
704 break;
705 case 2:
706 if ((0x7fffffe87fffffeL & l) == 0L)
707 break;
708 if (kind > 28)
709 kind = 28;
710 jjCheckNAdd(2);
711 break;
712 case 4:
713 if ((0xffffffffefffffffL & l) != 0L)
714 jjCheckNAddStates(4, 6);
715 break;
716 case 5:
717 if (curChar == 92)
718 jjAddStates(13, 14);
719 break;
720 case 6:
721 if ((0x7fffffffffffffffL & l) != 0L)
722 jjCheckNAddStates(4, 6);
723 break;
724 case 16:
725 if (curChar == 110)
726 jjCheckNAddTwoStates(17, 18);
727 break;
728 case 17:
729 if (curChar == 101 && kind > 27)
730 kind = 27;
731 break;
732 case 18:
733 if (curChar == 119 && kind > 27)
734 kind = 27;
735 break;
736 case 19:
737 if (curChar == 115)
738 jjCheckNAddTwoStates(17, 18);
739 break;
740 case 22:
741 jjAddStates(15, 16);
742 break;
743 case 24:
744 jjAddStates(7, 9);
745 break;
746 case 27:
747 jjAddStates(17, 18);
748 break;
749 case 29:
750 jjAddStates(10, 12);
751 break;
752 default : break;
753 }
754 } while(i != startsAt);
755 }
756 else
757 {
758 int hiByte = (int)(curChar >> 8);
759 int i1 = hiByte >> 6;
760 long l1 = 1L << (hiByte & 077);
761 int i2 = (curChar & 0xff) >> 6;
762 long l2 = 1L << (curChar & 077);
763 MatchLoop: do
764 {
765 switch(jjstateSet[--i])
766 {
767 case 0:
768 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
769 {
770 if (kind > 28)
771 kind = 28;
772 jjCheckNAdd(2);
773 }
774 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
775 {
776 if (kind > 28)
777 kind = 28;
778 jjCheckNAddTwoStates(10, 11);
779 }
780 break;
781 case 1:
782 case 2:
783 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
784 break;
785 if (kind > 28)
786 kind = 28;
787 jjCheckNAdd(2);
788 break;
789 case 4:
790 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
791 jjAddStates(4, 6);
792 break;
793 case 10:
794 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
795 break;
796 if (kind > 28)
797 kind = 28;
798 jjCheckNAddTwoStates(10, 11);
799 break;
800 case 12:
801 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
802 break;
803 if (kind > 28)
804 kind = 28;
805 jjstateSet[jjnewStateCnt++] = 12;
806 break;
807 case 15:
808 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
809 break;
810 if (kind > 28)
811 kind = 28;
812 jjstateSet[jjnewStateCnt++] = 15;
813 break;
814 case 22:
815 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
816 jjAddStates(15, 16);
817 break;
818 case 24:
819 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
820 jjAddStates(7, 9);
821 break;
822 case 27:
823 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
824 jjAddStates(17, 18);
825 break;
826 case 29:
827 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
828 jjAddStates(10, 12);
829 break;
830 default : break;
831 }
832 } while(i != startsAt);
833 }
834 if (kind != 0x7fffffff)
835 {
836 jjmatchedKind = kind;
837 jjmatchedPos = curPos;
838 kind = 0x7fffffff;
839 }
840 ++curPos;
841 if ((i = jjnewStateCnt) == (startsAt = 31 - (jjnewStateCnt = startsAt)))
842 break;
843 try { curChar = input_stream.readChar(); }
844 catch(java.io.IOException e) { break; }
845 }
846 if (jjmatchedPos > strPos)
847 return curPos;
848
849 int toRet = Math.max(curPos, seenUpto);
850
851 if (curPos < toRet)
852 for (i = toRet - Math.min(curPos, seenUpto); i-- > 0; )
853 try { curChar = input_stream.readChar(); }
854 catch(java.io.IOException e) { throw new Error("Internal Error : Please send a bug report."); }
855
856 if (jjmatchedPos < strPos)
857 {
858 jjmatchedKind = strKind;
859 jjmatchedPos = strPos;
860 }
861 else if (jjmatchedPos == strPos && jjmatchedKind > strKind)
862 jjmatchedKind = strKind;
863
864 return toRet;
865 }
866 private final int jjMoveStringLiteralDfa0_2()
867 {
868 switch(curChar)
869 {
870 case 42:
871 return jjMoveStringLiteralDfa1_2(0x200L);
872 default :
873 return 1;
874 }
875 }
876 private final int jjMoveStringLiteralDfa1_2(long active0)
877 {
878 try { curChar = input_stream.readChar(); }
879 catch(java.io.IOException e) {
880 return 1;
881 }
882 switch(curChar)
883 {
884 case 47:
885 if ((active0 & 0x200L) != 0L)
886 return jjStopAtPos(1, 9);
887 break;
888 default :
889 return 2;
890 }
891 return 2;
892 }
893 private final int jjMoveStringLiteralDfa0_1()
894 {
895 return jjMoveNfa_1(0, 0);
896 }
897 private final int jjMoveNfa_1(int startState, int curPos)
898 {
899 int[] nextStates;
900 int startsAt = 0;
901 jjnewStateCnt = 3;
902 int i = 1;
903 jjstateSet[0] = startState;
904 int j, kind = 0x7fffffff;
905 for (;;)
906 {
907 if (++jjround == 0x7fffffff)
908 ReInitRounds();
909 if (curChar < 64)
910 {
911 long l = 1L << curChar;
912 MatchLoop: do
913 {
914 switch(jjstateSet[--i])
915 {
916 case 0:
917 if ((0x2400L & l) != 0L)
918 {
919 if (kind > 8)
920 kind = 8;
921 }
922 if (curChar == 13)
923 jjstateSet[jjnewStateCnt++] = 1;
924 break;
925 case 1:
926 if (curChar == 10 && kind > 8)
927 kind = 8;
928 break;
929 case 2:
930 if (curChar == 13)
931 jjstateSet[jjnewStateCnt++] = 1;
932 break;
933 default : break;
934 }
935 } while(i != startsAt);
936 }
937 else if (curChar < 128)
938 {
939 long l = 1L << (curChar & 077);
940 MatchLoop: do
941 {
942 switch(jjstateSet[--i])
943 {
944 default : break;
945 }
946 } while(i != startsAt);
947 }
948 else
949 {
950 int hiByte = (int)(curChar >> 8);
951 int i1 = hiByte >> 6;
952 long l1 = 1L << (hiByte & 077);
953 int i2 = (curChar & 0xff) >> 6;
954 long l2 = 1L << (curChar & 077);
955 MatchLoop: do
956 {
957 switch(jjstateSet[--i])
958 {
959 default : break;
960 }
961 } while(i != startsAt);
962 }
963 if (kind != 0x7fffffff)
964 {
965 jjmatchedKind = kind;
966 jjmatchedPos = curPos;
967 kind = 0x7fffffff;
968 }
969 ++curPos;
970 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
971 return curPos;
972 try { curChar = input_stream.readChar(); }
973 catch(java.io.IOException e) { return curPos; }
974 }
975 }
976 static final int[] jjnextStates = {
977 21, 25, 26, 30, 4, 5, 7, 21, 24, 25, 26, 29, 30, 6, 9, 22,
978 23, 27, 28,
979 };
980 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
981 {
982 switch(hiByte)
983 {
984 case 0:
985 return ((jjbitVec2[i2] & l2) != 0L);
986 case 1:
987 return ((jjbitVec3[i2] & l2) != 0L);
988 case 2:
989 return ((jjbitVec4[i2] & l2) != 0L);
990 case 3:
991 return ((jjbitVec5[i2] & l2) != 0L);
992 case 4:
993 return ((jjbitVec6[i2] & l2) != 0L);
994 case 5:
995 return ((jjbitVec7[i2] & l2) != 0L);
996 case 6:
997 return ((jjbitVec8[i2] & l2) != 0L);
998 case 9:
999 return ((jjbitVec9[i2] & l2) != 0L);
1000 case 10:
1001 return ((jjbitVec10[i2] & l2) != 0L);
1002 case 11:
1003 return ((jjbitVec11[i2] & l2) != 0L);
1004 case 12:
1005 return ((jjbitVec12[i2] & l2) != 0L);
1006 case 13:
1007 return ((jjbitVec13[i2] & l2) != 0L);
1008 case 14:
1009 return ((jjbitVec14[i2] & l2) != 0L);
1010 case 15:
1011 return ((jjbitVec15[i2] & l2) != 0L);
1012 case 16:
1013 return ((jjbitVec16[i2] & l2) != 0L);
1014 case 17:
1015 return ((jjbitVec17[i2] & l2) != 0L);
1016 case 30:
1017 return ((jjbitVec18[i2] & l2) != 0L);
1018 case 31:
1019 return ((jjbitVec19[i2] & l2) != 0L);
1020 case 33:
1021 return ((jjbitVec20[i2] & l2) != 0L);
1022 case 48:
1023 return ((jjbitVec21[i2] & l2) != 0L);
1024 case 49:
1025 return ((jjbitVec22[i2] & l2) != 0L);
1026 case 159:
1027 return ((jjbitVec23[i2] & l2) != 0L);
1028 case 215:
1029 return ((jjbitVec24[i2] & l2) != 0L);
1030 default :
1031 if ((jjbitVec0[i1] & l1) != 0L)
1032 return true;
1033 return false;
1034 }
1035 }
1036 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1037 {
1038 switch(hiByte)
1039 {
1040 case 0:
1041 return ((jjbitVec26[i2] & l2) != 0L);
1042 default :
1043 if ((jjbitVec25[i1] & l1) != 0L)
1044 return true;
1045 return false;
1046 }
1047 }
1048 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
1049 {
1050 switch(hiByte)
1051 {
1052 case 6:
1053 return ((jjbitVec29[i2] & l2) != 0L);
1054 case 11:
1055 return ((jjbitVec30[i2] & l2) != 0L);
1056 case 13:
1057 return ((jjbitVec31[i2] & l2) != 0L);
1058 case 14:
1059 return ((jjbitVec32[i2] & l2) != 0L);
1060 case 15:
1061 return ((jjbitVec33[i2] & l2) != 0L);
1062 default :
1063 if ((jjbitVec27[i1] & l1) != 0L)
1064 if ((jjbitVec28[i2] & l2) == 0L)
1065 return false;
1066 else
1067 return true;
1068 return false;
1069 }
1070 }
1071 public static final String[] jjstrLiteralImages = {
1072 "", null, null, null, null, null, null, null, null, null, null, null, null,
1073 null, null, null, null, "\75", "\173", "\175", "\55\55", "\55\76", "\133", "\135",
1074 "\54", "\73", "\72", null, null, null, null, null, null, null, null, null, null, null,
1075 null, null, null, null, };
1076 public static final String[] lexStateNames = {
1077 "DEFAULT",
1078 "IN_SINGLE_LINE_COMMENT",
1079 "IN_MULTI_LINE_COMMENT",
1080 };
1081 public static final int[] jjnewLexState = {
1082 -1, -1, -1, -1, -1, -1, 1, 2, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1083 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1084 };
1085 static final long[] jjtoToken = {
1086 0x3ffff801L,
1087 };
1088 static final long[] jjtoSkip = {
1089 0x33eL,
1090 };
1091 static final long[] jjtoSpecial = {
1092 0x300L,
1093 };
1094 static final long[] jjtoMore = {
1095 0x4c0L,
1096 };
1097 protected SimpleCharStream input_stream;
1098 private final int[] jjrounds = new int[31];
1099 private final int[] jjstateSet = new int[62];
1100 StringBuffer image;
1101 int jjimageLen;
1102 int lengthOfMatch;
1103 protected char curChar;
1104 public DOTParserTokenManager(SimpleCharStream stream)
1105 {
1106 if (SimpleCharStream.staticFlag)
1107 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1108 input_stream = stream;
1109 }
1110 public DOTParserTokenManager(SimpleCharStream stream, int lexState)
1111 {
1112 this(stream);
1113 SwitchTo(lexState);
1114 }
1115 public void ReInit(SimpleCharStream stream)
1116 {
1117 jjmatchedPos = jjnewStateCnt = 0;
1118 curLexState = defaultLexState;
1119 input_stream = stream;
1120 ReInitRounds();
1121 }
1122 private final void ReInitRounds()
1123 {
1124 int i;
1125 jjround = 0x80000001;
1126 for (i = 31; i-- > 0;)
1127 jjrounds[i] = 0x80000000;
1128 }
1129 public void ReInit(SimpleCharStream stream, int lexState)
1130 {
1131 ReInit(stream);
1132 SwitchTo(lexState);
1133 }
1134 public void SwitchTo(int lexState)
1135 {
1136 if (lexState >= 3 || lexState < 0)
1137 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1138 else
1139 curLexState = lexState;
1140 }
1141
1142 protected Token jjFillToken()
1143 {
1144 Token t = Token.newToken(jjmatchedKind);
1145 t.kind = jjmatchedKind;
1146 String im = jjstrLiteralImages[jjmatchedKind];
1147 t.image = (im == null) ? input_stream.GetImage() : im;
1148 t.beginLine = input_stream.getBeginLine();
1149 t.beginColumn = input_stream.getBeginColumn();
1150 t.endLine = input_stream.getEndLine();
1151 t.endColumn = input_stream.getEndColumn();
1152 return t;
1153 }
1154
1155 int curLexState = 0;
1156 int defaultLexState = 0;
1157 int jjnewStateCnt;
1158 int jjround;
1159 int jjmatchedPos;
1160 int jjmatchedKind;
1161
1162 public Token getNextToken()
1163 {
1164 int kind;
1165 Token specialToken = null;
1166 Token matchedToken;
1167 int curPos = 0;
1168
1169 EOFLoop :
1170 for (;;)
1171 {
1172 try
1173 {
1174 curChar = input_stream.BeginToken();
1175 }
1176 catch(java.io.IOException e)
1177 {
1178 jjmatchedKind = 0;
1179 matchedToken = jjFillToken();
1180 matchedToken.specialToken = specialToken;
1181 return matchedToken;
1182 }
1183 image = null;
1184 jjimageLen = 0;
1185
1186 for (;;)
1187 {
1188 switch(curLexState)
1189 {
1190 case 0:
1191 jjmatchedKind = 0x7fffffff;
1192 jjmatchedPos = 0;
1193 curPos = jjMoveStringLiteralDfa0_0();
1194 break;
1195 case 1:
1196 jjmatchedKind = 0x7fffffff;
1197 jjmatchedPos = 0;
1198 curPos = jjMoveStringLiteralDfa0_1();
1199 if (jjmatchedPos == 0 && jjmatchedKind > 10)
1200 {
1201 jjmatchedKind = 10;
1202 }
1203 break;
1204 case 2:
1205 jjmatchedKind = 0x7fffffff;
1206 jjmatchedPos = 0;
1207 curPos = jjMoveStringLiteralDfa0_2();
1208 if (jjmatchedPos == 0 && jjmatchedKind > 10)
1209 {
1210 jjmatchedKind = 10;
1211 }
1212 break;
1213 }
1214 if (jjmatchedKind != 0x7fffffff)
1215 {
1216 if (jjmatchedPos + 1 < curPos)
1217 input_stream.backup(curPos - jjmatchedPos - 1);
1218 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1219 {
1220 matchedToken = jjFillToken();
1221 matchedToken.specialToken = specialToken;
1222 if (jjnewLexState[jjmatchedKind] != -1)
1223 curLexState = jjnewLexState[jjmatchedKind];
1224 return matchedToken;
1225 }
1226 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1227 {
1228 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1229 {
1230 matchedToken = jjFillToken();
1231 if (specialToken == null)
1232 specialToken = matchedToken;
1233 else
1234 {
1235 matchedToken.specialToken = specialToken;
1236 specialToken = (specialToken.next = matchedToken);
1237 }
1238 SkipLexicalActions(matchedToken);
1239 }
1240 else
1241 SkipLexicalActions(null);
1242 if (jjnewLexState[jjmatchedKind] != -1)
1243 curLexState = jjnewLexState[jjmatchedKind];
1244 continue EOFLoop;
1245 }
1246 jjimageLen += jjmatchedPos + 1;
1247 if (jjnewLexState[jjmatchedKind] != -1)
1248 curLexState = jjnewLexState[jjmatchedKind];
1249 curPos = 0;
1250 jjmatchedKind = 0x7fffffff;
1251 try {
1252 curChar = input_stream.readChar();
1253 continue;
1254 }
1255 catch (java.io.IOException e1) { }
1256 }
1257 int error_line = input_stream.getEndLine();
1258 int error_column = input_stream.getEndColumn();
1259 String error_after = null;
1260 boolean EOFSeen = false;
1261 try { input_stream.readChar(); input_stream.backup(1); }
1262 catch (java.io.IOException e1) {
1263 EOFSeen = true;
1264 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1265 if (curChar == '\n' || curChar == '\r') {
1266 error_line++;
1267 error_column = 0;
1268 }
1269 else
1270 error_column++;
1271 }
1272 if (!EOFSeen) {
1273 input_stream.backup(1);
1274 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1275 }
1276 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1277 }
1278 }
1279 }
1280
1281 void SkipLexicalActions(Token matchedToken)
1282 {
1283 switch(jjmatchedKind)
1284 {
1285 default :
1286 break;
1287 }
1288 }
1289 }