antlr/antlr4

ANTLR (ANother Tool for Language Recognition) is a powerful parser generator for reading, processing, executing, or translating structured text or binary files.

ANTLR v4

ANTLR (ANother Tool for Language Recognition) is a powerful parser generator for reading, processing, executing, or translating structured text or binary files. It's widely used to build languages, tools, and frameworks. From a grammar, ANTLR generates a parser that can build parse trees and also generates a listener interface (or visitor) that makes it easy to respond to the recognition of phrases of interest.

Dev branch build status

(github actions)

Versioning

ANTLR 4 supports 10 target languages (Cpp, CSharp, Dart, Java, JavaScript, PHP, Python3, Swift, TypeScript, Go), and ensuring consistency across these targets is a unique and highly valuable feature. To ensure proper support of this feature, each release of ANTLR is a complete release of the tool and the 10 runtimes, all with the same version. As such, ANTLR versioning does not strictly follow semver semantics:

• a component may be released with the latest version number even though nothing has changed within that component since the previous release
• major version is bumped only when ANTLR is rewritten for a totally new "generation", such as ANTLR3 -> ANTLR4 (LL(*) -> ALL(*) parsing)
• minor version updates may include minor breaking changes, the policy is to regenerate parsers with every release (4.11 -> 4.12)
• backwards compatibility is only guaranteed for patch version bumps (4.11.1 -> 4.11.2)

If you use a semver verifier in your CI, you probably want to apply special rules for ANTLR, such as treating minor change as a major change.

Repo branch structure

The default branch for this repo is master, which is the latest stable release and has tags for the various releases; e.g., see release tag 4.9.3. Branch dev is where development occurs between releases and all pull requests should be derived from that branch. The dev branch is merged back into master to cut a release and the release state is tagged (e.g., with 4.10-rc1 or 4.10.) Visually our process looks roughly like this:

The Go target now has its own dedicated repo:

$ go get github.com/antlr4-go/antlr

Note The dedicated Go repo is for go get and import only. Go runtime development is still performed in the main antlr/antlr4 repo.

Authors and major contributors

• Terence Parr, [email protected] ANTLR project lead and supreme dictator for life University of San Francisco
• Sam Harwell (Tool co-author, Java and original C# target)
• Eric Vergnaud (Javascript, TypeScript, Python2, Python3 targets and maintenance of C# target)
• Peter Boyer (Go target)
• Mike Lischke (C++ completed target)
• Dan McLaughlin (C++ initial target)
• David Sisson (C++ initial target and test)
• Janyou (Swift target)
• Ewan Mellor, Hanzhou Shi (Swift target merging)
• Ben Hamilton (Full Unicode support in serialized ATN and all languages' runtimes for code points > U+FFFF)
• Marcos Passos (PHP target)
• Lingyu Li (Dart target)
• Ivan Kochurkin has made major contributions to overall quality, error handling, and Target performance.
• Justin King has done a huge amount of work across multiple targets, but especially for C++.
• Ken Domino has a knack for finding bugs/issues and analysis; also a major contributor on the grammars-v4 repo.
• Jim Idle has contributed to previous versions of ANTLR and recently jumped back in to solve a major problem with the Go target.

Useful information

• Release notes
• Getting started with v4
• Official site
• Documentation
• FAQ
• ANTLR code generation targets
  (Currently: Java, C#, Python3, JavaScript, TypeScript, Go, C++, Swift, Dart, PHP)
• Note: As of version 4.14, we are dropping support for Python 2. We love the Python community, but Python 2 support was officially halted in Jan 2020. More recently, GiHub also dropped support for Python 2, which has made it impossible for us to maintain a consistent level of quality across targets (we use GitHub for our CI). Long live Python 3!
• Java API
• ANTLR v3
• v3 to v4 Migration, differences

You might also find the following pages useful, particularly if you want to mess around with the various target languages.

• How to build ANTLR itself
• How we create and deploy an ANTLR release

The Definitive ANTLR 4 Reference

Programmers run into parsing problems all the time. Whether it’s a data format like JSON, a network protocol like SMTP, a server configuration file for Apache, a PostScript/PDF file, or a simple spreadsheet macro language—ANTLR v4 and this book will demystify the process. ANTLR v4 has been rewritten from scratch to make it easier than ever to build parsers and the language applications built on top. This completely rewritten new edition of the bestselling Definitive ANTLR Reference shows you how to take advantage of these new features.

You can buy the book The Definitive ANTLR 4 Reference at amazon or an electronic version at the publisher's site.

You will find the Book source code useful.

Additional grammars

This repository is a collection of grammars without actions where the root directory name is the all-lowercase name of the language parsed by the grammar. For example, java, cpp, csharp, c, etc...

antlr4's Issues

Full-context parsing executes predicates out-of-context

The current algorithm for determining whether a context-sensitive predicate may be executed at the current location in execATN checks for an empty invocation context. In full-context parsing, the original invocation context is actually required for a predicate to be in context. This is resolved in sharwell/antlr4@99ce3cb, and included in pull request parrt#15.

Left recursion still not working

Hi,

the latest early access (built from latest commit d378469) is still not able to handle a (non-mutually) left recursive grammar. The following simple grammar yields the error:

qualifiedName returns [Object res]  
    : name=ID 
            { return null; }

    | (scope=qualifiedName '.') name=ID 
            { return null; }
    ;

ID 
    : '0'..'9'+;

the resulting error is error(119): ... ::: The following sets of rules are mutually left-recursive [qualifiedName]

tokens not introducing keyword rules in lexer?

the lexer wouldn't match correctly and would cast them all as id tokens

    tokens { TRUE='true'; FALSE='false'; TYPE_BOOL='boolean'; TYPE_VOID='void'; TYPE_INT='int';
             TYPE_FLOAT='float'; TYPE_CHAR='char';}

    primitiveType
      returns [CymbolProperties props]
      @init{$primitiveType.props = new CymbolProperties();}
      : 'float'
      | 'int'
      | 'char'
      | 'boolean
      | 'void'
      ;

-D command line option for any grammar option

so -abstract becomes -Dabstract, -DsuperClass=foo, etc...

Make a -package foo command line option

We sometimes need to know if the generated code is going into a package or whatever the target language called package. For example, when generating interfaces and such, it would be nice to say

import static MyParser.*;

so that we can simply reference FooContext instead of having to prefix it with MyParser. If there is no package specification that we generate in the default package. Due to a limitation in Java, we must prefix the context names with the parser name.

Make generic visitor with parameterized return values: XVisitor<T> upon -visitor option

add the following double dispatch:

public void accept(XVisitor visitor) { visitor.visit(this); }

and generate XVisitor. Make a BaseXVisitor that has a

void visitChildren(ParserRuleContext ctx) {
  for each child c: visit(c);
}

And generates the following default implementations:

void visit(slistContext ctx) { visitChildren(p); }

I guess we also need a generic method in ParserRuleContext:

public abstract void accept(XVisitor visitor);

People can do things like this:

int visit(NodeType n) { return n.left.accept(this) + n.right.accept(this); }

generating with JDK 1.5 give class version error

I'm using the Antlr eclipse plugin in RAD 8 (eclipse 3.6.2 - helios) and when is save my grammar I get following exception.

java.lang.UnsupportedClassVersionError: (org/stringtemplate/v4/STGroup) bad major version at offset=6
at java.lang.ClassLoader.defineClassImpl(Native Method)
at java.lang.ClassLoader.defineClass(ClassLoader.java:266)
at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:151)
at java.net.URLClassLoader.defineClass(URLClassLoader.java:600)
at java.net.URLClassLoader.access$400(URLClassLoader.java:124)
at java.net.URLClassLoader$ClassFinder.run(URLClassLoader.java:1055)
at java.security.AccessController.doPrivileged(AccessController.java:274)
at java.net.URLClassLoader.findClass(URLClassLoader.java:492)
at java.lang.ClassLoader.loadClass(ClassLoader.java:639)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:349)
at java.lang.ClassLoader.loadClass(ClassLoader.java:605)
at java.lang.J9VMInternals.verifyImpl(Native Method)
at java.lang.J9VMInternals.verify(J9VMInternals.java:69)
at java.lang.J9VMInternals.initialize(J9VMInternals.java:131)
at org.deved.antlride.runtime.Tool2.main(Tool2.java:21)

This is caused by the fact that the ST 4 classes in the antlr-3.4-complete.jar are compile for target java 1.6 while the antlr classes are compiled with target 1.4.
Checked by opening the classfiles in hexeditor.
org.stringtemplate.v4.STGroup version = 0032 which is J2SE 6.0
org.antlr.codegen.ActionScriptTarget.class version = 0030 which is JDK 1.4

Is it possible to rebuild the jar using target 1.5 since the minimum required version of java for Antlr-3.4 as specified on the website is java 1.5.

Move report* callbacks from ANTLRErrorStrategy to ANTLRErrorListener

The following calls are made from within ParserATNSimulator for reporting purposes only. The results of the call do not have any direct impact on parsing.

• ANTLRErrorStrategy.reportError This one can't be moved. Generated code calls this method and the error strategy determines what/when to report to the listener.
• ANTLRErrorStrategy.reportAmbiguity
• ANTLRErrorStrategy.reportAttemptingFullContext
• ANTLRErrorStrategy.reportContextSensitivity
• ANTLRErrorStrategy.reportInsufficientPredicates

These methods are more appropriate as part of the ANTLRErrorListener interface.

If someone does need an error strategy where behavior is dependent on these callbacks, it would be easy to simply implement both ANTLRErrorStrategy and ANTLRErrorListener on the same object.

Specify and implement parser tracing for debugging support

This is a broad feature for discussing the type of trace information logged by the parser for debugging purposes as well as the log format. The trace information should support (at minimum) a range of to-be-specified debugging features. I'll work on opening a wiki article for planning this feature in further detail, and use this issue for tracking progress.

Unable to parse new array expression with LR rule

With the current algorithm, it is not possible to parse certain expressions with an LR rule. One basic example is the new array expression in Java:

Grammar:

grammar T;
s @after {System.out.println($ctx.toStringTree(this));} : e EOF ;
expressionList
    : e (',' e)*
    ;
e   : INT
    | 'new' type ('[' e ']')+
    | e '[' e ']'
    ;
type: ID
    | ID '[' ']'
    ;
ID : ('a'..'z'|'A'..'Z'|'_'|'$')+;
INT : '0'..'9'+ ;
WS : (' '|'\\n') -> skip ;

Failed expression:

new T[1]

Expected:

(s (e new (type T) [ (e 1) ]) <EOF>)

Antlr 3.4 Javascript target bug

Antlr 3.3 Javascript target is ok,Antlr 3.4 Javascript target generate unusable.

Implicit label analysis only covers outer alts for list detection

In the code generated for the following rule, the VarSpecContext.expressionList() method returns a List<TerminalNode<Token>> when in reality the expressionList rule can be called at most 1 time.

varSpec
    :   identifierList
        (   type ('=' expressionList)?
        |   '=' expressionList
        )
    ;

Explicitly resolving if/if/else ambiguity in a grammar

I'm working with an ANTLR 4 grammar to correct any construct which results in a call to reportAmbiguity. In many cases this is done by refactoring or combining rules, but the case for an if/if/else construct is proving more challenging.

Starting with the following grammar:

grammar T;
stmt : ifStmt | ID;
ifStmt : 'if' ID stmt ('else' stmt)?;

ID : [a-zA-Z]+;
WS : ' '+ -> skip;

Given the input if x if x a else b, I'm looking for a way to modify the grammar such that no call to reportAmbiguity is needed, while following the standard if/else rule of binding to the closest unmatched if statement.

In ANTLR 3, a syntactic predicate allowed the user to explicitly handle this situation. In ANTLR 4, the correct decision is made through min-alt resolution, but it always wants to emit a "warning" regarding the situation.

Generating bad sempred method

The resulting grammar is accepted by latest Honey Badger (the one pulled from parrt/antlr). However, the resulting parser contains errors: an unused sempred method with errors is produced. Since it is unused, I simply deleted it. However, the parser still does not match the input correctly. I guess both things have are symptoms of the same bug.

Here is (a simplified version of) the grammar producing the erroneous parser:

rule returns [String r]
   :  t=ID  ':' alts+=expr ('|' alts+= expr)* ';'
       {  $r = "x"; }
   ;

strongExpr returns [String r]
   : ID                      { $r = "x"; }
   | '(' ep=parenExpr ')'               { $r = "x"; }
   | e1=strongExpr '?'             { $r = "x"; }
   ;

expr returns [String r]
   : e=strongExpr (e2=expr)? { $r = "x"; }
   | e1=expr '->' ID {$r = "x"; }
   ;

parenExpr returns [String r]
   : e1=expr '|' e2=parenExpr { $r = "x"; }
   | expr              {$r = $expr.r; }
   ;

ID  :   ('A'..'Z'|'a'..'z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*
     ;

the resulting unused sempred with errors:

public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
    switch ( ruleIndex ) {
    case 1 : return strongExpr_sempred((StrongExprContext)_localctx, predIndex);    
    case 2 : return expr_sempred((ExprContext)_localctx, predIndex);
    }
    return true;
}

The problems are the casts (StrongExprContext)_localctx and (ExprContext)_localctx, since _localctx is a RuleContext here. As mentioned, the sempred is not called anyway.

Getter for context is not a list when it should be

For this rule

compilationUnit
  locals[CymbolProperties props]
  @init{$compilationUnit.props = new CymbolProperties();}
    : (structDeclaration 
    | methodDeclaration 
    | varDeclaration)+
    ;

I would expect

ctx.methodDeclaration();

To hand back a list of methodDeclCtxs (ditto for structDecls and varDecls)

However, here is the generated code:

public structDeclarationContext structDeclaration() {
    return (structDeclarationContext)getRuleContext(structDeclarationContext.class,0);
}
public varDeclarationContext varDeclaration() {
    return (varDeclarationContext)getRuleContext(varDeclarationContext.class,0);
}
public methodDeclarationContext methodDeclaration() {
    return (methodDeclarationContext)getRuleContext(methodDeclarationContext.class,0);
}

Don't allow labels on not token set subrules

The following should be disallowed because expr is not a simple set of tokens

op=('=' | '+=' | expr)

Specify and implement lexer tracing for debugging support

This is a broad feature for discussing the type of trace information logged by the lexer for debugging purposes as well as the log format. The trace information should support (at minimum) a range of to-be-specified debugging features. I'll work on opening a wiki article for planning this feature in further detail, and use this issue for tracking progress.

Unable to generate this grammer!

Hi
I can't get antlerworks to generate this grammer...
Please Help Me...

Thanks in advance...

grammar phase222;
@lexer::member
{
    boolean multi = false;

}


program : module*;
module  :   MODULE ID (CHILDOF)?AO member* AC;
member  :   VIRTUAL ? ID PO (ID TYPE type (COLON ID TYPE type)*) ? PC TYPE type block | vardecl;
type    :   ID | INT | BOOL | STRING2 | VOID;
vardecl :   ID (QO CONSTINT QC)? (COLON ID (QO CONSTINT QC)?)* TYPE type;
st  : block | vardecl EOC | loc ASSIGN expr EOC | methodcall EOC |IF expr THEN block (ELSE block)? | WHILE expr LOOP block | RETURN expr? EOC
    | BREAK EOC | CONTINUE EOC | READ loc EOC |WRITE expr EOC;
block   :   AO st* AC;
loc :   ID (PROPERSTIS ID)* (QO expr QC)?;
methodcall
    :   ID (PROPERSTIS ID )* PO (expr (COLON expr)*)? PC;
expr    :   loc | methodcall | CREATE ID | CONSTINT | CONSTBOOL | STRING | expr2;
expr2   :  or (ASSIGN or)* ;

or  : and orrest;
orrest  :OR or orrest;

and :  not andrest;
andrest :AND and andrest;

not : (NOT)* assignornot;
assignornot :(COMPLEMENT | EQUAL) relatedoperation;

relatedoperation :plusminus relatedoperationrest;
relatedoperationrest:BGT | BGTE | LWT | LWTE relatedoperation relatedoperationrest;

plusminus    :multdivide plusminusrest;
plusminusrest    :PLUS | MINUS  plusminus plusminusrest;

multdivide : negetive multdividerest;
multdividerest : MULT | DIVIDE multdivide multdivide;   

negetive:   (MINUS)* end;

end     :ID | PO expr PC;




TURE   :'true'{Test.s+="\$true\$";};
FALSE  :'false'{Test.s+="\$false\$";};
MASKHAREH
    :   '\r';
//BOOLEAN :'ture'|'false'{Test.s+="constBool";};
NEWLINE :'\n'{if(Test.comment == true)Test.s+="\$MultilineComment\$";Test.s+="\n";Test.s+=Test.LINE++ + ": ";};
EOFF    :   EOF;
COMMENTSINGLE
    :   '%%' ~('\n'|'\r')* {$channel=HIDDEN;Test.s+="\$SinglelineComment\$";};
COMMENTMULTI
    :   '%%%' {Test.comment = true;} (options {greedy=false;} : ((NEWLINE) | .))* ('%%%') {$channel=HIDDEN;Test.s+="\$MultilineComment\$";Test.comment = false;};
WS  :   ( ' '
        | '\t'
        ) {$channel=HIDDEN;};
STRING  :'"' ( ESC_SEQ | ~('\\'|'"') )* '"'{Test.s+="constStr";};
MULT    :'*'{Test.s+="*";};
EQUAL   :'='{Test.s+="=";};
PLUS    :'+'{Test.s+="+";};
MINUS   :'-'{Test.s+="-";};
DIVIDE  :'/'{Test.s+="/";};
BGTE    :'>='{Test.s+=">=";};
BGT     :'>'{Test.s+=">";};
LWTE    :'<='{Test.s+="<=";};
LWT :'<'{Test.s+="<";};
COMPLEMENT :'!='{Test.s+="!=";};
EOC    :';'{Test.s+=";";};
PROPERSTIS :'.'{Test.s+=".";};
TYPE       :':'{Test.s+=":";};
ASSIGN     :':='{Test.s+=":=";};
COLON      :','{Test.s+=",";};
AO  :'{'{Test.s+="{";};
AC  :'}'{Test.s+="}";};
QO  :'['{Test.s+="[";};
QC  :']'{Test.s+="]";};
PO  :'('{Test.s+="(";};
PC  :')'{Test.s+=")";};
MODULE  :'module'{Test.s+="\$module\$";};
IF  :'if'{Test.s+="\$if\$";};
ELSE    :'else'{Test.s+="\$else\$";};
CHILDOF :'childof'{Test.s+="\$childof\$";};
VIRTUAL :'virtual'{Test.s+="\$virtual\$";};
CREATE  :'create'{Test.s+="\$create\$";};
THEN    :'then'{Test.s+="\$then\$";};
ENDIF   :'endif'{Test.s+="\$endif\$";};
WHILE   :'while'{Test.s+="\$while\$";};
LOOP    :'loop'{Test.s+="\$loop\$";};
ENDLOOP :'endloop'{Test.s+="\$endloop\$";};
BREAK   :'break'{Test.s+="\$break\$";}; 
CONTINUE:'continue'{Test.s+="\$continue\$";};
AND :'and'{Test.s+="\$and\$";};
OR  :'or'{Test.s+="\$or\$";};
NOT :'not'{Test.s+="\$not\$";};
READ    :'read'{Test.s+="\$read\$";};
WRITE   :'write'{Test.s+="\$write\$";};
RETURN  :'return'{Test.s+="\$return\$";};
INTWORD :'int'{Test.s+="\$int\$";};
BOOL    :'bool'{Test.s+="\$bool\$";};
STRING2 :'string'{Test.s+="\$string\$";};
VOID    :'void'{Test.s+="\$void\$";};
INT     :'int' {Test.s+="\$int\$";};


fragment
HEX_DIGIT : ('0'..'9'|'a'..'f'|'A'..'F') ;

fragment
ESC_SEQ
    :   '\\' ('b'|'t'|'n'|'f'|'r'|'\"'|'\''|'\\')
    |   UNICODE_ESC
    |   OCTAL_ESC
    ;

fragment
OCTAL_ESC
    :   '\\' ('0'..'3') ('0'..'7') ('0'..'7')
    |   '\\' ('0'..'7') ('0'..'7')
    |   '\\' ('0'..'7')
    ;

fragment
UNICODE_ESC
    :   '\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
    ;




CONSTBOOL : TURE | FALSE {{Test.s+="constBool";}};


fragment VALUE  :'0'..'9';
CHARACTER:'a'..'z'|'A'..'Z'|'_';
ID      :(CHARACTER)(CHARACTER|VALUE)*{Test.s+="ID";};
fragment ID2
    :(CHARACTER)(CHARACTER|VALUE)*;
fragment DIGIT  :'0'..'9'+;
ERORR1  :a=DIGIT ID2{Test.s+="\$Error1("+a.getText()+")\$ID";};

ERORR3  :('0')('0'..'9')+{Test.s+="\$Error3\$";};
CONSTINT :((('1'..'9')('0'..'9')*) |('0')){Test.s+="constInt";};

ERORR21 :(reich3=INVALIDCHARACHTER)DIGIT{Test.s+="\$Error2("+reich3.getText()+")\$constInt";};
ERORR22 :(reich3=INVALIDCHARACHTER)ID2{Test.s+="\$Error2("+reich3.getText()+")\$ID";};
ERORR23 :(reich3=INVALIDCHARACHTER){Test.s+="\$Error2("+reich3.getText()+")\$";};

fragment INVALIDCHARACHTER
    :   ~('*'|'='|'-'|'{'|'}'|'['|']'|')'|'('|'+'|'<'|'>'|';'|':'|'.'|','|' '|'\t'|CHARACTER|VALUE);

Implement a rule versioning mechanism

In my IDE work, support for any given language frequently includes hundreds up to several thousand references to context objects in the parse tree. Regardless of whether manual walking methods (iterating over or instanceof on the result of getChild(n) etc) or implicit labels are used, this code can be extremely sensitive to minor changes in the grammar and is a frequent source of regression bugs. A "versioning mechanism" for rules could be extremely helpful in tracking down interface problems early which arise when the grammar changes.

Rule annotations (current experimental implementation)

By adding annotations named @RuleVersion and @RuleDependency, a balance between the above items could be achieved. The generated code for a rule method would be marked with an @RuleVersion(n) annotation with the rule version. Code which depends on rules could be marked with one or more @RuleDependency(RULE_expr, 1) annotations declaring the dependency. Multiple dependencies can be wrapped in a @RuleDependencies annotation.

Benefits of this method include:

• Compile time dependency checking can be provided is provided by an annotation processor, but would not force a failure to compile following a version change. Runtime checking could be provided by a utility method which could check all dependency for a class and/or package at once.
• No overhead when -ea is specified (runtime assertion checking).
• Clean, declarative syntax.
• User control over when the version of a rule is incremented. This allows cross-rule changes to be reflected in versioning, such as incrementing the versions of rules a, b, and c when rule a changes from a : b; to a : c;.

A possible syntax for this which is reasonably clean, minimizes changes to the tool, and would keep the grammar target language agnostic could be:

foo
@version{1}
   : ...
   ;

Inline actions and runtime assertions (alternative 1, not in use)

This method does not introduce an code generation changes, so it can be used with the current versions of ANTLR 4. While better than unversioned rules, it does have a number of drawbacks. If the following code is added to an @members{} block:

private static int[] ruleVersions;

{
if (ruleVersions == null) {
    ruleVersions = new int[_ATN.ruleToStartState.length];
}
}

public static int getRuleVersion(int rule) {
    return ruleVersions[rule];
}

public static int getRuleVersion(ParserRuleContext<?> context) {
    return ruleVersions[context.ruleIndex];
}

private static void setRuleVersion(ParserRuleContext<?> context, int version) {
    ruleVersions[context.ruleIndex] = version;
}

Then the following @init{} action can be used to mark a rule version that can be incremented when the rule changes:

@init{setRuleVersion($ctx, 1);}

When a block/statement of code depends on a particular form of the rule, a statement like the following will allow quicker detection of potential problems.

// for code in a listener, or where a typed context object is used
ExprContext ctx = ...;
assert MyParser.getRuleVersion(ctx) == 1;

// for general dependencies
assert MyParser.getRuleVersion(MyParser.RULE_expr) == 1;

CRC constants and compile-time assertions (alternative 2, not in use)

If a block of code like the following could be automatically generated based on a CRC calculation of each rule's syntax (ignoring whitespace, actions, and unnecessary parentheses):

public static final boolean HASH_expr_2bc29fa4=true,
    HASH_stmt_56ed0cbb=true, ...;

Then an assertion like the following will actually produce a compile-time error until dependent code is updated following a change to a rule:

assert HASH_expr_2bc29fa4;

While the fields would be hard to keep track of, any modern editor will allow updating the assertion after code verification by simply typing HASH_expr_ followed by a complete word action (Ctrl+Space in many IDEs).

compilation error with java 6 on mac osx

G'day Ter and all,

Using today's sources (March 13) I got:

[javac] /Users/michael/coding/antlr4/build/src/org/antlr/v4/parse/ANTLRParser.java:2412: exception org.antlr.runtime.RecognitionException is never thrown in body of corresponding try statement
[javac]         catch (RecognitionException re) {
[javac]         ^

My system is OSX 10.6.8, Java 1.6.0_29

After fixing the above problem the build ran smoothly.

Michael

ATN-failover with erroneous input can corrupt cached DFA

When execDFA fails to find a cached edge for an input, it falls back to execATN. The fallback is enclosed in a try/catch block, and if execATN throws a RecognitionException an ERROR edge is added to the cached DFA. When the erroneous symbol that resulted in execATN throwing an exception is not the first symbol checked by execATN, the update to the cached DFA blocks the entire input sequence leading to the erroneous symbol starting with the first uncached (yet possibly valid) symbol. This is fixed in sharwell/antlr4@cd3adb1, and included in pull request parrt#15.

Oliver claims expectedTokens() doesn't work on these examples

http://code.google.com/p/antlr4-ast-visitor-sandbox/source/browse/trunk/test/ParserTest.java

Predicated configs suppress reportAmbiguity

Currently, no call to reportAmbiguity occurs when one or more ATNConfig instances have a semantic context. This is particularly problematic in tracking down issues in LR rules due to the automatically inserted predicates. One way to resolve this is having ParserATNSimulator.evalSemanticContext return an IntervalSet of all passing alternatives (unpredicated or having a predicate returning true). If the set contains more than one alternative, reportAmbiguity can be called before resolving the set to a single chosen alternative.

This presents a potential problem due to the fact that resolution currently prefers the minimum passing predicated alternative as opposed to the standard minimum acceptable alternative. However, this resolution policy will have to be changed to minimum acceptable alternative to resolve #29.

Hard to get parse tree text

imagine trying to get text for tokens matched in rule type. currently we have to do this:

            TokenStream tokens = parser.getTokenStream();
            Interval range = ctx.type().getSourceInterval();
            type = tokens.toString(range.a, range.b);

I suggest making ParserRuleContext.toString(TokenStream) return text.

NullPointerException in ATNConfig.hashCode

Hi,

I receive a NullPointerException when running the generated parser on an input. If you need a grammar and input to provoque the bug, let me know (but that will take some time).

Here is the stack trace:

Exception in thread "main" java.lang.NullPointerException
    at org.antlr.v4.runtime.atn.ATNConfig.hashCode(ATNConfig.java:149)
    at java.util.HashMap.put(Unknown Source)
    at java.util.HashSet.add(Unknown Source)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:924)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:1012)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:1012)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:1012)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:1012)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:1012)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:1012)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:1012)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:1012)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:1012)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:1012)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:1012)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:1012)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:1012)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:946)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:1012)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:1012)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.closure(ParserATNSimulator.java:912)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.computeReachSet(ParserATNSimulator.java:711)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.execATN(ParserATNSimulator.java:521)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.predictATN(ParserATNSimulator.java:331)
    at org.antlr.v4.runtime.atn.ParserATNSimulator.adaptivePredict(ParserATNSimulator.java:296)
    at org.eeve.antlrgen.parser.ANTLRv4Parser.strongExpr(ANTLRv4Parser.java:886)
    at org.eeve.antlrgen.parser.ANTLRv4Parser.expr(ANTLRv4Parser.java:1146)
    at org.eeve.antlrgen.parser.ANTLRv4Parser.grammarRule(ANTLRv4Parser.java:398)
    at org.eeve.antlrgen.parser.ANTLRv4Parser.gramma(ANTLRv4Parser.java:150)
    at org.eeve.antlrgen.ANTLRGenTest.parseStatic(ANTLRGenTest.java:92)
    at org.eeve.antlrgen.ANTLRGenTest.main(ANTLRGenTest.java:38)

Replace reportInsufficientPredicates with reportAmbiguity and reportPredicateResolution

In light of #29, #31, and #32, it seems that the reportInsufficientPredicates message does not provide helpful information and is actually likely to mislead a developer. In particular, if predicated configs have the same priority as unpredicated configs (as required by #29), then the information most likely to help improve a grammar comes from the reportAmbiguity message which would be restored to situations involving predicates as part of #31.

Consider the following rules:

a : b1 | b2 | b3;
b1 : {false}? ID;
b2 : ID;
b3 : ID;

Currently, the decision in rule a will result in a reportInsufficientPredicates message, even though no predicates are present in a at all. The desired message is actually reportAmbiguity for alternatives {2..3}. Since performance can be severely impacted by the presence of predicated configs which evaluate to an unambiguous alternative, a message (possibly reportPredicateResolution) that predicate evaluation is being used to resolve a syntactic ambiguity for alternatives {1..3} would be useful. This message would not be sent when predicate evaluation is only being used to gate a syntactically unambiguous alternative.

Prediction can return incorrect results when alts are partially predicated

The following example grammar is used for the TestSemPredEvalParser.testUnpredicatedPathsInAlt unit test.

When started at rule s with the input x 4, it should predict alt 1.

grammar T;
s : a {System.out.println("alt 1");}
  | b {System.out.println("alt 2");}
  ;
a : {false}? ID INT
  | ID INT
  ;
b : ID ID
  ;
ID : 'a'..'z'+ ;
INT : '0'..'9'+;
WS : (' '|'\n') {skip();} ;

ParserRuleContext.stop is null after RecognitionException

When a RecognitionException occurs, the stop token of the context object is not set. This makes it difficult to get the stop token when building parse trees (by finding the last descendent TerminalNode), and impossible to get the source interval when not building parse trees (the default).

When addressing this issue, it's important to retain the ability to determine whether or not an error has occurred.

Number of rule entries in listener while parsing does not match number while walking

This is illustrated by this test

http://code.google.com/p/antlr4-ast-visitor-sandbox/source/browse/trunk/test/EnterAndExitEveryRuleTest.java

Command line option to specify super class

Derived from a comment in #36.

A command line option -superclass could be added to specify the super class of a generated lexer/parser.

NullPointerException in getMissingSymbol

When parsing an empty document with a rule that contains non-optional symbols, a NPE gets thrown in DefaultErrorStrategy.getMissingSymbol when the call to TokenFactory.create dereferences the current variable.

add rule context object factory?

public static class LExprBaseContextFactory {
    public SContext createS(ParserRuleContext<Token> parent, int state) {
        return new SContext(parent, state);
    }
    public EContext createE(ParserRuleContext<Token> parent, int state, int _p) {
        return new EContext(parent, state, _p);
    }
    public MultContext createMult(EContext parent) { return new MultContext(parent); }
    public AddContext createAdd(EContext parent) { return new AddContext(parent); }
    public IntContext createInt(EContext parent) { return new IntContext(parent); }
}

Option to generate abstract classes

For lexers and parsers which have an inherent requirement to implement some features in a derived class, it would be convenient to be able to generate the lexer/parser classes as abstract. This would also allow abstract methods instead of stubs which throw UnsupportedOperationException to be placed in the @members{} blocks.

In addition, it would be especially useful if it prepended Abstract to the name of the class generated for an abstract parser grammar FooParser:

• AbstractFooParser
• FooParserParseListener / FooParserListener / FooParserVisitor
• FooParserBaseParseListener / FooParserBaseListener / FooParserBaseVisitor

Getters in context objects can go wrong when some alternatives have labels and some do not

It gets ugly when you only partially label the alternatives and rule because it can cause type collisions with overridden methods. For unlabeled alternatives, we get getters in the main context object. The context objects for labeled alternatives are subclasses of that context. We might have a collision when we override:

e : e '+' e -> Add
   | '(' e ')'
   | ID
   ;

The unlabeled alternatives get methods in eContext:

public eContext e() { }
public Token ID() { }

But in the AddContext, we find an override with a different return type:

public List<eContext> e() { }

since e can have multiple values in that context. I'm not sure how to resolve.

grammar option problem

It seems that, when setting the options {backtrack=true;}, the AST tree cannot be built normally. Is it a bug? I tried the java.g file which is provided in the url http://openjdk.java.net/projects/compiler-grammar/antlrworks/Java.g . And I added {output=AST;} in the options. However, when I used the generating source code to parse the java code, the AST tree seems abnormal.

NullPointerException in LexerATNSimulator.execDFA

I receive the following null pointer exception

line 1:1 token recognition error at: ' '
Exception in thread "main" java.lang.NullPointerException
    at org.antlr.v4.runtime.atn.LexerATNSimulator.execDFA(LexerATNSimulator.java:244)
    at org.antlr.v4.runtime.atn.LexerATNSimulator.match(LexerATNSimulator.java:155)
    at org.antlr.v4.runtime.Lexer.nextToken(Lexer.java:146)
    at org.antlr.v4.runtime.BufferedTokenStream.fetch(BufferedTokenStream.java:133)
    at org.antlr.v4.runtime.BufferedTokenStream.sync(BufferedTokenStream.java:127)
    at org.antlr.v4.runtime.CommonTokenStream.consume(CommonTokenStream.java:69)
    at org.antlr.v4.runtime.Parser.consume(Parser.java:351)
    at org.antlr.v4.runtime.Parser.match(Parser.java:135)
    at test.ANTLRv4Parser.ruler(ANTLRv4Parser.java:76)
    at Test.main(Test.java:19)

This is the used grammar (the one of issue #45)

    grammar ANTLRv4;

    ruler returns [String r]
      :  t=ID  ':' alts+=expr ('|' alts+= expr)* ';'
          {  $r = "x"; }
       ;

    strongExpr returns [String r]
      : ID                      { $r = "x"; }
      | '(' ep=parenExpr ')'            { $r = "x"; }
      | e1=strongExpr '?'             { $r = "x"; }
      ;  

    expr returns [String r]
      : e=strongExpr (e2=expr)? { $r = "x"; }
      | e1=expr '->' ID {$r = "x"; }
      ;

    parenExpr returns [String r]
      : e1=expr '|' e2=parenExpr { $r = "x"; }
      | expr              {$r = $expr.r; }
      ;

    ID  :   ('A'..'Z'|'a'..'z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*
        ;    

And here is a test input (similiar to the one of issue #45, only with spaces in between):

x : x ;

Code for parser execution:

    ANTLRv4Lexer lex = new ANTLRv4Lexer(new ANTLRInputStream(new FileInputStream(new File("test.input"))));
    CommonTokenStream tokens = new CommonTokenStream(lex);

    new ANTLRv4Parser(tokens).ruler();

error: declaration does not declare anything

The following grammar part causes errors in antlr 3.4 C target. When generating code with antr 3.2, everything works properly.

Grammar

assignment :
 (id=IDENTIFIER
        (  as1=valueAssignment
         | as2=typeAssignment
         | as3=parameterizedAssignment
         | as4=objectClassAssignment
        )

 )
 -> ^($id $as1? $as2? $as3? $as4?)
;

Antlr 3.2 generated code(the one that works)

// $ANTLR start synpred23_asn1
static void synpred23_asn1_fragment(pasn1Parser ctx )
{
        asn1Parser_valueAssignment_return as1;
        #undef  RETURN_TYPE_as1
        #define RETURN_TYPE_as1 asn1Parser_valueAssignment_return

    // /home/dfranusic/antlr-c-test/asn1.g:198:6: (as1= valueAssignment )
    // /home/dfranusic/antlr-c-test/asn1.g:198:6: as1= valueAssignment
    {
        FOLLOWPUSH(FOLLOW_valueAssignment_in_synpred23_asn13729);
        as1=valueAssignment(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred23_asn1Ex;
        }
        if (HASFAILED())
        {
            return ;
        }

    }

// This is where rules clean up and exit
//
goto rulesynpred23_asn1Ex; /* Prevent compiler warnings */
rulesynpred23_asn1Ex: ;

}

Antlr 3.4 generated code(the one that DOES NOT work)

// $ANTLR start synpred23_asn1
static void synpred23_asn1_fragment(pasn1Parser ctx )
{
        void ;
        #undef  RETURN_TYPE_
        #define RETURN_TYPE_ void

    // /home/dfranusic/antlr-c-test/asn1.g:198:6: (as1= valueAssignment )
    // /home/dfranusic/antlr-c-test/asn1.g:198:6: as1= valueAssignment
    {
        FOLLOWPUSH(FOLLOW_valueAssignment_in_synpred23_asn13729);
        as1=valueAssignment(ctx);

        FOLLOWPOP();
        if  (HASEXCEPTION())
        {
            goto rulesynpred23_asn1Ex;
        }
        if (HASFAILED())
        {
            return ;
        }


    }

// This is where rules clean up and exit
//
goto rulesynpred23_asn1Ex; /* Prevent compiler warnings */
rulesynpred23_asn1Ex: ;

}

default all rule refs to have labels in _localctx with same name with option to turn off

RuleContext object labels:

e : e '+' egets labels e1 and e2
a : e (',' e)*gets List e and NO e1, e2

Rules with multiple alternatives and non-unique elements, get no automatic labels. The reason is, you can get rules like this
a : ID+ | ID ;

have to label alt or element. even for e : expr '++' | expr '--' ;

-Xno-auto-ctx-labels option or something like that to turn off all of this overhead? better name?

Try to get labeled alt labels into alt context.

don't forget to sort out list vs regular labels. ID+ gets ID and ID_list but ID should be the list now.

Split parser / tree listener interfaces

we need to generate 2 interfaces:

    interface XParserListener {
            void enterR(); // if needs ctx, can get from parser.getCurrentContext() 
            void exitR(RContext ctx); // enterR/exitR for consistency
            …
    }

    interface XTreeListener {
            void enter(RContext ctx);
            void exit(RContext ctx);
            …
    }

means we need both XBaseParserListener, XBaseTreeListener, right?

Starting to think we need a buffet menu of options:

-parser-listener (on by default?)
-tree-listener
-tree-visitor

can have none or all i suppose.

Support code generation within ANTLRWorks 2

ANTLRWorks 2 should provide the ability to generate code for a grammar within the IDE.

MismatchedTreeNodeException when associating action

I posted this on stackoverflow:

ANTLR actions when building grammar resulting in MismatchedTreeNodeException

where Bart Kiers responded that it looks like an ANTLR bug.

The following works:

lexer grammar Test;    
NOT_LOWER_CASE : ~LOWER_CASE {System.out.println("not lower case");};
LOWER_CASE : 'a'..'z' ;

However, the following does not:

lexer grammar Test;
NOT_LOWER_CASE : ~LOWER_CASE;
LOWER_CASE : 'a'..'z' {System.out.println("lower case");};

with the following error:
Cannot generate the grammar because syntax error:buildnfa:MismatchedTreeNodeException(50!=29)

Lexer rule attributes?

Figure out if lexer rule attributes work.

an exception upon simple rule with double recursion in an alternative

expr
   : 'x'
   | e1=expr e2=expr
   ;

then the following exception is thrown:

         [java] can't find rule grammarSpec or tree structure error: 
(COMBINED_GRAMMAR ANTLRv4 (RULES (RULE expr (BLOCK (ALT 'x') (ALT (= e1 
expr[1]) (= e2 expr[1]))))))
         [java] java.lang.reflect.InvocationTargetException
         [java]     at 
sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
         [java]     at 
sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
         [java]     at 
sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
         [java]     at java.lang.reflect.Method.invoke(Unknown Source)
         [java]     at 
org.antlr.v4.parse.GrammarTreeVisitor.visit(GrammarTreeVisitor.java:192)
         [java]     at 
org.antlr.v4.parse.GrammarTreeVisitor.visitGrammar(GrammarTreeVisitor.java:186)
         [java]     at 
org.antlr.v4.semantics.SymbolCollector.process(SymbolCollector.java:69)
         [java]     at 

If/If/Else can lead to no viable alt at EOF

Here is a simplified grammar demonstrating the problem:

grammar T;
s : a | 'x';
a : 'a' s ('b' s)?;

No output for input axbx (correct)
No output for input x (correct)

Output for input ax (unexpected)

line 1:2 no viable alternative at input '<EOF>'

Output for input aaxbx (unexpected)

line 1:5 no viable alternative at input '<EOF>'

Antlr 3.4 error compiling to Java target

I am getting a Java compile error on a grammar.

I'm using Eclipse Indigo SR2 and these plugins:

• ANTLR IDE- ANTLR Tools v 2.1.2.201108281759
• ANTLR IDE- StringTemplate Tools, 1.1.0.201108281759

I am having Eclipse place the generated Java code in a package antlr-generated. The build path for antlr-generated includes antlr-3.4-complete.jar.

Here is my grammar:

/* Entry point */
 8: swiftMessage: block4 ;

10: block4: STARTBLOCK '4:' tag_value_pair+ ENDMESSAGEBLOCK ;

12: tag_value_pair :   NEWLINE tag value ;



16: tag :  COLON '1'..'9' '0'..'9' ('A'..'Z')?  ;

18: value :   COLON ('a'..'z' | 'A'..'Z' | '0'..'9' | ' ' | ',' | '.' )* ;

20: STARTBLOCK : '{' ;

22: ENDMESSAGEBLOCK : '-}' ;

24: NEWLINE : '\n' ;

26: COLON: ':' ; 

Here is the generated SwiftBugParser code (portions of comments ommitted):

    // $ANTLR start "tag"
    // \\SwiftBug.g:16:1: tag : COLON '1' .. '9' '0' .. '9' ( 'A' .. 'Z' )? ;
    public final void tag() throws RecognitionException {
        try {
            // \\SwiftBug.g:16:5: ( COLON '1' .. '9' '0' .. '9' ( 'A' .. 'Z' )? )
            // \\SwiftBug.g:16:8: COLON '1' .. '9' '0' .. '9' ( 'A' .. 'Z' )?
            {
            match(input,COLON,FOLLOW_COLON_in_tag68); 

            matchRange('1','9');  // FIRST ERROR, LINE 193

            matchRange('0','9');  // SECOND ERROR, LINE 195

            // \\SwiftBug.g:16:32: ( 'A' .. 'Z' )?
            int alt2=2;
            int LA2_0 = input.LA(1);

            if ( () ) {           // THIRD ERROR, LINE 201
                alt2=1;
            }
            switch (alt2) {
                case 1 :
                    // \\SwiftBug.g:
                    {
                    if (  ) {     // FOURTH ERROR, LINE 208
                        input.consume();
                        state.errorRecovery=false;
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        throw mse;
                    }


                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
            // do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "tag"

I am getting these four Java compilation errors:

Description Resource    Path    Location    Type
The method matchRange(char, char) is undefined for the type SwiftBugParser  SwiftBugParser.java /SwiftMessage/antlr-generated   line 193    Java Problem
The method matchRange(char, char) is undefined for the type SwiftBugParser  SwiftBugParser.java /SwiftMessage/antlr-generated   line 195    Java Problem
Syntax error on token "(", Expression expected after this token SwiftBugParser.java /SwiftMessage/antlr-generated   line 201    Java Problem
Syntax error on token "(", Expression expected after this token SwiftBugParser.java /SwiftMessage/antlr-generated   line 208    Java Problem

Problems while installing the antlr-2.7.7. version. Please help me out with this!

I downloaded the antlr-2.7.7.tar from internet.
I unpacked it to the local directory.
I run the configure script with --disable-examples option.
I run the makefile
I run the makefile with install option.( At this stage it says installation is successful.)
If i cross check for proper installation. By running " java antlr.Tool --version" ( I have set the class peth to antlr.jar) i get java related error and the error msg is :

java.lang.NoClassDefFoundError: antlr/Tool
Caused by: java.lang.ClassNotFoundException: antlr.Tool
at java.net.URLClassLoader$1.run(Unknown Source)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
Could not find the main class: antlr.Tool. Program will exit.

Please help me out with this. I am stuck at this point and i dont know how to proceed. Thans in advance.

Ambiguity at k=1 prevents full context parsing

Consider the following grammar:

grammar T;
start : s s EOF;
s : | x;
x : 'a' 'b';

When given the input abab, it should report the following with DiagnosticErrorStrategy:

line 1:0 reportAttemptingFullContext d=0: [(10,1,[]), (18,1,[14 8]), (18,2,[14 6])], input='a'
line 1:2 reportContextSensitivity d=0: [(20,2,[14 8])],uniqueAlt=2, input='aba'
line 1:2 reportAttemptingFullContext d=0: [(10,1,[]), (18,2,[14 8])], input='a'
line 1:2 reportContextSensitivity d=0: [(20,2,[14 8])],uniqueAlt=2, input='a'

However, with the k == 1 test in ParserATNSimulator.execATN, full context parsing is not attempted and the output is:

line 1:0 reportAmbiguity d=0: ambigAlts={1..2}:[(20,1,[14 8],up=1), (20,2,[14])],conflictingAlts={1..2},dipsIntoOuterContext, input='a'
line 1:0 mismatched input 'a' expecting <EOF>

Stack overflow in antlr3-maven-plugin version 3.4

Hello,

when running the following grammar through antlr3 using the maven plugin, I get a Stack Overflow. Even if the grammar is faulty, I'd expect an exception/error message instead. Using plugin and runtime version 3.3, I get files generated as expected. This is the stack trace:

Exception in thread "main" java.lang.StackOverflowError
at java.util.AbstractCollection.addAll(AbstractCollection.java:333)
at java.util.HashSet.(HashSet.java:117)
at org.antlr.analysis.SemanticContext.factorOr(SemanticContext.java:753)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:609)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at org.antlr.analysis.SemanticContext.and(SemanticContext.java:616)
at or

Consistent naming for combined and separated grammars

Here is the current naming:

Combined

grammar Foo;

• FooLexer, FooParser
• FooListener, FooBaseListener
• FooParseListener, FooBaseParseListener
• FooVisitor, FooBaseVisitor

Separated

lexer grammar FooLexer;
parser grammar FooParser;

• FooLexer, FooParser
• FooParserListener, FooParserBaseListener
• FooParserParseListener, FooParserBaseParseListener
• FooParserVisitor, FooParserBaseVisitor

Request

I find that in ANTLR 4 I'm more likely to use separated grammars than combined grammars. However, I wish the names of listeners/visitors generated by the separated grammars to match those of the combined grammar. In particular, if (and only if) a parser grammar is named *Parser, I'd like to drop the Parser suffix as part of deriving the generated file names.

Semantic predicates prevent fallback to full-context parsing

Currently full-context parsing is prevented when one or more configs contain semantic predicates. However, full-context parsing may eliminate one or more configs before the predicate evaluation stage which could change the predicted alternative.