ForFoundationOnly.h

   1 /*
   2  * Copyright (c) 2008 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 /*      ForFoundationOnly.h
  24         Copyright (c) 1998-2007, Apple Inc. All rights reserved.
  25 */
  26
  27 #if !CF_BUILDING_CF && !NSBUILDINGFOUNDATION
  28     #error The header file ForFoundationOnly.h is for the exclusive use of the
  29     #error CoreFoundation and Foundation projects.  No other project should include it.
  30 #endif
  31
  32 #if !defined(__COREFOUNDATION_FORFOUNDATIONONLY__)
  33 #define __COREFOUNDATION_FORFOUNDATIONONLY__ 1
  34
  35 #include <CoreFoundation/CFBase.h>
  36 #include <CoreFoundation/CFString.h>
  37 #include <CoreFoundation/CFArray.h>
  38 #include <CoreFoundation/CFDictionary.h>
  39 #include <CoreFoundation/CFPriv.h>
  40 #include <CoreFoundation/CFPropertyList.h>
  41 #include <CoreFoundation/CFError.h>
  42 #include <CoreFoundation/CFStringEncodingExt.h>
  43 #include <limits.h>
  44
  45 // NOTE: miscellaneous declarations are at the end
  46
  47 // ---- CFRuntime material ----------------------------------------
  48
  49 CF_EXTERN_C_BEGIN
  50
  51 #if DEPLOYMENT_TARGET_MACOSX || 0
  52 #include <malloc/malloc.h>
  53 #endif //__MACH__
  54
  55 CF_EXTERN_C_END
  56
  57 // ---- CFBundle material ----------------------------------------
  58
  59 #include <CoreFoundation/CFBundlePriv.h>
  60
  61 CF_EXTERN_C_BEGIN
  62
  63 CF_EXPORT const CFStringRef _kCFBundleExecutablePathKey;
  64 CF_EXPORT const CFStringRef _kCFBundleInfoPlistURLKey;
  65 CF_EXPORT const CFStringRef _kCFBundleRawInfoPlistURLKey;
  66 CF_EXPORT const CFStringRef _kCFBundleNumericVersionKey;
  67 CF_EXPORT const CFStringRef _kCFBundleResourcesFileMappedKey;
  68 CF_EXPORT const CFStringRef _kCFBundleCFMLoadAsBundleKey;
  69 CF_EXPORT const CFStringRef _kCFBundleAllowMixedLocalizationsKey;
  70 CF_EXPORT const CFStringRef _kCFBundleInitialPathKey;
  71 CF_EXPORT const CFStringRef _kCFBundleResolvedPathKey;
  72 CF_EXPORT const CFStringRef _kCFBundlePrincipalClassKey;
  73
  74 CF_EXPORT CFArrayRef _CFFindBundleResources(CFBundleRef bundle, CFURLRef bundleURL, CFStringRef subDirName, CFArrayRef searchLanguages, CFStringRef resName, CFArrayRef resTypes, CFIndex limit, UInt8 version);
  75
  76 CF_EXPORT UInt8 _CFBundleLayoutVersion(CFBundleRef bundle);
  77
  78 CF_EXPORT CFArrayRef _CFBundleCopyLanguageSearchListInDirectory(CFAllocatorRef alloc, CFURLRef url, UInt8 *version);
  79 CF_EXPORT CFArrayRef _CFBundleGetLanguageSearchList(CFBundleRef bundle);
  80
  81 CF_EXPORT Boolean _CFBundleLoadExecutableAndReturnError(CFBundleRef bundle, Boolean forceGlobal, CFErrorRef *error);
  82 CF_EXPORT CFErrorRef _CFBundleCreateError(CFAllocatorRef allocator, CFBundleRef bundle, CFIndex code);
  83
  84 CF_EXTERN_C_END
  85
  86
  87 #if (DEPLOYMENT_TARGET_MACOSX || 0) || defined (__WIN32__)
  88 // ---- CFPreferences material ----------------------------------------
  89
  90 #define DEBUG_PREFERENCES_MEMORY 0
  91
  92 #if DEBUG_PREFERENCES_MEMORY
  93 #include "../Tests/CFCountingAllocator.h"
  94 #endif
  95
  96 CF_EXTERN_C_BEGIN
  97
  98 extern void _CFPreferencesPurgeDomainCache(void);
  99
 100 typedef struct {
 101     void *      (*createDomain)(CFAllocatorRef allocator, CFTypeRef context);
 102     void        (*freeDomain)(CFAllocatorRef allocator, CFTypeRef context, void *domain);
 103     CFTypeRef   (*fetchValue)(CFTypeRef context, void *domain, CFStringRef key); // Caller releases
 104     void        (*writeValue)(CFTypeRef context, void *domain, CFStringRef key, CFTypeRef value);
 105     Boolean     (*synchronize)(CFTypeRef context, void *domain);
 106     void        (*getKeysAndValues)(CFAllocatorRef alloc, CFTypeRef context, void *domain, void **buf[], CFIndex *numKeyValuePairs);
 107     CFDictionaryRef (*copyDomainDictionary)(CFTypeRef context, void *domain);
 108     /* HACK - see comment on _CFPreferencesDomainSetIsWorldReadable(), below */
 109     void        (*setIsWorldReadable)(CFTypeRef context, void *domain, Boolean isWorldReadable);
 110 } _CFPreferencesDomainCallBacks;
 111
 112 CF_EXPORT CFAllocatorRef __CFPreferencesAllocator(void);
 113 CF_EXPORT  const _CFPreferencesDomainCallBacks __kCFVolatileDomainCallBacks;
 114 CF_EXPORT const _CFPreferencesDomainCallBacks __kCFXMLPropertyListDomainCallBacks;
 115
 116 typedef struct __CFPreferencesDomain * CFPreferencesDomainRef;
 117
 118 CF_EXPORT CFPreferencesDomainRef _CFPreferencesDomainCreate(CFTypeRef context, const _CFPreferencesDomainCallBacks *callBacks);
 119 CF_EXPORT CFPreferencesDomainRef _CFPreferencesStandardDomain(CFStringRef domainName, CFStringRef userName, CFStringRef hostName);
 120
 121 CF_EXPORT CFTypeRef _CFPreferencesDomainCreateValueForKey(CFPreferencesDomainRef domain, CFStringRef key);
 122 CF_EXPORT void _CFPreferencesDomainSet(CFPreferencesDomainRef domain, CFStringRef key, CFTypeRef value);
 123 CF_EXPORT Boolean _CFPreferencesDomainSynchronize(CFPreferencesDomainRef domain);
 124
 125 CF_EXPORT CFArrayRef _CFPreferencesCreateDomainList(CFStringRef userName, CFStringRef hostName);
 126 CF_EXPORT Boolean _CFSynchronizeDomainCache(void);
 127
 128 CF_EXPORT void _CFPreferencesDomainSetDictionary(CFPreferencesDomainRef domain, CFDictionaryRef dict);
 129 CF_EXPORT CFDictionaryRef _CFPreferencesDomainDeepCopyDictionary(CFPreferencesDomainRef domain);
 130 CF_EXPORT Boolean _CFPreferencesDomainExists(CFStringRef domainName, CFStringRef userName, CFStringRef hostName);
 131
 132 /* 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 */
 133 CF_EXPORT void _CFPreferencesDomainSetIsWorldReadable(CFPreferencesDomainRef domain, Boolean isWorldReadable);
 134
 135 typedef struct {
 136     CFMutableArrayRef _search;  // the search list; an array of _CFPreferencesDomains
 137     CFMutableDictionaryRef _dictRep; // Mutable; a collapsed view of the search list, expressed as a single dictionary
 138     CFStringRef _appName;
 139 } _CFApplicationPreferences;
 140
 141 CF_EXPORT _CFApplicationPreferences *_CFStandardApplicationPreferences(CFStringRef appName);
 142 CF_EXPORT _CFApplicationPreferences *_CFApplicationPreferencesCreateWithUser(CFStringRef userName, CFStringRef appName);
 143 CF_EXPORT void _CFDeallocateApplicationPreferences(_CFApplicationPreferences *self);
 144 CF_EXPORT CFTypeRef _CFApplicationPreferencesCreateValueForKey(_CFApplicationPreferences *prefs, CFStringRef key);
 145 CF_EXPORT void _CFApplicationPreferencesSet(_CFApplicationPreferences *self, CFStringRef defaultName, CFTypeRef value);
 146 CF_EXPORT void _CFApplicationPreferencesRemove(_CFApplicationPreferences *self, CFStringRef defaultName);
 147 CF_EXPORT Boolean _CFApplicationPreferencesSynchronize(_CFApplicationPreferences *self);
 148 CF_EXPORT void _CFApplicationPreferencesUpdate(_CFApplicationPreferences *self); // same as updateDictRep
 149 CF_EXPORT CFDictionaryRef _CFApplicationPreferencesCopyRepresentation3(_CFApplicationPreferences *self, CFDictionaryRef hint, CFDictionaryRef insertion, CFPreferencesDomainRef afterDomain);
 150 CF_EXPORT CFDictionaryRef _CFApplicationPreferencesCopyRepresentationWithHint(_CFApplicationPreferences *self, CFDictionaryRef hint); // same as dictRep
 151 CF_EXPORT void _CFApplicationPreferencesSetStandardSearchList(_CFApplicationPreferences *appPreferences);
 152 CF_EXPORT void _CFApplicationPreferencesSetCacheForApp(_CFApplicationPreferences *appPrefs, CFStringRef appName);
 153 CF_EXPORT void _CFApplicationPreferencesAddSuitePreferences(_CFApplicationPreferences *appPrefs, CFStringRef suiteName);
 154 CF_EXPORT void _CFApplicationPreferencesRemoveSuitePreferences(_CFApplicationPreferences *appPrefs, CFStringRef suiteName);
 155
 156 CF_EXPORT void _CFApplicationPreferencesAddDomain(_CFApplicationPreferences *self, CFPreferencesDomainRef domain, Boolean addAtTop);
 157 CF_EXPORT Boolean _CFApplicationPreferencesContainsDomain(_CFApplicationPreferences *self, CFPreferencesDomainRef domain);
 158 CF_EXPORT void _CFApplicationPreferencesRemoveDomain(_CFApplicationPreferences *self, CFPreferencesDomainRef domain);
 159
 160 CF_EXPORT CFTypeRef _CFApplicationPreferencesSearchDownToDomain(_CFApplicationPreferences *self, CFPreferencesDomainRef stopper, CFStringRef key);
 161
 162
 163 CF_EXTERN_C_END
 164
 165 #endif
 166
 167 // ---- CFString material ----------------------------------------
 168
 169
 170 CF_EXTERN_C_BEGIN
 171
 172 /* Create a byte stream from a CFString backing. Can convert a string piece at a
 173    time into a fixed size buffer. Returns number of characters converted.
 174    Characters that cannot be converted to the specified encoding are represented
 175    with the char specified by lossByte; if 0, then lossy conversion is not allowed
 176    and conversion stops, returning partial results.
 177    generatingExternalFile indicates that any extra stuff to allow this data to be
 178    persistent (for instance, BOM) should be included.
 179    Pass buffer==NULL if you don't care about the converted string (but just the
 180    convertability, or number of bytes required, indicated by usedBufLen).
 181    Does not zero-terminate. If you want to create Pascal or C string, allow one
 182    extra byte at start or end.
 183 */
 184 CF_EXPORT CFIndex __CFStringEncodeByteStream(CFStringRef string, CFIndex rangeLoc, CFIndex rangeLen, Boolean generatingExternalFile, CFStringEncoding encoding, char lossByte, UInt8 *buffer, CFIndex max, CFIndex *usedBufLen);
 185
 186 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);
 187
 188 CF_INLINE Boolean __CFStringEncodingIsSupersetOfASCII(CFStringEncoding encoding) {
 189     switch (encoding & 0x0000FF00) {
 190
 191         case 0x100: // Unicode range
 192             if (encoding != kCFStringEncodingUTF8) return false;
 193             return true;
 194
 195
 196         case 0x600: // National standards range
 197             if (encoding != kCFStringEncodingASCII) return false;
 198             return true;
 199
 200         case 0x800: // ISO 2022 range
 201             return false; // It's modal encoding
 202
 203
 204         case 0xB00:
 205             if (encoding == kCFStringEncodingNonLossyASCII) return false;
 206             return true;
 207
 208         case 0xC00: // EBCDIC
 209             return false;
 210
 211         default:
 212             return ((encoding & 0x0000FF00) > 0x0C00 ? false : true);
 213     }
 214 }
 215
 216
 217 /* Desperately using extern here */
 218 CF_EXPORT CFStringEncoding __CFDefaultEightBitStringEncoding;
 219 CF_EXPORT CFStringEncoding __CFStringComputeEightBitStringEncoding(void);
 220
 221 CF_INLINE CFStringEncoding __CFStringGetEightBitStringEncoding(void) {
 222     if (__CFDefaultEightBitStringEncoding == kCFStringEncodingInvalidId) __CFStringComputeEightBitStringEncoding();
 223     return __CFDefaultEightBitStringEncoding;
 224 }
 225
 226 enum {
 227      __kCFVarWidthLocalBufferSize = 1008
 228 };
 229
 230 typedef struct {      /* A simple struct to maintain ASCII/Unicode versions of the same buffer. */
 231      union {
 232         UInt8 *ascii;
 233         UniChar *unicode;
 234     } chars;
 235     Boolean isASCII;    /* This really does mean 7-bit ASCII, not _NSDefaultCStringEncoding() */
 236     Boolean shouldFreeChars;    /* If the number of bytes exceeds __kCFVarWidthLocalBufferSize, bytes are allocated */
 237     Boolean _unused1;
 238     Boolean _unused2;
 239     CFAllocatorRef allocator;   /* Use this allocator to allocate, reallocate, and deallocate the bytes */
 240     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 */
 241     UInt8 localBuffer[__kCFVarWidthLocalBufferSize];    /* private; 168 ISO2022JP chars, 504 Unicode chars, 1008 ASCII chars */
 242 } CFVarWidthCharBuffer;
 243
 244
 245 /* 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.
 246 !!! 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.
 247 !!! __CFStringDecodeByteStream2() needs to be deprecated and removed post-Jaguar.
 248 */
 249 CF_EXPORT Boolean __CFStringDecodeByteStream2(const UInt8 *bytes, UInt32 len, CFStringEncoding encoding, Boolean alwaysUnicode, CFVarWidthCharBuffer *buffer, Boolean *useClientsMemoryPtr);
 250 CF_EXPORT Boolean __CFStringDecodeByteStream3(const UInt8 *bytes, CFIndex len, CFStringEncoding encoding, Boolean alwaysUnicode, CFVarWidthCharBuffer *buffer, Boolean *useClientsMemoryPtr, UInt32 converterFlags);
 251
 252
 253 /* 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. The table is always safe to use; calling __CFSetCharToUniCharFunc() updates it.
 254 */
 255 CF_EXPORT Boolean (*__CFCharToUniCharFunc)(UInt32 flags, UInt8 ch, UniChar *unicodeChar);
 256 CF_EXPORT void __CFSetCharToUniCharFunc(Boolean (*func)(UInt32 flags, UInt8 ch, UniChar *unicodeChar));
 257 CF_EXPORT UniChar __CFCharToUniCharTable[256];
 258
 259 /* Character class functions UnicodeData-2_1_5.txt
 260 */
 261 CF_INLINE Boolean __CFIsWhitespace(UniChar theChar) {
 262     return ((theChar < 0x21) || (theChar > 0x7E && theChar < 0xA1) || (theChar >= 0x2000 && theChar <= 0x200B) || (theChar == 0x3000)) ? true : false;
 263 }
 264
 265 /* Same as CFStringGetCharacterFromInlineBuffer() but returns 0xFFFF on out of bounds access
 266 */
 267 CF_INLINE UniChar __CFStringGetCharacterFromInlineBufferAux(CFStringInlineBuffer *buf, CFIndex idx) {
 268     if (buf->directBuffer) {
 269         if (idx < 0 || idx >= buf->rangeToBuffer.length) return 0xFFFF;
 270         return buf->directBuffer[idx + buf->rangeToBuffer.location];
 271     }
 272     if (idx >= buf->bufferedRangeEnd || idx < buf->bufferedRangeStart) {
 273         if (idx < 0 || idx >= buf->rangeToBuffer.length) return 0xFFFF;
 274         if ((buf->bufferedRangeStart = idx - 4) < 0) buf->bufferedRangeStart = 0;
 275         buf->bufferedRangeEnd = buf->bufferedRangeStart + __kCFStringInlineBufferLength;
 276         if (buf->bufferedRangeEnd > buf->rangeToBuffer.length) buf->bufferedRangeEnd = buf->rangeToBuffer.length;
 277         CFStringGetCharacters(buf->theString, CFRangeMake(buf->rangeToBuffer.location + buf->bufferedRangeStart, buf->bufferedRangeEnd - buf->bufferedRangeStart), buf->buffer);
 278     }
 279     return buf->buffer[idx - buf->bufferedRangeStart];
 280 }
 281
 282 /* Same as CFStringGetCharacterFromInlineBuffer(), but without the bounds checking (will return garbage or crash)
 283 */
 284 CF_INLINE UniChar __CFStringGetCharacterFromInlineBufferQuick(CFStringInlineBuffer *buf, CFIndex idx) {
 285     if (buf->directBuffer) return buf->directBuffer[idx + buf->rangeToBuffer.location];
 286     if (idx >= buf->bufferedRangeEnd || idx < buf->bufferedRangeStart) {
 287         if ((buf->bufferedRangeStart = idx - 4) < 0) buf->bufferedRangeStart = 0;
 288         buf->bufferedRangeEnd = buf->bufferedRangeStart + __kCFStringInlineBufferLength;
 289         if (buf->bufferedRangeEnd > buf->rangeToBuffer.length) buf->bufferedRangeEnd = buf->rangeToBuffer.length;
 290         CFStringGetCharacters(buf->theString, CFRangeMake(buf->rangeToBuffer.location + buf->bufferedRangeStart, buf->bufferedRangeEnd - buf->bufferedRangeStart), buf->buffer);
 291     }
 292     return buf->buffer[idx - buf->bufferedRangeStart];
 293 }
 294
 295
 296 /* These two allow specifying an alternate description function (instead of CFCopyDescription); used by NSString
 297 */
 298 CF_EXPORT void _CFStringAppendFormatAndArgumentsAux(CFMutableStringRef outputString, CFStringRef (*copyDescFunc)(void *, const void *loc), CFDictionaryRef formatOptions, CFStringRef formatString, va_list args);
 299 CF_EXPORT CFStringRef  _CFStringCreateWithFormatAndArgumentsAux(CFAllocatorRef alloc, CFStringRef (*copyDescFunc)(void *, const void *loc), CFDictionaryRef formatOptions, CFStringRef format, va_list arguments);
 300
 301 /* For NSString (and NSAttributedString) usage, mutate with isMutable check
 302 */
 303 enum {_CFStringErrNone = 0, _CFStringErrNotMutable = 1, _CFStringErrNilArg = 2, _CFStringErrBounds = 3};
 304 CF_EXPORT int __CFStringCheckAndReplace(CFMutableStringRef str, CFRange range, CFStringRef replacement);
 305 CF_EXPORT Boolean __CFStringNoteErrors(void);           // Should string errors raise?
 306
 307 /* For NSString usage, guarantees that the contents can be extracted as 8-bit bytes in the __CFStringGetEightBitStringEncoding().
 308 */
 309 CF_EXPORT Boolean __CFStringIsEightBit(CFStringRef str);
 310
 311 /* For NSCFString usage, these do range check (where applicable) but don't check for ObjC dispatch
 312 */
 313 CF_EXPORT int _CFStringCheckAndGetCharacterAtIndex(CFStringRef str, CFIndex idx, UniChar *ch);
 314 CF_EXPORT int _CFStringCheckAndGetCharacters(CFStringRef str, CFRange range, UniChar *buffer);
 315 CF_EXPORT CFIndex _CFStringGetLength2(CFStringRef str);
 316 CF_EXPORT CFHashCode __CFStringHash(CFTypeRef cf);
 317 CF_EXPORT CFHashCode CFStringHashISOLatin1CString(const uint8_t *bytes, CFIndex len);
 318 CF_EXPORT CFHashCode CFStringHashCString(const uint8_t *bytes, CFIndex len);
 319 CF_EXPORT CFHashCode CFStringHashCharacters(const UniChar *characters, CFIndex len);
 320 CF_EXPORT CFHashCode CFStringHashNSString(CFStringRef str);
 321
 322 /* Currently for CFString usage, for handling out-of-memory conditions.
 323    The callback might not return; if it does, true indicates the error was potentially dealt with; false means no.
 324    Typically true means OK to continue executing.
 325 */
 326 typedef Boolean (*CFBadErrorCallBack)(CFTypeRef obj, CFStringRef domain, CFStringRef msg);
 327 CF_EXPORT CFBadErrorCallBack _CFGetOutOfMemoryErrorCallBack(void);
 328 CF_EXPORT void _CFSetOutOfMemoryErrorCallBack(CFBadErrorCallBack callback);
 329
 330
 331
 332 CF_EXTERN_C_END
 333
 334
 335 // ---- Binary plist material ----------------------------------------
 336
 337 typedef const struct __CFKeyedArchiverUID * CFKeyedArchiverUIDRef;
 338 extern CFTypeID _CFKeyedArchiverUIDGetTypeID(void);
 339 extern CFKeyedArchiverUIDRef _CFKeyedArchiverUIDCreate(CFAllocatorRef allocator, uint32_t value);
 340 extern uint32_t _CFKeyedArchiverUIDGetValue(CFKeyedArchiverUIDRef uid);
 341
 342
 343 enum {
 344     kCFBinaryPlistMarkerNull = 0x00,
 345     kCFBinaryPlistMarkerFalse = 0x08,
 346     kCFBinaryPlistMarkerTrue = 0x09,
 347     kCFBinaryPlistMarkerFill = 0x0F,
 348     kCFBinaryPlistMarkerInt = 0x10,
 349     kCFBinaryPlistMarkerReal = 0x20,
 350     kCFBinaryPlistMarkerDate = 0x33,
 351     kCFBinaryPlistMarkerData = 0x40,
 352     kCFBinaryPlistMarkerASCIIString = 0x50,
 353     kCFBinaryPlistMarkerUnicode16String = 0x60,
 354     kCFBinaryPlistMarkerUID = 0x80,
 355     kCFBinaryPlistMarkerArray = 0xA0,
 356     kCFBinaryPlistMarkerSet = 0xC0,
 357     kCFBinaryPlistMarkerDict = 0xD0
 358 };
 359
 360 typedef struct {
 361     uint8_t     _magic[6];
 362     uint8_t     _version[2];
 363 } CFBinaryPlistHeader;
 364
 365 typedef struct {
 366     uint8_t     _unused[6];
 367     uint8_t     _offsetIntSize;
 368     uint8_t     _objectRefSize;
 369     uint64_t    _numObjects;
 370     uint64_t    _topObject;
 371     uint64_t    _offsetTableOffset;
 372 } CFBinaryPlistTrailer;
 373
 374 extern bool __CFBinaryPlistGetTopLevelInfo(const uint8_t *databytes, uint64_t datalen, uint8_t *marker, uint64_t *offset, CFBinaryPlistTrailer *trailer);
 375 extern bool __CFBinaryPlistGetOffsetForValueFromArray2(const uint8_t *databytes, uint64_t datalen, uint64_t startOffset, const CFBinaryPlistTrailer *trailer, CFIndex idx, uint64_t *offset, CFMutableDictionaryRef objects);
 376 extern bool __CFBinaryPlistGetOffsetForValueFromDictionary2(const uint8_t *databytes, uint64_t datalen, uint64_t startOffset, const CFBinaryPlistTrailer *trailer, CFTypeRef key, uint64_t *koffset, uint64_t *voffset, CFMutableDictionaryRef objects);
 377 extern bool __CFBinaryPlistCreateObject(const uint8_t *databytes, uint64_t datalen, uint64_t startOffset, const CFBinaryPlistTrailer *trailer, CFAllocatorRef allocator, CFOptionFlags mutabilityOption, CFMutableDictionaryRef objects, CFPropertyListRef *plist);
 378 extern CFIndex __CFBinaryPlistWriteToStream(CFPropertyListRef plist, CFTypeRef stream);
 379
 380
 381 // ---- Used by property list parsing in Foundation
 382
 383 extern CFTypeRef _CFPropertyListCreateFromXMLData(CFAllocatorRef allocator, CFDataRef xmlData, CFOptionFlags option, CFStringRef *errorString, Boolean allowNewTypes, CFPropertyListFormat *format);
 384
 385
 386 // ---- Miscellaneous material ----------------------------------------
 387
 388 #include <CoreFoundation/CFBag.h>
 389 #include <CoreFoundation/CFSet.h>
 390 #include <math.h>
 391
 392 CF_EXTERN_C_BEGIN
 393
 394 CF_EXPORT CFTypeID CFTypeGetTypeID(void);
 395
 396 CF_EXPORT CFTypeRef _CFRetainGC(CFTypeRef cf);
 397 CF_EXPORT void _CFReleaseGC(CFTypeRef cf);
 398
 399 CF_EXPORT void _CFArraySetCapacity(CFMutableArrayRef array, CFIndex cap);
 400 CF_EXPORT void _CFBagSetCapacity(CFMutableBagRef bag, CFIndex cap);
 401 CF_EXPORT void _CFDictionarySetCapacity(CFMutableDictionaryRef dict, CFIndex cap);
 402 CF_EXPORT void _CFSetSetCapacity(CFMutableSetRef set, CFIndex cap);
 403
 404 CF_EXPORT void CFCharacterSetCompact(CFMutableCharacterSetRef theSet);
 405 CF_EXPORT void CFCharacterSetFast(CFMutableCharacterSetRef theSet);
 406
 407 CF_EXPORT const void *_CFArrayCheckAndGetValueAtIndex(CFArrayRef array, CFIndex idx);
 408 CF_EXPORT void _CFArrayReplaceValues(CFMutableArrayRef array, CFRange range, const void **newValues, CFIndex newCount);
 409
 410
 411 /* Enumeration
 412  Call CFStartSearchPathEnumeration() once, then call
 413  CFGetNextSearchPathEnumeration() one or more times with the returned state.
 414  The return value of CFGetNextSearchPathEnumeration() should be used as
 415  the state next time around.
 416  When CFGetNextSearchPathEnumeration() returns 0, you're done.
 417 */
 418 typedef CFIndex CFSearchPathEnumerationState;
 419 CF_EXPORT CFSearchPathEnumerationState __CFStartSearchPathEnumeration(CFSearchPathDirectory dir, CFSearchPathDomainMask domainMask);
 420 CF_EXPORT CFSearchPathEnumerationState __CFGetNextSearchPathEnumeration(CFSearchPathEnumerationState state, UInt8 *path, CFIndex pathSize);
 421
 422 /* For use by NSNumber and CFNumber.
 423   Hashing algorithm for CFNumber:
 424   M = Max CFHashCode (assumed to be unsigned)
 425   For positive integral values: (N * HASHFACTOR) mod M
 426   For negative integral values: ((-N) * HASHFACTOR) mod M
 427   For floating point numbers that are not integral: hash(integral part) + hash(float part * M)
 428   HASHFACTOR is 2654435761, from Knuth's multiplicative method
 429 */
 430 #define HASHFACTOR 2654435761U
 431
 432 CF_INLINE CFHashCode _CFHashInt(long i) {
 433     return ((i > 0) ? (CFHashCode)(i) : (CFHashCode)(-i)) * HASHFACTOR;
 434 }
 435
 436 CF_INLINE CFHashCode _CFHashDouble(double d) {
 437     double dInt;
 438     if (d < 0) d = -d;
 439     dInt = rint(d);
 440     return (CFHashCode)((HASHFACTOR * (CFHashCode)fmod(dInt, (double)ULONG_MAX)) + ((d - dInt) * ULONG_MAX));
 441 }
 442
 443
 444 /* 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.
 445 */
 446 CF_EXPORT CFStringRef _CFErrorCreateLocalizedDescription(CFErrorRef err);
 447 CF_EXPORT CFStringRef _CFErrorCreateLocalizedFailureReason(CFErrorRef err);
 448 CF_EXPORT CFStringRef _CFErrorCreateLocalizedRecoverySuggestion(CFErrorRef err);
 449 CF_EXPORT CFStringRef _CFErrorCreateDebugDescription(CFErrorRef err);
 450
 451 CF_EXPORT CFURLRef _CFURLAlloc(CFAllocatorRef allocator);
 452 CF_EXPORT void _CFURLInitWithString(CFURLRef url, CFStringRef string, CFURLRef baseURL);
 453 CF_EXPORT void _CFURLInitFSPath(CFURLRef url, CFStringRef path);
 454 CF_EXPORT Boolean _CFStringIsLegalURLString(CFStringRef string);
 455 CF_EXPORT void *__CFURLReservedPtr(CFURLRef  url);
 456 CF_EXPORT void __CFURLSetReservedPtr(CFURLRef  url, void *ptr);
 457 CF_EXPORT CFStringEncoding _CFURLGetEncoding(CFURLRef url);
 458
 459 CF_EXPORT Boolean _CFRunLoopFinished(CFRunLoopRef rl, CFStringRef mode);
 460
 461 CF_EXPORT CFIndex _CFStreamInstanceSize(void);
 462
 463 #if (DEPLOYMENT_TARGET_MACOSX || 0)
 464     #if !defined(__CFReadTSR)
 465     #include <mach/mach_time.h>
 466     #define __CFReadTSR() mach_absolute_time()
 467     #endif
 468 #elif defined(__WIN32__)
 469 CF_INLINE UInt64 __CFReadTSR(void) {
 470     LARGE_INTEGER freq;
 471     QueryPerformanceCounter(&freq);
 472     return freq.QuadPart;
 473 }
 474 #endif
 475
 476 #define CF_HAS_NSOBJECT 1
 477 #define CF_HAS_NSARRAY 1
 478 #define CF_HAS_NSMUTABLEARRAY 1
 479 #define CF_HAS_NSDICTIONARY 1
 480 #define CF_HAS_NSMUTABLEDICTIONARY 1
 481 #define CF_HAS_NSSET 1
 482 #define CF_HAS_NSMUTABLESET 1
 483 #define CF_HAS_NSBATCH2 1
 484
 485 CF_EXTERN_C_END
 486
 487 #endif /* ! __COREFOUNDATION_FORFOUNDATIONONLY__ */
 488