htmlparsertokenmanager.java

天乙社区6.0是一套基于JAVA技术的网络虚拟社区

              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 > 26) {
                kind = 26;
              }
              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 jjMoveStringLiteralDfa0_1() {
    return jjMoveNfa_1(1, 0);
  }

  private final int jjMoveNfa_1(int startState, int curPos) {
    int[] nextStates;
    int startsAt = 0;
    jjnewStateCnt = 12;
    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 ( (0xafffffffffffffffL & l) != 0L) {
                if (kind > 13) {
                  kind = 13;
                }
                jjCheckNAdd(0);
              }
              else if ( (0x5000000000000000L & l) != 0L) {
                if (kind > 13) {
                  kind = 13;
                }
              }
              if (curChar == 60) {
                jjstateSet[jjnewStateCnt++] = 10;
              }
              break;
            case 0:
              if ( (0xafffffffffffffffL & l) == 0L) {
                break;
              }
              if (kind > 13) {
                kind = 13;
              }
              jjCheckNAdd(0);
              break;
            case 3:
              if ( (0xafffffffffffffffL & l) != 0L) {
                jjAddStates(19, 20);
              }
              break;
            case 4:
              if (curChar == 62 && kind > 14) {
                kind = 14;
              }
              break;
            case 10:
              if (curChar == 47) {
                jjstateSet[jjnewStateCnt++] = 9;
              }
              break;
            case 11:
              if (curChar == 60) {
                jjstateSet[jjnewStateCnt++] = 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 > 13) {
                kind = 13;
              }
              jjCheckNAdd(0);
              break;
            case 2:
              if (curChar == 116) {
                jjCheckNAddTwoStates(3, 4);
              }
              break;
            case 3:
              jjCheckNAddTwoStates(3, 4);
              break;
            case 5:
              if (curChar == 112) {
                jjstateSet[jjnewStateCnt++] = 2;
              }
              break;
            case 6:
              if (curChar == 105) {
                jjstateSet[jjnewStateCnt++] = 5;
              }
              break;
            case 7:
              if (curChar == 114) {
                jjstateSet[jjnewStateCnt++] = 6;
              }
              break;
            case 8:
              if (curChar == 99) {
                jjstateSet[jjnewStateCnt++] = 7;
              }
              break;
            case 9:
              if (curChar == 115) {
                jjstateSet[jjnewStateCnt++] = 8;
              }
              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 > 13) {
                kind = 13;
              }
              jjCheckNAdd(0);
              break;
            case 3:
              if ( (jjbitVec0[i2] & l2) != 0L) {
                jjAddStates(19, 20);
              }
              break;
            default:
              break;
          }
        }
        while (i != startsAt);
      }
      if (kind != 0x7fffffff) {
        jjmatchedKind = kind;
        jjmatchedPos = curPos;
        kind = 0x7fffffff;
      }
      ++curPos;
      if ( (i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt))) {
        return curPos;
      }
      try {
        curChar = input_stream.readChar();
      }
      catch (java.io.IOException e) {
        return curPos;
      }
    }
  }

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

  private final int jjStartNfa_2(int pos, long active0) {
    return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
  }

  private final int jjStartNfaWithStates_2(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_2(state, pos + 1);
  }

  private final int jjMoveStringLiteralDfa0_2() {
    switch (curChar) {
      case 34:
        return jjStopAtPos(0, 20);
      case 39:
        return jjStopAtPos(0, 19);
      case 61:
        return jjStartNfaWithStates_2(0, 16, 3);
      default:
        return jjMoveNfa_2(0, 0);
    }
  }

  private final int jjMoveNfa_2(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 > 15) {
                  kind = 15;
                }
                jjCheckNAdd(1);
              }
              else if ( (0x100002600L & l) != 0L) {
                if (kind > 21) {
                  kind = 21;
                }
                jjCheckNAdd(5);
              }
              else if (curChar == 61) {
                jjstateSet[jjnewStateCnt++] = 3;
              }
              else if (curChar == 62) {
                if (kind > 17) {
                  kind = 17;
                }
              }
              break;
            case 1:
              if ( (0x9ffffffeffffd9ffL & l) == 0L) {
                break;
              }
              if (kind > 15) {
                kind = 15;
              }
              jjCheckNAdd(1);
              break;
            case 2:
            case 3:
              if (curChar == 62 && kind > 17) {
                kind = 17;
              }
              break;
            case 4:
              if (curChar == 61) {
                jjstateSet[jjnewStateCnt++] = 3;
              }
              break;
            case 5:
              if ( (0x100002600L & l) == 0L) {
                break;
              }
              kind = 21;
              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 > 15) {
                kind = 15;
              }
              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 > 15) {
                kind = 15;
              }
              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, 3, 4,
  };
  public static final String[] jjstrLiteralImages = {
      "", "\74\163\143\162\151\160\164", null, null, "\74\41\55\55", "\74\41", null,
      null, 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",
      "WithinScript",
      "WithinTag",
      "AfterEquals",
      "WithinQuote1",
      "WithinQuote2",
      "WithinComment1",
      "WithinComment2",
  };
  public static final int[] jjnewLexState = {
      -1, 1, 2, 2, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 3, 0, 2, 4, 5,
      -1, -1, 2, -1,
      2, -1, 0, -1, 0,
  };
  static final long[] jjtoToken = {
      0x3fdff67fL,
  };
  static final long[] jjtoSkip = {
      0x200000L,
  };
  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 >= 8 || 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 > 12) {
            jjmatchedKind = 12;
          }
          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;
        case 7:
          jjmatchedKind = 0x7fffffff;
          jjmatchedPos = 0;
          curPos = jjMoveStringLiteralDfa0_7();
          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);
    }
  }

}