1800 lines
50 KiB
Java
1800 lines
50 KiB
Java
package org.nfunk.jep;
|
|
|
|
import java.io.InputStream;
|
|
import java.io.Reader;
|
|
import java.util.Enumeration;
|
|
import java.util.Vector;
|
|
|
|
public class Parser implements ParserTreeConstants, ParserConstants {
|
|
protected JJTParserState jjtree = new JJTParserState();
|
|
|
|
private JEP jep;
|
|
|
|
private SymbolTable symTab;
|
|
|
|
private OperatorSet opSet;
|
|
|
|
private int initialTokenManagerState = 1;
|
|
|
|
public ParserTokenManager token_source;
|
|
|
|
JavaCharStream jj_input_stream;
|
|
|
|
public Token token;
|
|
|
|
public Token jj_nt;
|
|
|
|
private int jj_ntk;
|
|
|
|
private Token jj_scanpos;
|
|
|
|
private Token jj_lastpos;
|
|
|
|
private int jj_la;
|
|
|
|
public boolean lookingAhead = false;
|
|
|
|
private boolean jj_semLA;
|
|
|
|
private int jj_gen;
|
|
|
|
private final int[] jj_la1 = new int[22];
|
|
|
|
private static int[] jj_la1_0;
|
|
|
|
private static int[] jj_la1_1;
|
|
|
|
private final JJCalls[] jj_2_rtns = new JJCalls[8];
|
|
|
|
private boolean jj_rescan = false;
|
|
|
|
private int jj_gc = 0;
|
|
|
|
private final LookaheadSuccess jj_ls = new LookaheadSuccess();
|
|
|
|
private Vector jj_expentries = new Vector();
|
|
|
|
private int[] jj_expentry;
|
|
|
|
private int jj_kind = -1;
|
|
|
|
private int[] jj_lasttokens = new int[100];
|
|
|
|
private int jj_endpos;
|
|
|
|
public Node parseStream(Reader paramReader, JEP paramJEP) throws ParseException {
|
|
restart(paramReader, paramJEP);
|
|
enable_tracing();
|
|
ASTStart aSTStart = Start();
|
|
if (aSTStart == null)
|
|
throw new ParseException("No expression entered");
|
|
return aSTStart.jjtGetChild(0);
|
|
}
|
|
|
|
public void restart(Reader paramReader, JEP paramJEP) {
|
|
ReInit(paramReader);
|
|
this.token_source.SwitchTo(this.initialTokenManagerState);
|
|
this.jep = paramJEP;
|
|
this.symTab = this.jep.getSymbolTable();
|
|
this.opSet = this.jep.getOperatorSet();
|
|
}
|
|
|
|
public Node continueParse() throws ParseException {
|
|
ASTStart aSTStart = Start();
|
|
return (aSTStart == null) ? null : aSTStart.jjtGetChild(0);
|
|
}
|
|
|
|
private void addToErrorList(String paramString) {
|
|
this.jep.errorList.addElement(paramString);
|
|
}
|
|
|
|
public void setInitialTokenManagerState(int paramInt) {
|
|
this.initialTokenManagerState = paramInt;
|
|
}
|
|
|
|
private String replaceEscape(String paramString) {
|
|
int i = paramString.length();
|
|
int j = 0;
|
|
String str1 = "tnrbf\\\"'";
|
|
String str2 = "\t\n\r\b\f\\\"'";
|
|
StringBuffer stringBuffer = new StringBuffer();
|
|
int k;
|
|
while ((k = paramString.indexOf('\\', j)) != -1) {
|
|
stringBuffer.append(paramString.substring(j, k));
|
|
if (k + 1 == i)
|
|
break;
|
|
char c = paramString.charAt(k + 1);
|
|
int m = str1.indexOf(c);
|
|
if (m == -1) {
|
|
stringBuffer.append('\\');
|
|
stringBuffer.append(c);
|
|
} else {
|
|
stringBuffer.append(str2.charAt(m));
|
|
}
|
|
j = k + 2;
|
|
}
|
|
if (j < i)
|
|
stringBuffer.append(paramString.substring(j));
|
|
return stringBuffer.toString();
|
|
}
|
|
|
|
public final ASTStart Start() throws ParseException {
|
|
ASTStart aSTStart = new ASTStart(0);
|
|
boolean bool = true;
|
|
this.jjtree.openNodeScope(aSTStart);
|
|
try {
|
|
if (jj_2_1(1)) {
|
|
Expression();
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 0:
|
|
jj_consume_token(0);
|
|
break;
|
|
case 19:
|
|
jj_consume_token(19);
|
|
break;
|
|
default:
|
|
this.jj_la1[0] = this.jj_gen;
|
|
jj_consume_token(-1);
|
|
throw new ParseException();
|
|
}
|
|
this.jjtree.closeNodeScope(aSTStart, true);
|
|
bool = false;
|
|
return aSTStart;
|
|
}
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 0:
|
|
case 19:
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 0:
|
|
jj_consume_token(0);
|
|
break;
|
|
case 19:
|
|
jj_consume_token(19);
|
|
break;
|
|
default:
|
|
this.jj_la1[1] = this.jj_gen;
|
|
jj_consume_token(-1);
|
|
throw new ParseException();
|
|
}
|
|
this.jjtree.closeNodeScope(aSTStart, true);
|
|
bool = false;
|
|
return null;
|
|
}
|
|
this.jj_la1[2] = this.jj_gen;
|
|
jj_consume_token(-1);
|
|
throw new ParseException();
|
|
} catch (Throwable throwable) {
|
|
if (bool) {
|
|
this.jjtree.clearNodeScope(aSTStart);
|
|
bool = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool)
|
|
this.jjtree.closeNodeScope(aSTStart, true);
|
|
}
|
|
}
|
|
|
|
public final void Expression() throws ParseException {
|
|
if (jj_2_2(3)) {
|
|
AssignExpression();
|
|
} else if (jj_2_3(1)) {
|
|
OrExpression();
|
|
} else {
|
|
jj_consume_token(-1);
|
|
throw new ParseException();
|
|
}
|
|
}
|
|
|
|
public final void AssignExpression() throws ParseException {
|
|
ASTFunNode aSTFunNode = new ASTFunNode(2);
|
|
boolean bool = true;
|
|
this.jjtree.openNodeScope(aSTFunNode);
|
|
try {
|
|
Variable();
|
|
jj_consume_token(18);
|
|
Expression();
|
|
this.jjtree.closeNodeScope(aSTFunNode, 2);
|
|
bool = false;
|
|
if (!this.jep.getAllowAssignment())
|
|
throw new ParseException("Syntax Error (assignment not enabled)");
|
|
aSTFunNode.setOperator(this.opSet.getAssign());
|
|
} catch (Throwable throwable) {
|
|
if (bool) {
|
|
this.jjtree.clearNodeScope(aSTFunNode);
|
|
bool = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool)
|
|
this.jjtree.closeNodeScope(aSTFunNode, 2);
|
|
}
|
|
}
|
|
|
|
public final void OrExpression() throws ParseException {
|
|
AndExpression();
|
|
while (true) {
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 28:
|
|
break;
|
|
default:
|
|
this.jj_la1[3] = this.jj_gen;
|
|
break;
|
|
}
|
|
ASTFunNode aSTFunNode = new ASTFunNode(2);
|
|
boolean bool = true;
|
|
this.jjtree.openNodeScope(aSTFunNode);
|
|
try {
|
|
jj_consume_token(28);
|
|
AndExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode, 2);
|
|
bool = false;
|
|
aSTFunNode.setOperator(this.opSet.getOr());
|
|
} catch (Throwable throwable) {
|
|
if (bool) {
|
|
this.jjtree.clearNodeScope(aSTFunNode);
|
|
bool = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool)
|
|
this.jjtree.closeNodeScope(aSTFunNode, 2);
|
|
}
|
|
}
|
|
}
|
|
|
|
public final void AndExpression() throws ParseException {
|
|
EqualExpression();
|
|
while (true) {
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 27:
|
|
break;
|
|
default:
|
|
this.jj_la1[4] = this.jj_gen;
|
|
break;
|
|
}
|
|
ASTFunNode aSTFunNode = new ASTFunNode(2);
|
|
boolean bool = true;
|
|
this.jjtree.openNodeScope(aSTFunNode);
|
|
try {
|
|
jj_consume_token(27);
|
|
EqualExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode, 2);
|
|
bool = false;
|
|
aSTFunNode.setOperator(this.opSet.getAnd());
|
|
} catch (Throwable throwable) {
|
|
if (bool) {
|
|
this.jjtree.clearNodeScope(aSTFunNode);
|
|
bool = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool)
|
|
this.jjtree.closeNodeScope(aSTFunNode, 2);
|
|
}
|
|
}
|
|
}
|
|
|
|
public final void EqualExpression() throws ParseException {
|
|
RelationalExpression();
|
|
while (true) {
|
|
ASTFunNode aSTFunNode1;
|
|
boolean bool1;
|
|
ASTFunNode aSTFunNode2;
|
|
boolean bool2;
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 23:
|
|
case 26:
|
|
break;
|
|
default:
|
|
this.jj_la1[5] = this.jj_gen;
|
|
break;
|
|
}
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 26:
|
|
aSTFunNode1 = new ASTFunNode(2);
|
|
bool1 = true;
|
|
this.jjtree.openNodeScope(aSTFunNode1);
|
|
try {
|
|
jj_consume_token(26);
|
|
RelationalExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode1, 2);
|
|
bool1 = false;
|
|
aSTFunNode1.setOperator(this.opSet.getNE());
|
|
continue;
|
|
} catch (Throwable throwable) {
|
|
if (bool1) {
|
|
this.jjtree.clearNodeScope(aSTFunNode1);
|
|
bool1 = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool1)
|
|
this.jjtree.closeNodeScope(aSTFunNode1, 2);
|
|
}
|
|
case 23:
|
|
aSTFunNode2 = new ASTFunNode(2);
|
|
bool2 = true;
|
|
this.jjtree.openNodeScope(aSTFunNode2);
|
|
try {
|
|
jj_consume_token(23);
|
|
RelationalExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode2, 2);
|
|
bool2 = false;
|
|
aSTFunNode2.setOperator(this.opSet.getEQ());
|
|
continue;
|
|
} catch (Throwable throwable) {
|
|
if (bool2) {
|
|
this.jjtree.clearNodeScope(aSTFunNode2);
|
|
bool2 = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool2)
|
|
this.jjtree.closeNodeScope(aSTFunNode2, 2);
|
|
}
|
|
}
|
|
this.jj_la1[6] = this.jj_gen;
|
|
jj_consume_token(-1);
|
|
throw new ParseException();
|
|
}
|
|
}
|
|
|
|
public final void RelationalExpression() throws ParseException {
|
|
AdditiveExpression();
|
|
while (true) {
|
|
ASTFunNode aSTFunNode1;
|
|
boolean bool1;
|
|
ASTFunNode aSTFunNode2;
|
|
boolean bool2;
|
|
ASTFunNode aSTFunNode3;
|
|
boolean bool3;
|
|
ASTFunNode aSTFunNode4;
|
|
boolean bool4;
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 21:
|
|
case 22:
|
|
case 24:
|
|
case 25:
|
|
break;
|
|
default:
|
|
this.jj_la1[7] = this.jj_gen;
|
|
break;
|
|
}
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 22:
|
|
aSTFunNode1 = new ASTFunNode(2);
|
|
bool1 = true;
|
|
this.jjtree.openNodeScope(aSTFunNode1);
|
|
try {
|
|
jj_consume_token(22);
|
|
AdditiveExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode1, 2);
|
|
bool1 = false;
|
|
aSTFunNode1.setOperator(this.opSet.getLT());
|
|
continue;
|
|
} catch (Throwable throwable) {
|
|
if (bool1) {
|
|
this.jjtree.clearNodeScope(aSTFunNode1);
|
|
bool1 = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool1)
|
|
this.jjtree.closeNodeScope(aSTFunNode1, 2);
|
|
}
|
|
case 21:
|
|
aSTFunNode2 = new ASTFunNode(2);
|
|
bool2 = true;
|
|
this.jjtree.openNodeScope(aSTFunNode2);
|
|
try {
|
|
jj_consume_token(21);
|
|
AdditiveExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode2, 2);
|
|
bool2 = false;
|
|
aSTFunNode2.setOperator(this.opSet.getGT());
|
|
continue;
|
|
} catch (Throwable throwable) {
|
|
if (bool2) {
|
|
this.jjtree.clearNodeScope(aSTFunNode2);
|
|
bool2 = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool2)
|
|
this.jjtree.closeNodeScope(aSTFunNode2, 2);
|
|
}
|
|
case 24:
|
|
aSTFunNode3 = new ASTFunNode(2);
|
|
bool3 = true;
|
|
this.jjtree.openNodeScope(aSTFunNode3);
|
|
try {
|
|
jj_consume_token(24);
|
|
AdditiveExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode3, 2);
|
|
bool3 = false;
|
|
aSTFunNode3.setOperator(this.opSet.getLE());
|
|
continue;
|
|
} catch (Throwable throwable) {
|
|
if (bool3) {
|
|
this.jjtree.clearNodeScope(aSTFunNode3);
|
|
bool3 = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool3)
|
|
this.jjtree.closeNodeScope(aSTFunNode3, 2);
|
|
}
|
|
case 25:
|
|
aSTFunNode4 = new ASTFunNode(2);
|
|
bool4 = true;
|
|
this.jjtree.openNodeScope(aSTFunNode4);
|
|
try {
|
|
jj_consume_token(25);
|
|
AdditiveExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode4, 2);
|
|
bool4 = false;
|
|
aSTFunNode4.setOperator(this.opSet.getGE());
|
|
continue;
|
|
} catch (Throwable throwable) {
|
|
if (bool4) {
|
|
this.jjtree.clearNodeScope(aSTFunNode4);
|
|
bool4 = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool4)
|
|
this.jjtree.closeNodeScope(aSTFunNode4, 2);
|
|
}
|
|
}
|
|
this.jj_la1[8] = this.jj_gen;
|
|
jj_consume_token(-1);
|
|
throw new ParseException();
|
|
}
|
|
}
|
|
|
|
public final void AdditiveExpression() throws ParseException {
|
|
MultiplicativeExpression();
|
|
while (true) {
|
|
ASTFunNode aSTFunNode1;
|
|
boolean bool1;
|
|
ASTFunNode aSTFunNode2;
|
|
boolean bool2;
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 29:
|
|
case 30:
|
|
break;
|
|
default:
|
|
this.jj_la1[9] = this.jj_gen;
|
|
break;
|
|
}
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 29:
|
|
aSTFunNode1 = new ASTFunNode(2);
|
|
bool1 = true;
|
|
this.jjtree.openNodeScope(aSTFunNode1);
|
|
try {
|
|
jj_consume_token(29);
|
|
MultiplicativeExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode1, 2);
|
|
bool1 = false;
|
|
aSTFunNode1.setOperator(this.opSet.getAdd());
|
|
continue;
|
|
} catch (Throwable throwable) {
|
|
if (bool1) {
|
|
this.jjtree.clearNodeScope(aSTFunNode1);
|
|
bool1 = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool1)
|
|
this.jjtree.closeNodeScope(aSTFunNode1, 2);
|
|
}
|
|
case 30:
|
|
aSTFunNode2 = new ASTFunNode(2);
|
|
bool2 = true;
|
|
this.jjtree.openNodeScope(aSTFunNode2);
|
|
try {
|
|
jj_consume_token(30);
|
|
MultiplicativeExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode2, 2);
|
|
bool2 = false;
|
|
aSTFunNode2.setOperator(this.opSet.getSubtract());
|
|
continue;
|
|
} catch (Throwable throwable) {
|
|
if (bool2) {
|
|
this.jjtree.clearNodeScope(aSTFunNode2);
|
|
bool2 = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool2)
|
|
this.jjtree.closeNodeScope(aSTFunNode2, 2);
|
|
}
|
|
}
|
|
this.jj_la1[10] = this.jj_gen;
|
|
jj_consume_token(-1);
|
|
throw new ParseException();
|
|
}
|
|
}
|
|
|
|
public final void MultiplicativeExpression() throws ParseException {
|
|
UnaryExpression();
|
|
while (jj_2_4(1)) {
|
|
ASTFunNode aSTFunNode1;
|
|
boolean bool1;
|
|
ASTFunNode aSTFunNode2;
|
|
boolean bool2;
|
|
ASTFunNode aSTFunNode3;
|
|
boolean bool3;
|
|
ASTFunNode aSTFunNode4;
|
|
boolean bool4;
|
|
ASTFunNode aSTFunNode5;
|
|
boolean bool5;
|
|
if (jj_2_5(1)) {
|
|
ASTFunNode aSTFunNode = new ASTFunNode(2);
|
|
boolean bool = true;
|
|
this.jjtree.openNodeScope(aSTFunNode);
|
|
try {
|
|
PowerExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode, 2);
|
|
bool = false;
|
|
if (!this.jep.implicitMul)
|
|
throw new ParseException("Syntax Error (implicit multiplication not enabled)");
|
|
aSTFunNode.setOperator(this.opSet.getMultiply());
|
|
continue;
|
|
} catch (Throwable throwable) {
|
|
if (bool) {
|
|
this.jjtree.clearNodeScope(aSTFunNode);
|
|
bool = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool)
|
|
this.jjtree.closeNodeScope(aSTFunNode, 2);
|
|
}
|
|
}
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 31:
|
|
aSTFunNode1 = new ASTFunNode(2);
|
|
bool1 = true;
|
|
this.jjtree.openNodeScope(aSTFunNode1);
|
|
try {
|
|
jj_consume_token(31);
|
|
UnaryExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode1, 2);
|
|
bool1 = false;
|
|
aSTFunNode1.setOperator(this.opSet.getMultiply());
|
|
continue;
|
|
} catch (Throwable throwable) {
|
|
if (bool1) {
|
|
this.jjtree.clearNodeScope(aSTFunNode1);
|
|
bool1 = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool1)
|
|
this.jjtree.closeNodeScope(aSTFunNode1, 2);
|
|
}
|
|
case 32:
|
|
aSTFunNode2 = new ASTFunNode(2);
|
|
bool2 = true;
|
|
this.jjtree.openNodeScope(aSTFunNode2);
|
|
try {
|
|
jj_consume_token(32);
|
|
UnaryExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode2, 2);
|
|
bool2 = false;
|
|
aSTFunNode2.setOperator(this.opSet.getDot());
|
|
continue;
|
|
} catch (Throwable throwable) {
|
|
if (bool2) {
|
|
this.jjtree.clearNodeScope(aSTFunNode2);
|
|
bool2 = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool2)
|
|
this.jjtree.closeNodeScope(aSTFunNode2, 2);
|
|
}
|
|
case 37:
|
|
aSTFunNode3 = new ASTFunNode(2);
|
|
bool3 = true;
|
|
this.jjtree.openNodeScope(aSTFunNode3);
|
|
try {
|
|
jj_consume_token(37);
|
|
UnaryExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode3, 2);
|
|
bool3 = false;
|
|
aSTFunNode3.setOperator(this.opSet.getCross());
|
|
continue;
|
|
} catch (Throwable throwable) {
|
|
if (bool3) {
|
|
this.jjtree.clearNodeScope(aSTFunNode3);
|
|
bool3 = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool3)
|
|
this.jjtree.closeNodeScope(aSTFunNode3, 2);
|
|
}
|
|
case 33:
|
|
aSTFunNode4 = new ASTFunNode(2);
|
|
bool4 = true;
|
|
this.jjtree.openNodeScope(aSTFunNode4);
|
|
try {
|
|
jj_consume_token(33);
|
|
UnaryExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode4, 2);
|
|
bool4 = false;
|
|
aSTFunNode4.setOperator(this.opSet.getDivide());
|
|
continue;
|
|
} catch (Throwable throwable) {
|
|
if (bool4) {
|
|
this.jjtree.clearNodeScope(aSTFunNode4);
|
|
bool4 = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool4)
|
|
this.jjtree.closeNodeScope(aSTFunNode4, 2);
|
|
}
|
|
case 34:
|
|
aSTFunNode5 = new ASTFunNode(2);
|
|
bool5 = true;
|
|
this.jjtree.openNodeScope(aSTFunNode5);
|
|
try {
|
|
jj_consume_token(34);
|
|
UnaryExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode5, 2);
|
|
bool5 = false;
|
|
aSTFunNode5.setOperator(this.opSet.getMod());
|
|
continue;
|
|
} catch (Throwable throwable) {
|
|
if (bool5) {
|
|
this.jjtree.clearNodeScope(aSTFunNode5);
|
|
bool5 = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool5)
|
|
this.jjtree.closeNodeScope(aSTFunNode5, 2);
|
|
}
|
|
}
|
|
this.jj_la1[11] = this.jj_gen;
|
|
jj_consume_token(-1);
|
|
throw new ParseException();
|
|
}
|
|
}
|
|
|
|
public final void UnaryExpression() throws ParseException {
|
|
ASTFunNode aSTFunNode1;
|
|
boolean bool1;
|
|
ASTFunNode aSTFunNode2;
|
|
boolean bool2;
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 29:
|
|
jj_consume_token(29);
|
|
UnaryExpression();
|
|
return;
|
|
case 30:
|
|
aSTFunNode1 = new ASTFunNode(2);
|
|
bool1 = true;
|
|
this.jjtree.openNodeScope(aSTFunNode1);
|
|
try {
|
|
jj_consume_token(30);
|
|
UnaryExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode1, 1);
|
|
bool1 = false;
|
|
aSTFunNode1.setOperator(this.opSet.getUMinus());
|
|
} catch (Throwable throwable) {
|
|
if (bool1) {
|
|
this.jjtree.clearNodeScope(aSTFunNode1);
|
|
bool1 = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool1)
|
|
this.jjtree.closeNodeScope(aSTFunNode1, 1);
|
|
}
|
|
return;
|
|
case 35:
|
|
aSTFunNode2 = new ASTFunNode(2);
|
|
bool2 = true;
|
|
this.jjtree.openNodeScope(aSTFunNode2);
|
|
try {
|
|
jj_consume_token(35);
|
|
UnaryExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode2, 1);
|
|
bool2 = false;
|
|
aSTFunNode2.setOperator(this.opSet.getNot());
|
|
} catch (Throwable throwable) {
|
|
if (bool2) {
|
|
this.jjtree.clearNodeScope(aSTFunNode2);
|
|
bool2 = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool2)
|
|
this.jjtree.closeNodeScope(aSTFunNode2, 1);
|
|
}
|
|
return;
|
|
}
|
|
this.jj_la1[12] = this.jj_gen;
|
|
if (jj_2_6(1)) {
|
|
PowerExpression();
|
|
} else {
|
|
jj_consume_token(-1);
|
|
throw new ParseException();
|
|
}
|
|
}
|
|
|
|
public final void PowerExpression() throws ParseException {
|
|
ASTFunNode aSTFunNode;
|
|
boolean bool;
|
|
UnaryExpressionNotPlusMinus();
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 36:
|
|
aSTFunNode = new ASTFunNode(2);
|
|
bool = true;
|
|
this.jjtree.openNodeScope(aSTFunNode);
|
|
try {
|
|
jj_consume_token(36);
|
|
UnaryExpression();
|
|
this.jjtree.closeNodeScope(aSTFunNode, 2);
|
|
bool = false;
|
|
aSTFunNode.setOperator(this.opSet.getPower());
|
|
} catch (Throwable throwable) {
|
|
if (bool) {
|
|
this.jjtree.clearNodeScope(aSTFunNode);
|
|
bool = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool)
|
|
this.jjtree.closeNodeScope(aSTFunNode, 2);
|
|
}
|
|
return;
|
|
}
|
|
this.jj_la1[13] = this.jj_gen;
|
|
}
|
|
|
|
public final void UnaryExpressionNotPlusMinus() throws ParseException {
|
|
String str = "";
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 7:
|
|
case 9:
|
|
case 11:
|
|
AnyConstant();
|
|
return;
|
|
}
|
|
this.jj_la1[15] = this.jj_gen;
|
|
if (jj_2_7(1)) {
|
|
if (((getToken(1)).kind == 12 || (getToken(1)).kind == 15) && this.jep.funTab.containsKey((getToken(1)).image)) {
|
|
Function();
|
|
} else {
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 12:
|
|
case 15:
|
|
Variable();
|
|
return;
|
|
}
|
|
this.jj_la1[14] = this.jj_gen;
|
|
jj_consume_token(-1);
|
|
throw new ParseException();
|
|
}
|
|
} else {
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 40:
|
|
jj_consume_token(40);
|
|
Expression();
|
|
jj_consume_token(41);
|
|
return;
|
|
case 38:
|
|
ListExpression();
|
|
return;
|
|
}
|
|
this.jj_la1[16] = this.jj_gen;
|
|
jj_consume_token(-1);
|
|
throw new ParseException();
|
|
}
|
|
}
|
|
|
|
public final void ListExpression() throws ParseException {
|
|
ASTFunNode aSTFunNode = new ASTFunNode(2);
|
|
boolean bool = true;
|
|
this.jjtree.openNodeScope(aSTFunNode);
|
|
aSTFunNode.setOperator(this.opSet.getList());
|
|
try {
|
|
jj_consume_token(38);
|
|
Expression();
|
|
while (true) {
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 20:
|
|
break;
|
|
default:
|
|
this.jj_la1[17] = this.jj_gen;
|
|
jj_consume_token(39);
|
|
return;
|
|
}
|
|
jj_consume_token(20);
|
|
Expression();
|
|
}
|
|
} catch (Throwable throwable) {
|
|
if (bool) {
|
|
this.jjtree.clearNodeScope(aSTFunNode);
|
|
bool = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool)
|
|
this.jjtree.closeNodeScope(aSTFunNode, true);
|
|
}
|
|
}
|
|
|
|
public final void Variable() throws ParseException {
|
|
String str = "";
|
|
ASTVarNode aSTVarNode = new ASTVarNode(3);
|
|
boolean bool = true;
|
|
this.jjtree.openNodeScope(aSTVarNode);
|
|
try {
|
|
str = Identifier();
|
|
this.jjtree.closeNodeScope(aSTVarNode, true);
|
|
bool = false;
|
|
if (this.symTab.containsKey(str)) {
|
|
aSTVarNode.setVar(this.symTab.getVar(str));
|
|
} else if (this.jep.allowUndeclared) {
|
|
aSTVarNode.setVar(this.symTab.makeVarIfNeeded(str));
|
|
} else {
|
|
addToErrorList("Unrecognized symbol \"" + str + "\"");
|
|
}
|
|
} catch (Throwable throwable) {
|
|
if (bool) {
|
|
this.jjtree.clearNodeScope(aSTVarNode);
|
|
bool = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool)
|
|
this.jjtree.closeNodeScope(aSTVarNode, true);
|
|
}
|
|
}
|
|
|
|
public final void Function() throws ParseException {
|
|
int i = 0;
|
|
String str = "";
|
|
ASTFunNode aSTFunNode = new ASTFunNode(2);
|
|
boolean bool = true;
|
|
this.jjtree.openNodeScope(aSTFunNode);
|
|
try {
|
|
str = Identifier();
|
|
if (this.jep.funTab.containsKey(str)) {
|
|
i = this.jep.funTab.get(str).getNumberOfParameters();
|
|
aSTFunNode.setFunction(str, this.jep.funTab.get(str));
|
|
} else {
|
|
addToErrorList("!!! Unrecognized function \"" + str + "\"");
|
|
}
|
|
jj_consume_token(40);
|
|
ArgumentList(i, str);
|
|
jj_consume_token(41);
|
|
} catch (Throwable throwable) {
|
|
if (bool) {
|
|
this.jjtree.clearNodeScope(aSTFunNode);
|
|
bool = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool)
|
|
this.jjtree.closeNodeScope(aSTFunNode, true);
|
|
}
|
|
}
|
|
|
|
public final void ArgumentList(int paramInt, String paramString) throws ParseException {
|
|
byte b = 0;
|
|
String str = "";
|
|
if (jj_2_8(1)) {
|
|
Expression();
|
|
b++;
|
|
while (true) {
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 20:
|
|
break;
|
|
default:
|
|
this.jj_la1[18] = this.jj_gen;
|
|
break;
|
|
}
|
|
jj_consume_token(20);
|
|
Expression();
|
|
b++;
|
|
}
|
|
}
|
|
if (paramInt != b && paramInt != -1) {
|
|
str = "Function \"" + paramString + "\" requires " + paramInt + " parameter";
|
|
if (paramInt != 1)
|
|
str = str + "s";
|
|
addToErrorList(str);
|
|
}
|
|
}
|
|
|
|
public final String Identifier() throws ParseException {
|
|
Token token;
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 12:
|
|
token = jj_consume_token(12);
|
|
return token.image;
|
|
case 15:
|
|
token = jj_consume_token(15);
|
|
return token.image;
|
|
}
|
|
this.jj_la1[19] = this.jj_gen;
|
|
jj_consume_token(-1);
|
|
throw new ParseException();
|
|
}
|
|
|
|
public final void AnyConstant() throws ParseException {
|
|
ASTConstant aSTConstant = new ASTConstant(4);
|
|
boolean bool = true;
|
|
this.jjtree.openNodeScope(aSTConstant);
|
|
try {
|
|
Token token;
|
|
Object object;
|
|
String str;
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 11:
|
|
token = jj_consume_token(11);
|
|
this.jjtree.closeNodeScope(aSTConstant, true);
|
|
bool = false;
|
|
str = token.image.substring(1, token.image.length() - 1);
|
|
str = replaceEscape(str);
|
|
aSTConstant.setValue(str);
|
|
break;
|
|
case 7:
|
|
case 9:
|
|
object = RealConstant();
|
|
this.jjtree.closeNodeScope(aSTConstant, true);
|
|
bool = false;
|
|
aSTConstant.setValue(object);
|
|
break;
|
|
default:
|
|
this.jj_la1[20] = this.jj_gen;
|
|
jj_consume_token(-1);
|
|
throw new ParseException();
|
|
}
|
|
} catch (Throwable throwable) {
|
|
if (bool) {
|
|
this.jjtree.clearNodeScope(aSTConstant);
|
|
bool = false;
|
|
} else {
|
|
this.jjtree.popNode();
|
|
}
|
|
if (throwable instanceof RuntimeException)
|
|
throw (RuntimeException)throwable;
|
|
if (throwable instanceof ParseException)
|
|
throw (ParseException)throwable;
|
|
throw (Error)throwable;
|
|
} finally {
|
|
if (bool)
|
|
this.jjtree.closeNodeScope(aSTConstant, true);
|
|
}
|
|
}
|
|
|
|
public final Object RealConstant() throws ParseException {
|
|
Token token;
|
|
Object object;
|
|
switch ((this.jj_ntk == -1) ? jj_ntk() : this.jj_ntk) {
|
|
case 7:
|
|
token = jj_consume_token(7);
|
|
break;
|
|
case 9:
|
|
token = jj_consume_token(9);
|
|
break;
|
|
default:
|
|
this.jj_la1[21] = this.jj_gen;
|
|
jj_consume_token(-1);
|
|
throw new ParseException();
|
|
}
|
|
try {
|
|
object = this.jep.getNumberFactory().createNumber(token.image);
|
|
} catch (Exception exception) {
|
|
object = null;
|
|
addToErrorList("Can't parse \"" + token.image + "\"");
|
|
}
|
|
return object;
|
|
}
|
|
|
|
private final boolean jj_2_1(int paramInt) {
|
|
this.jj_la = paramInt;
|
|
this.jj_lastpos = this.jj_scanpos = this.token;
|
|
try {
|
|
return !jj_3_1();
|
|
} catch (LookaheadSuccess lookaheadSuccess) {
|
|
return true;
|
|
} finally {
|
|
jj_save(0, paramInt);
|
|
}
|
|
}
|
|
|
|
private final boolean jj_2_2(int paramInt) {
|
|
this.jj_la = paramInt;
|
|
this.jj_lastpos = this.jj_scanpos = this.token;
|
|
try {
|
|
return !jj_3_2();
|
|
} catch (LookaheadSuccess lookaheadSuccess) {
|
|
return true;
|
|
} finally {
|
|
jj_save(1, paramInt);
|
|
}
|
|
}
|
|
|
|
private final boolean jj_2_3(int paramInt) {
|
|
this.jj_la = paramInt;
|
|
this.jj_lastpos = this.jj_scanpos = this.token;
|
|
try {
|
|
return !jj_3_3();
|
|
} catch (LookaheadSuccess lookaheadSuccess) {
|
|
return true;
|
|
} finally {
|
|
jj_save(2, paramInt);
|
|
}
|
|
}
|
|
|
|
private final boolean jj_2_4(int paramInt) {
|
|
this.jj_la = paramInt;
|
|
this.jj_lastpos = this.jj_scanpos = this.token;
|
|
try {
|
|
return !jj_3_4();
|
|
} catch (LookaheadSuccess lookaheadSuccess) {
|
|
return true;
|
|
} finally {
|
|
jj_save(3, paramInt);
|
|
}
|
|
}
|
|
|
|
private final boolean jj_2_5(int paramInt) {
|
|
this.jj_la = paramInt;
|
|
this.jj_lastpos = this.jj_scanpos = this.token;
|
|
try {
|
|
return !jj_3_5();
|
|
} catch (LookaheadSuccess lookaheadSuccess) {
|
|
return true;
|
|
} finally {
|
|
jj_save(4, paramInt);
|
|
}
|
|
}
|
|
|
|
private final boolean jj_2_6(int paramInt) {
|
|
this.jj_la = paramInt;
|
|
this.jj_lastpos = this.jj_scanpos = this.token;
|
|
try {
|
|
return !jj_3_6();
|
|
} catch (LookaheadSuccess lookaheadSuccess) {
|
|
return true;
|
|
} finally {
|
|
jj_save(5, paramInt);
|
|
}
|
|
}
|
|
|
|
private final boolean jj_2_7(int paramInt) {
|
|
this.jj_la = paramInt;
|
|
this.jj_lastpos = this.jj_scanpos = this.token;
|
|
try {
|
|
return !jj_3_7();
|
|
} catch (LookaheadSuccess lookaheadSuccess) {
|
|
return true;
|
|
} finally {
|
|
jj_save(6, paramInt);
|
|
}
|
|
}
|
|
|
|
private final boolean jj_2_8(int paramInt) {
|
|
this.jj_la = paramInt;
|
|
this.jj_lastpos = this.jj_scanpos = this.token;
|
|
try {
|
|
return !jj_3_8();
|
|
} catch (LookaheadSuccess lookaheadSuccess) {
|
|
return true;
|
|
} finally {
|
|
jj_save(7, paramInt);
|
|
}
|
|
}
|
|
|
|
private final boolean jj_3R_10() {
|
|
return jj_3R_20() ? true : (jj_scan_token(18) ? true : (jj_3R_9()));
|
|
}
|
|
|
|
private final boolean jj_3_8() {
|
|
return jj_3R_9();
|
|
}
|
|
|
|
private final boolean jj_3R_32() {
|
|
return jj_3R_35();
|
|
}
|
|
|
|
private final boolean jj_3R_17() {
|
|
return jj_3R_22();
|
|
}
|
|
|
|
private final boolean jj_3_3() {
|
|
return jj_3R_11();
|
|
}
|
|
|
|
private final boolean jj_3R_36() {
|
|
Token token = this.jj_scanpos;
|
|
if (jj_scan_token(7)) {
|
|
this.jj_scanpos = token;
|
|
if (jj_scan_token(9))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private final boolean jj_3R_9() {
|
|
Token token = this.jj_scanpos;
|
|
if (jj_3_2()) {
|
|
this.jj_scanpos = token;
|
|
if (jj_3_3())
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private final boolean jj_3_2() {
|
|
return jj_3R_10();
|
|
}
|
|
|
|
private final boolean jj_3_6() {
|
|
return jj_3R_17();
|
|
}
|
|
|
|
private final boolean jj_3R_40() {
|
|
return jj_scan_token(35);
|
|
}
|
|
|
|
private final boolean jj_3R_39() {
|
|
return jj_scan_token(30);
|
|
}
|
|
|
|
private final boolean jj_3R_23() {
|
|
return jj_3R_24();
|
|
}
|
|
|
|
private final boolean jj_3R_38() {
|
|
return jj_scan_token(29);
|
|
}
|
|
|
|
private final boolean jj_3R_37() {
|
|
Token token = this.jj_scanpos;
|
|
if (jj_3R_38()) {
|
|
this.jj_scanpos = token;
|
|
if (jj_3R_39()) {
|
|
this.jj_scanpos = token;
|
|
if (jj_3R_40()) {
|
|
this.jj_scanpos = token;
|
|
if (jj_3_6())
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private final boolean jj_3_1() {
|
|
return jj_3R_9();
|
|
}
|
|
|
|
private final boolean jj_3R_29() {
|
|
return jj_3R_32();
|
|
}
|
|
|
|
private final boolean jj_3R_16() {
|
|
return jj_scan_token(34);
|
|
}
|
|
|
|
private final boolean jj_3R_15() {
|
|
return jj_scan_token(33);
|
|
}
|
|
|
|
private final boolean jj_3R_20() {
|
|
return jj_3R_24();
|
|
}
|
|
|
|
private final boolean jj_3R_14() {
|
|
return jj_scan_token(37);
|
|
}
|
|
|
|
private final boolean jj_3R_25() {
|
|
return jj_3R_29();
|
|
}
|
|
|
|
private final boolean jj_3R_34() {
|
|
return jj_3R_36();
|
|
}
|
|
|
|
private final boolean jj_3R_13() {
|
|
return jj_scan_token(32);
|
|
}
|
|
|
|
private final boolean jj_3R_31() {
|
|
return jj_scan_token(38);
|
|
}
|
|
|
|
private final boolean jj_3R_12() {
|
|
return jj_scan_token(31);
|
|
}
|
|
|
|
private final boolean jj_3R_19() {
|
|
return jj_3R_20();
|
|
}
|
|
|
|
private final boolean jj_3R_30() {
|
|
Token token = this.jj_scanpos;
|
|
if (jj_3R_33()) {
|
|
this.jj_scanpos = token;
|
|
if (jj_3R_34())
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private final boolean jj_3R_33() {
|
|
return jj_scan_token(11);
|
|
}
|
|
|
|
private final boolean jj_3R_28() {
|
|
return jj_3R_31();
|
|
}
|
|
|
|
private final boolean jj_3R_21() {
|
|
return jj_3R_25();
|
|
}
|
|
|
|
private final boolean jj_3R_27() {
|
|
return jj_scan_token(40);
|
|
}
|
|
|
|
private final boolean jj_3_4() {
|
|
Token token = this.jj_scanpos;
|
|
if (jj_3_5()) {
|
|
this.jj_scanpos = token;
|
|
if (jj_3R_12()) {
|
|
this.jj_scanpos = token;
|
|
if (jj_3R_13()) {
|
|
this.jj_scanpos = token;
|
|
if (jj_3R_14()) {
|
|
this.jj_scanpos = token;
|
|
if (jj_3R_15()) {
|
|
this.jj_scanpos = token;
|
|
if (jj_3R_16())
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private final boolean jj_3_5() {
|
|
return jj_3R_17();
|
|
}
|
|
|
|
private final boolean jj_3R_18() {
|
|
return jj_3R_23();
|
|
}
|
|
|
|
private final boolean jj_3R_24() {
|
|
Token token = this.jj_scanpos;
|
|
if (jj_scan_token(12)) {
|
|
this.jj_scanpos = token;
|
|
if (jj_scan_token(15))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private final boolean jj_3_7() {
|
|
Token token = this.jj_scanpos;
|
|
this.lookingAhead = true;
|
|
this.jj_semLA = (((getToken(1)).kind == 12 || (getToken(1)).kind == 15) && this.jep.funTab.containsKey((getToken(1)).image));
|
|
this.lookingAhead = false;
|
|
if (!this.jj_semLA || jj_3R_18()) {
|
|
this.jj_scanpos = token;
|
|
if (jj_3R_19())
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private final boolean jj_3R_35() {
|
|
return jj_3R_37();
|
|
}
|
|
|
|
private final boolean jj_3R_22() {
|
|
Token token = this.jj_scanpos;
|
|
if (jj_3R_26()) {
|
|
this.jj_scanpos = token;
|
|
if (jj_3_7()) {
|
|
this.jj_scanpos = token;
|
|
if (jj_3R_27()) {
|
|
this.jj_scanpos = token;
|
|
if (jj_3R_28())
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private final boolean jj_3R_26() {
|
|
return jj_3R_30();
|
|
}
|
|
|
|
private final boolean jj_3R_11() {
|
|
return jj_3R_21();
|
|
}
|
|
|
|
private static void jj_la1_0() {
|
|
jj_la1_0 = new int[] {
|
|
524289, 524289, 524289, 268435456, 134217728, 75497472, 75497472, 56623104, 56623104, 1610612736,
|
|
1610612736, Integer.MIN_VALUE, 1610612736, 0, 36864, 2688, 0, 1048576, 1048576, 36864,
|
|
2688, 640 };
|
|
}
|
|
|
|
private static void jj_la1_1() {
|
|
jj_la1_1 = new int[] {
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 39, 8, 16, 0, 0, 320, 0, 0, 0,
|
|
0, 0 };
|
|
}
|
|
|
|
public Parser(InputStream paramInputStream) {
|
|
this.jj_input_stream = new JavaCharStream(paramInputStream, 1, 1);
|
|
this.token_source = new ParserTokenManager(this.jj_input_stream);
|
|
this.token = new Token();
|
|
this.jj_ntk = -1;
|
|
this.jj_gen = 0;
|
|
byte b;
|
|
for (b = 0; b < 22; b++)
|
|
this.jj_la1[b] = -1;
|
|
for (b = 0; b < this.jj_2_rtns.length; b++)
|
|
this.jj_2_rtns[b] = new JJCalls();
|
|
}
|
|
|
|
public void ReInit(InputStream paramInputStream) {
|
|
this.jj_input_stream.ReInit(paramInputStream, 1, 1);
|
|
this.token_source.ReInit(this.jj_input_stream);
|
|
this.token = new Token();
|
|
this.jj_ntk = -1;
|
|
this.jjtree.reset();
|
|
this.jj_gen = 0;
|
|
byte b;
|
|
for (b = 0; b < 22; b++)
|
|
this.jj_la1[b] = -1;
|
|
for (b = 0; b < this.jj_2_rtns.length; b++)
|
|
this.jj_2_rtns[b] = new JJCalls();
|
|
}
|
|
|
|
public Parser(Reader paramReader) {
|
|
this.jj_input_stream = new JavaCharStream(paramReader, 1, 1);
|
|
this.token_source = new ParserTokenManager(this.jj_input_stream);
|
|
this.token = new Token();
|
|
this.jj_ntk = -1;
|
|
this.jj_gen = 0;
|
|
byte b;
|
|
for (b = 0; b < 22; b++)
|
|
this.jj_la1[b] = -1;
|
|
for (b = 0; b < this.jj_2_rtns.length; b++)
|
|
this.jj_2_rtns[b] = new JJCalls();
|
|
}
|
|
|
|
public void ReInit(Reader paramReader) {
|
|
this.jj_input_stream.ReInit(paramReader, 1, 1);
|
|
this.token_source.ReInit(this.jj_input_stream);
|
|
this.token = new Token();
|
|
this.jj_ntk = -1;
|
|
this.jjtree.reset();
|
|
this.jj_gen = 0;
|
|
byte b;
|
|
for (b = 0; b < 22; b++)
|
|
this.jj_la1[b] = -1;
|
|
for (b = 0; b < this.jj_2_rtns.length; b++)
|
|
this.jj_2_rtns[b] = new JJCalls();
|
|
}
|
|
|
|
public Parser(ParserTokenManager paramParserTokenManager) {
|
|
this.token_source = paramParserTokenManager;
|
|
this.token = new Token();
|
|
this.jj_ntk = -1;
|
|
this.jj_gen = 0;
|
|
byte b;
|
|
for (b = 0; b < 22; b++)
|
|
this.jj_la1[b] = -1;
|
|
for (b = 0; b < this.jj_2_rtns.length; b++)
|
|
this.jj_2_rtns[b] = new JJCalls();
|
|
}
|
|
|
|
public void ReInit(ParserTokenManager paramParserTokenManager) {
|
|
this.token_source = paramParserTokenManager;
|
|
this.token = new Token();
|
|
this.jj_ntk = -1;
|
|
this.jjtree.reset();
|
|
this.jj_gen = 0;
|
|
byte b;
|
|
for (b = 0; b < 22; b++)
|
|
this.jj_la1[b] = -1;
|
|
for (b = 0; b < this.jj_2_rtns.length; b++)
|
|
this.jj_2_rtns[b] = new JJCalls();
|
|
}
|
|
|
|
private final Token jj_consume_token(int paramInt) throws ParseException {
|
|
Token token;
|
|
if ((token = this.token).next != null) {
|
|
this.token = this.token.next;
|
|
} else {
|
|
this.token = this.token.next = this.token_source.getNextToken();
|
|
}
|
|
this.jj_ntk = -1;
|
|
if (this.token.kind == paramInt) {
|
|
this.jj_gen++;
|
|
if (++this.jj_gc > 100) {
|
|
this.jj_gc = 0;
|
|
for (byte b = 0; b < this.jj_2_rtns.length; b++) {
|
|
for (JJCalls jJCalls = this.jj_2_rtns[b]; jJCalls != null; jJCalls = jJCalls.next) {
|
|
if (jJCalls.gen < this.jj_gen)
|
|
jJCalls.first = null;
|
|
}
|
|
}
|
|
}
|
|
return this.token;
|
|
}
|
|
this.token = token;
|
|
this.jj_kind = paramInt;
|
|
throw generateParseException();
|
|
}
|
|
|
|
private final boolean jj_scan_token(int paramInt) {
|
|
if (this.jj_scanpos == this.jj_lastpos) {
|
|
this.jj_la--;
|
|
if (this.jj_scanpos.next == null) {
|
|
this.jj_lastpos = this.jj_scanpos = this.jj_scanpos.next = this.token_source.getNextToken();
|
|
} else {
|
|
this.jj_lastpos = this.jj_scanpos = this.jj_scanpos.next;
|
|
}
|
|
} else {
|
|
this.jj_scanpos = this.jj_scanpos.next;
|
|
}
|
|
if (this.jj_rescan) {
|
|
byte b = 0;
|
|
Token token;
|
|
for (token = this.token; token != null && token != this.jj_scanpos; token = token.next)
|
|
b++;
|
|
if (token != null)
|
|
jj_add_error_token(paramInt, b);
|
|
}
|
|
if (this.jj_scanpos.kind != paramInt)
|
|
return true;
|
|
if (this.jj_la == 0 && this.jj_scanpos == this.jj_lastpos)
|
|
throw this.jj_ls;
|
|
return false;
|
|
}
|
|
|
|
public final Token getNextToken() {
|
|
if (this.token.next != null) {
|
|
this.token = this.token.next;
|
|
} else {
|
|
this.token = this.token.next = this.token_source.getNextToken();
|
|
}
|
|
this.jj_ntk = -1;
|
|
this.jj_gen++;
|
|
return this.token;
|
|
}
|
|
|
|
public final Token getToken(int paramInt) {
|
|
Token token = this.lookingAhead ? this.jj_scanpos : this.token;
|
|
for (byte b = 0; b < paramInt; b++) {
|
|
if (token.next != null) {
|
|
token = token.next;
|
|
} else {
|
|
token = token.next = this.token_source.getNextToken();
|
|
}
|
|
}
|
|
return token;
|
|
}
|
|
|
|
private final int jj_ntk() {
|
|
return ((this.jj_nt = this.token.next) == null) ? (this.jj_ntk = (this.token.next = this.token_source.getNextToken()).kind) : (this.jj_ntk = this.jj_nt.kind);
|
|
}
|
|
|
|
private void jj_add_error_token(int paramInt1, int paramInt2) {
|
|
if (paramInt2 >= 100)
|
|
return;
|
|
if (paramInt2 == this.jj_endpos + 1) {
|
|
this.jj_lasttokens[this.jj_endpos++] = paramInt1;
|
|
} else if (this.jj_endpos != 0) {
|
|
this.jj_expentry = new int[this.jj_endpos];
|
|
byte b;
|
|
for (b = 0; b < this.jj_endpos; b++)
|
|
this.jj_expentry[b] = this.jj_lasttokens[b];
|
|
b = 0;
|
|
Enumeration enumeration = this.jj_expentries.elements();
|
|
while (enumeration.hasMoreElements()) {
|
|
int[] arrayOfInt = enumeration.nextElement();
|
|
if (arrayOfInt.length == this.jj_expentry.length) {
|
|
b = 1;
|
|
for (byte b1 = 0; b1 < this.jj_expentry.length; b1++) {
|
|
if (arrayOfInt[b1] != this.jj_expentry[b1]) {
|
|
b = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (b != 0)
|
|
break;
|
|
}
|
|
}
|
|
if (b == 0)
|
|
this.jj_expentries.addElement(this.jj_expentry);
|
|
if (paramInt2 != 0)
|
|
this.jj_lasttokens[(this.jj_endpos = paramInt2) - 1] = paramInt1;
|
|
}
|
|
}
|
|
|
|
public ParseException generateParseException() {
|
|
this.jj_expentries.removeAllElements();
|
|
boolean[] arrayOfBoolean = new boolean[42];
|
|
byte b1;
|
|
for (b1 = 0; b1 < 42; b1++)
|
|
arrayOfBoolean[b1] = false;
|
|
if (this.jj_kind >= 0) {
|
|
arrayOfBoolean[this.jj_kind] = true;
|
|
this.jj_kind = -1;
|
|
}
|
|
for (b1 = 0; b1 < 22; b1++) {
|
|
if (this.jj_la1[b1] == this.jj_gen)
|
|
for (byte b = 0; b < 32; b++) {
|
|
if ((jj_la1_0[b1] & 1 << b) != 0)
|
|
arrayOfBoolean[b] = true;
|
|
if ((jj_la1_1[b1] & 1 << b) != 0)
|
|
arrayOfBoolean[32 + b] = true;
|
|
}
|
|
}
|
|
for (b1 = 0; b1 < 42; b1++) {
|
|
if (arrayOfBoolean[b1]) {
|
|
this.jj_expentry = new int[1];
|
|
this.jj_expentry[0] = b1;
|
|
this.jj_expentries.addElement(this.jj_expentry);
|
|
}
|
|
}
|
|
this.jj_endpos = 0;
|
|
jj_rescan_token();
|
|
jj_add_error_token(0, 0);
|
|
int[][] arrayOfInt = new int[this.jj_expentries.size()][];
|
|
for (byte b2 = 0; b2 < this.jj_expentries.size(); b2++)
|
|
arrayOfInt[b2] = this.jj_expentries.elementAt(b2);
|
|
return new ParseException(this.token, arrayOfInt, ParserConstants.tokenImage);
|
|
}
|
|
|
|
public final void enable_tracing() {}
|
|
|
|
public final void disable_tracing() {}
|
|
|
|
private final void jj_rescan_token() {
|
|
this.jj_rescan = true;
|
|
byte b = 0;
|
|
while (b < 8) {
|
|
JJCalls jJCalls = this.jj_2_rtns[b];
|
|
while (true) {
|
|
if (jJCalls.gen > this.jj_gen) {
|
|
this.jj_la = jJCalls.arg;
|
|
this.jj_lastpos = this.jj_scanpos = jJCalls.first;
|
|
switch (b) {
|
|
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;
|
|
}
|
|
}
|
|
jJCalls = jJCalls.next;
|
|
if (jJCalls == null)
|
|
b++;
|
|
}
|
|
}
|
|
this.jj_rescan = false;
|
|
}
|
|
|
|
private final void jj_save(int paramInt1, int paramInt2) {
|
|
JJCalls jJCalls;
|
|
for (jJCalls = this.jj_2_rtns[paramInt1]; jJCalls.gen > this.jj_gen; jJCalls = jJCalls.next) {
|
|
if (jJCalls.next == null) {
|
|
jJCalls = jJCalls.next = new JJCalls();
|
|
break;
|
|
}
|
|
}
|
|
jJCalls.gen = this.jj_gen + paramInt2 - this.jj_la;
|
|
jJCalls.first = this.token;
|
|
jJCalls.arg = paramInt2;
|
|
}
|
|
|
|
static {
|
|
jj_la1_0();
|
|
jj_la1_1();
|
|
}
|
|
|
|
static final class JJCalls {
|
|
int gen;
|
|
|
|
Token first;
|
|
|
|
int arg;
|
|
|
|
JJCalls next;
|
|
}
|
|
|
|
private static final class LookaheadSuccess extends Error {
|
|
private LookaheadSuccess() {}
|
|
}
|
|
}
|