diff options
Diffstat (limited to 'src/main/java/io/devnulllabs/openjava/tools/parser')
15 files changed, 15022 insertions, 0 deletions
diff --git a/src/main/java/io/devnulllabs/openjava/tools/parser/ASCII_UCodeESC_CharStream.java b/src/main/java/io/devnulllabs/openjava/tools/parser/ASCII_UCodeESC_CharStream.java new file mode 100644 index 0000000..5d5ab56 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/tools/parser/ASCII_UCodeESC_CharStream.java @@ -0,0 +1,519 @@ +package io.devnulllabs.openjava.tools.parser; + +/** + * An implementation of interface CharStream, where the stream is assumed to + * contain only ASCII characters (with java-like unicode escape processing). + */ + +public final class ASCII_UCodeESC_CharStream +{ + public static final boolean staticFlag = false; + 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 + } + + public int bufpos = -1; + int bufsize; + int available; + int tokenBegin; + private int bufline[]; + private int bufcolumn[]; + + private int column = 0; + private int line = 1; + + private java.io.Reader inputStream; + + private boolean prevCharIsCR = false; + private boolean prevCharIsLF = false; + + private char[] nextCharBuf; + private char[] buffer; + private int maxNextCharInd = 0; + private int nextCharInd = -1; + private int inBuf = 0; + + private final void ExpandBuff(boolean wrapAround) + { + char[] newbuffer = new char[bufsize + 2048]; + int newbufline[] = new int[bufsize + 2048]; + int newbufcolumn[] = new int[bufsize + 2048]; + + try + { + if (wrapAround) + { + System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin); + System.arraycopy(buffer, 0, newbuffer, + bufsize - tokenBegin, bufpos); + buffer = newbuffer; + + 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; + + bufpos += (bufsize - tokenBegin); + } + else + { + System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin); + buffer = newbuffer; + + System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin); + bufline = newbufline; + + System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin); + bufcolumn = newbufcolumn; + + bufpos -= tokenBegin; + } + } + catch (Throwable t) + { + throw new Error(t.getMessage()); + } + + available = (bufsize += 2048); + tokenBegin = 0; + } + + private final 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); + } + else + { + bufline[bufpos] = line; + bufcolumn[bufpos] = column; + } + throw e; + } + } + + private final char ReadByte() throws java.io.IOException + { + if (++nextCharInd >= maxNextCharInd) + FillBuff(); + + return nextCharBuf[nextCharInd]; + } + + public final char BeginToken() throws java.io.IOException + { + if (inBuf > 0) + { + --inBuf; + return buffer[tokenBegin = (bufpos == bufsize - 1) ? (bufpos = 0) + : ++bufpos]; + } + + tokenBegin = 0; + bufpos = -1; + + return readChar(); + } + + private final 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; + } + + private final 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 += (8 - (column & 07)); + break; + default : + break; + } + + bufline[bufpos] = line; + bufcolumn[bufpos] = column; + } + + public final char readChar() throws java.io.IOException + { + if (inBuf > 0) + { + --inBuf; + return buffer[(bufpos == bufsize - 1) ? (bufpos = 0) : ++bufpos]; + } + + char c; + + if (++bufpos == available) + AdjustBuffSize(); + + if (((buffer[bufpos] = c = (char)((char)0xff & ReadByte())) == '\\')) + { + UpdateLineColumn(c); + + int backSlashCnt = 1; + + for (;;) // Read all the backslashes + { + if (++bufpos == available) + AdjustBuffSize(); + + try + { + if ((buffer[bufpos] = c = (char)((char)0xff & 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) + { + if (backSlashCnt > 1) + backup(backSlashCnt); + + return '\\'; + } + + UpdateLineColumn(c); + backSlashCnt++; + } + + // Here, we have seen an odd number of backslash's followed by a 'u' + try + { + while ((c = (char)((char)0xff & ReadByte())) == 'u') + ++column; + + buffer[bufpos] = c = (char)(hexval(c) << 12 | + hexval((char)((char)0xff & ReadByte())) << 8 | + hexval((char)((char)0xff & ReadByte())) << 4 | + hexval((char)((char)0xff & ReadByte()))); + + column += 4; + } + catch(java.io.IOException e) + { + throw new Error("Invalid escape character at line " + line + + " column " + column + "."); + } + + if (backSlashCnt == 1) + return c; + else + { + backup(backSlashCnt - 1); + return '\\'; + } + } + else + { + UpdateLineColumn(c); + return (c); + } + } + + /** + * @deprecated + * @see #getEndColumn + */ + + public final int getColumn() { + return bufcolumn[bufpos]; + } + + /** + * @deprecated + * @see #getEndLine + */ + + public final int getLine() { + return bufline[bufpos]; + } + + public final int getEndColumn() { + return bufcolumn[bufpos]; + } + + public final int getEndLine() { + return bufline[bufpos]; + } + + public final int getBeginColumn() { + return bufcolumn[tokenBegin]; + } + + public final int getBeginLine() { + return bufline[tokenBegin]; + } + + public final void backup(int amount) { + + inBuf += amount; + if ((bufpos -= amount) < 0) + bufpos += bufsize; + } + + public ASCII_UCodeESC_CharStream(java.io.Reader dstream, + int startline, int startcolumn, int buffersize) + { + inputStream = dstream; + line = startline; + column = startcolumn - 1; + + available = bufsize = buffersize; + buffer = new char[buffersize]; + bufline = new int[buffersize]; + bufcolumn = new int[buffersize]; + nextCharBuf = new char[4096]; + } + + public ASCII_UCodeESC_CharStream(java.io.Reader dstream, + int startline, int startcolumn) + { + this(dstream, startline, startcolumn, 4096); + } + public void ReInit(java.io.Reader dstream, + int startline, int startcolumn, int buffersize) + { + inputStream = dstream; + line = startline; + column = startcolumn - 1; + + if (buffer == null || buffersize != buffer.length) + { + available = bufsize = buffersize; + buffer = new char[buffersize]; + bufline = new int[buffersize]; + bufcolumn = new int[buffersize]; + nextCharBuf = new char[4096]; + } + prevCharIsLF = prevCharIsCR = false; + tokenBegin = inBuf = maxNextCharInd = 0; + nextCharInd = bufpos = -1; + } + + public void ReInit(java.io.Reader dstream, + int startline, int startcolumn) + { + ReInit(dstream, startline, startcolumn, 4096); + } + public ASCII_UCodeESC_CharStream(java.io.InputStream dstream, int startline, + int startcolumn, int buffersize) + { + this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096); + } + + public ASCII_UCodeESC_CharStream(java.io.InputStream dstream, int startline, + int startcolumn) + { + this(dstream, startline, startcolumn, 4096); + } + + public void ReInit(java.io.InputStream dstream, int startline, + int startcolumn, int buffersize) + { + ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096); + } + public void ReInit(java.io.InputStream dstream, int startline, + int startcolumn) + { + ReInit(dstream, startline, startcolumn, 4096); + } + + public final 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); + } + + public final 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; + } + + public void Done() + { + nextCharBuf = null; + buffer = null; + bufline = null; + bufcolumn = null; + } + + /** + * Method to adjust line and column numbers for the start of a token.<BR> + */ + 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]; + } + +} diff --git a/src/main/java/io/devnulllabs/openjava/tools/parser/CustomTokenManager.java b/src/main/java/io/devnulllabs/openjava/tools/parser/CustomTokenManager.java new file mode 100644 index 0000000..08967d9 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/tools/parser/CustomTokenManager.java @@ -0,0 +1,68 @@ +/* + * CustomTokenManager.java + * + * comments here. + * + * @author Michiaki Tatsubori + * @version %VERSION% %DATE% + * @see java.lang.Object + * + * COPYRIGHT 1998 by Michiaki Tatsubori, ALL RIGHTS RESERVED. + */ +package io.devnulllabs.openjava.tools.parser; + + +import io.devnulllabs.openjava.mop.Environment; +import io.devnulllabs.openjava.syntax.TokenSource; + + +/** + * The class <code>CustomTokenManager</code> + * <p> + * For example + * <pre> + * </pre> + * <p> + * + * @author Michiaki Tatsubori + * @version 1.0 + * @since $Id: CustomTokenManager.java,v 1.2 2003/02/19 02:55:01 tatsubori Exp $ + * @see java.lang.Object + */ +public final class CustomTokenManager + extends ParserTokenManager + implements TokenSource +{ + private Parser parser; + private Environment env; + + int pointer = 0; + int offset = 0; + + public CustomTokenManager( Parser parser, Environment env ) { + super( null ); + this.parser = parser; + this.env = env; + } + + public Environment getEnvironment() { + return env; + } + + public void assume() { offset = pointer; } + public void restore() { pointer = offset; } + public void fix() { + for (int i = offset; i < pointer; ++i) { + parser.getNextToken(); + } + pointer = 0; offset = 0; + } + public Token getNextToken() { + return parser.getToken( ++pointer ); + } + + public Token getToken( int i ) { + return parser.getToken( pointer + i ); + } + +} diff --git a/src/main/java/io/devnulllabs/openjava/tools/parser/JavaCharStream.java b/src/main/java/io/devnulllabs/openjava/tools/parser/JavaCharStream.java new file mode 100644 index 0000000..4f15719 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/tools/parser/JavaCharStream.java @@ -0,0 +1,546 @@ +package io.devnulllabs.openjava.tools.parser; + +/** + * An implementation of interface CharStream, where the stream is assumed to + * contain only ASCII characters (with java-like unicode escape processing). + */ + +public final class JavaCharStream +{ + public static final boolean staticFlag = false; + 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 + } + + public int bufpos = -1; + int bufsize; + int available; + int tokenBegin; + private int bufline[]; + private int bufcolumn[]; + + private int column = 0; + private int line = 1; + + private boolean prevCharIsCR = false; + private boolean prevCharIsLF = false; + + private java.io.Reader inputStream; + + private char[] nextCharBuf; + private char[] buffer; + private int maxNextCharInd = 0; + private int nextCharInd = -1; + private int inBuf = 0; + + private final void ExpandBuff(boolean wrapAround) + { + char[] newbuffer = new char[bufsize + 2048]; + int newbufline[] = new int[bufsize + 2048]; + int newbufcolumn[] = new int[bufsize + 2048]; + + try + { + if (wrapAround) + { + System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin); + System.arraycopy(buffer, 0, newbuffer, + bufsize - tokenBegin, bufpos); + buffer = newbuffer; + + 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; + + bufpos += (bufsize - tokenBegin); + } + else + { + System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin); + buffer = newbuffer; + + System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin); + bufline = newbufline; + + System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin); + bufcolumn = newbufcolumn; + + bufpos -= tokenBegin; + } + } + catch (Throwable t) + { + throw new Error(t.getMessage()); + } + + available = (bufsize += 2048); + tokenBegin = 0; + } + + private final 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); + } + else + { + bufline[bufpos] = line; + bufcolumn[bufpos] = column; + } + throw e; + } + } + + private final char ReadByte() throws java.io.IOException + { + if (++nextCharInd >= maxNextCharInd) + FillBuff(); + + return nextCharBuf[nextCharInd]; + } + + public final 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(); + } + + private final 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; + } + + private final 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 += (8 - (column & 07)); + break; + default : + break; + } + + bufline[bufpos] = line; + bufcolumn[bufpos] = column; + } + + public final 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()) == '\\') + { + UpdateLineColumn(c); + + 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) + { + if (backSlashCnt > 1) + backup(backSlashCnt); + + return '\\'; + } + + UpdateLineColumn(c); + backSlashCnt++; + } + + // Here, we have seen an odd number of backslash's followed by a 'u' + try + { + while ((c = ReadByte()) == 'u') + ++column; + + buffer[bufpos] = c = (char)(hexval(c) << 12 | + hexval(ReadByte()) << 8 | + hexval(ReadByte()) << 4 | + hexval(ReadByte())); + + column += 4; + } + catch(java.io.IOException e) + { + throw new Error("Invalid escape character at line " + line + + " column " + column + "."); + } + + if (backSlashCnt == 1) + return c; + else + { + backup(backSlashCnt - 1); + return '\\'; + } + } + else + { + UpdateLineColumn(c); + return (c); + } + } + + /** + * @deprecated + * @see #getEndColumn + */ + + public final int getColumn() { + return bufcolumn[bufpos]; + } + + /** + * @deprecated + * @see #getEndLine + */ + + public final int getLine() { + return bufline[bufpos]; + } + + public final int getEndColumn() { + return bufcolumn[bufpos]; + } + + public final int getEndLine() { + return bufline[bufpos]; + } + + public final int getBeginColumn() { + return bufcolumn[tokenBegin]; + } + + public final int getBeginLine() { + return bufline[tokenBegin]; + } + + public final void backup(int amount) { + + inBuf += amount; + if ((bufpos -= amount) < 0) + bufpos += bufsize; + } + + public JavaCharStream(java.io.Reader dstream, + int startline, int startcolumn, int buffersize) + { + inputStream = dstream; + line = startline; + column = startcolumn - 1; + + available = bufsize = buffersize; + buffer = new char[buffersize]; + bufline = new int[buffersize]; + bufcolumn = new int[buffersize]; + nextCharBuf = new char[4096]; + } + + public JavaCharStream(java.io.Reader dstream, + int startline, int startcolumn) + { + this(dstream, startline, startcolumn, 4096); + } + + public JavaCharStream(java.io.Reader dstream) + { + this(dstream, 1, 1, 4096); + } + public void ReInit(java.io.Reader dstream, + int startline, int startcolumn, int buffersize) + { + inputStream = dstream; + line = startline; + column = startcolumn - 1; + + if (buffer == null || buffersize != buffer.length) + { + available = bufsize = buffersize; + buffer = new char[buffersize]; + bufline = new int[buffersize]; + bufcolumn = new int[buffersize]; + nextCharBuf = new char[4096]; + } + prevCharIsLF = prevCharIsCR = false; + tokenBegin = inBuf = maxNextCharInd = 0; + nextCharInd = bufpos = -1; + } + + public void ReInit(java.io.Reader dstream, + int startline, int startcolumn) + { + ReInit(dstream, startline, startcolumn, 4096); + } + + public void ReInit(java.io.Reader dstream) + { + ReInit(dstream, 1, 1, 4096); + } + public JavaCharStream(java.io.InputStream dstream, int startline, + int startcolumn, int buffersize) + { + this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096); + } + + public JavaCharStream(java.io.InputStream dstream, int startline, + int startcolumn) + { + this(dstream, startline, startcolumn, 4096); + } + + public JavaCharStream(java.io.InputStream dstream) + { + this(dstream, 1, 1, 4096); + } + + public void ReInit(java.io.InputStream dstream, int startline, + int startcolumn, int buffersize) + { + ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096); + } + public void ReInit(java.io.InputStream dstream, int startline, + int startcolumn) + { + ReInit(dstream, startline, startcolumn, 4096); + } + public void ReInit(java.io.InputStream dstream) + { + ReInit(dstream, 1, 1, 4096); + } + + public final 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); + } + + public final 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; + } + + public void Done() + { + nextCharBuf = null; + buffer = null; + bufline = null; + bufcolumn = null; + } + + /** + * Method to adjust line and column numbers for the start of a token.<BR> + */ + 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]; + } + +} diff --git a/src/main/java/io/devnulllabs/openjava/tools/parser/Makefile b/src/main/java/io/devnulllabs/openjava/tools/parser/Makefile new file mode 100644 index 0000000..2b543aa --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/tools/parser/Makefile @@ -0,0 +1,35 @@ +# Makefile +# by Michiaki Tatsubori +# +#JJ_OPTION = -USER_TOKEN_MANAGER=true -BUILD_TOKEN_MANAGER=false +#SCAN_OPTION = -BUILD_PARSER=false -BUILD_TOKEN_MANAGER=true +JJ_OPTION := -BUILD_TOKEN_MANAGER=true + +PARSER_SRC := Parser.java ParserTokenManager.java \ + ParseException.java CustomTokenManager.java \ + TokenIDPublisher.java TokenSourceAdapter.java + + +Parser: Parser.java + + +# +# WARNING: +# A modification of patchParserTokenManager.pl may not be automatically +# reflected. Modification of Parser.jj is also required in this case. +# +Parser.java: Parser.jj + javacc $(JJ_OPTION) $? + mv ParserTokenManager.java ParserTokenManager.java.org + ./patchParserTokenManager.pl < ParserTokenManager.java.org \ + > ParserTokenManager.java\ + +jjdoc: Parser.jj + jjdoc $? + + +clean: + \rm -f *~ Parser.java ParserConstants.java \ + ASCII_UCodeESC_CharStream.java \ + Token.java TokenMgrError.java \ + ParserTokenManager.java ParserTokenManager.java.org diff --git a/src/main/java/io/devnulllabs/openjava/tools/parser/ParseException.java b/src/main/java/io/devnulllabs/openjava/tools/parser/ParseException.java new file mode 100644 index 0000000..2dd1580 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/tools/parser/ParseException.java @@ -0,0 +1,192 @@ +/* Generated By:JavaCC: Do not edit this line. ParseException.java Version 2.1 */ +package io.devnulllabs.openjava.tools.parser; + +/** + * This exception is thrown when parse errors are encountered. + * You can explicitly create objects of this exception type by + * calling the method generateParseException in the generated + * parser. + * + * You can modify this class to customize your error reporting + * mechanisms so long as you retain the public fields. + */ +public class ParseException extends Exception { + + /** + * This constructor is used by the method "generateParseException" + * in the generated parser. Calling this constructor generates + * a new object of this type with the fields "currentToken", + * "expectedTokenSequences", and "tokenImage" set. The boolean + * flag "specialConstructor" is also set to true to indicate that + * this constructor was used to create this object. + * This constructor calls its super class with the empty string + * to force the "toString" method of parent class "Throwable" to + * print the error message in the form: + * ParseException: <result of getMessage> + */ + public ParseException(Token currentTokenVal, + int[][] expectedTokenSequencesVal, + String[] tokenImageVal + ) + { + super(""); + specialConstructor = true; + currentToken = currentTokenVal; + expectedTokenSequences = expectedTokenSequencesVal; + tokenImage = tokenImageVal; + } + + /** + * The following constructors are for use by you for whatever + * purpose you can think of. Constructing the exception in this + * manner makes the exception behave in the normal way - i.e., as + * documented in the class "Throwable". The fields "errorToken", + * "expectedTokenSequences", and "tokenImage" do not contain + * relevant information. The JavaCC generated code does not use + * these constructors. + */ + + public ParseException() { + super(); + specialConstructor = false; + } + + public ParseException(String message) { + super(message); + specialConstructor = false; + } + + /** + * This variable determines which constructor was used to create + * this object and thereby affects the semantics of the + * "getMessage" method (see below). + */ + protected boolean specialConstructor; + + /** + * This is the last token that has been consumed successfully. If + * this object has been created due to a parse error, the token + * followng this token will (therefore) be the first error token. + */ + public Token currentToken; + + /** + * Each entry in this array is an array of integers. Each array + * of integers represents a sequence of tokens (by their ordinal + * values) that is expected at this point of the parse. + */ + public int[][] expectedTokenSequences; + + /** + * This is a reference to the "tokenImage" array of the generated + * parser within which the parse error occurred. This array is + * defined in the generated ...Constants interface. + */ + public String[] tokenImage; + + /** + * This method has the standard behavior when this object has been + * created using the standard constructors. Otherwise, it uses + * "currentToken" and "expectedTokenSequences" to generate a parse + * error message and returns it. If this object has been created + * due to a parse error, and you do not catch it (it gets thrown + * from the parser), then this method is called during the printing + * of the final stack trace, and hence the correct error message + * gets displayed. + */ + public String getMessage() { + if (!specialConstructor) { + return super.getMessage(); + } + String expected = ""; + int maxSize = 0; + for (int i = 0; i < expectedTokenSequences.length; i++) { + if (maxSize < expectedTokenSequences[i].length) { + maxSize = expectedTokenSequences[i].length; + } + for (int j = 0; j < expectedTokenSequences[i].length; j++) { + expected += tokenImage[expectedTokenSequences[i][j]] + " "; + } + if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) { + expected += "..."; + } + expected += eol + " "; + } + String retval = "Encountered \""; + Token tok = currentToken.next; + for (int i = 0; i < maxSize; i++) { + if (i != 0) retval += " "; + if (tok.kind == 0) { + retval += tokenImage[0]; + break; + } + retval += add_escapes(tok.image); + tok = tok.next; + } + retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn; + retval += "." + eol; + if (expectedTokenSequences.length == 1) { + retval += "Was expecting:" + eol + " "; + } else { + retval += "Was expecting one of:" + eol + " "; + } + retval += expected; + return retval; + } + + /** + * The end of line string for this machine. + */ + protected String eol = System.getProperty("line.separator", "\n"); + + /** + * Used to convert raw characters to their escaped version + * when these raw version cannot be used as part of an ASCII + * string literal. + */ + protected String add_escapes(String str) { + StringBuffer retval = new StringBuffer(); + char ch; + for (int i = 0; i < str.length(); i++) { + switch (str.charAt(i)) + { + case 0 : + continue; + case '\b': + retval.append("\\b"); + continue; + case '\t': + retval.append("\\t"); + continue; + case '\n': + retval.append("\\n"); + continue; + case '\f': + retval.append("\\f"); + continue; + case '\r': + retval.append("\\r"); + continue; + case '\"': + retval.append("\\\""); + continue; + case '\'': + retval.append("\\\'"); + continue; + case '\\': + retval.append("\\\\"); + continue; + default: + if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) { + String s = "0000" + Integer.toString(ch, 16); + retval.append("\\u" + s.substring(s.length() - 4, s.length())); + } else { + retval.append(ch); + } + continue; + } + } + return retval.toString(); + } + +} diff --git a/src/main/java/io/devnulllabs/openjava/tools/parser/Parser.java b/src/main/java/io/devnulllabs/openjava/tools/parser/Parser.java new file mode 100644 index 0000000..749fa53 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/tools/parser/Parser.java @@ -0,0 +1,6327 @@ +package io.devnulllabs.openjava.tools.parser; + + +import java.lang.reflect.Method; +import java.util.Hashtable; +import java.util.Vector; + +import io.devnulllabs.openjava.mop.ClassEnvironment; +import io.devnulllabs.openjava.mop.ClosedEnvironment; +import io.devnulllabs.openjava.mop.Environment; +import io.devnulllabs.openjava.mop.FileEnvironment; +import io.devnulllabs.openjava.mop.OJSystem; +import io.devnulllabs.openjava.ptree.AllocationExpression; +import io.devnulllabs.openjava.ptree.ArrayAccess; +import io.devnulllabs.openjava.ptree.ArrayAllocationExpression; +import io.devnulllabs.openjava.ptree.ArrayInitializer; +import io.devnulllabs.openjava.ptree.AssignmentExpression; +import io.devnulllabs.openjava.ptree.BinaryExpression; +import io.devnulllabs.openjava.ptree.Block; +import io.devnulllabs.openjava.ptree.BreakStatement; +import io.devnulllabs.openjava.ptree.CaseGroup; +import io.devnulllabs.openjava.ptree.CaseGroupList; +import io.devnulllabs.openjava.ptree.CastExpression; +import io.devnulllabs.openjava.ptree.CatchBlock; +import io.devnulllabs.openjava.ptree.CatchList; +import io.devnulllabs.openjava.ptree.ClassDeclaration; +import io.devnulllabs.openjava.ptree.ClassDeclarationList; +import io.devnulllabs.openjava.ptree.ClassLiteral; +import io.devnulllabs.openjava.ptree.CompilationUnit; +import io.devnulllabs.openjava.ptree.ConditionalExpression; +import io.devnulllabs.openjava.ptree.ConstructorDeclaration; +import io.devnulllabs.openjava.ptree.ConstructorInvocation; +import io.devnulllabs.openjava.ptree.ContinueStatement; +import io.devnulllabs.openjava.ptree.DoWhileStatement; +import io.devnulllabs.openjava.ptree.EmptyStatement; +import io.devnulllabs.openjava.ptree.Expression; +import io.devnulllabs.openjava.ptree.ExpressionList; +import io.devnulllabs.openjava.ptree.ExpressionStatement; +import io.devnulllabs.openjava.ptree.FieldAccess; +import io.devnulllabs.openjava.ptree.FieldDeclaration; +import io.devnulllabs.openjava.ptree.ForStatement; +import io.devnulllabs.openjava.ptree.IfStatement; +import io.devnulllabs.openjava.ptree.InstanceofExpression; +import io.devnulllabs.openjava.ptree.LabeledStatement; +import io.devnulllabs.openjava.ptree.Literal; +import io.devnulllabs.openjava.ptree.MemberDeclaration; +import io.devnulllabs.openjava.ptree.MemberDeclarationList; +import io.devnulllabs.openjava.ptree.MemberInitializer; +import io.devnulllabs.openjava.ptree.MethodCall; +import io.devnulllabs.openjava.ptree.MethodDeclaration; +import io.devnulllabs.openjava.ptree.ModifierList; +import io.devnulllabs.openjava.ptree.Parameter; +import io.devnulllabs.openjava.ptree.ParameterList; +import io.devnulllabs.openjava.ptree.ParseTree; +import io.devnulllabs.openjava.ptree.ReturnStatement; +import io.devnulllabs.openjava.ptree.SelfAccess; +import io.devnulllabs.openjava.ptree.Statement; +import io.devnulllabs.openjava.ptree.StatementList; +import io.devnulllabs.openjava.ptree.SwitchStatement; +import io.devnulllabs.openjava.ptree.SynchronizedStatement; +import io.devnulllabs.openjava.ptree.ThrowStatement; +import io.devnulllabs.openjava.ptree.TryStatement; +import io.devnulllabs.openjava.ptree.TypeName; +import io.devnulllabs.openjava.ptree.UnaryExpression; +import io.devnulllabs.openjava.ptree.Variable; +import io.devnulllabs.openjava.ptree.VariableDeclaration; +import io.devnulllabs.openjava.ptree.VariableDeclarator; +import io.devnulllabs.openjava.ptree.VariableInitializer; +import io.devnulllabs.openjava.ptree.WhileStatement; +import io.devnulllabs.openjava.syntax.SyntaxRule; +import io.devnulllabs.openjava.syntax.TokenSource; +import io.devnulllabs.openjava.tools.DebugOut; + + +public class Parser implements ParserConstants { + /** + * Allocates a new parser object who gets tokens from the given parser + * object. + * + * @param parser this is used to get tokens via <code>getToken()</code> + * or <code>getNextToken()</code>. + */ + public Parser( Parser parser ) { + this( (ParserTokenManager) new CustomTokenManager( parser, OJSystem.env ) ); + } + + public Parser( TokenSource token_src ) { + this( new TokenSourceAdapter( token_src ) ); + } + + private final String getComment() { + Token token = getToken( 1 ).specialToken; + return ((token == null) ? null : token.image); + } + + + private final static int makeInt( String str ) { + if (str.length() == 1) { + return Integer.valueOf( str ).intValue(); + } else if (str.startsWith( "0x" ) || str.startsWith( "0X" )) { + return Integer.valueOf( str.substring( 2 ), 16 ).intValue(); + } else if (str.startsWith( "0" )) { + return Integer.valueOf( str.substring( 1 ), 8 ).intValue(); + } + return Integer.valueOf( str ).intValue(); + } + private final static long makeLong( String str ) { + if (str.length() == 1) { + return Long.valueOf( str ).longValue(); + } else if (str.startsWith( "0x" ) || str.startsWith( "0X" )) { + str = str.substring( 2 ); + if (str.endsWith( "l" ) || str.endsWith( "L" )) { + str = str.substring( 0, str.length() - 1 ); + } + return Long.valueOf( str, 16 ).longValue(); + } else if (str.startsWith( "0" )) { + str = str.substring( 1 ); + if (str.endsWith( "l" ) || str.endsWith( "L" )) { + str = str.substring( 0, str.length() - 1 ); + } + return Long.valueOf( str, 8 ).longValue(); + } + return Long.valueOf( str ).longValue(); + } + + /** + * Detects class or interface name and metaclass + */ + private final ClassEnvironment setClassEnvironment( Environment base_env ) + throws ParseException + { + int ptr = 1; + for (; roughModifierCheck( getToken( ptr ) ) ; ++ptr) ; + Token c_or_i = getToken( ptr++ ); + if (c_or_i.kind != CLASS && c_or_i.kind != INTERFACE) { + throw new ParseException( "'class' or 'interface' expected : " + + c_or_i.image ); + } + Token cname = getToken( ptr++ ); + if (cname.kind != IDENTIFIER) { + throw new ParseException( "class name expected : " + + c_or_i.image ); + } + String classname = cname.image; + + ClassEnvironment result = new ClassEnvironment(base_env, classname); + + Token inst = getToken(ptr++); + if (inst.kind != INSTANTIATES) { + ptr++; + } else { + IntAndObj tmp = consumeMetaclassName(ptr); ptr = tmp.ptr; + String meta = base_env.toQualifiedName((String) tmp.obj); + OJSystem.metabind(result.toQualifiedName(classname), meta); + } + + return result; + } + + private IntAndObj consumeMetaclassName( int ptr ) throws ParseException { + Token token = getToken( ptr++ ); + if (token.kind != IDENTIFIER) { + throw new ParseException( "metaclass name exptected : " + + token.image ); + } + StringBuffer buf = new StringBuffer( token.image ); + while (getToken( ptr ).kind == DOT + && getToken( ptr + 1 ).kind == IDENTIFIER) { + buf.append( "." ).append( getToken( ptr + 1 ).image ); + ptr += 2; + } + return new IntAndObj( ptr, buf.toString() ); + } + + /** + * This is used to check io.devnulllabs.openjava user modifier semantically. + */ + private final boolean OpenJavaModifierLookahead( Environment env ) { + return modifierCheck( env, getToken( 1 ) ); + } + + /** + * This is used to check OpenJava user modifier semantically. + */ + private final boolean ModifierLookahead( Environment env ) { + return modifierCheck( env, getToken( 1 ) ); + } + + boolean DeclSuffixLookahead( Environment env ) { + String typename = env.currentClassName(); + String keyword = consumeKeyword( 1 ); + if (keyword == null) return false; + Class meta = toExecutable( env, typename ); + return invokeOJClass_isRegisteredKeyword( meta, keyword ); + } + + boolean TypeSuffixLookahead( Environment env, String typename ) { + String keyword = consumeKeyword( 1 ); + if (keyword == null) return false; + Class meta = toExecutable( env, typename ); + return invokeOJClass_isRegisteredKeyword( meta, keyword ); + } + + private static final boolean modifierCheck( Environment env, Token t ) { + if (pureModifierCheck( t )) return true; + if (t.kind != IDENTIFIER) return false; + Class meta = toExecutable( env, env.currentClassName() ); + if (meta == null) return false; + return invokeOJClass_isRegisteredModifier( meta, t.image ); + } + + private String consumeKeyword( int ptr ) { + Token token = getToken( ptr ); + if (token.kind != IDENTIFIER) return null; + return token.image; + } + + static final Class toExecutable( Environment env, String typename ) { + String qname = env.toQualifiedName( typename ); + return OJSystem.getMetabind( qname ); + } + + static boolean invokeOJClass_isRegisteredKeyword( Class meta, + String keyword ) + { + try { + Method m = meta.getMethod( "isRegisteredKeyword", + new Class[]{ String . class} ); + Boolean b = (Boolean) m.invoke( null, new Object[]{ keyword } ); + return b.booleanValue(); + } catch ( Exception e ) {} + return false; + } + + static SyntaxRule invokeOJClass_getDeclSuffixRule(Environment env, + Class meta, + String keyword) + { + SyntaxRule result = null; + try { + Method m = meta.getMethod("getDeclSuffixRule", + new Class[]{ Environment.class, + String.class }); + result = (SyntaxRule) m.invoke(null, new Object[]{ env, keyword }); + } catch (Exception e) {} /* ignore if the method not provided */ + if (result != null) return result; + try { + Method m = meta.getMethod("getDeclSuffixRule", + new Class[]{ String.class }); + result = (SyntaxRule) m.invoke(null, new Object[]{ keyword }); + } catch (Exception e) {} /* ignore if the method not provided */ + return result; + } + + static SyntaxRule invokeOJClass_getTypeSuffixRule(Environment env, + Class meta, + String keyword) + { + SyntaxRule result = null; + try { + Method m = meta.getMethod("getTypeSuffixRule", + new Class[]{ Environment.class, + String.class }); + result = (SyntaxRule) m.invoke(null, new Object[]{ env, keyword }); + } catch (Exception e) {} /* ignore if the method not provided */ + if (result != null) return result; + try { + Method m = meta.getMethod("getTypeSuffixRule", + new Class[]{ String.class}); + result = (SyntaxRule) m.invoke(null, new Object[]{ keyword }); + } catch (Exception e) {} /* ignore if the method not provided */ + return result; + } + + static boolean invokeOJClass_isRegisteredModifier( Class meta, + String keyword ) + { + try { + Method m = meta.getMethod( "isRegisteredModifier", + new Class[]{ String . class} ); + Boolean b = (Boolean) m.invoke( null, new Object[]{ keyword } ); + return b.booleanValue(); + } catch ( Exception e ) {} + return false; + } + + /** + * This is used to check constructors semantically. + */ + private final boolean ConstructorDeclarationLookahead( + ClassEnvironment env ) { + int ptr; + for (ptr = 1; modifierCheck( env, getToken( ptr ) ) ; ++ptr) ; + String simplename = Environment.toSimpleName( env.currentClassName() ); + //if (! getToken( ptr ).image.equals( simplename ) + // || getToken( ptr + 1 ).kind != LPAREN) { + // return false; + //} + //return true; + return (getToken(ptr + 1).kind == LPAREN); + } + + /** + * This will used to check local variable declaration semantically. + */ + private final boolean LocalVariableDeclarationLookahead( + Environment env ) { + int ptr; + for (ptr = 1; modifierCheck( env, getToken( ptr ) ) ; ++ptr) ; + int old_ptr = ptr; + ptr = consumePureResultType( old_ptr ); + if (ptr != old_ptr && getToken( ptr ).kind == IDENTIFIER) { + return true; + } + return false; + } + + private final boolean roughModifierCheck( Token t ) { + if (pureModifierCheck( t )) return true; + return (t.kind == IDENTIFIER); + } + + private static final boolean pureModifierCheck( Token t ) { + switch (t.kind) { + case ABSTRACT : case FINAL : case PUBLIC : case PRIVATE : + case PROTECTED : case STATIC : case TRANSIENT : case VOLATILE : + case NATIVE : case SYNCHRONIZED : + return true; + } + return false; + } + + private final boolean ConstructorInvocationLookahead() { + int ptr = 1; + while (getToken(ptr).kind != EOF) { + if (getToken(ptr).kind == SUPER + && getToken(ptr + 1).kind == LPAREN) { + return true; + } + if (getToken(ptr).kind == SEMICOLON) return false; + if (getToken(ptr).kind == RBRACE) return false; + ++ptr; + } + return false; + } + + private final boolean AssignmentLookahead() { + int ptr = 1; + switch (getToken( ptr ).kind) { + case LPAREN : + ptr = consumeParenPair( ptr ); + break; + case IDENTIFIER : + case THIS : + case SUPER : + ptr++; + break; + default : + return false; + } + for (boolean cont = true; cont;) { + switch (getToken( ptr ).kind) { + case LPAREN : + ptr = consumeParenPair( ptr ); + break; + case LBRACKET : + ptr = consumeBracketPair( ptr ); + break; + case DOT : + ptr++; + if (getToken( ptr ).kind != IDENTIFIER) return false; + ptr++; + break; + default : + cont = false; + } + } + return assignmentOperatorCheck( getToken( ptr ) ); + } + + private final int consumeParenPair( int ptr ) { + int nest = 1; + for (++ptr; nest > 0; ptr++) { + if (getToken( ptr ).kind == LPAREN) nest++; + if (getToken( ptr ).kind == RPAREN) nest--; + } + return ptr; + } + + private final int consumeBracketPair( int ptr ) { + int nest = 1; + for (++ptr; nest > 0; ptr++) { + if (getToken( ptr ).kind == LBRACKET) nest++; + if (getToken( ptr ).kind == RBRACKET) nest--; + } + return ptr; + } + + private static final boolean assignmentOperatorCheck( Token t ) { + if (t.kind == ASSIGN) return true; + if (t.kind == PLUSASSIGN) return true; + if (t.kind == MINUSASSIGN) return true; + if (t.kind == STARASSIGN) return true; + if (t.kind == SLASHASSIGN) return true; + if (t.kind == ANDASSIGN) return true; + if (t.kind == ORASSIGN) return true; + if (t.kind == XORASSIGN) return true; + if (t.kind == REMASSIGN) return true; + if (t.kind == LSHIFTASSIGN) return true; + if (t.kind == RSIGNEDSHIFTASSIGN) return true; + if (t.kind == RUNSIGNEDSHIFTASSIGN) return true; + return false; + } + + private final boolean ClassLiteralLookahead() { + int ptr = 1; + ptr = consumePureResultType( ptr ); + if (ptr == 1) return false; + /** here should be user suffix check **/ + if (getToken( ptr ).kind != DOT) return false; + if (getToken( ptr + 1 ).kind != CLASS) return false; + return true; + } + + private final int consumePureResultType( int ptr ) { + Token token = getToken( ptr ); + if (primitiveTypeCheck( token )) { + ptr++; + } else if (token.kind == IDENTIFIER) { + ptr++; + while (getToken( ptr ).kind == DOT + && getToken( ptr + 1 ).kind == IDENTIFIER) { + ptr += 2; + } + } else { + return ptr; + } + + while (getToken( ptr ).kind == LBRACKET + && getToken( ptr + 1 ).kind == RBRACKET) { + ptr += 2; + } + + return ptr; + } + + private final boolean primitiveTypeCheck( Token t ) { + if (t.kind == BOOLEAN || t.kind == CHAR || t.kind == BYTE + || t.kind == SHORT || t.kind == INT || t.kind == LONG + || t.kind == FLOAT || t.kind == DOUBLE || t.kind == VOID) { + return true; + } + return false; + } + + void debug_message1() throws ParseException { + DebugOut.println( "debug1 : " + getToken( 0 ).image + + " , " + getToken( 1 ).image ); + } + + ParseTree UserDeclSuffix(Environment env, String keyword) throws ParseException { + String typename = env.currentClassName(); + Class meta = toExecutable(env, typename); + SyntaxRule rule = invokeOJClass_getDeclSuffixRule(env, meta, keyword); + CustomTokenManager token_mgr = new CustomTokenManager(this, env); + token_mgr.assume(); + ParseTree result = rule.consume(token_mgr); + token_mgr.fix(); + return result; + } + + ParseTree UserTypeSuffix(Environment env, String typename, String keyword) throws ParseException { + Class meta = toExecutable(env, typename); + SyntaxRule rule = invokeOJClass_getTypeSuffixRule(env, meta, keyword); + CustomTokenManager token_mgr = new CustomTokenManager(this, env); + token_mgr.assume(); + ParseTree result = rule.consume(token_mgr); + token_mgr.fix(); + return result; + } + + void E() throws ParseException { + } + +/***************************************** + * Syntactical Descriptions * + *****************************************/ + +/* + * Program structuring syntax follows. + */ + final public CompilationUnit CompilationUnit(Environment base_env) throws ParseException { + CompilationUnit result; + FileEnvironment env = new FileEnvironment( base_env ); + String p1; + String[] p2; + ClassDeclarationList p3; + /**/DebugOut.println( "#CompilationUnit()" ); + String comment = getComment(); + p1 = PackageDeclarationOpt(); + p2 = ImportDeclarationListOpt(); + env.setPackage( p1 ); + for (int i = 0; i < p2.length; ++i) { + if (CompilationUnit.isOnDemandImport( p2[i] )) { + String pack_cls = CompilationUnit.trimOnDemand( p2[i] ); + env.importPackage( pack_cls ); + } else { + env.importClass( p2[i] ); + } + } + label_1: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SEMICOLON: + ; + break; + default: + jj_la1[0] = jj_gen; + break label_1; + } + jj_consume_token(SEMICOLON); + } + p3 = TypeDeclarationListOpt(env); + jj_consume_token(0); + result = new CompilationUnit( p1, p2, p3 ); + result.setComment( comment ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public String PackageDeclarationOpt() throws ParseException { + String p1; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case PACKAGE: + jj_consume_token(PACKAGE); + p1 = Name(); + jj_consume_token(SEMICOLON); + {if (true) return p1;} + break; + default: + jj_la1[1] = jj_gen; + E(); + {if (true) return null;} + } + throw new Error("Missing return statement in function"); + } + + final public String[] ImportDeclarationListOpt() throws ParseException { + String[] result; + String p1; + Vector v = new Vector(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IMPORT: + label_2: + while (true) { + p1 = ImportDeclaration(); + v.addElement( p1 ); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IMPORT: + ; + break; + default: + jj_la1[2] = jj_gen; + break label_2; + } + } + result = new String[v.size()]; + for (int i = 0; i < result.length; ++i) { + result[i] = (String) v.elementAt( i ); + } + {if (true) return result;} + break; + default: + jj_la1[3] = jj_gen; + E(); + {if (true) return new String[0];} + } + throw new Error("Missing return statement in function"); + } + + final public String ImportDeclaration() throws ParseException { + String p1; + StringBuffer strbuf = new StringBuffer(); + jj_consume_token(IMPORT); + Identifier(); + strbuf.append( getToken( 0 ).image ); + label_3: + while (true) { + if (jj_2_1(2)) { + ; + } else { + break label_3; + } + jj_consume_token(DOT); + Identifier(); + strbuf.append( "." + getToken( 0 ).image ); + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case DOT: + jj_consume_token(DOT); + jj_consume_token(STAR); + strbuf.append( ".*" ); + break; + default: + jj_la1[4] = jj_gen; + ; + } + jj_consume_token(SEMICOLON); + {if (true) return strbuf.toString();} + throw new Error("Missing return statement in function"); + } + + final public ClassDeclarationList TypeDeclarationListOpt(Environment env) throws ParseException { + ClassEnvironment newenv; + ClassDeclarationList result = new ClassDeclarationList(); + ClassDeclaration p1; + if ((getToken( 1 ).kind != RBRACE + && getToken( 1 ).kind != EOF)) { + label_4: + while (true) { + newenv = setClassEnvironment( env ); + p1 = TypeDeclaration(newenv); + label_5: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SEMICOLON: + ; + break; + default: + jj_la1[5] = jj_gen; + break label_5; + } + jj_consume_token(SEMICOLON); + } + result.add( p1 ); + if ((getToken( 1 ).kind != RBRACE + && getToken( 1 ).kind != EOF)) { + ; + } else { + break label_4; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public ClassDeclaration TypeDeclaration(ClassEnvironment env) throws ParseException { + ClassDeclaration result; + ClassDeclaration p1; + Token ctoken = getToken( 1 ).specialToken; + String comment = getComment(); + if (jj_2_2(2147483647)) { + p1 = ClassDeclaration(env); + } else { + p1 = InterfaceDeclaration(env); + } + result = p1; + result.setComment( comment ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public String Identifier() throws ParseException { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IDENTIFIER: + jj_consume_token(IDENTIFIER); + {if (true) return getToken( 0 ).image;} + break; + case METACLASS: + jj_consume_token(METACLASS); + {if (true) return "metaclass";} + break; + default: + jj_la1[6] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public String[] MetaclassesOpt(Environment env) throws ParseException { + String[] result; + String p1; + String p2; + Vector v = new Vector(); + String qname; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case METACLASS: + jj_consume_token(METACLASS); + p1 = Name(); + qname = env.toQualifiedName( p1 ); + v.addElement( qname ); + /****/DebugOut.print( "metaclass " + qname ); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + jj_consume_token(COMMA); + p2 = Name(); + qname = env.toQualifiedName( p2 ); + /****/DebugOut.print( ", " + qname ); + break; + default: + jj_la1[7] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COLON: + jj_consume_token(COLON); + break; + case SEMICOLON: + jj_consume_token(SEMICOLON); + break; + default: + jj_la1[8] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + /****/DebugOut.println( " :" ); + result = new String[v.size()]; + for (int i = 0; i < result.length; ++i) { + result[i] = (String) v.elementAt( i ); + } + {if (true) return result;} + break; + default: + jj_la1[9] = jj_gen; + E(); + {if (true) return new String[0];} + } + throw new Error("Missing return statement in function"); + } + + final public String InstantiatesPhraseOpt(ClassEnvironment env) throws ParseException { + String p1 = null; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INSTANTIATES: + jj_consume_token(INSTANTIATES); + p1 = Name(); + {if (true) return p1;} + break; + default: + jj_la1[10] = jj_gen; + E(); + {if (true) return p1;} + } + throw new Error("Missing return statement in function"); + } + + final public String OpenJavaModifier() throws ParseException { + String result; + jj_consume_token(IDENTIFIER); + result = getToken( 0 ).image; + DebugOut.println( "user modifier detected : " + result ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Hashtable OpenJavaDeclSuffixListOpt(Environment env) throws ParseException { + Hashtable result = new Hashtable(); + String p1; + ParseTree p2; + if (DeclSuffixLookahead( env )) { + label_6: + while (true) { + p1 = Identifier(); + p2 = UserDeclSuffix(env, p1); + DebugOut.println( "decl suffix : " + p1 + " " + p2 ); + result.put( p1, p2 ); + if (DeclSuffixLookahead( env )) { + ; + } else { + break label_6; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public Hashtable OpenJavaTypeSuffixListOpt(Environment env, String typename) throws ParseException { + Hashtable result = new Hashtable(); + String p1; + ParseTree p2; + if (TypeSuffixLookahead( env, typename )) { + label_7: + while (true) { + p1 = Identifier(); + p2 = UserTypeSuffix(env, typename, p1); + DebugOut.println( "type suffix : " + p1 + " " + p2 ); + result.put( p1, p2 ); + if (TypeSuffixLookahead( env, typename )) { + ; + } else { + break label_7; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public int Modifier() throws ParseException { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ABSTRACT: + jj_consume_token(ABSTRACT); + {if (true) return ModifierList.ABSTRACT;} + break; + case FINAL: + jj_consume_token(FINAL); + {if (true) return ModifierList.FINAL;} + break; + case PUBLIC: + jj_consume_token(PUBLIC); + {if (true) return ModifierList.PUBLIC;} + break; + case PRIVATE: + jj_consume_token(PRIVATE); + {if (true) return ModifierList.PRIVATE;} + break; + case PROTECTED: + jj_consume_token(PROTECTED); + {if (true) return ModifierList.PROTECTED;} + break; + case STATIC: + jj_consume_token(STATIC); + {if (true) return ModifierList.STATIC;} + break; + case TRANSIENT: + jj_consume_token(TRANSIENT); + {if (true) return ModifierList.TRANSIENT;} + break; + case VOLATILE: + jj_consume_token(VOLATILE); + {if (true) return ModifierList.VOLATILE;} + break; + case NATIVE: + jj_consume_token(NATIVE); + {if (true) return ModifierList.NATIVE;} + break; + case SYNCHRONIZED: + jj_consume_token(SYNCHRONIZED); + {if (true) return ModifierList.SYNCHRONIZED;} + break; + default: + jj_la1[11] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + +/* + * Declaration syntax follows. + */ + final public ClassDeclaration ClassDeclaration(ClassEnvironment env) throws ParseException { + ModifierList p1; + ClassDeclaration p2; + + DebugOut.println( "#ClassDeclaration()" ); + p1 = ClassModifiersOpt(env); + p2 = UnmodifiedClassDeclaration(env); + p2.setModifiers( p1 ); + {if (true) return p2;} + throw new Error("Missing return statement in function"); + } + + final public ModifierList ClassModifiersOpt(Environment env) throws ParseException { + ModifierList result = new ModifierList(); + int p1; + String p2; + if ((getToken( 1 ).kind != CLASS)) { + label_8: + while (true) { + if (jj_2_3(2147483647)) { + p1 = Modifier(); + result.add( p1 ); + } else if (OpenJavaModifierLookahead( env )) { + p2 = OpenJavaModifier(); + result.add( p2 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (ModifierLookahead( env )) { + ; + } else { + break label_8; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public ClassDeclaration UnmodifiedClassDeclaration(ClassEnvironment env) throws ParseException { + ClassDeclaration result; + String p1; + TypeName[] p2; + TypeName[] p3; + MemberDeclarationList p4; + String mm; + Hashtable sf; + jj_consume_token(CLASS); + p1 = Identifier(); + mm = InstantiatesPhraseOpt(env); + p2 = ExtendsPhraseOpt(env); + p3 = ImplementsPhraseOpt(env); + sf = OpenJavaDeclSuffixListOpt(env); + p4 = ClassBody(env); + result = new ClassDeclaration( null, p1, p2, p3, p4 ); + result.setSuffixes( sf ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public TypeName[] ExtendsPhraseOpt(Environment env) throws ParseException { + TypeName[] p1; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case EXTENDS: + jj_consume_token(EXTENDS); + p1 = TypeNameList(env); + {if (true) return p1;} + break; + default: + jj_la1[12] = jj_gen; + E(); + {if (true) return null;} + } + throw new Error("Missing return statement in function"); + } + + final public TypeName[] ImplementsPhraseOpt(Environment env) throws ParseException { + TypeName[] p1; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IMPLEMENTS: + jj_consume_token(IMPLEMENTS); + p1 = TypeNameList(env); + {if (true) return p1;} + break; + default: + jj_la1[13] = jj_gen; + E(); + {if (true) return null;} + } + throw new Error("Missing return statement in function"); + } + + final public MemberDeclarationList ClassBody(ClassEnvironment env) throws ParseException { + MemberDeclarationList p1; + + DebugOut.println( "#ClassBody()" ); + jj_consume_token(LBRACE); + label_9: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SEMICOLON: + ; + break; + default: + jj_la1[14] = jj_gen; + break label_9; + } + jj_consume_token(SEMICOLON); + } + p1 = ClassBodyDeclarationListOpt(env); + jj_consume_token(RBRACE); + {if (true) return p1;} + throw new Error("Missing return statement in function"); + } + + final public MemberDeclarationList ClassBodyDeclarationListOpt(ClassEnvironment env) throws ParseException { + MemberDeclarationList result = new MemberDeclarationList(); + MemberDeclarationList p1; + if ((getToken( 1 ).kind != RBRACE)) { + label_10: + while (true) { + p1 = ClassBodyDeclaration(env); + label_11: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SEMICOLON: + ; + break; + default: + jj_la1[15] = jj_gen; + break label_11; + } + jj_consume_token(SEMICOLON); + } + result.addAll( p1 ); + if ((getToken( 1 ).kind != RBRACE)) { + ; + } else { + break label_10; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public ClassDeclaration NestedTypeDeclaration(ClassEnvironment env) throws ParseException { + ClassDeclaration result; + ClassDeclaration p1; + Token ctoken = getToken( 1 ).specialToken; + String comment = getComment(); + if (jj_2_4(2147483647)) { + p1 = NestedClassDeclaration(env); + } else { + p1 = NestedInterfaceDeclaration(env); + } + result = p1; + result.setComment( comment ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ClassDeclaration NestedClassDeclaration(ClassEnvironment env) throws ParseException { + ModifierList p1; + ClassDeclaration p2; + + DebugOut.println( "#NestedClassDeclaration()" ); + p1 = NestedClassModifiersOpt(env); + p2 = UnmodifiedClassDeclaration(env); + p2.setModifiers( p1 ); + {if (true) return p2;} + throw new Error("Missing return statement in function"); + } + + final public ModifierList NestedClassModifiersOpt(ClassEnvironment env) throws ParseException { + ModifierList result = new ModifierList(); + int p1; + String p2; + if ((getToken( 1 ).kind != CLASS)) { + label_12: + while (true) { + if (jj_2_5(2147483647)) { + p1 = Modifier(); + result.add( p1 ); + } else if (OpenJavaModifierLookahead( env )) { + p2 = OpenJavaModifier(); + result.add( p2 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (ModifierLookahead( env )) { + ; + } else { + break label_12; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public MemberDeclarationList ClassBodyDeclaration(ClassEnvironment env) throws ParseException { + ClassEnvironment newenv; + MemberDeclarationList result; + MemberDeclaration p1; + MemberDeclarationList p2; + if (jj_2_6(2147483647)) { + p1 = MemberInitializer(env); + result = new MemberDeclarationList( p1 ); + {if (true) return result;} + } else if (jj_2_7(2147483647)) { + newenv = setClassEnvironment( env ); + p1 = NestedTypeDeclaration(newenv); + result = new MemberDeclarationList( p1 ); + {if (true) return result;} + } else if (ConstructorDeclarationLookahead( env )) { + p1 = ConstructorDeclaration(env); + result = new MemberDeclarationList( p1 ); + {if (true) return result;} + } else { + p2 = MethodOrFieldDeclaration(env); + {if (true) return p2;} + } + throw new Error("Missing return statement in function"); + } + + final public MemberDeclarationList MethodOrFieldDeclaration(Environment base_env) throws ParseException { + Environment env = new ClosedEnvironment( base_env ); + MemberDeclarationList result = new MemberDeclarationList(); + ModifierList p1; + TypeName p2; + String p3; + ParameterList p4; + int p5; + TypeName[] p6; + StatementList p7; + VariableDeclarator p8; + Hashtable sf; + Token ctoken = getToken( 1 ).specialToken; + String comment = getComment(); + p1 = MemberModifiersOpt(base_env); + p2 = Type(base_env); + if (jj_2_8(2147483647)) { + p3 = Identifier(); + p4 = FormalParameters(env); + p5 = EmptyBracketsOpt(); + p6 = ThrowsPhraseOpt(base_env); + sf = OpenJavaDeclSuffixListOpt(env); + p7 = MethodBody(env); + p2.addDimension( p5 ); + MethodDeclaration mthd + = new MethodDeclaration( p1, p2, p3, p4, p6, p7 ); + mthd.setSuffixes( sf ); + mthd.setComment( comment ); + result.add( mthd ); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case METACLASS: + case IDENTIFIER: + p8 = VariableDeclarator(base_env); + FieldDeclaration fld1 = new FieldDeclaration( p1, p2, p8 ); + fld1.setComment( comment ); + result.add( fld1 ); + label_13: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[16] = jj_gen; + break label_13; + } + jj_consume_token(COMMA); + p8 = VariableDeclarator(env); + FieldDeclaration fld2 = new FieldDeclaration( p1, p2, p8 ); + fld2.setComment( comment ); + result.add( fld2 ); + } + jj_consume_token(SEMICOLON); + break; + default: + jj_la1[17] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public TypeName[] ThrowsPhraseOpt(Environment env) throws ParseException { + TypeName[] p1; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case THROWS: + jj_consume_token(THROWS); + p1 = TypeNameList(env); + {if (true) return p1;} + break; + default: + jj_la1[18] = jj_gen; + E(); + {if (true) return null;} + } + throw new Error("Missing return statement in function"); + } + + final public StatementList MethodBody(Environment env) throws ParseException { + StatementList p1; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p1 = BlockedBody(env); + {if (true) return p1;} + break; + case SEMICOLON: + jj_consume_token(SEMICOLON); + {if (true) return null;} + break; + default: + jj_la1[19] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public ModifierList MemberModifiersOpt(Environment env) throws ParseException { + ModifierList result = new ModifierList(); + int p1; + String p2; + if (modifierCheck( env, getToken( 1 ) )) { + label_14: + while (true) { + if (jj_2_9(2147483647)) { + p1 = Modifier(); + result.add( p1 ); + } else if (OpenJavaModifierLookahead( env )) { + p2 = OpenJavaModifier(); + result.add( p2 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (ModifierLookahead( env )) { + ; + } else { + break label_14; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public ClassDeclaration InterfaceDeclaration(ClassEnvironment env) throws ParseException { + ModifierList p1; + ClassDeclaration p2; + + DebugOut.println( "#InterfaceDeclaration()" ); + p1 = InterfaceModifiersOpt(env); + p2 = UnmodifiedInterfaceDeclaration(env); + p2.setModifiers( p1 ); + {if (true) return p2;} + throw new Error("Missing return statement in function"); + } + + final public ModifierList InterfaceModifiersOpt(Environment env) throws ParseException { + ModifierList result = new ModifierList(); + int p1; + String p2; + if ((getToken( 1 ).kind != INTERFACE)) { + label_15: + while (true) { + if (jj_2_10(2147483647)) { + p1 = Modifier(); + result.add( p1 ); + } else if (OpenJavaModifierLookahead( env )) { + p2 = OpenJavaModifier(); + result.add( p2 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (ModifierLookahead( env )) { + ; + } else { + break label_15; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public ClassDeclaration NestedInterfaceDeclaration(ClassEnvironment env) throws ParseException { + ModifierList p1; + ClassDeclaration p2; + + DebugOut.println( "#NestedInterfaceDeclaration()" ); + p1 = NestedInterfaceModifiersOpt(env); + p2 = UnmodifiedInterfaceDeclaration(env); + p2.setModifiers( p1 ); + {if (true) return p2;} + throw new Error("Missing return statement in function"); + } + + final public ModifierList NestedInterfaceModifiersOpt(ClassEnvironment env) throws ParseException { + ModifierList result = new ModifierList(); + int p1; + String p2; + if ((getToken( 1 ).kind != INTERFACE)) { + label_16: + while (true) { + if (jj_2_11(2147483647)) { + p1 = Modifier(); + result.add( p1 ); + } else if (OpenJavaModifierLookahead( env )) { + p2 = OpenJavaModifier(); + result.add( p2 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (ModifierLookahead( env )) { + ; + } else { + break label_16; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public ClassDeclaration UnmodifiedInterfaceDeclaration(ClassEnvironment env) throws ParseException { + ClassDeclaration result; + String p1; + TypeName[] p2; + MemberDeclarationList p3; + String mm; + Hashtable sf; + jj_consume_token(INTERFACE); + p1 = Identifier(); + mm = InstantiatesPhraseOpt(env); + p2 = ExtendsPhraseOpt(env); + sf = OpenJavaDeclSuffixListOpt(env); + p3 = InterfaceBody(env); + result = new ClassDeclaration( null, p1, p2, null, p3, false ); + result.setSuffixes( sf ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public MemberDeclarationList InterfaceBody(ClassEnvironment env) throws ParseException { + MemberDeclarationList p1; + jj_consume_token(LBRACE); + p1 = InterfaceBodyDeclarationListOpt(env); + jj_consume_token(RBRACE); + {if (true) return p1;} + throw new Error("Missing return statement in function"); + } + + final public MemberDeclarationList InterfaceBodyDeclarationListOpt(ClassEnvironment env) throws ParseException { + MemberDeclarationList result = new MemberDeclarationList(); + MemberDeclarationList p1; + if ((getToken( 1 ).kind != RBRACE)) { + label_17: + while (true) { + p1 = InterfaceBodyDeclaration(env); + result.addAll( p1 ); + if ((getToken( 1 ).kind != RBRACE)) { + ; + } else { + break label_17; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public MemberDeclarationList InterfaceBodyDeclaration(ClassEnvironment env) throws ParseException { + ClassEnvironment newenv; + MemberDeclarationList result; + ClassDeclaration p1; + MemberDeclarationList p2; + if (jj_2_12(2147483647)) { + newenv = setClassEnvironment( env ); + p1 = NestedTypeDeclaration(newenv); + result = new MemberDeclarationList( p1 ); + {if (true) return result;} + } else { + p2 = MethodOrFieldDeclaration(env); + {if (true) return p2;} + } + throw new Error("Missing return statement in function"); + } + + final public VariableDeclarator VariableDeclarator(Environment env) throws ParseException { + String p1; + int p2; + VariableInitializer p3 = null; + p1 = Identifier(); + p2 = EmptyBracketsOpt(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ASSIGN: + jj_consume_token(ASSIGN); + p3 = VariableInitializer(env); + break; + default: + jj_la1[20] = jj_gen; + ; + } + {if (true) return new VariableDeclarator( p1, p2, p3 );} + throw new Error("Missing return statement in function"); + } + + final public int EmptyBracketsOpt() throws ParseException { + int result = 0; + if (jj_2_14(2147483647)) { + label_18: + while (true) { + jj_consume_token(LBRACKET); + jj_consume_token(RBRACKET); + result++; + if (jj_2_13(2)) { + ; + } else { + break label_18; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public VariableInitializer VariableInitializer(Environment env) throws ParseException { + VariableInitializer p1; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p1 = ArrayInitializer(env); + {if (true) return p1;} + break; + default: + jj_la1[21] = jj_gen; + if (jj_2_15(1)) { + p1 = Expression(env); + {if (true) return p1;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + throw new Error("Missing return statement in function"); + } + + final public ArrayInitializer ArrayInitializer(Environment env) throws ParseException { + ArrayInitializer result = new ArrayInitializer(); + VariableInitializer p1; + jj_consume_token(LBRACE); + if ((getToken( 1 ).kind != RBRACE + && getToken( 1 ).kind != COMMA)) { + p1 = VariableInitializer(env); + result.add( p1 ); + label_19: + while (true) { + if ((getToken( 1 ).kind == COMMA + && getToken( 2 ).kind != RBRACE)) { + ; + } else { + break label_19; + } + jj_consume_token(COMMA); + p1 = VariableInitializer(env); + result.add( p1 ); + } + } else { + ; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + jj_consume_token(COMMA); + result.omitRemainder( true ); + break; + default: + jj_la1[22] = jj_gen; + ; + } + jj_consume_token(RBRACE); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ParameterList FormalParameters(Environment env) throws ParseException { + ParameterList result = new ParameterList(); + Parameter p1; + + DebugOut.println( "#FormalParameters()" ); + jj_consume_token(LPAREN); + if ((getToken( 1 ).kind != RPAREN)) { + p1 = FormalParameter(env); + result.add( p1 ); + label_20: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[23] = jj_gen; + break label_20; + } + jj_consume_token(COMMA); + p1 = FormalParameter(env); + result.add( p1 ); + } + } else { + ; + } + jj_consume_token(RPAREN); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Parameter FormalParameter(Environment env) throws ParseException { + ModifierList p1; + TypeName p2; + String p3; + int p4; + DebugOut.println( "#FormalParameter()" ); + p1 = FormalParameterModifiersOpt(env); + p2 = Type(env); + p3 = Identifier(); + p4 = EmptyBracketsOpt(); + p2.addDimension( p4 ); + /* binds the parameter variable as the null type */ + env.bindVariable(p3, OJSystem.NULLTYPE); + {if (true) return new Parameter( p1, p2, p3 );} + throw new Error("Missing return statement in function"); + } + + final public ModifierList FormalParameterModifiersOpt(Environment env) throws ParseException { + ModifierList result = new ModifierList(); + int p1; + String p2; + if (modifierCheck( env, getToken( 1 ) )) { + label_21: + while (true) { + if (jj_2_16(2147483647)) { + p1 = Modifier(); + result.add( p1 ); + } else if (OpenJavaModifierLookahead( env )) { + p2 = OpenJavaModifier(); + result.add( p2 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (ModifierLookahead( env )) { + ; + } else { + break label_21; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public ConstructorDeclaration ConstructorDeclaration(Environment base_env) throws ParseException { + Environment env = new ClosedEnvironment( base_env ); + ConstructorDeclaration result; + ModifierList p1; + String p2; + ParameterList p3; + TypeName[] p4; + ConstructorInvocation p5; + StatementList p6; + Hashtable sf; + + DebugOut.println( "#ConstructorDeclaration()" ); + p1 = ConstructorModifiersOpt(base_env); + p2 = Identifier(); + p3 = FormalParameters(env); + p4 = ThrowsPhraseOpt(base_env); + sf = OpenJavaDeclSuffixListOpt(env); + jj_consume_token(LBRACE); + p5 = ExplicitConstructorInvocationOpt(env); + p6 = BlockOrStatementListOpt(env); + jj_consume_token(RBRACE); + result = new ConstructorDeclaration( p1, p2, p3, p4, p5, p6 ); + result.setSuffixes( sf ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ModifierList ConstructorModifiersOpt(Environment env) throws ParseException { + ModifierList result = new ModifierList(); + int p1; + String p2; + if (jj_2_17(2147483647)) { + p1 = Modifier(); + result.add( p1 ); + label_22: + while (true) { + if (OpenJavaModifierLookahead( env )) { + ; + } else { + break label_22; + } + p2 = OpenJavaModifier(); + result.add( p2 ); + } + {if (true) return result;} + } else if (OpenJavaModifierLookahead( env )) { + label_23: + while (true) { + p2 = OpenJavaModifier(); + result.add( p2 ); + if (OpenJavaModifierLookahead( env )) { + ; + } else { + break label_23; + } + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ABSTRACT: + case FINAL: + case NATIVE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case STATIC: + case SYNCHRONIZED: + case TRANSIENT: + case VOLATILE: + p1 = Modifier(); + result.add( p1 ); + label_24: + while (true) { + if (OpenJavaModifierLookahead( env )) { + ; + } else { + break label_24; + } + p2 = OpenJavaModifier(); + result.add( p2 ); + } + break; + default: + jj_la1[24] = jj_gen; + ; + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public ConstructorInvocation ExplicitConstructorInvocationOpt(Environment env) throws ParseException { + ExpressionList p1; + Expression p2 = null; + + DebugOut.println( "#ExplicitConstructorInvocationOpt()" ); + if (jj_2_18(2147483647)) { + jj_consume_token(THIS); + p1 = Arguments(env); + jj_consume_token(SEMICOLON); + {if (true) return new ConstructorInvocation( p1 );} + } else if (ConstructorInvocationLookahead()) { + if ((getToken( 1 ).kind != SUPER)) { + p2 = PrimaryExpression(env); + jj_consume_token(DOT); + } else { + ; + } + jj_consume_token(SUPER); + p1 = Arguments(env); + jj_consume_token(SEMICOLON); + {if (true) return new ConstructorInvocation( p1, p2 );} + } else { + E(); + {if (true) return null;} + } + throw new Error("Missing return statement in function"); + } + + final public MemberInitializer MemberInitializer(Environment env) throws ParseException { + MemberInitializer result; + StatementList p1; + boolean is_static = false; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case STATIC: + jj_consume_token(STATIC); + is_static = true; + break; + default: + jj_la1[25] = jj_gen; + ; + } + p1 = BlockedBody(env); + if (is_static) { + result = new MemberInitializer( p1, true ); + } else { + result = new MemberInitializer( p1 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + +/* + * Type, name and expression syntax follows. + */ + final public TypeName Type(Environment env) throws ParseException { + TypeName result; + String p1; + Hashtable p2; + int p3; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + case VOID: + p1 = PrimitiveType(); + break; + case METACLASS: + case IDENTIFIER: + p1 = Name(); + break; + default: + jj_la1[26] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = OpenJavaTypeSuffixListOpt(env, p1); + p3 = EmptyBracketsOpt(); + result = new TypeName( p1, p3, p2 ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public String PrimitiveType() throws ParseException { + String result; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BOOLEAN: + jj_consume_token(BOOLEAN); + break; + case CHAR: + jj_consume_token(CHAR); + break; + case BYTE: + jj_consume_token(BYTE); + break; + case SHORT: + jj_consume_token(SHORT); + break; + case INT: + jj_consume_token(INT); + break; + case LONG: + jj_consume_token(LONG); + break; + case FLOAT: + jj_consume_token(FLOAT); + break; + case DOUBLE: + jj_consume_token(DOUBLE); + break; + case VOID: + jj_consume_token(VOID); + break; + default: + jj_la1[27] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + result = getToken( 0 ).image; + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public String Name() throws ParseException { + String p1; + StringBuffer strbuf = null; + p1 = Identifier(); + strbuf = new StringBuffer( p1 ); + label_25: + while (true) { + if (jj_2_19(2)) { + ; + } else { + break label_25; + } + jj_consume_token(DOT); + p1 = Identifier(); + strbuf.append( "." + p1 ); + } + {if (true) return strbuf.toString();} + throw new Error("Missing return statement in function"); + } + + final public TypeName TypeName(Environment env) throws ParseException { + TypeName result; + String p1; + Hashtable p2; + p1 = Name(); + p2 = OpenJavaTypeSuffixListOpt(env, p1); + result = new TypeName( p1, p2 ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public TypeName[] TypeNameList(Environment env) throws ParseException { + TypeName[] result; + TypeName p1; + Vector v = new Vector(); + p1 = TypeName(env); + v.addElement( p1 ); + label_26: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[28] = jj_gen; + break label_26; + } + jj_consume_token(COMMA); + p1 = TypeName(env); + v.addElement( p1 ); + } + result = new TypeName[v.size()]; + for (int i = 0; i < result.length; ++i) { + result[i] = (TypeName) v.elementAt( i ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public TypeName[] TypeNameListOpt(Environment env) throws ParseException { + TypeName[] result; + TypeName p1; + Vector v = new Vector(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case METACLASS: + case IDENTIFIER: + p1 = TypeName(env); + v.addElement( p1 ); + label_27: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[29] = jj_gen; + break label_27; + } + jj_consume_token(COMMA); + p1 = TypeName(env); + v.addElement( p1 ); + } + result = new TypeName[v.size()]; + for (int i = 0; i < result.length; ++i) { + result[i] = (TypeName) v.elementAt( i ); + } + {if (true) return result;} + break; + default: + jj_la1[30] = jj_gen; + E(); + {if (true) return new TypeName[0];} + } + throw new Error("Missing return statement in function"); + } + +/* + * Expression syntax follows. + */ + final public Expression Expression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2 = null; + Expression p3 = null; + + DebugOut.println( "#Expression()" ); + p1 = ConditionalExpression(env); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ASSIGN: + case PLUSASSIGN: + case MINUSASSIGN: + case STARASSIGN: + case SLASHASSIGN: + case ANDASSIGN: + case ORASSIGN: + case XORASSIGN: + case REMASSIGN: + case LSHIFTASSIGN: + case RSIGNEDSHIFTASSIGN: + case RUNSIGNEDSHIFTASSIGN: + p2 = AssignmentOperator(); + p3 = Expression(env); + break; + default: + jj_la1[31] = jj_gen; + ; + } + if (p2 != null) { + result = new AssignmentExpression( p1, p2, p3 ); + } else { + result = p1; + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public AssignmentExpression AssignmentExpression(Environment env) throws ParseException { + Expression p1; + String p2; + Expression p3; + + DebugOut.println( "#AssignmentExpression()" ); + p1 = PrimaryExpression(env); + p2 = AssignmentOperator(); + p3 = Expression(env); + {if (true) return new AssignmentExpression( p1, p2, p3 );} + throw new Error("Missing return statement in function"); + } + + final public String AssignmentOperator() throws ParseException { + String result; + + DebugOut.println( "#AssignmentOperator()" ); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ASSIGN: + jj_consume_token(ASSIGN); + break; + case STARASSIGN: + jj_consume_token(STARASSIGN); + break; + case SLASHASSIGN: + jj_consume_token(SLASHASSIGN); + break; + case REMASSIGN: + jj_consume_token(REMASSIGN); + break; + case PLUSASSIGN: + jj_consume_token(PLUSASSIGN); + break; + case MINUSASSIGN: + jj_consume_token(MINUSASSIGN); + break; + case LSHIFTASSIGN: + jj_consume_token(LSHIFTASSIGN); + break; + case RSIGNEDSHIFTASSIGN: + jj_consume_token(RSIGNEDSHIFTASSIGN); + break; + case RUNSIGNEDSHIFTASSIGN: + jj_consume_token(RUNSIGNEDSHIFTASSIGN); + break; + case ANDASSIGN: + jj_consume_token(ANDASSIGN); + break; + case XORASSIGN: + jj_consume_token(XORASSIGN); + break; + case ORASSIGN: + jj_consume_token(ORASSIGN); + break; + default: + jj_la1[32] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + result = getToken( 0 ).image; + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression ConditionalExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + Expression p2 = null; + Expression p3 = null; + p1 = ConditionalOrExpression(env); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case HOOK: + jj_consume_token(HOOK); + p2 = Expression(env); + jj_consume_token(COLON); + p3 = ConditionalExpression(env); + break; + default: + jj_la1[33] = jj_gen; + ; + } + if (p2 != null) { + result = new ConditionalExpression( p1, p2, p3 ); + } else { + result = p1; + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression ConditionalOrExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = ConditionalAndExpression(env); + result = p1; + label_28: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SC_OR: + ; + break; + default: + jj_la1[34] = jj_gen; + break label_28; + } + jj_consume_token(SC_OR); + p2 = getToken( 0 ).image; + p3 = ConditionalAndExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression ConditionalAndExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = InclusiveOrExpression(env); + result = p1; + label_29: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SC_AND: + ; + break; + default: + jj_la1[35] = jj_gen; + break label_29; + } + jj_consume_token(SC_AND); + p2 = getToken( 0 ).image; + p3 = InclusiveOrExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression InclusiveOrExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = ExclusiveOrExpression(env); + result = p1; + label_30: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BIT_OR: + ; + break; + default: + jj_la1[36] = jj_gen; + break label_30; + } + jj_consume_token(BIT_OR); + p2 = getToken( 0 ).image; + p3 = ExclusiveOrExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression ExclusiveOrExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = AndExpression(env); + result = p1; + label_31: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case XOR: + ; + break; + default: + jj_la1[37] = jj_gen; + break label_31; + } + jj_consume_token(XOR); + p2 = getToken( 0 ).image; + p3 = AndExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression AndExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = EqualityExpression(env); + result = p1; + label_32: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BIT_AND: + ; + break; + default: + jj_la1[38] = jj_gen; + break label_32; + } + jj_consume_token(BIT_AND); + p2 = getToken( 0 ).image; + p3 = EqualityExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression EqualityExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + + DebugOut.println( "#EqualityExpression()" ); + p1 = InstanceofExpression(env); + result = p1; + label_33: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case EQ: + case NE: + ; + break; + default: + jj_la1[39] = jj_gen; + break label_33; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case EQ: + jj_consume_token(EQ); + break; + case NE: + jj_consume_token(NE); + break; + default: + jj_la1[40] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = getToken( 0 ).image; + p3 = InstanceofExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression InstanceofExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + TypeName p2 = null; + p1 = RelationalExpression(env); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INSTANCEOF: + jj_consume_token(INSTANCEOF); + p2 = Type(env); + break; + default: + jj_la1[41] = jj_gen; + ; + } + if (p2 != null) { + result = new InstanceofExpression( p1, p2 ); + } else { + result = p1; + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression RelationalExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = ShiftExpression(env); + result = p1; + label_34: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case GT: + case LT: + case LE: + case GE: + ; + break; + default: + jj_la1[42] = jj_gen; + break label_34; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LT: + jj_consume_token(LT); + break; + case GT: + jj_consume_token(GT); + break; + case LE: + jj_consume_token(LE); + break; + case GE: + jj_consume_token(GE); + break; + default: + jj_la1[43] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = getToken( 0 ).image; + p3 = ShiftExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression ShiftExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = AdditiveExpression(env); + result = p1; + label_35: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LSHIFT: + case RSIGNEDSHIFT: + case RUNSIGNEDSHIFT: + ; + break; + default: + jj_la1[44] = jj_gen; + break label_35; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LSHIFT: + jj_consume_token(LSHIFT); + break; + case RSIGNEDSHIFT: + jj_consume_token(RSIGNEDSHIFT); + break; + case RUNSIGNEDSHIFT: + jj_consume_token(RUNSIGNEDSHIFT); + break; + default: + jj_la1[45] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = getToken( 0 ).image; + p3 = AdditiveExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression AdditiveExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = MultiplicativeExpression(env); + result = p1; + label_36: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case PLUS: + case MINUS: + ; + break; + default: + jj_la1[46] = jj_gen; + break label_36; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case PLUS: + jj_consume_token(PLUS); + break; + case MINUS: + jj_consume_token(MINUS); + break; + default: + jj_la1[47] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = getToken( 0 ).image; + p3 = MultiplicativeExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression MultiplicativeExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + String p2; + Expression p3; + p1 = UnaryExpression(env); + result = p1; + label_37: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case STAR: + case SLASH: + case REM: + ; + break; + default: + jj_la1[48] = jj_gen; + break label_37; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case STAR: + jj_consume_token(STAR); + break; + case SLASH: + jj_consume_token(SLASH); + break; + case REM: + jj_consume_token(REM); + break; + default: + jj_la1[49] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = getToken( 0 ).image; + p3 = UnaryExpression(env); + result = new BinaryExpression( result, p2, p3 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression UnaryExpression(Environment env) throws ParseException { + int p1; + Expression p2; + if (jj_2_20(2147483647)) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case PLUS: + jj_consume_token(PLUS); + p1 = UnaryExpression.PLUS; + break; + case MINUS: + jj_consume_token(MINUS); + p1 = UnaryExpression.MINUS; + break; + default: + jj_la1[50] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = UnaryExpression(env); + {if (true) return new UnaryExpression( p1, p2 );} + } else if (jj_2_21(2147483647)) { + p2 = PreIncrementExpression(env); + {if (true) return p2;} + } else if (jj_2_22(1)) { + p2 = UnaryExpressionNotPlusMinus(env); + {if (true) return p2;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public Expression PreIncrementExpression(Environment env) throws ParseException { + int p1; + Expression p2; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INCR: + jj_consume_token(INCR); + p1 = UnaryExpression.PRE_INCREMENT; + break; + case DECR: + jj_consume_token(DECR); + p1 = UnaryExpression.PRE_DECREMENT; + break; + default: + jj_la1[51] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = PrimaryExpression(env); + {if (true) return new UnaryExpression( p1, p2 );} + throw new Error("Missing return statement in function"); + } + + final public Expression UnaryExpressionNotPlusMinus(Environment env) throws ParseException { + int p1; + Expression p2; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BANG: + case TILDE: + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case TILDE: + jj_consume_token(TILDE); + p1 = UnaryExpression.BIT_NOT; + break; + case BANG: + jj_consume_token(BANG); + p1 = UnaryExpression.NOT; + break; + default: + jj_la1[52] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = UnaryExpression(env); + {if (true) return new UnaryExpression( p1, p2 );} + break; + default: + jj_la1[53] = jj_gen; + if (jj_2_23(2147483647)) { + p2 = CastExpression(env); + {if (true) return p2;} + } else if (jj_2_24(1)) { + p2 = PostfixExpression(env); + {if (true) return p2;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + throw new Error("Missing return statement in function"); + } + + final public void CastLookahead(Environment env) throws ParseException { + if (jj_2_25(2)) { + jj_consume_token(LPAREN); + PrimitiveType(); + } else if (jj_2_26(2147483647)) { + jj_consume_token(LPAREN); + Name(); + jj_consume_token(LBRACKET); + jj_consume_token(RBRACKET); + } else if (jj_2_27(2147483647)) { + jj_consume_token(LPAREN); + Name(); + jj_consume_token(RPAREN); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case TILDE: + jj_consume_token(TILDE); + break; + case BANG: + jj_consume_token(BANG); + break; + case LPAREN: + jj_consume_token(LPAREN); + break; + case METACLASS: + case IDENTIFIER: + Identifier(); + break; + case THIS: + jj_consume_token(THIS); + break; + case SUPER: + jj_consume_token(SUPER); + break; + case NEW: + jj_consume_token(NEW); + break; + case FALSE: + case NULL: + case TRUE: + case INTEGER_LITERAL: + case LONG_LITERAL: + case DOUBLE_FLOATING_POINT_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + Literal(); + break; + default: + jj_la1[54] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LPAREN: + jj_consume_token(LPAREN); + Name(); + Identifier(); + break; + default: + jj_la1[55] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + } + + final public Expression PostfixExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + int p2 = -1; + p1 = PrimaryExpression(env); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INCR: + case DECR: + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INCR: + jj_consume_token(INCR); + p2 = UnaryExpression.POST_INCREMENT; + break; + case DECR: + jj_consume_token(DECR); + p2 = UnaryExpression.POST_DECREMENT; + break; + default: + jj_la1[56] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + break; + default: + jj_la1[57] = jj_gen; + ; + } + if (p2 != -1) { + result = new UnaryExpression( p1, p2 ); + } else { + result = p1; + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public CastExpression CastExpression(Environment env) throws ParseException { + TypeName p1; + Expression p2; + + DebugOut.println( "#CastExpression()" ); + if (jj_2_28(2147483647)) { + jj_consume_token(LPAREN); + p1 = Type(env); + jj_consume_token(RPAREN); + p2 = UnaryExpression(env); + {if (true) return new CastExpression( p1, p2 );} + } else if (jj_2_29(2147483647)) { + jj_consume_token(LPAREN); + p1 = Type(env); + jj_consume_token(RPAREN); + p2 = UnaryExpressionNotPlusMinus(env); + {if (true) return new CastExpression( p1, p2 );} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public Expression SelfAccess(Environment env) throws ParseException { + Expression result; + String p1 = null; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case METACLASS: + case IDENTIFIER: + p1 = Name(); + jj_consume_token(DOT); + break; + default: + jj_la1[58] = jj_gen; + ; + } + jj_consume_token(THIS); + if (p1 != null) { + result = SelfAccess.makeThis( p1 ); + } else { + result = SelfAccess.constantThis(); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ClassLiteral ClassLiteral(Environment env) throws ParseException { + TypeName p1; + p1 = Type(env); + jj_consume_token(DOT); + jj_consume_token(CLASS); + {if (true) return new ClassLiteral( p1 );} + throw new Error("Missing return statement in function"); + } + + final public Expression PrimaryExpression(Environment env) throws ParseException { + Expression result; + Expression p1; + Expression p2; + Expression p3; + String p4; + ExpressionList p5; + p1 = PrimaryPrefix(env); + result = p1; + label_38: + while (true) { + if (jj_2_30(2147483647)) { + ; + } else { + break label_38; + } + if (jj_2_31(2147483647)) { + jj_consume_token(DOT); + p2 = AllocationExpression(env); + AllocationExpression alloc = (AllocationExpression) p2; + alloc.setEncloser( result ); + result = alloc; + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACKET: + jj_consume_token(LBRACKET); + p3 = Expression(env); + jj_consume_token(RBRACKET); + result = new ArrayAccess( result, p3 ); + break; + case DOT: + jj_consume_token(DOT); + p4 = Identifier(); + result = new FieldAccess( result, p4 ); + break; + case LPAREN: + p5 = Arguments(env); + FieldAccess base = (FieldAccess) result; + Expression expr = base.getReferenceExpr(); + String name = base.getName(); + result = new MethodCall( expr, name, p5 ); + break; + default: + jj_la1[59] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression PrimaryPrefix(Environment env) throws ParseException { + Expression p1; + String p2; + + DebugOut.println( "#PrimaryPrefix()" ); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case FALSE: + case NULL: + case TRUE: + case INTEGER_LITERAL: + case LONG_LITERAL: + case DOUBLE_FLOATING_POINT_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + p1 = Literal(); + {if (true) return p1;} + break; + default: + jj_la1[60] = jj_gen; + if (jj_2_32(2147483647)) { + p1 = SelfAccess(env); + {if (true) return p1;} + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SUPER: + jj_consume_token(SUPER); + jj_consume_token(DOT); + p2 = Identifier(); + {if (true) return new FieldAccess( SelfAccess.constantSuper(), p2 );} + break; + case LPAREN: + jj_consume_token(LPAREN); + p1 = Expression(env); + jj_consume_token(RPAREN); + {if (true) return p1;} + break; + case NEW: + p1 = AllocationExpression(env); + {if (true) return p1;} + break; + default: + jj_la1[61] = jj_gen; + if (ClassLiteralLookahead()) { + p1 = ClassLiteral(env); + {if (true) return p1;} + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case METACLASS: + case IDENTIFIER: + p1 = TempFieldAccess(env); + {if (true) return p1;} + break; + default: + jj_la1[62] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + } + } + } + throw new Error("Missing return statement in function"); + } + + final public FieldAccess TempFieldAccess(Environment env) throws ParseException { + FieldAccess result; + String p1; + StringBuffer strbuf = null; + p1 = Identifier(); + label_39: + while (true) { + if (jj_2_33(2147483647)) { + ; + } else { + break label_39; + } + jj_consume_token(DOT); + if (strbuf == null) { + strbuf = new StringBuffer( p1 ); + } else { + strbuf.append( "." + p1 ); + } + p1 = Identifier(); + } + if (strbuf == null || strbuf.length() == 0) { + result = new FieldAccess( (Variable) null, p1 ); + } else { + Variable var = new Variable( strbuf.toString() ); + result = new FieldAccess( var, p1 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Literal Literal() throws ParseException { + String p1; + Literal p2; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INTEGER_LITERAL: + jj_consume_token(INTEGER_LITERAL); + p1 = getToken( 0 ).image; + {if (true) return new Literal( Literal.INTEGER, p1 );} + break; + case LONG_LITERAL: + jj_consume_token(LONG_LITERAL); + p1 = getToken( 0 ).image; + {if (true) return new Literal( Literal.LONG, p1 );} + break; + case FLOATING_POINT_LITERAL: + jj_consume_token(FLOATING_POINT_LITERAL); + p1 = getToken( 0 ).image; + {if (true) return new Literal( Literal.FLOAT, p1 );} + break; + case DOUBLE_FLOATING_POINT_LITERAL: + jj_consume_token(DOUBLE_FLOATING_POINT_LITERAL); + p1 = getToken( 0 ).image; + {if (true) return new Literal( Literal.DOUBLE, p1 );} + break; + case CHARACTER_LITERAL: + jj_consume_token(CHARACTER_LITERAL); + p1 = getToken( 0 ).image; + {if (true) return new Literal( Literal.CHARACTER, p1 );} + break; + case STRING_LITERAL: + jj_consume_token(STRING_LITERAL); + p1 = getToken( 0 ).image; + {if (true) return new Literal( Literal.STRING, p1 );} + break; + case TRUE: + jj_consume_token(TRUE); + {if (true) return Literal.constantTrue();} + break; + case FALSE: + jj_consume_token(FALSE); + {if (true) return Literal.constantFalse();} + break; + case NULL: + jj_consume_token(NULL); + {if (true) return Literal.constantNull();} + break; + default: + jj_la1[63] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public ExpressionList Arguments(Environment env) throws ParseException { + ExpressionList result = new ExpressionList(); + Expression p1; + + DebugOut.println( "#Arguments()" ); + jj_consume_token(LPAREN); + if (jj_2_34(1)) { + p1 = Expression(env); + result.add( p1 ); + label_40: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[64] = jj_gen; + break label_40; + } + jj_consume_token(COMMA); + p1 = Expression(env); + result.add( p1 ); + } + } else { + ; + } + jj_consume_token(RPAREN); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public Expression AllocationExpression(Environment env) throws ParseException { + Expression result; + AllocationExpression aloc_result; + TypeName p1; + ArrayAllocationExpression p2; + ExpressionList p3; + MemberDeclarationList p4 = null; + + DebugOut.println( "#AllocationExpression()" ); + if (jj_2_36(2147483647)) { + jj_consume_token(NEW); + p1 = TypeWithoutDims(env); + p2 = ArrayDimsAndInits(env, p1); + result = p2; + {if (true) return result;} + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case NEW: + jj_consume_token(NEW); + p1 = TypeWithoutDims(env); + if (jj_2_35(2147483647)) { + p2 = ArrayDimsAndInits(env, p1); + result = p2; + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LPAREN: + p3 = Arguments(env); + aloc_result = new AllocationExpression( p1, p3, p4 ); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p4 = ClassBody(new ClassEnvironment( env )); + aloc_result.setClassBody( p4 ); + break; + default: + jj_la1[65] = jj_gen; + ; + } + result = aloc_result; + break; + default: + jj_la1[66] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + {if (true) return result;} + break; + default: + jj_la1[67] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + throw new Error("Missing return statement in function"); + } + + final public TypeName TypeWithoutDims(Environment env) throws ParseException { + String p1; + Hashtable p2; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + case VOID: + p1 = PrimitiveType(); + break; + case METACLASS: + case IDENTIFIER: + p1 = Name(); + break; + default: + jj_la1[68] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + p2 = OpenJavaTypeSuffixListOpt(env, p1); + {if (true) return new TypeName( p1, p2 );} + throw new Error("Missing return statement in function"); + } + + final public ArrayAllocationExpression ArrayDimsAndInits(Environment env, TypeName type) throws ParseException { + Expression p1; + int p2; + ArrayInitializer p3; + ExpressionList exprs = new ExpressionList(); + if (jj_2_37(2147483647)) { + p2 = EmptyBracketsOpt(); + p3 = ArrayInitializer(env); + for (int i = 0; i < p2; ++i) exprs.add( null ); + {if (true) return new ArrayAllocationExpression( type, exprs, p3 );} + } else if (jj_2_38(2147483647)) { + label_41: + while (true) { + jj_consume_token(LBRACKET); + p1 = Expression(env); + exprs.add( p1 ); + jj_consume_token(RBRACKET); + if ((getToken( 1 ).kind == LBRACKET + && getToken( 2 ).kind != RBRACKET)) { + ; + } else { + break label_41; + } + } + p2 = EmptyBracketsOpt(); + for (int i = 0; i < p2; ++i) exprs.add( null ); + {if (true) return new ArrayAllocationExpression( type, exprs );} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public StatementList BlockedBody(Environment env) throws ParseException { + StatementList p1; + jj_consume_token(LBRACE); + p1 = BlockOrStatementListOpt(env); + jj_consume_token(RBRACE); + {if (true) return p1;} + throw new Error("Missing return statement in function"); + } + +/* + * Statement syntax follows. + */ + final public Statement Statement(Environment env) throws ParseException { + Statement p1; + if (jj_2_39(2147483647)) { + p1 = LabeledStatement(env); + {if (true) return p1;} + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p1 = Block(env); + {if (true) return p1;} + break; + case SEMICOLON: + p1 = EmptyStatement(env); + {if (true) return p1;} + break; + case SWITCH: + p1 = SwitchStatement(env); + {if (true) return p1;} + break; + case IF: + p1 = IfStatement(env); + {if (true) return p1;} + break; + case WHILE: + p1 = WhileStatement(env); + {if (true) return p1;} + break; + case DO: + p1 = DoWhileStatement(env); + {if (true) return p1;} + break; + case FOR: + p1 = ForStatement(env); + {if (true) return p1;} + break; + case BREAK: + p1 = BreakStatement(env); + {if (true) return p1;} + break; + case CONTINUE: + p1 = ContinueStatement(env); + {if (true) return p1;} + break; + case RETURN: + p1 = ReturnStatement(env); + {if (true) return p1;} + break; + case THROW: + p1 = ThrowStatement(env); + {if (true) return p1;} + break; + case SYNCHRONIZED: + p1 = SynchronizedStatement(env); + {if (true) return p1;} + break; + case TRY: + p1 = TryStatement(env); + {if (true) return p1;} + break; + default: + jj_la1[69] = jj_gen; + if (jj_2_40(1)) { + p1 = ExpressionStatement(env); + {if (true) return p1;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + } + throw new Error("Missing return statement in function"); + } + + final public LabeledStatement LabeledStatement(Environment env) throws ParseException { + String p1; + Statement p2; + + DebugOut.println( "#LabeledStatement()" ); + p1 = Identifier(); + jj_consume_token(COLON); + p2 = Statement(env); + {if (true) return new LabeledStatement( p1, p2 );} + throw new Error("Missing return statement in function"); + } + + final public Block Block(Environment env) throws ParseException { + StatementList p1; + DebugOut.println( "#Block()" ); + jj_consume_token(LBRACE); + p1 = BlockOrStatementListOpt(env); + jj_consume_token(RBRACE); + {if (true) return new Block( p1 );} + throw new Error("Missing return statement in function"); + } + + final public StatementList BlockOrStatementListOpt(Environment env) throws ParseException { + StatementList result = new StatementList(); + StatementList p1; + if ((getToken( 1 ).kind != RBRACE + && getToken( 1 ).kind != EOF + && getToken( 1 ).kind != CASE + && getToken( 1 ).kind != _DEFAULT )) { + label_42: + while (true) { + p1 = BlockOrStatement(env); + result.addAll( p1 ); + if ((getToken( 1 ).kind != RBRACE + && getToken( 1 ).kind != EOF + && getToken( 1 ).kind != CASE + && getToken( 1 ).kind != _DEFAULT )) { + ; + } else { + break label_42; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public StatementList BlockOrStatement(Environment env) throws ParseException { + Statement p1; + StatementList p2; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case CLASS: + p1 = UnmodifiedClassDeclaration(new ClassEnvironment( env )); + {if (true) return new StatementList( p1 );} + break; + default: + jj_la1[70] = jj_gen; + if (LocalVariableDeclarationLookahead( env )) { + p2 = LocalVariableDeclaration(env); + jj_consume_token(SEMICOLON); + {if (true) return p2;} + } else if (jj_2_41(1)) { + p1 = Statement(env); + {if (true) return new StatementList( p1 );} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + throw new Error("Missing return statement in function"); + } + + final public StatementList LocalVariableDeclaration(Environment env) throws ParseException { + StatementList result = new StatementList(); + ModifierList p1; + TypeName p2; + VariableDeclarator p3; + TypeName tspec; + String vname; + VariableInitializer vinit; + DebugOut.println( "#LocalVariableDeclaration()" ); + p1 = VariableModifiersOpt(env); + p2 = Type(env); + p3 = VariableDeclarator(env); + tspec = (TypeName) p2.makeRecursiveCopy(); + tspec.addDimension( p3.getDimension() ); + vname = p3.getVariable(); + vinit = p3.getInitializer(); + result.add( new VariableDeclaration( p1, tspec, vname, vinit ) ); + label_43: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[71] = jj_gen; + break label_43; + } + jj_consume_token(COMMA); + p3 = VariableDeclarator(env); + tspec = (TypeName) p2.makeRecursiveCopy(); + tspec.addDimension( p3.getDimension() ); + vname = p3.getVariable(); + vinit = p3.getInitializer(); + result.add( new VariableDeclaration( p1, tspec, vname, vinit ) ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ModifierList VariableModifiersOpt(Environment env) throws ParseException { + ModifierList result = new ModifierList(); + int p1; + String p2; + if (modifierCheck( env, getToken( 1 ) )) { + label_44: + while (true) { + if (jj_2_42(2147483647)) { + p1 = Modifier(); + result.add( p1 ); + } else if (OpenJavaModifierLookahead( env )) { + p2 = OpenJavaModifier(); + result.add( p2 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + if (ModifierLookahead( env )) { + ; + } else { + break label_44; + } + } + {if (true) return result;} + } else { + E(); + {if (true) return result;} + } + throw new Error("Missing return statement in function"); + } + + final public EmptyStatement EmptyStatement(Environment env) throws ParseException { + DebugOut.println( "#EmptyStatement()" ); + jj_consume_token(SEMICOLON); + {if (true) return new EmptyStatement();} + throw new Error("Missing return statement in function"); + } + + final public ExpressionStatement ExpressionStatement(Environment env) throws ParseException { + Expression p1; + + DebugOut.println( "#ExpressionStatement()" ); + p1 = StatementExpression(env); + jj_consume_token(SEMICOLON); + {if (true) return new ExpressionStatement( p1 );} + throw new Error("Missing return statement in function"); + } + + final public Expression StatementExpression(Environment env) throws ParseException { + Expression p1; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INCR: + case DECR: + p1 = PreIncrementExpression(env); + {if (true) return p1;} + break; + default: + jj_la1[72] = jj_gen; + if (AssignmentLookahead()) { + p1 = AssignmentExpression(env); + {if (true) return p1;} + } else if (jj_2_43(1)) { + p1 = PostfixExpression(env); + {if (true) return p1;} + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + throw new Error("Missing return statement in function"); + } + + final public SwitchStatement SwitchStatement(Environment env) throws ParseException { + Expression p1; + Expression p2; + StatementList p3; + CaseGroupList cplist = new CaseGroupList(); + ExpressionList exprs; + + DebugOut.println( "#SwitchStatement()" ); + jj_consume_token(SWITCH); + jj_consume_token(LPAREN); + p1 = Expression(env); + jj_consume_token(RPAREN); + jj_consume_token(LBRACE); + label_45: + while (true) { + if (jj_2_44(2147483647)) { + ; + } else { + break label_45; + } + exprs = new ExpressionList(); + label_46: + while (true) { + p2 = SwitchLabel(env); + exprs.add( p2 ); + if (jj_2_45(2147483647)) { + ; + } else { + break label_46; + } + } + p3 = BlockOrStatementListOpt(env); + cplist.add( new CaseGroup( exprs, p3 ) ); + } + jj_consume_token(RBRACE); + {if (true) return new SwitchStatement( p1, cplist );} + throw new Error("Missing return statement in function"); + } + + final public Expression SwitchLabel(Environment env) throws ParseException { + Expression p1; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case CASE: + jj_consume_token(CASE); + p1 = Expression(env); + jj_consume_token(COLON); + {if (true) return p1;} + break; + case _DEFAULT: + jj_consume_token(_DEFAULT); + jj_consume_token(COLON); + {if (true) return null;} + break; + default: + jj_la1[73] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + throw new Error("Missing return statement in function"); + } + + final public IfStatement IfStatement(Environment env) throws ParseException { + IfStatement result; + Expression p1; + StatementList p2; + Statement p3; + StatementList true_part; + StatementList false_part = null; + + DebugOut.println( "#IfStatement()" ); + jj_consume_token(IF); + jj_consume_token(LPAREN); + p1 = Expression(env); + jj_consume_token(RPAREN); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p2 = BlockedBody(env); + true_part = p2; + break; + default: + jj_la1[74] = jj_gen; + if (jj_2_46(1)) { + p3 = Statement(env); + true_part = new StatementList( p3 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case ELSE: + jj_consume_token(ELSE); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p2 = BlockedBody(env); + false_part = p2; + break; + default: + jj_la1[75] = jj_gen; + if (jj_2_47(1)) { + p3 = Statement(env); + false_part = new StatementList( p3 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + break; + default: + jj_la1[76] = jj_gen; + ; + } + {if (true) return new IfStatement( p1, true_part, false_part );} + throw new Error("Missing return statement in function"); + } + + final public WhileStatement WhileStatement(Environment env) throws ParseException { + Expression p1; + StatementList p2; + Statement p3; + StatementList body; + + DebugOut.println( "#WhileStatement()" ); + jj_consume_token(WHILE); + jj_consume_token(LPAREN); + p1 = Expression(env); + jj_consume_token(RPAREN); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p2 = BlockedBody(env); + body = p2; + break; + default: + jj_la1[77] = jj_gen; + if (jj_2_48(1)) { + p3 = Statement(env); + body = new StatementList( p3 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + {if (true) return new WhileStatement( p1, body );} + throw new Error("Missing return statement in function"); + } + + final public DoWhileStatement DoWhileStatement(Environment env) throws ParseException { + StatementList p1; + Statement p2; + Expression p3; + StatementList body; + + DebugOut.println( "#DoWhileStatement()" ); + jj_consume_token(DO); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p1 = BlockedBody(env); + body = p1; + break; + default: + jj_la1[78] = jj_gen; + if (jj_2_49(1)) { + p2 = Statement(env); + body = new StatementList( p2 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + jj_consume_token(WHILE); + jj_consume_token(LPAREN); + p3 = Expression(env); + jj_consume_token(RPAREN); + jj_consume_token(SEMICOLON); + {if (true) return new DoWhileStatement( body, p3 );} + throw new Error("Missing return statement in function"); + } + + final public ForStatement ForStatement(Environment env) throws ParseException { + ForStatement result; + TypeName p1 = null; + VariableDeclarator[] p2 = null; + ExpressionList p3 = null; + Expression p4 = null; + ExpressionList p5 = null; + StatementList p6; + Statement p7; + StatementList body; + + DebugOut.println( "#ForStatement()" ); + jj_consume_token(FOR); + jj_consume_token(LPAREN); + if ((getToken( 1 ).kind != SEMICOLON)) { + if (LocalVariableDeclarationLookahead( env )) { + p1 = Type(env); + p2 = VariableDeclaratorList(env); + } else if (jj_2_50(1)) { + p3 = StatementExpressionList(env); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } else { + ; + } + jj_consume_token(SEMICOLON); + if ((getToken( 1 ).kind != SEMICOLON)) { + p4 = Expression(env); + } else { + ; + } + jj_consume_token(SEMICOLON); + if ((getToken( 1 ).kind != RPAREN)) { + p5 = StatementExpressionList(env); + } else { + ; + } + jj_consume_token(RPAREN); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LBRACE: + p6 = BlockedBody(env); + body = p6; + break; + default: + jj_la1[79] = jj_gen; + if (jj_2_51(1)) { + p7 = Statement(env); + body = new StatementList( p7 ); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + } + if (p1 != null) { + result = new ForStatement( p1, p2, p4, p5, body ); + } else if (p3 != null) { + result = new ForStatement( p3, p4, p5, body ); + } else { + result = new ForStatement( new ExpressionList(), p4, p5, body ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public VariableDeclarator[] VariableDeclaratorList(Environment env) throws ParseException { + VariableDeclarator[] result; + VariableDeclarator p1; + Vector v = new Vector(); + + DebugOut.println( "#LocalVariableDeclaration()" ); + p1 = VariableDeclarator(env); + v.addElement( p1 ); + label_47: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[80] = jj_gen; + break label_47; + } + jj_consume_token(COMMA); + p1 = VariableDeclarator(env); + v.addElement( p1 ); + } + result = new VariableDeclarator[v.size()]; + for (int i = 0; i < result.length; ++i) { + result[i] = (VariableDeclarator) v.elementAt( i ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ExpressionList StatementExpressionList(Environment env) throws ParseException { + ExpressionList result = new ExpressionList(); + Expression p1; + p1 = StatementExpression(env); + result.add( p1 ); + label_48: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case COMMA: + ; + break; + default: + jj_la1[81] = jj_gen; + break label_48; + } + jj_consume_token(COMMA); + p1 = StatementExpression(env); + result.add( p1 ); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public BreakStatement BreakStatement(Environment env) throws ParseException { + BreakStatement result; + String p1 = null; + + DebugOut.println( "#BreakStatement()" ); + jj_consume_token(BREAK); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case METACLASS: + case IDENTIFIER: + p1 = Identifier(); + break; + default: + jj_la1[82] = jj_gen; + ; + } + jj_consume_token(SEMICOLON); + if (p1 != null) { + result = new BreakStatement( p1 ); + } else { + result = new BreakStatement(); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ContinueStatement ContinueStatement(Environment env) throws ParseException { + ContinueStatement result; + String p1 = null; + + DebugOut.println( "#ContinueStatement()" ); + jj_consume_token(CONTINUE); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case METACLASS: + case IDENTIFIER: + p1 = Identifier(); + break; + default: + jj_la1[83] = jj_gen; + ; + } + jj_consume_token(SEMICOLON); + if (p1 != null) { + result = new ContinueStatement( p1 ); + } else { + result = new ContinueStatement(); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ReturnStatement ReturnStatement(Environment env) throws ParseException { + ReturnStatement result; + Expression p1 = null; + + DebugOut.println( "#ReturnStatement()" ); + jj_consume_token(RETURN); + if ((getToken(1).kind != SEMICOLON)) { + p1 = Expression(env); + } else { + ; + } + jj_consume_token(SEMICOLON); + if (p1 != null) { + result = new ReturnStatement( p1 ); + } else { + result = new ReturnStatement(); + } + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final public ThrowStatement ThrowStatement(Environment env) throws ParseException { + Statement result; + Expression p1; + + DebugOut.println( "#ThrowStatement()" ); + jj_consume_token(THROW); + p1 = Expression(env); + jj_consume_token(SEMICOLON); + {if (true) return new ThrowStatement( p1 );} + throw new Error("Missing return statement in function"); + } + + final public SynchronizedStatement SynchronizedStatement(Environment env) throws ParseException { + Expression p1; + StatementList p2; + + DebugOut.println( "#SynchronizedStatement()" ); + jj_consume_token(SYNCHRONIZED); + jj_consume_token(LPAREN); + p1 = Expression(env); + jj_consume_token(RPAREN); + p2 = BlockedBody(env); + {if (true) return new SynchronizedStatement( p1, p2 );} + throw new Error("Missing return statement in function"); + } + + final public TryStatement TryStatement(Environment base_env) throws ParseException { + Environment env = new ClosedEnvironment( base_env ); + TryStatement result; + StatementList p1; + Parameter p2; + StatementList p3; + StatementList p4 = null; + CatchList catches = new CatchList(); + + DebugOut.println( "#TryStatement()" ); + jj_consume_token(TRY); + p1 = BlockedBody(env); + label_49: + while (true) { + if (jj_2_52(2147483647)) { + ; + } else { + break label_49; + } + env = new ClosedEnvironment( base_env ); + jj_consume_token(CATCH); + jj_consume_token(LPAREN); + p2 = FormalParameter(env); + jj_consume_token(RPAREN); + p3 = BlockedBody(env); + catches.add( new CatchBlock( p2, p3 ) ); + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case FINALLY: + jj_consume_token(FINALLY); + p4 = BlockedBody(new ClosedEnvironment( base_env )); + break; + default: + jj_la1[84] = jj_gen; + ; + } + result = new TryStatement( p1, catches, p4 ); + {if (true) return result;} + throw new Error("Missing return statement in function"); + } + + final private boolean jj_2_1(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_1(); + jj_save(0, xla); + return retval; + } + + final private boolean jj_2_2(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_2(); + jj_save(1, xla); + return retval; + } + + final private boolean jj_2_3(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_3(); + jj_save(2, xla); + return retval; + } + + final private boolean jj_2_4(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_4(); + jj_save(3, xla); + return retval; + } + + final private boolean jj_2_5(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_5(); + jj_save(4, xla); + return retval; + } + + final private boolean jj_2_6(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_6(); + jj_save(5, xla); + return retval; + } + + final private boolean jj_2_7(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_7(); + jj_save(6, xla); + return retval; + } + + final private boolean jj_2_8(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_8(); + jj_save(7, xla); + return retval; + } + + final private boolean jj_2_9(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_9(); + jj_save(8, xla); + return retval; + } + + final private boolean jj_2_10(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_10(); + jj_save(9, xla); + return retval; + } + + final private boolean jj_2_11(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_11(); + jj_save(10, xla); + return retval; + } + + final private boolean jj_2_12(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_12(); + jj_save(11, xla); + return retval; + } + + final private boolean jj_2_13(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_13(); + jj_save(12, xla); + return retval; + } + + final private boolean jj_2_14(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_14(); + jj_save(13, xla); + return retval; + } + + final private boolean jj_2_15(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_15(); + jj_save(14, xla); + return retval; + } + + final private boolean jj_2_16(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_16(); + jj_save(15, xla); + return retval; + } + + final private boolean jj_2_17(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_17(); + jj_save(16, xla); + return retval; + } + + final private boolean jj_2_18(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_18(); + jj_save(17, xla); + return retval; + } + + final private boolean jj_2_19(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_19(); + jj_save(18, xla); + return retval; + } + + final private boolean jj_2_20(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_20(); + jj_save(19, xla); + return retval; + } + + final private boolean jj_2_21(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_21(); + jj_save(20, xla); + return retval; + } + + final private boolean jj_2_22(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_22(); + jj_save(21, xla); + return retval; + } + + final private boolean jj_2_23(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_23(); + jj_save(22, xla); + return retval; + } + + final private boolean jj_2_24(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_24(); + jj_save(23, xla); + return retval; + } + + final private boolean jj_2_25(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_25(); + jj_save(24, xla); + return retval; + } + + final private boolean jj_2_26(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_26(); + jj_save(25, xla); + return retval; + } + + final private boolean jj_2_27(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_27(); + jj_save(26, xla); + return retval; + } + + final private boolean jj_2_28(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_28(); + jj_save(27, xla); + return retval; + } + + final private boolean jj_2_29(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_29(); + jj_save(28, xla); + return retval; + } + + final private boolean jj_2_30(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_30(); + jj_save(29, xla); + return retval; + } + + final private boolean jj_2_31(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_31(); + jj_save(30, xla); + return retval; + } + + final private boolean jj_2_32(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_32(); + jj_save(31, xla); + return retval; + } + + final private boolean jj_2_33(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_33(); + jj_save(32, xla); + return retval; + } + + final private boolean jj_2_34(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_34(); + jj_save(33, xla); + return retval; + } + + final private boolean jj_2_35(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_35(); + jj_save(34, xla); + return retval; + } + + final private boolean jj_2_36(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_36(); + jj_save(35, xla); + return retval; + } + + final private boolean jj_2_37(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_37(); + jj_save(36, xla); + return retval; + } + + final private boolean jj_2_38(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_38(); + jj_save(37, xla); + return retval; + } + + final private boolean jj_2_39(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_39(); + jj_save(38, xla); + return retval; + } + + final private boolean jj_2_40(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_40(); + jj_save(39, xla); + return retval; + } + + final private boolean jj_2_41(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_41(); + jj_save(40, xla); + return retval; + } + + final private boolean jj_2_42(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_42(); + jj_save(41, xla); + return retval; + } + + final private boolean jj_2_43(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_43(); + jj_save(42, xla); + return retval; + } + + final private boolean jj_2_44(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_44(); + jj_save(43, xla); + return retval; + } + + final private boolean jj_2_45(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_45(); + jj_save(44, xla); + return retval; + } + + final private boolean jj_2_46(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_46(); + jj_save(45, xla); + return retval; + } + + final private boolean jj_2_47(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_47(); + jj_save(46, xla); + return retval; + } + + final private boolean jj_2_48(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_48(); + jj_save(47, xla); + return retval; + } + + final private boolean jj_2_49(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_49(); + jj_save(48, xla); + return retval; + } + + final private boolean jj_2_50(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_50(); + jj_save(49, xla); + return retval; + } + + final private boolean jj_2_51(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_51(); + jj_save(50, xla); + return retval; + } + + final private boolean jj_2_52(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + boolean retval = !jj_3_52(); + jj_save(51, xla); + return retval; + } + + final private boolean jj_3R_133() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_31() { + if (jj_scan_token(DOT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(NEW)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_14() { + if (jj_scan_token(LBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(RBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_101() { + if (jj_scan_token(LBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_30() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_100()) { + jj_scanpos = xsp; + if (jj_3R_101()) { + jj_scanpos = xsp; + if (jj_3R_102()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_100() { + if (jj_scan_token(DOT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_13() { + if (jj_scan_token(LBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(RBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_52() { + if (jj_scan_token(CATCH)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_132() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_135() { + if (jj_3R_166()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_86() { + if (jj_scan_token(INTERFACE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_141() { + if (jj_3R_178()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_194() { + if (jj_scan_token(TRY)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_85() { + if (jj_scan_token(CLASS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_84() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_131()) { + jj_scanpos = xsp; + if (jj_3R_132()) { + jj_scanpos = xsp; + if (jj_3R_133()) { + jj_scanpos = xsp; + if (jj_3R_134()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_131() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_12() { + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_84()) { jj_scanpos = xsp; break; } + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } + xsp = jj_scanpos; + if (jj_3R_85()) { + jj_scanpos = xsp; + if (jj_3R_86()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_207() { + if (jj_3R_141()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_220() { + if (jj_3R_228()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_193() { + if (jj_scan_token(SYNCHRONIZED)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_177() { + if (jj_3R_198()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_54() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_176() { + if (jj_scan_token(NEW)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_225() { + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_53() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_41() { + if (jj_3R_105()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_218() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_225()) jj_scanpos = xsp; + else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(THIS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_29() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_192() { + if (jj_scan_token(THROW)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_87() { + if (jj_3R_135()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_28() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_98()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_175() { + if (jj_scan_token(SUPER)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_83() { + if (jj_scan_token(PRIVATE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_197() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_52() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_3() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_52()) { + jj_scanpos = xsp; + if (jj_3R_53()) { + jj_scanpos = xsp; + if (jj_3R_54()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_80() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_196() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_169() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_196()) { + jj_scanpos = xsp; + if (jj_3R_197()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_174() { + if (jj_scan_token(THIS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_82() { + if (jj_scan_token(PROTECTED)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_191() { + if (jj_scan_token(RETURN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_79() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_173() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_81() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_11() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_78()) { + jj_scanpos = xsp; + if (jj_3R_79()) { + jj_scanpos = xsp; + if (jj_3R_80()) { + jj_scanpos = xsp; + if (jj_3R_81()) { + jj_scanpos = xsp; + if (jj_3R_82()) { + jj_scanpos = xsp; + if (jj_3R_83()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_78() { + if (jj_scan_token(STATIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_172() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_182() { + if (jj_scan_token(LBRACE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_97() { + if (jj_3R_141()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_171() { + if (jj_scan_token(BANG)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_27() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(RPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_190() { + if (jj_scan_token(CONTINUE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_26() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(LBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_170() { + if (jj_scan_token(TILDE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_140() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_181() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_147() { + if (jj_scan_token(LONG)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_139() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(RPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_170()) { + jj_scanpos = xsp; + if (jj_3R_171()) { + jj_scanpos = xsp; + if (jj_3R_172()) { + jj_scanpos = xsp; + if (jj_3R_173()) { + jj_scanpos = xsp; + if (jj_3R_174()) { + jj_scanpos = xsp; + if (jj_3R_175()) { + jj_scanpos = xsp; + if (jj_3R_176()) { + jj_scanpos = xsp; + if (jj_3R_177()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_138() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(LBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(RBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_146() { + if (jj_scan_token(INT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_25() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_98()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_96() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_25()) { + jj_scanpos = xsp; + if (jj_3R_138()) { + jj_scanpos = xsp; + if (jj_3R_139()) { + jj_scanpos = xsp; + if (jj_3R_140()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_23() { + if (jj_3R_96()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_77() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_40() { + if (jj_3R_104()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_189() { + if (jj_scan_token(BREAK)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_165() { + if (jj_3R_194()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_24() { + if (jj_3R_97()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_164() { + if (jj_3R_193()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_145() { + if (jj_scan_token(SHORT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_163() { + if (jj_3R_192()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_137() { + if (jj_3R_169()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_168() { + if (jj_scan_token(BANG)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_150() { + if (jj_scan_token(VOID)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_167() { + if (jj_scan_token(TILDE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_162() { + if (jj_3R_191()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_10() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_76()) { + jj_scanpos = xsp; + if (jj_3R_77()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_75() { + if (jj_scan_token(SYNCHRONIZED)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_76() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_161() { + if (jj_3R_190()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_144() { + if (jj_scan_token(BYTE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_95() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_136()) { + jj_scanpos = xsp; + if (jj_3R_137()) { + jj_scanpos = xsp; + if (jj_3_24()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_136() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_167()) { + jj_scanpos = xsp; + if (jj_3R_168()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_160() { + if (jj_3R_189()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_110() { + if (jj_3R_151()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_19() { + if (jj_scan_token(DOT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_159() { + if (jj_3R_188()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_149() { + if (jj_scan_token(DOUBLE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_99() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_19()) { jj_scanpos = xsp; break; } + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } + return false; + } + + final private boolean jj_3R_158() { + if (jj_3R_187()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_74() { + if (jj_scan_token(NATIVE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_223() { + if (jj_scan_token(DECR)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_143() { + if (jj_scan_token(CHAR)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_222() { + if (jj_scan_token(INCR)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_157() { + if (jj_3R_186()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_71() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_94() { + if (jj_scan_token(DECR)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_68() { + if (jj_scan_token(PRIVATE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_231() { + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_156() { + if (jj_3R_185()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_206() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_222()) { + jj_scanpos = xsp; + if (jj_3R_223()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_148() { + if (jj_scan_token(FLOAT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_39() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(COLON)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_155() { + if (jj_3R_184()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_21() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_93()) { + jj_scanpos = xsp; + if (jj_3R_94()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_93() { + if (jj_scan_token(INCR)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_154() { + if (jj_3R_183()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_142() { + if (jj_scan_token(BOOLEAN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_73() { + if (jj_scan_token(VOLATILE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_92() { + if (jj_scan_token(MINUS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_153() { + if (jj_3R_182()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_98() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_142()) { + jj_scanpos = xsp; + if (jj_3R_143()) { + jj_scanpos = xsp; + if (jj_3R_144()) { + jj_scanpos = xsp; + if (jj_3R_145()) { + jj_scanpos = xsp; + if (jj_3R_146()) { + jj_scanpos = xsp; + if (jj_3R_147()) { + jj_scanpos = xsp; + if (jj_3R_148()) { + jj_scanpos = xsp; + if (jj_3R_149()) { + jj_scanpos = xsp; + if (jj_3R_150()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_70() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_22() { + if (jj_3R_95()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_152() { + if (jj_3R_181()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_67() { + if (jj_scan_token(PROTECTED)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_105() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_152()) { + jj_scanpos = xsp; + if (jj_3R_153()) { + jj_scanpos = xsp; + if (jj_3R_154()) { + jj_scanpos = xsp; + if (jj_3R_155()) { + jj_scanpos = xsp; + if (jj_3R_156()) { + jj_scanpos = xsp; + if (jj_3R_157()) { + jj_scanpos = xsp; + if (jj_3R_158()) { + jj_scanpos = xsp; + if (jj_3R_159()) { + jj_scanpos = xsp; + if (jj_3R_160()) { + jj_scanpos = xsp; + if (jj_3R_161()) { + jj_scanpos = xsp; + if (jj_3R_162()) { + jj_scanpos = xsp; + if (jj_3R_163()) { + jj_scanpos = xsp; + if (jj_3R_164()) { + jj_scanpos = xsp; + if (jj_3R_165()) { + jj_scanpos = xsp; + if (jj_3_40()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_20() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_91()) { + jj_scanpos = xsp; + if (jj_3R_92()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_91() { + if (jj_scan_token(PLUS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_240() { + if (jj_3R_206()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_242() { + if (jj_scan_token(MINUS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_241() { + if (jj_scan_token(PLUS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_230() { + if (jj_3R_98()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_72() { + if (jj_scan_token(TRANSIENT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_69() { + if (jj_scan_token(STATIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_228() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_230()) { + jj_scanpos = xsp; + if (jj_3R_231()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_66() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_9() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_66()) { + jj_scanpos = xsp; + if (jj_3R_67()) { + jj_scanpos = xsp; + if (jj_3R_68()) { + jj_scanpos = xsp; + if (jj_3R_69()) { + jj_scanpos = xsp; + if (jj_3R_70()) { + jj_scanpos = xsp; + if (jj_3R_71()) { + jj_scanpos = xsp; + if (jj_3R_72()) { + jj_scanpos = xsp; + if (jj_3R_73()) { + jj_scanpos = xsp; + if (jj_3R_74()) { + jj_scanpos = xsp; + if (jj_3R_75()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_239() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_241()) { + jj_scanpos = xsp; + if (jj_3R_242()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_238() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_239()) { + jj_scanpos = xsp; + if (jj_3R_240()) { + jj_scanpos = xsp; + if (jj_3_22()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_51() { + if (jj_3R_105()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_38() { + if (jj_scan_token(LBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_37() { + if (jj_scan_token(LBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(RBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_237() { + if (jj_3R_238()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_50() { + if (jj_3R_110()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_188() { + if (jj_scan_token(FOR)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_18() { + if (jj_scan_token(THIS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_236() { + if (jj_3R_237()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_116() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_115() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_90() { + if (jj_scan_token(PRIVATE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_35() { + if (jj_scan_token(LBRACKET)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_49() { + if (jj_3R_105()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_235() { + if (jj_3R_236()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_114() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_36() { + if (jj_scan_token(NEW)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_98()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_89() { + if (jj_scan_token(PROTECTED)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_187() { + if (jj_scan_token(DO)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_227() { + if (jj_scan_token(NEW)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_226() { + if (jj_scan_token(NEW)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_219() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_226()) { + jj_scanpos = xsp; + if (jj_3R_227()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_112() { + if (jj_scan_token(METACLASS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_17() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_88()) { + jj_scanpos = xsp; + if (jj_3R_89()) { + jj_scanpos = xsp; + if (jj_3R_90()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_88() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_234() { + if (jj_3R_235()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_48() { + if (jj_3R_105()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_51() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_113()) { + jj_scanpos = xsp; + if (jj_3R_114()) { + jj_scanpos = xsp; + if (jj_3R_115()) { + jj_scanpos = xsp; + if (jj_3R_116()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_50() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_111()) { + jj_scanpos = xsp; + if (jj_3R_112()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_111() { + if (jj_scan_token(IDENTIFIER)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_113() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_8() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_127() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_2() { + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_51()) { jj_scanpos = xsp; break; } + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } + if (jj_scan_token(CLASS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_186() { + if (jj_scan_token(WHILE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_130() { + if (jj_scan_token(PRIVATE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_126() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_34() { + if (jj_3R_87()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_233() { + if (jj_3R_234()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_47() { + if (jj_3R_105()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_125() { + if (jj_scan_token(STATIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_129() { + if (jj_scan_token(PROTECTED)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_65() { + if (jj_scan_token(INTERFACE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_46() { + if (jj_3R_105()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_217() { + if (jj_scan_token(NULL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_232() { + if (jj_3R_233()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_216() { + if (jj_scan_token(FALSE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_61() { + if (jj_scan_token(PRIVATE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_64() { + if (jj_scan_token(CLASS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_128() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_215() { + if (jj_scan_token(TRUE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_185() { + if (jj_scan_token(IF)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_58() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_63() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_124()) { + jj_scanpos = xsp; + if (jj_3R_125()) { + jj_scanpos = xsp; + if (jj_3R_126()) { + jj_scanpos = xsp; + if (jj_3R_127()) { + jj_scanpos = xsp; + if (jj_3R_128()) { + jj_scanpos = xsp; + if (jj_3R_129()) { + jj_scanpos = xsp; + if (jj_3R_130()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_124() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_214() { + if (jj_scan_token(STRING_LITERAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_7() { + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_63()) { jj_scanpos = xsp; break; } + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } + xsp = jj_scanpos; + if (jj_3R_64()) { + jj_scanpos = xsp; + if (jj_3R_65()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_16() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_213() { + if (jj_scan_token(CHARACTER_LITERAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_62() { + if (jj_scan_token(STATIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_6() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_62()) jj_scanpos = xsp; + else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(LBRACE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_212() { + if (jj_scan_token(DOUBLE_FLOATING_POINT_LITERAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_60() { + if (jj_scan_token(PROTECTED)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_211() { + if (jj_scan_token(FLOATING_POINT_LITERAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_109() { + if (jj_scan_token(_DEFAULT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_57() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_229() { + if (jj_3R_232()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_210() { + if (jj_scan_token(LONG_LITERAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_209() { + if (jj_scan_token(INTEGER_LITERAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_198() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_209()) { + jj_scanpos = xsp; + if (jj_3R_210()) { + jj_scanpos = xsp; + if (jj_3R_211()) { + jj_scanpos = xsp; + if (jj_3R_212()) { + jj_scanpos = xsp; + if (jj_3R_213()) { + jj_scanpos = xsp; + if (jj_3R_214()) { + jj_scanpos = xsp; + if (jj_3R_215()) { + jj_scanpos = xsp; + if (jj_3R_216()) { + jj_scanpos = xsp; + if (jj_3R_217()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_107() { + if (jj_scan_token(_DEFAULT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_1() { + if (jj_scan_token(DOT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_45() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_108()) { + jj_scanpos = xsp; + if (jj_3R_109()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_108() { + if (jj_scan_token(CASE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_59() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_56() { + if (jj_scan_token(STATIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_5() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_56()) { + jj_scanpos = xsp; + if (jj_3R_57()) { + jj_scanpos = xsp; + if (jj_3R_58()) { + jj_scanpos = xsp; + if (jj_3R_59()) { + jj_scanpos = xsp; + if (jj_3R_60()) { + jj_scanpos = xsp; + if (jj_3R_61()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_120() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_44() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_106()) { + jj_scanpos = xsp; + if (jj_3R_107()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_106() { + if (jj_scan_token(CASE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_224() { + if (jj_3R_229()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_33() { + if (jj_scan_token(DOT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_123() { + if (jj_scan_token(PRIVATE)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_119() { + if (jj_scan_token(ABSTRACT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_184() { + if (jj_scan_token(SWITCH)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_221() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_118() { + if (jj_scan_token(STATIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_208() { + if (jj_3R_224()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_122() { + if (jj_scan_token(PROTECTED)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_43() { + if (jj_3R_97()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_180() { + if (jj_3R_207()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_121() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_205() { + if (jj_3R_221()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_55() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_117()) { + jj_scanpos = xsp; + if (jj_3R_118()) { + jj_scanpos = xsp; + if (jj_3R_119()) { + jj_scanpos = xsp; + if (jj_3R_120()) { + jj_scanpos = xsp; + if (jj_3R_121()) { + jj_scanpos = xsp; + if (jj_3R_122()) { + jj_scanpos = xsp; + if (jj_3R_123()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_117() { + if (jj_3R_50()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_179() { + if (jj_3R_206()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_151() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_179()) { + jj_scanpos = xsp; + lookingAhead = true; + jj_semLA = AssignmentLookahead(); + lookingAhead = false; + if (!jj_semLA || jj_3R_180()) { + jj_scanpos = xsp; + if (jj_3_43()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_4() { + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_55()) { jj_scanpos = xsp; break; } + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } + if (jj_scan_token(CLASS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_204() { + if (jj_3R_220()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_103() { + if (jj_3R_99()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(DOT)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_195() { + if (jj_3R_208()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_32() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_103()) jj_scanpos = xsp; + else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + if (jj_scan_token(THIS)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_203() { + if (jj_3R_219()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_202() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_104() { + if (jj_3R_151()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_201() { + if (jj_scan_token(SUPER)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_200() { + if (jj_3R_218()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_199() { + if (jj_3R_198()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_178() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_199()) { + jj_scanpos = xsp; + if (jj_3R_200()) { + jj_scanpos = xsp; + if (jj_3R_201()) { + jj_scanpos = xsp; + if (jj_3R_202()) { + jj_scanpos = xsp; + if (jj_3R_203()) { + jj_scanpos = xsp; + lookingAhead = true; + jj_semLA = ClassLiteralLookahead(); + lookingAhead = false; + if (!jj_semLA || jj_3R_204()) { + jj_scanpos = xsp; + if (jj_3R_205()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_183() { + if (jj_scan_token(SEMICOLON)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_166() { + if (jj_3R_195()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_134() { + if (jj_scan_token(PUBLIC)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_42() { + if (jj_scan_token(FINAL)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3R_102() { + if (jj_scan_token(LPAREN)) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + final private boolean jj_3_15() { + if (jj_3R_87()) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) return false; + return false; + } + + public ParserTokenManager token_source; + JavaCharStream jj_input_stream; + public Token token, jj_nt; + private int jj_ntk; + private Token jj_scanpos, jj_lastpos; + private int jj_la; + public boolean lookingAhead = false; + private boolean jj_semLA; + private int jj_gen; + final private int[] jj_la1 = new int[85]; + final private int[] jj_la1_0 = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20002000,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20002000,0x0,0x82094000,0x82094000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x10000000,0x0,0x0,0x0,0x0,0x82094000,0x1408000,0x100000,0x0,0x0,0x820000,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,}; + final private int[] jj_la1_1 = {0x0,0x1000,0x10,0x10,0x0,0x0,0x80000000,0x0,0x0,0x80000000,0x0,0x2224e200,0x0,0x8,0x0,0x0,0x0,0x80000000,0x1000000,0x0,0x0,0x0,0x0,0x0,0x2224e200,0x40000,0x90020140,0x10020140,0x0,0x0,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x84480c00,0x0,0x0,0x0,0x80000000,0x0,0x4000800,0x80400,0x80000000,0x4000800,0x0,0x0,0x0,0x400,0x90020140,0x48b10005,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000000,0x80000000,0x0,}; + final private int[] jj_la1_2 = {0x100000,0x0,0x0,0x0,0x400000,0x100000,0x800,0x200000,0x20100000,0x0,0x1,0x0,0x0,0x0,0x100000,0x100000,0x200000,0x800,0x0,0x110000,0x800000,0x10000,0x200000,0x200000,0x0,0x0,0x800,0x0,0x200000,0x200000,0x800,0x800000,0x800000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x40000000,0x40000000,0x0,0x83000000,0x83000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000000,0xc000000,0xc004ec6,0x4000,0x0,0x0,0x800,0x444000,0x6c6,0x4000,0x800,0x6c6,0x200000,0x10000,0x4000,0x0,0x800,0x110000,0x0,0x200000,0x0,0x0,0x10000,0x10000,0x0,0x10000,0x10000,0x10000,0x200000,0x200000,0x800,0x800,0x0,}; + final private int[] jj_la1_3 = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe0000,0xffe0000,0x0,0x4,0x8,0x800,0x1000,0x400,0x2,0x2,0x0,0x1,0x1,0x1c000,0x1c000,0xc0,0xc0,0x2300,0x2300,0xc0,0x30,0x0,0x0,0x0,0x0,0x30,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; + final private JJCalls[] jj_2_rtns = new JJCalls[52]; + private boolean jj_rescan = false; + private int jj_gc = 0; + + public Parser(java.io.InputStream stream) { + jj_input_stream = new JavaCharStream(stream, 1, 1); + token_source = new ParserTokenManager(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 85; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + public void ReInit(java.io.InputStream stream) { + jj_input_stream.ReInit(stream, 1, 1); + token_source.ReInit(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 85; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + public Parser(java.io.Reader stream) { + jj_input_stream = new JavaCharStream(stream, 1, 1); + token_source = new ParserTokenManager(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 85; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + public void ReInit(java.io.Reader stream) { + jj_input_stream.ReInit(stream, 1, 1); + token_source.ReInit(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 85; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + public Parser(ParserTokenManager tm) { + token_source = tm; + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 85; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + public void ReInit(ParserTokenManager tm) { + token_source = tm; + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 85; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + final private Token jj_consume_token(int kind) throws ParseException { + Token oldToken; + if ((oldToken = token).next != null) token = token.next; + else token = token.next = token_source.getNextToken(); + jj_ntk = -1; + if (token.kind == kind) { + jj_gen++; + if (++jj_gc > 100) { + jj_gc = 0; + for (int i = 0; i < jj_2_rtns.length; i++) { + JJCalls c = jj_2_rtns[i]; + while (c != null) { + if (c.gen < jj_gen) c.first = null; + c = c.next; + } + } + } + return token; + } + token = oldToken; + jj_kind = kind; + throw generateParseException(); + } + + final private boolean jj_scan_token(int kind) { + if (jj_scanpos == jj_lastpos) { + jj_la--; + if (jj_scanpos.next == null) { + jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken(); + } else { + jj_lastpos = jj_scanpos = jj_scanpos.next; + } + } else { + jj_scanpos = jj_scanpos.next; + } + if (jj_rescan) { + int i = 0; Token tok = token; + while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; } + if (tok != null) jj_add_error_token(kind, i); + } + return (jj_scanpos.kind != kind); + } + + final public Token getNextToken() { + if (token.next != null) token = token.next; + else token = token.next = token_source.getNextToken(); + jj_ntk = -1; + jj_gen++; + return token; + } + + final public Token getToken(int index) { + Token t = lookingAhead ? jj_scanpos : token; + for (int i = 0; i < index; i++) { + if (t.next != null) t = t.next; + else t = t.next = token_source.getNextToken(); + } + return t; + } + + final private int jj_ntk() { + if ((jj_nt=token.next) == null) + return (jj_ntk = (token.next=token_source.getNextToken()).kind); + else + return (jj_ntk = jj_nt.kind); + } + + private java.util.Vector jj_expentries = new java.util.Vector(); + private int[] jj_expentry; + private int jj_kind = -1; + private int[] jj_lasttokens = new int[100]; + private int jj_endpos; + + private void jj_add_error_token(int kind, int pos) { + if (pos >= 100) return; + if (pos == jj_endpos + 1) { + jj_lasttokens[jj_endpos++] = kind; + } else if (jj_endpos != 0) { + jj_expentry = new int[jj_endpos]; + for (int i = 0; i < jj_endpos; i++) { + jj_expentry[i] = jj_lasttokens[i]; + } + boolean exists = false; + for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) { + int[] oldentry = (int[])(enum.nextElement()); + if (oldentry.length == jj_expentry.length) { + exists = true; + for (int i = 0; i < jj_expentry.length; i++) { + if (oldentry[i] != jj_expentry[i]) { + exists = false; + break; + } + } + if (exists) break; + } + } + if (!exists) jj_expentries.addElement(jj_expentry); + if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind; + } + } + + final public ParseException generateParseException() { + jj_expentries.removeAllElements(); + boolean[] la1tokens = new boolean[124]; + for (int i = 0; i < 124; i++) { + la1tokens[i] = false; + } + if (jj_kind >= 0) { + la1tokens[jj_kind] = true; + jj_kind = -1; + } + for (int i = 0; i < 85; i++) { + if (jj_la1[i] == jj_gen) { + for (int j = 0; j < 32; j++) { + if ((jj_la1_0[i] & (1<<j)) != 0) { + la1tokens[j] = true; + } + if ((jj_la1_1[i] & (1<<j)) != 0) { + la1tokens[32+j] = true; + } + if ((jj_la1_2[i] & (1<<j)) != 0) { + la1tokens[64+j] = true; + } + if ((jj_la1_3[i] & (1<<j)) != 0) { + la1tokens[96+j] = true; + } + } + } + } + for (int i = 0; i < 124; i++) { + if (la1tokens[i]) { + jj_expentry = new int[1]; + jj_expentry[0] = i; + jj_expentries.addElement(jj_expentry); + } + } + jj_endpos = 0; + jj_rescan_token(); + jj_add_error_token(0, 0); + int[][] exptokseq = new int[jj_expentries.size()][]; + for (int i = 0; i < jj_expentries.size(); i++) { + exptokseq[i] = (int[])jj_expentries.elementAt(i); + } + return new ParseException(token, exptokseq, tokenImage); + } + + final public void enable_tracing() { + } + + final public void disable_tracing() { + } + + final private void jj_rescan_token() { + jj_rescan = true; + for (int i = 0; i < 52; i++) { + JJCalls p = jj_2_rtns[i]; + do { + if (p.gen > jj_gen) { + jj_la = p.arg; jj_lastpos = jj_scanpos = p.first; + switch (i) { + case 0: jj_3_1(); break; + case 1: jj_3_2(); break; + case 2: jj_3_3(); break; + case 3: jj_3_4(); break; + case 4: jj_3_5(); break; + case 5: jj_3_6(); break; + case 6: jj_3_7(); break; + case 7: jj_3_8(); break; + case 8: jj_3_9(); break; + case 9: jj_3_10(); break; + case 10: jj_3_11(); break; + case 11: jj_3_12(); break; + case 12: jj_3_13(); break; + case 13: jj_3_14(); break; + case 14: jj_3_15(); break; + case 15: jj_3_16(); break; + case 16: jj_3_17(); break; + case 17: jj_3_18(); break; + case 18: jj_3_19(); break; + case 19: jj_3_20(); break; + case 20: jj_3_21(); break; + case 21: jj_3_22(); break; + case 22: jj_3_23(); break; + case 23: jj_3_24(); break; + case 24: jj_3_25(); break; + case 25: jj_3_26(); break; + case 26: jj_3_27(); break; + case 27: jj_3_28(); break; + case 28: jj_3_29(); break; + case 29: jj_3_30(); break; + case 30: jj_3_31(); break; + case 31: jj_3_32(); break; + case 32: jj_3_33(); break; + case 33: jj_3_34(); break; + case 34: jj_3_35(); break; + case 35: jj_3_36(); break; + case 36: jj_3_37(); break; + case 37: jj_3_38(); break; + case 38: jj_3_39(); break; + case 39: jj_3_40(); break; + case 40: jj_3_41(); break; + case 41: jj_3_42(); break; + case 42: jj_3_43(); break; + case 43: jj_3_44(); break; + case 44: jj_3_45(); break; + case 45: jj_3_46(); break; + case 46: jj_3_47(); break; + case 47: jj_3_48(); break; + case 48: jj_3_49(); break; + case 49: jj_3_50(); break; + case 50: jj_3_51(); break; + case 51: jj_3_52(); break; + } + } + p = p.next; + } while (p != null); + } + jj_rescan = false; + } + + final private void jj_save(int index, int xla) { + JJCalls p = jj_2_rtns[index]; + while (p.gen > jj_gen) { + if (p.next == null) { p = p.next = new JJCalls(); break; } + p = p.next; + } + p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla; + } + + static final class JJCalls { + int gen; + Token first; + int arg; + JJCalls next; + } + +} + +class IntAndObj +{ + IntAndObj( int ptr, Object obj ) { + super(); this.ptr = ptr; this.obj = obj; + } + int ptr; + Object obj; +} diff --git a/src/main/java/io/devnulllabs/openjava/tools/parser/Parser.jj b/src/main/java/io/devnulllabs/openjava/tools/parser/Parser.jj new file mode 100644 index 0000000..5da8c91 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/tools/parser/Parser.jj @@ -0,0 +1,3043 @@ +/* + * OpenJava1.0.jj + * + * The parser for OpenJava 1.0 system. + * This parser is LL(k) leaded by semantics. + * + * @date Mar 30, 1998 + * @auther Michiaki Tatsubori + * Apr 29, 1998 by mich + * + */ +options { + STATIC = false; + JAVA_UNICODE_ESCAPE = true; +} + + +PARSER_BEGIN(Parser) + + package io.devnulllabs.openjava.tools.parser; + + +import java.io.Reader; +import java.util.Vector; +import java.util.Hashtable; +import java.lang.reflect.Method; +import io.devnulllabs.openjava.mop.*; +import io.devnulllabs.openjava.ptree.*; +import io.devnulllabs.openjava.tools.DebugOut; +import io.devnulllabs.openjava.syntax.SyntaxRule; +import io.devnulllabs.openjava.syntax.TokenSource; + + +public class Parser +{ + /** + * Allocates a new parser object who gets tokens from the given parser + * object. + * + * @param parser this is used to get tokens via <code>getToken()</code> + * or <code>getNextToken()</code>. + */ + public Parser( Parser parser ) { + this((ParserTokenManager)new CustomTokenManager(parser, OJSystem.env)); + } + + public Parser( TokenSource token_src ) { + this( new TokenSourceAdapter( token_src ) ); + } + + private final String getComment() { + Token token = getToken( 1 ).specialToken; + return ((token == null) ? null : token.image); + } + + + private final static int makeInt( String str ) { + if (str.length() == 1) { + return Integer.valueOf( str ).intValue(); + } else if (str.startsWith( "0x" ) || str.startsWith( "0X" )) { + return Integer.valueOf( str.substring( 2 ), 16 ).intValue(); + } else if (str.startsWith( "0" )) { + return Integer.valueOf( str.substring( 1 ), 8 ).intValue(); + } + return Integer.valueOf( str ).intValue(); + } + private final static long makeLong( String str ) { + if (str.length() == 1) { + return Long.valueOf( str ).longValue(); + } else if (str.startsWith( "0x" ) || str.startsWith( "0X" )) { + str = str.substring( 2 ); + if (str.endsWith( "l" ) || str.endsWith( "L" )) { + str = str.substring( 0, str.length() - 1 ); + } + return Long.valueOf( str, 16 ).longValue(); + } else if (str.startsWith( "0" )) { + str = str.substring( 1 ); + if (str.endsWith( "l" ) || str.endsWith( "L" )) { + str = str.substring( 0, str.length() - 1 ); + } + return Long.valueOf( str, 8 ).longValue(); + } + return Long.valueOf( str ).longValue(); + } + + /** + * Detects class or interface name and metaclass + */ + private final ClassEnvironment setClassEnvironment( Environment base_env ) + throws ParseException + { + int ptr = 1; + for (; roughModifierCheck( getToken( ptr ) ) ; ++ptr) ; + Token c_or_i = getToken( ptr++ ); + if (c_or_i.kind != CLASS && c_or_i.kind != INTERFACE) { + throw new ParseException( "'class' or 'interface' expected : " + + c_or_i.image ); + } + Token cname = getToken( ptr++ ); + if (cname.kind != IDENTIFIER) { + throw new ParseException( "class name expected : " + + c_or_i.image ); + } + String classname = cname.image; + + ClassEnvironment result = new ClassEnvironment(base_env, classname); + + Token inst = getToken(ptr++); + if (inst.kind != INSTANTIATES) { + ptr++; + } else { + IntAndObj tmp = consumeMetaclassName(ptr); ptr = tmp.ptr; + String meta = base_env.toQualifiedName((String) tmp.obj); + OJSystem.metabind(result.toQualifiedName(classname), meta); + } + + return result; + } + + private IntAndObj consumeMetaclassName( int ptr ) throws ParseException { + Token token = getToken( ptr++ ); + if (token.kind != IDENTIFIER) { + throw new ParseException( "metaclass name exptected : " + + token.image ); + } + StringBuffer buf = new StringBuffer( token.image ); + while (getToken( ptr ).kind == DOT + && getToken( ptr + 1 ).kind == IDENTIFIER) { + buf.append( "." ).append( getToken( ptr + 1 ).image ); + ptr += 2; + } + return new IntAndObj( ptr, buf.toString() ); + } + + /** + * This is used to check OpenJava user modifier semantically. + */ + private final boolean OpenJavaModifierLookahead( Environment env ) { + return modifierCheck( env, getToken( 1 ) ); + } + + /** + * This is used to check OpenJava user modifier semantically. + */ + private final boolean ModifierLookahead(Environment env) { + return modifierCheck( env, getToken(1) ); + } + + boolean DeclSuffixLookahead(Environment env) { + String typename = env.currentClassName(); + String keyword = consumeKeyword(1); + if (keyword == null) return false; + Class meta = toExecutable( env, typename ); + return invokeOJClass_isRegisteredKeyword(meta, keyword); + } + + boolean TypeSuffixLookahead(Environment env, String typename) { + String keyword = consumeKeyword(1); + if (keyword == null) return false; + Class meta = toExecutable( env, typename ); + return invokeOJClass_isRegisteredKeyword( meta, keyword ); + } + + private static final boolean modifierCheck(Environment env, Token t) { + if (pureModifierCheck(t)) return true; + if (t.kind != IDENTIFIER) return false; + Class meta = toExecutable( env, env.currentClassName() ); + if (meta == null) return false; + return invokeOJClass_isRegisteredModifier(meta, t.image); + } + + private String consumeKeyword(int ptr) { + Token token = getToken(ptr); + if (token.kind != IDENTIFIER) return null; + return token.image; + } + + static final Class toExecutable( Environment env, String typename ) { + String qname = env.toQualifiedName( typename ); + return OJSystem.getMetabind( qname ); + } + + static boolean invokeOJClass_isRegisteredKeyword( Class meta, + String keyword ) + { + try { + Method m = meta.getMethod( "isRegisteredKeyword", + new Class[]{ String . class} ); + Boolean b = (Boolean) m.invoke( null, new Object[]{ keyword } ); + return b.booleanValue(); + } catch ( Exception e ) {} + return false; + } + + static SyntaxRule invokeOJClass_getDeclSuffixRule(Environment env, + Class meta, + String keyword) + { + SyntaxRule result = null; + try { + Method m = meta.getMethod("getDeclSuffixRule", + new Class[]{ Environment.class, + String.class }); + result = (SyntaxRule) m.invoke(null, new Object[]{ env, keyword }); + } catch (Exception e) {} /* ignore if the method not provided */ + if (result != null) return result; + try { + Method m = meta.getMethod("getDeclSuffixRule", + new Class[]{ String.class }); + result = (SyntaxRule) m.invoke(null, new Object[]{ keyword }); + } catch (Exception e) {} /* ignore if the method not provided */ + return result; + } + + static SyntaxRule invokeOJClass_getTypeSuffixRule(Environment env, + Class meta, + String keyword) + { + SyntaxRule result = null; + try { + Method m = meta.getMethod("getTypeSuffixRule", + new Class[]{ Environment.class, + String.class }); + result = (SyntaxRule) m.invoke(null, new Object[]{ env, keyword }); + } catch (Exception e) {} /* ignore if the method not provided */ + if (result != null) return result; + try { + Method m = meta.getMethod("getTypeSuffixRule", + new Class[]{ String.class}); + result = (SyntaxRule) m.invoke(null, new Object[]{ keyword }); + } catch (Exception e) {} /* ignore if the method not provided */ + return result; + } + + static boolean invokeOJClass_isRegisteredModifier( Class meta, + String keyword ) + { + try { + Method m = meta.getMethod( "isRegisteredModifier", + new Class[]{ String . class} ); + Boolean b = (Boolean) m.invoke( null, new Object[]{ keyword } ); + return b.booleanValue(); + } catch ( Exception e ) {} + return false; + } + + /** + * This is used to check constructors semantically. + */ + private final boolean ConstructorDeclarationLookahead( + ClassEnvironment env ) { + int ptr; + for (ptr = 1; modifierCheck( env, getToken( ptr ) ) ; ++ptr) ; + String simplename = Environment.toSimpleName( env.currentClassName() ); + //if (! getToken( ptr ).image.equals( simplename ) + // || getToken( ptr + 1 ).kind != LPAREN) { + // return false; + //} + //return true; + return (getToken(ptr + 1).kind == LPAREN); + } + + /** + * This will used to check local variable declaration semantically. + */ + private final boolean LocalVariableDeclarationLookahead( + Environment env ) { + int ptr; + for (ptr = 1; modifierCheck( env, getToken( ptr ) ) ; ++ptr) ; + int old_ptr = ptr; + ptr = consumePureResultType( old_ptr ); + if (ptr != old_ptr && getToken( ptr ).kind == IDENTIFIER) { + return true; + } + return false; + } + + private final boolean roughModifierCheck( Token t ) { + if (pureModifierCheck( t )) return true; + return (t.kind == IDENTIFIER); + } + + private static final boolean pureModifierCheck( Token t ) { + switch (t.kind) { + case ABSTRACT : case FINAL : case PUBLIC : case PRIVATE : + case PROTECTED : case STATIC : case TRANSIENT : case VOLATILE : + case NATIVE : case SYNCHRONIZED : + return true; + } + return false; + } + + private final boolean ConstructorInvocationLookahead() { + int ptr = 1; + while (getToken(ptr).kind != EOF) { + if (getToken(ptr).kind == SUPER + && getToken(ptr + 1).kind == LPAREN) { + return true; + } + if (getToken(ptr).kind == SEMICOLON) return false; + if (getToken(ptr).kind == RBRACE) return false; + ++ptr; + } + return false; + } + + private final boolean AssignmentLookahead() { + int ptr = 1; + switch (getToken( ptr ).kind) { + case LPAREN : + ptr = consumeParenPair( ptr ); + break; + case IDENTIFIER : + case THIS : + case SUPER : + ptr++; + break; + default : + return false; + } + for (boolean cont = true; cont;) { + switch (getToken( ptr ).kind) { + case LPAREN : + ptr = consumeParenPair( ptr ); + break; + case LBRACKET : + ptr = consumeBracketPair( ptr ); + break; + case DOT : + ptr++; + if (getToken( ptr ).kind != IDENTIFIER) return false; + ptr++; + break; + default : + cont = false; + } + } + return assignmentOperatorCheck( getToken( ptr ) ); + } + + private final int consumeParenPair( int ptr ) { + int nest = 1; + for (++ptr; nest > 0; ptr++) { + if (getToken( ptr ).kind == LPAREN) nest++; + if (getToken( ptr ).kind == RPAREN) nest--; + } + return ptr; + } + + private final int consumeBracketPair( int ptr ) { + int nest = 1; + for (++ptr; nest > 0; ptr++) { + if (getToken( ptr ).kind == LBRACKET) nest++; + if (getToken( ptr ).kind == RBRACKET) nest--; + } + return ptr; + } + + private static final boolean assignmentOperatorCheck( Token t ) { + if (t.kind == ASSIGN) return true; + if (t.kind == PLUSASSIGN) return true; + if (t.kind == MINUSASSIGN) return true; + if (t.kind == STARASSIGN) return true; + if (t.kind == SLASHASSIGN) return true; + if (t.kind == ANDASSIGN) return true; + if (t.kind == ORASSIGN) return true; + if (t.kind == XORASSIGN) return true; + if (t.kind == REMASSIGN) return true; + if (t.kind == LSHIFTASSIGN) return true; + if (t.kind == RSIGNEDSHIFTASSIGN) return true; + if (t.kind == RUNSIGNEDSHIFTASSIGN) return true; + return false; + } + + private final boolean ClassLiteralLookahead() { + int ptr = 1; + ptr = consumePureResultType( ptr ); + if (ptr == 1) return false; + /** here should be user suffix check **/ + if (getToken( ptr ).kind != DOT) return false; + if (getToken( ptr + 1 ).kind != CLASS) return false; + return true; + } + + private final int consumePureResultType( int ptr ) { + Token token = getToken( ptr ); + if (primitiveTypeCheck( token )) { + ptr++; + } else if (token.kind == IDENTIFIER) { + ptr++; + while (getToken( ptr ).kind == DOT + && getToken( ptr + 1 ).kind == IDENTIFIER) { + ptr += 2; + } + } else { + return ptr; + } + + while (getToken( ptr ).kind == LBRACKET + && getToken( ptr + 1 ).kind == RBRACKET) { + ptr += 2; + } + + return ptr; + } + + private final boolean primitiveTypeCheck( Token t ) { + if (t.kind == BOOLEAN || t.kind == CHAR || t.kind == BYTE + || t.kind == SHORT || t.kind == INT || t.kind == LONG + || t.kind == FLOAT || t.kind == DOUBLE || t.kind == VOID) { + return true; + } + return false; + } + +} + +class IntAndObj +{ + IntAndObj( int ptr, Object obj ) { + super(); this.ptr = ptr; this.obj = obj; + } + int ptr; + Object obj; +} + +PARSER_END(Parser) + + +/***************************************** + * Utility Codes for Semantical Analysis * + *****************************************/ + +/* For Debug */ + JAVACODE + void debug_message1() { + DebugOut.println( "debug1 : " + getToken( 0 ).image + + " , " + getToken( 1 ).image ); +} + +/* Declaration Suffix */ +JAVACODE + ParseTree UserDeclSuffix(Environment env, String keyword) { + String typename = env.currentClassName(); + Class meta = toExecutable(env, typename); + SyntaxRule rule = invokeOJClass_getDeclSuffixRule(env, meta, keyword); + CustomTokenManager token_mgr = new CustomTokenManager(this, env); + token_mgr.assume(); + ParseTree result = rule.consume(token_mgr); + token_mgr.fix(); + return result; +} + +/* Type Name Suffix */ +JAVACODE + ParseTree UserTypeSuffix(Environment env, String typename, String keyword) { + Class meta = toExecutable(env, typename); + SyntaxRule rule = invokeOJClass_getTypeSuffixRule(env, meta, keyword); + CustomTokenManager token_mgr = new CustomTokenManager(this, env); + token_mgr.assume(); + ParseTree result = rule.consume(token_mgr); + token_mgr.fix(); + return result; +} + +/* Epsilon */ +JAVACODE + void E() {} + + +/***************************************** + * Lexical Descriptions * + *****************************************/ + +/* WHITE SPACE */ + +SKIP : +{ + " " + | "\t" + | "\n" + | "\r" + | "\f" + } + +/* COMMENTS */ + +MORE : +{ + <"/**" ~["/"]> : IN_FORMAL_COMMENT + } + +MORE : +{ + "//" : IN_SINGLE_LINE_COMMENT + | + "/*" : IN_MULTI_LINE_COMMENT + } + +<IN_SINGLE_LINE_COMMENT> + SPECIAL_TOKEN : +{ + <SINGLE_LINE_COMMENT: "\n" | "\r" | "\r\n" > : DEFAULT + } + +<IN_FORMAL_COMMENT> + SPECIAL_TOKEN : +{ + <FORMAL_COMMENT: "*/" > : DEFAULT + } + +<IN_MULTI_LINE_COMMENT> + SPECIAL_TOKEN : +{ + <MULTI_LINE_COMMENT: "*/" > : DEFAULT + } + +<IN_SINGLE_LINE_COMMENT,IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT> + MORE : +{ + < ~[] > + } + +/* RESERVED WORDS AND LITERALS */ + +TOKEN : +{ + < ABSTRACT: "abstract" > + | < BOOLEAN: "boolean" > + | < BREAK: "break" > + | < BYTE: "byte" > + | < CASE: "case" > + | < CATCH: "catch" > + | < CHAR: "char" > + | < CLASS: "class" > + | < CONST: "const" > + | < CONTINUE: "continue" > + | < _DEFAULT: "default" > + | < DO: "do" > + | < DOUBLE: "double" > + | < ELSE: "else" > + | < EXTENDS: "extends" > + | < FALSE: "false" > + | < FINAL: "final" > + | < FINALLY: "finally" > + | < FLOAT: "float" > + | < FOR: "for" > + | < GOTO: "goto" > + | < IF: "if" > + | < IMPLEMENTS: "implements" > + | < IMPORT: "import" > + | < INSTANCEOF: "instanceof" > + | < INT: "int" > + | < INTERFACE: "interface" > + | < LONG: "long" > + | < NATIVE: "native" > + | < NEW: "new" > + | < NULL: "null" > + | < PACKAGE: "package"> + | < PRIVATE: "private" > + | < PROTECTED: "protected" > + | < PUBLIC: "public" > + | < RETURN: "return" > + | < SHORT: "short" > + | < STATIC: "static" > + | < SUPER: "super" > + | < SWITCH: "switch" > + | < SYNCHRONIZED: "synchronized" > + | < THIS: "this" > + | < THROW: "throw" > + | < THROWS: "throws" > + | < TRANSIENT: "transient" > + | < TRUE: "true" > + | < TRY: "try" > + | < VOID: "void" > + | < VOLATILE: "volatile" > + | < WHILE: "while" > + | < METACLASS: "metaclass" > + | < INSTANTIATES: "instantiates" > + } + +/* LITERALS */ + +TOKEN : +{ + < INTEGER_LITERAL: + <DECIMAL_LITERAL> + | <HEX_LITERAL> + | <OCTAL_LITERAL> + > + | + < LONG_LITERAL: + <DECIMAL_LITERAL> ["l","L"] + | <HEX_LITERAL> ["l","L"] + | <OCTAL_LITERAL> ["l","L"] + > + | + < #DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* > + | + < #HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ > + | + < #OCTAL_LITERAL: "0" (["0"-"7"])* > + | + < DOUBLE_FLOATING_POINT_LITERAL: + (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)? (["d","D"])? + | "." (["0"-"9"])+ (<EXPONENT>)? ["d","D"] + | (["0"-"9"])+ <EXPONENT> ["d","D"] + | (["0"-"9"])+ (<EXPONENT>)? ["d","D"] + > + | + < FLOATING_POINT_LITERAL: + (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)? ["f","F"] + | "." (["0"-"9"])+ (<EXPONENT>)? (["f","F"])? + | (["0"-"9"])+ <EXPONENT> (["f","F"])? + | (["0"-"9"])+ (<EXPONENT>)? ["f","F"] + > + | + < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ > + | + < CHARACTER_LITERAL: + "'" + ( (~["'","\\","\n","\r"]) + | ("\\" + ( ["n","t","b","r","f","\\","'","\""] + | ["0"-"7"] ( ["0"-"7"] )? + | ["0"-"3"] ["0"-"7"] ["0"-"7"] + ) + ) + ) + "'" + > + | + < STRING_LITERAL: + "\"" + ( (~["\"","\\","\n","\r"]) + | ("\\" + ( ["n","t","b","r","f","\\","'","\""] + | ["0"-"7"] ( ["0"-"7"] )? + | ["0"-"3"] ["0"-"7"] ["0"-"7"] + ) + ) + )* + "\"" + > + } + +/* IDENTIFIERS */ + +TOKEN : +{ + < IDENTIFIER: <LETTER> (<LETTER>|<DIGIT>)* > + | + < #LETTER: + [ + "\u0024", + "\u0041"-"\u005a", + "\u005f", + "\u0061"-"\u007a", + "\u00c0"-"\u00d6", + "\u00d8"-"\u00f6", + "\u00f8"-"\u00ff", + "\u0100"-"\u1fff", + "\u3040"-"\u318f", + "\u3300"-"\u337f", + "\u3400"-"\u3d2d", + "\u4e00"-"\u9fff", + "\uf900"-"\ufaff" + ] + > + | + < #DIGIT: + [ + "\u0030"-"\u0039", + "\u0660"-"\u0669", + "\u06f0"-"\u06f9", + "\u0966"-"\u096f", + "\u09e6"-"\u09ef", + "\u0a66"-"\u0a6f", + "\u0ae6"-"\u0aef", + "\u0b66"-"\u0b6f", + "\u0be7"-"\u0bef", + "\u0c66"-"\u0c6f", + "\u0ce6"-"\u0cef", + "\u0d66"-"\u0d6f", + "\u0e50"-"\u0e59", + "\u0ed0"-"\u0ed9", + "\u1040"-"\u1049" + ] + > + } + +/* SEPARATORS */ + +TOKEN : +{ + < LPAREN: "(" > + | < RPAREN: ")" > + | < LBRACE: "{" > + | < RBRACE: "}" > + | < LBRACKET: "[" > + | < RBRACKET: "]" > + | < SEMICOLON: ";" > + | < COMMA: "," > + | < DOT: "." > + } + +/* OPERATORS */ + +TOKEN : +{ + < ASSIGN: "=" > + | < GT: ">" > + | < LT: "<" > + | < BANG: "!" > + | < TILDE: "~" > + | < HOOK: "?" > + | < COLON: ":" > + | < EQ: "==" > + | < LE: "<=" > + | < GE: ">=" > + | < NE: "!=" > + | < SC_OR: "||" > + | < SC_AND: "&&" > + | < INCR: "++" > + | < DECR: "--" > + | < PLUS: "+" > + | < MINUS: "-" > + | < STAR: "*" > + | < SLASH: "/" > + | < BIT_AND: "&" > + | < BIT_OR: "|" > + | < XOR: "^" > + | < REM: "%" > + | < LSHIFT: "<<" > + | < RSIGNEDSHIFT: ">>" > + | < RUNSIGNEDSHIFT: ">>>" > + | < PLUSASSIGN: "+=" > + | < MINUSASSIGN: "-=" > + | < STARASSIGN: "*=" > + | < SLASHASSIGN: "/=" > + | < ANDASSIGN: "&=" > + | < ORASSIGN: "|=" > + | < XORASSIGN: "^=" > + | < REMASSIGN: "%=" > + | < LSHIFTASSIGN: "<<=" > + | < RSIGNEDSHIFTASSIGN: ">>=" > + | < RUNSIGNEDSHIFTASSIGN: ">>>=" > + } + + +/***************************************** + * Syntactical Descriptions * + *****************************************/ + +/* + * Program structuring syntax follows. + */ + +CompilationUnit CompilationUnit( Environment base_env ) : +/* Any ";" around each type declaration must be ignored. */ +{ + CompilationUnit result; + FileEnvironment env = new FileEnvironment( base_env ); + String p1; + String[] p2; + ClassDeclarationList p3; + /**/DebugOut.println( "#CompilationUnit()" ); + String comment = getComment(); +} +{ + p1=PackageDeclarationOpt() + p2=ImportDeclarationListOpt() + { + env.setPackage( p1 ); + for (int i = 0; i < p2.length; ++i) { + if (CompilationUnit.isOnDemandImport( p2[i] )) { + String pack_cls = CompilationUnit.trimOnDemand( p2[i] ); + env.importPackage( pack_cls ); + } else { + env.importClass( p2[i] ); + } + } + } + ( ";" )* + p3=TypeDeclarationListOpt( env ) + <EOF> + { + result = new CompilationUnit( p1, p2, p3 ); + result.setComment( comment ); + return result; + } +} + +String PackageDeclarationOpt() : +{ + String p1; +} +{ + "package" p1=Name() ";" + { return p1; } + | + E() + { return null; } +} + +String[] ImportDeclarationListOpt() : +{ + String[] result; + String p1; + Vector v = new Vector(); +} +{ + ( p1=ImportDeclaration() { v.addElement( p1 ); } )+ + { + result = new String[v.size()]; + for (int i = 0; i < result.length; ++i) { + result[i] = (String) v.elementAt( i ); + } + } + { return result; } + | + E() + { return new String[0]; } +} + +String ImportDeclaration() : +{ + String p1; + StringBuffer strbuf = new StringBuffer(); +} +{ + "import" + Identifier() + { strbuf.append( getToken( 0 ).image ); } + ( LOOKAHEAD(2) + "." Identifier() + { strbuf.append( "." + getToken( 0 ).image ); } + )* + [ + "." "*" + { strbuf.append( ".*" ); } + ] + ";" + { return strbuf.toString(); } +} + +ClassDeclarationList TypeDeclarationListOpt( Environment env ) : +/* Must ignore ";"s */ +{ + ClassEnvironment newenv; + ClassDeclarationList result = new ClassDeclarationList(); + ClassDeclaration p1; +} +{ + LOOKAHEAD( { (getToken( 1 ).kind != RBRACE + && getToken( 1 ).kind != EOF) } ) + ( LOOKAHEAD( { (getToken( 1 ).kind != RBRACE + && getToken( 1 ).kind != EOF) } ) + { newenv = setClassEnvironment( env ); } + p1=TypeDeclaration( newenv ) + ( ";" )* + { result.add( p1 ); } + )+ + { return result; } + | + E() + { return result; } +} + +ClassDeclaration TypeDeclaration( ClassEnvironment env ) : +{ + ClassDeclaration result; + ClassDeclaration p1; + Token ctoken = getToken( 1 ).specialToken; + String comment = getComment(); +} +{ + ( + LOOKAHEAD( ( Identifier() | "abstract" | "final" | "public" )* + "class" ) + p1=ClassDeclaration( env ) + | + p1=InterfaceDeclaration( env ) + ) + { + result = p1; + result.setComment( comment ); + return result; + } +} + +String Identifier() : +/* This enables it to use "metaclass" as identifier. */ +{} +{ + <IDENTIFIER> + { return getToken( 0 ).image; } + | + "metaclass" + { return "metaclass"; } +} + +String[] MetaclassesOpt( Environment env ) : +/* metaclass may have metametaclass */ +{ + String[] result; + String p1; + String p2; + Vector v = new Vector(); + String qname; +} +{ + "metaclass" + p1=Name() + { + qname = env.toQualifiedName( p1 ); + v.addElement( qname ); + /****/DebugOut.print( "metaclass " + qname ); + } + [ + "," p2=Name() + { + qname = env.toQualifiedName( p2 ); + /****/DebugOut.print( ", " + qname ); + } + ] + ( ":" | ";" ) + { /****/DebugOut.println( " :" ); } + { + result = new String[v.size()]; + for (int i = 0; i < result.length; ++i) { + result[i] = (String) v.elementAt( i ); + } + } + { return result; } + | + E() + { return new String[0]; } +} + +String InstantiatesPhraseOpt( ClassEnvironment env ) : +{ + String p1 = null; +} +{ + "instantiates" p1=Name() + { return p1; } + | + E() + { return p1; } +} + +String OpenJavaModifier() : +/* User modifiers must not be "metaclass" */ +{ + String result; +} +{ + <IDENTIFIER> + { + result = getToken( 0 ).image; + DebugOut.println( "user modifier detected : " + result ); + } + { return result; } +} + +Hashtable OpenJavaDeclSuffixListOpt( Environment env ) : +{ + Hashtable result = new Hashtable(); + String p1; + ParseTree p2; +} +{ + LOOKAHEAD( { DeclSuffixLookahead( env ) } ) + ( LOOKAHEAD( { DeclSuffixLookahead( env ) } ) + p1=Identifier() + p2=UserDeclSuffix( env, p1 ) + { + DebugOut.println( "decl suffix : " + p1 + " " + p2 ); + result.put( p1, p2 ); + } + )+ + { return result; } + | + E() + { return result; } +} + +Hashtable OpenJavaTypeSuffixListOpt( Environment env, String typename ) : +{ + Hashtable result = new Hashtable(); + String p1; + ParseTree p2; +} +{ + LOOKAHEAD( { TypeSuffixLookahead( env, typename ) } ) + ( LOOKAHEAD( { TypeSuffixLookahead( env, typename ) } ) + p1=Identifier() + p2=UserTypeSuffix( env, typename, p1 ) + { + DebugOut.println( "type suffix : " + p1 + " " + p2 ); + result.put( p1, p2 ); + } + )+ + { return result; } + | + E() + { return result; } +} + +int Modifier() : +{} +{ + "abstract" { return ModifierList.ABSTRACT; } + | "final" { return ModifierList.FINAL; } + | "public" { return ModifierList.PUBLIC; } + | "private" { return ModifierList.PRIVATE; } + | "protected" { return ModifierList.PROTECTED; } + | "static" { return ModifierList.STATIC; } + | "transient" { return ModifierList.TRANSIENT; } + | "volatile" { return ModifierList.VOLATILE; } + | "native" { return ModifierList.NATIVE; } + | "synchronized" { return ModifierList.SYNCHRONIZED; } +} + +/* + * Declaration syntax follows. + */ + +ClassDeclaration ClassDeclaration( ClassEnvironment env ) : +{ + ModifierList p1; + ClassDeclaration p2; + + DebugOut.println( "#ClassDeclaration()" ); +} +{ + p1=ClassModifiersOpt( env ) + p2=UnmodifiedClassDeclaration( env ) + { p2.setModifiers( p1 ); } + { return p2; } +} + +ModifierList ClassModifiersOpt( Environment env ) : +{ + ModifierList result = new ModifierList(); + int p1; + String p2; +} +{ + LOOKAHEAD( { (getToken( 1 ).kind != CLASS) } ) + ( LOOKAHEAD( { ModifierLookahead( env ) } ) + ( + LOOKAHEAD( "abstract" | "final" | "public" ) + p1=Modifier() + { result.add( p1 ); } + | + LOOKAHEAD( { OpenJavaModifierLookahead( env ) } ) + p2=OpenJavaModifier() + { result.add( p2 ); } + ) + )+ + { return result; } + | + E() + { return result; } +} + +ClassDeclaration UnmodifiedClassDeclaration( ClassEnvironment env ) : +{ + ClassDeclaration result; + String p1; + TypeName[] p2; + TypeName[] p3; + MemberDeclarationList p4; + String mm; + Hashtable sf; +} +{ + "class" p1=Identifier() + mm=InstantiatesPhraseOpt( env ) + p2=ExtendsPhraseOpt( env ) + p3=ImplementsPhraseOpt( env ) + sf=OpenJavaDeclSuffixListOpt( env ) + p4=ClassBody( env ) + { + result = new ClassDeclaration( null, p1, p2, p3, p4 ); + result.setSuffixes( sf ); + } + { return result; } +} + +TypeName[] ExtendsPhraseOpt( Environment env ) : +{ + TypeName[] p1; +} +{ + /* "extends" TypeName() */ + "extends" p1=TypeNameList( env ) + { return p1; } + | + E() + { return null; } +} + +TypeName[] ImplementsPhraseOpt( Environment env ) : +{ + TypeName[] p1; +} +{ + "implements" p1=TypeNameList( env ) + { return p1; } + | + E() + { return null; } +} + +MemberDeclarationList ClassBody( ClassEnvironment env ) : +{ + MemberDeclarationList p1; + + DebugOut.println( "#ClassBody()" ); +} +{ + "{" + ( ";" )* + p1=ClassBodyDeclarationListOpt( env ) + "}" + { return p1; } +} + +MemberDeclarationList ClassBodyDeclarationListOpt( ClassEnvironment env ) : +{ + MemberDeclarationList result = new MemberDeclarationList(); + MemberDeclarationList p1; +} +{ + LOOKAHEAD( { (getToken( 1 ).kind != RBRACE) } ) + ( LOOKAHEAD( { (getToken( 1 ).kind != RBRACE) } ) + p1=ClassBodyDeclaration( env ) + ( ";" )* + { result.addAll( p1 ); } + )+ + { return result; } + | + E() + { return result; } +} + +ClassDeclaration NestedTypeDeclaration( ClassEnvironment env ) : +{ + ClassDeclaration result; + ClassDeclaration p1; + Token ctoken = getToken( 1 ).specialToken; + String comment = getComment(); +} +{ + ( + LOOKAHEAD( ( Identifier() | "static" | "abstract" | "final" + | "public" | "protected" | "private" )* + "class" ) + p1=NestedClassDeclaration( env ) + | + p1=NestedInterfaceDeclaration( env ) + ) + { + result = p1; + result.setComment( comment ); + return result; + } +} + +ClassDeclaration NestedClassDeclaration( ClassEnvironment env ) : +{ + ModifierList p1; + ClassDeclaration p2; + + DebugOut.println( "#NestedClassDeclaration()" ); +} +{ + p1=NestedClassModifiersOpt( env ) + p2=UnmodifiedClassDeclaration( env ) + { p2.setModifiers( p1 ); } + { return p2; } +} + +ModifierList NestedClassModifiersOpt( ClassEnvironment env ) : +{ + ModifierList result = new ModifierList(); + int p1; + String p2; +} +{ + LOOKAHEAD( { (getToken( 1 ).kind != CLASS) } ) + ( LOOKAHEAD( { ModifierLookahead( env ) } ) + ( + LOOKAHEAD( "static" | "abstract" | "final" + | "public" | "protected" | "private" ) + p1=Modifier() + { result.add( p1 ); } + | + LOOKAHEAD( { OpenJavaModifierLookahead( env ) } ) + p2=OpenJavaModifier() + { result.add( p2 ); } + ) + )+ + { return result; } + | + E() + { return result; } +} + +MemberDeclarationList ClassBodyDeclaration( ClassEnvironment env ) : +{ + ClassEnvironment newenv; + MemberDeclarationList result; + MemberDeclaration p1; + MemberDeclarationList p2; +} +{ + LOOKAHEAD( [ "static" ] "{" ) + p1=MemberInitializer( env ) + { result = new MemberDeclarationList( p1 ); } + { return result; } + | + LOOKAHEAD( ( Identifier() | "static" | "abstract" | "final" + | "public" | "protected" | "private" )* + ( "class" | "interface" ) ) + { newenv = setClassEnvironment( env ); } + p1=NestedTypeDeclaration( newenv ) + { result = new MemberDeclarationList( p1 ); } + { return result; } + | + LOOKAHEAD( { ConstructorDeclarationLookahead( env ) } ) + p1=ConstructorDeclaration( env ) + { result = new MemberDeclarationList( p1 ); } + { return result; } + | + p2=MethodOrFieldDeclaration( env ) + { return p2; } +} + +MemberDeclarationList MethodOrFieldDeclaration( Environment base_env ) : +{ + Environment env = new ClosedEnvironment( base_env ); + MemberDeclarationList result = new MemberDeclarationList(); + ModifierList p1; + TypeName p2; + String p3; + ParameterList p4; + int p5; + TypeName[] p6; + StatementList p7; + VariableDeclarator p8; + Hashtable sf; + Token ctoken = getToken( 1 ).specialToken; + String comment = getComment(); +} +{ + p1=MemberModifiersOpt( base_env ) + p2=Type( base_env ) + ( + LOOKAHEAD( Identifier() "(" ) + p3=Identifier() + p4=FormalParameters( env ) + p5=EmptyBracketsOpt() + p6=ThrowsPhraseOpt( base_env ) + sf=OpenJavaDeclSuffixListOpt( env ) + p7=MethodBody( env ) + { + p2.addDimension( p5 ); + MethodDeclaration mthd + = new MethodDeclaration( p1, p2, p3, p4, p6, p7 ); + mthd.setSuffixes( sf ); + mthd.setComment( comment ); + result.add( mthd ); + } + | + p8=VariableDeclarator( base_env ) + { + FieldDeclaration fld1 = new FieldDeclaration( p1, p2, p8 ); + fld1.setComment( comment ); + result.add( fld1 ); + } + ( + "," + p8=VariableDeclarator( env ) + { + FieldDeclaration fld2 = new FieldDeclaration( p1, p2, p8 ); + fld2.setComment( comment ); + result.add( fld2 ); + } + )* + ";" + ) + { return result; } +} + +TypeName[] ThrowsPhraseOpt( Environment env ) : +{ + TypeName[] p1; +} +{ + "throws" p1=TypeNameList( env ) + { return p1; } + | + E() + { return null; } +} + +StatementList MethodBody( Environment env ) : +{ + StatementList p1; +} +{ + p1=BlockedBody( env ) + { return p1; } + | + ";" + { return null; } +} + +ModifierList MemberModifiersOpt( Environment env ) : +{ + ModifierList result = new ModifierList(); + int p1; + String p2; +} +{ + LOOKAHEAD( { modifierCheck( env, getToken( 1 ) ) } ) + ( LOOKAHEAD( { ModifierLookahead( env ) } ) + ( + LOOKAHEAD( "public" | "protected" | "private" + | "static" | "abstract" | "final" + | "transient" | "volatile" | "native" | "synchronized" ) + p1=Modifier() + { result.add( p1 ); } + | + LOOKAHEAD( { OpenJavaModifierLookahead( env ) } ) + p2=OpenJavaModifier() + { result.add( p2 ); } + ) + )+ + { return result; } + | + E() + { return result; } +} + +ClassDeclaration InterfaceDeclaration( ClassEnvironment env ) : +{ + ModifierList p1; + ClassDeclaration p2; + + DebugOut.println( "#InterfaceDeclaration()" ); +} +{ + p1=InterfaceModifiersOpt( env ) + p2=UnmodifiedInterfaceDeclaration( env ) + { p2.setModifiers( p1 ); } + { return p2; } +} + +ModifierList InterfaceModifiersOpt( Environment env ) : +{ + ModifierList result = new ModifierList(); + int p1; + String p2; +} +{ + LOOKAHEAD( { (getToken( 1 ).kind != INTERFACE) } ) + ( LOOKAHEAD( { ModifierLookahead( env ) } ) + ( + LOOKAHEAD( "abstract" | "public" ) + p1=Modifier() + { result.add( p1 ); } + | + LOOKAHEAD( { OpenJavaModifierLookahead( env ) } ) + p2=OpenJavaModifier() + { result.add( p2 ); } + ) + )+ + { return result; } + | + E() + { return result; } +} + +ClassDeclaration NestedInterfaceDeclaration( ClassEnvironment env ) : +{ + ModifierList p1; + ClassDeclaration p2; + + DebugOut.println( "#NestedInterfaceDeclaration()" ); +} +{ + p1=NestedInterfaceModifiersOpt( env ) + p2=UnmodifiedInterfaceDeclaration( env ) + { p2.setModifiers( p1 ); } + { return p2; } +} + +ModifierList NestedInterfaceModifiersOpt( ClassEnvironment env ) : +{ + ModifierList result = new ModifierList(); + int p1; + String p2; +} +{ + LOOKAHEAD( { (getToken( 1 ).kind != INTERFACE) } ) + ( LOOKAHEAD( { ModifierLookahead( env ) } ) + ( + LOOKAHEAD( "static" | "abstract" | "final" + | "public" | "protected" | "private" ) + p1=Modifier() + { result.add( p1 ); } + | + LOOKAHEAD( { OpenJavaModifierLookahead( env ) } ) + p2=OpenJavaModifier() + { result.add( p2 ); } + ) + )+ + { return result; } + | + E() + { return result; } +} + +ClassDeclaration UnmodifiedInterfaceDeclaration( ClassEnvironment env ) : +{ + ClassDeclaration result; + String p1; + TypeName[] p2; + MemberDeclarationList p3; + String mm; + Hashtable sf; +} +{ + "interface" p1=Identifier() + mm=InstantiatesPhraseOpt( env ) + p2=ExtendsPhraseOpt( env ) + sf=OpenJavaDeclSuffixListOpt( env ) + p3=InterfaceBody( env ) + { + result = new ClassDeclaration( null, p1, p2, null, p3, false ); + result.setSuffixes( sf ); + } + { return result; } +} + +MemberDeclarationList InterfaceBody( ClassEnvironment env ) : +{ + MemberDeclarationList p1; +} +{ + "{" p1=InterfaceBodyDeclarationListOpt( env ) "}" + { return p1; } +} + +MemberDeclarationList InterfaceBodyDeclarationListOpt( ClassEnvironment env ) : +{ + MemberDeclarationList result = new MemberDeclarationList(); + MemberDeclarationList p1; +} +{ + LOOKAHEAD( { (getToken( 1 ).kind != RBRACE) } ) + ( LOOKAHEAD( { (getToken( 1 ).kind != RBRACE) } ) + p1=InterfaceBodyDeclaration( env ) + { result.addAll( p1 ); } + )+ + { return result; } + | + E() + { return result; } +} + +MemberDeclarationList InterfaceBodyDeclaration( ClassEnvironment env ) : +{ + ClassEnvironment newenv; + MemberDeclarationList result; + ClassDeclaration p1; + MemberDeclarationList p2; +} +{ + LOOKAHEAD( ( Identifier() | "abstract" | "final" | "public" )* + ( "class" | "interface" ) ) + { newenv = setClassEnvironment( env ); } + p1=NestedTypeDeclaration( newenv ) + { result = new MemberDeclarationList( p1 ); } + { return result; } + | + p2=MethodOrFieldDeclaration( env ) + { return p2; } +} + +VariableDeclarator VariableDeclarator( Environment env ) : +{ + String p1; + int p2; + VariableInitializer p3 = null; +} +{ + p1=Identifier() p2=EmptyBracketsOpt() [ "=" p3=VariableInitializer( env ) ] + { return new VariableDeclarator( p1, p2, p3 ); } +} + +int EmptyBracketsOpt() : +{ + int result = 0; +} +{ + LOOKAHEAD( "[" "]" ) + ( LOOKAHEAD(2) "[" "]" { result++; } )+ + { return result; } + | + E() + { return result; } +} + +VariableInitializer VariableInitializer( Environment env ) : +{ + VariableInitializer p1; +} +{ + p1=ArrayInitializer( env ) + { return p1; } + | + p1=Expression( env ) + { return p1; } +} + +ArrayInitializer ArrayInitializer( Environment env ) : +{ + ArrayInitializer result = new ArrayInitializer(); + VariableInitializer p1; +} +{ + "{" + [ LOOKAHEAD( { (getToken( 1 ).kind != RBRACE + && getToken( 1 ).kind != COMMA) } ) + p1=VariableInitializer( env ) + { result.add( p1 ); } + ( LOOKAHEAD( { (getToken( 1 ).kind == COMMA + && getToken( 2 ).kind != RBRACE) } ) + "," p1=VariableInitializer( env ) + { result.add( p1 ); } + )* + ] + [ "," { result.omitRemainder( true ); } ] + "}" + { return result; } +} + +ParameterList FormalParameters( Environment env ) : +{ + ParameterList result = new ParameterList(); + Parameter p1; + + DebugOut.println( "#FormalParameters()" ); +} +{ + "(" + [ LOOKAHEAD( { (getToken( 1 ).kind != RPAREN) } ) + p1=FormalParameter( env ) + { result.add( p1 ); } + ( "," p1=FormalParameter( env ) { result.add( p1 ); } )* + ] + ")" + { return result; } +} + +Parameter FormalParameter( Environment env ) : +{ + ModifierList p1; + TypeName p2; + String p3; + int p4; + DebugOut.println( "#FormalParameter()" ); +} +{ + p1=FormalParameterModifiersOpt( env ) p2=Type( env ) + p3=Identifier() p4=EmptyBracketsOpt() + { + p2.addDimension( p4 ); + /* binds the parameter variable as the null type */ + env.bindVariable(p3, OJSystem.NULLTYPE); + } + { return new Parameter( p1, p2, p3 ); } +} + +ModifierList FormalParameterModifiersOpt( Environment env ) : +{ + ModifierList result = new ModifierList(); + int p1; + String p2; +} +{ + LOOKAHEAD( { modifierCheck( env, getToken( 1 ) ) } ) + ( LOOKAHEAD( { ModifierLookahead( env ) } ) + ( + LOOKAHEAD( "final" ) + p1=Modifier() + { result.add( p1 ); } + | + LOOKAHEAD( { OpenJavaModifierLookahead( env ) } ) + p2=OpenJavaModifier() + { result.add( p2 ); } + ) + )+ + { return result; } + | + E() + { return result; } +} + +ConstructorDeclaration ConstructorDeclaration( Environment base_env ) : +{ + Environment env = new ClosedEnvironment( base_env ); + ConstructorDeclaration result; + ModifierList p1; + String p2; + ParameterList p3; + TypeName[] p4; + ConstructorInvocation p5; + StatementList p6; + Hashtable sf; + + DebugOut.println( "#ConstructorDeclaration()" ); +} +{ + p1=ConstructorModifiersOpt( base_env ) + p2=Identifier() + p3=FormalParameters( env ) + p4=ThrowsPhraseOpt( base_env ) + sf=OpenJavaDeclSuffixListOpt( env ) + "{" + p5=ExplicitConstructorInvocationOpt( env ) + p6=BlockOrStatementListOpt( env ) + "}" + { + result = new ConstructorDeclaration( p1, p2, p3, p4, p5, p6 ); + result.setSuffixes( sf ); + return result; + } +} + +ModifierList ConstructorModifiersOpt( Environment env ) : +{ + ModifierList result = new ModifierList(); + int p1; + String p2; +} +{ + LOOKAHEAD( "public" | "protected" | "private" ) + p1=Modifier() + { result.add( p1 ); } + ( LOOKAHEAD( { OpenJavaModifierLookahead( env ) } ) + p2=OpenJavaModifier() + { result.add( p2 ); } + )* + { return result; } + | + LOOKAHEAD( { OpenJavaModifierLookahead( env ) } ) + ( LOOKAHEAD( { OpenJavaModifierLookahead( env ) } ) + p2=OpenJavaModifier() + { result.add( p2 ); } + )+ + [ + p1=Modifier() + { result.add( p1 ); } + ( LOOKAHEAD( { OpenJavaModifierLookahead( env ) } ) + p2=OpenJavaModifier() + { result.add( p2 ); } + )* + ] + { return result; } + | + E() + { return result; } +} + +ConstructorInvocation ExplicitConstructorInvocationOpt( Environment env ) : +{ + ExpressionList p1; + Expression p2 = null; + + DebugOut.println( "#ExplicitConstructorInvocationOpt()" ); +} +{ + LOOKAHEAD( "this" "(" ) + "this" p1=Arguments( env ) ";" + { return new ConstructorInvocation( p1 ); } + | + LOOKAHEAD( { ConstructorInvocationLookahead() } ) + [ LOOKAHEAD( { (getToken( 1 ).kind != SUPER) } ) + p2=PrimaryExpression( env ) "." + ] + "super" p1=Arguments( env ) ";" + { return new ConstructorInvocation( p1, p2 ); } + | + E() + { return null; } +} + +MemberInitializer MemberInitializer( Environment env ) : +{ + MemberInitializer result; + StatementList p1; + boolean is_static = false; +} +{ + [ "static" { is_static = true; } ] p1=BlockedBody( env ) + { + if (is_static) { + result = new MemberInitializer( p1, true ); + } else { + result = new MemberInitializer( p1 ); + } + } + { return result; } +} + + +/* + * Type, name and expression syntax follows. + */ + +TypeName Type( Environment env ) : +{ + TypeName result; + String p1; + Hashtable p2; + int p3; +} +{ + ( p1=PrimitiveType() | p1=Name() ) + p2=OpenJavaTypeSuffixListOpt( env, p1 ) + p3=EmptyBracketsOpt() + { + result = new TypeName( p1, p3, p2 ); + } + { return result; } +} + +String PrimitiveType() : +{ + String result; +} +{ + ( "boolean" | "char" | "byte" | "short" | "int" | "long" + | "float" | "double" | "void" + ) + { result = getToken( 0 ).image; } + { return result; } +} + +String Name() : +/* + * A lookahead of 2 is required below since "Name" can be followed + * by a ".*" when used in the context of an "ImportDeclaration". + */ +{ + String p1; + StringBuffer strbuf = null; +} +{ + p1=Identifier() { strbuf = new StringBuffer( p1 ); } + ( LOOKAHEAD(2) + "." p1=Identifier() + { strbuf.append( "." + p1 ); } + )* + { return strbuf.toString(); } +} + +TypeName TypeName( Environment env ) : +{ + TypeName result; + String p1; + Hashtable p2; +} +{ + p1=Name() + p2=OpenJavaTypeSuffixListOpt( env, p1 ) + { + result = new TypeName( p1, p2 ); + } + { return result; } +} + +TypeName[] TypeNameList( Environment env ) : +{ + TypeName[] result; + TypeName p1; + Vector v = new Vector(); +} +{ + p1=TypeName( env ) { v.addElement( p1 ); } + ( + "," + p1=TypeName( env ) { v.addElement( p1 ); } + )* + { + result = new TypeName[v.size()]; + for (int i = 0; i < result.length; ++i) { + result[i] = (TypeName) v.elementAt( i ); + } + } + { return result; } +} + +TypeName[] TypeNameListOpt( Environment env ) : +{ + TypeName[] result; + TypeName p1; + Vector v = new Vector(); +} +{ + p1=TypeName( env ) { v.addElement( p1 ); } + ( + "," + p1=TypeName( env ) { v.addElement( p1 ); } + )* + { + result = new TypeName[v.size()]; + for (int i = 0; i < result.length; ++i) { + result[i] = (TypeName) v.elementAt( i ); + } + } + { return result; } + | + E() + { return new TypeName[0]; } +} + + +/* + * Expression syntax follows. + */ + +Expression Expression( Environment env ) : +{ + Expression result; + Expression p1; + String p2 = null; + Expression p3 = null; + + DebugOut.println( "#Expression()" ); +} +{ + p1=ConditionalExpression( env ) + [ p2=AssignmentOperator() p3=Expression( env ) ] + { + if (p2 != null) { + result = new AssignmentExpression( p1, p2, p3 ); + } else { + result = p1; + } + } + { return result; } +} + +AssignmentExpression AssignmentExpression( Environment env ) : +{ + Expression p1; + String p2; + Expression p3; + + DebugOut.println( "#AssignmentExpression()" ); +} +{ + p1=PrimaryExpression( env ) p2=AssignmentOperator() p3=Expression( env ) + { return new AssignmentExpression( p1, p2, p3 ); } +} + +String AssignmentOperator() : +{ + String result; + + DebugOut.println( "#AssignmentOperator()" ); +} +{ + ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | ">>>=" + | "&=" | "^=" | "|=" ) + { result = getToken( 0 ).image; } + { return result; } +} + +Expression ConditionalExpression( Environment env ) : +{ + Expression result; + Expression p1; + Expression p2 = null; + Expression p3 = null; +} +{ + p1=ConditionalOrExpression( env ) + [ + "?" p2=Expression( env ) + ":" p3=ConditionalExpression( env ) + ] + { + if (p2 != null) { + result = new ConditionalExpression( p1, p2, p3 ); + } else { + result = p1; + } + } + { return result; } +} + +Expression ConditionalOrExpression( Environment env ) : +{ + Expression result; + Expression p1; + String p2; + Expression p3; +} +{ + p1=ConditionalAndExpression( env ) + { result = p1; } + ( + "||" { p2 = getToken( 0 ).image; } + p3=ConditionalAndExpression( env ) + { result = new BinaryExpression( result, p2, p3 ); } + )* + { return result; } +} + +Expression ConditionalAndExpression( Environment env ) : +{ + Expression result; + Expression p1; + String p2; + Expression p3; +} +{ + p1=InclusiveOrExpression( env ) + { result = p1; } + ( + "&&" { p2 = getToken( 0 ).image; } + p3=InclusiveOrExpression( env ) + { result = new BinaryExpression( result, p2, p3 ); } + )* + { return result; } +} + +Expression InclusiveOrExpression( Environment env ) : +{ + Expression result; + Expression p1; + String p2; + Expression p3; +} +{ + p1=ExclusiveOrExpression( env ) + { result = p1; } + ( + "|" { p2 = getToken( 0 ).image; } + p3=ExclusiveOrExpression( env ) + { result = new BinaryExpression( result, p2, p3 ); } + )* + { return result; } +} + +Expression ExclusiveOrExpression( Environment env ) : +{ + Expression result; + Expression p1; + String p2; + Expression p3; +} +{ + p1=AndExpression( env ) + { result = p1; } + ( + "^" { p2 = getToken( 0 ).image; } + p3=AndExpression( env ) + { result = new BinaryExpression( result, p2, p3 ); } + )* + { return result; } +} + +Expression AndExpression( Environment env ) : +{ + Expression result; + Expression p1; + String p2; + Expression p3; +} +{ + p1=EqualityExpression( env ) + { result = p1; } + ( + "&" { p2 = getToken( 0 ).image; } + p3=EqualityExpression( env ) + { result = new BinaryExpression( result, p2, p3 ); } + )* + { return result; } +} + +Expression EqualityExpression( Environment env ) : +{ + Expression result; + Expression p1; + String p2; + Expression p3; + + DebugOut.println( "#EqualityExpression()" ); +} +{ + p1=InstanceofExpression( env ) + { result = p1; } + ( + ( "==" | "!=" ) { p2 = getToken( 0 ).image; } + p3=InstanceofExpression( env ) + { result = new BinaryExpression( result, p2, p3 ); } + )* + { return result; } +} + +Expression InstanceofExpression( Environment env ) : +{ + Expression result; + Expression p1; + TypeName p2 = null; +} +{ + p1=RelationalExpression( env ) [ "instanceof" p2=Type( env ) ] + { + if (p2 != null) { + result = new InstanceofExpression( p1, p2 ); + } else { + result = p1; + } + } + { return result; } +} + +Expression RelationalExpression( Environment env ) : +{ + Expression result; + Expression p1; + String p2; + Expression p3; +} +{ + p1=ShiftExpression( env ) + { result = p1; } + ( + ( "<" | ">" | "<=" | ">=" ) { p2 = getToken( 0 ).image; } + p3=ShiftExpression( env ) + { result = new BinaryExpression( result, p2, p3 ); } + )* + { return result; } +} + +Expression ShiftExpression( Environment env ) : +{ + Expression result; + Expression p1; + String p2; + Expression p3; +} +{ + p1=AdditiveExpression( env ) + { result = p1; } + ( + ( "<<" | ">>" | ">>>" ) { p2 = getToken( 0 ).image; } + p3=AdditiveExpression( env ) + { result = new BinaryExpression( result, p2, p3 ); } + )* + { return result; } +} + +Expression AdditiveExpression( Environment env ) : +{ + Expression result; + Expression p1; + String p2; + Expression p3; +} +{ + p1=MultiplicativeExpression( env ) + { result = p1; } + ( + ( "+" | "-" ) { p2 = getToken( 0 ).image; } + p3=MultiplicativeExpression( env ) + { result = new BinaryExpression( result, p2, p3 ); } + )* + { return result; } +} + +Expression MultiplicativeExpression( Environment env ) : +{ + Expression result; + Expression p1; + String p2; + Expression p3; +} +{ + p1=UnaryExpression( env ) + { result = p1; } + ( + ( "*" | "/" | "%" ) { p2 = getToken( 0 ).image; } + p3=UnaryExpression( env ) + { result = new BinaryExpression( result, p2, p3 ); } + )* + { return result; } +} + +Expression UnaryExpression( Environment env ) : +{ + int p1; + Expression p2; +} +{ + LOOKAHEAD( "+" | "-" ) + ( + "+" { p1 = UnaryExpression.PLUS; } + | + "-" { p1 = UnaryExpression.MINUS; } + ) + p2=UnaryExpression( env ) + { return new UnaryExpression( p1, p2 ); } + | + LOOKAHEAD( "++" | "--" ) + p2=PreIncrementExpression( env ) + { return p2; } + | + p2=UnaryExpressionNotPlusMinus( env ) + { return p2; } +} + +Expression PreIncrementExpression( Environment env ) : +{ + int p1; + Expression p2; +} +{ + ( + "++" { p1 = UnaryExpression.PRE_INCREMENT; } + | + "--" { p1 = UnaryExpression.PRE_DECREMENT; } + ) + p2=PrimaryExpression( env ) + { return new UnaryExpression( p1, p2 ); } +} + +Expression UnaryExpressionNotPlusMinus( Environment env ) : +{ + int p1; + Expression p2; +} +{ + ( + "~" { p1 = UnaryExpression.BIT_NOT; } + | + "!" { p1 = UnaryExpression.NOT; } + ) + p2=UnaryExpression( env ) + { return new UnaryExpression( p1, p2 ); } + | + LOOKAHEAD( CastLookahead() ) + p2=CastExpression( env ) + { return p2; } + | + p2=PostfixExpression( env ) + { return p2; } +} + +void CastLookahead( Environment env ) : + /* This method is lookahead only. */ +{} +{ + LOOKAHEAD(2) + "(" PrimitiveType() + | + LOOKAHEAD("(" Name() "[") + "(" Name() "[" "]" + | + LOOKAHEAD("(" Name() ")") + "(" Name() ")" + ( "~" | "!" | "(" | Identifier() | "this" | "super" | "new" | Literal() ) + | + "(" Name() Identifier() + } + +Expression PostfixExpression( Environment env ) : +{ + Expression result; + Expression p1; + int p2 = -1; +} +{ + p1=PrimaryExpression( env ) + [ + "++" { p2 = UnaryExpression.POST_INCREMENT; } + | + "--" { p2 = UnaryExpression.POST_DECREMENT; } + ] + { + if (p2 != -1) { + result = new UnaryExpression( p1, p2 ); + } else { + result = p1; + } + } + { return result; } +} + +CastExpression CastExpression( Environment env ) : +{ + TypeName p1; + Expression p2; + + DebugOut.println( "#CastExpression()" ); +} +{ + LOOKAHEAD( "(" PrimitiveType() ) + "(" p1=Type( env ) ")" p2=UnaryExpression( env ) + { return new CastExpression( p1, p2 ); } + | + LOOKAHEAD( "(" Name() ) + "(" p1=Type( env ) ")" p2=UnaryExpressionNotPlusMinus( env ) + { return new CastExpression( p1, p2 ); } +} + +Expression SelfAccess( Environment env ) : +{ + Expression result; + String p1 = null; +} +{ + [ p1=Name() "." ] "this" + { + if (p1 != null) { + result = SelfAccess.makeThis( p1 ); + } else { + result = SelfAccess.constantThis(); + } + } + { return result; } +} + +ClassLiteral ClassLiteral( Environment env ) : +{ + TypeName p1; +} +{ + p1=Type( env ) "." "class" + { return new ClassLiteral( p1 ); } +} + +Expression PrimaryExpression( Environment env ) : +/* There must not be Name() . Identifier() + * There is a case that PrimaryPrefix is a Name() but is actualy + * FieldAccess(). This should be resolved later. + */ +{ + Expression result; + Expression p1; + Expression p2; + Expression p3; + String p4; + ExpressionList p5; +} +{ + p1=PrimaryPrefix( env ) + { result = p1; } + ( LOOKAHEAD( "." | "[" | "(" ) + ( + LOOKAHEAD( "." "new" ) + "." p2=AllocationExpression( env ) + { + AllocationExpression alloc = (AllocationExpression) p2; + alloc.setEncloser( result ); + result = alloc; + } + | + "[" p3=Expression( env ) "]" + { result = new ArrayAccess( result, p3 ); } + | + "." p4=Identifier() + { result = new FieldAccess( result, p4 ); } + | + p5=Arguments( env ) + { + FieldAccess base = (FieldAccess) result; + Expression expr = base.getReferenceExpr(); + String name = base.getName(); + result = new MethodCall( expr, name, p5 ); + } + ) + )* + { return result; } +} + +Expression PrimaryPrefix( Environment env ) : +{ + Expression p1; + String p2; + + DebugOut.println( "#PrimaryPrefix()" ); +} +{ + p1=Literal() + { return p1; } + | + LOOKAHEAD( [ Name() "." ] "this" ) + p1=SelfAccess( env ) + { return p1; } + | + "super" "." p2=Identifier() + { return new FieldAccess( SelfAccess.constantSuper(), p2 ); } + | + "(" p1=Expression( env ) ")" + { return p1; } + | + p1=AllocationExpression( env ) + { return p1; } + | + LOOKAHEAD( { ClassLiteralLookahead() } ) + p1=ClassLiteral( env ) + { return p1; } + | + p1=TempFieldAccess( env ) + { return p1; } +} + +FieldAccess TempFieldAccess( Environment env ) : +/* + * Returns temporary expression as a field access; + * A field access without primary may be a variable. + * A variable may be qualified class name or field access. + */ +{ + FieldAccess result; + String p1; + StringBuffer strbuf = null; +} +{ + p1=Identifier() + ( LOOKAHEAD( "." Identifier() ) + "." + { + if (strbuf == null) { + strbuf = new StringBuffer( p1 ); + } else { + strbuf.append( "." + p1 ); + } + } + p1=Identifier() + )* + { + if (strbuf == null || strbuf.length() == 0) { + result = new FieldAccess( (Variable) null, p1 ); + } else { + Variable var = new Variable( strbuf.toString() ); + result = new FieldAccess( var, p1 ); + } + } + { return result; } +} + +Literal Literal() : +{ + String p1; + Literal p2; +} +{ + <INTEGER_LITERAL> { p1 = getToken( 0 ).image; } + { return new Literal( Literal.INTEGER, p1 ); } + | + <LONG_LITERAL> { p1 = getToken( 0 ).image; } + { return new Literal( Literal.LONG, p1 ); } + | + <FLOATING_POINT_LITERAL> { p1 = getToken( 0 ).image; } + { return new Literal( Literal.FLOAT, p1 ); } + | + <DOUBLE_FLOATING_POINT_LITERAL> { p1 = getToken( 0 ).image; } + { return new Literal( Literal.DOUBLE, p1 ); } + | + <CHARACTER_LITERAL> { p1 = getToken( 0 ).image; } + { return new Literal( Literal.CHARACTER, p1 ); } + | + <STRING_LITERAL> { p1 = getToken( 0 ).image; } + { return new Literal( Literal.STRING, p1 ); } + | + "true" + { return Literal.constantTrue(); } + | + "false" + { return Literal.constantFalse(); } + | + "null" + { return Literal.constantNull(); } +} + +ExpressionList Arguments( Environment env ) : +{ + ExpressionList result = new ExpressionList(); + Expression p1; + + DebugOut.println( "#Arguments()" ); +} +{ + "(" + [ + p1=Expression( env ) + { result.add( p1 ); } + ( + "," p1=Expression( env ) + { result.add( p1 ); } + )* + ] + ")" + { return result; } +} + +Expression AllocationExpression( Environment env ) : +{ + Expression result; + AllocationExpression aloc_result; + TypeName p1; + ArrayAllocationExpression p2; + ExpressionList p3; + MemberDeclarationList p4 = null; + + DebugOut.println( "#AllocationExpression()" ); +} +{ + LOOKAHEAD( "new" PrimitiveType() ) + "new" p1=TypeWithoutDims( env ) + p2=ArrayDimsAndInits( env, p1 ) + { result = p2; } + { return result; } + | + "new" p1=TypeWithoutDims( env ) + ( + LOOKAHEAD( "[" ) + p2=ArrayDimsAndInits( env, p1 ) + { result = p2; } + | + p3=Arguments( env ) + { aloc_result = new AllocationExpression( p1, p3, p4 ); } + [ + p4=ClassBody( new ClassEnvironment( env ) ) + { aloc_result.setClassBody( p4 ); } + ] + { result = aloc_result; } + ) + { return result; } +} + +TypeName TypeWithoutDims( Environment env ) : +{ + String p1; + Hashtable p2; +} +{ + ( p1=PrimitiveType() | p1=Name() ) + p2=OpenJavaTypeSuffixListOpt( env, p1 ) + { return new TypeName( p1, p2 ); } +} + +ArrayAllocationExpression ArrayDimsAndInits( Environment env, TypeName type ) : +/* + * The first LOOKAHEAD specification below is to parse to PrimarySuffix + * if there is an expression between the "[...]". + */ +{ + Expression p1; + int p2; + ArrayInitializer p3; + ExpressionList exprs = new ExpressionList(); +} +{ + LOOKAHEAD( "[" "]" ) + p2=EmptyBracketsOpt() p3=ArrayInitializer( env ) + { for (int i = 0; i < p2; ++i) exprs.add( null ); } + { return new ArrayAllocationExpression( type, exprs, p3 ); } + | + LOOKAHEAD( "[" ) + ( LOOKAHEAD( { (getToken( 1 ).kind == LBRACKET + && getToken( 2 ).kind != RBRACKET) } ) + "[" p1=Expression( env ) { exprs.add( p1 ); } "]" + )+ + p2=EmptyBracketsOpt() + { for (int i = 0; i < p2; ++i) exprs.add( null ); } + { return new ArrayAllocationExpression( type, exprs ); } +} + +StatementList BlockedBody( Environment env ) : +/* See also Block. This is for bodys but for statement */ +{ + StatementList p1; +} +{ + "{" p1=BlockOrStatementListOpt( env ) "}" + { return p1; } +} + +/* + * Statement syntax follows. + */ + +Statement Statement( Environment env ) : +{ + Statement p1; +} +{ + LOOKAHEAD( Identifier() ":" ) + p1=LabeledStatement( env ) + { return p1; } + | + p1=Block( env ) + { return p1; } + | + p1=EmptyStatement( env ) + { return p1; } + | + p1=SwitchStatement( env ) + { return p1; } + | + p1=IfStatement( env ) + { return p1; } + | + p1=WhileStatement( env ) + { return p1; } + | + p1=DoWhileStatement( env ) + { return p1; } + | + p1=ForStatement( env ) + { return p1; } + | + p1=BreakStatement( env ) + { return p1; } + | + p1=ContinueStatement( env ) + { return p1; } + | + p1=ReturnStatement( env ) + { return p1; } + | + p1=ThrowStatement( env ) + { return p1; } + | + p1=SynchronizedStatement( env ) + { return p1; } + | + p1=TryStatement( env ) + { return p1; } + | + p1=ExpressionStatement( env ) + { return p1; } +} + +LabeledStatement LabeledStatement( Environment env ) : +{ + String p1; + Statement p2; + + DebugOut.println( "#LabeledStatement()" ); +} +{ + p1=Identifier() ":" p2=Statement( env ) + { return new LabeledStatement( p1, p2 ); } +} + +Block Block( Environment env ) : +/* See also BlockedBody. This is to be statement */ +{ + StatementList p1; + DebugOut.println( "#Block()" ); +} +{ + "{" p1=BlockOrStatementListOpt( env ) "}" + { return new Block( p1 ); } +} + +StatementList BlockOrStatementListOpt( Environment env ) : +{ + StatementList result = new StatementList(); + StatementList p1; +} +{ + LOOKAHEAD( { (getToken( 1 ).kind != RBRACE + && getToken( 1 ).kind != EOF + && getToken( 1 ).kind != CASE + && getToken( 1 ).kind != _DEFAULT ) } ) + ( LOOKAHEAD( { (getToken( 1 ).kind != RBRACE + && getToken( 1 ).kind != EOF + && getToken( 1 ).kind != CASE + && getToken( 1 ).kind != _DEFAULT ) } ) + p1=BlockOrStatement( env ) + { result.addAll( p1 ); } + )+ + { return result; } + | + E() + { return result; } +} + +StatementList BlockOrStatement( Environment env ) : +{ + Statement p1; + StatementList p2; +} +{ + p1=UnmodifiedClassDeclaration( new ClassEnvironment( env ) ) + { return new StatementList( p1 ); } + | + LOOKAHEAD( { LocalVariableDeclarationLookahead( env ) } ) + p2=LocalVariableDeclaration( env ) ";" + { return p2; } + | + p1=Statement( env ) + { return new StatementList( p1 ); } +} + +StatementList LocalVariableDeclaration( Environment env ) : +{ + StatementList result = new StatementList(); + ModifierList p1; + TypeName p2; + VariableDeclarator p3; + TypeName tspec; + String vname; + VariableInitializer vinit; + DebugOut.println( "#LocalVariableDeclaration()" ); +} +{ + p1=VariableModifiersOpt( env ) p2=Type( env ) + p3=VariableDeclarator( env ) + { + tspec = (TypeName) p2.makeRecursiveCopy(); + tspec.addDimension( p3.getDimension() ); + vname = p3.getVariable(); + vinit = p3.getInitializer(); + result.add( new VariableDeclaration( p1, tspec, vname, vinit ) ); + } + ( + "," p3=VariableDeclarator( env ) + { + tspec = (TypeName) p2.makeRecursiveCopy(); + tspec.addDimension( p3.getDimension() ); + vname = p3.getVariable(); + vinit = p3.getInitializer(); + result.add( new VariableDeclaration( p1, tspec, vname, vinit ) ); + } + )* + { return result; } +} + +ModifierList VariableModifiersOpt( Environment env ) : +{ + ModifierList result = new ModifierList(); + int p1; + String p2; +} +{ + LOOKAHEAD( { modifierCheck( env, getToken( 1 ) ) } ) + ( LOOKAHEAD( { ModifierLookahead( env ) } ) + ( + LOOKAHEAD( "final" ) + p1=Modifier() + { result.add( p1 ); } + | + LOOKAHEAD( { OpenJavaModifierLookahead( env ) } ) + p2=OpenJavaModifier() + { result.add( p2 ); } + ) + )+ + { return result; } + | + E() + { return result; } +} + +EmptyStatement EmptyStatement( Environment env ) : +{ + DebugOut.println( "#EmptyStatement()" ); +} +{ + ";" + { return new EmptyStatement(); } +} + +ExpressionStatement ExpressionStatement( Environment env ) : +{ + Expression p1; + + DebugOut.println( "#ExpressionStatement()" ); +} +{ + p1=StatementExpression( env ) ";" + { return new ExpressionStatement( p1 ); } +} + +Expression StatementExpression( Environment env ) : +{ + Expression p1; + /***********/ +} +{ + p1=PreIncrementExpression( env ) + { return p1; } + | + /*LOOKAHEAD( PrimaryExpression( env ) AssignmentOperator() )*/ + LOOKAHEAD( { AssignmentLookahead() } ) + p1=AssignmentExpression( env ) + { return p1; } + | + p1=PostfixExpression( env ) + { return p1; } +} + +SwitchStatement SwitchStatement( Environment env ) : +{ + Expression p1; + Expression p2; + StatementList p3; + CaseGroupList cplist = new CaseGroupList(); + ExpressionList exprs; + + DebugOut.println( "#SwitchStatement()" ); +} +{ + "switch" "(" p1=Expression( env ) ")" "{" + ( LOOKAHEAD( "case" | "default" ) + { exprs = new ExpressionList(); } + ( LOOKAHEAD( "case" | "default" ) + p2=SwitchLabel( env ) { exprs.add( p2 ); } + )+ + p3=BlockOrStatementListOpt( env ) + { cplist.add( new CaseGroup( exprs, p3 ) ); } + )* + "}" + { return new SwitchStatement( p1, cplist ); } +} + +Expression SwitchLabel( Environment env ) : +{ + Expression p1; +} +{ + "case" p1=Expression( env ) ":" + { return p1; } + | + "default" ":" + { return null; } +} + +IfStatement IfStatement( Environment env ) : +/* + * The disambiguating algorithm of JavaCC automatically binds dangling + * else's to the innermost if statement. The LOOKAHEAD specification + * is to tell JavaCC that we know what we are doing. + */ +{ + IfStatement result; + Expression p1; + StatementList p2; + Statement p3; + StatementList true_part; + StatementList false_part = null; + + DebugOut.println( "#IfStatement()" ); +} +{ + "if" "(" p1=Expression( env ) ")" + ( LOOKAHEAD(1) + p2=BlockedBody( env ) + { true_part = p2; } + | + p3=Statement( env ) + { true_part = new StatementList( p3 ); } + ) + [ LOOKAHEAD(1) + "else" + ( LOOKAHEAD(1) + p2=BlockedBody( env ) + { false_part = p2; } + | + p3=Statement( env ) + { false_part = new StatementList( p3 ); } + ) + ] + { return new IfStatement( p1, true_part, false_part ); } +} + +WhileStatement WhileStatement( Environment env ) : +{ + Expression p1; + StatementList p2; + Statement p3; + StatementList body; + + DebugOut.println( "#WhileStatement()" ); +} +{ + "while" "(" p1=Expression( env ) ")" + ( LOOKAHEAD(1) + p2=BlockedBody( env ) + { body = p2; } + | + p3=Statement( env ) + { body = new StatementList( p3 ); } + ) + { return new WhileStatement( p1, body ); } +} + +DoWhileStatement DoWhileStatement( Environment env ) : +{ + StatementList p1; + Statement p2; + Expression p3; + StatementList body; + + DebugOut.println( "#DoWhileStatement()" ); +} +{ + "do" + ( LOOKAHEAD(1) + p1=BlockedBody( env ) + { body = p1; } + | + p2=Statement( env ) + { body = new StatementList( p2 ); } + ) + "while" "(" p3=Expression( env ) ")" ";" + { return new DoWhileStatement( body, p3 ); } +} + +ForStatement ForStatement( Environment env ) : +{ + ForStatement result; + TypeName p1 = null; + VariableDeclarator[] p2 = null; + ExpressionList p3 = null; + Expression p4 = null; + ExpressionList p5 = null; + StatementList p6; + Statement p7; + StatementList body; + + DebugOut.println( "#ForStatement()" ); +} +{ + "for" "(" + [ LOOKAHEAD( { (getToken( 1 ).kind != SEMICOLON) } ) + ( + LOOKAHEAD( { LocalVariableDeclarationLookahead( env ) } ) + p1=Type( env ) + p2=VariableDeclaratorList( env ) + | + p3=StatementExpressionList( env ) + ) + ] + ";" + [ LOOKAHEAD( { (getToken( 1 ).kind != SEMICOLON) } ) + p4=Expression( env ) + ] + ";" + [ LOOKAHEAD( { (getToken( 1 ).kind != RPAREN) } ) + p5=StatementExpressionList( env ) + ] + ")" + ( + LOOKAHEAD(1) + p6=BlockedBody( env ) + { body = p6; } + | + p7=Statement( env ) + { body = new StatementList( p7 ); } + ) + { + if (p1 != null) { + result = new ForStatement( p1, p2, p4, p5, body ); + } else if (p3 != null) { + result = new ForStatement( p3, p4, p5, body ); + } else { + result = new ForStatement( new ExpressionList(), p4, p5, body ); + } + } + { return result; } +} + +VariableDeclarator[] VariableDeclaratorList( Environment env ) : +{ + VariableDeclarator[] result; + VariableDeclarator p1; + Vector v = new Vector(); + + DebugOut.println( "#LocalVariableDeclaration()" ); +} +{ + p1=VariableDeclarator( env ) + { v.addElement( p1 ); } + ( + "," p1=VariableDeclarator( env ) + { v.addElement( p1 ); } + )* + { + result = new VariableDeclarator[v.size()]; + for (int i = 0; i < result.length; ++i) { + result[i] = (VariableDeclarator) v.elementAt( i ); + } + return result; + } +} + +ExpressionList StatementExpressionList( Environment env ) : +{ + ExpressionList result = new ExpressionList(); + Expression p1; +} +{ + p1=StatementExpression( env ) + { result.add( p1 ); } + ( + "," p1=StatementExpression( env ) + { result.add( p1 ); } + )* + { return result; } +} + +BreakStatement BreakStatement( Environment env ) : +{ + BreakStatement result; + String p1 = null; + + DebugOut.println( "#BreakStatement()" ); +} +{ + "break" [ p1=Identifier() ] ";" + { + if (p1 != null) { + result = new BreakStatement( p1 ); + } else { + result = new BreakStatement(); + } + } + { return result; } +} + +ContinueStatement ContinueStatement( Environment env ) : +{ + ContinueStatement result; + String p1 = null; + + DebugOut.println( "#ContinueStatement()" ); +} +{ + "continue" [ p1=Identifier() ] ";" + { + if (p1 != null) { + result = new ContinueStatement( p1 ); + } else { + result = new ContinueStatement(); + } + } + { return result; } +} + +ReturnStatement ReturnStatement( Environment env ) : +{ + ReturnStatement result; + Expression p1 = null; + + DebugOut.println( "#ReturnStatement()" ); +} +{ + "return" + [ + LOOKAHEAD( { (getToken(1).kind != SEMICOLON)} ) + p1=Expression( env ) + ] + ";" + { + if (p1 != null) { + result = new ReturnStatement( p1 ); + } else { + result = new ReturnStatement(); + } + } + { return result; } +} + +ThrowStatement ThrowStatement( Environment env ) : +{ + Statement result; + Expression p1; + + DebugOut.println( "#ThrowStatement()" ); +} +{ + "throw" p1=Expression( env ) ";" + { return new ThrowStatement( p1 ); } +} + +SynchronizedStatement SynchronizedStatement( Environment env ) : +{ + Expression p1; + StatementList p2; + + DebugOut.println( "#SynchronizedStatement()" ); +} +{ + "synchronized" "(" p1=Expression( env ) ")" p2=BlockedBody( env ) + { return new SynchronizedStatement( p1, p2 ); } +} + +TryStatement TryStatement( Environment base_env ) : +/* + * Semantic check required here to make sure that at least one + * finally/catch is present. + */ +{ + Environment env = new ClosedEnvironment( base_env ); + TryStatement result; + StatementList p1; + Parameter p2; + StatementList p3; + StatementList p4 = null; + CatchList catches = new CatchList(); + + DebugOut.println( "#TryStatement()" ); +} +{ + "try" p1=BlockedBody( env ) + ( LOOKAHEAD( "catch" ) + { env = new ClosedEnvironment( base_env ); } + "catch" "(" p2=FormalParameter( env ) ")" p3=BlockedBody( env ) + { catches.add( new CatchBlock( p2, p3 ) ); } + )* + [ + "finally" p4=BlockedBody( new ClosedEnvironment( base_env ) ) + ] + { result = new TryStatement( p1, catches, p4 ); } + { return result; } +} diff --git a/src/main/java/io/devnulllabs/openjava/tools/parser/ParserConstants.java b/src/main/java/io/devnulllabs/openjava/tools/parser/ParserConstants.java new file mode 100644 index 0000000..ce28d57 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/tools/parser/ParserConstants.java @@ -0,0 +1,254 @@ +/* Generated By:JavaCC: Do not edit this line. ParserConstants.java */ +package io.devnulllabs.openjava.tools.parser; + +public interface ParserConstants { + + int EOF = 0; + int SINGLE_LINE_COMMENT = 9; + int FORMAL_COMMENT = 10; + int MULTI_LINE_COMMENT = 11; + int ABSTRACT = 13; + int BOOLEAN = 14; + int BREAK = 15; + int BYTE = 16; + int CASE = 17; + int CATCH = 18; + int CHAR = 19; + int CLASS = 20; + int CONST = 21; + int CONTINUE = 22; + int _DEFAULT = 23; + int DO = 24; + int DOUBLE = 25; + int ELSE = 26; + int EXTENDS = 27; + int FALSE = 28; + int FINAL = 29; + int FINALLY = 30; + int FLOAT = 31; + int FOR = 32; + int GOTO = 33; + int IF = 34; + int IMPLEMENTS = 35; + int IMPORT = 36; + int INSTANCEOF = 37; + int INT = 38; + int INTERFACE = 39; + int LONG = 40; + int NATIVE = 41; + int NEW = 42; + int NULL = 43; + int PACKAGE = 44; + int PRIVATE = 45; + int PROTECTED = 46; + int PUBLIC = 47; + int RETURN = 48; + int SHORT = 49; + int STATIC = 50; + int SUPER = 51; + int SWITCH = 52; + int SYNCHRONIZED = 53; + int THIS = 54; + int THROW = 55; + int THROWS = 56; + int TRANSIENT = 57; + int TRUE = 58; + int TRY = 59; + int VOID = 60; + int VOLATILE = 61; + int WHILE = 62; + int METACLASS = 63; + int INSTANTIATES = 64; + int INTEGER_LITERAL = 65; + int LONG_LITERAL = 66; + int DECIMAL_LITERAL = 67; + int HEX_LITERAL = 68; + int OCTAL_LITERAL = 69; + int DOUBLE_FLOATING_POINT_LITERAL = 70; + int FLOATING_POINT_LITERAL = 71; + int EXPONENT = 72; + int CHARACTER_LITERAL = 73; + int STRING_LITERAL = 74; + int IDENTIFIER = 75; + int LETTER = 76; + int DIGIT = 77; + int LPAREN = 78; + int RPAREN = 79; + int LBRACE = 80; + int RBRACE = 81; + int LBRACKET = 82; + int RBRACKET = 83; + int SEMICOLON = 84; + int COMMA = 85; + int DOT = 86; + int ASSIGN = 87; + int GT = 88; + int LT = 89; + int BANG = 90; + int TILDE = 91; + int HOOK = 92; + int COLON = 93; + int EQ = 94; + int LE = 95; + int GE = 96; + int NE = 97; + int SC_OR = 98; + int SC_AND = 99; + int INCR = 100; + int DECR = 101; + int PLUS = 102; + int MINUS = 103; + int STAR = 104; + int SLASH = 105; + int BIT_AND = 106; + int BIT_OR = 107; + int XOR = 108; + int REM = 109; + int LSHIFT = 110; + int RSIGNEDSHIFT = 111; + int RUNSIGNEDSHIFT = 112; + int PLUSASSIGN = 113; + int MINUSASSIGN = 114; + int STARASSIGN = 115; + int SLASHASSIGN = 116; + int ANDASSIGN = 117; + int ORASSIGN = 118; + int XORASSIGN = 119; + int REMASSIGN = 120; + int LSHIFTASSIGN = 121; + int RSIGNEDSHIFTASSIGN = 122; + int RUNSIGNEDSHIFTASSIGN = 123; + + int DEFAULT = 0; + int IN_SINGLE_LINE_COMMENT = 1; + int IN_FORMAL_COMMENT = 2; + int IN_MULTI_LINE_COMMENT = 3; + + String[] tokenImage = { + "<EOF>", + "\" \"", + "\"\\t\"", + "\"\\n\"", + "\"\\r\"", + "\"\\f\"", + "<token of kind 6>", + "\"//\"", + "\"/*\"", + "<SINGLE_LINE_COMMENT>", + "\"*/\"", + "\"*/\"", + "<token of kind 12>", + "\"abstract\"", + "\"boolean\"", + "\"break\"", + "\"byte\"", + "\"case\"", + "\"catch\"", + "\"char\"", + "\"class\"", + "\"const\"", + "\"continue\"", + "\"default\"", + "\"do\"", + "\"double\"", + "\"else\"", + "\"extends\"", + "\"false\"", + "\"final\"", + "\"finally\"", + "\"float\"", + "\"for\"", + "\"goto\"", + "\"if\"", + "\"implements\"", + "\"import\"", + "\"instanceof\"", + "\"int\"", + "\"interface\"", + "\"long\"", + "\"native\"", + "\"new\"", + "\"null\"", + "\"package\"", + "\"private\"", + "\"protected\"", + "\"public\"", + "\"return\"", + "\"short\"", + "\"static\"", + "\"super\"", + "\"switch\"", + "\"synchronized\"", + "\"this\"", + "\"throw\"", + "\"throws\"", + "\"transient\"", + "\"true\"", + "\"try\"", + "\"void\"", + "\"volatile\"", + "\"while\"", + "\"metaclass\"", + "\"instantiates\"", + "<INTEGER_LITERAL>", + "<LONG_LITERAL>", + "<DECIMAL_LITERAL>", + "<HEX_LITERAL>", + "<OCTAL_LITERAL>", + "<DOUBLE_FLOATING_POINT_LITERAL>", + "<FLOATING_POINT_LITERAL>", + "<EXPONENT>", + "<CHARACTER_LITERAL>", + "<STRING_LITERAL>", + "<IDENTIFIER>", + "<LETTER>", + "<DIGIT>", + "\"(\"", + "\")\"", + "\"{\"", + "\"}\"", + "\"[\"", + "\"]\"", + "\";\"", + "\",\"", + "\".\"", + "\"=\"", + "\">\"", + "\"<\"", + "\"!\"", + "\"~\"", + "\"?\"", + "\":\"", + "\"==\"", + "\"<=\"", + "\">=\"", + "\"!=\"", + "\"||\"", + "\"&&\"", + "\"++\"", + "\"--\"", + "\"+\"", + "\"-\"", + "\"*\"", + "\"/\"", + "\"&\"", + "\"|\"", + "\"^\"", + "\"%\"", + "\"<<\"", + "\">>\"", + "\">>>\"", + "\"+=\"", + "\"-=\"", + "\"*=\"", + "\"/=\"", + "\"&=\"", + "\"|=\"", + "\"^=\"", + "\"%=\"", + "\"<<=\"", + "\">>=\"", + "\">>>=\"", + }; + +} diff --git a/src/main/java/io/devnulllabs/openjava/tools/parser/ParserTokenManager.java b/src/main/java/io/devnulllabs/openjava/tools/parser/ParserTokenManager.java new file mode 100644 index 0000000..648a1b1 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/tools/parser/ParserTokenManager.java @@ -0,0 +1,1820 @@ +/* Generated By:JavaCC: Do not edit this line. ParserTokenManager.java */ +package io.devnulllabs.openjava.tools.parser; + +public class ParserTokenManager implements ParserConstants +{ + public java.io.PrintStream debugStream = System.out; + public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } +private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1) +{ + switch (pos) + { + case 0: + if ((active0 & 0x180L) != 0L || (active1 & 0x10020000000000L) != 0L) + return 2; + if ((active1 & 0x400000L) != 0L) + return 75; + if ((active0 & 0xffffffffffffe000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 75; + return 23; + } + return -1; + case 1: + if ((active0 & 0x100L) != 0L) + return 0; + if ((active0 & 0x403000000L) != 0L) + return 23; + if ((active0 & 0xfffffffbfcffe000L) != 0L || (active1 & 0x1L) != 0L) + { + if (jjmatchedPos != 1) + { + jjmatchedKind = 75; + jjmatchedPos = 1; + } + return 23; + } + return -1; + case 2: + if ((active0 & 0x80004c100000000L) != 0L) + return 23; + if ((active0 & 0xf7fffb3afeffe000L) != 0L || (active1 & 0x1L) != 0L) + { + if (jjmatchedPos != 2) + { + jjmatchedKind = 75; + jjmatchedPos = 2; + } + return 23; + } + return -1; + case 3: + if ((active0 & 0xe3bff2b8faf4e000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 75; + jjmatchedPos = 3; + return 23; + } + if ((active0 & 0x14400902040b0000L) != 0L) + return 23; + return -1; + case 4: + if ((active0 & 0x418a0000f0348000L) != 0L) + return 23; + if ((active0 & 0xa235f2b80ac06000L) != 0L || (active1 & 0x1L) != 0L) + { + if (jjmatchedPos != 4) + { + jjmatchedKind = 75; + jjmatchedPos = 4; + } + return 23; + } + return -1; + case 5: + if ((active0 & 0x115821002000000L) != 0L) + return 23; + if ((active0 & 0xa22070a848c06000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 75; + jjmatchedPos = 5; + return 23; + } + return -1; + case 6: + if ((active0 & 0xa22040a800402000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 75; + jjmatchedPos = 6; + return 23; + } + if ((active0 & 0x300048804000L) != 0L) + return 23; + return -1; + case 7: + if ((active0 & 0x822040a800000000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 75; + jjmatchedPos = 7; + return 23; + } + if ((active0 & 0x2000000000402000L) != 0L) + return 23; + return -1; + case 8: + if ((active0 & 0x8200408000000000L) != 0L) + return 23; + if ((active0 & 0x20002800000000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 75; + jjmatchedPos = 8; + return 23; + } + return -1; + case 9: + if ((active0 & 0x20000000000000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 75; + jjmatchedPos = 9; + return 23; + } + if ((active0 & 0x2800000000L) != 0L) + return 23; + return -1; + case 10: + if ((active0 & 0x20000000000000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 75; + jjmatchedPos = 10; + return 23; + } + return -1; + default : + return -1; + } +} +private final int jjStartNfa_0(int pos, long active0, long active1) +{ + return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1); +} +private final int jjStopAtPos(int pos, int kind) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + return pos + 1; +} +private final int jjStartNfaWithStates_0(int pos, int kind, int state) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return pos + 1; } + return jjMoveNfa_0(state, pos + 1); +} +private final int jjMoveStringLiteralDfa0_0() +{ + switch(curChar) + { + case 33: + jjmatchedKind = 90; + return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000L); + case 37: + jjmatchedKind = 109; + return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000000000L); + case 38: + jjmatchedKind = 106; + return jjMoveStringLiteralDfa1_0(0x0L, 0x20000800000000L); + case 40: + return jjStopAtPos(0, 78); + case 41: + return jjStopAtPos(0, 79); + case 42: + jjmatchedKind = 104; + return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000L); + case 43: + jjmatchedKind = 102; + return jjMoveStringLiteralDfa1_0(0x0L, 0x2001000000000L); + case 44: + return jjStopAtPos(0, 85); + case 45: + jjmatchedKind = 103; + return jjMoveStringLiteralDfa1_0(0x0L, 0x4002000000000L); + case 46: + return jjStartNfaWithStates_0(0, 86, 75); + case 47: + jjmatchedKind = 105; + return jjMoveStringLiteralDfa1_0(0x180L, 0x10000000000000L); + case 58: + return jjStopAtPos(0, 93); + case 59: + return jjStopAtPos(0, 84); + case 60: + jjmatchedKind = 89; + return jjMoveStringLiteralDfa1_0(0x0L, 0x200400080000000L); + case 61: + jjmatchedKind = 87; + return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000L); + case 62: + jjmatchedKind = 88; + return jjMoveStringLiteralDfa1_0(0x0L, 0xc01800100000000L); + case 63: + return jjStopAtPos(0, 92); + case 91: + return jjStopAtPos(0, 82); + case 93: + return jjStopAtPos(0, 83); + case 94: + jjmatchedKind = 108; + return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000000000L); + case 97: + return jjMoveStringLiteralDfa1_0(0x2000L, 0x0L); + case 98: + return jjMoveStringLiteralDfa1_0(0x1c000L, 0x0L); + case 99: + return jjMoveStringLiteralDfa1_0(0x7e0000L, 0x0L); + case 100: + return jjMoveStringLiteralDfa1_0(0x3800000L, 0x0L); + case 101: + return jjMoveStringLiteralDfa1_0(0xc000000L, 0x0L); + case 102: + return jjMoveStringLiteralDfa1_0(0x1f0000000L, 0x0L); + case 103: + return jjMoveStringLiteralDfa1_0(0x200000000L, 0x0L); + case 105: + return jjMoveStringLiteralDfa1_0(0xfc00000000L, 0x1L); + case 108: + return jjMoveStringLiteralDfa1_0(0x10000000000L, 0x0L); + case 109: + return jjMoveStringLiteralDfa1_0(0x8000000000000000L, 0x0L); + case 110: + return jjMoveStringLiteralDfa1_0(0xe0000000000L, 0x0L); + case 112: + return jjMoveStringLiteralDfa1_0(0xf00000000000L, 0x0L); + case 114: + return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L); + case 115: + return jjMoveStringLiteralDfa1_0(0x3e000000000000L, 0x0L); + case 116: + return jjMoveStringLiteralDfa1_0(0xfc0000000000000L, 0x0L); + case 118: + return jjMoveStringLiteralDfa1_0(0x3000000000000000L, 0x0L); + case 119: + return jjMoveStringLiteralDfa1_0(0x4000000000000000L, 0x0L); + case 123: + return jjStopAtPos(0, 80); + case 124: + jjmatchedKind = 107; + return jjMoveStringLiteralDfa1_0(0x0L, 0x40000400000000L); + case 125: + return jjStopAtPos(0, 81); + case 126: + return jjStopAtPos(0, 91); + default : + return jjMoveNfa_0(3, 0); + } +} +private final int jjMoveStringLiteralDfa1_0(long active0, long active1) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(0, active0, active1); + return 1; + } + switch(curChar) + { + case 38: + if ((active1 & 0x800000000L) != 0L) + return jjStopAtPos(1, 99); + break; + case 42: + if ((active0 & 0x100L) != 0L) + return jjStartNfaWithStates_0(1, 8, 0); + break; + case 43: + if ((active1 & 0x1000000000L) != 0L) + return jjStopAtPos(1, 100); + break; + case 45: + if ((active1 & 0x2000000000L) != 0L) + return jjStopAtPos(1, 101); + break; + case 47: + if ((active0 & 0x80L) != 0L) + return jjStopAtPos(1, 7); + break; + case 60: + if ((active1 & 0x400000000000L) != 0L) + { + jjmatchedKind = 110; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x200000000000000L); + case 61: + if ((active1 & 0x40000000L) != 0L) + return jjStopAtPos(1, 94); + else if ((active1 & 0x80000000L) != 0L) + return jjStopAtPos(1, 95); + else if ((active1 & 0x100000000L) != 0L) + return jjStopAtPos(1, 96); + else if ((active1 & 0x200000000L) != 0L) + return jjStopAtPos(1, 97); + else if ((active1 & 0x2000000000000L) != 0L) + return jjStopAtPos(1, 113); + else if ((active1 & 0x4000000000000L) != 0L) + return jjStopAtPos(1, 114); + else if ((active1 & 0x8000000000000L) != 0L) + return jjStopAtPos(1, 115); + else if ((active1 & 0x10000000000000L) != 0L) + return jjStopAtPos(1, 116); + else if ((active1 & 0x20000000000000L) != 0L) + return jjStopAtPos(1, 117); + else if ((active1 & 0x40000000000000L) != 0L) + return jjStopAtPos(1, 118); + else if ((active1 & 0x80000000000000L) != 0L) + return jjStopAtPos(1, 119); + else if ((active1 & 0x100000000000000L) != 0L) + return jjStopAtPos(1, 120); + break; + case 62: + if ((active1 & 0x800000000000L) != 0L) + { + jjmatchedKind = 111; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0xc01000000000000L); + case 97: + return jjMoveStringLiteralDfa2_0(active0, 0x120010060000L, active1, 0L); + case 98: + return jjMoveStringLiteralDfa2_0(active0, 0x2000L, active1, 0L); + case 101: + return jjMoveStringLiteralDfa2_0(active0, 0x8001040000800000L, active1, 0L); + case 102: + if ((active0 & 0x400000000L) != 0L) + return jjStartNfaWithStates_0(1, 34, 23); + break; + case 104: + return jjMoveStringLiteralDfa2_0(active0, 0x41c2000000080000L, active1, 0L); + case 105: + return jjMoveStringLiteralDfa2_0(active0, 0x60000000L, active1, 0L); + case 108: + return jjMoveStringLiteralDfa2_0(active0, 0x84100000L, active1, 0L); + case 109: + return jjMoveStringLiteralDfa2_0(active0, 0x1800000000L, active1, 0L); + case 110: + return jjMoveStringLiteralDfa2_0(active0, 0xe000000000L, active1, 0x1L); + case 111: + if ((active0 & 0x1000000L) != 0L) + { + jjmatchedKind = 24; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0x3000010302604000L, active1, 0L); + case 114: + return jjMoveStringLiteralDfa2_0(active0, 0xe00600000008000L, active1, 0L); + case 116: + return jjMoveStringLiteralDfa2_0(active0, 0x4000000000000L, active1, 0L); + case 117: + return jjMoveStringLiteralDfa2_0(active0, 0x8880000000000L, active1, 0L); + case 119: + return jjMoveStringLiteralDfa2_0(active0, 0x10000000000000L, active1, 0L); + case 120: + return jjMoveStringLiteralDfa2_0(active0, 0x8000000L, active1, 0L); + case 121: + return jjMoveStringLiteralDfa2_0(active0, 0x20000000010000L, active1, 0L); + case 124: + if ((active1 & 0x400000000L) != 0L) + return jjStopAtPos(1, 98); + break; + default : + break; + } + return jjStartNfa_0(0, active0, active1); +} +private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(0, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(1, active0, active1); + return 2; + } + switch(curChar) + { + case 61: + if ((active1 & 0x200000000000000L) != 0L) + return jjStopAtPos(2, 121); + else if ((active1 & 0x400000000000000L) != 0L) + return jjStopAtPos(2, 122); + break; + case 62: + if ((active1 & 0x1000000000000L) != 0L) + { + jjmatchedKind = 112; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x800000000000000L); + case 97: + return jjMoveStringLiteralDfa3_0(active0, 0x204000000180000L, active1, 0L); + case 98: + return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L, active1, 0L); + case 99: + return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L, active1, 0L); + case 101: + return jjMoveStringLiteralDfa3_0(active0, 0x8000L, active1, 0L); + case 102: + return jjMoveStringLiteralDfa3_0(active0, 0x800000L, active1, 0L); + case 105: + return jjMoveStringLiteralDfa3_0(active0, 0x5050200000000000L, active1, 0L); + case 108: + return jjMoveStringLiteralDfa3_0(active0, 0x2000080010000000L, active1, 0L); + case 110: + return jjMoveStringLiteralDfa3_0(active0, 0x20010060600000L, active1, 0L); + case 111: + return jjMoveStringLiteralDfa3_0(active0, 0x2400080004000L, active1, 0L); + case 112: + return jjMoveStringLiteralDfa3_0(active0, 0x8001800000000L, active1, 0L); + case 114: + if ((active0 & 0x100000000L) != 0L) + return jjStartNfaWithStates_0(2, 32, 23); + return jjMoveStringLiteralDfa3_0(active0, 0x180000000000000L, active1, 0L); + case 115: + return jjMoveStringLiteralDfa3_0(active0, 0x2004022000L, active1, 0x1L); + case 116: + if ((active0 & 0x4000000000L) != 0L) + { + jjmatchedKind = 38; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_0(active0, 0x8001028208050000L, active1, 0L); + case 117: + return jjMoveStringLiteralDfa3_0(active0, 0x400000002000000L, active1, 0L); + case 119: + if ((active0 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_0(2, 42, 23); + break; + case 121: + if ((active0 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_0(2, 59, 23); + break; + default : + break; + } + return jjStartNfa_0(1, active0, active1); +} +private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(1, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(2, active0, active1); + return 3; + } + switch(curChar) + { + case 61: + if ((active1 & 0x800000000000000L) != 0L) + return jjStopAtPos(3, 123); + break; + case 97: + return jjMoveStringLiteralDfa4_0(active0, 0xa0000000e0808000L, active1, 0L); + case 98: + return jjMoveStringLiteralDfa4_0(active0, 0x2000000L, active1, 0L); + case 99: + return jjMoveStringLiteralDfa4_0(active0, 0x20000000040000L, active1, 0L); + case 100: + if ((active0 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 60, 23); + break; + case 101: + if ((active0 & 0x10000L) != 0L) + return jjStartNfaWithStates_0(3, 16, 23); + else if ((active0 & 0x20000L) != 0L) + return jjStartNfaWithStates_0(3, 17, 23); + else if ((active0 & 0x4000000L) != 0L) + return jjStartNfaWithStates_0(3, 26, 23); + else if ((active0 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 58, 23); + return jjMoveStringLiteralDfa4_0(active0, 0x8008008000000L, active1, 0L); + case 103: + if ((active0 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_0(3, 40, 23); + break; + case 105: + return jjMoveStringLiteralDfa4_0(active0, 0x20000000000L, active1, 0L); + case 107: + return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L); + case 108: + if ((active0 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(3, 43, 23); + return jjMoveStringLiteralDfa4_0(active0, 0x4000800800004000L, active1, 0L); + case 110: + return jjMoveStringLiteralDfa4_0(active0, 0x200000000000000L, active1, 0L); + case 111: + if ((active0 & 0x200000000L) != 0L) + return jjStartNfaWithStates_0(3, 33, 23); + return jjMoveStringLiteralDfa4_0(active0, 0x180001000000000L, active1, 0L); + case 114: + if ((active0 & 0x80000L) != 0L) + return jjStartNfaWithStates_0(3, 19, 23); + return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0L); + case 115: + if ((active0 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 54, 23); + return jjMoveStringLiteralDfa4_0(active0, 0x10300000L, active1, 0L); + case 116: + return jjMoveStringLiteralDfa4_0(active0, 0x14402000402000L, active1, 0x1L); + case 117: + return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0L); + case 118: + return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0L); + default : + break; + } + return jjStartNfa_0(2, active0, active1); +} +private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(2, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(3, active0, active1); + return 4; + } + switch(curChar) + { + case 97: + return jjMoveStringLiteralDfa5_0(active0, 0x302000000000L, active1, 0x1L); + case 99: + return jjMoveStringLiteralDfa5_0(active0, 0x8010000000000000L, active1, 0L); + case 101: + if ((active0 & 0x10000000L) != 0L) + return jjStartNfaWithStates_0(4, 28, 23); + else if ((active0 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 62, 23); + return jjMoveStringLiteralDfa5_0(active0, 0x400800004000L, active1, 0L); + case 104: + if ((active0 & 0x40000L) != 0L) + return jjStartNfaWithStates_0(4, 18, 23); + return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L, active1, 0L); + case 105: + return jjMoveStringLiteralDfa5_0(active0, 0x4800000400000L, active1, 0L); + case 107: + if ((active0 & 0x8000L) != 0L) + return jjStartNfaWithStates_0(4, 15, 23); + break; + case 108: + if ((active0 & 0x20000000L) != 0L) + { + jjmatchedKind = 29; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_0(active0, 0x42000000L, active1, 0L); + case 110: + return jjMoveStringLiteralDfa5_0(active0, 0x8000000L, active1, 0L); + case 114: + if ((active0 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 51, 23); + return jjMoveStringLiteralDfa5_0(active0, 0x1009000002000L, active1, 0L); + case 115: + if ((active0 & 0x100000L) != 0L) + return jjStartNfaWithStates_0(4, 20, 23); + return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L, active1, 0L); + case 116: + if ((active0 & 0x200000L) != 0L) + return jjStartNfaWithStates_0(4, 21, 23); + else if ((active0 & 0x80000000L) != 0L) + return jjStartNfaWithStates_0(4, 31, 23); + else if ((active0 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 49, 23); + return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000000L, active1, 0L); + case 117: + return jjMoveStringLiteralDfa5_0(active0, 0x800000L, active1, 0L); + case 118: + return jjMoveStringLiteralDfa5_0(active0, 0x20000000000L, active1, 0L); + case 119: + if ((active0 & 0x80000000000000L) != 0L) + { + jjmatchedKind = 55; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L, active1, 0L); + default : + break; + } + return jjStartNfa_0(3, active0, active1); +} +private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(3, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(4, active0, active1); + return 5; + } + switch(curChar) + { + case 97: + return jjMoveStringLiteralDfa6_0(active0, 0x6000L, active1, 0L); + case 99: + if ((active0 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(5, 47, 23); + else if ((active0 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 50, 23); + return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0L); + case 100: + return jjMoveStringLiteralDfa6_0(active0, 0x8000000L, active1, 0L); + case 101: + if ((active0 & 0x2000000L) != 0L) + return jjStartNfaWithStates_0(5, 25, 23); + else if ((active0 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_0(5, 41, 23); + break; + case 102: + return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L, active1, 0L); + case 103: + return jjMoveStringLiteralDfa6_0(active0, 0x100000000000L, active1, 0L); + case 104: + if ((active0 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 52, 23); + break; + case 105: + return jjMoveStringLiteralDfa6_0(active0, 0x2200000000000000L, active1, 0L); + case 108: + return jjMoveStringLiteralDfa6_0(active0, 0x8000000040800000L, active1, 0L); + case 109: + return jjMoveStringLiteralDfa6_0(active0, 0x800000000L, active1, 0L); + case 110: + if ((active0 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 48, 23); + return jjMoveStringLiteralDfa6_0(active0, 0x2000400000L, active1, 0x1L); + case 114: + return jjMoveStringLiteralDfa6_0(active0, 0x20000000000000L, active1, 0L); + case 115: + if ((active0 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 56, 23); + break; + case 116: + if ((active0 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_0(5, 36, 23); + return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L, active1, 0L); + default : + break; + } + return jjStartNfa_0(4, active0, active1); +} +private final int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(4, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(5, active0, active1); + return 6; + } + switch(curChar) + { + case 97: + return jjMoveStringLiteralDfa7_0(active0, 0x8000008000000000L, active1, 0L); + case 99: + return jjMoveStringLiteralDfa7_0(active0, 0x2000002000L, active1, 0L); + case 101: + if ((active0 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_0(6, 44, 23); + else if ((active0 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_0(6, 45, 23); + return jjMoveStringLiteralDfa7_0(active0, 0x200000800000000L, active1, 0L); + case 108: + return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000000L, active1, 0L); + case 110: + if ((active0 & 0x4000L) != 0L) + return jjStartNfaWithStates_0(6, 14, 23); + break; + case 111: + return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L, active1, 0L); + case 115: + if ((active0 & 0x8000000L) != 0L) + return jjStartNfaWithStates_0(6, 27, 23); + break; + case 116: + if ((active0 & 0x800000L) != 0L) + return jjStartNfaWithStates_0(6, 23, 23); + return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L, active1, 0x1L); + case 117: + return jjMoveStringLiteralDfa7_0(active0, 0x400000L, active1, 0L); + case 121: + if ((active0 & 0x40000000L) != 0L) + return jjStartNfaWithStates_0(6, 30, 23); + break; + default : + break; + } + return jjStartNfa_0(5, active0, active1); +} +private final int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(5, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(6, active0, active1); + return 7; + } + switch(curChar) + { + case 99: + return jjMoveStringLiteralDfa8_0(active0, 0x8000000000L, active1, 0L); + case 101: + if ((active0 & 0x400000L) != 0L) + return jjStartNfaWithStates_0(7, 22, 23); + else if ((active0 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 61, 23); + return jjMoveStringLiteralDfa8_0(active0, 0x402000000000L, active1, 0L); + case 105: + return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x1L); + case 110: + return jjMoveStringLiteralDfa8_0(active0, 0x220000800000000L, active1, 0L); + case 115: + return jjMoveStringLiteralDfa8_0(active0, 0x8000000000000000L, active1, 0L); + case 116: + if ((active0 & 0x2000L) != 0L) + return jjStartNfaWithStates_0(7, 13, 23); + break; + default : + break; + } + return jjStartNfa_0(6, active0, active1); +} +private final int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(6, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(7, active0, active1); + return 8; + } + switch(curChar) + { + case 97: + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x1L); + case 100: + if ((active0 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_0(8, 46, 23); + break; + case 101: + if ((active0 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_0(8, 39, 23); + break; + case 105: + return jjMoveStringLiteralDfa9_0(active0, 0x20000000000000L, active1, 0L); + case 111: + return jjMoveStringLiteralDfa9_0(active0, 0x2000000000L, active1, 0L); + case 115: + if ((active0 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 63, 23); + break; + case 116: + if ((active0 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 57, 23); + return jjMoveStringLiteralDfa9_0(active0, 0x800000000L, active1, 0L); + default : + break; + } + return jjStartNfa_0(7, active0, active1); +} +private final int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(7, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(8, active0, active1); + return 9; + } + switch(curChar) + { + case 102: + if ((active0 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_0(9, 37, 23); + break; + case 115: + if ((active0 & 0x800000000L) != 0L) + return jjStartNfaWithStates_0(9, 35, 23); + break; + case 116: + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x1L); + case 122: + return jjMoveStringLiteralDfa10_0(active0, 0x20000000000000L, active1, 0L); + default : + break; + } + return jjStartNfa_0(8, active0, active1); +} +private final int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(8, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(9, active0, active1); + return 10; + } + switch(curChar) + { + case 101: + return jjMoveStringLiteralDfa11_0(active0, 0x20000000000000L, active1, 0x1L); + default : + break; + } + return jjStartNfa_0(9, active0, active1); +} +private final int jjMoveStringLiteralDfa11_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(9, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(10, active0, active1); + return 11; + } + switch(curChar) + { + case 100: + if ((active0 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 53, 23); + break; + case 115: + if ((active1 & 0x1L) != 0L) + return jjStartNfaWithStates_0(11, 64, 23); + break; + default : + break; + } + return jjStartNfa_0(10, active0, active1); +} +private final void jjCheckNAdd(int state) +{ + if (jjrounds[state] != jjround) + { + jjstateSet[jjnewStateCnt++] = state; + jjrounds[state] = jjround; + } +} +private final void jjAddStates(int start, int end) +{ + do { + jjstateSet[jjnewStateCnt++] = jjnextStates[start]; + } while (start++ != end); +} +private final void jjCheckNAddTwoStates(int state1, int state2) +{ + jjCheckNAdd(state1); + jjCheckNAdd(state2); +} +private final void jjCheckNAddStates(int start, int end) +{ + do { + jjCheckNAdd(jjnextStates[start]); + } while (start++ != end); +} +private final void jjCheckNAddStates(int start) +{ + jjCheckNAdd(jjnextStates[start]); + jjCheckNAdd(jjnextStates[start + 1]); +} +static final long[] jjbitVec0 = { + 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL +}; +static final long[] jjbitVec2 = { + 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL +}; +static final long[] jjbitVec3 = { + 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L +}; +static final long[] jjbitVec4 = { + 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL +}; +static final long[] jjbitVec5 = { + 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL +}; +static final long[] jjbitVec6 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L +}; +static final long[] jjbitVec7 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L +}; +static final long[] jjbitVec8 = { + 0x3fffffffffffL, 0x0L, 0x0L, 0x0L +}; +private final int jjMoveNfa_0(int startState, int curPos) +{ + int[] nextStates; + int startsAt = 0; + jjnewStateCnt = 75; + int i = 1; + jjstateSet[0] = startState; + int j, kind = 0x7fffffff; + for (;;) + { + if (++jjround == 0x7fffffff) + ReInitRounds(); + if (curChar < 64) + { + long l = 1L << curChar; + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 75: + if ((0x3ff000000000000L & l) != 0L) + { + if (kind > 71) + kind = 71; + jjCheckNAddStates(0, 2); + } + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(3, 5); + break; + case 3: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(6, 19); + else if (curChar == 46) + jjCheckNAddTwoStates(29, 34); + else if (curChar == 36) + { + if (kind > 75) + kind = 75; + jjCheckNAdd(23); + } + else if (curChar == 34) + jjCheckNAddStates(20, 22); + else if (curChar == 39) + jjAddStates(23, 24); + else if (curChar == 47) + jjstateSet[jjnewStateCnt++] = 2; + if ((0x3fe000000000000L & l) != 0L) + { + if (kind > 65) + kind = 65; + jjCheckNAddStates(25, 27); + } + else if (curChar == 48) + { + if (kind > 65) + kind = 65; + jjCheckNAddStates(28, 32); + } + break; + case 0: + if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 1; + break; + case 1: + if ((0xffff7fffffffffffL & l) != 0L && kind > 6) + kind = 6; + break; + case 2: + if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 0; + break; + case 4: + if (curChar == 39) + jjAddStates(23, 24); + break; + case 5: + if ((0xffffff7fffffdbffL & l) != 0L) + jjCheckNAdd(6); + break; + case 6: + if (curChar == 39 && kind > 73) + kind = 73; + break; + case 8: + if ((0x8400000000L & l) != 0L) + jjCheckNAdd(6); + break; + case 9: + if ((0xff000000000000L & l) != 0L) + jjCheckNAddTwoStates(10, 6); + break; + case 10: + if ((0xff000000000000L & l) != 0L) + jjCheckNAdd(6); + break; + case 11: + if ((0xf000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 12; + break; + case 12: + if ((0xff000000000000L & l) != 0L) + jjCheckNAdd(10); + break; + case 13: + if (curChar == 34) + jjCheckNAddStates(20, 22); + break; + case 14: + if ((0xfffffffbffffdbffL & l) != 0L) + jjCheckNAddStates(20, 22); + break; + case 16: + if ((0x8400000000L & l) != 0L) + jjCheckNAddStates(20, 22); + break; + case 17: + if (curChar == 34 && kind > 74) + kind = 74; + break; + case 18: + if ((0xff000000000000L & l) != 0L) + jjCheckNAddStates(33, 36); + break; + case 19: + if ((0xff000000000000L & l) != 0L) + jjCheckNAddStates(20, 22); + break; + case 20: + if ((0xf000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 21; + break; + case 21: + if ((0xff000000000000L & l) != 0L) + jjCheckNAdd(19); + break; + case 22: + if (curChar != 36) + break; + if (kind > 75) + kind = 75; + jjCheckNAdd(23); + break; + case 23: + if ((0x3ff001000000000L & l) == 0L) + break; + if (kind > 75) + kind = 75; + jjCheckNAdd(23); + break; + case 24: + if ((0x3fe000000000000L & l) == 0L) + break; + if (kind > 65) + kind = 65; + jjCheckNAddStates(25, 27); + break; + case 25: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 65) + kind = 65; + jjCheckNAdd(25); + break; + case 26: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(26, 27); + break; + case 28: + if (curChar == 46) + jjCheckNAddTwoStates(29, 34); + break; + case 29: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(3, 5); + break; + case 31: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(32); + break; + case 32: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(32, 33); + break; + case 34: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 71) + kind = 71; + jjCheckNAddStates(0, 2); + break; + case 36: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(37); + break; + case 37: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 71) + kind = 71; + jjCheckNAddTwoStates(37, 38); + break; + case 39: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(6, 19); + break; + case 40: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(40, 41); + break; + case 41: + if (curChar != 46) + break; + if (kind > 70) + kind = 70; + jjCheckNAddStates(37, 39); + break; + case 42: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 70) + kind = 70; + jjCheckNAddStates(37, 39); + break; + case 44: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(45); + break; + case 45: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 70) + kind = 70; + jjCheckNAddTwoStates(45, 33); + break; + case 46: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(46, 47); + break; + case 48: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(49); + break; + case 49: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(49, 33); + break; + case 50: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(40, 42); + break; + case 52: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(53); + break; + case 53: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(53, 33); + break; + case 54: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(54, 55); + break; + case 55: + if (curChar == 46) + jjCheckNAddStates(43, 45); + break; + case 56: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(43, 45); + break; + case 58: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(59); + break; + case 59: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(59, 38); + break; + case 60: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(60, 61); + break; + case 62: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(63); + break; + case 63: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 71) + kind = 71; + jjCheckNAddTwoStates(63, 38); + break; + case 64: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(46, 48); + break; + case 66: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(67); + break; + case 67: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(67, 38); + break; + case 68: + if (curChar != 48) + break; + if (kind > 65) + kind = 65; + jjCheckNAddStates(28, 32); + break; + case 70: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 65) + kind = 65; + jjstateSet[jjnewStateCnt++] = 70; + break; + case 71: + if ((0xff000000000000L & l) == 0L) + break; + if (kind > 65) + kind = 65; + jjCheckNAdd(71); + break; + case 73: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(73, 27); + break; + case 74: + if ((0xff000000000000L & l) != 0L) + jjCheckNAddTwoStates(74, 27); + break; + default : break; + } + } while(i != startsAt); + } + else if (curChar < 128) + { + long l = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 3: + case 23: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 75) + kind = 75; + jjCheckNAdd(23); + break; + case 1: + if (kind > 6) + kind = 6; + break; + case 5: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAdd(6); + break; + case 7: + if (curChar == 92) + jjAddStates(49, 51); + break; + case 8: + if ((0x14404410000000L & l) != 0L) + jjCheckNAdd(6); + break; + case 14: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAddStates(20, 22); + break; + case 15: + if (curChar == 92) + jjAddStates(52, 54); + break; + case 16: + if ((0x14404410000000L & l) != 0L) + jjCheckNAddStates(20, 22); + break; + case 27: + if ((0x100000001000L & l) != 0L && kind > 66) + kind = 66; + break; + case 30: + if ((0x2000000020L & l) != 0L) + jjAddStates(55, 56); + break; + case 33: + if ((0x1000000010L & l) != 0L && kind > 70) + kind = 70; + break; + case 35: + if ((0x2000000020L & l) != 0L) + jjAddStates(57, 58); + break; + case 38: + if ((0x4000000040L & l) != 0L && kind > 71) + kind = 71; + break; + case 43: + if ((0x2000000020L & l) != 0L) + jjAddStates(59, 60); + break; + case 47: + if ((0x2000000020L & l) != 0L) + jjAddStates(61, 62); + break; + case 51: + if ((0x2000000020L & l) != 0L) + jjAddStates(63, 64); + break; + case 57: + if ((0x2000000020L & l) != 0L) + jjAddStates(65, 66); + break; + case 61: + if ((0x2000000020L & l) != 0L) + jjAddStates(67, 68); + break; + case 65: + if ((0x2000000020L & l) != 0L) + jjAddStates(69, 70); + break; + case 69: + if ((0x100000001000000L & l) != 0L) + jjCheckNAdd(70); + break; + case 70: + if ((0x7e0000007eL & l) == 0L) + break; + if (kind > 65) + kind = 65; + jjCheckNAdd(70); + break; + case 72: + if ((0x100000001000000L & l) != 0L) + jjCheckNAdd(73); + break; + case 73: + if ((0x7e0000007eL & l) != 0L) + jjCheckNAddTwoStates(73, 27); + break; + default : break; + } + } while(i != startsAt); + } + else + { + int hiByte = (int)(curChar >> 8); + int i1 = hiByte >> 6; + long l1 = 1L << (hiByte & 077); + int i2 = (curChar & 0xff) >> 6; + long l2 = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 3: + case 23: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 75) + kind = 75; + jjCheckNAdd(23); + break; + case 1: + if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 6) + kind = 6; + break; + case 5: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjstateSet[jjnewStateCnt++] = 6; + break; + case 14: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(20, 22); + break; + default : break; + } + } while(i != startsAt); + } + if (kind != 0x7fffffff) + { + jjmatchedKind = kind; + jjmatchedPos = curPos; + kind = 0x7fffffff; + } + ++curPos; + if ((i = jjnewStateCnt) == (startsAt = 75 - (jjnewStateCnt = startsAt))) + return curPos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return curPos; } + } +} +private final int jjMoveStringLiteralDfa0_3() +{ + switch(curChar) + { + case 42: + return jjMoveStringLiteralDfa1_3(0x800L); + default : + return 1; + } +} +private final int jjMoveStringLiteralDfa1_3(long active0) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + return 1; + } + switch(curChar) + { + case 47: + if ((active0 & 0x800L) != 0L) + return jjStopAtPos(1, 11); + break; + default : + return 2; + } + return 2; +} +private final int jjMoveStringLiteralDfa0_1() +{ + return jjMoveNfa_1(0, 0); +} +private final int jjMoveNfa_1(int startState, int curPos) +{ + int[] nextStates; + int startsAt = 0; + jjnewStateCnt = 3; + int i = 1; + jjstateSet[0] = startState; + int j, kind = 0x7fffffff; + for (;;) + { + if (++jjround == 0x7fffffff) + ReInitRounds(); + if (curChar < 64) + { + long l = 1L << curChar; + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 0: + if ((0x2400L & l) != 0L) + { + if (kind > 9) + kind = 9; + } + if (curChar == 13) + jjstateSet[jjnewStateCnt++] = 1; + break; + case 1: + if (curChar == 10 && kind > 9) + kind = 9; + break; + case 2: + if (curChar == 13) + jjstateSet[jjnewStateCnt++] = 1; + break; + default : break; + } + } while(i != startsAt); + } + else if (curChar < 128) + { + long l = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + default : break; + } + } while(i != startsAt); + } + else + { + int hiByte = (int)(curChar >> 8); + int i1 = hiByte >> 6; + long l1 = 1L << (hiByte & 077); + int i2 = (curChar & 0xff) >> 6; + long l2 = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + default : break; + } + } while(i != startsAt); + } + if (kind != 0x7fffffff) + { + jjmatchedKind = kind; + jjmatchedPos = curPos; + kind = 0x7fffffff; + } + ++curPos; + if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt))) + return curPos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return curPos; } + } +} +private final int jjMoveStringLiteralDfa0_2() +{ + switch(curChar) + { + case 42: + return jjMoveStringLiteralDfa1_2(0x400L); + default : + return 1; + } +} +private final int jjMoveStringLiteralDfa1_2(long active0) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + return 1; + } + switch(curChar) + { + case 47: + if ((active0 & 0x400L) != 0L) + return jjStopAtPos(1, 10); + break; + default : + return 2; + } + return 2; +} +static final int[] jjnextStates = { + 34, 35, 38, 29, 30, 33, 40, 41, 46, 47, 50, 51, 33, 54, 55, 60, + 61, 64, 65, 38, 14, 15, 17, 5, 7, 25, 26, 27, 69, 71, 72, 74, + 27, 14, 15, 19, 17, 42, 43, 33, 50, 51, 33, 56, 57, 38, 64, 65, + 38, 8, 9, 11, 16, 18, 20, 31, 32, 36, 37, 44, 45, 48, 49, 52, + 53, 58, 59, 62, 63, 66, 67, +}; +private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) +{ + switch(hiByte) + { + case 0: + return ((jjbitVec2[i2] & l2) != 0L); + default : + if ((jjbitVec0[i1] & l1) != 0L) + return true; + return false; + } +} +private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2) +{ + switch(hiByte) + { + case 0: + return ((jjbitVec4[i2] & l2) != 0L); + case 48: + return ((jjbitVec5[i2] & l2) != 0L); + case 49: + return ((jjbitVec6[i2] & l2) != 0L); + case 51: + return ((jjbitVec7[i2] & l2) != 0L); + case 61: + return ((jjbitVec8[i2] & l2) != 0L); + default : + if ((jjbitVec3[i1] & l1) != 0L) + return true; + return false; + } +} +public static final String[] jjstrLiteralImages = { +"", null, null, null, null, null, null, null, null, null, null, null, null, +"\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153", "\142\171\164\145", +"\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163", +"\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", +"\144\157", "\144\157\165\142\154\145", "\145\154\163\145", +"\145\170\164\145\156\144\163", "\146\141\154\163\145", "\146\151\156\141\154", +"\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146", +"\151\155\160\154\145\155\145\156\164\163", "\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", +"\151\156\164", "\151\156\164\145\162\146\141\143\145", "\154\157\156\147", +"\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145", +"\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", +"\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\165\160\145\162", +"\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163", +"\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\141\156\163\151\145\156\164", +"\164\162\165\145", "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145", +"\167\150\151\154\145", "\155\145\164\141\143\154\141\163\163", +"\151\156\163\164\141\156\164\151\141\164\145\163", null, null, null, null, null, null, null, null, null, null, null, null, null, +"\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56", "\75", "\76", +"\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75", "\76\75", "\41\75", +"\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", "\57", "\46", "\174", +"\136", "\45", "\74\74", "\76\76", "\76\76\76", "\53\75", "\55\75", "\52\75", +"\57\75", "\46\75", "\174\75", "\136\75", "\45\75", "\74\74\75", "\76\76\75", +"\76\76\76\75", }; +public static final String[] lexStateNames = { + "DEFAULT", + "IN_SINGLE_LINE_COMMENT", + "IN_FORMAL_COMMENT", + "IN_MULTI_LINE_COMMENT", +}; +public static final int[] jjnewLexState = { + -1, -1, -1, -1, -1, -1, 2, 1, 3, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +}; +static final long[] jjtoToken = { + 0xffffffffffffe001L, 0xfffffffffffcec7L, +}; +static final long[] jjtoSkip = { + 0xe3eL, 0x0L, +}; +static final long[] jjtoSpecial = { + 0xe00L, 0x0L, +}; +static final long[] jjtoMore = { + 0x11c0L, 0x0L, +}; +private JavaCharStream input_stream; +private final int[] jjrounds = new int[75]; +private final int[] jjstateSet = new int[150]; +StringBuffer image; +int jjimageLen; +int lengthOfMatch; +protected char curChar; +public ParserTokenManager(JavaCharStream stream) +{ + if (JavaCharStream.staticFlag) + throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); + input_stream = stream; +} +public ParserTokenManager(JavaCharStream stream, int lexState) +{ + this(stream); + SwitchTo(lexState); +} +public void ReInit(JavaCharStream stream) +{ + jjmatchedPos = jjnewStateCnt = 0; + curLexState = defaultLexState; + input_stream = stream; + ReInitRounds(); +} +private final void ReInitRounds() +{ + int i; + jjround = 0x80000001; + for (i = 75; i-- > 0;) + jjrounds[i] = 0x80000000; +} +public void ReInit(JavaCharStream stream, int lexState) +{ + ReInit(stream); + SwitchTo(lexState); +} +public void SwitchTo(int lexState) +{ + if (lexState >= 4 || lexState < 0) + throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); + else + curLexState = lexState; +} + +private final Token jjFillToken() +{ + Token t = Token.newToken(jjmatchedKind); + t.kind = jjmatchedKind; + String im = jjstrLiteralImages[jjmatchedKind]; + t.image = (im == null) ? input_stream.GetImage() : im; + t.beginLine = input_stream.getBeginLine(); + t.beginColumn = input_stream.getBeginColumn(); + t.endLine = input_stream.getEndLine(); + t.endColumn = input_stream.getEndColumn(); + return t; +} + +int curLexState = 0; +int defaultLexState = 0; +int jjnewStateCnt; +int jjround; +int jjmatchedPos; +int jjmatchedKind; + +public Token getNextToken() +{ + int kind; + Token specialToken = null; + Token matchedToken; + int curPos = 0; + + EOFLoop : + for (;;) + { + try + { + curChar = input_stream.BeginToken(); + } + catch(java.io.IOException e) + { + jjmatchedKind = 0; + matchedToken = jjFillToken(); + matchedToken.specialToken = specialToken; + return matchedToken; + } + image = null; + jjimageLen = 0; + + for (;;) + { + switch(curLexState) + { + case 0: + try { input_stream.backup(0); + while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) + curChar = input_stream.BeginToken(); + } + catch (java.io.IOException e1) { continue EOFLoop; } + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_0(); + break; + case 1: + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_1(); + if (jjmatchedPos == 0 && jjmatchedKind > 12) + { + jjmatchedKind = 12; + } + break; + case 2: + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_2(); + if (jjmatchedPos == 0 && jjmatchedKind > 12) + { + jjmatchedKind = 12; + } + break; + case 3: + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_3(); + if (jjmatchedPos == 0 && jjmatchedKind > 12) + { + jjmatchedKind = 12; + } + break; + } + if (jjmatchedKind != 0x7fffffff) + { + if (jjmatchedPos + 1 < curPos) + input_stream.backup(curPos - jjmatchedPos - 1); + if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + matchedToken = jjFillToken(); + matchedToken.specialToken = specialToken; + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + return matchedToken; + } + else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + matchedToken = jjFillToken(); + if (specialToken == null) + specialToken = matchedToken; + else + { + matchedToken.specialToken = specialToken; + specialToken = (specialToken.next = matchedToken); + } + SkipLexicalActions(matchedToken); + } + else + SkipLexicalActions(null); + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + continue EOFLoop; + } + jjimageLen += jjmatchedPos + 1; + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + curPos = 0; + jjmatchedKind = 0x7fffffff; + try { + curChar = input_stream.readChar(); + continue; + } + catch (java.io.IOException e1) { } + } + int error_line = input_stream.getEndLine(); + int error_column = input_stream.getEndColumn(); + String error_after = null; + boolean EOFSeen = false; + try { input_stream.readChar(); input_stream.backup(1); } + catch (java.io.IOException e1) { + EOFSeen = true; + error_after = curPos <= 1 ? "" : input_stream.GetImage(); + if (curChar == '\n' || curChar == '\r') { + error_line++; + error_column = 0; + } + else + error_column++; + } + if (!EOFSeen) { + input_stream.backup(1); + error_after = curPos <= 1 ? "" : input_stream.GetImage(); + } + throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); + } + } +} + +final void SkipLexicalActions(Token matchedToken) +{ + switch(jjmatchedKind) + { + default : + break; + } +} +} diff --git a/src/main/java/io/devnulllabs/openjava/tools/parser/ParserTokenManager.java.org b/src/main/java/io/devnulllabs/openjava/tools/parser/ParserTokenManager.java.org new file mode 100644 index 0000000..9877b11 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/tools/parser/ParserTokenManager.java.org @@ -0,0 +1,1827 @@ +/* Generated By:JavaCC: Do not edit this line. ParserTokenManager.java */ +package io.devnulllabs.openjava.tools.parser; +import java.io.Reader; +import java.util.Vector; +import java.util.Hashtable; +import java.lang.reflect.Method; +import io.devnulllabs.openjava.mop.*; +import io.devnulllabs.openjava.ptree.*; +import io.devnulllabs.openjava.tools.DebugOut; +import io.devnulllabs.openjava.syntax.SyntaxRule; +import io.devnulllabs.openjava.syntax.TokenSource; + +public class ParserTokenManager implements ParserConstants +{ +private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1) +{ + switch (pos) + { + case 0: + if ((active0 & 0x180L) != 0L || (active1 & 0x10020000000000L) != 0L) + return 2; + if ((active1 & 0x400000L) != 0L) + return 75; + if ((active0 & 0xffffffffffffe000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 75; + return 23; + } + return -1; + case 1: + if ((active0 & 0x100L) != 0L) + return 0; + if ((active0 & 0x403000000L) != 0L) + return 23; + if ((active0 & 0xfffffffbfcffe000L) != 0L || (active1 & 0x1L) != 0L) + { + if (jjmatchedPos != 1) + { + jjmatchedKind = 75; + jjmatchedPos = 1; + } + return 23; + } + return -1; + case 2: + if ((active0 & 0x80004c100000000L) != 0L) + return 23; + if ((active0 & 0xf7fffb3afeffe000L) != 0L || (active1 & 0x1L) != 0L) + { + if (jjmatchedPos != 2) + { + jjmatchedKind = 75; + jjmatchedPos = 2; + } + return 23; + } + return -1; + case 3: + if ((active0 & 0xe3bff2b8faf4e000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 75; + jjmatchedPos = 3; + return 23; + } + if ((active0 & 0x14400902040b0000L) != 0L) + return 23; + return -1; + case 4: + if ((active0 & 0x418a0000f0348000L) != 0L) + return 23; + if ((active0 & 0xa235f2b80ac06000L) != 0L || (active1 & 0x1L) != 0L) + { + if (jjmatchedPos != 4) + { + jjmatchedKind = 75; + jjmatchedPos = 4; + } + return 23; + } + return -1; + case 5: + if ((active0 & 0x115821002000000L) != 0L) + return 23; + if ((active0 & 0xa22070a848c06000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 75; + jjmatchedPos = 5; + return 23; + } + return -1; + case 6: + if ((active0 & 0xa22040a800402000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 75; + jjmatchedPos = 6; + return 23; + } + if ((active0 & 0x300048804000L) != 0L) + return 23; + return -1; + case 7: + if ((active0 & 0x822040a800000000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 75; + jjmatchedPos = 7; + return 23; + } + if ((active0 & 0x2000000000402000L) != 0L) + return 23; + return -1; + case 8: + if ((active0 & 0x8200408000000000L) != 0L) + return 23; + if ((active0 & 0x20002800000000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 75; + jjmatchedPos = 8; + return 23; + } + return -1; + case 9: + if ((active0 & 0x20000000000000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 75; + jjmatchedPos = 9; + return 23; + } + if ((active0 & 0x2800000000L) != 0L) + return 23; + return -1; + case 10: + if ((active0 & 0x20000000000000L) != 0L || (active1 & 0x1L) != 0L) + { + jjmatchedKind = 75; + jjmatchedPos = 10; + return 23; + } + return -1; + default : + return -1; + } +} +private final int jjStartNfa_0(int pos, long active0, long active1) +{ + return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1); +} +private final int jjStopAtPos(int pos, int kind) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + return pos + 1; +} +private final int jjStartNfaWithStates_0(int pos, int kind, int state) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return pos + 1; } + return jjMoveNfa_0(state, pos + 1); +} +private final int jjMoveStringLiteralDfa0_0() +{ + switch(curChar) + { + case 33: + jjmatchedKind = 90; + return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000L); + case 37: + jjmatchedKind = 109; + return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000000000L); + case 38: + jjmatchedKind = 106; + return jjMoveStringLiteralDfa1_0(0x0L, 0x20000800000000L); + case 40: + return jjStopAtPos(0, 78); + case 41: + return jjStopAtPos(0, 79); + case 42: + jjmatchedKind = 104; + return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000L); + case 43: + jjmatchedKind = 102; + return jjMoveStringLiteralDfa1_0(0x0L, 0x2001000000000L); + case 44: + return jjStopAtPos(0, 85); + case 45: + jjmatchedKind = 103; + return jjMoveStringLiteralDfa1_0(0x0L, 0x4002000000000L); + case 46: + return jjStartNfaWithStates_0(0, 86, 75); + case 47: + jjmatchedKind = 105; + return jjMoveStringLiteralDfa1_0(0x180L, 0x10000000000000L); + case 58: + return jjStopAtPos(0, 93); + case 59: + return jjStopAtPos(0, 84); + case 60: + jjmatchedKind = 89; + return jjMoveStringLiteralDfa1_0(0x0L, 0x200400080000000L); + case 61: + jjmatchedKind = 87; + return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000L); + case 62: + jjmatchedKind = 88; + return jjMoveStringLiteralDfa1_0(0x0L, 0xc01800100000000L); + case 63: + return jjStopAtPos(0, 92); + case 91: + return jjStopAtPos(0, 82); + case 93: + return jjStopAtPos(0, 83); + case 94: + jjmatchedKind = 108; + return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000000000L); + case 97: + return jjMoveStringLiteralDfa1_0(0x2000L, 0x0L); + case 98: + return jjMoveStringLiteralDfa1_0(0x1c000L, 0x0L); + case 99: + return jjMoveStringLiteralDfa1_0(0x7e0000L, 0x0L); + case 100: + return jjMoveStringLiteralDfa1_0(0x3800000L, 0x0L); + case 101: + return jjMoveStringLiteralDfa1_0(0xc000000L, 0x0L); + case 102: + return jjMoveStringLiteralDfa1_0(0x1f0000000L, 0x0L); + case 103: + return jjMoveStringLiteralDfa1_0(0x200000000L, 0x0L); + case 105: + return jjMoveStringLiteralDfa1_0(0xfc00000000L, 0x1L); + case 108: + return jjMoveStringLiteralDfa1_0(0x10000000000L, 0x0L); + case 109: + return jjMoveStringLiteralDfa1_0(0x8000000000000000L, 0x0L); + case 110: + return jjMoveStringLiteralDfa1_0(0xe0000000000L, 0x0L); + case 112: + return jjMoveStringLiteralDfa1_0(0xf00000000000L, 0x0L); + case 114: + return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L); + case 115: + return jjMoveStringLiteralDfa1_0(0x3e000000000000L, 0x0L); + case 116: + return jjMoveStringLiteralDfa1_0(0xfc0000000000000L, 0x0L); + case 118: + return jjMoveStringLiteralDfa1_0(0x3000000000000000L, 0x0L); + case 119: + return jjMoveStringLiteralDfa1_0(0x4000000000000000L, 0x0L); + case 123: + return jjStopAtPos(0, 80); + case 124: + jjmatchedKind = 107; + return jjMoveStringLiteralDfa1_0(0x0L, 0x40000400000000L); + case 125: + return jjStopAtPos(0, 81); + case 126: + return jjStopAtPos(0, 91); + default : + return jjMoveNfa_0(3, 0); + } +} +private final int jjMoveStringLiteralDfa1_0(long active0, long active1) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(0, active0, active1); + return 1; + } + switch(curChar) + { + case 38: + if ((active1 & 0x800000000L) != 0L) + return jjStopAtPos(1, 99); + break; + case 42: + if ((active0 & 0x100L) != 0L) + return jjStartNfaWithStates_0(1, 8, 0); + break; + case 43: + if ((active1 & 0x1000000000L) != 0L) + return jjStopAtPos(1, 100); + break; + case 45: + if ((active1 & 0x2000000000L) != 0L) + return jjStopAtPos(1, 101); + break; + case 47: + if ((active0 & 0x80L) != 0L) + return jjStopAtPos(1, 7); + break; + case 60: + if ((active1 & 0x400000000000L) != 0L) + { + jjmatchedKind = 110; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x200000000000000L); + case 61: + if ((active1 & 0x40000000L) != 0L) + return jjStopAtPos(1, 94); + else if ((active1 & 0x80000000L) != 0L) + return jjStopAtPos(1, 95); + else if ((active1 & 0x100000000L) != 0L) + return jjStopAtPos(1, 96); + else if ((active1 & 0x200000000L) != 0L) + return jjStopAtPos(1, 97); + else if ((active1 & 0x2000000000000L) != 0L) + return jjStopAtPos(1, 113); + else if ((active1 & 0x4000000000000L) != 0L) + return jjStopAtPos(1, 114); + else if ((active1 & 0x8000000000000L) != 0L) + return jjStopAtPos(1, 115); + else if ((active1 & 0x10000000000000L) != 0L) + return jjStopAtPos(1, 116); + else if ((active1 & 0x20000000000000L) != 0L) + return jjStopAtPos(1, 117); + else if ((active1 & 0x40000000000000L) != 0L) + return jjStopAtPos(1, 118); + else if ((active1 & 0x80000000000000L) != 0L) + return jjStopAtPos(1, 119); + else if ((active1 & 0x100000000000000L) != 0L) + return jjStopAtPos(1, 120); + break; + case 62: + if ((active1 & 0x800000000000L) != 0L) + { + jjmatchedKind = 111; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0xc01000000000000L); + case 97: + return jjMoveStringLiteralDfa2_0(active0, 0x120010060000L, active1, 0L); + case 98: + return jjMoveStringLiteralDfa2_0(active0, 0x2000L, active1, 0L); + case 101: + return jjMoveStringLiteralDfa2_0(active0, 0x8001040000800000L, active1, 0L); + case 102: + if ((active0 & 0x400000000L) != 0L) + return jjStartNfaWithStates_0(1, 34, 23); + break; + case 104: + return jjMoveStringLiteralDfa2_0(active0, 0x41c2000000080000L, active1, 0L); + case 105: + return jjMoveStringLiteralDfa2_0(active0, 0x60000000L, active1, 0L); + case 108: + return jjMoveStringLiteralDfa2_0(active0, 0x84100000L, active1, 0L); + case 109: + return jjMoveStringLiteralDfa2_0(active0, 0x1800000000L, active1, 0L); + case 110: + return jjMoveStringLiteralDfa2_0(active0, 0xe000000000L, active1, 0x1L); + case 111: + if ((active0 & 0x1000000L) != 0L) + { + jjmatchedKind = 24; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0x3000010302604000L, active1, 0L); + case 114: + return jjMoveStringLiteralDfa2_0(active0, 0xe00600000008000L, active1, 0L); + case 116: + return jjMoveStringLiteralDfa2_0(active0, 0x4000000000000L, active1, 0L); + case 117: + return jjMoveStringLiteralDfa2_0(active0, 0x8880000000000L, active1, 0L); + case 119: + return jjMoveStringLiteralDfa2_0(active0, 0x10000000000000L, active1, 0L); + case 120: + return jjMoveStringLiteralDfa2_0(active0, 0x8000000L, active1, 0L); + case 121: + return jjMoveStringLiteralDfa2_0(active0, 0x20000000010000L, active1, 0L); + case 124: + if ((active1 & 0x400000000L) != 0L) + return jjStopAtPos(1, 98); + break; + default : + break; + } + return jjStartNfa_0(0, active0, active1); +} +private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(0, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(1, active0, active1); + return 2; + } + switch(curChar) + { + case 61: + if ((active1 & 0x200000000000000L) != 0L) + return jjStopAtPos(2, 121); + else if ((active1 & 0x400000000000000L) != 0L) + return jjStopAtPos(2, 122); + break; + case 62: + if ((active1 & 0x1000000000000L) != 0L) + { + jjmatchedKind = 112; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x800000000000000L); + case 97: + return jjMoveStringLiteralDfa3_0(active0, 0x204000000180000L, active1, 0L); + case 98: + return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L, active1, 0L); + case 99: + return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L, active1, 0L); + case 101: + return jjMoveStringLiteralDfa3_0(active0, 0x8000L, active1, 0L); + case 102: + return jjMoveStringLiteralDfa3_0(active0, 0x800000L, active1, 0L); + case 105: + return jjMoveStringLiteralDfa3_0(active0, 0x5050200000000000L, active1, 0L); + case 108: + return jjMoveStringLiteralDfa3_0(active0, 0x2000080010000000L, active1, 0L); + case 110: + return jjMoveStringLiteralDfa3_0(active0, 0x20010060600000L, active1, 0L); + case 111: + return jjMoveStringLiteralDfa3_0(active0, 0x2400080004000L, active1, 0L); + case 112: + return jjMoveStringLiteralDfa3_0(active0, 0x8001800000000L, active1, 0L); + case 114: + if ((active0 & 0x100000000L) != 0L) + return jjStartNfaWithStates_0(2, 32, 23); + return jjMoveStringLiteralDfa3_0(active0, 0x180000000000000L, active1, 0L); + case 115: + return jjMoveStringLiteralDfa3_0(active0, 0x2004022000L, active1, 0x1L); + case 116: + if ((active0 & 0x4000000000L) != 0L) + { + jjmatchedKind = 38; + jjmatchedPos = 2; + } + return jjMoveStringLiteralDfa3_0(active0, 0x8001028208050000L, active1, 0L); + case 117: + return jjMoveStringLiteralDfa3_0(active0, 0x400000002000000L, active1, 0L); + case 119: + if ((active0 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_0(2, 42, 23); + break; + case 121: + if ((active0 & 0x800000000000000L) != 0L) + return jjStartNfaWithStates_0(2, 59, 23); + break; + default : + break; + } + return jjStartNfa_0(1, active0, active1); +} +private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(1, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(2, active0, active1); + return 3; + } + switch(curChar) + { + case 61: + if ((active1 & 0x800000000000000L) != 0L) + return jjStopAtPos(3, 123); + break; + case 97: + return jjMoveStringLiteralDfa4_0(active0, 0xa0000000e0808000L, active1, 0L); + case 98: + return jjMoveStringLiteralDfa4_0(active0, 0x2000000L, active1, 0L); + case 99: + return jjMoveStringLiteralDfa4_0(active0, 0x20000000040000L, active1, 0L); + case 100: + if ((active0 & 0x1000000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 60, 23); + break; + case 101: + if ((active0 & 0x10000L) != 0L) + return jjStartNfaWithStates_0(3, 16, 23); + else if ((active0 & 0x20000L) != 0L) + return jjStartNfaWithStates_0(3, 17, 23); + else if ((active0 & 0x4000000L) != 0L) + return jjStartNfaWithStates_0(3, 26, 23); + else if ((active0 & 0x400000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 58, 23); + return jjMoveStringLiteralDfa4_0(active0, 0x8008008000000L, active1, 0L); + case 103: + if ((active0 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_0(3, 40, 23); + break; + case 105: + return jjMoveStringLiteralDfa4_0(active0, 0x20000000000L, active1, 0L); + case 107: + return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L); + case 108: + if ((active0 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(3, 43, 23); + return jjMoveStringLiteralDfa4_0(active0, 0x4000800800004000L, active1, 0L); + case 110: + return jjMoveStringLiteralDfa4_0(active0, 0x200000000000000L, active1, 0L); + case 111: + if ((active0 & 0x200000000L) != 0L) + return jjStartNfaWithStates_0(3, 33, 23); + return jjMoveStringLiteralDfa4_0(active0, 0x180001000000000L, active1, 0L); + case 114: + if ((active0 & 0x80000L) != 0L) + return jjStartNfaWithStates_0(3, 19, 23); + return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0L); + case 115: + if ((active0 & 0x40000000000000L) != 0L) + return jjStartNfaWithStates_0(3, 54, 23); + return jjMoveStringLiteralDfa4_0(active0, 0x10300000L, active1, 0L); + case 116: + return jjMoveStringLiteralDfa4_0(active0, 0x14402000402000L, active1, 0x1L); + case 117: + return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0L); + case 118: + return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0L); + default : + break; + } + return jjStartNfa_0(2, active0, active1); +} +private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(2, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(3, active0, active1); + return 4; + } + switch(curChar) + { + case 97: + return jjMoveStringLiteralDfa5_0(active0, 0x302000000000L, active1, 0x1L); + case 99: + return jjMoveStringLiteralDfa5_0(active0, 0x8010000000000000L, active1, 0L); + case 101: + if ((active0 & 0x10000000L) != 0L) + return jjStartNfaWithStates_0(4, 28, 23); + else if ((active0 & 0x4000000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 62, 23); + return jjMoveStringLiteralDfa5_0(active0, 0x400800004000L, active1, 0L); + case 104: + if ((active0 & 0x40000L) != 0L) + return jjStartNfaWithStates_0(4, 18, 23); + return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L, active1, 0L); + case 105: + return jjMoveStringLiteralDfa5_0(active0, 0x4800000400000L, active1, 0L); + case 107: + if ((active0 & 0x8000L) != 0L) + return jjStartNfaWithStates_0(4, 15, 23); + break; + case 108: + if ((active0 & 0x20000000L) != 0L) + { + jjmatchedKind = 29; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_0(active0, 0x42000000L, active1, 0L); + case 110: + return jjMoveStringLiteralDfa5_0(active0, 0x8000000L, active1, 0L); + case 114: + if ((active0 & 0x8000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 51, 23); + return jjMoveStringLiteralDfa5_0(active0, 0x1009000002000L, active1, 0L); + case 115: + if ((active0 & 0x100000L) != 0L) + return jjStartNfaWithStates_0(4, 20, 23); + return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L, active1, 0L); + case 116: + if ((active0 & 0x200000L) != 0L) + return jjStartNfaWithStates_0(4, 21, 23); + else if ((active0 & 0x80000000L) != 0L) + return jjStartNfaWithStates_0(4, 31, 23); + else if ((active0 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_0(4, 49, 23); + return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000000L, active1, 0L); + case 117: + return jjMoveStringLiteralDfa5_0(active0, 0x800000L, active1, 0L); + case 118: + return jjMoveStringLiteralDfa5_0(active0, 0x20000000000L, active1, 0L); + case 119: + if ((active0 & 0x80000000000000L) != 0L) + { + jjmatchedKind = 55; + jjmatchedPos = 4; + } + return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L, active1, 0L); + default : + break; + } + return jjStartNfa_0(3, active0, active1); +} +private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(3, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(4, active0, active1); + return 5; + } + switch(curChar) + { + case 97: + return jjMoveStringLiteralDfa6_0(active0, 0x6000L, active1, 0L); + case 99: + if ((active0 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(5, 47, 23); + else if ((active0 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 50, 23); + return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0L); + case 100: + return jjMoveStringLiteralDfa6_0(active0, 0x8000000L, active1, 0L); + case 101: + if ((active0 & 0x2000000L) != 0L) + return jjStartNfaWithStates_0(5, 25, 23); + else if ((active0 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_0(5, 41, 23); + break; + case 102: + return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L, active1, 0L); + case 103: + return jjMoveStringLiteralDfa6_0(active0, 0x100000000000L, active1, 0L); + case 104: + if ((active0 & 0x10000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 52, 23); + break; + case 105: + return jjMoveStringLiteralDfa6_0(active0, 0x2200000000000000L, active1, 0L); + case 108: + return jjMoveStringLiteralDfa6_0(active0, 0x8000000040800000L, active1, 0L); + case 109: + return jjMoveStringLiteralDfa6_0(active0, 0x800000000L, active1, 0L); + case 110: + if ((active0 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 48, 23); + return jjMoveStringLiteralDfa6_0(active0, 0x2000400000L, active1, 0x1L); + case 114: + return jjMoveStringLiteralDfa6_0(active0, 0x20000000000000L, active1, 0L); + case 115: + if ((active0 & 0x100000000000000L) != 0L) + return jjStartNfaWithStates_0(5, 56, 23); + break; + case 116: + if ((active0 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_0(5, 36, 23); + return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L, active1, 0L); + default : + break; + } + return jjStartNfa_0(4, active0, active1); +} +private final int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(4, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(5, active0, active1); + return 6; + } + switch(curChar) + { + case 97: + return jjMoveStringLiteralDfa7_0(active0, 0x8000008000000000L, active1, 0L); + case 99: + return jjMoveStringLiteralDfa7_0(active0, 0x2000002000L, active1, 0L); + case 101: + if ((active0 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_0(6, 44, 23); + else if ((active0 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_0(6, 45, 23); + return jjMoveStringLiteralDfa7_0(active0, 0x200000800000000L, active1, 0L); + case 108: + return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000000L, active1, 0L); + case 110: + if ((active0 & 0x4000L) != 0L) + return jjStartNfaWithStates_0(6, 14, 23); + break; + case 111: + return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L, active1, 0L); + case 115: + if ((active0 & 0x8000000L) != 0L) + return jjStartNfaWithStates_0(6, 27, 23); + break; + case 116: + if ((active0 & 0x800000L) != 0L) + return jjStartNfaWithStates_0(6, 23, 23); + return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L, active1, 0x1L); + case 117: + return jjMoveStringLiteralDfa7_0(active0, 0x400000L, active1, 0L); + case 121: + if ((active0 & 0x40000000L) != 0L) + return jjStartNfaWithStates_0(6, 30, 23); + break; + default : + break; + } + return jjStartNfa_0(5, active0, active1); +} +private final int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(5, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(6, active0, active1); + return 7; + } + switch(curChar) + { + case 99: + return jjMoveStringLiteralDfa8_0(active0, 0x8000000000L, active1, 0L); + case 101: + if ((active0 & 0x400000L) != 0L) + return jjStartNfaWithStates_0(7, 22, 23); + else if ((active0 & 0x2000000000000000L) != 0L) + return jjStartNfaWithStates_0(7, 61, 23); + return jjMoveStringLiteralDfa8_0(active0, 0x402000000000L, active1, 0L); + case 105: + return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x1L); + case 110: + return jjMoveStringLiteralDfa8_0(active0, 0x220000800000000L, active1, 0L); + case 115: + return jjMoveStringLiteralDfa8_0(active0, 0x8000000000000000L, active1, 0L); + case 116: + if ((active0 & 0x2000L) != 0L) + return jjStartNfaWithStates_0(7, 13, 23); + break; + default : + break; + } + return jjStartNfa_0(6, active0, active1); +} +private final int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(6, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(7, active0, active1); + return 8; + } + switch(curChar) + { + case 97: + return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x1L); + case 100: + if ((active0 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_0(8, 46, 23); + break; + case 101: + if ((active0 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_0(8, 39, 23); + break; + case 105: + return jjMoveStringLiteralDfa9_0(active0, 0x20000000000000L, active1, 0L); + case 111: + return jjMoveStringLiteralDfa9_0(active0, 0x2000000000L, active1, 0L); + case 115: + if ((active0 & 0x8000000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 63, 23); + break; + case 116: + if ((active0 & 0x200000000000000L) != 0L) + return jjStartNfaWithStates_0(8, 57, 23); + return jjMoveStringLiteralDfa9_0(active0, 0x800000000L, active1, 0L); + default : + break; + } + return jjStartNfa_0(7, active0, active1); +} +private final int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(7, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(8, active0, active1); + return 9; + } + switch(curChar) + { + case 102: + if ((active0 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_0(9, 37, 23); + break; + case 115: + if ((active0 & 0x800000000L) != 0L) + return jjStartNfaWithStates_0(9, 35, 23); + break; + case 116: + return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x1L); + case 122: + return jjMoveStringLiteralDfa10_0(active0, 0x20000000000000L, active1, 0L); + default : + break; + } + return jjStartNfa_0(8, active0, active1); +} +private final int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(8, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(9, active0, active1); + return 10; + } + switch(curChar) + { + case 101: + return jjMoveStringLiteralDfa11_0(active0, 0x20000000000000L, active1, 0x1L); + default : + break; + } + return jjStartNfa_0(9, active0, active1); +} +private final int jjMoveStringLiteralDfa11_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(9, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(10, active0, active1); + return 11; + } + switch(curChar) + { + case 100: + if ((active0 & 0x20000000000000L) != 0L) + return jjStartNfaWithStates_0(11, 53, 23); + break; + case 115: + if ((active1 & 0x1L) != 0L) + return jjStartNfaWithStates_0(11, 64, 23); + break; + default : + break; + } + return jjStartNfa_0(10, active0, active1); +} +private final void jjCheckNAdd(int state) +{ + if (jjrounds[state] != jjround) + { + jjstateSet[jjnewStateCnt++] = state; + jjrounds[state] = jjround; + } +} +private final void jjAddStates(int start, int end) +{ + do { + jjstateSet[jjnewStateCnt++] = jjnextStates[start]; + } while (start++ != end); +} +private final void jjCheckNAddTwoStates(int state1, int state2) +{ + jjCheckNAdd(state1); + jjCheckNAdd(state2); +} +private final void jjCheckNAddStates(int start, int end) +{ + do { + jjCheckNAdd(jjnextStates[start]); + } while (start++ != end); +} +private final void jjCheckNAddStates(int start) +{ + jjCheckNAdd(jjnextStates[start]); + jjCheckNAdd(jjnextStates[start + 1]); +} +static final long[] jjbitVec0 = { + 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL +}; +static final long[] jjbitVec2 = { + 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL +}; +static final long[] jjbitVec3 = { + 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L +}; +static final long[] jjbitVec4 = { + 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL +}; +static final long[] jjbitVec5 = { + 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL +}; +static final long[] jjbitVec6 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L +}; +static final long[] jjbitVec7 = { + 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L +}; +static final long[] jjbitVec8 = { + 0x3fffffffffffL, 0x0L, 0x0L, 0x0L +}; +private final int jjMoveNfa_0(int startState, int curPos) +{ + int[] nextStates; + int startsAt = 0; + jjnewStateCnt = 75; + int i = 1; + jjstateSet[0] = startState; + int j, kind = 0x7fffffff; + for (;;) + { + if (++jjround == 0x7fffffff) + ReInitRounds(); + if (curChar < 64) + { + long l = 1L << curChar; + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 75: + if ((0x3ff000000000000L & l) != 0L) + { + if (kind > 71) + kind = 71; + jjCheckNAddStates(0, 2); + } + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(3, 5); + break; + case 3: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(6, 19); + else if (curChar == 46) + jjCheckNAddTwoStates(29, 34); + else if (curChar == 36) + { + if (kind > 75) + kind = 75; + jjCheckNAdd(23); + } + else if (curChar == 34) + jjCheckNAddStates(20, 22); + else if (curChar == 39) + jjAddStates(23, 24); + else if (curChar == 47) + jjstateSet[jjnewStateCnt++] = 2; + if ((0x3fe000000000000L & l) != 0L) + { + if (kind > 65) + kind = 65; + jjCheckNAddStates(25, 27); + } + else if (curChar == 48) + { + if (kind > 65) + kind = 65; + jjCheckNAddStates(28, 32); + } + break; + case 0: + if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 1; + break; + case 1: + if ((0xffff7fffffffffffL & l) != 0L && kind > 6) + kind = 6; + break; + case 2: + if (curChar == 42) + jjstateSet[jjnewStateCnt++] = 0; + break; + case 4: + if (curChar == 39) + jjAddStates(23, 24); + break; + case 5: + if ((0xffffff7fffffdbffL & l) != 0L) + jjCheckNAdd(6); + break; + case 6: + if (curChar == 39 && kind > 73) + kind = 73; + break; + case 8: + if ((0x8400000000L & l) != 0L) + jjCheckNAdd(6); + break; + case 9: + if ((0xff000000000000L & l) != 0L) + jjCheckNAddTwoStates(10, 6); + break; + case 10: + if ((0xff000000000000L & l) != 0L) + jjCheckNAdd(6); + break; + case 11: + if ((0xf000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 12; + break; + case 12: + if ((0xff000000000000L & l) != 0L) + jjCheckNAdd(10); + break; + case 13: + if (curChar == 34) + jjCheckNAddStates(20, 22); + break; + case 14: + if ((0xfffffffbffffdbffL & l) != 0L) + jjCheckNAddStates(20, 22); + break; + case 16: + if ((0x8400000000L & l) != 0L) + jjCheckNAddStates(20, 22); + break; + case 17: + if (curChar == 34 && kind > 74) + kind = 74; + break; + case 18: + if ((0xff000000000000L & l) != 0L) + jjCheckNAddStates(33, 36); + break; + case 19: + if ((0xff000000000000L & l) != 0L) + jjCheckNAddStates(20, 22); + break; + case 20: + if ((0xf000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 21; + break; + case 21: + if ((0xff000000000000L & l) != 0L) + jjCheckNAdd(19); + break; + case 22: + if (curChar != 36) + break; + if (kind > 75) + kind = 75; + jjCheckNAdd(23); + break; + case 23: + if ((0x3ff001000000000L & l) == 0L) + break; + if (kind > 75) + kind = 75; + jjCheckNAdd(23); + break; + case 24: + if ((0x3fe000000000000L & l) == 0L) + break; + if (kind > 65) + kind = 65; + jjCheckNAddStates(25, 27); + break; + case 25: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 65) + kind = 65; + jjCheckNAdd(25); + break; + case 26: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(26, 27); + break; + case 28: + if (curChar == 46) + jjCheckNAddTwoStates(29, 34); + break; + case 29: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(3, 5); + break; + case 31: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(32); + break; + case 32: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(32, 33); + break; + case 34: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 71) + kind = 71; + jjCheckNAddStates(0, 2); + break; + case 36: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(37); + break; + case 37: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 71) + kind = 71; + jjCheckNAddTwoStates(37, 38); + break; + case 39: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(6, 19); + break; + case 40: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(40, 41); + break; + case 41: + if (curChar != 46) + break; + if (kind > 70) + kind = 70; + jjCheckNAddStates(37, 39); + break; + case 42: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 70) + kind = 70; + jjCheckNAddStates(37, 39); + break; + case 44: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(45); + break; + case 45: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 70) + kind = 70; + jjCheckNAddTwoStates(45, 33); + break; + case 46: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(46, 47); + break; + case 48: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(49); + break; + case 49: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(49, 33); + break; + case 50: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(40, 42); + break; + case 52: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(53); + break; + case 53: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(53, 33); + break; + case 54: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(54, 55); + break; + case 55: + if (curChar == 46) + jjCheckNAddStates(43, 45); + break; + case 56: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(43, 45); + break; + case 58: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(59); + break; + case 59: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(59, 38); + break; + case 60: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(60, 61); + break; + case 62: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(63); + break; + case 63: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 71) + kind = 71; + jjCheckNAddTwoStates(63, 38); + break; + case 64: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(46, 48); + break; + case 66: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(67); + break; + case 67: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(67, 38); + break; + case 68: + if (curChar != 48) + break; + if (kind > 65) + kind = 65; + jjCheckNAddStates(28, 32); + break; + case 70: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 65) + kind = 65; + jjstateSet[jjnewStateCnt++] = 70; + break; + case 71: + if ((0xff000000000000L & l) == 0L) + break; + if (kind > 65) + kind = 65; + jjCheckNAdd(71); + break; + case 73: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(73, 27); + break; + case 74: + if ((0xff000000000000L & l) != 0L) + jjCheckNAddTwoStates(74, 27); + break; + default : break; + } + } while(i != startsAt); + } + else if (curChar < 128) + { + long l = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 3: + case 23: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 75) + kind = 75; + jjCheckNAdd(23); + break; + case 1: + if (kind > 6) + kind = 6; + break; + case 5: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAdd(6); + break; + case 7: + if (curChar == 92) + jjAddStates(49, 51); + break; + case 8: + if ((0x14404410000000L & l) != 0L) + jjCheckNAdd(6); + break; + case 14: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAddStates(20, 22); + break; + case 15: + if (curChar == 92) + jjAddStates(52, 54); + break; + case 16: + if ((0x14404410000000L & l) != 0L) + jjCheckNAddStates(20, 22); + break; + case 27: + if ((0x100000001000L & l) != 0L && kind > 66) + kind = 66; + break; + case 30: + if ((0x2000000020L & l) != 0L) + jjAddStates(55, 56); + break; + case 33: + if ((0x1000000010L & l) != 0L && kind > 70) + kind = 70; + break; + case 35: + if ((0x2000000020L & l) != 0L) + jjAddStates(57, 58); + break; + case 38: + if ((0x4000000040L & l) != 0L && kind > 71) + kind = 71; + break; + case 43: + if ((0x2000000020L & l) != 0L) + jjAddStates(59, 60); + break; + case 47: + if ((0x2000000020L & l) != 0L) + jjAddStates(61, 62); + break; + case 51: + if ((0x2000000020L & l) != 0L) + jjAddStates(63, 64); + break; + case 57: + if ((0x2000000020L & l) != 0L) + jjAddStates(65, 66); + break; + case 61: + if ((0x2000000020L & l) != 0L) + jjAddStates(67, 68); + break; + case 65: + if ((0x2000000020L & l) != 0L) + jjAddStates(69, 70); + break; + case 69: + if ((0x100000001000000L & l) != 0L) + jjCheckNAdd(70); + break; + case 70: + if ((0x7e0000007eL & l) == 0L) + break; + if (kind > 65) + kind = 65; + jjCheckNAdd(70); + break; + case 72: + if ((0x100000001000000L & l) != 0L) + jjCheckNAdd(73); + break; + case 73: + if ((0x7e0000007eL & l) != 0L) + jjCheckNAddTwoStates(73, 27); + break; + default : break; + } + } while(i != startsAt); + } + else + { + int hiByte = (int)(curChar >> 8); + int i1 = hiByte >> 6; + long l1 = 1L << (hiByte & 077); + int i2 = (curChar & 0xff) >> 6; + long l2 = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 3: + case 23: + if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) + break; + if (kind > 75) + kind = 75; + jjCheckNAdd(23); + break; + case 1: + if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 6) + kind = 6; + break; + case 5: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjstateSet[jjnewStateCnt++] = 6; + break; + case 14: + if (jjCanMove_0(hiByte, i1, i2, l1, l2)) + jjAddStates(20, 22); + break; + default : break; + } + } while(i != startsAt); + } + if (kind != 0x7fffffff) + { + jjmatchedKind = kind; + jjmatchedPos = curPos; + kind = 0x7fffffff; + } + ++curPos; + if ((i = jjnewStateCnt) == (startsAt = 75 - (jjnewStateCnt = startsAt))) + return curPos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return curPos; } + } +} +private final int jjMoveStringLiteralDfa0_3() +{ + switch(curChar) + { + case 42: + return jjMoveStringLiteralDfa1_3(0x800L); + default : + return 1; + } +} +private final int jjMoveStringLiteralDfa1_3(long active0) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + return 1; + } + switch(curChar) + { + case 47: + if ((active0 & 0x800L) != 0L) + return jjStopAtPos(1, 11); + break; + default : + return 2; + } + return 2; +} +private final int jjMoveStringLiteralDfa0_1() +{ + return jjMoveNfa_1(0, 0); +} +private final int jjMoveNfa_1(int startState, int curPos) +{ + int[] nextStates; + int startsAt = 0; + jjnewStateCnt = 3; + int i = 1; + jjstateSet[0] = startState; + int j, kind = 0x7fffffff; + for (;;) + { + if (++jjround == 0x7fffffff) + ReInitRounds(); + if (curChar < 64) + { + long l = 1L << curChar; + MatchLoop: do + { + switch(jjstateSet[--i]) + { + case 0: + if ((0x2400L & l) != 0L) + { + if (kind > 9) + kind = 9; + } + if (curChar == 13) + jjstateSet[jjnewStateCnt++] = 1; + break; + case 1: + if (curChar == 10 && kind > 9) + kind = 9; + break; + case 2: + if (curChar == 13) + jjstateSet[jjnewStateCnt++] = 1; + break; + default : break; + } + } while(i != startsAt); + } + else if (curChar < 128) + { + long l = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + default : break; + } + } while(i != startsAt); + } + else + { + int hiByte = (int)(curChar >> 8); + int i1 = hiByte >> 6; + long l1 = 1L << (hiByte & 077); + int i2 = (curChar & 0xff) >> 6; + long l2 = 1L << (curChar & 077); + MatchLoop: do + { + switch(jjstateSet[--i]) + { + default : break; + } + } while(i != startsAt); + } + if (kind != 0x7fffffff) + { + jjmatchedKind = kind; + jjmatchedPos = curPos; + kind = 0x7fffffff; + } + ++curPos; + if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt))) + return curPos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return curPos; } + } +} +private final int jjMoveStringLiteralDfa0_2() +{ + switch(curChar) + { + case 42: + return jjMoveStringLiteralDfa1_2(0x400L); + default : + return 1; + } +} +private final int jjMoveStringLiteralDfa1_2(long active0) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + return 1; + } + switch(curChar) + { + case 47: + if ((active0 & 0x400L) != 0L) + return jjStopAtPos(1, 10); + break; + default : + return 2; + } + return 2; +} +static final int[] jjnextStates = { + 34, 35, 38, 29, 30, 33, 40, 41, 46, 47, 50, 51, 33, 54, 55, 60, + 61, 64, 65, 38, 14, 15, 17, 5, 7, 25, 26, 27, 69, 71, 72, 74, + 27, 14, 15, 19, 17, 42, 43, 33, 50, 51, 33, 56, 57, 38, 64, 65, + 38, 8, 9, 11, 16, 18, 20, 31, 32, 36, 37, 44, 45, 48, 49, 52, + 53, 58, 59, 62, 63, 66, 67, +}; +private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) +{ + switch(hiByte) + { + case 0: + return ((jjbitVec2[i2] & l2) != 0L); + default : + if ((jjbitVec0[i1] & l1) != 0L) + return true; + return false; + } +} +private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2) +{ + switch(hiByte) + { + case 0: + return ((jjbitVec4[i2] & l2) != 0L); + case 48: + return ((jjbitVec5[i2] & l2) != 0L); + case 49: + return ((jjbitVec6[i2] & l2) != 0L); + case 51: + return ((jjbitVec7[i2] & l2) != 0L); + case 61: + return ((jjbitVec8[i2] & l2) != 0L); + default : + if ((jjbitVec3[i1] & l1) != 0L) + return true; + return false; + } +} +public static final String[] jjstrLiteralImages = { +"", null, null, null, null, null, null, null, null, null, null, null, null, +"\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153", "\142\171\164\145", +"\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163", +"\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", +"\144\157", "\144\157\165\142\154\145", "\145\154\163\145", +"\145\170\164\145\156\144\163", "\146\141\154\163\145", "\146\151\156\141\154", +"\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146", +"\151\155\160\154\145\155\145\156\164\163", "\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", +"\151\156\164", "\151\156\164\145\162\146\141\143\145", "\154\157\156\147", +"\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145", +"\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", +"\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\165\160\145\162", +"\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163", +"\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\141\156\163\151\145\156\164", +"\164\162\165\145", "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145", +"\167\150\151\154\145", "\155\145\164\141\143\154\141\163\163", +"\151\156\163\164\141\156\164\151\141\164\145\163", null, null, null, null, null, null, null, null, null, null, null, null, null, +"\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56", "\75", "\76", +"\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75", "\76\75", "\41\75", +"\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", "\57", "\46", "\174", +"\136", "\45", "\74\74", "\76\76", "\76\76\76", "\53\75", "\55\75", "\52\75", +"\57\75", "\46\75", "\174\75", "\136\75", "\45\75", "\74\74\75", "\76\76\75", +"\76\76\76\75", }; +public static final String[] lexStateNames = { + "DEFAULT", + "IN_SINGLE_LINE_COMMENT", + "IN_FORMAL_COMMENT", + "IN_MULTI_LINE_COMMENT", +}; +public static final int[] jjnewLexState = { + -1, -1, -1, -1, -1, -1, 2, 1, 3, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, +}; +static final long[] jjtoToken = { + 0xffffffffffffe001L, 0xfffffffffffcec7L, +}; +static final long[] jjtoSkip = { + 0xe3eL, 0x0L, +}; +static final long[] jjtoSpecial = { + 0xe00L, 0x0L, +}; +static final long[] jjtoMore = { + 0x11c0L, 0x0L, +}; +private ASCII_UCodeESC_CharStream input_stream; +private final int[] jjrounds = new int[75]; +private final int[] jjstateSet = new int[150]; +StringBuffer image; +int jjimageLen; +int lengthOfMatch; +protected char curChar; +public ParserTokenManager(ASCII_UCodeESC_CharStream stream) +{ + if (ASCII_UCodeESC_CharStream.staticFlag) + throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); + input_stream = stream; +} +public ParserTokenManager(ASCII_UCodeESC_CharStream stream, int lexState) +{ + this(stream); + SwitchTo(lexState); +} +public void ReInit(ASCII_UCodeESC_CharStream stream) +{ + jjmatchedPos = jjnewStateCnt = 0; + curLexState = defaultLexState; + input_stream = stream; + ReInitRounds(); +} +private final void ReInitRounds() +{ + int i; + jjround = 0x80000001; + for (i = 75; i-- > 0;) + jjrounds[i] = 0x80000000; +} +public void ReInit(ASCII_UCodeESC_CharStream stream, int lexState) +{ + ReInit(stream); + SwitchTo(lexState); +} +public void SwitchTo(int lexState) +{ + if (lexState >= 4 || lexState < 0) + throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); + else + curLexState = lexState; +} + +private final Token jjFillToken() +{ + Token t = Token.newToken(jjmatchedKind); + t.kind = jjmatchedKind; + String im = jjstrLiteralImages[jjmatchedKind]; + t.image = (im == null) ? input_stream.GetImage() : im; + t.beginLine = input_stream.getBeginLine(); + t.beginColumn = input_stream.getBeginColumn(); + t.endLine = input_stream.getEndLine(); + t.endColumn = input_stream.getEndColumn(); + return t; +} + +int curLexState = 0; +int defaultLexState = 0; +int jjnewStateCnt; +int jjround; +int jjmatchedPos; +int jjmatchedKind; + +public final Token getNextToken() +{ + int kind; + Token specialToken = null; + Token matchedToken; + int curPos = 0; + + EOFLoop : + for (;;) + { + try + { + curChar = input_stream.BeginToken(); + } + catch(java.io.IOException e) + { + jjmatchedKind = 0; + matchedToken = jjFillToken(); + matchedToken.specialToken = specialToken; + return matchedToken; + } + image = null; + jjimageLen = 0; + + for (;;) + { + switch(curLexState) + { + case 0: + try { input_stream.backup(0); + while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) + curChar = input_stream.BeginToken(); + } + catch (java.io.IOException e1) { continue EOFLoop; } + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_0(); + break; + case 1: + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_1(); + if (jjmatchedPos == 0 && jjmatchedKind > 12) + { + jjmatchedKind = 12; + } + break; + case 2: + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_2(); + if (jjmatchedPos == 0 && jjmatchedKind > 12) + { + jjmatchedKind = 12; + } + break; + case 3: + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_3(); + if (jjmatchedPos == 0 && jjmatchedKind > 12) + { + jjmatchedKind = 12; + } + break; + } + if (jjmatchedKind != 0x7fffffff) + { + if (jjmatchedPos + 1 < curPos) + input_stream.backup(curPos - jjmatchedPos - 1); + if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + matchedToken = jjFillToken(); + matchedToken.specialToken = specialToken; + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + return matchedToken; + } + else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + matchedToken = jjFillToken(); + if (specialToken == null) + specialToken = matchedToken; + else + { + matchedToken.specialToken = specialToken; + specialToken = (specialToken.next = matchedToken); + } + SkipLexicalActions(matchedToken); + } + else + SkipLexicalActions(null); + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + continue EOFLoop; + } + jjimageLen += jjmatchedPos + 1; + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + curPos = 0; + jjmatchedKind = 0x7fffffff; + try { + curChar = input_stream.readChar(); + continue; + } + catch (java.io.IOException e1) { } + } + int error_line = input_stream.getEndLine(); + int error_column = input_stream.getEndColumn(); + String error_after = null; + boolean EOFSeen = false; + try { input_stream.readChar(); input_stream.backup(1); } + catch (java.io.IOException e1) { + EOFSeen = true; + error_after = curPos <= 1 ? "" : input_stream.GetImage(); + if (curChar == '\n' || curChar == '\r') { + error_line++; + error_column = 0; + } + else + error_column++; + } + if (!EOFSeen) { + input_stream.backup(1); + error_after = curPos <= 1 ? "" : input_stream.GetImage(); + } + throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); + } + } +} + +final void SkipLexicalActions(Token matchedToken) +{ + switch(jjmatchedKind) + { + default : + break; + } +} +} diff --git a/src/main/java/io/devnulllabs/openjava/tools/parser/Token.java b/src/main/java/io/devnulllabs/openjava/tools/parser/Token.java new file mode 100644 index 0000000..1cf7c60 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/tools/parser/Token.java @@ -0,0 +1,81 @@ +/* Generated By:JavaCC: Do not edit this line. Token.java Version 2.1 */ +package io.devnulllabs.openjava.tools.parser; + +/** + * Describes the input token stream. + */ + +public class Token { + + /** + * An integer that describes the kind of this token. This numbering + * system is determined by JavaCCParser, and a table of these numbers is + * stored in the file ...Constants.java. + */ + public int kind; + + /** + * beginLine and beginColumn describe the position of the first character + * of this token; endLine and endColumn describe the position of the + * last character of this token. + */ + public int beginLine, beginColumn, endLine, endColumn; + + /** + * The string image of the token. + */ + public String image; + + /** + * A reference to the next regular (non-special) token from the input + * stream. If this is the last token from the input stream, or if the + * token manager has not read tokens beyond this one, this field is + * set to null. This is true only if this token is also a regular + * token. Otherwise, see below for a description of the contents of + * this field. + */ + public Token next; + + /** + * This field is used to access special tokens that occur prior to this + * token, but after the immediately preceding regular (non-special) token. + * If there are no such special tokens, this field is set to null. + * When there are more than one such special token, this field refers + * to the last of these special tokens, which in turn refers to the next + * previous special token through its specialToken field, and so on + * until the first special token (whose specialToken field is null). + * The next fields of special tokens refer to other special tokens that + * immediately follow it (without an intervening regular token). If there + * is no such token, this field is null. + */ + public Token specialToken; + + /** + * Returns the image. + */ + public final String toString() + { + return image; + } + + /** + * Returns a new Token object, by default. However, if you want, you + * can create and return subclass objects based on the value of ofKind. + * Simply add the cases to the switch for all those special cases. + * For example, if you have a subclass of Token called IDToken that + * you want to create if ofKind is ID, simlpy add something like : + * + * case MyParserConstants.ID : return new IDToken(); + * + * to the following switch statement. Then you can cast matchedToken + * variable to the appropriate type and use it in your lexical actions. + */ + public static final Token newToken(int ofKind) + { + switch(ofKind) + { + default : return new Token(); + } + } + +} diff --git a/src/main/java/io/devnulllabs/openjava/tools/parser/TokenIDPublisher.java b/src/main/java/io/devnulllabs/openjava/tools/parser/TokenIDPublisher.java new file mode 100644 index 0000000..3214779 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/tools/parser/TokenIDPublisher.java @@ -0,0 +1,122 @@ +package io.devnulllabs.openjava.tools.parser; + + +public interface TokenIDPublisher { + + public static final int EOF = ParserConstants.EOF; + + public static final int ABSTRACT = ParserConstants.ABSTRACT; + public static final int BOOLEAN = ParserConstants.BOOLEAN; + public static final int BREAK = ParserConstants.BREAK; + public static final int BYTE = ParserConstants.BYTE; + public static final int CASE = ParserConstants.CASE; + public static final int CATCH = ParserConstants.CATCH; + public static final int CHAR = ParserConstants.CHAR; + public static final int CLASS = ParserConstants.CLASS; + public static final int CONTINUE = ParserConstants.CONTINUE; + public static final int DEFAULT = ParserConstants._DEFAULT; + public static final int DO = ParserConstants.DO; + public static final int DOUBLE = ParserConstants.DOUBLE; + public static final int ELSE = ParserConstants.ELSE; + public static final int EXTENDS = ParserConstants.EXTENDS; + public static final int FALSE = ParserConstants.FALSE; + public static final int FINAL = ParserConstants.FINAL; + public static final int FINALLY = ParserConstants.FINALLY; + public static final int FLOAT = ParserConstants.FLOAT; + public static final int FOR = ParserConstants.FOR; + public static final int IF = ParserConstants.IF; + public static final int IMPLEMENTS = ParserConstants.IMPLEMENTS; + public static final int IMPORT = ParserConstants.IMPORT; + public static final int INSTANCEOF = ParserConstants.INSTANCEOF; + public static final int INT = ParserConstants.INT; + public static final int INTERFACE = ParserConstants.INTERFACE; + public static final int LONG = ParserConstants.LONG; + public static final int NATIVE = ParserConstants.NATIVE; + public static final int NEW = ParserConstants.NEW; + public static final int NULL = ParserConstants.NULL; + public static final int PACKAGE = ParserConstants.PACKAGE; + public static final int PRIVATE = ParserConstants.PRIVATE; + public static final int PROTECTED = ParserConstants.PROTECTED; + public static final int PUBLIC = ParserConstants.PUBLIC; + public static final int RETURN = ParserConstants.RETURN; + public static final int SHORT = ParserConstants.SHORT; + public static final int STATIC = ParserConstants.STATIC; + public static final int SUPER = ParserConstants.SUPER; + public static final int SWITCH = ParserConstants.SWITCH; + public static final int SYNCHRONIZED = ParserConstants.SYNCHRONIZED; + public static final int THIS = ParserConstants.THIS; + public static final int THROW = ParserConstants.THROW; + public static final int THROWS = ParserConstants.THROWS; + public static final int TRANSIENT = ParserConstants.TRANSIENT; + public static final int TRUE = ParserConstants.TRUE; + public static final int TRY = ParserConstants.TRY; + public static final int VOID = ParserConstants.VOID; + public static final int VOLATILE = ParserConstants.VOLATILE; + public static final int WHILE = ParserConstants.WHILE; + public static final int METACLASS = ParserConstants.METACLASS; + public static final int INSTANTIATES = ParserConstants.INSTANTIATES; + + public static final int INTEGER_LITERAL + = ParserConstants.INTEGER_LITERAL; + public static final int LONG_LITERAL + = ParserConstants.LONG_LITERAL; + public static final int DOUBLE_LITERAL + = ParserConstants.DOUBLE_FLOATING_POINT_LITERAL; + public static final int FLOAT_LITERAL + = ParserConstants.FLOATING_POINT_LITERAL; + public static final int CHARACTER_LITERAL + = ParserConstants.CHARACTER_LITERAL; + public static final int STRING_LITERAL + = ParserConstants.STRING_LITERAL; + + public static final int IDENTIFIER = ParserConstants.IDENTIFIER; + public static final int LPAREN = ParserConstants.LPAREN; + public static final int RPAREN = ParserConstants.RPAREN; + public static final int LBRACE = ParserConstants.LBRACE; + public static final int RBRACE = ParserConstants.RBRACE; + public static final int LBRACKET = ParserConstants.LBRACKET; + public static final int RBRACKET = ParserConstants.RBRACKET; + public static final int SEMICOLON = ParserConstants.SEMICOLON; + public static final int COMMA = ParserConstants.COMMA; + public static final int DOT = ParserConstants.DOT; + public static final int ASSIGN = ParserConstants.ASSIGN; + public static final int GREATER = ParserConstants.GT; + public static final int LESS = ParserConstants.LT; + public static final int BANG = ParserConstants.BANG; + public static final int TILDE = ParserConstants.TILDE; + public static final int HOOK = ParserConstants.HOOK; + public static final int COLON = ParserConstants.COLON; + public static final int EQUAL = ParserConstants.EQ; + public static final int LESS_EQUAL = ParserConstants.LE; + public static final int GREATER_EQUAL = ParserConstants.GE; + public static final int NOT_EQUAL = ParserConstants.NE; + public static final int CONDITIONAL_OR = ParserConstants.SC_OR; + public static final int CONDITIONAL_AND = ParserConstants.SC_AND; + public static final int INCREMENT = ParserConstants.INCR; + public static final int DECREMENT = ParserConstants.DECR; + public static final int PLUS = ParserConstants.PLUS; + public static final int MINUS = ParserConstants.MINUS; + public static final int STAR = ParserConstants.STAR; + public static final int SLASH = ParserConstants.SLASH; + public static final int BIT_AND = ParserConstants.BIT_AND; + public static final int BIT_OR = ParserConstants.BIT_OR; + public static final int XOR = ParserConstants.XOR; + public static final int REM = ParserConstants.REM; + public static final int LSHIFT = ParserConstants.LSHIFT; + public static final int RSIGNEDSHIFT = ParserConstants.RSIGNEDSHIFT; + public static final int RUNSIGNEDSHIFT = ParserConstants.RUNSIGNEDSHIFT; + public static final int PLUSASSIGN = ParserConstants.PLUSASSIGN; + public static final int MINUSASSIGN = ParserConstants.MINUSASSIGN; + public static final int STARASSIGN = ParserConstants.STARASSIGN; + public static final int SLASHASSIGN = ParserConstants.SLASHASSIGN; + public static final int ANDASSIGN = ParserConstants.ANDASSIGN; + public static final int ORASSIGN = ParserConstants.ORASSIGN; + public static final int XORASSIGN = ParserConstants.XORASSIGN; + public static final int REMASSIGN = ParserConstants.REMASSIGN; + public static final int LSHIFTASSIGN = ParserConstants.LSHIFTASSIGN; + public static final int RSIGNEDSHIFTASSIGN + = ParserConstants.RSIGNEDSHIFTASSIGN; + public static final int RUNSIGNEDSHIFTASSIGN + = ParserConstants.RUNSIGNEDSHIFTASSIGN; + +} diff --git a/src/main/java/io/devnulllabs/openjava/tools/parser/TokenMgrError.java b/src/main/java/io/devnulllabs/openjava/tools/parser/TokenMgrError.java new file mode 100644 index 0000000..90eb662 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/tools/parser/TokenMgrError.java @@ -0,0 +1,133 @@ +/* Generated By:JavaCC: Do not edit this line. TokenMgrError.java Version 2.1 */ +package io.devnulllabs.openjava.tools.parser; + +public class TokenMgrError extends Error +{ + /* + * Ordinals for various reasons why an Error of this type can be thrown. + */ + + /** + * Lexical error occured. + */ + static final int LEXICAL_ERROR = 0; + + /** + * An attempt wass made to create a second instance of a static token manager. + */ + static final int STATIC_LEXER_ERROR = 1; + + /** + * Tried to change to an invalid lexical state. + */ + static final int INVALID_LEXICAL_STATE = 2; + + /** + * Detected (and bailed out of) an infinite loop in the token manager. + */ + static final int LOOP_DETECTED = 3; + + /** + * Indicates the reason why the exception is thrown. It will have + * one of the above 4 values. + */ + int errorCode; + + /** + * Replaces unprintable characters by their espaced (or unicode escaped) + * equivalents in the given string + */ + protected static final String addEscapes(String str) { + StringBuffer retval = new StringBuffer(); + char ch; + for (int i = 0; i < str.length(); i++) { + switch (str.charAt(i)) + { + case 0 : + continue; + case '\b': + retval.append("\\b"); + continue; + case '\t': + retval.append("\\t"); + continue; + case '\n': + retval.append("\\n"); + continue; + case '\f': + retval.append("\\f"); + continue; + case '\r': + retval.append("\\r"); + continue; + case '\"': + retval.append("\\\""); + continue; + case '\'': + retval.append("\\\'"); + continue; + case '\\': + retval.append("\\\\"); + continue; + default: + if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) { + String s = "0000" + Integer.toString(ch, 16); + retval.append("\\u" + s.substring(s.length() - 4, s.length())); + } else { + retval.append(ch); + } + continue; + } + } + return retval.toString(); + } + + /** + * Returns a detailed message for the Error when it is thrown by the + * token manager to indicate a lexical error. + * Parameters : + * EOFSeen : indicates if EOF caused the lexicl error + * curLexState : lexical state in which this error occured + * errorLine : line number when the error occured + * errorColumn : column number when the error occured + * errorAfter : prefix that was seen before this error occured + * curchar : the offending character + * Note: You can customize the lexical error message by modifying this method. + */ + private static final String LexicalError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar) { + return("Lexical error at line " + + errorLine + ", column " + + errorColumn + ". Encountered: " + + (EOFSeen ? "<EOF> " : ("\"" + addEscapes(String.valueOf(curChar)) + "\"") + " (" + (int)curChar + "), ") + + "after : \"" + addEscapes(errorAfter) + "\""); + } + + /** + * You can also modify the body of this method to customize your error messages. + * For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not + * of end-users concern, so you can return something like : + * + * "Internal Error : Please file a bug report .... " + * + * from this method for such cases in the release version of your parser. + */ + public String getMessage() { + return super.getMessage(); + } + + /* + * Constructors of various flavors follow. + */ + + public TokenMgrError() { + } + + public TokenMgrError(String message, int reason) { + super(message); + errorCode = reason; + } + + public TokenMgrError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar, int reason) { + this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason); + } +} diff --git a/src/main/java/io/devnulllabs/openjava/tools/parser/TokenSourceAdapter.java b/src/main/java/io/devnulllabs/openjava/tools/parser/TokenSourceAdapter.java new file mode 100644 index 0000000..1d9e0f8 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/tools/parser/TokenSourceAdapter.java @@ -0,0 +1,44 @@ +/* + * TokenSourceAdapter.java + * + * comments here. + * + * @author Michiaki Tatsubori + * @version %VERSION% %DATE% + * @see java.lang.Object + * + * COPYRIGHT 1998 by Michiaki Tatsubori, ALL RIGHTS RESERVED. + */ +package io.devnulllabs.openjava.tools.parser; + +import io.devnulllabs.openjava.syntax.TokenSource; + +/** + * The class <code>TokenSourceAdapter</code> + * <p> + * For example + * <pre> + * </pre> + * <p> + * + * @author Michiaki Tatsubori + * @version 1.0 + * @since $Id: TokenSourceAdapter.java,v 1.2 2003/02/19 02:55:01 tatsubori Exp $ + * @see java.lang.Object + */ +public final class TokenSourceAdapter extends ParserTokenManager { + private TokenSource token_src; + + public TokenSourceAdapter(TokenSource token_src) { + super(null); + this.token_src = token_src; + } + + public Token getNextToken() { + return token_src.getNextToken(); + } + + public Token getToken(int i) { + return token_src.getToken(i); + } +} diff --git a/src/main/java/io/devnulllabs/openjava/tools/parser/patchParserTokenManager.pl b/src/main/java/io/devnulllabs/openjava/tools/parser/patchParserTokenManager.pl new file mode 100644 index 0000000..26dc274 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/tools/parser/patchParserTokenManager.pl @@ -0,0 +1,11 @@ +#!/usr/local/bin/perl + +while (<>) { + print &removefinal($_); +} + +sub removefinal { + local($_) = @_; + $_ =~ s/public final Token getNextToken/public Token getNextToken/; + return $_; +} |