parse_expression.c File Reference

#include <stdbool.h>
#include "ast.h"
#include "aststack.h"
#include "module.h"
#include "parser.h"
#include "tkqueue.h"
#include "tkstack.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 24 of file parse_expression.c.

{
  tkstack_t stack;
  tkqueue_t queue;
  token_t* current_token;
  bool is_unary = false;
  unsigned int ntokens = 0;
 
  if (token->type == TK_IDENTIFIER && token[1].type == TK_OPEN_BRACES) {
    return parse_bitfield_spec(module, parent, token);
  }
 
  tkstack_init(&stack);
  tkqueue_init(&queue, 30);
 
  for (;;) {
    current_token = &token[ntokens++];
 
    switch (current_token->type) {
    case TK_OPEN_PARENS:
      tkstack_push(&stack, current_token);
      is_unary = true;
      break;
    case TK_IDENTIFIER:
    case TK_NUMBER:
      tkqueue_add(&queue, current_token);
      is_unary = false;
      break;
    case TK_EQUAL:
      ntokens = _parse_bitfield_expression(module, parent, &queue, current_token);
      goto clean_and_exit;
    case TK_OPERATOR:
      if (is_unary && current_token->value == OP_MINUS) {
        current_token->value = OP_NEGATE;
      }
 
      while (! tkstack_isempty(&stack) && tkstack_peek(&stack)->type != TK_OPEN_PARENS &&
             _op_precedence(tkstack_peek(&stack)) >= _op_precedence(current_token)) {
        tkqueue_add(&queue, tkstack_pop(&stack));
      }
 
      tkstack_push(&stack, current_token);
      is_unary = true;
      break;
    case TK_CLOSE_PARENS:
      for (;;) {
        token_t* popped = tkstack_pop(&stack);
        if (! popped) {
          module_add_error(
            module,
            current_token->line,
            current_token->column,
            current_token->lexeme.length,
            "Close parentheses here is not matching a open parentheses."
          );
 
          goto clean_and_exit;
        }
 
        if (popped->type == TK_OPEN_PARENS) {
          break;
        }
 
        tkqueue_add(&queue, popped);
      }
 
      is_unary = false;
      break;
    case TK_SEMICOLON:
    case TK_CLOSE_BRACES:
    case TK_CLOSE_BRACKET:
    case TK_COMMA:
    case TK_EOF:
      ntokens--;
      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:
  while (! tkstack_isempty(&stack)) {
    tkqueue_add(&queue, tkstack_pop(&stack));
  }
 
  _generate_ast(module, parent, &queue);
 
clean_and_exit:
  tkstack_close(&stack);
  tkqueue_close(&queue);
 
  return ntokens;
}