Comment: | Prefix private methods with of_ instead of OF_
This matches Apple's style. |
---|---|
Downloads: | Tarball | ZIP archive | SQL archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA3-256: |
6b77a5dd8b2caa343b959a6e42327d6e |
User & Date: | js on 2017-05-21 21:28:57 |
Other Links: | manifest | tags |
2017-05-21
| ||
21:33 | OFThreadPool: Fix missing autorelease pool check-in: 9558a93c7e user: js tags: trunk | |
21:28 | Prefix private methods with of_ instead of OF_ check-in: 6b77a5dd8b user: js tags: trunk | |
20:19 | Readd autogen.sh check-in: fa610dee8f user: js tags: trunk | |
Modified src/OFApplication.m from [2ce5c50064] to [e40754826f].
︙ | ︙ | |||
64 65 66 67 68 69 70 | #ifdef HAVE_SIGACTION # ifndef SA_RESTART # define SA_RESTART 0 # endif #endif @interface OFApplication () | | | | | | 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 | #ifdef HAVE_SIGACTION # ifndef SA_RESTART # define SA_RESTART 0 # endif #endif @interface OFApplication () - (instancetype)of_init OF_METHOD_FAMILY(init); - (void)of_setArgumentCount: (int *)argc andArgumentValues: (char **[])argv; #ifdef OF_WINDOWS - (void)of_setArgumentCount: (int)argc andWideArgumentValues: (wchar_t *[])argv; #endif - (void)of_run; @end static OFApplication *app = nil; static void atexitHandler(void) { |
︙ | ︙ | |||
127 128 129 130 131 132 133 | "application delegate!\n Most likely, you wanted to " "subclass OFObject instead or specified\n the wrong class " "with OF_APPLICATION_DELEGATE().\n", class_getName(cls), class_getName(cls)); exit(1); } | | | | | | 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 | "application delegate!\n Most likely, you wanted to " "subclass OFObject instead or specified\n the wrong class " "with OF_APPLICATION_DELEGATE().\n", class_getName(cls), class_getName(cls)); exit(1); } app = [[OFApplication alloc] of_init]; [app of_setArgumentCount: argc andArgumentValues: argv]; #ifdef OF_WINDOWS __wgetmainargs(&wargc, &wargv, &wenvp, _CRT_glob, &si); [app of_setArgumentCount: wargc andWideArgumentValues: wargv]; #endif delegate = [[cls alloc] init]; [app setDelegate: delegate]; [app of_run]; [delegate release]; return 0; } @implementation OFApplication |
︙ | ︙ | |||
202 203 204 205 206 207 208 | #endif - init { OF_INVALID_INIT_METHOD } | | | 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 | #endif - init { OF_INVALID_INIT_METHOD } - of_init { self = [super init]; @try { void *pool; OFMutableDictionary *environment; #if defined(OF_MACOS) |
︙ | ︙ | |||
361 362 363 364 365 366 367 | { [_arguments release]; [_environment release]; [super dealloc]; } | | | 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 | { [_arguments release]; [_environment release]; [super dealloc]; } - (void)of_setArgumentCount: (int *)argc andArgumentValues: (char ***)argv { #ifndef OF_WINDOWS void *pool = objc_autoreleasePoolPush(); OFMutableArray *arguments; of_string_encoding_t encoding; |
︙ | ︙ | |||
401 402 403 404 405 406 407 | #else _argc = argc; _argv = argv; #endif } #ifdef OF_WINDOWS | | | 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 | #else _argc = argc; _argv = argv; #endif } #ifdef OF_WINDOWS - (void)of_setArgumentCount: (int)argc andWideArgumentValues: (wchar_t **)argv { void *pool = objc_autoreleasePoolPush(); OFMutableArray *arguments; if (argc > 0) { _programName = [[OFString alloc] initWithUTF16String: argv[0]]; |
︙ | ︙ | |||
481 482 483 484 485 486 487 | #ifdef SIGUSR2 REGISTER_SIGNAL(SIGUSR2) #endif #undef REGISTER_SIGNAL } | | | | | | 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 | #ifdef SIGUSR2 REGISTER_SIGNAL(SIGUSR2) #endif #undef REGISTER_SIGNAL } - (void)of_run { void *pool = objc_autoreleasePoolPush(); OFRunLoop *runLoop; #ifdef OF_HAVE_THREADS [OFThread of_createMainThread]; runLoop = [OFRunLoop currentRunLoop]; #else runLoop = [[[OFRunLoop alloc] init] autorelease]; #endif [OFRunLoop of_setMainRunLoop: runLoop]; objc_autoreleasePoolPop(pool); /* * Note: runLoop is still valid after the release of the pool, as * of_setMainRunLoop: retained it. However, we only have a weak * reference to it now, whereas we had a strong reference before. */ pool = objc_autoreleasePoolPush(); [_delegate applicationDidFinishLaunching]; objc_autoreleasePoolPop(pool); |
︙ | ︙ |
Modified src/OFArray.m from [acebabe718] to [75d72d0a96].
︙ | ︙ | |||
34 35 36 37 38 39 40 | #import "OFOutOfRangeException.h" static struct { Class isa; } placeholder; @interface OFArray () | | | 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 | #import "OFOutOfRangeException.h" static struct { Class isa; } placeholder; @interface OFArray () - (OFString *)of_JSONRepresentationWithOptions: (int)options depth: (size_t)depth; @end @interface OFArray_placeholder: OFArray @end @implementation OFArray_placeholder |
︙ | ︙ | |||
584 585 586 587 588 589 590 | objc_autoreleasePoolPop(pool); return [element autorelease]; } - (OFString *)JSONRepresentation { | | | | | 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 | objc_autoreleasePoolPop(pool); return [element autorelease]; } - (OFString *)JSONRepresentation { return [self of_JSONRepresentationWithOptions: 0 depth: 0]; } - (OFString *)JSONRepresentationWithOptions: (int)options { return [self of_JSONRepresentationWithOptions: options depth: 0]; } - (OFString *)of_JSONRepresentationWithOptions: (int)options depth: (size_t)depth { OFMutableString *JSON = [OFMutableString stringWithString: @"["]; void *pool = objc_autoreleasePoolPush(); size_t i, count = [self count]; if (options & OF_JSON_REPRESENTATION_PRETTY) { |
︙ | ︙ | |||
616 617 618 619 620 621 622 | i = 0; for (id object in self) { void *pool2 = objc_autoreleasePoolPush(); [JSON appendString: indentation]; [JSON appendString: @"\t"]; [JSON appendString: [object | | | | 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 | i = 0; for (id object in self) { void *pool2 = objc_autoreleasePoolPush(); [JSON appendString: indentation]; [JSON appendString: @"\t"]; [JSON appendString: [object of_JSONRepresentationWithOptions: options depth: depth + 1]]; if (++i < count) [JSON appendString: @",\n"]; else [JSON appendString: @"\n"]; objc_autoreleasePoolPop(pool2); } [JSON appendString: indentation]; } else { i = 0; for (id object in self) { void *pool2 = objc_autoreleasePoolPush(); [JSON appendString: [object of_JSONRepresentationWithOptions: options depth: depth + 1]]; if (++i < count) [JSON appendString: @","]; objc_autoreleasePoolPop(pool2); } |
︙ | ︙ |
Modified src/OFAutoreleasePool+Private.h from [9960e42a45] to [d007f32574].
︙ | ︙ | |||
15 16 17 18 19 20 21 | */ #import "OFAutoreleasePool.h" OF_ASSUME_NONNULL_BEGIN @interface OFAutoreleasePool () | | | | 15 16 17 18 19 20 21 22 23 24 25 26 | */ #import "OFAutoreleasePool.h" OF_ASSUME_NONNULL_BEGIN @interface OFAutoreleasePool () + (void)of_handleThreadTermination; - (void)of_super_dealloc; @end OF_ASSUME_NONNULL_END |
Modified src/OFAutoreleasePool.m from [d441366c61] to [e9bf9ceb4f].
︙ | ︙ | |||
68 69 70 71 72 73 74 | } + (id)addObject: (id)object { return _objc_rootAutorelease(object); } | | | | 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 | } + (id)addObject: (id)object { return _objc_rootAutorelease(object); } + (void)of_handleThreadTermination { #if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS) OFAutoreleasePool **cache = of_tlskey_get(cacheKey); #endif if (cache != NULL) { for (size_t i = 0; i < MAX_CACHE_SIZE; i++) [cache[i] of_super_dealloc]; free(cache); cache = NULL; } } - init |
︙ | ︙ | |||
121 122 123 124 125 126 127 | } - (void)drain { [self dealloc]; } | | | 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 | } - (void)drain { [self dealloc]; } - (void)of_super_dealloc { [super dealloc]; } - (void)dealloc { #if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS) |
︙ | ︙ |
Modified src/OFDataArray+CryptoHashing.m from [07e9d87070] to [7a19dd94a4].
︙ | ︙ | |||
26 27 28 29 30 31 32 | #import "OFSHA256Hash.h" #import "OFSHA384Hash.h" #import "OFSHA512Hash.h" int _OFDataArray_CryptoHashing_reference; @implementation OFDataArray (Hashing) | | | 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | #import "OFSHA256Hash.h" #import "OFSHA384Hash.h" #import "OFSHA512Hash.h" int _OFDataArray_CryptoHashing_reference; @implementation OFDataArray (Hashing) - (OFString *)of_cryptoHashWithClass: (Class <OFCryptoHash>)class { void *pool = objc_autoreleasePoolPush(); id <OFCryptoHash> hash = [class cryptoHash]; size_t digestSize = [class digestSize]; const unsigned char *digest; char cString[digestSize * 2]; |
︙ | ︙ | |||
57 58 59 60 61 62 63 | return [OFString stringWithCString: cString encoding: OF_STRING_ENCODING_ASCII length: digestSize * 2]; } - (OFString *)MD5Hash { | | | | | | | | | 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 | return [OFString stringWithCString: cString encoding: OF_STRING_ENCODING_ASCII length: digestSize * 2]; } - (OFString *)MD5Hash { return [self of_cryptoHashWithClass: [OFMD5Hash class]]; } - (OFString *)RIPEMD160Hash { return [self of_cryptoHashWithClass: [OFRIPEMD160Hash class]]; } - (OFString *)SHA1Hash { return [self of_cryptoHashWithClass: [OFSHA1Hash class]]; } - (OFString *)SHA224Hash { return [self of_cryptoHashWithClass: [OFSHA224Hash class]]; } - (OFString *)SHA256Hash { return [self of_cryptoHashWithClass: [OFSHA256Hash class]]; } - (OFString *)SHA384Hash { return [self of_cryptoHashWithClass: [OFSHA384Hash class]]; } - (OFString *)SHA512Hash { return [self of_cryptoHashWithClass: [OFSHA512Hash class]]; } @end |
Modified src/OFDeflateStream.m from [be9beadf26] to [95db2a693c].
︙ | ︙ | |||
59 60 61 62 63 64 65 | struct huffman_tree { struct huffman_tree *leafs[2]; uint16_t value; }; @interface OFDeflateStream () | | | 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 | struct huffman_tree { struct huffman_tree *leafs[2]; uint16_t value; }; @interface OFDeflateStream () - (void)of_initDecompression; @end #ifndef DEFLATE64 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, |
︙ | ︙ | |||
322 323 324 325 326 327 328 | releaseTree(_decompression->context.huffman.distTree); } [super dealloc]; } #endif | | | 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 | releaseTree(_decompression->context.huffman.distTree); } [super dealloc]; } #endif - (void)of_initDecompression { _decompression = [self allocMemoryWithSize: sizeof(*_decompression)]; memset(_decompression, 0, sizeof(*_decompression)); /* 0-7 address the bit, 8 means fetch next byte */ _decompression->bitIndex = 8; #ifdef DEFLATE64 |
︙ | ︙ | |||
348 349 350 351 352 353 354 | uint16_t bits, tmp; uint16_t value; size_t bytesWritten = 0; uint8_t *slidingWindow; uint16_t slidingWindowIndex; if (ivars == NULL) { | | | 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 | uint16_t bits, tmp; uint16_t value; size_t bytesWritten = 0; uint8_t *slidingWindow; uint16_t slidingWindowIndex; if (ivars == NULL) { [self of_initDecompression]; ivars = _decompression; } if (ivars->atEndOfStream) @throw [OFReadFailedException exceptionWithObject: self requestedLength: length]; |
︙ | ︙ |
Modified src/OFDictionary.m from [0862e86c30] to [d620b3bd51].
︙ | ︙ | |||
32 33 34 35 36 37 38 | #import "OFUndefinedKeyException.h" static struct { Class isa; } placeholder; @interface OFDictionary () | | | 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 | #import "OFUndefinedKeyException.h" static struct { Class isa; } placeholder; @interface OFDictionary () - (OFString *)of_JSONRepresentationWithOptions: (int)options depth: (size_t)depth; @end @interface OFDictionary_placeholder: OFDictionary @end @implementation OFDictionary_placeholder |
︙ | ︙ | |||
612 613 614 615 616 617 618 | objc_autoreleasePoolPop(pool); return [element autorelease]; } - (OFString *)JSONRepresentation { | | | | | | 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 | objc_autoreleasePoolPop(pool); return [element autorelease]; } - (OFString *)JSONRepresentation { return [self of_JSONRepresentationWithOptions: 0 depth: 0]; } - (OFString *)JSONRepresentationWithOptions: (int)options { return [self of_JSONRepresentationWithOptions: options depth: 0]; } - (OFString *)of_JSONRepresentationWithOptions: (int)options depth: (size_t)depth { OFMutableString *JSON = [OFMutableString stringWithString: @"{"]; void *pool = objc_autoreleasePoolPush(); OFEnumerator *keyEnumerator = [self keyEnumerator]; OFEnumerator *objectEnumerator = [self objectEnumerator]; size_t i, count = [self count]; id key, object; |
︙ | ︙ | |||
653 654 655 656 657 658 659 | if (![key isKindOfClass: [OFString class]]) @throw [OFInvalidArgumentException exception]; [JSON appendString: indentation]; [JSON appendString: @"\t"]; [JSON appendString: [key | | | | 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 | if (![key isKindOfClass: [OFString class]]) @throw [OFInvalidArgumentException exception]; [JSON appendString: indentation]; [JSON appendString: @"\t"]; [JSON appendString: [key of_JSONRepresentationWithOptions: identifierOptions depth: depth + 1]]; [JSON appendString: @": "]; [JSON appendString: [object of_JSONRepresentationWithOptions: options depth: depth + 1]]; if (++i < count) [JSON appendString: @",\n"]; else [JSON appendString: @"\n"]; |
︙ | ︙ | |||
681 682 683 684 685 686 687 | int identifierOptions = options | OF_JSON_REPRESENTATION_IDENTIFIER; if (![key isKindOfClass: [OFString class]]) @throw [OFInvalidArgumentException exception]; [JSON appendString: [key | | | | 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 | int identifierOptions = options | OF_JSON_REPRESENTATION_IDENTIFIER; if (![key isKindOfClass: [OFString class]]) @throw [OFInvalidArgumentException exception]; [JSON appendString: [key of_JSONRepresentationWithOptions: identifierOptions depth: depth + 1]]; [JSON appendString: @":"]; [JSON appendString: [object of_JSONRepresentationWithOptions: options depth: depth + 1]]; if (++i < count) [JSON appendString: @","]; objc_autoreleasePoolPop(pool2); } |
︙ | ︙ |
Modified src/OFHTTPClient.m from [8ee3bb44d0] to [530dbe6279].
︙ | ︙ | |||
66 67 68 69 70 71 72 73 | @interface OFHTTPClientResponse: OFHTTPResponse { OFTCPSocket *_socket; bool _hasContentLength, _chunked, _keepAlive, _atEndOfStream; size_t _toRead; } - initWithSocket: (OFTCPSocket *)socket; | > > < > > < < < < < | 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 | @interface OFHTTPClientResponse: OFHTTPResponse { OFTCPSocket *_socket; bool _hasContentLength, _chunked, _keepAlive, _atEndOfStream; size_t _toRead; } @property (nonatomic, setter=of_setKeepAlive:) bool of_keepAlive; - initWithSocket: (OFTCPSocket *)socket; @end @implementation OFHTTPClientResponse @synthesize of_keepAlive = _keepAlive; - initWithSocket: (OFTCPSocket *)socket { self = [super init]; _socket = [socket retain]; return self; } - (void)dealloc { [_socket release]; [super dealloc]; } |
︙ | ︙ | |||
279 280 281 282 283 284 285 | - (OFHTTPResponse *)performRequest: (OFHTTPRequest *)request { return [self performRequest: request redirects: 10]; } | | | 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 | - (OFHTTPResponse *)performRequest: (OFHTTPRequest *)request { return [self performRequest: request redirects: 10]; } - (OFTCPSocket *)of_closeAndCreateSocketForRequest: (OFHTTPRequest *)request { OFURL *URL = [request URL]; OFTCPSocket *socket; [self close]; if ([[URL scheme] isEqual: @"https"]) { |
︙ | ︙ | |||
365 366 367 368 369 370 371 | } } } @finally { [_lastResponse release]; _lastResponse = nil; } } else | | | 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 | } } } @finally { [_lastResponse release]; _lastResponse = nil; } } else socket = [self of_closeAndCreateSocketForRequest: request]; /* * As a work around for a bug with split packets in lighttpd when using * HTTPS, we construct the complete request in a buffer string and then * send it all at once. * * We do not use the socket's write buffer in case we need to resend |
︙ | ︙ | |||
472 473 474 475 476 477 478 | @try { [socket writeString: requestString]; } @catch (OFWriteFailedException *e) { if ([e errNo] != ECONNRESET && [e errNo] != EPIPE) @throw e; /* Reconnect in case a keep-alive connection timed out */ | | | | 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 | @try { [socket writeString: requestString]; } @catch (OFWriteFailedException *e) { if ([e errNo] != ECONNRESET && [e errNo] != EPIPE) @throw e; /* Reconnect in case a keep-alive connection timed out */ socket = [self of_closeAndCreateSocketForRequest: request]; [socket writeString: requestString]; } if (body != nil) [socket writeBuffer: [body items] length: [body count] * [body itemSize]]; @try { line = [socket readLine]; } @catch (OFInvalidEncodingException *e) { @throw [OFInvalidServerReplyException exception]; } /* * It's possible that the write succeeds on a connection that is * keep-alive, but the connection has already been closed by the remote * end due to a timeout. In this case, we need to reconnect. */ if (line == nil) { socket = [self of_closeAndCreateSocketForRequest: request]; [socket writeString: requestString]; if (body != nil) [socket writeBuffer: [body items] length: [body count] * [body itemSize]]; |
︙ | ︙ | |||
603 604 605 606 607 608 609 | keepAlive = ([connectionHeader caseInsensitiveCompare: @"keep-alive"] == OF_ORDERED_SAME); else keepAlive = false; } if (keepAlive) { | | | 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 | keepAlive = ([connectionHeader caseInsensitiveCompare: @"keep-alive"] == OF_ORDERED_SAME); else keepAlive = false; } if (keepAlive) { [response of_setKeepAlive: true]; _socket = [socket retain]; _lastURL = [URL copy]; _lastWasHEAD = (method == OF_HTTP_REQUEST_METHOD_HEAD); _lastResponse = [response retain]; } |
︙ | ︙ |
Modified src/OFHTTPServer.m from [6f3529bdbf] to [4d2868ce13].
︙ | ︙ | |||
43 44 45 46 47 48 49 | /* * FIXME: Key normalization replaces headers like "DNT" with "Dnt". * FIXME: Errors are not reported to the user. */ @interface OFHTTPServer () | | | 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 | /* * FIXME: Key normalization replaces headers like "DNT" with "Dnt". * FIXME: Errors are not reported to the user. */ @interface OFHTTPServer () - (bool)of_socket: (OFTCPSocket *)socket didAcceptSocket: (OFTCPSocket *)clientSocket exception: (OFException *)exception; @end static const char * statusCodeToString(short code) { |
︙ | ︙ | |||
206 207 208 209 210 211 212 | [_server release]; [_request release]; [super dealloc]; } | | | 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 | [_server release]; [_request release]; [super dealloc]; } - (void)of_sendHeaders { void *pool = objc_autoreleasePoolPush(); OFMutableDictionary OF_GENERIC(OFString *, OFString *) *headers; OFEnumerator *keyEnumerator, *valueEnumerator; OFString *key, *value; [_socket writeFormat: @"HTTP/%@ %d %s\r\n", |
︙ | ︙ | |||
259 260 261 262 263 264 265 | { void *pool; if (_socket == nil) @throw [OFNotOpenException exceptionWithObject: self]; if (!_headersSent) | | | 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 | { void *pool; if (_socket == nil) @throw [OFNotOpenException exceptionWithObject: self]; if (!_headersSent) [self of_sendHeaders]; if (!_chunked) { [_socket writeBuffer: buffer length: length]; return; } |
︙ | ︙ | |||
284 285 286 287 288 289 290 | - (void)close { if (_socket == nil) @throw [OFNotOpenException exceptionWithObject: self]; @try { if (!_headersSent) | | | 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 | - (void)close { if (_socket == nil) @throw [OFNotOpenException exceptionWithObject: self]; @try { if (!_headersSent) [self of_sendHeaders]; if (_chunked) [_socket writeBuffer: "0\r\n\r\n" length: 5]; } @catch (OFWriteFailedException *e) { id <OFHTTPServerDelegate> delegate = [_server delegate]; |
︙ | ︙ | |||
715 716 717 718 719 720 721 | _listeningSocket = [[OFTCPSocket alloc] init]; _port = [_listeningSocket bindToHost: _host port: _port]; [_listeningSocket listen]; [_listeningSocket asyncAcceptWithTarget: self | | | | 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 | _listeningSocket = [[OFTCPSocket alloc] init]; _port = [_listeningSocket bindToHost: _host port: _port]; [_listeningSocket listen]; [_listeningSocket asyncAcceptWithTarget: self selector: @selector(of_socket: didAcceptSocket: exception:)]; } - (void)stop { [_listeningSocket cancelAsyncRequests]; [_listeningSocket release]; _listeningSocket = nil; } - (bool)of_socket: (OFTCPSocket *)socket didAcceptSocket: (OFTCPSocket *)clientSocket exception: (OFException *)exception { OFHTTPServer_Connection *connection; if (exception != nil) { if ([_delegate respondsToSelector: |
︙ | ︙ |
Modified src/OFINICategory+Private.h from [9eccb1bef3] to [59ee9ce154].
︙ | ︙ | |||
18 19 20 21 22 23 24 | #import "OFString.h" OF_ASSUME_NONNULL_BEGIN @class OFStream; @interface OFINICategory () | | | | | 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | #import "OFString.h" OF_ASSUME_NONNULL_BEGIN @class OFStream; @interface OFINICategory () - (instancetype)of_init OF_METHOD_FAMILY(init); - (void)of_parseLine: (OFString *)line; - (bool)of_writeToStream: (OFStream *)stream encoding: (of_string_encoding_t)encoding first: (bool)first; @end OF_ASSUME_NONNULL_END |
Modified src/OFINICategory.m from [0b4fba9171] to [4c38694599].
︙ | ︙ | |||
117 118 119 120 121 122 123 | [super dealloc]; } @end @implementation OFINICategory @synthesize name = _name; | | | 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 | [super dealloc]; } @end @implementation OFINICategory @synthesize name = _name; - (instancetype)of_init { self = [super init]; @try { _lines = [[OFMutableArray alloc] init]; } @catch (id e) { [self release]; |
︙ | ︙ | |||
144 145 146 147 148 149 150 | { [_name release]; [_lines release]; [super dealloc]; } | | | 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 | { [_name release]; [_lines release]; [super dealloc]; } - (void)of_parseLine: (OFString *)line { if (![line hasPrefix: @";"]) { OFINICategory_Pair *pair = [[[OFINICategory_Pair alloc] init] autorelease]; OFString *key, *value; size_t pos; |
︙ | ︙ | |||
485 486 487 488 489 490 491 | continue; } } objc_autoreleasePoolPop(pool); } | | | 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 | continue; } } objc_autoreleasePoolPop(pool); } - (bool)of_writeToStream: (OFStream *)stream encoding: (of_string_encoding_t)encoding first: (bool)first { if ([_lines count] == 0) return false; if (first) |
︙ | ︙ |
Modified src/OFINIFile.m from [8890f1cc69] to [6eaed9a153].
︙ | ︙ | |||
25 26 27 28 29 30 31 | #import "OFINICategory.h" #import "OFINICategory+Private.h" #import "OFInvalidFormatException.h" #import "OFOpenItemFailedException.h" @interface OFINIFile () | | | 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | #import "OFINICategory.h" #import "OFINICategory+Private.h" #import "OFInvalidFormatException.h" #import "OFOpenItemFailedException.h" @interface OFINIFile () - (void)of_parseFile: (OFString *)path encoding: (of_string_encoding_t)encoding; @end static bool isWhitespaceLine(OFString *line) { const char *cString = [line UTF8String]; |
︙ | ︙ | |||
82 83 84 85 86 87 88 | encoding: (of_string_encoding_t)encoding { self = [super init]; @try { _categories = [[OFMutableArray alloc] init]; | | | 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 | encoding: (of_string_encoding_t)encoding { self = [super init]; @try { _categories = [[OFMutableArray alloc] init]; [self of_parseFile: path encoding: encoding]; } @catch (id e) { [self release]; @throw e; } return self; |
︙ | ︙ | |||
108 109 110 111 112 113 114 | void *pool = objc_autoreleasePoolPush(); OFINICategory *category; for (category in _categories) if ([[category name] isEqual: name]) return category; | | | | 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 | void *pool = objc_autoreleasePoolPush(); OFINICategory *category; for (category in _categories) if ([[category name] isEqual: name]) return category; category = [[[OFINICategory alloc] of_init] autorelease]; [category setName: name]; [_categories addObject: category]; objc_autoreleasePoolPop(pool); return category; } - (void)of_parseFile: (OFString *)path encoding: (of_string_encoding_t)encoding { void *pool = objc_autoreleasePoolPush(); OFFile *file; OFINICategory *category = nil; OFString *line; |
︙ | ︙ | |||
150 151 152 153 154 155 156 | if (![line hasSuffix: @"]"]) @throw [OFInvalidFormatException exception]; categoryName = [line substringWithRange: of_range(1, [line length] - 2)]; category = [[[OFINICategory alloc] | | | | 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 | if (![line hasSuffix: @"]"]) @throw [OFInvalidFormatException exception]; categoryName = [line substringWithRange: of_range(1, [line length] - 2)]; category = [[[OFINICategory alloc] of_init] autorelease]; [category setName: categoryName]; [_categories addObject: category]; } else { if (category == nil) @throw [OFInvalidFormatException exception]; [category of_parseLine: line]; } } objc_autoreleasePoolPop(pool); } - (void)writeToFile: (OFString *)path |
︙ | ︙ | |||
179 180 181 182 183 184 185 | { void *pool = objc_autoreleasePoolPush(); OFFile *file = [OFFile fileWithPath: path mode: @"w"]; bool first = true; for (OFINICategory *category in _categories) | | | 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 | { void *pool = objc_autoreleasePoolPush(); OFFile *file = [OFFile fileWithPath: path mode: @"w"]; bool first = true; for (OFINICategory *category in _categories) if ([category of_writeToStream: file encoding: encoding first: first]) first = false; objc_autoreleasePoolPop(pool); } @end |
Modified src/OFIntrospection.m from [46193e4da0] to [0844281f73].
︙ | ︙ | |||
29 30 31 32 33 34 35 | - init { OF_INVALID_INIT_METHOD } #if defined(OF_OBJFW_RUNTIME) | | | | 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 | - init { OF_INVALID_INIT_METHOD } #if defined(OF_OBJFW_RUNTIME) - (instancetype)of_initWithMethod: (struct objc_method *)method { self = [super init]; @try { _selector = (SEL)&method->sel; _name = [[OFString alloc] initWithUTF8String: sel_getName(_selector)]; _typeEncoding = method->sel.types; } @catch (id e) { [self release]; @throw e; } return self; } #elif defined(OF_APPLE_RUNTIME) - (instancetype)of_initWithMethod: (Method)method { self = [super init]; @try { _selector = method_getName(method); _name = [[OFString alloc] initWithUTF8String: sel_getName(_selector)]; |
︙ | ︙ | |||
136 137 138 139 140 141 142 | - init { OF_INVALID_INIT_METHOD } #if defined(OF_OBJFW_RUNTIME) | | | 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 | - init { OF_INVALID_INIT_METHOD } #if defined(OF_OBJFW_RUNTIME) - (instancetype)of_initWithProperty: (struct objc_property *)property { self = [super init]; @try { _name = [[OFString alloc] initWithUTF8String: property->name]; _attributes = property->attributes | (property->extended_attributes << 8); |
︙ | ︙ | |||
159 160 161 162 163 164 165 | [self release]; @throw e; } return self; } #elif defined(OF_APPLE_RUNTIME) | | | 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 | [self release]; @throw e; } return self; } #elif defined(OF_APPLE_RUNTIME) - (instancetype)of_initWithProperty: (objc_property_t)property { self = [super init]; @try { const char *attributes; _name = [[OFString alloc] |
︙ | ︙ | |||
362 363 364 365 366 367 368 | - init { OF_INVALID_INIT_METHOD } #if defined(OF_OBJFW_RUNTIME) | | | | 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 | - init { OF_INVALID_INIT_METHOD } #if defined(OF_OBJFW_RUNTIME) - (instancetype)of_initWithIvar: (struct objc_ivar *)ivar { self = [super init]; @try { _name = [[OFString alloc] initWithUTF8String: ivar->name]; _typeEncoding = ivar->type; _offset = ivar->offset; } @catch (id e) { [self release]; @throw e; } return self; } #elif defined(OF_APPLE_RUNTIME) - (instancetype)of_initWithIvar: (Ivar)ivar { self = [super init]; @try { _name = [[OFString alloc] initWithUTF8String: ivar_getName(ivar)]; _typeEncoding = ivar_getTypeEncoding(ivar); |
︙ | ︙ | |||
455 456 457 458 459 460 461 | #if defined(OF_OBJFW_RUNTIME) for (methodList = object_getClass(class)->methodlist; methodList != NULL; methodList = methodList->next) { pool = objc_autoreleasePoolPush(); for (unsigned int i = 0; i < methodList->count; i++) [_classMethods addObject: [[[OFMethod alloc] | | | | | | | | | | 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 | #if defined(OF_OBJFW_RUNTIME) for (methodList = object_getClass(class)->methodlist; methodList != NULL; methodList = methodList->next) { pool = objc_autoreleasePoolPush(); for (unsigned int i = 0; i < methodList->count; i++) [_classMethods addObject: [[[OFMethod alloc] of_initWithMethod: &methodList->methods[i]] autorelease]]; objc_autoreleasePoolPop(pool); } for (methodList = class->methodlist; methodList != NULL; methodList = methodList->next) { pool = objc_autoreleasePoolPush(); for (unsigned int i = 0; i < methodList->count; i++) [_instanceMethods addObject: [[[OFMethod alloc] of_initWithMethod: &methodList->methods[i]] autorelease]]; objc_autoreleasePoolPop(pool); } for (propertyList = class->properties; propertyList != NULL; propertyList = propertyList->next) { pool = objc_autoreleasePoolPush(); for (unsigned int i = 0; i < propertyList->count; i++) [_properties addObject: [[[OFProperty alloc] of_initWithProperty: &propertyList->properties[i]] autorelease]]; objc_autoreleasePoolPop(pool); } if (class->ivars != NULL) { pool = objc_autoreleasePoolPush(); for (unsigned int i = 0; i < class->ivars->count; i++) [_instanceVariables addObject: [[[OFInstanceVariable alloc] of_initWithIvar: &class->ivars->ivars[i]] autorelease]]; objc_autoreleasePoolPop(pool); } #elif defined(OF_APPLE_RUNTIME) methodList = class_copyMethodList(object_getClass(class), &count); @try { pool = objc_autoreleasePoolPush(); for (unsigned int i = 0; i < count; i++) [_classMethods addObject: [[[OFMethod alloc] of_initWithMethod: methodList[i]] autorelease]]; objc_autoreleasePoolPop(pool); } @finally { free(methodList); } methodList = class_copyMethodList(class, &count); @try { pool = objc_autoreleasePoolPush(); for (unsigned int i = 0; i < count; i++) [_instanceMethods addObject: [[[OFMethod alloc] of_initWithMethod: methodList[i]] autorelease]]; objc_autoreleasePoolPop(pool); } @finally { free(methodList); } propertyList = class_copyPropertyList(class, &count); @try { pool = objc_autoreleasePoolPush(); for (unsigned int i = 0; i < count; i++) [_properties addObject: [[[OFProperty alloc] of_initWithProperty: propertyList[i]] autorelease]]; objc_autoreleasePoolPop(pool); } @finally { free(propertyList); } ivarList = class_copyIvarList(class, &count); @try { pool = objc_autoreleasePoolPush(); for (unsigned int i = 0; i < count; i++) [_instanceVariables addObject: [[[OFInstanceVariable alloc] of_initWithIvar: ivarList[i]] autorelease]]; objc_autoreleasePoolPop(pool); } @finally { free(ivarList); } #else # error Invalid ObjC runtime! |
︙ | ︙ |
Modified src/OFKernelEventObserver+Private.h from [63b9067ddf] to [2e13c9e416].
︙ | ︙ | |||
15 16 17 18 19 20 21 | */ #import "OFKernelEventObserver.h" OF_ASSUME_NONNULL_BEGIN @interface OFKernelEventObserver () | | | | | | | | 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | */ #import "OFKernelEventObserver.h" OF_ASSUME_NONNULL_BEGIN @interface OFKernelEventObserver () - (void)of_addObjectForReading: (id <OFReadyForReadingObserving>)object; - (void)of_addObjectForWriting: (id <OFReadyForWritingObserving>)object; - (void)of_removeObjectForReading: (id <OFReadyForReadingObserving>)object; - (void)of_removeObjectForWriting: (id <OFReadyForWritingObserving>)object; - (void)of_processQueue; - (bool)of_processReadBuffers; @end OF_ASSUME_NONNULL_END |
Modified src/OFKernelEventObserver.m from [9bc4c1ecdf] to [1a2dbaaf85].
︙ | ︙ | |||
269 270 271 272 273 274 275 | [_mutex unlock]; } #endif [self cancel]; } | | > > > > > | | < < < < < | | 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 | [_mutex unlock]; } #endif [self cancel]; } - (void)of_addObjectForReading: (id <OFReadyForReadingObserving>)object { OF_UNRECOGNIZED_SELECTOR } - (void)of_addObjectForWriting: (id <OFReadyForWritingObserving>)object { OF_UNRECOGNIZED_SELECTOR } - (void)of_removeObjectForReading: (id <OFReadyForReadingObserving>)object { OF_UNRECOGNIZED_SELECTOR } - (void)of_removeObjectForWriting: (id <OFReadyForWritingObserving>)object { OF_UNRECOGNIZED_SELECTOR } - (void)of_processQueue { void *pool = objc_autoreleasePoolPush(); #ifdef OF_HAVE_THREADS [_mutex lock]; @try { #endif |
︙ | ︙ | |||
312 313 314 315 316 317 318 | id object = queueObjects[i]; switch (action) { case QUEUE_ADD | QUEUE_READ: [_readObjects addObject: object]; @try { | | | | | | | | 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 | id object = queueObjects[i]; switch (action) { case QUEUE_ADD | QUEUE_READ: [_readObjects addObject: object]; @try { [self of_addObjectForReading: object]; } @catch (id e) { [_readObjects removeObjectIdenticalTo: object]; @throw e; } break; case QUEUE_ADD | QUEUE_WRITE: [_writeObjects addObject: object]; @try { [self of_addObjectForWriting: object]; } @catch (id e) { [_writeObjects removeObjectIdenticalTo: object]; @throw e; } break; case QUEUE_REMOVE | QUEUE_READ: [self of_removeObjectForReading: object]; [_readObjects removeObjectIdenticalTo: object]; break; case QUEUE_REMOVE | QUEUE_WRITE: [self of_removeObjectForWriting: object]; [_writeObjects removeObjectIdenticalTo: object]; break; default: OF_ENSURE(0); } } [_queueActions removeAllItems]; [_queueObjects removeAllObjects]; #ifdef OF_HAVE_THREADS } @finally { [_mutex unlock]; } #endif objc_autoreleasePoolPop(pool); } - (bool)of_processReadBuffers { bool foundInReadBuffer = false; for (id object in _readObjects) { void *pool = objc_autoreleasePoolPush(); if ([object isKindOfClass: [OFStream class]] && [object hasDataInReadBuffer] && ![object of_isWaitingForDelimiter]) { if ([_delegate respondsToSelector: @selector(objectIsReadyForReading:)]) [_delegate objectIsReadyForReading: object]; foundInReadBuffer = true; } |
︙ | ︙ |
Modified src/OFKernelEventObserver_epoll.m from [662ee50aca] to [e75e01d402].
︙ | ︙ | |||
88 89 90 91 92 93 94 | close(_epfd); [_FDToEvents release]; [super dealloc]; } | | | 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 | close(_epfd); [_FDToEvents release]; [super dealloc]; } - (void)of_addObject: (id)object fileDescriptor: (int)fd events: (int)addEvents { struct epoll_event event; intptr_t events; events = (intptr_t)[_FDToEvents |
︙ | ︙ | |||
111 112 113 114 115 116 117 | @throw [OFObserveFailedException exceptionWithObserver: self errNo: errno]; [_FDToEvents setObject: (void *)(events | addEvents) forKey: (void *)((intptr_t)fd + 1)]; } | | | 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 | @throw [OFObserveFailedException exceptionWithObserver: self errNo: errno]; [_FDToEvents setObject: (void *)(events | addEvents) forKey: (void *)((intptr_t)fd + 1)]; } - (void)of_removeObject: (id)object fileDescriptor: (int)fd events: (int)removeEvents { intptr_t events; events = (intptr_t)[_FDToEvents objectForKey: (void *)((intptr_t)fd + 1)]; |
︙ | ︙ | |||
145 146 147 148 149 150 151 | errNo: errno]; [_FDToEvents setObject: (void *)events forKey: (void *)((intptr_t)fd + 1)]; } } | | | | | | | | | | | | 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 | errNo: errno]; [_FDToEvents setObject: (void *)events forKey: (void *)((intptr_t)fd + 1)]; } } - (void)of_addObjectForReading: (id <OFReadyForReadingObserving>)object { [self of_addObject: object fileDescriptor: [object fileDescriptorForReading] events: EPOLLIN]; } - (void)of_addObjectForWriting: (id <OFReadyForWritingObserving>)object { [self of_addObject: object fileDescriptor: [object fileDescriptorForWriting] events: EPOLLOUT]; } - (void)of_removeObjectForReading: (id <OFReadyForReadingObserving>)object { [self of_removeObject: object fileDescriptor: [object fileDescriptorForReading] events: EPOLLIN]; } - (void)of_removeObjectForWriting: (id <OFReadyForWritingObserving>)object { [self of_removeObject: object fileDescriptor: [object fileDescriptorForWriting] events: EPOLLOUT]; } - (void)observeForTimeInterval: (of_time_interval_t)timeInterval { OFNull *nullObject = [OFNull null]; struct epoll_event eventList[EVENTLIST_SIZE]; int events; [self of_processQueue]; if ([self of_processReadBuffers]) return; events = epoll_wait(_epfd, eventList, EVENTLIST_SIZE, (timeInterval != -1 ? timeInterval * 1000 : -1)); if (events < 0) @throw [OFObserveFailedException exceptionWithObserver: self |
︙ | ︙ |
Modified src/OFKernelEventObserver_kqueue.m from [ab8ff7a52e] to [4a787d392f].
︙ | ︙ | |||
81 82 83 84 85 86 87 | - (void)dealloc { close(_kernelQueue); [super dealloc]; } | | | | | | | | 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 | - (void)dealloc { close(_kernelQueue); [super dealloc]; } - (void)of_addObjectForReading: (id <OFReadyForReadingObserving>)object { struct kevent event; memset(&event, 0, sizeof(event)); event.ident = [object fileDescriptorForReading]; event.filter = EVFILT_READ; event.flags = EV_ADD; #ifndef OF_NETBSD event.udata = object; #else event.udata = (intptr_t)object; #endif if (kevent(_kernelQueue, &event, 1, NULL, 0, NULL) != 0) @throw [OFObserveFailedException exceptionWithObserver: self errNo: errno]; } - (void)of_addObjectForWriting: (id <OFReadyForWritingObserving>)object { struct kevent event; memset(&event, 0, sizeof(event)); event.ident = [object fileDescriptorForWriting]; event.filter = EVFILT_WRITE; event.flags = EV_ADD; #ifndef OF_NETBSD event.udata = object; #else event.udata = (intptr_t)object; #endif if (kevent(_kernelQueue, &event, 1, NULL, 0, NULL) != 0) @throw [OFObserveFailedException exceptionWithObserver: self errNo: errno]; } - (void)of_removeObjectForReading: (id <OFReadyForReadingObserving>)object { struct kevent event; memset(&event, 0, sizeof(event)); event.ident = [object fileDescriptorForReading]; event.filter = EVFILT_READ; event.flags = EV_DELETE; if (kevent(_kernelQueue, &event, 1, NULL, 0, NULL) != 0) @throw [OFObserveFailedException exceptionWithObserver: self errNo: errno]; } - (void)of_removeObjectForWriting: (id <OFReadyForWritingObserving>)object { struct kevent event; memset(&event, 0, sizeof(event)); event.ident = [object fileDescriptorForWriting]; event.filter = EVFILT_WRITE; event.flags = EV_DELETE; if (kevent(_kernelQueue, &event, 1, NULL, 0, NULL) != 0) @throw [OFObserveFailedException exceptionWithObserver: self errNo: errno]; } - (void)observeForTimeInterval: (of_time_interval_t)timeInterval { struct timespec timeout; struct kevent eventList[EVENTLIST_SIZE]; int events; [self of_processQueue]; if ([self of_processReadBuffers]) return; timeout.tv_sec = (time_t)timeInterval; timeout.tv_nsec = lrint((timeInterval - timeout.tv_sec) * 1000000000); events = kevent(_kernelQueue, NULL, 0, eventList, EVENTLIST_SIZE, (timeInterval != -1 ? &timeout : NULL)); |
︙ | ︙ |
Modified src/OFKernelEventObserver_poll.m from [5c00bd3414] to [d87bf7dc93].
︙ | ︙ | |||
66 67 68 69 70 71 72 | - (void)dealloc { [_FDs release]; [super dealloc]; } | | | 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 | - (void)dealloc { [_FDs release]; [super dealloc]; } - (void)of_addObject: (id)object fileDescriptor: (int)fd events: (short)events { struct pollfd *FDs = [_FDs items]; size_t count = [_FDs count]; bool found = false; |
︙ | ︙ | |||
97 98 99 100 101 102 103 | } _FDToObject[fd] = object; [_FDs addItem: &p]; } } | | | 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 | } _FDToObject[fd] = object; [_FDs addItem: &p]; } } - (void)of_removeObject: (id)object fileDescriptor: (int)fd events: (short)events { struct pollfd *FDs = [_FDs items]; size_t nFDs = [_FDs count]; for (size_t i = 0; i < nFDs; i++) { |
︙ | ︙ | |||
121 122 123 124 125 126 127 | } break; } } } | | | | | | | | | | | | 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 | } break; } } } - (void)of_addObjectForReading: (id <OFReadyForReadingObserving>)object { [self of_addObject: object fileDescriptor: [object fileDescriptorForReading] events: POLLIN]; } - (void)of_addObjectForWriting: (id <OFReadyForWritingObserving>)object { [self of_addObject: object fileDescriptor: [object fileDescriptorForWriting] events: POLLOUT]; } - (void)of_removeObjectForReading: (id <OFReadyForReadingObserving>)object { [self of_removeObject: object fileDescriptor: [object fileDescriptorForReading] events: POLLIN]; } - (void)of_removeObjectForWriting: (id <OFReadyForWritingObserving>)object { [self of_removeObject: object fileDescriptor: [object fileDescriptorForWriting] events: POLLOUT]; } - (void)observeForTimeInterval: (of_time_interval_t)timeInterval { struct pollfd *FDs; int events; size_t nFDs; [self of_processQueue]; if ([self of_processReadBuffers]) return; FDs = [_FDs items]; nFDs = [_FDs count]; #ifdef OPEN_MAX if (nFDs > OPEN_MAX) |
︙ | ︙ |
Modified src/OFKernelEventObserver_select.m from [ca3998cc6e] to [ab8bd97091].
︙ | ︙ | |||
61 62 63 64 65 66 67 | @throw [OFOutOfRangeException exception]; _maxFD = (int)_cancelFD[0]; return self; } | | | | | | 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 | @throw [OFOutOfRangeException exception]; _maxFD = (int)_cancelFD[0]; return self; } - (void)of_addObjectForReading: (id <OFReadyForReadingObserving>)object { int fd = [object fileDescriptorForReading]; if (fd < 0 || fd > INT_MAX - 1) @throw [OFOutOfRangeException exception]; #ifndef OF_WINDOWS if (fd >= (int)FD_SETSIZE) @throw [OFOutOfRangeException exception]; #endif if (fd > _maxFD) _maxFD = fd; FD_SET((of_socket_t)fd, &_readFDs); } - (void)of_addObjectForWriting: (id <OFReadyForWritingObserving>)object { int fd = [object fileDescriptorForWriting]; if (fd < 0 || fd > INT_MAX - 1) @throw [OFOutOfRangeException exception]; #ifndef OF_WINDOWS if (fd >= (int)FD_SETSIZE) @throw [OFOutOfRangeException exception]; #endif if (fd > _maxFD) _maxFD = fd; FD_SET((of_socket_t)fd, &_writeFDs); } - (void)of_removeObjectForReading: (id <OFReadyForReadingObserving>)object { /* TODO: Adjust _maxFD */ int fd = [object fileDescriptorForReading]; if (fd < 0) @throw [OFOutOfRangeException exception]; #ifndef OF_WINDOWS if (fd >= (int)FD_SETSIZE) @throw [OFOutOfRangeException exception]; #endif FD_CLR((of_socket_t)fd, &_readFDs); } - (void)of_removeObjectForWriting: (id <OFReadyForWritingObserving>)object { /* TODO: Adjust _maxFD */ int fd = [object fileDescriptorForWriting]; if (fd < 0) @throw [OFOutOfRangeException exception]; |
︙ | ︙ | |||
140 141 142 143 144 145 146 | id const *objects; fd_set readFDs; fd_set writeFDs; struct timeval timeout; int events; size_t count; | | | | 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 | id const *objects; fd_set readFDs; fd_set writeFDs; struct timeval timeout; int events; size_t count; [self of_processQueue]; if ([self of_processReadBuffers]) return; #ifdef FD_COPY FD_COPY(&_readFDs, &readFDs); FD_COPY(&_writeFDs, &writeFDs); #else readFDs = _readFDs; |
︙ | ︙ |
Modified src/OFMD5Hash.h from [5fcb172421] to [61caed852a].
︙ | ︙ | |||
30 31 32 33 34 35 36 | union of_md5_hash_buffer { uint8_t bytes[64]; uint32_t words[16]; } _buffer; size_t _bufferLength; bool _calculated; } | < < | 30 31 32 33 34 35 36 37 38 39 | union of_md5_hash_buffer { uint8_t bytes[64]; uint32_t words[16]; } _buffer; size_t _bufferLength; bool _calculated; } @end OF_ASSUME_NONNULL_END |
Modified src/OFMD5Hash.m from [003b801911] to [5fa8ef5288].
︙ | ︙ | |||
17 18 19 20 21 22 23 24 25 26 27 28 29 30 | #include "config.h" #include <string.h> #import "OFMD5Hash.h" #import "OFHashAlreadyCalculatedException.h" #define F(a, b, c) (((a) & (b)) | (~(a) & (c))) #define G(a, b, c) (((a) & (c)) | ((b) & ~(c))) #define H(a, b, c) ((a) ^ (b) ^ (c)) #define I(a, b, c) ((b) ^ ((a) | ~(c))) static const uint32_t table[] = { | > > > > | 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | #include "config.h" #include <string.h> #import "OFMD5Hash.h" #import "OFHashAlreadyCalculatedException.h" @interface OFMD5Hash () - (void)of_resetState; @end #define F(a, b, c) (((a) & (b)) | (~(a) & (c))) #define G(a, b, c) (((a) & (c)) | ((b) & ~(c))) #define H(a, b, c) ((a) ^ (b) ^ (c)) #define I(a, b, c) ((b) ^ ((a) | ~(c))) static const uint32_t table[] = { |
︙ | ︙ | |||
130 131 132 133 134 135 136 | return [[[self alloc] init] autorelease]; } - init { self = [super init]; | | | 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 | return [[[self alloc] init] autorelease]; } - init { self = [super init]; [self of_resetState]; return self; } - (void)dealloc { [self reset]; |
︙ | ︙ | |||
155 156 157 158 159 160 161 | memcpy(©->_buffer, &_buffer, sizeof(_buffer)); copy->_bufferLength = _bufferLength; copy->_calculated = _calculated; return copy; } | | | 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 | memcpy(©->_buffer, &_buffer, sizeof(_buffer)); copy->_bufferLength = _bufferLength; copy->_calculated = _calculated; return copy; } - (void)of_resetState { _state[0] = 0x67452301; _state[1] = 0xEFCDAB89; _state[2] = 0x98BADCFE; _state[3] = 0x10325476; } |
︙ | ︙ | |||
219 220 221 222 223 224 225 | _calculated = true; return (const uint8_t *)_state; } - (void)reset { | | | 223 224 225 226 227 228 229 230 231 232 233 234 235 236 | _calculated = true; return (const uint8_t *)_state; } - (void)reset { [self of_resetState]; _bits = 0; memset(&_buffer, 0, sizeof(_buffer)); _bufferLength = 0; _calculated = false; } @end |
Modified src/OFMapTable.m from [654a4184b9] to [9a08c57256].
︙ | ︙ | |||
57 58 59 60 61 62 63 | static bool defaultEqual(void *object1, void *object2) { return (object1 == object2); } @interface OFMapTable () | | | | 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 | static bool defaultEqual(void *object1, void *object2) { return (object1 == object2); } @interface OFMapTable () - (void)of_setObject: (void *)object forKey: (void *)key hash: (uint32_t)hash; @end @interface OFMapTableEnumerator () - (instancetype)of_initWithMapTable: (OFMapTable *)mapTable buckets: (struct of_map_table_bucket **)buckets capacity: (uint32_t)capacity mutationsPointer: (unsigned long *)mutationsPtr OF_METHOD_FAMILY(init); @end @interface OFMapTableKeyEnumerator: OFMapTableEnumerator |
︙ | ︙ | |||
241 242 243 244 245 246 247 | initWithKeyFunctions: _keyFunctions objectFunctions: _objectFunctions capacity: _capacity]; @try { for (uint32_t i = 0; i < _capacity; i++) if (_buckets[i] != NULL && _buckets[i] != &deleted) | | | 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 | initWithKeyFunctions: _keyFunctions objectFunctions: _objectFunctions capacity: _capacity]; @try { for (uint32_t i = 0; i < _capacity; i++) if (_buckets[i] != NULL && _buckets[i] != &deleted) [copy of_setObject: _buckets[i]->object forKey: _buckets[i]->key hash: OF_ROR(_buckets[i]->hash, _rotate)]; } @catch (id e) { [copy release]; @throw e; } |
︙ | ︙ | |||
293 294 295 296 297 298 299 | if (_keyFunctions.equal(_buckets[i]->key, key)) return _buckets[i]->object; } return NULL; } | | | 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 | if (_keyFunctions.equal(_buckets[i]->key, key)) return _buckets[i]->object; } return NULL; } - (void)of_resizeForCount: (uint32_t)count { uint32_t fullness, capacity; struct of_map_table_bucket **buckets; if (count > UINT32_MAX / sizeof(*_buckets) || count > UINT32_MAX / 8) @throw [OFOutOfRangeException exception]; |
︙ | ︙ | |||
354 355 356 357 358 359 360 | } [self freeMemory: _buckets]; _buckets = buckets; _capacity = capacity; } | | | 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 | } [self freeMemory: _buckets]; _buckets = buckets; _capacity = capacity; } - (void)of_setObject: (void *)object forKey: (void *)key hash: (uint32_t)hash { uint32_t i, last; void *old; if (key == NULL || object == NULL) |
︙ | ︙ | |||
393 394 395 396 397 398 399 | } /* Key not in map table */ if (i >= last || _buckets[i] == NULL || _buckets[i] == &deleted || !_keyFunctions.equal(_buckets[i]->key, key)) { struct of_map_table_bucket *bucket; | | | 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 | } /* Key not in map table */ if (i >= last || _buckets[i] == NULL || _buckets[i] == &deleted || !_keyFunctions.equal(_buckets[i]->key, key)) { struct of_map_table_bucket *bucket; [self of_resizeForCount: _count + 1]; _mutations++; last = _capacity; for (i = hash & (_capacity - 1); i < last && _buckets[i] != NULL && _buckets[i] != &deleted; i++); |
︙ | ︙ | |||
445 446 447 448 449 450 451 | _buckets[i]->object = _objectFunctions.retain(object); _objectFunctions.release(old); } - (void)setObject: (void *)object forKey: (void *)key { | | | 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 | _buckets[i]->object = _objectFunctions.retain(object); _objectFunctions.release(old); } - (void)setObject: (void *)object forKey: (void *)key { [self of_setObject: object forKey: key hash: _keyFunctions.hash(key)]; } - (void)removeObjectForKey: (void *)key { uint32_t i, hash, last; |
︙ | ︙ | |||
474 475 476 477 478 479 480 | _keyFunctions.release(_buckets[i]->key); _objectFunctions.release(_buckets[i]->object); [self freeMemory: _buckets[i]]; _buckets[i] = &deleted; _count--; | | | 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 | _keyFunctions.release(_buckets[i]->key); _objectFunctions.release(_buckets[i]->object); [self freeMemory: _buckets[i]]; _buckets[i] = &deleted; _count--; [self of_resizeForCount: _count]; return; } } if (i < last) return; |
︙ | ︙ | |||
499 500 501 502 503 504 505 | _objectFunctions.release(_buckets[i]->object); [self freeMemory: _buckets[i]]; _buckets[i] = &deleted; _count--; _mutations++; | | | 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 | _objectFunctions.release(_buckets[i]->object); [self freeMemory: _buckets[i]]; _buckets[i] = &deleted; _count--; _mutations++; [self of_resizeForCount: _count]; return; } } } - (void)removeAllObjects |
︙ | ︙ | |||
572 573 574 575 576 577 578 | return false; } - (OFMapTableEnumerator *)keyEnumerator { return [[[OFMapTableKeyEnumerator alloc] | | | | 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 | return false; } - (OFMapTableEnumerator *)keyEnumerator { return [[[OFMapTableKeyEnumerator alloc] of_initWithMapTable: self buckets: _buckets capacity: _capacity mutationsPointer: &_mutations] autorelease]; } - (OFMapTableEnumerator *)objectEnumerator { return [[[OFMapTableObjectEnumerator alloc] of_initWithMapTable: self buckets: _buckets capacity: _capacity mutationsPointer: &_mutations] autorelease]; } - (int)countByEnumeratingWithState: (of_fast_enumeration_state_t *)state objects: (id *)objects |
︙ | ︙ | |||
662 663 664 665 666 667 668 | @implementation OFMapTableEnumerator - init { OF_INVALID_INIT_METHOD } | | | 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 | @implementation OFMapTableEnumerator - init { OF_INVALID_INIT_METHOD } - (instancetype)of_initWithMapTable: (OFMapTable *)mapTable buckets: (struct of_map_table_bucket **)buckets capacity: (uint32_t)capacity mutationsPointer: (unsigned long *)mutationsPtr { self = [super init]; _mapTable = [mapTable retain]; |
︙ | ︙ |
Modified src/OFMutableString.m from [4a06375780] to [f5a01a1e43].
︙ | ︙ | |||
236 237 238 239 240 241 242 | if (self == [OFMutableString class]) return (id)&placeholder; return [super alloc]; } #ifdef OF_HAVE_UNICODE_TABLES | | | 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 | if (self == [OFMutableString class]) return (id)&placeholder; return [super alloc]; } #ifdef OF_HAVE_UNICODE_TABLES - (void)of_convertWithWordStartTable: (const of_unichar_t *const[])startTable wordMiddleTable: (const of_unichar_t *const[])middleTable wordStartTableSize: (size_t)startTableSize wordMiddleTableSize: (size_t)middleTableSize { void *pool = objc_autoreleasePoolPush(); const of_unichar_t *characters = [self characters]; size_t length = [self length]; |
︙ | ︙ | |||
279 280 281 282 283 284 285 | break; } } objc_autoreleasePoolPop(pool); } #else | | | 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 | break; } } objc_autoreleasePoolPop(pool); } #else - (void)of_convertWithWordStartFunction: (char (*)(char))startFunction wordMiddleFunction: (char (*)(char))middleFunction { void *pool = objc_autoreleasePoolPush(); const of_unichar_t *characters = [self characters]; size_t length = [self length]; bool isStart = true; |
︙ | ︙ | |||
442 443 444 445 446 447 448 | atIndex: i]; } } #ifdef OF_HAVE_UNICODE_TABLES - (void)uppercase { | | | | | | | | 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 | atIndex: i]; } } #ifdef OF_HAVE_UNICODE_TABLES - (void)uppercase { [self of_convertWithWordStartTable: of_unicode_uppercase_table wordMiddleTable: of_unicode_uppercase_table wordStartTableSize: OF_UNICODE_UPPERCASE_TABLE_SIZE wordMiddleTableSize: OF_UNICODE_UPPERCASE_TABLE_SIZE]; } - (void)lowercase { [self of_convertWithWordStartTable: of_unicode_lowercase_table wordMiddleTable: of_unicode_lowercase_table wordStartTableSize: OF_UNICODE_LOWERCASE_TABLE_SIZE wordMiddleTableSize: OF_UNICODE_LOWERCASE_TABLE_SIZE]; } - (void)capitalize { [self of_convertWithWordStartTable: of_unicode_titlecase_table wordMiddleTable: of_unicode_lowercase_table wordStartTableSize: OF_UNICODE_TITLECASE_TABLE_SIZE wordMiddleTableSize: OF_UNICODE_LOWERCASE_TABLE_SIZE]; } #else - (void)uppercase { [self of_convertWithWordStartFunction: of_ascii_toupper wordMiddleFunction: of_ascii_toupper]; } - (void)lowercase { [self of_convertWithWordStartFunction: of_ascii_tolower wordMiddleFunction: of_ascii_tolower]; } - (void)capitalize { [self of_convertWithWordStartFunction: of_ascii_toupper wordMiddleFunction: of_ascii_tolower]; } #endif - (void)insertString: (OFString *)string atIndex: (size_t)index { |
︙ | ︙ |
Modified src/OFMutableString_UTF8.m from [841b1b06a7] to [247368600b].
︙ | ︙ | |||
50 51 52 53 54 55 56 | if (freeWhenDone) free(UTF8String); } return self; } | | | 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 | if (freeWhenDone) free(UTF8String); } return self; } - (void)of_convertWithWordStartTable: (const of_unichar_t *const[])startTable wordMiddleTable: (const of_unichar_t *const[])middleTable wordStartTableSize: (size_t)startTableSize wordMiddleTableSize: (size_t)middleTableSize { of_unichar_t *unicodeString; size_t unicodeLen, newCStringLength; size_t i, j; |
︙ | ︙ |
Modified src/OFNull.m from [8d2ffd1fab] to [de9d2023b1].
︙ | ︙ | |||
20 21 22 23 24 25 26 | #import "OFString.h" #import "OFXMLElement.h" #import "OFDataArray.h" #import "OFInvalidArgumentException.h" @interface OFNull () | | | 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | #import "OFString.h" #import "OFXMLElement.h" #import "OFDataArray.h" #import "OFInvalidArgumentException.h" @interface OFNull () - (OFString *)of_JSONRepresentationWithOptions: (int)options depth: (size_t)depth; @end static OFNull *null = nil; @implementation OFNull + (void)initialize |
︙ | ︙ | |||
81 82 83 84 85 86 87 | objc_autoreleasePoolPop(pool); return [element autorelease]; } - (OFString *)JSONRepresentation { | | | | | | 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 | objc_autoreleasePoolPop(pool); return [element autorelease]; } - (OFString *)JSONRepresentation { return [self of_JSONRepresentationWithOptions: 0 depth: 0]; } - (OFString *)JSONRepresentationWithOptions: (int)options { return [self of_JSONRepresentationWithOptions: options depth: 0]; } - (OFString *)of_JSONRepresentationWithOptions: (int)options depth: (size_t)depth { return @"null"; } - (OFDataArray *)messagePackRepresentation { OFDataArray *data = [OFDataArray dataArrayWithItemSize: 1 |
︙ | ︙ |
Modified src/OFNumber.m from [4f64bc6461] to [30e08cc2cc].
︙ | ︙ | |||
88 89 90 91 92 93 94 | case OF_NUMBER_TYPE_DOUBLE: \ return (t)_value.double_; \ default: \ @throw [OFInvalidFormatException exception]; \ } @interface OFNumber () | | | 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 | case OF_NUMBER_TYPE_DOUBLE: \ return (t)_value.double_; \ default: \ @throw [OFInvalidFormatException exception]; \ } @interface OFNumber () - (OFString *)of_JSONRepresentationWithOptions: (int)options depth: (size_t)depth; @end @implementation OFNumber @synthesize type = _type; + (instancetype)numberWithBool: (bool)bool_ |
︙ | ︙ | |||
1012 1013 1014 1015 1016 1017 1018 | objc_autoreleasePoolPop(pool); return [element autorelease]; } - (OFString *)JSONRepresentation { | | | | | 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 | objc_autoreleasePoolPop(pool); return [element autorelease]; } - (OFString *)JSONRepresentation { return [self of_JSONRepresentationWithOptions: 0 depth: 0]; } - (OFString *)JSONRepresentationWithOptions: (int)options { return [self of_JSONRepresentationWithOptions: options depth: 0]; } - (OFString *)of_JSONRepresentationWithOptions: (int)options depth: (size_t)depth { double doubleValue; if (_type == OF_NUMBER_TYPE_BOOL) return (_value.bool_ ? @"true" : @"false"); |
︙ | ︙ |
Modified src/OFProcess.m from [8cc38c1f3c] to [57b3b6c720].
︙ | ︙ | |||
54 55 56 57 58 59 60 | #if !defined(OF_WINDOWS) && !defined(HAVE_POSIX_SPAWNP) extern char **environ; #endif @interface OFProcess () #ifndef OF_WINDOWS | | | | | 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 | #if !defined(OF_WINDOWS) && !defined(HAVE_POSIX_SPAWNP) extern char **environ; #endif @interface OFProcess () #ifndef OF_WINDOWS - (void)of_getArgv: (char ***)argv forProgramName: (OFString *)programName andArguments: (OFArray *)arguments; - (char **)of_environmentForDictionary: (OFDictionary *)dictionary; #else - (char16_t *)of_environmentForDictionary: (OFDictionary *)dictionary; #endif @end @implementation OFProcess + (instancetype)processWithProgram: (OFString *)program { return [[[self alloc] initWithProgram: program] autorelease]; |
︙ | ︙ | |||
146 147 148 149 150 151 152 | char **argv; if (pipe(_readPipe) != 0 || pipe(_writePipe) != 0) @throw [OFInitializationFailedException exceptionWithClass: [self class]]; path = [program cStringWithEncoding: [OFLocalization encoding]]; | | | | 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 | char **argv; if (pipe(_readPipe) != 0 || pipe(_writePipe) != 0) @throw [OFInitializationFailedException exceptionWithClass: [self class]]; path = [program cStringWithEncoding: [OFLocalization encoding]]; [self of_getArgv: &argv forProgramName: programName andArguments: arguments]; @try { char **env = [self of_environmentForDictionary: environment]; # ifdef HAVE_POSIX_SPAWNP posix_spawn_file_actions_t actions; posix_spawnattr_t attr; if (posix_spawn_file_actions_init(&actions) != 0) @throw [OFInitializationFailedException exceptionWithClass: [self class]]; |
︙ | ︙ | |||
302 303 304 305 306 307 308 | count: length + 1]; memcpy(argumentsCopy, [argumentsString UTF16String], ([argumentsString UTF16StringLength] + 1) * 2); @try { if (!CreateProcessW([program UTF16String], argumentsCopy, NULL, NULL, TRUE, CREATE_UNICODE_ENVIRONMENT, | | | 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 | count: length + 1]; memcpy(argumentsCopy, [argumentsString UTF16String], ([argumentsString UTF16StringLength] + 1) * 2); @try { if (!CreateProcessW([program UTF16String], argumentsCopy, NULL, NULL, TRUE, CREATE_UNICODE_ENVIRONMENT, [self of_environmentForDictionary: environment], NULL, &si, &pi)) @throw [OFInitializationFailedException exceptionWithClass: [self class]]; } @finally { [self freeMemory: argumentsCopy]; } |
︙ | ︙ | |||
334 335 336 337 338 339 340 | { [self close]; [super dealloc]; } #ifndef OF_WINDOWS | | | 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 | { [self close]; [super dealloc]; } #ifndef OF_WINDOWS - (void)of_getArgv: (char ***)argv forProgramName: (OFString *)programName andArguments: (OFArray *)arguments { OFString *const *objects = [arguments objects]; size_t i, count = [arguments count]; of_string_encoding_t encoding; |
︙ | ︙ | |||
356 357 358 359 360 361 362 | for (i = 0; i < count; i++) (*argv)[i + 1] = (char *)[objects[i] cStringWithEncoding: encoding]; (*argv)[i + 1] = NULL; } | | | 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 | for (i = 0; i < count; i++) (*argv)[i + 1] = (char *)[objects[i] cStringWithEncoding: encoding]; (*argv)[i + 1] = NULL; } - (char **)of_environmentForDictionary: (OFDictionary *)environment { OFEnumerator *keyEnumerator, *objectEnumerator; char **envp; size_t i, count; of_string_encoding_t encoding; if (environment == nil) |
︙ | ︙ | |||
400 401 402 403 404 405 406 | } envp[i] = NULL; return envp; } #else | | | 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 | } envp[i] = NULL; return envp; } #else - (char16_t *)of_environmentForDictionary: (OFDictionary *)environment { OFDataArray *env; OFEnumerator *keyEnumerator, *objectEnumerator; OFString *key, *object; const char16_t equal = '='; const char16_t zero[2] = { 0, 0 }; |
︙ | ︙ |
Modified src/OFRIPEMD160Hash.h from [d03857c8ba] to [e347f0ae41].
︙ | ︙ | |||
30 31 32 33 34 35 36 | union of_ripemd_160_hash_buffer { uint8_t bytes[64]; uint32_t words[16]; } _buffer; size_t _bufferLength; bool _calculated; } | < < | 30 31 32 33 34 35 36 37 38 39 | union of_ripemd_160_hash_buffer { uint8_t bytes[64]; uint32_t words[16]; } _buffer; size_t _bufferLength; bool _calculated; } @end OF_ASSUME_NONNULL_END |
Modified src/OFRIPEMD160Hash.m from [eb95ce0800] to [9e827ae911].
︙ | ︙ | |||
17 18 19 20 21 22 23 24 25 26 27 28 29 30 | #include "config.h" #include <string.h> #import "OFRIPEMD160Hash.h" #import "OFHashAlreadyCalculatedException.h" #define F(a, b, c) ((a) ^ (b) ^ (c)) #define G(a, b, c) (((a) & (b)) | (~(a) & (c))) #define H(a, b, c) (((a) | ~(b)) ^ (c)) #define I(a, b, c) (((a) & (c)) | ((b) & ~(c))) #define J(a, b, c) ((a) ^ ((b) | ~(c))) | > > > > | 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | #include "config.h" #include <string.h> #import "OFRIPEMD160Hash.h" #import "OFHashAlreadyCalculatedException.h" @interface OFRIPEMD160Hash () - (void)of_resetState; @end #define F(a, b, c) ((a) ^ (b) ^ (c)) #define G(a, b, c) (((a) & (b)) | (~(a) & (c))) #define H(a, b, c) (((a) | ~(b)) ^ (c)) #define I(a, b, c) (((a) & (c)) | ((b) & ~(c))) #define J(a, b, c) ((a) ^ ((b) | ~(c))) |
︙ | ︙ | |||
144 145 146 147 148 149 150 | return [[[self alloc] init] autorelease]; } - init { self = [super init]; | | | 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 | return [[[self alloc] init] autorelease]; } - init { self = [super init]; [self of_resetState]; return self; } - (void)dealloc { [self reset]; |
︙ | ︙ | |||
169 170 171 172 173 174 175 | memcpy(©->_buffer, &_buffer, sizeof(_buffer)); copy->_bufferLength = _bufferLength; copy->_calculated = _calculated; return copy; } | | | 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 | memcpy(©->_buffer, &_buffer, sizeof(_buffer)); copy->_bufferLength = _bufferLength; copy->_calculated = _calculated; return copy; } - (void)of_resetState { _state[0] = 0x67452301; _state[1] = 0xEFCDAB89; _state[2] = 0x98BADCFE; _state[3] = 0x10325476; _state[4] = 0xC3D2E1F0; } |
︙ | ︙ | |||
234 235 236 237 238 239 240 | _calculated = true; return (const uint8_t *)_state; } - (void)reset { | | | 238 239 240 241 242 243 244 245 246 247 248 249 250 251 | _calculated = true; return (const uint8_t *)_state; } - (void)reset { [self of_resetState]; _bits = 0; memset(&_buffer, 0, sizeof(_buffer)); _bufferLength = 0; _calculated = false; } @end |
Modified src/OFRunLoop+Private.h from [a788ecb156] to [6cb34b1a9e].
︙ | ︙ | |||
19 20 21 22 23 24 25 | #ifdef OF_HAVE_SOCKETS # import "OFUDPSocket.h" #endif OF_ASSUME_NONNULL_BEGIN @interface OFRunLoop () | | | | | | | | | | | | | | | 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 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 | #ifdef OF_HAVE_SOCKETS # import "OFUDPSocket.h" #endif OF_ASSUME_NONNULL_BEGIN @interface OFRunLoop () + (void)of_setMainRunLoop: (OFRunLoop *)runLoop; #ifdef OF_HAVE_SOCKETS + (void)of_addAsyncReadForStream: (OFStream *)stream buffer: (void *)buffer length: (size_t)length target: (id)target selector: (SEL)selector; + (void)of_addAsyncReadForStream: (OFStream *)stream buffer: (void *)buffer exactLength: (size_t)length target: (id)target selector: (SEL)selector; + (void)of_addAsyncReadLineForStream: (OFStream *)stream encoding: (of_string_encoding_t)encoding target: (id)target selector: (SEL)selector; + (void)of_addAsyncAcceptForTCPSocket: (OFTCPSocket *)socket target: (id)target selector: (SEL)selector; + (void)of_addAsyncReceiveForUDPSocket: (OFUDPSocket *)socket buffer: (void *)buffer length: (size_t)length target: (id)target selector: (SEL)selector; # ifdef OF_HAVE_BLOCKS + (void)of_addAsyncReadForStream: (OFStream *)stream buffer: (void *)buffer length: (size_t)length block: (of_stream_async_read_block_t)block; + (void)of_addAsyncReadForStream: (OFStream *)stream buffer: (void *)buffer exactLength: (size_t)length block: (of_stream_async_read_block_t)block; + (void)of_addAsyncReadLineForStream: (OFStream *)stream encoding: (of_string_encoding_t)encoding block: (of_stream_async_read_line_block_t)block; + (void)of_addAsyncAcceptForTCPSocket: (OFTCPSocket *)socket block: (of_tcp_socket_async_accept_block_t) block; + (void)of_addAsyncReceiveForUDPSocket: (OFUDPSocket *)socket buffer: (void *)buffer length: (size_t)length block: (of_udp_socket_async_receive_block_t) block; # endif + (void)of_cancelAsyncRequestsForObject: (id)object; #endif - (void)of_removeTimer: (OFTimer *)timer; @end OF_ASSUME_NONNULL_END |
Modified src/OFRunLoop.m from [750b7da4cf] to [50df1150e8].
︙ | ︙ | |||
345 346 347 348 349 350 351 | #ifdef OF_HAVE_THREADS return [[OFThread currentThread] runLoop]; #else return [self mainRunLoop]; #endif } | | | 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 | #ifdef OF_HAVE_THREADS return [[OFThread currentThread] runLoop]; #else return [self mainRunLoop]; #endif } + (void)of_setMainRunLoop: (OFRunLoop *)runLoop { mainRunLoop = [runLoop retain]; } #ifdef OF_HAVE_SOCKETS # define ADD_READ(type, object, code) \ void *pool = objc_autoreleasePoolPush(); \ |
︙ | ︙ | |||
373 374 375 376 377 378 379 | \ queueItem = [[[type alloc] init] autorelease]; \ code \ [queue appendObject: queueItem]; \ \ objc_autoreleasePoolPop(pool); | | | | | | | | | | | | | 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 | \ queueItem = [[[type alloc] init] autorelease]; \ code \ [queue appendObject: queueItem]; \ \ objc_autoreleasePoolPop(pool); + (void)of_addAsyncReadForStream: (OFStream *)stream buffer: (void *)buffer length: (size_t)length target: (id)target selector: (SEL)selector { ADD_READ(OFRunLoop_ReadQueueItem, stream, { queueItem->_target = [target retain]; queueItem->_selector = selector; queueItem->_buffer = buffer; queueItem->_length = length; }) } + (void)of_addAsyncReadForStream: (OFStream *)stream buffer: (void *)buffer exactLength: (size_t)exactLength target: (id)target selector: (SEL)selector { ADD_READ(OFRunLoop_ExactReadQueueItem, stream, { queueItem->_target = [target retain]; queueItem->_selector = selector; queueItem->_buffer = buffer; queueItem->_exactLength = exactLength; }) } + (void)of_addAsyncReadLineForStream: (OFStream *)stream encoding: (of_string_encoding_t)encoding target: (id)target selector: (SEL)selector { ADD_READ(OFRunLoop_ReadLineQueueItem, stream, { queueItem->_target = [target retain]; queueItem->_selector = selector; queueItem->_encoding = encoding; }) } + (void)of_addAsyncAcceptForTCPSocket: (OFTCPSocket *)stream target: (id)target selector: (SEL)selector { ADD_READ(OFRunLoop_AcceptQueueItem, stream, { queueItem->_target = [target retain]; queueItem->_selector = selector; }) } + (void)of_addAsyncReceiveForUDPSocket: (OFUDPSocket *)socket buffer: (void *)buffer length: (size_t)length target: (id)target selector: (SEL)selector { ADD_READ(OFRunLoop_UDPReceiveQueueItem, socket, { queueItem->_buffer = buffer; queueItem->_length = length; queueItem->_target = [target retain]; queueItem->_selector = selector; }) } # ifdef OF_HAVE_BLOCKS + (void)of_addAsyncReadForStream: (OFStream *)stream buffer: (void *)buffer length: (size_t)length block: (of_stream_async_read_block_t)block { ADD_READ(OFRunLoop_ReadQueueItem, stream, { queueItem->_block = [block copy]; queueItem->_buffer = buffer; queueItem->_length = length; }) } + (void)of_addAsyncReadForStream: (OFStream *)stream buffer: (void *)buffer exactLength: (size_t)exactLength block: (of_stream_async_read_block_t)block { ADD_READ(OFRunLoop_ExactReadQueueItem, stream, { queueItem->_block = [block copy]; queueItem->_buffer = buffer; queueItem->_exactLength = exactLength; }) } + (void)of_addAsyncReadLineForStream: (OFStream *)stream encoding: (of_string_encoding_t)encoding block: (of_stream_async_read_line_block_t)block { ADD_READ(OFRunLoop_ReadLineQueueItem, stream, { queueItem->_block = [block copy]; queueItem->_encoding = encoding; }) } + (void)of_addAsyncAcceptForTCPSocket: (OFTCPSocket *)stream block: (of_tcp_socket_async_accept_block_t)block { ADD_READ(OFRunLoop_AcceptQueueItem, stream, { queueItem->_block = [block copy]; }) } + (void)of_addAsyncReceiveForUDPSocket: (OFUDPSocket *)socket buffer: (void *)buffer length: (size_t)length block: (of_udp_socket_async_receive_block_t) block { ADD_READ(OFRunLoop_UDPReceiveQueueItem, socket, { queueItem->_buffer = buffer; queueItem->_length = length; queueItem->_block = [block copy]; }) } # endif # undef ADD_READ + (void)of_cancelAsyncRequestsForObject: (id)object { void *pool = objc_autoreleasePoolPush(); OFRunLoop *runLoop = [self currentRunLoop]; OFList *queue; if ((queue = [runLoop->_readQueues objectForKey: object]) != nil) { assert([queue count] > 0); |
︙ | ︙ | |||
573 574 575 576 577 578 579 | [_timersQueue insertObject: timer]; #ifdef OF_HAVE_THREADS } @finally { [_timersQueueLock unlock]; } #endif | | | | 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 | [_timersQueue insertObject: timer]; #ifdef OF_HAVE_THREADS } @finally { [_timersQueueLock unlock]; } #endif [timer of_setInRunLoop: self]; #if defined(OF_HAVE_SOCKETS) [_kernelEventObserver cancel]; #elif defined(OF_HAVE_THREADS) [_condition signal]; #endif } - (void)of_removeTimer: (OFTimer *)timer { #ifdef OF_HAVE_THREADS [_timersQueueLock lock]; @try { #endif of_list_object_t *iter; |
︙ | ︙ | |||
675 676 677 678 679 680 681 | OF_ORDERED_DESCENDING) { timer = [[listObject->object retain] autorelease]; [_timersQueue removeListObject: listObject]; | | | 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 | OF_ORDERED_DESCENDING) { timer = [[listObject->object retain] autorelease]; [_timersQueue removeListObject: listObject]; [timer of_setInRunLoop: nil]; } else break; #ifdef OF_HAVE_THREADS } @finally { [_timersQueueLock unlock]; } #endif |
︙ | ︙ |
Modified src/OFSHA1Hash.h from [51d13a0a33] to [56057951f0].
︙ | ︙ | |||
30 31 32 33 34 35 36 | union of_sha_1_hash_buffer { uint8_t bytes[64]; uint32_t words[80]; } _buffer; size_t _bufferLength; bool _calculated; } | < < | 30 31 32 33 34 35 36 37 38 39 | union of_sha_1_hash_buffer { uint8_t bytes[64]; uint32_t words[80]; } _buffer; size_t _bufferLength; bool _calculated; } @end OF_ASSUME_NONNULL_END |
Modified src/OFSHA1Hash.m from [766775fc8c] to [cd2db0fc50].
︙ | ︙ | |||
17 18 19 20 21 22 23 24 25 26 27 28 29 30 | #include "config.h" #include <string.h> #import "OFSHA1Hash.h" #import "OFHashAlreadyCalculatedException.h" #define F(a, b, c, d) ((d) ^ ((b) & ((c) ^ (d)))) #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 | > > > > | 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | #include "config.h" #include <string.h> #import "OFSHA1Hash.h" #import "OFHashAlreadyCalculatedException.h" @interface OFSHA1Hash () - (void)of_resetState; @end #define F(a, b, c, d) ((d) ^ ((b) & ((c) ^ (d)))) #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 |
︙ | ︙ | |||
104 105 106 107 108 109 110 | return [[[self alloc] init] autorelease]; } - init { self = [super init]; | | | 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 | return [[[self alloc] init] autorelease]; } - init { self = [super init]; [self of_resetState]; return self; } - (void)dealloc { [self reset]; |
︙ | ︙ | |||
129 130 131 132 133 134 135 | memcpy(©->_buffer, &_buffer, sizeof(_buffer)); copy->_bufferLength = _bufferLength; copy->_calculated = _calculated; return copy; } | | | 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 | memcpy(©->_buffer, &_buffer, sizeof(_buffer)); copy->_bufferLength = _bufferLength; copy->_calculated = _calculated; return copy; } - (void)of_resetState { _state[0] = 0x67452301; _state[1] = 0xEFCDAB89; _state[2] = 0x98BADCFE; _state[3] = 0x10325476; _state[4] = 0xC3D2E1F0; } |
︙ | ︙ | |||
194 195 196 197 198 199 200 | _calculated = true; return (const uint8_t *)_state; } - (void)reset { | | | 198 199 200 201 202 203 204 205 206 207 208 209 210 211 | _calculated = true; return (const uint8_t *)_state; } - (void)reset { [self of_resetState]; _bits = 0; memset(&_buffer, 0, sizeof(_buffer)); _bufferLength = 0; _calculated = false; } @end |
Modified src/OFSHA224Hash.m from [75ee815673] to [c4997cbc29].
︙ | ︙ | |||
20 21 22 23 24 25 26 | @implementation OFSHA224Hash + (size_t)digestSize { return 28; } | | | 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | @implementation OFSHA224Hash + (size_t)digestSize { return 28; } - (void)of_resetState { _state[0] = 0xC1059ED8; _state[1] = 0x367CD507; _state[2] = 0x3070DD17; _state[3] = 0xF70E5939; _state[4] = 0xFFC00B31; _state[5] = 0x68581511; _state[6] = 0x64F98FA7; _state[7] = 0xBEFA4FA4; } @end |
Modified src/OFSHA224Or256Hash.h from [d784642d5f] to [d2b1bed551].
︙ | ︙ | |||
30 31 32 33 34 35 36 | union of_sha_224_or_256_hash_buffer { uint8_t bytes[64]; uint32_t words[64]; } _buffer; size_t _bufferLength; bool _calculated; } | < < | 30 31 32 33 34 35 36 37 38 39 | union of_sha_224_or_256_hash_buffer { uint8_t bytes[64]; uint32_t words[64]; } _buffer; size_t _bufferLength; bool _calculated; } @end OF_ASSUME_NONNULL_END |
Modified src/OFSHA224Or256Hash.m from [07e1179a49] to [280841ab34].
︙ | ︙ | |||
18 19 20 21 22 23 24 25 26 27 28 29 30 31 | #include <stdlib.h> #include <string.h> #import "OFSHA224Or256Hash.h" #import "OFHashAlreadyCalculatedException.h" static const uint32_t table[] = { 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5, 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC, | > > > > | 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | #include <stdlib.h> #include <string.h> #import "OFSHA224Or256Hash.h" #import "OFHashAlreadyCalculatedException.h" @interface OFSHA224Or256Hash () - (void)of_resetState; @end static const uint32_t table[] = { 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5, 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC, |
︙ | ︙ | |||
132 133 134 135 136 137 138 | @try { if ([self class] == [OFSHA224Or256Hash class]) { [self doesNotRecognizeSelector: _cmd]; abort(); } | | | 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 | @try { if ([self class] == [OFSHA224Or256Hash class]) { [self doesNotRecognizeSelector: _cmd]; abort(); } [self of_resetState]; } @catch (id e) { [self release]; @throw e; } return self; } |
︙ | ︙ | |||
217 218 219 220 221 222 223 | _calculated = true; return (const uint8_t *)_state; } - (void)reset { | | | | 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 | _calculated = true; return (const uint8_t *)_state; } - (void)reset { [self of_resetState]; _bits = 0; memset(&_buffer, 0, sizeof(_buffer)); _bufferLength = 0; _calculated = false; } - (void)of_resetState { OF_UNRECOGNIZED_SELECTOR } @end |
Modified src/OFSHA256Hash.m from [1d00b10ec1] to [07fd4c904a].
︙ | ︙ | |||
20 21 22 23 24 25 26 | @implementation OFSHA256Hash + (size_t)digestSize { return 32; } | | | 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | @implementation OFSHA256Hash + (size_t)digestSize { return 32; } - (void)of_resetState { _state[0] = 0x6A09E667; _state[1] = 0xBB67AE85; _state[2] = 0x3C6EF372; _state[3] = 0xA54FF53A; _state[4] = 0x510E527F; _state[5] = 0x9B05688C; _state[6] = 0x1F83D9AB; _state[7] = 0x5BE0CD19; } @end |
Modified src/OFSHA384Hash.m from [404fbb0310] to [e7f29d7b24].
︙ | ︙ | |||
20 21 22 23 24 25 26 | @implementation OFSHA384Hash + (size_t)digestSize { return 48; } | | | 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | @implementation OFSHA384Hash + (size_t)digestSize { return 48; } - (void)of_resetState { _state[0] = 0xCBBB9D5DC1059ED8; _state[1] = 0x629A292A367CD507; _state[2] = 0x9159015A3070DD17; _state[3] = 0x152FECD8F70E5939; _state[4] = 0x67332667FFC00B31; _state[5] = 0x8EB44A8768581511; _state[6] = 0xDB0C2E0D64F98FA7; _state[7] = 0x47B5481DBEFA4FA4; } @end |
Modified src/OFSHA384Or512Hash.h from [cfc249c62f] to [557203084b].
︙ | ︙ | |||
30 31 32 33 34 35 36 | union of_sha_384_or_512_hash_buffer { uint8_t bytes[128]; uint64_t words[80]; } _buffer; size_t _bufferLength; bool _calculated; } | < < | 30 31 32 33 34 35 36 37 38 39 | union of_sha_384_or_512_hash_buffer { uint8_t bytes[128]; uint64_t words[80]; } _buffer; size_t _bufferLength; bool _calculated; } @end OF_ASSUME_NONNULL_END |
Modified src/OFSHA384Or512Hash.m from [d5b60b898c] to [6ff07dab9e].
︙ | ︙ | |||
18 19 20 21 22 23 24 25 26 27 28 29 30 31 | #include <stdlib.h> #include <string.h> #import "OFSHA384Or512Hash.h" #import "OFHashAlreadyCalculatedException.h" static const uint64_t table[] = { 0x428A2F98D728AE22, 0x7137449123EF65CD, 0xB5C0FBCFEC4D3B2F, 0xE9B5DBA58189DBBC, 0x3956C25BF348B538, 0x59F111F1B605D019, 0x923F82A4AF194F9B, 0xAB1C5ED5DA6D8118, 0xD807AA98A3030242, 0x12835B0145706FBE, 0x243185BE4EE4B28C, 0x550C7DC3D5FFB4E2, 0x72BE5D74F27B896F, 0x80DEB1FE3B1696B1, 0x9BDC06A725C71235, | > > > > | 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | #include <stdlib.h> #include <string.h> #import "OFSHA384Or512Hash.h" #import "OFHashAlreadyCalculatedException.h" @interface OFSHA384Or512Hash () - (void)of_resetState; @end static const uint64_t table[] = { 0x428A2F98D728AE22, 0x7137449123EF65CD, 0xB5C0FBCFEC4D3B2F, 0xE9B5DBA58189DBBC, 0x3956C25BF348B538, 0x59F111F1B605D019, 0x923F82A4AF194F9B, 0xAB1C5ED5DA6D8118, 0xD807AA98A3030242, 0x12835B0145706FBE, 0x243185BE4EE4B28C, 0x550C7DC3D5FFB4E2, 0x72BE5D74F27B896F, 0x80DEB1FE3B1696B1, 0x9BDC06A725C71235, |
︙ | ︙ | |||
143 144 145 146 147 148 149 | @try { if ([self class] == [OFSHA384Or512Hash class]) { [self doesNotRecognizeSelector: _cmd]; abort(); } | | | 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 | @try { if ([self class] == [OFSHA384Or512Hash class]) { [self doesNotRecognizeSelector: _cmd]; abort(); } [self of_resetState]; } @catch (id e) { [self release]; @throw e; } return self; } |
︙ | ︙ | |||
230 231 232 233 234 235 236 | _calculated = true; return (const uint8_t *)_state; } - (void)reset { | | | | 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 | _calculated = true; return (const uint8_t *)_state; } - (void)reset { [self of_resetState]; memset(_bits, 0, sizeof(_bits)); memset(&_buffer, 0, sizeof(_buffer)); _bufferLength = 0; _calculated = false; } - (void)of_resetState { OF_UNRECOGNIZED_SELECTOR } @end |
Modified src/OFSHA512Hash.m from [0a69e7a200] to [58e7af6661].
︙ | ︙ | |||
20 21 22 23 24 25 26 | @implementation OFSHA512Hash + (size_t)digestSize { return 64; } | | | 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | @implementation OFSHA512Hash + (size_t)digestSize { return 64; } - (void)of_resetState { _state[0] = 0x6A09E667F3BCC908; _state[1] = 0xBB67AE8584CAA73B; _state[2] = 0x3C6EF372FE94F82B; _state[3] = 0xA54FF53A5F1D36F1; _state[4] = 0x510E527FADE682D1; _state[5] = 0x9B05688C2B3E6C1F; _state[6] = 0x1F83D9ABFB41BD6B; _state[7] = 0x5BE0CD19137E2179; } @end |
Modified src/OFSettings_INIFile.m from [4485c04494] to [458ae98147].
︙ | ︙ | |||
49 50 51 52 53 54 55 | { [_filePath release]; [_INIFile release]; [super dealloc]; } | | | 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 | { [_filePath release]; [_INIFile release]; [super dealloc]; } - (void)of_getCategory: (OFString **)category andKey: (OFString **)key forPath: (OFString *)path { size_t pos = [path rangeOfString: @"." options: OF_STRING_SEARCH_BACKWARDS].location; if (pos == OF_NOT_FOUND) { |
︙ | ︙ | |||
73 74 75 76 77 78 79 | - (void)setString: (OFString *)string forPath: (OFString *)path { void *pool = objc_autoreleasePoolPush(); OFString *category, *key; | | | | | | | | | | | | | | | 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 | - (void)setString: (OFString *)string forPath: (OFString *)path { void *pool = objc_autoreleasePoolPush(); OFString *category, *key; [self of_getCategory: &category andKey: &key forPath: path]; [[_INIFile categoryForName: category] setString: string forKey: key]; objc_autoreleasePoolPop(pool); } - (void)setInteger: (intmax_t)integer forPath: (OFString *)path { void *pool = objc_autoreleasePoolPush(); OFString *category, *key; [self of_getCategory: &category andKey: &key forPath: path]; [[_INIFile categoryForName: category] setInteger: integer forKey: key]; objc_autoreleasePoolPop(pool); } - (void)setBool: (bool)bool_ forPath: (OFString *)path { void *pool = objc_autoreleasePoolPush(); OFString *category, *key; [self of_getCategory: &category andKey: &key forPath: path]; [[_INIFile categoryForName: category] setBool: bool_ forKey: key]; objc_autoreleasePoolPop(pool); } - (void)setFloat: (float)float_ forPath: (OFString *)path { void *pool = objc_autoreleasePoolPush(); OFString *category, *key; [self of_getCategory: &category andKey: &key forPath: path]; [[_INIFile categoryForName: category] setFloat: float_ forKey: key]; objc_autoreleasePoolPop(pool); } - (void)setDouble: (double)double_ forPath: (OFString *)path { void *pool = objc_autoreleasePoolPush(); OFString *category, *key; [self of_getCategory: &category andKey: &key forPath: path]; [[_INIFile categoryForName: category] setDouble: double_ forKey: key]; objc_autoreleasePoolPop(pool); } - (void)setArray: (OFArray *)array forPath: (OFString *)path { void *pool = objc_autoreleasePoolPush(); OFString *category, *key; [self of_getCategory: &category andKey: &key forPath: path]; [[_INIFile categoryForName: category] setArray: array forKey: key]; objc_autoreleasePoolPop(pool); } - (OFString *)stringForPath: (OFString *)path defaultValue: (OFString *)defaultValue { void *pool = objc_autoreleasePoolPush(); OFString *category, *key, *ret; [self of_getCategory: &category andKey: &key forPath: path]; ret = [[_INIFile categoryForName: category] stringForKey: key defaultValue: defaultValue]; [ret retain]; objc_autoreleasePoolPop(pool); return [ret autorelease]; } - (intmax_t)integerForPath: (OFString *)path defaultValue: (intmax_t)defaultValue { void *pool = objc_autoreleasePoolPush(); OFString *category, *key; intmax_t ret; [self of_getCategory: &category andKey: &key forPath: path]; ret = [[_INIFile categoryForName: category] integerForKey: key defaultValue: defaultValue]; objc_autoreleasePoolPop(pool); return ret; } - (bool)boolForPath: (OFString *)path defaultValue: (bool)defaultValue { void *pool = objc_autoreleasePoolPush(); OFString *category, *key; bool ret; [self of_getCategory: &category andKey: &key forPath: path]; ret = [[_INIFile categoryForName: category] boolForKey: key defaultValue: defaultValue]; objc_autoreleasePoolPop(pool); return ret; } - (float)floatForPath: (OFString *)path defaultValue: (float)defaultValue { void *pool = objc_autoreleasePoolPush(); OFString *category, *key; float ret; [self of_getCategory: &category andKey: &key forPath: path]; ret = [[_INIFile categoryForName: category] floatForKey: key defaultValue: defaultValue]; objc_autoreleasePoolPop(pool); return ret; } - (double)doubleForPath: (OFString *)path defaultValue: (double)defaultValue { void *pool = objc_autoreleasePoolPush(); OFString *category, *key; double ret; [self of_getCategory: &category andKey: &key forPath: path]; ret = [[_INIFile categoryForName: category] doubleForKey: key defaultValue: defaultValue]; objc_autoreleasePoolPop(pool); return ret; } - (OFArray *)arrayForPath: (OFString *)path { void *pool = objc_autoreleasePoolPush(); OFString *category, *key; OFArray *ret; [self of_getCategory: &category andKey: &key forPath: path]; ret = [[_INIFile categoryForName: category] arrayForKey: key]; [ret retain]; objc_autoreleasePoolPop(pool); return [ret autorelease]; } - (void)removeValueForPath: (OFString *)path { void *pool = objc_autoreleasePoolPush(); OFString *category, *key; [self of_getCategory: &category andKey: &key forPath: path]; [[_INIFile categoryForName: category] removeValueForKey: key]; objc_autoreleasePoolPop(pool); } - (void)save { [_INIFile writeToFile: _filePath]; } @end |
Modified src/OFStdIOStream+Private.h from [c761984453] to [c0cf9d2b80].
︙ | ︙ | |||
15 16 17 18 19 20 21 | */ #import "OFStdIOStream.h" OF_ASSUME_NONNULL_BEGIN @interface OFStdIOStream () | | | 15 16 17 18 19 20 21 22 23 24 25 | */ #import "OFStdIOStream.h" OF_ASSUME_NONNULL_BEGIN @interface OFStdIOStream () - (instancetype)of_initWithFileDescriptor: (int)fd OF_METHOD_FAMILY(init); @end OF_ASSUME_NONNULL_END |
Modified src/OFStdIOStream.m from [5324fa0d07] to [d6e666357c].
︙ | ︙ | |||
80 81 82 83 84 85 86 | objc_autoreleasePoolPop(pool); } @implementation OFStdIOStream #ifndef OF_WINDOWS + (void)load { | | | | | | 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 | objc_autoreleasePoolPop(pool); } @implementation OFStdIOStream #ifndef OF_WINDOWS + (void)load { of_stdin = [[OFStdIOStream alloc] of_initWithFileDescriptor: 0]; of_stdout = [[OFStdIOStream alloc] of_initWithFileDescriptor: 1]; of_stderr = [[OFStdIOStream alloc] of_initWithFileDescriptor: 2]; } #endif - init { OF_INVALID_INIT_METHOD } - (instancetype)of_initWithFileDescriptor: (int)fd { self = [super init]; _fd = fd; return self; } |
︙ | ︙ |
Modified src/OFStdIOStream_Win32Console.m from [877aa024e4] to [b94d48eb9c].
︙ | ︙ | |||
57 58 59 60 61 62 63 | #include <windows.h> @implementation OFStdIOStream_Win32Console + (void)load { of_stdin = [[OFStdIOStream_Win32Console alloc] | | | | | | | 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 | #include <windows.h> @implementation OFStdIOStream_Win32Console + (void)load { of_stdin = [[OFStdIOStream_Win32Console alloc] of_initWithFileDescriptor: 0]; of_stdout = [[OFStdIOStream_Win32Console alloc] of_initWithFileDescriptor: 1]; of_stderr = [[OFStdIOStream_Win32Console alloc] of_initWithFileDescriptor: 2]; } - (instancetype)of_initWithFileDescriptor: (int)fd { self = [super of_initWithFileDescriptor: fd]; @try { DWORD mode; switch (fd) { case 0: _handle = GetStdHandle(STD_INPUT_HANDLE); |
︙ | ︙ |
Modified src/OFStream+Private.h from [dfdce57421] to [17c7533b28].
︙ | ︙ | |||
15 16 17 18 19 20 21 | */ #import "OFStream.h" OF_ASSUME_NONNULL_BEGIN @interface OFStream () | | | | 15 16 17 18 19 20 21 22 23 24 25 26 | */ #import "OFStream.h" OF_ASSUME_NONNULL_BEGIN @interface OFStream () @property (readonly, nonatomic, getter=of_isWaitingForDelimiter) bool of_waitingForDelimiter; @end OF_ASSUME_NONNULL_END |
Modified src/OFStream.m from [277ef6a678] to [563c34066f].
︙ | ︙ | |||
50 51 52 53 54 55 56 | #import "OFSetOptionFailedException.h" #import "of_asprintf.h" #define MIN_READ_SIZE 512 @implementation OFStream | | | 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 | #import "OFSetOptionFailedException.h" #import "of_asprintf.h" #define MIN_READ_SIZE 512 @implementation OFStream @synthesize of_waitingForDelimiter = _waitingForDelimiter; #ifndef OF_WINDOWS + (void)initialize { if (self == [OFStream class]) signal(SIGPIPE, SIG_IGN); } |
︙ | ︙ | |||
183 184 185 186 187 188 189 | #ifdef OF_HAVE_SOCKETS - (void)asyncReadIntoBuffer: (void *)buffer length: (size_t)length target: (id)target selector: (SEL)selector { | | | | | | 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 | #ifdef OF_HAVE_SOCKETS - (void)asyncReadIntoBuffer: (void *)buffer length: (size_t)length target: (id)target selector: (SEL)selector { [OFRunLoop of_addAsyncReadForStream: self buffer: buffer length: length target: target selector: selector]; } - (void)asyncReadIntoBuffer: (void *)buffer exactLength: (size_t)length target: (id)target selector: (SEL)selector { [OFRunLoop of_addAsyncReadForStream: self buffer: buffer exactLength: length target: target selector: selector]; } # ifdef OF_HAVE_BLOCKS - (void)asyncReadIntoBuffer: (void *)buffer length: (size_t)length block: (of_stream_async_read_block_t)block { [OFRunLoop of_addAsyncReadForStream: self buffer: buffer length: length block: block]; } - (void)asyncReadIntoBuffer: (void *)buffer exactLength: (size_t)length block: (of_stream_async_read_block_t)block { [OFRunLoop of_addAsyncReadForStream: self buffer: buffer exactLength: length block: block]; } # endif #endif |
︙ | ︙ | |||
758 759 760 761 762 763 764 | selector: selector]; } - (void)asyncReadLineWithEncoding: (of_string_encoding_t)encoding target: (id)target selector: (SEL)selector { | | | | 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 | selector: selector]; } - (void)asyncReadLineWithEncoding: (of_string_encoding_t)encoding target: (id)target selector: (SEL)selector { [OFRunLoop of_addAsyncReadLineForStream: self encoding: encoding target: target selector: selector]; } # ifdef OF_HAVE_BLOCKS - (void)asyncReadLineWithBlock: (of_stream_async_read_line_block_t)block { [self asyncReadLineWithEncoding: OF_STRING_ENCODING_UTF_8 block: block]; } - (void)asyncReadLineWithEncoding: (of_string_encoding_t)encoding block: (of_stream_async_read_line_block_t)block { [OFRunLoop of_addAsyncReadLineForStream: self encoding: encoding block: block]; } # endif #endif - (OFString *)tryReadLine |
︙ | ︙ | |||
1513 1514 1515 1516 1517 1518 1519 | { OF_UNRECOGNIZED_SELECTOR } #ifdef OF_HAVE_SOCKETS - (void)cancelAsyncRequests { | | | 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 | { OF_UNRECOGNIZED_SELECTOR } #ifdef OF_HAVE_SOCKETS - (void)cancelAsyncRequests { [OFRunLoop of_cancelAsyncRequestsForObject: self]; } #endif - (void)unreadFromBuffer: (const void *)buffer length: (size_t)length { char *readBuffer; |
︙ | ︙ |
Modified src/OFString+CryptoHashing.m from [78fa704049] to [68de61fc18].
︙ | ︙ | |||
25 26 27 28 29 30 31 | #import "OFSHA256Hash.h" #import "OFSHA384Hash.h" #import "OFSHA512Hash.h" int _OFString_CryptoHashing_reference; @implementation OFString (CryptoHashing) | | | 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | #import "OFSHA256Hash.h" #import "OFSHA384Hash.h" #import "OFSHA512Hash.h" int _OFString_CryptoHashing_reference; @implementation OFString (CryptoHashing) - (OFString *)of_cryptoHashWithClass: (Class <OFCryptoHash>)class { void *pool = objc_autoreleasePoolPush(); id <OFCryptoHash> hash = [class cryptoHash]; size_t digestSize = [class digestSize]; const unsigned char *digest; char cString[digestSize * 2]; |
︙ | ︙ | |||
56 57 58 59 60 61 62 | return [OFString stringWithCString: cString encoding: OF_STRING_ENCODING_ASCII length: digestSize * 2]; } - (OFString *)MD5Hash { | | | | | | | | | 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 | return [OFString stringWithCString: cString encoding: OF_STRING_ENCODING_ASCII length: digestSize * 2]; } - (OFString *)MD5Hash { return [self of_cryptoHashWithClass: [OFMD5Hash class]]; } - (OFString *)RIPEMD160Hash { return [self of_cryptoHashWithClass: [OFRIPEMD160Hash class]]; } - (OFString *)SHA1Hash { return [self of_cryptoHashWithClass: [OFSHA1Hash class]]; } - (OFString *)SHA224Hash { return [self of_cryptoHashWithClass: [OFSHA224Hash class]]; } - (OFString *)SHA256Hash { return [self of_cryptoHashWithClass: [OFSHA256Hash class]]; } - (OFString *)SHA384Hash { return [self of_cryptoHashWithClass: [OFSHA384Hash class]]; } - (OFString *)SHA512Hash { return [self of_cryptoHashWithClass: [OFSHA512Hash class]]; } @end |
Modified src/OFString.m from [583af651c3] to [37a16908bb].
︙ | ︙ | |||
76 77 78 79 80 81 82 | #endif #if defined(HAVE_STRTOF_L) || defined(HAVE_STRTOD_L) static locale_t cLocale; #endif @interface OFString () | | | | | 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 | #endif #if defined(HAVE_STRTOF_L) || defined(HAVE_STRTOD_L) static locale_t cLocale; #endif @interface OFString () - (size_t)of_getCString: (char *)cString maxLength: (size_t)maxLength encoding: (of_string_encoding_t)encoding lossy: (bool)lossy; - (const char *)of_cStringWithEncoding: (of_string_encoding_t)encoding lossy: (bool)lossy; - (OFString *)of_JSONRepresentationWithOptions: (int)options depth: (size_t)depth; @end extern bool of_unicode_to_iso_8859_2(const of_unichar_t *, unsigned char *, size_t, bool); extern bool of_unicode_to_iso_8859_3(const of_unichar_t *, unsigned char *, size_t, bool); |
︙ | ︙ | |||
367 368 369 370 371 372 373 | size_t length; void *storage; length = strlen(UTF8String); string = of_alloc_object([OFString_UTF8 class], length + 1, 1, &storage); | | | | 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 | size_t length; void *storage; length = strlen(UTF8String); string = of_alloc_object([OFString_UTF8 class], length + 1, 1, &storage); return (id)[string of_initWithUTF8String: UTF8String length: length storage: storage]; } - initWithUTF8String: (const char *)UTF8String length: (size_t)UTF8StringLength { id string; void *storage; string = of_alloc_object([OFString_UTF8 class], UTF8StringLength + 1, 1, &storage); return (id)[string of_initWithUTF8String: UTF8String length: UTF8StringLength storage: storage]; } - initWithUTF8StringNoCopy: (char *)UTF8String freeWhenDone: (bool)freeWhenDone { |
︙ | ︙ | |||
406 407 408 409 410 411 412 | size_t length; void *storage; length = strlen(cString); string = of_alloc_object([OFString_UTF8 class], length + 1, 1, &storage); | | | | 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 | size_t length; void *storage; length = strlen(cString); string = of_alloc_object([OFString_UTF8 class], length + 1, 1, &storage); return (id)[string of_initWithUTF8String: cString length: length storage: storage]; } return (id)[[OFString_UTF8 alloc] initWithCString: cString encoding: encoding]; } - initWithCString: (const char *)cString encoding: (of_string_encoding_t)encoding length: (size_t)cStringLength { if (encoding == OF_STRING_ENCODING_UTF_8) { id string; void *storage; string = of_alloc_object([OFString_UTF8 class], cStringLength + 1, 1, &storage); return (id)[string of_initWithUTF8String: cString length: cStringLength storage: storage]; } return (id)[[OFString_UTF8 alloc] initWithCString: cString encoding: encoding length: cStringLength]; |
︙ | ︙ | |||
1044 1045 1046 1047 1048 1049 1050 | [self release]; @throw e; } return self; } | | | 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 | [self release]; @throw e; } return self; } - (size_t)of_getCString: (char *)cString maxLength: (size_t)maxLength encoding: (of_string_encoding_t)encoding lossy: (bool)lossy { const of_unichar_t *characters = [self characters]; size_t i, length = [self length]; |
︙ | ︙ | |||
1279 1280 1281 1282 1283 1284 1285 | } } - (size_t)getCString: (char *)cString maxLength: (size_t)maxLength encoding: (of_string_encoding_t)encoding { | | | | | | 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 | } } - (size_t)getCString: (char *)cString maxLength: (size_t)maxLength encoding: (of_string_encoding_t)encoding { return [self of_getCString: cString maxLength: maxLength encoding: encoding lossy: false]; } - (size_t)getLossyCString: (char *)cString maxLength: (size_t)maxLength encoding: (of_string_encoding_t)encoding { return [self of_getCString: cString maxLength: maxLength encoding: encoding lossy: true]; } - (const char *)of_cStringWithEncoding: (of_string_encoding_t)encoding lossy: (bool)lossy { OFObject *object = [[[OFObject alloc] init] autorelease]; size_t length = [self length]; char *cString; switch (encoding) { case OF_STRING_ENCODING_UTF_8:; size_t cStringLength; cString = [object allocMemoryWithSize: (length * 4) + 1]; cStringLength = [self of_getCString: cString maxLength: (length * 4) + 1 encoding: OF_STRING_ENCODING_UTF_8 lossy: lossy]; @try { cString = [object resizeMemory: cString size: cStringLength + 1]; |
︙ | ︙ | |||
1336 1337 1338 1339 1340 1341 1342 | case OF_STRING_ENCODING_CODEPAGE_850: case OF_STRING_ENCODING_CODEPAGE_858: case OF_STRING_ENCODING_MAC_ROMAN: case OF_STRING_ENCODING_KOI8_R: case OF_STRING_ENCODING_KOI8_U: cString = [object allocMemoryWithSize: length + 1]; | | | | | 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 | case OF_STRING_ENCODING_CODEPAGE_850: case OF_STRING_ENCODING_CODEPAGE_858: case OF_STRING_ENCODING_MAC_ROMAN: case OF_STRING_ENCODING_KOI8_R: case OF_STRING_ENCODING_KOI8_U: cString = [object allocMemoryWithSize: length + 1]; [self of_getCString: cString maxLength: length + 1 encoding: encoding lossy: lossy]; break; default: @throw [OFInvalidEncodingException exception]; } return cString; } - (const char *)cStringWithEncoding: (of_string_encoding_t)encoding { return [self of_cStringWithEncoding: encoding lossy: false]; } - (const char *)lossyCStringWithEncoding: (of_string_encoding_t)encoding { return [self of_cStringWithEncoding: encoding lossy: true]; } - (const char *)UTF8String { return [self cStringWithEncoding: OF_STRING_ENCODING_UTF_8]; } |
︙ | ︙ | |||
1628 1629 1630 1631 1632 1633 1634 | objc_autoreleasePoolPop(pool); return [element autorelease]; } - (OFString *)JSONRepresentation { | | | | | 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 | objc_autoreleasePoolPop(pool); return [element autorelease]; } - (OFString *)JSONRepresentation { return [self of_JSONRepresentationWithOptions: 0 depth: 0]; } - (OFString *)JSONRepresentationWithOptions: (int)options { return [self of_JSONRepresentationWithOptions: options depth: 0]; } - (OFString *)of_JSONRepresentationWithOptions: (int)options depth: (size_t)depth { OFMutableString *JSON = [[self mutableCopy] autorelease]; /* FIXME: This is slow! Write it in pure C! */ [JSON replaceOccurrencesOfString: @"\\" withString: @"\\\\"]; |
︙ | ︙ |
Modified src/OFString_UTF8+Private.h from [bb37f1c56d] to [3871abb827].
︙ | ︙ | |||
15 16 17 18 19 20 21 | */ #import "OFString_UTF8.h" OF_ASSUME_NONNULL_BEGIN @interface OFString_UTF8 () | | | 15 16 17 18 19 20 21 22 23 24 25 26 27 | */ #import "OFString_UTF8.h" OF_ASSUME_NONNULL_BEGIN @interface OFString_UTF8 () - (instancetype)of_initWithUTF8String: (const char *)UTF8String length: (size_t)UTF8StringLength storage: (char *)storage OF_METHOD_FAMILY(init); @end OF_ASSUME_NONNULL_END |
Modified src/OFString_UTF8.m from [b63159ccbd] to [2b39181352].
︙ | ︙ | |||
183 184 185 186 187 188 189 | [self release]; @throw e; } return self; } | | | 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 | [self release]; @throw e; } return self; } - (instancetype)of_initWithUTF8String: (const char *)UTF8String length: (size_t)UTF8StringLength storage: (char *)storage { self = [super init]; @try { if (UTF8StringLength >= 3 && |
︙ | ︙ |
Modified src/OFTCPSocket.m from [379b9f377d] to [b98f01fc09].
︙ | ︙ | |||
569 570 571 572 573 574 575 | return client; } - (void)asyncAcceptWithTarget: (id)target selector: (SEL)selector { | | | | 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 | return client; } - (void)asyncAcceptWithTarget: (id)target selector: (SEL)selector { [OFRunLoop of_addAsyncAcceptForTCPSocket: self target: target selector: selector]; } #ifdef OF_HAVE_BLOCKS - (void)asyncAcceptWithBlock: (of_tcp_socket_async_accept_block_t)block { [OFRunLoop of_addAsyncAcceptForTCPSocket: self block: block]; } #endif - (OFString *)remoteAddress { OFString *ret; |
︙ | ︙ |
Modified src/OFTarArchive.m from [a36962d678] to [cd4c802a1e].
︙ | ︙ | |||
75 76 77 78 79 80 81 | { union { char c[512]; uint32_t u32[512 / sizeof(uint32_t)]; } buffer; bool empty = true; | | | 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 | { union { char c[512]; uint32_t u32[512 / sizeof(uint32_t)]; } buffer; bool empty = true; [_lastReturnedEntry of_skip]; [_lastReturnedEntry close]; [_lastReturnedEntry release]; _lastReturnedEntry = nil; if ([_stream isAtEndOfStream]) return nil; |
︙ | ︙ | |||
102 103 104 105 106 107 108 | if (buffer.u32[i] != 0) @throw [OFInvalidFormatException exception]; return nil; } _lastReturnedEntry = [[OFTarArchiveEntry alloc] | | | 102 103 104 105 106 107 108 109 110 111 112 113 114 | if (buffer.u32[i] != 0) @throw [OFInvalidFormatException exception]; return nil; } _lastReturnedEntry = [[OFTarArchiveEntry alloc] of_initWithHeader: buffer.c stream: _stream]; return _lastReturnedEntry; } @end |
Modified src/OFTarArchiveEntry+Private.h from [0bb407dd23] to [ca35be2adb].
︙ | ︙ | |||
15 16 17 18 19 20 21 | */ #import "OFTarArchiveEntry.h" OF_ASSUME_NONNULL_BEGIN @interface OFTarArchiveEntry () | | | | 15 16 17 18 19 20 21 22 23 24 25 26 27 | */ #import "OFTarArchiveEntry.h" OF_ASSUME_NONNULL_BEGIN @interface OFTarArchiveEntry () - (instancetype)of_initWithHeader: (char [_Nonnull 512])header stream: (OFStream *)stream OF_METHOD_FAMILY(init); - (void)of_skip; @end OF_ASSUME_NONNULL_END |
Modified src/OFTarArchiveEntry.m from [e989f0ffdc] to [0b52b84545].
︙ | ︙ | |||
58 59 60 61 62 63 64 | @synthesize deviceMajor = _deviceMajor, deviceMinor = _deviceMinor; - init { OF_INVALID_INIT_METHOD } | | | 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 | @synthesize deviceMajor = _deviceMajor, deviceMinor = _deviceMinor; - init { OF_INVALID_INIT_METHOD } - (instancetype)of_initWithHeader: (char [512])header stream: (OFStream *)stream { self = [super init]; @try { void *pool = objc_autoreleasePoolPush(); |
︙ | ︙ | |||
161 162 163 164 165 166 167 | - (void)close { _atEndOfStream = true; [super close]; } | | | 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 | - (void)close { _atEndOfStream = true; [super close]; } - (void)of_skip { char buffer[512]; while (_toRead >= 512) { [_stream readIntoBuffer: buffer exactLength: 512]; _toRead -= 512; |
︙ | ︙ |
Modified src/OFThread+Private.h from [3056c9ce56] to [880b9d9aa8].
︙ | ︙ | |||
16 17 18 19 20 21 22 | #import "OFThread.h" OF_ASSUME_NONNULL_BEGIN #ifdef OF_HAVE_THREADS @interface OFThread () | | | 16 17 18 19 20 21 22 23 24 25 26 27 | #import "OFThread.h" OF_ASSUME_NONNULL_BEGIN #ifdef OF_HAVE_THREADS @interface OFThread () + (void)of_createMainThread; @end #endif OF_ASSUME_NONNULL_END |
Modified src/OFThread.m from [3b9d6bd50a] to [b1f565231d].
︙ | ︙ | |||
118 119 120 121 122 123 124 | thread->_returnValue = [[thread main] retain]; [thread handleTermination]; thread->_running = OF_THREAD_WAITING_FOR_JOIN; objc_autoreleasePoolPop(thread->_pool); | | | 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | thread->_returnValue = [[thread main] retain]; [thread handleTermination]; thread->_running = OF_THREAD_WAITING_FOR_JOIN; objc_autoreleasePoolPop(thread->_pool); [OFAutoreleasePool of_handleThreadTermination]; [thread release]; } #endif @implementation OFThread #ifdef OF_HAVE_THREADS |
︙ | ︙ | |||
257 258 259 260 261 262 263 | [thread handleTermination]; thread->_running = OF_THREAD_WAITING_FOR_JOIN; objc_autoreleasePoolPop(thread->_pool); } | | | | 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 | [thread handleTermination]; thread->_running = OF_THREAD_WAITING_FOR_JOIN; objc_autoreleasePoolPop(thread->_pool); } [OFAutoreleasePool of_handleThreadTermination]; [thread release]; of_thread_exit(); } + (void)of_createMainThread { mainThread = [[OFThread alloc] init]; mainThread->_thread = of_thread_current(); if (!of_tlskey_set(threadSelfKey, mainThread)) @throw [OFInitializationFailedException exceptionWithClass: self]; |
︙ | ︙ |
Modified src/OFThreadPool.m from [04406d7334] to [f1417cd36d].
︙ | ︙ | |||
312 313 314 315 316 317 318 | [_queue release]; [_queueCondition release]; [_countCondition release]; [super dealloc]; } | | | 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 | [_queue release]; [_queueCondition release]; [_countCondition release]; [super dealloc]; } - (void)of_dispatchJob: (OFThreadPoolJob *)job { [_countCondition lock]; _count++; [_countCondition unlock]; [_queueCondition lock]; @try { |
︙ | ︙ | |||
346 347 348 349 350 351 352 | } } - (void)dispatchWithTarget: (id)target selector: (SEL)selector object: (id)object { | | | | 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 | } } - (void)dispatchWithTarget: (id)target selector: (SEL)selector object: (id)object { [self of_dispatchJob: [OFThreadPoolJob jobWithTarget: target selector: selector object: object]]; } #ifdef OF_HAVE_BLOCKS - (void)dispatchWithBlock: (of_thread_pool_block_t)block { [self of_dispatchJob: [OFThreadPoolJob jobWithBlock: block]]; } #endif - (size_t)size { return _size; } @end |
Modified src/OFTimer+Private.h from [22f9803439] to [315f62b4c1].
︙ | ︙ | |||
15 16 17 18 19 20 21 | */ #import "OFTimer.h" OF_ASSUME_NONNULL_BEGIN @interface OFTimer () | | | | 15 16 17 18 19 20 21 22 23 24 25 26 | */ #import "OFTimer.h" OF_ASSUME_NONNULL_BEGIN @interface OFTimer () @property OF_NULLABLE_PROPERTY (nonatomic, retain, setter=of_setInRunLoop:) OFRunLoop *of_inRunLoop; @end OF_ASSUME_NONNULL_END |
Modified src/OFTimer.m from [38ec5c3401] to [31ff560703].
︙ | ︙ | |||
29 30 31 32 33 34 35 | # import "OFCondition.h" #endif #import "OFInvalidArgumentException.h" @implementation OFTimer @synthesize timeInterval = _interval, repeating = _repeats, valid = _valid; | | | 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 | # import "OFCondition.h" #endif #import "OFInvalidArgumentException.h" @implementation OFTimer @synthesize timeInterval = _interval, repeating = _repeats, valid = _valid; @synthesize of_inRunLoop = _inRunLoop; + (instancetype)scheduledTimerWithTimeInterval: (of_time_interval_t)timeInterval target: (id)target selector: (SEL)selector repeats: (bool)repeats { void *pool = objc_autoreleasePoolPush(); |
︙ | ︙ | |||
208 209 210 211 212 213 214 | #endif - init { OF_INVALID_INIT_METHOD } | | | | 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 | #endif - init { OF_INVALID_INIT_METHOD } - (instancetype)of_initWithFireDate: (OFDate *)fireDate interval: (of_time_interval_t)interval target: (id)target selector: (SEL)selector object: (id)object1 object: (id)object2 arguments: (uint8_t)arguments repeats: (bool)repeats OF_METHOD_FAMILY(init) { self = [super init]; @try { _fireDate = [fireDate retain]; _interval = interval; _target = [target retain]; |
︙ | ︙ | |||
246 247 248 249 250 251 252 | - initWithFireDate: (OFDate *)fireDate interval: (of_time_interval_t)interval target: (id)target selector: (SEL)selector repeats: (bool)repeats { | | | | | 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 | - initWithFireDate: (OFDate *)fireDate interval: (of_time_interval_t)interval target: (id)target selector: (SEL)selector repeats: (bool)repeats { return [self of_initWithFireDate: fireDate interval: interval target: target selector: selector object: nil object: nil arguments: 0 repeats: repeats]; } - initWithFireDate: (OFDate *)fireDate interval: (of_time_interval_t)interval target: (id)target selector: (SEL)selector object: (id)object repeats: (bool)repeats { return [self of_initWithFireDate: fireDate interval: interval target: target selector: selector object: object object: nil arguments: 1 repeats: repeats]; } - initWithFireDate: (OFDate *)fireDate interval: (of_time_interval_t)interval target: (id)target selector: (SEL)selector object: (id)object1 object: (id)object2 repeats: (bool)repeats { return [self of_initWithFireDate: fireDate interval: interval target: target selector: selector object: object1 object: object2 arguments: 2 repeats: repeats]; |
︙ | ︙ | |||
418 419 420 421 422 423 424 | - (void)setFireDate: (OFDate *)fireDate { [self retain]; @try { @synchronized (self) { OFDate *old; | | | 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 | - (void)setFireDate: (OFDate *)fireDate { [self retain]; @try { @synchronized (self) { OFDate *old; [_inRunLoop of_removeTimer: self]; old = _fireDate; _fireDate = [fireDate copy]; [old release]; [_inRunLoop addTimer: self]; } |
︙ | ︙ |
Modified src/OFUDPSocket.m from [f67659d08d] to [06ff6d8241].
︙ | ︙ | |||
555 556 557 558 559 560 561 | } - (void)asyncReceiveIntoBuffer: (void *)buffer length: (size_t)length target: (id)target selector: (SEL)selector { | | | | 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 | } - (void)asyncReceiveIntoBuffer: (void *)buffer length: (size_t)length target: (id)target selector: (SEL)selector { [OFRunLoop of_addAsyncReceiveForUDPSocket: self buffer: buffer length: length target: target selector: selector]; } #ifdef OF_HAVE_BLOCKS - (void)asyncReceiveIntoBuffer: (void *)buffer length: (size_t)length block: (of_udp_socket_async_receive_block_t)block { [OFRunLoop of_addAsyncReceiveForUDPSocket: self buffer: buffer length: length block: block]; } #endif - (void)sendBuffer: (const void *)buffer |
︙ | ︙ | |||
608 609 610 611 612 613 614 | requestedLength: length errNo: of_socket_errno()]; #endif } - (void)cancelAsyncRequests { | | | 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 | requestedLength: length errNo: of_socket_errno()]; #endif } - (void)cancelAsyncRequests { [OFRunLoop of_cancelAsyncRequestsForObject: self]; } - (int)fileDescriptorForReading { #ifndef OF_WINDOWS return _socket; #else |
︙ | ︙ |
Modified src/OFXMLAttribute.m from [6356477585] to [464c2003f8].
︙ | ︙ | |||
51 52 53 54 55 56 57 | stringValue: stringValue]; } - initWithName: (OFString *)name namespace: (OFString *)namespace stringValue: (OFString *)stringValue { | | | | 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 | stringValue: stringValue]; } - initWithName: (OFString *)name namespace: (OFString *)namespace stringValue: (OFString *)stringValue { self = [super of_init]; @try { _name = [name copy]; _namespace = [namespace copy]; _stringValue = [stringValue copy]; } @catch (id e) { [self release]; @throw e; } return self; } - initWithSerialization: (OFXMLElement *)element { self = [super of_init]; @try { void *pool = objc_autoreleasePoolPush(); if (![[element name] isEqual: [self className]] || ![[element namespace] isEqual: OF_SERIALIZATION_NS]) @throw [OFInvalidArgumentException exception]; |
︙ | ︙ |
Modified src/OFXMLCDATA.m from [ccd956a73a] to [c06dfedaeb].
︙ | ︙ | |||
27 28 29 30 31 32 33 | + (instancetype)CDATAWithString: (OFString *)string { return [[[self alloc] initWithString: string] autorelease]; } - initWithString: (OFString *)string { | | | | 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 | + (instancetype)CDATAWithString: (OFString *)string { return [[[self alloc] initWithString: string] autorelease]; } - initWithString: (OFString *)string { self = [super of_init]; @try { _CDATA = [string copy]; } @catch (id e) { [self release]; @throw e; } return self; } - initWithSerialization: (OFXMLElement *)element { self = [super of_init]; @try { void *pool = objc_autoreleasePoolPush(); if (![[element name] isEqual: [self className]] || ![[element namespace] isEqual: OF_SERIALIZATION_NS]) @throw [OFInvalidArgumentException exception]; |
︙ | ︙ |
Modified src/OFXMLCharacters.m from [19c67d9f30] to [366dd6ac23].
︙ | ︙ | |||
27 28 29 30 31 32 33 | + (instancetype)charactersWithString: (OFString *)string { return [[[self alloc] initWithString: string] autorelease]; } - initWithString: (OFString *)string { | | | | 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 | + (instancetype)charactersWithString: (OFString *)string { return [[[self alloc] initWithString: string] autorelease]; } - initWithString: (OFString *)string { self = [super of_init]; @try { _characters = [string copy]; } @catch (id e) { [self release]; @throw e; } return self; } - initWithSerialization: (OFXMLElement *)element { self = [super of_init]; @try { void *pool = objc_autoreleasePoolPush(); if (![[element name] isEqual: [self className]] || ![[element namespace] isEqual: OF_SERIALIZATION_NS]) @throw [OFInvalidArgumentException exception]; |
︙ | ︙ |
Modified src/OFXMLComment.m from [60c54714c0] to [f4e7bbcd6f].
︙ | ︙ | |||
29 30 31 32 33 34 35 | + (instancetype)commentWithString: (OFString *)string { return [[[self alloc] initWithString: string] autorelease]; } - initWithString: (OFString *)string { | | | | 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 | + (instancetype)commentWithString: (OFString *)string { return [[[self alloc] initWithString: string] autorelease]; } - initWithString: (OFString *)string { self = [super of_init]; @try { _comment = [string copy]; } @catch (id e) { [self release]; @throw e; } return self; } - initWithSerialization: (OFXMLElement *)element { self = [super of_init]; @try { void *pool = objc_autoreleasePoolPush(); if (![[element name] isEqual: [self className]] || ![[element namespace] isEqual: OF_SERIALIZATION_NS]) @throw [OFInvalidArgumentException exception]; |
︙ | ︙ |
Modified src/OFXMLElement.m from [d59ef84b41] to [5451d232fb].
︙ | ︙ | |||
157 158 159 160 161 162 163 | stringValue: nil]; } - initWithName: (OFString *)name namespace: (OFString *)namespace stringValue: (OFString *)stringValue { | | | 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 | stringValue: nil]; } - initWithName: (OFString *)name namespace: (OFString *)namespace stringValue: (OFString *)stringValue { self = [super of_init]; @try { if (name == nil) @throw [OFInvalidArgumentException exception]; _name = [name copy]; _namespace = [namespace copy]; |
︙ | ︙ | |||
183 184 185 186 187 188 189 | } return self; } - initWithElement: (OFXMLElement *)element { | | | 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 | } return self; } - initWithElement: (OFXMLElement *)element { self = [super of_init]; @try { if (element == nil) @throw [OFInvalidArgumentException exception]; _name = [element->_name copy]; _namespace = [element->_namespace copy]; |
︙ | ︙ | |||
272 273 274 275 276 277 278 | return self; } #endif - initWithSerialization: (OFXMLElement *)element { | | | 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 | return self; } #endif - initWithSerialization: (OFXMLElement *)element { self = [super of_init]; @try { void *pool = objc_autoreleasePoolPush(); OFXMLElement *attributesElement, *namespacesElement; OFXMLElement *childrenElement; OFEnumerator *keyEnumerator, *objectEnumerator; id key, object; |
︙ | ︙ | |||
418 419 420 421 422 423 424 | } [ret makeImmutable]; return ret; } | | | 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 | } [ret makeImmutable]; return ret; } - (OFString *)of_XMLStringWithParent: (OFXMLElement *)parent namespaces: (OFDictionary *)allNamespaces indentation: (unsigned int)indentation level: (unsigned int)level { void *pool; char *cString; size_t length, i; |
︙ | ︙ | |||
587 588 589 590 591 592 593 | unsigned int ind = (indent ? indentation : 0); if (ind) [tmp addItem: "\n"]; if ([child isKindOfClass: [OFXMLElement class]]) childString = [(OFXMLElement *)child | | | 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 | unsigned int ind = (indent ? indentation : 0); if (ind) [tmp addItem: "\n"]; if ([child isKindOfClass: [OFXMLElement class]]) childString = [(OFXMLElement *)child of_XMLStringWithParent: self namespaces: allNamespaces indentation: ind level: level + 1]; else childString = [child XMLStringWithIndentation: ind level: level + 1]; |
︙ | ︙ | |||
662 663 664 665 666 667 668 | [self freeMemory: cString]; } return ret; } - (OFString *)XMLString { | | | | | 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 | [self freeMemory: cString]; } return ret; } - (OFString *)XMLString { return [self of_XMLStringWithParent: nil namespaces: nil indentation: 0 level: 0]; } - (OFString *)XMLStringWithIndentation: (unsigned int)indentation { return [self of_XMLStringWithParent: nil namespaces: nil indentation: indentation level: 0]; } - (OFString *)XMLStringWithIndentation: (unsigned int)indentation level: (unsigned int)level { return [self of_XMLStringWithParent: nil namespaces: nil indentation: indentation level: level]; } - (OFXMLElement *)XMLElementBySerializing { |
︙ | ︙ |
Modified src/OFXMLNode+Private.h from [28230f8098] to [a10bf304ec].
︙ | ︙ | |||
15 16 17 18 19 20 21 | */ #import "OFXMLNode.h" OF_ASSUME_NONNULL_BEGIN @interface OFXMLNode () | | | 15 16 17 18 19 20 21 22 23 24 25 | */ #import "OFXMLNode.h" OF_ASSUME_NONNULL_BEGIN @interface OFXMLNode () - (instancetype)of_init OF_METHOD_FAMILY(init); @end OF_ASSUME_NONNULL_END |
Modified src/OFXMLNode.m from [9e4a8b39c2] to [858e69720c].
︙ | ︙ | |||
16 17 18 19 20 21 22 | #include "config.h" #import "OFXMLNode.h" #import "OFString.h" @implementation OFXMLNode | | | 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | #include "config.h" #import "OFXMLNode.h" #import "OFString.h" @implementation OFXMLNode - (instancetype)of_init { return [super init]; } - init { OF_INVALID_INIT_METHOD |
︙ | ︙ |
Modified src/OFXMLParser.m from [f6cfcd55b0] to [9b8cdb5bf4].
︙ | ︙ | |||
143 144 145 146 147 148 149 | @implementation OFXMLParser @synthesize delegate = _delegate, depthLimit = _depthLimit; + (void)initialize { const SEL selectors_[OF_XMLPARSER_NUM_STATES] = { | | | | | | | | | | | | | | | | | | | | | | 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 | @implementation OFXMLParser @synthesize delegate = _delegate, depthLimit = _depthLimit; + (void)initialize { const SEL selectors_[OF_XMLPARSER_NUM_STATES] = { @selector(of_inByteOrderMarkState), @selector(of_outsideTagState), @selector(of_tagOpenedState), @selector(of_inProcessingInstructionsState), @selector(of_inTagNameState), @selector(of_inCloseTagNameState), @selector(of_inTagState), @selector(of_inAttributeNameState), @selector(of_expectAttributeEqualSignState), @selector(of_expectAttributeDelimiterState), @selector(of_inAttributeValueState), @selector(of_expectTagCloseState), @selector(of_expectSpaceOrTagCloseState), @selector(of_inExclamationMarkState), @selector(of_inCDATAOpeningState), @selector(of_inCDATAState), @selector(of_inCommentOpeningState), @selector(of_inCommentState1), @selector(of_inCommentState2), @selector(of_inDOCTYPEState) }; memcpy(selectors, selectors_, sizeof(selectors_)); for (size_t i = 0; i < OF_XMLPARSER_NUM_STATES; i++) { if (![self instancesRespondToSelector: selectors[i]]) @throw [OFInitializationFailedException exceptionWithClass: self]; |
︙ | ︙ | |||
298 299 300 301 302 303 304 | /* * The following methods handle the different states of the parser. They are * looked up in +[initialize] and put in a lookup table to speed things up. * One dispatch for every character would be way too slow! */ | | | | 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 | /* * The following methods handle the different states of the parser. They are * looked up in +[initialize] and put in a lookup table to speed things up. * One dispatch for every character would be way too slow! */ - (void)of_inByteOrderMarkState { if (_data[_i] != "\xEF\xBB\xBF"[_level]) { if (_level == 0) { _state = OF_XMLPARSER_OUTSIDE_TAG; _i--; return; } @throw [OFMalformedXMLException exceptionWithParser: self]; } if (_level++ == 2) _state = OF_XMLPARSER_OUTSIDE_TAG; _last = _i + 1; } /* Not in a tag */ - (void)of_outsideTagState { size_t length; if ((_finishedParsing || [_previous count] < 1) && _data[_i] != ' ' && _data[_i] != '\t' && _data[_i] != '\n' && _data[_i] != '\r' && _data[_i] != '<') @throw [OFMalformedXMLException exceptionWithParser: self]; |
︙ | ︙ | |||
351 352 353 354 355 356 357 | [_buffer removeAllItems]; _last = _i + 1; _state = OF_XMLPARSER_TAG_OPENED; } /* Tag was just opened */ | | | 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 | [_buffer removeAllItems]; _last = _i + 1; _state = OF_XMLPARSER_TAG_OPENED; } /* Tag was just opened */ - (void)of_tagOpenedState { if (_finishedParsing && _data[_i] != '!' && _data[_i] != '?') @throw [OFMalformedXMLException exceptionWithParser: self]; switch (_data[_i]) { case '?': _last = _i + 1; |
︙ | ︙ | |||
385 386 387 388 389 390 391 | _acceptProlog = false; _i--; break; } } /* <?xml […]?> */ | | | 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 | _acceptProlog = false; _i--; break; } } /* <?xml […]?> */ - (bool)of_parseXMLProcessingInstructions: (OFString *)pi { const char *cString; size_t length, last; int PIState = 0; OFString *attribute = nil; OFMutableString *value = nil; char piDelimiter = 0; |
︙ | ︙ | |||
473 474 475 476 477 478 479 | if (PIState != 0 || !hasVersion) return false; return true; } /* Inside processing instructions */ | | | | | 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 | if (PIState != 0 || !hasVersion) return false; return true; } /* Inside processing instructions */ - (void)of_inProcessingInstructionsState { if (_data[_i] == '?') _level = 1; else if (_level == 1 && _data[_i] == '>') { void *pool = objc_autoreleasePoolPush(); OFString *PI; appendToBuffer(_buffer, _data + _last, _encoding, _i - _last); PI = transformString(self, _buffer, 1, false); if ([PI isEqual: @"xml"] || [PI hasPrefix: @"xml "] || [PI hasPrefix: @"xml\t"] || [PI hasPrefix: @"xml\r"] || [PI hasPrefix: @"xml\n"]) if (![self of_parseXMLProcessingInstructions: PI]) @throw [OFMalformedXMLException exceptionWithParser: self]; if ([_delegate respondsToSelector: @selector(parser:foundProcessingInstructions:)]) [_delegate parser: self foundProcessingInstructions: PI]; objc_autoreleasePoolPop(pool); [_buffer removeAllItems]; _last = _i + 1; _state = OF_XMLPARSER_OUTSIDE_TAG; } else _level = 0; } /* Inside a tag, no name yet */ - (void)of_inTagNameState { void *pool; const char *bufferCString, *tmp; size_t length, bufferLength; OFString *bufferString; if (_data[_i] != ' ' && _data[_i] != '\t' && _data[_i] != '\n' && |
︙ | ︙ | |||
592 593 594 595 596 597 598 | objc_autoreleasePoolPop(pool); [_buffer removeAllItems]; _last = _i + 1; } /* Inside a close tag, no name yet */ | | | 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 | objc_autoreleasePoolPop(pool); [_buffer removeAllItems]; _last = _i + 1; } /* Inside a close tag, no name yet */ - (void)of_inCloseTagNameState { void *pool; const char *bufferCString, *tmp; size_t length, bufferLength; OFString *bufferString, *namespace; if (_data[_i] != ' ' && _data[_i] != '\t' && _data[_i] != '\n' && |
︙ | ︙ | |||
662 663 664 665 666 667 668 | : OF_XMLPARSER_EXPECT_SPACE_OR_TAG_CLOSE); if ([_previous count] == 0) _finishedParsing = true; } /* Inside a tag, name found */ | | | 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 | : OF_XMLPARSER_EXPECT_SPACE_OR_TAG_CLOSE); if ([_previous count] == 0) _finishedParsing = true; } /* Inside a tag, name found */ - (void)of_inTagState { void *pool; OFString *namespace; OFXMLAttribute *const *attributesObjects; size_t attributesCount; if (_data[_i] != '>' && _data[_i] != '/') { |
︙ | ︙ | |||
736 737 738 739 740 741 742 | _last = _i + 1; _state = (_data[_i] == '/' ? OF_XMLPARSER_EXPECT_TAG_CLOSE : OF_XMLPARSER_OUTSIDE_TAG); } /* Looking for attribute name */ | | | 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 | _last = _i + 1; _state = (_data[_i] == '/' ? OF_XMLPARSER_EXPECT_TAG_CLOSE : OF_XMLPARSER_OUTSIDE_TAG); } /* Looking for attribute name */ - (void)of_inAttributeNameState { void *pool; OFString *bufferString; const char *bufferCString, *tmp; size_t length, bufferLength; if (_data[_i] != '=' && _data[_i] != ' ' && _data[_i] != '\t' && |
︙ | ︙ | |||
782 783 784 785 786 787 788 | _last = _i + 1; _state = (_data[_i] == '=' ? OF_XMLPARSER_EXPECT_ATTRIBUTE_DELIMITER : OF_XMLPARSER_EXPECT_ATTRIBUTE_EQUAL_SIGN); } /* Expecting equal sign of an attribute */ | | | | | 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 | _last = _i + 1; _state = (_data[_i] == '=' ? OF_XMLPARSER_EXPECT_ATTRIBUTE_DELIMITER : OF_XMLPARSER_EXPECT_ATTRIBUTE_EQUAL_SIGN); } /* Expecting equal sign of an attribute */ - (void)of_expectAttributeEqualSignState { if (_data[_i] == '=') { _last = _i + 1; _state = OF_XMLPARSER_EXPECT_ATTRIBUTE_DELIMITER; return; } if (_data[_i] != ' ' && _data[_i] != '\t' && _data[_i] != '\n' && _data[_i] != '\r') @throw [OFMalformedXMLException exceptionWithParser: self]; } /* Expecting name/value delimiter of an attribute */ - (void)of_expectAttributeDelimiterState { _last = _i + 1; if (_data[_i] == ' ' || _data[_i] == '\t' || _data[_i] == '\n' || _data[_i] == '\r') return; if (_data[_i] != '\'' && _data[_i] != '"') @throw [OFMalformedXMLException exceptionWithParser: self]; _delimiter = _data[_i]; _state = OF_XMLPARSER_IN_ATTRIBUTE_VALUE; } /* Looking for attribute value */ - (void)of_inAttributeValueState { void *pool; OFString *attributeValue; size_t length; if (_data[_i] != _delimiter) return; |
︙ | ︙ | |||
851 852 853 854 855 856 857 | _attributeName = _attributePrefix = nil; _last = _i + 1; _state = OF_XMLPARSER_IN_TAG; } /* Expecting closing '>' */ | | | | | | | 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 | _attributeName = _attributePrefix = nil; _last = _i + 1; _state = OF_XMLPARSER_IN_TAG; } /* Expecting closing '>' */ - (void)of_expectTagCloseState { if (_data[_i] == '>') { _last = _i + 1; _state = OF_XMLPARSER_OUTSIDE_TAG; } else @throw [OFMalformedXMLException exceptionWithParser: self]; } /* Expecting closing '>' or space */ - (void)of_expectSpaceOrTagCloseState { if (_data[_i] == '>') { _last = _i + 1; _state = OF_XMLPARSER_OUTSIDE_TAG; } else if (_data[_i] != ' ' && _data[_i] != '\t' && _data[_i] != '\n' && _data[_i] != '\r') @throw [OFMalformedXMLException exceptionWithParser: self]; } /* In <! */ - (void)of_inExclamationMarkState { if (_finishedParsing && _data[_i] != '-') @throw [OFMalformedXMLException exceptionWithParser: self]; if (_data[_i] == '-') _state = OF_XMLPARSER_IN_COMMENT_OPENING; else if (_data[_i] == '[') { _state = OF_XMLPARSER_IN_CDATA_OPENING; _level = 0; } else if (_data[_i] == 'D') { _state = OF_XMLPARSER_IN_DOCTYPE; _level = 0; } else @throw [OFMalformedXMLException exceptionWithParser: self]; _last = _i + 1; } /* CDATA */ - (void)of_inCDATAOpeningState { if (_data[_i] != "CDATA["[_level]) @throw [OFMalformedXMLException exceptionWithParser: self]; if (++_level == 6) { _state = OF_XMLPARSER_IN_CDATA; _level = 0; } _last = _i + 1; } - (void)of_inCDATAState { if (_data[_i] == ']') _level++; else if (_data[_i] == '>' && _level >= 2) { void *pool = objc_autoreleasePoolPush(); OFString *CDATA; |
︙ | ︙ | |||
933 934 935 936 937 938 939 | _last = _i + 1; _state = OF_XMLPARSER_OUTSIDE_TAG; } else _level = 0; } /* Comment */ | | | | | 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 | _last = _i + 1; _state = OF_XMLPARSER_OUTSIDE_TAG; } else _level = 0; } /* Comment */ - (void)of_inCommentOpeningState { if (_data[_i] != '-') @throw [OFMalformedXMLException exceptionWithParser: self]; _last = _i + 1; _state = OF_XMLPARSER_IN_COMMENT_1; _level = 0; } - (void)of_inCommentState1 { if (_data[_i] == '-') _level++; else _level = 0; if (_level == 2) _state = OF_XMLPARSER_IN_COMMENT_2; } - (void)of_inCommentState2 { void *pool; OFString *comment; if (_data[_i] != '>') @throw [OFMalformedXMLException exceptionWithParser: self]; |
︙ | ︙ | |||
980 981 982 983 984 985 986 | [_buffer removeAllItems]; _last = _i + 1; _state = OF_XMLPARSER_OUTSIDE_TAG; } /* In <!DOCTYPE ...> */ | | | 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 | [_buffer removeAllItems]; _last = _i + 1; _state = OF_XMLPARSER_OUTSIDE_TAG; } /* In <!DOCTYPE ...> */ - (void)of_inDOCTYPEState { if ((_level < 6 && _data[_i] != "OCTYPE"[_level]) || (_level == 6 && _data[_i] != ' ' && _data[_i] != '\t' && _data[_i] != '\n' && _data[_i] != '\r')) @throw [OFMalformedXMLException exceptionWithParser: self]; _level++; |
︙ | ︙ |
Modified src/OFXMLProcessingInstructions.m from [76bf1f744c] to [ef7508c1b7].
︙ | ︙ | |||
29 30 31 32 33 34 35 | + (instancetype)processingInstructionsWithString: (OFString *)string { return [[[self alloc] initWithString: string] autorelease]; } - initWithString: (OFString *)string { | | | | 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 | + (instancetype)processingInstructionsWithString: (OFString *)string { return [[[self alloc] initWithString: string] autorelease]; } - initWithString: (OFString *)string { self = [super of_init]; @try { _processingInstructions = [string copy]; } @catch (id e) { [self release]; @throw e; } return self; } - initWithSerialization: (OFXMLElement *)element { self = [super of_init]; @try { void *pool = objc_autoreleasePoolPush(); if (![[element name] isEqual: [self className]] || ![[element namespace] isEqual: OF_SERIALIZATION_NS]) @throw [OFInvalidArgumentException exception]; |
︙ | ︙ |
Modified src/OFZIPArchive.m from [3ab00e0dd7] to [af4fea4ffc].
︙ | ︙ | |||
47 48 49 50 51 52 53 | * FIXME: Current limitations: * - Split archives are not supported. * - Write support is missing. * - Encrypted files cannot be read. */ @interface OFZIPArchive () | | | | 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 | * FIXME: Current limitations: * - Split archives are not supported. * - Write support is missing. * - Encrypted files cannot be read. */ @interface OFZIPArchive () - (void)of_readZIPInfo; - (void)of_readEntries; @end @interface OFZIPArchive_LocalFileHeader: OFObject { @public uint16_t _minVersionNeeded, _generalPurposeBitFlag, _compressionMethod; uint16_t _lastModifiedFileTime, _lastModifiedFileDate; |
︙ | ︙ | |||
156 157 158 159 160 161 162 | - initWithSeekableStream: (OFSeekableStream *)stream { self = [super init]; @try { _stream = [stream retain]; | | | | 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 | - initWithSeekableStream: (OFSeekableStream *)stream { self = [super init]; @try { _stream = [stream retain]; [self of_readZIPInfo]; [self of_readEntries]; } @catch (id e) { [self release]; @throw e; } return self; } |
︙ | ︙ | |||
192 193 194 195 196 197 198 | [_entries release]; [_pathToEntryMap release]; [_lastReturnedStream release]; [super dealloc]; } | | | 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 | [_entries release]; [_pathToEntryMap release]; [_lastReturnedStream release]; [super dealloc]; } - (void)of_readZIPInfo { void *pool = objc_autoreleasePoolPush(); uint16_t commentLength; of_offset_t offset = -22; bool valid = false; do { |
︙ | ︙ | |||
281 282 283 284 285 286 287 | _centralDirectoryOffset) @throw [OFOutOfRangeException exception]; } objc_autoreleasePoolPop(pool); } | | | | 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 | _centralDirectoryOffset) @throw [OFOutOfRangeException exception]; } objc_autoreleasePoolPop(pool); } - (void)of_readEntries { void *pool = objc_autoreleasePoolPush(); if (_centralDirectoryOffset < 0 || (of_offset_t)_centralDirectoryOffset != _centralDirectoryOffset) @throw [OFOutOfRangeException exception]; seekOrThrowInvalidFormat(_stream, (of_offset_t)_centralDirectoryOffset, SEEK_SET); _entries = [[OFMutableArray alloc] init]; _pathToEntryMap = [[OFMutableDictionary alloc] init]; for (size_t i = 0; i < _centralDirectoryEntries; i++) { OFZIPArchiveEntry *entry = [[[OFZIPArchiveEntry alloc] of_initWithStream: _stream] autorelease]; if ([_pathToEntryMap objectForKey: [entry fileName]] != nil) @throw [OFInvalidFormatException exception]; [_entries addObject: entry]; [_pathToEntryMap setObject: entry forKey: [entry fileName]]; |
︙ | ︙ | |||
334 335 336 337 338 339 340 | mode: @"rb" errNo: ENOENT]; [_lastReturnedStream close]; [_lastReturnedStream release]; _lastReturnedStream = nil; | | | 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 | mode: @"rb" errNo: ENOENT]; [_lastReturnedStream close]; [_lastReturnedStream release]; _lastReturnedStream = nil; offset64 = [entry of_localFileHeaderOffset]; if (offset64 < 0 || (of_offset_t)offset64 != offset64) @throw [OFOutOfRangeException exception]; seekOrThrowInvalidFormat(_stream, (of_offset_t)offset64, SEEK_SET); localFileHeader = [[[OFZIPArchive_LocalFileHeader alloc] initWithStream: _stream] autorelease]; |
︙ | ︙ | |||
430 431 432 433 434 435 436 | [super dealloc]; } - (bool)matchesEntry: (OFZIPArchiveEntry *)entry { if (_compressionMethod != [entry compressionMethod] || | | | | 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 | [super dealloc]; } - (bool)matchesEntry: (OFZIPArchiveEntry *)entry { if (_compressionMethod != [entry compressionMethod] || _lastModifiedFileTime != [entry of_lastModifiedFileTime] || _lastModifiedFileDate != [entry of_lastModifiedFileDate]) return false; if (!(_generalPurposeBitFlag & (1 << 3))) if (_CRC32 != [entry CRC32] || _compressedSize != [entry compressedSize] || _uncompressedSize != [entry uncompressedSize]) return false; |
︙ | ︙ |
Modified src/OFZIPArchiveEntry+Private.h from [70580d8166] to [f1b3349a83].
︙ | ︙ | |||
16 17 18 19 20 21 22 | #import "OFZIPArchive.h" OF_ASSUME_NONNULL_BEGIN @interface OFZIPArchiveEntry () @property (readonly, nonatomic) | | | | | 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | #import "OFZIPArchive.h" OF_ASSUME_NONNULL_BEGIN @interface OFZIPArchiveEntry () @property (readonly, nonatomic) uint16_t of_lastModifiedFileTime, of_lastModifiedFileDate; @property (readonly, nonatomic) int64_t of_localFileHeaderOffset; - (instancetype)of_initWithStream: (OFStream *)stream OF_METHOD_FAMILY(init); @end OF_ASSUME_NONNULL_END |
Modified src/OFZIPArchiveEntry.m from [103543f1f3] to [bdb8babfcc].
︙ | ︙ | |||
147 148 149 150 151 152 153 | @synthesize minVersionNeeded = _minVersionNeeded; @synthesize compressionMethod = _compressionMethod; @synthesize compressedSize = _compressedSize; @synthesize uncompressedSize = _uncompressedSize; @synthesize CRC32 = _CRC32; @synthesize versionSpecificAttributes = _versionSpecificAttributes; @synthesize generalPurposeBitFlag = _generalPurposeBitFlag; | | | | | | 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 | @synthesize minVersionNeeded = _minVersionNeeded; @synthesize compressionMethod = _compressionMethod; @synthesize compressedSize = _compressedSize; @synthesize uncompressedSize = _uncompressedSize; @synthesize CRC32 = _CRC32; @synthesize versionSpecificAttributes = _versionSpecificAttributes; @synthesize generalPurposeBitFlag = _generalPurposeBitFlag; @synthesize of_lastModifiedFileTime = _lastModifiedFileTime; @synthesize of_lastModifiedFileDate = _lastModifiedFileDate; @synthesize of_localFileHeaderOffset = _localFileHeaderOffset; - init { OF_INVALID_INIT_METHOD } - (instancetype)of_initWithStream: (OFStream *)stream { self = [super init]; @try { void *pool = objc_autoreleasePoolPush(); uint16_t fileNameLength, extraFieldLength, fileCommentLength; of_string_encoding_t encoding; |
︙ | ︙ |