Bison 移位减少野牛语法中的冲突？

我有下面的Bison语法文件，当我执行“Bison-d filename.y”时，我会收到一条消息

冲突：5班/减少

事实上，他们是8，我设法摆脱了3，但不知道其余的在哪里，我猜这是与逗号有关，但嗯。。我的语法定义有什么错。解析器应该解析Prolog语法的一部分

%{#include <math.h>
#include <stdio.h>
void yyerror(char *message);
%}
%start program
%token ATOM VAR NUM

%token DOT COMMA
%token PARENTLEFT PARENTRIGHT RSQRBRACKETS LSQRBRACKETS
%token IF CUT IS PIPE
%token SMALLEREQ GREQ SMALLER GREATER EQ
%token PLUS MULTIP DIVIDE MINUS MOD
%token Aus

%left PLUS MINUS
%left DIVIDE MULTIP
%left COMMA

%%
program :           program rule                { printf("programm fertig gelesen \n");} 
        |       program fact                { printf("programm fertig gelesen \n");} 
        |       rule                        { printf("programm fertig gelesen \n");} 
        |       fact                        { printf("programm fertig gelesen \n");}
;

fact :              struct DOT                  { printf("Fakt gelesen\n\n\n"); }
;

rule :              struct IF subProbList DOT   { printf("Regel mit %d Teilprobleme    gelesen\n\n\n", $3); }
;

struct :            ATOM PARENTLEFT parameterList PARENTRIGHT  {printf("%s mit %d    Variablen\n",$1,$3); $$=$3;}
;

subProbList :       subProb                     {$$ = 1; }
        |       subProbList COMMA subProb   {$$ = $1 + 1;}
;

subProb :           struct | assignmentTerm | comparison | CUT { printf("CUT Op\n"); }
;

assignmentTerm :    exp IS exp                  { printf("is mit %d Variabeln\n", ($1 + $3)); $$ = $1 + $3; }
;

exp :               num                         { $$ = 0; }
    |           var                         { printf("Variable %s \n", $1); $$ = 1; } 
    |           exp operation exp           { printf("left exp is %d right exp is %d\n",$1,$3); $$ = $1 + $3;} 
    |           PARENTLEFT exp PARENTRIGHT         { $$ = $2;}
;

parameter :         var                         { printf("Variable %s\n",$1 ); $$ = 1; }
        |       struct                      { $$ = $1; }
        |       list                        { $$ = $1; }
;

parameterList :     parameter                   { $$ = $1;}
            |   parameterList COMMA parameter {$$= $1 + $3;}
;

operation :         PLUS | MINUS | MULTIP | DIVIDE | MOD
;

comparison :        var comparisonOp num        { printf("Variable %s \n", $1);

                                                printf("Vergleich mit 1 Vars\n" );
                                                $$=1;   
                                            }
        |       num comparisonOp var        {  
                                                printf("Variable %s \n", $3);
                                                printf("Vergleich mit 1 Vars\n" );
                                                $$=1;   
                                            }

        |       var comparisonOp var        {   printf("Variable %s \n", $1);
                                                printf("Variable %s \n", $3);
                                                printf("Vergleich mit 2 Vars\n" );
                                                $$=2;   
                                            }
        |       num comparisonOp num        {  
                                                $$=0; 
                                                printf("Vergleich mit 0 Variablen \n");

                                            }
;

comparisonOp :      EQ | GREATER | SMALLER | GREQ | SMALLEREQ
;

list :              LSQRBRACKETS varList RSQRBRACKETS       {$$ = $2;}
    |           LSQRBRACKETS elementList RSQRBRACKETS   {$$ = $2;}
    |           LSQRBRACKETS RSQRBRACKETS               {$$ = 0;}
;
varList :           var PIPE var                {   printf("Variable %s \n", $1);
                                                printf("Variable %s \n", $3);
                                                $$ = 2;
                                            }
;
elementList :       ATOM                        { $$ = 0;}
            |   var                         { printf("Variable %s \n", $1); $$ = 1; } 
            |   elementList COMMA var       { $$ = $1 + 1; } 
            |   elementList COMMA ATOM      { $$ = $1; }
;

num : NUM | MINUS NUM
;
var : VAR | MINUS VAR
;
%%

int main(int argc, char **argv){
    yyparse();
    return 0;
}

void yyerror(char *message) {
    printf("How about no?Well,no,that word doesnt belong to this classy language! \n");
}

%{#包括
#包括
无效错误（字符*消息）；
%}
%启动程序
%标记原子变量NUM
%标记点逗号
%标记PARENTLEFT PARENTRIGHT RSQR括号LSQR括号
%如果切割是管道，则标记
%令牌SMALLEREQ GREQ更小更大EQ
%令牌加多重除法减模
%代币澳大利亚
%左加减
%左除多
%左逗号
%%
程序：程序规则{printf（“programm fertig gelesen\n”）；}
|程序事实{printf（“programm fertig gelesen\n”）；}
|规则{printf（“programm fertig gelesen\n”）；}
|事实{printf（“programm fertig gelesen\n”）；}
;
事实：结构点{printf（“Fakt-gelesen\n\n”）；}
;
规则：struct IF subblist DOT{printf（“Regel mit%d Teilprobleme gelesen\n\n”，$3）；}
;
结构：ATOM PARENTLEFT参数列表PARENTRIGHT{printf（“%s mit%d Variablen\n”，$1，$3）；$$=$3；}
;
subboList:subboB{$$=1；}
|subboList逗号subboB{$$=$1+1；}
;
子B:struct | assignmentTerm | comparison | CUT{printf（“CUT Op\n”）；}
;
assignmentTerm:exp是exp{printf（“是mit%d Variabeln\n”，（$1+$3））；$$=$1+$3；}
;
exp:num{$$=0；}
|var{printf（“变量%s\n”，$1）；$$=1；}
|exp操作exp{printf（“左exp为%d，右exp为%d\n”，$1，$3）；$$=$1+$3；}
|PARENTLEFT exp PARENTRIGHT{$$=$2；}
;
参数：var{printf（“变量%s\n”，$1）；$$=1；}
|结构{$$=$1；}
|列表{$$=$1；}
;
parameterList:参数{$$=$1；}
|参数列表逗号参数{$$=$1+$3；}
;
操作：加|减|多|除|模
;
比较：var comparisonOp num{printf（“变量%s\n”，$1）；
printf（“Vergleich mit 1变量”）；
$$=1;   
}
|num comparisonOp var{
printf（“变量%s\n”，$3）；
printf（“Vergleich mit 1变量”）；
$$=1;   
}
|var comparisonOp var{printf（“变量%s\n”，$1）；
printf（“变量%s\n”，$3）；
printf（“Vergleich mit 2变量”）；
$$=2;   
}
|num comparisonOp num{
$$=0; 
printf（“Vergleich mit 0 Variablen\n”）；
}
;
比较NOP:EQ |大|小|格雷克|小雷克
;
列表：lsqrcolds变量列表rsqrcolds{$$=$2；}
|lsqr括号元素列表rsqr括号{$$=$2；}
|lsqr括号rsqr括号{$$=0；}
;
varList:var PIPE var{printf（“变量%s\n”，$1）；
printf（“变量%s\n”，$3）；
$$ = 2;
}
;
elementList:ATOM{$$=0；}
|var{printf（“变量%s\n”，$1）；$$=1；}
|elementList逗号变量{$$=$1+1；}
|元素列表逗号原子{$$=$1；}
;
num:num |减去num
;
var:var |减去var
;
%%
int main（int argc，字符**argv）{
yyparse（）；
返回0；
}
无效错误（字符*消息）{
printf（“不呢？不，这个词不属于这种上流语言！\n”）；
}

如果将

exp

的定义更改为

exp :           num    
    |           var
    |           exp PLUS exp
    |           exp MINUS exp
    |           exp MULTIP exp
    |           exp DIVIDE exp
    |           exp MOD exp
    |           PARENTLEFT exp PARENTRIGHT
;

即在

exp

中展开

操作（并将其删除），然后添加

%left MOD

在其他操作符中，就是定义它相对于其他操作符的优先级，那么你应该没问题。
顺便说一句，解析器完美地解析了我作为输入提供的文件，因此它可以按照我的要求工作，但如果冲突可以消除，那就太好了。