Index: src/OFDate.m ================================================================== --- src/OFDate.m +++ src/OFDate.m @@ -355,11 +355,11 @@ uint32_t hash; union { double d; uint8_t b[sizeof(double)]; } d; - uint_fast8_t i; + uint8_t i; d.d = OF_BSWAP_DOUBLE_IF_BE(_seconds); OF_HASH_INIT(hash); Index: src/OFInflateStream.h ================================================================== --- src/OFInflateStream.h +++ src/OFInflateStream.h @@ -31,39 +31,39 @@ #ifdef OF_INFLATE_STREAM_M @public #endif OFStream *_stream; uint8_t _buffer[OF_INFLATE_STREAM_BUFFER_SIZE]; - uint_fast16_t _bufferIndex, _bufferLength; + uint16_t _bufferIndex, _bufferLength; uint8_t _byte; - uint_fast8_t _bitIndex, _savedBitsLength; - uint_fast16_t _savedBits; + uint8_t _bitIndex, _savedBitsLength; + uint16_t _savedBits; @protected uint8_t *_slidingWindow; - uint_fast16_t _slidingWindowIndex, _slidingWindowMask; + uint16_t _slidingWindowIndex, _slidingWindowMask; enum { OF_INFLATE_STREAM_BLOCK_HEADER, OF_INFLATE_STREAM_UNCOMPRESSED_BLOCK_HEADER, OF_INFLATE_STREAM_UNCOMPRESSED_BLOCK, OF_INFLATE_STREAM_HUFFMAN_TREE, OF_INFLATE_STREAM_HUFFMAN_BLOCK } _state; union { struct { - uint_fast8_t position; + uint8_t position; uint8_t length[4]; } uncompressedHeader; struct { - uint_fast16_t position, length; + uint16_t position, length; } uncompressed; struct { struct huffman_tree *litLenTree, *distTree; struct huffman_tree *codeLenTree, *treeIter; uint8_t *lengths; - uint_fast16_t receivedCount; - uint_fast8_t value, litLenCodesCount, distCodesCount; - uint_fast8_t codeLenCodesCount; + uint16_t receivedCount; + uint8_t value, litLenCodesCount, distCodesCount; + uint8_t codeLenCodesCount; } huffmanTree; struct { struct huffman_tree *litLenTree, *distTree, *treeIter; enum { OF_INFLATE_STREAM_WRITE_VALUE, @@ -71,12 +71,12 @@ OF_INFLATE_STREAM_AWAIT_LENGTH_EXTRA_BITS, OF_INFLATE_STREAM_AWAIT_DISTANCE, OF_INFLATE_STREAM_AWAIT_DISTANCE_EXTRA_BITS, OF_INFLATE_STREAM_PROCESS_PAIR } state; - uint_fast16_t value, length, distance; - uint_fast16_t extraBits; + uint16_t value, length, distance; + uint16_t extraBits; } huffman; } _context; bool _inLastBlock, _atEndOfStream; } Index: src/OFInflateStream.m ================================================================== --- src/OFInflateStream.m +++ src/OFInflateStream.m @@ -58,11 +58,11 @@ struct huffman_tree *leafs[2]; uint16_t value; }; #ifndef DEFLATE64 -static const uint_fast8_t numDistanceCodes = 30; +static const uint8_t numDistanceCodes = 30; static const uint8_t lengthCodes[29] = { /* indices are -257, values -3 */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 255 }; @@ -77,11 +77,11 @@ static const uint8_t distanceExtraBits[30] = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 }; #else -static const uint_fast8_t numDistanceCodes = 32; +static const uint8_t numDistanceCodes = 32; static const uint8_t lengthCodes[29] = { /* indices are -257, values -3 */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 0 }; @@ -103,14 +103,14 @@ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 }; static struct huffman_tree *fixedLitLenTree, *fixedDistTree; static bool -tryReadBits(OFInflateStream *stream, uint_fast16_t *bits, uint_fast8_t count) +tryReadBits(OFInflateStream *stream, uint16_t *bits, uint8_t count) { - uint_fast16_t ret = stream->_savedBits; - uint_fast8_t i; + uint16_t ret = stream->_savedBits; + uint8_t i; assert(stream->_savedBitsLength < count); for (i = stream->_savedBitsLength; i < count; i++) { if OF_UNLIKELY (stream->_bitIndex == 8) { @@ -128,11 +128,11 @@ return false; } stream->_byte = stream->_buffer[0]; stream->_bufferIndex = 1; - stream->_bufferLength = (uint_fast16_t)length; + stream->_bufferLength = (uint16_t)length; } stream->_bitIndex = 0; } @@ -160,15 +160,15 @@ return tree; } static void -treeInsert(struct huffman_tree *tree, uint_fast16_t code, uint_fast8_t length, +treeInsert(struct huffman_tree *tree, uint16_t code, uint8_t length, uint16_t value) { while (length > 0) { - uint_fast8_t bit; + uint8_t bit; length--; bit = (code & (1 << length)) >> length; if (tree->leafs[bit] == NULL) @@ -179,16 +179,16 @@ tree->value = value; } static struct huffman_tree* -constructTree(uint8_t lengths[], uint_fast16_t count) +constructTree(uint8_t lengths[], uint16_t count) { struct huffman_tree *tree; uint16_t lengthCount[MAX_BITS + 1] = { 0 }; uint16_t code, maxCode = 0, nextCode[MAX_BITS + 1]; - uint_fast16_t i; + uint16_t i; for (i = 0; i < count; i++) { uint8_t length = lengths[i]; if OF_UNLIKELY (length > MAX_BITS) @@ -220,11 +220,11 @@ static bool walkTree(OFInflateStream *stream, struct huffman_tree **tree, uint16_t *value) { struct huffman_tree *iter = *tree; - uint_fast16_t bits; + uint16_t bits; while (iter->value == 0xFFFF) { if OF_UNLIKELY (!tryReadBits(stream, &bits, 1)) { *tree = iter; return false; @@ -241,11 +241,11 @@ } static void releaseTree(struct huffman_tree *tree) { - uint_fast8_t i; + uint8_t i; for (i = 0; i < 2; i++) if OF_LIKELY (tree->leafs[i] != NULL) releaseTree(tree->leafs[i]); @@ -253,11 +253,11 @@ } @implementation OFInflateStream + (void)initialize { - uint_fast16_t i; + uint16_t i; uint8_t lengths[288]; if (self != [OFInflateStream class]) return; @@ -310,15 +310,15 @@ - (size_t)lowlevelReadIntoBuffer: (void*)buffer_ length: (size_t)length { uint8_t *buffer = buffer_; - uint_fast16_t bits, i, tmp; + uint16_t bits, i, tmp; uint16_t value; size_t bytesWritten = 0; uint8_t *slidingWindow; - uint_fast16_t slidingWindowIndex; + uint16_t slidingWindowIndex; if (_atEndOfStream) @throw [OFReadFailedException exceptionWithObject: self requestedLength: length]; @@ -401,15 +401,14 @@ #define CTX _context.uncompressed if OF_UNLIKELY (length == 0) return bytesWritten; tmp = (length < CTX.length - CTX.position - ? (uint_fast16_t)length : CTX.length - CTX.position); + ? (uint16_t)length : CTX.length - CTX.position); - tmp = (uint_fast16_t)[_stream - readIntoBuffer: buffer + bytesWritten - length: tmp]; + tmp = (uint16_t)[_stream readIntoBuffer: buffer + bytesWritten + length: tmp]; if OF_UNLIKELY (_slidingWindow == NULL) { _slidingWindow = [self allocMemoryWithSize: _slidingWindowMask + 1]; /* Avoid leaking data */ @@ -491,11 +490,11 @@ CTX.lengths = [self allocMemoryWithSize: CTX.litLenCodesCount + CTX.distCodesCount + 258]; for (i = CTX.receivedCount; i < CTX.litLenCodesCount + CTX.distCodesCount + 258;) { - uint_fast8_t j, count; + uint8_t j, count; if OF_LIKELY (CTX.value == 0xFF) { if OF_UNLIKELY (!walkTree(self, &CTX.treeIter, &value)) { CTX.receivedCount = i; @@ -585,11 +584,11 @@ goto start; #undef CTX case HUFFMAN_BLOCK: #define CTX _context.huffman for (;;) { - uint_fast8_t extraBits, lengthCodeIndex; + uint8_t extraBits, lengthCodeIndex; if OF_UNLIKELY (CTX.state == WRITE_VALUE) { if OF_UNLIKELY (length == 0) return bytesWritten; @@ -661,18 +660,18 @@ CTX.state = PROCESS_PAIR; } /* Length distance pair */ if (CTX.state == PROCESS_PAIR) { - uint_fast16_t j; + uint16_t j; if OF_UNLIKELY (_slidingWindow == NULL) @throw [OFInvalidFormatException exception]; for (j = 0; j < CTX.length; j++) { - uint_fast16_t index; + uint16_t index; if OF_UNLIKELY (length == 0) { CTX.length -= j; return bytesWritten; } Index: src/OFMD5Hash.m ================================================================== --- src/OFMD5Hash.m +++ src/OFMD5Hash.m @@ -60,14 +60,14 @@ 4, 11, 16, 23, 6, 10, 15, 21 }; static OF_INLINE void -byteSwapVectorIfBE(uint32_t *vector, uint_fast8_t length) +byteSwapVectorIfBE(uint32_t *vector, uint8_t length) { #ifdef OF_BIG_ENDIAN - uint_fast8_t i; + uint8_t i; for (i = 0; i < length; i++) vector[i] = OF_BSWAP32(vector[i]); #endif } @@ -74,11 +74,11 @@ static void processBlock(uint32_t *state, uint32_t *buffer) { uint32_t new[4]; - uint_fast8_t i = 0; + uint8_t i = 0; new[0] = state[0]; new[1] = state[1]; new[2] = state[2]; new[3] = state[3]; Index: src/OFNumber.m ================================================================== --- src/OFNumber.m +++ src/OFNumber.m @@ -830,11 +830,11 @@ if (type & OF_NUMBER_TYPE_FLOAT) { union { double d; uint8_t b[sizeof(double)]; } d; - uint_fast8_t i; + uint8_t i; if (isnan([self doubleValue])) return 0; d.d = OF_BSWAP_DOUBLE_IF_BE([self doubleValue]); Index: src/OFRIPEMD160Hash.m ================================================================== --- src/OFRIPEMD160Hash.m +++ src/OFRIPEMD160Hash.m @@ -56,14 +56,14 @@ 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 }; static OF_INLINE void -byteSwapVectorIfBE(uint32_t *vector, uint_fast8_t length) +byteSwapVectorIfBE(uint32_t *vector, uint8_t length) { #ifdef OF_BIG_ENDIAN - uint_fast8_t i; + uint8_t i; for (i = 0; i < length; i++) vector[i] = OF_BSWAP32(vector[i]); #endif } @@ -70,11 +70,11 @@ static void processBlock(uint32_t *state, uint32_t *buffer) { uint32_t new[5], new2[5]; - uint_fast8_t i = 0; + uint8_t i = 0; new[0] = new2[0] = state[0]; new[1] = new2[1] = state[1]; new[2] = new2[2] = state[2]; new[3] = new2[3] = state[3]; Index: src/OFSHA1Hash.m ================================================================== --- src/OFSHA1Hash.m +++ src/OFSHA1Hash.m @@ -26,14 +26,14 @@ #define G(a, b, c, d) ((b) ^ (c) ^ (d)) #define H(a, b, c, d) (((b) & (c)) | ((d) & ((b) | (c)))) #define I(a, b, c, d) ((b) ^ (c) ^ (d)) static OF_INLINE void -byteSwapVectorIfLE(uint32_t *vector, uint_fast8_t length) +byteSwapVectorIfLE(uint32_t *vector, uint8_t length) { #ifndef OF_BIG_ENDIAN - uint_fast8_t i; + uint8_t i; for (i = 0; i < length; i++) vector[i] = OF_BSWAP32(vector[i]); #endif } @@ -40,11 +40,11 @@ static void processBlock(uint32_t *state, uint32_t *buffer) { uint32_t new[5]; - uint_fast8_t i; + uint8_t i; new[0] = state[0]; new[1] = state[1]; new[2] = state[2]; new[3] = state[3]; Index: src/OFSHA224Or256Hash.m ================================================================== --- src/OFSHA224Or256Hash.m +++ src/OFSHA224Or256Hash.m @@ -40,14 +40,14 @@ 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2 }; static OF_INLINE void -byteSwapVectorIfLE(uint32_t *vector, uint_fast8_t length) +byteSwapVectorIfLE(uint32_t *vector, uint8_t length) { #ifndef OF_BIG_ENDIAN - uint_fast8_t i; + uint8_t i; for (i = 0; i < length; i++) vector[i] = OF_BSWAP32(vector[i]); #endif } @@ -54,11 +54,11 @@ static void processBlock(uint32_t *state, uint32_t *buffer) { uint32_t new[8]; - uint_fast8_t i; + uint8_t i; new[0] = state[0]; new[1] = state[1]; new[2] = state[2]; new[3] = state[3]; Index: src/OFSHA384Or512Hash.m ================================================================== --- src/OFSHA384Or512Hash.m +++ src/OFSHA384Or512Hash.m @@ -51,14 +51,14 @@ 0x431D67C49C100D4C, 0x4CC5D4BECB3E42B6, 0x597F299CFC657E2A, 0x5FCB6FAB3AD6FAEC, 0x6C44198C4A475817 }; static OF_INLINE void -byteSwapVectorIfLE(uint64_t *vector, uint_fast8_t length) +byteSwapVectorIfLE(uint64_t *vector, uint8_t length) { #ifndef OF_BIG_ENDIAN - uint_fast8_t i; + uint8_t i; for (i = 0; i < length; i++) vector[i] = OF_BSWAP64(vector[i]); #endif } @@ -65,11 +65,11 @@ static void processBlock(uint64_t *state, uint64_t *buffer) { uint64_t new[8]; - uint_fast8_t i; + uint8_t i; new[0] = state[0]; new[1] = state[1]; new[2] = state[2]; new[3] = state[3]; Index: src/OFZIPArchive.m ================================================================== --- src/OFZIPArchive.m +++ src/OFZIPArchive.m @@ -84,11 +84,11 @@ uint32_t of_zip_archive_read_field32(uint8_t **data, uint16_t *size) { uint32_t field = 0; - uint_fast8_t i; + uint8_t i; if (*size < 4) @throw [OFInvalidFormatException exception]; for (i = 0; i < 4; i++) @@ -102,11 +102,11 @@ uint64_t of_zip_archive_read_field64(uint8_t **data, uint16_t *size) { uint64_t field = 0; - uint_fast8_t i; + uint8_t i; if (*size < 8) @throw [OFInvalidFormatException exception]; for (i = 0; i < 8; i++) @@ -122,11 +122,11 @@ calculateCRC32(uint32_t crc, uint8_t *bytes, size_t length) { size_t i; for (i = 0; i < length; i++) { - uint_fast8_t j; + uint8_t j; crc ^= bytes[i]; for (j = 0; j < 8; j++) crc = (crc >> 1) ^ (CRC32_MAGIC & (~(crc & 1) + 1)); Index: src/OFZIPArchiveEntry.m ================================================================== --- src/OFZIPArchiveEntry.m +++ src/OFZIPArchiveEntry.m @@ -239,16 +239,16 @@ } - (OFDate*)modificationDate { void *pool = objc_autoreleasePoolPush(); - uint_fast16_t year = ((_lastModifiedFileDate & 0xFE00) >> 9) + 1980; - uint_fast8_t month = (_lastModifiedFileDate & 0x1E0) >> 5; - uint_fast8_t day = (_lastModifiedFileDate & 0x1F); - uint_fast8_t hour = (_lastModifiedFileTime & 0xF800) >> 11; - uint_fast8_t minute = (_lastModifiedFileTime & 0x7E0) >> 5; - uint_fast8_t second = (_lastModifiedFileTime & 0x1F) << 1; + uint16_t year = ((_lastModifiedFileDate & 0xFE00) >> 9) + 1980; + uint8_t month = (_lastModifiedFileDate & 0x1E0) >> 5; + uint8_t day = (_lastModifiedFileDate & 0x1F); + uint8_t hour = (_lastModifiedFileTime & 0xF800) >> 11; + uint8_t minute = (_lastModifiedFileTime & 0x7E0) >> 5; + uint8_t second = (_lastModifiedFileTime & 0x1F) << 1; OFDate *date; OFString *dateString; dateString = [OFString stringWithFormat: @"%04u-%02u-%02u %02u:%02u:%02u", Index: src/exceptions/OFException.m ================================================================== --- src/exceptions/OFException.m +++ src/exceptions/OFException.m @@ -67,11 +67,11 @@ _URC_END_OF_STACK = 5 }_Unwind_Reason_Code; struct backtrace_ctx { void **backtrace; - uint_fast8_t i; + uint8_t i; }; extern _Unwind_Reason_Code _Unwind_Backtrace( _Unwind_Reason_Code(*)(struct _Unwind_Context*, void*), void*); # ifdef OF_ARM @@ -260,11 +260,11 @@ - (OFArray*)backtrace { #ifdef HAVE_DWARF_EXCEPTIONS OFMutableArray *backtrace = [OFMutableArray array]; void *pool = objc_autoreleasePoolPush(); - uint_fast8_t i; + uint8_t i; for (i = 0; i < OF_BACKTRACE_SIZE && _backtrace[i] != NULL; i++) { # ifdef HAVE_DLADDR Dl_info info; Index: src/runtime/class.m ================================================================== --- src/runtime/class.m +++ src/runtime/class.m @@ -368,11 +368,11 @@ } void objc_register_all_classes(struct objc_abi_symtab *symtab) { - uint_fast32_t i; + uint32_t i; for (i = 0; i < symtab->cls_def_cnt; i++) { struct objc_abi_class *cls = (struct objc_abi_class*)symtab->defs[i]; @@ -840,11 +840,11 @@ } void objc_unregister_all_classes(void) { - uint_fast32_t i; + uint32_t i; if (classes == NULL) return; for (i = 0; i < classes->size; i++) { @@ -860,14 +860,14 @@ /* * The table might have been resized, so go back to the * start again. * * Due to the i++ in the for loop, we need to set it to - * UINT_FAST32_MAX so that it will get increased at the - * end of the loop and thus become 0. + * UINT32_MAX so that it will get increased at the end + * of the loop and thus become 0. */ - i = UINT_FAST32_MAX; + i = UINT32_MAX; } } assert(classes_cnt == 0); Index: src/runtime/dtable.m ================================================================== --- src/runtime/dtable.m +++ src/runtime/dtable.m @@ -28,11 +28,11 @@ #endif static void init(void) { - uint_fast16_t i; + uint16_t i; empty_level2 = malloc(sizeof(struct objc_dtable_level2)); if (empty_level2 == NULL) OBJC_ERROR("Not enough memory to allocate dtable!"); @@ -55,11 +55,11 @@ struct objc_dtable* objc_dtable_new(void) { struct objc_dtable *dtable; - uint_fast16_t i; + uint16_t i; #ifdef OF_SELUID24 if (empty_level2 == NULL || empty_level3 == NULL) init(); #else @@ -77,13 +77,13 @@ } void objc_dtable_copy(struct objc_dtable *dst, struct objc_dtable *src) { - uint_fast16_t i, j; + uint16_t i, j; #ifdef OF_SELUID24 - uint_fast16_t k; + uint16_t k; #endif uint32_t idx; for (i = 0; i < 256; i++) { if (src->buckets[i] == empty_level2) @@ -135,11 +135,11 @@ uint8_t j = idx; #endif if (dtable->buckets[i] == empty_level2) { struct objc_dtable_level2 *level2; - uint_fast16_t l; + uint16_t l; level2 = malloc(sizeof(struct objc_dtable_level2)); if (level2 == NULL) OBJC_ERROR("Not enough memory to insert into dtable!"); @@ -155,11 +155,11 @@ } #ifdef OF_SELUID24 if (dtable->buckets[i]->buckets[j] == empty_level3) { struct objc_dtable_level3 *level3; - uint_fast16_t l; + uint16_t l; level3 = malloc(sizeof(struct objc_dtable_level3)); if (level3 == NULL) OBJC_ERROR("Not enough memory to insert into dtable!"); @@ -177,13 +177,13 @@ } void objc_dtable_free(struct objc_dtable *dtable) { - uint_fast16_t i; + uint16_t i; #ifdef OF_SELUID24 - uint_fast16_t j; + uint16_t j; #endif for (i = 0; i < 256; i++) { if (dtable->buckets[i] == empty_level2) continue; Index: src/runtime/runtime-private.h ================================================================== --- src/runtime/runtime-private.h +++ src/runtime/runtime-private.h @@ -106,11 +106,11 @@ struct objc_sparsearray { struct objc_sparsearray_data { void *next[256]; } *data; - uint_fast8_t index_size; + uint8_t index_size; }; struct objc_dtable { struct objc_dtable_level2 { #ifdef OF_SELUID24 @@ -143,11 +143,11 @@ extern void objc_hashtable_delete(struct objc_hashtable*, const void*); extern void objc_hashtable_free(struct objc_hashtable*); extern void objc_register_selector(struct objc_abi_selector*); extern void objc_register_all_selectors(struct objc_abi_symtab*); extern void objc_unregister_all_selectors(void); -extern struct objc_sparsearray* objc_sparsearray_new(uint_fast8_t); +extern struct objc_sparsearray* objc_sparsearray_new(uint8_t); extern void* objc_sparsearray_get(struct objc_sparsearray*, uintptr_t); extern void objc_sparsearray_set(struct objc_sparsearray*, uintptr_t, void*); extern void objc_sparsearray_free(struct objc_sparsearray*); extern struct objc_dtable* objc_dtable_new(void); extern void objc_dtable_copy(struct objc_dtable*, struct objc_dtable*); Index: src/runtime/sparsearray.m ================================================================== --- src/runtime/sparsearray.m +++ src/runtime/sparsearray.m @@ -21,11 +21,11 @@ #import "runtime.h" #import "runtime-private.h" struct objc_sparsearray* -objc_sparsearray_new(uint_fast8_t index_size) +objc_sparsearray_new(uint8_t index_size) { struct objc_sparsearray *sparsearray; if ((sparsearray = calloc(1, sizeof(*sparsearray))) == NULL) OBJC_ERROR("Failed to allocate memory for sparse array!"); @@ -40,11 +40,11 @@ void* objc_sparsearray_get(struct objc_sparsearray *sparsearray, uintptr_t idx) { struct objc_sparsearray_data *iter = sparsearray->data; - uint_fast8_t i; + uint8_t i; for (i = 0; i < sparsearray->index_size - 1; i++) { uintptr_t j = (idx >> ((sparsearray->index_size - i - 1) * 8)) & 0xFF; @@ -58,11 +58,11 @@ void objc_sparsearray_set(struct objc_sparsearray *sparsearray, uintptr_t idx, void *value) { struct objc_sparsearray_data *iter = sparsearray->data; - uint_fast8_t i; + uint8_t i; for (i = 0; i < sparsearray->index_size - 1; i++) { uintptr_t j = (idx >> ((sparsearray->index_size - i - 1) * 8)) & 0xFF; @@ -77,13 +77,13 @@ iter->next[idx & 0xFF] = value; } static void -free_sparsearray_data(struct objc_sparsearray_data *data, uint_fast8_t depth) +free_sparsearray_data(struct objc_sparsearray_data *data, uint8_t depth) { - uint_fast16_t i; + uint16_t i; if (data == NULL || depth == 0) return; for (i = 0; i < 256; i++) Index: utils/ofzip/OFZIP.m ================================================================== --- utils/ofzip/OFZIP.m +++ utils/ofzip/OFZIP.m @@ -44,11 +44,11 @@ # define S_IRWXO 0 #endif @interface OFZIP: OFObject { - int_fast8_t _override, _outputLevel; + int8_t _override, _outputLevel; int _exitStatus; } - (OFZIPArchive*)openArchiveWithPath: (OFString*)path; - (void)listFilesInArchive: (OFZIPArchive*)archive; @@ -328,11 +328,11 @@ OFString *directory; OFStream *stream; OFFile *output; char buffer[BUFFER_SIZE]; uint64_t written = 0, size = [entry uncompressedSize]; - int_fast8_t percent = -1, newPercent; + int8_t percent = -1, newPercent; if (!all && ![files containsObject: fileName]) continue; [missing removeObject: fileName]; @@ -454,11 +454,11 @@ goto outer_loop_end; } written += length; newPercent = (written == size - ? 100 : (int_fast8_t)(written * 100 / size)); + ? 100 : (int8_t)(written * 100 / size)); if (_outputLevel >= 0 && percent != newPercent) { percent = newPercent; [of_stdout writeFormat: