野牛的冲突答案

【问题标题】：Conflicts in Bison野牛的冲突
【发布时间】：2015-08-10 16:28:22
【问题描述】：

我正在尝试使用 Bison 和 Flex 制作一个小型编译器，但我经常出现移位/减少错误。我怀疑问题出在规则“assignacion”和规则“booleano”、“comparacion”、“expresionArit”、“termino”、“potencia”上。可能语法定义不正确。我希望通过使用“%prec”来解决这个问题，但我没有成功。

然后我把代码Bison和错误：

...
%start programa
%token <id> IDENTIFICADOR
%token <intvalue> ENTERO
%token <floatvalue> FLOTANTE
%token <boolvalue> BOOLEANO
%token <stringvalue> CADENA
%token <etiqueta> IF ELSEIF ELSE FOR WHILE DO IN READ WRITE PRINT BREAK CONTINUE PASS EXCEPT TO DOWNTO
%token NL EOF_INS APAR OPAR ACLAU OCLAU
%left OR
%left AND
%nonassoc PEQUENO GRANDE PEQIG GRAIG IGUAL DIFFE
%left MENOS MAS
%left DIVISION_ENTERA DIVISION PRODUCTO MODULO
%right EXPONENTE
%right ASSIGNACIONS
%nonassoc IFX
%nonassoc ELSE

%%
programa : bloques;
bloques : bloque bloques
        | bloque
        ;
bloque : if_sentencia
       | while_sentencia
       | for_sentencia
       | do_sentencia
       | instruccion
       | NL
       ;
if_sentencia : IF expresion ACLAU bloques OCLAU %prec IFX
             | IF expresion ACLAU bloques OCLAU else_sentencia
             ;
else_sentencia : ELSE expresion ACLAU bloques OCLAU
             | ELSEIF expresion ACLAU bloques OCLAU else_sentencia
             ;
while_sentencia: WHILE expresion ACLAU bloques OCLAU
               ;
for_sentencia: FOR APAR assignacion EOF_INS expresion EOF_INS assignacion OPAR ACLAU bloques OCLAU
             ;
do_sentencia: DO ACLAU bloques OCLAU WHILE expresion EOF_INS
            ;
instruccion : expresion EOF_INS;
expresion: expresion OR expresion
         | booleano;
booleano: booleano AND booleano
         | comparacion;
comparacion: comparacion PEQUENO comparacion
         | comparacion GRANDE comparacion
         | comparacion PEQIG comparacion
         | comparacion GRAIG comparacion
         | comparacion IGUAL comparacion
         | comparacion DIFFE comparacion
         | expresionArit
         ;
expresionArit: expresionArit MAS expresionArit
         | expresionArit MENOS expresionArit
         | termino;
termino: termino PRODUCTO termino
         | termino DIVISION termino
         | termino DIVISION_ENTERA termino
         | termino MODULO termino
         | potencia
         ;
potencia: potencia EXPONENTE potencia
         | factor
         ;
factor: ENTERO {printd("INT\n");}
         | FLOTANTE {printd("FLOAT\n");}
         | BOOLEANO {printd("BOOL\n");}
         | CADENA {printd("STRING\n");}
         | APAR expresion OPAR
         | assignacion
         ;
assignacion: variable ASSIGNACIONS expresion {printd("ASSIGNACION");} | variable;
// a=b=c;
variable: IDENTIFICADOR {printd("VARIABLE\n");};
%%
int
yyerror (char const *s)
{
    printf ("%s\n", s);
}
void main(int argc, char *argv[])
{
    extern FILE *yyin;
    ++argv; --argc;
    yyin = fopen( argv[0], "r" );
    yyparse();
}

错误：

conflictos: 14 desplazamiento(s)/reducción(ones)

我查看了输出，有些产品会产生错误，但要解决它们。

estado 21

   19 expresion: booleano .
   20 booleano: booleano . AND booleano

    AND  desplazar e ir al estado 38

    AND       [reduce usando la regla 19 (expresion)]
    $default  reduce usando la regla 19 (expresion)


estado 22

   21 booleano: comparacion .
   22 comparacion: comparacion . PEQUENO comparacion
   23            | comparacion . GRANDE comparacion
   24            | comparacion . PEQIG comparacion
   25            | comparacion . GRAIG comparacion
   26            | comparacion . IGUAL comparacion
   27            | comparacion . DIFFE comparacion

    DIFFE    desplazar e ir al estado 39
    IGUAL    desplazar e ir al estado 40
    GRAIG    desplazar e ir al estado 41
    PEQIG    desplazar e ir al estado 42
    GRANDE   desplazar e ir al estado 43
    PEQUENO  desplazar e ir al estado 44

    DIFFE     [reduce usando la regla 21 (booleano)]
    IGUAL     [reduce usando la regla 21 (booleano)]
    GRAIG     [reduce usando la regla 21 (booleano)]
    PEQIG     [reduce usando la regla 21 (booleano)]
    GRANDE    [reduce usando la regla 21 (booleano)]
    PEQUENO   [reduce usando la regla 21 (booleano)]
    $default  reduce usando la regla 21 (booleano)


estado 23

   28 comparacion: expresionArit .
   29 expresionArit: expresionArit . MAS expresionArit
   30              | expresionArit . MENOS expresionArit

    MAS    desplazar e ir al estado 45
    MENOS  desplazar e ir al estado 46

    MAS       [reduce usando la regla 28 (comparacion)]
    MENOS     [reduce usando la regla 28 (comparacion)]
    $default  reduce usando la regla 28 (comparacion)


estado 24

   31 expresionArit: termino .
   32 termino: termino . PRODUCTO termino
   33        | termino . DIVISION termino
   34        | termino . DIVISION_ENTERA termino
   35        | termino . MODULO termino

    MODULO           desplazar e ir al estado 47
    PRODUCTO         desplazar e ir al estado 48
    DIVISION         desplazar e ir al estado 49
    DIVISION_ENTERA  desplazar e ir al estado 50

    MODULO           [reduce usando la regla 31 (expresionArit)]
    PRODUCTO         [reduce usando la regla 31 (expresionArit)]
    DIVISION         [reduce usando la regla 31 (expresionArit)]
    DIVISION_ENTERA  [reduce usando la regla 31 (expresionArit)]
    $default         reduce usando la regla 31 (expresionArit)


estado 25

   36 termino: potencia .
   37 potencia: potencia . EXPONENTE potencia

    EXPONENTE  desplazar e ir al estado 51

    EXPONENTE  [reduce usando la regla 36 (termino)]
    $default   reduce usando la regla 36 (termino)

【问题讨论】：

标签： c compiler-construction bison lex

【解决方案1】：

表达式语法

算术表达式有两种常见的语法编写方式：

1。有优先声明。

在这种情况下，我们指定每个运算符的优先级，从最低优先级开始（通常是+和-）。优先级越高，运算符与其操作数的绑定就越紧密。例如，在3+4*5 中，* 优先于 +，因为表达式被解析为 3+(4*5)。）

在这种情况下，只有一个“表达式”非终结符，我们用那个非终结符编写所有规则：

%left '+' '-'
%left '*' '/' '%'
  /* ... */
%nonassoc '<' "<=" "==" "!=" ">=" '>'
%left "&&"
%left "||"

%%

expression: expression "||" expression
          | expression "&&" expression
          | expression "<=" expression
          | expression '+' expression
          | expression '-' expression
  /* etcetera */
          | NUMBER
          | IDENTIFIER
          | '(' expression ')'

2。显式（无优先声明）

在这种风格中，我们写出规则以使表达式明确。在这种情况下，每个优先级都需要一个单独的非终结符，但我们不需要优先级声明。请注意，每个产生式中的非终结符在上下文中仅明确包含绑定更紧密的运算符。特别是，关联性也被编码，这取决于左侧的相同运算符绑定更紧密，还是右侧的运算符绑定更紧密：

 expr : expr0

 expr0: expr0 '+' expr1  /* Left associative */
      | expr0 '-' expr1
      | expr1            /* There is always a unit rule */
 expr1: expr1 '*' expr2
      | expr1 '/' expr2
      | expr1 '%' expr2
      | expr2
  /* ... */
 expr3: expr4 "**" expr3 /* Right associative */
      | expr4
 expr4: expr5 "<=" expr5 /* Non-associative */
      | expr5 "==" expr5
      | expr5 "!=" expr5
      | expr5 ">=" expr5
      | expr5 '<'  expr5
      | expr5 '>'  expr5
      | expr5
 expr5: expr5 "&&" expr6
      | expr6
 expr6: expr6 "||" expr7
      | expr7
 expr7: '-' expr7   /* Prefix operator */
      | expr8
 expr8: expr8 '[' expr ']' /* Postfix operator */
      | term
 term : NUMBER | IDENTIFIER | '(' expr ')'

所以您可以选择上述任何一种，但您需要选择其中一种。你所拥有的是一种不舒服的混合物，它会让野牛和人类读者感到困惑。

如果语句

在这里，问题要简单得多。您的语法允许使用else 或elseif 选择性地扩展if 语句，但您的优先级声明仅包括else。

【讨论】：

【解决方案2】：

在编写表达式语法时，您应该或者在标记上使用优先级并拥有expression 中的所有规则，或者使用多个规则来表示优先级。你不能真正混合搭配，部分采用一种方式，部分采用另一种方式。在这里，您尝试使用%left/%right 设置左/右关联，并使用多个规则设置优先级。您需要选择其中一个。

要仅使用优先声明，请将所有非终结符 booleano、comparicion 等替换为 expression任何地方。然后删除多余的expression: expression 规则，因为这些是导致冲突的原因。

要使用优先级规则，请将运算符前后非终结符相同的规则更改为使用一侧的下一级非终结符来设置左或右关联性：

expresion: expresion OR booleano  /* left associative */

comparacion: expresionArit PEQUENO expresionArit   /* non-associative */

potencia: factor EXPONENTE potencia    /* right associative */

【讨论】：

如果我已替换为表达式和 rici 所说的话。我完全理解！感谢您的帮助！