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;

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;

/**

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;

}

}

}