More no_std support

objc/src/cache.rs

@@ -1,6 +1,6 @@
-use std::os::raw::c_void;
-use std::ptr;
-use std::sync::atomic::{AtomicPtr, Ordering};
+use core::ffi::c_void;
+use core::ptr;
+use core::sync::atomic::{AtomicPtr, Ordering};
 
 use crate::runtime::{self, Class, Sel};
 

objc/src/declare.rs

@@ -34,9 +34,11 @@ decl.register();
 ```
 */
 
+use alloc::format;
+use alloc::string::ToString;
+use core::mem;
+use core::ptr;
 use std::ffi::CString;
-use std::mem;
-use std::ptr;
 
 use crate::runtime::{self, Class, Imp, Object, Protocol, Sel, BOOL, NO};
 use crate::{Encode, EncodeArguments, Encoding, Message};
@@ -95,7 +97,7 @@ fn method_type_encoding(ret: &Encoding<'_>, args: &[Encoding<'_>]) -> CString {
     // First two arguments are always self and the selector
     let mut types = format!("{}{}{}", ret, <*mut Object>::ENCODING, Sel::ENCODING);
     for enc in args {
-        use std::fmt::Write;
+        use core::fmt::Write;
         write!(&mut types, "{}", enc).unwrap();
     }
     CString::new(types).unwrap()

objc/src/encode.rs

@@ -55,6 +55,7 @@ encode_args_impl!(A, B, C, D, E, F, G, H, I, J, K, L);
 #[cfg(test)]
 mod tests {
     use crate::runtime::{Class, Object, Sel};
+    use alloc::string::ToString;
     use objc_encode::Encode;
 
     #[test]

objc/src/lib.rs

@@ -60,11 +60,13 @@ The bindings can be used on Linux or *BSD utilizing the
 [GNUstep Objective-C runtime](https://www.github.com/gnustep/libobjc2).
 */
 
-#![crate_name = "objc"]
-#![crate_type = "lib"]
+#![no_std]
 #![warn(missing_docs)]
 #![allow(clippy::missing_safety_doc)]
 
+extern crate alloc;
+extern crate std;
+
 pub use objc_encode::{Encode, Encoding};
 
 pub use crate::encode::EncodeArguments;

objc/src/message/apple/arm.rs

@@ -1,5 +1,5 @@
-use std::any::{Any, TypeId};
-use std::mem;
+use core::any::{Any, TypeId};
+use core::mem;
 
 use crate::runtime::Imp;
 

objc/src/message/apple/mod.rs

@@ -1,4 +1,4 @@
-use std::any::Any;
+use core::any::Any;
 
 use super::{Message, MessageArguments, MessageError, Super};
 use crate::runtime::{Class, Object, Sel};

objc/src/message/apple/x86.rs

@@ -1,5 +1,5 @@
-use std::any::{Any, TypeId};
-use std::mem;
+use core::any::{Any, TypeId};
+use core::mem;
 
 use crate::runtime::Imp;
 

objc/src/message/apple/x86_64.rs

@@ -1,4 +1,4 @@
-use std::mem;
+use core::mem;
 
 use crate::runtime::Imp;
 

objc/src/message/gnustep.rs

@@ -1,5 +1,5 @@
-use std::any::Any;
-use std::mem;
+use core::any::Any;
+use core::mem;
 
 use super::{Message, MessageArguments, MessageError, Super};
 use crate::runtime::{Class, Imp, Object, Sel};

objc/src/message/mod.rs

@@ -1,7 +1,8 @@
-use std::any::Any;
+use alloc::string::{String, ToString};
+use core::any::Any;
+use core::fmt;
+use core::mem;
 use std::error::Error;
-use std::fmt;
-use std::mem;
 
 use crate::runtime::{Class, Imp, Object, Sel};
 use crate::{Encode, EncodeArguments};
@@ -314,7 +315,7 @@ mod tests {
     #[cfg(not(feature = "verify_message"))]
     #[test]
     fn test_send_message_nil() {
-        let nil: *mut Object = ::std::ptr::null_mut();
+        let nil: *mut Object = ::core::ptr::null_mut();
         let result: usize = unsafe { msg_send![nil, hash] };
         assert!(result == 0);
 

objc/src/message/verify.rs

@@ -1,4 +1,4 @@
-use std::fmt;
+use core::fmt;
 
 use crate::runtime::{Class, Method, Object, Sel};
 use crate::{Encode, EncodeArguments, Encoding};

objc/src/rc/autorelease.rs

@@ -1,5 +1,5 @@
 use crate::runtime::{objc_autoreleasePoolPop, objc_autoreleasePoolPush};
-use std::os::raw::c_void;
+use core::ffi::c_void;
 
 // we use a struct to ensure that objc_autoreleasePoolPop during unwinding.
 struct AutoReleaseHelper {

objc/src/rc/strong.rs

@@ -1,6 +1,6 @@
-use std::fmt;
-use std::mem;
-use std::ops::Deref;
+use core::fmt;
+use core::mem;
+use core::ops::Deref;
 
 use super::WeakPtr;
 use crate::runtime::{self, Object};

objc/src/rc/weak.rs

@@ -1,5 +1,6 @@
-use std::cell::UnsafeCell;
-use std::ptr;
+use alloc::boxed::Box;
+use core::cell::UnsafeCell;
+use core::ptr;
 
 use super::StrongPtr;
 use crate::runtime::{self, Object};

objc/src/runtime.rs

@@ -3,12 +3,13 @@
 //! For more information on foreign functions, see Apple's documentation:
 //! <https://developer.apple.com/library/mac/documentation/Cocoa/Reference/ObjCRuntimeRef/index.html>
 
+use core::ffi::c_void;
+use core::fmt;
+use core::ptr;
+use core::str;
 use malloc_buf::Malloc;
 use std::ffi::{CStr, CString};
-use std::fmt;
-use std::os::raw::{c_char, c_int, c_uint, c_void};
-use std::ptr;
-use std::str;
+use std::os::raw::{c_char, c_int, c_uint};
 
 use crate::Encode;
 

objc/src/test_utils.rs

@@ -1,4 +1,4 @@
-use std::ops::{Deref, DerefMut};
+use core::ops::{Deref, DerefMut};
 use std::os::raw::c_char;
 use std::sync::Once;
 

objc_encode/src/encoding.rs

@@ -102,7 +102,7 @@ impl PartialEq<Encoding<'_>> for str {
 #[cfg(test)]
 mod tests {
     use super::Encoding;
-    use std::string::ToString;
+    use alloc::string::ToString;
 
     #[test]
     fn test_array_display() {

objc_encode/src/lib.rs

@@ -44,7 +44,7 @@ assert_eq!(i32::ENCODING.to_string(), "i");
 #![no_std]
 
 #[cfg(test)]
-extern crate std;
+extern crate alloc;
 
 mod encode;
 mod encoding;

objc_exception/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2018"
 
 description = "Rust interface for Objective-C's throw and try/catch statements."
 keywords = ["objective-c", "osx", "ios"]
+categories = ["development-tools::ffi", "no-std"]
 repository = "http://github.com/SSheldon/rust-objc-exception"
 documentation = "http://ssheldon.github.io/rust-objc/objc_exception/"
 license = "MIT"

objc_exception/extern/exception.m

@@ -2,7 +2,8 @@
 // See https://clang.llvm.org/docs/AutomaticReferenceCounting.html#arc-runtime-objc-retain
 id objc_retain(id value);
 
-int RustObjCExceptionTryCatch(void (*try)(void *), void *context, id *error) {
+// We return `unsigned char`, since it is guaranteed to be an `u8` on all platforms
+unsigned char RustObjCExceptionTryCatch(void (*try)(void *), void *context, id *error) {
     @try {
         try(context);
         if (error) {

objc_exception/src/lib.rs

@@ -1,8 +1,13 @@
 //! Rust interface for Objective-C's `@throw` and `@try`/`@catch` statements.
 
-use std::mem;
-use std::os::raw::{c_int, c_void};
-use std::ptr;
+#![no_std]
+
+#[cfg(test)]
+extern crate alloc;
+
+use core::ffi::c_void;
+use core::mem;
+use core::ptr;
 
 #[link(name = "objc", kind = "dylib")]
 // TODO: "C-unwind"
@@ -20,7 +25,7 @@ extern "C" {
         r#try: extern "C" fn(*mut c_void),
         context: *mut c_void,
         error: *mut *mut c_void,
-    ) -> c_int;
+    ) -> u8; // std::os::raw::c_uchar
 }
 
 /// An opaque type representing any Objective-C object thrown as an exception.
@@ -100,8 +105,10 @@ where
 
 #[cfg(test)]
 mod tests {
+    use alloc::string::ToString;
+    use core::ptr;
+
     use super::{r#try, throw};
-    use std::ptr;
 
     #[test]
     fn test_try() {

objc_foundation/derive/src/lib.rs

@@ -4,7 +4,7 @@ extern crate quote;
 extern crate syn;
 
 use proc_macro::TokenStream;
-use quote::{Tokens, ToTokens};
+use quote::{ToTokens, Tokens};
 
 #[proc_macro_derive(INSObject)]
 pub fn impl_object(input: TokenStream) -> TokenStream {
@@ -22,7 +22,8 @@ pub fn impl_object(input: TokenStream) -> TokenStream {
     let mut gen = Tokens::new();
     quote!(
         unsafe impl #impl_generics ::objc::Message for #name #ty_generics #where_clause { }
-    ).to_tokens(&mut gen);
+    )
+    .to_tokens(&mut gen);
 
     quote!(
         impl #impl_generics INSObject for #name #ty_generics #where_clause {
@@ -36,32 +37,36 @@ pub fn impl_object(input: TokenStream) -> TokenStream {
                 }
             }
         }
-    ).to_tokens(&mut gen);
+    )
+    .to_tokens(&mut gen);
 
     quote!(
-        impl #impl_generics ::std::cmp::PartialEq for #name #ty_generics #where_clause {
+        impl #impl_generics ::core::cmp::PartialEq for #name #ty_generics #where_clause {
             fn eq(&self, other: &Self) -> bool {
                 INSObject::is_equal(self, other)
             }
         }
-    ).to_tokens(&mut gen);
+    )
+    .to_tokens(&mut gen);
 
     quote!(
-        impl #impl_generics ::std::hash::Hash for #name #ty_generics #where_clause {
-            fn hash<H>(&self, state: &mut H) where H: ::std::hash::Hasher {
+        impl #impl_generics ::core::hash::Hash for #name #ty_generics #where_clause {
+            fn hash<H>(&self, state: &mut H) where H: ::core::hash::Hasher {
                 INSObject::hash_code(self).hash(state);
             }
         }
-    ).to_tokens(&mut gen);
+    )
+    .to_tokens(&mut gen);
 
     quote!(
-        impl #impl_generics ::std::fmt::Debug for #name #ty_generics #where_clause {
-            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        impl #impl_generics ::core::fmt::Debug for #name #ty_generics #where_clause {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                 let s = INSObject::description(self);
-                ::std::fmt::Display::fmt(&*s, f)
+                ::core::fmt::Display::fmt(&*s, f)
             }
         }
-    ).to_tokens(&mut gen);
+    )
+    .to_tokens(&mut gen);
 
     // Return the generated impl
     gen.parse().unwrap()

objc_foundation/src/array.rs

@@ -1,7 +1,8 @@
-use std::cmp::Ordering;
-use std::marker::PhantomData;
-use std::ops::{Index, Range};
-use std::os::raw::c_void;
+use alloc::vec::Vec;
+use core::cmp::Ordering;
+use core::ffi::c_void;
+use core::marker::PhantomData;
+use core::ops::{Index, Range};
 
 use objc::runtime::{Class, Object};
 use objc::{class, msg_send};
@@ -406,6 +407,9 @@ pub type NSMutableSharedArray<T> = NSMutableArray<T, Shared>;
 
 #[cfg(test)]
 mod tests {
+    use alloc::vec;
+    use alloc::vec::Vec;
+
     use super::{INSArray, INSMutableArray, NSArray, NSMutableArray};
     use crate::{INSObject, INSString, NSObject, NSString};
     use objc_id::Id;

objc_foundation/src/data.rs

@@ -1,6 +1,8 @@
-use std::ops::Range;
-use std::os::raw::c_void;
-use std::slice;
+#[cfg(feature = "block")]
+use alloc::vec::Vec;
+use core::ffi::c_void;
+use core::ops::Range;
+use core::slice;
 
 use super::{INSCopying, INSMutableCopying, INSObject, NSRange};
 #[cfg(feature = "block")]
@@ -57,7 +59,7 @@ pub trait INSData: INSObject {
             let obj: *mut Self = msg_send![obj, initWithBytesNoCopy:bytes_ptr
                                                              length:bytes.len()
                                                         deallocator:dealloc];
-            std::mem::forget(bytes);
+            core::mem::forget(bytes);
             Id::from_retained_ptr(obj)
         }
     }
@@ -135,6 +137,8 @@ impl INSMutableCopying for NSMutableData {
 mod tests {
     use super::{INSData, INSMutableData, NSData, NSMutableData};
     use crate::INSObject;
+    #[cfg(feature = "block")]
+    use alloc::vec;
 
     #[test]
     fn test_bytes() {

objc_foundation/src/dictionary.rs

@@ -1,7 +1,8 @@
-use std::cmp::min;
-use std::marker::PhantomData;
-use std::ops::Index;
-use std::ptr;
+use alloc::vec::Vec;
+use core::cmp::min;
+use core::marker::PhantomData;
+use core::ops::Index;
+use core::ptr;
 
 use objc::runtime::Class;
 use objc::{class, msg_send};
@@ -164,9 +165,11 @@ where
 
 #[cfg(test)]
 mod tests {
+    use alloc::vec;
+    use objc_id::Id;
+
     use super::{INSDictionary, NSDictionary};
     use crate::{INSArray, INSObject, INSString, NSObject, NSString};
-    use objc_id::Id;
 
     fn sample_dict(key: &str) -> Id<NSDictionary<NSString, NSObject>> {
         let string = NSString::from_str(key);