functionalscript 0.0.463 → 0.0.465

package/.github/workflows/com.yml

@@ -19,10 +19,13 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Use Node.js 19
       uses: actions/setup-node@v2
       with:
         node-version: 19
+    - uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: 7
     - run: npm ci
     - run: npm run comtest

package/Cargo.lock

@@ -4,7 +4,7 @@ version = 3
 
 [[package]]
 name = "nanocom"
-version = "0.2.0"
+version = "0.2.1"
 
 [[package]]
 name = "testrust"

package/com/cpp/com.hpp

@@ -2,6 +2,8 @@
 
 #include <cstdint>
 #include <cstddef>
+#include <atomic>
+#include <iostream>
 
 #if defined(__aarch64__) || defined(__amd64__)
 #define COM_STDCALL
@@ -13,15 +15,62 @@
 
 namespace com
 {
+    constexpr uint64_t byteswap(uint64_t v)
+    {
+        v = v >>  8 & 0x00FF00FF00FF00FF |
+            v <<  8 & 0xFF00FF00FF00FF00;
+        v = v >> 16 & 0x0000FFFF0000FFFF |
+            v << 16 & 0xFFFF0000FFFF0000;
+        return v >> 32 | v << 32;
+    }
+
     class GUID
     {
     public:
-        uint64_t hi;
         uint64_t lo;
+        uint64_t hi;
+        constexpr GUID(uint64_t const lo, uint64_t const hi) noexcept
+            : lo(lo << 48 & 0xFFFF'0000'0000'0000 |
+                 lo << 16 & 0x0000'FFFF'0000'0000 |
+                 lo >> 32),
+              hi(byteswap(hi))
+        {
+        }
+        constexpr bool operator==(GUID const b) const noexcept
+        {
+            return lo == b.lo && hi == b.hi;
+        }
+        constexpr bool operator!=(GUID const b) const noexcept
+        {
+            return !(*this == b);
+        }
     };
 
+    inline void guid_part(std::ostream &os, uint64_t const v)
+    {
+        for (int i = 64; i > 0;)
+        {
+            i -= 4;
+            char const c = (v >> i) & 0xF;
+            char const x = c < 10 ? c + '0' : c + ('A' - 10);
+            os << x;
+        }
+    }
+
+    inline std::ostream &operator<<(std::ostream &os, GUID const &self)
+    {
+        guid_part(os, self.lo);
+        guid_part(os, self.hi);
+        return os;
+    }
+
     typedef uint32_t HRESULT;
+
+    static HRESULT const E_NOINTERFACE = 0x80004002;
+    static HRESULT const S_OK = 0;
+
     typedef uint32_t ULONG;
+
     typedef int32_t BOOL;
 
     class IUnknown
@@ -36,7 +85,7 @@ namespace com
     class ref
     {
     public:
-        explicit ref(I &other) noexcept : p(other.p)
+        explicit ref(I &other) noexcept : p(other)
         {
             p.AddRef();
         }
@@ -47,7 +96,52 @@ namespace com
         {
             p.Release();
         }
+
     private:
         I &p;
     };
+
+    constexpr static GUID const iunknown_guid =
+        GUID(0x00000000'0000'0000, 0xC000'000000000046);
+
+    template <class I>
+    constexpr GUID interface_guid();
+
+    template <class T>
+    class implementation : public T
+    {
+    private:
+        HRESULT COM_STDCALL QueryInterface(GUID const &riid, IUnknown **const ppvObject) noexcept override
+        {
+            if (riid != iunknown_guid && riid != T::guid)
+            {
+                return E_NOINTERFACE;
+            }
+            add_ref();
+            *ppvObject = this;
+            return S_OK;
+        }
+
+        ULONG add_ref() noexcept
+        {
+            return counter.fetch_add(1);
+        }
+
+        ULONG COM_STDCALL AddRef() noexcept override
+        {
+            return add_ref() + 1;
+        }
+
+        ULONG COM_STDCALL Release() noexcept override
+        {
+            auto const c = counter.fetch_sub(1) - 1;
+            if (c == 0)
+            {
+                delete this;
+            }
+            return c;
+        }
+
+        std::atomic<ULONG> counter;
+    };
 }

package/com/cpp/module.f.cjs

@@ -5,7 +5,7 @@ const obj = require('../../types/object/module.f.cjs')
 const list = require('../../types/list/module.f.cjs')
 const { map, flatMap, flat } = list
 const { join } = require('../../types/string/module.f.cjs')
-const { entries } =  Object
+const { entries } = Object
 
 /** @type {(name: string) => (body: text.Block) => text.Block} */
 const struct = name => body => [`struct ${name}`, '{', body, '};']
@@ -70,12 +70,20 @@ const cpp = name => lib => {
     const mapMethod = map(method)
 
     /** @type {(i: types.Interface) => text.Block} */
-    const defInterface = i => mapMethod(entries(i.interface))
+    const defInterface = ({ guid, interface: i }) => {
+        const g = guid.replaceAll('-', '');
+        const lo = g.substring(0, 16);
+        const hi = g.substring(16);
+        return flat([
+            [`constexpr static ::com::GUID const guid = ::com::GUID(0x${lo}, 0x${hi});`],
+            mapMethod(entries(i))
+        ])
+    }
 
     /** @type {(kv: obj.Entry<types.Definition>) => text.Block} */
     const def = ([name, d]) => d.interface === undefined
         ? struct(name)(defStruct(d))
-        : struct(`${name}: ::com::IUnknown`)(defInterface(d))
+        : struct(`${name} : ::com::IUnknown`)(defInterface(d))
 
     /** @type {(kv: obj.Entry<types.Definition>) => text.Block} */
     const forward = ([name]) => [`struct ${name};`]

package/com/cpp/test.f.cjs

@@ -19,8 +19,9 @@ const f = () =>
         '    {\n' +
         '        ::com::ref<IMy> M;\n' +
         '    };\n' +
-        '    struct IMy: ::com::IUnknown\n' +
+        '    struct IMy : ::com::IUnknown\n' +
         '    {\n' +
+        '        constexpr static ::com::GUID const guid = ::com::GUID(0xC66FB2702D8049AD, 0xBB6E88C1F90B805D);\n' +
         '        virtual Slice COM_STDCALL GetSlice() noexcept = 0;\n' +
         '        virtual void COM_STDCALL SetSlice(Slice slice) noexcept = 0;\n' +
         '        virtual ::com::BOOL* COM_STDCALL GetUnsafe() noexcept = 0;\n' +

package/com/rust/nanocom/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nanocom"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 description = "Nano-COM, extremly small subset of cross-platform COM"
 authors = ["NatFoam"]

package/com/rust/nanocom/src/cobject.rs

@@ -3,7 +3,7 @@ use std::{
     sync::atomic::{AtomicU32, Ordering},
 };
 
-use crate::{hresult::HRESULT, iunknown::IUnknown, Class, Interface, Object, Ref, Vmt};
+use crate::{guid::GuidEx, hresult::HRESULT, iunknown::IUnknown, Class, Object, Ref};
 
 #[repr(C)]
 pub struct CObject<T: Class> {
@@ -12,14 +12,6 @@ pub struct CObject<T: Class> {
     pub value: T,
 }
 
-const fn guid<I: Interface>() -> u128 {
-    let x = <I>::GUID;
-    (x >> 96) |
-    ((x >>  48) & 0x00000_000_0000_0000_0000_FFFF_0000_0000) |
-    ((x >>  16) & 0x0000_0000_0000_0000_FFFF_0000_0000_0000) |
-    (((x as u64).swap_bytes() as u128) << 64)
-}
-
 impl<T: Class> CObject<T> {
     pub const IUNKNOWN: IUnknown<T::Interface> = IUnknown {
         QueryInterface: Self::QueryInterface,
@@ -38,7 +30,7 @@ impl<T: Class> CObject<T> {
         riid: &u128,
         ppv_object: &mut *const Object,
     ) -> HRESULT {
-        let (p, r) = if *riid == guid::<()>() || *riid == guid::<T::Interface>() {
+        let (p, r) = if *riid == <()>::PLATFORM_GUID || *riid == T::Interface::PLATFORM_GUID {
             Self::AddRef(this);
             (this.to_iunknown() as *const Object, HRESULT::S_OK)
         } else {

package/com/rust/nanocom/src/guid.rs

@@ -1 +1,15 @@
+use crate::Interface;
+
 pub type GUID = u128;
+
+pub trait GuidEx: Interface {
+    const PLATFORM_GUID: GUID = {
+        let x = Self::GUID;
+        (x >> 96)
+            | ((x >> 48) & 0x00000_000_0000_0000_0000_FFFF_0000_0000)
+            | ((x >> 16) & 0x0000_0000_0000_0000_FFFF_0000_0000_0000)
+            | (((x as u64).swap_bytes() as u128) << 64)
+    };
+}
+
+impl<T: Interface> GuidEx for T {}

package/com/test/build.f.cjs

@@ -46,9 +46,9 @@ const flags = platform => {
         case 'win32':
             return []
         case 'linux':
-            return ['-lstdc++']
+            return ['-lstdc++', '-fPIC']
         default:
-            return ['-std=c++11', '-lc++']
+            return ['-std=c++17', '-lc++']
     }
 }
 
@@ -77,13 +77,17 @@ const cpp = ({dirname, platform}) => ({
 })
 
 /** @type {Func} */
-const cs = ({dirname}) => ({
+const cs = ({dirname, platform}) => ({
     file: {
         name: `${dirname}/cs/_result.cs`,
         content: csContent,
     },
     line: [
-        ['dotnet', 'run', '--project', `${dirname}/cs/cs.csproj`]],
+        platform === 'win32'
+            ? ['dotnet', 'run', '--project', `${dirname}/cs/cs.csproj`]
+        // .Net on Linux and Windows doesn't properly support COM object marshalling
+            : ['dotnet', 'build', `${dirname}/cs/cs.csproj`]
+    ],
 })
 
 /** @type {Func} */

package/com/test/cpp/main.cpp

@@ -13,6 +13,33 @@ extern "C" int c_get()
     return 43;
 }
 
-class Impl: My::IMy {
-
+class Impl: public My::IMy
+{
+    My::Slice COM_STDCALL GetSlice() noexcept override
+    {
+    }
+    void COM_STDCALL SetSlice(My::Slice slice) noexcept override
+    {
+    }
+    ::com::BOOL *COM_STDCALL GetUnsafe() noexcept override
+    {
+    }
+    void COM_STDCALL SetUnsafe(My::Slice *p, uint32_t size) noexcept override
+    {
+    }
+    ::com::BOOL COM_STDCALL Some(My::IMy &p) noexcept override
+    {
+    }
+    ::com::ref<My::IMy> COM_STDCALL GetIMy() noexcept override
+    {
+    }
+    void COM_STDCALL SetManagedStruct(My::ManagedStruct a) noexcept override
+    {
+    }
 };
+
+DLL_EXPORT
+extern "C" My::IMy* c_my_create()
+{
+    return new ::com::implementation<Impl>();
+}

package/com/test/cs/Program.cs

@@ -10,10 +10,15 @@ static extern IMy rust_my_create();
 [DllImport("testc")]
 static extern int c_get();
 
+[DllImport("testc")]
+static extern IMy c_my_create();
+
 // See https://aka.ms/new-console-template for more information
 Console.WriteLine("Hello, World!");
 Console.WriteLine(get());
 Console.WriteLine(c_get());
 
-// var x = rust_my_create();
-// x.SetSlice(new Slice { Start = null, Size = (UIntPtr)44 });
+var x = rust_my_create();
+x.SetSlice(new Slice { Start = null, Size = (UIntPtr)44 });
+
+var y = c_my_create();

package/com/test/rust/src/lib.rs

@@ -46,9 +46,11 @@ impl _result::IMy::Ex for nanocom::CObject<My> {
 }
 
 #[no_mangle]
-pub extern "C" fn get() -> i32 { 42 }
+pub extern "C" fn get() -> i32 {
+    42
+}
 
 #[no_mangle]
 pub extern "C" fn rust_my_create() -> IMy::Ref {
     My {}.to_cobject()
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.463",
+  "version": "0.0.465",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {