/*

 * 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

     */

    @SuppressWarnings("fallthrough")

    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