reader.h File Reference

A simple sexp reader to be used with textual IR. More...

#include <stdint.h>
#include "serene/rt/impl/array_list.h"
#include "serene/rt/source_manager.h"
#include "serene/rt/errors.h"

Include dependency graph for reader.h:

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

Go to the source code of this file.

Data Structures
struct	srn_sexp_atom_t
struct	srn_sexp_str_t
struct	srn_sexp_num_t
	A number literal, kept as the raw text it was written with (e.g. More...
struct	srn_sexp_cons_t
struct	srn_sexp_list_t
struct	srn_sexp_node_t
struct	srn_sexp_parser_t
struct	srn_sexp_tree_t
struct	reader_fiber_arg_t

Typedefs
typedef struct srn_sexp_node_t	srn_sexp_node_t
typedef struct srn_src_location_t	srn_src_location_t
typedef struct srn_sexp_parser_t	srn_sexp_parser_t
typedef struct array_list_t	array_list_t
typedef enum srn_sexp_node_type_e	srn_sexp_node_type_e
typedef struct srn_sexp_atom_t	srn_sexp_atom_t
typedef struct srn_sexp_str_t	srn_sexp_str_t
typedef struct srn_sexp_num_t	srn_sexp_num_t
	A number literal, kept as the raw text it was written with (e.g.
typedef struct srn_sexp_cons_t	srn_sexp_cons_t
typedef struct srn_sexp_list_t	srn_sexp_list_t
typedef struct srn_sexp_tree_t	srn_sexp_tree_t
typedef struct reader_fiber_arg_t	reader_fiber_arg_t

Enumerations
enum	srn_sexp_node_type_e : uint8_t {   SRN_SEXP_ATOM , SRN_SEXP_CONS , SRN_SEXP_LIST , SRN_SEXP_NUM ,   SRN_SEXP_SEQ , SRN_SEXP_STR }

Functions
srn_sexp_node_t *	srn_sexp_make_atom (srn_context_t *ctx, const char *name)
srn_sexp_node_t *	srn_sexp_make_str (srn_context_t *ctx, const char *data)
srn_sexp_node_t *	srn_sexp_make_num (srn_context_t *ctx, const char *text)
srn_sexp_node_t *	srn_sexp_make_cons (srn_context_t *ctx, srn_sexp_node_t *head, srn_sexp_node_t *tail)
srn_sexp_node_t *	srn_sexp_make_list (srn_context_t *ctx)
srn_sexp_node_t *	srn_sexp_make_node (srn_context_t *ctx, srn_sexp_node_type_e type)
srn_sexp_tree_t *	srn_sexp_read_from_string (srn_context_t *ctx, void *reading_context, const char *buf)
	Read the symbolic expressions from a buffer.
srn_sexp_tree_t *	srn_sexp_read_from_file (srn_context_t *ctx, void *reading_context, const char *path)
	Read the symbolic expressions from a file.
srn_sexp_node_t *	read_expr (srn_sexp_parser_t *parser, srn_error_t **err)
srn_fiber_result_t	read_from_buffer (srn_context_t *ctx, void *arg)
const char *	srn_sexp_to_debug_string (srn_context_t *ctx, srn_sexp_tree_t *tree)
	Convert the given sexp to a string for debugging purposes.

Detailed Description

A simple sexp reader to be used with textual IR.

The IR types we use for the runtime have a lispy representation, and this reader will parse symbolic expressions in a basic form and different layers of IR can use this reader and transform the symbolic expressions to a format that they like.

I wrote this parser mostly to act as an inefficient way to parse different layers of IR without needing to have multiple parsers. Long in the future when we have everything in place, I should write efficient parsers for only the crucial layers of IR and avoid this generic one.

Definition in file reader.h.

Typedef Documentation

array_list_t

typedef struct array_list_t array_list_t

Definition at line 49 of file reader.h.

reader_fiber_arg_t

typedef struct reader_fiber_arg_t reader_fiber_arg_t

srn_sexp_atom_t

typedef struct srn_sexp_atom_t srn_sexp_atom_t

srn_sexp_cons_t

typedef struct srn_sexp_cons_t srn_sexp_cons_t

srn_sexp_list_t

typedef struct srn_sexp_list_t srn_sexp_list_t

srn_sexp_node_t

typedef struct srn_sexp_node_t srn_sexp_node_t

Definition at line 46 of file reader.h.

srn_sexp_node_type_e

typedef enum srn_sexp_node_type_e srn_sexp_node_type_e

srn_sexp_num_t

typedef struct srn_sexp_num_t srn_sexp_num_t

A number literal, kept as the raw text it was written with (e.g.

"42", "-3.14", "+1e10"). The reader only recognises the shape of a number, it does not parse it into an int/float value or fix its precision, that is a later phase's job.

srn_sexp_parser_t

typedef struct srn_sexp_parser_t srn_sexp_parser_t

Definition at line 48 of file reader.h.

srn_sexp_str_t

typedef struct srn_sexp_str_t srn_sexp_str_t

srn_sexp_tree_t

typedef struct srn_sexp_tree_t srn_sexp_tree_t

srn_src_location_t

typedef struct srn_src_location_t srn_src_location_t

Definition at line 47 of file reader.h.

Enumeration Type Documentation

srn_sexp_node_type_e

enum srn_sexp_node_type_e : uint8_t

Enumerator
SRN_SEXP_ATOM
SRN_SEXP_CONS
SRN_SEXP_LIST
SRN_SEXP_NUM
SRN_SEXP_SEQ
SRN_SEXP_STR

Definition at line 51 of file reader.h.

                                  : uint8_t {
  SRN_SEXP_ATOM,
  SRN_SEXP_CONS,
  SRN_SEXP_LIST,
  SRN_SEXP_NUM,
  SRN_SEXP_SEQ, // An array list of expressions
  SRN_SEXP_STR,
} srn_sexp_node_type_e;

Function Documentation

read_expr()

srn_sexp_node_t * read_expr	(	srn_sexp_parser_t *	parser,
		srn_error_t **	err )

Definition at line 552 of file reader.c.

                                                                         {
  skip_whitespace(parser);
 
  utf8_int32_t c = peek(parser);
 
  if (c == '(') {
    return read_list(parser, err);
  }
 
  // Checked before is_atom_start: a sign like '-' is itself a valid atom-start
  // character (see is_atom_char), so "-5" would otherwise be read as the atom "-5"
  // never reaching read_number at all.
  if (is_number_start(c, peek_next(parser))) {
    return read_number(parser, err);
  }
 
  if (is_atom_start(c)) {
    return read_atom(parser, err);
  }
 
  if (c == '"') {
    return read_string(parser, err);
  }
 
  if (c == '[') {
    return read_seq(parser, err);
  }
 
  *err = parse_error(parser, c, nullptr);
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_from_buffer()

srn_fiber_result_t read_from_buffer	(	srn_context_t *	ctx,
		void *	arg )

Definition at line 584 of file reader.c.

                                                                   {
  UNUSED(ctx);
  reader_fiber_arg_t *fiber_arg = arg;
 
  srn_sexp_parser_t *parser = fiber_arg->parser;
 
  auto sexps       = array_list_empty(parser->ctx);
  srn_error_t *err = nullptr;
 
  // Every decode below trusts the lead byte of a sequence and reads the
  // continuation bytes without looking for the terminator, so the whole buffer
  // is checked once here. A sequence cut short by the end of the buffer, a
  // continuation byte with no lead byte, and an overlong encoding are all
  // rejected, which also guarantees that re-encoding a codepoint never needs
  // more bytes than it was read from.
  const utf8_int8_t *bad = utf8nvalid((const utf8_int8_t *)parser->buffer, parser->len);
  if (bad != nullptr) {
    parser->pos = (uint32_t)(bad - (const utf8_int8_t *)parser->buffer);
    return parse_error(parser, '\0', "Malformed UTF-8 sequence");
  }
 
  // Whitespace and comments after the last expression are not an expression,
  // so they are consumed here rather than handed to `read_expr`.
  for (;;) {
    skip_whitespace(parser);
    if (is_at_end(parser)) {
      break;
    }
 
    auto expr = read_expr(parser, &err);
 
    if (err != nullptr) {
      return err;
    }
 
    err = array_list_push(&sexps, expr);
    if (err != nullptr) {
      return err;
    }
    srn_fiber_yield();
  }
 
  srn_sexp_tree_t *tree = ALLOC_OR_PANIC(parser->ctx, srn_sexp_tree_t);
  tree->maybe_error     = nullptr;
  tree->reading_context = parser->reading_context;
  tree->exprs           = sexps;
  fiber_arg->tree       = tree;
 
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_sexp_make_atom()

srn_sexp_node_t * srn_sexp_make_atom	(	srn_context_t *	ctx,
		const char *	name )

Definition at line 176 of file reader.c.

                                                                          {
  // NOTE: We assume name is allocated in an block, we just take it
  PANIC_IF_NULL(name);
  srn_sexp_atom_t *atom = ALLOC_OR_PANIC(ctx, srn_sexp_atom_t);
  srn_sexp_node_t *n    = srn_sexp_make_node(ctx, SRN_SEXP_ATOM);
 
  atom->name = (char *)name;
  n->as.atom = atom;
  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_sexp_make_cons()

srn_sexp_node_t * srn_sexp_make_cons	(	srn_context_t *	ctx,
		srn_sexp_node_t *	head,
		srn_sexp_node_t *	tail )

Definition at line 211 of file reader.c.

                                                                                     {
  PANIC_IF_NULL(head);
 
  srn_sexp_cons_t *c = ALLOC_OR_PANIC(ctx, srn_sexp_cons_t);
  srn_sexp_node_t *n = srn_sexp_make_node(ctx, SRN_SEXP_CONS);
 
  c->head    = head;
  c->tail    = tail;
  n->as.cons = c;
 
  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_sexp_make_list()

srn_sexp_node_t * srn_sexp_make_list

(

srn_context_t *

ctx

)

Definition at line 224 of file reader.c.

                                                        {
  srn_sexp_list_t *l = ALLOC_OR_PANIC(ctx, srn_sexp_list_t);
  srn_sexp_node_t *n = srn_sexp_make_node(ctx, SRN_SEXP_LIST);
 
  l->head    = nullptr;
  l->len     = 0;
  n->as.list = l;
 
  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_sexp_make_node()

srn_sexp_node_t * srn_sexp_make_node	(	srn_context_t *	ctx,
		srn_sexp_node_type_e	type )

Definition at line 234 of file reader.c.

                                                                                   {
  auto n      = ALLOC_OR_PANIC(ctx, srn_sexp_node_t);
  n->type     = type;
  n->metadata = nullptr;
  return n;
}

Here is the caller graph for this function:

srn_sexp_make_num()

srn_sexp_node_t * srn_sexp_make_num	(	srn_context_t *	ctx,
		const char *	text )

Definition at line 198 of file reader.c.

                                                                         {
  // NOTE: We assume text is allocated in a block, we just take it
  PANIC_IF_NULL(text);
  srn_sexp_num_t *num = ALLOC_OR_PANIC(ctx, srn_sexp_num_t);
  srn_sexp_node_t *n  = srn_sexp_make_node(ctx, SRN_SEXP_NUM);
 
  num->text = (char *)text;
  n->as.num = num;
 
  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_sexp_make_str()

srn_sexp_node_t * srn_sexp_make_str	(	srn_context_t *	ctx,
		const char *	data )

Definition at line 187 of file reader.c.

                                                                         {
  // NOTE: We assume data is allocated in an block, we just take it
  srn_sexp_str_t *s  = ALLOC_OR_PANIC(ctx, srn_sexp_str_t);
  srn_sexp_node_t *n = srn_sexp_make_node(ctx, SRN_SEXP_STR);
 
  s->data      = (char *)data;
  n->as.string = s;
 
  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_sexp_read_from_file()

srn_sexp_tree_t * srn_sexp_read_from_file	(	srn_context_t *	ctx,
		void *	reading_context,
		const char *	path )

Read the symbolic expressions from a file.

reading_context is a piece of data that the reader might provide as an identity or a piece of data that gives meaning to the result. For example a namespace key.

Definition at line 643 of file reader.c.

                                                                                     {
  srn_sexp_tree_t *result = ALLOC_OR_PANIC(ctx, srn_sexp_tree_t);
 
  srn_sm_t *sm               = ctx->engine->source_manager;
  srn_sm_maybe_id_t maybe_id = srn_sm_read_buffer_file(sm, path, false);
 
  if (HAS_ERROR(maybe_id)) {
    PUSH_AND_MOVE(sm->ctx, maybe_id, *result);
    return result;
  }
 
  srn_sm_buffer_t *buf = srn_sm_get_buffer(sm, maybe_id.id);
  PANIC_IF_NULL(buf);
 
  if (buf->data == nullptr || buf->len == 0) {
    result->maybe_error     = nullptr;
    result->exprs           = array_list_empty(ctx);
    result->reading_context = reading_context;
    return result;
  }
 
  srn_sexp_parser_t parser = {
    .ctx             = ctx,
    .reading_context = reading_context,
    .buffer_id       = maybe_id.id,
    .buffer          = srn_sm_buffer_data(buf),
    .len             = srn_sm_buffer_len(buf),
    .pos             = 0,
  };
 
  reader_fiber_arg_t fiber_arg = {
    .parser = &parser,
    // This will be the output
    .tree = nullptr,
  };
 
  srn_fiber_t *fiber              = srn_fiber_spawn(ctx, read_from_buffer, &fiber_arg);
  srn_fiber_result_t fiber_result = srn_fiber_wait_for(fiber);
 
  if (fiber_result != nullptr) {
    result->maybe_error = (srn_error_t *)fiber_result;
    PUSH_TRACE(sm->ctx, *result);
    return result;
  }
 
  result = fiber_arg.tree;
  return result;
}

Here is the call graph for this function:

srn_sexp_read_from_string()

srn_sexp_tree_t * srn_sexp_read_from_string	(	srn_context_t *	ctx,
		void *	reading_context,
		const char *	buf )

Read the symbolic expressions from a buffer.

reading_context is a piece of data that the reader might provide as an identity or a piece of data that gives meaning to the result. For example a namespace key.

Definition at line 636 of file reader.c.

                                                                                      {
  // TODO(lxsameer): Extend the source manager to support sparse buffers and add the given
  // buffer here as a sparse buffer for the given namespace i guess
  return nullptr;
}

srn_sexp_to_debug_string()

const char * srn_sexp_to_debug_string	(	srn_context_t *	ctx,
		srn_sexp_tree_t *	tree )

Convert the given sexp to a string for debugging purposes.

The string will contain metadata info as well.

Definition at line 860 of file reader.c.

                                                                                {
  // Since this function is for debugging purposes we set a hard limit on the buffer
  char *buf = srn_mm_malloc(ctx->engine->mm, sizeof(char) * DEBUG_BUF_MAX_SIZE);
  PANIC_IF_NULL(buf);
  buf[0] = '\0';
 
  auto err = array_list_reduce(&tree->exprs, sexp_tree_reducer, buf);
  PANIC_IF(err != nullptr, srn_error_to_string(ctx, err));
 
  return buf;
}

Here is the call graph for this function:

Here is the caller graph for this function: