From 3f725f97eb500aad7697b25e2ab2a40739428b36 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Mon, 24 Aug 2015 23:08:37 -0700 Subject: [PATCH] Start splitting out a separate sys package Moved array and base so far --- .gitignore | 4 +- core-foundation-sys/Cargo.toml | 13 +++++ core-foundation-sys/build.rs | 3 ++ core-foundation-sys/src/array.rs | 48 ++++++++++++++++++ core-foundation-sys/src/base.rs | 54 ++++++++++++++++++++ core-foundation-sys/src/lib.rs | 6 +++ core-foundation/Cargo.toml | 1 + core-foundation/src/array.rs | 56 ++------------------- core-foundation/src/base.rs | 84 +------------------------------ core-foundation/src/boolean.rs | 4 +- core-foundation/src/bundle.rs | 3 +- core-foundation/src/data.rs | 7 +-- core-foundation/src/dictionary.rs | 7 +-- core-foundation/src/lib.rs | 11 ++-- core-foundation/src/number.rs | 7 +-- core-foundation/src/runloop.rs | 16 +++--- core-foundation/src/set.rs | 6 ++- core-foundation/src/string.rs | 11 ++-- core-foundation/src/url.rs | 6 +-- 19 files changed, 175 insertions(+), 172 deletions(-) create mode 100644 core-foundation-sys/Cargo.toml create mode 100644 core-foundation-sys/build.rs create mode 100644 core-foundation-sys/src/array.rs create mode 100644 core-foundation-sys/src/base.rs create mode 100644 core-foundation-sys/src/lib.rs diff --git a/.gitignore b/.gitignore index 2a66ba7..be576c4 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,3 @@ -/Cargo.lock -/target +Cargo.lock +target/ diff --git a/core-foundation-sys/Cargo.toml b/core-foundation-sys/Cargo.toml new file mode 100644 index 0000000..523bd46 --- /dev/null +++ b/core-foundation-sys/Cargo.toml @@ -0,0 +1,13 @@ +[package] +name = "core-foundation-sys" +description = "Bindings to Core Foundation for OS X" +homepage = "https://github.com/servo/core-foundation-rs" +repository = "https://github.com/servo/core-foundation-rs" +version = "0.1.0" +authors = ["The Servo Project Developers"] +license = "MIT / Apache-2.0" +build = "build.rs" +links = "CoreFoundation.framework" + +[dependencies] +libc = "0.1" diff --git a/core-foundation-sys/build.rs b/core-foundation-sys/build.rs new file mode 100644 index 0000000..94e6e93 --- /dev/null +++ b/core-foundation-sys/build.rs @@ -0,0 +1,3 @@ +fn main() { + println!("cargo:rustc-link-lib=framework=CoreFoundation"); +} diff --git a/core-foundation-sys/src/array.rs b/core-foundation-sys/src/array.rs new file mode 100644 index 0000000..0e982c6 --- /dev/null +++ b/core-foundation-sys/src/array.rs @@ -0,0 +1,48 @@ +use libc::c_void; + +use base::{CFIndex, CFAllocatorRef, CFTypeID}; + +/// FIXME(pcwalton): This is wrong. +pub type CFArrayRetainCallBack = *const u8; + +/// FIXME(pcwalton): This is wrong. +pub type CFArrayReleaseCallBack = *const u8; + +/// FIXME(pcwalton): This is wrong. +pub type CFArrayCopyDescriptionCallBack = *const u8; + +/// FIXME(pcwalton): This is wrong. +pub type CFArrayEqualCallBack = *const u8; + +#[repr(C)] +#[derive(Clone, Copy)] +pub struct CFArrayCallBacks { + pub version: CFIndex, + pub retain: CFArrayRetainCallBack, + pub release: CFArrayReleaseCallBack, + pub copyDescription: CFArrayCopyDescriptionCallBack, + pub equal: CFArrayEqualCallBack, +} + +pub type CFArrayRef = *const c_void; + +extern { + /* + * CFArray.h + */ + pub static kCFTypeArrayCallBacks: CFArrayCallBacks; + + pub fn CFArrayCreate(allocator: CFAllocatorRef, values: *const *const c_void, + numValues: CFIndex, callBacks: *const CFArrayCallBacks) -> CFArrayRef; + // CFArrayCreateCopy + // CFArrayBSearchValues + // CFArrayContainsValue + pub fn CFArrayGetCount(theArray: CFArrayRef) -> CFIndex; + // CFArrayGetCountOfValue + // CFArrayGetFirstIndexOfValue + // CFArrayGetLastIndexOfValue + // CFArrayGetValues + pub fn CFArrayGetValueAtIndex(theArray: CFArrayRef, idx: CFIndex) -> *const c_void; + // CFArrayApplyFunction + pub fn CFArrayGetTypeID() -> CFTypeID; +} diff --git a/core-foundation-sys/src/base.rs b/core-foundation-sys/src/base.rs new file mode 100644 index 0000000..a9c06d0 --- /dev/null +++ b/core-foundation-sys/src/base.rs @@ -0,0 +1,54 @@ +use libc::{c_uint, c_long, c_ulong, c_void}; + +pub type Boolean = u8; +pub type CFIndex = c_long; +pub type mach_port_t = c_uint; +pub type CFAllocatorRef = *const c_void; +pub type CFNullRef = *const c_void; +pub type CFHashCode = c_ulong; +pub type CFTypeID = c_ulong; +pub type CFTypeRef = *const c_void; +pub type CFOptionFlags = u32; + +#[repr(C)] +#[derive(Clone, Copy)] +pub struct CFRange { + pub location: CFIndex, + pub length: CFIndex +} + +extern { + /* + * CFBase.h + */ + + /* CFAllocator Reference */ + // N.B. Many CFAllocator functions and constants are omitted here. + pub static kCFAllocatorDefault: CFAllocatorRef; + pub static kCFAllocatorSystemDefault: CFAllocatorRef; + pub static kCFAllocatorMalloc: CFAllocatorRef; + pub static kCFAllocatorMallocZone: CFAllocatorRef; + pub static kCFAllocatorNull: CFAllocatorRef; + pub static kCFAllocatorUseContext: CFAllocatorRef; + + /* CFNull Reference */ + + pub static kCFNull: CFNullRef; + + /* CFType Reference */ + + //fn CFCopyDescription + //fn CFCopyTypeIDDescription + //fn CFEqual + //fn CFGetAllocator + pub fn CFGetRetainCount(cf: CFTypeRef) -> CFIndex; + pub fn CFGetTypeID(cf: CFTypeRef) -> CFTypeID; + pub fn CFHash(cf: CFTypeRef) -> CFHashCode; + //fn CFMakeCollectable + pub fn CFRelease(cf: CFTypeRef); + pub fn CFRetain(cf: CFTypeRef) -> CFTypeRef; + pub fn CFShow(obj: CFTypeRef); + + /* Base Utilities Reference */ + // N.B. Some things missing here. +} diff --git a/core-foundation-sys/src/lib.rs b/core-foundation-sys/src/lib.rs new file mode 100644 index 0000000..b4e8825 --- /dev/null +++ b/core-foundation-sys/src/lib.rs @@ -0,0 +1,6 @@ +#![allow(non_snake_case, non_camel_case_types)] + +extern crate libc; + +pub mod array; +pub mod base; diff --git a/core-foundation/Cargo.toml b/core-foundation/Cargo.toml index e20a0b7..122b69a 100644 --- a/core-foundation/Cargo.toml +++ b/core-foundation/Cargo.toml @@ -9,3 +9,4 @@ license = "MIT / Apache-2.0" [dependencies] libc = "0.1" +core-foundation-sys = { path = "../core-foundation-sys" } diff --git a/core-foundation/src/array.rs b/core-foundation/src/array.rs index 0a47a2c..b077552 100644 --- a/core-foundation/src/array.rs +++ b/core-foundation/src/array.rs @@ -9,39 +9,13 @@ //! Heterogeneous immutable arrays. -use base::{CFAllocatorRef, CFIndex, CFIndexConvertible, CFRelease}; -use base::{CFTypeID, CFTypeRef, TCFType}; -use base::{kCFAllocatorDefault}; +use core_foundation_sys::array::*; +use core_foundation_sys::base::{CFIndex, CFRelease}; +use core_foundation_sys::base::{CFTypeRef, kCFAllocatorDefault}; use libc::c_void; use std::mem; -/// FIXME(pcwalton): This is wrong. -pub type CFArrayRetainCallBack = *const u8; - -/// FIXME(pcwalton): This is wrong. -pub type CFArrayReleaseCallBack = *const u8; - -/// FIXME(pcwalton): This is wrong. -pub type CFArrayCopyDescriptionCallBack = *const u8; - -/// FIXME(pcwalton): This is wrong. -pub type CFArrayEqualCallBack = *const u8; - -#[allow(dead_code)] -#[repr(C)] -#[derive(Clone, Copy)] -pub struct CFArrayCallBacks { - version: CFIndex, - retain: CFArrayRetainCallBack, - release: CFArrayReleaseCallBack, - copyDescription: CFArrayCopyDescriptionCallBack, - equal: CFArrayEqualCallBack, -} - -#[repr(C)] -struct __CFArray; - -pub type CFArrayRef = *const __CFArray; +use base::{CFIndexConvertible, TCFType}; /// A heterogeneous immutable array. pub struct CFArray(CFArrayRef); @@ -126,28 +100,6 @@ impl<'a> IntoIterator for &'a CFArray { } } -#[link(name = "CoreFoundation", kind = "framework")] -extern { - /* - * CFArray.h - */ - static kCFTypeArrayCallBacks: CFArrayCallBacks; - - fn CFArrayCreate(allocator: CFAllocatorRef, values: *const *const c_void, - numValues: CFIndex, callBacks: *const CFArrayCallBacks) -> CFArrayRef; - // CFArrayCreateCopy - // CFArrayBSearchValues - // CFArrayContainsValue - fn CFArrayGetCount(theArray: CFArrayRef) -> CFIndex; - // CFArrayGetCountOfValue - // CFArrayGetFirstIndexOfValue - // CFArrayGetLastIndexOfValue - // CFArrayGetValues - fn CFArrayGetValueAtIndex(theArray: CFArrayRef, idx: CFIndex) -> *const c_void; - // CFArrayApplyFunction - fn CFArrayGetTypeID() -> CFTypeID; -} - #[test] fn should_box_and_unbox() { use number::{CFNumber, number}; diff --git a/core-foundation/src/base.rs b/core-foundation/src/base.rs index fb1dadf..60fa4e1 100644 --- a/core-foundation/src/base.rs +++ b/core-foundation/src/base.rs @@ -7,14 +7,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use libc::{c_long, c_ulong, c_uint}; - -pub type Boolean = u8; - -pub type CFIndex = c_long; - -#[allow(non_camel_case_types)] -pub type mach_port_t = c_uint; +use core_foundation_sys::base::*; pub trait CFIndexConvertible { /// Always use this method to construct a `CFIndex` value. It performs bounds checking to @@ -33,44 +26,6 @@ impl CFIndexConvertible for usize { } } -pub type CFOptionFlags = u32; - -#[allow(dead_code)] -#[repr(C)] -#[derive(Clone, Copy)] -pub struct CFRange { - location: CFIndex, - length: CFIndex -} - -impl CFRange { - pub fn init(offset: CFIndex, length: CFIndex) -> CFRange { - CFRange { - location: offset, - length: length, - } - } -} - -#[repr(C)] -struct __CFAllocator; - -pub type CFAllocatorRef = *const __CFAllocator; - -#[repr(C)] -struct __CFNull; - -pub type CFNullRef = *const __CFNull; - -pub type CFHashCode = c_ulong; - -pub type CFTypeID = c_ulong; - -#[repr(C)] -struct __CFType; - -pub type CFTypeRef = *const __CFType; - /// Superclass of all Core Foundation objects. pub struct CFType(CFTypeRef); @@ -185,40 +140,3 @@ impl TCFType for CFType { true } } - -#[link(name = "CoreFoundation", kind = "framework")] -extern { - /* - * CFBase.h - */ - - /* CFAllocator Reference */ - // N.B. Many CFAllocator functions and constants are omitted here. - pub static kCFAllocatorDefault: CFAllocatorRef; - pub static kCFAllocatorSystemDefault: CFAllocatorRef; - pub static kCFAllocatorMalloc: CFAllocatorRef; - pub static kCFAllocatorMallocZone: CFAllocatorRef; - pub static kCFAllocatorNull: CFAllocatorRef; - pub static kCFAllocatorUseContext: CFAllocatorRef; - - /* CFNull Reference */ - - pub static kCFNull: CFNullRef; - - /* CFType Reference */ - - //fn CFCopyDescription - //fn CFCopyTypeIDDescription - //fn CFEqual - //fn CFGetAllocator - pub fn CFGetRetainCount(cf: CFTypeRef) -> CFIndex; - pub fn CFGetTypeID(cf: CFTypeRef) -> CFTypeID; - pub fn CFHash(cf: CFTypeRef) -> CFHashCode; - //fn CFMakeCollectable - pub fn CFRelease(cf: CFTypeRef); - pub fn CFRetain(cf: CFTypeRef) -> CFTypeRef; - pub fn CFShow(obj: CFTypeRef); - - /* Base Utilities Reference */ - // N.B. Some things missing here. -} diff --git a/core-foundation/src/boolean.rs b/core-foundation/src/boolean.rs index 9ededa8..06b2f57 100644 --- a/core-foundation/src/boolean.rs +++ b/core-foundation/src/boolean.rs @@ -9,9 +9,11 @@ //! A Boolean type. -use base::{CFRelease, CFTypeID, TCFType}; +use core_foundation_sys::base::{CFRelease, CFTypeID}; use std::mem; +use base::TCFType; + pub type Boolean = u32; #[repr(C)] diff --git a/core-foundation/src/bundle.rs b/core-foundation/src/bundle.rs index 76edb33..7645fa6 100644 --- a/core-foundation/src/bundle.rs +++ b/core-foundation/src/bundle.rs @@ -9,9 +9,10 @@ //! Core Foundation Bundle Type -use base::{CFRelease, CFTypeID, TCFType}; +use core_foundation_sys::base::{CFRelease, CFTypeID}; use std::mem; +use base::{TCFType}; use string::CFStringRef; use libc::c_void; diff --git a/core-foundation/src/data.rs b/core-foundation/src/data.rs index 9c8ace9..1b75677 100644 --- a/core-foundation/src/data.rs +++ b/core-foundation/src/data.rs @@ -9,13 +9,14 @@ //! Core Foundation byte buffers. -use base::{CFAllocatorRef, CFIndex, CFIndexConvertible, CFRelease}; -use base::{CFTypeID, TCFType, kCFAllocatorDefault}; - +use core_foundation_sys::base::{CFAllocatorRef, CFIndex, CFRelease}; +use core_foundation_sys::base::{CFTypeID, kCFAllocatorDefault}; use std::mem; use std::ops::Deref; use std::slice; +use base::{CFIndexConvertible, TCFType}; + #[repr(C)] struct __CFData; diff --git a/core-foundation/src/dictionary.rs b/core-foundation/src/dictionary.rs index e2fbd7c..5540d20 100644 --- a/core-foundation/src/dictionary.rs +++ b/core-foundation/src/dictionary.rs @@ -9,13 +9,14 @@ //! Dictionaries of key-value pairs. -use base::{Boolean, CFAllocatorRef, CFIndex, CFIndexConvertible, CFRelease}; -use base::{CFType, CFTypeID, CFTypeRef, TCFType, kCFAllocatorDefault}; - +use core_foundation_sys::base::{Boolean, CFAllocatorRef, CFIndex, CFRelease}; +use core_foundation_sys::base::{CFTypeID, CFTypeRef, kCFAllocatorDefault}; use libc::c_void; use std::mem; use std::ptr; +use base::{CFType, CFIndexConvertible, TCFType}; + pub type CFDictionaryApplierFunction = *const u8; pub type CFDictionaryCopyDescriptionCallBack = *const u8; pub type CFDictionaryEqualCallBack = *const u8; diff --git a/core-foundation/src/lib.rs b/core-foundation/src/lib.rs index 569a2e0..b8fb276 100644 --- a/core-foundation/src/lib.rs +++ b/core-foundation/src/lib.rs @@ -6,12 +6,9 @@ // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. - -#![crate_name = "core_foundation"] -#![crate_type = "rlib"] - #![allow(non_snake_case)] +extern crate core_foundation_sys; extern crate libc; #[macro_export] @@ -25,12 +22,12 @@ macro_rules! impl_TCFType { #[inline] unsafe fn wrap_under_get_rule(reference: $raw) -> $ty { - let reference = mem::transmute($crate::base::CFRetain(mem::transmute(reference))); + let reference = mem::transmute(::core_foundation_sys::base::CFRetain(mem::transmute(reference))); $crate::base::TCFType::wrap_under_create_rule(reference) } #[inline] - fn as_CFTypeRef(&self) -> $crate::base::CFTypeRef { + fn as_CFTypeRef(&self) -> ::core_foundation_sys::base::CFTypeRef { unsafe { mem::transmute(self.as_concrete_TypeRef()) } @@ -42,7 +39,7 @@ macro_rules! impl_TCFType { } #[inline] - fn type_id() -> $crate::base::CFTypeID { + fn type_id() -> ::core_foundation_sys::base::CFTypeID { unsafe { $ty_id() } diff --git a/core-foundation/src/number.rs b/core-foundation/src/number.rs index 198dbad..0309bc8 100644 --- a/core-foundation/src/number.rs +++ b/core-foundation/src/number.rs @@ -11,12 +11,13 @@ #![allow(non_upper_case_globals)] -use base::{CFAllocatorRef, CFRelease, CFTypeID}; -use base::{TCFType, kCFAllocatorDefault}; - +use core_foundation_sys::base::{CFAllocatorRef, CFRelease, CFTypeID}; +use core_foundation_sys::base::{kCFAllocatorDefault}; use libc::c_void; use std::mem; +use base::{TCFType}; + pub type CFNumberType = u32; // members of enum CFNumberType diff --git a/core-foundation/src/runloop.rs b/core-foundation/src/runloop.rs index b0782a2..ee71bef 100644 --- a/core-foundation/src/runloop.rs +++ b/core-foundation/src/runloop.rs @@ -9,16 +9,18 @@ #![allow(non_upper_case_globals)] -use base::{CFAllocatorRef, CFIndex, CFOptionFlags, CFRelease}; -use base::{CFTypeID, TCFType, CFHashCode, mach_port_t}; -use base::{kCFAllocatorDefault}; -use base::{Boolean}; -use array::{CFArrayRef}; -use string::{CFString, CFStringRef}; -use date::{CFAbsoluteTime, CFTimeInterval}; + +use core_foundation_sys::base::{CFAllocatorRef, CFIndex, CFRelease}; +use core_foundation_sys::base::{CFTypeID, CFHashCode, mach_port_t}; +use core_foundation_sys::base::{kCFAllocatorDefault, Boolean, CFOptionFlags}; +use core_foundation_sys::array::{CFArrayRef}; use libc::c_void; use std::mem; +use base::{TCFType}; +use string::{CFString, CFStringRef}; +use date::{CFAbsoluteTime, CFTimeInterval}; + pub struct CFRunLoop(CFRunLoopRef); impl Drop for CFRunLoop { diff --git a/core-foundation/src/set.rs b/core-foundation/src/set.rs index b5e26b8..680007f 100644 --- a/core-foundation/src/set.rs +++ b/core-foundation/src/set.rs @@ -9,8 +9,10 @@ //! An immutable bag of elements. -use base::{CFAllocatorRef, CFIndex, CFIndexConvertible, CFRelease}; -use base::{CFTypeID, CFTypeRef, TCFType, kCFAllocatorDefault}; +use core_foundation_sys::base::{CFAllocatorRef, CFIndex, CFRelease}; +use core_foundation_sys::base::{CFTypeID, CFTypeRef, kCFAllocatorDefault}; + +use base::{CFIndexConvertible, TCFType}; use libc::c_void; use std::mem; diff --git a/core-foundation/src/string.rs b/core-foundation/src/string.rs index 99bb397..e502074 100644 --- a/core-foundation/src/string.rs +++ b/core-foundation/src/string.rs @@ -11,10 +11,11 @@ #![allow(non_upper_case_globals)] -use base::{Boolean, CFAllocatorRef, CFIndex, CFIndexConvertible, CFOptionFlags, CFRange}; -use base::{CFRelease, CFTypeID, TCFType}; -use base::{kCFAllocatorDefault, kCFAllocatorNull}; +use base::{CFIndexConvertible, TCFType}; +use core_foundation_sys::base::{Boolean, CFAllocatorRef, CFIndex, CFRange}; +use core_foundation_sys::base::{CFRelease, CFTypeID}; +use core_foundation_sys::base::{kCFAllocatorDefault, kCFAllocatorNull, CFOptionFlags}; use libc; use std::ffi::CStr; use std::fmt; @@ -250,7 +251,7 @@ impl fmt::Display for CFString { // First, ask how big the buffer ought to be. let mut bytes_required: CFIndex = 0; CFStringGetBytes(self.0, - CFRange::init(0, char_len), + CFRange { location: 0, length: char_len }, kCFStringEncodingUTF8, 0, false as Boolean, @@ -264,7 +265,7 @@ impl fmt::Display for CFString { let mut bytes_used: CFIndex = 0; let chars_written = CFStringGetBytes(self.0, - CFRange::init(0, char_len), + CFRange { location: 0, length: char_len }, kCFStringEncodingUTF8, 0, false as Boolean, diff --git a/core-foundation/src/url.rs b/core-foundation/src/url.rs index c6c5708..95b5612 100644 --- a/core-foundation/src/url.rs +++ b/core-foundation/src/url.rs @@ -11,11 +11,11 @@ #![allow(non_upper_case_globals)] -use base::{CFAllocatorRef, CFIndex, CFOptionFlags, CFRelease}; -use base::{Boolean, CFTypeID, TCFType}; -use base::{kCFAllocatorDefault}; +use base::{TCFType}; use string::{CFString, CFStringRef}; +use core_foundation_sys::base::{CFAllocatorRef, CFIndex, CFRelease, CFOptionFlags}; +use core_foundation_sys::base::{Boolean, CFTypeID, kCFAllocatorDefault}; use std::fmt; use std::mem;