Java ICharacterScanner.unread方法代码示例

import org.eclipse.jface.text.rules.ICharacterScanner; //导入方法依赖的package包/类
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;
}
 

import org.eclipse.jface.text.rules.ICharacterScanner; //导入方法依赖的package包/类
@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;
}
 

import org.eclipse.jface.text.rules.ICharacterScanner; //导入方法依赖的package包/类
@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;
}
 

import org.eclipse.jface.text.rules.ICharacterScanner; //导入方法依赖的package包/类
@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;
}
 

import org.eclipse.jface.text.rules.ICharacterScanner; //导入方法依赖的package包/类
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;
}
 

import org.eclipse.jface.text.rules.ICharacterScanner; //导入方法依赖的package包/类
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;
   }
 

import org.eclipse.jface.text.rules.ICharacterScanner; //导入方法依赖的package包/类
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);
}
 

import org.eclipse.jface.text.rules.ICharacterScanner; //导入方法依赖的package包/类
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;
	}
 

import org.eclipse.jface.text.rules.ICharacterScanner; //导入方法依赖的package包/类
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);
		}
	}
}
 

import org.eclipse.jface.text.rules.ICharacterScanner; //导入方法依赖的package包/类
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;
	}
 

import org.eclipse.jface.text.rules.ICharacterScanner; //导入方法依赖的package包/类
@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();
}
 

import org.eclipse.jface.text.rules.ICharacterScanner; //导入方法依赖的package包/类
@Override
public IToken evaluate(final ICharacterScanner scanner) {
  final int c = scanner.read();
  if (c == '[' || c == ']') {
    return this.token;
  }
  scanner.unread();
  return Token.UNDEFINED;
}
 

import org.eclipse.jface.text.rules.ICharacterScanner; //导入方法依赖的package包/类
@Override
protected boolean endSequenceDetected(final ICharacterScanner scanner) {

  int readCount = 1;
  int c;
  int open = 0;
  while ((c = scanner.read()) != ICharacterScanner.EOF) {

    if (c == '{') {
      open++;
    } else if (c == '}') {
      open--;
      if (open == 0) {
        if (this.sequenceDetected(scanner, this.fEndSequence, this.fBreaksOnEOF)) {
          return true;
        }
      }
    }

    readCount++;
  }

  for (; readCount > 0; readCount--) {
    scanner.unread();
  }

  return false;
}
 

import org.eclipse.jface.text.rules.ICharacterScanner; //导入方法依赖的package包/类
@Override
public IToken evaluate(final ICharacterScanner scanner) {
  final int c = scanner.read();
  if (c == '(' || c == ')') {
    return this.token;
  }
  scanner.unread();
  return Token.UNDEFINED;
}
 

import org.eclipse.jface.text.rules.ICharacterScanner; //导入方法依赖的package包/类
@Override
public IToken evaluate(final ICharacterScanner scanner) {
  final int c = scanner.read();
  if (c == this.specChar) {
    return this.token;
  }
  scanner.unread();
  return Token.UNDEFINED;
}