ANTLR4 Неожиданное поведение при разборе - PullRequest
Новая
       42

ANTLR4 Неожиданное поведение при разборе

0 голосов
/ 24 декабря 2018

Я пытаюсь создать новый язык с ANTLR, и я столкнулся с проблемой.Я пытаюсь поддерживать числовые выражения и математические операции над числами (я считаю, это очень важно), но парсер, похоже, не работает так, как я ожидаю.Вот моя грамматика: 

grammar Lumos;

/*
 * Parser Rules
 */

 program        : 'start' stat+ 'stop';

 block          : stat*
                ;

 stat           : assign
                | numop
                | if_stat
                | while_stat
                | display
                ;



 assign         : LET ID BE expr ;

 display        : DISPLAY expr ;
 numop          : add | subtract | multiply | divide ; 


 add            : 'add' expr TO ID ;
 subtract       : 'subtract' expr 'from' ID ;
 divide         : 'divide' ID BY expr ; 
 multiply       : 'multiply' ID BY expr ;

 append         : 'append' expr TO ID ;

 if_stat
 : IF condition_block (ELSE IF condition_block)* (ELSE stat_block)?
 ;

condition_block
 : expr stat_block
 ;

stat_block
 : OBRACE block CBRACE
 | stat
 ;

while_stat
 : WHILE expr stat_block
 ;



 expr           : expr POW<assoc=right> expr        #powExpr
                | MINUS expr                        #unaryExpr
                | NOT expr                          #notExpr
                | expr op=(TIMES|DIV|MOD) expr      #multiplicativeExpr
                | expr op=(PLUS|MINUS) expr         #additiveExpr
                | expr op=RELATIONALOPERATOR expr   #relationalExpr
                | expr op=EQUALITYOPERATOR expr     #equalityExpr
                | expr AND expr                     #andExpr
                | expr OR expr                      #orExpr
                //| ARRAY                               #arrayExpr
                | atom                              #atomExpr
                ;                                   

 atom           : LPAREN expr RPAREN                #parExpr
                | (INT|FLOAT)                       #numberExpr

                | (TRUE|FALSE)                      #booleanAtom
                | ID                                #idAtom
                | STRING                            #stringAtom
                | NIX                               #nixAtom
                ;


compileUnit                     : EOF ;

/*
 * Lexer Rules
 */

 fragment LETTER    : [a-zA-Z] ;

 MATHOP             : PLUS
                    | MINUS
                    | TIMES
                    | DIV
                    | MOD
                    | POW
                    ;

    RELATIONALOPERATOR  : LTEQ
                        | GTEQ
                        | LT
                        | GT
                        ;  

    EQUALITYOPERATOR    : EQ
                        | NEQ
                        ;

 LPAREN             : '(' ;
 RPAREN             : ')' ;
 LBRACE             : '{' ;
 RBRACE             : '}' ;

 OR                 : 'or' ;
 AND                : 'and' ;

 BY                 : 'by' ;
 TO                 : 'to' ;
 FROM               : 'from' ;
 LET                : 'let' ;
 BE                 : 'be' ;


 EQ                 :'==' ;
 NEQ                :'!=' ;
 LTEQ               :'<=' ;
 GTEQ               :'>=' ;
 LT                 :'<' ;
 GT                 :'>' ;

 //Different statements will choose between these, but they are pretty much the 
 same.
 PLUS               :'plus' ;
 ADD                :'add' ;
 MINUS              :'minus' ;
 SUBTRACT           :'sub' ;
 TIMES              :'times' ;
 MULT               :'multiply' ;

 DIV                :'divide' ; 
 MOD                :'mod' ;
 POW                :'pow' ;

 NOT                :'not' ;
 TRUE               :'true' ;
 FALSE              :'false' ;
 NIX                :'nix' ;
 IF                 :'if' ;
 THEN               :'then' ;
 ELSE               :'else' ;
 WHILE              :'while' ;
 DISPLAY            :'display' ;

 ARRAY              : '['(INT|FLOAT)(','(INT|FLOAT))+']';
 ID                 : [a-z]+ ;
 WORD               : LETTER+ ;

 //NUMBER               : INT | FLOAT ;

 INT                : [0-9]+ ; 

 FLOAT              : [0-9]+ '.' [0-9]*
                    | '.'[0-9]+ 
                    ;

 COMMENT            : '#' ~[\r\n]* -> channel(HIDDEN) ;
 WS                 : [ \n\t\r]+ -> channel(HIDDEN) ;
 STRING             : '"' (~["{}])+ '"' ;

При вводе let foo be 5 times 3 посетитель видит let foo be 5 и посторонний times 3.Я думал, что настроил правило expr, чтобы оно распознавало выражение умножения до того, как распознало атомы, чтобы этого не произошло.Я не знаю, где я ошибся, но это не работает, как я ожидал.

Если у кого-нибудь есть идеи, где я ошибся или как я могу решить эту проблему, я был бы признателен за ваш вклад.

1 Ответ

0 голосов
/ 24 декабря 2018

Вы используете TIMES в правилах вашего синтаксического анализатора, но MATHOP также соответствует TIMES и, поскольку MATHOP определено перед вашим правилом TIMES, оно получает приоритет.Вот почему правило TIMES в expr op=(TIMES|DIV|MOD) expr не совпадает.

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

...