parse_expression.c File Reference

#include "ast.h"
#include "module.h"
#include "parser.h"
#include "stack.h"
#include "types/operators.h"

Include dependency graph for parse_expression.c:

Go to the source code of this file.

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