source: java/FramclipsePlugin/src/main/java/com/framsticks/framclipse/internal/parser/FramclipseNonScriptParserTokenManager.java @ 193

Last change on this file since 193 was 193, checked in by Maciej Komosinski, 10 years ago

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