Clover coverage report - Code Coverage for hivemind release 1.0-beta-1
Coverage timestamp: Sat Jul 3 2004 09:41:37 EDT
file stats: LOC: 672   Methods: 0
NCLOC: 648   Classes: 1
30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover
 
 Source file Conditionals Statements Methods TOTAL
SimpleDataLanguageParserTokenManager.java - - - -
coverage
 1   
 /* Generated By: SimpleDataLanguageParser.jj,v 1.3 2004/06/25 20&JavaCC: Do not edit this line. SimpleDataLanguageParserTokenManager.java */
 2   
 //  Copyright 2004 The Apache Software Foundation
 3   
 //
 4   
 // Licensed under the Apache License, Version 2.0 (the "License");
 5   
 // you may not use this file except in compliance with the License.
 6   
 // You may obtain a copy of the License at
 7   
 //
 8   
 //     http://www.apache.org/licenses/LICENSE-2.0
 9   
 //
 10   
 // Unless required by applicable law or agreed to in writing, software
 11   
 // distributed under the License is distributed on an "AS IS" BASIS,
 12   
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13   
 // See the License for the specific language governing permissions and
 14   
 // limitations under the License.
 15   
 
 16   
 ///CLOVER:OFF
 17   
 package org.apache.hivemind.sdl.parser;
 18   
 import org.xml.sax.*;
 19   
 import org.xml.sax.helpers.*;
 20   
 
 21   
 public class SimpleDataLanguageParserTokenManager implements SimpleDataLanguageParserConstants
 22   
 {
 23   
   public  java.io.PrintStream debugStream = System.out;
 24   
   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
 25   
 private final int jjStopAtPos(int pos, int kind)
 26   
 {
 27   
    jjmatchedKind = kind;
 28   
    jjmatchedPos = pos;
 29   
    return pos + 1;
 30   
 }
 31   
 private final int jjMoveStringLiteralDfa0_3()
 32   
 {
 33   
    switch(curChar)
 34   
    {
 35   
       case 42:
 36   
          return jjMoveStringLiteralDfa1_3(0x2000000L);
 37   
       default :
 38   
          return 1;
 39   
    }
 40   
 }
 41   
 private final int jjMoveStringLiteralDfa1_3(long active0)
 42   
 {
 43   
    try { curChar = input_stream.readChar(); }
 44   
    catch(java.io.IOException e) {
 45   
       return 1;
 46   
    }
 47   
    switch(curChar)
 48   
    {
 49   
       case 47:
 50   
          if ((active0 & 0x2000000L) != 0L)
 51   
             return jjStopAtPos(1, 25);
 52   
          break;
 53   
       default :
 54   
          return 2;
 55   
    }
 56   
    return 2;
 57   
 }
 58   
 private final int jjStopStringLiteralDfa_0(int pos, long active0)
 59   
 {
 60   
    switch (pos)
 61   
    {
 62   
       default :
 63   
          return -1;
 64   
    }
 65   
 }
 66   
 private final int jjStartNfa_0(int pos, long active0)
 67   
 {
 68   
    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
 69   
 }
 70   
 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
 71   
 {
 72   
    jjmatchedKind = kind;
 73   
    jjmatchedPos = pos;
 74   
    try { curChar = input_stream.readChar(); }
 75   
    catch(java.io.IOException e) { return pos + 1; }
 76   
    return jjMoveNfa_0(state, pos + 1);
 77   
 }
 78   
 private final int jjMoveStringLiteralDfa0_0()
 79   
 {
 80   
    switch(curChar)
 81   
    {
 82   
       case 40:
 83   
          return jjStopAtPos(0, 13);
 84   
       case 41:
 85   
          return jjStopAtPos(0, 14);
 86   
       case 47:
 87   
          return jjMoveStringLiteralDfa1_0(0x300000L);
 88   
       case 61:
 89   
          return jjStopAtPos(0, 17);
 90   
       case 123:
 91   
          return jjStopAtPos(0, 15);
 92   
       case 125:
 93   
          return jjStopAtPos(0, 16);
 94   
       default :
 95   
          return jjMoveNfa_0(0, 0);
 96   
    }
 97   
 }
 98   
 private final int jjMoveStringLiteralDfa1_0(long active0)
 99   
 {
 100   
    try { curChar = input_stream.readChar(); }
 101   
    catch(java.io.IOException e) {
 102   
       jjStopStringLiteralDfa_0(0, active0);
 103   
       return 1;
 104   
    }
 105   
    switch(curChar)
 106   
    {
 107   
       case 42:
 108   
          if ((active0 & 0x200000L) != 0L)
 109   
             return jjStopAtPos(1, 21);
 110   
          break;
 111   
       case 47:
 112   
          if ((active0 & 0x100000L) != 0L)
 113   
             return jjStopAtPos(1, 20);
 114   
          break;
 115   
       default :
 116   
          break;
 117   
    }
 118   
    return jjStartNfa_0(0, active0);
 119   
 }
 120   
 private final void jjCheckNAdd(int state)
 121   
 {
 122   
    if (jjrounds[state] != jjround)
 123   
    {
 124   
       jjstateSet[jjnewStateCnt++] = state;
 125   
       jjrounds[state] = jjround;
 126   
    }
 127   
 }
 128   
 private final void jjAddStates(int start, int end)
 129   
 {
 130   
    do {
 131   
       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
 132   
    } while (start++ != end);
 133   
 }
 134   
 private final void jjCheckNAddTwoStates(int state1, int state2)
 135   
 {
 136   
    jjCheckNAdd(state1);
 137   
    jjCheckNAdd(state2);
 138   
 }
 139   
 private final void jjCheckNAddStates(int start, int end)
 140   
 {
 141   
    do {
 142   
       jjCheckNAdd(jjnextStates[start]);
 143   
    } while (start++ != end);
 144   
 }
 145   
 private final void jjCheckNAddStates(int start)
 146   
 {
 147   
    jjCheckNAdd(jjnextStates[start]);
 148   
    jjCheckNAdd(jjnextStates[start + 1]);
 149   
 }
 150   
 static final long[] jjbitVec0 = {
 151   
    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 152   
 };
 153   
 private final int jjMoveNfa_0(int startState, int curPos)
 154   
 {
 155   
    int[] nextStates;
 156   
    int startsAt = 0;
 157   
    jjnewStateCnt = 32;
 158   
    int i = 1;
 159   
    jjstateSet[0] = startState;
 160   
    int j, kind = 0x7fffffff;
 161   
    for (;;)
 162   
    {
 163   
       if (++jjround == 0x7fffffff)
 164   
          ReInitRounds();
 165   
       if (curChar < 64)
 166   
       {
 167   
          long l = 1L << curChar;
 168   
          MatchLoop: do
 169   
          {
 170   
             switch(jjstateSet[--i])
 171   
             {
 172   
                case 0:
 173   
                   if ((0x3ff000000000000L & l) != 0L)
 174   
                   {
 175   
                      if (kind > 5)
 176   
                         kind = 5;
 177   
                      jjCheckNAddStates(0, 3);
 178   
                   }
 179   
                   else if ((0x280000000000L & l) != 0L)
 180   
                      jjCheckNAddTwoStates(1, 3);
 181   
                   else if (curChar == 36)
 182   
                      jjstateSet[jjnewStateCnt++] = 18;
 183   
                   else if (curChar == 60)
 184   
                      jjstateSet[jjnewStateCnt++] = 12;
 185   
                   else if (curChar == 34)
 186   
                      jjCheckNAddStates(4, 6);
 187   
                   else if (curChar == 46)
 188   
                      jjCheckNAdd(2);
 189   
                   break;
 190   
                case 1:
 191   
                   if (curChar == 46)
 192   
                      jjCheckNAdd(2);
 193   
                   break;
 194   
                case 2:
 195   
                   if ((0x3ff000000000000L & l) == 0L)
 196   
                      break;
 197   
                   if (kind > 5)
 198   
                      kind = 5;
 199   
                   jjCheckNAdd(2);
 200   
                   break;
 201   
                case 3:
 202   
                   if ((0x3ff000000000000L & l) == 0L)
 203   
                      break;
 204   
                   if (kind > 5)
 205   
                      kind = 5;
 206   
                   jjCheckNAddStates(0, 3);
 207   
                   break;
 208   
                case 4:
 209   
                   if ((0x3ff000000000000L & l) == 0L)
 210   
                      break;
 211   
                   if (kind > 5)
 212   
                      kind = 5;
 213   
                   jjCheckNAddTwoStates(4, 5);
 214   
                   break;
 215   
                case 5:
 216   
                   if (curChar == 46 && kind > 5)
 217   
                      kind = 5;
 218   
                   break;
 219   
                case 6:
 220   
                   if ((0x3ff000000000000L & l) != 0L)
 221   
                      jjCheckNAddTwoStates(6, 1);
 222   
                   break;
 223   
                case 7:
 224   
                case 10:
 225   
                   if (curChar == 34)
 226   
                      jjCheckNAddStates(4, 6);
 227   
                   break;
 228   
                case 8:
 229   
                   if ((0xfffffffbffffffffL & l) != 0L)
 230   
                      jjCheckNAddStates(4, 6);
 231   
                   break;
 232   
                case 11:
 233   
                   if (curChar == 34 && kind > 8)
 234   
                      kind = 8;
 235   
                   break;
 236   
                case 12:
 237   
                   if (curChar == 60)
 238   
                      jjCheckNAddStates(7, 9);
 239   
                   break;
 240   
                case 13:
 241   
                   if ((0xbfffffffffffffffL & l) != 0L)
 242   
                      jjCheckNAddStates(7, 9);
 243   
                   break;
 244   
                case 14:
 245   
                   if (curChar == 62)
 246   
                      jjCheckNAdd(13);
 247   
                   break;
 248   
                case 15:
 249   
                   if (curChar == 62 && kind > 9)
 250   
                      kind = 9;
 251   
                   break;
 252   
                case 16:
 253   
                   if (curChar == 62)
 254   
                      jjstateSet[jjnewStateCnt++] = 15;
 255   
                   break;
 256   
                case 17:
 257   
                   if (curChar == 60)
 258   
                      jjstateSet[jjnewStateCnt++] = 12;
 259   
                   break;
 260   
                case 20:
 261   
                   if ((0x3ff200000000000L & l) != 0L)
 262   
                      jjCheckNAddStates(10, 12);
 263   
                   break;
 264   
                case 21:
 265   
                   if (curChar == 46)
 266   
                      jjstateSet[jjnewStateCnt++] = 22;
 267   
                   break;
 268   
                case 23:
 269   
                   if ((0x3ff200000000000L & l) != 0L)
 270   
                      jjCheckNAddStates(13, 15);
 271   
                   break;
 272   
                case 25:
 273   
                   if (curChar == 36)
 274   
                      jjstateSet[jjnewStateCnt++] = 18;
 275   
                   break;
 276   
                case 27:
 277   
                   if ((0x3ff200000000000L & l) == 0L)
 278   
                      break;
 279   
                   if (kind > 6)
 280   
                      kind = 6;
 281   
                   jjstateSet[jjnewStateCnt++] = 27;
 282   
                   break;
 283   
                case 28:
 284   
                   if ((0x3ff200000000000L & l) == 0L)
 285   
                      break;
 286   
                   if (kind > 7)
 287   
                      kind = 7;
 288   
                   jjCheckNAddTwoStates(28, 29);
 289   
                   break;
 290   
                case 29:
 291   
                   if (curChar == 46)
 292   
                      jjstateSet[jjnewStateCnt++] = 30;
 293   
                   break;
 294   
                case 31:
 295   
                   if ((0x3ff200000000000L & l) == 0L)
 296   
                      break;
 297   
                   if (kind > 7)
 298   
                      kind = 7;
 299   
                   jjCheckNAddTwoStates(29, 31);
 300   
                   break;
 301   
                default : break;
 302   
             }
 303   
          } while(i != startsAt);
 304   
       }
 305   
       else if (curChar < 128)
 306   
       {
 307   
          long l = 1L << (curChar & 077);
 308   
          MatchLoop: do
 309   
          {
 310   
             switch(jjstateSet[--i])
 311   
             {
 312   
                case 0:
 313   
                   if ((0x7fffffe87fffffeL & l) == 0L)
 314   
                      break;
 315   
                   if (kind > 6)
 316   
                      kind = 6;
 317   
                   jjCheckNAddStates(16, 18);
 318   
                   break;
 319   
                case 8:
 320   
                   jjCheckNAddStates(4, 6);
 321   
                   break;
 322   
                case 9:
 323   
                   if (curChar == 92)
 324   
                      jjstateSet[jjnewStateCnt++] = 10;
 325   
                   break;
 326   
                case 10:
 327   
                   if ((0x14400010000000L & l) != 0L)
 328   
                      jjCheckNAddStates(4, 6);
 329   
                   break;
 330   
                case 13:
 331   
                   jjAddStates(7, 9);
 332   
                   break;
 333   
                case 18:
 334   
                   if (curChar == 123)
 335   
                      jjstateSet[jjnewStateCnt++] = 19;
 336   
                   break;
 337   
                case 19:
 338   
                case 20:
 339   
                   if ((0x7fffffe87fffffeL & l) != 0L)
 340   
                      jjCheckNAddStates(10, 12);
 341   
                   break;
 342   
                case 22:
 343   
                case 23:
 344   
                   if ((0x7fffffe87fffffeL & l) != 0L)
 345   
                      jjCheckNAddStates(13, 15);
 346   
                   break;
 347   
                case 24:
 348   
                   if (curChar == 125 && kind > 10)
 349   
                      kind = 10;
 350   
                   break;
 351   
                case 27:
 352   
                   if ((0x7fffffe87fffffeL & l) == 0L)
 353   
                      break;
 354   
                   if (kind > 6)
 355   
                      kind = 6;
 356   
                   jjCheckNAdd(27);
 357   
                   break;
 358   
                case 28:
 359   
                   if ((0x7fffffe87fffffeL & l) == 0L)
 360   
                      break;
 361   
                   if (kind > 7)
 362   
                      kind = 7;
 363   
                   jjCheckNAddTwoStates(28, 29);
 364   
                   break;
 365   
                case 30:
 366   
                case 31:
 367   
                   if ((0x7fffffe87fffffeL & l) == 0L)
 368   
                      break;
 369   
                   if (kind > 7)
 370   
                      kind = 7;
 371   
                   jjCheckNAddTwoStates(29, 31);
 372   
                   break;
 373   
                default : break;
 374   
             }
 375   
          } while(i != startsAt);
 376   
       }
 377   
       else
 378   
       {
 379   
          int i2 = (curChar & 0xff) >> 6;
 380   
          long l2 = 1L << (curChar & 077);
 381   
          MatchLoop: do
 382   
          {
 383   
             switch(jjstateSet[--i])
 384   
             {
 385   
                case 8:
 386   
                   if ((jjbitVec0[i2] & l2) != 0L)
 387   
                      jjAddStates(4, 6);
 388   
                   break;
 389   
                case 13:
 390   
                   if ((jjbitVec0[i2] & l2) != 0L)
 391   
                      jjAddStates(7, 9);
 392   
                   break;
 393   
                default : break;
 394   
             }
 395   
          } while(i != startsAt);
 396   
       }
 397   
       if (kind != 0x7fffffff)
 398   
       {
 399   
          jjmatchedKind = kind;
 400   
          jjmatchedPos = curPos;
 401   
          kind = 0x7fffffff;
 402   
       }
 403   
       ++curPos;
 404   
       if ((i = jjnewStateCnt) == (startsAt = 32 - (jjnewStateCnt = startsAt)))
 405   
          return curPos;
 406   
       try { curChar = input_stream.readChar(); }
 407   
       catch(java.io.IOException e) { return curPos; }
 408   
    }
 409   
 }
 410   
 private final int jjMoveStringLiteralDfa0_2()
 411   
 {
 412   
    return jjMoveNfa_2(0, 0);
 413   
 }
 414   
 private final int jjMoveNfa_2(int startState, int curPos)
 415   
 {
 416   
    int[] nextStates;
 417   
    int startsAt = 0;
 418   
    jjnewStateCnt = 1;
 419   
    int i = 1;
 420   
    jjstateSet[0] = startState;
 421   
    int j, kind = 0x7fffffff;
 422   
    for (;;)
 423   
    {
 424   
       if (++jjround == 0x7fffffff)
 425   
          ReInitRounds();
 426   
       if (curChar < 64)
 427   
       {
 428   
          long l = 1L << curChar;
 429   
          MatchLoop: do
 430   
          {
 431   
             switch(jjstateSet[--i])
 432   
             {
 433   
                case 0:
 434   
                   if ((0x2400L & l) != 0L)
 435   
                      kind = 23;
 436   
                   break;
 437   
                default : break;
 438   
             }
 439   
          } while(i != startsAt);
 440   
       }
 441   
       else if (curChar < 128)
 442   
       {
 443   
          long l = 1L << (curChar & 077);
 444   
          MatchLoop: do
 445   
          {
 446   
             switch(jjstateSet[--i])
 447   
             {
 448   
                default : break;
 449   
             }
 450   
          } while(i != startsAt);
 451   
       }
 452   
       else
 453   
       {
 454   
          int i2 = (curChar & 0xff) >> 6;
 455   
          long l2 = 1L << (curChar & 077);
 456   
          MatchLoop: do
 457   
          {
 458   
             switch(jjstateSet[--i])
 459   
             {
 460   
                default : break;
 461   
             }
 462   
          } while(i != startsAt);
 463   
       }
 464   
       if (kind != 0x7fffffff)
 465   
       {
 466   
          jjmatchedKind = kind;
 467   
          jjmatchedPos = curPos;
 468   
          kind = 0x7fffffff;
 469   
       }
 470   
       ++curPos;
 471   
       if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
 472   
          return curPos;
 473   
       try { curChar = input_stream.readChar(); }
 474   
       catch(java.io.IOException e) { return curPos; }
 475   
    }
 476   
 }
 477   
 private final int jjMoveStringLiteralDfa0_1()
 478   
 {
 479   
    switch(curChar)
 480   
    {
 481   
       case 34:
 482   
          return jjStopAtPos(0, 22);
 483   
       default :
 484   
          return 1;
 485   
    }
 486   
 }
 487   
 static final int[] jjnextStates = {
 488   
    4, 5, 6, 1, 8, 9, 11, 13, 14, 16, 20, 21, 24, 21, 23, 24, 
 489   
    27, 28, 29, 
 490   
 };
 491   
 public static final String[] jjstrLiteralImages = {
 492   
 "", null, null, null, null, null, null, null, null, null, null, null, null, 
 493   
 "\50", "\51", "\173", "\175", "\75", null, null, null, null, null, null, null, null, 
 494   
 null, };
 495   
 public static final String[] lexStateNames = {
 496   
    "DEFAULT", 
 497   
    "EXTRACTING_QUOTED_LITERAL", 
 498   
    "SINGLE_LINE_COMMENT", 
 499   
    "MULTILINE_COMMENT", 
 500   
 };
 501   
 public static final int[] jjnewLexState = {
 502   
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 3, 0, 0, -1, 
 503   
    0, -1, 
 504   
 };
 505   
 static final long[] jjtoToken = {
 506   
    0x3e7e1L, 
 507   
 };
 508   
 static final long[] jjtoSkip = {
 509   
    0x7f0001eL, 
 510   
 };
 511   
 private SimpleCharStream input_stream;
 512   
 private final int[] jjrounds = new int[32];
 513   
 private final int[] jjstateSet = new int[64];
 514   
 protected char curChar;
 515   
 public SimpleDataLanguageParserTokenManager(SimpleCharStream stream)
 516   
 {
 517   
    if (SimpleCharStream.staticFlag)
 518   
       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
 519   
    input_stream = stream;
 520   
 }
 521   
 public SimpleDataLanguageParserTokenManager(SimpleCharStream stream, int lexState)
 522   
 {
 523   
    this(stream);
 524   
    SwitchTo(lexState);
 525   
 }
 526   
 public void ReInit(SimpleCharStream stream)
 527   
 {
 528   
    jjmatchedPos = jjnewStateCnt = 0;
 529   
    curLexState = defaultLexState;
 530   
    input_stream = stream;
 531   
    ReInitRounds();
 532   
 }
 533   
 private final void ReInitRounds()
 534   
 {
 535   
    int i;
 536   
    jjround = 0x80000001;
 537   
    for (i = 32; i-- > 0;)
 538   
       jjrounds[i] = 0x80000000;
 539   
 }
 540   
 public void ReInit(SimpleCharStream stream, int lexState)
 541   
 {
 542   
    ReInit(stream);
 543   
    SwitchTo(lexState);
 544   
 }
 545   
 public void SwitchTo(int lexState)
 546   
 {
 547   
    if (lexState >= 4 || lexState < 0)
 548   
       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
 549   
    else
 550   
       curLexState = lexState;
 551   
 }
 552   
 
 553   
 private final Token jjFillToken()
 554   
 {
 555   
    Token t = Token.newToken(jjmatchedKind);
 556   
    t.kind = jjmatchedKind;
 557   
    String im = jjstrLiteralImages[jjmatchedKind];
 558   
    t.image = (im == null) ? input_stream.GetImage() : im;
 559   
    t.beginLine = input_stream.getBeginLine();
 560   
    t.beginColumn = input_stream.getBeginColumn();
 561   
    t.endLine = input_stream.getEndLine();
 562   
    t.endColumn = input_stream.getEndColumn();
 563   
    return t;
 564   
 }
 565   
 
 566   
 int curLexState = 0;
 567   
 int defaultLexState = 0;
 568   
 int jjnewStateCnt;
 569   
 int jjround;
 570   
 int jjmatchedPos;
 571   
 int jjmatchedKind;
 572   
 
 573   
 public final Token getNextToken() 
 574   
 {
 575   
   int kind;
 576   
   Token specialToken = null;
 577   
   Token matchedToken;
 578   
   int curPos = 0;
 579   
 
 580   
   EOFLoop :
 581   
   for (;;)
 582   
   {   
 583   
    try   
 584   
    {     
 585   
       curChar = input_stream.BeginToken();
 586   
    }     
 587   
    catch(java.io.IOException e)
 588   
    {        
 589   
       jjmatchedKind = 0;
 590   
       matchedToken = jjFillToken();
 591   
       return matchedToken;
 592   
    }
 593   
 
 594   
    switch(curLexState)
 595   
    {
 596   
      case 0:
 597   
        try { input_stream.backup(0);
 598   
           while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
 599   
              curChar = input_stream.BeginToken();
 600   
        }
 601   
        catch (java.io.IOException e1) { continue EOFLoop; }
 602   
        jjmatchedKind = 0x7fffffff;
 603   
        jjmatchedPos = 0;
 604   
        curPos = jjMoveStringLiteralDfa0_0();
 605   
        break;
 606   
      case 1:
 607   
        jjmatchedKind = 0x7fffffff;
 608   
        jjmatchedPos = 0;
 609   
        curPos = jjMoveStringLiteralDfa0_1();
 610   
        break;
 611   
      case 2:
 612   
        jjmatchedKind = 0x7fffffff;
 613   
        jjmatchedPos = 0;
 614   
        curPos = jjMoveStringLiteralDfa0_2();
 615   
        if (jjmatchedPos == 0 && jjmatchedKind > 24)
 616   
        {
 617   
           jjmatchedKind = 24;
 618   
        }
 619   
        break;
 620   
      case 3:
 621   
        jjmatchedKind = 0x7fffffff;
 622   
        jjmatchedPos = 0;
 623   
        curPos = jjMoveStringLiteralDfa0_3();
 624   
        if (jjmatchedPos == 0 && jjmatchedKind > 26)
 625   
        {
 626   
           jjmatchedKind = 26;
 627   
        }
 628   
        break;
 629   
    }
 630   
      if (jjmatchedKind != 0x7fffffff)
 631   
      {
 632   
         if (jjmatchedPos + 1 < curPos)
 633   
            input_stream.backup(curPos - jjmatchedPos - 1);
 634   
         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 635   
         {
 636   
            matchedToken = jjFillToken();
 637   
        if (jjnewLexState[jjmatchedKind] != -1)
 638   
          curLexState = jjnewLexState[jjmatchedKind];
 639   
            return matchedToken;
 640   
         }
 641   
         else
 642   
         {
 643   
          if (jjnewLexState[jjmatchedKind] != -1)
 644   
            curLexState = jjnewLexState[jjmatchedKind];
 645   
            continue EOFLoop;
 646   
         }
 647   
      }
 648   
      int error_line = input_stream.getEndLine();
 649   
      int error_column = input_stream.getEndColumn();
 650   
      String error_after = null;
 651   
      boolean EOFSeen = false;
 652   
      try { input_stream.readChar(); input_stream.backup(1); }
 653   
      catch (java.io.IOException e1) {
 654   
         EOFSeen = true;
 655   
         error_after = curPos <= 1 ? "" : input_stream.GetImage();
 656   
         if (curChar == '\n' || curChar == '\r') {
 657   
            error_line++;
 658   
            error_column = 0;
 659   
         }
 660   
         else
 661   
            error_column++;
 662   
      }
 663   
      if (!EOFSeen) {
 664   
         input_stream.backup(1);
 665   
         error_after = curPos <= 1 ? "" : input_stream.GetImage();
 666   
      }
 667   
      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
 668   
   }
 669   
 }
 670   
 
 671   
 }
 672