From 9918693037dce8aa4bb6f08741b6812923486c18 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 19 Jun 2024 11:26:03 +0200 Subject: Merging upstream version 1.76.0+dfsg1. Signed-off-by: Daniel Baumann --- vendor/core-foundation-sys/.cargo-checksum.json | 2 +- vendor/core-foundation-sys/Cargo.toml | 8 +- vendor/core-foundation-sys/src/array.rs | 127 +++- .../core-foundation-sys/src/attributed_string.rs | 99 ++- vendor/core-foundation-sys/src/bag.rs | 101 +++ vendor/core-foundation-sys/src/base.rs | 88 ++- vendor/core-foundation-sys/src/binary_heap.rs | 83 +++ vendor/core-foundation-sys/src/bit_vector.rs | 74 ++ vendor/core-foundation-sys/src/bundle.rs | 215 +++++- vendor/core-foundation-sys/src/calendar.rs | 128 ++++ vendor/core-foundation-sys/src/characterset.rs | 102 ++- vendor/core-foundation-sys/src/data.rs | 59 +- vendor/core-foundation-sys/src/date.rs | 10 +- vendor/core-foundation-sys/src/date_formatter.rs | 147 ++++ vendor/core-foundation-sys/src/dictionary.rs | 124 ++-- vendor/core-foundation-sys/src/error.rs | 38 +- vendor/core-foundation-sys/src/file_security.rs | 71 ++ vendor/core-foundation-sys/src/filedescriptor.rs | 56 +- vendor/core-foundation-sys/src/lib.rs | 42 +- vendor/core-foundation-sys/src/locale.rs | 146 ++++ vendor/core-foundation-sys/src/mach_port.rs | 63 +- vendor/core-foundation-sys/src/messageport.rs | 123 ++-- .../core-foundation-sys/src/notification_center.rs | 89 +++ vendor/core-foundation-sys/src/number.rs | 74 +- vendor/core-foundation-sys/src/number_formatter.rs | 163 +++++ vendor/core-foundation-sys/src/plugin.rs | 99 +++ vendor/core-foundation-sys/src/preferences.rs | 103 +++ vendor/core-foundation-sys/src/propertylist.rs | 102 ++- vendor/core-foundation-sys/src/runloop.rs | 220 ++++-- vendor/core-foundation-sys/src/set.rs | 64 +- vendor/core-foundation-sys/src/socket.rs | 188 +++++ vendor/core-foundation-sys/src/stream.rs | 281 ++++++++ vendor/core-foundation-sys/src/string.rs | 757 +++++++++++++-------- vendor/core-foundation-sys/src/string_tokenizer.rs | 91 +++ vendor/core-foundation-sys/src/timezone.rs | 76 ++- vendor/core-foundation-sys/src/tree.rs | 74 ++ vendor/core-foundation-sys/src/url.rs | 468 ++++++++++--- vendor/core-foundation-sys/src/url_enumerator.rs | 62 ++ .../core-foundation-sys/src/user_notification.rs | 138 ++++ vendor/core-foundation-sys/src/uuid.rs | 74 +- vendor/core-foundation-sys/src/xml_node.rs | 147 ++++ vendor/core-foundation-sys/src/xml_parser.rs | 174 +++++ 42 files changed, 4629 insertions(+), 721 deletions(-) create mode 100644 vendor/core-foundation-sys/src/bag.rs create mode 100644 vendor/core-foundation-sys/src/binary_heap.rs create mode 100644 vendor/core-foundation-sys/src/bit_vector.rs create mode 100644 vendor/core-foundation-sys/src/calendar.rs create mode 100644 vendor/core-foundation-sys/src/date_formatter.rs create mode 100644 vendor/core-foundation-sys/src/file_security.rs create mode 100644 vendor/core-foundation-sys/src/locale.rs create mode 100644 vendor/core-foundation-sys/src/notification_center.rs create mode 100644 vendor/core-foundation-sys/src/number_formatter.rs create mode 100644 vendor/core-foundation-sys/src/plugin.rs create mode 100644 vendor/core-foundation-sys/src/preferences.rs create mode 100644 vendor/core-foundation-sys/src/socket.rs create mode 100644 vendor/core-foundation-sys/src/stream.rs create mode 100644 vendor/core-foundation-sys/src/string_tokenizer.rs create mode 100644 vendor/core-foundation-sys/src/tree.rs create mode 100644 vendor/core-foundation-sys/src/url_enumerator.rs create mode 100644 vendor/core-foundation-sys/src/user_notification.rs create mode 100644 vendor/core-foundation-sys/src/xml_node.rs create mode 100644 vendor/core-foundation-sys/src/xml_parser.rs (limited to 'vendor/core-foundation-sys') diff --git a/vendor/core-foundation-sys/.cargo-checksum.json b/vendor/core-foundation-sys/.cargo-checksum.json index c2cd267f0..7dd167643 100644 --- a/vendor/core-foundation-sys/.cargo-checksum.json +++ b/vendor/core-foundation-sys/.cargo-checksum.json @@ -1 +1 @@ -{"files":{"Cargo.toml":"3d8f48ae4a8127b0b716ca1d2baf49e37ee2b1c99c9ae6d3014a215d59c2ebb5","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"62065228e42caebca7e7d7db1204cbb867033de5982ca4009928915e4095f3a3","src/array.rs":"1e016cbb3f52c9df45abcc3bce8102cf74c9eeae9d7db16e3bba9ee81b35100d","src/attributed_string.rs":"48c2d161d6f54136ae895a9f52efad1f831718ea331b875d25498039158a2d51","src/base.rs":"7b21281e9a01903c79a7891ee4e1865a11504b281b468815d1a3838e1744a3c2","src/bundle.rs":"2a3413e649e1cf5eb1557fa5e3e6d442389caa2978a4a0c2c7afdfa4c388c0bf","src/characterset.rs":"a10bbb42ddc74b3dc50b43ae6a50cc9d9a1cd08b975a1ce1b092be4bf64448a6","src/data.rs":"2b121f102b4c2778475f4902016820c4a70e2f8ac532af53913561d42757fa2e","src/date.rs":"c064ee4c3ebd1927532c34871e2e41179d6e3c3e400f6b409a18ad9e2337477f","src/dictionary.rs":"3327a6f90f1e0db5e3fde1973e2df4143ca896716a816d03f2b17c8e988c5159","src/error.rs":"6205ebeb7631daa8bcd560862b6daa10f640c8c117ce5f6f7184f268dcbcb42a","src/filedescriptor.rs":"49580654b657811fade7adaa256f5f895cb011c9baa4731e2f44a6ec7fdba235","src/lib.rs":"469b20bf6fc5d86e54183147a2dc80481db2bb73843c7e16305fe259897ac3e2","src/mach_port.rs":"bd413d44772eaeb24e74e1b7b4f234b159b916caa0896c8e82fe54ce1b9deeb6","src/messageport.rs":"e9227d5907cba8e29cdeea41bcb3ae5c7840220442953ab19aace31a84542f47","src/number.rs":"f28040accfbbec99c4e55f411facac7cde4ad89298af2d7d907312f18e4263bf","src/propertylist.rs":"7ec928438826c4ce40befedf3de0a37c8ecbc0fc17896dfa629d5864000b2cfe","src/runloop.rs":"26ca33e2472d191f583e01c24e8cd262f54de8b542fbe7278f33ab08b2925794","src/set.rs":"116c2f18008bfbeecac570d366dbd95b8fe5b9373e3e1bdd2c1d588314d776c5","src/string.rs":"b2856d0bf7a8583370d18d3f041ac5eb00fd6a1aabc69503e7c11a93d42036d8","src/timezone.rs":"c7dd9557646b7ff2bfd6a98bf92142b8304125b4e78dd651b687abc8da191159","src/url.rs":"4358f756ed3d5e9afd5a7f3e2e9115adc6133b47dc7ce59d6ebb32c6610b0e8f","src/uuid.rs":"82f75efa73d0842dff2e13d299c166c6593a77fcb69c4b7629a2df1c17ae507d"},"package":"e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa"} \ No newline at end of file +{"files":{"Cargo.toml":"f8b5e9fa6c6bbfad4e3c0acfbad03f05cbd98073e664e3ad2fe16a56dd492aa1","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"62065228e42caebca7e7d7db1204cbb867033de5982ca4009928915e4095f3a3","src/array.rs":"4d469ca3f6aceb42dfaf7b26aa9ef14a8ebce05e02d0beda985fa32f2ec48963","src/attributed_string.rs":"7042f3fbf6904efecb15f01ce2e96eecf84973e0fef9be4c10d14944b0f90a24","src/bag.rs":"dec9ff467ac713526c3be8148ae41b21ab8840f393733bb53c77224ef089787c","src/base.rs":"5d0dee358519712e881e2edbea0ca6d3539958ed1ff3d70aa136af7e25292f22","src/binary_heap.rs":"0565125dbdb1fa578888e00f5b195ab91f0bf65881eabcd39de99ca811d756de","src/bit_vector.rs":"dcdaa573d90b25bdc6b98f2330110e8591b7c329601643dcc6aa23b1b9ec7210","src/bundle.rs":"83ac9d7c45f06161767588c465eed086a773714734da0614d98d000326df3603","src/calendar.rs":"b73796956e50d92f0479479e84246712804537d694e4cdd01d5440e5fbcbd333","src/characterset.rs":"ba60f78884cd860e151df35c1953bcd6eae46d9f27c36584b66e508e2301a7a8","src/data.rs":"fe4e2effbfd9348575507d06aa53cd583808c908f9e03ac1a076b077230c9c01","src/date.rs":"971d681f6eeefa3764d8a43e53cbf7c937c419331207c7bb003a25c9b0b0722f","src/date_formatter.rs":"05e84ac3cf4c0daae2e939a9bedddfd10dd5309ea1536bf8241de41971d11f8a","src/dictionary.rs":"ac23d99208131049c82c13b37a99b4fd129224d1dafcd65ff2f9de200d73e9d1","src/error.rs":"b523faa8c498e1115c72e71a10e7a3bf8bcc01588cb02e70dc9fd45cbdaa35f6","src/file_security.rs":"542c5d8eef22424479abcb448601611d85c9cc96e41cd6cd6de5ea3efe1213a6","src/filedescriptor.rs":"706eebde408713cc49bbab078e86fe51e95fe29b167420bbcbb573847dcf29e2","src/lib.rs":"8ae5082d92ebf6b1a53332211b87986aa7228534f5e341b62100e522b7fcadec","src/locale.rs":"372190a9cb5659fba0b92598c5dcbdaa3f90b29b3440ddcfe77931e85c1f96d9","src/mach_port.rs":"e52c2ce794e82ebeeb0cba170902409f18626b7d9e29d6dcd333e9c13411408a","src/messageport.rs":"d8e342f0eabe47f6f4746fdbf996bf9008b4b5f1fa24e0bc4ecd73b2de81b234","src/notification_center.rs":"0ab30523bc4ac799016970c9c59594cbb3afeda054705c15d0979eb07abb7c7d","src/number.rs":"28b10c9d2361cac18549ef66839f595e98490096e756e9a7f25536b6ceb1f687","src/number_formatter.rs":"024fbd3b2ecaecf19cfdb463e0f0096d1fa28bc4ce636659e53459d1b01af658","src/plugin.rs":"0904b1b4b882e626d5d63ac91c540dfdf65f5f4428cf38c9def6acfc7ed84cd3","src/preferences.rs":"49d8ac0c669a01678fa0dc26d6cb13bc72004c8422e525bf3e26f01feb5a3693","src/propertylist.rs":"f7f12cb8c67098e5b96cb8a63b4a947549a2cbf7a6523ce314141b4f8cc202c4","src/runloop.rs":"8fa6e5e74a013f8101d5a4f6616818573adc7ed197e28b799dca4c3a1cedaac9","src/set.rs":"0e619ec75a6b975be6b6d59ed3b01c803dd635020288b178db949b1c45442d17","src/socket.rs":"b67737b8c04142fa4d198c19f0867fd653837e529bf2665e78750c94f469a793","src/stream.rs":"f9b1099191010a96ce0aadcc22385732710dfc1521873096a9db67ad80472e36","src/string.rs":"fa46e7b7865709494bb05c9c7c6006f165fafa956ab41f053af0e4b41904efa4","src/string_tokenizer.rs":"0da4ae1a841591871602f21cc1c9b51289a0514a255b269e4b61afdeb0097c10","src/timezone.rs":"f584ea76627f12f33eba25d7ea054c2d2c10a2d96474fce12858ccb4bdf688c1","src/tree.rs":"50d513ea1801797c549218c51f5ebf77be4cf80901b12ce3ba0a223c602995d4","src/url.rs":"cb08b0bd24708e6572711f4f82b88370e811aabf4f58f22c34f0f873a44c7486","src/url_enumerator.rs":"bd531f31f6c62b2849d5ccbc82bfc3ae3866c4cdd6768b6c2fe380f24c290540","src/user_notification.rs":"e86b052817028847e62121752e7d58f8ed6f8ad15f5ef947c1fa93bbd0fcbf26","src/uuid.rs":"48af493dc6c8b00d804d6ae92a2fd71eabdae8a2be0500baaa55ce56345c350a","src/xml_node.rs":"c7894a4d08f695ba75d539b3c8d6cc3a90544000786fe3f9cd9c02ad7541213b","src/xml_parser.rs":"ac8a3d2c71ec8ec80603ce5ef214147c0e93bed211c1559a47f14fc31cb0bbaf"},"package":"06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"} \ No newline at end of file diff --git a/vendor/core-foundation-sys/Cargo.toml b/vendor/core-foundation-sys/Cargo.toml index a174e02e2..345cbab91 100644 --- a/vendor/core-foundation-sys/Cargo.toml +++ b/vendor/core-foundation-sys/Cargo.toml @@ -10,19 +10,23 @@ # See Cargo.toml.orig for the original contents. [package] +edition = "2018" name = "core-foundation-sys" -version = "0.8.4" +version = "0.8.6" authors = ["The Servo Project Developers"] description = "Bindings to Core Foundation for macOS" homepage = "https://github.com/servo/core-foundation-rs" -license = "MIT / Apache-2.0" +license = "MIT OR Apache-2.0" repository = "https://github.com/servo/core-foundation-rs" [package.metadata.docs.rs] +all-features = true default-target = "x86_64-apple-darwin" [dependencies] [features] +default = ["link"] +link = [] mac_os_10_7_support = [] mac_os_10_8_features = [] 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 or the MIT license +// , 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 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 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, pub reallocate: Option, pub deallocate: Option, - pub preferredSize: Option + pub preferredSize: Option, } /// Trait for all types which are Core Foundation reference types. @@ -110,7 +132,7 @@ impl 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 or the MIT license +// , 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 or the MIT license +// , 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 or the MIT license +// , 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 or the MIT license +// , 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 or the MIT license +// , 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 *const c_void>, - pub release: Option, - pub copyDescription: Option CFStringRef>, + pub retain: Option *const c_void>, + pub release: Option, + pub copyDescription: Option 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 @@ // , 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 or the MIT license +// , 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 or the MIT license +// , 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 *const c_void>, - pub release: Option, - pub copyDescription: Option CFStringRef>, + pub retain: Option *const c_void>, + pub release: Option, + pub copyDescription: Option 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; + +/* 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 or the MIT license +// , 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 or the MIT license +// , 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 or the MIT license +// , 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 or the MIT license +// , 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 *const c_void>, - pub release: Option, - pub copyDescription: Option CFStringRef>, - pub equal: Option Boolean>, - pub hash: Option CFHashCode>, - pub schedule: Option, - pub cancel: Option, - pub perform: extern "C" fn (info: *const c_void), + pub retain: Option *const c_void>, + pub release: Option, + pub copyDescription: Option CFStringRef>, + pub equal: Option Boolean>, + pub hash: Option CFHashCode>, + pub schedule: Option, + pub cancel: Option, + 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 *const c_void>, - pub release: Option, - pub copyDescription: Option CFStringRef>, - pub equal: Option Boolean>, - pub hash: Option 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 *const c_void>, + pub release: Option, + pub copyDescription: Option CFStringRef>, + pub equal: Option Boolean>, + pub hash: Option 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 *const c_void>, - pub release: Option, - pub copyDescription: Option CFStringRef>, + pub retain: Option *const c_void>, + pub release: Option, + pub copyDescription: Option 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 *const c_void>, - pub release: Option, - pub copyDescription: Option CFStringRef>, + pub retain: Option *const c_void>, + pub release: Option, + pub copyDescription: Option 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 or the MIT license +// , 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 or the MIT license +// , 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 or the MIT license +// , 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 or the MIT license +// , 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 or the MIT license +// , 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 or the MIT license +// , 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 or the MIT license +// , 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 or the MIT license +// , 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; +} -- cgit v1.2.3