compilekv 0.0.0__tar.gz

compilekv-0.0.0/CompileKvWasm/Package.swift

@@ -0,0 +1,27 @@
+// swift-tools-version: 6.2
+import PackageDescription
+
+let package = Package(
+    name: "CompileKvWasm",
+    platforms: [
+        .macOS(.v13)
+    ],
+    products: [
+        .executable(
+            name: "CompileKvWasm",
+            targets: ["CompileKvWasm"]
+        )
+    ],
+    dependencies: [
+        .package(path: "../KvToPyClass")
+    ],
+    targets: [
+        .executableTarget(
+            name: "CompileKvWasm",
+            dependencies: [
+                .product(name: "KvToPyClass", package: "KvToPyClass")
+            ],
+            path: "Sources/CompileKvWasm"
+        )
+    ]
+)

compilekv-0.0.0/CompileKvWasm/Sources/CompileKvWasm/Conversion.swift

@@ -0,0 +1,27 @@
+import Foundation
+import KvParser
+import KvToPyClass
+
+/// Convert KV source to Python. `pySource` is the existing .py, or empty.
+/// `constantsSource` holds `#:set` directives gathered from other KV files.
+func convert(kvSource: String, pySource: String, constantsSource: String = "") throws -> String {
+    let module = try parse(kvSource)
+
+    let existing = pySource.isEmpty
+        ? PythonModuleInfo(body: [], classes: [])
+        : PythonClassParser(source: pySource).parseModule()
+
+    // Directives the file declares itself win over the shared ones.
+    let shared = constantsSource.isEmpty ? [] : (try? parse(constantsSource))?.directives ?? []
+
+    return try KvToPyClassGenerator(
+        module: module,
+        existing: existing,
+        sharedDirectives: shared
+    ).generate()
+}
+
+private func parse(_ source: String) throws -> KvModule {
+    let tokens = try KvTokenizer(source: source).tokenize()
+    return try KvParser(tokens: tokens).parse()
+}

compilekv-0.0.0/CompileKvWasm/Sources/CompileKvWasm/Exports.swift

@@ -0,0 +1,89 @@
+import Foundation
+
+// Wasm can only pass numbers, so strings travel as (pointer, length) into
+// linear memory. The host allocates with kv_alloc, calls kv_convert, then reads
+// the result through kv_result_ptr/kv_result_len and releases it.
+
+private nonisolated(unsafe) var resultBuffer: UnsafeMutableRawPointer?
+private nonisolated(unsafe) var resultCount: Int32 = 0
+
+private func storeResult(_ string: String) {
+    freeResult()
+    let utf8 = Array(string.utf8)
+    guard !utf8.isEmpty else { return }
+    let buffer = UnsafeMutableRawPointer.allocate(byteCount: utf8.count, alignment: 1)
+    utf8.withUnsafeBytes { buffer.copyMemory(from: $0.baseAddress!, byteCount: utf8.count) }
+    resultBuffer = buffer
+    resultCount = Int32(utf8.count)
+}
+
+private func freeResult() {
+    resultBuffer?.deallocate()
+    resultBuffer = nil
+    resultCount = 0
+}
+
+private func string(from pointer: UnsafeRawPointer?, length: Int32) -> String {
+    guard let pointer, length > 0 else { return "" }
+    return String(decoding: UnsafeRawBufferPointer(start: pointer, count: Int(length)), as: UTF8.self)
+}
+
+@_expose(wasm, "kv_alloc")
+@_cdecl("kv_alloc")
+public func kv_alloc(_ size: Int32) -> UnsafeMutableRawPointer? {
+    guard size > 0 else { return nil }
+    return UnsafeMutableRawPointer.allocate(byteCount: Int(size), alignment: 1)
+}
+
+@_expose(wasm, "kv_dealloc")
+@_cdecl("kv_dealloc")
+public func kv_dealloc(_ pointer: UnsafeMutableRawPointer?, _ size: Int32) {
+    pointer?.deallocate()
+}
+
+/// Returns 0 on success, 1 on failure. Either way the result buffer holds the
+/// generated code or the error description.
+///
+/// `constants` carries `#:set` directives from other KV files. They are passed
+/// separately rather than pasted onto the front of the source so parser error
+/// line numbers still match the file the caller is looking at.
+@_expose(wasm, "kv_convert")
+@_cdecl("kv_convert")
+public func kv_convert(
+    _ kvPointer: UnsafeRawPointer?,
+    _ kvLength: Int32,
+    _ pyPointer: UnsafeRawPointer?,
+    _ pyLength: Int32,
+    _ constantsPointer: UnsafeRawPointer?,
+    _ constantsLength: Int32
+) -> Int32 {
+    do {
+        storeResult(try convert(
+            kvSource: string(from: kvPointer, length: kvLength),
+            pySource: string(from: pyPointer, length: pyLength),
+            constantsSource: string(from: constantsPointer, length: constantsLength)
+        ))
+        return 0
+    } catch {
+        storeResult("\(error)")
+        return 1
+    }
+}
+
+@_expose(wasm, "kv_result_ptr")
+@_cdecl("kv_result_ptr")
+public func kv_result_ptr() -> UnsafeMutableRawPointer? {
+    resultBuffer
+}
+
+@_expose(wasm, "kv_result_len")
+@_cdecl("kv_result_len")
+public func kv_result_len() -> Int32 {
+    resultCount
+}
+
+@_expose(wasm, "kv_result_free")
+@_cdecl("kv_result_free")
+public func kv_result_free() {
+    freeResult()
+}

compilekv-0.0.0/CompileKvWasm/Sources/CompileKvWasm/main.swift

@@ -0,0 +1,2 @@
+// Built as a reactor: the host calls `_initialize`, then the exports in
+// Exports.swift. SwiftPM still wants an entry point, so this stays empty.

compilekv-0.0.0/KvToPyClass/Package.swift

@@ -0,0 +1,54 @@
+// swift-tools-version: 6.2
+import PackageDescription
+
+let package = Package(
+    name: "KvToPyClass",
+    platforms: [
+        .macOS(.v13)
+    ],
+    products: [
+        .library(
+            name: "KvToPyClass",
+            targets: ["KvToPyClass"]
+        ),
+        .executable(
+            name: "KvToPyClassCLI",
+            targets: ["KvToPyClassCLI"]
+        )
+    ],
+    dependencies: [
+        // Local dependency on SwiftyKvLang parser
+        .package(url: "https://github.com/kivy-school/SwiftyKvLang.git", exact: "0.0.0"),
+        // PySwiftAST for generating Python code
+        .package(url: "https://github.com/Py-Swift/PySwiftAST.git", exact: "0.0.1")
+    ],
+    targets: [
+        .target(
+            name: "KvToPyClass",
+            dependencies: [
+                .product(name: "KivyWidgetRegistry", package: "SwiftyKvLang"),
+                .product(name: "KvParser", package: "SwiftyKvLang"),
+                .product(name: "PySwiftAST", package: "PySwiftAST"),
+                .product(name: "PySwiftCodeGen", package: "PySwiftAST"),
+                .product(name: "PyFormatters", package: "PySwiftAST")
+            ],
+            path: "Sources/KvToPyClass"
+        ),
+        .executableTarget(
+            name: "KvToPyClassCLI",
+            dependencies: [
+                "KvToPyClass",
+                .product(name: "KivyWidgetRegistry", package: "SwiftyKvLang")
+            ],
+            path: "Sources/KvToPyClassCLI"
+        ),
+        .testTarget(
+            name: "KvToPyClassTests",
+            dependencies: [
+                "KvToPyClass",
+                .product(name: "KivyWidgetRegistry", package: "SwiftyKvLang")
+            ],
+            path: "Tests/KvToPyClassTests"
+        )
+    ]
+)