Skip to content

Instantly share code, notes, and snippets.

@genotrance

genotrance/quickjs.nim

Last active July 15, 2020 16:57
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 1 You must be signed in to fork a gist
  • Save genotrance/4869d1feb53c7ec7be806a2f225d07ab to your computer and use it in GitHub Desktop.
Save genotrance/4869d1feb53c7ec7be806a2f225d07ab to your computer and use it in GitHub Desktop.
Download ZIP
Nim wrapper for quickjs using nimterop
Raw
quickjs.nim
# nim c -d:FLAGS quickjs.nim
#
# FLAGS
# -d:quickjsGit
# -d:quickjsSetVer=
# -d:quickjsStatic
import os
import nimterop/[build, cimport]
const
baseDir = getProjectCacheDir("nimquickjs")
setDefines(@["quickjsStatic"])
getHeader(
header = "quickjs.h",
giturl = "https://github.com/ldarren/quickjs",
outdir = baseDir,
makeFlags = "libquickjs.a"
)
static:
cDisableCaching()
cImport(quickjsPath, flags = "-E__")
Raw
wrapper.nim
# Generated @ 2020-07-03T00:54:21-05:00
# Command line:
# /home/gt/nimterop/nimterop/toast --preprocess -m:c -E__ --pnim --nim:/home/gt/programming/nimdevel/bin/nim /home/gt/.cache/nim/nimterop/nimquickjs/quickjs.h -o /home/gt/programming/wrappers/QuickJS/quickjswrapper.nim
# const 'js_force_inline' has unsupported value 'inline __attribute__((always_inline))'
# const 'JS_BOOL' has unsupported value 'int'
# const 'JS_FLOAT64_NAN' has unsupported value 'NAN'
# const 'JSValueConst' has unsupported value 'JSValue'
# const 'JS_NAN' has unsupported value '(JSValue){ .u.float64 = JS_FLOAT64_NAN, JS_TAG_FLOAT64 }'
# const 'JS_NULL' has unsupported value 'JS_MKVAL(JS_TAG_NULL, 0)'
# const 'JS_UNDEFINED' has unsupported value 'JS_MKVAL(JS_TAG_UNDEFINED, 0)'
# const 'JS_FALSE' has unsupported value 'JS_MKVAL(JS_TAG_BOOL, 0)'
# const 'JS_TRUE' has unsupported value 'JS_MKVAL(JS_TAG_BOOL, 1)'
# const 'JS_EXCEPTION' has unsupported value 'JS_MKVAL(JS_TAG_EXCEPTION, 0)'
# const 'JS_UNINITIALIZED' has unsupported value 'JS_MKVAL(JS_TAG_UNINITIALIZED, 0)'
{.push hint[ConvFromXtoItselfNotNeeded]: off.}
import macros
macro defineEnum(typ: untyped): untyped =
result = newNimNode(nnkStmtList)
# Enum mapped to distinct cint
result.add quote do:
type `typ`* = distinct cint
for i in ["+", "-", "*", "div", "mod", "shl", "shr", "or", "and", "xor", "<", "<=", "==", ">", ">="]:
let
ni = newIdentNode(i)
typout = if i[0] in "<=>": newIdentNode("bool") else: typ # comparisons return bool
if i[0] == '>': # cannot borrow `>` and `>=` from templates
let
nopp = if i.len == 2: newIdentNode("<=") else: newIdentNode("<")
result.add quote do:
proc `ni`*(x: `typ`, y: cint): `typout` = `nopp`(y, x)
proc `ni`*(x: cint, y: `typ`): `typout` = `nopp`(y, x)
proc `ni`*(x, y: `typ`): `typout` = `nopp`(y, x)
else:
result.add quote do:
proc `ni`*(x: `typ`, y: cint): `typout` {.borrow.}
proc `ni`*(x: cint, y: `typ`): `typout` {.borrow.}
proc `ni`*(x, y: `typ`): `typout` {.borrow.}
result.add quote do:
proc `ni`*(x: `typ`, y: int): `typout` = `ni`(x, y.cint)
proc `ni`*(x: int, y: `typ`): `typout` = `ni`(x.cint, y)
let
divop = newIdentNode("/") # `/`()
dlrop = newIdentNode("$") # `$`()
notop = newIdentNode("not") # `not`()
result.add quote do:
proc `divop`*(x, y: `typ`): `typ` = `typ`((x.float / y.float).cint)
proc `divop`*(x: `typ`, y: cint): `typ` = `divop`(x, `typ`(y))
proc `divop`*(x: cint, y: `typ`): `typ` = `divop`(`typ`(x), y)
proc `divop`*(x: `typ`, y: int): `typ` = `divop`(x, y.cint)
proc `divop`*(x: int, y: `typ`): `typ` = `divop`(x.cint, y)
proc `dlrop`*(x: `typ`): string {.borrow.}
proc `notop`*(x: `typ`): `typ` {.borrow.}
{.pragma: impquickjsHdr,
header: "/home/gt/.cache/nim/nimterop/nimquickjs/quickjs.h".}
{.experimental: "codeReordering".}
defineEnum(Enum_quickjsh1)
defineEnum(JSCFunctionEnum) ## ```
## C function definition
## ```
const
JS_TAG_FIRST* = (-11).cint ## ```
## first negative tag
## ```
JS_TAG_BIG_DECIMAL* = (-11).cint ## ```
## first negative tag
## ```
JS_TAG_BIG_INT* = (-10).cint
JS_TAG_BIG_FLOAT* = (-9).cint
JS_TAG_SYMBOL* = (-8).cint
JS_TAG_STRING* = (-7).cint
JS_TAG_MODULE* = (-3).cint ## ```
## used internally
## ```
JS_TAG_FUNCTION_BYTECODE* = (-2).cint ## ```
## used internally
## ```
JS_TAG_OBJECT* = (-1).cint ## ```
## used internally
## ```
JS_TAG_INT* = (0).cint
JS_TAG_BOOL* = (1).cint
JS_TAG_NULL* = (2).cint
JS_TAG_UNDEFINED* = (3).cint
JS_TAG_UNINITIALIZED* = (4).cint
JS_TAG_CATCH_OFFSET* = (5).cint
JS_TAG_EXCEPTION* = (6).cint
JS_TAG_FLOAT64* = (7).cint ## ```
## any larger tag is FLOAT64 if JS_NAN_BOXING
## ```
JS_PROP_CONFIGURABLE* = (1 shl typeof(1)(0))
JS_PROP_WRITABLE* = (1 shl typeof(1)(1))
JS_PROP_ENUMERABLE* = (1 shl typeof(1)(2))
JS_PROP_C_W_E* = (JS_PROP_CONFIGURABLE or
typeof(JS_PROP_CONFIGURABLE)(JS_PROP_WRITABLE) or
typeof(JS_PROP_CONFIGURABLE)(JS_PROP_ENUMERABLE))
JS_PROP_LENGTH* = (1 shl typeof(1)(3))
JS_PROP_TMASK* = (3 shl typeof(3)(4))
JS_PROP_NORMAL* = (0 shl typeof(0)(4))
JS_PROP_GETSET* = (1 shl typeof(1)(4))
JS_PROP_VARREF* = (2 shl typeof(2)(4))
JS_PROP_AUTOINIT* = (3 shl typeof(3)(4))
JS_PROP_HAS_SHIFT* = 8
JS_PROP_HAS_CONFIGURABLE* = (1 shl typeof(1)(8))
JS_PROP_HAS_WRITABLE* = (1 shl typeof(1)(9))
JS_PROP_HAS_ENUMERABLE* = (1 shl typeof(1)(10))
JS_PROP_HAS_GET* = (1 shl typeof(1)(11))
JS_PROP_HAS_SET* = (1 shl typeof(1)(12))
JS_PROP_HAS_VALUE* = (1 shl typeof(1)(13))
JS_PROP_THROW* = (1 shl typeof(1)(14))
JS_PROP_THROW_STRICT* = (1 shl typeof(1)(15))
JS_PROP_NO_ADD* = (1 shl typeof(1)(16))
JS_PROP_NO_EXOTIC* = (1 shl typeof(1)(17))
JS_DEFAULT_STACK_SIZE* = (256 * typeof(256)(1024))
JS_EVAL_TYPE_GLOBAL* = (0 shl typeof(0)(0))
JS_EVAL_TYPE_MODULE* = (1 shl typeof(1)(0))
JS_EVAL_TYPE_DIRECT* = (2 shl typeof(2)(0))
JS_EVAL_TYPE_INDIRECT* = (3 shl typeof(3)(0))
JS_EVAL_TYPE_MASK* = (3 shl typeof(3)(0))
JS_EVAL_FLAG_STRICT* = (1 shl typeof(1)(3))
JS_EVAL_FLAG_STRIP* = (1 shl typeof(1)(4))
JS_EVAL_FLAG_COMPILE_ONLY* = (1 shl typeof(1)(5))
JS_EVAL_FLAG_BACKTRACE_BARRIER* = (1 shl typeof(1)(6))
JS_CALL_FLAG_CONSTRUCTOR* = (1 shl typeof(1)(0))
JS_GPN_STRING_MASK* = (1 shl typeof(1)(0))
JS_GPN_SYMBOL_MASK* = (1 shl typeof(1)(1))
JS_GPN_PRIVATE_MASK* = (1 shl typeof(1)(2))
JS_GPN_ENUM_ONLY* = (1 shl typeof(1)(4))
JS_GPN_SET_ENUM* = (1 shl typeof(1)(5))
JS_WRITE_OBJ_BYTECODE* = (1 shl typeof(1)(0))
JS_WRITE_OBJ_BSWAP* = (1 shl typeof(1)(1))
JS_READ_OBJ_BYTECODE* = (1 shl typeof(1)(0))
JS_READ_OBJ_ROM_DATA* = (1 shl typeof(1)(1))
JS_CFUNC_generic* = (0).JSCFunctionEnum ## ```
## XXX: should rename for namespace isolation
## ```
JS_CFUNC_generic_magic* = (JS_CFUNC_generic + 1).JSCFunctionEnum
JS_CFUNC_constructor* = (JS_CFUNC_generic_magic + 1).JSCFunctionEnum
JS_CFUNC_constructor_magic* = (JS_CFUNC_constructor + 1).JSCFunctionEnum
JS_CFUNC_constructor_or_func* = (JS_CFUNC_constructor_magic + 1).JSCFunctionEnum
JS_CFUNC_constructor_or_func_magic* = (JS_CFUNC_constructor_or_func + 1).JSCFunctionEnum
JS_CFUNC_f_f* = (JS_CFUNC_constructor_or_func_magic + 1).JSCFunctionEnum
JS_CFUNC_f_f_f* = (JS_CFUNC_f_f + 1).JSCFunctionEnum
JS_CFUNC_getter* = (JS_CFUNC_f_f_f + 1).JSCFunctionEnum
JS_CFUNC_setter* = (JS_CFUNC_getter + 1).JSCFunctionEnum
JS_CFUNC_getter_magic* = (JS_CFUNC_setter + 1).JSCFunctionEnum
JS_CFUNC_setter_magic* = (JS_CFUNC_getter_magic + 1).JSCFunctionEnum
JS_CFUNC_iterator_next* = (JS_CFUNC_setter_magic + 1).JSCFunctionEnum
JS_DEF_CFUNC* = 0
JS_DEF_CGETSET* = 1
JS_DEF_CGETSET_MAGIC* = 2
JS_DEF_PROP_STRING* = 3
JS_DEF_PROP_INT32* = 4
JS_DEF_PROP_INT64* = 5
JS_DEF_PROP_DOUBLE* = 6
JS_DEF_PROP_UNDEFINED* = 7
JS_DEF_OBJECT* = 8
JS_DEF_ALIAS* = 9
type
JSRuntime* {.importc, impquickjsHdr, incompleteStruct.} = object
JSContext* {.importc, impquickjsHdr, incompleteStruct.} = object
JSObject* {.importc, impquickjsHdr, incompleteStruct.} = object
JSClass* {.importc, impquickjsHdr, incompleteStruct.} = object
JSClassID* {.importc, impquickjsHdr.} = uint32
JSAtom* {.importc, impquickjsHdr.} = uint32
JSRefCountHeader* {.bycopy, impquickjsHdr, importc: "struct JSRefCountHeader".} = object
ref_count*: cint
JSValueUnion* {.union, bycopy, impquickjsHdr, importc: "union JSValueUnion".} = object
int32*: int32
float64*: cdouble
`ptr`*: pointer
JSValue* {.bycopy, impquickjsHdr, importc: "struct JSValue".} = object
u*: JSValueUnion
tag*: int64
JSCFunction* {.importc, impquickjsHdr.} = proc (ctx: ptr JSContext; this_val: JSValue;
argc: cint; argv: ptr JSValue): JSValue {.cdecl.}
JSCFunctionMagic* {.importc, impquickjsHdr.} = proc (ctx: ptr JSContext;
this_val: JSValue; argc: cint; argv: ptr JSValue; magic: cint): JSValue {.cdecl.}
JSCFunctionData* {.importc, impquickjsHdr.} = proc (ctx: ptr JSContext;
this_val: JSValue; argc: cint; argv: ptr JSValue; magic: cint;
func_data: ptr JSValue): JSValue {.cdecl.}
JSMallocState* {.bycopy, impquickjsHdr, importc: "struct JSMallocState".} = object
malloc_count*: uint
malloc_size*: uint
malloc_limit*: uint
opaque*: pointer ## ```
## user opaque
## ```
JSMallocFunctions* {.bycopy, impquickjsHdr, importc: "struct JSMallocFunctions".} = object
js_malloc*: proc (s: ptr JSMallocState; size: uint): pointer {.cdecl.}
js_free*: proc (s: ptr JSMallocState; `ptr`: pointer) {.cdecl.}
js_realloc*: proc (s: ptr JSMallocState; `ptr`: pointer; size: uint): pointer {.cdecl.}
js_malloc_usable_size*: proc (`ptr`: pointer): uint {.cdecl.}
JSGCObjectHeader* {.importc, impquickjsHdr, incompleteStruct.} = object
JS_MarkFunc* {.importc, impquickjsHdr.} = proc (rt: ptr JSRuntime;
gp: ptr JSGCObjectHeader) {.cdecl.}
JSMemoryUsage* {.bycopy, impquickjsHdr, importc: "struct JSMemoryUsage".} = object
malloc_size*: int64
malloc_limit*: int64
memory_used_size*: int64
malloc_count*: int64
memory_used_count*: int64
atom_count*: int64
atom_size*: int64
str_count*: int64
str_size*: int64
obj_count*: int64
obj_size*: int64
prop_count*: int64
prop_size*: int64
shape_count*: int64
shape_size*: int64
js_func_count*: int64
js_func_size*: int64
js_func_code_size*: int64
js_func_pc2line_count*: int64
js_func_pc2line_size*: int64
c_func_count*: int64
array_count*: int64
fast_array_count*: int64
fast_array_elements*: int64
binary_object_count*: int64
binary_object_size*: int64
JSPropertyEnum* {.bycopy, impquickjsHdr, importc: "struct JSPropertyEnum".} = object
is_enumerable*: cint
atom*: JSAtom
JSPropertyDescriptor* {.bycopy, impquickjsHdr,
importc: "struct JSPropertyDescriptor".} = object
flags*: cint
value*: JSValue
getter*: JSValue
setter*: JSValue
JSClassExoticMethods* {.bycopy, impquickjsHdr,
importc: "struct JSClassExoticMethods".} = object
get_own_property*: proc (ctx: ptr JSContext; desc: ptr JSPropertyDescriptor;
obj: JSValue; prop: JSAtom): cint {.cdecl.} ## ```
## Return -1 if exception (can only happen in case of Proxy object),
## FALSE if the property does not exists, TRUE if it exists. If 1 is
## returned, the property descriptor 'desc' is filled if != NULL.
## ```
get_own_property_names*: proc (ctx: ptr JSContext; ptab: ptr ptr JSPropertyEnum;
plen: ptr uint32; obj: JSValue): cint {.cdecl.} ## ```
## '*ptab' should hold the '*plen' property keys. Return 0 if OK,
## -1 if exception. The 'is_enumerable' field is ignored.
## ```
delete_property*: proc (ctx: ptr JSContext; obj: JSValue; prop: JSAtom): cint {.cdecl.} ## ```
## return < 0 if exception, or TRUE/FALSE
## ```
define_own_property*: proc (ctx: ptr JSContext; this_obj: JSValue; prop: JSAtom;
val: JSValue; getter: JSValue; setter: JSValue;
flags: cint): cint {.cdecl.} ## ```
## return < 0 if exception or TRUE/FALSE
## ```
has_property*: proc (ctx: ptr JSContext; obj: JSValue; atom: JSAtom): cint {.cdecl.} ## ```
## The following methods can be emulated with the previous ones,
## so they are usually not needed
## return < 0 if exception or TRUE/FALSE
## ```
get_property*: proc (ctx: ptr JSContext; obj: JSValue; atom: JSAtom;
receiver: JSValue): JSValue {.cdecl.}
set_property*: proc (ctx: ptr JSContext; obj: JSValue; atom: JSAtom; value: JSValue;
receiver: JSValue; flags: cint): cint {.cdecl.} ## ```
## return < 0 if exception or TRUE/FALSE
## ```
JSClassFinalizer* {.importc, impquickjsHdr.} = proc (rt: ptr JSRuntime; val: JSValue) {.
cdecl.}
JSClassGCMark* {.importc, impquickjsHdr.} = proc (rt: ptr JSRuntime; val: JSValue;
mark_func: ptr JS_MarkFunc) {.cdecl.}
JSClassCall* {.importc, impquickjsHdr.} = proc (ctx: ptr JSContext; func_obj: JSValue;
this_val: JSValue; argc: cint; argv: ptr JSValue; flags: cint): JSValue {.cdecl.}
JSClassDef* {.bycopy, impquickjsHdr, importc: "struct JSClassDef".} = object
class_name*: cstring
finalizer*: ptr JSClassFinalizer
gc_mark*: ptr JSClassGCMark ## ```
## if call != NULL, the object is a function. If (flags &
## JS_CALL_FLAG_CONSTRUCTOR) != 0, the function is called as a
## constructor. In this case, 'this_val' is new.target. A
## constructor call only happens if the object constructor bit is
## set (see JS_SetConstructorBit()).
## ```
call*: ptr JSClassCall ## ```
## if call != NULL, the object is a function. If (flags &
## JS_CALL_FLAG_CONSTRUCTOR) != 0, the function is called as a
## constructor. In this case, 'this_val' is new.target. A
## constructor call only happens if the object constructor bit is
## set (see JS_SetConstructorBit()).
## ```
exotic*: ptr JSClassExoticMethods ## ```
## XXX: suppress this indirection ? It is here only to save memory
## because only a few classes need these methods
## ```
JSFreeArrayBufferDataFunc* {.importc, impquickjsHdr.} = proc (rt: ptr JSRuntime;
opaque: pointer; `ptr`: pointer) {.cdecl.}
JSHostPromiseRejectionTracker* {.importc, impquickjsHdr.} = proc (
ctx: ptr JSContext; promise: JSValue; reason: JSValue; is_handled: cint;
opaque: pointer) {.cdecl.}
JSInterruptHandler* {.importc, impquickjsHdr.} = proc (rt: ptr JSRuntime;
opaque: pointer): cint {.cdecl.}
JSModuleDef* {.importc, impquickjsHdr, incompleteStruct.} = object
JSModuleNormalizeFunc* {.importc, impquickjsHdr.} = proc (ctx: ptr JSContext;
module_base_name: cstring; module_name: cstring; opaque: pointer): cstring {.
cdecl.}
JSModuleLoaderFunc* {.importc, impquickjsHdr.} = proc (ctx: ptr JSContext;
module_name: cstring; opaque: pointer): ptr JSModuleDef {.cdecl.}
JSJobFunc* {.importc, impquickjsHdr.} = proc (ctx: ptr JSContext; argc: cint;
argv: ptr JSValue): JSValue {.cdecl.}
JSCFunctionType* {.union, bycopy, impquickjsHdr, importc: "union JSCFunctionType".} = object
generic*: ptr JSCFunction
generic_magic*: proc (ctx: ptr JSContext; this_val: JSValue; argc: cint;
argv: ptr JSValue; magic: cint): JSValue {.cdecl.}
constructor*: ptr JSCFunction
constructor_magic*: proc (ctx: ptr JSContext; new_target: JSValue; argc: cint;
argv: ptr JSValue; magic: cint): JSValue {.cdecl.}
constructor_or_func*: ptr JSCFunction
f_f*: proc (a1: cdouble): cdouble {.cdecl.}
f_f_f*: proc (a1: cdouble; a2: cdouble): cdouble {.cdecl.}
getter*: proc (ctx: ptr JSContext; this_val: JSValue): JSValue {.cdecl.}
setter*: proc (ctx: ptr JSContext; this_val: JSValue; val: JSValue): JSValue {.cdecl.}
getter_magic*: proc (ctx: ptr JSContext; this_val: JSValue; magic: cint): JSValue {.
cdecl.}
setter_magic*: proc (ctx: ptr JSContext; this_val: JSValue; val: JSValue; magic: cint): JSValue {.
cdecl.}
iterator_next*: proc (ctx: ptr JSContext; this_val: JSValue; argc: cint;
argv: ptr JSValue; pdone: ptr cint; magic: cint): JSValue {.cdecl.}
Type_quickjsh1* {.bycopy, impquickjsHdr, importc: "struct Type_quickjsh1".} = object
length*: uint8 ## ```
## XXX: should move outside union
## ```
cproto*: uint8 ## ```
## XXX: should move outside union
## ```
cfunc*: JSCFunctionType ## ```
## XXX: should move outside union
## ```
Type_quickjsh2* {.bycopy, impquickjsHdr, importc: "struct Type_quickjsh2".} = object
get*: JSCFunctionType
set*: JSCFunctionType
Type_quickjsh3* {.bycopy, impquickjsHdr, importc: "struct Type_quickjsh3".} = object
name*: cstring
base*: cint
Type_quickjsh4* {.bycopy, impquickjsHdr, importc: "struct Type_quickjsh4".} = object
tab*: ptr JSCFunctionListEntry
len*: cint
Union_quickjsh1* {.union, bycopy, impquickjsHdr, importc: "union Union_quickjsh1".} = object
`func`*: Type_quickjsh1
getset*: Type_quickjsh2
alias*: Type_quickjsh3
prop_list*: Type_quickjsh4
str*: cstring
i32*: int32
i64*: int64
f64*: cdouble
JSCFunctionListEntry* {.bycopy, impquickjsHdr,
importc: "struct JSCFunctionListEntry".} = object
name*: cstring
prop_flags*: uint8
def_type*: uint8
magic*: int16
u*: Union_quickjsh1
JSModuleInitFunc* {.importc, impquickjsHdr.} = proc (ctx: ptr JSContext;
m: ptr JSModuleDef): cint {.cdecl.}
proc JS_NewFloat64*(ctx: ptr JSContext; d: cdouble): JSValue {.
importc: "__JS_NewFloat64", cdecl, impquickjsHdr.}
proc JS_VALUE_IS_NAN*(v: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_NewRuntime*(): ptr JSRuntime {.importc, cdecl, impquickjsHdr.}
## ```
## info lifetime must exceed that of rt
## ```
proc JS_SetRuntimeInfo*(rt: ptr JSRuntime; info: cstring) {.importc, cdecl,
impquickjsHdr.}
## ```
## info lifetime must exceed that of rt
## ```
proc JS_SetMemoryLimit*(rt: ptr JSRuntime; limit: uint) {.importc, cdecl, impquickjsHdr.}
proc JS_SetGCThreshold*(rt: ptr JSRuntime; gc_threshold: uint) {.importc, cdecl,
impquickjsHdr.}
proc JS_SetMaxStackSize*(rt: ptr JSRuntime; stack_size: uint) {.importc, cdecl,
impquickjsHdr.}
proc JS_NewRuntime2*(mf: ptr JSMallocFunctions; opaque: pointer): ptr JSRuntime {.
importc, cdecl, impquickjsHdr.}
proc JS_FreeRuntime*(rt: ptr JSRuntime) {.importc, cdecl, impquickjsHdr.}
proc JS_GetRuntimeOpaque*(rt: ptr JSRuntime): pointer {.importc, cdecl, impquickjsHdr.}
proc JS_SetRuntimeOpaque*(rt: ptr JSRuntime; opaque: pointer) {.importc, cdecl,
impquickjsHdr.}
proc JS_MarkValue*(rt: ptr JSRuntime; val: JSValue; mark_func: ptr JS_MarkFunc) {.
importc, cdecl, impquickjsHdr.}
proc JS_RunGC*(rt: ptr JSRuntime) {.importc, cdecl, impquickjsHdr.}
proc JS_IsLiveObject*(rt: ptr JSRuntime; obj: JSValue): cint {.importc, cdecl,
impquickjsHdr.}
proc JS_NewContext*(rt: ptr JSRuntime): ptr JSContext {.importc, cdecl, impquickjsHdr.}
proc JS_FreeContext*(s: ptr JSContext) {.importc, cdecl, impquickjsHdr.}
proc JS_DupContext*(ctx: ptr JSContext): ptr JSContext {.importc, cdecl, impquickjsHdr.}
proc JS_GetContextOpaque*(ctx: ptr JSContext): pointer {.importc, cdecl, impquickjsHdr.}
proc JS_SetContextOpaque*(ctx: ptr JSContext; opaque: pointer) {.importc, cdecl,
impquickjsHdr.}
proc JS_GetRuntime*(ctx: ptr JSContext): ptr JSRuntime {.importc, cdecl, impquickjsHdr.}
proc JS_SetClassProto*(ctx: ptr JSContext; class_id: JSClassID; obj: JSValue) {.importc,
cdecl, impquickjsHdr.}
proc JS_GetClassProto*(ctx: ptr JSContext; class_id: JSClassID): JSValue {.importc,
cdecl, impquickjsHdr.}
proc JS_NewContextRaw*(rt: ptr JSRuntime): ptr JSContext {.importc, cdecl, impquickjsHdr.}
## ```
## the following functions are used to select the intrinsic object to
## save memory
## ```
proc JS_AddIntrinsicBaseObjects*(ctx: ptr JSContext) {.importc, cdecl, impquickjsHdr.}
proc JS_AddIntrinsicDate*(ctx: ptr JSContext) {.importc, cdecl, impquickjsHdr.}
proc JS_AddIntrinsicEval*(ctx: ptr JSContext) {.importc, cdecl, impquickjsHdr.}
proc JS_AddIntrinsicStringNormalize*(ctx: ptr JSContext) {.importc, cdecl,
impquickjsHdr.}
proc JS_AddIntrinsicRegExpCompiler*(ctx: ptr JSContext) {.importc, cdecl,
impquickjsHdr.}
proc JS_AddIntrinsicRegExp*(ctx: ptr JSContext) {.importc, cdecl, impquickjsHdr.}
proc JS_AddIntrinsicJSON*(ctx: ptr JSContext) {.importc, cdecl, impquickjsHdr.}
proc JS_AddIntrinsicProxy*(ctx: ptr JSContext) {.importc, cdecl, impquickjsHdr.}
proc JS_AddIntrinsicMapSet*(ctx: ptr JSContext) {.importc, cdecl, impquickjsHdr.}
proc JS_AddIntrinsicTypedArrays*(ctx: ptr JSContext) {.importc, cdecl, impquickjsHdr.}
proc JS_AddIntrinsicPromise*(ctx: ptr JSContext) {.importc, cdecl, impquickjsHdr.}
proc JS_AddIntrinsicBigInt*(ctx: ptr JSContext) {.importc, cdecl, impquickjsHdr.}
proc JS_AddIntrinsicBigFloat*(ctx: ptr JSContext) {.importc, cdecl, impquickjsHdr.}
proc JS_AddIntrinsicBigDecimal*(ctx: ptr JSContext) {.importc, cdecl, impquickjsHdr.}
## ```
## enable operator overloading
## ```
proc JS_AddIntrinsicOperators*(ctx: ptr JSContext) {.importc, cdecl, impquickjsHdr.}
## ```
## enable operator overloading
## ```
proc JS_EnableBignumExt*(ctx: ptr JSContext; enable: cint) {.importc, cdecl,
impquickjsHdr.}
## ```
## enable "use math"
## ```
proc js_string_codePointRange*(ctx: ptr JSContext; this_val: JSValue; argc: cint;
argv: ptr JSValue): JSValue {.importc, cdecl,
impquickjsHdr.}
proc js_malloc_rt*(rt: ptr JSRuntime; size: uint): pointer {.importc, cdecl,
impquickjsHdr.}
proc js_free_rt*(rt: ptr JSRuntime; `ptr`: pointer) {.importc, cdecl, impquickjsHdr.}
proc js_realloc_rt*(rt: ptr JSRuntime; `ptr`: pointer; size: uint): pointer {.importc,
cdecl, impquickjsHdr.}
proc js_malloc_usable_size_rt*(rt: ptr JSRuntime; `ptr`: pointer): uint {.importc,
cdecl, impquickjsHdr.}
proc js_mallocz_rt*(rt: ptr JSRuntime; size: uint): pointer {.importc, cdecl,
impquickjsHdr.}
proc js_malloc*(ctx: ptr JSContext; size: uint): pointer {.importc, cdecl, impquickjsHdr.}
proc js_free*(ctx: ptr JSContext; `ptr`: pointer) {.importc, cdecl, impquickjsHdr.}
proc js_realloc*(ctx: ptr JSContext; `ptr`: pointer; size: uint): pointer {.importc,
cdecl, impquickjsHdr.}
proc js_malloc_usable_size*(ctx: ptr JSContext; `ptr`: pointer): uint {.importc, cdecl,
impquickjsHdr.}
proc js_realloc2*(ctx: ptr JSContext; `ptr`: pointer; size: uint; pslack: ptr uint): pointer {.
importc, cdecl, impquickjsHdr.}
proc js_mallocz*(ctx: ptr JSContext; size: uint): pointer {.importc, cdecl, impquickjsHdr.}
proc js_strdup*(ctx: ptr JSContext; str: cstring): cstring {.importc, cdecl,
impquickjsHdr.}
proc js_strndup*(ctx: ptr JSContext; s: cstring; n: uint): cstring {.importc, cdecl,
impquickjsHdr.}
proc JS_ComputeMemoryUsage*(rt: ptr JSRuntime; s: ptr JSMemoryUsage) {.importc, cdecl,
impquickjsHdr.}
proc JS_DumpMemoryUsage*(fp: File; s: ptr JSMemoryUsage; rt: ptr JSRuntime) {.importc,
cdecl, impquickjsHdr.}
proc JS_NewAtomLen*(ctx: ptr JSContext; str: cstring; len: uint): JSAtom {.importc, cdecl,
impquickjsHdr.}
## ```
## atom support
## ```
proc JS_NewAtom*(ctx: ptr JSContext; str: cstring): JSAtom {.importc, cdecl,
impquickjsHdr.}
proc JS_NewAtomUInt32*(ctx: ptr JSContext; n: uint32): JSAtom {.importc, cdecl,
impquickjsHdr.}
proc JS_DupAtom*(ctx: ptr JSContext; v: JSAtom): JSAtom {.importc, cdecl, impquickjsHdr.}
proc JS_FreeAtom*(ctx: ptr JSContext; v: JSAtom) {.importc, cdecl, impquickjsHdr.}
proc JS_FreeAtomRT*(rt: ptr JSRuntime; v: JSAtom) {.importc, cdecl, impquickjsHdr.}
proc JS_AtomToValue*(ctx: ptr JSContext; atom: JSAtom): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_AtomToString*(ctx: ptr JSContext; atom: JSAtom): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_AtomToCString*(ctx: ptr JSContext; atom: JSAtom): cstring {.importc, cdecl,
impquickjsHdr.}
proc JS_ValueToAtom*(ctx: ptr JSContext; val: JSValue): JSAtom {.importc, cdecl,
impquickjsHdr.}
proc JS_NewClassID*(pclass_id: ptr JSClassID): JSClassID {.importc, cdecl,
impquickjsHdr.}
proc JS_NewClass*(rt: ptr JSRuntime; class_id: JSClassID; class_def: ptr JSClassDef): cint {.
importc, cdecl, impquickjsHdr.}
proc JS_IsRegisteredClass*(rt: ptr JSRuntime; class_id: JSClassID): cint {.importc,
cdecl, impquickjsHdr.}
proc JS_NewBool*(ctx: ptr JSContext; val: cint): JSValue {.importc, cdecl, impquickjsHdr.}
proc JS_NewInt32*(ctx: ptr JSContext; val: int32): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_NewCatchOffset*(ctx: ptr JSContext; val: int32): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_NewInt64*(ctx: ptr JSContext; val: int64): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_NewUint32*(ctx: ptr JSContext; val: uint32): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_NewBigInt64*(ctx: ptr JSContext; v: int64): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_NewBigUint64*(ctx: ptr JSContext; v: uint64): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_IsNumber*(v: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_IsBigInt*(ctx: ptr JSContext; v: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_IsBigFloat*(v: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_IsBigDecimal*(v: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_IsBool*(v: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_IsNull*(v: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_IsUndefined*(v: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_IsException*(v: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_IsUninitialized*(v: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_IsString*(v: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_IsSymbol*(v: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_IsObject*(v: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_Throw*(ctx: ptr JSContext; obj: JSValue): JSValue {.importc, cdecl, impquickjsHdr.}
proc JS_GetException*(ctx: ptr JSContext): JSValue {.importc, cdecl, impquickjsHdr.}
proc JS_IsError*(ctx: ptr JSContext; val: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_ResetUncatchableError*(ctx: ptr JSContext) {.importc, cdecl, impquickjsHdr.}
proc JS_NewError*(ctx: ptr JSContext): JSValue {.importc, cdecl, impquickjsHdr.}
proc JS_ThrowSyntaxError*(ctx: ptr JSContext; fmt: cstring): JSValue {.importc, cdecl,
impquickjsHdr, varargs.}
proc JS_ThrowTypeError*(ctx: ptr JSContext; fmt: cstring): JSValue {.importc, cdecl,
impquickjsHdr, varargs.}
proc JS_ThrowReferenceError*(ctx: ptr JSContext; fmt: cstring): JSValue {.importc,
cdecl, impquickjsHdr, varargs.}
proc JS_ThrowRangeError*(ctx: ptr JSContext; fmt: cstring): JSValue {.importc, cdecl,
impquickjsHdr, varargs.}
proc JS_ThrowInternalError*(ctx: ptr JSContext; fmt: cstring): JSValue {.importc, cdecl,
impquickjsHdr, varargs.}
proc JS_ThrowOutOfMemory*(ctx: ptr JSContext): JSValue {.importc, cdecl, impquickjsHdr.}
proc JS_FreeValue*(ctx: ptr JSContext; v: JSValue) {.importc: "__JS_FreeValue", cdecl,
impquickjsHdr.}
proc JS_FreeValueRT*(rt: ptr JSRuntime; v: JSValue) {.importc: "__JS_FreeValueRT",
cdecl, impquickjsHdr.}
proc JS_DupValue*(ctx: ptr JSContext; v: JSValue): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_DupValueRT*(rt: ptr JSRuntime; v: JSValue): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_ToBool*(ctx: ptr JSContext; val: JSValue): cint {.importc, cdecl, impquickjsHdr.}
## ```
## return -1 for JS_EXCEPTION
## ```
proc JS_ToInt32*(ctx: ptr JSContext; pres: ptr int32; val: JSValue): cint {.importc, cdecl,
impquickjsHdr.}
## ```
## return -1 for JS_EXCEPTION
## ```
proc JS_ToUint32*(ctx: ptr JSContext; pres: ptr uint32; val: JSValue): cint {.importc,
cdecl, impquickjsHdr.}
proc JS_ToInt64*(ctx: ptr JSContext; pres: ptr int64; val: JSValue): cint {.importc, cdecl,
impquickjsHdr.}
proc JS_ToIndex*(ctx: ptr JSContext; plen: ptr uint64; val: JSValue): cint {.importc,
cdecl, impquickjsHdr.}
proc JS_ToFloat64*(ctx: ptr JSContext; pres: ptr cdouble; val: JSValue): cint {.importc,
cdecl, impquickjsHdr.}
## ```
## return an exception if 'val' is a Number
## ```
proc JS_ToBigInt64*(ctx: ptr JSContext; pres: ptr int64; val: JSValue): cint {.importc,
cdecl, impquickjsHdr.}
## ```
## return an exception if 'val' is a Number
## ```
proc JS_ToInt64Ext*(ctx: ptr JSContext; pres: ptr int64; val: JSValue): cint {.importc,
cdecl, impquickjsHdr.}
## ```
## same as JS_ToInt64() but allow BigInt
## ```
proc JS_NewStringLen*(ctx: ptr JSContext; str1: cstring; len1: uint): JSValue {.importc,
cdecl, impquickjsHdr.}
proc JS_NewString*(ctx: ptr JSContext; str: cstring): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_NewAtomString*(ctx: ptr JSContext; str: cstring): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_ToString*(ctx: ptr JSContext; val: JSValue): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_ToPropertyKey*(ctx: ptr JSContext; val: JSValue): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_ToCStringLen2*(ctx: ptr JSContext; plen: ptr uint; val1: JSValue; cesu8: cint): cstring {.
importc, cdecl, impquickjsHdr.}
proc JS_ToCStringLen*(ctx: ptr JSContext; plen: ptr uint; val1: JSValue): cstring {.
importc, cdecl, impquickjsHdr.}
proc JS_ToCString*(ctx: ptr JSContext; val1: JSValue): cstring {.importc, cdecl,
impquickjsHdr.}
proc JS_FreeCString*(ctx: ptr JSContext; `ptr`: cstring) {.importc, cdecl, impquickjsHdr.}
proc JS_NewObjectProtoClass*(ctx: ptr JSContext; proto: JSValue; class_id: JSClassID): JSValue {.
importc, cdecl, impquickjsHdr.}
proc JS_NewObjectClass*(ctx: ptr JSContext; class_id: cint): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_NewObjectProto*(ctx: ptr JSContext; proto: JSValue): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_NewObject*(ctx: ptr JSContext): JSValue {.importc, cdecl, impquickjsHdr.}
proc JS_IsFunction*(ctx: ptr JSContext; val: JSValue): cint {.importc, cdecl,
impquickjsHdr.}
proc JS_IsConstructor*(ctx: ptr JSContext; val: JSValue): cint {.importc, cdecl,
impquickjsHdr.}
proc JS_SetConstructorBit*(ctx: ptr JSContext; func_obj: JSValue; val: cint): cint {.
importc, cdecl, impquickjsHdr.}
proc JS_NewArray*(ctx: ptr JSContext): JSValue {.importc, cdecl, impquickjsHdr.}
proc JS_IsArray*(ctx: ptr JSContext; val: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_GetPropertyInternal*(ctx: ptr JSContext; obj: JSValue; prop: JSAtom;
receiver: JSValue; throw_ref_error: cint): JSValue {.
importc, cdecl, impquickjsHdr.}
proc JS_GetProperty*(ctx: ptr JSContext; this_obj: JSValue; prop: JSAtom): JSValue {.
importc, cdecl, impquickjsHdr.}
proc JS_GetPropertyStr*(ctx: ptr JSContext; this_obj: JSValue; prop: cstring): JSValue {.
importc, cdecl, impquickjsHdr.}
proc JS_GetPropertyUint32*(ctx: ptr JSContext; this_obj: JSValue; idx: uint32): JSValue {.
importc, cdecl, impquickjsHdr.}
proc JS_SetPropertyInternal*(ctx: ptr JSContext; this_obj: JSValue; prop: JSAtom;
val: JSValue; flags: cint): cint {.importc, cdecl,
impquickjsHdr.}
proc JS_SetProperty*(ctx: ptr JSContext; this_obj: JSValue; prop: JSAtom; val: JSValue): cint {.
importc, cdecl, impquickjsHdr.}
proc JS_SetPropertyUint32*(ctx: ptr JSContext; this_obj: JSValue; idx: uint32;
val: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_SetPropertyInt64*(ctx: ptr JSContext; this_obj: JSValue; idx: int64;
val: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_SetPropertyStr*(ctx: ptr JSContext; this_obj: JSValue; prop: cstring;
val: JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_HasProperty*(ctx: ptr JSContext; this_obj: JSValue; prop: JSAtom): cint {.
importc, cdecl, impquickjsHdr.}
proc JS_IsExtensible*(ctx: ptr JSContext; obj: JSValue): cint {.importc, cdecl,
impquickjsHdr.}
proc JS_PreventExtensions*(ctx: ptr JSContext; obj: JSValue): cint {.importc, cdecl,
impquickjsHdr.}
proc JS_DeleteProperty*(ctx: ptr JSContext; obj: JSValue; prop: JSAtom; flags: cint): cint {.
importc, cdecl, impquickjsHdr.}
proc JS_SetPrototype*(ctx: ptr JSContext; obj: JSValue; proto_val: JSValue): cint {.
importc, cdecl, impquickjsHdr.}
proc JS_GetPrototype*(ctx: ptr JSContext; val: JSValue): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_GetOwnPropertyNames*(ctx: ptr JSContext; ptab: ptr ptr JSPropertyEnum;
plen: ptr uint32; obj: JSValue; flags: cint): cint {.
importc, cdecl, impquickjsHdr.}
proc JS_GetOwnProperty*(ctx: ptr JSContext; desc: ptr JSPropertyDescriptor;
obj: JSValue; prop: JSAtom): cint {.importc, cdecl,
impquickjsHdr.}
proc JS_Call*(ctx: ptr JSContext; func_obj: JSValue; this_obj: JSValue; argc: cint;
argv: ptr JSValue): JSValue {.importc, cdecl, impquickjsHdr.}
proc JS_Invoke*(ctx: ptr JSContext; this_val: JSValue; atom: JSAtom; argc: cint;
argv: ptr JSValue): JSValue {.importc, cdecl, impquickjsHdr.}
proc JS_CallConstructor*(ctx: ptr JSContext; func_obj: JSValue; argc: cint;
argv: ptr JSValue): JSValue {.importc, cdecl, impquickjsHdr.}
proc JS_CallConstructor2*(ctx: ptr JSContext; func_obj: JSValue; new_target: JSValue;
argc: cint; argv: ptr JSValue): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_DetectModule*(input: cstring; input_len: uint): cint {.importc, cdecl,
impquickjsHdr.}
## ```
## 'input' must be zero terminated i.e. input[input_len] = '\0'.
## ```
proc JS_Eval*(ctx: ptr JSContext; input: cstring; input_len: uint; filename: cstring;
eval_flags: cint): JSValue {.importc, cdecl, impquickjsHdr.}
## ```
## 'input' must be zero terminated i.e. input[input_len] = '\0'.
## ```
proc JS_EvalFunction*(ctx: ptr JSContext; fun_obj: JSValue): JSValue {.importc, cdecl,
impquickjsHdr.}
proc JS_GetGlobalObject*(ctx: ptr JSContext): JSValue {.importc, cdecl, impquickjsHdr.}
proc JS_IsInstanceOf*(ctx: ptr JSContext; val: JSValue; obj: JSValue): cint {.importc,
cdecl, impquickjsHdr.}
proc JS_DefineProperty*(ctx: ptr JSContext; this_obj: JSValue; prop: JSAtom;
val: JSValue; getter: JSValue; setter: JSValue; flags: cint): cint {.
importc, cdecl, impquickjsHdr.}
proc JS_DefinePropertyValue*(ctx: ptr JSContext; this_obj: JSValue; prop: JSAtom;
val: JSValue; flags: cint): cint {.importc, cdecl,
impquickjsHdr.}
proc JS_DefinePropertyValueUint32*(ctx: ptr JSContext; this_obj: JSValue; idx: uint32;
val: JSValue; flags: cint): cint {.importc, cdecl,
impquickjsHdr.}
proc JS_DefinePropertyValueStr*(ctx: ptr JSContext; this_obj: JSValue; prop: cstring;
val: JSValue; flags: cint): cint {.importc, cdecl,
impquickjsHdr.}
proc JS_DefinePropertyGetSet*(ctx: ptr JSContext; this_obj: JSValue; prop: JSAtom;
getter: JSValue; setter: JSValue; flags: cint): cint {.
importc, cdecl, impquickjsHdr.}
proc JS_SetOpaque*(obj: JSValue; opaque: pointer) {.importc, cdecl, impquickjsHdr.}
proc JS_GetOpaque*(obj: JSValue; class_id: JSClassID): pointer {.importc, cdecl,
impquickjsHdr.}
proc JS_GetOpaque2*(ctx: ptr JSContext; obj: JSValue; class_id: JSClassID): pointer {.
importc, cdecl, impquickjsHdr.}
proc JS_ParseJSON*(ctx: ptr JSContext; buf: cstring; buf_len: uint; filename: cstring): JSValue {.
importc, cdecl, impquickjsHdr.}
## ```
## 'buf' must be zero terminated i.e. buf[buf_len] = '\0'.
## ```
proc JS_JSONStringify*(ctx: ptr JSContext; obj: JSValue; replacer: JSValue;
space0: JSValue): JSValue {.importc, cdecl, impquickjsHdr.}
proc JS_NewArrayBuffer*(ctx: ptr JSContext; buf: ptr uint8; len: uint;
free_func: ptr JSFreeArrayBufferDataFunc; opaque: pointer;
is_shared: cint): JSValue {.importc, cdecl, impquickjsHdr.}
proc JS_NewArrayBufferCopy*(ctx: ptr JSContext; buf: ptr uint8; len: uint): JSValue {.
importc, cdecl, impquickjsHdr.}
proc JS_DetachArrayBuffer*(ctx: ptr JSContext; obj: JSValue) {.importc, cdecl,
impquickjsHdr.}
proc JS_GetArrayBuffer*(ctx: ptr JSContext; psize: ptr uint; obj: JSValue): ptr uint8 {.
importc, cdecl, impquickjsHdr.}
proc JS_GetTypedArrayBuffer*(ctx: ptr JSContext; obj: JSValue; pbyte_offset: ptr uint;
pbyte_length: ptr uint; pbytes_per_element: ptr uint): JSValue {.
importc, cdecl, impquickjsHdr.}
proc JS_NewPromiseCapability*(ctx: ptr JSContext; resolving_funcs: ptr JSValue): JSValue {.
importc, cdecl, impquickjsHdr.}
proc JS_SetHostPromiseRejectionTracker*(rt: ptr JSRuntime;
cb: ptr JSHostPromiseRejectionTracker;
opaque: pointer) {.importc, cdecl,
impquickjsHdr.}
proc JS_SetInterruptHandler*(rt: ptr JSRuntime; cb: ptr JSInterruptHandler;
opaque: pointer) {.importc, cdecl, impquickjsHdr.}
## ```
## if can_block is TRUE, Atomics.wait() can be used
## ```
proc JS_SetCanBlock*(rt: ptr JSRuntime; can_block: cint) {.importc, cdecl, impquickjsHdr.}
## ```
## if can_block is TRUE, Atomics.wait() can be used
## ```
proc JS_SetModuleLoaderFunc*(rt: ptr JSRuntime;
module_normalize: ptr JSModuleNormalizeFunc;
module_loader: ptr JSModuleLoaderFunc; opaque: pointer) {.
importc, cdecl, impquickjsHdr.}
## ```
## module_normalize = NULL is allowed and invokes the default module
## filename normalizer
## ```
proc JS_GetImportMeta*(ctx: ptr JSContext; m: ptr JSModuleDef): JSValue {.importc, cdecl,
impquickjsHdr.}
## ```
## return the import.meta object of a module
## ```
proc JS_GetModuleName*(ctx: ptr JSContext; m: ptr JSModuleDef): JSAtom {.importc, cdecl,
impquickjsHdr.}
proc JS_EnqueueJob*(ctx: ptr JSContext; job_func: ptr JSJobFunc; argc: cint;
argv: ptr JSValue): cint {.importc, cdecl, impquickjsHdr.}
proc JS_IsJobPending*(rt: ptr JSRuntime): cint {.importc, cdecl, impquickjsHdr.}
proc JS_ExecutePendingJob*(rt: ptr JSRuntime; pctx: ptr ptr JSContext): cint {.importc,
cdecl, impquickjsHdr.}
proc JS_WriteObject*(ctx: ptr JSContext; psize: ptr uint; obj: JSValue; flags: cint): ptr uint8 {.
importc, cdecl, impquickjsHdr.}
proc JS_ReadObject*(ctx: ptr JSContext; buf: ptr uint8; buf_len: uint; flags: cint): JSValue {.
importc, cdecl, impquickjsHdr.}
proc JS_ResolveModule*(ctx: ptr JSContext; obj: JSValue): cint {.importc, cdecl,
impquickjsHdr.}
## ```
## load the dependencies of the module 'obj'. Useful when JS_ReadObject()
## returns a module.
## ```
proc JS_NewCFunction2*(ctx: ptr JSContext; `func`: ptr JSCFunction; name: cstring;
length: cint; cproto: JSCFunctionEnum; magic: cint): JSValue {.
importc, cdecl, impquickjsHdr.}
proc JS_NewCFunctionData*(ctx: ptr JSContext; `func`: ptr JSCFunctionData;
length: cint; magic: cint; data_len: cint; data: ptr JSValue): JSValue {.
importc, cdecl, impquickjsHdr.}
proc JS_NewCFunction*(ctx: ptr JSContext; `func`: ptr JSCFunction; name: cstring;
length: cint): JSValue {.importc, cdecl, impquickjsHdr.}
proc JS_NewCFunctionMagic*(ctx: ptr JSContext; `func`: ptr JSCFunctionMagic;
name: cstring; length: cint; cproto: JSCFunctionEnum;
magic: cint): JSValue {.importc, cdecl, impquickjsHdr.}
proc JS_SetConstructor*(ctx: ptr JSContext; func_obj: JSValue; proto: JSValue) {.
importc, cdecl, impquickjsHdr.}
proc JS_SetPropertyFunctionList*(ctx: ptr JSContext; obj: JSValue;
tab: ptr JSCFunctionListEntry; len: cint) {.importc,
cdecl, impquickjsHdr.}
proc JS_NewCModule*(ctx: ptr JSContext; name_str: cstring;
`func`: ptr JSModuleInitFunc): ptr JSModuleDef {.importc, cdecl,
impquickjsHdr.}
proc JS_AddModuleExport*(ctx: ptr JSContext; m: ptr JSModuleDef; name_str: cstring): cint {.
importc, cdecl, impquickjsHdr.}
## ```
## can only be called before the module is instantiated
## ```
proc JS_AddModuleExportList*(ctx: ptr JSContext; m: ptr JSModuleDef;
tab: ptr JSCFunctionListEntry; len: cint): cint {.importc,
cdecl, impquickjsHdr.}
proc JS_SetModuleExport*(ctx: ptr JSContext; m: ptr JSModuleDef; export_name: cstring;
val: JSValue): cint {.importc, cdecl, impquickjsHdr.}
## ```
## can only be called after the module is instantiated
## ```
proc JS_SetModuleExportList*(ctx: ptr JSContext; m: ptr JSModuleDef;
tab: ptr JSCFunctionListEntry; len: cint): cint {.importc,
cdecl, impquickjsHdr.}
{.pop.}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment