ANTLR Tool Source Code
ANTLR is a powerful parser generator for multiple programming languages
including Java.
ANTLR contains 2 major modules:
- Runtime - For building and executing parsers/lexers generated in Java.
- Tool (The Parser Generator) - For generating parsers/lexers Java class.
ANTLR Tool Source Code files are provided in the distribution packge (antlr4-4.10.1.zip). You can download them at ANTLR Website.
You can also browse the source code below:
✍: FYIcenter
⏎ org/antlr/v4/tool/ErrorType.java
/*
* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
* Use of this file is governed by the BSD 3-clause license that
* can be found in the LICENSE.txt file in the project root.
*/
package org.antlr.v4.tool;
import org.antlr.v4.Tool;
import org.antlr.v4.runtime.Lexer;
/**
* A complex enumeration of all the error messages that the tool can issue.
* <p>
* When adding error messages, also add a description of the message to the
* Wiki with a location under the Wiki page
* <a href="http://www.antlr.org/wiki/display/ANTLR4/Errors+Reported+by+the+ANTLR+Tool">Errors Reported by the ANTLR Tool</a>.
*
* @author Jim Idle <jimi@temporal-wave.com>, Terence Parr
* @since 4.0
*/
public enum ErrorType {
/*
* Tool errors
*/
/**
* Compiler Error 1.
*
* <p>cannot write file <em>filename</em>: <em>reason</em></p>
*/
CANNOT_WRITE_FILE(1, "cannot write file <arg>: <arg2>", ErrorSeverity.ERROR),
/**
* Compiler Error 2.
*
* <p>unknown command-line option <em>option</em></p>
*/
INVALID_CMDLINE_ARG(2, "unknown command-line option <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 3.
*
* <p>cannot find tokens file <em>filename</em></p>
*/
CANNOT_FIND_TOKENS_FILE_GIVEN_ON_CMDLINE(3, "cannot find tokens file <arg> given for <arg2>", ErrorSeverity.ERROR),
/**
* Compiler Error 4.
*
* <p>cannot find tokens file <em>filename</em>: <em>reason</em></p>
*/
ERROR_READING_TOKENS_FILE(4, "error reading tokens file <arg>: <arg2>", ErrorSeverity.ERROR),
/**
* Compiler Error 5.
*
* <p>directory not found: <em>directory</em></p>
*/
DIR_NOT_FOUND(5, "directory not found: <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 6.
*
* <p>output directory is a file: <em>filename</em></p>
*/
OUTPUT_DIR_IS_FILE(6, "output directory is a file: <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 7.
*
* <p>cannot find or open file: <em>filename</em></p>
*/
CANNOT_OPEN_FILE(7, "cannot find or open file: <arg><if(exception&&verbose)>; reason: <exception><endif>", ErrorSeverity.ERROR),
/**
* Compiler Error 8.
*
* <p>
* grammar name <em>name</em> and file name <em>filename</em> differ</p>
*/
FILE_AND_GRAMMAR_NAME_DIFFER(8, "grammar name <arg> and file name <arg2> differ", ErrorSeverity.ERROR),
/**
* Compiler Error 9.
*
* <p>invalid {@code -Dname=value} syntax: <em>syntax</em></p>
*/
BAD_OPTION_SET_SYNTAX(9, "invalid -Dname=value syntax: <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 10.
*
* <p>warning treated as error</p>
*/
WARNING_TREATED_AS_ERROR(10, "warning treated as error", ErrorSeverity.ERROR_ONE_OFF),
/**
* Compiler Error 11.
*
* <p>cannot find tokens file <em>filename</em>: <em>reason</em></p>
*/
ERROR_READING_IMPORTED_GRAMMAR(11, "error reading imported grammar <arg> referenced in <arg2>", ErrorSeverity.ERROR),
/**
* Compiler Error 20.
*
* <p>internal error: <em>message</em></p>
*/
INTERNAL_ERROR(20, "internal error: <arg> <arg2><if(exception&&verbose)>: <exception>" +
"<stackTrace; separator=\"\\n\"><endif>", ErrorSeverity.ERROR),
/**
* Compiler Error 21.
*
* <p>.tokens file syntax error <em>filename</em>: <em>message</em></p>
*/
TOKENS_FILE_SYNTAX_ERROR(21, ".tokens file syntax error <arg>:<arg2>", ErrorSeverity.ERROR),
/**
* Compiler Warning 22.
*
* <p>template error: <em>message</em></p>
*/
STRING_TEMPLATE_WARNING(22, "template error: <arg> <arg2><if(exception&&verbose)>: <exception>" +
"<stackTrace; separator=\"\\n\"><endif>", ErrorSeverity.WARNING),
/*
* Code generation errors
*/
/**
* Compiler Error 30.
*
* <p>can't find code generation templates: <em>group</em></p>
*/
MISSING_CODE_GEN_TEMPLATES(30, "can't find code generation templates: <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 31.
*
* <p>
* ANTLR cannot generate <em>language</em> code as of version
* <em>version</em></p>
*/
CANNOT_CREATE_TARGET_GENERATOR(31, "ANTLR cannot generate <arg> code as of version "+ Tool.VERSION, ErrorSeverity.ERROR_ONE_OFF),
/**
* Compiler Error 32.
*
* <p>
* code generation template <em>template</em> has missing, misnamed, or
* incomplete arg list; missing <em>field</em></p>
*/
CODE_TEMPLATE_ARG_ISSUE(32, "code generation template <arg> has missing, misnamed, or incomplete arg list; missing <arg2>", ErrorSeverity.ERROR),
/**
* Compiler Error 33.
*
* <p>missing code generation template <em>template</em></p>
*/
CODE_GEN_TEMPLATES_INCOMPLETE(33, "missing code generation template <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 34.
*
* <p>
* no mapping to template name for output model class <em>class</em></p>
*/
NO_MODEL_TO_TEMPLATE_MAPPING(34, "no mapping to template name for output model class <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 35.
*
* <p>templates/target and tool aren't compatible</p>
*/
INCOMPATIBLE_TOOL_AND_TEMPLATES(35, "<arg3> code generation target requires ANTLR <arg2>; it can't be loaded by the current ANTLR <arg>", ErrorSeverity.ERROR),
/*
* Grammar errors
*/
/**
* Compiler Error 50.
*
* <p>syntax error: <em>message</em></p>
*/
SYNTAX_ERROR(50, "syntax error: <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 51.
*
* <p>rule <em>rule</em> redefinition; previous at line <em>line</em></p>
*/
RULE_REDEFINITION(51, "rule <arg> redefinition; previous at line <arg2>", ErrorSeverity.ERROR),
/**
* Compiler Error 52.
*
* <p>lexer rule <em>rule</em> not allowed in parser</p>
*/
LEXER_RULES_NOT_ALLOWED(52, "lexer rule <arg> not allowed in parser", ErrorSeverity.ERROR),
/**
* Compiler Error 53.
*
* <p>parser rule <em>rule</em> not allowed in lexer</p>
*/
PARSER_RULES_NOT_ALLOWED(53, "parser rule <arg> not allowed in lexer", ErrorSeverity.ERROR),
/**
* Compiler Error 54.
*
* <p>
* repeated grammar prequel spec ({@code options}, {@code tokens}, or
* {@code import}); please merge</p>
*/
REPEATED_PREQUEL(54, "repeated grammar prequel spec (options, tokens, or import); please merge", ErrorSeverity.ERROR),
/**
* Compiler Error 56.
*
* <p>reference to undefined rule: <em>rule</em></p>
*
* @see #PARSER_RULE_REF_IN_LEXER_RULE
*/
UNDEFINED_RULE_REF(56, "reference to undefined rule: <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 57.
*
* <p>
* reference to undefined rule <em>rule</em> in non-local ref
* <em>reference</em></p>
*/
UNDEFINED_RULE_IN_NONLOCAL_REF(57, "reference to undefined rule <arg> in non-local ref <arg3>", ErrorSeverity.ERROR),
/**
* Compiler Error 60.
*
* <p>token names must start with an uppercase letter: <em>name</em></p>
*/
TOKEN_NAMES_MUST_START_UPPER(60, "token names must start with an uppercase letter: <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 63.
*
* <p>
* unknown attribute reference <em>attribute</em> in
* <em>expression</em></p>
*/
UNKNOWN_SIMPLE_ATTRIBUTE(63, "unknown attribute reference <arg> in <arg2>", ErrorSeverity.ERROR),
/**
* Compiler Error 64.
*
* <p>
* parameter <em>parameter</em> of rule <em>rule</em> is not accessible
* in this scope: <em>expression</em></p>
*/
INVALID_RULE_PARAMETER_REF(64, "parameter <arg> of rule <arg2> is not accessible in this scope: <arg3>", ErrorSeverity.ERROR),
/**
* Compiler Error 65.
*
* <p>
* unknown attribute <em>attribute</em> for rule <em>rule</em> in
* <em>expression</em></p>
*/
UNKNOWN_RULE_ATTRIBUTE(65, "unknown attribute <arg> for rule <arg2> in <arg3>", ErrorSeverity.ERROR),
/**
* Compiler Error 66.
*
* <p>
* attribute <em>attribute</em> isn't a valid property in
* <em>expression</em></p>
*/
UNKNOWN_ATTRIBUTE_IN_SCOPE(66, "attribute <arg> isn't a valid property in <arg2>", ErrorSeverity.ERROR),
/**
* Compiler Error 67.
*
* <p>
* missing attribute access on rule reference <em>rule</em> in
* <em>expression</em></p>
*/
ISOLATED_RULE_REF(67, "missing attribute access on rule reference <arg> in <arg2>", ErrorSeverity.ERROR),
/**
* Compiler Error 69.
*
* <p>label <em>label</em> conflicts with rule with same name</p>
*/
LABEL_CONFLICTS_WITH_RULE(69, "label <arg> conflicts with rule with same name", ErrorSeverity.ERROR),
/**
* Compiler Error 70.
*
* <p>label <em>label</em> conflicts with token with same name</p>
*/
LABEL_CONFLICTS_WITH_TOKEN(70, "label <arg> conflicts with token with same name", ErrorSeverity.ERROR),
/**
* Compiler Error 72.
*
* <p>label <em>label</em> conflicts with parameter with same name</p>
*/
LABEL_CONFLICTS_WITH_ARG(72, "label <arg> conflicts with parameter with same name", ErrorSeverity.ERROR),
/**
* Compiler Error 73.
*
* <p>label <em>label</em> conflicts with return value with same name</p>
*/
LABEL_CONFLICTS_WITH_RETVAL(73, "label <arg> conflicts with return value with same name", ErrorSeverity.ERROR),
/**
* Compiler Error 74.
*
* <p>label <em>label</em> conflicts with local with same name</p>
*/
LABEL_CONFLICTS_WITH_LOCAL(74, "label <arg> conflicts with local with same name", ErrorSeverity.ERROR),
/**
* Compiler Error 75.
*
* <p>
* label <em>label</em> type mismatch with previous definition:
* <em>message</em></p>
*/
LABEL_TYPE_CONFLICT(75, "label <arg> type mismatch with previous definition: <arg2>", ErrorSeverity.ERROR),
/**
* Compiler Error 76.
*
* <p>
* return value <em>name</em> conflicts with parameter with same name</p>
*/
RETVAL_CONFLICTS_WITH_ARG(76, "return value <arg> conflicts with parameter with same name", ErrorSeverity.ERROR),
/**
* Compiler Error 79.
*
* <p>missing argument(s) on rule reference: <em>rule</em></p>
*/
MISSING_RULE_ARGS(79, "missing argument(s) on rule reference: <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 80.
*
* <p>rule <em>rule</em> has no defined parameters</p>
*/
RULE_HAS_NO_ARGS(80, "rule <arg> has no defined parameters", ErrorSeverity.ERROR),
/**
* Compiler Warning 83.
*
* <p>unsupported option <em>option</em></p>
*/
ILLEGAL_OPTION(83, "unsupported option <arg>", ErrorSeverity.WARNING),
/**
* Compiler Warning 84.
*
* <p>unsupported option value <em>name</em>=<em>value</em></p>
*/
ILLEGAL_OPTION_VALUE(84, "unsupported option value <arg>=<arg2>", ErrorSeverity.WARNING),
/**
* Compiler Error 94.
*
* <p>redefinition of <em>action</em> action</p>
*/
ACTION_REDEFINITION(94, "redefinition of <arg> action", ErrorSeverity.ERROR),
/**
* Compiler Error 99.
*
* <p>This error may take any of the following forms.</p>
*
* <ul>
* <li>grammar <em>grammar</em> has no rules</li>
* <li>implicitly generated grammar <em>grammar</em> has no rules</li>
* </ul>
*/
NO_RULES(99, "<if(arg2.implicitLexerOwner)>implicitly generated <endif>grammar <arg> has no rules", ErrorSeverity.ERROR),
/**
* Compiler Error 105.
*
* <p>
* reference to undefined grammar in rule reference:
* <em>grammar</em>.<em>rule</em></p>
*/
NO_SUCH_GRAMMAR_SCOPE(105, "reference to undefined grammar in rule reference: <arg>.<arg2>", ErrorSeverity.ERROR),
/**
* Compiler Error 106.
*
* <p>rule <em>rule</em> is not defined in grammar <em>grammar</em></p>
*/
NO_SUCH_RULE_IN_SCOPE(106, "rule <arg2> is not defined in grammar <arg>", ErrorSeverity.ERROR),
/**
* Compiler Warning 108.
*
* <p>token name <em>Token</em> is already defined</p>
*/
TOKEN_NAME_REASSIGNMENT(108, "token name <arg> is already defined", ErrorSeverity.WARNING),
/**
* Compiler Warning 109.
*
* <p>options ignored in imported grammar <em>grammar</em></p>
*/
OPTIONS_IN_DELEGATE(109, "options ignored in imported grammar <arg>", ErrorSeverity.WARNING),
/**
* Compiler Error 110.
*
* <p>
* can't find or load grammar <em>grammar</em> from
* <em>filename</em></p>
*/
CANNOT_FIND_IMPORTED_GRAMMAR(110, "can't find or load grammar <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 111.
*
* <p>
* <em>grammartype</em> grammar <em>grammar1</em> cannot import
* <em>grammartype</em> grammar <em>grammar2</em></p>
*/
INVALID_IMPORT(111, "<arg.typeString> grammar <arg.name> cannot import <arg2.typeString> grammar <arg2.name>", ErrorSeverity.ERROR),
/**
* Compiler Error 113.
*
* <p>
* <em>grammartype</em> grammar <em>grammar1</em> and imported
* <em>grammartype</em> grammar <em>grammar2</em> both generate
* <em>recognizer</em></p>
*/
IMPORT_NAME_CLASH(113, "<arg.typeString> grammar <arg.name> and imported <arg2.typeString> grammar <arg2.name> both generate <arg2.recognizerName>", ErrorSeverity.ERROR),
/**
* Compiler Error 114.
*
* <p>cannot find tokens file <em>filename</em></p>
*/
CANNOT_FIND_TOKENS_FILE_REFD_IN_GRAMMAR(114, "cannot find tokens file <arg>", ErrorSeverity.ERROR),
/**
* Compiler Warning 118.
*
* <p>
* all operators of alt <em>alt</em> of left-recursive rule must have same
* associativity</p>
*
* @deprecated This warning is no longer applicable with the current syntax for specifying associativity.
*/
@Deprecated
ALL_OPS_NEED_SAME_ASSOC(118, "all operators of alt <arg> of left-recursive rule must have same associativity", ErrorSeverity.WARNING),
/**
* Compiler Error 119.
*
* <p>
* The following sets of rules are mutually left-recursive
* <em>[rules]</em></p>
*/
LEFT_RECURSION_CYCLES(119, "The following sets of rules are mutually left-recursive <arg:{c| [<c:{r|<r.name>}; separator=\", \">]}; separator=\" and \">", ErrorSeverity.ERROR),
/**
* Compiler Error 120.
*
* <p>lexical modes are only allowed in lexer grammars</p>
*/
MODE_NOT_IN_LEXER(120, "lexical modes are only allowed in lexer grammars", ErrorSeverity.ERROR),
/**
* Compiler Error 121.
*
* <p>cannot find an attribute name in attribute declaration</p>
*/
CANNOT_FIND_ATTRIBUTE_NAME_IN_DECL(121, "cannot find an attribute name in attribute declaration", ErrorSeverity.ERROR),
/**
* Compiler Error 122.
*
* <p>rule <em>rule</em>: must label all alternatives or none</p>
*/
RULE_WITH_TOO_FEW_ALT_LABELS(122, "rule <arg>: must label all alternatives or none", ErrorSeverity.ERROR),
/**
* Compiler Error 123.
*
* <p>
* rule alt label <em>label</em> redefined in rule <em>rule1</em>,
* originally in rule <em>rule2</em></p>
*/
ALT_LABEL_REDEF(123, "rule alt label <arg> redefined in rule <arg2>, originally in rule <arg3>", ErrorSeverity.ERROR),
/**
* Compiler Error 124.
*
* <p>
* rule alt label <em>label</em> conflicts with rule <em>rule</em></p>
*/
ALT_LABEL_CONFLICTS_WITH_RULE(124, "rule alt label <arg> conflicts with rule <arg2>", ErrorSeverity.ERROR),
/**
* Compiler Warning 125.
*
* <p>implicit definition of token <em>Token</em> in parser</p>
*/
IMPLICIT_TOKEN_DEFINITION(125, "implicit definition of token <arg> in parser", ErrorSeverity.WARNING),
/**
* Compiler Error 126.
*
* <p>
* cannot create implicit token for string literal in non-combined grammar:
* <em>literal</em></p>
*/
IMPLICIT_STRING_DEFINITION(126, "cannot create implicit token for string literal in non-combined grammar: <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 128.
*
* <p>
* attribute references not allowed in lexer actions:
* <em>expression</em></p>
*/
ATTRIBUTE_IN_LEXER_ACTION(128, "attribute references not allowed in lexer actions: $<arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 130.
*
* <p>label <em>label</em> assigned to a block which is not a set</p>
*/
LABEL_BLOCK_NOT_A_SET(130, "label <arg> assigned to a block which is not a set", ErrorSeverity.ERROR),
/**
* Compiler Warning 131.
*
* <p>This warning may take any of the following forms.</p>
*
* <ul>
* <li>greedy block {@code ()*} contains wildcard; the non-greedy syntax {@code ()*?} may be preferred</li>
* <li>greedy block {@code ()+} contains wildcard; the non-greedy syntax {@code ()+?} may be preferred</li>
* </ul>
*/
EXPECTED_NON_GREEDY_WILDCARD_BLOCK(131, "greedy block ()<arg> contains wildcard; the non-greedy syntax ()<arg>? may be preferred", ErrorSeverity.WARNING),
/**
* Compiler Error 132.
*
* <p>
* action in lexer rule <em>rule</em> must be last element of single
* outermost alt</p>
*
* @deprecated This error is no longer issued by ANTLR 4.2.
*/
@Deprecated
LEXER_ACTION_PLACEMENT_ISSUE(132, "action in lexer rule <arg> must be last element of single outermost alt", ErrorSeverity.ERROR),
/**
* Compiler Error 133.
*
* <p>
* {@code ->command} in lexer rule <em>rule</em> must be last element of
* single outermost alt</p>
*/
LEXER_COMMAND_PLACEMENT_ISSUE(133, "->command in lexer rule <arg> must be last element of single outermost alt", ErrorSeverity.ERROR),
/**
* Compiler Error 134.
*
* <p>
* symbol <em>symbol</em> conflicts with generated code in target language
* or runtime</p>
*/
@Deprecated
USE_OF_BAD_WORD(134, "symbol <arg> conflicts with generated code in target language or runtime", ErrorSeverity.ERROR),
/**
* Compiler Error 183.
*
* <p>rule reference <em>rule</em> is not currently supported in a set</p>
*/
UNSUPPORTED_REFERENCE_IN_LEXER_SET(183, "rule reference <arg> is not currently supported in a set", ErrorSeverity.ERROR),
/**
* Compiler Error 135.
*
* <p>cannot assign a value to list label <em>label</em></p>
*/
ASSIGNMENT_TO_LIST_LABEL(135, "cannot assign a value to list label <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 136.
*
* <p>return value <em>name</em> conflicts with rule with same name</p>
*/
RETVAL_CONFLICTS_WITH_RULE(136, "return value <arg> conflicts with rule with same name", ErrorSeverity.ERROR),
/**
* Compiler Error 137.
*
* <p>return value <em>name</em> conflicts with token with same name</p>
*/
RETVAL_CONFLICTS_WITH_TOKEN(137, "return value <arg> conflicts with token with same name", ErrorSeverity.ERROR),
/**
* Compiler Error 138.
*
* <p>parameter <em>parameter</em> conflicts with rule with same name</p>
*/
ARG_CONFLICTS_WITH_RULE(138, "parameter <arg> conflicts with rule with same name", ErrorSeverity.ERROR),
/**
* Compiler Error 139.
*
* <p>parameter <em>parameter</em> conflicts with token with same name</p>
*/
ARG_CONFLICTS_WITH_TOKEN(139, "parameter <arg> conflicts with token with same name", ErrorSeverity.ERROR),
/**
* Compiler Error 140.
*
* <p>local <em>local</em> conflicts with rule with same name</p>
*/
LOCAL_CONFLICTS_WITH_RULE(140, "local <arg> conflicts with rule with same name", ErrorSeverity.ERROR),
/**
* Compiler Error 141.
*
* <p>local <em>local</em> conflicts with rule token same name</p>
*/
LOCAL_CONFLICTS_WITH_TOKEN(141, "local <arg> conflicts with rule token same name", ErrorSeverity.ERROR),
/**
* Compiler Error 142.
*
* <p>local <em>local</em> conflicts with parameter with same name</p>
*/
LOCAL_CONFLICTS_WITH_ARG(142, "local <arg> conflicts with parameter with same name", ErrorSeverity.ERROR),
/**
* Compiler Error 143.
*
* <p>local <em>local</em> conflicts with return value with same name</p>
*/
LOCAL_CONFLICTS_WITH_RETVAL(143, "local <arg> conflicts with return value with same name", ErrorSeverity.ERROR),
/**
* Compiler Error 144.
*
* <p>
* multi-character literals are not allowed in lexer sets:
* <em>literal</em></p>
*/
INVALID_LITERAL_IN_LEXER_SET(144, "multi-character literals are not allowed in lexer sets: <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 145.
*
* <p>
* lexer mode <em>mode</em> must contain at least one non-fragment
* rule</p>
*
* <p>
* Every lexer mode must contain at least one rule which is not declared
* with the {@code fragment} modifier.</p>
*/
MODE_WITHOUT_RULES(145, "lexer mode <arg> must contain at least one non-fragment rule", ErrorSeverity.ERROR),
/**
* Compiler Warning 146.
*
* <p>non-fragment lexer rule <em>rule</em> can match the empty string</p>
*
* <p>All non-fragment lexer rules must match at least one character.</p>
*
* <p>The following example shows this error.</p>
*
* <pre>
* Whitespace : [ \t]+; // ok
* Whitespace : [ \t]; // ok
*
* fragment WS : [ \t]*; // ok
*
* Whitespace : [ \t]*; // error 146
* </pre>
*/
EPSILON_TOKEN(146, "non-fragment lexer rule <arg> can match the empty string", ErrorSeverity.WARNING),
/**
* Compiler Error 147.
*
* <p>
* left recursive rule <em>rule</em> must contain an alternative which is
* not left recursive</p>
*
* <p>Left-recursive rules must contain at least one alternative which is not
* left recursive.</p>
*
* <p>The following rule produces this error.</p>
*
* <pre>
* // error 147:
* a : a ID
* | a INT
* ;
* </pre>
*/
NO_NON_LR_ALTS(147, "left recursive rule <arg> must contain an alternative which is not left recursive", ErrorSeverity.ERROR),
/**
* Compiler Error 148.
*
* <p>
* left recursive rule <em>rule</em> contains a left recursive alternative
* which can be followed by the empty string</p>
*
* <p>In left-recursive rules, all left-recursive alternatives must match at
* least one symbol following the recursive rule invocation.</p>
*
* <p>The following rule produces this error.</p>
*
* <pre>
* 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)
* ;
* </pre>
*/
EPSILON_LR_FOLLOW(148, "left recursive rule <arg> contains a left recursive alternative which can be followed by the empty string", ErrorSeverity.ERROR),
/**
* Compiler Error 149.
*
* <p>
* lexer command <em>command</em> does not exist or is not supported by
* the current target</p>
*
* <p>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.</p>
*
* <p>The following rule produces this error.</p>
*
* <pre>
* X : 'foo' -> type(Foo); // ok
* Y : 'foo' -> token(Foo); // error 149 (token is not a supported lexer command)
* </pre>
*
* @since 4.1
*/
INVALID_LEXER_COMMAND(149, "lexer command <arg> does not exist or is not supported by the current target", ErrorSeverity.ERROR),
/**
* Compiler Error 150.
*
* <p>missing argument for lexer command <em>command</em></p>
*
* <p>Some lexer commands require an argument.</p>
*
* <p>The following rule produces this error.</p>
*
* <pre>
* X : 'foo' -> type(Foo); // ok
* Y : 'foo' -> type; // error 150 (the type command requires an argument)
* </pre>
*
* @since 4.1
*/
MISSING_LEXER_COMMAND_ARGUMENT(150, "missing argument for lexer command <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 151.
*
* <p>lexer command <em>command</em> does not take any arguments</p>
*
* <p>A lexer command which does not take parameters was invoked with an
* argument.</p>
*
* <p>The following rule produces this error.</p>
*
* <pre>
* X : 'foo' -> popMode; // ok
* Y : 'foo' -> popMode(A); // error 151 (the popMode command does not take an argument)
* </pre>
*
* @since 4.1
*/
UNWANTED_LEXER_COMMAND_ARGUMENT(151, "lexer command <arg> does not take any arguments", ErrorSeverity.ERROR),
/**
* Compiler Error 152.
*
* <p>unterminated string literal</p>
*
* <p>The grammar contains an unterminated string literal.</p>
*
* <p>The following rule produces this error.</p>
*
* <pre>
* x : 'x'; // ok
* y : 'y'; // error 152
* </pre>
*
* @since 4.1
*/
UNTERMINATED_STRING_LITERAL(152, "unterminated string literal", ErrorSeverity.ERROR),
/**
* Compiler Error 153.
*
* <p>
* rule <em>rule</em> contains a closure with at least one alternative
* that can match an empty string</p>
*
* <p>A rule contains a closure ({@code (...)*}) or positive closure
* ({@code (...)+}) around an empty alternative.</p>
*
* <p>The following rule produces this error.</p>
*
* <pre>
* x : ;
* y : x+; // error 153
* z1 : ('foo' | 'bar'? 'bar2'?)*; // error 153
* z2 : ('foo' | 'bar' 'bar2'? | 'bar2')*; // ok
* </pre>
*
* @since 4.1
*/
EPSILON_CLOSURE(153, "rule <arg> contains a closure with at least one alternative that can match an empty string", ErrorSeverity.ERROR),
/**
* Compiler Warning 154.
*
* <p>
* rule <em>rule</em> contains an optional block with at least one
* alternative that can match an empty string</p>
*
* <p>A rule contains an optional block ({@code (...)?}) around an empty
* alternative.</p>
*
* <p>The following rule produces this warning.</p>
*
* <pre>
* x : ;
* y : x?; // warning 154
* z1 : ('foo' | 'bar'? 'bar2'?)?; // warning 154
* z2 : ('foo' | 'bar' 'bar2'? | 'bar2')?; // ok
* </pre>
*
* @since 4.1
*/
EPSILON_OPTIONAL(154, "rule <arg> contains an optional block with at least one alternative that can match an empty string", ErrorSeverity.WARNING),
/**
* Compiler Warning 155.
*
* <p>
* rule <em>rule</em> contains a lexer command with an unrecognized
* constant value; lexer interpreters may produce incorrect output</p>
*
* <p>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.</p>
*
* <p>The following rule produces this warning.</p>
*
* <pre>
* @members {
* public static final int CUSTOM = HIDDEN + 1;
* }
*
* X : 'foo' -> channel(HIDDEN); // ok
* Y : 'bar' -> channel(CUSTOM); // warning 155
* </pre>
*
* @since 4.2
*/
UNKNOWN_LEXER_CONSTANT(155, "rule <arg> contains a lexer command with an unrecognized constant value; lexer interpreters may produce incorrect output", ErrorSeverity.WARNING),
/**
* Compiler Error 156.
*
* <p>invalid escape sequence</p>
*
* <p>The grammar contains a string literal with an invalid escape sequence.</p>
*
* <p>The following rule produces this error.</p>
*
* <pre>
* x : 'x'; // ok
* y : '\u005Cu'; // error 156
* </pre>
*
* @since 4.2.1
*/
INVALID_ESCAPE_SEQUENCE(156, "invalid escape sequence <arg>", ErrorSeverity.ERROR),
/**
* Compiler Warning 157.
*
* <p>rule <em>rule</em> contains an assoc element option in an
* unrecognized location</p>
*
* <p>
* In ANTLR 4.2, the position of the {@code assoc} element option was moved
* from the operator terminal(s) to the alternative itself. This warning is
* reported when an {@code 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.
* </p>
*
* <p>The following rule produces this warning.</p>
*
* <pre>
* x : 'x'
* | x '+'<assoc=right> x // warning 157
* |<assoc=right> x * x // ok
* ;
* </pre>
*
* @since 4.2.1
*/
UNRECOGNIZED_ASSOC_OPTION(157, "rule <arg> contains an assoc terminal option in an unrecognized location", ErrorSeverity.WARNING),
/**
* Compiler Warning 158.
*
* <p>fragment rule <em>rule</em> contains an action or command which can
* never be executed</p>
*
* <p>A lexer rule which is marked with the {@code 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.</p>
*
* <p>The following rule produces this warning.</p>
*
* <pre>
* X1 : 'x' -> more // ok
* ;
* Y1 : 'x' {more();} // ok
* ;
* fragment
* X2 : 'x' -> more // warning 158
* ;
* fragment
* Y2 : 'x' {more();} // warning 158
* ;
* </pre>
*
* @since 4.2.1
*/
FRAGMENT_ACTION_IGNORED(158, "fragment rule <arg> contains an action or command which can never be executed", ErrorSeverity.WARNING),
/**
* Compiler Error 159.
*
* <p>cannot declare a rule with reserved name <em>rule</em></p>
*
* <p>A rule was declared with a reserved name.</p>
*
* <p>The following rule produces this error.</p>
*
* <pre>
* EOF : ' ' // error 159 (EOF is a reserved name)
* ;
* </pre>
*
* @since 4.2.1
*/
RESERVED_RULE_NAME(159, "cannot declare a rule with reserved name <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 160.
*
* <p>reference to parser rule <em>rule</em> in lexer rule <em>name</em></p>
*
* @see #UNDEFINED_RULE_REF
*/
PARSER_RULE_REF_IN_LEXER_RULE(160, "reference to parser rule <arg> in lexer rule <arg2>", ErrorSeverity.ERROR),
/**
* Compiler Error 161.
*
* <p>channel <em>name</em> conflicts with token with same name</p>
*/
CHANNEL_CONFLICTS_WITH_TOKEN(161, "channel <arg> conflicts with token with same name", ErrorSeverity.ERROR),
/**
* Compiler Error 162.
*
* <p>channel <em>name</em> conflicts with mode with same name</p>
*/
CHANNEL_CONFLICTS_WITH_MODE(162, "channel <arg> conflicts with mode with same name", ErrorSeverity.ERROR),
/**
* Compiler Error 163.
*
* <p>custom channels are not supported in parser grammars</p>
*/
CHANNELS_BLOCK_IN_PARSER_GRAMMAR(163, "custom channels are not supported in parser grammars", ErrorSeverity.ERROR),
/**
* Compiler Error 164.
*
* <p>custom channels are not supported in combined grammars</p>
*/
CHANNELS_BLOCK_IN_COMBINED_GRAMMAR(164, "custom channels are not supported in combined grammars", ErrorSeverity.ERROR),
NONCONFORMING_LR_RULE(169, "rule <arg> is left recursive but doesn't conform to a pattern ANTLR can handle", ErrorSeverity.ERROR),
/**
* Compiler Error 170.
*
* <pre>
* mode M1;
* A1: 'a'; // ok
* mode M2;
* A2: 'a'; // ok
* M1: 'b'; // error 170
* </pre>
*
* <p>mode <em>name</em> conflicts with token with same name</p>
*/
MODE_CONFLICTS_WITH_TOKEN(170, "mode <arg> conflicts with token with same name", ErrorSeverity.ERROR),
/**
* Compiler Error 171.
*
* <p>can not use or declare token with reserved name</p>
*
* <p>Reserved names: HIDDEN, DEFAULT_TOKEN_CHANNEL, SKIP, MORE, MAX_CHAR_VALUE, MIN_CHAR_VALUE.
*
* <p>Can be used but cannot be declared: EOF</p>
*/
TOKEN_CONFLICTS_WITH_COMMON_CONSTANTS(171, "cannot use or declare token with reserved name <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 172.
*
* <p>can not use or declare channel with reserved name</p>
*
* <p>Reserved names: DEFAULT_MODE, SKIP, MORE, EOF, MAX_CHAR_VALUE, MIN_CHAR_VALUE.
*
* <p>Can be used but cannot be declared: HIDDEN, DEFAULT_TOKEN_CHANNEL</p>
*/
CHANNEL_CONFLICTS_WITH_COMMON_CONSTANTS(172, "cannot use or declare channel with reserved name <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 173.
*
* <p>can not use or declare mode with reserved name</p>
*
* <p>Reserved names: HIDDEN, DEFAULT_TOKEN_CHANNEL, SKIP, MORE, MAX_CHAR_VALUE, MIN_CHAR_VALUE.
*
* <p>Can be used and cannot declared: DEFAULT_MODE</p>
*/
MODE_CONFLICTS_WITH_COMMON_CONSTANTS(173, "cannot use or declare mode with reserved name <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 174.
*
* <p>empty strings and sets not allowed</p>
*
* <pre>
* A: '''test''';
* B: '';
* C: 'test' '';
* D: [];
* E: [f-a];
* </pre>
*/
EMPTY_STRINGS_AND_SETS_NOT_ALLOWED(174, "string literals and sets cannot be empty: <arg>", ErrorSeverity.ERROR),
/**
* Compiler Error 175.
*
* <p><em>name</em> is not a recognized token name</p>
*
* <pre>TOKEN: 'a' -> type(CHANNEL1); // error 175</pre>
*/
CONSTANT_VALUE_IS_NOT_A_RECOGNIZED_TOKEN_NAME(175, "<arg> is not a recognized token name", ErrorSeverity.ERROR),
/**
* Compiler Error 176.
*
* <p><em>name</em>is not a recognized mode name</p>
*
* <pre>TOKEN: 'a' -> mode(MODE1); // error 176</pre>
*/
CONSTANT_VALUE_IS_NOT_A_RECOGNIZED_MODE_NAME(176, "<arg> is not a recognized mode name", ErrorSeverity.ERROR),
/**
* Compiler Error 177.
*
* <p><em>name</em> is not a recognized channel name</p>
*
* <pre>TOKEN: 'a' -> channel(TOKEN1); // error 177</pre>
*/
CONSTANT_VALUE_IS_NOT_A_RECOGNIZED_CHANNEL_NAME(177, "<arg> is not a recognized channel name", ErrorSeverity.ERROR),
/*
* Compiler Warning 178.
*
* <p>lexer rule has a duplicated commands</p>
*
* <p>TOKEN: 'asdf' -> mode(MODE1), mode(MODE2);</p>
* */
DUPLICATED_COMMAND(178, "duplicated command <arg>", ErrorSeverity.WARNING),
/*
* Compiler Waring 179.
*
* <p>incompatible commands <em>command1</em> and <em>command2</em></p>
*
* <p>T00: 'a00' -> skip, more;</p>
*/
INCOMPATIBLE_COMMANDS(179, "incompatible commands <arg> and <arg2>", ErrorSeverity.WARNING),
/**
* Compiler Warning 180.
*
* <p>chars "a-f" used multiple times in set [a-fc-m]</p>
*
* <pre>
* A: [aa-z]; // warning
* B: [a-fc-m]; // warning
* </pre>
*
* TODO: Does not work with fragment rules.
*/
CHARACTERS_COLLISION_IN_SET(180, "chars <arg> used multiple times in set <arg2>", ErrorSeverity.WARNING),
/**
* Compiler Warning 181
*
* <p>The token range operator makes no sense in the parser as token types
* are not ordered (except in implementation).
* </p>
*
* <pre>
* grammar T;
* a : 'A'..'Z' ;
* </pre>
*
*/
TOKEN_RANGE_IN_PARSER(181, "token ranges not allowed in parser: <arg>..<arg2>", ErrorSeverity.ERROR),
/**
* Compiler Error 182.
*
* <p>Unicode properties cannot be part of a lexer charset range</p>
*
* <pre>
* A: [\\p{Letter}-\\p{Number}];
* </pre>
*/
UNICODE_PROPERTY_NOT_ALLOWED_IN_RANGE(
182,
"unicode property escapes not allowed in lexer charset range: <arg>",
ErrorSeverity.ERROR),
/**
* Compiler Warning 184.
*
* <p>The token value overlapped by another token or self</p>
*
* <pre>
* TOKEN1: 'value';
* TOKEN2: 'value'; // warning
* </pre>
*/
TOKEN_UNREACHABLE(
184,
"One of the token <arg> values unreachable. <arg2> is always overlapped by token <arg3>",
ErrorSeverity.WARNING),
/**
* <p>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[\\\]^_`]
* </p>
*
* <pre>
* TOKEN: [A-z]; // warning
* </pre>
*/
RANGE_PROBABLY_CONTAINS_NOT_IMPLIED_CHARACTERS(
185,
"Range <arg>..<arg2> probably contains not implied characters <arg3>. Both bounds should be defined in lower or UPPER case",
ErrorSeverity.WARNING
),
/**
* <p>
* rule <em>rule</em> contains a closure with at least one alternative
* that can match EOF</p>
*
* <p>A rule contains a closure ({@code (...)*}) or positive closure
* ({@code (...)+}) around EOF.</p>
*
* <p>The following rule produces this error.</p>
*
* <pre>
* x : EOF*; // error
* y : EOF+; // error
* z : EOF; // ok
* </pre>
*/
EOF_CLOSURE(
186,
"rule <arg> contains a closure with at least one alternative that can match EOF",
ErrorSeverity.ERROR
),
/**
* <p>Redundant caseInsensitive lexer rule option</p>
*
* <pre>
* options { caseInsensitive=true; }
* TOKEN options { caseInsensitive=true; } : [a-z]+ -> caseInsensitive(true); // warning
* </pre>
*/
REDUNDANT_CASE_INSENSITIVE_LEXER_RULE_OPTION(
187,
"caseInsensitive lexer rule option is redundant because its value equals to global value (<arg>)",
ErrorSeverity.WARNING
),
/*
* Backward incompatibility errors
*/
/**
* Compiler Error 200.
*
* <p>tree grammars are not supported in ANTLR 4</p>
*
* <p>
* 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.</p>
*/
@Deprecated
V3_TREE_GRAMMAR(200, "tree grammars are not supported in ANTLR 4", ErrorSeverity.ERROR),
/**
* Compiler Warning 201.
*
* <p>
* labels in lexer rules are not supported in ANTLR 4; actions cannot
* reference elements of lexical rules but you can use
* {@link Lexer#getText()} to get the entire text matched for the rule</p>
*
* <p>
* 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.</p>
*/
@Deprecated
V3_LEXER_LABEL(201, "labels in lexer rules are not supported in ANTLR 4; " +
"actions cannot reference elements of lexical rules but you can use " +
"getText() to get the entire text matched for the rule", ErrorSeverity.WARNING),
/**
* Compiler Warning 202.
*
* <p>
* {@code tokens {A; B;}} syntax is now {@code tokens {A, B}} in ANTLR
* 4</p>
*
* <p>
* ANTLR 4 uses comma-separated token declarations in the {@code tokens{}}
* block. This warning appears when the tokens block is written using the
* ANTLR 3 syntax of semicolon-terminated token declarations.</p>
*
* <p>
* <strong>NOTE:</strong> ANTLR 4 does not allow a trailing comma to appear following the
* last token declared in the {@code tokens{}} block.</p>
*/
@Deprecated
V3_TOKENS_SYNTAX(202, "tokens {A; B;} syntax is now tokens {A, B} in ANTLR 4", ErrorSeverity.WARNING),
/**
* Compiler Error 203.
*
* <p>
* assignments in {@code tokens{}} are not supported in ANTLR 4; use lexical
* rule <em>TokenName</em> : <em>LiteralValue</em>; instead</p>
*
* <p>
* ANTLR 3 allowed literal tokens to be declared and assigned a value within
* the {@code 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 {@code tokens{}} block should be converted to
* standard lexer rules.</p>
*/
@Deprecated
V3_ASSIGN_IN_TOKENS(203, "assignments in tokens{} are not supported in ANTLR 4; use lexical rule <arg> : <arg2>; instead", ErrorSeverity.ERROR),
/**
* Compiler Warning 204.
*
* <p>
* {@code {...}?=>} explicitly gated semantic predicates are deprecated in
* ANTLR 4; use {@code {...}?} instead</p>
*
* <p>
* 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.</p>
*/
@Deprecated
V3_GATED_SEMPRED(204, "{...}?=> explicitly gated semantic predicates are deprecated in ANTLR 4; use {...}? instead", ErrorSeverity.WARNING),
/**
* Compiler Error 205.
*
* <p>{@code (...)=>} syntactic predicates are not supported in ANTLR 4</p>
*
* <p>
* 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.</p>
*/
@Deprecated
V3_SYNPRED(205, "(...)=> syntactic predicates are not supported in ANTLR 4", ErrorSeverity.ERROR),
// Dependency sorting errors
/* t1.g4 -> t2.g4 -> t3.g4 ->t1.g4 */
//CIRCULAR_DEPENDENCY(200, "your grammars contain a circular dependency and cannot be sorted into a valid build order", ErrorSeverity.ERROR),
;
/**
* The error or warning message, in StringTemplate 4 format using {@code <}
* and {@code >} as the delimiters. Arguments for the message may be
* referenced using the following names:
*
* <ul>
* <li>{@code arg}: The first template argument</li>
* <li>{@code arg2}: The second template argument</li>
* <li>{@code arg3}: The third template argument</li>
* <li>{@code verbose}: {@code true} if verbose messages were requested; otherwise, {@code false}</li>
* <li>{@code exception}: The exception which resulted in the error, if any.</li>
* <li>{@code stackTrace}: The stack trace for the exception, when available.</li>
* </ul>
*/
public final String msg;
/**
* The error or warning number.
*
* <p>The code should be unique, and following its
* use in a release should not be altered or reassigned.</p>
*/
public final int code;
/**
* The error severity.
*/
public final ErrorSeverity severity;
/**
* Constructs a new {@link ErrorType} with the specified code, message, and
* severity.
*
* @param code The unique error number.
* @param msg The error message template.
* @param severity The error severity.
*/
ErrorType(int code, String msg, ErrorSeverity severity) {
this.code = code;
this.msg = msg;
this.severity = severity;
}
}
⏎ org/antlr/v4/tool/ErrorType.java
Or download all of them as a single archive file:
File name: antlr-tool-4.10.1-sources.jar File size: 347718 bytes Release date: 2022-04-15 Download
2022-04-24, 27114👍, 0💬
Related Topics:
