@@ -107,14 +107,14 @@
 		skipWhitespaces(pointer, stop, line);
 		skipComment(pointer, stop, line);
 	}
 }
 
-static inline of_char16_t
+static inline OFChar16
 parseUnicodeEscape(const char *pointer, const char *stop)
 {
-	of_char16_t ret = 0;
+	OFChar16 ret = 0;
 
 	if (pointer + 5 >= stop)
 		return 0xFFFF;
 
 	if (pointer[0] != '\\' || pointer[1] != 'u')
@@ -148,17 +148,17 @@
 	char delimiter = **pointer;
 
 	if (++(*pointer) + 1 >= stop)
 		return nil;
 
-	buffer = of_alloc(stop - *pointer, 1);
+	buffer = OFAllocMemory(stop - *pointer, 1);
 
 	while (*pointer < stop) {
 		/* Parse escape codes */
 		if (**pointer == '\\') {
 			if (++(*pointer) >= stop) {
-				free(buffer);
+				OFFreeMemory(buffer);
 				return nil;
 			}
 
 			switch (**pointer) {
 			case '"':
@@ -187,32 +187,31 @@
 				buffer[i++] = '\t';
 				(*pointer)++;
 				break;
 			/* Parse Unicode escape sequence */
 			case 'u':;
-				of_char16_t c1, c2;
-				of_unichar_t c;
+				OFChar16 c1, c2;
+				OFUnichar c;
 				size_t l;
 
 				c1 = parseUnicodeEscape(*pointer - 1, stop);
 				if (c1 == 0xFFFF) {
-					free(buffer);
+					OFFreeMemory(buffer);
 					return nil;
 				}
 
 				/* Low surrogate */
 				if ((c1 & 0xFC00) == 0xDC00) {
-					free(buffer);
+					OFFreeMemory(buffer);
 					return nil;
 				}
 
 				/* Normal character */
 				if ((c1 & 0xFC00) != 0xD800) {
-					l = of_string_utf8_encode(c1,
-					    buffer + i);
+					l = OFUTF8StringEncode(c1, buffer + i);
 					if (l == 0) {
-						free(buffer);
+						OFFreeMemory(buffer);
 						return nil;
 					}
 
 					i += l;
 					*pointer += 5;
@@ -225,20 +224,20 @@
 				 * surrogate and now need to get the other one
 				 * in order to produce UTF-8 and not CESU-8.
 				 */
 				c2 = parseUnicodeEscape(*pointer + 5, stop);
 				if (c2 == 0xFFFF) {
-					free(buffer);
+					OFFreeMemory(buffer);
 					return nil;
 				}
 
 				c = (((c1 & 0x3FF) << 10) |
 				    (c2 & 0x3FF)) + 0x10000;
 
-				l = of_string_utf8_encode(c, buffer + i);
+				l = OFUTF8StringEncode(c, buffer + i);
 				if (l == 0) {
-					free(buffer);
+					OFFreeMemory(buffer);
 					return nil;
 				}
 
 				i += l;
 				*pointer += 11;
@@ -256,11 +255,11 @@
 			case '\n':
 				(*pointer)++;
 				(*line)++;
 				break;
 			default:
-				free(buffer);
+				OFFreeMemory(buffer);
 				return nil;
 			}
 		/* End of string found */
 		} else if (**pointer == delimiter) {
 			OFString *ret;
@@ -267,38 +266,38 @@
 
 			@try {
 				ret = [OFString stringWithUTF8String: buffer
 							      length: i];
 			} @finally {
-				free(buffer);
+				OFFreeMemory(buffer);
 			}
 
 			(*pointer)++;
 
 			return ret;
 		/* Newlines in strings are disallowed */
 		} else if (**pointer == '\n' || **pointer == '\r') {
 			(*line)++;
-			free(buffer);
+			OFFreeMemory(buffer);
 			return nil;
 		} else {
 			buffer[i++] = **pointer;
 			(*pointer)++;
 		}
 	}
 
-	free(buffer);
+	OFFreeMemory(buffer);
 	return nil;
 }
 
 static inline OFString *
 parseIdentifier(const char **pointer, const char *stop)
 {
 	char *buffer;
 	size_t i = 0;
 
-	buffer = of_alloc(stop - *pointer, 1);
+	buffer = OFAllocMemory(stop - *pointer, 1);
 
 	while (*pointer < stop) {
 		if ((**pointer >= 'a' && **pointer <= 'z') ||
 		    (**pointer >= 'A' && **pointer <= 'Z') ||
 		    (**pointer >= '0' && **pointer <= '9') ||
@@ -305,36 +304,36 @@
 		    **pointer == '_' || **pointer == '$' ||
 		    (**pointer & 0x80)) {
 			buffer[i++] = **pointer;
 			(*pointer)++;
 		} else if (**pointer == '\\') {
-			of_char16_t c1, c2;
-			of_unichar_t c;
+			OFChar16 c1, c2;
+			OFUnichar c;
 			size_t l;
 
 			if (++(*pointer) >= stop || **pointer != 'u') {
-				free(buffer);
+				OFFreeMemory(buffer);
 				return nil;
 			}
 
 			c1 = parseUnicodeEscape(*pointer - 1, stop);
 			if (c1 == 0xFFFF) {
-				free(buffer);
+				OFFreeMemory(buffer);
 				return nil;
 			}
 
 			/* Low surrogate */
 			if ((c1 & 0xFC00) == 0xDC00) {
-				free(buffer);
+				OFFreeMemory(buffer);
 				return nil;
 			}
 
 			/* Normal character */
 			if ((c1 & 0xFC00) != 0xD800) {
-				l = of_string_utf8_encode(c1, buffer + i);
+				l = OFUTF8StringEncode(c1, buffer + i);
 				if (l == 0) {
-					free(buffer);
+					OFFreeMemory(buffer);
 					return nil;
 				}
 
 				i += l;
 				*pointer += 5;
@@ -347,37 +346,37 @@
 			 * surrogate and now need to get the other one in order
 			 * to produce UTF-8 and not CESU-8.
 			 */
 			c2 = parseUnicodeEscape(*pointer + 5, stop);
 			if (c2 == 0xFFFF) {
-				free(buffer);
+				OFFreeMemory(buffer);
 				return nil;
 			}
 
 			c = (((c1 & 0x3FF) << 10) | (c2 & 0x3FF)) + 0x10000;
 
-			l = of_string_utf8_encode(c, buffer + i);
+			l = OFUTF8StringEncode(c, buffer + i);
 			if (l == 0) {
-				free(buffer);
+				OFFreeMemory(buffer);
 				return nil;
 			}
 
 			i += l;
 			*pointer += 11;
 		} else {
 			OFString *ret;
 
 			if (i == 0 || (buffer[0] >= '0' && buffer[0] <= '9')) {
-				free(buffer);
+				OFFreeMemory(buffer);
 				return nil;
 			}
 
 			@try {
 				ret = [OFString stringWithUTF8String: buffer
 							      length: i];
 			} @finally {
-				free(buffer);
+				OFFreeMemory(buffer);
 			}
 
 			return ret;
 		}
 	}
@@ -384,11 +383,11 @@
 
 	/*
 	 * It is never possible to end with an identifier, thus we should never
 	 * reach stop.
 	 */
-	free(buffer);
+	OFFreeMemory(buffer);
 	return nil;
 }
 
 static inline OFMutableArray *
 parseArray(const char **pointer, const char *stop, size_t *line,
@@ -502,12 +501,11 @@
 
 		object = nextObject(pointer, stop, line, depthLimit);
 		if (object == nil)
 			return nil;
 
-		[dictionary setObject: object
-			       forKey: key];
+		[dictionary setObject: object forKey: key];
 
 		skipWhitespacesAndComments(pointer, stop, line);
 		if (*pointer >= stop)
 			return nil;
 
@@ -548,12 +546,11 @@
 
 			break;
 		}
 	}
 
-	string = [[OFString alloc] initWithUTF8String: *pointer
-					       length: i];
+	string = [[OFString alloc] initWithUTF8String: *pointer length: i];
 	*pointer += i;
 
 	@try {
 		if (hasDecimal)
 			number = [OFNumber numberWithDouble: