add header library for ESP32.

Author: binzume

README.md

@@ -11,22 +11,25 @@ platformio.ini
 
 ```ini
 lib_deps = 
+  ...
 	https://github.com/binzume/esp32quickjs.git
 ```
 
 main.cpp
 
 ```c++
 #include <Arduino.h>
-#include "quickjs.h"
+#include "esp/QuickJS.h"
 
-JSRuntime *rt;
-JSContext *ctx;
+static const char *jscode = R"CODE(
+  console.log('Hello, JavaScript!');
+)CODE";
+
+M5QuickJS qjs;
 
 void setup() {
-  rt = JS_NewRuntime();
-  ctx = JS_NewContext(rt);
-  // Do anything.
+  Serial.begin(115200);
+  qjs.begin();
+  qjs.exec(jscode);
 }
-
 ```

esp32/QuickJS.h

@@ -0,0 +1,290 @@
+#pragma once
+#include <Arduino.h>
+
+#include <algorithm>
+#include <vector>
+
+#include "../quickjs.h"
+
+void qjs_dump_exception(JSContext *ctx, JSValue v) {
+  if (!JS_IsUndefined(v)) {
+    const char *str = JS_ToCString(ctx, v);
+    if (str) {
+      Serial.println(str);
+      JS_FreeCString(ctx, str);
+    } else {
+      Serial.println("[Exception]");
+    }
+  }
+  JSValue e = JS_GetException(ctx);
+  const char *str = JS_ToCString(ctx, e);
+  if (str) {
+    Serial.println(str);
+    JS_FreeCString(ctx, str);
+  }
+  if (JS_IsError(ctx, e)) {
+    JSValue s = JS_GetPropertyStr(ctx, e, "stack");
+    if (!JS_IsUndefined(s)) {
+      const char *str = JS_ToCString(ctx, s);
+      if (str) {
+        Serial.println(str);
+        JS_FreeCString(ctx, str);
+      }
+    }
+    JS_FreeValue(ctx, s);
+  }
+  JS_FreeValue(ctx, e);
+}
+
+class JSTimer {
+  // 20 bytes / entry.
+  struct TimerEntry {
+    uint32_t id;
+    int32_t timeout;
+    int32_t interval;
+    JSValue func;
+  };
+  std::vector<TimerEntry> timers;
+  uint32_t id_counter = 0;
+
+ public:
+  uint32_t RegisterTimer(JSValue f, int32_t time, int32_t interval = -1) {
+    uint32_t id = ++id_counter;
+    timers.push_back(TimerEntry{id, time, interval, f});
+    return id;
+  }
+  void RemoveTimer(uint32_t id) {
+    timers.erase(std::remove_if(timers.begin(), timers.end(),
+                                [id](TimerEntry &t) { return t.id == id; }),
+                 timers.end());
+  }
+  int32_t GetNextTimeout(int32_t now) {
+    if (timers.empty()) {
+      return -1;
+    }
+    std::sort(timers.begin(), timers.end(),
+              [now](TimerEntry &a, TimerEntry &b) -> bool {
+                return (a.timeout - now) >
+                       (b.timeout - now);  // 2^32 wraparound
+              });
+    int next = timers.back().timeout - now;
+    return max(next, 0);
+  }
+  bool ConsumeTimer(JSContext *ctx, int32_t now) {
+    std::vector<TimerEntry> t;
+    int32_t eps = 2;
+    while (!timers.empty() && timers.back().timeout - now <= eps) {
+      t.push_back(timers.back());
+      timers.pop_back();
+    }
+    for (auto &ent : t) {
+      JSValue r =
+          JS_Call(ctx, ent.func, ent.func, 0, nullptr);  // may update timers.
+      if (JS_IsException(r)) {
+        qjs_dump_exception(ctx, r);
+      }
+      JS_FreeValue(ctx, r);
+
+      if (ent.interval >= 0) {
+        ent.timeout = now + ent.interval;
+        timers.push_back(ent);
+      } else {
+        JS_FreeValue(ctx, ent.func);
+      }
+    }
+    return !t.empty();
+  }
+};
+
+class ESP32QuickJS {
+ public:
+  JSRuntime *rt;
+  JSContext *ctx;
+  JSTimer timer;
+  JSValue loop_func = JS_UNDEFINED;
+
+  void begin() {
+    JSRuntime *rt = JS_NewRuntime();
+    begin(rt, JS_NewContext(rt));
+  }
+
+  void begin(JSRuntime *rt, JSContext *ctx, int memoryLimit = 0) {
+    this->rt = rt;
+    this->ctx = ctx;
+    if (memoryLimit == 0) {
+      memoryLimit = ESP.getFreeHeap() >> 1;
+    }
+    JS_SetMemoryLimit(rt, memoryLimit);
+    JS_SetGCThreshold(rt, memoryLimit >> 3);
+    JSValue global = JS_GetGlobalObject(ctx);
+    setup(ctx, global);
+    JS_FreeValue(ctx, global);
+  }
+
+  void loop(bool callLoopFn = true) {
+    // async
+    JSContext *c;
+    int ret = JS_ExecutePendingJob(JS_GetRuntime(ctx), &c);
+    if (ret < 0) {
+      qjs_dump_exception(ctx, JS_UNDEFINED);
+    }
+
+    // timer
+    uint32_t now = millis();
+    if (timer.GetNextTimeout(now) >= 0) {
+      timer.ConsumeTimer(ctx, now);
+    }
+
+    // loop()
+    if (callLoopFn && JS_IsFunction(ctx, loop_func)) {
+      JSValue ret = JS_Call(ctx, loop_func, loop_func, 0, nullptr);
+      if (JS_IsException(ret)) {
+        qjs_dump_exception(ctx, ret);
+      }
+      JS_FreeValue(ctx, ret);
+    }
+  }
+
+  void runGC() { JS_RunGC(rt); }
+
+  bool exec(const char *code) {
+    JSValue result = eval(code);
+    bool ret = JS_IsException(result);
+    JS_FreeValue(ctx, result);
+    return ret;
+  }
+
+  JSValue eval(const char *code) {
+    JSValue ret =
+        JS_Eval(ctx, code, strlen(code), "<eval>", JS_EVAL_FLAG_STRICT);
+    if (JS_IsException(ret)) {
+      qjs_dump_exception(ctx, ret);
+    }
+    return ret;
+  }
+
+  void registerLoopFunc(const char *fname) {
+    JSValue global = JS_GetGlobalObject(ctx);
+    setLoopFunc(JS_GetPropertyStr(ctx, global, fname));
+    JS_FreeValue(ctx, global);
+  }
+
+  void dispose() {
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+  }
+
+ protected:
+  void setLoopFunc(JSValue f) {
+    JS_FreeValue(ctx, loop_func);
+    loop_func = f;
+  }
+
+  virtual void setup(JSContext *ctx, JSValue global) {
+    this->ctx = ctx;
+    JS_SetContextOpaque(ctx, this);
+
+    // setup console.log()
+    JSValue console = JS_NewObject(ctx);
+    JS_SetPropertyStr(ctx, global, "console", console);
+    JS_SetPropertyStr(ctx, console, "log",
+                      JS_NewCFunction(ctx, console_log, "log", 1));
+
+    // timer
+    JS_SetPropertyStr(ctx, global, "setTimeout",
+                      JS_NewCFunction(ctx, set_timeout, "setTimeout", 2));
+    JS_SetPropertyStr(ctx, global, "clearTimeout",
+                      JS_NewCFunction(ctx, clear_timeout, "clearTimeout", 1));
+    JS_SetPropertyStr(ctx, global, "setInterval",
+                      JS_NewCFunction(ctx, set_interval, "setInterval", 2));
+    JS_SetPropertyStr(ctx, global, "clearInterval",
+                      JS_NewCFunction(ctx, clear_timeout, "clearInterval", 1));
+
+    // gpio
+    JSValue gpio = JS_NewObject(ctx);
+    JS_SetPropertyStr(ctx, global, "gpio", gpio);
+    JS_SetPropertyStr(ctx, gpio, "pinMode",
+                      JS_NewCFunction(ctx, gpio_mode, "pinMode", 2));
+    JS_SetPropertyStr(
+        ctx, gpio, "digitalRead",
+        JS_NewCFunction(ctx, gpio_digital_read, "digitalRead", 1));
+    JS_SetPropertyStr(
+        ctx, gpio, "digitalWrite",
+        JS_NewCFunction(ctx, gpio_digital_write, "digitalWrite", 2));
+
+    JS_SetPropertyStr(ctx, global, "registerLoop",
+                      JS_NewCFunction(ctx, register_loop, "registerLoop", 1));
+
+  }
+
+  static JSValue set_timeout(JSContext *ctx, JSValueConst jsThis, int argc,
+                             JSValueConst *argv) {
+    ESP32QuickJS *qjs = (ESP32QuickJS *)JS_GetContextOpaque(ctx);
+    uint32_t t;
+    JS_ToUint32(ctx, &t, argv[1]);
+    uint32_t id =
+        qjs->timer.RegisterTimer(JS_DupValue(ctx, argv[0]), millis() + t);
+    return JS_NewUint32(ctx, id);
+  }
+
+  static JSValue clear_timeout(JSContext *ctx, JSValueConst jsThis, int argc,
+                               JSValueConst *argv) {
+    ESP32QuickJS *qjs = (ESP32QuickJS *)JS_GetContextOpaque(ctx);
+    uint32_t tid;
+    JS_ToUint32(ctx, &tid, argv[0]);
+    qjs->timer.RemoveTimer(tid);
+    return JS_UNDEFINED;
+  }
+
+  static JSValue set_interval(JSContext *ctx, JSValueConst jsThis, int argc,
+                              JSValueConst *argv) {
+    ESP32QuickJS *qjs = (ESP32QuickJS *)JS_GetContextOpaque(ctx);
+    uint32_t t;
+    JS_ToUint32(ctx, &t, argv[1]);
+    uint32_t id =
+        qjs->timer.RegisterTimer(JS_DupValue(ctx, argv[0]), millis() + t, t);
+    return JS_NewUint32(ctx, id);
+  }
+
+  static JSValue gpio_mode(JSContext *ctx, JSValueConst jsThis, int argc,
+                           JSValueConst *argv) {
+    uint32_t pin, mode;
+    JS_ToUint32(ctx, &pin, argv[0]);
+    JS_ToUint32(ctx, &mode, argv[1]);
+    pinMode(pin, mode);
+    return JS_UNDEFINED;
+  }
+
+  static JSValue gpio_digital_read(JSContext *ctx, JSValueConst jsThis,
+                                   int argc, JSValueConst *argv) {
+    uint32_t pin;
+    JS_ToUint32(ctx, &pin, argv[0]);
+    return JS_NewUint32(ctx, digitalRead(pin));
+  }
+
+  static JSValue gpio_digital_write(JSContext *ctx, JSValueConst jsThis,
+                                    int argc, JSValueConst *argv) {
+    uint32_t pin, value;
+    JS_ToUint32(ctx, &pin, argv[0]);
+    JS_ToUint32(ctx, &value, argv[1]);
+    digitalWrite(pin, value);
+    return JS_UNDEFINED;
+  }
+
+  static JSValue console_log(JSContext *ctx, JSValueConst jsThis, int argc,
+                             JSValueConst *argv) {
+    const char *str = JS_ToCString(ctx, argv[0]);
+    if (str) {
+      Serial.println(str);
+      JS_FreeCString(ctx, str);
+    }
+    return JS_UNDEFINED;
+  }
+
+  static JSValue register_loop(JSContext *ctx, JSValueConst jsThis, int argc,
+                               JSValueConst *argv) {
+    ESP32QuickJS *qjs = (ESP32QuickJS *)JS_GetContextOpaque(ctx);
+    qjs->setLoopFunc(JS_DupValue(ctx, argv[0]));
+    return JS_UNDEFINED;
+  }
+};