print.h File Reference

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

Include dependency graph for print.h:

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

Go to the source code of this file.

Functions
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 ' '.
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

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: