namespaces.h

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/>.
 */
#pragma once
 
#include "serene/rt/context.h"
#include "serene/rt/engine.h"
#include "serene/rt/impl/hashmap.h"
#include "serene/utils.h"
 
typedef struct srn_string_t srn_string_t;
 
/// There's no reason behind this number, just me guessing
 
#define MAX_NS_NAME_LEN 4096
 
typedef struct srn_namespace_src_buffer_t {
  /// Path on disk this buffer is associated with. When not null,
  /// srn_src_reload re-reads from here. A null value means the buffer
  /// has no associated file, for example a fresh REPL session that has
  /// not loaded one. A buffer can acquire a path later by being assigned
  /// one, or lose its connection by being passed to a future detach
  /// helper. Owned by the buffer and freed on shutdown.
  char *path;
 
  /// Byte storage. `bytes[0..len]` is the live content. `bytes[len..cap]`
  /// is unused capacity. Allocated through the engine's memory manager
  /// and freed on shutdown.
  uint8_t *bytes;
  size_t len;
  size_t cap;
} srn_namespace_src_buffer_t;
 
typedef struct srn_namespace_t {
  srn_string_t *name;
  srn_object_id_t id;
 
  srn_context_t *root_context;
 
  /// A mapping symbol names to (srn_value_t with type symbol).
  /// Since `hmap_t` hashes out the name, it's really a mapping from unsigned
  /// 32bit integer to symbols
  hmap_t sym_table;
  srn_spinlock_t sym_table_lock;
 
  /// The buffer holding the source code for this namespace. Can be a nullptr
  /// For new and empty namespaces. DO NOT hold any reference to this buffer
  /// since it will be purged in case of a namespace reload.
  srn_namespace_src_buffer_t *src_buffer;
  /// Guards every access to source buffer. Acquire before any operation.
  /// Even read.
  srn_spinlock_t src_buffer_lock;
} srn_namespace_t;
 
/// Creates a new namespace in the give context. The given context will NOT
/// be the namespace's root context
[[gnu::nonnull(1)]]
srn_value_t *srn_namespace_make(srn_context_t *ctx, srn_metadata_t *metadata,
                                srn_string_t *name);
 
/// Load the namespace from the filesystem by looking up the file
/// in the filesystem, load the file into the src_buffer, parse
/// the code, and populate the symtable.
[[gnu::nonnull(1)]]
srn_namespace_t *srn_namespace_load(srn_namespace_t *ns);