resolver.c

#include "compiler.h"
#include "vector.h"
#include <assert.h>
#include <stdlib.h>
static struct compile_process *cp;
void resolver_follow_part(struct resolver_process *resolver, struct node *node,
                          struct resolver_result *result);
struct resolver_entity *resolver_follow_exp(struct resolver_process *resolver,
                                            struct node *node,
                                            struct resolver_result *result);
struct resolver_result *resolver_follow(struct resolver_process *resolver,
                                        struct node *node);
struct resolver_entity *
resolver_follow_array_bracket(struct resolver_process *resolver,
                              struct node *node,
                              struct resolver_result *result);
struct resolver_entity *
resolver_follow_part_return_entity(struct resolver_process *resolver,
                                   struct node *node,
                                   struct resolver_result *result);

bool resolver_result_failed(struct resolver_result *result) {
  return result->flags & RESOLVER_RESULT_FLAG_FAILED;
}

bool resolver_result_ok(struct resolver_result *result) {
  return !resolver_result_failed(result);
}

bool resolver_result_finished(struct resolver_result *result) {
  return result->flags & RESOLVER_RESULT_FLAG_RUNTIME_NEEDED_TO_FINISH_PATH;
}

struct resolver_entity *
resolver_result_entity_root(struct resolver_result *result) {
  return result->entity;
}

struct resolver_entity *
resolver_result_entity_next(struct resolver_entity *entity) {
  return entity->next;
}

struct resolver_entity *resolver_entity_clone(struct resolver_entity *entity) {
  if (!entity) {
    return NULL;
  }

  struct resolver_entity *new_entity =
      calloc(1, sizeof(struct resolver_entity));
  memcpy(new_entity, entity, sizeof(struct resolver_entity));
  vector_push(cp->gb, &new_entity);
  return new_entity;
}

struct resolver_entity *resolver_result_entity(struct resolver_result *result) {
  if (resolver_result_failed(result)) {
    return NULL;
  }

  return result->entity;
}

struct resolver_result *resolver_new_result(struct resolver_process *process) {
  struct resolver_result *result = calloc(1, sizeof(struct resolver_result));
  struct vector *arrayEntities =
      vector_create(sizeof(struct resolver_entity *));

  vector_push(cp->gb, &result);
  vector_push(cp->gbForVectors, &arrayEntities);

  result->array_data.array_entities = arrayEntities;
  return result;
}

void resolver_result_free(struct resolver_result *result) {
  vector_free(result->array_data.array_entities);
  free(result);
}

struct resolver_scope *
resolver_process_scope_current(struct resolver_process *process) {
  return process->scope.current;
}

void resolver_runtime_needed(struct resolver_result *result,
                             struct resolver_entity *last_entity) {
  result->entity = last_entity;
  result->flags &= ~RESOLVER_RESULT_FLAG_RUNTIME_NEEDED_TO_FINISH_PATH;
}

void resolver_result_entity_push(struct resolver_result *result,
                                 struct resolver_entity *entity) {
  if (!result->first_entity_const) {
    result->first_entity_const = entity;
  }

  if (!result->last_entity) {
    result->entity = entity;
    result->last_entity = entity;
    result->count++;
    return;
  }

  result->last_entity->next = entity;
  entity->prev = result->last_entity;
  result->last_entity = entity;
  result->count++;
}

struct resolver_entity *resolver_result_peek(struct resolver_result *result) {
  return result->last_entity;
}

struct resolver_entity *
resolver_result_peek_ignore_rule_entity(struct resolver_result *result) {
  struct resolver_entity *entity = resolver_result_peek(result);
  while (entity && entity->type == RESOLVER_ENTITY_TYPE_RULE) {
    entity = entity->prev;
  }

  return entity;
}

struct resolver_entity *resolver_result_pop(struct resolver_result *result) {
  struct resolver_entity *entity = result->last_entity;
  if (!result->entity) {
    return NULL;
  }

  if (result->entity == result->last_entity) {
    result->entity = result->last_entity->prev;
    result->last_entity = result->last_entity->prev;
    result->count--;
    goto out;
  }

  result->last_entity = result->last_entity->prev;
  result->count--;
out:
  if (result->count == 0) {
    result->first_entity_const = NULL;
    result->last_entity = NULL;
    result->entity = NULL;
  }
  entity->prev = NULL;
  entity->next = NULL;
  return entity;
}

struct vector *resolver_array_data_vec(struct resolver_result *result) {
  return result->array_data.array_entities;
}

struct compile_process *resolver_compiler(struct resolver_process *process) {
  return process->compiler;
}

struct resolver_scope *
resolver_scope_current(struct resolver_process *process) {
  return process->scope.current;
}

struct resolver_scope *resolver_scope_root(struct resolver_process *process) {
  return process->scope.root;
}

struct resolver_scope *resolver_new_scope_create() {
  struct resolver_scope *scope = calloc(1, sizeof(struct resolver_scope));
  scope->entities = vector_create(sizeof(struct resolver_entity *));
  vector_push(cp->trackedScopes, &scope);
  return scope;
}

struct resolver_scope *resolver_new_scope(struct resolver_process *resolver,
                                          void *private, int flags) {
  struct resolver_scope *scope = resolver_new_scope_create();
  if (!scope) {
    return NULL;
  }

  resolver->scope.current->next = scope;
  scope->prev = resolver->scope.current;
  resolver->scope.current = scope;
  scope->private = private;
  scope->flags = flags;
  return scope;
}

void resolver_finish_scope(struct resolver_process *resolver) {
  struct resolver_scope *scope = resolver->scope.current;
  resolver->scope.current = scope->prev;
}

struct resolver_process *
resolver_new_process(struct compile_process *compiler,
                     struct resolver_callbacks *callbacks) {
  struct resolver_process *process = calloc(1, sizeof(struct resolver_process));
  compiler->trackedScopes = vector_create(sizeof(struct resolver_scope *));
  process->compiler = compiler;
  cp = compiler;

  memcpy(&process->callbacks, callbacks, sizeof(process->callbacks));
  process->scope.root = resolver_new_scope_create();
  process->scope.current = process->scope.root;
  return process;
}

struct resolver_entity *
resolver_create_new_entity(struct resolver_result *result, int type,
                           void *private) {
  struct resolver_entity *entity = calloc(1, sizeof(struct resolver_entity));
  if (!entity) {
    return NULL;
  }

  entity->type = type;
  entity->private = private;
  vector_push(cp->gbVectorForCustonResolverEntities, &entity);
  return entity;
}

struct resolver_entity *
resolver_create_new_entity_for_unsupported_node(struct resolver_result *result,
                                                struct node *node) {
  struct resolver_entity *entity = resolver_create_new_entity(
      result, RESOLVER_ENTITY_TYPE_UNSUPPORTED, NULL);
  if (!entity) {
    return NULL;
  }

  entity->node = node;
  entity->flags = RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_LEFT_ENTITY |
                  RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_NEXT_ENTITY;
  return entity;
}

struct resolver_entity *resolver_create_new_entity_for_array_bracket(
    struct resolver_result *result, struct resolver_process *process,
    struct node *node, struct node *array_index_node, int index,
    struct datatype *dtype, void *private, struct resolver_scope *scope) {
  struct resolver_entity *entity = resolver_create_new_entity(
      result, RESOLVER_ENTITY_TYPE_ARRAY_BRACKET, private);
  if (!entity) {
    return NULL;
  }

  entity->scope = scope;
  if (!entity->scope) {
    compiler_error(cp, "resolver error: scope doesnt exist \n");
  }

  entity->name = NULL;
  entity->dtype = *dtype;
  entity->node = node;
  entity->array.index = index;
  entity->array.dtype = *dtype;
  entity->array.array_index_node = array_index_node;
  int array_index_val = 1;
  if (array_index_node->type == NODE_TYPE_NUMBER) {
    array_index_val = array_index_node->llnum;
  }
  entity->offset = array_offset(dtype, index, array_index_val);
  return entity;
}

struct resolver_entity *resolver_create_new_entity_for_merged_array_bracket(
    struct resolver_result *result, struct resolver_process *process,
    struct node *node, struct node *array_index_node, int index,
    struct datatype *dtype, void *private, struct resolver_scope *scope) {
  struct resolver_entity *entity = resolver_create_new_entity(
      result, RESOLVER_ENTITY_TYPE_ARRAY_BRACKET, private);
  if (!entity) {
    return NULL;
  }

  entity->scope = scope;
  if (!entity->scope) {
    compiler_error(cp, "resolver error: scope doesnt exist \n");
  }
  entity->name = NULL;
  entity->dtype = *dtype;
  entity->node = node;
  entity->array.index = index;
  entity->array.dtype = *dtype;
  entity->array.array_index_node = array_index_node;
  return entity;
}

struct resolver_entity *
resolver_create_new_unknown_entity(struct resolver_process *process,
                                   struct resolver_result *result,
                                   struct datatype *dtype, struct node *node,
                                   struct resolver_scope *scope, int offset) {
  struct resolver_entity *entity =
      resolver_create_new_entity(result, RESOLVER_ENTITY_TYPE_GENERAL, NULL);
  if (!entity) {
    return NULL;
  }

  entity->flags |= RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_NEXT_ENTITY |
                   RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_LEFT_ENTITY;
  entity->scope = scope;
  entity->dtype = *dtype;
  entity->node = node;
  entity->offset = offset;
  return entity;
}

struct resolver_entity *resolver_create_new_unary_indirection_entity(
    struct resolver_process *process, struct resolver_result *result,
    struct node *node, int indirection_depth) {
  struct resolver_entity *entity = resolver_create_new_entity(
      result, RESOLVER_ENTITY_TYPE_UNARY_INDIRECTION, NULL);
  if (!entity) {
    return NULL;
  }

  entity->flags = RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_LEFT_ENTITY |
                  RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_NEXT_ENTITY;
  entity->node = node;
  entity->indirection.depth = indirection_depth;
  return entity;
}

/**
 * @brief &a.b.c
 *
 * @param process
 * @param result
 * @param dtype
 * @param node
 * @param scope
 * @param offset
 * @return struct resolver_entity*
 */
struct resolver_entity *resolver_create_new_unary_get_address_entity(
    struct resolver_process *process, struct resolver_result *result,
    struct datatype *dtype, struct node *node, struct resolver_scope *scope,
    int offset) {
  struct resolver_entity *entity = resolver_create_new_entity(
      result, RESOLVER_ENTITY_TYPE_UNARY_GET_ADDRESS, NULL);
  if (!entity) {
    return NULL;
  }

  entity->flags = RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_LEFT_ENTITY |
                  RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_NEXT_ENTITY;
  entity->node = node;
  entity->scope = scope;

  entity->dtype = *dtype;
  entity->dtype.flags |= DATATYPE_FLAG_IS_POINTER;
  entity->dtype.pointer_depth++;
  return entity;
}

struct resolver_entity *
resolver_create_new_cast_entity(struct resolver_process *process,
                                struct resolver_scope *scope,
                                struct datatype *cast_dtype) {
  struct resolver_entity *entity =
      resolver_create_new_entity(NULL, RESOLVER_ENTITY_TYPE_CAST, NULL);
  if (!entity) {
    return NULL;
  }

  entity->flags = RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_LEFT_ENTITY |
                  RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_NEXT_ENTITY;
  entity->scope = scope;
  entity->dtype = *cast_dtype;
  return entity;
}

struct resolver_entity *resolver_create_new_entity_for_var_node_custom_scope(
    struct resolver_process *process, struct node *var_node, void *private,
    struct resolver_scope *scope, int offset) {
  if (var_node->type != NODE_TYPE_VARIABLE) {
    compiler_error(cp, "resolver error: not a variable node \n");
  }
  struct resolver_entity *entity =
      resolver_create_new_entity(NULL, RESOLVER_ENTITY_TYPE_VARIABLE, private);
  if (!entity) {
    return NULL;
  }

  entity->scope = scope;
  if (!entity->scope) {
    compiler_error(cp, "resolver error: scope doesnt exist \n");
  }
  entity->dtype = var_node->var.type;
  entity->var_data.dtype = var_node->var.type;
  entity->node = var_node;
  entity->name = var_node->var.name;
  entity->offset = offset;
  return entity;
}

struct resolver_entity *
resolver_create_new_entity_for_var_node(struct resolver_process *process,
                                        struct node *var_node, void *private,
                                        int offset) {
  return resolver_create_new_entity_for_var_node_custom_scope(
      process, var_node, private, resolver_scope_current(process), offset);
}

struct resolver_entity *resolver_new_entity_for_var_node_no_push(
    struct resolver_process *process, struct node *var_node, void *private,
    int offset, struct resolver_scope *scope) {
  struct resolver_entity *entity =
      resolver_create_new_entity_for_var_node_custom_scope(
          process, var_node, private, scope, offset);
  if (!entity) {
    return NULL;
  }

  if (scope->flags & RESOLVER_SCOPE_FLAG_IS_STACK) {
    entity->flags |= RESOLVER_ENTITY_FLAG_IS_STACK;
  }

  return entity;
}

struct resolver_entity *
resolver_new_entity_for_var_node(struct resolver_process *process,
                                 struct node *var_node, void *private,
                                 int offset) {
  struct resolver_entity *entity = resolver_new_entity_for_var_node_no_push(
      process, var_node, private, offset,
      resolver_process_scope_current(process));
  if (!entity) {
    return NULL;
  }

  vector_push(process->scope.current->entities, &entity);
  return entity;
}

void resolver_new_entity_for_rule(struct resolver_process *process,
                                  struct resolver_result *result,
                                  struct resolver_entity_rule *rule) {
  struct resolver_entity *entity_rule =
      resolver_create_new_entity(result, RESOLVER_ENTITY_TYPE_RULE, NULL);
  entity_rule->rule = *rule;
  resolver_result_entity_push(result, entity_rule);
}

struct resolver_entity *resolver_make_entity(
    struct resolver_process *process, struct resolver_result *result,
    struct datatype *custom_dtype, struct node *node,
    struct resolver_entity *guided_entity, struct resolver_scope *scope) {
  struct resolver_entity *entity = NULL;
  int offset = guided_entity->offset;
  int flags = guided_entity->flags;
  switch (node->type) {
  case NODE_TYPE_VARIABLE:
    entity = resolver_new_entity_for_var_node_no_push(process, node, NULL,
                                                      offset, scope);
    break;

  default:
    entity = resolver_create_new_unknown_entity(process, result, custom_dtype,
                                                node, scope, offset);
  }

  if (entity) {
    entity->flags |= flags;
    if (custom_dtype) {
      entity->dtype = *custom_dtype;
    }

    entity->private =
        process->callbacks.make_private(entity, node, offset, scope);
  }
  return entity;
}

struct resolver_entity *resolver_create_new_entity_for_function_call(
    struct resolver_result *result, struct resolver_process *process,
    struct resolver_entity *left_operand_entity, void *private) {
  struct resolver_entity *entity = resolver_create_new_entity(
      result, RESOLVER_ENTITY_TYPE_FUNCTION_CALL, private);
  if (!entity) {
    return NULL;
  }

  entity->dtype = left_operand_entity->dtype;
  entity->func_call_data.arguments = vector_create(sizeof(struct node *));
  // vector_push(cp->gbForVectors, &entity->func_call_data.arguments);
  return entity;
}

struct resolver_entity *
resolver_register_function(struct resolver_process *process,
                           struct node *func_node, void *private) {
  struct resolver_entity *entity =
      resolver_create_new_entity(NULL, RESOLVER_ENTITY_TYPE_FUNCTION, private);
  if (!entity) {
    return NULL;
  }

  entity->name = func_node->func.name;
  entity->node = func_node;
  entity->dtype = func_node->func.rtype;
  entity->scope = resolver_process_scope_current(process);
  vector_push(process->scope.root->entities, &entity);
  return entity;
}

struct resolver_entity *resolver_get_entity_in_scope_with_entity_type(
    struct resolver_result *result, struct resolver_process *resolver,
    struct resolver_scope *scope, const char *entity_name, int entity_type) {

  /*
   * Are we accessing a structure or union
   */
  if (result && result->last_struct_union_entity) {
    struct resolver_scope *scope = result->last_struct_union_entity->scope;
    struct node *out_node = NULL;
    struct datatype *node_var_datatype =
        &result->last_struct_union_entity->dtype;
    int offset =
        struct_offset(resolver_compiler(resolver), node_var_datatype->type_str,
                      entity_name, &out_node, 0, 0);
    if (node_var_datatype->type == DATA_TYPE_UNION) {
      offset = 0;
    }
    return resolver_make_entity(
        resolver, result, NULL, out_node,
        &(struct resolver_entity){.type = RESOLVER_ENTITY_TYPE_VARIABLE,
                                  .offset = offset},
        scope);
  }

  // Dealing with a primtiive type
  vector_set_peek_pointer_end(scope->entities);
  vector_set_flag(scope->entities, VECTOR_FLAG_PEEK_DECREMENT);
  struct resolver_entity *current = vector_peek_ptr(scope->entities);
  while (current) {
    if (entity_type != -1 && current->type != entity_type) {
      current = vector_peek_ptr(scope->entities);
      continue;
    }

    if (S_EQ(current->name, entity_name)) {
      break;
    }

    current = vector_peek_ptr(scope->entities);
  }

  return current;
}

struct resolver_entity *
resolver_get_entity_for_type(struct resolver_result *result,
                             struct resolver_process *resolver,
                             const char *entity_name, int entity_type) {
  struct resolver_scope *scope = resolver->scope.current;
  struct resolver_entity *entity = NULL;
  while (scope) {
    entity = resolver_get_entity_in_scope_with_entity_type(
        result, resolver, scope, entity_name, entity_type);
    if (entity) {
      break;
    }

    scope = scope->prev;
  }

  if (entity) {
    memset(&entity->last_resolve, 0, sizeof(entity->last_resolve));
  }
  return entity;
}

struct resolver_entity *resolver_get_entity(struct resolver_result *result,
                                            struct resolver_process *resolver,
                                            const char *entity_name) {
  return resolver_get_entity_for_type(result, resolver, entity_name, -1);
}

struct resolver_entity *resolver_get_entity_in_scope(
    struct resolver_result *result, struct resolver_process *resolver,
    struct resolver_scope *scope, const char *entity_name) {
  return resolver_get_entity_in_scope_with_entity_type(result, resolver, scope,
                                                       entity_name, -1);
}

struct resolver_entity *resolver_get_variable(struct resolver_result *result,
                                              struct resolver_process *resolver,
                                              const char *var_name) {
  return resolver_get_entity_for_type(result, resolver, var_name,
                                      RESOLVER_ENTITY_TYPE_VARIABLE);
}

struct resolver_entity *resolver_get_function_in_scope(
    struct resolver_result *result, struct resolver_process *resolver,
    const char *func_name, struct resolver_scope *scope) {
  return resolver_get_entity_for_type(result, resolver, func_name,
                                      RESOLVER_ENTITY_TYPE_FUNCTION);
}

struct resolver_entity *resolver_get_function(struct resolver_result *result,
                                              struct resolver_process *resolver,
                                              const char *func_name) {
  struct resolver_entity *entity = NULL;
  struct resolver_scope *scope = resolver->scope.root;
  entity = resolver_get_function_in_scope(result, resolver, func_name, scope);
  return entity;
}

struct resolver_entity *
resolver_follow_for_name(struct resolver_process *resolver, const char *name,
                         struct resolver_result *result) {
  struct resolver_entity *entity =
      resolver_entity_clone(resolver_get_entity(result, resolver, name));
  if (!entity) {
    return NULL;
  }

  resolver_result_entity_push(result, entity);

  // The first found identifier
  if (!result->identifier) {
    result->identifier = entity;
  }

  if (entity->type == RESOLVER_ENTITY_TYPE_VARIABLE &&
          datatype_is_struct_or_union(&entity->var_data.dtype) ||
      (entity->type == RESOLVER_ENTITY_TYPE_FUNCTION &&
       datatype_is_struct_or_union(&entity->dtype))) {
    result->last_struct_union_entity = entity;
  }

  return entity;
}

struct resolver_entity *
resolver_follow_identifier(struct resolver_process *resolver, struct node *node,
                           struct resolver_result *result) {
  struct resolver_entity *entity =
      resolver_follow_for_name(resolver, node->sval, result);
  if (entity) {
    entity->last_resolve.referencing_node = node;
  }
  return entity;
}

struct resolver_entity *
resolver_follow_variable(struct resolver_process *resolver,
                         struct node *var_node,
                         struct resolver_result *result) {
  struct resolver_entity *entity =
      resolver_follow_for_name(resolver, var_node->var.name, result);
  return entity;
}

struct resolver_entity *
resolver_follow_struct_exp(struct resolver_process *resolver, struct node *node,
                           struct resolver_result *result) {
  // a.b
  resolver_follow_part(resolver, node->exp.left, result);
  struct resolver_entity *left_entity = resolver_result_peek(result);
  struct resolver_entity_rule rule = {};
  if (is_access_node_with_op(node, "->")) {
    // a->b (do not merge)
    rule.left.flags = RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_NEXT_ENTITY;
    if (left_entity->type != RESOLVER_ENTITY_TYPE_FUNCTION_CALL) {
      //            int* a;
      //          *a = 50;
      rule.right.flags = RESOLVER_ENTITY_FLAG_DO_INDIRECTION;
    }
  }

  resolver_new_entity_for_rule(resolver, result, &rule);
  resolver_follow_part(resolver, node->exp.right, result);
  return NULL;
}

struct resolver_entity *resolver_follow_array(struct resolver_process *resolver,
                                              struct node *node,
                                              struct resolver_result *result) {
  resolver_follow_part(resolver, node->exp.left, result);
  struct resolver_entity *left_entity = resolver_result_peek(result);
  resolver_follow_part(resolver, node->exp.right, result);
  return left_entity;
}

struct datatype *resolver_get_datatype(struct resolver_process *resolver,
                                       struct node *node) {
  struct resolver_result *result = resolver_follow(resolver, node);
  if (!resolver_result_ok(result)) {
    return NULL;
  }

  return &result->last_entity->dtype;
}

void resolver_build_function_call_arguments(
    struct resolver_process *resolver, struct node *argument_node,
    struct resolver_entity *root_func_call_entity, size_t *total_size_out) {
  if (is_argument_node(argument_node)) {
    // Build the left node for this function argument
    resolver_build_function_call_arguments(resolver, argument_node->exp.left,
                                           root_func_call_entity,
                                           total_size_out);
    // Build the right node for this function argument
    resolver_build_function_call_arguments(resolver, argument_node->exp.right,
                                           root_func_call_entity,
                                           total_size_out);
  } else if (argument_node->type == NODE_TYPE_EXPRESSION_PARENTHESES) {
    resolver_build_function_call_arguments(
        resolver, argument_node->parenthesis.exp, root_func_call_entity,
        total_size_out);
  } else if (node_valid(argument_node)) {
    vector_push(root_func_call_entity->func_call_data.arguments,
                &argument_node);
    size_t stack_change = DATA_SIZE_DWORD;
    struct datatype *dtype = resolver_get_datatype(resolver, argument_node);
    if (dtype) {
      // 4 bytes unless its a structure
      stack_change = datatype_element_size(dtype);
      if (stack_change < DATA_SIZE_DWORD) {
        stack_change = DATA_SIZE_DWORD;
      }

      stack_change = align_value(stack_change, DATA_SIZE_DWORD);
    }
    *total_size_out += stack_change;
  }
}
struct resolver_entity *
resolver_follow_function_call(struct resolver_process *resolver,
                              struct resolver_result *result,
                              struct node *node) {
  resolver_follow_part(resolver, node->exp.left, result);
  struct resolver_entity *left_entity = resolver_result_peek(result);

  struct resolver_entity *func_call_entity =
      resolver_create_new_entity_for_function_call(result, resolver,
                                                   left_entity, NULL);
  if (!func_call_entity) {
    compiler_error(cp, "resolver error: function call entity doesnt exist \n");
  }

  func_call_entity->flags |= RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_NEXT_ENTITY |
                             RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_LEFT_ENTITY;

  resolver_build_function_call_arguments(
      resolver, node->exp.right, func_call_entity,
      &func_call_entity->func_call_data.stack_size);

  // Push the function call entity to the stack
  resolver_result_entity_push(result, func_call_entity);
  return func_call_entity;
}

struct resolver_entity *
resolver_follow_parentheses(struct resolver_process *resolver,
                            struct node *node, struct resolver_result *result) {
  if (node->exp.left->type == NODE_TYPE_IDENTIFIER) {
    return resolver_follow_function_call(resolver, result, node);
  }

  return resolver_follow_exp(resolver, node->parenthesis.exp, result);
}

struct resolver_entity *resolver_follow_exp(struct resolver_process *resolver,
                                            struct node *node,
                                            struct resolver_result *result) {
  struct resolver_entity *entity = NULL;
  if (is_access_node(node)) {
    entity = resolver_follow_struct_exp(resolver, node, result);
  } else if (is_array_node(node)) {
    entity = resolver_follow_array(resolver, node, result);
  } else if (is_parentheses_node(node)) {
    entity = resolver_follow_parentheses(resolver, node, result);
  }
  return entity;
}

void resolver_array_bracket_set_flags(struct resolver_entity *bracket_entity,
                                      struct datatype *dtype,
                                      struct node *bracket_node, int index) {
  if (!(dtype->flags & DATATYPE_FLAG_IS_ARRAY) ||
      array_brackets_count(dtype) <= index) {
    bracket_entity->flags = RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_LEFT_ENTITY |
                            RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_NEXT_ENTITY |
                            RESOLVER_ENTITY_FLAG_IS_POINTER_ARRAY_ENTITY;
  } else if (bracket_node->bracket.inner->type != NODE_TYPE_NUMBER) {
    bracket_entity->flags = RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_LEFT_ENTITY |
                            RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_NEXT_ENTITY;
  } else {
    bracket_entity->flags = RESOLVER_ENTITY_FLAG_JUST_USE_OFFSET;
  }
}
struct resolver_entity *
resolver_follow_array_bracket(struct resolver_process *resolver,
                              struct node *node,
                              struct resolver_result *result) {
  if (node->type != NODE_TYPE_BRACKET) {
    compiler_error(cp, "resolver error: not a bracket node\n");
  }

  int index = 0;
  struct datatype dtype;
  struct resolver_scope *scope = NULL;
  struct resolver_entity *last_entity =
      resolver_result_peek_ignore_rule_entity(result);
  scope = last_entity->scope;
  dtype = last_entity->dtype;
  if (last_entity->type == RESOLVER_ENTITY_TYPE_ARRAY_BRACKET) {
    index = last_entity->array.index + 1;
  }

  if (dtype.flags & DATATYPE_FLAG_IS_ARRAY) {
    dtype.array.size = array_brackets_calculate_size_from_index(
        &dtype, dtype.array.brackets, index + 1);
  }

  // We need to reduce the dtype
  void *private = resolver->callbacks.new_array_entity(result, node);
  struct resolver_entity *array_bracket_entity =
      resolver_create_new_entity_for_array_bracket(result, resolver, node,
                                                   node->bracket.inner, index,
                                                   &dtype, private, scope);
  struct resolver_entity_rule rule = {};
  resolver_array_bracket_set_flags(array_bracket_entity, &dtype, node, index);
  last_entity->flags |= RESOLVER_ENTITY_FLAG_USES_ARRAY_BRACKETS;
  if (array_bracket_entity->flags &
      RESOLVER_ENTITY_FLAG_IS_POINTER_ARRAY_ENTITY) {
    datatype_decrement_pointer(&array_bracket_entity->dtype);
  }

  resolver_result_entity_push(result, array_bracket_entity);
  return array_bracket_entity;
}

struct resolver_entity *
resolver_follow_exp_parenthesis(struct resolver_process *resolver,
                                struct node *node,
                                struct resolver_result *result) {
  return resolver_follow_part_return_entity(resolver, node->parenthesis.exp,
                                            result);
}

struct resolver_entity *
resolver_follow_unsupported_unary_node(struct resolver_process *resolver,
                                       struct node *node,
                                       struct resolver_result *result) {
  return resolver_follow_part_return_entity(resolver, node->unary.operand,
                                            result);
}

struct resolver_entity *
resolver_follow_unsupported_node(struct resolver_process *resolver,
                                 struct node *node,
                                 struct resolver_result *result) {
  bool followed = false;
  switch (node->type) {
  case NODE_TYPE_UNARY:
    resolver_follow_unsupported_unary_node(resolver, node, result);
    followed = true;
    break;

  default:
    followed = false;
  }

  struct resolver_entity *unsupported_entity =
      resolver_create_new_entity_for_unsupported_node(result, node);
  if (!unsupported_entity) {
    compiler_error(cp, "resolver error: unsupported_entity doesnt exist \n");
  }
  resolver_result_entity_push(result, unsupported_entity);
  return unsupported_entity;
}
struct resolver_entity *resolver_follow_cast(struct resolver_process *resolver,
                                             struct node *node,
                                             struct resolver_result *result) {
  struct resolver_entity *operand_entity = NULL;
  resolver_follow_unsupported_node(resolver, node->cast.operand, result);
  operand_entity = resolver_result_peek(result);
  operand_entity->flags |= RESOLVER_ENTITY_FLAG_WAS_CASTED;

  struct resolver_entity *cast_entity = resolver_create_new_cast_entity(
      resolver, operand_entity->scope, &node->cast.dtype);
  resolver_result_entity_push(result, cast_entity);
  return cast_entity;
}

struct resolver_entity *
resolver_follow_indirection(struct resolver_process *resolver,
                            struct node *node, struct resolver_result *result) {
  // Indirection **a.b *a.b *****k
  resolver_follow_part(resolver, node->unary.operand, result);

  struct resolver_entity *last_entity = resolver_result_peek(result);
  if (!last_entity) {
    last_entity =
        resolver_follow_unsupported_node(resolver, node->unary.operand, result);
  }
  struct resolver_entity *unary_indirection_entity =
      resolver_create_new_unary_indirection_entity(
          resolver, result, node, node->unary.indirection.depth);
  resolver_result_entity_push(result, unary_indirection_entity);
  return unary_indirection_entity;
}

struct resolver_entity *
resolver_follow_unary_address(struct resolver_process *resolver,
                              struct node *node,
                              struct resolver_result *result) {
  // &a.b.c
  resolver_follow_part(resolver, node->unary.operand, result);
  struct resolver_entity *last_entity = resolver_result_peek(result);
  struct resolver_entity *unary_address_entity =
      resolver_create_new_unary_get_address_entity(
          resolver, result, &last_entity->dtype, node, last_entity->scope,
          last_entity->offset);
  resolver_result_entity_push(result, unary_address_entity);
  return unary_address_entity;
}

struct resolver_entity *resolver_follow_unary(struct resolver_process *resolver,
                                              struct node *node,
                                              struct resolver_result *result) {
  struct resolver_entity *result_entity = NULL;
  if (op_is_indirection(node->unary.op)) {
    result_entity = resolver_follow_indirection(resolver, node, result);
  } else if (op_is_address(node->unary.op)) {
    result_entity = resolver_follow_unary_address(resolver, node, result);
  }

  return result_entity;
}

struct resolver_entity *
resolver_follow_part_return_entity(struct resolver_process *resolver,
                                   struct node *node,
                                   struct resolver_result *result) {
  struct resolver_entity *entity = NULL;
  switch (node->type) {
  case NODE_TYPE_IDENTIFIER:
    entity = resolver_follow_identifier(resolver, node, result);
    break;
  case NODE_TYPE_VARIABLE:
    entity = resolver_follow_variable(resolver, node, result);
    break;

  case NODE_TYPE_EXPRESSION:
    entity = resolver_follow_exp(resolver, node, result);
    break;

  case NODE_TYPE_BRACKET:
    entity = resolver_follow_array_bracket(resolver, node, result);
    break;

  case NODE_TYPE_EXPRESSION_PARENTHESES:
    entity = resolver_follow_exp_parenthesis(resolver, node, result);
    break;

  case NODE_TYPE_CAST:
    entity = resolver_follow_cast(resolver, node, result);
    break;

  case NODE_TYPE_UNARY:
    entity = resolver_follow_unary(resolver, node, result);
    break;

  default: {
    // Can't do aanything lets create a special entity that requires more
    // computation later on at runtime.
    entity = resolver_follow_unsupported_node(resolver, node, result);
  }
  }

  if (entity) {
    entity->result = result;
    entity->resolver = resolver;
  }

  return entity;
}

void resolver_follow_part(struct resolver_process *resolver, struct node *node,
                          struct resolver_result *result) {
  resolver_follow_part_return_entity(resolver, node, result);
}

void resolver_rule_apply_rules(struct resolver_entity *rule_entity,
                               struct resolver_entity *left_entity,
                               struct resolver_entity *right_entity) {
  if (rule_entity->type != RESOLVER_ENTITY_TYPE_RULE) {
    compiler_error(cp, "Resolver error: not an entity of rule type\n");
  }
  if (left_entity) {
    left_entity->flags |= rule_entity->rule.left.flags;
  }

  if (right_entity) {
    right_entity->flags |= rule_entity->rule.right.flags;
  }
}

void resolver_push_vector_of_entities(struct resolver_result *result,
                                      struct vector *vec) {
  vector_set_peek_pointer_end(vec);
  vector_set_flag(vec, VECTOR_FLAG_PEEK_DECREMENT);
  struct resolver_entity *entity = vector_peek_ptr(vec);
  while (entity) {
    resolver_result_entity_push(result, entity);
    entity = vector_peek_ptr(vec);
  }
}

void resolver_execute_rules(struct resolver_process *resolver,
                            struct resolver_result *result) {
  struct vector *saved_entities =
      vector_create(sizeof(struct resolver_entity *));
  vector_push(cp->gbForVectors, &saved_entities);
  struct resolver_entity *entity = resolver_result_pop(result);
  struct resolver_entity *last_processed_entity = NULL;
  while (entity) {
    if (entity->type == RESOLVER_ENTITY_TYPE_RULE) {
      struct resolver_entity *left_entity = resolver_result_pop(result);
      resolver_rule_apply_rules(entity, left_entity, last_processed_entity);
      entity = left_entity;
    }

    vector_push(saved_entities, &entity);
    last_processed_entity = entity;
    entity = resolver_result_pop(result);
  }

  resolver_push_vector_of_entities(result, saved_entities);
}

struct resolver_entity *resolver_merge_compile_time_result(
    struct resolver_process *resolver, struct resolver_result *result,
    struct resolver_entity *left_entity, struct resolver_entity *right_entity) {
  if (left_entity && right_entity) {
    if (left_entity->flags & RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_NEXT_ENTITY ||
        right_entity->flags & RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_LEFT_ENTITY) {
      goto no_merge_possible;
    }

    struct resolver_entity *result_entity = resolver->callbacks.merge_entities(
        resolver, result, left_entity, right_entity);
    if (!result_entity) {
      goto no_merge_possible;
    }

    return result_entity;
  }

no_merge_possible:
  return NULL;
}

void _resolver_merge_compile_times(struct resolver_process *resolver,
                                   struct resolver_result *result) {
  struct vector *saved_entities =
      vector_create(sizeof(struct resolver_entity *));
  while (1) {
    struct resolver_entity *right_entity = resolver_result_pop(result);
    struct resolver_entity *left_entity = resolver_result_pop(result);
    if (!right_entity) {
      break;
    }

    if (!left_entity) {
      // only one entity
      resolver_result_entity_push(result, right_entity);
      break;
    }

    struct resolver_entity *merged_entity = resolver_merge_compile_time_result(
        resolver, result, left_entity, right_entity);
    if (merged_entity) {
      resolver_result_entity_push(result, merged_entity);
      continue;
    }

    right_entity->flags |= RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_LEFT_ENTITY;
    vector_push(saved_entities, &right_entity);
    // The left entity goes back to the result as we may be able to merge with
    // next entity.
    resolver_result_entity_push(result, left_entity);
  }

  resolver_push_vector_of_entities(result, saved_entities);
  vector_free(saved_entities);
}

void resolver_merge_compile_times(struct resolver_process *resolver,
                                  struct resolver_result *result) {
  size_t total_entities = 0;
  do {
    total_entities = result->count;
    _resolver_merge_compile_times(resolver, result);
  } while (total_entities != 1 && total_entities != result->count);
}

void resolver_finalize_result_flags(struct resolver_process *resolver,
                                    struct resolver_result *result) {
  int flags = RESOLVER_RESULT_FLAG_FIRST_ENTITY_PUSH_VALUE;
  // We need to iterate through all of the results
  struct resolver_entity *entity = result->entity;
  struct resolver_entity *first_entity = entity;
  struct resolver_entity *last_entity = result->last_entity;
  bool does_get_address = false;
  if (entity == last_entity) {
    // We only have one entity
    if (last_entity->type == RESOLVER_ENTITY_TYPE_VARIABLE &&
        datatype_is_struct_or_union_non_pointer(&last_entity->dtype)) {
      flags |= RESOLVER_RESULT_FLAG_FIRST_ENTITY_LOAD_TO_EBX;
      flags &= ~RESOLVER_RESULT_FLAG_FIRST_ENTITY_PUSH_VALUE;
    }

    result->flags = flags;
    return;
  }

  while (entity) {
    if (entity->flags & RESOLVER_ENTITY_FLAG_DO_INDIRECTION) {
      // Load the address of the first entity since we have indirection
      flags |= RESOLVER_RESULT_FLAG_FIRST_ENTITY_LOAD_TO_EBX |
               RESOLVER_RESULT_FLAG_FINAL_INDIRECTION_REQUIRED_FOR_VALUE;
      flags &= ~RESOLVER_RESULT_FLAG_FIRST_ENTITY_PUSH_VALUE;
    }

    if (entity->type == RESOLVER_ENTITY_TYPE_UNARY_GET_ADDRESS) {
      flags |= RESOLVER_RESULT_FLAG_FIRST_ENTITY_LOAD_TO_EBX |
               RESOLVER_RESULT_FLAG_DOES_GET_ADDRESS;
      flags &= ~RESOLVER_RESULT_FLAG_FIRST_ENTITY_PUSH_VALUE |
               RESOLVER_RESULT_FLAG_FINAL_INDIRECTION_REQUIRED_FOR_VALUE;
      does_get_address = true;
    }

    if (entity->type == RESOLVER_ENTITY_TYPE_FUNCTION_CALL) {
      flags |= RESOLVER_RESULT_FLAG_FIRST_ENTITY_LOAD_TO_EBX;
      flags &= ~RESOLVER_RESULT_FLAG_FIRST_ENTITY_PUSH_VALUE;
    }

    if (entity->type == RESOLVER_ENTITY_TYPE_ARRAY_BRACKET) {
      if (entity->dtype.flags & DATATYPE_FLAG_IS_POINTER) {
        flags |= RESOLVER_RESULT_FLAG_FIRST_ENTITY_PUSH_VALUE;
        flags &= ~RESOLVER_RESULT_FLAG_FIRST_ENTITY_LOAD_TO_EBX;
      } else {
        flags |= RESOLVER_RESULT_FLAG_FIRST_ENTITY_LOAD_TO_EBX;
        flags &= ~RESOLVER_RESULT_FLAG_FIRST_ENTITY_PUSH_VALUE;
      }

      if (entity->flags & RESOLVER_ENTITY_FLAG_IS_POINTER_ARRAY_ENTITY) {
        flags |= RESOLVER_RESULT_FLAG_FINAL_INDIRECTION_REQUIRED_FOR_VALUE;
      }
    }

    if (entity->type == RESOLVER_ENTITY_TYPE_GENERAL) {
      flags |= RESOLVER_RESULT_FLAG_FIRST_ENTITY_LOAD_TO_EBX |
               RESOLVER_RESULT_FLAG_FINAL_INDIRECTION_REQUIRED_FOR_VALUE;
      flags &= ~RESOLVER_RESULT_FLAG_FIRST_ENTITY_PUSH_VALUE;
    }

    entity = entity->next;
  }

  if (last_entity->dtype.flags & DATATYPE_FLAG_IS_ARRAY &&
      (!does_get_address &&
       last_entity->type == RESOLVER_ENTITY_TYPE_VARIABLE &&
       !(last_entity->flags & RESOLVER_ENTITY_FLAG_USES_ARRAY_BRACKETS))) {
    // char abc[50]; char* p = abc; abc[0];
    flags &= ~RESOLVER_RESULT_FLAG_FINAL_INDIRECTION_REQUIRED_FOR_VALUE;
  } else if (last_entity->type == RESOLVER_ENTITY_TYPE_VARIABLE) {
    flags |= RESOLVER_RESULT_FLAG_FINAL_INDIRECTION_REQUIRED_FOR_VALUE;
  }

  if (does_get_address) {
    flags &= ~RESOLVER_RESULT_FLAG_FINAL_INDIRECTION_REQUIRED_FOR_VALUE;
  }
  result->flags |= flags;
}

void resolver_finalize_unary(struct resolver_process *resolver,
                             struct resolver_result *result,
                             struct resolver_entity *entity) {
  struct resolver_entity *previous_entity = entity->prev;
  if (!previous_entity) {
    return;
  }

  entity->scope = previous_entity->scope;
  entity->dtype = previous_entity->dtype;
  entity->offset = previous_entity->offset;
  if (entity->type == RESOLVER_ENTITY_TYPE_UNARY_INDIRECTION) {
    int indirection_depth = entity->indirection.depth;
    entity->dtype.pointer_depth -= indirection_depth;
    if (entity->dtype.pointer_depth <= 0) {
      entity->dtype.flags &= ~DATATYPE_FLAG_IS_POINTER;
    }
  } else if (entity->type == RESOLVER_ENTITY_TYPE_UNARY_GET_ADDRESS) {
    entity->dtype.flags |= DATATYPE_FLAG_IS_POINTER;
    entity->dtype.pointer_depth++;
  }
}
void resolver_finalize_last_entity(struct resolver_process *resolver,
                                   struct resolver_result *result) {
  struct resolver_entity *last_entity = resolver_result_peek(result);
  switch (last_entity->type) {
  case RESOLVER_ENTITY_TYPE_UNARY_INDIRECTION:
  case RESOLVER_ENTITY_TYPE_UNARY_GET_ADDRESS:
    resolver_finalize_unary(resolver, result, last_entity);
    break;
  }
}
void resolver_finalize_result(struct resolver_process *resolver,
                              struct resolver_result *result) {
  struct resolver_entity *first_entity = resolver_result_entity_root(result);
  if (!first_entity) {
    // Theirs nothing on the stack.
    return;
  }
  resolver->callbacks.set_result_base(result, first_entity);
  resolver_finalize_result_flags(resolver, result);
  resolver_finalize_last_entity(resolver, result);
}
struct resolver_result *resolver_follow(struct resolver_process *resolver,
                                        struct node *node) {
  if (!resolver) {
    compiler_error(cp, "resolver doesnt exist\n");
  }
  if (!node) {
    compiler_error(cp, "node doesnt exist\n");
  }
  struct resolver_result *result = resolver_new_result(resolver);
  resolver_follow_part(resolver, node, result);
  if (!resolver_result_entity_root(result)) {
    result->flags |= RESOLVER_RESULT_FLAG_FAILED;
  }
  resolver_execute_rules(resolver, result);
  resolver_merge_compile_times(resolver, result);
  resolver_finalize_result(resolver, result);
  return result;
}