Error while compiling Concurrent YACC program - c

Question

I am trying to build implement a basic calculator using Concurrent YACC. I have tried the code by statically creating the threads. But whe I want to dynamically specify how many threads to be created, the parser seems to have a problem. Here are the contents of my code.
aa.y file
%{
#include <stdio.h>
#include <pthread.h>
#include <string.h>
void * scanner;
FILE *yyin;
#define YYSTYPE int
%}
%token digit
%lex-param {void * scanner}
%parse-param {void * scanner}
%start list
%token NUMBER
%left '+' '-'
%left '*' '/' '%'
%left UMINUS
%union {int i;}
%%
list:
|
list stat '\n'
|
list error '\n'{ yyerrok; }
;
stat: expr { printf("Thread = %d ... Ans = %d\n",pthread_self(),$1);}
;
expr: '(' expr ')'{ $$ = $2; }
|
expr '*' expr { $$ = $1 * $3; }
|
expr '/' expr { $$ = $1 / $3; }
|
expr '+' expr { $$ = $1 + $3; }
|
expr '-' expr { $$ = $1 - $3; }
|
'-' expr %prec UMINUS { $$ = -$2; }
|
NUMBER
;
%%
struct struct_arg
{
unsigned char* file;
};
int yyerror()
{
return 1;
}
void *parse(void *arguments)
{
struct struct_arg *args = (struct struct_arg *)arguments;
unsigned char* filename;
filename = args -> file;
yyin = fopen(filename,"r+");
if(yyin == NULL)
{
}
else
{
yylex_init(&scanner);
yyset_in(yyin,scanner);
yyparse(scanner);
yylex_destroy(scanner);
printf("Thread = %d\n",pthread_self());
}
fclose(yyin);
}
int main(int argc, char *argv[])
{
int num;
printf("How many threads you want to create??\n");
scanf("%d", &num);
int error, count = 0;
FILE *fp[num], *file_pointer;
char line[256];
size_t len = 0;
char read;
file_pointer = fopen("test.txt", "r");
while (fgets(line, sizeof(line), file_pointer))
{
char file_name[32] = "test_";
char dummy[4];
char dummy2[5] = ".txt";
sprintf(dummy, "%d", count);
strcat(file_name, dummy);
strcat(file_name, dummy2);
fp[count] = fopen(file_name, "a");
fprintf(fp[count], "%s", line);
fclose(fp[count]);
count++;
if(count == num)
{
count = 0;
}
}
struct struct_arg arguments[num];
int i = 0;
while(i < num)
{
char file_name[32] = "test_";
char dummy[4];
char dummy2[5] = ".txt";
sprintf(dummy, "%d", i);
strcat(file_name, dummy);
strcat(file_name, dummy2);
arguments[i].file = file_name;
i++;
}
pthread_t tid[num];
int j = 0;
while(j < num)
{
error = pthread_create(&(tid[j]), NULL, &parse, (void *) &arguments[j]);
j++;
}
int n = 0;
while(n < num)
{
pthread_join(tid[n], NULL);
n++;
}
int temp, k = 0;
while(k < num)
{
char file_name[32] = "test_";
char dummy[4];
char dummy2[5] = ".txt";
sprintf(dummy, "%d", k);
strcat(file_name, dummy);
strcat(file_name, dummy2);
temp = remove(file_name);
k++;
}
return 0;
}
aa.l
%{
#include <stdio.h>
#include "y.tab.h"
extern int scanner;
%}
%option reentrant
%option noyywrap
NUMBER [0-9]+
%%
" " ;
{NUMBER} {
yylval->i = atoi(yytext);
return(NUMBER);
}
[^0-9\b] {
return(yytext[0]);
}
My compiling steps are
yacc -d aa.y
lex aa.l
cc lex.yy.c y.tab.c -o aa.exe -pthread
And the error generated is
aa.l: In function 'yylex':
aa.l:13:23: error: invalid type argument of '->' (have 'YYSTYPE')
yylval->i = atoi(yytext);
Can anyone please point out what I am doing wrong??

Answer 1

That's a simple compiler error, which is (indirectly) the result of your not requesting a reentrant ("pure") bison parser. [Note 1]
Since the parser is not reentrant, it uses a global yylval which is of type YYSTYPE. Your %union declaration will create a declaration of YYSTYPE as a union type which will be placed in the generated header file y.tab.h, which effectively looks something like this (leaving out some unimportant details):
#ifndef YYSTYPE
typedef union yystype {
int i;
} YYSTYPE;
extern YYSTYPE yylval;
#endif
That code will also be placed into y.tab.c, but it will go after the inserted C segment from the %{...} section of your bison definition. There you #define YYSTYPE int, with the result that in y.tab.c yylval has type int, whereas in `yy.lex.c, it is a union type. That's undefined behaviour (UB), which is how you say "wrong wrong wrong" in C. (But UB is really undefined; one possibility is that the error is silently ignored.)
Since yylval is an instance of YYSTYPE, rather than a pointer to a YYSTYPE, the correct way of referring to member i is yylval.i, not yylval->i. Hence the compiler error.
In your bison file, you don't declare any of your nonterminals to have a type. Since you're including a %union declaration, bison requires you to tell it the type of any terminal or non-terminal whose semantic value is used (with $1, $2, etc.) or assigned to (with $$). So you should have received a pile of errors when you attempted to pass the file through bison. On the other hand, if you had declared types, then the bison-generated parser would have contained references to yylval.i, and that would also generated compiler errors because your #define YYSTYPE effectively bypassed the union declaration. (Bison doesn't know about the #define because it doesn't parse included C code. So it can't generate an error message. But it's definitely an error.)
If you had told bison to produce a re-entrant parser, then the generated parser would have called yylex with an additional argument of type YYSTYPE*; had you also supplied %option bison-bridge in the flex definition, then flex would have generated a declaration of yylex with an additional parameter of type YYSTYPE* which will become the value of yylval. In that case, yylval will be a pointer, rather than an instance, and yylval->i would have been correct.
Notes
For some reason, the use of reentrant bison parsers is referred to incorrectly as "Concurrent YACC". That's wrong on two counts: first, the generated parser is not concurrent (although because it is reentrant, it can be used concurrently if the actions don't introduce race conditions), and secondly because the feature is not available in YACC; it's a bison extension.
A quick Google search revealed two uses of the phrase "Concurrent YACC". One of them was in a comment in an entry in ESR's blog, describing a tool he wrote some decades ago, before bison existed, to make yacc parsers reentrant. The other one was a third-year programming assignment in a course on concurrent programming offered by the University of Pune, which uses the phrase "Concurrent YACC" as though it were meaningful.
I'm guessing that this question derives from the second of those, which might imply that the coursework includes an explanation of what is meant. But for what it's worth, ESR does outline the steps involved in correctly bridging a reentrant bison parser to a reentrant flex lexer. So I suggest you take a look at it, although I do not endorse ESR's description of %bison-bridge as buggy. (Had he said "badly-documented kludge", I would have been 100% on-side.)