
JavaParserTokenManager.java


0001 /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParserTokenManager.java */

0002 package net.sourceforge.pmd.lang.java.ast;

0003 import java.util.*;

0004 import net.sourceforge.pmd.PMD;

0005 import net.sourceforge.pmd.lang.ast.CharStream;

0006 import net.sourceforge.pmd.lang.ast.TokenMgrError;

0007 

0008 /** Token Manager. */

0009 public class JavaParserTokenManager extends net.sourceforge.pmd.lang.ast.AbstractTokenManager implements JavaParserConstants

0010 {

0011     protected List<Comment> comments = new ArrayList<Comment>();

0012 

0013   /** Debug output. */

0014   public  java.io.PrintStream debugStream = System.out;

0015   /** Set debug output. */

0016   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }

0017 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)

0018 {

0019    switch (pos)

0020    {

0021       case 0:

0022          if ((active1 & 0x80000000080000L) != 0L)

0023             return 4;

0024          if ((active0 & 0x7ffffffffffff000L) != 0L)

0025          {

0026             jjmatchedKind = 72;

0027             return 28;

0028          }

0029          if ((active0 & 0x100L) != 0L || (active1 & 0x804000000000L) != 0L)

0030             return 45;

0031          return -1;

0032       case 1:

0033          if ((active0 & 0x201800000L) != 0L)

0034             return 28;

0035          if ((active0 & 0x7ffffffdfe7ff000L) != 0L)

0036          {

0037             if (jjmatchedPos != 1)

0038             {

0039                jjmatchedKind = 72;

0040                jjmatchedPos = 1;

0041             }

0042             return 28;

0043          }

0044          if ((active0 & 0x100L) != 0L)

0045             return 50;

0046          return -1;

0047       case 2:

0048          if ((active0 & 0x400026080000000L) != 0L)

0049             return 28;

0050          if ((active0 & 0x7bfffd9d7f7ff000L) != 0L)

0051          {

0052             if (jjmatchedPos != 2)

0053             {

0054                jjmatchedKind = 72;

0055                jjmatchedPos = 2;

0056             }

0057             return 28;

0058          }

0059          return -1;

0060       case 3:

0061          if ((active0 & 0x71dff95c7d7a7000L) != 0L)

0062          {

0063             jjmatchedKind = 72;

0064             jjmatchedPos = 3;

0065             return 28;

0066          }

0067          if ((active0 & 0xa20048102058000L) != 0L)

0068             return 28;

0069          return -1;

0070       case 4:

0071          if ((active0 & 0x20c50000781a4000L) != 0L)

0072             return 28;

0073          if ((active0 & 0x511af95c05603000L) != 0L)

0074          {

0075             if (jjmatchedPos != 4)

0076             {

0077                jjmatchedKind = 72;

0078                jjmatchedPos = 4;

0079             }

0080             return 28;

0081          }

0082          return -1;

0083       case 5:

0084          if ((active0 & 0x8ac10801000000L) != 0L)

0085             return 28;

0086          if ((active0 & 0x5110385424603000L) != 0L)

0087          {

0088             jjmatchedKind = 72;

0089             jjmatchedPos = 5;

0090             return 28;

0091          }

0092          return -1;

0093       case 6:

0094          if ((active0 & 0x5110205400201000L) != 0L)

0095          {

0096             jjmatchedKind = 72;

0097             jjmatchedPos = 6;

0098             return 28;

0099          }

0100          if ((active0 & 0x180024402000L) != 0L)

0101             return 28;

0102          return -1;

0103       case 7:

0104          if ((active0 & 0x5000000000201000L) != 0L)

0105             return 28;

0106          if ((active0 & 0x110205400000000L) != 0L)

0107          {

0108             jjmatchedKind = 72;

0109             jjmatchedPos = 7;

0110             return 28;

0111          }

0112          return -1;

0113       case 8:

0114          if ((active0 & 0x100204000000000L) != 0L)

0115             return 28;

0116          if ((active0 & 0x10001400000000L) != 0L)

0117          {

0118             jjmatchedKind = 72;

0119             jjmatchedPos = 8;

0120             return 28;

0121          }

0122          return -1;

0123       case 9:

0124          if ((active0 & 0x1400000000L) != 0L)

0125             return 28;

0126          if ((active0 & 0x10000000000000L) != 0L)

0127          {

0128             jjmatchedKind = 72;

0129             jjmatchedPos = 9;

0130             return 28;

0131          }

0132          return -1;

0133       case 10:

0134          if ((active0 & 0x10000000000000L) != 0L)

0135          {

0136             jjmatchedKind = 72;

0137             jjmatchedPos = 10;

0138             return 28;

0139          }

0140          return -1;

0141       default :

0142          return -1;

0143    }

0144 }

0145 private final int jjStartNfa_0(int pos, long active0, long active1)

0146 {

0147    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);

0148 }

0149 private int jjStopAtPos(int pos, int kind)

0150 {

0151    jjmatchedKind = kind;

0152    jjmatchedPos = pos;

0153    return pos + 1;

0154 }

0155 private int jjMoveStringLiteralDfa0_0()

0156 {

0157    switch(curChar)

0158    {

0159       case 9:

0160          return jjStopAtPos(0, 2);

0161       case 10:

0162          return jjStopAtPos(0, 3);

0163       case 12:

0164          return jjStopAtPos(0, 5);

0165       case 13:

0166          return jjStopAtPos(0, 4);

0167       case 26:

0168          return jjStopAtPos(0, 123);

0169       case 32:

0170          return jjStopAtPos(0, 1);

0171       case 33:

0172          jjmatchedKind = 87;

0173          return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000L);

0174       case 37:

0175          jjmatchedKind = 106;

0176          return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000L);

0177       case 38:

0178          jjmatchedKind = 103;

0179          return jjMoveStringLiteralDfa1_0(0x0L, 0x1000100000000L);

0180       case 40:

0181          return jjStopAtPos(0, 75);

0182       case 41:

0183          return jjStopAtPos(0, 76);

0184       case 42:

0185          jjmatchedKind = 101;

0186          return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000000L);

0187       case 43:

0188          jjmatchedKind = 99;

0189          return jjMoveStringLiteralDfa1_0(0x0L, 0x100200000000L);

0190       case 44:

0191          return jjStopAtPos(0, 82);

0192       case 45:

0193          jjmatchedKind = 100;

0194          return jjMoveStringLiteralDfa1_0(0x0L, 0x200400000000L);

0195       case 46:

0196          jjmatchedKind = 83;

0197          return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000000000L);

0198       case 47:

0199          jjmatchedKind = 102;

0200          return jjMoveStringLiteralDfa1_0(0x100L, 0x800000000000L);

0201       case 58:

0202          return jjStopAtPos(0, 90);

0203       case 59:

0204          return jjStopAtPos(0, 81);

0205       case 60:

0206          jjmatchedKind = 86;

0207          return jjMoveStringLiteralDfa1_0(0x0L, 0x10080010000000L);

0208       case 61:

0209          jjmatchedKind = 85;

0210          return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000L);

0211       case 62:

0212          jjmatchedKind = 122;

0213          return jjMoveStringLiteralDfa1_0(0x0L, 0x360000020000000L);

0214       case 63:

0215          return jjStopAtPos(0, 89);

0216       case 64:

0217          return jjStopAtPos(0, 84);

0218       case 91:

0219          return jjStopAtPos(0, 79);

0220       case 93:

0221          return jjStopAtPos(0, 80);

0222       case 94:

0223          jjmatchedKind = 105;

0224          return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000000L);

0225       case 97:

0226          return jjMoveStringLiteralDfa1_0(0x1000L, 0x0L);

0227       case 98:

0228          return jjMoveStringLiteralDfa1_0(0xe000L, 0x0L);

0229       case 99:

0230          return jjMoveStringLiteralDfa1_0(0x3f0000L, 0x0L);

0231       case 100:

0232          return jjMoveStringLiteralDfa1_0(0x1c00000L, 0x0L);

0233       case 101:

0234          return jjMoveStringLiteralDfa1_0(0x6000000L, 0x0L);

0235       case 102:

0236          return jjMoveStringLiteralDfa1_0(0xf8000000L, 0x0L);

0237       case 103:

0238          return jjMoveStringLiteralDfa1_0(0x100000000L, 0x0L);

0239       case 105:

0240          return jjMoveStringLiteralDfa1_0(0x7e00000000L, 0x0L);

0241       case 108:

0242          return jjMoveStringLiteralDfa1_0(0x8000000000L, 0x0L);

0243       case 110:

0244          return jjMoveStringLiteralDfa1_0(0x70000000000L, 0x0L);

0245       case 112:

0246          return jjMoveStringLiteralDfa1_0(0x780000000000L, 0x0L);

0247       case 114:

0248          return jjMoveStringLiteralDfa1_0(0x800000000000L, 0x0L);

0249       case 115:

0250          return jjMoveStringLiteralDfa1_0(0x401f000000000000L, 0x0L);

0251       case 116:

0252          return jjMoveStringLiteralDfa1_0(0x7e0000000000000L, 0x0L);

0253       case 118:

0254          return jjMoveStringLiteralDfa1_0(0x1800000000000000L, 0x0L);

0255       case 119:

0256          return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L);

0257       case 123:

0258          return jjStopAtPos(0, 77);

0259       case 124:

0260          jjmatchedKind = 104;

0261          return jjMoveStringLiteralDfa1_0(0x0L, 0x2000080000000L);

0262       case 125:

0263          return jjStopAtPos(0, 78);

0264       case 126:

0265          jjmatchedKind = 88;

0266          return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000000L);

0267       default :

0268          return jjMoveNfa_0(0, 0);

0269    }

0270 }

0271 private int jjMoveStringLiteralDfa1_0(long active0, long active1)

0272 {

0273    try { curChar = input_stream.readChar(); }

0274    catch(java.io.IOException e) {

0275       jjStopStringLiteralDfa_0(0, active0, active1);

0276       return 1;

0277    }

0278    switch(curChar)

0279    {

0280       case 38:

0281          if ((active1 & 0x100000000L) != 0L)

0282             return jjStopAtPos(1, 96);

0283          break;

0284       case 42:

0285          if ((active0 & 0x100L) != 0L)

0286             return jjStartNfaWithStates_0(1, 8, 50);

0287          break;

0288       case 43:

0289          if ((active1 & 0x200000000L) != 0L)

0290             return jjStopAtPos(1, 97);

0291          break;

0292       case 45:

0293          if ((active1 & 0x400000000L) != 0L)

0294             return jjStopAtPos(1, 98);

0295          break;

0296       case 46:

0297          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x80000000000000L);

0298       case 60:

0299          if ((active1 & 0x80000000000L) != 0L)

0300          {

0301             jjmatchedKind = 107;

0302             jjmatchedPos = 1;

0303          }

0304          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x10000000000000L);

0305       case 61:

0306          if ((active1 & 0x8000000L) != 0L)

0307             return jjStopAtPos(1, 91);

0308          else if ((active1 & 0x10000000L) != 0L)

0309             return jjStopAtPos(1, 92);

0310          else if ((active1 & 0x20000000L) != 0L)

0311             return jjStopAtPos(1, 93);

0312          else if ((active1 & 0x40000000L) != 0L)

0313             return jjStopAtPos(1, 94);

0314          else if ((active1 & 0x100000000000L) != 0L)

0315             return jjStopAtPos(1, 108);

0316          else if ((active1 & 0x200000000000L) != 0L)

0317             return jjStopAtPos(1, 109);

0318          else if ((active1 & 0x400000000000L) != 0L)

0319             return jjStopAtPos(1, 110);

0320          else if ((active1 & 0x800000000000L) != 0L)

0321             return jjStopAtPos(1, 111);

0322          else if ((active1 & 0x1000000000000L) != 0L)

0323             return jjStopAtPos(1, 112);

0324          else if ((active1 & 0x2000000000000L) != 0L)

0325             return jjStopAtPos(1, 113);

0326          else if ((active1 & 0x4000000000000L) != 0L)

0327             return jjStopAtPos(1, 114);

0328          else if ((active1 & 0x8000000000000L) != 0L)

0329             return jjStopAtPos(1, 115);

0330          break;

0331       case 62:

0332          if ((active1 & 0x200000000000000L) != 0L)

0333          {

0334             jjmatchedKind = 121;

0335             jjmatchedPos = 1;

0336          }

0337          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x160000000000000L);

0338       case 91:

0339          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x1000000000000000L);

0340       case 97:

0341          return jjMoveStringLiteralDfa2_0(active0, 0x90008030000L, active1, 0L);

0342       case 98:

0343          return jjMoveStringLiteralDfa2_0(active0, 0x1000L, active1, 0L);

0344       case 101:

0345          return jjMoveStringLiteralDfa2_0(active0, 0x820000400000L, active1, 0L);

0346       case 102:

0347          if ((active0 & 0x200000000L) != 0L)

0348             return jjStartNfaWithStates_0(1, 33, 28);

0349          break;

0350       case 104:

0351          return jjMoveStringLiteralDfa2_0(active0, 0x20e1000000040000L, active1, 0L);

0352       case 105:

0353          return jjMoveStringLiteralDfa2_0(active0, 0x30000000L, active1, 0L);

0354       case 108:

0355          return jjMoveStringLiteralDfa2_0(active0, 0x42080000L, active1, 0L);

0356       case 109:

0357          return jjMoveStringLiteralDfa2_0(active0, 0xc00000000L, active1, 0L);

0358       case 110:

0359          return jjMoveStringLiteralDfa2_0(active0, 0x7000000000L, active1, 0L);

0360       case 111:

0361          if ((active0 & 0x800000L) != 0L)

0362          {

0363             jjmatchedKind = 23;

0364             jjmatchedPos = 1;

0365          }

0366          return jjMoveStringLiteralDfa2_0(active0, 0x1800008181302000L, active1, 0L);

0367       case 114:

0368          return jjMoveStringLiteralDfa2_0(active0, 0x700300000004000L, active1, 0L);

0369       case 116:

0370          return jjMoveStringLiteralDfa2_0(active0, 0x4002000000000000L, active1, 0L);

0371       case 117:

0372          return jjMoveStringLiteralDfa2_0(active0, 0x4440000000000L, active1, 0L);

0373       case 119:

0374          return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L, active1, 0L);

0375       case 120:

0376          return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0L);

0377       case 121:

0378          return jjMoveStringLiteralDfa2_0(active0, 0x10000000008000L, active1, 0L);

0379       case 124:

0380          if ((active1 & 0x80000000L) != 0L)

0381             return jjStopAtPos(1, 95);

0382          break;

0383       default :

0384          break;

0385    }

0386    return jjStartNfa_0(0, active0, active1);

0387 }

0388 private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)

0389 {

0390    if (((active0 &= old0) | (active1 &= old1)) == 0L)

0391       return jjStartNfa_0(0, old0, old1);

0392    try { curChar = input_stream.readChar(); }

0393    catch(java.io.IOException e) {

0394       jjStopStringLiteralDfa_0(1, active0, active1);

0395       return 2;

0396    }

0397    switch(curChar)

0398    {

0399       case 46:

0400          if ((active1 & 0x80000000000000L) != 0L)

0401             return jjStopAtPos(2, 119);

0402          break;

0403       case 61:

0404          if ((active1 & 0x10000000000000L) != 0L)

0405             return jjStopAtPos(2, 116);

0406          else if ((active1 & 0x20000000000000L) != 0L)

0407             return jjStopAtPos(2, 117);

0408          break;

0409       case 62:

0410          if ((active1 & 0x100000000000000L) != 0L)

0411          {

0412             jjmatchedKind = 120;

0413             jjmatchedPos = 2;

0414          }

0415          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x40000000000000L);

0416       case 93:

0417          if ((active1 & 0x1000000000000000L) != 0L)

0418             return jjStopAtPos(2, 124);

0419          break;

0420       case 97:

0421          return jjMoveStringLiteralDfa3_0(active0, 0x1020000000c0000L, active1, 0L);

0422       case 98:

0423          return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L, active1, 0L);

0424       case 99:

0425          return jjMoveStringLiteralDfa3_0(active0, 0x80000000000L, active1, 0L);

0426       case 101:

0427          return jjMoveStringLiteralDfa3_0(active0, 0x4000L, active1, 0L);

0428       case 102:

0429          return jjMoveStringLiteralDfa3_0(active0, 0x400000L, active1, 0L);

0430       case 105:

0431          return jjMoveStringLiteralDfa3_0(active0, 0x2828100000000000L, active1, 0L);

0432       case 108:

0433          return jjMoveStringLiteralDfa3_0(active0, 0x1000040008000000L, active1, 0L);

0434       case 110:

0435          return jjMoveStringLiteralDfa3_0(active0, 0x10008030300000L, active1, 0L);

0436       case 111:

0437          return jjMoveStringLiteralDfa3_0(active0, 0x1200040002000L, active1, 0L);

0438       case 112:

0439          return jjMoveStringLiteralDfa3_0(active0, 0x4000c00000000L, active1, 0L);

0440       case 114:

0441          if ((active0 & 0x80000000L) != 0L)

0442             return jjStartNfaWithStates_0(2, 31, 28);

0443          return jjMoveStringLiteralDfa3_0(active0, 0x40c0000000000000L, active1, 0L);

0444       case 115:

0445          return jjMoveStringLiteralDfa3_0(active0, 0x1002011000L, active1, 0L);

0446       case 116:

0447          if ((active0 & 0x2000000000L) != 0L)

0448          {

0449             jjmatchedKind = 37;

0450             jjmatchedPos = 2;

0451          }

0452          return jjMoveStringLiteralDfa3_0(active0, 0x814104028000L, active1, 0L);

0453       case 117:

0454          return jjMoveStringLiteralDfa3_0(active0, 0x200000001000000L, active1, 0L);

0455       case 119:

0456          if ((active0 & 0x20000000000L) != 0L)

0457             return jjStartNfaWithStates_0(2, 41, 28);

0458          break;

0459       case 121:

0460          if ((active0 & 0x400000000000000L) != 0L)

0461             return jjStartNfaWithStates_0(2, 58, 28);

0462          break;

0463       default :

0464          break;

0465    }

0466    return jjStartNfa_0(1, active0, active1);

0467 }

0468 private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)

0469 {

0470    if (((active0 &= old0) | (active1 &= old1)) == 0L)

0471       return jjStartNfa_0(1, old0, old1);

0472    try { curChar = input_stream.readChar(); }

0473    catch(java.io.IOException e) {

0474       jjStopStringLiteralDfa_0(2, active0, active1);

0475       return 3;

0476    }

0477    switch(curChar)

0478    {

0479       case 61:

0480          if ((active1 & 0x40000000000000L) != 0L)

0481             return jjStopAtPos(3, 118);

0482          break;

0483       case 97:

0484          return jjMoveStringLiteralDfa4_0(active0, 0x1000000070404000L, active1, 0L);

0485       case 98:

0486          return jjMoveStringLiteralDfa4_0(active0, 0x1000000L, active1, 0L);

0487       case 99:

0488          return jjMoveStringLiteralDfa4_0(active0, 0x10000000020000L, active1, 0L);

0489       case 100:

0490          if ((active0 & 0x800000000000000L) != 0L)

0491             return jjStartNfaWithStates_0(3, 59, 28);

0492          break;

0493       case 101:

0494          if ((active0 & 0x8000L) != 0L)

0495             return jjStartNfaWithStates_0(3, 15, 28);

0496          else if ((active0 & 0x10000L) != 0L)

0497             return jjStartNfaWithStates_0(3, 16, 28);

0498          else if ((active0 & 0x2000000L) != 0L)

0499             return jjStartNfaWithStates_0(3, 25, 28);

0500          else if ((active0 & 0x200000000000000L) != 0L)

0501             return jjStartNfaWithStates_0(3, 57, 28);

0502          return jjMoveStringLiteralDfa4_0(active0, 0x4004004000000L, active1, 0L);

0503       case 103:

0504          if ((active0 & 0x8000000000L) != 0L)

0505             return jjStartNfaWithStates_0(3, 39, 28);

0506          break;

0507       case 105:

0508          return jjMoveStringLiteralDfa4_0(active0, 0x4000010000000000L, active1, 0L);

0509       case 107:

0510          return jjMoveStringLiteralDfa4_0(active0, 0x80000000000L, active1, 0L);

0511       case 108:

0512          if ((active0 & 0x40000000000L) != 0L)

0513             return jjStartNfaWithStates_0(3, 42, 28);

0514          return jjMoveStringLiteralDfa4_0(active0, 0x2000400400002000L, active1, 0L);

0515       case 110:

0516          return jjMoveStringLiteralDfa4_0(active0, 0x100000000000000L, active1, 0L);

0517       case 111:

0518          if ((active0 & 0x100000000L) != 0L)

0519             return jjStartNfaWithStates_0(3, 32, 28);

0520          return jjMoveStringLiteralDfa4_0(active0, 0xc0000800000000L, active1, 0L);

0521       case 114:

0522          if ((active0 & 0x40000L) != 0L)

0523             return jjStartNfaWithStates_0(3, 18, 28);

0524          return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0L);

0525       case 115:

0526          if ((active0 & 0x20000000000000L) != 0L)

0527             return jjStartNfaWithStates_0(3, 53, 28);

0528          return jjMoveStringLiteralDfa4_0(active0, 0x8180000L, active1, 0L);

0529       case 116:

0530          return jjMoveStringLiteralDfa4_0(active0, 0xa201000201000L, active1, 0L);

0531       case 117:

0532          return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L, active1, 0L);

0533       case 118:

0534          return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L);

0535       default :

0536          break;

0537    }

0538    return jjStartNfa_0(2, active0, active1);

0539 }

0540 private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)

0541 {

0542    if (((active0 &= old0) | (active1 &= old1)) == 0L)

0543       return jjStartNfa_0(2, old0, old1);

0544    try { curChar = input_stream.readChar(); }

0545    catch(java.io.IOException e) {

0546       jjStopStringLiteralDfa_0(3, active0, 0L);

0547       return 4;

0548    }

0549    switch(curChar)

0550    {

0551       case 97:

0552          return jjMoveStringLiteralDfa5_0(active0, 0x181000000000L);

0553       case 99:

0554          return jjMoveStringLiteralDfa5_0(active0, 0x4008000000000000L);

0555       case 101:

0556          if ((active0 & 0x8000000L) != 0L)

0557             return jjStartNfaWithStates_0(4, 27, 28);

0558          else if ((active0 & 0x2000000000000000L) != 0L)

0559             return jjStartNfaWithStates_0(4, 61, 28);

0560          return jjMoveStringLiteralDfa5_0(active0, 0x200400002000L);

0561       case 104:

0562          if ((active0 & 0x20000L) != 0L)

0563             return jjStartNfaWithStates_0(4, 17, 28);

0564          return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L);

0565       case 105:

0566          return jjMoveStringLiteralDfa5_0(active0, 0x2400000200000L);

0567       case 107:

0568          if ((active0 & 0x4000L) != 0L)

0569             return jjStartNfaWithStates_0(4, 14, 28);

0570          break;

0571       case 108:

0572          if ((active0 & 0x10000000L) != 0L)

0573          {

0574             jjmatchedKind = 28;

0575             jjmatchedPos = 4;

0576          }

0577          return jjMoveStringLiteralDfa5_0(active0, 0x21000000L);

0578       case 110:

0579          return jjMoveStringLiteralDfa5_0(active0, 0x4000000L);

0580       case 114:

0581          if ((active0 & 0x4000000000000L) != 0L)

0582             return jjStartNfaWithStates_0(4, 50, 28);

0583          return jjMoveStringLiteralDfa5_0(active0, 0x804800001000L);

0584       case 115:

0585          if ((active0 & 0x80000L) != 0L)

0586             return jjStartNfaWithStates_0(4, 19, 28);

0587          return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L);

0588       case 116:

0589          if ((active0 & 0x100000L) != 0L)

0590             return jjStartNfaWithStates_0(4, 20, 28);

0591          else if ((active0 & 0x40000000L) != 0L)

0592             return jjStartNfaWithStates_0(4, 30, 28);

0593          else if ((active0 & 0x1000000000000L) != 0L)

0594             return jjStartNfaWithStates_0(4, 48, 28);

0595          return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000000L);

0596       case 117:

0597          return jjMoveStringLiteralDfa5_0(active0, 0x400000L);

0598       case 118:

0599          return jjMoveStringLiteralDfa5_0(active0, 0x10000000000L);

0600       case 119:

0601          if ((active0 & 0x40000000000000L) != 0L)

0602          {

0603             jjmatchedKind = 54;

0604             jjmatchedPos = 4;

0605          }

0606          return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L);

0607       default :

0608          break;

0609    }

0610    return jjStartNfa_0(3, active0, 0L);

0611 }

0612 private int jjMoveStringLiteralDfa5_0(long old0, long active0)

0613 {

0614    if (((active0 &= old0)) == 0L)

0615       return jjStartNfa_0(3, old0, 0L);

0616    try { curChar = input_stream.readChar(); }

0617    catch(java.io.IOException e) {

0618       jjStopStringLiteralDfa_0(4, active0, 0L);

0619       return 5;

0620    }

0621    switch(curChar)

0622    {

0623       case 97:

0624          return jjMoveStringLiteralDfa6_0(active0, 0x3000L);

0625       case 99:

0626          if ((active0 & 0x400000000000L) != 0L)

0627             return jjStartNfaWithStates_0(5, 46, 28);

0628          else if ((active0 & 0x2000000000000L) != 0L)

0629             return jjStartNfaWithStates_0(5, 49, 28);

0630          return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L);

0631       case 100:

0632          return jjMoveStringLiteralDfa6_0(active0, 0x4000000L);

0633       case 101:

0634          if ((active0 & 0x1000000L) != 0L)

0635             return jjStartNfaWithStates_0(5, 24, 28);

0636          else if ((active0 & 0x10000000000L) != 0L)

0637             return jjStartNfaWithStates_0(5, 40, 28);

0638          break;

0639       case 102:

0640          return jjMoveStringLiteralDfa6_0(active0, 0x4000000000L);

0641       case 103:

0642          return jjMoveStringLiteralDfa6_0(active0, 0x80000000000L);

0643       case 104:

0644          if ((active0 & 0x8000000000000L) != 0L)

0645             return jjStartNfaWithStates_0(5, 51, 28);

0646          break;

0647       case 105:

0648          return jjMoveStringLiteralDfa6_0(active0, 0x1100000000000000L);

0649       case 108:

0650          return jjMoveStringLiteralDfa6_0(active0, 0x20400000L);

0651       case 109:

0652          return jjMoveStringLiteralDfa6_0(active0, 0x400000000L);

0653       case 110:

0654          if ((active0 & 0x800000000000L) != 0L)

0655             return jjStartNfaWithStates_0(5, 47, 28);

0656          return jjMoveStringLiteralDfa6_0(active0, 0x1000200000L);

0657       case 114:

0658          return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L);

0659       case 115:

0660          if ((active0 & 0x80000000000000L) != 0L)

0661             return jjStartNfaWithStates_0(5, 55, 28);

0662          break;

0663       case 116:

0664          if ((active0 & 0x800000000L) != 0L)

0665             return jjStartNfaWithStates_0(5, 35, 28);

0666          return jjMoveStringLiteralDfa6_0(active0, 0x4000100000000000L);

0667       default :

0668          break;

0669    }

0670    return jjStartNfa_0(4, active0, 0L);

0671 }

0672 private int jjMoveStringLiteralDfa6_0(long old0, long active0)

0673 {

0674    if (((active0 &= old0)) == 0L)

0675       return jjStartNfa_0(4, old0, 0L);

0676    try { curChar = input_stream.readChar(); }

0677    catch(java.io.IOException e) {

0678       jjStopStringLiteralDfa_0(5, active0, 0L);

0679       return 6;

0680    }

0681    switch(curChar)

0682    {

0683       case 97:

0684          return jjMoveStringLiteralDfa7_0(active0, 0x4000000000L);

0685       case 99:

0686          return jjMoveStringLiteralDfa7_0(active0, 0x1000001000L);

0687       case 101:

0688          if ((active0 & 0x80000000000L) != 0L)

0689             return jjStartNfaWithStates_0(6, 43, 28);

0690          else if ((active0 & 0x100000000000L) != 0L)

0691             return jjStartNfaWithStates_0(6, 44, 28);

0692          return jjMoveStringLiteralDfa7_0(active0, 0x100000400000000L);

0693       case 102:

0694          return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000000L);

0695       case 108:

0696          return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000000L);

0697       case 110:

0698          if ((active0 & 0x2000L) != 0L)

0699             return jjStartNfaWithStates_0(6, 13, 28);

0700          break;

0701       case 111:

0702          return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L);

0703       case 115:

0704          if ((active0 & 0x4000000L) != 0L)

0705             return jjStartNfaWithStates_0(6, 26, 28);

0706          break;

0707       case 116:

0708          if ((active0 & 0x400000L) != 0L)

0709             return jjStartNfaWithStates_0(6, 22, 28);

0710          return jjMoveStringLiteralDfa7_0(active0, 0x200000000000L);

0711       case 117:

0712          return jjMoveStringLiteralDfa7_0(active0, 0x200000L);

0713       case 121:

0714          if ((active0 & 0x20000000L) != 0L)

0715             return jjStartNfaWithStates_0(6, 29, 28);

0716          break;

0717       default :

0718          break;

0719    }

0720    return jjStartNfa_0(5, active0, 0L);

0721 }

0722 private int jjMoveStringLiteralDfa7_0(long old0, long active0)

0723 {

0724    if (((active0 &= old0)) == 0L)

0725       return jjStartNfa_0(5, old0, 0L);

0726    try { curChar = input_stream.readChar(); }

0727    catch(java.io.IOException e) {

0728       jjStopStringLiteralDfa_0(6, active0, 0L);

0729       return 7;

0730    }

0731    switch(curChar)

0732    {

0733       case 99:

0734          return jjMoveStringLiteralDfa8_0(active0, 0x4000000000L);

0735       case 101:

0736          if ((active0 & 0x200000L) != 0L)

0737             return jjStartNfaWithStates_0(7, 21, 28);

0738          else if ((active0 & 0x1000000000000000L) != 0L)

0739             return jjStartNfaWithStates_0(7, 60, 28);

0740          return jjMoveStringLiteralDfa8_0(active0, 0x201000000000L);

0741       case 110:

0742          return jjMoveStringLiteralDfa8_0(active0, 0x110000400000000L);

0743       case 112:

0744          if ((active0 & 0x4000000000000000L) != 0L)

0745             return jjStartNfaWithStates_0(7, 62, 28);

0746          break;

0747       case 116:

0748          if ((active0 & 0x1000L) != 0L)

0749             return jjStartNfaWithStates_0(7, 12, 28);

0750          break;

0751       default :

0752          break;

0753    }

0754    return jjStartNfa_0(6, active0, 0L);

0755 }

0756 private int jjMoveStringLiteralDfa8_0(long old0, long active0)

0757 {

0758    if (((active0 &= old0)) == 0L)

0759       return jjStartNfa_0(6, old0, 0L);

0760    try { curChar = input_stream.readChar(); }

0761    catch(java.io.IOException e) {

0762       jjStopStringLiteralDfa_0(7, active0, 0L);

0763       return 8;

0764    }

0765    switch(curChar)

0766    {

0767       case 100:

0768          if ((active0 & 0x200000000000L) != 0L)

0769             return jjStartNfaWithStates_0(8, 45, 28);

0770          break;

0771       case 101:

0772          if ((active0 & 0x4000000000L) != 0L)

0773             return jjStartNfaWithStates_0(8, 38, 28);

0774          break;

0775       case 105:

0776          return jjMoveStringLiteralDfa9_0(active0, 0x10000000000000L);

0777       case 111:

0778          return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L);

0779       case 116:

0780          if ((active0 & 0x100000000000000L) != 0L)

0781             return jjStartNfaWithStates_0(8, 56, 28);

0782          return jjMoveStringLiteralDfa9_0(active0, 0x400000000L);

0783       default :

0784          break;

0785    }

0786    return jjStartNfa_0(7, active0, 0L);

0787 }

0788 private int jjMoveStringLiteralDfa9_0(long old0, long active0)

0789 {

0790    if (((active0 &= old0)) == 0L)

0791       return jjStartNfa_0(7, old0, 0L);

0792    try { curChar = input_stream.readChar(); }

0793    catch(java.io.IOException e) {

0794       jjStopStringLiteralDfa_0(8, active0, 0L);

0795       return 9;

0796    }

0797    switch(curChar)

0798    {

0799       case 102:

0800          if ((active0 & 0x1000000000L) != 0L)

0801             return jjStartNfaWithStates_0(9, 36, 28);

0802          break;

0803       case 115:

0804          if ((active0 & 0x400000000L) != 0L)

0805             return jjStartNfaWithStates_0(9, 34, 28);

0806          break;

0807       case 122:

0808          return jjMoveStringLiteralDfa10_0(active0, 0x10000000000000L);

0809       default :

0810          break;

0811    }

0812    return jjStartNfa_0(8, active0, 0L);

0813 }

0814 private int jjMoveStringLiteralDfa10_0(long old0, long active0)

0815 {

0816    if (((active0 &= old0)) == 0L)

0817       return jjStartNfa_0(8, old0, 0L);

0818    try { curChar = input_stream.readChar(); }

0819    catch(java.io.IOException e) {

0820       jjStopStringLiteralDfa_0(9, active0, 0L);

0821       return 10;

0822    }

0823    switch(curChar)

0824    {

0825       case 101:

0826          return jjMoveStringLiteralDfa11_0(active0, 0x10000000000000L);

0827       default :

0828          break;

0829    }

0830    return jjStartNfa_0(9, active0, 0L);

0831 }

0832 private int jjMoveStringLiteralDfa11_0(long old0, long active0)

0833 {

0834    if (((active0 &= old0)) == 0L)

0835       return jjStartNfa_0(9, old0, 0L);

0836    try { curChar = input_stream.readChar(); }

0837    catch(java.io.IOException e) {

0838       jjStopStringLiteralDfa_0(10, active0, 0L);

0839       return 11;

0840    }

0841    switch(curChar)

0842    {

0843       case 100:

0844          if ((active0 & 0x10000000000000L) != 0L)

0845             return jjStartNfaWithStates_0(11, 52, 28);

0846          break;

0847       default :

0848          break;

0849    }

0850    return jjStartNfa_0(10, active0, 0L);

0851 }

0852 private int jjStartNfaWithStates_0(int pos, int kind, int state)

0853 {

0854    jjmatchedKind = kind;

0855    jjmatchedPos = pos;

0856    try { curChar = input_stream.readChar(); }

0857    catch(java.io.IOException e) { return pos + 1; }

0858    return jjMoveNfa_0(state, pos + 1);

0859 }

0860 static final long[] jjbitVec0 = {

0861    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL

0862 };

0863 static final long[] jjbitVec2 = {

0864    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL

0865 };

0866 static final long[] jjbitVec3 = {

0867    0xfff0000000200002L, 0xffffffffffffdfffL, 0xfffff00f7fffffffL, 0x12000000007fffffL

0868 };

0869 static final long[] jjbitVec4 = {

0870    0x0L, 0x0L, 0x420043c00000000L, 0xff7fffffff7fffffL

0871 };

0872 static final long[] jjbitVec5 = {

0873    0xffffcffffffffL, 0xffffffffffff0000L, 0xf9ff3fffffffffffL, 0x401f00030003L

0874 };

0875 static final long[] jjbitVec6 = {

0876    0x0L, 0x400000000000000L, 0xfffffffbffffd740L, 0xffffffcff7fffL

0877 };

0878 static final long[] jjbitVec7 = {

0879    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff003L, 0x33fffffffff199fL

0880 };

0881 static final long[] jjbitVec8 = {

0882    0xfffe000000000000L, 0xfffffffe027fffffL, 0xffL, 0x707ffffff0000L

0883 };

0884 static final long[] jjbitVec9 = {

0885    0x7fffffe00000000L, 0xfffe0000000007ffL, 0xffffffffffffffffL, 0x1c000060002fffffL

0886 };

0887 static final long[] jjbitVec10 = {

0888    0x1ffffffd0000L, 0x0L, 0x3fffffffffL, 0x0L

0889 };

0890 static final long[] jjbitVec11 = {

0891    0x23ffffffffffffe0L, 0x3ff010000L, 0x3c5fdfffff99fe0L, 0xf0003b0000000L

0892 };

0893 static final long[] jjbitVec12 = {

0894    0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100010000L

0895 };

0896 static final long[] jjbitVec13 = {

0897    0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L

0898 };

0899 static final long[] jjbitVec14 = {

0900    0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L

0901 };

0902 static final long[] jjbitVec15 = {

0903    0x3fffdfffffddfe0L, 0x300000000L, 0x2ffbfffffc7fffe0L, 0x7fL

0904 };

0905 static final long[] jjbitVec16 = {

0906    0x800dfffffffffffeL, 0x7fL, 0x200decaefef02596L, 0x3000005fL

0907 };

0908 static final long[] jjbitVec17 = {

0909    0x1L, 0x7fffffffeffL, 0xf00L, 0x0L

0910 };

0911 static final long[] jjbitVec18 = {

0912    0x6fbffffffffL, 0x3f0000L, 0xffffffff00000000L, 0x7fffffffff003fL

0913 };

0914 static final long[] jjbitVec19 = {

0915    0xffffffffffffffffL, 0xffffffff83ffffffL, 0xffffff07ffffffffL, 0x3ffffffffffffffL

0916 };

0917 static final long[] jjbitVec20 = {

0918    0xffffffffffffff7fL, 0xffffffff3d7f3d7fL, 0x7f3d7fffffff3d7fL, 0xffff7fffff7f7f3dL

0919 };

0920 static final long[] jjbitVec21 = {

0921    0xffffffff7f3d7fffL, 0x7ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL

0922 };

0923 static final long[] jjbitVec22 = {

0924    0xffffffffffffffffL, 0x7f9fffffffffffL, 0xffffffff07fffffeL, 0x7ffffffffffL

0925 };

0926 static final long[] jjbitVec23 = {

0927    0x0L, 0x0L, 0xfffffffffffffL, 0x8000000L

0928 };

0929 static final long[] jjbitVec24 = {

0930    0xffffffff00000000L, 0xffffffffffffffL, 0x1ffffffffffL, 0x0L

0931 };

0932 static final long[] jjbitVec25 = {

0933    0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL

0934 };

0935 static final long[] jjbitVec26 = {

0936    0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL

0937 };

0938 static final long[] jjbitVec27 = {

0939    0x8000000000000000L, 0x8000000000000001L, 0xffff00000000L, 0x0L

0940 };

0941 static final long[] jjbitVec28 = {

0942    0x3fbbd503e2ffc84L, 0xffffffff00000000L, 0xfL, 0x0L

0943 };

0944 static final long[] jjbitVec29 = {

0945    0x73e03fe000000e0L, 0xfffffffffffffffeL, 0xfffffffe601fffffL, 0x7fffffffffffffffL

0946 };

0947 static final long[] jjbitVec30 = {

0948    0xfffe1fffffffffe0L, 0xffffffffffffffffL, 0xffffff00007fffL, 0x0L

0949 };

0950 static final long[] jjbitVec31 = {

0951    0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffffffL, 0x0L

0952 };

0953 static final long[] jjbitVec32 = {

0954    0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L

0955 };

0956 static final long[] jjbitVec33 = {

0957    0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL, 0x0L

0958 };

0959 static final long[] jjbitVec34 = {

0960    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L

0961 };

0962 static final long[] jjbitVec35 = {

0963    0x3fffffffffffL, 0x0L, 0x0L, 0x0L

0964 };

0965 static final long[] jjbitVec36 = {

0966    0x5f7ffdffa0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L

0967 };

0968 static final long[] jjbitVec37 = {

0969    0x3fffffffffffffffL, 0xffffffffffff0000L, 0xfffffffffffcffffL, 0xfff0000000000ffL

0970 };

0971 static final long[] jjbitVec38 = {

0972    0x18000000000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x1fffffffffffffffL

0973 };

0974 static final long[] jjbitVec39 = {

0975    0x87fffffe00000010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0x631cfcfcfcL

0976 };

0977 static final long[] jjbitVec40 = {

0978    0x0L, 0x0L, 0x420043cffffffffL, 0xff7fffffff7fffffL

0979 };

0980 static final long[] jjbitVec41 = {

0981    0xffffffffffffffffL, 0x400000700007fffL, 0xfffffffbffffd740L, 0xffffffcff7fffL

0982 };

0983 static final long[] jjbitVec42 = {

0984    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff07bL, 0x33fffffffff199fL

0985 };

0986 static final long[] jjbitVec43 = {

0987    0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe00ffL, 0x707ffffff0016L

0988 };

0989 static final long[] jjbitVec44 = {

0990    0x7fffffe00000000L, 0xffff03ff003fffffL, 0xffffffffffffffffL, 0x1fff3dff9fefffffL

0991 };

0992 static final long[] jjbitVec45 = {

0993    0xffff1fffffff8000L, 0x7ffL, 0x1ffffffffffffL, 0x0L

0994 };

0995 static final long[] jjbitVec46 = {

0996    0xf3ffffffffffffeeL, 0xffcfff1f3fffL, 0xd3c5fdfffff99feeL, 0xfffcfb080399fL

0997 };

0998 static final long[] jjbitVec47 = {

0999    0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100013bbfL

1000 };

1001 static final long[] jjbitVec48 = {

1002    0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L

1003 };

1004 static final long[] jjbitVec49 = {

1005    0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL

1006 };

1007 static final long[] jjbitVec50 = {

1008    0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x2ffbfffffc7fffecL, 0xc0000ff5f847fL

1009 };

1010 static final long[] jjbitVec51 = {

1011    0x87fffffffffffffeL, 0x3ff7fffL, 0x3bffecaefef02596L, 0x33ff3f5fL

1012 };

1013 static final long[] jjbitVec52 = {

1014    0xc2a003ff03000001L, 0xfffe07fffffffeffL, 0x1ffffffffeff0fdfL, 0x40L

1015 };

1016 static final long[] jjbitVec53 = {

1017    0x3c7f6fbffffffffL, 0x3ff03ffL, 0xffffffff00000000L, 0x7fffffffff003fL

1018 };

1019 static final long[] jjbitVec54 = {

1020    0xffffffff7f3d7fffL, 0x3fe0007ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL

1021 };

1022 static final long[] jjbitVec55 = {

1023    0x0L, 0x0L, 0xffffffffffffffffL, 0x3ff080fffffL

1024 };

1025 static final long[] jjbitVec56 = {

1026    0xffffffff03ff7800L, 0xffffffffffffffL, 0x3ffffffffffL, 0x0L

1027 };

1028 static final long[] jjbitVec57 = {

1029    0x80007c000000f000L, 0x8000fc0000000001L, 0xffff00000000L, 0x21fff0000L

1030 };

1031 static final long[] jjbitVec58 = {

1032    0x73efffe000000e0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x7fffffffffffffffL

1033 };

1034 static final long[] jjbitVec59 = {

1035    0x5f7ffdffe0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L

1036 };

1037 static final long[] jjbitVec60 = {

1038    0x18000f00000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x9fffffffffffffffL

1039 };

1040 static final long[] jjbitVec61 = {

1041    0x87fffffe03ff0010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0xe0000631cfcfcfcL

1042 };

1043 private int jjMoveNfa_0(int startState, int curPos)

1044 {

1045    int startsAt = 0;

1046    jjnewStateCnt = 68;

1047    int i = 1;

1048    jjstateSet[0] = startState;

1049    int kind = 0x7fffffff;

1050    for (;;)

1051    {

1052       if (++jjround == 0x7fffffff)

1053          ReInitRounds();

1054       if (curChar < 64)

1055       {

1056          long l = 1L << curChar;

1057          do

1058          {

1059             switch(jjstateSet[--i])

1060             {

1061                case 45:

1062                   if (curChar == 42)

1063                      jjstateSet[jjnewStateCnt++] = 50;

1064                   else if (curChar == 47)

1065                   {

1066                      if (kind > 6)

1067                         kind = 6;

1068                      jjCheckNAddStates(0, 2);

1069                   }

1070                   break;

1071                case 0:

1072                   if ((0x3ff000000000000L & l) != 0L)

1073                      jjCheckNAddStates(3, 9);

1074                   else if (curChar == 47)

1075                      jjAddStates(10, 11);

1076                   else if (curChar == 36)

1077                   {

1078                      if (kind > 72)

1079                         kind = 72;

1080                      jjCheckNAdd(28);

1081                   }

1082                   else if (curChar == 34)

1083                      jjCheckNAddStates(12, 14);

1084                   else if (curChar == 39)

1085                      jjAddStates(15, 16);

1086                   else if (curChar == 46)

1087                      jjCheckNAdd(4);

1088                   if ((0x3fe000000000000L & l) != 0L)

1089                   {

1090                      if (kind > 63)

1091                         kind = 63;

1092                      jjCheckNAddTwoStates(1, 2);

1093                   }

1094                   else if (curChar == 48)

1095                   {

1096                      if (kind > 63)

1097                         kind = 63;

1098                      jjCheckNAddStates(17, 21);

1099                   }

1100                   break;

1101                case 1:

1102                   if ((0x3ff000000000000L & l) == 0L)

1103                      break;

1104                   if (kind > 63)

1105                      kind = 63;

1106                   jjCheckNAddTwoStates(1, 2);

1107                   break;

1108                case 3:

1109                   if (curChar == 46)

1110                      jjCheckNAdd(4);

1111                   break;

1112                case 4:

1113                   if ((0x3ff000000000000L & l) == 0L)

1114                      break;

1115                   if (kind > 67)

1116                      kind = 67;

1117                   jjCheckNAddStates(22, 24);

1118                   break;

1119                case 6:

1120                   if ((0x280000000000L & l) != 0L)

1121                      jjCheckNAdd(7);

1122                   break;

1123                case 7:

1124                   if ((0x3ff000000000000L & l) == 0L)

1125                      break;

1126                   if (kind > 67)

1127                      kind = 67;

1128                   jjCheckNAddTwoStates(7, 8);

1129                   break;

1130                case 9:

1131                   if (curChar == 39)

1132                      jjAddStates(15, 16);

1133                   break;

1134                case 10:

1135                   if ((0xffffff7fffffdbffL & l) != 0L)

1136                      jjCheckNAdd(11);

1137                   break;

1138                case 11:

1139                   if (curChar == 39 && kind > 70)

1140                      kind = 70;

1141                   break;

1142                case 13:

1143                   if ((0x8400000000L & l) != 0L)

1144                      jjCheckNAdd(11);

1145                   break;

1146                case 14:

1147                   if ((0xff000000000000L & l) != 0L)

1148                      jjCheckNAddTwoStates(15, 11);

1149                   break;

1150                case 15:

1151                   if ((0xff000000000000L & l) != 0L)

1152                      jjCheckNAdd(11);

1153                   break;

1154                case 16:

1155                   if ((0xf000000000000L & l) != 0L)

1156                      jjstateSet[jjnewStateCnt++] = 17;

1157                   break;

1158                case 17:

1159                   if ((0xff000000000000L & l) != 0L)

1160                      jjCheckNAdd(15);

1161                   break;

1162                case 18:

1163                   if (curChar == 34)

1164                      jjCheckNAddStates(12, 14);

1165                   break;

1166                case 19:

1167                   if ((0xfffffffbffffdbffL & l) != 0L)

1168                      jjCheckNAddStates(12, 14);

1169                   break;

1170                case 21:

1171                   if ((0x8400000000L & l) != 0L)

1172                      jjCheckNAddStates(12, 14);

1173                   break;

1174                case 22:

1175                   if (curChar == 34 && kind > 71)

1176                      kind = 71;

1177                   break;

1178                case 23:

1179                   if ((0xff000000000000L & l) != 0L)

1180                      jjCheckNAddStates(25, 28);

1181                   break;

1182                case 24:

1183                   if ((0xff000000000000L & l) != 0L)

1184                      jjCheckNAddStates(12, 14);

1185                   break;

1186                case 25:

1187                   if ((0xf000000000000L & l) != 0L)

1188                      jjstateSet[jjnewStateCnt++] = 26;

1189                   break;

1190                case 26:

1191                   if ((0xff000000000000L & l) != 0L)

1192                      jjCheckNAdd(24);

1193                   break;

1194                case 27:

1195                   if (curChar != 36)

1196                      break;

1197                   if (kind > 72)

1198                      kind = 72;

1199                   jjCheckNAdd(28);

1200                   break;

1201                case 28:

1202                   if ((0x3ff00100fffc1ffL & l) == 0L)

1203                      break;

1204                   if (kind > 72)

1205                      kind = 72;

1206                   jjCheckNAdd(28);

1207                   break;

1208                case 29:

1209                   if ((0x3ff000000000000L & l) != 0L)

1210                      jjCheckNAddStates(3, 9);

1211                   break;

1212                case 30:

1213                   if ((0x3ff000000000000L & l) != 0L)

1214                      jjCheckNAddTwoStates(30, 31);

1215                   break;

1216                case 31:

1217                   if (curChar != 46)

1218                      break;

1219                   if (kind > 67)

1220                      kind = 67;

1221                   jjCheckNAddStates(29, 31);

1222                   break;

1223                case 32:

1224                   if ((0x3ff000000000000L & l) == 0L)

1225                      break;

1226                   if (kind > 67)

1227                      kind = 67;

1228                   jjCheckNAddStates(29, 31);

1229                   break;

1230                case 34:

1231                   if ((0x280000000000L & l) != 0L)

1232                      jjCheckNAdd(35);

1233                   break;

1234                case 35:

1235                   if ((0x3ff000000000000L & l) == 0L)

1236                      break;

1237                   if (kind > 67)

1238                      kind = 67;

1239                   jjCheckNAddTwoStates(35, 8);

1240                   break;

1241                case 36:

1242                   if ((0x3ff000000000000L & l) != 0L)

1243                      jjCheckNAddTwoStates(36, 37);

1244                   break;

1245                case 38:

1246                   if ((0x280000000000L & l) != 0L)

1247                      jjCheckNAdd(39);

1248                   break;

1249                case 39:

1250                   if ((0x3ff000000000000L & l) == 0L)

1251                      break;

1252                   if (kind > 67)

1253                      kind = 67;

1254                   jjCheckNAddTwoStates(39, 8);

1255                   break;

1256                case 40:

1257                   if ((0x3ff000000000000L & l) != 0L)

1258                      jjCheckNAddStates(32, 34);

1259                   break;

1260                case 42:

1261                   if ((0x280000000000L & l) != 0L)

1262                      jjCheckNAdd(43);

1263                   break;

1264                case 43:

1265                   if ((0x3ff000000000000L & l) != 0L)

1266                      jjCheckNAddTwoStates(43, 8);

1267                   break;

1268                case 44:

1269                   if (curChar == 47)

1270                      jjAddStates(10, 11);

1271                   break;

1272                case 46:

1273                   if ((0xffffffffffffdbffL & l) == 0L)

1274                      break;

1275                   if (kind > 6)

1276                      kind = 6;

1277                   jjCheckNAddStates(0, 2);

1278                   break;

1279                case 47:

1280                   if ((0x2400L & l) != 0L && kind > 6)

1281                      kind = 6;

1282                   break;

1283                case 48:

1284                   if (curChar == 10 && kind > 6)

1285                      kind = 6;

1286                   break;

1287                case 49:

1288                   if (curChar == 13)

1289                      jjstateSet[jjnewStateCnt++] = 48;

1290                   break;

1291                case 50:

1292                   if (curChar == 42)

1293                      jjstateSet[jjnewStateCnt++] = 51;

1294                   break;

1295                case 51:

1296                   if ((0xffff7fffffffffffL & l) != 0L && kind > 7)

1297                      kind = 7;

1298                   break;

1299                case 52:

1300                   if (curChar == 42)

1301                      jjstateSet[jjnewStateCnt++] = 50;

1302                   break;

1303                case 53:

1304                   if (curChar != 48)

1305                      break;

1306                   if (kind > 63)

1307                      kind = 63;

1308                   jjCheckNAddStates(17, 21);

1309                   break;

1310                case 55:

1311                   if ((0x3ff000000000000L & l) == 0L)

1312                      break;

1313                   if (kind > 63)

1314                      kind = 63;

1315                   jjCheckNAddTwoStates(55, 2);

1316                   break;

1317                case 56:

1318                   if ((0xff000000000000L & l) == 0L)

1319                      break;

1320                   if (kind > 63)

1321                      kind = 63;

1322                   jjCheckNAddTwoStates(56, 2);

1323                   break;

1324                case 58:

1325                   if ((0x3ff000000000000L & l) != 0L)

1326                      jjCheckNAddStates(35, 37);

1327                   break;

1328                case 59:

1329                   if (curChar == 46)

1330                      jjCheckNAdd(60);

1331                   break;

1332                case 61:

1333                   if ((0x280000000000L & l) != 0L)

1334                      jjCheckNAdd(62);

1335                   break;

1336                case 62:

1337                   if ((0x3ff000000000000L & l) == 0L)

1338                      break;

1339                   if (kind > 68)

1340                      kind = 68;

1341                   jjCheckNAddTwoStates(62, 63);

1342                   break;

1343                case 65:

1344                   if ((0x3ff000000000000L & l) != 0L)

1345                      jjAddStates(38, 39);

1346                   break;

1347                case 66:

1348                   if (curChar == 46)

1349                      jjCheckNAdd(67);

1350                   break;

1351                case 67:

1352                   if ((0x3ff000000000000L & l) != 0L)

1353                      jjCheckNAddTwoStates(67, 60);

1354                   break;

1355                default : break;

1356             }

1357          } while(i != startsAt);

1358       }

1359       else if (curChar < 128)

1360       {

1361          long l = 1L << (curChar & 077);

1362          do

1363          {

1364             switch(jjstateSet[--i])

1365             {

1366                case 0:

1367                   if ((0x7fffffe87fffffeL & l) == 0L)

1368                      break;

1369                   if (kind > 72)

1370                      kind = 72;

1371                   jjCheckNAdd(28);

1372                   break;

1373                case 2:

1374                   if ((0x100000001000L & l) != 0L && kind > 63)

1375                      kind = 63;

1376                   break;

1377                case 5:

1378                   if ((0x2000000020L & l) != 0L)

1379                      jjAddStates(40, 41);

1380                   break;

1381                case 8:

1382                   if ((0x5000000050L & l) != 0L && kind > 67)

1383                      kind = 67;

1384                   break;

1385                case 10:

1386                   if ((0xffffffffefffffffL & l) != 0L)

1387                      jjCheckNAdd(11);

1388                   break;

1389                case 12:

1390                   if (curChar == 92)

1391                      jjAddStates(42, 44);

1392                   break;

1393                case 13:

1394                   if ((0x14404410000000L & l) != 0L)

1395                      jjCheckNAdd(11);

1396                   break;

1397                case 19:

1398                   if ((0xffffffffefffffffL & l) != 0L)

1399                      jjCheckNAddStates(12, 14);

1400                   break;

1401                case 20:

1402                   if (curChar == 92)

1403                      jjAddStates(45, 47);

1404                   break;

1405                case 21:

1406                   if ((0x14404410000000L & l) != 0L)

1407                      jjCheckNAddStates(12, 14);

1408                   break;

1409                case 28:

1410                   if ((0x87fffffe87fffffeL & l) == 0L)

1411                      break;

1412                   if (kind > 72)

1413                      kind = 72;

1414                   jjCheckNAdd(28);

1415                   break;

1416                case 33:

1417                   if ((0x2000000020L & l) != 0L)

1418                      jjAddStates(48, 49);

1419                   break;

1420                case 37:

1421                   if ((0x2000000020L & l) != 0L)

1422                      jjAddStates(50, 51);

1423                   break;

1424                case 41:

1425                   if ((0x2000000020L & l) != 0L)

1426                      jjAddStates(52, 53);

1427                   break;

1428                case 46:

1429                   if (kind > 6)

1430                      kind = 6;

1431                   jjAddStates(0, 2);

1432                   break;

1433                case 51:

1434                   if (kind > 7)

1435                      kind = 7;

1436                   break;

1437                case 54:

1438                   if ((0x100000001000000L & l) != 0L)

1439                      jjCheckNAdd(55);

1440                   break;

1441                case 55:

1442                   if ((0x7e0000007eL & l) == 0L)

1443                      break;

1444                   if (kind > 63)

1445                      kind = 63;

1446                   jjCheckNAddTwoStates(55, 2);

1447                   break;

1448                case 57:

1449                   if ((0x100000001000000L & l) != 0L)

1450                      jjCheckNAdd(58);

1451                   break;

1452                case 58:

1453                   if ((0x7e0000007eL & l) != 0L)

1454                      jjCheckNAddStates(35, 37);

1455                   break;

1456                case 60:

1457                   if ((0x1000000010000L & l) != 0L)

1458                      jjAddStates(54, 55);

1459                   break;

1460                case 63:

1461                   if ((0x5000000050L & l) != 0L && kind > 68)

1462                      kind = 68;

1463                   break;

1464                case 64:

1465                   if ((0x100000001000000L & l) != 0L)

1466                      jjCheckNAddTwoStates(65, 66);

1467                   break;

1468                case 65:

1469                   if ((0x7e0000007eL & l) != 0L)

1470                      jjCheckNAddTwoStates(65, 66);

1471                   break;

1472                case 67:

1473                   if ((0x7e0000007eL & l) != 0L)

1474                      jjCheckNAddTwoStates(67, 60);

1475                   break;

1476                default : break;

1477             }

1478          } while(i != startsAt);

1479       }

1480       else

1481       {

1482          int hiByte = (int)(curChar >> 8);

1483          int i1 = hiByte >> 6;

1484          long l1 = 1L << (hiByte & 077);

1485          int i2 = (curChar & 0xff) >> 6;

1486          long l2 = 1L << (curChar & 077);

1487          do

1488          {

1489             switch(jjstateSet[--i])

1490             {

1491                case 0:

1492                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))

1493                      break;

1494                   if (kind > 72)

1495                      kind = 72;

1496                   jjCheckNAdd(28);

1497                   break;

1498                case 10:

1499                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))

1500                      jjstateSet[jjnewStateCnt++] = 11;

1501                   break;

1502                case 19:

1503                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))

1504                      jjAddStates(12, 14);

1505                   break;

1506                case 28:

1507                   if (!jjCanMove_2(hiByte, i1, i2, l1, l2))

1508                      break;

1509                   if (kind > 72)

1510                      kind = 72;

1511                   jjCheckNAdd(28);

1512                   break;

1513                case 46:

1514                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))

1515                      break;

1516                   if (kind > 6)

1517                      kind = 6;

1518                   jjAddStates(0, 2);

1519                   break;

1520                case 51:

1521                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7)

1522                      kind = 7;

1523                   break;

1524                default : break;

1525             }

1526          } while(i != startsAt);

1527       }

1528       if (kind != 0x7fffffff)

1529       {

1530          jjmatchedKind = kind;

1531          jjmatchedPos = curPos;

1532          kind = 0x7fffffff;

1533       }

1534       ++curPos;

1535       if ((i = jjnewStateCnt) == (startsAt = 68 - (jjnewStateCnt = startsAt)))

1536          return curPos;

1537       try { curChar = input_stream.readChar(); }

1538       catch(java.io.IOException e) { return curPos; }

1539    }

1540 }

1541 private int jjMoveStringLiteralDfa0_2()

1542 {

1543    switch(curChar)

1544    {

1545       case 42:

1546          return jjMoveStringLiteralDfa1_2(0x400L);

1547       default :

1548          return 1;

1549    }

1550 }

1551 private int jjMoveStringLiteralDfa1_2(long active0)

1552 {

1553    try { curChar = input_stream.readChar(); }

1554    catch(java.io.IOException e) {

1555       return 1;

1556    }

1557    switch(curChar)

1558    {

1559       case 47:

1560          if ((active0 & 0x400L) != 0L)

1561             return jjStopAtPos(1, 10);

1562          break;

1563       default :

1564          return 2;

1565    }

1566    return 2;

1567 }

1568 private int jjMoveStringLiteralDfa0_1()

1569 {

1570    switch(curChar)

1571    {

1572       case 42:

1573          return jjMoveStringLiteralDfa1_1(0x200L);

1574       default :

1575          return 1;

1576    }

1577 }

1578 private int jjMoveStringLiteralDfa1_1(long active0)

1579 {

1580    try { curChar = input_stream.readChar(); }

1581    catch(java.io.IOException e) {

1582       return 1;

1583    }

1584    switch(curChar)

1585    {

1586       case 47:

1587          if ((active0 & 0x200L) != 0L)

1588             return jjStopAtPos(1, 9);

1589          break;

1590       default :

1591          return 2;

1592    }

1593    return 2;

1594 }

1595 static final int[] jjnextStates = {

1596    46, 47, 49, 30, 31, 36, 37, 40, 41, 8, 45, 52, 19, 20, 22, 10, 

1597    12, 54, 56, 2, 57, 64, 4, 5, 8, 19, 20, 24, 22, 32, 33, 8, 

1598    40, 41, 8, 58, 59, 60, 65, 66, 6, 7, 13, 14, 16, 21, 23, 25, 

1599    34, 35, 38, 39, 42, 43, 61, 62, 

1600 };

1601 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)

1602 {

1603    switch(hiByte)

1604    {

1605       case 0:

1606          return ((jjbitVec2[i2] & l2) != 0L);

1607       default :

1608          if ((jjbitVec0[i1] & l1) != 0L)

1609             return true;

1610          return false;

1611    }

1612 }

1613 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)

1614 {

1615    switch(hiByte)

1616    {

1617       case 0:

1618          return ((jjbitVec4[i2] & l2) != 0L);

1619       case 2:

1620          return ((jjbitVec5[i2] & l2) != 0L);

1621       case 3:

1622          return ((jjbitVec6[i2] & l2) != 0L);

1623       case 4:

1624          return ((jjbitVec7[i2] & l2) != 0L);

1625       case 5:

1626          return ((jjbitVec8[i2] & l2) != 0L);

1627       case 6:

1628          return ((jjbitVec9[i2] & l2) != 0L);

1629       case 7:

1630          return ((jjbitVec10[i2] & l2) != 0L);

1631       case 9:

1632          return ((jjbitVec11[i2] & l2) != 0L);

1633       case 10:

1634          return ((jjbitVec12[i2] & l2) != 0L);

1635       case 11:

1636          return ((jjbitVec13[i2] & l2) != 0L);

1637       case 12:

1638          return ((jjbitVec14[i2] & l2) != 0L);

1639       case 13:

1640          return ((jjbitVec15[i2] & l2) != 0L);

1641       case 14:

1642          return ((jjbitVec16[i2] & l2) != 0L);

1643       case 15:

1644          return ((jjbitVec17[i2] & l2) != 0L);

1645       case 16:

1646          return ((jjbitVec18[i2] & l2) != 0L);

1647       case 17:

1648          return ((jjbitVec19[i2] & l2) != 0L);

1649       case 18:

1650          return ((jjbitVec20[i2] & l2) != 0L);

1651       case 19:

1652          return ((jjbitVec21[i2] & l2) != 0L);

1653       case 20:

1654          return ((jjbitVec0[i2] & l2) != 0L);

1655       case 22:

1656          return ((jjbitVec22[i2] & l2) != 0L);

1657       case 23:

1658          return ((jjbitVec23[i2] & l2) != 0L);

1659       case 24:

1660          return ((jjbitVec24[i2] & l2) != 0L);

1661       case 30:

1662          return ((jjbitVec25[i2] & l2) != 0L);

1663       case 31:

1664          return ((jjbitVec26[i2] & l2) != 0L);

1665       case 32:

1666          return ((jjbitVec27[i2] & l2) != 0L);

1667       case 33:

1668          return ((jjbitVec28[i2] & l2) != 0L);

1669       case 48:

1670          return ((jjbitVec29[i2] & l2) != 0L);

1671       case 49:

1672          return ((jjbitVec30[i2] & l2) != 0L);

1673       case 77:

1674          return ((jjbitVec31[i2] & l2) != 0L);

1675       case 159:

1676          return ((jjbitVec32[i2] & l2) != 0L);

1677       case 164:

1678          return ((jjbitVec33[i2] & l2) != 0L);

1679       case 215:

1680          return ((jjbitVec34[i2] & l2) != 0L);

1681       case 250:

1682          return ((jjbitVec35[i2] & l2) != 0L);

1683       case 251:

1684          return ((jjbitVec36[i2] & l2) != 0L);

1685       case 253:

1686          return ((jjbitVec37[i2] & l2) != 0L);

1687       case 254:

1688          return ((jjbitVec38[i2] & l2) != 0L);

1689       case 255:

1690          return ((jjbitVec39[i2] & l2) != 0L);

1691       default :

1692          if ((jjbitVec3[i1] & l1) != 0L)

1693             return true;

1694          return false;

1695    }

1696 }

1697 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)

1698 {

1699    switch(hiByte)

1700    {

1701       case 0:

1702          return ((jjbitVec40[i2] & l2) != 0L);

1703       case 2:

1704          return ((jjbitVec5[i2] & l2) != 0L);

1705       case 3:

1706          return ((jjbitVec41[i2] & l2) != 0L);

1707       case 4:

1708          return ((jjbitVec42[i2] & l2) != 0L);

1709       case 5:

1710          return ((jjbitVec43[i2] & l2) != 0L);

1711       case 6:

1712          return ((jjbitVec44[i2] & l2) != 0L);

1713       case 7:

1714          return ((jjbitVec45[i2] & l2) != 0L);

1715       case 9:

1716          return ((jjbitVec46[i2] & l2) != 0L);

1717       case 10:

1718          return ((jjbitVec47[i2] & l2) != 0L);

1719       case 11:

1720          return ((jjbitVec48[i2] & l2) != 0L);

1721       case 12:

1722          return ((jjbitVec49[i2] & l2) != 0L);

1723       case 13:

1724          return ((jjbitVec50[i2] & l2) != 0L);

1725       case 14:

1726          return ((jjbitVec51[i2] & l2) != 0L);

1727       case 15:

1728          return ((jjbitVec52[i2] & l2) != 0L);

1729       case 16:

1730          return ((jjbitVec53[i2] & l2) != 0L);

1731       case 17:

1732          return ((jjbitVec19[i2] & l2) != 0L);

1733       case 18:

1734          return ((jjbitVec20[i2] & l2) != 0L);

1735       case 19:

1736          return ((jjbitVec54[i2] & l2) != 0L);

1737       case 20:

1738          return ((jjbitVec0[i2] & l2) != 0L);

1739       case 22:

1740          return ((jjbitVec22[i2] & l2) != 0L);

1741       case 23:

1742          return ((jjbitVec55[i2] & l2) != 0L);

1743       case 24:

1744          return ((jjbitVec56[i2] & l2) != 0L);

1745       case 30:

1746          return ((jjbitVec25[i2] & l2) != 0L);

1747       case 31:

1748          return ((jjbitVec26[i2] & l2) != 0L);

1749       case 32:

1750          return ((jjbitVec57[i2] & l2) != 0L);

1751       case 33:

1752          return ((jjbitVec28[i2] & l2) != 0L);

1753       case 48:

1754          return ((jjbitVec58[i2] & l2) != 0L);

1755       case 49:

1756          return ((jjbitVec30[i2] & l2) != 0L);

1757       case 77:

1758          return ((jjbitVec31[i2] & l2) != 0L);

1759       case 159:

1760          return ((jjbitVec32[i2] & l2) != 0L);

1761       case 164:

1762          return ((jjbitVec33[i2] & l2) != 0L);

1763       case 215:

1764          return ((jjbitVec34[i2] & l2) != 0L);

1765       case 250:

1766          return ((jjbitVec35[i2] & l2) != 0L);

1767       case 251:

1768          return ((jjbitVec59[i2] & l2) != 0L);

1769       case 253:

1770          return ((jjbitVec37[i2] & l2) != 0L);

1771       case 254:

1772          return ((jjbitVec60[i2] & l2) != 0L);

1773       case 255:

1774          return ((jjbitVec61[i2] & l2) != 0L);

1775       default :

1776          if ((jjbitVec3[i1] & l1) != 0L)

1777             return true;

1778          return false;

1779    }

1780 }

1781 

1782 /** Token literal values. */

1783 public static final String[] jjstrLiteralImages = {

1784 "", null, null, null, null, null, null, null, null, null, null, null, 

1785 "\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153", "\142\171\164\145", 

1786 "\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163", 

1787 "\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", 

1788 "\144\157", "\144\157\165\142\154\145", "\145\154\163\145", 

1789 "\145\170\164\145\156\144\163", "\146\141\154\163\145", "\146\151\156\141\154", 

1790 "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146", 

1791 "\151\155\160\154\145\155\145\156\164\163", "\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", 

1792 "\151\156\164", "\151\156\164\145\162\146\141\143\145", "\154\157\156\147", 

1793 "\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145", 

1794 "\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", 

1795 "\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\165\160\145\162", 

1796 "\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163", 

1797 "\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\141\156\163\151\145\156\164", 

1798 "\164\162\165\145", "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145", 

1799 "\167\150\151\154\145", "\163\164\162\151\143\164\146\160", null, null, null, null, null, null, null, 

1800 null, null, null, null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", 

1801 "\54", "\56", "\100", "\75", "\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75", 

1802 "\76\75", "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", 

1803 "\57", "\46", "\174", "\136", "\45", "\74\74", "\53\75", "\55\75", "\52\75", 

1804 "\57\75", "\46\75", "\174\75", "\136\75", "\45\75", "\74\74\75", "\76\76\75", 

1805 "\76\76\76\75", "\56\56\56", "\76\76\76", "\76\76", "\76", "\32", "\176\133\135", };

1806 

1807 /** Lexer state names. */

1808 public static final String[] lexStateNames = {

1809    "DEFAULT",

1810    "IN_FORMAL_COMMENT",

1811    "IN_MULTI_LINE_COMMENT",

1812 };

1813 

1814 /** Lex State array. */

1815 public static final int[] jjnewLexState = {

1816    -1, -1, -1, -1, -1, -1, -1, 1, 2, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 

1817    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 

1818    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 

1819    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 

1820    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 

1821 };

1822 static final long[] jjtoToken = {

1823    0xfffffffffffff001L, 0x1ffffffffffff9d8L, 

1824 };

1825 static final long[] jjtoSkip = {

1826    0x67eL, 0x0L, 

1827 };

1828 static final long[] jjtoSpecial = {

1829    0x67eL, 0x0L, 

1830 };

1831 static final long[] jjtoMore = {

1832    0x980L, 0x0L, 

1833 };

1834 protected CharStream input_stream;

1835 private final int[] jjrounds = new int[68];

1836 private final int[] jjstateSet = new int[136];

1837 private final StringBuilder jjimage = new StringBuilder();

1838 private StringBuilder image = jjimage;

1839 private int jjimageLen;

1840 private int lengthOfMatch;

1841 protected char curChar;

1842 /** Constructor. */

1843 public JavaParserTokenManager(CharStream stream){

1844    input_stream = stream;

1845 }

1846 

1847 /** Constructor. */

1848 public JavaParserTokenManager(CharStream stream, int lexState){

1849    this(stream);

1850    SwitchTo(lexState);

1851 }

1852 

1853 /** Reinitialise parser. */

1854 public void ReInit(CharStream stream)

1855 {

1856    jjmatchedPos = jjnewStateCnt = 0;

1857    curLexState = defaultLexState;

1858    input_stream = stream;

1859    ReInitRounds();

1860 }

1861 private void ReInitRounds()

1862 {

1863    int i;

1864    jjround = 0x80000001;

1865    for (i = 68; i-- > 0;)

1866       jjrounds[i] = 0x80000000;

1867 }

1868 

1869 /** Reinitialise parser. */

1870 public void ReInit(CharStream stream, int lexState)

1871 {

1872    ReInit(stream);

1873    SwitchTo(lexState);

1874 }

1875 

1876 /** Switch to specified lex state. */

1877 public void SwitchTo(int lexState)

1878 {

1879    if (lexState >= 3 || lexState < 0)

1880       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);

1881    else

1882       curLexState = lexState;

1883 }

1884 

1885 protected Token jjFillToken()

1886 {

1887    final Token t;

1888    final String curTokenImage;

1889    final int beginLine;

1890    final int endLine;

1891    final int beginColumn;

1892    final int endColumn;

1893    String im = jjstrLiteralImages[jjmatchedKind];

1894    curTokenImage = (im == null) ? input_stream.GetImage() : im;

1895    beginLine = input_stream.getBeginLine();

1896    beginColumn = input_stream.getBeginColumn();

1897    endLine = input_stream.getEndLine();

1898    endColumn = input_stream.getEndColumn();

1899    t = Token.newToken(jjmatchedKind, curTokenImage);

1900 

1901    t.beginLine = beginLine;

1902    t.endLine = endLine;

1903    t.beginColumn = beginColumn;

1904    t.endColumn = endColumn;

1905 

1906    return t;

1907 }

1908 

1909 int curLexState = 0;

1910 int defaultLexState = 0;

1911 int jjnewStateCnt;

1912 int jjround;

1913 int jjmatchedPos;

1914 int jjmatchedKind;

1915 

1916 /** Get the next Token. */

1917 public Token getNextToken() 

1918 {

1919   Token specialToken = null;

1920   Token matchedToken;

1921   int curPos = 0;

1922 

1923   EOFLoop :

1924   for (;;)

1925   {

1926    try

1927    {

1928       curChar = input_stream.BeginToken();

1929    }

1930    catch(java.io.IOException e)

1931    {

1932       jjmatchedKind = 0;

1933       matchedToken = jjFillToken();

1934       matchedToken.specialToken = specialToken;

1935       return matchedToken;

1936    }

1937    image = jjimage;

1938    image.setLength(0);

1939    jjimageLen = 0;

1940 

1941    for (;;)

1942    {

1943      switch(curLexState)

1944      {

1945        case 0:

1946          jjmatchedKind = 0x7fffffff;

1947          jjmatchedPos = 0;

1948          curPos = jjMoveStringLiteralDfa0_0();

1949          break;

1950        case 1:

1951          jjmatchedKind = 0x7fffffff;

1952          jjmatchedPos = 0;

1953          curPos = jjMoveStringLiteralDfa0_1();

1954          if (jjmatchedPos == 0 && jjmatchedKind > 11)

1955          {

1956             jjmatchedKind = 11;

1957          }

1958          break;

1959        case 2:

1960          jjmatchedKind = 0x7fffffff;

1961          jjmatchedPos = 0;

1962          curPos = jjMoveStringLiteralDfa0_2();

1963          if (jjmatchedPos == 0 && jjmatchedKind > 11)

1964          {

1965             jjmatchedKind = 11;

1966          }

1967          break;

1968      }

1969      if (jjmatchedKind != 0x7fffffff)

1970      {

1971         if (jjmatchedPos + 1 < curPos)

1972            input_stream.backup(curPos - jjmatchedPos - 1);

1973         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)

1974         {

1975            matchedToken = jjFillToken();

1976            matchedToken.specialToken = specialToken;

1977            TokenLexicalActions(matchedToken);

1978        if (jjnewLexState[jjmatchedKind] != -1)

1979          curLexState = jjnewLexState[jjmatchedKind];

1980            return matchedToken;

1981         }

1982         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)

1983         {

1984            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)

1985            {

1986               matchedToken = jjFillToken();

1987               if (specialToken == null)

1988                  specialToken = matchedToken;

1989               else

1990               {

1991                  matchedToken.specialToken = specialToken;

1992                  specialToken = (specialToken.next = matchedToken);

1993               }

1994               SkipLexicalActions(matchedToken);

1995            }

1996            else

1997               SkipLexicalActions(null);

1998          if (jjnewLexState[jjmatchedKind] != -1)

1999            curLexState = jjnewLexState[jjmatchedKind];

2000            continue EOFLoop;

2001         }

2002         MoreLexicalActions();

2003       if (jjnewLexState[jjmatchedKind] != -1)

2004         curLexState = jjnewLexState[jjmatchedKind];

2005         curPos = 0;

2006         jjmatchedKind = 0x7fffffff;

2007         try {

2008            curChar = input_stream.readChar();

2009            continue;

2010         }

2011         catch (java.io.IOException e1) { }

2012      }

2013      int error_line = input_stream.getEndLine();

2014      int error_column = input_stream.getEndColumn();

2015      String error_after = null;

2016      boolean EOFSeen = false;

2017      try { input_stream.readChar(); input_stream.backup(1); }

2018      catch (java.io.IOException e1) {

2019         EOFSeen = true;

2020         error_after = curPos <= 1 ? "" : input_stream.GetImage();

2021         if (curChar == '\n' || curChar == '\r') {

2022            error_line++;

2023            error_column = 0;

2024         }

2025         else

2026            error_column++;

2027      }

2028      if (!EOFSeen) {

2029         input_stream.backup(1);

2030         error_after = curPos <= 1 ? "" : input_stream.GetImage();

2031      }

2032      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);

2033    }

2034   }

2035 }

2036 

2037 void SkipLexicalActions(Token matchedToken)

2038 {

2039    switch(jjmatchedKind)

2040    {

2041       case 6 :

2042          image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));

2043         int startOfNOPMD = matchedToken.image.indexOf(suppressMarker);

2044         if (startOfNOPMD != -1) {

2045             suppressMap.put(matchedToken.beginLine, matchedToken.image.substring(startOfNOPMD + suppressMarker.length()));

2046         }

2047         comments.add(new SingleLineComment(matchedToken));

2048          break;

2049       case 9 :

2050          image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));

2051                             comments.add(new FormalComment(matchedToken));

2052          break;

2053       case 10 :

2054          image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));

2055                                 comments.add(new MultiLineComment(matchedToken));

2056          break;

2057       default :

2058          break;

2059    }

2060 }

2061 void MoreLexicalActions()

2062 {

2063    jjimageLen += (lengthOfMatch = jjmatchedPos + 1);

2064    switch(jjmatchedKind)

2065    {

2066       case 7 :

2067          image.append(input_stream.GetSuffix(jjimageLen));

2068          jjimageLen = 0;

2069                    input_stream.backup(1);

2070          break;

2071       default :

2072          break;

2073    }

2074 }

2075 void TokenLexicalActions(Token matchedToken)

2076 {

2077    switch(jjmatchedKind)

2078    {

2079       case 120 :

2080         image.append(jjstrLiteralImages[120]);

2081         lengthOfMatch = jjstrLiteralImages[120].length();

2082      matchedToken.kind = GT;

2083      ((Token.GTToken)matchedToken).realKind = RUNSIGNEDSHIFT;

2084      input_stream.backup(2);

2085      matchedToken.image = ">";

2086          break;

2087       case 121 :

2088         image.append(jjstrLiteralImages[121]);

2089         lengthOfMatch = jjstrLiteralImages[121].length();

2090      matchedToken.kind = GT;

2091      ((Token.GTToken)matchedToken).realKind = RSIGNEDSHIFT;

2092      input_stream.backup(1);

2093      matchedToken.image = ">";

2094          break;

2095       default :

2096          break;

2097    }

2098 }

2099 private void jjCheckNAdd(int state)

2100 {

2101    if (jjrounds[state] != jjround)

2102    {

2103       jjstateSet[jjnewStateCnt++] = state;

2104       jjrounds[state] = jjround;

2105    }

2106 }

2107 private void jjAddStates(int start, int end)

2108 {

2109    do {

2110       jjstateSet[jjnewStateCnt++] = jjnextStates[start];

2111    } while (start++ != end);

2112 }

2113 private void jjCheckNAddTwoStates(int state1, int state2)

2114 {

2115    jjCheckNAdd(state1);

2116    jjCheckNAdd(state2);

2117 }

2118 

2119 private void jjCheckNAddStates(int start, int end)

2120 {

2121    do {

2122       jjCheckNAdd(jjnextStates[start]);

2123    } while (start++ != end);

2124 }

2125 

2126 }