evaluator.h File Reference

#include <stdint.h>
#include "types/ast.h"
#include "types/mir.h"
#include "types/module.h"

Include dependency graph for evaluator.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int64_t	eval_expression (hashtable_t *variables, module_t *module, ast_node_t *ast)
	Evaluates a mathetical expression.
void	eval_bitfield (mir_t *mir, module_t *module, ast_node_t *ast)
	Evaluates a bitfield statement.
void	eval_include (mir_t *mir, module_t *module, ast_node_t *ast)
	Evaluates an include statement.
void	eval_inst (mir_t *mir, module_t *module, ast_node_t *ast)
	Evaluates an inst statement.
void	eval_register (mir_t *mir, module_t *module, ast_node_t *ast)
	Evaluates a register statement.
void	eval_set (mir_t *mir, module_t *module, ast_node_t *ast)
	Evaluates a set statement.
void	eval_bitfield_spec (mir_bitfield_spec_t *spec, module_t *module, ast_node_t *ast, hashtable_t *variables)
	Evaluates a bitfield specification expression.

Function Documentation

eval_bitfield()

void eval_bitfield	(	mir_t *	mir,
		module_t *	module,
		ast_node_t *	ast )

Evaluates a bitfield statement.

Parameters

mir	The MIR struct where to add the intermediate represetation.
module	Mya module where the statement is in.
ast	The AST node where start the statement.

Definition at line 9 of file eval_bitfield.c.

{
  if (ast->type != NT_STATEMENT || ast->token->value != KEY_BITFIELD) {
    module_add_error(
      module,
      ast->token->line,
      ast->token->column,
      ast->token->lexeme.length,
      "Unexpected token where is expected a bitfield statement."
    );
 
    return;
  }
 
  ast_node_t* node_name = &ast->children[0];
  ast_node_t* node_size = &ast->children[1];
 
  int64_t size = eval_expression(&mir->variables, module, node_size);
  if (size < 0 || size > 512) {
    module_add_error(
      module,
      node_size->token->line,
      node_size->token->column,
      node_size->token->lexeme.length,
      "Bitfield size should be between 0 and 512."
    );
 
    return;
  }
 
  const char* name = node_name->token->lexeme.data;
  if (! isupper(name[0])) {
    module_add_error(
      module,
      node_name->token->line,
      node_name->token->column,
      node_name->token->lexeme.length,
      "Bitfield name should start with upper case."
    );
 
    return;
  }
 
  mir_bitfield_t* bitfield = mir_add_bitfield(mir, name, size);
  if (ast->children_count != 3) {
    return;
  }
 
  ast_node_t* node_body = &ast->children[2];
  if (node_body->type != NT_BITFIELD_BODY) {
    module_add_error(
      module,
      node_body->token->line,
      node_body->token->column,
      node_body->token->lexeme.length,
      "Bitfield body declaration expected here."
    );
 
    return;
  }
 
  int64_t total_size = 0;
 
  for (int i = 0; i < node_body->children_count; i++) {
    ast_node_t* field = &node_body->children[i];
    const char* field_name = field->token->lexeme.data;
    int64_t field_size = eval_expression(&mir->variables, module, field->children);
 
    mir_bitfield_add_field(bitfield, field_name, field_size);
 
    total_size += field_size;
  }
 
  if (size != total_size) {
    module_add_error(
      module,
      node_size->token->line,
      node_size->token->column,
      node_size->token->lexeme.length,
      "Bitfield size should be equal to the sum of all field sizes."
    );
  }
}

eval_bitfield_spec()

void eval_bitfield_spec	(	mir_bitfield_spec_t *	spec,
		module_t *	module,
		ast_node_t *	ast,
		hashtable_t *	variables )

Evaluates a bitfield specification expression.

Parameters

spec	The spec struct where to save the spec data.
module	Mya module where the expression is in.
ast	The AST node where start the bitfield specification.
variables	The hashtable with the declared variables.

Definition at line 10 of file eval_bitfield_spec.c.

{
  if (ast->type != NT_BITFIELD_SPEC) {
    module_add_error(
      module,
      ast->token->line,
      ast->token->column,
      ast->token->lexeme.length,
      "Unexpected token where is expected a bitfield specification expression."
    );
 
    return;
  }
 
  ast_node_t* field_spec = &ast->children[0];
  if (field_spec->type != NT_FIELD_SPEC) {
    module_add_error(
      module,
      ast->token->line,
      ast->token->column,
      ast->token->lexeme.length,
      "Unexpected token where is expected a bitfield specification's field list or expression."
    );
 
    return;
  }
 
  dstring_copy(&spec->name, ast->token->lexeme.data);
  spec->type = _spec_type(ast);
 
  switch (spec->type) {
  case FT_SPEC:
    mir_bitfield_spec_set_spec(spec, field_spec->children[0].token->lexeme.data, FT_LITERAL);
    eval_bitfield_spec(spec->spec, module, &field_spec->children[0], variables);
    break;
  case FT_LITERAL:
    spec->value = eval_expression(variables, module, field_spec->children);
    break;
  case FT_IDENTIFIER:
    dstring_copy(&spec->identifier, field_spec->children[0].token->lexeme.data);
    break;
  case FT_FIELDS:
    for (int i = 0; i < field_spec->children_count; i++) {
      mir_bitfield_spec_t* field =
        mir_bitfield_spec_add_field(spec, field_spec->children[i].token->lexeme.data, FT_LITERAL);
      eval_bitfield_spec(field, module, &field_spec->children[i], variables);
    }
    break;
  }
}

eval_expression()

int64_t eval_expression	(	hashtable_t *	variables,
		module_t *	module,
		ast_node_t *	ast )

Evaluates a mathetical expression.

Parameters

variables	The hashtable with the declared variables.
module	Mya module where this expression is in.
ast	The AST node where start the expression.

Definition at line 15 of file eval_expression.c.

{
  int64_t result;
 
  if (ast->type != NT_EXPRESSION) {
    module_add_error(
      module,
      ast->token->line,
      ast->token->column,
      ast->token->lexeme.length,
      "Unexpected token inside an expression."
    );
 
    return 0;
  }
 
  switch (ast->token->type) {
  case TK_OPEN_PARENS:
    return eval_expression(variables, module, ast->children);
  case TK_NUMBER:
    return ast->token->value;
  case TK_IDENTIFIER:
    if (hashtable_get(variables, ast->token->lexeme.data, &result) != ERR_OK) {
      module_add_error(module, ast->token->line, ast->token->column, ast->token->lexeme.length, "Undefined variable.");
      return 0;
    }
 
    return result;
  case TK_OPERATOR:
    bool is_binary = (ast->children_count == 2);
    ast_node_t* a = &ast->children[0];
 
    if (is_binary) {
      ast_node_t* b = &ast->children[1];
      return _op_binary_eval(
        eval_expression(variables, module, a),
        ast->token->value,
        eval_expression(variables, module, b)
      );
    }
 
    return _op_unary_eval(ast->token->value, eval_expression(variables, module, a));
  default:
    return 0;
  }
}

eval_include()

void eval_include	(	mir_t *	mir,
		module_t *	module,
		ast_node_t *	ast )

Evaluates an include statement.

Parameters

mir	The MIR struct where to add the intermediate represetation.
module	Mya module where the statement is in.
ast	The AST node where start the statement.

Definition at line 8 of file eval_include.c.

{
  if (ast->type != NT_STATEMENT || ast->token->value != KEY_INCLUDE) {
    module_add_error(
      module,
      ast->token->line,
      ast->token->column,
      ast->token->lexeme.length,
      "Unexpected token where is expected an include statement."
    );
 
    return;
  }
 
  token_t* token_path = ast->children[0].token;
  module_t* submodule = module_add_submodule(module);
  if (module_init(submodule, token_path->lexeme.data) != ERR_OK) {
    module_add_error(
      module,
      token_path->line,
      token_path->column,
      token_path->lexeme.length,
      "File not found. You should use an absolute path or a relative path from the current working directory."
    );
 
    return;
  }
 
  if (mya_lexer(submodule) != ERR_OK) {
    return;
  }
 
  if (mya_parser(submodule) != ERR_OK) {
    return;
  }
 
  mya_evaluator(mir, submodule);
}

eval_inst()

void eval_inst	(	mir_t *	mir,
		module_t *	module,
		ast_node_t *	ast )

Evaluates an inst statement.

Parameters

mir	The MIR struct where to add the intermediate represetation.
module	Mya module where the statement is in.
ast	The AST node where start the statement.

eval_register()

void eval_register	(	mir_t *	mir,
		module_t *	module,
		ast_node_t *	ast )

Evaluates a register statement.

Parameters

mir	The MIR struct where to add the intermediate represetation.
module	Mya module where the statement is in.
ast	The AST node where start the statement.

Definition at line 7 of file eval_register.c.

{
  if (ast->type != NT_STATEMENT || ast->token->value != KEY_REGISTER) {
    module_add_error(
      module,
      ast->token->line,
      ast->token->column,
      ast->token->lexeme.length,
      "Unexpected token where is expected a register statement."
    );
 
    return;
  }
 
  ast_node_t* node_name = &ast->children[0];
  ast_node_t* node_size = &ast->children[1];
  ast_node_t* node_spec = &ast->children[2];
 
  int64_t size = eval_expression(&mir->variables, module, node_size);
  if (size < 0 || size > 4096) {
    module_add_error(
      module,
      node_size->token->line,
      node_size->token->column,
      node_size->token->lexeme.length,
      "Register size should be between 0 and 4096."
    );
 
    return;
  }
 
  mir_register_t* reg = mir_add_register(mir, node_name->token->lexeme.data, size);
  eval_bitfield_spec(&reg->spec, module, node_spec, &mir->variables);
}

eval_set()

void eval_set	(	mir_t *	mir,
		module_t *	module,
		ast_node_t *	ast )

Evaluates a set statement.

Parameters

mir	The MIR struct where to add the intermediate represetation.
module	Mya module where the statement is in.
ast	The AST node where start the statement.

Definition at line 8 of file eval_set.c.

{
  if (ast->type != NT_STATEMENT || ast->token->value != KEY_SET) {
    module_add_error(
      module,
      ast->token->line,
      ast->token->column,
      ast->token->lexeme.length,
      "Unexpected token where is expected a set statement."
    );
 
    return;
  }
 
  ast_node_t* node_var = &ast->children[0];
  ast_node_t* node_value = &ast->children[1];
 
  int64_t value = eval_expression(&mir->variables, module, node_value);
  hashtable_set(&mir->variables, node_var->token->lexeme.data, value);
}