# Namespace --- ## Object Definitions ```c typedef struct _kpl_export { KPL_ALLOC_TREE_HEADER(struct _kpl_export); kpl_type_ptr type; } kpl_export; typedef struct _kpl_namespace_native { KPL_SLAB_TREE_HEADER(struct _kpl_namespace_native); const char *name; kpl_export *export_tree; } kpl_namespace_native; static kpl_namespace_native namespace_native_tree; typedef enum : uint8_t { // ... } namespace_lifecycle; typedef struct _kpl_namespace_module { KPL_SLAB_TREE_HEADER(struct _kpl_namespace_module); kpl_type_ptr ast; kpl_name *name_tree; kpl_buffer *module_name, *module_string; kpl_export *export_tree; kpl_mutex mutex; } kpl_namespace_module; static kpl_namespace_module *namespace_module_tree; kpl_mutex namespace_module_mutex; typedef struct _kpl_namespace_string { kpl_type_ptr ast; kpl_name *name_tree; kpl_buffer *string; kpl_mutex mutex; } kpl_namespace_string; static kpl_namespace_string namespace_string ``` Each `NAMESPACE_IDENTIFIER` maps to `kpl_namespace_native*` or `kpl_namespace_module*` depending on flags ## Lookup and Storage The native and namespace objects are stored as a tree The exports are stored under a tree for both the native and namespace objects # Registering ## Native TODO C code for exposing native code ## Module/String/REPL ### Main Begin life cycle and [Register](../lifecycle/register.md) ### Scan ``import` Add a [Register](../lifecycle/regiser.md) task to `namespace_module_mutex` # Updating ## Native ### Native code should not be updated at runtime, doing so is undefined behavior ## Module ### ``export` Add exports directly to the namespaces `export_tree`, thread safe ## String/REPL ### Cannot export for String/REPL # Using ## Native ### ``use` Since the native modules are loaded statically the `native_module_tree` becomes read only at runtime, access is thread safe ## Module/String/REPL ### Import ``import` 1. Add find namespace task to the `namespace_module_mutex`, the namespace not existing is an error 2. Add task to the namespaces `mutex` 3. The task will resume the importer