functionalscript 0.3.4 → 0.3.5

package/com/cpp/module.f.ts

@@ -1,180 +0,0 @@
-/**
- * This module generates C++ code blocks, including structs, interfaces, and method headers,
- * based on a COM library of type definitions.
- */
-
-import * as types from '../types/module.f.ts'
-import * as text from '../../text/module.f.ts'
-import * as O from '../../types/object/module.f.ts'
-import * as list from '../../types/list/module.f.ts'
-import * as string from '../../types/string/module.f.ts'
-const { join } = string
-const { paramList } = types
-const { map, flatMap, flat } = list
-const { entries } = Object
-
-const struct
-= (name: string) => (body: text.Block): text.Block =>
-    [`struct ${name}`, '{', body, '};']
-
-const baseTypeMap = {
-    u8: 'uint8_t',
-    i8: 'int8_t',
-    u16: 'uint16_t',
-    i16: 'int16_t',
-    u32: 'uint32_t',
-    i32: 'int32_t',
-    u64: 'uint64_t',
-    i64: 'int64_t',
-    usize: 'size_t',
-    isize: 'ptrdiff_t',
-    f32: 'float',
-    f64: 'double',
-    bool: 'bool',
-}
-
-const baseType
-    : (t: types.BaseType) => string
-    = t => baseTypeMap[t]
-
-const resultVoid = types.result('void')
-
-const namespace = text.curly('namespace')
-
-const comRef
-    : (id: string) => string
-    = id => `::nanocom::ref<${id}>`
-
-const ptr
-    : (id: string) => string
-    = id => `${id} const*`
-
-const ref
-    : (id: string) => string
-    = id => `${id} const&`
-
-const paramName
-    : (p: types.Field) => string
-    = ([name]) => name
-
-const mapParamName = map(paramName)
-
-const joinComma = join(', ')
-
-/**
- * Generates the C++ code for a library.
- */
-export const cpp
-    : (name: string) => (lib: types.Library) => text.Block
-    = name => lib => {
-
-    const interface_
-        : (t: types.Type) => string|null
-        = t => {
-
-        if (!(t instanceof Array) || t.length !== 1) {
-            return null
-        }
-        const [name] = t
-        return 'interface' in lib[name] ? name : null
-    }
-
-    const objectType
-        : (i: (t: string) => string) => (t: types.Type) => string
-        = i => t => {
-
-        if (typeof (t) === 'string') { return baseType(t) }
-        if (t.length === 2) { return `${type(t[1])} const*` }
-        const [id] = t
-        return 'interface' in lib[id] ? i(id) : id
-    }
-
-    const type = objectType(comRef)
-
-    const resultType = objectType(ptr)
-
-    const field
-        : (s: types.Field) => text.Item
-        = ([name, t]) => `${type(t)} ${name};`
-
-    const mapField = map(field)
-
-    const defStruct
-        : (s: types.Struct) => text.Block
-        = s => mapField(entries(s.struct))
-
-    const cppResult
-        : (fa: types.FieldArray) => string
-        = resultVoid(resultType)
-
-    const param
-        : (p: types.Field) => string
-        = ([name, t]) => `${objectType(ref)(t)} ${name}`
-
-    const mapParam = map(param)
-
-    const methodHeader
-        : (result: string) => (paramArrayStr: string) => (name: string) => text.Item
-        = result => paramArrayStr => name =>
-            `virtual ${result} ${name}${paramArrayStr} const noexcept = 0;`
-
-    const method
-        : (m: types.Method) => readonly text.Item[]
-        = ([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 === null) {
-            return [m(name)]
-        }
-        return [
-            m(`${name}_`),
-            `${comRef(resultName)} ${name}${paramArrayStr} const noexcept`,
-            '{',
-            [`return ::nanocom::move_to_ref(${name}_(${joinComma(mapParamName(paramL))}));`],
-            '}',
-        ]
-    }
-
-    const mapMethod = flatMap(method)
-
-    const defInterface
-        : (i: types.Interface) => text.Block
-        = ({ guid, interface: i }) => {
-
-        const g = guid.replaceAll('-', '');
-        const lo = g.substring(0, 16);
-        const hi = g.substring(16);
-        return flat([
-            [`constexpr static ::nanocom::GUID const guid = ::nanocom::GUID(0x${lo}, 0x${hi});`],
-            mapMethod(entries(i))
-        ])
-    }
-
-    const def
-        : (kv: O.Entry<types.Definition>) => text.Block
-        = ([name, d]) => 'interface' in d
-
-        ? [
-            `class ${name} : public ::nanocom::IUnknown`,
-            '{',
-            'public:',
-            defInterface(d),
-            '};'
-        ]
-        : struct(name)(defStruct(d))
-
-    const forward
-        : (kv: O.Entry<types.Definition>) => text.Block
-        = ([name]) => [`struct ${name};`]
-
-    const e = entries(lib)
-
-    return flat([
-        ['#pragma once', ''],
-        namespace(name)(flat([flatMap(forward)(e), flatMap(def)(e)]))
-    ])
-}

package/com/cpp/nanocom.hpp

@@ -1,195 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <cstddef>
-#include <atomic>
-#include <iostream>
-
-static_assert(sizeof(bool) == 1);
-
-namespace nanocom
-{
-    constexpr uint64_t byteswap(uint64_t v) noexcept
-    {
-        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;
-    }
-
-    class GUID
-    {
-    public:
-        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);
-        }
-    };
-
-    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 = 60; i >= 0; i -= 4)
-        {
-            os << hex_digit(v, i);
-        }
-    }
-
-    inline std::ostream &operator<<(std::ostream &os, GUID const &self)
-    {
-        guid_part(os, self.lo);
-        guid_part(os, self.hi);
-        return os;
-    }
-
-    enum class HRESULT : uint32_t
-    {
-        S_OK = 0,
-        E_NOINTERFACE = 0x80004002,
-    };
-
-    typedef uint32_t ULONG;
-
-    class IUnknown
-    {
-    public:
-        virtual HRESULT QueryInterface(GUID const &riid, IUnknown const **ppvObject) const noexcept = 0;
-        virtual ULONG AddRef() const noexcept = 0;
-        virtual ULONG Release() const noexcept = 0;
-    protected:
-        IUnknown() = default;
-    private:
-        IUnknown(IUnknown const&);
-        IUnknown& operator=(IUnknown const&);
-    };
-
-    template <class I>
-    class ref
-    {
-    public:
-        explicit ref(I const &other) noexcept : p(other)
-        {
-            p.AddRef();
-        }
-        ref(ref const &other) noexcept : ref(other.p)
-        {
-        }
-        ~ref() noexcept
-        {
-            p.Release();
-        }
-
-        template <class U>
-        ref<U> upcast() const noexcept
-        {
-            return ref<U>(p);
-        }
-
-        I const *operator->() const noexcept
-        {
-            return &p;
-        }
-
-        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 const &p;
-        ref(I const *const p) : p(*p) {}
-    };
-
-    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);
-    }
-
-    constexpr static GUID const iunknown_guid =
-        GUID(0x00000000'0000'0000, 0xC000'000000000046);
-
-    template <class T>
-    class implementation : public T
-    {
-    public:
-        template <class... U>
-        static ref<T> create(U... u)
-        {
-            T const *const p = new implementation(u...);
-            return to_ref(*p);
-        }
-
-    private:
-        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;
-            // std::cout << "T::guid:  " << T::guid << std::endl;
-            // std::cout << std::endl;
-            if (riid != iunknown_guid && riid != T::guid)
-            {
-                return HRESULT::E_NOINTERFACE;
-            }
-            add_ref();
-            *ppvObject = this;
-            return HRESULT::S_OK;
-        }
-
-        ULONG add_ref() const noexcept
-        {
-            return counter.fetch_add(1);
-        }
-
-        ULONG AddRef() const noexcept override
-        {
-            return add_ref() + 1;
-        }
-
-        ULONG Release() const noexcept override
-        {
-            auto const c = counter.fetch_sub(1) - 1;
-            if (c == 0)
-            {
-                delete this;
-            }
-            return c;
-        }
-
-        template <class... U>
-        explicit implementation(U... u) : T(u...) {}
-
-        mutable std::atomic<ULONG> counter;
-    };
-}

package/com/cpp/testlib.f.ts

@@ -1,8 +0,0 @@
-import * as string from '../../types/string/module.f.ts'
-const { join } = string
-import * as text from '../../text/module.f.ts'
-const { flat } = text
-import library from '../types/testlib.f.ts'
-import { cpp } from './module.f.ts'
-
-export default () => join('\n')(flat('    ')(cpp('My')(library)))

package/com/cs/module.f.ts

@@ -1,145 +0,0 @@
-/**
- * This module generates C# code blocks for COM interop from a high-level type library definition.
- *
- * The module maps type definitions (e.g., structs, interfaces, and methods) into C# constructs
- * with appropriate attributes for COM interop, such as `[StructLayout]`, `[Guid]`, and `[InterfaceType]`.
- */
-import * as types from '../types/module.f.ts'
-const { result, paramList } = types
-import * as text from '../../text/module.f.ts'
-const { curly } = text
-import * as list from '../../types/list/module.f.ts'
-const { flat, map, some, flatMap } = list
-import * as string from '../../types/string/module.f.ts'
-const { join } = string
-import * as O from '../../types/object/module.f.ts'
-const { entries } = Object
-
-const using
-    : (v: string) => string
-    = v => `using ${v};`
-
-const typeDef
-    :   (attributes: list.List<string>) =>
-        (type: string) =>
-        (name: string) =>
-        (body: text.Block) =>
-        list.List<text.Item>
-    = attributes => type => name => body =>
-    flat([
-        map(v => `[${v}]`)(attributes),
-        curly(`public ${type}`)(name)(body)
-    ])
-
-const baseTypeMap = {
-    bool: 'byte',
-    f32: 'float',
-    f64: 'double',
-    i16: 'short',
-    i32: 'int',
-    i64: 'long',
-    i8: 'sbyte',
-    isize: 'IntPtr',
-    u16: 'ushort',
-    u32: 'uint',
-    u64: 'ulong',
-    u8: 'byte',
-    usize: 'UIntPtr',
-}
-
-const baseType
-    : (t: types.BaseType) => string
-    = t => baseTypeMap[t]
-
-const unsafe
-    : (isUnsafe: boolean) => string
-    = isUnsafe => isUnsafe ? 'unsafe ' : ''
-
-const fullType
-    : (t: types.Type) => readonly[boolean, string]
-    = t =>
-    typeof (t) === 'string' ? [false, baseType(t)] :
-        t.length === 1 ? [false, t[0]] :
-            [true, `${type(t[1])}*`]
-
-const type
-    : (m: types.Type) => string
-    = t => fullType(t)[1]
-
-const param
-    : (f: types.Field) => string
-    = ([name, t]) => `${type(t)} ${name}`
-
-const mapParam = map(param)
-
-const field
-    : (f: types.Field) => string
-    = ([name, comType]) => {
-    const [isUnsafe, t] = fullType(comType)
-    return `public ${unsafe(isUnsafe)}${t} ${name};`
-}
-
-const isUnsafeField
-    : (field: types.Field) => boolean
-    = field => fullType(field[1])[0]
-
-const mapIsUnsafeField = map(isUnsafeField)
-
-const resultVoid = result('void')
-
-const joinComma = join(', ')
-
-const method
-    : (e: O.Entry<types.FieldArray>) => readonly string[]
-    = ([name, m]) => {
-
-    const paramAndResultList = entries(m)
-    const pl = paramList(m)
-    const isUnsafe = some(mapIsUnsafeField(paramAndResultList))
-    return [
-        '[PreserveSig]',
-        `${unsafe(isUnsafe)}${resultVoid(type)(m)} ${name}(${joinComma(mapParam(pl))});`
-    ]
-}
-
-const struct = typeDef
-    (['StructLayout(LayoutKind.Sequential)'])
-    ('struct')
-
-const mapField = map(field)
-
-const flatMapMethod = flatMap(method)
-
-const def
-    : (e: O.Entry<types.Definition>) => list.List<text.Item>
-    = ([n, d]) => {
-    return !('interface' in d) ?
-        struct(n)(mapField(entries(d.struct))) :
-        typeDef
-            ([`Guid("${d.guid}")`, 'InterfaceType(ComInterfaceType.InterfaceIsIUnknown)'])
-            ('interface')
-            (n)
-            (flatMapMethod(entries(d.interface)))
-}
-
-const flatMapDef = flatMap(def)
-
-const namespace = curly('namespace')
-
-/** @type {text.Block} */
-const header = [
-    using('System'),
-    using('System.Runtime.InteropServices'),
-    ''
-]
-
-/**
- * Generates the C# code for a library.
- */
-export const cs
-    : (name: string) => (library: types.Library) => text.Block
-    = name => library => {
-    const v = flatMapDef(entries(library))
-    const ns = namespace(name)(v)
-    return flat([header, ns])
-}

package/com/cs/testlib.f.ts

@@ -1,8 +0,0 @@
-import * as text from '../../text/module.f.ts'
-const { flat } = text
-import * as string from '../../types/string/module.f.ts'
-const { join } = string
-import { cs } from './module.f.ts'
-import library from '../types/testlib.f.ts'
-
-export default join('\n')(flat('    ')(cs('My')(library)))

package/com/proposals.md

@@ -1,28 +0,0 @@
-# Proposals For NanoCOM
-
-## Pointer Types
-
-- By ownership
-  - direct reference/pointer. `&I`
-  - cloneable wrapper. For example, `ref<I>`.
-- By nullability
-  - non-nullable, a reference. For example, `ref<I>`.
-  - nullable, a pointer. For example, `ptr<I>`.
-- By mutability
-  - immutable. Multithreaded, with an atomic counter. The object can be mutable with synchronization mechanisms.
-  - mutable. Single-threaded. With a simple counter and mutable.
-- By value
-  - interface. All functions are virtual. For example add_ref/release
-  - implementation. Functions can be called directly, including add_ref/release.
-  ```rust
-  trait IUnknown {
-    fn add_ref(self);
-    fn release(self);
-    fn query_interface<I>(self) -> ptr<I>;
-  }
-  // examples
-  impl IUnknown for &IImmutableInterface { ... }
-  impl IUnknown for &mut IMutableInterface { ... }
-  impl IUnknown for &IImmutableInterfaceImplementation { ... }
-  impl IUnknown for &mut IMutableInterfaceImplementation { ... }
-  ```