parse_common.c File Reference

#include "ast.h"
#include "module.h"
#include "parser.h"
#include "types/keywords.h"

Include dependency graph for parse_common.c:

Go to the source code of this file.

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