使用ANTLR同时执行while和while

Question

早些时候我创建了这个问题，询问如何使用ANTLR 4创建if/else语句。我得到了一个很好的答案，它也展示了如何做while循环。我已经在我的语言中实现了这一点，现在我正在尝试使用几乎相同的原理制作一个do-while循环。

while循环的语法如下:

count is 0
while count is less than 10
  count+
  if count not equals 10
    write " " + count + ": Getting there..."
  else if count equals 10
    write count + ": The end!"
  end if
end while

这就是我想要的do-while循环:

count is 0
do
  count+
  write "count is " + count
  if count equals 10
    write "The end!"
  end if
while count is less than 10

我已经测试过了，他们都工作，但是，不是在同一时间。下面是我的语法(很抱歉把它都贴出来了，但我认为这是必要的)。

如果我的WHILE和END_WHILE标记高于我的DO_WHILE和DO_WHILE_CONDITION标记，则while循环工作。然而，如果我把它们调换一下，我的do-while循环就可以工作了。如果我将DO_WHILE_CONDITION令牌更改为以外的任何东西，而则两者都有效。

无论如何，我可以让他们都工作与当前的语法?我明白这可能是一个问题，因为我使用相同的关键字多件事，但我希望有一种方法来做到这一点。

//////////////////////////////////
// PARSER
//////////////////////////////////
program
 : block EOF
 ;
block
 : (statement (NEW_LINE+ | EOF))*
 ;
statement
 : assignment
 | if_statement
 | while_statement
 | until_statement
 | do_while_statement
 | write
 ;
assignment
 : ID ASSIGN expression # expressionAssignment
 | ID PLUS              # incrementAssignment
 | ID MINUS             # decrementAssignment
 ;
if_statement
 : IF condition_block (ELSE_IF condition_block)* (ELSE NEW_LINE statement_block)? END_IF
 ;
condition_block
 : expression NEW_LINE statement_block
 ;
statement_block
 : block
 ;
while_statement
 : WHILE expression NEW_LINE statement_block END_WHILE
 ;
until_statement
 : UNTIL expression NEW_LINE statement_block END_UNTIL
 ;
do_while_statement
 : DO_WHILE NEW_LINE statement_block DO_WHILE_CONDITION expression
 ;
expression
 : atom                                             # atomExpression
 | expression PLUS expression                       # plusExpression
 | expression MINUS expression                      # minusExpression
 | expression MULTIPLY expression                   # multiplicationExpression
 | expression DIVIDE expression                     # divisionExpression
 | expression PLUS                                  # incrementExpression
 | expression MINUS                                 # decrementExpression
 | expression AND expression                        # andExpression
 | expression OR expression                         # orExpression
 | expression EQUALS expression                     # equalityExpression
 | expression NOT_EQUALS expression                 # notEqualityExpression
 | expression LESS_THAN expression                  # lessThanExpression
 | expression NOT_LESS_THAN expression              # notLessThanExpression
 | expression GREATER_THAN expression               # greaterThanExpression
 | expression NOT_GREATER_THAN expression           # notGreaterThanExpression
 | expression GREATER_THAN_OR_EQUAL expression      # greaterThanOrEqualExpression
 | expression LESS_THAN_OR_EQUAL expression         # lessThanOrEqualExpression
 ;
atom
 : INT                              # integerAtom
 | FLOAT                            # floatAtom
 | BOOLEAN                          # boolAtom
 | ID                               # idAtom
 | STRING                           # stringAtom
 | OPEN_PAR expression CLOSE_PAR    # expressionAtom
 ;
write
 : WRITE expression
 ;
////////////////////////////////// 
// LEXER
//////////////////////////////////
PLUS                        : '+';
MINUS                       : '-';
MULTIPLY                    : '*';
DIVIDE                      : '/';
ASSIGN                      : 'is';
OPEN_CURLY                  : '{';
CLOSE_CURLY                 : '}';
OPEN_PAR                    : '(';
CLOSE_PAR                   : ')';
COLON                       : ':';
NEW_LINE                    : 'r'? 'n';
IF                          : 'if';
ELSE_IF                     : 'else if';
ELSE                        : 'else';
END_IF                      : 'end if';
WHILE                       : 'while';
END_WHILE                   : 'end while';
UNTIL                       : 'until';
END_UNTIL                   : 'end until';
DO_WHILE                    : 'do';
DO_WHILE_CONDITION          : 'while';
EQUALS                      : 'equals';
NOT_EQUALS                  : 'not equals';
LESS_THAN                   : 'is less than';
NOT_LESS_THAN               : 'is not less than';
GREATER_THAN                : 'is greater than';
NOT_GREATER_THAN            : 'is not greater than';
GREATER_THAN_OR_EQUAL       : 'is greater than or equals';
LESS_THAN_OR_EQUAL          : 'is less than or equals';
WRITE                       : 'write';
AND                         : 'and';
OR                          : 'or';
NOT                         : 'not';
BOOLEAN
 : 'TRUE' | 'true' | 'YES' | 'yes'
 | 'FALSE' | 'false' | 'NO' | 'no'
 ;
INT
 : (PLUS | MINUS)? NUMBER+
 ;
FLOAT
 : (PLUS | MINUS)? NUMBER+ ('.' | ',') (NUMBER+)?
 | (PLUS | MINUS)? (NUMBER+)? ('.' | ',') NUMBER+
 ;
NUMBER
 : '0'..'9'
 ;
STRING
 : '"' ( '\"' | ~["] )* '"'
 ;
ID
 : ('a'..'z' | 'A'..'Z' | '0'..'9')+
 ;
WHITESPACE
 : [ t]+ -> skip
 ;
COMMENT
 : ( ';;' .*? ';;' | ';' ~[rn]* ) -> skip
 ;  

Answer 1

创建令牌时，词法分析器不考虑解析器在某一点上可能需要的内容。检查这个描述规则(v3和v4)的问题:Antlr v3与解析器/词法分析器规则的错误

这意味着在您的情况下，规则DO_WHILE_CONDITION:

WHILE                       : 'while';
...
DO_WHILE_CONDITION          : 'while';

永远不会被匹配。

除此之外，用空白将关键字"粘"在一起通常不是一个好主意。考虑输入是"end  if"(2个空格)的情况。最好创建两个令牌:一个END和一个IF，并在解析器规则中使用它们。

试试这样写:

program
 : block
 ; 
block
 : NEW_LINE* (statement (NEW_LINE+ | EOF))*
 ;
statement
 : assignment
 | if_statement
 | while_statement
 | until_statement
 | do_while_statement
 | write
 ;
assignment
 : ID IS expression # expressionAssignment
 | ID PLUS          # incrementAssignment
 | ID MINUS         # decrementAssignment
 ;
if_statement
 : IF condition_block (ELSE IF condition_block)* (ELSE NEW_LINE statement_block)? END IF
 ;
condition_block
 : expression NEW_LINE statement_block
 ;
statement_block
 : block
 ;
while_statement
 : WHILE expression NEW_LINE statement_block END WHILE
 ;
until_statement
 : UNTIL expression NEW_LINE statement_block END UNTIL
 ;
do_while_statement
 : DO NEW_LINE statement_block WHILE expression
 ;
// Added unary expressions instead of combining them in the lexer.
expression
 : atom                                            # atomExpression
 | MINUS expression                                # unaryMinusExpression
 | PLUS expression                                 # unaryPlusExpression
 | expression PLUS expression                      # plusExpression
 | expression MINUS expression                     # minusExpression
 | expression MULTIPLY expression                  # multiplicationExpression
 | expression DIVIDE expression                    # divisionExpression
 | expression PLUS                                 # incrementExpression
 | expression MINUS                                # decrementExpression
 | expression AND expression                       # andExpression
 | expression OR expression                        # orExpression
 | expression EQUALS expression                    # equalityExpression
 | expression NOT EQUALS expression                # notEqualityExpression
 | expression IS LESS THAN expression              # lessThanExpression
 | expression IS NOT LESS THAN expression          # notLessThanExpression
 | expression IS GREATER THAN expression           # greaterThanExpression
 | expression IS NOT GREATER THAN expression       # notGreaterThanExpression
 | expression IS GREATER THAN OR EQUALS expression # greaterThanOrEqualExpression
 | expression IS LESS THAN OR EQUALS expression    # lessThanOrEqualExpression
 ;
atom
 : INT                              # integerAtom
 | FLOAT                            # floatAtom
 | bool                             # boolAtom
 | ID                               # idAtom
 | STRING                           # stringAtom
 | OPEN_PAR expression CLOSE_PAR    # expressionAtom
 ;
write
 : WRITE expression
 ;
// By making this a parser rule, you needn't inspect the lexer rule 
// to see if it's true or false.
bool
 : TRUE
 | FALSE
 ;
////////////////////////////////// 
// LEXER
//////////////////////////////////
PLUS                        : '+';
MINUS                       : '-';
MULTIPLY                    : '*';
DIVIDE                      : '/';
OPEN_CURLY                  : '{';
CLOSE_CURLY                 : '}';
OPEN_PAR                    : '(';
CLOSE_PAR                   : ')';
COLON                       : ':';
NEW_LINE                    : 'r'? 'n';
IF                          : 'if';
ELSE                        : 'else';
END                         : 'end';
WHILE                       : 'while';
UNTIL                       : 'until';
DO                          : 'do';
EQUALS                      : 'equals';
NOT                         : 'not';
IS                          : 'is';
LESS                        : 'less';
THAN                        : 'than';
GREATER                     : 'greater';
WRITE                       : 'write';
AND                         : 'and';
OR                          : 'or';
TRUE  : 'TRUE'  | 'true'  | 'YES' | 'yes';
FALSE : 'FALSE' | 'false' | 'NO'  | 'no';
INT
 : DIGIT+
 ;
// (DIGIT+)? is the same as: DIGIT*
FLOAT
 : DIGIT+ [.,] DIGIT*
 | DIGIT* [.,] DIGIT+
 ;
// If a rule can never become a token on its own (an INT will always 
// be created instead of a DIGIT), mark it as a 'fragment'.
fragment DIGIT
 : [0-9]
 ;
// Added support for escaped backslashes.
STRING
 : '"' ( '\"' | '\\' | ~["\] )* '"'
 ;
// Can it start with a digit? Maybe this is better: [a-zA-Z] [a-zA-Z0-9]*
ID
 : [a-zA-Z0-9]+
 ;
WHITESPACE
 : [ t]+ -> skip
 ;
COMMENT
 : ( ';;' .*? ';;' | ';' ~[rn]* ) -> skip
 ;  

哪个解析器都是while结构而没有问题。还请注意，我对您的语法做了轻微的调整(请参阅内联注释)。一元表达式很重要，否则1-2将被标记为2个INT标记，而在解析器中无法匹配expression !