| /* |
| * Copyright (c) 1994, 2004, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package sun.tools.java; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.util.Hashtable; |
| |
| /** |
| * A Scanner for Java tokens. Errors are reported |
| * to the environment object.<p> |
| * |
| * The scanner keeps track of the current token, |
| * the value of the current token (if any), and the start |
| * position of the current token.<p> |
| * |
| * The scan() method advances the scanner to the next |
| * token in the input.<p> |
| * |
| * The match() method is used to quickly match opening |
| * brackets (ie: '(', '{', or '[') with their closing |
| * counter part. This is useful during error recovery.<p> |
| * |
| * An position consists of: ((linenr << WHEREOFFSETBITS) | offset) |
| * this means that both the line number and the exact offset into |
| * the file are encoded in each position value.<p> |
| * |
| * The compiler treats either "\n", "\r" or "\r\n" as the |
| * end of a line.<p> |
| * |
| * WARNING: The contents of this source file are not part of any |
| * supported API. Code that depends on them does so at its own risk: |
| * they are subject to change or removal without notice. |
| * |
| * @author Arthur van Hoff |
| */ |
| |
| public |
| class Scanner implements Constants { |
| /** |
| * The increment for each character. |
| */ |
| public static final long OFFSETINC = 1; |
| |
| /** |
| * The increment for each line. |
| */ |
| public static final long LINEINC = 1L << WHEREOFFSETBITS; |
| |
| /** |
| * End of input |
| */ |
| public static final int EOF = -1; |
| |
| /** |
| * Where errors are reported |
| */ |
| public Environment env; |
| |
| /** |
| * Input reader |
| */ |
| protected ScannerInputReader in; |
| |
| /** |
| * If true, present all comments as tokens. |
| * Contents are not saved, but positions are recorded accurately, |
| * so the comment can be recovered from the text. |
| * Line terminations are also returned as comment tokens, |
| * and may be distinguished by their start and end positions, |
| * which are equal (meaning, these tokens contain no chars). |
| */ |
| public boolean scanComments = false; |
| |
| /** |
| * Current token |
| */ |
| public int token; |
| |
| /** |
| * The position of the current token |
| */ |
| public long pos; |
| |
| /** |
| * The position of the previous token |
| */ |
| public long prevPos; |
| |
| /** |
| * The current character |
| */ |
| protected int ch; |
| |
| /* |
| * Token values. |
| */ |
| public char charValue; |
| public int intValue; |
| public long longValue; |
| public float floatValue; |
| public double doubleValue; |
| public String stringValue; |
| public Identifier idValue; |
| public int radix; // Radix, when reading int or long |
| |
| /* |
| * A doc comment preceding the most recent token |
| */ |
| public String docComment; |
| |
| /* |
| * A growable character buffer. |
| */ |
| private int count; |
| private char buffer[] = new char[1024]; |
| private void growBuffer() { |
| char newBuffer[] = new char[buffer.length * 2]; |
| System.arraycopy(buffer, 0, newBuffer, 0, buffer.length); |
| buffer = newBuffer; |
| } |
| |
| // The following two methods have been hand-inlined in |
| // scanDocComment. If you make changes here, you should |
| // check to see if scanDocComment also needs modification. |
| private void putc(int ch) { |
| if (count == buffer.length) { |
| growBuffer(); |
| } |
| buffer[count++] = (char)ch; |
| } |
| |
| private String bufferString() { |
| return new String(buffer, 0, count); |
| } |
| |
| /** |
| * Create a scanner to scan an input stream. |
| */ |
| public Scanner(Environment env, InputStream in) throws IOException { |
| this.env = env; |
| useInputStream(in); |
| } |
| |
| /** |
| * Setup input from the given input stream, |
| * and scan the first token from it. |
| */ |
| protected void useInputStream(InputStream in) throws IOException { |
| try { |
| this.in = new ScannerInputReader(env, in); |
| } catch (Exception e) { |
| env.setCharacterEncoding(null); |
| this.in = new ScannerInputReader(env, in); |
| } |
| |
| ch = this.in.read(); |
| prevPos = this.in.pos; |
| |
| scan(); |
| } |
| |
| /** |
| * Create a scanner to scan an input stream. |
| */ |
| protected Scanner(Environment env) { |
| this.env = env; |
| // Expect the subclass to call useInputStream at the right time. |
| } |
| |
| /** |
| * Define a keyword. |
| */ |
| private static void defineKeyword(int val) { |
| Identifier.lookup(opNames[val]).setType(val); |
| } |
| |
| /** |
| * Initialized keyword and token Hashtables |
| */ |
| static { |
| // Statement keywords |
| defineKeyword(FOR); |
| defineKeyword(IF); |
| defineKeyword(ELSE); |
| defineKeyword(WHILE); |
| defineKeyword(DO); |
| defineKeyword(SWITCH); |
| defineKeyword(CASE); |
| defineKeyword(DEFAULT); |
| defineKeyword(BREAK); |
| defineKeyword(CONTINUE); |
| defineKeyword(RETURN); |
| defineKeyword(TRY); |
| defineKeyword(CATCH); |
| defineKeyword(FINALLY); |
| defineKeyword(THROW); |
| |
| // Type defineKeywords |
| defineKeyword(BYTE); |
| defineKeyword(CHAR); |
| defineKeyword(SHORT); |
| defineKeyword(INT); |
| defineKeyword(LONG); |
| defineKeyword(FLOAT); |
| defineKeyword(DOUBLE); |
| defineKeyword(VOID); |
| defineKeyword(BOOLEAN); |
| |
| // Expression keywords |
| defineKeyword(INSTANCEOF); |
| defineKeyword(TRUE); |
| defineKeyword(FALSE); |
| defineKeyword(NEW); |
| defineKeyword(THIS); |
| defineKeyword(SUPER); |
| defineKeyword(NULL); |
| |
| // Declaration keywords |
| defineKeyword(IMPORT); |
| defineKeyword(CLASS); |
| defineKeyword(EXTENDS); |
| defineKeyword(IMPLEMENTS); |
| defineKeyword(INTERFACE); |
| defineKeyword(PACKAGE); |
| defineKeyword(THROWS); |
| |
| // Modifier keywords |
| defineKeyword(PRIVATE); |
| defineKeyword(PUBLIC); |
| defineKeyword(PROTECTED); |
| defineKeyword(STATIC); |
| defineKeyword(TRANSIENT); |
| defineKeyword(SYNCHRONIZED); |
| defineKeyword(NATIVE); |
| defineKeyword(ABSTRACT); |
| defineKeyword(VOLATILE); |
| defineKeyword(FINAL); |
| defineKeyword(STRICTFP); |
| |
| // reserved keywords |
| defineKeyword(CONST); |
| defineKeyword(GOTO); |
| } |
| |
| /** |
| * Scan a comment. This method should be |
| * called once the initial /, * and the next |
| * character have been read. |
| */ |
| private void skipComment() throws IOException { |
| while (true) { |
| switch (ch) { |
| case EOF: |
| env.error(pos, "eof.in.comment"); |
| return; |
| |
| case '*': |
| if ((ch = in.read()) == '/') { |
| ch = in.read(); |
| return; |
| } |
| break; |
| |
| default: |
| ch = in.read(); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Scan a doc comment. This method should be called |
| * once the initial /, * and * have been read. It gathers |
| * the content of the comment (witout leading spaces and '*'s) |
| * in the string buffer. |
| */ |
| private String scanDocComment() throws IOException { |
| // Note: this method has been hand-optimized to yield |
| // better performance. This was done after it was noted |
| // that javadoc spent a great deal of its time here. |
| // This should also help the performance of the compiler |
| // as well -- it scans the doc comments to find |
| // @deprecated tags. |
| // |
| // The logic of the method has been completely rewritten |
| // to avoid the use of flags that need to be looked at |
| // for every character read. Members that are accessed |
| // more than once have been stored in local variables. |
| // The methods putc() and bufferString() have been |
| // inlined by hand. Extra cases have been added to |
| // switch statements to trick the compiler into generating |
| // a tableswitch instead of a lookupswitch. |
| // |
| // This implementation aims to preserve the previous |
| // behavior of this method. |
| |
| int c; |
| |
| // Put `in' in a local variable. |
| final ScannerInputReader in = this.in; |
| |
| // We maintain the buffer locally rather than calling putc(). |
| char[] buffer = this.buffer; |
| int count = 0; |
| |
| // We are called pointing at the second star of the doc |
| // comment: |
| // |
| // Input: /** the rest of the comment ... */ |
| // ^ |
| // |
| // We rely on this in the code below. |
| |
| // Consume any number of stars. |
| while ((c = in.read()) == '*') |
| ; |
| |
| // Is the comment of the form /**/, /***/, /****/, etc.? |
| if (c == '/') { |
| // Set ch and return |
| ch = in.read(); |
| return ""; |
| } |
| |
| // Skip a newline on the first line of the comment. |
| if (c == '\n') { |
| c = in.read(); |
| } |
| |
| outerLoop: |
| // The outerLoop processes the doc comment, looping once |
| // for each line. For each line, it first strips off |
| // whitespace, then it consumes any stars, then it |
| // puts the rest of the line into our buffer. |
| while (true) { |
| |
| // The wsLoop consumes whitespace from the beginning |
| // of each line. |
| wsLoop: |
| while (true) { |
| switch (c) { |
| case ' ': |
| case '\t': |
| // We could check for other forms of whitespace |
| // as well, but this is left as is for minimum |
| // disturbance of functionality. |
| // |
| // Just skip whitespace. |
| c = in.read(); |
| break; |
| |
| // We have added extra cases here to trick the |
| // compiler into using a tableswitch instead of |
| // a lookupswitch. They can be removed without |
| // a change in meaning. |
| case 10: case 11: case 12: case 13: case 14: case 15: |
| case 16: case 17: case 18: case 19: case 20: case 21: |
| case 22: case 23: case 24: case 25: case 26: case 27: |
| case 28: case 29: case 30: case 31: |
| default: |
| // We've seen something that isn't whitespace, |
| // jump out. |
| break wsLoop; |
| } |
| } // end wsLoop. |
| |
| // Are there stars here? If so, consume them all |
| // and check for the end of comment. |
| if (c == '*') { |
| // Skip all of the stars... |
| do { |
| c = in.read(); |
| } while (c == '*'); |
| |
| // ...then check for the closing slash. |
| if (c == '/') { |
| // We're done with the doc comment. |
| // Set ch and break out. |
| ch = in.read(); |
| break outerLoop; |
| } |
| } |
| |
| // The textLoop processes the rest of the characters |
| // on the line, adding them to our buffer. |
| textLoop: |
| while (true) { |
| switch (c) { |
| case EOF: |
| // We've seen a premature EOF. Break out |
| // of the loop. |
| env.error(pos, "eof.in.comment"); |
| ch = EOF; |
| break outerLoop; |
| |
| case '*': |
| // Is this just a star? Or is this the |
| // end of a comment? |
| c = in.read(); |
| if (c == '/') { |
| // This is the end of the comment, |
| // set ch and return our buffer. |
| ch = in.read(); |
| break outerLoop; |
| } |
| // This is just an ordinary star. Add it to |
| // the buffer. |
| if (count == buffer.length) { |
| growBuffer(); |
| buffer = this.buffer; |
| } |
| buffer[count++] = '*'; |
| break; |
| |
| case '\n': |
| // We've seen a newline. Add it to our |
| // buffer and break out of this loop, |
| // starting fresh on a new line. |
| if (count == buffer.length) { |
| growBuffer(); |
| buffer = this.buffer; |
| } |
| buffer[count++] = '\n'; |
| c = in.read(); |
| break textLoop; |
| |
| // Again, the extra cases here are a trick |
| // to get the compiler to generate a tableswitch. |
| case 0: case 1: case 2: case 3: case 4: case 5: |
| case 6: case 7: case 8: case 11: case 12: case 13: |
| case 14: case 15: case 16: case 17: case 18: case 19: |
| case 20: case 21: case 22: case 23: case 24: case 25: |
| case 26: case 27: case 28: case 29: case 30: case 31: |
| case 32: case 33: case 34: case 35: case 36: case 37: |
| case 38: case 39: case 40: |
| default: |
| // Add the character to our buffer. |
| if (count == buffer.length) { |
| growBuffer(); |
| buffer = this.buffer; |
| } |
| buffer[count++] = (char)c; |
| c = in.read(); |
| break; |
| } |
| } // end textLoop |
| } // end outerLoop |
| |
| // We have scanned our doc comment. It is stored in |
| // buffer. The previous implementation of scanDocComment |
| // stripped off all trailing spaces and stars from the comment. |
| // We will do this as well, so as to cause a minimum of |
| // disturbance. Is this what we want? |
| if (count > 0) { |
| int i = count - 1; |
| trailLoop: |
| while (i > -1) { |
| switch (buffer[i]) { |
| case ' ': |
| case '\t': |
| case '*': |
| i--; |
| break; |
| // And again, the extra cases here are a trick |
| // to get the compiler to generate a tableswitch. |
| case 0: case 1: case 2: case 3: case 4: case 5: |
| case 6: case 7: case 8: case 10: case 11: case 12: |
| case 13: case 14: case 15: case 16: case 17: case 18: |
| case 19: case 20: case 21: case 22: case 23: case 24: |
| case 25: case 26: case 27: case 28: case 29: case 30: |
| case 31: case 33: case 34: case 35: case 36: case 37: |
| case 38: case 39: case 40: |
| default: |
| break trailLoop; |
| } |
| } |
| count = i + 1; |
| |
| // Return the text of the doc comment. |
| return new String(buffer, 0, count); |
| } else { |
| return ""; |
| } |
| } |
| |
| /** |
| * Scan a number. The first digit of the number should be the current |
| * character. We may be scanning hex, decimal, or octal at this point |
| */ |
| private void scanNumber() throws IOException { |
| boolean seenNonOctal = false; |
| boolean overflow = false; |
| boolean seenDigit = false; // used to detect invalid hex number 0xL |
| radix = (ch == '0' ? 8 : 10); |
| long value = ch - '0'; |
| count = 0; |
| putc(ch); // save character in buffer |
| numberLoop: |
| for (;;) { |
| switch (ch = in.read()) { |
| case '.': |
| if (radix == 16) |
| break numberLoop; // an illegal character |
| scanReal(); |
| return; |
| |
| case '8': case '9': |
| // We can't yet throw an error if reading an octal. We might |
| // discover we're really reading a real. |
| seenNonOctal = true; |
| case '0': case '1': case '2': case '3': |
| case '4': case '5': case '6': case '7': |
| seenDigit = true; |
| putc(ch); |
| if (radix == 10) { |
| overflow = overflow || (value * 10)/10 != value; |
| value = (value * 10) + (ch - '0'); |
| overflow = overflow || (value - 1 < -1); |
| } else if (radix == 8) { |
| overflow = overflow || (value >>> 61) != 0; |
| value = (value << 3) + (ch - '0'); |
| } else { |
| overflow = overflow || (value >>> 60) != 0; |
| value = (value << 4) + (ch - '0'); |
| } |
| break; |
| |
| case 'd': case 'D': case 'e': case 'E': case 'f': case 'F': |
| if (radix != 16) { |
| scanReal(); |
| return; |
| } |
| // fall through |
| case 'a': case 'A': case 'b': case 'B': case 'c': case 'C': |
| seenDigit = true; |
| putc(ch); |
| if (radix != 16) |
| break numberLoop; // an illegal character |
| overflow = overflow || (value >>> 60) != 0; |
| value = (value << 4) + 10 + |
| Character.toLowerCase((char)ch) - 'a'; |
| break; |
| |
| case 'l': case 'L': |
| ch = in.read(); // skip over 'l' |
| longValue = value; |
| token = LONGVAL; |
| break numberLoop; |
| |
| case 'x': case 'X': |
| // if the first character is a '0' and this is the second |
| // letter, then read in a hexadecimal number. Otherwise, error. |
| if (count == 1 && radix == 8) { |
| radix = 16; |
| seenDigit = false; |
| break; |
| } else { |
| // we'll get an illegal character error |
| break numberLoop; |
| } |
| |
| default: |
| intValue = (int)value; |
| token = INTVAL; |
| break numberLoop; |
| } |
| } // while true |
| |
| // We have just finished reading the number. The next thing better |
| // not be a letter or digit. |
| // Note: There will be deprecation warnings against these uses |
| // of Character.isJavaLetterOrDigit and Character.isJavaLetter. |
| // Do not fix them yet; allow the compiler to run on pre-JDK1.1 VMs. |
| if (Character.isJavaLetterOrDigit((char)ch) || ch == '.') { |
| env.error(in.pos, "invalid.number"); |
| do { ch = in.read(); } |
| while (Character.isJavaLetterOrDigit((char)ch) || ch == '.'); |
| intValue = 0; |
| token = INTVAL; |
| } else if (radix == 8 && seenNonOctal) { |
| // A bogus octal literal. |
| intValue = 0; |
| token = INTVAL; |
| env.error(pos, "invalid.octal.number"); |
| } else if (radix == 16 && seenDigit == false) { |
| // A hex literal with no digits, 0xL, for example. |
| intValue = 0; |
| token = INTVAL; |
| env.error(pos, "invalid.hex.number"); |
| } else { |
| if (token == INTVAL) { |
| // Check for overflow. Note that base 10 literals |
| // have different rules than base 8 and 16. |
| overflow = overflow || |
| (value & 0xFFFFFFFF00000000L) != 0 || |
| (radix == 10 && value > 2147483648L); |
| |
| if (overflow) { |
| intValue = 0; |
| |
| // Give a specific error message which tells |
| // the user the range. |
| switch (radix) { |
| case 8: |
| env.error(pos, "overflow.int.oct"); |
| break; |
| case 10: |
| env.error(pos, "overflow.int.dec"); |
| break; |
| case 16: |
| env.error(pos, "overflow.int.hex"); |
| break; |
| default: |
| throw new CompilerError("invalid radix"); |
| } |
| } |
| } else { |
| if (overflow) { |
| longValue = 0; |
| |
| // Give a specific error message which tells |
| // the user the range. |
| switch (radix) { |
| case 8: |
| env.error(pos, "overflow.long.oct"); |
| break; |
| case 10: |
| env.error(pos, "overflow.long.dec"); |
| break; |
| case 16: |
| env.error(pos, "overflow.long.hex"); |
| break; |
| default: |
| throw new CompilerError("invalid radix"); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Scan a float. We are either looking at the decimal, or we have already |
| * seen it and put it into the buffer. We haven't seen an exponent. |
| * Scan a float. Should be called with the current character is either |
| * the 'e', 'E' or '.' |
| */ |
| private void scanReal() throws IOException { |
| boolean seenExponent = false; |
| boolean isSingleFloat = false; |
| char lastChar; |
| if (ch == '.') { |
| putc(ch); |
| ch = in.read(); |
| } |
| |
| numberLoop: |
| for ( ; ; ch = in.read()) { |
| switch (ch) { |
| case '0': case '1': case '2': case '3': case '4': |
| case '5': case '6': case '7': case '8': case '9': |
| putc(ch); |
| break; |
| |
| case 'e': case 'E': |
| if (seenExponent) |
| break numberLoop; // we'll get a format error |
| putc(ch); |
| seenExponent = true; |
| break; |
| |
| case '+': case '-': |
| lastChar = buffer[count - 1]; |
| if (lastChar != 'e' && lastChar != 'E') |
| break numberLoop; // this isn't an error, though! |
| putc(ch); |
| break; |
| |
| case 'f': case 'F': |
| ch = in.read(); // skip over 'f' |
| isSingleFloat = true; |
| break numberLoop; |
| |
| case 'd': case 'D': |
| ch = in.read(); // skip over 'd' |
| // fall through |
| default: |
| break numberLoop; |
| } // sswitch |
| } // loop |
| |
| // we have just finished reading the number. The next thing better |
| // not be a letter or digit. |
| if (Character.isJavaLetterOrDigit((char)ch) || ch == '.') { |
| env.error(in.pos, "invalid.number"); |
| do { ch = in.read(); } |
| while (Character.isJavaLetterOrDigit((char)ch) || ch == '.'); |
| doubleValue = 0; |
| token = DOUBLEVAL; |
| } else { |
| token = isSingleFloat ? FLOATVAL : DOUBLEVAL; |
| try { |
| lastChar = buffer[count - 1]; |
| if (lastChar == 'e' || lastChar == 'E' |
| || lastChar == '+' || lastChar == '-') { |
| env.error(in.pos -1, "float.format"); |
| } else if (isSingleFloat) { |
| String string = bufferString(); |
| floatValue = Float.valueOf(string).floatValue(); |
| if (Float.isInfinite(floatValue)) { |
| env.error(pos, "overflow.float"); |
| } else if (floatValue == 0 && !looksLikeZero(string)) { |
| env.error(pos, "underflow.float"); |
| } |
| } else { |
| String string = bufferString(); |
| doubleValue = Double.valueOf(string).doubleValue(); |
| if (Double.isInfinite(doubleValue)) { |
| env.error(pos, "overflow.double"); |
| } else if (doubleValue == 0 && !looksLikeZero(string)) { |
| env.error(pos, "underflow.double"); |
| } |
| } |
| } catch (NumberFormatException ee) { |
| env.error(pos, "float.format"); |
| doubleValue = 0; |
| floatValue = 0; |
| } |
| } |
| return; |
| } |
| |
| // We have a token that parses as a number. Is this token possibly zero? |
| // i.e. does it have a non-zero value in the mantissa? |
| private static boolean looksLikeZero(String token) { |
| int length = token.length(); |
| for (int i = 0; i < length; i++) { |
| switch (token.charAt(i)) { |
| case 0: case '.': |
| continue; |
| case '1': case '2': case '3': case '4': case '5': |
| case '6': case '7': case '8': case '9': |
| return false; |
| case 'e': case 'E': case 'f': case 'F': |
| return true; |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Scan an escape character. |
| * @return the character or -1 if it escaped an |
| * end-of-line. |
| */ |
| private int scanEscapeChar() throws IOException { |
| long p = in.pos; |
| |
| switch (ch = in.read()) { |
| case '0': case '1': case '2': case '3': |
| case '4': case '5': case '6': case '7': { |
| int n = ch - '0'; |
| for (int i = 2 ; i > 0 ; i--) { |
| switch (ch = in.read()) { |
| case '0': case '1': case '2': case '3': |
| case '4': case '5': case '6': case '7': |
| n = (n << 3) + ch - '0'; |
| break; |
| |
| default: |
| if (n > 0xFF) { |
| env.error(p, "invalid.escape.char"); |
| } |
| return n; |
| } |
| } |
| ch = in.read(); |
| if (n > 0xFF) { |
| env.error(p, "invalid.escape.char"); |
| } |
| return n; |
| } |
| |
| case 'r': ch = in.read(); return '\r'; |
| case 'n': ch = in.read(); return '\n'; |
| case 'f': ch = in.read(); return '\f'; |
| case 'b': ch = in.read(); return '\b'; |
| case 't': ch = in.read(); return '\t'; |
| case '\\': ch = in.read(); return '\\'; |
| case '\"': ch = in.read(); return '\"'; |
| case '\'': ch = in.read(); return '\''; |
| } |
| |
| env.error(p, "invalid.escape.char"); |
| ch = in.read(); |
| return -1; |
| } |
| |
| /** |
| * Scan a string. The current character |
| * should be the opening " of the string. |
| */ |
| private void scanString() throws IOException { |
| token = STRINGVAL; |
| count = 0; |
| ch = in.read(); |
| |
| // Scan a String |
| while (true) { |
| switch (ch) { |
| case EOF: |
| env.error(pos, "eof.in.string"); |
| stringValue = bufferString(); |
| return; |
| |
| case '\r': |
| case '\n': |
| ch = in.read(); |
| env.error(pos, "newline.in.string"); |
| stringValue = bufferString(); |
| return; |
| |
| case '"': |
| ch = in.read(); |
| stringValue = bufferString(); |
| return; |
| |
| case '\\': { |
| int c = scanEscapeChar(); |
| if (c >= 0) { |
| putc((char)c); |
| } |
| break; |
| } |
| |
| default: |
| putc(ch); |
| ch = in.read(); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Scan a character. The current character should be |
| * the opening ' of the character constant. |
| */ |
| private void scanCharacter() throws IOException { |
| token = CHARVAL; |
| |
| switch (ch = in.read()) { |
| case '\\': |
| int c = scanEscapeChar(); |
| charValue = (char)((c >= 0) ? c : 0); |
| break; |
| |
| case '\'': |
| // There are two standard problems this case deals with. One |
| // is the malformed single quote constant (i.e. the programmer |
| // uses ''' instead of '\'') and the other is the empty |
| // character constant (i.e. ''). Just consume any number of |
| // single quotes and emit an error message. |
| charValue = 0; |
| env.error(pos, "invalid.char.constant"); |
| ch = in.read(); |
| while (ch == '\'') { |
| ch = in.read(); |
| } |
| return; |
| |
| case '\r': |
| case '\n': |
| charValue = 0; |
| env.error(pos, "invalid.char.constant"); |
| return; |
| |
| default: |
| charValue = (char)ch; |
| ch = in.read(); |
| break; |
| } |
| |
| if (ch == '\'') { |
| ch = in.read(); |
| } else { |
| env.error(pos, "invalid.char.constant"); |
| while (true) { |
| switch (ch) { |
| case '\'': |
| ch = in.read(); |
| return; |
| case ';': |
| case '\n': |
| case EOF: |
| return; |
| default: |
| ch = in.read(); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Scan an Identifier. The current character should |
| * be the first character of the identifier. |
| */ |
| private void scanIdentifier() throws IOException { |
| count = 0; |
| |
| while (true) { |
| putc(ch); |
| switch (ch = in.read()) { |
| case 'a': case 'b': case 'c': case 'd': case 'e': |
| case 'f': case 'g': case 'h': case 'i': case 'j': |
| case 'k': case 'l': case 'm': case 'n': case 'o': |
| case 'p': case 'q': case 'r': case 's': case 't': |
| case 'u': case 'v': case 'w': case 'x': case 'y': |
| case 'z': |
| case 'A': case 'B': case 'C': case 'D': case 'E': |
| case 'F': case 'G': case 'H': case 'I': case 'J': |
| case 'K': case 'L': case 'M': case 'N': case 'O': |
| case 'P': case 'Q': case 'R': case 'S': case 'T': |
| case 'U': case 'V': case 'W': case 'X': case 'Y': |
| case 'Z': |
| case '0': case '1': case '2': case '3': case '4': |
| case '5': case '6': case '7': case '8': case '9': |
| case '$': case '_': |
| break; |
| |
| default: |
| if (!Character.isJavaLetterOrDigit((char)ch)) { |
| idValue = Identifier.lookup(bufferString()); |
| token = idValue.getType(); |
| return; |
| } |
| } |
| } |
| } |
| |
| /** |
| * The ending position of the current token |
| */ |
| // Note: This should be part of the pos itself. |
| public long getEndPos() { |
| return in.pos; |
| } |
| |
| /** |
| * If the current token is IDENT, return the identifier occurrence. |
| * It will be freshly allocated. |
| */ |
| public IdentifierToken getIdToken() { |
| return (token != IDENT) ? null : new IdentifierToken(pos, idValue); |
| } |
| |
| /** |
| * Scan the next token. |
| * @return the position of the previous token. |
| */ |
| public long scan() throws IOException { |
| return xscan(); |
| } |
| |
| protected long xscan() throws IOException { |
| final ScannerInputReader in = this.in; |
| long retPos = pos; |
| prevPos = in.pos; |
| docComment = null; |
| while (true) { |
| pos = in.pos; |
| |
| switch (ch) { |
| case EOF: |
| token = EOF; |
| return retPos; |
| |
| case '\n': |
| if (scanComments) { |
| ch = ' '; |
| // Avoid this path the next time around. |
| // Do not just call in.read; we want to present |
| // a null token (and also avoid read-ahead). |
| token = COMMENT; |
| return retPos; |
| } |
| case ' ': |
| case '\t': |
| case '\f': |
| ch = in.read(); |
| break; |
| |
| case '/': |
| switch (ch = in.read()) { |
| case '/': |
| // Parse a // comment |
| while (((ch = in.read()) != EOF) && (ch != '\n')); |
| if (scanComments) { |
| token = COMMENT; |
| return retPos; |
| } |
| break; |
| |
| case '*': |
| ch = in.read(); |
| if (ch == '*') { |
| docComment = scanDocComment(); |
| } else { |
| skipComment(); |
| } |
| if (scanComments) { |
| return retPos; |
| } |
| break; |
| |
| case '=': |
| ch = in.read(); |
| token = ASGDIV; |
| return retPos; |
| |
| default: |
| token = DIV; |
| return retPos; |
| } |
| break; |
| |
| case '"': |
| scanString(); |
| return retPos; |
| |
| case '\'': |
| scanCharacter(); |
| return retPos; |
| |
| case '0': case '1': case '2': case '3': case '4': |
| case '5': case '6': case '7': case '8': case '9': |
| scanNumber(); |
| return retPos; |
| |
| case '.': |
| switch (ch = in.read()) { |
| case '0': case '1': case '2': case '3': case '4': |
| case '5': case '6': case '7': case '8': case '9': |
| count = 0; |
| putc('.'); |
| scanReal(); |
| break; |
| default: |
| token = FIELD; |
| } |
| return retPos; |
| |
| case '{': |
| ch = in.read(); |
| token = LBRACE; |
| return retPos; |
| |
| case '}': |
| ch = in.read(); |
| token = RBRACE; |
| return retPos; |
| |
| case '(': |
| ch = in.read(); |
| token = LPAREN; |
| return retPos; |
| |
| case ')': |
| ch = in.read(); |
| token = RPAREN; |
| return retPos; |
| |
| case '[': |
| ch = in.read(); |
| token = LSQBRACKET; |
| return retPos; |
| |
| case ']': |
| ch = in.read(); |
| token = RSQBRACKET; |
| return retPos; |
| |
| case ',': |
| ch = in.read(); |
| token = COMMA; |
| return retPos; |
| |
| case ';': |
| ch = in.read(); |
| token = SEMICOLON; |
| return retPos; |
| |
| case '?': |
| ch = in.read(); |
| token = QUESTIONMARK; |
| return retPos; |
| |
| case '~': |
| ch = in.read(); |
| token = BITNOT; |
| return retPos; |
| |
| case ':': |
| ch = in.read(); |
| token = COLON; |
| return retPos; |
| |
| case '-': |
| switch (ch = in.read()) { |
| case '-': |
| ch = in.read(); |
| token = DEC; |
| return retPos; |
| |
| case '=': |
| ch = in.read(); |
| token = ASGSUB; |
| return retPos; |
| } |
| token = SUB; |
| return retPos; |
| |
| case '+': |
| switch (ch = in.read()) { |
| case '+': |
| ch = in.read(); |
| token = INC; |
| return retPos; |
| |
| case '=': |
| ch = in.read(); |
| token = ASGADD; |
| return retPos; |
| } |
| token = ADD; |
| return retPos; |
| |
| case '<': |
| switch (ch = in.read()) { |
| case '<': |
| if ((ch = in.read()) == '=') { |
| ch = in.read(); |
| token = ASGLSHIFT; |
| return retPos; |
| } |
| token = LSHIFT; |
| return retPos; |
| |
| case '=': |
| ch = in.read(); |
| token = LE; |
| return retPos; |
| } |
| token = LT; |
| return retPos; |
| |
| case '>': |
| switch (ch = in.read()) { |
| case '>': |
| switch (ch = in.read()) { |
| case '=': |
| ch = in.read(); |
| token = ASGRSHIFT; |
| return retPos; |
| |
| case '>': |
| if ((ch = in.read()) == '=') { |
| ch = in.read(); |
| token = ASGURSHIFT; |
| return retPos; |
| } |
| token = URSHIFT; |
| return retPos; |
| } |
| token = RSHIFT; |
| return retPos; |
| |
| case '=': |
| ch = in.read(); |
| token = GE; |
| return retPos; |
| } |
| token = GT; |
| return retPos; |
| |
| case '|': |
| switch (ch = in.read()) { |
| case '|': |
| ch = in.read(); |
| token = OR; |
| return retPos; |
| |
| case '=': |
| ch = in.read(); |
| token = ASGBITOR; |
| return retPos; |
| } |
| token = BITOR; |
| return retPos; |
| |
| case '&': |
| switch (ch = in.read()) { |
| case '&': |
| ch = in.read(); |
| token = AND; |
| return retPos; |
| |
| case '=': |
| ch = in.read(); |
| token = ASGBITAND; |
| return retPos; |
| } |
| token = BITAND; |
| return retPos; |
| |
| case '=': |
| if ((ch = in.read()) == '=') { |
| ch = in.read(); |
| token = EQ; |
| return retPos; |
| } |
| token = ASSIGN; |
| return retPos; |
| |
| case '%': |
| if ((ch = in.read()) == '=') { |
| ch = in.read(); |
| token = ASGREM; |
| return retPos; |
| } |
| token = REM; |
| return retPos; |
| |
| case '^': |
| if ((ch = in.read()) == '=') { |
| ch = in.read(); |
| token = ASGBITXOR; |
| return retPos; |
| } |
| token = BITXOR; |
| return retPos; |
| |
| case '!': |
| if ((ch = in.read()) == '=') { |
| ch = in.read(); |
| token = NE; |
| return retPos; |
| } |
| token = NOT; |
| return retPos; |
| |
| case '*': |
| if ((ch = in.read()) == '=') { |
| ch = in.read(); |
| token = ASGMUL; |
| return retPos; |
| } |
| token = MUL; |
| return retPos; |
| |
| case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': |
| case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': |
| case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': |
| case 's': case 't': case 'u': case 'v': case 'w': case 'x': |
| case 'y': case 'z': |
| case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': |
| case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': |
| case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': |
| case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': |
| case 'Y': case 'Z': |
| case '$': case '_': |
| scanIdentifier(); |
| return retPos; |
| |
| case '\u001a': |
| // Our one concession to DOS. |
| if ((ch = in.read()) == EOF) { |
| token = EOF; |
| return retPos; |
| } |
| env.error(pos, "funny.char"); |
| ch = in.read(); |
| break; |
| |
| |
| default: |
| if (Character.isJavaLetter((char)ch)) { |
| scanIdentifier(); |
| return retPos; |
| } |
| env.error(pos, "funny.char"); |
| ch = in.read(); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Scan to a matching '}', ']' or ')'. The current token must be |
| * a '{', '[' or '('; |
| */ |
| public void match(int open, int close) throws IOException { |
| int depth = 1; |
| |
| while (true) { |
| scan(); |
| if (token == open) { |
| depth++; |
| } else if (token == close) { |
| if (--depth == 0) { |
| return; |
| } |
| } else if (token == EOF) { |
| env.error(pos, "unbalanced.paren"); |
| return; |
| } |
| } |
| } |
| } |
