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_expression (module_t *module, ast_node_t *parent, token_t *token)
	Parse a mathematical expression adding it as a children on parent AST node.

Function Documentation

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;
 
  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 += parse_expression(module, child, 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_SEMICOLON:
      ntokens++;
    case TK_CLOSE_PARENS:
    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.");
    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."
    );
 
    return ntokens + 1;
  }
 
  ast_insert_children(parent, &node);
 
  return ntokens + 1;
}

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.\n"
    );
 
    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);
  default:
    return 1;
  }
}

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 2 + (tksemicolon->type == TK_SEMICOLON);
  }
 
  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 3;
}

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);
  parse_expression(module, node_statement, tkexpr);
 
  return 3;
}