templates.gwt.JavaCharStream.template Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of javacc Show documentation
Show all versions of javacc Show documentation
JavaCC is a parser/scanner generator for Java.
/**
* An implementation of interface CharStream, where the stream is assumed to
* contain only ASCII characters (with java-like unicode escape processing).
*/
#if SUPPORT_CLASS_VISIBILITY_PUBLIC
public
#fi
class JavaCharStream
{
/** Whether parser is static. */
public static final boolean staticFlag = ${STATIC};
static final int hexval(char c) throws java.io.IOException {
switch(c)
{
case '0' :
return 0;
case '1' :
return 1;
case '2' :
return 2;
case '3' :
return 3;
case '4' :
return 4;
case '5' :
return 5;
case '6' :
return 6;
case '7' :
return 7;
case '8' :
return 8;
case '9' :
return 9;
case 'a' :
case 'A' :
return 10;
case 'b' :
case 'B' :
return 11;
case 'c' :
case 'C' :
return 12;
case 'd' :
case 'D' :
return 13;
case 'e' :
case 'E' :
return 14;
case 'f' :
case 'F' :
return 15;
}
throw new java.io.IOException(); // Should never come here
}
/** Position in buffer. */
${PREFIX}public int bufpos = -1;
${PREFIX}int bufsize;
${PREFIX}int available;
${PREFIX}int tokenBegin;
#if KEEP_LINE_COLUMN
${PREFIX}protected int bufline[];
${PREFIX}protected int bufcolumn[];
${PREFIX}protected int column = 0;
${PREFIX}protected int line = 1;
${PREFIX}protected boolean prevCharIsCR = false;
${PREFIX}protected boolean prevCharIsLF = false;
#fi
${PREFIX}protected Provider inputStream;
${PREFIX}protected char[] nextCharBuf;
${PREFIX}protected char[] buffer;
${PREFIX}protected int maxNextCharInd = 0;
${PREFIX}protected int nextCharInd = -1;
${PREFIX}protected int inBuf = 0;
${PREFIX}protected int tabSize = 1;
#if KEEP_LINE_COLUMN
${PREFIX}protected boolean trackLineColumn = true;
#else
${PREFIX}protected boolean trackLineColumn = false;
#fi
${PREFIX}public void setTabSize(int i) { tabSize = i; }
${PREFIX}public int getTabSize(int i) { return tabSize; }
${PREFIX}protected void ExpandBuff(boolean wrapAround)
{
char[] newbuffer = new char[bufsize + 2048];
#if KEEP_LINE_COLUMN
int newbufline[] = new int[bufsize + 2048];
int newbufcolumn[] = new int[bufsize + 2048];
#fi
try
{
if (wrapAround)
{
System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
System.arraycopy(buffer, 0, newbuffer, bufsize - tokenBegin, bufpos);
buffer = newbuffer;
#if KEEP_LINE_COLUMN
System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
bufline = newbufline;
System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
bufcolumn = newbufcolumn;
#fi
bufpos += (bufsize - tokenBegin);
}
else
{
System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
buffer = newbuffer;
#if KEEP_LINE_COLUMN
System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
bufline = newbufline;
System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
bufcolumn = newbufcolumn;
#fi
bufpos -= tokenBegin;
}
}
catch (${LEGACY_EXCEPTION_HANDLING?Throwable:Exception} t)
{
throw new ${LEGACY_EXCEPTION_HANDLING?Error:RuntimeException}(t.getMessage());
}
available = (bufsize += 2048);
tokenBegin = 0;
}
${PREFIX}protected void FillBuff() throws java.io.IOException
{
int i;
if (maxNextCharInd == 4096)
maxNextCharInd = nextCharInd = 0;
try {
if ((i = inputStream.read(nextCharBuf, maxNextCharInd,
4096 - maxNextCharInd)) == -1)
{
inputStream.close();
throw new java.io.IOException();
}
else
maxNextCharInd += i;
return;
}
catch(java.io.IOException e) {
if (bufpos != 0)
{
--bufpos;
backup(0);
}
#if KEEP_LINE_COLUMN
else
{
bufline[bufpos] = line;
bufcolumn[bufpos] = column;
}
#fi
throw e;
}
}
${PREFIX}protected char ReadByte() throws java.io.IOException
{
if (++nextCharInd >= maxNextCharInd)
FillBuff();
return nextCharBuf[nextCharInd];
}
/** @return starting character for token. */
${PREFIX}public char BeginToken() throws java.io.IOException
{
if (inBuf > 0)
{
--inBuf;
if (++bufpos == bufsize)
bufpos = 0;
tokenBegin = bufpos;
return buffer[bufpos];
}
tokenBegin = 0;
bufpos = -1;
return readChar();
}
${PREFIX}protected void AdjustBuffSize()
{
if (available == bufsize)
{
if (tokenBegin > 2048)
{
bufpos = 0;
available = tokenBegin;
}
else
ExpandBuff(false);
}
else if (available > tokenBegin)
available = bufsize;
else if ((tokenBegin - available) < 2048)
ExpandBuff(true);
else
available = tokenBegin;
}
#if KEEP_LINE_COLUMN
${PREFIX}protected void UpdateLineColumn(char c)
{
column++;
if (prevCharIsLF)
{
prevCharIsLF = false;
line += (column = 1);
}
else if (prevCharIsCR)
{
prevCharIsCR = false;
if (c == '\n')
{
prevCharIsLF = true;
}
else
line += (column = 1);
}
switch (c)
{
case '\r' :
prevCharIsCR = true;
break;
case '\n' :
prevCharIsLF = true;
break;
case '\t' :
column--;
column += (tabSize - (column % tabSize));
break;
default :
break;
}
bufline[bufpos] = line;
bufcolumn[bufpos] = column;
}
#fi
/** Read a character. */
${PREFIX}public char readChar() throws java.io.IOException
{
if (inBuf > 0)
{
--inBuf;
if (++bufpos == bufsize)
bufpos = 0;
return buffer[bufpos];
}
char c;
if (++bufpos == available)
AdjustBuffSize();
if ((buffer[bufpos] = c = ReadByte()) == '\\')
{
#if KEEP_LINE_COLUMN
UpdateLineColumn(c);
#fi
int backSlashCnt = 1;
for (;;) // Read all the backslashes
{
if (++bufpos == available)
AdjustBuffSize();
try
{
if ((buffer[bufpos] = c = ReadByte()) != '\\')
{
UpdateLineColumn(c);
// found a non-backslash char.
if ((c == 'u') && ((backSlashCnt & 1) == 1))
{
if (--bufpos < 0)
bufpos = bufsize - 1;
break;
}
backup(backSlashCnt);
return '\\';
}
}
catch(java.io.IOException e)
{
// We are returning one backslash so we should only backup (count-1)
if (backSlashCnt > 1)
backup(backSlashCnt-1);
return '\\';
}
#if KEEP_LINE_COLUMN
UpdateLineColumn(c);
#fi
backSlashCnt++;
}
// Here, we have seen an odd number of backslash's followed by a 'u'
try
{
while ((c = ReadByte()) == 'u')
#if KEEP_LINE_COLUMN
++column;
#else
;
#fi
buffer[bufpos] = c = (char)(hexval(c) << 12 |
hexval(ReadByte()) << 8 |
hexval(ReadByte()) << 4 |
hexval(ReadByte()));
#if KEEP_LINE_COLUMN
column += 4;
#fi
}
catch(java.io.IOException e)
{
#if KEEP_LINE_COLUMN
throw new ${LEGACY_EXCEPTION_HANDLING?Error:RuntimeException}("Invalid escape character at line " + line +
" column " + column + ".");
#else
throw new ${LEGACY_EXCEPTION_HANDLING?Error:RuntimeException}(\"Invalid escape character in input\");
#fi
}
if (backSlashCnt == 1)
return c;
else
{
backup(backSlashCnt - 1);
return '\\';
}
}
else
{
#if KEEP_LINE_COLUMN
UpdateLineColumn(c);
#fi
return c;
}
}
#if GENERATE_ANNOTATIONS
@Deprecated
#fi
/**
* @deprecated
* @see #getEndColumn
*/
@Deprecated
${PREFIX}public int getColumn() {
#if KEEP_LINE_COLUMN
return bufcolumn[bufpos];
#else
return -1;
#fi
}
#if GENERATE_ANNOTATIONS
@Deprecated
#fi
/**
* @deprecated
* @see #getEndLine
*/
@Deprecated
${PREFIX}public int getLine() {
#if KEEP_LINE_COLUMN
return bufline[bufpos];
#else
return -1;
#fi
}
/** Get end column. */
${PREFIX}public int getEndColumn() {
#if KEEP_LINE_COLUMN
return bufcolumn[bufpos];
#else
return -1;
#fi
}
/** Get end line. */
${PREFIX}public int getEndLine() {
#if KEEP_LINE_COLUMN
return bufline[bufpos];
#else
return -1;
#fi
}
/** @return column of token start */
${PREFIX}public int getBeginColumn() {
#if KEEP_LINE_COLUMN
return bufcolumn[tokenBegin];
#else
return -1;
#fi
}
/** @return line number of token start */
${PREFIX}public int getBeginLine() {
#if KEEP_LINE_COLUMN
return bufline[tokenBegin];
#else
return -1;
#fi
}
/** Retreat. */
${PREFIX}public void backup(int amount) {
inBuf += amount;
if ((bufpos -= amount) < 0)
bufpos += bufsize;
}
/** Constructor. */
public JavaCharStream(Provider dstream,
int startline, int startcolumn, int buffersize)
{
#if STATIC
if (inputStream != null)
throw new ${LEGACY_EXCEPTION_HANDLING?Error:RuntimeException}("\n ERROR: Second call to the constructor of a static JavaCharStream.\n" +
" You must either use ReInit() or set the JavaCC option STATIC to false\n" +
" during the generation of this class.");
#fi
inputStream = dstream;
#if KEEP_LINE_COLUMN
line = startline;
column = startcolumn - 1;
#fi
available = bufsize = buffersize;
buffer = new char[buffersize];
#if KEEP_LINE_COLUMN
bufline = new int[buffersize];
bufcolumn = new int[buffersize];
#fi
nextCharBuf = new char[4096];
}
/** Constructor. */
public JavaCharStream(Provider dstream,
int startline, int startcolumn)
{
this(dstream, startline, startcolumn, 4096);
}
/** Constructor. */
public JavaCharStream(Provider dstream)
{
this(dstream, 1, 1, 4096);
}
/** Reinitialise. */
public void ReInit(Provider dstream,
int startline, int startcolumn, int buffersize)
{
inputStream = dstream;
#if KEEP_LINE_COLUMN
line = startline;
column = startcolumn - 1;
#fi
if (buffer == null || buffersize != buffer.length)
{
available = bufsize = buffersize;
buffer = new char[buffersize];
#if KEEP_LINE_COLUMN
bufline = new int[buffersize];
bufcolumn = new int[buffersize];
#fi
nextCharBuf = new char[4096];
}
#if KEEP_LINE_COLUMN
prevCharIsLF = prevCharIsCR = false;
#fi
tokenBegin = inBuf = maxNextCharInd = 0;
nextCharInd = bufpos = -1;
}
/** Reinitialise. */
public void ReInit(Provider dstream,
int startline, int startcolumn)
{
ReInit(dstream, startline, startcolumn, 4096);
}
/** Reinitialise. */
public void ReInit(Provider dstream)
{
ReInit(dstream, 1, 1, 4096);
}
/** @return token image as String */
${PREFIX}public String GetImage()
{
if (bufpos >= tokenBegin)
return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
else
return new String(buffer, tokenBegin, bufsize - tokenBegin) +
new String(buffer, 0, bufpos + 1);
}
/** @return suffix */
${PREFIX}public char[] GetSuffix(int len)
{
char[] ret = new char[len];
if ((bufpos + 1) >= len)
System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
else
{
System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
len - bufpos - 1);
System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
}
return ret;
}
/** Set buffers back to null when finished. */
${PREFIX}public void Done()
{
nextCharBuf = null;
buffer = null;
#if KEEP_LINE_COLUMN
bufline = null;
bufcolumn = null;
#fi
}
#if KEEP_LINE_COLUMN
/**
* Method to adjust line and column numbers for the start of a token.
*/
${PREFIX}public void adjustBeginLineColumn(int newLine, int newCol)
{
int start = tokenBegin;
int len;
if (bufpos >= tokenBegin)
{
len = bufpos - tokenBegin + inBuf + 1;
}
else
{
len = bufsize - tokenBegin + bufpos + 1 + inBuf;
}
int i = 0, j = 0, k = 0;
int nextColDiff = 0, columnDiff = 0;
while (i < len && bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
{
bufline[j] = newLine;
nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
bufcolumn[j] = newCol + columnDiff;
columnDiff = nextColDiff;
i++;
}
if (i < len)
{
bufline[j] = newLine++;
bufcolumn[j] = newCol + columnDiff;
while (i++ < len)
{
if (bufline[j = start % bufsize] != bufline[++start % bufsize])
bufline[j] = newLine++;
else
bufline[j] = newLine;
}
}
line = bufline[j];
column = bufcolumn[j];
}
${PREFIX}boolean getTrackLineColumn() { return trackLineColumn; }
${PREFIX}void setTrackLineColumn(boolean tlc) { trackLineColumn = tlc; }
#fi
}