Java SpelParseException类代码示例

import org.springframework.expression.spel.SpelParseException; //导入依赖的package包/类
@Override
protected SpelExpression doParseExpression(String expressionString, ParserContext context) throws ParseException {
	try {
		this.expressionString = expressionString;
		Tokenizer tokenizer = new Tokenizer(expressionString);
		tokenizer.process();
		this.tokenStream = tokenizer.getTokens();
		this.tokenStreamLength = this.tokenStream.size();
		this.tokenStreamPointer = 0;
		this.constructedNodes.clear();
		SpelNodeImpl ast = eatExpression();
		if (moreTokens()) {
			throw new SpelParseException(peekToken().startpos,SpelMessage.MORE_INPUT,toString(nextToken()));
		}
		Assert.isTrue(this.constructedNodes.isEmpty());
		return new SpelExpression(expressionString, ast, this.configuration);
	}
	catch (InternalParseException ipe) {
		throw ipe.getCause();
	}
}
 

import org.springframework.expression.spel.SpelParseException; //导入依赖的package包/类
private void lexQuotedStringLiteral() {
	int start = this.pos;
	boolean terminated = false;
	while (!terminated) {
		this.pos++;
		char ch = this.toProcess[this.pos];
		if (ch == '\'') {
			// may not be the end if the char after is also a '
			if (this.toProcess[this.pos + 1] == '\'') {
				this.pos++; // skip over that too, and continue
			}
			else {
				terminated = true;
			}
		}
		if (ch == 0) {
			throw new InternalParseException(new SpelParseException(this.expressionString,
					start, SpelMessage.NON_TERMINATING_QUOTED_STRING));
		}
	}
	this.pos++;
	this.tokens.add(new Token(TokenKind.LITERAL_STRING, subarray(start, this.pos), start, this.pos));
}
 

import org.springframework.expression.spel.SpelParseException; //导入依赖的package包/类
private void lexDoubleQuotedStringLiteral() {
	int start = this.pos;
	boolean terminated = false;
	while (!terminated) {
		this.pos++;
		char ch = this.toProcess[this.pos];
		if (ch == '"') {
			// may not be the end if the char after is also a "
			if (this.toProcess[this.pos + 1] == '"') {
				this.pos++; // skip over that too, and continue
			}
			else {
				terminated = true;
			}
		}
		if (ch == 0) {
			throw new InternalParseException(new SpelParseException(this.expressionString,
					start, SpelMessage.NON_TERMINATING_DOUBLE_QUOTED_STRING));
		}
	}
	this.pos++;
	this.tokens.add(new Token(TokenKind.LITERAL_STRING, subarray(start, this.pos), start, this.pos));
}
 

import org.springframework.expression.spel.SpelParseException; //导入依赖的package包/类
private void pushHexIntToken(char[] data, boolean isLong, int start, int end) {
	if (data.length == 0) {
		if (isLong) {
			throw new InternalParseException(new SpelParseException(this.expressionString,
					start, SpelMessage.NOT_A_LONG, this.expressionString.substring(start,
							end + 1)));
		}
		else {
			throw new InternalParseException(new SpelParseException(this.expressionString,
					start, SpelMessage.NOT_AN_INTEGER, this.expressionString.substring(
							start, end)));
		}
	}
	if (isLong) {
		this.tokens.add(new Token(TokenKind.LITERAL_HEXLONG, data, start, end));
	}
	else {
		this.tokens.add(new Token(TokenKind.LITERAL_HEXINT, data, start, end));
	}
}
 

import org.springframework.expression.spel.SpelParseException; //导入依赖的package包/类
@Override
protected SpelExpression doParseExpression(String expressionString, ParserContext context) throws ParseException {
	try {
		this.expressionString = expressionString;
		Tokenizer tokenizer = new Tokenizer(expressionString);
		tokenizer.process();
		this.tokenStream = tokenizer.getTokens();
		this.tokenStreamLength = this.tokenStream.size();
		this.tokenStreamPointer = 0;
		this.constructedNodes.clear();
		SpelNodeImpl ast = eatExpression();
		if (moreTokens()) {
			throw new SpelParseException(peekToken().startPos, SpelMessage.MORE_INPUT, toString(nextToken()));
		}
		Assert.isTrue(this.constructedNodes.isEmpty());
		return new SpelExpression(expressionString, ast, this.configuration);
	}
	catch (InternalParseException ex) {
		throw ex.getCause();
	}
}
 

import org.springframework.expression.spel.SpelParseException; //导入依赖的package包/类
private void lexQuotedStringLiteral() {
	int start = this.pos;
	boolean terminated = false;
	while (!terminated) {
		this.pos++;
		char ch = this.toProcess[this.pos];
		if (ch == '\'') {
			// may not be the end if the char after is also a '
			if (this.toProcess[this.pos + 1] == '\'') {
				this.pos++; // skip over that too, and continue
			}
			else {
				terminated = true;
			}
		}
		if (ch == 0) {
			throw new InternalParseException(new SpelParseException(this.expressionString, start,
					SpelMessage.NON_TERMINATING_QUOTED_STRING));
		}
	}
	this.pos++;
	this.tokens.add(new Token(TokenKind.LITERAL_STRING, subarray(start, this.pos), start, this.pos));
}
 

import org.springframework.expression.spel.SpelParseException; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public void resolveExpressionsForParagraph(P p, T expressionContext, WordprocessingMLPackage document) {
  ParagraphWrapper paragraphWrapper = new ParagraphWrapper(p);
  List<String> placeholders = expressionUtil.findVariableExpressions(paragraphWrapper.getText());
  for (String placeholder : placeholders) {
    try {
      Object replacement = expressionResolver.resolveExpression(placeholder, expressionContext);
      if (replacement != null) {
        ITypeResolver resolver = typeResolverRegistry.getResolverForType(replacement.getClass());
        Object replacementObject = resolver.resolve(document, replacement);
        replace(paragraphWrapper, placeholder, replacementObject);
        logger.debug(String.format("Replaced expression '%s' with value provided by TypeResolver %s", placeholder, resolver.getClass()));
      }
    } catch (SpelEvaluationException | SpelParseException e) {
      logger.warn(String.format(
              "Expression %s could not be resolved against context root of type %s. Reason: %s. Set log level to TRACE to view Stacktrace.",
              placeholder, expressionContext.getClass(), e.getMessage()));
      logger.trace("Reason for skipping expression:", e);
    }
  }
  if (this.lineBreakPlaceholder != null) {
    replaceLineBreaks(paragraphWrapper);
  }
}
 

import org.springframework.expression.spel.SpelParseException; //导入依赖的package包/类
@Override
protected SpelExpression doParseExpression(String expressionString, ParserContext context) throws ParseException {
	try {
		this.expressionString = expressionString;
		Tokenizer tokenizer = new Tokenizer(expressionString);
		tokenizer.process();
		tokenStream = tokenizer.getTokens();
		tokenStreamLength = tokenStream.size();
		tokenStreamPointer = 0;
		constructedNodes.clear();
		SpelNodeImpl ast = eatExpression();
		if (moreTokens()) {
			throw new SpelParseException(peekToken().startpos,SpelMessage.MORE_INPUT,toString(nextToken()));
		}
		Assert.isTrue(constructedNodes.isEmpty());
		return new SpelExpression(expressionString, ast, configuration);
	}
	catch (InternalParseException ipe) {
		throw ipe.getCause();
	}
}
 

import org.springframework.expression.spel.SpelParseException; //导入依赖的package包/类
private void lexQuotedStringLiteral() {
	int start = pos;
	boolean terminated = false;
	while (!terminated) {
		pos++;
		char ch = toProcess[pos];
		if (ch=='\'') {
			// may not be the end if the char after is also a '
			if (toProcess[pos+1]=='\'') {
				pos++; // skip over that too, and continue
			} else {
				terminated = true;
			}
		}
		if (ch==0) {
			throw new InternalParseException(new SpelParseException(expressionString,start,SpelMessage.NON_TERMINATING_QUOTED_STRING));
		}
	}
	pos++;
	tokens.add(new Token(TokenKind.LITERAL_STRING, subarray(start,pos), start, pos));
}
 

import org.springframework.expression.spel.SpelParseException; //导入依赖的package包/类
private void lexDoubleQuotedStringLiteral() {
	int start = pos;
	boolean terminated = false;
	while (!terminated) {
		pos++;
		char ch = toProcess[pos];
		if (ch=='"') {
			// may not be the end if the char after is also a "
			if (toProcess[pos+1]=='"') {
				pos++; // skip over that too, and continue
			} else {
				terminated = true;
			}
		}
		if (ch==0) {
			throw new InternalParseException(new SpelParseException(expressionString,start,SpelMessage.NON_TERMINATING_DOUBLE_QUOTED_STRING));
		}
	}
	pos++;
	tokens.add(new Token(TokenKind.LITERAL_STRING, subarray(start,pos), start, pos));
}
 

import org.springframework.expression.spel.SpelParseException; //导入依赖的package包/类
/**
 * Process the string form of a number, using the specified base if supplied and return an appropriate literal to
 * hold it. Any suffix to indicate a long will be taken into account (either 'l' or 'L' is supported).
 * @param numberToken the token holding the number as its payload (eg. 1234 or 0xCAFE)
 * @param radix the base of number
 * @return a subtype of Literal that can represent it
 */
public static Literal getIntLiteral(String numberToken, int pos, int radix) {
	try {
		int value = Integer.parseInt(numberToken, radix);
		return new IntLiteral(numberToken, pos, value);
	}
	catch (NumberFormatException nfe) {
		throw new InternalParseException(new SpelParseException(pos>>16, nfe, SpelMessage.NOT_AN_INTEGER, numberToken));
	}
}
 

import org.springframework.expression.spel.SpelParseException; //导入依赖的package包/类
public static Literal getLongLiteral(String numberToken, int pos, int radix) {
	try {
		long value = Long.parseLong(numberToken, radix);
		return new LongLiteral(numberToken, pos, value);
	}
	catch (NumberFormatException nfe) {
		throw new InternalParseException(new SpelParseException(pos>>16, nfe, SpelMessage.NOT_A_LONG, numberToken));
	}
}
 

import org.springframework.expression.spel.SpelParseException; //导入依赖的package包/类
private void eatConstructorArgs(List<SpelNodeImpl> accumulatedArguments) {
	if (!peekToken(TokenKind.LPAREN)) {
		throw new InternalParseException(new SpelParseException(this.expressionString,positionOf(peekToken()),SpelMessage.MISSING_CONSTRUCTOR_ARGS));
	}
	consumeArguments(accumulatedArguments);
	eatToken(TokenKind.RPAREN);
}
 

import org.springframework.expression.spel.SpelParseException; //导入依赖的package包/类
/**
 * Process the string form of a number, using the specified base if supplied
 * and return an appropriate literal to hold it. Any suffix to indicate a
 * long will be taken into account (either 'l' or 'L' is supported).
 * @param numberToken the token holding the number as its payload (eg. 1234 or 0xCAFE)
 * @param radix the base of number
 * @return a subtype of Literal that can represent it
 */
public static Literal getIntLiteral(String numberToken, int pos, int radix) {
	try {
		int value = Integer.parseInt(numberToken, radix);
		return new IntLiteral(numberToken, pos, value);
	}
	catch (NumberFormatException ex) {
		throw new InternalParseException(new SpelParseException(pos>>16, ex, SpelMessage.NOT_AN_INTEGER, numberToken));
	}
}
 

import org.springframework.expression.spel.SpelParseException; //导入依赖的package包/类
public static Literal getLongLiteral(String numberToken, int pos, int radix) {
	try {
		long value = Long.parseLong(numberToken, radix);
		return new LongLiteral(numberToken, pos, value);
	}
	catch (NumberFormatException ex) {
		throw new InternalParseException(new SpelParseException(pos>>16, ex, SpelMessage.NOT_A_LONG, numberToken));
	}
}