Compiler Theory

parser.y

/* CMSC 430 Compiler Theory and Design Project 3 UMGC CITE Project 3 Parser with semantic actions for the interpreter */ %{ #include <iostream> #include <cmath> #include <string> #include <vector> #include <map> using namespace std; #include "values.h" #include "listing.h" #include "symbols.h" int yylex(); void yyerror(const char* message); double extract_element(CharPtr list_name, double subscript); Symbols<double> scalars; Symbols<vector<double>*> lists; double result; double* param_values; int param_index; %} %define parse.error verbose %union { CharPtr iden; Operators oper; double value; vector<double>* list; } %left ADDOP %left MULOP %right EXPOP %left ANDOP %left OROP %left RELOP %nonassoc NOTOP %token <iden> IDENTIFIER %token <value> INT_LITERAL CHAR_LITERAL REAL_LITERAL HEX_LITERAL %token <oper> ADDOP MULOP ANDOP RELOP ARROW OROP MODOP EXPOP NOTOP NEGOP SUBOP DIVOP %token BEGIN_ CASE CHARACTER IF ELSE END ENDSWITCH FUNCTION INTEGER IS LIST OF OTHERS RETURNS SWITCH WHEN ELSIF THEN ENDIF FOLD ENDFOLD LEFT RIGHT REAL %type <value> function function_header type optional_variable variables variable body statement_ statement cases case condition relation expression term factor unary primary optional_parameters parameters parameter elsif_statements else_statement direction operator others_case %type <list> list expressions list_choice %% function: function_header optional_variable body ';' {result = $3;}; function_header: FUNCTION IDENTIFIER optional_parameters RETURNS type ';' { param_index = 0; } | FUNCTION error ';' { $$ = 0; }; optional_parameters: %empty { $$ = 0; } | parameters; parameters: parameters ',' parameter { $$ = 0; } | parameter { $$ = 0; }; parameter: IDENTIFIER ':' type { scalars.insert($1, param_values[param_index++]); }; type: INTEGER { $$ = 0; } | REAL { $$ = 0; } | CHARACTER { $$ = 0; }; optional_variable: variables { $$ = 0; } | %empty { $$ = 0; }; variables: variables variable { $$ = 0; } | variable { $$ = 0; } | error ';' { $$ = 0; }; variable: IDENTIFIER ':' type IS statement ';' { scalars.insert($1, $5); $$ = 0; } | IDENTIFIER ':' LIST OF type IS list ';' { lists.insert($1, $7); $$ = 0; }; list: '(' expressions ')' { $$ = $2; }; expressions: expressions ',' expression { $1->push_back($3); $$ = $1; } | expression { $$ = new vector<double>(); $$->push_back($1); }; body: BEGIN_ statement_ END { $$ = $2; }; statement_: statement ';' { $$ = $1; } | error ';' { $$ = 0; }; statement: expression { $$ = $1; } | WHEN condition ',' expression ':' expression { $$ = $2 ? $4 : $6; } | SWITCH expression IS cases others_case ENDSWITCH { $$ = !isnan($4) ? $4 : $5; } | IF condition THEN statement_ elsif_statements else_statement ENDIF { $$ = $2 ? $4 : ($5 != 0 ? $5 : $6); } | FOLD direction operator list_choice ENDFOLD { $$ = evaluateFold($2, (Operators)$3, $4); }; elsif_statements: %empty { $$ = 0; } | elsif_statements ELSIF condition THEN statement_ { $$ = $3 ? $5 : $1; }; else_statement: ELSE statement_ { $$ = $2; } | %empty { $$ = 0; }; cases: cases case { $$ = !isnan($1) ? $1 : $2; } | %empty { $$ = NAN; }; others_case: OTHERS ARROW statement ';' { $$ = $3; } | OTHERS ARROW statement { $$ = $2; } case: CASE INT_LITERAL ARROW statement ';' { $$ = ($2 == result) ? $4 : NAN; } | CASE CHAR_LITERAL ARROW statement ';' { $$ = ($2 == result) ? $4 : NAN; } | error ';' { $$ = NAN; }; direction: LEFT { $$ = 'L'; } | RIGHT { $$ = 'R'; }; operator: ADDOP { $$ = ADD; } | MULOP { $$ = MULTIPLY; } | SUBOP { $$ = SUBTRACT; } | DIVOP { $$ = DIVIDE; }; list_choice: list { $$ = $1; } | IDENTIFIER { vector<double>* temp; if (lists.find($1, temp)) $$ = temp; else { $$ = nullptr; appendError(UNDECLARED, $1); } }; condition: condition OROP relation { $$ = $1 || $3; } | condition ANDOP relation { $$ = $1 && $3; } | relation; relation: '(' condition ')' { $$ = $2; } | expression RELOP expression { $$ = evaluateRelational($1, $2, $3); } | NOTOP relation { $$ = !$2; }; expression: expression ADDOP term { $$ = evaluateArithmetic($1, $2, $3); } | expression SUBOP term { $$ = evaluateArithmetic($1, SUBTRACT, $3); } | term; term: term MULOP factor { $$ = evaluateArithmetic($1, $2, $3); } | term DIVOP factor { $$ = evaluateArithmetic($1, DIVIDE, $3); } | term MODOP factor { $$ = fmod($1, $3); } | factor; factor: primary EXPOP factor { $$ = pow($1, $3); } | unary; unary: NEGOP unary { $$ = -$2; } | primary; primary: '(' expression ')' { $$ = $2; } | INT_LITERAL { $$ = $1; } | REAL_LITERAL { $$ = $1; } | CHAR_LITERAL { $$ = $1; } | HEX_LITERAL { $$ = $1; } | IDENTIFIER '(' expression ')' { $$ = extract_element($1, $3); } | IDENTIFIER { if (!scalars.find($1, $$)) appendError(UNDECLARED, $1); }; %% void yyerror(const char* message) { appendError(SYNTAX, message); } double extract_element(CharPtr list_name, double subscript) { vector<double>* list; if (lists.find(list_name, list)) return (*list)[subscript]; appendError(UNDECLARED, list_name); return NAN; } int main(int argc, char *argv[]) { firstLine(); param_values = new double[argc - 1]; for (int i = 1; i < argc; ++i) { param_values[i - 1] = atof(argv[i]); } yyparse(); if (lastLine() == 0) cout << "Result = " << result << endl; delete[] param_values; return 0; }