From 80af509b111969ea789bf2c86464225fd98ee715 Mon Sep 17 00:00:00 2001
From: Clemens Paumgarten <clemenspaumgarten@gmail.com>
Date: Wed, 29 May 2019 21:45:38 +0200
Subject: [PATCH] channge argument to dynamic array
---
include/mcc/ast.h | 98 ++++----
src/ast.c | 430 +++++++++++++++++-------------------
src/ast_print.c | 114 +++++-----
src/ast_visit.c | 222 +++++++++----------
src/symbol_table_validate.c | 22 +-
5 files changed, 439 insertions(+), 447 deletions(-)
diff --git a/include/mcc/ast.h b/include/mcc/ast.h
index 6a0e7a1..5759ce5 100644
--- a/include/mcc/ast.h
+++ b/include/mcc/ast.h
@@ -12,6 +12,7 @@
// library to support boolean data type
#include <stdbool.h>
+#include "mcc/dynamic_array.h"
#ifndef MCC_AST_H
#define MCC_AST_H
@@ -42,11 +43,11 @@ struct mcc_ast_node {
enum mcc_ast_data_type {
- MCC_AST_DATA_TYPE_INT,
- MCC_AST_DATA_TYPE_STRING,
- MCC_AST_DATA_TYPE_BOOL,
- MCC_AST_DATA_TYPE_FLOAT,
- MCC_AST_DATA_TYPE_VOID
+ MCC_AST_DATA_TYPE_INT,
+ MCC_AST_DATA_TYPE_STRING,
+ MCC_AST_DATA_TYPE_BOOL,
+ MCC_AST_DATA_TYPE_FLOAT,
+ MCC_AST_DATA_TYPE_VOID
};
// ------------------------------------------------------------------ Operators
@@ -56,20 +57,20 @@ enum mcc_ast_binary_op {
MCC_AST_BINARY_OP_SUB,
MCC_AST_BINARY_OP_MUL,
MCC_AST_BINARY_OP_DIV,
- MCC_AST_BINARY_OP_AND,
- MCC_AST_BINARY_OP_OR,
- MCC_AST_BINARY_OP_EQUALS,
- MCC_AST_BINARY_OP_NOT_EQUALS,
- MCC_AST_BINARY_OP_LESS,
- MCC_AST_BINARY_OP_GREATER,
- MCC_AST_BINARY_OP_LESS_EQUALS,
- MCC_AST_BINARY_OP_GREATER_EQUALS,
+ MCC_AST_BINARY_OP_AND,
+ MCC_AST_BINARY_OP_OR,
+ MCC_AST_BINARY_OP_EQUALS,
+ MCC_AST_BINARY_OP_NOT_EQUALS,
+ MCC_AST_BINARY_OP_LESS,
+ MCC_AST_BINARY_OP_GREATER,
+ MCC_AST_BINARY_OP_LESS_EQUALS,
+ MCC_AST_BINARY_OP_GREATER_EQUALS,
};
enum mcc_ast_unary_op {
- MCC_AST_UNARY_OP_NOT,
- MCC_AST_UNARY_OP_MINUS
+ MCC_AST_UNARY_OP_NOT,
+ MCC_AST_UNARY_OP_MINUS
};
// ---------------------------------------------------------------- Expressions
@@ -134,23 +135,23 @@ mcc_ast_new_expression_identifier(struct mcc_ast_identifier *identifier);
struct mcc_ast_expression *
mcc_ast_new_expression_call_expression(struct mcc_ast_identifier *function_name,
- struct mcc_ast_argument *argument);
+ struct mcc_ast_argument *argument);
struct mcc_ast_expression *
mcc_ast_new_expression_unary_op(enum mcc_ast_unary_op op,
- struct mcc_ast_expression *expression);
+ struct mcc_ast_expression *expression);
struct mcc_ast_expression *
mcc_ast_new_expression_binary_op(enum mcc_ast_binary_op op,
- struct mcc_ast_expression *lhs,
- struct mcc_ast_expression *rhs);
+ struct mcc_ast_expression *lhs,
+ struct mcc_ast_expression *rhs);
struct mcc_ast_expression *
mcc_ast_new_expression_parenth(struct mcc_ast_expression *expression);
struct mcc_ast_expression *
mcc_ast_new_expression_bracket(struct mcc_ast_identifier *identifier,
- struct mcc_ast_expression *expression);
+ struct mcc_ast_expression *expression);
void mcc_ast_delete_expression(struct mcc_ast_expression *expression);
@@ -159,9 +160,10 @@ void mcc_ast_delete_expression(struct mcc_ast_expression *expression);
struct mcc_ast_argument {
struct mcc_ast_node node;
+ Dynamic_Array *expressions;
int size;
int max;
- struct mcc_ast_expression *expressions[];
+ // struct mcc_ast_expression *expressions[];
};
struct mcc_ast_argument *mcc_ast_new_argument(struct mcc_ast_expression *expression);
@@ -185,7 +187,7 @@ void mcc_ast_delete_identifier(struct mcc_ast_identifier *identifier);
// ------------------------------------------------------------------- Declaration
struct mcc_ast_declaration {
-
+
struct mcc_ast_node node;
enum mcc_ast_data_type type;
@@ -225,20 +227,20 @@ struct mcc_ast_assignment {
struct mcc_ast_assignment *
mcc_ast_new_assignment(struct mcc_ast_identifier *identifier,
- struct mcc_ast_expression *rhs);
+ struct mcc_ast_expression *rhs);
struct mcc_ast_assignment *
mcc_ast_new_array_assignment(struct mcc_ast_identifier *identifier,
- struct mcc_ast_expression *index,
- struct mcc_ast_expression *rhs);
+ struct mcc_ast_expression *index,
+ struct mcc_ast_expression *rhs);
void mcc_ast_delete_assignment(struct mcc_ast_assignment *assignment);
// ------------------------------------------------------------------- Statements
enum mcc_ast_statement_type {
- MCC_AST_STATEMENT_TYPE_EXPRESSION,
- MCC_AST_STATEMENT_TYPE_IF,
+ MCC_AST_STATEMENT_TYPE_EXPRESSION,
+ MCC_AST_STATEMENT_TYPE_IF,
MCC_AST_STATEMENT_TYPE_WHILE,
MCC_AST_STATEMENT_TYPE_DECL,
MCC_AST_STATEMENT_TYPE_ASSGN,
@@ -259,16 +261,16 @@ mcc_ast_new_statement_list(struct mcc_ast_statement *statement);
void mcc_ast_delete_statement_list(struct mcc_ast_statement_list *statement_list);
struct mcc_ast_statement {
- struct mcc_ast_node node;
+ struct mcc_ast_node node;
- enum mcc_ast_statement_type type;
+ enum mcc_ast_statement_type type;
- union {
+ union {
struct {
- enum mcc_ast_data_type data_type;
- struct mcc_ast_identifier *id_decl;
- };
+ enum mcc_ast_data_type data_type;
+ struct mcc_ast_identifier *id_decl;
+ };
struct {
struct mcc_ast_expression *if_condition;
@@ -289,17 +291,17 @@ struct mcc_ast_statement {
struct mcc_ast_expression *expression;
struct mcc_ast_statement_list *statement_list;
- };
+ };
};
struct mcc_ast_statement *mcc_ast_new_statement_expression (struct mcc_ast_expression *expression);
struct mcc_ast_statement *mcc_ast_new_statement_if(struct mcc_ast_expression *condition,
struct mcc_ast_statement *if_stmt,
- struct mcc_ast_statement *else_stmt);
+ struct mcc_ast_statement *else_stmt);
struct mcc_ast_statement *mcc_ast_new_statement_while(struct mcc_ast_expression *condition,
- struct mcc_ast_statement *while_stmt);
+ struct mcc_ast_statement *while_stmt);
struct mcc_ast_statement *mcc_ast_new_statement_assignment(struct mcc_ast_assignment *assignment);
@@ -356,8 +358,8 @@ void mcc_ast_empty_node();
// int PARAMETER_BLOCK_SIZE = 4;
struct mcc_ast_parameter {
struct mcc_ast_node node;
- int max;
- int size;
+ int max;
+ int size;
struct mcc_ast_declaration *parameters[];
};
@@ -369,19 +371,19 @@ void mcc_ast_delete_parameter(struct mcc_ast_parameter *parameter);
// -------------------------------------------------------------------- Function
struct mcc_ast_function {
- struct mcc_ast_node node;
+ struct mcc_ast_node node;
- enum mcc_ast_data_type return_type;
- struct mcc_ast_identifier *identifier;
- struct mcc_ast_parameter *parameter;
+ enum mcc_ast_data_type return_type;
+ struct mcc_ast_identifier *identifier;
+ struct mcc_ast_parameter *parameter;
struct mcc_ast_statement *statement;
};
struct mcc_ast_function *mcc_ast_new_function(
- enum mcc_ast_data_type return_type,
- struct mcc_ast_identifier *identifier,
- struct mcc_ast_parameter *parameter,
- struct mcc_ast_statement *statement
+ enum mcc_ast_data_type return_type,
+ struct mcc_ast_identifier *identifier,
+ struct mcc_ast_parameter *parameter,
+ struct mcc_ast_statement *statement
);
void mcc_ast_delete_function(struct mcc_ast_function *function);
@@ -391,8 +393,8 @@ void mcc_ast_delete_function(struct mcc_ast_function *function);
struct mcc_ast_program {
struct mcc_ast_node node;
- int max;
- int size;
+ int max;
+ int size;
struct mcc_ast_function* function_def[];
};
diff --git a/src/ast.c b/src/ast.c
index a0c51ba..2507982 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -30,7 +30,7 @@ mcc_ast_new_expression_literal(struct mcc_ast_literal *literal)
struct mcc_ast_expression *
mcc_ast_new_expression_unary_op(enum mcc_ast_unary_op op,
- struct mcc_ast_expression *expression)
+ struct mcc_ast_expression *expression)
{
assert(expression);
@@ -43,13 +43,13 @@ mcc_ast_new_expression_unary_op(enum mcc_ast_unary_op op,
expr->unary_op = op;
expr->unary_expression = expression;
- return expr;
+ return expr;
}
struct mcc_ast_expression *
mcc_ast_new_expression_binary_op(enum mcc_ast_binary_op op,
- struct mcc_ast_expression *lhs,
- struct mcc_ast_expression *rhs)
+ struct mcc_ast_expression *lhs,
+ struct mcc_ast_expression *rhs)
{
assert(lhs);
assert(rhs);
@@ -83,7 +83,7 @@ mcc_ast_new_expression_parenth(struct mcc_ast_expression *expression)
struct mcc_ast_expression *
mcc_ast_new_expression_bracket(struct mcc_ast_identifier *identifier,
- struct mcc_ast_expression *expression)
+ struct mcc_ast_expression *expression)
{
assert(identifier);
assert(expression);
@@ -120,37 +120,37 @@ void mcc_ast_delete_expression(struct mcc_ast_expression *expression)
assert(expression);
switch (expression->type) {
- case MCC_AST_EXPRESSION_TYPE_LITERAL:
- mcc_ast_delete_literal(expression->literal);
- break;
-
- case MCC_AST_EXPRESSION_TYPE_IDENTIFIER:
- mcc_ast_delete_identifier(expression->identifier);
- break;
-
- case MCC_AST_EXPRESSION_TYPE_UNARY_OP:
- mcc_ast_delete_expression(expression->unary_expression);
- break;
-
- case MCC_AST_EXPRESSION_TYPE_BINARY_OP:
- mcc_ast_delete_expression(expression->lhs);
- mcc_ast_delete_expression(expression->rhs);
- break;
-
- case MCC_AST_EXPRESSION_TYPE_PARENTH:
- mcc_ast_delete_expression(expression->expression);
- break;
-
- case MCC_AST_EXPRESSION_TYPE_BRACKET:
- mcc_ast_delete_identifier(expression->bracket_identifier);
- mcc_ast_delete_expression(expression->bracket_expression);
- break;
- case MCC_AST_EXPRESSION_TYPE_CALL_EXPRESSION:
- mcc_ast_delete_identifier(expression->bracket_identifier);
- if(expression->argument != NULL){
- mcc_ast_delete_argument(expression->argument);
- }
- break;
+ case MCC_AST_EXPRESSION_TYPE_LITERAL:
+ mcc_ast_delete_literal(expression->literal);
+ break;
+
+ case MCC_AST_EXPRESSION_TYPE_IDENTIFIER:
+ mcc_ast_delete_identifier(expression->identifier);
+ break;
+
+ case MCC_AST_EXPRESSION_TYPE_UNARY_OP:
+ mcc_ast_delete_expression(expression->unary_expression);
+ break;
+
+ case MCC_AST_EXPRESSION_TYPE_BINARY_OP:
+ mcc_ast_delete_expression(expression->lhs);
+ mcc_ast_delete_expression(expression->rhs);
+ break;
+
+ case MCC_AST_EXPRESSION_TYPE_PARENTH:
+ mcc_ast_delete_expression(expression->expression);
+ break;
+
+ case MCC_AST_EXPRESSION_TYPE_BRACKET:
+ mcc_ast_delete_identifier(expression->bracket_identifier);
+ mcc_ast_delete_expression(expression->bracket_expression);
+ break;
+ case MCC_AST_EXPRESSION_TYPE_CALL_EXPRESSION:
+ mcc_ast_delete_identifier(expression->bracket_identifier);
+ if(expression->argument != NULL){
+ mcc_ast_delete_argument(expression->argument);
+ }
+ break;
}
free(expression);
@@ -158,17 +158,17 @@ void mcc_ast_delete_expression(struct mcc_ast_expression *expression)
struct mcc_ast_expression *
mcc_ast_new_expression_call_expression(struct mcc_ast_identifier *function_name,
- struct mcc_ast_argument *argument)
+ struct mcc_ast_argument *argument)
{
- assert(function_name);
+ assert(function_name);
- struct mcc_ast_expression *expression = malloc(sizeof(*expression));
+ struct mcc_ast_expression *expression = malloc(sizeof(*expression));
- expression -> type = MCC_AST_EXPRESSION_TYPE_CALL_EXPRESSION;
+ expression -> type = MCC_AST_EXPRESSION_TYPE_CALL_EXPRESSION;
expression -> function_name = function_name;
- expression -> argument = argument;
+ expression -> argument = argument;
- return expression;
+ return expression;
}
// ------------------------------------------------------------------- Literals
@@ -209,7 +209,7 @@ struct mcc_ast_literal *mcc_ast_new_literal_string(char *value)
assert(lit);
char *copyValue = malloc(sizeof(char) * (strlen(value) + 4));
- strcpy(copyValue, value);
+ strcpy(copyValue, value);
lit->type = MCC_AST_DATA_TYPE_STRING;
lit->s_value = copyValue;
@@ -250,7 +250,7 @@ void mcc_ast_delete_identifier(struct mcc_ast_identifier *identifier)
struct mcc_ast_declaration *mcc_ast_new_declaration(enum mcc_ast_data_type type, struct mcc_ast_literal *arr_size, struct mcc_ast_identifier *ident)
{
- assert(ident);
+ assert(ident);
struct mcc_ast_declaration *decl = malloc(sizeof(*decl));
if (!decl) {
@@ -265,8 +265,8 @@ struct mcc_ast_declaration *mcc_ast_new_declaration(enum mcc_ast_data_type type,
void mcc_ast_delete_declaration(struct mcc_ast_declaration *declaration)
{
- assert(declaration);
- mcc_ast_delete_identifier(declaration->ident);
+ assert(declaration);
+ mcc_ast_delete_identifier(declaration->ident);
if (declaration->arr_literal) {
mcc_ast_delete_literal(declaration->arr_literal);
}
@@ -277,7 +277,7 @@ void mcc_ast_delete_declaration(struct mcc_ast_declaration *declaration)
struct mcc_ast_assignment *
mcc_ast_new_assignment(struct mcc_ast_identifier *identifier,
- struct mcc_ast_expression *rhs)
+ struct mcc_ast_expression *rhs)
{
assert(identifier);
assert(rhs);
@@ -293,8 +293,8 @@ mcc_ast_new_assignment(struct mcc_ast_identifier *identifier,
struct mcc_ast_assignment *
mcc_ast_new_array_assignment(struct mcc_ast_identifier *identifier,
- struct mcc_ast_expression *index,
- struct mcc_ast_expression *rhs)
+ struct mcc_ast_expression *index,
+ struct mcc_ast_expression *rhs)
{
assert(identifier);
assert(index);
@@ -330,7 +330,7 @@ struct mcc_ast_statement *mcc_ast_new_statement_expression(struct mcc_ast_expres
assert(expression);
struct mcc_ast_statement *stmt = malloc(sizeof(*stmt));
- assert(stmt);
+ assert(stmt);
stmt -> type = MCC_AST_STATEMENT_TYPE_EXPRESSION;
stmt -> expression = expression;
@@ -339,56 +339,56 @@ struct mcc_ast_statement *mcc_ast_new_statement_expression(struct mcc_ast_expres
struct mcc_ast_statement *mcc_ast_new_statement_if(struct mcc_ast_expression *condition,
- struct mcc_ast_statement *if_stmt,
- struct mcc_ast_statement *else_stmt)
+ struct mcc_ast_statement *if_stmt,
+ struct mcc_ast_statement *else_stmt)
{
- assert(condition);
- assert(if_stmt);
+ assert(condition);
+ assert(if_stmt);
- struct mcc_ast_statement *stmt = malloc(sizeof(*stmt));
+ struct mcc_ast_statement *stmt = malloc(sizeof(*stmt));
- stmt -> type = MCC_AST_STATEMENT_TYPE_IF;
- stmt->if_condition = condition;
- stmt -> if_stmt = if_stmt;
- stmt->else_stmt = else_stmt;
- return stmt;
+ stmt -> type = MCC_AST_STATEMENT_TYPE_IF;
+ stmt->if_condition = condition;
+ stmt -> if_stmt = if_stmt;
+ stmt->else_stmt = else_stmt;
+ return stmt;
}
struct mcc_ast_statement *mcc_ast_new_statement_declaration(struct mcc_ast_declaration *declaration)
{
- assert(declaration);
+ assert(declaration);
- struct mcc_ast_statement *stmt = malloc(sizeof(*stmt));
- if (!stmt) {
+ struct mcc_ast_statement *stmt = malloc(sizeof(*stmt));
+ if (!stmt) {
return NULL;
}
- stmt-> declaration = declaration;
- stmt -> type = MCC_AST_STATEMENT_TYPE_DECL;
-
- return stmt;
+ stmt-> declaration = declaration;
+ stmt -> type = MCC_AST_STATEMENT_TYPE_DECL;
+
+ return stmt;
}
struct mcc_ast_statement *mcc_ast_new_statement_while(struct mcc_ast_expression *condition,
- struct mcc_ast_statement *while_stmt)
+ struct mcc_ast_statement *while_stmt)
{
- assert(condition);
- assert(while_stmt);
+ assert(condition);
+ assert(while_stmt);
- struct mcc_ast_statement *stmt = malloc(sizeof(*stmt));
+ struct mcc_ast_statement *stmt = malloc(sizeof(*stmt));
- stmt -> type = MCC_AST_STATEMENT_TYPE_WHILE;
- stmt -> while_condition = condition;
- stmt -> while_stmt = while_stmt;
+ stmt -> type = MCC_AST_STATEMENT_TYPE_WHILE;
+ stmt -> while_condition = condition;
+ stmt -> while_stmt = while_stmt;
- return stmt;
+ return stmt;
}
struct mcc_ast_statement *mcc_ast_new_statement(struct mcc_ast_statement *statement){
- assert(statement);
+ assert(statement);
- struct mcc_ast_statement *stmt = malloc(sizeof(*stmt));
- return statement;
+ struct mcc_ast_statement *stmt = malloc(sizeof(*stmt));
+ return statement;
}
struct mcc_ast_statement_list *
@@ -399,12 +399,12 @@ mcc_ast_new_statement_list(struct mcc_ast_statement *statement)
assert(list);
list->statement = statement;
-
+
return list;
}
void mcc_ast_delete_statement_list(
- struct mcc_ast_statement_list *statement_list)
+ struct mcc_ast_statement_list *statement_list)
{
assert(statement_list);
if (statement_list->next != NULL) {
@@ -420,23 +420,23 @@ mcc_ast_new_statement_compound(struct mcc_ast_statement_list *statement)
assert(stmt);
stmt -> type = MCC_AST_STATEMENT_TYPE_COMPOUND;
- stmt -> statement_list = statement;
+ stmt -> statement_list = statement;
- return stmt;
+ return stmt;
}
struct mcc_ast_statement *mcc_ast_new_statement_assignment(struct mcc_ast_assignment *assignment)
{
- assert(assignment);
-
- struct mcc_ast_statement *stmt = malloc(sizeof(*stmt));
- assert(stmt);
+ assert(assignment);
- stmt->type = assignment->type == MCC_AST_ASSIGNMENT_TYPE_NORMAL
- ? MCC_AST_STATEMENT_TYPE_ASSGN
- : MCC_AST_STATEMENT_TYPE_ASSGN_ARR;
+ struct mcc_ast_statement *stmt = malloc(sizeof(*stmt));
+ assert(stmt);
+
+ stmt->type = assignment->type == MCC_AST_ASSIGNMENT_TYPE_NORMAL
+ ? MCC_AST_STATEMENT_TYPE_ASSGN
+ : MCC_AST_STATEMENT_TYPE_ASSGN_ARR;
stmt->assignment = assignment;
- return stmt;
+ return stmt;
}
struct mcc_ast_statement *mcc_ast_new_statement_return(struct mcc_ast_expression *expression)
@@ -447,46 +447,46 @@ struct mcc_ast_statement *mcc_ast_new_statement_return(struct mcc_ast_expression
}
stmt->type = MCC_AST_STATEMENT_TYPE_RETURN;
stmt->expression = expression;
-
+
return stmt;
}
void mcc_ast_delete_statement(struct mcc_ast_statement *statement)
{
- assert(statement);
-
- switch(statement->type){
- case MCC_AST_STATEMENT_TYPE_EXPRESSION:
- mcc_ast_delete_expression(statement->expression);
- break;
- case MCC_AST_STATEMENT_TYPE_IF:
- mcc_ast_delete_expression(statement->if_condition);
- mcc_ast_delete_statement(statement->if_stmt);
- if(statement->else_stmt != NULL){
- mcc_ast_delete_statement(statement->else_stmt);
- }
- break;
- case MCC_AST_STATEMENT_TYPE_WHILE:
- mcc_ast_delete_expression(statement->while_condition);
- mcc_ast_delete_statement(statement->while_stmt);
- break;
- case MCC_AST_STATEMENT_TYPE_DECL:
- mcc_ast_delete_declaration(statement->declaration);
- break;
- case MCC_AST_STATEMENT_TYPE_ASSGN:
- case MCC_AST_STATEMENT_TYPE_ASSGN_ARR:
- mcc_ast_delete_assignment(statement->assignment);
- break;
- case MCC_AST_STATEMENT_TYPE_COMPOUND:
- if(statement -> statement_list != NULL){
- mcc_ast_delete_statement_list(statement->statement_list);
- }
- break;
+ assert(statement);
+
+ switch(statement->type){
+ case MCC_AST_STATEMENT_TYPE_EXPRESSION:
+ mcc_ast_delete_expression(statement->expression);
+ break;
+ case MCC_AST_STATEMENT_TYPE_IF:
+ mcc_ast_delete_expression(statement->if_condition);
+ mcc_ast_delete_statement(statement->if_stmt);
+ if(statement->else_stmt != NULL){
+ mcc_ast_delete_statement(statement->else_stmt);
+ }
+ break;
+ case MCC_AST_STATEMENT_TYPE_WHILE:
+ mcc_ast_delete_expression(statement->while_condition);
+ mcc_ast_delete_statement(statement->while_stmt);
+ break;
+ case MCC_AST_STATEMENT_TYPE_DECL:
+ mcc_ast_delete_declaration(statement->declaration);
+ break;
+ case MCC_AST_STATEMENT_TYPE_ASSGN:
+ case MCC_AST_STATEMENT_TYPE_ASSGN_ARR:
+ mcc_ast_delete_assignment(statement->assignment);
+ break;
+ case MCC_AST_STATEMENT_TYPE_COMPOUND:
+ if(statement -> statement_list != NULL){
+ mcc_ast_delete_statement_list(statement->statement_list);
+ }
+ break;
case MCC_AST_STATEMENT_TYPE_RETURN:
mcc_ast_delete_expression(statement->expression);
break;
- default : break;
- }
+ default : break;
+ }
}
void mcc_ast_empty_node() {
@@ -498,121 +498,108 @@ void mcc_ast_empty_node() {
struct mcc_ast_parameter *mcc_ast_new_parameter(struct mcc_ast_declaration *declaration, struct mcc_ast_parameter *params)
{
assert(declaration);
- // assert(params);
-
- if (params == NULL) {
- struct mcc_ast_parameter *param = malloc(sizeof(*param) + sizeof(struct mcc_ast_declaration*) * MCC_PARAMETER_DECLARATION_SIZE);
- param -> size = 1;
- param -> max = MCC_PARAMETER_DECLARATION_SIZE;
- param -> parameters[0] = declaration;
- return param;
- }
-
- // add to previous params list
- if ((params -> size) > (params -> max)) {
- int size = params -> size;
- struct mcc_ast_parameter *new_params = realloc(params, sizeof(*params) + sizeof(struct mcc_ast_declaration*) * MCC_PARAMETER_DECLARATION_SIZE);
+ // assert(params);
+
+ if (params == NULL) {
+ struct mcc_ast_parameter *param = malloc(sizeof(*param) + sizeof(struct mcc_ast_declaration*) * MCC_PARAMETER_DECLARATION_SIZE);
+ param -> size = 1;
+ param -> max = MCC_PARAMETER_DECLARATION_SIZE;
+ param -> parameters[0] = declaration;
+ return param;
+ }
+
+ // add to previous params list
+ if ((params -> size) > (params -> max)) {
+ int size = params -> size;
+ struct mcc_ast_parameter *new_params = realloc(params, sizeof(*params) + sizeof(struct mcc_ast_declaration*) * MCC_PARAMETER_DECLARATION_SIZE);
if(new_params == NULL ){
mcc_ast_delete_parameter(params);
return NULL;
}
- new_params -> parameters[size] = declaration;
- new_params -> size += 1;
- new_params -> max += MCC_PARAMETER_DECLARATION_SIZE;
- } else {
- params -> parameters[(params -> size)] = declaration;
- params -> size += 1;
- }
+ new_params -> parameters[size] = declaration;
+ new_params -> size += 1;
+ new_params -> max += MCC_PARAMETER_DECLARATION_SIZE;
+ } else {
+ params -> parameters[(params -> size)] = declaration;
+ params -> size += 1;
+ }
- return params;
+ return params;
}
void mcc_ast_delete_parameter(struct mcc_ast_parameter *parameter) {
- if (parameter != NULL) {
- for (int i = 0; i < parameter -> size; i++) {
- mcc_ast_delete_declaration(parameter -> parameters[i]);
- }
+ if (parameter != NULL) {
+ for (int i = 0; i < parameter -> size; i++) {
+ mcc_ast_delete_declaration(parameter -> parameters[i]);
+ }
- free(parameter);
- }
+ free(parameter);
+ }
}
// ------------------------------------------------------------------- Arguments
struct mcc_ast_argument *mcc_ast_new_argument(struct mcc_ast_expression *expression) {
- assert(expression);
-
- struct mcc_ast_argument *argument = malloc(sizeof(*argument) + sizeof(struct mcc_ast_expression*) * MCC_ARGUMENT_EXPRESSION_SIZE);
+ assert(expression);
- argument -> expressions[0] = expression;
- argument -> size = 1;
- argument -> max = MCC_ARGUMENT_EXPRESSION_SIZE;
+ struct mcc_ast_argument *argument = malloc(sizeof(*argument));
- return argument;
+ argument -> expressions = mcc_create_dynamic_array(MCC_ARGUMENT_EXPRESSION_SIZE);
}
struct mcc_ast_argument *mcc_ast_add_new_argument(struct mcc_ast_expression *expression, struct mcc_ast_argument *argument) {
- assert(argument);
- assert(expression);
+ assert(argument);
+ assert(expression);
- int size = argument -> size;
- int max = argument -> max;
+ if (mcc_add_to_array(argument -> expressions, expression) == 1) {
+ return NULL;
+ }
- if (size < max) {
- argument -> expressions[size] = expression;
- argument -> size += 1;
- } else {
- argument = realloc(argument, sizeof(*argument) + sizeof(struct mcc_ast_expression*) * MCC_ARGUMENT_EXPRESSION_SIZE);
- if(argument == NULL ){
- mcc_ast_delete_argument(argument);
- return NULL;
- }
- argument -> expressions[size] = expression;
- argument -> size += 1;
- argument -> max += MCC_ARGUMENT_EXPRESSION_SIZE;
- }
+ return argument;
+}
- return argument;
+// cast void pointer to expression pointer
+void delete_argument_expression(void *expression) {
+ struct mcc_ast_expression *e = (struct mcc_ast_expression *) expression;
+ mcc_ast_delete_expression(e);
}
void mcc_ast_delete_argument(struct mcc_ast_argument *argument) {
- assert(argument);
- for(int i = 0; i < argument -> size; i++) {
- mcc_ast_delete_expression(argument -> expressions[i]);
- }
+ assert(argument);
- free(argument);
+ mcc_delete_array(argument -> expressions, delete_argument_expression);
+ free(argument);
}
// ------------------------------------------------------------------- Function
struct mcc_ast_function *mcc_ast_new_function(
- enum mcc_ast_data_type return_type,
- struct mcc_ast_identifier *identifier,
- struct mcc_ast_parameter *parameter,
- struct mcc_ast_statement *statement
+ enum mcc_ast_data_type return_type,
+ struct mcc_ast_identifier *identifier,
+ struct mcc_ast_parameter *parameter,
+ struct mcc_ast_statement *statement
)
{
- assert(identifier);
+ assert(identifier);
- struct mcc_ast_function *func = malloc(sizeof(*func));
+ struct mcc_ast_function *func = malloc(sizeof(*func));
- func -> return_type = return_type;
- func -> identifier = identifier;
+ func -> return_type = return_type;
+ func -> identifier = identifier;
- if (parameter != NULL) {
- func -> parameter = parameter;
- }
+ if (parameter != NULL) {
+ func -> parameter = parameter;
+ }
- func -> statement = statement;
+ func -> statement = statement;
- return func;
+ return func;
}
void mcc_ast_delete_function(struct mcc_ast_function *function) {
- assert(function);
- mcc_ast_delete_identifier(function -> identifier);
+ assert(function);
+ mcc_ast_delete_identifier(function -> identifier);
if (function -> parameter != NULL) {
mcc_ast_delete_parameter(function -> parameter);
@@ -622,58 +609,55 @@ void mcc_ast_delete_function(struct mcc_ast_function *function) {
mcc_ast_delete_statement(function -> statement);
}
- free(function);
+ free(function);
}
// ------------------------------------------------------------------- Program
struct mcc_ast_program *mcc_ast_new_program(struct mcc_ast_function *function_def) {
- assert(function_def);
+ assert(function_def);
struct mcc_ast_program *p = malloc(sizeof(*p) + sizeof(struct mcc_ast_function*) * MCC_PROGRAM_FUNCTION_DEF_SIZE);
- p -> size = 1;
- p -> max = MCC_PROGRAM_FUNCTION_DEF_SIZE;
- p -> function_def[0] = function_def;
+ p -> size = 1;
+ p -> max = MCC_PROGRAM_FUNCTION_DEF_SIZE;
+ p -> function_def[0] = function_def;
- return p;
+ return p;
}
struct mcc_ast_program *mcc_ast_add_function(struct mcc_ast_function *function_def, struct mcc_ast_program *program)
{
- assert(program);
- assert(function_def);
+ assert(program);
+ assert(function_def);
- int size = program -> size;
- if (program -> size < program -> max) {
- program -> function_def[size] = function_def;
- program -> size += 1;
- } else {
+ int size = program -> size;
+ if (program -> size < program -> max) {
+ program -> function_def[size] = function_def;
+ program -> size += 1;
+ } else {
- program = realloc(program, sizeof(*program) + sizeof(struct mcc_ast_function*) * MCC_PROGRAM_FUNCTION_DEF_SIZE);
+ program = realloc(program, sizeof(*program) + sizeof(struct mcc_ast_function*) * MCC_PROGRAM_FUNCTION_DEF_SIZE);
if(program == NULL ){
mcc_ast_delete_program(program);
return NULL;
}
- program -> max += MCC_PROGRAM_FUNCTION_DEF_SIZE;
- program -> function_def[size] = function_def;
- program -> size += 1;
- }
+ program -> max += MCC_PROGRAM_FUNCTION_DEF_SIZE;
+ program -> function_def[size] = function_def;
+ program -> size += 1;
+ }
- return program;
+ return program;
}
void mcc_ast_delete_program(struct mcc_ast_program *program)
{
- assert(program);
-
- for (int i = 0; i < program -> size; i++) {
- mcc_ast_delete_function(program -> function_def[i]);
-
- }
-
- free(program);
-}
+ assert(program);
+ for (int i = 0; i < program -> size; i++) {
+ mcc_ast_delete_function(program -> function_def[i]);
+ }
+ free(program);
+}
diff --git a/src/ast_print.c b/src/ast_print.c
index 9024cae..3afe920 100644
--- a/src/ast_print.c
+++ b/src/ast_print.c
@@ -9,8 +9,8 @@
const char *mcc_ast_print_unary_op(enum mcc_ast_unary_op op)
{
switch (op) {
- case MCC_AST_UNARY_OP_MINUS: return "-";
- case MCC_AST_UNARY_OP_NOT: return "!";
+ case MCC_AST_UNARY_OP_MINUS: return "-";
+ case MCC_AST_UNARY_OP_NOT: return "!";
}
return "unknown op";
@@ -82,8 +82,8 @@ const char *mcc_ast_print_statement(enum mcc_ast_statement_type stmt_type)
return "ASSGN_STMT";
case MCC_AST_STATEMENT_TYPE_COMPOUND:
return "COMPOUND_STMT";
- case MCC_AST_STATEMENT_TYPE_ASSGN_ARR:
- return "TYPE ARR STMT";
+ case MCC_AST_STATEMENT_TYPE_ASSGN_ARR:
+ return "TYPE ARR STMT";
case MCC_AST_STATEMENT_TYPE_RETURN:
return "RETURN_STMT";
}
@@ -101,7 +101,7 @@ static void print_dot_begin(FILE *out)
assert(out);
fprintf(out, "digraph \"AST\" {\n"
- "\tnodesep=0.6\n");
+ "\tnodesep=0.6\n");
}
static void print_dot_end(FILE *out)
@@ -149,7 +149,7 @@ static void print_dot_expression_unary_op(struct mcc_ast_expression *expression,
char label[LABEL_SIZE] = { 0 };
snprintf(label, sizeof(label), "expr: %s",
- mcc_ast_print_unary_op(expression->unary_op));
+ mcc_ast_print_unary_op(expression->unary_op));
FILE *out = data;
print_dot_node(out, expression, label);
@@ -302,19 +302,19 @@ static void print_dot_statement_assignment( struct mcc_ast_statement *statement,
assert(statement);
assert(data);
assert(statement->type == MCC_AST_STATEMENT_TYPE_ASSGN ||
- statement->type == MCC_AST_STATEMENT_TYPE_ASSGN_ARR);
+ statement->type == MCC_AST_STATEMENT_TYPE_ASSGN_ARR);
FILE *out = data;
print_dot_edge(out, statement, statement->assignment->identifier,
- "identifier");
+ "identifier");
if (statement->assignment->type == MCC_AST_ASSIGNMENT_TYPE_NORMAL) {
print_dot_edge(out, statement, statement->assignment->normal_ass.rhs,
- "rhs");
+ "rhs");
} else {
print_dot_edge(out, statement, statement->assignment->array_ass.index,
- "index");
+ "index");
print_dot_edge(out, statement, statement->assignment->array_ass.rhs,
- "rhs");
+ "rhs");
}
}
@@ -352,7 +352,7 @@ static void print_dot_statement_list(struct mcc_ast_statement_list *statement_li
print_dot_edge(out, statement_list, statement_list->statement, "statement");
if (statement_list->next != NULL) {
print_dot_edge(out, statement_list, statement_list->next,
- "next statement");
+ "next statement");
}
}
@@ -365,12 +365,12 @@ static void print_dot_statement_compound( struct mcc_ast_statement *statement, v
FILE *out = data;
if (statement->statement_list != NULL) {
print_dot_edge(out, statement, statement->statement_list,
- "statement list");
+ "statement list");
}
}
static void print_dot_statement_return(
- struct mcc_ast_statement *statement, void *data)
+ struct mcc_ast_statement *statement, void *data)
{
assert(statement);
assert(data);
@@ -385,14 +385,14 @@ static void print_dot_statement_return(
// ------------------------------------------------------------------- Declaration
static void print_dot_declaration(struct mcc_ast_declaration *declaration,
- void *data)
+ void *data)
{
assert(declaration);
assert(data);
char label[LABEL_SIZE] = { 0 };
snprintf(label, sizeof(label), "decl: %s",
- mcc_ast_print_data_type(declaration->type));
+ mcc_ast_print_data_type(declaration->type));
FILE *out = data;
print_dot_node(out, declaration, label);
@@ -411,11 +411,11 @@ static void print_dot_parameter(struct mcc_ast_parameter *parameter, void *data)
FILE *out = data;
print_dot_node(out, parameter, "param: decl");
- for (int i = 0; i <= parameter->size; ++i) {
+ for (int i = 0; i <= parameter->size; ++i) {
if(parameter->parameters[i] != NULL){
print_dot_edge(out, parameter, parameter->parameters[i], "declaration");
}
-
+
}
}
@@ -428,11 +428,11 @@ static void print_dot_argument(struct mcc_ast_argument *argument, void *data)
FILE *out = data;
print_dot_node(out, argument, "arguments ");
- for (int i = 0; i < argument->size; ++i) {
- if(argument->expressions[i] != NULL){
- print_dot_edge(out, argument, argument->expressions[i], "arg expression");
+ for (int i = 0; i < argument->size; ++i) {
+ if(argument->expressions -> arr[i] != NULL){
+ print_dot_edge(out, argument, argument->expressions -> arr[i], "arg expression");
}
-
+
}
}
@@ -469,7 +469,7 @@ static void print_dot_program(struct mcc_ast_program *program, void *data)
print_dot_node(out, program, "program");
for (int i = 0; i < program->size; i++) {
print_dot_edge(out, program, program->function_def[i],
- "function_definition");
+ "function_definition");
}
}
@@ -479,39 +479,39 @@ static struct mcc_ast_visitor print_dot_visitor(FILE *out)
assert(out);
return (struct mcc_ast_visitor){
- .traversal = MCC_AST_VISIT_DEPTH_FIRST,
- .order = MCC_AST_VISIT_PRE_ORDER,
-
- .userdata = out,
-
- .expression_literal = print_dot_expression_literal,
- .expression_unary_op = print_dot_expression_unary_op,
- .expression_binary_op = print_dot_expression_binary_op,
- .expression_parenth = print_dot_expression_parenth,
- .expression_identifier = print_dot_expression_identifier,
- .expression_call_expression = print_dot_expression_call_expression,
-
- .literal_bool = print_dot_literal_bool,
- .literal_int = print_dot_literal_int,
- .literal_float = print_dot_literal_float,
- .literal_string = print_dot_literal_string,
- .identifier = print_dot_identifier,
-
- .statement_expression = print_dot_statement_expression,
- .statement_assignment = print_dot_statement_assignment,
- .statement_declaration = print_dot_statement_declaration,
- .statement_if = print_dot_statement_if,
- .statement_while = print_dot_statement_while,
- .statement_compound = print_dot_statement_compound,
- .statement_list = print_dot_statement_list,
- .statement_return = print_dot_statement_return,
-
- .declaration = print_dot_declaration,
-
- .function = print_dot_function,
- .parameter = print_dot_parameter,
- .argument = print_dot_argument,
- .program = print_dot_program,
+ .traversal = MCC_AST_VISIT_DEPTH_FIRST,
+ .order = MCC_AST_VISIT_PRE_ORDER,
+
+ .userdata = out,
+
+ .expression_literal = print_dot_expression_literal,
+ .expression_unary_op = print_dot_expression_unary_op,
+ .expression_binary_op = print_dot_expression_binary_op,
+ .expression_parenth = print_dot_expression_parenth,
+ .expression_identifier = print_dot_expression_identifier,
+ .expression_call_expression = print_dot_expression_call_expression,
+
+ .literal_bool = print_dot_literal_bool,
+ .literal_int = print_dot_literal_int,
+ .literal_float = print_dot_literal_float,
+ .literal_string = print_dot_literal_string,
+ .identifier = print_dot_identifier,
+
+ .statement_expression = print_dot_statement_expression,
+ .statement_assignment = print_dot_statement_assignment,
+ .statement_declaration = print_dot_statement_declaration,
+ .statement_if = print_dot_statement_if,
+ .statement_while = print_dot_statement_while,
+ .statement_compound = print_dot_statement_compound,
+ .statement_list = print_dot_statement_list,
+ .statement_return = print_dot_statement_return,
+
+ .declaration = print_dot_declaration,
+
+ .function = print_dot_function,
+ .parameter = print_dot_parameter,
+ .argument = print_dot_argument,
+ .program = print_dot_program,
};
}
@@ -558,7 +558,7 @@ void mcc_ast_print_dot_declaration(FILE *out, struct mcc_ast_declaration *declar
void mcc_ast_print_dot_program(FILE *out, struct mcc_ast_program *program)
{
assert(out);
- assert(program);
+ assert(program);
print_dot_begin(out);
diff --git a/src/ast_visit.c b/src/ast_visit.c
index b3107f6..dc5c1c6 100644
--- a/src/ast_visit.c
+++ b/src/ast_visit.c
@@ -31,48 +31,48 @@ void mcc_ast_visit_expression(struct mcc_ast_expression *expression, struct mcc_
visit_if_pre_order(expression, visitor->expression, visitor);
switch (expression->type) {
- case MCC_AST_EXPRESSION_TYPE_LITERAL:
- visit_if_pre_order(expression, visitor->expression_literal, visitor);
- mcc_ast_visit_literal(expression->literal, visitor);
- visit_if_post_order(expression, visitor->expression_literal, visitor);
- break;
-
- case MCC_AST_EXPRESSION_TYPE_BINARY_OP:
- visit_if_pre_order(expression, visitor->expression_binary_op, visitor);
- mcc_ast_visit_expression(expression->lhs, visitor);
- mcc_ast_visit_expression(expression->rhs, visitor);
- visit_if_post_order(expression, visitor->expression_binary_op, visitor);
- break;
-
- case MCC_AST_EXPRESSION_TYPE_UNARY_OP:
- visit_if_pre_order(expression, visitor->expression_unary_op,visitor);
- mcc_ast_visit_expression(expression->unary_expression, visitor);
- visit_if_post_order(expression, visitor->expression_unary_op, visitor);
- break;
-
- case MCC_AST_EXPRESSION_TYPE_PARENTH:
- visit_if_pre_order(expression, visitor->expression_parenth, visitor);
- mcc_ast_visit_expression(expression->expression, visitor);
- visit_if_post_order(expression, visitor->expression_parenth, visitor);
- break;
- case MCC_AST_EXPRESSION_TYPE_IDENTIFIER:
- visit_if_pre_order(expression, visitor->expression_identifier, visitor);
- mcc_ast_visit_identifier(expression->identifier, visitor);
- visit_if_post_order(expression, visitor->expression_identifier, visitor);
- break;
- case MCC_AST_EXPRESSION_TYPE_CALL_EXPRESSION:
- visit_if_pre_order(expression, visitor->expression_call_expression, visitor);
- mcc_ast_visit_identifier(expression->function_name,visitor);
- if (expression->argument != NULL) {
- mcc_ast_visit_argument(expression->argument, visitor);
- }
- visit_if_post_order(expression, visitor->expression_parenth, visitor);
- break;
- case MCC_AST_EXPRESSION_TYPE_BRACKET:
- visit_if_pre_order(expression,visitor->expression_bracket,visitor);
- mcc_ast_visit_identifier(expression->bracket_identifier,visitor);
- mcc_ast_visit_expression(expression->bracket_expression,visitor);
- visit_if_post_order(expression,visitor->expression_bracket,visitor);
+ case MCC_AST_EXPRESSION_TYPE_LITERAL:
+ visit_if_pre_order(expression, visitor->expression_literal, visitor);
+ mcc_ast_visit_literal(expression->literal, visitor);
+ visit_if_post_order(expression, visitor->expression_literal, visitor);
+ break;
+
+ case MCC_AST_EXPRESSION_TYPE_BINARY_OP:
+ visit_if_pre_order(expression, visitor->expression_binary_op, visitor);
+ mcc_ast_visit_expression(expression->lhs, visitor);
+ mcc_ast_visit_expression(expression->rhs, visitor);
+ visit_if_post_order(expression, visitor->expression_binary_op, visitor);
+ break;
+
+ case MCC_AST_EXPRESSION_TYPE_UNARY_OP:
+ visit_if_pre_order(expression, visitor->expression_unary_op,visitor);
+ mcc_ast_visit_expression(expression->unary_expression, visitor);
+ visit_if_post_order(expression, visitor->expression_unary_op, visitor);
+ break;
+
+ case MCC_AST_EXPRESSION_TYPE_PARENTH:
+ visit_if_pre_order(expression, visitor->expression_parenth, visitor);
+ mcc_ast_visit_expression(expression->expression, visitor);
+ visit_if_post_order(expression, visitor->expression_parenth, visitor);
+ break;
+ case MCC_AST_EXPRESSION_TYPE_IDENTIFIER:
+ visit_if_pre_order(expression, visitor->expression_identifier, visitor);
+ mcc_ast_visit_identifier(expression->identifier, visitor);
+ visit_if_post_order(expression, visitor->expression_identifier, visitor);
+ break;
+ case MCC_AST_EXPRESSION_TYPE_CALL_EXPRESSION:
+ visit_if_pre_order(expression, visitor->expression_call_expression, visitor);
+ mcc_ast_visit_identifier(expression->function_name,visitor);
+ if (expression->argument != NULL) {
+ mcc_ast_visit_argument(expression->argument, visitor);
+ }
+ visit_if_post_order(expression, visitor->expression_parenth, visitor);
+ break;
+ case MCC_AST_EXPRESSION_TYPE_BRACKET:
+ visit_if_pre_order(expression,visitor->expression_bracket,visitor);
+ mcc_ast_visit_identifier(expression->bracket_identifier,visitor);
+ mcc_ast_visit_expression(expression->bracket_expression,visitor);
+ visit_if_post_order(expression,visitor->expression_bracket,visitor);
}
@@ -85,28 +85,28 @@ void mcc_ast_visit_literal(struct mcc_ast_literal *literal,struct mcc_ast_visito
assert(visitor);
switch (literal->type) {
- case MCC_AST_DATA_TYPE_BOOL:
- visit(literal, visitor->literal_bool, visitor);
- break;
-
- case MCC_AST_DATA_TYPE_INT:
- visit(literal, visitor->literal_int, visitor);
- break;
-
- case MCC_AST_DATA_TYPE_FLOAT:
- visit(literal, visitor->literal_float, visitor);
- break;
-
- case MCC_AST_DATA_TYPE_STRING:
- visit(literal, visitor->literal_string, visitor);
- break;
- default:
- break;
+ case MCC_AST_DATA_TYPE_BOOL:
+ visit(literal, visitor->literal_bool, visitor);
+ break;
+
+ case MCC_AST_DATA_TYPE_INT:
+ visit(literal, visitor->literal_int, visitor);
+ break;
+
+ case MCC_AST_DATA_TYPE_FLOAT:
+ visit(literal, visitor->literal_float, visitor);
+ break;
+
+ case MCC_AST_DATA_TYPE_STRING:
+ visit(literal, visitor->literal_string, visitor);
+ break;
+ default:
+ break;
}
}
void mcc_ast_visit_declaration(struct mcc_ast_declaration *declaration,
- struct mcc_ast_visitor *visitor)
+ struct mcc_ast_visitor *visitor)
{
assert(declaration);
assert(visitor);
@@ -120,35 +120,35 @@ void mcc_ast_visit_declaration(struct mcc_ast_declaration *declaration,
}
void mcc_ast_visit_statement_list(struct mcc_ast_statement_list *statement_list,
- struct mcc_ast_visitor *visitor)
+ struct mcc_ast_visitor *visitor)
{
- assert(statement_list);
- assert(visitor);
-
- struct mcc_ast_statement_list *next = statement_list;
- while (next != NULL) {
- visit_if_pre_order(next, visitor->statement_list, visitor);
- mcc_ast_visit_statement(next->statement, visitor);
- visit_if_post_order(statement_list, visitor->statement_list, visitor);
- next = next->next;
- }
+ assert(statement_list);
+ assert(visitor);
+
+ struct mcc_ast_statement_list *next = statement_list;
+ while (next != NULL) {
+ visit_if_pre_order(next, visitor->statement_list, visitor);
+ mcc_ast_visit_statement(next->statement, visitor);
+ visit_if_post_order(statement_list, visitor->statement_list, visitor);
+ next = next->next;
+ }
}
void mcc_ast_visit_statement(struct mcc_ast_statement *statement,
- struct mcc_ast_visitor *visitor)
+ struct mcc_ast_visitor *visitor)
{
- assert(statement);
- assert(visitor);
+ assert(statement);
+ assert(visitor);
- visit_if_pre_order(statement, visitor->statement, visitor);
+ visit_if_pre_order(statement, visitor->statement, visitor);
- switch (statement->type) {
+ switch (statement->type) {
case MCC_AST_STATEMENT_TYPE_IF:
visit_if_pre_order(statement, visitor->statement_if, visitor);
mcc_ast_visit_expression(statement->if_condition, visitor);
mcc_ast_visit_statement(statement->if_stmt, visitor);
if (statement->else_stmt != NULL) {
- mcc_ast_visit_statement(statement->else_stmt, visitor);
+ mcc_ast_visit_statement(statement->else_stmt, visitor);
}
visit_if_post_order(statement, visitor->statement_if, visitor);
break;
@@ -163,40 +163,40 @@ void mcc_ast_visit_statement(struct mcc_ast_statement *statement,
case MCC_AST_STATEMENT_TYPE_DECL:
visit_if_pre_order(statement, visitor->statement_declaration,
- visitor);
+ visitor);
mcc_ast_visit_declaration(statement->declaration, visitor);
visit_if_post_order(statement, visitor->statement_declaration,
- visitor);
+ visitor);
break;
case MCC_AST_STATEMENT_TYPE_ASSGN:
visit_if_pre_order(statement, visitor->statement_assignment,
- visitor);
+ visitor);
mcc_ast_visit_identifier(statement->assignment->identifier, visitor);
if (statement->assignment) {
mcc_ast_visit_expression(statement->assignment->array_ass.index, visitor);
}
mcc_ast_visit_expression(statement->assignment->normal_ass.rhs, visitor);
visit_if_post_order(statement, visitor->statement_assignment,
- visitor);
+ visitor);
break;
case MCC_AST_STATEMENT_TYPE_EXPRESSION:
visit_if_pre_order(statement, visitor->statement_expression,
- visitor);
+ visitor);
mcc_ast_visit_expression(statement->expression, visitor);
visit_if_post_order(statement, visitor->statement_expression,
- visitor);
+ visitor);
break;
case MCC_AST_STATEMENT_TYPE_COMPOUND:
visit_if_pre_order(statement, visitor->statement_compound, visitor);
if (statement->statement_list != NULL) {
- mcc_ast_visit_statement_list(statement->statement_list, visitor);
+ mcc_ast_visit_statement_list(statement->statement_list, visitor);
}
visit_if_post_order(statement, visitor->statement_compound,
- visitor);
+ visitor);
break;
case MCC_AST_STATEMENT_TYPE_RETURN:
@@ -206,31 +206,31 @@ void mcc_ast_visit_statement(struct mcc_ast_statement *statement,
}
visit_if_post_order(statement, visitor->statement_return, visitor);
break;
-
- case MCC_AST_STATEMENT_TYPE_ASSGN_ARR:
- break;
- }
- visit_if_post_order(statement, visitor->statement, visitor);
-
+ case MCC_AST_STATEMENT_TYPE_ASSGN_ARR:
+ break;
+ }
+
+ visit_if_post_order(statement, visitor->statement, visitor);
+
}
void mcc_ast_visit_assignment(struct mcc_ast_assignment *assignment,
- struct mcc_ast_visitor *visitor)
+ struct mcc_ast_visitor *visitor)
{
assert(assignment);
assert(visitor);
visit_if_pre_order(assignment, visitor->assignment, visitor);
switch (assignment->type) {
- case MCC_AST_ASSIGNMENT_TYPE_NORMAL:
- mcc_ast_visit_identifier(assignment->identifier, visitor);
- mcc_ast_visit_expression(assignment->normal_ass.rhs, visitor);
- break;
- case MCC_AST_ASSIGNMENT_TYPE_ARRAY:
- mcc_ast_visit_identifier(assignment->identifier, visitor);
- mcc_ast_visit_expression(assignment->array_ass.index, visitor);
- mcc_ast_visit_expression(assignment->array_ass.rhs, visitor);
- break;
+ case MCC_AST_ASSIGNMENT_TYPE_NORMAL:
+ mcc_ast_visit_identifier(assignment->identifier, visitor);
+ mcc_ast_visit_expression(assignment->normal_ass.rhs, visitor);
+ break;
+ case MCC_AST_ASSIGNMENT_TYPE_ARRAY:
+ mcc_ast_visit_identifier(assignment->identifier, visitor);
+ mcc_ast_visit_expression(assignment->array_ass.index, visitor);
+ mcc_ast_visit_expression(assignment->array_ass.rhs, visitor);
+ break;
}
visit_if_post_order(assignment, visitor->assignment, visitor);
}
@@ -244,7 +244,7 @@ void mcc_ast_visit_identifier(struct mcc_ast_identifier *identifier, struct mcc_
}
void mcc_ast_visit_parameter(struct mcc_ast_parameter *parameter,
- struct mcc_ast_visitor *visitor)
+ struct mcc_ast_visitor *visitor)
{
assert(visitor);
@@ -258,34 +258,34 @@ void mcc_ast_visit_parameter(struct mcc_ast_parameter *parameter,
}
void mcc_ast_visit_argument(struct mcc_ast_argument *argument,
- struct mcc_ast_visitor *visitor)
+ struct mcc_ast_visitor *visitor)
{
assert(visitor);
if (argument) {
visit_if_pre_order(argument, visitor->argument, visitor);
for (int i = 0; i < argument->size; i++) {
- mcc_ast_visit_expression(argument->expressions[i], visitor);
+ mcc_ast_visit_expression(argument->expressions -> arr[i], visitor);
}
visit_if_post_order(argument, visitor->argument, visitor);
}
}
void mcc_ast_visit_function(struct mcc_ast_function *function,
- struct mcc_ast_visitor *visitor)
+ struct mcc_ast_visitor *visitor)
{
assert(function);
assert(visitor);
visit_if_pre_order(function, visitor->function, visitor);
mcc_ast_visit_identifier(function->identifier, visitor);
- if (function -> parameter != NULL) {
- mcc_ast_visit_parameter(function->parameter, visitor);
- }
+ if (function -> parameter != NULL) {
+ mcc_ast_visit_parameter(function->parameter, visitor);
+ }
- if (function -> statement != NULL) {
- mcc_ast_visit_statement(function->statement, visitor);
- }
+ if (function -> statement != NULL) {
+ mcc_ast_visit_statement(function->statement, visitor);
+ }
visit_if_post_order(function, visitor->function, visitor);
}
diff --git a/src/symbol_table_validate.c b/src/symbol_table_validate.c
index aefb5d9..7946067 100644
--- a/src/symbol_table_validate.c
+++ b/src/symbol_table_validate.c
@@ -52,14 +52,20 @@ int mcc_symbol_table_validate_call_expression(
struct mcc_ast_argument *argument = expression->argument;
Dynamic_Array *func_arguments = s -> func_arguments;
- if((argument == NULL && func_arguments->size != 0) || (argument != NULL && func_arguments == NULL)) {
- mcc_symbol_table_add_error(
- ec,
- mcc_symbol_table_new_error(&(expression->node.sloc), MCC_SEMANTIC_ERROR_INVALID_NUM_OF_ARGUMENTS));
+ if (argument == NULL) {
+ // func_arguments is always initialized so cannot be Null
+ if (func_arguments -> size != 0) {
+ mcc_symbol_table_add_error(
+ ec,
+ mcc_symbol_table_new_error(&(expression->node.sloc), MCC_SEMANTIC_ERROR_INVALID_NUM_OF_ARGUMENTS));
- return 1;
+ return 1;
+ }
+
+ return 0;
}
- if(argument != NULL && (argument->size != func_arguments->size)) {
+
+ if(argument->size != func_arguments->size) {
mcc_symbol_table_add_error(
ec,
mcc_symbol_table_new_error(&(expression->node.sloc), MCC_SEMANTIC_ERROR_INVALID_NUM_OF_ARGUMENTS));
@@ -71,7 +77,7 @@ int mcc_symbol_table_validate_call_expression(
struct mcc_symbol_function_argument *fa = func_arguments -> arr[i];
enum mcc_ast_data_type func_arg_type = fa -> arg_type;
- enum mcc_ast_data_type arg_typ = mcc_symbol_table_get_expression_return_type(argument->expressions[i],
+ enum mcc_ast_data_type arg_typ = mcc_symbol_table_get_expression_return_type(argument->expressions -> arr[i],
symbol_table);
mcc_symbol_table_add_type_check(
@@ -81,6 +87,7 @@ int mcc_symbol_table_validate_call_expression(
MCC_SEMANTIC_TYPE_CHECK_ARG_TYPE,
&(expression->node.sloc)
);
+
// wrong type passed as an argument
if(func_arg_type != arg_typ) {
mcc_symbol_table_add_error(
@@ -90,7 +97,6 @@ int mcc_symbol_table_validate_call_expression(
return 1;
}
}
-
return 0;
}
}
--
GitLab