1 /*
2  * QuickJS Javascript Engine
3  *
4  * Copyright (c) 2017-2020 Fabrice Bellard
5  * Copyright (c) 2017-2020 Charlie Gordon
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a copy
8  * of this software and associated documentation files (the "Software"), to deal
9  * in the Software without restriction, including without limitation the rights
10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11  * copies of the Software, and to permit persons to whom the Software is
12  * furnished to do so, subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included in
15  * all copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23  * THE SOFTWARE.
24  */
25 #ifndef QUICKJS_H
26 #define QUICKJS_H
27 
28 #include <stdio.h>
29 #include <stdint.h>
30 
31 #ifdef __cplusplus
32 extern "C" {
33 #endif
34 
35 #if defined(__GNUC__) || defined(__clang__)
36 #define js_likely(x)          __builtin_expect(!!(x), 1)
37 #define js_unlikely(x)        __builtin_expect(!!(x), 0)
38 #define js_force_inline       inline __attribute__((always_inline))
39 #define __js_printf_like(f, a)   __attribute__((format(printf, f, a)))
40 #else
41 #define js_likely(x)     (x)
42 #define js_unlikely(x)   (x)
43 #define js_force_inline  inline
44 #define __js_printf_like(a, b)
45 #endif
46 
47 #define JS_BOOL int
48 
49 typedef struct JSRuntime JSRuntime;
50 typedef struct JSContext JSContext;
51 typedef struct JSObject JSObject;
52 typedef struct JSClass JSClass;
53 typedef uint32_t JSClassID;
54 typedef uint32_t JSAtom;
55 
56 #if INTPTR_MAX >= INT64_MAX
57 #define JS_PTR64
58 #define JS_PTR64_DEF(a) a
59 #else
60 #define JS_PTR64_DEF(a)
61 #endif
62 
63 #ifndef JS_PTR64
64 #define JS_NAN_BOXING
65 #endif
66 
67 enum {
68     /* all tags with a reference count are negative */
69     JS_TAG_FIRST       = -11, /* first negative tag */
70     JS_TAG_BIG_DECIMAL = -11,
71     JS_TAG_BIG_INT     = -10,
72     JS_TAG_BIG_FLOAT   = -9,
73     JS_TAG_SYMBOL      = -8,
74     JS_TAG_STRING      = -7,
75     JS_TAG_MODULE      = -3, /* used internally */
76     JS_TAG_FUNCTION_BYTECODE = -2, /* used internally */
77     JS_TAG_OBJECT      = -1,
78 
79     JS_TAG_INT         = 0,
80     JS_TAG_BOOL        = 1,
81     JS_TAG_NULL        = 2,
82     JS_TAG_UNDEFINED   = 3,
83     JS_TAG_UNINITIALIZED = 4,
84     JS_TAG_CATCH_OFFSET = 5,
85     JS_TAG_EXCEPTION   = 6,
86     JS_TAG_FLOAT64     = 7,
87     /* any larger tag is FLOAT64 if JS_NAN_BOXING */
88 };
89 
90 typedef struct JSRefCountHeader {
91     int ref_count;
92 } JSRefCountHeader;
93 
94 #define JS_FLOAT64_NAN NAN
95 
96 #ifdef CONFIG_CHECK_JSVALUE
97 /* JSValue consistency : it is not possible to run the code in this
98    mode, but it is useful to detect simple reference counting
99    errors. It would be interesting to modify a static C analyzer to
100    handle specific annotations (clang has such annotations but only
101    for objective C) */
102 typedef struct __JSValue *JSValue;
103 typedef const struct __JSValue *JSValueConst;
104 
105 #define JS_VALUE_GET_TAG(v) (int)((uintptr_t)(v) & 0xf)
106 /* same as JS_VALUE_GET_TAG, but return JS_TAG_FLOAT64 with NaN boxing */
107 #define JS_VALUE_GET_NORM_TAG(v) JS_VALUE_GET_TAG(v)
108 #define JS_VALUE_GET_INT(v) (int)((intptr_t)(v) >> 4)
109 #define JS_VALUE_GET_BOOL(v) JS_VALUE_GET_INT(v)
110 #define JS_VALUE_GET_FLOAT64(v) (double)JS_VALUE_GET_INT(v)
111 #define JS_VALUE_GET_PTR(v) (void *)((intptr_t)(v) & ~0xf)
112 
113 #define JS_MKVAL(tag, val) (JSValue)(intptr_t)(((val) << 4) | (tag))
114 #define JS_MKPTR(tag, p) (JSValue)((intptr_t)(p) | (tag))
115 
116 #define JS_TAG_IS_FLOAT64(tag) ((unsigned)(tag) == JS_TAG_FLOAT64)
117 
118 #define JS_NAN JS_MKVAL(JS_TAG_FLOAT64, 1)
119 
__JS_NewFloat64(JSContext * ctx,double d)120 static inline JSValue __JS_NewFloat64(JSContext *ctx, double d)
121 {
122     return JS_MKVAL(JS_TAG_FLOAT64, (int)d);
123 }
124 
JS_VALUE_IS_NAN(JSValue v)125 static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
126 {
127     return 0;
128 }
129 
130 #elif defined(JS_NAN_BOXING)
131 
132 typedef uint64_t JSValue;
133 
134 #define JSValueConst JSValue
135 
136 #define JS_VALUE_GET_TAG(v) (int)((v) >> 32)
137 #define JS_VALUE_GET_INT(v) (int)(v)
138 #define JS_VALUE_GET_BOOL(v) (int)(v)
139 #define JS_VALUE_GET_PTR(v) (void *)(intptr_t)(v)
140 
141 #define JS_MKVAL(tag, val) (((uint64_t)(tag) << 32) | (uint32_t)(val))
142 #define JS_MKPTR(tag, ptr) (((uint64_t)(tag) << 32) | (uintptr_t)(ptr))
143 
144 #define JS_FLOAT64_TAG_ADDEND (0x7ff80000 - JS_TAG_FIRST + 1) /* quiet NaN encoding */
145 
JS_VALUE_GET_FLOAT64(JSValue v)146 static inline double JS_VALUE_GET_FLOAT64(JSValue v)
147 {
148     union {
149         JSValue v;
150         double d;
151     } u;
152     u.v = v;
153     u.v += (uint64_t)JS_FLOAT64_TAG_ADDEND << 32;
154     return u.d;
155 }
156 
157 #define JS_NAN (0x7ff8000000000000 - ((uint64_t)JS_FLOAT64_TAG_ADDEND << 32))
158 
__JS_NewFloat64(JSContext * ctx,double d)159 static inline JSValue __JS_NewFloat64(JSContext *ctx, double d)
160 {
161     union {
162         double d;
163         uint64_t u64;
164     } u;
165     JSValue v;
166     u.d = d;
167     /* normalize NaN */
168     if (js_unlikely((u.u64 & 0x7fffffffffffffff) > 0x7ff0000000000000))
169         v = JS_NAN;
170     else
171         v = u.u64 - ((uint64_t)JS_FLOAT64_TAG_ADDEND << 32);
172     return v;
173 }
174 
175 #define JS_TAG_IS_FLOAT64(tag) ((unsigned)((tag) - JS_TAG_FIRST) >= (JS_TAG_FLOAT64 - JS_TAG_FIRST))
176 
177 /* same as JS_VALUE_GET_TAG, but return JS_TAG_FLOAT64 with NaN boxing */
JS_VALUE_GET_NORM_TAG(JSValue v)178 static inline int JS_VALUE_GET_NORM_TAG(JSValue v)
179 {
180     uint32_t tag;
181     tag = JS_VALUE_GET_TAG(v);
182     if (JS_TAG_IS_FLOAT64(tag))
183         return JS_TAG_FLOAT64;
184     else
185         return tag;
186 }
187 
JS_VALUE_IS_NAN(JSValue v)188 static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
189 {
190     uint32_t tag;
191     tag = JS_VALUE_GET_TAG(v);
192     return tag == (JS_NAN >> 32);
193 }
194 
195 #else /* !JS_NAN_BOXING */
196 
197 typedef union JSValueUnion {
198     int32_t int32;
199     double float64;
200     void *ptr;
201 } JSValueUnion;
202 
203 typedef struct JSValue {
204     JSValueUnion u;
205     int64_t tag;
206 } JSValue;
207 
208 #define JSValueConst JSValue
209 
210 #define JS_VALUE_GET_TAG(v) ((int32_t)(v).tag)
211 /* same as JS_VALUE_GET_TAG, but return JS_TAG_FLOAT64 with NaN boxing */
212 #define JS_VALUE_GET_NORM_TAG(v) JS_VALUE_GET_TAG(v)
213 #define JS_VALUE_GET_INT(v) ((v).u.int32)
214 #define JS_VALUE_GET_BOOL(v) ((v).u.int32)
215 #define JS_VALUE_GET_FLOAT64(v) ((v).u.float64)
216 #define JS_VALUE_GET_PTR(v) ((v).u.ptr)
217 
218 #define JS_MKVAL(tag, val) (JSValue){ (JSValueUnion){ .int32 = val }, tag }
219 #define JS_MKPTR(tag, p) (JSValue){ (JSValueUnion){ .ptr = p }, tag }
220 
221 #define JS_TAG_IS_FLOAT64(tag) ((unsigned)(tag) == JS_TAG_FLOAT64)
222 
223 #define JS_NAN (JSValue){ .u.float64 = JS_FLOAT64_NAN, JS_TAG_FLOAT64 }
224 
__JS_NewFloat64(JSContext * ctx,double d)225 static inline JSValue __JS_NewFloat64(JSContext *ctx, double d)
226 {
227     JSValue v;
228     v.tag = JS_TAG_FLOAT64;
229     v.u.float64 = d;
230     return v;
231 }
232 
JS_VALUE_IS_NAN(JSValue v)233 static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
234 {
235     union {
236         double d;
237         uint64_t u64;
238     } u;
239     if (v.tag != JS_TAG_FLOAT64)
240         return 0;
241     u.d = v.u.float64;
242     return (u.u64 & 0x7fffffffffffffff) > 0x7ff0000000000000;
243 }
244 
245 #endif /* !JS_NAN_BOXING */
246 
247 #define JS_VALUE_IS_BOTH_INT(v1, v2) ((JS_VALUE_GET_TAG(v1) | JS_VALUE_GET_TAG(v2)) == 0)
248 #define JS_VALUE_IS_BOTH_FLOAT(v1, v2) (JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(v1)) && JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(v2)))
249 
250 #define JS_VALUE_GET_OBJ(v) ((JSObject *)JS_VALUE_GET_PTR(v))
251 #define JS_VALUE_GET_STRING(v) ((JSString *)JS_VALUE_GET_PTR(v))
252 #define JS_VALUE_HAS_REF_COUNT(v) ((unsigned)JS_VALUE_GET_TAG(v) >= (unsigned)JS_TAG_FIRST)
253 
254 /* special values */
255 #define JS_NULL      JS_MKVAL(JS_TAG_NULL, 0)
256 #define JS_UNDEFINED JS_MKVAL(JS_TAG_UNDEFINED, 0)
257 #define JS_FALSE     JS_MKVAL(JS_TAG_BOOL, 0)
258 #define JS_TRUE      JS_MKVAL(JS_TAG_BOOL, 1)
259 #define JS_EXCEPTION JS_MKVAL(JS_TAG_EXCEPTION, 0)
260 #define JS_UNINITIALIZED JS_MKVAL(JS_TAG_UNINITIALIZED, 0)
261 
262 /* flags for object properties */
263 #define JS_PROP_CONFIGURABLE  (1 << 0)
264 #define JS_PROP_WRITABLE      (1 << 1)
265 #define JS_PROP_ENUMERABLE    (1 << 2)
266 #define JS_PROP_C_W_E         (JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE | JS_PROP_ENUMERABLE)
267 #define JS_PROP_LENGTH        (1 << 3) /* used internally in Arrays */
268 #define JS_PROP_TMASK         (3 << 4) /* mask for NORMAL, GETSET, VARREF, AUTOINIT */
269 #define JS_PROP_NORMAL         (0 << 4)
270 #define JS_PROP_GETSET         (1 << 4)
271 #define JS_PROP_VARREF         (2 << 4) /* used internally */
272 #define JS_PROP_AUTOINIT       (3 << 4) /* used internally */
273 
274 /* flags for JS_DefineProperty */
275 #define JS_PROP_HAS_SHIFT        8
276 #define JS_PROP_HAS_CONFIGURABLE (1 << 8)
277 #define JS_PROP_HAS_WRITABLE     (1 << 9)
278 #define JS_PROP_HAS_ENUMERABLE   (1 << 10)
279 #define JS_PROP_HAS_GET          (1 << 11)
280 #define JS_PROP_HAS_SET          (1 << 12)
281 #define JS_PROP_HAS_VALUE        (1 << 13)
282 
283 /* throw an exception if false would be returned
284    (JS_DefineProperty/JS_SetProperty) */
285 #define JS_PROP_THROW            (1 << 14)
286 /* throw an exception if false would be returned in strict mode
287    (JS_SetProperty) */
288 #define JS_PROP_THROW_STRICT     (1 << 15)
289 
290 #define JS_PROP_NO_ADD           (1 << 16) /* internal use */
291 #define JS_PROP_NO_EXOTIC        (1 << 17) /* internal use */
292 
293 #define JS_DEFAULT_STACK_SIZE (256 * 1024)
294 
295 /* JS_Eval() flags */
296 #define JS_EVAL_TYPE_GLOBAL   (0 << 0) /* global code (default) */
297 #define JS_EVAL_TYPE_MODULE   (1 << 0) /* module code */
298 #define JS_EVAL_TYPE_DIRECT   (2 << 0) /* direct call (internal use) */
299 #define JS_EVAL_TYPE_INDIRECT (3 << 0) /* indirect call (internal use) */
300 #define JS_EVAL_TYPE_MASK     (3 << 0)
301 
302 #define JS_EVAL_FLAG_STRICT   (1 << 3) /* force 'strict' mode */
303 #define JS_EVAL_FLAG_STRIP    (1 << 4) /* force 'strip' mode */
304 /* compile but do not run. The result is an object with a
305    JS_TAG_FUNCTION_BYTECODE or JS_TAG_MODULE tag. It can be executed
306    with JS_EvalFunction(). */
307 #define JS_EVAL_FLAG_COMPILE_ONLY (1 << 5)
308 /* don't include the stack frames before this eval in the Error() backtraces */
309 #define JS_EVAL_FLAG_BACKTRACE_BARRIER (1 << 6)
310 
311 typedef JSValue JSCFunction(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
312 typedef JSValue JSCFunctionMagic(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic);
313 typedef JSValue JSCFunctionData(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic, JSValue *func_data);
314 
315 typedef struct JSMallocState {
316     size_t malloc_count;
317     size_t malloc_size;
318     size_t malloc_limit;
319     void *opaque; /* user opaque */
320 } JSMallocState;
321 
322 typedef struct JSMallocFunctions {
323     void *(*js_malloc)(JSMallocState *s, size_t size);
324     void (*js_free)(JSMallocState *s, void *ptr);
325     void *(*js_realloc)(JSMallocState *s, void *ptr, size_t size);
326     size_t (*js_malloc_usable_size)(const void *ptr);
327 } JSMallocFunctions;
328 
329 typedef struct JSGCObjectHeader JSGCObjectHeader;
330 
331 JSRuntime *JS_NewRuntime(void);
332 /* info lifetime must exceed that of rt */
333 void JS_SetRuntimeInfo(JSRuntime *rt, const char *info);
334 void JS_SetMemoryLimit(JSRuntime *rt, size_t limit);
335 void JS_SetGCThreshold(JSRuntime *rt, size_t gc_threshold);
336 void JS_SetMaxStackSize(JSRuntime *rt, size_t stack_size);
337 JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque);
338 void JS_FreeRuntime(JSRuntime *rt);
339 void *JS_GetRuntimeOpaque(JSRuntime *rt);
340 void JS_SetRuntimeOpaque(JSRuntime *rt, void *opaque);
341 typedef void JS_MarkFunc(JSRuntime *rt, JSGCObjectHeader *gp);
342 void JS_MarkValue(JSRuntime *rt, JSValueConst val, JS_MarkFunc *mark_func);
343 void JS_RunGC(JSRuntime *rt);
344 JS_BOOL JS_IsLiveObject(JSRuntime *rt, JSValueConst obj);
345 
346 JSContext *JS_NewContext(JSRuntime *rt);
347 void JS_FreeContext(JSContext *s);
348 JSContext *JS_DupContext(JSContext *ctx);
349 void *JS_GetContextOpaque(JSContext *ctx);
350 void JS_SetContextOpaque(JSContext *ctx, void *opaque);
351 JSRuntime *JS_GetRuntime(JSContext *ctx);
352 void JS_SetClassProto(JSContext *ctx, JSClassID class_id, JSValue obj);
353 JSValue JS_GetClassProto(JSContext *ctx, JSClassID class_id);
354 
355 /* the following functions are used to select the intrinsic object to
356    save memory */
357 JSContext *JS_NewContextRaw(JSRuntime *rt);
358 void JS_AddIntrinsicBaseObjects(JSContext *ctx);
359 void JS_AddIntrinsicDate(JSContext *ctx);
360 void JS_AddIntrinsicEval(JSContext *ctx);
361 void JS_AddIntrinsicStringNormalize(JSContext *ctx);
362 void JS_AddIntrinsicRegExpCompiler(JSContext *ctx);
363 void JS_AddIntrinsicRegExp(JSContext *ctx);
364 void JS_AddIntrinsicJSON(JSContext *ctx);
365 void JS_AddIntrinsicProxy(JSContext *ctx);
366 void JS_AddIntrinsicMapSet(JSContext *ctx);
367 void JS_AddIntrinsicTypedArrays(JSContext *ctx);
368 void JS_AddIntrinsicPromise(JSContext *ctx);
369 void JS_AddIntrinsicBigInt(JSContext *ctx);
370 void JS_AddIntrinsicBigFloat(JSContext *ctx);
371 void JS_AddIntrinsicBigDecimal(JSContext *ctx);
372 /* enable operator overloading */
373 void JS_AddIntrinsicOperators(JSContext *ctx);
374 /* enable "use math" */
375 void JS_EnableBignumExt(JSContext *ctx, JS_BOOL enable);
376 
377 JSValue js_string_codePointRange(JSContext *ctx, JSValueConst this_val,
378                                  int argc, JSValueConst *argv);
379 
380 void *js_malloc_rt(JSRuntime *rt, size_t size);
381 void js_free_rt(JSRuntime *rt, void *ptr);
382 void *js_realloc_rt(JSRuntime *rt, void *ptr, size_t size);
383 size_t js_malloc_usable_size_rt(JSRuntime *rt, const void *ptr);
384 void *js_mallocz_rt(JSRuntime *rt, size_t size);
385 
386 void *js_malloc(JSContext *ctx, size_t size);
387 void js_free(JSContext *ctx, void *ptr);
388 void *js_realloc(JSContext *ctx, void *ptr, size_t size);
389 size_t js_malloc_usable_size(JSContext *ctx, const void *ptr);
390 void *js_realloc2(JSContext *ctx, void *ptr, size_t size, size_t *pslack);
391 void *js_mallocz(JSContext *ctx, size_t size);
392 char *js_strdup(JSContext *ctx, const char *str);
393 char *js_strndup(JSContext *ctx, const char *s, size_t n);
394 
395 typedef struct JSMemoryUsage {
396     int64_t malloc_size, malloc_limit, memory_used_size;
397     int64_t malloc_count;
398     int64_t memory_used_count;
399     int64_t atom_count, atom_size;
400     int64_t str_count, str_size;
401     int64_t obj_count, obj_size;
402     int64_t prop_count, prop_size;
403     int64_t shape_count, shape_size;
404     int64_t js_func_count, js_func_size, js_func_code_size;
405     int64_t js_func_pc2line_count, js_func_pc2line_size;
406     int64_t c_func_count, array_count;
407     int64_t fast_array_count, fast_array_elements;
408     int64_t binary_object_count, binary_object_size;
409 } JSMemoryUsage;
410 
411 void JS_ComputeMemoryUsage(JSRuntime *rt, JSMemoryUsage *s);
412 void JS_DumpMemoryUsage(FILE *fp, const JSMemoryUsage *s, JSRuntime *rt);
413 
414 /* atom support */
415 JSAtom JS_NewAtomLen(JSContext *ctx, const char *str, size_t len);
416 JSAtom JS_NewAtom(JSContext *ctx, const char *str);
417 JSAtom JS_NewAtomUInt32(JSContext *ctx, uint32_t n);
418 JSAtom JS_DupAtom(JSContext *ctx, JSAtom v);
419 void JS_FreeAtom(JSContext *ctx, JSAtom v);
420 void JS_FreeAtomRT(JSRuntime *rt, JSAtom v);
421 JSValue JS_AtomToValue(JSContext *ctx, JSAtom atom);
422 JSValue JS_AtomToString(JSContext *ctx, JSAtom atom);
423 const char *JS_AtomToCString(JSContext *ctx, JSAtom atom);
424 JSAtom JS_ValueToAtom(JSContext *ctx, JSValueConst val);
425 
426 /* object class support */
427 
428 typedef struct JSPropertyEnum {
429     JS_BOOL is_enumerable;
430     JSAtom atom;
431 } JSPropertyEnum;
432 
433 typedef struct JSPropertyDescriptor {
434     int flags;
435     JSValue value;
436     JSValue getter;
437     JSValue setter;
438 } JSPropertyDescriptor;
439 
440 typedef struct JSClassExoticMethods {
441     /* Return -1 if exception (can only happen in case of Proxy object),
442        FALSE if the property does not exists, TRUE if it exists. If 1 is
443        returned, the property descriptor 'desc' is filled if != NULL. */
444     int (*get_own_property)(JSContext *ctx, JSPropertyDescriptor *desc,
445                              JSValueConst obj, JSAtom prop);
446     /* '*ptab' should hold the '*plen' property keys. Return 0 if OK,
447        -1 if exception. The 'is_enumerable' field is ignored.
448     */
449     int (*get_own_property_names)(JSContext *ctx, JSPropertyEnum **ptab,
450                                   uint32_t *plen,
451                                   JSValueConst obj);
452     /* return < 0 if exception, or TRUE/FALSE */
453     int (*delete_property)(JSContext *ctx, JSValueConst obj, JSAtom prop);
454     /* return < 0 if exception or TRUE/FALSE */
455     int (*define_own_property)(JSContext *ctx, JSValueConst this_obj,
456                                JSAtom prop, JSValueConst val,
457                                JSValueConst getter, JSValueConst setter,
458                                int flags);
459     /* The following methods can be emulated with the previous ones,
460        so they are usually not needed */
461     /* return < 0 if exception or TRUE/FALSE */
462     int (*has_property)(JSContext *ctx, JSValueConst obj, JSAtom atom);
463     JSValue (*get_property)(JSContext *ctx, JSValueConst obj, JSAtom atom,
464                             JSValueConst receiver);
465     /* return < 0 if exception or TRUE/FALSE */
466     int (*set_property)(JSContext *ctx, JSValueConst obj, JSAtom atom,
467                         JSValueConst value, JSValueConst receiver, int flags);
468 } JSClassExoticMethods;
469 
470 typedef void JSClassFinalizer(JSRuntime *rt, JSValue val);
471 typedef void JSClassGCMark(JSRuntime *rt, JSValueConst val,
472                            JS_MarkFunc *mark_func);
473 #define JS_CALL_FLAG_CONSTRUCTOR (1 << 0)
474 typedef JSValue JSClassCall(JSContext *ctx, JSValueConst func_obj,
475                             JSValueConst this_val, int argc, JSValueConst *argv,
476                             int flags);
477 
478 typedef struct JSClassDef {
479     const char *class_name;
480     JSClassFinalizer *finalizer;
481     JSClassGCMark *gc_mark;
482     /* if call != NULL, the object is a function. If (flags &
483        JS_CALL_FLAG_CONSTRUCTOR) != 0, the function is called as a
484        constructor. In this case, 'this_val' is new.target. A
485        constructor call only happens if the object constructor bit is
486        set (see JS_SetConstructorBit()). */
487     JSClassCall *call;
488     /* XXX: suppress this indirection ? It is here only to save memory
489        because only a few classes need these methods */
490     JSClassExoticMethods *exotic;
491 } JSClassDef;
492 
493 JSClassID JS_NewClassID(JSClassID *pclass_id);
494 int JS_NewClass(JSRuntime *rt, JSClassID class_id, const JSClassDef *class_def);
495 int JS_IsRegisteredClass(JSRuntime *rt, JSClassID class_id);
496 
497 /* value handling */
498 
JS_NewBool(JSContext * ctx,JS_BOOL val)499 static js_force_inline JSValue JS_NewBool(JSContext *ctx, JS_BOOL val)
500 {
501     return JS_MKVAL(JS_TAG_BOOL, (val != 0));
502 }
503 
JS_NewInt32(JSContext * ctx,int32_t val)504 static js_force_inline JSValue JS_NewInt32(JSContext *ctx, int32_t val)
505 {
506     return JS_MKVAL(JS_TAG_INT, val);
507 }
508 
JS_NewCatchOffset(JSContext * ctx,int32_t val)509 static js_force_inline JSValue JS_NewCatchOffset(JSContext *ctx, int32_t val)
510 {
511     return JS_MKVAL(JS_TAG_CATCH_OFFSET, val);
512 }
513 
JS_NewInt64(JSContext * ctx,int64_t val)514 static js_force_inline JSValue JS_NewInt64(JSContext *ctx, int64_t val)
515 {
516     JSValue v;
517     if (val == (int32_t)val) {
518         v = JS_NewInt32(ctx, val);
519     } else {
520         v = __JS_NewFloat64(ctx, val);
521     }
522     return v;
523 }
524 
JS_NewUint32(JSContext * ctx,uint32_t val)525 static js_force_inline JSValue JS_NewUint32(JSContext *ctx, uint32_t val)
526 {
527     JSValue v;
528     if (val <= 0x7fffffff) {
529         v = JS_NewInt32(ctx, val);
530     } else {
531         v = __JS_NewFloat64(ctx, val);
532     }
533     return v;
534 }
535 
536 JSValue JS_NewBigInt64(JSContext *ctx, int64_t v);
537 JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v);
538 
JS_NewFloat64(JSContext * ctx,double d)539 static js_force_inline JSValue JS_NewFloat64(JSContext *ctx, double d)
540 {
541     JSValue v;
542     int32_t val;
543     union {
544         double d;
545         uint64_t u;
546     } u, t;
547     u.d = d;
548     val = (int32_t)d;
549     t.d = val;
550     /* -0 cannot be represented as integer, so we compare the bit
551         representation */
552     if (u.u == t.u) {
553         v = JS_MKVAL(JS_TAG_INT, val);
554     } else {
555         v = __JS_NewFloat64(ctx, d);
556     }
557     return v;
558 }
559 
JS_IsNumber(JSValueConst v)560 static inline JS_BOOL JS_IsNumber(JSValueConst v)
561 {
562     int tag = JS_VALUE_GET_TAG(v);
563     return tag == JS_TAG_INT || JS_TAG_IS_FLOAT64(tag);
564 }
565 
JS_IsBigInt(JSContext * ctx,JSValueConst v)566 static inline JS_BOOL JS_IsBigInt(JSContext *ctx, JSValueConst v)
567 {
568     int tag = JS_VALUE_GET_TAG(v);
569     return tag == JS_TAG_BIG_INT;
570 }
571 
JS_IsBigFloat(JSValueConst v)572 static inline JS_BOOL JS_IsBigFloat(JSValueConst v)
573 {
574     int tag = JS_VALUE_GET_TAG(v);
575     return tag == JS_TAG_BIG_FLOAT;
576 }
577 
JS_IsBigDecimal(JSValueConst v)578 static inline JS_BOOL JS_IsBigDecimal(JSValueConst v)
579 {
580     int tag = JS_VALUE_GET_TAG(v);
581     return tag == JS_TAG_BIG_DECIMAL;
582 }
583 
JS_IsBool(JSValueConst v)584 static inline JS_BOOL JS_IsBool(JSValueConst v)
585 {
586     return JS_VALUE_GET_TAG(v) == JS_TAG_BOOL;
587 }
588 
JS_IsNull(JSValueConst v)589 static inline JS_BOOL JS_IsNull(JSValueConst v)
590 {
591     return JS_VALUE_GET_TAG(v) == JS_TAG_NULL;
592 }
593 
JS_IsUndefined(JSValueConst v)594 static inline JS_BOOL JS_IsUndefined(JSValueConst v)
595 {
596     return JS_VALUE_GET_TAG(v) == JS_TAG_UNDEFINED;
597 }
598 
JS_IsException(JSValueConst v)599 static inline JS_BOOL JS_IsException(JSValueConst v)
600 {
601     return js_unlikely(JS_VALUE_GET_TAG(v) == JS_TAG_EXCEPTION);
602 }
603 
JS_IsUninitialized(JSValueConst v)604 static inline JS_BOOL JS_IsUninitialized(JSValueConst v)
605 {
606     return js_unlikely(JS_VALUE_GET_TAG(v) == JS_TAG_UNINITIALIZED);
607 }
608 
JS_IsString(JSValueConst v)609 static inline JS_BOOL JS_IsString(JSValueConst v)
610 {
611     return JS_VALUE_GET_TAG(v) == JS_TAG_STRING;
612 }
613 
JS_IsSymbol(JSValueConst v)614 static inline JS_BOOL JS_IsSymbol(JSValueConst v)
615 {
616     return JS_VALUE_GET_TAG(v) == JS_TAG_SYMBOL;
617 }
618 
JS_IsObject(JSValueConst v)619 static inline JS_BOOL JS_IsObject(JSValueConst v)
620 {
621     return JS_VALUE_GET_TAG(v) == JS_TAG_OBJECT;
622 }
623 
624 JSValue JS_Throw(JSContext *ctx, JSValue obj);
625 JSValue JS_GetException(JSContext *ctx);
626 JS_BOOL JS_IsError(JSContext *ctx, JSValueConst val);
627 void JS_ResetUncatchableError(JSContext *ctx);
628 JSValue JS_NewError(JSContext *ctx);
629 JSValue __js_printf_like(2, 3) JS_ThrowSyntaxError(JSContext *ctx, const char *fmt, ...);
630 JSValue __js_printf_like(2, 3) JS_ThrowTypeError(JSContext *ctx, const char *fmt, ...);
631 JSValue __js_printf_like(2, 3) JS_ThrowReferenceError(JSContext *ctx, const char *fmt, ...);
632 JSValue __js_printf_like(2, 3) JS_ThrowRangeError(JSContext *ctx, const char *fmt, ...);
633 JSValue __js_printf_like(2, 3) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...);
634 JSValue JS_ThrowOutOfMemory(JSContext *ctx);
635 
636 void __JS_FreeValue(JSContext *ctx, JSValue v);
JS_FreeValue(JSContext * ctx,JSValue v)637 static inline void JS_FreeValue(JSContext *ctx, JSValue v)
638 {
639     if (JS_VALUE_HAS_REF_COUNT(v)) {
640         JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
641         if (--p->ref_count <= 0) {
642             __JS_FreeValue(ctx, v);
643         }
644     }
645 }
646 void __JS_FreeValueRT(JSRuntime *rt, JSValue v);
JS_FreeValueRT(JSRuntime * rt,JSValue v)647 static inline void JS_FreeValueRT(JSRuntime *rt, JSValue v)
648 {
649     if (JS_VALUE_HAS_REF_COUNT(v)) {
650         JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
651         if (--p->ref_count <= 0) {
652             __JS_FreeValueRT(rt, v);
653         }
654     }
655 }
656 
JS_DupValue(JSContext * ctx,JSValueConst v)657 static inline JSValue JS_DupValue(JSContext *ctx, JSValueConst v)
658 {
659     if (JS_VALUE_HAS_REF_COUNT(v)) {
660         JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
661         p->ref_count++;
662     }
663     return (JSValue)v;
664 }
665 
JS_DupValueRT(JSRuntime * rt,JSValueConst v)666 static inline JSValue JS_DupValueRT(JSRuntime *rt, JSValueConst v)
667 {
668     if (JS_VALUE_HAS_REF_COUNT(v)) {
669         JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
670         p->ref_count++;
671     }
672     return (JSValue)v;
673 }
674 
675 int JS_ToBool(JSContext *ctx, JSValueConst val); /* return -1 for JS_EXCEPTION */
676 int JS_ToInt32(JSContext *ctx, int32_t *pres, JSValueConst val);
JS_ToUint32(JSContext * ctx,uint32_t * pres,JSValueConst val)677 static inline int JS_ToUint32(JSContext *ctx, uint32_t *pres, JSValueConst val)
678 {
679     return JS_ToInt32(ctx, (int32_t*)pres, val);
680 }
681 int JS_ToInt64(JSContext *ctx, int64_t *pres, JSValueConst val);
682 int JS_ToIndex(JSContext *ctx, uint64_t *plen, JSValueConst val);
683 int JS_ToFloat64(JSContext *ctx, double *pres, JSValueConst val);
684 /* return an exception if 'val' is a Number */
685 int JS_ToBigInt64(JSContext *ctx, int64_t *pres, JSValueConst val);
686 /* same as JS_ToInt64() but allow BigInt */
687 int JS_ToInt64Ext(JSContext *ctx, int64_t *pres, JSValueConst val);
688 
689 JSValue JS_NewStringLen(JSContext *ctx, const char *str1, size_t len1);
690 JSValue JS_NewString(JSContext *ctx, const char *str);
691 JSValue JS_NewAtomString(JSContext *ctx, const char *str);
692 JSValue JS_ToString(JSContext *ctx, JSValueConst val);
693 JSValue JS_ToPropertyKey(JSContext *ctx, JSValueConst val);
694 const char *JS_ToCStringLen2(JSContext *ctx, size_t *plen, JSValueConst val1, JS_BOOL cesu8);
JS_ToCStringLen(JSContext * ctx,size_t * plen,JSValueConst val1)695 static inline const char *JS_ToCStringLen(JSContext *ctx, size_t *plen, JSValueConst val1)
696 {
697     return JS_ToCStringLen2(ctx, plen, val1, 0);
698 }
JS_ToCString(JSContext * ctx,JSValueConst val1)699 static inline const char *JS_ToCString(JSContext *ctx, JSValueConst val1)
700 {
701     return JS_ToCStringLen2(ctx, NULL, val1, 0);
702 }
703 void JS_FreeCString(JSContext *ctx, const char *ptr);
704 
705 JSValue JS_NewObjectProtoClass(JSContext *ctx, JSValueConst proto, JSClassID class_id);
706 JSValue JS_NewObjectClass(JSContext *ctx, int class_id);
707 JSValue JS_NewObjectProto(JSContext *ctx, JSValueConst proto);
708 JSValue JS_NewObject(JSContext *ctx);
709 
710 JS_BOOL JS_IsFunction(JSContext* ctx, JSValueConst val);
711 JS_BOOL JS_IsConstructor(JSContext* ctx, JSValueConst val);
712 JS_BOOL JS_SetConstructorBit(JSContext *ctx, JSValueConst func_obj, JS_BOOL val);
713 
714 JSValue JS_NewArray(JSContext *ctx);
715 int JS_IsArray(JSContext *ctx, JSValueConst val);
716 
717 JSValue JS_GetPropertyInternal(JSContext *ctx, JSValueConst obj,
718                                JSAtom prop, JSValueConst receiver,
719                                JS_BOOL throw_ref_error);
JS_GetProperty(JSContext * ctx,JSValueConst this_obj,JSAtom prop)720 static js_force_inline JSValue JS_GetProperty(JSContext *ctx, JSValueConst this_obj,
721                                               JSAtom prop)
722 {
723     return JS_GetPropertyInternal(ctx, this_obj, prop, this_obj, 0);
724 }
725 JSValue JS_GetPropertyStr(JSContext *ctx, JSValueConst this_obj,
726                           const char *prop);
727 JSValue JS_GetPropertyUint32(JSContext *ctx, JSValueConst this_obj,
728                              uint32_t idx);
729 
730 int JS_SetPropertyInternal(JSContext *ctx, JSValueConst this_obj,
731                            JSAtom prop, JSValue val,
732                            int flags);
JS_SetProperty(JSContext * ctx,JSValueConst this_obj,JSAtom prop,JSValue val)733 static inline int JS_SetProperty(JSContext *ctx, JSValueConst this_obj,
734                                  JSAtom prop, JSValue val)
735 {
736     return JS_SetPropertyInternal(ctx, this_obj, prop, val, JS_PROP_THROW);
737 }
738 int JS_SetPropertyUint32(JSContext *ctx, JSValueConst this_obj,
739                          uint32_t idx, JSValue val);
740 int JS_SetPropertyInt64(JSContext *ctx, JSValueConst this_obj,
741                         int64_t idx, JSValue val);
742 int JS_SetPropertyStr(JSContext *ctx, JSValueConst this_obj,
743                       const char *prop, JSValue val);
744 int JS_HasProperty(JSContext *ctx, JSValueConst this_obj, JSAtom prop);
745 int JS_IsExtensible(JSContext *ctx, JSValueConst obj);
746 int JS_PreventExtensions(JSContext *ctx, JSValueConst obj);
747 int JS_DeleteProperty(JSContext *ctx, JSValueConst obj, JSAtom prop, int flags);
748 int JS_SetPrototype(JSContext *ctx, JSValueConst obj, JSValueConst proto_val);
749 JSValue JS_GetPrototype(JSContext *ctx, JSValueConst val);
750 
751 #define JS_GPN_STRING_MASK  (1 << 0)
752 #define JS_GPN_SYMBOL_MASK  (1 << 1)
753 #define JS_GPN_PRIVATE_MASK (1 << 2)
754 /* only include the enumerable properties */
755 #define JS_GPN_ENUM_ONLY    (1 << 4)
756 /* set theJSPropertyEnum.is_enumerable field */
757 #define JS_GPN_SET_ENUM     (1 << 5)
758 
759 int JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **ptab,
760                            uint32_t *plen, JSValueConst obj, int flags);
761 int JS_GetOwnProperty(JSContext *ctx, JSPropertyDescriptor *desc,
762                       JSValueConst obj, JSAtom prop);
763 
764 JSValue JS_Call(JSContext *ctx, JSValueConst func_obj, JSValueConst this_obj,
765                 int argc, JSValueConst *argv);
766 JSValue JS_Invoke(JSContext *ctx, JSValueConst this_val, JSAtom atom,
767                   int argc, JSValueConst *argv);
768 JSValue JS_CallConstructor(JSContext *ctx, JSValueConst func_obj,
769                            int argc, JSValueConst *argv);
770 JSValue JS_CallConstructor2(JSContext *ctx, JSValueConst func_obj,
771                             JSValueConst new_target,
772                             int argc, JSValueConst *argv);
773 JS_BOOL JS_DetectModule(const char *input, size_t input_len);
774 /* 'input' must be zero terminated i.e. input[input_len] = '\0'. */
775 JSValue JS_Eval(JSContext *ctx, const char *input, size_t input_len,
776                 const char *filename, int eval_flags);
777 // export JS_EvalObject api by falcon
778 JSValue JS_EvalObject(JSContext *ctx, JSValueConst this_obj,
779         JSValueConst val, int flags, int scope_idx);
780 JSValue JS_EvalFunction(JSContext *ctx, JSValue fun_obj);
781 JSValue JS_GetGlobalObject(JSContext *ctx);
782 int JS_IsInstanceOf(JSContext *ctx, JSValueConst val, JSValueConst obj);
783 int JS_DefineProperty(JSContext *ctx, JSValueConst this_obj,
784                       JSAtom prop, JSValueConst val,
785                       JSValueConst getter, JSValueConst setter, int flags);
786 int JS_DefinePropertyValue(JSContext *ctx, JSValueConst this_obj,
787                            JSAtom prop, JSValue val, int flags);
788 int JS_DefinePropertyValueUint32(JSContext *ctx, JSValueConst this_obj,
789                                  uint32_t idx, JSValue val, int flags);
790 int JS_DefinePropertyValueStr(JSContext *ctx, JSValueConst this_obj,
791                               const char *prop, JSValue val, int flags);
792 int JS_DefinePropertyGetSet(JSContext *ctx, JSValueConst this_obj,
793                             JSAtom prop, JSValue getter, JSValue setter,
794                             int flags);
795 void JS_SetOpaque(JSValue obj, void *opaque);
796 void *JS_GetOpaque(JSValueConst obj, JSClassID class_id);
797 void *JS_GetOpaque2(JSContext *ctx, JSValueConst obj, JSClassID class_id);
798 
799 /* 'buf' must be zero terminated i.e. buf[buf_len] = '\0'. */
800 JSValue JS_ParseJSON(JSContext *ctx, const char *buf, size_t buf_len,
801                      const char *filename);
802 #define JS_PARSE_JSON_EXT (1 << 0) /* allow extended JSON */
803 JSValue JS_ParseJSON2(JSContext *ctx, const char *buf, size_t buf_len,
804                       const char *filename, int flags);
805 JSValue JS_JSONStringify(JSContext *ctx, JSValueConst obj,
806                          JSValueConst replacer, JSValueConst space0);
807 
808 typedef void JSFreeArrayBufferDataFunc(JSRuntime *rt, void *opaque, void *ptr);
809 JSValue JS_NewArrayBuffer(JSContext *ctx, uint8_t *buf, size_t len,
810                           JSFreeArrayBufferDataFunc *free_func, void *opaque,
811                           JS_BOOL is_shared);
812 JSValue JS_NewArrayBufferCopy(JSContext *ctx, const uint8_t *buf, size_t len);
813 void JS_DetachArrayBuffer(JSContext *ctx, JSValueConst obj);
814 uint8_t *JS_GetArrayBuffer(JSContext *ctx, size_t *psize, JSValueConst obj);
815 JSValue JS_GetTypedArrayBuffer(JSContext *ctx, JSValueConst obj,
816                                size_t *pbyte_offset,
817                                size_t *pbyte_length,
818                                size_t *pbytes_per_element);
819 typedef struct {
820     void *(*sab_alloc)(void *opaque, size_t size);
821     void (*sab_free)(void *opaque, void *ptr);
822     void (*sab_dup)(void *opaque, void *ptr);
823     void *sab_opaque;
824 } JSSharedArrayBufferFunctions;
825 void JS_SetSharedArrayBufferFunctions(JSRuntime *rt,
826                                       const JSSharedArrayBufferFunctions *sf);
827 
828 JSValue JS_NewPromiseCapability(JSContext *ctx, JSValue *resolving_funcs);
829 
830 /* is_handled = TRUE means that the rejection is handled */
831 typedef void JSHostPromiseRejectionTracker(JSContext *ctx, JSValueConst promise,
832                                            JSValueConst reason,
833                                            JS_BOOL is_handled, void *opaque);
834 void JS_SetHostPromiseRejectionTracker(JSRuntime *rt, JSHostPromiseRejectionTracker *cb, void *opaque);
835 
836 /* return != 0 if the JS code needs to be interrupted */
837 typedef int JSInterruptHandler(JSRuntime *rt, void *opaque);
838 void JS_SetInterruptHandler(JSRuntime *rt, JSInterruptHandler *cb, void *opaque);
839 /* if can_block is TRUE, Atomics.wait() can be used */
840 void JS_SetCanBlock(JSRuntime *rt, JS_BOOL can_block);
841 
842 typedef struct JSModuleDef JSModuleDef;
843 
844 /* return the module specifier (allocated with js_malloc()) or NULL if
845    exception */
846 typedef char *JSModuleNormalizeFunc(JSContext *ctx,
847                                     const char *module_base_name,
848                                     const char *module_name, void *opaque);
849 typedef JSModuleDef *JSModuleLoaderFunc(JSContext *ctx,
850                                         const char *module_name, void *opaque);
851 
852 /* module_normalize = NULL is allowed and invokes the default module
853    filename normalizer */
854 void JS_SetModuleLoaderFunc(JSRuntime *rt,
855                             JSModuleNormalizeFunc *module_normalize,
856                             JSModuleLoaderFunc *module_loader, void *opaque);
857 /* return the import.meta object of a module */
858 JSValue JS_GetImportMeta(JSContext *ctx, JSModuleDef *m);
859 JSAtom JS_GetModuleName(JSContext *ctx, JSModuleDef *m);
860 
861 /* JS Job support */
862 
863 typedef JSValue JSJobFunc(JSContext *ctx, int argc, JSValueConst *argv);
864 int JS_EnqueueJob(JSContext *ctx, JSJobFunc *job_func, int argc, JSValueConst *argv);
865 
866 JS_BOOL JS_IsJobPending(JSRuntime *rt);
867 int JS_ExecutePendingJob(JSRuntime *rt, JSContext **pctx);
868 
869 /* Object Writer/Reader (currently only used to handle precompiled code) */
870 #define JS_WRITE_OBJ_BYTECODE  (1 << 0) /* allow function/module */
871 #define JS_WRITE_OBJ_BSWAP     (1 << 1) /* byte swapped output */
872 #define JS_WRITE_OBJ_SAB       (1 << 2) /* allow SharedArrayBuffer */
873 #define JS_WRITE_OBJ_REFERENCE (1 << 3) /* allow object references to
874                                            encode arbitrary object
875                                            graph */
876 uint8_t *JS_WriteObject(JSContext *ctx, size_t *psize, JSValueConst obj,
877                         int flags);
878 uint8_t *JS_WriteObject2(JSContext *ctx, size_t *psize, JSValueConst obj,
879                          int flags, uint8_t ***psab_tab, size_t *psab_tab_len);
880 
881 #define JS_READ_OBJ_BYTECODE  (1 << 0) /* allow function/module */
882 #define JS_READ_OBJ_ROM_DATA  (1 << 1) /* avoid duplicating 'buf' data */
883 #define JS_READ_OBJ_SAB       (1 << 2) /* allow SharedArrayBuffer */
884 #define JS_READ_OBJ_REFERENCE (1 << 3) /* allow object references */
885 JSValue JS_ReadObject(JSContext *ctx, const uint8_t *buf, size_t buf_len,
886                       int flags);
887 
888 /* load the dependencies of the module 'obj'. Useful when JS_ReadObject()
889    returns a module. */
890 int JS_ResolveModule(JSContext *ctx, JSValueConst obj);
891 
892 /* C function definition */
893 typedef enum JSCFunctionEnum {  /* XXX: should rename for namespace isolation */
894     JS_CFUNC_generic,
895     JS_CFUNC_generic_magic,
896     JS_CFUNC_constructor,
897     JS_CFUNC_constructor_magic,
898     JS_CFUNC_constructor_or_func,
899     JS_CFUNC_constructor_or_func_magic,
900     JS_CFUNC_f_f,
901     JS_CFUNC_f_f_f,
902     JS_CFUNC_getter,
903     JS_CFUNC_setter,
904     JS_CFUNC_getter_magic,
905     JS_CFUNC_setter_magic,
906     JS_CFUNC_iterator_next,
907 } JSCFunctionEnum;
908 
909 typedef union JSCFunctionType {
910     JSCFunction *generic;
911     JSValue (*generic_magic)(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic);
912     JSCFunction *constructor;
913     JSValue (*constructor_magic)(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv, int magic);
914     JSCFunction *constructor_or_func;
915     double (*f_f)(double);
916     double (*f_f_f)(double, double);
917     JSValue (*getter)(JSContext *ctx, JSValueConst this_val);
918     JSValue (*setter)(JSContext *ctx, JSValueConst this_val, JSValueConst val);
919     JSValue (*getter_magic)(JSContext *ctx, JSValueConst this_val, int magic);
920     JSValue (*setter_magic)(JSContext *ctx, JSValueConst this_val, JSValueConst val, int magic);
921     JSValue (*iterator_next)(JSContext *ctx, JSValueConst this_val,
922                              int argc, JSValueConst *argv, int *pdone, int magic);
923 } JSCFunctionType;
924 
925 JSValue JS_NewCFunction2(JSContext *ctx, JSCFunction *func,
926                          const char *name,
927                          int length, JSCFunctionEnum cproto, int magic);
928 JSValue JS_NewCFunctionData(JSContext *ctx, JSCFunctionData *func,
929                             int length, int magic, int data_len,
930                             JSValueConst *data);
931 
JS_NewCFunction(JSContext * ctx,JSCFunction * func,const char * name,int length)932 static inline JSValue JS_NewCFunction(JSContext *ctx, JSCFunction *func, const char *name,
933                                       int length)
934 {
935     return JS_NewCFunction2(ctx, func, name, length, JS_CFUNC_generic, 0);
936 }
937 
JS_NewCFunctionMagic(JSContext * ctx,JSCFunctionMagic * func,const char * name,int length,JSCFunctionEnum cproto,int magic)938 static inline JSValue JS_NewCFunctionMagic(JSContext *ctx, JSCFunctionMagic *func,
939                                            const char *name,
940                                            int length, JSCFunctionEnum cproto, int magic)
941 {
942     return JS_NewCFunction2(ctx, (JSCFunction *)func, name, length, cproto, magic);
943 }
944 void JS_SetConstructor(JSContext *ctx, JSValueConst func_obj,
945                        JSValueConst proto);
946 
947 /* C property definition */
948 
949 typedef struct JSCFunctionListEntry {
950     const char *name;
951     uint8_t prop_flags;
952     uint8_t def_type;
953     int16_t magic;
954     union {
955         struct {
956             uint8_t length; /* XXX: should move outside union */
957             uint8_t cproto; /* XXX: should move outside union */
958             JSCFunctionType cfunc;
959         } func;
960         struct {
961             JSCFunctionType get;
962             JSCFunctionType set;
963         } getset;
964         struct {
965             const char *name;
966             int base;
967         } alias;
968         struct {
969             const struct JSCFunctionListEntry *tab;
970             int len;
971         } prop_list;
972         const char *str;
973         int32_t i32;
974         int64_t i64;
975         double f64;
976     } u;
977 } JSCFunctionListEntry;
978 
979 #define JS_DEF_CFUNC          0
980 #define JS_DEF_CGETSET        1
981 #define JS_DEF_CGETSET_MAGIC  2
982 #define JS_DEF_PROP_STRING    3
983 #define JS_DEF_PROP_INT32     4
984 #define JS_DEF_PROP_INT64     5
985 #define JS_DEF_PROP_DOUBLE    6
986 #define JS_DEF_PROP_UNDEFINED 7
987 #define JS_DEF_OBJECT         8
988 #define JS_DEF_ALIAS          9
989 
990 /* Note: c++ does not like nested designators */
991 #define JS_CFUNC_DEF(name, length, func1) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_CFUNC, 0, .u = { .func = { length, JS_CFUNC_generic, { .generic = func1 } } } }
992 #define JS_CFUNC_MAGIC_DEF(name, length, func1, magic) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_CFUNC, magic, .u = { .func = { length, JS_CFUNC_generic_magic, { .generic_magic = func1 } } } }
993 #define JS_CFUNC_SPECIAL_DEF(name, length, cproto, func1) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_CFUNC, 0, .u = { .func = { length, JS_CFUNC_ ## cproto, { .cproto = func1 } } } }
994 #define JS_ITERATOR_NEXT_DEF(name, length, func1, magic) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_CFUNC, magic, .u = { .func = { length, JS_CFUNC_iterator_next, { .iterator_next = func1 } } } }
995 #define JS_CGETSET_DEF(name, fgetter, fsetter) { name, JS_PROP_CONFIGURABLE, JS_DEF_CGETSET, 0, .u = { .getset = { .get = { .getter = fgetter }, .set = { .setter = fsetter } } } }
996 #define JS_CGETSET_MAGIC_DEF(name, fgetter, fsetter, magic) { name, JS_PROP_CONFIGURABLE, JS_DEF_CGETSET_MAGIC, magic, .u = { .getset = { .get = { .getter_magic = fgetter }, .set = { .setter_magic = fsetter } } } }
997 #define JS_PROP_STRING_DEF(name, cstr, prop_flags) { name, prop_flags, JS_DEF_PROP_STRING, 0, .u = { .str = cstr } }
998 #define JS_PROP_INT32_DEF(name, val, prop_flags) { name, prop_flags, JS_DEF_PROP_INT32, 0, .u = { .i32 = val } }
999 #define JS_PROP_INT64_DEF(name, val, prop_flags) { name, prop_flags, JS_DEF_PROP_INT64, 0, .u = { .i64 = val } }
1000 #define JS_PROP_DOUBLE_DEF(name, val, prop_flags) { name, prop_flags, JS_DEF_PROP_DOUBLE, 0, .u = { .f64 = val } }
1001 #define JS_PROP_UNDEFINED_DEF(name, prop_flags) { name, prop_flags, JS_DEF_PROP_UNDEFINED, 0, .u = { .i32 = 0 } }
1002 #define JS_OBJECT_DEF(name, tab, len, prop_flags) { name, prop_flags, JS_DEF_OBJECT, 0, .u = { .prop_list = { tab, len } } }
1003 #define JS_ALIAS_DEF(name, from) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_ALIAS, 0, .u = { .alias = { from, -1 } } }
1004 #define JS_ALIAS_BASE_DEF(name, from, base) { name, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE, JS_DEF_ALIAS, 0, .u = { .alias = { from, base } } }
1005 
1006 void JS_SetPropertyFunctionList(JSContext *ctx, JSValueConst obj,
1007                                 const JSCFunctionListEntry *tab,
1008                                 int len);
1009 
1010 /* C module definition */
1011 
1012 typedef int JSModuleInitFunc(JSContext *ctx, JSModuleDef *m);
1013 
1014 JSModuleDef *JS_NewCModule(JSContext *ctx, const char *name_str,
1015                            JSModuleInitFunc *func);
1016 /* can only be called before the module is instantiated */
1017 int JS_AddModuleExport(JSContext *ctx, JSModuleDef *m, const char *name_str);
1018 int JS_AddModuleExportList(JSContext *ctx, JSModuleDef *m,
1019                            const JSCFunctionListEntry *tab, int len);
1020 /* can only be called after the module is instantiated */
1021 int JS_SetModuleExport(JSContext *ctx, JSModuleDef *m, const char *export_name,
1022                        JSValue val);
1023 int JS_SetModuleExportList(JSContext *ctx, JSModuleDef *m,
1024                            const JSCFunctionListEntry *tab, int len);
1025 
1026 #undef js_unlikely
1027 #undef js_force_inline
1028 
1029 #ifdef __cplusplus
1030 } /* extern "C" { */
1031 #endif
1032 
1033 #endif /* QUICKJS_H */
1034