Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-js

Source of release 0.6.1

0.6.1 / tests / ljsc / compile.lucb

#==============================================================================================
#
#   compile - Compiling scripts and modules and writing their bytecode as Luce byte arrays
#
#   DESCRIPTION:
#       Port of qjsc.c lines 128-363: the names of the generated arrays (get_c_name,
#       find_unique_cname), the byte array output (dump_hex, output_object_code), the module
#       loader that follows the imports of the compiled modules (jsc_module_loader) and
#       compile_file.
#
#==============================================================================================

# mark: Names ===================================================================================

## The identifier of the arrays of `file`: the prefix and the base name without its
## extension, other characters than letters and digits replaced by '_' (get_c_name).
func get_c_name(buf: u8*, buf_size: usize, file: const u8*):
    var p = file
    if let slash = strrchr(file, (i32)'/'):
        p = slash + 1
    var len: usize = 0
    if let r = strrchr(p, (i32)'.'):
        len = (usize)(r - p)
    else:
        len = strlen(p)
    pstrcpy(buf, buf_size, c_ident_prefix.bytes.data)
    var q = strlen(buf)
    for i in 0..<len:
        var ch = p[i]
        if not ((ch >= '0' and ch <= '9') or (ch >= 'A' and ch <= 'Z') or (ch >= 'a' and ch <= 'z')):
            ch = '_'
        if q < buf_size - 1:
            buf[q] = ch
            q += 1
    buf[q] = 0

## find a C name not matching an existing module C name by adding a numeric suffix
func find_unique_cname(cname: u8*, cname_size: usize):
    var cname1: u8[1024] = ---
    assert(cname_size >= 32)
    let len = strlen(cname)
    let max_len = cname_size - 16
    if len > max_len:
        cname[max_len] = 0
    var suffix_num: i32 = 1
    while true:
        _ = snprintf(&cname1[0], 1024, z("%s_%d"), cname, suffix_num)
        if namelist_find(&cname_list, &cname1[0]) == none:
            break
        suffix_num += 1
    pstrcpy(cname, cname_size, &cname1[0])

# mark: Output ==================================================================================

## The bytes of `buf` as the elements of a Luce array literal, eight per line.
func dump_hex(f: void*, buf: const u8*, len: usize):
    var col = 0
    for i in 0..<len:
        if col == 0:
            _ = fputs(z("   "), f)
        _ = fprintf(f, z(" 0x%02x,"), (u32)buf[i])
        col += 1
        if col == 8:
            _ = fprintf(f, z("\n"))
            col = 0
    if col != 0:
        _ = fprintf(f, z("\n"))

## the kinds of the generated arrays (CNameTypeEnum)
let cname_type_script: i32 = 0
let cname_type_module: i32 = 1
let cname_type_json_module: i32 = 2

## Write `obj` with JS_WriteObject as the arrays `c_name` and `c_name`_size.
func output_object_code(ctx: js.Context*, fo: void*, obj: js.Value, c_name: const u8*, c_name_type: i32):
    var flags: i32 = 0
    if c_name_type != cname_type_json_module:
        flags = js.write_obj_bytecode
    if byte_swap:
        flags |= js.write_obj_bswap
    var out_buf_len: usize = 0
    let out_buf = js.js_write_object(ctx, &out_buf_len, obj, flags) catch:
        host.js_std_dump_error(ctx)
        c_exit(1)

    namelist_add(&cname_list, c_name, none, c_name_type)

    _ = fprintf(fo, z("## The size of %s.\npub let %s_size: u32 = %u\n\n"),
                c_name, c_name, (u32)out_buf_len)
    if c_name_type == cname_type_json_module:
        _ = fprintf(fo, z("## The JSON value of the module %s, written by JS_WriteObject.\n"), c_name)
    else:
        _ = fprintf(fo, z("## The bytecode of %s, written by JS_WriteObject.\n"), c_name)
    _ = fprintf(fo, z("pub let %s: u8[%u] = [\n"), c_name, (u32)out_buf_len)
    dump_hex(fo, out_buf, out_buf_len)
    _ = fprintf(fo, z("]\n\n"))

    js.js_free(ctx, out_buf)

# mark: Module loader ===========================================================================

func js_module_dummy_init(ctx: js.Context*, m: js.ModuleDef*) -> !:
    # should never be called when compiling JS code
    abort()

## The module loader while compiling: a declared native module or a .so becomes a dummy
## module; any other module is compiled and written out too (jsc_module_loader).
func jsc_module_loader(ctx: js.Context*, module_name: const u8*, opaque: void*?,
                       attributes: js.Value) -> js.ModuleDef*!:
    # check if it is a declared C or system module
    if let e = namelist_find(&cmodule_list, module_name):
        # add in the static init module list
        namelist_add(&init_module_list, e.name, e.short_name, 0)
        # create a dummy module
        return try js.js_new_c_module(ctx, module_name, js_module_dummy_init)
    if has_suffix(module_name, ".so"):
        _ = fprintf(stderr(), z("Warning: binary module '%s' will be dynamically loaded\n"), module_name)
        # create a dummy module
        let m = try js.js_new_c_module(ctx, module_name, js_module_dummy_init)
        # the resulting executable will export its symbols for the dynamic library
        dynamic_export = true
        return m

    let fo = outfile else abort()
    var buf_len: usize = 0
    var cname: u8[1024] = ---
    let buf = host.js_load_file(ctx, &buf_len, module_name) else try js.js_throw_reference_error(ctx, f"could not load module filename '{view(module_name)}'")

    let res = host.js_module_test_json(ctx, attributes)
    if has_suffix(module_name, ".json") or res > 0:
        # compile as JSON or JSON5 depending on "type"
        var flags: i32 = 0
        if res == 2:
            flags = js.parse_json_ext
        let parsed = js.js_parse_json2(ctx, buf, buf_len, module_name, flags) catch failure:
            js.js_free(ctx, buf)
            error(failure.code, failure.message)
        js.js_free(ctx, buf)
        let val = parsed
        defer js.js_free_value(ctx, val)
        # create a dummy module
        let m = try js.js_new_c_module(ctx, module_name, js_module_dummy_init)

        get_c_name(&cname[0], 1024, module_name)
        if namelist_find(&cname_list, &cname[0]) != none:
            find_unique_cname(&cname[0], 1024)

        # output the module name
        _ = fprintf(fo, z("## The name of the JSON module %s.\npub let %s_module_name: u8[%u] = [\n"),
                    &cname[0], &cname[0], (u32)(strlen(module_name) + 1))
        dump_hex(fo, module_name, strlen(module_name) + 1)
        _ = fprintf(fo, z("]\n\n"))

        output_object_code(ctx, fo, val, &cname[0], cname_type_json_module)
        return m

    # compile the module
    let compiled = js.js_eval(ctx, buf, buf_len, module_name, js.eval_type_module | js.eval_flag_compile_only) catch failure:
        js.js_free(ctx, buf)
        error(failure.code, failure.message)
    js.js_free(ctx, buf)
    let func_val = compiled
    get_c_name(&cname[0], 1024, module_name)
    if namelist_find(&cname_list, &cname[0]) != none:
        find_unique_cname(&cname[0], 1024)
    output_object_code(ctx, fo, func_val, &cname[0], cname_type_module)

    # the module is already referenced, so we must free it
    let m = (js.ModuleDef*)js.js_value_get_ptr(func_val)
    js.js_free_value(ctx, func_val)
    return m

# mark: Files ===================================================================================

## Compile the file `filename` and write it as the arrays `c_name1` (by default, named
## after the file); module: 1 module, 0 script, -1 detect (compile_file).
func compile_file(ctx: js.Context*, fo: void*, filename: const u8*, c_name1: const u8*?, module: i32):
    var c_name: u8[1024] = ---
    var buf_len: usize = 0
    let loaded = host.js_load_file(ctx, &buf_len, filename)
    if loaded == none:
        _ = fprintf(stderr(), z("Could not load '%s'\n"), filename)
    let buf = loaded else c_exit(1)
    var eval_flags = js.eval_flag_compile_only
    var is_module = module > 0
    if module < 0:
        is_module = has_suffix(filename, ".mjs") or js.js_detect_module(buf, buf_len)
    if is_module:
        eval_flags |= js.eval_type_module
    else:
        eval_flags |= js.eval_type_global
    let obj = js.js_eval(ctx, buf, buf_len, filename, eval_flags) catch:
        host.js_std_dump_error(ctx)
        c_exit(1)
    js.js_free(ctx, buf)
    if let name = c_name1:
        pstrcpy(&c_name[0], 1024, name)
    else:
        get_c_name(&c_name[0], 1024, filename)
        if namelist_find(&cname_list, &c_name[0]) != none:
            find_unique_cname(&c_name[0], 1024)
    output_object_code(ctx, fo, obj, &c_name[0], cname_type_script)
    js.js_free_value(ctx, obj)