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