@mikrojs/native 0.0.7

package/src/platform_posix.cpp

@@ -0,0 +1,134 @@
+#include "mikrojs/platform.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <unistd.h>
+
+static int64_t posix_get_boot_us(void) {
+    struct timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    return (int64_t)ts.tv_sec * 1000000 + ts.tv_nsec / 1000;
+}
+
+static int64_t posix_get_rtc_us(void) {
+    /* No deep sleep on desktop — same as boot */
+    return posix_get_boot_us();
+}
+
+static uint32_t posix_random(void) {
+    return arc4random();
+}
+
+static void posix_restart(void) {
+    exit(1);
+}
+
+static void posix_yield(void) {
+    usleep(1000);
+}
+
+static size_t posix_get_free_system_mem(void) {
+    return 0;  /* Not available on desktop */
+}
+
+static size_t posix_get_min_free_system_mem(void) {
+    return 0;  /* Not available on desktop */
+}
+
+static size_t posix_get_total_system_mem(void) {
+    return 0;  /* Not available on desktop */
+}
+
+static size_t posix_get_largest_free_system_mem(void) {
+    return 0;  /* Not available on desktop */
+}
+
+static bool posix_get_fs_info(const char* label, size_t* total, size_t* used) {
+    (void)label;
+    (void)total;
+    (void)used;
+    return false;
+}
+
+static int posix_stdout_write(const void* buf, size_t len) {
+    return (int)write(fileno(stdout), buf, len);
+}
+
+static int posix_stderr_write(const void* buf, size_t len) {
+    return (int)write(fileno(stderr), buf, len);
+}
+
+static int posix_stdin_read(void* buf, size_t len) {
+    return (int)read(fileno(stdin), buf, len);
+}
+
+/* Derive a stable device ID from the hostname. FNV-1a hash truncated to
+ * 6 bytes, then Crockford's Base32 encoded (10 lowercase chars).
+ * Deterministic across restarts on the same machine. */
+static const char* posix_get_device_id(void) {
+    static const char cb32[] = "0123456789abcdefghjkmnpqrstvwxyz";
+    static char id[11] = {0};
+    if (id[0] == '\0') {
+        char hostname[256];
+        if (gethostname(hostname, sizeof(hostname)) != 0) {
+            hostname[0] = '?';
+            hostname[1] = '\0';
+        }
+        /* FNV-1a 64-bit, then take the low 48 bits */
+        uint64_t h = 0xcbf29ce484222325ULL;
+        for (const char* p = hostname; *p; p++) {
+            h ^= (uint8_t)*p;
+            h *= 0x100000001b3ULL;
+        }
+        uint64_t v = h & 0xffffffffffffULL;
+        for (int i = 9; i >= 0; i--) {
+            id[i] = cb32[v & 0x1f];
+            v >>= 5;
+        }
+    }
+    return id;
+}
+
+static void posix_log(int level, const char* tag, const char* fmt, ...) {
+    if (level < MIK_LOG_ERROR || level > MIK_LOG_VERBOSE) return;
+    fprintf(stderr, "[%s] %s: ", mik_log_level_name(level), tag);
+    va_list args;
+    va_start(args, fmt);
+    vfprintf(stderr, fmt, args);
+    va_end(args);
+    fprintf(stderr, "\n");
+}
+
+static const MIKPlatform posix_platform = {
+    .get_boot_us = posix_get_boot_us,
+    .get_rtc_us = posix_get_rtc_us,
+    .random = posix_random,
+    .restart = posix_restart,
+    .yield = posix_yield,
+    .get_free_system_mem = posix_get_free_system_mem,
+    .get_min_free_system_mem = posix_get_min_free_system_mem,
+    .get_total_system_mem = posix_get_total_system_mem,
+    .get_largest_free_system_mem = posix_get_largest_free_system_mem,
+    .get_fs_info = posix_get_fs_info,
+    .log = posix_log,
+    .stdout_write = posix_stdout_write,
+    .stderr_write = posix_stderr_write,
+    .stdin_read = posix_stdin_read,
+    .get_device_id = posix_get_device_id,
+};
+
+static const MIKPlatform* current_platform = &posix_platform;
+
+void MIK_SetPlatform(const MIKPlatform* platform) {
+    current_platform = platform;
+}
+
+const MIKPlatform* MIK_GetPlatform(void) {
+    return current_platform;
+}
+
+const MIKPlatform* MIK_DefaultPOSIXPlatform(void) {
+    return &posix_platform;
+}

package/src/timers.cpp

@@ -0,0 +1,208 @@
+#include <mikrojs/platform.h>
+#include <mikrojs/private.h>
+#include <mikrojs/utils.h>
+
+#include <algorithm>
+
+#include "quickjs.h"
+
+#define MAX_SAFE_INTEGER (((uint32_t)1 << 31) - 1)
+
+uint32_t MIK_Timer_Schedule(MIKTimers* timers, JSContext* ctx, const JSValue func, const int argc,
+                            const JSValue* argv, const int64_t timeout, const bool is_interval,
+                            const int64_t now = MIK_GetPlatform()->get_boot_us()) {
+    auto timer_id = timers->next_timer_id++;
+
+    if (timer_id > MAX_SAFE_INTEGER)
+        timer_id = 1;
+
+    const int64_t next_deadline = now + timeout;
+
+    auto entry = MIKTimerEntry{
+        timer_id, is_interval, timeout, next_deadline, JS_DupValue(ctx, func), argc, {},
+    };
+
+    for (int i = 0; i < argc; i++) {
+        entry.argv[i] = JS_DupValue(ctx, argv[i]);
+    }
+
+    timers->entries.push_back(entry);
+    return entry.id;
+}
+
+bool MIK_Timer_UnSchedule(MIKTimers* timers, JSContext* ctx, uint32_t id) {
+    auto it = std::find_if(timers->entries.begin(), timers->entries.end(),
+                           [id](const MIKTimerEntry& e) { return e.id == id; });
+    if (it != timers->entries.end()) {
+        JS_FreeValue(ctx, it->func);
+        for (int i = 0; i < it->argc; i++) JS_FreeValue(ctx, it->argv[i]);
+        timers->entries.erase(it);  // remove the element
+        return true;
+    }
+
+    return false;
+}
+
+size_t MIK_Timer_CountDue(MIKTimers* timers, int64_t now) {
+    size_t count = 0;
+    for (const auto& entry : timers->entries) {
+        if (entry.next_deadline <= now) {
+            count++;
+        }
+    }
+    return count;
+}
+
+void MIK_Timer_SetNextDeadline(MIKTimers* timers, uint32_t id, int64_t next_deadline) {
+    for (auto& timer : timers->entries) {
+        if (timer.id == id) {
+            timer.next_deadline = next_deadline;
+            return;
+        }
+    }
+}
+
+void MIK_Timer_ClearAll(MIKTimers* timers, JSContext* ctx) {
+    while (!timers->entries.empty()) {
+        auto& entry = timers->entries.back();
+        JS_FreeValue(ctx, entry.func);
+        for (int i = 0; i < entry.argc; i++) JS_FreeValue(ctx, entry.argv[i]);
+        timers->entries.pop_back();
+    }
+}
+
+MIKTimerRegistry* MIK_NewTimerRegistry() {
+    auto* timers = new MIKTimerRegistry();
+    timers->entries.reserve(MIK_MAX_DUE_TIMERS);
+    return timers;
+}
+
+static JSValue mik__timer_set(JSContext* ctx, JSValue this_val, int argc, JSValue* argv,
+                              int magic) {
+    MIKRuntime* mik_runtime = static_cast<MIKRuntime*>(JS_GetContextOpaque(ctx));
+    CHECK_NOT_NULL(mik_runtime);
+
+    int64_t delay;
+    JSValue func;
+
+    func = argv[0];
+    if (!JS_IsFunction(ctx, func)) {
+        return JS_ThrowTypeError(ctx, "not a function");
+    }
+
+    if (argc <= 1) {
+        delay = 0;
+    } else if (JS_ToInt64(ctx, &delay, argv[1])) {
+        return JS_EXCEPTION;
+    }
+
+    int nargs = argc - 2;
+    if (nargs < 0) {
+        nargs = 0;
+    }
+    if (nargs > MIK_TIMER_MAX_ARGS) {
+        return JS_ThrowRangeError(ctx, "too many arguments for setTimeout/setInterval (max %d)",
+                                  MIK_TIMER_MAX_ARGS);
+    }
+
+    uint32_t id = MIK_Timer_Schedule(mik_runtime->timers, mik_runtime->ctx, func, nargs,
+                                     argv + 2, delay * 1000, magic);
+
+    return JS_NewInt32(ctx, id);
+}
+
+static JSValue mik__timer_clear(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    MIKRuntime* mik_runtime = static_cast<MIKRuntime*>(JS_GetContextOpaque(ctx));
+    CHECK_NOT_NULL(mik_runtime);
+    int64_t timer_id;
+
+    if (JS_ToInt64(ctx, &timer_id, argv[0])) {
+        return JS_EXCEPTION;
+    }
+
+    MIK_Timer_UnSchedule(mik_runtime->timers, mik_runtime->ctx, timer_id);
+    return JS_UNDEFINED;
+}
+
+static const JSCFunctionListEntry mik_timer_funcs[] = {
+    JS_CFUNC_MAGIC_DEF("setTimeout", 2, mik__timer_set, 0),
+    MIK_CFUNC_DEF("clearTimeout", 1, mik__timer_clear),
+    JS_CFUNC_MAGIC_DEF("setInterval", 2, mik__timer_set, 1),
+    MIK_CFUNC_DEF("clearInterval", 1, mik__timer_clear)};
+
+void mik__timers_init(JSContext* ctx, JSValue ns) {
+    JS_SetPropertyFunctionList(ctx, ns, mik_timer_funcs, countof(mik_timer_funcs));
+}
+
+void mik__timers_destroy(JSContext* ctx) {
+    const MIKRuntime* mik_rt = static_cast<MIKRuntime*>(JS_GetContextOpaque(ctx));
+    MIK_Timer_ClearAll(mik_rt->timers, mik_rt->ctx);
+}
+
+void mik__timers_consume(JSContext* ctx) {
+    MIKRuntime* mik_rt = static_cast<MIKRuntime*>(JS_GetContextOpaque(ctx));
+    auto* timers = mik_rt->timers;
+    const MIKPlatform* platform = MIK_GetPlatform();
+    int64_t now = platform->get_boot_us();
+
+    // Collect IDs of due timers into a small stack buffer to avoid heap allocation.
+    // This lets us safely iterate even if callbacks add/remove timers.
+    uint32_t due_ids[MIK_MAX_DUE_TIMERS];
+    size_t due_count = 0;
+
+    for (auto& entry : timers->entries) {
+        if (entry.next_deadline <= now) {
+            if (due_count < MIK_MAX_DUE_TIMERS) {
+                due_ids[due_count++] = entry.id;
+            }
+            // Update interval deadlines before executing callbacks
+            if (entry.is_interval) {
+                entry.next_deadline = entry.timeout + platform->get_boot_us();
+            }
+        }
+    }
+
+    if (due_count == 0)
+        return;
+
+    for (size_t i = 0; i < due_count; i++) {
+        // Re-find the entry — a previous callback may have cleared it
+        auto it = std::find_if(timers->entries.begin(), timers->entries.end(),
+                               [&](const MIKTimerEntry& e) { return e.id == due_ids[i]; });
+        if (it == timers->entries.end())
+            continue;
+
+        // Dup the function and args before calling — the callback may call
+        // clearInterval which frees the entry (and its JSValues) mid-call.
+        JSValue func = JS_DupValue(mik_rt->ctx, it->func);
+        int nargs = it->argc;
+        JSValue args[MIK_TIMER_MAX_ARGS];
+        for (int j = 0; j < nargs; j++) {
+            args[j] = JS_DupValue(mik_rt->ctx, it->argv[j]);
+        }
+
+        JSValue ret = JS_Call(mik_rt->ctx, func, JS_UNDEFINED, nargs, args);
+        if (JS_IsException(ret)) {
+            if (mik_rt->error_handler_fn && JS_HasException(mik_rt->ctx)) {
+                JSValue exc = JS_GetException(mik_rt->ctx);
+                mik_rt->error_handler_fn(mik_rt->ctx, exc, mik_rt->error_handler_opaque);
+                JS_Throw(mik_rt->ctx, exc);
+            }
+            mik_dump_error(mik_rt->ctx);
+        }
+        JS_FreeValue(mik_rt->ctx, ret);
+        JS_FreeValue(mik_rt->ctx, func);
+        for (int j = 0; j < nargs; j++) {
+            JS_FreeValue(mik_rt->ctx, args[j]);
+        }
+    }
+
+    // Remove one-shot timers that are still alive (not already cleared by a callback)
+    for (size_t i = 0; i < due_count; i++) {
+        auto it = std::find_if(timers->entries.begin(), timers->entries.end(),
+                               [&](const MIKTimerEntry& e) { return e.id == due_ids[i]; });
+        if (it != timers->entries.end() && !it->is_interval) {
+            MIK_Timer_UnSchedule(timers, mik_rt->ctx, due_ids[i]);
+        }
+    }
+}

package/src/utils.cpp

@@ -0,0 +1,173 @@
+#include "mikrojs/utils.h"
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "mikrojs/mikrojs.h"
+#include "mikrojs/private.h"
+
+JSValue mik_new_error(JSContext* ctx, int err) {
+    JSValue obj = JS_NewError(ctx);
+    JS_DefinePropertyValueStr(ctx, obj, "message", JS_NewString(ctx, strerror(err)),
+                              JS_PROP_C_W_E);
+    JS_DefinePropertyValueStr(ctx, obj, "errno", JS_NewInt32(ctx, err), JS_PROP_C_W_E);
+    return obj;
+}
+
+JSValue mik_throw_errno(JSContext* ctx, int err) {
+    return JS_Throw(ctx, mik_new_error(ctx, err));
+}
+
+void mik_assert(const struct AssertionInfo info) {
+    fprintf(stderr, "%s:%s%s Assertion `%s' failed.\n", info.file_line, info.function,
+            *info.function ? ":" : "", info.message);
+    fflush(stderr);
+    abort();
+}
+
+static void mik_dump_obj(JSContext* ctx, FILE* f, JSValue val) {
+    const char* str = JS_ToCString(ctx, val);
+    if (str) {
+        fprintf(f, "%s\n", str);
+        JS_FreeCString(ctx, str);
+    } else {
+        fprintf(f, "[exception]\n");
+    }
+}
+
+void mik_dump_error(JSContext* ctx) {
+    JSValue exception_val = JS_GetException(ctx);
+    mik_dump_error1(ctx, exception_val);
+    JS_FreeValue(ctx, exception_val);
+}
+
+void mik_dump_error1(JSContext* ctx, JSValue exception_val) {
+    /* In REPL mode, use the colorized report path */
+    if (MIK_IsReplActive()) {
+        mik__report_uncaught(ctx, exception_val);
+        return;
+    }
+
+    int is_error = JS_IsError(exception_val);
+    mik_dump_obj(ctx, stderr, exception_val);
+    if (is_error) {
+        JSValue val = JS_GetPropertyStr(ctx, exception_val, "stack");
+        if (!JS_IsUndefined(val)) {
+            mik_dump_obj(ctx, stderr, val);
+        }
+        JS_FreeValue(ctx, val);
+    }
+    fflush(stderr);
+}
+
+void mik_call_handler(JSContext* ctx, JSValue func, int argc, JSValue* argv) {
+    JSValue ret, func1;
+    /* 'func' might be destroyed when calling itself (if it frees the
+       handler), so must take extra care */
+    func1 = JS_DupValue(ctx, func);
+    ret = JS_Call(ctx, func1, JS_UNDEFINED, argc, argv);
+    JS_FreeValue(ctx, func1);
+    if (JS_IsException(ret)) {
+        mik_dump_error(ctx);
+    }
+    JS_FreeValue(ctx, ret);
+}
+
+JSValue MIK_InitPromise(JSContext* ctx, MIKPromise* p) {
+    JSValue rfuncs[2];
+    p->p = JS_NewPromiseCapability(ctx, rfuncs);
+    if (JS_IsException(p->p)) {
+        return JS_EXCEPTION;
+    }
+    p->rfuncs[0] = rfuncs[0];
+    p->rfuncs[1] = rfuncs[1];
+    return JS_DupValue(ctx, p->p);
+}
+
+bool MIK_IsPromisePending(JSContext* ctx, MIKPromise* p) { return !JS_IsUndefined(p->p); }
+
+void MIK_FreePromise(JSContext* ctx, MIKPromise* p) {
+    JS_FreeValue(ctx, p->rfuncs[0]);
+    JS_FreeValue(ctx, p->rfuncs[1]);
+    JS_FreeValue(ctx, p->p);
+}
+
+void MIK_FreePromiseRT(JSRuntime* rt, MIKPromise* p) {
+    JS_FreeValueRT(rt, p->rfuncs[0]);
+    JS_FreeValueRT(rt, p->rfuncs[1]);
+    JS_FreeValueRT(rt, p->p);
+}
+
+void MIK_ClearPromise(JSContext* ctx, MIKPromise* p) {
+    p->p = JS_UNDEFINED;
+    p->rfuncs[0] = JS_UNDEFINED;
+    p->rfuncs[1] = JS_UNDEFINED;
+}
+
+void MIK_MarkPromise(JSRuntime* rt, MIKPromise* p, JS_MarkFunc* mark_func) {
+    JS_MarkValue(rt, p->p, mark_func);
+    JS_MarkValue(rt, p->rfuncs[0], mark_func);
+    JS_MarkValue(rt, p->rfuncs[1], mark_func);
+}
+
+void MIK_SettlePromise(JSContext* ctx, MIKPromise* p, bool is_reject, int argc, JSValue* argv) {
+    JSValue ret = JS_Call(ctx, p->rfuncs[is_reject], JS_UNDEFINED, argc, argv);
+    for (int i = 0; i < argc; i++) {
+        JS_FreeValue(ctx, argv[i]);
+    }
+    if (JS_IsException(ret)) {
+        mik_dump_error(ctx);
+    }
+    JS_FreeValue(ctx, ret);
+    MIK_FreePromise(ctx, p);
+}
+
+void MIK_ResolvePromise(JSContext* ctx, MIKPromise* p, int argc, JSValue* argv) {
+    MIK_SettlePromise(ctx, p, false, argc, argv);
+}
+
+void MIK_RejectPromise(JSContext* ctx, MIKPromise* p, int argc, JSValue* argv) {
+    MIK_SettlePromise(ctx, p, true, argc, argv);
+}
+
+static inline JSValue mik__settled_promise(JSContext* ctx, bool is_reject, int argc,
+                                           JSValue* argv) {
+    JSValue promise, resolving_funcs[2], ret;
+
+    promise = JS_NewPromiseCapability(ctx, resolving_funcs);
+    if (JS_IsException(promise)) {
+        return JS_EXCEPTION;
+    }
+
+    ret = JS_Call(ctx, resolving_funcs[is_reject], JS_UNDEFINED, argc, argv);
+
+    for (int i = 0; i < argc; i++) {
+        JS_FreeValue(ctx, argv[i]);
+    }
+    JS_FreeValue(ctx, ret);
+    JS_FreeValue(ctx, resolving_funcs[0]);
+    JS_FreeValue(ctx, resolving_funcs[1]);
+
+    return promise;
+}
+
+JSValue MIK_NewResolvedPromise(JSContext* ctx, int argc, JSValue* argv) {
+    return mik__settled_promise(ctx, false, argc, argv);
+}
+
+JSValue MIK_NewRejectedPromise(JSContext* ctx, int argc, JSValue* argv) {
+    return mik__settled_promise(ctx, true, argc, argv);
+}
+
+static void mik__buf_free(JSRuntime* rt, void* opaque, void* ptr) { js_free_rt(rt, ptr); }
+
+JSValue MIK_NewUint8Array(JSContext* ctx, uint8_t* data, size_t size) {
+    return JS_NewUint8Array(ctx, data, size, mik__buf_free, NULL, false);
+}
+
+void mik_dbuf_init(JSContext* ctx, DynBuf* s) {
+    dbuf_init2(s, JS_GetRuntime(ctx), (DynBufReallocFunc*)js_realloc_rt);
+}