Clover coverage report - Code Coverage for hivemind release 1.0-beta-2
Coverage timestamp: Sun Aug 1 2004 14:03:45 EDT
file stats: LOC: 744   Methods: 0
NCLOC: 720   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.4 2004/07/16 23&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(0x8000000L);
 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 & 0x8000000L) != 0L)
 51   
             return jjStopAtPos(1, 27);
 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, 14);
 84   
       case 41:
 85   
          return jjStopAtPos(0, 15);
 86   
       case 47:
 87   
          return jjMoveStringLiteralDfa1_0(0xc00000L);
 88   
       case 61:
 89   
          return jjStopAtPos(0, 18);
 90   
       case 123:
 91   
          return jjStopAtPos(0, 16);
 92   
       case 125:
 93   
          return jjStopAtPos(0, 17);
 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 & 0x800000L) != 0L)
 109   
             return jjStopAtPos(1, 23);
 110   
          break;
 111   
       case 47:
 112   
          if ((active0 & 0x400000L) != 0L)
 113   
             return jjStopAtPos(1, 22);
 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 = 42;
 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 > 9)
 234   
                      kind = 9;
 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 > 10)
 250   
                      kind = 10;
 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   
                case 32:
 302   
                   if ((0x3ff200000000000L & l) == 0L)
 303   
                      break;
 304   
                   if (kind > 8)
 305   
                      kind = 8;
 306   
                   jjCheckNAddStates(16, 18);
 307   
                   break;
 308   
                case 33:
 309   
                   if (curChar == 46)
 310   
                      jjstateSet[jjnewStateCnt++] = 34;
 311   
                   break;
 312   
                case 35:
 313   
                   if ((0x3ff200000000000L & l) == 0L)
 314   
                      break;
 315   
                   if (kind > 8)
 316   
                      kind = 8;
 317   
                   jjCheckNAddStates(19, 21);
 318   
                   break;
 319   
                case 36:
 320   
                   if (curChar == 58)
 321   
                      jjstateSet[jjnewStateCnt++] = 37;
 322   
                   break;
 323   
                case 38:
 324   
                   if ((0x3ff200000000000L & l) == 0L)
 325   
                      break;
 326   
                   if (kind > 8)
 327   
                      kind = 8;
 328   
                   jjCheckNAddStates(22, 24);
 329   
                   break;
 330   
                case 39:
 331   
                   if (curChar == 46)
 332   
                      jjstateSet[jjnewStateCnt++] = 40;
 333   
                   break;
 334   
                case 41:
 335   
                   if ((0x3ff200000000000L & l) == 0L)
 336   
                      break;
 337   
                   if (kind > 8)
 338   
                      kind = 8;
 339   
                   jjCheckNAddStates(25, 27);
 340   
                   break;
 341   
                default : break;
 342   
             }
 343   
          } while(i != startsAt);
 344   
       }
 345   
       else if (curChar < 128)
 346   
       {
 347   
          long l = 1L << (curChar & 077);
 348   
          MatchLoop: do
 349   
          {
 350   
             switch(jjstateSet[--i])
 351   
             {
 352   
                case 0:
 353   
                   if ((0x7fffffe87fffffeL & l) == 0L)
 354   
                      break;
 355   
                   if (kind > 6)
 356   
                      kind = 6;
 357   
                   jjCheckNAddStates(28, 33);
 358   
                   break;
 359   
                case 8:
 360   
                   jjCheckNAddStates(4, 6);
 361   
                   break;
 362   
                case 9:
 363   
                   if (curChar == 92)
 364   
                      jjstateSet[jjnewStateCnt++] = 10;
 365   
                   break;
 366   
                case 10:
 367   
                   if ((0x14400010000000L & l) != 0L)
 368   
                      jjCheckNAddStates(4, 6);
 369   
                   break;
 370   
                case 13:
 371   
                   jjAddStates(7, 9);
 372   
                   break;
 373   
                case 18:
 374   
                   if (curChar == 123)
 375   
                      jjstateSet[jjnewStateCnt++] = 19;
 376   
                   break;
 377   
                case 19:
 378   
                case 20:
 379   
                   if ((0x7fffffe87fffffeL & l) != 0L)
 380   
                      jjCheckNAddStates(10, 12);
 381   
                   break;
 382   
                case 22:
 383   
                case 23:
 384   
                   if ((0x7fffffe87fffffeL & l) != 0L)
 385   
                      jjCheckNAddStates(13, 15);
 386   
                   break;
 387   
                case 24:
 388   
                   if (curChar == 125 && kind > 11)
 389   
                      kind = 11;
 390   
                   break;
 391   
                case 27:
 392   
                   if ((0x7fffffe87fffffeL & l) == 0L)
 393   
                      break;
 394   
                   if (kind > 6)
 395   
                      kind = 6;
 396   
                   jjCheckNAdd(27);
 397   
                   break;
 398   
                case 28:
 399   
                   if ((0x7fffffe87fffffeL & l) == 0L)
 400   
                      break;
 401   
                   if (kind > 7)
 402   
                      kind = 7;
 403   
                   jjCheckNAddTwoStates(28, 29);
 404   
                   break;
 405   
                case 30:
 406   
                case 31:
 407   
                   if ((0x7fffffe87fffffeL & l) == 0L)
 408   
                      break;
 409   
                   if (kind > 7)
 410   
                      kind = 7;
 411   
                   jjCheckNAddTwoStates(29, 31);
 412   
                   break;
 413   
                case 32:
 414   
                   if ((0x7fffffe87fffffeL & l) == 0L)
 415   
                      break;
 416   
                   if (kind > 8)
 417   
                      kind = 8;
 418   
                   jjCheckNAddStates(16, 18);
 419   
                   break;
 420   
                case 34:
 421   
                case 35:
 422   
                   if ((0x7fffffe87fffffeL & l) == 0L)
 423   
                      break;
 424   
                   if (kind > 8)
 425   
                      kind = 8;
 426   
                   jjCheckNAddStates(19, 21);
 427   
                   break;
 428   
                case 37:
 429   
                case 38:
 430   
                   if ((0x7fffffe87fffffeL & l) == 0L)
 431   
                      break;
 432   
                   if (kind > 8)
 433   
                      kind = 8;
 434   
                   jjCheckNAddStates(22, 24);
 435   
                   break;
 436   
                case 40:
 437   
                case 41:
 438   
                   if ((0x7fffffe87fffffeL & l) == 0L)
 439   
                      break;
 440   
                   if (kind > 8)
 441   
                      kind = 8;
 442   
                   jjCheckNAddStates(25, 27);
 443   
                   break;
 444   
                default : break;
 445   
             }
 446   
          } while(i != startsAt);
 447   
       }
 448   
       else
 449   
       {
 450   
          int i2 = (curChar & 0xff) >> 6;
 451   
          long l2 = 1L << (curChar & 077);
 452   
          MatchLoop: do
 453   
          {
 454   
             switch(jjstateSet[--i])
 455   
             {
 456   
                case 8:
 457   
                   if ((jjbitVec0[i2] & l2) != 0L)
 458   
                      jjAddStates(4, 6);
 459   
                   break;
 460   
                case 13:
 461   
                   if ((jjbitVec0[i2] & l2) != 0L)
 462   
                      jjAddStates(7, 9);
 463   
                   break;
 464   
                default : break;
 465   
             }
 466   
          } while(i != startsAt);
 467   
       }
 468   
       if (kind != 0x7fffffff)
 469   
       {
 470   
          jjmatchedKind = kind;
 471   
          jjmatchedPos = curPos;
 472   
          kind = 0x7fffffff;
 473   
       }
 474   
       ++curPos;
 475   
       if ((i = jjnewStateCnt) == (startsAt = 42 - (jjnewStateCnt = startsAt)))
 476   
          return curPos;
 477   
       try { curChar = input_stream.readChar(); }
 478   
       catch(java.io.IOException e) { return curPos; }
 479   
    }
 480   
 }
 481   
 private final int jjMoveStringLiteralDfa0_2()
 482   
 {
 483   
    return jjMoveNfa_2(0, 0);
 484   
 }
 485   
 private final int jjMoveNfa_2(int startState, int curPos)
 486   
 {
 487   
    int[] nextStates;
 488   
    int startsAt = 0;
 489   
    jjnewStateCnt = 1;
 490   
    int i = 1;
 491   
    jjstateSet[0] = startState;
 492   
    int j, kind = 0x7fffffff;
 493   
    for (;;)
 494   
    {
 495   
       if (++jjround == 0x7fffffff)
 496   
          ReInitRounds();
 497   
       if (curChar < 64)
 498   
       {
 499   
          long l = 1L << curChar;
 500   
          MatchLoop: do
 501   
          {
 502   
             switch(jjstateSet[--i])
 503   
             {
 504   
                case 0:
 505   
                   if ((0x2400L & l) != 0L)
 506   
                      kind = 25;
 507   
                   break;
 508   
                default : break;
 509   
             }
 510   
          } while(i != startsAt);
 511   
       }
 512   
       else if (curChar < 128)
 513   
       {
 514   
          long l = 1L << (curChar & 077);
 515   
          MatchLoop: do
 516   
          {
 517   
             switch(jjstateSet[--i])
 518   
             {
 519   
                default : break;
 520   
             }
 521   
          } while(i != startsAt);
 522   
       }
 523   
       else
 524   
       {
 525   
          int i2 = (curChar & 0xff) >> 6;
 526   
          long l2 = 1L << (curChar & 077);
 527   
          MatchLoop: do
 528   
          {
 529   
             switch(jjstateSet[--i])
 530   
             {
 531   
                default : break;
 532   
             }
 533   
          } while(i != startsAt);
 534   
       }
 535   
       if (kind != 0x7fffffff)
 536   
       {
 537   
          jjmatchedKind = kind;
 538   
          jjmatchedPos = curPos;
 539   
          kind = 0x7fffffff;
 540   
       }
 541   
       ++curPos;
 542   
       if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
 543   
          return curPos;
 544   
       try { curChar = input_stream.readChar(); }
 545   
       catch(java.io.IOException e) { return curPos; }
 546   
    }
 547   
 }
 548   
 private final int jjMoveStringLiteralDfa0_1()
 549   
 {
 550   
    switch(curChar)
 551   
    {
 552   
       case 34:
 553   
          return jjStopAtPos(0, 24);
 554   
       default :
 555   
          return 1;
 556   
    }
 557   
 }
 558   
 static final int[] jjnextStates = {
 559   
    4, 5, 6, 1, 8, 9, 11, 13, 14, 16, 20, 21, 24, 21, 23, 24, 
 560   
    32, 33, 36, 33, 35, 36, 36, 38, 39, 36, 39, 41, 27, 28, 29, 32, 
 561   
    33, 36, 
 562   
 };
 563   
 public static final String[] jjstrLiteralImages = {
 564   
 "", null, null, null, null, null, null, null, null, null, null, null, null, 
 565   
 null, "\50", "\51", "\173", "\175", "\75", null, null, null, null, null, null, null, 
 566   
 null, null, null, };
 567   
 public static final String[] lexStateNames = {
 568   
    "DEFAULT", 
 569   
    "EXTRACTING_QUOTED_LITERAL", 
 570   
    "SINGLE_LINE_COMMENT", 
 571   
    "MULTILINE_COMMENT", 
 572   
 };
 573   
 public static final int[] jjnewLexState = {
 574   
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 3, 0, 
 575   
    0, -1, 0, -1, 
 576   
 };
 577   
 static final long[] jjtoToken = {
 578   
    0x7cfe1L, 
 579   
 };
 580   
 static final long[] jjtoSkip = {
 581   
    0x1fc0001eL, 
 582   
 };
 583   
 private SimpleCharStream input_stream;
 584   
 private final int[] jjrounds = new int[42];
 585   
 private final int[] jjstateSet = new int[84];
 586   
 protected char curChar;
 587   
 public SimpleDataLanguageParserTokenManager(SimpleCharStream stream)
 588   
 {
 589   
    if (SimpleCharStream.staticFlag)
 590   
       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
 591   
    input_stream = stream;
 592   
 }
 593   
 public SimpleDataLanguageParserTokenManager(SimpleCharStream stream, int lexState)
 594   
 {
 595   
    this(stream);
 596   
    SwitchTo(lexState);
 597   
 }
 598   
 public void ReInit(SimpleCharStream stream)
 599   
 {
 600   
    jjmatchedPos = jjnewStateCnt = 0;
 601   
    curLexState = defaultLexState;
 602   
    input_stream = stream;
 603   
    ReInitRounds();
 604   
 }
 605   
 private final void ReInitRounds()
 606   
 {
 607   
    int i;
 608   
    jjround = 0x80000001;
 609   
    for (i = 42; i-- > 0;)
 610   
       jjrounds[i] = 0x80000000;
 611   
 }
 612   
 public void ReInit(SimpleCharStream stream, int lexState)
 613   
 {
 614   
    ReInit(stream);
 615   
    SwitchTo(lexState);
 616   
 }
 617   
 public void SwitchTo(int lexState)
 618   
 {
 619   
    if (lexState >= 4 || lexState < 0)
 620   
       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
 621   
    else
 622   
       curLexState = lexState;
 623   
 }
 624   
 
 625   
 private final Token jjFillToken()
 626   
 {
 627   
    Token t = Token.newToken(jjmatchedKind);
 628   
    t.kind = jjmatchedKind;
 629   
    String im = jjstrLiteralImages[jjmatchedKind];
 630   
    t.image = (im == null) ? input_stream.GetImage() : im;
 631   
    t.beginLine = input_stream.getBeginLine();
 632   
    t.beginColumn = input_stream.getBeginColumn();
 633   
    t.endLine = input_stream.getEndLine();
 634   
    t.endColumn = input_stream.getEndColumn();
 635   
    return t;
 636   
 }
 637   
 
 638   
 int curLexState = 0;
 639   
 int defaultLexState = 0;
 640   
 int jjnewStateCnt;
 641   
 int jjround;
 642   
 int jjmatchedPos;
 643   
 int jjmatchedKind;
 644   
 
 645   
 public final Token getNextToken() 
 646   
 {
 647   
   int kind;
 648   
   Token specialToken = null;
 649   
   Token matchedToken;
 650   
   int curPos = 0;
 651   
 
 652   
   EOFLoop :
 653   
   for (;;)
 654   
   {   
 655   
    try   
 656   
    {     
 657   
       curChar = input_stream.BeginToken();
 658   
    }     
 659   
    catch(java.io.IOException e)
 660   
    {        
 661   
       jjmatchedKind = 0;
 662   
       matchedToken = jjFillToken();
 663   
       return matchedToken;
 664   
    }
 665   
 
 666   
    switch(curLexState)
 667   
    {
 668   
      case 0:
 669   
        try { input_stream.backup(0);
 670   
           while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
 671   
              curChar = input_stream.BeginToken();
 672   
        }
 673   
        catch (java.io.IOException e1) { continue EOFLoop; }
 674   
        jjmatchedKind = 0x7fffffff;
 675   
        jjmatchedPos = 0;
 676   
        curPos = jjMoveStringLiteralDfa0_0();
 677   
        break;
 678   
      case 1:
 679   
        jjmatchedKind = 0x7fffffff;
 680   
        jjmatchedPos = 0;
 681   
        curPos = jjMoveStringLiteralDfa0_1();
 682   
        break;
 683   
      case 2:
 684   
        jjmatchedKind = 0x7fffffff;
 685   
        jjmatchedPos = 0;
 686   
        curPos = jjMoveStringLiteralDfa0_2();
 687   
        if (jjmatchedPos == 0 && jjmatchedKind > 26)
 688   
        {
 689   
           jjmatchedKind = 26;
 690   
        }
 691   
        break;
 692   
      case 3:
 693   
        jjmatchedKind = 0x7fffffff;
 694   
        jjmatchedPos = 0;
 695   
        curPos = jjMoveStringLiteralDfa0_3();
 696   
        if (jjmatchedPos == 0 && jjmatchedKind > 28)
 697   
        {
 698   
           jjmatchedKind = 28;
 699   
        }
 700   
        break;
 701   
    }
 702   
      if (jjmatchedKind != 0x7fffffff)
 703   
      {
 704   
         if (jjmatchedPos + 1 < curPos)
 705   
            input_stream.backup(curPos - jjmatchedPos - 1);
 706   
         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 707   
         {
 708   
            matchedToken = jjFillToken();
 709   
        if (jjnewLexState[jjmatchedKind] != -1)
 710   
          curLexState = jjnewLexState[jjmatchedKind];
 711   
            return matchedToken;
 712   
         }
 713   
         else
 714   
         {
 715   
          if (jjnewLexState[jjmatchedKind] != -1)
 716   
            curLexState = jjnewLexState[jjmatchedKind];
 717   
            continue EOFLoop;
 718   
         }
 719   
      }
 720   
      int error_line = input_stream.getEndLine();
 721   
      int error_column = input_stream.getEndColumn();
 722   
      String error_after = null;
 723   
      boolean EOFSeen = false;
 724   
      try { input_stream.readChar(); input_stream.backup(1); }
 725   
      catch (java.io.IOException e1) {
 726   
         EOFSeen = true;
 727   
         error_after = curPos <= 1 ? "" : input_stream.GetImage();
 728   
         if (curChar == '\n' || curChar == '\r') {
 729   
            error_line++;
 730   
            error_column = 0;
 731   
         }
 732   
         else
 733   
            error_column++;
 734   
      }
 735   
      if (!EOFSeen) {
 736   
         input_stream.backup(1);
 737   
         error_after = curPos <= 1 ? "" : input_stream.GetImage();
 738   
      }
 739   
      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
 740   
   }
 741   
 }
 742   
 
 743   
 }
 744