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 ' '.
static void	print_quoted_string (FILE *out, const char *s)
static void	print_seq_body (FILE *out, srn_context_t *ctx, const seq_t *body, char open, char close)
void	srn_syntax_print (FILE *out, srn_context_t *ctx, const srn_syntax_t *s)
	Print a syntax node to out in its S-expression form.
void	srn_syntax_println (FILE *out, srn_context_t *ctx, const srn_syntax_t *s)
	Same as srn_syntax_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_quoted_string()

void print_quoted_string ( FILE * out, const char * s )

static

Definition at line 201 of file print.c.

                                                          {
  fputc('"', out);
  for (const char *p = s; *p != '\0'; p++) {
    switch (*p) {
    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)(unsigned char)*p, out);
      break;
    }
  }
  fputc('"', out);
}

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_seq_body()

void print_seq_body ( FILE * out, srn_context_t * ctx, const seq_t * body, char open, char close )

static

Definition at line 231 of file print.c.

                                                                                        {
  fputc(open, out);
  for (size_t i = 0; i < body->len; i++) {
    if (i > 0) {
      fputc(' ', out);
    }
    seq_lookup_result_t r = seq_get(body, i);
    if (r.maybe_error != nullptr) {
      fputs("#<seq-error>", out);
      continue;
    }
    srn_syntax_print(out, ctx, (const srn_syntax_t *)r.data);
  }
  fputc(close, 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_syntax_print()

void srn_syntax_print	(	FILE *	out,
		srn_context_t *	ctx,
		const srn_syntax_t *	s )

Print a syntax node to out in its S-expression form.

Numbers are emitted from their stored raw text (no formatting normalization). Maps print as {k v k v} because the syntax-level container is a flat seq.

Definition at line 247 of file print.c.

                                                                            {
  PANIC_IF_NULL(out);
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(s);
 
  switch (s->type) {
  case SNil:
    fputs("nil", out);
    break;
  case STrue:
    fputs("true", out);
    break;
  case SFalse:
    fputs("false", out);
    break;
 
  case SSymbol:
    fputs(s->as.symbol, out);
    break;
  case SNumber:
    fputs(s->as.number, out);
    break;
 
  case SString:
    print_quoted_string(out, s->as.string);
    break;
 
  case SKeyword:
    fputc(':', out);
    fputs(s->as.keyword, out);
    break;
 
  case SList:
    print_seq_body(out, ctx, s->as.list, '(', ')');
    break;
  case SSeq:
    print_seq_body(out, ctx, s->as.seq, '[', ']');
    break;
  case SMap:
    print_seq_body(out, ctx, s->as.map, '{', '}');
    break;
 
  case SQuote:
    fputc('\'', out);
    srn_syntax_print(out, ctx, s->as.quote);
    break;
 
  case SError: {
    srn_error_t *e = s->as.error;
    (void)fprintf(out, "#<error tag=%d", (int)e->tag);
    if (e->msg != nullptr) {
      (void)fprintf(out, " %s", e->msg);
    }
    fputc('>', out);
    break;
  }
 
  default:
    fputs("#<unknown>", out);
    break;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_syntax_println()

void srn_syntax_println	(	FILE *	out,
		srn_context_t *	ctx,
		const srn_syntax_t *	s )

Same as srn_syntax_print followed by '
'.

Definition at line 310 of file print.c.

                                                                              {
  srn_syntax_print(out, ctx, s);
  fputc('\n', out);
}

Here is the call 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: