Fix memory manager

NICK · NICK · commit 3ebee2eaa115 · 2022-07-28T23:28:39.000+03:00
diff --git a/macros/src/lib.rs b/macros/src/lib.rs
@@ -96,7 +96,7 @@ pub fn native_object(_args: TokenStream, input: TokenStream) -> TokenStream {
                 unsafe extern "C" fn get_prop_name<T: IComponentBase + IComponentInit>(_0: &T, num: i64, alias: i64) -> *const u16 {
                     let _0 = &*((((_0 as *const T) as *const u8) as usize - 8) as *const T);
                     let prop_name = _0.get_prop_name(num, alias);
-                    memory_manager().copy_utf16_str(prop_name)
+                    _0.mem_manager().copy_utf16_str(prop_name)
                 }
                 get_prop_name::<#ident>
             },
@@ -149,7 +149,7 @@ pub fn native_object(_args: TokenStream, input: TokenStream) -> TokenStream {
                 unsafe extern "C" fn get_method_name<T: IComponentBase + IComponentInit>(_0: &T, num: i64, alias: i64) -> *const u16 {
                     let _0 = &*((((_0 as *const T) as *const u8) as usize - 8) as *const T);
                     let method_name = _0.get_method_name(num, alias);
-                    memory_manager().copy_utf16_str(method_name)
+                    _0.mem_manager().copy_utf16_str(method_name)
                 }
                 get_method_name::<#ident>
             },
@@ -222,6 +222,8 @@ pub fn native_object(_args: TokenStream, input: TokenStream) -> TokenStream {
         #[repr(C)]
         struct Inner {
             vtable: IComponentBaseVTable<#ident>,
+            memory_manager: RefCell<*mut IMemoryManager>,
+            connector1c: RefCell<*mut IConnector>,
         }
 
         impl #ident {
@@ -232,7 +234,25 @@ pub fn native_object(_args: TokenStream, input: TokenStream) -> TokenStream {
 
         impl IComponentInit for #ident {
             fn register_extension_as(&mut self, name: *mut *const u16) -> bool {
-                unsafe { *name = memory_manager().copy_utf16_str(#ident_str); }
+                unsafe { *name = self.mem_manager().copy_utf16_str(#ident_str); }
+                true
+            }
+
+            fn set_mem_manager(&mut self, mem: *mut c_void) -> bool {
+                self.inner.memory_manager = RefCell::new(mem as *mut IMemoryManager);
+                true
+            }
+
+            fn mem_manager(&self) -> &mut IMemoryManager {
+                unsafe { self.inner.memory_manager.borrow_mut().as_mut().unwrap() }
+            }
+
+            fn connector(&self) -> &mut IConnector {
+                unsafe { self.inner.connector1c.borrow_mut().as_mut().unwrap() }
+            }
+
+            fn set_connector(&mut self, connector: *mut c_void) -> bool {
+                self.inner.connector1c = RefCell::new(connector as *mut IConnector);
                 true
             }
         }
@@ -245,6 +265,8 @@ pub fn native_object(_args: TokenStream, input: TokenStream) -> TokenStream {
                         language_extension_vtable: NonNull::from(&#language_ext_vtable_name),
                         locale_base_vtable: NonNull::from(&#locale_vtable_name),
                     },
+                    memory_manager: RefCell::new(std::ptr::null_mut()),
+                    connector1c: RefCell::new(std::ptr::null_mut()),
                 }
             }
         }
@@ -259,10 +281,11 @@ pub fn native_object(_args: TokenStream, input: TokenStream) -> TokenStream {
 
             use std::ptr::NonNull;
             use std::ffi::c_void;
+            use std::cell::RefCell;
             use ::native_1c::component::*;
             use ::native_1c::memory::*;
+            use ::native_1c::connector::*;
             use ::native_1c::types::*;
-            use ::native_1c::memory_manager;
             use ::native_1c::Derivative;
             use ::native_1c::widestring;
 
diff --git a/src/component.rs b/src/component.rs
@@ -1,8 +1,8 @@
 use std::ffi::c_void;
 use std::ptr::NonNull;
-use crate::IConnector;
 use crate::memory::IMemoryManager;
 use crate::types::Variant;
+use crate::connector::IConnector;
 
 #[repr(C)]
 pub struct IInitDoneBaseVTable<T> {
@@ -48,12 +48,16 @@ pub struct IComponentBaseVTable<T> {
 }
 
 pub trait IComponentInit where Self: IComponentBase {
-    fn set_mem_manager(&mut self, mem: *mut c_void) -> bool {
-        crate::set_memory_manager(mem as *mut IMemoryManager)
-    }
+    fn set_mem_manager(&mut self, mem: *mut c_void) -> bool;
+
+    fn mem_manager(&self) -> &mut IMemoryManager;
+
+    fn connector(&self) -> &mut IConnector;
+
+    fn set_connector(&mut self, connector: *mut c_void) -> bool;
 
     fn _init(&mut self, connector: *mut c_void) -> bool {
-        if crate::set_connector(connector as *mut IConnector) {
+        if self.set_connector(connector) {
             return IComponentBase::init(self)
         }
         return false
diff --git a/src/connector.rs b/src/connector.rs
@@ -1,9 +1,26 @@
 use std::ffi::c_void;
 use std::ptr::NonNull;
 use widestring::U16CStr;
-use crate::memory_manager;
+use crate::memory::IMemoryManager;
 use crate::types::Variant;
 
+#[repr(u8)]
+enum Interface {
+    IMsgBox = 0,
+    IPlatformInfo = 1,
+}
+
+#[repr(C)]
+struct IMessageBoxVTable {
+    confirm: unsafe extern "C" fn(&IMessageBox, *const u16, *mut Variant) -> bool,
+    alert: unsafe extern "C" fn(&IMessageBox, *const u16) -> bool,
+}
+
+#[repr(C)]
+struct IMessageBox {
+    vtable: NonNull<IMessageBoxVTable>
+}
+
 #[repr(C)]
 struct IConnectorVTable {
     _drop: unsafe extern "C" fn(&mut IConnector),
@@ -17,41 +34,42 @@ struct IConnectorVTable {
     clean_event_buffer: unsafe extern "C" fn(&mut IConnector),
     set_status_line: unsafe extern "C" fn(&mut IConnector, *const u16) -> bool,
     reset_status_line: unsafe extern "C" fn(&mut IConnector),
+    get_interface: unsafe extern "C" fn(&IConnector, Interface) -> *const c_void,
 }
 
 #[repr(C)]
 pub struct IConnector {
-    vtable: NonNull<IConnectorVTable>
+    vtable: NonNull<IConnectorVTable>,
 }
 
 impl IConnector {
-    pub fn add_error(&mut self, code: u16, source: &str, descr: &str, scode: i64) -> bool {
-        let source = memory_manager().copy_utf16_str(source);
-        let descr = memory_manager().copy_utf16_str(descr);
+    pub fn add_error(&mut self, code: u16, source: &str, descr: &str, scode: i64, manager: &mut IMemoryManager) -> bool {
+        let source = manager.copy_utf16_str(source);
+        let descr = manager.copy_utf16_str(descr);
         unsafe { (self.vtable.as_mut().add_error)(self, code, source, descr, scode) }
     }
 
-    pub fn read(&mut self, prop_name: &str, value: &mut Variant, error: &mut u64, error_description: &mut String) -> bool {
-        let prop_name = memory_manager().copy_utf16_str(prop_name);
+    pub fn read(&mut self, prop_name: &str, value: &mut Variant, error: &mut u64, error_description: &mut String, manager: &mut IMemoryManager) -> bool {
+        let prop_name = manager.copy_utf16_str(prop_name);
         let value = value as *mut Variant;
         let error = error as *mut u64;
         let mut error_description_ptr = std::ptr::null();
 
         let result = unsafe { (self.vtable.as_mut().read)(self, prop_name, value, error, &error_description_ptr) };
         if !error_description_ptr.is_null() {
             *error_description = unsafe { U16CStr::from_ptr_str(error_description_ptr).to_string().unwrap() };
-            memory_manager().free_memory((&mut error_description_ptr as *mut *const u16) as *mut *const c_void);
+            manager.free_memory((&mut error_description_ptr as *mut *const u16) as *mut *const c_void);
         }
         result
     }
 
-    pub fn write(&mut self, prop_name: &str, value: &Variant) -> bool {
-        let prop_name = memory_manager().copy_utf16_str(prop_name);
+    pub fn write(&mut self, prop_name: &str, value: &Variant, manager: &mut IMemoryManager) -> bool {
+        let prop_name = manager.copy_utf16_str(prop_name);
         unsafe { (self.vtable.as_mut().write)(self, prop_name, value as *const Variant) }
     }
 
-    pub fn register_profile_as(&mut self, profile_name: &str) -> bool {
-        let profile_name = memory_manager().copy_utf16_str(profile_name);
+    pub fn register_profile_as(&mut self, profile_name: &str, manager: &mut IMemoryManager) -> bool {
+        let profile_name = manager.copy_utf16_str(profile_name);
         unsafe { (self.vtable.as_mut().register_profile_as)(self, profile_name) }
     }
 
@@ -63,25 +81,62 @@ impl IConnector {
         unsafe { (self.vtable.as_mut().get_event_buffer_depths)(self) }
     }
 
-    pub fn external_event(&mut self, source: &str, message: &str, data: &str) -> bool {
-        let source = memory_manager().copy_utf16_str(source);
-        let message = memory_manager().copy_utf16_str(message);
-        let data = memory_manager().copy_utf16_str(data);
+    pub fn external_event(&mut self, source: &str, message: &str, data: &str, manager: &mut IMemoryManager) -> bool {
+        let source = manager.copy_utf16_str(source);
+        let message = manager.copy_utf16_str(message);
+        let data = manager.copy_utf16_str(data);
         unsafe { (self.vtable.as_mut().external_event)(self, source, message, data) }
     }
 
     pub fn clear_event_buffer(&mut self) {
         unsafe { (self.vtable.as_mut().clean_event_buffer)(self) }
     }
 
-    pub fn set_status_line(&mut self, message: &str) -> bool {
-        let message = memory_manager().copy_utf16_str(message);
+    pub fn set_status_line(&mut self, message: &str, manager: &mut IMemoryManager) -> bool {
+        let message = manager.copy_utf16_str(message);
         unsafe { (self.vtable.as_mut().set_status_line)(self, message) }
     }
 
     pub fn reset_status_line(&mut self) {
         unsafe { (self.vtable.as_mut().reset_status_line)(self) }
     }
 
+    fn get_interface(&mut self, interface: Interface) -> *const c_void {
+        unsafe { (self.vtable.as_mut().get_interface)(self, interface) }
+    }
+
+    pub fn message_box_confirm(&mut self, text: &str, manager: &mut IMemoryManager) -> Result<Variant, ()> {
+        let interface = self.get_interface(Interface::IMsgBox);
+        if interface.is_null() {
+            return Err(())
+        }
+
+        let mut ret= Variant::empty();
+        let text = manager.copy_utf16_str(text);
+        let interface = unsafe { &mut *(interface as *mut IMessageBox) };
+        let result = unsafe { (interface.vtable.as_mut().confirm)(interface, text, &mut ret as *mut Variant) };
+        if result {
+            Ok(ret)
+        }
+        else {
+            Err(())
+        }
+    }
 
+    pub fn message_box_alert(&mut self, text: &str, manager: &mut IMemoryManager) -> Result<(), ()> {
+        let interface = self.get_interface(Interface::IMsgBox);
+        if interface.is_null() {
+            return Err(())
+        }
+
+        let text = manager.copy_utf16_str(text);
+        let interface = unsafe { &mut *(interface as *mut IMessageBox) };
+        let result = unsafe { (interface.vtable.as_mut().alert)(interface, text) };
+        if result {
+            Ok(())
+        }
+        else {
+            Err(())
+        }
+    }
 }
diff --git a/src/lib.rs b/src/lib.rs
@@ -11,31 +11,3 @@ pub mod types;
 pub mod memory;
 pub mod connector;
 
-use memory::IMemoryManager;
-use connector::IConnector;
-
-pub(crate) struct SafePointer<T>(*mut T);
-unsafe impl<T> Sync for SafePointer<T> {}
-unsafe impl<T> Send for SafePointer<T> {}
-
-static MEMORY_MANAGER: OnceCell<SafePointer<IMemoryManager>> = OnceCell::new();
-static CONNECTOR: OnceCell<SafePointer<IConnector>> = OnceCell::new();
-
-pub fn memory_manager() -> &'static mut IMemoryManager {
-    unsafe { MEMORY_MANAGER.get().unwrap().0.as_mut().unwrap() }
-}
-
-pub(crate) fn set_memory_manager(manager: *mut IMemoryManager) -> bool {
-    MEMORY_MANAGER.get_or_init(|| SafePointer(manager));
-    true
-}
-
-pub fn connector() -> &'static mut IConnector {
-    unsafe { CONNECTOR.get().unwrap().0.as_mut().unwrap() }
-}
-
-pub(crate) fn set_connector(connector: *mut IConnector) -> bool {
-    CONNECTOR.get_or_init(|| SafePointer(connector));
-    true
-}
-
diff --git a/src/types.rs b/src/types.rs
