Question

我正在尝试使用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)

Answer 1

表达式语法

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

1。使用优先级声明。

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

在这种情况下，只有一个＆＃34;表达式＆＃34;非终端，我们用单个非终端编写所有规则：

%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 ')'

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

如果陈述

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

Answer 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 */

野牛的冲突

2 个答案:

表达式语法

1。使用优先级声明。

2。显式（无优先级声明）

如果陈述