Add Variant helpers

Author: NICK

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().alloc_utf16_str(prop_name)
+                    memory_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().alloc_utf16_str(method_name)
+                    memory_manager().copy_utf16_str(method_name)
                 }
                 get_method_name::<#ident>
             },
@@ -182,7 +182,7 @@ pub fn native_object(_args: TokenStream, input: TokenStream) -> TokenStream {
                         true => None,
                         false => Some(std::slice::from_raw_parts_mut(params, size))
                     };
-                    _0.call_as_proc(num, params, size)
+                    _0.call_as_proc(num, params)
                 }
                 call_as_proc::<#ident>
             },
@@ -195,7 +195,7 @@ pub fn native_object(_args: TokenStream, input: TokenStream) -> TokenStream {
                     };
                     let ret = &mut *ret;
 
-                    _0.call_as_func(num, ret, params, size)
+                    _0.call_as_func(num, ret, params)
                 }
                 call_as_func::<#ident>
             }
@@ -232,7 +232,7 @@ 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().alloc_utf16_str(#ident_str); }
+                unsafe { *name = memory_manager().copy_utf16_str(#ident_str); }
                 true
             }
         }

src/component.rs

@@ -82,8 +82,8 @@ pub trait IComponentBase {
     fn get_n_params(&self, method_num: i64) -> i64;
     fn get_param_def_value(&self, method_num: i64, param_num: i64, var_param_def_value: &mut Variant) -> bool;
     fn has_ret_val(&self, method_num: i64) -> bool;
-    fn call_as_proc(&mut self, method_num: i64, params: Option<&mut [Variant]>, size: usize) -> bool;
-    fn call_as_func(&mut self, method_num: i64, ret_vals: &mut Variant, params: Option<&mut [Variant]>, size: usize) -> bool;
+    fn call_as_proc(&mut self, method_num: i64, params: Option<&mut [Variant]>) -> bool;
+    fn call_as_func(&mut self, method_num: i64, ret_vals: &mut Variant, params: Option<&mut [Variant]>) -> bool;
 
     // LocaleBaseVTable
     fn set_locale(&mut self, loc: &str);

src/connector.rs

@@ -26,13 +26,13 @@ pub struct IConnector {
 
 impl IConnector {
     pub fn add_error(&mut self, code: u16, source: &str, descr: &str, scode: i64) -> bool {
-        let source = memory_manager().alloc_utf16_str(source);
-        let descr = memory_manager().alloc_utf16_str(descr);
+        let source = memory_manager().copy_utf16_str(source);
+        let descr = memory_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().alloc_utf16_str(prop_name);
+        let prop_name = memory_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();
@@ -46,12 +46,12 @@ impl IConnector {
     }
 
     pub fn write(&mut self, prop_name: &str, value: &Variant) -> bool {
-        let prop_name = memory_manager().alloc_utf16_str(prop_name);
+        let prop_name = memory_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().alloc_utf16_str(profile_name);
+        let profile_name = memory_manager().copy_utf16_str(profile_name);
         unsafe { (self.vtable.as_mut().register_profile_as)(self, profile_name) }
     }
 
@@ -64,9 +64,9 @@ impl IConnector {
     }
 
     pub fn external_event(&mut self, source: &str, message: &str, data: &str) -> bool {
-        let source = memory_manager().alloc_utf16_str(source);
-        let message = memory_manager().alloc_utf16_str(message);
-        let data = memory_manager().alloc_utf16_str(data);
+        let source = memory_manager().copy_utf16_str(source);
+        let message = memory_manager().copy_utf16_str(message);
+        let data = memory_manager().copy_utf16_str(data);
         unsafe { (self.vtable.as_mut().external_event)(self, source, message, data) }
     }
 
@@ -75,7 +75,7 @@ impl IConnector {
     }
 
     pub fn set_status_line(&mut self, message: &str) -> bool {
-        let message = memory_manager().alloc_utf16_str(message);
+        let message = memory_manager().copy_utf16_str(message);
         unsafe { (self.vtable.as_mut().set_status_line)(self, message) }
     }
 

src/memory.rs

@@ -26,7 +26,33 @@ impl IMemoryManager {
         }
     }
 
-    pub fn alloc_utf16_str(&mut self, value: &str) -> *const u16 {
+    pub fn copy_u8_array<T>(&mut self, value: &[T]) -> *const u8 {
+        let mut ptr = std::ptr::null_mut();
+        let data_ptr = value.as_ptr() as *const u8;
+        let size = value.len() * std::mem::size_of::<T>();
+        self.alloc_memory((&mut ptr as *mut *mut u8) as *mut *const c_void, size);
+        unsafe {
+            if !value.is_empty() {
+                std::ptr::copy(data_ptr, ptr, size);
+            }
+        }
+        ptr
+    }
+
+    pub fn copy_utf8_str(&mut self, value: &str) -> *const u8 {
+        let mut ptr = std::ptr::null_mut();
+        let data_ptr = value.as_ptr();
+        self.alloc_memory((&mut ptr as *mut *mut u8) as *mut *const c_void, value.len() + 1);
+        unsafe {
+            if !value.is_empty() {
+                std::ptr::copy(data_ptr, ptr, value.len() + 1);
+            }
+            std::ptr::write(((ptr as usize) + value.len()) as *mut u8, 0x00 as u8);
+        }
+        ptr
+    }
+
+    pub fn copy_utf16_str(&mut self, value: &str) -> *const u16 {
         let data = value.encode_utf16().collect::<Vec<u16>>();
         let data_ptr = data.as_ptr();
         let mut ptr = std::ptr::null_mut();