Home work for modifying the syntactic analyzer for the attached comp.docx

Home work for modifying the syntactic analyzer for the
attached compiler by adding to the existing grammar. The full
grammar of the language is shown below. The highlighted
portions of the grammar show what you must either modify or
add to the existing grammar.
function:
function_header {variable} body
function_header:
FUNCTION IDENTIFIER [parameters] RETURNS type ;
variable:
IDENTIFIER : type IS statement
parameters:
parameter {, parameter}
parameter:
IDENTIFIER : type
type:
INTEGER | REAL | BOOLEAN
body:
BEGIN statement END ;
statement: expression ; |

REDUCE operator {statement} ENDREDUCE ; |
IF expression THEN statement ELSE statement ENDIF ; |
CASE expression IS {case} OTHERS ARROW statement ;
ENDCASE ;
operator:
ADDOP | MULOP
case:
WHEN INT_LITERAL ARROW statement
expression:
( expression ) |
REAL_LITERAL
NOT expression
expression binary_operator expression |
|
INT_LITERAL | IDENTIFIER
| BOOL_LITERAL |
binary_operator: ADDOP | MULOP | REMOP | EXPOP | RELOP
| ANDOP | OROP
In the above grammar, the red symbols are nonterminals, the

blue symbols are terminals and the black punctuation are EBNF
metasymbols. The braces denote repetition 0 or more times and
the brackets denote optional.
You must rewrite the grammar to eliminate the EBNF brace and
bracket metasymbols and to incorporate the significance of
parentheses, operator precedence and associativity for all
operators. Among arithmetic operators the exponentiation
operator has highest precedence following by the multiplying
operators and then the adding operators. All relational operators
have the same precedence. Among the binary logical operators,
and has higher precedence than or. Of the categories of
operators, the unary logical operator has highest precedence, the
arithmetic operators have next highest precedence, followed by
the relational operators and finally the binary logical operators.
All operators except the exponentiation operator are left
associative. The directives to specify precedence and
associativity, such as %prec and %left, may not be used
Your parser should be able to correctly parse any syntactically
correct program without any problem.
You must modify the syntactic analyzer to detect and recover
from additional syntax errors using the semicolon as the
synchronization token. To accomplish detecting additional
errors an error production must be added to the function header
and another to the variable declaration.
Your bison input file should not produce any shift/reduce or
reduce/reduce errors. Eliminating them can be difficult so the
best strategy is not introduce any. That is best achieved by
making small incremental additions to the grammar and
ensuring that no addition introduces any such errors.
An example of compilation listing output containing syntax
errors is shown below:

1 -- Multiple errors 2
function main a integer returns real; Syntax Error, Unexpected
INTEGER, expecting ':'
b: integer is * 2; Syntax Error, Unexpected MULOP
c: real is 6.0;
begin
if a > c then 8 b 3.0;
Syntax Error, Unexpected REAL_LITERAL, expecting ';'
9 else
10 b = 4.;
11 endif;
12 ;
Syntax Error, Unexpected ';', expecting END
Lexical Errors 0
Syntax Errors 4
Semantic Errors 0
------------------------------------------------------------

listing.h
// This file contains the function prototypes for the functions
that produce the // compilation listing
enum ErrorCategories {LEXICAL, SYNTAX,
GENERAL_SEMANTIC, DUPLICATE_IDENTIFIER,
UNDECLARED};
void firstLine();
void nextLine();
int lastLine();
void appendError(ErrorCategories errorCategory, string
message);
---------------------------------------------------------------------------
-------
makefile
compile: scanner.o parser.o listing.o
g++ -o compile scanner.o parser.o listing.o
scanner.o: scanner.c listing.h tokens.h
g++ -c scanner.c
scanner.c: scanner.l
flex scanner.l

mv lex.yy.c scanner.c
parser.o: parser.c listing.h
g++ -c parser.c
parser.c tokens.h: parser.y
bison -d -v parser.y
mv parser.tab.c parser.c
mv parser.tab.h tokens.h
listing.o: listing.cc listing.h
g++ -c listing.cc
----------------------------------------------------------
parser.y
%{
#include
using namespace std;
#include "listing.h"
int yylex();
void yyerror(const char* message);
%}

%error-verbose
%token IDENTIFIER
%token INT_LITERAL
%token ADDOP MULOP RELOP ANDOP
%token BEGIN_ BOOLEAN END ENDREDUCE FUNCTION
INTEGER IS REDUCE RETURNS
%%
function:
function_header optional_variable body ;
function_header:
FUNCTION IDENTIFIER RETURNS type ';' ;
optional_variable:
variable |
;
variable:
IDENTIFIER ':' type IS statement_ ;
type:
INTEGER |

BOOLEAN ;
body:
BEGIN_ statement_ END ';' ;
statement_:
statement ';' |
error ';' ;
statement:
expression |
REDUCE operator reductions ENDREDUCE ;
operator:
ADDOP |
MULOP ;
reductions:
reductions statement_ |
;
expression:

{
appendError(SYNTAX, message);
}
int main(int argc, char *argv[])
{
firstLine();
yyparse();
lastLine();
return 0;
}
------------------------------------------------------------------------
scanner
/* Compiler Theory and Design
Dr. Duane J. Jarc */
/* This file contains flex input file */
%{
#include
#include

#include "tokens.h"
%}
%option noyywrap
ws [ tr]+
comment --.*n
line [n]
id [A-Za-z][A-Za-z0-9]*
digit [0-9]
int {digit}+
punc [(),:;]
%%
{ws} { ECHO; }
{comment} { ECHO; nextLine();}
{line} { ECHO; nextLine();}
"<" { ECHO; return(RELOP); }
"+" { ECHO; return(ADDOP); }

"*" { ECHO; return(MULOP); }
begin { ECHO; return(BEGIN_); }
boolean { ECHO; return(BOOLEAN); }
end { ECHO; return(END); }
endreduce { ECHO; return(ENDREDUCE); }
function { ECHO; return(FUNCTION); }
integer { ECHO; return(INTEGER); }
is { ECHO; return(IS); }
reduce { ECHO; return REDUCE; }
returns { ECHO; return(RETURNS); }
and { ECHO; return(ANDOP); }
{id} { ECHO; return(IDENTIFIER);}
{int} { ECHO; return(INT_LITERAL); }
{punc} { ECHO; return(yytext[0]); }
. { ECHO; appendError(LEXICAL, yytext); }
%%
----------------------------------------------------------------
listing.cc

// Compiler Theory and Design
// Dr. Duane J. Jarc
// This file contains the bodies of the functions that produces
the compilation
// listing
#include
#include
static int lineNumber;
static string error = "";
static int totalErrors = 0;
static void displayErrors();
void firstLine()
{
lineNumber = 1;
printf("n%4d ",lineNumber);
}
void nextLine()

{
displayErrors();
lineNumber++;
printf("%4d ",lineNumber);
}
int lastLine()
{
printf("r");
displayErrors();
printf(" n");
return totalErrors;
}
void appendError(ErrorCategories errorCategory, string
message)
{
string messages[] = { "Lexical Error, Invalid Character ", "",
"Semantic Error, ", "Semantic Error, Duplicate Identifier:
",

"Semantic Error, Undeclared " };
error = messages[errorCategory] + message;
totalErrors++;
}
void displayErrors()
{
if (error != "")
printf("%sn", error.c_str());
error = "";
}
----------------------------------------------------------

Home work for modifying the syntactic analyzer for the attached comp.docx

More Related Content

What's hot (20)

Similar to Home work for modifying the syntactic analyzer for the attached comp.docx (20)

More from simonithomas47935 (20)

Recently uploaded (20)

Home work for modifying the syntactic analyzer for the attached comp.docx