functionalscript 0.0.464 → 0.0.465

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,13 +15,55 @@
 
 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;
@@ -37,11 +81,11 @@ namespace com
         virtual ULONG COM_STDCALL Release() noexcept = 0;
     };
 
-    template<class I>
+    template <class I>
     class ref
     {
     public:
-        explicit ref(I &other) noexcept : p(other.p)
+        explicit ref(I &other) noexcept : p(other)
         {
             p.AddRef();
         }
@@ -52,24 +96,52 @@ namespace com
         {
             p.Release();
         }
+
     private:
         I &p;
     };
 
-    template<class I>
-    class implementation: public I
+    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
         {
-            return E_NOINTERFACE;
+            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 0;
+            return add_ref() + 1;
         }
+
         ULONG COM_STDCALL Release() noexcept override
         {
-            return 0;
+            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/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++']
     }
 }
 

package/com/test/cpp/main.cpp

@@ -13,7 +13,7 @@ extern "C" int c_get()
     return 43;
 }
 
-class Impl: public com::implementation<My::IMy>
+class Impl: public My::IMy
 {
     My::Slice COM_STDCALL GetSlice() noexcept override
     {
@@ -41,5 +41,5 @@ class Impl: public com::implementation<My::IMy>
 DLL_EXPORT
 extern "C" My::IMy* c_my_create()
 {
-    return new Impl();
+    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 });
+x.SetSlice(new Slice { Start = null, Size = (UIntPtr)44 });
+
+var y = c_my_create();

package/package.json

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