node.c

#include "compiler.h"
#include "helpers/vector.h"
#include <assert.h>

struct vector *node_vector = NULL;
struct vector *node_vector_root = NULL;

struct node *parser_current_body = NULL;
struct node *parser_current_function = NULL;

void node_set_vector(struct vector *vec, struct vector *root_vec) {
  node_vector = vec;
  node_vector_root = root_vec;
}

void node_push(struct node *node) { vector_push(node_vector, &node); }

struct node *node_peek_or_null() {
  return vector_back_ptr_or_null(node_vector);
}

struct node *node_peek() { return *(struct node **)(vector_back(node_vector)); }

struct node *node_pop() {
  struct node *last_node = vector_back_ptr(node_vector);
  struct node *last_node_root = vector_empty(node_vector)
                                    ? NULL
                                    : vector_back_ptr_or_null(node_vector_root);

  vector_pop(node_vector);

  if (last_node == last_node_root) {
    vector_pop(node_vector_root);
  }

  return last_node;
}

bool node_is_expressionable(struct node *node) {
  return node->type == NODE_TYPE_EXPRESSION ||
         node->type == NODE_TYPE_EXPRESSION_PARENTHESIS ||
         node->type == NODE_TYPE_UNARY || node->type == NODE_TYPE_IDENTIFIER ||
         node->type == NODE_TYPE_NUMBER || node->type == NODE_TYPE_STRING;
}

struct node *node_peek_expressionable_or_null() {
  struct node *last_node = node_peek_or_null();
  return node_is_expressionable(last_node) ? last_node : NULL;
}

void make_exp_node(struct node *left_node, struct node *right_node,
                   const char *op) {
  assert(left_node);
  assert(right_node);
  node_create(&(struct node){.type = NODE_TYPE_EXPRESSION,
                             .exp.left = left_node,
                             .exp.right = right_node,
                             .exp.op = op});
}

void make_unary_node(const char *op, struct node *operand_node, int flags) {
  node_create(&(struct node){.type = NODE_TYPE_UNARY,
                             .unary.op = op,
                             .unary.operand = operand_node,
                             .unary.flags = flags});
}

void make_exp_parentheses_node(struct node *exp_node) {
  node_create(&(struct node){.type = NODE_TYPE_EXPRESSION_PARENTHESIS,
                             .paren.exp = exp_node});
}

void make_if_node(struct node *cond_node, struct node *body_node,
                  struct node *next_node) {
  node_create(&(struct node){.type = NODE_TYPE_STATEMENT_IF,
                             .stmt.if_stmt.cond_node = cond_node,
                             .stmt.if_stmt.body_node = body_node,
                             .stmt.if_stmt.next = next_node});
}

void make_else_node(struct node *body_node) {
  node_create(&(struct node){.type = NODE_TYPE_STATEMENT_ELSE,
                             .stmt.else_stmt.body_node = body_node});
}

void make_return_node(struct node *exp_node) {
  node_create(&(struct node){.type = NODE_TYPE_STATEMENT_RETURN,
                             .stmt.return_stmt.exp = exp_node});
}

void make_for_node(struct node *init_node, struct node *cond_node,
                   struct node *inc_node, struct node *body_node) {
  node_create(&(struct node){.type = NODE_TYPE_STATEMENT_FOR,
                             .stmt.for_stmt.init = init_node,
                             .stmt.for_stmt.cond = cond_node,
                             .stmt.for_stmt.inc = inc_node,
                             .stmt.for_stmt.body = body_node});
}

void make_while_node(struct node *cond_node, struct node *body_node) {
  node_create(&(struct node){.type = NODE_TYPE_STATEMENT_WHILE,
                             .stmt.while_stmt.cond = cond_node,
                             .stmt.while_stmt.body = body_node});
}

void make_do_while_node(struct node *cond_node, struct node *body_node) {
  node_create(&(struct node){.type = NODE_TYPE_STATEMENT_DO_WHILE,
                             .stmt.do_while_stmt.cond = cond_node,
                             .stmt.do_while_stmt.body = body_node});
}

void make_switch_node(struct node *exp_node, struct node *body_node,
                      struct vector *cases, bool has_default_case) {
  node_create(
      &(struct node){.type = NODE_TYPE_STATEMENT_SWITCH,
                     .stmt.switch_stmt.exp = exp_node,
                     .stmt.switch_stmt.body = body_node,
                     .stmt.switch_stmt.cases = cases,
                     .stmt.switch_stmt.has_default_case = has_default_case});
}

void make_continue_node() {
  node_create(&(struct node){.type = NODE_TYPE_STATEMENT_CONTINUE});
}

void make_break_node() {
  node_create(&(struct node){.type = NODE_TYPE_STATEMENT_BREAK});
}

void make_label_node(struct node *name_node) {
  node_create(&(struct node){.type = NODE_TYPE_LABEL, .label.name = name_node});
}

void make_goto_node(struct node *label_node) {
  node_create(&(struct node){.type = NODE_TYPE_STATEMENT_GOTO,
                             .stmt._goto.label = label_node});
}

void make_case_node(struct node *exp_node) {
  node_create(&(struct node){.type = NODE_TYPE_STATEMENT_CASE,
                             .stmt._case.exp = exp_node});
}

void make_default_node() {
  node_create(&(struct node){.type = NODE_TYPE_STATEMENT_DEFAULT});
}

void make_tenary_node(struct node *true_node, struct node *false_node) {
  node_create(&(struct node){.type = NODE_TYPE_TENARY,
                             .tenary.true_node = true_node,
                             .tenary.false_node = false_node});
}

void make_cast_node(struct datatype *dtype, struct node *exp_node) {
  node_create(&(struct node){
      .type = NODE_TYPE_CAST, .cast.dtype = *dtype, .cast.exp = exp_node});
}

struct node *node_create(struct node *_node) {
  struct node *node = malloc(sizeof(struct node));
  memcpy(node, _node, sizeof(struct node));
  node->binded.owner = parser_current_body;
  node->binded.function = parser_current_function;
  node_push(node);
  return node;
}

void make_bracket_node(struct node *node) {
  node_create(&(struct node){.type = NODE_TYPE_BRACKET, .bracket.inner = node});
}

void make_body_node(struct vector *body_vec, size_t size, bool padded,
                    struct node *largest_var_node) {
  node_create(&(struct node){.type = NODE_TYPE_BODY,
                             .body.statements = body_vec,
                             .body.size = size,
                             .body.padded = padded,
                             .body.largest_variable_node = largest_var_node});
}

void make_struct_node(const char *name, struct node *body_node) {
  int flags = 0;
  if (!body_node) {
    flags |= NODE_FLAG_IS_FORWARD_DECLARATION;
  }

  node_create(&(struct node){.type = NODE_TYPE_STRUCT,
                             ._struct.body_n = body_node,
                             ._struct.name = name,
                             .flags = flags});
}

void make_union_node(const char *name, struct node *body_node) {
  int flags = 0;
  if (!body_node) {
    flags |= NODE_FLAG_IS_FORWARD_DECLARATION;
  }

  node_create(&(struct node){.type = NODE_TYPE_UNION,
                             ._union.body_n = body_node,
                             ._union.name = name,
                             .flags = flags});
}

void make_function_node(struct datatype *rtype, const char *name,
                        struct vector *args, struct node *body) {
  struct node *func_node =
      node_create(&(struct node){.type = NODE_TYPE_FUNCTION,
                                 .func.rtype = *rtype,
                                 .func.name = name,
                                 .func.args.args = args,
                                 .func.body_n = body,
                                 .func.args.stack_addition = DATA_SIZE_QWORD});
  func_node->func.stack_frame.elements =
      vector_create(sizeof(struct stack_frame_element));
}

struct node *node_from_sym(struct symbol *sym) {
  if (sym->type != SYMBOL_TYPE_NODE) {
    return NULL;
  }

  return sym->data;
}

struct node *node_from_symbol(struct compile_process *process,
                              const char *name) {
  struct symbol *sym = symresolver_get_symbol(process, name);
  if (!sym) {
    return NULL;
  }

  return node_from_sym(sym);
}

struct node *struct_node_for_name(struct compile_process *process,
                                  const char *name) {
  struct node *node = node_from_symbol(process, name);
  if (!node) {
    return NULL;
  }

  if (node->type != NODE_TYPE_STRUCT) {
    return NULL;
  }

  return node;
}

struct node *union_node_for_name(struct compile_process *process,
                                 const char *name) {
  struct node *node = node_from_symbol(process, name);
  if (!node) {
    return NULL;
  }

  if (node->type != NODE_TYPE_UNION) {
    return NULL;
  }

  return node;
}

bool node_is_struct_or_union(struct node *node) {
  return node->type == NODE_TYPE_STRUCT || node->type == NODE_TYPE_UNION;
}

bool node_is_struct_or_union_variable(struct node *node) {
  if (node->type != NODE_TYPE_VARIABLE) {
    return false;
  }

  return datatype_is_struct_or_union(&node->var.type);
}

struct node *variable_node(struct node *node) {
  struct node *var_node = NULL;
  switch (node->type) {
  case NODE_TYPE_VARIABLE:
    var_node = node;
    break;

  case NODE_TYPE_STRUCT:
    var_node = node->_struct.var;
    break;

  case NODE_TYPE_UNION:
    var_node = node->_union.var;
    break;
  }

  return var_node;
}

bool variable_node_is_primitive(struct node *node) {
  assert(node->type == NODE_TYPE_VARIABLE);
  return datatype_is_primitive(&node->var.type);
}

struct node *variable_node_or_list(struct node *node) {
  if (node->type == NODE_TYPE_VARIABLE_LIST) {
    return node;
  }

  return variable_node(node);
}

size_t function_node_argument_stack_addition(struct node *node) {
  assert(node->type == NODE_TYPE_FUNCTION);
  return node->func.args.stack_addition;
}

size_t function_node_stack_size(struct node *node) {
  assert(node->type == NODE_TYPE_FUNCTION);
  return node->func.stack_size;
}

struct vector *function_node_argument_vec(struct node *node) {
  assert(node->type == NODE_TYPE_FUNCTION);
  return node->func.args.args;
}

bool function_node_is_prototype(struct node *node) {
  return node->func.body_n == NULL;
}

bool node_is_expression_or_parentheses(struct node *node) {
  return node->type == NODE_TYPE_EXPRESSION ||
         node->type == NODE_TYPE_EXPRESSION_PARENTHESIS;
}

bool node_is_value_type(struct node *node) {
  return node_is_expression_or_parentheses(node) ||
         node->type == NODE_TYPE_IDENTIFIER || node->type == NODE_TYPE_NUMBER ||
         node->type == NODE_TYPE_UNARY || node->type == NODE_TYPE_TENARY ||
         node->type == NODE_TYPE_STRING;
}

bool node_is_expression(struct node *node, const char *op) {
  return node->type == NODE_TYPE_EXPRESSION && S_EQ(node->exp.op, op);
}

bool is_node_assignment(struct node *node) {
  if (node->type != NODE_TYPE_EXPRESSION) {
    return false;
  }

  return S_EQ(node->exp.op, "=") || S_EQ(node->exp.op, "+=") ||
         S_EQ(node->exp.op, "-=") || S_EQ(node->exp.op, "*=") ||
         S_EQ(node->exp.op, "/=") || S_EQ(node->exp.op, "%=") ||
         S_EQ(node->exp.op, "&=") || S_EQ(node->exp.op, "|=") ||
         S_EQ(node->exp.op, "^=") || S_EQ(node->exp.op, "<<=") ||
         S_EQ(node->exp.op, ">>=");
}

bool node_valid(struct node *node) {
  return node && node->type != NODE_TYPE_BLANK;
}