Coverage Report - org.apache.commons.configuration.plist.PropertyListParserTokenManager
 
Classes in this File Line Coverage Branch Coverage Complexity
PropertyListParserTokenManager
62%
257/410
48%
147/301
9,846
 
 1  
 /* Generated By:JavaCC: Do not edit this line. PropertyListParserTokenManager.java */
 2  
 package org.apache.commons.configuration.plist;
 3  
 import java.util.Date;
 4  
 import java.util.List;
 5  
 import java.util.ArrayList;
 6  
 import org.apache.commons.configuration.HierarchicalConfiguration;
 7  
 import org.apache.commons.configuration.HierarchicalConfiguration.Node;
 8  
 import org.apache.commons.codec.binary.Hex;
 9  
 
 10  
 /** Token Manager. */
 11  
 public class PropertyListParserTokenManager implements PropertyListParserConstants
 12  
 {
 13  
 
 14  
   /** Debug output. */
 15  32
   public  java.io.PrintStream debugStream = System.out;
 16  
   /** Set debug output. */
 17  0
   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
 18  
 private final int jjStopStringLiteralDfa_0(int pos, long active0)
 19  
 {
 20  52
    switch (pos)
 21  
    {
 22  
       case 0:
 23  52
          if ((active0 & 0x20000120L) != 0L)
 24  
          {
 25  0
             jjmatchedKind = 27;
 26  0
             return 8;
 27  
          }
 28  52
          if ((active0 & 0x80000L) != 0L)
 29  0
             return 8;
 30  52
          if ((active0 & 0x200000L) != 0L)
 31  0
             return 14;
 32  52
          if ((active0 & 0x140000L) != 0L)
 33  52
             return 6;
 34  0
          return -1;
 35  
       case 1:
 36  0
          if ((active0 & 0x100000L) != 0L)
 37  
          {
 38  0
             jjmatchedKind = 27;
 39  0
             jjmatchedPos = 1;
 40  0
             return 3;
 41  
          }
 42  0
          if ((active0 & 0x120L) != 0L)
 43  0
             return 8;
 44  0
          return -1;
 45  
       default :
 46  0
          return -1;
 47  
    }
 48  
 }
 49  
 private final int jjStartNfa_0(int pos, long active0)
 50  
 {
 51  52
    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
 52  
 }
 53  
 private int jjStopAtPos(int pos, int kind)
 54  
 {
 55  1762
    jjmatchedKind = kind;
 56  1762
    jjmatchedPos = pos;
 57  1762
    return pos + 1;
 58  
 }
 59  
 private int jjMoveStringLiteralDfa0_0()
 60  
 {
 61  2789
    switch(curChar)
 62  
    {
 63  
       case 34:
 64  211
          return jjStartNfaWithStates_0(0, 21, 14);
 65  
       case 40:
 66  150
          return jjStopAtPos(0, 11);
 67  
       case 41:
 68  150
          return jjStopAtPos(0, 12);
 69  
       case 44:
 70  150
          return jjStopAtPos(0, 13);
 71  
       case 47:
 72  46
          return jjMoveStringLiteralDfa1_0(0x120L);
 73  
       case 59:
 74  358
          return jjStopAtPos(0, 16);
 75  
       case 60:
 76  77
          jjmatchedKind = 18;
 77  77
          return jjMoveStringLiteralDfa1_0(0x100000L);
 78  
       case 61:
 79  527
          return jjStopAtPos(0, 17);
 80  
       case 62:
 81  0
          return jjStartNfaWithStates_0(0, 19, 8);
 82  
       case 92:
 83  0
          return jjMoveStringLiteralDfa1_0(0x20000000L);
 84  
       case 123:
 85  202
          return jjStopAtPos(0, 14);
 86  
       case 125:
 87  202
          return jjStopAtPos(0, 15);
 88  
       default :
 89  716
          return jjMoveNfa_0(0, 0);
 90  
    }
 91  
 }
 92  
 private int jjMoveStringLiteralDfa1_0(long active0)
 93  
 {
 94  123
    try { curChar = input_stream.readChar(); }
 95  0
    catch(java.io.IOException e) {
 96  0
       jjStopStringLiteralDfa_0(0, active0);
 97  0
       return 1;
 98  123
    }
 99  123
    switch(curChar)
 100  
    {
 101  
       case 34:
 102  0
          if ((active0 & 0x20000000L) != 0L)
 103  0
             return jjStopAtPos(1, 29);
 104  
          break;
 105  
       case 42:
 106  48
          if ((active0 & 0x20L) != 0L)
 107  23
             return jjStartNfaWithStates_0(1, 5, 8);
 108  25
          return jjMoveStringLiteralDfa2_0(active0, 0x100000L);
 109  
       case 47:
 110  23
          if ((active0 & 0x100L) != 0L)
 111  23
             return jjStartNfaWithStates_0(1, 8, 8);
 112  
          break;
 113  
       default :
 114  
          break;
 115  
    }
 116  52
    return jjStartNfa_0(0, active0);
 117  
 }
 118  
 private int jjMoveStringLiteralDfa2_0(long old0, long active0)
 119  
 {
 120  25
    if (((active0 &= old0)) == 0L)
 121  0
       return jjStartNfa_0(0, old0);
 122  25
    try { curChar = input_stream.readChar(); }
 123  0
    catch(java.io.IOException e) {
 124  0
       jjStopStringLiteralDfa_0(1, active0);
 125  0
       return 2;
 126  25
    }
 127  25
    switch(curChar)
 128  
    {
 129  
       case 68:
 130  25
          if ((active0 & 0x100000L) != 0L)
 131  25
             return jjStartNfaWithStates_0(2, 20, 15);
 132  
          break;
 133  
       default :
 134  
          break;
 135  
    }
 136  0
    return jjStartNfa_0(1, active0);
 137  
 }
 138  
 private int jjStartNfaWithStates_0(int pos, int kind, int state)
 139  
 {
 140  282
    jjmatchedKind = kind;
 141  282
    jjmatchedPos = pos;
 142  282
    try { curChar = input_stream.readChar(); }
 143  282
    catch(java.io.IOException e) { return pos + 1; }
 144  282
    return jjMoveNfa_0(state, pos + 1);
 145  
 }
 146  1
 static final long[] jjbitVec0 = {
 147  
    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 148  
 };
 149  
 private int jjMoveNfa_0(int startState, int curPos)
 150  
 {
 151  1050
    int startsAt = 0;
 152  1050
    jjnewStateCnt = 14;
 153  1050
    int i = 1;
 154  1050
    jjstateSet[0] = startState;
 155  1050
    int kind = 0x7fffffff;
 156  
    for (;;)
 157  
    {
 158  9472
       if (++jjround == 0x7fffffff)
 159  0
          ReInitRounds();
 160  9472
       if (curChar < 64)
 161  
       {
 162  2941
          long l = 1L << curChar;
 163  
          do
 164  
          {
 165  5785
             switch(jjstateSet[--i])
 166  
             {
 167  
                case 15:
 168  25
                   if ((0xd7ffecfaffffd9ffL & l) != 0L)
 169  
                   {
 170  25
                      if (kind > 27)
 171  25
                         kind = 27;
 172  25
                      jjCheckNAdd(8);
 173  
                   }
 174  25
                   if ((0x7ff280100000000L & l) != 0L)
 175  25
                      jjCheckNAddTwoStates(4, 5);
 176  0
                   else if (curChar == 62)
 177  
                   {
 178  0
                      if (kind > 26)
 179  0
                         kind = 26;
 180  
                   }
 181  
                   break;
 182  
                case 6:
 183  52
                   if ((0xd7ffecfaffffd9ffL & l) != 0L)
 184  
                   {
 185  29
                      if (kind > 27)
 186  29
                         kind = 27;
 187  29
                      jjCheckNAdd(8);
 188  
                   }
 189  52
                   if ((0x3ff000100002600L & l) != 0L)
 190  50
                      jjCheckNAddTwoStates(1, 2);
 191  2
                   else if (curChar == 42)
 192  0
                      jjstateSet[jjnewStateCnt++] = 3;
 193  2
                   else if (curChar == 62)
 194  
                   {
 195  2
                      if (kind > 25)
 196  2
                         kind = 25;
 197  
                   }
 198  
                   break;
 199  
                case 14:
 200  0
                   if ((0xfffffffbffffffffL & l) != 0L)
 201  0
                      jjCheckNAddStates(0, 2);
 202  0
                   else if (curChar == 34)
 203  
                   {
 204  0
                      if (kind > 28)
 205  0
                         kind = 28;
 206  
                   }
 207  
                   break;
 208  
                case 3:
 209  
                case 8:
 210  1535
                   if ((0xd7ffecfaffffd9ffL & l) == 0L)
 211  816
                      break;
 212  719
                   if (kind > 27)
 213  719
                      kind = 27;
 214  719
                   jjCheckNAdd(8);
 215  719
                   break;
 216  
                case 0:
 217  0
                   if ((0xd7ffecfaffffd9ffL & l) != 0L)
 218  
                   {
 219  0
                      if (kind > 27)
 220  0
                         kind = 27;
 221  0
                      jjCheckNAdd(8);
 222  
                   }
 223  0
                   else if (curChar == 34)
 224  0
                      jjCheckNAddStates(0, 2);
 225  0
                   if (curChar == 60)
 226  0
                      jjstateSet[jjnewStateCnt++] = 6;
 227  0
                   if (curChar == 60)
 228  0
                      jjCheckNAddTwoStates(1, 2);
 229  
                   break;
 230  
                case 1:
 231  385
                   if ((0x3ff000100002600L & l) != 0L)
 232  335
                      jjCheckNAddTwoStates(1, 2);
 233  
                   break;
 234  
                case 2:
 235  385
                   if (curChar == 62 && kind > 25)
 236  50
                      kind = 25;
 237  
                   break;
 238  
                case 4:
 239  625
                   if ((0x7ff280100000000L & l) != 0L)
 240  600
                      jjCheckNAddTwoStates(4, 5);
 241  
                   break;
 242  
                case 5:
 243  625
                   if (curChar == 62 && kind > 26)
 244  25
                      kind = 26;
 245  
                   break;
 246  
                case 7:
 247  0
                   if (curChar == 60)
 248  0
                      jjstateSet[jjnewStateCnt++] = 6;
 249  
                   break;
 250  
                case 9:
 251  
                case 11:
 252  50
                   if (curChar == 34)
 253  50
                      jjCheckNAddStates(0, 2);
 254  
                   break;
 255  
                case 10:
 256  701
                   if ((0xfffffffbffffffffL & l) != 0L)
 257  440
                      jjCheckNAddStates(0, 2);
 258  
                   break;
 259  
                case 13:
 260  701
                   if (curChar == 34 && kind > 28)
 261  261
                      kind = 28;
 262  
                   break;
 263  
                default : break;
 264  
             }
 265  5785
          } while(i != startsAt);
 266  2941
       }
 267  6531
       else if (curChar < 128)
 268  
       {
 269  6531
          long l = 1L << (curChar & 077);
 270  
          do
 271  
          {
 272  9991
             switch(jjstateSet[--i])
 273  
             {
 274  
                case 15:
 275  0
                   if ((0xd7ffffffffffffffL & l) != 0L)
 276  
                   {
 277  0
                      if (kind > 27)
 278  0
                         kind = 27;
 279  0
                      jjCheckNAdd(8);
 280  
                   }
 281  0
                   if (curChar == 90)
 282  0
                      jjCheckNAddTwoStates(4, 5);
 283  
                   break;
 284  
                case 6:
 285  0
                   if ((0xd7ffffffffffffffL & l) != 0L)
 286  
                   {
 287  0
                      if (kind > 27)
 288  0
                         kind = 27;
 289  0
                      jjCheckNAdd(8);
 290  
                   }
 291  0
                   if ((0x7e0000007eL & l) != 0L)
 292  0
                      jjCheckNAddTwoStates(1, 2);
 293  
                   break;
 294  
                case 14:
 295  211
                   jjCheckNAddStates(0, 2);
 296  211
                   if (curChar == 92)
 297  0
                      jjstateSet[jjnewStateCnt++] = 11;
 298  
                   break;
 299  
                case 3:
 300  0
                   if ((0xd7ffffffffffffffL & l) != 0L)
 301  
                   {
 302  0
                      if (kind > 27)
 303  0
                         kind = 27;
 304  0
                      jjCheckNAdd(8);
 305  
                   }
 306  0
                   if (curChar == 68)
 307  0
                      jjCheckNAddTwoStates(4, 5);
 308  
                   break;
 309  
                case 0:
 310  
                case 8:
 311  4640
                   if ((0xd7ffffffffffffffL & l) == 0L)
 312  0
                      break;
 313  4640
                   if (kind > 27)
 314  4640
                      kind = 27;
 315  4640
                   jjCheckNAdd(8);
 316  4640
                   break;
 317  
                case 1:
 318  50
                   if ((0x7e0000007eL & l) != 0L)
 319  50
                      jjCheckNAddTwoStates(1, 2);
 320  
                   break;
 321  
                case 4:
 322  0
                   if (curChar == 90)
 323  0
                      jjCheckNAddTwoStates(4, 5);
 324  
                   break;
 325  
                case 10:
 326  1680
                   jjCheckNAddStates(0, 2);
 327  1680
                   break;
 328  
                case 12:
 329  1680
                   if (curChar == 92)
 330  50
                      jjstateSet[jjnewStateCnt++] = 11;
 331  
                   break;
 332  
                default : break;
 333  
             }
 334  9991
          } while(i != startsAt);
 335  6531
       }
 336  
       else
 337  
       {
 338  0
          int i2 = (curChar & 0xff) >> 6;
 339  0
          long l2 = 1L << (curChar & 077);
 340  
          do
 341  
          {
 342  0
             switch(jjstateSet[--i])
 343  
             {
 344  
                case 15:
 345  
                case 8:
 346  0
                   if ((jjbitVec0[i2] & l2) == 0L)
 347  0
                      break;
 348  0
                   if (kind > 27)
 349  0
                      kind = 27;
 350  0
                   jjCheckNAdd(8);
 351  0
                   break;
 352  
                case 6:
 353  0
                   if ((jjbitVec0[i2] & l2) == 0L)
 354  0
                      break;
 355  0
                   if (kind > 27)
 356  0
                      kind = 27;
 357  0
                   jjCheckNAdd(8);
 358  0
                   break;
 359  
                case 14:
 360  
                case 10:
 361  0
                   if ((jjbitVec0[i2] & l2) != 0L)
 362  0
                      jjCheckNAddStates(0, 2);
 363  
                   break;
 364  
                case 3:
 365  0
                   if ((jjbitVec0[i2] & l2) == 0L)
 366  0
                      break;
 367  0
                   if (kind > 27)
 368  0
                      kind = 27;
 369  0
                   jjCheckNAdd(8);
 370  0
                   break;
 371  
                case 0:
 372  0
                   if ((jjbitVec0[i2] & l2) == 0L)
 373  0
                      break;
 374  0
                   if (kind > 27)
 375  0
                      kind = 27;
 376  0
                   jjCheckNAdd(8);
 377  0
                   break;
 378  
                default : break;
 379  
             }
 380  0
          } while(i != startsAt);
 381  
       }
 382  9472
       if (kind != 0x7fffffff)
 383  
       {
 384  5745
          jjmatchedKind = kind;
 385  5745
          jjmatchedPos = curPos;
 386  5745
          kind = 0x7fffffff;
 387  
       }
 388  9472
       ++curPos;
 389  9472
       if ((i = jjnewStateCnt) == (startsAt = 14 - (jjnewStateCnt = startsAt)))
 390  1050
          return curPos;
 391  8422
       try { curChar = input_stream.readChar(); }
 392  8422
       catch(java.io.IOException e) { return curPos; }
 393  
    }
 394  
 }
 395  
 private int jjMoveStringLiteralDfa0_2()
 396  
 {
 397  828
    return jjMoveNfa_2(0, 0);
 398  
 }
 399  
 private int jjMoveNfa_2(int startState, int curPos)
 400  
 {
 401  828
    int startsAt = 0;
 402  828
    jjnewStateCnt = 3;
 403  828
    int i = 1;
 404  828
    jjstateSet[0] = startState;
 405  828
    int kind = 0x7fffffff;
 406  
    for (;;)
 407  
    {
 408  851
       if (++jjround == 0x7fffffff)
 409  0
          ReInitRounds();
 410  851
       if (curChar < 64)
 411  
       {
 412  207
          long l = 1L << curChar;
 413  
          do
 414  
          {
 415  207
             switch(jjstateSet[--i])
 416  
             {
 417  
                case 0:
 418  184
                   if ((0x2400L & l) != 0L)
 419  
                   {
 420  23
                      if (kind > 9)
 421  23
                         kind = 9;
 422  
                   }
 423  184
                   if (curChar == 13)
 424  23
                      jjstateSet[jjnewStateCnt++] = 1;
 425  
                   break;
 426  
                case 1:
 427  23
                   if (curChar == 10 && kind > 9)
 428  23
                      kind = 9;
 429  
                   break;
 430  
                case 2:
 431  0
                   if (curChar == 13)
 432  0
                      jjstateSet[jjnewStateCnt++] = 1;
 433  
                   break;
 434  
                default : break;
 435  
             }
 436  207
          } while(i != startsAt);
 437  207
       }
 438  644
       else if (curChar < 128)
 439  
       {
 440  644
          long l = 1L << (curChar & 077);
 441  
          do
 442  
          {
 443  644
             switch(jjstateSet[--i])
 444  
             {
 445  
                default : break;
 446  
             }
 447  644
          } while(i != startsAt);
 448  644
       }
 449  
       else
 450  
       {
 451  0
          int i2 = (curChar & 0xff) >> 6;
 452  0
          long l2 = 1L << (curChar & 077);
 453  
          do
 454  
          {
 455  0
             switch(jjstateSet[--i])
 456  
             {
 457  
                default : break;
 458  
             }
 459  0
          } while(i != startsAt);
 460  
       }
 461  851
       if (kind != 0x7fffffff)
 462  
       {
 463  46
          jjmatchedKind = kind;
 464  46
          jjmatchedPos = curPos;
 465  46
          kind = 0x7fffffff;
 466  
       }
 467  851
       ++curPos;
 468  851
       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
 469  828
          return curPos;
 470  23
       try { curChar = input_stream.readChar(); }
 471  23
       catch(java.io.IOException e) { return curPos; }
 472  
    }
 473  
 }
 474  
 private int jjMoveStringLiteralDfa0_1()
 475  
 {
 476  18699
    switch(curChar)
 477  
    {
 478  
       case 42:
 479  345
          return jjMoveStringLiteralDfa1_1(0x80L);
 480  
       default :
 481  18354
          return 1;
 482  
    }
 483  
 }
 484  
 private int jjMoveStringLiteralDfa1_1(long active0)
 485  
 {
 486  345
    try { curChar = input_stream.readChar(); }
 487  0
    catch(java.io.IOException e) {
 488  0
       return 1;
 489  345
    }
 490  345
    switch(curChar)
 491  
    {
 492  
       case 47:
 493  23
          if ((active0 & 0x80L) != 0L)
 494  23
             return jjStopAtPos(1, 7);
 495  
          break;
 496  
       default :
 497  322
          return 2;
 498  
    }
 499  0
    return 2;
 500  
 }
 501  1
 static final int[] jjnextStates = {
 502  
    10, 12, 13, 
 503  
 };
 504  
 
 505  
 /** Token literal values. */
 506  1
 public static final String[] jjstrLiteralImages = {
 507  
 "", null, null, null, null, null, null, null, null, null, null, "\50", "\51", 
 508  
 "\54", "\173", "\175", "\73", "\75", "\74", "\76", "\74\52\104", "\42", null, null, 
 509  
 null, null, null, null, null, "\134\42", };
 510  
 
 511  
 /** Lexer state names. */
 512  1
 public static final String[] lexStateNames = {
 513  
    "DEFAULT",
 514  
    "IN_COMMENT",
 515  
    "IN_SINGLE_LINE_COMMENT",
 516  
 };
 517  
 
 518  
 /** Lex State array. */
 519  1
 public static final int[] jjnewLexState = {
 520  
    -1, -1, -1, -1, -1, 1, -1, 0, 2, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
 521  
    -1, -1, -1, -1, -1, 
 522  
 };
 523  1
 static final long[] jjtoToken = {
 524  
    0x3e3ff801L, 
 525  
 };
 526  1
 static final long[] jjtoSkip = {
 527  
    0x29eL, 
 528  
 };
 529  1
 static final long[] jjtoSpecial = {
 530  
    0x200L, 
 531  
 };
 532  1
 static final long[] jjtoMore = {
 533  
    0x560L, 
 534  
 };
 535  
 protected SimpleCharStream input_stream;
 536  32
 private final int[] jjrounds = new int[14];
 537  32
 private final int[] jjstateSet = new int[28];
 538  32
 private final StringBuilder jjimage = new StringBuilder();
 539  32
 private StringBuilder image = jjimage;
 540  
 private int jjimageLen;
 541  
 private int lengthOfMatch;
 542  
 protected char curChar;
 543  
 /** Constructor. */
 544  32
 public PropertyListParserTokenManager(SimpleCharStream stream){
 545  
    if (SimpleCharStream.staticFlag)
 546  
       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
 547  32
    input_stream = stream;
 548  32
 }
 549  
 
 550  
 /** Constructor. */
 551  
 public PropertyListParserTokenManager(SimpleCharStream stream, int lexState){
 552  0
    this(stream);
 553  0
    SwitchTo(lexState);
 554  0
 }
 555  
 
 556  
 /** Reinitialise parser. */
 557  
 public void ReInit(SimpleCharStream stream)
 558  
 {
 559  0
    jjmatchedPos = jjnewStateCnt = 0;
 560  0
    curLexState = defaultLexState;
 561  0
    input_stream = stream;
 562  0
    ReInitRounds();
 563  0
 }
 564  
 private void ReInitRounds()
 565  
 {
 566  
    int i;
 567  0
    jjround = 0x80000001;
 568  0
    for (i = 14; i-- > 0;)
 569  0
       jjrounds[i] = 0x80000000;
 570  0
 }
 571  
 
 572  
 /** Reinitialise parser. */
 573  
 public void ReInit(SimpleCharStream stream, int lexState)
 574  
 {
 575  0
    ReInit(stream);
 576  0
    SwitchTo(lexState);
 577  0
 }
 578  
 
 579  
 /** Switch to specified lex state. */
 580  
 public void SwitchTo(int lexState)
 581  
 {
 582  0
    if (lexState >= 3 || lexState < 0)
 583  0
       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
 584  
    else
 585  0
       curLexState = lexState;
 586  0
 }
 587  
 
 588  
 protected Token jjFillToken()
 589  
 {
 590  
    final Token t;
 591  
    final String curTokenImage;
 592  
    final int beginLine;
 593  
    final int endLine;
 594  
    final int beginColumn;
 595  
    final int endColumn;
 596  2794
    String im = jjstrLiteralImages[jjmatchedKind];
 597  2794
    curTokenImage = (im == null) ? input_stream.GetImage() : im;
 598  2794
    beginLine = input_stream.getBeginLine();
 599  2794
    beginColumn = input_stream.getBeginColumn();
 600  2794
    endLine = input_stream.getEndLine();
 601  2794
    endColumn = input_stream.getEndColumn();
 602  2794
    t = Token.newToken(jjmatchedKind, curTokenImage);
 603  
 
 604  2794
    t.beginLine = beginLine;
 605  2794
    t.endLine = endLine;
 606  2794
    t.beginColumn = beginColumn;
 607  2794
    t.endColumn = endColumn;
 608  
 
 609  2794
    return t;
 610  
 }
 611  
 
 612  32
 int curLexState = 0;
 613  32
 int defaultLexState = 0;
 614  
 int jjnewStateCnt;
 615  
 int jjround;
 616  
 int jjmatchedPos;
 617  
 int jjmatchedKind;
 618  
 
 619  
 /** Get the next Token. */
 620  
 public Token getNextToken() 
 621  
 {
 622  2771
   Token specialToken = null;
 623  
   Token matchedToken;
 624  2771
   int curPos = 0;
 625  
 
 626  
   EOFLoop :
 627  
   for (;;)
 628  
   {
 629  
    try
 630  
    {
 631  2840
       curChar = input_stream.BeginToken();
 632  
    }
 633  28
    catch(java.io.IOException e)
 634  
    {
 635  28
       jjmatchedKind = 0;
 636  28
       matchedToken = jjFillToken();
 637  28
       matchedToken.specialToken = specialToken;
 638  28
       return matchedToken;
 639  2812
    }
 640  2812
    image = jjimage;
 641  2812
    image.setLength(0);
 642  2812
    jjimageLen = 0;
 643  
 
 644  
    for (;;)
 645  
    {
 646  22339
      switch(curLexState)
 647  
      {
 648  
        case 0:
 649  2812
          try { input_stream.backup(0);
 650  11206
             while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
 651  8417
                curChar = input_stream.BeginToken();
 652  
          }
 653  2789
          catch (java.io.IOException e1) { continue EOFLoop; }
 654  2789
          jjmatchedKind = 0x7fffffff;
 655  2789
          jjmatchedPos = 0;
 656  2789
          curPos = jjMoveStringLiteralDfa0_0();
 657  2789
          break;
 658  
        case 1:
 659  18699
          jjmatchedKind = 0x7fffffff;
 660  18699
          jjmatchedPos = 0;
 661  18699
          curPos = jjMoveStringLiteralDfa0_1();
 662  18699
          if (jjmatchedPos == 0 && jjmatchedKind > 6)
 663  
          {
 664  18676
             jjmatchedKind = 6;
 665  
          }
 666  
          break;
 667  
        case 2:
 668  828
          jjmatchedKind = 0x7fffffff;
 669  828
          jjmatchedPos = 0;
 670  828
          curPos = jjMoveStringLiteralDfa0_2();
 671  828
          if (jjmatchedPos == 0 && jjmatchedKind > 10)
 672  
          {
 673  805
             jjmatchedKind = 10;
 674  
          }
 675  
          break;
 676  
      }
 677  22316
      if (jjmatchedKind != 0x7fffffff)
 678  
      {
 679  22316
         if (jjmatchedPos + 1 < curPos)
 680  1090
            input_stream.backup(curPos - jjmatchedPos - 1);
 681  22316
         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 682  
         {
 683  2743
            matchedToken = jjFillToken();
 684  2743
            matchedToken.specialToken = specialToken;
 685  2743
        if (jjnewLexState[jjmatchedKind] != -1)
 686  0
          curLexState = jjnewLexState[jjmatchedKind];
 687  2743
            return matchedToken;
 688  
         }
 689  19573
         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 690  
         {
 691  46
            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 692  
            {
 693  23
               matchedToken = jjFillToken();
 694  23
               if (specialToken == null)
 695  23
                  specialToken = matchedToken;
 696  
               else
 697  
               {
 698  0
                  matchedToken.specialToken = specialToken;
 699  0
                  specialToken = (specialToken.next = matchedToken);
 700  
               }
 701  23
               SkipLexicalActions(matchedToken);
 702  
            }
 703  
            else
 704  23
               SkipLexicalActions(null);
 705  46
          if (jjnewLexState[jjmatchedKind] != -1)
 706  46
            curLexState = jjnewLexState[jjmatchedKind];
 707  
            continue EOFLoop;
 708  
         }
 709  19527
         jjimageLen += jjmatchedPos + 1;
 710  19527
       if (jjnewLexState[jjmatchedKind] != -1)
 711  46
         curLexState = jjnewLexState[jjmatchedKind];
 712  19527
         curPos = 0;
 713  19527
         jjmatchedKind = 0x7fffffff;
 714  
         try {
 715  19527
            curChar = input_stream.readChar();
 716  19527
            continue;
 717  
         }
 718  0
         catch (java.io.IOException e1) { }
 719  
      }
 720  0
      int error_line = input_stream.getEndLine();
 721  0
      int error_column = input_stream.getEndColumn();
 722  0
      String error_after = null;
 723  0
      boolean EOFSeen = false;
 724  0
      try { input_stream.readChar(); input_stream.backup(1); }
 725  0
      catch (java.io.IOException e1) {
 726  0
         EOFSeen = true;
 727  0
         error_after = curPos <= 1 ? "" : input_stream.GetImage();
 728  0
         if (curChar == '\n' || curChar == '\r') {
 729  0
            error_line++;
 730  0
            error_column = 0;
 731  
         }
 732  
         else
 733  0
            error_column++;
 734  0
      }
 735  0
      if (!EOFSeen) {
 736  0
         input_stream.backup(1);
 737  0
         error_after = curPos <= 1 ? "" : input_stream.GetImage();
 738  
      }
 739  0
      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
 740  
    }
 741  
   }
 742  
 }
 743  
 
 744  
 void SkipLexicalActions(Token matchedToken)
 745  
 {
 746  46
    switch(jjmatchedKind)
 747  
    {
 748  
       default :
 749  
          break;
 750  
    }
 751  46
 }
 752  
 private void jjCheckNAdd(int state)
 753  
 {
 754  14676
    if (jjrounds[state] != jjround)
 755  
    {
 756  14676
       jjstateSet[jjnewStateCnt++] = state;
 757  14676
       jjrounds[state] = jjround;
 758  
    }
 759  14676
 }
 760  
 private void jjAddStates(int start, int end)
 761  
 {
 762  
    do {
 763  0
       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
 764  0
    } while (start++ != end);
 765  0
 }
 766  
 private void jjCheckNAddTwoStates(int state1, int state2)
 767  
 {
 768  1060
    jjCheckNAdd(state1);
 769  1060
    jjCheckNAdd(state2);
 770  1060
 }
 771  
 
 772  
 private void jjCheckNAddStates(int start, int end)
 773  
 {
 774  
    do {
 775  7143
       jjCheckNAdd(jjnextStates[start]);
 776  7143
    } while (start++ != end);
 777  2381
 }
 778  
 
 779  
 }