Java 类org.eclipse.jface.text.rules.ICharacterScanner 实例源码

boolean cleanupAndReturn(ICharacterScanner scanner, boolean result){
    if (result){
        return true; // do not clean up - pos is as wanted
    }
    if (count==0){
        return result;
    }
    if (count>0){
        while(count!=0){
            scanner.unread();
            count--;
        }
    }else{
        while(count!=0){
            scanner.read();
            count++;
        }
    }
    return false;
}

@Override
public IToken evaluate(ICharacterScanner scanner1, boolean resume) {
    if (!(scanner1 instanceof BatchDocumentPartitionScanner)){
        return Token.UNDEFINED;
    }
    BatchDocumentPartitionScanner scanner = (BatchDocumentPartitionScanner)scanner1;
    if (scanner.getOffset()<ECHO.length()){
        /* would be a problem on start on going back...*/
        return Token.UNDEFINED;
    }
    scanner.unread(); // go to character before
    int charBeforeAsInt = scanner.read(); // get character, moves to origin pos again
    /* fast guard closing:*/
    if (charBeforeAsInt!='o' && charBeforeAsInt!='O'){ // echo ECHO <- last character must be an o other wise guard close...
        return Token.UNDEFINED;
    }
    ICharacterScannerCodePosSupport codePosSupport = new ICharacterScannerCodePosSupport(scanner);
    if (parserSupport.isAfterEchoHandled(codePosSupport)){
        return getSuccessToken();
    }
    codePosSupport.resetToStartPos();
    return Token.UNDEFINED;
}

boolean cleanupAndReturn(ICharacterScanner scanner, boolean result){
    if (result){
        return true; // do not clean up - pos is as wanted
    }
    if (count==0){
        return result;
    }
    if (count>0){
        while(count!=0){
            scanner.unread();
            count--;
        }
    }else{
        while(count!=0){
            scanner.read();
            count++;
        }
    }
    return false;
}

@Override
public IToken evaluate(ICharacterScanner scanner, boolean resume) {
    int r = scanner.read();
    scanner.unread();
    /* fast guard closing:*/
    if (ICharacterScanner.EOF==r || r!='<'){
        return Token.UNDEFINED;
    }

    ICharacterScannerCodePosSupport codePosSupport = new ICharacterScannerCodePosSupport(scanner);
    if (hereStringSupport.isHereStringStateHandled(codePosSupport)){
        return getSuccessToken();
    }
    codePosSupport.resetToStartPos();
    return Token.UNDEFINED;
}

@Override
public IToken evaluate(ICharacterScanner scanner, boolean resume) {
    int r = scanner.read();
    scanner.unread();
    /* fast guard closing:*/
    if (ICharacterScanner.EOF==r || r!='<'){
        return Token.UNDEFINED;
    }

    ICharacterScannerCodePosSupport codePosSupport = new ICharacterScannerCodePosSupport(scanner);
    if (hereDocSupport.isHereDocStateHandled(codePosSupport)){
        return getSuccessToken();
    }
    codePosSupport.resetToStartPos();
    return Token.UNDEFINED;
}

@Override
protected IToken doEvaluate(final ICharacterScanner scanner, final boolean resume) {

  if (resume) {
    if (this.endSequenceDetected(scanner)) {
      return this.fToken;
    }
  } else {
    final int c = scanner.read();
    if (c == this.fStartSequence[0]) {
      if (this.sequenceDetected(scanner, this.fStartSequence, false)) {
        if (this.endSequenceDetected(scanner)) {
          return this.fToken;
        }
      }
    }
  }

  scanner.unread();
  return Token.UNDEFINED;
}

private boolean isList(ICharacterScanner scanner) {
    int n = scanner.read();
    if (isEol(n)) return false;                 // blank line

    if (n == '-' || n == '+' || n == '*') {
        // Log.error("List mark at " + getOffset(scanner));
        if (spaceFollows(scanner)) {            // skip unordered lists
            // Log.error("List item at " + getOffset(scanner));
            gotoBOL(scanner);                   // align, then consume the list
            gotoEOB(scanner);
            return true;
        }
        return false;
    }
    if (Character.isDigit(n)) {
        // Log.error("Digit mark at " + getOffset(scanner));
        if (isDigitSeq(scanner)) {      // skip ordered lists
            // Log.error("Digit item at " + getOffset(scanner));
            gotoBOL(scanner);           // align, then consume the list
            gotoEOB(scanner);
            return true;
        }
    }
    return false;
}

private boolean cleanupAndReturn(ICharacterScanner scanner, boolean result){
    if (result){
        return true; // do not clean up - pos is as wanted
    }
    if (count==0){
        return result;
    }
    if (count>0){
        while(count!=0){
            scanner.unread();
            count--;
        }
    }else{
        while(count!=0){
            scanner.read();
            count++;
        }
    }
    return false;
}

public IToken evaluate( ICharacterScanner scanner){

      buffer.setLength(0);

      int c = read(scanner);
      if (c == '&') {

         int i = 0;
         do {
            c = read(scanner);
            i++;

            if (c == '<' || c == ']') {
               for (int j = i - 1; j > 0; j--)
                  scanner.unread();
               return Token.UNDEFINED;
            }
         } while (c != ';');
         return fToken;
      }

      scanner.unread();
      return Token.UNDEFINED;
   }

public IToken evaluate( ICharacterScanner scanner){

      buffer.setLength(0);

      charsRead = 0;
      int c = read(scanner);

      if (c == matchString.charAt(0)) {
         do {
            c = read(scanner);
         } while (isOK((char) c));

         if (charsRead == matchString.length()) {
            return fToken;
         } else {
            rewind(scanner);
            return Token.UNDEFINED;
         }

      }

      scanner.unread();
      return Token.UNDEFINED;
   }

protected boolean sequenceDetected( ICharacterScanner scanner, char[] sequence, boolean eofAllowed){
   int c = scanner.read();
   if (sequence[0] == '<') {
      if (c == '?') {
         // processing instruction - abort
         scanner.unread();
         return false;
      }
      if (c == '!') {
         scanner.unread();
         // comment - abort
         return false;
      }
   } else if (sequence[0] == '>') {
      scanner.unread();
   }
   return super.sequenceDetected(scanner, sequence, eofAllowed);
}

/**
 * Does the actual evaluation of the stream.
 * 
 * @param scanner The scanner
 * @param count The initial count of {
 * @return <code>fToken</code> on success, <code>Token.UNDEFINED</code> if
 * the match doesn't succeed
 */
private IToken doEvaluate(ICharacterScanner scanner, int count) {
    boolean inString = false;
    int c = scanner.read();

    if (((char) c) == '{') {
        do {
            c = scanner.read();
            if (((char) c) == '{' && !inString)
                count++;
            else if (((char) c) == '}' && !inString)
                count--;
            else if (((char) c) == '"' && !inString)
                inString = true;
            else if (((char) c) == '"' && inString)
                inString = false;
            else if (c == ICharacterScanner.EOF)
                return Token.UNDEFINED;
        } while (count > 0);
        return fToken;
    }
    scanner.unread();
    return Token.UNDEFINED;
}

public IToken evaluate(ICharacterScanner scanner) {

        buffer.setLength(0);

        int c = read(scanner);
        if (c == '&') {

            int i = 0;
            do {
                c = read(scanner);
                i++;

                if (c == '<' || c == ']') {
                    for (int j = i - 1; j > 0; j--)
                        scanner.unread();
                    return Token.UNDEFINED;
                }
            } while (c != ';');
            return fToken;
        }

        scanner.unread();
        return Token.UNDEFINED;
    }

public IToken evaluate(ICharacterScanner scanner) {

        buffer.setLength(0);

        charsRead = 0;
        int c = read(scanner);

        if (c == matchString.charAt(0)) {
            do {
                c = read(scanner);
            } while (isOK((char) c));

            if (charsRead == matchString.length()) {
                return fToken;
            } else {
                rewind(scanner);
                return Token.UNDEFINED;
            }

        }

        scanner.unread();
        return Token.UNDEFINED;
    }

@Override
public IToken evaluate(ICharacterScanner scanner) {
    found = false;

    int c = scanner.read();
    scanner.unread();
    if (isHws(c)) {
        int col = scanner.getColumn();
        if (col == 1) {
            scanner.unread();
            int p = scanner.read();
            if (p == '\n') col = 0;
        }
        if (col == 0) {
            tabWidth = FluentMkUI.getDefault().getPreferenceStore().getInt(Prefs.EDITOR_TAB_WIDTH);
            if (tabWidth < 2) tabWidth = 4;
            line = 0;
            while (evaluateLine(scanner)) {
                found = true;
                line++;
            }
        }
    }
    if (found) return token;
    return Token.UNDEFINED;
}

protected boolean sequenceDetected(ICharacterScanner scanner,
        char[] sequence, boolean eofAllowed) {
    int c = scanner.read();
    if (sequence[0] == '<') {
        if (c == '?') {
            // processing instruction - abort
            scanner.unread();
            return false;
        }
        if (c == '!') {
            scanner.unread();
            // comment - abort
            return false;
        }
        if (c == '/') {
            // end tag
            scanner.unread();
            return false;
        }
    } else if (sequence[0] == '>') {
        scanner.unread();
    }
    return super.sequenceDetected(scanner, sequence, eofAllowed);
}

private boolean gotoEOL(ICharacterScanner scanner, boolean consumeEOL) {
    boolean blank = true;
    int b = scanner.read();
    while (!isEol(b)) {
        blank = blank && Character.isWhitespace(b);
        b = scanner.read();
    }
    if (b == ICharacterScanner.EOF) scanner.unread();
    if (consumeEOL) {
        b = scanner.read();
        if (b == '\r') {
            b = scanner.read();
        }
        if (b == ICharacterScanner.EOF) scanner.unread();
    }
    return blank;
}

@Override
public IToken evaluate(ICharacterScanner scanner) {
    int c = scanner.read();
    if (c != ICharacterScanner.EOF && 0 == scanner.getColumn() - 1) {
        try {
            if (dotStarts(scanner, c)) {
                gotoEOB(scanner, c);
                return getSuccessToken();
            }
        } catch (BadLocationException e) {
            Log.error("DotCodeRule", e);
        }
    }

    scanner.unread();
    return Token.UNDEFINED;
}

private boolean gotoEOL(ICharacterScanner scanner, boolean consumeEOL) {
    int b = scanner.read();
    scanner.unread();
    while (!isEol(b)) {
        b = scanner.read();
    }
    if (b == ICharacterScanner.EOF) {
        scanner.unread();
        return false;
    }
    if (consumeEOL) {
        b = scanner.read();
        if (b == '\r') {
            b = scanner.read();
        }
        if (b == ICharacterScanner.EOF) {
            scanner.unread();
            return false;
        }
    }
    return true;
}

@Override
public IToken evaluate(ICharacterScanner scanner) {
    int col = scanner.getColumn();
    if (col == 1) {
        scanner.unread();
        int p = scanner.read();
        if (p == '\n') col = 0;
    }

    try {
        if (col == 0) {
            String text = getScanText(scanner);
            if (tagStarts(text)) {
                gotoEOB(scanner);
                return getSuccessToken();
            }
        }
    } catch (BadLocationException e) {
        Log.error("HtmlCodeRule", e);
    }
    return Token.UNDEFINED;
}

private boolean gotoEOL(ICharacterScanner scanner, boolean consumeEOL) {
    boolean blank = true;
    int b = scanner.read();
    while (!isEol(b)) {
        blank = blank && Character.isWhitespace(b);
        b = scanner.read();
    }
    if (b == ICharacterScanner.EOF) scanner.unread();
    if (consumeEOL) {
        b = scanner.read();
        if (b == '\r') {
            b = scanner.read();
        }
        if (b == ICharacterScanner.EOF) scanner.unread();
    }
    return blank;
}

@Override
public IToken evaluate(ICharacterScanner scanner, boolean resume) {
    if (fColumn == UNDEFINED) return doEvaluate(scanner, resume);

    int c = scanner.read();
    scanner.unread();
    if (c == fStartSequence[0]) {
        int col = scanner.getColumn();
        if (col == 1) {
            scanner.unread();
            int p = scanner.read();
            if (p == '\n') col = 0;
        }
        return (fColumn == col ? doEvaluate(scanner, resume) : Token.UNDEFINED);
    }
    return Token.UNDEFINED;
}

private boolean sequenceDetected(ICharacterScanner scanner, char[] sequence, boolean forward, boolean eofAllowed) {
    int c = scanner.read();
    if (c == ICharacterScanner.EOF) {
        if (forward) return false;
        return eofAllowed ? true : false;
    }
    scanner.unread();

    try {
        String txt = getScanText(scanner, 6, forward);
        String regex = String.valueOf(sequence);
        if (forward && txt.matches(regex + ".*")) {
            return true;
        }
        if (!forward && txt.matches(".*" + regex)) {
            return true;
        }
    } catch (BadLocationException e) {}
    return false;
}

private String getScanText(ICharacterScanner scanner, int max, boolean forward) throws BadLocationException {
    IScannerExt scan = ((IScannerExt) scanner);
    IDocument doc = scan.getDocument();
    int beg;
    int end;
    int len;
    if (forward) {
        beg = scan.getOffset();
        end = scan.getRangeEnd();
        len = Math.min(max, end - beg);
    } else {
        end = scan.getOffset() + 1;
        beg = Math.max(0, end - max);
        len = end - beg;
    }
    return doc.get(beg, len);
}

private int scannerRead(ICharacterScanner scanner, Counter counter) {
    int c = scanner.read();
    if (c==ICharacterScanner.EOF){
        return c;
    }
    counter.count++;
    if (trace){
        traceSb.append((char)c);
    }
    return c;

}

private void scannerUnread(ICharacterScanner scanner, Counter counter) {
    scanner.unread();
    counter.count--;
    if (trace){
        int length = traceSb.length();
        if (length<1){
            traceSb.append("[(-1)]");
        }else{
            length=length-1;
            traceSb.setLength(length);
        }
    }
}

public ICharacterScannerCodePosSupport(ICharacterScanner scanner){
    this.scanner=scanner;
    this.counter=new Counter();
    // startPos start will always be 0. this is okay, here, because no tokens will be created so the information can start from 0 and
    // is okay. also an ICharacterScanner does not support real startPos handling but only forward and backward
    this.startPos=0;
    this.pos=-1;
}

@Override
public Character getCharacterAtPosOrNull(int pos) {
    moveToPos(pos);
    if (lastReadValue == ICharacterScanner.EOF){
        return null;
    }
    char lastCharacter = (char)lastReadValue;
    return Character.valueOf(lastCharacter);
}

protected IToken doEvaluate(ICharacterScanner scanner, boolean resume) {

        if (resume) {

            if (endSequenceDetected(scanner))
                return fToken;

        } else {
            int c= scanner.read();
            if (c == fStartSequence[0]) {
                scanner.unread();
                scanner.unread();
                int before = scanner.read();

                if (before=='\\'){
                    return Token.UNDEFINED;
                }
                scanner.read();

                if (sequenceDetected(scanner, fStartSequence, false)) {
                    if (endSequenceDetected(scanner))
                        return fToken;
                }
            }
        }

        scanner.unread();
        return Token.UNDEFINED;
    }

private int scannerRead(ICharacterScanner scanner, Counter counter) {
    int c = scanner.read();
    if (c==ICharacterScanner.EOF){
        return c;
    }
    counter.count++;
    if (trace){
        traceSb.append((char)c);
    }
    return c;

}

private void scannerUnread(ICharacterScanner scanner, Counter counter) {
    scanner.unread();
    counter.count--;
    if (trace){
        int length = traceSb.length();
        if (length<1){
            traceSb.append("[(-1)]");
        }else{
            length=length-1;
            traceSb.setLength(length);
        }
    }
}

@Override
public IToken evaluate(ICharacterScanner scanner, boolean resume) {
    char start = (char) scanner.read();
    if ('-' !=start) {
        scanner.unread();
        return Token.UNDEFINED;
    }

    /* check if the former character is a space - if not this is not an argument */
    scanner.unread();
    scanner.unread();
    char beforeStart = (char) scanner.read();
    if (' ' !=beforeStart){
        /* no unread necessary, scanner is at start start*/
        return Token.UNDEFINED;
    }
    /* go after start again*/
    scanner.read();

    /* okay could be a parameter*/
    do {
        char c = (char) scanner.read();
        if (! isPartOfParameter(c)) {
            scanner.unread();
            break;
        }
    } while (true);
    return getSuccessToken();
}

private int scannerRead(ICharacterScanner scanner, Counter counter) {
    int c = scanner.read();
    if (c==ICharacterScanner.EOF){
        return c;
    }
    counter.count++;
    if (trace){
        traceSb.append((char)c);
    }
    return c;

}

private void scannerUnread(ICharacterScanner scanner, Counter counter) {
    scanner.unread();
    counter.count--;
    if (trace){
        int length = traceSb.length();
        if (length<1){
            traceSb.append("[(-1)]");
        }else{
            length=length-1;
            traceSb.setLength(length);
        }
    }
}

public ICharacterScannerCodePosSupport(ICharacterScanner scanner){
    this.scanner=scanner;
    this.counter=new Counter();
    // startPos start will always be 0. this is okay, here, because no tokens will be created so the information can start from 0 and
    // is okay. also an ICharacterScanner does not support real startPos handling but only forward and backward
    this.startPos=0;
    this.pos=-1;
}

@Override
public Character getCharacterAtPosOrNull(int pos) {
    moveToPos(pos);
    if (lastReadValue == ICharacterScanner.EOF){
        return null;
    }
    char lastCharacter = (char)lastReadValue;
    return Character.valueOf(lastCharacter);
}

private int scannerRead(ICharacterScanner scanner, Counter counter) {
    int c = scanner.read();
    if (c==ICharacterScanner.EOF){
        return c;
    }
    counter.count++;
    if (trace){
        traceSb.append((char)c);
    }
    return c;

}

private void scannerUnread(ICharacterScanner scanner, Counter counter) {
    scanner.unread();
    counter.count--;
    if (trace){
        int length = traceSb.length();
        if (length<1){
            traceSb.append("[(-1)]");
        }else{
            length=length-1;
            traceSb.setLength(length);
        }
    }
}

protected IToken doEvaluate(ICharacterScanner scanner, boolean resume) {

        if (resume) {

            if (endSequenceDetected(scanner))
                return fToken;

        } else {
            int c= scanner.read();
            if (c == fStartSequence[0]) {
                scanner.unread();
                scanner.unread();
                int before = scanner.read();

                if (before=='\\'){
                    return Token.UNDEFINED;
                }
                scanner.read();

                if (sequenceDetected(scanner, fStartSequence, false)) {
                    if (endSequenceDetected(scanner))
                        return fToken;
                }
            }
        }

        scanner.unread();
        return Token.UNDEFINED;
    }

@Override
public IToken evaluate(ICharacterScanner scanner, boolean resume) {
    char start = (char) scanner.read();
    if ('-' !=start) {
        scanner.unread();
        return Token.UNDEFINED;
    }

    /* check if the former character is a space - if not this is not an argument */
    scanner.unread();
    scanner.unread();
    char beforeStart = (char) scanner.read();
    if (' ' !=beforeStart){
        /* no unread necessary, scanner is at start start*/
        return Token.UNDEFINED;
    }
    /* go after start again*/
    scanner.read();

    /* okay could be a parameter*/
    do {
        char c = (char) scanner.read();
        if (! isPartOfParameter(c)) {
            scanner.unread();
            break;
        }
    } while (true);
    return getSuccessToken();
}