Index: src/OFDataArray.m
==================================================================
--- src/OFDataArray.m
+++ src/OFDataArray.m
@@ -101,11 +101,10 @@
 	@try {
 		OFFile *file = [[OFFile alloc] initWithPath: path
 						       mode: @"rb"];
 
 		itemSize = 1;
-		data = NULL;
 
 		@try {
 			char *buffer = [self allocMemoryWithSize: of_pagesize];
 
 			while (![file isAtEndOfStream]) {
@@ -164,11 +163,10 @@
 - initWithBase64EncodedString: (OFString*)string
 {
 	self = [super init];
 
 	itemSize = 1;
-	data = NULL;
 
 	if (!of_base64_decode(self, [string cString], [string cStringLength])) {
 		Class c = isa;
 		[self release];
 		@throw [OFInvalidEncodingException newWithClass: c];

Index: src/base64.m
==================================================================
--- src/base64.m
+++ src/base64.m
@@ -38,23 +38,23 @@
 	31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
 	48, 49, 50, 51, -1, -1, -1, -1, -1
 };
 
 OFString*
-of_base64_encode(const char *data, size_t len)
+of_base64_encode(const char *data, size_t length)
 {
 	OFMutableString *ret = [OFMutableString string];
-	uint8_t *buf = (uint8_t*)data;
+	uint8_t *buffer = (uint8_t*)data;
 	size_t i;
 	uint8_t rest;
 	char tb[4];
 	uint32_t sb;
 
-	rest = len % 3;
+	rest = length % 3;
 
-	for (i = 0; i < len - rest; i += 3) {
-		sb = (buf[i] << 16) | (buf[i + 1] << 8) | buf[i + 2];
+	for (i = 0; i < length - rest; i += 3) {
+		sb = (buffer[i] << 16) | (buffer[i + 1] << 8) | buffer[i + 2];
 
 		tb[0] = of_base64_encode_table[(sb & 0xFC0000) >> 18];
 		tb[1] = of_base64_encode_table[(sb & 0x03F000) >> 12];
 		tb[2] = of_base64_encode_table[(sb & 0x000FC0) >> 6];
 		tb[3] = of_base64_encode_table[sb & 0x00003F];
@@ -63,20 +63,20 @@
 					       length: 4];
 	}
 
 	switch (rest) {
 	case 1:
-		tb[0] = of_base64_encode_table[buf[i] >> 2];
-		tb[1] = of_base64_encode_table[(buf[i] & 3) << 4];
+		tb[0] = of_base64_encode_table[buffer[i] >> 2];
+		tb[1] = of_base64_encode_table[(buffer[i] & 3) << 4];
 		tb[2] = tb[3] = '=';
 
 		[ret appendCStringWithoutUTF8Checking: tb
 					       length: 4];
 
 		break;
 	case 2:
-		sb = (buf[i] << 16) | (buf[i + 1] << 8);
+		sb = (buffer[i] << 16) | (buffer[i + 1] << 8);
 
 		tb[0] = of_base64_encode_table[(sb & 0xFC0000) >> 18];
 		tb[1] = of_base64_encode_table[(sb & 0x03F000) >> 12];
 		tb[2] = of_base64_encode_table[(sb & 0x000FC0) >> 6];
 		tb[3] = '=';
@@ -95,56 +95,56 @@
 	ret->isa = [OFString class];
 	return ret;
 }
 
 BOOL
-of_base64_decode(OFDataArray *data, const char *str, size_t len)
+of_base64_decode(OFDataArray *data, const char *string, size_t length)
 {
-	const uint8_t *buf = (const uint8_t*)str;
+	const uint8_t *buffer = (const uint8_t*)string;
 	size_t i;
 
-	if ((len & 3) != 0)
+	if ((length & 3) != 0)
 		return NO;
 
 	if ([data itemSize] != 1)
 		return NO;
 
-	for (i = 0; i < len; i += 4) {
+	for (i = 0; i < length; i += 4) {
 		uint32_t sb = 0;
 		uint8_t count = 3;
 		char db[3];
 		char tmp;
 
-		if (buf[i] > 0x7F || buf[i + 1] > 0x7F ||
-		    buf[i + 2] > 0x7F || buf[i + 3] > 0x7F)
+		if (buffer[i] > 0x7F || buffer[i + 1] > 0x7F ||
+		    buffer[i + 2] > 0x7F || buffer[i + 3] > 0x7F)
 			return NO;
 
-		if (buf[i] == '=' || buf[i + 1] == '=' ||
-		    (buf[i + 2] == '=' && buf[i + 3] != '='))
+		if (buffer[i] == '=' || buffer[i + 1] == '=' ||
+		    (buffer[i + 2] == '=' && buffer[i + 3] != '='))
 			return NO;
 
-		if (buf[i + 2] == '=')
+		if (buffer[i + 2] == '=')
 			count--;
-		if (buf[i + 3] == '=')
+		if (buffer[i + 3] == '=')
 			count--;
 
-		if ((tmp = of_base64_decode_table[buf[i]]) == -1)
+		if ((tmp = of_base64_decode_table[buffer[i]]) == -1)
 			return NO;
 
 		sb |= tmp << 18;
 
-		if ((tmp = of_base64_decode_table[buf[i + 1]]) == -1)
+		if ((tmp = of_base64_decode_table[buffer[i + 1]]) == -1)
 			return NO;
 
 		sb |= tmp << 12;
 
-		if ((tmp = of_base64_decode_table[buf[i + 2]]) == -1)
+		if ((tmp = of_base64_decode_table[buffer[i + 2]]) == -1)
 			return NO;
 
 		sb |= tmp << 6;
 
-		if ((tmp = of_base64_decode_table[buf[i + 3]]) == -1)
+		if ((tmp = of_base64_decode_table[buffer[i + 3]]) == -1)
 			return NO;
 
 		sb |= tmp;
 
 		db[0] = (sb & 0xFF0000) >> 16;