[apple/cf.git] / CoreFoundation_Prefix.h

/*
 * Copyright (c) 2011 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */

/*	CoreFoundation_Prefix.h
	Copyright (c) 2005-2011, Apple Inc. All rights reserved.
*/


#define _DARWIN_UNLIMITED_SELECT 1

#include <CoreFoundation/CFBase.h>


#include <stdlib.h>
#include <stdint.h>
#include <string.h>

#if DEPLOYMENT_TARGET_WINDOWS && defined(__cplusplus)
extern "C" {
#endif

#define SystemIntegrityCheck(A, B)	do {} while (0)

    
#if INCLUDE_OBJC
#include <objc/objc.h>
#else
typedef signed char	BOOL; 
typedef char * id;
typedef char * Class;
#define YES (BOOL)1
#define NO (BOOL)0
#define nil NULL
#endif

#if DEPLOYMENT_TARGET_MACOSX && defined(__ppc__)
#define SUPPORT_CFM 1
#endif

#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
#import <libkern/OSAtomic.h>
#import <pthread.h>
#endif

/* This macro creates 3 helper functions which are useful in dealing with libdispatch:
 *  __ PREFIX SyncDispatchIsSafe  -- returns bool indicating whether calling dispatch_sync() would be safe from self-deadlock
 *  __ PREFIX Queue -- manages and returns a singleton serial queue
 *
 * Use the macro like this:
 *   DISPATCH_HELPER_FUNCTIONS(fh, NSFileHandle)
 */

#define DISPATCH_HELPER_FUNCTIONS(PREFIX, QNAME)			\
static Boolean __ ## PREFIX ## SyncDispatchIsSafe(dispatch_queue_t Q) {	\
    dispatch_queue_t C = dispatch_get_current_queue();			\
    return (!C || Q != C) ? true : false;				\
}									\
									\
static dispatch_queue_t __ ## PREFIX ## Queue(void) {			\
    static volatile dispatch_queue_t __ ## PREFIX ## dq = NULL;		\
    if (!__ ## PREFIX ## dq) {						\
        dispatch_queue_t dq = dispatch_queue_create(# QNAME, NULL);	\
        void * volatile *loc = (void * volatile *)&__ ## PREFIX ## dq;	\
        if (!OSAtomicCompareAndSwapPtrBarrier(NULL, dq, loc)) {		\
            dispatch_release(dq);					\
        }								\
    }									\
    return __ ## PREFIX ## dq;						\
}									\


#define LIBAUTO_STUB	1

#ifndef LIBAUTO_STUB

#if DEPLOYMENT_TARGET_MACOSX
#include <auto_zone.h>
#endif
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
#include <objc/objc-auto.h>
#endif

#endif // LIBAUTO_STUB

#if DEPLOYMENT_TARGET_WINDOWS
// Compatibility with boolean.h
#if defined(__x86_64__)
typedef unsigned int	boolean_t;
#else
typedef int		boolean_t;
#endif
#endif

#if DEPLOYMENT_TARGET_LINUX
    
#define __private_extern__
#define __strong
#define __weak

#define strtod_l(a,b,locale) strtod(a,b)
#define strtoul_l(a,b,c,locale) strtoul(a,b,c)
#define strtol_l(a,b,c,locale) strtol(a,b,c)
#define strncasecmp_l(a, b, c, d) strncasecmp(a, b, c)

#define fprintf_l(a,locale,b,...) fprintf(a, b, __VA_ARGS__)
    
#define strlcat(a,b,c) strncat(a,b,c)
#define strlcpy(a,b,c) strncpy(a,b,c)

#define issetugid() 0
    
// Implemented in CFPlatform.c 
bool OSAtomicCompareAndSwapPtr(void *oldp, void *newp, void *volatile *dst);
bool OSAtomicCompareAndSwapLong(long oldl, long newl, long volatile *dst);
bool OSAtomicCompareAndSwapPtrBarrier(void *oldp, void *newp, void *volatile *dst);

int32_t OSAtomicDecrement32Barrier(volatile int32_t *dst);
int32_t OSAtomicIncrement32Barrier(volatile int32_t *dst);
int32_t OSAtomicIncrement32(volatile int32_t *theValue);
int32_t OSAtomicDecrement32(volatile int32_t *theValue);

int32_t OSAtomicAdd32( int32_t theAmount, volatile int32_t *theValue );
int32_t OSAtomicAdd32Barrier( int32_t theAmount, volatile int32_t *theValue );
bool OSAtomicCompareAndSwap32Barrier( int32_t oldValue, int32_t newValue, volatile int32_t *theValue );
    
void OSMemoryBarrier();

#include <malloc.h>
CF_INLINE size_t malloc_size(void *memblock) {
    return malloc_usable_size(memblock);
}

#endif

#if DEPLOYMENT_TARGET_WINDOWS || DEPLOYMENT_TARGET_LINUX    
#if !defined(MIN)
#define MIN(A,B)	((A) < (B) ? (A) : (B))
#endif
    
#if !defined(MAX)
#define MAX(A,B)	((A) > (B) ? (A) : (B))
#endif
    
#if !defined(ABS)
#define ABS(A)	((A) < 0 ? (-(A)) : (A))
#endif    
#endif

#if DEPLOYMENT_TARGET_WINDOWS

#define MAXPATHLEN MAX_PATH
#undef MAX_PATH
#undef INVALID_HANDLE_VALUE

// Defined for source compatibility
#define ino_t _ino_t
#define off_t _off_t
#define mode_t uint16_t
        
// This works because things aren't actually exported from the DLL unless they have a __declspec(dllexport) on them... so extern by itself is closest to __private_extern__ on Mac OS
#define __private_extern__ extern
    
#define __builtin_expect(P1,P2) P1
    
// These are replacements for POSIX calls on Windows, ensuring that the UTF8 parameters are converted to UTF16 before being passed to Windows
CF_EXPORT int _NS_stat(const char *name, struct _stat *st);
CF_EXPORT int _NS_mkdir(const char *name);
CF_EXPORT int _NS_rmdir(const char *name);
CF_EXPORT int _NS_chmod(const char *name, int mode);
CF_EXPORT int _NS_unlink(const char *name);
CF_EXPORT char *_NS_getcwd(char *dstbuf, size_t size);     // Warning: this doesn't support dstbuf as null even though 'getcwd' does
CF_EXPORT char *_NS_getenv(const char *name);
CF_EXPORT int _NS_rename(const char *oldName, const char *newName);
CF_EXPORT int _NS_open(const char *name, int oflag, int pmode = 0);
CF_EXPORT int _NS_chdir(const char *name);
CF_EXPORT int _NS_mkstemp(char *name, int bufSize);
CF_EXPORT int _NS_access(const char *name, int amode);

#define BOOL WINDOWS_BOOL

#define WIN32_LEAN_AND_MEAN

#ifndef WINVER
#define WINVER  0x0501
#endif
    
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0501
#endif

// The order of these includes is important
#include <winsock2.h>
#include <windows.h>
#include <pthread.h>

#undef BOOL

#ifndef HAVE_STRUCT_TIMESPEC
#define HAVE_STRUCT_TIMESPEC 1
struct timespec {
        long tv_sec;
        long tv_nsec;
};
#endif /* HAVE_STRUCT_TIMESPEC */

#define __PRETTY_FUNCTION__ __FUNCTION__

#define malloc_default_zone() (void *)0
#define malloc_zone_from_ptr(a) (void *)0
#define malloc_zone_malloc(zone,size) malloc(size)
#define malloc_zone_memalign(zone,align,size) malloc(size)
#define malloc_zone_calloc(zone,count,size) calloc(count,size)
#define bcopy(b1,b2,len) memmove(b2, b1, (size_t)(len))
typedef int malloc_zone_t;
typedef int uid_t;
typedef int gid_t;
#define geteuid() 0
#define getuid() 0
#define getegid() 0

#define fsync(a) _commit(a)
#define malloc_create_zone(a,b) 123
#define malloc_set_zone_name(zone,name)
#define malloc_zone_realloc(zone,ptr,size) realloc(ptr,size)
#define malloc_zone_free(zone,ptr) free(ptr)

// implemented in CFInternal.h
#define OSSpinLockLock(A) __CFSpinLock(A)
#define OSSpinLockUnlock(A) __CFSpinUnlock(A)
    
typedef int32_t OSSpinLock;

#define OS_SPINLOCK_INIT       0

#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <malloc.h>

CF_INLINE size_t malloc_size(void *memblock) {
    return _msize(memblock);
}

#define mach_absolute_time() ((uint64_t)(CFAbsoluteTimeGetCurrent() * 1000000000.0))

#define strtod_l(a,b,locale) strtod(a,b)
#define strtoul_l(a,b,c,locale) strtoul(a,b,c)
#define strtol_l(a,b,c,locale) strtol(a,b,c)
#define strncasecmp_l(a, b, c, d) _strnicmp(a, b, c)
#define snprintf _snprintf

#define fprintf_l(a,locale,b,...) fprintf(a, b, __VA_ARGS__)

#define strlcat(a,b,c) strncat(a,b,c)
#define strlcpy(a,b,c) strncpy(a,b,c)
    
#define sleep(x) Sleep(1000*x)

#define issetugid() 0

// CF exports these useful atomic operation functions on Windows
CF_EXPORT bool OSAtomicCompareAndSwapPtr(void *oldp, void *newp, void *volatile *dst);
CF_EXPORT bool OSAtomicCompareAndSwapLong(long oldl, long newl, long volatile *dst);
CF_EXPORT bool OSAtomicCompareAndSwapPtrBarrier(void *oldp, void *newp, void *volatile *dst);

CF_EXPORT int32_t OSAtomicDecrement32Barrier(volatile int32_t *dst);
CF_EXPORT int32_t OSAtomicIncrement32Barrier(volatile int32_t *dst);
CF_EXPORT int32_t OSAtomicIncrement32(volatile int32_t *theValue);
CF_EXPORT int32_t OSAtomicDecrement32(volatile int32_t *theValue);
    
CF_EXPORT int32_t OSAtomicAdd32( int32_t theAmount, volatile int32_t *theValue );
CF_EXPORT int32_t OSAtomicAdd32Barrier( int32_t theAmount, volatile int32_t *theValue );
CF_EXPORT bool OSAtomicCompareAndSwap32Barrier( int32_t oldValue, int32_t newValue, volatile int32_t *theValue );

/*
CF_EXPORT bool OSAtomicCompareAndSwap64( int64_t __oldValue, int64_t __newValue, volatile int64_t *__theValue );
CF_EXPORT bool OSAtomicCompareAndSwap64Barrier( int64_t __oldValue, int64_t __newValue, volatile int64_t *__theValue );
    
CF_EXPORT int64_t OSAtomicAdd64( int64_t __theAmount, volatile int64_t *__theValue );
CF_EXPORT int64_t OSAtomicAdd64Barrier( int64_t __theAmount, volatile int64_t *__theValue );
*/

//#ifndef NTDDI_VERSION
//#define NTDDI_VERSION NTDDI_WINXP
//#endif

#include <io.h>
#include <fcntl.h>
#include <errno.h>
    
#endif

#if DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_WINDOWS

#include <stdarg.h>

CF_INLINE int flsl( long mask ) {
    int idx = 0;
    while (mask != 0) mask = (unsigned long)mask >> 1, idx++;
    return idx;
}
    
CF_INLINE int popcountll(long long x) {
    int count = 0;
    while (x) {
        count++;
        x &= x - 1; // reset LS1B
    }
    return count;
}

__private_extern__ int asprintf(char **ret, const char *format, ...);

#endif

#ifdef LIBAUTO_STUB

#include <stddef.h>

/* Stubs for functions in libauto. */

enum {OBJC_GENERATIONAL = (1 << 0)};

enum {
    OBJC_RATIO_COLLECTION        = (0 << 0), 
    OBJC_GENERATIONAL_COLLECTION = (1 << 0),
    OBJC_FULL_COLLECTION         = (2 << 0),
    OBJC_EXHAUSTIVE_COLLECTION   = (3 << 0),
    OBJC_COLLECT_IF_NEEDED       = (1 << 3),
    OBJC_WAIT_UNTIL_DONE         = (1 << 4),
};

    
enum {
    AUTO_TYPE_UNKNOWN = -1,
    AUTO_UNSCANNED = (1 << 0),
    AUTO_OBJECT = (1 << 1),
    AUTO_POINTERS_ONLY = (1 << 2),
    AUTO_MEMORY_SCANNED = !AUTO_UNSCANNED,
    AUTO_MEMORY_UNSCANNED = AUTO_UNSCANNED,
    AUTO_MEMORY_ALL_POINTERS = AUTO_POINTERS_ONLY,
    AUTO_MEMORY_ALL_WEAK_POINTERS = (AUTO_UNSCANNED | AUTO_POINTERS_ONLY),
    AUTO_OBJECT_SCANNED = AUTO_OBJECT,
    AUTO_OBJECT_UNSCANNED = AUTO_OBJECT | AUTO_UNSCANNED, 
    AUTO_OBJECT_ALL_POINTERS = AUTO_OBJECT | AUTO_POINTERS_ONLY
};
typedef unsigned long auto_memory_type_t;
typedef struct _auto_zone_t auto_zone_t;
typedef struct auto_weak_callback_block {
    struct auto_weak_callback_block *next;
    void (*callback_function)(void *arg1, void *arg2);
    void *arg1;
    void *arg2;
} auto_weak_callback_block_t;

CF_INLINE void *objc_memmove_collectable(void *a, const void *b, size_t c) { return memmove(a, b, c); }
CF_INLINE void *objc_collectableZone(void) { return 0; }

CF_INLINE void *auto_zone_allocate_object(void *zone, size_t size, auto_memory_type_t type, int rc, int clear) { return 0; }
CF_INLINE const void *auto_zone_base_pointer(void *zone, const void *ptr) { return 0; }
CF_INLINE void auto_zone_set_scan_exactly(void *zone, void *ptr) {}
CF_INLINE void auto_zone_retain(void *zone, void *ptr) {}
CF_INLINE unsigned int auto_zone_release(void *zone, void *ptr) { return 0; }
CF_INLINE unsigned int auto_zone_retain_count(void *zone, const void *ptr) { return 0; }
CF_INLINE void auto_zone_set_unscanned(void *zone, void *ptr) {}
CF_INLINE void auto_zone_set_nofinalize(void *zone, void *ptr) {}
CF_INLINE int auto_zone_is_finalized(void *zone, const void *ptr) { return 0; }
CF_INLINE size_t auto_zone_size(void *zone, const void *ptr) { return 0; }
CF_INLINE void auto_register_weak_reference(void *zone, const void *referent, void **referrer, uintptr_t *counter, void **listHead, void **listElement) {}
CF_INLINE void auto_unregister_weak_reference(void *zone, const void *referent, void **referrer) {}
CF_INLINE int auto_zone_is_valid_pointer(void *zone, const void *ptr) { return 0; }
CF_INLINE BOOL objc_isAuto(id object) { return 0; }
CF_INLINE void* auto_read_weak_reference(void *zone, void **referrer) { void *result = *referrer; return result; }
CF_INLINE void auto_assign_weak_reference(void *zone, const void *value, const void **location, auto_weak_callback_block_t *block) { *location = (void *)value; }
CF_INLINE auto_memory_type_t auto_zone_get_layout_type(void *zone, void *ptr) { return AUTO_UNSCANNED; }
CF_INLINE int auto_zone_set_write_barrier(void *zone, const void *dest, const void *new_value) { return false; }

CF_INLINE void objc_assertRegisteredThreadWithCollector(void) {}
CF_INLINE void objc_registerThreadWithCollector(void) {}

CF_INLINE uintptr_t _object_getExternalHash(id obj) {
    return (uintptr_t)obj;
}
    
// from objc-auto.h

CF_INLINE BOOL objc_atomicCompareAndSwapPtr(id predicate, id replacement, volatile id *objectLocation) 
{ return OSAtomicCompareAndSwapPtr((void *)predicate, (void *)replacement, (void * volatile *)objectLocation); }

CF_INLINE BOOL objc_atomicCompareAndSwapPtrBarrier(id predicate, id replacement, volatile id *objectLocation) 
{ return OSAtomicCompareAndSwapPtrBarrier((void *)predicate, (void *)replacement, (void * volatile *)objectLocation); }

CF_INLINE BOOL objc_atomicCompareAndSwapGlobal(id predicate, id replacement, volatile id *objectLocation) 
{ return OSAtomicCompareAndSwapPtr((void *)predicate, (void *)replacement, (void * volatile *)objectLocation); }

CF_INLINE BOOL objc_atomicCompareAndSwapGlobalBarrier(id predicate, id replacement, volatile id *objectLocation) 
{ return OSAtomicCompareAndSwapPtrBarrier((void *)predicate, (void *)replacement, (void * volatile *)objectLocation); }

CF_INLINE BOOL objc_atomicCompareAndSwapInstanceVariable(id predicate, id replacement, volatile id *objectLocation) 
{ return OSAtomicCompareAndSwapPtr((void *)predicate, (void *)replacement, (void * volatile *)objectLocation); }

CF_INLINE BOOL objc_atomicCompareAndSwapInstanceVariableBarrier(id predicate, id replacement, volatile id *objectLocation) 
{ return OSAtomicCompareAndSwapPtrBarrier((void *)predicate, (void *)replacement, (void * volatile *)objectLocation); }

CF_INLINE id objc_assign_strongCast(id val, id *dest) 
{ return (*dest = val); }

CF_INLINE id objc_assign_global(id val, id *dest) 
{ return (*dest = val); }

CF_INLINE id objc_assign_ivar(id val, id dest, ptrdiff_t offset) 
{ return (*(id*)((char *)dest+offset) = val); }

//CF_INLINE void *objc_memmove_collectable(void *dst, const void *src, size_t size) { return memmove(dst, src, size); }

CF_INLINE id objc_read_weak(id *location) 
{ return *location; }

CF_INLINE id objc_assign_weak(id value, id *location) 
{ return (*location = value); }


CF_INLINE void objc_finalizeOnMainThread(Class cls) { }
CF_INLINE BOOL objc_is_finalized(void *ptr) { return NO; }
CF_INLINE void objc_clear_stack(unsigned long options) { }

CF_INLINE BOOL objc_collectingEnabled(void) { return NO; }
CF_INLINE void objc_start_collector_thread(void) { }

CF_INLINE void objc_collect(unsigned long options) { }
    
#endif

// Need to use the _O_BINARY flag on Windows to get the correct behavior
#if DEPLOYMENT_TARGET_WINDOWS
    #define CF_OPENFLGS	(_O_BINARY|_O_NOINHERIT)
#else
    #define CF_OPENFLGS	(0)
#endif

#if DEPLOYMENT_TARGET_WINDOWS

// These are replacements for pthread calls on Windows
CF_EXPORT int _NS_pthread_main_np();
CF_EXPORT int _NS_pthread_setspecific(pthread_key_t key, const void *val);
CF_EXPORT void* _NS_pthread_getspecific(pthread_key_t key);
CF_EXPORT int _NS_pthread_key_init_np(int key, void (*destructor)(void *));
CF_EXPORT void _NS_pthread_setname_np(const char *name);
    
// map use of pthread_set/getspecific to internal API
#define pthread_setspecific _NS_pthread_setspecific
#define pthread_getspecific _NS_pthread_getspecific
#define pthread_key_init_np _NS_pthread_key_init_np
#define pthread_main_np _NS_pthread_main_np
#define pthread_setname_np _NS_pthread_setname_np
#endif

#if DEPLOYMENT_TARGET_WINDOWS
// replacement for DISPATCH_QUEUE_OVERCOMMIT until we get a bug fix in dispatch on Windows
// <rdar://problem/7923891> dispatch on Windows: Need queue_private.h
#define DISPATCH_QUEUE_OVERCOMMIT 2
#endif
    
#if DEPLOYMENT_TARGET_WINDOWS && defined(__cplusplus)
} // extern "C"
#endif
Commit	Line	Data
cf7d2af9	1	/*
8ca704e1	2	* Copyright (c) 2011 Apple Inc. All rights reserved.
cf7d2af9 A	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	*/
f64f9b69	23
cf7d2af9	24	/* CoreFoundation_Prefix.h
8ca704e1	25	Copyright (c) 2005-2011, Apple Inc. All rights reserved.
cf7d2af9 A	26	*/
	27
	28
	29	#define _DARWIN_UNLIMITED_SELECT 1
	30
	31	#include <CoreFoundation/CFBase.h>
	32
	33
	34	#include <stdlib.h>
	35	#include <stdint.h>
	36	#include <string.h>
	37
	38	#if DEPLOYMENT_TARGET_WINDOWS && defined(__cplusplus)
	39	extern "C" {
	40	#endif
8ca704e1 A	41
	42	#define SystemIntegrityCheck(A, B) do {} while (0)
	43
cf7d2af9	44
8ca704e1	45	#if INCLUDE_OBJC
cf7d2af9	46	#include <objc/objc.h>
8ca704e1 A	47	#else
	48	typedef signed char BOOL;
	49	typedef char * id;
	50	typedef char * Class;
	51	#define YES (BOOL)1
	52	#define NO (BOOL)0
	53	#define nil NULL
cf7d2af9 A	54	#endif
cf7d2af9 A	55
8ca704e1 A	56	#if DEPLOYMENT_TARGET_MACOSX && defined(__ppc__)
8ca704e1 A	57	#define SUPPORT_CFM 1
cf7d2af9 A	58	#endif
	59
	60	#if DEPLOYMENT_TARGET_MACOSX \|\| DEPLOYMENT_TARGET_EMBEDDED
cf7d2af9 A	61	#import <libkern/OSAtomic.h>
cf7d2af9 A	62	#import <pthread.h>
8ca704e1	63	#endif
cf7d2af9 A	64
	65	/* This macro creates 3 helper functions which are useful in dealing with libdispatch:
	66	* __ PREFIX SyncDispatchIsSafe -- returns bool indicating whether calling dispatch_sync() would be safe from self-deadlock
	67	* __ PREFIX Queue -- manages and returns a singleton serial queue
	68	*
	69	* Use the macro like this:
	70	* DISPATCH_HELPER_FUNCTIONS(fh, NSFileHandle)
	71	*/
	72
	73	#define DISPATCH_HELPER_FUNCTIONS(PREFIX, QNAME) \
	74	static Boolean __ ## PREFIX ## SyncDispatchIsSafe(dispatch_queue_t Q) { \
	75	dispatch_queue_t C = dispatch_get_current_queue(); \
	76	return (!C \|\| Q != C) ? true : false; \
	77	} \
	78	\
	79	static dispatch_queue_t __ ## PREFIX ## Queue(void) { \
	80	static volatile dispatch_queue_t __ ## PREFIX ## dq = NULL; \
	81	if (!__ ## PREFIX ## dq) { \
	82	dispatch_queue_t dq = dispatch_queue_create(# QNAME, NULL); \
	83	void * volatile loc = (void volatile *)&__ ## PREFIX ## dq; \
	84	if (!OSAtomicCompareAndSwapPtrBarrier(NULL, dq, loc)) { \
	85	dispatch_release(dq); \
	86	} \
	87	} \
	88	return __ ## PREFIX ## dq; \
	89	} \
	90
cf7d2af9 A	91
	92	#define LIBAUTO_STUB 1
	93
	94	#ifndef LIBAUTO_STUB
	95
	96	#if DEPLOYMENT_TARGET_MACOSX
	97	#include <auto_zone.h>
	98	#endif
	99	#if DEPLOYMENT_TARGET_MACOSX \|\| DEPLOYMENT_TARGET_EMBEDDED
	100	#include <objc/objc-auto.h>
	101	#endif
	102
	103	#endif // LIBAUTO_STUB
	104
	105	#if DEPLOYMENT_TARGET_WINDOWS
	106	// Compatibility with boolean.h
	107	#if defined(__x86_64__)
	108	typedef unsigned int boolean_t;
	109	#else
	110	typedef int boolean_t;
	111	#endif
	112	#endif
	113
8ca704e1 A	114	#if DEPLOYMENT_TARGET_LINUX
	115
	116	#define __private_extern__
	117	#define __strong
	118	#define __weak
cf7d2af9	119
8ca704e1 A	120	#define strtod_l(a,b,locale) strtod(a,b)
	121	#define strtoul_l(a,b,c,locale) strtoul(a,b,c)
	122	#define strtol_l(a,b,c,locale) strtol(a,b,c)
	123	#define strncasecmp_l(a, b, c, d) strncasecmp(a, b, c)
cf7d2af9	124
8ca704e1	125	#define fprintf_l(a,locale,b,...) fprintf(a, b, __VA_ARGS__)
cf7d2af9	126
8ca704e1 A	127	#define strlcat(a,b,c) strncat(a,b,c)
	128	#define strlcpy(a,b,c) strncpy(a,b,c)
	129
	130	#define issetugid() 0
	131
	132	// Implemented in CFPlatform.c
	133	bool OSAtomicCompareAndSwapPtr(void oldp, void newp, void volatile dst);
	134	bool OSAtomicCompareAndSwapLong(long oldl, long newl, long volatile *dst);
	135	bool OSAtomicCompareAndSwapPtrBarrier(void oldp, void newp, void volatile dst);
	136
	137	int32_t OSAtomicDecrement32Barrier(volatile int32_t *dst);
	138	int32_t OSAtomicIncrement32Barrier(volatile int32_t *dst);
	139	int32_t OSAtomicIncrement32(volatile int32_t *theValue);
	140	int32_t OSAtomicDecrement32(volatile int32_t *theValue);
	141
	142	int32_t OSAtomicAdd32( int32_t theAmount, volatile int32_t *theValue );
	143	int32_t OSAtomicAdd32Barrier( int32_t theAmount, volatile int32_t *theValue );
	144	bool OSAtomicCompareAndSwap32Barrier( int32_t oldValue, int32_t newValue, volatile int32_t *theValue );
	145
	146	void OSMemoryBarrier();
	147
	148	#include <malloc.h>
	149	CF_INLINE size_t malloc_size(void *memblock) {
	150	return malloc_usable_size(memblock);
	151	}
	152
	153	#endif
	154
	155	#if DEPLOYMENT_TARGET_WINDOWS \|\| DEPLOYMENT_TARGET_LINUX
cf7d2af9 A	156	#if !defined(MIN)
	157	#define MIN(A,B) ((A) < (B) ? (A) : (B))
	158	#endif
	159
	160	#if !defined(MAX)
	161	#define MAX(A,B) ((A) > (B) ? (A) : (B))
	162	#endif
	163
	164	#if !defined(ABS)
	165	#define ABS(A) ((A) < 0 ? (-(A)) : (A))
8ca704e1	166	#endif
cf7d2af9	167	#endif
8ca704e1 A	168
	169	#if DEPLOYMENT_TARGET_WINDOWS
	170
	171	#define MAXPATHLEN MAX_PATH
	172	#undef MAX_PATH
	173	#undef INVALID_HANDLE_VALUE
cf7d2af9 A	174
	175	// Defined for source compatibility
	176	#define ino_t _ino_t
	177	#define off_t _off_t
	178	#define mode_t uint16_t
	179
	180	// This works because things aren't actually exported from the DLL unless they have a __declspec(dllexport) on them... so extern by itself is closest to __private_extern__ on Mac OS
	181	#define __private_extern__ extern
	182
	183	#define __builtin_expect(P1,P2) P1
	184
	185	// These are replacements for POSIX calls on Windows, ensuring that the UTF8 parameters are converted to UTF16 before being passed to Windows
	186	CF_EXPORT int _NS_stat(const char name, struct _stat st);
	187	CF_EXPORT int _NS_mkdir(const char *name);
	188	CF_EXPORT int _NS_rmdir(const char *name);
	189	CF_EXPORT int _NS_chmod(const char *name, int mode);
	190	CF_EXPORT int _NS_unlink(const char *name);
	191	CF_EXPORT char _NS_getcwd(char dstbuf, size_t size); // Warning: this doesn't support dstbuf as null even though 'getcwd' does
	192	CF_EXPORT char _NS_getenv(const char name);
	193	CF_EXPORT int _NS_rename(const char oldName, const char newName);
	194	CF_EXPORT int _NS_open(const char *name, int oflag, int pmode = 0);
	195	CF_EXPORT int _NS_chdir(const char *name);
	196	CF_EXPORT int _NS_mkstemp(char *name, int bufSize);
	197	CF_EXPORT int _NS_access(const char *name, int amode);
	198
	199	#define BOOL WINDOWS_BOOL
	200
	201	#define WIN32_LEAN_AND_MEAN
	202
	203	#ifndef WINVER
	204	#define WINVER 0x0501
	205	#endif
	206
	207	#ifndef _WIN32_WINNT
	208	#define _WIN32_WINNT 0x0501
	209	#endif
	210
	211	// The order of these includes is important
	212	#include <winsock2.h>
	213	#include <windows.h>
8ca704e1	214	#include <pthread.h>
cf7d2af9 A	215
	216	#undef BOOL
	217
	218	#ifndef HAVE_STRUCT_TIMESPEC
	219	#define HAVE_STRUCT_TIMESPEC 1
	220	struct timespec {
	221	long tv_sec;
	222	long tv_nsec;
	223	};
	224	#endif /* HAVE_STRUCT_TIMESPEC */
	225
	226	#define __PRETTY_FUNCTION__ __FUNCTION__
	227
	228	#define malloc_default_zone() (void *)0
	229	#define malloc_zone_from_ptr(a) (void *)0
	230	#define malloc_zone_malloc(zone,size) malloc(size)
8ca704e1	231	#define malloc_zone_memalign(zone,align,size) malloc(size)
cf7d2af9 A	232	#define malloc_zone_calloc(zone,count,size) calloc(count,size)
	233	#define bcopy(b1,b2,len) memmove(b2, b1, (size_t)(len))
	234	typedef int malloc_zone_t;
	235	typedef int uid_t;
	236	typedef int gid_t;
	237	#define geteuid() 0
	238	#define getuid() 0
	239	#define getegid() 0
	240
	241	#define fsync(a) _commit(a)
	242	#define malloc_create_zone(a,b) 123
	243	#define malloc_set_zone_name(zone,name)
	244	#define malloc_zone_realloc(zone,ptr,size) realloc(ptr,size)
	245	#define malloc_zone_free(zone,ptr) free(ptr)
	246
	247	// implemented in CFInternal.h
	248	#define OSSpinLockLock(A) __CFSpinLock(A)
	249	#define OSSpinLockUnlock(A) __CFSpinUnlock(A)
	250
	251	typedef int32_t OSSpinLock;
	252
	253	#define OS_SPINLOCK_INIT 0
	254
	255	#include <stdint.h>
	256	#include <stdbool.h>
cf7d2af9	257	#include <stdio.h>
cf7d2af9	258	#include <malloc.h>
8ca704e1	259
cf7d2af9 A	260	CF_INLINE size_t malloc_size(void *memblock) {
	261	return _msize(memblock);
	262	}
	263
	264	#define mach_absolute_time() ((uint64_t)(CFAbsoluteTimeGetCurrent() * 1000000000.0))
	265
cf7d2af9 A	266	#define strtod_l(a,b,locale) strtod(a,b)
	267	#define strtoul_l(a,b,c,locale) strtoul(a,b,c)
	268	#define strtol_l(a,b,c,locale) strtol(a,b,c)
8ca704e1 A	269	#define strncasecmp_l(a, b, c, d) _strnicmp(a, b, c)
8ca704e1 A	270	#define snprintf _snprintf
cf7d2af9	271
8ca704e1	272	#define fprintf_l(a,locale,b,...) fprintf(a, b, __VA_ARGS__)
cf7d2af9 A	273
cf7d2af9 A	274	#define strlcat(a,b,c) strncat(a,b,c)
8ca704e1 A	275	#define strlcpy(a,b,c) strncpy(a,b,c)
	276
	277	#define sleep(x) Sleep(1000*x)
cf7d2af9 A	278
	279	#define issetugid() 0
	280
	281	// CF exports these useful atomic operation functions on Windows
	282	CF_EXPORT bool OSAtomicCompareAndSwapPtr(void oldp, void newp, void volatile dst);
	283	CF_EXPORT bool OSAtomicCompareAndSwapLong(long oldl, long newl, long volatile *dst);
	284	CF_EXPORT bool OSAtomicCompareAndSwapPtrBarrier(void oldp, void newp, void volatile dst);
	285
	286	CF_EXPORT int32_t OSAtomicDecrement32Barrier(volatile int32_t *dst);
	287	CF_EXPORT int32_t OSAtomicIncrement32Barrier(volatile int32_t *dst);
	288	CF_EXPORT int32_t OSAtomicIncrement32(volatile int32_t *theValue);
	289	CF_EXPORT int32_t OSAtomicDecrement32(volatile int32_t *theValue);
	290
8ca704e1	291	CF_EXPORT int32_t OSAtomicAdd32( int32_t theAmount, volatile int32_t *theValue );
cf7d2af9 A	292	CF_EXPORT int32_t OSAtomicAdd32Barrier( int32_t theAmount, volatile int32_t *theValue );
	293	CF_EXPORT bool OSAtomicCompareAndSwap32Barrier( int32_t oldValue, int32_t newValue, volatile int32_t *theValue );
	294
	295	/*
	296	CF_EXPORT bool OSAtomicCompareAndSwap64( int64_t __oldValue, int64_t __newValue, volatile int64_t *__theValue );
	297	CF_EXPORT bool OSAtomicCompareAndSwap64Barrier( int64_t __oldValue, int64_t __newValue, volatile int64_t *__theValue );
	298
	299	CF_EXPORT int64_t OSAtomicAdd64( int64_t __theAmount, volatile int64_t *__theValue );
	300	CF_EXPORT int64_t OSAtomicAdd64Barrier( int64_t __theAmount, volatile int64_t *__theValue );
	301	*/
8ca704e1	302
cf7d2af9 A	303	//#ifndef NTDDI_VERSION
	304	//#define NTDDI_VERSION NTDDI_WINXP
	305	//#endif
	306
	307	#include <io.h>
	308	#include <fcntl.h>
	309	#include <errno.h>
8ca704e1 A	310
	311	#endif
	312
	313	#if DEPLOYMENT_TARGET_LINUX \|\| DEPLOYMENT_TARGET_WINDOWS
	314
	315	#include <stdarg.h>
cf7d2af9	316
8ca704e1	317	CF_INLINE int flsl( long mask ) {
cf7d2af9	318	int idx = 0;
8ca704e1 A	319	while (mask != 0) mask = (unsigned long)mask >> 1, idx++;
8ca704e1 A	320	return idx;
cf7d2af9	321	}
8ca704e1 A	322
	323	CF_INLINE int popcountll(long long x) {
	324	int count = 0;
	325	while (x) {
	326	count++;
	327	x &= x - 1; // reset LS1B
	328	}
	329	return count;
cf7d2af9 A	330	}
cf7d2af9 A	331
8ca704e1	332	__private_extern__ int asprintf(char *ret, const char format, ...);
cf7d2af9	333
cf7d2af9 A	334	#endif
	335
	336	#ifdef LIBAUTO_STUB
	337
8ca704e1 A	338	#include <stddef.h>
8ca704e1 A	339
cf7d2af9 A	340	/* Stubs for functions in libauto. */
	341
	342	enum {OBJC_GENERATIONAL = (1 << 0)};
	343
	344	enum {
	345	OBJC_RATIO_COLLECTION = (0 << 0),
	346	OBJC_GENERATIONAL_COLLECTION = (1 << 0),
	347	OBJC_FULL_COLLECTION = (2 << 0),
	348	OBJC_EXHAUSTIVE_COLLECTION = (3 << 0),
	349	OBJC_COLLECT_IF_NEEDED = (1 << 3),
	350	OBJC_WAIT_UNTIL_DONE = (1 << 4),
	351	};
	352
	353
8ca704e1 A	354	enum {
	355	AUTO_TYPE_UNKNOWN = -1,
	356	AUTO_UNSCANNED = (1 << 0),
	357	AUTO_OBJECT = (1 << 1),
	358	AUTO_POINTERS_ONLY = (1 << 2),
	359	AUTO_MEMORY_SCANNED = !AUTO_UNSCANNED,
	360	AUTO_MEMORY_UNSCANNED = AUTO_UNSCANNED,
	361	AUTO_MEMORY_ALL_POINTERS = AUTO_POINTERS_ONLY,
	362	AUTO_MEMORY_ALL_WEAK_POINTERS = (AUTO_UNSCANNED \| AUTO_POINTERS_ONLY),
	363	AUTO_OBJECT_SCANNED = AUTO_OBJECT,
	364	AUTO_OBJECT_UNSCANNED = AUTO_OBJECT \| AUTO_UNSCANNED,
	365	AUTO_OBJECT_ALL_POINTERS = AUTO_OBJECT \| AUTO_POINTERS_ONLY
	366	};
cf7d2af9 A	367	typedef unsigned long auto_memory_type_t;
	368	typedef struct _auto_zone_t auto_zone_t;
	369	typedef struct auto_weak_callback_block {
	370	struct auto_weak_callback_block *next;
	371	void (callback_function)(void arg1, void *arg2);
	372	void *arg1;
	373	void *arg2;
	374	} auto_weak_callback_block_t;
	375
	376	CF_INLINE void objc_memmove_collectable(void a, const void *b, size_t c) { return memmove(a, b, c); }
8ca704e1	377	CF_INLINE void *objc_collectableZone(void) { return 0; }
cf7d2af9	378
cf7d2af9 A	379	CF_INLINE void auto_zone_allocate_object(void zone, size_t size, auto_memory_type_t type, int rc, int clear) { return 0; }
cf7d2af9 A	380	CF_INLINE const void auto_zone_base_pointer(void zone, const void *ptr) { return 0; }
8ca704e1	381	CF_INLINE void auto_zone_set_scan_exactly(void zone, void ptr) {}
cf7d2af9 A	382	CF_INLINE void auto_zone_retain(void zone, void ptr) {}
	383	CF_INLINE unsigned int auto_zone_release(void zone, void ptr) { return 0; }
	384	CF_INLINE unsigned int auto_zone_retain_count(void zone, const void ptr) { return 0; }
8ca704e1 A	385	CF_INLINE void auto_zone_set_unscanned(void zone, void ptr) {}
8ca704e1 A	386	CF_INLINE void auto_zone_set_nofinalize(void zone, void ptr) {}
cf7d2af9 A	387	CF_INLINE int auto_zone_is_finalized(void zone, const void ptr) { return 0; }
	388	CF_INLINE size_t auto_zone_size(void zone, const void ptr) { return 0; }
	389	CF_INLINE void auto_register_weak_reference(void zone, const void referent, void *referrer, uintptr_t counter, void listHead, void listElement) {}
	390	CF_INLINE void auto_unregister_weak_reference(void zone, const void referent, void **referrer) {}
cf7d2af9 A	391	CF_INLINE int auto_zone_is_valid_pointer(void zone, const void ptr) { return 0; }
	392	CF_INLINE BOOL objc_isAuto(id object) { return 0; }
	393	CF_INLINE void* auto_read_weak_reference(void zone, void referrer) { void result = *referrer; return result; }
8ca704e1	394	CF_INLINE void auto_assign_weak_reference(void zone, const void value, const void *location, auto_weak_callback_block_t block) { location = (void )value; }
cf7d2af9	395	CF_INLINE auto_memory_type_t auto_zone_get_layout_type(void zone, void ptr) { return AUTO_UNSCANNED; }
8ca704e1	396	CF_INLINE int auto_zone_set_write_barrier(void zone, const void dest, const void *new_value) { return false; }
cf7d2af9 A	397
cf7d2af9 A	398	CF_INLINE void objc_assertRegisteredThreadWithCollector(void) {}
8ca704e1	399	CF_INLINE void objc_registerThreadWithCollector(void) {}
cf7d2af9	400
8ca704e1 A	401	CF_INLINE uintptr_t _object_getExternalHash(id obj) {
	402	return (uintptr_t)obj;
	403	}
	404
cf7d2af9 A	405	// from objc-auto.h
cf7d2af9 A	406
8ca704e1	407	CF_INLINE BOOL objc_atomicCompareAndSwapPtr(id predicate, id replacement, volatile id *objectLocation)
cf7d2af9 A	408	{ return OSAtomicCompareAndSwapPtr((void )predicate, (void )replacement, (void * volatile *)objectLocation); }
cf7d2af9 A	409
8ca704e1	410	CF_INLINE BOOL objc_atomicCompareAndSwapPtrBarrier(id predicate, id replacement, volatile id *objectLocation)
cf7d2af9 A	411	{ return OSAtomicCompareAndSwapPtrBarrier((void )predicate, (void )replacement, (void * volatile *)objectLocation); }
cf7d2af9 A	412
8ca704e1	413	CF_INLINE BOOL objc_atomicCompareAndSwapGlobal(id predicate, id replacement, volatile id *objectLocation)
cf7d2af9 A	414	{ return OSAtomicCompareAndSwapPtr((void )predicate, (void )replacement, (void * volatile *)objectLocation); }
cf7d2af9 A	415
8ca704e1	416	CF_INLINE BOOL objc_atomicCompareAndSwapGlobalBarrier(id predicate, id replacement, volatile id *objectLocation)
cf7d2af9 A	417	{ return OSAtomicCompareAndSwapPtrBarrier((void )predicate, (void )replacement, (void * volatile *)objectLocation); }
cf7d2af9 A	418
8ca704e1	419	CF_INLINE BOOL objc_atomicCompareAndSwapInstanceVariable(id predicate, id replacement, volatile id *objectLocation)
cf7d2af9 A	420	{ return OSAtomicCompareAndSwapPtr((void )predicate, (void )replacement, (void * volatile *)objectLocation); }
cf7d2af9 A	421
8ca704e1	422	CF_INLINE BOOL objc_atomicCompareAndSwapInstanceVariableBarrier(id predicate, id replacement, volatile id *objectLocation)
cf7d2af9 A	423	{ return OSAtomicCompareAndSwapPtrBarrier((void )predicate, (void )replacement, (void * volatile *)objectLocation); }
cf7d2af9 A	424
8ca704e1	425	CF_INLINE id objc_assign_strongCast(id val, id *dest)
cf7d2af9 A	426	{ return (*dest = val); }
cf7d2af9 A	427
8ca704e1	428	CF_INLINE id objc_assign_global(id val, id *dest)
cf7d2af9 A	429	{ return (*dest = val); }
cf7d2af9 A	430
8ca704e1	431	CF_INLINE id objc_assign_ivar(id val, id dest, ptrdiff_t offset)
cf7d2af9 A	432	{ return ((id)((char *)dest+offset) = val); }
cf7d2af9 A	433
8ca704e1	434	//CF_INLINE void objc_memmove_collectable(void dst, const void *src, size_t size) { return memmove(dst, src, size); }
cf7d2af9	435
8ca704e1	436	CF_INLINE id objc_read_weak(id *location)
cf7d2af9 A	437	{ return *location; }
cf7d2af9 A	438
8ca704e1	439	CF_INLINE id objc_assign_weak(id value, id *location)
cf7d2af9 A	440	{ return (*location = value); }
	441
	442
8ca704e1 A	443	CF_INLINE void objc_finalizeOnMainThread(Class cls) { }
	444	CF_INLINE BOOL objc_is_finalized(void *ptr) { return NO; }
	445	CF_INLINE void objc_clear_stack(unsigned long options) { }
cf7d2af9	446
8ca704e1 A	447	CF_INLINE BOOL objc_collectingEnabled(void) { return NO; }
8ca704e1 A	448	CF_INLINE void objc_start_collector_thread(void) { }
cf7d2af9	449
8ca704e1	450	CF_INLINE void objc_collect(unsigned long options) { }
cf7d2af9 A	451
	452	#endif
	453
	454	// Need to use the _O_BINARY flag on Windows to get the correct behavior
	455	#if DEPLOYMENT_TARGET_WINDOWS
	456	#define CF_OPENFLGS (_O_BINARY\|_O_NOINHERIT)
	457	#else
	458	#define CF_OPENFLGS (0)
	459	#endif
	460
8ca704e1 A	461	#if DEPLOYMENT_TARGET_WINDOWS
	462
	463	// These are replacements for pthread calls on Windows
	464	CF_EXPORT int _NS_pthread_main_np();
	465	CF_EXPORT int _NS_pthread_setspecific(pthread_key_t key, const void *val);
	466	CF_EXPORT void* _NS_pthread_getspecific(pthread_key_t key);
	467	CF_EXPORT int _NS_pthread_key_init_np(int key, void (destructor)(void ));
	468	CF_EXPORT void _NS_pthread_setname_np(const char *name);
	469
	470	// map use of pthread_set/getspecific to internal API
	471	#define pthread_setspecific _NS_pthread_setspecific
	472	#define pthread_getspecific _NS_pthread_getspecific
	473	#define pthread_key_init_np _NS_pthread_key_init_np
	474	#define pthread_main_np _NS_pthread_main_np
	475	#define pthread_setname_np _NS_pthread_setname_np
	476	#endif
cf7d2af9	477
8ca704e1 A	478	#if DEPLOYMENT_TARGET_WINDOWS
	479	// replacement for DISPATCH_QUEUE_OVERCOMMIT until we get a bug fix in dispatch on Windows
	480	// <rdar://problem/7923891> dispatch on Windows: Need queue_private.h
	481	#define DISPATCH_QUEUE_OVERCOMMIT 2
	482	#endif
	483
cf7d2af9 A	484	#if DEPLOYMENT_TARGET_WINDOWS && defined(__cplusplus)
	485	} // extern "C"
	486	#endif