functionalscript 0.0.470 → 0.0.472

package/com/cpp/module.f.cjs

@@ -33,11 +33,33 @@ const resultVoid = types.result('void')
 
 const namespace = text.curly('namespace')
 
+/** @type {(id: string) => string} */
+const comRef = id => `::nanocom::ref<${id}>`
+
+/** @type {(id: string) => string} */
+const ptr = id => `${id} const*`
+
+/** @type {(id: string) => string} */
+const ref = id => `${id} const&`
+
+/** @type {(p: types.Field) => string} */
+const paramName = ([name]) => name
+
+const mapParamName = map(paramName)
+
+const joinComma = join(', ')
+
 /** @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 {(t: types.Type) => string|undefined} */
+    const interface_ = t => {
+        if (!(t instanceof Array) || t.length !== 1) {
+            return undefined
+        }
+        const [name] = t
+        return lib[name].interface !== undefined ? name : undefined
+    }
 
     /** @type {(i: (t: string) => string) => (t: types.Type) => string} */
     const objectType = i => t => {
@@ -48,9 +70,9 @@ const cpp = name => lib => {
         return i(id)
     }
 
-    const type = objectType(id => `::com::ref<${id}>`)
+    const type = objectType(comRef)
 
-    const resultType = objectType(id => `${id} const*`)
+    const resultType = objectType(ptr)
 
     /** @type {(s: types.Field) => text.Item} */
     const field = ([name, t]) => `${type(t)} ${name};`
@@ -64,20 +86,34 @@ const cpp = name => lib => {
     const cppResult = resultVoid(resultType)
 
     /** @type {(p: types.Field) => string} */
-    const param = ([name, t]) => `${objectType(id => `${id} const&`)(t)} ${name}`
+    const param = ([name, t]) => `${objectType(ref)(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 = m => {
-        const [, paramArray] = m
-        return `virtual ${cppResult(paramArray)} COM_STDCALL ${virtualName(m)}(${join(', ')(mapParam(paramList(paramArray)))}) const noexcept = 0;`
+    /** @type {(result: string) => (paramArrayStr: string) => (name: string) => text.Item} */
+    const methodHeader = result => paramArrayStr => name =>
+        `virtual ${result} ${name}${paramArrayStr} const noexcept = 0;`
+
+    /** @type {(m: types.Method) => readonly text.Item[]} */
+    const method = ([name, paramArray]) => {
+        const result = cppResult(paramArray)
+        const paramL = paramList(paramArray)
+        const paramArrayStr = `(${joinComma(mapParam(paramL))})`
+        const m = methodHeader(result)(paramArrayStr)
+        const resultName = interface_(paramArray._)
+        if (resultName === undefined) {
+            return [m(name)]
+        }
+        return [
+            m(`${name}_`),
+            `${comRef(resultName)} ${name}${paramArrayStr} const noexcept`,
+            '{',
+            [`return ::nanocom::move_to_ref(${name}_(${joinComma(mapParamName(paramL))}));`],
+            '}',
+        ]
     }
 
-    const mapMethod = map(method)
+    const mapMethod = flatMap(method)
 
     /** @type {(i: types.Interface) => text.Block} */
     const defInterface = ({ guid, interface: i }) => {
@@ -85,7 +121,7 @@ const cpp = name => lib => {
         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});`],
+            [`constexpr static ::nanocom::GUID const guid = ::nanocom::GUID(0x${lo}, 0x${hi});`],
             mapMethod(entries(i))
         ])
     }
@@ -93,7 +129,13 @@ const cpp = name => lib => {
     /** @type {(kv: obj.Entry<types.Definition>) => text.Block} */
     const def = ([name, d]) => d.interface === undefined
         ? struct(name)(defStruct(d))
-        : [`class ${name} : public ::com::IUnknown`, '{', 'public:', defInterface(d), '};']
+        : [
+            `class ${name} : public ::nanocom::IUnknown`,
+            '{',
+            'public:',
+            defInterface(d),
+            '};'
+        ]
 
     /** @type {(kv: obj.Entry<types.Definition>) => text.Block} */
     const forward = ([name]) => [`struct ${name};`]

package/com/cpp/{com.hpp → nanocom.hpp}

@@ -5,17 +5,9 @@
 #include <atomic>
 #include <iostream>
 
-#if defined(__aarch64__) || defined(__amd64__)
-#define COM_STDCALL
-#elif defined(__clang__)
-#define COM_STDCALL __attribute__((stdcall))
-#else
-#define COM_STDCALL __stdcall
-#endif
-
 static_assert(sizeof(bool) == 1);
 
-namespace com
+namespace nanocom
 {
     constexpr uint64_t byteswap(uint64_t v) noexcept
     {
@@ -80,9 +72,9 @@ namespace com
     class IUnknown
     {
     public:
-        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;
+        virtual HRESULT QueryInterface(GUID const &riid, IUnknown const **ppvObject) const noexcept = 0;
+        virtual ULONG AddRef() const noexcept = 0;
+        virtual ULONG Release() const noexcept = 0;
     };
 
     template <class I>
@@ -155,7 +147,7 @@ namespace com
         }
 
     private:
-        HRESULT COM_STDCALL QueryInterface(GUID const &riid, IUnknown const **const ppvObject) const noexcept override
+        HRESULT QueryInterface(GUID const &riid, IUnknown const **const ppvObject) const noexcept override
         {
             // std::cout << "riid:     " << riid << std::endl;
             // std::cout << "iunknown: " << iunknown_guid << std::endl;
@@ -175,12 +167,12 @@ namespace com
             return counter.fetch_add(1);
         }
 
-        ULONG COM_STDCALL AddRef() const noexcept override
+        ULONG AddRef() const noexcept override
         {
             return add_ref() + 1;
         }
 
-        ULONG COM_STDCALL Release() const noexcept override
+        ULONG Release() const noexcept override
         {
             auto const c = counter.fetch_sub(1) - 1;
             if (c == 0)

package/com/cpp/test.f.cjs

@@ -17,19 +17,23 @@ const f = () =>
         '    };\n' +
         '    struct ManagedStruct\n' +
         '    {\n' +
-        '        ::com::ref<IMy> M;\n' +
+        '        ::nanocom::ref<IMy> M;\n' +
         '    };\n' +
-        '    class IMy : public ::com::IUnknown\n' +
+        '    class IMy : public ::nanocom::IUnknown\n' +
         '    {\n' +
         '    public:\n' +
-        '        constexpr static ::com::GUID const guid = ::com::GUID(0xC66FB2702D8049AD, 0xBB6E88C1F90B805D);\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' +
+        '        constexpr static ::nanocom::GUID const guid = ::nanocom::GUID(0xC66FB2702D8049AD, 0xBB6E88C1F90B805D);\n' +
+        '        virtual Slice GetSlice() const noexcept = 0;\n' +
+        '        virtual void SetSlice(Slice slice) const noexcept = 0;\n' +
+        '        virtual bool const* GetUnsafe() const noexcept = 0;\n' +
+        '        virtual void SetUnsafe(Slice const* p, uint32_t size) const noexcept = 0;\n' +
+        '        virtual bool Some(IMy const& p) const noexcept = 0;\n' +
+        '        virtual IMy const* GetIMy_(uint16_t a, int16_t b) const noexcept = 0;\n' +
+        '        ::nanocom::ref<IMy> GetIMy(uint16_t a, int16_t b) const noexcept\n' +
+        '        {\n' +
+        '            return ::nanocom::move_to_ref(GetIMy_(a, b));\n' +
+        '        }\n' +
+        '        virtual void SetManagedStruct(ManagedStruct a) const noexcept = 0;\n' +
         '    };\n' +
         '}'
     if (cpp !== e) { throw cpp }

package/com/cs/test.f.cjs

@@ -34,7 +34,7 @@ const f = () =>
         '        [PreserveSig]\n' +
         '        byte Some(IMy p);\n' +
         '        [PreserveSig]\n' +
-        '        IMy GetIMy();\n' +
+        '        IMy GetIMy(ushort a, short b);\n' +
         '        [PreserveSig]\n' +
         '        void SetManagedStruct(ManagedStruct a);\n' +
         '    }\n' +

package/com/rust/test.f.cjs

@@ -23,7 +23,7 @@ module.exports = () => {
         '        pub GetUnsafe: unsafe extern "system" fn(this: &Object) -> *const bool,\n' +
         '        pub SetUnsafe: unsafe extern "system" fn(this: &Object, p: *const super::Slice, size: u32),\n' +
         '        pub Some: unsafe extern "system" fn(this: &Object, p: &super::IMy::Object) -> bool,\n' +
-        '        pub GetIMy: unsafe extern "system" fn(this: &Object) -> super::IMy::Ref,\n' +
+        '        pub GetIMy: unsafe extern "system" fn(this: &Object, a: u16, b: i16) -> super::IMy::Ref,\n' +
         '        pub SetManagedStruct: unsafe extern "system" fn(this: &Object, a: super::ManagedStruct),\n' +
         '    }\n' +
         '    impl nanocom::Interface for Interface {\n' +
@@ -35,7 +35,7 @@ module.exports = () => {
         '        fn GetUnsafe(&self) -> *const bool;\n' +
         '        fn SetUnsafe(&self, p: *const super::Slice, size: u32);\n' +
         '        fn Some(&self, p: &super::IMy::Object) -> bool;\n' +
-        '        fn GetIMy(&self) -> super::IMy::Ref;\n' +
+        '        fn GetIMy(&self, a: u16, b: i16) -> super::IMy::Ref;\n' +
         '        fn SetManagedStruct(&self, a: super::ManagedStruct);\n' +
         '    }\n' +
         '    impl Ex for Object {\n' +
@@ -54,8 +54,8 @@ module.exports = () => {
         '        fn Some(&self, p: &super::IMy::Object) -> bool {\n' +
         '            unsafe { (self.interface().Some)(self, p) }\n' +
         '        }\n' +
-        '        fn GetIMy(&self) -> super::IMy::Ref {\n' +
-        '            unsafe { (self.interface().GetIMy)(self) }\n' +
+        '        fn GetIMy(&self, a: u16, b: i16) -> super::IMy::Ref {\n' +
+        '            unsafe { (self.interface().GetIMy)(self, a, b) }\n' +
         '        }\n' +
         '        fn SetManagedStruct(&self, a: super::ManagedStruct) {\n' +
         '            unsafe { (self.interface().SetManagedStruct)(self, a) }\n' +
@@ -105,8 +105,8 @@ module.exports = () => {
         '        extern "system" fn Some(this: &Object, p: &super::IMy::Object) -> bool {\n' +
         '            unsafe { nanocom::CObject::from_object_unchecked(this) }.Some(p)\n' +
         '        }\n' +
-        '        extern "system" fn GetIMy(this: &Object) -> super::IMy::Ref {\n' +
-        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.GetIMy()\n' +
+        '        extern "system" fn GetIMy(this: &Object, a: u16, b: i16) -> super::IMy::Ref {\n' +
+        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.GetIMy(a, b)\n' +
         '        }\n' +
         '        extern "system" fn SetManagedStruct(this: &Object, a: super::ManagedStruct) {\n' +
         '            unsafe { nanocom::CObject::from_object_unchecked(this) }.SetManagedStruct(a)\n' +

package/com/test/cpp/main.cpp

@@ -1,4 +1,4 @@
-#include "../../cpp/com.hpp"
+#include "../../cpp/nanocom.hpp"
 #include "_result.hpp"
 
 #ifdef _WIN32
@@ -16,10 +16,10 @@ extern "C" int c_get()
 class Impl : public My::IMy
 {
 public:
-    My::Slice COM_STDCALL GetSlice() const noexcept override
+    My::Slice GetSlice() const noexcept override
     {
     }
-    void COM_STDCALL SetSlice(My::Slice slice) const noexcept override
+    void SetSlice(My::Slice slice) const noexcept override
     {
         std::cout
             << "SetSlice: "
@@ -28,24 +28,20 @@ public:
             << slice.Size
             << std::endl;
     }
-    bool const *COM_STDCALL GetUnsafe() const noexcept override
+    bool const *GetUnsafe() const noexcept override
     {
     }
-    void COM_STDCALL SetUnsafe(My::Slice const *p, uint32_t size) const noexcept override
+    void SetUnsafe(My::Slice const *p, uint32_t size) const noexcept override
     {
     }
-    bool COM_STDCALL Some(My::IMy const &p) const noexcept override
+    bool Some(My::IMy const &p) const noexcept override
     {
     }
-    My::IMy const *COM_STDCALL GetIMy_() const noexcept override
+    My::IMy const *GetIMy_(uint16_t a, int16_t b) const noexcept override
     {
-        return ::com::to_ref(*this).copy_to_raw();
+        return ::nanocom::to_ref(*this).copy_to_raw();
     }
-    com::ref<My::IMy> GetIMy() const noexcept
-    {
-        return com::move_to_ref(GetIMy_());
-    }
-    void COM_STDCALL SetManagedStruct(My::ManagedStruct a) const noexcept override
+    void SetManagedStruct(My::ManagedStruct a) const noexcept override
     {
     }
     ~Impl()
@@ -58,12 +54,12 @@ DLL_EXPORT
 extern "C" My::IMy const *c_my_create()
 {
     {
-        auto const x = ::com::implementation<Impl>::create().copy_to_raw();
+        auto const x = ::nanocom::implementation<Impl>::create().copy_to_raw();
         x->Release();
     }
     {
-        auto const x = ::com::implementation<Impl>::create().upcast<My::IMy>();
+        auto const x = ::nanocom::implementation<Impl>::create().upcast<My::IMy>();
         x->SetSlice(My::Slice());
     }
-    return ::com::implementation<Impl>::create().copy_to_raw();
+    return ::nanocom::implementation<Impl>::create().copy_to_raw();
 }

package/com/test/cs/Program.cs

@@ -24,7 +24,7 @@ x.SetSlice(new Slice { Start = null, Size = (UIntPtr)44 });
 {
     var y = c_my_create();
     y.SetSlice(new Slice { Start = null, Size = (UIntPtr)45 });
-    var t = y.GetIMy();
+    var t = y.GetIMy(1, 2);
 }
 
 GC.Collect();

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

@@ -36,7 +36,7 @@ impl _result::IMy::Ex for nanocom::CObject<My> {
         todo!()
     }
 
-    fn GetIMy(&self) -> _result::IMy::Ref {
+    fn GetIMy(&self, a: u16, b: i16) -> _result::IMy::Ref {
         todo!()
     }
 

package/com/types/testlib.f.cjs

@@ -24,7 +24,7 @@ module.exports = {
                 size: 'u32'
             },
             Some: { p: ['IMy'], _: 'bool' },
-            GetIMy: { _: ['IMy'] },
+            GetIMy: { a: 'u16', b: 'i16', _: ['IMy'] },
             SetManagedStruct: { a: ['ManagedStruct'] },
         },
     }

package/package.json

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