EMMA Coverage Report (generated Wed Jun 28 22:15:27 PDT 2006)
[all classes][org.apache.derby.impl.tools.ij]

COVERAGE SUMMARY FOR SOURCE FILE [ParseException.java]

nameclass, %method, %block, %line, %
ParseException.java100% (1/1)20%  (1/5)7%   (21/322)11%  (6.5/61)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class ParseException100% (1/1)20%  (1/5)7%   (21/322)11%  (6.5/61)
ParseException (): void 0%   (0/1)0%   (0/11)0%   (0/4)
ParseException (String): void 0%   (0/1)0%   (0/12)0%   (0/4)
ParseException (Token, int [][], String []): void 100% (1/1)100% (21/21)100% (7/7)
add_escapes (String): String 0%   (0/1)0%   (0/104)0%   (0/25)
getMessage (): String 0%   (0/1)0%   (0/174)0%   (0/23)

1/* Generated By:JavaCC: Do not edit this line. ParseException.java Version 3.0 */
2/*
3 
4   Derby - Class org.apache.derby.impl.tools.ij.ParseException
5 
6   Copyright 1997, 2004 The Apache Software Foundation or its licensors, as applicable.
7 
8   Licensed under the Apache License, Version 2.0 (the "License");
9   you may not use this file except in compliance with the License.
10   You may obtain a copy of the License at
11 
12      http://www.apache.org/licenses/LICENSE-2.0
13 
14   Unless required by applicable law or agreed to in writing, software
15   distributed under the License is distributed on an "AS IS" BASIS,
16   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17   See the License for the specific language governing permissions and
18   limitations under the License.
19 
20 */
21package org.apache.derby.impl.tools.ij;
22 
23/**
24 * This exception is thrown when parse errors are encountered.
25 * You can explicitly create objects of this exception type by
26 * calling the method generateParseException in the generated
27 * parser.
28 *
29 * You can modify this class to customize your error reporting
30 * mechanisms so long as you retain the public fields.
31 */
32public class ParseException extends Exception {
33  /**
34   * This constructor is used by the method "generateParseException"
35   * in the generated parser.  Calling this constructor generates
36   * a new object of this type with the fields "currentToken",
37   * "expectedTokenSequences", and "tokenImage" set.  The boolean
38   * flag "specialConstructor" is also set to true to indicate that
39   * this constructor was used to create this object.
40   * This constructor calls its super class with the empty string
41   * to force the "toString" method of parent class "Throwable" to
42   * print the error message in the form:
43   *     ParseException: <result of getMessage>
44   */
45  public ParseException(Token currentTokenVal,
46                        int[][] expectedTokenSequencesVal,
47                        String[] tokenImageVal
48                       )
49  {
50    super("");
51    specialConstructor = true;
52    currentToken = currentTokenVal;
53    expectedTokenSequences = expectedTokenSequencesVal;
54    tokenImage = tokenImageVal;
55  }
56 
57  /**
58   * The following constructors are for use by you for whatever
59   * purpose you can think of.  Constructing the exception in this
60   * manner makes the exception behave in the normal way - i.e., as
61   * documented in the class "Throwable".  The fields "errorToken",
62   * "expectedTokenSequences", and "tokenImage" do not contain
63   * relevant information.  The JavaCC generated code does not use
64   * these constructors.
65   */
66 
67  public ParseException() {
68    super();
69    specialConstructor = false;
70  }
71 
72  public ParseException(String message) {
73    super(message);
74    specialConstructor = false;
75  }
76 
77  /**
78   * This variable determines which constructor was used to create
79   * this object and thereby affects the semantics of the
80   * "getMessage" method (see below).
81   */
82  protected boolean specialConstructor;
83 
84  /**
85   * This is the last token that has been consumed successfully.  If
86   * this object has been created due to a parse error, the token
87   * followng this token will (therefore) be the first error token.
88   */
89  public Token currentToken;
90 
91  /**
92   * Each entry in this array is an array of integers.  Each array
93   * of integers represents a sequence of tokens (by their ordinal
94   * values) that is expected at this point of the parse.
95   */
96  public int[][] expectedTokenSequences;
97 
98  /**
99   * This is a reference to the "tokenImage" array of the generated
100   * parser within which the parse error occurred.  This array is
101   * defined in the generated ...Constants interface.
102   */
103  public String[] tokenImage;
104 
105  /**
106   * This method has the standard behavior when this object has been
107   * created using the standard constructors.  Otherwise, it uses
108   * "currentToken" and "expectedTokenSequences" to generate a parse
109   * error message and returns it.  If this object has been created
110   * due to a parse error, and you do not catch it (it gets thrown
111   * from the parser), then this method is called during the printing
112   * of the final stack trace, and hence the correct error message
113   * gets displayed.
114   */
115  public String getMessage() {
116    if (!specialConstructor) {
117      return super.getMessage();
118    }
119    String expected = "";
120    int maxSize = 0;
121    for (int i = 0; i < expectedTokenSequences.length; i++) {
122      if (maxSize < expectedTokenSequences[i].length) {
123        maxSize = expectedTokenSequences[i].length;
124      }
125      for (int j = 0; j < expectedTokenSequences[i].length; j++) {
126        expected += tokenImage[expectedTokenSequences[i][j]] + " ";
127      }
128      if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) {
129        expected += "...";
130      }
131      expected += eol + "    ";
132    }
133    String retval = "Encountered \"";
134    Token tok = currentToken.next;
135    for (int i = 0; i < maxSize; i++) {
136      if (i != 0) retval += " ";
137      if (tok.kind == 0) {
138        retval += tokenImage[0];
139        break;
140      }
141      retval += add_escapes(tok.image);
142      tok = tok.next;
143    }
144    retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn;
145 /*
146  * for output compatibility with previous releases, do not report expected tokens.
147  *
148    retval += "." + eol;
149    if (expectedTokenSequences.length == 1) {
150      retval += "Was expecting:" + eol + "    ";
151    } else {
152      retval += "Was expecting one of:" + eol + "    ";
153    }
154    retval += expected;
155  */
156    return retval;
157  }
158 
159  /**
160   * The end of line string for this machine.
161   */
162  protected String eol = System.getProperty("line.separator", "\n");
163 
164  /**
165   * Used to convert raw characters to their escaped version
166   * when these raw version cannot be used as part of an ASCII
167   * string literal.
168   */
169  protected String add_escapes(String str) {
170      StringBuffer retval = new StringBuffer();
171      char ch;
172      for (int i = 0; i < str.length(); i++) {
173        switch (str.charAt(i))
174        {
175           case 0 :
176              continue;
177           case '\b':
178              retval.append("\\b");
179              continue;
180           case '\t':
181              retval.append("\\t");
182              continue;
183           case '\n':
184              retval.append("\\n");
185              continue;
186           case '\f':
187              retval.append("\\f");
188              continue;
189           case '\r':
190              retval.append("\\r");
191              continue;
192           case '\"':
193              retval.append("\\\"");
194              continue;
195           case '\'':
196              retval.append("\\\'");
197              continue;
198           case '\\':
199              retval.append("\\\\");
200              continue;
201           default:
202              if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
203                 String s = "0000" + Integer.toString(ch, 16);
204                 retval.append("\\u" + s.substring(s.length() - 4, s.length()));
205              } else {
206                 retval.append(ch);
207              }
208              continue;
209        }
210      }
211      return retval.toString();
212   }
213 
214}

[all classes][org.apache.derby.impl.tools.ij]
EMMA 2.0.5312 (C) Vladimir Roubtsov