ForFoundationOnly.h

   1 /*
   2  * Copyright (c) 2013 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24 /*      ForFoundationOnly.h
  25         Copyright (c) 1998-2013, Apple Inc. All rights reserved.
  26 */
  27
  28 #if !CF_BUILDING_CF && !NSBUILDINGFOUNDATION
  29     #error The header file ForFoundationOnly.h is for the exclusive use of the
  30     #error CoreFoundation and Foundation projects.  No other project should include it.
  31 #endif
  32
  33 #if !defined(__COREFOUNDATION_FORFOUNDATIONONLY__)
  34 #define __COREFOUNDATION_FORFOUNDATIONONLY__ 1
  35
  36 #include <CoreFoundation/CFBase.h>
  37 #include <CoreFoundation/CFString.h>
  38 #include <CoreFoundation/CFArray.h>
  39 #include <CoreFoundation/CFData.h>
  40 #include <CoreFoundation/CFDictionary.h>
  41 #include <CoreFoundation/CFSet.h>
  42 #include <CoreFoundation/CFPriv.h>
  43 #include <CoreFoundation/CFPropertyList.h>
  44 #include <CoreFoundation/CFError.h>
  45 #include <CoreFoundation/CFStringEncodingExt.h>
  46 #include <limits.h>
  47
  48 // NOTE: miscellaneous declarations are at the end
  49
  50 // ---- CFRuntime material ----------------------------------------
  51
  52 CF_EXTERN_C_BEGIN
  53
  54 #if DEPLOYMENT_TARGET_LINUX
  55 #include <malloc.h>
  56 #elif DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
  57 #include <malloc/malloc.h>
  58 #endif
  59
  60 CF_EXTERN_C_END
  61
  62 // ---- CFBundle material ----------------------------------------
  63
  64 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI || DEPLOYMENT_TARGET_WINDOWS
  65 #include <CoreFoundation/CFBundlePriv.h>
  66
  67 CF_EXTERN_C_BEGIN
  68
  69 CF_EXPORT const CFStringRef _kCFBundleExecutablePathKey;
  70 CF_EXPORT const CFStringRef _kCFBundleInfoPlistURLKey;
  71 CF_EXPORT const CFStringRef _kCFBundleRawInfoPlistURLKey;
  72 CF_EXPORT const CFStringRef _kCFBundleNumericVersionKey;
  73 CF_EXPORT const CFStringRef _kCFBundleResourcesFileMappedKey;
  74 CF_EXPORT const CFStringRef _kCFBundleAllowMixedLocalizationsKey;
  75 CF_EXPORT const CFStringRef _kCFBundleInitialPathKey;
  76 CF_EXPORT const CFStringRef _kCFBundleResolvedPathKey;
  77 CF_EXPORT const CFStringRef _kCFBundlePrincipalClassKey;
  78
  79 #if __BLOCKS__
  80 CF_EXPORT CFTypeRef _CFBundleCopyFindResources(CFBundleRef bundle, CFURLRef bundleURL, CFArrayRef languages, CFStringRef resourceName, CFStringRef resourceType, CFStringRef subPath, CFStringRef lproj, Boolean returnArray, Boolean localized, Boolean (^predicate)(CFStringRef filename, Boolean *stop));
  81 #endif
  82
  83 CF_EXPORT CFArrayRef _CFBundleGetLanguageSearchList(CFBundleRef bundle);
  84
  85 CF_EXPORT Boolean _CFBundleLoadExecutableAndReturnError(CFBundleRef bundle, Boolean forceGlobal, CFErrorRef *error);
  86 CF_EXPORT CFErrorRef _CFBundleCreateError(CFAllocatorRef allocator, CFBundleRef bundle, CFIndex code);
  87
  88 CF_EXTERN_C_END
  89
  90 #endif
  91
  92 // ---- CFPreferences material ----------------------------------------
  93
  94 #define DEBUG_PREFERENCES_MEMORY 0
  95
  96 #if DEBUG_PREFERENCES_MEMORY
  97 #include "../Tests/CFCountingAllocator.h"
  98 #endif
  99
 100 CF_EXTERN_C_BEGIN
 101
 102 extern void _CFPreferencesPurgeDomainCache(void);
 103
 104 typedef struct {
 105     void *      (*createDomain)(CFAllocatorRef allocator, CFTypeRef context);
 106     void        (*freeDomain)(CFAllocatorRef allocator, CFTypeRef context, void *domain);
 107     CFTypeRef   (*fetchValue)(CFTypeRef context, void *domain, CFStringRef key); // Caller releases
 108     void        (*writeValue)(CFTypeRef context, void *domain, CFStringRef key, CFTypeRef value);
 109     Boolean     (*synchronize)(CFTypeRef context, void *domain);
 110     void        (*getKeysAndValues)(CFAllocatorRef alloc, CFTypeRef context, void *domain, void **buf[], CFIndex *numKeyValuePairs);
 111     CFDictionaryRef (*copyDomainDictionary)(CFTypeRef context, void *domain);
 112     /* HACK - see comment on _CFPreferencesDomainSetIsWorldReadable(), below */
 113     void        (*setIsWorldReadable)(CFTypeRef context, void *domain, Boolean isWorldReadable);
 114 } _CFPreferencesDomainCallBacks;
 115
 116 CF_EXPORT CFAllocatorRef __CFPreferencesAllocator(void);
 117 CF_EXPORT  const _CFPreferencesDomainCallBacks __kCFVolatileDomainCallBacks;
 118 CF_EXPORT const _CFPreferencesDomainCallBacks __kCFXMLPropertyListDomainCallBacks;
 119
 120 typedef struct __CFPreferencesDomain * CFPreferencesDomainRef;
 121
 122 CF_EXPORT CFPreferencesDomainRef _CFPreferencesDomainCreate(CFTypeRef context, const _CFPreferencesDomainCallBacks *callBacks);
 123 CF_EXPORT CFPreferencesDomainRef _CFPreferencesStandardDomain(CFStringRef domainName, CFStringRef userName, CFStringRef hostName);
 124
 125 CF_EXPORT CFTypeRef _CFPreferencesDomainCreateValueForKey(CFPreferencesDomainRef domain, CFStringRef key);
 126 CF_EXPORT void _CFPreferencesDomainSet(CFPreferencesDomainRef domain, CFStringRef key, CFTypeRef value);
 127 CF_EXPORT Boolean _CFPreferencesDomainSynchronize(CFPreferencesDomainRef domain);
 128
 129 CF_EXPORT CFArrayRef _CFPreferencesCreateDomainList(CFStringRef userName, CFStringRef hostName);
 130 CF_EXPORT Boolean _CFSynchronizeDomainCache(void);
 131
 132 CF_EXPORT void _CFPreferencesDomainSetDictionary(CFPreferencesDomainRef domain, CFDictionaryRef dict);
 133 CF_EXPORT CFDictionaryRef _CFPreferencesDomainDeepCopyDictionary(CFPreferencesDomainRef domain);
 134 CF_EXPORT Boolean _CFPreferencesDomainExists(CFStringRef domainName, CFStringRef userName, CFStringRef hostName);
 135
 136 /* HACK - this is to work around the fact that individual domains lose the information about their user/host/app triplet at creation time.  We should find a better way to propogate this information.  REW, 1/13/00 */
 137 CF_EXPORT void _CFPreferencesDomainSetIsWorldReadable(CFPreferencesDomainRef domain, Boolean isWorldReadable);
 138
 139 typedef struct {
 140     CFMutableArrayRef _search;  // the search list; an array of _CFPreferencesDomains
 141     CFMutableDictionaryRef _dictRep; // Mutable; a collapsed view of the search list, expressed as a single dictionary
 142     CFStringRef _appName;
 143 } _CFApplicationPreferences;
 144
 145 CF_EXPORT _CFApplicationPreferences *_CFStandardApplicationPreferences(CFStringRef appName);
 146 CF_EXPORT _CFApplicationPreferences *_CFApplicationPreferencesCreateWithUser(CFStringRef userName, CFStringRef appName);
 147 CF_EXPORT void _CFDeallocateApplicationPreferences(_CFApplicationPreferences *self);
 148 CF_EXPORT CFTypeRef _CFApplicationPreferencesCreateValueForKey(_CFApplicationPreferences *prefs, CFStringRef key);
 149 CF_EXPORT void _CFApplicationPreferencesSet(_CFApplicationPreferences *self, CFStringRef defaultName, CFTypeRef value);
 150 CF_EXPORT void _CFApplicationPreferencesRemove(_CFApplicationPreferences *self, CFStringRef defaultName);
 151 CF_EXPORT Boolean _CFApplicationPreferencesSynchronize(_CFApplicationPreferences *self);
 152 CF_EXPORT void _CFApplicationPreferencesUpdate(_CFApplicationPreferences *self); // same as updateDictRep
 153 CF_EXPORT CFDictionaryRef _CFApplicationPreferencesCopyRepresentation3(_CFApplicationPreferences *self, CFDictionaryRef hint, CFDictionaryRef insertion, CFPreferencesDomainRef afterDomain);
 154 CF_EXPORT CFDictionaryRef _CFApplicationPreferencesCopyRepresentationWithHint(_CFApplicationPreferences *self, CFDictionaryRef hint); // same as dictRep
 155 CF_EXPORT void _CFApplicationPreferencesSetStandardSearchList(_CFApplicationPreferences *appPreferences);
 156 CF_EXPORT void _CFApplicationPreferencesSetCacheForApp(_CFApplicationPreferences *appPrefs, CFStringRef appName);
 157 CF_EXPORT void _CFApplicationPreferencesAddSuitePreferences(_CFApplicationPreferences *appPrefs, CFStringRef suiteName);
 158 CF_EXPORT void _CFApplicationPreferencesRemoveSuitePreferences(_CFApplicationPreferences *appPrefs, CFStringRef suiteName);
 159
 160 CF_EXPORT void _CFApplicationPreferencesAddDomain(_CFApplicationPreferences *self, CFPreferencesDomainRef domain, Boolean addAtTop);
 161 CF_EXPORT Boolean _CFApplicationPreferencesContainsDomain(_CFApplicationPreferences *self, CFPreferencesDomainRef domain);
 162 CF_EXPORT void _CFApplicationPreferencesRemoveDomain(_CFApplicationPreferences *self, CFPreferencesDomainRef domain);
 163
 164 CF_EXPORT CFTypeRef _CFApplicationPreferencesSearchDownToDomain(_CFApplicationPreferences *self, CFPreferencesDomainRef stopper, CFStringRef key);
 165
 166
 167 CF_EXTERN_C_END
 168
 169
 170
 171 // ---- CFString material ----------------------------------------
 172
 173 #include <CoreFoundation/CFStringEncodingExt.h>
 174
 175 #define NSSTRING_BOUNDSERROR \
 176     [NSException raise:NSRangeException format:@"%@: Range or index out of bounds", __CFExceptionProem((id)self, _cmd)]
 177
 178 #define NSSTRING_RANGEERROR(range, len) \
 179     [NSException raise:NSRangeException format:@"%@: Range {%lu, %lu} out of bounds; string length %lu", __CFExceptionProem((id)self, _cmd), (unsigned long)range.location, (unsigned long)range.length, (unsigned long)len]
 180
 181 #define NSSTRING_INDEXERROR(index, len) \
 182     [NSException raise:NSRangeException format:@"%@: Index %lu out of bounds; string length %lu", __CFExceptionProem((id)self, _cmd), (unsigned long)index, (unsigned long)len]
 183
 184 // This can be made into an exception for post-10.9 apps
 185 #define NSSTRING_POSSIBLE_RANGEERROR(range, len)     \
 186     if (__CFStringNoteErrors()) {       \
 187         static bool warnonce = false;   \
 188         if (!warnonce) {                \
 189             warnonce = true;            \
 190             CFLog(kCFLogLevelWarning, CFSTR("*** %@: Range {%lu, %lu} out of bounds; string length %lu. This will become an exception for apps linked after 10.9. Warning shown once per app execution."), __CFExceptionProem((id)self, _cmd), (unsigned long)range.location, (unsigned long)range.length, (unsigned long)len);        \
 191     }   \
 192 }
 193
 194 #define NSSTRING_ILLEGALREQUESTERROR \
 195     [NSException raise:NSInvalidArgumentException format:@"Can't call %s in %@", sel_getName(_cmd), object_getClass((id)self)]
 196
 197 #define NSSTRING_INVALIDMUTATIONERROR \
 198     [NSException raise:NSInvalidArgumentException format:@"Attempt to mutate immutable object with %s", sel_getName(_cmd)]
 199
 200 #define NSSTRING_NULLCSTRINGERROR \
 201     [NSException raise:NSInvalidArgumentException format:@"%@: NULL cString", __CFExceptionProem((id)self, _cmd)]
 202
 203 #define NSSTRING_NILSTRINGERROR \
 204     [NSException raise:NSInvalidArgumentException format:@"%@: nil argument", __CFExceptionProem((id)self, _cmd)]
 205
 206
 207 CF_EXTERN_C_BEGIN
 208
 209 /* Create a byte stream from a CFString backing. Can convert a string piece at a
 210    time into a fixed size buffer. Returns number of characters converted.
 211    Characters that cannot be converted to the specified encoding are represented
 212    with the char specified by lossByte; if 0, then lossy conversion is not allowed
 213    and conversion stops, returning partial results.
 214    generatingExternalFile indicates that any extra stuff to allow this data to be
 215    persistent (for instance, BOM) should be included.
 216    Pass buffer==NULL if you don't care about the converted string (but just the
 217    convertability, or number of bytes required, indicated by usedBufLen).
 218    Does not zero-terminate. If you want to create Pascal or C string, allow one
 219    extra byte at start or end.
 220 */
 221 CF_EXPORT CFIndex __CFStringEncodeByteStream(CFStringRef string, CFIndex rangeLoc, CFIndex rangeLen, Boolean generatingExternalFile, CFStringEncoding encoding, char lossByte, UInt8 *buffer, CFIndex max, CFIndex *usedBufLen);
 222
 223 CF_EXPORT CFStringRef __CFStringCreateImmutableFunnel2(CFAllocatorRef alloc, const void *bytes, CFIndex numBytes, CFStringEncoding encoding, Boolean possiblyExternalFormat, Boolean tryToReduceUnicode, Boolean hasLengthByte, Boolean hasNullByte, Boolean noCopy, CFAllocatorRef contentsDeallocator);
 224
 225 CF_EXPORT void __CFStringAppendBytes(CFMutableStringRef str, const char *cStr, CFIndex appendedLength, CFStringEncoding encoding);
 226
 227 CF_INLINE Boolean __CFStringEncodingIsSupersetOfASCII(CFStringEncoding encoding) {
 228     switch (encoding & 0x0000FF00) {
 229         case 0x0: // MacOS Script range
 230             // Symbol & bidi encodings are not ASCII superset
 231             if (encoding == kCFStringEncodingMacJapanese || encoding == kCFStringEncodingMacArabic || encoding == kCFStringEncodingMacHebrew || encoding == kCFStringEncodingMacUkrainian || encoding == kCFStringEncodingMacSymbol || encoding == kCFStringEncodingMacDingbats) return false;
 232             return true;
 233
 234         case 0x100: // Unicode range
 235             if (encoding != kCFStringEncodingUTF8) return false;
 236             return true;
 237
 238         case 0x200: // ISO range
 239             if (encoding == kCFStringEncodingISOLatinArabic) return false;
 240             return true;
 241
 242         case 0x600: // National standards range
 243             if (encoding != kCFStringEncodingASCII) return false;
 244             return true;
 245
 246         case 0x800: // ISO 2022 range
 247             return false; // It's modal encoding
 248
 249         case 0xA00: // Misc standard range
 250             if ((encoding == kCFStringEncodingShiftJIS) || (encoding == kCFStringEncodingHZ_GB_2312) || (encoding == kCFStringEncodingUTF7_IMAP)) return false;
 251             return true;
 252
 253         case 0xB00:
 254             if (encoding == kCFStringEncodingNonLossyASCII) return false;
 255             return true;
 256
 257         case 0xC00: // EBCDIC
 258             return false;
 259
 260         default:
 261             return ((encoding & 0x0000FF00) > 0x0C00 ? false : true);
 262     }
 263 }
 264
 265
 266 /* Desperately using extern here */
 267 CF_EXPORT CFStringEncoding __CFDefaultEightBitStringEncoding;
 268 CF_EXPORT CFStringEncoding __CFStringComputeEightBitStringEncoding(void);
 269
 270 CF_INLINE CFStringEncoding __CFStringGetEightBitStringEncoding(void) {
 271     if (__CFDefaultEightBitStringEncoding == kCFStringEncodingInvalidId) __CFStringComputeEightBitStringEncoding();
 272     return __CFDefaultEightBitStringEncoding;
 273 }
 274
 275 enum {
 276      __kCFVarWidthLocalBufferSize = 1008
 277 };
 278
 279 typedef struct {      /* A simple struct to maintain ASCII/Unicode versions of the same buffer. */
 280      union {
 281         UInt8 *ascii;
 282         UniChar *unicode;
 283     } chars;
 284     Boolean isASCII;    /* This really does mean 7-bit ASCII, not _NSDefaultCStringEncoding() */
 285     Boolean shouldFreeChars;    /* If the number of bytes exceeds __kCFVarWidthLocalBufferSize, bytes are allocated */
 286     Boolean _unused1;
 287     Boolean _unused2;
 288     CFAllocatorRef allocator;   /* Use this allocator to allocate, reallocate, and deallocate the bytes */
 289     CFIndex numChars;   /* This is in terms of ascii or unicode; that is, if isASCII, it is number of 7-bit chars; otherwise it is number of UniChars; note that the actual allocated space might be larger */
 290     UInt8 localBuffer[__kCFVarWidthLocalBufferSize];    /* private; 168 ISO2022JP chars, 504 Unicode chars, 1008 ASCII chars */
 291 } CFVarWidthCharBuffer;
 292
 293
 294 /* Convert a byte stream to ASCII (7-bit!) or Unicode, with a CFVarWidthCharBuffer struct on the stack. false return indicates an error occured during the conversion. Depending on .isASCII, follow .chars.ascii or .chars.unicode.  If .shouldFreeChars is returned as true, free the returned buffer when done with it.  If useClientsMemoryPtr is provided as non-NULL, and the provided memory can be used as is, this is set to true, and the .ascii or .unicode buffer in CFVarWidthCharBuffer is set to bytes.
 295 !!! If the stream is Unicode and has no BOM, the data is assumed to be big endian! Could be trouble on Intel if someone didn't follow that assumption.
 296 !!! __CFStringDecodeByteStream2() needs to be deprecated and removed post-Jaguar.
 297 */
 298 CF_EXPORT Boolean __CFStringDecodeByteStream2(const UInt8 *bytes, UInt32 len, CFStringEncoding encoding, Boolean alwaysUnicode, CFVarWidthCharBuffer *buffer, Boolean *useClientsMemoryPtr);
 299 CF_EXPORT Boolean __CFStringDecodeByteStream3(const UInt8 *bytes, CFIndex len, CFStringEncoding encoding, Boolean alwaysUnicode, CFVarWidthCharBuffer *buffer, Boolean *useClientsMemoryPtr, UInt32 converterFlags);
 300
 301
 302 /* Convert single byte to Unicode; assumes one-to-one correspondence (that is, can only be used with 1-byte encodings). You can use the function if it's not NULL.
 303 */
 304 CF_EXPORT Boolean (*__CFCharToUniCharFunc)(UInt32 flags, UInt8 ch, UniChar *unicodeChar);
 305
 306 /* Character class functions UnicodeData-2_1_5.txt
 307 */
 308 CF_INLINE Boolean __CFIsWhitespace(UniChar theChar) {
 309     return ((theChar < 0x21) || (theChar > 0x7E && theChar < 0xA1) || (theChar >= 0x2000 && theChar <= 0x200B) || (theChar == 0x3000)) ? true : false;
 310 }
 311
 312 /* Same as CFStringGetCharacterFromInlineBuffer() but returns 0xFFFF on out of bounds access
 313 */
 314 CF_INLINE UniChar __CFStringGetCharacterFromInlineBufferAux(CFStringInlineBuffer *buf, CFIndex idx) {
 315     if (idx < 0 || idx >= buf->rangeToBuffer.length) return 0xFFFF;
 316     if (buf->directUniCharBuffer) return buf->directUniCharBuffer[idx + buf->rangeToBuffer.location];
 317     if (buf->directCStringBuffer) return (UniChar)(buf->directCStringBuffer[idx + buf->rangeToBuffer.location]);
 318     if (idx >= buf->bufferedRangeEnd || idx < buf->bufferedRangeStart) {
 319         if ((buf->bufferedRangeStart = idx - 4) < 0) buf->bufferedRangeStart = 0;
 320         buf->bufferedRangeEnd = buf->bufferedRangeStart + __kCFStringInlineBufferLength;
 321         if (buf->bufferedRangeEnd > buf->rangeToBuffer.length) buf->bufferedRangeEnd = buf->rangeToBuffer.length;
 322         CFStringGetCharacters(buf->theString, CFRangeMake(buf->rangeToBuffer.location + buf->bufferedRangeStart, buf->bufferedRangeEnd - buf->bufferedRangeStart), buf->buffer);
 323     }
 324     return buf->buffer[idx - buf->bufferedRangeStart];
 325 }
 326
 327 /* Same as CFStringGetCharacterFromInlineBuffer(), but without the bounds checking (will return garbage or crash)
 328 */
 329 CF_INLINE UniChar __CFStringGetCharacterFromInlineBufferQuick(CFStringInlineBuffer *buf, CFIndex idx) {
 330     if (buf->directUniCharBuffer) return buf->directUniCharBuffer[idx + buf->rangeToBuffer.location];
 331     if (buf->directCStringBuffer) return (UniChar)(buf->directCStringBuffer[idx + buf->rangeToBuffer.location]);
 332     if (idx >= buf->bufferedRangeEnd || idx < buf->bufferedRangeStart) {
 333         if ((buf->bufferedRangeStart = idx - 4) < 0) buf->bufferedRangeStart = 0;
 334         buf->bufferedRangeEnd = buf->bufferedRangeStart + __kCFStringInlineBufferLength;
 335         if (buf->bufferedRangeEnd > buf->rangeToBuffer.length) buf->bufferedRangeEnd = buf->rangeToBuffer.length;
 336         CFStringGetCharacters(buf->theString, CFRangeMake(buf->rangeToBuffer.location + buf->bufferedRangeStart, buf->bufferedRangeEnd - buf->bufferedRangeStart), buf->buffer);
 337     }
 338     return buf->buffer[idx - buf->bufferedRangeStart];
 339 }
 340
 341
 342 /* These two allow specifying an alternate description function (instead of CFCopyDescription); used by NSString
 343 */
 344 CF_EXPORT void _CFStringAppendFormatAndArgumentsAux(CFMutableStringRef outputString, CFStringRef (*copyDescFunc)(void *, const void *loc), CFDictionaryRef formatOptions, CFStringRef formatString, va_list args);
 345 CF_EXPORT CFStringRef  _CFStringCreateWithFormatAndArgumentsAux(CFAllocatorRef alloc, CFStringRef (*copyDescFunc)(void *, const void *loc), CFDictionaryRef formatOptions, CFStringRef format, va_list arguments);
 346
 347 /* For NSString (and NSAttributedString) usage, mutate with isMutable check
 348 */
 349 enum {_CFStringErrNone = 0, _CFStringErrNotMutable = 1, _CFStringErrNilArg = 2, _CFStringErrBounds = 3};
 350 CF_EXPORT int __CFStringCheckAndReplace(CFMutableStringRef str, CFRange range, CFStringRef replacement);
 351 CF_EXPORT Boolean __CFStringNoteErrors(void);           // Should string errors raise?
 352
 353 /* For NSString usage, guarantees that the contents can be extracted as 8-bit bytes in the __CFStringGetEightBitStringEncoding().
 354 */
 355 CF_EXPORT Boolean __CFStringIsEightBit(CFStringRef str);
 356
 357 /* For NSCFString usage, these do range check (where applicable) but don't check for ObjC dispatch
 358 */
 359 CF_EXPORT int _CFStringCheckAndGetCharacterAtIndex(CFStringRef str, CFIndex idx, UniChar *ch);
 360 CF_EXPORT int _CFStringCheckAndGetCharacters(CFStringRef str, CFRange range, UniChar *buffer);
 361 CF_EXPORT CFIndex _CFStringGetLength2(CFStringRef str);
 362 CF_EXPORT CFHashCode __CFStringHash(CFTypeRef cf);
 363 CF_EXPORT CFHashCode CFStringHashISOLatin1CString(const uint8_t *bytes, CFIndex len);
 364 CF_EXPORT CFHashCode CFStringHashCString(const uint8_t *bytes, CFIndex len);
 365 CF_EXPORT CFHashCode CFStringHashCharacters(const UniChar *characters, CFIndex len);
 366 CF_EXPORT CFHashCode CFStringHashNSString(CFStringRef str);
 367
 368
 369 CF_EXTERN_C_END
 370
 371
 372 // ---- Binary plist material ----------------------------------------
 373
 374 typedef const struct __CFKeyedArchiverUID * CFKeyedArchiverUIDRef;
 375 CF_EXPORT CFTypeID _CFKeyedArchiverUIDGetTypeID(void);
 376 CF_EXPORT CFKeyedArchiverUIDRef _CFKeyedArchiverUIDCreate(CFAllocatorRef allocator, uint32_t value);
 377 CF_EXPORT uint32_t _CFKeyedArchiverUIDGetValue(CFKeyedArchiverUIDRef uid);
 378
 379
 380 enum {
 381     kCFBinaryPlistMarkerNull = 0x00,
 382     kCFBinaryPlistMarkerFalse = 0x08,
 383     kCFBinaryPlistMarkerTrue = 0x09,
 384     kCFBinaryPlistMarkerFill = 0x0F,
 385     kCFBinaryPlistMarkerInt = 0x10,
 386     kCFBinaryPlistMarkerReal = 0x20,
 387     kCFBinaryPlistMarkerDate = 0x33,
 388     kCFBinaryPlistMarkerData = 0x40,
 389     kCFBinaryPlistMarkerASCIIString = 0x50,
 390     kCFBinaryPlistMarkerUnicode16String = 0x60,
 391     kCFBinaryPlistMarkerUID = 0x80,
 392     kCFBinaryPlistMarkerArray = 0xA0,
 393     kCFBinaryPlistMarkerSet = 0xC0,
 394     kCFBinaryPlistMarkerDict = 0xD0
 395 };
 396
 397 typedef struct {
 398     uint8_t     _magic[6];
 399     uint8_t     _version[2];
 400 } CFBinaryPlistHeader;
 401
 402 typedef struct {
 403     uint8_t     _unused[5];
 404     uint8_t     _sortVersion;
 405     uint8_t     _offsetIntSize;
 406     uint8_t     _objectRefSize;
 407     uint64_t    _numObjects;
 408     uint64_t    _topObject;
 409     uint64_t    _offsetTableOffset;
 410 } CFBinaryPlistTrailer;
 411
 412
 413 CF_EXPORT bool __CFBinaryPlistGetTopLevelInfo(const uint8_t *databytes, uint64_t datalen, uint8_t *marker, uint64_t *offset, CFBinaryPlistTrailer *trailer);
 414 CF_EXPORT bool __CFBinaryPlistGetOffsetForValueFromArray2(const uint8_t *databytes, uint64_t datalen, uint64_t startOffset, const CFBinaryPlistTrailer *trailer, CFIndex idx, uint64_t *offset, CFMutableDictionaryRef objects);
 415 CF_EXPORT bool __CFBinaryPlistGetOffsetForValueFromDictionary3(const uint8_t *databytes, uint64_t datalen, uint64_t startOffset, const CFBinaryPlistTrailer *trailer, CFTypeRef key, uint64_t *koffset, uint64_t *voffset, Boolean unused, CFMutableDictionaryRef objects);
 416 CF_EXPORT bool __CFBinaryPlistCreateObject(const uint8_t *databytes, uint64_t datalen, uint64_t startOffset, const CFBinaryPlistTrailer *trailer, CFAllocatorRef allocator, CFOptionFlags mutabilityOption, CFMutableDictionaryRef objects, CFPropertyListRef *plist);
 417 CF_EXPORT CFIndex __CFBinaryPlistWriteToStream(CFPropertyListRef plist, CFTypeRef stream);
 418 CF_EXPORT CFIndex __CFBinaryPlistWriteToStreamWithEstimate(CFPropertyListRef plist, CFTypeRef stream, uint64_t estimate); // will be removed soon
 419 CF_EXPORT CFIndex __CFBinaryPlistWriteToStreamWithOptions(CFPropertyListRef plist, CFTypeRef stream, uint64_t estimate, CFOptionFlags options); // will be removed soon
 420 CF_EXPORT CFIndex __CFBinaryPlistWrite(CFPropertyListRef plist, CFTypeRef stream, uint64_t estimate, CFOptionFlags options, CFErrorRef *error);
 421
 422 // ---- Used by property list parsing in Foundation
 423
 424 CF_EXPORT CFTypeRef _CFPropertyListCreateFromXMLData(CFAllocatorRef allocator, CFDataRef xmlData, CFOptionFlags option, CFStringRef *errorString, Boolean allowNewTypes, CFPropertyListFormat *format);
 425
 426 CF_EXPORT CFTypeRef _CFPropertyListCreateFromXMLString(CFAllocatorRef allocator, CFStringRef xmlString, CFOptionFlags option, CFStringRef *errorString, Boolean allowNewTypes, CFPropertyListFormat *format);
 427
 428 // ---- Sudden Termination material ----------------------------------------
 429
 430 #if DEPLOYMENT_TARGET_MACOSX
 431
 432 CF_EXPORT void _CFSuddenTerminationDisable(void);
 433 CF_EXPORT void _CFSuddenTerminationEnable(void);
 434 CF_EXPORT void _CFSuddenTerminationExitIfTerminationEnabled(int exitStatus);
 435 CF_EXPORT void _CFSuddenTerminationExitWhenTerminationEnabled(int exitStatus);
 436 CF_EXPORT size_t _CFSuddenTerminationDisablingCount(void);
 437
 438 #endif
 439
 440 // ---- Thread-specific data --------------------------------------------
 441
 442 // Get some thread specific data from a pre-assigned slot.
 443 CF_EXPORT void *_CFGetTSD(uint32_t slot);
 444
 445 // Set some thread specific data in a pre-assigned slot. Don't pick a random value. Make sure you're using a slot that is unique. Pass in a destructor to free this data, or NULL if none is needed. Unlike pthread TSD, the destructor is per-thread.
 446 CF_EXPORT void *_CFSetTSD(uint32_t slot, void *newVal, void (*destructor)(void *));
 447
 448 #if DEPLOYMENT_TARGET_WINDOWS
 449 // ---- Windows-specific material ---------------------------------------
 450
 451 // These are replacements for POSIX calls on Windows, ensuring that the UTF8 parameters are converted to UTF16 before being passed to Windows
 452 CF_EXPORT int _NS_stat(const char *name, struct _stat *st);
 453 CF_EXPORT int _NS_mkdir(const char *name);
 454 CF_EXPORT int _NS_rmdir(const char *name);
 455 CF_EXPORT int _NS_chmod(const char *name, int mode);
 456 CF_EXPORT int _NS_unlink(const char *name);
 457 CF_EXPORT char *_NS_getcwd(char *dstbuf, size_t size);     // Warning: this doesn't support dstbuf as null even though 'getcwd' does
 458 CF_EXPORT char *_NS_getenv(const char *name);
 459 CF_EXPORT int _NS_rename(const char *oldName, const char *newName);
 460 CF_EXPORT int _NS_open(const char *name, int oflag, int pmode);
 461 CF_EXPORT int _NS_mkstemp(char *name, int bufSize);
 462 #endif
 463
 464 // ---- Miscellaneous material ----------------------------------------
 465
 466 #include <CoreFoundation/CFBag.h>
 467 #include <CoreFoundation/CFSet.h>
 468 #include <math.h>
 469
 470 CF_EXTERN_C_BEGIN
 471
 472 CF_EXPORT CFTypeID CFTypeGetTypeID(void);
 473
 474 CF_EXPORT void _CFArraySetCapacity(CFMutableArrayRef array, CFIndex cap);
 475 CF_EXPORT void _CFBagSetCapacity(CFMutableBagRef bag, CFIndex cap);
 476 CF_EXPORT void _CFDictionarySetCapacity(CFMutableDictionaryRef dict, CFIndex cap);
 477 CF_EXPORT void _CFSetSetCapacity(CFMutableSetRef set, CFIndex cap);
 478
 479 CF_EXPORT void CFCharacterSetCompact(CFMutableCharacterSetRef theSet);
 480 CF_EXPORT void CFCharacterSetFast(CFMutableCharacterSetRef theSet);
 481
 482 CF_EXPORT const void *_CFArrayCheckAndGetValueAtIndex(CFArrayRef array, CFIndex idx);
 483 CF_EXPORT void _CFArrayReplaceValues(CFMutableArrayRef array, CFRange range, const void **newValues, CFIndex newCount);
 484
 485
 486 /* Enumeration
 487  Call CFStartSearchPathEnumeration() once, then call
 488  CFGetNextSearchPathEnumeration() one or more times with the returned state.
 489  The return value of CFGetNextSearchPathEnumeration() should be used as
 490  the state next time around.
 491  When CFGetNextSearchPathEnumeration() returns 0, you're done.
 492 */
 493 typedef CFIndex CFSearchPathEnumerationState;
 494 CF_EXPORT CFSearchPathEnumerationState __CFStartSearchPathEnumeration(CFSearchPathDirectory dir, CFSearchPathDomainMask domainMask);
 495 CF_EXPORT CFSearchPathEnumerationState __CFGetNextSearchPathEnumeration(CFSearchPathEnumerationState state, UInt8 *path, CFIndex pathSize);
 496
 497 /* For use by NSNumber and CFNumber.
 498   Hashing algorithm for CFNumber:
 499   M = Max CFHashCode (assumed to be unsigned)
 500   For positive integral values: (N * HASHFACTOR) mod M
 501   For negative integral values: ((-N) * HASHFACTOR) mod M
 502   For floating point numbers that are not integral: hash(integral part) + hash(float part * M)
 503   HASHFACTOR is 2654435761, from Knuth's multiplicative method
 504 */
 505 #define HASHFACTOR 2654435761U
 506
 507 CF_INLINE CFHashCode _CFHashInt(long i) {
 508     return ((i > 0) ? (CFHashCode)(i) : (CFHashCode)(-i)) * HASHFACTOR;
 509 }
 510
 511 CF_INLINE CFHashCode _CFHashDouble(double d) {
 512     double dInt;
 513     if (d < 0) d = -d;
 514     dInt = floor(d+0.5);
 515     CFHashCode integralHash = HASHFACTOR * (CFHashCode)fmod(dInt, (double)ULONG_MAX);
 516     return (CFHashCode)(integralHash + (CFHashCode)((d - dInt) * ULONG_MAX));
 517 }
 518
 519
 520 /* These four functions are used by NSError in formatting error descriptions. They take NS or CFError as arguments and return a retained CFString or NULL.
 521 */
 522 CF_EXPORT CFStringRef _CFErrorCreateLocalizedDescription(CFErrorRef err);
 523 CF_EXPORT CFStringRef _CFErrorCreateLocalizedFailureReason(CFErrorRef err);
 524 CF_EXPORT CFStringRef _CFErrorCreateLocalizedRecoverySuggestion(CFErrorRef err);
 525 CF_EXPORT CFStringRef _CFErrorCreateDebugDescription(CFErrorRef err);
 526
 527 CF_EXPORT CFURLRef _CFURLAlloc(CFAllocatorRef allocator);
 528 CF_EXPORT Boolean _CFURLInitWithURLString(CFURLRef uninitializedURL, CFStringRef string, Boolean checkForLegalCharacters, CFURLRef baseURL);
 529 CF_EXPORT Boolean _CFURLInitWithFileSystemPath(CFURLRef uninitializedURL, CFStringRef fileSystemPath, CFURLPathStyle pathStyle, Boolean isDirectory, CFURLRef baseURL);
 530 CF_EXPORT Boolean _CFURLInitWithFileSystemRepresentation(CFURLRef uninitializedURL, const UInt8 *buffer, CFIndex bufLen, Boolean isDirectory, CFURLRef baseURL);
 531 CF_EXPORT void *__CFURLReservedPtr(CFURLRef  url);
 532 CF_EXPORT void __CFURLSetReservedPtr(CFURLRef  url, void *ptr);
 533 CF_EXPORT CFStringEncoding _CFURLGetEncoding(CFURLRef url);
 534
 535 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI || DEPLOYMENT_TARGET_WINDOWS
 536 CF_EXPORT Boolean _CFRunLoopFinished(CFRunLoopRef rl, CFStringRef mode);
 537 #endif
 538
 539 CF_EXPORT CFIndex _CFStreamInstanceSize(void);
 540
 541 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
 542 typedef struct {
 543     mach_vm_address_t address;
 544     mach_vm_size_t size;
 545     mach_port_t port;
 546     bool purgeable;
 547     bool corporeal;
 548     bool volatyle;
 549     uintptr_t reserved;
 550 } CFDiscorporateMemory;
 551
 552 extern kern_return_t _CFDiscorporateMemoryAllocate(CFDiscorporateMemory *hm, size_t size, bool purgeable);
 553 extern kern_return_t _CFDiscorporateMemoryDeallocate(CFDiscorporateMemory *hm);
 554 extern kern_return_t _CFDiscorporateMemoryDematerialize(CFDiscorporateMemory *hm);
 555 extern kern_return_t _CFDiscorporateMemoryMaterialize(CFDiscorporateMemory *hm);
 556 #endif
 557
 558 enum {
 559     kCFNumberFormatterOrdinalStyle = 6,
 560     kCFNumberFormatterDurationStyle = 7,
 561 };
 562
 563 CF_EXPORT CFRange _CFDataFindBytes(CFDataRef data, CFDataRef dataToFind, CFRange searchRange, CFDataSearchFlags compareOptions);
 564
 565
 566 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
 567     #if !defined(__CFReadTSR)
 568     #include <mach/mach_time.h>
 569     #define __CFReadTSR() mach_absolute_time()
 570     #endif
 571 #elif DEPLOYMENT_TARGET_WINDOWS
 572 #if 0
 573 CF_INLINE UInt64 __CFReadTSR(void) {
 574     LARGE_INTEGER freq;
 575     QueryPerformanceCounter(&freq);
 576     return freq.QuadPart;
 577 }
 578 #endif
 579 #endif
 580
 581
 582 CF_EXTERN_C_END
 583
 584 #endif /* ! __COREFOUNDATION_FORFOUNDATIONONLY__ */
 585