diff options
Diffstat (limited to 'antlr-3.4/tool/src/main/resources/org/antlr/tool/templates/messages/languages/en.stg')
| -rw-r--r-- | antlr-3.4/tool/src/main/resources/org/antlr/tool/templates/messages/languages/en.stg | 297 |
1 files changed, 297 insertions, 0 deletions
diff --git a/antlr-3.4/tool/src/main/resources/org/antlr/tool/templates/messages/languages/en.stg b/antlr-3.4/tool/src/main/resources/org/antlr/tool/templates/messages/languages/en.stg new file mode 100644 index 0000000..ea27ddc --- /dev/null +++ b/antlr-3.4/tool/src/main/resources/org/antlr/tool/templates/messages/languages/en.stg @@ -0,0 +1,297 @@ +/* + [The "BSD license"] + Copyright (c) 2010 Terence Parr + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + 3. The name of the author may not be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +/* + New style messages. This file only contains the messages in English, but no + information about which file, line, or column it occurred in. + The location and message ids are taken out of the formats directory. + Kay Roepke +*/ +group en_US; + +// TOOL ERRORS +// file errors +CANNOT_WRITE_FILE(arg,exception,stackTrace) ::= << +cannot write file <arg>: <exception> +<stackTrace; separator="\n"> +>> +CANNOT_CLOSE_FILE(arg,exception,stackTrace) ::= "cannot close file <arg>: <exception>" +CANNOT_FIND_TOKENS_FILE(arg) ::= "cannot find tokens file <arg>" +ERROR_READING_TOKENS_FILE(arg,exception,stackTrace) ::= << +problem reading token vocabulary file <arg>: <exception> +<stackTrace; separator="\n"> +>> +DIR_NOT_FOUND(arg,exception,stackTrace) ::= "directory not found: <arg>" +OUTPUT_DIR_IS_FILE(arg,exception,stackTrace) ::= "output directory is a file: <arg>" +CANNOT_OPEN_FILE(arg,exception,stackTrace) ::= "cannot find or open file: <arg><if(exception)>; reason: <exception><endif>" +CIRCULAR_DEPENDENCY() ::= "your grammars contain a circular dependency and cannot be sorted into a valid build order." + +INTERNAL_ERROR(arg,arg2,exception,stackTrace) ::= << +internal error: <arg> <arg2><if(exception)>: <exception><endif> +<stackTrace; separator="\n"> +>> +INTERNAL_WARNING(arg) ::= "internal warning: <arg>" +ERROR_CREATING_ARTIFICIAL_RULE(arg,exception,stackTrace) ::= << +problems creating lexer rule listing all tokens: <exception> +<stackTrace; separator="\n"> +>> +TOKENS_FILE_SYNTAX_ERROR(arg,arg2) ::= + "problems parsing token vocabulary file <arg> on line <arg2>" +CANNOT_GEN_DOT_FILE(arg,exception,stackTrace) ::= + "cannot write DFA DOT file <arg>: <exception>" +BAD_ACTION_AST_STRUCTURE(exception,stackTrace) ::= + "bad internal tree structure for action '<arg>': <exception>" +BAD_AST_STRUCTURE(arg,exception,stackTrace) ::= << +bad internal tree structure '<arg>': <exception> +<stackTrace; separator="\n"> +>> +FILE_AND_GRAMMAR_NAME_DIFFER(arg,arg2) ::= + "file <arg2> contains grammar <arg>; names must be identical" +FILENAME_EXTENSION_ERROR(arg) ::= + "file <arg> must end in a file extension, normally .g" + +// code gen errors +MISSING_CODE_GEN_TEMPLATES(arg) ::= + "cannot find code generation templates <arg>.stg" +MISSING_CYCLIC_DFA_CODE_GEN_TEMPLATES() ::= + "cannot find code generation cyclic DFA templates for language <arg>" +CODE_GEN_TEMPLATES_INCOMPLETE(arg) ::= + "at least one code generation template missing for language <arg>" +CANNOT_CREATE_TARGET_GENERATOR(arg,exception,stackTrace) ::= + "cannot create target <arg> code generator: <exception>" +CANNOT_COMPUTE_SAMPLE_INPUT_SEQ() ::= + "cannot generate a sample input sequence from lookahead DFA" + +// grammar interpretation errors +/* +NO_VIABLE_DFA_ALT(arg,arg2) ::= + "no viable transition from state <arg> on <arg2> while interpreting DFA" +*/ + +// GRAMMAR ERRORS +SYNTAX_ERROR(arg) ::= "syntax error: <arg>" +RULE_REDEFINITION(arg) ::= + "rule <arg> redefinition" +LEXER_RULES_NOT_ALLOWED(arg) ::= + "lexer rule <arg> not allowed in parser" +PARSER_RULES_NOT_ALLOWED(arg) ::= + "parser rule <arg> not allowed in lexer" +CANNOT_FIND_ATTRIBUTE_NAME_IN_DECL(arg) ::= + "cannot find an attribute name in attribute declaration" +NO_TOKEN_DEFINITION(arg) ::= + "no lexer rule corresponding to token: <arg>" +UNDEFINED_RULE_REF(arg) ::= + "reference to undefined rule: <arg>" +LITERAL_NOT_ASSOCIATED_WITH_LEXER_RULE(arg) ::= + "literal has no associated lexer rule: <arg>" +CANNOT_ALIAS_TOKENS_IN_LEXER(arg) ::= + "literals are illegal in lexer tokens{} section: <arg>" +ATTRIBUTE_REF_NOT_IN_RULE(arg,arg2) ::= + "reference to attribute outside of a rule: <arg><if(arg2)>.<arg2><endif>" +UNKNOWN_ATTRIBUTE_IN_SCOPE(arg,arg2) ::= + "unknown attribute for <arg>: <arg2>" +UNKNOWN_RULE_ATTRIBUTE(arg,arg2) ::= + "unknown attribute for rule <arg>: <arg2>" +UNKNOWN_SIMPLE_ATTRIBUTE(arg,args2) ::= + "attribute is not a token, parameter, or return value: <arg>" +ISOLATED_RULE_SCOPE(arg) ::= + "missing attribute access on rule scope: <arg>" +INVALID_RULE_PARAMETER_REF(arg,arg2) ::= + "cannot access rule <arg>'s parameter: <arg2>" +INVALID_RULE_SCOPE_ATTRIBUTE_REF(arg,arg2) ::= + "cannot access rule <arg>'s dynamically-scoped attribute: <arg2>" +SYMBOL_CONFLICTS_WITH_GLOBAL_SCOPE(arg) ::= + "symbol <arg> conflicts with global dynamic scope with same name" +WRITE_TO_READONLY_ATTR(arg,arg2,arg3) ::= + "cannot write to read only attribute: $<arg><if(arg2)>.<arg2><endif>" +LABEL_CONFLICTS_WITH_RULE(arg) ::= + "label <arg> conflicts with rule with same name" +LABEL_CONFLICTS_WITH_TOKEN(arg) ::= + "label <arg> conflicts with token with same name" +LABEL_CONFLICTS_WITH_RULE_SCOPE_ATTRIBUTE(arg,arg2) ::= + "label <arg> conflicts with rule <arg2>'s dynamically-scoped attribute with same name" +LABEL_CONFLICTS_WITH_RULE_ARG_RETVAL(arg,arg2) ::= + "label <arg> conflicts with rule <arg2>'s return value or parameter with same name" +ATTRIBUTE_CONFLICTS_WITH_RULE(arg,arg2) ::= + "rule <arg2>'s dynamically-scoped attribute <arg> conflicts with the rule name" +ATTRIBUTE_CONFLICTS_WITH_RULE_ARG_RETVAL(arg,arg2) ::= + "rule <arg2>'s dynamically-scoped attribute <arg> conflicts with<arg2>'s return value or parameter with same name" +LABEL_TYPE_CONFLICT(arg,arg2) ::= + "label <arg> type mismatch with previous definition: <arg2>" +ARG_RETVAL_CONFLICT(arg,arg2) ::= + "rule <arg2>'s argument <arg> conflicts a return value with same name" +NONUNIQUE_REF(arg) ::= + "<arg> is a non-unique reference" +FORWARD_ELEMENT_REF(arg) ::= + "illegal forward reference: <arg>" +MISSING_RULE_ARGS(arg) ::= + "missing parameter(s) on rule reference: <arg>" +RULE_HAS_NO_ARGS(arg) ::= + "rule <arg> has no defined parameters" +ARGS_ON_TOKEN_REF(arg) ::= + "token reference <arg> may not have parameters" +ILLEGAL_OPTION(arg) ::= + "illegal option <arg>" +LIST_LABEL_INVALID_UNLESS_RETVAL_STRUCT(arg) ::= + "rule '+=' list labels are not allowed w/o output option: <arg>" +UNDEFINED_TOKEN_REF_IN_REWRITE(arg) ::= + "reference to undefined token in rewrite rule: <arg>" +REWRITE_ELEMENT_NOT_PRESENT_ON_LHS(arg) ::= + "reference to rewrite element <arg> without reference on left of ->" +UNDEFINED_LABEL_REF_IN_REWRITE(arg) ::= + "reference to undefined label in rewrite rule: $<arg>" +NO_GRAMMAR_START_RULE (arg) ::= + "grammar <arg>: no start rule (no rule can obviously be followed by EOF)" +EMPTY_COMPLEMENT(arg) ::= << +<if(arg)> +set complement ~<arg> is empty +<else> +set complement is empty +<endif> +>> +UNKNOWN_DYNAMIC_SCOPE(arg) ::= + "unknown dynamic scope: <arg>" +UNKNOWN_DYNAMIC_SCOPE_ATTRIBUTE(arg,arg2) ::= + "unknown dynamically-scoped attribute for scope <arg>: <arg2>" +RULE_REF_AMBIG_WITH_RULE_IN_ALT(arg) ::= + "reference $<arg> is ambiguous; rule <arg> is enclosing rule and referenced in the production (assuming enclosing rule)" +ISOLATED_RULE_ATTRIBUTE(arg) ::= + "reference to locally-defined rule scope attribute without rule name: <arg>" +INVALID_ACTION_SCOPE(arg,arg2) ::= + "unknown or invalid action scope for <arg2> grammar: <arg>" +ACTION_REDEFINITION(arg) ::= + "redefinition of <arg> action" +DOUBLE_QUOTES_ILLEGAL(arg) ::= + "string literals must use single quotes (such as \'begin\'): <arg>" +INVALID_TEMPLATE_ACTION(arg) ::= + "invalid StringTemplate % shorthand syntax: '<arg>'" +MISSING_ATTRIBUTE_NAME() ::= + "missing attribute name on $ reference" +ARG_INIT_VALUES_ILLEGAL(arg) ::= + "rule parameters may not have init values: <arg>" +REWRITE_OR_OP_WITH_NO_OUTPUT_OPTION(arg) ::= + "<if(arg)>rule <arg> uses <endif>rewrite syntax or operator with no output option; setting output=AST" +AST_OP_WITH_NON_AST_OUTPUT_OPTION(arg) ::= + "AST operator with non-AST output option: <arg>" +NO_RULES(arg) ::= "grammar file <arg> has no rules" +MISSING_AST_TYPE_IN_TREE_GRAMMAR(arg) ::= + "tree grammar <arg> has no ASTLabelType option" +REWRITE_FOR_MULTI_ELEMENT_ALT(arg) ::= + "with rewrite=true, alt <arg> not simple node or obvious tree element; text attribute for rule not guaranteed to be correct" +RULE_INVALID_SET(arg) ::= + "Cannot complement rule <arg>; not a simple set or element" +HETERO_ILLEGAL_IN_REWRITE_ALT(arg) ::= + "alts with rewrites can't use heterogeneous types left of ->" +NO_SUCH_GRAMMAR_SCOPE(arg,arg2) ::= + "reference to undefined grammar in rule reference: <arg>.<arg2>" +NO_SUCH_RULE_IN_SCOPE(arg,arg2) ::= + "rule <arg2> is not defined in grammar <arg>" +TOKEN_ALIAS_CONFLICT(arg,arg2) ::= + "cannot alias <arg>; string already assigned to <arg2>" +TOKEN_ALIAS_REASSIGNMENT(arg,arg2) ::= + "cannot alias <arg>; token name already assigned to <arg2>" +TOKEN_VOCAB_IN_DELEGATE(arg,arg2) ::= + "tokenVocab option ignored in imported grammar <arg>" +INVALID_IMPORT(arg,arg2) ::= + "<arg.grammarTypeString> grammar <arg.name> cannot import <arg2.grammarTypeString> grammar <arg2.name>" +IMPORTED_TOKENS_RULE_EMPTY(arg,arg2) ::= + "no lexer rules contributed to <arg> from imported grammar <arg2>" +IMPORT_NAME_CLASH(arg,arg2) ::= + "combined grammar <arg.name> and imported <arg2.grammarTypeString> grammar <arg2.name> both generate <arg2.recognizerName>; import ignored" +AST_OP_IN_ALT_WITH_REWRITE(arg,arg2) ::= + "rule <arg> alt <arg2> uses rewrite syntax and also an AST operator" +WILDCARD_AS_ROOT(arg) ::= "Wildcard invalid as root; wildcard can itself be a tree" +CONFLICTING_OPTION_IN_TREE_FILTER(arg,arg2) ::= "option <arg>=<arg2> conflicts with tree grammar filter mode" +ILLEGAL_OPTION_VALUE(arg, arg2) ::= "value '<arg2>' invalid for option <arg>" +ALL_OPS_NEED_SAME_ASSOC(arg) ::= "all operators of alt <alt> of left-recursive rule must have same associativity" + +// GRAMMAR WARNINGS + +GRAMMAR_NONDETERMINISM(input,conflictingAlts,paths,disabled,hasPredicateBlockedByAction) ::= +<< +<if(paths)> +Decision can match input such as "<input>" using multiple alternatives: +<paths:{ it | alt <it.alt> via NFA path <it.states; separator=","><\n>}> +<else> +Decision can match input such as "<input>" using multiple alternatives: <conflictingAlts; separator=", "> +<endif> +<if(disabled)><\n>As a result, alternative(s) <disabled; separator=","> were disabled for that input<endif><if(hasPredicateBlockedByAction)><\n>Semantic predicates were present but were hidden by actions.<endif> +>> + +DANGLING_STATE(danglingAlts,input) ::= << +the decision cannot distinguish between alternative(s) <danglingAlts; separator=","> for input such as "<input>" +>> + +UNREACHABLE_ALTS(alts) ::= << +The following alternatives can never be matched: <alts; separator=","><\n> +>> + +INSUFFICIENT_PREDICATES(upon,altToLocations,hasPredicateBlockedByAction) ::= << +Input such as "<upon>" is insufficiently covered with predicates at locations: <altToLocations.keys:{alt|alt <alt>: <altToLocations.(alt):{loc| line <loc.line>:<loc.column> at <loc.text>}; separator=", ">}; separator=", "><if(hasPredicateBlockedByAction)><\n>Semantic predicates were present but were hidden by actions.<endif> +>> + +DUPLICATE_SET_ENTRY(arg) ::= + "duplicate token type <arg> when collapsing subrule into set" + +ANALYSIS_ABORTED(enclosingRule) ::= << +ANTLR could not analyze this decision in rule <enclosingRule>; often this is because of recursive rule references visible from the left edge of alternatives. ANTLR will re-analyze the decision with a fixed lookahead of k=1. Consider using "options {k=1;}" for that decision and possibly adding a syntactic predicate. +>> + +RECURSION_OVERLOW(alt,input,targetRules,callSiteStates) ::= << +Alternative <alt>: after matching input such as <input> decision cannot predict what comes next due to recursion overflow <targetRules,callSiteStates:{t,c|to <t> from <c:{s|<s.enclosingRule.name>};separator=", ">}; separator=" and "> +>> + +LEFT_RECURSION(targetRules,alt,callSiteStates) ::= << +Alternative <alt> discovers infinite left-recursion <targetRules,callSiteStates:{t,c|to <t> from <c:{s|<s.enclosingRule>};separator=", ">}; separator=" and "> +>> + +UNREACHABLE_TOKENS(tokens) ::= << +The following token definitions can never be matched because prior tokens match the same input: <tokens; separator=","> +>> + +TOKEN_NONDETERMINISM(input,conflictingTokens,paths,disabled,hasPredicateBlockedByAction) ::= +<< +<if(paths)> +Decision can match input such as "<input>" using multiple alternatives: +<paths:{ it | alt <it.alt> via NFA path <it.states; separator=","><\n>}> +<else> +Multiple token rules can match input such as "<input>": <conflictingTokens; separator=", "><\n> +<endif> +<if(disabled)><\n>As a result, token(s) <disabled; separator=","> were disabled for that input<endif><if(hasPredicateBlockedByAction)><\n>Semantic predicates were present but were hidden by actions.<endif> +>> + +LEFT_RECURSION_CYCLES(listOfCycles) ::= << +The following sets of rules are mutually left-recursive <listOfCycles:{c| [<c:{r|<r.name>}; separator=", ">]}; separator=" and "> +>> + +NONREGULAR_DECISION(ruleName,alts) ::= << +[fatal] rule <ruleName> has non-LL(*) decision due to recursive rule invocations reachable from alts <alts; separator=",">. Resolve by left-factoring or using syntactic predicates or using backtrack=true option. +>> + +/* l10n for message levels */ +warning() ::= "warning" +error() ::= "error" |