functionalscript 0.3.4 → 0.3.6

package/com/rust/nanocom/tests/it.rs

@@ -1,186 +0,0 @@
-#![allow(non_snake_case)]
-
-// interface definition:
-
-mod library {
-    use nanocom::{CObject, Class, Interface, Object, Ref, GUID};
-
-    #[repr(C)]
-    pub struct IMy {
-        pub A: unsafe extern "system" fn(this: &Object<IMy>) -> Ref<IMy>,
-        pub B: unsafe extern "system" fn(this: &Object<IMy>) -> u32,
-    }
-
-    impl Interface for IMy {
-        const GUID: GUID = 0x01234567_89AB_CDEF_0123_456789ABCDEF;
-    }
-
-    pub trait IMyEx {
-        fn A(&self) -> Ref<IMy>;
-        fn B(&self) -> u32;
-    }
-
-    impl IMyEx for Object<IMy> {
-        fn A(&self) -> Ref<IMy> {
-            unsafe { (self.interface().A)(self) }
-        }
-        fn B(&self) -> u32 {
-            unsafe { (self.interface().B)(self) }
-        }
-    }
-
-    pub trait IMyVmt: Class<Interface = IMy>
-    where
-        CObject<Self>: IMyEx,
-    {
-        const INTERFACE: IMy = IMy {
-            A: Self::A,
-            B: Self::B,
-        };
-    }
-
-    impl<T: Class<Interface = IMy>> IMyVmt for T where CObject<T>: IMyEx {}
-
-    trait IMyVmtFn: Class<Interface = IMy>
-    where
-        CObject<Self>: IMyEx,
-    {
-        extern "system" fn A(this: &Object<IMy>) -> Ref<IMy> {
-            unsafe { CObject::from_object_unchecked(this) }.A()
-        }
-        extern "system" fn B(this: &Object<IMy>) -> u32 {
-            unsafe { CObject::from_object_unchecked(this) }.B()
-        }
-    }
-
-    impl<T: Class<Interface = IMy>> IMyVmtFn for T where CObject<T>: IMyEx {}
-}
-
-// interface implementation
-mod number {
-    use nanocom::{CObject, Class, Ref, Vmt};
-
-    use super::library::{IMy, IMyEx, IMyVmt};
-
-    pub struct X(pub u32);
-
-    impl Class for X {
-        type Interface = IMy;
-        fn static_vmt() -> &'static Vmt<Self::Interface> {
-            static V: Vmt<IMy> = Vmt {
-                iunknown: CObject::<X>::IUNKNOWN,
-                interface: X::INTERFACE,
-            };
-            &V
-        }
-    }
-
-    #[allow(non_snake_case)]
-    impl IMyEx for CObject<X> {
-        fn A(&self) -> Ref<IMy> {
-            self.into()
-        }
-        fn B(&self) -> u32 {
-            self.value.0
-        }
-    }
-}
-
-mod use_number {
-    use nanocom::CObjectEx;
-
-    use super::{library::IMyEx, number::X};
-
-    #[test]
-    fn test() {
-        let a = X(42).to_cobject();
-        let a1 = a.A();
-        assert_eq!(a, a1);
-        assert_eq!(a.B(), 42);
-        let b = X(43).to_cobject();
-        assert_ne!(a, b);
-        assert_eq!(b.B(), 43);
-    }
-}
-
-mod destructor {
-    use std::{
-        rc::Rc,
-        sync::atomic::{AtomicU32, Ordering},
-    };
-
-    use nanocom::{CObject, Class, Ref, Vmt};
-
-    use super::library::{IMy, IMyEx, IMyVmt};
-
-    pub struct X {
-        p: Rc<AtomicU32>,
-    }
-
-    impl X {
-        pub fn new(p: Rc<AtomicU32>) -> Self {
-            p.fetch_add(1, Ordering::Relaxed);
-            Self { p }
-        }
-    }
-
-    impl Drop for X {
-        fn drop(&mut self) {
-            self.p.fetch_sub(1, Ordering::Relaxed);
-        }
-    }
-
-    impl Class for X {
-        type Interface = IMy;
-        fn static_vmt() -> &'static Vmt<Self::Interface> {
-            static V: Vmt<IMy> = Vmt {
-                iunknown: CObject::<X>::IUNKNOWN,
-                interface: X::INTERFACE,
-            };
-            &V
-        }
-    }
-
-    #[allow(non_snake_case)]
-    impl IMyEx for CObject<X> {
-        fn A(&self) -> Ref<IMy> {
-            self.into()
-        }
-        fn B(&self) -> u32 {
-            self.value.p.load(Ordering::Relaxed)
-        }
-    }
-}
-
-mod use_destructor {
-    use std::{
-        rc::Rc,
-        sync::atomic::{AtomicU32, Ordering},
-    };
-
-    use nanocom::CObjectEx;
-
-    use super::{destructor::X, library::IMyEx};
-
-    #[test]
-    fn test() {
-        let p = Rc::new(AtomicU32::default());
-        {
-            assert_eq!(p.load(Ordering::Relaxed), 0);
-            let a = X::new(p.clone()).to_cobject();
-            assert_eq!(p.load(Ordering::Relaxed), 1);
-            let a1 = a.A();
-            assert_eq!(p.load(Ordering::Relaxed), 1);
-            assert_eq!(a, a1);
-            assert_eq!(a.B(), 1);
-            {
-                let b = X::new(p.clone()).to_cobject();
-                assert_eq!(p.load(Ordering::Relaxed), 2);
-                assert_ne!(a, b);
-                assert_eq!(b.B(), 2);
-            }
-            assert_eq!(p.load(Ordering::Relaxed), 1);
-        }
-        assert_eq!(p.load(Ordering::Relaxed), 0);
-    }
-}

package/com/rust/nanocom/tests/itmod.rs

@@ -1,195 +0,0 @@
-#![allow(non_snake_case)]
-
-// interface definition:
-
-mod library {
-    pub mod IMy {
-        use nanocom::CObject;
-
-        pub type Object = nanocom::Object<Interface>;
-        pub type Ref = nanocom::Ref<Interface>;
-        pub type Vmt = nanocom::Vmt<Interface>;
-
-        #[repr(C)]
-        pub struct Interface {
-            pub A: unsafe extern "system" fn(this: &Object) -> Ref,
-            pub B: unsafe extern "system" fn(this: &Object) -> u32,
-        }
-
-        impl nanocom::Interface for Interface {
-            const GUID: nanocom::GUID = 0x01234567_89AB_CDEF_0123_456789ABCDEF;
-        }
-
-        pub trait Ex {
-            fn A(&self) -> Ref;
-            fn B(&self) -> u32;
-        }
-
-        impl Ex for Object {
-            fn A(&self) -> Ref {
-                unsafe { (self.interface().A)(self) }
-            }
-            fn B(&self) -> u32 {
-                unsafe { (self.interface().B)(self) }
-            }
-        }
-
-        pub trait ClassEx: nanocom::Class<Interface = Interface>
-        where
-            nanocom::CObject<Self>: Ex,
-        {
-            const VMT: Vmt = Vmt {
-                iunknown: CObject::<Self>::IUNKNOWN,
-                interface: Interface {
-                    A: Self::A,
-                    B: Self::B,
-                },
-            };
-        }
-
-        impl<T: nanocom::Class<Interface = Interface>> ClassEx for T where nanocom::CObject<T>: Ex {}
-
-        trait PrivateClassEx: nanocom::Class<Interface = Interface>
-        where
-            nanocom::CObject<Self>: Ex,
-        {
-            extern "system" fn A(this: &Object) -> Ref {
-                unsafe { CObject::from_object_unchecked(this) }.A()
-            }
-            extern "system" fn B(this: &Object) -> u32 {
-                unsafe { CObject::from_object_unchecked(this) }.B()
-            }
-        }
-
-        impl<T: nanocom::Class<Interface = Interface>> PrivateClassEx for T where nanocom::CObject<T>: Ex {}
-    }
-}
-
-// interface implementation
-mod number {
-    use nanocom::{CObject, Vmt};
-
-    use crate::library::IMy::ClassEx;
-
-    use super::library::IMy;
-
-    pub struct X(pub u32);
-
-    impl nanocom::Class for X {
-        type Interface = IMy::Interface;
-        fn static_vmt() -> &'static Vmt<Self::Interface> {
-            static V: IMy::Vmt = X::VMT;
-            &V
-        }
-    }
-
-    impl IMy::Ex for CObject<X> {
-        fn A(&self) -> IMy::Ref {
-            self.into()
-        }
-        fn B(&self) -> u32 {
-            self.value.0
-        }
-    }
-}
-
-mod use_number {
-    use nanocom::CObjectEx;
-
-    use crate::library::IMy::Ex;
-
-    use super::number::X;
-
-    #[test]
-    fn test() {
-        let a = X(42).to_cobject();
-        let a1 = a.A();
-        assert_eq!(a, a1);
-        assert_eq!(a.B(), 42);
-        let b = X(43).to_cobject();
-        assert_ne!(a, b);
-        assert_eq!(b.B(), 43);
-    }
-}
-
-mod destructor {
-    use std::{
-        rc::Rc,
-        sync::atomic::{AtomicU32, Ordering},
-    };
-
-    use nanocom::{CObject, Vmt};
-
-    use crate::library::IMy::ClassEx;
-
-    use super::library::IMy;
-
-    pub struct X {
-        p: Rc<AtomicU32>,
-    }
-
-    impl X {
-        pub fn new(p: Rc<AtomicU32>) -> Self {
-            p.fetch_add(1, Ordering::Relaxed);
-            Self { p }
-        }
-    }
-
-    impl Drop for X {
-        fn drop(&mut self) {
-            self.p.fetch_sub(1, Ordering::Relaxed);
-        }
-    }
-
-    impl nanocom::Class for X {
-        type Interface = IMy::Interface;
-        fn static_vmt() -> &'static Vmt<Self::Interface> {
-            static V: IMy::Vmt = X::VMT;
-            &V
-        }
-    }
-
-    impl IMy::Ex for CObject<X> {
-        fn A(&self) -> IMy::Ref {
-            self.into()
-        }
-        fn B(&self) -> u32 {
-            self.value.p.load(Ordering::Relaxed)
-        }
-    }
-}
-
-mod use_destructor {
-    use std::{
-        rc::Rc,
-        sync::atomic::{AtomicU32, Ordering},
-    };
-
-    use nanocom::CObjectEx;
-
-    use crate::library::IMy::Ex;
-
-    use super::destructor::X;
-
-    #[test]
-    fn test() {
-        let p = Rc::new(AtomicU32::default());
-        {
-            assert_eq!(p.load(Ordering::Relaxed), 0);
-            let a = X::new(p.clone()).to_cobject();
-            assert_eq!(p.load(Ordering::Relaxed), 1);
-            let a1 = a.A();
-            assert_eq!(p.load(Ordering::Relaxed), 1);
-            assert_eq!(a, a1);
-            assert_eq!(a.B(), 1);
-            {
-                let b = X::new(p.clone()).to_cobject();
-                assert_eq!(p.load(Ordering::Relaxed), 2);
-                assert_ne!(a, b);
-                assert_eq!(b.B(), 2);
-            }
-            assert_eq!(p.load(Ordering::Relaxed), 1);
-        }
-        assert_eq!(p.load(Ordering::Relaxed), 0);
-    }
-}

package/com/rust/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 { rust } from './module.f.ts'
-import library from '../types/testlib.f.ts'
-
-export default join('\n')(flat('    ')(rust(library)))

package/com/test/build.f.ts

@@ -1,111 +0,0 @@
-import * as list from '../../types/list/module.f.ts'
-const { flat } = list
-
-import cppContent from '../cpp/testlib.f.ts'
-import csContent from '../cs/testlib.f.ts'
-import rustContent from '../rust/testlib.f.ts'
-
-type Platform =
-   | 'aix'
-   | 'android'
-   | 'darwin'
-   | 'freebsd'
-   | 'haiku'
-   | 'linux'
-   | 'openbsd'
-   | 'sunos'
-   | 'win32'
-   | 'cygwin'
-   | 'netbsd'
-
-type NodeJs = {
-   readonly dirname: string
-   readonly platform: Platform
-}
-
-type Output ={
-   readonly file: {
-       readonly name: string
-       readonly content: string
-   }
-   readonly line: list.List<list.List<string>>
-}
-
-export type Func = (nodejs: NodeJs) => Output
-
-const flags
-    : (platform: Platform) => readonly string[]
-    = platform => {
-
-    switch (platform) {
-        case 'win32':
-            return []
-        case 'linux':
-            return ['-std=c++17', '-lstdc++', '-fPIC']
-        default:
-            return ['-std=c++17', '-lc++']
-    }
-}
-
-const output
-    : (platform: Platform) => (name: string) => string
-    = platform => name => {
-
-    switch (platform) {
-        case 'win32': return `${name}.dll`
-        case 'darwin': return `lib${name}.dylib`
-        default: return `lib${name}.so`
-    }
-}
-
-const cpp
-    : Func
-    = ({ dirname, platform }) => ({
-
-    file: {
-        name: `${dirname}/cpp/_result.hpp`,
-        content: cppContent(),
-    },
-    line: [
-        flat([
-            ['clang', '-shared', '-o', output(platform)('testc')],
-            flags(platform),
-            [`${dirname}/cpp/main.cpp`],
-        ]),
-    ],
-})
-
-const cs
-    : Func
-    = ({ dirname, platform }) => ({
-
-    file: {
-        name: `${dirname}/cs/_result.cs`,
-        content: csContent,
-    },
-    line: [
-        platform === 'win32'
-            ? ['dotnet', 'run', '--project', `${dirname}/cs/cs.csproj`]
-            // .Net on Linux and MacOS doesn't properly support COM object marshalling
-            : ['dotnet', 'build', `${dirname}/cs/cs.csproj`]
-    ],
-})
-
-const rust
-: Func
-= ({ dirname }) => ({
-    file: {
-        name: `${dirname}/rust/src/_result.rs`,
-        content: rustContent,
-    },
-    line: [['cargo', 'build' /**, '--locked' */]]
-})
-
-export default {
-    /** @readonly */
-    cpp,
-    /** @readonly */
-    cs,
-    /** @readonly */
-    rust,
-}

package/com/test/build.ts

@@ -1,45 +0,0 @@
-import { writeFileSync } from 'node:fs'
-import { execSync } from 'node:child_process'
-import { platform, exit } from 'node:process'
-import build, * as Build from './build.f.ts'
-const { cpp, cs, rust } = build
-import * as string from '../../types/string/module.f.ts'
-const { join } = string
-const { log, error } = console
-import * as sgr from '../../text/sgr/module.f.ts'
-const { bold, reset } = sgr
-import * as list from '../../types/list/module.f.ts'
-
-import { fileURLToPath } from 'node:url'
-import { dirname } from 'node:path'
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename)
-
-const nodeJs = {
-    dirname: __dirname,
-    platform,
-}
-
-const run
-    : (f: Build.Func) => void
-    = f => {
-    const { file: { name, content }, line } = f(nodeJs)
-    log(`${bold}writing: ${name}${reset}`)
-    writeFileSync(name, content)
-    for (const i of list.iterable(line)) {
-        const cmd = join(' ')(i)
-        log(`${bold}running: ${cmd}${reset}`)
-        try {
-            log(execSync(cmd).toString())
-        } catch (e) {
-            // @ts-ignore
-            error(e.output.toString())
-            exit(-1)
-        }
-    }
-}
-
-run(cpp)
-run(rust)
-run(cs)

package/com/test/cpp/main.cpp

@@ -1,74 +0,0 @@
-#include "../../cpp/nanocom.hpp"
-#include "_result.hpp"
-
-#ifdef _WIN32
-#define DLL_EXPORT __declspec(dllexport)
-#else
-#define DLL_EXPORT
-#endif
-
-DLL_EXPORT
-extern "C" int c_get()
-{
-    return 43;
-}
-
-class Impl : public My::IMy
-{
-public:
-    My::Slice GetSlice() const noexcept override
-    {
-    }
-    void SetSlice(My::Slice slice) const noexcept override
-    {
-        std::cout
-            << "SetSlice: "
-            << (slice.Start - static_cast<uint8_t const *>(nullptr))
-            << ", "
-            << slice.Size
-            << std::endl;
-    }
-    bool const *GetUnsafe() const noexcept override
-    {
-    }
-    void SetUnsafe(My::Slice const *p, uint32_t size) const noexcept override
-    {
-    }
-    bool Some(My::IMy const &p) const noexcept override
-    {
-    }
-    My::IMy const *GetIMy_(uint16_t a, int16_t b) const noexcept override
-    {
-        return ::nanocom::to_ref(*this).copy_to_raw();
-    }
-    void SetManagedStruct(My::ManagedStruct a) const noexcept override
-    {
-    }
-    ~Impl()
-    {
-        ::std::cout << "done" << std::endl;
-    }
-};
-
-DLL_EXPORT
-extern "C" My::IMy const *c_my_create()
-{
-    {
-        auto const a = ::nanocom::implementation<Impl>::create().copy_to_raw();
-        // auto const c = *x; // no copy constructor
-        Impl *b;
-        b = const_cast<Impl*>(::nanocom::implementation<Impl>::create().copy_to_raw());
-        // *b = *a; // no assignment operator
-        b->Release();
-        a->Release();
-    }
-    {
-        auto const x = ::nanocom::implementation<Impl>::create().copy_to_raw();
-        x->Release();
-    }
-    {
-        auto const x = ::nanocom::implementation<Impl>::create().upcast<My::IMy>();
-        x->SetSlice(My::Slice());
-    }
-    return ::nanocom::implementation<Impl>::create().copy_to_raw();
-}

package/com/test/cs/Program.cs

@@ -1,31 +0,0 @@
-using System.Runtime.InteropServices;
-using My;
-
-[DllImport("testrust")]
-static extern int get();
-
-[DllImport("testrust")]
-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 });
-
-{
-    var y = c_my_create();
-    y.SetSlice(new Slice { Start = null, Size = (UIntPtr)45 });
-    var t = y.GetIMy(1, 2);
-}
-
-GC.Collect();
-Console.WriteLine("ok");

package/com/test/cs/cs.csproj

@@ -1,16 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <None Include="../../../target/debug/*testrust.*" CopyToOutputDirectory="PreserveNewest"/>
-    <None Include="../../../*testc.*" CopyToOutputDirectory="PreserveNewest"/>
-  </ItemGroup>
-
-</Project>

package/com/test/rust/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "testrust"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-nanocom = { path = "../../rust/nanocom" }