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