Make parser create trees

This commit is contained in:
Danila Fedorin 2019-05-20 11:12:53 -07:00
parent c1e4433011
commit f098f91455
4 changed files with 75 additions and 66 deletions

View File

@ -1,39 +1,14 @@
#include <iostream> #include <iostream>
#include <set> #include <set>
#include "tree.hpp"
#include "parser.hpp" #include "parser.hpp"
extern int yylex(); extern int yylex();
extern std::string* target_program; extern stmt_ptr target_program;
extern std::set<std::string> symbols;
int main() { int main() {
if (!yylex()) { if (!yylex()) {
// Write initial C++ stuff.
std::cout << "#include <iostream>" << std::endl;
std::cout << "int main() {" << std::endl;
// Write declaractions for all variables.
std::set<std::string>::iterator it;
for (it = symbols.begin(); it != symbols.end(); it++) {
std::cout << "double " << *it << ";" << std::endl;
}
// Write the program itself.
std::cout << std::endl << "/* Begin program */" << std::endl << std::endl;
std::cout << *target_program << std::endl;
std::cout << "/* End program */" << std::endl << std::endl;
// Write print statements for all symbols.
for (it = symbols.begin(); it != symbols.end(); it++) {
std::cout << "std::cout << \"" << *it << ": \" << " << *it << " << std::endl;" << std::endl;
}
// Write terminating brace.
std::cout << "}" << std::endl;
delete target_program; delete target_program;
target_program = NULL;
} }
} }

View File

@ -2,6 +2,7 @@
#include <iostream> #include <iostream>
#include <set> #include <set>
#include "tree.hpp"
#include "parser.hpp" #include "parser.hpp"
extern int yylex(); extern int yylex();
@ -12,8 +13,7 @@ std::string* translate_boolean_str(std::string* boolean_str);
* Here, target_program is a string that will hold the target program being * Here, target_program is a string that will hold the target program being
* generated, and symbols is a simple symbol table. * generated, and symbols is a simple symbol table.
*/ */
std::string* target_program; stmt_ptr target_program;
std::set<std::string> symbols;
%} %}
/* Enable location tracking. */ /* Enable location tracking. */
@ -23,7 +23,11 @@ std::set<std::string> symbols;
* All program constructs will be represented as strings, specifically as * All program constructs will be represented as strings, specifically as
* their corresponding C/C++ translation. * their corresponding C/C++ translation.
*/ */
%define api.value.type { std::string* } %union {
expr_ptr ex;
stmt_ptr st;
std::string* str;
}
/* /*
* Because the lexer can generate more than one token at a time (i.e. DEDENT * Because the lexer can generate more than one token at a time (i.e. DEDENT
@ -56,6 +60,10 @@ std::set<std::string> symbols;
%left EQ NEQ GT GTE LT LTE %left EQ NEQ GT GTE LT LTE
%right NOT %right NOT
%type <str> IDENTIFIER FLOAT INTEGER BOOLEAN
%type <st> program statements statement if_statement while_statement break_statement block elif_blocks else_block
%type <ex> assign_statement primary_expression negated_expression expression condition
/* This is our goal/start symbol. */ /* This is our goal/start symbol. */
%start program %start program
@ -73,78 +81,78 @@ program
; ;
statements statements
: statement { $$ = $1; } : statement { $$ = new stmt_block(); ((stmt_block*)$$)->children.push_back($1); }
| statements statement { $$ = new std::string(*$1 + *$2); delete $1; delete $2; } | statements statement { $$ = $1; ((stmt_block*)$$)->children.push_back($2); }
; ;
statement statement
: assign_statement { $$ = $1; } : assign_statement { $$ = new stmt_expr($1); }
| if_statement { $$ = $1; } | if_statement { $$ = $1; }
| while_statement { $$ = $1; } | while_statement { $$ = $1; }
| break_statement { $$ = $1; } | break_statement { $$ = $1; }
; ;
primary_expression primary_expression
: IDENTIFIER { $$ = $1; } : IDENTIFIER { $$ = new expr_id(*$1); delete $1; }
| FLOAT { $$ = $1; } | FLOAT { $$ = new expr_float(std::stod(*$1)); delete $1; }
| INTEGER { $$ = $1; } | INTEGER { $$ = new expr_int(std::stoi(*$1)); delete $1; }
| BOOLEAN { $$ = translate_boolean_str($1); delete $1; } | BOOLEAN { $$ = new expr_int(*$1 == "True"); delete $1; }
| LPAREN expression RPAREN { $$ = new std::string("(" + *$2 + ")"); delete $2; } | LPAREN expression RPAREN { $$ = $2; }
; ;
negated_expression negated_expression
: NOT primary_expression { $$ = new std::string("!" + *$2); delete $2; } : NOT primary_expression { $$ = new expr_unop(unop::lnot, $2); }
; ;
expression expression
: primary_expression { $$ = $1; } : primary_expression { $$ = $1; }
| negated_expression { $$ = $1; } | negated_expression { $$ = $1; }
| expression PLUS expression { $$ = new std::string(*$1 + " + " + *$3); delete $1; delete $3; } | expression PLUS expression { $$ = new expr_binop(binop::plus, $1, $3); }
| expression MINUS expression { $$ = new std::string(*$1 + " - " + *$3); delete $1; delete $3; } | expression MINUS expression { $$ = new expr_binop(binop::minus, $1, $3); }
| expression TIMES expression { $$ = new std::string(*$1 + " * " + *$3); delete $1; delete $3; } | expression TIMES expression { $$ = new expr_binop(binop::times, $1, $3); }
| expression DIVIDEDBY expression { $$ = new std::string(*$1 + " / " + *$3); delete $1; delete $3; } | expression DIVIDEDBY expression { $$ = new expr_binop(binop::divide, $1, $3); }
| expression EQ expression { $$ = new std::string(*$1 + " == " + *$3); delete $1; delete $3; } | expression EQ expression { $$ = new expr_binop(binop::eq, $1, $3); }
| expression NEQ expression { $$ = new std::string(*$1 + " != " + *$3); delete $1; delete $3; } | expression NEQ expression { $$ = new expr_binop(binop::neq, $1, $3); }
| expression GT expression { $$ = new std::string(*$1 + " > " + *$3); delete $1; delete $3; } | expression GT expression { $$ = new expr_binop(binop::gt, $1, $3); }
| expression GTE expression { $$ = new std::string(*$1 + " >= " + *$3); delete $1; delete $3; } | expression GTE expression { $$ = new expr_binop(binop::gte, $1, $3); }
| expression LT expression { $$ = new std::string(*$1 + " < " + *$3); delete $1; delete $3; } | expression LT expression { $$ = new expr_binop(binop::lt, $1, $3); }
| expression LTE expression { $$ = new std::string(*$1 + " <= " + *$3); delete $1; delete $3; } | expression LTE expression { $$ = new expr_binop(binop::lte, $1, $3); }
; ;
assign_statement assign_statement
: IDENTIFIER ASSIGN expression NEWLINE { symbols.insert(*$1); $$ = new std::string(*$1 + " = " + *$3 + ";\n"); delete $1; delete $3; } : IDENTIFIER ASSIGN expression NEWLINE { $$ = new expr_assign(*$1, $3); delete $1; }
; ;
block block
: INDENT statements DEDENT { $$ = new std::string("{\n" + *$2 + "}"); delete $2; } : INDENT statements DEDENT { $$ = $2; }
; ;
condition condition
: expression { $$ = $1; } : expression { $$ = $1; }
| condition AND condition { $$ = new std::string(*$1 + " && " + *$3); delete $1; delete $3; } | condition AND condition { $$ = new expr_binop(binop::land, $1, $3); }
| condition OR condition { $$ = new std::string(*$1 + " || " + *$3); delete $1; delete $3; } | condition OR condition { $$ = new expr_binop(binop::lor, $1, $3); }
; ;
if_statement if_statement
: IF condition COLON NEWLINE block elif_blocks else_block { $$ = new std::string("if (" + *$2 + ") " + *$5 + *$6 + *$7 + "\n"); delete $2; delete $5; delete $6; delete $7; } : IF condition COLON NEWLINE block elif_blocks else_block { $$ = new stmt_if($2, $6, $7); delete $6; }
; ;
elif_blocks elif_blocks
: %empty { $$ = new std::string(""); } : %empty { $$ = nullptr; }
| elif_blocks ELIF condition COLON NEWLINE block { $$ = new std::string(*$1 + " else if (" + *$3 + ") " + *$6); delete $1; delete $3; delete $6; } | elif_blocks ELIF condition COLON NEWLINE block { $$ = new stmt_if($3, $6); delete $6; }
; ;
else_block else_block
: %empty { $$ = new std::string(""); } : %empty { $$ = nullptr; }
| ELSE COLON NEWLINE block { $$ = new std::string(" else " + *$4); delete $4; } | ELSE COLON NEWLINE block { $$ = $4; }
while_statement while_statement
: WHILE condition COLON NEWLINE block { $$ = new std::string("while (" + *$2 + ") " + *$5 + "\n"); delete $2; delete $5; } : WHILE condition COLON NEWLINE block { $$ = new stmt_while($2, $5); }
; ;
break_statement break_statement
: BREAK NEWLINE { $$ = new std::string("break;\n"); } : BREAK NEWLINE { $$ = new stmt_break(); }
; ;
%% %%

View File

@ -7,6 +7,7 @@
#include <stack> #include <stack>
#include <cstdlib> #include <cstdlib>
#include "tree.hpp"
#include "parser.hpp" #include "parser.hpp"
/* /*
@ -44,8 +45,7 @@ std::stack<int> _indent_stack;
YYLTYPE loc; YYLTYPE loc;
#define PUSH_TOKEN(token, text) do { \ #define PUSH_TOKEN(token, text) do { \
yylval = text ? new std::string(text) : NULL; \ yylval.str = text ? new std::string(text) : NULL; \
loc.first_line = loc.last_line = yylineno; \
int status = yypush_parse(pstate, token, &yylval, &loc); \ int status = yypush_parse(pstate, token, &yylval, &loc); \
if (status != YYPUSH_MORE) { \ if (status != YYPUSH_MORE) { \
yypstate_delete(pstate); \ yypstate_delete(pstate); \

View File

@ -25,7 +25,26 @@ struct expr {
virtual ~expr() = default; virtual ~expr() = default;
}; };
typedef std::unique_ptr<expr> expr_ptr; typedef expr* expr_ptr;
struct expr_id : expr {
std::string id;
expr_id(std::string i) :
id(std::move(i)) {}
};
struct expr_int : expr {
int val;
expr_int(int i) : val(i) {}
};
struct expr_float : expr {
double val;
expr_float(double f) : val(f) {}
};
struct expr_binop : expr { struct expr_binop : expr {
binop op; binop op;
@ -61,7 +80,7 @@ struct stmt {
virtual ~stmt() = default; virtual ~stmt() = default;
}; };
typedef std::unique_ptr<stmt> stmt_ptr; typedef stmt* stmt_ptr;
struct stmt_block : stmt { struct stmt_block : stmt {
std::vector<stmt_ptr> children; std::vector<stmt_ptr> children;
@ -80,14 +99,21 @@ struct stmt_while : stmt {
expr_ptr cond; expr_ptr cond;
stmt_ptr body; stmt_ptr body;
stmt_while(expr_ptr c, stmt_ptr b) stmt_while(expr_ptr c, stmt_ptr b) :
: cond(std::move(c)), body(std::move(b)) {} cond(std::move(c)), body(std::move(b)) {}
}; };
struct stmt_break : stmt { struct stmt_break : stmt {
}; };
struct stmt_expr : stmt {
expr_ptr child;
stmt_expr(expr_ptr c) :
child(std::move(c)) {}
};
template <typename T, typename ... Ts> template <typename T, typename ... Ts>
stmt_ptr make_stmt(Ts&& ... ts) { stmt_ptr make_stmt(Ts&& ... ts) {
return stmt_ptr(new T(std::move(ts)...)); return stmt_ptr(new T(std::move(ts)...));