Bison 非终结符在语法中无用，规则在解析器中无用答案

【问题标题】：Bison nonterminal useless in grammar, rule useless in parserBison 非终结符在语法中无用，规则在解析器中无用
【发布时间】：2021-09-05 14:23:44
【问题描述】：

我正在尝试使用 flex-bison “从头开始”制作编译器。我试图在网上寻求帮助，但我没有找到太多的东西我设法找到了一本书：John Levine 的 flex & bison

它非常有用，但我不知道该怎么做。

这是我的弹性代码：

%option noyywrap 

%{
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include "parser.tab.h"

    extern FILE *yyin;
    extern FILE *yyout;
    int line_no = 1;

    //the function of lexer analysis. Return the token
    int yylex();
    //error function 
    void yyerror();
    //print statement function
    void print_return(char *token);

%}

%x ML_COMMENT

alphabet    [a-zA-Z]        
digit           [0-9]
alphanumeric    {alphabet}|{digit}
print       [ -~]
underscore  _
identifier      ({alphabet}|{underscore})+({alphanumeric}|{underscore})* 
integer         "0"|[0-9]{digit}*
float_number    "0"|{digit}*"."{digit}+
char        \'{print}\'

%%

"PROGRAM"       {  print_return("PROGRAM"); return PROGRAM}

"%".*           {  print_return("COMMENT"); return COMMENT; }

"BREAK"         {  print_return("BREAK"); return BREAK; }
"VARS"          {  print_return("VARS"); return VARS; }    

"STARTMAIN"     {  print_return("STARTMAIN");  return STARTMAIN; }   
"ENDMAIN"       {  print_return("ENDMAIN"); return ENDMAIN;}

"IF"            {  print_return("IF");  return IF; }
"THEN"          {  print_return("THEN"); return THEN;}
"ELSEIF"        {  print_return("ELSEIF"); return ELSEIF; }
"ELSE"          {  print_return("ELSE"); return ELSE; }
"ENDIF"         {  print_return("ENDIF"); return ENDIF; }

"FOR"           {  print_return("FOR"); return FOR; }
"TO"            {  print_return("TO"); return TO; }
"STEP"          {  print_return("STEP"); return STEP; }
"ENDFOR"        {  print_return("ENDFOR"); return ENDFOR; }

"SWITCH"        {  print_return("SWITCH"); return SWITCH; }
"CASE"          {  print_return("CASE"); return CASE; }
"ENDSWITCH"     {  print_return("ENDSWITCH"); return ENDSWITCH; }

"RETURN"        {  print_return("RETURN"); RETURN; }

"FUNCTION"      {  print_return("FUN"); return FUN; }
"ENDFUNCTION"   {  print_return("ENDFUNCTION"); return ENDFUNCTION; }

"PRINT"         {  print_return("PRINT"); return PRINT; }

"WHILE"         {  print_return("WHILE"); return WHILE;}
"ENDWHILE"      {  print_return("ENDWHILE"); return ENDWHILE;}

";"             {  print_return("QM"); return QM; }
"\n"            {  line_no++; print_return("NEWLINE"); return NEWLINE; }     
"\t"            {  print_return("INDENT"); return INDENT; }     
       
"+="            {  print_return("ADD_ASSIGN"); return ADD_ASSIGN; }        
"-="            {  print_return("SUB_ASSIGN"); return SUB_ASSIGN; }       
"/="            {  print_return("DIV_ASSIGN"); return DIV_ASSIGN; }       
"%="            {  print_return("MOD_ASSIGN"); return MOD_ASSIGN; }     
"--"            {  print_return("DEC_OP"); return DEC_OP; }      
"++"            {  print_return("INC_OP"); return INC_OP; }        
"AND"           {  print_return("AND_OP"); return AND_OP; }      
"OR"            {  print_return("OR_OP"); return OR_OP; }       
"=="            {  print_return("EQ_OP"); return EQ_OP; }      
">="            {  print_return("GE_OP"); return GE_OP; }      
"<="            {  print_return("LE_OP"); return LE_OP; }      
"!="            {  print_return("NE_OP"); return NE_OP; }     
"{"             {  print_return("L_BRACE"); return L_BRACE; }        
"}"             {  print_return("R_BRACE"); return R_BRACE; }        
","             {  print_return("COMMA"); return COMMA; }       

"="             {  print_return("ASSIGN"); return ASSIGN; }       
"("             {  print_return("L_PAR"); return L_PAR; }        
")"             {  print_return("R_PAR"); return R_PAR;}     
"["             {  print_return("L_BRACK"); return L_BRACK; }        
"]"             {  print_return("R_BRACK"); return R_BRACK;}     
"."             {  print_return("DOT"); return DOT; }        
"_"             {  print_return("UNDERSCORE"); return UNDERSCORE; }       
"-"             {  print_return("MINUS"); return MINUS; }        
"+"             {  print_return("PLUS"); return PLUS; }       
"*"             {  print_return("MUL"); return MUL; } 
":"             {  print_return("COLON"); return COLON; }

"/"             {  print_return("DIV"); return DIV; }
"<"             {  print_return("LT"); return LT; }
">"             {  print_return("GT"); return GT; }
[ ]             ; 
.               { yyerror("Unkown character"); }

{identifier}    { print_return("ID"); strcpy(yylval.name, yytext);  return IDENTIFIER; } 
{integer}       { yylval.integer_val = atoi(yytext); print_return("INTEGER"); return INTEGER; }
{float_number}  { print_return("FLOAT"); return FLOAT; }
{char}          { print_return("CHAR"); return CHAR; }

%%
/*---------------------------------------------------------------------------------------------------------------------*/
void print_return(char *token)
{
    printf("Token: %s\t\t Line: %d\t\t Text: %s\n", token, line_no, yytext);    
}

这是我的野牛文件：

%{

    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    #include "print_console.c"

    //pointer to input file of lexer
    extern FILE *yyin; 
    //pointer to output file of lexer
    extern FILE *yyout;
    //line counter
    extern int line_no;
    //reads the input stream generates tokens
    extern int yylex();
    //temporary token save
    extern char* yytext;

    //Function Initilize
    int yylex();
    void yyerror(char *message);

%}

//struct for print_console
%union 
{
    char name[500];
    int integer_val;
}

/* --------------------------------------- TOKENS ---------------------------------------*/
//starting symbol
%start PROGRAM 

%token COMMENT
%token BREAK
%token VARS

%token QM

%token STARTMAIN 
%token ENDMAIN

%token IF
%token THEN
%token ELSEIF
%token ELSE
%token ENDIF

%token FOR
%token TO
%token STEP
%token ENDFOR

%token SWITCH
%token CASE
%token ENDSWITCH

%token RETURN

%token FUNCTION
%token ENDFUNCTION

%token PRINT

%token WHILE
%token ENDWHILE

%token NEWLINE
%token INDENT

%token ADD_ASSIGN
%token SUB_ASSIGN
%token DIV_ASSIGN
%token MOD_ASSIGN
%token DEC_OP
%token INC_OP
%token AND_OP
%token OR_OP
%token EQ_OP
%token GE_OP
%token LE_OP
%token NE_OP
%token L_BRACE
%token R_BRACE
%token COMMA
%token COLON

%token ASSIGN
%token L_PAR
%token R_PAR
%token L_BRACK
%token R_BRACK
%token DOT
%token UNDERSCORE
%token MINUS
%token PLUS
%token MUL
%token DIV
%token LT
%token GT
%token FLOAT
%token CHAR

%token <name> IDENTIFIER
%token <integer_val> INTEGER

//type for access to $$ 
%type <integer_val> line int_op int_data
%type <name> calc_assignment

%%  

/* --------------------------------------- BNF GRAMMAR ---------------------------------------*/

program: program line;

line:   if_stmt {;} 
        | elseif_stmt {;} 
        | else_stmt {;} 
        | for_statement {;} 
        | function NEWLINE INDENT {;}
        | function NEWLINE indent2 {;}
        | function NEWLINE {;} 
        | function_call {;} 
        | comments NEWLINE {;} 
        | action {;}
        | print NEWLINE {;}
        | switch  NEWLINE  case NEWLINE {;}
        | dictionaries NEWLINE {;} 
    | calc_assignment NEWLINE {;}
        | NEWLINE {;}    ;
/*--------- BREAK -------------*/
break:BREAK QM NEWLINE ;

/*--------- ACTION & indents -------------*/

indent2: INDENT INDENT;
indent3: INDENT INDENT INDENT;
indent4: INDENT INDENT INDENT INDENT;
indent5: INDENT INDENT INDENT INDENT INDENT;

action: INDENT line 
        | indent2 line 
        | indent3 line 
        | indent4 line 
        | indent5 line ;
/*--------- DATA TYPES -------------*/
data_type: CHAR
        | INTEGER 
        | IDENTIFIER;

/*--------- FUNCTIONS --------------*/
function: FUNCTION IDENTIFIER L_PAR optional_parameters R_PAR ;
end_function: ENDFUNCTION NEWLINE;

function_call: IDENTIFIER L_PAR optional_parameters R_PAR 
            | IDENTIFIER L_PAR data_type R_PAR
                | IDENTIFIER L_PAR data_type COMMA data_type R_PAR    
                | IDENTIFIER L_PAR data_type COMMA data_type COMMA data_type R_PAR;

/*------------ INSPECTORS -------------*/
inspector:IDENTIFIER operators IDENTIFIER
        |IDENTIFIER operators INTEGER
        |INTEGER operators IDENTIFIER
        |INTEGER operators INTEGER   ;

inspector_gen: inspector | inspector AND_OR_operators;

/*----------- IF & FOR STATEMENTS -------------*/

if_stmt:IF L_PAR inspector_gen R_PAR THEN NEWLINE action  ;
elseif_stmt: ELSEIF L_PAR inspector_gen R_PAR NEWLINE action  ;
else_stmt: ELSE NEWLINE action  ;
end_if_stmt:ENDIF NEWLINE  ;

for_statement: FOR IDENTIFIER COLON ASSIGN INTEGER TO INTEGER STEP INTEGER NEWLINE action;
end_for_statement: ENDFOR NEWLINE;


/*---------- SWITCH / CASE STATEMENT -----------------*/
switch: SWITCH L_PAR LT IDENTIFIER GT R_PAR NEWLINE action;

case: CASE L_PAR LT INTEGER GT R_PAR NEWLINE action;

end_switch: ENDSWITCH NEWLINE;

/*-------------- WHILE ---------------*/
while: WHILE L_PAR inspector_gen R_PAR NEWLINE action  ;
end_wile: ENDWHILE NEWLINE;

/*-------------- OPERATORS ---------------*/
operators:EQ_OP 
      | GE_OP 
      | LE_OP 
      | NE_OP 
      | DEC_OP 
      | INC_OP 
      | LT 
      | GT;

AND_OR_operators:AND_OP
        |OR_OP;

optional_parameters: IDENTIFIER 
        | optional_parameters COMMA IDENTIFIER ;

/*-------------- COMMENTS ---------------*/
comments: COMMENT;

/*-------------- PRINT ---------------*/
print: PRINT L_PAR data_type R_PAR QM;

/*-------------- MAIN ---------------*/
start_main: STARTMAIN NEWLINE action;
end_main: ENDMAIN NEWLINE  ;

/* --- DICTIONARIES --- */
dictionaries: IDENTIFIER ASSIGN L_BRACE dictionary_data R_BRACE 
        | IDENTIFIER ASSIGN IDENTIFIER L_PAR L_BRACK L_PAR dictionary_data R_PAR R_BRACK R_PAR
     IDENTIFIER ASSIGN IDENTIFIER L_PAR dictionary_data optional_parameters dictionary_data R_PAR ;

dictionary_data: data_type COLON data_type 
        |data_type COLON data_type COMMA dictionary_data 
        | data_type COMMA data_type optional_parameters 
        | IDENTIFIER ASSIGN data_type | /* empty */ ;

/* --- CALCULATE --- */
calc_assignment: IDENTIFIER ASSIGN int_op { Change($1, $3); };
    
int_op: int_data { $$ = $1; }
    | int_op PLUS int_data { $$ = $1 + $3; }
    | int_op MINUS int_data { $$ = $1 - $3; }
    | int_op MUL int_data { $$ = $1 * $3; }
    | int_op DIV int_data { $$ = $1 / $3; } ;

int_data: INTEGER { $$ = $1; } 
        | IDENTIFIER { $$ = Search($1) -> integer_val; };

%%

/* ------------------------------------------------ C FUNCTIONS -------------------------------------------- */

void yyerror(char *message){
    printf("Error: \"%s\"\t in line %d. Token = %s\n", message, line_no, yytext);
    exit(1);
}   

/* ------------------------------------------ MAIN FUNCTION --------------------------------------------- */

int main(int argc, char *argv[]){

    hashTable = (hash *) calloc(SIZE, sizeof(hash));

        int flag;

    yyin = fopen(argv[1],"r");
    //yyparse(): reads tokens, executes actions
    flag = yyparse();
    fclose(yyin);

    printf("Parsing finished succesfully!\n\n");
    printf(" __________________________\n");
    Print();
    printf(" __________________________\n");

    return flag;   
}

我被困住了，不知道该怎么办。编译器就是不喜欢我的代码：

parser.y: warning: 9 nonterminals useless in grammar [-Wother]
parser.y: warning: 9 rules useless in grammar [-Wother]
parser.y:136.1-5: warning: nonterminal useless in grammar: break [-Wother]
  136 | break:BREAK QM NEWLINE ;
      | ^~~~~
parser.y:157.1-12: warning: nonterminal useless in grammar: end_function [-Wother]
  157 | end_function: ENDFUNCTION NEWLINE;
      | ^~~~~~~~~~~~
parser.y:177.1-11: warning: nonterminal useless in grammar: end_if_stmt [-Wother]
  177 | end_if_stmt:ENDIF NEWLINE  ;
      | ^~~~~~~~~~~
parser.y:180.1-17: warning: nonterminal useless in grammar: end_for_statement [-Wother]
  180 | end_for_statement: ENDFOR NEWLINE;
      | ^~~~~~~~~~~~~~~~~
parser.y:188.1-10: warning: nonterminal useless in grammar: end_switch [-Wother]
  188 | end_switch: ENDSWITCH NEWLINE;
      | ^~~~~~~~~~
parser.y:191.1-5: warning: nonterminal useless in grammar: while [-Wother]
  191 | while: WHILE L_PAR inspector_gen R_PAR NEWLINE action  ;
      | ^~~~~
parser.y:192.1-8: warning: nonterminal useless in grammar: end_wile [-Wother]
  192 | end_wile: ENDWHILE NEWLINE;
      | ^~~~~~~~
parser.y:217.1-10: warning: nonterminal useless in grammar: start_main [-Wother]
  217 | start_main: STARTMAIN NEWLINE action;
      | ^~~~~~~~~~
parser.y:218.1-8: warning: nonterminal useless in grammar: end_main [-Wother]
  218 | end_main: ENDMAIN NEWLINE  ;
      | ^~~~~~~~
parser.y: warning: 48 shift/reduce conflicts [-Wconflicts-sr]
parser.y: warning: 68 reduce/reduce conflicts [-Wconflicts-rr]
parser.y:141.10-29: warning: rule useless in parser due to conflicts [-Wother]
  141 | indent3: INDENT INDENT INDENT;
      |          ^~~~~~~~~~~~~~~~~~~~
parser.y:142.10-36: warning: rule useless in parser due to conflicts [-Wother]
  142 | indent4: INDENT INDENT INDENT INDENT;
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~
parser.y:143.10-43: warning: rule useless in parser due to conflicts [-Wother]
  143 | indent5: INDENT INDENT INDENT INDENT INDENT;

我知道我做错了什么。请帮我！我不知道如何继续。

【问题讨论】：

标签： c compiler-construction bison flex-lexer

【解决方案1】：

当您开始使用 Bison 时（实际上，在您使用它的任何时候），您最好将您的语法分成小块编写和调试。对于任何编程语言的任何项目来说，这都是一个好习惯，但当您缺乏经验时尤其如此。不要实现 all 运算符，只需实现其中的几个即可。一旦你有这个工作，你可以添加其余的。同样，不要实现 every 语句语法。从一个开始，让它工作，然后添加另一个。当干草堆不是很大时，更容易发现错误。一旦你养成了这个习惯，你会发现编程实际上变得容易多了。

现在，您的实际问题。如果从未使用过非终端，则它是“无用的”。换句话说，如果您定义了一个非终端并且从未在某些生产中使用它，bison 会警告您定义该非终端是没有意义的。 Bison 足够聪明，可以递归地进行分析：如果非终结符出现的唯一位置是在无用的非终结符的右侧，那么该非终结符也是无用的，你会收到警告它也。（我认为这不是问题，但我没有对您的代码进行广泛的分析。）

因此，例如，在您的语法中，除了将非终结符 break 定义为 break:BREAK QM NEWLINE ; 之外，您没有对它做任何事情。我想您打算稍后将其添加到您的语句替代方案中，在这种情况下，您可以忽略警告（这就是为什么它是警告而不是错误的原因）。但是，总的来说，在您准备好添加它的使用之前，不要将break 添加到您的语法中，这样会产生更少的噪音。

现在，移位/减少冲突。除非你有幸偶然发现了一个明显的问题，否则很难在没有看到冲突的实际状态的情况下弄清楚是什么导致了 shift/reduce 冲突；如果您使用-v 命令行选项，Bison 将生成这些状态的报告。在 John Levine 的优秀著作中提供了有关调试冲突的有用信息。

最新的 Bison 版本可以通过生成反例为您提供更多帮助。 Bison manual 中还有另一个很好的冲突解释，以及一些解释如何使用这个新功能的示例。

但是，碰巧的是，我确实偶然发现了一个明显的错误。您（部分）拥有以下作品：

line: action | print NEWLINE
action: INDENT line | indent2 line
indent2: INDENT INDENT

还有很多，但这足以造成冲突。撇开什么构成 INDENT 令牌，只注意到 print 以令牌 PRINT 开头，假设我们有以下输入：

INDENT INDENT PRINT

现在，你的语法是如何推导出它的？它可以这样做：

line -> action -> INDENT line -> INDENT action 
     -> INDENT INDENT line -> INDENT INDENT print NEWLINE

或者它可以这样做：

line -> action -> indent2 line -> INDENT INDENT line
     -> INDENT INDENT print NEWLINE

（我希望你知道，推导步骤包括用其右侧之一替换非终结符。所以上面是相同输入的两个不同推导，这意味着你的语法是不明确的。Bison 坚持生成一个明确的解析——这就是它的全部目的——如果同一输入有两个可能的解析，它就不能这样做。

或者，更准确地说，它可以通过在某些规则的帮助下选择要使用的解析来做到这一点。但是这些规则通常不会按预期工作，并且对于模棱两可的语法，除了语法的作者之外，真的没有办法让任何人知道要进行哪个解析。因此 Bison 会警告您存在 shift/reduce 冲突，然后使用其内置规则来选择一种可能的解析策略。

通常，与您的语法一样，当 Bison 应用这些规则时，它会发现某些产生式将不再适用于任何输入（因为消歧规则选择了其他一些产生式来应用）。在这种情况下，被淘汰的产品变得无用，这几乎可以肯定是一个错误，所以 Bison 也会对此产生警告。

我不知道这是否是所有冲突的原因，但最好解决这个问题，然后看看还剩下什么。

在我看来，您的意图似乎不是编写一种类似 Python 的语言，其中布局决定块结构，因为您似乎正在为所有块语法定义明确的结束标记。不可能使用上下文无关语法来强制正确缩进，所以我希望这不是您的意图。

对于像 C 这样不将布局视为语法一部分的语言，最常用的解析技术是让词法扫描器简单地跳过空格（制表符和空格）；由于空格对解析没有任何影响，因此通过强制它考虑空格可能去哪里来混淆语法是没有意义的。这当然是我的建议，但由于我真的不知道你的意图是什么，我真的不能再说什么了。

祝项目顺利。

【讨论】：

非常感谢。你很有帮助。我会尝试结束它