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