print.c

Go to the documentation of this file.

/* -*- C -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <lxsameer@lxsameer.com>
 *
 * This library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 */
#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"
 
static void print_string_payload(FILE *out, const srn_string_t *s) {
  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);
}
 
static inline void write_bytes(FILE *out, const uint8_t *buf, size_t len) {
  if (len > 0) {
    (void)fwrite(buf, 1, len, out);
  }
}
 
static void print_list(FILE *out, srn_context_t *ctx, const srn_value_t *v) {
  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);
}
 
static void print_seq(FILE *out, srn_context_t *ctx, const srn_value_t *v) {
  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);
}
 
void srn_value_print(FILE *out, srn_context_t *ctx, const srn_value_t *v) {
  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;
  }
}
 
void srn_value_println(FILE *out, srn_context_t *ctx, const srn_value_t *v) {
  srn_value_print(out, ctx, v);
  fputc('\n', out);
}