Yacc only reads the first match of the rule - yacc

Hi I am writing a simple yacc program that takes a program code and counts how many assign statements there are.
For example, for the following code snippet:
void main() {
int a = 3;
int bb = 10;
}
I'd like my yacc to print out that there are 2 assign sentences. Since I am a beginner, I found a sample code from Oreily's book online and modified the code.
yacc.y
%{
2 #include <stdio.h>
3 int assign = 0;
4 %}
5
6 %token NAME NUMBER
7 %start statement
8 %%
9 statement: NAME '=' expression ';' {assign++;}
11 ;
12 | expression { printf("= %d\n", $1); }
13 ;
14 expression: expression '+' NUMBER { $$ = $1 + $3;
15 printf ("Recognized '+' expression.\n");
16 }
17 | expression '-' NUMBER { $$ = $1 - $3;
18 printf ("Recognized '-' expression.\n");
19 }
20 | NUMBER { $$ = $1;
21 printf ("Recognized a number.\n");
22 }
23 ;
24 %%
25 int main (void) {
26 yyparse();
27 printf("assign =%d", assign);
28 }
29
30 /* Added because panther doesn't have liby.a installed. */
31 int yyerror (char *msg) {
32 return fprintf (stderr, "YACC: %s\n", msg);
33 }
lex.l
1 %{
2 #include "y.tab.h"
3 extern int yylval;
4 %}
5
6 %%
7 [0-9]+ { yylval = atoi (yytext);
8 printf ("scanned the number %d\n", yylval);
9 return NUMBER; }
10 [ \t] { printf ("skipped whitespace\n"); }
11 \n { printf ("reached end of line\n");
12 return 0;
13 }
14 [a-zA-Z]+ {printf("found name"); return NAME;}
15 . { printf ("found other data \"%s\"\n", yytext);
16 return yytext[0];
17 /* so yacc can see things like '+', '-', and '=' */
18 }
19 %%
20 int yywrap(){
21 return 1;
22 }
~
test.txt
a = 3;
3+2;
b = 3;
When I build the code, I get a.out. When I run ./a.out < test.txt, the output shows that the there is one assign. IT seems like it only recognized the first sentence.
How do I make it so that the program keeps looking for the matches after the first match?
Also, why is there semi-colon in line 11 and 13 in yacc.y? Since it's all connected by '|', I don't understand why ; is placed there.

Your grammar only parses one statement. Make the following changes:
%start statements
statements
: statement
| statements statement
;
etc. as before.

It's very important knowing how to debug your program. In first part of the file you need to add #define YYDEBUG 1, and in main function yydebug = 1. This will allow you to see exact steps when you run your parser and then you'll know where your error is. Knowing this is extremely important, because mistakes in Yacc are usually very hard to find. So debug your program!
%{
#define YYDEBUG 1 // This is new
%}
int main(){
yydebug = 1; // This is new
yyparse();
}
Semicolon on line 11 is wrong. Yacc rules look like this:
Nonterminal : something here
| something else here
| ... etc.
...
;

Related

How to fix implicit declaration of function 'yyerror' problem

Hi I am making a program that does simple arithmetic operations using Lex and yacc, but I am having a problem with a specific error.
ex1.y
%{
#include <stdio.h>
int sym[26];
%}
%token INTEGER VARIABLE
%left '+' '-'
%left '*' '/' '%'
%%
program:
program statement '\n'
|
;
statement:
expr {printf("%d\n", $1);}
| VARIABLE '=' expr {sym[$1] = $3;}
;
expr:
INTEGER
| VARIABLE { $$ = sym[$1];}
| expr '+' expr { $$ = $1 + $3;}
| expr '-' expr { $$ = $1 - $3;}
| expr '*' expr { $$ = $1 * $3;}
| expr '/' expr { $$ = $1 / $3;}
| '(' expr ')' { $$ = $2;}
;
%%
main() { return yyparse();}
int yyerror(char *s){
fprintf(stderr,"%s\n",s);
return 0;
}
ex1.l
%{
#include <stdlib.h>
#include "y.tab.h"
%}
%%
/* variables */
[a-z] {
yylval = *yytext -'a';
return VARIABLE;
}
/* integers */
[0-9]+ {
yylval = atoi(yytext);
return INTEGER;
}
/* operators */
[-+()=/*\n] { return *yytext;}
/* skip whitespace */
[ \t] ;
/* anything else is an error */
. yyerror("invalid character");
%%
int yywrap (void){
return 1;
}
when I execute bellow instruction
$bison –d -y ex1.y
$lex ex1.l
$gcc lex.yy.c y.tab.c –o ex1
The following error occurs:
ex1.l: In function ‘yylex’:
ex1.l:28:1: warning: implicit declaration of function ‘yyerror’; did you mean ‘perror’? [-Wimplicit-function-declaration]
28 |
| ^
| perror
y.tab.c: In function ‘yyparse’:
y.tab.c:1227:16: warning: implicit declaration of function ‘yylex’ [-Wimplicit-function-declaration]
1227 | yychar = yylex ();
| ^~~~~
y.tab.c:1402:7: warning: implicit declaration of function ‘yyerror’; did you mean ‘yyerrok’? [-Wimplicit-function-declaration]
1402 | yyerror (YY_("syntax error"));
| ^~~~~~~
| yyerrok
I don't know what is wrong with my code. I would appreciate it if you could tell me how to fix the above error.
The version of bison you are using requires you to declare prototypes for yylex() and yyerror. These should go right after the #include <stdio.h> at the top of the file:
int yylex(void);
int yyerror(char* s);
I would use int yyerror(const char* s) as the prototype for yyerror, because it is more accurate, but if you do that you'll have to make the same change in the definition.
You use yyerror in your lex file, so you will have to add its declaration in that file as well.
main() hasn't been a valid prototype any time this century. Return types are required in function declarations, including main(). So I guess you are basing your code on a very old template. There are better starting points in the examples in the bison manual.
(And don't expect it to be easy to work with parser generators if you have no experience with C.)

how to fix integer out of range error :$3 error in YACC

I am developing a calculator using YACC and I receive this error :
Integer out of rang $3;
I have just now started learning yacc and can't rectify the error I can see the question already but no one has answered
%token NUMBER
%%
expr :expr '+'{$$ = $1 + $3;}
%%
#include<stdio.h>
#include "lex.yy.c"
yylex()
{
int c;
c=getchar();
if(isdigit(c))
{
yylval=c-'0';
return NUMBER;
}
return c;
}
int main()
{
yyparse();
return 1;
}
int yyerror(){
return 1;}
$3 refers to the 3rd term on the right side of the rule. In
expr :expr '+'{$$ = $1 + $3;}
there are only 2 terms on the right side of the production...

How to Read Multiple Lines of input file for arithmetic yacc program?

I am new to compilers and learning to make calculator that inputs multiple line equations (one equation each line) from a .txt file. And I am facing the problem of segmentation fault.
YACC Code :
%{
#include <stdio.h>
#include <string.h>
#define YYSTYPE int /* the attribute type for Yacc's stack */
extern int yylval; /* defined by lex, holds attrib of cur token */
extern char yytext[]; /* defined by lex and holds most recent token */
extern FILE * yyin; /* defined by lex; lex reads from this file */
%}
%token NUM
%%
Begin : Line
| Begin Line
;
Line : Calc {printf("%s",$$); }
;
Calc : Expr {printf("Result = %d\n",$1);}
Expr : Fact '+' Expr { $$ = $1 + $3; }
| Fact '-' Expr { $$ = $1 - $3; }
| Fact '*' Expr { $$ = $1 * $3; }
| Fact '/' Expr { $$ = $1 / $3; }
| Fact { $$ = $1; }
| '-' Expr { $$ = -$2; }
;
Fact : '(' Expr ')' { $$ = $2; }
| Id { $$ = $1; }
;
Id : NUM { $$ = yylval; }
;
%%
void yyerror(char *mesg); /* this one is required by YACC */
main(int argc, char* *argv){
char ch;
if(argc != 2) {printf("useage: calc filename \n"); exit(1);}
if( !(yyin = fopen(argv[1],"r")) ){
printf("cannot open file\n");exit(1);
}
yyparse();
}
void yyerror(char *mesg){
printf("Bad Expression : %s\n", mesg);
exit(1); /* stop after the first error */
}
LEX Code :
%{
#include <stdio.h>
#include "y.tab.h"
int yylval; /*declared extern by yacc code. used to pass info to yacc*/
%}
letter [A-Za-z]
digit [0-9]
num ({digit})*
op "+"|"*"|"("|")"|"/"|"-"
ws [ \t\n]
other .
%%
{ws} { /* note, no return */ }
{num} { yylval = atoi(yytext); return NUM;}
{op} { return yytext[0];}
{other} { printf("bad%cbad%d\n",*yytext,*yytext); return '?'; }
%%
/* c functions called in the matching section could go here */
I am trying to print the expression along with result.
Thanks In Advance.
In your parser, you have:
Line : Calc {printf("%s",$$); }
Now $$ is the semantic value which the rule is computing, and you haven't assigned anything to it. So it would not be unreasonable to assume that it is undefined, which would be bad, but in fact it does have a value because of the default rule $$ = $1;. All the same, it would be much more readable to write
printf("%s", $1);
But that's not correct, is it? After all, you have
#define YYSTYPE int
so all semantic types are integers. But you're telling printf that $1 is a string (%s). printf will believe you, so it will go ahead and try to dereference the int as though it were a char*, with predictable results (i.e., a segfault).
You are probably using a compiler which is clever enough to notice the fact that you are trying to print an int with a %s format code. But either you haven't asked the compiler to help you or you are ignoring its advice.
Always compile with warnings enabled. If you are using gcc or clang, that means putting -Wall in the command line. (If you are using some other compiler, find out how to produce warnings. It will be documented.) And then read the warnings and fix them before trying to run the program.
There are several other errors and/or questionable practices in your code. Your grammar is inaccurate (why do you use fact as the left-hand operand of every operator?), and despite your comment, your lexical scanner ignores newline characters, so there is no way the parser can know whether expressions are one per line, two per line, or spread over multiple lines; that will make it hard to use the calculator as a command-line tool.
There is no need to define the lex macro digit; (f)lex recognizes the Posix character class [[:digit:]] (and others, documented here) automatically. Nor is it particularly useful to define the macro num. Overuse of lex macros makes your program harder to read; it is usually better to just write the patterns out in place:
[[:digit:]]+ { yylval = atoi(yytext); return NUM; }
which would be more readable and less work both for you and for anyone reading your code. (If your professor or tutor disagrees, I'd be happy to discuss the matter with them directly.)

how to check values while using recursion in yacc?

I am using recursion in yacc and I want to check all the values that are parsed by the recursion rule.My yacc rule is
%{
#include<stdio.h>
.
.
.
%}
%%
abc:ABC expr
;
expr:VALUE','expr
|VALUE
;
%%
if i have a statement like
ABC 1,2,3,4
it gets parsed.
i want to check that all the numbers parsed via expr
have sum equal to some value say 10
how can i check this?
Edit:
You can count the values parsed and keep their running total with code that goes something like this:
%{
#include<stdio.h>
int count;
.
.
.
%}
%%
abc: { count = 0; } ABC expr { printf("count: %d; sum: %d\n", count, $2); }
;
expr: VALUE ',' expr { $$ = $1 + $3; }
| VALUE { $$ = $1; count++; }
;
%%

Why am I getting conflicts: 1 shift/reduce

I'm new to bison and I'm getting a "conflicts: 1 shift/reduce" error. Can anyone shed some light on this?
Here's the y file.
test.y:
%{
#include <stdio.h>
#include <string.h>
#define YYERROR_VERBOSE
#define YYDEBUG 1
void yyerror(const char *str);
int yywrap();
%}
%union
{
int integer;
char *string;
}
%token <string> VAR_LOCAL
%token <integer> LIT_NUMBER
%token <string> LIT_STRING
%token WS_LINEBRK
//%token SYMB_EQL
%token SYMB_PLUS
%token SYMB_MINUS
%token SYMB_MUL
%token SYMB_DIV
%%
/*
// Sample input
num = 10
str = "this is a string"
*/
inputs: /* empty token */
| literal
| variable
| inputs stmt WS_LINEBRK
;
stmt: variable "=" exps
;
exps: variable op literal
| variable op variable
| literal op literal
| literal op variable
;
op: SYMB_PLUS | SYMB_MINUS | SYMB_MUL | SYMB_DIV ;
variable: VAR_LOCAL
{
printf("variable: %s\n", $1);
}
;
literal:
number | string
;
string: LIT_STRING
{
printf("word: %s\n", $1);
}
;
number: LIT_NUMBER
{
printf("number: %d\n", $1);
}
;
%%
void yyerror(const char *str)
{
fprintf(stderr,"error: %s\n",str);
}
int yywrap()
{
return 1;
}
main()
{
yyparse();
}
Here's the lex file
test.l:
%{
#include <stdio.h>
#include <stdlib.h>
#include "y.tab.h"
int line_no = 0;
%}
%%
[a-z][a-zA-Z0-9]* {
// local variable
yylval.string=strdup(yytext);
return VAR_LOCAL;
}
[0-9]+ {
//number literal
yylval.integer=atoi(yytext);
return LIT_NUMBER;
}
= return SYMB_EQL;
\+ return SYMB_PLUS;
\- return SYMB_MINUS;
\* return SYMB_MUL;
\/ return SYMB_DIV;
\"[-+\!\.a-zA-Z0-9' ]+\" {
// word literal
yylval.string=strdup(yytext);
return LIT_STRING;
}
\n {
// line break
printf("\n");
return WS_LINEBRK;
}
[ \t]+ /* ignore whitespace */;
%%
bison -r test.y will write a file test.output with a detailed description of the generated state machine that allows you to see what's going on - such as the state where the shift/reduce conflict occurs.
In your case, the problem is in the start state (corresponding to your start nonterminal, inputs). Say the first token is VAR_LOCAL. There's two things your parser could do:
It could match the variable case.
It could also match the inputs stmt WS_LINEBRK case: inputs matches the empty string (first line), and stmt matches variable "=" exps.
With the one token of lookahead that bison parsers use, there's no way to tell. You need to change your grammar to get rid of this case.
To fix the grammar, as Fabian has suggested, move the variable and literal to the end of exps from inputs
inputs:
| variable
| literal
exps:
...
| variable
| literal
That allows x= y,x="aliteral" syntax.
To allow for empty input lines, change the /* empty token */ rule to WS_LINEBREAK:
inputs: WS_LINEBRK
| stmt WS_LINEBRK
| inputs stmt WS_LINEBRK
;
On another note, since the scanner still looks for the SYMB_ EQUAL ; but the parser no longer defines it (its commented out), something needs to be done in order to compile. One option is to uncomment the %token definition and use SYMB_ EQUAL instead of the literal "=" in the parser .y file.