File Coverage

QuickJS.xs

Criterion	Covered	Total	%
statement	451	482	93.5
branch	151	202	74.7
condition			n/a
subroutine			n/a
pod			n/a
total	602	684	88.0

#include

#include "easyxs/easyxs.h"

#include "quickjs/quickjs.h"
#include "quickjs/quickjs-libc.h"

#define PERL_NS_ROOT "JavaScript::QuickJS"

#define PERL_BOOLEAN_CLASS "Types::Serialiser::Boolean"

#define PQJS_JSOBJECT_CLASS PERL_NS_ROOT "::JSObject"
#define PQJS_FUNCTION_CLASS PERL_NS_ROOT "::Function"
#define PQJS_REGEXP_CLASS   PERL_NS_ROOT "::RegExp"
#define PQJS_DATE_CLASS     PERL_NS_ROOT "::Date"
#define PQJS_PROMISE_CLASS  PERL_NS_ROOT "::Promise"

typedef struct {
    JSContext *ctx;
    pid_t pid;
    bool added_std;
    bool added_os;
    bool added_helpers;
    char* module_base_path;
} perl_qjs_s;

typedef struct {
    JSContext *ctx;
    JSValue jsobj;
    pid_t pid;
} perl_qjs_jsobj_s;

typedef struct {
#ifdef MULTIPLICITY
    tTHX aTHX;
#endif
    SV** svs;
    U32 svs_count;
    U32 refcount;
    bool ran_js_std_init_handlers;
    JSValue regexp_jsvalue;
    JSValue date_jsvalue;
    JSValue promise_jsvalue;
} ctx_opaque_s;

const char* __jstype_name_back[] = {
    [JS_TAG_BIG_DECIMAL - JS_TAG_FIRST] = "big decimal",
    [JS_TAG_BIG_INT - JS_TAG_FIRST] = "big integer",
    [JS_TAG_BIG_FLOAT - JS_TAG_FIRST] = "big float",
    [JS_TAG_SYMBOL - JS_TAG_FIRST] = "symbol",
    [JS_TAG_MODULE - JS_TAG_FIRST] = "module",
    [JS_TAG_OBJECT - JS_TAG_FIRST] = "object",
    [JS_TAG_FLOAT64 - JS_TAG_FIRST] = "float64",

    /* Small hack to ensure we can always read: */
    [99] = NULL,
};

const char* const DATE_GETTER_FROM_IX[] = {
    "toString",
    "toUTCString",
    "toGMTString",
    "toISOString",
    "toDateString",
    "toTimeString",
    "toLocaleString",
    "toLocaleDateString",
    "toLocaleTimeString",
    "getTimezoneOffset",
    "getTime",
    "getFullYear",
    "getUTCFullYear",
    "getMonth",
    "getUTCMonth",
    "getDate",
    "getUTCDate",
    "getHours",
    "getUTCHours",
    "getMinutes",
    "getUTCMinutes",
    "getSeconds",
    "getUTCSeconds",
    "getMilliseconds",
    "getUTCMilliseconds",
    "getDay",
    "getUTCDay",
    "toJSON",
};

const char* const DATE_SETTER_FROM_IX[] = {
    "setTime",
    "setMilliseconds",
    "setUTCMilliseconds",
    "setSeconds",
    "setUTCSeconds",
    "setMinutes",
    "setUTCMinutes",
    "setHours",
    "setUTCHours",
    "setDate",
    "setUTCDate",
    "setMonth",
    "setUTCMonth",
    "setFullYear",
    "setUTCFullYear",
};

#if defined _WIN32 || defined __CYGWIN__
#   define PATH_SEPARATOR '\\'
#else
#   define PATH_SEPARATOR '/'
#endif

#define _jstype_name(typenum) __jstype_name_back[ typenum - JS_TAG_FIRST ]

static SV* _JSValue_to_SV (pTHX_ JSContext* ctx, JSValue jsval, SV** err_svp);

static inline SV* _JSValue_special_object_to_SV (pTHX_ JSContext* ctx, JSValue jsval, SV** err_svp, const char* class) {
    assert(!*err_svp);

    SV* sv = exs_new_structref(perl_qjs_jsobj_s, class);
    perl_qjs_jsobj_s* pqjs = exs_structref_ptr(sv);

    *pqjs = (perl_qjs_jsobj_s) {
        .ctx = ctx,
        .jsobj = JS_DupValue(ctx, jsval),
        .pid = getpid(),
    };

    ctx_opaque_s* ctxdata = JS_GetContextOpaque(ctx);
    ctxdata->refcount++;

    return sv;
}

static inline SV* _JSValue_object_to_SV (pTHX_ JSContext* ctx, JSValue jsval, SV** err_svp) {
    assert(!*err_svp);

    JSPropertyEnum *tab_atom;
    uint32_t tab_atom_count;

    int propnameserr = JS_GetOwnPropertyNames(ctx, &tab_atom, &tab_atom_count, jsval, JS_GPN_STRING_MASK);

    PERL_UNUSED_VAR(propnameserr);
    assert(!propnameserr);

    HV* hv = newHV();

    for(int i = 0; i < tab_atom_count; i++) {
        JSValue key = JS_AtomToString(ctx, tab_atom[i].atom);
        STRLEN strlen;
        const char* keystr = JS_ToCStringLen(ctx, &strlen, key);

        JSValue value = JS_GetProperty(ctx, jsval, tab_atom[i].atom);

        SV* val_sv = _JSValue_to_SV(aTHX_ ctx, value, err_svp);

        if (val_sv) {
            hv_store(hv, keystr, -strlen, val_sv, 0);
        }

        JS_FreeCString(ctx, keystr);
        JS_FreeValue(ctx, key);
        JS_FreeValue(ctx, value);
        JS_FreeAtom(ctx, tab_atom[i].atom);

        if (!val_sv) break;
    }

    js_free(ctx, tab_atom);

    if (*err_svp) {
        SvREFCNT_dec( (SV*) hv );
        return NULL;
    }

    return newRV_noinc((SV*) hv);
}

static inline SV* _JSValue_array_to_SV (pTHX_ JSContext* ctx, JSValue jsval, SV** err_svp) {
    JSValue jslen = JS_GetPropertyStr(ctx, jsval, "length");
    uint32_t len;
    JS_ToUint32(ctx, &len, jslen);
    JS_FreeValue(ctx, jslen);

    AV* av = newAV();

    if (len) {
        av_fill( av, len - 1 );
        for (uint32_t i=0; i
            JSValue jsitem = JS_GetPropertyUint32(ctx, jsval, i);

            SV* val_sv = _JSValue_to_SV(aTHX_ ctx, jsitem, err_svp);

            if (val_sv) av_store( av, i, val_sv );

            JS_FreeValue(ctx, jsitem);

            if (!val_sv) break;
        }
    }

    if (*err_svp) {
        SvREFCNT_dec((SV*) av);
        return NULL;
    }

    return newRV_noinc((SV*) av);
}

/* NO JS exceptions allowed here! */
static SV* _JSValue_to_SV (pTHX_ JSContext* ctx, JSValue jsval, SV** err_svp) {
    assert(!*err_svp);

    SV* RETVAL;

    int tag = JS_VALUE_GET_NORM_TAG(jsval);

    assert(tag != JS_TAG_EXCEPTION);

    switch (tag) {
        case JS_TAG_STRING:
            STMT_START {
                STRLEN strlen;
                const char* str = JS_ToCStringLen(ctx, &strlen, jsval);
                RETVAL = newSVpvn_flags(str, strlen, SVf_UTF8);
                JS_FreeCString(ctx, str);
            } STMT_END;
            break;

        case JS_TAG_INT:
            RETVAL = newSViv(JS_VALUE_GET_INT(jsval));
            break;

        case JS_TAG_FLOAT64:
            RETVAL = newSVnv(JS_VALUE_GET_FLOAT64(jsval));
            break;

        case JS_TAG_BOOL:
            RETVAL = boolSV(JS_VALUE_GET_BOOL(jsval));
            break;

        case JS_TAG_NULL:
        case JS_TAG_UNDEFINED:
            RETVAL = &PL_sv_undef;
            break;

        case JS_TAG_OBJECT:
            if (JS_IsFunction(ctx, jsval)) {
                load_module(
                    PERL_LOADMOD_NOIMPORT,
                    newSVpvs(PQJS_FUNCTION_CLASS),
                    NULL
                );

                SV* func_sv = exs_new_structref(perl_qjs_jsobj_s, PQJS_FUNCTION_CLASS);
                perl_qjs_jsobj_s* pqjs = exs_structref_ptr(func_sv);

                *pqjs = (perl_qjs_jsobj_s) {
                    .ctx = ctx,
                    .jsobj = JS_DupValue(ctx, jsval),
                    .pid = getpid(),
                };

                ctx_opaque_s* ctxdata = JS_GetContextOpaque(ctx);
                ctxdata->refcount++;

                RETVAL = func_sv;
            }
            else if (JS_IsArray(ctx, jsval)) {
                RETVAL = _JSValue_array_to_SV(aTHX_ ctx, jsval, err_svp);
            }
            else {

                ctx_opaque_s* ctxdata = JS_GetContextOpaque(ctx);

                if (JS_IsInstanceOf(ctx, jsval, ctxdata->regexp_jsvalue)) {
                    RETVAL = _JSValue_special_object_to_SV(aTHX_ ctx, jsval, err_svp, PQJS_REGEXP_CLASS);
                }
                else if (JS_IsInstanceOf(ctx, jsval, ctxdata->date_jsvalue)) {
                    RETVAL = _JSValue_special_object_to_SV(aTHX_ ctx, jsval, err_svp, PQJS_DATE_CLASS);
                }
                else if (JS_IsInstanceOf(ctx, jsval, ctxdata->promise_jsvalue)) {
                    RETVAL = _JSValue_special_object_to_SV(aTHX_ ctx, jsval, err_svp, PQJS_PROMISE_CLASS);
                }
                else {
                    RETVAL = _JSValue_object_to_SV(aTHX_ ctx, jsval, err_svp);
                }
            }

            break;

        default:
            STMT_START {
                const char* typename = _jstype_name(tag);

                if (typename) {
                    *err_svp = newSVpvf("Cannot convert JS %s (QuickJS tag %d) to Perl!", typename, tag);
                }
                else {
                    *err_svp = newSVpvf("Cannot convert (unexpected) JS tag value %d to Perl!", tag);
                }

                return NULL;
            } STMT_END;
    }

    return RETVAL;
}

static inline void _ctx_add_sv(pTHX_ JSContext* ctx, SV* sv) {
    ctx_opaque_s* ctxdata = JS_GetContextOpaque(ctx);

    ctxdata->svs_count++;

    if (ctxdata->svs_count == 1) {
        Newx(ctxdata->svs, ctxdata->svs_count, SV*);
    }
    else {
        Renew(ctxdata->svs, ctxdata->svs_count, SV*);
    }

    ctxdata->svs[ctxdata->svs_count - 1] = SvREFCNT_inc(sv);
}

static JSValue _sv_to_jsvalue(pTHX_ JSContext* ctx, SV* value, SV** error);

#define _MAX_ERRSV_TO_JS_TRIES 10

/* Kind of like _sv_to_jsvalue(), but we need to handle the case where
   the error SV’s own conversion to a JSValue fails. In that case, we
   warn on the 1st error, then propagate the 2nd. Repeat until there are
   no errors.
*/
static JSValue _sv_error_to_jsvalue(pTHX_ JSContext* ctx, SV* error) {
    SV* error2 = NULL;

    uint32_t tries = 0;

    JSValue to_js;

    while (1) {
        to_js = _sv_to_jsvalue(aTHX_ ctx, error, &error2);

        if (!error2) break;

        warn_sv(error);

        tries++;
        if (tries > _MAX_ERRSV_TO_JS_TRIES) {
            warn_sv(error2);
            return JS_NewString(ctx, "Failed to convert Perl error to JavaScript after " STRINGIFY(_MAX_ERRSV_TO_JS_TRIES) " tries!");
        }

        error = error2;
        error2 = NULL;
    }

    return to_js;
}

static JSValue __do_perl_callback(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int jsmagic, JSValue *func_data) {

#ifdef MULTIPLICITY
    ctx_opaque_s* ctxdata = JS_GetContextOpaque(ctx);
    pTHX = ctxdata->aTHX;
#endif

    PERL_UNUSED_VAR(jsmagic);
    SV* cb_sv = ((SV**) func_data)[0];

    SV* args[argc + 1];
    args[argc] = NULL;

    SV* error_sv = NULL;

    for (int a=0; a
        args[a] = _JSValue_to_SV(aTHX_ ctx, argv[a], &error_sv);

        if (error_sv) {
            while (--a >= 0) {
                SvREFCNT_dec(args[a]);
            }

            break;
        }
    }

    if (!error_sv) {
        SV* from_perl = exs_call_sv_scalar_trapped(cb_sv, args, &error_sv);

        if (from_perl) {
            JSValue to_js = _sv_to_jsvalue(aTHX_ ctx, from_perl, &error_sv);

            sv_2mortal(from_perl);

            if (!error_sv) return to_js;
        }
    }

    JSValue jserr = _sv_error_to_jsvalue(aTHX_ ctx, error_sv);

    return JS_Throw(ctx, jserr);
}

static JSValue _sviv_to_js(pTHX_ JSContext* ctx, SV* value) {
    if (sizeof(IV) == sizeof(int64_t)) {
        return JS_NewInt64(ctx, (int64_t) SvIV(value));
    }

    return JS_NewInt32(ctx, (int32_t) SvIV(value));
}

static JSValue _sv_to_jsvalue(pTHX_ JSContext* ctx, SV* value, SV** error_svp) {
    SvGETMAGIC(value);

    switch ( exs_sv_type(value) ) {
        case EXS_SVTYPE_UNDEF:
            return JS_NULL;

        case EXS_SVTYPE_BOOLEAN:
            return JS_NewBool(ctx, SvTRUE(value));

        case EXS_SVTYPE_STRING: STMT_START {
            STRLEN len;
            const char* str = SvPVutf8(value, len);

            return JS_NewStringLen(ctx, str, len);
        } STMT_END;

        case EXS_SVTYPE_UV: STMT_START {
            UV val_uv = SvUV(value);

            if (sizeof(UV) == sizeof(uint64_t)) {
                if (val_uv > IV_MAX) {
                    return JS_NewFloat64(ctx, val_uv);
                }
                else {
                    return JS_NewInt64(ctx, (int64_t) val_uv);
                }
            }
            else {
                return JS_NewUint32(ctx, (uint32_t) val_uv);
            }
        } STMT_END;

        case EXS_SVTYPE_IV: STMT_START {
            return _sviv_to_js(aTHX_ ctx, value);
        } STMT_END;

        case EXS_SVTYPE_NV: STMT_START {
            return JS_NewFloat64(ctx, (double) SvNV(value));
        } STMT_END;

        case EXS_SVTYPE_REFERENCE:
            if (sv_isobject(value)) {
                if (sv_derived_from(value, PERL_BOOLEAN_CLASS)) {
                    return JS_NewBool(ctx, SvTRUE(SvRV(value)));
                }
                else if (sv_derived_from(value, PQJS_JSOBJECT_CLASS)) {
                    perl_qjs_jsobj_s* pqjs = exs_structref_ptr(value);

                    if (LIKELY(pqjs->ctx == ctx)) {
                        return JS_DupValue(ctx, pqjs->jsobj);
                    }

                    *error_svp = newSVpvf("%s for QuickJS %p given to QuickJS %p!", sv_reftype(SvRV(value), 1), pqjs->ctx, ctx);
                    return JS_NULL;
                }

                break;
            }

            switch (SvTYPE(SvRV(value))) {
                case SVt_PVCV:
                    _ctx_add_sv(aTHX_ ctx, value);

                    /* A hack to store our callback via the func_data pointer: */
                    JSValue dummy = JS_MKPTR(JS_TAG_INT, value);

                    return JS_NewCFunctionData(
                        ctx,
                        __do_perl_callback,
                        0, 0,
                        1, &dummy
                    );

                case SVt_PVAV: STMT_START {
                    AV* av = (AV*) SvRV(value);
                    JSValue jsarray = JS_NewArray(ctx);
                    JS_SetPropertyStr(ctx, jsarray, "length", JS_NewUint32(ctx, 1 + av_len(av)));

                    for (int32_t i=0; i <= av_len(av); i++) {
                        SV** svp = av_fetch(av, i, 0);
                        assert(svp);
                        assert(*svp);

                        JSValue jsval = _sv_to_jsvalue(aTHX_ ctx, *svp, error_svp);

                        if (*error_svp) {
                            JS_FreeValue(ctx, jsarray);
                            return _sv_error_to_jsvalue(aTHX_ ctx, *error_svp);
                        }

                        JS_SetPropertyUint32(ctx, jsarray, i, jsval);
                    }

                    return jsarray;
                } STMT_END;

                case SVt_PVHV: STMT_START {
                    HV* hv = (HV*) SvRV(value);
                    JSValue jsobj = JS_NewObject(ctx);

                    hv_iterinit(hv);

                    HE* hvent;
                    while ( (hvent = hv_iternext(hv)) ) {
                        SV* key_sv = hv_iterkeysv(hvent);
                        SV* val_sv = hv_iterval(hv, hvent);

                        STRLEN keylen;
                        const char* key = SvPVutf8(key_sv, keylen);

                        JSValue jsval = _sv_to_jsvalue(aTHX_ ctx, val_sv, error_svp);
                        if (*error_svp) {
                            JS_FreeValue(ctx, jsobj);
                            return _sv_error_to_jsvalue(aTHX_ ctx, *error_svp);
                        }

                        JSAtom prop = JS_NewAtomLen(ctx, key, keylen);

                        /* NB: ctx takes over jsval. */
                        JS_DefinePropertyValue(ctx, jsobj, prop, jsval, JS_PROP_WRITABLE);

                        JS_FreeAtom(ctx, prop);
                    }

                    return jsobj;
                } STMT_END;

                default:
                    break;
            }

        default:
            break;
    }

    *error_svp = newSVpvf("Cannot convert %" SVf " to JavaScript!", value);

    return JS_NULL;
}

static JSContext* _create_new_jsctx( pTHX_ JSRuntime *rt ) {
    JSContext *ctx = JS_NewContext(rt);

    ctx_opaque_s* ctxdata;
    Newxz(ctxdata, 1, ctx_opaque_s);
    JS_SetContextOpaque(ctx, ctxdata);

    JSValue global = JS_GetGlobalObject(ctx);

    *ctxdata = (ctx_opaque_s) {
        .refcount = 1,
        .regexp_jsvalue = JS_GetPropertyStr(ctx, global, "RegExp"),
        .date_jsvalue = JS_GetPropertyStr(ctx, global, "Date"),
        .promise_jsvalue = JS_GetPropertyStr(ctx, global, "Promise"),
#ifdef MULTIPLICITY
        .aTHX = aTHX,
#endif
    };

    JS_FreeValue(ctx, global);

    return ctx;
}

static SV* _get_exception_from_jsvalue(pTHX_ JSContext* ctx, JSValue jsret) {
    SV* err;

    JSValue jserr = JS_GetException(ctx);
    //err = _JSValue_to_SV(aTHX_ ctx, jserr);

    /* Ideal here is to capture all aspects of the error object,
        including its `name` and members. But for now just give
        a string.

        JSValue jslen = JS_GetPropertyStr(ctx, jserr, "name");
        STRLEN namelen;
        const char* namestr = JS_ToCStringLen(ctx, &namelen, jslen);
    */

    STRLEN strlen;
    const char* str = JS_ToCStringLen(ctx, &strlen, jserr);

    err = newSVpvn_flags(str, strlen, SVf_UTF8);

    JS_FreeCString(ctx, str);
    JS_FreeValue(ctx, jserr);

    return err;
}

static inline SV* _return_jsvalue_or_croak(pTHX_ JSContext* ctx, JSValue jsret) {
    SV* err;
    SV* RETVAL;

    if (JS_IsException(jsret)) {
        err = _get_exception_from_jsvalue(aTHX_ ctx, jsret);
        RETVAL = NULL;  // silence uninitialized warning
    }
    else {
        err = NULL;
        RETVAL = _JSValue_to_SV(aTHX_ ctx, jsret, &err);
    }

    JS_FreeValue(ctx, jsret);

    if (err) croak_sv(err);

    return RETVAL;
}

static void _free_jsctx(pTHX_ JSContext* ctx) {
    ctx_opaque_s* ctxdata = JS_GetContextOpaque(ctx);

    if (--ctxdata->refcount == 0) {
        JS_FreeValue(ctx, ctxdata->regexp_jsvalue);
        JS_FreeValue(ctx, ctxdata->date_jsvalue);
        JS_FreeValue(ctx, ctxdata->promise_jsvalue);

        JSRuntime *rt = JS_GetRuntime(ctx);

        for (U32 i=0; isvs_count; i++) {
            SvREFCNT_dec(ctxdata->svs[i]);
        }

        if (ctxdata->ran_js_std_init_handlers) {
            js_std_free_handlers(rt);
        }

        Safefree(ctxdata);

        JS_FreeContext(ctx);

        JS_FreeRuntime(rt);
    }
}

static JSModuleDef *pqjs_module_loader(JSContext *ctx,
                              const char *module_name, void *opaque) {
    char** module_base_path_p = (char**) opaque;

    char* module_base_path = *module_base_path_p;

    JSModuleDef *moduledef;

    if (module_base_path) {
        size_t base_path_len = strlen(module_base_path);
        size_t module_name_len = strlen(module_name);

        char real_path[1 + base_path_len + module_name_len];

        memcpy(real_path, module_base_path, base_path_len);
        memcpy(real_path + base_path_len, module_name, module_name_len);
        real_path[base_path_len + module_name_len] = 0;

        moduledef = js_module_loader(ctx, real_path, NULL);
    }
    else {
        moduledef = js_module_loader(ctx, module_name, NULL);
    }

    return moduledef;
}

/* These must correlate to the ALIAS values below. */
static const char* _REGEXP_ACCESSORS[] = {
    "flags",
    "dotAll",
    "global",
    "hasIndices",
    "ignoreCase",
    "multiline",
    "source",
    "sticky",
    "unicode",
    "lastIndex",
};

/* These must correlate to the ALIAS values below. */
static const char* _FUNCTION_ACCESSORS[] = {
    "length",
    "name",
};

#define FUNC_CALL_INITIAL_ARGS 2

// returns the SV to croak.
static SV* _svs_to_jsvars(pTHX_ JSContext* jsctx, int32_t params_count, SV** svs, JSValue* jsvars) {
    SV* error = NULL;

    for (int32_t i=0; i
        SV* cur_sv = svs[i];

        JSValue jsval = _sv_to_jsvalue(aTHX_ jsctx, cur_sv, &error);

        if (error) {
            while (--i >= 0) {
                JS_FreeValue(jsctx, jsvars[i]);
            }

            break;
        }

        jsvars[i] = jsval;
    }

    return error;
}

static void _import_module_to_global(pTHX_ JSContext* jsctx, const char* modname) {
    const char* jstemplate = "import * as theModule from '%s';\n"
        "globalThis.%s = theModule;\n";

    char js[255] = { 0 };
    snprintf(js, 255, jstemplate, modname, modname);

    JSValue val = JS_Eval(jsctx, js, strlen(js), "", JS_EVAL_TYPE_MODULE);
    if (JS_IsException(val)) {
        SV* errsv = _get_exception_from_jsvalue(aTHX_ jsctx, val);
        if (errsv) {
            croak_sv(errsv);
        }

        croak("Got empty exception??");
    }

    JS_FreeValue(jsctx, val);
}

/* ---------------------------------------------------------------------- */

MODULE = JavaScript::QuickJS        PACKAGE = JavaScript::QuickJS

PROTOTYPES: DISABLE

SV*
_new (SV* classname_sv)
    CODE:
        JSRuntime *rt = JS_NewRuntime();
        JS_SetHostPromiseRejectionTracker(rt, js_std_promise_rejection_tracker, NULL);
        JS_SetModuleLoaderFunc(rt, NULL, js_module_loader, NULL);

        JSContext *ctx = _create_new_jsctx(aTHX_ rt);

        RETVAL = exs_new_structref(perl_qjs_s, SvPVbyte_nolen(classname_sv));
        perl_qjs_s* pqjs = exs_structref_ptr(RETVAL);

        *pqjs = (perl_qjs_s) {
            .ctx = ctx,
            .pid = getpid(),
        };

        JS_SetModuleLoaderFunc(
            rt,
            NULL,
            pqjs_module_loader,
            &pqjs->module_base_path
        );

        JS_SetRuntimeInfo(rt, PERL_NS_ROOT);

    OUTPUT:
        RETVAL

void
DESTROY (SV* self_sv)
    CODE:
        perl_qjs_s* pqjs = exs_structref_ptr(self_sv);

        if (PL_dirty && pqjs->pid == getpid()) {
            warn("DESTROYing %" SVf " at global destruction; memory leak likely!\n", self_sv);
        }

        if (pqjs->module_base_path) Safefree(pqjs->module_base_path);

        _free_jsctx(aTHX_ pqjs->ctx);

SV*
_configure (SV* self_sv, SV* max_stack_size_sv, SV* memory_limit_sv, SV* gc_threshold_sv)
    CODE:
        perl_qjs_s* pqjs = exs_structref_ptr(self_sv);

        JSRuntime *rt = JS_GetRuntime(pqjs->ctx);

        if (SvOK(max_stack_size_sv)) {
            JS_SetMaxStackSize(rt, exs_SvUV(max_stack_size_sv));
        }

        if (SvOK(memory_limit_sv)) {
            JS_SetMemoryLimit(rt, exs_SvUV(memory_limit_sv));
        }

        if (SvOK(gc_threshold_sv)) {
            JS_SetGCThreshold(rt, exs_SvUV(gc_threshold_sv));
        }

        RETVAL = SvREFCNT_inc(self_sv);

    OUTPUT:
        RETVAL

SV*
std (SV* self_sv)
    ALIAS:
        os = 1
        helpers = 2
    CODE:
        perl_qjs_s* pqjs = exs_structref_ptr(self_sv);

        switch (ix) {
            case 0:
                if (!pqjs->added_std) {
                    js_init_module_std(pqjs->ctx, "std");
                    _import_module_to_global(aTHX_ pqjs->ctx, "std");
                    pqjs->added_std = true;
                }

                break;
            case 1:
                if (!pqjs->added_os) {
                    js_init_module_os(pqjs->ctx, "os");
                    pqjs->added_os = true;

                    ctx_opaque_s* ctxdata = JS_GetContextOpaque(pqjs->ctx);

                    if (!ctxdata->ran_js_std_init_handlers) {
                        JSRuntime *rt = JS_GetRuntime(pqjs->ctx);
                        js_std_init_handlers(rt);

                        ctxdata->ran_js_std_init_handlers = true;
                    }

                    _import_module_to_global(aTHX_ pqjs->ctx, "os");
                }

                break;
            case 2:
                if (!pqjs->added_helpers) {
                    js_std_add_helpers(pqjs->ctx, 0, NULL);
                    pqjs->added_helpers = true;
                }

                break;

            default:
                croak("%s: Bad XS alias: %d\n", __func__, (int) ix);
        }

        RETVAL = SvREFCNT_inc(self_sv);

    OUTPUT:
        RETVAL

SV*
unset_module_base (SV* self_sv)
    CODE:
        perl_qjs_s* pqjs = exs_structref_ptr(self_sv);

        if (pqjs->module_base_path) {
            Safefree(pqjs->module_base_path);
            pqjs->module_base_path = NULL;
        }

        RETVAL = SvREFCNT_inc(self_sv);
    OUTPUT:
        RETVAL

SV*
set_module_base (SV* self_sv, SV* path_sv)
    CODE:
        if (!SvOK(path_sv)) croak("Give a path! (Did you want unset_module_base?)");

        perl_qjs_s* pqjs = exs_structref_ptr(self_sv);

        const char* path = exs_SvPVbyte_nolen(path_sv);

        size_t path_len = strlen(path);

        if (pqjs->module_base_path) {
            Renew(pqjs->module_base_path, 2 + path_len, char);
        }
        else {
            Newx(pqjs->module_base_path, 2 + path_len, char);
        }

        Copy(path, pqjs->module_base_path, 2 + path_len, char);

        /** If the given path is “/foo/bar”, we store “/foo/bar/”.
            This means if “/foo/bar/” is given we store “/foo/bar//”,
            which is ugly but should work on all supported platforms.
        */
        pqjs->module_base_path[path_len] = PATH_SEPARATOR;
        pqjs->module_base_path[1 + path_len] = 0;

        RETVAL = SvREFCNT_inc(self_sv);
    OUTPUT:
        RETVAL

SV*
set_globals (SV* self_sv, ...)
    CODE:
        if (items < 2) croak("Need at least 1 key/value pair.");

        if (!(items % 2)) croak("Need an even list of key/value pairs.");

        I32 valscount = (items - 1) >> 1;

        perl_qjs_s* pqjs = exs_structref_ptr(self_sv);

        SV* jsname_sv, *value_sv;

        SV* error = NULL;

        JSAtom jsnames[valscount];
        JSValue jsvals[valscount];

        for (int i=0; i < valscount; i++) {
            jsname_sv = ST( 1 + (i << 1) );
            value_sv = ST( 2 + (i << 1) );

            STRLEN jsnamelen;
            const char* jsname_str = SvPVutf8(jsname_sv, jsnamelen);

            JSValue jsval = _sv_to_jsvalue(aTHX_ pqjs->ctx, value_sv, &error);

            if (error) {
                while (i-- > 0) {
                    JS_FreeAtom(pqjs->ctx, jsnames[i]);
                    JS_FreeValue(pqjs->ctx, jsvals[i]);
                }

                croak_sv(error);
            }

            jsnames[i] = JS_NewAtomLen(pqjs->ctx, jsname_str, jsnamelen);
            jsvals[i] = jsval;
        }

        JSValue jsglobal = JS_GetGlobalObject(pqjs->ctx);

        for (int i=0; i < valscount; i++) {
            /* NB: ctx takes over jsval. */
            JS_DefinePropertyValue(pqjs->ctx, jsglobal, jsnames[i], jsvals[i], JS_PROP_WRITABLE);
            JS_FreeAtom(pqjs->ctx, jsnames[i]);
        }

        JS_FreeValue(pqjs->ctx, jsglobal);

        RETVAL = SvREFCNT_inc(self_sv);

    OUTPUT:
        RETVAL

SV*
eval (SV* self_sv, SV* js_code_sv)
    ALIAS:
        eval_module = 1
    CODE:
        perl_qjs_s* pqjs = exs_structref_ptr(self_sv);
        JSContext *ctx = pqjs->ctx;

        STRLEN js_code_len;
        const char* js_code = SvPVutf8(js_code_sv, js_code_len);

        int eval_flags = ix ? JS_EVAL_TYPE_MODULE : JS_EVAL_TYPE_GLOBAL;
        eval_flags |= JS_EVAL_FLAG_STRICT;

        JSValue jsret = JS_Eval(ctx, js_code, js_code_len, "", eval_flags);

        // In eval_module()’s case we want to croak if there was
        // an exception. If not we’ll just discard the return value
        RETVAL = _return_jsvalue_or_croak(aTHX_ ctx, jsret);

    OUTPUT:
        RETVAL

SV*
await (SV* self_sv)
    CODE:
        perl_qjs_s* pqjs = exs_structref_ptr(self_sv);
        JSContext *ctx = pqjs->ctx;

        js_std_loop(ctx);

        RETVAL = SvREFCNT_inc(self_sv);

    OUTPUT:
        RETVAL

# ----------------------------------------------------------------------

MODULE = JavaScript::QuickJS        PACKAGE = JavaScript::QuickJS::Date

SV*
setTime (SV* self_sv, SV* num_sv)
    ALIAS:
        setMilliseconds = 1
        setUTCMilliseconds = 2
        setSeconds = 3
        setUTCSeconds = 4
        setMinutes = 5
        setUTCMinutes = 6
        setHours = 7
        setUTCHours = 8
        setDate = 9
        setUTCDate = 10
        setMonth = 11
        setUTCMonth = 12
        setFullYear = 13
        setUTCFullYear = 14

    CODE:
        const char* setter_name = DATE_SETTER_FROM_IX[ix];

        perl_qjs_jsobj_s* pqjs = exs_structref_ptr(self_sv);
        JSContext *ctx = pqjs->ctx;

        JSAtom prop = JS_NewAtom(ctx, setter_name);

        JSValue arg;
        NV nvval;

        switch (exs_sv_type(num_sv)) {

            // In 32-bit perls setTime() values often overflow IV_MAX.
            case EXS_SVTYPE_NV:
            case EXS_SVTYPE_STRING:
                nvval = SvNV(num_sv);
                if (nvval > IV_MAX || nvval < IV_MIN) {
                    arg = JS_NewFloat64(ctx, (double) nvval);
                    break;
                }

                // fallthrough

            default:
                    arg = _sviv_to_js(aTHX_ ctx, num_sv);
        }

        JSValue jsret = JS_Invoke(
            ctx,
            pqjs->jsobj,
            prop,
            1,
            &arg
        );

        JS_FreeAtom(ctx, prop);
        JS_FreeValue(ctx, arg);

        RETVAL = _return_jsvalue_or_croak(aTHX_ pqjs->ctx, jsret);

    OUTPUT:
        RETVAL

SV*
toString (SV* self_sv, ...)
    ALIAS:
        toUTCString = 1
        toGMTString = 2
        toISOString = 3
        toDateString = 4
        toTimeString = 5
        toLocaleString = 6
        toLocaleDateString = 7
        toLocaleTimeString = 8
        getTimezoneOffset = 9
        getTime = 10
        getFullYear = 11
        getUTCFullYear = 12
        getMonth = 13
        getUTCMonth = 14
        getDate = 15
        getUTCDate = 16
        getHours = 17
        getUTCHours = 18
        getMinutes = 19
        getUTCMinutes = 20
        getSeconds = 21
        getUTCSeconds = 22
        getMilliseconds = 23
        getUTCMilliseconds = 24
        getDay = 25
        getUTCDay = 26
        toJSON = 27
    CODE:
        perl_qjs_jsobj_s* pqjs = exs_structref_ptr(self_sv);
        JSContext *ctx = pqjs->ctx;

        JSAtom prop = JS_NewAtom(ctx, DATE_GETTER_FROM_IX[ix]);

        JSValue jsret;

        if (items > 1) {
            int params_count = items - 1;

            JSValue jsargs[params_count];

            SV* error = _svs_to_jsvars(aTHX_ ctx, params_count, &ST(1), jsargs);
            if (error) {
                JS_FreeAtom(pqjs->ctx, prop);
                croak_sv(error);
            }

            jsret = JS_Invoke(
                ctx,
                pqjs->jsobj,
                prop,
                params_count,
                jsargs
            );

            for (uint32_t i=0; i
                JS_FreeValue(ctx, jsargs[i]);
            }
        }
        else {
            jsret = JS_Invoke(
                ctx,
                pqjs->jsobj,
                prop,
                0,
                NULL
            );
        }

        JS_FreeAtom(ctx, prop);

        RETVAL = _return_jsvalue_or_croak(aTHX_ pqjs->ctx, jsret);

    OUTPUT:
        RETVAL

# ----------------------------------------------------------------------

MODULE = JavaScript::QuickJS        PACKAGE = JavaScript::QuickJS::RegExp

SV*
exec (SV* self_sv, SV* specimen_sv)
    ALIAS:
        test = 1
    CODE:
        perl_qjs_jsobj_s* pqjs = exs_structref_ptr(self_sv);
        JSContext *ctx = pqjs->ctx;

        STRLEN specimen_len;
        const char* specimen = SvPVutf8(specimen_sv, specimen_len);

        /* TODO: optimize? */
        JSAtom prop = JS_NewAtom(ctx, ix ? "test" : "exec");

        JSValue specimen_js = JS_NewStringLen(ctx, specimen, specimen_len);

        JSValue jsret = JS_Invoke(
            ctx,
            pqjs->jsobj,
            prop,
            1,
            &specimen_js
        );

        JS_FreeValue(ctx, specimen_js);
        JS_FreeAtom(ctx, prop);

        RETVAL = _return_jsvalue_or_croak(aTHX_ pqjs->ctx, jsret);

    OUTPUT:
        RETVAL

SV*
flags( SV* self_sv)
    ALIAS:
        dotAll = 1
        global = 2
        hasIndices = 3
        ignoreCase = 4
        multiline = 5
        source = 6
        sticky = 7
        unicode = 8
        lastIndex = 9
    CODE:
        perl_qjs_jsobj_s* pqjs = exs_structref_ptr(self_sv);

        JSValue myret = JS_GetPropertyStr(pqjs->ctx, pqjs->jsobj, _REGEXP_ACCESSORS[ix]);

        SV* err = NULL;

        RETVAL = _JSValue_to_SV(aTHX_ pqjs->ctx, myret, &err);

        JS_FreeValue(pqjs->ctx, myret);

        if (err) croak_sv(err);

    OUTPUT:
        RETVAL

# ----------------------------------------------------------------------

MODULE = JavaScript::QuickJS        PACKAGE = JavaScript::QuickJS::JSObject

void
DESTROY( SV* self_sv )
    CODE:
        perl_qjs_jsobj_s* pqjs = exs_structref_ptr(self_sv);

        if (PL_dirty && pqjs->pid == getpid()) {
            warn("DESTROYing %" SVf " at global destruction; memory leak likely!\n", self_sv);
        }

        JS_FreeValue(pqjs->ctx, pqjs->jsobj);

        _free_jsctx(aTHX_ pqjs->ctx);

# ----------------------------------------------------------------------

MODULE = JavaScript::QuickJS        PACKAGE = JavaScript::QuickJS::Function

SV*
_give_self( SV* self_sv, ... )
    CODE:
        RETVAL = SvREFCNT_inc(self_sv);
    OUTPUT:
        RETVAL

SV*
length( SV* self_sv)
    ALIAS:
        name = 1
    CODE:
        perl_qjs_jsobj_s* pqjs = exs_structref_ptr(self_sv);

        JSValue myret = JS_GetPropertyStr(pqjs->ctx, pqjs->jsobj, _FUNCTION_ACCESSORS[ix]);

        SV* err = NULL;

        RETVAL = _JSValue_to_SV(aTHX_ pqjs->ctx, myret, &err);

        JS_FreeValue(pqjs->ctx, myret);

        if (err) croak_sv(err);

    OUTPUT:
        RETVAL

SV*
call( SV* self_sv, SV* this_sv=&PL_sv_undef, ... )
    CODE:
        perl_qjs_jsobj_s* pqjs = exs_structref_ptr(self_sv);

        U32 params_count = items - FUNC_CALL_INITIAL_ARGS;

        SV* error = NULL;

        JSValue thisjs = _sv_to_jsvalue(aTHX_ pqjs->ctx, this_sv, &error);
        if (error) croak_sv(error);

        JSValue jsvars[params_count];

        error = _svs_to_jsvars( aTHX_ pqjs->ctx, params_count, &ST(FUNC_CALL_INITIAL_ARGS), jsvars );
        if (error) {
            JS_FreeValue(pqjs->ctx, thisjs);
            croak_sv(error);
        }

        JSValue jsret = JS_Call(pqjs->ctx, pqjs->jsobj, thisjs, params_count, jsvars);

        JS_FreeValue(pqjs->ctx, thisjs);

        for (uint32_t i=0; i
            JS_FreeValue(pqjs->ctx, jsvars[i]);
        }

        RETVAL = _return_jsvalue_or_croak(aTHX_ pqjs->ctx, jsret);

    OUTPUT:
        RETVAL

# ----------------------------------------------------------------------

MODULE = JavaScript::QuickJS        PACKAGE = JavaScript::QuickJS::Promise

SV*
then( SV* self_sv, SV* on_success=&PL_sv_undef, SV* on_failure=&PL_sv_undef )
    CODE:
        PERL_UNUSED_ARG(on_success);
        PERL_UNUSED_ARG(on_failure);

        perl_qjs_jsobj_s* pqjs = exs_structref_ptr(self_sv);

        SV* error = NULL;

        JSValue jsvars[2];
        int callbacks_count = sizeof(jsvars) / sizeof(jsvars[0]);

        error = _svs_to_jsvars( aTHX_
            pqjs->ctx,
            callbacks_count,
            &ST(1),
            jsvars
        );
        if (error) {
            croak_sv(error);
        }

        JSAtom method_name = JS_NewAtom(pqjs->ctx, "then");

        JSValue jsret = JS_Invoke(
            pqjs->ctx,
            pqjs->jsobj,
            method_name,
            callbacks_count,
            jsvars
        );

        JS_FreeAtom(pqjs->ctx, method_name);

        for (uint32_t i=0; i
            JS_FreeValue(pqjs->ctx, jsvars[i]);
        }

        RETVAL = _return_jsvalue_or_croak(aTHX_ pqjs->ctx, jsret);

    OUTPUT:
        RETVAL

SV*
catch( SV* self_sv, SV* callback=&PL_sv_undef)
    ALIAS:
        finally = 1
    CODE:
        perl_qjs_jsobj_s* pqjs = exs_structref_ptr(self_sv);

        SV* error = NULL;

        JSValue callbackjs = _sv_to_jsvalue(aTHX_ pqjs->ctx, callback, &error);
        if (error) croak_sv(error);

        JSAtom method_name = JS_NewAtom(pqjs->ctx, ix ? "finally" : "catch");

        JSValue jsret = JS_Invoke(
            pqjs->ctx,
            pqjs->jsobj,
            method_name,
            1,
            &callbackjs
        );

        JS_FreeAtom(pqjs->ctx, method_name);
        JS_FreeValue(pqjs->ctx, callbackjs);

        RETVAL = _return_jsvalue_or_croak(aTHX_ pqjs->ctx, jsret);

    OUTPUT:
        RETVAL