Support String interpolation

kateinoigakukun · kateinoigakukun · commit 348129ddd7f2 · 2020-03-04T20:35:49.000+09:00
diff --git a/src/swift/Makefile b/src/swift/Makefile
@@ -6,6 +6,7 @@ build: .wasi-sdk/dummy
 	swift build --triple wasm32-unknown-wasi \
 		-Xswiftc -Xclang-linker \
 		-Xswiftc --sysroot=$(WASI_SDK_DIR)/share/wasi-sysroot \
+		-Xcc --sysroot=$(WASI_SDK_DIR)/share/wasi-sysroot \
 		-Xlinker --allow-undefined
 .wasi-sdk/dummy:
 	./script/install-wasi-sdk.sh $(WASI_SDK_DIR)
diff --git a/src/swift/Sources/JavaScriptKit/JSValue.swift b/src/swift/Sources/JavaScriptKit/JSValue.swift
@@ -1,6 +1,6 @@
-public class JSRef {
+public class JSRef: Equatable {
     let id: UInt32
-    init(id: UInt32) {
+    fileprivate init(id: UInt32) {
         self.id = id
     }
     public static func global() -> JSRef {
@@ -10,6 +10,10 @@ public class JSRef {
     deinit {
 
     }
+
+    public static func == (lhs: JSRef, rhs: JSRef) -> Bool {
+        return lhs.id == rhs.id
+    }
 }
 
 public enum JSValue: Equatable {
@@ -31,16 +35,19 @@ import _CJavaScriptKit
 
 public func getJSValue(this: JSRef, name: String) -> JSValue {
     var kind: JavaScriptValueKind = JavaScriptValueKind_Invalid
-    var payload: JavaScriptPayload = 0
-    _get_js_value(this.id, name, Int32(name.count), &kind, &payload)
+    var payload1: JavaScriptPayload = 0
+    var payload2: JavaScriptPayload = 0
+    _get_js_value(this.id, name, Int32(name.count), &kind, &payload1, &payload2)
     switch kind {
     case JavaScriptValueKind_Invalid:
         fatalError()
     case JavaScriptValueKind_Boolean:
-        return .boolean(payload != 0)
+        return .boolean(payload1 != 0)
     case JavaScriptValueKind_String:
-        let ptr = UnsafePointer<UInt8>(bitPattern: UInt(payload))!
-        return .string(String(decodingCString: ptr, as: UTF8.self))
+        let buffer = malloc(Int(payload2))!.assumingMemoryBound(to: UInt8.self)
+        _load_string(payload1 as JavaScriptValueId, buffer)
+        let string = String(decodingCString: UnsafePointer(buffer), as: UTF8.self)
+        return .string(string)
     default:
         fatalError("unreachable")
     }
@@ -56,17 +63,28 @@ public func setJSValue(this: JSRef, name: String, value: JSValue) {
         payload = boolValue ? 1 : 0
     case var .string(stringValue):
         kind = JavaScriptValueKind_String
-        stringValue.withUTF8 { ptr in
-            let ptrValue = unsafeBitCast(ptr, to: UInt32.self)
-            _set_js_value(this.id, name, Int32(name.count), kind, ptrValue)
+        stringValue.withUTF8 { bufferPtr in
+            let ptrValue = UInt32(UInt(bitPattern: bufferPtr.baseAddress!))
+            _set_js_value(this.id, name, Int32(name.count), kind, ptrValue, 0)
         }
         return
     }
-    _set_js_value(this.id, name, Int32(name.count), kind, payload)
+    _set_js_value(this.id, name, Int32(name.count), kind, payload, 0)
 }
 
 
 #if Xcode
-func _set_js_value(_ _this: JavaScriptValueId, _ prop: UnsafePointer<Int8>!, _ length: Int32, _ kind: JavaScriptValueKind, _ value: JavaScriptPayload) { fatalError() }
-func _get_js_value(_ _this: JavaScriptValueId, _ prop: UnsafePointer<Int8>!, _ length: Int32, _ kind: UnsafeMutablePointer<JavaScriptValueKind>!, _ value: UnsafeMutablePointer<JavaScriptPayload>!) {}
+func _set_js_value(
+    _ _this: JavaScriptValueId,
+    _ prop: UnsafePointer<Int8>!, _ length: Int32,
+    _ kind: JavaScriptValueKind,
+    _ payload1: JavaScriptPayload,
+    _ payload2: JavaScriptPayload) { fatalError() }
+func _get_js_value(
+    _ _this: JavaScriptValueId,
+    _ prop: UnsafePointer<Int8>!, _ length: Int32,
+    _ kind: UnsafeMutablePointer<JavaScriptValueKind>!,
+    _ payload1: UnsafeMutablePointer<JavaScriptPayload>!,
+    _ payload2: UnsafeMutablePointer<JavaScriptPayload>!) { fatalError() }
+func _load_string(_ ref: JavaScriptValueId, _ buffer: UnsafeMutablePointer<UInt8>!) { fatalError() }
 #endif
diff --git a/src/swift/Sources/_CJavaScriptKit/include/_CJavaScriptKit.h b/src/swift/Sources/_CJavaScriptKit/include/_CJavaScriptKit.h
@@ -1,12 +1,19 @@
 #ifndef _CJavaScriptKit_h
 #define _CJavaScriptKit_h
 
+#include <stdlib.h>
+
 typedef unsigned int JavaScriptValueId;
 
 typedef enum {
-    JavaScriptValueKind_Invalid = -1,
-    JavaScriptValueKind_Boolean = 0,
-    JavaScriptValueKind_String = 1,
+    JavaScriptValueKind_Invalid  = -1,
+    JavaScriptValueKind_Boolean  = 0,
+    JavaScriptValueKind_String   = 1,
+    JavaScriptValueKind_Number   = 2,
+    JavaScriptValueKind_Object   = 3,
+    JavaScriptValueKind_Array    = 4,
+    JavaScriptValueKind_Null     = 5,
+    JavaScriptValueKind_Function = 6,
 } JavaScriptValueKind;
 
 typedef unsigned JavaScriptPayload;
@@ -23,7 +30,8 @@ extern void _set_js_value(
     const char *prop,
     const int length,
     const JavaScriptValueKind kind,
-    const JavaScriptPayload value
+    const JavaScriptPayload payload1,
+    const JavaScriptPayload payload2
 );
 
 __attribute__((
@@ -35,7 +43,17 @@ extern void _get_js_value(
     const char *prop,
     const int length,
     JavaScriptValueKind *kind,
-    JavaScriptPayload *value
+    JavaScriptPayload *payload1,
+    JavaScriptPayload *payload2
+);
+
+__attribute__((
+    __import_module__("javascript_kit"),
+    __import_name__("swjs_load_string")
+))
+extern void _load_string(
+    const JavaScriptValueId ref,
+    unsigned char *buffer
 );
 
 #endif /* _CJavaScriptKit_h */
diff --git a/src/web/src/index.ts b/src/web/src/index.ts
@@ -5,10 +5,22 @@ interface ExportedMemory {
 type ref = number;
 type pointer = number;
 
-interface GlobalVariable {}
+interface GlobalVariable { }
 declare const window: GlobalVariable;
 declare const global: GlobalVariable;
 
+
+enum JavaScriptValueKind {
+    Invalid = -1,
+    Boolean = 0,
+    String = 1,
+    Number = 2,
+    Object = 3,
+    Array = 4,
+    Null = 5,
+    Function = 6,
+}
+
 export class SwiftRuntime {
     private instance: WebAssembly.Instance | null;
     private _heapValues: any[]
@@ -36,7 +48,16 @@ export class SwiftRuntime {
                 return this.instance.exports.memory as ExportedMemory;
             throw new Error("WebAssembly instance is not set yet");
         }
+
+        const allocValue = (value: any) => {
+            // TODO
+            const id = this._heapValues.length
+            this._heapValues.push(value)
+            return id
+        }
+
         const textDecoder = new TextDecoder('utf-8');
+        const textEncoder = new TextEncoder(); // Only support utf-8
 
         const readString = (ptr: pointer, len: number) => {
             const uint8Memory = new Uint8Array(memory().buffer);
@@ -48,6 +69,15 @@ export class SwiftRuntime {
             return textDecoder.decode(uint8Memory.slice(ptr));
         }
 
+        const writeString = (ptr: pointer, value: string) => {
+            const bytes = textEncoder.encode(value);
+            const uint8Memory = new Uint8Array(memory().buffer);
+            for (const [index, byte] of bytes.entries()) {
+                uint8Memory[ptr + index] = byte
+            }
+            uint8Memory[ptr]
+        }
+
         const writeUint32 = (ptr: pointer, value: number) => {
             const uint8Memory = new Uint8Array(memory().buffer);
             uint8Memory[ptr + 0] = value & 0x000000ff
@@ -56,17 +86,21 @@ export class SwiftRuntime {
             uint8Memory[ptr + 3] = value & 0xff000000
         }
 
-        const decodeValue = (kind: number, payload: number) => {
+        const decodeValue = (kind: JavaScriptValueKind, payload: number) => {
             switch (kind) {
-                case 0: {
+                case JavaScriptValueKind.Boolean: {
                     switch (payload) {
                         case 0: return false
                         case 1: return true
                     }
                 }
-                case 1: {
+                case JavaScriptValueKind.String: {
                     return readStringUntilNull(payload)
                 }
+                case JavaScriptValueKind.Object: {
+                }
+                default:
+                    throw new Error(`Type kind "${kind}" is not supported`)
             }
         }
 
@@ -77,22 +111,32 @@ export class SwiftRuntime {
                         kind: 0,
                         payload: value ? 1 : 0,
                     }
+                case "string": {
+                    return {
+                        kind: JavaScriptValueKind.String,
+                        payload: allocValue(value),
+                    }
+                }
                 default:
                     throw new Error(`Type "${typeof value}" is not supported yet`)
             }
         }
 
         return {
-            swjs_set_js_value: (ref: ref, name: number, length: number, kind: number, payload: number) => {
+            swjs_set_js_value: (ref: ref, name: pointer, length: number, kind: JavaScriptValueKind, payload: number) => {
                 const obj = this._heapValues[ref];
                 Reflect.set(obj, readString(name, length), decodeValue(kind, payload))
             },
-            swjs_get_js_value: (ref: ref, name: number, length: number, kind_ptr: pointer, payload_ptr: pointer) => {
+            swjs_get_js_value: (ref: ref, name: pointer, length: number, kind_ptr: pointer, payload_ptr: pointer) => {
                 const obj = this._heapValues[ref];
                 const result = Reflect.get(obj, readString(name, length));
                 const { kind, payload } = encodeValue(result);
                 writeUint32(kind_ptr, kind);
                 writeUint32(payload_ptr, payload);
+            },
+            swjs_load_string: (ref: ref, buffer: pointer) => {
+                const string = this._heapValues[ref];
+                writeString(buffer, string);
             }
         }
     }
diff --git a/test/JavaScriptKitExec/Sources/JavaScriptKitExec/main.swift b/test/JavaScriptKitExec/Sources/JavaScriptKitExec/main.swift
@@ -1,14 +1,17 @@
 import JavaScriptKit
 
 func expectEqual<T: Equatable>(_ lhs: T, _ rhs: T) {
-    assert(lhs == rhs, "Expect to be equal \"\(lhs)\" and \"\(rhs)\"")
+    if lhs != rhs {
+        print("[ERROR] Expect to be equal \"\(lhs)\" and \"\(rhs)\"")
+    }
 }
 
 let global = JSRef.global()
 do {
     let inputs: [JSValue] = [
         .boolean(true),
         .boolean(false),
+        .string("foobar"),
     ]
     for (index, input) in inputs.enumerated() {
         let prop = "prop_\(index)"
