Index: src/OFInflateStream.m
==================================================================
--- src/OFInflateStream.m
+++ src/OFInflateStream.m
@@ -37,25 +37,25 @@
 # define bufferSize OFInflateStreamBufferSize
 #else
 # define bufferSize OFInflate64StreamBufferSize
 #endif
 
-enum state {
+enum State {
 	StateBlockHeader,
 	StateUncompressedBlockHeader,
 	StateUncompressedBlock,
 	StateHuffmanTree,
 	StateHuffmanBlock
 };
 
-enum huffman_state {
-	WRITE_VALUE,
-	AWAIT_CODE,
-	AWAIT_LENGTH_EXTRA_BITS,
-	AWAIT_DISTANCE,
-	AWAIT_DISTANCE_EXTRA_BITS,
-	PROCESS_PAIR
+enum HuffmanState {
+	HuffmanStateWriteValue,
+	HuffmanStateAwaitCode,
+	HuffmanStateAwaitLengthExtraBits,
+	HuffmanStateAwaitDistance,
+	HuffmanStateAwaitDistanceExtraBits,
+	HuffmanStateProcessPair
 };
 
 #ifndef OF_INFLATE64_STREAM_M
 static const uint8_t numDistanceCodes = 30;
 static const uint8_t lengthCodes[29] = {
@@ -240,11 +240,11 @@
 
 	if (_atEndOfStream)
 		return 0;
 
 start:
-	switch ((enum state)_state) {
+	switch ((enum State)_state) {
 	case StateBlockHeader:
 		if OF_UNLIKELY (_inLastBlock) {
 			[_stream unreadFromBuffer: _buffer + _bufferIndex
 					   length: _bufferLength -
 						   _bufferIndex];
@@ -266,11 +266,11 @@
 			_context.uncompressedHeader.position = 0;
 			memset(_context.uncompressedHeader.length, 0, 4);
 			break;
 		case 1: /* Fixed Huffman */
 			_state = StateHuffmanBlock;
-			_context.huffman.state = AWAIT_CODE;
+			_context.huffman.state = HuffmanStateAwaitCode;
 			_context.huffman.litLenTree = fixedLitLenTree;
 			_context.huffman.distTree = fixedDistTree;
 			_context.huffman.treeIter = fixedLitLenTree;
 			break;
 		case 2: /* Dynamic Huffman */
@@ -488,21 +488,21 @@
 		 * 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 = AWAIT_CODE;
+		_context.huffman.state = HuffmanStateAwaitCode;
 		_context.huffman.treeIter = CTX.litLenTree;
 
 		goto start;
 #undef CTX
 	case StateHuffmanBlock:
 #define CTX _context.huffman
 		for (;;) {
 			uint8_t extraBits, lengthCodeIndex;
 
-			if OF_UNLIKELY (CTX.state == WRITE_VALUE) {
+			if OF_UNLIKELY (CTX.state == HuffmanStateWriteValue) {
 				if OF_UNLIKELY (length == 0)
 					return bytesWritten;
 
 				buffer[bytesWritten++] = CTX.value;
 				length--;
@@ -510,27 +510,28 @@
 				_slidingWindow[_slidingWindowIndex] = CTX.value;
 				_slidingWindowIndex =
 				    (_slidingWindowIndex + 1) &
 				    _slidingWindowMask;
 
-				CTX.state = AWAIT_CODE;
+				CTX.state = HuffmanStateAwaitCode;
 				CTX.treeIter = CTX.litLenTree;
 			}
 
-			if OF_UNLIKELY (CTX.state == AWAIT_LENGTH_EXTRA_BITS) {
+			if OF_UNLIKELY (CTX.state ==
+			    HuffmanStateAwaitLengthExtraBits) {
 				if OF_UNLIKELY (!tryReadBits(self, &bits,
 				    CTX.extraBits))
 					return bytesWritten;
 
 				CTX.length += bits;
 
-				CTX.state = AWAIT_DISTANCE;
+				CTX.state = HuffmanStateAwaitDistance;
 				CTX.treeIter = CTX.distTree;
 			}
 
 			/* Distance of length distance pair */
-			if (CTX.state == AWAIT_DISTANCE) {
+			if (CTX.state == HuffmanStateAwaitDistance) {
 				if OF_UNLIKELY (!OFHuffmanTreeWalk(self,
 				    tryReadBits, &CTX.treeIter, &value))
 					return bytesWritten;
 
 				if OF_UNLIKELY (value >= numDistanceCodes)
@@ -541,32 +542,34 @@
 				extraBits = distanceExtraBits[value];
 
 				if (extraBits > 0) {
 					if OF_UNLIKELY (!tryReadBits(self,
 					    &bits, extraBits)) {
-						CTX.state =
-						    AWAIT_DISTANCE_EXTRA_BITS;
+#define HSADEB HuffmanStateAwaitDistanceExtraBits
+						CTX.state = HSADEB;
+#undef HSADEB
 						CTX.extraBits = extraBits;
 						return bytesWritten;
 					}
 
 					CTX.distance += bits;
 				}
 
-				CTX.state = PROCESS_PAIR;
-			} else if (CTX.state == AWAIT_DISTANCE_EXTRA_BITS) {
+				CTX.state = HuffmanStateProcessPair;
+			} else if (CTX.state ==
+			    HuffmanStateAwaitDistanceExtraBits) {
 				if OF_UNLIKELY (!tryReadBits(self, &bits,
 				    CTX.extraBits))
 					return bytesWritten;
 
 				CTX.distance += bits;
 
-				CTX.state = PROCESS_PAIR;
+				CTX.state = HuffmanStateProcessPair;
 			}
 
 			/* Length distance pair */
-			if (CTX.state == PROCESS_PAIR) {
+			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;
@@ -585,11 +588,11 @@
 					_slidingWindowIndex =
 					    (_slidingWindowIndex + 1) &
 					    _slidingWindowMask;
 				}
 
-				CTX.state = AWAIT_CODE;
+				CTX.state = HuffmanStateAwaitCode;
 				CTX.treeIter = CTX.litLenTree;
 			}
 
 			if OF_UNLIKELY (!OFHuffmanTreeWalk(self, tryReadBits,
 			    &CTX.treeIter, &value))
@@ -607,11 +610,11 @@
 			}
 
 			/* Literal byte */
 			if OF_LIKELY (value < 256) {
 				if OF_UNLIKELY (length == 0) {
-					CTX.state = WRITE_VALUE;
+					CTX.state = HuffmanStateWriteValue;
 					CTX.value = value;
 					return bytesWritten;
 				}
 
 				buffer[bytesWritten++] = value;
@@ -636,19 +639,20 @@
 
 			if (extraBits > 0) {
 				if OF_UNLIKELY (!tryReadBits(self, &bits,
 				    extraBits)) {
 					CTX.extraBits = extraBits;
-					CTX.state = AWAIT_LENGTH_EXTRA_BITS;
+					CTX.state =
+					    HuffmanStateAwaitLengthExtraBits;
 					return bytesWritten;
 				}
 
 				CTX.length += bits;
 			}
 
 			CTX.treeIter = CTX.distTree;
-			CTX.state = AWAIT_DISTANCE;
+			CTX.state = HuffmanStateAwaitDistance;
 		}
 
 		break;
 #undef CTX
 	}