parser.h File Reference

#include "types/err.h"
#include "types/module.h"
#include "types/token.h"

Include dependency graph for parser.h:

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

Go to the source code of this file.

Functions
unsigned int	parse_statement (module_t *module, ast_node_t *parent, token_t *token)
	Parse a statement adding it as a children on parent AST node.
unsigned int	parse_statement_include (module_t *module, ast_node_t *parent, token_t *token)
	Parse a include statement adding it as a children on parent AST node.
unsigned int	parse_statement_set (module_t *module, ast_node_t *parent, token_t *token)
	Parse a set statement adding it as a children on parent AST node.
unsigned int	parse_statement_bitfield (module_t *module, ast_node_t *parent, token_t *token)
	Parse a bitfield statement adding it as a children on parent AST node.
unsigned int	parse_statement_register (module_t *module, ast_node_t *parent, token_t *token)
	Parse a register statement adding it as a children on parent AST node.
unsigned int	parse_statement_inst (module_t *module, ast_node_t *parent, token_t *token)
	Parse a inst statement adding it as a children on parent AST node.
unsigned int	parse_expression (module_t *module, ast_node_t *parent, token_t *token)
	Parse a mathematical expression adding it as a children on parent AST node.
unsigned int	parse_size_spec (module_t *module, ast_node_t *parent, token_t *token, const char *example)
	Parse a size specification in the format [ EXPRESSION ] adding it as a children on parent AST node.
unsigned int	parse_bitfield_spec (module_t *module, ast_node_t *parent, token_t *token)
	Parse a bitfield specification in the format Bitfield { FIELD_LIST } or Bitfield { EXPRESSION } adding it as a children on parent AST node.
unsigned int	parse_fieldlist_spec (module_t *module, ast_node_t *parent, token_t *token)
	Parse a field list specification in the format field = EXPRESSION, ... adding it as a children on parent AST node.
unsigned int	parse_advance (token_t *token, token_type_t *types, size_t ntypes)
	Finds the next token TK_EOF or any of the specified types and then returns the number of tokens traveled.

Function Documentation

parse_advance()

unsigned int parse_advance	(	token_t *	token,
		token_type_t *	types,
		size_t	ntypes )

Finds the next token TK_EOF or any of the specified types and then returns the number of tokens traveled.

This function could be used to skip wrong tokens when a error as found on parsing a statement. So it's avoid a lot of useless error messages.

Parameters

token	Pointer for the first token where to start searching.
types	Array of token types to search.
ntypes	Size of types array.

Definition at line 125 of file parse_common.c.

{
  int ntokens = 0;
 
  while (token[ntokens].type != TK_EOF) {
    for (int i = 0; i < ntypes; i++) {
      if (token[ntokens].type == types[i]) {
        return ntokens;
      }
    }
 
    ntokens++;
  }
 
  return ntokens;
}

parse_bitfield_spec()

unsigned int parse_bitfield_spec	(	module_t *	module,
		ast_node_t *	parent,
		token_t *	token )

Parse a bitfield specification in the format Bitfield { FIELD_LIST } or Bitfield { EXPRESSION } adding it as a children on parent AST node.

Parameters

module	The module where the AST is.
parent	The AST node parent for the bitfield specification.
token	The token where to start parsing the bitfield specification.

Returns

The number of tokens used on the bitfield specification.

Definition at line 47 of file parse_common.c.

{
  ast_node_t* node_statement = ast_add_children(parent, NT_BITFIELD_SPEC, token);
  token_t* tkid = token;
  token_t* tkopen_braces = token + 1;
 
  if (tkid->type != TK_IDENTIFIER) {
    module_add_error(
      module,
      tkid->line,
      tkid->column,
      tkid->lexeme.length,
      "Expected a bitfield identifier here. Example: Reg{1}"
    );
 
    return 1;
  }
 
  if (tkopen_braces->type != TK_OPEN_BRACES) {
    module_add_error(
      module,
      tkopen_braces->line,
      tkopen_braces->column,
      tkopen_braces->lexeme.length,
      "Expected a open braces after bitfield name. Examples:\n"
      "    Reg{1}\n"
      "\n"
      "    Opcode {\n"
      "        opcode = 0x01,\n"
      "        reg = Reg{arg1}\n"
      "    }"
    );
 
    return 2;
  }
 
  unsigned int ntokens = 1 + parse_fieldlist_spec(module, node_statement, tkopen_braces);
 
  token_t* tkclose_braces = token + ntokens - 1;
  if (tkclose_braces->type != TK_CLOSE_BRACES) {
    module_add_error(
      module,
      tkclose_braces->line,
      tkclose_braces->column,
      tkclose_braces->lexeme.length,
      "Expected a close braces at end of field specification list. Examples:\n"
      "    Reg{1}\n"
      "\n"
      "    Opcode {\n"
      "        opcode = 0x01,\n"
      "        reg = Reg{arg1},\n"
      "    }"
    );
  }
 
  return ntokens;
}

parse_expression()

unsigned int parse_expression	(	module_t *	module,
		ast_node_t *	parent,
		token_t *	token )

Parse a mathematical expression adding it as a children on parent AST node.

Parameters

module	The module where the AST is.
parent	The AST node parent for the expression.
token	The token where to start parsing the expression.

Returns

The number of tokens used on the expression.

Definition at line 17 of file parse_expression.c.

{
  stack_t stack;
  ast_node_t node;
  token_t* current_token;
  ast_node_t* child;
  unsigned int ntokens = 0;
 
  if (token->type == TK_IDENTIFIER && token[1].type == TK_OPEN_BRACES) {
    return parse_bitfield_spec(module, parent, token);
  }
 
  stack_init(&stack);
 
  for (;;) {
    current_token = &token[ntokens];
 
    switch (current_token->type) {
    case TK_OPEN_PARENS:
      child = stack_push(&stack, NT_EXPRESSION, current_token);
      ntokens += 1 + parse_expression(module, child, current_token + 1);
 
      if (token[ntokens].type != TK_CLOSE_PARENS) {
        module_add_error(
          module,
          child->token->line,
          child->token->column,
          child->token->lexeme.length,
          "Open parentheses starting here has not a expected close parentheses matching it."
        );
 
        return ntokens;
      }
 
      ntokens++;
      break;
    case TK_IDENTIFIER:
    case TK_NUMBER:
      stack_push(&stack, NT_EXPRESSION, current_token);
      ntokens++;
      break;
    case TK_OPERATOR:
      ntokens += _parse_operator(module, parent, &stack, current_token);
      break;
    case TK_EQUAL:
      ntokens += _parse_binary_operator(module, parent, &stack, current_token);
      break;
    case TK_SEMICOLON:
    case TK_CLOSE_PARENS:
    case TK_CLOSE_BRACES:
    case TK_CLOSE_BRACKET:
    case TK_COMMA:
    case TK_EOF:
      goto finish_expression;
    default:
      module_add_error(
        module,
        current_token->line,
        current_token->column,
        current_token->lexeme.length,
        "Unexpected token inside an expression."
      );
 
      ntokens++;
      goto finish_expression;
    }
  }
 
 
finish_expression:
  // We expect to only have one expression on stack at end. It's the root node of the expression.
 
  if (stack_isempty(&stack)) {
    module_add_error(module, token->line, token->column, token->lexeme.length, "Malformed expression starting here.");
    stack_close(&stack);
    return ntokens;
  }
 
  stack_pop(&stack, &node);
 
  if (! stack_isempty(&stack)) {
    stack_pop(&stack, &node);
 
    module_add_error(
      module,
      node.token->line,
      node.token->column,
      node.token->lexeme.length,
      "Unexpected expression starting here."
    );
 
    stack_close(&stack);
    return ntokens;
  }
 
  ast_insert_children(parent, &node);
  stack_close(&stack);
  return ntokens;
}

parse_fieldlist_spec()

unsigned int parse_fieldlist_spec	(	module_t *	module,
		ast_node_t *	parent,
		token_t *	token )

Parse a field list specification in the format field = EXPRESSION, ... adding it as a children on parent AST node.

Parameters

module	The module where the AST is.
parent	The AST node parent for the field list specification.
token	The token where to start parsing the field list specification. It should be the open braces ({).

Returns

The number of tokens used on the field list specification.

Definition at line 106 of file parse_common.c.

{
  ast_node_t* node_statement = ast_add_children(parent, NT_FIELD_SPEC, token);
  unsigned int ntokens = 0;
 
  do {
    ntokens++;
 
    if (token[ntokens].type == TK_CLOSE_BRACES) {
      break;
    }
 
    ntokens += parse_expression(module, node_statement, &token[ntokens]);
  } while (token[ntokens].type == TK_COMMA);
 
  return ntokens + 1;
}

parse_size_spec()

unsigned int parse_size_spec	(	module_t *	module,
		ast_node_t *	parent,
		token_t *	token,
		const char *	example )

Parse a size specification in the format [ EXPRESSION ] adding it as a children on parent AST node.

Parameters

module	The module where the AST is.
parent	The AST node parent for the size specification.
token	The token where to start parsing the size specification.
example	A code example printed on error messages when the size spec is syntactically wrong.

Returns

The number of tokens used on the size specification.

Definition at line 7 of file parse_common.c.

{
  char message[128];
  token_t* tkopen_bracket = token;
  token_t* tkexpr = token + 1;
 
  if (tkopen_bracket->type != TK_OPEN_BRACKET) {
    snprintf(
      message,
      sizeof message - 1,
      "Expected a size specifier after the %s name. Example: %s",
      mya_keywords[token->value],
      example
    );
 
    module_add_error(module, tkopen_bracket->line, tkopen_bracket->column, tkopen_bracket->lexeme.length, message);
 
    return 2;
  }
 
  unsigned int ntokens = parse_expression(module, parent, tkexpr);
 
  token_t* tkclose_bracket = token + ntokens + 1;
 
  if (tkclose_bracket->type != TK_CLOSE_BRACKET) {
    snprintf(message, sizeof message - 1, "Expected a close bracket here. Example: %s", example);
 
    module_add_error(
      module,
      tkclose_bracket->line,
      tkclose_bracket->column,
      tkclose_bracket->lexeme.length,
      "Expected a close bracket here. Example: bitfield Name[4]"
    );
  }
 
  return ntokens + 2;
}

parse_statement()

unsigned int parse_statement	(	module_t *	module,
		ast_node_t *	parent,
		token_t *	token )

Parse a statement adding it as a children on parent AST node.

Parameters

module	The module where the AST is.
parent	The AST node parent for the statement.
token	The token where to start parsing the statement.

Returns

The number of tokens used on the statement.

Definition at line 8 of file parse_statement.c.

{
  if (token->type != TK_KEYWORD) {
    module_add_error(
      module,
      token->line,
      token->column,
      token->lexeme.length,
      "This token is unexpected here. It's expected to be a valid statement keyword."
    );
 
    return 1;
  }
 
  switch (token->value) {
  case KEY_INCLUDE:
    return parse_statement_include(module, parent, token);
  case KEY_SET:
    return parse_statement_set(module, parent, token);
  case KEY_BITFIELD:
    return parse_statement_bitfield(module, parent, token);
  case KEY_REGISTER:
    return parse_statement_register(module, parent, token);
  case KEY_INST:
    return parse_statement_inst(module, parent, token);
  default:
    module_add_error(
      module,
      token->line,
      token->column,
      token->lexeme.length,
      "It's an invalid statement keyword. Are you sure it's a valid command or declaration?"
    );
 
    return 1;
  }
}

parse_statement_bitfield()

unsigned int parse_statement_bitfield	(	module_t *	module,
		ast_node_t *	parent,
		token_t *	token )

Parse a bitfield statement adding it as a children on parent AST node.

Parameters

module	The module where the AST is.
parent	The AST node parent for the statement.
token	The token where to start parsing the statement.

Returns

The number of tokens used on the statement.

Definition at line 10 of file parse_statement_bitfield.c.

{
  ast_node_t* node_statement = ast_add_children(parent, NT_STATEMENT, token);
  token_t* tkid = token + 1;
 
  if (tkid->type != TK_IDENTIFIER) {
    module_add_error(
      module,
      tkid->line,
      tkid->column,
      tkid->lexeme.length,
      "Expected an identifier here. Example: bitfield Name[4]"
    );
 
    return 1;
  }
 
  ast_add_children(node_statement, NT_IDENTIFIER, tkid);
  unsigned int ntokens = 2 + parse_size_spec(module, node_statement, token + 2, "bitfield Name[4]");
 
  token_t* tkopen_braces = token + ntokens;
 
  if (tkopen_braces->type == TK_OPEN_BRACES) {
    ast_node_t* body = ast_add_children(node_statement, NT_BITFIELD_BODY, tkopen_braces);
    ntokens += 1 + _parse_bitfield_body(module, body, tkopen_braces + 1);
  }
 
  return ntokens;
}

parse_statement_include()

unsigned int parse_statement_include	(	module_t *	module,
		ast_node_t *	parent,
		token_t *	token )

Parse a include statement adding it as a children on parent AST node.

Parameters

module	The module where the AST is.
parent	The AST node parent for the statement.
token	The token where to start parsing the statement.

Returns

The number of tokens used on the statement.

Definition at line 6 of file parse_statement_include.c.

{
  ast_node_t* node_statement = ast_add_children(parent, NT_STATEMENT, token);
  token_t* tkstring = token + 1;
  token_t* tksemicolon = token + 2;
 
  if (tkstring->type != TK_STRING) {
    module_add_error(
      module,
      tkstring->line,
      tkstring->column,
      tkstring->lexeme.length,
      "Expected literal string here. Example: include \"module.mya\";"
    );
 
    return 1;
  }
 
  if (tksemicolon->type != TK_SEMICOLON) {
    module_add_error(
      module,
      tkstring->line,
      tkstring->column + tkstring->lexeme.length + 1,
      1,
      "Expected semicolon at end of the include command. Example: include \"module.mya\";"
    );
  }
 
  ast_add_children(node_statement, NT_STRING, tkstring);
 
  return 2 + (tksemicolon->type == TK_SEMICOLON);
}

parse_statement_inst()

unsigned int parse_statement_inst	(	module_t *	module,
		ast_node_t *	parent,
		token_t *	token )

Parse a inst statement adding it as a children on parent AST node.

Parameters

module	The module where the AST is.
parent	The AST node parent for the statement.
token	The token where to start parsing the statement.

Returns

The number of tokens used on the statement.

Definition at line 14 of file parse_statement_inst.c.

{
  ast_node_t* node_statement = ast_add_children(parent, NT_STATEMENT, token);
  token_t* tkid = token + 1;
 
  if (tkid->type != TK_IDENTIFIER) {
    module_add_error(
      module,
      tkid->line,
      tkid->column,
      tkid->lexeme.length,
      "Expected an identifier here. Example: inst mov[16](arg1: register[32], arg2: immediate[8]) { ... }"
    );
 
    return 1;
  }
 
  ast_add_children(node_statement, NT_IDENTIFIER, tkid);
  unsigned int ntokens =
    2 +
    parse_size_spec(module, node_statement, token + 2, "inst mov[16](arg1: register[32], arg2: immediate[8]) { ... }");
 
  token_t* tkopen_parens = token + ntokens;
 
  if (tkopen_parens->type != TK_OPEN_PARENS) {
    module_add_error(
      module,
      tkopen_parens->line,
      tkopen_parens->column,
      tkopen_parens->lexeme.length,
      "Expected a list of arguments for the instruction inside parentheses. Example: inst mov[16](arg1: register[32], "
      "arg2: immediate[8]) { ... }"
    );
 
    return ntokens + 1;
  }
 
  ntokens += _parse_inst_args(module, node_statement, tkopen_parens);
 
  token_t* tkopen_braces = token + ntokens;
  if (tkopen_braces->type != TK_OPEN_BRACES) {
    module_add_error(
      module,
      tkopen_braces->line,
      tkopen_braces->column,
      tkopen_braces->lexeme.length,
      "Expected an open braces at start of the body of the instruction. Example: inst mov[16](arg1: register[32], "
      "arg2: immediate[8]) { ... }"
    );
 
    return ntokens;
  }
 
  ntokens += parse_fieldlist_spec(module, node_statement, token + ntokens);
 
  return ntokens;
}

parse_statement_register()

unsigned int parse_statement_register	(	module_t *	module,
		ast_node_t *	parent,
		token_t *	token )

Parse a register statement adding it as a children on parent AST node.

Parameters

module	The module where the AST is.
parent	The AST node parent for the statement.
token	The token where to start parsing the statement.

Returns

The number of tokens used on the statement.

Definition at line 6 of file parse_statement_register.c.

{
  ast_node_t* node_statement = ast_add_children(parent, NT_STATEMENT, token);
  token_t* tkid = token + 1;
 
  if (tkid->type != TK_IDENTIFIER) {
    module_add_error(
      module,
      tkid->line,
      tkid->column,
      tkid->lexeme.length,
      "Expected an identifier here. Example: register r1[32] = Reg{1}"
    );
 
    return 1;
  }
 
  ast_add_children(node_statement, NT_IDENTIFIER, tkid);
  unsigned int ntokens = 2 + parse_size_spec(module, node_statement, token + 2, "register r1[32] = Reg{1}");
 
  token_t* tkequal = token + ntokens;
 
  if (tkequal->type != TK_EQUAL) {
    module_add_error(
      module,
      tkequal->line,
      tkequal->column,
      tkequal->lexeme.length,
      "Expected an equal symbol here. Example: register r1[32] = Reg{1}"
    );
 
    return ntokens + 1;
  }
 
  return ntokens + 1 + parse_bitfield_spec(module, node_statement, tkequal + 1);
}

parse_statement_set()

unsigned int parse_statement_set	(	module_t *	module,
		ast_node_t *	parent,
		token_t *	token )

Parse a set statement adding it as a children on parent AST node.

Parameters

module	The module where the AST is.
parent	The AST node parent for the statement.
token	The token where to start parsing the statement.

Returns

The number of tokens used on the statement.

Definition at line 6 of file parse_statement_set.c.

{
  ast_node_t* node_statement = ast_add_children(parent, NT_STATEMENT, token);
  token_t* tkid = token + 1;
  token_t* tkequal = token + 2;
  token_t* tkexpr = token + 3;
 
  if (tkid->type != TK_IDENTIFIER) {
    module_add_error(
      module,
      tkid->line,
      tkid->column,
      tkid->lexeme.length,
      "Expected an identifier here. Example: set NAME = value;"
    );
 
    return 1;
  }
 
  if (tkequal->type != TK_EQUAL) {
    module_add_error(
      module,
      tkequal->line,
      tkequal->column,
      tkequal->lexeme.length,
      "Expected an equal operator here. Example: set NAME = value;"
    );
  }
 
  ast_add_children(node_statement, NT_IDENTIFIER, tkid);
 
  unsigned int ntokens = 3 + parse_expression(module, node_statement, tkexpr);
 
  token_t* tksemicolon = token + ntokens;
 
  if (tksemicolon->type != TK_SEMICOLON) {
    module_add_error(
      module,
      tksemicolon->line,
      tksemicolon->column,
      1,
      "Expected semicolon at end of the set command. Example: set NUMBER = 1;"
    );
  }
 
  return ntokens + 1;
}