sdl-ios-xcode: src/loadso/macosx/SDL

comparison src/loadso/macosx/SDL_dlcompat.c @ 1895:c121d94672cb

SDL 1.2 is moving to a branch, and SDL 1.3 is becoming the head.

author	Sam Lantinga <slouken@libsdl.org>
date	Mon, 10 Jul 2006 21:04:37 +0000
parents	e308d020d315
children	e1da92da346c

comparison

equal deleted inserted replaced

-:c69cee13dd76
+:c121d94672cb
 #define __BSD_VISIBLE 1
 #endif
 /*include "dlfcn.h"*/
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 #if defined (__GNUC__) && __GNUC__ > 3
 #define dl_restrict __restrict
 #else
 #if 0
 #ifndef _POSIX_SOURCE
 /*
 * Structure filled in by dladdr().
 */
-typedef struct SDL_OSX_dl_info {
+typedef struct SDL_OSX_dl_info
-const char      *dli_fname;     /* Pathname of shared object */
+{
-void            *dli_fbase;     /* Base address of shared object */
+const char *dli_fname;  /* Pathname of shared object */
-const char      *dli_sname;     /* Name of nearest symbol */
+void *dli_fbase;        /* Base address of shared object */
-void            *dli_saddr;     /* Address of nearest symbol */
+const char *dli_sname;  /* Name of nearest symbol */
-} SDL_OSX_Dl_info;
+void *dli_saddr;        /* Address of nearest symbol */
+} SDL_OSX_Dl_info;
-static int SDL_OSX_dladdr(const void * dl_restrict, SDL_OSX_Dl_info * dl_restrict);
-#endif /* ! _POSIX_SOURCE */
+static int SDL_OSX_dladdr(const void *dl_restrict,
-#endif /* 0 */
+SDL_OSX_Dl_info * dl_restrict);
+#endif                          /* ! _POSIX_SOURCE */
-static int SDL_OSX_dlclose(void * handle);
+#endif                          /* 0 */
-static const char * SDL_OSX_dlerror(void);
-static void * SDL_OSX_dlopen(const char *path, int mode);
+static int SDL_OSX_dlclose(void *handle);
-static void * SDL_OSX_dlsym(void * dl_restrict handle, const char * dl_restrict symbol);
+static const char *SDL_OSX_dlerror(void);
+static void *SDL_OSX_dlopen(const char *path, int mode);
+static void *SDL_OSX_dlsym(void *dl_restrict handle,
+const char *dl_restrict symbol);
 #define RTLD_LAZY	0x1
 #define RTLD_NOW	0x2
 #define RTLD_LOCAL	0x4
 #define RTLD_GLOBAL	0x8
 #define RTLD_NODELETE	0x80
 /*
 * Special handle arguments for SDL_OSX_dlsym().
 */
-#define	RTLD_NEXT		((void *) -1)	/* Search subsequent objects. */
+#define	RTLD_NEXT		((void *) -1)   /* Search subsequent objects. */
-#define	RTLD_DEFAULT	((void *) -2)	/* Use default search algorithm. */
+#define	RTLD_DEFAULT	((void *) -2)   /* Use default search algorithm. */
-#endif /* ! _POSIX_SOURCE */
+#endif                          /* ! _POSIX_SOURCE */
 #ifdef __cplusplus
 }
 #endif
 #endif
 #ifndef NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR
 #define NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR 0x4
 #endif
 /* These symbols will be looked for in dyld */
-static const struct mach_header *(*dyld_NSAddImage) (const char *, unsigned long) = 0;
+static const struct mach_header *(*dyld_NSAddImage) (const char *,
-static int (*dyld_NSIsSymbolNameDefinedInImage) (const struct mach_header *, const char *) = 0;
+unsigned long) = 0;
-static NSSymbol(*dyld_NSLookupSymbolInImage)
+static int (*dyld_NSIsSymbolNameDefinedInImage) (const struct mach_header *,
-	(const struct mach_header *, const char *, unsigned long) = 0;
+const char *) = 0;
+static NSSymbol(*dyld_NSLookupSymbolInImage) (const struct mach_header *,
+const char *, unsigned long) =
+0;
 /* Define this to make dlcompat reuse data block. This way in theory we save
 * a little bit of overhead. However we then couldn't correctly catch excess
 * calls to SDL_OSX_dlclose(). Hence we don't use this feature
 */
 */
 static pthread_key_t dlerror_key;
 struct dlthread
 {
-	int lockcnt;
+int lockcnt;
-	unsigned char errset;
+unsigned char errset;
-	char errstr[ERR_STR_LEN];
+char errstr[ERR_STR_LEN];
 };
 /* This is our central data structure. Whenever a module is loaded via
 * SDL_OSX_dlopen(), we create such a struct.
 */
 struct dlstatus
 {
-	struct dlstatus *next;		/* pointer to next element in the linked list */
+struct dlstatus *next;      /* pointer to next element in the linked list */
-	NSModule module;
+NSModule module;
-	const struct mach_header *lib;
+const struct mach_header *lib;
-	int refs;					/* reference count */
+int refs;                   /* reference count */
-	int mode;					/* mode in which this module was loaded */
+int mode;                   /* mode in which this module was loaded */
-	dev_t device;
+dev_t device;
-	ino_t inode;
+ino_t inode;
-	int flags;					/* Any internal flags we may need */
+int flags;                  /* Any internal flags we may need */
 };
 /* Head node of the dlstatus list */
-static struct dlstatus mainStatus = { 0, MAGIC_DYLIB_MOD, NULL, -1, RTLD_GLOBAL, 0, 0, 0 };
+static struct dlstatus mainStatus =
+{ 0, MAGIC_DYLIB_MOD, NULL, -1, RTLD_GLOBAL, 0, 0, 0 };
 static struct dlstatus *stqueue = &mainStatus;
 /* Storage for the last error message (used by dlerror()) */
 /* static char err_str[ERR_STR_LEN]; */
 static inline int isFlagSet(int mode, int flag);
 static struct dlstatus *lookupStatus(const struct stat *sbuf);
 static void insertStatus(struct dlstatus *dls, const struct stat *sbuf);
 static int promoteLocalToGlobal(struct dlstatus *dls);
 static void *reference(struct dlstatus *dls, int mode);
-static void *dlsymIntern(struct dlstatus *dls, const char *symbol, int canSetError);
+static void *dlsymIntern(struct dlstatus *dls, const char *symbol,
+int canSetError);
 static struct dlstatus *allocStatus(void);
-static struct dlstatus *loadModule(const char *path, const struct stat *sbuf, int mode);
+static struct dlstatus *loadModule(const char *path, const struct stat *sbuf,
-static NSSymbol search_linked_libs(const struct mach_header *mh, const char *symbol);
+int mode);
+static NSSymbol search_linked_libs(const struct mach_header *mh,
+const char *symbol);
 static const char *get_lib_name(const struct mach_header *mh);
 static const struct mach_header *get_mach_header_from_NSModule(NSModule mod);
 static void dlcompat_init_func(void);
 static inline void dlcompat_init_check(void);
 static inline void dolock(void);
 /* Two Global Functions */
 static void *dlsym_prepend_underscore(void *handle, const char *symbol);
 static void *dlsym_auto_underscore(void *handle, const char *symbol);
 /* And their _intern counterparts */
-static void *dlsym_prepend_underscore_intern(void *handle, const char *symbol);
+static void *dlsym_prepend_underscore_intern(void *handle,
+const char *symbol);
 static void *dlsym_auto_underscore_intern(void *handle, const char *symbol);
 #endif
 /* Functions */
-static void debug(const char *fmt, ...)
+static void
+debug(const char *fmt, ...)
 {
 #if DEBUG > 1
-	va_list arg;
+va_list arg;
-	va_start(arg, fmt);
+va_start(arg, fmt);
-	fprintf(stderr, "DLDEBUG: ");
+fprintf(stderr, "DLDEBUG: ");
-	vfprintf(stderr, fmt, arg);
+vfprintf(stderr, fmt, arg);
-	fprintf(stderr, "\n");
+fprintf(stderr, "\n");
-	fflush(stderr);
+fflush(stderr);
-	va_end(arg);
+va_end(arg);
 #endif
 }
-static void error(const char *str, ...)
+static void
-{
+error(const char *str, ...)
-	va_list arg;
+{
-	struct dlthread  *tss;
+va_list arg;
-	char * err_str;
+struct dlthread *tss;
-	va_start(arg, str);
+char *err_str;
-	tss = pthread_getspecific(dlerror_key);
+va_start(arg, str);
-	err_str = tss->errstr;
+tss = pthread_getspecific(dlerror_key);
-	SDL_strlcpy(err_str, "dlcompat: ", ERR_STR_LEN);
+err_str = tss->errstr;
-	vsnprintf(err_str + 10, ERR_STR_LEN - 10, str, arg);
+SDL_strlcpy(err_str, "dlcompat: ", ERR_STR_LEN);
-	va_end(arg);
+vsnprintf(err_str + 10, ERR_STR_LEN - 10, str, arg);
-	debug("ERROR: %s\n", err_str);
+va_end(arg);
-	tss->errset = 1;
+debug("ERROR: %s\n", err_str);
-}
+tss->errset = 1;
+}
-static void warning(const char *str)
+static void
+warning(const char *str)
 {
 #if DEBUG > 0
-	fprintf(stderr, "WARNING: dlcompat: %s\n", str);
+fprintf(stderr, "WARNING: dlcompat: %s\n", str);
 #endif
 }
-static const char *safegetenv(const char *s)
+static const char *
-{
+safegetenv(const char *s)
-	const char *ss = SDL_getenv(s);
+{
-	return ss ? ss : "";
+const char *ss = SDL_getenv(s);
+return ss ? ss : "";
 }
 /* because this is only used for debugging and error reporting functions, we
 * don't really care about how elegant it is... it could use the load
 * commands to find the install name of the library, but...
 */
-static const char *get_lib_name(const struct mach_header *mh)
+static const char *
-{
+get_lib_name(const struct mach_header *mh)
-	unsigned long count = _dyld_image_count();
+{
-	unsigned long i;
+unsigned long count = _dyld_image_count();
-	const char *val = NULL;
+unsigned long i;
-	if (mh)
+const char *val = NULL;
-	{
+if (mh) {
-		for (i = 0; i < count; i++)
+for (i = 0; i < count; i++) {
-		{
+if (mh == _dyld_get_image_header(i)) {
-			if (mh == _dyld_get_image_header(i))
+val = _dyld_get_image_name(i);
-			{
+break;
-				val = _dyld_get_image_name(i);
+}
-				break;
+}
-			}
+}
-		}
+return val;
-	}
-	return val;
 }
 /* Returns the mach_header for the module bu going through all the loaded images
 * and finding the one with the same name as the module. There really ought to be
 * an api for doing this, would be faster, but there isn't one right now
 */
-static const struct mach_header *get_mach_header_from_NSModule(NSModule mod)
+static const struct mach_header *
-{
+get_mach_header_from_NSModule(NSModule mod)
-	const char *mod_name = NSNameOfModule(mod);
+{
-	const struct mach_header *mh = NULL;
+const char *mod_name = NSNameOfModule(mod);
-	unsigned long count = _dyld_image_count();
+const struct mach_header *mh = NULL;
-	unsigned long i;
+unsigned long count = _dyld_image_count();
-	debug("Module name: %s", mod_name);
+unsigned long i;
-	for (i = 0; i < count; i++)
+debug("Module name: %s", mod_name);
-	{
+for (i = 0; i < count; i++) {
-		if (!SDL_strcmp(mod_name, _dyld_get_image_name(i)))
+if (!SDL_strcmp(mod_name, _dyld_get_image_name(i))) {
-		{
+mh = _dyld_get_image_header(i);
-			mh = _dyld_get_image_header(i);
+break;
-			break;
+}
-		}
+}
-	}
+return mh;
-	return mh;
 }
 /* Compute and return a list of all directories that we should search when
 * trying to locate a module. We first look at the values of LD_LIBRARY_PATH
 * /usr/lib and /lib. Since both of the environments variables can contain a
 * list of colon seperated paths, we simply concat them and the two other paths
 * into one big string, which we then can easily parse.
 * Splitting this string into the actual path list is done by getSearchPath()
 */
-static const char *searchList()
+static const char *
-{
+searchList()
-	size_t buf_size;
+{
-	static char *buf=NULL;
+size_t buf_size;
-	const char *ldlp = safegetenv("LD_LIBRARY_PATH");
+static char *buf = NULL;
-	const char *dyldlp = safegetenv("DYLD_LIBRARY_PATH");
+const char *ldlp = safegetenv("LD_LIBRARY_PATH");
-	const char *stdpath = SDL_getenv("DYLD_FALLBACK_LIBRARY_PATH");
+const char *dyldlp = safegetenv("DYLD_LIBRARY_PATH");
-	if (!stdpath)
+const char *stdpath = SDL_getenv("DYLD_FALLBACK_LIBRARY_PATH");
-		stdpath = "/usr/local/lib:/lib:/usr/lib";
+if (!stdpath)
-	if (!buf)
+stdpath = "/usr/local/lib:/lib:/usr/lib";
-	{
+if (!buf) {
-		buf_size = SDL_strlen(ldlp) + SDL_strlen(dyldlp) + SDL_strlen(stdpath) + 4;
+buf_size =
-		buf = SDL_malloc(buf_size);
+SDL_strlen(ldlp) + SDL_strlen(dyldlp) + SDL_strlen(stdpath) + 4;
-		SDL_snprintf(buf, buf_size, "%s%s%s%s%s%c", dyldlp, (dyldlp[0] ? ":" : ""), ldlp, (ldlp[0] ? ":" : ""),
+buf = SDL_malloc(buf_size);
-				 stdpath, '\0');
+SDL_snprintf(buf, buf_size, "%s%s%s%s%s%c", dyldlp,
-	}
+(dyldlp[0] ? ":" : ""), ldlp, (ldlp[0] ? ":" : ""),
-	return buf;
+stdpath, '\0');
+}
+return buf;
 }
 /* Returns the ith search path from the list as computed by searchList() */
-static const char *getSearchPath(int i)
+static const char *
-{
+getSearchPath(int i)
-	static const char *list = 0;
+{
-	static char **path = (char **)0;
+static const char *list = 0;
-	static int end = 0;
+static char **path = (char **) 0;
-	static int numsize = MAX_SEARCH_PATHS;
+static int end = 0;
-	static char **tmp;
+static int numsize = MAX_SEARCH_PATHS;
-	/* So we can call SDL_free() in the "destructor" we use i=-1 to return the alloc'd array */
+static char **tmp;
-	if (i == -1)
+/* So we can call SDL_free() in the "destructor" we use i=-1 to return the alloc'd array */
-	{
+if (i == -1) {
-		return (const char*)path;
+return (const char *) path;
-	}
+}
-	if (!path)
+if (!path) {
-	{
+path = (char **) SDL_calloc(MAX_SEARCH_PATHS, sizeof(char **));
-		path = (char **)SDL_calloc(MAX_SEARCH_PATHS, sizeof(char **));
+}
-	}
+if (!list && !end)
-	if (!list && !end)
+list = searchList();
-		list = searchList();
+if (i >= (numsize)) {
-	if (i >= (numsize))
+debug("Increasing size for long PATH");
-	{
+tmp =
-		debug("Increasing size for long PATH");
+(char **) SDL_calloc((MAX_SEARCH_PATHS + numsize),
-		tmp = (char **)SDL_calloc((MAX_SEARCH_PATHS + numsize), sizeof(char **));
+sizeof(char **));
-		if (tmp)
+if (tmp) {
-		{
+SDL_memcpy(tmp, path, sizeof(char **) * numsize);
-			SDL_memcpy(tmp, path, sizeof(char **) * numsize);
+SDL_free(path);
-			SDL_free(path);
+path = tmp;
-			path = tmp;
+numsize += MAX_SEARCH_PATHS;
-			numsize += MAX_SEARCH_PATHS;
+} else {
-		}
+return 0;
-		else
+}
-		{
+}
-			return 0;
-		}
+while (!path[i] && !end) {
-	}
+path[i] = strsep((char **) &list, ":");
-	while (!path[i] && !end)
+if (path[i][0] == 0)
-	{
+path[i] = 0;
-		path[i] = strsep((char **)&list, ":");
+end = (list == 0);
+}
-		if (path[i][0] == 0)
+return path[i];
-			path[i] = 0;
+}
-		end = (list == 0);
-	}
+static const char *
-	return path[i];
+getFullPath(int i, const char *file)
-}
+{
+static char buf[PATH_MAX];
-static const char *getFullPath(int i, const char *file)
+const char *path = getSearchPath(i);
-{
+if (path) {
-	static char buf[PATH_MAX];
+SDL_snprintf(buf, PATH_MAX, "%s/%s", path, file);
-	const char *path = getSearchPath(i);
+}
-	if (path)
+return path ? buf : 0;
-	{
-		SDL_snprintf(buf, PATH_MAX, "%s/%s", path, file);
-	}
-	return path ? buf : 0;
 }
 /* Given a file name, try to determine the full path for that file. Starts
 * its search in the current directory, and then tries all paths in the
 * search list in the order they are specified there.
 */
-static const struct stat *findFile(const char *file, const char **fullPath)
+static const struct stat *
-{
+findFile(const char *file, const char **fullPath)
-	int i = 0;
+{
-	static struct stat sbuf;
+int i = 0;
-	char *fileName;
+static struct stat sbuf;
-	debug("finding file %s", file);
+char *fileName;
-	*fullPath = file;
+debug("finding file %s", file);
-	if (0 == stat(file, &sbuf))
+*fullPath = file;
-		return &sbuf;
+if (0 == stat(file, &sbuf))
-	if (SDL_strchr(file, '/'))
+return &sbuf;
-		return 0;				/* If the path had a / we don't look in env var places */
+if (SDL_strchr(file, '/'))
-	fileName = NULL;
+return 0;               /* If the path had a / we don't look in env var places */
-	if (!fileName)
+fileName = NULL;
-		fileName = (char *)file;
+if (!fileName)
-	while ((*fullPath = getFullPath(i++, fileName)))
+fileName = (char *) file;
-	{
+while ((*fullPath = getFullPath(i++, fileName))) {
-		if (0 == stat(*fullPath, &sbuf))
+if (0 == stat(*fullPath, &sbuf))
-			return &sbuf;
+return &sbuf;
-	}
+}
-	;
+;
-	return 0;
+return 0;
 }
 /* Determine whether a given dlstatus is valid or not */
-static int isValidStatus(struct dlstatus *status)
+static int
-{
+isValidStatus(struct dlstatus *status)
-	/* Walk the list to verify status is contained in it */
+{
-	struct dlstatus *dls = stqueue;
+/* Walk the list to verify status is contained in it */
-	while (dls && status != dls)
+struct dlstatus *dls = stqueue;
-		dls = dls->next;
+while (dls && status != dls)
-	if (dls == 0)
+dls = dls->next;
-		error("invalid handle");
+if (dls == 0)
-	else if ((dls->module == 0) || (dls->refs == 0))
+error("invalid handle");
-		error("handle to closed library");
+else if ((dls->module == 0) || (dls->refs == 0))
-	else
+error("handle to closed library");
-		return TRUE;
+else
-	return FALSE;
+return TRUE;
-}
+return FALSE;
+}
-static inline int isFlagSet(int mode, int flag)
-{
+static inline int
-	return (mode & flag) == flag;
+isFlagSet(int mode, int flag)
-}
+{
+return (mode & flag) == flag;
-static struct dlstatus *lookupStatus(const struct stat *sbuf)
+}
-{
-	struct dlstatus *dls = stqueue;
+static struct dlstatus *
-	debug("looking for status");
+lookupStatus(const struct stat *sbuf)
-	while (dls && ( /* isFlagSet(dls->mode, RTLD_UNSHARED) */ 0
+{
-				   || sbuf->st_dev != dls->device || sbuf->st_ino != dls->inode))
+struct dlstatus *dls = stqueue;
-		dls = dls->next;
+debug("looking for status");
-	return dls;
+while (dls && ( /* isFlagSet(dls->mode, RTLD_UNSHARED) */ 0
-}
+|| sbuf->st_dev != dls->device
+|| sbuf->st_ino != dls->inode))
-static void insertStatus(struct dlstatus *dls, const struct stat *sbuf)
+dls = dls->next;
-{
+return dls;
-	debug("inserting status");
+}
-	dls->inode = sbuf->st_ino;
-	dls->device = sbuf->st_dev;
+static void
-	dls->refs = 0;
+insertStatus(struct dlstatus *dls, const struct stat *sbuf)
-	dls->mode = 0;
+{
-	if ((dls->flags & DL_IN_LIST) == 0)
+debug("inserting status");
-	{
+dls->inode = sbuf->st_ino;
-		dls->next = stqueue;
+dls->device = sbuf->st_dev;
-		stqueue = dls;
+dls->refs = 0;
-		dls->flags |= DL_IN_LIST;
+dls->mode = 0;
-	}
+if ((dls->flags & DL_IN_LIST) == 0) {
-}
+dls->next = stqueue;
+stqueue = dls;
-static struct dlstatus *allocStatus()
+dls->flags |= DL_IN_LIST;
-{
+}
-	struct dlstatus *dls;
+}
+static struct dlstatus *
+allocStatus()
+{
+struct dlstatus *dls;
 #ifdef REUSE_STATUS
-	dls = stqueue;
+dls = stqueue;
-	while (dls && dls->module)
+while (dls && dls->module)
-		dls = dls->next;
+dls = dls->next;
-	if (!dls)
+if (!dls)
 #endif
-		dls = SDL_calloc(sizeof(*dls),1);
+dls = SDL_calloc(sizeof(*dls), 1);
-	return dls;
+return dls;
 }
-static int promoteLocalToGlobal(struct dlstatus *dls)
+static int
-{
+promoteLocalToGlobal(struct dlstatus *dls)
-	static int (*p) (NSModule module) = 0;
+{
-	debug("promoting");
+static int (*p) (NSModule module) = 0;
-	if (!p)
+debug("promoting");
-		_dyld_func_lookup("__dyld_NSMakePrivateModulePublic", (void **)&p);
+if (!p)
-	return (dls->module == MAGIC_DYLIB_MOD) || (p && p(dls->module));
+_dyld_func_lookup("__dyld_NSMakePrivateModulePublic", (void **) &p);
-}
+return (dls->module == MAGIC_DYLIB_MOD) || (p && p(dls->module));
+}
-static void *reference(struct dlstatus *dls, int mode)
-{
+static void *
-	if (dls)
+reference(struct dlstatus *dls, int mode)
-	{
+{
-		if (dls->module == MAGIC_DYLIB_MOD && isFlagSet(mode, RTLD_LOCAL))
+if (dls) {
-		{
+if (dls->module == MAGIC_DYLIB_MOD && isFlagSet(mode, RTLD_LOCAL)) {
-			warning("trying to open a .dylib with RTLD_LOCAL");
+warning("trying to open a .dylib with RTLD_LOCAL");
-			error("unable to open a .dylib with RTLD_LOCAL");
+error("unable to open a .dylib with RTLD_LOCAL");
-			return NULL;
+return NULL;
-		}
+}
-		if (isFlagSet(mode, RTLD_GLOBAL) &&
+if (isFlagSet(mode, RTLD_GLOBAL) && !isFlagSet(dls->mode, RTLD_GLOBAL)
-			!isFlagSet(dls->mode, RTLD_GLOBAL) && !promoteLocalToGlobal(dls))
+&& !promoteLocalToGlobal(dls)) {
-		{
+error("unable to promote local module to global");
-			error("unable to promote local module to global");
+return NULL;
-			return NULL;
+}
-		}
+dls->mode |= mode;
-		dls->mode |= mode;
+dls->refs++;
-		dls->refs++;
+} else
-	}
+debug("reference called with NULL argument");
-	else
-		debug("reference called with NULL argument");
+return dls;
+}
-	return dls;
-}
+static const struct mach_header *
+my_find_image(const char *name)
-static const struct mach_header *my_find_image(const char *name)
+{
-{
+const struct mach_header *mh = 0;
-	const struct mach_header *mh = 0;
+const char *id = NULL;
-	const char *id = NULL;
+int i = _dyld_image_count();
-	int i = _dyld_image_count();
+int j;
-	int j;
+mh = (struct mach_header *)
-	mh = (struct mach_header *)
+dyld_NSAddImage(name, NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED |
-		dyld_NSAddImage(name, NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED |
+NSADDIMAGE_OPTION_RETURN_ON_ERROR);
-						NSADDIMAGE_OPTION_RETURN_ON_ERROR);
+if (!mh) {
-	if (!mh)
+for (j = 0; j < i; j++) {
-	{
+id = _dyld_get_image_name(j);
-		for (j = 0; j < i; j++)
+if (!SDL_strcmp(id, name)) {
-		{
+mh = _dyld_get_image_header(j);
-			id = _dyld_get_image_name(j);
+break;
-			if (!SDL_strcmp(id, name))
+}
-			{
+}
-				mh = _dyld_get_image_header(j);
+}
-				break;
+return mh;
-			}
-		}
-	}
-	return mh;
 }
 /*
 * dyld adds libraries by first adding the directly dependant libraries in link order, and
 * then adding the dependencies for those libraries, so we should do the same... but we don't
 * bother adding the extra dependencies, if the symbols are neither in the loaded image nor
 * any of it's direct dependencies, then it probably isn't there.
 */
-static NSSymbol search_linked_libs(const struct mach_header * mh, const char *symbol)
+static NSSymbol
-{
+search_linked_libs(const struct mach_header *mh, const char *symbol)
-	unsigned int n;
+{
-	struct load_command *lc = 0;
+unsigned int n;
-	struct mach_header *wh;
+struct load_command *lc = 0;
-	NSSymbol nssym = 0;
+struct mach_header *wh;
-	if (dyld_NSAddImage && dyld_NSIsSymbolNameDefinedInImage && dyld_NSLookupSymbolInImage)
+NSSymbol nssym = 0;
-	{
+if (dyld_NSAddImage && dyld_NSIsSymbolNameDefinedInImage
-		lc = (struct load_command *)((char *)mh + sizeof(struct mach_header));
+&& dyld_NSLookupSymbolInImage) {
-		for (n = 0; n < mh->ncmds; n++, lc = (struct load_command *)((char *)lc + lc->cmdsize))
+lc = (struct load_command *) ((char *) mh +
-		{
+sizeof(struct mach_header));
-			if ((LC_LOAD_DYLIB == lc->cmd) || (LC_LOAD_WEAK_DYLIB == lc->cmd))
+for (n = 0; n < mh->ncmds;
-			{
+n++, lc = (struct load_command *) ((char *) lc + lc->cmdsize)) {
-				if ((wh = (struct mach_header *)
+if ((LC_LOAD_DYLIB == lc->cmd)
-					 my_find_image((char *)(((struct dylib_command *)lc)->dylib.name.offset +
+|| (LC_LOAD_WEAK_DYLIB == lc->cmd)) {
-											(char *)lc))))
+if ((wh = (struct mach_header *)
-				{
+my_find_image((char
-					if (dyld_NSIsSymbolNameDefinedInImage(wh, symbol))
+*) (((struct dylib_command *) lc)->
-					{
+dylib.name.offset + (char *) lc)))) {
-						nssym = dyld_NSLookupSymbolInImage(wh,
+if (dyld_NSIsSymbolNameDefinedInImage(wh, symbol)) {
-														   symbol,
+nssym = dyld_NSLookupSymbolInImage(wh,
-														   NSLOOKUPSYMBOLINIMAGE_OPTION_BIND |
+symbol,
-														   NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR);
+NSLOOKUPSYMBOLINIMAGE_OPTION_BIND
-						break;
+|
-					}
+NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR);
-				}
+break;
-			}
+}
-		}
+}
-		if ((!nssym) && NSIsSymbolNameDefined(symbol))
+}
-		{
+}
-			/* I've never seen this debug message...*/
+if ((!nssym) && NSIsSymbolNameDefined(symbol)) {
-			debug("Symbol \"%s\" is defined but was not found", symbol);
+/* I've never seen this debug message... */
-		}
+debug("Symbol \"%s\" is defined but was not found", symbol);
-	}
+}
-	return nssym;
+}
+return nssym;
 }
 /* Up to the caller to SDL_free() returned string */
-static inline char *dyld_error_str()
+static inline char *
-{
+dyld_error_str()
-	NSLinkEditErrors dylder;
+{
-	int dylderno;
+NSLinkEditErrors dylder;
-	const char *dylderrstr;
+int dylderno;
-	const char *dyldfile;
+const char *dylderrstr;
-	char* retStr = NULL;
+const char *dyldfile;
-	NSLinkEditError(&dylder, &dylderno, &dyldfile, &dylderrstr);
+char *retStr = NULL;
-	if (dylderrstr && *dylderrstr)
+NSLinkEditError(&dylder, &dylderno, &dyldfile, &dylderrstr);
-	{
+if (dylderrstr && *dylderrstr) {
-		retStr = SDL_strdup(dylderrstr);
+retStr = SDL_strdup(dylderrstr);
-	}
+}
-	return retStr;
+return retStr;
 }
-static void *dlsymIntern(struct dlstatus *dls, const char *symbol, int canSetError)
+static void *
-{
+dlsymIntern(struct dlstatus *dls, const char *symbol, int canSetError)
-NSSymbol nssym = 0;
+{
-#ifdef __GCC__
+NSSymbol nssym = 0;
-	void *caller = __builtin_return_address(1);	/* Be *very* careful about inlining */
+#ifdef __GCC__
+void *caller = __builtin_return_address(1); /* Be *very* careful about inlining */
 #else
-	void *caller = NULL;
+void *caller = NULL;
 #endif
-	const struct mach_header *caller_mh = 0;
+const struct mach_header *caller_mh = 0;
-	char *savedErrorStr = NULL;
+char *savedErrorStr = NULL;
-	resetdlerror();
+resetdlerror();
 #ifndef RTLD_SELF
 #define	RTLD_SELF		((void *) -3)
 #endif
-	if (NULL == dls)
+if (NULL == dls)
-		dls = RTLD_SELF;
+dls = RTLD_SELF;
-	if ((RTLD_NEXT == dls) || (RTLD_SELF == dls))
+if ((RTLD_NEXT == dls) || (RTLD_SELF == dls)) {
-	{
+if (dyld_NSIsSymbolNameDefinedInImage && dyld_NSLookupSymbolInImage
-		if (dyld_NSIsSymbolNameDefinedInImage && dyld_NSLookupSymbolInImage && caller)
+&& caller) {
-		  {
+caller_mh = image_for_address(caller);
-			caller_mh = image_for_address(caller);
+if (RTLD_SELF == dls) {
-			if (RTLD_SELF == dls)
+/* FIXME: We should be using the NSModule api, if SELF is an MH_BUNDLE
-			{
+* But it appears to work anyway, and looking at the code in dyld_libfuncs.c
-				/* FIXME: We should be using the NSModule api, if SELF is an MH_BUNDLE
+* this is acceptable.
-				 * But it appears to work anyway, and looking at the code in dyld_libfuncs.c
+*/
-				 * this is acceptable.
+if (dyld_NSIsSymbolNameDefinedInImage(caller_mh, symbol)) {
-				 */
+nssym = dyld_NSLookupSymbolInImage(caller_mh,
-				if (dyld_NSIsSymbolNameDefinedInImage(caller_mh, symbol))
+symbol,
-				{
+NSLOOKUPSYMBOLINIMAGE_OPTION_BIND
-					nssym = dyld_NSLookupSymbolInImage(caller_mh,
+|
-													   symbol,
+NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR);
-													   NSLOOKUPSYMBOLINIMAGE_OPTION_BIND |
+}
-													   NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR);
+}
-				}
+if (!nssym) {
-			}
+if (RTLD_SELF == dls)
-			if (!nssym)
+savedErrorStr = dyld_error_str();
-			{
+nssym = search_linked_libs(caller_mh, symbol);
-				if (RTLD_SELF == dls)
+}
-					savedErrorStr = dyld_error_str();
+} else {
-				nssym = search_linked_libs(caller_mh, symbol);
+if (canSetError)
-			}
+error("RTLD_SELF and RTLD_NEXT are not supported");
-		}
+return NULL;
-		else
+}
-		{
+}
-			if (canSetError)
+if (!nssym) {
-				error("RTLD_SELF and RTLD_NEXT are not supported");
-			return NULL;
+if (RTLD_DEFAULT == dls) {
-		}
+dls = &mainStatus;
-	}
+}
-	if (!nssym)
+if (!isValidStatus(dls))
-	{
+return NULL;
-		if (RTLD_DEFAULT == dls)
+if (dls->module != MAGIC_DYLIB_MOD) {
-		{
+nssym = NSLookupSymbolInModule(dls->module, symbol);
-			dls = &mainStatus;
+if (!nssym && NSIsSymbolNameDefined(symbol)) {
-		}
+debug("Searching dependencies");
-		if (!isValidStatus(dls))
+savedErrorStr = dyld_error_str();
-			return NULL;
+nssym =
+search_linked_libs(get_mach_header_from_NSModule
-		if (dls->module != MAGIC_DYLIB_MOD)
+(dls->module), symbol);
-		{
+}
-			nssym = NSLookupSymbolInModule(dls->module, symbol);
+} else if (dls->lib && dyld_NSIsSymbolNameDefinedInImage
-			if (!nssym && NSIsSymbolNameDefined(symbol))
+&& dyld_NSLookupSymbolInImage) {
-			{
+if (dyld_NSIsSymbolNameDefinedInImage(dls->lib, symbol)) {
-				debug("Searching dependencies");
+nssym = dyld_NSLookupSymbolInImage(dls->lib,
-				savedErrorStr = dyld_error_str();
+symbol,
-				nssym = search_linked_libs(get_mach_header_from_NSModule(dls->module), symbol);
+NSLOOKUPSYMBOLINIMAGE_OPTION_BIND
-			}
+|
-		}
+NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR);
-		else if (dls->lib && dyld_NSIsSymbolNameDefinedInImage && dyld_NSLookupSymbolInImage)
+} else if (NSIsSymbolNameDefined(symbol)) {
-		{
+debug("Searching dependencies");
-			if (dyld_NSIsSymbolNameDefinedInImage(dls->lib, symbol))
+savedErrorStr = dyld_error_str();
-			{
+nssym = search_linked_libs(dls->lib, symbol);
-				nssym = dyld_NSLookupSymbolInImage(dls->lib,
+}
-												   symbol,
+} else if (dls->module == MAGIC_DYLIB_MOD) {
-												   NSLOOKUPSYMBOLINIMAGE_OPTION_BIND |
+/* Global context, use NSLookupAndBindSymbol */
-												   NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR);
+if (NSIsSymbolNameDefined(symbol)) {
-			}
+/* There doesn't seem to be a return on error option for this call???
-			else if (NSIsSymbolNameDefined(symbol))
+this is potentially broken, if binding fails, it will improperly
-			{
+exit the application. */
-				debug("Searching dependencies");
+nssym = NSLookupAndBindSymbol(symbol);
-				savedErrorStr = dyld_error_str();
+} else {
-				nssym = search_linked_libs(dls->lib, symbol);
+if (savedErrorStr)
-			}
+SDL_free(savedErrorStr);
-		}
+savedErrorStr = SDL_malloc(256);
-		else if (dls->module == MAGIC_DYLIB_MOD)
+SDL_snprintf(savedErrorStr, 256,
-		{
+"Symbol \"%s\" not in global context", symbol);
-			/* Global context, use NSLookupAndBindSymbol */
+}
-			if (NSIsSymbolNameDefined(symbol))
+}
-			{
+}
-				/* There doesn't seem to be a return on error option for this call???
+/* Error reporting */
-				   this is potentially broken, if binding fails, it will improperly
+if (!nssym) {
-				   exit the application. */
+if (!savedErrorStr || !SDL_strlen(savedErrorStr)) {
-				nssym = NSLookupAndBindSymbol(symbol);
+if (savedErrorStr)
-			}
+SDL_free(savedErrorStr);
-			else
+savedErrorStr = SDL_malloc(256);
-			{
+SDL_snprintf(savedErrorStr, 256, "Symbol \"%s\" not found",
-				if (savedErrorStr)
+symbol);
-					SDL_free(savedErrorStr);
+}
-				savedErrorStr = SDL_malloc(256);
+if (canSetError) {
-				SDL_snprintf(savedErrorStr, 256, "Symbol \"%s\" not in global context",symbol);
+error(savedErrorStr);
-			}
+} else {
-		}
+debug(savedErrorStr);
-	}
+}
-	/* Error reporting */
+if (savedErrorStr)
-	if (!nssym)
+SDL_free(savedErrorStr);
-	{
+return NULL;
-		if (!savedErrorStr || !SDL_strlen(savedErrorStr))
+}
-		{
+return NSAddressOfSymbol(nssym);
-			if (savedErrorStr)
+}
-				SDL_free(savedErrorStr);
-			savedErrorStr = SDL_malloc(256);
+static struct dlstatus *
-			SDL_snprintf(savedErrorStr, 256,"Symbol \"%s\" not found",symbol);
+loadModule(const char *path, const struct stat *sbuf, int mode)
-		}
+{
-		if (canSetError)
+NSObjectFileImage ofi = 0;
-		{
+NSObjectFileImageReturnCode ofirc;
-			error(savedErrorStr);
+struct dlstatus *dls;
-		}
+NSLinkEditErrors ler;
-		else
+int lerno;
-		{
+const char *errstr;
-			debug(savedErrorStr);
+const char *file;
-		}
+void (*init) (void);
-		if (savedErrorStr)
-			SDL_free(savedErrorStr);
+ofirc = NSCreateObjectFileImageFromFile(path, &ofi);
-		return NULL;
+switch (ofirc) {
-	}
+case NSObjectFileImageSuccess:
-	return NSAddressOfSymbol(nssym);
+break;
-}
+case NSObjectFileImageInappropriateFile:
+if (dyld_NSAddImage && dyld_NSIsSymbolNameDefinedInImage
-static struct dlstatus *loadModule(const char *path, const struct stat *sbuf, int mode)
+&& dyld_NSLookupSymbolInImage) {
-{
+if (isFlagSet(mode, RTLD_LOCAL)) {
-	NSObjectFileImage ofi = 0;
+warning("trying to open a .dylib with RTLD_LOCAL");
-	NSObjectFileImageReturnCode ofirc;
+error("unable to open this file with RTLD_LOCAL");
-	struct dlstatus *dls;
+return NULL;
-	NSLinkEditErrors ler;
+}
-	int lerno;
+} else {
-	const char *errstr;
+error("opening this file is unsupported on this system");
-	const char *file;
+return NULL;
-	void (*init) (void);
+}
+break;
-	ofirc = NSCreateObjectFileImageFromFile(path, &ofi);
+case NSObjectFileImageFailure:
-	switch (ofirc)
+error("object file setup failure");
-	{
+return NULL;
-		case NSObjectFileImageSuccess:
+case NSObjectFileImageArch:
-			break;
+error("no object for this architecture");
-		case NSObjectFileImageInappropriateFile:
+return NULL;
-			if (dyld_NSAddImage && dyld_NSIsSymbolNameDefinedInImage && dyld_NSLookupSymbolInImage)
+case NSObjectFileImageFormat:
-			{
+error("bad object file format");
-				if (isFlagSet(mode, RTLD_LOCAL))
+return NULL;
-				{
+case NSObjectFileImageAccess:
-					warning("trying to open a .dylib with RTLD_LOCAL");
+error("can't read object file");
-					error("unable to open this file with RTLD_LOCAL");
+return NULL;
-					return NULL;
+default:
-				}
+error("unknown error from NSCreateObjectFileImageFromFile()");
-			}
+return NULL;
-			else
+}
-			{
+dls = lookupStatus(sbuf);
-				error("opening this file is unsupported on this system");
+if (!dls) {
-				return NULL;
+dls = allocStatus();
-			}
+}
-			break;
+if (!dls) {
-		case NSObjectFileImageFailure:
+error("unable to allocate memory");
-			error("object file setup failure");
+return NULL;
-			return NULL;
+}
-		case NSObjectFileImageArch:
+//      dls->lib = 0;
-			error("no object for this architecture");
+if (ofirc == NSObjectFileImageInappropriateFile) {
-			return NULL;
+if ((dls->lib =
-		case NSObjectFileImageFormat:
+dyld_NSAddImage(path, NSADDIMAGE_OPTION_RETURN_ON_ERROR))) {
-			error("bad object file format");
+debug("Dynamic lib loaded at %ld", dls->lib);
-			return NULL;
+ofi = MAGIC_DYLIB_OFI;
-		case NSObjectFileImageAccess:
+dls->module = MAGIC_DYLIB_MOD;
-			error("can't read object file");
+ofirc = NSObjectFileImageSuccess;
-			return NULL;
+/* Although it is possible with a bit of work to modify this so it works and
-		default:
+functions with RTLD_NOW, I don't deem it necessary at the moment */
-			error("unknown error from NSCreateObjectFileImageFromFile()");
+}
-			return NULL;
+if (!(dls->module)) {
-	}
+NSLinkEditError(&ler, &lerno, &file, &errstr);
-	dls = lookupStatus(sbuf);
+if (!errstr || (!SDL_strlen(errstr)))
-	if (!dls)
+error("Can't open this file type");
-	{
+else
-		dls = allocStatus();
+error(errstr);
-	}
+if ((dls->flags & DL_IN_LIST) == 0) {
-	if (!dls)
+SDL_free(dls);
-	{
+}
-		error("unable to allocate memory");
+return NULL;
-		return NULL;
+}
-	}
+} else {
-	//	dls->lib = 0;
+dls->module = NSLinkModule(ofi, path,
-	if (ofirc == NSObjectFileImageInappropriateFile)
+NSLINKMODULE_OPTION_RETURN_ON_ERROR |
-	{
+NSLINKMODULE_OPTION_PRIVATE |
-		if ((dls->lib = dyld_NSAddImage(path, NSADDIMAGE_OPTION_RETURN_ON_ERROR)))
+(isFlagSet(mode, RTLD_NOW) ?
-		{
+NSLINKMODULE_OPTION_BINDNOW : 0));
-			debug("Dynamic lib loaded at %ld", dls->lib);
+NSDestroyObjectFileImage(ofi);
-			ofi = MAGIC_DYLIB_OFI;
+if (dls->module) {
-			dls->module = MAGIC_DYLIB_MOD;
+dls->lib = get_mach_header_from_NSModule(dls->module);
-			ofirc = NSObjectFileImageSuccess;
+}
-			/* Although it is possible with a bit of work to modify this so it works and
+}
-			   functions with RTLD_NOW, I don't deem it necessary at the moment */
+if (!dls->module) {
-		}
+NSLinkEditError(&ler, &lerno, &file, &errstr);
-		if (!(dls->module))
+if ((dls->flags & DL_IN_LIST) == 0) {
-		{
+SDL_free(dls);
-			NSLinkEditError(&ler, &lerno, &file, &errstr);
+}
-			if (!errstr || (!SDL_strlen(errstr)))
+error(errstr);
-				error("Can't open this file type");
+return NULL;
-			else
+}
-				error(errstr);
-			if ((dls->flags & DL_IN_LIST) == 0)
+insertStatus(dls, sbuf);
-			{
+dls = reference(dls, mode);
-				SDL_free(dls);
+if ((init = dlsymIntern(dls, "__init", 0))) {
-			}
+debug("calling _init()");
-			return NULL;
+init();
-		}
+}
-	}
+return dls;
-	else
+}
-	{
-		dls->module = NSLinkModule(ofi, path,
+inline static void
-								   NSLINKMODULE_OPTION_RETURN_ON_ERROR |
+dlcompat_init_check(void)
-								   NSLINKMODULE_OPTION_PRIVATE |
+{
-								   (isFlagSet(mode, RTLD_NOW) ? NSLINKMODULE_OPTION_BINDNOW : 0));
+static pthread_mutex_t l = PTHREAD_MUTEX_INITIALIZER;
-		NSDestroyObjectFileImage(ofi);
+static int init_done = 0;
-		if (dls->module)
-		{
+pthread_mutex_lock(&l);
-			dls->lib = get_mach_header_from_NSModule(dls->module);
+if (!init_done) {
-		}
+dlcompat_init_func();
-	}
+init_done = 1;
-	if (!dls->module)
+}
-	{
+pthread_mutex_unlock(&l);
-		NSLinkEditError(&ler, &lerno, &file, &errstr);
+}
-		if ((dls->flags & DL_IN_LIST) == 0)
-		{
+static void
-			SDL_free(dls);
+dlcompat_init_func(void)
-		}
+{
-		error(errstr);
+_dyld_func_lookup("__dyld_NSAddImage", (void **) &dyld_NSAddImage);
-		return NULL;
+_dyld_func_lookup("__dyld_NSIsSymbolNameDefinedInImage",
-	}
+(void **) &dyld_NSIsSymbolNameDefinedInImage);
+_dyld_func_lookup("__dyld_NSLookupSymbolInImage",
-	insertStatus(dls, sbuf);
+(void **) &dyld_NSLookupSymbolInImage);
-	dls = reference(dls, mode);
+if (pthread_mutex_init(&dlcompat_mutex, NULL))
-	if ((init = dlsymIntern(dls, "__init", 0)))
+exit(1);
-	{
+if (pthread_key_create(&dlerror_key, &dlerrorfree))
-		debug("calling _init()");
+exit(1);
-		init();
+}
-	}
-	return dls;
+static void
-}
+resetdlerror()
+{
-inline static void dlcompat_init_check(void)
+struct dlthread *tss;
-{
+tss = pthread_getspecific(dlerror_key);
-	static pthread_mutex_t l = PTHREAD_MUTEX_INITIALIZER;
+tss->errset = 0;
-	static int init_done = 0;
+}
-	pthread_mutex_lock(&l);
+static void
-	if (!init_done) {
+dlerrorfree(void *data)
-		dlcompat_init_func();
+{
-		init_done = 1;
+SDL_free(data);
-	}
-	pthread_mutex_unlock(&l);
-}
-static void dlcompat_init_func(void)
-{
-_dyld_func_lookup("__dyld_NSAddImage", (void **)&dyld_NSAddImage);
-	_dyld_func_lookup("__dyld_NSIsSymbolNameDefinedInImage",
-			  (void **)&dyld_NSIsSymbolNameDefinedInImage);
-	_dyld_func_lookup("__dyld_NSLookupSymbolInImage", (void **)&dyld_NSLookupSymbolInImage);
-	if (pthread_mutex_init(&dlcompat_mutex, NULL))
-	    exit(1);
-	if (pthread_key_create(&dlerror_key, &dlerrorfree))
-	    exit(1);
-}
-static void resetdlerror()
-{
-	struct dlthread *tss;
-	tss = pthread_getspecific(dlerror_key);
-	tss->errset = 0;
-}
-static void dlerrorfree(void *data)
-{
-	SDL_free(data);
 }
 /* We kind of want a recursive lock here, but meet a little trouble
 * because they are not available pre OS X 10.2, so we fake it
 * using thread specific storage to keep a lock count
 */
-static inline void dolock(void)
+static inline void
-{
+dolock(void)
-	int err = 0;
+{
-	struct dlthread *tss;
+int err = 0;
-	dlcompat_init_check();
+struct dlthread *tss;
-	tss = pthread_getspecific(dlerror_key);
+dlcompat_init_check();
-	if (!tss)
+tss = pthread_getspecific(dlerror_key);
-	{
+if (!tss) {
-		tss = SDL_malloc(sizeof(struct dlthread));
+tss = SDL_malloc(sizeof(struct dlthread));
-		tss->lockcnt = 0;
+tss->lockcnt = 0;
-		tss->errset = 0;
+tss->errset = 0;
-		if (pthread_setspecific(dlerror_key, tss))
+if (pthread_setspecific(dlerror_key, tss)) {
-		{
+fprintf(stderr, "dlcompat: pthread_setspecific failed\n");
-			fprintf(stderr,"dlcompat: pthread_setspecific failed\n");
+exit(1);
-			exit(1);
+}
-		}
+}
-	}
+if (!tss->lockcnt)
-	if (!tss->lockcnt)
+err = pthread_mutex_lock(&dlcompat_mutex);
-		err = pthread_mutex_lock(&dlcompat_mutex);
+tss->lockcnt = tss->lockcnt + 1;
-	tss->lockcnt = tss->lockcnt +1;
+if (err)
-	if (err)
+exit(err);
-		exit(err);
+}
-}
+static inline void
-static inline void dounlock(void)
+dounlock(void)
 {
-	int err = 0;
+int err = 0;
-	struct dlthread *tss;
+struct dlthread *tss;
-	tss = pthread_getspecific(dlerror_key);
+tss = pthread_getspecific(dlerror_key);
-	tss->lockcnt = tss->lockcnt -1;
+tss->lockcnt = tss->lockcnt - 1;
-	if (!tss->lockcnt)
+if (!tss->lockcnt)
-		err = pthread_mutex_unlock(&dlcompat_mutex);
+err = pthread_mutex_unlock(&dlcompat_mutex);
-	if (err)
+if (err)
-		exit(err);
+exit(err);
 }
-static void *SDL_OSX_dlopen(const char *path, int mode)
+static void *
-{
+SDL_OSX_dlopen(const char *path, int mode)
-	const struct stat *sbuf;
+{
-	struct dlstatus *dls;
+const struct stat *sbuf;
-	const char *fullPath;
+struct dlstatus *dls;
+const char *fullPath;
-	dolock();
-	resetdlerror();
+dolock();
-	if (!path)
+resetdlerror();
-	{
+if (!path) {
-		dls = &mainStatus;
+dls = &mainStatus;
-		goto dlopenok;
+goto dlopenok;
-	}
+}
-	if (!(sbuf = findFile(path, &fullPath)))
+if (!(sbuf = findFile(path, &fullPath))) {
-	{
+error("file \"%s\" not found", path);
-		error("file \"%s\" not found", path);
+goto dlopenerror;
-		goto dlopenerror;
+}
-	}
+/* Now checks that it hasn't been closed already */
-	/* Now checks that it hasn't been closed already */
+if ((dls = lookupStatus(sbuf)) && (dls->refs > 0)) {
-	if ((dls = lookupStatus(sbuf)) && (dls->refs > 0))
+/* debug("status found"); */
-	{
+dls = reference(dls, mode);
-		/* debug("status found"); */
+goto dlopenok;
-		dls = reference(dls, mode);
+}
-		goto dlopenok;
-	}
 #ifdef 	RTLD_NOLOAD
-	if (isFlagSet(mode, RTLD_NOLOAD))
+if (isFlagSet(mode, RTLD_NOLOAD)) {
-	{
+error("no existing handle and RTLD_NOLOAD specified");
-		error("no existing handle and RTLD_NOLOAD specified");
+goto dlopenerror;
-		goto dlopenerror;
+}
-	}
+#endif
-#endif
+if (isFlagSet(mode, RTLD_LAZY) && isFlagSet(mode, RTLD_NOW)) {
-	if (isFlagSet(mode, RTLD_LAZY) && isFlagSet(mode, RTLD_NOW))
+error("how can I load something both RTLD_LAZY and RTLD_NOW?");
-	{
+goto dlopenerror;
-		error("how can I load something both RTLD_LAZY and RTLD_NOW?");
+}
-		goto dlopenerror;
+dls = loadModule(fullPath, sbuf, mode);
-	}
-	dls = loadModule(fullPath, sbuf, mode);
 dlopenok:
-	dounlock();
+dounlock();
-	return (void *)dls;
+return (void *) dls;
 dlopenerror:
-	dounlock();
+dounlock();
-	return NULL;
+return NULL;
 }
 #if !FINK_BUILD
-static void *SDL_OSX_dlsym(void * dl_restrict handle, const char * dl_restrict symbol)
+static void *
-{
+SDL_OSX_dlsym(void *dl_restrict handle, const char *dl_restrict symbol)
-	int sym_len = SDL_strlen(symbol);
+{
-	void *value = NULL;
+int sym_len = SDL_strlen(symbol);
-	char *malloc_sym = NULL;
+void *value = NULL;
-	dolock();
+char *malloc_sym = NULL;
-	malloc_sym = SDL_malloc(sym_len + 2);
+dolock();
-	if (malloc_sym)
+malloc_sym = SDL_malloc(sym_len + 2);
-	{
+if (malloc_sym) {
-		SDL_snprintf(malloc_sym, sym_len+2, "_%s", symbol);
+SDL_snprintf(malloc_sym, sym_len + 2, "_%s", symbol);
-		value = dlsymIntern(handle, malloc_sym, 1);
+value = dlsymIntern(handle, malloc_sym, 1);
-		SDL_free(malloc_sym);
+SDL_free(malloc_sym);
-	}
+} else {
-	else
+error("Unable to allocate memory");
-	{
+goto dlsymerror;
-		error("Unable to allocate memory");
+}
-		goto dlsymerror;
+dounlock();
-	}
+return value;
-	dounlock();
-	return value;
 dlsymerror:
-	dounlock();
+dounlock();
-	return NULL;
+return NULL;
 }
 #endif
 #if FINK_BUILD
-static void *dlsym_prepend_underscore(void *handle, const char *symbol)
+static void *
-{
+dlsym_prepend_underscore(void *handle, const char *symbol)
-	void *answer;
+{
-	dolock();
+void *answer;
-	answer = dlsym_prepend_underscore_intern(handle, symbol);
+dolock();
-	dounlock();
+answer = dlsym_prepend_underscore_intern(handle, symbol);
-	return answer;
+dounlock();
-}
+return answer;
+}
-static void *dlsym_prepend_underscore_intern(void *handle, const char *symbol)
+static void *
+dlsym_prepend_underscore_intern(void *handle, const char *symbol)
 {
 /*
 *	A quick and easy way for porting packages which call dlsym(handle,"sym")
 *	If the porter adds -Ddlsym=dlsym_prepend_underscore to the CFLAGS then
 *	this function will be called, and will add the required underscore.
 *
 *	Note that I haven't figured out yet which should be "standard", prepend
 *	the underscore always, or not at all. These global functions need to go away
 *	for opendarwin.
 */
-	int sym_len = SDL_strlen(symbol);
+int sym_len = SDL_strlen(symbol);
-	void *value = NULL;
+void *value = NULL;
-	char *malloc_sym = NULL;
+char *malloc_sym = NULL;
-	malloc_sym = SDL_malloc(sym_len + 2);
+malloc_sym = SDL_malloc(sym_len + 2);
-	if (malloc_sym)
+if (malloc_sym) {
-	{
+SDL_snprintf(malloc_sym, sym_len + 2, "_%s", symbol);
-		SDL_snprintf(malloc_sym, sym_len+2, "_%s", symbol);
+value = dlsymIntern(handle, malloc_sym, 1);
-		value = dlsymIntern(handle, malloc_sym, 1);
+SDL_free(malloc_sym);
-		SDL_free(malloc_sym);
+} else {
-	}
+error("Unable to allocate memory");
-	else
+}
-	{
+return value;
-		error("Unable to allocate memory");
+}
-	}
-	return value;
+static void *
-}
+dlsym_auto_underscore(void *handle, const char *symbol)
+{
-static void *dlsym_auto_underscore(void *handle, const char *symbol)
+void *answer;
-{
+dolock();
-	void *answer;
+answer = dlsym_auto_underscore_intern(handle, symbol);
-	dolock();
+dounlock();
-	answer = dlsym_auto_underscore_intern(handle, symbol);
+return answer;
-	dounlock();
-	return answer;
+}
+static void *
-}
+dlsym_auto_underscore_intern(void *handle, const char *symbol)
-static void *dlsym_auto_underscore_intern(void *handle, const char *symbol)
+{
-{
+struct dlstatus *dls = handle;
-	struct dlstatus *dls = handle;
+void *addr = 0;
-	void *addr = 0;
+addr = dlsymIntern(dls, symbol, 0);
-	addr = dlsymIntern(dls, symbol, 0);
+if (!addr)
-	if (!addr)
+addr = dlsym_prepend_underscore_intern(handle, symbol);
-		addr = dlsym_prepend_underscore_intern(handle, symbol);
+return addr;
-	return addr;
+}
-}
+static void *
-static void *SDL_OSX_dlsym(void * dl_restrict handle, const char * dl_restrict symbol)
+SDL_OSX_dlsym(void *dl_restrict handle, const char *dl_restrict symbol)
 {
-	struct dlstatus *dls = handle;
+struct dlstatus *dls = handle;
-	void *addr = 0;
+void *addr = 0;
-	dolock();
+dolock();
-	addr = dlsymIntern(dls, symbol, 1);
+addr = dlsymIntern(dls, symbol, 1);
-	dounlock();
+dounlock();
-	return addr;
+return addr;
 }
 #endif
-static int SDL_OSX_dlclose(void *handle)
+static int
-{
+SDL_OSX_dlclose(void *handle)
-	struct dlstatus *dls = handle;
+{
-	dolock();
+struct dlstatus *dls = handle;
-	resetdlerror();
+dolock();
-	if (!isValidStatus(dls))
+resetdlerror();
-	{
+if (!isValidStatus(dls)) {
-		goto dlcloseerror;
+goto dlcloseerror;
-	}
+}
-	if (dls->module == MAGIC_DYLIB_MOD)
+if (dls->module == MAGIC_DYLIB_MOD) {
-	{
+const char *name;
-		const char *name;
+if (!dls->lib) {
-		if (!dls->lib)
+name = "global context";
-		{
+} else {
-			name = "global context";
+name = get_lib_name(dls->lib);
-		}
+}
-		else
+warning("trying to close a .dylib!");
-		{
+error("Not closing \"%s\" - dynamic libraries cannot be closed",
-			name = get_lib_name(dls->lib);
+name);
-		}
+goto dlcloseerror;
-		warning("trying to close a .dylib!");
+}
-		error("Not closing \"%s\" - dynamic libraries cannot be closed", name);
+if (!dls->module) {
-		goto dlcloseerror;
+error("module already closed");
-	}
+goto dlcloseerror;
-	if (!dls->module)
+}
-	{
-		error("module already closed");
+if (dls->refs == 1) {
-		goto dlcloseerror;
+unsigned long options = 0;
-	}
+void (*fini) (void);
+if ((fini = dlsymIntern(dls, "__fini", 0))) {
-	if (dls->refs == 1)
+debug("calling _fini()");
-	{
+fini();
-		unsigned long options = 0;
+}
-		void (*fini) (void);
+options |= NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES;
-		if ((fini = dlsymIntern(dls, "__fini", 0)))
-		{
-			debug("calling _fini()");
-			fini();
-		}
-		options |= NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES;
 #ifdef RTLD_NODELETE
-		if (isFlagSet(dls->mode, RTLD_NODELETE))
+if (isFlagSet(dls->mode, RTLD_NODELETE))
-			options |= NSUNLINKMODULE_OPTION_KEEP_MEMORY_MAPPED;
+options |= NSUNLINKMODULE_OPTION_KEEP_MEMORY_MAPPED;
 #endif
-		if (!NSUnLinkModule(dls->module, options))
+if (!NSUnLinkModule(dls->module, options)) {
-		{
+error("unable to unlink module");
-			error("unable to unlink module");
+goto dlcloseerror;
-			goto dlcloseerror;
+}
-		}
+dls->refs--;
-		dls->refs--;
+dls->module = 0;
-		dls->module = 0;
+/* Note: the dlstatus struct dls is neither removed from the list
-		/* Note: the dlstatus struct dls is neither removed from the list
+* nor is the memory it occupies freed. This shouldn't pose a
-		 * nor is the memory it occupies freed. This shouldn't pose a
+* problem in mostly all cases, though.
-		 * problem in mostly all cases, though.
+*/
-		 */
+}
-	}
+dounlock();
-	dounlock();
+return 0;
-	return 0;
 dlcloseerror:
-	dounlock();
+dounlock();
-	return 1;
+return 1;
 }
-static const char *SDL_OSX_dlerror(void)
+static const char *
-{
+SDL_OSX_dlerror(void)
-	struct dlthread  *tss;
+{
-	const char * err_str = NULL;
+struct dlthread *tss;
-	dlcompat_init_check();
+const char *err_str = NULL;
-	tss = pthread_getspecific(dlerror_key);
+dlcompat_init_check();
-	if (tss != NULL && tss->errset != 0) {
+tss = pthread_getspecific(dlerror_key);
-		tss->errset = 0;
+if (tss != NULL && tss->errset != 0) {
-		err_str = tss->errstr;
+tss->errset = 0;
-	}
+err_str = tss->errstr;
-	return (err_str);
+}
+return (err_str);
 }
 /* Given an address, return the mach_header for the image containing it
 * or zero if the given address is not contained in any loaded images.
 */
-static const struct mach_header *image_for_address(const void *address)
+static const struct mach_header *
-{
+image_for_address(const void *address)
-	unsigned long i;
+{
-	unsigned long j;
+unsigned long i;
-	unsigned long count = _dyld_image_count();
+unsigned long j;
-	const struct mach_header *mh = 0;
+unsigned long count = _dyld_image_count();
-	struct load_command *lc = 0;
+const struct mach_header *mh = 0;
-	unsigned long addr = 0;
+struct load_command *lc = 0;
-	for (i = 0; i < count; i++)
+unsigned long addr = 0;
-	{
+for (i = 0; i < count; i++) {
-		addr = (unsigned long)address - _dyld_get_image_vmaddr_slide(i);
+addr = (unsigned long) address - _dyld_get_image_vmaddr_slide(i);
-		mh = _dyld_get_image_header(i);
+mh = _dyld_get_image_header(i);
-		if (mh)
+if (mh) {
-		{
+lc = (struct load_command *) ((char *) mh +
-			lc = (struct load_command *)((char *)mh + sizeof(struct mach_header));
+sizeof(struct mach_header));
-			for (j = 0; j < mh->ncmds; j++, lc = (struct load_command *)((char *)lc + lc->cmdsize))
+for (j = 0; j < mh->ncmds;
-			{
+j++, lc =
-				if (LC_SEGMENT == lc->cmd &&
+(struct load_command *) ((char *) lc + lc->cmdsize)) {
-					addr >= ((struct segment_command *)lc)->vmaddr &&
+if (LC_SEGMENT == lc->cmd &&
-					addr <
+addr >= ((struct segment_command *) lc)->vmaddr &&
-					((struct segment_command *)lc)->vmaddr + ((struct segment_command *)lc)->vmsize)
+addr <
-				{
+((struct segment_command *) lc)->vmaddr +
-					goto image_found;
+((struct segment_command *) lc)->vmsize) {
-				}
+goto image_found;
-			}
+}
-		}
+}
-		mh = 0;
+}
-	}
+mh = 0;
+}
 image_found:
-	return mh;
+return mh;
 }
-#if 0 /* unused */
+#if 0                           /* unused */
-static int SDL_OSX_dladdr(const void * dl_restrict p, SDL_OSX_Dl_info * dl_restrict info)
+static int
+SDL_OSX_dladdr(const void *dl_restrict p, SDL_OSX_Dl_info * dl_restrict info)
 {
 /*
 	FIXME: USe the routine image_for_address.
 */
-	unsigned long i;
+unsigned long i;
-	unsigned long j;
+unsigned long j;
-	unsigned long count = _dyld_image_count();
+unsigned long count = _dyld_image_count();
-	struct mach_header *mh = 0;
+struct mach_header *mh = 0;
-	struct load_command *lc = 0;
+struct load_command *lc = 0;
-	unsigned long addr = NULL;
+unsigned long addr = NULL;
-	unsigned long table_off = (unsigned long)0;
+unsigned long table_off = (unsigned long) 0;
-	int found = 0;
+int found = 0;
-	if (!info)
+if (!info)
-		return 0;
+return 0;
-	dolock();
+dolock();
-	resetdlerror();
+resetdlerror();
-	info->dli_fname = 0;
+info->dli_fname = 0;
-	info->dli_fbase = 0;
+info->dli_fbase = 0;
-	info->dli_sname = 0;
+info->dli_sname = 0;
-	info->dli_saddr = 0;
+info->dli_saddr = 0;
 /* Some of this was swiped from code posted by Douglas Davidson <ddavidso AT apple DOT com>
 * to darwin-development AT lists DOT apple DOT com and slightly modified
 */
-	for (i = 0; i < count; i++)
+for (i = 0; i < count; i++) {
-	{
+addr = (unsigned long) p - _dyld_get_image_vmaddr_slide(i);
-		addr = (unsigned long)p - _dyld_get_image_vmaddr_slide(i);
+mh = _dyld_get_image_header(i);
-		mh = _dyld_get_image_header(i);
+if (mh) {
-		if (mh)
+lc = (struct load_command *) ((char *) mh +
-		{
+sizeof(struct mach_header));
-			lc = (struct load_command *)((char *)mh + sizeof(struct mach_header));
+for (j = 0; j < mh->ncmds;
-			for (j = 0; j < mh->ncmds; j++, lc = (struct load_command *)((char *)lc + lc->cmdsize))
+j++, lc =
-			{
+(struct load_command *) ((char *) lc + lc->cmdsize)) {
-				if (LC_SEGMENT == lc->cmd &&
+if (LC_SEGMENT == lc->cmd &&
-					addr >= ((struct segment_command *)lc)->vmaddr &&
+addr >= ((struct segment_command *) lc)->vmaddr &&
-					addr <
+addr <
-					((struct segment_command *)lc)->vmaddr + ((struct segment_command *)lc)->vmsize)
+((struct segment_command *) lc)->vmaddr +
-				{
+((struct segment_command *) lc)->vmsize) {
-					info->dli_fname = _dyld_get_image_name(i);
+info->dli_fname = _dyld_get_image_name(i);
-					info->dli_fbase = (void *)mh;
+info->dli_fbase = (void *) mh;
-					found = 1;
+found = 1;
-					break;
+break;
-				}
+}
-			}
+}
-			if (found)
+if (found)
-				break;
+break;
-		}
+}
-	}
+}
-	if (!found)
+if (!found) {
-	{
+dounlock();
-		dounlock();
+return 0;
-		return 0;
+}
-	}
+lc = (struct load_command *) ((char *) mh + sizeof(struct mach_header));
-	lc = (struct load_command *)((char *)mh + sizeof(struct mach_header));
+for (j = 0; j < mh->ncmds;
-	for (j = 0; j < mh->ncmds; j++, lc = (struct load_command *)((char *)lc + lc->cmdsize))
+j++, lc = (struct load_command *) ((char *) lc + lc->cmdsize)) {
-	{
+if (LC_SEGMENT == lc->cmd) {
-		if (LC_SEGMENT == lc->cmd)
+if (!SDL_strcmp
-		{
+(((struct segment_command *) lc)->segname, "__LINKEDIT"))
-			if (!SDL_strcmp(((struct segment_command *)lc)->segname, "__LINKEDIT"))
+break;
-				break;
+}
-		}
+}
-	}
+table_off =
-	table_off =
+((unsigned long) ((struct segment_command *) lc)->vmaddr) -
-		((unsigned long)((struct segment_command *)lc)->vmaddr) -
+((unsigned long) ((struct segment_command *) lc)->fileoff) +
-		((unsigned long)((struct segment_command *)lc)->fileoff) + _dyld_get_image_vmaddr_slide(i);
+_dyld_get_image_vmaddr_slide(i);
-	debug("table off %x", table_off);
+debug("table off %x", table_off);
-	lc = (struct load_command *)((char *)mh + sizeof(struct mach_header));
+lc = (struct load_command *) ((char *) mh + sizeof(struct mach_header));
-	for (j = 0; j < mh->ncmds; j++, lc = (struct load_command *)((char *)lc + lc->cmdsize))
+for (j = 0; j < mh->ncmds;
-	{
+j++, lc = (struct load_command *) ((char *) lc + lc->cmdsize)) {
-		if (LC_SYMTAB == lc->cmd)
+if (LC_SYMTAB == lc->cmd) {
-		{
+struct nlist *symtable =
-			struct nlist *symtable = (struct nlist *)(((struct symtab_command *)lc)->symoff + table_off);
+(struct nlist *) (((struct symtab_command *) lc)->symoff +
-			unsigned long numsyms = ((struct symtab_command *)lc)->nsyms;
+table_off);
-			struct nlist *nearest = NULL;
+unsigned long numsyms = ((struct symtab_command *) lc)->nsyms;
-			unsigned long diff = 0xffffffff;
+struct nlist *nearest = NULL;
-			unsigned long strtable = (unsigned long)(((struct symtab_command *)lc)->stroff + table_off);
+unsigned long diff = 0xffffffff;
-			debug("symtable %x", symtable);
+unsigned long strtable =
-			for (i = 0; i < numsyms; i++)
+(unsigned long) (((struct symtab_command *) lc)->stroff +
-			{
+table_off);
-				/* Ignore the following kinds of Symbols */
+debug("symtable %x", symtable);
-				if ((!symtable->n_value)	/* Undefined */
+for (i = 0; i < numsyms; i++) {
-					|| (symtable->n_type >= N_PEXT)	/* Debug symbol */
+/* Ignore the following kinds of Symbols */
-					|| (!(symtable->n_type & N_EXT))	/* Local Symbol */
+if ((!symtable->n_value)        /* Undefined */
-					)
+||(symtable->n_type >= N_PEXT)      /* Debug symbol */
-				{
+||(!(symtable->n_type & N_EXT))     /* Local Symbol */
-					symtable++;
+) {
-					continue;
+symtable++;
-				}
+continue;
-				if ((addr >= symtable->n_value) && (diff >= (symtable->n_value - addr)))
+}
-				{
+if ((addr >= symtable->n_value)
-					diff = (unsigned long)symtable->n_value - addr;
+&& (diff >= (symtable->n_value - addr))) {
-					nearest = symtable;
+diff = (unsigned long) symtable->n_value - addr;
-				}
+nearest = symtable;
-				symtable++;
+}
-			}
+symtable++;
-			if (nearest)
+}
-			{
+if (nearest) {
-				info->dli_saddr = nearest->n_value + ((void *)p - addr);
+info->dli_saddr = nearest->n_value + ((void *) p - addr);
-				info->dli_sname = (char *)(strtable + nearest->n_un.n_strx);
+info->dli_sname = (char *) (strtable + nearest->n_un.n_strx);
-			}
+}
-		}
+}
-	}
+}
-	dounlock();
+dounlock();
-	return 1;
+return 1;
 }
 #endif
 /*
 * Implement the dlfunc() interface, which behaves exactly the same as
 * about undefined behavior, and is intended as prior art for future
 * POSIX standardization.  This function requires that all pointer types
 * have the same representation, which is true on all platforms FreeBSD
 * runs on, but is not guaranteed by the C standard.
 */
 #if 0
-static dlfunc_t SDL_OSX_dlfunc(void * dl_restrict handle, const char * dl_restrict symbol)
+static dlfunc_t
-{
+SDL_OSX_dlfunc(void *dl_restrict handle, const char *dl_restrict symbol)
-	union
+{
-	{
+union
-		void *d;
+{
-		dlfunc_t f;
+void *d;
-	} rv;
+dlfunc_t f;
-	int sym_len = SDL_strlen(symbol);
+} rv;
-	char *malloc_sym = NULL;
+int sym_len = SDL_strlen(symbol);
-	dolock();
+char *malloc_sym = NULL;
-	malloc_sym = SDL_malloc(sym_len + 2);
+dolock();
-	if (malloc_sym)
+malloc_sym = SDL_malloc(sym_len + 2);
-	{
+if (malloc_sym) {
-		SDL_snprintf(malloc_sym, sym_len+2, "_%s", symbol);
+SDL_snprintf(malloc_sym, sym_len + 2, "_%s", symbol);
-		rv.d = dlsymIntern(handle, malloc_sym, 1);
+rv.d = dlsymIntern(handle, malloc_sym, 1);
-		SDL_free(malloc_sym);
+SDL_free(malloc_sym);
-	}
+} else {
-	else
+error("Unable to allocate memory");
-	{
+goto dlfuncerror;
-		error("Unable to allocate memory");
+}
-		goto dlfuncerror;
+dounlock();
-	}
+return rv.f;
-	dounlock();
-	return rv.f;
 dlfuncerror:
-	dounlock();
+dounlock();
-	return NULL;
+return NULL;
 }
 #endif
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /* System dependent library loading routines                           */
 #include "SDL_loadso.h"
-void *SDL_LoadObject(const char *sofile)
+void *
-{
+SDL_LoadObject(const char *sofile)
-	void *handle = SDL_OSX_dlopen(sofile, RTLD_NOW);
+{
-	const char *loaderror = SDL_OSX_dlerror();
+void *handle = SDL_OSX_dlopen(sofile, RTLD_NOW);
-	if ( handle == NULL ) {
+const char *loaderror = SDL_OSX_dlerror();
-		SDL_SetError("Failed loading %s: %s", sofile, loaderror);
+if (handle == NULL) {
-	}
+SDL_SetError("Failed loading %s: %s", sofile, loaderror);
-	return(handle);
+}
-}
+return (handle);
+}
-void *SDL_LoadFunction(void *handle, const char *name)
-{
+void *
-	void *symbol = SDL_OSX_dlsym(handle, name);
+SDL_LoadFunction(void *handle, const char *name)
-	if ( symbol == NULL ) {
+{
-		SDL_SetError("Failed loading %s: %s", name, SDL_OSX_dlerror());
+void *symbol = SDL_OSX_dlsym(handle, name);
-	}
+if (symbol == NULL) {
-	return(symbol);
+SDL_SetError("Failed loading %s: %s", name, SDL_OSX_dlerror());
 }
+return (symbol);
-void SDL_UnloadObject(void *handle)
+}
-{
-	if ( handle != NULL ) {
+void
-		SDL_OSX_dlclose(handle);
+SDL_UnloadObject(void *handle)
-	}
+{
+if (handle != NULL) {
+SDL_OSX_dlclose(handle);
+}
 }
 #endif /* SDL_LOADSO_DLCOMPAT */
+/* vi: set ts=4 sw=4 expandtab: */

Mercurial > sdl-ios-xcode

comparison src/loadso/macosx/SDL_dlcompat.c @ 1895:c121d94672cb