functionalscript 0.0.469 → 0.0.470

package/com/cpp/com.hpp

@@ -13,14 +13,16 @@
 #define COM_STDCALL __stdcall
 #endif
 
+static_assert(sizeof(bool) == 1);
+
 namespace com
 {
     constexpr uint64_t byteswap(uint64_t v) noexcept
     {
-        v = v >>  8 & 0x00FF00FF00FF00FF |
-            v <<  8 & 0xFF00FF00FF00FF00;
-        v = v >> 16 & 0x0000FFFF0000FFFF |
-            v << 16 & 0xFFFF0000FFFF0000;
+        v = v >> 8 & 0x00FF'00FF'00FF'00FF |
+            v << 8 & 0xFF00'FF00'FF00'FF00;
+        v = v >> 16 & 0x0000'FFFF'0000'FFFF |
+            v << 16 & 0xFFFF'0000'FFFF'0000;
         return v >> 32 | v << 32;
     }
 
@@ -46,14 +48,17 @@ namespace com
         }
     };
 
+    constexpr inline char hex_digit(uint64_t const v, int const i) noexcept
+    {
+        char const c = v >> i & 0x0F;
+        return c < 10 ? c + '0' : c + ('A' - 10);
+    }
+
     inline void guid_part(std::ostream &os, uint64_t const v)
     {
-        for (int i = 64; i > 0;)
+        for (int i = 60; i >= 0; i -= 4)
         {
-            i -= 4;
-            char const c = (v >> i) & 0xF;
-            char const x = c < 10 ? c + '0' : c + ('A' - 10);
-            os << x;
+            os << hex_digit(v, i);
         }
     }
 
@@ -64,28 +69,27 @@ namespace com
         return os;
     }
 
-    typedef uint32_t HRESULT;
-
-    static HRESULT const E_NOINTERFACE = 0x80004002;
-    static HRESULT const S_OK = 0;
+    enum class HRESULT : uint32_t
+    {
+        S_OK = 0,
+        E_NOINTERFACE = 0x80004002,
+    };
 
     typedef uint32_t ULONG;
 
-    typedef int32_t BOOL;
-
     class IUnknown
     {
     public:
-        virtual HRESULT COM_STDCALL QueryInterface(GUID const &riid, IUnknown **const ppvObject) noexcept = 0;
-        virtual ULONG COM_STDCALL AddRef() noexcept = 0;
-        virtual ULONG COM_STDCALL Release() noexcept = 0;
+        virtual HRESULT COM_STDCALL QueryInterface(GUID const &riid, IUnknown const **ppvObject) const noexcept = 0;
+        virtual ULONG COM_STDCALL AddRef() const noexcept = 0;
+        virtual ULONG COM_STDCALL Release() const noexcept = 0;
     };
 
     template <class I>
     class ref
     {
     public:
-        explicit ref(I &other) noexcept : p(other)
+        explicit ref(I const &other) noexcept : p(other)
         {
             p.AddRef();
         }
@@ -97,28 +101,41 @@ namespace com
             p.Release();
         }
 
-        template<class U>
+        template <class U>
         ref<U> upcast() const noexcept
         {
             return ref<U>(p);
         }
 
-        I* operator->() const noexcept
+        I const *operator->() const noexcept
         {
             return &p;
         }
 
-        I* unsafe_result() const noexcept
+        I const *copy_to_raw() const noexcept
         {
             p.AddRef();
             return &p;
         }
+
+        static ref move_to_ref(I const *const p)
+        {
+            return ref(p);
+        }
+
     private:
-        I &p;
+        I const &p;
+        ref(I const *const p) : p(*p) {}
     };
 
-    template<class I>
-    ref<I> to_ref(I& p) noexcept
+    template <class I>
+    ref<I> move_to_ref(I const *const p)
+    {
+        return ref<I>::move_to_ref(p);
+    }
+
+    template <class I>
+    ref<I> to_ref(I const &p) noexcept
     {
         return ref<I>(p);
     }
@@ -130,39 +147,40 @@ namespace com
     class implementation : public T
     {
     public:
-        template<class ...U>
-        static T* create_raw(U... u)
-        {
-            return new implementation(u...);
-        }
-        template<class ...U>
+        template <class... U>
         static ref<T> create(U... u)
         {
-            return to_ref(*create_raw(u...));
+            T const *const p = new implementation(u...);
+            return to_ref(*p);
         }
+
     private:
-        HRESULT COM_STDCALL QueryInterface(GUID const &riid, IUnknown **const ppvObject) noexcept override
+        HRESULT COM_STDCALL QueryInterface(GUID const &riid, IUnknown const **const ppvObject) const noexcept override
         {
+            // std::cout << "riid:     " << riid << std::endl;
+            // std::cout << "iunknown: " << iunknown_guid << std::endl;
+            // std::cout << "T::guid:  " << T::guid << std::endl;
+            // std::cout << std::endl;
             if (riid != iunknown_guid && riid != T::guid)
             {
-                return E_NOINTERFACE;
+                return HRESULT::E_NOINTERFACE;
             }
             add_ref();
             *ppvObject = this;
-            return S_OK;
+            return HRESULT::S_OK;
         }
 
-        ULONG add_ref() noexcept
+        ULONG add_ref() const noexcept
         {
             return counter.fetch_add(1);
         }
 
-        ULONG COM_STDCALL AddRef() noexcept override
+        ULONG COM_STDCALL AddRef() const noexcept override
         {
             return add_ref() + 1;
         }
 
-        ULONG COM_STDCALL Release() noexcept override
+        ULONG COM_STDCALL Release() const noexcept override
         {
             auto const c = counter.fetch_sub(1) - 1;
             if (c == 0)
@@ -172,9 +190,9 @@ namespace com
             return c;
         }
 
-        template<class ...U>
-        explicit implementation(U... u): T(u...) {}
+        template <class... U>
+        explicit implementation(U... u) : T(u...) {}
 
-        std::atomic<ULONG> counter;
+        mutable std::atomic<ULONG> counter;
     };
 }

package/com/cpp/module.f.cjs

@@ -23,7 +23,7 @@ const baseTypeMap = {
     isize: 'ptrdiff_t',
     f32: 'float',
     f64: 'double',
-    bool: '::com::BOOL',
+    bool: 'bool',
 }
 
 /** @type {(t: types.BaseType) => string} */
@@ -36,10 +36,13 @@ const namespace = text.curly('namespace')
 /** @type {(name: string) => (lib: types.Library) => text.Block} */
 const cpp = name => lib => {
 
+    /** @type {(t: types.Type) => boolean} */
+    const isInterface = t => t instanceof Array && t.length === 1 && lib[t[0]].interface !== undefined
+
     /** @type {(i: (t: string) => string) => (t: types.Type) => string} */
     const objectType = i => t => {
         if (typeof (t) === 'string') { return baseType(t) }
-        if (t.length === 2) { return `${type(t[1])}*` }
+        if (t.length === 2) { return `${type(t[1])} const*` }
         const [id] = t
         if (lib[id].interface === undefined) { return id }
         return i(id)
@@ -47,7 +50,7 @@ const cpp = name => lib => {
 
     const type = objectType(id => `::com::ref<${id}>`)
 
-    const resultType = objectType(id => `${id}*`)
+    const resultType = objectType(id => `${id} const*`)
 
     /** @type {(s: types.Field) => text.Item} */
     const field = ([name, t]) => `${type(t)} ${name};`
@@ -61,13 +64,18 @@ const cpp = name => lib => {
     const cppResult = resultVoid(resultType)
 
     /** @type {(p: types.Field) => string} */
-    const param = ([name, t]) => `${objectType(id => `${id}&`)(t)} ${name}`
+    const param = ([name, t]) => `${objectType(id => `${id} const&`)(t)} ${name}`
 
     const mapParam = map(param)
 
+    /** @type {(m: types.Method) => string} */
+    const virtualName = ([name, paramArray]) => isInterface(paramArray._) ? `${name}_` : name
+
     /** @type {(m: types.Method) => text.Item} */
-    const method = ([name, paramArray]) =>
-        `virtual ${cppResult(paramArray)} COM_STDCALL ${name}(${join(', ')(mapParam(paramList(paramArray)))}) noexcept = 0;`
+    const method = m => {
+        const [, paramArray] = m
+        return `virtual ${cppResult(paramArray)} COM_STDCALL ${virtualName(m)}(${join(', ')(mapParam(paramList(paramArray)))}) const noexcept = 0;`
+    }
 
     const mapMethod = map(method)
 
@@ -85,7 +93,7 @@ const cpp = name => lib => {
     /** @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))
+        : [`class ${name} : public ::com::IUnknown`, '{', 'public:', defInterface(d), '};']
 
     /** @type {(kv: obj.Entry<types.Definition>) => text.Block} */
     const forward = ([name]) => [`struct ${name};`]

package/com/cpp/test.f.cjs

@@ -12,23 +12,24 @@ const f = () =>
         '    struct IMy;\n' +
         '    struct Slice\n' +
         '    {\n' +
-        '        uint8_t* Start;\n' +
+        '        uint8_t const* Start;\n' +
         '        size_t Size;\n' +
         '    };\n' +
         '    struct ManagedStruct\n' +
         '    {\n' +
         '        ::com::ref<IMy> M;\n' +
         '    };\n' +
-        '    struct IMy : ::com::IUnknown\n' +
+        '    class IMy : public ::com::IUnknown\n' +
         '    {\n' +
+        '    public:\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' +
-        '        virtual void COM_STDCALL SetUnsafe(Slice* p, uint32_t size) noexcept = 0;\n' +
-        '        virtual ::com::BOOL COM_STDCALL Some(IMy& p) noexcept = 0;\n' +
-        '        virtual IMy* COM_STDCALL GetIMy() noexcept = 0;\n' +
-        '        virtual void COM_STDCALL SetManagedStruct(ManagedStruct a) noexcept = 0;\n' +
+        '        virtual Slice COM_STDCALL GetSlice() const noexcept = 0;\n' +
+        '        virtual void COM_STDCALL SetSlice(Slice slice) const noexcept = 0;\n' +
+        '        virtual bool const* COM_STDCALL GetUnsafe() const noexcept = 0;\n' +
+        '        virtual void COM_STDCALL SetUnsafe(Slice const* p, uint32_t size) const noexcept = 0;\n' +
+        '        virtual bool COM_STDCALL Some(IMy const& p) const noexcept = 0;\n' +
+        '        virtual IMy const* COM_STDCALL GetIMy_() const noexcept = 0;\n' +
+        '        virtual void COM_STDCALL SetManagedStruct(ManagedStruct a) const noexcept = 0;\n' +
         '    };\n' +
         '}'
     if (cpp !== e) { throw cpp }

package/com/cs/module.f.cjs

@@ -25,7 +25,7 @@ const typeDef = attributes => type => name => body =>
     ])
 
 const baseTypeMap = {
-    bool: 'bool',
+    bool: 'byte',
     f32: 'float',
     f64: 'double',
     i16: 'short',

package/com/cs/test.f.cjs

@@ -28,11 +28,11 @@ const f = () =>
         '        [PreserveSig]\n' +
         '        void SetSlice(Slice slice);\n' +
         '        [PreserveSig]\n' +
-        '        unsafe bool* GetUnsafe();\n' +
+        '        unsafe byte* GetUnsafe();\n' +
         '        [PreserveSig]\n' +
         '        unsafe void SetUnsafe(Slice* p, uint size);\n' +
         '        [PreserveSig]\n' +
-        '        bool Some(IMy p);\n' +
+        '        byte Some(IMy p);\n' +
         '        [PreserveSig]\n' +
         '        IMy GetIMy();\n' +
         '        [PreserveSig]\n' +

package/com/test/build.f.cjs

@@ -46,7 +46,7 @@ const flags = platform => {
         case 'win32':
             return []
         case 'linux':
-            return ['-lstdc++', '-fPIC']
+            return ['-std=c++17', '-lstdc++', '-fPIC']
         default:
             return ['-std=c++17', '-lc++']
     }

package/com/test/cpp/main.cpp

@@ -13,35 +13,39 @@ extern "C" int c_get()
     return 43;
 }
 
-class Impl: public My::IMy
+class Impl : public My::IMy
 {
 public:
-    My::Slice COM_STDCALL GetSlice() noexcept override
+    My::Slice COM_STDCALL GetSlice() const noexcept override
     {
     }
-    void COM_STDCALL SetSlice(My::Slice slice) noexcept override
+    void COM_STDCALL SetSlice(My::Slice slice) const noexcept override
     {
         std::cout
             << "SetSlice: "
-            << (slice.Start - static_cast<uint8_t*>(nullptr))
+            << (slice.Start - static_cast<uint8_t const *>(nullptr))
             << ", "
             << slice.Size
             << std::endl;
     }
-    ::com::BOOL *COM_STDCALL GetUnsafe() noexcept override
+    bool const *COM_STDCALL GetUnsafe() const noexcept override
     {
     }
-    void COM_STDCALL SetUnsafe(My::Slice *p, uint32_t size) noexcept override
+    void COM_STDCALL SetUnsafe(My::Slice const *p, uint32_t size) const noexcept override
     {
     }
-    ::com::BOOL COM_STDCALL Some(My::IMy &p) noexcept override
+    bool COM_STDCALL Some(My::IMy const &p) const noexcept override
     {
     }
-    My::IMy* COM_STDCALL GetIMy() noexcept override
+    My::IMy const *COM_STDCALL GetIMy_() const noexcept override
     {
-        return ::com::to_ref(*this).unsafe_result();
+        return ::com::to_ref(*this).copy_to_raw();
     }
-    void COM_STDCALL SetManagedStruct(My::ManagedStruct a) noexcept override
+    com::ref<My::IMy> GetIMy() const noexcept
+    {
+        return com::move_to_ref(GetIMy_());
+    }
+    void COM_STDCALL SetManagedStruct(My::ManagedStruct a) const noexcept override
     {
     }
     ~Impl()
@@ -51,15 +55,15 @@ public:
 };
 
 DLL_EXPORT
-extern "C" My::IMy* c_my_create()
+extern "C" My::IMy const *c_my_create()
 {
     {
-        auto const x = ::com::implementation<Impl>::create().unsafe_result();
+        auto const x = ::com::implementation<Impl>::create().copy_to_raw();
         x->Release();
     }
     {
         auto const x = ::com::implementation<Impl>::create().upcast<My::IMy>();
         x->SetSlice(My::Slice());
     }
-    return ::com::implementation<Impl>::create().unsafe_result();
+    return ::com::implementation<Impl>::create().copy_to_raw();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.469",
+  "version": "0.0.470",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {
@@ -30,7 +30,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^18.11.2",
+    "@types/node": "^18.11.9",
     "typescript": "^4.8.4"
   }
 }