htmlparsertokenmanager.java

天乙代码src_531.rar 天乙代码src_531.rar 天乙代码src_531.rar 天乙代码src_531.rar

    }
    switch (curChar) {
      case 45:
        return jjMoveStringLiteralDfa2_5(active0, 0x1000000L);
      default:
        break;
    }
    return jjStartNfa_5(0, active0);
  }

  private final int jjMoveStringLiteralDfa2_5(long old0, long active0) {
    if ( ( (active0 &= old0)) == 0L) {
      return jjStartNfa_5(0, old0);
    }
    try {
      curChar = input_stream.readChar();
    }
    catch (java.io.IOException e) {
      jjStopStringLiteralDfa_5(1, active0);
      return 2;
    }
    switch (curChar) {
      case 62:
        if ( (active0 & 0x1000000L) != 0L) {
          return jjStopAtPos(2, 24);
        }
        break;
      default:
        break;
    }
    return jjStartNfa_5(1, active0);
  }

  private final int jjMoveNfa_5(int startState, int curPos) {
    int[] nextStates;
    int startsAt = 0;
    jjnewStateCnt = 2;
    int i = 1;
    jjstateSet[0] = startState;
    int j, kind = 0x7fffffff;
    for (; ; ) {
      if (++jjround == 0x7fffffff) {
        ReInitRounds();
      }
      if (curChar < 64) {
        long l = 1L << curChar;
        MatchLoop:do {
          switch (jjstateSet[--i]) {
            case 1:
              if ( (0xffffdfffffffffffL & l) != 0L) {
                if (kind > 23) {
                  kind = 23;
                }
                jjCheckNAdd(0);
              }
              else if (curChar == 45) {
                if (kind > 23) {
                  kind = 23;
                }
              }
              break;
            case 0:
              if ( (0xffffdfffffffffffL & l) == 0L) {
                break;
              }
              kind = 23;
              jjCheckNAdd(0);
              break;
            default:
              break;
          }
        }
        while (i != startsAt);
      }
      else if (curChar < 128) {
        long l = 1L << (curChar & 077);
        MatchLoop:do {
          switch (jjstateSet[--i]) {
            case 1:
            case 0:
              kind = 23;
              jjCheckNAdd(0);
              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 > 23) {
                kind = 23;
              }
              jjCheckNAdd(0);
              break;
            default:
              break;
          }
        }
        while (i != startsAt);
      }
      if (kind != 0x7fffffff) {
        jjmatchedKind = kind;
        jjmatchedPos = curPos;
        kind = 0x7fffffff;
      }
      ++curPos;
      if ( (i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt))) {
        return curPos;
      }
      try {
        curChar = input_stream.readChar();
      }
      catch (java.io.IOException e) {
        return curPos;
      }
    }
  }

  private final int jjStopStringLiteralDfa_1(int pos, long active0) {
    switch (pos) {
      default:
        return -1;
    }
  }

  private final int jjStartNfa_1(int pos, long active0) {
    return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
  }

  private final int jjStartNfaWithStates_1(int pos, int kind, int state) {
    jjmatchedKind = kind;
    jjmatchedPos = pos;
    try {
      curChar = input_stream.readChar();
    }
    catch (java.io.IOException e) {
      return pos + 1;
    }
    return jjMoveNfa_1(state, pos + 1);
  }

  private final int jjMoveStringLiteralDfa0_1() {
    switch (curChar) {
      case 34:
        return jjStopAtPos(0, 17);
      case 39:
        return jjStopAtPos(0, 16);
      case 61:
        return jjStartNfaWithStates_1(0, 13, 3);
      default:
        return jjMoveNfa_1(0, 0);
    }
  }

  private final int jjMoveNfa_1(int startState, int curPos) {
    int[] nextStates;
    int startsAt = 0;
    jjnewStateCnt = 6;
    int i = 1;
    jjstateSet[0] = startState;
    int j, kind = 0x7fffffff;
    for (; ; ) {
      if (++jjround == 0x7fffffff) {
        ReInitRounds();
      }
      if (curChar < 64) {
        long l = 1L << curChar;
        MatchLoop:do {
          switch (jjstateSet[--i]) {
            case 0:
              if ( (0x9fffff7affffd9ffL & l) != 0L) {
                if (kind > 12) {
                  kind = 12;
                }
                jjCheckNAdd(1);
              }
              else if ( (0x100002600L & l) != 0L) {
                if (kind > 18) {
                  kind = 18;
                }
                jjCheckNAdd(5);
              }
              else if (curChar == 61) {
                jjstateSet[jjnewStateCnt++] = 3;
              }
              else if (curChar == 62) {
                if (kind > 14) {
                  kind = 14;
                }
              }
              break;
            case 1:
              if ( (0x9ffffffeffffd9ffL & l) == 0L) {
                break;
              }
              if (kind > 12) {
                kind = 12;
              }
              jjCheckNAdd(1);
              break;
            case 2:
            case 3:
              if (curChar == 62 && kind > 14) {
                kind = 14;
              }
              break;
            case 4:
              if (curChar == 61) {
                jjstateSet[jjnewStateCnt++] = 3;
              }
              break;
            case 5:
              if ( (0x100002600L & l) == 0L) {
                break;
              }
              kind = 18;
              jjCheckNAdd(5);
              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 (kind > 12) {
                kind = 12;
              }
              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:
            case 1:
              if ( (jjbitVec0[i2] & l2) == 0L) {
                break;
              }
              if (kind > 12) {
                kind = 12;
              }
              jjCheckNAdd(1);
              break;
            default:
              break;
          }
        }
        while (i != startsAt);
      }
      if (kind != 0x7fffffff) {
        jjmatchedKind = kind;
        jjmatchedPos = curPos;
        kind = 0x7fffffff;
      }
      ++curPos;
      if ( (i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt))) {
        return curPos;
      }
      try {
        curChar = input_stream.readChar();
      }
      catch (java.io.IOException e) {
        return curPos;
      }
    }
  }

  static final int[] jjnextStates = {
      17, 18, 21, 12, 14, 5, 8, 0, 4, 6, 0, 4, 6, 5, 0, 4,
      6, 12, 13,
  };
  public static final String[] jjstrLiteralImages = {
      "", null, null, "\74\41\55\55", "\74\41", null, null, null, null, null, null,
      null, null, "\75", null, null, "\47", "\42", null, null, null, null, null, null,
      "\55\55\76", null, "\76", };
  public static final String[] lexStateNames = {
      "DEFAULT",
      "WithinTag",
      "AfterEquals",
      "WithinQuote1",
      "WithinQuote2",
      "WithinComment1",
      "WithinComment2",
  };
  public static final int[] jjnewLexState = {
      -1, 1, 1, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, 2, 0, 1, 3, 4, -1, -1, 1,
      -1, 1, -1, 0,
      -1, 0,
  };
  static final long[] jjtoToken = {
      0x7fbfb3fL,
  };
  static final long[] jjtoSkip = {
      0x40000L,
  };
  protected SimpleCharStream input_stream;
  private final int[] jjrounds = new int[25];
  private final int[] jjstateSet = new int[50];
  protected char curChar;
  public HTMLParserTokenManager(SimpleCharStream stream) {
    if (SimpleCharStream.staticFlag) {
      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
    }
    input_stream = stream;
  }

  public HTMLParserTokenManager(SimpleCharStream stream, int lexState) {
    this(stream);
    SwitchTo(lexState);
  }

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

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

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

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

  protected 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 Token getNextToken() {
    int kind;
    Token specialToken = null;
    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();
          if (jjmatchedPos == 0 && jjmatchedKind > 11) {
            jjmatchedKind = 11;
          }
          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;
        case 4:
          jjmatchedKind = 0x7fffffff;
          jjmatchedPos = 0;
          curPos = jjMoveStringLiteralDfa0_4();
          break;
        case 5:
          jjmatchedKind = 0x7fffffff;
          jjmatchedPos = 0;
          curPos = jjMoveStringLiteralDfa0_5();
          break;
        case 6:
          jjmatchedKind = 0x7fffffff;
          jjmatchedPos = 0;
          curPos = jjMoveStringLiteralDfa0_6();
          break;
      }
      if (jjmatchedKind != 0x7fffffff) {
        if (jjmatchedPos + 1 < curPos) {
          input_stream.backup(curPos - jjmatchedPos - 1);
        }
        if ( (jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) !=
            0L) {
          matchedToken = jjFillToken();
          if (jjnewLexState[jjmatchedKind] != -1) {
            curLexState = jjnewLexState[jjmatchedKind];
          }
          return matchedToken;
        }
        else {
          if (jjnewLexState[jjmatchedKind] != -1) {
            curLexState = jjnewLexState[jjmatchedKind];
          }
          continue EOFLoop;
        }
      }
      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);
    }
  }

}