/* Generated By:JavaCC: Do not edit this line. DTDInitialParserTokenManager.java */
package org.exolab.castor.xml.dtd.parser;

public class DTDInitialParserTokenManager implements DTDInitialParserConstants {
  private final int jjMoveStringLiteralDfa0_0() {
    return jjMoveNfa_0(1, 0);
  }

  private final void jjCheckNAdd(int state) {
    if (jjrounds[state] != jjround) {
      jjstateSet[jjnewStateCnt++] = state;
      jjrounds[state] = jjround;
    }
  }

  private final void jjAddStates(int start, int end) {
    do {
      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
    } while (start++ != end);
  }

  private final void jjCheckNAddTwoStates(int state1, int state2) {
    jjCheckNAdd(state1);
    jjCheckNAdd(state2);
  }

  static final long[] jjbitVec0 = {0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL};
  static final long[] jjbitVec1 = {0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL};
  static final long[] jjbitVec3 = {0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL};
  static final long[] jjbitVec4 =
      {0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL};
  static final long[] jjbitVec5 = {0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L};
  static final long[] jjbitVec6 = {0x0L, 0x0L, 0xfffffffbffffd740L, 0xffffd547f7fffL};
  static final long[] jjbitVec7 =
      {0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff0003L, 0x33fcfffffff199fL};
  static final long[] jjbitVec8 =
      {0xfffe000000000000L, 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L};
  static final long[] jjbitVec9 =
      {0x7fffffe00000000L, 0xfffe0000000007feL, 0x7cffffffffffffffL, 0x60002f7fffL};
  static final long[] jjbitVec10 =
      {0x23ffffffffffffe0L, 0x3ff000000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L};
  static final long[] jjbitVec11 =
      {0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100000000L};
  static final long[] jjbitVec12 = {0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L};
  static final long[] jjbitVec13 =
      {0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L};
  static final long[] jjbitVec14 = {0x3fffdfffffddfe0L, 0x300000000L, 0x0L, 0x0L};
  static final long[] jjbitVec15 = {0xd7ffffffffffeL, 0x3fL, 0x200d6caefef02596L, 0x1fL};
  static final long[] jjbitVec16 = {0x0L, 0x3fffffffeffL, 0x0L, 0x0L};
  static final long[] jjbitVec17 = {0x0L, 0x0L, 0xffffffff00000000L, 0x7fffffffff003fL};
  static final long[] jjbitVec18 =
      {0x500000000007daedL, 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L};
  static final long[] jjbitVec19 =
      {0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL};
  static final long[] jjbitVec20 =
      {0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL};
  static final long[] jjbitVec21 = {0x4c4000000000L, 0x0L, 0x7L, 0x0L};
  static final long[] jjbitVec22 =
      {0x3fe00000080L, 0xfffffffffffffffeL, 0xfffffffe001fffffL, 0x7ffffffffffffffL};
  static final long[] jjbitVec23 = {0x1fffffffffe0L, 0x0L, 0x0L, 0x0L};
  static final long[] jjbitVec24 = {0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L};
  static final long[] jjbitVec25 = {0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L};
  static final long[] jjbitVec26 = {0x0L, 0x0L, 0x80000000000000L, 0xff7fffffff7fffffL};
  static final long[] jjbitVec27 = {0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x30003L};
  static final long[] jjbitVec28 =
      {0xffffffffffffffffL, 0x30000003fL, 0xfffffffbffffd7c0L, 0xffffd547f7fffL};
  static final long[] jjbitVec29 =
      {0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff007bL, 0x33fcfffffff199fL};
  static final long[] jjbitVec30 =
      {0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe007fL, 0x707ffffff0016L};
  static final long[] jjbitVec31 =
      {0x7fffffe00000000L, 0xffff03ff0007ffffL, 0x7cffffffffffffffL, 0x3ff3dffffef7fffL};
  static final long[] jjbitVec32 =
      {0xf3ffffffffffffeeL, 0xffcfff1e3fffL, 0xd3c5fdfffff99feeL, 0x3ffcfb080399fL};
  static final long[] jjbitVec33 =
      {0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100003bbfL};
  static final long[] jjbitVec34 =
      {0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L};
  static final long[] jjbitVec35 =
      {0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL};
  static final long[] jjbitVec36 = {0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x0L, 0x0L};
  static final long[] jjbitVec37 =
      {0x7ff7ffffffffffeL, 0x3ff7fffL, 0x3bff6caefef02596L, 0x3ff3f5fL};
  static final long[] jjbitVec38 =
      {0xc2a003ff03000000L, 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L};
  static final long[] jjbitVec39 = {0x0L, 0x0L, 0x0L, 0x21fff0000L};
  static final long[] jjbitVec40 =
      {0x3efffe000000a0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x77ffffffffffffffL};

  private final int jjMoveNfa_0(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 17;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;) {
      if (++jjround == 0x7fffffff)
        ReInitRounds();
      if (curChar < 64) {
        long l = 1L << curChar;
        MatchLoop: do {
          switch (jjstateSet[--i]) {
            case 1:
              if ((0xefffffdfffffffffL & l) != 0L) {
                if (kind > 8)
                  kind = 8;
                jjCheckNAdd(0);
              } else if ((0x1000002000000000L & l) != 0L) {
                if (kind > 8)
                  kind = 8;
              }
              if (curChar == 37)
                jjstateSet[jjnewStateCnt++] = 14;
              else if (curChar == 60)
                jjstateSet[jjnewStateCnt++] = 11;
              break;
            case 0:
              if ((0xefffffdfffffffffL & l) == 0L)
                break;
              if (kind > 8)
                kind = 8;
              jjCheckNAdd(0);
              break;
            case 3:
              if ((0x100002600L & l) != 0L)
                jjAddStates(0, 1);
              break;
            case 4:
              if (curChar == 37)
                jjCheckNAdd(5);
              break;
            case 5:
              if ((0x100002600L & l) == 0L)
                break;
              if (kind > 9)
                kind = 9;
              jjCheckNAdd(5);
              break;
            case 11:
              if (curChar == 33)
                jjstateSet[jjnewStateCnt++] = 10;
              break;
            case 12:
              if (curChar == 60)
                jjstateSet[jjnewStateCnt++] = 11;
              break;
            case 13:
              if (curChar == 37)
                jjstateSet[jjnewStateCnt++] = 14;
              break;
            case 14:
              if (curChar == 58)
                jjCheckNAddTwoStates(15, 16);
              break;
            case 15:
              if ((0x7ff600000000000L & l) != 0L)
                jjCheckNAddTwoStates(15, 16);
              break;
            case 16:
              if (curChar == 59 && kind > 10)
                kind = 10;
              break;
            default:
              break;
          }
        } while (i != startsAt);
      } else if (curChar < 128) {
        long l = 1L << (curChar & 077);
        MatchLoop: do {
          switch (jjstateSet[--i]) {
            case 1:
            case 0:
              if (kind > 8)
                kind = 8;
              jjCheckNAdd(0);
              break;
            case 2:
              if (curChar == 89)
                jjstateSet[jjnewStateCnt++] = 3;
              break;
            case 6:
              if (curChar == 84)
                jjstateSet[jjnewStateCnt++] = 2;
              break;
            case 7:
              if (curChar == 73)
                jjstateSet[jjnewStateCnt++] = 6;
              break;
            case 8:
              if (curChar == 84)
                jjstateSet[jjnewStateCnt++] = 7;
              break;
            case 9:
              if (curChar == 78)
                jjstateSet[jjnewStateCnt++] = 8;
              break;
            case 10:
              if (curChar == 69)
                jjstateSet[jjnewStateCnt++] = 9;
              break;
            case 14:
            case 15:
              if ((0x7fffffe87fffffeL & l) != 0L)
                jjCheckNAddTwoStates(15, 16);
              break;
            default:
              break;
          }
        } while (i != startsAt);
      } else {
        int i2 = (curChar & 0xff) >> 6;
        long l2 = 1L << (curChar & 077);
        MatchLoop: do {
          switch (jjstateSet[--i]) {
            case 1:
            case 0:
              if ((jjbitVec0[i2] & l2) == 0L)
                break;
              if (kind > 8)
                kind = 8;
              jjCheckNAdd(0);
              break;
            case 14:
              if ((jjbitVec3[i2] & l2) != 0L)
                jjCheckNAddTwoStates(15, 16);
              break;
            case 15:
              if ((jjbitVec26[i2] & l2) != 0L)
                jjCheckNAddTwoStates(15, 16);
              break;
            default:
              break;
          }
        } while (i != startsAt);
      }
      if (kind != 0x7fffffff) {
        jjmatchedKind = kind;
        jjmatchedPos = curPos;
        kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 17 - (jjnewStateCnt = startsAt)))
        return curPos;
      try {
        curChar = input_stream.readChar();
      } catch (java.io.IOException e) {
        return curPos;
      }
    }
  }

  private final int jjStopAtPos(int pos, int kind) {
    jjmatchedKind = kind;
    jjmatchedPos = pos;
    return pos + 1;
  }

  private final int jjMoveStringLiteralDfa0_2() {
    switch (curChar) {
      case 34:
        return jjStopAtPos(0, 18);
      default:
        return jjMoveNfa_2(1, 0);
    }
  }

  private final int jjMoveNfa_2(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 5;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;) {
      if (++jjround == 0x7fffffff)
        ReInitRounds();
      if (curChar < 64) {
        long l = 1L << curChar;
        MatchLoop: do {
          switch (jjstateSet[--i]) {
            case 1:
              if ((0xffffffdbffffffffL & l) != 0L) {
                if (kind > 16)
                  kind = 16;
                jjCheckNAdd(0);
              } else if (curChar == 37)
                jjstateSet[jjnewStateCnt++] = 2;
              break;
            case 0:
              if ((0xffffffdbffffffffL & l) == 0L)
                break;
              if (kind > 16)
                kind = 16;
              jjCheckNAdd(0);
              break;
            case 2:
              if (curChar == 58)
                jjCheckNAddTwoStates(3, 4);
              break;
            case 3:
              if ((0x7ff600000000000L & l) != 0L)
                jjCheckNAddTwoStates(3, 4);
              break;
            case 4:
              if (curChar == 59 && kind > 17)
                kind = 17;
              break;
            default:
              break;
          }
        } while (i != startsAt);
      } else if (curChar < 128) {
        long l = 1L << (curChar & 077);
        MatchLoop: do {
          switch (jjstateSet[--i]) {
            case 1:
            case 0:
              if (kind > 16)
                kind = 16;
              jjCheckNAdd(0);
              break;
            case 2:
            case 3:
              if ((0x7fffffe87fffffeL & l) != 0L)
                jjCheckNAddTwoStates(3, 4);
              break;
            default:
              break;
          }
        } while (i != startsAt);
      } else {
        int i2 = (curChar & 0xff) >> 6;
        long l2 = 1L << (curChar & 077);
        MatchLoop: do {
          switch (jjstateSet[--i]) {
            case 1:
            case 0:
              if ((jjbitVec0[i2] & l2) == 0L)
                break;
              if (kind > 16)
                kind = 16;
              jjCheckNAdd(0);
              break;
            case 2:
              if ((jjbitVec3[i2] & l2) != 0L)
                jjCheckNAddTwoStates(3, 4);
              break;
            case 3:
              if ((jjbitVec26[i2] & l2) != 0L)
                jjCheckNAddTwoStates(3, 4);
              break;
            default:
              break;
          }
        } while (i != startsAt);
      }
      if (kind != 0x7fffffff) {
        jjmatchedKind = kind;
        jjmatchedPos = curPos;
        kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
        return curPos;
      try {
        curChar = input_stream.readChar();
      } catch (java.io.IOException e) {
        return curPos;
      }
    }
  }

  private final int jjMoveStringLiteralDfa0_1() {
    switch (curChar) {
      case 34:
        return jjStopAtPos(0, 13);
      case 39:
        return jjStopAtPos(0, 14);
      case 62:
        return jjStopAtPos(0, 15);
      default:
        return jjMoveNfa_1(0, 0);
    }
  }

  private final int jjMoveNfa_1(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 3;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;) {
      if (++jjround == 0x7fffffff)
        ReInitRounds();
      if (curChar < 64) {
        long l = 1L << curChar;
        MatchLoop: do {
          switch (jjstateSet[--i]) {
            case 0:
              if ((0x100002600L & l) != 0L) {
                if (kind > 12)
                  kind = 12;
                jjCheckNAdd(2);
              } else if (curChar == 58) {
                if (kind > 11)
                  kind = 11;
                jjCheckNAdd(1);
              }
              break;
            case 1:
              if ((0x7ff600000000000L & l) == 0L)
                break;
              if (kind > 11)
                kind = 11;
              jjCheckNAdd(1);
              break;
            case 2:
              if ((0x100002600L & l) == 0L)
                break;
              kind = 12;
              jjCheckNAdd(2);
              break;
            default:
              break;
          }
        } while (i != startsAt);
      } else if (curChar < 128) {
        long l = 1L << (curChar & 077);
        MatchLoop: do {
          switch (jjstateSet[--i]) {
            case 0:
            case 1:
              if ((0x7fffffe87fffffeL & l) == 0L)
                break;
              if (kind > 11)
                kind = 11;
              jjCheckNAdd(1);
              break;
            default:
              break;
          }
        } while (i != startsAt);
      } else {
        int i2 = (curChar & 0xff) >> 6;
        long l2 = 1L << (curChar & 077);
        MatchLoop: do {
          switch (jjstateSet[--i]) {
            case 0:
              if ((jjbitVec3[i2] & l2) == 0L)
                break;
              if (kind > 11)
                kind = 11;
              jjCheckNAdd(1);
              break;
            case 1:
              if ((jjbitVec26[i2] & l2) == 0L)
                break;
              if (kind > 11)
                kind = 11;
              jjCheckNAdd(1);
              break;
            default:
              break;
          }
        } while (i != startsAt);
      }
      if (kind != 0x7fffffff) {
        jjmatchedKind = kind;
        jjmatchedPos = curPos;
        kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
        return curPos;
      try {
        curChar = input_stream.readChar();
      } catch (java.io.IOException e) {
        return curPos;
      }
    }
  }

  private final int jjMoveStringLiteralDfa0_3() {
    switch (curChar) {
      case 39:
        return jjStopAtPos(0, 21);
      default:
        return jjMoveNfa_3(1, 0);
    }
  }

  private final int jjMoveNfa_3(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 5;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;) {
      if (++jjround == 0x7fffffff)
        ReInitRounds();
      if (curChar < 64) {
        long l = 1L << curChar;
        MatchLoop: do {
          switch (jjstateSet[--i]) {
            case 1:
              if ((0xffffff5fffffffffL & l) != 0L) {
                if (kind > 19)
                  kind = 19;
                jjCheckNAdd(0);
              } else if (curChar == 37)
                jjstateSet[jjnewStateCnt++] = 2;
              break;
            case 0:
              if ((0xffffff5fffffffffL & l) == 0L)
                break;
              if (kind > 19)
                kind = 19;
              jjCheckNAdd(0);
              break;
            case 2:
              if (curChar == 58)
                jjCheckNAddTwoStates(3, 4);
              break;
            case 3:
              if ((0x7ff600000000000L & l) != 0L)
                jjCheckNAddTwoStates(3, 4);
              break;
            case 4:
              if (curChar == 59 && kind > 20)
                kind = 20;
              break;
            default:
              break;
          }
        } while (i != startsAt);
      } else if (curChar < 128) {
        long l = 1L << (curChar & 077);
        MatchLoop: do {
          switch (jjstateSet[--i]) {
            case 1:
            case 0:
              if (kind > 19)
                kind = 19;
              jjCheckNAdd(0);
              break;
            case 2:
            case 3:
              if ((0x7fffffe87fffffeL & l) != 0L)
                jjCheckNAddTwoStates(3, 4);
              break;
            default:
              break;
          }
        } while (i != startsAt);
      } else {
        int i2 = (curChar & 0xff) >> 6;
        long l2 = 1L << (curChar & 077);
        MatchLoop: do {
          switch (jjstateSet[--i]) {
            case 1:
            case 0:
              if ((jjbitVec0[i2] & l2) == 0L)
                break;
              if (kind > 19)
                kind = 19;
              jjCheckNAdd(0);
              break;
            case 2:
              if ((jjbitVec3[i2] & l2) != 0L)
                jjCheckNAddTwoStates(3, 4);
              break;
            case 3:
              if ((jjbitVec26[i2] & l2) != 0L)
                jjCheckNAddTwoStates(3, 4);
              break;
            default:
              break;
          }
        } while (i != startsAt);
      }
      if (kind != 0x7fffffff) {
        jjmatchedKind = kind;
        jjmatchedPos = curPos;
        kind = 0x7fffffff;
      }
      ++curPos;
      if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
        return curPos;
      try {
        curChar = input_stream.readChar();
      } catch (java.io.IOException e) {
        return curPos;
      }
    }
  }

  static final int[] jjnextStates = {3, 4,};
  public static final String[] jjstrLiteralImages = {"", null, null, null, null, null, null, null,
      null, null, null, null, null, "\42", "\47", "\76", null, null, "\42", null, null, "\47",};
  public static final String[] lexStateNames =
      {"DEFAULT", "WithinPEdecl", "WithinEntityValueDQ", "WithinEntityValueSQ",};
  public static final int[] jjnewLexState =
      {-1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 2, 3, 0, -1, -1, 1, -1, -1, 1,};
  private CharStream input_stream;
  private final int[] jjrounds = new int[17];
  private final int[] jjstateSet = new int[34];
  protected char curChar;

  public DTDInitialParserTokenManager(CharStream stream) {
    input_stream = stream;
  }

  public DTDInitialParserTokenManager(CharStream stream, int lexState) {
    this(stream);
    SwitchTo(lexState);
  }

  public void ReInit(CharStream stream) {
    jjmatchedPos = jjnewStateCnt = 0;
    curLexState = defaultLexState;
    input_stream = stream;
    ReInitRounds();
  }

  private final void ReInitRounds() {
    int i;
    jjround = 0x80000001;
    for (i = 17; i-- > 0;)
      jjrounds[i] = 0x80000000;
  }

  public void ReInit(CharStream stream, int lexState) {
    ReInit(stream);
    SwitchTo(lexState);
  }

  public void SwitchTo(int lexState) {
    if (lexState >= 4 || lexState < 0) {
      throw new TokenMgrError(
          "Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.",
          TokenMgrError.INVALID_LEXICAL_STATE);
    }
    curLexState = lexState;
  }

  private final Token jjFillToken() {
    Token t = Token.newToken(jjmatchedKind);
    t.kind = jjmatchedKind;
    String im = jjstrLiteralImages[jjmatchedKind];
    t.image = (im == null) ? input_stream.GetImage() : im;
    t.beginLine = input_stream.getBeginLine();
    t.beginColumn = input_stream.getBeginColumn();
    t.endLine = input_stream.getEndLine();
    t.endColumn = input_stream.getEndColumn();
    return t;
  }

  int curLexState = 0;
  int defaultLexState = 0;
  int jjnewStateCnt;
  int jjround;
  int jjmatchedPos;
  int jjmatchedKind;

  public final Token getNextToken() {
    Token matchedToken;
    int curPos = 0;

    EOFLoop: for (;;) {
      try {
        curChar = input_stream.BeginToken();
      } catch (java.io.IOException e) {
        jjmatchedKind = 0;
        matchedToken = jjFillToken();
        return matchedToken;
      }

      switch (curLexState) {
        case 0:
          jjmatchedKind = 0x7fffffff;
          jjmatchedPos = 0;
          curPos = jjMoveStringLiteralDfa0_0();
          break;
        case 1:
          jjmatchedKind = 0x7fffffff;
          jjmatchedPos = 0;
          curPos = jjMoveStringLiteralDfa0_1();
          break;
        case 2:
          jjmatchedKind = 0x7fffffff;
          jjmatchedPos = 0;
          curPos = jjMoveStringLiteralDfa0_2();
          break;
        case 3:
          jjmatchedKind = 0x7fffffff;
          jjmatchedPos = 0;
          curPos = jjMoveStringLiteralDfa0_3();
          break;
      }
      if (jjmatchedKind != 0x7fffffff) {
        if (jjmatchedPos + 1 < curPos)
          input_stream.backup(curPos - jjmatchedPos - 1);
        matchedToken = jjFillToken();
        if (jjnewLexState[jjmatchedKind] != -1)
          curLexState = jjnewLexState[jjmatchedKind];
        return matchedToken;
      }
      int error_line = input_stream.getEndLine();
      int error_column = input_stream.getEndColumn();
      String error_after = null;
      boolean EOFSeen = false;
      try {
        input_stream.readChar();
        input_stream.backup(1);
      } catch (java.io.IOException e1) {
        EOFSeen = true;
        error_after = curPos <= 1 ? "" : input_stream.GetImage();
        if (curChar == '\n' || curChar == '\r') {
          error_line++;
          error_column = 0;
        } else
          error_column++;
      }
      if (!EOFSeen) {
        input_stream.backup(1);
        error_after = curPos <= 1 ? "" : input_stream.GetImage();
      }
      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar,
          TokenMgrError.LEXICAL_ERROR);
    }
  }

}
