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;
}

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;
  }

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

  return NULL;
}

struct node* body_largest_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_var_node;
}

struct node* variable_struct_or_union_largest_variable_node(struct node* var_node)
{
  return body_largest_variable_node(var_node);
}

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;
}

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

  vector_set_peek_pointer(dtype->array.brackets->n_brackets, index + 1);
  int size_sum = index_value;
  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_value = declared_index;
    size_sum *= size_value;
    bracket_node = vector_peek_ptr(dtype->array.brackets->n_brackets);
  }

  return size_sum;
}

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

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

int struct_offset(struct compile_process* compiel_proc, 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(compiel_proc, struct_name);
  assert(struct_sym && struct_sym->type == SYMBOL_TYPE_NODE);
  struct node* node = struct_sym->data;
  assert(node && 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);
      }
    }

    // Have we found the variable? then we are done
    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_access_node_with_op(struct node* node, const char* op)
{
  return is_access_node(node) && S_EQ(node->exp.op, 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_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);
}

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, "--");
}

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

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

bool is_address_operator(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);
}

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

struct datatype* datatype_thats_a_pointer(struct datatype* d1, struct datatype* d2)
{
  if (d1->flags & DATATYPE_FLAG_IS_POINTER)
  {
    return d1;
  }

  if (d2->flags & DATATYPE_FLAG_IS_POINTER)
  {
    return d2;
  }

  return NULL;
}

struct datatype* datatype_pointer_reduce(struct datatype* datatype, int by)
{
  struct datatype* new_datatye = calloc(1, sizeof(struct datatype));
  memcpy(new_datatye, datatype, sizeof(struct datatype));
  new_datatye->pointer_depth -= by;
  if (new_datatye->pointer_depth <= 0)
  {
    new_datatye->flags &= ~DATATYPE_FLAG_IS_POINTER;
    new_datatye->pointer_depth = 0;
  }

  return new_datatye;
}

long arithmetic(struct compile_process* compiler, long left_operand, long right_operand, const char* op, bool* success)
{
  *success = true;
  int result = 0;

  if (S_EQ(op, "*"))
  {
    result = left_operand * right_operand;
  }
  else if (S_EQ(op, "/"))
  {
    result = left_operand / right_operand;
  }
  else if (S_EQ(op, "+"))
  {
    result = left_operand + right_operand;
  }
  else if (S_EQ(op, "-"))
  {
    result = left_operand - right_operand;
  }
  else if (S_EQ(op, "=="))
  {
    result = left_operand == right_operand;
  }
  else if (S_EQ(op, "!="))
  {
    result = left_operand != right_operand;
  }
  else if (S_EQ(op, ">"))
  {
    result = left_operand > right_operand;
  }
  else if (S_EQ(op, "<"))
  {
    result = left_operand < right_operand;
  }
  else if (S_EQ(op, ">="))
  {
    result = left_operand >= right_operand;
  }
  else if (S_EQ(op, "<="))
  {
    result = left_operand <= right_operand;
  }
  else if (S_EQ(op, "<<"))
  {
    result = left_operand << right_operand;
  }
  else if (S_EQ(op, ">>"))
  {
    result = left_operand >> right_operand;
  }
  else if (S_EQ(op, "&&"))
  {
    result = left_operand && right_operand;
  }
  else if (S_EQ(op, "||"))
  {
    result = left_operand || right_operand;
  }
  else
  {
    *success = false;
  }

  return result;
}

bool file_exists(const char* filename)
{
  FILE* f = fopen(filename, "r");
  if (!f)
  {
    return false;
  }

  fclose(f);
  return true;
}