functionalscript 0.0.361 → 0.0.362

package/com/cpp/com.hpp

@@ -0,0 +1,47 @@
+#ifndef COM_HPP
+#define COM_HPP
+
+#include <cstdint>
+
+namespace com
+{
+    class GUID
+    {
+    public:
+        uint64_t hi;
+        uint64_t lo;
+    };
+
+    typedef uint32_t HRESULT;
+    typedef uint32_t ULONG;
+
+    class IUnknown
+    {
+    public:
+        virtual HRESULT __stdcall QueryInterface(GUID const &riid, IUnknown **const ppvObject) noexcept = 0;
+        virtual ULONG __stdcall AddRef() noexcept = 0;
+        virtual ULONG __stdcall Release() noexcept = 0;
+    };
+
+    template <class I>
+    class Ref
+    {
+    public:
+        explicit Ref(I &other) noexcept : p(other.p)
+        {
+            p.AddRef();
+        }
+        Ref(Ref const &other) noexcept : Ref(other.p)
+        {
+        }
+        ~Ref() noexcept
+        {
+            p.Release();
+        }
+
+    private:
+        I &p;
+    };
+}
+
+#endif

package/com/cpp/main.f.js

@@ -0,0 +1 @@
+module.exports = {}

package/com/cs/main.f.js

@@ -47,8 +47,8 @@ const unsafe = isUnsafe => isUnsafe ? 'unsafe ' : ''
 /** @type {(t: types.Type) => readonly[boolean, string]} */
 const csType = t =>
     typeof (t) === 'string' ? [false, csBaseType(t)] :
-        t instanceof Array ? [false, t[0]] :
-            [true, `${csType(t['*'])[1]}*`]
+        t.length === 1 ? [false, t[0]] :
+            [true, `${csType(t[1])[1]}*`]
 
 /** @type {(f: types.Field) => string} */
 const csParam = ([name, type]) => `${csType(type)[1]} ${name}`
@@ -59,19 +59,23 @@ const csField = ([name, type]) => {
     return `public ${unsafe(isUnsafe)}${t} ${name};`
 }
 
-/** @type {(m: types.Method) => readonly[boolean, string]} */
-const csResult = m => m.length === 2 ? [false, 'void'] : csType(m[2])
+/** @type {(m: types.FieldArray) => readonly[boolean, string]} */
+const csResult = m => m._ === undefined ? [false, 'void'] : csType(m._)
 
 /** @type {(field: types.Field) => boolean} */
 const isUnsafeField = field => csType(field[1])[0]
 
-/** @type {(m: types.Method) => readonly string[]} */
-const csMethod = m => {
+/** @type {(kv: obj.Entry<types.Type>) => boolean} */
+const isParam = kv => kv[0] !== '_'
+
+/** @type {(e: obj.Entry<types.FieldArray>) => readonly string[]} */
+const csMethod = ([name, m]) => {
     const result = csResult(m)
-    const isUnsafe = result[0] || list.some(list.map(isUnsafeField)(m[1]))
+    const paramArray = list.filter(isParam)(Object.entries(m))
+    const isUnsafe = result[0] || list.some(list.map(isUnsafeField)(paramArray))
     return [
         '[PreserveSig]',
-        `${unsafe(isUnsafe)}${result[1]} ${m[0]}(${list.join(', ')(list.map(csParam)(m[1]))});`
+        `${unsafe(isUnsafe)}${result[1]} ${name}(${list.join(', ')(list.map(csParam)(paramArray))});`
     ]
 }
 
@@ -83,12 +87,12 @@ const csDef = ([n, d]) => {
             (['StructLayout(LayoutKind.Sequential)'])
             ('struct')
             (n)
-            (() => list.map(csField)(d.struct)) :
+            (() => list.map(csField)(Object.entries(d.struct))) :
         csTypeDef
             ([`Guid("${d.guid}")`, 'InterfaceType(ComInterfaceType.InterfaceIsIUnknown)'])
             ('interface')
             (n)
-            (() => list.flatMap(csMethod)(d.interface))
+            (() => list.flatMap(csMethod)(Object.entries(d.interface)))
 }
 
 /** @type {(name: string) => (library: types.Library) => text.Block} */

package/com/cs/test/build.js

@@ -7,5 +7,5 @@ try {
     console.log(cp.execSync('dotnet build').toString())
 } catch (e) {
     // @ts-ignore
-    console.log(e.output.toString())
+    console.error(e.output.toString())
 }

package/com/cs/test.f.js

@@ -6,19 +6,28 @@ const text = require('../../text/main.f.js')
 /** @type {types.Library} */
 const library = {
     Slice: {
-        struct: [
-            ['Start', { '*': 'u8' }],
-            ['Size', 'usize'],
-        ]
+        struct: {
+            Start: ['*', 'u8'],
+            Size: 'usize',
+        },
     },
     IMy: {
         guid: 'C66FB270-2D80-49AD-BB6E-88C1F90B805D',
-        interface: [
-            ['GetSlice', [], ['Slice']],
-            ['SetSlice', [['slice', ['Slice']]]],
-            ['GetUnsafe', [], {'*': 'bool'}],
-            ['SetUnsafe', [['p', {'*': ['Slice']}], ['size', 'u32']]],
-        ],
+        interface: {
+            GetSlice: {
+                _: ['Slice']
+            },
+            SetSlice: {
+                slice: ['Slice']
+            },
+            GetUnsafe: {
+                _: ['*', 'bool']
+            },
+            SetUnsafe: {
+                p: ['*', ['Slice']],
+                size: 'u32'
+            },
+        },
     }
 }
 

package/com/types/main.f.js

@@ -9,7 +9,7 @@
  * }} Struct
  */
 
-/** @typedef {readonly Field[]} FieldArray */
+/** @typedef {{readonly[k in string]: Type}} FieldArray */
 
 /** @typedef {readonly[string, Type]} Field */
 
@@ -20,13 +20,7 @@
  * }} Interface
  */
 
-/** @typedef {readonly Method[]} MethodArray */
-
-/** @typedef {readonly[string, FieldArray, Type]} GetMethod */
-
-/** @typedef {readonly[string, FieldArray]} SetMethod */
-
-/** @typedef {GetMethod|SetMethod} Method */
+/** @typedef {{readonly[k in string]: FieldArray}} MethodArray */
 
 /** @typedef {BaseType|Id|Pointer} Type */
 
@@ -50,6 +44,6 @@
  * } BaseType
  */
 
-/** @typedef {{readonly '*': Type}} Pointer */
+/** @typedef {readonly['*', Type]} Pointer */
 
 module.exports = {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.361",
+  "version": "0.0.362",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "main.f.js",
   "scripts": {