diff options
Diffstat (limited to 'common/quicktime_win32/CoreFoundation/CFBase.h')
| -rw-r--r-- | common/quicktime_win32/CoreFoundation/CFBase.h | 378 |
1 files changed, 378 insertions, 0 deletions
diff --git a/common/quicktime_win32/CoreFoundation/CFBase.h b/common/quicktime_win32/CoreFoundation/CFBase.h new file mode 100644 index 0000000..dcf1c46 --- /dev/null +++ b/common/quicktime_win32/CoreFoundation/CFBase.h @@ -0,0 +1,378 @@ +/* CFBase.h + Copyright (c) 1998-2003, Apple, Inc. All rights reserved. +*/ + +#if !defined(__COREFOUNDATION_CFBASE__) +#define __COREFOUNDATION_CFBASE__ 1 + +#if CF_QUICKTIME +#include <ConditionalMacros.h> +#include "QTMLCompilerOptions.h" +#include "QTCFRenames.h" + +#pragma warning(disable:4090) +#pragma warning(disable:4133) + +#endif + +// Look for various windows environments, boil them all down to defining __WIN32__. +// _WIN32 comes from MS tools. When using MinGW __WIN32__ is already defined. +#if (defined(__CYGWIN32__) || defined(_WIN32) || (defined(__MWERKS__) && defined(__INTEL__))) && !defined (__WIN32__) +#define __WIN32__ 1 +#endif + +#if defined(_MSC_VER) && defined(_M_IX86) && !defined(__i386__) +#define __i386__ 1 +#endif + +#if TARGET_OS_WIN32 + #define CF_BUILDING_CF_AS_LIB 1 +#endif + +#if defined(__GNUC__) || defined(__MWERKS__) + #include <stdint.h> + #include <stdbool.h> +#else + // mostly for the benefit of MSVC + #include <stdint.h> + #include <GNUCompatibility/stdbool.h> + #if TARGET_OS_WIN32 + #undef pascal + #define pascal + typedef void *HANDLE; + #endif +#endif + +#include <AvailabilityMacros.h> + + #include <MacTypes.h> + +#if !defined(__MACTYPES__) + typedef unsigned char Boolean; + typedef unsigned char UInt8; + typedef signed char SInt8; + typedef unsigned short UInt16; + typedef signed short SInt16; + typedef unsigned long UInt32; + typedef signed long SInt32; + typedef uint64_t UInt64; + typedef int64_t SInt64; + typedef float Float32; + typedef double Float64; + typedef unsigned short UniChar; + typedef unsigned char * StringPtr; + typedef const unsigned char * ConstStringPtr; + typedef unsigned char Str255[256]; + typedef const unsigned char * ConstStr255Param; + typedef SInt16 OSErr; + typedef SInt32 OSStatus; +#endif +#if !defined(__MACTYPES__) || (defined(UNIVERSAL_INTERFACES_VERSION) && UNIVERSAL_INTERFACES_VERSION < 0x0340) + typedef UInt32 UTF32Char; + typedef UInt16 UTF16Char; + typedef UInt8 UTF8Char; +#endif + +#if defined(__CYGWIN32__) || defined (D__CYGWIN_) +#error CoreFoundation is currently built with the Microsoft C Runtime, which is incompatible with the Cygwin DLL. You must either use the -mno-cygwin flag, or complete a port of CF to the Cygwin environment. +#endif + +#if defined(__cplusplus) +extern "C" { +#endif + +#if !defined(NULL) + #define NULL 0 +#endif + +#if !defined(TRUE) + #define TRUE 1 +#endif + +#if !defined(FALSE) + #define FALSE 0 +#endif + +#if defined(__WIN32__) + #undef CF_EXPORT + #if defined(CF_BUILDING_CF_AS_LIB) + // we're building CF as a library + #define CF_EXPORT extern + #elif defined(CF_BUILDING_CF) + // we're building CF as a DLL + #define CF_EXPORT __declspec(dllexport) extern + #else + #define CF_EXPORT __declspec(dllimport) extern + #endif +#elif defined(macintosh) + #if defined(__MWERKS__) + #define CF_EXPORT __declspec(export) extern + #endif +#endif + +#if !defined(CF_EXPORT) + #define CF_EXPORT extern +#endif + +#if !defined(CF_INLINE) + #if defined(__GNUC__) + #define CF_INLINE static __inline__ + #elif defined(__MWERKS__) || defined(__cplusplus) + #define CF_INLINE static inline + #elif defined(_MSC_VER) + #define CF_INLINE static __inline + #elif defined(__WIN32__) + #define CF_INLINE static __inline__ + #endif +#endif + + +CF_EXPORT double kCFCoreFoundationVersionNumber; + +#define kCFCoreFoundationVersionNumber10_0 196.4 +#define kCFCoreFoundationVersionNumber10_0_3 196.5 +#if MAC_OS_X_VERSION_10_2 <= MAC_OS_X_VERSION_MAX_ALLOWED +#define kCFCoreFoundationVersionNumber10_1 226.0 +/* Note these do not follow the usual numbering policy from the base release */ +#define kCFCoreFoundationVersionNumber10_1_2 227.2 +#define kCFCoreFoundationVersionNumber10_1_4 227.3 +#endif +#if MAC_OS_X_VERSION_10_3 <= MAC_OS_X_VERSION_MAX_ALLOWED +#define kCFCoreFoundationVersionNumber10_2 263.0 +#endif + +typedef UInt32 CFTypeID; +typedef UInt32 CFOptionFlags; +typedef UInt32 CFHashCode; +typedef SInt32 CFIndex; + +/* Base "type" of all "CF objects", and polymorphic functions on them */ +typedef const void * CFTypeRef; + +typedef const struct __CFString * CFStringRef; +typedef struct __CFString * CFMutableStringRef; + +/* + Type to mean any instance of a property list type; + currently, CFString, CFData, CFNumber, CFBoolean, CFDate, + CFArray, and CFDictionary. +*/ +typedef CFTypeRef CFPropertyListRef; + +/* Values returned from comparison functions */ +typedef enum { + kCFCompareLessThan = -1, + kCFCompareEqualTo = 0, + kCFCompareGreaterThan = 1 +} CFComparisonResult; + +/* A standard comparison function */ +typedef CFComparisonResult (*CFComparatorFunction)(const void *val1, const void *val2, void *context); + +/* Constant used by some functions to indicate failed searches. */ +/* This is of type CFIndex. */ +enum { + kCFNotFound = -1 +}; + + +#if TARGET_OS_WIN32 +CF_EXPORT +void *QTGetCFConstant(const char *cfGlobalConstantKey); +#endif // TARGET_OS_WIN32 + +/* Range type */ +typedef struct { + CFIndex location; + CFIndex length; +} CFRange; + +#if defined(CF_INLINE) +CF_INLINE CFRange CFRangeMake(CFIndex loc, CFIndex len) { + CFRange range; + range.location = loc; + range.length = len; + return range; +} +#else +#define CFRangeMake(LOC, LEN) __CFRangeMake(LOC, LEN) +#endif + +/* Private; do not use */ +CF_EXPORT +CFRange __CFRangeMake(CFIndex loc, CFIndex len); + + +#if MAC_OS_X_VERSION_10_2 <= MAC_OS_X_VERSION_MAX_ALLOWED +/* Null representant */ + +typedef const struct __CFNull * CFNullRef; + +CF_EXPORT +CFTypeID CFNullGetTypeID(void); + +#if TARGET_OS_WIN32 +#define kCFNull (*((const CFNullRef *)QTGetCFConstant("kCFNull"))) +#else +CF_EXPORT +const CFNullRef kCFNull; // the singleton null instance +#endif + +#endif + + +/* Allocator API + + Most of the time when specifying an allocator to Create functions, the NULL + argument indicates "use the default"; this is the same as using kCFAllocatorDefault + or the return value from CFAllocatorGetDefault(). This assures that you will use + the allocator in effect at that time. + + You should rarely use kCFAllocatorSystemDefault, the default default allocator. +*/ +typedef const struct __CFAllocator * CFAllocatorRef; + +#if TARGET_OS_WIN32 +#define kCFAllocatorDefault (*((const CFAllocatorRef *)QTGetCFConstant("kCFAllocatorDefault"))) +#define kCFAllocatorSystemDefault (*((const CFAllocatorRef *)QTGetCFConstant("kCFAllocatorSystemDefault"))) +#define kCFAllocatorMalloc (*((const CFAllocatorRef *)QTGetCFConstant("kCFAllocatorMalloc"))) +#define kCFAllocatorNull (*((const CFAllocatorRef *)QTGetCFConstant("kCFAllocatorNull"))) +#define kCFAllocatorUseContext (*((const CFAllocatorRef *)QTGetCFConstant("kCFAllocatorUseContext"))) +#else +/* This is a synonym for NULL, if you'd rather use a named constant. */ +CF_EXPORT +const CFAllocatorRef kCFAllocatorDefault; + +/* Default system allocator; you rarely need to use this. */ +CF_EXPORT +const CFAllocatorRef kCFAllocatorSystemDefault; + +/* This allocator uses malloc(), realloc(), and free(). This should not be + generally used; stick to kCFAllocatorDefault whenever possible. This + allocator is useful as the "bytesDeallocator" in CFData or + "contentsDeallocator" in CFString where the memory was obtained as a + result of malloc() type functions. +*/ +CF_EXPORT +const CFAllocatorRef kCFAllocatorMalloc; + +/* Null allocator which does nothing and allocates no memory. This allocator + is useful as the "bytesDeallocator" in CFData or "contentsDeallocator" + in CFString where the memory should not be freed. +*/ +CF_EXPORT +const CFAllocatorRef kCFAllocatorNull; + +/* Special allocator argument to CFAllocatorCreate() which means + "use the functions given in the context to allocate the allocator + itself as well". +*/ +CF_EXPORT +const CFAllocatorRef kCFAllocatorUseContext; +#endif + +typedef const void * (*CFAllocatorRetainCallBack)(const void *info); +typedef void (*CFAllocatorReleaseCallBack)(const void *info); +typedef CFStringRef (*CFAllocatorCopyDescriptionCallBack)(const void *info); +typedef void * (*CFAllocatorAllocateCallBack)(CFIndex allocSize, CFOptionFlags hint, void *info); +typedef void * (*CFAllocatorReallocateCallBack)(void *ptr, CFIndex newsize, CFOptionFlags hint, void *info); +typedef void (*CFAllocatorDeallocateCallBack)(void *ptr, void *info); +typedef CFIndex (*CFAllocatorPreferredSizeCallBack)(CFIndex size, CFOptionFlags hint, void *info); +typedef struct { + CFIndex version; + void * info; + CFAllocatorRetainCallBack retain; + CFAllocatorReleaseCallBack release; + CFAllocatorCopyDescriptionCallBack copyDescription; + CFAllocatorAllocateCallBack allocate; + CFAllocatorReallocateCallBack reallocate; + CFAllocatorDeallocateCallBack deallocate; + CFAllocatorPreferredSizeCallBack preferredSize; +} CFAllocatorContext; + +CF_EXPORT +CFTypeID CFAllocatorGetTypeID(void); + +/* + CFAllocatorSetDefault() sets the allocator that is used in the current + thread whenever NULL is specified as an allocator argument. This means + that most, if not all allocations will go through this allocator. It + also means that any allocator set as the default needs to be ready to + deal with arbitrary memory allocation requests; in addition, the size + and number of requests will change between releases. + + An allocator set as the default will never be released, even if later + another allocator replaces it as the default. Not only is it impractical + for it to be released (as there might be caches created under the covers + that refer to the allocator), in general it's also safer and more + efficient to keep it around. + + If you wish to use a custom allocator in a context, it's best to provide + it as the argument to the various creation functions rather than setting + it as the default. Setting the default allocator is not encouraged. + + If you do set an allocator as the default, either do it for all time in + your app, or do it in a nested fashion (by restoring the previous allocator + when you exit your context). The latter might be appropriate for plug-ins + or libraries that wish to set the default allocator. +*/ +CF_EXPORT +void CFAllocatorSetDefault(CFAllocatorRef allocator); + +CF_EXPORT +CFAllocatorRef CFAllocatorGetDefault(void); + +CF_EXPORT +CFAllocatorRef CFAllocatorCreate(CFAllocatorRef allocator, CFAllocatorContext *context); + +CF_EXPORT +void *CFAllocatorAllocate(CFAllocatorRef allocator, CFIndex size, CFOptionFlags hint); + +CF_EXPORT +void *CFAllocatorReallocate(CFAllocatorRef allocator, void *ptr, CFIndex newsize, CFOptionFlags hint); + +CF_EXPORT +void CFAllocatorDeallocate(CFAllocatorRef allocator, void *ptr); + +CF_EXPORT +CFIndex CFAllocatorGetPreferredSizeForSize(CFAllocatorRef allocator, CFIndex size, CFOptionFlags hint); + +CF_EXPORT +void CFAllocatorGetContext(CFAllocatorRef allocator, CFAllocatorContext *context); + + +/* Polymorphic CF functions */ + +CF_EXPORT +CFTypeID CFGetTypeID(CFTypeRef cf); + +CF_EXPORT +CFStringRef CFCopyTypeIDDescription(CFTypeID type_id); + +CF_EXPORT +CFTypeRef CFRetain(CFTypeRef cf); + +CF_EXPORT +void CFRelease(CFTypeRef cf); + +CF_EXPORT +CFIndex CFGetRetainCount(CFTypeRef cf); + +CF_EXPORT +Boolean CFEqual(CFTypeRef cf1, CFTypeRef cf2); + +CF_EXPORT +CFHashCode CFHash(CFTypeRef cf); + +CF_EXPORT +CFStringRef CFCopyDescription(CFTypeRef cf); + +CF_EXPORT +CFAllocatorRef CFGetAllocator(CFTypeRef cf); + +#if defined(__cplusplus) +} +#endif + +#endif /* ! __COREFOUNDATION_CFBASE__ */ + |