How do I represent epsilon when I making the rules inside my Yacc file? - yacc

Question

I am trying to implement a simple C minus parser in lex/yacc. I tested my code with a very simple set of rules and it worked. But now, when I try to add in the actual rules, I am getting this error everywhere that there is an epsilon rule. error: syntax error, unexpected identifier
I have looked up how to represent epsilon in yacc and every where I look says that I can just leave the rule empty. I have even tried putting a comment in the rule because I have seen that as well. But, I suppose the issue could lie somewhere else.
Why is this not working for me?
Below is my .y file and the first error says this (unexpected identifier):
arglist {};
^^^^^^^
void yyerror (char *s);
#include <stdio.h>
#include <stdlib.h>
int yylex();
extern int yytext[];
extern FILE *yyin;
%}
%start program
%token LTE GTE BEQUALS NOTEQUALS BEGCOMMENT ENDCOMMENT COMMENT GREATER LESS COMMA PLUS SUB MULT DIV EQUAL LP RP LB RB LC RC SEMICOLON INT FLOAT VOID IF WHILE RETURN ELSE ID NUM INVALID
%%
program : declarationlist { printf("\nACCEPT\n"); };
declarationlist : declaration declarationlistPrime {};
declaration : typespecifier ID DDD {};
DDD : vardeclarationPrime {};
| LP params RP compoundstmt {};
vardeclaration : typespecifier ID vardeclarationPrime {};
typespecifier : INT {};
| VOID {};
| FLOAT {};
params : paramlist {};
| VOID {};
paramlist : param paramlistPrime {};
param : INT ID paramPrime {};
| VOID ID paramPrime {};
| FLOAT ID paramPrime {};
compoundstmt : LC localdeclarations statementlist RC {};
localdeclarations : localdeclarationsPrime {};
statementlist : statementlistPrime {};
statement : expressionstmt {};
| LC localdeclarations statementlist RC {};
| selectionstmt {};
| iterationstmt {};
| returnstmt {};
expressionstmt : expression SEMICOLON {};
| SEMICOLON {};
selectionstmt : IF LP expression RP statement selectionstmtPrime {};
iterationstmt : WHILE LP expression RP statement {};
returnstmt : RETURN returnstmtPrime {};
expression : ID FFF {};
| LP expression RP termPrime SSS {};
| NUM termPrime SSS {};
FFF : LP args RP termPrime SSS {};
| varPrime XXX {};
XXX : EQUAL expression arglistPrime {};
| termPrime additiveexpressionPrime SSS {};
var : ID varPrime {};
SSS : additiveexpressionPrime arglistPrime {};
| relop additiveexpression arglistPrime {};
relop : LTE {};
| LESS {};
| GREATER {};
| GTE {};
| BEQUALS {};
| NOTEQUALS {};
additiveexpression : term additiveexpressionPrime {};
addop : ADD {};
| SUB {};
term : factor termPrime {};
mulop : MULT {};
| DIV {};
factor : LP expression RP {};
| ID factorXYZ {};
| NUM {};
factorXYZ : varPrime {};
| LP args RP {};
args : /* epsilon */ | {};
arglist {};
arglist : ID CS {};
| LP expression RP termPrime FID {};
| NUM termPrime FID {};
CS : varPrime EEE {};
| LP args RP termPrime FID {};
EEE : EQUAL expression arglistPrime {};
| termPrime FID {};
FID : relop additiveexpression arglistPrime {};
| additiveexpressionPrime arglistPrime {};
vardeclarationPrime : SEMICOLON {};
| LB NUM RB SEMICOLON {};
paramPrime : /* epsilon */ | {};
LB RB {};
selectionstmtPrime : |
ELSE statement {};
returnstmtPrime : SEMICOLON {};
| ID CCC {};
| NUM termPrime BBB {};
| LP expression RP termPrime BBB {};
AAA : EQUAL expression SEMICOLON {};
| termPrime BBB {};
BBB : relop additiveexpression SEMICOLON {};
| additiveexpressionPrime SEMICOLON {};
CCC : varPrime AAA {};
| LP args RP termPrime BBB {};
varPrime : | {};
LB expression RB {};
declarationlistPrime : | {};
declaration declarationlistPrime {};
paramlistPrime : | {};
COMMA param paramlistPrime {};
localdeclarationsPrime : | {};
vardeclaration localdeclarationsPrime {};
statementlistPrime : | {};
statement statementlistPrime {};
additiveexpressionPrime : | {};
addop term additiveexpressionPrime {};
termPrime : | {};
mulop factor termPrime {};
arglistPrime : | {};
COMMA expression arglistPrime {};
%%
int main(int argc, char *argv[])
{
yyin = fopen(argv[1], "r");
if (!yyin)
{
printf("no file\n");
exit(0);
}
yyparse();
}
void yyerror(char *s)
{
printf("\nREJECT\n");
// printf("error from yyerror\n");
exit(0);
}
int yywrap()
{
// printf("in yywarp\n");
exit(0);
}```
Please help, I have tried everything I can think of.

Answer 1

You have
args : /* epsilon */ | {};
Which is two productions for args, both of them empty, and one with an explicit no-op action. That's terminated with a semi-colon, meaning the end of the rules for args. Thus, bison is not expecting another right-hand side. It's expecting rules for some different non-terminal.
What you meant, I suppose, was
args : /* epsilon */
| arglist
;
Note that there is no need to explicitly add an empty action Leaving the action out altogether (as above) is exactly the same, and is arguably less noisy.
Better style with bison is to use the %empty marker instead of a comment, because bison will ensure that a rule with %empty really is empty:
args : %empty
| arglist
;