dymokomi/luce-js
Source of release 0.6.0
0.6.0 / src / engine / modules.lucb
#==============================================================================================
#
# modules - Module records, their import and export tables, C modules and the loader
#
# DESCRIPTION:
# Port of quickjs.c lines 29662-30084: creating, marking and freeing a module
# (JSModuleDef), the requested-module, export and star-export tables, the C module
# API (JS_NewCModule, JS_AddModuleExport, JS_SetModuleExport and the private value),
# the host's module loader configuration, the default name normalizer and
# js_host_resolve_imported_module, which finds a loaded module or asks the host to
# load it.
#
#==============================================================================================
# mark: Module records ==========================================================================
# 'name' is freed. The module is referenced by 'ctx.loaded_modules'.
func js_new_module_def(ctx: Context*, name: Atom) -> ModuleDef*!:
let block = js_mallocz(ctx, memory.size_of(ModuleDef)) catch failure:
js_free_atom(ctx, name)
error(failure.code, failure.message)
let m = (ModuleDef*)block
js_rc(m).ref_count = 1
add_gc_object(ctx.rt, &m.header, GCObjectType.module)
m.module_name = name
m.module_ns = js_undefined()
m.func_obj = js_undefined()
m.eval_exception = js_undefined()
m.meta_obj = js_undefined()
m.promise = js_undefined()
m.resolving_funcs[0] = js_undefined()
m.resolving_funcs[1] = js_undefined()
m.private_value = js_undefined()
cutils.list_add_tail(&m.link, &ctx.loaded_modules)
return m
# The requested module entry `i` of `m` (&m->req_module_entries[i]).
func module_req_entry(m: ModuleDef*, i: i32) -> ReqModuleEntry*:
let tab = m.req_module_entries else trap("module without requested modules")
return tab + (usize)i
# The export entry `i` of `m` (&m->export_entries[i]).
func module_export_entry(m: ModuleDef*, i: i32) -> ExportEntry*:
let tab = m.export_entries else trap("module without exports")
return tab + (usize)i
# The star export entry `i` of `m` (&m->star_export_entries[i]).
func module_star_export_entry(m: ModuleDef*, i: i32) -> StarExportEntry*:
let tab = m.star_export_entries else trap("module without star exports")
return tab + (usize)i
# The import entry `i` of `m` (&m->import_entries[i]).
func module_import_entry(m: ModuleDef*, i: i32) -> ImportEntry*:
let tab = m.import_entries else trap("module without imports")
return tab + (usize)i
# The module a requested module entry was resolved to (rme->module after
# js_resolve_module).
func req_entry_module(rme: const ReqModuleEntry*) -> ModuleDef*:
return rme.module else trap("requested module not resolved")
func js_mark_module_def(rt: Runtime*, m: ModuleDef*, mark_func: MarkFunc):
for i in 0..<m.req_module_entries_count:
let rme = module_req_entry(m, i)
js_mark_value(rt, rme.attributes, mark_func)
for i in 0..<m.export_entries_count:
let me = module_export_entry(m, i)
if me.export_type == ExportType.local_:
if let var_ref = me.u.local_.var_ref:
mark_func(rt, &var_ref.header)
js_mark_value(rt, m.module_ns, mark_func)
js_mark_value(rt, m.func_obj, mark_func)
js_mark_value(rt, m.eval_exception, mark_func)
js_mark_value(rt, m.meta_obj, mark_func)
js_mark_value(rt, m.promise, mark_func)
js_mark_value(rt, m.resolving_funcs[0], mark_func)
js_mark_value(rt, m.resolving_funcs[1], mark_func)
js_mark_value(rt, m.private_value, mark_func)
func js_free_module_def(rt: Runtime*, m: ModuleDef*):
js_free_atom_rt(rt, m.module_name)
for i in 0..<m.req_module_entries_count:
let rme = module_req_entry(m, i)
js_free_atom_rt(rt, rme.module_name)
js_free_value_rt(rt, rme.attributes)
if let tab = m.req_module_entries:
js_free_rt(rt, tab)
for i in 0..<m.export_entries_count:
let me = module_export_entry(m, i)
if me.export_type == ExportType.local_:
free_var_ref(rt, me.u.local_.var_ref)
js_free_atom_rt(rt, me.export_name)
js_free_atom_rt(rt, me.local_name)
if let tab = m.export_entries:
js_free_rt(rt, tab)
if let tab = m.star_export_entries:
js_free_rt(rt, tab)
for i in 0..<m.import_entries_count:
let mi = module_import_entry(m, i)
js_free_atom_rt(rt, mi.import_name)
if let tab = m.import_entries:
js_free_rt(rt, tab)
if let tab = m.async_parent_modules:
js_free_rt(rt, tab)
js_free_value_rt(rt, m.module_ns)
js_free_value_rt(rt, m.func_obj)
js_free_value_rt(rt, m.eval_exception)
js_free_value_rt(rt, m.meta_obj)
js_free_value_rt(rt, m.promise)
js_free_value_rt(rt, m.resolving_funcs[0])
js_free_value_rt(rt, m.resolving_funcs[1])
js_free_value_rt(rt, m.private_value)
# during the GC the finalizers are called in an arbitrary order so the module may no
# longer be referenced by the Context list
if m.link.next != none:
cutils.list_del(&m.link)
remove_gc_object(&m.header)
if rt.gc_phase == GCPhase.remove_cycles and js_rc(m).ref_count != 0:
cutils.list_add_tail(&m.header.link, &rt.gc_zero_ref_count_list)
else:
js_free_rt(rt, m)
# mark: Imports and exports =====================================================================
# Add `module_name` to the modules `m` requests; answers its index.
func add_req_module_entry(ctx: Context*, m: ModuleDef*, module_name: Atom) -> i32!:
try js_resize_array(ctx, (void*?*)&m.req_module_entries, (i32)memory.size_of(ReqModuleEntry),
&m.req_module_entries_size, m.req_module_entries_count + 1)
let rme = module_req_entry(m, m.req_module_entries_count)
m.req_module_entries_count += 1
rme.module_name = js_dup_atom(ctx, module_name)
rme.module = none
rme.attributes = js_undefined()
return m.req_module_entries_count - 1
func find_export_entry(ctx: Context*, m: ModuleDef*, export_name: Atom) -> ExportEntry*?:
for i in 0..<m.export_entries_count:
let me = module_export_entry(m, i)
if me.export_name == export_name:
return me
return none
# Add an export to `m`. A duplicate name is a parse error when `s` is given (the parser),
# else a SyntaxError.
func add_export_entry2(ctx: Context*, s: ParseState*?, m: ModuleDef*, local_name: Atom,
export_name: Atom, export_type: ExportType) -> ExportEntry*!:
if find_export_entry(ctx, m, export_name) != none:
if let ps = s:
var buf1: u8[atom_get_str_buf_size] = ---
try js_parse_error(ps, f"duplicate exported name '{js_atom_get_str(ctx, buf1, export_name)}'")
else:
try js_throw_syntax_error_atom(ctx, "duplicate exported name '%s'", export_name)
try js_resize_array(ctx, (void*?*)&m.export_entries, (i32)memory.size_of(ExportEntry),
&m.export_entries_size, m.export_entries_count + 1)
let me = module_export_entry(m, m.export_entries_count)
m.export_entries_count += 1
_ = cutils.memset(me, 0, memory.size_of(ExportEntry))
me.local_name = js_dup_atom(ctx, local_name)
me.export_name = js_dup_atom(ctx, export_name)
me.export_type = export_type
return me
func add_star_export_entry(ctx: Context*, m: ModuleDef*, req_module_idx: i32) -> !:
try js_resize_array(ctx, (void*?*)&m.star_export_entries, (i32)memory.size_of(StarExportEntry),
&m.star_export_entries_size, m.star_export_entries_count + 1)
let se = module_star_export_entry(m, m.star_export_entries_count)
m.star_export_entries_count += 1
se.req_module_idx = req_module_idx
# mark: C modules ===============================================================================
## Create a C module named `name_str`; `func_` initializes its exports when the module is
## evaluated (JS_NewCModule).
pub func js_new_c_module(ctx: Context*, name_str: const u8*, func_: ModuleInitFunc) -> ModuleDef*!:
let name = try js_new_atom_len(ctx, name_str, cutils.strlen(name_str))
let m = try js_new_module_def(ctx, name)
m.init_func = func_
return m
## Declare the export `export_name` of the C module `m`, before it is linked
## (JS_AddModuleExport).
pub func js_add_module_export(ctx: Context*, m: ModuleDef*, export_name: const u8*) -> !:
let name = try js_new_atom_len(ctx, export_name, cutils.strlen(export_name))
defer js_free_atom(ctx, name)
_ = try add_export_entry2(ctx, none, m, no_atom, name, ExportType.local_)
## Set the value of the export `export_name` of the C module `m`, taking ownership of `val`
## (JS_SetModuleExport). Answers false, with no exception pending, if `m` has no such
## export (QuickJS answers -1 then, as it does for an exception).
pub func js_set_module_export(ctx: Context*, m: ModuleDef*, export_name: const u8*, val: Value) -> bool!:
let name = js_new_atom_len(ctx, export_name, cutils.strlen(export_name)) catch failure:
js_free_value(ctx, val)
error(failure.code, failure.message)
let found = find_export_entry(ctx, m, name)
js_free_atom(ctx, name)
if let me = found:
let var_ref = me.u.local_.var_ref else trap("JS_SetModuleExport: module not linked")
set_value(ctx, var_ref.pvalue, val)
return true
js_free_value(ctx, val)
return false
## Set the private value of the C module `m`, taking ownership of `val`
## (JS_SetModulePrivateValue). Always answers 0.
pub func js_set_module_private_value(ctx: Context*, m: ModuleDef*, val: Value) -> i32:
set_value(ctx, &m.private_value, val)
return 0
## A new reference to the private value of the C module `m` (JS_GetModulePrivateValue).
pub func js_get_module_private_value(ctx: Context*, m: ModuleDef*) -> Value:
return js_dup_value(ctx, m.private_value)
# mark: The module loader =======================================================================
## Set the host's module name normalizer (none: the default one) and module loader
## (JS_SetModuleLoaderFunc).
pub func js_set_module_loader_func(rt: Runtime*, module_normalize: ModuleNormalizeFunc?,
module_loader: ModuleLoaderFunc?, opaque: void*?):
rt.module_normalize_func = module_normalize
rt.module_loader_has_attr = false
# QuickJS keeps the two loaders in one union
rt.module_loader_func = module_loader
rt.module_loader_func2 = none
rt.module_check_attrs = none
rt.module_loader_opaque = opaque
## Set the host's module name normalizer, a module loader that receives the import
## attributes, and the attribute checker (JS_SetModuleLoaderFunc2).
pub func js_set_module_loader_func2(rt: Runtime*, module_normalize: ModuleNormalizeFunc?,
module_loader: ModuleLoaderFunc2?,
module_check_attrs: ModuleCheckSupportedImportAttributes?,
opaque: void*?):
rt.module_normalize_func = module_normalize
rt.module_loader_has_attr = true
# QuickJS keeps the two loaders in one union
rt.module_loader_func = none
rt.module_loader_func2 = module_loader
rt.module_check_attrs = module_check_attrs
rt.module_loader_opaque = opaque
# The last `c` in the NUL-terminated text at `s` (strrchr).
func find_last_byte(s: const u8*, c: u8) -> const u8*?:
var found: const u8*? = none
var p = s
while *p != 0:
if *p == c:
found = p
p += 1
return found
# The path part of js_default_module_normalize_name: write into `filename` (`cap` bytes,
# at least len(dirname(base_name)) + strlen(name) + 2) the name of `name` relative to
# the directory of `base_name`, `name` starting with a dot.
func module_normalize_path(filename: u8*, cap: i32, base_name: const u8*, name: const u8*):
var len: i32 = 0
if let p = find_last_byte(base_name, '/'):
len = (i32)(p - base_name)
_ = cutils.memcpy(filename, base_name, (usize)len)
filename[(usize)len] = 0
# we only normalize the leading '..' or '.'
var r = name
while true:
if r[0] == '.' and r[1] == '/':
r += 2
elif r[0] == '.' and r[1] == '.' and r[2] == '/':
# remove the last path element of filename, except if "." or ".."
if filename[0] == 0:
break
var p = filename
if let q = find_last_byte(filename, '/'):
p = (u8*)q + 1
if cutils.c_str_equals(p, ".") or cutils.c_str_equals(p, ".."):
break
if p > filename:
p -= 1
*p = 0
r += 3
else:
break
if filename[0] != 0:
_ = cutils.pstrcat(filename, cap, "/".bytes.data)
_ = cutils.pstrcat(filename, cap, r)
# default module filename normalizer
func js_default_module_normalize_name(ctx: Context*, base_name: const u8*, name: const u8*) -> u8*!:
if name[0] != '.':
# if no initial dot, the module name is not modified
return try js_strdup(ctx, name)
var len: i32 = 0
if let p = find_last_byte(base_name, '/'):
len = (i32)(p - base_name)
let cap = len + (i32)cutils.strlen(name) + 1 + 1
let filename = (u8*)(try js_malloc(ctx, (usize)cap))
module_normalize_path(filename, cap, base_name, name)
return filename
func js_find_loaded_module(ctx: Context*, name: Atom) -> ModuleDef*?:
# first look at the loaded modules
let head = &ctx.loaded_modules
var el = head.next else trap("js_find_loaded_module: unlinked module list")
while el != head:
let m = (ModuleDef*)((u8*)el - memory.offset_of(ModuleDef, link))
if m.module_name == name:
return m
el = el.next else trap("js_find_loaded_module: unlinked module list")
return none
# fails in case of exception (e.g. module could not be loaded)
func js_host_resolve_imported_module(ctx: Context*, base_cname: const u8*, cname1: const u8*,
attributes: Value) -> ModuleDef*!:
let rt = ctx.rt
var cname: u8* = ---
if let normalize = rt.module_normalize_func:
cname = try normalize(ctx, base_cname, cname1, rt.module_loader_opaque)
else:
cname = try js_default_module_normalize_name(ctx, base_cname, cname1)
defer js_free(ctx, cname)
let module_name = try js_new_atom_len(ctx, cname, cutils.strlen(cname))
# first look at the loaded modules
if let m = js_find_loaded_module(ctx, module_name):
js_free_atom(ctx, module_name)
return m
js_free_atom(ctx, module_name)
# load the module
if rt.module_loader_has_attr:
if let loader = rt.module_loader_func2:
return try loader(ctx, cname, rt.module_loader_opaque, attributes)
elif let loader = rt.module_loader_func:
return try loader(ctx, cname, rt.module_loader_opaque)
# XXX: use a syntax error ?
try js_throw_reference_error(ctx, f"could not load module '{cutils.c_str_view(cname)}'")
func js_host_resolve_imported_module_atom(ctx: Context*, base_module_name: Atom,
module_name1: Atom, attributes: Value) -> ModuleDef*!:
let base_cname = try js_atom_to_c_string(ctx, base_module_name)
defer js_free_c_string(ctx, base_cname)
let cname = try js_atom_to_c_string(ctx, module_name1)
defer js_free_c_string(ctx, cname)
return try js_host_resolve_imported_module(ctx, base_cname, cname, attributes)