Initial commit

Author: tonyfreeman

.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj

Package.swift

@@ -0,0 +1,37 @@
+// swift-tools-version:4.0
+/*
+ * Copyright 2017 Tris Foundation and the project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License
+ *
+ * See LICENSE.txt in the project root for license information
+ * See CONTRIBUTORS.txt for the list of the project authors
+ */
+
+import PackageDescription
+
+let package = Package(
+    name: "JavaScript",
+    products: [
+        .library(
+            name: "JavaScriptCore",
+            targets: ["JavaScriptCore"])
+    ],
+    dependencies: [
+        .package(
+            url: "https://github.com/tris-foundation/test.git",
+            .branch("master"))
+    ],
+    targets: [
+        .target(
+            name: "CJavaScriptCore",
+            dependencies: []),
+        .target(
+            name: "JavaScriptCore",
+            dependencies: ["CJavaScriptCore"]),
+        .testTarget(
+            name: "JavaScriptCoreTests",
+            dependencies: ["Test", "JavaScriptCore"])
+    ]
+)

README.md

@@ -0,0 +1,30 @@
+# JavaScript
+
+Linux version of JavaScriptCore written in Swift with closure support.
+
+## Requirements
+
+```bash
+apt install libjavascriptcoregtk-1.0-dev
+```
+
+## Package.swift
+
+```swift
+.package(url: "https://github.com/tris-foundation/javascript.git", .branch("master"))
+```
+
+## Usage
+
+```swift
+let context = JSContext()
+try context.evaluate("40 + 2")
+
+try context.createFunction(name: "getResult") {
+    return .string("result string")
+}
+let result = try context.evaluate("getResult()")
+assertTrue(result.isString)
+assertEqual(try result.toString(), "result string")
+assertEqual("\(result)", "result string")
+```

Sources/CJavaScriptCore/dumb.c

@@ -0,0 +1,16 @@
+/*
+ * Copyright 2017 Tris Foundation and the project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License
+ *
+ * See LICENSE.txt in the project root for license information
+ * See CONTRIBUTORS.txt for the list of the project authors
+ */
+
+#ifndef __JAVASCRIPTCORE_H__
+#define __JAVASCRIPTCORE_H__
+
+#include <JavaScriptCore/JavaScript.h>
+
+#endif

Sources/CJavaScriptCore/include/include.h

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2017 Tris Foundation and the project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License
+ *
+ * See LICENSE.txt in the project root for license information
+ * See CONTRIBUTORS.txt for the list of the project authors
+ */
+
+module CJavaScriptCore [system] {
+    header "include.h"
+    link "javascriptcoregtk-1.0"
+    export *
+}

Sources/CJavaScriptCore/include/module.modulemap

@@ -0,0 +1,118 @@
+/*
+ * Copyright 2017 Tris Foundation and the project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License
+ *
+ * See LICENSE.txt in the project root for license information
+ * See CONTRIBUTORS.txt for the list of the project authors
+ */
+
+import CJavaScriptCore
+import struct Foundation.URL
+
+public class JSContext {
+    let group: JSContextGroupRef
+    let context: JSGlobalContextRef
+    var exception: JSObjectRef? = nil
+
+    var global: JSObjectRef {
+        return JSContextGetGlobalObject(context)!
+    }
+
+    public init() {
+        guard let group = JSContextGroupCreate(),
+            let context = JSGlobalContextCreateInGroup(group, nil) else {
+                fatalError("can't create context")
+        }
+
+        self.group = group
+        self.context = context
+    }
+
+    deinit {
+        JSGlobalContextRelease(context)
+        JSContextGroupRelease(group)
+    }
+
+    @discardableResult
+    public func evaluate(
+        _ script: String,
+        source: String? = nil
+    ) throws -> JSValue {
+        let file = JSStringCreateWithUTF8CString(source)
+        let script = JSStringCreateWithUTF8CString(script)
+        defer {
+            JSStringRelease(file)
+            JSStringRelease(script)
+        }
+        let result = try JSEvaluateScript(context, script, global, file, 0)
+        return JSValue(context: context, pointer: result)
+    }
+
+    @discardableResult
+    public func createFunction(
+        name: String,
+        callback: @escaping JSObjectCallAsFunctionCallback
+    ) throws -> JSObjectRef {
+        let name = JSStringCreateWithUTF8CString(name)
+        defer { JSStringRelease(name) }
+        let function = JSObjectMakeFunctionWithCallback(context, name, callback)
+        try JSObjectSetProperty(context, global, name, function, .none)
+        return function!
+    }
+}
+
+// MARK: register swift closure as javascript function
+
+public enum ReturnValue {
+    case undefined
+    case null
+    case bool(Bool)
+    case number(Double)
+    case string(String)
+}
+
+var functions: [OpaquePointer: [OpaquePointer: () throws -> ReturnValue]] = [:]
+
+extension JSContext {
+    public func createFunction(
+        name: String,
+        _ body: @escaping () throws -> ReturnValue
+    ) throws {
+        let function = try createFunction(name: name, callback: wrapper)
+        functions[global, default: [:]][function] = body
+    }
+}
+
+func wrapper(
+    ctx: JSContextRef!,
+    function: JSObjectRef!,
+    thisObject: JSObjectRef!,
+    argumentCount: Int,
+    arguments: UnsafePointer<JSValueRef?>?,
+    exception: UnsafeMutablePointer<JSValueRef?>?
+) -> JSValueRef? {
+    guard let body = functions[thisObject]?[function] else {
+        if let exception = exception {
+            let error = "swift error: unregistered function"
+            exception.pointee = JSValue(string: error, in: thisObject).pointer
+        }
+        return nil
+    }
+    do {
+        let result = try body()
+        switch result {
+        case .undefined: return JSValueMakeUndefined(ctx)
+        case .null: return JSValueMakeNull(ctx)
+        case .bool(let value): return JSValueMakeBoolean(ctx, value)
+        case .number(let value): return JSValueMakeNumber(ctx, value)
+        case .string(let value): return JSValue(string: value, in: ctx).pointer
+        }
+    } catch {
+        if let exception = exception {
+            exception.pointee = JSValue(string: "\(error)", in: ctx).pointer
+        }
+        return nil
+    }
+}

Sources/JavaScriptCore/JSContext.swift

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2017 Tris Foundation and the project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License
+ *
+ * See LICENSE.txt in the project root for license information
+ * See CONTRIBUTORS.txt for the list of the project authors
+ */
+
+import CJavaScriptCore
+
+public struct JSError: Error, CustomStringConvertible {
+    public var description: String
+
+    init(context: JSContextRef, pointer: JSValueRef) {
+        let value = JSValue(context: context, pointer: pointer)
+        do {
+            self.description = try value.toString()
+        } catch {
+            self.description = "\(error)"
+        }
+    }
+}

Sources/JavaScriptCore/JSError.swift

@@ -0,0 +1,120 @@
+/*
+ * Copyright 2017 Tris Foundation and the project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License
+ *
+ * See LICENSE.txt in the project root for license information
+ * See CONTRIBUTORS.txt for the list of the project authors
+ */
+
+import CJavaScriptCore
+
+public class JSValue {
+    let context: JSContextRef
+    let pointer: JSValueRef
+
+    init(context: JSContextRef, pointer: JSValueRef) {
+        self.context = context
+        self.pointer = pointer
+    }
+
+    init(undefinedIn context: JSContextRef) {
+        self.context = context
+        self.pointer = JSValueMakeUndefined(context)
+    }
+
+    init(bool: Bool, in context: JSContextRef) {
+        self.context = context
+        self.pointer = JSValueMakeBoolean(context, bool)
+    }
+
+    init(number: Double, in context: JSContextRef) {
+        self.context = context
+        self.pointer = JSValueMakeNumber(context, number)
+    }
+
+    init(string: String, in context: JSContextRef) {
+        self.context = context
+        let bytes = [UInt16](string.utf16)
+        let stringRef = JSStringCreateWithCharacters(bytes, bytes.count)
+        self.pointer = JSValueMakeString(context, stringRef)
+    }
+}
+
+extension JSValue {
+    convenience
+    public init(undefinedIn context: JSContext) {
+        self.init(undefinedIn: context.context)
+    }
+
+    convenience
+    public init(bool: Bool, in context: JSContext) {
+        self.init(bool: bool, in: context.context)
+    }
+
+    convenience
+    public init(number: Double, in context: JSContext) {
+        self.init(number: number, in: context.context)
+    }
+
+    convenience
+    public init(string: String, in context: JSContext) {
+        self.init(string: string, in: context.context)
+    }
+}
+
+extension JSValue {
+    public var isNull: Bool {
+        return JSValueIsNull(context, pointer)
+    }
+
+    public var isUndefined: Bool {
+        return JSValueIsUndefined(context, pointer)
+    }
+
+    public var isBool: Bool {
+        return JSValueIsBoolean(context, pointer)
+    }
+
+    public var isNumber: Bool {
+        return JSValueIsNumber(context, pointer)
+    }
+
+    public var isString: Bool {
+        return JSValueIsString(context, pointer)
+    }
+}
+
+extension JSValue {
+    public func toBool() -> Bool {
+        return JSValueToBoolean(context, pointer)
+    }
+
+    public func toDouble() throws -> Double {
+        return try JSValueToNumber(context, pointer)
+    }
+
+    public func toInt() throws -> Int {
+        return Int(try JSValueToNumber(context, pointer))
+    }
+
+    public func toString() throws -> String {
+        let stringRef = try JSValueToStringCopy(context, pointer)
+        defer { JSStringRelease(stringRef) }
+        let len = JSStringGetLength(stringRef)
+        let characters = JSStringGetCharactersPtr(stringRef)
+        let buffer = UnsafeBufferPointer<UInt16>(start: characters!, count: len)
+        return String(decoding: buffer, as: UTF16.self)
+    }
+}
+
+extension JSValue: CustomStringConvertible {
+    public var description: String {
+        do {
+            return try toString()
+        } catch {
+            return "unknown"
+        }
+    }
+}