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