Add generic_ctypes Cargo feature

NB: SGX and Switch can just use the generics

Author: josephlr

Cargo.toml

@@ -28,6 +28,7 @@ use_std = []
 align = []
 rustc-dep-of-std = ['align', 'rustc-std-workspace-core']
 extra_traits = ["align"]
+generic_ctypes = []
 
 [workspace]
 members = ["libc-test"]

README.md

@@ -45,7 +45,7 @@ libc = { version = "0.2", features = ["align"] }
 ```
 
 All structs implemented by the libc crate have the `Copy` and `Clone` traits
-implemented for them. The additional traits of `Debug, `Eq`, `Hash`, and
+implemented for them. The additional traits of `Debug`, `Eq`, `Hash`, and
 `PartialEq` can be enabled with the *extra_traits* feature (requires Rust 1.25
 or newer):
 
@@ -54,6 +54,22 @@ or newer):
 libc = { version = "0.2", features = ["extra_traits"] }
 ```
 
+A large number of targets are supported by libc; however, some unsupported or
+custom targets just need libc's basic types (`c_int`, `size_t`, etc...) for 
+linking to C code. These types can be enabled for _any_ target with the
+*generic_ctypes* feature:
+
+```toml
+[dependencies.libc]
+version = "0.2"
+default-features = false
+features = ["generic_ctypes"]
+```
+
+Note that if you target has strange definitions for C types, *generic_ctypes*
+will not necessarily generate the correct types, as the generation process is 
+based only on your CPU architecture and pointer size.
+
 ## What is libc?
 
 The primary purpose of this crate is to provide all of the definitions necessary

src/cloudabi/mod.rs

@@ -1,5 +1,18 @@
 use dox::Option;
 
+pub type c_short = i16;
+pub type c_ushort = u16;
+pub type c_int = i32;
+pub type c_uint = u32;
+pub type c_longlong = i64;
+pub type c_ulonglong = u64;
+pub type intmax_t = i64;
+pub type uintmax_t = u64;
+
+pub type size_t = usize;
+pub type ptrdiff_t = isize;
+pub type ssize_t = isize;
+
 pub type in_addr_t = u32;
 pub type in_port_t = u16;
 pub type pthread_key_t = usize;
@@ -58,6 +71,9 @@ s! {
     }
 }
 
+pub const INT_MIN: c_int = -2147483648;
+pub const INT_MAX: c_int = 2147483647;
+
 pub const _SC_NPROCESSORS_ONLN: ::c_int = 52;
 pub const _SC_PAGESIZE: ::c_int = 54;
 

src/fuchsia/mod.rs

@@ -7,6 +7,19 @@ use dox::{mem, Option};
 
 // PUB_TYPE
 
+pub type c_short = i16;
+pub type c_ushort = u16;
+pub type c_int = i32;
+pub type c_uint = u32;
+pub type c_longlong = i64;
+pub type c_ulonglong = u64;
+pub type intmax_t = i64;
+pub type uintmax_t = u64;
+
+pub type size_t = usize;
+pub type ptrdiff_t = isize;
+pub type ssize_t = isize;
+
 pub type pid_t = i32;
 pub type uid_t = u32;
 pub type gid_t = u32;
@@ -1069,6 +1082,9 @@ s! {
 
 // PUB_CONST
 
+pub const INT_MIN: c_int = -2147483648;
+pub const INT_MAX: c_int = 2147483647;
+
 pub const SIG_DFL: sighandler_t = 0 as sighandler_t;
 pub const SIG_IGN: sighandler_t = 1 as sighandler_t;
 pub const SIG_ERR: sighandler_t = !0 as sighandler_t;

src/generic.rs

@@ -0,0 +1,100 @@
+//! This module attempts to attempts to give reasonable definitions for most
+//! basic C types. Note that these are essentially educated guesses and are NOT
+//! guaranteed to match the types produced by your C compiler.
+
+// Per the C11 specification, these type definitions are not guaranteed to be
+// correct for all platforms. However, virtually all platforms use these
+// definitions, including all targets supported by rustc.
+pub type c_short = i16;
+pub type c_ushort = u16;
+pub type c_int = i32;
+pub type c_uint = u32;
+pub type c_longlong = i64;
+pub type c_ulonglong = u64;
+pub type intmax_t = i64;
+pub type uintmax_t = u64;
+pub type size_t = usize;
+pub type ptrdiff_t = isize;
+pub type ssize_t = isize;
+
+pub const INT_MIN: c_int = -2147483648;
+pub const INT_MAX: c_int = 2147483647;
+
+// There are two ways that platforms (in practice) differ in their C types:
+//   - chars can either be signed or unsigned
+//   - longs can either be 32-bit or 64-bit
+
+// Whether chars default to signed or unsigned is primarily determined by
+// architecture (windows is the main exception here).
+pub use self::chars::*;
+#[cfg(any(
+    target_arch = "aarch64",
+    target_arch = "arm",
+    target_arch = "armebv7r",
+    target_arch = "armv5te",
+    target_arch = "armv7",
+    target_arch = "armv7r",
+    target_arch = "armv7s",
+    target_arch = "asmjs",
+    target_arch = "wasm32",
+    target_arch = "wasm64",
+    target_arch = "powerpc",
+    target_arch = "powerpc64",
+    target_arch = "powerpc64le",
+    target_arch = "s390x",
+    target_arch = "thumbv6",
+    target_arch = "thumbv6m",
+    target_arch = "thummv7",
+    target_arch = "thumbv7em",
+    target_arch = "thumbv7m",
+    target_arch = "thumbv7neon",
+    target_arch = "tummbv8",
+    target_arch = "thumbv8m",
+    target_arch = "thumbv8m.main"
+))]
+mod chars {
+    pub type c_char = u8;
+    pub type wchar_t = u32;
+}
+
+#[cfg(any(
+    target_arch = "i386",
+    target_arch = "i586",
+    target_arch = "i686",
+    target_arch = "x86",
+    target_arch = "x86_64",
+    target_arch = "mips",
+    target_arch = "mips64",
+    target_arch = "mips64el",
+    target_arch = "mipsel",
+    target_arch = "nvptx",
+    target_arch = "nvptx64",
+    target_arch = "sparc64",
+    target_arch = "sparcv9",
+    target_arch = "riscv64",
+    target_arch = "riscv32",
+    target_arch = "riscv32imac",
+    target_arch = "riscv32imc"
+))]
+mod chars {
+    pub type c_char = i8;
+    pub type wchar_t = i32;
+}
+
+// On all platforms but Windows, longs are the same size as a pointer.
+pub use self::long::*;
+#[cfg(target_pointer_width = "64")]
+mod long {
+    pub type c_long = i64;
+    pub type c_ulong = u64;
+}
+
+#[cfg(any(target_pointer_width = "16", target_pointer_width = "32"))]
+mod long {
+    pub type c_long = i32;
+    pub type c_ulong = u32;
+}
+
+// POSIX specifications make no guarantees that off_t == long int, but this is
+// what GNU and others always do.
+pub type off_t = ::c_long;

src/lib.rs

@@ -135,7 +135,7 @@ mod macros;
 
 mod dox;
 
-// C types that are always the same Rust type
+// Per the Rust and C11 specs, these C types will always have these definitions.
 pub type int8_t = i8;
 pub type int16_t = i16;
 pub type int32_t = i32;
@@ -144,28 +144,12 @@ pub type uint8_t = u8;
 pub type uint16_t = u16;
 pub type uint32_t = u32;
 pub type uint64_t = u64;
-
+pub type intptr_t = isize;
+pub type uintptr_t = usize;
 pub type c_schar = i8;
 pub type c_uchar = u8;
-pub type c_short = i16;
-pub type c_ushort = u16;
-pub type c_int = i32;
-pub type c_uint = u32;
 pub type c_float = f32;
 pub type c_double = f64;
-pub type c_longlong = i64;
-pub type c_ulonglong = u64;
-pub type intmax_t = i64;
-pub type uintmax_t = u64;
-
-pub type size_t = usize;
-pub type ptrdiff_t = isize;
-pub type intptr_t = isize;
-pub type uintptr_t = usize;
-pub type ssize_t = isize;
-
-pub const INT_MIN: c_int = -2147483648;
-pub const INT_MAX: c_int = 2147483647;
 
 cfg_if! {
     if #[cfg(core_cvoid)] {
@@ -199,16 +183,13 @@ cfg_if! {
     } else if #[cfg(target_os = "fuchsia")] {
         mod fuchsia;
         pub use fuchsia::*;
-    } else if #[cfg(target_os = "switch")] {
-        mod switch;
-        pub use switch::*;
     } else if #[cfg(unix)] {
         mod unix;
         pub use unix::*;
-    } else if #[cfg(target_env = "sgx")] {
-        mod sgx;
-        pub use sgx::*;
-    }  else {
-        // non-supported targets: empty...
+    } else {
+        // Some targets only need the generic C types (and don't need functions)
+        #[cfg(any(feature = "generic_ctypes", target_env = "sgx", target_os = "switch"))]
+        mod generic;
+        pub use generic::*;
     }
 }

src/redox/mod.rs

@@ -1,3 +1,16 @@
+pub type c_short = i16;
+pub type c_ushort = u16;
+pub type c_int = i32;
+pub type c_uint = u32;
+pub type c_longlong = i64;
+pub type c_ulonglong = u64;
+pub type intmax_t = i64;
+pub type uintmax_t = u64;
+
+pub type size_t = usize;
+pub type ptrdiff_t = isize;
+pub type ssize_t = isize;
+
 pub type c_char = i8;
 pub type c_long = i64;
 pub type c_ulong = u64;
@@ -73,6 +86,9 @@ s! {
     }
 }
 
+pub const INT_MIN: ::c_int = -2147483648;
+pub const INT_MAX: ::c_int = 2147483647;
+
 pub const STDIN_FILENO: ::c_int = 0;
 pub const STDOUT_FILENO: ::c_int = 1;
 pub const STDERR_FILENO: ::c_int = 2;

src/sgx.rs

@@ -5,6 +5,19 @@
 
 use dox::Option;
 
+pub type c_short = i16;
+pub type c_ushort = u16;
+pub type c_int = i32;
+pub type c_uint = u32;
+pub type c_longlong = i64;
+pub type c_ulonglong = u64;
+pub type intmax_t = i64;
+pub type uintmax_t = u64;
+
+pub type size_t = usize;
+pub type ptrdiff_t = isize;
+pub type ssize_t = isize;
+
 pub type pid_t = i32;
 pub type uid_t = u32;
 pub type gid_t = u32;
@@ -198,6 +211,9 @@ s! {
     }
 }
 
+pub const INT_MIN: ::c_int = -2147483648;
+pub const INT_MAX: ::c_int = 2147483647;
+
 pub const SIG_DFL: sighandler_t = 0 as sighandler_t;
 pub const SIG_IGN: sighandler_t = 1 as sighandler_t;
 pub const SIG_ERR: sighandler_t = !0 as sighandler_t;

src/switch.rs

@@ -1,5 +1,17 @@
 //! Windows CRT definitions
 
+pub type c_short = i16;
+pub type c_ushort = u16;
+pub type c_int = i32;
+pub type c_uint = u32;
+pub type c_longlong = i64;
+pub type c_ulonglong = u64;
+pub type intmax_t = i64;
+pub type uintmax_t = u64;
+
+pub type size_t = usize;
+pub type ptrdiff_t = isize;
+pub type ssize_t = isize;
 pub type sighandler_t = usize;
 
 pub type c_char = i8;
@@ -80,6 +92,9 @@ s! {
     }
 }
 
+pub const INT_MIN: ::c_int = -2147483648;
+pub const INT_MAX: ::c_int = 2147483647;
+
 pub const EXIT_FAILURE: ::c_int = 1;
 pub const EXIT_SUCCESS: ::c_int = 0;
 pub const RAND_MAX: ::c_int = 32767;