Luce packages
LuceLuce BaseLuciaOS

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)