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