Index: src/OFLHAArchive.h
==================================================================
--- src/OFLHAArchive.h
+++ src/OFLHAArchive.h
@@ -29,15 +29,11 @@
  */
 OF_SUBCLASSING_RESTRICTED
 @interface OFLHAArchive: OFObject
 {
 	OFStream *_stream;
-	enum {
-		OFLHAArchiveModeRead,
-		OFLHAArchiveModeWrite,
-		OFLHAArchiveModeAppend
-	} _mode;
+	uint_least8_t _mode;
 	OFStringEncoding _encoding;
 	OFStream *_Nullable _lastReturnedStream;
 }
 
 /**

Index: src/OFLHAArchive.m
==================================================================
--- src/OFLHAArchive.m
+++ src/OFLHAArchive.m
@@ -32,10 +32,16 @@
 #import "OFNotImplementedException.h"
 #import "OFNotOpenException.h"
 #import "OFOutOfRangeException.h"
 #import "OFTruncatedDataException.h"
 #import "OFWriteFailedException.h"
+
+enum {
+	modeRead,
+	modeWrite,
+	modeAppend
+};
 
 OF_DIRECT_MEMBERS
 @interface OFLHAArchiveFileReadStream: OFStream <OFReadyForReadingObserving>
 {
 	OFStream *_stream, *_decompressedStream;
@@ -92,24 +98,23 @@
 
 	@try {
 		_stream = [stream retain];
 
 		if ([mode isEqual: @"r"])
-			_mode = OFLHAArchiveModeRead;
+			_mode = modeRead;
 		else if ([mode isEqual: @"w"])
-			_mode = OFLHAArchiveModeWrite;
+			_mode = modeWrite;
 		else if ([mode isEqual: @"a"])
-			_mode = OFLHAArchiveModeAppend;
+			_mode = modeAppend;
 		else
 			@throw [OFInvalidArgumentException exception];
 
-		if ((_mode == OFLHAArchiveModeWrite ||
-		    _mode == OFLHAArchiveModeAppend) &&
+		if ((_mode == modeWrite || _mode == modeAppend) &&
 		    ![_stream isKindOfClass: [OFSeekableStream class]])
 			@throw [OFInvalidArgumentException exception];
 
-		if (_mode == OFLHAArchiveModeAppend)
+		if (_mode == modeAppend)
 			[(OFSeekableStream *)_stream seekToOffset: 0
 							   whence: SEEK_END];
 
 		_encoding = OFStringEncodingISO8859_1;
 	} @catch (id e) {
@@ -152,11 +157,11 @@
 {
 	OFLHAArchiveEntry *entry;
 	char header[21];
 	size_t headerLen;
 
-	if (_mode != OFLHAArchiveModeRead)
+	if (_mode != modeRead)
 		@throw [OFInvalidArgumentException exception];
 
 	[(OFLHAArchiveFileReadStream *)_lastReturnedStream of_skip];
 	@try {
 		[_lastReturnedStream close];
@@ -193,11 +198,11 @@
 	return entry;
 }
 
 - (OFStream *)streamForReadingCurrentEntry
 {
-	if (_mode != OFLHAArchiveModeRead)
+	if (_mode != modeRead)
 		@throw [OFInvalidArgumentException exception];
 
 	if (_lastReturnedStream == nil)
 		@throw [OFInvalidArgumentException exception];
 
@@ -207,11 +212,11 @@
 
 - (OFStream *)streamForWritingEntry: (OFLHAArchiveEntry *)entry
 {
 	OFString *compressionMethod;
 
-	if (_mode != OFLHAArchiveModeWrite && _mode != OFLHAArchiveModeAppend)
+	if (_mode != modeWrite && _mode != modeAppend)
 		@throw [OFInvalidArgumentException exception];
 
 	compressionMethod = entry.compressionMethod;
 
 	if (![compressionMethod isEqual: @"-lh0-"] &&

Index: src/OFZIPArchive.h
==================================================================
--- src/OFZIPArchive.h
+++ src/OFZIPArchive.h
@@ -32,15 +32,11 @@
 OF_SUBCLASSING_RESTRICTED
 @interface OFZIPArchive: OFObject
 {
 	OFStream *_stream;
 	int64_t _offset;
-	enum {
-		OFZIPArchiveModeRead,
-		OFZIPArchiveModeWrite,
-		OFZIPArchiveModeAppend
-	} _mode;
+	uint_least8_t _mode;
 	uint32_t _diskNumber, _centralDirectoryDisk;
 	uint64_t _centralDirectoryEntriesInDisk, _centralDirectoryEntries;
 	uint64_t _centralDirectorySize;
 	int64_t _centralDirectoryOffset;
 	OFString *_Nullable _archiveComment;

Index: src/OFZIPArchive.m
==================================================================
--- src/OFZIPArchive.m
+++ src/OFZIPArchive.m
@@ -46,10 +46,16 @@
 /*
  * FIXME: Current limitations:
  *  - Split archives are not supported.
  *  - Encrypted files cannot be read.
  */
+
+enum {
+	modeRead,
+	modeWrite,
+	modeAppend
+};
 
 OF_DIRECT_MEMBERS
 @interface OFZIPArchive ()
 - (void)of_readZIPInfo;
 - (void)of_readEntries;
@@ -173,32 +179,31 @@
 {
 	self = [super init];
 
 	@try {
 		if ([mode isEqual: @"r"])
-			_mode = OFZIPArchiveModeRead;
+			_mode = modeRead;
 		else if ([mode isEqual: @"w"])
-			_mode = OFZIPArchiveModeWrite;
+			_mode = modeWrite;
 		else if ([mode isEqual: @"a"])
-			_mode = OFZIPArchiveModeAppend;
+			_mode = modeAppend;
 		else
 			@throw [OFInvalidArgumentException exception];
 
 		_stream = [stream retain];
 		_entries = [[OFMutableArray alloc] init];
 		_pathToEntryMap = [[OFMutableDictionary alloc] init];
 
-		if (_mode == OFZIPArchiveModeRead ||
-		    _mode == OFZIPArchiveModeAppend) {
+		if (_mode == modeRead || _mode == modeAppend) {
 			if (![stream isKindOfClass: [OFSeekableStream class]])
 				@throw [OFInvalidArgumentException exception];
 
 			[self of_readZIPInfo];
 			[self of_readEntries];
 		}
 
-		if (_mode == OFZIPArchiveModeAppend) {
+		if (_mode == modeAppend) {
 			_offset = _centralDirectoryOffset;
 			seekOrThrowInvalidFormat((OFSeekableStream *)_stream,
 			    (OFFileOffset)_offset, SEEK_SET);
 		}
 	} @catch (id e) {
@@ -398,12 +403,11 @@
 		[_lastReturnedStream close];
 	} @catch (OFNotOpenException *e) {
 		/* Might have already been closed by the user - that's fine. */
 	}
 
-	if ((_mode == OFZIPArchiveModeWrite ||
-	    _mode == OFZIPArchiveModeAppend) &&
+	if ((_mode == modeWrite || _mode == modeAppend) &&
 	    [_lastReturnedStream isKindOfClass:
 	    [OFZIPArchiveFileWriteStream class]]) {
 		OFZIPArchiveFileWriteStream *stream =
 		    (OFZIPArchiveFileWriteStream *)_lastReturnedStream;
 
@@ -428,11 +432,11 @@
 	void *pool = objc_autoreleasePoolPush();
 	OFZIPArchiveEntry *entry;
 	OFZIPArchiveLocalFileHeader *localFileHeader;
 	int64_t offset64;
 
-	if (_mode != OFZIPArchiveModeRead)
+	if (_mode != modeRead)
 		@throw [OFInvalidArgumentException exception];
 
 	if ((entry = [_pathToEntryMap objectForKey: path]) == nil)
 		@throw [OFOpenItemFailedException exceptionWithPath: path
 							       mode: @"r"
@@ -478,11 +482,11 @@
 	OFMutableZIPArchiveEntry *entry;
 	OFString *fileName;
 	OFData *extraField;
 	uint16_t fileNameLength, extraFieldLength;
 
-	if (_mode != OFZIPArchiveModeWrite && _mode != OFZIPArchiveModeAppend)
+	if (_mode != modeWrite && _mode != modeAppend)
 		@throw [OFInvalidArgumentException exception];
 
 	pool = objc_autoreleasePoolPush();
 	entry = [[entry_ mutableCopy] autorelease];
 
@@ -611,11 +615,11 @@
 	if (_stream == nil)
 		@throw [OFNotOpenException exceptionWithObject: self];
 
 	[self of_closeLastReturnedStream];
 
-	if (_mode == OFZIPArchiveModeWrite || _mode == OFZIPArchiveModeAppend)
+	if (_mode == modeWrite || _mode == modeAppend)
 		[self of_writeCentralDirectory];
 
 	[_stream release];
 	_stream = nil;
 }