001: /* Generated By:JavaCC: Do not edit this line. ParseException.java Version 3.0 */
002: package org.openrdf.query.parser.sparql.ast;
003:
004: /**
005: * This exception is thrown when parse errors are encountered. You can
006: * explicitly create objects of this exception type by calling the method
007: * generateParseException in the generated parser. You can modify this class to
008: * customize your error reporting mechanisms so long as you retain the public
009: * fields.
010: */
011: public class ParseException extends Exception {
012:
013: /**
014: * This constructor is used by the method "generateParseException" in the
015: * generated parser. Calling this constructor generates a new object of this
016: * type with the fields "currentToken", "expectedTokenSequences", and
017: * "tokenImage" set. The boolean flag "specialConstructor" is also set to
018: * true to indicate that this constructor was used to create this object.
019: * This constructor calls its super class with the empty string to force the
020: * "toString" method of parent class "Throwable" to print the error message
021: * in the form: ParseException: <result of getMessage>
022: */
023: public ParseException(Token currentTokenVal,
024: int[][] expectedTokenSequencesVal, String[] tokenImageVal) {
025: super ("");
026: specialConstructor = true;
027: currentToken = currentTokenVal;
028: expectedTokenSequences = expectedTokenSequencesVal;
029: tokenImage = tokenImageVal;
030: }
031:
032: /**
033: * The following constructors are for use by you for whatever purpose you can
034: * think of. Constructing the exception in this manner makes the exception
035: * behave in the normal way - i.e., as documented in the class "Throwable".
036: * The fields "errorToken", "expectedTokenSequences", and "tokenImage" do not
037: * contain relevant information. The JavaCC generated code does not use these
038: * constructors.
039: */
040:
041: public ParseException() {
042: super ();
043: specialConstructor = false;
044: }
045:
046: public ParseException(String message) {
047: super (message);
048: specialConstructor = false;
049: }
050:
051: /**
052: * This variable determines which constructor was used to create this object
053: * and thereby affects the semantics of the "getMessage" method (see below).
054: */
055: protected boolean specialConstructor;
056:
057: /**
058: * This is the last token that has been consumed successfully. If this object
059: * has been created due to a parse error, the token followng this token will
060: * (therefore) be the first error token.
061: */
062: public Token currentToken;
063:
064: /**
065: * Each entry in this array is an array of integers. Each array of integers
066: * represents a sequence of tokens (by their ordinal values) that is expected
067: * at this point of the parse.
068: */
069: public int[][] expectedTokenSequences;
070:
071: /**
072: * This is a reference to the "tokenImage" array of the generated parser
073: * within which the parse error occurred. This array is defined in the
074: * generated ...Constants interface.
075: */
076: public String[] tokenImage;
077:
078: /**
079: * This method has the standard behavior when this object has been created
080: * using the standard constructors. Otherwise, it uses "currentToken" and
081: * "expectedTokenSequences" to generate a parse error message and returns it.
082: * If this object has been created due to a parse error, and you do not catch
083: * it (it gets thrown from the parser), then this method is called during the
084: * printing of the final stack trace, and hence the correct error message
085: * gets displayed.
086: */
087: @Override
088: public String getMessage() {
089: if (!specialConstructor) {
090: return super .getMessage();
091: }
092: StringBuffer expected = new StringBuffer();
093: int maxSize = 0;
094: for (int i = 0; i < expectedTokenSequences.length; i++) {
095: if (maxSize < expectedTokenSequences[i].length) {
096: maxSize = expectedTokenSequences[i].length;
097: }
098: for (int j = 0; j < expectedTokenSequences[i].length; j++) {
099: expected.append(
100: tokenImage[expectedTokenSequences[i][j]])
101: .append(" ");
102: }
103: if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) {
104: expected.append("...");
105: }
106: expected.append(eol).append(" ");
107: }
108: String retval = "Encountered \"";
109: Token tok = currentToken.next;
110: for (int i = 0; i < maxSize; i++) {
111: if (i != 0) {
112: retval += " ";
113: }
114: if (tok.kind == 0) {
115: retval += tokenImage[0];
116: break;
117: }
118: retval += add_escapes(tok.image);
119: tok = tok.next;
120: }
121: retval += "\" at line " + currentToken.next.beginLine
122: + ", column " + currentToken.next.beginColumn;
123: retval += "." + eol;
124: if (expectedTokenSequences.length == 1) {
125: retval += "Was expecting:" + eol + " ";
126: } else {
127: retval += "Was expecting one of:" + eol + " ";
128: }
129: retval += expected.toString();
130: return retval;
131: }
132:
133: /**
134: * The end of line string for this machine.
135: */
136: protected String eol = System.getProperty("line.separator", "\n");
137:
138: /**
139: * Used to convert raw characters to their escaped version when these raw
140: * version cannot be used as part of an ASCII string literal.
141: */
142: protected String add_escapes(String str) {
143: StringBuffer retval = new StringBuffer();
144: char ch;
145: for (int i = 0; i < str.length(); i++) {
146: switch (str.charAt(i)) {
147: case 0:
148: continue;
149: case '\b':
150: retval.append("\\b");
151: continue;
152: case '\t':
153: retval.append("\\t");
154: continue;
155: case '\n':
156: retval.append("\\n");
157: continue;
158: case '\f':
159: retval.append("\\f");
160: continue;
161: case '\r':
162: retval.append("\\r");
163: continue;
164: case '\"':
165: retval.append("\\\"");
166: continue;
167: case '\'':
168: retval.append("\\\'");
169: continue;
170: case '\\':
171: retval.append("\\\\");
172: continue;
173: default:
174: if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
175: String s = "0000" + Integer.toString(ch, 16);
176: retval.append("\\u"
177: + s.substring(s.length() - 4, s.length()));
178: } else {
179: retval.append(ch);
180: }
181: continue;
182: }
183: }
184: return retval.toString();
185: }
186:
187: }
|