#include <stddef.h>
#include "serene/rt/core.h"

Include dependency graph for lists.h:

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

Data Structures
struct	srn_list_node_t
	A list is a singly linked sequence of values. More...
struct	srn_list_t

Typedefs
typedef struct srn_list_node_t	srn_list_node_t
	A list is a singly linked sequence of values.
typedef struct srn_list_t	srn_list_t

Functions
srn_value_t *	srn_list_make (srn_context_t ctx, srn_metadata_t metadata, srn_value_t const items, size_t count)
	Build a list from an array of elements.
srn_value_t *	srn_list_cons (srn_context_t ctx, srn_metadata_t metadata, srn_value_t value, srn_value_t list)
	Prepend value to list, returning a new list.

Typedef Documentation

◆ srn_list_node_t

typedef struct srn_list_node_t srn_list_node_t

A list is a singly linked sequence of values.

Nodes hold a value and a pointer to the next node; the list header caches the length and points at the head node. Empty lists are represented by nil_v; a list value with tag VList always has at least one element.

◆ srn_list_t

typedef struct srn_list_t srn_list_t

Function Documentation

◆ srn_list_cons()

srn_value_t * srn_list_cons	(	srn_context_t *	ctx,
		srn_metadata_t *	metadata,
		srn_value_t *	value,
		srn_value_t *	list )

Prepend value to list, returning a new list.

list may be nil_v (treated as the empty list); the input list is not modified — its nodes are shared with the returned list.

Definition at line 51 of file lists.c.

                                                                                                   {
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(value);
  PANIC_IF_NULL(list);
 
  srn_list_node_t *next_head = nullptr;
  size_t next_len            = 0;
  if (!IS_NIL(list)) {
    if (!IS_A(list, VList)) {
      return srn_errors_make_error(ctx, metadata, ABSURD, "expected a list");
    }
    srn_list_t *l = AS_LIST(list);
    next_head     = l->head;
    next_len      = l->len;
  }
 
  srn_list_node_t *node = ALLOC(ctx, srn_list_node_t);
  node->value           = value;
  node->next            = next_head;
 
  srn_list_t *result = ALLOC(ctx, srn_list_t);
  result->len        = next_len + 1;
  result->head       = node;
  return srn_value_make(ctx, VList, metadata, (void *)result);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ srn_list_make()

srn_value_t * srn_list_make	(	srn_context_t *	ctx,
		srn_metadata_t *	metadata,
		srn_value_t const	items,
		size_t	count )

Build a list from an array of elements.

When count == 0, returns nil_v (empty lists have no allocated representation). Otherwise allocates one node per element plus the list header, all in ctx.

Definition at line 25 of file lists.c.

  {
  PANIC_IF_NULL(ctx);
  if (count == 0) {
    return &nil_v;
  }
  PANIC_IF_NULL(items);
 
  // Build the chain from the tail back to the head so each node's `next`
  // already points at an initialized successor.
  srn_list_node_t *head = nullptr;
  for (size_t i = count; i-- > 0;) {
    srn_list_node_t *node = ALLOC(ctx, srn_list_node_t);
    node->value           = items[i];
    node->next            = head;
    head                  = node;
  }
 
  srn_list_t *list = ALLOC(ctx, srn_list_t);
  list->len        = count;
  list->head       = head;
  return srn_value_make(ctx, VList, metadata, (void *)list);
}