resolver.c

#include "compiler.h"
#include "helpers/vector.h"

#include <stdlib.h>
#include <assert.h>

// < Global functions start

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

// > Global functions end

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->root_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));
  return new_entity;
}

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

  return result->root_entity;
}

struct resolver_result* resolver_new_result(struct resolver_process* process)
{
  struct resolver_result* result = calloc(1, sizeof(struct resolver_result));
  result->array_data.array_entities = vector_create(sizeof(struct resolver_entity*));
  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 resolve_runtime_needed(struct resolver_result* result, struct resolver_entity* last_entity)
{
  result->root_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->root_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->root_entity)
  {
    return NULL;
  }

  if (result->root_entity == result->last_entity)
  {
    result->root_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->root_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_root(struct resolver_process* process)
{
  return process->scope.root;
}

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

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*));
  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;
  resolver->callbacks.delete_scope(scope);
  free(scope);
}

struct resolver_process* resolver_new_process(struct compile_process* compiler, struct resolver_callbacks* callbacks)
{
  struct resolver_process* process = calloc(1, sizeof(struct resolver_process));
  process->compiler = compiler;
  memcpy(&process->callbacks, callbacks, sizeof(struct resolver_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;

  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;
  assert(entity->scope);
  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_merges_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;
  assert(entity->scope);
  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_entity_for_unknown_entity(struct resolver_process* process, struct resolver_result* result, struct datatype* dtype, struct resolver_scope* scope, struct node* node, 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_LEFT_ENTITY | RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_NEXT_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 for getting address i.e &a.b.c
 * 
 * @param process 
 * @param result 
 * @param dtype 
 * @param scope 
 * @param node 
 * @return struct resolver_entity* the created entity
 */
struct resolver_entity* resolver_create_new_unary_get_address_entity(struct resolver_process* process, struct resolver_result* result, struct datatype* dtype, struct resolver_scope* scope, struct node* node)
{
  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, struct resolver_scope* scope, void* private, int offset)
{
  assert(var_node->type == NODE_TYPE_VARIABLE);
  struct resolver_entity* entity = resolver_create_new_entity(NULL, RESOLVER_ENTITY_TYPE_VARIABLE, private);
  if (!entity)
  {
    return NULL;
  }

  entity->scope = scope;
  assert(entity->scope);
  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, resolver_scope_current(process), private, offset);
}

struct resolver_entity* resolver_create_new_entity_for_var_node_no_push(struct resolver_process* process, struct resolver_scope* scope, struct node* var_node, void* private, int offset)
{
  struct resolver_entity* entity = resolver_create_new_entity_for_var_node_custom_scope(process, var_node, scope, private, 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_create_new_entity_for_var_node_no_push(process, resolver_scope_current(process), var_node, private, offset);
  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_create_new_entity_for_var_node_no_push(process, scope, node, NULL, offset);
      break;

    default:
      entity = resolver_create_new_entity_for_unknown_entity(process, result, custom_dtype, scope, node, 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_process* process, struct resolver_result* result, 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->name = left_operand_entity->name;
  entity->func_call_data.arguments = vector_create(sizeof(struct node*));

  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_process* resolver, struct resolver_result* result, 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* struct_union_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 primitive datatype
  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_process* resolver, struct resolver_result* result, 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(resolver, result, 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_process* resolver, struct resolver_result* result, const char* entity_name)
{
  return resolver_get_entity_for_type(resolver, result, entity_name, -1);
}

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

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

struct resolver_entity* resolver_get_variable_from_local_scope(struct resolver_process* resolver, const char* var_name)
{
  struct resolver_result* result = resolver_new_result(resolver);
  return resolver_get_entity_in_scope(resolver, result, resolver_scope_current(resolver), var_name);
}

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

  if (!entity)
  {
    entity = resolver_get_entity_for_type(resolver, result, func_name, RESOLVER_ENTITY_TYPE_NATIVE_FUNCTION);
  }

  return entity;
}

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

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(resolver, result, name));
  if (!entity)
  {
    return NULL;
  }

  resolver_result_entity_push(result, entity);

  // The first found identitfier
  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_create_new_entity_for_native_function(struct resolver_process* process, const char* name, struct symbol* native_func_symbol)
{
  struct resolver_entity* entity = resolver_create_new_entity(NULL, RESOLVER_ENTITY_TYPE_NATIVE_FUNCTION, NULL);
  if (!entity)
  {
    return NULL;
  }

  // Make a void return type
  datatype_set_void(&entity->dtype);
  make_function_node(&entity->dtype, name, NULL, NULL);
  entity->node = node_pop();
  entity->name = name;
  entity->native_func.symbol = native_func_symbol;
  entity->scope = resolver_process_scope_current(process);
  vector_push(process->scope.root->entities, &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)
  {
    struct symbol* symbol = symresolver_get_symbol_for_native_function(resolver->compiler, node->sval);
    if (symbol)
    {
      // We have a native function
      entity = resolver_create_new_entity_for_native_function(resolver, symbol->name, symbol);
      resolver_result_entity_push(result, entity);
    }
  }

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

bool resolver_do_indirection(struct resolver_entity* entity)
{
  struct resolver_result* result = entity->result;
  return entity->type != RESOLVER_ENTITY_TYPE_FUNCTION_CALL &&
         !(result->flags & RESOLVER_RESULT_FLAG_DOES_GET_ADDRESS) &&
         entity->type != RESOLVER_ENTITY_TYPE_CAST;
}

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 (resolver_do_indirection(left_entity))
    {
      // 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;
}

void resolver_build_function_call_arguments(struct resolver_process* resolver, struct node* argument_node, struct resolver_entity* root_func_cal_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_cal_entity, total_size_out);
    // Build the right node for this function argument
    resolver_build_function_call_arguments(resolver, argument_node->exp.right, root_func_cal_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_cal_entity, total_size_out);
  }
  else if (node_is_valid(argument_node))
  {
    vector_push(root_func_cal_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 it's 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 node* node, struct resolver_result* result)
{
  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(resolver, result, left_entity, NULL);
  assert(func_call_entity);
  func_call_entity->flags |= RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_LEFT_ENTITY | RESOLVER_ENTITY_FLAG_NO_MERGE_WITH_NEXT_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, node, result);
  }

  return resolver_follow_exp(resolver, node, 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)
{
  assert(node->type == NODE_TYPE_BRACKET);
  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);
  assert(unsupported_entity);
  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);
  if (datatype_is_struct_or_union(&node->cast.dtype))
  {
    if (!cast_entity->scope)
    {
      cast_entity->scope = resolver->scope.current;
    }

    result->last_struct_union_entity = cast_entity;
  }

  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
  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->unary.operand, 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
  result->flags |= RESOLVER_RESULT_FLAG_DOES_GET_ADDRESS;
  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, last_entity->scope, node);
  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 (is_indirection_operator(node->unary.op))
  {
    result_entity = resolver_follow_indirection(resolver, node, result);
  }
  else if (is_address_operator(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 anything, let's 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)
{
  assert(rule_entity->type == RESOLVER_ENTITY_TYPE_RULE);

  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*));
  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_times_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_times_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->root_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;
    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)
  {
    // There is 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)
{
  assert(resolver);
  assert(node);
  
  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;
}