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 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 FromClause() throws ParseError {
jjtree.openIndefiniteNode(ASTFromClause.jjtCreate("FromClause"));
jj_consume_token(FROM);
RangeList();
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 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 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 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 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 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 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);
}
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);
}
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 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 NullLiteral() throws ParseError {
jjtree.openIndefiniteNode(ASTNullLiteralC.jjtCreate("NullLiteralC"));
jj_consume_token(NULL);
jjtree.closeIndefiniteNode();
jjtree.updateCurrentNode(1);
}
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 WhereQuery() throws ParseError {
jjtree.openIndefiniteNode(ASTWhereQuery.jjtCreate("WhereQuery"));
WhereClause();
jjtree.closeIndefiniteNode();
jjtree.updateCurrentNode(1);
}
