Modified generators/unicode/TableGenerator.m
from [4d33b76d8d]
to [d270af51c2].
︙ | | |
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
-
+
|
OFArray *decomposed = [[components objectAtIndex: 5]
componentsSeparatedByString: @" "];
bool compat = false;
OFMutableString *string;
if ([decomposed.firstObject hasPrefix: @"<"]) {
decomposed = [decomposed objectsInRange:
of_range(1, decomposed.count - 1)];
OFMakeRange(1, decomposed.count - 1)];
compat = true;
}
string = [OFMutableString string];
for (OFString *character in decomposed) {
of_unichar_t unichar = (of_unichar_t)[character
|
︙ | | |
Modified src/OFAdjacentArray.m
from [0ad6ceaf6f]
to [7938b92408].
︙ | | |
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
-
+
|
}
- (id)objectAtIndexedSubscript: (size_t)idx
{
return *((id *)[_array itemAtIndex: idx]);
}
- (void)getObjects: (id *)buffer inRange: (of_range_t)range
- (void)getObjects: (id *)buffer inRange: (OFRange)range
{
id const *objects = _array.items;
size_t count = _array.count;
if (range.length > SIZE_MAX - range.location ||
range.location + range.length > count)
@throw [OFOutOfRangeException exception];
|
︙ | | |
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
|
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
|
-
+
|
if (objects[i] == object)
return i;
return OF_NOT_FOUND;
}
- (OFArray *)objectsInRange: (of_range_t)range
- (OFArray *)objectsInRange: (OFRange)range
{
if (range.length > SIZE_MAX - range.location ||
range.location + range.length > _array.count)
@throw [OFOutOfRangeException exception];
if ([self isKindOfClass: [OFMutableArray class]])
return [OFArray
|
︙ | | |
Modified src/OFArray.h
from [891042f11e]
to [faed016421].
︙ | | |
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
|
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
|
-
+
|
/**
* @brief Copies the objects at the specified range to the specified buffer.
*
* @param buffer The buffer to copy the objects to
* @param range The range to copy
*/
- (void)getObjects: (ObjectType __unsafe_unretained _Nonnull *_Nonnull)buffer
inRange: (of_range_t)range;
inRange: (OFRange)range;
/**
* @brief Returns the index of the first object that is equivalent to the
* specified object or `OF_NOT_FOUND` if it was not found.
*
* @param object The object whose index is returned
* @return The index of the first object equivalent to the specified object
|
︙ | | |
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
|
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
|
-
+
|
/**
* @brief Returns the objects in the specified range as a new OFArray.
*
* @param range The range for the subarray
* @return The subarray as a new autoreleased OFArray
*/
- (OFArray OF_GENERIC(ObjectType) *)objectsInRange: (of_range_t)range;
- (OFArray OF_GENERIC(ObjectType) *)objectsInRange: (OFRange)range;
/**
* @brief Creates a string by joining all objects of the array.
*
* @param separator The string with which the objects should be joined
* @return A string containing all objects joined by the separator
*/
|
︙ | | |
Modified src/OFArray.m
from [cb54365db5]
to [dfd2b260d5].
︙ | | |
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
|
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
|
-
+
-
+
|
}
- (size_t)count
{
OF_UNRECOGNIZED_SELECTOR
}
- (void)getObjects: (id *)buffer inRange: (of_range_t)range
- (void)getObjects: (id *)buffer inRange: (OFRange)range
{
for (size_t i = 0; i < range.length; i++)
buffer[i] = [self objectAtIndex: range.location + i];
}
- (id const *)objects
{
size_t count = self.count;
id *buffer = of_alloc(count, sizeof(id));
@try {
[self getObjects: buffer inRange: of_range(0, count)];
[self getObjects: buffer inRange: OFMakeRange(0, count)];
return [[OFData dataWithItemsNoCopy: buffer
count: count
itemSize: sizeof(id)
freeWhenDone: true] items];
} @catch (id e) {
free(buffer);
|
︙ | | |
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
|
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
|
-
+
|
if (count > 0)
return [self objectAtIndex: count - 1];
return nil;
}
- (OFArray *)objectsInRange: (of_range_t)range
- (OFArray *)objectsInRange: (OFRange)range
{
OFArray *ret;
id *buffer;
if (range.length > SIZE_MAX - range.location ||
range.location + range.length < self.count)
@throw [OFOutOfRangeException exception];
|
︙ | | |
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
|
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
|
-
+
|
return new;
}
- (int)countByEnumeratingWithState: (of_fast_enumeration_state_t *)state
objects: (id *)objects
count: (int)count
{
of_range_t range = of_range(state->state, count);
OFRange range = OFMakeRange(state->state, count);
if (range.length > SIZE_MAX - range.location)
@throw [OFOutOfRangeException exception];
if (range.location + range.length > self.count)
range.length = self.count - range.location;
|
︙ | | |
Modified src/OFCharacterSet.h
from [213677c26a]
to [2510cc80c2].
︙ | | |
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
|
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
|
-
+
|
/**
* @brief Creates a new character set containing the characters in the specified
* range.
*
* @param range The range of characters for the character set
* @return A new OFCharacterSet
*/
+ (instancetype)characterSetWithRange: (of_range_t)range;
+ (instancetype)characterSetWithRange: (OFRange)range;
/**
* @brief A character set containing all Unicode characters in the category
* `Zs` plus CHARACTER TABULATION (U+0009).
*/
+ (OFCharacterSet *)whitespaceCharacterSet;
|
︙ | | |
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
-
+
|
/**
* @brief Initializes an already allocated character set with the characters in
* the specified range.
*
* @param range The range of characters for the character set
* @return An initialized OFCharacterSet
*/
- (instancetype)initWithRange: (of_range_t)range;
- (instancetype)initWithRange: (OFRange)range;
/**
* @brief Returns whether the specified character is a member of the character
* set.
*
* @param character The character that is checked for being a member of the
* character set
* @return Whether the specified character is a member of the character set.
*/
- (bool)characterIsMember: (of_unichar_t)character;
@end
OF_ASSUME_NONNULL_END
|
Modified src/OFCharacterSet.m
from [e06618edef]
to [9953d8febc].
︙ | | |
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
-
+
|
- (instancetype)initWithCharactersInString: (OFString *)characters
{
return (id)[[OFBitSetCharacterSet alloc]
initWithCharactersInString: characters];
}
- (instancetype)initWithRange: (of_range_t)range
- (instancetype)initWithRange: (OFRange)range
{
return (id)[[OFRangeCharacterSet alloc] initWithRange: range];
}
- (instancetype)retain
{
return self;
|
︙ | | |
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
|
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
|
-
+
|
+ (instancetype)characterSetWithCharactersInString: (OFString *)characters
{
return [[[self alloc] initWithCharactersInString: characters]
autorelease];
}
+ (instancetype)characterSetWithRange: (of_range_t)range
+ (instancetype)characterSetWithRange: (OFRange)range
{
return [[[self alloc] initWithRange: range] autorelease];
}
+ (OFCharacterSet *)whitespaceCharacterSet
{
static of_once_t onceControl = OF_ONCE_INIT;
|
︙ | | |
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
-
+
|
}
- (instancetype)initWithCharactersInString: (OFString *)characters
{
OF_INVALID_INIT_METHOD
}
- (instancetype)initWithRange: (of_range_t)range
- (instancetype)initWithRange: (OFRange)range
{
OF_INVALID_INIT_METHOD
}
- (bool)characterIsMember: (of_unichar_t)character
{
OF_UNRECOGNIZED_SELECTOR
|
︙ | | |
Modified src/OFConstantString.m
from [ae80fd102e]
to [0411bc7458].
︙ | | |
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
301
302
303
304
305
306
307
308
|
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
301
302
303
304
305
306
307
308
|
-
+
-
+
-
+
-
-
-
+
+
+
-
+
|
- (of_unichar_t)characterAtIndex: (size_t)idx
{
[self finishInitialization];
return [self characterAtIndex: idx];
}
- (void)getCharacters: (of_unichar_t *)buffer inRange: (of_range_t)range
- (void)getCharacters: (of_unichar_t *)buffer inRange: (OFRange)range
{
[self finishInitialization];
[self getCharacters: buffer inRange: range];
}
- (of_range_t)rangeOfString: (OFString *)string
- (OFRange)rangeOfString: (OFString *)string
{
[self finishInitialization];
return [self rangeOfString: string];
}
- (of_range_t)rangeOfString: (OFString *)string options: (int)options
- (OFRange)rangeOfString: (OFString *)string options: (int)options
{
[self finishInitialization];
return [self rangeOfString: string options: options];
}
- (of_range_t)rangeOfString: (OFString *)string
options: (int)options
range: (of_range_t)range
- (OFRange)rangeOfString: (OFString *)string
options: (int)options
range: (OFRange)range
{
[self finishInitialization];
return [self rangeOfString: string options: options range: range];
}
- (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet
{
[self finishInitialization];
return [self indexOfCharacterFromSet: characterSet];
}
- (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet
options: (int)options
{
[self finishInitialization];
return [self indexOfCharacterFromSet: characterSet options: options];
}
- (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet
options: (int)options
range: (of_range_t)range
range: (OFRange)range
{
[self finishInitialization];
return [self indexOfCharacterFromSet: characterSet
options: options
range: range];
}
|
︙ | | |
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
|
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
|
-
+
|
- (OFString *)substringToIndex: (size_t)idx
{
[self finishInitialization];
return [self substringToIndex: idx];
}
- (OFString *)substringWithRange: (of_range_t)range
- (OFString *)substringWithRange: (OFRange)range
{
[self finishInitialization];
return [self substringWithRange: range];
}
- (OFString *)stringByAppendingString: (OFString *)string
{
|
︙ | | |
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
|
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
|
-
+
|
return [self stringByReplacingOccurrencesOfString: string
withString: replacement];
}
- (OFString *)stringByReplacingOccurrencesOfString: (OFString *)string
withString: (OFString *)replacement
options: (int)options
range: (of_range_t)range
range: (OFRange)range
{
[self finishInitialization];
return [self stringByReplacingOccurrencesOfString: string
withString: replacement
options: options
range: range];
}
|
︙ | | |
Modified src/OFDNSResolverSettings.m
from [a893fa1b35]
to [5f1a9f53fd].
︙ | | |
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
-
+
|
static OFArray OF_GENERIC(OFString *) *
parseNetStackArray(OFString *string)
{
if (![string hasPrefix: @"["] || ![string hasSuffix: @"]"])
return nil;
string = [string substringWithRange: of_range(1, string.length - 2)];
string = [string substringWithRange: OFMakeRange(1, string.length - 2)];
return [string componentsSeparatedByString: @"|"];
}
#endif
@implementation OFDNSResolverSettings
- (void)dealloc
|
︙ | | |
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
|
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
|
-
+
|
options: OF_STRING_SKIP_EMPTY];
if (components.count < 2)
continue;
address = components.firstObject;
hosts = [components objectsInRange:
of_range(1, components.count - 1)];
OFMakeRange(1, components.count - 1)];
for (OFString *host in hosts) {
OFMutableArray *addresses =
[staticHosts objectForKey: host];
if (addresses == nil) {
addresses = [OFMutableArray array];
|
︙ | | |
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
|
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
|
-
+
|
if (components.count < 2) {
objc_autoreleasePoolPop(pool2);
continue;
}
option = components.firstObject;
arguments = [components objectsInRange:
of_range(1, components.count - 1)];
OFMakeRange(1, components.count - 1)];
if ([option isEqual: @"nameserver"]) {
if (arguments.count != 1) {
objc_autoreleasePoolPop(pool2);
continue;
}
|
︙ | | |
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
|
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
|
-
+
|
OFArray *hosts;
if (components.count < 2)
continue;
address = components.firstObject;
hosts = [components objectsInRange:
of_range(1, components.count - 1)];
OFMakeRange(1, components.count - 1)];
for (OFString *host in hosts) {
OFMutableArray *addresses =
[staticHosts objectForKey: host];
if (addresses == nil) {
addresses = [OFMutableArray array];
|
︙ | | |
Modified src/OFData.h
from [2943180e46]
to [bb1d7048ef].
︙ | | |
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
|
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
|
-
+
-
-
-
+
+
+
|
/**
* @brief Returns the data in the specified range as a new OFData.
*
* @param range The range of the data for the new OFData
* @return The data in the specified range as a new OFData
*/
- (OFData *)subdataWithRange: (of_range_t)range;
- (OFData *)subdataWithRange: (OFRange)range;
/**
* @brief Returns the range of the data.
*
* @param data The data to search for
* @param options Options modifying search behavior.@n
* Possible values are:
* Value | Description
* ---------------------------|-----------------------------
* `OF_DATA_SEARCH_BACKWARDS` | Search backwards in the data
* @param range The range in which to search
* @return The range of the first occurrence of the data or a range with
* `OF_NOT_FOUND` as start position if it was not found.
*/
- (of_range_t)rangeOfData: (OFData *)data
options: (int)options
range: (of_range_t)range;
- (OFRange)rangeOfData: (OFData *)data
options: (int)options
range: (OFRange)range;
#ifdef OF_HAVE_FILES
/**
* @brief Writes the OFData into the specified file.
*
* @param path The path of the file to write to
*/
|
︙ | | |
Modified src/OFData.m
from [54da306e4c]
to [2dbcaf9024].
︙ | | |
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
|
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
|
-
+
|
OF_HASH_ADD(hash, ((uint8_t *)_items)[i]);
OF_HASH_FINALIZE(hash);
return hash;
}
- (OFData *)subdataWithRange: (of_range_t)range
- (OFData *)subdataWithRange: (OFRange)range
{
OFData *ret;
if (range.length > SIZE_MAX - range.location ||
range.location + range.length > _count)
@throw [OFOutOfRangeException exception];
|
︙ | | |
541
542
543
544
545
546
547
548
549
550
551
552
553
554
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
582
583
584
585
586
587
588
589
590
591
592
593
594
595
|
541
542
543
544
545
546
547
548
549
550
551
552
553
554
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
582
583
584
585
586
587
588
589
590
591
592
593
594
595
|
-
-
-
+
+
+
-
+
-
+
-
+
-
+
-
+
|
}
- (OFString *)stringByBase64Encoding
{
return of_base64_encode(_items, _count * _itemSize);
}
- (of_range_t)rangeOfData: (OFData *)data
options: (int)options
range: (of_range_t)range
- (OFRange)rangeOfData: (OFData *)data
options: (int)options
range: (OFRange)range
{
const char *search;
size_t searchLength;
if (range.length > SIZE_MAX - range.location ||
range.location + range.length > _count)
@throw [OFOutOfRangeException exception];
if (data == nil || data.itemSize != _itemSize)
@throw [OFInvalidArgumentException exception];
if ((searchLength = data.count) == 0)
return of_range(0, 0);
return OFMakeRange(0, 0);
if (searchLength > range.length)
return of_range(OF_NOT_FOUND, 0);
return OFMakeRange(OF_NOT_FOUND, 0);
search = data.items;
if (options & OF_DATA_SEARCH_BACKWARDS) {
for (size_t i = range.length - searchLength;; i--) {
if (memcmp(_items + i * _itemSize, search,
searchLength * _itemSize) == 0)
return of_range(i, searchLength);
return OFMakeRange(i, searchLength);
/* No match and we're at the last item */
if (i == 0)
break;
}
} else {
for (size_t i = range.location;
i <= range.length - searchLength; i++)
if (memcmp(_items + i * _itemSize, search,
searchLength * _itemSize) == 0)
return of_range(i, searchLength);
return OFMakeRange(i, searchLength);
}
return of_range(OF_NOT_FOUND, 0);
return OFMakeRange(OF_NOT_FOUND, 0);
}
#ifdef OF_HAVE_FILES
- (void)writeToFile: (OFString *)path
{
OFFile *file = [[OFFile alloc] initWithPath: path mode: @"w"];
@try {
|
︙ | | |
Modified src/OFHTTPClient.m
from [3474437b44]
to [34f9c5b83e].
︙ | | |
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
|
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
|
-
+
-
+
|
return false;
}
if (![line hasPrefix: @"HTTP/"] || line.length < 9 ||
[line characterAtIndex: 8] != ' ')
@throw [OFInvalidServerReplyException exception];
_version = [[line substringWithRange: of_range(5, 3)] copy];
_version = [[line substringWithRange: OFMakeRange(5, 3)] copy];
if (![_version isEqual: @"1.0"] && ![_version isEqual: @"1.1"])
@throw [OFUnsupportedVersionException
exceptionWithVersion: _version];
status = [line substringWithRange: of_range(9, 3)].longLongValue;
status = [line substringWithRange: OFMakeRange(9, 3)].longLongValue;
if (status < 0 || status > 599)
@throw [OFInvalidServerReplyException exception];
_status = (short)status;
return true;
|
︙ | | |
Modified src/OFHTTPCookie.m
from [07b73513b9]
to [48027eefc6].
︙ | | |
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
|
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
|
-
+
-
+
-
+
|
last = i;
i--;
}
break;
case STATE_NAME:
if (characters[i] == '=') {
name = [string substringWithRange:
of_range(last, i - last)];
OFMakeRange(last, i - last)];
state = STATE_EXPECT_VALUE;
}
break;
case STATE_EXPECT_VALUE:
if (characters[i] == '"') {
state = STATE_QUOTED_VALUE;
last = i + 1;
} else {
state = STATE_VALUE;
last = i;
}
i--;
break;
case STATE_VALUE:
if (characters[i] == ';' || characters[i] == ',') {
value = [string substringWithRange:
of_range(last, i - last)];
OFMakeRange(last, i - last)];
[ret addObject:
[OFHTTPCookie cookieWithName: name
value: value
domain: domain]];
state = (characters[i] == ';'
? STATE_PRE_ATTR_NAME : STATE_PRE_NAME);
}
break;
case STATE_QUOTED_VALUE:
if (characters[i] == '"') {
value = [string substringWithRange:
of_range(last, i - last)];
OFMakeRange(last, i - last)];
[ret addObject:
[OFHTTPCookie cookieWithName: name
value: value
domain: domain]];
state = STATE_POST_QUOTED_VALUE;
}
|
︙ | | |
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
|
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
|
-
+
-
+
-
+
|
last = i;
i--;
}
break;
case STATE_ATTR_NAME:
if (characters[i] == '=') {
name = [string substringWithRange:
of_range(last, i - last)];
OFMakeRange(last, i - last)];
state = STATE_ATTR_VALUE;
last = i + 1;
} else if (characters[i] == ';' ||
characters[i] == ',') {
name = [string substringWithRange:
of_range(last, i - last)];
OFMakeRange(last, i - last)];
handleAttribute(ret.lastObject, name, nil);
state = (characters[i] == ';'
? STATE_PRE_ATTR_NAME : STATE_PRE_NAME);
}
break;
case STATE_ATTR_VALUE:
if (characters[i] == ';' || characters[i] == ',') {
value = [string substringWithRange:
of_range(last, i - last)];
OFMakeRange(last, i - last)];
/*
* Expires often contains a comma, even though
* the comma is used as a separator for
* concatenating headers as per RFC 2616,
* meaning RFC 6265 contradicts RFC 2616.
* Solve this by special casing this.
|
︙ | | |
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
|
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
|
-
+
-
+
-
+
|
break;
case STATE_NAME:
case STATE_QUOTED_VALUE:
@throw [OFInvalidFormatException exception];
break;
case STATE_VALUE:
value = [string substringWithRange:
of_range(last, length - last)];
OFMakeRange(last, length - last)];
[ret addObject: [OFHTTPCookie cookieWithName: name
value: value
domain: domain]];
break;
/* We end up here if the cookie is just foo= */
case STATE_EXPECT_VALUE:
[ret addObject: [OFHTTPCookie cookieWithName: name
value: @""
domain: domain]];
break;
case STATE_ATTR_NAME:
if (last != length) {
name = [string substringWithRange:
of_range(last, length - last)];
OFMakeRange(last, length - last)];
handleAttribute(ret.lastObject, name, nil);
}
break;
case STATE_ATTR_VALUE:
value = [string substringWithRange:
of_range(last, length - last)];
OFMakeRange(last, length - last)];
handleAttribute(ret.lastObject, name, value);
break;
}
objc_autoreleasePoolPop(pool);
|
︙ | | |
Modified src/OFHTTPServer.m
from [bf72062f11]
to [72e3c9c242].
︙ | | |
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
|
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
|
-
+
|
{
OFString *method;
OFMutableString *path;
size_t pos;
@try {
OFString *version = [line
substringWithRange: of_range(line.length - 9, 9)];
substringWithRange: OFMakeRange(line.length - 9, 9)];
of_unichar_t tmp;
if (![version hasPrefix: @" HTTP/1."])
return [self sendErrorAndClose: 505];
tmp = [version characterAtIndex: 8];
if (tmp < '0' || tmp > '9')
|
︙ | | |
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
|
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
|
-
+
|
@try {
_method = of_http_request_method_from_string(method);
} @catch (OFInvalidArgumentException *e) {
return [self sendErrorAndClose: 405];
}
@try {
of_range_t range = of_range(pos + 1, line.length - pos - 10);
OFRange range = OFMakeRange(pos + 1, line.length - pos - 10);
path = [[[line substringWithRange:
range] mutableCopy] autorelease];
} @catch (OFOutOfRangeException *e) {
return [self sendErrorAndClose: 400];
}
|
︙ | | |
Modified src/OFINICategory.m
from [3853ee5e40]
to [218aef4190].
︙ | | |
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
-
+
|
unescapeString(OFString *string)
{
OFMutableString *mutableString;
if (![string hasPrefix: @"\""] || ![string hasSuffix: @"\""])
return string;
string = [string substringWithRange: of_range(1, string.length - 2)];
string = [string substringWithRange: OFMakeRange(1, string.length - 2)];
mutableString = [[string mutableCopy] autorelease];
[mutableString replaceOccurrencesOfString: @"\\f" withString: @"\f"];
[mutableString replaceOccurrencesOfString: @"\\r" withString: @"\r"];
[mutableString replaceOccurrencesOfString: @"\\n" withString: @"\n"];
[mutableString replaceOccurrencesOfString: @"\\\"" withString: @"\""];
[mutableString replaceOccurrencesOfString: @"\\\\" withString: @"\\"];
|
︙ | | |
Modified src/OFINIFile.m
from [2183d90e0a]
to [5d8c2084f2].
︙ | | |
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
-
+
|
if ([line hasPrefix: @"["]) {
OFString *categoryName;
if (![line hasSuffix: @"]"])
@throw [OFInvalidFormatException exception];
categoryName = [line substringWithRange:
of_range(1, line.length - 2)];
OFMakeRange(1, line.length - 2)];
category = [[[OFINICategory alloc]
of_initWithName: categoryName] autorelease];
[_categories addObject: category];
} else {
if (category == nil)
@throw [OFInvalidFormatException exception];
|
︙ | | |
Modified src/OFMutableAdjacentArray.m
from [7c769150fe]
to [863f03f97e].
︙ | | |
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
|
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
|
-
+
|
for (size_t i = 0; i < count; i++)
[objects[i] release];
[_array removeAllItems];
}
- (void)removeObjectsInRange: (of_range_t)range
- (void)removeObjectsInRange: (OFRange)range
{
id const *objects = _array.items;
size_t count = _array.count;
id *copy;
if (range.length > SIZE_MAX - range.location ||
range.location >= count || range.length > count - range.location)
|
︙ | | |
Modified src/OFMutableArray.h
from [ffc0dffd0c]
to [73afdbce22].
︙ | | |
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
-
+
|
- (void)removeObjectAtIndex: (size_t)index;
/**
* @brief Removes the object in the specified range.
*
* @param range The range of the objects to remove
*/
- (void)removeObjectsInRange: (of_range_t)range;
- (void)removeObjectsInRange: (OFRange)range;
/**
* @brief Removes the last object.
*/
- (void)removeLastObject;
/**
|
︙ | | |
Modified src/OFMutableArray.m
from [38e99ca8e4]
to [3c3d4c88e1].
︙ | | |
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
386
387
388
389
390
|
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
386
387
388
389
390
|
-
+
-
+
|
[self removeObjectAtIndex: i];
return;
}
}
}
- (void)removeObjectsInRange: (of_range_t)range
- (void)removeObjectsInRange: (OFRange)range
{
for (size_t i = 0; i < range.length; i++)
[self removeObjectAtIndex: range.location];
}
- (void)removeLastObject
{
size_t count = self.count;
if (count == 0)
return;
[self removeObjectAtIndex: count - 1];
}
- (void)removeAllObjects
{
[self removeObjectsInRange: of_range(0, self.count)];
[self removeObjectsInRange: OFMakeRange(0, self.count)];
}
#ifdef OF_HAVE_BLOCKS
- (void)replaceObjectsUsingBlock: (of_array_replace_block_t)block
{
[self enumerateObjectsUsingBlock: ^ (id object, size_t idx,
bool *stop) {
|
︙ | | |
Modified src/OFMutableData.h
from [7e3b1e1f63]
to [8cc32bdba7].
︙ | | |
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
-
+
|
- (void)removeItemAtIndex: (size_t)index;
/**
* @brief Removes the specified amount of items at the specified index.
*
* @param range The range of items to remove
*/
- (void)removeItemsInRange: (of_range_t)range;
- (void)removeItemsInRange: (OFRange)range;
/**
* @brief Removes the last item.
*/
- (void)removeLastItem;
/**
|
︙ | | |
Modified src/OFMutableData.m
from [01aa579278]
to [641dd5b634].
︙ | | |
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
-
+
|
{
if (_items == NULL || _count == 0)
return NULL;
return _items + (_count - 1) * _itemSize;
}
- (OFData *)subdataWithRange: (of_range_t)range
- (OFData *)subdataWithRange: (OFRange)range
{
if (range.length > SIZE_MAX - range.location ||
range.location + range.length > _count)
@throw [OFOutOfRangeException exception];
return [OFData dataWithItems: _items + (range.location * _itemSize)
count: range.length
|
︙ | | |
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
|
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
|
-
+
-
+
|
memset(_items + _count * _itemSize, '\0', count * _itemSize);
_count += count;
}
- (void)removeItemAtIndex: (size_t)idx
{
[self removeItemsInRange: of_range(idx, 1)];
[self removeItemsInRange: OFMakeRange(idx, 1)];
}
- (void)removeItemsInRange: (of_range_t)range
- (void)removeItemsInRange: (OFRange)range
{
if (range.length > SIZE_MAX - range.location ||
range.location + range.length > _count)
@throw [OFOutOfRangeException exception];
memmove(_items + range.location * _itemSize,
_items + (range.location + range.length) * _itemSize,
|
︙ | | |
Modified src/OFMutableString.h
from [ae1870f5f2]
to [821dc3e159].
︙ | | |
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
-
+
-
+
|
- (void)insertString: (OFString *)string atIndex: (size_t)index;
/**
* @brief Deletes the characters at the specified range.
*
* @param range The range of the characters which should be removed
*/
- (void)deleteCharactersInRange: (of_range_t)range;
- (void)deleteCharactersInRange: (OFRange)range;
/**
* @brief Replaces the characters at the specified range.
*
* @param range The range of the characters which should be replaced
* @param replacement The string to the replace the characters with
*/
- (void)replaceCharactersInRange: (of_range_t)range
- (void)replaceCharactersInRange: (OFRange)range
withString: (OFString *)replacement;
/**
* @brief Replaces all occurrences of a string with another string.
*
* @param string The string to replace
* @param replacement The string with which it should be replaced
|
︙ | | |
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
-
+
|
* @param options Options modifying search behaviour
* Possible values: None yet
* @param range The range in which the string should be replaced
*/
- (void)replaceOccurrencesOfString: (OFString *)string
withString: (OFString *)replacement
options: (int)options
range: (of_range_t)range;
range: (OFRange)range;
/**
* @brief Deletes all whitespaces at the beginning of the string.
*/
- (void)deleteLeadingWhitespaces;
/**
|
︙ | | |
Modified src/OFMutableString.m
from [219bee6d83]
to [ba205102b7].
︙ | | |
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
|
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
|
-
+
|
#endif
- (void)setCharacter: (of_unichar_t)character atIndex: (size_t)idx
{
void *pool = objc_autoreleasePoolPush();
OFString *string =
[OFString stringWithCharacters: &character length: 1];
[self replaceCharactersInRange: of_range(idx, 1) withString: string];
[self replaceCharactersInRange: OFMakeRange(idx, 1) withString: string];
objc_autoreleasePoolPop(pool);
}
- (void)appendString: (OFString *)string
{
[self insertString: string atIndex: self.length];
}
|
︙ | | |
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
|
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
|
-
+
-
+
-
+
-
+
-
+
|
{
convert(self, of_ascii_toupper, of_ascii_tolower);
}
#endif
- (void)insertString: (OFString *)string atIndex: (size_t)idx
{
[self replaceCharactersInRange: of_range(idx, 0) withString: string];
[self replaceCharactersInRange: OFMakeRange(idx, 0) withString: string];
}
- (void)deleteCharactersInRange: (of_range_t)range
- (void)deleteCharactersInRange: (OFRange)range
{
[self replaceCharactersInRange: range withString: @""];
}
- (void)replaceCharactersInRange: (of_range_t)range
- (void)replaceCharactersInRange: (OFRange)range
withString: (OFString *)replacement
{
OF_UNRECOGNIZED_SELECTOR
}
- (void)replaceOccurrencesOfString: (OFString *)string
withString: (OFString *)replacement
{
[self replaceOccurrencesOfString: string
withString: replacement
options: 0
range: of_range(0, self.length)];
range: OFMakeRange(0, self.length)];
}
- (void)replaceOccurrencesOfString: (OFString *)string
withString: (OFString *)replacement
options: (int)options
range: (of_range_t)range
range: (OFRange)range
{
void *pool = objc_autoreleasePoolPush(), *pool2;
const of_unichar_t *characters;
const of_unichar_t *searchCharacters = string.characters;
size_t searchLength = string.length;
size_t replacementLength = replacement.length;
|
︙ | | |
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
|
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
|
-
+
|
characters = self.characters;
for (size_t i = range.location; i <= range.length - searchLength; i++) {
if (memcmp(characters + i, searchCharacters,
searchLength * sizeof(of_unichar_t)) != 0)
continue;
[self replaceCharactersInRange: of_range(i, searchLength)
[self replaceCharactersInRange: OFMakeRange(i, searchLength)
withString: replacement];
range.length -= searchLength;
range.length += replacementLength;
i += replacementLength - 1;
|
︙ | | |
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
|
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
|
-
+
|
if (!of_ascii_isspace(c))
break;
}
objc_autoreleasePoolPop(pool);
[self deleteCharactersInRange: of_range(0, i)];
[self deleteCharactersInRange: OFMakeRange(0, i)];
}
- (void)deleteTrailingWhitespaces
{
void *pool;
const of_unichar_t *characters, *p;
size_t length, d;
|
︙ | | |
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
|
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
|
-
+
|
break;
d++;
}
objc_autoreleasePoolPop(pool);
[self deleteCharactersInRange: of_range(length - d, d)];
[self deleteCharactersInRange: OFMakeRange(length - d, d)];
}
- (void)deleteEnclosingWhitespaces
{
[self deleteLeadingWhitespaces];
[self deleteTrailingWhitespaces];
}
|
︙ | | |
Modified src/OFMutableURL.m
from [66f15c46f8]
to [6cfd3507ce].
︙ | | |
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
-
+
|
- (void)setURLEncodedHost: (OFString *)URLEncodedHost
{
OFString *old;
if ([URLEncodedHost hasPrefix: @"["] &&
[URLEncodedHost hasSuffix: @"]"]) {
if (!of_url_is_ipv6_host([URLEncodedHost substringWithRange:
of_range(1, URLEncodedHost.length - 2)]))
OFMakeRange(1, URLEncodedHost.length - 2)]))
@throw [OFInvalidFormatException exception];
} else if (URLEncodedHost != nil)
of_url_verify_escaped(URLEncodedHost,
[OFCharacterSet URLHostAllowedCharacterSet]);
old = _URLEncodedHost;
_URLEncodedHost = [URLEncodedHost copy];
|
︙ | | |
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
|
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
|
-
+
|
done = false;
break;
}
if ([current isEqual: @".."] && parent != nil &&
![parent isEqual: @".."]) {
[array removeObjectsInRange:
of_range(i - 1, 2)];
OFMakeRange(i - 1, 2)];
done = false;
break;
}
}
}
|
︙ | | |
Modified src/OFMutableUTF8String.m
from [ae60bfdf29]
to [5528604b06].
︙ | | |
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
|
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
|
-
+
|
[string isKindOfClass: [OFMutableUTF8String class]]) {
if (((OFMutableUTF8String *)string)->_s->isUTF8)
_s->isUTF8 = true;
} else
_s->isUTF8 = true;
}
- (void)deleteCharactersInRange: (of_range_t)range
- (void)deleteCharactersInRange: (OFRange)range
{
size_t start = range.location;
size_t end = range.location + range.length;
if (range.length > SIZE_MAX - range.location || end > _s->length)
@throw [OFOutOfRangeException exception];
|
︙ | | |
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
|
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
|
-
+
|
@try {
_s->cString = of_realloc(_s->cString, _s->cStringLength + 1, 1);
} @catch (OFOutOfMemoryException *e) {
/* We don't really care, as we only made it smaller */
}
}
- (void)replaceCharactersInRange: (of_range_t)range
- (void)replaceCharactersInRange: (OFRange)range
withString: (OFString *)replacement
{
size_t start = range.location;
size_t end = range.location + range.length;
size_t newCStringLength, newLength;
if (replacement == nil)
|
︙ | | |
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
|
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
|
-
+
|
} else
_s->isUTF8 = true;
}
- (void)replaceOccurrencesOfString: (OFString *)string
withString: (OFString *)replacement
options: (int)options
range: (of_range_t)range
range: (OFRange)range
{
const char *searchString = string.UTF8String;
const char *replacementString = replacement.UTF8String;
size_t searchLength = string.UTF8StringLength;
size_t replacementLength = replacement.UTF8StringLength;
size_t last, newCStringLength, newLength;
char *newCString;
|
︙ | | |
Modified src/OFNumber.h
from [4ee73ac137]
to [39b3c2a529].
︙ | | |
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
-
+
|
@property (readonly, nonatomic) OFString *stringValue;
#ifdef OF_HAVE_UNAVAILABLE
+ (instancetype)valueWithBytes: (const void *)bytes
objCType: (const char *)objCType OF_UNAVAILABLE;
+ (instancetype)valueWithPointer: (const void *)pointer OF_UNAVAILABLE;
+ (instancetype)valueWithNonretainedObject: (id)object OF_UNAVAILABLE;
+ (instancetype)valueWithRange: (of_range_t)range OF_UNAVAILABLE;
+ (instancetype)valueWithRange: (OFRange)range OF_UNAVAILABLE;
+ (instancetype)valueWithPoint: (of_point_t)point OF_UNAVAILABLE;
+ (instancetype)valueWithDimension: (of_dimension_t)dimension OF_UNAVAILABLE;
+ (instancetype)valueWithRectangle: (of_rectangle_t)rectangle OF_UNAVAILABLE;
#endif
/**
* @brief Creates a new OFNumber with the specified `bool`.
|
︙ | | |
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
|
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
|
-
+
|
- (instancetype)init OF_UNAVAILABLE;
#ifdef OF_HAVE_UNAVAILABLE
- (instancetype)initWithBytes: (const void *)bytes
objCType: (const char *)objCType OF_UNAVAILABLE;
- (instancetype)initWithPointer: (const void *)pointer OF_UNAVAILABLE;
- (instancetype)initWithNonretainedObject: (id)object OF_UNAVAILABLE;
- (instancetype)initWithRange: (of_range_t)range OF_UNAVAILABLE;
- (instancetype)initWithRange: (OFRange)range OF_UNAVAILABLE;
- (instancetype)initWithPoint: (of_point_t)point OF_UNAVAILABLE;
- (instancetype)initWithDimension: (of_dimension_t)dimension OF_UNAVAILABLE;
- (instancetype)initWithRectangle: (of_rectangle_t)rectangle OF_UNAVAILABLE;
#endif
/**
* @brief Initializes an already allocated OFNumber with the specified `bool`.
|
︙ | | |
Modified src/OFObject.h
from [354a662802]
to [51e30260c3].
︙ | | |
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
|
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
|
-
+
-
+
-
+
-
+
-
+
-
-
+
+
-
+
-
+
|
OFByteOrderNative = OFByteOrderBigEndian
#else
OFByteOrderNative = OFByteOrderLittleEndian
#endif
} OFByteOrder;
/**
* @struct of_range_t OFObject.h ObjFW/OFObject.h
* @struct OFRange OFObject.h ObjFW/OFObject.h
*
* @brief A range.
*/
struct OF_BOXABLE of_range_t {
struct OF_BOXABLE OFRange {
/** The start of the range */
size_t location;
/** The length of the range */
size_t length;
};
typedef struct of_range_t of_range_t;
typedef struct OFRange OFRange;
/**
* @brief Creates a new of_range_t.
* @brief Creates a new OFRange.
*
* @param start The starting index of the range
* @param length The length of the range
* @return An of_range with the specified start and length
* @return An OFRangeith the specified start and length
*/
static OF_INLINE of_range_t OF_CONST_FUNC
of_range(size_t start, size_t length)
static OF_INLINE OFRange OF_CONST_FUNC
OFMakeRange(size_t start, size_t length)
{
of_range_t range = { start, length };
OFRange range = { start, length };
return range;
}
/**
* @brief Returns whether the two ranges are equal.
*
* @param range1 The first range for the comparison
* @param range2 The second range for the comparison
* @return Whether the two ranges are equal
*/
static OF_INLINE bool
of_range_equal(of_range_t range1, of_range_t range2)
OFEqualRanges(OFRange range1, OFRange range2)
{
if (range1.location != range2.location)
return false;
if (range1.length != range2.length)
return false;
|
︙ | | |
Modified src/OFOptionsParser.m
from [9cfc874f7b]
to [d1f92a8ca3].
︙ | | |
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
-
+
|
OF_NOT_FOUND)
_argument = [[argument
substringFromIndex: pos + 1] copy];
else
pos = argument.length;
_lastLongOption = [[argument substringWithRange:
of_range(2, pos - 2)] copy];
OFMakeRange(2, pos - 2)] copy];
objc_autoreleasePoolPop(pool);
option = [_longOptions objectForKey: _lastLongOption];
if (option == NULL)
return '?';
|
︙ | | |
267
268
269
270
271
272
273
274
275
276
|
267
268
269
270
271
272
273
274
275
276
|
-
+
|
return '?';
}
- (OFArray *)remainingArguments
{
return [_arguments objectsInRange:
of_range(_index, _arguments.count - _index)];
OFMakeRange(_index, _arguments.count - _index)];
}
@end
|
Modified src/OFRangeCharacterSet.h
from [146f282cd5]
to [36adda48b7].
︙ | | |
15
16
17
18
19
20
21
22
23
24
25
26
|
15
16
17
18
19
20
21
22
23
24
25
26
|
-
+
|
#import "OFCharacterSet.h"
OF_ASSUME_NONNULL_BEGIN
@interface OFRangeCharacterSet: OFCharacterSet
{
of_range_t _range;
OFRange _range;
}
@end
OF_ASSUME_NONNULL_END
|
Modified src/OFRangeCharacterSet.m
from [e174e57848]
to [e67323bc01].
︙ | | |
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
-
+
|
@implementation OFRangeCharacterSet
- (instancetype)init
{
OF_INVALID_INIT_METHOD
}
- (instancetype)initWithRange: (of_range_t)range
- (instancetype)initWithRange: (OFRange)range
{
self = [super init];
@try {
if (SIZE_MAX - range.location < range.length)
@throw [OFOutOfRangeException exception];
|
︙ | | |
Modified src/OFRangeValue.h
from [d625b84e6d]
to [364a68b940].
︙ | | |
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
-
+
-
+
|
#import "OFValue.h"
OF_ASSUME_NONNULL_BEGIN
@interface OFRangeValue: OFValue
{
of_range_t _range;
OFRange _range;
}
- (instancetype)initWithRange: (of_range_t)range;
- (instancetype)initWithRange: (OFRange)range;
@end
OF_ASSUME_NONNULL_END
|
Modified src/OFRangeValue.m
from [4b2520185b]
to [d1e5de9d18].
︙ | | |
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
-
+
-
+
-
+
|
#import "OFString.h"
#import "OFOutOfRangeException.h"
@implementation OFRangeValue
@synthesize rangeValue = _range;
- (instancetype)initWithRange: (of_range_t)range
- (instancetype)initWithRange: (OFRange)range
{
self = [super init];
_range = range;
return self;
}
- (const char *)objCType
{
return @encode(of_range_t);
return @encode(OFRange);
}
- (void)getValue: (void *)value size: (size_t)size
{
if (size != sizeof(_range))
@throw [OFOutOfRangeException exception];
memcpy(value, &_range, sizeof(_range));
}
- (OFString *)description
{
return [OFString stringWithFormat:
@"<OFValue: of_range_t { %zu, %zu }>",
@"<OFValue: OFRange { %zu, %zu }>",
_range.location, _range.length];
}
@end
|
Modified src/OFString.h
from [7fdd4e8be5]
to [69ba6f1fd0].
︙ | | |
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
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
|
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
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
|
-
+
-
+
-
+
-
-
-
+
+
+
|
/**
* @brief Copies the Unicode characters in the specified range to the specified
* buffer.
*
* @param buffer The buffer to store the Unicode characters
* @param range The range of the Unicode characters to copy
*/
- (void)getCharacters: (of_unichar_t *)buffer inRange: (of_range_t)range;
- (void)getCharacters: (of_unichar_t *)buffer inRange: (OFRange)range;
/**
* @brief Returns the range of the first occurrence of the string.
*
* @param string The string to search
* @return The range of the first occurrence of the string or a range with
* `OF_NOT_FOUND` as start position if it was not found
*/
- (of_range_t)rangeOfString: (OFString *)string;
- (OFRange)rangeOfString: (OFString *)string;
/**
* @brief Returns the range of the string.
*
* @param string The string to search
* @param options Options modifying search behavior.@n
* Possible values are:
* Value | Description
* -----------------------------|-------------------------------
* `OF_STRING_SEARCH_BACKWARDS` | Search backwards in the string
* @return The range of the first occurrence of the string or a range with
* `OF_NOT_FOUND` as start position if it was not found
*/
- (of_range_t)rangeOfString: (OFString *)string options: (int)options;
- (OFRange)rangeOfString: (OFString *)string options: (int)options;
/**
* @brief Returns the range of the string in the specified range.
*
* @param string The string to search
* @param options Options modifying search behaviour.@n
* Possible values are:
* Value | Description
* -----------------------------|-------------------------------
* `OF_STRING_SEARCH_BACKWARDS` | Search backwards in the string
* @param range The range in which to search
* @return The range of the first occurrence of the string or a range with
* `OF_NOT_FOUND` as start position if it was not found
*/
- (of_range_t)rangeOfString: (OFString *)string
options: (int)options
range: (of_range_t)range;
- (OFRange)rangeOfString: (OFString *)string
options: (int)options
range: (OFRange)range;
/**
* @brief Returns the index of the first character from the set.
*
* @param characterSet The set of characters to search for
* @return The index of the first occurrence of a character from the set or
* `OF_NOT_FOUND` if it was not found
|
︙ | | |
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
|
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
|
-
+
|
* `OF_STRING_SEARCH_BACKWARDS` | Search backwards in the string
* @param range The range in which to search
* @return The index of the first occurrence of a character from the set or
* `OF_NOT_FOUND` if it was not found
*/
- (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet
options: (int)options
range: (of_range_t)range;
range: (OFRange)range;
/**
* @brief Returns whether the string contains the specified string.
*
* @param string The string to search
* @return Whether the string contains the specified string
*/
|
︙ | | |
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
|
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
|
-
+
|
/**
* @brief Creates a substring with the specified range.
*
* @param range The range of the substring
* @return The substring as a new autoreleased OFString
*/
- (OFString *)substringWithRange: (of_range_t)range;
- (OFString *)substringWithRange: (OFRange)range;
/**
* @brief The value of the string in the specified base as a `long long`.
*
* Leading and trailing whitespaces are ignored.
*
* If the string contains any non-number characters, an
|
︙ | | |
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
|
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
|
-
+
|
* * None yet
* @param range The range in which to replace the string
* @return A new string with the occurrences of the specified string replaced
*/
- (OFString *)stringByReplacingOccurrencesOfString: (OFString *)string
withString: (OFString *)replacement
options: (int)options
range: (of_range_t)range;
range: (OFRange)range;
/**
* @brief Checks whether the string has the specified prefix.
*
* @param prefix The prefix to check for
* @return A boolean whether the string has the specified prefix
*/
|
︙ | | |
Modified src/OFString.m
from [357ffae861]
to [9b61edd18e].
︙ | | |
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
|
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
|
-
+
|
- (of_unichar_t)characterAtIndex: (size_t)idx
{
OF_UNRECOGNIZED_SELECTOR
}
- (void)getCharacters: (of_unichar_t *)buffer
inRange: (of_range_t)range
inRange: (OFRange)range
{
for (size_t i = 0; i < range.length; i++)
buffer[i] = [self characterAtIndex: range.location + i];
}
- (bool)isEqual: (id)object
{
|
︙ | | |
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
|
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
|
-
+
-
+
-
+
-
+
-
-
-
+
+
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
|
@throw [OFOutOfRangeException exception];
[data addItems: self.UTF8String count: length];
return data;
}
- (of_range_t)rangeOfString: (OFString *)string
- (OFRange)rangeOfString: (OFString *)string
{
return [self rangeOfString: string
options: 0
range: of_range(0, self.length)];
range: OFMakeRange(0, self.length)];
}
- (of_range_t)rangeOfString: (OFString *)string options: (int)options
- (OFRange)rangeOfString: (OFString *)string options: (int)options
{
return [self rangeOfString: string
options: options
range: of_range(0, self.length)];
range: OFMakeRange(0, self.length)];
}
- (of_range_t)rangeOfString: (OFString *)string
options: (int)options
range: (of_range_t)range
- (OFRange)rangeOfString: (OFString *)string
options: (int)options
range: (OFRange)range
{
void *pool;
const of_unichar_t *searchCharacters;
of_unichar_t *characters;
size_t searchLength;
if ((searchLength = string.length) == 0)
return of_range(0, 0);
return OFMakeRange(0, 0);
if (searchLength > range.length)
return of_range(OF_NOT_FOUND, 0);
return OFMakeRange(OF_NOT_FOUND, 0);
if (range.length > SIZE_MAX / sizeof(of_unichar_t))
@throw [OFOutOfRangeException exception];
pool = objc_autoreleasePoolPush();
searchCharacters = string.characters;
characters = of_alloc(range.length, sizeof(of_unichar_t));
@try {
[self getCharacters: characters inRange: range];
if (options & OF_STRING_SEARCH_BACKWARDS) {
for (size_t i = range.length - searchLength;; i--) {
if (memcmp(characters + i, searchCharacters,
searchLength * sizeof(of_unichar_t)) == 0) {
objc_autoreleasePoolPop(pool);
return of_range(range.location + i,
return OFMakeRange(range.location + i,
searchLength);
}
/* No match and we're at the last character */
if (i == 0)
break;
}
} else {
for (size_t i = 0;
i <= range.length - searchLength; i++) {
if (memcmp(characters + i, searchCharacters,
searchLength * sizeof(of_unichar_t)) == 0) {
objc_autoreleasePoolPop(pool);
return of_range(range.location + i,
return OFMakeRange(range.location + i,
searchLength);
}
}
}
} @finally {
free(characters);
}
objc_autoreleasePoolPop(pool);
return of_range(OF_NOT_FOUND, 0);
return OFMakeRange(OF_NOT_FOUND, 0);
}
- (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet
{
return [self indexOfCharacterFromSet: characterSet
options: 0
range: of_range(0, self.length)];
range: OFMakeRange(0, self.length)];
}
- (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet
options: (int)options
{
return [self indexOfCharacterFromSet: characterSet
options: options
range: of_range(0, self.length)];
range: OFMakeRange(0, self.length)];
}
- (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet
options: (int)options
range: (of_range_t)range
range: (OFRange)range
{
bool (*characterIsMember)(id, SEL, of_unichar_t) =
(bool (*)(id, SEL, of_unichar_t))[characterSet
methodForSelector: @selector(characterIsMember:)];
of_unichar_t *characters;
if (range.length == 0)
|
︙ | | |
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
|
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
|
-
+
-
+
-
+
|
objc_autoreleasePoolPop(pool);
return false;
}
- (OFString *)substringFromIndex: (size_t)idx
{
return [self substringWithRange: of_range(idx, self.length - idx)];
return [self substringWithRange: OFMakeRange(idx, self.length - idx)];
}
- (OFString *)substringToIndex: (size_t)idx
{
return [self substringWithRange: of_range(0, idx)];
return [self substringWithRange: OFMakeRange(0, idx)];
}
- (OFString *)substringWithRange: (of_range_t)range
- (OFString *)substringWithRange: (OFRange)range
{
void *pool;
OFString *ret;
if (range.length > SIZE_MAX - range.location ||
range.location + range.length > self.length)
@throw [OFOutOfRangeException exception];
|
︙ | | |
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
|
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
|
-
+
|
[new makeImmutable];
return new;
}
- (OFString *)stringByReplacingOccurrencesOfString: (OFString *)string
withString: (OFString *)replacement
options: (int)options
range: (of_range_t)range
range: (OFRange)range
{
OFMutableString *new = [[self mutableCopy] autorelease];
[new replaceOccurrencesOfString: string
withString: replacement
options: options
range: range];
[new makeImmutable];
|
︙ | | |
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
|
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
|
-
+
|
if ((prefixLength = prefix.length) > self.length)
return false;
tmp = of_alloc(prefixLength, sizeof(of_unichar_t));
@try {
void *pool = objc_autoreleasePoolPush();
[self getCharacters: tmp inRange: of_range(0, prefixLength)];
[self getCharacters: tmp inRange: OFMakeRange(0, prefixLength)];
hasPrefix = (memcmp(tmp, prefix.characters,
prefixLength * sizeof(of_unichar_t)) == 0);
objc_autoreleasePoolPop(pool);
} @finally {
free(tmp);
|
︙ | | |
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
|
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
|
-
+
|
length = self.length;
tmp = of_alloc(suffixLength, sizeof(of_unichar_t));
@try {
void *pool = objc_autoreleasePoolPush();
[self getCharacters: tmp
inRange: of_range(length - suffixLength,
inRange: OFMakeRange(length - suffixLength,
suffixLength)];
suffixCharacters = suffix.characters;
hasSuffix = (memcmp(tmp, suffixCharacters,
suffixLength * sizeof(of_unichar_t)) == 0);
objc_autoreleasePoolPop(pool);
|
︙ | | |
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
|
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
|
-
+
+
-
+
|
last = 0;
for (size_t i = 0; i <= length - delimiterLength; i++) {
if (memcmp(characters + i, delimiterCharacters,
delimiterLength * sizeof(of_unichar_t)) != 0)
continue;
component = [self substringWithRange: of_range(last, i - last)];
component = [self substringWithRange:
OFMakeRange(last, i - last)];
if (!skipEmpty || component.length > 0)
[array addObject: component];
i += delimiterLength - 1;
last = i + 1;
}
component = [self substringWithRange: of_range(last, length - last)];
component = [self substringWithRange: OFMakeRange(last, length - last)];
if (!skipEmpty || component.length > 0)
[array addObject: component];
[array makeImmutable];
objc_autoreleasePoolPop(pool);
|
︙ | | |
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
|
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
|
-
+
-
+
|
last = 0;
for (size_t i = 0; i < length; i++) {
if (characterIsMember(characterSet,
@selector(characterIsMember:), characters[i])) {
if (!skipEmpty || i != last) {
OFString *component = [self substringWithRange:
of_range(last, i - last)];
OFMakeRange(last, i - last)];
[array addObject: component];
}
last = i + 1;
}
}
if (!skipEmpty || length != last) {
OFString *component = [self substringWithRange:
of_range(last, length - last)];
OFMakeRange(last, length - last)];
[array addObject: component];
}
[array makeImmutable];
objc_autoreleasePoolPop(pool);
|
︙ | | |
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
|
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
|
-
+
|
- (const of_unichar_t *)characters
{
size_t length = self.length;
of_unichar_t *buffer;
buffer = of_alloc(length, sizeof(of_unichar_t));
@try {
[self getCharacters: buffer inRange: of_range(0, length)];
[self getCharacters: buffer inRange: OFMakeRange(0, length)];
return [[OFData dataWithItemsNoCopy: buffer
count: length
itemSize: sizeof(of_unichar_t)
freeWhenDone: true] items];
} @catch (id e) {
free(buffer);
|
︙ | | |
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
|
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
|
-
+
|
- (const of_char32_t *)UTF32StringWithByteOrder: (OFByteOrder)byteOrder
{
size_t length = self.length;
of_char32_t *buffer;
buffer = of_alloc(length + 1, sizeof(of_char32_t));
@try {
[self getCharacters: buffer inRange: of_range(0, length)];
[self getCharacters: buffer inRange: OFMakeRange(0, length)];
buffer[length] = 0;
if (byteOrder != OFByteOrderNative)
for (size_t i = 0; i < length; i++)
buffer[i] = OF_BSWAP32(buffer[i]);
return [[OFData dataWithItemsNoCopy: buffer
|
︙ | | |
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
|
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
|
-
+
-
+
|
continue;
}
if (characters[i] == '\n' || characters[i] == '\r') {
void *pool2 = objc_autoreleasePoolPush();
block([self substringWithRange:
of_range(last, i - last)], &stop);
OFMakeRange(last, i - last)], &stop);
last = i + 1;
objc_autoreleasePoolPop(pool2);
}
lastCarriageReturn = (characters[i] == '\r');
}
if (!stop)
block([self substringWithRange: of_range(last, i - last)],
block([self substringWithRange: OFMakeRange(last, i - last)],
&stop);
objc_autoreleasePoolPop(pool);
}
#endif
@end
|
Modified src/OFSubarray.h
from [a7a115b770]
to [398ae6fbae].
︙ | | |
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
-
+
-
-
+
+
|
#import "OFArray.h"
OF_ASSUME_NONNULL_BEGIN
@interface OFSubarray: OFArray
{
OFArray *_array;
of_range_t _range;
OFRange _range;
}
+ (instancetype)arrayWithArray: (OFArray *)array range: (of_range_t)range;
- (instancetype)initWithArray: (OFArray *)array range: (of_range_t)range;
+ (instancetype)arrayWithArray: (OFArray *)array range: (OFRange)range;
- (instancetype)initWithArray: (OFArray *)array range: (OFRange)range;
@end
OF_ASSUME_NONNULL_END
|
Modified src/OFSubarray.m
from [a275f23615]
to [b218747221].
︙ | | |
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
-
+
-
+
|
#include "config.h"
#import "OFSubarray.h"
#import "OFOutOfRangeException.h"
@implementation OFSubarray
+ (instancetype)arrayWithArray: (OFArray *)array range: (of_range_t)range
+ (instancetype)arrayWithArray: (OFArray *)array range: (OFRange)range
{
return [[[self alloc] initWithArray: array range: range] autorelease];
}
- (instancetype)initWithArray: (OFArray *)array range: (of_range_t)range
- (instancetype)initWithArray: (OFArray *)array range: (OFRange)range
{
self = [super init];
@try {
/* Should usually be retain, as it's useless with a copy */
_array = [array copy];
_range = range;
|
︙ | | |
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
-
+
|
{
if (idx >= _range.length)
@throw [OFOutOfRangeException exception];
return [_array objectAtIndex: idx + _range.location];
}
- (void)getObjects: (id *)buffer inRange: (of_range_t)range
- (void)getObjects: (id *)buffer inRange: (OFRange)range
{
if (range.length > SIZE_MAX - range.location ||
range.location + range.length > _range.length)
@throw [OFOutOfRangeException exception];
range.location += _range.location;
|
︙ | | |
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
-
+
|
if (idx >= _range.length)
return OF_NOT_FOUND;
return idx;
}
- (OFArray *)objectsInRange: (of_range_t)range
- (OFArray *)objectsInRange: (OFRange)range
{
if (range.length > SIZE_MAX - range.location ||
range.location + range.length > _range.length)
@throw [OFOutOfRangeException exception];
range.location += _range.location;
return [_array objectsInRange: range];
}
@end
|
Modified src/OFSystemInfo.m
from [6c63cf09e4]
to [8425925bcc].
︙ | | |
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
|
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
|
-
+
|
OFString *home;
if ((home = [env objectForKey: @"HOME"]) == nil)
@throw [OFNotImplementedException
exceptionWithSelector: _cmd
object: self];
[path deleteCharactersInRange: of_range(0, 1)];
[path deleteCharactersInRange: OFMakeRange(0, 1)];
[path prependString: home];
}
[path makeImmutable];
return path;
# elif defined(OF_WINDOWS)
|
︙ | | |
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
|
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
|
-
+
|
OFString *home;
if ((home = [env objectForKey: @"HOME"]) == nil)
@throw [OFNotImplementedException
exceptionWithSelector: _cmd
object: self];
[path deleteCharactersInRange: of_range(0, 1)];
[path deleteCharactersInRange: OFMakeRange(0, 1)];
[path prependString: home];
}
[path appendString: @"/Preferences"];
[path makeImmutable];
return path;
|
︙ | | |
Modified src/OFURL.m
from [c6fcf8ea2f]
to [e76bba4226].
︙ | | |
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
|
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
|
-
+
|
copy];
else {
OFMutableString *path = [OFMutableString
stringWithString:
(URL->_URLEncodedPath != nil
? URL->_URLEncodedPath
: @"/")];
of_range_t range = [path
OFRange range = [path
rangeOfString: @"/"
options: OF_STRING_SEARCH_BACKWARDS];
if (range.location == OF_NOT_FOUND)
@throw [OFInvalidFormatException
exception];
|
︙ | | |
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
|
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
|
-
+
|
}
- (OFString *)host
{
if ([_URLEncodedHost hasPrefix: @"["] &&
[_URLEncodedHost hasSuffix: @"]"]) {
OFString *host = [_URLEncodedHost substringWithRange:
of_range(1, _URLEncodedHost.length - 2)];
OFMakeRange(1, _URLEncodedHost.length - 2)];
if (!of_url_is_ipv6_host(host))
@throw [OFInvalidArgumentException exception];
return host;
}
|
︙ | | |
Modified src/OFUTF8String.m
from [afaff8f361]
to [70226f2f8c].
︙ | | |
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
|
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
|
-
+
-
-
-
+
+
+
|
if (of_string_utf8_decode(_s->cString + idx,
_s->cStringLength - idx, &character) <= 0)
@throw [OFInvalidEncodingException exception];
return character;
}
- (void)getCharacters: (of_unichar_t *)buffer inRange: (of_range_t)range
- (void)getCharacters: (of_unichar_t *)buffer inRange: (OFRange)range
{
/* TODO: Could be slightly optimized */
void *pool = objc_autoreleasePoolPush();
const of_unichar_t *characters = self.characters;
if (range.length > SIZE_MAX - range.location ||
range.location + range.length > _s->length)
@throw [OFOutOfRangeException exception];
memcpy(buffer, characters + range.location,
range.length * sizeof(of_unichar_t));
objc_autoreleasePoolPop(pool);
}
- (of_range_t)rangeOfString: (OFString *)string
options: (int)options
range: (of_range_t)range
- (OFRange)rangeOfString: (OFString *)string
options: (int)options
range: (OFRange)range
{
const char *cString = string.UTF8String;
size_t cStringLength = string.UTF8StringLength;
size_t rangeLocation, rangeLength;
if (range.length > SIZE_MAX - range.location ||
range.location + range.length > _s->length)
|
︙ | | |
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
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
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
|
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
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
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
|
-
+
-
+
-
+
-
+
-
+
|
_s->cStringLength - rangeLocation);
} else {
rangeLocation = range.location;
rangeLength = range.length;
}
if (cStringLength == 0)
return of_range(0, 0);
return OFMakeRange(0, 0);
if (cStringLength > rangeLength)
return of_range(OF_NOT_FOUND, 0);
return OFMakeRange(OF_NOT_FOUND, 0);
if (options & OF_STRING_SEARCH_BACKWARDS) {
for (size_t i = rangeLength - cStringLength;; i--) {
if (memcmp(_s->cString + rangeLocation + i, cString,
cStringLength) == 0) {
range.location += of_string_utf8_get_index(
_s->cString + rangeLocation, i);
range.length = string.length;
return range;
}
/* Did not match and we're at the last char */
if (i == 0)
return of_range(OF_NOT_FOUND, 0);
return OFMakeRange(OF_NOT_FOUND, 0);
}
} else {
for (size_t i = 0; i <= rangeLength - cStringLength; i++) {
if (memcmp(_s->cString + rangeLocation + i, cString,
cStringLength) == 0) {
range.location += of_string_utf8_get_index(
_s->cString + rangeLocation, i);
range.length = string.length;
return range;
}
}
}
return of_range(OF_NOT_FOUND, 0);
return OFMakeRange(OF_NOT_FOUND, 0);
}
- (bool)containsString: (OFString *)string
{
const char *cString = string.UTF8String;
size_t cStringLength = string.UTF8StringLength;
if (cStringLength == 0)
return true;
if (cStringLength > _s->cStringLength)
return false;
for (size_t i = 0; i <= _s->cStringLength - cStringLength; i++)
if (memcmp(_s->cString + i, cString, cStringLength) == 0)
return true;
return false;
}
- (OFString *)substringWithRange: (of_range_t)range
- (OFString *)substringWithRange: (OFRange)range
{
size_t start = range.location;
size_t end = range.location + range.length;
if (range.length > SIZE_MAX - range.location || end > _s->length)
@throw [OFOutOfRangeException exception];
|
︙ | | |
Modified src/OFValue.h
from [938b5927a6]
to [a6b31cd7ee].
︙ | | |
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
-
+
|
@property (readonly, nonatomic) id nonretainedObjectValue;
/**
* @brief The value as a range.
*
* If the value is not range-sized, @ref OFOutOfRangeException is thrown.
*/
@property (readonly, nonatomic) of_range_t rangeValue;
@property (readonly, nonatomic) OFRange rangeValue;
/**
* @brief The value as a point.
*
* If the value is not point-sized, @ref OFOutOfRangeException is thrown.
*/
@property (readonly, nonatomic) of_point_t pointValue;
|
︙ | | |
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
-
+
|
/**
* @brief Creates a new, autoreleased OFValue containing the specified range.
*
* @param range The range the OFValue should contain
* @return A new, autoreleased OFValue
*/
+ (instancetype)valueWithRange: (of_range_t)range;
+ (instancetype)valueWithRange: (OFRange)range;
/**
* @brief Creates a new, autoreleased OFValue containing the specified point.
*
* @param point The point the OFValue should contain
* @return A new, autoreleased OFValue
*/
|
︙ | | |
Modified src/OFValue.m
from [57c5a42ed5]
to [9ac03935d2].
︙ | | |
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
-
+
|
+ (instancetype)valueWithNonretainedObject: (id)object
{
return [[[OFNonretainedObjectValue alloc]
initWithNonretainedObject: object] autorelease];
}
+ (instancetype)valueWithRange: (of_range_t)range
+ (instancetype)valueWithRange: (OFRange)range
{
return [[[OFRangeValue alloc] initWithRange: range] autorelease];
}
+ (instancetype)valueWithPoint: (of_point_t)point
{
return [[[OFPointValue alloc] initWithPoint: point] autorelease];
|
︙ | | |
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
-
+
-
+
|
- (id)nonretainedObjectValue
{
id ret;
[self getValue: &ret size: sizeof(ret)];
return ret;
}
- (of_range_t)rangeValue
- (OFRange)rangeValue
{
of_range_t ret;
OFRange ret;
[self getValue: &ret size: sizeof(ret)];
return ret;
}
- (of_point_t)pointValue
{
of_point_t ret;
|
︙ | | |
Modified src/OFZIPArchive.m
from [4c67ad00cf]
to [c586c9999e].
︙ | | |
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
|
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
|
-
-
+
+
|
ZIP64Index = of_zip_archive_entry_extra_field_find(extraField,
OF_ZIP_ARCHIVE_ENTRY_EXTRA_FIELD_ZIP64, &ZIP64Size);
if (ZIP64Index != OF_NOT_FOUND) {
const uint8_t *ZIP64 =
[extraField itemAtIndex: ZIP64Index];
of_range_t range =
of_range(ZIP64Index - 4, ZIP64Size + 4);
OFRange range =
OFMakeRange(ZIP64Index - 4, ZIP64Size + 4);
if (_uncompressedSize == 0xFFFFFFFF)
_uncompressedSize = of_zip_archive_read_field64(
&ZIP64, &ZIP64Size);
if (_compressedSize == 0xFFFFFFFF)
_compressedSize = of_zip_archive_read_field64(
&ZIP64, &ZIP64Size);
|
︙ | | |
Modified src/OFZIPArchiveEntry.m
from [1b0f865f32]
to [ff28020be3].
︙ | | |
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
|
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
|
-
-
+
+
|
ZIP64Index = of_zip_archive_entry_extra_field_find(extraField,
OF_ZIP_ARCHIVE_ENTRY_EXTRA_FIELD_ZIP64, &ZIP64Size);
if (ZIP64Index != OF_NOT_FOUND) {
const uint8_t *ZIP64 =
[extraField itemAtIndex: ZIP64Index];
of_range_t range =
of_range(ZIP64Index - 4, ZIP64Size + 4);
OFRange range =
OFMakeRange(ZIP64Index - 4, ZIP64Size + 4);
if (_uncompressedSize == 0xFFFFFFFF)
_uncompressedSize = of_zip_archive_read_field64(
&ZIP64, &ZIP64Size);
if (_compressedSize == 0xFFFFFFFF)
_compressedSize = of_zip_archive_read_field64(
&ZIP64, &ZIP64Size);
|
︙ | | |
Modified src/platform/amiga/OFString+PathAdditions.m
from [173be0674b]
to [7a5e07b2d5].
︙ | | |
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
-
+
|
}
objc_autoreleasePoolPop(pool);
return @"";
}
components = [components objectsInRange:
of_range(0, components.count - 1)];
OFMakeRange(0, components.count - 1)];
ret = [OFString pathWithComponents: components];
[ret retain];
objc_autoreleasePoolPop(pool);
return [ret autorelease];
}
|
︙ | | |
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
|
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
|
-
+
|
done = false;
break;
}
if ([component isEqual: @"/"] &&
parent != nil && ![parent isEqual: @"/"]) {
[array removeObjectsInRange:
of_range(i - 1, 2)];
OFMakeRange(i - 1, 2)];
done = false;
break;
}
}
}
|
︙ | | |
Modified src/platform/libfat/OFString+PathAdditions.m
from [420e4f330e]
to [f134ad6b35].
︙ | | |
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
|
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
|
-
+
|
done = false;
break;
}
if ([component isEqual: @".."] &&
parent != nil && ![parent isEqual: @".."]) {
[array removeObjectsInRange:
of_range(i - 1, 2)];
OFMakeRange(i - 1, 2)];
done = false;
break;
}
}
}
|
︙ | | |
Modified src/platform/posix/OFString+PathAdditions.m
from [456ec4e1f3]
to [a5c896fc45].
︙ | | |
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
|
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
|
-
+
|
done = false;
break;
}
if ([component isEqual: @".."] &&
parent != nil && ![parent isEqual: @".."]) {
[array removeObjectsInRange:
of_range(i - 1, 2)];
OFMakeRange(i - 1, 2)];
done = false;
break;
}
}
}
|
︙ | | |
Modified src/platform/windows/OFString+PathAdditions.m
from [41e0a20445]
to [db89219f61].
︙ | | |
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
-
+
|
}
objc_autoreleasePoolPop(pool);
return @".";
}
components = [components objectsInRange:
of_range(0, components.count - 1)];
OFMakeRange(0, components.count - 1)];
ret = [OFString pathWithComponents: components];
[ret retain];
objc_autoreleasePoolPop(pool);
return [ret autorelease];
}
|
︙ | | |
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
|
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
|
-
+
|
if ([component isEqual: @".."] && parent != nil &&
![parent isEqual: @".."] &&
![parent hasSuffix: @":"] &&
![parent hasSuffix: @":\\"] &&
![parent hasSuffix: @"://"] &&
(![parent hasPrefix: @"\\"] || i != 1)) {
[array removeObjectsInRange:
of_range(i - 1, 2)];
OFMakeRange(i - 1, 2)];
done = false;
break;
}
}
}
|
︙ | | |
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
|
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
|
-
+
|
if (components.count < 2)
@throw [OFInvalidFormatException exception];
*URLEncodedHost = [[components objectAtIndex: 1]
stringByURLEncodingWithAllowedCharacters:
[OFCharacterSet URLHostAllowedCharacterSet]];
path = [OFString pathWithComponents: [components
objectsInRange: of_range(2, components.count - 2)]];
objectsInRange: OFMakeRange(2, components.count - 2)]];
}
path = [path stringByReplacingOccurrencesOfString: @"\\"
withString: @"/"];
path = [path stringByPrependingString: @"/"];
return path;
|
︙ | | |
Modified tests/OFArrayTests.m
from [578f78bc93]
to [03f79a56bf].
︙ | | |
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
-
+
|
TEST(@"-[indexOfObject:]", [a[0] indexOfObject: c_ary[1]] == 1)
TEST(@"-[indexOfObjectIdenticalTo:]",
[a[1] indexOfObjectIdenticalTo: c_ary[1]] == 1)
TEST(@"-[objectsInRange:]",
[[a[0] objectsInRange: of_range(1, 2)] isEqual:
[[a[0] objectsInRange: OFMakeRange(1, 2)] isEqual:
[arrayClass arrayWithObjects: c_ary[1], c_ary[2], nil]])
TEST(@"-[replaceObject:withObject:]",
R([m[0] replaceObject: c_ary[1] withObject: c_ary[0]]) &&
[[m[0] objectAtIndex: 0] isEqual: c_ary[0]] &&
[[m[0] objectAtIndex: 1] isEqual: c_ary[0]] &&
[[m[0] objectAtIndex: 2] isEqual: c_ary[2]])
|
︙ | | |
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
-
+
|
m[1] = [[a[0] mutableCopy] autorelease];
TEST(@"-[removeObjectAtIndex:]", R([m[1] removeObjectAtIndex: 1]) &&
m[1].count == 2 && [[m[1] objectAtIndex: 1] isEqual: c_ary[2]])
m[1] = [[a[0] mutableCopy] autorelease];
TEST(@"-[removeObjectsInRange:]",
R([m[1] removeObjectsInRange: of_range(0, 2)]) &&
R([m[1] removeObjectsInRange: OFMakeRange(0, 2)]) &&
m[1].count == 1 && [[m[1] objectAtIndex: 0] isEqual: c_ary[2]])
m[1] = [[a[0] mutableCopy] autorelease];
[m[1] addObject: @"qux"];
[m[1] addObject: @"last"];
TEST(@"-[reverse]",
R([m[1] reverse]) && [m[1] isEqual: [arrayClass arrayWithObjects:
|
︙ | | |
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
|
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
|
-
+
|
@"z", @"Foo", @"Baz", @"Bar", @"0", nil]])
EXPECT_EXCEPTION(@"Detect out of range in -[objectAtIndex:]",
OFOutOfRangeException, [a[0] objectAtIndex: a[0].count])
EXPECT_EXCEPTION(@"Detect out of range in -[removeObjectsInRange:]",
OFOutOfRangeException, [m[0] removeObjectsInRange:
of_range(0, m[0].count + 1)])
OFMakeRange(0, m[0].count + 1)])
TEST(@"-[componentsJoinedByString:]",
(a[1] = [arrayClass arrayWithObjects: @"", @"a", @"b", @"c",
nil]) &&
[[a[1] componentsJoinedByString: @" "] isEqual: @" a b c"] &&
(a[1] = [arrayClass arrayWithObject: @"foo"]) &&
[[a[1] componentsJoinedByString: @" "] isEqual: @"foo"])
|
︙ | | |
Modified tests/OFCharacterSetTests.m
from [7038831ad1]
to [9b3eff0bb8].
︙ | | |
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
|
-
+
+
|
ok = false;
}
TEST(@"-[characterIsMember:]", ok);
module = @"OFRangeCharacterSet";
TEST(@"+[characterSetWithRange:]",
(cs = [OFCharacterSet characterSetWithRange: of_range('0', 10)]) &&
(cs = [OFCharacterSet
characterSetWithRange: OFMakeRange('0', 10)]) &&
[cs isKindOfClass: [OFRangeCharacterSet class]])
ok = true;
for (of_unichar_t c = 0; c < 65536; c++) {
if (c >= '0' && c <= '9') {
if (![cs characterIsMember: c])
ok = false;
|
︙ | | |
Modified tests/OFDataTests.m
from [0b61c12094]
to [2cb3375466].
︙ | | |
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
-
+
|
@implementation TestsAppDelegate (OFDataTests)
- (void)dataTests
{
void *pool = objc_autoreleasePoolPush();
OFMutableData *mutable;
OFData *immutable;
void *raw[2];
of_range_t range;
OFRange range;
TEST(@"+[dataWithItemSize:]",
(mutable = [OFMutableData dataWithItemSize: 4096]))
raw[0] = of_alloc(1, 4096);
raw[1] = of_alloc(1, 4096);
memset(raw[0], 0xFF, 4096);
|
︙ | | |
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
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
|
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
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
|
-
+
-
+
-
+
-
+
-
-
+
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
+
-
+
+
|
mutable = [OFMutableData dataWithItems: "abcdef" count: 6];
TEST(@"-[removeLastItem]", R([mutable removeLastItem]) &&
mutable.count == 5 && memcmp(mutable.items, "abcde", 5) == 0)
TEST(@"-[removeItemsInRange:]",
R([mutable removeItemsInRange: of_range(1, 2)]) &&
R([mutable removeItemsInRange: OFMakeRange(1, 2)]) &&
mutable.count == 3 && memcmp(mutable.items, "ade", 3) == 0)
TEST(@"-[insertItems:atIndex:count:]",
R([mutable insertItems: "bc" atIndex: 1 count: 2]) &&
mutable.count == 5 && memcmp(mutable.items, "abcde", 5) == 0)
immutable = [OFData dataWithItems: "aaabaccdacaabb"
count: 7
itemSize: 2];
range = [immutable rangeOfData: [OFData dataWithItems: "aa"
count: 1
itemSize: 2]
options: 0
range: of_range(0, 7)];
range: OFMakeRange(0, 7)];
TEST(@"-[rangeOfData:options:range:] #1",
range.location == 0 && range.length == 1)
range = [immutable rangeOfData: [OFData dataWithItems: "aa"
count: 1
itemSize: 2]
options: OF_DATA_SEARCH_BACKWARDS
range: of_range(0, 7)];
range: OFMakeRange(0, 7)];
TEST(@"-[rangeOfData:options:range:] #2",
range.location == 5 && range.length == 1)
range = [immutable rangeOfData: [OFData dataWithItems: "ac"
count: 1
itemSize: 2]
options: 0
range: of_range(0, 7)];
range: OFMakeRange(0, 7)];
TEST(@"-[rangeOfData:options:range:] #3",
range.location == 2 && range.length == 1)
range = [immutable rangeOfData: [OFData dataWithItems: "aabb"
count: 2
itemSize: 2]
options: 0
range: of_range(0, 7)];
options: 0
range: OFMakeRange(0, 7)];
TEST(@"-[rangeOfData:options:range:] #4",
range.location == 5 && range.length == 2)
TEST(@"-[rangeOfData:options:range:] #5",
R(range = [immutable rangeOfData: [OFData dataWithItems: "aa"
count: 1
itemSize: 2]
options: 0
range: of_range(1, 6)]) &&
range: OFMakeRange(1, 6)]) &&
range.location == 5 && range.length == 1)
range = [immutable rangeOfData: [OFData dataWithItems: "aa"
count: 1
itemSize: 2]
options: OF_DATA_SEARCH_BACKWARDS
range: of_range(0, 5)];
range: OFMakeRange(0, 5)];
TEST(@"-[rangeOfData:options:range:] #6",
range.location == 0 && range.length == 1)
EXPECT_EXCEPTION(
@"-[rangeOfData:options:range:] failing on different itemSize",
OFInvalidArgumentException,
[immutable rangeOfData: [OFData dataWithItems: "aaa"
count: 1
itemSize: 3]
options: 0
range: of_range(0, 1)])
range: OFMakeRange(0, 1)])
EXPECT_EXCEPTION(
@"-[rangeOfData:options:range:] failing on out of range",
OFOutOfRangeException,
[immutable rangeOfData: [OFData dataWithItems: ""
count: 0
itemSize: 2]
options: 0
range: of_range(8, 1)])
range: OFMakeRange(8, 1)])
TEST(@"-[subdataWithRange:]",
[[immutable subdataWithRange: of_range(2, 4)]
[[immutable subdataWithRange: OFMakeRange(2, 4)]
isEqual: [OFData dataWithItems: "accdacaa"
count: 4
itemSize: 2]] &&
[[mutable subdataWithRange: of_range(2, 3)]
[[mutable subdataWithRange: OFMakeRange(2, 3)]
isEqual: [OFData dataWithItems: "cde"
count: 3]])
EXPECT_EXCEPTION(@"-[subdataWithRange:] failing on out of range #1",
OFOutOfRangeException, [immutable subdataWithRange: of_range(7, 1)])
OFOutOfRangeException,
[immutable subdataWithRange: OFMakeRange(7, 1)])
EXPECT_EXCEPTION(@"-[subdataWithRange:] failing on out of range #2",
OFOutOfRangeException, [mutable subdataWithRange: of_range(6, 1)])
OFOutOfRangeException,
[mutable subdataWithRange: OFMakeRange(6, 1)])
TEST(@"-[stringByMD5Hashing]", [mutable.stringByMD5Hashing
isEqual: @"ab56b4d92b40713acc5af89985d4b786"])
TEST(@"-[stringByRIPEMD160Hashing]", [mutable.stringByRIPEMD160Hashing
isEqual: @"973398b6e6c6cfa6b5e6a5173f195ce3274bf828"])
|
︙ | | |
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
-
+
|
OFOutOfRangeException, [mutable itemAtIndex: mutable.count])
EXPECT_EXCEPTION(@"Detect out of range in -[addItems:count:]",
OFOutOfRangeException, [mutable addItems: raw[0] count: SIZE_MAX])
EXPECT_EXCEPTION(@"Detect out of range in -[removeItemsInRange:]",
OFOutOfRangeException,
[mutable removeItemsInRange: of_range(mutable.count, 1)])
[mutable removeItemsInRange: OFMakeRange(mutable.count, 1)])
free(raw[0]);
free(raw[1]);
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFStringTests.m
from [8afaa899f0]
to [4f0b2599ed].
︙ | | |
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
-
+
|
@implementation SimpleMutableString
+ (void)initialize
{
if (self == [SimpleMutableString class])
[self inheritMethodsFromClass: [SimpleString class]];
}
- (void)replaceCharactersInRange: (of_range_t)range
- (void)replaceCharactersInRange: (OFRange)range
withString: (OFString *)string
{
[_string replaceCharactersInRange: range withString: string];
}
@end
@interface EntityHandler: OFObject <OFStringXMLUnescapingDelegate>
|
︙ | | |
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
|
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
|
-
+
-
+
-
+
-
+
-
-
+
+
-
+
-
+
|
options: OF_STRING_SEARCH_BACKWARDS].location == 0 &&
[C(@"𝄞öö") rangeOfString: @"x"
options: OF_STRING_SEARCH_BACKWARDS].location == OF_NOT_FOUND)
EXPECT_EXCEPTION(
@"Detect out of range in -[rangeOfString:options:range:]",
OFOutOfRangeException,
[C(@"𝄞öö") rangeOfString: @"ö" options: 0 range: of_range(3, 1)])
[C(@"𝄞öö") rangeOfString: @"ö" options: 0 range: OFMakeRange(3, 1)])
cs = [OFCharacterSet characterSetWithCharactersInString: @"cđ"];
TEST(@"-[indexOfCharacterFromSet:]",
[C(@"abcđabcđe") indexOfCharacterFromSet: cs] == 2 &&
[C(@"abcđabcđë")
indexOfCharacterFromSet: cs
options: OF_STRING_SEARCH_BACKWARDS] == 7 &&
[C(@"abcđabcđë")
indexOfCharacterFromSet: cs
options: 0
range: of_range(4, 4)] == 6 &&
range: OFMakeRange(4, 4)] == 6 &&
[C(@"abcđabcđëf")
indexOfCharacterFromSet: cs
options: 0
range: of_range(8, 2)] == OF_NOT_FOUND)
range: OFMakeRange(8, 2)] == OF_NOT_FOUND)
EXPECT_EXCEPTION(
@"Detect out of range in -[indexOfCharacterFromSet:options:range:]",
OFOutOfRangeException,
[C(@"𝄞öö") indexOfCharacterFromSet: cs
options: 0
range: of_range(3, 1)])
range: OFMakeRange(3, 1)])
TEST(@"-[substringWithRange:]",
[[C(@"𝄞öö") substringWithRange: of_range(1, 1)] isEqual: @"ö"] &&
[[C(@"𝄞öö") substringWithRange: of_range(3, 0)] isEqual: @""])
[[C(@"𝄞öö") substringWithRange: OFMakeRange(1, 1)] isEqual: @"ö"] &&
[[C(@"𝄞öö") substringWithRange: OFMakeRange(3, 0)] isEqual: @""])
EXPECT_EXCEPTION(@"Detect out of range in -[substringWithRange:] #1",
OFOutOfRangeException,
[C(@"𝄞öö") substringWithRange: of_range(2, 2)])
[C(@"𝄞öö") substringWithRange: OFMakeRange(2, 2)])
EXPECT_EXCEPTION(@"Detect out of range in -[substringWithRange:] #2",
OFOutOfRangeException,
[C(@"𝄞öö") substringWithRange: of_range(4, 0)])
[C(@"𝄞öö") substringWithRange: OFMakeRange(4, 0)])
TEST(@"-[stringByAppendingString:]",
[[C(@"foo") stringByAppendingString: @"bar"] isEqual: @"foobar"])
TEST(@"-[stringByPrependingString:]",
[[C(@"foo") stringByPrependingString: @"bar"] isEqual: @"barfoo"])
|
︙ | | |
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
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
1323
1324
1325
1326
1327
1328
1329
1330
1331
|
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
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
1323
1324
1325
1326
1327
1328
1329
1330
1331
|
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
|
[s[0] isEqual: @"abcde"] &&
R([s[0] setCharacter: 0x20AC atIndex: 3]) &&
[s[0] isEqual: @"abc€e"] &&
R([s[0] setCharacter: 'x' atIndex: 1]) && [s[0] isEqual: @"axc€e"])
TEST(@"-[deleteCharactersInRange:]",
(s[0] = [mutableStringClass stringWithString: @"𝄞öööbä€"]) &&
R([s[0] deleteCharactersInRange: of_range(1, 3)]) &&
R([s[0] deleteCharactersInRange: OFMakeRange(1, 3)]) &&
[s[0] isEqual: @"𝄞bä€"] &&
R([s[0] deleteCharactersInRange: of_range(0, 4)]) &&
R([s[0] deleteCharactersInRange: OFMakeRange(0, 4)]) &&
[s[0] isEqual: @""])
TEST(@"-[replaceCharactersInRange:withString:]",
(s[0] = [mutableStringClass stringWithString: @"𝄞öööbä€"]) &&
R([s[0] replaceCharactersInRange: of_range(1, 3)
R([s[0] replaceCharactersInRange: OFMakeRange(1, 3)
withString: @"äöüß"]) &&
[s[0] isEqual: @"𝄞äöüßbä€"] &&
R([s[0] replaceCharactersInRange: of_range(4, 2)
R([s[0] replaceCharactersInRange: OFMakeRange(4, 2)
withString: @"b"]) &&
[s[0] isEqual: @"𝄞äöübä€"] &&
R([s[0] replaceCharactersInRange: of_range(0, 7)
R([s[0] replaceCharactersInRange: OFMakeRange(0, 7)
withString: @""]) &&
[s[0] isEqual: @""])
EXPECT_EXCEPTION(@"Detect OoR in -[deleteCharactersInRange:] #1",
OFOutOfRangeException,
{
s[0] = [mutableStringClass stringWithString: @"𝄞öö"];
[s[0] deleteCharactersInRange: of_range(2, 2)];
[s[0] deleteCharactersInRange: OFMakeRange(2, 2)];
})
EXPECT_EXCEPTION(@"Detect OoR in -[deleteCharactersInRange:] #2",
OFOutOfRangeException,
[s[0] deleteCharactersInRange: of_range(4, 0)])
[s[0] deleteCharactersInRange: OFMakeRange(4, 0)])
EXPECT_EXCEPTION(@"Detect OoR in "
@"-[replaceCharactersInRange:withString:] #1",
OFOutOfRangeException,
[s[0] replaceCharactersInRange: of_range(2, 2) withString: @""])
[s[0] replaceCharactersInRange: OFMakeRange(2, 2) withString: @""])
EXPECT_EXCEPTION(@"Detect OoR in "
@"-[replaceCharactersInRange:withString:] #2",
OFOutOfRangeException,
[s[0] replaceCharactersInRange: of_range(4, 0) withString: @""])
[s[0] replaceCharactersInRange: OFMakeRange(4, 0) withString: @""])
TEST(@"-[replaceOccurrencesOfString:withString:]",
(s[0] = [mutableStringClass stringWithString:
@"asd fo asd fofo asd"]) &&
R([s[0] replaceOccurrencesOfString: @"fo" withString: @"foo"]) &&
[s[0] isEqual: @"asd foo asd foofoo asd"] &&
(s[0] = [mutableStringClass stringWithString: @"XX"]) &&
R([s[0] replaceOccurrencesOfString: @"X" withString: @"XX"]) &&
[s[0] isEqual: @"XXXX"])
TEST(@"-[replaceOccurrencesOfString:withString:options:range:]",
(s[0] = [mutableStringClass stringWithString:
@"foofoobarfoobarfoo"]) &&
R([s[0] replaceOccurrencesOfString: @"oo"
withString: @"óò"
options: 0
range: of_range(2, 15)]) &&
range: OFMakeRange(2, 15)]) &&
[s[0] isEqual: @"foofóòbarfóòbarfoo"])
TEST(@"-[deleteLeadingWhitespaces]",
(s[0] = [mutableStringClass stringWithString: whitespace[0]]) &&
R([s[0] deleteLeadingWhitespaces]) &&
[s[0] isEqual: @"asd \t \t\t\r\n"] &&
(s[0] = [mutableStringClass stringWithString: whitespace[1]]) &&
|
︙ | | |
Modified tests/OFValueTests.m
from [dd07d710ca]
to [2f27932fb7].
︙ | | |
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
|
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
|
-
+
-
+
-
+
-
-
+
+
-
+
|
static OFString *module = @"OFValue";
@implementation TestsAppDelegate (OFValueTests)
- (void)valueTests
{
void *pool = objc_autoreleasePoolPush();
of_range_t range = of_range(1, 64), range2;
OFRange range = OFMakeRange(1, 64), range2;
of_point_t point = of_point(1.5f, 3.0f), point2;
of_dimension_t dimension = of_dimension(4.5f, 5.0f), dimension2;
of_rectangle_t rectangle = of_rectangle(1.5f, 3.0f, 4.5f, 6.0f);
of_rectangle_t rectangle2;
OFValue *value;
void *pointer = &value;
TEST(@"+[valueWithBytes:objCType:]",
(value = [OFValue valueWithBytes: &range
objCType: @encode(of_range_t)]))
objCType: @encode(OFRange)]))
TEST(@"-[objCType]", strcmp(value.objCType, @encode(of_range_t)) == 0)
TEST(@"-[objCType]", strcmp(value.objCType, @encode(OFRange)) == 0)
TEST(@"-[getValue:size:]",
R([value getValue: &range2 size: sizeof(of_range_t)]) &&
of_range_equal(range2, range))
R([value getValue: &range2 size: sizeof(OFRange)]) &&
OFEqualRanges(range2, range))
EXPECT_EXCEPTION(@"-[getValue:size:] with wrong size throws",
OFOutOfRangeException,
[value getValue: &range size: sizeof(of_range_t) - 1])
[value getValue: &range size: sizeof(OFRange) - 1])
TEST(@"+[valueWithPointer:]",
(value = [OFValue valueWithPointer: pointer]))
TEST(@"-[pointerValue]",
value.pointerValue == pointer &&
[[OFValue valueWithBytes: &pointer
|
︙ | | |
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
-
+
-
-
+
+
-
+
|
[[OFValue valueWithBytes: "a"
objCType: @encode(char)] nonretainedObjectValue])
TEST(@"+[valueWithRange:]",
(value = [OFValue valueWithRange: range]))
TEST(@"-[rangeValue]",
of_range_equal(value.rangeValue, range) &&
OFEqualRanges(value.rangeValue, range) &&
(value = [OFValue valueWithBytes: &range
objCType: @encode(of_range_t)]) &&
of_range_equal(value.rangeValue, range))
objCType: @encode(OFRange)]) &&
OFEqualRanges(value.rangeValue, range))
TEST(@"-[getValue:size:] for OFRangeValue",
(value = [OFValue valueWithRange: range]) &&
R([value getValue: &range2 size: sizeof(range2)]) &&
of_range_equal(range2, range))
OFEqualRanges(range2, range))
EXPECT_EXCEPTION(@"-[rangeValue] with wrong size throws",
OFOutOfRangeException,
[[OFValue valueWithBytes: "a"
objCType: @encode(char)] rangeValue])
TEST(@"+[valueWithPoint:]",
|
︙ | | |
Modified utils/ofarc/OFArc.m
from [e174e86e3a]
to [415cfb1a2f].
︙ | | |
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
|
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
|
-
+
|
switch (mode) {
case 'a':
case 'c':
if (remainingArguments.count < 1)
help(of_stderr, false, 1);
files = [remainingArguments objectsInRange:
of_range(1, remainingArguments.count - 1)];
OFMakeRange(1, remainingArguments.count - 1)];
#ifdef OF_HAVE_SANDBOX
if (![remainingArguments.firstObject isEqual: @"-"])
[sandbox unveilPath: remainingArguments.firstObject
permissions: (mode == 'a' ? @"rwc" : @"wc")];
for (OFString *path in files)
|
︙ | | |
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
396
397
398
|
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
396
397
398
|
-
+
-
+
|
permissions: @"r"];
sandbox.allowsUnveil = false;
[OFApplication of_activateSandbox: sandbox];
#endif
files = [remainingArguments objectsInRange:
of_range(1, remainingArguments.count - 1)];
OFMakeRange(1, remainingArguments.count - 1)];
archive = [self
openArchiveWithPath: remainingArguments.firstObject
type: type
mode: mode
encoding: encoding];
[archive printFiles: files];
break;
case 'x':
if (remainingArguments.count < 1)
help(of_stderr, false, 1);
files = [remainingArguments objectsInRange:
of_range(1, remainingArguments.count - 1)];
OFMakeRange(1, remainingArguments.count - 1)];
#ifdef OF_HAVE_SANDBOX
if (![remainingArguments.firstObject isEqual: @"-"])
[sandbox unveilPath: remainingArguments.firstObject
permissions: @"r"];
if (files.count > 0)
|
︙ | | |