final /*package*/ void AdditiveExpression() throws ParseError {
Token t;
jjtree.openGTNode(ASTAdditiveExpression.jjtCreate("AdditiveExpression"));
MultiplicativeExpression();
if (jj_mask_24[getToken(1).kind]) {
if (jj_mask_23[getToken(1).kind]) {
jj_consume_token(PLUS);
} else {
jj_expLA1[23] = jj_gen;
if (jj_mask_22[getToken(1).kind]) {
jj_consume_token(MINUS);
} else {
jj_expLA1[22] = jj_gen;
jj_consume_token(-1);
throw new ParseError();
}
}
try {
ASTAdditiveExpression jjtThis = (ASTAdditiveExpression) jjtree.currentNode();
t = getToken(0);
jjtThis.setName(t.image);
} finally {
}
MultiplicativeExpression();
} else {
jj_expLA1[24] = jj_gen;
;
}
jjtree.closeGTNode(1);
jjtree.updateCurrentNode(1);
}
final /*package*/ void FromClause() throws ParseError {
jjtree.openIndefiniteNode(ASTFromClause.jjtCreate("FromClause"));
jj_consume_token(FROM);
RangeList();
jjtree.closeIndefiniteNode();
jjtree.updateCurrentNode(1);
}
final /*package*/ void Name() throws ParseError {
Token t;
if (jj_mask_43[getToken(1).kind]) {
jjtree.openIndefiniteNode(ASTName.jjtCreate("Name"));
t = jj_consume_token(IDENTIFIER);
jjtree.closeIndefiniteNode();
try {
ASTName jjtThis = (ASTName) jjtree.currentNode();
jjtThis.setName(t.image);
} finally {
jjtree.updateCurrentNode(1);
}
} else {
jj_expLA1[43] = jj_gen;
if (jj_mask_42[getToken(1).kind]) {
UnboundName();
} else {
jj_expLA1[42] = jj_gen;
if (jj_mask_41[getToken(1).kind]) {
UnboundIndex();
} else {
jj_expLA1[41] = jj_gen;
jj_consume_token(-1);
throw new ParseError();
}
}
}
}
final /*package*/ void WhereClause() throws ParseError {
jjtree.openIndefiniteNode(ASTWhereClause.jjtCreate("WhereClause"));
jj_consume_token(WHERE);
Condition();
jjtree.closeIndefiniteNode();
jjtree.updateCurrentNode(1);
}
final /*package*/ void Message() throws ParseError {
Token t;
jjtree.openIndefiniteNode(ASTMessage.jjtCreate("Message"));
if (jj_mask_45[getToken(1).kind]) {
jj_consume_token(DOT);
} else {
jj_expLA1[45] = jj_gen;
if (jj_mask_44[getToken(1).kind]) {
jj_consume_token(RARROW);
} else {
jj_expLA1[44] = jj_gen;
jj_consume_token(-1);
throw new ParseError();
}
}
t = jj_consume_token(IDENTIFIER);
try {
ASTMessage jjtThis = (ASTMessage) jjtree.currentNode();
jjtThis.setName(t.image);
} finally {
}
if (jj_mask_46[getToken(1).kind]) {
Arguments();
} else {
jj_expLA1[46] = jj_gen;
;
}
jjtree.closeIndefiniteNode();
jjtree.updateCurrentNode(1);
}
final /*package*/ void SelectClause() throws ParseError {
jjtree.openIndefiniteNode(ASTSelectClause.jjtCreate("SelectClause"));
jj_consume_token(SELECT);
ExpressionList();
jjtree.closeIndefiniteNode();
jjtree.updateCurrentNode(1);
}
final /*package*/ void FromQuery() throws ParseError {
jjtree.openIndefiniteNode(ASTFromQuery.jjtCreate("FromQuery"));
FromClause();
if (jj_mask_4[getToken(1).kind]) {
WhereClause();
} else {
jj_expLA1[4] = jj_gen;
;
}
jjtree.closeIndefiniteNode();
jjtree.updateCurrentNode(1);
}
final /*package*/ void LabeledExpression() throws ParseError {
jjtree.openGTNode(ASTLabeledExpression.jjtCreate("LabeledExpression"));
Expression();
if (jj_mask_9[getToken(1).kind]) {
jj_consume_token(AS);
Name();
} else {
jj_expLA1[9] = jj_gen;
;
}
jjtree.closeGTNode(1);
jjtree.updateCurrentNode(1);
}
final /*package*/ void UnboundName() throws ParseError {
Token t;
jjtree.openIndefiniteNode(ASTUnboundName.jjtCreate("UnboundName"));
jj_consume_token(COLON);
t = jj_consume_token(IDENTIFIER);
jjtree.closeIndefiniteNode();
try {
ASTUnboundName jjtThis = (ASTUnboundName) jjtree.currentNode();
jjtThis.setName(t.image);
} finally {
jjtree.updateCurrentNode(1);
}
}
final /*package*/ void UnboundIndex() throws ParseError {
Token t;
jjtree.openIndefiniteNode(ASTUnboundIndex.jjtCreate("UnboundIndex"));
jj_consume_token(DOLLAR);
t = jj_consume_token(INTEGER_LITERAL);
jjtree.closeIndefiniteNode();
try {
ASTUnboundIndex jjtThis = (ASTUnboundIndex) jjtree.currentNode();
jjtThis.setName(t.image);
} finally {
jjtree.updateCurrentNode(1);
}
}
final /*package*/ void Arguments() throws ParseError {
jjtree.openIndefiniteNode(ASTArguments.jjtCreate("Arguments"));
jj_consume_token(LPAREN);
if (jj_mask_47[getToken(1).kind]) {
ArgumentList();
} else {
jj_expLA1[47] = jj_gen;
;
}
jj_consume_token(RPAREN);
jjtree.closeIndefiniteNode();
jjtree.updateCurrentNode(1);
}
final /*package*/ void BooleanLiteral() throws ParseError {
Token t;
if (jj_mask_56[getToken(1).kind]) {
jjtree.openIndefiniteNode(ASTBooleanLiteralC.jjtCreate("BooleanLiteralC"));
t = jj_consume_token(TRUE);
jjtree.closeIndefiniteNode();
try {
ASTBooleanLiteralC jjtThis = (ASTBooleanLiteralC) jjtree.currentNode();
jjtThis.makeTrue();
} finally {
jjtree.updateCurrentNode(1);
}
} else {
jj_expLA1[56] = jj_gen;
if (jj_mask_55[getToken(1).kind]) {
jjtree.openIndefiniteNode(ASTBooleanLiteralC.jjtCreate("BooleanLiteralC"));
t = jj_consume_token(FALSE);
jjtree.closeIndefiniteNode();
try {
ASTBooleanLiteralC jjtThis = (ASTBooleanLiteralC) jjtree.currentNode();
jjtThis.makeFalse();
} finally {
jjtree.updateCurrentNode(1);
}
} else {
jj_expLA1[55] = jj_gen;
jj_consume_token(-1);
throw new ParseError();
}
}
}
// **********************************************************
final /*package*/ void MessageList() throws ParseError {
jjtree.openGTNode(ASTMessageList.jjtCreate("MessageList"));
Name();
label_6:
while (true) {
if (jj_mask_40[getToken(1).kind]) {;
} else {
jj_expLA1[40] = jj_gen;
break label_6;
}
Message();
}
jjtree.closeGTNode(1);
jjtree.updateCurrentNode(1);
}
final /*package*/ void ExclusiveOrCondition() throws ParseError {
jjtree.openGTNode(ASTExclusiveOrCondition.jjtCreate("ExclusiveOrCondition"));
AndCondition();
label_4:
while (true) {
if (jj_mask_11[getToken(1).kind]) {;
} else {
jj_expLA1[11] = jj_gen;
break label_4;
}
jj_consume_token(XOR);
AndCondition();
}
jjtree.closeGTNode(1);
jjtree.updateCurrentNode(1);
}
// **********************************************************
// **********************************************************
// **********************************************************
final /*package*/ void RangeList() throws ParseError {
jjtree.openIndefiniteNode(ASTRangeList.jjtCreate("RangeList"));
Range();
label_1:
while (true) {
if (jj_mask_5[getToken(1).kind]) {;
} else {
jj_expLA1[5] = jj_gen;
break label_1;
}
jj_consume_token(COMMA);
Range();
}
jjtree.closeIndefiniteNode();
jjtree.updateCurrentNode(1);
}
/*package*/ void ReInit(OqlParserTokenManager tm) {
token_source = tm;
token = new Token();
jjtree.reset();
jj_gen = 0;
for (int i = 0; i < 57; i++) jj_expLA1[i] = -1;
}
final /*package*/ void AndCondition() throws ParseError {
jjtree.openGTNode(ASTAndCondition.jjtCreate("AndCondition"));
ComparisonCondition();
label_5:
while (true) {
if (jj_mask_12[getToken(1).kind]) {;
} else {
jj_expLA1[12] = jj_gen;
break label_5;
}
jj_consume_token(AND);
ComparisonCondition();
}
jjtree.closeGTNode(1);
jjtree.updateCurrentNode(1);
}
final /*package*/ void ArgumentList() throws ParseError {
jjtree.openIndefiniteNode(ASTArgumentList.jjtCreate("ArgumentList"));
Expression();
label_7:
while (true) {
if (jj_mask_48[getToken(1).kind]) {;
} else {
jj_expLA1[48] = jj_gen;
break label_7;
}
jj_consume_token(COMMA);
Expression();
}
jjtree.closeIndefiniteNode();
jjtree.updateCurrentNode(1);
}
/*package*/ void ReInit(java.io.InputStream stream) {
ASCII_UCodeESC_CharStream input_stream = new ASCII_UCodeESC_CharStream(stream, 1, 1);
token_source.ReInit(input_stream);
token = new Token();
jjtree.reset();
jj_gen = 0;
for (int i = 0; i < 57; i++) jj_expLA1[i] = -1;
}
final /*package*/ void Range() throws ParseError {
jjtree.openIndefiniteNode(ASTRange.jjtCreate("Range"));
MessageList();
if (jj_mask_7[getToken(1).kind]) {
if (jj_mask_6[getToken(1).kind]) {
jj_consume_token(AS);
} else {
jj_expLA1[6] = jj_gen;
;
}
Name();
} else {
jj_expLA1[7] = jj_gen;
;
}
jjtree.closeIndefiniteNode();
jjtree.updateCurrentNode(1);
}
final /*package*/ void MultiplicativeExpression() throws ParseError {
Token t;
jjtree.openGTNode(ASTMultiplicativeExpression.jjtCreate("MultiplicativeExpression"));
UnarySignExpression();
if (jj_mask_28[getToken(1).kind]) {
if (jj_mask_27[getToken(1).kind]) {
jj_consume_token(TIMES);
} else {
jj_expLA1[27] = jj_gen;
if (jj_mask_26[getToken(1).kind]) {
jj_consume_token(DIVIDE);
} else {
jj_expLA1[26] = jj_gen;
if (jj_mask_25[getToken(1).kind]) {
jj_consume_token(REM);
} else {
jj_expLA1[25] = jj_gen;
jj_consume_token(-1);
throw new ParseError();
}
}
}
try {
ASTMultiplicativeExpression jjtThis = (ASTMultiplicativeExpression) jjtree.currentNode();
t = getToken(0);
jjtThis.setName(t.image);
} finally {
}
UnarySignExpression();
} else {
jj_expLA1[28] = jj_gen;
;
}
jjtree.closeGTNode(1);
jjtree.updateCurrentNode(1);
}
final /*package*/ void UnaryNotCondition() throws ParseError {
Token t;
if (jj_mask_36[getToken(1).kind]) {
jjtree.openIndefiniteNode(ASTUnaryNotCondition.jjtCreate("UnaryNotCondition"));
if (jj_mask_35[getToken(1).kind]) {
jj_consume_token(TILDE);
} else {
jj_expLA1[35] = jj_gen;
if (jj_mask_34[getToken(1).kind]) {
jj_consume_token(BANG);
} else {
jj_expLA1[34] = jj_gen;
jj_consume_token(-1);
throw new ParseError();
}
}
try {
ASTUnaryNotCondition jjtThis = (ASTUnaryNotCondition) jjtree.currentNode();
t = getToken(0);
jjtThis.setName(t.image);
} finally {
}
PrimaryPrefix();
jjtree.closeIndefiniteNode();
jjtree.updateCurrentNode(1);
} else {
jj_expLA1[36] = jj_gen;
if (jj_mask_33[getToken(1).kind]) {
PrimaryPrefix();
} else {
jj_expLA1[33] = jj_gen;
jj_consume_token(-1);
throw new ParseError();
}
}
}
final /*package*/ void UnarySignExpression() throws ParseError {
Token t;
if (jj_mask_32[getToken(1).kind]) {
jjtree.openIndefiniteNode(ASTUnarySignExpression.jjtCreate("UnarySignExpression"));
if (jj_mask_31[getToken(1).kind]) {
jj_consume_token(PLUS);
} else {
jj_expLA1[31] = jj_gen;
if (jj_mask_30[getToken(1).kind]) {
jj_consume_token(MINUS);
} else {
jj_expLA1[30] = jj_gen;
jj_consume_token(-1);
throw new ParseError();
}
}
try {
ASTUnarySignExpression jjtThis = (ASTUnarySignExpression) jjtree.currentNode();
t = getToken(0);
jjtThis.setName(t.image);
} finally {
}
UnaryNotCondition();
jjtree.closeIndefiniteNode();
jjtree.updateCurrentNode(1);
} else {
jj_expLA1[32] = jj_gen;
if (jj_mask_29[getToken(1).kind]) {
UnaryNotCondition();
} else {
jj_expLA1[29] = jj_gen;
jj_consume_token(-1);
throw new ParseError();
}
}
}
final /*package*/ void Literal() throws ParseError {
Token t;
if (jj_mask_54[getToken(1).kind]) {
jjtree.openIndefiniteNode(ASTIntegerLiteral.jjtCreate("IntegerLiteral"));
t = jj_consume_token(INTEGER_LITERAL);
jjtree.closeIndefiniteNode();
try {
ASTIntegerLiteral jjtThis = (ASTIntegerLiteral) jjtree.currentNode();
jjtThis.setName(t.image);
} finally {
jjtree.updateCurrentNode(1);
}
} else {
jj_expLA1[54] = jj_gen;
if (jj_mask_53[getToken(1).kind]) {
jjtree.openIndefiniteNode(ASTFloatingPointLiteral.jjtCreate("FloatingPointLiteral"));
t = jj_consume_token(FLOATING_POINT_LITERAL);
jjtree.closeIndefiniteNode();
try {
ASTFloatingPointLiteral jjtThis = (ASTFloatingPointLiteral) jjtree.currentNode();
jjtThis.setName(t.image);
} finally {
jjtree.updateCurrentNode(1);
}
} else {
jj_expLA1[53] = jj_gen;
if (jj_mask_52[getToken(1).kind]) {
jjtree.openIndefiniteNode(ASTStringLiteral.jjtCreate("StringLiteral"));
t = jj_consume_token(STRING_LITERAL2);
jjtree.closeIndefiniteNode();
try {
ASTStringLiteral jjtThis = (ASTStringLiteral) jjtree.currentNode();
jjtThis.setName(t.image);
} finally {
jjtree.updateCurrentNode(1);
}
} else {
jj_expLA1[52] = jj_gen;
if (jj_mask_51[getToken(1).kind]) {
jjtree.openIndefiniteNode(ASTStringLiteral.jjtCreate("StringLiteral"));
t = jj_consume_token(STRING_LITERAL);
jjtree.closeIndefiniteNode();
try {
ASTStringLiteral jjtThis = (ASTStringLiteral) jjtree.currentNode();
jjtThis.setName(t.image);
} finally {
jjtree.updateCurrentNode(1);
}
} else {
jj_expLA1[51] = jj_gen;
if (jj_mask_50[getToken(1).kind]) {
BooleanLiteral();
} else {
jj_expLA1[50] = jj_gen;
if (jj_mask_49[getToken(1).kind]) {
NullLiteral();
} else {
jj_expLA1[49] = jj_gen;
jj_consume_token(-1);
throw new ParseError();
}
}
}
}
}
}
}
final /*package*/ void NullLiteral() throws ParseError {
jjtree.openIndefiniteNode(ASTNullLiteralC.jjtCreate("NullLiteralC"));
jj_consume_token(NULL);
jjtree.closeIndefiniteNode();
jjtree.updateCurrentNode(1);
}
final /*package*/ void WhereQuery() throws ParseError {
jjtree.openIndefiniteNode(ASTWhereQuery.jjtCreate("WhereQuery"));
WhereClause();
jjtree.closeIndefiniteNode();
jjtree.updateCurrentNode(1);
}
final /*package*/ void ComparisonCondition() throws ParseError {
Token t;
jjtree.openGTNode(ASTComparisonCondition.jjtCreate("ComparisonCondition"));
AdditiveExpression();
if (jj_mask_21[getToken(1).kind]) {
if (jj_mask_20[getToken(1).kind]) {
jj_consume_token(EQ);
} else {
jj_expLA1[20] = jj_gen;
if (jj_mask_19[getToken(1).kind]) {
jj_consume_token(EQ2);
} else {
jj_expLA1[19] = jj_gen;
if (jj_mask_18[getToken(1).kind]) {
jj_consume_token(NE);
} else {
jj_expLA1[18] = jj_gen;
if (jj_mask_17[getToken(1).kind]) {
jj_consume_token(NE2);
} else {
jj_expLA1[17] = jj_gen;
if (jj_mask_16[getToken(1).kind]) {
jj_consume_token(LT);
} else {
jj_expLA1[16] = jj_gen;
if (jj_mask_15[getToken(1).kind]) {
jj_consume_token(GT);
} else {
jj_expLA1[15] = jj_gen;
if (jj_mask_14[getToken(1).kind]) {
jj_consume_token(LE);
} else {
jj_expLA1[14] = jj_gen;
if (jj_mask_13[getToken(1).kind]) {
jj_consume_token(GE);
} else {
jj_expLA1[13] = jj_gen;
jj_consume_token(-1);
throw new ParseError();
}
}
}
}
}
}
}
}
try {
ASTComparisonCondition jjtThis = (ASTComparisonCondition) jjtree.currentNode();
t = getToken(0);
jjtThis.setName(t.image);
} finally {
}
AdditiveExpression();
} else {
jj_expLA1[21] = jj_gen;
;
}
jjtree.closeGTNode(1);
jjtree.updateCurrentNode(1);
}
