functionalscript 0.0.413 → 0.0.416

package/Cargo.lock

@@ -5,10 +5,3 @@ version = 3
 [[package]]
 name = "nanocom"
 version = "0.1.2"
-
-[[package]]
-name = "rstest"
-version = "0.1.0"
-dependencies = [
- "nanocom",
-]

package/Cargo.toml

@@ -1,5 +1,4 @@
 [workspace]
 members = [
-    "com/rust/nanocom",
-    "com/rust/nanocom/rstest",
+    "com/rust/nanocom"
 ]

package/com/rust/nanocom/README.md

@@ -1,3 +1,56 @@
 # Nano-COM
 
-See [Nano-COM](https://en.wikipedia.org/wiki/Component_Object_Model#Nano-COM_(a.k.a_XPCOM)).
+See [Nano-COM](https://en.wikipedia.org/wiki/Component_Object_Model#Nano-COM_(a.k.a_XPCOM)).
+
+## Function Stack
+
+- a public function.
+  ```rust
+  let o: Object<IMy> = ...;
+  // calling a public function
+  let i: u32 = o.B();
+  ```
+  ```rust
+  trait IMyEx {
+      // a definition
+      fn B(&self) -> u32;
+  }
+  impl IMyEx for Object<IMy> {
+      // an implementation of the public function
+      fn B(&self) -> u32 {
+          // calling a virtual function.
+          unsafe { (self.interface().B()(self) }
+      }
+  }
+  ```
+- a virtual function.
+  ```rust
+  #[repr(C)]
+  pub struct IMy {
+      // a definiton of the virtual function
+      pub B: unsafe extern "stdcall" fn(this: &Object<IMy>) -> u32
+  }
+  trait IMyVmtFn: Class<Interface = IMy>
+  where
+      CObject<Self>: IMyEx
+  {
+      // an implementation of the virtual function
+      extern "stdcall" fn B(this: &Object<IMy>) -> u32 {
+          // calling a function implementation
+          unsafe { Self::to_cobject(this) }.B()
+      }
+  }
+  ```
+- a function implementation.
+  ```rust
+  trait IMyEx {
+      // a definition
+      fn B(&self) -> u32;
+  }
+  impl IMyEx for CObject<X> {
+      // an implementation of the function.
+      fn B(&self) -> u32 {
+          self.value.0
+      }
+  }
+  ```

package/com/rust/nanocom/src/cobject.rs

@@ -35,7 +35,7 @@ impl<T: Class> CObject<T> {
     };
 
     #[allow(non_snake_case)]
-    extern "stdcall" fn QueryInterface(
+    extern "system" fn QueryInterface(
         this: &Object<T::Interface>,
         riid: &u128,
         ppv_object: &mut *const Object,
@@ -51,7 +51,7 @@ impl<T: Class> CObject<T> {
     }
 
     #[allow(non_snake_case)]
-    extern "stdcall" fn AddRef(this: &Object<T::Interface>) -> u32 {
+    extern "system" fn AddRef(this: &Object<T::Interface>) -> u32 {
         unsafe { T::to_cobject(this) }
             .counter
             .fetch_add(1, Ordering::Relaxed)
@@ -59,7 +59,7 @@ impl<T: Class> CObject<T> {
     }
 
     #[allow(non_snake_case)]
-    extern "stdcall" fn Release(this: &Object<T::Interface>) -> u32 {
+    extern "system" fn Release(this: &Object<T::Interface>) -> u32 {
         let t = unsafe { T::to_cobject(this) };
         match t.counter.fetch_sub(1, Ordering::Relaxed) {
             1 => {

package/com/rust/nanocom/src/iunknown.rs

@@ -3,11 +3,11 @@ use crate::{hresult::HRESULT, Object, GUID};
 #[allow(non_snake_case)]
 #[repr(C)]
 pub struct IUnknown<I: 'static> {
-    pub QueryInterface: unsafe extern "stdcall" fn(
+    pub QueryInterface: unsafe extern "system" fn(
         this: &Object<I>,
         riid: &GUID,
         ppv_object: &mut *const Object,
     ) -> HRESULT,
-    pub AddRef: unsafe extern "stdcall" fn(this: &Object<I>) -> u32,
-    pub Release: unsafe extern "stdcall" fn(this: &Object<I>) -> u32,
+    pub AddRef: unsafe extern "system" fn(this: &Object<I>) -> u32,
+    pub Release: unsafe extern "system" fn(this: &Object<I>) -> u32,
 }

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

@@ -0,0 +1,188 @@
+// interface definition:
+
+mod library {
+    use nanocom::{CObject, Class, Interface, Object, Ref, GUID};
+
+    #[allow(non_snake_case)]
+    #[repr(C)]
+    pub struct IMy {
+        pub A: unsafe extern "stdcall" fn(this: &Object<IMy>) -> Ref<IMy>,
+        pub B: unsafe extern "stdcall" fn(this: &Object<IMy>) -> u32,
+    }
+
+    impl Interface for IMy {
+        const GUID: GUID = 0x01234567_89AB_CDEF_0123_456789ABCDEF;
+    }
+
+    #[allow(non_snake_case)]
+    pub trait IMyEx {
+        fn A(&self) -> Ref<IMy>;
+        fn B(&self) -> u32;
+    }
+
+    #[allow(non_snake_case)]
+    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 {}
+
+    #[allow(non_snake_case)]
+    trait IMyVmtFn: Class<Interface = IMy>
+    where
+        CObject<Self>: IMyEx,
+    {
+        extern "stdcall" fn A(this: &Object<IMy>) -> Ref<IMy> {
+            unsafe { Self::to_cobject(this) }.A()
+        }
+        extern "stdcall" fn B(this: &Object<IMy>) -> u32 {
+            unsafe { Self::to_cobject(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: X::IUNKNOWN,
+                interface: X::INTERFACE,
+            };
+            &V
+        }
+    }
+
+    #[allow(non_snake_case)]
+    impl IMyEx for CObject<X> {
+        fn A(&self) -> Ref<IMy> {
+            self.to_interface().into()
+        }
+        fn B(&self) -> u32 {
+            self.value.0
+        }
+    }
+}
+
+mod use_number {
+    use nanocom::Class;
+
+    use super::{library::IMyEx, number::X};
+
+    #[test]
+    fn test() {
+        let a = X(42).cobject_new();
+        let a1 = a.A();
+        assert_eq!(a, a1);
+        assert_eq!(a.B(), 42);
+        let b = X(43).cobject_new();
+        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: X::IUNKNOWN,
+                interface: X::INTERFACE,
+            };
+            &V
+        }
+    }
+
+    #[allow(non_snake_case)]
+    impl IMyEx for CObject<X> {
+        fn A(&self) -> Ref<IMy> {
+            self.to_interface().into()
+        }
+        fn B(&self) -> u32 {
+            self.value.p.load(Ordering::Relaxed)
+        }
+    }
+}
+
+mod use_destructor {
+    use std::{
+        rc::Rc,
+        sync::atomic::{AtomicU32, Ordering},
+    };
+
+    use nanocom::Class;
+
+    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()).cobject_new();
+            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()).cobject_new();
+                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/package.json

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

package/com/rust/nanocom/rstest/Cargo.lock

@@ -1,14 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "com"
-version = "0.1.0"
-
-[[package]]
-name = "rstest"
-version = "0.1.0"
-dependencies = [
- "com",
-]

package/com/rust/nanocom/rstest/Cargo.toml

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

package/com/rust/nanocom/rstest/src/lib.rs

@@ -1,191 +0,0 @@
-#[cfg(test)]
-mod test {
-    // interface definition:
-
-    mod library {
-        use nanocom::{CObject, Class, Interface, Object, Ref, GUID};
-
-        #[allow(non_snake_case)]
-        #[repr(C)]
-        pub struct IMy {
-            pub A: unsafe extern "stdcall" fn(this: &Object<IMy>) -> Ref<IMy>,
-            pub B: unsafe extern "stdcall" fn(this: &Object<IMy>) -> u32,
-        }
-
-        impl Interface for IMy {
-            const GUID: GUID = 0x01234567_89AB_CDEF_0123_456789ABCDEF;
-        }
-
-        #[allow(non_snake_case)]
-        pub trait IMyEx {
-            fn A(&self) -> Ref<IMy>;
-            fn B(&self) -> u32;
-        }
-
-        #[allow(non_snake_case)]
-        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 {}
-
-        #[allow(non_snake_case)]
-        trait IMyVmtFn: Class<Interface = IMy>
-        where
-            CObject<Self>: IMyEx,
-        {
-            extern "stdcall" fn A(this: &Object<IMy>) -> Ref<IMy> {
-                unsafe { Self::to_cobject(this) }.A()
-            }
-            extern "stdcall" fn B(this: &Object<IMy>) -> u32 {
-                unsafe { Self::to_cobject(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: X::IUNKNOWN,
-                    interface: X::INTERFACE,
-                };
-                &V
-            }
-        }
-
-        #[allow(non_snake_case)]
-        impl IMyEx for CObject<X> {
-            fn A(&self) -> Ref<IMy> {
-                self.to_interface().into()
-            }
-            fn B(&self) -> u32 {
-                self.value.0
-            }
-        }
-    }
-
-    mod use_number {
-        use nanocom::Class;
-
-        use crate::test::{library::IMyEx, number::X};
-
-        #[test]
-        fn test() {
-            let a = X(42).cobject_new();
-            let a1 = a.A();
-            assert_eq!(a, a1);
-            assert_eq!(a.B(), 42);
-            let b = X(43).cobject_new();
-            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: X::IUNKNOWN,
-                    interface: X::INTERFACE,
-                };
-                &V
-            }
-        }
-
-        #[allow(non_snake_case)]
-        impl IMyEx for CObject<X> {
-            fn A(&self) -> Ref<IMy> {
-                self.to_interface().into()
-            }
-            fn B(&self) -> u32 {
-                self.value.p.load(Ordering::Relaxed)
-            }
-        }
-    }
-
-    mod use_destructor {
-        use std::{
-            rc::Rc,
-            sync::atomic::{AtomicU32, Ordering},
-        };
-
-        use nanocom::Class;
-
-        use crate::test::{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()).cobject_new();
-                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()).cobject_new();
-                    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);
-        }
-    }
-}