Index: src/objc_sync.m
==================================================================
--- src/objc_sync.m
+++ src/objc_sync.m
@@ -106,11 +106,11 @@
 
 #define thread_is_current(t) (t == GetCurrentThreadId())
 #define thread_current() GetCurrentThreadId()
 #endif
 
-#define ERROR(f)							\
+#define SYNC_ERR(f)							\
 	{								\
 		fprintf(stderr, "WARNING: %s failed in line %d!\n"	\
 		    "WARNING: This might result in a race "		\
 		    "condition!\n", f, __LINE__);			\
 		return 1;						\
@@ -129,11 +129,11 @@
 
 	if (obj == nil)
 		return 0;
 
 	if (!mutex_lock(&mutex))
-		ERROR("mutex_lock(&mutex)");
+		SYNC_ERR("mutex_lock(&mutex)");
 
 	for (i = num_locks - 1; i >= 0; i--) {
 		if (locks[i].obj == obj) {
 			if (thread_is_current(locks[i].thread))
 				locks[i].recursion++;
@@ -141,45 +141,45 @@
 				/* Make sure objc_sync_exit doesn't free it */
 				locks[i].count++;
 
 				/* Unlock so objc_sync_exit can return */
 				if (!mutex_unlock(&mutex))
-					ERROR("mutex_unlock(&mutex)");
+					SYNC_ERR("mutex_unlock(&mutex)");
 
 				if (!mutex_lock(&locks[i].mutex)) {
 					mutex_unlock(&mutex);
-					ERROR("mutex_lock(&locks[i].mutex");
+					SYNC_ERR("mutex_lock(&locks[i].mutex");
 				}
 
 				if (!mutex_lock(&mutex))
-					ERROR("mutex_lock(&mutex)");
+					SYNC_ERR("mutex_lock(&mutex)");
 
 				assert(locks[i].recursion == 0);
 
 				/* Update lock's active thread */
 				locks[i].thread = thread_current();
 			}
 
 			if (!mutex_unlock(&mutex))
-				ERROR("mutex_unlock(&mutex)");
+				SYNC_ERR("mutex_unlock(&mutex)");
 
 			return 0;
 		}
 	}
 
 	if (locks == NULL) {
 		if ((locks = malloc(sizeof(struct locks_s))) == NULL) {
 			mutex_unlock(&mutex);
-			ERROR("malloc(...)");
+			SYNC_ERR("malloc(...)");
 		}
 	} else {
 		struct locks_s *new_locks;
 
 		if ((new_locks = realloc(locks, (num_locks + 1) *
 		    sizeof(struct locks_s))) == NULL) {
 			mutex_unlock(&mutex);
-			ERROR("realloc(...)");
+			SYNC_ERR("realloc(...)");
 		}
 
 		locks = new_locks;
 	}
 
@@ -188,22 +188,22 @@
 	locks[num_locks].recursion = 0;
 	locks[num_locks].thread = thread_current();
 
 	if (!mutex_new(&locks[num_locks].mutex)) {
 		mutex_unlock(&mutex);
-		ERROR("mutex_new(&locks[num_locks].mutex");
+		SYNC_ERR("mutex_new(&locks[num_locks].mutex");
 	}
 
 	if (!mutex_lock(&locks[num_locks].mutex)) {
 		mutex_unlock(&mutex);
-		ERROR("mutex_lock(&locks[num_locks].mutex");
+		SYNC_ERR("mutex_lock(&locks[num_locks].mutex");
 	}
 
 	num_locks++;
 
 	if (!mutex_unlock(&mutex))
-		ERROR("mutex_unlock(&mutex)");
+		SYNC_ERR("mutex_unlock(&mutex)");
 
 	return 0;
 }
 
 int
@@ -213,37 +213,37 @@
 
 	if (obj == nil)
 		return 0;
 
 	if (!mutex_lock(&mutex))
-		ERROR("mutex_lock(&mutex)");
+		SYNC_ERR("mutex_lock(&mutex)");
 
 	for (i = num_locks - 1; i >= 0; i--) {
 		if (locks[i].obj == obj) {
 			if (locks[i].recursion > 0 &&
 			    thread_is_current(locks[i].thread)) {
 				locks[i].recursion--;
 
 				if (!mutex_unlock(&mutex))
-					ERROR("mutex_unlock(&mutex)");
+					SYNC_ERR("mutex_unlock(&mutex)");
 
 				return 0;
 			}
 
 			if (!mutex_unlock(&locks[i].mutex)) {
 				mutex_unlock(&mutex);
-				ERROR("mutex_unlock(&locks[i].mutex)");
+				SYNC_ERR("mutex_unlock(&locks[i].mutex)");
 			}
 
 			locks[i].count--;
 
 			if (locks[i].count == 0) {
 				struct locks_s *new_locks = NULL;
 
 				if (!mutex_free(&locks[i].mutex)) {
 					mutex_unlock(&mutex);
-					ERROR("mutex_free(&locks[i].mutex");
+					SYNC_ERR("mutex_free(&locks[i].mutex");
 				}
 
 				num_locks--;
 				locks[i] = locks[num_locks];
 
@@ -252,21 +252,21 @@
 					new_locks = NULL;
 				} else if ((new_locks = realloc(locks,
 				    num_locks * sizeof(struct locks_s))) ==
 				    NULL) {
 					mutex_unlock(&mutex);
-					ERROR("realloc(...)");
+					SYNC_ERR("realloc(...)");
 				}
 
 				locks = new_locks;
 			}
 
 			if (!mutex_unlock(&mutex))
-				ERROR("mutex_unlock(&mutex)");
+				SYNC_ERR("mutex_unlock(&mutex)");
 
 			return 0;
 		}
 	}
 
 	mutex_unlock(&mutex);
-	ERROR("objc_sync_exit()");
+	SYNC_ERR("objc_sync_exit()");
 }