// $ANTLR : "antlr.g" -> "ANTLRParser.java"$
package persistence.antlr;
import persistence.antlr.TokenBuffer;
import persistence.antlr.TokenStreamException;
import persistence.antlr.TokenStreamIOException;
import persistence.antlr.ANTLRException;
import persistence.antlr.LLkParser;
import persistence.antlr.Token;
import persistence.antlr.TokenStream;
import persistence.antlr.RecognitionException;
import persistence.antlr.NoViableAltException;
import persistence.antlr.MismatchedTokenException;
import persistence.antlr.SemanticException;
import persistence.antlr.ParserSharedInputState;
import persistence.antlr.collections.impl.BitSet;
import java.util.Enumeration;
import java.io.DataInputStream;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class ANTLRParser extends persistence.antlr.LLkParser implements ANTLRTokenTypes
{
private static final boolean DEBUG_PARSER = false;
ANTLRGrammarParseBehavior behavior;
Tool antlrTool;
protected int blockNesting= -1;
public ANTLRParser(
TokenBuffer tokenBuf,
ANTLRGrammarParseBehavior behavior_,
Tool tool_
) {
super(tokenBuf, 1);
tokenNames = _tokenNames;
behavior = behavior_;
antlrTool = tool_;
}
public void reportError(String s) {
antlrTool.error(s, getFilename(), -1, -1);
}
public void reportError(RecognitionException e) {
reportError(e, e.getErrorMessage());
}
public void reportError(RecognitionException e, String s) {
antlrTool.error(s, e.getFilename(), e.getLine(), e.getColumn());
}
public void reportWarning(String s) {
antlrTool.warning(s, getFilename(), -1, -1);
}
private boolean lastInRule() throws TokenStreamException {
if ( blockNesting==0 && (LA(1)==SEMI || LA(1)==LITERAL_exception || LA(1)==OR) ) {
return true;
}
return false;
}
private void checkForMissingEndRule(Token label) {
if ( label.getColumn()==1 ) {
antlrTool.warning("did you forget to terminate previous rule?", getFilename(), label.getLine(), label.getColumn());
}
}
protected ANTLRParser(TokenBuffer tokenBuf, int k) {
super(tokenBuf,k);
tokenNames = _tokenNames;
}
public ANTLRParser(TokenBuffer tokenBuf) {
this(tokenBuf,2);
}
protected ANTLRParser(TokenStream lexer, int k) {
super(lexer,k);
tokenNames = _tokenNames;
}
public ANTLRParser(TokenStream lexer) {
this(lexer,2);
}
public ANTLRParser(ParserSharedInputState state) {
super(state,2);
tokenNames = _tokenNames;
}
public final void grammar() throws RecognitionException, TokenStreamException {
Token n = null;
Token h = null;
try { // for error handling
{
_loop4:
do {
if ((LA(1)==LITERAL_header)) {
if ( inputState.guessing==0 ) {
n = null; // RK: prevent certain orders of header actions
// overwriting eachother.
}
match(LITERAL_header);
{
switch ( LA(1)) {
case STRING_LITERAL:
{
n = LT(1);
match(STRING_LITERAL);
break;
}
case ACTION:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
h = LT(1);
match(ACTION);
if ( inputState.guessing==0 ) {
// store the header action
// FIXME: 'n' should be checked for validity
behavior.refHeaderAction(n,h);
}
}
else {
break _loop4;
}
} while (true);
}
{
switch ( LA(1)) {
case OPTIONS:
{
fileOptionsSpec();
break;
}
case EOF:
case ACTION:
case DOC_COMMENT:
case LITERAL_lexclass:
case LITERAL_class:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
_loop7:
do {
if (((LA(1) >= ACTION && LA(1) <= LITERAL_class))) {
classDef();
}
else {
break _loop7;
}
} while (true);
}
match(Token.EOF_TYPE);
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
reportError(ex, "rule grammar trapped:\n"+ex.toString());
consumeUntil(EOF);
} else {
throw ex;
}
}
}
public final void fileOptionsSpec() throws RecognitionException, TokenStreamException {
Token idTok; Token value;
match(OPTIONS);
{
_loop18:
do {
if ((LA(1)==TOKEN_REF||LA(1)==RULE_REF)) {
idTok=id();
match(ASSIGN);
value=optionValue();
if ( inputState.guessing==0 ) {
behavior.setFileOption(idTok, value,getInputState().filename);
}
match(SEMI);
}
else {
break _loop18;
}
} while (true);
}
match(RCURLY);
}
public final void classDef() throws RecognitionException, TokenStreamException {
Token a = null;
Token d = null;
String doc=null;
try { // for error handling
{
switch ( LA(1)) {
case ACTION:
{
a = LT(1);
match(ACTION);
if ( inputState.guessing==0 ) {
behavior.refPreambleAction(a);
}
break;
}
case DOC_COMMENT:
case LITERAL_lexclass:
case LITERAL_class:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case DOC_COMMENT:
{
d = LT(1);
match(DOC_COMMENT);
if ( inputState.guessing==0 ) {
doc=d.getText();
}
break;
}
case LITERAL_lexclass:
case LITERAL_class:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
boolean synPredMatched13 = false;
if (((LA(1)==LITERAL_lexclass||LA(1)==LITERAL_class) && (LA(2)==TOKEN_REF||LA(2)==RULE_REF))) {
int _m13 = mark();
synPredMatched13 = true;
inputState.guessing++;
try {
{
switch ( LA(1)) {
case LITERAL_lexclass:
{
match(LITERAL_lexclass);
break;
}
case LITERAL_class:
{
match(LITERAL_class);
id();
match(LITERAL_extends);
match(LITERAL_Lexer);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
catch (RecognitionException pe) {
synPredMatched13 = false;
}
rewind(_m13);
inputState.guessing--;
}
if ( synPredMatched13 ) {
lexerSpec(doc);
}
else {
boolean synPredMatched15 = false;
if (((LA(1)==LITERAL_class) && (LA(2)==TOKEN_REF||LA(2)==RULE_REF))) {
int _m15 = mark();
synPredMatched15 = true;
inputState.guessing++;
try {
{
match(LITERAL_class);
id();
match(LITERAL_extends);
match(LITERAL_TreeParser);
}
}
catch (RecognitionException pe) {
synPredMatched15 = false;
}
rewind(_m15);
inputState.guessing--;
}
if ( synPredMatched15 ) {
treeParserSpec(doc);
}
else if ((LA(1)==LITERAL_class) && (LA(2)==TOKEN_REF||LA(2)==RULE_REF)) {
parserSpec(doc);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
rules();
if ( inputState.guessing==0 ) {
behavior.endGrammar();
}
}
catch (RecognitionException ex) {
if (inputState.guessing==0) {
if ( ex instanceof NoViableAltException ) {
NoViableAltException e = (NoViableAltException)ex;
// RK: These probably generate inconsequent error messages...
// have to see how this comes out..
if ( e.token.getType()==DOC_COMMENT ) {
reportError(ex, "JAVADOC comments may only prefix rules and grammars");
}
else {
reportError(ex, "rule classDef trapped:\n"+ex.toString());
}
}
else {
reportError(ex, "rule classDef trapped:\n"+ex.toString());
}
behavior.abortGrammar();
boolean consuming = true;
// consume everything until the next class definition or EOF
while (consuming) {
consume();
switch(LA(1)) {
case LITERAL_class:
case LITERAL_lexclass:
case EOF:
consuming = false;
break;
}
}
} else {
throw ex;
}
}
}
public final Token id() throws RecognitionException, TokenStreamException {
Token idTok ;
Token a = null;
Token b = null;
idTok = null;
switch ( LA(1)) {
case TOKEN_REF:
{
a = LT(1);
match(TOKEN_REF);
if ( inputState.guessing==0 ) {
idTok = a;
}
break;
}
case RULE_REF:
{
b = LT(1);
match(RULE_REF);
if ( inputState.guessing==0 ) {
idTok = b;
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
return idTok ;
}
public final void lexerSpec(
String doc
) throws RecognitionException, TokenStreamException {
Token lc = null;
Token a = null;
Token idTok;
String sup=null;
{
switch ( LA(1)) {
case LITERAL_lexclass:
{
lc = LT(1);
match(LITERAL_lexclass);
idTok=id();
if ( inputState.guessing==0 ) {
antlrTool.warning("lexclass' is deprecated; use 'class X extends Lexer'",
getFilename(), lc.getLine(), lc.getColumn());
// System.out.println("warning: line " + lc.getLine() + ": 'lexclass' is deprecated; use 'class X extends Lexer'");
}
break;
}
case LITERAL_class:
{
match(LITERAL_class);
idTok=id();
match(LITERAL_extends);
match(LITERAL_Lexer);
{
switch ( LA(1)) {
case LPAREN:
{
sup=superClass();
break;
}
case SEMI:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.startLexer(getFilename(), idTok,sup,doc);
}
match(SEMI);
{
switch ( LA(1)) {
case OPTIONS:
{
lexerOptionsSpec();
break;
}
case ACTION:
case DOC_COMMENT:
case TOKENS:
case TOKEN_REF:
case LITERAL_protected:
case LITERAL_public:
case LITERAL_private:
case RULE_REF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.endOptions();
}
{
switch ( LA(1)) {
case TOKENS:
{
tokensSpec();
break;
}
case ACTION:
case DOC_COMMENT:
case TOKEN_REF:
case LITERAL_protected:
case LITERAL_public:
case LITERAL_private:
case RULE_REF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case ACTION:
{
a = LT(1);
match(ACTION);
if ( inputState.guessing==0 ) {
behavior.refMemberAction(a);
}
break;
}
case DOC_COMMENT:
case TOKEN_REF:
case LITERAL_protected:
case LITERAL_public:
case LITERAL_private:
case RULE_REF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
public final void treeParserSpec(
String doc
) throws RecognitionException, TokenStreamException {
Token a = null;
Token idTok;
String sup=null;
match(LITERAL_class);
idTok=id();
match(LITERAL_extends);
match(LITERAL_TreeParser);
{
switch ( LA(1)) {
case LPAREN:
{
sup=superClass();
break;
}
case SEMI:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.startTreeWalker(getFilename(), idTok,sup,doc);
}
match(SEMI);
{
switch ( LA(1)) {
case OPTIONS:
{
treeParserOptionsSpec();
break;
}
case ACTION:
case DOC_COMMENT:
case TOKENS:
case TOKEN_REF:
case LITERAL_protected:
case LITERAL_public:
case LITERAL_private:
case RULE_REF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.endOptions();
}
{
switch ( LA(1)) {
case TOKENS:
{
tokensSpec();
break;
}
case ACTION:
case DOC_COMMENT:
case TOKEN_REF:
case LITERAL_protected:
case LITERAL_public:
case LITERAL_private:
case RULE_REF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case ACTION:
{
a = LT(1);
match(ACTION);
if ( inputState.guessing==0 ) {
behavior.refMemberAction(a);
}
break;
}
case DOC_COMMENT:
case TOKEN_REF:
case LITERAL_protected:
case LITERAL_public:
case LITERAL_private:
case RULE_REF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
public final void parserSpec(
String doc
) throws RecognitionException, TokenStreamException {
Token a = null;
Token idTok;
String sup=null;
match(LITERAL_class);
idTok=id();
{
switch ( LA(1)) {
case LITERAL_extends:
{
match(LITERAL_extends);
match(LITERAL_Parser);
{
switch ( LA(1)) {
case LPAREN:
{
sup=superClass();
break;
}
case SEMI:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case SEMI:
{
if ( inputState.guessing==0 ) {
antlrTool.warning("use 'class X extends Parser'", getFilename(), idTok.getLine(), idTok.getColumn());
// System.out.println("warning: line " +
// idTok.getLine() + ": use 'class X extends Parser'");
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.startParser(getFilename(), idTok, sup, doc);
}
match(SEMI);
{
switch ( LA(1)) {
case OPTIONS:
{
parserOptionsSpec();
break;
}
case ACTION:
case DOC_COMMENT:
case TOKENS:
case TOKEN_REF:
case LITERAL_protected:
case LITERAL_public:
case LITERAL_private:
case RULE_REF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.endOptions();
}
{
switch ( LA(1)) {
case TOKENS:
{
tokensSpec();
break;
}
case ACTION:
case DOC_COMMENT:
case TOKEN_REF:
case LITERAL_protected:
case LITERAL_public:
case LITERAL_private:
case RULE_REF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case ACTION:
{
a = LT(1);
match(ACTION);
if ( inputState.guessing==0 ) {
behavior.refMemberAction(a);
}
break;
}
case DOC_COMMENT:
case TOKEN_REF:
case LITERAL_protected:
case LITERAL_public:
case LITERAL_private:
case RULE_REF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
public final void rules() throws RecognitionException, TokenStreamException {
{
int _cnt68=0;
_loop68:
do {
if ((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {
rule();
}
else {
if ( _cnt68>=1 ) { break _loop68; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt68++;
} while (true);
}
}
public final Token optionValue() throws RecognitionException, TokenStreamException {
Token retval ;
Token sl = null;
Token cl = null;
Token il = null;
retval = null;
switch ( LA(1)) {
case TOKEN_REF:
case RULE_REF:
{
retval=qualifiedID();
break;
}
case STRING_LITERAL:
{
sl = LT(1);
match(STRING_LITERAL);
if ( inputState.guessing==0 ) {
retval = sl;
}
break;
}
case CHAR_LITERAL:
{
cl = LT(1);
match(CHAR_LITERAL);
if ( inputState.guessing==0 ) {
retval = cl;
}
break;
}
case INT:
{
il = LT(1);
match(INT);
if ( inputState.guessing==0 ) {
retval = il;
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
return retval ;
}
public final void parserOptionsSpec() throws RecognitionException, TokenStreamException {
Token idTok; Token value;
match(OPTIONS);
{
_loop21:
do {
if ((LA(1)==TOKEN_REF||LA(1)==RULE_REF)) {
idTok=id();
match(ASSIGN);
value=optionValue();
if ( inputState.guessing==0 ) {
behavior.setGrammarOption(idTok, value);
}
match(SEMI);
}
else {
break _loop21;
}
} while (true);
}
match(RCURLY);
}
public final void treeParserOptionsSpec() throws RecognitionException, TokenStreamException {
Token idTok; Token value;
match(OPTIONS);
{
_loop24:
do {
if ((LA(1)==TOKEN_REF||LA(1)==RULE_REF)) {
idTok=id();
match(ASSIGN);
value=optionValue();
if ( inputState.guessing==0 ) {
behavior.setGrammarOption(idTok, value);
}
match(SEMI);
}
else {
break _loop24;
}
} while (true);
}
match(RCURLY);
}
public final void lexerOptionsSpec() throws RecognitionException, TokenStreamException {
Token idTok; Token value; BitSet b;
match(OPTIONS);
{
_loop27:
do {
switch ( LA(1)) {
case LITERAL_charVocabulary:
{
match(LITERAL_charVocabulary);
match(ASSIGN);
b=charSet();
match(SEMI);
if ( inputState.guessing==0 ) {
behavior.setCharVocabulary(b);
}
break;
}
case TOKEN_REF:
case RULE_REF:
{
idTok=id();
match(ASSIGN);
value=optionValue();
if ( inputState.guessing==0 ) {
behavior.setGrammarOption(idTok, value);
}
match(SEMI);
break;
}
default:
{
break _loop27;
}
}
} while (true);
}
match(RCURLY);
}
public final BitSet charSet() throws RecognitionException, TokenStreamException {
BitSet b ;
b = null;
BitSet tmpSet = null;
b=setBlockElement();
{
_loop34:
do {
if ((LA(1)==OR)) {
match(OR);
tmpSet=setBlockElement();
if ( inputState.guessing==0 ) {
b.orInPlace(tmpSet);
}
}
else {
break _loop34;
}
} while (true);
}
return b ;
}
public final void subruleOptionsSpec() throws RecognitionException, TokenStreamException {
Token idTok; Token value;
match(OPTIONS);
{
_loop30:
do {
if ((LA(1)==TOKEN_REF||LA(1)==RULE_REF)) {
idTok=id();
match(ASSIGN);
value=optionValue();
if ( inputState.guessing==0 ) {
behavior.setSubruleOption(idTok, value);
}
match(SEMI);
}
else {
break _loop30;
}
} while (true);
}
match(RCURLY);
}
/** Match a.b.c.d qualified ids; WILDCARD here is overloaded as
* id separator; that is, I need a reference to the '.' token.
*/
public final Token qualifiedID() throws RecognitionException, TokenStreamException {
Token qidTok=null;
StringBuffer buf = new StringBuffer(30);
Token a;
a=id();
if ( inputState.guessing==0 ) {
buf.append(a.getText());
}
{
_loop144:
do {
if ((LA(1)==WILDCARD)) {
match(WILDCARD);
a=id();
if ( inputState.guessing==0 ) {
buf.append('.'); buf.append(a.getText());
}
}
else {
break _loop144;
}
} while (true);
}
if ( inputState.guessing==0 ) {
// can use either TOKEN_REF or RULE_REF; should
// really create a QID or something instead.
qidTok = new CommonToken(TOKEN_REF, buf.toString());
qidTok.setLine(a.getLine());
}
return qidTok;
}
public final BitSet setBlockElement() throws RecognitionException, TokenStreamException {
BitSet b ;
Token c1 = null;
Token c2 = null;
b = null;
int rangeMin = 0;
c1 = LT(1);
match(CHAR_LITERAL);
if ( inputState.guessing==0 ) {
rangeMin = ANTLRLexer.tokenTypeForCharLiteral(c1.getText());
b = BitSet.of(rangeMin);
}
{
switch ( LA(1)) {
case RANGE:
{
match(RANGE);
c2 = LT(1);
match(CHAR_LITERAL);
if ( inputState.guessing==0 ) {
int rangeMax = ANTLRLexer.tokenTypeForCharLiteral(c2.getText());
if (rangeMax < rangeMin) {
antlrTool.error("Malformed range line ", getFilename(), c1.getLine(), c1.getColumn());
}
for (int i = rangeMin+1; i <= rangeMax; i++) {
b.add(i);
}
}
break;
}
case SEMI:
case OR:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
return b ;
}
public final void tokensSpec() throws RecognitionException, TokenStreamException {
Token t1 = null;
Token s1 = null;
Token s3 = null;
match(TOKENS);
{
int _cnt43=0;
_loop43:
do {
if ((LA(1)==STRING_LITERAL||LA(1)==TOKEN_REF)) {
{
switch ( LA(1)) {
case TOKEN_REF:
{
if ( inputState.guessing==0 ) {
s1=null;
}
t1 = LT(1);
match(TOKEN_REF);
{
switch ( LA(1)) {
case ASSIGN:
{
match(ASSIGN);
s1 = LT(1);
match(STRING_LITERAL);
break;
}
case SEMI:
case OPEN_ELEMENT_OPTION:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.defineToken(t1, s1);
}
{
switch ( LA(1)) {
case OPEN_ELEMENT_OPTION:
{
tokensSpecOptions(t1);
break;
}
case SEMI:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case STRING_LITERAL:
{
s3 = LT(1);
match(STRING_LITERAL);
if ( inputState.guessing==0 ) {
behavior.defineToken(null, s3);
}
{
switch ( LA(1)) {
case OPEN_ELEMENT_OPTION:
{
tokensSpecOptions(s3);
break;
}
case SEMI:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(SEMI);
}
else {
if ( _cnt43>=1 ) { break _loop43; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt43++;
} while (true);
}
match(RCURLY);
}
public final void tokensSpecOptions(
Token t
) throws RecognitionException, TokenStreamException {
Token o=null, v=null;
match(OPEN_ELEMENT_OPTION);
o=id();
match(ASSIGN);
v=optionValue();
if ( inputState.guessing==0 ) {
behavior.refTokensSpecElementOption(t,o,v);
}
{
_loop46:
do {
if ((LA(1)==SEMI)) {
match(SEMI);
o=id();
match(ASSIGN);
v=optionValue();
if ( inputState.guessing==0 ) {
behavior.refTokensSpecElementOption(t,o,v);
}
}
else {
break _loop46;
}
} while (true);
}
match(CLOSE_ELEMENT_OPTION);
}
public final String superClass() throws RecognitionException, TokenStreamException {
String sup;
sup=null;
match(LPAREN);
if ( inputState.guessing==0 ) {
sup = LT(1).getText();
sup = StringUtils.stripFrontBack(sup, "\"", "\"");
}
{
match(STRING_LITERAL);
}
match(RPAREN);
return sup;
}
public final void rule() throws RecognitionException, TokenStreamException {
Token d = null;
Token p1 = null;
Token p2 = null;
Token p3 = null;
Token aa = null;
Token rt = null;
Token a = null;
String access="public";
Token idTok;
String doc=null;
boolean ruleAutoGen = true;
blockNesting = -1; // block increments, so -1 to make rule at level 0
{
switch ( LA(1)) {
case DOC_COMMENT:
{
d = LT(1);
match(DOC_COMMENT);
if ( inputState.guessing==0 ) {
doc=d.getText();
}
break;
}
case TOKEN_REF:
case LITERAL_protected:
case LITERAL_public:
case LITERAL_private:
case RULE_REF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case LITERAL_protected:
{
p1 = LT(1);
match(LITERAL_protected);
if ( inputState.guessing==0 ) {
access=p1.getText();
}
break;
}
case LITERAL_public:
{
p2 = LT(1);
match(LITERAL_public);
if ( inputState.guessing==0 ) {
access=p2.getText();
}
break;
}
case LITERAL_private:
{
p3 = LT(1);
match(LITERAL_private);
if ( inputState.guessing==0 ) {
access=p3.getText();
}
break;
}
case TOKEN_REF:
case RULE_REF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
idTok=id();
{
switch ( LA(1)) {
case BANG:
{
match(BANG);
if ( inputState.guessing==0 ) {
ruleAutoGen = false;
}
break;
}
case ACTION:
case OPTIONS:
case ARG_ACTION:
case LITERAL_returns:
case COLON:
case LITERAL_throws:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.defineRuleName(idTok, access, ruleAutoGen, doc);
}
{
switch ( LA(1)) {
case ARG_ACTION:
{
aa = LT(1);
match(ARG_ACTION);
if ( inputState.guessing==0 ) {
behavior.refArgAction(aa);
}
break;
}
case ACTION:
case OPTIONS:
case LITERAL_returns:
case COLON:
case LITERAL_throws:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case LITERAL_returns:
{
match(LITERAL_returns);
rt = LT(1);
match(ARG_ACTION);
if ( inputState.guessing==0 ) {
behavior.refReturnAction(rt);
}
break;
}
case ACTION:
case OPTIONS:
case COLON:
case LITERAL_throws:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case LITERAL_throws:
{
throwsSpec();
break;
}
case ACTION:
case OPTIONS:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case OPTIONS:
{
ruleOptionsSpec();
break;
}
case ACTION:
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case ACTION:
{
a = LT(1);
match(ACTION);
if ( inputState.guessing==0 ) {
behavior.refInitAction(a);
}
break;
}
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(COLON);
block();
match(SEMI);
{
switch ( LA(1)) {
case LITERAL_exception:
{
exceptionGroup();
break;
}
case EOF:
case ACTION:
case DOC_COMMENT:
case LITERAL_lexclass:
case LITERAL_class:
case TOKEN_REF:
case LITERAL_protected:
case LITERAL_public:
case LITERAL_private:
case RULE_REF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.endRule(idTok.getText());
}
}
public final void throwsSpec() throws RecognitionException, TokenStreamException {
String t=null;
Token a,b;
match(LITERAL_throws);
a=id();
if ( inputState.guessing==0 ) {
t=a.getText();
}
{
_loop84:
do {
if ((LA(1)==COMMA)) {
match(COMMA);
b=id();
if ( inputState.guessing==0 ) {
t+=","+b.getText();
}
}
else {
break _loop84;
}
} while (true);
}
if ( inputState.guessing==0 ) {
behavior.setUserExceptions(t);
}
}
public final void ruleOptionsSpec() throws RecognitionException, TokenStreamException {
Token idTok; Token value;
match(OPTIONS);
{
_loop81:
do {
if ((LA(1)==TOKEN_REF||LA(1)==RULE_REF)) {
idTok=id();
match(ASSIGN);
value=optionValue();
if ( inputState.guessing==0 ) {
behavior.setRuleOption(idTok, value);
}
match(SEMI);
}
else {
break _loop81;
}
} while (true);
}
match(RCURLY);
}
public final void block() throws RecognitionException, TokenStreamException {
if ( inputState.guessing==0 ) {
blockNesting++;
}
alternative();
{
_loop87:
do {
if ((LA(1)==OR)) {
match(OR);
alternative();
}
else {
break _loop87;
}
} while (true);
}
if ( inputState.guessing==0 ) {
blockNesting--;
}
}
public final void exceptionGroup() throws RecognitionException, TokenStreamException {
if ( inputState.guessing==0 ) {
behavior.beginExceptionGroup();
}
{
int _cnt95=0;
_loop95:
do {
if ((LA(1)==LITERAL_exception)) {
exceptionSpec();
}
else {
if ( _cnt95>=1 ) { break _loop95; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt95++;
} while (true);
}
if ( inputState.guessing==0 ) {
behavior.endExceptionGroup();
}
}
public final void alternative() throws RecognitionException, TokenStreamException {
boolean altAutoGen = true;
{
switch ( LA(1)) {
case BANG:
{
match(BANG);
if ( inputState.guessing==0 ) {
altAutoGen=false;
}
break;
}
case STRING_LITERAL:
case ACTION:
case SEMI:
case CHAR_LITERAL:
case OR:
case TOKEN_REF:
case LPAREN:
case RPAREN:
case LITERAL_exception:
case RULE_REF:
case NOT_OP:
case SEMPRED:
case TREE_BEGIN:
case WILDCARD:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.beginAlt(altAutoGen);
}
{
_loop91:
do {
if ((_tokenSet_2.member(LA(1)))) {
element();
}
else {
break _loop91;
}
} while (true);
}
{
switch ( LA(1)) {
case LITERAL_exception:
{
exceptionSpecNoLabel();
break;
}
case SEMI:
case OR:
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.endAlt();
}
}
public final void element() throws RecognitionException, TokenStreamException {
elementNoOptionSpec();
{
switch ( LA(1)) {
case OPEN_ELEMENT_OPTION:
{
elementOptionSpec();
break;
}
case STRING_LITERAL:
case ACTION:
case SEMI:
case CHAR_LITERAL:
case OR:
case TOKEN_REF:
case LPAREN:
case RPAREN:
case LITERAL_exception:
case RULE_REF:
case NOT_OP:
case SEMPRED:
case TREE_BEGIN:
case WILDCARD:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
public final void exceptionSpecNoLabel() throws RecognitionException, TokenStreamException {
match(LITERAL_exception);
if ( inputState.guessing==0 ) {
behavior.beginExceptionSpec(null);
}
{
_loop102:
do {
if ((LA(1)==LITERAL_catch)) {
exceptionHandler();
}
else {
break _loop102;
}
} while (true);
}
if ( inputState.guessing==0 ) {
behavior.endExceptionSpec();
}
}
public final void exceptionSpec() throws RecognitionException, TokenStreamException {
Token aa = null;
Token labelAction = null;
match(LITERAL_exception);
{
switch ( LA(1)) {
case ARG_ACTION:
{
aa = LT(1);
match(ARG_ACTION);
if ( inputState.guessing==0 ) {
labelAction = aa;
}
break;
}
case EOF:
case ACTION:
case DOC_COMMENT:
case LITERAL_lexclass:
case LITERAL_class:
case TOKEN_REF:
case LITERAL_protected:
case LITERAL_public:
case LITERAL_private:
case LITERAL_exception:
case LITERAL_catch:
case RULE_REF:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.beginExceptionSpec(labelAction);
}
{
_loop99:
do {
if ((LA(1)==LITERAL_catch)) {
exceptionHandler();
}
else {
break _loop99;
}
} while (true);
}
if ( inputState.guessing==0 ) {
behavior.endExceptionSpec();
}
}
public final void exceptionHandler() throws RecognitionException, TokenStreamException {
Token a1 = null;
Token a2 = null;
Token exType; Token exName;
match(LITERAL_catch);
a1 = LT(1);
match(ARG_ACTION);
a2 = LT(1);
match(ACTION);
if ( inputState.guessing==0 ) {
behavior.refExceptionHandler(a1, a2);
}
}
public final void elementNoOptionSpec() throws RecognitionException, TokenStreamException {
Token rr = null;
Token aa = null;
Token tr = null;
Token aa2 = null;
Token r2 = null;
Token aa3 = null;
Token a = null;
Token p = null;
Token label = null;
Token assignId = null;
Token args = null;
int autoGen = GrammarElement.AUTO_GEN_NONE;
switch ( LA(1)) {
case ACTION:
{
a = LT(1);
match(ACTION);
if ( inputState.guessing==0 ) {
behavior.refAction(a);
}
break;
}
case SEMPRED:
{
p = LT(1);
match(SEMPRED);
if ( inputState.guessing==0 ) {
behavior.refSemPred(p);
}
break;
}
case TREE_BEGIN:
{
tree();
break;
}
default:
if ((LA(1)==TOKEN_REF||LA(1)==RULE_REF) && (LA(2)==ASSIGN)) {
assignId=id();
match(ASSIGN);
{
if ((LA(1)==TOKEN_REF||LA(1)==RULE_REF) && (LA(2)==COLON)) {
label=id();
match(COLON);
if ( inputState.guessing==0 ) {
checkForMissingEndRule(label);
}
}
else if ((LA(1)==TOKEN_REF||LA(1)==RULE_REF) && (_tokenSet_3.member(LA(2)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case RULE_REF:
{
rr = LT(1);
match(RULE_REF);
{
switch ( LA(1)) {
case ARG_ACTION:
{
aa = LT(1);
match(ARG_ACTION);
if ( inputState.guessing==0 ) {
args=aa;
}
break;
}
case STRING_LITERAL:
case ACTION:
case SEMI:
case CHAR_LITERAL:
case OR:
case TOKEN_REF:
case OPEN_ELEMENT_OPTION:
case LPAREN:
case RPAREN:
case BANG:
case LITERAL_exception:
case RULE_REF:
case NOT_OP:
case SEMPRED:
case TREE_BEGIN:
case WILDCARD:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case BANG:
{
match(BANG);
if ( inputState.guessing==0 ) {
autoGen = GrammarElement.AUTO_GEN_BANG;
}
break;
}
case STRING_LITERAL:
case ACTION:
case SEMI:
case CHAR_LITERAL:
case OR:
case TOKEN_REF:
case OPEN_ELEMENT_OPTION:
case LPAREN:
case RPAREN:
case LITERAL_exception:
case RULE_REF:
case NOT_OP:
case SEMPRED:
case TREE_BEGIN:
case WILDCARD:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.refRule(assignId, rr, label, args, autoGen);
}
break;
}
case TOKEN_REF:
{
tr = LT(1);
match(TOKEN_REF);
{
switch ( LA(1)) {
case ARG_ACTION:
{
aa2 = LT(1);
match(ARG_ACTION);
if ( inputState.guessing==0 ) {
args=aa2;
}
break;
}
case STRING_LITERAL:
case ACTION:
case SEMI:
case CHAR_LITERAL:
case OR:
case TOKEN_REF:
case OPEN_ELEMENT_OPTION:
case LPAREN:
case RPAREN:
case LITERAL_exception:
case RULE_REF:
case NOT_OP:
case SEMPRED:
case TREE_BEGIN:
case WILDCARD:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.refToken(assignId, tr, label, args, false, autoGen, lastInRule());
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else if ((_tokenSet_4.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
{
if ((LA(1)==TOKEN_REF||LA(1)==RULE_REF) && (LA(2)==COLON)) {
label=id();
match(COLON);
if ( inputState.guessing==0 ) {
checkForMissingEndRule(label);
}
}
else if ((_tokenSet_4.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
{
switch ( LA(1)) {
case RULE_REF:
{
r2 = LT(1);
match(RULE_REF);
{
switch ( LA(1)) {
case ARG_ACTION:
{
aa3 = LT(1);
match(ARG_ACTION);
if ( inputState.guessing==0 ) {
args=aa3;
}
break;
}
case STRING_LITERAL:
case ACTION:
case SEMI:
case CHAR_LITERAL:
case OR:
case TOKEN_REF:
case OPEN_ELEMENT_OPTION:
case LPAREN:
case RPAREN:
case BANG:
case LITERAL_exception:
case RULE_REF:
case NOT_OP:
case SEMPRED:
case TREE_BEGIN:
case WILDCARD:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case BANG:
{
match(BANG);
if ( inputState.guessing==0 ) {
autoGen = GrammarElement.AUTO_GEN_BANG;
}
break;
}
case STRING_LITERAL:
case ACTION:
case SEMI:
case CHAR_LITERAL:
case OR:
case TOKEN_REF:
case OPEN_ELEMENT_OPTION:
case LPAREN:
case RPAREN:
case LITERAL_exception:
case RULE_REF:
case NOT_OP:
case SEMPRED:
case TREE_BEGIN:
case WILDCARD:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.refRule(assignId, r2, label, args, autoGen);
}
break;
}
case NOT_OP:
{
match(NOT_OP);
{
switch ( LA(1)) {
case CHAR_LITERAL:
case TOKEN_REF:
{
notTerminal(label);
break;
}
case LPAREN:
{
ebnf(label,true);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case LPAREN:
{
ebnf(label,false);
break;
}
default:
if ((LA(1)==STRING_LITERAL||LA(1)==CHAR_LITERAL||LA(1)==TOKEN_REF) && (LA(2)==RANGE)) {
range(label);
}
else if ((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2)))) {
terminal(label);
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
public final void elementOptionSpec() throws RecognitionException, TokenStreamException {
Token o=null, v=null;
match(OPEN_ELEMENT_OPTION);
o=id();
match(ASSIGN);
v=optionValue();
if ( inputState.guessing==0 ) {
behavior.refElementOption(o,v);
}
{
_loop108:
do {
if ((LA(1)==SEMI)) {
match(SEMI);
o=id();
match(ASSIGN);
v=optionValue();
if ( inputState.guessing==0 ) {
behavior.refElementOption(o,v);
}
}
else {
break _loop108;
}
} while (true);
}
match(CLOSE_ELEMENT_OPTION);
}
public final void range(
Token label
) throws RecognitionException, TokenStreamException {
Token crLeft = null;
Token crRight = null;
Token t = null;
Token u = null;
Token v = null;
Token w = null;
Token trLeft=null;
Token trRight=null;
int autoGen=GrammarElement.AUTO_GEN_NONE;
switch ( LA(1)) {
case CHAR_LITERAL:
{
crLeft = LT(1);
match(CHAR_LITERAL);
match(RANGE);
crRight = LT(1);
match(CHAR_LITERAL);
{
switch ( LA(1)) {
case BANG:
{
match(BANG);
if ( inputState.guessing==0 ) {
autoGen = GrammarElement.AUTO_GEN_BANG;
}
break;
}
case STRING_LITERAL:
case ACTION:
case SEMI:
case CHAR_LITERAL:
case OR:
case TOKEN_REF:
case OPEN_ELEMENT_OPTION:
case LPAREN:
case RPAREN:
case LITERAL_exception:
case RULE_REF:
case NOT_OP:
case SEMPRED:
case TREE_BEGIN:
case WILDCARD:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.refCharRange(crLeft, crRight, label, autoGen, lastInRule());
}
break;
}
case STRING_LITERAL:
case TOKEN_REF:
{
{
switch ( LA(1)) {
case TOKEN_REF:
{
t = LT(1);
match(TOKEN_REF);
if ( inputState.guessing==0 ) {
trLeft=t;
}
break;
}
case STRING_LITERAL:
{
u = LT(1);
match(STRING_LITERAL);
if ( inputState.guessing==0 ) {
trLeft=u;
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(RANGE);
{
switch ( LA(1)) {
case TOKEN_REF:
{
v = LT(1);
match(TOKEN_REF);
if ( inputState.guessing==0 ) {
trRight=v;
}
break;
}
case STRING_LITERAL:
{
w = LT(1);
match(STRING_LITERAL);
if ( inputState.guessing==0 ) {
trRight=w;
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
autoGen=ast_type_spec();
if ( inputState.guessing==0 ) {
behavior.refTokenRange(trLeft, trRight, label, autoGen, lastInRule());
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
public final void terminal(
Token label
) throws RecognitionException, TokenStreamException {
Token cl = null;
Token tr = null;
Token aa = null;
Token sl = null;
Token wi = null;
int autoGen=GrammarElement.AUTO_GEN_NONE;
Token args=null;
switch ( LA(1)) {
case CHAR_LITERAL:
{
cl = LT(1);
match(CHAR_LITERAL);
{
switch ( LA(1)) {
case BANG:
{
match(BANG);
if ( inputState.guessing==0 ) {
autoGen = GrammarElement.AUTO_GEN_BANG;
}
break;
}
case STRING_LITERAL:
case ACTION:
case SEMI:
case CHAR_LITERAL:
case OR:
case TOKEN_REF:
case OPEN_ELEMENT_OPTION:
case LPAREN:
case RPAREN:
case LITERAL_exception:
case RULE_REF:
case NOT_OP:
case SEMPRED:
case TREE_BEGIN:
case WILDCARD:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.refCharLiteral(cl, label, false, autoGen, lastInRule());
}
break;
}
case TOKEN_REF:
{
tr = LT(1);
match(TOKEN_REF);
autoGen=ast_type_spec();
{
switch ( LA(1)) {
case ARG_ACTION:
{
aa = LT(1);
match(ARG_ACTION);
if ( inputState.guessing==0 ) {
args=aa;
}
break;
}
case STRING_LITERAL:
case ACTION:
case SEMI:
case CHAR_LITERAL:
case OR:
case TOKEN_REF:
case OPEN_ELEMENT_OPTION:
case LPAREN:
case RPAREN:
case LITERAL_exception:
case RULE_REF:
case NOT_OP:
case SEMPRED:
case TREE_BEGIN:
case WILDCARD:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.refToken(null, tr, label, args, false, autoGen, lastInRule());
}
break;
}
case STRING_LITERAL:
{
sl = LT(1);
match(STRING_LITERAL);
autoGen=ast_type_spec();
if ( inputState.guessing==0 ) {
behavior.refStringLiteral(sl, label, autoGen, lastInRule());
}
break;
}
case WILDCARD:
{
wi = LT(1);
match(WILDCARD);
autoGen=ast_type_spec();
if ( inputState.guessing==0 ) {
behavior.refWildcard(wi, label, autoGen);
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
public final void notTerminal(
Token label
) throws RecognitionException, TokenStreamException {
Token cl = null;
Token tr = null;
int autoGen=GrammarElement.AUTO_GEN_NONE;
switch ( LA(1)) {
case CHAR_LITERAL:
{
cl = LT(1);
match(CHAR_LITERAL);
{
switch ( LA(1)) {
case BANG:
{
match(BANG);
if ( inputState.guessing==0 ) {
autoGen = GrammarElement.AUTO_GEN_BANG;
}
break;
}
case STRING_LITERAL:
case ACTION:
case SEMI:
case CHAR_LITERAL:
case OR:
case TOKEN_REF:
case OPEN_ELEMENT_OPTION:
case LPAREN:
case RPAREN:
case LITERAL_exception:
case RULE_REF:
case NOT_OP:
case SEMPRED:
case TREE_BEGIN:
case WILDCARD:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.refCharLiteral(cl, label, true, autoGen, lastInRule());
}
break;
}
case TOKEN_REF:
{
tr = LT(1);
match(TOKEN_REF);
autoGen=ast_type_spec();
if ( inputState.guessing==0 ) {
behavior.refToken(null, tr, label, null, true, autoGen, lastInRule());
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
public final void ebnf(
Token label, boolean not
) throws RecognitionException, TokenStreamException {
Token lp = null;
Token aa = null;
Token ab = null;
lp = LT(1);
match(LPAREN);
if ( inputState.guessing==0 ) {
behavior.beginSubRule(label, lp, not);
}
{
if ((LA(1)==OPTIONS)) {
subruleOptionsSpec();
{
switch ( LA(1)) {
case ACTION:
{
aa = LT(1);
match(ACTION);
if ( inputState.guessing==0 ) {
behavior.refInitAction(aa);
}
break;
}
case COLON:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(COLON);
}
else if ((LA(1)==ACTION) && (LA(2)==COLON)) {
ab = LT(1);
match(ACTION);
if ( inputState.guessing==0 ) {
behavior.refInitAction(ab);
}
match(COLON);
}
else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
block();
match(RPAREN);
{
switch ( LA(1)) {
case STRING_LITERAL:
case ACTION:
case SEMI:
case CHAR_LITERAL:
case OR:
case TOKEN_REF:
case OPEN_ELEMENT_OPTION:
case LPAREN:
case RPAREN:
case BANG:
case LITERAL_exception:
case RULE_REF:
case NOT_OP:
case SEMPRED:
case TREE_BEGIN:
case QUESTION:
case STAR:
case PLUS:
case WILDCARD:
{
{
switch ( LA(1)) {
case QUESTION:
{
match(QUESTION);
if ( inputState.guessing==0 ) {
behavior.optionalSubRule();
}
break;
}
case STAR:
{
match(STAR);
if ( inputState.guessing==0 ) {
behavior.zeroOrMoreSubRule();
}
break;
}
case PLUS:
{
match(PLUS);
if ( inputState.guessing==0 ) {
behavior.oneOrMoreSubRule();
}
break;
}
case STRING_LITERAL:
case ACTION:
case SEMI:
case CHAR_LITERAL:
case OR:
case TOKEN_REF:
case OPEN_ELEMENT_OPTION:
case LPAREN:
case RPAREN:
case BANG:
case LITERAL_exception:
case RULE_REF:
case NOT_OP:
case SEMPRED:
case TREE_BEGIN:
case WILDCARD:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1)) {
case BANG:
{
match(BANG);
if ( inputState.guessing==0 ) {
behavior.noASTSubRule();
}
break;
}
case STRING_LITERAL:
case ACTION:
case SEMI:
case CHAR_LITERAL:
case OR:
case TOKEN_REF:
case OPEN_ELEMENT_OPTION:
case LPAREN:
case RPAREN:
case LITERAL_exception:
case RULE_REF:
case NOT_OP:
case SEMPRED:
case TREE_BEGIN:
case WILDCARD:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case IMPLIES:
{
match(IMPLIES);
if ( inputState.guessing==0 ) {
behavior.synPred();
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if ( inputState.guessing==0 ) {
behavior.endSubRule();
}
}
public final void tree() throws RecognitionException, TokenStreamException {
Token lp = null;
lp = LT(1);
match(TREE_BEGIN);
if ( inputState.guessing==0 ) {
behavior.beginTree(lp);
}
rootNode();
if ( inputState.guessing==0 ) {
behavior.beginChildList();
}
{
int _cnt122=0;
_loop122:
do {
if ((_tokenSet_2.member(LA(1)))) {
element();
}
else {
if ( _cnt122>=1 ) { break _loop122; } else {throw new NoViableAltException(LT(1), getFilename());}
}
_cnt122++;
} while (true);
}
if ( inputState.guessing==0 ) {
behavior.endChildList();
}
match(RPAREN);
if ( inputState.guessing==0 ) {
behavior.endTree();
}
}
public final void rootNode() throws RecognitionException, TokenStreamException {
Token label = null;
{
if ((LA(1)==TOKEN_REF||LA(1)==RULE_REF) && (LA(2)==COLON)) {
label=id();
match(COLON);
if ( inputState.guessing==0 ) {
checkForMissingEndRule(label);
}
}
else if ((_tokenSet_7.member(LA(1))) && (_tokenSet_11.member(LA(2)))) {
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
terminal(label);
}
public final int ast_type_spec() throws RecognitionException, TokenStreamException {
int autoGen ;
autoGen = GrammarElement.AUTO_GEN_NONE;
{
switch ( LA(1)) {
case CARET:
{
match(CARET);
if ( inputState.guessing==0 ) {
autoGen = GrammarElement.AUTO_GEN_CARET;
}
break;
}
case BANG:
{
match(BANG);
if ( inputState.guessing==0 ) {
autoGen = GrammarElement.AUTO_GEN_BANG;
}
break;
}
case STRING_LITERAL:
case ACTION:
case SEMI:
case CHAR_LITERAL:
case OR:
case TOKEN_REF:
case OPEN_ELEMENT_OPTION:
case LPAREN:
case RPAREN:
case ARG_ACTION:
case LITERAL_exception:
case RULE_REF:
case NOT_OP:
case SEMPRED:
case TREE_BEGIN:
case WILDCARD:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
return autoGen ;
}
public static final String[] _tokenNames = {
"<0>",
"EOF",
"<2>",
"NULL_TREE_LOOKAHEAD",
"\"tokens\"",
"\"header\"",
"STRING_LITERAL",
"ACTION",
"DOC_COMMENT",
"\"lexclass\"",
"\"class\"",
"\"extends\"",
"\"Lexer\"",
"\"TreeParser\"",
"OPTIONS",
"ASSIGN",
"SEMI",
"RCURLY",
"\"charVocabulary\"",
"CHAR_LITERAL",
"INT",
"OR",
"RANGE",
"TOKENS",
"TOKEN_REF",
"OPEN_ELEMENT_OPTION",
"CLOSE_ELEMENT_OPTION",
"LPAREN",
"RPAREN",
"\"Parser\"",
"\"protected\"",
"\"public\"",
"\"private\"",
"BANG",
"ARG_ACTION",
"\"returns\"",
"COLON",
"\"throws\"",
"COMMA",
"\"exception\"",
"\"catch\"",
"RULE_REF",
"NOT_OP",
"SEMPRED",
"TREE_BEGIN",
"QUESTION",
"STAR",
"PLUS",
"IMPLIES",
"CARET",
"WILDCARD",
"\"options\"",
"WS",
"COMMENT",
"SL_COMMENT",
"ML_COMMENT",
"ESC",
"DIGIT",
"XDIGIT",
"NESTED_ARG_ACTION",
"NESTED_ACTION",
"WS_LOOP",
"INTERNAL_RULE_REF",
"WS_OPT"
};
private static final long[] mk_tokenSet_0() {
long[] data = { 2206556225792L, 0L};
return data;
}
public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
private static final long[] mk_tokenSet_1() {
long[] data = { 2472844214400L, 0L};
return data;
}
public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
private static final long[] mk_tokenSet_2() {
long[] data = { 1158885407195328L, 0L};
return data;
}
public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
private static final long[] mk_tokenSet_3() {
long[] data = { 1159461236965568L, 0L};
return data;
}
public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
private static final long[] mk_tokenSet_4() {
long[] data = { 1132497128128576L, 0L};
return data;
}
public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
private static final long[] mk_tokenSet_5() {
long[] data = { 1722479914074304L, 0L};
return data;
}
public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
private static final long[] mk_tokenSet_6() {
long[] data = { 1722411194597568L, 0L};
return data;
}
public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
private static final long[] mk_tokenSet_7() {
long[] data = { 1125899924144192L, 0L};
return data;
}
public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
private static final long[] mk_tokenSet_8() {
long[] data = { 1722411190386880L, 0L};
return data;
}
public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
private static final long[] mk_tokenSet_9() {
long[] data = { 1159444023476416L, 0L};
return data;
}
public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
private static final long[] mk_tokenSet_10() {
long[] data = { 2251345007067328L, 0L};
return data;
}
public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
private static final long[] mk_tokenSet_11() {
long[] data = { 1721861130420416L, 0L};
return data;
}
public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
}
|
