View Javadoc
1   /* Generated By:JavaCC: Do not edit this line. MatlabParserTokenManager.java */
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   /** Token Manager. */
7   public class MatlabParserTokenManager extends net.sourceforge.pmd.lang.ast.AbstractTokenManager implements MatlabParserConstants
8   {
9   
10    /** Debug output. */
11    public  java.io.PrintStream debugStream = System.out;
12    /** Set debug output. */
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 /** Token literal values. */
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 /** Lexer state names. */
1659 public static final String[] lexStateNames = {
1660    "DEFAULT",
1661    "TRANSPOSE",
1662    "IN_COMMENT",
1663    "IN_LINE_COMMENT",
1664 };
1665 
1666 /** Lex State array. */
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 /** Constructor. */
1687 public MatlabParserTokenManager(CharStream stream){
1688    input_stream = stream;
1689 }
1690 
1691 /** Constructor. */
1692 public MatlabParserTokenManager(CharStream stream, int lexState){
1693    this(stream);
1694    SwitchTo(lexState);
1695 }
1696 
1697 /** Reinitialise parser. */
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 /** Reinitialise parser. */
1714 public void ReInit(CharStream stream, int lexState)
1715 {
1716    ReInit(stream);
1717    SwitchTo(lexState);
1718 }
1719 
1720 /** Switch to specified lex state. */
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 /** Get the next Token. */
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 }