print.c

Go to the documentation of this file.

/* -*- C -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <[email protected]>
 *
 * 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 "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 <inttypes.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(ctx, &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);
    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);
}
 
// ---------------------------------------------------------------------------
// Syntax-side printer
// ---------------------------------------------------------------------------
 
static void print_quoted_string(FILE *out, const char *s) {
  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);
}
 
// Walk `body` and print each element with the given open/close brackets.
// Elements are separated by a single space.
static void print_seq_body(FILE *out, srn_context_t *ctx, const seq_t *body, char open,
                           char close) {
  fputc(open, out);
  for (size_t i = 0; i < body->len; i++) {
    if (i > 0) {
      fputc(' ', out);
    }
    seq_lookup_result_t r = seq_get(ctx, 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);
}
 
void srn_syntax_print(FILE *out, srn_context_t *ctx, const srn_syntax_t *s) {
  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;
  }
}
 
void srn_syntax_println(FILE *out, srn_context_t *ctx, const srn_syntax_t *s) {
  srn_syntax_print(out, ctx, s);
  fputc('\n', out);
}