@@ -34,38 +34,38 @@
 static void
 registerClass(Class class)
 {
 	if (classes == NULL)
 		classes = objc_hashtable_new(
-		    objc_hash_string, objc_equal_string, 2);
+		    objc_string_hash, objc_string_equal, 2);
 
 	objc_hashtable_set(classes, class->name, class);
 
 	if (emptyDTable == NULL)
 		emptyDTable = objc_dtable_new();
 
-	class->DTable = emptyDTable;
-	class->isa->DTable = emptyDTable;
+	class->dTable = emptyDTable;
+	class->isa->dTable = emptyDTable;
 
 	if (strcmp(class->name, "Protocol") != 0)
 		classesCount++;
 }
 
 bool
 class_registerAlias_np(Class class, const char *name)
 {
-	objc_global_mutex_lock();
+	objc_globalMutex_lock();
 
 	if (classes == NULL) {
-		objc_global_mutex_unlock();
+		objc_globalMutex_unlock();
 
 		return NO;
 	}
 
 	objc_hashtable_set(classes, name, (Class)((uintptr_t)class | 1));
 
-	objc_global_mutex_unlock();
+	objc_globalMutex_unlock();
 
 	return YES;
 }
 
 static void
@@ -74,15 +74,15 @@
 	struct objc_method_list *iter;
 	unsigned int i;
 
 	for (iter = class->methodList; iter != NULL; iter = iter->next)
 		for (i = 0; i < iter->count; i++)
-			objc_register_selector(&iter->methods[i].selector);
+			objc_registerSelector(&iter->methods[i].selector);
 }
 
 Class
-objc_classname_to_class(const char *name, bool cache)
+objc_classnameToClass(const char *name, bool cache)
 {
 	Class class;
 
 	if (classes == NULL)
 		return Nil;
@@ -113,21 +113,21 @@
 
 		if (class != Nil)
 			return class;
 	}
 
-	objc_global_mutex_lock();
+	objc_globalMutex_lock();
 
 	class = (Class)((uintptr_t)objc_hashtable_get(classes, name) & ~1);
 
 	if (cache && fastPath == NULL && --lookupsUntilFastPath == 0)
 		fastPath = objc_sparsearray_new(sizeof(uintptr_t));
 
 	if (cache && fastPath != NULL)
 		objc_sparsearray_set(fastPath, (uintptr_t)name, class);
 
-	objc_global_mutex_unlock();
+	objc_globalMutex_unlock();
 
 	return class;
 }
 
 static void
@@ -178,31 +178,31 @@
 
 	class->info |= OBJC_CLASS_INFO_LOADED;
 }
 
 void
-objc_update_dtable(Class class)
+objc_updateDTable(Class class)
 {
 	struct objc_category **categories;
 
 	if (!(class->info & OBJC_CLASS_INFO_DTABLE))
 		return;
 
-	if (class->DTable == emptyDTable)
-		class->DTable = objc_dtable_new();
+	if (class->dTable == emptyDTable)
+		class->dTable = objc_dtable_new();
 
 	if (class->superclass != Nil)
-		objc_dtable_copy(class->DTable, class->superclass->DTable);
+		objc_dtable_copy(class->dTable, class->superclass->dTable);
 
 	for (struct objc_method_list *methodList = class->methodList;
 	    methodList != NULL; methodList = methodList->next)
 		for (unsigned int i = 0; i < methodList->count; i++)
-			objc_dtable_set(class->DTable,
+			objc_dtable_set(class->dTable,
 			    (uint32_t)methodList->methods[i].selector.UID,
 			    methodList->methods[i].implementation);
 
-	if ((categories = objc_categories_for_class(class)) != NULL) {
+	if ((categories = objc_categoriesForClass(class)) != NULL) {
 		for (unsigned int i = 0; categories[i] != NULL; i++) {
 			struct objc_method_list *methodList =
 			    (class->info & OBJC_CLASS_INFO_CLASS
 			    ? categories[i]->instanceMethods
 			    : categories[i]->classMethods);
@@ -209,21 +209,21 @@
 
 			for (; methodList != NULL;
 			    methodList = methodList->next)
 				for (unsigned int j = 0;
 				    j < methodList->count; j++)
-					objc_dtable_set(class->DTable,
+					objc_dtable_set(class->dTable,
 					    (uint32_t)methodList->methods[j]
 					    .selector.UID,
 					    methodList->methods[j]
 					    .implementation);
 		}
 	}
 
 	if (class->subclassList != NULL)
 		for (Class *iter = class->subclassList; *iter != NULL; iter++)
-			objc_update_dtable(*iter);
+			objc_updateDTable(*iter);
 }
 
 static void
 addSubclass(Class class)
 {
@@ -280,26 +280,26 @@
 		for (unsigned int i = 0; i < class->ivars->count; i++)
 			*class->ivarOffsets[i] = class->ivars->ivars[i].offset;
 }
 
 static void
-setupClass(Class class)
+setUpClass(Class class)
 {
 	const char *superclassName;
 
 	if (class->info & OBJC_CLASS_INFO_SETUP)
 		return;
 
 	superclassName = (const char *)class->superclass;
 	if (superclassName != NULL) {
-		Class super = objc_classname_to_class(superclassName, false);
+		Class super = objc_classnameToClass(superclassName, false);
 		Class rootClass;
 
 		if (super == Nil)
 			return;
 
-		setupClass(super);
+		setUpClass(super);
 
 		if (!(super->info & OBJC_CLASS_INFO_SETUP))
 			return;
 
 		/*
@@ -349,12 +349,12 @@
 		return;
 
 	class->info |= OBJC_CLASS_INFO_DTABLE;
 	class->isa->info |= OBJC_CLASS_INFO_DTABLE;
 
-	objc_update_dtable(class);
-	objc_update_dtable(class->isa);
+	objc_updateDTable(class);
+	objc_updateDTable(class->isa);
 
 	/*
 	 * Set it first to prevent calling it recursively due to message sends
 	 * in the initialize method
 	 */
@@ -373,44 +373,44 @@
 		initialize(class, initializeSel);
 	}
 }
 
 void
-objc_initialize_class(Class class)
+objc_initializeClass(Class class)
 {
 	if (class->info & OBJC_CLASS_INFO_INITIALIZED)
 		return;
 
-	objc_global_mutex_lock();
+	objc_globalMutex_lock();
 
 	/*
 	 * It's possible that two threads try to initialize a class at the same
 	 * time. Make sure that the thread which held the lock did not already
 	 * initialize it.
 	 */
 	if (class->info & OBJC_CLASS_INFO_INITIALIZED) {
-		objc_global_mutex_unlock();
+		objc_globalMutex_unlock();
 		return;
 	}
 
-	setupClass(class);
+	setUpClass(class);
 
 	if (!(class->info & OBJC_CLASS_INFO_SETUP)) {
-		objc_global_mutex_unlock();
+		objc_globalMutex_unlock();
 		return;
 	}
 
 	initializeClass(class);
 
-	objc_global_mutex_unlock();
+	objc_globalMutex_unlock();
 }
 
 static void
 processLoadQueue()
 {
 	for (size_t i = 0; i < loadQueueCount; i++) {
-		setupClass(loadQueue[i]);
+		setUpClass(loadQueue[i]);
 
 		if (loadQueue[i]->info & OBJC_CLASS_INFO_SETUP) {
 			callLoad(loadQueue[i]);
 
 			loadQueueCount--;
@@ -431,11 +431,11 @@
 		}
 	}
 }
 
 void
-objc_register_all_classes(struct objc_symtab *symtab)
+objc_registerAllClasses(struct objc_symtab *symtab)
 {
 	for (uint16_t i = 0; i < symtab->classDefsCount; i++) {
 		Class class = (Class)symtab->defs[i];
 
 		registerClass(class);
@@ -445,11 +445,11 @@
 
 	for (uint16_t i = 0; i < symtab->classDefsCount; i++) {
 		Class class = (Class)symtab->defs[i];
 
 		if (hasLoad(class)) {
-			setupClass(class);
+			setUpClass(class);
 
 			if (class->info & OBJC_CLASS_INFO_SETUP)
 				callLoad(class);
 			else {
 				loadQueue = realloc(loadQueue,
@@ -503,11 +503,11 @@
 }
 
 void
 objc_registerClassPair(Class class)
 {
-	objc_global_mutex_lock();
+	objc_globalMutex_lock();
 
 	registerClass(class);
 
 	if (class->superclass != Nil) {
 		addSubclass(class);
@@ -522,29 +522,29 @@
 	else
 		class->info |= OBJC_CLASS_INFO_LOADED;
 
 	processLoadQueue();
 
-	objc_global_mutex_unlock();
+	objc_globalMutex_unlock();
 }
 
 Class
 objc_lookUpClass(const char *name)
 {
 	Class class;
 
-	if ((class = objc_classname_to_class(name, true)) == NULL)
+	if ((class = objc_classnameToClass(name, true)) == NULL)
 		return Nil;
 
 	if (class->info & OBJC_CLASS_INFO_SETUP)
 		return class;
 
-	objc_global_mutex_lock();
+	objc_globalMutex_lock();
 
-	setupClass(class);
+	setUpClass(class);
 
-	objc_global_mutex_unlock();
+	objc_globalMutex_unlock();
 
 	if (!(class->info & OBJC_CLASS_INFO_SETUP))
 		return Nil;
 
 	return class;
@@ -581,11 +581,11 @@
 
 unsigned int
 objc_getClassList(Class *buffer, unsigned int count)
 {
 	unsigned int j;
-	objc_global_mutex_lock();
+	objc_globalMutex_lock();
 
 	if (buffer == NULL)
 		return classesCount;
 
 	if (classesCount < count)
@@ -594,11 +594,11 @@
 	j = 0;
 	for (uint32_t i = 0; i < classes->size; i++) {
 		void *class;
 
 		if (j >= count) {
-			objc_global_mutex_unlock();
+			objc_globalMutex_unlock();
 			return j;
 		}
 
 		if (classes->data[i] == NULL)
 			continue;
@@ -612,11 +612,11 @@
 			continue;
 
 		buffer[j++] = class;
 	}
 
-	objc_global_mutex_unlock();
+	objc_globalMutex_unlock();
 
 	return j;
 }
 
 Class *
@@ -623,11 +623,11 @@
 objc_copyClassList(unsigned int *length)
 {
 	Class *ret;
 	unsigned int count;
 
-	objc_global_mutex_lock();
+	objc_globalMutex_lock();
 
 	if ((ret = malloc((classesCount + 1) * sizeof(Class))) == NULL)
 		OBJC_ERROR("Failed to allocate memory for class list!");
 
 	count = objc_getClassList(ret, classesCount);
@@ -636,11 +636,11 @@
 	ret[count] = Nil;
 
 	if (length != NULL)
 		*length = count;
 
-	objc_global_mutex_unlock();
+	objc_globalMutex_unlock();
 
 	return ret;
 }
 
 bool
@@ -724,11 +724,11 @@
 static struct objc_method *
 getMethod(Class class, SEL selector)
 {
 	struct objc_category **categories;
 
-	if ((categories = objc_categories_for_class(class)) != NULL) {
+	if ((categories = objc_categoriesForClass(class)) != NULL) {
 		for (; *categories != NULL; categories++) {
 			struct objc_method_list *methodList =
 			    (class->info & OBJC_CLASS_INFO_METACLASS
 			    ? (*categories)->classMethods
 			    : (*categories)->instanceMethods);
@@ -758,11 +758,11 @@
 addMethod(Class class, SEL selector, IMP implementation,
     const char *typeEncoding)
 {
 	struct objc_method_list *methodList;
 
-	/* FIXME: We need a way to free this at objc_exit() */
+	/* FIXME: We need a way to free this at objc_deinit() */
 	if ((methodList = malloc(sizeof(*methodList))) == NULL)
 		OBJC_ERROR("Not enough memory to replace method!");
 
 	methodList->next = class->methodList;
 	methodList->count = 1;
@@ -770,11 +770,11 @@
 	methodList->methods[0].selector.typeEncoding = typeEncoding;
 	methodList->methods[0].implementation = implementation;
 
 	class->methodList = methodList;
 
-	objc_update_dtable(class);
+	objc_updateDTable(class);
 }
 
 Method
 class_getInstanceMethod(Class class, SEL selector)
 {
@@ -782,20 +782,20 @@
 	Class superclass;
 
 	if (class == Nil)
 		return NULL;
 
-	objc_global_mutex_lock();
+	objc_globalMutex_lock();
 
 	if ((method = getMethod(class, selector)) != NULL) {
-		objc_global_mutex_unlock();
+		objc_globalMutex_unlock();
 		return method;
 	}
 
 	superclass = class->superclass;
 
-	objc_global_mutex_unlock();
+	objc_globalMutex_unlock();
 
 	if (superclass != Nil)
 		return class_getInstanceMethod(superclass, selector);
 
 	return NULL;
@@ -805,19 +805,19 @@
 class_addMethod(Class class, SEL selector, IMP implementation,
     const char *typeEncoding)
 {
 	bool ret;
 
-	objc_global_mutex_lock();
+	objc_globalMutex_lock();
 
 	if (getMethod(class, selector) == NULL) {
 		addMethod(class, selector, implementation, typeEncoding);
 		ret = true;
 	} else
 		ret = false;
 
-	objc_global_mutex_unlock();
+	objc_globalMutex_unlock();
 
 	return ret;
 }
 
 IMP
@@ -825,22 +825,22 @@
     const char *typeEncoding)
 {
 	struct objc_method *method;
 	IMP oldImplementation;
 
-	objc_global_mutex_lock();
+	objc_globalMutex_lock();
 
 	if ((method = getMethod(class, selector)) != NULL) {
 		oldImplementation = method->implementation;
 		method->implementation = implementation;
-		objc_update_dtable(class);
+		objc_updateDTable(class);
 	} else {
 		oldImplementation = NULL;
 		addMethod(class, selector, implementation, typeEncoding);
 	}
 
-	objc_global_mutex_unlock();
+	objc_globalMutex_unlock();
 
 	return oldImplementation;
 }
 
 Class
@@ -912,31 +912,31 @@
 	if (class->subclassList != NULL) {
 		free(class->subclassList);
 		class->subclassList = NULL;
 	}
 
-	if (class->DTable != NULL && class->DTable != emptyDTable)
-		objc_dtable_free(class->DTable);
+	if (class->dTable != NULL && class->dTable != emptyDTable)
+		objc_dtable_free(class->dTable);
 
-	class->DTable = NULL;
+	class->dTable = NULL;
 
 	if ((class->info & OBJC_CLASS_INFO_SETUP) && class->superclass != Nil)
 		class->superclass = (Class)class->superclass->name;
 
 	class->info &= ~OBJC_CLASS_INFO_SETUP;
 }
 
 void
-objc_unregister_class(Class class)
+objc_unregisterClass(Class class)
 {
 	static SEL unloadSel = NULL;
 
 	if (unloadSel == NULL)
 		unloadSel = sel_registerName("unload");
 
 	while (class->subclassList != NULL && class->subclassList[0] != Nil)
-		objc_unregister_class(class->subclassList[0]);
+		objc_unregisterClass(class->subclassList[0]);
 
 	if (class->info & OBJC_CLASS_INFO_LOADED)
 		callSelector(class, unloadSel);
 
 	objc_hashtable_delete(classes, class->name);
@@ -947,24 +947,24 @@
 	unregisterClass(class);
 	unregisterClass(class->isa);
 }
 
 void
-objc_unregister_all_classes(void)
+objc_unregisterAllClasses(void)
 {
 	if (classes == NULL)
 		return;
 
 	for (uint32_t i = 0; i < classes->size; i++) {
 		if (classes->data[i] != NULL &&
-		    classes->data[i] != &objc_deleted_bucket) {
+		    classes->data[i] != &objc_deletedBucket) {
 			void *class = (Class)classes->data[i]->object;
 
 			if (class == Nil || (uintptr_t)class & 1)
 				continue;
 
-			objc_unregister_class(class);
+			objc_unregisterClass(class);
 
 			/*
 			 * The table might have been resized, so go back to the
 			 * start again.
 			 *