namespaces.h File Reference

A namespace is an isolation for names nad technically a compilation unit. More...

#include <stdatomic.h>
#include "serene/rt/context.h"
#include "serene/rt/engine.h"
#include "serene/rt/impl/hashmap.h"
#include "serene/rt/source_manager.h"
#include "serene/utils.h"

Include dependency graph for namespaces.h:

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

Go to the source code of this file.

Data Structures
struct	srn_namespace_t

Typedefs
typedef struct srn_namespace_t	srn_namespace_t

Functions
srn_namespace_t *	srn_namespace_get_or_create (srn_engine_t *engine, srn_string_t *name, srn_error_t **err)
	Create a new and empty namespace if it is not already created in the engine, if it exists, return the namespace.
srn_namespace_t *	srn_namespace_load (srn_namespace_t *ns)
	Load the namespace's source from the filesystem into src_buffer, parse it, and populate the symbol table.

Detailed Description

A namespace is an isolation for names nad technically a compilation unit.

Typically each namespace will resolve to a single file on the filesystem. Namespaces maintain a sym table that maps global names that the namespace provides to their definition.

Definition in file namespaces.h.

Typedef Documentation

srn_namespace_t

typedef struct srn_namespace_t srn_namespace_t

Function Documentation

srn_namespace_get_or_create()

srn_namespace_t * srn_namespace_get_or_create	(	srn_engine_t *	engine,
		srn_string_t *	name,
		srn_error_t **	err )

Create a new and empty namespace if it is not already created in the engine, if it exists, return the namespace.

Note that in case of creation, this function will register the new namespace with the engine.

Definition at line 30 of file namespaces.c.

                                                                                         {
  PANIC_IF_NULL(engine);
  PANIC_IF_NULL(name);
  // TODO(lxsameer): Return these panics as errors. This is fine for now!
  UNUSED(err);
  PANIC_IF(srn_string_is_empty(name), "Empty namespace name is not allowed");
  PANIC_IF(
    srn_string_length(name) > engine->config.limits.ns_name_max_len,
    "Namespace name exceeds the length limit"
  );
  srn_context_t *parent_ctx = engine->root_context;
 
  // The key is the raw bytes of the namespace name (no struct header,
  // no null terminator). The map copies the key into its pinned context, so
  // a stack struct is enough here. Find by C string must use the same byte
  // range as the key.
  hmap_key_t k = {.data = (void *)name->buffer, .len = srn_string_length(name)};
 
  // Readers never take `ns_lock`. Every published head is immutable, so an
  // acquire load is enough to see a fully built map.
  auto namespaces = atomic_load_explicit(&engine->namespaces, memory_order_acquire);
  auto ns_ptr     = srn_context_find_namespace(parent_ctx, (const char *)name->buffer);
 
  if (ns_ptr != nullptr) {
    // A namespace with the same name is already registered.
    return (srn_namespace_t *)ns_ptr;
  }
 
  srn_namespace_t *ns = nullptr;
 
  // Writers are serialized by `ns_lock`. Creating and publishing the
  // namespace both happen while it is held.
  WITH_LOCK(engine->ns_lock, {
    // Another fiber may have registered the same name between the unlocked
    // lookup and taking the lock, so the lookup is repeated here.
    namespaces = atomic_load_explicit(&engine->namespaces, memory_order_relaxed);
    ns         = hmap_lookup(namespaces, &k, nullptr);
 
    if (ns == nullptr) {
      ns               = ALLOC_OR_PANIC(parent_ctx, srn_namespace_t);
      ns->name         = srn_string_copy(parent_ctx, name);
      ns->id           = srn_allocate_object_id(engine);
      ns->root_context = srn_context_make(engine);
 
      // The symbol table outlives the creating context, so it is pinned to the
      // namespace's own root context; the table's keys and trie nodes land in
      // that chain rather than in the creating caller's block. The namespace
      // is not visible to anyone yet, so the atomic is initialized rather
      // than stored.
      hmap_t *sym_table = ALLOC_OR_PANIC(ns->root_context, hmap_t);
      *sym_table        = hmap_empty(ns->root_context);
      atomic_init(&ns->sym_table, sym_table);
      // No node to begin with
      ns->node = nullptr;
 
      ns->sym_table_lock = ALLOC_OR_PANIC(ns->root_context, srn_fiber_mutex_t);
      srn_fiber_mutex_init(ns->sym_table_lock);
 
      // Every head is immutable once published, so the new version gets its
      // own allocation and the old one stays valid for readers that already
      // loaded it.
      hmap_t *next = ALLOC_OR_PANIC(parent_ctx, hmap_t);
      *next        = hmap_insert(namespaces, &k, ns);
 
      atomic_store_explicit(&engine->namespaces, next, memory_order_release);
    }
  });
 
  return ns;
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_namespace_load()

srn_namespace_t * srn_namespace_load

(

srn_namespace_t *

ns

)

Load the namespace's source from the filesystem into src_buffer, parse it, and populate the symbol table.

Not implemented, the current body returns null unconditionally, so callers cannot rely on it yet.

Definition at line 101 of file namespaces.c.

                                                         {
  PANIC_IF_NULL(ns);
  return nullptr;
}