Skip to content
Snippets Groups Projects
Commit 3d66b0d8 authored by Clemens Paumgarten's avatar Clemens Paumgarten
Browse files

Fix segfault in statement parse 

	Prints still in code for further debugging
parent 481a3b5d
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
CMakeLists.txt
+ 1
− 1
View file @ 3d66b0d8
......@@ -56,4 +56,4 @@ add_executable(mcc
include/mcc/mcc.h
app/mc_ir.c
src/tac.c
include/mcc/tac.h src/tac_string_builder.c include/mcc/tac_string_builder.h src/utils/utils.c include/mcc/utils.h)
include/mcc/tac.h src/tac_string_builder.c include/mcc/tac_string_builder.h src/utils/utils.c include/mcc/utils.h src/tac_print.c)
app/mc_ir.c
+ 2
− 0
View file @ 3d66b0d8
......@@ -110,6 +110,8 @@ int main(int argc, char *argv[]) {
return EXIT_FAILURE;
}
// mcc_symbol_table_print(symbol_table, out);
// create tac
struct mcc_tac *tac = mcc_tac_build(prog,symbol_table);
......
include/mcc/tac.h
+ 1
− 1
View file @ 3d66b0d8
......@@ -161,7 +161,7 @@ int mcc_tac_create_and_add_new_entry_temp(
void mcc_tac_enter_next_deeper_scope(struct mcc_tac *tac);
void mcc_tac_exit_to_outer_scoper(struct mcc_tac *tac, int prev_index);
void mcc_tac_exit_to_outer_scope(struct mcc_tac *tac, int prev_index);
void mcc_tac_jump_to_next_inner_st(struct mcc_tac *tac);
......
src/symbol_table_validate.c
+ 0
− 2
View file @ 3d66b0d8
......@@ -678,8 +678,6 @@ int mcc_symbol_table_validate_statement_return(
func_def,
ec
);
printf("\n Result of parent return %d\n",result);
}
}
......
src/tac.c
+ 121
− 103
View file @ 3d66b0d8
......@@ -48,13 +48,13 @@ struct mcc_tac *mcc_tac_new(struct mcc_tac *prev_tac, struct mcc_symbol_table *s
prev_tac->next = tac;
}
tac -> tac_entries = mcc_create_dynamic_array(MCC_TAC_ENTRY_SIZE);
tac -> temporary_count = 0;
tac -> label_count = 0;
tac->tac_entries = mcc_create_dynamic_array(MCC_TAC_ENTRY_SIZE);
tac->temporary_count = 0;
tac->label_count = 0;
tac -> root_table = st;
tac -> current_symbol_table = st;
tac -> current_symbol_index = 0;
tac->root_table = st;
tac->current_symbol_table = st;
tac->current_symbol_index = 0;
return tac;
}
......@@ -67,16 +67,16 @@ struct mcc_tac_entry *mcc_tac_new_entry(
) {
struct mcc_tac_entry *te = malloc(sizeof(*te));
te -> tac_op = tac_op;
te -> arg1 = arg1;
te -> arg2 = arg2;
te -> result = result;
te->tac_op = tac_op;
te->arg1 = arg1;
te->arg2 = arg2;
te->result = result;
return te;
}
int mcc_tac_add_entry(struct mcc_tac *tac, struct mcc_tac_entry *te) {
return mcc_add_to_array(tac -> tac_entries, te);
return mcc_add_to_array(tac->tac_entries, te);
}
int mcc_tac_create_and_add_new_entry(
......@@ -95,11 +95,11 @@ int mcc_tac_create_and_add_new_entry_temp(
char *arg1,
char *arg2,
struct mcc_tac *tac) {
char *result = mcc_tac_new_temporary_string(tac);
struct mcc_tac_entry *te = mcc_tac_new_entry(tac_op, arg1, arg2, result);
return mcc_tac_add_entry(tac, te);
char *result = mcc_tac_new_temporary_string(tac);
struct mcc_tac_entry *te = mcc_tac_new_entry(tac_op, arg1, arg2, result);
return mcc_tac_add_entry(tac, te);
}
......@@ -110,7 +110,7 @@ void mcc_tac_delete_entry(void *te) {
}
void mcc_tac_delete(struct mcc_tac *tac) {
if(tac->next!= NULL) {
if(tac->next != NULL) {
mcc_tac_delete(tac->next);
}
......@@ -120,7 +120,7 @@ void mcc_tac_delete(struct mcc_tac *tac) {
}
enum mcc_tac_operation mcc_convert_ast_type_to_tac_literal(enum mcc_ast_data_type type) {
switch (type) {
switch(type) {
case MCC_AST_DATA_TYPE_INT:
return MCC_TAC_INT;
case MCC_AST_DATA_TYPE_BOOL:
......@@ -129,13 +129,14 @@ enum mcc_tac_operation mcc_convert_ast_type_to_tac_literal(enum mcc_ast_data_typ
return MCC_TAC_FLOAT;
case MCC_AST_DATA_TYPE_STRING:
return MCC_TAC_STRING;
default: break;
default:
break;
}
return MCC_TAC_UNKNOWN;
}
enum mcc_tac_operation mcc_convert_ast_type_to_tac_ident(enum mcc_ast_data_type type) {
switch (type) {
switch(type) {
case MCC_AST_DATA_TYPE_INT:
return MCC_TAC_IDENTIFIER_INT;
case MCC_AST_DATA_TYPE_BOOL:
......@@ -144,13 +145,14 @@ enum mcc_tac_operation mcc_convert_ast_type_to_tac_ident(enum mcc_ast_data_type
return MCC_TAC_IDENTIFIER_FLOAT;
case MCC_AST_DATA_TYPE_STRING:
return MCC_TAC_IDENTIFIER_STRING;
default: break;
default:
break;
}
return MCC_TAC_UNKNOWN;
}
enum mcc_tac_operation mcc_convert_ast_type_to_tac_param(enum mcc_ast_data_type type) {
switch (type) {
switch(type) {
case MCC_AST_DATA_TYPE_INT:
return MCC_TAC_PARAM_INT;
case MCC_AST_DATA_TYPE_BOOL:
......@@ -159,120 +161,136 @@ enum mcc_tac_operation mcc_convert_ast_type_to_tac_param(enum mcc_ast_data_type
return MCC_TAC_PARAM_FLOAT;
case MCC_AST_DATA_TYPE_STRING:
return MCC_TAC_PARAM_INT;
default: break;
default:
break;
}
return MCC_TAC_UNKNOWN;
}
enum mcc_tac_operation mcc_convert_ast_type_to_tac_unary(enum mcc_ast_data_type type) {
switch (type) {
switch(type) {
case MCC_AST_DATA_TYPE_INT:
return MCC_TAC_MINUS_INT_UN;
case MCC_AST_DATA_TYPE_BOOL:
return MCC_TAC_PARAM_BOOL;
case MCC_TAC_MINUS_FLOAT_UN:
return MCC_TAC_NOT;
default: break;
default:
break;
}
return MCC_TAC_UNKNOWN;
}
enum mcc_tac_operation mcc_convert_ast_type_to_tac_binary(enum mcc_ast_binary_op binary_op,enum mcc_ast_data_type type) {
switch (binary_op) {
case MCC_AST_BINARY_OP_ADD:
return (type == MCC_AST_DATA_TYPE_INT)
? MCC_TAC_PLUS_INT
: MCC_TAC_PLUS_FLOAT;
case MCC_AST_BINARY_OP_SUB:
return (type == MCC_AST_DATA_TYPE_INT)
? MCC_TAC_MINUS_INT_BIN
: MCC_TAC_MINUS_FLOAT_BIN;
case MCC_AST_BINARY_OP_MUL:
return (type == MCC_AST_DATA_TYPE_INT)
? MCC_TAC_MUL_INT
: MCC_TAC_MUL_FLOAT;
case MCC_AST_BINARY_OP_DIV:
return (type == MCC_AST_DATA_TYPE_INT)
? MCC_TAC_DIV_INT
: MCC_TAC_DIV_FLOAT;
case MCC_AST_BINARY_OP_LESS:
return (type == MCC_AST_DATA_TYPE_INT)
? MCC_TAC_LT
: MCC_TAC_LT_FLOAT;
case MCC_AST_BINARY_OP_GREATER:
return (type == MCC_AST_DATA_TYPE_INT)
? MCC_TAC_GT
: MCC_TAC_GT_FLOAT;
case MCC_AST_BINARY_OP_LESS_EQUALS:
return (type == MCC_AST_DATA_TYPE_INT)
? MCC_TAC_LTEQ
: MCC_TAC_LTEQ_FLOAT;
case MCC_AST_BINARY_OP_GREATER_EQUALS:
return (type == MCC_AST_DATA_TYPE_INT)
? MCC_TAC_GTEQ
: MCC_TAC_GTEQ_FLOAT;
case MCC_AST_BINARY_OP_EQUALS:
if (type == MCC_AST_DATA_TYPE_BOOL) {
return MCC_TAC_EQ_BOOL;
} else if (type == MCC_AST_DATA_TYPE_INT) {
return MCC_TAC_EQ;
} else {
return MCC_TAC_EQ_FLOAT;
}
case MCC_AST_BINARY_OP_NOT_EQUALS:
if (type == MCC_AST_DATA_TYPE_BOOL) {
return MCC_TAC_NEQ_BOOL;
} else if (type == MCC_AST_DATA_TYPE_INT) {
return MCC_TAC_NEQ;
} else {
return MCC_TAC_NEQ_FLOAT;
}
case MCC_AST_BINARY_OP_AND: return MCC_TAC_AND;
case MCC_AST_BINARY_OP_OR: return MCC_TAC_OR;
default: break;
}
enum mcc_tac_operation
mcc_convert_ast_type_to_tac_binary(enum mcc_ast_binary_op binary_op, enum mcc_ast_data_type type) {
switch(binary_op) {
case MCC_AST_BINARY_OP_ADD:
return (type == MCC_AST_DATA_TYPE_INT)
? MCC_TAC_PLUS_INT
: MCC_TAC_PLUS_FLOAT;
case MCC_AST_BINARY_OP_SUB:
return (type == MCC_AST_DATA_TYPE_INT)
? MCC_TAC_MINUS_INT_BIN
: MCC_TAC_MINUS_FLOAT_BIN;
case MCC_AST_BINARY_OP_MUL:
return (type == MCC_AST_DATA_TYPE_INT)
? MCC_TAC_MUL_INT
: MCC_TAC_MUL_FLOAT;
case MCC_AST_BINARY_OP_DIV:
return (type == MCC_AST_DATA_TYPE_INT)
? MCC_TAC_DIV_INT
: MCC_TAC_DIV_FLOAT;
case MCC_AST_BINARY_OP_LESS:
return (type == MCC_AST_DATA_TYPE_INT)
? MCC_TAC_LT
: MCC_TAC_LT_FLOAT;
case MCC_AST_BINARY_OP_GREATER:
return (type == MCC_AST_DATA_TYPE_INT)
? MCC_TAC_GT
: MCC_TAC_GT_FLOAT;
case MCC_AST_BINARY_OP_LESS_EQUALS:
return (type == MCC_AST_DATA_TYPE_INT)
? MCC_TAC_LTEQ
: MCC_TAC_LTEQ_FLOAT;
case MCC_AST_BINARY_OP_GREATER_EQUALS:
return (type == MCC_AST_DATA_TYPE_INT)
? MCC_TAC_GTEQ
: MCC_TAC_GTEQ_FLOAT;
case MCC_AST_BINARY_OP_EQUALS:
if(type == MCC_AST_DATA_TYPE_BOOL) {
return MCC_TAC_EQ_BOOL;
} else if(type == MCC_AST_DATA_TYPE_INT) {
return MCC_TAC_EQ;
} else {
return MCC_TAC_EQ_FLOAT;
}
case MCC_AST_BINARY_OP_NOT_EQUALS:
if(type == MCC_AST_DATA_TYPE_BOOL) {
return MCC_TAC_NEQ_BOOL;
} else if(type == MCC_AST_DATA_TYPE_INT) {
return MCC_TAC_NEQ;
} else {
return MCC_TAC_NEQ_FLOAT;
}
case MCC_AST_BINARY_OP_AND:
return MCC_TAC_AND;
case MCC_AST_BINARY_OP_OR:
return MCC_TAC_OR;
default:
break;
}
return MCC_TAC_UNKNOWN;
}
enum mcc_tac_operation mcc_convert_ast_type_to_tac_load(enum mcc_ast_data_type type) {
switch (type) {
case MCC_AST_DATA_TYPE_BOOL: return MCC_TAC_LOAD_BOOL;
case MCC_AST_DATA_TYPE_INT: return MCC_TAC_LOAD_INT;
case MCC_AST_DATA_TYPE_FLOAT: return MCC_TAC_LOAD_FLOAT;
case MCC_AST_DATA_TYPE_STRING: return MCC_TAC_LOAD_STRING;
default: break;
}
return MCC_TAC_UNKNOWN;
switch(type) {
case MCC_AST_DATA_TYPE_BOOL:
return MCC_TAC_LOAD_BOOL;
case MCC_AST_DATA_TYPE_INT:
return MCC_TAC_LOAD_INT;
case MCC_AST_DATA_TYPE_FLOAT:
return MCC_TAC_LOAD_FLOAT;
case MCC_AST_DATA_TYPE_STRING:
return MCC_TAC_LOAD_STRING;
default:
break;
}
return MCC_TAC_UNKNOWN;
}
enum mcc_tac_operation mcc_convert_ast_type_to_tac_store(enum mcc_ast_data_type type) {
switch (type) {
case MCC_AST_DATA_TYPE_BOOL: return MCC_TAC_STORE_BOOL;
case MCC_AST_DATA_TYPE_INT: return MCC_TAC_STORE_INT;
case MCC_AST_DATA_TYPE_FLOAT: return MCC_TAC_STORE_FLOAT;
case MCC_AST_DATA_TYPE_STRING: return MCC_TAC_STORE_STRING;
default: break;
}
return MCC_TAC_UNKNOWN;
switch(type) {
case MCC_AST_DATA_TYPE_BOOL:
return MCC_TAC_STORE_BOOL;
case MCC_AST_DATA_TYPE_INT:
return MCC_TAC_STORE_INT;
case MCC_AST_DATA_TYPE_FLOAT:
return MCC_TAC_STORE_FLOAT;
case MCC_AST_DATA_TYPE_STRING:
return MCC_TAC_STORE_STRING;
default:
return MCC_TAC_UNKNOWN;
}
}
void mcc_tac_enter_next_deeper_scope(struct mcc_tac *tac) {
struct mcc_symbol_table *next_curr = tac -> current_symbol_table -> inner_tables -> arr[tac -> current_symbol_index];
struct mcc_symbol_table *next_curr = tac->current_symbol_table->inner_tables->arr[tac->current_symbol_index];
tac -> current_symbol_table = next_curr;
tac -> current_symbol_index = 0;
tac->current_symbol_table = next_curr;
tac->current_symbol_index = 0;
}
void mcc_tac_exit_to_outer_scoper(struct mcc_tac *tac, int tac_st_index) {
struct mcc_symbol_table *root = tac -> current_symbol_table -> parent;
void mcc_tac_exit_to_outer_scope(struct mcc_tac *tac, int tac_st_index) {
struct mcc_symbol_table *root = tac->current_symbol_table->parent;
tac -> current_symbol_table = root -> inner_tables -> arr[tac_st_index];
tac -> current_symbol_index = tac_st_index;
tac->current_symbol_table = root;
tac->current_symbol_index = tac_st_index;
}
void mcc_tac_jump_to_next_inner_st(struct mcc_tac *tac) {
......
src/tac_build.c
+ 123
− 107
View file @ 3d66b0d8
......@@ -4,11 +4,12 @@
#include <assert.h>
#include <mcc/ast.h>
#include "mcc/tac_string_builder.h"
#include "mcc/tac_build.h"
#include "mcc/tac_string_builder.h"
#include "mcc/symbol_table.h"
#include "mcc/utils.h"
#include "mcc/symbol_table_validate.h"
#include "mcc/symbol_table_print.h"
#include "mcc/utils.h"
// -------------------------------- parse expression
......@@ -148,132 +149,140 @@ void mcc_tac_parse_statement_list(struct mcc_ast_statement_list *stl, struct mcc
}
struct mcc_tac *mcc_tac_parse_statement(struct mcc_ast_statement *statement, struct mcc_tac *tac) {
switch (statement -> type) {
case MCC_AST_STATEMENT_TYPE_COMPOUND:
mcc_tac_parse_statement_list(statement -> statement_list, tac);
break;
case MCC_AST_STATEMENT_TYPE_IF: {
printf("Parse statement \n");
switch (statement -> type) {
case MCC_AST_STATEMENT_TYPE_COMPOUND:
printf("\t Compound \n");
mcc_tac_parse_statement_list(statement -> statement_list, tac);
break;
case MCC_AST_STATEMENT_TYPE_IF: {
printf("\t If \n");
// evaluate if expression
mcc_tac_parse_expression(statement -> while_condition, tac);
char *last_temp = tac -> last_temporary;
// now do that jump / jumpfalse stuff here
char *if_label = mcc_tac_new_label_string(tac);
mcc_tac_create_and_add_new_entry(MCC_TAC_JMP_FALSE, last_temp, NULL, if_label, tac);
// scope go to deeper scope and save current index
int current_scope_index = tac -> current_symbol_index;
// evaluate if expression
mcc_tac_parse_expression(statement -> while_condition, tac);
mcc_tac_enter_next_deeper_scope(tac);
mcc_tac_parse_statement(statement -> if_stmt, tac);
char *last_temp = tac -> last_temporary;
// go back to previous scope
mcc_tac_exit_to_outer_scope(tac, current_scope_index);
// now do that jump / jumpfalse stuff here
char *if_label = mcc_tac_new_label_string(tac);
tac -> current_symbol_index++;
mcc_tac_create_and_add_new_entry(MCC_TAC_JMP_FALSE, last_temp, NULL, if_label, tac);
char *else_label= mcc_tac_new_label_string(tac);
mcc_tac_create_and_add_new_entry(MCC_TAC_JMP, NULL, NULL, else_label, tac);
if (statement -> else_stmt != NULL) {
// jump last label
current_scope_index = tac -> current_symbol_index;
//scope go to deeper scope and save current index
int current_scope_index = tac -> current_symbol_index;
mcc_tac_enter_next_deeper_scope(tac);
mcc_tac_parse_statement(statement -> if_stmt, tac);
mcc_tac_parse_statement(statement -> else_stmt, tac);
//go back to previous scope
mcc_tac_exit_to_outer_scoper(tac, current_scope_index);
mcc_tac_exit_to_outer_scope(tac, current_scope_index);
tac -> current_symbol_index++;
}
char *else_label= mcc_tac_new_label_string(tac);
mcc_tac_create_and_add_new_entry(MCC_TAC_JMP, NULL, NULL, else_label, tac);
} break;
case MCC_AST_STATEMENT_TYPE_EXPRESSION:
printf("\t Expression \n");
mcc_tac_parse_expression(statement -> expression, tac);
break;
case MCC_AST_STATEMENT_TYPE_WHILE: {
printf("\t While \n");
mcc_tac_parse_expression(statement -> while_condition, tac);
if (statement -> else_stmt != NULL) {
// jump last label
char *last_temp = tac -> last_temporary;
current_scope_index = tac -> current_symbol_index;
mcc_tac_enter_next_deeper_scope(tac);
char *while_label = mcc_tac_new_label_string(tac);
mcc_tac_create_and_add_new_entry(MCC_TAC_JMP_FALSE, last_temp, NULL, while_label, tac);
mcc_tac_parse_statement(statement -> else_stmt, tac);
int current_scope_index = tac -> current_symbol_index;
mcc_tac_enter_next_deeper_scope(tac);
//go back to previous scope
mcc_tac_exit_to_outer_scoper(tac, current_scope_index);
tac -> current_symbol_index++;
}
mcc_tac_parse_statement(statement -> if_stmt, tac);
} break;
case MCC_AST_STATEMENT_TYPE_EXPRESSION:
mcc_tac_parse_expression(statement -> expression, tac);
break;
case MCC_AST_STATEMENT_TYPE_WHILE: {
mcc_tac_parse_expression(statement -> while_condition, tac);
//go back to previous scope
mcc_tac_exit_to_outer_scope(tac, current_scope_index);
tac -> current_symbol_index++;
} break;
case MCC_AST_STATEMENT_TYPE_DECL: {
// Check nicht ganz um was es da geht
// struct mCc_ast_literal *array_size = statement->declaration->array_size;
// if (array_size) {
// builder->current_variable_count += atoi(array_size->value);
// create_and_add_line(builder, MCC_TAC_OPERATION_ARRAY_DECLARATION,
// array_size->value, NULL,
// statement->declaration->identifier->name);
// }
// break;
// }
} break;
case MCC_AST_STATEMENT_TYPE_ASSGN_ARR:
case MCC_AST_STATEMENT_TYPE_ASSGN: {
printf("\t Assignment \n");
// get type
struct mcc_ast_assignment *a = statement -> assignment;
char *result = statement -> assignment -> identifier ->i_value;
char *last_temp = tac -> last_temporary;
enum mcc_ast_data_type assignment_type = mcc_symbol_table_get_symbol(
tac->current_symbol_table,
result,
true) -> data_type;
char *while_label = mcc_tac_new_label_string(tac);
mcc_tac_create_and_add_new_entry(MCC_TAC_JMP_FALSE, last_temp, NULL, while_label, tac);
enum mcc_tac_operation tac_op = mcc_convert_ast_type_to_tac_literal(assignment_type);
if (a -> type == MCC_AST_ASSIGNMENT_TYPE_ARRAY) {
mcc_tac_parse_expression(a -> array_ass.index, tac);
int current_scope_index = tac -> current_symbol_index;
mcc_tac_enter_next_deeper_scope(tac);
char *arg2 = tac -> last_temporary;
mcc_tac_parse_statement(statement -> if_stmt, tac);
mcc_tac_parse_expression(a -> array_ass.rhs, tac);
char *arg1 = tac -> last_temporary;
mcc_tac_create_and_add_new_entry(tac_op, arg1, arg2, result, tac);
} else {
// evaluate expression
mcc_tac_parse_expression(a -> normal_ass.rhs, tac);
//go back to previous scope
mcc_tac_exit_to_outer_scoper(tac, current_scope_index);
tac -> current_symbol_index++;
} break;
case MCC_AST_STATEMENT_TYPE_DECL: {
// Check nicht ganz um was es da geht
// struct mCc_ast_literal *array_size = statement->declaration->array_size;
// if (array_size) {
// builder->current_variable_count += atoi(array_size->value);
// create_and_add_line(builder, MCC_TAC_OPERATION_ARRAY_DECLARATION,
// array_size->value, NULL,
// statement->declaration->identifier->name);
// }
// break;
// }
} break;
case MCC_AST_STATEMENT_TYPE_ASSGN_ARR:
case MCC_AST_STATEMENT_TYPE_ASSGN: {
// get type
struct mcc_ast_assignment *a = statement -> assignment;
char *result = statement -> assignment -> identifier ->i_value;
enum mcc_ast_data_type assignment_type =
mcc_symbol_table_get_symbol(
tac->current_symbol_table,
result,
true) -> data_type;
enum mcc_tac_operation tac_op = mcc_convert_ast_type_to_tac_literal(assignment_type);
if (a -> type == MCC_AST_ASSIGNMENT_TYPE_ARRAY) {
mcc_tac_parse_expression(a -> array_ass.index, tac);
char *arg2 = tac -> last_temporary;
mcc_tac_parse_expression(a -> array_ass.rhs, tac);
char *arg1 = tac -> last_temporary;
mcc_tac_create_and_add_new_entry(tac_op, arg1, arg2, result, tac);
} else {
// evaluate expression
mcc_tac_parse_expression(a -> normal_ass.rhs, tac);
char *arg1 = tac -> last_temporary;
mcc_tac_create_and_add_new_entry(tac_op, arg1, NULL, result, tac);
}
} break;
case MCC_AST_STATEMENT_TYPE_RETURN: {
// TODO: get symbol table name from a seperate variable (tac -> root_table)
// get expression type
enum mcc_ast_data_type return_type = mcc_symbol_table_get_expression_return_type(
statement -> expression,
tac -> current_symbol_table
);
enum mcc_tac_operation tac_op = mcc_convert_ast_type_to_tac_literal(return_type);
mcc_tac_parse_expression(statement -> expression, tac);
char *arg1 = tac -> last_temporary;
mcc_tac_create_and_add_new_entry(tac_op, arg1, NULL, result, tac);
}
} break;
case MCC_AST_STATEMENT_TYPE_RETURN: {
printf("\t Return \n");
// TODO: get symbol table name from a seperate variable (tac -> root_table)
// get expression type
enum mcc_ast_data_type return_type = mcc_symbol_table_get_expression_return_type(
statement -> expression,
tac -> current_symbol_table
);
char *result = mcc_tac_new_return_function_name(tac -> current_symbol_table -> sym_table_name);
mcc_tac_create_and_add_new_entry(MCC_TAC_RETURN, arg1, NULL, result, tac);
enum mcc_tac_operation tac_op = mcc_convert_ast_type_to_tac_literal(return_type);
} break;
}
mcc_tac_parse_expression(statement -> expression, tac);
char *arg1 = tac -> last_temporary;
char *result = mcc_tac_new_return_function_name(tac -> current_symbol_table -> sym_table_name);
mcc_tac_create_and_add_new_entry(MCC_TAC_RETURN, arg1, NULL, result, tac);
} break;
}
}
// -------------------------------- parse function
......@@ -282,6 +291,8 @@ int mcc_tac_parse_function(struct mcc_ast_function *f, struct mcc_tac *tac) {
assert(f);
assert(tac);
// TODO: do something with params
if (f->statement != NULL) {
mcc_tac_parse_statement(f -> statement, tac);
}
......@@ -294,11 +305,16 @@ struct mcc_tac *mcc_tac_build(struct mcc_ast_program *program, struct mcc_symbol
struct mcc_ast_function *f = NULL;
// look for main an start parsing program
for (int i = 0; i < program -> function_def -> size; i++) {
for (int i = 0; i < program -> function_def -> size; i++) {
f = program -> function_def -> arr[i];
if (strcmp(f -> identifier -> i_value, "main") == 0) {
struct mcc_symbol_table *t = mcc_symbol_table_get_inner_table_by_name(st, "main");
tac -> current_symbol_table = t;
tac -> current_symbol_index = 0;
mcc_symbol_table_print(tac -> current_symbol_table, stdout);
if (t != NULL) {
mcc_tac_parse_function(f, tac);
......@@ -306,7 +322,7 @@ struct mcc_tac *mcc_tac_build(struct mcc_ast_program *program, struct mcc_symbol
}
}
return tac;
printf("Build tac over \n");
return NULL;
return tac;
}
src/tac_print.c
+ 178
− 178
View file @ 3d66b0d8
......@@ -8,190 +8,190 @@
static const char *tac_type(enum mcc_tac_operation type)
{
switch (type) {
case MCC_TAC_BOOL:
case MCC_TAC_BOOL_LITERAL:
case MCC_TAC_NOT:
case MCC_TAC_AND:
case MCC_TAC_OR:
case MCC_TAC_LOAD_BOOL:
case MCC_TAC_STORE_BOOL:
case MCC_TAC_EQ_BOOL:
case MCC_TAC_NEQ_BOOL: return "bool";
case MCC_TAC_INT:
case MCC_TAC_INT_LITERAL:
case MCC_TAC_MINUS_INT_BIN:
case MCC_TAC_PLUS_INT:
case MCC_TAC_MUL_INT:
case MCC_TAC_DIV_INT:
case MCC_TAC_LOAD_INT:
case MCC_TAC_EQ:
case MCC_TAC_NEQ:
case MCC_TAC_GT:
case MCC_TAC_LT:
case MCC_TAC_LTEQ:
case MCC_TAC_GTEQ: return "int";
case MCC_TAC_FLOAT:
case MCC_TAC_FLOAT_LITERAL:
case MCC_TAC_MINUS_FLOAT_UN:
case MCC_TAC_PLUS_FLOAT:
case MCC_TAC_MINUS_FLOAT_BIN:
case MCC_TAC_MUL_FLOAT:
case MCC_TAC_DIV_FLOAT:
case MCC_TAC_PARAM_FLOAT:
case MCC_TAC_LOAD_FLOAT:
case MCC_TAC_STORE_FLOAT:
case MCC_TAC_LT_FLOAT:
case MCC_TAC_LTEQ_FLOAT:
case MCC_TAC_GT_FLOAT:
case MCC_TAC_GTEQ_FLOAT:
case MCC_TAC_EQ_FLOAT:
case MCC_TAC_NEQ_FLOAT: return "float";
case MCC_TAC_STRING:
case MCC_TAC_STRING_LITERAL:
case MCC_TAC_PARAM_STRING:
case MCC_TAC_LOAD_STRING:
case MCC_TAC_STORE_STRING: return "string";
case MCC_TAC_JMP:
case MCC_TAC_JMP_FALSE:
case MCC_TAC_LABLE:
case MCC_TAC_CALL:
case MCC_TAC_RETURN:
case MCC_TAC_FUNCTION_END:
case MCC_TAC_UNKNOWN: return "untyped";
}
return "ERROR";
switch (type) {
case MCC_TAC_BOOL:
case MCC_TAC_BOOL_LITERAL:
case MCC_TAC_NOT:
case MCC_TAC_AND:
case MCC_TAC_OR:
case MCC_TAC_LOAD_BOOL:
case MCC_TAC_STORE_BOOL:
case MCC_TAC_EQ_BOOL:
case MCC_TAC_NEQ_BOOL: return "bool";
case MCC_TAC_INT:
case MCC_TAC_INT_LITERAL:
case MCC_TAC_MINUS_INT_BIN:
case MCC_TAC_PLUS_INT:
case MCC_TAC_MUL_INT:
case MCC_TAC_DIV_INT:
case MCC_TAC_LOAD_INT:
case MCC_TAC_EQ:
case MCC_TAC_NEQ:
case MCC_TAC_GT:
case MCC_TAC_LT:
case MCC_TAC_LTEQ:
case MCC_TAC_GTEQ: return "int";
case MCC_TAC_FLOAT:
case MCC_TAC_FLOAT_LITERAL:
case MCC_TAC_MINUS_FLOAT_UN:
case MCC_TAC_PLUS_FLOAT:
case MCC_TAC_MINUS_FLOAT_BIN:
case MCC_TAC_MUL_FLOAT:
case MCC_TAC_DIV_FLOAT:
case MCC_TAC_PARAM_FLOAT:
case MCC_TAC_LOAD_FLOAT:
case MCC_TAC_STORE_FLOAT:
case MCC_TAC_LT_FLOAT:
case MCC_TAC_LTEQ_FLOAT:
case MCC_TAC_GT_FLOAT:
case MCC_TAC_GTEQ_FLOAT:
case MCC_TAC_EQ_FLOAT:
case MCC_TAC_NEQ_FLOAT: return "float";
case MCC_TAC_STRING:
case MCC_TAC_STRING_LITERAL:
case MCC_TAC_PARAM_STRING:
case MCC_TAC_LOAD_STRING:
case MCC_TAC_STORE_STRING: return "string";
case MCC_TAC_JMP:
case MCC_TAC_JMP_FALSE:
case MCC_TAC_LABLE:
case MCC_TAC_CALL:
case MCC_TAC_RETURN:
case MCC_TAC_FUNCTION_END:
case MCC_TAC_UNKNOWN: return "untyped";
}
return "ERROR";
}
void tac_print(struct mcc_tac *tac)
{
printf("------------------------------\n");
printf("- TAC -\n");
printf("------------------------------\n");
for (int i = 0; i < tac->tac_entries->size ; i++) {
printf("------------------------------\n");
printf("- TAC -\n");
printf("------------------------------\n");
for (int i = 0; i < tac->tac_entries->size ; i++) {
struct mcc_tac_entry *entry = tac->tac_entries->arr[i];
const char *op_type = tac_type(entry->tac_op);
switch (entry->tac_op) {
case MCC_TAC_BOOL:
case MCC_TAC_BOOL_LITERAL:
case MCC_TAC_INT:
case MCC_TAC_INT_LITERAL:
case MCC_TAC_FLOAT:
case MCC_TAC_FLOAT_LITERAL:
case MCC_TAC_STRING:
case MCC_TAC_STRING_LITERAL:
printf("> %s = %s (%s)\n", entry->result, entry->arg1, op_type);
break;
case MCC_TAC_MINUS_INT_UN:
case MCC_TAC_MINUS_FLOAT_UN:
printf("> %s = -%s (%s)\n", entry->result, entry->arg1, op_type);
break;
case MCC_TAC_NOT:
printf("> %s = !%s (%s)\n", entry->result, entry->arg1, op_type);
break;
case MCC_TAC_PLUS_INT:
case MCC_TAC_PLUS_FLOAT:
printf("> %s = %s + %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_MINUS_INT_BIN:
case MCC_TAC_MINUS_FLOAT_BIN:
printf("> %s = %s - %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_MUL_INT:
case MCC_TAC_MUL_FLOAT:
printf("> %s = %s * %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_DIV_INT:
case MCC_TAC_DIV_FLOAT:
printf("> %s = %s / %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_LT:
case MCC_TAC_LT_FLOAT:
printf("> %s = %s < %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_GT:
case MCC_TAC_GT_FLOAT:
printf("> %s = %s > %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_LTEQ:
case MCC_TAC_LTEQ_FLOAT:
printf("> %s = %s <= %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_GTEQ:
case MCC_TAC_GTEQ_FLOAT:
printf("> %s = %s >= %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_AND:
printf("> %s = %s && %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_OR:
printf("> %s = %s || %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_EQ:
case MCC_TAC_EQ_FLOAT:
case MCC_TAC_EQ_BOOL:
printf("> %s = %s == %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_NEQ:
case MCC_TAC_NEQ_FLOAT:
case MCC_TAC_NEQ_BOOL:
printf("> %s = %s != %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_PARAM_BOOL:
case MCC_TAC_PARAM_INT:
case MCC_TAC_PARAM_FLOAT:
case MCC_TAC_PARAM_STRING:
printf("> param_push %s (%s)\n", entry->arg1, op_type);
break;
case MCC_TAC_LOAD_BOOL:
case MCC_TAC_LOAD_INT:
case MCC_TAC_LOAD_FLOAT:
case MCC_TAC_LOAD_STRING:
printf("> load %s[%s] %s (%s)\n", entry->arg1, entry->arg2,
entry->result, op_type);
break;
case MCC_TAC_STORE_BOOL:
case MCC_TAC_STORE_INT:
case MCC_TAC_STORE_FLOAT:
case MCC_TAC_STORE_STRING:
printf("> store %s[%s] %s (%s)\n", entry->result, entry->arg2,
entry->arg1, op_type);
break;
case MCC_TAC_JMP:
printf("> jump %s (%s)\n", entry->result, op_type);
break;
case MCC_TAC_JMP_FALSE:
printf("> jumpfalse %s %s (%s)\n", entry->arg1, entry->result,
op_type);
break;
case MCC_TAC_LABLE:
printf("\n");
printf("> label %s (%s)\n", entry->result, op_type);
break;
case MCC_TAC_CALL:
printf("> call %s %s (%s)\n", entry->result, entry->arg1, op_type);
break;
case MCC_TAC_RETURN:
case MCC_TAC_FUNCTION_END:
printf("> return (%s)\n", op_type);
break;
default: printf("ERROR\n");
}
}
const char *op_type = tac_type(entry->tac_op);
switch (entry->tac_op) {
case MCC_TAC_BOOL:
case MCC_TAC_BOOL_LITERAL:
case MCC_TAC_INT:
case MCC_TAC_INT_LITERAL:
case MCC_TAC_FLOAT:
case MCC_TAC_FLOAT_LITERAL:
case MCC_TAC_STRING:
case MCC_TAC_STRING_LITERAL:
printf("> %s = %s (%s)\n", entry->result, entry->arg1, op_type);
break;
case MCC_TAC_MINUS_INT_UN:
case MCC_TAC_MINUS_FLOAT_UN:
printf("> %s = -%s (%s)\n", entry->result, entry->arg1, op_type);
break;
case MCC_TAC_NOT:
printf("> %s = !%s (%s)\n", entry->result, entry->arg1, op_type);
break;
case MCC_TAC_PLUS_INT:
case MCC_TAC_PLUS_FLOAT:
printf("> %s = %s + %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_MINUS_INT_BIN:
case MCC_TAC_MINUS_FLOAT_BIN:
printf("> %s = %s - %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_MUL_INT:
case MCC_TAC_MUL_FLOAT:
printf("> %s = %s * %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_DIV_INT:
case MCC_TAC_DIV_FLOAT:
printf("> %s = %s / %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_LT:
case MCC_TAC_LT_FLOAT:
printf("> %s = %s < %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_GT:
case MCC_TAC_GT_FLOAT:
printf("> %s = %s > %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_LTEQ:
case MCC_TAC_LTEQ_FLOAT:
printf("> %s = %s <= %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_GTEQ:
case MCC_TAC_GTEQ_FLOAT:
printf("> %s = %s >= %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_AND:
printf("> %s = %s && %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_OR:
printf("> %s = %s || %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_EQ:
case MCC_TAC_EQ_FLOAT:
case MCC_TAC_EQ_BOOL:
printf("> %s = %s == %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_NEQ:
case MCC_TAC_NEQ_FLOAT:
case MCC_TAC_NEQ_BOOL:
printf("> %s = %s != %s (%s)\n", entry->result, entry->arg1,
entry->arg2, op_type);
break;
case MCC_TAC_PARAM_BOOL:
case MCC_TAC_PARAM_INT:
case MCC_TAC_PARAM_FLOAT:
case MCC_TAC_PARAM_STRING:
printf("> param_push %s (%s)\n", entry->arg1, op_type);
break;
case MCC_TAC_LOAD_BOOL:
case MCC_TAC_LOAD_INT:
case MCC_TAC_LOAD_FLOAT:
case MCC_TAC_LOAD_STRING:
printf("> load %s[%s] %s (%s)\n", entry->arg1, entry->arg2,
entry->result, op_type);
break;
case MCC_TAC_STORE_BOOL:
case MCC_TAC_STORE_INT:
case MCC_TAC_STORE_FLOAT:
case MCC_TAC_STORE_STRING:
printf("> store %s[%s] %s (%s)\n", entry->result, entry->arg2,
entry->arg1, op_type);
break;
case MCC_TAC_JMP:
printf("> jump %s (%s)\n", entry->result, op_type);
break;
case MCC_TAC_JMP_FALSE:
printf("> jumpfalse %s %s (%s)\n", entry->arg1, entry->result,
op_type);
break;
case MCC_TAC_LABLE:
printf("\n");
printf("> label %s (%s)\n", entry->result, op_type);
break;
case MCC_TAC_CALL:
printf("> call %s %s (%s)\n", entry->result, entry->arg1, op_type);
break;
case MCC_TAC_RETURN:
case MCC_TAC_FUNCTION_END:
printf("> return (%s)\n", op_type);
break;
default: printf("ERROR\n");
}
}
}
\ No newline at end of file
test-files/test.mcc
+ 11
− 5
View file @ 3d66b0d8
int main() {
int a;
int b;
int max;
if (1 < 2) {
int a;
return 2;
a = 1;
b = 2;
if (a < b) {
max = b;
} else {
max = a;
}
return 0;
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment