以下几组规则是相互左递归的TREE GRAMMAR

Question

我有一个完整的解析器语法，而不是生成一个AST，我可以说使用重写规则和树操作符是正确的。目前，我被困在创建树grammar.I的阶段有这样的错误：

规则的以下几组相互左递归[direct_declarator，说明符]和[abstract_declarator，direct_abstract_declarator]

重写没有输出选项的语法或运算符;设置输出= AST

这是我的树语法。

tree grammar walker; 

options { 
    language = Java; 
    tokenVocab = c2p; 
    ASTLabelType = CommonTree; 
    backtrack = true; 
} 

@header 
{ 
package com.frankdaniel.compiler; 
} 

translation_unit 
    : ^(PROGRAM (^(FUNCTION external_declaration))+) 
    ; 

external_declaration 
options {k=1;} 
    : (declaration_specifiers? declarator declaration*)=> function_definition 
    | declaration 
    ; 


function_definition 
    : declaration_specifiers? declarator (declaration+ compound_statement|compound_statement) 
    ; 

declaration 

    : 'typedef' declaration_specifiers? init_declarator_list  
    | declaration_specifiers init_declarator_list? 
    ; 

declaration_specifiers 
    : (type_specifier|type_qualifier)+ 
    ; 

init_declarator_list 
    : ^(INIT_DECLARATOR_LIST init_declarator+) 
    ; 

init_declarator 
    : declarator (ASSIGN^ initializer)? 
    ; 


type_specifier : (CONST)? (VOID | CHAR | INT | FLOAT); 


type_id 
    : IDENTIFIER 
     //{System.out.println($IDENTIFIER.text+" is a type");} 
    ; 

type_qualifier 
    : CONST 
    ; 

declarator 
    : pointer? direct_declarator 
    | pointer 
    ; 

direct_declarator 
    : (IDENTIFIER|declarator) declarator_suffix* 
    ; 

declarator_suffix 
    : constant_expression 
    | parameter_type_list 
    | identifier_list 

    ; 

pointer 
    : TIMES type_qualifier+ pointer? 
    | TIMES pointer 
    | TIMES 
    ; 

parameter_type_list 
    : parameter_list 
    ; 

parameter_list 
    : ^(PARAMETER_LIST parameter_declaration) 
    ; 

parameter_declaration 
    : declaration_specifiers (declarator|abstract_declarator)* 
    ; 

identifier_list 
    : ^(IDENTIFIER_LIST IDENTIFIER+) 
    ; 

type_name 
    : specifier_qualifier_list abstract_declarator? 
    ; 
specifier_qualifier_list 
    : (type_qualifier | type_specifier)+ 
    ; 

abstract_declarator 
    : pointer direct_abstract_declarator? 
    | direct_abstract_declarator 
    ; 

direct_abstract_declarator 
    : (abstract_declarator | abstract_declarator_suffix) abstract_declarator_suffix* 
    ; 

abstract_declarator_suffix 
    : constant_expression 
    | parameter_type_list 
    ; 

initializer 
    : assignment_expression 
    | initializer_list? 
    ; 

initializer_list 
    : ^(INITIALIZER_LIST initializer+) 
    ; 


// EXPRESSIONS 
argument_expression_list 
    : ^(EXPRESSION_LIST assignment_expression+) 
    ; 

multiplicative_expression 
    : ^((TIMES|DIV|MOD) cast_expression cast_expression); 


additive_expression 
    : ^((PLUS|MINUS) multiplicative_expression multiplicative_expression); 



cast_expression 
    : ^(CAST_EXPRESSION type_name cast_expression) 
    | unary_expression 
    ; 

unary_expression 
    : postfix_expression 
    | PPLUS unary_expression 
    | MMINUS unary_expression 
    | unary_operator cast_expression 
    ; 

postfix_expression 
    : primary_expression 
     ( expression 
     | argument_expression_list 
     | IDENTIFIER 
     | IDENTIFIER 
     | PPLUS 
     | MMINUS 
     )* 
    ; 

unary_operator 
    : TIMES 
    | PLUS 
    | MINUS 
    | NOT 
    ; 

primary_expression 
    : IDENTIFIER 
    | constant 
    | expression 
    ; 

constant 
    : HEX_LITERAL 
    | OCTAL_LITERAL 
    | DECIMAL_LITERAL 
    | CHARACTER_LITERAL 
    | STRING_LITERAL 
    | FLOATING_POINT_LITERAL 
    ; 

//////////////////////////////////////////////////////// 

expression 
    : ^(EXPRESSION assignment_expression+) 
    ; 

constant_expression 
    : conditional_expression 
    ; 

assignment_expression 
    : ^(assignment_operator lvalue assignment_expression) 
    | conditional_expression 
    ; 

lvalue 
    : unary_expression 
    ; 

assignment_operator 
    : ASSIGN 
    ; 

conditional_expression : (logical_or_expression) (QUESTIONMARK expression COLON conditional_expression)?; 
logical_or_expression : ^(OR logical_and_expression logical_and_expression); 
logical_and_expression : ^(AND equality_expression equality_expression); 

//equality_expression : (a=relational_expression) ((e=EQUAL|e=NONEQUAL)^ b=relational_expression)?; 
equality_expression : ^((EQUAL|NONEQUAL) relational_expression relational_expression); 

//relational_expression : additive_expression ((ST|GT|STEQ|GTEQ)^ additive_expression)* ; 
relational_expression : ^((ST|GT|STEQ|GTEQ) additive_expression additive_expression); 



// STATEMENTS 
statement 
    : compound_statement 
    | expression_statement 
    | selection_statement 
    | iteration_statement 
    | jump_statement 
    ; 

compound_statement 
    : ^(STATEMENT declaration* statement_list?) 
    ; 

statement_list 
    : statement+ 
    ; 

expression_statement 
    :expression 
    ; 

selection_statement 
    :^(IF expression statement (^(ELSE statement))?) 
    |^(SWITCH expression statement) 
    ; 

iteration_statement 
    : ^(WHILE expression statement) 
    | ^(DO statement ^(WHILE expression)) 
    | ^(FOR expression_statement expression_statement expression? statement) 
    ; 

jump_statement 
    : CONTINUE 
    | BREAK 
    | RETURN 
    | ^(RETURN expression) 
    ; 

Answer 1

它似乎很明显的是，以下两条规则是左递归：

{}代码说明符 ：指针？ direct_declarator |指针 ;

direct_declarator ：（名称|声明符）declarator_suffix * ;
{code}

规则“声明符”引用“direct_declarator”，“direct_declarator”引用“声明符”，并且没有其他谓词用于引导规则评估。