quickjs在嵌入式中的应用

零、前言

　　之前搞过在嵌入式中引入Lua作为脚本，以实现动态执行效果。详见（https://www.cnblogs.com/wunaozai/p/14087370.html）但是众所周知原因，其实Lua远远没有JS好，一方面是目前前端的如日中天，加之前端开源的库很多。很多都可以复用。

　　在选型用哪个JS引擎时，参考了网上的资料，最终在JerryScript和QuickJS中间选择，最后选择QuickJS作为本次嵌入到C/C++程序中。主要原因是，虽然QuickJS占用的资源会比JerryScript多一些。但是QuickJS比较新，而且支持ES6以上语法，这样，一些NodeJS的库是可以直接用到这里的。性能相比也跟强大一些。

 

一、安装、编译动态库

这一步，没什么好说的，就是从github上下载代码，然后进行编译，我是用mingw进行编译的，说几个注意点

1. 源码中的Makefile需要修改为window编译，打开文件取消 CONFIG_WIN32=y 注释

2. 把DOCS相关的编译去掉，因为系统没有texi2pdf, makeinfo命令来生成文档

3. 如果在编译过程中出现 -ldl 包未找到， 可以到 https://github.com/pepstack/dlfcn-win32 编译一个 libdl.dll，然后放到编译器的lib目录下

 编译后产生以下几个文件，其中libquickjs是静态链接库，用于链接到c环境实现集成。

qjs.exe就是quickjs的运行环境， qjsc.exe就是可以将js文件编译成c源码，然后把c源码编译成exe。

> qjsc -o hello helloworld.js #通过qjsc编译器，直接将js编译成可执行文件

> qjsc -e -o helloworld.c helloworld.js #将js文件编译转成c文件，上面的编译成可执行文件就是通过该代码实现

> qjsc -c -o helloworld.c helloworld.js #将js文件编译成二进制文件，类似java的字节码文件，然后可以跑到jsc虚拟机中即可，在不方便编译成so动态库的情况下，编译成字节码字节码文件也是一种不错的选择

 

 二、测试验证

普通js测试

console.log("Hello World");

加载js模块

fib_module.js

export function fib(n)
{
    if (n <= 0)
        return 0;
    else if (n == 1)
        return 1;
    else
        return fib(n - 1) + fib(n - 2);
}

hello_module.js

import { fib } from "./fib_module.js";

console.log("Hello World");
console.log("fib(10)=", fib(10));

qjs hello_module.js

拓展 Externd

拓展，表示通过其他语言，拓展JS的能力。比如，纯JS文件，JS调用C/C++写的module。下面分为两种情况分别在Linux和Windows下如何加载

加载so模块(Linux/Unix)

加载so模块，需要在Linux环境测试、一般嵌入式设备也是Linux环境

将官方示例中的fib.c 手动编译成so动态库

#include "../quickjs.h"

#define countof(x) (sizeof(x) / sizeof((x)[0]))

static int fib(int n)
{
    if (n <= 0)
        return 0;
    else if (n == 1)
        return 1;
    else
        return fib(n - 1) + fib(n - 2);
}

static JSValue js_fib(JSContext *ctx, JSValueConst this_val,
                      int argc, JSValueConst *argv)
{
    int n, res;
    if (JS_ToInt32(ctx, &n, argv[0]))
        return JS_EXCEPTION;
    res = fib(n);
    return JS_NewInt32(ctx, res);
}

static const JSCFunctionListEntry js_fib_funcs[] = {
    JS_CFUNC_DEF("fib", 1, js_fib ),
};

static int js_fib_init(JSContext *ctx, JSModuleDef *m)
{
    return JS_SetModuleExportList(ctx, m, js_fib_funcs,
                                  countof(js_fib_funcs));
}

#ifdef JS_SHARED_LIBRARY
#define JS_INIT_MODULE js_init_module
#else
#define JS_INIT_MODULE js_init_module_fib
#endif

JSModuleDef *JS_INIT_MODULE(JSContext *ctx, const char *module_name)
{
    JSModuleDef *m;
    m = JS_NewCModule(ctx, module_name, js_fib_init);
    if (!m)
        return NULL;
    JS_AddModuleExportList(ctx, m, js_fib_funcs, countof(js_fib_funcs));
    return m;
}

编译so库命令行

gcc fib.c -shared -DJS_SHARED_LIBRARY -o fib.so

如果没有加上 -DJS_SHARED_LIBRARY，那么在import引用so库时，会提示 ReferenceError: could not load module filename 'fib.so': js_init_module not found

js加载so库例子

/* example of JS module importing a C module */

import { fib } from "./fib.so";

console.log("Hello World");
console.log("fib(10)=", fib(10));

 

加载so模块(Window)

除了Linux环境，有时候仿真需要在Windows上测试，因此需要能支持加载dll模块才行。 可以参考这篇文章。https://zhuanlan.zhihu.com/p/623863082

主要的修改点如下，可以打开quickjs-libc.c 这个文件，搜索 js_module_loader_so函数，就会发现 在 #if defined(_WIN32) 

static JSModuleDef *js_module_loader_so(JSContext *ctx,
                                        const char *module_name)
{
    JS_ThrowReferenceError(ctx, "shared library modules are not supported yet");
    return NULL;
}

需要将上面的代码改成下面的代码，使其能加载so或者dll

static JSModuleDef *js_module_loader_so(JSContext *ctx,
                                        const char *module_name)
{
    //实现支持window dll动态库
    JSModuleDef *m;
    void *hd;
    JSInitModuleFunc *init;
    char *filename;
    
    if (!strchr(module_name, '/')) {
        /* must add a '/' so that the DLL is not searched in the
           system library paths */
        filename = js_malloc(ctx, strlen(module_name) + 2 + 1);
        if (!filename)
            return NULL;
        strcpy(filename, "./");
        strcpy(filename + 2, module_name);
    } else {
        filename = (char *)module_name;
    }
    
    /* C module */
    hd = LoadLibrary(filename);
    if (filename != module_name)
        js_free(ctx, filename);
    if (!hd) {
        JS_ThrowReferenceError(ctx, "could not load module filename '%s' as shared library",
                               module_name);
        goto fail;
    }

    init = (JSInitModuleFunc*)GetProcAddress(hd, "js_init_module");
    if (!init) {
        JS_ThrowReferenceError(ctx, "could not load module filename '%s': js_init_module not found",
                               module_name);
        goto fail;
    }

    m = init(ctx, module_name);
    if (!m) {
        JS_ThrowReferenceError(ctx, "could not load module filename '%s': initialization error",
                               module_name);
    fail:
        if (hd)
            FreeLibrary(hd);
        return NULL;
    }
    return m;
}

原理也比较简单，就是Linux和Windows上的动态库操作函数不一样而已。

主要的区别是以下部分：

Windows使用LoadLibrary函数加载动态库
Windows使用FreeLibrary释放动态库
Windows使用GetProcAddress查找动态库提供的函数
而对于Linux/macos

unix-like使用dlopen函数加载动态库
unix-like使用dlclose释放动态库
unix-like使用dlsym查找动态库提供的函数。

编译成so库

gcc fib.c ..\libquickjs.a -shared -DJS_SHARED_LIBRARY -o fib.so

调用so库

D:\test\quickjs\examples>..\qjs.exe test_fib.js
Hello World
fib(10)= 55

 

嵌入 Embed

嵌入，表示通过在其他编程语言中，嵌入JS的能力，使其能执行JS脚本。比如，在C/C++程序中，能执行JS脚本，并能进行交互。

使用文档真不好找，先要试用默认的std、os库，总是提示不存在。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "quickjs-libc.h"

int main(int argc, char *argv[])
{
  printf("HELLO\n");

  JSRuntime *rt = JS_NewRuntime();
  js_std_init_handlers(rt);
  JSContext *ctx = JS_NewContext(rt);
  /* system modules */
  js_init_module_std(ctx, "std");
  js_init_module_os(ctx, "os");
  const char *str =
      "import * as std from 'std';\n"
      "import * as os from 'os';\n"
      "globalThis.std = std;\n"
      "globalThis.os = os;\n"
      "var console = {};\n"
      "console.log = value => std.printf(value);\n";
  JSValue init_compile =
      JS_Eval(ctx, str, strlen(str), "<input>", JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);

  js_module_set_import_meta(ctx, init_compile, 1, 1);
  JSValue init_run = JS_EvalFunction(ctx, init_compile);
  
  const char *test_val = R"(
    var console = {};
    console.log = value => globalThis.std.printf(value + "\n");
    console.log('ok')
    for(var key in globalThis){
      console.log("--->" + key)
    }
    for(var key in std){
      console.log("--->" + key)
    }
    for(var key in os){
      console.log("--->" + key)
    }
    globalThis.std.printf('hello_world\n');
    globalThis.std.printf(globalThis + "\n");
    var a = false;
    os.setTimeout(()=>{std.printf('AAB\n')}, 2000)
    globalThis.std.printf(a + "\n");
  )";
  JSValue result = JS_Eval(ctx, test_val, strlen(test_val), "test", JS_EVAL_TYPE_MODULE);
  printf("loop\n");
  js_std_loop(ctx);

  int32_t len;
  int to_int_32;
  if ((to_int_32 = JS_ToInt32(ctx, &len, result)) != 0) {
    js_std_dump_error(ctx);
    
  }

  JS_FreeContext(ctx);
  JS_FreeRuntime(rt);
  return 0;
}

编译

Linux:  gcc test.c -o main  -L . -I . -lm -lquickjs -ldl -lpthread
Window: gcc test.c libquickjs.a -o main.exe -I . 

 

参考资料：

　　https://github.com/quickjs-zh/QuickJS/

　　https://github.com/saghul/txiki.js/

　　https://github.com/bellard/quickjs

　　https://bellard.org/quickjs/quickjs.html#Quick-start

　　https://zhuanlan.zhihu.com/p/379697068

　　https://zhuanlan.zhihu.com/p/382296206

　　https://fuchsia.googlesource.com/third_party/quickjs/+/refs/heads/main/basic_test.cc

　　 libdl.dll 库 https://files.cnblogs.com/files/wunaozai/libdl.zip

本文地址：https://www.cnblogs.com/wunaozai/p/17850789.html

系列目录：https://www.cnblogs.com/wunaozai/p/17853962.html