ObjFW  Check-in [88b56f8ce9]

Overview
Comment:Merge trunk into branch "asn1"
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | asn1
Files: files | file ages | folders
SHA3-256: 88b56f8ce92d45276195beeb32ae9d35c94d35f245d9a1d653f7a5e404fdefc6
User & Date: js on 2021-04-07 22:27:04
Other Links: branch diff | manifest | tags
Context
2021-04-30
21:56
Merge trunk into branch "asn1" check-in: 4507e0bee3 user: js tags: asn1
2021-04-07
22:27
Merge trunk into branch "asn1" check-in: 88b56f8ce9 user: js tags: asn1
22:26
Remove leftovers from ASN.1 support check-in: dd7961ffd5 user: js tags: trunk
21:57
Merge trunk into branch "asn1" check-in: bbcb77703f user: js tags: asn1
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Modified src/OFConstantString.m from [415348861e] to [b52e6a55a7].

︙
175
176
177
178
179
180
181
182

183
184
185

186
187
188
189
190
191
192

175
176
177
178
179
180
181

182
183
184

185
186
187
188
189
190
191
192








-
+


-
+








- (id)mutableCopy
{
	[self finishInitialization];
	return [self mutableCopy];
}

/* From protocol OFComparing,  but overridden in OFString */
- (of_comparison_result_t)compare: (OFString *)object
- (of_comparison_result_t)compare: (OFString *)string
{
	[self finishInitialization];
	return [self compare: object];
	return [self compare: string];
}

/* From OFObject, but reimplemented in OFString */
- (bool)isEqual: (id)object
{
	[self finishInitialization];
	return [self isEqual: object];
︙
241
242
243
244
245
246
247
248

249
250
251

252
253
254
255
256
257
258

241
242
243
244
245
246
247

248
249
250

251
252
253
254
255
256
257
258








-
+


-
+









- (size_t)cStringLengthWithEncoding: (of_string_encoding_t)encoding
{
	[self finishInitialization];
	return [self cStringLengthWithEncoding: encoding];
}

- (of_comparison_result_t)caseInsensitiveCompare: (OFString *)otherString
- (of_comparison_result_t)caseInsensitiveCompare: (OFString *)string
{
	[self finishInitialization];
	return [self caseInsensitiveCompare: otherString];
	return [self caseInsensitiveCompare: string];
}

- (of_unichar_t)characterAtIndex: (size_t)idx
{
	[self finishInitialization];
	return [self characterAtIndex: idx];
}
︙

Modified src/OFData.m from [526e2e37ba] to [565aab28b7].

︙
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

446
447
448
449
450
451
452

453
454

455
456
457

458
459
460


461
462
463
464
465
466
467








-
+

-



-
+


-
-








		return false;
	if (memcmp(data.items, _items, _count * _itemSize) != 0)
		return false;

	return true;
}

- (of_comparison_result_t)compare: (id <OFComparing>)object
- (of_comparison_result_t)compare: (OFData *)data
{
	OFData *data;
	int comparison;
	size_t count, minCount;

	if (![(id)object isKindOfClass: [OFData class]])
	if (![data isKindOfClass: [OFData class]])
		@throw [OFInvalidArgumentException exception];

	data = (OFData *)object;

	if (data.itemSize != _itemSize)
		@throw [OFInvalidArgumentException exception];

	count = data.count;
	minCount = (_count > count ? count : _count);

	if ((comparison = memcmp(_items, data.items,
︙

Modified src/OFDate.m from [a6b8335541] to [c1ec0de284].

︙
561
562
563
564
565
566
567
568

569
570
571
572

573
574
575
576
577

578
579

580
581
582
583
584
585
586

561
562
563
564
565
566
567

568
569



570
571
572



573
574

575
576
577
578
579
580
581
582








-
+

-
-
-
+


-
-
-
+

-
+








}

- (id)copy
{
	return [self retain];
}

- (of_comparison_result_t)compare: (id <OFComparing>)object
- (of_comparison_result_t)compare: (OFDate *)date
{
	OFDate *otherDate;

	if (![(id)object isKindOfClass: [OFDate class]])
	if (![date isKindOfClass: [OFDate class]])
		@throw [OFInvalidArgumentException exception];

	otherDate = (OFDate *)object;

	if (self.timeIntervalSince1970 < otherDate.timeIntervalSince1970)
	if (self.timeIntervalSince1970 < date.timeIntervalSince1970)
		return OF_ORDERED_ASCENDING;
	if (self.timeIntervalSince1970 > otherDate.timeIntervalSince1970)
	if (self.timeIntervalSince1970 > date.timeIntervalSince1970)
		return OF_ORDERED_DESCENDING;

	return OF_ORDERED_SAME;
}

- (OFString *)description
{
︙

Modified src/OFNumber.m from [1b24e74726] to [965d322b8e].

︙
938
939
940
941
942
943
944
945

946
947
948
949

950
951
952
953
954
955
956
957
958
959

938
939
940
941
942
943
944

945
946



947
948


949
950
951
952
953
954
955








-
+

-
-
-
+

-
-









	if (isSigned(self) || isSigned(number))
		return (number.longLongValue == self.longLongValue);

	return (number.unsignedLongLongValue == self.unsignedLongLongValue);
}

- (of_comparison_result_t)compare: (id <OFComparing>)object
- (of_comparison_result_t)compare: (OFNumber *)number
{
	OFNumber *number;

	if (![(id)object isKindOfClass: [OFNumber class]])
	if (![number isKindOfClass: [OFNumber class]])
		@throw [OFInvalidArgumentException exception];

	number = (OFNumber *)object;

	if (isFloat(self) || isFloat(number)) {
		double double1 = self.doubleValue;
		double double2 = number.doubleValue;

		if (double1 > double2)
			return OF_ORDERED_DESCENDING;
︙

Modified src/OFString.m from [d43b0aa5cd] to [858181ff3a].

︙
1510
1511
1512
1513
1514
1515
1516
1517

1518
1519
1520
1521
1522
1523
1524
1525
1526
1527

1528
1529
1530

1531
1532
1533
1534
1535
1536

1537
1538
1539
1540
1541
1542
1543

1510
1511
1512
1513
1514
1515
1516

1517
1518
1519
1520
1521
1522
1523
1524
1525
1526

1527
1528
1529

1530
1531
1532
1533
1534
1535

1536
1537
1538
1539
1540
1541
1542
1543








-
+









-
+


-
+





-
+








	for (size_t i = 0; i < range.length; i++)
		buffer[i] = [self characterAtIndex: range.location + i];
}

- (bool)isEqual: (id)object
{
	void *pool;
	OFString *otherString;
	OFString *string;
	const of_unichar_t *characters, *otherCharacters;
	size_t length;

	if (object == self)
		return true;

	if (![object isKindOfClass: [OFString class]])
		return false;

	otherString = object;
	string = object;
	length = self.length;

	if (otherString.length != length)
	if (string.length != length)
		return false;

	pool = objc_autoreleasePoolPush();

	characters = self.characters;
	otherCharacters = otherString.characters;
	otherCharacters = string.characters;

	if (memcmp(characters, otherCharacters,
	    length * sizeof(of_unichar_t)) != 0) {
		objc_autoreleasePoolPop(pool);
		return false;
	}
︙
1552
1553
1554
1555
1556
1557
1558
1559

1560
1561
1562
1563
1564
1565
1566

1567
1568
1569

1570
1571
1572
1573
1574


1575
1576
1577
1578
1579

1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595

1596
1597

1598
1599
1600
1601
1602
1603

1604
1605
1606
1607
1608
1609

1610
1611
1612
1613

1614
1615

1616
1617
1618
1619
1620
1621
1622

1552
1553
1554
1555
1556
1557
1558

1559
1560
1561

1562
1563
1564

1565
1566
1567

1568
1569
1570



1571
1572
1573
1574
1575
1576

1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592

1593
1594

1595
1596
1597
1598
1599
1600

1601
1602
1603
1604
1605
1606

1607
1608
1609
1610

1611
1612

1613
1614
1615
1616
1617
1618
1619
1620








-
+


-



-
+


-
+


-
-
-
+
+




-
+















-
+

-
+





-
+





-
+



-
+

-
+








}

- (id)mutableCopy
{
	return [[OFMutableString alloc] initWithString: self];
}

- (of_comparison_result_t)compare: (id <OFComparing>)object
- (of_comparison_result_t)compare: (OFString *)string
{
	void *pool;
	OFString *otherString;
	const of_unichar_t *characters, *otherCharacters;
	size_t minimumLength;

	if (object == self)
	if (string == self)
		return OF_ORDERED_SAME;

	if (![(id)object isKindOfClass: [OFString class]])
	if (![string isKindOfClass: [OFString class]])
		@throw [OFInvalidArgumentException exception];

	otherString = (OFString *)object;
	minimumLength = (self.length > otherString.length
	    ? otherString.length : self.length);
	minimumLength = (self.length > string.length
	    ? string.length : self.length);

	pool = objc_autoreleasePoolPush();

	characters = self.characters;
	otherCharacters = otherString.characters;
	otherCharacters = string.characters;

	for (size_t i = 0; i < minimumLength; i++) {
		if (characters[i] > otherCharacters[i]) {
			objc_autoreleasePoolPop(pool);
			return OF_ORDERED_DESCENDING;
		}

		if (characters[i] < otherCharacters[i]) {
			objc_autoreleasePoolPop(pool);
			return OF_ORDERED_ASCENDING;
		}
	}

	objc_autoreleasePoolPop(pool);

	if (self.length > otherString.length)
	if (self.length > string.length)
		return OF_ORDERED_DESCENDING;
	if (self.length < otherString.length)
	if (self.length < string.length)
		return OF_ORDERED_ASCENDING;

	return OF_ORDERED_SAME;
}

- (of_comparison_result_t)caseInsensitiveCompare: (OFString *)otherString
- (of_comparison_result_t)caseInsensitiveCompare: (OFString *)string
{
	void *pool = objc_autoreleasePoolPush();
	const of_unichar_t *characters, *otherCharacters;
	size_t length, otherLength, minimumLength;

	if (otherString == self)
	if (string == self)
		return OF_ORDERED_SAME;

	characters = self.characters;
	otherCharacters = otherString.characters;
	otherCharacters = string.characters;
	length = self.length;
	otherLength = otherString.length;
	otherLength = string.length;

	minimumLength = (length > otherLength ? otherLength : length);

	for (size_t i = 0; i < minimumLength; i++) {
		of_unichar_t c = characters[i];
		of_unichar_t oc = otherCharacters[i];
︙

Modified src/OFTimer.m from [8d739f9efc] to [a68714fb85].

︙
502
503
504
505
506
507
508
509

510
511
512
513

514
515
516
517
518
519
520
521
522
523

502
503
504
505
506
507
508

509
510



511
512


513
514
515
516
517
518
519








-
+

-
-
-
+

-
-








#ifdef OF_HAVE_THREADS
	[_condition release];
#endif

	[super dealloc];
}

- (of_comparison_result_t)compare: (id <OFComparing>)object
- (of_comparison_result_t)compare: (OFTimer *)timer
{
	OFTimer *timer;

	if (![(id)object isKindOfClass: [OFTimer class]])
	if (![timer isKindOfClass: [OFTimer class]])
		@throw [OFInvalidArgumentException exception];

	timer = (OFTimer *)object;

	return [_fireDate compare: timer->_fireDate];
}

- (void)of_setInRunLoop: (OFRunLoop *)runLoop mode: (of_run_loop_mode_t)mode
{
	OFRunLoop *oldInRunLoop = _inRunLoop;
︙

Modified src/OFUTF8String.m from [b5e6f95eb4] to [2057b791a1].

︙
770
771
772
773
774
775
776
777

778
779
780
781
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
827
828
829
830
831
832
833
834
835

836
837
838
839
840
841
842
843
844

845
846
847
848
849
850
851


852
853
854
855
856
857
858

770
771
772
773
774
775
776

777
778
779
780
781
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
827
828
829
830
831

832
833
834
835
836
837
838
839
840

841
842
843





844
845
846
847
848
849
850
851
852








-
+







-
+

-
-
+
+


-
-
-
+
+
+
-


-
+





-
+

-



-
+


-
+


-
-
+



-
+














-
+








-
+


-
-
-
-
-
+
+








- (size_t)UTF8StringLength
{
	return _s->cStringLength;
}

- (bool)isEqual: (id)object
{
	OFUTF8String *otherString;
	OFUTF8String *string;

	if (object == self)
		return true;

	if (![object isKindOfClass: [OFString class]])
		return false;

	otherString = object;
	string = object;

	if (otherString.UTF8StringLength != _s->cStringLength ||
	    otherString.length != _s->length)
	if (string.UTF8StringLength != _s->cStringLength ||
	    string.length != _s->length)
		return false;

	if (([otherString isKindOfClass: [OFUTF8String class]] ||
	    [otherString isKindOfClass: [OFMutableUTF8String class]]) &&
	    _s->hashed && otherString->_s->hashed &&
	if (([string isKindOfClass: [OFUTF8String class]] ||
	    [string isKindOfClass: [OFMutableUTF8String class]]) &&
	    _s->hashed && string->_s->hashed && _s->hash != string->_s->hash)
	    _s->hash != otherString->_s->hash)
		return false;

	if (strcmp(_s->cString, otherString.UTF8String) != 0)
	if (strcmp(_s->cString, string.UTF8String) != 0)
		return false;

	return true;
}

- (of_comparison_result_t)compare: (id <OFComparing>)object
- (of_comparison_result_t)compare: (OFString *)string
{
	OFString *otherString;
	size_t otherCStringLength, minimumCStringLength;
	int compare;

	if (object == self)
	if (string == self)
		return OF_ORDERED_SAME;

	if (![(id)object isKindOfClass: [OFString class]])
	if (![string isKindOfClass: [OFString class]])
		@throw [OFInvalidArgumentException exception];

	otherString = (OFString *)object;
	otherCStringLength = otherString.UTF8StringLength;
	otherCStringLength = string.UTF8StringLength;
	minimumCStringLength = (_s->cStringLength > otherCStringLength
	    ? otherCStringLength : _s->cStringLength);

	if ((compare = memcmp(_s->cString, otherString.UTF8String,
	if ((compare = memcmp(_s->cString, string.UTF8String,
	    minimumCStringLength)) == 0) {
		if (_s->cStringLength > otherCStringLength)
			return OF_ORDERED_DESCENDING;
		if (_s->cStringLength < otherCStringLength)
			return OF_ORDERED_ASCENDING;
		return OF_ORDERED_SAME;
	}

	if (compare > 0)
		return OF_ORDERED_DESCENDING;
	else
		return OF_ORDERED_ASCENDING;
}

- (of_comparison_result_t)caseInsensitiveCompare: (OFString *)otherString
- (of_comparison_result_t)caseInsensitiveCompare: (OFString *)string
{
	const char *otherCString;
	size_t otherCStringLength, minimumCStringLength;
#ifdef OF_HAVE_UNICODE_TABLES
	size_t i, j;
#endif
	int compare;

	if (otherString == self)
	if (string == self)
		return OF_ORDERED_SAME;

	if (![otherString isKindOfClass: [OFString class]])
		@throw [OFInvalidArgumentException exception];

	otherCString = otherString.UTF8String;
	otherCStringLength = otherString.UTF8StringLength;
	otherCString = string.UTF8String;
	otherCStringLength = string.UTF8StringLength;

#ifdef OF_HAVE_UNICODE_TABLES
	if (!_s->isUTF8) {
#endif
		minimumCStringLength = (_s->cStringLength > otherCStringLength
		    ? otherCStringLength : _s->cStringLength);
︙

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