diff options
Diffstat (limited to 'velocity-engine-core/src/main/java/org/apache/velocity/runtime/parser/TemplateParseException.java')
| -rw-r--r-- | velocity-engine-core/src/main/java/org/apache/velocity/runtime/parser/TemplateParseException.java | 245 |
1 files changed, 245 insertions, 0 deletions
diff --git a/velocity-engine-core/src/main/java/org/apache/velocity/runtime/parser/TemplateParseException.java b/velocity-engine-core/src/main/java/org/apache/velocity/runtime/parser/TemplateParseException.java new file mode 100644 index 00000000..acb20a97 --- /dev/null +++ b/velocity-engine-core/src/main/java/org/apache/velocity/runtime/parser/TemplateParseException.java @@ -0,0 +1,245 @@ +package org.apache.velocity.runtime.parser; + +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +import org.apache.velocity.exception.ExtendedParseException; +import org.apache.velocity.util.StringUtils; + +/** + * This is an extension of the ParseException, which also takes a + * template name. + * + * @see org.apache.velocity.runtime.parser.ParseException + * + * @author <a href="hps@intermeta.de">Henning P. Schmiedehausen</a> + * @version $Id$ + * @since 1.5 + */ +public class TemplateParseException + extends ParseException + implements ExtendedParseException +{ + private static final long serialVersionUID = -3146323135623083918L; + + /** + * This is the name of the template which contains the parsing error, or + * null if not defined. + */ + private final String templateName; + + /** + * This constructor is used to add a template name + * to info cribbed from a ParseException generated in the parser. + * @param currentTokenVal + * @param expectedTokenSequencesVal + * @param tokenImageVal + * @param templateNameVal + */ + public TemplateParseException(Token currentTokenVal, int [][] expectedTokenSequencesVal, String [] tokenImageVal, + String templateNameVal) + { + super(currentTokenVal, expectedTokenSequencesVal, tokenImageVal); + this.templateName = templateNameVal; + } + + /** + * <p>This constructor is used by the method "generateParseException" + * in the generated parser. Calling this constructor generates + * a new object of this type with the fields "currentToken", + * "expectedTokenSequences", and "tokenImage" set. The boolean + * flag "specialConstructor" is also set to true to indicate that + * this constructor was used to create this object. + * This constructor calls its super class with the empty string + * to force the "toString" method of parent class "Throwable" to + * print the error message in the form:</p> + * <pre> + * ParseException: <result of getMessage> + * </pre> + * @param currentTokenVal + * @param expectedTokenSequencesVal + * @param tokenImageVal + */ + public TemplateParseException(Token currentTokenVal, int [][] expectedTokenSequencesVal, String [] tokenImageVal) + { + super(currentTokenVal, expectedTokenSequencesVal, tokenImageVal); + templateName = "*unset*"; + } + + /** + * The following constructors are for use by you for whatever + * purpose you can think of. Constructing the exception in this + * manner makes the exception behave in the normal way - i.e., as + * documented in the class "Throwable". The fields "errorToken", + * "expectedTokenSequences", and "tokenImage" do not contain + * relevant information. The JavaCC generated code does not use + * these constructors. + */ + public TemplateParseException() + { + super(); + templateName = "*unset*"; + } + + /** + * Creates a new TemplateParseException object. + * + * @param message TODO: DOCUMENT ME! + */ + public TemplateParseException(String message) + { + super(message); + templateName = "*unset*"; + } + + /** + * returns the Template name where this exception occurred. + * @return The Template name where this exception occurred. + */ + @Override + public String getTemplateName() + { + return templateName; + } + + /** + * returns the line number where this exception occurred. + * @return The line number where this exception occurred. + */ + @Override + public int getLineNumber() + { + if ((currentToken != null) && (currentToken.next != null)) + { + return currentToken.next.beginLine; + } + else + { + return -1; + } + } + + /** + * returns the column number where this exception occurred. + * @return The column number where this exception occurred. + */ + @Override + public int getColumnNumber() + { + if ((currentToken != null) && (currentToken.next != null)) + { + return currentToken.next.beginColumn; + } + else + { + return -1; + } + } + + /** + * This method has the standard behavior when this object has been + * created using the standard constructors. Otherwise, it uses + * "currentToken" and "expectedTokenSequences" to generate a parse + * error message and returns it. If this object has been created + * due to a parse error, and you do not catch it (it gets thrown + * from the parser), then this method is called during the printing + * of the final stack trace, and hence the correct error message + * gets displayed. + * @return The error message. + */ + @Override + public String getMessage() + { + if (!specialConstructor) + { + StringBuilder sb = new StringBuilder(super.getMessage()); + appendTemplateInfo(sb); + return sb.toString(); + } + + int maxSize = 0; + + StringBuilder expected = new StringBuilder(); + + for (int[] expectedTokenSequence : expectedTokenSequences) + { + if (maxSize < expectedTokenSequence.length) + { + maxSize = expectedTokenSequence.length; + } + + for (int i : expectedTokenSequence) + { + expected.append(tokenImage[i]).append(" "); + } + + if (expectedTokenSequence[expectedTokenSequence.length - 1] != 0) + { + expected.append("..."); + } + + expected.append(eol).append(" "); + } + + StringBuilder retval = new StringBuilder("Encountered \""); + Token tok = currentToken.next; + + for (int i = 0; i < maxSize; i++) + { + if (i != 0) + { + retval.append(" "); + } + + if (tok.kind == 0) + { + retval.append(tokenImage[0]); + break; + } + + retval.append(add_escapes(tok.image)); + tok = tok.next; + } + + retval.append("\" at "); + appendTemplateInfo(retval); + + if (expectedTokenSequences.length == 1) + { + retval.append("Was expecting:").append(eol).append(" "); + } + else + { + retval.append("Was expecting one of:").append(eol).append(" "); + } + + // avoid JDK 1.3 StringBuffer.append(Object o) vs 1.4 StringBuffer.append(StringBuffer sb) gotcha. + retval.append(expected.toString()); + return retval.toString(); + } + + /** + * @param sb + */ + protected void appendTemplateInfo(final StringBuilder sb) + { + sb.append(StringUtils.formatFileString(getTemplateName(), getLineNumber(), getColumnNumber())); + sb.append(eol); + } +} |