public final Enum ErrorType

Compiler Error 94.

redefinition of action action

Compiler Warning 118.

all operators of alt alt of left-recursive rule must have same associativity

Compiler Error 124.

rule alt label label conflicts with rule rule

Compiler Error 123.

rule alt label label redefined in rule rule1, originally in rule rule2

Compiler Error 138.

parameter parameter conflicts with rule with same name

Compiler Error 139.

parameter parameter conflicts with token with same name

Compiler Error 135.

cannot assign a value to list label label

Compiler Error 128.

attribute references not allowed in lexer actions: expression

Compiler Error 9.

invalid -Dname=value syntax: syntax

Compiler Error 31.

ANTLR cannot generate language code as of version version

Compiler Error 121.

cannot find an attribute name in attribute declaration

Compiler Error 110.

can't find or load grammar grammar from filename

Compiler Error 3.

cannot find tokens file filename

Compiler Error 114.

cannot find tokens file filename

Compiler Error 7.

cannot find or open file: filename

Compiler Error 1.

cannot write file filename: reason

Compiler Error 172.

can not use or declare channel with reserved name

Reserved names: DEFAULT_MODE, SKIP, MORE, EOF, MAX_CHAR_VALUE, MIN_CHAR_VALUE.

Can be used but cannot be declared: HIDDEN, DEFAULT_TOKEN_CHANNEL

Compiler Error 162.

channel name conflicts with mode with same name

Compiler Error 161.

channel name conflicts with token with same name

Compiler Error 164.

custom channels are not supported in combined grammars

Compiler Error 163.

custom channels are not supported in parser grammars

Compiler Warning 180.

chars "a-f" used multiple times in set [a-fc-m]

A:    [aa-z];   // warning
B:    [a-fc-m]; // warning

The error or warning number.

The code should be unique, and following its use in a release should not be altered or reassigned.

Compiler Error 33.

missing code generation template template

Compiler Error 32.

code generation template template has missing, misnamed, or incomplete arg list; missing field

Compiler Error 177.

name is not a recognized channel name

TOKEN: 'a' -> channel(TOKEN1); // error 177

Compiler Error 176.

nameis not a recognized mode name

TOKEN: 'a' -> mode(MODE1); // error 176

Compiler Error 175.

name is not a recognized token name

TOKEN: 'a' -> type(CHANNEL1); // error 175

Compiler Error 5.

directory not found: directory

Compiler Error 174.

empty strings and sets not allowed

A: '''test''';
B: '';
C: 'test' '';
D: [];
E: [f-a];

rule rule contains a closure with at least one alternative that can match EOF

A rule contains a closure ((...)*) or positive closure ((...)+) around EOF.

The following rule produces this error.

x : EOF*;         // error
y : EOF+;         // error
z : EOF;         // ok

Compiler Error 153.

rule rule contains a closure with at least one alternative that can match an empty string

A rule contains a closure ((...)*) or positive closure ((...)+) around an empty alternative.

The following rule produces this error.

x  : ;
y  : x+;                                // error 153
z1 : ('foo' | 'bar'? 'bar2'?)*;         // error 153
z2 : ('foo' | 'bar' 'bar2'? | 'bar2')*; // ok

Since

4.1

Compiler Error 148.

left recursive rule rule contains a left recursive alternative which can be followed by the empty string

In left-recursive rules, all left-recursive alternatives must match at least one symbol following the recursive rule invocation.

The following rule produces this error.

a : ID    // ok        (alternative is not left recursive)
  | a INT // ok        (a must be follow by INT)
  | a ID? // error 148 (the ID following a is optional)
  ;

Compiler Warning 154.

rule rule contains an optional block with at least one alternative that can match an empty string

A rule contains an optional block ((...)?) around an empty alternative.

The following rule produces this warning.

x  : ;
y  : x?;                                // warning 154
z1 : ('foo' | 'bar'? 'bar2'?)?;         // warning 154
z2 : ('foo' | 'bar' 'bar2'? | 'bar2')?; // ok

Since

4.1

Compiler Warning 146.

non-fragment lexer rule rule can match the empty string

All non-fragment lexer rules must match at least one character.

The following example shows this error.

Whitespace : [ \t]+;  // ok
Whitespace : [ \t];   // ok

fragment WS : [ \t]*; // ok

Whitespace : [ \t]*;  // error 146

Compiler Error 11.

cannot find tokens file filename: reason

Compiler Error 4.

cannot find tokens file filename: reason

Compiler Warning 131.

This warning may take any of the following forms.

• greedy block ()* contains wildcard; the non-greedy syntax ()*? may be preferred
• greedy block ()+ contains wildcard; the non-greedy syntax ()+? may be preferred

Compiler Error 8.

grammar name name and file name filename differ

Compiler Warning 158.

fragment rule rule contains an action or command which can never be executed

A lexer rule which is marked with the fragment modifier contains an embedded action or lexer command. ANTLR lexers only execute commands and embedded actions located in the top-level matched rule. Since fragment rules can never be the top-level rule matched by a lexer, actions or commands placed in these rules can never be executed during the lexing process.

The following rule produces this warning.

X1 : 'x' -> more    // ok
   ;
Y1 : 'x' {more();}  // ok
   ;
fragment
X2 : 'x' -> more    // warning 158
   ;
fragment
Y2 : 'x' {more();}  // warning 158
   ;

Since

4.2.1

Compiler Warning 83.

unsupported option option

Compiler Warning 84.

unsupported option value name=value

Compiler Error 126.

cannot create implicit token for string literal in non-combined grammar: literal

Compiler Warning 125.

implicit definition of token Token in parser

Compiler Error 113.

grammartype grammar grammar1 and imported grammartype grammar grammar2 both generate recognizer

Compiler Error 35.

templates/target and tool aren't compatible

Compiler Error 20.

internal error: message

Compiler Error 2.

unknown command-line option option

Compiler Error 156.

invalid escape sequence

The grammar contains a string literal with an invalid escape sequence.

The following rule produces this error.

x : 'x';  // ok
y : '\u'; // error 156

Since

4.2.1

Compiler Error 111.

grammartype grammar grammar1 cannot import grammartype grammar grammar2

Compiler Error 149.

lexer command command does not exist or is not supported by the current target

Each lexer command requires an explicit implementation in the target templates. This error indicates that the command was incorrectly written or is not supported by the current target.

The following rule produces this error.

X : 'foo' -> type(Foo);  // ok
Y : 'foo' -> token(Foo); // error 149 (token is not a supported lexer command)

Since

4.1

Compiler Error 144.

multi-character literals are not allowed in lexer sets: literal

Compiler Error 64.

parameter parameter of rule rule is not accessible in this scope: expression

Compiler Error 67.

missing attribute access on rule reference rule in expression

Compiler Error 130.

label label assigned to a block which is not a set

Compiler Error 72.

label label conflicts with parameter with same name

Compiler Error 74.

label label conflicts with local with same name

Compiler Error 73.

label label conflicts with return value with same name

Compiler Error 69.

label label conflicts with rule with same name

Compiler Error 70.

label label conflicts with token with same name

Compiler Error 75.

label label type mismatch with previous definition: message

Compiler Error 119.

The following sets of rules are mutually left-recursive [rules]

Compiler Error 132.

action in lexer rule rule must be last element of single outermost alt

Compiler Error 133.

->command in lexer rule rule must be last element of single outermost alt

Compiler Error 52.

lexer rule rule not allowed in parser

Compiler Error 142.

local local conflicts with parameter with same name

Compiler Error 143.

local local conflicts with return value with same name

Compiler Error 140.

local local conflicts with rule with same name

Compiler Error 141.

local local conflicts with rule token same name

Compiler Error 30.

can't find code generation templates: group

Compiler Error 150.

missing argument for lexer command command

Some lexer commands require an argument.

The following rule produces this error.

X : 'foo' -> type(Foo); // ok
Y : 'foo' -> type;      // error 150 (the type command requires an argument)

Since

4.1

Compiler Error 79.

missing argument(s) on rule reference: rule

Compiler Error 173.

can not use or declare mode with reserved name

Reserved names: HIDDEN, DEFAULT_TOKEN_CHANNEL, SKIP, MORE, MAX_CHAR_VALUE, MIN_CHAR_VALUE.

Can be used and cannot declared: DEFAULT_MODE

Compiler Error 170.

mode M1;
A1: 'a'; // ok
mode M2;
A2: 'a'; // ok
M1: 'b'; // error 170

mode name conflicts with token with same name

Compiler Error 120.

lexical modes are only allowed in lexer grammars

Compiler Error 145.

lexer mode mode must contain at least one non-fragment rule

Every lexer mode must contain at least one rule which is not declared with the fragment modifier.

The error or warning message, in StringTemplate 4 format using < and > as the delimiters. Arguments for the message may be referenced using the following names:

• arg: The first template argument
• arg2: The second template argument
• arg3: The third template argument
• verbose: true if verbose messages were requested; otherwise, false
• exception: The exception which resulted in the error, if any.
• stackTrace: The stack trace for the exception, when available.

Compiler Error 34.

no mapping to template name for output model class class

Compiler Error 147.

left recursive rule rule must contain an alternative which is not left recursive

Left-recursive rules must contain at least one alternative which is not left recursive.

The following rule produces this error.

// error 147:
a : a ID
  | a INT
  ;

Compiler Error 99.

This error may take any of the following forms.

• grammar grammar has no rules
• implicitly generated grammar grammar has no rules

Compiler Error 105.

reference to undefined grammar in rule reference: grammar.rule

Compiler Error 106.

rule rule is not defined in grammar grammar

Compiler Warning 109.

options ignored in imported grammar grammar

Compiler Error 6.

output directory is a file: filename

Compiler Error 160.

reference to parser rule rule in lexer rule name

See Also

UNDEFINED_RULE_REF

Compiler Error 53.

parser rule rule not allowed in lexer

Range probably contains not implied characters. Both bounds should be defined in lower or UPPER case For instance, the range [A-z] (ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy) probably contains not implied characters: [\]^_` Use the following definition: [A-Za-z] If the characters are implied, include them explicitly: [A-Za-z[\\\]^_`]

TOKEN: [A-z]; // warning

Redundant caseInsensitive lexer rule option

options { caseInsensitive=true; }
TOKEN options { caseInsensitive=true; } : [a-z]+ -> caseInsensitive(true); // warning

Compiler Error 54.

repeated grammar prequel spec (options, tokens, or import); please merge

Compiler Error 159.

cannot declare a rule with reserved name rule

A rule was declared with a reserved name.

The following rule produces this error.

EOF :  ' '   // error 159 (EOF is a reserved name)
    ;

Since

4.2.1

Compiler Error 76.

return value name conflicts with parameter with same name

Compiler Error 136.

return value name conflicts with rule with same name

Compiler Error 137.

return value name conflicts with token with same name

Compiler Error 80.

rule rule has no defined parameters

Compiler Error 51.

rule rule redefinition; previous at line line

Compiler Error 122.

rule rule: must label all alternatives or none

The error severity.

Compiler Warning 22.

template error: message

Compiler Error 50.

syntax error: message

Compiler Error 171.

can not use or declare token with reserved name

Reserved names: HIDDEN, DEFAULT_TOKEN_CHANNEL, SKIP, MORE, MAX_CHAR_VALUE, MIN_CHAR_VALUE.

Can be used but cannot be declared: EOF

Compiler Warning 108.

token name Token is already defined

Compiler Error 60.

token names must start with an uppercase letter: name

Compiler Warning 181

The token range operator makes no sense in the parser as token types are not ordered (except in implementation).

grammar T;
a : 'A'..'Z' ;

Compiler Warning 184.

The token value overlapped by another token or self

TOKEN1: 'value';
TOKEN2: 'value'; // warning

Compiler Error 21.

.tokens file syntax error filename: message

Compiler Error 57.

reference to undefined rule rule in non-local ref reference

Compiler Error 56.

reference to undefined rule: rule

See Also

PARSER_RULE_REF_IN_LEXER_RULE

Compiler Error 182.

Unicode properties cannot be part of a lexer charset range

A: [\\p{Letter}-\\p{Number}];

Compiler Error 66.

attribute attribute isn't a valid property in expression

Compiler Warning 155.

rule rule contains a lexer command with an unrecognized constant value; lexer interpreters may produce incorrect output

A lexer rule contains a standard lexer command, but the constant value argument for the command is an unrecognized string. As a result, the lexer command will be translated as a custom lexer action, preventing the command from executing in some interpreted modes. The output of the lexer interpreter may not match the output of the generated lexer.

The following rule produces this warning.

@members {
public static final int CUSTOM = HIDDEN + 1;
}

X : 'foo' -> channel(HIDDEN);           // ok
Y : 'bar' -> channel(CUSTOM);           // warning 155

Since

4.2

Compiler Error 65.

unknown attribute attribute for rule rule in expression

Compiler Error 63.

unknown attribute reference attribute in expression

Compiler Warning 157.

rule rule contains an assoc element option in an unrecognized location

In ANTLR 4.2, the position of the assoc element option was moved from the operator terminal(s) to the alternative itself. This warning is reported when an assoc element option is specified on a grammar element that is not recognized by the current version of ANTLR, and as a result will simply be ignored.

The following rule produces this warning.

x : 'x'
  | x '+'<assoc=right> x   // warning 157
  |<assoc=right> x * x   // ok
  ;

Since

4.2.1

Compiler Error 183.

rule reference rule is not currently supported in a set

Compiler Error 152.

unterminated string literal

The grammar contains an unterminated string literal.

The following rule produces this error.

x : 'x'; // ok
y : 'y';  // error 152

Since

4.1

Compiler Error 151.

lexer command command does not take any arguments

A lexer command which does not take parameters was invoked with an argument.

The following rule produces this error.

X : 'foo' -> popMode;    // ok
Y : 'foo' -> popMode(A); // error 151 (the popMode command does not take an argument)

Since

4.1

Compiler Error 134.

symbol symbol conflicts with generated code in target language or runtime

Compiler Error 203.

assignments in tokens{} are not supported in ANTLR 4; use lexical rule TokenName : LiteralValue; instead

ANTLR 3 allowed literal tokens to be declared and assigned a value within the tokens{} block. ANTLR 4 no longer offers this syntax. When migrating a grammar from ANTLR 3 to ANTLR 4, any tokens with a literal value declared in the tokens{} block should be converted to standard lexer rules.

Compiler Warning 204.

{...}?=> explicitly gated semantic predicates are deprecated in ANTLR 4; use {...}? instead

ANTLR 4 treats semantic predicates consistently in a manner similar to gated semantic predicates in ANTLR 3. When migrating a grammar from ANTLR 3 to ANTLR 4, all uses of the gated semantic predicate syntax can be safely converted to the standard semantic predicated syntax, which is the only form used by ANTLR 4.

Compiler Warning 201.

labels in lexer rules are not supported in ANTLR 4; actions cannot reference elements of lexical rules but you can use Lexer#getText() to get the entire text matched for the rule

ANTLR 4 uses a DFA for recognition of entire tokens, resulting in faster and smaller lexers than ANTLR 3 produced. As a result, sub-rules referenced within lexer rules are not tracked independently, and cannot be assigned to labels.

Compiler Error 205.

(...)=> syntactic predicates are not supported in ANTLR 4

ANTLR 4's improved lookahead algorithms do not require the use of syntactic predicates to disambiguate long lookahead sequences. The syntactic predicates should be removed when migrating a grammar from ANTLR 3 to ANTLR 4.

Compiler Warning 202.

tokens {A; B;} syntax is now tokens {A, B} in ANTLR 4

ANTLR 4 uses comma-separated token declarations in the tokens{} block. This warning appears when the tokens block is written using the ANTLR 3 syntax of semicolon-terminated token declarations.

Compiler Error 200.

tree grammars are not supported in ANTLR 4

This error message is provided as a compatibility notice for users migrating from ANTLR 3. ANTLR 4 does not support tree grammars, but instead offers automatically generated parse tree listeners and visitors as a more maintainable alternative.

Compiler Error 10.

warning treated as error