ObjFW  Check-in [44413ada84]

Overview
Comment:Work around GCC being extremely buggy

This includes GCC thinking uint16_t and uint_fast16_t have a different
signedness and pointers to subclasses of OFStream and pointers to
OFStream being incompatible pointer types.

Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA3-256: 44413ada844d55061d242647a5c4425968b3030330bf26399397a0bb546848f9
User & Date: js on 2018-06-03 20:11:18
Other Links: manifest | tags
Context
2018-06-03
20:58
ofzip: LHA: Only try to set a mode if we have one check-in: 54c76965d7 user: js tags: trunk
20:11
Work around GCC being extremely buggy check-in: 44413ada84 user: js tags: trunk
18:15
OFLHAArchive: Support for -lh[4567]- compression check-in: 6cbc2253b8 user: js tags: trunk
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Modified src/OFInflateStream.m from [6dcb1199a3] to [cd213df087].

︙
375
376
377
378
379
380
381
382

383
384
385
386
387
388
389

375
376
377
378
379
380
381

382
383
384
385
386
387
388
389








-
+








			}

			if OF_LIKELY (CTX.lengths == NULL) {
				CTX.lengths = [self allocMemoryWithSize: 19];
				memset(CTX.lengths, 0, 19);
			}

			for (uint_fast16_t i = CTX.receivedCount;
			for (uint16_t i = CTX.receivedCount;
			    i < CTX.codeLenCodesCount + 4; i++) {
				if OF_UNLIKELY (!tryReadBits(self, &bits, 3)) {
					CTX.receivedCount = i;
					return bytesWritten;
				}

				CTX.lengths[codeLengthsOrder[i]] = bits;
︙
399
400
401
402
403
404
405
406

407
408
409
410
411
412
413

399
400
401
402
403
404
405

406
407
408
409
410
411
412
413








-
+








			CTX.value = 0xFF;
		}

		if OF_LIKELY (CTX.lengths == NULL)
			CTX.lengths = [self allocMemoryWithSize:
			    CTX.litLenCodesCount + CTX.distCodesCount + 258];

		for (uint_fast16_t i = CTX.receivedCount;
		for (uint16_t i = CTX.receivedCount;
		    i < CTX.litLenCodesCount + CTX.distCodesCount + 258;) {
			uint8_t j, count;

			if OF_LIKELY (CTX.value == 0xFF) {
				if OF_UNLIKELY (!of_huffman_tree_walk(self,
				    tryReadBits, &CTX.treeIter, &value)) {
					CTX.receivedCount = i;
︙

Modified src/OFLHAArchive.m from [f1be19a9ae] to [9530d9435c].

︙
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272

252
253
254
255
256
257
258


259
260
261


262
263
264
265
266
267
268








-
-



-
-








			entry: _lastEntry];

	return [[_lastEntry copy] autorelease];
}

- (OFStream <OFReadyForReadingObserving> *)streamForReadingCurrentEntry
{
	OFString *method;

	if (_lastReturnedStream == nil)
		@throw [OFInvalidArgumentException exception];

	method = [_lastEntry method];

	return [[_lastReturnedStream retain] autorelease];
}

- (void)close
{
	if (_stream == nil)
		return;
︙
451
452
453
454
455
456
457
458

459
460
461
462
463
464
465

447
448
449
450
451
452
453

454
455
456
457
458
459
460
461








-
+









		_treeIter = _codeLenTree;
		_state = STATE_LITLEN_TREE;
		goto start;
	case STATE_LITLEN_TREE:
		while (_codesReceived < _codesCount) {
			if OF_UNLIKELY (_skip) {
				uint_fast16_t skipCount;
				uint16_t skipCount;

				switch (_codesLengths[_codesReceived]) {
				case 0:
					skipCount = 1;
					break;
				case 1:
					if OF_UNLIKELY (!tryReadBits(self,
︙
480
481
482
483
484
485
486
487

488
489
490
491
492
493
494

476
477
478
479
480
481
482

483
484
485
486
487
488
489
490








-
+








				}

				if OF_UNLIKELY (_codesReceived + skipCount >
				    _codesCount)
					@throw [OFInvalidFormatException
					    exception];

				for (uint16_t j = 0; j < skipCount; j++)
				for (uint_fast16_t j = 0; j < skipCount; j++)
					_codesLengths[_codesReceived++] = 0;

				_skip = false;
				continue;
			}

			if (!of_huffman_tree_walk(self, tryReadBits,
︙
678
679
680
681
682
683
684


685
686
687
688
689
690
691

674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689








+
+









		_symbolsLeft--;

		_treeIter = _litLenTree;
		_state = STATE_BLOCK_LITLEN;
		goto start;
	}

	OF_UNREACHABLE
}

- (bool)lowlevelIsAtEndOfStream
{
	if (_stream == nil)
		@throw [OFNotOpenException exceptionWithObject: self];
︙

Modified src/huffman_tree.h from [d01cbc1eac] to [11f24074b8].

︙
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


41
42
43
44
45
46
47

18
19
20
21
22
23
24


25
26
27
28
29
30
31
32
33
34
35
36


37
38
39
40
41
42
43
44
45








-
-












-
-
+
+








#include <stdbool.h>
#include <stdint.h>

#import "macros.h"

OF_ASSUME_NONNULL_BEGIN

@class OFStream;

struct of_huffman_tree {
	struct of_huffman_tree *_Nullable leaves[2];
	uint16_t value;
};

#ifdef __cplusplus
extern "C" {
#endif
extern struct of_huffman_tree *_Nonnull of_huffman_tree_construct(
    uint8_t lengths[_Nonnull], uint16_t count);
extern struct of_huffman_tree *_Nonnull of_huffman_tree_construct_single(
    uint16_t value);
extern bool of_huffman_tree_walk(OFStream *_Nullable stream,
    bool (*bitReader)(OFStream *_Nullable, uint16_t *_Nonnull, uint8_t),
extern bool of_huffman_tree_walk(id _Nullable stream,
    bool (*bitReader)(id _Nullable, uint16_t *_Nonnull, uint8_t),
    struct of_huffman_tree *_Nonnull *_Nonnull tree, uint16_t *_Nonnull value);
extern void of_huffman_tree_release(struct of_huffman_tree *_Nonnull tree);
#ifdef __cplusplus
}
#endif

OF_ASSUME_NONNULL_END

Modified src/huffman_tree.m from [44d960865e] to [d14cb85d84].

︙
107
108
109
110
111
112
113
114

115
116
117
118
119
120
121
122

107
108
109
110
111
112
113

114

115
116
117
118
119
120
121








-
+
-









	tree->value = value;

	return tree;
}

bool
of_huffman_tree_walk(OFStream *stream,
of_huffman_tree_walk(id stream, bool (*bitReader)(id, uint16_t *, uint8_t),
    bool (*bitReader)(OFStream *, uint16_t *, uint8_t),
    struct of_huffman_tree **tree, uint16_t *value)
{
	struct of_huffman_tree *iter = *tree;
	uint16_t bits;

	while (iter->value == 0xFFFF) {
		if OF_UNLIKELY (!bitReader(stream, &bits, 1)) {
︙

Fossil 2.23 [47362306a7] 2023-11-01 18:56:47
This page was generated in about 0.022s