helper.c

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

size_t variable_size(struct node *var_node) {
  assert(var_node->type == NODE_TYPE_VARIABLE);
  return datatype_size(&var_node->var.type);
}

size_t variable_size_for_list(struct node *var_list_node) {
  assert(var_list_node->type == NODE_TYPE_VARIABLE_LIST);
  size_t size = 0;
  vector_set_peek_pointer(var_list_node->var_list.list, 0);
  struct node *var_node = vector_peek_ptr(var_list_node->var_list.list);
  while (var_node) {
    size += variable_size(var_node);
    var_node = vector_peek_ptr(var_list_node->var_list.list);
  }

  return size;
}

int padding(int val, int to) {
  if (to <= 0) {
    return 0;
  }

  if (val % to == 0) {
    return 0;
  }

  return to - (val % to) % to;
}

int align_value(int val, int to) {
  if (val % to) {
    val += padding(val, to);
  }

  return val;
}

int align_value_treat_positive(int val, int to) {
  assert(to >= 0);

  if (val < 0) {
    to = -to;
  }

  return align_value(val, to);
}

int compute_sum_padding(struct vector *vec) {
  int padding = 0;
  int last_type = -1;
  bool mixed_types = false;
  vector_set_peek_pointer(vec, 0);
  struct node *cur_node = vector_peek_ptr(vec);
  struct node *last_node = NULL;
  while (cur_node) {
    if (cur_node->type != NODE_TYPE_VARIABLE) {
      cur_node = vector_peek_ptr(vec);
      continue;
    }

    padding += cur_node->var.padding;
    last_type = cur_node->var.type.type;
    last_node = cur_node;
    cur_node = vector_peek_ptr(vec);
  }

  return padding;
}

struct node *variable_struct_or_union_body_node(struct node *node) {
  if (!node_is_struct_or_union_variable(node)) {
    return NULL;
  }

  if (node->var.type.type == DATA_TYPE_STRUCT) {
    return node->var.type.struct_node->_struct.body_n;
  }

  if (node->var.type.type == DATA_TYPE_UNION) {
    return node->var.type.union_node->_union.body_n;
  }

  return NULL;
}

int array_multiplier(struct datatype *dtype, int index, int index_val) {
  if (!(dtype->flags & DATATYPE_FLAG_IS_ARRAY)) {
    return index_val;
  }

  vector_set_peek_pointer(dtype->array.brackets->n_brackets, index + 1);
  int size_sum = index_val;
  struct node *bracket_node =
      vector_peek_ptr(dtype->array.brackets->n_brackets);
  while (bracket_node) {
    assert(bracket_node->bracket.inner->type == NODE_TYPE_NUMBER);
    int declared_index = bracket_node->bracket.inner->llnum;
    int size_val = declared_index;
    size_sum *= size_val;
    bracket_node = vector_peek_ptr(dtype->array.brackets->n_brackets);
  }

  return size_sum;
}

int array_offset(struct datatype *dtype, int index, int index_val) {
  if (!(dtype->flags & DATATYPE_FLAG_IS_ARRAY) ||
      (index == vector_count(dtype->array.brackets->n_brackets) - 1)) {
    return index_val * datatype_element_size(dtype);
  }

  return array_multiplier(dtype, index, index_val) *
         datatype_element_size(dtype);
}

struct node *body_larest_variable_node(struct node *body_node) {
  if (!body_node) {
    return NULL;
  }

  if (body_node->type != NODE_TYPE_BODY) {
    return NULL;
  }

  return body_node->body.largest_variable_node;
}

struct node *
variable_struct_or_union_largest_variable_node(struct node *var_node) {
  return body_larest_variable_node(
      variable_struct_or_union_body_node(var_node));
}

int struct_offset(struct compile_process *compile_process,
                  const char *struct_name, const char *var_name,
                  struct node **var_node_out, int last_pos, int flags) {
  struct symbol *struct_sym =
      symresolver_get_symbol(compile_process, struct_name);
  assert(struct_sym && struct_sym->type == SYMBOL_TYPE_NODE);
  struct node *node = struct_sym->data;
  assert(node_is_struct_or_union(node));

  struct vector *struct_vars_vec = node->_struct.body_n->body.statements;
  vector_set_peek_pointer(struct_vars_vec, 0);
  if (flags & STRUCT_ACCESS_BACKWARDS) {
    vector_set_peek_pointer_end(struct_vars_vec);
    vector_set_flag(struct_vars_vec, VECTOR_FLAG_PEEK_DECREMENT);
  }

  struct node *var_node_cur = variable_node(vector_peek_ptr(struct_vars_vec));
  struct node *var_node_last = NULL;
  int position = last_pos;
  *var_node_out = NULL;
  while (var_node_cur) {
    *var_node_out = var_node_cur;
    if (var_node_last) {
      position += variable_size(var_node_last);
      if (variable_node_is_primitive(var_node_cur)) {
        position =
            align_value_treat_positive(position, var_node_cur->var.type.size);
      } else {
        position = align_value_treat_positive(
            position,
            variable_struct_or_union_largest_variable_node(var_node_cur)
                ->var.type.size);
      }
    }

    if (S_EQ(var_node_cur->var.name, var_name)) {
      break;
    }

    var_node_last = var_node_cur;
    var_node_cur = variable_node(vector_peek_ptr(struct_vars_vec));
  }

  vector_unset_flag(struct_vars_vec, VECTOR_FLAG_PEEK_DECREMENT);
  return position;
}

bool is_access_operator(const char *op) {
  return S_EQ(op, ".") || S_EQ(op, "->");
}

bool is_access_node(struct node *node) {
  return node->type == NODE_TYPE_EXPRESSION && is_access_operator(node->exp.op);
}

bool is_array_operator(const char *op) { return S_EQ(op, "[]"); }

bool is_array_node(struct node *node) {
  return node->type == NODE_TYPE_EXPRESSION && is_array_operator(node->exp.op);
}

bool is_parentheses_operator(const char *op) { return S_EQ(op, "()"); }

bool is_parentheses_node(struct node *node) {
  return node->type == NODE_TYPE_EXPRESSION &&
         is_parentheses_operator(node->exp.op);
}

bool is_access_node_with_op(struct node *node, const char *op) {
  return is_access_node(node) && S_EQ(node->exp.op, op);
}

bool is_argument_operator(const char *op) { return S_EQ(op, ","); }

bool is_argument_node(struct node *node) {
  return node->type == NODE_TYPE_EXPRESSION &&
         is_argument_operator(node->exp.op);
}

void datatype_decrement_pointer(struct datatype *dtype) {
  dtype->pointer_depth--;
  if (dtype->pointer_depth <= 0) {
    dtype->flags &= ~DATATYPE_FLAG_IS_POINTER;
  }
}

bool is_unary_operator(const char *op) {
  return S_EQ(op, "-") || S_EQ(op, "+") || S_EQ(op, "!") || S_EQ(op, "~") ||
         S_EQ(op, "*") || S_EQ(op, "&") || S_EQ(op, "++") || S_EQ(op, "--");
}

bool op_is_indirection(const char *op) { return S_EQ(op, "*"); }

bool op_is_address(const char *op) { return S_EQ(op, "&"); }

bool is_logical_operator(const char *op) {
  return S_EQ(op, "&&") || S_EQ(op, "||");
}

bool is_logical_node(struct node *node) {
  return node->type == NODE_TYPE_EXPRESSION &&
         is_logical_operator(node->exp.op);
}

bool is_parentheses(const char *op) { return S_EQ(op, "("); }

bool unary_operand_compatible(struct token *token) {
  return is_access_operator(token->sval) || is_array_operator(token->sval) ||
         is_parentheses(token->sval);
}

bool is_left_operanded_unary_operator(const char *op) {
  return S_EQ(op, "++") || S_EQ(op, "--");
}

long arithmetic(struct compile_process *compiler, long left, long right,
                const char *op, bool *success) {
  *success = true;
  int res = 0;
  if (S_EQ(op, "+")) {
    res = left + right;
  } else if (S_EQ(op, "-")) {
    res = left - right;
  } else if (S_EQ(op, "*")) {
    res = left * right;
  } else if (S_EQ(op, "/")) {
    if (right == 0) {
      *success = false;
      return 0;
    }

    res = left / right;
  } else if (S_EQ(op, "%")) {
    if (right == 0) {
      *success = false;
      return 0;
    }

    res = left % right;
  } else if (S_EQ(op, "<<")) {
    res = left << right;
  } else if (S_EQ(op, ">>")) {
    res = left >> right;
  } else if (S_EQ(op, "&")) {
    res = left & right;
  } else if (S_EQ(op, "|")) {
    res = left | right;
  } else if (S_EQ(op, "^")) {
    res = left ^ right;
  } else if (S_EQ(op, "&&")) {
    res = left && right;
  } else if (S_EQ(op, "||")) {
    res = left || right;
  } else if (S_EQ(op, "==")) {
    res = left == right;
  } else if (S_EQ(op, "!=")) {
    res = left != right;
  } else if (S_EQ(op, "<")) {
    res = left < right;
  } else if (S_EQ(op, ">")) {
    res = left > right;
  } else if (S_EQ(op, "<=")) {
    res = left <= right;
  } else if (S_EQ(op, ">=")) {
    res = left >= right;
  } else {
    *success = false;
  }

  return res;
}

bool file_exists(const char *filename) {
  FILE *file = fopen(filename, "r");
  if (file) {
    fclose(file);
    return true;
  }

  return false;
}