Is there a better way to specify optional elements in rules of a CFG? - grammar

Question

Consider a language and a compiler to design and develop for it.
In this language there is a particular statement that is part of the grammar: (=<identifier>). This piece can be recognized by the compiler. But spaces are allowed between the brackets and the equal sign and the identifier. So I have these possibilities:
(=<identifier>)
( = <identifier> )
(=identifier )
( =identifier )
...
Without considering the whole grammar but just the rules to handle this language feature, I have something like this (in a Bison-like syntax for grammar rules):
statement: OBRCKT EQ ID CBRCKT
| OBRCKT S EQ S ID S CBRCKT
| OBRCKT S EQ ID S CBRCKT
| OBRCKT S EQ S ID CBRCKT
| OBRCKT S EQ ID CBRCKT
| OBRCKT EQ S ID S CBRCKT
| OBRCKT EQ ID S CBRCKT
| OBRCKT EQ S ID CBRCKT
| ...
The space terminal S can appear or not. But the way rules are, I need to specify all possible combinations... Is there a better way to achieve this result?

Answer 1

As Jim commented, use your lexical tool to handle these cases instead of writing them into the productions of your grammar.
For example, I commonly use Flex for lexical analysis and Bison to define my grammar (probably as you have done).
You can achieve the result that you want with something like the following (this is just an example so it's pretty simple and cannot do much):
lexicalAnalyzer.l
/* lexicalAnalyzer.l
Specifications of tokens for some language.
*/
%{
%}
/*
* Definitions of regular expressions
* Note: You capture whitespace here...
*/
WSPACE [ \t\r]+ //We take care of the spaces here...
/*
* Tokens
*/
%%
"=" {
printf("TOKEN: EQ LEXEME: %s\n", yytext);
return T_EQ;
}
"(" {
printf("TOKEN: OBRCKT LEXEME: %s\n", yytext);
return T_OBRCKT;
}
")" {
printf("TOKEN: CBRCKT LEXEME: %s\n", yytext);
return T_CBRCKT;
}
"<" {
printf("TOKEN: LT LEXEME: %s\n", yytext);
return T_LT;
}
">" {
printf("TOKEN: GT LEXEME: %s\n", yytext);
return T_GT;
}
"identifier" {
printf("TOKEN: IDENT LEXEME: %s\n", yytext);
return T_IDENT;
}
{WSPACE} { }
. {
printf("TOKEN: UNKNOWN LEXEME: %s\n", yytext);
return T_UNKNOWN;
}
%%
syntaxAnalyzer.y
/*
syntaxAnalyzer.y
To create syntax analyzer:
flex file.l
bison file.y
g++ file.tab.c -o file_parser
file_parser < inputFileName
*/
/*
* Declaration section.
*/
%{
#include <stdio.h>
void printRule(const char *lhs, const char *rhs);
int yyerror(const char *s) {
printf("Error!");
}
extern "C" {
int yyparse(void);
int yylex(void);
int yywrap() {return 1;}
}
%}
/*
* Token declarations
*/
%token T_OBRCKT T_CBRCKT
%token T_LT T_GT T_EQ
%token T_IDENT T_UNKNOWN
/*
* Starting point.
*/
%start N_START
/*
* Translation rules.
*/
%%
N_START : N_STATEMENT
{
printRule("START", "STATEMENT");
printf("\n---- Completed parsing ----\n\n");
return 0;
}
;
N_STATEMENT : T_OBRCKT T_EQ T_LT T_IDENT T_GT T_CBRCKT
{
printRule("EXPR", "T_OBRCKT T_EQ T_LT T_IDENT T_GT T_CBRCKT");
}
;
%%
#include "lex.yy.c"
extern FILE *yyin;
void printRule(const char *lhs, const char *rhs) {
printf("%s -> %s\n", lhs, rhs);
return;
}
int main() {
do {
yyparse();
} while (!feof(yyin));
return 0;
}