symbols.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.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include "serene/rt/symbols.h"
 
#include "serene/rt/context.h"
#include "serene/rt/engine.h"
#include "serene/rt/errors.h"
#include "serene/rt/impl/hashmap.h"
#include "serene/rt/namespaces.h"
#include "serene/rt/strings.h"
#include "serene/utils.h"
 
srn_value_t *srn_symbol_make(
  srn_context_t *ctx, srn_metadata_t *metadata, srn_namespace_t *ns, srn_string_t *name
) {
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(ns);
  PANIC_IF_NULL(name);
 
  srn_symbol_t *sym = ALLOC(ctx, srn_symbol_t);
  sym->name         = srn_string_copy(ctx, name);
 
  sym->ns = ns;
 
  return srn_value_make(ctx, VSymbol, metadata, (void *)sym);
}
 
srn_value_t *srn_symbol_intern(
  srn_context_t *ctx, srn_metadata_t *metadata, srn_namespace_t *ns, srn_string_t *symbol_name
) {
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(ns);
  PANIC_IF_NULL(symbol_name);
 
  if (srn_string_is_empty(symbol_name)) {
    return srn_errors_make_error(ctx, metadata, EMPTY_SYMBOL_NAME, nullptr);
  };
 
  hmap_key_t k = {.data = &symbol_name->buffer, .len = symbol_name->size};
 
  // The lock covers the lookup as well as the insert. Two interners racing
  // on the same new name would otherwise both miss and insert two distinct
  // symbols for one name, and symbol equality is pointer identity. Holding
  // the lock for the read also pairs it with the non-atomic replacement of
  // the sym_table struct below.
  srn_spinlock_lock(&ns->sym_table_lock);
 
  void *result = hmap_lookup(&ns->sym_table, &k, nullptr);
  if (result != nullptr) {
    srn_spinlock_unlock(&ns->sym_table_lock);
    return (srn_value_t *)result;
  }
 
  // The table retains the symbol for the namespace's lifetime, so the value
  // and its name copy are allocated through the namespace's root context,
  // not the interning caller's transient one.
  srn_value_t *sym = srn_symbol_make(ns->root_context, metadata, ns, symbol_name);
 
  ns->sym_table = hmap_insert(&ns->sym_table, &k, (void *)sym);
  srn_spinlock_unlock(&ns->sym_table_lock);
  return sym;
}
 
srn_value_t *srn_symbol_gen(
  srn_context_t *ctx, srn_metadata_t *metadata, srn_namespace_t *ns, srn_string_t *optional_name
) {
  // TODO(lxsameer): Fold the optional name into the generated spelling.
  UNUSED(optional_name);
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(ns);
 
  // A generated symbol must be fresh, a symbol nothing else already names.
  // The spelling is readable text, so a user symbol can occupy it. When the
  // name is taken, a new id gives a new name to try. The lock covers the
  // lookup and the insert, the pairing srn_symbol_intern relies on too.
  for (;;) {
    srn_object_id_t id = srn_allocate_object_id(ctx->engine);
 
    // Calculate the length
    int len = snprintf(nullptr, 0, "gensym_%" PRIu64, id);
    PANIC_IF(len < 0, "This should never happen!");
 
    // Including the null terminator
    char *name = srn_allocate(ctx, len + 1, alignof(char));
    (void)snprintf(name, len + 1, "gensym_%" PRIu64, id);
 
    srn_value_t *sym_name = srn_string_make(ctx, metadata, name);
    hmap_key_t k = {.data = &AS_STRING(sym_name)->buffer, .len = AS_STRING(sym_name)->size};
 
    srn_spinlock_lock(&ns->sym_table_lock);
    if (hmap_lookup(&ns->sym_table, &k, nullptr) != nullptr) {
      srn_spinlock_unlock(&ns->sym_table_lock);
      continue;
    }
 
    // The table retains the symbol for the namespace's lifetime, so the
    // value and its name copy are allocated through the namespace's root
    // context, not the generating caller's transient one.
    srn_value_t *sym = srn_symbol_make(ns->root_context, metadata, ns, AS_STRING(sym_name));
 
    ns->sym_table = hmap_insert(&ns->sym_table, &k, (void *)sym);
    srn_spinlock_unlock(&ns->sym_table_lock);
    return sym;
  }
}