WIP

Author: kateinoigakukun

IntegrationTests/JavaScriptKitExec/Sources/JavaScriptKitExec/main.swift

@@ -67,6 +67,17 @@ Object_Conversion: do {
     print(error)
 }
 
+Value_Construction: do {
+    let globalObject1 = getJSValue(this: .global, name: "globalObject1")
+    let globalObject1Ref = try expectObject(globalObject1)
+    let prop_7 = getJSValue(this: globalObject1Ref, name: "prop_7")
+    print(prop_7)
+    try expectEqual(Double.construct(from: prop_7), 3.14)
+    try expectEqual(Float.construct(from: prop_7), 3.14)
+} catch {
+    print(error)
+}
+
 Function_Call: do {
     // Notes: globalObject1 is defined in JavaScript environment
     //

IntegrationTests/index.js

@@ -41,7 +41,8 @@ global.globalObject1 = {
     "call_host_1": () => {
       return global.globalObject1.prop_6.host_func_1()
     }
-  }
+  },
+  "prop_7": 3.14,
 }
 
 global.Animal = function(name, age, isCat) {

Runtime/src/index.ts

@@ -102,11 +102,8 @@ export class SwiftRuntime {
             const argv = exports.swjs_prepare_host_function_call(argc)
             for (let index = 0; index < args.length; index++) {
                 const argument = args[index]
-                const value = encodeValue(argument)
-                const base = argv + 12 * index
-                writeUint32(base, value.kind)
-                writeUint32(base + 4, value.payload1)
-                writeUint32(base + 8, value.payload2)
+                const base = argv + 16 * index
+                writeValue(argument, base, base + 4, base + 12)
             }
             let output: any;
             const callback_func_ref = this.heap.allocHeap(function (result: any) {
@@ -142,6 +139,11 @@ export class SwiftRuntime {
                 + (uint8Memory[ptr + 3] << 24)
         }
 
+        const readFloat64 = (ptr: pointer) => {
+            const dataView = new DataView(memory().buffer);
+            return dataView.getFloat64(ptr, true);
+        }
+
         const writeUint32 = (ptr: pointer, value: number) => {
             const uint8Memory = new Uint8Array(memory().buffer);
             uint8Memory[ptr + 0] = (value & 0x000000ff) >> 0
@@ -150,25 +152,30 @@ export class SwiftRuntime {
             uint8Memory[ptr + 3] = (value & 0xff000000) >> 24
         }
 
+        const writeFloat64 = (ptr: pointer, value: number) => {
+            const dataView = new DataView(memory().buffer);
+            dataView.setFloat64(ptr, value, true);
+        }
+
         const decodeValue = (
             kind: JavaScriptValueKind,
-            payload1: number, payload2: number
+            payload1_ptr: pointer, payload2_ptr: pointer
         ) => {
             switch (kind) {
                 case JavaScriptValueKind.Boolean: {
-                    switch (payload1) {
+                    switch (readUInt32(payload1_ptr)) {
                         case 0: return false
                         case 1: return true
                     }
                 }
                 case JavaScriptValueKind.Number: {
-                    return payload1
+                    return readFloat64(payload1_ptr);
                 }
                 case JavaScriptValueKind.String: {
-                    return readString(payload1, payload2)
+                    return readString(readUInt32(payload1_ptr), readUInt32(payload2_ptr))
                 }
                 case JavaScriptValueKind.Object: {
-                    return this.heap.referenceHeap(payload1)
+                    return this.heap.referenceHeap(readUInt32(payload1_ptr))
                 }
                 case JavaScriptValueKind.Null: {
                     return null
@@ -177,80 +184,76 @@ export class SwiftRuntime {
                     return undefined
                 }
                 case JavaScriptValueKind.Function: {
-                    return this.heap.referenceHeap(payload1)
+                    return this.heap.referenceHeap(readUInt32(payload1_ptr))
                 }
                 default:
                     throw new Error(`Type kind "${kind}" is not supported`)
             }
         }
 
-        const encodeValue = (value: any) => {
+        const writeValue = (
+            value: any, kind_ptr: pointer,
+            payload1_ptr: pointer, payload2_ptr: pointer
+        ) => {
             if (value === null) {
-                return {
-                    kind: JavaScriptValueKind.Null,
-                    payload1: 0,
-                    payload2: 0,
-                }
+                writeUint32(kind_ptr, JavaScriptValueKind.Null);
+                writeUint32(payload1_ptr, 0);
+                writeUint32(payload2_ptr, 0);
             }
             switch (typeof value) {
                 case "boolean": {
-                    return {
-                        kind: JavaScriptValueKind.Boolean,
-                        payload1: value ? 1 : 0,
-                        payload2: 0,
-                    }
+                    writeUint32(kind_ptr, JavaScriptValueKind.Boolean);
+                    writeUint32(payload1_ptr, value ? 1 : 0);
+                    writeUint32(payload2_ptr, 0);
+                    break;
                 }
                 case "number": {
-                    return {
-                        kind: JavaScriptValueKind.Number,
-                        payload1: value,
-                        payload2: 0,
-                    }
+                    writeUint32(kind_ptr, JavaScriptValueKind.Number);
+                    writeFloat64(payload1_ptr, value);
+                    writeUint32(payload2_ptr, 0);
+                    break;
                 }
                 case "string": {
+                    // FIXME: currently encode twice
                     const bytes = textEncoder.encode(value);
-                    return {
-                        kind: JavaScriptValueKind.String,
-                        payload1: this.heap.allocHeap(value),
-                        payload2: bytes.length,
-                    }
+                    writeUint32(kind_ptr, JavaScriptValueKind.String);
+                    writeUint32(payload1_ptr, this.heap.allocHeap(value));
+                    writeUint32(payload2_ptr, bytes.length);
+                    break;
                 }
                 case "undefined": {
-                    return {
-                        kind: JavaScriptValueKind.Undefined,
-                        payload1: 0,
-                        payload2: 0,
-                    }
+                    writeUint32(kind_ptr, JavaScriptValueKind.Undefined);
+                    writeUint32(payload1_ptr, 0);
+                    writeUint32(payload2_ptr, 0);
+                    break;
                 }
                 case "object": {
-                    return {
-                        kind: JavaScriptValueKind.Object,
-                        payload1: this.heap.allocHeap(value),
-                        payload2: 0,
-                    }
+                    writeUint32(kind_ptr, JavaScriptValueKind.Object);
+                    writeUint32(payload1_ptr, this.heap.allocHeap(value));
+                    writeUint32(payload2_ptr, 0);
+                    break;
                 }
                 case "function": {
-                    return {
-                        kind: JavaScriptValueKind.Function,
-                        payload1: this.heap.allocHeap(value),
-                        payload2: 0,
-                    }
+                    writeUint32(kind_ptr, JavaScriptValueKind.Function);
+                    writeUint32(payload1_ptr, this.heap.allocHeap(value));
+                    writeUint32(payload2_ptr, 0);
+                    break;
                 }
                 default:
                     throw new Error(`Type "${typeof value}" is not supported yet`)
             }
         }
 
         // Note:
-        // `decodeValues` assumes that the size of RawJSValue is 12
+        // `decodeValues` assumes that the size of RawJSValue is 16
         // and the alignment of it is 4
         const decodeValues = (ptr: pointer, length: number) => {
             let result = []
             for (let index = 0; index < length; index++) {
-                const base = ptr + 12 * index
+                const base = ptr + 16 * index
                 const kind = readUInt32(base)
-                const payload1 = readUInt32(base + 4)
-                const payload2 = readUInt32(base + 8)
+                const payload1 = readFloat64(base + 4)
+                const payload2 = readUInt32(base + 12)
                 result.push(decodeValue(kind, payload1, payload2))
             }
             return result
@@ -272,10 +275,7 @@ export class SwiftRuntime {
             ) => {
                 const obj = this.heap.referenceHeap(ref);
                 const result = Reflect.get(obj, readString(name, length));
-                const { kind, payload1, payload2 } = encodeValue(result);
-                writeUint32(kind_ptr, kind);
-                writeUint32(payload1_ptr, payload1);
-                writeUint32(payload2_ptr, payload2);
+                writeValue(result, kind_ptr, payload1_ptr, payload2_ptr);
             },
             swjs_set_subscript: (
                 ref: ref, index: number,
@@ -292,10 +292,7 @@ export class SwiftRuntime {
             ) => {
                 const obj = this.heap.referenceHeap(ref);
                 const result = Reflect.get(obj, index);
-                const { kind, payload1, payload2 } = encodeValue(result);
-                writeUint32(kind_ptr, kind);
-                writeUint32(payload1_ptr, payload1);
-                writeUint32(payload2_ptr, payload2);
+                writeValue(result, kind_ptr, payload1_ptr, payload2_ptr);
             },
             swjs_load_string: (ref: ref, buffer: pointer) => {
                 const string = this.heap.referenceHeap(ref);
@@ -308,10 +305,7 @@ export class SwiftRuntime {
             ) => {
                 const func = this.heap.referenceHeap(ref)
                 const result = Reflect.apply(func, undefined, decodeValues(argv, argc))
-                const { kind, payload1, payload2 } = encodeValue(result);
-                writeUint32(kind_ptr, kind);
-                writeUint32(payload1_ptr, payload1);
-                writeUint32(payload2_ptr, payload2);
+                writeValue(result, kind_ptr, payload1_ptr, payload2_ptr);
             },
             swjs_call_function_with_this: (
                 obj_ref: ref, func_ref: ref,
@@ -322,10 +316,7 @@ export class SwiftRuntime {
                 const obj = this.heap.referenceHeap(obj_ref)
                 const func = this.heap.referenceHeap(func_ref)
                 const result = Reflect.apply(func, obj, decodeValues(argv, argc))
-                const { kind, payload1, payload2 } = encodeValue(result);
-                writeUint32(kind_ptr, kind);
-                writeUint32(payload1_ptr, payload1);
-                writeUint32(payload2_ptr, payload2);
+                writeValue(result, kind_ptr, payload1_ptr, payload2_ptr);
             },
             swjs_create_function: (
                 host_func_id: number,

Sources/JavaScriptKit/JSFunction.swift

@@ -44,7 +44,7 @@ public class JSFunctionRef: JSObjectRef {
             rawValues.withUnsafeBufferPointer { bufferPointer in
                 let argv = bufferPointer.baseAddress
                 let argc = bufferPointer.count
-                var resultObj = JavaScriptPayload()
+                var resultObj = JavaScriptObjectRef()
                 _call_new(
                     self.id, argv, Int32(argc),
                     &resultObj
@@ -85,7 +85,7 @@ public func _cleanup_host_function_call(_ pointer: UnsafeMutableRawPointer) {
 public func _call_host_function(
     _ hostFuncRef: JavaScriptHostFuncRef,
     _ argv: UnsafePointer<RawJSValue>, _ argc: Int32,
-    _ callbackFuncRef: JavaScriptPayload) {
+    _ callbackFuncRef: JavaScriptObjectRef) {
     let hostFunc = JSFunctionRef.sharedFunctions[Int(hostFuncRef)]
     let args = UnsafeBufferPointer(start: argv, count: Int(argc)).map {
         $0.jsValue()

Sources/JavaScriptKit/JSValueConvertible.swift

@@ -69,23 +69,24 @@ extension RawJSValue: JSValueConvertible {
         case JavaScriptValueKind_Boolean:
             return .boolean(payload1 != 0)
         case JavaScriptValueKind_Number:
-            return .number(Int32(bitPattern: payload1))
+            fatalError("unimplemented yet")
+//            return .number(Int32(bitPattern: payload1))
         case JavaScriptValueKind_String:
             // +1 for null terminator
             let buffer = malloc(Int(payload2 + 1))!.assumingMemoryBound(to: UInt8.self)
             defer { free(buffer) }
-            _load_string(payload1 as JavaScriptObjectRef, buffer)
+            _load_string(JavaScriptObjectRef(payload1), buffer)
             buffer[Int(payload2)] = 0
             let string = String(decodingCString: UnsafePointer(buffer), as: UTF8.self)
             return .string(string)
         case JavaScriptValueKind_Object:
-            return .object(JSObjectRef(id: payload1))
+            return .object(JSObjectRef(id: UInt32(payload1)))
         case JavaScriptValueKind_Null:
             return .null
         case JavaScriptValueKind_Undefined:
             return .undefined
         case JavaScriptValueKind_Function:
-            return .function(JSFunctionRef(id: payload1))
+            return .function(JSFunctionRef(id: UInt32(payload1)))
         default:
             fatalError("unreachable")
         }
@@ -95,27 +96,28 @@ extension RawJSValue: JSValueConvertible {
 extension JSValue {
     func withRawJSValue<T>(_ body: (RawJSValue) -> T) -> T {
         let kind: JavaScriptValueKind
-        let payload1: JavaScriptPayload
-        let payload2: JavaScriptPayload
+        let payload1: JavaScriptPayload1
+        let payload2: JavaScriptPayload2
         switch self {
         case let .boolean(boolValue):
             kind = JavaScriptValueKind_Boolean
             payload1 = boolValue ? 1 : 0
             payload2 = 0
         case let .number(numberValue):
-            kind = JavaScriptValueKind_Number
-            payload1 = JavaScriptPayload(bitPattern: numberValue)
-            payload2 = 0
+            fatalError("unimplemented yet")
+//            kind = JavaScriptValueKind_Number
+//            payload1 = JavaScriptPayload1(bitPattern: numberValue)
+//            payload2 = 0
         case var .string(stringValue):
             kind = JavaScriptValueKind_String
             return stringValue.withUTF8 { bufferPtr in
                 let ptrValue = UInt32(UInt(bitPattern: bufferPtr.baseAddress!))
-                let rawValue = RawJSValue(kind: kind, payload1: ptrValue, payload2: JavaScriptPayload(bufferPtr.count))
+                let rawValue = RawJSValue(kind: kind, payload1: JavaScriptPayload1(ptrValue), payload2: JavaScriptPayload2(bufferPtr.count))
                 return body(rawValue)
             }
         case let .object(ref):
             kind = JavaScriptValueKind_Object
-            payload1 = ref.id
+            payload1 = JavaScriptPayload1(ref.id)
             payload2 = 0
         case .null:
             kind = JavaScriptValueKind_Null
@@ -127,7 +129,7 @@ extension JSValue {
             payload2 = 0
         case let .function(functionRef):
             kind = JavaScriptValueKind_Function
-            payload1 = functionRef.id
+            payload1 = JavaScriptPayload1(functionRef.id)
             payload2 = 0
         }
         let rawValue = RawJSValue(kind: kind, payload1: payload1, payload2: payload2)