/*

 * Copyright (c) 1995, 2003, 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.io.InputStreamReader;

import java.io.BufferedReader;

import java.io.FilterReader;

import java.io.UnsupportedEncodingException;

/**

 * An input stream for java programs. The stream treats either "\n", "\r"

 * or "\r\n" as the end of a line, it always returns \n. It also parses

 * UNICODE characters expressed as \uffff. However, if it sees "\\", the

 * second slash cannot begin a unicode sequence. It keeps track of the current

 * position in the input stream.

 *

 * 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 ScannerInputReader extends FilterReader implements Constants {

    // A note.  This class does not really properly subclass FilterReader.

    // Since this class only overrides the single character read method,

    // and not the multi-character read method, any use of the latter

    // will not work properly.  Any attempt to use this code outside of

    // the compiler should take that into account.

    //

    // For efficiency, it might be worth moving this code to Scanner and

    // getting rid of this class.

    Environment env;

    long pos;

    private long chpos;

    private int pushBack = -1;

    public ScannerInputReader(Environment env, InputStream in)

        throws UnsupportedEncodingException

    {

        // ScannerInputStream has been modified to no longer use

        // BufferedReader.  It now does its own buffering for

        // performance.

        super(env.getCharacterEncoding() != null ?

              new InputStreamReader(in, env.getCharacterEncoding()) :

              new InputStreamReader(in));

        // Start out the buffer empty.

        currentIndex = 0;

        numChars = 0;

        this.env = env;

        chpos = Scanner.LINEINC;

    }

    //------------------------------------------------------------

    // Buffering code.

    // The size of our buffer.

    private static final int BUFFERLEN = 10 * 1024;

    // A character buffer.

    private final char[] buffer = new char[BUFFERLEN];

    // The index of the next character to be "read" from the buffer.

    private int currentIndex;

    // The number of characters in the buffer.  -1 if EOF is reached.

    private int numChars;

    /**

     * Get the next character from our buffer.

     * Note: this method has been inlined by hand in the `read' method

     * below.  Any changes made to this method should be equally applied

     * to that code.

     */

    private int getNextChar() throws IOException {

        // Check to see if we have either run out of characters in our

        // buffer or gotten to EOF on a previous call.

        if (currentIndex >= numChars) {

            numChars = in.read(buffer);

            if (numChars == -1) {

                // We have reached EOF.

                return -1;

            }

            // No EOF.  currentIndex points to first char in buffer.

            currentIndex = 0;

        }

        return buffer[currentIndex++];

    }

    //------------------------------------------------------------

    public int read(char[] buffer, int off, int len) {

        throw new CompilerError(

                   "ScannerInputReader is not a fully implemented reader.");

    }

    public int read() throws IOException {

        pos = chpos;

        chpos += Scanner.OFFSETINC;

        int c = pushBack;

        if (c == -1) {

        getchar: try {

                // Here the call...

                //     c = getNextChar();

                // has been inlined by hand for performance.

                if (currentIndex >= numChars) {

                    numChars = in.read(buffer);

                    if (numChars == -1) {

                        // We have reached EOF.

                        c = -1;

                        break getchar;

                    }

                    // No EOF.  currentIndex points to first char in buffer.

                    currentIndex = 0;

                }

                c = buffer[currentIndex++];

            } catch (java.io.CharConversionException e) {

                env.error(pos, "invalid.encoding.char");

                // this is fatal error

                return -1;

            }

        } else {

            pushBack = -1;

        }

        // parse special characters

        switch (c) {

          case -2:

            // -2 is a special code indicating a pushback of a backslash that

            // definitely isn't the start of a unicode sequence.

            return '\\';

          case '\\':

            if ((c = getNextChar()) != 'u') {

                pushBack = (c == '\\' ? -2 : c);

                return '\\';

            }

            // we have a unicode sequence

            chpos += Scanner.OFFSETINC;

            while ((c = getNextChar()) == 'u') {

                chpos += Scanner.OFFSETINC;

            }

            // unicode escape sequence

            int d = 0;

            for (int i = 0 ; i < 4 ; i++, chpos += Scanner.OFFSETINC, c = getNextChar()) {

                switch (c) {

                  case '0': case '1': case '2': case '3': case '4':

                  case '5': case '6': case '7': case '8': case '9':

                    d = (d << 4) + c - '0';

                    break;

                  case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':

                    d = (d << 4) + 10 + c - 'a';

                    break;

                  case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':

                    d = (d << 4) + 10 + c - 'A';

                    break;

                  default:

                    env.error(pos, "invalid.escape.char");

                    pushBack = c;

                    return d;

                }

            }

            pushBack = c;

            // To read the following line, switch \ and /...

            // Handle /u000a, /u000A, /u000d, /u000D properly as

            // line terminators as per JLS 3.4, even though they are encoded

            // (this properly respects the order given in JLS 3.2).

            switch (d) {

                case '\n':

                   chpos += Scanner.LINEINC;

                    return '\n';

                case '\r':

                    if ((c = getNextChar()) != '\n') {

                        pushBack = c;

                    } else {

                        chpos += Scanner.OFFSETINC;

                    }

                    chpos += Scanner.LINEINC;

                    return '\n';

                default:

                    return d;

            }

          case '\n':

            chpos += Scanner.LINEINC;

            return '\n';

          case '\r':

            if ((c = getNextChar()) != '\n') {

                pushBack = c;

            } else {

                chpos += Scanner.OFFSETINC;

            }

            chpos += Scanner.LINEINC;

            return '\n';

          default:

            return c;

        }

    }

}