print.c File Reference

#include "serene/rt/print.h"
#include <inttypes.h>
#include "serene/rt/context.h"
#include "serene/rt/core.h"
#include "serene/rt/errors.h"
#include "serene/rt/impl/seq.h"
#include "serene/rt/keywords.h"
#include "serene/rt/lists.h"
#include "serene/rt/maps.h"
#include "serene/rt/namespaces.h"
#include "serene/rt/seqs.h"
#include "serene/rt/strings.h"
#include "serene/rt/symbols.h"
#include "serene/utils.h"

Include dependency graph for print.c:

Go to the source code of this file.

Functions
static void	print_string_payload (FILE *out, const srn_string_t *s)
static void	write_bytes (FILE *out, const uint8_t *buf, size_t len)
static void	print_list (FILE *out, srn_context_t *ctx, const srn_value_t *v)
static void	print_seq (FILE *out, srn_context_t *ctx, const srn_value_t *v)
void	srn_value_print (FILE *out, srn_context_t *ctx, const srn_value_t *v)
	Print a value to out in its S-expression form.
void	srn_value_println (FILE *out, srn_context_t *ctx, const srn_value_t *v)
	Same as srn_value_print followed by ' '.

Function Documentation

print_list()

void print_list ( FILE * out, srn_context_t * ctx, const srn_value_t * v )

static

Definition at line 66 of file print.c.

                                                                            {
  fputc('(', out);
  srn_list_t *l = AS_LIST(v);
  bool first    = true;
  for (srn_list_node_t *n = l->head; n != nullptr; n = n->next) {
    if (!first) {
      fputc(' ', out);
    }
    first = false;
    srn_value_print(out, ctx, n->value);
  }
  fputc(')', out);
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_seq()

void print_seq ( FILE * out, srn_context_t * ctx, const srn_value_t * v )

static

Definition at line 80 of file print.c.

                                                                           {
  fputc('[', out);
  srn_seq_t *s = AS_SEQ(v);
  for (size_t i = 0; i < s->inner.len; i++) {
    if (i > 0) {
      fputc(' ', out);
    }
    seq_lookup_result_t r = seq_get(&s->inner, i);
    if (r.maybe_error != nullptr) {
      fputs("#<seq-error>", out);
      continue;
    }
    srn_value_print(out, ctx, (srn_value_t *)r.data);
  }
  fputc(']', out);
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_string_payload()

void print_string_payload ( FILE * out, const srn_string_t * s )

static

Definition at line 32 of file print.c.

                                                                   {
  fputc('"', out);
  for (size_t i = 0; i < s->len; i++) {
    uint8_t c = s->buffer[i];
    switch (c) {
    case '"':
      fputs("\\\"", out);
      break;
    case '\\':
      fputs("\\\\", out);
      break;
    case '\n':
      fputs("\\n", out);
      break;
    case '\t':
      fputs("\\t", out);
      break;
    case '\r':
      fputs("\\r", out);
      break;
    default:
      fputc((int)c, out);
      break;
    }
  }
  fputc('"', out);
}

Here is the caller graph for this function:

srn_value_print()

void srn_value_print	(	FILE *	out,
		srn_context_t *	ctx,
		const srn_value_t *	v )

Print a value to out in its S-expression form.

Atoms round-trip with the reader; compounds without a public iterator (VMap) print as opaque placeholders for now.

Definition at line 97 of file print.c.

                                                                          {
  PANIC_IF_NULL(out);
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(v);
 
  switch (v->type) {
  case VNil:
    fputs("nil", out);
    break;
  case VTrue:
    fputs("true", out);
    break;
  case VFalse:
    fputs("false", out);
    break;
 
  case VI64:
    (void)fprintf(out, "%" PRId64, AS_I64(v));
    break;
 
  case VF64:
    // %.17g is enough digits to round-trip a double exactly.
    (void)fprintf(out, "%.17g", AS_F64(v));
    break;
 
  case VString:
    print_string_payload(out, AS_STRING(v));
    break;
 
  case VSymbol: {
    srn_symbol_t *sym = AS_SYMBOL(v);
    // The qualified form, so the printed atom names one symbol, symbols
    // intern per namespace and the bare name alone is ambiguous across them.
    if (sym->ns != nullptr) {
      write_bytes(out, sym->ns->name->buffer, sym->ns->name->len);
      fputc('/', out);
    }
    write_bytes(out, sym->name->buffer, sym->name->len);
    break;
  }
 
  case VKeyword: {
    srn_keyword_t *k = AS_KEYWORD(v);
    fputc(':', out);
    write_bytes(out, k->name->buffer, k->name->len);
    break;
  }
 
  case VNamespace: {
    srn_namespace_t *ns = AS_NS(v);
    fputs("#<ns ", out);
    write_bytes(out, ns->name->buffer, ns->name->len);
    fputc('>', out);
    break;
  }
 
  case VList:
    print_list(out, ctx, v);
    break;
 
  case VSeq:
    print_seq(out, ctx, v);
    break;
 
  case VMap: {
    // CHAMT walker is not exposed; show size only for now.
    srn_map_t *m = AS_MAP(v);
    (void)fprintf(out, "#<map size=%zu>", m->inner.len);
    break;
  }
 
  case VClosure:
    fputs("#<closure>", out);
    break;
 
  case VError: {
    srn_error_t *e = AS_ERROR(v);
    (void)fprintf(out, "#<error tag=%d", (int)e->tag);
    if (e->msg != nullptr) {
      (void)fprintf(out, " %s", e->msg);
    }
    fputc('>', out);
    break;
  }
 
  case VQuote:
    fputs("#<quote>", out);
    break;
 
  default:
    fputs("#<unknown>", out);
    break;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_value_println()

void srn_value_println	(	FILE *	out,
		srn_context_t *	ctx,
		const srn_value_t *	v )

Same as srn_value_print followed by '
'.

Definition at line 192 of file print.c.

                                                                            {
  srn_value_print(out, ctx, v);
  fputc('\n', out);
}

Here is the call graph for this function:

write_bytes()

void write_bytes ( FILE * out, const uint8_t * buf, size_t len )

inlinestatic

Definition at line 60 of file print.c.

                                                                          {
  if (len > 0) {
    (void)fwrite(buf, 1, len, out);
  }
}

Here is the caller graph for this function: