MSVC compatibility #16

c-smile · 2020-10-12T00:36:03Z

General MSVC compatibility.
CONFIG_VERSION (too common/generic) replaced by QUICKJS_VERSION due to clashes with other libraries that use CONFIG_VERSION too
premake5 script - allows to generate makefile's, cmakes, VS project, XCode project, Code::Block, etc. Try premake5 gmake2 in sources directory.
3.a premake5.lua script generates quickjs-version.h file from VERSION file.

1. MSVC compatibility 2. CONFIG_VERSION (too common/generic) replaced by QUICKJS_VERSION due to clashes with other libraries that use CONFIG_VERSION too

JS_STRICT_NAN_BOXING option allows compact packaging for 32 **and ** 64 bit versions. JS_STRICT_NAN_BOXING is the only option that enables x64 builds using MSVC

RGFTheCoder · 2020-10-17T01:42:26Z

Send this to the mailing list. He doesn't accept pull requests

c-smile · 2020-10-17T02:53:46Z

Umm... "this" here is what exactly? diff files ?

andrewrch · 2020-10-18T07:51:14Z

You can add .patch to a pull request URL to get a patch and then send that to the mailing list, e.g

https://github.com/bellard/quickjs/pull/16.patch

Typos

past-due · 2020-11-01T20:07:31Z

@c-smile: 2ead907 seems to break QuickJS behavior - even in x86 / Win32 compiles, if JS_STRICT_NAN_BOXING is defined. (I'm trying to track down specifics now.) Any thoughts?

(I'm comparing a QuickJS x86 build with only 4298c1a applied, versus a QuickJS x86 build with 4298c1a and 2ead907 applied. The latter yields incorrect behavior for a complex series of scripts embedded in an open-source game.)

c-smile · 2020-11-01T21:25:41Z

I do not see any problems yet with that variant of nan-boxing. I am using that variant in Sciter.JS. So far it runs Mithril and some other pretty big JS libraries as they are.

So I need more details.

past-due · 2020-11-01T23:29:47Z

@c-smile: Thanks - was wondering if you'd come across any quirks. I will look into coming up with a minimal repro case when I have a chance.

In the interim, here is a potential alternative to your JS_STRICT_NAN_BOXING patch for MSVC 64-bit compatibility:

diff --git a/quickjs.c b/quickjs.c
--- a/3rdparty/quickjs/quickjs.c
+++ b/3rdparty/quickjs/quickjs.c
@@ -7212,7 +7212,7 @@ static int JS_DefinePrivateField(JSContext *ctx, JSValueConst obj,
         JS_ThrowTypeErrorNotASymbol(ctx);
         goto fail;
     }
-    prop = js_symbol_to_atom(ctx, (JSValue)name);
+    prop = js_symbol_to_atom(ctx, JS_VALUE_CONST_CAST(name));
     p = JS_VALUE_GET_OBJ(obj);
     prs = find_own_property(&pr, p, prop);
     if (prs) {
@@ -7243,7 +7243,7 @@ static JSValue JS_GetPrivateField(JSContext *ctx, JSValueConst obj,
     /* safety check */
     if (unlikely(JS_VALUE_GET_TAG(name) != JS_TAG_SYMBOL))
         return JS_ThrowTypeErrorNotASymbol(ctx);
-    prop = js_symbol_to_atom(ctx, (JSValue)name);
+    prop = js_symbol_to_atom(ctx, JS_VALUE_CONST_CAST(name));
     p = JS_VALUE_GET_OBJ(obj);
     prs = find_own_property(&pr, p, prop);
     if (!prs) {
@@ -7270,7 +7270,7 @@ static int JS_SetPrivateField(JSContext *ctx, JSValueConst obj,
         JS_ThrowTypeErrorNotASymbol(ctx);
         goto fail;
     }
-    prop = js_symbol_to_atom(ctx, (JSValue)name);
+    prop = js_symbol_to_atom(ctx, JS_VALUE_CONST_CAST(name));
     p = JS_VALUE_GET_OBJ(obj);
     prs = find_own_property(&pr, p, prop);
     if (!prs) {
@@ -7360,7 +7360,7 @@ static int JS_CheckBrand(JSContext *ctx, JSValueConst obj, JSValueConst func)
     if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT))
         goto not_obj;
     p = JS_VALUE_GET_OBJ(obj);
-    prs = find_own_property(&pr, p, js_symbol_to_atom(ctx, (JSValue)brand));
+    prs = find_own_property(&pr, p, js_symbol_to_atom(ctx, JS_VALUE_CONST_CAST(brand)));
     if (!prs) {
         JS_ThrowTypeError(ctx, "invalid brand on object");
         return -1;
@@ -15954,7 +15954,7 @@ static JSValue js_call_c_function(JSContext *ctx, JSValueConst func_obj,
 #else
     sf->js_mode = 0;
 #endif
-    sf->cur_func = (JSValue)func_obj;
+    sf->cur_func = JS_VALUE_CONST_CAST(func_obj);
     sf->arg_count = argc;
     arg_buf = argv;
 
@@ -16198,7 +16198,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
     sf->js_mode = b->js_mode;
     arg_buf = argv;
     sf->arg_count = argc;
-    sf->cur_func = (JSValue)func_obj;
+    sf->cur_func = JS_VALUE_CONST_CAST(func_obj);
     init_list_head(&sf->var_ref_list);
     var_refs = p->u.func.var_refs;
 
@@ -38865,8 +38865,8 @@ static int64_t JS_FlattenIntoArray(JSContext *ctx, JSValueConst target,
         if (!JS_IsUndefined(mapperFunction)) {
             JSValueConst args[3] = { element, JS_NewInt64(ctx, sourceIndex), source };
             element = JS_Call(ctx, mapperFunction, thisArg, 3, args);
-            JS_FreeValue(ctx, (JSValue)args[0]);
-            JS_FreeValue(ctx, (JSValue)args[1]);
+            JS_FreeValue(ctx, JS_VALUE_CONST_CAST(args[0]));
+            JS_FreeValue(ctx, JS_VALUE_CONST_CAST(args[1]));
             if (JS_IsException(element))
                 return -1;
         }
@@ -40324,7 +40324,7 @@ static JSValue js_string_match(JSContext *ctx, JSValueConst this_val,
         str = JS_NewString(ctx, "g");
         if (JS_IsException(str))
             goto fail;
-        args[args_len++] = (JSValueConst)str;
+        args[args_len++] = JS_VALUE_MAKE_CONST(str);
     }
     rx = JS_CallConstructor(ctx, ctx->regexp_ctor, args_len, args);
     JS_FreeValue(ctx, str);
@@ -45354,7 +45354,7 @@ static JSMapRecord *map_add_record(JSContext *ctx, JSMapState *s,
     } else {
         JS_DupValue(ctx, key);
     }
-    mr->key = (JSValue)key;
+    mr->key = JS_VALUE_CONST_CAST(key);
     h = map_hash_key(ctx, key) & (s->hash_size - 1);
     list_add_tail(&mr->hash_link, &s->hash_table[h]);
     list_add_tail(&mr->link, &s->records);
@@ -45576,7 +45576,7 @@ static JSValue js_map_forEach(JSContext *ctx, JSValueConst this_val,
                 args[0] = args[1];
             else
                 args[0] = JS_DupValue(ctx, mr->value);
-            args[2] = (JSValue)this_val;
+            args[2] = JS_VALUE_CONST_CAST(this_val);
             ret = JS_Call(ctx, func, this_arg, 3, (JSValueConst *)args);
             JS_FreeValue(ctx, args[0]);
             if (!magic)
@@ -46554,7 +46554,7 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
                 goto fail_reject;
             }
             resolve_element_data[0] = JS_NewBool(ctx, FALSE);
-            resolve_element_data[1] = (JSValueConst)JS_NewInt32(ctx, index);
+            resolve_element_data[1] = JS_VALUE_MAKE_CONST(JS_NewInt32(ctx, index));
             resolve_element_data[2] = values;
             resolve_element_data[3] = resolving_funcs[is_promise_any];
             resolve_element_data[4] = resolve_element_env;
@@ -46924,7 +46924,7 @@ static JSValue js_async_from_sync_iterator_unwrap_func_create(JSContext *ctx,
 {
     JSValueConst func_data[1];
 
-    func_data[0] = (JSValueConst)JS_NewBool(ctx, done);
+    func_data[0] = JS_VALUE_MAKE_CONST(JS_NewBool(ctx, done));
     return JS_NewCFunctionData(ctx, js_async_from_sync_iterator_unwrap,
                                1, 0, 1, func_data);
 }
@@ -52279,8 +52279,8 @@ static int js_TA_cmp_generic(const void *a, const void *b, void *opaque) {
             psc->exception = 1;
         }
     done:
-        JS_FreeValue(ctx, (JSValue)argv[0]);
-        JS_FreeValue(ctx, (JSValue)argv[1]);
+        JS_FreeValue(ctx, JS_VALUE_CONST_CAST(argv[0]));
+        JS_FreeValue(ctx, JS_VALUE_CONST_CAST(argv[1]));
     }
     return cmp;
 }
diff --git a/quickjs.h b/quickjs.h
--- a/3rdparty/quickjs/quickjs.h
+++ b/3rdparty/quickjs/quickjs.h
@@ -105,6 +105,8 @@ typedef struct JSRefCountHeader {
    for objective C) */
 typedef struct __JSValue *JSValue;
 typedef const struct __JSValue *JSValueConst;
+#define JS_VALUE_CONST_CAST(cVal) (JSValue)cVal
+#define JS_VALUE_MAKE_CONST(val) (JSValueConst)val
 
 #define JS_VALUE_GET_TAG(v) (int)((uintptr_t)(v) & 0xf)
 /* same as JS_VALUE_GET_TAG, but return JS_TAG_FLOAT64 with NaN boxing */
@@ -136,6 +138,8 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
 typedef uint64_t JSValue;
 
 #define JSValueConst JSValue
+#define JS_VALUE_CONST_CAST(cVal) cVal
+#define JS_VALUE_MAKE_CONST(val) val
 
 #define JS_VALUE_GET_TAG(v) (int)((v) >> 32)
 #define JS_VALUE_GET_INT(v) (int)(v)
@@ -201,7 +205,7 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
 typedef union JSValueUnion {
     int32_t int32;
     double float64;
-    void *ptr;
+    uintptr_t ptr;
 } JSValueUnion;
 
 typedef struct JSValue {
@@ -210,6 +214,8 @@ typedef struct JSValue {
 } JSValue;
 
 #define JSValueConst JSValue
+#define JS_VALUE_CONST_CAST(cVal) cVal
+#define JS_VALUE_MAKE_CONST(val) val
 
 #define JS_VALUE_GET_TAG(v) ((int32_t)(v).tag)
 /* same as JS_VALUE_GET_TAG, but return JS_TAG_FLOAT64 with NaN boxing */
@@ -217,10 +223,10 @@ typedef struct JSValue {
 #define JS_VALUE_GET_INT(v) ((v).u.int32)
 #define JS_VALUE_GET_BOOL(v) ((v).u.int32)
 #define JS_VALUE_GET_FLOAT64(v) ((v).u.float64)
-#define JS_VALUE_GET_PTR(v) ((v).u.ptr)
+#define JS_VALUE_GET_PTR(v) ((void *)((v).u.ptr))
 
 #define JS_MKVAL(tag, val) (JSValue){ (JSValueUnion){ .int32 = val }, tag }
-#define JS_MKPTR(tag, p) (JSValue){ (JSValueUnion){ .ptr = p }, tag }
+#define JS_MKPTR(tag, p) (JSValue){ (JSValueUnion){ .ptr = (uintptr_t)(void *)p }, tag }
 
 #define JS_TAG_IS_FLOAT64(tag) ((unsigned)(tag) == JS_TAG_FLOAT64)
 
@@ -675,7 +681,7 @@ static inline JSValue JS_DupValue(JSContext *ctx, JSValueConst v)
         JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
         p->ref_count++;
     }
-    return (JSValue)v;
+    return JS_VALUE_CONST_CAST(v);
 }
 
 static inline JSValue JS_DupValueRT(JSRuntime *rt, JSValueConst v)
@@ -684,7 +690,7 @@ static inline JSValue JS_DupValueRT(JSRuntime *rt, JSValueConst v)
         JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
         p->ref_count++;
     }
-    return (JSValue)v;
+    return JS_VALUE_CONST_CAST(v);
 }
 
 int JS_ToBool(JSContext *ctx, JSValueConst val); /* return -1 for JS_EXCEPTION */

c-smile · 2020-11-01T23:59:28Z

Yes, that's what I started from. But realized that 128 bits for value is too much. Yet exactly half of them are used at any given time. Note that x64 uses 48 bits for address max.

Note that with JS_STRICT_NAN_BOXING JS_UNINITIALIZED value is exactly zero - uint64(0).
In original version uint64(0) is JSValue of type integer - int32(0).

Check if your code initializes JSValue storages properly.

past-due · 2020-11-02T14:24:04Z

@c-smile: Please try the following Javascript with the current JS_STRICT_NAN_BOXING defined:

var valInfinity = Infinity;
var valLessThanInfinity = 0.5;
if (valLessThanInfinity < valInfinity) {
	console.log("Less than infinity");
} else {
	console.log("???"); // this is what I see output with JS_STRICT_NAN_BOXING defined
}

c-smile · 2020-11-02T15:57:14Z

Oh, thanks a lot.

Fixed by c-smile@95e55eb

past-due · 2020-11-02T16:33:45Z

👍

Yes, that's what I started from. But realized that 128 bits for value is too much. Yet exactly half of them are used at any given time. Note that x64 uses 48 bits for address max.

Also just a quick note, of which you may already be aware: Intel has announced PML5, yielding (potentially) 57-bit virtual addresses on x64 (if the OS chooses to support+enable it, on supported hardware).

c-smile · 2020-11-02T21:16:03Z

Intel has announced PML5

On such systems, indeed, we would not worry about 128 bits for true | false and so it will be "plan B"

This change enables "named parameters call", consider this code ``` function foo(obj) { console.log(obj); } foo {bar:"bar"}; ``` The above is equivalent of ``` foo ({bar:"bar"}); ``` that is function call with single argument - object literal. Just tiread of writing those brackets....

<Foo /> - upper case tags are treated as functional or class components. So this ``` <Foo /> ``` will lead to call : JSX(Foo,{},[]);

JS_Eval2 is needed when JS is embedded into other files like HTML: ``` <head> <script> // line 10 ( for example ) // some script here </script> ``` so errors are reported properly.

…sertion" rules in JS

Alhadis · 2021-03-30T17:22:47Z

@c-smile The changes proposed here are huge and quite specific (JSX is not ECMAScript). IMHO, you're better off making a fork called quickjsx or something.

Moreover, @bellard has made it quite clear that patches are to be submitted to the mailing-list. As in, e-mailing this as a file attachment named msvc.patch or whatever. Though don't be surprised if 4.0 MBs worth of changes gets rejected…

ekibun · 2021-04-01T14:55:58Z

Hi, I've tried to add stack check for msvc as follow. It works fine in my case, but I'm not sure the replacement is correct.

static inline uintptr_t js_get_stack_pointer(void)
{
+ #ifdef _MSC_VER
+    return _AddressOfReturnAddress();
+ #else
    return (uintptr_t)__builtin_frame_address(0);
+ #endif
 }

see https://stackoverflow.com/a/22086803

fix: compile error on Windows

fix: linux compile

feat: update test262.conf and addci yml

* Implements getQuickJSImmediate * Update quickjs.ts * Prettier

Limit passing compiler specific flags when that compiler is used

Allow the use of native modules on MinGW.

c-smile added 3 commits October 11, 2020 17:26

MSVC compatibility

4298c1a

1. MSVC compatibility 2. CONFIG_VERSION (too common/generic) replaced by QUICKJS_VERSION due to clashes with other libraries that use CONFIG_VERSION too

README.md added

a953bfc

JS_STRICT_NAN_BOXING

2ead907

JS_STRICT_NAN_BOXING option allows compact packaging for 32 **and ** 64 bit versions. JS_STRICT_NAN_BOXING is the only option that enables x64 builds using MSVC

c-smile and others added 10 commits October 20, 2020 20:23

fixes issue in var [a,b,c,d] = ... destructuring assignment

a37183d

Update .gitignore

3b661bc

gitignore

a0a4315

gitignore

a60f3b0

JSX implementation

43198ce

Update README.md

4b6d73f

Update README.md

b428495

Update README.md

b7352f1

Typos

4663592

Merge pull request #1 from 4silvertooth/patch-1

e682f63

Typos

kvenux mentioned this pull request Nov 2, 2020

stack-overflow at quickjs.c:31754 #8

Closed

Fix of Infinity handling

95e55eb

c-smile added 4 commits November 8, 2020 14:55

JSX: support of components

3e2984f

<Foo /> - upper case tags are treated as functional or class components. So this ``` <Foo /> ``` will lead to call : JSX(Foo,{},[]);

+ JS_Eval2 function is JS_Eval with line_no parameters

810b6f0

JS_Eval2 is needed when JS is embedded into other files like HTML: ``` <head> <script> // line 10 ( for example ) // some script here </script> ``` so errors are reported properly.

reverted "call by object" feature due to wild "automatic semicolon in…

cd64917

…sertion" rules in JS

c-smile added 8 commits March 1, 2021 20:56

Update README.md

7464a56

Update architecture.md

01c5a4f

Update architecture.md

4ee9cdc

Update Storage.md

0820493

Update Storage.md

fe8d555

Update architecture.md

b5e802a

JSX fixes + JS Debugger hooks (as used in Sciter.JS Inspector)

cf9901f

Merge branch 'master' of https://github.com/c-smile/quickjspp

35f5a29

c-smile and others added 12 commits April 25, 2021 14:25

Sync with QuickJS v. 2021-03-27

e5d2b16

Persistence fixes.

d1ea93e

[persistence] Fix of AV when storage was not closed explicitly.

25f545f

Update README.md

573d8b6

MSVC compatibility / x64

2488030

Merge branch 'master' of https://github.com/c-smile/quickjspp

c8f45cb

GCC compatibility.

121dca5

fix: compile error on Windows

2af70e4

fix: output exe to platform directory

4c9988f

Merge pull request #4 from c0i/dev

2902f49

fix: compile error on Windows

fix: linux compile

655c88b

Merge pull request #5 from c0i/fix_linux_compile

a2ce903

fix: linux compile

cykoder pushed a commit to cykoder/quickjs that referenced this pull request Sep 1, 2023

Merge pull request bellard#16 from openwebf/feat/ci

def36ef

feat: update test262.conf and addci yml

GerHobbelt pushed a commit to GerHobbelt/quickjs that referenced this pull request Oct 17, 2023

Implements getQuickJSImmediate (bellard#16)

5bad6cf

* Implements getQuickJSImmediate * Update quickjs.ts * Prettier

iongion and others added 2 commits March 17, 2024 19:50

Limit passic compiler specific flags when that compiler is used

29ee70e

Merge pull request #6 from iongion/fix-linux-compilation

2519e1a

Limit passing compiler specific flags when that compiler is used

metarutaiga mentioned this pull request May 23, 2024

Fix JSValue casting #307

Open

DenisBelmondo and others added 3 commits June 17, 2024 22:13

Allow the use of native modules when using MinGW.

4be286c

Add platform-specific native module suffixes.

0575c08

Merge pull request #7 from DenisBelmondo/allow-dl-on-mingw

aef8e4e

Allow the use of native modules on MinGW.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

MSVC compatibility #16

MSVC compatibility #16

c-smile commented Oct 12, 2020

RGFTheCoder commented Oct 17, 2020

c-smile commented Oct 17, 2020

andrewrch commented Oct 18, 2020

past-due commented Nov 1, 2020

c-smile commented Nov 1, 2020

past-due commented Nov 1, 2020

c-smile commented Nov 1, 2020

past-due commented Nov 2, 2020 •

edited

Loading

c-smile commented Nov 2, 2020

past-due commented Nov 2, 2020 •

edited

Loading

c-smile commented Nov 2, 2020

Alhadis commented Mar 30, 2021

ekibun commented Apr 1, 2021

MSVC compatibility #16

Are you sure you want to change the base?

MSVC compatibility #16

Conversation

c-smile commented Oct 12, 2020

RGFTheCoder commented Oct 17, 2020

c-smile commented Oct 17, 2020

andrewrch commented Oct 18, 2020

past-due commented Nov 1, 2020

c-smile commented Nov 1, 2020

past-due commented Nov 1, 2020

c-smile commented Nov 1, 2020

past-due commented Nov 2, 2020 • edited Loading

c-smile commented Nov 2, 2020

past-due commented Nov 2, 2020 • edited Loading

c-smile commented Nov 2, 2020

Alhadis commented Mar 30, 2021

ekibun commented Apr 1, 2021

past-due commented Nov 2, 2020 •

edited

Loading

past-due commented Nov 2, 2020 •

edited

Loading