Antlr gauche problème récursif

Question

J'ai un problème récursif gauche dans ma grammaire Antlr. Même si je pense comprendre pourquoi il y a un problème, je suis incapable de penser à une solution. Le problème est avec la dernière ligne pour ma règle de type de données. J'ai inclus la grammaire entière pour vous de voir:

grammar Test; 

options {output=AST;ASTLabelType=CommonTree;} 
tokens {FUNCTION; ATTRIBUTES; CHILDREN; COMPOSITE;} 

program  : function ; 
function : ID (OPEN_BRACKET (attribute (COMMA? attribute)*)? CLOSE_BRACKET)? (OPEN_BRACE function* CLOSE_BRACE)? SEMICOLON? -> ^(FUNCTION ID ^(ATTRIBUTES attribute*) ^(CHILDREN function*)) ; 

attribute : ID (COLON | EQUALS) datatype -> ^(ID datatype); 

datatype : ID  -> ^(STRING["id"] ID) 
      | NUMBER -> ^(STRING["number"] NUMBER) 
      | STRING -> ^(STRING["string"] STRING) 
      | BOOLEAN -> ^(STRING["boolean"] BOOLEAN) 
      | array -> ^(STRING["array"] array) 
      | lookup -> ^(STRING["lookup"] lookup) 
      | datatype PLUS datatype -> ^(COMPOSITE datatype datatype) ; 

array  : OPEN_BOX (datatype (COMMA datatype)*)? CLOSE_BOX -> datatype* ; 
lookup  : OPEN_BRACE (ID (PERIOD ID)*) CLOSE_BRACE -> ID* ; 

NUMBER 
    : ('+' | '-')? (INTEGER | FLOAT) 
    ; 

STRING 
    : '"' (ESC_SEQ | ~('\\'|'"'))* '"' 
    ; 

BOOLEAN 
    : 'true' | 'TRUE' | 'false' | 'FALSE' 
    ; 

ID : (LETTER|'_') (LETTER | INTEGER |'_')* 
    ; 

COMMENT 
    : '//' ~('\n'|'\r')* '\r'? '\n' {$channel=HIDDEN;} 
    | '/*' (options {greedy=false;} : .)* '*/' {$channel=HIDDEN;} 
    ; 

WHITESPACE : (' ' | '\t' | '\r' | '\n') {$channel=HIDDEN;} ; 

COLON : ':' ; 
SEMICOLON : ';' ; 

COMMA : ',' ; 
PERIOD : '.' ; 
PLUS : '+' ; 
EQUALS : '=' ; 

OPEN_BRACKET : '(' ; 
CLOSE_BRACKET : ')' ; 

OPEN_BRACE : '{' ; 
CLOSE_BRACE : '}' ; 

OPEN_BOX : '[' ; 
CLOSE_BOX : ']' ; 

fragment 
LETTER 
    : 'a'..'z' | 'A'..'Z' 
    ; 

fragment 
INTEGER 
    : '0'..'9'+ 
    ; 

fragment 
FLOAT 
    : INTEGER+ '.' INTEGER* 
    ; 

fragment 
ESC_SEQ 
    : '\\' ('b'|'t'|'n'|'f'|'r'|'\"'|'\''|'\\') 
    ; 

Je développe l'aide fonctionne Antlr qui fournit une fonction pour résoudre ce problème - mais malheureusement, il ne semble pas fonctionner: s

Toute aide sois super.

Merci.

EDIT:

Voici un exemple de la langue que je suis en train de mettre en œuvre/analyser

<FunctionName> <OptionalAttributes> <OptionalChildFunctions> 

Ainsi, par exemple:

ForEach(in:[1,2,3,4,5] as:"i") { 
    Switch(value:{i}) { 
    Case(value:3) { 
     Print(message:"This is the number 3") 
    } 

    Default { 
     Print(message:"This isn't the number 3") 
    } 
} 
} 

Answer 1

D'accord, cela devrait faire l'affaire :

grammar Test; 

/************************************** PARSER **************************************/ 
program 
    : function EOF 
    ; 

function 
    : ID (OPEN_PAREN (attribute (COMMA attribute)*)? CLOSE_PAREN)? 
     (OPEN_BRACE function* CLOSE_BRACE)? 
     SEMICOLON? 
    ; 

attribute 
    : ID (COLON | EQUALS)? expression 
    ; 

expression 
    : atom (PLUS atom)* 
    ; 

atom 
    : ID 
    | STRING 
    | BOOLEAN 
    | NUMBER 
    | array 
    | lookup 
    ; 

array 
    : OPEN_BOX (expression (COMMA expression)*)? CLOSE_BOX 
    ; 

lookup 
    : OPEN_BRACE (ID (PERIOD ID)*) CLOSE_BRACE 
    ; 

/************************************** LEXER **************************************/ 
NUMBER   : ('+' | '-')? (INTEGER | FLOAT) 
       ; 

STRING   : '"' (ESC_SEQ | ~('\\'|'"'))* '"' 
       ; 

BOOLEAN   : 'true' | 'TRUE' | 'false' | 'FALSE' 
       ; 

ID    : (LETTER|'_') (LETTER | INTEGER |'_')* 
       ; 

COMMENT   : '//' ~('\n'|'\r')* ('\r'? '\n'| EOF) {$channel=HIDDEN;} 
       | '/*' (options {greedy=false;} : .)* '*/' {$channel=HIDDEN;} 
       ; 

WHITESPACE  : (' ' | '\t' | '\r' | '\n') {$channel=HIDDEN;} ; 

COLON   : ':' ; 
SEMICOLON  : ';' ; 

COMMA   : ',' ; 
PERIOD   : '.' ; 
PLUS   : '+' ; 
EQUALS   : '=' ; 

OPEN_PAREN  : '(' ; 
CLOSE_PAREN  : ')' ; 

OPEN_BRACE  : '{' ; 
CLOSE_BRACE  : '}' ; 

OPEN_BOX  : '[' ; 
CLOSE_BOX  : ']' ; 

fragment 
LETTER   : 'a'..'z' | 'A'..'Z' ; 
fragment 
INTEGER   : '0'..'9'+ ; 
fragment 
FLOAT   : INTEGER+ '.' INTEGER* ; 
fragment 
ESC_SEQ   : '\\' ('b'|'t'|'n'|'f'|'r'|'\"'|'\''|'\\') ; 

Notez que j'ai changé le nom de OPEN_BRACKET et CLOSE_BRACKET en OPEN_PAREN et CLOSE_PAREN. Les rondes, ( et ), sont des parenthèses, les carrés, [ et ], sont appelés parenthèses (ceux que vous avez appelés des boîtes, mais en les appelant des boîtes ne fait pas mal IMO).