YACC rules do not decrease

This is my calc.y code. I keep getting error: yacc: 1 rule never decreased yacc: 3 reduce / reduce conflicts

not sure what that means

I have done some research elsewhere, but now I am lost. I assume these rules are program and statement specific, but even so ... what does the abbreviation rule mean?

%{
  #include <stdio.h>
  FILE *outfile;
  int yyline = 1;
  int yycolumn = 1;
%}

%union{
  int nw;
  struct{
    int v;
    char s[1000];
  }attr;
}

%token   SEMInumber
%token   LPARENnumber
%token   <nw> ICONSTnumber
%token   BEGINnumber
%token   PROGRAMnumber
%token   MINUSnumber
%token   TIMESnumber
%token   <nw> VARnumber
%token   INTnumber
%token   EOFnumber
%token   COMMAnumber
%token   RPARENnumber
%token   <nw>IDnumber
%token   ENDnumber
%token   ISnumber
%token   PLUSnumber
%token   DIVnumber
%token   PRINTnumber
%token   EQnumber

%type <attr> exp
%type <attr> term
%type <attr> factor
%%


program: PROGRAMnumber IDnumber ISnumber compstate
         ;

compstate: BEGINnumber {print_header();} statement ENDnumber{print_end();}
           | BEGINnumber {print_header();} statement SEMInumber statement ENDnumber{print_end();}
           ;

statement: IDnumber EQnumber exp
           | PRINTnumber exp
 | declaration
           ;

declaration: VARnumber IDnumber
             | VARnumber IDnumber COMMAnumber IDnumber
             ;

exp: term {$$.v = $1.v; strcpy($$.s, $1.s);}
     | exp PLUSnumber term {$$.v = $1.v + $3.v; sprintf($$.s, "(%s) + (%s)", $1. s, $3.s);}
     | exp MINUSnumber term {$$.v = $1.v - $3.v; sprintf($$.s, "(%s) - (%s)", $1. s, $3.s);}
     ;

term: factor {$$.v = $1.v; strcpy($$.s, $1.s);}
      | term TIMESnumber factor {$$.v = $1.v * $3.v; sprintf($$.s, "(%s) * (%s)", $1.s, $3.s);}
      | term DIVnumber factor {$$.v = $1.v / $3.v; sprintf($$.s, "(%s) / (%s)", $1.s, $3.s);}
      ;

 factor: ICONSTnumber {$$.v = $1; sprintf($$.s, "%d", $1);}
          | IDnumber {$$.v = $1.v; strcpy($$.s,  $1.s);}
          | LPARENnumber exp RPARENnumber {$$.v = $2.v; strcpy($$.s,  $2.s);}
;


%%


int main()
{
  if(!yyparse())
    {
      printf("accept\n");
    }
  else
    printf("reject\n");
}

void print_header() {}
void print_end(){}

void yyerror(const char *str)
{
  printf("yyerror: %s at line %d\n", str, yyline);
}

      

0


source to share


2 answers


When compstate shifts the BEGINnumber token, the two internal rules for the middle rule {print_header();}

can be reduced, resulting in an R / R conflict. You can replace

compstate: BEGINnumber {print_header();} statement ENDnumber{print_end();}
           | BEGINnumber {print_header();} statement SEMInumber statement 
ENDnumber{print_end();}
           ;

      

with for example



begin_number:
    BEGINnumber { print_header(); }

compstate: begin_number statement ENDnumber{print_end();}
           | begin_number statement SEMInumber statement 
ENDnumber{print_end();}
           ;

      

to resolve the conflict.

+2


source


Info messages% s:% d
rules never declined Some rules are never used because they were not used in grammar or because they were on the losing side of changing / reducing or reducing / reducing conflicts. Either change the grammar to use the rules or remove them.



-1


source







All Articles