summaryrefslogtreecommitdiffstats
path: root/vendor/core-foundation-sys/src
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-06-19 09:26:03 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-06-19 09:26:03 +0000
commit9918693037dce8aa4bb6f08741b6812923486c18 (patch)
tree21d2b40bec7e6a7ea664acee056eb3d08e15a1cf /vendor/core-foundation-sys/src
parentReleasing progress-linux version 1.75.0+dfsg1-5~progress7.99u1. (diff)
downloadrustc-9918693037dce8aa4bb6f08741b6812923486c18.tar.xz
rustc-9918693037dce8aa4bb6f08741b6812923486c18.zip
Merging upstream version 1.76.0+dfsg1.
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'vendor/core-foundation-sys/src')
-rw-r--r--vendor/core-foundation-sys/src/array.rs127
-rw-r--r--vendor/core-foundation-sys/src/attributed_string.rs99
-rw-r--r--vendor/core-foundation-sys/src/bag.rs101
-rw-r--r--vendor/core-foundation-sys/src/base.rs88
-rw-r--r--vendor/core-foundation-sys/src/binary_heap.rs83
-rw-r--r--vendor/core-foundation-sys/src/bit_vector.rs74
-rw-r--r--vendor/core-foundation-sys/src/bundle.rs215
-rw-r--r--vendor/core-foundation-sys/src/calendar.rs128
-rw-r--r--vendor/core-foundation-sys/src/characterset.rs102
-rw-r--r--vendor/core-foundation-sys/src/data.rs59
-rw-r--r--vendor/core-foundation-sys/src/date.rs10
-rw-r--r--vendor/core-foundation-sys/src/date_formatter.rs147
-rw-r--r--vendor/core-foundation-sys/src/dictionary.rs124
-rw-r--r--vendor/core-foundation-sys/src/error.rs38
-rw-r--r--vendor/core-foundation-sys/src/file_security.rs71
-rw-r--r--vendor/core-foundation-sys/src/filedescriptor.rs56
-rw-r--r--vendor/core-foundation-sys/src/lib.rs42
-rw-r--r--vendor/core-foundation-sys/src/locale.rs146
-rw-r--r--vendor/core-foundation-sys/src/mach_port.rs63
-rw-r--r--vendor/core-foundation-sys/src/messageport.rs123
-rw-r--r--vendor/core-foundation-sys/src/notification_center.rs89
-rw-r--r--vendor/core-foundation-sys/src/number.rs74
-rw-r--r--vendor/core-foundation-sys/src/number_formatter.rs163
-rw-r--r--vendor/core-foundation-sys/src/plugin.rs99
-rw-r--r--vendor/core-foundation-sys/src/preferences.rs103
-rw-r--r--vendor/core-foundation-sys/src/propertylist.rs102
-rw-r--r--vendor/core-foundation-sys/src/runloop.rs220
-rw-r--r--vendor/core-foundation-sys/src/set.rs64
-rw-r--r--vendor/core-foundation-sys/src/socket.rs188
-rw-r--r--vendor/core-foundation-sys/src/stream.rs281
-rw-r--r--vendor/core-foundation-sys/src/string.rs757
-rw-r--r--vendor/core-foundation-sys/src/string_tokenizer.rs91
-rw-r--r--vendor/core-foundation-sys/src/timezone.rs76
-rw-r--r--vendor/core-foundation-sys/src/tree.rs74
-rw-r--r--vendor/core-foundation-sys/src/url.rs468
-rw-r--r--vendor/core-foundation-sys/src/url_enumerator.rs62
-rw-r--r--vendor/core-foundation-sys/src/user_notification.rs138
-rw-r--r--vendor/core-foundation-sys/src/uuid.rs74
-rw-r--r--vendor/core-foundation-sys/src/xml_node.rs147
-rw-r--r--vendor/core-foundation-sys/src/xml_parser.rs174
40 files changed, 4622 insertions, 718 deletions
diff --git a/vendor/core-foundation-sys/src/array.rs b/vendor/core-foundation-sys/src/array.rs
index c73896125..1e521b3e4 100644
--- a/vendor/core-foundation-sys/src/array.rs
+++ b/vendor/core-foundation-sys/src/array.rs
@@ -9,18 +9,19 @@
use std::os::raw::c_void;
-use base::{CFRange, CFIndex, CFAllocatorRef, CFTypeID, Boolean, CFComparisonResult};
-use string::CFStringRef;
+use crate::base::{Boolean, CFAllocatorRef, CFComparatorFunction, CFIndex, CFRange, CFTypeID};
+use crate::string::CFStringRef;
-pub type CFArrayRetainCallBack = extern "C" fn(allocator: CFAllocatorRef, value: *const c_void) -> *const c_void;
+pub type CFArrayRetainCallBack =
+ extern "C" fn(allocator: CFAllocatorRef, value: *const c_void) -> *const c_void;
pub type CFArrayReleaseCallBack = extern "C" fn(allocator: CFAllocatorRef, value: *const c_void);
pub type CFArrayCopyDescriptionCallBack = extern "C" fn(value: *const c_void) -> CFStringRef;
-pub type CFArrayEqualCallBack = extern "C" fn(value1: *const c_void, value2: *const c_void) -> Boolean;
+pub type CFArrayEqualCallBack =
+ extern "C" fn(value1: *const c_void, value2: *const c_void) -> Boolean;
pub type CFArrayApplierFunction = extern "C" fn(value: *const c_void, context: *mut c_void);
-pub type CFComparatorFunction = extern "C" fn(val1: *const c_void, val2: *const c_void) -> CFComparisonResult;
#[repr(C)]
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
pub struct CFArrayCallBacks {
pub version: CFIndex,
pub retain: CFArrayRetainCallBack,
@@ -35,33 +36,107 @@ pub struct __CFArray(c_void);
pub type CFArrayRef = *const __CFArray;
pub type CFMutableArrayRef = *mut __CFArray;
-extern {
+extern "C" {
/*
* CFArray.h
*/
+
pub static kCFTypeArrayCallBacks: CFArrayCallBacks;
- pub fn CFArrayGetTypeID() -> CFTypeID;
- pub fn CFArrayCreate(allocator: CFAllocatorRef, values: *const *const c_void, numValues: CFIndex, callBacks: *const CFArrayCallBacks) -> CFArrayRef;
- pub fn CFArrayCreateCopy(allocator: CFAllocatorRef , theArray: CFArrayRef) -> CFArrayRef;
- pub fn CFArrayCreateMutable(allocator: CFAllocatorRef, capacity: CFIndex, callBacks: *const CFArrayCallBacks) -> CFMutableArrayRef;
- pub fn CFArrayCreateMutableCopy(allocator: CFAllocatorRef, capacity: CFIndex, theArray: CFArrayRef)-> CFMutableArrayRef;
+ /* CFArray */
+ /* Creating an Array */
+ pub fn CFArrayCreate(
+ allocator: CFAllocatorRef,
+ values: *const *const c_void,
+ numValues: CFIndex,
+ callBacks: *const CFArrayCallBacks,
+ ) -> CFArrayRef;
+ pub fn CFArrayCreateCopy(allocator: CFAllocatorRef, theArray: CFArrayRef) -> CFArrayRef;
+
+ /* Examining an Array */
+ pub fn CFArrayBSearchValues(
+ theArray: CFArrayRef,
+ range: CFRange,
+ value: *const c_void,
+ comparator: CFComparatorFunction,
+ context: *mut c_void,
+ ) -> CFIndex;
+ pub fn CFArrayContainsValue(
+ theArray: CFArrayRef,
+ range: CFRange,
+ value: *const c_void,
+ ) -> Boolean;
pub fn CFArrayGetCount(theArray: CFArrayRef) -> CFIndex;
- pub fn CFArrayGetCountOfValue(theArray: CFArrayRef, range: CFRange, value: *const c_void) -> CFIndex;
- pub fn CFArrayContainsValue(theArray: CFArrayRef, range: CFRange, value: *const c_void) -> Boolean;
- pub fn CFArrayGetValueAtIndex(theArray: CFArrayRef, idx: CFIndex) -> *const c_void;
+ pub fn CFArrayGetCountOfValue(
+ theArray: CFArrayRef,
+ range: CFRange,
+ value: *const c_void,
+ ) -> CFIndex;
+ pub fn CFArrayGetFirstIndexOfValue(
+ theArray: CFArrayRef,
+ range: CFRange,
+ value: *const c_void,
+ ) -> CFIndex;
+ pub fn CFArrayGetLastIndexOfValue(
+ theArray: CFArrayRef,
+ range: CFRange,
+ value: *const c_void,
+ ) -> CFIndex;
pub fn CFArrayGetValues(theArray: CFArrayRef, range: CFRange, values: *mut *const c_void);
- pub fn CFArrayApplyFunction(theArray: CFArrayRef, range: CFRange, applier: CFArrayApplierFunction, context: *mut c_void);
- pub fn CFArrayGetFirstIndexOfValue(theArray: CFArrayRef, range: CFRange, value: *const c_void) -> CFIndex;
- pub fn CFArrayGetLastIndexOfValue(theArray: CFArrayRef, range: CFRange, value: *const c_void) -> CFIndex;
- pub fn CFArrayBSearchValues(theArray: CFArrayRef, range: CFRange, value: *const c_void, comparator: CFComparatorFunction, context: *mut c_void) -> CFIndex;
+ pub fn CFArrayGetValueAtIndex(theArray: CFArrayRef, idx: CFIndex) -> *const c_void;
+
+ /* Applying a Function to Elements */
+ pub fn CFArrayApplyFunction(
+ theArray: CFArrayRef,
+ range: CFRange,
+ applier: CFArrayApplierFunction,
+ context: *mut c_void,
+ );
+
+ /* Getting the CFArray Type ID */
+ pub fn CFArrayGetTypeID() -> CFTypeID;
+
+ /* CFMutableArray */
+ /* CFMutableArray Miscellaneous Functions */
+ pub fn CFArrayAppendArray(
+ theArray: CFMutableArrayRef,
+ otherArray: CFArrayRef,
+ otherRange: CFRange,
+ );
pub fn CFArrayAppendValue(theArray: CFMutableArrayRef, value: *const c_void);
- pub fn CFArrayInsertValueAtIndex(theArray: CFMutableArrayRef, idx: CFIndex, value: *const c_void);
- pub fn CFArraySetValueAtIndex(theArray: CFMutableArrayRef, idx: CFIndex, value: *const c_void);
- pub fn CFArrayRemoveValueAtIndex(theArray: CFMutableArrayRef, idx: CFIndex);
+ pub fn CFArrayCreateMutable(
+ allocator: CFAllocatorRef,
+ capacity: CFIndex,
+ callBacks: *const CFArrayCallBacks,
+ ) -> CFMutableArrayRef;
+ pub fn CFArrayCreateMutableCopy(
+ allocator: CFAllocatorRef,
+ capacity: CFIndex,
+ theArray: CFArrayRef,
+ ) -> CFMutableArrayRef;
+ pub fn CFArrayExchangeValuesAtIndices(
+ theArray: CFMutableArrayRef,
+ idx1: CFIndex,
+ idx2: CFIndex,
+ );
+ pub fn CFArrayInsertValueAtIndex(
+ theArray: CFMutableArrayRef,
+ idx: CFIndex,
+ value: *const c_void,
+ );
pub fn CFArrayRemoveAllValues(theArray: CFMutableArrayRef);
- pub fn CFArrayReplaceValues(theArray: CFMutableArrayRef, range: CFRange, newValues: *mut *const c_void, newCount: CFIndex);
- pub fn CFArrayExchangeValuesAtIndices(theArray: CFMutableArrayRef, idx1: CFIndex, idx2: CFIndex);
- pub fn CFArraySortValues(theArray: CFMutableArrayRef, range: CFRange, comparator: CFComparatorFunction, context: *mut c_void);
- pub fn CFArrayAppendArray(theArray: CFMutableArrayRef, otherArray: CFArrayRef, otherRange: CFRange );
+ pub fn CFArrayRemoveValueAtIndex(theArray: CFMutableArrayRef, idx: CFIndex);
+ pub fn CFArrayReplaceValues(
+ theArray: CFMutableArrayRef,
+ range: CFRange,
+ newValues: *mut *const c_void,
+ newCount: CFIndex,
+ );
+ pub fn CFArraySetValueAtIndex(theArray: CFMutableArrayRef, idx: CFIndex, value: *const c_void);
+ pub fn CFArraySortValues(
+ theArray: CFMutableArrayRef,
+ range: CFRange,
+ comparator: CFComparatorFunction,
+ context: *mut c_void,
+ );
}
diff --git a/vendor/core-foundation-sys/src/attributed_string.rs b/vendor/core-foundation-sys/src/attributed_string.rs
index c91bf5be3..54c27ec41 100644
--- a/vendor/core-foundation-sys/src/attributed_string.rs
+++ b/vendor/core-foundation-sys/src/attributed_string.rs
@@ -7,49 +7,114 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use crate::base::{Boolean, CFAllocatorRef, CFIndex, CFRange, CFTypeID, CFTypeRef};
+use crate::dictionary::CFDictionaryRef;
+use crate::string::CFMutableStringRef;
+use crate::string::CFStringRef;
use std::os::raw::c_void;
-use base::{CFAllocatorRef, CFTypeRef, CFIndex, CFRange, CFTypeID};
-use string::CFStringRef;
-use dictionary::CFDictionaryRef;
#[repr(C)]
pub struct __CFAttributedString(c_void);
pub type CFAttributedStringRef = *const __CFAttributedString;
-pub type CFMutableAttributedStringRef = *const __CFAttributedString;
+pub type CFMutableAttributedStringRef = *mut __CFAttributedString;
-extern {
- /* CFAttributedString */
+extern "C" {
+ /*
+ * CFAttributedString.h
+ */
+ /* CFAttributedString */
+ /* Creating a CFAttributedString */
pub fn CFAttributedStringCreate(
allocator: CFAllocatorRef,
str: CFStringRef,
attributes: CFDictionaryRef,
) -> CFAttributedStringRef;
-
+ pub fn CFAttributedStringCreateCopy(
+ alloc: CFAllocatorRef,
+ aStr: CFAttributedStringRef,
+ ) -> CFAttributedStringRef;
+ pub fn CFAttributedStringCreateWithSubstring(
+ alloc: CFAllocatorRef,
+ aStr: CFAttributedStringRef,
+ range: CFRange,
+ ) -> CFAttributedStringRef;
pub fn CFAttributedStringGetLength(astr: CFAttributedStringRef) -> CFIndex;
+ pub fn CFAttributedStringGetString(aStr: CFAttributedStringRef) -> CFStringRef;
+
+ /* Accessing Attributes */
+ pub fn CFAttributedStringGetAttribute(
+ aStr: CFAttributedStringRef,
+ loc: CFIndex,
+ attrName: CFStringRef,
+ effectiveRange: *mut CFRange,
+ ) -> CFTypeRef;
+ pub fn CFAttributedStringGetAttributes(
+ aStr: CFAttributedStringRef,
+ loc: CFIndex,
+ effectiveRange: *mut CFRange,
+ ) -> CFDictionaryRef;
+ pub fn CFAttributedStringGetAttributeAndLongestEffectiveRange(
+ aStr: CFAttributedStringRef,
+ loc: CFIndex,
+ attrName: CFStringRef,
+ inRange: CFRange,
+ longestEffectiveRange: *mut CFRange,
+ ) -> CFTypeRef;
+ pub fn CFAttributedStringGetAttributesAndLongestEffectiveRange(
+ aStr: CFAttributedStringRef,
+ loc: CFIndex,
+ inRange: CFRange,
+ longestEffectiveRange: *mut CFRange,
+ ) -> CFDictionaryRef;
+ /* Getting Attributed String Properties */
pub fn CFAttributedStringGetTypeID() -> CFTypeID;
/* CFMutableAttributedString */
-
- pub fn CFAttributedStringCreateMutableCopy(
- allocator: CFAllocatorRef, max_length: CFIndex, astr: CFAttributedStringRef
- ) -> CFMutableAttributedStringRef;
-
+ /* Creating a CFMutableAttributedString */
pub fn CFAttributedStringCreateMutable(
allocator: CFAllocatorRef,
max_length: CFIndex,
) -> CFMutableAttributedStringRef;
+ pub fn CFAttributedStringCreateMutableCopy(
+ allocator: CFAllocatorRef,
+ max_length: CFIndex,
+ astr: CFAttributedStringRef,
+ ) -> CFMutableAttributedStringRef;
+ /* Modifying a CFMutableAttributedString */
+ pub fn CFAttributedStringBeginEditing(aStr: CFMutableAttributedStringRef);
+ pub fn CFAttributedStringEndEditing(aStr: CFMutableAttributedStringRef);
+ pub fn CFAttributedStringGetMutableString(
+ aStr: CFMutableAttributedStringRef,
+ ) -> CFMutableStringRef;
+ pub fn CFAttributedStringRemoveAttribute(
+ aStr: CFMutableAttributedStringRef,
+ range: CFRange,
+ attrName: CFStringRef,
+ );
pub fn CFAttributedStringReplaceString(
- astr: CFMutableAttributedStringRef, range: CFRange, replacement: CFStringRef);
-
+ aStr: CFMutableAttributedStringRef,
+ range: CFRange,
+ replacement: CFStringRef,
+ );
+ pub fn CFAttributedStringReplaceAttributedString(
+ aStr: CFMutableAttributedStringRef,
+ range: CFRange,
+ replacement: CFAttributedStringRef,
+ );
pub fn CFAttributedStringSetAttribute(
- astr: CFMutableAttributedStringRef,
+ aStr: CFMutableAttributedStringRef,
range: CFRange,
- attr_name: CFStringRef,
+ attrName: CFStringRef,
value: CFTypeRef,
);
-
+ pub fn CFAttributedStringSetAttributes(
+ aStr: CFMutableAttributedStringRef,
+ range: CFRange,
+ replacement: CFDictionaryRef,
+ clearOtherAttributes: Boolean,
+ );
}
diff --git a/vendor/core-foundation-sys/src/bag.rs b/vendor/core-foundation-sys/src/bag.rs
new file mode 100644
index 000000000..041caa59c
--- /dev/null
+++ b/vendor/core-foundation-sys/src/bag.rs
@@ -0,0 +1,101 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::c_void;
+
+use crate::base::{Boolean, CFAllocatorRef, CFHashCode, CFIndex, CFTypeID};
+use crate::string::CFStringRef;
+
+#[repr(C)]
+pub struct __CFBag(c_void);
+
+pub type CFBagRef = *const __CFBag;
+pub type CFMutableBagRef = *mut __CFBag;
+
+pub type CFBagRetainCallBack =
+ extern "C" fn(allocator: CFAllocatorRef, value: *const c_void) -> *const c_void;
+pub type CFBagReleaseCallBack = extern "C" fn(allocator: CFAllocatorRef, value: *const c_void);
+pub type CFBagCopyDescriptionCallBack = extern "C" fn(value: *const c_void) -> CFStringRef;
+pub type CFBagEqualCallBack =
+ extern "C" fn(value1: *const c_void, value2: *const c_void) -> Boolean;
+pub type CFBagHashCallBack = extern "C" fn(value: *const c_void) -> CFHashCode;
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFBagCallBacks {
+ pub version: CFIndex,
+ pub retain: CFBagRetainCallBack,
+ pub release: CFBagReleaseCallBack,
+ pub copyDescription: CFBagCopyDescriptionCallBack,
+ pub equal: CFBagEqualCallBack,
+ pub hash: CFBagHashCallBack,
+}
+
+pub type CFBagApplierFunction = extern "C" fn(value: *const c_void, context: *mut c_void);
+
+extern "C" {
+ /*
+ * CFBag.h
+ */
+ /* Predefined Callback Structures */
+ pub static kCFTypeBagCallBacks: CFBagCallBacks;
+ pub static kCFCopyStringBagCallBacks: CFBagCallBacks;
+
+ /* CFBag */
+ /* Creating a Bag */
+ pub fn CFBagCreate(
+ allocator: CFAllocatorRef,
+ values: *const *const c_void,
+ numValues: CFIndex,
+ callBacks: *const CFBagCallBacks,
+ ) -> CFBagRef;
+ pub fn CFBagCreateCopy(allocator: CFAllocatorRef, theBag: CFBagRef) -> CFBagRef;
+
+ /* Examining a Bag */
+ pub fn CFBagContainsValue(theBag: CFBagRef, value: *const c_void) -> Boolean;
+ pub fn CFBagGetCount(theBag: CFBagRef) -> CFIndex;
+ pub fn CFBagGetCountOfValue(theBag: CFBagRef, value: *const c_void) -> CFIndex;
+ pub fn CFBagGetValue(theBag: CFBagRef, value: *const c_void) -> *const c_void;
+ pub fn CFBagGetValueIfPresent(
+ theBag: CFBagRef,
+ candidate: *const c_void,
+ value: *const *const c_void,
+ ) -> Boolean;
+ pub fn CFBagGetValues(theBag: CFBagRef, values: *const *const c_void);
+
+ /* Applying a Function to the Contents of a Bag */
+ pub fn CFBagApplyFunction(
+ theBag: CFBagRef,
+ applier: CFBagApplierFunction,
+ context: *mut c_void,
+ );
+
+ /* Getting the CFBag Type ID */
+ pub fn CFBagGetTypeID() -> CFTypeID;
+
+ /* CFMutableBag */
+ /* Creating a Mutable Bag */
+ pub fn CFBagCreateMutable(
+ allocator: CFAllocatorRef,
+ capacity: CFIndex,
+ callBacks: *const CFBagCallBacks,
+ ) -> CFMutableBagRef;
+ pub fn CFBagCreateMutableCopy(
+ allocator: CFAllocatorRef,
+ capacity: CFIndex,
+ theBag: CFBagRef,
+ ) -> CFMutableBagRef;
+
+ /* Modifying a Mutable Bag */
+ pub fn CFBagAddValue(theBag: CFMutableBagRef, value: *const c_void);
+ pub fn CFBagRemoveAllValues(theBag: CFMutableBagRef);
+ pub fn CFBagRemoveValue(theBag: CFMutableBagRef, value: *const c_void);
+ pub fn CFBagReplaceValue(theBag: CFMutableBagRef, value: *const c_void);
+ pub fn CFBagSetValue(theBag: CFMutableBagRef, value: *const c_void);
+}
diff --git a/vendor/core-foundation-sys/src/base.rs b/vendor/core-foundation-sys/src/base.rs
index 52a166fdf..78e06a65f 100644
--- a/vendor/core-foundation-sys/src/base.rs
+++ b/vendor/core-foundation-sys/src/base.rs
@@ -7,21 +7,33 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use crate::string::CFStringRef;
use std::cmp::Ordering;
-use std::os::raw::{c_uint, c_void, c_int};
-use string::CFStringRef;
+use std::os::raw::{c_int, c_short, c_uchar, c_uint, c_ushort, c_void};
pub type Boolean = u8;
pub type mach_port_t = c_uint;
pub type CFAllocatorRef = *const c_void;
pub type CFNullRef = *const c_void;
pub type CFTypeRef = *const c_void;
+pub type ConstStr255Param = *const c_uchar;
+pub type StringPtr = *mut c_uchar;
+pub type ConstStringPtr = *const c_uchar;
pub type OSStatus = i32;
+pub type UInt8 = c_uchar;
+pub type UInt16 = c_ushort;
+pub type SInt16 = c_short;
pub type SInt32 = c_int;
+pub type UInt32 = c_uint;
pub type CFTypeID = usize;
pub type CFOptionFlags = usize;
pub type CFHashCode = usize;
pub type CFIndex = isize;
+pub type LangCode = SInt16;
+pub type RegionCode = SInt16;
+pub type UTF32Char = c_uint;
+pub type UTF16Char = c_ushort;
+pub type UTF8Char = c_uchar;
#[repr(isize)]
#[derive(Clone, Copy, Debug, PartialEq)]
@@ -31,43 +43,53 @@ pub enum CFComparisonResult {
GreaterThan = 1,
}
-impl Into<Ordering> for CFComparisonResult {
- fn into(self) -> Ordering {
- match self {
+pub type CFComparatorFunction = extern "C" fn(
+ val1: *const c_void,
+ val2: *const c_void,
+ context: *mut c_void,
+) -> CFComparisonResult;
+
+impl From<CFComparisonResult> for Ordering {
+ fn from(val: CFComparisonResult) -> Self {
+ match val {
CFComparisonResult::LessThan => Ordering::Less,
CFComparisonResult::EqualTo => Ordering::Equal,
- CFComparisonResult::GreaterThan => Ordering::Greater
+ CFComparisonResult::GreaterThan => Ordering::Greater,
}
}
}
#[repr(C)]
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug, PartialEq)]
pub struct CFRange {
pub location: CFIndex,
- pub length: CFIndex
+ pub length: CFIndex,
}
// for back-compat
impl CFRange {
pub fn init(location: CFIndex, length: CFIndex) -> CFRange {
- CFRange {
- location: location,
- length: length,
- }
+ CFRange { location, length }
}
}
pub type CFAllocatorRetainCallBack = extern "C" fn(info: *mut c_void) -> *mut c_void;
pub type CFAllocatorReleaseCallBack = extern "C" fn(info: *mut c_void);
pub type CFAllocatorCopyDescriptionCallBack = extern "C" fn(info: *mut c_void) -> CFStringRef;
-pub type CFAllocatorAllocateCallBack = extern "C" fn(allocSize: CFIndex, hint: CFOptionFlags, info: *mut c_void) -> *mut c_void;
-pub type CFAllocatorReallocateCallBack = extern "C" fn(ptr: *mut c_void, newsize: CFIndex, hint: CFOptionFlags, info: *mut c_void) -> *mut c_void;
+pub type CFAllocatorAllocateCallBack =
+ extern "C" fn(allocSize: CFIndex, hint: CFOptionFlags, info: *mut c_void) -> *mut c_void;
+pub type CFAllocatorReallocateCallBack = extern "C" fn(
+ ptr: *mut c_void,
+ newsize: CFIndex,
+ hint: CFOptionFlags,
+ info: *mut c_void,
+) -> *mut c_void;
pub type CFAllocatorDeallocateCallBack = extern "C" fn(ptr: *mut c_void, info: *mut c_void);
-pub type CFAllocatorPreferredSizeCallBack = extern "C" fn(size: CFIndex, hint: CFOptionFlags, info: *mut c_void) -> CFIndex;
+pub type CFAllocatorPreferredSizeCallBack =
+ extern "C" fn(size: CFIndex, hint: CFOptionFlags, info: *mut c_void) -> CFIndex;
#[repr(C)]
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
pub struct CFAllocatorContext {
pub version: CFIndex,
pub info: *mut c_void,
@@ -77,7 +99,7 @@ pub struct CFAllocatorContext {
pub allocate: Option<CFAllocatorAllocateCallBack>,
pub reallocate: Option<CFAllocatorReallocateCallBack>,
pub deallocate: Option<CFAllocatorDeallocateCallBack>,
- pub preferredSize: Option<CFAllocatorPreferredSizeCallBack>
+ pub preferredSize: Option<CFAllocatorPreferredSizeCallBack>,
}
/// Trait for all types which are Core Foundation reference types.
@@ -110,7 +132,7 @@ impl<T> TCFTypeRef for *mut T {
/// Constant used by some functions to indicate failed searches.
pub static kCFNotFound: CFIndex = -1;
-extern {
+extern "C" {
/*
* CFBase.h
*/
@@ -124,11 +146,27 @@ extern {
pub static kCFAllocatorNull: CFAllocatorRef;
pub static kCFAllocatorUseContext: CFAllocatorRef;
- pub fn CFAllocatorCreate(allocator: CFAllocatorRef, context: *mut CFAllocatorContext) -> CFAllocatorRef;
- pub fn CFAllocatorAllocate(allocator: CFAllocatorRef, size: CFIndex, hint: CFOptionFlags) -> *mut c_void;
+ pub fn CFAllocatorCreate(
+ allocator: CFAllocatorRef,
+ context: *mut CFAllocatorContext,
+ ) -> CFAllocatorRef;
+ pub fn CFAllocatorAllocate(
+ allocator: CFAllocatorRef,
+ size: CFIndex,
+ hint: CFOptionFlags,
+ ) -> *mut c_void;
pub fn CFAllocatorDeallocate(allocator: CFAllocatorRef, ptr: *mut c_void);
- pub fn CFAllocatorGetPreferredSizeForSize(allocator: CFAllocatorRef, size: CFIndex, hint: CFOptionFlags) -> CFIndex;
- pub fn CFAllocatorReallocate(allocator: CFAllocatorRef, ptr: *mut c_void, newsize: CFIndex, hint: CFOptionFlags) -> *mut c_void;
+ pub fn CFAllocatorGetPreferredSizeForSize(
+ allocator: CFAllocatorRef,
+ size: CFIndex,
+ hint: CFOptionFlags,
+ ) -> CFIndex;
+ pub fn CFAllocatorReallocate(
+ allocator: CFAllocatorRef,
+ ptr: *mut c_void,
+ newsize: CFIndex,
+ hint: CFOptionFlags,
+ ) -> *mut c_void;
pub fn CFAllocatorGetDefault() -> CFAllocatorRef;
pub fn CFAllocatorSetDefault(allocator: CFAllocatorRef);
pub fn CFAllocatorGetContext(allocator: CFAllocatorRef, context: *mut CFAllocatorContext);
@@ -138,10 +176,12 @@ extern {
pub static kCFNull: CFNullRef;
+ pub fn CFNullGetTypeID() -> CFTypeID;
+
/* CFType Reference */
- //fn CFCopyTypeIDDescription
- //fn CFGetAllocator
+ pub fn CFCopyTypeIDDescription(type_id: CFTypeID) -> CFStringRef;
+ pub fn CFGetAllocator(cf: CFTypeRef) -> CFAllocatorRef;
pub fn CFCopyDescription(cf: CFTypeRef) -> CFStringRef;
pub fn CFEqual(cf1: CFTypeRef, cf2: CFTypeRef) -> Boolean;
pub fn CFGetRetainCount(cf: CFTypeRef) -> CFIndex;
diff --git a/vendor/core-foundation-sys/src/binary_heap.rs b/vendor/core-foundation-sys/src/binary_heap.rs
new file mode 100644
index 000000000..8bcaa8e26
--- /dev/null
+++ b/vendor/core-foundation-sys/src/binary_heap.rs
@@ -0,0 +1,83 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::c_void;
+
+use crate::base::{Boolean, CFAllocatorRef, CFComparisonResult, CFIndex, CFTypeID};
+use crate::string::CFStringRef;
+
+#[repr(C)]
+pub struct __CFBinaryHeap(c_void);
+
+pub type CFBinaryHeapRef = *mut __CFBinaryHeap;
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFBinaryHeapCompareContext {
+ pub version: CFIndex,
+ pub info: *mut c_void,
+ pub retain: extern "C" fn(info: *const c_void) -> *const c_void,
+ pub release: extern "C" fn(info: *const c_void),
+ pub copyDescription: extern "C" fn(info: *const c_void) -> CFStringRef,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFBinaryHeapCallBacks {
+ pub version: CFIndex,
+ pub retain: extern "C" fn(allocator: CFAllocatorRef, ptr: *const c_void) -> *const c_void,
+ pub release: extern "C" fn(allocator: CFAllocatorRef, ptr: *const c_void),
+ pub copyDescription: extern "C" fn(ptr: *const c_void) -> CFStringRef,
+ pub compare: extern "C" fn(
+ ptr1: *const c_void,
+ ptr2: *const c_void,
+ context: *mut c_void,
+ ) -> CFComparisonResult,
+}
+
+pub type CFBinaryHeapApplierFunction = extern "C" fn(val: *const c_void, context: *const c_void);
+
+extern "C" {
+ /*
+ * CFBinaryHeap.h
+ */
+ /* Predefined Callback Structures */
+ pub static kCFStringBinaryHeapCallBacks: CFBinaryHeapCallBacks;
+
+ /* CFBinaryHeap Miscellaneous Functions */
+ pub fn CFBinaryHeapAddValue(heap: CFBinaryHeapRef, value: *const c_void);
+ pub fn CFBinaryHeapApplyFunction(
+ heap: CFBinaryHeapRef,
+ applier: CFBinaryHeapApplierFunction,
+ context: *mut c_void,
+ );
+ pub fn CFBinaryHeapContainsValue(heap: CFBinaryHeapRef, value: *const c_void) -> Boolean;
+ pub fn CFBinaryHeapCreate(
+ allocator: CFAllocatorRef,
+ capacity: CFIndex,
+ callBacks: *const CFBinaryHeapCallBacks,
+ compareContext: *const CFBinaryHeapCompareContext,
+ ) -> CFBinaryHeapRef;
+ pub fn CFBinaryHeapCreateCopy(
+ allocator: CFAllocatorRef,
+ capacity: CFIndex,
+ heap: CFBinaryHeapRef,
+ ) -> CFBinaryHeapRef;
+ pub fn CFBinaryHeapGetCount(heap: CFBinaryHeapRef) -> CFIndex;
+ pub fn CFBinaryHeapGetCountOfValue(heap: CFBinaryHeapRef, value: *const c_void) -> CFIndex;
+ pub fn CFBinaryHeapGetMinimum(heap: CFBinaryHeapRef) -> *const c_void;
+ pub fn CFBinaryHeapGetMinimumIfPresent(
+ heap: CFBinaryHeapRef,
+ value: *const *const c_void,
+ ) -> Boolean;
+ pub fn CFBinaryHeapGetTypeID() -> CFTypeID;
+ pub fn CFBinaryHeapGetValues(heap: CFBinaryHeapRef, values: *const *const c_void);
+ pub fn CFBinaryHeapRemoveAllValues(heap: CFBinaryHeapRef);
+ pub fn CFBinaryHeapRemoveMinimumValue(heap: CFBinaryHeapRef);
+}
diff --git a/vendor/core-foundation-sys/src/bit_vector.rs b/vendor/core-foundation-sys/src/bit_vector.rs
new file mode 100644
index 000000000..f270c3d1d
--- /dev/null
+++ b/vendor/core-foundation-sys/src/bit_vector.rs
@@ -0,0 +1,74 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::c_void;
+
+use crate::base::{Boolean, CFAllocatorRef, CFIndex, CFRange, CFTypeID, UInt32, UInt8};
+
+#[repr(C)]
+pub struct __CFBitVector(c_void);
+
+pub type CFBitVectorRef = *const __CFBitVector;
+pub type CFMutableBitVectorRef = *mut __CFBitVector;
+pub type CFBit = UInt32;
+
+extern "C" {
+ /*
+ * CFBitVector.h
+ */
+
+ /* CFBitVector */
+ /* Creating a Bit Vector */
+ pub fn CFBitVectorCreate(
+ allocator: CFAllocatorRef,
+ bytes: *const UInt8,
+ numBits: CFIndex,
+ ) -> CFBitVectorRef;
+ pub fn CFBitVectorCreateCopy(allocator: CFAllocatorRef, bv: CFBitVectorRef) -> CFBitVectorRef;
+
+ /* Getting Information About a Bit Vector */
+ pub fn CFBitVectorContainsBit(bv: CFBitVectorRef, range: CFRange, value: CFBit) -> Boolean;
+ pub fn CFBitVectorGetBitAtIndex(bv: CFBitVectorRef, idx: CFIndex) -> CFBit;
+ pub fn CFBitVectorGetBits(bv: CFBitVectorRef, range: CFRange, bytes: *mut UInt8);
+ pub fn CFBitVectorGetCount(bv: CFBitVectorRef) -> CFIndex;
+ pub fn CFBitVectorGetCountOfBit(bv: CFBitVectorRef, range: CFRange, value: CFBit) -> CFIndex;
+ pub fn CFBitVectorGetFirstIndexOfBit(
+ bv: CFBitVectorRef,
+ range: CFRange,
+ value: CFBit,
+ ) -> CFIndex;
+ pub fn CFBitVectorGetLastIndexOfBit(
+ bv: CFBitVectorRef,
+ range: CFRange,
+ value: CFBit,
+ ) -> CFIndex;
+
+ /* Getting the CFBitVector Type ID */
+ pub fn CFBitVectorGetTypeID() -> CFTypeID;
+
+ /* CFMutableBitVector */
+ /* Creating a CFMutableBitVector Object */
+ pub fn CFBitVectorCreateMutable(
+ allocator: CFAllocatorRef,
+ capacity: CFIndex,
+ ) -> CFMutableBitVectorRef;
+ pub fn CFBitVectorCreateMutableCopy(
+ allocator: CFAllocatorRef,
+ capacity: CFIndex,
+ bv: CFBitVectorRef,
+ ) -> CFMutableBitVectorRef;
+
+ /* Modifying a Bit Vector */
+ pub fn CFBitVectorFlipBitAtIndex(bv: CFMutableBitVectorRef, idx: CFIndex);
+ pub fn CFBitVectorFlipBits(bv: CFMutableBitVectorRef, range: CFRange);
+ pub fn CFBitVectorSetAllBits(bv: CFMutableBitVectorRef, value: CFBit);
+ pub fn CFBitVectorSetBitAtIndex(bv: CFMutableBitVectorRef, idx: CFIndex, value: CFBit);
+ pub fn CFBitVectorSetBits(bv: CFMutableBitVectorRef, range: CFRange, value: CFBit);
+ pub fn CFBitVectorSetCount(bv: CFMutableBitVectorRef, count: CFIndex);
+}
diff --git a/vendor/core-foundation-sys/src/bundle.rs b/vendor/core-foundation-sys/src/bundle.rs
index 29f8e1261..60aaa4c77 100644
--- a/vendor/core-foundation-sys/src/bundle.rs
+++ b/vendor/core-foundation-sys/src/bundle.rs
@@ -9,31 +9,226 @@
use std::os::raw::c_void;
-use base::{CFTypeID, CFAllocatorRef};
-use url::CFURLRef;
-use dictionary::CFDictionaryRef;
-use string::CFStringRef;
+use crate::array::CFArrayRef;
+#[cfg(target_os = "macos")]
+use crate::base::SInt32;
+use crate::base::{Boolean, CFAllocatorRef, CFTypeID, CFTypeRef, UInt32};
+use crate::dictionary::CFDictionaryRef;
+use crate::error::CFErrorRef;
+use crate::string::CFStringRef;
+use crate::url::CFURLRef;
+use std::os::raw::{c_int, c_uint};
#[repr(C)]
pub struct __CFBundle(c_void);
pub type CFBundleRef = *mut __CFBundle;
+pub type CFPlugInRef = *mut __CFBundle;
+pub type CFBundleRefNum = c_int;
-extern {
+#[allow(unused)]
+#[inline(always)]
+pub unsafe fn CFCopyLocalizedString(key: CFStringRef, comment: CFStringRef) -> CFStringRef {
+ CFBundleCopyLocalizedString(CFBundleGetMainBundle(), key, key, std::ptr::null())
+}
+#[allow(unused)]
+#[inline(always)]
+pub unsafe fn CFCopyLocalizedStringFromTable(
+ key: CFStringRef,
+ tbl: CFStringRef,
+ comment: CFStringRef,
+) -> CFStringRef {
+ CFBundleCopyLocalizedString(CFBundleGetMainBundle(), key, key, tbl)
+}
+#[allow(unused)]
+#[inline(always)]
+pub unsafe fn CFCopyLocalizedStringFromTableInBundle(
+ key: CFStringRef,
+ tbl: CFStringRef,
+ bundle: CFBundleRef,
+ comment: CFStringRef,
+) -> CFStringRef {
+ CFBundleCopyLocalizedString(bundle, key, key, tbl)
+}
+#[allow(unused)]
+#[inline(always)]
+pub unsafe fn CFCopyLocalizedStringWithDefaultValue(
+ key: CFStringRef,
+ tbl: CFStringRef,
+ bundle: CFBundleRef,
+ value: CFStringRef,
+ comment: CFStringRef,
+) -> CFStringRef {
+ CFBundleCopyLocalizedString(bundle, key, value, tbl)
+}
+
+pub static kCFBundleExecutableArchitectureI386: c_uint = 0x00000007;
+pub static kCFBundleExecutableArchitecturePPC: c_uint = 0x00000012;
+pub static kCFBundleExecutableArchitectureX86_64: c_uint = 0x01000007;
+pub static kCFBundleExecutableArchitecturePPC64: c_uint = 0x01000012;
+//pub static kCFBundleExecutableArchitectureARM64: c_uint = 0x0100000c; //macos(11.0)+
+
+extern "C" {
/*
* CFBundle.h
*/
- pub fn CFBundleCreate(allocator: CFAllocatorRef, bundleURL: CFURLRef) -> CFBundleRef;
+ /* Information Property List Keys */
+ pub static kCFBundleInfoDictionaryVersionKey: CFStringRef;
+ pub static kCFBundleExecutableKey: CFStringRef;
+ pub static kCFBundleIdentifierKey: CFStringRef;
+ pub static kCFBundleVersionKey: CFStringRef;
+ pub static kCFBundleDevelopmentRegionKey: CFStringRef;
+ pub static kCFBundleNameKey: CFStringRef;
+ pub static kCFBundleLocalizationsKey: CFStringRef;
+
+ /* Creating and Accessing Bundles */
+ pub fn CFBundleCreate(allocator: CFAllocatorRef, bundleURL: CFURLRef) -> CFBundleRef;
+ pub fn CFBundleCreateBundlesFromDirectory(
+ allocator: CFAllocatorRef,
+ directoryURL: CFURLRef,
+ bundleType: CFStringRef,
+ ) -> CFArrayRef;
+ pub fn CFBundleGetAllBundles() -> CFArrayRef;
pub fn CFBundleGetBundleWithIdentifier(bundleID: CFStringRef) -> CFBundleRef;
- pub fn CFBundleGetFunctionPointerForName(bundle: CFBundleRef, function_name: CFStringRef) -> *const c_void;
pub fn CFBundleGetMainBundle() -> CFBundleRef;
- pub fn CFBundleGetInfoDictionary(bundle: CFBundleRef) -> CFDictionaryRef;
- pub fn CFBundleGetTypeID() -> CFTypeID;
+ /* Loading and Unloading a Bundle */
+ pub fn CFBundleIsExecutableLoaded(bundle: CFBundleRef) -> Boolean;
+ pub fn CFBundlePreflightExecutable(bundle: CFBundleRef, error: *mut CFErrorRef) -> Boolean;
+ pub fn CFBundleLoadExecutable(bundle: CFBundleRef) -> Boolean;
+ pub fn CFBundleLoadExecutableAndReturnError(
+ bundle: CFBundleRef,
+ error: *mut CFErrorRef,
+ ) -> Boolean;
+ pub fn CFBundleUnloadExecutable(bundle: CFBundleRef);
+
+ /* Finding Locations in a Bundle */
+ pub fn CFBundleCopyAuxiliaryExecutableURL(
+ bundle: CFBundleRef,
+ executableName: CFStringRef,
+ ) -> CFURLRef;
+ pub fn CFBundleCopyBuiltInPlugInsURL(bundle: CFBundleRef) -> CFURLRef;
pub fn CFBundleCopyExecutableURL(bundle: CFBundleRef) -> CFURLRef;
pub fn CFBundleCopyPrivateFrameworksURL(bundle: CFBundleRef) -> CFURLRef;
+ pub fn CFBundleCopyResourcesDirectoryURL(bundle: CFBundleRef) -> CFURLRef;
+ pub fn CFBundleCopySharedFrameworksURL(bundle: CFBundleRef) -> CFURLRef;
pub fn CFBundleCopySharedSupportURL(bundle: CFBundleRef) -> CFURLRef;
+ pub fn CFBundleCopySupportFilesDirectoryURL(bundle: CFBundleRef) -> CFURLRef;
+
+ /* Locating Bundle Resources */
+ #[cfg(target_os = "macos")]
+ pub fn CFBundleCloseBundleResourceMap(bundle: CFBundleRef, refNum: CFBundleRefNum); // DEPRECATED macosx(10.0, 10.15)
+ pub fn CFBundleCopyResourceURL(
+ bundle: CFBundleRef,
+ resourceName: CFStringRef,
+ resourceType: CFStringRef,
+ subDirName: CFStringRef,
+ ) -> CFURLRef;
+ pub fn CFBundleCopyResourceURLInDirectory(
+ bundleURL: CFURLRef,
+ resourceName: CFStringRef,
+ resourceType: CFStringRef,
+ subDirName: CFStringRef,
+ ) -> CFURLRef;
+ pub fn CFBundleCopyResourceURLsOfType(
+ bundle: CFBundleRef,
+ resourceType: CFStringRef,
+ subDirName: CFStringRef,
+ ) -> CFArrayRef;
+ pub fn CFBundleCopyResourceURLsOfTypeInDirectory(
+ bundleURL: CFURLRef,
+ resourceType: CFStringRef,
+ subDirName: CFStringRef,
+ ) -> CFArrayRef;
+ pub fn CFBundleCopyResourceURLForLocalization(
+ bundle: CFBundleRef,
+ resourceName: CFStringRef,
+ resourceType: CFStringRef,
+ subDirName: CFStringRef,
+ localizationName: CFStringRef,
+ ) -> CFURLRef;
+ pub fn CFBundleCopyResourceURLsOfTypeForLocalization(
+ bundle: CFBundleRef,
+ resourceType: CFStringRef,
+ subDirName: CFStringRef,
+ localizationName: CFStringRef,
+ ) -> CFArrayRef;
+ #[cfg(target_os = "macos")]
+ pub fn CFBundleOpenBundleResourceFiles(
+ bundle: CFBundleRef,
+ refNum: *mut CFBundleRefNum,
+ localizedRefNum: *mut CFBundleRefNum,
+ ) -> SInt32; // DEPRECATED macosx(10.0, 10.15)
+ #[cfg(target_os = "macos")]
+ pub fn CFBundleOpenBundleResourceMap(bundle: CFBundleRef) -> CFBundleRefNum; // DEPRECATED macosx(10.0, 10.15)
+
+ /* Managing Localizations */
+ pub fn CFBundleCopyBundleLocalizations(bundle: CFBundleRef) -> CFArrayRef;
+ pub fn CFBundleCopyLocalizedString(
+ bundle: CFBundleRef,
+ key: CFStringRef,
+ value: CFStringRef,
+ tableName: CFStringRef,
+ ) -> CFStringRef;
+ pub fn CFBundleCopyLocalizationsForPreferences(
+ locArray: CFArrayRef,
+ prefArray: CFArrayRef,
+ ) -> CFArrayRef;
+ pub fn CFBundleCopyLocalizationsForURL(url: CFURLRef) -> CFArrayRef;
+ pub fn CFBundleCopyPreferredLocalizationsFromArray(locArray: CFArrayRef) -> CFArrayRef;
+
+ /* Managing Executable Code */
+ pub fn CFBundleGetDataPointerForName(
+ bundle: CFBundleRef,
+ symbolName: CFStringRef,
+ ) -> *mut c_void;
+ pub fn CFBundleGetDataPointersForNames(
+ bundle: CFBundleRef,
+ symbolNames: CFArrayRef,
+ stbl: *mut [c_void],
+ );
+ pub fn CFBundleGetFunctionPointerForName(
+ bundle: CFBundleRef,
+ function_name: CFStringRef,
+ ) -> *const c_void;
+ pub fn CFBundleGetFunctionPointersForNames(
+ bundle: CFBundleRef,
+ functionNames: CFArrayRef,
+ ftbl: *mut [c_void],
+ );
+ pub fn CFBundleGetPlugIn(bundle: CFBundleRef) -> CFPlugInRef;
+
+ /* Getting Bundle Properties */
pub fn CFBundleCopyBundleURL(bundle: CFBundleRef) -> CFURLRef;
- pub fn CFBundleCopyResourcesDirectoryURL(bundle: CFBundleRef) -> CFURLRef;
+ pub fn CFBundleGetDevelopmentRegion(bundle: CFBundleRef) -> CFStringRef;
+ pub fn CFBundleGetIdentifier(bundle: CFBundleRef) -> CFStringRef;
+ pub fn CFBundleGetInfoDictionary(bundle: CFBundleRef) -> CFDictionaryRef;
+ pub fn CFBundleGetLocalInfoDictionary(bundle: CFBundleRef) -> CFDictionaryRef;
+ pub fn CFBundleGetValueForInfoDictionaryKey(bundle: CFBundleRef, key: CFStringRef)
+ -> CFTypeRef;
+ pub fn CFBundleCopyInfoDictionaryInDirectory(bundleURL: CFURLRef) -> CFDictionaryRef;
+ pub fn CFBundleCopyInfoDictionaryForURL(url: CFURLRef) -> CFDictionaryRef;
+ pub fn CFBundleGetPackageInfo(
+ bundle: CFBundleRef,
+ packageType: *mut UInt32,
+ packageCreator: *mut UInt32,
+ );
+ pub fn CFBundleGetPackageInfoInDirectory(
+ url: CFURLRef,
+ packageType: *mut UInt32,
+ packageCreator: *mut UInt32,
+ ) -> Boolean;
+ pub fn CFBundleCopyExecutableArchitectures(bundle: CFBundleRef) -> CFArrayRef;
+ pub fn CFBundleCopyExecutableArchitecturesForURL(url: CFURLRef) -> CFArrayRef;
+ pub fn CFBundleGetVersionNumber(bundle: CFBundleRef) -> UInt32;
+
+ /* macos(11.0)+
+ pub fn CFBundleIsExecutableLoadable(bundle: CFBundleRef) -> Boolean;
+ pub fn CFBundleIsExecutableLoadableForURL(url: CFURLRef) -> Boolean;
+ pub fn CFBundleIsArchitectureLoadable(arch: cpu_type_t) -> Boolean;
+ */
+
+ /* Getting the CFBundle Type ID */
+ pub fn CFBundleGetTypeID() -> CFTypeID;
}
diff --git a/vendor/core-foundation-sys/src/calendar.rs b/vendor/core-foundation-sys/src/calendar.rs
new file mode 100644
index 000000000..54c2a00cd
--- /dev/null
+++ b/vendor/core-foundation-sys/src/calendar.rs
@@ -0,0 +1,128 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::{c_char, c_void};
+
+use crate::base::{Boolean, CFAllocatorRef, CFIndex, CFOptionFlags, CFRange, CFTypeID};
+use crate::date::{CFAbsoluteTime, CFTimeInterval};
+use crate::locale::{CFCalendarIdentifier, CFLocaleRef};
+use crate::timezone::CFTimeZoneRef;
+
+#[repr(C)]
+pub struct __CFCalendar(c_void);
+pub type CFCalendarRef = *mut __CFCalendar;
+
+pub type CFCalendarUnit = CFOptionFlags;
+pub const kCFCalendarUnitEra: CFCalendarUnit = 1 << 1;
+pub const kCFCalendarUnitYear: CFCalendarUnit = 1 << 2;
+pub const kCFCalendarUnitMonth: CFCalendarUnit = 1 << 3;
+pub const kCFCalendarUnitDay: CFCalendarUnit = 1 << 4;
+pub const kCFCalendarUnitHour: CFCalendarUnit = 1 << 5;
+pub const kCFCalendarUnitMinute: CFCalendarUnit = 1 << 6;
+pub const kCFCalendarUnitSecond: CFCalendarUnit = 1 << 7;
+pub const kCFCalendarUnitWeek: CFCalendarUnit = 1 << 8; // deprecated since macos 10.10
+pub const kCFCalendarUnitWeekday: CFCalendarUnit = 1 << 9;
+pub const kCFCalendarUnitWeekdayOrdinal: CFCalendarUnit = 1 << 10;
+pub const kCFCalendarUnitQuarter: CFCalendarUnit = 1 << 11;
+pub const kCFCalendarUnitWeekOfMonth: CFCalendarUnit = 1 << 12;
+pub const kCFCalendarUnitWeekOfYear: CFCalendarUnit = 1 << 13;
+pub const kCFCalendarUnitYearForWeekOfYear: CFCalendarUnit = 1 << 14;
+
+pub const kCFCalendarComponentsWrap: CFOptionFlags = 1 << 0;
+
+extern "C" {
+ /*
+ * CFCalendar.h
+ */
+
+ /* Creating a Calendar */
+ pub fn CFCalendarCopyCurrent() -> CFCalendarRef;
+ pub fn CFCalendarCreateWithIdentifier(
+ allocator: CFAllocatorRef,
+ identifier: CFCalendarIdentifier,
+ ) -> CFCalendarRef;
+
+ /* Calendrical Calculations */
+ pub fn CFCalendarAddComponents(
+ identifier: CFCalendarIdentifier,
+ /* inout */ at: *mut CFAbsoluteTime,
+ options: CFOptionFlags,
+ componentDesc: *const char,
+ ...
+ ) -> Boolean;
+ pub fn CFCalendarComposeAbsoluteTime(
+ identifier: CFCalendarIdentifier,
+ /* out */ at: *mut CFAbsoluteTime,
+ componentDesc: *const c_char,
+ ...
+ ) -> Boolean;
+ pub fn CFCalendarDecomposeAbsoluteTime(
+ identifier: CFCalendarIdentifier,
+ at: CFAbsoluteTime,
+ componentDesc: *const c_char,
+ ...
+ ) -> Boolean;
+ pub fn CFCalendarGetComponentDifference(
+ identifier: CFCalendarIdentifier,
+ startingAT: CFAbsoluteTime,
+ resultAT: CFAbsoluteTime,
+ options: CFOptionFlags,
+ componentDesc: *const c_char,
+ ...
+ ) -> Boolean;
+
+ /* Getting Ranges of Units */
+ pub fn CFCalendarGetRangeOfUnit(
+ identifier: CFCalendarIdentifier,
+ smallerUnit: CFCalendarUnit,
+ biggerUnit: CFCalendarUnit,
+ at: CFAbsoluteTime,
+ ) -> CFRange;
+ pub fn CFCalendarGetOrdinalityOfUnit(
+ identifier: CFCalendarIdentifier,
+ smallerUnit: CFCalendarUnit,
+ biggerUnit: CFCalendarUnit,
+ at: CFAbsoluteTime,
+ ) -> CFIndex;
+ pub fn CFCalendarGetTimeRangeOfUnit(
+ identifier: CFCalendarIdentifier,
+ unit: CFCalendarUnit,
+ at: CFAbsoluteTime,
+ startp: *mut CFAbsoluteTime,
+ tip: *mut CFTimeInterval,
+ ) -> Boolean;
+ pub fn CFCalendarGetMaximumRangeOfUnit(
+ identifier: CFCalendarIdentifier,
+ unit: CFCalendarUnit,
+ ) -> CFRange;
+ pub fn CFCalendarGetMinimumRangeOfUnit(
+ identifier: CFCalendarIdentifier,
+ unit: CFCalendarUnit,
+ ) -> CFRange;
+
+ /* Getting and Setting the Time Zone */
+ pub fn CFCalendarCopyTimeZone(identifier: CFCalendarIdentifier) -> CFTimeZoneRef;
+ pub fn CFCalendarSetTimeZone(identifier: CFCalendarIdentifier, tz: CFTimeZoneRef);
+
+ /* Getting the Identifier */
+ pub fn CFCalendarGetIdentifier(identifier: CFCalendarIdentifier) -> CFCalendarIdentifier;
+
+ /* Getting and Setting the Locale */
+ pub fn CFCalendarCopyLocale(identifier: CFCalendarIdentifier) -> CFLocaleRef;
+ pub fn CFCalendarSetLocale(identifier: CFCalendarIdentifier, locale: CFLocaleRef);
+
+ /* Getting and Setting Day Information */
+ pub fn CFCalendarGetFirstWeekday(identifier: CFCalendarIdentifier) -> CFIndex;
+ pub fn CFCalendarSetFirstWeekday(identifier: CFCalendarIdentifier, wkdy: CFIndex);
+ pub fn CFCalendarGetMinimumDaysInFirstWeek(identifier: CFCalendarIdentifier) -> CFIndex;
+ pub fn CFCalendarSetMinimumDaysInFirstWeek(identifier: CFCalendarIdentifier, mwd: CFIndex);
+
+ /* Getting the Type ID */
+ pub fn CFCalendarGetTypeID() -> CFTypeID;
+}
diff --git a/vendor/core-foundation-sys/src/characterset.rs b/vendor/core-foundation-sys/src/characterset.rs
index 6b347a5cd..8d75679af 100644
--- a/vendor/core-foundation-sys/src/characterset.rs
+++ b/vendor/core-foundation-sys/src/characterset.rs
@@ -7,10 +7,10 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use crate::base::{Boolean, CFAllocatorRef, CFIndex, CFRange, CFTypeID, UTF32Char};
+use crate::data::CFDataRef;
+use crate::string::{CFStringRef, UniChar};
use std::os::raw::c_void;
-use base::{Boolean, CFAllocatorRef, CFIndex, CFRange, CFTypeID};
-use data::CFDataRef;
-use string::{CFStringRef, UniChar};
pub type CFCharacterSetPredefinedSet = CFIndex;
@@ -35,24 +35,90 @@ pub static kCFCharacterSetNewline: CFCharacterSetPredefinedSet = 15;
pub struct __CFCharacterSet(c_void);
pub type CFCharacterSetRef = *const __CFCharacterSet;
-pub type CFMutableCharacterSetRef = *const __CFCharacterSet;
+pub type CFMutableCharacterSetRef = *mut __CFCharacterSet;
-extern {
+extern "C" {
+ /*
+ * CFCharacterSet.h
+ */
+
+ /* CFCharacterSet */
+ /* Creating Character Sets */
+ pub fn CFCharacterSetCreateCopy(
+ alloc: CFAllocatorRef,
+ theSet: CFCharacterSetRef,
+ ) -> CFCharacterSetRef;
+ pub fn CFCharacterSetCreateInvertedSet(
+ alloc: CFAllocatorRef,
+ theSet: CFCharacterSetRef,
+ ) -> CFCharacterSetRef;
+ pub fn CFCharacterSetCreateWithCharactersInRange(
+ alloc: CFAllocatorRef,
+ theRange: CFRange,
+ ) -> CFCharacterSetRef;
+ pub fn CFCharacterSetCreateWithCharactersInString(
+ alloc: CFAllocatorRef,
+ theString: CFStringRef,
+ ) -> CFCharacterSetRef;
+ pub fn CFCharacterSetCreateWithBitmapRepresentation(
+ alloc: CFAllocatorRef,
+ theData: CFDataRef,
+ ) -> CFCharacterSetRef;
+
+ /* Getting Predefined Character Sets */
+ pub fn CFCharacterSetGetPredefined(
+ theSetIdentifier: CFCharacterSetPredefinedSet,
+ ) -> CFCharacterSetRef;
+
+ /* Querying Character Sets */
+ pub fn CFCharacterSetCreateBitmapRepresentation(
+ alloc: CFAllocatorRef,
+ theSet: CFCharacterSetRef,
+ ) -> CFDataRef;
+ pub fn CFCharacterSetHasMemberInPlane(theSet: CFCharacterSetRef, thePlane: CFIndex) -> Boolean;
+ pub fn CFCharacterSetIsCharacterMember(theSet: CFCharacterSetRef, theChar: UniChar) -> Boolean;
+ pub fn CFCharacterSetIsLongCharacterMember(
+ theSet: CFCharacterSetRef,
+ theChar: UTF32Char,
+ ) -> Boolean;
+ pub fn CFCharacterSetIsSupersetOfSet(
+ theSet: CFCharacterSetRef,
+ theOtherset: CFCharacterSetRef,
+ ) -> Boolean;
+
+ /* Getting the Character Set Type Identifier */
pub fn CFCharacterSetGetTypeID() -> CFTypeID;
- pub fn CFCharacterSetGetPredefined(theSetIdentifier: CFCharacterSetPredefinedSet) -> CFCharacterSetRef;
- pub fn CFCharacterSetCreateWithCharactersInRange(alloc: CFAllocatorRef, theRange: CFRange) -> CFCharacterSetRef;
- pub fn CFCharacterSetCreateWithCharactersInString(alloc: CFAllocatorRef, theString: CFStringRef) -> CFCharacterSetRef;
- pub fn CFCharacterSetCreateWithBitmapRepresentation(alloc: CFAllocatorRef, theData: CFDataRef) -> CFCharacterSetRef;
+
+ /* CFMutableCharacterSet */
+ /* Creating a Mutable Character Set */
pub fn CFCharacterSetCreateMutable(alloc: CFAllocatorRef) -> CFMutableCharacterSetRef;
- pub fn CFCharacterSetCreateCopy(alloc: CFAllocatorRef, theSet: CFCharacterSetRef) -> CFCharacterSetRef;
- pub fn CFCharacterSetCreateMutableCopy(alloc: CFAllocatorRef, theSet: CFCharacterSetRef) -> CFMutableCharacterSetRef;
- pub fn CFCharacterSetIsCharacterMember(theSet: CFCharacterSetRef, theChar: UniChar) -> Boolean;
- pub fn CFCharacterSetCreateBitmapRepresentation(alloc: CFAllocatorRef, theSet: CFCharacterSetRef) -> CFDataRef;
+ pub fn CFCharacterSetCreateMutableCopy(
+ alloc: CFAllocatorRef,
+ theSet: CFCharacterSetRef,
+ ) -> CFMutableCharacterSetRef;
+
+ /* Adding Characters */
pub fn CFCharacterSetAddCharactersInRange(theSet: CFMutableCharacterSetRef, theRange: CFRange);
- pub fn CFCharacterSetRemoveCharactersInRange(theSet: CFMutableCharacterSetRef, theRange: CFRange);
- pub fn CFCharacterSetAddCharactersInString(theSet: CFMutableCharacterSetRef, theString: CFStringRef);
- pub fn CFCharacterSetRemoveCharactersInString(theSet: CFMutableCharacterSetRef, theString: CFStringRef);
- pub fn CFCharacterSetUnion(theSet: CFMutableCharacterSetRef, theOtherSet: CFCharacterSetRef);
- pub fn CFCharacterSetIntersect(theSet: CFMutableCharacterSetRef, theOtherSet: CFCharacterSetRef);
+ pub fn CFCharacterSetAddCharactersInString(
+ theSet: CFMutableCharacterSetRef,
+ theString: CFStringRef,
+ );
+
+ /* Removing Characters */
+ pub fn CFCharacterSetRemoveCharactersInRange(
+ theSet: CFMutableCharacterSetRef,
+ theRange: CFRange,
+ );
+ pub fn CFCharacterSetRemoveCharactersInString(
+ theSet: CFMutableCharacterSetRef,
+ theString: CFStringRef,
+ );
+
+ /* Logical Operations */
+ pub fn CFCharacterSetIntersect(
+ theSet: CFMutableCharacterSetRef,
+ theOtherSet: CFCharacterSetRef,
+ );
pub fn CFCharacterSetInvert(theSet: CFMutableCharacterSetRef);
+ pub fn CFCharacterSetUnion(theSet: CFMutableCharacterSetRef, theOtherSet: CFCharacterSetRef);
}
diff --git a/vendor/core-foundation-sys/src/data.rs b/vendor/core-foundation-sys/src/data.rs
index e5ed0dc9f..ba87d0c5d 100644
--- a/vendor/core-foundation-sys/src/data.rs
+++ b/vendor/core-foundation-sys/src/data.rs
@@ -7,32 +7,71 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use crate::base::{CFAllocatorRef, CFIndex, CFOptionFlags, CFRange, CFTypeID};
use std::os::raw::c_void;
-use base::{CFAllocatorRef, CFTypeID, CFIndex, CFRange};
-
#[repr(C)]
pub struct __CFData(c_void);
pub type CFDataRef = *const __CFData;
+pub type CFMutableDataRef = *mut __CFData;
+pub type CFDataSearchFlags = CFOptionFlags;
+
+// typedef CF_OPTIONS(CFOptionFlags, CFDataSearchFlags)
+pub const kCFDataSearchBackwards: CFDataSearchFlags = 1usize << 0;
+pub const kCFDataSearchAnchored: CFDataSearchFlags = 1usize << 1;
-extern {
+extern "C" {
/*
* CFData.h
*/
- pub fn CFDataCreate(allocator: CFAllocatorRef,
- bytes: *const u8, length: CFIndex) -> CFDataRef;
- //fn CFDataFind
- pub fn CFDataGetBytePtr(theData: CFDataRef) -> *const u8;
- pub fn CFDataGetBytes(theData: CFDataRef, range: CFRange, buffer: *mut u8);
- pub fn CFDataGetLength(theData: CFDataRef) -> CFIndex;
+ /* CFData */
+ /* Creating a CFData Object */
+ pub fn CFDataCreate(allocator: CFAllocatorRef, bytes: *const u8, length: CFIndex) -> CFDataRef;
+ pub fn CFDataCreateCopy(allocator: CFAllocatorRef, theData: CFDataRef) -> CFDataRef;
pub fn CFDataCreateWithBytesNoCopy(
allocator: CFAllocatorRef,
bytes: *const u8,
length: CFIndex,
- allocator: CFAllocatorRef,
+ bytesDeallocator: CFAllocatorRef,
) -> CFDataRef;
+ /* Examining a CFData Object */
+ pub fn CFDataGetBytePtr(theData: CFDataRef) -> *const u8;
+ pub fn CFDataGetBytes(theData: CFDataRef, range: CFRange, buffer: *mut u8);
+ pub fn CFDataGetLength(theData: CFDataRef) -> CFIndex;
+ pub fn CFDataFind(
+ theData: CFDataRef,
+ dataToFind: CFDataRef,
+ searchRange: CFRange,
+ compareOptions: CFDataSearchFlags,
+ ) -> CFRange;
+
+ /* Getting the CFData Type ID */
pub fn CFDataGetTypeID() -> CFTypeID;
+
+ /* CFMutableData */
+ /* Creating a Mutable Data Object */
+ pub fn CFDataCreateMutable(allocator: CFAllocatorRef, capacity: CFIndex) -> CFMutableDataRef;
+ pub fn CFDataCreateMutableCopy(
+ allocator: CFAllocatorRef,
+ capacity: CFIndex,
+ theData: CFDataRef,
+ ) -> CFMutableDataRef;
+
+ /* Accessing Data */
+ pub fn CFDataGetMutableBytePtr(theData: CFMutableDataRef) -> *mut u8;
+
+ /* Modifying a Mutable Data Object */
+ pub fn CFDataAppendBytes(theData: CFMutableDataRef, bytes: *const u8, length: CFIndex);
+ pub fn CFDataDeleteBytes(theData: CFMutableDataRef, range: CFRange);
+ pub fn CFDataReplaceBytes(
+ theData: CFMutableDataRef,
+ range: CFRange,
+ newBytes: *const u8,
+ newLength: CFIndex,
+ );
+ pub fn CFDataIncreaseLength(theData: CFMutableDataRef, extraLength: CFIndex);
+ pub fn CFDataSetLength(theData: CFMutableDataRef, length: CFIndex);
}
diff --git a/vendor/core-foundation-sys/src/date.rs b/vendor/core-foundation-sys/src/date.rs
index f83ce1dd1..26b55d402 100644
--- a/vendor/core-foundation-sys/src/date.rs
+++ b/vendor/core-foundation-sys/src/date.rs
@@ -9,7 +9,7 @@
use std::os::raw::c_void;
-use base::{CFAllocatorRef, CFComparisonResult, CFTypeID};
+use crate::base::{CFAllocatorRef, CFComparisonResult, CFTypeID};
#[repr(C)]
pub struct __CFDate(c_void);
@@ -19,7 +19,7 @@ pub type CFDateRef = *const __CFDate;
pub type CFTimeInterval = f64;
pub type CFAbsoluteTime = CFTimeInterval;
-extern {
+extern "C" {
pub static kCFAbsoluteTimeIntervalSince1904: CFTimeInterval;
pub static kCFAbsoluteTimeIntervalSince1970: CFTimeInterval;
@@ -28,7 +28,11 @@ extern {
pub fn CFDateCreate(allocator: CFAllocatorRef, at: CFAbsoluteTime) -> CFDateRef;
pub fn CFDateGetAbsoluteTime(date: CFDateRef) -> CFAbsoluteTime;
pub fn CFDateGetTimeIntervalSinceDate(date: CFDateRef, other: CFDateRef) -> CFTimeInterval;
- pub fn CFDateCompare(date: CFDateRef, other: CFDateRef, context: *mut c_void) -> CFComparisonResult;
+ pub fn CFDateCompare(
+ date: CFDateRef,
+ other: CFDateRef,
+ context: *mut c_void,
+ ) -> CFComparisonResult;
pub fn CFDateGetTypeID() -> CFTypeID;
}
diff --git a/vendor/core-foundation-sys/src/date_formatter.rs b/vendor/core-foundation-sys/src/date_formatter.rs
new file mode 100644
index 000000000..83c6e1fa7
--- /dev/null
+++ b/vendor/core-foundation-sys/src/date_formatter.rs
@@ -0,0 +1,147 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::c_void;
+
+use crate::base::{Boolean, CFAllocatorRef, CFIndex, CFOptionFlags, CFRange, CFTypeID, CFTypeRef};
+use crate::date::{CFAbsoluteTime, CFDateRef};
+use crate::locale::CFLocaleRef;
+use crate::string::CFStringRef;
+
+#[repr(C)]
+pub struct __CFDateFormatter(c_void);
+pub type CFDateFormatterRef = *mut __CFDateFormatter;
+
+pub type CFDateFormatterKey = CFStringRef;
+pub type CFDateFormatterStyle = CFIndex;
+pub type CFISO8601DateFormatOptions = CFOptionFlags;
+
+/* Date Formatter Styles */
+pub const kCFDateFormatterNoStyle: CFDateFormatterStyle = 0;
+pub const kCFDateFormatterShortStyle: CFDateFormatterStyle = 1;
+pub const kCFDateFormatterMediumStyle: CFDateFormatterStyle = 2;
+pub const kCFDateFormatterLongStyle: CFDateFormatterStyle = 3;
+pub const kCFDateFormatterFullStyle: CFDateFormatterStyle = 4;
+
+//pub const kCFISO8601DateFormatWithYear: CFISO8601DateFormatOptions = 1 << 0; // macosx(10.12)+
+//pub const kCFISO8601DateFormatWithMonth: CFISO8601DateFormatOptions = 1 << 1; // macosx(10.12)+
+//pub const kCFISO8601DateFormatWithWeekOfYear: CFISO8601DateFormatOptions = 1 << 2; // macosx(10.12)+
+//pub const kCFISO8601DateFormatWithDay: CFISO8601DateFormatOptions = 1 << 4; // macosx(10.12)+
+//pub const kCFISO8601DateFormatWithTime: CFISO8601DateFormatOptions = 1 << 5; // macosx(10.12)+
+//pub const kCFISO8601DateFormatWithTimeZone: CFISO8601DateFormatOptions = 1 << 6; // macosx(10.12)+
+//pub const kCFISO8601DateFormatWithSpaceBetweenDateAndTime: CFISO8601DateFormatOptions = 1 << 7; // macosx(10.12)+
+//pub const kCFISO8601DateFormatWithDashSeparatorInDate: CFISO8601DateFormatOptions = 1 << 8; // macosx(10.12)+
+//pub const kCFISO8601DateFormatWithColonSeparatorInTime: CFISO8601DateFormatOptions = 1 << 9; // macosx(10.12)+
+//pub const kCFISO8601DateFormatWithColonSeparatorInTimeZone: CFISO8601DateFormatOptions = 1 << 10; // macosx(10.12)+
+//pub const kCFISO8601DateFormatWithFractionalSeconds: CFISO8601DateFormatOptions = 1 << 11; // macosx(10.13)+
+//pub const kCFISO8601DateFormatWithFullDate: CFISO8601DateFormatOptions = kCFISO8601DateFormatWithYear | kCFISO8601DateFormatWithMonth | kCFISO8601DateFormatWithDay | kCFISO8601DateFormatWithDashSeparatorInDate; // macosx(10.12)+
+//pub const kCFISO8601DateFormatWithFullTime: CFISO8601DateFormatOptions = kCFISO8601DateFormatWithTime | kCFISO8601DateFormatWithColonSeparatorInTime | kCFISO8601DateFormatWithTimeZone | kCFISO8601DateFormatWithColonSeparatorInTimeZone; // macosx(10.12)+
+//pub const kCFISO8601DateFormatWithInternetDateTime: CFISO8601DateFormatOptions = kCFISO8601DateFormatWithFullDate | kCFISO8601DateFormatWithFullTime; // macosx(10.12)+
+
+extern "C" {
+ /*
+ * CFDateFormatter.h
+ */
+
+ /* Date Formatter Property Keys */
+ // The values for these keys are all CFType objects.
+ // The specific types for each key are specified above.
+ pub static kCFDateFormatterIsLenient: CFDateFormatterKey; // CFBoolean
+ pub static kCFDateFormatterTimeZone: CFDateFormatterKey; // CFTimeZone
+ pub static kCFDateFormatterCalendarName: CFDateFormatterKey; // CFString
+ pub static kCFDateFormatterDefaultFormat: CFDateFormatterKey; // CFString
+ pub static kCFDateFormatterTwoDigitStartDate: CFDateFormatterKey; // CFDate
+ pub static kCFDateFormatterDefaultDate: CFDateFormatterKey; // CFDate
+ pub static kCFDateFormatterCalendar: CFDateFormatterKey; // CFCalendar
+ pub static kCFDateFormatterEraSymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterMonthSymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterShortMonthSymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterWeekdaySymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterShortWeekdaySymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterAMSymbol: CFDateFormatterKey; // CFString
+ pub static kCFDateFormatterPMSymbol: CFDateFormatterKey; // CFString
+ pub static kCFDateFormatterLongEraSymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterVeryShortMonthSymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterStandaloneMonthSymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterShortStandaloneMonthSymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterVeryShortStandaloneMonthSymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterVeryShortWeekdaySymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterStandaloneWeekdaySymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterShortStandaloneWeekdaySymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterVeryShortStandaloneWeekdaySymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterQuarterSymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterShortQuarterSymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterStandaloneQuarterSymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterShortStandaloneQuarterSymbols: CFDateFormatterKey; // CFArray of CFString
+ pub static kCFDateFormatterGregorianStartDate: CFDateFormatterKey; // CFDate
+ pub static kCFDateFormatterDoesRelativeDateFormattingKey: CFDateFormatterKey; // CFBoolean
+
+ /* Creating a Date Formatter */
+ pub fn CFDateFormatterCreate(
+ allocator: CFAllocatorRef,
+ locale: CFLocaleRef,
+ dateStyle: CFDateFormatterStyle,
+ timeStyle: CFDateFormatterStyle,
+ ) -> CFDateFormatterRef;
+
+ /* Configuring a Date Formatter */
+ pub fn CFDateFormatterSetFormat(formatter: CFDateFormatterRef, formatString: CFStringRef);
+ pub fn CFDateFormatterSetProperty(
+ formatter: CFDateFormatterRef,
+ key: CFStringRef,
+ value: CFTypeRef,
+ );
+
+ /* Parsing Strings */
+ pub fn CFDateFormatterCreateDateFromString(
+ allocator: CFAllocatorRef,
+ formatter: CFDateFormatterRef,
+ string: CFStringRef,
+ rangep: *mut CFRange,
+ ) -> CFDateRef;
+ pub fn CFDateFormatterGetAbsoluteTimeFromString(
+ formatter: CFDateFormatterRef,
+ string: CFStringRef,
+ rangep: *mut CFRange,
+ atp: *mut CFAbsoluteTime,
+ ) -> Boolean;
+
+ /* Creating Strings From Data */
+ pub fn CFDateFormatterCreateStringWithAbsoluteTime(
+ allocator: CFAllocatorRef,
+ formatter: CFDateFormatterRef,
+ at: CFAbsoluteTime,
+ ) -> CFStringRef;
+ pub fn CFDateFormatterCreateStringWithDate(
+ allocator: CFAllocatorRef,
+ formatter: CFDateFormatterRef,
+ date: CFDateRef,
+ ) -> CFStringRef;
+ pub fn CFDateFormatterCreateDateFormatFromTemplate(
+ allocator: CFAllocatorRef,
+ tmplate: CFStringRef,
+ options: CFOptionFlags,
+ locale: CFLocaleRef,
+ ) -> CFStringRef;
+
+ /* Getting Information About a Date Formatter */
+ pub fn CFDateFormatterCopyProperty(
+ formatter: CFDateFormatterRef,
+ key: CFDateFormatterKey,
+ ) -> CFTypeRef;
+ pub fn CFDateFormatterGetDateStyle(formatter: CFDateFormatterRef) -> CFDateFormatterStyle;
+ pub fn CFDateFormatterGetFormat(formatter: CFDateFormatterRef) -> CFStringRef;
+ pub fn CFDateFormatterGetLocale(formatter: CFDateFormatterRef) -> CFLocaleRef;
+ pub fn CFDateFormatterGetTimeStyle(formatter: CFDateFormatterRef) -> CFDateFormatterStyle;
+
+ /* Getting the CFDateFormatter Type ID */
+ pub fn CFDateFormatterGetTypeID() -> CFTypeID;
+
+ //pub fn CFDateFormatterCreateISO8601Formatter(allocator: CFAllocatorRef, formatOptions: CFISO8601DateFormatOptions) -> CFDateFormatterRef; // macosx(10.12)+
+}
diff --git a/vendor/core-foundation-sys/src/dictionary.rs b/vendor/core-foundation-sys/src/dictionary.rs
index d10e9c120..8c04d680d 100644
--- a/vendor/core-foundation-sys/src/dictionary.rs
+++ b/vendor/core-foundation-sys/src/dictionary.rs
@@ -9,15 +9,19 @@
use std::os::raw::c_void;
-use base::{CFAllocatorRef, CFHashCode, CFIndex, CFTypeID, Boolean};
-use string::CFStringRef;
+use crate::base::{Boolean, CFAllocatorRef, CFHashCode, CFIndex, CFTypeID};
+use crate::string::CFStringRef;
-pub type CFDictionaryApplierFunction = extern "C" fn(key: *const c_void, value: *const c_void, context: *mut c_void);
+pub type CFDictionaryApplierFunction =
+ extern "C" fn(key: *const c_void, value: *const c_void, context: *mut c_void);
-pub type CFDictionaryRetainCallBack = extern "C" fn(allocator: CFAllocatorRef, value: *const c_void) -> *const c_void;
-pub type CFDictionaryReleaseCallBack = extern "C" fn(allocator: CFAllocatorRef, value: *const c_void);
+pub type CFDictionaryRetainCallBack =
+ extern "C" fn(allocator: CFAllocatorRef, value: *const c_void) -> *const c_void;
+pub type CFDictionaryReleaseCallBack =
+ extern "C" fn(allocator: CFAllocatorRef, value: *const c_void);
pub type CFDictionaryCopyDescriptionCallBack = extern "C" fn(value: *const c_void) -> CFStringRef;
-pub type CFDictionaryEqualCallBack = extern "C" fn(value1: *const c_void, value2: *const c_void) -> Boolean;
+pub type CFDictionaryEqualCallBack =
+ extern "C" fn(value1: *const c_void, value2: *const c_void) -> Boolean;
pub type CFDictionaryHashCallBack = extern "C" fn(value: *const c_void) -> CFHashCode;
#[repr(C)]
@@ -28,7 +32,7 @@ pub struct CFDictionaryKeyCallBacks {
pub release: CFDictionaryReleaseCallBack,
pub copyDescription: CFDictionaryCopyDescriptionCallBack,
pub equal: CFDictionaryEqualCallBack,
- pub hash: CFDictionaryHashCallBack
+ pub hash: CFDictionaryHashCallBack,
}
#[repr(C)]
@@ -38,7 +42,7 @@ pub struct CFDictionaryValueCallBacks {
pub retain: CFDictionaryRetainCallBack,
pub release: CFDictionaryReleaseCallBack,
pub copyDescription: CFDictionaryCopyDescriptionCallBack,
- pub equal: CFDictionaryEqualCallBack
+ pub equal: CFDictionaryEqualCallBack,
}
#[repr(C)]
@@ -47,45 +51,89 @@ pub struct __CFDictionary(c_void);
pub type CFDictionaryRef = *const __CFDictionary;
pub type CFMutableDictionaryRef = *mut __CFDictionary;
-extern {
+extern "C" {
/*
* CFDictionary.h
*/
pub static kCFTypeDictionaryKeyCallBacks: CFDictionaryKeyCallBacks;
+ pub static kCFCopyStringDictionaryKeyCallBacks: CFDictionaryKeyCallBacks;
pub static kCFTypeDictionaryValueCallBacks: CFDictionaryValueCallBacks;
+ /* CFDictionary */
+ /* Creating a dictionary */
+ pub fn CFDictionaryCreate(
+ allocator: CFAllocatorRef,
+ keys: *const *const c_void,
+ values: *const *const c_void,
+ numValues: CFIndex,
+ keyCallBacks: *const CFDictionaryKeyCallBacks,
+ valueCallBacks: *const CFDictionaryValueCallBacks,
+ ) -> CFDictionaryRef;
+ pub fn CFDictionaryCreateCopy(
+ allocator: CFAllocatorRef,
+ theDict: CFDictionaryRef,
+ ) -> CFDictionaryRef;
+
+ /* Examining a dictionary */
pub fn CFDictionaryContainsKey(theDict: CFDictionaryRef, key: *const c_void) -> Boolean;
- pub fn CFDictionaryCreate(allocator: CFAllocatorRef, keys: *const *const c_void, values: *const *const c_void,
- numValues: CFIndex, keyCallBacks: *const CFDictionaryKeyCallBacks,
- valueCallBacks: *const CFDictionaryValueCallBacks)
- -> CFDictionaryRef;
+ pub fn CFDictionaryContainsValue(theDict: CFDictionaryRef, value: *const c_void) -> Boolean;
pub fn CFDictionaryGetCount(theDict: CFDictionaryRef) -> CFIndex;
+ pub fn CFDictionaryGetCountOfKey(theDict: CFDictionaryRef, key: *const c_void) -> CFIndex;
+ pub fn CFDictionaryGetCountOfValue(heDict: CFDictionaryRef, value: *const c_void) -> CFIndex;
+ pub fn CFDictionaryGetKeysAndValues(
+ theDict: CFDictionaryRef,
+ keys: *mut *const c_void,
+ values: *mut *const c_void,
+ );
+ pub fn CFDictionaryGetValue(theDict: CFDictionaryRef, key: *const c_void) -> *const c_void;
+ pub fn CFDictionaryGetValueIfPresent(
+ theDict: CFDictionaryRef,
+ key: *const c_void,
+ value: *mut *const c_void,
+ ) -> Boolean;
+
+ /* Applying a function to a dictionary */
+ pub fn CFDictionaryApplyFunction(
+ theDict: CFDictionaryRef,
+ applier: CFDictionaryApplierFunction,
+ context: *mut c_void,
+ );
+
+ /* Getting the CFDictionary type ID */
pub fn CFDictionaryGetTypeID() -> CFTypeID;
- pub fn CFDictionaryGetValueIfPresent(theDict: CFDictionaryRef, key: *const c_void, value: *mut *const c_void)
- -> Boolean;
- pub fn CFDictionaryApplyFunction(theDict: CFDictionaryRef,
- applier: CFDictionaryApplierFunction,
- context: *mut c_void);
- pub fn CFDictionaryGetKeysAndValues(theDict: CFDictionaryRef,
- keys: *mut *const c_void,
- values: *mut *const c_void);
-
- pub fn CFDictionaryCreateMutable(allocator: CFAllocatorRef, capacity: CFIndex,
- keyCallbacks: *const CFDictionaryKeyCallBacks,
- valueCallbacks: *const CFDictionaryValueCallBacks) -> CFMutableDictionaryRef;
- pub fn CFDictionaryCreateMutableCopy(allocator: CFAllocatorRef, capacity: CFIndex,
- theDict: CFDictionaryRef) -> CFMutableDictionaryRef;
- pub fn CFDictionaryAddValue(theDict: CFMutableDictionaryRef,
- key: *const c_void,
- value: *const c_void);
- pub fn CFDictionarySetValue(theDict: CFMutableDictionaryRef,
- key: *const c_void,
- value: *const c_void);
- pub fn CFDictionaryReplaceValue(theDict: CFMutableDictionaryRef,
- key: *const c_void,
- value: *const c_void);
- pub fn CFDictionaryRemoveValue(theDict: CFMutableDictionaryRef,
- key: *const c_void);
+
+ /* CFMutableDictionary */
+ /* Creating a Mutable Dictionary */
+ pub fn CFDictionaryCreateMutable(
+ allocator: CFAllocatorRef,
+ capacity: CFIndex,
+ keyCallbacks: *const CFDictionaryKeyCallBacks,
+ valueCallbacks: *const CFDictionaryValueCallBacks,
+ ) -> CFMutableDictionaryRef;
+ pub fn CFDictionaryCreateMutableCopy(
+ allocator: CFAllocatorRef,
+ capacity: CFIndex,
+ theDict: CFDictionaryRef,
+ ) -> CFMutableDictionaryRef;
+
+ /* Modifying a Dictionary */
+ pub fn CFDictionaryAddValue(
+ theDict: CFMutableDictionaryRef,
+ key: *const c_void,
+ value: *const c_void,
+ );
pub fn CFDictionaryRemoveAllValues(theDict: CFMutableDictionaryRef);
+ pub fn CFDictionaryRemoveValue(theDict: CFMutableDictionaryRef, key: *const c_void);
+ pub fn CFDictionaryReplaceValue(
+ theDict: CFMutableDictionaryRef,
+ key: *const c_void,
+ value: *const c_void,
+ );
+ pub fn CFDictionarySetValue(
+ theDict: CFMutableDictionaryRef,
+ key: *const c_void,
+ value: *const c_void,
+ );
+
}
diff --git a/vendor/core-foundation-sys/src/error.rs b/vendor/core-foundation-sys/src/error.rs
index 8a4c1d494..e8ebd6c42 100644
--- a/vendor/core-foundation-sys/src/error.rs
+++ b/vendor/core-foundation-sys/src/error.rs
@@ -9,24 +9,54 @@
use std::os::raw::c_void;
-use base::{CFTypeID, CFIndex};
-use string::CFStringRef;
+use crate::base::{CFAllocatorRef, CFIndex, CFTypeID};
+use crate::dictionary::CFDictionaryRef;
+use crate::string::CFStringRef;
#[repr(C)]
pub struct __CFError(c_void);
pub type CFErrorRef = *mut __CFError;
+pub type CFErrorDomain = CFStringRef;
extern "C" {
- pub fn CFErrorGetTypeID() -> CFTypeID;
+ /*
+ * CFError.h
+ */
+ /* Error domains */
pub static kCFErrorDomainPOSIX: CFStringRef;
pub static kCFErrorDomainOSStatus: CFStringRef;
pub static kCFErrorDomainMach: CFStringRef;
pub static kCFErrorDomainCocoa: CFStringRef;
+ /* Keys for the user info dictionary */
+ pub static kCFErrorLocalizedDescriptionKey: CFStringRef;
+ // pub static kCFErrorLocalizedFailureKey: CFStringRef; // macos(10.13)+
+ pub static kCFErrorLocalizedFailureReasonKey: CFStringRef;
+ pub static kCFErrorLocalizedRecoverySuggestionKey: CFStringRef;
+ pub static kCFErrorDescriptionKey: CFStringRef;
+ pub static kCFErrorUnderlyingErrorKey: CFStringRef;
+ pub static kCFErrorURLKey: CFStringRef;
+ pub static kCFErrorFilePathKey: CFStringRef;
+
+ /* Creating a CFError */
+ pub fn CFErrorCreate(
+ allocator: CFAllocatorRef,
+ domain: CFErrorDomain,
+ code: CFIndex,
+ userInfo: CFDictionaryRef,
+ ) -> CFErrorRef;
+ //pub fn CFErrorCreateWithUserInfoKeysAndValues
+
+ /* Getting Information About an Error */
pub fn CFErrorGetDomain(err: CFErrorRef) -> CFStringRef;
pub fn CFErrorGetCode(err: CFErrorRef) -> CFIndex;
-
+ pub fn CFErrorCopyUserInfo(err: CFErrorRef) -> CFDictionaryRef;
pub fn CFErrorCopyDescription(err: CFErrorRef) -> CFStringRef;
+ pub fn CFErrorCopyFailureReason(err: CFErrorRef) -> CFStringRef;
+ pub fn CFErrorCopyRecoverySuggestion(err: CFErrorRef) -> CFStringRef;
+
+ /* Getting the CFError Type ID */
+ pub fn CFErrorGetTypeID() -> CFTypeID;
}
diff --git a/vendor/core-foundation-sys/src/file_security.rs b/vendor/core-foundation-sys/src/file_security.rs
new file mode 100644
index 000000000..a4ec6112b
--- /dev/null
+++ b/vendor/core-foundation-sys/src/file_security.rs
@@ -0,0 +1,71 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::c_void;
+
+#[cfg(feature = "mac_os_10_8_features")]
+use crate::base::CFOptionFlags;
+use crate::base::{Boolean, CFAllocatorRef, CFTypeID};
+use crate::uuid::CFUUIDRef;
+
+#[repr(C)]
+pub struct __CFFileSecurity(c_void);
+pub type CFFileSecurityRef = *mut __CFFileSecurity;
+
+#[cfg(feature = "mac_os_10_8_features")]
+pub type CFFileSecurityClearOptions = CFOptionFlags;
+#[cfg(feature = "mac_os_10_8_features")]
+pub const kCFFileSecurityClearOwner: CFFileSecurityClearOptions = 1 << 0;
+#[cfg(feature = "mac_os_10_8_features")]
+pub const kCFFileSecurityClearGroup: CFFileSecurityClearOptions = 1 << 1;
+#[cfg(feature = "mac_os_10_8_features")]
+pub const kCFFileSecurityClearMode: CFFileSecurityClearOptions = 1 << 2;
+#[cfg(feature = "mac_os_10_8_features")]
+pub const kCFFileSecurityClearOwnerUUID: CFFileSecurityClearOptions = 1 << 3;
+#[cfg(feature = "mac_os_10_8_features")]
+pub const kCFFileSecurityClearGroupUUID: CFFileSecurityClearOptions = 1 << 4;
+#[cfg(feature = "mac_os_10_8_features")]
+pub const kCFFileSecurityClearAccessControlList: CFFileSecurityClearOptions = 1 << 5;
+
+extern "C" {
+ /*
+ * CFFileSecurity.h
+ */
+ pub fn CFFileSecurityGetTypeID() -> CFTypeID;
+ pub fn CFFileSecurityCreate(allocator: CFAllocatorRef) -> CFFileSecurityRef;
+ pub fn CFFileSecurityCreateCopy(
+ allocator: CFAllocatorRef,
+ fileSec: CFFileSecurityRef,
+ ) -> CFFileSecurityRef;
+ pub fn CFFileSecurityCopyOwnerUUID(
+ fileSec: CFFileSecurityRef,
+ ownerUUID: *mut CFUUIDRef,
+ ) -> Boolean;
+ pub fn CFFileSecuritySetOwnerUUID(fileSec: CFFileSecurityRef, ownerUUID: CFUUIDRef) -> Boolean;
+ pub fn CFFileSecurityCopyGroupUUID(
+ fileSec: CFFileSecurityRef,
+ groupUUID: *mut CFUUIDRef,
+ ) -> Boolean;
+ pub fn CFFileSecuritySetGroupUUID(fileSec: CFFileSecurityRef, groupUUID: CFUUIDRef) -> Boolean;
+ //pub fn CFFileSecurityCopyAccessControlList(fileSec: CFFileSecurityRef, accessControlList: *mut acl_t) -> Boolean;
+ //pub fn CFFileSecuritySetAccessControlList(fileSec: CFFileSecurityRef, accessControlList: acl_t) -> Boolean;
+ //pub fn CFFileSecurityGetOwner(fileSec: CFFileSecurityRef, owner: *mut uid_t) -> Boolean;
+ //pub fn CFFileSecuritySetOwner(fileSec: CFFileSecurityRef, owner: uid_t) -> Boolean;
+ //pub fn CFFileSecurityGetGroup(fileSec: CFFileSecurityRef, group: *mut gid_t) -> Boolean;
+ //pub fn CFFileSecuritySetGroup(fileSec: CFFileSecurityRef, group: gid_t) -> Boolean;
+ //pub fn CFFileSecurityGetMode(fileSec: CFFileSecurityRef, mode: *mut mode_t) -> Boolean;
+ //pub fn CFFileSecuritySetMode(fileSec: CFFileSecurityRef, mode: mode_t) -> Boolean;
+
+ #[cfg(feature = "mac_os_10_8_features")]
+ #[cfg_attr(feature = "mac_os_10_7_support", linkage = "extern_weak")]
+ pub fn CFFileSecurityClearProperties(
+ fileSec: CFFileSecurityRef,
+ clearPropertyMask: CFFileSecurityClearOptions,
+ ) -> Boolean;
+}
diff --git a/vendor/core-foundation-sys/src/filedescriptor.rs b/vendor/core-foundation-sys/src/filedescriptor.rs
index 3f51d1072..271adb716 100644
--- a/vendor/core-foundation-sys/src/filedescriptor.rs
+++ b/vendor/core-foundation-sys/src/filedescriptor.rs
@@ -9,9 +9,9 @@
use std::os::raw::{c_int, c_void};
-use base::{Boolean, CFIndex, CFTypeID, CFOptionFlags, CFAllocatorRef};
-use string::CFStringRef;
-use runloop::CFRunLoopSourceRef;
+use crate::base::{Boolean, CFAllocatorRef, CFIndex, CFOptionFlags, CFTypeID};
+use crate::runloop::CFRunLoopSourceRef;
+use crate::string::CFStringRef;
pub type CFFileDescriptorNativeDescriptor = c_int;
@@ -21,38 +21,60 @@ pub struct __CFFileDescriptor(c_void);
pub type CFFileDescriptorRef = *mut __CFFileDescriptor;
/* Callback Reason Types */
-pub const kCFFileDescriptorReadCallBack: CFOptionFlags = 1 << 0;
+pub const kCFFileDescriptorReadCallBack: CFOptionFlags = 1 << 0;
pub const kCFFileDescriptorWriteCallBack: CFOptionFlags = 1 << 1;
-pub type CFFileDescriptorCallBack = extern "C" fn (f: CFFileDescriptorRef, callBackTypes: CFOptionFlags, info: *mut c_void);
+pub type CFFileDescriptorCallBack =
+ extern "C" fn(f: CFFileDescriptorRef, callBackTypes: CFOptionFlags, info: *mut c_void);
#[repr(C)]
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
pub struct CFFileDescriptorContext {
pub version: CFIndex,
pub info: *mut c_void,
- pub retain: Option<extern "C" fn (info: *const c_void) -> *const c_void>,
- pub release: Option<extern "C" fn (info: *const c_void)>,
- pub copyDescription: Option<extern "C" fn (info: *const c_void) -> CFStringRef>,
+ pub retain: Option<extern "C" fn(info: *const c_void) -> *const c_void>,
+ pub release: Option<extern "C" fn(info: *const c_void)>,
+ pub copyDescription: Option<extern "C" fn(info: *const c_void) -> CFStringRef>,
}
-extern {
+extern "C" {
/*
* CFFileDescriptor.h
*/
- pub fn CFFileDescriptorGetTypeID() -> CFTypeID;
- pub fn CFFileDescriptorCreate(allocator: CFAllocatorRef, fd: CFFileDescriptorNativeDescriptor, closeOnInvalidate: Boolean, callout: CFFileDescriptorCallBack, context: *const CFFileDescriptorContext) -> CFFileDescriptorRef;
+ /* Creating a CFFileDescriptor */
+ pub fn CFFileDescriptorCreate(
+ allocator: CFAllocatorRef,
+ fd: CFFileDescriptorNativeDescriptor,
+ closeOnInvalidate: Boolean,
+ callout: CFFileDescriptorCallBack,
+ context: *const CFFileDescriptorContext,
+ ) -> CFFileDescriptorRef;
- pub fn CFFileDescriptorGetNativeDescriptor(f: CFFileDescriptorRef) -> CFFileDescriptorNativeDescriptor;
+ /* Getting Information About a File Descriptor */
+ pub fn CFFileDescriptorGetNativeDescriptor(
+ f: CFFileDescriptorRef,
+ ) -> CFFileDescriptorNativeDescriptor;
+ pub fn CFFileDescriptorIsValid(f: CFFileDescriptorRef) -> Boolean;
+ pub fn CFFileDescriptorGetContext(
+ f: CFFileDescriptorRef,
+ context: *mut CFFileDescriptorContext,
+ );
- pub fn CFFileDescriptorGetContext(f: CFFileDescriptorRef, context: *mut CFFileDescriptorContext);
+ /* Invalidating a File Descriptor */
+ pub fn CFFileDescriptorInvalidate(f: CFFileDescriptorRef);
+ /* Managing Callbacks */
pub fn CFFileDescriptorEnableCallBacks(f: CFFileDescriptorRef, callBackTypes: CFOptionFlags);
pub fn CFFileDescriptorDisableCallBacks(f: CFFileDescriptorRef, callBackTypes: CFOptionFlags);
- pub fn CFFileDescriptorInvalidate(f: CFFileDescriptorRef);
- pub fn CFFileDescriptorIsValid(f: CFFileDescriptorRef) -> Boolean;
+ /* Creating a Run Loop Source */
+ pub fn CFFileDescriptorCreateRunLoopSource(
+ allocator: CFAllocatorRef,
+ f: CFFileDescriptorRef,
+ order: CFIndex,
+ ) -> CFRunLoopSourceRef;
- pub fn CFFileDescriptorCreateRunLoopSource(allocator: CFAllocatorRef, f: CFFileDescriptorRef, order: CFIndex) -> CFRunLoopSourceRef;
+ /* Getting the CFFileDescriptor Type ID */
+ pub fn CFFileDescriptorGetTypeID() -> CFTypeID;
}
diff --git a/vendor/core-foundation-sys/src/lib.rs b/vendor/core-foundation-sys/src/lib.rs
index 48c08878b..948ce807d 100644
--- a/vendor/core-foundation-sys/src/lib.rs
+++ b/vendor/core-foundation-sys/src/lib.rs
@@ -6,37 +6,69 @@
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![allow(non_snake_case, non_camel_case_types, non_upper_case_globals, improper_ctypes)]
-
-#![cfg_attr(all(feature="mac_os_10_7_support", feature="mac_os_10_8_features"), feature(linkage))] // back-compat requires weak linkage
+#![allow(
+ non_snake_case,
+ non_camel_case_types,
+ non_upper_case_globals,
+ improper_ctypes
+)]
+#![cfg_attr(
+ all(feature = "mac_os_10_7_support", feature = "mac_os_10_8_features"),
+ feature(linkage)
+)] // back-compat requires weak linkage
// Link to CoreFoundation on any Apple device.
//
// We don't use `target_vendor` since that is going to be deprecated:
// https://github.com/rust-lang/lang-team/issues/102
#[cfg_attr(
- any(target_os = "macos", target_os = "ios", target_os = "tvos"),
+ all(
+ any(target_os = "macos", target_os = "ios", target_os = "tvos"),
+ feature = "link"
+ ),
link(name = "CoreFoundation", kind = "framework")
)]
extern "C" {}
pub mod array;
pub mod attributed_string;
+pub mod bag;
pub mod base;
+pub mod binary_heap;
+pub mod bit_vector;
pub mod bundle;
+pub mod calendar;
pub mod characterset;
pub mod data;
pub mod date;
+pub mod date_formatter;
pub mod dictionary;
pub mod error;
+pub mod file_security;
pub mod filedescriptor;
+pub mod locale;
+pub mod mach_port;
pub mod messageport;
+pub mod notification_center;
pub mod number;
+pub mod number_formatter;
+pub mod plugin;
+pub mod preferences;
pub mod propertylist;
pub mod runloop;
pub mod set;
+pub mod socket;
+pub mod stream;
pub mod string;
+pub mod string_tokenizer;
pub mod timezone;
+pub mod tree;
pub mod url;
+pub mod url_enumerator;
+#[cfg(target_os = "macos")]
+pub mod user_notification;
pub mod uuid;
-pub mod mach_port;
+#[cfg(target_os = "macos")]
+pub mod xml_node;
+#[cfg(target_os = "macos")]
+pub mod xml_parser;
diff --git a/vendor/core-foundation-sys/src/locale.rs b/vendor/core-foundation-sys/src/locale.rs
new file mode 100644
index 000000000..f80e5c4a6
--- /dev/null
+++ b/vendor/core-foundation-sys/src/locale.rs
@@ -0,0 +1,146 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use crate::array::CFArrayRef;
+use crate::base::{CFAllocatorRef, CFIndex, CFTypeID, CFTypeRef, LangCode, RegionCode};
+use crate::dictionary::CFDictionaryRef;
+use crate::notification_center::CFNotificationName;
+use crate::string::CFStringRef;
+use std::os::raw::c_void;
+
+#[repr(C)]
+pub struct __CFLocale(c_void);
+pub type CFLocaleRef = *const __CFLocale;
+
+pub type CFLocaleIdentifier = CFStringRef;
+pub type CFLocaleKey = CFStringRef;
+pub type CFCalendarIdentifier = CFStringRef;
+pub type CFLocaleLanguageDirection = CFIndex;
+
+pub const kCFLocaleLanguageDirectionUnknown: CFLocaleLanguageDirection = 0;
+pub const kCFLocaleLanguageDirectionLeftToRight: CFLocaleLanguageDirection = 1;
+pub const kCFLocaleLanguageDirectionRightToLeft: CFLocaleLanguageDirection = 2;
+pub const kCFLocaleLanguageDirectionTopToBottom: CFLocaleLanguageDirection = 3;
+pub const kCFLocaleLanguageDirectionBottomToTop: CFLocaleLanguageDirection = 4;
+
+extern "C" {
+ /*
+ * CFLocale.h
+ */
+
+ /* Locale Change Notification */
+ pub static kCFLocaleCurrentLocaleDidChangeNotification: CFNotificationName;
+
+ /* Locale Property Keys */
+ pub static kCFLocaleIdentifier: CFLocaleKey;
+ pub static kCFLocaleLanguageCode: CFLocaleKey;
+ pub static kCFLocaleCountryCode: CFLocaleKey;
+ pub static kCFLocaleScriptCode: CFLocaleKey;
+ pub static kCFLocaleVariantCode: CFLocaleKey;
+
+ pub static kCFLocaleExemplarCharacterSet: CFLocaleKey;
+ pub static kCFLocaleCalendarIdentifier: CFLocaleKey;
+ pub static kCFLocaleCalendar: CFLocaleKey;
+ pub static kCFLocaleCollationIdentifier: CFLocaleKey;
+ pub static kCFLocaleUsesMetricSystem: CFLocaleKey;
+ pub static kCFLocaleMeasurementSystem: CFLocaleKey;
+ pub static kCFLocaleDecimalSeparator: CFLocaleKey;
+ pub static kCFLocaleGroupingSeparator: CFLocaleKey;
+ pub static kCFLocaleCurrencySymbol: CFLocaleKey;
+ pub static kCFLocaleCurrencyCode: CFLocaleKey;
+ pub static kCFLocaleCollatorIdentifier: CFLocaleKey;
+ pub static kCFLocaleQuotationBeginDelimiterKey: CFLocaleKey;
+ pub static kCFLocaleQuotationEndDelimiterKey: CFLocaleKey;
+ pub static kCFLocaleAlternateQuotationBeginDelimiterKey: CFLocaleKey;
+ pub static kCFLocaleAlternateQuotationEndDelimiterKey: CFLocaleKey;
+
+ /* Locale Calendar Identifiers */
+ pub static kCFGregorianCalendar: CFCalendarIdentifier;
+ pub static kCFBuddhistCalendar: CFCalendarIdentifier;
+ pub static kCFChineseCalendar: CFCalendarIdentifier;
+ pub static kCFHebrewCalendar: CFCalendarIdentifier;
+ pub static kCFIslamicCalendar: CFCalendarIdentifier;
+ pub static kCFIslamicCivilCalendar: CFCalendarIdentifier;
+ pub static kCFJapaneseCalendar: CFCalendarIdentifier;
+ pub static kCFRepublicOfChinaCalendar: CFCalendarIdentifier;
+ pub static kCFPersianCalendar: CFCalendarIdentifier;
+ pub static kCFIndianCalendar: CFCalendarIdentifier;
+ pub static kCFISO8601Calendar: CFCalendarIdentifier;
+ //pub static kCFIslamicTabularCalendar: CFCalendarIdentifier; // macos(10.10)+
+ //pub static kCFIslamicUmmAlQuraCalendar: CFCalendarIdentifier; // macos(10.10)+
+
+ /* Creating a Locale */
+ pub fn CFLocaleCopyCurrent() -> CFLocaleRef;
+ pub fn CFLocaleCreate(
+ allocator: CFAllocatorRef,
+ localeIdentifier: CFLocaleIdentifier,
+ ) -> CFLocaleRef;
+ pub fn CFLocaleCreateCopy(allocator: CFAllocatorRef, locale: CFLocaleRef) -> CFLocaleRef;
+ pub fn CFLocaleGetSystem() -> CFLocaleRef;
+
+ /* Getting System Locale Information */
+ pub fn CFLocaleCopyAvailableLocaleIdentifiers() -> CFArrayRef;
+
+ /* Getting ISO Information */
+ pub fn CFLocaleCopyISOCountryCodes() -> CFArrayRef;
+ pub fn CFLocaleCopyISOLanguageCodes() -> CFArrayRef;
+ pub fn CFLocaleCopyISOCurrencyCodes() -> CFArrayRef;
+ pub fn CFLocaleCopyCommonISOCurrencyCodes() -> CFArrayRef;
+
+ /* Language Preferences */
+ pub fn CFLocaleCopyPreferredLanguages() -> CFArrayRef;
+
+ /* Getting Information About a Locale */
+ pub fn CFLocaleCopyDisplayNameForPropertyValue(
+ displayLocale: CFLocaleRef,
+ key: CFLocaleKey,
+ value: CFStringRef,
+ ) -> CFStringRef;
+ pub fn CFLocaleGetValue(locale: CFLocaleRef, key: CFLocaleKey) -> CFTypeRef;
+ pub fn CFLocaleGetIdentifier(locale: CFLocaleRef) -> CFLocaleIdentifier;
+
+ /* Getting and Creating Locale Identifiers */
+ pub fn CFLocaleCreateCanonicalLocaleIdentifierFromScriptManagerCodes(
+ allocator: CFAllocatorRef,
+ lcode: LangCode,
+ rcode: RegionCode,
+ ) -> CFLocaleIdentifier;
+ pub fn CFLocaleCreateCanonicalLanguageIdentifierFromString(
+ allocator: CFAllocatorRef,
+ localeIdentifier: CFStringRef,
+ ) -> CFLocaleIdentifier;
+ pub fn CFLocaleCreateCanonicalLocaleIdentifierFromString(
+ allocator: CFAllocatorRef,
+ localeIdentifier: CFStringRef,
+ ) -> CFLocaleIdentifier;
+ pub fn CFLocaleCreateComponentsFromLocaleIdentifier(
+ allocator: CFAllocatorRef,
+ localeID: CFLocaleIdentifier,
+ ) -> CFDictionaryRef;
+ pub fn CFLocaleCreateLocaleIdentifierFromComponents(
+ allocator: CFAllocatorRef,
+ dictionary: CFDictionaryRef,
+ ) -> CFLocaleIdentifier;
+ pub fn CFLocaleCreateLocaleIdentifierFromWindowsLocaleCode(
+ allocator: CFAllocatorRef,
+ lcid: u32,
+ ) -> CFLocaleIdentifier;
+ pub fn CFLocaleGetWindowsLocaleCodeFromLocaleIdentifier(
+ localeIdentifier: CFLocaleIdentifier,
+ ) -> u32;
+
+ /* Getting Line and Character Direction for a Language */
+ pub fn CFLocaleGetLanguageCharacterDirection(
+ isoLangCode: CFStringRef,
+ ) -> CFLocaleLanguageDirection;
+ pub fn CFLocaleGetLanguageLineDirection(isoLangCode: CFStringRef) -> CFLocaleLanguageDirection;
+
+ /* Getting the CFLocale Type ID */
+ pub fn CFLocaleGetTypeID() -> CFTypeID;
+}
diff --git a/vendor/core-foundation-sys/src/mach_port.rs b/vendor/core-foundation-sys/src/mach_port.rs
index 2341fd4e7..1f47275de 100644
--- a/vendor/core-foundation-sys/src/mach_port.rs
+++ b/vendor/core-foundation-sys/src/mach_port.rs
@@ -1,20 +1,75 @@
-pub use base::{CFAllocatorRef, CFIndex, CFTypeID};
-use runloop::CFRunLoopSourceRef;
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use crate::base::{mach_port_t, Boolean};
+pub use crate::base::{CFAllocatorRef, CFIndex, CFTypeID};
+use crate::runloop::CFRunLoopSourceRef;
+use crate::string::CFStringRef;
use std::os::raw::c_void;
#[repr(C)]
pub struct __CFMachPort(c_void);
-pub type CFMachPortRef = *const __CFMachPort;
+pub type CFMachPortRef = *mut __CFMachPort;
+
+pub type CFMachPortCallBack =
+ extern "C" fn(port: CFMachPortRef, msg: *mut c_void, size: CFIndex, info: *mut c_void);
+pub type CFMachPortInvalidationCallBack = extern "C" fn(port: CFMachPortRef, info: *mut c_void);
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CFMachPortContext {
+ pub version: CFIndex,
+ pub info: *mut c_void,
+ pub retain: extern "C" fn(info: *const c_void) -> *const c_void,
+ pub release: extern "C" fn(info: *const c_void),
+ pub copyDescription: extern "C" fn(info: *const c_void) -> CFStringRef,
+}
extern "C" {
/*
* CFMachPort.h
*/
+
+ /* Creating a CFMachPort Object */
+ pub fn CFMachPortCreate(
+ allocator: CFAllocatorRef,
+ callout: CFMachPortCallBack,
+ context: *mut CFMachPortContext,
+ shouldFreeInfo: *mut Boolean,
+ ) -> CFMachPortRef;
+ pub fn CFMachPortCreateWithPort(
+ allocator: CFAllocatorRef,
+ portNum: mach_port_t,
+ callout: CFMachPortCallBack,
+ context: *mut CFMachPortContext,
+ shouldFreeInfo: *mut Boolean,
+ ) -> CFMachPortRef;
+
+ /* Configuring a CFMachPort Object */
+ pub fn CFMachPortInvalidate(port: CFMachPortRef);
pub fn CFMachPortCreateRunLoopSource(
allocator: CFAllocatorRef,
port: CFMachPortRef,
order: CFIndex,
) -> CFRunLoopSourceRef;
-
+ pub fn CFMachPortSetInvalidationCallBack(
+ port: CFMachPortRef,
+ callout: CFMachPortInvalidationCallBack,
+ );
+
+ /* Examining a CFMachPort Object */
+ pub fn CFMachPortGetContext(port: CFMachPortRef, context: *mut CFMachPortContext);
+ pub fn CFMachPortGetInvalidationCallBack(port: CFMachPortRef)
+ -> CFMachPortInvalidationCallBack;
+ pub fn CFMachPortGetPort(port: CFMachPortRef) -> mach_port_t;
+ pub fn CFMachPortIsValid(port: CFMachPortRef) -> Boolean;
+
+ /* Getting the CFMachPort Type ID */
pub fn CFMachPortGetTypeID() -> CFTypeID;
}
diff --git a/vendor/core-foundation-sys/src/messageport.rs b/vendor/core-foundation-sys/src/messageport.rs
index e33d9aa4b..4ccdcc8b3 100644
--- a/vendor/core-foundation-sys/src/messageport.rs
+++ b/vendor/core-foundation-sys/src/messageport.rs
@@ -9,71 +9,98 @@
use std::os::raw::c_void;
-use base::{CFAllocatorRef, CFIndex, CFTypeID, Boolean};
-use data::CFDataRef;
-use date::CFTimeInterval;
-use runloop::CFRunLoopSourceRef;
-use string::CFStringRef;
+use crate::base::{Boolean, CFAllocatorRef, CFIndex, CFTypeID, SInt32};
+use crate::data::CFDataRef;
+use crate::date::CFTimeInterval;
+use crate::runloop::CFRunLoopSourceRef;
+use crate::string::CFStringRef;
#[repr(C)]
-#[derive(Copy, Clone)]
-#[derive(Debug)]
+#[derive(Copy, Clone, Debug)]
pub struct CFMessagePortContext {
pub version: CFIndex,
pub info: *mut c_void,
- pub retain: Option<unsafe extern fn(info: *const c_void) -> *const c_void>,
- pub release: Option<unsafe extern fn(info: *const c_void)>,
- pub copyDescription: Option<unsafe extern fn(info: *const c_void)
- -> CFStringRef>,
+ pub retain: Option<unsafe extern "C" fn(info: *const c_void) -> *const c_void>,
+ pub release: Option<unsafe extern "C" fn(info: *const c_void)>,
+ pub copyDescription: Option<unsafe extern "C" fn(info: *const c_void) -> CFStringRef>,
}
pub type CFMessagePortCallBack = Option<
- unsafe extern fn(local: CFMessagePortRef,
- msgid: i32,
- data: CFDataRef,
- info: *mut c_void) -> CFDataRef>;
+ unsafe extern "C" fn(
+ local: CFMessagePortRef,
+ msgid: i32,
+ data: CFDataRef,
+ info: *mut c_void,
+ ) -> CFDataRef,
+>;
-pub type CFMessagePortInvalidationCallBack = Option<
- unsafe extern "C" fn(ms: CFMessagePortRef, info: *mut c_void)>;
+pub type CFMessagePortInvalidationCallBack =
+ Option<unsafe extern "C" fn(ms: CFMessagePortRef, info: *mut c_void)>;
+
+/* CFMessagePortSendRequest Error Codes */
+pub const kCFMessagePortSuccess: SInt32 = 0;
+pub const kCFMessagePortSendTimeout: SInt32 = -1;
+pub const kCFMessagePortReceiveTimeout: SInt32 = -2;
+pub const kCFMessagePortIsInvalid: SInt32 = -3;
+pub const kCFMessagePortTransportError: SInt32 = -4;
+pub const kCFMessagePortBecameInvalidError: SInt32 = -5;
#[repr(C)]
pub struct __CFMessagePort(c_void);
pub type CFMessagePortRef = *mut __CFMessagePort;
-extern {
+extern "C" {
/*
* CFMessagePort.h
*/
- pub fn CFMessagePortGetTypeID() -> CFTypeID;
- pub fn CFMessagePortCreateLocal(allocator: CFAllocatorRef,
- name: CFStringRef,
- callout: CFMessagePortCallBack,
- context: *const CFMessagePortContext,
- shouldFreeInfo: *mut Boolean)
- -> CFMessagePortRef;
- pub fn CFMessagePortCreateRemote(allocator: CFAllocatorRef,
- name: CFStringRef) -> CFMessagePortRef;
- pub fn CFMessagePortIsRemote(ms: CFMessagePortRef) -> Boolean;
- pub fn CFMessagePortGetName(ms: CFMessagePortRef) -> CFStringRef;
- pub fn CFMessagePortSetName(ms: CFMessagePortRef, newName: CFStringRef)
- -> Boolean;
- pub fn CFMessagePortGetContext(ms: CFMessagePortRef,
- context: *mut CFMessagePortContext);
+
+ /* Creating a CFMessagePort Object */
+ pub fn CFMessagePortCreateLocal(
+ allocator: CFAllocatorRef,
+ name: CFStringRef,
+ callout: CFMessagePortCallBack,
+ context: *const CFMessagePortContext,
+ shouldFreeInfo: *mut Boolean,
+ ) -> CFMessagePortRef;
+ pub fn CFMessagePortCreateRemote(
+ allocator: CFAllocatorRef,
+ name: CFStringRef,
+ ) -> CFMessagePortRef;
+
+ /* Configuring a CFMessagePort Object */
+ pub fn CFMessagePortCreateRunLoopSource(
+ allocator: CFAllocatorRef,
+ local: CFMessagePortRef,
+ order: CFIndex,
+ ) -> CFRunLoopSourceRef;
+ pub fn CFMessagePortSetInvalidationCallBack(
+ ms: CFMessagePortRef,
+ callout: CFMessagePortInvalidationCallBack,
+ );
+ pub fn CFMessagePortSetName(ms: CFMessagePortRef, newName: CFStringRef) -> Boolean;
+
+ /* Using a Message Port */
pub fn CFMessagePortInvalidate(ms: CFMessagePortRef);
+ pub fn CFMessagePortSendRequest(
+ remote: CFMessagePortRef,
+ msgid: i32,
+ data: CFDataRef,
+ sendTimeout: CFTimeInterval,
+ rcvTimeout: CFTimeInterval,
+ replyMode: CFStringRef,
+ returnData: *mut CFDataRef,
+ ) -> i32;
+ //pub fn CFMessagePortSetDispatchQueue(ms: CFMessagePortRef, queue: dispatch_queue_t);
+
+ /* Examining a Message Port */
+ pub fn CFMessagePortGetContext(ms: CFMessagePortRef, context: *mut CFMessagePortContext);
+ pub fn CFMessagePortGetInvalidationCallBack(
+ ms: CFMessagePortRef,
+ ) -> CFMessagePortInvalidationCallBack;
+ pub fn CFMessagePortGetName(ms: CFMessagePortRef) -> CFStringRef;
+ pub fn CFMessagePortIsRemote(ms: CFMessagePortRef) -> Boolean;
pub fn CFMessagePortIsValid(ms: CFMessagePortRef) -> Boolean;
- pub fn CFMessagePortGetInvalidationCallBack(ms: CFMessagePortRef)
- -> CFMessagePortInvalidationCallBack;
- pub fn CFMessagePortSetInvalidationCallBack(ms: CFMessagePortRef,
- callout: CFMessagePortInvalidationCallBack);
- pub fn CFMessagePortSendRequest(remote: CFMessagePortRef, msgid: i32,
- data: CFDataRef,
- sendTimeout: CFTimeInterval,
- rcvTimeout: CFTimeInterval,
- replyMode: CFStringRef,
- returnData: *mut CFDataRef) -> i32;
- pub fn CFMessagePortCreateRunLoopSource(allocator: CFAllocatorRef,
- local: CFMessagePortRef,
- order: CFIndex)
- -> CFRunLoopSourceRef;
- // CFMessagePortSetDispatchQueue
+
+ /* Getting the CFMessagePort Type ID */
+ pub fn CFMessagePortGetTypeID() -> CFTypeID;
}
diff --git a/vendor/core-foundation-sys/src/notification_center.rs b/vendor/core-foundation-sys/src/notification_center.rs
new file mode 100644
index 000000000..2ed829233
--- /dev/null
+++ b/vendor/core-foundation-sys/src/notification_center.rs
@@ -0,0 +1,89 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::c_void;
+
+use crate::base::{Boolean, CFIndex, CFOptionFlags, CFTypeID};
+use crate::dictionary::CFDictionaryRef;
+use crate::string::CFStringRef;
+
+#[repr(C)]
+pub struct __CFNotificationCenter(c_void);
+
+pub type CFNotificationCenterRef = *mut __CFNotificationCenter;
+
+pub type CFNotificationName = CFStringRef;
+pub type CFNotificationCallback = extern "C" fn(
+ center: CFNotificationCenterRef,
+ observer: *mut c_void,
+ name: CFNotificationName,
+ object: *const c_void,
+ userInfo: CFDictionaryRef,
+);
+pub type CFNotificationSuspensionBehavior = CFIndex;
+
+pub const CFNotificationSuspensionBehaviorDrop: CFNotificationSuspensionBehavior = 1;
+pub const CFNotificationSuspensionBehaviorCoalesce: CFNotificationSuspensionBehavior = 2;
+pub const CFNotificationSuspensionBehaviorHold: CFNotificationSuspensionBehavior = 3;
+pub const CFNotificationSuspensionBehaviorDeliverImmediately: CFNotificationSuspensionBehavior = 4;
+
+/* Notification Posting Options */
+pub const kCFNotificationDeliverImmediately: CFOptionFlags = 1usize << 0;
+pub const kCFNotificationPostToAllSessions: CFOptionFlags = 1usize << 1;
+
+extern "C" {
+ /*
+ * CFNotificationCenter.h
+ */
+
+ /* Accessing a Notification Center */
+ pub fn CFNotificationCenterGetDarwinNotifyCenter() -> CFNotificationCenterRef;
+ #[cfg(any(target_os = "macos", target_os = "windows"))]
+ pub fn CFNotificationCenterGetDistributedCenter() -> CFNotificationCenterRef;
+ pub fn CFNotificationCenterGetLocalCenter() -> CFNotificationCenterRef;
+
+ /* Posting a Notification */
+ pub fn CFNotificationCenterPostNotification(
+ center: CFNotificationCenterRef,
+ name: CFNotificationName,
+ object: *const c_void,
+ userInfo: CFDictionaryRef,
+ deliverImmediately: Boolean,
+ );
+ pub fn CFNotificationCenterPostNotificationWithOptions(
+ center: CFNotificationCenterRef,
+ name: CFNotificationName,
+ object: *const c_void,
+ userInfo: CFDictionaryRef,
+ options: CFOptionFlags,
+ );
+
+ /* Adding and Removing Observers */
+ pub fn CFNotificationCenterAddObserver(
+ center: CFNotificationCenterRef,
+ observer: *const c_void,
+ callBack: CFNotificationCallback,
+ name: CFStringRef,
+ object: *const c_void,
+ suspensionBehavior: CFNotificationSuspensionBehavior,
+ );
+ pub fn CFNotificationCenterRemoveEveryObserver(
+ center: CFNotificationCenterRef,
+ observer: *const c_void,
+ );
+ pub fn CFNotificationCenterRemoveObserver(
+ center: CFNotificationCenterRef,
+ observer: *const c_void,
+ name: CFNotificationName,
+ object: *const c_void,
+ );
+
+ /* Getting the CFNotificationCenter Type ID */
+ pub fn CFNotificationCenterGetTypeID() -> CFTypeID;
+}
diff --git a/vendor/core-foundation-sys/src/number.rs b/vendor/core-foundation-sys/src/number.rs
index c056a245b..d822d417d 100644
--- a/vendor/core-foundation-sys/src/number.rs
+++ b/vendor/core-foundation-sys/src/number.rs
@@ -9,7 +9,7 @@
use std::os::raw::c_void;
-use base::{CFAllocatorRef, CFTypeID, CFComparisonResult};
+use crate::base::{Boolean, CFAllocatorRef, CFComparisonResult, CFIndex, CFTypeID};
#[repr(C)]
pub struct __CFBoolean(c_void);
@@ -19,23 +19,23 @@ pub type CFBooleanRef = *const __CFBoolean;
pub type CFNumberType = u32;
// members of enum CFNumberType
-pub const kCFNumberSInt8Type: CFNumberType = 1;
-pub const kCFNumberSInt16Type: CFNumberType = 2;
-pub const kCFNumberSInt32Type: CFNumberType = 3;
-pub const kCFNumberSInt64Type: CFNumberType = 4;
-pub const kCFNumberFloat32Type: CFNumberType = 5;
-pub const kCFNumberFloat64Type: CFNumberType = 6;
-pub const kCFNumberCharType: CFNumberType = 7;
-pub const kCFNumberShortType: CFNumberType = 8;
-pub const kCFNumberIntType: CFNumberType = 9;
-pub const kCFNumberLongType: CFNumberType = 10;
-pub const kCFNumberLongLongType: CFNumberType = 11;
-pub const kCFNumberFloatType: CFNumberType = 12;
-pub const kCFNumberDoubleType: CFNumberType = 13;
-pub const kCFNumberCFIndexType: CFNumberType = 14;
+pub const kCFNumberSInt8Type: CFNumberType = 1;
+pub const kCFNumberSInt16Type: CFNumberType = 2;
+pub const kCFNumberSInt32Type: CFNumberType = 3;
+pub const kCFNumberSInt64Type: CFNumberType = 4;
+pub const kCFNumberFloat32Type: CFNumberType = 5;
+pub const kCFNumberFloat64Type: CFNumberType = 6;
+pub const kCFNumberCharType: CFNumberType = 7;
+pub const kCFNumberShortType: CFNumberType = 8;
+pub const kCFNumberIntType: CFNumberType = 9;
+pub const kCFNumberLongType: CFNumberType = 10;
+pub const kCFNumberLongLongType: CFNumberType = 11;
+pub const kCFNumberFloatType: CFNumberType = 12;
+pub const kCFNumberDoubleType: CFNumberType = 13;
+pub const kCFNumberCFIndexType: CFNumberType = 14;
pub const kCFNumberNSIntegerType: CFNumberType = 15;
-pub const kCFNumberCGFloatType: CFNumberType = 16;
-pub const kCFNumberMaxType: CFNumberType = 16;
+pub const kCFNumberCGFloatType: CFNumberType = 16;
+pub const kCFNumberMaxType: CFNumberType = 16;
// This is an enum due to zero-sized types warnings.
// For more details see https://github.com/rust-lang/rust/issues/27303
@@ -43,23 +43,45 @@ pub enum __CFNumber {}
pub type CFNumberRef = *const __CFNumber;
-extern {
+extern "C" {
/*
* CFNumber.h
*/
pub static kCFBooleanTrue: CFBooleanRef;
pub static kCFBooleanFalse: CFBooleanRef;
+ pub static kCFNumberPositiveInfinity: CFNumberRef;
+ pub static kCFNumberNegativeInfinity: CFNumberRef;
+ pub static kCFNumberNaN: CFNumberRef;
- pub fn CFBooleanGetTypeID() -> CFTypeID;
- pub fn CFBooleanGetValue(boolean: CFBooleanRef) -> bool;
+ /* Creating a Number */
+ pub fn CFNumberCreate(
+ allocator: CFAllocatorRef,
+ theType: CFNumberType,
+ valuePtr: *const c_void,
+ ) -> CFNumberRef;
- pub fn CFNumberCreate(allocator: CFAllocatorRef, theType: CFNumberType, valuePtr: *const c_void)
- -> CFNumberRef;
- //fn CFNumberGetByteSize
- pub fn CFNumberGetValue(number: CFNumberRef, theType: CFNumberType, valuePtr: *mut c_void) -> bool;
- pub fn CFNumberCompare(date: CFNumberRef, other: CFNumberRef, context: *mut c_void) -> CFComparisonResult;
- pub fn CFNumberGetTypeID() -> CFTypeID;
+ /* Getting Information About Numbers */
+ pub fn CFNumberGetByteSize(number: CFNumberRef) -> CFIndex;
pub fn CFNumberGetType(number: CFNumberRef) -> CFNumberType;
+ pub fn CFNumberGetValue(
+ number: CFNumberRef,
+ theType: CFNumberType,
+ valuePtr: *mut c_void,
+ ) -> bool;
+ pub fn CFNumberIsFloatType(number: CFNumberRef) -> Boolean;
+
+ /* Comparing Numbers */
+ pub fn CFNumberCompare(
+ date: CFNumberRef,
+ other: CFNumberRef,
+ context: *mut c_void,
+ ) -> CFComparisonResult;
+
+ /* Getting the CFNumber Type ID */
+ pub fn CFNumberGetTypeID() -> CFTypeID;
+
+ pub fn CFBooleanGetValue(boolean: CFBooleanRef) -> bool;
+ pub fn CFBooleanGetTypeID() -> CFTypeID;
}
#[cfg(test)]
diff --git a/vendor/core-foundation-sys/src/number_formatter.rs b/vendor/core-foundation-sys/src/number_formatter.rs
new file mode 100644
index 000000000..cae7b11b0
--- /dev/null
+++ b/vendor/core-foundation-sys/src/number_formatter.rs
@@ -0,0 +1,163 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::{c_double, c_void};
+
+use crate::base::{Boolean, CFAllocatorRef, CFIndex, CFOptionFlags, CFRange, CFTypeID, CFTypeRef};
+use crate::locale::CFLocaleRef;
+use crate::number::{CFNumberRef, CFNumberType};
+use crate::string::CFStringRef;
+
+#[repr(C)]
+pub struct __CFNumberFormatter(c_void);
+
+pub type CFNumberFormatterRef = *mut __CFNumberFormatter;
+
+pub type CFNumberFormatterKey = CFStringRef;
+pub type CFNumberFormatterStyle = CFIndex;
+pub type CFNumberFormatterOptionFlags = CFOptionFlags;
+pub type CFNumberFormatterRoundingMode = CFIndex;
+pub type CFNumberFormatterPadPosition = CFIndex;
+
+/* Number Formatter Styles */
+pub const kCFNumberFormatterNoStyle: CFNumberFormatterStyle = 0;
+pub const kCFNumberFormatterDecimalStyle: CFNumberFormatterStyle = 1;
+pub const kCFNumberFormatterCurrencyStyle: CFNumberFormatterStyle = 2;
+pub const kCFNumberFormatterPercentStyle: CFNumberFormatterStyle = 3;
+pub const kCFNumberFormatterScientificStyle: CFNumberFormatterStyle = 4;
+pub const kCFNumberFormatterSpellOutStyle: CFNumberFormatterStyle = 5;
+//pub const kCFNumberFormatterOrdinalStyle: CFNumberFormatterStyle = 6; // macos(10.11)+
+//pub const kCFNumberFormatterCurrencyISOCodeStyle: CFNumberFormatterStyle = 8; // macos(10.11)+
+//pub const kCFNumberFormatterCurrencyPluralStyle: CFNumberFormatterStyle = 9; // macos(10.11)+
+//pub const kCFNumberFormatterCurrencyAccountingStyle: CFNumberFormatterStyle = 10; // macos(10.11)+
+
+/* Number Format Options */
+pub const kCFNumberFormatterParseIntegersOnly: CFNumberFormatterOptionFlags = 1;
+
+/* CFNumberFormatterRoundingMode */
+pub const kCFNumberFormatterRoundCeiling: CFNumberFormatterRoundingMode = 0;
+pub const kCFNumberFormatterRoundFloor: CFNumberFormatterRoundingMode = 1;
+pub const kCFNumberFormatterRoundDown: CFNumberFormatterRoundingMode = 2;
+pub const kCFNumberFormatterRoundUp: CFNumberFormatterRoundingMode = 3;
+pub const kCFNumberFormatterRoundHalfEven: CFNumberFormatterRoundingMode = 4;
+pub const kCFNumberFormatterRoundHalfDown: CFNumberFormatterRoundingMode = 5;
+pub const kCFNumberFormatterRoundHalfUp: CFNumberFormatterRoundingMode = 6;
+
+/* Padding Positions */
+pub const kCFNumberFormatterPadBeforePrefix: CFNumberFormatterPadPosition = 0;
+pub const kCFNumberFormatterPadAfterPrefix: CFNumberFormatterPadPosition = 1;
+pub const kCFNumberFormatterPadBeforeSuffix: CFNumberFormatterPadPosition = 2;
+pub const kCFNumberFormatterPadAfterSuffix: CFNumberFormatterPadPosition = 3;
+
+extern "C" {
+ /*
+ * CFNumberFormatter.h
+ */
+
+ /* Number Formatter Property Keys */
+ // The values for these keys are all CFType objects.
+ // The specific types for each key are specified above.
+ pub static kCFNumberFormatterCurrencyCode: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterDecimalSeparator: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterCurrencyDecimalSeparator: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterAlwaysShowDecimalSeparator: CFNumberFormatterKey; // CFBoolean
+ pub static kCFNumberFormatterGroupingSeparator: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterUseGroupingSeparator: CFNumberFormatterKey; // CFBoolean
+ pub static kCFNumberFormatterPercentSymbol: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterZeroSymbol: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterNaNSymbol: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterInfinitySymbol: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterMinusSign: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterPlusSign: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterCurrencySymbol: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterExponentSymbol: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterMinIntegerDigits: CFNumberFormatterKey; // CFNumber
+ pub static kCFNumberFormatterMaxIntegerDigits: CFNumberFormatterKey; // CFNumber
+ pub static kCFNumberFormatterMinFractionDigits: CFNumberFormatterKey; // CFNumber
+ pub static kCFNumberFormatterMaxFractionDigits: CFNumberFormatterKey; // CFNumber
+ pub static kCFNumberFormatterGroupingSize: CFNumberFormatterKey; // CFNumber
+ pub static kCFNumberFormatterSecondaryGroupingSize: CFNumberFormatterKey; // CFNumber
+ pub static kCFNumberFormatterRoundingMode: CFNumberFormatterKey; // CFNumber
+ pub static kCFNumberFormatterRoundingIncrement: CFNumberFormatterKey; // CFNumber
+ pub static kCFNumberFormatterFormatWidth: CFNumberFormatterKey; // CFNumber
+ pub static kCFNumberFormatterPaddingPosition: CFNumberFormatterKey; // CFNumber
+ pub static kCFNumberFormatterPaddingCharacter: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterDefaultFormat: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterMultiplier: CFNumberFormatterKey; // CFNumber
+ pub static kCFNumberFormatterPositivePrefix: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterPositiveSuffix: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterNegativePrefix: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterNegativeSuffix: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterPerMillSymbol: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterInternationalCurrencySymbol: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterCurrencyGroupingSeparator: CFNumberFormatterKey; // CFString
+ pub static kCFNumberFormatterIsLenient: CFNumberFormatterKey; // CFBoolean
+ pub static kCFNumberFormatterUseSignificantDigits: CFNumberFormatterKey; // CFBoolean
+ pub static kCFNumberFormatterMinSignificantDigits: CFNumberFormatterKey; // CFNumber
+ pub static kCFNumberFormatterMaxSignificantDigits: CFNumberFormatterKey; // CFNumber
+
+ /* Creating a Number Formatter */
+ pub fn CFNumberFormatterCreate(
+ allocator: CFAllocatorRef,
+ locale: CFLocaleRef,
+ style: CFNumberFormatterStyle,
+ ) -> CFNumberFormatterRef;
+
+ /* Configuring a Number Formatter */
+ pub fn CFNumberFormatterSetFormat(formatter: CFNumberFormatterRef, formatString: CFStringRef);
+ pub fn CFNumberFormatterSetProperty(
+ formatter: CFNumberFormatterRef,
+ key: CFNumberFormatterKey,
+ value: CFTypeRef,
+ );
+
+ /* Formatting Values */
+ pub fn CFNumberFormatterCreateNumberFromString(
+ allocator: CFAllocatorRef,
+ formatter: CFNumberFormatterRef,
+ string: CFStringRef,
+ rangep: *mut CFRange,
+ options: CFOptionFlags,
+ ) -> CFNumberRef;
+ pub fn CFNumberFormatterCreateStringWithNumber(
+ allocator: CFAllocatorRef,
+ formatter: CFNumberFormatterRef,
+ number: CFNumberRef,
+ ) -> CFStringRef;
+ pub fn CFNumberFormatterCreateStringWithValue(
+ allocator: CFAllocatorRef,
+ formatter: CFNumberFormatterRef,
+ numberType: CFNumberType,
+ valuePtr: *const c_void,
+ ) -> CFStringRef;
+ pub fn CFNumberFormatterGetDecimalInfoForCurrencyCode(
+ currencyCode: CFStringRef,
+ defaultFractionDigits: *mut i32,
+ roundingIncrement: *mut c_double,
+ ) -> Boolean;
+ pub fn CFNumberFormatterGetValueFromString(
+ formatter: CFNumberFormatterRef,
+ string: CFStringRef,
+ rangep: *mut CFRange,
+ numberType: CFNumberType,
+ valuePtr: *mut c_void,
+ ) -> Boolean;
+
+ /* Examining a Number Formatter */
+ pub fn CFNumberFormatterCopyProperty(
+ formatter: CFNumberFormatterRef,
+ key: CFNumberFormatterKey,
+ ) -> CFTypeRef;
+ pub fn CFNumberFormatterGetFormat(formatter: CFNumberFormatterRef) -> CFStringRef;
+ pub fn CFNumberFormatterGetLocale(formatter: CFNumberFormatterRef) -> CFLocaleRef;
+ pub fn CFNumberFormatterGetStyle(formatter: CFNumberFormatterRef) -> CFNumberFormatterStyle;
+
+ /* Getting the CFNumberFormatter Type ID */
+ pub fn CFNumberFormatterGetTypeID() -> CFTypeID;
+}
diff --git a/vendor/core-foundation-sys/src/plugin.rs b/vendor/core-foundation-sys/src/plugin.rs
new file mode 100644
index 000000000..fa236777c
--- /dev/null
+++ b/vendor/core-foundation-sys/src/plugin.rs
@@ -0,0 +1,99 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::c_void;
+
+use crate::array::CFArrayRef;
+use crate::base::{Boolean, CFAllocatorRef, CFIndex, CFTypeID};
+use crate::bundle::{CFBundleRef, CFPlugInRef};
+use crate::string::CFStringRef;
+use crate::url::CFURLRef;
+use crate::uuid::CFUUIDRef;
+
+#[repr(C)]
+pub struct __CFPlugInInstance(c_void);
+pub type CFPlugInInstanceRef = *mut __CFPlugInInstance;
+
+pub type CFPlugInDynamicRegisterFunction = extern "C" fn(plugIn: CFPlugInRef);
+pub type CFPlugInUnloadFunction = extern "C" fn(plugIn: CFPlugInRef);
+pub type CFPlugInFactoryFunction =
+ extern "C" fn(allocator: CFAllocatorRef, typeUUID: CFUUIDRef) -> *mut c_void;
+
+pub type CFPlugInInstanceGetInterfaceFunction = extern "C" fn(
+ instance: CFPlugInInstanceRef,
+ interfaceName: CFStringRef,
+ ftbl: *mut *mut c_void,
+) -> Boolean;
+pub type CFPlugInInstanceDeallocateInstanceDataFunction = extern "C" fn(instanceData: *mut c_void);
+
+extern "C" {
+ /*
+ * CFPlugIn.h
+ */
+
+ /* CFPlugIn */
+ /* Information Property List Keys */
+ pub static kCFPlugInDynamicRegistrationKey: CFStringRef;
+ pub static kCFPlugInDynamicRegisterFunctionKey: CFStringRef;
+ pub static kCFPlugInUnloadFunctionKey: CFStringRef;
+ pub static kCFPlugInFactoriesKey: CFStringRef;
+ pub static kCFPlugInTypesKey: CFStringRef;
+
+ /* Creating Plug-ins */
+ pub fn CFPlugInCreate(allocator: CFAllocatorRef, plugInURL: CFURLRef) -> CFPlugInRef;
+ pub fn CFPlugInInstanceCreate(
+ allocator: CFAllocatorRef,
+ factoryUUID: CFUUIDRef,
+ typeUUID: CFUUIDRef,
+ ) -> *mut c_void;
+
+ /* Registration */
+ pub fn CFPlugInRegisterFactoryFunction(
+ factoryUUID: CFUUIDRef,
+ func: CFPlugInFactoryFunction,
+ ) -> Boolean;
+ pub fn CFPlugInRegisterFactoryFunctionByName(
+ CfactoryUUID: CFUUIDRef,
+ plugIn: CFPlugInRef,
+ functionName: CFStringRef,
+ ) -> Boolean;
+ pub fn CFPlugInRegisterPlugInType(factoryUUID: CFUUIDRef, typeUUID: CFUUIDRef) -> Boolean;
+ pub fn CFPlugInUnregisterFactory(factoryUUID: CFUUIDRef) -> Boolean;
+ pub fn CFPlugInUnregisterPlugInType(factoryUUID: CFUUIDRef, typeUUID: CFUUIDRef) -> Boolean;
+
+ /* CFPlugIn Miscellaneous Functions */
+ pub fn CFPlugInAddInstanceForFactory(factoryID: CFUUIDRef);
+ pub fn CFPlugInFindFactoriesForPlugInType(typeUUID: CFUUIDRef) -> CFArrayRef;
+ pub fn CFPlugInFindFactoriesForPlugInTypeInPlugIn(
+ typeUUID: CFUUIDRef,
+ plugIn: CFPlugInRef,
+ ) -> CFArrayRef;
+ pub fn CFPlugInGetBundle(plugIn: CFPlugInRef) -> CFBundleRef;
+ pub fn CFPlugInGetTypeID() -> CFTypeID;
+ pub fn CFPlugInIsLoadOnDemand(plugIn: CFPlugInRef) -> Boolean;
+ pub fn CFPlugInRemoveInstanceForFactory(factoryID: CFUUIDRef);
+ pub fn CFPlugInSetLoadOnDemand(plugIn: CFPlugInRef, flag: Boolean);
+
+ /* CFPlugInInstance: deprecated */
+ pub fn CFPlugInInstanceCreateWithInstanceDataSize(
+ allocator: CFAllocatorRef,
+ instanceDataSize: CFIndex,
+ deallocateInstanceFunction: CFPlugInInstanceDeallocateInstanceDataFunction,
+ factoryName: CFStringRef,
+ getInterfaceFunction: CFPlugInInstanceGetInterfaceFunction,
+ ) -> CFPlugInInstanceRef;
+ pub fn CFPlugInInstanceGetFactoryName(instance: CFPlugInInstanceRef) -> CFStringRef;
+ pub fn CFPlugInInstanceGetInstanceData(instance: CFPlugInInstanceRef) -> *mut c_void;
+ pub fn CFPlugInInstanceGetInterfaceFunctionTable(
+ instance: CFPlugInInstanceRef,
+ interfaceName: CFStringRef,
+ ftbl: *mut *mut c_void,
+ ) -> Boolean;
+ pub fn CFPlugInInstanceGetTypeID() -> CFTypeID;
+}
diff --git a/vendor/core-foundation-sys/src/preferences.rs b/vendor/core-foundation-sys/src/preferences.rs
new file mode 100644
index 000000000..0899938e5
--- /dev/null
+++ b/vendor/core-foundation-sys/src/preferences.rs
@@ -0,0 +1,103 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use crate::array::CFArrayRef;
+use crate::base::{Boolean, CFIndex};
+use crate::dictionary::CFDictionaryRef;
+use crate::propertylist::CFPropertyListRef;
+use crate::string::CFStringRef;
+
+extern "C" {
+ /*
+ * CFPreferences.h
+ */
+ /* Application, Host, and User Keys */
+ pub static kCFPreferencesAnyApplication: CFStringRef;
+ pub static kCFPreferencesCurrentApplication: CFStringRef;
+ pub static kCFPreferencesAnyHost: CFStringRef;
+ pub static kCFPreferencesCurrentHost: CFStringRef;
+ pub static kCFPreferencesAnyUser: CFStringRef;
+ pub static kCFPreferencesCurrentUser: CFStringRef;
+
+ /* Getting Preference Values */
+ pub fn CFPreferencesCopyAppValue(
+ key: CFStringRef,
+ applicationID: CFStringRef,
+ ) -> CFPropertyListRef;
+ pub fn CFPreferencesCopyKeyList(
+ applicationID: CFStringRef,
+ userName: CFStringRef,
+ hostName: CFStringRef,
+ ) -> CFArrayRef;
+ pub fn CFPreferencesCopyMultiple(
+ keysToFetch: CFArrayRef,
+ applicationID: CFStringRef,
+ userName: CFStringRef,
+ hostName: CFStringRef,
+ ) -> CFDictionaryRef;
+ pub fn CFPreferencesCopyValue(
+ key: CFStringRef,
+ applicationID: CFStringRef,
+ userName: CFStringRef,
+ hostName: CFStringRef,
+ ) -> CFPropertyListRef;
+ pub fn CFPreferencesGetAppBooleanValue(
+ key: CFStringRef,
+ applicationID: CFStringRef,
+ keyExistsAndHasValidFormat: *mut Boolean,
+ ) -> Boolean;
+ pub fn CFPreferencesGetAppIntegerValue(
+ key: CFStringRef,
+ applicationID: CFStringRef,
+ keyExistsAndHasValidFormat: *mut Boolean,
+ ) -> CFIndex;
+
+ /* Setting Preference Values */
+ pub fn CFPreferencesSetAppValue(
+ key: CFStringRef,
+ value: CFPropertyListRef,
+ applicationID: CFStringRef,
+ );
+ pub fn CFPreferencesSetMultiple(
+ keysToSet: CFDictionaryRef,
+ keysToRemove: CFArrayRef,
+ applicationID: CFStringRef,
+ userName: CFStringRef,
+ hostName: CFStringRef,
+ );
+ pub fn CFPreferencesSetValue(
+ key: CFStringRef,
+ value: CFPropertyListRef,
+ applicationID: CFStringRef,
+ userName: CFStringRef,
+ hostName: CFStringRef,
+ );
+
+ /* Synchronizing Preferences */
+ pub fn CFPreferencesAppSynchronize(applicationID: CFStringRef) -> Boolean;
+ pub fn CFPreferencesSynchronize(
+ applicationID: CFStringRef,
+ userName: CFStringRef,
+ hostName: CFStringRef,
+ ) -> Boolean;
+
+ /* Adding and Removing Suite Preferences */
+ pub fn CFPreferencesAddSuitePreferencesToApp(applicationID: CFStringRef, suiteID: CFStringRef);
+ pub fn CFPreferencesRemoveSuitePreferencesFromApp(
+ applicationID: CFStringRef,
+ suiteID: CFStringRef,
+ );
+
+ /* Miscellaneous Functions */
+ pub fn CFPreferencesAppValueIsForced(key: CFStringRef, applicationID: CFStringRef) -> Boolean;
+ pub fn CFPreferencesCopyApplicationList(
+ userName: CFStringRef,
+ hostName: CFStringRef,
+ ) -> CFArrayRef; // deprecated since macos 10.9
+}
diff --git a/vendor/core-foundation-sys/src/propertylist.rs b/vendor/core-foundation-sys/src/propertylist.rs
index 574c4d13f..d4ceb1b0c 100644
--- a/vendor/core-foundation-sys/src/propertylist.rs
+++ b/vendor/core-foundation-sys/src/propertylist.rs
@@ -7,9 +7,11 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use base::{CFAllocatorRef, CFIndex, CFOptionFlags, CFTypeRef};
-use data::CFDataRef;
-use error::CFErrorRef;
+use crate::base::{Boolean, CFAllocatorRef, CFIndex, CFOptionFlags, CFTypeRef};
+use crate::data::CFDataRef;
+use crate::error::CFErrorRef;
+use crate::stream::{CFReadStreamRef, CFWriteStreamRef};
+use crate::string::CFStringRef;
pub type CFPropertyListRef = CFTypeRef;
@@ -23,24 +25,80 @@ pub const kCFPropertyListImmutable: CFPropertyListMutabilityOptions = 0;
pub const kCFPropertyListMutableContainers: CFPropertyListMutabilityOptions = 1;
pub const kCFPropertyListMutableContainersAndLeaves: CFPropertyListMutabilityOptions = 2;
+/* Reading and Writing Error Codes */
+pub const kCFPropertyListReadCorruptError: CFIndex = 3840;
+pub const kCFPropertyListReadUnknownVersionError: CFIndex = 3841;
+pub const kCFPropertyListReadStreamError: CFIndex = 3842;
+pub const kCFPropertyListWriteStreamError: CFIndex = 3851;
+
extern "C" {
- // CFPropertyList.h
- //
-
- // fn CFPropertyListCreateDeepCopy
- // fn CFPropertyListIsValid
- pub fn CFPropertyListCreateWithData(allocator: CFAllocatorRef,
- data: CFDataRef,
- options: CFPropertyListMutabilityOptions,
- format: *mut CFPropertyListFormat,
- error: *mut CFErrorRef)
- -> CFPropertyListRef;
- // fn CFPropertyListCreateWithStream
- // fn CFPropertyListWrite
- pub fn CFPropertyListCreateData(allocator: CFAllocatorRef,
- propertyList: CFPropertyListRef,
- format: CFPropertyListFormat,
- options: CFOptionFlags,
- error: *mut CFErrorRef)
- -> CFDataRef;
+ /*
+ * CFPropertyList.h
+ */
+
+ /* Creating a Property List */
+ pub fn CFPropertyListCreateWithData(
+ allocator: CFAllocatorRef,
+ data: CFDataRef,
+ options: CFPropertyListMutabilityOptions,
+ format: *mut CFPropertyListFormat,
+ error: *mut CFErrorRef,
+ ) -> CFPropertyListRef;
+ pub fn CFPropertyListCreateWithStream(
+ allocator: CFAllocatorRef,
+ stream: CFReadStreamRef,
+ streamLength: CFIndex,
+ options: CFOptionFlags,
+ format: *mut CFPropertyListFormat,
+ error: *mut CFErrorRef,
+ ) -> CFPropertyListRef;
+ pub fn CFPropertyListCreateDeepCopy(
+ allocator: CFAllocatorRef,
+ propertyList: CFPropertyListRef,
+ mutabilityOption: CFOptionFlags,
+ ) -> CFPropertyListRef;
+ pub fn CFPropertyListCreateFromXMLData(
+ allocator: CFAllocatorRef,
+ xmlData: CFDataRef,
+ mutabilityOption: CFOptionFlags,
+ errorString: *mut CFStringRef,
+ ) -> CFPropertyListRef; // deprecated
+ pub fn CFPropertyListCreateFromStream(
+ allocator: CFAllocatorRef,
+ stream: CFReadStreamRef,
+ streamLength: CFIndex,
+ mutabilityOption: CFOptionFlags,
+ format: *mut CFPropertyListFormat,
+ errorString: *mut CFStringRef,
+ ) -> CFPropertyListRef; // deprecated
+
+ /* Exporting a Property List */
+ pub fn CFPropertyListCreateData(
+ allocator: CFAllocatorRef,
+ propertyList: CFPropertyListRef,
+ format: CFPropertyListFormat,
+ options: CFOptionFlags,
+ error: *mut CFErrorRef,
+ ) -> CFDataRef;
+ pub fn CFPropertyListWrite(
+ propertyList: CFPropertyListRef,
+ stream: CFWriteStreamRef,
+ format: CFPropertyListFormat,
+ options: CFOptionFlags,
+ error: *mut CFErrorRef,
+ ) -> CFIndex;
+ pub fn CFPropertyListCreateXMLData(
+ allocator: CFAllocatorRef,
+ propertyList: CFPropertyListRef,
+ ) -> CFDataRef; // deprecated
+ pub fn CFPropertyListWriteToStream(
+ propertyList: CFPropertyListRef,
+ stream: CFWriteStreamRef,
+ format: CFPropertyListFormat,
+ errorString: *mut CFStringRef,
+ ) -> CFIndex;
+
+ /* Validating a Property List */
+ pub fn CFPropertyListIsValid(plist: CFPropertyListRef, format: CFPropertyListFormat)
+ -> Boolean;
}
diff --git a/vendor/core-foundation-sys/src/runloop.rs b/vendor/core-foundation-sys/src/runloop.rs
index 53035a2e7..5d5fda7a0 100644
--- a/vendor/core-foundation-sys/src/runloop.rs
+++ b/vendor/core-foundation-sys/src/runloop.rs
@@ -9,10 +9,12 @@
use std::os::raw::c_void;
-use array::CFArrayRef;
-use base::{Boolean, CFIndex, CFTypeID, CFAllocatorRef, CFOptionFlags, CFHashCode, mach_port_t};
-use date::{CFAbsoluteTime, CFTimeInterval};
-use string::CFStringRef;
+use crate::array::CFArrayRef;
+use crate::base::{
+ mach_port_t, Boolean, CFAllocatorRef, CFHashCode, CFIndex, CFOptionFlags, CFTypeID,
+};
+use crate::date::{CFAbsoluteTime, CFTimeInterval};
+use crate::string::CFStringRef;
#[repr(C)]
pub struct __CFRunLoop(c_void);
@@ -30,135 +32,225 @@ pub struct __CFRunLoopObserver(c_void);
pub type CFRunLoopObserverRef = *mut __CFRunLoopObserver;
// Reasons for CFRunLoopRunInMode() to Return
-pub const kCFRunLoopRunFinished: i32 = 1;
-pub const kCFRunLoopRunStopped: i32 = 2;
-pub const kCFRunLoopRunTimedOut: i32 = 3;
+pub const kCFRunLoopRunFinished: i32 = 1;
+pub const kCFRunLoopRunStopped: i32 = 2;
+pub const kCFRunLoopRunTimedOut: i32 = 3;
pub const kCFRunLoopRunHandledSource: i32 = 4;
// Run Loop Observer Activities
//typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
pub type CFRunLoopActivity = CFOptionFlags;
-pub const kCFRunLoopEntry: CFOptionFlags = 1 << 0;
-pub const kCFRunLoopBeforeTimers: CFOptionFlags = 1 << 1;
+pub const kCFRunLoopEntry: CFOptionFlags = 1 << 0;
+pub const kCFRunLoopBeforeTimers: CFOptionFlags = 1 << 1;
pub const kCFRunLoopBeforeSources: CFOptionFlags = 1 << 2;
pub const kCFRunLoopBeforeWaiting: CFOptionFlags = 1 << 5;
-pub const kCFRunLoopAfterWaiting: CFOptionFlags = 1 << 6;
-pub const kCFRunLoopExit: CFOptionFlags = 1 << 7;
+pub const kCFRunLoopAfterWaiting: CFOptionFlags = 1 << 6;
+pub const kCFRunLoopExit: CFOptionFlags = 1 << 7;
pub const kCFRunLoopAllActivities: CFOptionFlags = 0x0FFFFFFF;
#[repr(C)]
+#[derive(Debug, Clone, Copy)]
pub struct CFRunLoopSourceContext {
pub version: CFIndex,
pub info: *mut c_void,
- pub retain: Option<extern "C" fn (info: *const c_void) -> *const c_void>,
- pub release: Option<extern "C" fn (info: *const c_void)>,
- pub copyDescription: Option<extern "C" fn (info: *const c_void) -> CFStringRef>,
- pub equal: Option<extern "C" fn (info1: *const c_void, info2: *const c_void) -> Boolean>,
- pub hash: Option<extern "C" fn (info: *const c_void) -> CFHashCode>,
- pub schedule: Option<extern "C" fn (info: *const c_void, rl: CFRunLoopRef, mode: CFStringRef)>,
- pub cancel: Option<extern "C" fn (info: *const c_void, rl: CFRunLoopRef, mode: CFStringRef)>,
- pub perform: extern "C" fn (info: *const c_void),
+ pub retain: Option<extern "C" fn(info: *const c_void) -> *const c_void>,
+ pub release: Option<extern "C" fn(info: *const c_void)>,
+ pub copyDescription: Option<extern "C" fn(info: *const c_void) -> CFStringRef>,
+ pub equal: Option<extern "C" fn(info1: *const c_void, info2: *const c_void) -> Boolean>,
+ pub hash: Option<extern "C" fn(info: *const c_void) -> CFHashCode>,
+ pub schedule: Option<extern "C" fn(info: *const c_void, rl: CFRunLoopRef, mode: CFStringRef)>,
+ pub cancel: Option<extern "C" fn(info: *const c_void, rl: CFRunLoopRef, mode: CFStringRef)>,
+ pub perform: extern "C" fn(info: *const c_void),
}
#[repr(C)]
+#[derive(Debug, Clone, Copy)]
pub struct CFRunLoopSourceContext1 {
pub version: CFIndex,
pub info: *mut c_void,
- pub retain: Option<extern "C" fn (info: *const c_void) -> *const c_void>,
- pub release: Option<extern "C" fn (info: *const c_void)>,
- pub copyDescription: Option<extern "C" fn (info: *const c_void) -> CFStringRef>,
- pub equal: Option<extern "C" fn (info1: *const c_void, info2: *const c_void) -> Boolean>,
- pub hash: Option<extern "C" fn (info: *const c_void) -> CFHashCode>,
- // note that the following two fields are platform dependent in the C header, the ones here are for macOS
- pub getPort: extern "C" fn (info: *mut c_void) -> mach_port_t,
- pub perform: extern "C" fn (msg: *mut c_void, size: CFIndex, allocator: CFAllocatorRef, info: *mut c_void) -> *mut c_void,
+ pub retain: Option<extern "C" fn(info: *const c_void) -> *const c_void>,
+ pub release: Option<extern "C" fn(info: *const c_void)>,
+ pub copyDescription: Option<extern "C" fn(info: *const c_void) -> CFStringRef>,
+ pub equal: Option<extern "C" fn(info1: *const c_void, info2: *const c_void) -> Boolean>,
+ pub hash: Option<extern "C" fn(info: *const c_void) -> CFHashCode>,
+
+ #[cfg(any(target_os = "macos", target_os = "ios"))]
+ pub getPort: extern "C" fn(info: *mut c_void) -> mach_port_t,
+ #[cfg(any(target_os = "macos", target_os = "ios"))]
+ pub perform: extern "C" fn(
+ msg: *mut c_void,
+ size: CFIndex,
+ allocator: CFAllocatorRef,
+ info: *mut c_void,
+ ) -> *mut c_void,
+
+ #[cfg(not(any(target_os = "macos", target_os = "ios")))]
+ pub getPort: extern "C" fn(info: *mut c_void) -> *mut c_void,
+ #[cfg(not(any(target_os = "macos", target_os = "ios")))]
+ pub perform: extern "C" fn(info: *mut c_void) -> *mut c_void,
}
#[repr(C)]
+#[derive(Debug, Clone, Copy)]
pub struct CFRunLoopObserverContext {
pub version: CFIndex,
pub info: *mut c_void,
- pub retain: Option<extern "C" fn (info: *const c_void) -> *const c_void>,
- pub release: Option<extern "C" fn (info: *const c_void)>,
- pub copyDescription: Option<extern "C" fn (info: *const c_void) -> CFStringRef>,
+ pub retain: Option<extern "C" fn(info: *const c_void) -> *const c_void>,
+ pub release: Option<extern "C" fn(info: *const c_void)>,
+ pub copyDescription: Option<extern "C" fn(info: *const c_void) -> CFStringRef>,
}
-pub type CFRunLoopObserverCallBack = extern "C" fn (observer: CFRunLoopObserverRef, activity: CFRunLoopActivity, info: *mut c_void);
+pub type CFRunLoopObserverCallBack =
+ extern "C" fn(observer: CFRunLoopObserverRef, activity: CFRunLoopActivity, info: *mut c_void);
#[repr(C)]
+#[derive(Clone, Copy, Debug)]
pub struct CFRunLoopTimerContext {
pub version: CFIndex,
pub info: *mut c_void,
- pub retain: Option<extern "C" fn (info: *const c_void) -> *const c_void>,
- pub release: Option<extern "C" fn (info: *const c_void)>,
- pub copyDescription: Option<extern "C" fn (info: *const c_void) -> CFStringRef>,
+ pub retain: Option<extern "C" fn(info: *const c_void) -> *const c_void>,
+ pub release: Option<extern "C" fn(info: *const c_void)>,
+ pub copyDescription: Option<extern "C" fn(info: *const c_void) -> CFStringRef>,
}
-pub type CFRunLoopTimerCallBack = extern "C" fn (timer: CFRunLoopTimerRef, info: *mut c_void);
+pub type CFRunLoopTimerCallBack = extern "C" fn(timer: CFRunLoopTimerRef, info: *mut c_void);
#[repr(C)]
pub struct __CFRunLoopTimer(c_void);
pub type CFRunLoopTimerRef = *mut __CFRunLoopTimer;
-extern {
+extern "C" {
/*
* CFRunLoop.h
*/
+
pub static kCFRunLoopDefaultMode: CFStringRef;
pub static kCFRunLoopCommonModes: CFStringRef;
- pub fn CFRunLoopGetTypeID() -> CFTypeID;
+
+ /* CFRunLoop */
+ /* Getting a Run Loop */
pub fn CFRunLoopGetCurrent() -> CFRunLoopRef;
pub fn CFRunLoopGetMain() -> CFRunLoopRef;
- pub fn CFRunLoopCopyCurrentMode(rl: CFRunLoopRef) -> CFStringRef;
- pub fn CFRunLoopCopyAllModes(rl: CFRunLoopRef) -> CFArrayRef;
- pub fn CFRunLoopAddCommonMode(rl: CFRunLoopRef, mode: CFStringRef);
- pub fn CFRunLoopGetNextTimerFireDate(rl: CFRunLoopRef, mode: CFStringRef) -> CFAbsoluteTime;
+
+ /* Starting and Stopping a Run Loop */
pub fn CFRunLoopRun();
- pub fn CFRunLoopRunInMode(mode: CFStringRef, seconds: CFTimeInterval, returnAfterSourceHandled: Boolean) -> i32;
- pub fn CFRunLoopIsWaiting(rl: CFRunLoopRef) -> Boolean;
+ pub fn CFRunLoopRunInMode(
+ mode: CFStringRef,
+ seconds: CFTimeInterval,
+ returnAfterSourceHandled: Boolean,
+ ) -> i32;
pub fn CFRunLoopWakeUp(rl: CFRunLoopRef);
pub fn CFRunLoopStop(rl: CFRunLoopRef);
- // fn CFRunLoopPerformBlock(rl: CFRunLoopRef, mode: CFTypeRef, block: void (^)(void));
- pub fn CFRunLoopContainsSource(rl: CFRunLoopRef, source: CFRunLoopSourceRef, mode: CFStringRef) -> Boolean;
+ pub fn CFRunLoopIsWaiting(rl: CFRunLoopRef) -> Boolean;
+
+ /* Managing Sources */
pub fn CFRunLoopAddSource(rl: CFRunLoopRef, source: CFRunLoopSourceRef, mode: CFStringRef);
+ pub fn CFRunLoopContainsSource(
+ rl: CFRunLoopRef,
+ source: CFRunLoopSourceRef,
+ mode: CFStringRef,
+ ) -> Boolean;
pub fn CFRunLoopRemoveSource(rl: CFRunLoopRef, source: CFRunLoopSourceRef, mode: CFStringRef);
- pub fn CFRunLoopContainsObserver(rl: CFRunLoopRef, observer: CFRunLoopObserverRef, mode: CFStringRef) -> Boolean;
- pub fn CFRunLoopAddObserver(rl: CFRunLoopRef, observer: CFRunLoopObserverRef, mode: CFStringRef);
- pub fn CFRunLoopRemoveObserver(rl: CFRunLoopRef, observer: CFRunLoopObserverRef, mode: CFStringRef);
- pub fn CFRunLoopContainsTimer(rl: CFRunLoopRef, timer: CFRunLoopTimerRef, mode: CFStringRef) -> Boolean;
+
+ /* Managing Observers */
+ pub fn CFRunLoopAddObserver(
+ rl: CFRunLoopRef,
+ observer: CFRunLoopObserverRef,
+ mode: CFStringRef,
+ );
+ pub fn CFRunLoopContainsObserver(
+ rl: CFRunLoopRef,
+ observer: CFRunLoopObserverRef,
+ mode: CFStringRef,
+ ) -> Boolean;
+ pub fn CFRunLoopRemoveObserver(
+ rl: CFRunLoopRef,
+ observer: CFRunLoopObserverRef,
+ mode: CFStringRef,
+ );
+
+ /* Managing Run Loop Modes */
+ pub fn CFRunLoopAddCommonMode(rl: CFRunLoopRef, mode: CFStringRef);
+ pub fn CFRunLoopCopyAllModes(rl: CFRunLoopRef) -> CFArrayRef;
+ pub fn CFRunLoopCopyCurrentMode(rl: CFRunLoopRef) -> CFStringRef;
+
+ /* Managing Timers */
pub fn CFRunLoopAddTimer(rl: CFRunLoopRef, timer: CFRunLoopTimerRef, mode: CFStringRef);
+ pub fn CFRunLoopGetNextTimerFireDate(rl: CFRunLoopRef, mode: CFStringRef) -> CFAbsoluteTime;
pub fn CFRunLoopRemoveTimer(rl: CFRunLoopRef, timer: CFRunLoopTimerRef, mode: CFStringRef);
+ pub fn CFRunLoopContainsTimer(
+ rl: CFRunLoopRef,
+ timer: CFRunLoopTimerRef,
+ mode: CFStringRef,
+ ) -> Boolean;
- pub fn CFRunLoopSourceGetTypeID() -> CFTypeID;
- pub fn CFRunLoopSourceCreate(allocator: CFAllocatorRef, order: CFIndex, context: *mut CFRunLoopSourceContext) -> CFRunLoopSourceRef;
+ /* Scheduling Blocks */
+ // fn CFRunLoopPerformBlock(rl: CFRunLoopRef, mode: CFTypeRef, block: void (^)(void));
+
+ /* Getting the CFRunLoop Type ID */
+ pub fn CFRunLoopGetTypeID() -> CFTypeID;
+
+ /* CFRunLoopSource */
+ /* CFRunLoopSource Miscellaneous Functions */
+ pub fn CFRunLoopSourceCreate(
+ allocator: CFAllocatorRef,
+ order: CFIndex,
+ context: *mut CFRunLoopSourceContext,
+ ) -> CFRunLoopSourceRef;
+ pub fn CFRunLoopSourceGetContext(
+ source: CFRunLoopSourceRef,
+ context: *mut CFRunLoopSourceContext,
+ );
pub fn CFRunLoopSourceGetOrder(source: CFRunLoopSourceRef) -> CFIndex;
+ pub fn CFRunLoopSourceGetTypeID() -> CFTypeID;
pub fn CFRunLoopSourceInvalidate(source: CFRunLoopSourceRef);
pub fn CFRunLoopSourceIsValid(source: CFRunLoopSourceRef) -> Boolean;
- pub fn CFRunLoopSourceGetContext(source: CFRunLoopSourceRef, context: *mut CFRunLoopSourceContext);
pub fn CFRunLoopSourceSignal(source: CFRunLoopSourceRef);
- pub fn CFRunLoopObserverGetTypeID() -> CFTypeID;
- pub fn CFRunLoopObserverCreate(allocator: CFAllocatorRef, activities: CFOptionFlags, repeats: Boolean, order: CFIndex, callout: CFRunLoopObserverCallBack, context: *mut CFRunLoopObserverContext) -> CFRunLoopObserverRef;
+ /* CFRunLoopObserver */
+ /* CFRunLoopObserver Miscellaneous Functions */
// fn CFRunLoopObserverCreateWithHandler(allocator: CFAllocatorRef, activities: CFOptionFlags, repeats: Boolean, order: CFIndex, block: void (^) (CFRunLoopObserverRef observer, CFRunLoopActivity activity)) -> CFRunLoopObserverRef;
- pub fn CFRunLoopObserverGetActivities(observer: CFRunLoopObserverRef) -> CFOptionFlags;
+ pub fn CFRunLoopObserverCreate(
+ allocator: CFAllocatorRef,
+ activities: CFOptionFlags,
+ repeats: Boolean,
+ order: CFIndex,
+ callout: CFRunLoopObserverCallBack,
+ context: *mut CFRunLoopObserverContext,
+ ) -> CFRunLoopObserverRef;
pub fn CFRunLoopObserverDoesRepeat(observer: CFRunLoopObserverRef) -> Boolean;
+ pub fn CFRunLoopObserverGetActivities(observer: CFRunLoopObserverRef) -> CFOptionFlags;
+ pub fn CFRunLoopObserverGetContext(
+ observer: CFRunLoopObserverRef,
+ context: *mut CFRunLoopObserverContext,
+ );
pub fn CFRunLoopObserverGetOrder(observer: CFRunLoopObserverRef) -> CFIndex;
+ pub fn CFRunLoopObserverGetTypeID() -> CFTypeID;
pub fn CFRunLoopObserverInvalidate(observer: CFRunLoopObserverRef);
pub fn CFRunLoopObserverIsValid(observer: CFRunLoopObserverRef) -> Boolean;
- pub fn CFRunLoopObserverGetContext(observer: CFRunLoopObserverRef, context: *mut CFRunLoopObserverContext);
- pub fn CFRunLoopTimerGetTypeID() -> CFTypeID;
- pub fn CFRunLoopTimerCreate(allocator: CFAllocatorRef, fireDate: CFAbsoluteTime, interval: CFTimeInterval, flags: CFOptionFlags, order: CFIndex, callout: CFRunLoopTimerCallBack, context: *mut CFRunLoopTimerContext) -> CFRunLoopTimerRef;
+ /* CFRunLoopTimer */
+ /* CFRunLoopTimer Miscellaneous Functions */
// fn CFRunLoopTimerCreateWithHandler(allocator: CFAllocatorRef, fireDate: CFAbsoluteTime, interval: CFTimeInterval, flags: CFOptionFlags, order: CFIndex, block: void (^) (CFRunLoopTimerRef timer)) -> CFRunLoopTimerRef;
- pub fn CFRunLoopTimerGetNextFireDate(timer: CFRunLoopTimerRef) -> CFAbsoluteTime;
- pub fn CFRunLoopTimerSetNextFireDate(timer: CFRunLoopTimerRef, fireDate: CFAbsoluteTime);
- pub fn CFRunLoopTimerGetInterval(timer: CFRunLoopTimerRef) -> CFTimeInterval;
+ pub fn CFRunLoopTimerCreate(
+ allocator: CFAllocatorRef,
+ fireDate: CFAbsoluteTime,
+ interval: CFTimeInterval,
+ flags: CFOptionFlags,
+ order: CFIndex,
+ callout: CFRunLoopTimerCallBack,
+ context: *mut CFRunLoopTimerContext,
+ ) -> CFRunLoopTimerRef;
pub fn CFRunLoopTimerDoesRepeat(timer: CFRunLoopTimerRef) -> Boolean;
+ pub fn CFRunLoopTimerGetContext(timer: CFRunLoopTimerRef, context: *mut CFRunLoopTimerContext);
+ pub fn CFRunLoopTimerGetInterval(timer: CFRunLoopTimerRef) -> CFTimeInterval;
+ pub fn CFRunLoopTimerGetNextFireDate(timer: CFRunLoopTimerRef) -> CFAbsoluteTime;
pub fn CFRunLoopTimerGetOrder(timer: CFRunLoopTimerRef) -> CFIndex;
+ pub fn CFRunLoopTimerGetTypeID() -> CFTypeID;
pub fn CFRunLoopTimerInvalidate(timer: CFRunLoopTimerRef);
pub fn CFRunLoopTimerIsValid(timer: CFRunLoopTimerRef) -> Boolean;
- pub fn CFRunLoopTimerGetContext(timer: CFRunLoopTimerRef, context: *mut CFRunLoopTimerContext);
- pub fn CFRunLoopTimerGetTolerance(timer: CFRunLoopTimerRef) -> CFTimeInterval;
- pub fn CFRunLoopTimerSetTolerance(timer: CFRunLoopTimerRef, tolerance: CFTimeInterval);
+ pub fn CFRunLoopTimerSetNextFireDate(timer: CFRunLoopTimerRef, fireDate: CFAbsoluteTime);
+ pub fn CFRunLoopTimerGetTolerance(timer: CFRunLoopTimerRef) -> CFTimeInterval; //macos(10.9)+
+ pub fn CFRunLoopTimerSetTolerance(timer: CFRunLoopTimerRef, tolerance: CFTimeInterval); //macos(10.9)+
}
diff --git a/vendor/core-foundation-sys/src/set.rs b/vendor/core-foundation-sys/src/set.rs
index a5cc1b16f..8141c5999 100644
--- a/vendor/core-foundation-sys/src/set.rs
+++ b/vendor/core-foundation-sys/src/set.rs
@@ -9,15 +9,17 @@
use std::os::raw::c_void;
-use base::{CFAllocatorRef, CFIndex, CFTypeID, Boolean};
+use crate::base::{Boolean, CFAllocatorRef, CFHashCode, CFIndex, CFTypeID};
+use crate::string::CFStringRef;
-pub type CFSetApplierFunction = extern "C" fn (value: *const c_void,
- context: *const c_void);
-pub type CFSetRetainCallBack = *const u8;
-pub type CFSetReleaseCallBack = *const u8;
-pub type CFSetCopyDescriptionCallBack = *const u8;
-pub type CFSetEqualCallBack = *const u8;
-pub type CFSetHashCallBack = *const u8;
+pub type CFSetApplierFunction = extern "C" fn(value: *const c_void, context: *const c_void);
+pub type CFSetRetainCallBack =
+ extern "C" fn(allocator: CFAllocatorRef, value: *const c_void) -> *const c_void;
+pub type CFSetReleaseCallBack = extern "C" fn(allocator: CFAllocatorRef, value: *const c_void);
+pub type CFSetCopyDescriptionCallBack = extern "C" fn(value: *const c_void) -> CFStringRef;
+pub type CFSetEqualCallBack =
+ extern "C" fn(value1: *const c_void, value2: *const c_void) -> Boolean;
+pub type CFSetHashCallBack = extern "C" fn(value: *const c_void) -> CFHashCode;
#[repr(C)]
#[derive(Clone, Copy)]
@@ -34,17 +36,24 @@ pub struct CFSetCallBacks {
pub struct __CFSet(c_void);
pub type CFSetRef = *const __CFSet;
+pub type CFMutableSetRef = *mut __CFSet;
-extern {
+extern "C" {
/*
* CFSet.h
*/
pub static kCFTypeSetCallBacks: CFSetCallBacks;
+ pub static kCFCopyStringSetCallBacks: CFSetCallBacks;
+ /* CFSet */
/* Creating Sets */
- pub fn CFSetCreate(allocator: CFAllocatorRef, values: *const *const c_void, numValues: CFIndex,
- callBacks: *const CFSetCallBacks) -> CFSetRef;
+ pub fn CFSetCreate(
+ allocator: CFAllocatorRef,
+ values: *const *const c_void,
+ numValues: CFIndex,
+ callBacks: *const CFSetCallBacks,
+ ) -> CFSetRef;
pub fn CFSetCreateCopy(allocator: CFAllocatorRef, theSet: CFSetRef) -> CFSetRef;
/* Examining a Set */
@@ -52,15 +61,38 @@ extern {
pub fn CFSetGetCount(theSet: CFSetRef) -> CFIndex;
pub fn CFSetGetCountOfValue(theSet: CFSetRef, value: *const c_void) -> CFIndex;
pub fn CFSetGetValue(theSet: CFSetRef, value: *const c_void) -> *const c_void;
- pub fn CFSetGetValueIfPresent(theSet: CFSetRef, candidate: *const c_void, value: *mut *const c_void) -> Boolean;
+ pub fn CFSetGetValueIfPresent(
+ theSet: CFSetRef,
+ candidate: *const c_void,
+ value: *mut *const c_void,
+ ) -> Boolean;
pub fn CFSetGetValues(theSet: CFSetRef, values: *mut *const c_void);
/* Applying a Function to Set Members */
- pub fn CFSetApplyFunction(theSet: CFSetRef,
- applier: CFSetApplierFunction,
- context: *const c_void);
+ pub fn CFSetApplyFunction(
+ theSet: CFSetRef,
+ applier: CFSetApplierFunction,
+ context: *const c_void,
+ );
/* Getting the CFSet Type ID */
pub fn CFSetGetTypeID() -> CFTypeID;
-}
+ /* CFMutableSet */
+ /* CFMutableSet Miscellaneous Functions */
+ pub fn CFSetAddValue(theSet: CFMutableSetRef, value: *const c_void);
+ pub fn CFSetCreateMutable(
+ allocator: CFAllocatorRef,
+ capacity: CFIndex,
+ callBacks: *const CFSetCallBacks,
+ ) -> CFMutableSetRef;
+ pub fn CFSetCreateMutableCopy(
+ allocator: CFAllocatorRef,
+ capacity: CFIndex,
+ theSet: CFSetRef,
+ ) -> CFMutableSetRef;
+ pub fn CFSetRemoveAllValues(theSet: CFMutableSetRef);
+ pub fn CFSetRemoveValue(theSet: CFMutableSetRef, value: *const c_void);
+ pub fn CFSetReplaceValue(theSet: CFMutableSetRef, value: *const c_void);
+ pub fn CFSetSetValue(theSet: CFMutableSetRef, value: *const c_void);
+}
diff --git a/vendor/core-foundation-sys/src/socket.rs b/vendor/core-foundation-sys/src/socket.rs
new file mode 100644
index 000000000..6fb70a108
--- /dev/null
+++ b/vendor/core-foundation-sys/src/socket.rs
@@ -0,0 +1,188 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::c_void;
+
+use crate::base::{Boolean, CFAllocatorRef, CFIndex, CFOptionFlags, CFTypeID, SInt32, UInt16};
+use crate::data::CFDataRef;
+use crate::date::CFTimeInterval;
+use crate::propertylist::CFPropertyListRef;
+use crate::runloop::CFRunLoopSourceRef;
+use crate::string::CFStringRef;
+
+#[repr(C)]
+pub struct __CFSocket(c_void);
+
+pub type CFSocketRef = *mut __CFSocket;
+
+pub type CFSocketError = CFIndex;
+pub type CFSocketCallBackType = CFOptionFlags;
+pub type CFSocketCallBack = extern "C" fn(
+ s: CFSocketRef,
+ _type: CFSocketCallBackType,
+ address: CFDataRef,
+ cdata: *const c_void,
+ info: *mut c_void,
+);
+#[cfg(not(target_os = "windows"))]
+pub type CFSocketNativeHandle = std::os::raw::c_int;
+#[cfg(target_os = "windows")]
+pub type CFSocketNativeHandle = std::os::raw::c_ulong;
+
+pub const kCFSocketSuccess: CFSocketError = 0;
+pub const kCFSocketError: CFSocketError = -1;
+pub const kCFSocketTimeout: CFSocketError = -2;
+
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+pub struct CFSocketSignature {
+ pub protocolFamily: SInt32,
+ pub socketType: SInt32,
+ pub protocol: SInt32,
+ pub address: CFDataRef,
+}
+
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+pub struct CFSocketContext {
+ pub version: CFIndex,
+ pub info: *mut c_void,
+ pub retain: extern "C" fn(info: *const c_void) -> *const c_void,
+ pub release: extern "C" fn(info: *const c_void),
+ pub copyDescription: extern "C" fn(info: *const c_void) -> CFStringRef,
+}
+
+pub const kCFSocketNoCallBack: CFSocketError = 0;
+pub const kCFSocketReadCallBack: CFSocketError = 1;
+pub const kCFSocketAcceptCallBack: CFSocketError = 2;
+pub const kCFSocketDataCallBack: CFSocketError = 3;
+pub const kCFSocketConnectCallBack: CFSocketError = 4;
+pub const kCFSocketWriteCallBack: CFSocketError = 8;
+
+pub const kCFSocketAutomaticallyReenableReadCallBack: CFOptionFlags = 1;
+pub const kCFSocketAutomaticallyReenableAcceptCallBack: CFOptionFlags = 2;
+pub const kCFSocketAutomaticallyReenableDataCallBack: CFOptionFlags = 3;
+pub const kCFSocketAutomaticallyReenableWriteCallBack: CFOptionFlags = 8;
+pub const kCFSocketLeaveErrors: CFOptionFlags = 64;
+pub const kCFSocketCloseOnInvalidate: CFOptionFlags = 128;
+
+extern "C" {
+ /*
+ * CFSocket.h
+ */
+
+ /* CFSocket Name Server Keys: Not used */
+ pub static kCFSocketCommandKey: CFStringRef;
+ pub static kCFSocketNameKey: CFStringRef;
+ pub static kCFSocketValueKey: CFStringRef;
+ pub static kCFSocketResultKey: CFStringRef;
+ pub static kCFSocketErrorKey: CFStringRef;
+ pub static kCFSocketRegisterCommand: CFStringRef;
+ pub static kCFSocketRetrieveCommand: CFStringRef;
+
+ /* Creating Sockets */
+ pub fn CFSocketCreate(
+ allocator: CFAllocatorRef,
+ protocolFamily: SInt32,
+ socketType: SInt32,
+ protocol: SInt32,
+ callBackTypes: CFOptionFlags,
+ callout: CFSocketCallBack,
+ context: *const CFSocketContext,
+ ) -> CFSocketRef;
+ pub fn CFSocketCreateConnectedToSocketSignature(
+ allocator: CFAllocatorRef,
+ signature: *const CFSocketSignature,
+ callBackTypes: CFOptionFlags,
+ callout: CFSocketCallBack,
+ context: *const CFSocketContext,
+ timeout: CFTimeInterval,
+ ) -> CFSocketRef;
+ pub fn CFSocketCreateWithNative(
+ allocator: CFAllocatorRef,
+ sock: CFSocketNativeHandle,
+ callBackTypes: CFOptionFlags,
+ callout: CFSocketCallBack,
+ context: *const CFSocketContext,
+ ) -> CFSocketRef;
+ pub fn CFSocketCreateWithSocketSignature(
+ allocator: CFAllocatorRef,
+ signature: *const CFSocketSignature,
+ callBackTypes: CFOptionFlags,
+ callout: CFSocketCallBack,
+ context: *const CFSocketContext,
+ ) -> CFSocketRef;
+
+ /* Configuring Sockets */
+ pub fn CFSocketCopyAddress(s: CFSocketRef) -> CFDataRef;
+ pub fn CFSocketCopyPeerAddress(s: CFSocketRef) -> CFDataRef;
+ pub fn CFSocketDisableCallBacks(s: CFSocketRef, callBackTypes: CFOptionFlags);
+ pub fn CFSocketEnableCallBacks(s: CFSocketRef, callBackTypes: CFOptionFlags);
+ pub fn CFSocketGetContext(s: CFSocketRef, context: *mut CFSocketContext);
+ pub fn CFSocketGetNative(s: CFSocketRef) -> CFSocketNativeHandle;
+ pub fn CFSocketGetSocketFlags(s: CFSocketRef) -> CFOptionFlags;
+ pub fn CFSocketSetAddress(s: CFSocketRef, address: CFDataRef) -> CFSocketError;
+ pub fn CFSocketSetSocketFlags(s: CFSocketRef, flags: CFOptionFlags);
+
+ /* Using Sockets */
+ pub fn CFSocketConnectToAddress(
+ s: CFSocketRef,
+ address: CFDataRef,
+ timeout: CFTimeInterval,
+ ) -> CFSocketError;
+ pub fn CFSocketCreateRunLoopSource(
+ allocator: CFAllocatorRef,
+ s: CFSocketRef,
+ order: CFIndex,
+ ) -> CFRunLoopSourceRef;
+ pub fn CFSocketGetTypeID() -> CFTypeID;
+ pub fn CFSocketInvalidate(s: CFSocketRef);
+ pub fn CFSocketIsValid(s: CFSocketRef) -> Boolean;
+ pub fn CFSocketSendData(
+ s: CFSocketRef,
+ address: CFDataRef,
+ data: CFDataRef,
+ timeout: CFTimeInterval,
+ ) -> CFSocketError;
+
+ /* Socket Name Server Utilities */
+ pub fn CFSocketCopyRegisteredSocketSignature(
+ nameServerSignature: *const CFSocketSignature,
+ timeout: CFTimeInterval,
+ name: CFStringRef,
+ signature: *mut CFSocketSignature,
+ nameServerAddress: *mut CFDataRef,
+ ) -> CFSocketError;
+ pub fn CFSocketCopyRegisteredValue(
+ nameServerSignature: *const CFSocketSignature,
+ timeout: CFTimeInterval,
+ name: CFStringRef,
+ value: *mut CFPropertyListRef,
+ nameServerAddress: *mut CFDataRef,
+ ) -> CFSocketError;
+ pub fn CFSocketGetDefaultNameRegistryPortNumber() -> UInt16;
+ pub fn CFSocketRegisterSocketSignature(
+ nameServerSignature: *const CFSocketSignature,
+ timeout: CFTimeInterval,
+ name: CFStringRef,
+ signature: *const CFSocketSignature,
+ ) -> CFSocketError;
+ pub fn CFSocketRegisterValue(
+ nameServerSignature: *const CFSocketSignature,
+ timeout: CFTimeInterval,
+ name: CFStringRef,
+ value: CFPropertyListRef,
+ ) -> CFSocketError;
+ pub fn CFSocketSetDefaultNameRegistryPortNumber(port: UInt16);
+ pub fn CFSocketUnregister(
+ nameServerSignature: *const CFSocketSignature,
+ timeout: CFTimeInterval,
+ name: CFStringRef,
+ ) -> CFSocketError;
+}
diff --git a/vendor/core-foundation-sys/src/stream.rs b/vendor/core-foundation-sys/src/stream.rs
new file mode 100644
index 000000000..922700e48
--- /dev/null
+++ b/vendor/core-foundation-sys/src/stream.rs
@@ -0,0 +1,281 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::{c_int, c_void};
+
+use crate::base::{
+ Boolean, CFAllocatorRef, CFIndex, CFOptionFlags, CFTypeID, CFTypeRef, SInt32, UInt32, UInt8,
+};
+use crate::error::CFErrorRef;
+use crate::runloop::CFRunLoopRef;
+use crate::socket::{CFSocketNativeHandle, CFSocketSignature};
+use crate::string::CFStringRef;
+use crate::url::CFURLRef;
+
+#[repr(C)]
+pub struct __CFReadStream(c_void);
+
+#[repr(C)]
+pub struct __CFWriteStream(c_void);
+
+pub type CFReadStreamRef = *mut __CFReadStream;
+pub type CFWriteStreamRef = *mut __CFWriteStream;
+pub type CFStreamPropertyKey = CFStringRef;
+pub type CFStreamStatus = CFIndex;
+pub type CFStreamEventType = CFOptionFlags;
+pub type CFStreamErrorDomain = CFIndex;
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct CFStreamError {
+ pub domain: CFIndex,
+ pub error: SInt32,
+}
+
+/* CFStreamStatus: Constants that describe the status of a stream */
+pub const kCFStreamStatusNotOpen: CFStreamStatus = 0;
+pub const kCFStreamStatusOpening: CFStreamStatus = 1;
+pub const kCFStreamStatusOpen: CFStreamStatus = 2;
+pub const kCFStreamStatusReading: CFStreamStatus = 3;
+pub const kCFStreamStatusWriting: CFStreamStatus = 4;
+pub const kCFStreamStatusAtEnd: CFStreamStatus = 5;
+pub const kCFStreamStatusClosed: CFStreamStatus = 6;
+pub const kCFStreamStatusError: CFStreamStatus = 7;
+
+// deprecated
+pub const kCFStreamErrorDomainCustom: CFStreamErrorDomain = -1;
+pub const kCFStreamErrorDomainPOSIX: CFStreamErrorDomain = 1;
+pub const kCFStreamErrorDomainMacOSStatus: CFStreamErrorDomain = 2;
+
+/* CFStreamEventType: Defines constants for stream-related events */
+pub const kCFStreamEventNone: CFStreamEventType = 0;
+pub const kCFStreamEventOpenCompleted: CFStreamEventType = 1;
+pub const kCFStreamEventHasBytesAvailable: CFStreamEventType = 2;
+pub const kCFStreamEventCanAcceptBytes: CFStreamEventType = 4;
+pub const kCFStreamEventErrorOccurred: CFStreamEventType = 8;
+pub const kCFStreamEventEndEncountered: CFStreamEventType = 16;
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFStreamClientContext {
+ pub version: CFIndex,
+ pub info: *mut c_void,
+ pub retain: extern "C" fn(info: *const c_void) -> *const c_void,
+ pub release: extern "C" fn(info: *const c_void),
+ pub copyDescription: extern "C" fn(info: *const c_void) -> CFStringRef,
+}
+
+pub type CFReadStreamClientCallBack = extern "C" fn(
+ stream: CFReadStreamRef,
+ _type: CFStreamEventType,
+ clientCallBackInfo: *mut c_void,
+);
+pub type CFWriteStreamClientCallBack = extern "C" fn(
+ stream: CFWriteStreamRef,
+ _type: CFStreamEventType,
+ clientCallBackInfo: *mut c_void,
+);
+
+extern "C" {
+ /*
+ * CFStream.h
+ */
+
+ /* Stream Properties */
+ pub static kCFStreamPropertyAppendToFile: CFStreamPropertyKey;
+ pub static kCFStreamPropertyDataWritten: CFStreamPropertyKey;
+ pub static kCFStreamPropertyFileCurrentOffset: CFStreamPropertyKey;
+ pub static kCFStreamPropertySocketNativeHandle: CFStreamPropertyKey;
+ pub static kCFStreamPropertySocketRemoteHostName: CFStreamPropertyKey;
+ pub static kCFStreamPropertySocketRemotePortNumber: CFStreamPropertyKey;
+ pub static kCFStreamPropertyShouldCloseNativeSocket: CFStringRef;
+ pub static kCFStreamPropertySocketSecurityLevel: CFStringRef;
+
+ /* CFStream Socket Security Level Constants */
+ pub static kCFStreamSocketSecurityLevelNone: CFStringRef;
+ pub static kCFStreamSocketSecurityLevelSSLv2: CFStringRef;
+ pub static kCFStreamSocketSecurityLevelSSLv3: CFStringRef;
+ pub static kCFStreamSocketSecurityLevelTLSv1: CFStringRef;
+ pub static kCFStreamSocketSecurityLevelNegotiatedSSL: CFStringRef;
+
+ /* CFStream SOCKS Proxy Key Constants */
+ pub static kCFStreamPropertySOCKSProxy: CFStringRef;
+ pub static kCFStreamPropertySOCKSProxyHost: CFStringRef;
+ pub static kCFStreamPropertySOCKSProxyPort: CFStringRef;
+ pub static kCFStreamPropertySOCKSVersion: CFStringRef;
+ pub static kCFStreamSocketSOCKSVersion4: CFStringRef;
+ pub static kCFStreamSocketSOCKSVersion5: CFStringRef;
+ pub static kCFStreamPropertySOCKSUser: CFStringRef;
+ pub static kCFStreamPropertySOCKSPassword: CFStringRef;
+
+ /* CFStream Error Domain Constants (CFHost) */
+ pub static kCFStreamErrorDomainSOCKS: c_int;
+ pub static kCFStreamErrorDomainSSL: c_int;
+
+ /* CFStream: Creating Streams */
+ pub fn CFStreamCreatePairWithPeerSocketSignature(
+ alloc: CFAllocatorRef,
+ signature: *const CFSocketSignature,
+ readStream: *mut CFReadStreamRef,
+ writeStream: *mut CFWriteStreamRef,
+ ); // deprecated
+ pub fn CFStreamCreatePairWithSocketToHost(
+ alloc: CFAllocatorRef,
+ host: CFStringRef,
+ port: UInt32,
+ readStream: *mut CFReadStreamRef,
+ writeStream: *mut CFWriteStreamRef,
+ ); // deprecated
+ pub fn CFStreamCreatePairWithSocket(
+ alloc: CFAllocatorRef,
+ sock: CFSocketNativeHandle,
+ readStream: *mut CFReadStreamRef,
+ writeStream: *mut CFWriteStreamRef,
+ ); // deprecated
+ pub fn CFStreamCreateBoundPair(
+ alloc: CFAllocatorRef,
+ readStream: *mut CFReadStreamRef,
+ writeStream: *mut CFWriteStreamRef,
+ transferBufferSize: CFIndex,
+ );
+
+ //pub fn CFReadStreamSetDispatchQueue(stream: CFReadStreamRef, q: dispatch_queue_t); // macos(10.9)+
+ //pub fn CFWriteStreamSetDispatchQueue(stream: CFWriteStreamRef, q: dispatch_queue_t); // macos(10.9)+
+ //pub fn CFReadStreamCopyDispatchQueue(stream: CFReadStreamRef) -> dispatch_queue_t; // macos(10.9)+
+ //pub fn CFWriteStreamCopyDispatchQueue(stream: CFReadStreamRef) -> dispatch_queue_t; // macos(10.9)+
+
+ /* CFReadStream */
+ /* Creating a Read Stream */
+ pub fn CFReadStreamCreateWithBytesNoCopy(
+ alloc: CFAllocatorRef,
+ bytes: *const UInt8,
+ length: CFIndex,
+ bytesDeallocator: CFAllocatorRef,
+ ) -> CFReadStreamRef;
+ pub fn CFReadStreamCreateWithFile(alloc: CFAllocatorRef, fileURL: CFURLRef) -> CFReadStreamRef;
+
+ /* Opening and Closing a Read Stream */
+ pub fn CFReadStreamClose(stream: CFReadStreamRef);
+ pub fn CFReadStreamOpen(stream: CFReadStreamRef) -> Boolean;
+
+ /* Reading from a Stream */
+ pub fn CFReadStreamRead(
+ stream: CFReadStreamRef,
+ buffer: *mut UInt8,
+ bufferLength: CFIndex,
+ ) -> CFIndex;
+
+ /* Scheduling a Read Stream */
+ pub fn CFReadStreamScheduleWithRunLoop(
+ stream: CFReadStreamRef,
+ runLoop: CFRunLoopRef,
+ runLoopMode: CFStringRef,
+ );
+ pub fn CFReadStreamUnscheduleFromRunLoop(
+ stream: CFReadStreamRef,
+ runLoop: CFRunLoopRef,
+ runLoopMode: CFStringRef,
+ );
+
+ /* Examining Stream Properties */
+ pub fn CFReadStreamCopyProperty(
+ stream: CFReadStreamRef,
+ propertyName: CFStreamPropertyKey,
+ ) -> CFTypeRef;
+ pub fn CFReadStreamGetBuffer(
+ stream: CFReadStreamRef,
+ maxBytesToRead: CFIndex,
+ numBytesRead: *mut CFIndex,
+ ) -> *const UInt8;
+ pub fn CFReadStreamCopyError(stream: CFReadStreamRef) -> CFErrorRef;
+ pub fn CFReadStreamGetError(stream: CFReadStreamRef) -> CFStreamError; // deprecated
+ pub fn CFReadStreamGetStatus(stream: CFReadStreamRef) -> CFStreamStatus;
+ pub fn CFReadStreamHasBytesAvailable(stream: CFReadStreamRef) -> Boolean;
+
+ /* Setting Stream Properties */
+ pub fn CFReadStreamSetClient(
+ stream: CFReadStreamRef,
+ streamEvents: CFOptionFlags,
+ clientCB: CFReadStreamClientCallBack,
+ clientContext: *mut CFStreamClientContext,
+ ) -> Boolean;
+ pub fn CFReadStreamSetProperty(
+ stream: CFReadStreamRef,
+ propertyName: CFStreamPropertyKey,
+ propertyValue: CFTypeRef,
+ ) -> Boolean;
+
+ /* Getting the CFReadStream Type ID */
+ pub fn CFReadStreamGetTypeID() -> CFTypeID;
+
+ /* CFWriteStream */
+ /* Creating a Write Stream */
+ pub fn CFWriteStreamCreateWithAllocatedBuffers(
+ alloc: CFAllocatorRef,
+ bufferAllocator: CFAllocatorRef,
+ ) -> CFWriteStreamRef;
+ pub fn CFWriteStreamCreateWithBuffer(
+ alloc: CFAllocatorRef,
+ buffer: *mut UInt8,
+ bufferCapacity: CFIndex,
+ ) -> CFWriteStreamRef;
+ pub fn CFWriteStreamCreateWithFile(
+ alloc: CFAllocatorRef,
+ fileURL: CFURLRef,
+ ) -> CFWriteStreamRef;
+
+ /* Opening and Closing a Stream */
+ pub fn CFWriteStreamClose(stream: CFWriteStreamRef);
+ pub fn CFWriteStreamOpen(stream: CFWriteStreamRef) -> Boolean;
+
+ /* Writing to a Stream */
+ pub fn CFWriteStreamWrite(
+ stream: CFWriteStreamRef,
+ buffer: *const UInt8,
+ bufferLength: CFIndex,
+ ) -> CFIndex;
+
+ /* Scheduling a Write Stream */
+ pub fn CFWriteStreamScheduleWithRunLoop(
+ stream: CFWriteStreamRef,
+ runLoop: CFRunLoopRef,
+ runLoopMode: CFStringRef,
+ );
+ pub fn CFWriteStreamUnscheduleFromRunLoop(
+ stream: CFWriteStreamRef,
+ runLoop: CFRunLoopRef,
+ runLoopMode: CFStringRef,
+ );
+
+ /* Examining Stream Properties */
+ pub fn CFWriteStreamCanAcceptBytes(stream: CFWriteStreamRef) -> Boolean;
+ pub fn CFWriteStreamCopyProperty(
+ stream: CFWriteStreamRef,
+ propertyName: CFStreamPropertyKey,
+ ) -> CFTypeRef;
+ pub fn CFWriteStreamCopyError(stream: CFWriteStreamRef) -> CFErrorRef;
+ pub fn CFWriteStreamGetError(stream: CFWriteStreamRef) -> CFStreamError; // deprecated
+ pub fn CFWriteStreamGetStatus(stream: CFWriteStreamRef) -> CFStreamStatus;
+
+ /* Setting Stream Properties */
+ pub fn CFWriteStreamSetClient(
+ stream: CFWriteStreamRef,
+ streamEvents: CFOptionFlags,
+ clientCB: CFWriteStreamClientCallBack,
+ clientContext: *mut CFStreamClientContext,
+ ) -> Boolean;
+ pub fn CFWriteStreamSetProperty(
+ stream: CFWriteStreamRef,
+ propertyName: CFStreamPropertyKey,
+ propertyValue: CFTypeRef,
+ ) -> Boolean;
+
+ /* Getting the CFWriteStream Type ID */
+ pub fn CFWriteStreamGetTypeID() -> CFTypeID;
+}
diff --git a/vendor/core-foundation-sys/src/string.rs b/vendor/core-foundation-sys/src/string.rs
index d4f655078..2cb6ae948 100644
--- a/vendor/core-foundation-sys/src/string.rs
+++ b/vendor/core-foundation-sys/src/string.rs
@@ -7,317 +7,540 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::os::raw::{c_char, c_ushort, c_void};
-
-use base::{Boolean, CFOptionFlags, CFIndex, CFAllocatorRef, CFRange, CFTypeID};
-
-pub type UniChar = c_ushort;
-
-// CFString.h
+use crate::array::CFArrayRef;
+use crate::base::{
+ Boolean, CFAllocatorRef, CFComparisonResult, CFIndex, CFOptionFlags, CFRange, CFTypeID,
+ ConstStr255Param, ConstStringPtr, SInt32, StringPtr, UInt32, UInt8, UTF32Char,
+};
+use crate::characterset::CFCharacterSetRef;
+use crate::data::CFDataRef;
+use crate::dictionary::CFDictionaryRef;
+use crate::locale::CFLocaleRef;
+use std::os::raw::{c_char, c_double, c_ulong, c_ushort, c_void};
pub type CFStringCompareFlags = CFOptionFlags;
-//static kCFCompareCaseInsensitive: CFStringCompareFlags = 1;
-//static kCFCompareBackwards: CFStringCompareFlags = 4;
-//static kCFCompareAnchored: CFStringCompareFlags = 8;
-//static kCFCompareNonliteral: CFStringCompareFlags = 16;
-//static kCFCompareLocalized: CFStringCompareFlags = 32;
-//static kCFCompareNumerically: CFStringCompareFlags = 64;
-//static kCFCompareDiacriticInsensitive: CFStringCompareFlags = 128;
-//static kCFCompareWidthInsensitive: CFStringCompareFlags = 256;
-//static kCFCompareForcedOrdering: CFStringCompareFlags = 512;
+pub const kCFCompareCaseInsensitive: CFStringCompareFlags = 1;
+pub const kCFCompareBackwards: CFStringCompareFlags = 4;
+pub const kCFCompareAnchored: CFStringCompareFlags = 8;
+pub const kCFCompareNonliteral: CFStringCompareFlags = 16;
+pub const kCFCompareLocalized: CFStringCompareFlags = 32;
+pub const kCFCompareNumerically: CFStringCompareFlags = 64;
+pub const kCFCompareDiacriticInsensitive: CFStringCompareFlags = 128;
+pub const kCFCompareWidthInsensitive: CFStringCompareFlags = 256;
+pub const kCFCompareForcedOrdering: CFStringCompareFlags = 512;
-pub type CFStringEncoding = u32;
+pub type CFStringEncoding = UInt32;
+pub type UniChar = c_ushort;
// macOS built-in encodings.
-//static kCFStringEncodingMacRoman: CFStringEncoding = 0;
-//static kCFStringEncodingWindowsLatin1: CFStringEncoding = 0x0500;
-//static kCFStringEncodingISOLatin1: CFStringEncoding = 0x0201;
-//static kCFStringEncodingNextStepLatin: CFStringEncoding = 0x0B01;
-//static kCFStringEncodingASCII: CFStringEncoding = 0x0600;
-//static kCFStringEncodingUnicode: CFStringEncoding = 0x0100;
-pub static kCFStringEncodingUTF8: CFStringEncoding = 0x08000100;
-//static kCFStringEncodingNonLossyASCII: CFStringEncoding = 0x0BFF;
-
-//static kCFStringEncodingUTF16: CFStringEncoding = 0x0100;
-//static kCFStringEncodingUTF16BE: CFStringEncoding = 0x10000100;
-//static kCFStringEncodingUTF16LE: CFStringEncoding = 0x14000100;
-//static kCFStringEncodingUTF32: CFStringEncoding = 0x0c000100;
-//static kCFStringEncodingUTF32BE: CFStringEncoding = 0x18000100;
-//static kCFStringEncodingUTF32LE: CFStringEncoding = 0x1c000100;
+pub const kCFStringEncodingMacRoman: CFStringEncoding = 0;
+pub const kCFStringEncodingWindowsLatin1: CFStringEncoding = 0x0500;
+pub const kCFStringEncodingISOLatin1: CFStringEncoding = 0x0201;
+pub const kCFStringEncodingNextStepLatin: CFStringEncoding = 0x0B01;
+pub const kCFStringEncodingASCII: CFStringEncoding = 0x0600;
+pub const kCFStringEncodingUnicode: CFStringEncoding = 0x0100;
+pub const kCFStringEncodingUTF8: CFStringEncoding = 0x08000100;
+pub const kCFStringEncodingNonLossyASCII: CFStringEncoding = 0x0BFF;
+pub const kCFStringEncodingUTF16: CFStringEncoding = 0x0100;
+pub const kCFStringEncodingUTF16BE: CFStringEncoding = 0x10000100;
+pub const kCFStringEncodingUTF16LE: CFStringEncoding = 0x14000100;
+pub const kCFStringEncodingUTF32: CFStringEncoding = 0x0c000100;
+pub const kCFStringEncodingUTF32BE: CFStringEncoding = 0x18000100;
+pub const kCFStringEncodingUTF32LE: CFStringEncoding = 0x1c000100;
// CFStringEncodingExt.h
+// External encodings, except those defined above.
+pub const kCFStringEncodingMacJapanese: CFStringEncoding = 1;
+pub const kCFStringEncodingMacChineseTrad: CFStringEncoding = 2;
+pub const kCFStringEncodingMacKorean: CFStringEncoding = 3;
+pub const kCFStringEncodingMacArabic: CFStringEncoding = 4;
+pub const kCFStringEncodingMacHebrew: CFStringEncoding = 5;
+pub const kCFStringEncodingMacGreek: CFStringEncoding = 6;
+pub const kCFStringEncodingMacCyrillic: CFStringEncoding = 7;
+pub const kCFStringEncodingMacDevanagari: CFStringEncoding = 9;
+pub const kCFStringEncodingMacGurmukhi: CFStringEncoding = 10;
+pub const kCFStringEncodingMacGujarati: CFStringEncoding = 11;
+pub const kCFStringEncodingMacOriya: CFStringEncoding = 12;
+pub const kCFStringEncodingMacBengali: CFStringEncoding = 13;
+pub const kCFStringEncodingMacTamil: CFStringEncoding = 14;
+pub const kCFStringEncodingMacTelugu: CFStringEncoding = 15;
+pub const kCFStringEncodingMacKannada: CFStringEncoding = 16;
+pub const kCFStringEncodingMacMalayalam: CFStringEncoding = 17;
+pub const kCFStringEncodingMacSinhalese: CFStringEncoding = 18;
+pub const kCFStringEncodingMacBurmese: CFStringEncoding = 19;
+pub const kCFStringEncodingMacKhmer: CFStringEncoding = 20;
+pub const kCFStringEncodingMacThai: CFStringEncoding = 21;
+pub const kCFStringEncodingMacLaotian: CFStringEncoding = 22;
+pub const kCFStringEncodingMacGeorgian: CFStringEncoding = 23;
+pub const kCFStringEncodingMacArmenian: CFStringEncoding = 24;
+pub const kCFStringEncodingMacChineseSimp: CFStringEncoding = 25;
+pub const kCFStringEncodingMacTibetan: CFStringEncoding = 26;
+pub const kCFStringEncodingMacMongolian: CFStringEncoding = 27;
+pub const kCFStringEncodingMacEthiopic: CFStringEncoding = 28;
+pub const kCFStringEncodingMacCentralEurRoman: CFStringEncoding = 29;
+pub const kCFStringEncodingMacVietnamese: CFStringEncoding = 30;
+pub const kCFStringEncodingMacExtArabic: CFStringEncoding = 31;
+pub const kCFStringEncodingMacSymbol: CFStringEncoding = 33;
+pub const kCFStringEncodingMacDingbats: CFStringEncoding = 34;
+pub const kCFStringEncodingMacTurkish: CFStringEncoding = 35;
+pub const kCFStringEncodingMacCroatian: CFStringEncoding = 36;
+pub const kCFStringEncodingMacIcelandic: CFStringEncoding = 37;
+pub const kCFStringEncodingMacRomanian: CFStringEncoding = 38;
+pub const kCFStringEncodingMacCeltic: CFStringEncoding = 39;
+pub const kCFStringEncodingMacGaelic: CFStringEncoding = 40;
+pub const kCFStringEncodingMacFarsi: CFStringEncoding = 0x8C;
+pub const kCFStringEncodingMacUkrainian: CFStringEncoding = 0x98;
+pub const kCFStringEncodingMacInuit: CFStringEncoding = 0xEC;
+pub const kCFStringEncodingMacVT100: CFStringEncoding = 0xFC;
+pub const kCFStringEncodingMacHFS: CFStringEncoding = 0xFF;
+pub const kCFStringEncodingISOLatin2: CFStringEncoding = 0x0202;
+pub const kCFStringEncodingISOLatin3: CFStringEncoding = 0x0203;
+pub const kCFStringEncodingISOLatin4: CFStringEncoding = 0x0204;
+pub const kCFStringEncodingISOLatinCyrillic: CFStringEncoding = 0x0205;
+pub const kCFStringEncodingISOLatinArabic: CFStringEncoding = 0x0206;
+pub const kCFStringEncodingISOLatinGreek: CFStringEncoding = 0x0207;
+pub const kCFStringEncodingISOLatinHebrew: CFStringEncoding = 0x0208;
+pub const kCFStringEncodingISOLatin5: CFStringEncoding = 0x0209;
+pub const kCFStringEncodingISOLatin6: CFStringEncoding = 0x020A;
+pub const kCFStringEncodingISOLatinThai: CFStringEncoding = 0x020B;
+pub const kCFStringEncodingISOLatin7: CFStringEncoding = 0x020D;
+pub const kCFStringEncodingISOLatin8: CFStringEncoding = 0x020E;
+pub const kCFStringEncodingISOLatin9: CFStringEncoding = 0x020F;
+pub const kCFStringEncodingISOLatin10: CFStringEncoding = 0x0210;
+pub const kCFStringEncodingDOSLatinUS: CFStringEncoding = 0x0400;
+pub const kCFStringEncodingDOSGreek: CFStringEncoding = 0x0405;
+pub const kCFStringEncodingDOSBalticRim: CFStringEncoding = 0x0406;
+pub const kCFStringEncodingDOSLatin1: CFStringEncoding = 0x0410;
+pub const kCFStringEncodingDOSGreek1: CFStringEncoding = 0x0411;
+pub const kCFStringEncodingDOSLatin2: CFStringEncoding = 0x0412;
+pub const kCFStringEncodingDOSCyrillic: CFStringEncoding = 0x0413;
+pub const kCFStringEncodingDOSTurkish: CFStringEncoding = 0x0414;
+pub const kCFStringEncodingDOSPortuguese: CFStringEncoding = 0x0415;
+pub const kCFStringEncodingDOSIcelandic: CFStringEncoding = 0x0416;
+pub const kCFStringEncodingDOSHebrew: CFStringEncoding = 0x0417;
+pub const kCFStringEncodingDOSCanadianFrench: CFStringEncoding = 0x0418;
+pub const kCFStringEncodingDOSArabic: CFStringEncoding = 0x0419;
+pub const kCFStringEncodingDOSNordic: CFStringEncoding = 0x041A;
+pub const kCFStringEncodingDOSRussian: CFStringEncoding = 0x041B;
+pub const kCFStringEncodingDOSGreek2: CFStringEncoding = 0x041C;
+pub const kCFStringEncodingDOSThai: CFStringEncoding = 0x041D;
+pub const kCFStringEncodingDOSJapanese: CFStringEncoding = 0x0420;
+pub const kCFStringEncodingDOSChineseSimplif: CFStringEncoding = 0x0421;
+pub const kCFStringEncodingDOSKorean: CFStringEncoding = 0x0422;
+pub const kCFStringEncodingDOSChineseTrad: CFStringEncoding = 0x0423;
+pub const kCFStringEncodingWindowsLatin2: CFStringEncoding = 0x0501;
+pub const kCFStringEncodingWindowsCyrillic: CFStringEncoding = 0x0502;
+pub const kCFStringEncodingWindowsGreek: CFStringEncoding = 0x0503;
+pub const kCFStringEncodingWindowsLatin5: CFStringEncoding = 0x0504;
+pub const kCFStringEncodingWindowsHebrew: CFStringEncoding = 0x0505;
+pub const kCFStringEncodingWindowsArabic: CFStringEncoding = 0x0506;
+pub const kCFStringEncodingWindowsBalticRim: CFStringEncoding = 0x0507;
+pub const kCFStringEncodingWindowsVietnamese: CFStringEncoding = 0x0508;
+pub const kCFStringEncodingWindowsKoreanJohab: CFStringEncoding = 0x0510;
+pub const kCFStringEncodingANSEL: CFStringEncoding = 0x0601;
+pub const kCFStringEncodingJIS_X0201_76: CFStringEncoding = 0x0620;
+pub const kCFStringEncodingJIS_X0208_83: CFStringEncoding = 0x0621;
+pub const kCFStringEncodingJIS_X0208_90: CFStringEncoding = 0x0622;
+pub const kCFStringEncodingJIS_X0212_90: CFStringEncoding = 0x0623;
+pub const kCFStringEncodingJIS_C6226_78: CFStringEncoding = 0x0624;
+pub const kCFStringEncodingShiftJIS_X0213: CFStringEncoding = 0x0628;
+pub const kCFStringEncodingShiftJIS_X0213_MenKuTen: CFStringEncoding = 0x0629;
+pub const kCFStringEncodingGB_2312_80: CFStringEncoding = 0x0630;
+pub const kCFStringEncodingGBK_95: CFStringEncoding = 0x0631;
+pub const kCFStringEncodingGB_18030_2000: CFStringEncoding = 0x0632;
+pub const kCFStringEncodingKSC_5601_87: CFStringEncoding = 0x0640;
+pub const kCFStringEncodingKSC_5601_92_Johab: CFStringEncoding = 0x0641;
+pub const kCFStringEncodingCNS_11643_92_P1: CFStringEncoding = 0x0651;
+pub const kCFStringEncodingCNS_11643_92_P2: CFStringEncoding = 0x0652;
+pub const kCFStringEncodingCNS_11643_92_P3: CFStringEncoding = 0x0653;
+pub const kCFStringEncodingISO_2022_JP: CFStringEncoding = 0x0820;
+pub const kCFStringEncodingISO_2022_JP_2: CFStringEncoding = 0x0821;
+pub const kCFStringEncodingISO_2022_JP_1: CFStringEncoding = 0x0822;
+pub const kCFStringEncodingISO_2022_JP_3: CFStringEncoding = 0x0823;
+pub const kCFStringEncodingISO_2022_CN: CFStringEncoding = 0x0830;
+pub const kCFStringEncodingISO_2022_CN_EXT: CFStringEncoding = 0x0831;
+pub const kCFStringEncodingISO_2022_KR: CFStringEncoding = 0x0840;
+pub const kCFStringEncodingEUC_JP: CFStringEncoding = 0x0920;
+pub const kCFStringEncodingEUC_CN: CFStringEncoding = 0x0930;
+pub const kCFStringEncodingEUC_TW: CFStringEncoding = 0x0931;
+pub const kCFStringEncodingEUC_KR: CFStringEncoding = 0x0940;
+pub const kCFStringEncodingShiftJIS: CFStringEncoding = 0x0A01;
+pub const kCFStringEncodingKOI8_R: CFStringEncoding = 0x0A02;
+pub const kCFStringEncodingBig5: CFStringEncoding = 0x0A03;
+pub const kCFStringEncodingMacRomanLatin1: CFStringEncoding = 0x0A04;
+pub const kCFStringEncodingHZ_GB_2312: CFStringEncoding = 0x0A05;
+pub const kCFStringEncodingBig5_HKSCS_1999: CFStringEncoding = 0x0A06;
+pub const kCFStringEncodingVISCII: CFStringEncoding = 0x0A07;
+pub const kCFStringEncodingKOI8_U: CFStringEncoding = 0x0A08;
+pub const kCFStringEncodingBig5_E: CFStringEncoding = 0x0A09;
+pub const kCFStringEncodingNextStepJapanese: CFStringEncoding = 0x0B02;
+pub const kCFStringEncodingEBCDIC_US: CFStringEncoding = 0x0C01;
+pub const kCFStringEncodingEBCDIC_CP037: CFStringEncoding = 0x0C02;
+pub const kCFStringEncodingUTF7: CFStringEncoding = 0x04000100;
+pub const kCFStringEncodingUTF7_IMAP: CFStringEncoding = 0x0A10;
+pub const kCFStringEncodingShiftJIS_X0213_00: CFStringEncoding = 0x0628; /* Deprecated */
-pub type CFStringEncodings = CFIndex;
+pub const kCFStringEncodingInvalidId: u32 = 0xffffffff;
-// External encodings, except those defined above.
-// Defined above: kCFStringEncodingMacRoman = 0
-//static kCFStringEncodingMacJapanese: CFStringEncoding = 1;
-//static kCFStringEncodingMacChineseTrad: CFStringEncoding = 2;
-//static kCFStringEncodingMacKorean: CFStringEncoding = 3;
-//static kCFStringEncodingMacArabic: CFStringEncoding = 4;
-//static kCFStringEncodingMacHebrew: CFStringEncoding = 5;
-//static kCFStringEncodingMacGreek: CFStringEncoding = 6;
-//static kCFStringEncodingMacCyrillic: CFStringEncoding = 7;
-//static kCFStringEncodingMacDevanagari: CFStringEncoding = 9;
-//static kCFStringEncodingMacGurmukhi: CFStringEncoding = 10;
-//static kCFStringEncodingMacGujarati: CFStringEncoding = 11;
-//static kCFStringEncodingMacOriya: CFStringEncoding = 12;
-//static kCFStringEncodingMacBengali: CFStringEncoding = 13;
-//static kCFStringEncodingMacTamil: CFStringEncoding = 14;
-//static kCFStringEncodingMacTelugu: CFStringEncoding = 15;
-//static kCFStringEncodingMacKannada: CFStringEncoding = 16;
-//static kCFStringEncodingMacMalayalam: CFStringEncoding = 17;
-//static kCFStringEncodingMacSinhalese: CFStringEncoding = 18;
-//static kCFStringEncodingMacBurmese: CFStringEncoding = 19;
-//static kCFStringEncodingMacKhmer: CFStringEncoding = 20;
-//static kCFStringEncodingMacThai: CFStringEncoding = 21;
-//static kCFStringEncodingMacLaotian: CFStringEncoding = 22;
-//static kCFStringEncodingMacGeorgian: CFStringEncoding = 23;
-//static kCFStringEncodingMacArmenian: CFStringEncoding = 24;
-//static kCFStringEncodingMacChineseSimp: CFStringEncoding = 25;
-//static kCFStringEncodingMacTibetan: CFStringEncoding = 26;
-//static kCFStringEncodingMacMongolian: CFStringEncoding = 27;
-//static kCFStringEncodingMacEthiopic: CFStringEncoding = 28;
-//static kCFStringEncodingMacCentralEurRoman: CFStringEncoding = 29;
-//static kCFStringEncodingMacVietnamese: CFStringEncoding = 30;
-//static kCFStringEncodingMacExtArabic: CFStringEncoding = 31;
-//static kCFStringEncodingMacSymbol: CFStringEncoding = 33;
-//static kCFStringEncodingMacDingbats: CFStringEncoding = 34;
-//static kCFStringEncodingMacTurkish: CFStringEncoding = 35;
-//static kCFStringEncodingMacCroatian: CFStringEncoding = 36;
-//static kCFStringEncodingMacIcelandic: CFStringEncoding = 37;
-//static kCFStringEncodingMacRomanian: CFStringEncoding = 38;
-//static kCFStringEncodingMacCeltic: CFStringEncoding = 39;
-//static kCFStringEncodingMacGaelic: CFStringEncoding = 40;
-//static kCFStringEncodingMacFarsi: CFStringEncoding = 0x8C;
-//static kCFStringEncodingMacUkrainian: CFStringEncoding = 0x98;
-//static kCFStringEncodingMacInuit: CFStringEncoding = 0xEC;
-//static kCFStringEncodingMacVT100: CFStringEncoding = 0xFC;
-//static kCFStringEncodingMacHFS: CFStringEncoding = 0xFF;
-// Defined above: kCFStringEncodingISOLatin1 = 0x0201
-//static kCFStringEncodingISOLatin2: CFStringEncoding = 0x0202;
-//static kCFStringEncodingISOLatin3: CFStringEncoding = 0x0203;
-//static kCFStringEncodingISOLatin4: CFStringEncoding = 0x0204;
-//static kCFStringEncodingISOLatinCyrillic: CFStringEncoding = 0x0205;
-//static kCFStringEncodingISOLatinArabic: CFStringEncoding = 0x0206;
-//static kCFStringEncodingISOLatinGreek: CFStringEncoding = 0x0207;
-//static kCFStringEncodingISOLatinHebrew: CFStringEncoding = 0x0208;
-//static kCFStringEncodingISOLatin5: CFStringEncoding = 0x0209;
-//static kCFStringEncodingISOLatin6: CFStringEncoding = 0x020A;
-//static kCFStringEncodingISOLatinThai: CFStringEncoding = 0x020B;
-//static kCFStringEncodingISOLatin7: CFStringEncoding = 0x020D;
-//static kCFStringEncodingISOLatin8: CFStringEncoding = 0x020E;
-//static kCFStringEncodingISOLatin9: CFStringEncoding = 0x020F;
-//static kCFStringEncodingISOLatin10: CFStringEncoding = 0x0210;
-//static kCFStringEncodingDOSLatinUS: CFStringEncoding = 0x0400;
-//static kCFStringEncodingDOSGreek: CFStringEncoding = 0x0405;
-//static kCFStringEncodingDOSBalticRim: CFStringEncoding = 0x0406;
-//static kCFStringEncodingDOSLatin1: CFStringEncoding = 0x0410;
-//static kCFStringEncodingDOSGreek1: CFStringEncoding = 0x0411;
-//static kCFStringEncodingDOSLatin2: CFStringEncoding = 0x0412;
-//static kCFStringEncodingDOSCyrillic: CFStringEncoding = 0x0413;
-//static kCFStringEncodingDOSTurkish: CFStringEncoding = 0x0414;
-//static kCFStringEncodingDOSPortuguese: CFStringEncoding = 0x0415;
-//static kCFStringEncodingDOSIcelandic: CFStringEncoding = 0x0416;
-//static kCFStringEncodingDOSHebrew: CFStringEncoding = 0x0417;
-//static kCFStringEncodingDOSCanadianFrench: CFStringEncoding = 0x0418;
-//static kCFStringEncodingDOSArabic: CFStringEncoding = 0x0419;
-//static kCFStringEncodingDOSNordic: CFStringEncoding = 0x041A;
-//static kCFStringEncodingDOSRussian: CFStringEncoding = 0x041B;
-//static kCFStringEncodingDOSGreek2: CFStringEncoding = 0x041C;
-//static kCFStringEncodingDOSThai: CFStringEncoding = 0x041D;
-//static kCFStringEncodingDOSJapanese: CFStringEncoding = 0x0420;
-//static kCFStringEncodingDOSChineseSimplif: CFStringEncoding = 0x0421;
-//static kCFStringEncodingDOSKorean: CFStringEncoding = 0x0422;
-//static kCFStringEncodingDOSChineseTrad: CFStringEncoding = 0x0423;
-// Defined above: kCFStringEncodingWindowsLatin1 = 0x0500
-//static kCFStringEncodingWindowsLatin2: CFStringEncoding = 0x0501;
-//static kCFStringEncodingWindowsCyrillic: CFStringEncoding = 0x0502;
-//static kCFStringEncodingWindowsGreek: CFStringEncoding = 0x0503;
-//static kCFStringEncodingWindowsLatin5: CFStringEncoding = 0x0504;
-//static kCFStringEncodingWindowsHebrew: CFStringEncoding = 0x0505;
-//static kCFStringEncodingWindowsArabic: CFStringEncoding = 0x0506;
-//static kCFStringEncodingWindowsBalticRim: CFStringEncoding = 0x0507;
-//static kCFStringEncodingWindowsVietnamese: CFStringEncoding = 0x0508;
-//static kCFStringEncodingWindowsKoreanJohab: CFStringEncoding = 0x0510;
-// Defined above: kCFStringEncodingASCII = 0x0600
-//static kCFStringEncodingANSEL: CFStringEncoding = 0x0601;
-//static kCFStringEncodingJIS_X0201_76: CFStringEncoding = 0x0620;
-//static kCFStringEncodingJIS_X0208_83: CFStringEncoding = 0x0621;
-//static kCFStringEncodingJIS_X0208_90: CFStringEncoding = 0x0622;
-//static kCFStringEncodingJIS_X0212_90: CFStringEncoding = 0x0623;
-//static kCFStringEncodingJIS_C6226_78: CFStringEncoding = 0x0624;
-//static kCFStringEncodingShiftJIS_X0213: CFStringEncoding = 0x0628;
-//static kCFStringEncodingShiftJIS_X0213_MenKuTen: CFStringEncoding = 0x0629;
-//static kCFStringEncodingGB_2312_80: CFStringEncoding = 0x0630;
-//static kCFStringEncodingGBK_95: CFStringEncoding = 0x0631;
-//static kCFStringEncodingGB_18030_2000: CFStringEncoding = 0x0632;
-//static kCFStringEncodingKSC_5601_87: CFStringEncoding = 0x0640;
-//static kCFStringEncodingKSC_5601_92_Johab: CFStringEncoding = 0x0641;
-//static kCFStringEncodingCNS_11643_92_P1: CFStringEncoding = 0x0651;
-//static kCFStringEncodingCNS_11643_92_P2: CFStringEncoding = 0x0652;
-//static kCFStringEncodingCNS_11643_92_P3: CFStringEncoding = 0x0653;
-//static kCFStringEncodingISO_2022_JP: CFStringEncoding = 0x0820;
-//static kCFStringEncodingISO_2022_JP_2: CFStringEncoding = 0x0821;
-//static kCFStringEncodingISO_2022_JP_1: CFStringEncoding = 0x0822;
-//static kCFStringEncodingISO_2022_JP_3: CFStringEncoding = 0x0823;
-//static kCFStringEncodingISO_2022_CN: CFStringEncoding = 0x0830;
-//static kCFStringEncodingISO_2022_CN_EXT: CFStringEncoding = 0x0831;
-//static kCFStringEncodingISO_2022_KR: CFStringEncoding = 0x0840;
-//static kCFStringEncodingEUC_JP: CFStringEncoding = 0x0920;
-//static kCFStringEncodingEUC_CN: CFStringEncoding = 0x0930;
-//static kCFStringEncodingEUC_TW: CFStringEncoding = 0x0931;
-//static kCFStringEncodingEUC_KR: CFStringEncoding = 0x0940;
-//static kCFStringEncodingShiftJIS: CFStringEncoding = 0x0A01;
-//static kCFStringEncodingKOI8_R: CFStringEncoding = 0x0A02;
-//static kCFStringEncodingBig5: CFStringEncoding = 0x0A03;
-//static kCFStringEncodingMacRomanLatin1: CFStringEncoding = 0x0A04;
-//static kCFStringEncodingHZ_GB_2312: CFStringEncoding = 0x0A05;
-//static kCFStringEncodingBig5_HKSCS_1999: CFStringEncoding = 0x0A06;
-//static kCFStringEncodingVISCII: CFStringEncoding = 0x0A07;
-//static kCFStringEncodingKOI8_U: CFStringEncoding = 0x0A08;
-//static kCFStringEncodingBig5_E: CFStringEncoding = 0x0A09;
-// Defined above: kCFStringEncodingNextStepLatin = 0x0B01
-//static kCFStringEncodingNextStepJapanese: CFStringEncoding = 0x0B02;
-//static kCFStringEncodingEBCDIC_US: CFStringEncoding = 0x0C01;
-//static kCFStringEncodingEBCDIC_CP037: CFStringEncoding = 0x0C02;
-//static kCFStringEncodingUTF7: CFStringEncoding = 0x04000100;
-//static kCFStringEncodingUTF7_IMAP: CFStringEncoding = 0x0A10;
-//static kCFStringEncodingShiftJIS_X0213_00: CFStringEncoding = 0x0628; /* Deprecated */
+pub type CFStringNormalizationForm = CFIndex;
+pub const kCFStringNormalizationFormD: CFStringNormalizationForm = 0;
+pub const kCFStringNormalizationFormKD: CFStringNormalizationForm = 1;
+pub const kCFStringNormalizationFormC: CFStringNormalizationForm = 2;
+pub const kCFStringNormalizationFormKC: CFStringNormalizationForm = 3;
#[repr(C)]
pub struct __CFString(c_void);
pub type CFStringRef = *const __CFString;
+pub type CFMutableStringRef = *mut __CFString;
+
+/* todo: The source code of the following functions is right in CFString.h */
+/*
+pub fn CFStringGetLongCharacterForSurrogatePair(surrogateHigh: UniChar, surrogateLow: UniChar) -> UTF32Char;
+pub fn CFStringGetSurrogatePairForLongCharacter(character: UTF32Char, surrogates: *mut UniChar) -> Boolean;
+pub fn CFStringIsSurrogateHighCharacter(character: UniChar) -> Boolean;
+pub fn CFStringIsSurrogateLowCharacter(character: UniChar) -> Boolean;
+pub fn CFStringInitInlineBuffer(str: CFStringRef, buf: *mut CFStringInlineBuffer, range: CFRange);
+pub fn CFStringGetCharacterFromInlineBuffer(buf: *mut CFStringInlineBuffer, idx: CFIndex) -> UniChar;
+*/
-extern {
+extern "C" {
/*
* CFString.h
*/
// N.B. organized according to "Functions by task" in docs
+ /* CFString */
/* Creating a CFString */
//fn CFSTR
- //fn CFStringCreateArrayBySeparatingStrings
- //fn CFStringCreateByCombiningStrings
- //fn CFStringCreateCopy
- //fn CFStringCreateFromExternalRepresentation
- pub fn CFStringCreateWithBytes(alloc: CFAllocatorRef,
- bytes: *const u8,
- numBytes: CFIndex,
- encoding: CFStringEncoding,
- isExternalRepresentation: Boolean)
- -> CFStringRef;
- pub fn CFStringCreateWithBytesNoCopy(alloc: CFAllocatorRef,
- bytes: *const u8,
- numBytes: CFIndex,
- encoding: CFStringEncoding,
- isExternalRepresentation: Boolean,
- contentsDeallocator: CFAllocatorRef)
- -> CFStringRef;
- //fn CFStringCreateWithCharacters
- pub fn CFStringCreateWithCharactersNoCopy(alloc: CFAllocatorRef,
- chars: *const UniChar,
- numChars: CFIndex,
- contentsDeallocator: CFAllocatorRef)
- -> CFStringRef;
- pub fn CFStringCreateWithCString(alloc: CFAllocatorRef,
- cStr: *const c_char,
- encoding: CFStringEncoding)
- -> CFStringRef;
- //fn CFStringCreateWithCStringNoCopy
- //fn CFStringCreateWithFormat
- //fn CFStringCreateWithFormatAndArguments
- //fn CFStringCreateWithPascalString
- //fn CFStringCreateWithPascalStringNoCopy
- //fn CFStringCreateWithSubstring
+ pub fn CFStringCreateArrayBySeparatingStrings(
+ alloc: CFAllocatorRef,
+ theString: CFStringRef,
+ separatorString: CFStringRef,
+ ) -> CFArrayRef;
+ pub fn CFStringCreateByCombiningStrings(
+ alloc: CFAllocatorRef,
+ theArray: CFArrayRef,
+ separatorString: CFStringRef,
+ ) -> CFStringRef;
+ pub fn CFStringCreateCopy(alloc: CFAllocatorRef, theString: CFStringRef) -> CFStringRef;
+ pub fn CFStringCreateFromExternalRepresentation(
+ alloc: CFAllocatorRef,
+ data: CFDataRef,
+ encoding: CFStringEncoding,
+ ) -> CFStringRef;
+ pub fn CFStringCreateWithBytes(
+ alloc: CFAllocatorRef,
+ bytes: *const UInt8,
+ numBytes: CFIndex,
+ encoding: CFStringEncoding,
+ isExternalRepresentation: Boolean,
+ ) -> CFStringRef;
+ pub fn CFStringCreateWithBytesNoCopy(
+ alloc: CFAllocatorRef,
+ bytes: *const UInt8,
+ numBytes: CFIndex,
+ encoding: CFStringEncoding,
+ isExternalRepresentation: Boolean,
+ contentsDeallocator: CFAllocatorRef,
+ ) -> CFStringRef;
+ pub fn CFStringCreateWithCharacters(
+ alloc: CFAllocatorRef,
+ chars: *const UniChar,
+ numChars: CFIndex,
+ ) -> CFStringRef;
+ pub fn CFStringCreateWithCharactersNoCopy(
+ alloc: CFAllocatorRef,
+ chars: *const UniChar,
+ numChars: CFIndex,
+ contentsDeallocator: CFAllocatorRef,
+ ) -> CFStringRef;
+ pub fn CFStringCreateWithCString(
+ alloc: CFAllocatorRef,
+ cStr: *const c_char,
+ encoding: CFStringEncoding,
+ ) -> CFStringRef;
+ pub fn CFStringCreateWithCStringNoCopy(
+ alloc: CFAllocatorRef,
+ cStr: *const c_char,
+ encoding: CFStringEncoding,
+ contentsDeallocator: CFAllocatorRef,
+ ) -> CFStringRef;
+ pub fn CFStringCreateWithFormat(
+ alloc: CFAllocatorRef,
+ formatOptions: CFDictionaryRef,
+ format: CFStringRef,
+ ...
+ ) -> CFStringRef;
+ //pub fn CFStringCreateWithFormatAndArguments(alloc: CFAllocatorRef, formatOptions: CFDictionaryRef, format: CFStringRef, arguments: va_list) -> CFStringRef;
+ pub fn CFStringCreateWithPascalString(
+ alloc: CFAllocatorRef,
+ pStr: ConstStr255Param,
+ encoding: CFStringEncoding,
+ ) -> CFStringRef;
+ pub fn CFStringCreateWithPascalStringNoCopy(
+ alloc: CFAllocatorRef,
+ pStr: ConstStr255Param,
+ encoding: CFStringEncoding,
+ contentsDeallocator: CFAllocatorRef,
+ ) -> CFStringRef;
+ pub fn CFStringCreateWithSubstring(
+ alloc: CFAllocatorRef,
+ str: CFStringRef,
+ range: CFRange,
+ ) -> CFStringRef;
/* Searching Strings */
- //fn CFStringCreateArrayWithFindResults
- //fn CFStringFind
- //fn CFStringFindCharacterFromSet
- //fn CFStringFindWithOptions
- //fn CFStringFindWithOptionsAndLocale
- //fn CFStringGetLineBounds
+ pub fn CFStringCreateArrayWithFindResults(
+ alloc: CFAllocatorRef,
+ theString: CFStringRef,
+ stringToFind: CFStringRef,
+ rangeToSearch: CFRange,
+ compareOptions: CFStringCompareFlags,
+ ) -> CFArrayRef;
+ pub fn CFStringFind(
+ theString: CFStringRef,
+ stringToFind: CFStringRef,
+ compareOptions: CFStringCompareFlags,
+ ) -> CFRange;
+ pub fn CFStringFindCharacterFromSet(
+ theString: CFStringRef,
+ theSet: CFCharacterSetRef,
+ rangeToSearch: CFRange,
+ searchOptions: CFStringCompareFlags,
+ result: *mut CFRange,
+ ) -> Boolean;
+ pub fn CFStringFindWithOptions(
+ theString: CFStringRef,
+ stringToFind: CFStringRef,
+ rangeToSearch: CFRange,
+ searchOptions: CFStringCompareFlags,
+ result: *mut CFRange,
+ ) -> Boolean;
+ pub fn CFStringFindWithOptionsAndLocale(
+ theString: CFStringRef,
+ stringToFind: CFStringRef,
+ rangeToSearch: CFRange,
+ searchOptions: CFStringCompareFlags,
+ locale: CFLocaleRef,
+ result: *mut CFRange,
+ ) -> Boolean;
+ pub fn CFStringGetLineBounds(
+ theString: CFStringRef,
+ range: CFRange,
+ lineBeginIndex: *mut CFIndex,
+ lineEndIndex: *mut CFIndex,
+ contentsEndIndex: *mut CFIndex,
+ );
/* Comparing Strings */
- //fn CFStringCompare
- //fn CFStringCompareWithOptions
- //fn CFStringCompareWithOptionsAndLocale
- //fn CFStringHasPrefix
- //fn CFStringHasSuffix
+ pub fn CFStringCompare(
+ theString1: CFStringRef,
+ theString2: CFStringRef,
+ compareOptions: CFStringCompareFlags,
+ ) -> CFComparisonResult;
+ pub fn CFStringCompareWithOptions(
+ theString1: CFStringRef,
+ theString2: CFStringRef,
+ rangeToCompare: CFRange,
+ compareOptions: CFStringCompareFlags,
+ ) -> CFComparisonResult;
+ pub fn CFStringCompareWithOptionsAndLocale(
+ theString1: CFStringRef,
+ theString2: CFStringRef,
+ rangeToCompare: CFRange,
+ compareOptions: CFStringCompareFlags,
+ locale: CFLocaleRef,
+ ) -> CFComparisonResult;
+ pub fn CFStringHasPrefix(theString: CFStringRef, prefix: CFStringRef) -> Boolean;
+ pub fn CFStringHasSuffix(theString: CFStringRef, suffix: CFStringRef) -> Boolean;
/* Accessing Characters */
- //fn CFStringCreateExternalRepresentation
- pub fn CFStringGetBytes(theString: CFStringRef,
- range: CFRange,
- encoding: CFStringEncoding,
- lossByte: u8,
- isExternalRepresentation: Boolean,
- buffer: *mut u8,
- maxBufLen: CFIndex,
- usedBufLen: *mut CFIndex)
- -> CFIndex;
- //fn CFStringGetCharacterAtIndex
- //fn CFStringGetCharacters
- //fn CFStringGetCharactersPtr
- //fn CFStringGetCharacterFromInlineBuffer
- pub fn CFStringGetCString(theString: CFStringRef,
- buffer: *mut c_char,
- bufferSize: CFIndex,
- encoding: CFStringEncoding)
- -> Boolean;
- pub fn CFStringGetCStringPtr(theString: CFStringRef,
- encoding: CFStringEncoding)
- -> *const c_char;
+ pub fn CFStringCreateExternalRepresentation(
+ alloc: CFAllocatorRef,
+ theString: CFStringRef,
+ encoding: CFStringEncoding,
+ lossByte: UInt8,
+ ) -> CFDataRef;
+ pub fn CFStringGetBytes(
+ theString: CFStringRef,
+ range: CFRange,
+ encoding: CFStringEncoding,
+ lossByte: UInt8,
+ isExternalRepresentation: Boolean,
+ buffer: *mut UInt8,
+ maxBufLen: CFIndex,
+ usedBufLen: *mut CFIndex,
+ ) -> CFIndex;
+ pub fn CFStringGetCharacterAtIndex(theString: CFStringRef, idx: CFIndex) -> UniChar;
+ pub fn CFStringGetCharacters(theString: CFStringRef, range: CFRange, buffer: *mut UniChar);
+ pub fn CFStringGetCharactersPtr(theString: CFStringRef) -> *const UniChar;
+ pub fn CFStringGetCString(
+ theString: CFStringRef,
+ buffer: *mut c_char,
+ bufferSize: CFIndex,
+ encoding: CFStringEncoding,
+ ) -> Boolean;
+ pub fn CFStringGetCStringPtr(
+ theString: CFStringRef,
+ encoding: CFStringEncoding,
+ ) -> *const c_char;
pub fn CFStringGetLength(theString: CFStringRef) -> CFIndex;
- //fn CFStringGetPascalString
- //fn CFStringGetPascalStringPtr
- //fn CFStringGetRangeOfComposedCharactersAtIndex
- //fn CFStringInitInlineBuffer
+ pub fn CFStringGetPascalString(
+ theString: CFStringRef,
+ buffer: StringPtr,
+ bufferSize: CFIndex,
+ encoding: CFStringEncoding,
+ ) -> Boolean;
+ pub fn CFStringGetPascalStringPtr(
+ theString: CFStringRef,
+ encoding: CFStringEncoding,
+ ) -> ConstStringPtr;
+ pub fn CFStringGetRangeOfComposedCharactersAtIndex(
+ theString: CFStringRef,
+ theIndex: CFIndex,
+ ) -> CFRange;
/* Working With Hyphenation */
- //fn CFStringGetHyphenationLocationBeforeIndex
- //fn CFStringIsHyphenationAvailableForLocale
+ pub fn CFStringGetHyphenationLocationBeforeIndex(
+ string: CFStringRef,
+ location: CFIndex,
+ limitRange: CFRange,
+ options: CFOptionFlags,
+ locale: CFLocaleRef,
+ character: *mut UTF32Char,
+ ) -> CFIndex;
+ pub fn CFStringIsHyphenationAvailableForLocale(locale: CFLocaleRef) -> Boolean;
/* Working With Encodings */
- //fn CFStringConvertEncodingToIANACharSetName
- //fn CFStringConvertEncodingToNSStringEncoding
- //fn CFStringConvertEncodingToWindowsCodepage
- //fn CFStringConvertIANACharSetNameToEncoding
- //fn CFStringConvertNSStringEncodingToEncoding
- //fn CFStringConvertWindowsCodepageToEncoding
- //fn CFStringGetFastestEncoding
- //fn CFStringGetListOfAvailableEncodings
- //fn CFStringGetMaximumSizeForEncoding
- //fn CFStringGetMostCompatibleMacStringEncoding
- //fn CFStringGetNameOfEncoding
- //fn CFStringGetSmallestEncoding
- //fn CFStringGetSystemEncoding
- //fn CFStringIsEncodingAvailable
+ pub fn CFStringConvertEncodingToIANACharSetName(encoding: CFStringEncoding) -> CFStringRef;
+ pub fn CFStringConvertEncodingToNSStringEncoding(encoding: CFStringEncoding) -> c_ulong;
+ pub fn CFStringConvertEncodingToWindowsCodepage(encoding: CFStringEncoding) -> UInt32;
+ pub fn CFStringConvertIANACharSetNameToEncoding(theString: CFStringRef) -> CFStringEncoding;
+ pub fn CFStringConvertNSStringEncodingToEncoding(encoding: c_ulong) -> CFStringEncoding;
+ pub fn CFStringConvertWindowsCodepageToEncoding(codepage: UInt32) -> CFStringEncoding;
+ pub fn CFStringGetFastestEncoding(theString: CFStringRef) -> CFStringEncoding;
+ pub fn CFStringGetListOfAvailableEncodings() -> *const CFStringEncoding;
+ pub fn CFStringGetMaximumSizeForEncoding(
+ length: CFIndex,
+ encoding: CFStringEncoding,
+ ) -> CFIndex;
+ pub fn CFStringGetMostCompatibleMacStringEncoding(
+ encoding: CFStringEncoding,
+ ) -> CFStringEncoding;
+ pub fn CFStringGetNameOfEncoding(encoding: CFStringEncoding) -> CFStringRef;
+ pub fn CFStringGetSmallestEncoding(theString: CFStringRef) -> CFStringEncoding;
+ pub fn CFStringGetSystemEncoding() -> CFStringEncoding;
+ pub fn CFStringIsEncodingAvailable(encoding: CFStringEncoding) -> Boolean;
/* Getting Numeric Values */
- //fn CFStringGetDoubleValue
- //fn CFStringGetIntValue
+ pub fn CFStringGetDoubleValue(str: CFStringRef) -> c_double;
+ pub fn CFStringGetIntValue(str: CFStringRef) -> SInt32;
/* Getting String Properties */
- //fn CFShowStr
+ pub fn CFShowStr(str: CFStringRef);
pub fn CFStringGetTypeID() -> CFTypeID;
/* String File System Representations */
- //fn CFStringCreateWithFileSystemRepresentation
- //fn CFStringGetFileSystemRepresentation
- //fn CFStringGetMaximumSizeOfFileSystemRepresentation
+ pub fn CFStringCreateWithFileSystemRepresentation(
+ alloc: CFAllocatorRef,
+ buffer: *const c_char,
+ ) -> CFStringRef;
+ pub fn CFStringGetFileSystemRepresentation(
+ string: CFStringRef,
+ buffer: *mut c_char,
+ maxBufLen: CFIndex,
+ ) -> Boolean;
+ pub fn CFStringGetMaximumSizeOfFileSystemRepresentation(string: CFStringRef) -> CFIndex;
/* Getting Paragraph Bounds */
- //fn CFStringGetParagraphBounds
+ pub fn CFStringGetParagraphBounds(
+ string: CFStringRef,
+ range: CFRange,
+ parBeginIndex: *mut CFIndex,
+ parEndIndex: *mut CFIndex,
+ contentsEndIndex: *mut CFIndex,
+ );
- /* Managing Surrogates */
- //fn CFStringGetLongCharacterForSurrogatePair
- //fn CFStringGetSurrogatePairForLongCharacter
- //fn CFStringIsSurrogateHighCharacter
- //fn CFStringIsSurrogateLowCharacter
+ /* CFMutableString */
+ /* CFMutableString Miscellaneous Functions */
+ pub fn CFStringAppend(theString: CFMutableStringRef, appendedString: CFStringRef);
+ pub fn CFStringAppendCharacters(
+ theString: CFMutableStringRef,
+ chars: *const UniChar,
+ numChars: CFIndex,
+ );
+ pub fn CFStringAppendCString(
+ theString: CFMutableStringRef,
+ cStr: *const c_char,
+ encoding: CFStringEncoding,
+ );
+ pub fn CFStringAppendFormat(
+ theString: CFMutableStringRef,
+ formatOptions: CFDictionaryRef,
+ format: CFStringRef,
+ ...
+ );
+ //pub fn CFStringAppendFormatAndArguments(theString: CFMutableStringRef, formatOptions: CFDictionaryRef, format: CFStringRef, arguments: va_list);
+ pub fn CFStringAppendPascalString(
+ theString: CFMutableStringRef,
+ pStr: ConstStr255Param,
+ encoding: CFStringEncoding,
+ );
+ pub fn CFStringCapitalize(theString: CFMutableStringRef, locale: CFLocaleRef);
+ pub fn CFStringCreateMutable(alloc: CFAllocatorRef, maxLength: CFIndex) -> CFMutableStringRef;
+ pub fn CFStringCreateMutableCopy(
+ alloc: CFAllocatorRef,
+ maxLength: CFIndex,
+ theString: CFStringRef,
+ ) -> CFMutableStringRef;
+ pub fn CFStringCreateMutableWithExternalCharactersNoCopy(
+ alloc: CFAllocatorRef,
+ chars: *mut UniChar,
+ numChars: CFIndex,
+ capacity: CFIndex,
+ externalCharactersAllocator: CFAllocatorRef,
+ ) -> CFMutableStringRef;
+ pub fn CFStringDelete(theString: CFMutableStringRef, range: CFRange);
+ pub fn CFStringFindAndReplace(
+ theString: CFMutableStringRef,
+ stringToFind: CFStringRef,
+ replacementString: CFStringRef,
+ rangeToSearch: CFRange,
+ compareOptions: CFStringCompareFlags,
+ ) -> CFIndex;
+ pub fn CFStringFold(
+ theString: CFMutableStringRef,
+ theFlags: CFStringCompareFlags,
+ theLocale: CFLocaleRef,
+ );
+ pub fn CFStringInsert(str: CFMutableStringRef, idx: CFIndex, insertedStr: CFStringRef);
+ pub fn CFStringLowercase(theString: CFMutableStringRef, locale: CFLocaleRef);
+ pub fn CFStringNormalize(theString: CFMutableStringRef, theForm: CFStringNormalizationForm);
+ pub fn CFStringPad(
+ theString: CFMutableStringRef,
+ padString: CFStringRef,
+ length: CFIndex,
+ indexIntoPad: CFIndex,
+ );
+ pub fn CFStringReplace(theString: CFMutableStringRef, range: CFRange, replacement: CFStringRef);
+ pub fn CFStringReplaceAll(theString: CFMutableStringRef, replacement: CFStringRef);
+ pub fn CFStringSetExternalCharactersNoCopy(
+ theString: CFMutableStringRef,
+ chars: *mut UniChar,
+ length: CFIndex,
+ capacity: CFIndex,
+ );
+ pub fn CFStringTransform(
+ string: CFMutableStringRef,
+ range: *mut CFRange,
+ transform: CFStringRef,
+ reverse: Boolean,
+ ) -> Boolean;
+ pub fn CFStringTrim(theString: CFMutableStringRef, trimString: CFStringRef);
+ pub fn CFStringTrimWhitespace(theString: CFMutableStringRef);
+ pub fn CFStringUppercase(theString: CFMutableStringRef, locale: CFLocaleRef);
}
diff --git a/vendor/core-foundation-sys/src/string_tokenizer.rs b/vendor/core-foundation-sys/src/string_tokenizer.rs
new file mode 100644
index 000000000..b23d6a2d3
--- /dev/null
+++ b/vendor/core-foundation-sys/src/string_tokenizer.rs
@@ -0,0 +1,91 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::c_void;
+
+use crate::array::CFMutableArrayRef;
+use crate::base::{CFAllocatorRef, CFIndex, CFOptionFlags, CFRange, CFTypeID, CFTypeRef};
+use crate::locale::CFLocaleRef;
+use crate::string::CFStringRef;
+
+#[repr(C)]
+pub struct __CFStringTokenizer(c_void);
+pub type CFStringTokenizerRef = *mut __CFStringTokenizer;
+
+pub type CFStringTokenizerTokenType = CFOptionFlags;
+
+pub const kCFStringTokenizerTokenNone: CFStringTokenizerTokenType = 0;
+pub const kCFStringTokenizerTokenNormal: CFStringTokenizerTokenType = 1 << 0;
+pub const kCFStringTokenizerTokenHasSubTokensMask: CFStringTokenizerTokenType = 1 << 1;
+pub const kCFStringTokenizerTokenHasDerivedSubTokensMask: CFStringTokenizerTokenType = 1 << 2;
+pub const kCFStringTokenizerTokenHasHasNumbersMask: CFStringTokenizerTokenType = 1 << 3;
+pub const kCFStringTokenizerTokenHasNonLettersMask: CFStringTokenizerTokenType = 1 << 4;
+pub const kCFStringTokenizerTokenIsCJWordMask: CFStringTokenizerTokenType = 1 << 5;
+
+/* Tokenization Modifiers */
+pub const kCFStringTokenizerUnitWord: CFOptionFlags = 0;
+pub const kCFStringTokenizerUnitSentence: CFOptionFlags = 1;
+pub const kCFStringTokenizerUnitParagraph: CFOptionFlags = 2;
+pub const kCFStringTokenizerUnitLineBreak: CFOptionFlags = 3;
+pub const kCFStringTokenizerUnitWordBoundary: CFOptionFlags = 4;
+pub const kCFStringTokenizerAttributeLatinTranscription: CFOptionFlags = 1 << 16;
+pub const kCFStringTokenizerAttributeLanguage: CFOptionFlags = 1 << 17;
+
+extern "C" {
+ /*
+ * CFStringTokenizer.h
+ */
+
+ /* Creating a Tokenizer */
+ pub fn CFStringTokenizerCreate(
+ alloc: CFAllocatorRef,
+ string: CFStringRef,
+ range: CFRange,
+ options: CFOptionFlags,
+ locale: CFLocaleRef,
+ ) -> CFStringTokenizerRef;
+
+ /* Setting the String */
+ pub fn CFStringTokenizerSetString(
+ tokenizer: CFStringTokenizerRef,
+ string: CFStringRef,
+ range: CFRange,
+ );
+
+ /* Changing the Location */
+ pub fn CFStringTokenizerAdvanceToNextToken(
+ tokenizer: CFStringTokenizerRef,
+ ) -> CFStringTokenizerTokenType;
+ pub fn CFStringTokenizerGoToTokenAtIndex(
+ tokenizer: CFStringTokenizerRef,
+ index: CFIndex,
+ ) -> CFStringTokenizerTokenType;
+
+ /* Getting Information About the Current Token */
+ pub fn CFStringTokenizerCopyCurrentTokenAttribute(
+ tokenizer: CFStringTokenizerRef,
+ attribute: CFOptionFlags,
+ ) -> CFTypeRef;
+ pub fn CFStringTokenizerGetCurrentTokenRange(tokenizer: CFStringTokenizerRef) -> CFRange;
+ pub fn CFStringTokenizerGetCurrentSubTokens(
+ tokenizer: CFStringTokenizerRef,
+ ranges: *mut CFRange,
+ maxRangeLength: CFIndex,
+ derivedSubTokens: CFMutableArrayRef,
+ ) -> CFIndex;
+
+ /* Identifying a Language */
+ pub fn CFStringTokenizerCopyBestStringLanguage(
+ string: CFStringRef,
+ range: CFRange,
+ ) -> CFStringRef;
+
+ /* Getting the CFStringTokenizer Type ID */
+ pub fn CFStringTokenizerGetTypeID() -> CFTypeID;
+}
diff --git a/vendor/core-foundation-sys/src/timezone.rs b/vendor/core-foundation-sys/src/timezone.rs
index 0b279db18..076062a49 100644
--- a/vendor/core-foundation-sys/src/timezone.rs
+++ b/vendor/core-foundation-sys/src/timezone.rs
@@ -9,21 +9,83 @@
use std::os::raw::c_void;
-use base::{CFAllocatorRef, CFTypeID};
-use date::{CFTimeInterval, CFAbsoluteTime};
-use string::CFStringRef;
+use crate::array::CFArrayRef;
+use crate::base::{Boolean, CFAllocatorRef, CFIndex, CFTypeID};
+use crate::data::CFDataRef;
+use crate::date::{CFAbsoluteTime, CFTimeInterval};
+use crate::dictionary::CFDictionaryRef;
+use crate::locale::CFLocaleRef;
+use crate::notification_center::CFNotificationName;
+use crate::string::CFStringRef;
#[repr(C)]
pub struct __CFTimeZone(c_void);
pub type CFTimeZoneRef = *const __CFTimeZone;
+pub type CFTimeZoneNameStyle = CFIndex;
-extern {
- pub fn CFTimeZoneCopySystem() -> CFTimeZoneRef;
+/* Constants to specify styles for time zone names */
+pub const kCFTimeZoneNameStyleStandard: CFTimeZoneNameStyle = 0;
+pub const kCFTimeZoneNameStyleShortStandard: CFTimeZoneNameStyle = 1;
+pub const kCFTimeZoneNameStyleDaylightSaving: CFTimeZoneNameStyle = 2;
+pub const kCFTimeZoneNameStyleShortDaylightSaving: CFTimeZoneNameStyle = 3;
+pub const kCFTimeZoneNameStyleGeneric: CFTimeZoneNameStyle = 4;
+pub const kCFTimeZoneNameStyleShortGeneric: CFTimeZoneNameStyle = 5;
+
+extern "C" {
+ /*
+ * CFTimeZone.h
+ */
+
+ pub static kCFTimeZoneSystemTimeZoneDidChangeNotification: CFNotificationName;
+
+ /* Creating a Time Zone */
+ pub fn CFTimeZoneCreate(
+ allocator: CFAllocatorRef,
+ name: CFStringRef,
+ data: CFDataRef,
+ ) -> CFTimeZoneRef;
+ pub fn CFTimeZoneCreateWithName(
+ allocator: CFAllocatorRef,
+ name: CFStringRef,
+ tryAbbrev: Boolean,
+ ) -> CFTimeZoneRef;
+ pub fn CFTimeZoneCreateWithTimeIntervalFromGMT(
+ allocator: CFAllocatorRef,
+ interval: CFTimeInterval,
+ ) -> CFTimeZoneRef;
+
+ /* System and Default Time Zones and Information */
+ pub fn CFTimeZoneCopyAbbreviationDictionary() -> CFDictionaryRef;
+ pub fn CFTimeZoneCopyAbbreviation(tz: CFTimeZoneRef, at: CFAbsoluteTime) -> CFStringRef;
pub fn CFTimeZoneCopyDefault() -> CFTimeZoneRef;
- pub fn CFTimeZoneCreateWithTimeIntervalFromGMT(allocator: CFAllocatorRef, interval: CFTimeInterval) -> CFTimeZoneRef;
+ pub fn CFTimeZoneCopySystem() -> CFTimeZoneRef;
+ pub fn CFTimeZoneSetDefault(tz: CFTimeZoneRef);
+ pub fn CFTimeZoneCopyKnownNames() -> CFArrayRef;
+ pub fn CFTimeZoneResetSystem();
+ pub fn CFTimeZoneSetAbbreviationDictionary(dict: CFDictionaryRef);
+
+ /* Getting Information About Time Zones */
+ pub fn CFTimeZoneGetName(tz: CFTimeZoneRef) -> CFStringRef;
+ pub fn CFTimeZoneCopyLocalizedName(
+ tz: CFTimeZoneRef,
+ style: CFTimeZoneNameStyle,
+ locale: CFLocaleRef,
+ ) -> CFStringRef;
pub fn CFTimeZoneGetSecondsFromGMT(tz: CFTimeZoneRef, time: CFAbsoluteTime) -> CFTimeInterval;
+ pub fn CFTimeZoneGetData(tz: CFTimeZoneRef) -> CFDataRef;
+ /* Getting Daylight Savings Time Information */
+ pub fn CFTimeZoneIsDaylightSavingTime(tz: CFTimeZoneRef, at: CFAbsoluteTime) -> Boolean;
+ pub fn CFTimeZoneGetDaylightSavingTimeOffset(
+ tz: CFTimeZoneRef,
+ at: CFAbsoluteTime,
+ ) -> CFTimeInterval;
+ pub fn CFTimeZoneGetNextDaylightSavingTimeTransition(
+ tz: CFTimeZoneRef,
+ at: CFAbsoluteTime,
+ ) -> CFAbsoluteTime;
+
+ /* Getting the CFTimeZone Type ID */
pub fn CFTimeZoneGetTypeID() -> CFTypeID;
- pub fn CFTimeZoneGetName(tz: CFTimeZoneRef) -> CFStringRef;
}
diff --git a/vendor/core-foundation-sys/src/tree.rs b/vendor/core-foundation-sys/src/tree.rs
new file mode 100644
index 000000000..da6fdd607
--- /dev/null
+++ b/vendor/core-foundation-sys/src/tree.rs
@@ -0,0 +1,74 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::c_void;
+
+use crate::base::{CFAllocatorRef, CFComparatorFunction, CFIndex, CFTypeID};
+use crate::string::CFStringRef;
+
+#[repr(C)]
+pub struct __CFTree(c_void);
+pub type CFTreeRef = *mut __CFTree;
+
+pub type CFTreeRetainCallBack = extern "C" fn(info: *const c_void) -> *const c_void;
+pub type CFTreeReleaseCallBack = extern "C" fn(info: *const c_void);
+pub type CFTreeCopyDescriptionCallBack = extern "C" fn(info: *const c_void) -> CFStringRef;
+pub type CFTreeApplierFunction = extern "C" fn(value: *const c_void, context: *mut c_void);
+
+#[repr(C)]
+pub struct CFTreeContext {
+ pub version: CFIndex,
+ pub info: *mut c_void,
+ pub retain: CFTreeRetainCallBack,
+ pub release: CFTreeReleaseCallBack,
+ pub copyDescription: CFTreeCopyDescriptionCallBack,
+}
+
+extern "C" {
+ /*
+ * CFTree.h
+ */
+ /* Creating Trees */
+ pub fn CFTreeCreate(allocator: CFAllocatorRef, context: *const CFTreeContext) -> CFTreeRef;
+
+ /* Modifying a Tree */
+ pub fn CFTreeAppendChild(tree: CFTreeRef, newChild: CFTreeRef);
+ pub fn CFTreeInsertSibling(tree: CFTreeRef, newSibling: CFTreeRef);
+ pub fn CFTreeRemoveAllChildren(tree: CFTreeRef);
+ pub fn CFTreePrependChild(tree: CFTreeRef, newChild: CFTreeRef);
+ pub fn CFTreeRemove(tree: CFTreeRef);
+ pub fn CFTreeSetContext(tree: CFTreeRef, context: *const CFTreeContext);
+
+ /* Sorting a Tree */
+ pub fn CFTreeSortChildren(
+ tree: CFTreeRef,
+ comparator: CFComparatorFunction,
+ context: *mut c_void,
+ );
+
+ /* Examining a Tree */
+ pub fn CFTreeFindRoot(tree: CFTreeRef) -> CFTreeRef;
+ pub fn CFTreeGetChildAtIndex(tree: CFTreeRef, idx: CFIndex) -> CFTreeRef;
+ pub fn CFTreeGetChildCount(tree: CFTreeRef) -> CFIndex;
+ pub fn CFTreeGetChildren(tree: CFTreeRef, children: *mut CFTreeRef);
+ pub fn CFTreeGetContext(tree: CFTreeRef, context: *mut CFTreeContext);
+ pub fn CFTreeGetFirstChild(tree: CFTreeRef) -> CFTreeRef;
+ pub fn CFTreeGetNextSibling(tree: CFTreeRef) -> CFTreeRef;
+ pub fn CFTreeGetParent(tree: CFTreeRef) -> CFTreeRef;
+
+ /* Performing an Operation on Tree Elements */
+ pub fn CFTreeApplyFunctionToChildren(
+ tree: CFTreeRef,
+ applier: CFTreeApplierFunction,
+ context: *mut c_void,
+ );
+
+ /* Getting the Tree Type ID */
+ pub fn CFTreeGetTypeID() -> CFTypeID;
+}
diff --git a/vendor/core-foundation-sys/src/url.rs b/vendor/core-foundation-sys/src/url.rs
index 08e7bcd9f..2274d3608 100644
--- a/vendor/core-foundation-sys/src/url.rs
+++ b/vendor/core-foundation-sys/src/url.rs
@@ -9,12 +9,14 @@
use std::os::raw::c_void;
-use base::{CFOptionFlags, CFIndex, CFAllocatorRef, Boolean, CFTypeID, CFTypeRef, SInt32};
-use data::CFDataRef;
-use array::CFArrayRef;
-use dictionary::CFDictionaryRef;
-use string::{CFStringRef, CFStringEncoding};
-use error::CFErrorRef;
+use crate::array::CFArrayRef;
+use crate::base::{
+ Boolean, CFAllocatorRef, CFIndex, CFOptionFlags, CFRange, CFTypeID, CFTypeRef, SInt32,
+};
+use crate::data::CFDataRef;
+use crate::dictionary::CFDictionaryRef;
+use crate::error::CFErrorRef;
+use crate::string::{CFStringEncoding, CFStringRef};
#[repr(C)]
pub struct __CFURL(c_void);
@@ -28,95 +30,330 @@ pub type CFURLBookmarkFileCreationOptions = CFOptionFlags;
pub type CFURLPathStyle = CFIndex;
/* typedef CF_ENUM(CFIndex, CFURLPathStyle) */
-pub const kCFURLPOSIXPathStyle: CFURLPathStyle = 0;
-pub const kCFURLHFSPathStyle: CFURLPathStyle = 1;
+pub const kCFURLPOSIXPathStyle: CFURLPathStyle = 0;
+pub const kCFURLHFSPathStyle: CFURLPathStyle = 1;
pub const kCFURLWindowsPathStyle: CFURLPathStyle = 2;
-pub static kCFURLBookmarkCreationPreferFileIDResolutionMask: CFURLBookmarkCreationOptions =
- (1u32 << 8) as usize;
+/* Bookmark Data Creation Options */
pub static kCFURLBookmarkCreationMinimalBookmarkMask: CFURLBookmarkCreationOptions =
(1u32 << 9) as usize;
pub static kCFURLBookmarkCreationSuitableForBookmarkFile: CFURLBookmarkCreationOptions =
(1u32 << 10) as usize;
+
+#[cfg(target_os = "macos")]
pub static kCFURLBookmarkCreationWithSecurityScope: CFURLBookmarkCreationOptions =
(1u32 << 11) as usize;
+
+#[cfg(target_os = "macos")]
pub static kCFURLBookmarkCreationSecurityScopeAllowOnlyReadAccess: CFURLBookmarkCreationOptions =
(1u32 << 12) as usize;
-// TODO: there are a lot of missing keys and constants. Add if you are bored or need them.
+pub static kCFURLBookmarkCreationWithoutImplicitSecurityScope: CFURLBookmarkCreationOptions =
+ (1u32 << 29) as usize;
+
+pub static kCFURLBookmarkCreationPreferFileIDResolutionMask: CFURLBookmarkCreationOptions =
+ (1u32 << 8) as usize; // deprecated
+
+/* The types of components in a URL. */
+pub type CFURLComponentType = CFIndex;
+pub const kCFURLComponentScheme: CFIndex = 1;
+pub const kCFURLComponentNetLocation: CFIndex = 2;
+pub const kCFURLComponentPath: CFIndex = 3;
+pub const kCFURLComponentResourceSpecifier: CFIndex = 4;
+pub const kCFURLComponentUser: CFIndex = 5;
+pub const kCFURLComponentPassword: CFIndex = 6;
+pub const kCFURLComponentUserInfo: CFIndex = 7;
+pub const kCFURLComponentHost: CFIndex = 8;
+pub const kCFURLComponentPort: CFIndex = 9;
+pub const kCFURLComponentParameterString: CFIndex = 10;
+pub const kCFURLComponentQuery: CFIndex = 11;
+pub const kCFURLComponentFragment: CFIndex = 12;
-extern {
+/* Bookmark Data Resolution Options */
+pub const kCFURLBookmarkResolutionWithoutUIMask: CFURLBookmarkResolutionOptions =
+ (1u32 << 8) as usize;
+pub const kCFURLBookmarkResolutionWithoutMountingMask: CFURLBookmarkResolutionOptions =
+ (1u32 << 9) as usize;
+#[cfg(target_os = "macos")]
+pub const kCFURLBookmarkResolutionWithSecurityScope: CFURLBookmarkResolutionOptions =
+ (1u32 << 10) as usize;
+//pub const kCFURLBookmarkResolutionWithoutImplicitStartAccessing: CFURLBookmarkResolutionOptions = ( 1u32 << 15 ) as usize; // macos(11.2)+
+pub const kCFBookmarkResolutionWithoutUIMask: CFURLBookmarkResolutionOptions = (1u32 << 8) as usize;
+pub const kCFBookmarkResolutionWithoutMountingMask: CFURLBookmarkResolutionOptions =
+ (1u32 << 9) as usize;
+
+extern "C" {
/*
* CFURL.h
*/
/* Common File System Resource Keys */
- pub static kCFURLAttributeModificationDateKey: CFStringRef;
- pub static kCFURLContentAccessDateKey: CFStringRef;
- pub static kCFURLContentModificationDateKey: CFStringRef;
- pub static kCFURLCreationDateKey: CFStringRef;
- pub static kCFURLFileResourceIdentifierKey: CFStringRef;
- pub static kCFURLFileSecurityKey: CFStringRef;
- pub static kCFURLHasHiddenExtensionKey: CFStringRef;
- pub static kCFURLIsDirectoryKey: CFStringRef;
- pub static kCFURLIsExecutableKey: CFStringRef;
- pub static kCFURLIsHiddenKey: CFStringRef;
- pub static kCFURLIsPackageKey: CFStringRef;
- pub static kCFURLIsReadableKey: CFStringRef;
+ pub static kCFURLNameKey: CFStringRef;
+ pub static kCFURLLocalizedNameKey: CFStringRef;
pub static kCFURLIsRegularFileKey: CFStringRef;
+ pub static kCFURLIsDirectoryKey: CFStringRef;
pub static kCFURLIsSymbolicLinkKey: CFStringRef;
+ pub static kCFURLIsVolumeKey: CFStringRef;
+ pub static kCFURLIsPackageKey: CFStringRef;
+ pub static kCFURLIsApplicationKey: CFStringRef;
+ // pub static kCFURLApplicationIsScriptableKey: CFStringRef; //macos(10.11)+
+
pub static kCFURLIsSystemImmutableKey: CFStringRef;
pub static kCFURLIsUserImmutableKey: CFStringRef;
- pub static kCFURLIsVolumeKey: CFStringRef;
- pub static kCFURLIsWritableKey: CFStringRef;
- pub static kCFURLLabelNumberKey: CFStringRef;
+ pub static kCFURLIsHiddenKey: CFStringRef;
+ pub static kCFURLHasHiddenExtensionKey: CFStringRef;
+ pub static kCFURLCreationDateKey: CFStringRef;
+ pub static kCFURLContentAccessDateKey: CFStringRef;
+ pub static kCFURLContentModificationDateKey: CFStringRef;
+ pub static kCFURLAttributeModificationDateKey: CFStringRef;
+ // pub static kCFURLFileIdentifierKey: CFStringRef; //macos(13.3)+
+ // pub static kCFURLFileContentIdentifierKey: CFStringRef; //macos(11.0)+
+ // pub static kCFURLMayShareFileContentKey: CFStringRef; //macos(11.0)+
+ // pub static kCFURLMayHaveExtendedAttributesKey: CFStringRef; //macos(11.0)+
+ // pub static kCFURLIsPurgeableKey: CFStringRef; //macos(11.0)+
+ // pub static kCFURLIsSparseKey: CFStringRef; //macos(11.0)+
+
pub static kCFURLLinkCountKey: CFStringRef;
- pub static kCFURLLocalizedLabelKey: CFStringRef;
- pub static kCFURLLocalizedNameKey: CFStringRef;
- pub static kCFURLLocalizedTypeDescriptionKey: CFStringRef;
- pub static kCFURLNameKey: CFStringRef;
pub static kCFURLParentDirectoryURLKey: CFStringRef;
- pub static kCFURLPreferredIOBlockSizeKey: CFStringRef;
- pub static kCFURLTypeIdentifierKey: CFStringRef;
- pub static kCFURLVolumeIdentifierKey: CFStringRef;
pub static kCFURLVolumeURLKey: CFStringRef;
- #[cfg(feature="mac_os_10_8_features")]
+ pub static kCFURLTypeIdentifierKey: CFStringRef; //deprecated
+
+ pub static kCFURLLocalizedTypeDescriptionKey: CFStringRef;
+ pub static kCFURLLabelNumberKey: CFStringRef;
+ pub static kCFURLLabelColorKey: CFStringRef; //deprecated
+ pub static kCFURLLocalizedLabelKey: CFStringRef;
+ pub static kCFURLEffectiveIconKey: CFStringRef; //deprecated
+ pub static kCFURLCustomIconKey: CFStringRef; //deprecated
+
+ pub static kCFURLFileResourceIdentifierKey: CFStringRef;
+ pub static kCFURLVolumeIdentifierKey: CFStringRef;
+ pub static kCFURLPreferredIOBlockSizeKey: CFStringRef;
+ pub static kCFURLIsReadableKey: CFStringRef;
+ pub static kCFURLIsWritableKey: CFStringRef;
+ pub static kCFURLIsExecutableKey: CFStringRef;
+ pub static kCFURLFileSecurityKey: CFStringRef;
+
+ #[cfg(feature = "mac_os_10_8_features")]
#[cfg_attr(feature = "mac_os_10_7_support", linkage = "extern_weak")]
pub static kCFURLIsExcludedFromBackupKey: CFStringRef;
+ // pub static kCFURLTagNamesKey: CFStringRef; //macos(10.9)+
+ #[cfg(feature = "mac_os_10_8_features")]
+ #[cfg_attr(feature = "mac_os_10_7_support", linkage = "extern_weak")]
+ pub static kCFURLPathKey: CFStringRef; // macos(10.8)+
+ pub static kCFURLCanonicalPathKey: CFStringRef; // macos(10.12)+
+
+ pub static kCFURLIsMountTriggerKey: CFStringRef;
+
+ // pub static kCFURLGenerationIdentifierKey: CFStringRef; // macos(10.10)+
+ // pub static kCFURLDocumentIdentifierKey: CFStringRef; // macos(10.10)+
+ // pub static kCFURLAddedToDirectoryDateKey: CFStringRef; // macos(10.10)+
+ // pub static kCFURLQuarantinePropertiesKey: CFStringRef; // macos(10.10)+
+
pub static kCFURLFileResourceTypeKey: CFStringRef;
+ /* File Resource Types. The file system object type values returned for the kCFURLFileResourceTypeKey */
+ pub static kCFURLFileResourceTypeNamedPipe: CFStringRef;
+ pub static kCFURLFileResourceTypeCharacterSpecial: CFStringRef;
+ pub static kCFURLFileResourceTypeDirectory: CFStringRef;
+ pub static kCFURLFileResourceTypeBlockSpecial: CFStringRef;
+ pub static kCFURLFileResourceTypeRegular: CFStringRef;
+ pub static kCFURLFileResourceTypeSymbolicLink: CFStringRef;
+ pub static kCFURLFileResourceTypeSocket: CFStringRef;
+ pub static kCFURLFileResourceTypeUnknown: CFStringRef;
+
+ /* File Property Keys */
+ pub static kCFURLFileSizeKey: CFStringRef;
+ pub static kCFURLFileAllocatedSizeKey: CFStringRef;
+ pub static kCFURLTotalFileSizeKey: CFStringRef;
+ pub static kCFURLTotalFileAllocatedSizeKey: CFStringRef;
+ pub static kCFURLIsAliasFileKey: CFStringRef;
+
+ // pub static kCFURLFileProtectionKey: CFStringRef; // ios(9.0)+
+
+ /* The protection level values returned for the kCFURLFileProtectionKey */
+ // pub static kCFURLFileProtectionNone: CFStringRef; // ios(9.0)+
+ // pub static kCFURLFileProtectionComplete: CFStringRef; // ios(9.0)+
+ // pub static kCFURLFileProtectionCompleteUnlessOpen: CFStringRef; // ios(9.0)+
+ // pub static kCFURLFileProtectionCompleteUntilFirstUserAuthentication: CFStringRef; // ios(9.0)+
+
+ /* Volume Property Keys */
+ pub static kCFURLVolumeLocalizedFormatDescriptionKey: CFStringRef;
+ pub static kCFURLVolumeTotalCapacityKey: CFStringRef;
+ pub static kCFURLVolumeAvailableCapacityKey: CFStringRef;
+ //pub static kCFURLVolumeAvailableCapacityForImportantUsageKey: CFStringRef; //macos(10.13)+
+ //pub static kCFURLVolumeAvailableCapacityForOpportunisticUsageKey: CFStringRef; //macos(10.13)+
+
+ pub static kCFURLVolumeResourceCountKey: CFStringRef;
+ pub static kCFURLVolumeSupportsPersistentIDsKey: CFStringRef;
+ pub static kCFURLVolumeSupportsSymbolicLinksKey: CFStringRef;
+ pub static kCFURLVolumeSupportsHardLinksKey: CFStringRef;
+ pub static kCFURLVolumeSupportsJournalingKey: CFStringRef;
+ pub static kCFURLVolumeIsJournalingKey: CFStringRef;
+ pub static kCFURLVolumeSupportsSparseFilesKey: CFStringRef;
+ pub static kCFURLVolumeSupportsZeroRunsKey: CFStringRef;
+ pub static kCFURLVolumeSupportsCaseSensitiveNamesKey: CFStringRef;
+ pub static kCFURLVolumeSupportsCasePreservedNamesKey: CFStringRef;
+ pub static kCFURLVolumeSupportsRootDirectoryDatesKey: CFStringRef;
+ pub static kCFURLVolumeSupportsVolumeSizesKey: CFStringRef;
+ pub static kCFURLVolumeSupportsRenamingKey: CFStringRef;
+ pub static kCFURLVolumeSupportsAdvisoryFileLockingKey: CFStringRef;
+ pub static kCFURLVolumeSupportsExtendedSecurityKey: CFStringRef;
+ pub static kCFURLVolumeIsBrowsableKey: CFStringRef;
+ pub static kCFURLVolumeMaximumFileSizeKey: CFStringRef;
+ pub static kCFURLVolumeIsEjectableKey: CFStringRef;
+ pub static kCFURLVolumeIsRemovableKey: CFStringRef;
+ pub static kCFURLVolumeIsInternalKey: CFStringRef;
+ pub static kCFURLVolumeIsAutomountedKey: CFStringRef;
+ pub static kCFURLVolumeIsLocalKey: CFStringRef;
+ pub static kCFURLVolumeIsReadOnlyKey: CFStringRef;
+ pub static kCFURLVolumeCreationDateKey: CFStringRef;
+ pub static kCFURLVolumeURLForRemountingKey: CFStringRef;
+ pub static kCFURLVolumeUUIDStringKey: CFStringRef;
+ pub static kCFURLVolumeNameKey: CFStringRef;
+ pub static kCFURLVolumeLocalizedNameKey: CFStringRef;
+ // pub static kCFURLVolumeIsEncryptedKey: CFStringRef; //macos(10.12)+
+ // pub static kCFURLVolumeIsRootFileSystemKey: CFStringRef; //macos(10.12)+
+ // pub static kCFURLVolumeSupportsCompressionKey: CFStringRef; //macos(10.12)+
+ // pub static kCFURLVolumeSupportsFileCloningKey: CFStringRef; //macos(10.12)+
+ // pub static kCFURLVolumeSupportsSwapRenamingKey: CFStringRef; //macos(10.12)+
+ // pub static kCFURLVolumeSupportsExclusiveRenamingKey: CFStringRef; //macos(10.12)+
+ // pub static kCFURLVolumeSupportsImmutableFilesKey: CFStringRef; //macos(10.13)+
+ // pub static kCFURLVolumeSupportsAccessPermissionsKey: CFStringRef; //macos(10.13)+
+ // pub static kCFURLVolumeSupportsFileProtectionKey: CFStringRef; //macos(11.0)+
+ // pub static kCFURLVolumeTypeNameKey: CFStringRef; //macos(13.3)+
+ // pub static kCFURLVolumeSubtypeKey: CFStringRef; //macos(13.3)+
+ // pub static kCFURLVolumeMountFromLocationKey: CFStringRef; //macos(13.3)+
+
+ /* iCloud Constants */
+ pub static kCFURLIsUbiquitousItemKey: CFStringRef;
+ pub static kCFURLUbiquitousItemHasUnresolvedConflictsKey: CFStringRef;
+ pub static kCFURLUbiquitousItemIsDownloadedKey: CFStringRef; // deprecated
+ pub static kCFURLUbiquitousItemIsDownloadingKey: CFStringRef;
+ pub static kCFURLUbiquitousItemIsUploadedKey: CFStringRef;
+ pub static kCFURLUbiquitousItemIsUploadingKey: CFStringRef;
+ pub static kCFURLUbiquitousItemPercentDownloadedKey: CFStringRef; // deprecated
+ pub static kCFURLUbiquitousItemPercentUploadedKey: CFStringRef; // deprecated
+ // pub static kCFURLUbiquitousItemDownloadingStatusKey: CFStringRef; // macos(10.9)+
+ // pub static kCFURLUbiquitousItemDownloadingErrorKey: CFStringRef; // macos(10.9)+
+ // pub static kCFURLUbiquitousItemUploadingErrorKey: CFStringRef; // macos(10.9)+
+ // pub static kCFURLUbiquitousItemIsExcludedFromSyncKey: CFStringRef; // macos(11.3)+
+
+ /* The values returned for kCFURLUbiquitousItemDownloadingStatusKey */
+ // pub static kCFURLUbiquitousItemDownloadingStatusNotDownloaded: CFStringRef; // macos(10.9)+
+ // pub static kCFURLUbiquitousItemDownloadingStatusDownloaded: CFStringRef; // macos(10.9)+
+ // pub static kCFURLUbiquitousItemDownloadingStatusCurrent: CFStringRef; // macos(10.9)+
+
+ /* CFError userInfo Dictionary Keys */
+ pub static kCFURLKeysOfUnsetValuesKey: CFStringRef;
+
/* Creating a CFURL */
pub fn CFURLCopyAbsoluteURL(anURL: CFURLRef) -> CFURLRef;
- pub fn CFURLCreateAbsoluteURLWithBytes(allocator: CFAllocatorRef, relativeURLBytes: *const u8, length: CFIndex, encoding: CFStringEncoding, baseURL: CFURLRef, useCompatibilityMode: Boolean) -> CFURLRef;
- pub fn CFURLCreateByResolvingBookmarkData(allocator: CFAllocatorRef, bookmark: CFDataRef, options: CFURLBookmarkResolutionOptions, relativeToURL: CFURLRef, resourcePropertiesToInclude: CFArrayRef, isStale: *mut Boolean, error: *mut CFErrorRef) -> CFURLRef;
- //fn CFURLCreateCopyAppendingPathComponent
- //fn CFURLCreateCopyAppendingPathExtension
- //fn CFURLCreateCopyDeletingLastPathComponent
- //fn CFURLCreateCopyDeletingPathExtension
- pub fn CFURLCreateFilePathURL(allocator: CFAllocatorRef, url: CFURLRef, error: *mut CFErrorRef) -> CFURLRef;
- //fn CFURLCreateFileReferenceURL
- pub fn CFURLCreateFromFileSystemRepresentation(allocator: CFAllocatorRef, buffer: *const u8, bufLen: CFIndex, isDirectory: Boolean) -> CFURLRef;
- //fn CFURLCreateFromFileSystemRepresentationRelativeToBase
- //fn CFURLCreateFromFSRef
- pub fn CFURLCreateWithBytes(allocator: CFAllocatorRef, URLBytes: *const u8, length: CFIndex, encoding: CFStringEncoding, baseURL: CFURLRef) -> CFURLRef;
- pub fn CFURLCreateWithFileSystemPath(allocator: CFAllocatorRef, filePath: CFStringRef, pathStyle: CFURLPathStyle, isDirectory: Boolean) -> CFURLRef;
- pub fn CFURLCreateWithFileSystemPathRelativeToBase(allocator: CFAllocatorRef, filePath: CFStringRef, pathStyle: CFURLPathStyle, isDirectory: Boolean, baseURL: CFURLRef) -> CFURLRef;
- //fn CFURLCreateWithString(allocator: CFAllocatorRef, urlString: CFStringRef,
- // baseURL: CFURLRef) -> CFURLRef;
+ pub fn CFURLCreateAbsoluteURLWithBytes(
+ allocator: CFAllocatorRef,
+ relativeURLBytes: *const u8,
+ length: CFIndex,
+ encoding: CFStringEncoding,
+ baseURL: CFURLRef,
+ useCompatibilityMode: Boolean,
+ ) -> CFURLRef;
+ pub fn CFURLCreateByResolvingBookmarkData(
+ allocator: CFAllocatorRef,
+ bookmark: CFDataRef,
+ options: CFURLBookmarkResolutionOptions,
+ relativeToURL: CFURLRef,
+ resourcePropertiesToInclude: CFArrayRef,
+ isStale: *mut Boolean,
+ error: *mut CFErrorRef,
+ ) -> CFURLRef;
+ pub fn CFURLCreateCopyAppendingPathComponent(
+ allocator: CFAllocatorRef,
+ url: CFURLRef,
+ pathComponent: CFStringRef,
+ isDirectory: Boolean,
+ ) -> CFURLRef;
+ pub fn CFURLCreateCopyAppendingPathExtension(
+ allocator: CFAllocatorRef,
+ url: CFURLRef,
+ extension: CFStringRef,
+ ) -> CFURLRef;
+ pub fn CFURLCreateCopyDeletingLastPathComponent(
+ allocator: CFAllocatorRef,
+ url: CFURLRef,
+ ) -> CFURLRef;
+ pub fn CFURLCreateCopyDeletingPathExtension(
+ allocator: CFAllocatorRef,
+ url: CFURLRef,
+ ) -> CFURLRef;
+ pub fn CFURLCreateFilePathURL(
+ allocator: CFAllocatorRef,
+ url: CFURLRef,
+ error: *mut CFErrorRef,
+ ) -> CFURLRef;
+ pub fn CFURLCreateFileReferenceURL(
+ allocator: CFAllocatorRef,
+ url: CFURLRef,
+ error: *mut CFErrorRef,
+ ) -> CFURLRef;
+ pub fn CFURLCreateFromFileSystemRepresentation(
+ allocator: CFAllocatorRef,
+ buffer: *const u8,
+ bufLen: CFIndex,
+ isDirectory: Boolean,
+ ) -> CFURLRef;
+ pub fn CFURLCreateFromFileSystemRepresentationRelativeToBase(
+ allocator: CFAllocatorRef,
+ buffer: *const u8,
+ bufLen: CFIndex,
+ isDirectory: Boolean,
+ baseURL: CFURLRef,
+ ) -> CFURLRef;
+ //pub fn CFURLCreateFromFSRef(allocator: CFAllocatorRef, fsRef: *const FSRef) -> CFURLRef
+ pub fn CFURLCreateWithBytes(
+ allocator: CFAllocatorRef,
+ URLBytes: *const u8,
+ length: CFIndex,
+ encoding: CFStringEncoding,
+ baseURL: CFURLRef,
+ ) -> CFURLRef;
+ pub fn CFURLCreateWithFileSystemPath(
+ allocator: CFAllocatorRef,
+ filePath: CFStringRef,
+ pathStyle: CFURLPathStyle,
+ isDirectory: Boolean,
+ ) -> CFURLRef;
+ pub fn CFURLCreateWithFileSystemPathRelativeToBase(
+ allocator: CFAllocatorRef,
+ filePath: CFStringRef,
+ pathStyle: CFURLPathStyle,
+ isDirectory: Boolean,
+ baseURL: CFURLRef,
+ ) -> CFURLRef;
+ pub fn CFURLCreateWithString(
+ allocator: CFAllocatorRef,
+ URLString: CFStringRef,
+ baseURL: CFURLRef,
+ ) -> CFURLRef;
/* Accessing the Parts of a URL */
pub fn CFURLCanBeDecomposed(anURL: CFURLRef) -> Boolean;
pub fn CFURLCopyFileSystemPath(anURL: CFURLRef, pathStyle: CFURLPathStyle) -> CFStringRef;
- pub fn CFURLCopyFragment(anURL: CFURLRef, charactersToLeaveEscaped: CFStringRef) -> CFStringRef;
+ pub fn CFURLCopyFragment(anURL: CFURLRef, charactersToLeaveEscaped: CFStringRef)
+ -> CFStringRef;
pub fn CFURLCopyHostName(anURL: CFURLRef) -> CFStringRef;
pub fn CFURLCopyLastPathComponent(anURL: CFURLRef) -> CFStringRef;
pub fn CFURLCopyNetLocation(anURL: CFURLRef) -> CFStringRef;
- pub fn CFURLCopyParameterString(anURL: CFURLRef, charactersToLeaveEscaped: CFStringRef) -> CFStringRef;
+ pub fn CFURLCopyParameterString(
+ anURL: CFURLRef,
+ charactersToLeaveEscaped: CFStringRef,
+ ) -> CFStringRef; // deprecated
pub fn CFURLCopyPassword(anURL: CFURLRef) -> CFStringRef;
pub fn CFURLCopyPath(anURL: CFURLRef) -> CFStringRef;
pub fn CFURLCopyPathExtension(anURL: CFURLRef) -> CFStringRef;
- pub fn CFURLCopyQueryString(anURL: CFURLRef, charactersToLeaveEscaped: CFStringRef) -> CFStringRef;
+ pub fn CFURLCopyQueryString(
+ anURL: CFURLRef,
+ charactersToLeaveEscaped: CFStringRef,
+ ) -> CFStringRef;
pub fn CFURLCopyResourceSpecifier(anURL: CFURLRef) -> CFStringRef;
pub fn CFURLCopyScheme(anURL: CFURLRef) -> CFStringRef;
pub fn CFURLCopyStrictPath(anURL: CFURLRef, isAbsolute: *mut Boolean) -> CFStringRef;
@@ -125,45 +362,120 @@ extern {
pub fn CFURLHasDirectoryPath(anURL: CFURLRef) -> Boolean;
/* Converting URLs to Other Representations */
- //fn CFURLCreateData(allocator: CFAllocatorRef, url: CFURLRef,
- // encoding: CFStringEncoding, escapeWhitespace: bool) -> CFDataRef;
- //fn CFURLCreateStringByAddingPercentEscapes
- //fn CFURLCreateStringByReplacingPercentEscapes
- //fn CFURLCreateStringByReplacingPercentEscapesUsingEncoding
- pub fn CFURLGetFileSystemRepresentation(anURL: CFURLRef, resolveAgainstBase: Boolean, buffer: *mut u8, maxBufLen: CFIndex) -> Boolean;
-
- //fn CFURLGetFSRef
+ pub fn CFURLCreateData(
+ allocator: CFAllocatorRef,
+ url: CFURLRef,
+ encoding: CFStringEncoding,
+ escapeWhitespace: Boolean,
+ ) -> CFDataRef;
+ pub fn CFURLCreateStringByAddingPercentEscapes(
+ allocator: CFAllocatorRef,
+ originalString: CFStringRef,
+ charactersToLeaveUnescaped: CFStringRef,
+ legalURLCharactersToBeEscaped: CFStringRef,
+ encoding: CFStringEncoding,
+ ) -> CFStringRef; // API_DEPRECATED("Use [NSString stringByAddingPercentEncodingWithAllowedCharacters:] instead, which always uses the recommended UTF-8 encoding, and which encodes for a specific URL component or subcomponent (since each URL component or subcomponent has different rules for what characters are valid).", macos(10.0,10.11), ios(2.0,9.0), watchos(2.0,2.0), tvos(9.0,9.0));
+ pub fn CFURLCreateStringByReplacingPercentEscapes(
+ allocator: CFAllocatorRef,
+ originalString: CFStringRef,
+ charactersToLeaveEscaped: CFStringRef,
+ ) -> CFStringRef;
+ pub fn CFURLCreateStringByReplacingPercentEscapesUsingEncoding(
+ allocator: CFAllocatorRef,
+ origString: CFStringRef,
+ charsToLeaveEscaped: CFStringRef,
+ encoding: CFStringEncoding,
+ ) -> CFStringRef; // deprecated
+ pub fn CFURLGetFileSystemRepresentation(
+ anURL: CFURLRef,
+ resolveAgainstBase: Boolean,
+ buffer: *mut u8,
+ maxBufLen: CFIndex,
+ ) -> Boolean;
+ //pub fn CFURLIsFileReferenceURL(url: CFURLRef) -> Boolean; // macos(10.9)+
+ //pub fn CFURLGetFSRef(url: CFURLRef, fsRef: *mut FSRef) -> Boolean;
pub fn CFURLGetString(anURL: CFURLRef) -> CFStringRef;
/* Getting URL Properties */
- //fn CFURLGetBaseURL(anURL: CFURLRef) -> CFURLRef;
+ pub fn CFURLGetBaseURL(anURL: CFURLRef) -> CFURLRef;
pub fn CFURLGetBytes(anURL: CFURLRef, buffer: *mut u8, bufferLength: CFIndex) -> CFIndex;
- //fn CFURLGetByteRangeForComponent
+ pub fn CFURLGetByteRangeForComponent(
+ url: CFURLRef,
+ component: CFURLComponentType,
+ rangeIncludingSeparators: *mut CFRange,
+ ) -> CFRange;
pub fn CFURLGetTypeID() -> CFTypeID;
- //fn CFURLResourceIsReachable
+ pub fn CFURLResourceIsReachable(url: CFURLRef, error: *mut CFErrorRef) -> Boolean;
/* Getting and Setting File System Resource Properties */
pub fn CFURLClearResourcePropertyCache(url: CFURLRef);
- //fn CFURLClearResourcePropertyCacheForKey
- //fn CFURLCopyResourcePropertiesForKeys
- //fn CFURLCopyResourcePropertyForKey
- pub fn CFURLCreateResourcePropertiesForKeysFromBookmarkData(allocator: CFAllocatorRef, resourcePropertiesToReturn: CFArrayRef, bookmark: CFDataRef) -> CFDictionaryRef;
- pub fn CFURLCreateResourcePropertyForKeyFromBookmarkData(allocator: CFAllocatorRef, resourcePropertyKey: CFStringRef, bookmark: CFDataRef) -> CFTypeRef;
- //fn CFURLSetResourcePropertiesForKeys
- pub fn CFURLSetResourcePropertyForKey(url: CFURLRef, key: CFStringRef, value: CFTypeRef, error: *mut CFErrorRef) -> Boolean;
- //fn CFURLSetTemporaryResourcePropertyForKey
+ pub fn CFURLClearResourcePropertyCacheForKey(url: CFURLRef, key: CFStringRef);
+ pub fn CFURLCopyResourcePropertiesForKeys(
+ url: CFURLRef,
+ keys: CFArrayRef,
+ error: *mut CFErrorRef,
+ ) -> CFDictionaryRef;
+ //pub fn CFURLCopyResourcePropertyForKey(url: CFURLRef, key: CFStringRef, propertyValueTypeRefPtr: *mut c_void, error: *mut CFErrorRef) -> Boolean
+ pub fn CFURLCreateResourcePropertiesForKeysFromBookmarkData(
+ allocator: CFAllocatorRef,
+ resourcePropertiesToReturn: CFArrayRef,
+ bookmark: CFDataRef,
+ ) -> CFDictionaryRef;
+ pub fn CFURLCreateResourcePropertyForKeyFromBookmarkData(
+ allocator: CFAllocatorRef,
+ resourcePropertyKey: CFStringRef,
+ bookmark: CFDataRef,
+ ) -> CFTypeRef;
+ pub fn CFURLSetResourcePropertiesForKeys(
+ url: CFURLRef,
+ keyedPropertyValues: CFDictionaryRef,
+ error: *mut CFErrorRef,
+ ) -> Boolean;
+ pub fn CFURLSetResourcePropertyForKey(
+ url: CFURLRef,
+ key: CFStringRef,
+ value: CFTypeRef,
+ error: *mut CFErrorRef,
+ ) -> Boolean;
+ pub fn CFURLSetTemporaryResourcePropertyForKey(
+ url: CFURLRef,
+ key: CFStringRef,
+ propertyValue: CFTypeRef,
+ );
/* Working with Bookmark Data */
- pub fn CFURLCreateBookmarkData(allocator: CFAllocatorRef, url: CFURLRef, options: CFURLBookmarkCreationOptions, resourcePropertiesToInclude: CFArrayRef, relativeToURL: CFURLRef, error: *mut CFErrorRef) -> CFDataRef;
- pub fn CFURLCreateBookmarkDataFromAliasRecord(allocator: CFAllocatorRef, aliasRecordDataRef: CFDataRef) -> CFDataRef;
- pub fn CFURLCreateBookmarkDataFromFile(allocator: CFAllocatorRef, fileURL: CFURLRef, errorRef: *mut CFErrorRef) -> CFDataRef;
- pub fn CFURLWriteBookmarkDataToFile(bookmarkRef: CFDataRef, fileURL: CFURLRef, options: CFURLBookmarkFileCreationOptions, errorRef: *mut CFErrorRef) -> Boolean;
+ pub fn CFURLCreateBookmarkData(
+ allocator: CFAllocatorRef,
+ url: CFURLRef,
+ options: CFURLBookmarkCreationOptions,
+ resourcePropertiesToInclude: CFArrayRef,
+ relativeToURL: CFURLRef,
+ error: *mut CFErrorRef,
+ ) -> CFDataRef;
+
+ #[cfg(target_os = "macos")]
+ pub fn CFURLCreateBookmarkDataFromAliasRecord(
+ allocator: CFAllocatorRef,
+ aliasRecordDataRef: CFDataRef,
+ ) -> CFDataRef; // deprecated
+
+ pub fn CFURLCreateBookmarkDataFromFile(
+ allocator: CFAllocatorRef,
+ fileURL: CFURLRef,
+ errorRef: *mut CFErrorRef,
+ ) -> CFDataRef;
+ pub fn CFURLWriteBookmarkDataToFile(
+ bookmarkRef: CFDataRef,
+ fileURL: CFURLRef,
+ options: CFURLBookmarkFileCreationOptions,
+ errorRef: *mut CFErrorRef,
+ ) -> Boolean;
pub fn CFURLStartAccessingSecurityScopedResource(url: CFURLRef) -> Boolean;
pub fn CFURLStopAccessingSecurityScopedResource(url: CFURLRef);
}
#[test]
-#[cfg(feature="mac_os_10_8_features")]
+#[cfg(feature = "mac_os_10_8_features")]
fn can_see_excluded_from_backup_key() {
let _ = unsafe { kCFURLIsExcludedFromBackupKey };
}
diff --git a/vendor/core-foundation-sys/src/url_enumerator.rs b/vendor/core-foundation-sys/src/url_enumerator.rs
new file mode 100644
index 000000000..71b74beb5
--- /dev/null
+++ b/vendor/core-foundation-sys/src/url_enumerator.rs
@@ -0,0 +1,62 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::c_void;
+
+use crate::array::CFArrayRef;
+use crate::base::{Boolean, CFAllocatorRef, CFIndex, CFOptionFlags, CFTypeID};
+use crate::error::CFErrorRef;
+use crate::url::CFURLRef;
+
+#[repr(C)]
+pub struct __CFURLEnumerator(c_void);
+
+pub type CFURLEnumeratorRef = *mut __CFURLEnumerator;
+
+pub type CFURLEnumeratorOptions = CFOptionFlags;
+pub const kCFURLEnumeratorDefaultBehavior: CFURLEnumeratorOptions = 0;
+pub const kCFURLEnumeratorDescendRecursively: CFURLEnumeratorOptions = 1 << 0;
+pub const kCFURLEnumeratorSkipInvisibles: CFURLEnumeratorOptions = 1 << 1;
+pub const kCFURLEnumeratorGenerateFileReferenceURLs: CFURLEnumeratorOptions = 1 << 2;
+pub const kCFURLEnumeratorSkipPackageContents: CFURLEnumeratorOptions = 1 << 3;
+pub const kCFURLEnumeratorIncludeDirectoriesPreOrder: CFURLEnumeratorOptions = 1 << 4;
+pub const kCFURLEnumeratorIncludeDirectoriesPostOrder: CFURLEnumeratorOptions = 1 << 5;
+//pub const kCFURLEnumeratorGenerateRelativePathURLs = 1UL << 6; // macos(10.15)+
+
+pub type CFURLEnumeratorResult = CFIndex;
+pub const kCFURLEnumeratorSuccess: CFURLEnumeratorOptions = 1;
+pub const kCFURLEnumeratorEnd: CFURLEnumeratorOptions = 2;
+pub const kCFURLEnumeratorError: CFURLEnumeratorOptions = 3;
+pub const kCFURLEnumeratorDirectoryPostOrderSuccess: CFURLEnumeratorOptions = 4;
+
+extern "C" {
+ /*
+ * CFURLEnumerator.h
+ */
+ pub fn CFURLEnumeratorGetTypeID() -> CFTypeID;
+ pub fn CFURLEnumeratorCreateForDirectoryURL(
+ alloc: CFAllocatorRef,
+ directoryURL: CFURLRef,
+ option: CFURLEnumeratorOptions,
+ propertyKeys: CFArrayRef,
+ ) -> CFURLEnumeratorRef;
+ pub fn CFURLEnumeratorCreateForMountedVolumes(
+ alloc: CFAllocatorRef,
+ option: CFURLEnumeratorOptions,
+ propertyKeys: CFArrayRef,
+ ) -> CFURLEnumeratorRef;
+ pub fn CFURLEnumeratorGetNextURL(
+ enumerator: CFURLEnumeratorRef,
+ url: *mut CFURLRef,
+ error: *mut CFErrorRef,
+ ) -> CFURLEnumeratorResult;
+ pub fn CFURLEnumeratorSkipDescendents(enumerator: CFURLEnumeratorRef);
+ pub fn CFURLEnumeratorGetDescendentLevel(enumerator: CFURLEnumeratorRef) -> CFIndex;
+ pub fn CFURLEnumeratorGetSourceDidChange(enumerator: CFURLEnumeratorRef) -> Boolean; // deprecated since macos 10.7
+}
diff --git a/vendor/core-foundation-sys/src/user_notification.rs b/vendor/core-foundation-sys/src/user_notification.rs
new file mode 100644
index 000000000..643271826
--- /dev/null
+++ b/vendor/core-foundation-sys/src/user_notification.rs
@@ -0,0 +1,138 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::c_void;
+
+use crate::base::{CFAllocatorRef, CFIndex, CFOptionFlags, CFTypeID, SInt32};
+use crate::date::CFTimeInterval;
+use crate::dictionary::CFDictionaryRef;
+use crate::runloop::CFRunLoopSourceRef;
+use crate::string::CFStringRef;
+use crate::url::CFURLRef;
+
+#[repr(C)]
+pub struct __CFUserNotification(c_void);
+
+pub type CFUserNotificationCallBack =
+ extern "C" fn(userNotification: CFUserNotificationRef, responseFlags: CFOptionFlags);
+pub type CFUserNotificationRef = *mut __CFUserNotification;
+
+/* Alert Levels */
+pub const kCFUserNotificationStopAlertLevel: CFOptionFlags = 0;
+pub const kCFUserNotificationNoteAlertLevel: CFOptionFlags = 1;
+pub const kCFUserNotificationCautionAlertLevel: CFOptionFlags = 2;
+pub const kCFUserNotificationPlainAlertLevel: CFOptionFlags = 3;
+
+/* Response Codes */
+pub const kCFUserNotificationDefaultResponse: CFOptionFlags = 0;
+pub const kCFUserNotificationAlternateResponse: CFOptionFlags = 1;
+pub const kCFUserNotificationOtherResponse: CFOptionFlags = 2;
+pub const kCFUserNotificationCancelResponse: CFOptionFlags = 3;
+
+/* Button Flags */
+pub const kCFUserNotificationNoDefaultButtonFlag: CFOptionFlags = 1usize << 5;
+pub const kCFUserNotificationUseRadioButtonsFlag: CFOptionFlags = 1usize << 6;
+
+#[inline(always)]
+pub fn CFUserNotificationCheckBoxChecked(i: CFIndex) -> CFOptionFlags {
+ (1u32 << (8 + i)) as CFOptionFlags
+}
+
+#[inline(always)]
+pub fn CFUserNotificationSecureTextField(i: CFIndex) -> CFOptionFlags {
+ (1u32 << (16 + i)) as CFOptionFlags
+}
+
+#[inline(always)]
+pub fn CFUserNotificationPopUpSelection(n: CFIndex) -> CFOptionFlags {
+ (n << 24) as CFOptionFlags
+}
+
+extern "C" {
+ /*
+ * CFUserNotification.h
+ */
+
+ /* Dialog Description Keys */
+ pub static kCFUserNotificationIconURLKey: CFStringRef;
+ pub static kCFUserNotificationSoundURLKey: CFStringRef;
+ pub static kCFUserNotificationLocalizationURLKey: CFStringRef;
+ pub static kCFUserNotificationAlertHeaderKey: CFStringRef;
+ pub static kCFUserNotificationAlertMessageKey: CFStringRef;
+ pub static kCFUserNotificationDefaultButtonTitleKey: CFStringRef;
+ pub static kCFUserNotificationAlternateButtonTitleKey: CFStringRef;
+ pub static kCFUserNotificationOtherButtonTitleKey: CFStringRef;
+ pub static kCFUserNotificationProgressIndicatorValueKey: CFStringRef;
+ pub static kCFUserNotificationPopUpTitlesKey: CFStringRef;
+ pub static kCFUserNotificationTextFieldTitlesKey: CFStringRef;
+ pub static kCFUserNotificationCheckBoxTitlesKey: CFStringRef;
+ pub static kCFUserNotificationTextFieldValuesKey: CFStringRef;
+ pub static kCFUserNotificationPopUpSelectionKey: CFStringRef;
+ pub static kCFUserNotificationAlertTopMostKey: CFStringRef;
+ pub static kCFUserNotificationKeyboardTypesKey: CFStringRef;
+
+ /* CFUserNotification Miscellaneous Functions */
+ pub fn CFUserNotificationCancel(userNotification: CFUserNotificationRef) -> SInt32;
+ pub fn CFUserNotificationCreate(
+ allocator: CFAllocatorRef,
+ timeout: CFTimeInterval,
+ flags: CFOptionFlags,
+ error: *mut SInt32,
+ dictionary: CFDictionaryRef,
+ ) -> CFUserNotificationRef;
+ pub fn CFUserNotificationCreateRunLoopSource(
+ allocator: CFAllocatorRef,
+ userNotification: CFUserNotificationRef,
+ callout: CFUserNotificationCallBack,
+ order: CFIndex,
+ ) -> CFRunLoopSourceRef;
+ pub fn CFUserNotificationDisplayAlert(
+ timeout: CFTimeInterval,
+ flags: CFOptionFlags,
+ iconURL: CFURLRef,
+ soundURL: CFURLRef,
+ localizationURL: CFURLRef,
+ alertHeader: CFStringRef,
+ alertMessage: CFStringRef,
+ defaultButtonTitle: CFStringRef,
+ alternateButtonTitle: CFStringRef,
+ otherButtonTitle: CFStringRef,
+ responseFlags: *mut CFOptionFlags,
+ ) -> SInt32;
+ pub fn CFUserNotificationDisplayNotice(
+ timeout: CFTimeInterval,
+ flags: CFOptionFlags,
+ iconURL: CFURLRef,
+ soundURL: CFURLRef,
+ localizationURL: CFURLRef,
+ alertHeader: CFStringRef,
+ alertMessage: CFStringRef,
+ defaultButtonTitle: CFStringRef,
+ ) -> SInt32;
+ pub fn CFUserNotificationGetTypeID() -> CFTypeID;
+ pub fn CFUserNotificationGetResponseDictionary(
+ userNotification: CFUserNotificationRef,
+ ) -> CFDictionaryRef;
+ pub fn CFUserNotificationGetResponseValue(
+ userNotification: CFUserNotificationRef,
+ key: CFStringRef,
+ idx: CFIndex,
+ ) -> CFStringRef;
+ pub fn CFUserNotificationReceiveResponse(
+ userNotification: CFUserNotificationRef,
+ timeout: CFTimeInterval,
+ responseFlags: *mut CFOptionFlags,
+ ) -> SInt32;
+ pub fn CFUserNotificationUpdate(
+ userNotification: CFUserNotificationRef,
+ timeout: CFTimeInterval,
+ flags: CFOptionFlags,
+ dictionary: CFDictionaryRef,
+ ) -> SInt32;
+}
diff --git a/vendor/core-foundation-sys/src/uuid.rs b/vendor/core-foundation-sys/src/uuid.rs
index 425395293..a1714a8a8 100644
--- a/vendor/core-foundation-sys/src/uuid.rs
+++ b/vendor/core-foundation-sys/src/uuid.rs
@@ -9,7 +9,8 @@
use std::os::raw::c_void;
-use base::{CFAllocatorRef, CFTypeID};
+use crate::base::{CFAllocatorRef, CFTypeID};
+use crate::string::CFStringRef;
#[repr(C)]
pub struct __CFUUID(c_void);
@@ -17,33 +18,78 @@ pub struct __CFUUID(c_void);
pub type CFUUIDRef = *const __CFUUID;
#[repr(C)]
-#[derive(Clone, Copy, Default)]
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct CFUUIDBytes {
- pub byte0: u8,
- pub byte1: u8,
- pub byte2: u8,
- pub byte3: u8,
- pub byte4: u8,
- pub byte5: u8,
- pub byte6: u8,
- pub byte7: u8,
- pub byte8: u8,
- pub byte9: u8,
+ pub byte0: u8,
+ pub byte1: u8,
+ pub byte2: u8,
+ pub byte3: u8,
+ pub byte4: u8,
+ pub byte5: u8,
+ pub byte6: u8,
+ pub byte7: u8,
+ pub byte8: u8,
+ pub byte9: u8,
pub byte10: u8,
pub byte11: u8,
pub byte12: u8,
pub byte13: u8,
pub byte14: u8,
- pub byte15: u8
+ pub byte15: u8,
}
-extern {
+extern "C" {
/*
* CFUUID.h
*/
+
+ /* Creating CFUUID Objects */
pub fn CFUUIDCreate(allocator: CFAllocatorRef) -> CFUUIDRef;
+ pub fn CFUUIDCreateFromString(alloc: CFAllocatorRef, uuidStr: CFStringRef) -> CFUUIDRef;
pub fn CFUUIDCreateFromUUIDBytes(allocator: CFAllocatorRef, bytes: CFUUIDBytes) -> CFUUIDRef;
+ pub fn CFUUIDCreateWithBytes(
+ alloc: CFAllocatorRef,
+ byte0: u8,
+ byte1: u8,
+ byte2: u8,
+ byte3: u8,
+ byte4: u8,
+ byte5: u8,
+ byte6: u8,
+ byte7: u8,
+ byte8: u8,
+ byte9: u8,
+ byte10: u8,
+ byte11: u8,
+ byte12: u8,
+ byte13: u8,
+ byte14: u8,
+ byte15: u8,
+ ) -> CFUUIDRef;
+
+ /* Getting Information About CFUUID Objects */
+ pub fn CFUUIDCreateString(allocator: CFAllocatorRef, uid: CFUUIDRef) -> CFStringRef;
+ pub fn CFUUIDGetConstantUUIDWithBytes(
+ alloc: CFAllocatorRef,
+ byte0: u8,
+ byte1: u8,
+ byte2: u8,
+ byte3: u8,
+ byte4: u8,
+ byte5: u8,
+ byte6: u8,
+ byte7: u8,
+ byte8: u8,
+ byte9: u8,
+ byte10: u8,
+ byte11: u8,
+ byte12: u8,
+ byte13: u8,
+ byte14: u8,
+ byte15: u8,
+ ) -> CFUUIDRef;
pub fn CFUUIDGetUUIDBytes(uuid: CFUUIDRef) -> CFUUIDBytes;
+ /* Getting the CFUUID Type Identifier */
pub fn CFUUIDGetTypeID() -> CFTypeID;
}
diff --git a/vendor/core-foundation-sys/src/xml_node.rs b/vendor/core-foundation-sys/src/xml_node.rs
new file mode 100644
index 000000000..332beec82
--- /dev/null
+++ b/vendor/core-foundation-sys/src/xml_node.rs
@@ -0,0 +1,147 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::{c_char, c_void};
+
+use crate::array::CFArrayRef;
+use crate::base::{Boolean, CFAllocatorRef, CFIndex, CFTypeID};
+use crate::dictionary::CFDictionaryRef;
+use crate::string::{CFStringEncoding, CFStringRef};
+use crate::tree::CFTreeRef;
+use crate::url::CFURLRef;
+
+#[repr(C)]
+pub struct __CFXMLNode(c_void);
+
+pub type CFXMLNodeRef = *mut __CFXMLNode;
+pub type CFXMLTreeRef = CFTreeRef;
+
+pub const kCFXMLNodeCurrentVersion: CFIndex = 1;
+
+pub type CFXMLNodeTypeCode = CFIndex;
+pub const kCFXMLNodeTypeDocument: CFXMLNodeTypeCode = 1;
+pub const kCFXMLNodeTypeElement: CFXMLNodeTypeCode = 2;
+pub const kCFXMLNodeTypeAttribute: CFXMLNodeTypeCode = 3;
+pub const kCFXMLNodeTypeProcessingInstruction: CFXMLNodeTypeCode = 4;
+pub const kCFXMLNodeTypeComment: CFXMLNodeTypeCode = 5;
+pub const kCFXMLNodeTypeText: CFXMLNodeTypeCode = 6;
+pub const kCFXMLNodeTypeCDATASection: CFXMLNodeTypeCode = 7;
+pub const kCFXMLNodeTypeDocumentFragment: CFXMLNodeTypeCode = 8;
+pub const kCFXMLNodeTypeEntity: CFXMLNodeTypeCode = 9;
+pub const kCFXMLNodeTypeEntityReference: CFXMLNodeTypeCode = 10;
+pub const kCFXMLNodeTypeDocumentType: CFXMLNodeTypeCode = 11;
+pub const kCFXMLNodeTypeWhitespace: CFXMLNodeTypeCode = 12;
+pub const kCFXMLNodeTypeNotation: CFXMLNodeTypeCode = 13;
+pub const kCFXMLNodeTypeElementTypeDeclaration: CFXMLNodeTypeCode = 14;
+pub const kCFXMLNodeTypeAttributeListDeclaration: CFXMLNodeTypeCode = 15;
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFXMLElementInfo {
+ pub attributes: CFDictionaryRef,
+ pub attributeOrder: CFArrayRef,
+ pub isEmpty: Boolean,
+ pub _reserved: [c_char; 3],
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFXMLProcessingInstructionInfo {
+ pub dataString: CFStringRef,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFXMLDocumentInfo {
+ pub sourceURL: CFURLRef,
+ pub encoding: CFStringEncoding,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFXMLExternalID {
+ pub systemID: CFURLRef,
+ pub publicID: CFStringRef,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFXMLDocumentTypeInfo {
+ pub externalID: CFXMLExternalID,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFXMLNotationInfo {
+ pub externalID: CFXMLExternalID,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFXMLElementTypeDeclarationInfo {
+ pub contentDescription: CFStringRef,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFXMLAttributeDeclarationInfo {
+ pub attributeName: CFStringRef,
+ pub typeString: CFStringRef,
+ pub defaultString: CFStringRef,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFXMLAttributeListDeclarationInfo {
+ pub numberOfAttributes: CFIndex,
+ pub attributes: *mut CFXMLAttributeDeclarationInfo,
+}
+
+pub type CFXMLEntityTypeCode = CFIndex;
+pub const kCFXMLEntityTypeParameter: CFXMLEntityTypeCode = 0;
+pub const kCFXMLEntityTypeParsedInternal: CFXMLEntityTypeCode = 1;
+pub const kCFXMLEntityTypeParsedExternal: CFXMLEntityTypeCode = 2;
+pub const kCFXMLEntityTypeUnparsed: CFXMLEntityTypeCode = 3;
+pub const kCFXMLEntityTypeCharacter: CFXMLEntityTypeCode = 4;
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFXMLEntityInfo {
+ pub entityType: CFXMLEntityTypeCode,
+ pub replacementText: CFStringRef,
+ pub entityID: CFXMLExternalID,
+ pub notationName: CFStringRef,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFXMLEntityReferenceInfo {
+ pub entityType: CFXMLEntityTypeCode,
+}
+
+extern "C" {
+ /*
+ * CFXMLNode.h
+ */
+ pub fn CFXMLNodeGetTypeID() -> CFTypeID;
+ pub fn CFXMLNodeCreate(
+ alloc: CFAllocatorRef,
+ xmlType: CFXMLNodeTypeCode,
+ dataString: CFStringRef,
+ additionalInfoPtr: *const c_void,
+ version: CFIndex,
+ ) -> CFXMLNodeRef;
+ pub fn CFXMLNodeCreateCopy(alloc: CFAllocatorRef, origNode: CFXMLNodeRef) -> CFXMLNodeRef;
+ pub fn CFXMLNodeGetTypeCode(node: CFXMLNodeRef) -> CFXMLNodeTypeCode;
+ pub fn CFXMLNodeGetString(node: CFXMLNodeRef) -> CFStringRef;
+ pub fn CFXMLNodeGetInfoPtr(node: CFXMLNodeRef) -> *const c_void;
+ pub fn CFXMLNodeGetVersion(node: CFXMLNodeRef) -> CFIndex;
+ pub fn CFXMLTreeCreateWithNode(alloc: CFAllocatorRef, node: CFXMLNodeRef) -> CFXMLTreeRef;
+ pub fn CFXMLTreeGetNode(xmlTree: CFXMLTreeRef) -> CFXMLNodeRef;
+}
diff --git a/vendor/core-foundation-sys/src/xml_parser.rs b/vendor/core-foundation-sys/src/xml_parser.rs
new file mode 100644
index 000000000..32dc709a6
--- /dev/null
+++ b/vendor/core-foundation-sys/src/xml_parser.rs
@@ -0,0 +1,174 @@
+// Copyright 2023 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::os::raw::c_void;
+
+use crate::base::{Boolean, CFAllocatorRef, CFIndex, CFOptionFlags, CFTypeID};
+use crate::data::CFDataRef;
+use crate::dictionary::CFDictionaryRef;
+use crate::string::CFStringRef;
+use crate::url::CFURLRef;
+use crate::xml_node::{CFXMLExternalID, CFXMLNodeRef, CFXMLTreeRef};
+
+#[repr(C)]
+pub struct __CFXMLParser(c_void);
+
+pub type CFXMLParserRef = *mut __CFXMLParser;
+
+pub type CFXMLParserOptions = CFOptionFlags;
+pub const kCFXMLParserValidateDocument: CFXMLParserOptions = 1 << 0;
+pub const kCFXMLParserSkipMetaData: CFXMLParserOptions = 1 << 1;
+pub const kCFXMLParserReplacePhysicalEntities: CFXMLParserOptions = 1 << 2;
+pub const kCFXMLParserSkipWhitespace: CFXMLParserOptions = 1 << 3;
+pub const kCFXMLParserResolveExternalEntities: CFXMLParserOptions = 1 << 4;
+pub const kCFXMLParserAddImpliedAttributes: CFXMLParserOptions = 1 << 5;
+pub const kCFXMLParserAllOptions: CFXMLParserOptions = 0x00FFFFFF;
+pub const kCFXMLParserNoOptions: CFXMLParserOptions = 0;
+
+pub type CFXMLParserStatusCode = CFIndex;
+pub const kCFXMLStatusParseNotBegun: CFIndex = -2;
+pub const kCFXMLStatusParseInProgress: CFIndex = -1;
+pub const kCFXMLStatusParseSuccessful: CFIndex = 0;
+pub const kCFXMLErrorUnexpectedEOF: CFIndex = 1;
+pub const kCFXMLErrorUnknownEncoding: CFIndex = 2;
+pub const kCFXMLErrorEncodingConversionFailure: CFIndex = 3;
+pub const kCFXMLErrorMalformedProcessingInstruction: CFIndex = 4;
+pub const kCFXMLErrorMalformedDTD: CFIndex = 5;
+pub const kCFXMLErrorMalformedName: CFIndex = 6;
+pub const kCFXMLErrorMalformedCDSect: CFIndex = 7;
+pub const kCFXMLErrorMalformedCloseTag: CFIndex = 8;
+pub const kCFXMLErrorMalformedStartTag: CFIndex = 9;
+pub const kCFXMLErrorMalformedDocument: CFIndex = 10;
+pub const kCFXMLErrorElementlessDocument: CFIndex = 11;
+pub const kCFXMLErrorMalformedComment: CFIndex = 12;
+pub const kCFXMLErrorMalformedCharacterReference: CFIndex = 13;
+pub const kCFXMLErrorMalformedParsedCharacterData: CFIndex = 14;
+pub const kCFXMLErrorNoData: CFIndex = 15;
+
+pub type CFXMLParserCreateXMLStructureCallBack =
+ extern "C" fn(parser: CFXMLParserRef, nodeDesc: CFXMLNodeRef, info: *mut c_void) -> *mut c_void;
+pub type CFXMLParserAddChildCallBack = extern "C" fn(
+ parser: CFXMLParserRef,
+ parent: *mut c_void,
+ child: *mut c_void,
+ info: *mut c_void,
+);
+pub type CFXMLParserEndXMLStructureCallBack =
+ extern "C" fn(parser: CFXMLParserRef, xmlType: *mut c_void, info: *mut c_void);
+pub type CFXMLParserResolveExternalEntityCallBack = extern "C" fn(
+ parser: CFXMLParserRef,
+ extID: *mut CFXMLExternalID,
+ info: *mut c_void,
+) -> CFDataRef;
+pub type CFXMLParserHandleErrorCallBack = extern "C" fn(
+ parser: CFXMLParserRef,
+ error: CFXMLParserStatusCode,
+ info: *mut c_void,
+) -> Boolean;
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFXMLParserCallBacks {
+ pub version: CFIndex,
+ pub createXMLStructure: CFXMLParserCreateXMLStructureCallBack,
+ pub addChild: CFXMLParserAddChildCallBack,
+ pub endXMLStructure: CFXMLParserEndXMLStructureCallBack,
+ pub resolveExternalEntity: CFXMLParserResolveExternalEntityCallBack,
+ pub handleError: CFXMLParserHandleErrorCallBack,
+}
+
+pub type CFXMLParserRetainCallBack = extern "C" fn(info: *const c_void) -> *const c_void;
+pub type CFXMLParserReleaseCallBack = extern "C" fn(info: *const c_void);
+pub type CFXMLParserCopyDescriptionCallBack = extern "C" fn(info: *const c_void) -> CFStringRef;
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CFXMLParserContext {
+ pub version: CFIndex,
+ pub info: *mut c_void,
+ pub retain: CFXMLParserRetainCallBack,
+ pub release: CFXMLParserReleaseCallBack,
+ pub copyDescription: CFXMLParserCopyDescriptionCallBack,
+}
+
+extern "C" {
+ /*
+ * CFXMLParser.h
+ */
+
+ pub static kCFXMLTreeErrorDescription: CFStringRef;
+ pub static kCFXMLTreeErrorLineNumber: CFStringRef;
+ pub static kCFXMLTreeErrorLocation: CFStringRef;
+ pub static kCFXMLTreeErrorStatusCode: CFStringRef;
+
+ pub fn CFXMLParserGetTypeID() -> CFTypeID;
+ pub fn CFXMLParserCreate(
+ allocator: CFAllocatorRef,
+ xmlData: CFDataRef,
+ dataSource: CFURLRef,
+ parseOptions: CFOptionFlags,
+ versionOfNodes: CFIndex,
+ callBacks: *mut CFXMLParserCallBacks,
+ context: *mut CFXMLParserContext,
+ ) -> CFXMLParserRef;
+ pub fn CFXMLParserCreateWithDataFromURL(
+ allocator: CFAllocatorRef,
+ dataSource: CFURLRef,
+ parseOptions: CFOptionFlags,
+ versionOfNodes: CFIndex,
+ callBacks: *mut CFXMLParserCallBacks,
+ context: *mut CFXMLParserContext,
+ ) -> CFXMLParserRef;
+ pub fn CFXMLParserGetContext(parser: CFXMLParserRef, context: *mut CFXMLParserContext);
+ pub fn CFXMLParserGetCallBacks(parser: CFXMLParserRef, callBacks: *mut CFXMLParserCallBacks);
+ pub fn CFXMLParserGetSourceURL(parser: CFXMLParserRef) -> CFURLRef;
+ pub fn CFXMLParserGetLocation(parser: CFXMLParserRef) -> CFIndex;
+ pub fn CFXMLParserGetLineNumber(parser: CFXMLParserRef) -> CFIndex;
+ pub fn CFXMLParserGetDocument(parser: CFXMLParserRef) -> *mut c_void;
+ pub fn CFXMLParserGetStatusCode(parser: CFXMLParserRef) -> CFXMLParserStatusCode;
+ pub fn CFXMLParserCopyErrorDescription(parser: CFXMLParserRef) -> CFStringRef;
+ pub fn CFXMLParserAbort(
+ parser: CFXMLParserRef,
+ errorCode: CFXMLParserStatusCode,
+ errorDescription: CFStringRef,
+ );
+ pub fn CFXMLParserParse(parser: CFXMLParserRef) -> Boolean;
+ pub fn CFXMLTreeCreateFromData(
+ allocator: CFAllocatorRef,
+ xmlData: CFDataRef,
+ dataSource: CFURLRef,
+ parseOptions: CFOptionFlags,
+ versionOfNodes: CFIndex,
+ ) -> CFXMLTreeRef;
+ pub fn CFXMLTreeCreateFromDataWithError(
+ allocator: CFAllocatorRef,
+ xmlData: CFDataRef,
+ dataSource: CFURLRef,
+ parseOptions: CFOptionFlags,
+ versionOfNodes: CFIndex,
+ errorDict: *mut CFDictionaryRef,
+ ) -> CFXMLTreeRef;
+ pub fn CFXMLTreeCreateWithDataFromURL(
+ allocator: CFAllocatorRef,
+ dataSource: CFURLRef,
+ parseOptions: CFOptionFlags,
+ versionOfNodes: CFIndex,
+ ) -> CFXMLTreeRef;
+ pub fn CFXMLTreeCreateXMLData(allocator: CFAllocatorRef, xmlTree: CFXMLTreeRef) -> CFDataRef;
+ pub fn CFXMLCreateStringByEscapingEntities(
+ allocator: CFAllocatorRef,
+ string: CFStringRef,
+ entitiesDictionary: CFDictionaryRef,
+ ) -> CFStringRef;
+ pub fn CFXMLCreateStringByUnescapingEntities(
+ allocator: CFAllocatorRef,
+ string: CFStringRef,
+ entitiesDictionary: CFDictionaryRef,
+ ) -> CFStringRef;
+}