@@ -38,24 +38,24 @@
 #else
 # define bufferSize OFInflate64StreamBufferSize
 #endif
 
 enum State {
-	StateBlockHeader,
-	StateUncompressedBlockHeader,
-	StateUncompressedBlock,
-	StateHuffmanTree,
-	StateHuffmanBlock
+	stateBlockHeader,
+	stateUncompressedBlockHeader,
+	stateUncompressedBlock,
+	stateHuffmanTree,
+	stateHuffmanBlock
 };
 
 enum HuffmanState {
-	HuffmanStateWriteValue,
-	HuffmanStateAwaitCode,
-	HuffmanStateAwaitLengthExtraBits,
-	HuffmanStateAwaitDistance,
-	HuffmanStateAwaitDistanceExtraBits,
-	HuffmanStateProcessPair
+	huffmanStateWriteValue,
+	huffmanStateAwaitCode,
+	huffmanStateAwaitLengthExtraBits,
+	huffmanStateAwaitDistance,
+	huffmanStateAwaitDistanceExtraBits,
+	huffmanStateProcessPair
 };
 
 #ifndef OF_INFLATE64_STREAM_M
 static const uint8_t numDistanceCodes = 30;
 static const uint8_t lengthCodes[29] = {
@@ -207,18 +207,18 @@
 	if (_stream != nil)
 		[self close];
 
 	OFFreeMemory(_slidingWindow);
 
-	if (_state == StateHuffmanTree) {
+	if (_state == stateHuffmanTree) {
 		OFFreeMemory(_context.huffmanTree.lengths);
 
 		if (_context.huffmanTree.codeLenTree != NULL)
 			OFHuffmanTreeFree(_context.huffmanTree.codeLenTree);
 	}
 
-	if (_state == StateHuffmanTree || _state == StateHuffmanBlock) {
+	if (_state == stateHuffmanTree || _state == stateHuffmanBlock) {
 		if (_context.huffman.litLenTree != fixedLitLenTree)
 			OFHuffmanTreeFree(_context.huffman.litLenTree);
 		if (_context.huffman.distTree != fixedDistTree)
 			OFHuffmanTreeFree(_context.huffman.distTree);
 	}
@@ -241,11 +241,11 @@
 	if (_atEndOfStream)
 		return 0;
 
 start:
 	switch ((enum State)_state) {
-	case StateBlockHeader:
+	case stateBlockHeader:
 		if OF_UNLIKELY (_inLastBlock) {
 			[_stream unreadFromBuffer: _buffer + _bufferIndex
 					   length: _bufferLength -
 						   _bufferIndex];
 			_bufferIndex = _bufferLength = 0;
@@ -259,24 +259,24 @@
 
 		_inLastBlock = (bits & 1);
 
 		switch (bits >> 1) {
 		case 0: /* No compression */
-			_state = StateUncompressedBlockHeader;
+			_state = stateUncompressedBlockHeader;
 			_bitIndex = 8;
 			_context.uncompressedHeader.position = 0;
 			memset(_context.uncompressedHeader.length, 0, 4);
 			break;
 		case 1: /* Fixed Huffman */
-			_state = StateHuffmanBlock;
-			_context.huffman.state = HuffmanStateAwaitCode;
+			_state = stateHuffmanBlock;
+			_context.huffman.state = huffmanStateAwaitCode;
 			_context.huffman.litLenTree = fixedLitLenTree;
 			_context.huffman.distTree = fixedDistTree;
 			_context.huffman.treeIter = fixedLitLenTree;
 			break;
 		case 2: /* Dynamic Huffman */
-			_state = StateHuffmanTree;
+			_state = stateHuffmanTree;
 			_context.huffmanTree.lengths = NULL;
 			_context.huffmanTree.receivedCount = 0;
 			_context.huffmanTree.value = 0xFE;
 			_context.huffmanTree.litLenCodesCount = 0xFF;
 			_context.huffmanTree.distCodesCount = 0xFF;
@@ -285,11 +285,11 @@
 		default:
 			@throw [OFInvalidFormatException exception];
 		}
 
 		goto start;
-	case StateUncompressedBlockHeader:
+	case stateUncompressedBlockHeader:
 #define CTX _context.uncompressedHeader
 		/* FIXME: This can be done more efficiently than unreading */
 		[_stream unreadFromBuffer: _buffer + _bufferIndex
 				   length: _bufferLength - _bufferIndex];
 		_bufferIndex = _bufferLength = 0;
@@ -303,11 +303,11 @@
 
 		if OF_UNLIKELY ((CTX.length[0] | (CTX.length[1] << 8)) !=
 		    (uint16_t)~(CTX.length[2] | (CTX.length[3] << 8)))
 			@throw [OFInvalidFormatException exception];
 
-		_state = StateUncompressedBlock;
+		_state = stateUncompressedBlock;
 
 		/*
 		 * Do not reorder! _context.uncompressed.position and
 		 * _context.uncompressedHeader.length overlap!
 		 */
@@ -315,11 +315,11 @@
 		    CTX.length[0] | (CTX.length[1] << 8);
 		_context.uncompressed.position = 0;
 
 		goto start;
 #undef CTX
-	case StateUncompressedBlock:
+	case stateUncompressedBlock:
 #define CTX _context.uncompressed
 		if OF_UNLIKELY (length == 0)
 			return bytesWritten;
 
 		tmp = (length < (size_t)CTX.length - CTX.position
@@ -341,15 +341,15 @@
 		length -= tmp;
 		bytesWritten += tmp;
 
 		CTX.position += tmp;
 		if OF_UNLIKELY (CTX.position == CTX.length)
-			_state = StateBlockHeader;
+			_state = stateBlockHeader;
 
 		goto start;
 #undef CTX
-	case StateHuffmanTree:
+	case stateHuffmanTree:
 #define CTX _context.huffmanTree
 		if OF_LIKELY (CTX.value == 0xFE) {
 			if OF_LIKELY (CTX.litLenCodesCount == 0xFF) {
 				if OF_UNLIKELY (!tryReadBits(self, &bits, 5))
 					return bytesWritten;
@@ -487,22 +487,22 @@
 		/*
 		 * litLenTree and distTree are at the same location in
 		 * _context.huffman and _context.huffmanTree, thus no need to
 		 * set them.
 		 */
-		_state = StateHuffmanBlock;
-		_context.huffman.state = HuffmanStateAwaitCode;
+		_state = stateHuffmanBlock;
+		_context.huffman.state = huffmanStateAwaitCode;
 		_context.huffman.treeIter = CTX.litLenTree;
 
 		goto start;
 #undef CTX
-	case StateHuffmanBlock:
+	case stateHuffmanBlock:
 #define CTX _context.huffman
 		for (;;) {
 			uint8_t extraBits, lengthCodeIndex;
 
-			if OF_UNLIKELY (CTX.state == HuffmanStateWriteValue) {
+			if OF_UNLIKELY (CTX.state == huffmanStateWriteValue) {
 				if OF_UNLIKELY (length == 0)
 					return bytesWritten;
 
 				buffer[bytesWritten++] = CTX.value;
 				length--;
@@ -510,28 +510,28 @@
 				_slidingWindow[_slidingWindowIndex] = CTX.value;
 				_slidingWindowIndex =
 				    (_slidingWindowIndex + 1) &
 				    _slidingWindowMask;
 
-				CTX.state = HuffmanStateAwaitCode;
+				CTX.state = huffmanStateAwaitCode;
 				CTX.treeIter = CTX.litLenTree;
 			}
 
 			if OF_UNLIKELY (CTX.state ==
-			    HuffmanStateAwaitLengthExtraBits) {
+			    huffmanStateAwaitLengthExtraBits) {
 				if OF_UNLIKELY (!tryReadBits(self, &bits,
 				    CTX.extraBits))
 					return bytesWritten;
 
 				CTX.length += bits;
 
-				CTX.state = HuffmanStateAwaitDistance;
+				CTX.state = huffmanStateAwaitDistance;
 				CTX.treeIter = CTX.distTree;
 			}
 
 			/* Distance of length distance pair */
-			if (CTX.state == HuffmanStateAwaitDistance) {
+			if (CTX.state == huffmanStateAwaitDistance) {
 				if OF_UNLIKELY (!OFHuffmanTreeWalk(self,
 				    tryReadBits, &CTX.treeIter, &value))
 					return bytesWritten;
 
 				if OF_UNLIKELY (value >= numDistanceCodes)
@@ -542,34 +542,34 @@
 				extraBits = distanceExtraBits[value];
 
 				if (extraBits > 0) {
 					if OF_UNLIKELY (!tryReadBits(self,
 					    &bits, extraBits)) {
-#define HSADEB HuffmanStateAwaitDistanceExtraBits
+#define HSADEB huffmanStateAwaitDistanceExtraBits
 						CTX.state = HSADEB;
 #undef HSADEB
 						CTX.extraBits = extraBits;
 						return bytesWritten;
 					}
 
 					CTX.distance += bits;
 				}
 
-				CTX.state = HuffmanStateProcessPair;
+				CTX.state = huffmanStateProcessPair;
 			} else if (CTX.state ==
-			    HuffmanStateAwaitDistanceExtraBits) {
+			    huffmanStateAwaitDistanceExtraBits) {
 				if OF_UNLIKELY (!tryReadBits(self, &bits,
 				    CTX.extraBits))
 					return bytesWritten;
 
 				CTX.distance += bits;
 
-				CTX.state = HuffmanStateProcessPair;
+				CTX.state = huffmanStateProcessPair;
 			}
 
 			/* Length distance pair */
-			if (CTX.state == HuffmanStateProcessPair) {
+			if (CTX.state == huffmanStateProcessPair) {
 				for (uint_fast16_t j = 0; j < CTX.length; j++) {
 					uint16_t idx;
 
 					if OF_UNLIKELY (length == 0) {
 						CTX.length -= j;
@@ -588,11 +588,11 @@
 					_slidingWindowIndex =
 					    (_slidingWindowIndex + 1) &
 					    _slidingWindowMask;
 				}
 
-				CTX.state = HuffmanStateAwaitCode;
+				CTX.state = huffmanStateAwaitCode;
 				CTX.treeIter = CTX.litLenTree;
 			}
 
 			if OF_UNLIKELY (!OFHuffmanTreeWalk(self, tryReadBits,
 			    &CTX.treeIter, &value))
@@ -603,18 +603,18 @@
 				if (CTX.litLenTree != fixedLitLenTree)
 					OFHuffmanTreeFree(CTX.litLenTree);
 				if (CTX.distTree != fixedDistTree)
 					OFHuffmanTreeFree(CTX.distTree);
 
-				_state = StateBlockHeader;
+				_state = stateBlockHeader;
 				goto start;
 			}
 
 			/* Literal byte */
 			if OF_LIKELY (value < 256) {
 				if OF_UNLIKELY (length == 0) {
-					CTX.state = HuffmanStateWriteValue;
+					CTX.state = huffmanStateWriteValue;
 					CTX.value = value;
 					return bytesWritten;
 				}
 
 				buffer[bytesWritten++] = value;
@@ -640,19 +640,19 @@
 			if (extraBits > 0) {
 				if OF_UNLIKELY (!tryReadBits(self, &bits,
 				    extraBits)) {
 					CTX.extraBits = extraBits;
 					CTX.state =
-					    HuffmanStateAwaitLengthExtraBits;
+					    huffmanStateAwaitLengthExtraBits;
 					return bytesWritten;
 				}
 
 				CTX.length += bits;
 			}
 
 			CTX.treeIter = CTX.distTree;
-			CTX.state = HuffmanStateAwaitDistance;
+			CTX.state = huffmanStateAwaitDistance;
 		}
 
 		break;
 #undef CTX
 	}