Не могу создать переменную только с одной буквой

Question

Хотелось бы, чтобы переменные могли быть объявлены только с одной буквой в имени. Когда я пишу Integer аа; все работают, но когда я набираю Integer a; тогда grun говорит: несоответствующий ввод 'a' ожидающий идентификатор. Я видел обратную проблему, но это не помогло. Я думаю, что мой код правильный, но я не вижу, где я не прав. Это мой лексер:

lexer grammar Symbols;

WS: [ \t\n\r] -> skip ;

INCR: '++' ;
DECR: '--' ;
ASSIGNMENT: '=' ;
ADD: '+' ;
ADD_ASSIGNMENT: '+=' ;
SUB: '-' ;
SUB_ASSIGNMENT: '-=' ;
MUL: '*' ;
MUL_ASSIGNMENT: '*=' ;
DIV: '/' ;
DIV_ASSIGNMENT: '/=' ;
MOD: '%' ;
MOD_ASSIGNMENT: '%=' ;
EQEQ: '==' ;
EXCL_EQ: '!=' ;
SEMI: ';' -> skip;
COLON: ':' ;
COLONCOLON: '::' ;
ARROW: '->' ;
COMMA: ',' ;
DOT: '.' ;
AND: '&&' ;
OR: '||' ;
NOT: '!' ;
RANGLE: '>' ;
GE: '>=' ;
LANGLE: '<' ;
LE: '<=' ;
LPAREN: '(' ;
RPAREN: ')' ;
LSQUARE: '[' ;
RSQUARE: ']' ;
LCURL: '{' ;
RCURL: '}' ;
UNDERSCORE: '_' ;
QUEST: '?' ;

//Keywords
IF: 'if' ;
ELIF: 'elif' ;
ELSE: 'else' ;
DO: 'do' ;
WHILE: 'while' ;
FOR: 'for' ;
CLASS: 'class' ;
SWITCH: 'switch' ;
CASE: 'case' ;
DEFAULT: 'default' ;
FINALLY: 'finally' ;
TRY: 'try' ;
CATCH: 'catch' ;
THROW: 'throw' ;
RETURN: 'return' ;
IS: 'is' ;
OF: 'of' ;
NEW: 'new' ;
OVERRIDE: 'override' ;
ENUM: 'enum' ;
EXTENDS: 'extends' ;
NULL: 'null' ;
THIS: 'this' ;
SUPER: 'super' ;
TRUE: 'true' ;
FALSE: 'false' ;
VOID: 'void' ;
CONSTRUCTOR: 'constructor' ;
OPERATOR: 'operator' ;
IMPORT: 'import' ;
LAMBDA: 'lambda' ;

//Modifiers
ABSTRACT: 'abstract' ;
FINAL: 'final' ;
STATIC: 'static' ;
PUBLIC: 'public' ;
PRIVATE: 'private' ;
PROTECTED: 'protected' ;

Operators
    : ADD
    | SUB
    | MUL
    | DIV
    | MOD
    | ADD_ASSIGNMENT
    | SUB_ASSIGNMENT
    | MUL_ASSIGNMENT
    | DIV_ASSIGNMENT
    | MOD_ASSIGNMENT
    | ASSIGNMENT
    | INCR
    | DECR
    ;

LineComment: '//' ~[\u000A\u000D]* -> channel(HIDDEN) ;
DelimetedComment: '/*' .*? '*/' -> channel(HIDDEN) ;

String: '"' .*? '"' ;
Character: '\'' (EscapeSeq | .) '\'' ;
IntegerLiteral: '0' | (ADD?| SUB) DecDigitNoZero DecDigit+ ;
FloatLiteral: ((ADD? | SUB) (DecDigitNoZero DecDigit*)? DOT DecDigit+ | IntegerLiteral) [F] ;
DoubleLiteral: ((ADD? | SUB) (DecDigitNoZero DecDigit*)? DOT DecDigit+ | IntegerLiteral) [D]  ;
LongLiteral: IntegerLiteral [L] ;
HexLiteral: '0' [xX] HexDigit (HexDigit | UNDERSCORE)* ;
BinLiteral: '0' [bB] BinDigit (BinDigit | UNDERSCORE)* ;
OctLiteral: '0' [cC] OctDigit (OctDigit | UNDERSCORE)* ;
Booleans: TRUE | FALSE ;
Number: IntegerLiteral | FloatLiteral | DoubleLiteral | BinLiteral | HexLiteral | OctLiteral | LongLiteral ;
EscapeSeq: UniCharacterLiteral | EscapedIdentifier;
UniCharacterLiteral: '\\' 'u' HexDigit HexDigit HexDigit HexDigit ;
EscapedIdentifier: '\\' ('t' | 'b' | 'r' | 'n' | '\'' | '"' | '\\' | '$') ;
HexDigit: [0-9a-fA-F] ;
BinDigit: [01] ;
OctDigit: [0-7];
DecDigit: [0-9];
DecDigitNoZero: [1-9];

ID: [a-z] ([a-zA-Z_] | [0-9])*;
TYPE: [A-Z] ([a-zA-Z] | UNDERSCORE | [0-9])* ;

DATATYPE: Number | String | Character | Booleans ;

А это мой парсер:

grammar File;

import Symbols;

file: importHeader* topLevelDeclaration* ;

importHeader
    : IMPORT TYPE (DOT MUL)?
    ;

topLevelDeclaration
    : classDeclaration
    | functionDeclaration
    | enumDeclaration
    ;

block
    : LCURL statement* RCURL
    ;

statement
    : ifStatement
    | forStatement
    | whileStatement
    | dowhileStatement
    | switchStatement
    | thisStatement
    | throwStatement
    | tryStatement
    | returnStatement
    | anObjectCalls
    | functionCall
    | indexOfArrayAssignmnet
    | lambdaFunction
    | varDeclaration
    | varAssignment
    | classDeclaration
    | functionDeclaration
    | enumDeclaration
    | arrayAssignment
    ;

expr
    : ID
    | DATATYPE
    | NULL
    | INCR expr
    | DECR expr
    | expr INCR
    | expr DECR
    | expr AND expr
    | expr OR expr
    | NOT expr
    | expr MUL expr
    | expr DIV expr
    | expr MOD expr
    | expr ADD expr
    | expr SUB expr
    | expr RANGLE expr
    | expr GE expr
    | expr LANGLE expr
    | expr LE expr
    | expr EQEQ expr
    | expr EXCL_EQ expr
    | functionCall
    | ifExpr
    | thisStatement
    | anObjectCalls
    | objectInstantation
    | indexOfArray
    | lambdaExpression
    ;

lambdaExpression
    : LPAREN formalParameters RPAREN (COLON TYPE | (COLON VOID)?) ARROW (block | statement)
    ;

lambdaFunction
    : LAMBDA ID ASSIGNMENT lambdaExpression
    ;

indexOfArray
    : ID LSQUARE expr RSQUARE
    ;

indexOfArrayAssignmnet
    : indexOfArray (ASSIGNMENT
    | ADD_ASSIGNMENT
    | SUB_ASSIGNMENT
    | MUL_ASSIGNMENT
    | DIV_ASSIGNMENT
    | MOD_ASSIGNMENT) expr
    ;

ifExpr
    : IF LPAREN expr RPAREN expr ELSE expr
    ;

varDeclaration
    : TYPE ID
    ;

varAssignment
    : ID (ASSIGNMENT
    | ADD_ASSIGNMENT
    | SUB_ASSIGNMENT
    | MUL_ASSIGNMENT
    | DIV_ASSIGNMENT
    | MOD_ASSIGNMENT) expr
    ;

arrayAssignment
    : ID ASSIGNMENT LSQUARE expr RSQUARE OF TYPE
    ;

visibilityModifier
    : PUBLIC
    | PRIVATE
    | PROTECTED
    ;

attributeMethodModifier
    : FINAL
    | STATIC
    ;

classModifier
    : ABSTRACT
    | FINAL
    | PUBLIC
    | PRIVATE
    ;

functionDeclaration
    : parametricTypes? ID LPAREN (formalParameters | VOID?) RPAREN COLON (TYPE | VOID) throwsStatement? block
    ;

throwsStatement
    : QUEST TYPE (COMMA TYPE)*
    ;

parametricTypes
    : LANGLE parametricType (COMMA parametricType)*  RANGLE
    ;

parametricType
    : TYPE | QUEST (EXTENDS TYPE (COMMA TYPE)* | SUPER TYPE (COMMA TYPE))
    ;

formalParameters
    : formalParameter (COMMA formalParameter)*
    ;

formalParameter
    : TYPE ID (ASSIGNMENT expr)?
    | TYPE ID LSQUARE RSQUARE
    ;

functionCall
    : ID LPAREN (currentParameters | VOID?) RPAREN
    ;

methodCall
    : ID LPAREN (currentParameters | VOID?) RPAREN
    ;

currentParameters
    : currentParameter (COMMA currentParameter)*
    ;

currentParameter
    : expr
    ;

classDeclaration
    : classModifier* CLASS TYPE parametricTypes? (EXTENDS TYPE (COMMA TYPE)*)? classBody
    ;

classBody
    : LCURL classMemberDeclaration* RCURL
    ;

classMemberDeclaration
    : classDeclaration
    | methodDeclaration
    | constructorDeclaration
    | attributeDeclaration
    ;

attributeDeclaration
    : visibilityModifier attributeDeclaration* ID (ASSIGNMENT expr)?
    ;

methodDeclaration
    : visibilityModifier attributeMethodModifier* functionDeclaration
    ;

constructorDeclaration
    : visibilityModifier CONSTRUCTOR LPAREN formalParameters RPAREN constructorBody
    ;

constructorBody
    : LCURL (SUPER LPAREN currentParameters RPAREN)? (THIS LPAREN currentParameters RPAREN)? statement*
    ;

enumDeclaration
    : ENUM TYPE enumBody
    ;

enumBody
    : LCURL ((ID | TYPE) (COMMA (ID | TYPE))*)? RCURL
    ;

ifStatement
    : IF LPAREN expr RPAREN (block | statement)
        ((ELIF LPAREN expr RPAREN (block | statement))* | (ELSE (block | statement))? )
    ;

whileStatement
    : WHILE LPAREN expr RPAREN (block | statement)
    ;

forStatement
    :  FOR LPAREN initializationfield COLON expr COLON updatefield RPAREN (block | statement)
    | FOR LPAREN TYPE ID COLON (expr | ID) RPAREN (block | statement)
    ;

initializationfield
    : ((TYPE ID | TYPE varAssignment | varAssignment) (COMMA (TYPE ID | TYPE varAssignment | varAssignment))*)
    ;

updatefield
    : varAssignment (COMMA varAssignment)*
    ;

dowhileStatement
    : DO (block | statement) WHILE LPAREN expr RPAREN
    ;

switchStatement
    : SWITCH LPAREN expr RPAREN LCURL defaultstatement? casestatement* finallystatement? RCURL
    ;

defaultstatement
    : DEFAULT ARROW block
    ;

finallystatement
    : FINALLY ARROW block
    ;

casestatement
    : CASE expr (COMMA expr)* ARROW block
    ;

throwStatement
    : THROW objectInstantation
    ;

tryStatement
    : TRY block (CATCH LPAREN formalParameters RPAREN block)+
    ;

thisStatement
    : THIS DOT ((ID | methodCall) | varAssignment)
    | THIS
    ;

objectInstantation
    : NEW TYPE LPAREN (currentParameters | VOID?) RPAREN
    ;

returnStatement
    : RETURN expr
    ;

anObjectCalls
    : ID DOT methodCall (DOT methodCall)*
    | objectInstantation DOT methodCall (DOT methodCall)*
    ;

Answer 1

Когда вы получаете сообщение об ошибке «Неожиданный ввод 'foo', ожидаемый BAR" и думаете, что "Но 'foo" - это бар "", первое, что вы должны сделать, это напечатать поток токеновдля вашего ввода (вы можете сделать это, запустив grun Symbols tokens -tokens inputfile).Если вы сделаете это, вы увидите, что a в вашем входе распознается как HexDigit, а не как ID.

Почему это происходит?Поскольку и HexDigit, и ID соответствуют входным данным a, а ANTLR (как и большинство генераторов лексеров) разрешает неоднозначности в соответствии с правилом максимального мунка: когда несколько правил могут соответствовать текущему вводу, выбирается то, которое дает самое длинное соответствие(именно поэтому переменные с более чем одной буквой работают), а затем разрешает связи, выбирая ту, которая определена первой, в данном случае HexDigit.

Обратите внимание, что лексеру не важно, какие правила лексераиспользуются парсером и когда.Лексер решает, какие токены создавать только на основе содержимого грамматики лексера, поэтому лексер не знает и не заботится о том, что парсер хочет ID прямо сейчас.Он просматривает все правила, которые соответствуют, а затем выбирает одно из них в соответствии с правилом максимального munch, и все.

В вашем случае вы фактически никогда не используете HexDigit в своей грамматике синтаксического анализатора, поэтому нет причин, почему вы 'я бы хотел, чтобы был создан токен HexDigit.Поэтому HexDigit не должно быть правилом лексера - это должно быть fragment:

fragment HexDigit : [0-9a-fA-F];

Это также относится к другим вашим правилам, которые не используются в анализаторе, включая все ...Digitправила.

PS: Ваше правило Number никогда не будет совпадать из-за этих же правил.Возможно, вместо этого это должно быть правило синтаксического анализа (или другие числовые правила должны быть фрагментами, если вам все равно, какой тип числового литерала у вас есть).