Remove objc2 build script

Author: madsmtm

objc-sys/Cargo.toml

@@ -1,6 +1,8 @@
 [package]
 name = "objc-sys"
-version = "0.2.0-alpha.1" # Remember to update html_root_url in lib.rs
+# Remember to update `html_root_url` in lib.rs, the `links` key, and the
+# exception function name.
+version = "0.2.0-alpha.1"
 authors = ["Mads Marquart <[email protected]>"]
 edition = "2021"
 
@@ -43,6 +45,12 @@ winobjc = ["gnustep-1-8"]
 # TODO
 objfw = []
 
+# Private/unstable features - must not be relied on!
+unstable-exception = ["cc"]
+
+[build-dependencies]
+cc = { version = "1", optional = true }
+
 [package.metadata.docs.rs]
 default-target = "x86_64-apple-darwin"
 no-default-features = true

objc-sys/build.rs

@@ -211,4 +211,25 @@ fn main() {
         // Link to libobjc
         println!("cargo:rustc-link-lib=dylib=objc");
     }
+
+    // We do this compilation step here instead of in `objc2` to cut down on
+    // the total number of build scripts required.
+    #[cfg(feature = "unstable-exception")]
+    {
+        if std::env::var("DOCS_RS").is_ok() {
+            // docs.rs doesn't have clang, so skip building this. The
+            // documentation will still work since it doesn't need to link.
+            return;
+        }
+        println!("cargo:rerun-if-changed=extern/exception.m");
+
+        let mut builder = cc::Build::new();
+        builder.file("extern/exception.m");
+
+        for flag in cc_args.split(' ') {
+            builder.flag(flag);
+        }
+
+        builder.compile("librust_objc_sys_0_2_try_catch_exception.a");
+    }
 }

objc2/extern/exception.m renamed to objc-sys/extern/exception.m

@@ -6,8 +6,10 @@
 /// See <https://clang.llvm.org/docs/AutomaticReferenceCounting.html#arc-runtime-objc-retain>.
 id objc_retain(id value);
 
-// We return `unsigned char`, since it is guaranteed to be an `u8` on all platforms
-unsigned char rust_objc_try_catch_exception(void (*f)(void *), void *context, id *error) {
+/// Unsure how C name resolution works, so we make sure to version this symbol.
+///
+/// Return `unsigned char` since it is guaranteed to be `u8` on all platforms.
+unsigned char rust_objc_sys_0_2_try_catch_exception(void (*f)(void *), void *context, id *error) {
     @try {
         f(context);
         if (error) {

objc-sys/src/exception.rs

@@ -2,10 +2,12 @@
 //! Apple: `objc-exception.h`
 //! GNUStep: `eh_personality.c`, which is a bit brittle to rely on, but I
 //!   think it's fine...
-#[cfg(not(objfw))]
+#[cfg(any(not(objfw), feature = "unstable-exception"))]
 use core::ffi::c_void;
 #[cfg(apple)]
 use std::os::raw::c_int;
+#[cfg(feature = "unstable-exception")]
+use std::os::raw::c_uchar;
 
 #[cfg(apple)]
 use crate::objc_class;
@@ -73,4 +75,26 @@ extern_c! {
     //
     // #[cfg(gnustep)]
     // pub fn objc_set_apple_compatible_objcxx_exceptions(newValue: c_int) -> c_int;
+
+    /// Call the given function inside an Objective-C `@try/@catch` block.
+    ///
+    /// Defined in `extern/exception.m` and compiled in `build.rs`.
+    ///
+    /// Alternatively, we could manually write assembly for this function like
+    /// [`objrs` does][manual-asm] does, that would cut down on a build stage
+    /// (and would probably give us a bit better performance), but it gets
+    /// unwieldy _very_ quickly, so I chose the much more stable option.
+    ///
+    /// Another thing to remember: While Rust's and Objective-C's unwinding
+    /// mechanisms are similar now, Rust's is explicitly unspecified, and they
+    /// may diverge significantly in the future; so handling this in pure Rust
+    /// (using mechanisms like core::intrinsics::r#try) is not an option!
+    ///
+    /// [manual-asm]: https://gitlab.com/objrs/objrs/-/blob/b4f6598696b3fa622e6fddce7aff281770b0a8c2/src/exception.rs
+    #[cfg(feature = "unstable-exception")]
+    pub fn rust_objc_sys_0_2_try_catch_exception(
+        f: extern "C" fn(*mut c_void),
+        context: *mut c_void,
+        error: *mut *mut objc_object,
+    ) -> c_uchar;
 }

objc2/Cargo.toml

@@ -16,15 +16,13 @@ repository = "https://github.com/madsmtm/objc2"
 documentation = "https://docs.rs/objc2/"
 license = "MIT"
 
-build = "build.rs"
-
 # NOTE: 'unstable' features are _not_ considered part of the SemVer contract,
 # and may be removed in a minor release.
 [features]
 default = ["apple"]
 
 # Enables `objc2::exception::throw` and `objc2::exception::catch`
-exception = ["cc"]
+exception = ["objc-sys/unstable-exception"]
 
 # Wrap every `objc2::msg_send` call in a `@try/@catch` block
 catch_all = ["exception"]
@@ -56,9 +54,6 @@ malloc_buf = { version = "1.0", optional = true }
 objc-sys = { path = "../objc-sys", version = "=0.2.0-alpha.1", default-features = false }
 objc2-encode = { path = "../objc2-encode", version = "=2.0.0-beta.2", default-features = false }
 
-[build-dependencies]
-cc = { version = "1", optional = true }
-
 [dev-dependencies]
 iai = { version = "0.1", git = "https://github.com/madsmtm/iai", branch = "callgrind" }
 

objc2/build.rs

@@ -20,35 +20,11 @@
 use core::ffi::c_void;
 use core::mem;
 use core::ptr;
-use std::os::raw::c_uchar;
 
 use crate::ffi;
 use crate::rc::{Id, Shared};
 use crate::runtime::Object;
 
-extern "C" {
-    /// Call the given function inside an Objective-C `@try/@catch` block.
-    ///
-    /// Defined in `extern/exception.m` and compiled in `build.rs`.
-    ///
-    /// Alternatively, we could manually write assembly for this function like
-    /// [`objrs` does][manual-asm] does, that would cut down on a build stage
-    /// (and would probably give us a bit better performance), but it gets
-    /// unwieldy _very_ quickly, so I chose the much more stable option.
-    ///
-    /// Another thing to remember: While Rust's and Objective-C's unwinding
-    /// mechanisms are similar now, Rust's is explicitly unspecified, and they
-    /// may diverge significantly in the future; so handling this in pure Rust
-    /// (using mechanisms like core::intrinsics::r#try) is not an option!
-    ///
-    /// [manual-asm]: https://gitlab.com/objrs/objrs/-/blob/b4f6598696b3fa622e6fddce7aff281770b0a8c2/src/exception.rs
-    fn rust_objc_try_catch_exception(
-        f: extern "C" fn(*mut c_void),
-        context: *mut c_void,
-        error: *mut *mut ffi::objc_object,
-    ) -> c_uchar;
-}
-
 /// Throws an Objective-C exception.
 ///
 /// The argument must be a pointer to an Objective-C object.
@@ -87,7 +63,7 @@ unsafe fn try_no_ret<F: FnOnce()>(closure: F) -> Result<(), Option<Id<Object, Sh
     let context = &mut closure as *mut _ as *mut c_void;
 
     let mut exception = ptr::null_mut();
-    let success = unsafe { rust_objc_try_catch_exception(f, context, &mut exception) };
+    let success = unsafe { ffi::rust_objc_sys_0_2_try_catch_exception(f, context, &mut exception) };
 
     if success == 0 {
         Ok(())