john/cell
1
0
Fork 0
Code Issues 31 Pull Requests Packages Projects Releases 2 Wiki Activity

rm jsstring and string_buffer

Browse Source
This commit is contained in:
John Alanbrook
2026-02-01 11:35:40 -06:00
parent bb83327a52
commit 6c3c492446
3 changed files with 404 additions and 1080 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
docs/memory.md
View File

@@ -55,12 +55,21 @@ Objects are heap allocated, referenced by a pointer value. They are all preceded
### 64 bit build ### 64 bit build
56 bits capacity 56 bits capacity
1 bit memory reclamation flag: note that this obj has already been moved 1 bit memory reclamation flag: note that this obj has already been moved
3 bit reserved (per object) 2 bit reserved (per object)
1 bit stone: note that this obj is immutable 1 bit stone: note that this obj is immutable
3 bit type: note the type of the object 3 bit type: note the type of the object
1 bit: fwd: note that this obj is a forward linkage
Type 7: Forward Last bit ..1:
The forward type indicates that the object (an array, blob, pretext, or record) has grown beyond its capacity and is now residing at a new address. The remaining 61 bits contain the address of the enlarged object. Forward linkages are cleaned up by the memory reclaimer. The forward type indicates that the object (an array, blob, pretext, or record) has grown beyond its capacity and is now residing at a new address. The remaining 63 bits contain the address of the enlarged object. Forward linkages are cleaned up by the memory reclaimer.
Type 7: C light C object
Header
Pointer
Capacity is an ID of a registered C type.
Pointer is a pointer to the opaque C object.
Type 0: Array Type 0: Array
Header Header

1181
source/quickjs.c
View File

File diff suppressed because it is too large Load Diff

288
source/quickjs.h
View File

@@ -44,8 +44,39 @@ extern "C" {
// #define BINARY64 // 64 bit word type (double) // #define BINARY64 // 64 bit word type (double)
// #define DEC64 // 64 bit word type (dec) // #define DEC64 // 64 bit word type (dec)
enum mist_obj_type {
OBJ_ARRAY = 0,
OBJ_BLOB = 1,
OBJ_TEXT = 2,
OBJ_RECORD = 3, // js style objects
OBJ_FUNCTION = 4,
OBJ_CODE = 5,
OBJ_FRAME = 6,
OBJ_FORWARD = 7
};
#define OBJHDR_CAP_SHIFT 8u
#define OBJHDR_CAP_MASK (((objhdr_t)1ull << 56) - 1ull)
#define OBJHDR_S_BIT 3u
#define OBJHDR_P_BIT 4u
#define OBJHDR_A_BIT 5u
#define OBJHDR_R_BIT 7u
#define OBJHDR_FLAG(bit) ((objhdr_t)1ull << (bit))
#define OBJHDR_S_MASK OBJHDR_FLAG (OBJHDR_S_BIT)
#define OBJHDR_P_MASK OBJHDR_FLAG (OBJHDR_P_BIT)
#define OBJHDR_A_MASK OBJHDR_FLAG (OBJHDR_A_BIT)
#define OBJHDR_R_MASK OBJHDR_FLAG (OBJHDR_R_BIT)
typedef uint64_t word_t; // one actor-memory word
typedef uint64_t objhdr_t; // header word
typedef uint64_t objref_t; // 56-bit word address (0 = null)
static inline uint8_t objhdr_type (objhdr_t h) { return (uint8_t)(h & 7u); }
static inline int objhdr_s (objhdr_t h) { return (h & OBJHDR_S_MASK) != 0; }
/* /*
NaN boxing is used, always. A value is the length of the word.
Half: 10 bits Half: 10 bits
Float: 23 bits Float: 23 bits
Double: 52 bits Double: 52 bits
@@ -64,21 +95,8 @@ typedef struct JSContext JSContext; // Each actor - has its own GC
typedef struct JSClass JSClass; typedef struct JSClass JSClass;
typedef uint32_t JSClassID; typedef uint32_t JSClassID;
typedef struct JSGCRef { /* Forward declaration - JSGCRef moved after JSValue definition */
JSValue val; struct JSGCRef;
struct JSGCRef *prev;
} JSGCRef;
/* stack of JSGCRef */
JSValue *JS_PushGCRef(JSContext *ctx, JSGCRef *ref);
JSValue JS_PopGCRef(JSContext *ctx, JSGCRef *ref);
#define JS_PUSH_VALUE(ctx, v) do { JS_PushGCRef(ctx, &v ## _ref); v ## _ref.val = v; } while (0)
#define JS_POP_VALUE(ctx, v) v = JS_PopGCRef(ctx, &v ## _ref)
/* list of JSGCRef (they can be removed in any order, slower) */
JSValue *JS_AddGCRef(JSContext *ctx, JSGCRef *ref);
void JS_DeleteGCRef(JSContext *ctx, JSGCRef *ref);
/* ============================================================ /* ============================================================
Mist Value Encoding (LSB-based type discrimination) Mist Value Encoding (LSB-based type discrimination)
@@ -130,23 +148,29 @@ enum {
JS_TAG_UNINITIALIZED = 0x17, /* 10111 */ JS_TAG_UNINITIALIZED = 0x17, /* 10111 */
JS_TAG_STRING_IMM = 0x1B, /* 11011 - immediate ASCII (up to 7 chars) */ JS_TAG_STRING_IMM = 0x1B, /* 11011 - immediate ASCII (up to 7 chars) */
JS_TAG_CATCH_OFFSET = 0x1F, /* 11111 */ JS_TAG_CATCH_OFFSET = 0x1F, /* 11111 */
/* Object subtypes (stored in object header, not value) */
JS_TAG_STRING = -8, /* mist_text pointer */
JS_TAG_ARRAY = -6, /* JSArray pointer */
JS_TAG_FUNCTION = -5, /* JSFunction pointer */
JS_TAG_FUNCTION_BYTECODE = -2,
JS_TAG_OBJECT = -1, /* JSRecord/JSObject pointer */
/* Legacy - for gradual migration (to be removed) */
JS_TAG_FIRST = -10,
JS_TAG_FLOAT64 = 8, /* unused in new encoding */
}; };
typedef struct JSRefCountHeader { typedef struct JSRefCountHeader {
int ref_count; int ref_count;
} JSRefCountHeader; } JSRefCountHeader;
/* JSGCRef - for rooting values during GC */
typedef struct JSGCRef {
JSValue val;
struct JSGCRef *prev;
} JSGCRef;
/* stack of JSGCRef */
JSValue *JS_PushGCRef(JSContext *ctx, JSGCRef *ref);
JSValue JS_PopGCRef(JSContext *ctx, JSGCRef *ref);
#define JS_PUSH_VALUE(ctx, v) do { JS_PushGCRef(ctx, &v ## _ref); v ## _ref.val = v; } while (0)
#define JS_POP_VALUE(ctx, v) v = JS_PopGCRef(ctx, &v ## _ref)
/* list of JSGCRef (they can be removed in any order, slower) */
JSValue *JS_AddGCRef(JSContext *ctx, JSGCRef *ref);
void JS_DeleteGCRef(JSContext *ctx, JSGCRef *ref);
/* ============================================================ /* ============================================================
Value Extraction Value Extraction
============================================================ */ ============================================================ */
@@ -185,10 +209,10 @@ JS_VALUE_GET_TAG (JSValue v) {
============================================================ */ ============================================================ */
#define JS_MKVAL(tag, val) _JS_MkVal (tag, val) #define JS_MKVAL(tag, val) _JS_MkVal (tag, val)
#define JS_MKPTR(tag, ptr) (((JSValue)(uintptr_t)(ptr)) | JS_TAG_PTR) #define JS_MKPTR(ptr) (((JSValue)(uintptr_t)(ptr)) | JS_TAG_PTR)
#define JS_MKFWD(ptr) (((JSValue)(uintptr_t)(ptr)) | JS_TAG_FORWARD)
static inline JSValue static inline JSValue _JS_MkVal (int tag, int32_t val) {
_JS_MkVal (int tag, int32_t val) {
if (tag == JS_TAG_INT) { return ((JSValue)(uint32_t)val << 1); } if (tag == JS_TAG_INT) { return ((JSValue)(uint32_t)val << 1); }
/* Special tags encode payload in upper bits */ /* Special tags encode payload in upper bits */
return ((JSValue)tag) | ((JSValue)(uint32_t)val << 5); return ((JSValue)tag) | ((JSValue)(uint32_t)val << 5);
@@ -239,8 +263,7 @@ __JS_NewFloat64 (JSContext *ctx, double d) {
| JS_TAG_SHORT_FLOAT; | JS_TAG_SHORT_FLOAT;
} }
static inline double static inline double JS_VALUE_GET_FLOAT64 (JSValue v) {
JS_VALUE_GET_FLOAT64 (JSValue v) {
if ((v & 7) != JS_TAG_SHORT_FLOAT) return 0.0; if ((v & 7) != JS_TAG_SHORT_FLOAT) return 0.0;
uint64_t sign = v >> 63; uint64_t sign = v >> 63;
@@ -258,11 +281,6 @@ JS_VALUE_GET_FLOAT64 (JSValue v) {
return u.d; return u.d;
} }
static inline JS_BOOL
JS_VALUE_IS_NAN (JSValue v) {
return 0; /* NaN becomes NULL in Mist encoding */
}
#define JS_TAG_IS_FLOAT64(tag) ((tag) == JS_TAG_SHORT_FLOAT) #define JS_TAG_IS_FLOAT64(tag) ((tag) == JS_TAG_SHORT_FLOAT)
#define JS_NAN JS_MKVAL (JS_TAG_NULL, 0) #define JS_NAN JS_MKVAL (JS_TAG_NULL, 0)
@@ -272,11 +290,6 @@ static inline JSValue __JS_NewFloat64 (JSContext *ctx,
double d); /* forward decl */ double d); /* forward decl */
static inline double JS_VALUE_GET_FLOAT64 (JSValue v); static inline double JS_VALUE_GET_FLOAT64 (JSValue v);
static inline JS_BOOL
JS_VALUE_IS_NAN (JSValue v) {
return 0;
}
#define JS_TAG_IS_FLOAT64(tag) (0) #define JS_TAG_IS_FLOAT64(tag) (0)
#define JS_NAN JS_MKVAL (JS_TAG_NULL, 0) #define JS_NAN JS_MKVAL (JS_TAG_NULL, 0)
@@ -286,18 +299,15 @@ JS_VALUE_IS_NAN (JSValue v) {
Type Checks Type Checks
============================================================ */ ============================================================ */
static inline JS_BOOL static inline JS_BOOL JS_IsInt (JSValue v) { return (v & 1) == 0; }
JS_IsInt (JSValue v) { static inline JS_BOOL JS_IsPtr (JSValue v) { return (v & 3) == JS_TAG_PTR; }
return (v & 1) == 0; static inline JS_BOOL JS_IsSpecial (JSValue v) { return (v & 3) == JS_TAG_SPECIAL; }
}
static inline JS_BOOL static inline JS_BOOL JS_IsStone(JSValue v) {
JS_IsPtr (JSValue v) { if (!JS_IsPtr(v)) return 1;
return (v & 3) == JS_TAG_PTR; return objhdr_s(*(objhdr_t *)JS_VALUE_GET_PTR(v));
}
static inline JS_BOOL
JS_IsSpecial (JSValue v) {
return (v & 3) == JS_TAG_SPECIAL;
} }
#ifdef JS_PTR64 #ifdef JS_PTR64
static inline JS_BOOL static inline JS_BOOL
JS_IsShortFloat (JSValue v) { JS_IsShortFloat (JSValue v) {
@@ -309,9 +319,6 @@ JS_IsShortFloat (JSValue v) {
#define JS_VALUE_IS_BOTH_FLOAT(v1, v2) \ #define JS_VALUE_IS_BOTH_FLOAT(v1, v2) \
(JS_IsShortFloat (v1) && JS_IsShortFloat (v2)) (JS_IsShortFloat (v1) && JS_IsShortFloat (v2))
/* Pointer values have ref counts */
#define JS_VALUE_HAS_REF_COUNT(v) JS_IsPtr (v)
/* ============================================================ /* ============================================================
Special Constants Special Constants
============================================================ */ ============================================================ */
@@ -371,7 +378,6 @@ typedef struct JSMallocFunctions {
typedef struct JSGCObjectHeader JSGCObjectHeader; typedef struct JSGCObjectHeader JSGCObjectHeader;
JSValue JS_Stone (JSContext *ctx, JSValue this_val); JSValue JS_Stone (JSContext *ctx, JSValue this_val);
int JS_IsStone (JSContext *ctx, JSValue val);
JSRuntime *JS_NewRuntime (void); JSRuntime *JS_NewRuntime (void);
/* info lifetime must exceed that of rt */ /* info lifetime must exceed that of rt */
@@ -405,29 +411,6 @@ JSValue JS_GetClassProto (JSContext *ctx, JSClassID class_id);
/* the following functions are used to select the intrinsic object to /* the following functions are used to select the intrinsic object to
save memory */ save memory */
JSContext *JS_NewContextRaw (JSRuntime *rt); JSContext *JS_NewContextRaw (JSRuntime *rt);
void JS_AddIntrinsicBaseObjects (JSContext *ctx);
void JS_AddIntrinsicEval (JSContext *ctx);
void JS_AddIntrinsicRegExpCompiler (JSContext *ctx);
void JS_AddIntrinsicRegExp (JSContext *ctx);
void JS_AddIntrinsicJSON (JSContext *ctx);
JSValue js_string_codePointRange (JSContext *ctx, JSValue this_val,
int argc, JSValue *argv);
void *js_malloc_rt (JSRuntime *rt, size_t size);
void js_free_rt (JSRuntime *rt, void *ptr);
void *js_realloc_rt (JSRuntime *rt, void *ptr, size_t size);
size_t js_malloc_usable_size_rt (JSRuntime *rt, const void *ptr);
void *js_mallocz_rt (JSRuntime *rt, size_t size);
void *js_malloc (JSContext *ctx, size_t size);
void js_free (JSContext *ctx, void *ptr);
void *js_realloc (JSContext *ctx, void *ptr, size_t size);
size_t js_malloc_usable_size (JSContext *ctx, const void *ptr);
void *js_realloc2 (JSContext *ctx, void *ptr, size_t size, size_t *pslack);
void *js_mallocz (JSContext *ctx, size_t size);
char *js_strdup (JSContext *ctx, const char *str);
char *js_strndup (JSContext *ctx, const char *s, size_t n);
typedef struct JSMemoryUsage { typedef struct JSMemoryUsage {
int64_t malloc_size, malloc_limit, memory_used_size; int64_t malloc_size, malloc_limit, memory_used_size;
@@ -530,29 +513,24 @@ JS_NewFloat64 (JSContext *ctx, double d) {
return __JS_NewFloat64 (ctx, d); return __JS_NewFloat64 (ctx, d);
} }
static inline JS_BOOL static inline JS_BOOL JS_IsNumber (JSValue v) {
JS_IsNumber (JSValue v) {
int tag = JS_VALUE_GET_TAG (v); int tag = JS_VALUE_GET_TAG (v);
return tag == JS_TAG_INT || JS_TAG_IS_FLOAT64 (tag); return tag == JS_TAG_INT || JS_TAG_IS_FLOAT64 (tag);
} }
static inline JS_BOOL static inline JS_BOOL JS_IsBool (JSValue v) {
JS_IsBool (JSValue v) {
return JS_VALUE_GET_TAG (v) == JS_TAG_BOOL; return JS_VALUE_GET_TAG (v) == JS_TAG_BOOL;
} }
static inline JS_BOOL static inline JS_BOOL JS_IsNull (JSValue v) {
JS_IsNull (JSValue v) {
return JS_VALUE_GET_TAG (v) == JS_TAG_NULL; return JS_VALUE_GET_TAG (v) == JS_TAG_NULL;
} }
static inline JS_BOOL static inline JS_BOOL JS_IsException (JSValue v) {
JS_IsException (JSValue v) {
return (JS_VALUE_GET_TAG (v) == JS_TAG_EXCEPTION); return (JS_VALUE_GET_TAG (v) == JS_TAG_EXCEPTION);
} }
static inline JS_BOOL static inline JS_BOOL JS_IsUninitialized (JSValue v) {
JS_IsUninitialized (JSValue v) {
return (JS_VALUE_GET_TAG (v) == JS_TAG_UNINITIALIZED); return (JS_VALUE_GET_TAG (v) == JS_TAG_UNINITIALIZED);
} }
@@ -586,24 +564,45 @@ MIST_TryNewImmediateASCII (const char *str, size_t len) {
return v; return v;
} }
JS_BOOL JS_IsString (JSValue v); static inline JS_BOOL JS_IsInteger (JSValue v) {
JS_BOOL JS_IsText (JSValue v);
/* Symbols removed in Mist encoding */
/* JS_IsFunction - check if value is a callable function.
With new tagging, must check gc_obj_type in JSGCObjectHeader. */
JS_BOOL JS_IsFunction (JSValue v);
static inline JS_BOOL
JS_IsInteger (JSValue v) {
return JS_VALUE_GET_TAG (v) == JS_TAG_INT; return JS_VALUE_GET_TAG (v) == JS_TAG_INT;
} }
/* JS_IsObject - check if value is a settable object (record or array). static inline JS_BOOL JS_IsObject (JSValue v) {
With new tagging, must check gc_obj_type in JSGCObjectHeader. */ return JS_IsPtr (v);
JS_BOOL JS_IsObject (JSValue v); }
int JS_IsArray (JSContext *ctx, JSValue val);
static inline JS_BOOL JS_IsArray(JSValue v) {
return JS_IsObject(v) && objhdr_type(*(objhdr_t *)JS_VALUE_GET_PTR(v)) == OBJ_ARRAY;
}
static inline JS_BOOL JS_IsRecord (JSValue v) {
return JS_IsObject(v) && objhdr_type(*(objhdr_t *)JS_VALUE_GET_PTR(v)) == OBJ_RECORD;
}
static inline JS_BOOL JS_IsFunction (JSValue v) {
return JS_IsObject(v) && objhdr_type(*(objhdr_t *)JS_VALUE_GET_PTR(v)) == OBJ_FUNCTION;
}
static inline JS_BOOL JS_IsCode (JSValue v) {
return JS_IsObject(v) && objhdr_type(*(objhdr_t *)JS_VALUE_GET_PTR(v)) == OBJ_CODE;
}
static inline JS_BOOL JS_IsForwarded (JSValue v) {
return JS_IsObject(v) && objhdr_type(*(objhdr_t *)JS_VALUE_GET_PTR(v)) == OBJ_FORWARD;
}
static inline JS_BOOL JS_IsFrame (JSValue v) {
return JS_IsObject(v) && objhdr_type(*(objhdr_t *)JS_VALUE_GET_PTR(v)) == OBJ_FRAME;
}
static inline JS_BOOL JS_IsBlob (JSValue v) {
return JS_IsObject(v) && objhdr_type(*(objhdr_t *)JS_VALUE_GET_PTR(v)) == OBJ_BLOB;
}
static inline JS_BOOL JS_IsText(JSValue v) {
return JS_IsObject(v) && objhdr_type(*(objhdr_t *)JS_VALUE_GET_PTR(v)) == OBJ_TEXT;
}
// Fundamental // Fundamental
int JS_GetLength (JSContext *ctx, JSValue obj, int64_t *pres); int JS_GetLength (JSContext *ctx, JSValue obj, int64_t *pres);
@@ -626,49 +625,12 @@ JSValue __js_printf_like (2, 3)
JS_ThrowInternalError (JSContext *ctx, const char *fmt, ...); JS_ThrowInternalError (JSContext *ctx, const char *fmt, ...);
JSValue JS_ThrowOutOfMemory (JSContext *ctx); JSValue JS_ThrowOutOfMemory (JSContext *ctx);
void __JS_FreeValue (JSContext *ctx, JSValue v);
static inline void
JS_FreeValue (JSContext *ctx, JSValue v) {
if (JS_VALUE_HAS_REF_COUNT (v)) {
JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR (v);
if (--p->ref_count <= 0) { __JS_FreeValue (ctx, v); }
}
}
void __JS_FreeValueRT (JSRuntime *rt, JSValue v);
static inline void
JS_FreeValueRT (JSRuntime *rt, JSValue v) {
if (JS_VALUE_HAS_REF_COUNT (v)) {
JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR (v);
if (--p->ref_count <= 0) { __JS_FreeValueRT (rt, v); }
}
}
static inline JSValue
JS_DupValue (JSContext *ctx, JSValue v) {
if (JS_VALUE_HAS_REF_COUNT (v)) {
JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR (v);
p->ref_count++;
}
return (JSValue)v;
}
static inline JSValue
JS_DupValueRT (JSRuntime *rt, JSValue v) {
if (JS_VALUE_HAS_REF_COUNT (v)) {
JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR (v);
p->ref_count++;
}
return (JSValue)v;
}
JS_BOOL JS_StrictEq (JSContext *ctx, JSValue op1, JSValue op2); JS_BOOL JS_StrictEq (JSContext *ctx, JSValue op1, JSValue op2);
JS_BOOL JS_SameValue (JSContext *ctx, JSValue op1, JSValue op2); JS_BOOL JS_SameValue (JSContext *ctx, JSValue op1, JSValue op2);
int JS_ToBool (JSContext *ctx, int JS_ToBool (JSContext *ctx, JSValue val); /* return -1 for JS_EXCEPTION */
JSValue val); /* return -1 for JS_EXCEPTION */
int JS_ToInt32 (JSContext *ctx, int32_t *pres, JSValue val); int JS_ToInt32 (JSContext *ctx, int32_t *pres, JSValue val);
static inline int static inline int JS_ToUint32 (JSContext *ctx, uint32_t *pres, JSValue val) {
JS_ToUint32 (JSContext *ctx, uint32_t *pres, JSValue val) {
return JS_ToInt32 (ctx, (int32_t *)pres, val); return JS_ToInt32 (ctx, (int32_t *)pres, val);
} }
int JS_ToInt64 (JSContext *ctx, int64_t *pres, JSValue val); int JS_ToInt64 (JSContext *ctx, int64_t *pres, JSValue val);
@@ -676,26 +638,21 @@ int JS_ToFloat64 (JSContext *ctx, double *pres, JSValue val);
/* return an exception if 'val' is a Number */ /* return an exception if 'val' is a Number */
JSValue JS_NewStringLen (JSContext *ctx, const char *str1, size_t len1); JSValue JS_NewStringLen (JSContext *ctx, const char *str1, size_t len1);
static inline JSValue static inline JSValue JS_NewString (JSContext *ctx, const char *str) {
JS_NewString (JSContext *ctx, const char *str) {
return JS_NewStringLen (ctx, str, strlen (str)); return JS_NewStringLen (ctx, str, strlen (str));
} }
JSValue JS_ToString (JSContext *ctx, JSValue val); JSValue JS_ToString (JSContext *ctx, JSValue val);
JSValue JS_ToPropertyKey (JSContext *ctx, JSValue val); JSValue JS_ToPropertyKey (JSContext *ctx, JSValue val);
const char *JS_ToCStringLen2 (JSContext *ctx, size_t *plen, JSValue val1, const char *JS_ToCStringLen2 (JSContext *ctx, size_t *plen, JSValue val1, JS_BOOL cesu8);
JS_BOOL cesu8); static inline const char * JS_ToCStringLen (JSContext *ctx, size_t *plen, JSValue val1) {
static inline const char *
JS_ToCStringLen (JSContext *ctx, size_t *plen, JSValue val1) {
return JS_ToCStringLen2 (ctx, plen, val1, 0); return JS_ToCStringLen2 (ctx, plen, val1, 0);
} }
static inline const char * static inline const char * JS_ToCString (JSContext *ctx, JSValue val1) {
JS_ToCString (JSContext *ctx, JSValue val1) {
return JS_ToCStringLen2 (ctx, NULL, val1, 0); return JS_ToCStringLen2 (ctx, NULL, val1, 0);
} }
void JS_FreeCString (JSContext *ctx, const char *ptr); void JS_FreeCString (JSContext *ctx, const char *ptr);
JSValue JS_NewObjectProtoClass (JSContext *ctx, JSValue proto, JSValue JS_NewObjectProtoClass (JSContext *ctx, JSValue proto, JSClassID class_id);
JSClassID class_id);
JSValue JS_NewObjectClass (JSContext *ctx, int class_id); JSValue JS_NewObjectClass (JSContext *ctx, int class_id);
JSValue JS_NewObjectProto (JSContext *ctx, JSValue proto); JSValue JS_NewObjectProto (JSContext *ctx, JSValue proto);
JSValue JS_NewObject (JSContext *ctx); JSValue JS_NewObject (JSContext *ctx);
@@ -825,42 +782,33 @@ typedef union JSCFunctionType {
JSValue JS_NewCFunction2 (JSContext *ctx, JSCFunction *func, const char *name, JSValue JS_NewCFunction2 (JSContext *ctx, JSCFunction *func, const char *name,
int length, JSCFunctionEnum cproto, int magic); int length, JSCFunctionEnum cproto, int magic);
static inline JSValue static inline JSValue JS_NewCFunction (JSContext *ctx, JSCFunction *func, const char *name, int length) {
JS_NewCFunction (JSContext *ctx, JSCFunction *func, const char *name,
int length) {
return JS_NewCFunction2 (ctx, func, name, length, JS_CFUNC_generic, 0); return JS_NewCFunction2 (ctx, func, name, length, JS_CFUNC_generic, 0);
} }
static inline JSValue static inline JSValue JS_NewCFunctionMagic (JSContext *ctx, JSCFunctionMagic *func, const char *name, int length, JSCFunctionEnum cproto, int magic) {
JS_NewCFunctionMagic (JSContext *ctx, JSCFunctionMagic *func, const char *name,
int length, JSCFunctionEnum cproto, int magic) {
return JS_NewCFunction2 (ctx, (JSCFunction *)func, name, length, cproto, return JS_NewCFunction2 (ctx, (JSCFunction *)func, name, length, cproto,
magic); magic);
} }
/* Fixed-arity fast path constructors */ /* Fixed-arity fast path constructors */
static inline JSValue static inline JSValue JS_NewCFuncFixed0 (JSContext *ctx, JSCFunction0 *func, const char *name) {
JS_NewCFuncFixed0 (JSContext *ctx, JSCFunction0 *func, const char *name) {
return JS_NewCFunction2 (ctx, (JSCFunction *)func, name, 0, JS_CFUNC_0, 0); return JS_NewCFunction2 (ctx, (JSCFunction *)func, name, 0, JS_CFUNC_0, 0);
} }
static inline JSValue static inline JSValue JS_NewCFuncFixed1 (JSContext *ctx, JSCFunction1 *func, const char *name) {
JS_NewCFuncFixed1 (JSContext *ctx, JSCFunction1 *func, const char *name) {
return JS_NewCFunction2 (ctx, (JSCFunction *)func, name, 1, JS_CFUNC_1, 0); return JS_NewCFunction2 (ctx, (JSCFunction *)func, name, 1, JS_CFUNC_1, 0);
} }
static inline JSValue static inline JSValue JS_NewCFuncFixed2 (JSContext *ctx, JSCFunction2 *func, const char *name) {
JS_NewCFuncFixed2 (JSContext *ctx, JSCFunction2 *func, const char *name) {
return JS_NewCFunction2 (ctx, (JSCFunction *)func, name, 2, JS_CFUNC_2, 0); return JS_NewCFunction2 (ctx, (JSCFunction *)func, name, 2, JS_CFUNC_2, 0);
} }
static inline JSValue static inline JSValue JS_NewCFuncFixed3 (JSContext *ctx, JSCFunction3 *func, const char *name) {
JS_NewCFuncFixed3 (JSContext *ctx, JSCFunction3 *func, const char *name) {
return JS_NewCFunction2 (ctx, (JSCFunction *)func, name, 3, JS_CFUNC_3, 0); return JS_NewCFunction2 (ctx, (JSCFunction *)func, name, 3, JS_CFUNC_3, 0);
} }
static inline JSValue static inline JSValue JS_NewCFuncFixed4 (JSContext *ctx, JSCFunction4 *func, const char *name) {
JS_NewCFuncFixed4 (JSContext *ctx, JSCFunction4 *func, const char *name) {
return JS_NewCFunction2 (ctx, (JSCFunction *)func, name, 4, JS_CFUNC_4, 0); return JS_NewCFunction2 (ctx, (JSCFunction *)func, name, 4, JS_CFUNC_4, 0);
} }