From d77be0489c2af757231fa5505eb0cac0dce06698 Mon Sep 17 00:00:00 2001 From: eri Date: Wed, 18 Sep 2024 17:21:35 +0200 Subject: [PATCH] remove g_param_spec_types link alltogether --- glib/gobject-sys/Cargo.toml | 2 +- glib/gobject-sys/build_manual.rs | 23 --------- glib/gobject-sys/src/lib.rs | 4 -- glib/gobject-sys/src/manual.rs | 31 ----------- glib/src/param_spec.rs | 89 +++++++++++++++++++++----------- 5 files changed, 61 insertions(+), 88 deletions(-) delete mode 100644 glib/gobject-sys/build_manual.rs delete mode 100644 glib/gobject-sys/src/manual.rs diff --git a/glib/gobject-sys/Cargo.toml b/glib/gobject-sys/Cargo.toml index 67336beac425..57d65f7cfe97 100644 --- a/glib/gobject-sys/Cargo.toml +++ b/glib/gobject-sys/Cargo.toml @@ -28,7 +28,7 @@ v2_82 = ["v2_80"] name = "gobject_sys" [package] -build = "build_manual.rs" +build = "build.rs" description = "FFI bindings to libgobject-2.0" keywords = ["gobject", "ffi", "gtk-rs", "gnome"] name = "gobject-sys" diff --git a/glib/gobject-sys/build_manual.rs b/glib/gobject-sys/build_manual.rs deleted file mode 100644 index 2b89af2a9f03..000000000000 --- a/glib/gobject-sys/build_manual.rs +++ /dev/null @@ -1,23 +0,0 @@ -#[cfg(docsrs)] -fn main() {} // prevent linking libraries to avoid documentation failure - -#[cfg(not(docsrs))] -fn main() { - match system_deps::Config::new().probe() { - Ok(deps) => { - let msvc = std::env::var("CARGO_CFG_TARGET_ENV") - .expect("Cargo should set this variable") - == "msvc"; - let lib = deps - .get_by_name("gobject_2_0") - .expect("The dependency key for gobject in its Cargo.toml should not change"); - if msvc && !lib.statik { - println!("cargo:rustc-cfg=msvc_dll"); - } - } - Err(s) => { - println!("cargo:warning={s}"); - std::process::exit(1); - } - } -} diff --git a/glib/gobject-sys/src/lib.rs b/glib/gobject-sys/src/lib.rs index d97fbe6182d6..048e356d5a28 100644 --- a/glib/gobject-sys/src/lib.rs +++ b/glib/gobject-sys/src/lib.rs @@ -13,10 +13,6 @@ use glib_sys as glib; -mod manual; - -pub use manual::*; - #[allow(unused_imports)] use libc::{ c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void, diff --git a/glib/gobject-sys/src/manual.rs b/glib/gobject-sys/src/manual.rs deleted file mode 100644 index b700b781da45..000000000000 --- a/glib/gobject-sys/src/manual.rs +++ /dev/null @@ -1,31 +0,0 @@ -use glib_sys::GType; - -#[cfg(not(msvc_dll))] -type GParamSpecType = *const GType; - -#[cfg(msvc_dll)] -type GParamSpecType = *const *const GType; - -// When using MSVC, variables marked with dllexport only have the load time linking version -// (prefixed by `__imp_`) publicly exported in the library. This means that it is necessary to either -// call dllimport those symbols (in Rust, this only happens when using the `#[link]` attribute), or -// to manually link to the `__imp_` version when using dynamic libraries. Since we need more customization -// of the library name than the link attribute currently allows, we choose the second option. -extern "C" { - #[cfg_attr(msvc_dll, link_name = "__imp_g_param_spec_types")] - static g_param_spec_types: GParamSpecType; -} - -/// # Safety -/// This should be safe as long as the offset added to g_param_spec_types is in bounds. -pub unsafe fn g_param_spec_types_get_type(offset: usize) -> GType { - #[cfg(not(msvc_dll))] - let ptr = g_param_spec_types; - - // One more step of indirection on windows because `__imp_` signifies a pointer to the - // underlying symbol https://learn.microsoft.com/en-us/windows/win32/dlls/load-time-dynamic-linking. - #[cfg(msvc_dll)] - let ptr = *g_param_spec_types; - - *ptr.add(offset) -} diff --git a/glib/src/param_spec.rs b/glib/src/param_spec.rs index d116ea0cf6d5..8bd73b7c8781 100644 --- a/glib/src/param_spec.rs +++ b/glib/src/param_spec.rs @@ -297,13 +297,12 @@ pub unsafe trait ParamSpecType: } macro_rules! define_param_spec { - ($rust_type:ident, $ffi_type:path, $rust_type_offset:expr) => { + ($rust_type:ident, $ffi_type:path, $type_name:literal) => { impl StaticType for $rust_type { #[inline] fn static_type() -> Type { - unsafe { - from_glib(gobject_sys::g_param_spec_types_get_type($rust_type_offset)) - } + const NAME: &CStr = unsafe { std::ffi::CStr::from_bytes_with_nul_unchecked(concat!($type_name, "\0").as_bytes()) }; + unsafe { from_glib(gobject_ffi::g_type_from_name(NAME.as_ptr())) } } } @@ -551,8 +550,8 @@ macro_rules! define_param_spec_min_max { } macro_rules! define_param_spec_numeric { - ($rust_type:ident, $ffi_type:path, $value_type:ty, $rust_type_offset:expr, $ffi_fun:ident) => { - define_param_spec!($rust_type, $ffi_type, $rust_type_offset); + ($rust_type:ident, $ffi_type:path, $value_type:ty, $type_name:literal, $ffi_fun:ident) => { + define_param_spec!($rust_type, $ffi_type, $type_name); define_param_spec_default!($rust_type, $ffi_type, $value_type, |x| x); define_param_spec_min_max!($rust_type, $ffi_type, $value_type); @@ -782,7 +781,7 @@ define_param_spec_numeric!( ParamSpecChar, gobject_ffi::GParamSpecChar, i8, - 0, + "GParamChar", g_param_spec_char ); @@ -802,7 +801,7 @@ define_param_spec_numeric!( ParamSpecUChar, gobject_ffi::GParamSpecUChar, u8, - 1, + "GParamUChar", g_param_spec_uchar ); @@ -823,7 +822,11 @@ wrapper! { unref => |ptr| gobject_ffi::g_param_spec_unref(ptr as *mut gobject_ffi::GParamSpec), } } -define_param_spec!(ParamSpecBoolean, gobject_ffi::GParamSpecBoolean, 2); +define_param_spec!( + ParamSpecBoolean, + gobject_ffi::GParamSpecBoolean, + "GParamBoolean" +); define_param_spec_default!( ParamSpecBoolean, @@ -874,7 +877,7 @@ define_param_spec_numeric!( ParamSpecInt, gobject_ffi::GParamSpecInt, i32, - 3, + "GParamInt", g_param_spec_int ); @@ -894,7 +897,7 @@ define_param_spec_numeric!( ParamSpecUInt, gobject_ffi::GParamSpecUInt, u32, - 4, + "GParamUInt", g_param_spec_uint ); @@ -919,7 +922,7 @@ define_param_spec_numeric!( ParamSpecLong, gobject_ffi::GParamSpecLong, libc::c_long, - 5, + "GParamLong", g_param_spec_long ); @@ -944,7 +947,7 @@ define_param_spec_numeric!( ParamSpecULong, gobject_ffi::GParamSpecULong, libc::c_ulong, - 6, + "GParamULong", g_param_spec_ulong ); @@ -969,7 +972,7 @@ define_param_spec_numeric!( ParamSpecInt64, gobject_ffi::GParamSpecInt64, i64, - 7, + "GParamInt64", g_param_spec_int64 ); @@ -994,7 +997,7 @@ define_param_spec_numeric!( ParamSpecUInt64, gobject_ffi::GParamSpecUInt64, u64, - 8, + "GParamUInt64", g_param_spec_uint64 ); @@ -1015,7 +1018,11 @@ wrapper! { unref => |ptr| gobject_ffi::g_param_spec_unref(ptr as *mut gobject_ffi::GParamSpec), } } -define_param_spec!(ParamSpecUnichar, gobject_ffi::GParamSpecUnichar, 9); +define_param_spec!( + ParamSpecUnichar, + gobject_ffi::GParamSpecUnichar, + "GParamUnichar" +); define_param_spec_default!(ParamSpecUnichar, gobject_ffi::GParamSpecUnichar, Result, TryFrom::try_from); impl ParamSpecUnichar { @@ -1057,7 +1064,7 @@ wrapper! { unref => |ptr| gobject_ffi::g_param_spec_unref(ptr as *mut gobject_ffi::GParamSpec), } } -define_param_spec!(ParamSpecEnum, gobject_ffi::GParamSpecEnum, 10); +define_param_spec!(ParamSpecEnum, gobject_ffi::GParamSpecEnum, "GParamEnum"); impl ParamSpecEnum { unsafe fn new_unchecked<'a>( @@ -1201,7 +1208,7 @@ wrapper! { unref => |ptr| gobject_ffi::g_param_spec_unref(ptr as *mut gobject_ffi::GParamSpec), } } -define_param_spec!(ParamSpecFlags, gobject_ffi::GParamSpecFlags, 11); +define_param_spec!(ParamSpecFlags, gobject_ffi::GParamSpecFlags, "GParamFlags"); impl ParamSpecFlags { unsafe fn new_unchecked<'a>( @@ -1344,7 +1351,7 @@ define_param_spec_numeric!( ParamSpecFloat, gobject_ffi::GParamSpecFloat, f32, - 12, + "GParamFloat", g_param_spec_float ); @@ -1369,7 +1376,7 @@ define_param_spec_numeric!( ParamSpecDouble, gobject_ffi::GParamSpecDouble, f64, - 13, + "GParamDouble", g_param_spec_double ); @@ -1390,7 +1397,11 @@ wrapper! { unref => |ptr| gobject_ffi::g_param_spec_unref(ptr as *mut gobject_ffi::GParamSpec), } } -define_param_spec!(ParamSpecString, gobject_ffi::GParamSpecString, 14); +define_param_spec!( + ParamSpecString, + gobject_ffi::GParamSpecString, + "GParamString" +); define_param_spec_default!( ParamSpecString, @@ -1499,7 +1510,7 @@ wrapper! { unref => |ptr| gobject_ffi::g_param_spec_unref(ptr as *mut gobject_ffi::GParamSpec), } } -define_param_spec!(ParamSpecParam, gobject_ffi::GParamSpecParam, 15); +define_param_spec!(ParamSpecParam, gobject_ffi::GParamSpecParam, "GParamParam"); impl ParamSpecParam { unsafe fn new_unchecked<'a>( @@ -1541,7 +1552,7 @@ wrapper! { unref => |ptr| gobject_ffi::g_param_spec_unref(ptr as *mut gobject_ffi::GParamSpec), } } -define_param_spec!(ParamSpecBoxed, gobject_ffi::GParamSpecBoxed, 16); +define_param_spec!(ParamSpecBoxed, gobject_ffi::GParamSpecBoxed, "GParamBoxed"); impl ParamSpecBoxed { unsafe fn new_unchecked<'a>( @@ -1629,7 +1640,11 @@ wrapper! { unref => |ptr| gobject_ffi::g_param_spec_unref(ptr as *mut gobject_ffi::GParamSpec), } } -define_param_spec!(ParamSpecPointer, gobject_ffi::GParamSpecPointer, 17); +define_param_spec!( + ParamSpecPointer, + gobject_ffi::GParamSpecPointer, + "GParamPointer" +); impl ParamSpecPointer { unsafe fn new_unchecked<'a>( @@ -1665,7 +1680,11 @@ wrapper! { unref => |ptr| gobject_ffi::g_param_spec_unref(ptr as *mut gobject_ffi::GParamSpec), } } -define_param_spec!(ParamSpecValueArray, gobject_ffi::GParamSpecValueArray, 18); +define_param_spec!( + ParamSpecValueArray, + gobject_ffi::GParamSpecValueArray, + "GParamValueArray" +); impl ParamSpecValueArray { unsafe fn new_unchecked<'a>( @@ -1785,7 +1804,11 @@ wrapper! { unref => |ptr| gobject_ffi::g_param_spec_unref(ptr as *mut gobject_ffi::GParamSpec), } } -define_param_spec!(ParamSpecObject, gobject_ffi::GParamSpecObject, 19); +define_param_spec!( + ParamSpecObject, + gobject_ffi::GParamSpecObject, + "GParamObject" +); impl ParamSpecObject { unsafe fn new_unchecked<'a>( @@ -1873,7 +1896,11 @@ wrapper! { unref => |ptr| gobject_ffi::g_param_spec_unref(ptr as *mut gobject_ffi::GParamSpec), } } -define_param_spec!(ParamSpecOverride, gobject_ffi::GParamSpecOverride, 20); +define_param_spec!( + ParamSpecOverride, + gobject_ffi::GParamSpecOverride, + "GParamOverride" +); impl ParamSpecOverride { unsafe fn new_unchecked(name: &str, overridden: impl AsRef) -> ParamSpec { @@ -1981,7 +2008,7 @@ wrapper! { unref => |ptr| gobject_ffi::g_param_spec_unref(ptr as *mut gobject_ffi::GParamSpec), } } -define_param_spec!(ParamSpecGType, gobject_ffi::GParamSpecGType, 21); +define_param_spec!(ParamSpecGType, gobject_ffi::GParamSpecGType, "GParamGType"); impl ParamSpecGType { unsafe fn new_unchecked<'a>( @@ -2021,7 +2048,11 @@ wrapper! { unref => |ptr| gobject_ffi::g_param_spec_unref(ptr as *mut gobject_ffi::GParamSpec), } } -define_param_spec!(ParamSpecVariant, gobject_ffi::GParamSpecVariant, 22); +define_param_spec!( + ParamSpecVariant, + gobject_ffi::GParamSpecVariant, + "GParamVariant" +); define_param_spec_default!( ParamSpecVariant,