1
2 package zeus.concepts;
3 import java.util.*;
4 import java.io.*;
5 import zeus.util.*;
6
7 public class PerformativeParserTokenManager implements PerformativeParserConstants
8 {
9 private final int jjStopStringLiteralDfa_0(int pos, long active0)
10 {
11 switch (pos)
12 {
13 case 0:
14 if ((active0 & 0x7ffffffff00L) != 0L)
15 {
16 jjmatchedKind = 43;
17 return 1;
18 }
19 return -1;
20 case 1:
21 if ((active0 & 0x7ffffffff00L) != 0L)
22 {
23 jjmatchedKind = 43;
24 jjmatchedPos = 1;
25 return 1;
26 }
27 return -1;
28 case 2:
29 if ((active0 & 0x7fffffff700L) != 0L)
30 {
31 jjmatchedKind = 43;
32 jjmatchedPos = 2;
33 return 1;
34 }
35 if ((active0 & 0x800L) != 0L)
36 return 1;
37 return -1;
38 case 3:
39 if ((active0 & 0x7fffffff700L) != 0L)
40 {
41 jjmatchedKind = 43;
42 jjmatchedPos = 3;
43 return 1;
44 }
45 return -1;
46 case 4:
47 if ((active0 & 0x5fffffff500L) != 0L)
48 {
49 jjmatchedKind = 43;
50 jjmatchedPos = 4;
51 return 1;
52 }
53 if ((active0 & 0x20000000200L) != 0L)
54 return 1;
55 return -1;
56 case 5:
57 if ((active0 & 0x5ffffbc7100L) != 0L)
58 {
59 if (jjmatchedPos != 5)
60 {
61 jjmatchedKind = 43;
62 jjmatchedPos = 5;
63 }
64 return 1;
65 }
66 if ((active0 & 0x438400L) != 0L)
67 return 1;
68 return -1;
69 case 6:
70 if ((active0 & 0x5ffd0b72100L) != 0L)
71 {
72 if (jjmatchedPos != 6)
73 {
74 jjmatchedKind = 43;
75 jjmatchedPos = 6;
76 }
77 return 1;
78 }
79 if ((active0 & 0x2f085000L) != 0L)
80 return 1;
81 return -1;
82 case 7:
83 if ((active0 & 0x5ff5ea72100L) != 0L)
84 {
85 jjmatchedKind = 43;
86 jjmatchedPos = 7;
87 return 1;
88 }
89 if ((active0 & 0x80100000L) != 0L)
90 return 1;
91 return -1;
92 case 8:
93 if ((active0 & 0x5050e862100L) != 0L)
94 {
95 jjmatchedKind = 43;
96 jjmatchedPos = 8;
97 return 1;
98 }
99 if ((active0 & 0xfa50210000L) != 0L)
100 return 1;
101 return -1;
102 case 9:
103 if ((active0 & 0x40000022000L) != 0L)
104 return 1;
105 if ((active0 & 0x1050e840100L) != 0L)
106 {
107 jjmatchedKind = 43;
108 jjmatchedPos = 9;
109 return 1;
110 }
111 return -1;
112 case 10:
113 if ((active0 & 0x1040e840100L) != 0L)
114 {
115 jjmatchedKind = 43;
116 jjmatchedPos = 10;
117 return 1;
118 }
119 if ((active0 & 0x100000000L) != 0L)
120 return 1;
121 return -1;
122 case 11:
123 if ((active0 & 0x10008840100L) != 0L)
124 {
125 if (jjmatchedPos != 11)
126 {
127 jjmatchedKind = 43;
128 jjmatchedPos = 11;
129 }
130 return 1;
131 }
132 if ((active0 & 0x406000000L) != 0L)
133 return 1;
134 return -1;
135 case 12:
136 if ((active0 & 0x1000c840100L) != 0L)
137 {
138 jjmatchedKind = 43;
139 jjmatchedPos = 12;
140 return 1;
141 }
142 return -1;
143 case 13:
144 if ((active0 & 0x1000c800100L) != 0L)
145 {
146 jjmatchedKind = 43;
147 jjmatchedPos = 13;
148 return 1;
149 }
150 if ((active0 & 0x40000L) != 0L)
151 return 1;
152 return -1;
153 case 14:
154 if ((active0 & 0x10004000000L) != 0L)
155 {
156 jjmatchedKind = 43;
157 jjmatchedPos = 14;
158 return 1;
159 }
160 if ((active0 & 0x8800100L) != 0L)
161 return 1;
162 return -1;
163 default :
164 return -1;
165 }
166 }
167 private final int jjStartNfa_0(int pos, long active0)
168 {
169 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
170 }
171 private final int jjStopAtPos(int pos, int kind)
172 {
173 jjmatchedKind = kind;
174 jjmatchedPos = pos;
175 return pos + 1;
176 }
177 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
178 {
179 jjmatchedKind = kind;
180 jjmatchedPos = pos;
181 try { curChar = input_stream.readChar(); }
182 catch(java.io.IOException e) { return pos + 1; }
183 return jjMoveNfa_0(state, pos + 1);
184 }
185 private final int jjMoveStringLiteralDfa0_0()
186 {
187 switch(curChar)
188 {
189 case 40:
190 return jjStopAtPos(0, 6);
191 case 41:
192 return jjStopAtPos(0, 7);
193 case 58:
194 return jjMoveStringLiteralDfa1_0(0x7ffe0000000L);
195 case 64:
196 return jjStopAtPos(0, 52);
197 case 97:
198 return jjMoveStringLiteralDfa1_0(0x300L);
199 case 99:
200 return jjMoveStringLiteralDfa1_0(0x1c00L);
201 case 100:
202 return jjMoveStringLiteralDfa1_0(0x2000L);
203 case 102:
204 return jjMoveStringLiteralDfa1_0(0x4000L);
205 case 105:
206 return jjMoveStringLiteralDfa1_0(0x38000L);
207 case 110:
208 return jjMoveStringLiteralDfa1_0(0x40000L);
209 case 112:
210 return jjMoveStringLiteralDfa1_0(0x80000L);
211 case 113:
212 return jjMoveStringLiteralDfa1_0(0x300000L);
213 case 114:
214 return jjMoveStringLiteralDfa1_0(0xfc00000L);
215 case 115:
216 return jjMoveStringLiteralDfa1_0(0x10000000L);
217 default :
218 return jjMoveNfa_0(0, 0);
219 }
220 }
221 private final int jjMoveStringLiteralDfa1_0(long active0)
222 {
223 try { curChar = input_stream.readChar(); }
224 catch(java.io.IOException e) {
225 jjStopStringLiteralDfa_0(0, active0);
226 return 1;
227 }
228 switch(curChar)
229 {
230 case 97:
231 return jjMoveStringLiteralDfa2_0(active0, 0x40000004400L);
232 case 99:
233 return jjMoveStringLiteralDfa2_0(active0, 0x10080000100L);
234 case 101:
235 return jjMoveStringLiteralDfa2_0(active0, 0x100fc00000L);
236 case 102:
237 return jjMoveStringLiteralDfa2_0(active0, 0x800L);
238 case 103:
239 return jjMoveStringLiteralDfa2_0(active0, 0x200L);
240 case 105:
241 return jjMoveStringLiteralDfa2_0(active0, 0x400002000L);
242 case 108:
243 return jjMoveStringLiteralDfa2_0(active0, 0x2000000000L);
244 case 110:
245 return jjMoveStringLiteralDfa2_0(active0, 0x20000038000L);
246 case 111:
247 return jjMoveStringLiteralDfa2_0(active0, 0x4000041000L);
248 case 112:
249 return jjMoveStringLiteralDfa2_0(active0, 0x8000000000L);
250 case 114:
251 return jjMoveStringLiteralDfa2_0(active0, 0xb40080000L);
252 case 115:
253 return jjMoveStringLiteralDfa2_0(active0, 0x20000000L);
254 case 117:
255 return jjMoveStringLiteralDfa2_0(active0, 0x10300000L);
256 default :
257 break;
258 }
259 return jjStartNfa_0(0, active0);
260 }
261 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
262 {
263 if (((active0 &= old0)) == 0L)
264 return jjStartNfa_0(0, old0);
265 try { curChar = input_stream.readChar(); }
266 catch(java.io.IOException e) {
267 jjStopStringLiteralDfa_0(1, active0);
268 return 2;
269 }
270 switch(curChar)
271 {
272 case 97:
273 return jjMoveStringLiteralDfa3_0(active0, 0x22000000000L);
274 case 98:
275 return jjMoveStringLiteralDfa3_0(active0, 0x10000000L);
276 case 99:
277 return jjMoveStringLiteralDfa3_0(active0, 0x100L);
278 case 100:
279 return jjMoveStringLiteralDfa3_0(active0, 0x40000000000L);
280 case 101:
281 return jjMoveStringLiteralDfa3_0(active0, 0xb60300000L);
282 case 102:
283 return jjMoveStringLiteralDfa3_0(active0, 0x438000L);
284 case 105:
285 return jjMoveStringLiteralDfa3_0(active0, 0x4000L);
286 case 106:
287 return jjMoveStringLiteralDfa3_0(active0, 0x800000L);
288 case 110:
289 return jjMoveStringLiteralDfa3_0(active0, 0x5400001400L);
290 case 111:
291 return jjMoveStringLiteralDfa3_0(active0, 0x10080080000L);
292 case 112:
293 if ((active0 & 0x800L) != 0L)
294 return jjStartNfaWithStates_0(2, 11, 1);
295 break;
296 case 113:
297 return jjMoveStringLiteralDfa3_0(active0, 0xf000000L);
298 case 114:
299 return jjMoveStringLiteralDfa3_0(active0, 0x8000000200L);
300 case 115:
301 return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
302 case 116:
303 return jjMoveStringLiteralDfa3_0(active0, 0x40000L);
304 default :
305 break;
306 }
307 return jjStartNfa_0(1, active0);
308 }
309 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
310 {
311 if (((active0 &= old0)) == 0L)
312 return jjStartNfa_0(1, old0);
313 try { curChar = input_stream.readChar(); }
314 catch(java.io.IOException e) {
315 jjStopStringLiteralDfa_0(2, active0);
316 return 3;
317 }
318 switch(curChar)
319 {
320 case 45:
321 return jjMoveStringLiteralDfa4_0(active0, 0x400040000L);
322 case 99:
323 return jjMoveStringLiteralDfa4_0(active0, 0x40002400L);
324 case 100:
325 return jjMoveStringLiteralDfa4_0(active0, 0x40000000000L);
326 case 101:
327 return jjMoveStringLiteralDfa4_0(active0, 0x800300L);
328 case 102:
329 return jjMoveStringLiteralDfa4_0(active0, 0x1000L);
330 case 108:
331 return jjMoveStringLiteralDfa4_0(active0, 0x4000L);
332 case 109:
333 return jjMoveStringLiteralDfa4_0(active0, 0x20000000000L);
334 case 110:
335 return jjMoveStringLiteralDfa4_0(active0, 0x120a0000000L);
336 case 111:
337 return jjMoveStringLiteralDfa4_0(active0, 0x8000038000L);
338 case 112:
339 return jjMoveStringLiteralDfa4_0(active0, 0xb00080000L);
340 case 114:
341 return jjMoveStringLiteralDfa4_0(active0, 0x300000L);
342 case 115:
343 return jjMoveStringLiteralDfa4_0(active0, 0x10000000L);
344 case 116:
345 return jjMoveStringLiteralDfa4_0(active0, 0x4000000000L);
346 case 117:
347 return jjMoveStringLiteralDfa4_0(active0, 0xf400000L);
348 case 118:
349 return jjMoveStringLiteralDfa4_0(active0, 0x1000000000L);
350 default :
351 break;
352 }
353 return jjStartNfa_0(2, active0);
354 }
355 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
356 {
357 if (((active0 &= old0)) == 0L)
358 return jjStartNfa_0(2, old0);
359 try { curChar = input_stream.readChar(); }
360 catch(java.io.IOException e) {
361 jjStopStringLiteralDfa_0(3, active0);
362 return 4;
363 }
364 switch(curChar)
365 {
366 case 99:
367 return jjMoveStringLiteralDfa5_0(active0, 0x10800000L);
368 case 100:
369 return jjMoveStringLiteralDfa5_0(active0, 0x20000000L);
370 case 101:
371 if ((active0 & 0x200L) != 0L)
372 return jjStartNfaWithStates_0(4, 9, 1);
373 else if ((active0 & 0x20000000000L) != 0L)
374 return jjStartNfaWithStates_0(4, 41, 1);
375 return jjMoveStringLiteralDfa5_0(active0, 0x104f000400L);
376 case 103:
377 return jjMoveStringLiteralDfa5_0(active0, 0x2000000000L);
378 case 105:
379 return jjMoveStringLiteralDfa5_0(active0, 0x1000L);
380 case 108:
381 return jjMoveStringLiteralDfa5_0(active0, 0xb00000000L);
382 case 111:
383 return jjMoveStringLiteralDfa5_0(active0, 0x4000082000L);
384 case 112:
385 return jjMoveStringLiteralDfa5_0(active0, 0x100L);
386 case 114:
387 return jjMoveStringLiteralDfa5_0(active0, 0x40400038000L);
388 case 115:
389 return jjMoveStringLiteralDfa5_0(active0, 0x400000L);
390 case 116:
391 return jjMoveStringLiteralDfa5_0(active0, 0x8080000000L);
392 case 117:
393 return jjMoveStringLiteralDfa5_0(active0, 0x44000L);
394 case 118:
395 return jjMoveStringLiteralDfa5_0(active0, 0x10000000000L);
396 case 121:
397 return jjMoveStringLiteralDfa5_0(active0, 0x300000L);
398 default :
399 break;
400 }
401 return jjStartNfa_0(3, active0);
402 }
403 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
404 {
405 if (((active0 &= old0)) == 0L)
406 return jjStartNfa_0(3, old0);
407 try { curChar = input_stream.readChar(); }
408 catch(java.io.IOException e) {
409 jjStopStringLiteralDfa_0(4, active0);
410 return 5;
411 }
412 switch(curChar)
413 {
414 case 45:
415 return jjMoveStringLiteralDfa6_0(active0, 0x300000L);
416 case 101:
417 if ((active0 & 0x400000L) != 0L)
418 return jjStartNfaWithStates_0(5, 22, 1);
419 return jjMoveStringLiteralDfa6_0(active0, 0x504a0000000L);
420 case 105:
421 return jjMoveStringLiteralDfa6_0(active0, 0x40000000L);
422 case 108:
423 if ((active0 & 0x400L) != 0L)
424 return jjStartNfaWithStates_0(5, 10, 1);
425 return jjMoveStringLiteralDfa6_0(active0, 0x5000000000L);
426 case 109:
427 if ((active0 & 0x8000L) != 0L)
428 {
429 jjmatchedKind = 15;
430 jjmatchedPos = 5;
431 }
432 return jjMoveStringLiteralDfa6_0(active0, 0x30000L);
433 case 110:
434 return jjMoveStringLiteralDfa6_0(active0, 0x42000L);
435 case 111:
436 return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L);
437 case 114:
438 return jjMoveStringLiteralDfa6_0(active0, 0x10005000L);
439 case 115:
440 return jjMoveStringLiteralDfa6_0(active0, 0xf080000L);
441 case 116:
442 return jjMoveStringLiteralDfa6_0(active0, 0x800100L);
443 case 117:
444 return jjMoveStringLiteralDfa6_0(active0, 0x2000000000L);
445 case 121:
446 return jjMoveStringLiteralDfa6_0(active0, 0xb00000000L);
447 default :
448 break;
449 }
450 return jjStartNfa_0(4, active0);
451 }
452 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
453 {
454 if (((active0 &= old0)) == 0L)
455 return jjStartNfa_0(4, old0);
456 try { curChar = input_stream.readChar(); }
457 catch(java.io.IOException e) {
458 jjStopStringLiteralDfa_0(5, active0);
459 return 6;
460 }
461 switch(curChar)
462 {
463 case 45:
464 return jjMoveStringLiteralDfa7_0(active0, 0xb00830100L);
465 case 97:
466 return jjMoveStringLiteralDfa7_0(active0, 0x2000000000L);
467 case 99:
468 return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L);
469 case 100:
470 return jjMoveStringLiteralDfa7_0(active0, 0x40000L);
471 case 101:
472 if ((active0 & 0x4000L) != 0L)
473 return jjStartNfaWithStates_0(6, 14, 1);
474 else if ((active0 & 0x80000L) != 0L)
475 return jjStartNfaWithStates_0(6, 19, 1);
476 break;
477 case 102:
478 return jjMoveStringLiteralDfa7_0(active0, 0x2000L);
479 case 105:
480 return jjMoveStringLiteralDfa7_0(active0, 0x10100000L);
481 case 109:
482 if ((active0 & 0x1000L) != 0L)
483 return jjStartNfaWithStates_0(6, 12, 1);
484 break;
485 case 110:
486 return jjMoveStringLiteralDfa7_0(active0, 0x80000000L);
487 case 111:
488 return jjMoveStringLiteralDfa7_0(active0, 0x5000000000L);
489 case 112:
490 return jjMoveStringLiteralDfa7_0(active0, 0x400000000L);
491 case 114:
492 if ((active0 & 0x20000000L) != 0L)
493 return jjStartNfaWithStates_0(6, 29, 1);
494 return jjMoveStringLiteralDfa7_0(active0, 0x10000200000L);
495 case 115:
496 return jjMoveStringLiteralDfa7_0(active0, 0x40000000000L);
497 case 116:
498 if ((active0 & 0x1000000L) != 0L)
499 {
500 jjmatchedKind = 24;
501 jjmatchedPos = 6;
502 }
503 return jjMoveStringLiteralDfa7_0(active0, 0xe000000L);
504 case 118:
505 return jjMoveStringLiteralDfa7_0(active0, 0x40000000L);
506 default :
507 break;
508 }
509 return jjStartNfa_0(5, active0);
510 }
511 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
512 {
513 if (((active0 &= old0)) == 0L)
514 return jjStartNfa_0(5, old0);
515 try { curChar = input_stream.readChar(); }
516 catch(java.io.IOException e) {
517 jjStopStringLiteralDfa_0(6, active0);
518 return 7;
519 }
520 switch(curChar)
521 {
522 case 45:
523 return jjMoveStringLiteralDfa8_0(active0, 0xe000000L);
524 case 98:
525 return jjMoveStringLiteralDfa8_0(active0, 0x210000000L);
526 case 101:
527 return jjMoveStringLiteralDfa8_0(active0, 0x40240000L);
528 case 102:
529 if ((active0 & 0x100000L) != 0L)
530 return jjStartNfaWithStates_0(7, 20, 1);
531 break;
532 case 103:
533 return jjMoveStringLiteralDfa8_0(active0, 0x6000000000L);
534 case 105:
535 return jjMoveStringLiteralDfa8_0(active0, 0x12000L);
536 case 108:
537 return jjMoveStringLiteralDfa8_0(active0, 0x400000000L);
538 case 111:
539 return jjMoveStringLiteralDfa8_0(active0, 0x8000000000L);
540 case 112:
541 return jjMoveStringLiteralDfa8_0(active0, 0x1000800100L);
542 case 114:
543 return jjMoveStringLiteralDfa8_0(active0, 0x20000L);
544 case 115:
545 return jjMoveStringLiteralDfa8_0(active0, 0x50000000000L);
546 case 116:
547 if ((active0 & 0x80000000L) != 0L)
548 return jjStartNfaWithStates_0(7, 31, 1);
549 return jjMoveStringLiteralDfa8_0(active0, 0x800000000L);
550 case 119:
551 return jjMoveStringLiteralDfa8_0(active0, 0x100000000L);
552 default :
553 break;
554 }
555 return jjStartNfa_0(6, active0);
556 }
557 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
558 {
559 if (((active0 &= old0)) == 0L)
560 return jjStartNfa_0(6, old0);
561 try { curChar = input_stream.readChar(); }
562 catch(java.io.IOException e) {
563 jjStopStringLiteralDfa_0(7, active0);
564 return 8;
565 }
566 switch(curChar)
567 {
568 case 97:
569 return jjMoveStringLiteralDfa9_0(active0, 0x10000000000L);
570 case 101:
571 if ((active0 & 0x10000000L) != 0L)
572 return jjStartNfaWithStates_0(8, 28, 1);
573 else if ((active0 & 0x1000000000L) != 0L)
574 return jjStartNfaWithStates_0(8, 36, 1);
575 else if ((active0 & 0x2000000000L) != 0L)
576 return jjStartNfaWithStates_0(8, 37, 1);
577 return jjMoveStringLiteralDfa9_0(active0, 0x40000020000L);
578 case 102:
579 if ((active0 & 0x10000L) != 0L)
580 return jjStartNfaWithStates_0(8, 16, 1);
581 else if ((active0 & 0x200000L) != 0L)
582 return jjStartNfaWithStates_0(8, 21, 1);
583 return jjMoveStringLiteralDfa9_0(active0, 0x8000000L);
584 case 105:
585 return jjMoveStringLiteralDfa9_0(active0, 0x100000000L);
586 case 108:
587 if ((active0 & 0x8000000000L) != 0L)
588 return jjStartNfaWithStates_0(8, 39, 1);
589 break;
590 case 111:
591 if ((active0 & 0x800000000L) != 0L)
592 return jjStartNfaWithStates_0(8, 35, 1);
593 break;
594 case 114:
595 if ((active0 & 0x40000000L) != 0L)
596 return jjStartNfaWithStates_0(8, 30, 1);
597 return jjMoveStringLiteralDfa9_0(active0, 0x842100L);
598 case 119:
599 return jjMoveStringLiteralDfa9_0(active0, 0x6000000L);
600 case 121:
601 if ((active0 & 0x200000000L) != 0L)
602 return jjStartNfaWithStates_0(8, 33, 1);
603 else if ((active0 & 0x4000000000L) != 0L)
604 return jjStartNfaWithStates_0(8, 38, 1);
605 return jjMoveStringLiteralDfa9_0(active0, 0x400000000L);
606 default :
607 break;
608 }
609 return jjStartNfa_0(7, active0);
610 }
611 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
612 {
613 if (((active0 &= old0)) == 0L)
614 return jjStartNfa_0(7, old0);
615 try { curChar = input_stream.readChar(); }
616 catch(java.io.IOException e) {
617 jjStopStringLiteralDfa_0(8, active0);
618 return 9;
619 }
620 switch(curChar)
621 {
622 case 45:
623 return jjMoveStringLiteralDfa10_0(active0, 0x400000000L);
624 case 102:
625 if ((active0 & 0x20000L) != 0L)
626 return jjStartNfaWithStates_0(9, 17, 1);
627 break;
628 case 104:
629 return jjMoveStringLiteralDfa10_0(active0, 0x6000000L);
630 case 109:
631 if ((active0 & 0x2000L) != 0L)
632 return jjStartNfaWithStates_0(9, 13, 1);
633 break;
634 case 111:
635 return jjMoveStringLiteralDfa10_0(active0, 0x8800100L);
636 case 115:
637 if ((active0 & 0x40000000000L) != 0L)
638 return jjStartNfaWithStates_0(9, 42, 1);
639 return jjMoveStringLiteralDfa10_0(active0, 0x40000L);
640 case 116:
641 return jjMoveStringLiteralDfa10_0(active0, 0x10100000000L);
642 default :
643 break;
644 }
645 return jjStartNfa_0(8, active0);
646 }
647 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
648 {
649 if (((active0 &= old0)) == 0L)
650 return jjStartNfa_0(8, old0);
651 try { curChar = input_stream.readChar(); }
652 catch(java.io.IOException e) {
653 jjStopStringLiteralDfa_0(9, active0);
654 return 10;
655 }
656 switch(curChar)
657 {
658 case 101:
659 return jjMoveStringLiteralDfa11_0(active0, 0x6000000L);
660 case 104:
661 if ((active0 & 0x100000000L) != 0L)
662 return jjStartNfaWithStates_0(10, 32, 1);
663 break;
664 case 105:
665 return jjMoveStringLiteralDfa11_0(active0, 0x10000000000L);
666 case 112:
667 return jjMoveStringLiteralDfa11_0(active0, 0x800100L);
668 case 114:
669 return jjMoveStringLiteralDfa11_0(active0, 0x8000000L);
670 case 116:
671 return jjMoveStringLiteralDfa11_0(active0, 0x400040000L);
672 default :
673 break;
674 }
675 return jjStartNfa_0(9, active0);
676 }
677 private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
678 {
679 if (((active0 &= old0)) == 0L)
680 return jjStartNfa_0(9, old0);
681 try { curChar = input_stream.readChar(); }
682 catch(java.io.IOException e) {
683 jjStopStringLiteralDfa_0(10, active0);
684 return 11;
685 }
686 switch(curChar)
687 {
688 case 110:
689 if ((active0 & 0x2000000L) != 0L)
690 {
691 jjmatchedKind = 25;
692 jjmatchedPos = 11;
693 }
694 return jjMoveStringLiteralDfa12_0(active0, 0x4000000L);
695 case 111:
696 if ((active0 & 0x400000000L) != 0L)
697 return jjStartNfaWithStates_0(11, 34, 1);
698 return jjMoveStringLiteralDfa12_0(active0, 0x10000840100L);
699 case 119:
700 return jjMoveStringLiteralDfa12_0(active0, 0x8000000L);
701 default :
702 break;
703 }
704 return jjStartNfa_0(10, active0);
705 }
706 private final int jjMoveStringLiteralDfa12_0(long old0, long active0)
707 {
708 if (((active0 &= old0)) == 0L)
709 return jjStartNfa_0(10, old0);
710 try { curChar = input_stream.readChar(); }
711 catch(java.io.IOException e) {
712 jjStopStringLiteralDfa_0(11, active0);
713 return 12;
714 }
715 switch(curChar)
716 {
717 case 97:
718 return jjMoveStringLiteralDfa13_0(active0, 0x8000000L);
719 case 101:
720 return jjMoveStringLiteralDfa13_0(active0, 0x4000000L);
721 case 110:
722 return jjMoveStringLiteralDfa13_0(active0, 0x10000000000L);
723 case 111:
724 return jjMoveStringLiteralDfa13_0(active0, 0x40000L);
725 case 115:
726 return jjMoveStringLiteralDfa13_0(active0, 0x800100L);
727 default :
728 break;
729 }
730 return jjStartNfa_0(11, active0);
731 }
732 private final int jjMoveStringLiteralDfa13_0(long old0, long active0)
733 {
734 if (((active0 &= old0)) == 0L)
735 return jjStartNfa_0(11, old0);
736 try { curChar = input_stream.readChar(); }
737 catch(java.io.IOException e) {
738 jjStopStringLiteralDfa_0(12, active0);
739 return 13;
740 }
741 switch(curChar)
742 {
743 case 45:
744 return jjMoveStringLiteralDfa14_0(active0, 0x10000000000L);
745 case 97:
746 return jjMoveStringLiteralDfa14_0(active0, 0x800100L);
747 case 100:
748 if ((active0 & 0x40000L) != 0L)
749 return jjStartNfaWithStates_0(13, 18, 1);
750 break;
751 case 114:
752 return jjMoveStringLiteralDfa14_0(active0, 0x8000000L);
753 case 118:
754 return jjMoveStringLiteralDfa14_0(active0, 0x4000000L);
755 default :
756 break;
757 }
758 return jjStartNfa_0(12, active0);
759 }
760 private final int jjMoveStringLiteralDfa14_0(long old0, long active0)
761 {
762 if (((active0 &= old0)) == 0L)
763 return jjStartNfa_0(12, old0);
764 try { curChar = input_stream.readChar(); }
765 catch(java.io.IOException e) {
766 jjStopStringLiteralDfa_0(13, active0);
767 return 14;
768 }
769 switch(curChar)
770 {
771 case 100:
772 if ((active0 & 0x8000000L) != 0L)
773 return jjStartNfaWithStates_0(14, 27, 1);
774 break;
775 case 101:
776 return jjMoveStringLiteralDfa15_0(active0, 0x4000000L);
777 case 105:
778 return jjMoveStringLiteralDfa15_0(active0, 0x10000000000L);
779 case 108:
780 if ((active0 & 0x100L) != 0L)
781 return jjStartNfaWithStates_0(14, 8, 1);
782 else if ((active0 & 0x800000L) != 0L)
783 return jjStartNfaWithStates_0(14, 23, 1);
784 break;
785 default :
786 break;
787 }
788 return jjStartNfa_0(13, active0);
789 }
790 private final int jjMoveStringLiteralDfa15_0(long old0, long active0)
791 {
792 if (((active0 &= old0)) == 0L)
793 return jjStartNfa_0(13, old0);
794 try { curChar = input_stream.readChar(); }
795 catch(java.io.IOException e) {
796 jjStopStringLiteralDfa_0(14, active0);
797 return 15;
798 }
799 switch(curChar)
800 {
801 case 100:
802 if ((active0 & 0x10000000000L) != 0L)
803 return jjStartNfaWithStates_0(15, 40, 1);
804 break;
805 case 114:
806 if ((active0 & 0x4000000L) != 0L)
807 return jjStartNfaWithStates_0(15, 26, 1);
808 break;
809 default :
810 break;
811 }
812 return jjStartNfa_0(14, active0);
813 }
814 private final void jjCheckNAdd(int state)
815 {
816 if (jjrounds[state] != jjround)
817 {
818 jjstateSet[jjnewStateCnt++] = state;
819 jjrounds[state] = jjround;
820 }
821 }
822 private final void jjAddStates(int start, int end)
823 {
824 do {
825 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
826 } while (start++ != end);
827 }
828 private final void jjCheckNAddTwoStates(int state1, int state2)
829 {
830 jjCheckNAdd(state1);
831 jjCheckNAdd(state2);
832 }
833 private final void jjCheckNAddStates(int start, int end)
834 {
835 do {
836 jjCheckNAdd(jjnextStates[start]);
837 } while (start++ != end);
838 }
839 private final void jjCheckNAddStates(int start)
840 {
841 jjCheckNAdd(jjnextStates[start]);
842 jjCheckNAdd(jjnextStates[start + 1]);
843 }
844 static final long[] jjbitVec0 = {
845 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
846 };
847 private final int jjMoveNfa_0(int startState, int curPos)
848 {
849 int[] nextStates;
850 int startsAt = 0;
851 jjnewStateCnt = 56;
852 int i = 1;
853 jjstateSet[0] = startState;
854 int j, kind = 0x7fffffff;
855 for (;;)
856 {
857 if (++jjround == 0x7fffffff)
858 ReInitRounds();
859 if (curChar < 64)
860 {
861 long l = 1L << curChar;
862 MatchLoop: do
863 {
864 switch(jjstateSet[--i])
865 {
866 case 0:
867 if ((0xfc00dcf2ffffc9ffL & l) != 0L)
868 {
869 if (kind > 43)
870 kind = 43;
871 jjCheckNAdd(1);
872 }
873 else if ((0x3ff000000000000L & l) != 0L)
874 jjCheckNAddStates(0, 7);
875 else if (curChar == 34)
876 jjCheckNAddStates(8, 10);
877 if ((0x3fe000000000000L & l) != 0L)
878 {
879 if (kind > 44)
880 kind = 44;
881 jjCheckNAddTwoStates(5, 3);
882 }
883 else if (curChar == 43)
884 jjstateSet[jjnewStateCnt++] = 13;
885 else if (curChar == 46)
886 jjCheckNAdd(7);
887 else if (curChar == 48)
888 {
889 if (kind > 44)
890 kind = 44;
891 jjCheckNAdd(3);
892 }
893 break;
894 case 1:
895 if ((0xfffffcfaffffc9ffL & l) == 0L)
896 break;
897 if (kind > 43)
898 kind = 43;
899 jjCheckNAdd(1);
900 break;
901 case 2:
902 if (curChar != 48)
903 break;
904 if (kind > 44)
905 kind = 44;
906 jjCheckNAdd(3);
907 break;
908 case 4:
909 if ((0x3fe000000000000L & l) == 0L)
910 break;
911 if (kind > 44)
912 kind = 44;
913 jjCheckNAddTwoStates(5, 3);
914 break;
915 case 5:
916 if ((0x3ff000000000000L & l) == 0L)
917 break;
918 if (kind > 44)
919 kind = 44;
920 jjCheckNAddTwoStates(5, 3);
921 break;
922 case 6:
923 if (curChar == 46)
924 jjCheckNAdd(7);
925 break;
926 case 7:
927 if ((0x3ff000000000000L & l) == 0L)
928 break;
929 if (kind > 45)
930 kind = 45;
931 jjCheckNAddStates(11, 13);
932 break;
933 case 9:
934 if ((0x280000000000L & l) != 0L)
935 jjCheckNAdd(10);
936 break;
937 case 10:
938 if ((0x3ff000000000000L & l) == 0L)
939 break;
940 if (kind > 45)
941 kind = 45;
942 jjCheckNAddTwoStates(10, 11);
943 break;
944 case 12:
945 if (curChar == 43)
946 jjstateSet[jjnewStateCnt++] = 13;
947 break;
948 case 13:
949 if ((0x3ff000000000000L & l) != 0L)
950 jjCheckNAdd(14);
951 break;
952 case 14:
953 if ((0x3ff000000000000L & l) != 0L)
954 jjstateSet[jjnewStateCnt++] = 15;
955 break;
956 case 15:
957 if ((0x3ff000000000000L & l) != 0L)
958 jjstateSet[jjnewStateCnt++] = 16;
959 break;
960 case 16:
961 if ((0x3ff000000000000L & l) != 0L)
962 jjstateSet[jjnewStateCnt++] = 17;
963 break;
964 case 17:
965 if ((0x3ff000000000000L & l) != 0L)
966 jjstateSet[jjnewStateCnt++] = 18;
967 break;
968 case 18:
969 if ((0x3ff000000000000L & l) != 0L)
970 jjstateSet[jjnewStateCnt++] = 19;
971 break;
972 case 19:
973 if ((0x3ff000000000000L & l) != 0L)
974 jjstateSet[jjnewStateCnt++] = 20;
975 break;
976 case 20:
977 if ((0x3ff000000000000L & l) != 0L)
978 jjstateSet[jjnewStateCnt++] = 21;
979 break;
980 case 22:
981 if ((0x3ff000000000000L & l) != 0L)
982 jjstateSet[jjnewStateCnt++] = 23;
983 break;
984 case 23:
985 if ((0x3ff000000000000L & l) != 0L)
986 jjstateSet[jjnewStateCnt++] = 24;
987 break;
988 case 24:
989 if ((0x3ff000000000000L & l) != 0L)
990 jjstateSet[jjnewStateCnt++] = 25;
991 break;
992 case 25:
993 if ((0x3ff000000000000L & l) != 0L)
994 jjstateSet[jjnewStateCnt++] = 26;
995 break;
996 case 26:
997 if ((0x3ff000000000000L & l) != 0L)
998 jjstateSet[jjnewStateCnt++] = 27;
999 break;
1000 case 27:
1001 if ((0x3ff000000000000L & l) != 0L)
1002 jjstateSet[jjnewStateCnt++] = 28;
1003 break;
1004 case 28:
1005 if ((0x3ff000000000000L & l) != 0L)
1006 jjstateSet[jjnewStateCnt++] = 29;
1007 break;
1008 case 29:
1009 if ((0x3ff000000000000L & l) != 0L)
1010 jjstateSet[jjnewStateCnt++] = 30;
1011 break;
1012 case 30:
1013 if ((0x3ff000000000000L & l) == 0L)
1014 break;
1015 if (kind > 46)
1016 kind = 46;
1017 jjstateSet[jjnewStateCnt++] = 31;
1018 break;
1019 case 32:
1020 if (curChar == 34)
1021 jjCheckNAddStates(8, 10);
1022 break;
1023 case 33:
1024 if ((0xfffffffbffffdbffL & l) != 0L)
1025 jjCheckNAddStates(8, 10);
1026 break;
1027 case 35:
1028 if ((0x8400000000L & l) != 0L)
1029 jjCheckNAddStates(8, 10);
1030 break;
1031 case 36:
1032 if (curChar == 34 && kind > 47)
1033 kind = 47;
1034 break;
1035 case 37:
1036 if ((0xff000000000000L & l) != 0L)
1037 jjCheckNAddStates(14, 17);
1038 break;
1039 case 38:
1040 if ((0xff000000000000L & l) != 0L)
1041 jjCheckNAddStates(8, 10);
1042 break;
1043 case 39:
1044 if ((0xf000000000000L & l) != 0L)
1045 jjstateSet[jjnewStateCnt++] = 40;
1046 break;
1047 case 40:
1048 if ((0xff000000000000L & l) != 0L)
1049 jjCheckNAdd(38);
1050 break;
1051 case 41:
1052 if ((0x3ff000000000000L & l) != 0L)
1053 jjCheckNAddStates(0, 7);
1054 break;
1055 case 42:
1056 if ((0x3ff000000000000L & l) != 0L)
1057 jjCheckNAddTwoStates(42, 43);
1058 break;
1059 case 43:
1060 if (curChar != 46)
1061 break;
1062 if (kind > 45)
1063 kind = 45;
1064 jjCheckNAddStates(18, 20);
1065 break;
1066 case 44:
1067 if ((0x3ff000000000000L & l) == 0L)
1068 break;
1069 if (kind > 45)
1070 kind = 45;
1071 jjCheckNAddStates(18, 20);
1072 break;
1073 case 46:
1074 if ((0x280000000000L & l) != 0L)
1075 jjCheckNAdd(47);
1076 break;
1077 case 47:
1078 if ((0x3ff000000000000L & l) == 0L)
1079 break;
1080 if (kind > 45)
1081 kind = 45;
1082 jjCheckNAddTwoStates(47, 11);
1083 break;
1084 case 48:
1085 if ((0x3ff000000000000L & l) != 0L)
1086 jjCheckNAddTwoStates(48, 49);
1087 break;
1088 case 50:
1089 if ((0x280000000000L & l) != 0L)
1090 jjCheckNAdd(51);
1091 break;
1092 case 51:
1093 if ((0x3ff000000000000L & l) == 0L)
1094 break;
1095 if (kind > 45)
1096 kind = 45;
1097 jjCheckNAddTwoStates(51, 11);
1098 break;
1099 case 52:
1100 if ((0x3ff000000000000L & l) != 0L)
1101 jjCheckNAddStates(21, 23);
1102 break;
1103 case 54:
1104 if ((0x280000000000L & l) != 0L)
1105 jjCheckNAdd(55);
1106 break;
1107 case 55:
1108 if ((0x3ff000000000000L & l) != 0L)
1109 jjCheckNAddTwoStates(55, 11);
1110 break;
1111 default : break;
1112 }
1113 } while(i != startsAt);
1114 }
1115 else if (curChar < 128)
1116 {
1117 long l = 1L << (curChar & 077);
1118 MatchLoop: do
1119 {
1120 switch(jjstateSet[--i])
1121 {
1122 case 0:
1123 if ((0xfffffffffffffffeL & l) == 0L)
1124 break;
1125 if (kind > 43)
1126 kind = 43;
1127 jjCheckNAdd(1);
1128 break;
1129 case 1:
1130 if (kind > 43)
1131 kind = 43;
1132 jjCheckNAdd(1);
1133 break;
1134 case 3:
1135 if ((0x100000001000L & l) != 0L && kind > 44)
1136 kind = 44;
1137 break;
1138 case 8:
1139 if ((0x2000000020L & l) != 0L)
1140 jjAddStates(24, 25);
1141 break;
1142 case 11:
1143 if ((0x5000000050L & l) != 0L && kind > 45)
1144 kind = 45;
1145 break;
1146 case 21:
1147 if (curChar == 84)
1148 jjstateSet[jjnewStateCnt++] = 22;
1149 break;
1150 case 31:
1151 if ((0x7fffffe07fffffeL & l) != 0L && kind > 46)
1152 kind = 46;
1153 break;
1154 case 33:
1155 if ((0xffffffffefffffffL & l) != 0L)
1156 jjCheckNAddStates(8, 10);
1157 break;
1158 case 34:
1159 if (curChar == 92)
1160 jjAddStates(26, 28);
1161 break;
1162 case 35:
1163 if ((0x14404410000000L & l) != 0L)
1164 jjCheckNAddStates(8, 10);
1165 break;
1166 case 45:
1167 if ((0x2000000020L & l) != 0L)
1168 jjAddStates(29, 30);
1169 break;
1170 case 49:
1171 if ((0x2000000020L & l) != 0L)
1172 jjAddStates(31, 32);
1173 break;
1174 case 53:
1175 if ((0x2000000020L & l) != 0L)
1176 jjAddStates(33, 34);
1177 break;
1178 default : break;
1179 }
1180 } while(i != startsAt);
1181 }
1182 else
1183 {
1184 int i2 = (curChar & 0xff) >> 6;
1185 long l2 = 1L << (curChar & 077);
1186 MatchLoop: do
1187 {
1188 switch(jjstateSet[--i])
1189 {
1190 case 0:
1191 case 1:
1192 if ((jjbitVec0[i2] & l2) == 0L)
1193 break;
1194 if (kind > 43)
1195 kind = 43;
1196 jjCheckNAdd(1);
1197 break;
1198 case 33:
1199 if ((jjbitVec0[i2] & l2) != 0L)
1200 jjAddStates(8, 10);
1201 break;
1202 default : break;
1203 }
1204 } while(i != startsAt);
1205 }
1206 if (kind != 0x7fffffff)
1207 {
1208 jjmatchedKind = kind;
1209 jjmatchedPos = curPos;
1210 kind = 0x7fffffff;
1211 }
1212 ++curPos;
1213 if ((i = jjnewStateCnt) == (startsAt = 56 - (jjnewStateCnt = startsAt)))
1214 return curPos;
1215 try { curChar = input_stream.readChar(); }
1216 catch(java.io.IOException e) { return curPos; }
1217 }
1218 }
1219 static final int[] jjnextStates = {
1220 42, 43, 48, 49, 52, 53, 11, 14, 33, 34, 36, 7, 8, 11, 33, 34,
1221 38, 36, 44, 45, 11, 52, 53, 11, 9, 10, 35, 37, 39, 46, 47, 50,
1222 51, 54, 55,
1223 };
1224 public static final String[] jjstrLiteralImages = {
1225 "", null, null, null, null, null, "\50", "\51",
1226 "\141\143\143\145\160\164\55\160\162\157\160\157\163\141\154", "\141\147\162\145\145", "\143\141\156\143\145\154", "\143\146\160",
1227 "\143\157\156\146\151\162\155", "\144\151\163\143\157\156\146\151\162\155", "\146\141\151\154\165\162\145",
1228 "\151\156\146\157\162\155", "\151\156\146\157\162\155\55\151\146",
1229 "\151\156\146\157\162\155\55\162\145\146", "\156\157\164\55\165\156\144\145\162\163\164\157\157\144",
1230 "\160\162\157\160\157\163\145", "\161\165\145\162\171\55\151\146", "\161\165\145\162\171\55\162\145\146",
1231 "\162\145\146\165\163\145", "\162\145\152\145\143\164\55\160\162\157\160\157\163\141\154",
1232 "\162\145\161\165\145\163\164", "\162\145\161\165\145\163\164\55\167\150\145\156",
1233 "\162\145\161\165\145\163\164\55\167\150\145\156\145\166\145\162", "\162\145\161\165\145\163\164\55\146\157\162\167\141\162\144",
1234 "\163\165\142\163\143\162\151\142\145", "\72\163\145\156\144\145\162", "\72\162\145\143\145\151\166\145\162",
1235 "\72\143\157\156\164\145\156\164", "\72\162\145\160\154\171\55\167\151\164\150",
1236 "\72\162\145\160\154\171\55\142\171", "\72\151\156\55\162\145\160\154\171\55\164\157",
1237 "\72\162\145\160\154\171\55\164\157", "\72\145\156\166\145\154\157\160\145", "\72\154\141\156\147\165\141\147\145",
1238 "\72\157\156\164\157\154\157\147\171", "\72\160\162\157\164\157\143\157\154",
1239 "\72\143\157\156\166\145\162\163\141\164\151\157\156\55\151\144", "\72\156\141\155\145", "\72\141\144\144\162\145\163\163\145\163", null, null,
1240 null, null, null, null, null, null, null, "\100", };
1241 public static final String[] lexStateNames = {
1242 "DEFAULT",
1243 };
1244 static final long[] jjtoToken = {
1245 0x10ffffffffffc1L,
1246 };
1247 static final long[] jjtoSkip = {
1248 0x3eL,
1249 };
1250 private ASCII_CharStream input_stream;
1251 private final int[] jjrounds = new int[56];
1252 private final int[] jjstateSet = new int[112];
1253 protected char curChar;
1254 public PerformativeParserTokenManager(ASCII_CharStream stream)
1255 {
1256 if (ASCII_CharStream.staticFlag)
1257 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1258 input_stream = stream;
1259 }
1260 public PerformativeParserTokenManager(ASCII_CharStream stream, int lexState)
1261 {
1262 this(stream);
1263 SwitchTo(lexState);
1264 }
1265 public void ReInit(ASCII_CharStream stream)
1266 {
1267 jjmatchedPos = jjnewStateCnt = 0;
1268 curLexState = defaultLexState;
1269 input_stream = stream;
1270 ReInitRounds();
1271 }
1272 private final void ReInitRounds()
1273 {
1274 int i;
1275 jjround = 0x80000001;
1276 for (i = 56; i-- > 0;)
1277 jjrounds[i] = 0x80000000;
1278 }
1279 public void ReInit(ASCII_CharStream stream, int lexState)
1280 {
1281 ReInit(stream);
1282 SwitchTo(lexState);
1283 }
1284 public void SwitchTo(int lexState)
1285 {
1286 if (lexState >= 1 || lexState < 0)
1287 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1288 else
1289 curLexState = lexState;
1290 }
1291
1292 private final Token jjFillToken()
1293 {
1294 Token t = Token.newToken(jjmatchedKind);
1295 t.kind = jjmatchedKind;
1296 String im = jjstrLiteralImages[jjmatchedKind];
1297 t.image = (im == null) ? input_stream.GetImage() : im;
1298 t.beginLine = input_stream.getBeginLine();
1299 t.beginColumn = input_stream.getBeginColumn();
1300 t.endLine = input_stream.getEndLine();
1301 t.endColumn = input_stream.getEndColumn();
1302 return t;
1303 }
1304
1305 int curLexState = 0;
1306 int defaultLexState = 0;
1307 int jjnewStateCnt;
1308 int jjround;
1309 int jjmatchedPos;
1310 int jjmatchedKind;
1311
1312 public final Token getNextToken()
1313 {
1314 int kind;
1315 Token specialToken = null;
1316 Token matchedToken;
1317 int curPos = 0;
1318
1319 EOFLoop :
1320 for (;;)
1321 {
1322 try
1323 {
1324 curChar = input_stream.BeginToken();
1325 }
1326 catch(java.io.IOException e)
1327 {
1328 jjmatchedKind = 0;
1329 matchedToken = jjFillToken();
1330 return matchedToken;
1331 }
1332
1333 try { input_stream.backup(0);
1334 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1335 curChar = input_stream.BeginToken();
1336 }
1337 catch (java.io.IOException e1) { continue EOFLoop; }
1338 jjmatchedKind = 0x7fffffff;
1339 jjmatchedPos = 0;
1340 curPos = jjMoveStringLiteralDfa0_0();
1341 if (jjmatchedKind != 0x7fffffff)
1342 {
1343 if (jjmatchedPos + 1 < curPos)
1344 input_stream.backup(curPos - jjmatchedPos - 1);
1345 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1346 {
1347 matchedToken = jjFillToken();
1348 return matchedToken;
1349 }
1350 else
1351 {
1352 continue EOFLoop;
1353 }
1354 }
1355 int error_line = input_stream.getEndLine();
1356 int error_column = input_stream.getEndColumn();
1357 String error_after = null;
1358 boolean EOFSeen = false;
1359 try { input_stream.readChar(); input_stream.backup(1); }
1360 catch (java.io.IOException e1) {
1361 EOFSeen = true;
1362 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1363 if (curChar == '\n' || curChar == '\r') {
1364 error_line++;
1365 error_column = 0;
1366 }
1367 else
1368 error_column++;
1369 }
1370 if (!EOFSeen) {
1371 input_stream.backup(1);
1372 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1373 }
1374 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1375 }
1376 }
1377
1378 }