ObjFW  Check-in [917ce5754c]

Overview
Comment:Add -[doesNotRecognizeSelector:].
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA3-256: 917ce5754c47eaf0d4196accd1dfe01a91c3803b14752c77b9a3ac5f17f57b59
User & Date: js on 2012-12-22 15:37:19
Other Links: manifest | tags
Context
2012-12-22
15:37
Xcode project: Set deployment target to default. check-in: 57a82682ae user: js tags: trunk
15:37
Add -[doesNotRecognizeSelector:]. check-in: 917ce5754c user: js tags: trunk
14:41
Never throw in -[typeEncodingForSelector:]. check-in: 77573bf01f user: js tags: trunk
Changes

Modified src/OFApplication.m from [c32b0e2937] to [35ca9806a3].

25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#import "OFApplication.h"
#import "OFString.h"
#import "OFArray.h"
#import "OFDictionary.h"
#import "OFThread.h"
#import "OFRunLoop.h"

#import "OFNotImplementedException.h"

#import "autorelease.h"

#if defined(__MACH__) && !defined(OF_IOS)
# include <crt_externs.h>
#elif !defined(OF_IOS)
extern char **environ;
#endif







<
<







25
26
27
28
29
30
31


32
33
34
35
36
37
38
#import "OFApplication.h"
#import "OFString.h"
#import "OFArray.h"
#import "OFDictionary.h"
#import "OFThread.h"
#import "OFRunLoop.h"



#import "autorelease.h"

#if defined(__MACH__) && !defined(OF_IOS)
# include <crt_externs.h>
#elif !defined(OF_IOS)
extern char **environ;
#endif

Modified src/OFArray.m from [a77077bbb2] to [0bbcdb4b0f].

13
14
15
16
17
18
19

20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdarg.h>


#import "OFArray.h"
#import "OFArray_subarray.h"
#import "OFArray_adjacent.h"
#import "OFString.h"
#import "OFXMLElement.h"

#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfRangeException.h"

#import "autorelease.h"
#import "macros.h"

static struct {
	Class isa;







>









<







13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

30
31
32
33
34
35
36
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdarg.h>
#include <stdlib.h>

#import "OFArray.h"
#import "OFArray_subarray.h"
#import "OFArray_adjacent.h"
#import "OFString.h"
#import "OFXMLElement.h"

#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"

#import "OFOutOfRangeException.h"

#import "autorelease.h"
#import "macros.h"

static struct {
	Class isa;
99
100
101
102
103
104
105
106

107
108

109
110
111
112
113
114
115

- (void)release
{
}

- (void)dealloc
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]

						    selector: _cmd];
	[super dealloc];	/* Get rid of a stupid warning */

}
@end

@implementation OFArray
+ (void)initialize
{
	if (self == [OFArray class])







|
>
|
|
>







99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFArray
+ (void)initialize
{
	if (self == [OFArray class])
158
159
160
161
162
163
164

165


166
167
168

169
170
171
172
173
174
175
	return [[[self alloc] initWithObjects: objects
					count: count] autorelease];
}

- init
{
	if (object_getClass(self) == [OFArray class]) {

		Class c = [self class];


		[self release];
		@throw [OFNotImplementedException exceptionWithClass: c
							    selector: _cmd];

	}

	return [super init];
}

- initWithObject: (id)object
{







>
|
>
>
|
|
<
>







160
161
162
163
164
165
166
167
168
169
170
171
172

173
174
175
176
177
178
179
180
	return [[[self alloc] initWithObjects: objects
					count: count] autorelease];
}

- init
{
	if (object_getClass(self) == [OFArray class]) {
		@try {
			[self doesNotRecognizeSelector: _cmd];
			abort();
		} @catch (id e) {
			[self release];
			@throw e;

		}
	}

	return [super init];
}

- initWithObject: (id)object
{
194
195
196
197
198
199
200

201


202
203
204

205
206
207
208

209


210
211
212

213
214
215
216
217

218


219
220
221

222
223
224
225

226


227
228
229

230
231
232
233
234
235

236
237
238
239
240
241
242

	return ret;
}

- initWithObject: (id)firstObject
       arguments: (va_list)arguments
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithArray: (OFArray*)array
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithObjects: (id const*)objects
	    count: (size_t)count
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithSerialization: (OFXMLElement*)element
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- (size_t)count
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)getObjects: (id*)buffer
	   inRange: (of_range_t)range
{
	size_t i;








>
|
>
>
|
|
<
>




>
|
>
>
|
|
<
>





>
|
>
>
|
|
<
>




>
|
>
>
|
|
<
>




<
|
>







199
200
201
202
203
204
205
206
207
208
209
210
211

212
213
214
215
216
217
218
219
220
221
222

223
224
225
226
227
228
229
230
231
232
233
234

235
236
237
238
239
240
241
242
243
244
245

246
247
248
249
250

251
252
253
254
255
256
257
258
259

	return ret;
}

- initWithObject: (id)firstObject
       arguments: (va_list)arguments
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithArray: (OFArray*)array
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithObjects: (id const*)objects
	    count: (size_t)count
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithSerialization: (OFXMLElement*)element
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- (size_t)count
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)getObjects: (id*)buffer
	   inRange: (of_range_t)range
{
	size_t i;

269
270
271
272
273
274
275
276
277

278
279
280
281
282
283
284
- mutableCopy
{
	return [[OFMutableArray alloc] initWithArray: self];
}

- (id)objectAtIndex: (size_t)index
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (id)objectAtIndexedSubscript: (size_t)index
{
	return [self objectAtIndex: index];
}








<
|
>







286
287
288
289
290
291
292

293
294
295
296
297
298
299
300
301
- mutableCopy
{
	return [[OFMutableArray alloc] initWithArray: self];
}

- (id)objectAtIndex: (size_t)index
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (id)objectAtIndexedSubscript: (size_t)index
{
	return [self objectAtIndex: index];
}

Modified src/OFAutoreleasePool.m from [b7dda03eca] to [b1114f3a89].

17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include "config.h"

#include <stdlib.h>

#import "OFAutoreleasePool.h"
#import "OFArray.h"

#import "OFNotImplementedException.h"

#import "macros.h"
#ifndef OF_COMPILER_TLS
# import "threading.h"

# import "OFInitializationFailedException.h"
#endif








<
<







17
18
19
20
21
22
23


24
25
26
27
28
29
30
#include "config.h"

#include <stdlib.h>

#import "OFAutoreleasePool.h"
#import "OFArray.h"



#import "macros.h"
#ifndef OF_COMPILER_TLS
# import "threading.h"

# import "OFInitializationFailedException.h"
#endif

157
158
159
160
161
162
163
164
165

166
167
168
169
170
171

172
173
	}

	[super dealloc];
}

- retain
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- autorelease
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}
@end







<
|
>




<
|
>


155
156
157
158
159
160
161

162
163
164
165
166
167

168
169
170
171
	}

	[super dealloc];
}

- retain
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- autorelease
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}
@end

Modified src/OFBlock.m from [90b4a8e14a] to [68b4ea5979].

26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# import <objc/runtime.h>
#endif

#import "OFBlock.h"

#import "OFAllocFailedException.h"
#import "OFInitializationFailedException.h"
#import "OFNotImplementedException.h"

#import "macros.h"
#ifdef OF_ATOMIC_OPS
# import "atomic.h"
#endif
#ifdef OF_THREADS
# import "threading.h"







<







26
27
28
29
30
31
32

33
34
35
36
37
38
39
# import <objc/runtime.h>
#endif

#import "OFBlock.h"

#import "OFAllocFailedException.h"
#import "OFInitializationFailedException.h"


#import "macros.h"
#ifdef OF_ATOMIC_OPS
# import "atomic.h"
#endif
#ifdef OF_THREADS
# import "threading.h"
385
386
387
388
389
390
391
392
393

394
395
396
397
398
399





400
401
402
403
404
405

406
407
408
409
410
411
412

413
414
415
416
417
418
419

420
421
422
423
424
425
426
427

428
429
430
431
432
433

434
435
436
437
438
439
440
			@throw [OFInitializationFailedException
			    exceptionWithClass: self];
}
#endif

+ alloc
{
	@throw [OFNotImplementedException exceptionWithClass: self
						    selector: _cmd];

}

- init
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];





}

- (void*)allocMemoryWithSize: (size_t)size
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void*)allocMemoryWithSize: (size_t)size
		       count: (size_t)count
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void*)resizeMemory: (void*)ptr
		 size: (size_t)size
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void*)resizeMemory: (void*)ptr
		 size: (size_t)size
		count: (size_t)count
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)freeMemory: (void*)ptr
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- retain
{
	if (object_getClass(self) == (Class)&_NSConcreteMallocBlock)
		return Block_copy(self);








<
|
>




|
|
>
>
>
>
>




<
|
>





<
|
>





<
|
>






<
|
>




<
|
>







384
385
386
387
388
389
390

391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407

408
409
410
411
412
413
414

415
416
417
418
419
420
421

422
423
424
425
426
427
428
429

430
431
432
433
434
435

436
437
438
439
440
441
442
443
444
			@throw [OFInitializationFailedException
			    exceptionWithClass: self];
}
#endif

+ alloc
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- init
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;
	}
}

- (void*)allocMemoryWithSize: (size_t)size
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void*)allocMemoryWithSize: (size_t)size
		       count: (size_t)count
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void*)resizeMemory: (void*)ptr
		 size: (size_t)size
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void*)resizeMemory: (void*)ptr
		 size: (size_t)size
		count: (size_t)count
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)freeMemory: (void*)ptr
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- retain
{
	if (object_getClass(self) == (Class)&_NSConcreteMallocBlock)
		return Block_copy(self);

467
468
469
470
471
472
473
474

475
476

477
478
{
	if (object_getClass(self) == (Class)&_NSConcreteMallocBlock)
		Block_release(self);
}

- (void)dealloc
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]

						    selector: _cmd];
	[super dealloc];	/* Get rid of a stupid warning */

}
@end







|
>
|
|
>


471
472
473
474
475
476
477
478
479
480
481
482
483
484
{
	if (object_getClass(self) == (Class)&_NSConcreteMallocBlock)
		Block_release(self);
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

Modified src/OFConstantString.m from [b86bf57c57] to [4e1d37633d].

22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <string.h>

#import "OFConstantString.h"
#import "OFString_UTF8.h"

#import "OFInitializationFailedException.h"
#import "OFInvalidEncodingException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfMemoryException.h"

#if defined(OF_APPLE_RUNTIME) && !defined(__OBJC2__)
# import <objc/runtime.h>

struct {
	struct class *isa, *super_class;







<







22
23
24
25
26
27
28

29
30
31
32
33
34
35
#include <string.h>

#import "OFConstantString.h"
#import "OFString_UTF8.h"

#import "OFInitializationFailedException.h"
#import "OFInvalidEncodingException.h"

#import "OFOutOfMemoryException.h"

#if defined(OF_APPLE_RUNTIME) && !defined(__OBJC2__)
# import <objc/runtime.h>

struct {
	struct class *isa, *super_class;
47
48
49
50
51
52
53
54
55

56
57
58
59
60
61
62

63
64
65
66
67
68
69

70
71
72
73
74
75
76

77
78
79
80
81
82
83
84

85
86
87
88
89
90

91
92
93
94
95
96
97

@interface OFString_const: OFString_UTF8
@end

@implementation OFString_const
+ alloc
{
	@throw [OFNotImplementedException exceptionWithClass: self
						    selector: _cmd];

}


- (void*)allocMemoryWithSize: (size_t)size
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void*)allocMemoryWithSize: (size_t)itemSize
		       count: (size_t)count
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void*)resizeMemory: (void*)ptr
		 size: (size_t)size
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void*)resizeMemory: (void*)ptr
	     toNItems: (size_t)nitems
	     withSize: (size_t)size
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)freeMemory: (void*)ptr
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- retain
{
	return self;
}








<
|
>





<
|
>





<
|
>





<
|
>






<
|
>




<
|
>







46
47
48
49
50
51
52

53
54
55
56
57
58
59

60
61
62
63
64
65
66

67
68
69
70
71
72
73

74
75
76
77
78
79
80
81

82
83
84
85
86
87

88
89
90
91
92
93
94
95
96

@interface OFString_const: OFString_UTF8
@end

@implementation OFString_const
+ alloc
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}


- (void*)allocMemoryWithSize: (size_t)size
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void*)allocMemoryWithSize: (size_t)itemSize
		       count: (size_t)count
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void*)resizeMemory: (void*)ptr
		 size: (size_t)size
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void*)resizeMemory: (void*)ptr
	     toNItems: (size_t)nitems
	     withSize: (size_t)size
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)freeMemory: (void*)ptr
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- retain
{
	return self;
}

107
108
109
110
111
112
113
114

115
116

117
118
119
120
121
122
123

- (void)release
{
}

- (void)dealloc
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]

						    selector: _cmd];
	[super dealloc];	/* Get rid of a stupid warning */

}
@end

@implementation OFConstantString
+ (void)load
{
#if defined(OF_APPLE_RUNTIME) && !defined(__OBJC2__)







|
>
|
|
>







106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFConstantString
+ (void)load
{
#if defined(OF_APPLE_RUNTIME) && !defined(__OBJC2__)
168
169
170
171
172
173
174
175
176

177
178
179
180
181
182

183
184
185
186
187
188
189

190
191
192
193
194
195
196

197
198
199
200
201
202
203
204

205
206
207
208
209
210

211
212
213
214
215
216
217

	cString = (char*)ivars;
	object_setClass(self, [OFString_const class]);
}

+ alloc
{
	@throw [OFNotImplementedException exceptionWithClass: self
						    selector: _cmd];

}

- (void*)allocMemoryWithSize: (size_t)size
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void*)allocMemoryWithSize: (size_t)size
		       count: (size_t)count
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void*)resizeMemory: (void*)ptr
		 size: (size_t)size
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void*)resizeMemory: (void*)ptr
		 size: (size_t)size
		count: (size_t)count
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)freeMemory: (void*)ptr
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- retain
{
	return self;
}








<
|
>




<
|
>





<
|
>





<
|
>






<
|
>




<
|
>







169
170
171
172
173
174
175

176
177
178
179
180
181

182
183
184
185
186
187
188

189
190
191
192
193
194
195

196
197
198
199
200
201
202
203

204
205
206
207
208
209

210
211
212
213
214
215
216
217
218

	cString = (char*)ivars;
	object_setClass(self, [OFString_const class]);
}

+ alloc
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void*)allocMemoryWithSize: (size_t)size
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void*)allocMemoryWithSize: (size_t)size
		       count: (size_t)count
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void*)resizeMemory: (void*)ptr
		 size: (size_t)size
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void*)resizeMemory: (void*)ptr
		 size: (size_t)size
		count: (size_t)count
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)freeMemory: (void*)ptr
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- retain
{
	return self;
}

227
228
229
230
231
232
233
234

235
236

237
238
239
240
241
242
243

- (void)release
{
}

- (void)dealloc
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]

						    selector: _cmd];
	[super dealloc];	/* Get rid of a stupid warning */

}

/*
 * In all following methods, the constant string is converted to an
 * OFString_UTF8 and the message sent again.
 */








|
>
|
|
>







228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}

/*
 * In all following methods, the constant string is converted to an
 * OFString_UTF8 and the message sent again.
 */

Modified src/OFCountedSet.m from [dd9c0e4002] to [85c3dcd865].

11
12
13
14
15
16
17


18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFCountedSet.h"
#import "OFCountedSet_hashtable.h"
#import "OFNumber.h"
#import "OFString.h"
#import "OFXMLElement.h"

#import "OFNotImplementedException.h"

#import "autorelease.h"

static struct {
	Class isa;
} placeholder;

@interface OFCountedSet_placeholder: OFCountedSet







>
>







<
<







11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


27
28
29
30
31
32
33
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFCountedSet.h"
#import "OFCountedSet_hashtable.h"
#import "OFNumber.h"
#import "OFString.h"
#import "OFXMLElement.h"



#import "autorelease.h"

static struct {
	Class isa;
} placeholder;

@interface OFCountedSet_placeholder: OFCountedSet
94
95
96
97
98
99
100
101

102
103

104
105
106
107
108
109
110

- (void)release
{
}

- (void)dealloc
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]

						    selector: _cmd];
	[super dealloc];	/* Get rid of a stupid warning */

}
@end

@implementation OFCountedSet
+ (void)initialize
{
	if (self == [OFCountedSet class])







|
>
|
|
>







94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFCountedSet
+ (void)initialize
{
	if (self == [OFCountedSet class])
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

	return [super alloc];
}

- init
{
	if (object_getClass(self) == [OFCountedSet class]) {

		Class c = [self class];


		[self release];
		@throw [OFNotImplementedException exceptionWithClass: c
							    selector: _cmd];

	}

	return [super init];
}

- (size_t)countForObject: (id)object
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (OFString*)description
{
	OFMutableString *ret;
	void *pool;
	OFEnumerator *enumerator;







>
|
>
>
|
|
<
>







<
|
>







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

	return [super alloc];
}

- init
{
	if (object_getClass(self) == [OFCountedSet class]) {
		@try {
			[self doesNotRecognizeSelector: _cmd];
			abort();
		} @catch (id e) {
			[self release];
			@throw e;

		}
	}

	return [super init];
}

- (size_t)countForObject: (id)object
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (OFString*)description
{
	OFMutableString *ret;
	void *pool;
	OFEnumerator *enumerator;

Modified src/OFDataArray.m from [84f1c9eaa1] to [b9544608cd].

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#import "OFHTTPClient.h"
#import "OFHTTPRequest.h"
#import "OFXMLElement.h"

#import "OFHTTPRequestFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfMemoryException.h"
#import "OFOutOfRangeException.h"

#import "autorelease.h"
#import "base64.h"
#import "macros.h"








<







27
28
29
30
31
32
33

34
35
36
37
38
39
40
#import "OFHTTPClient.h"
#import "OFHTTPRequest.h"
#import "OFXMLElement.h"

#import "OFHTTPRequestFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"

#import "OFOutOfMemoryException.h"
#import "OFOutOfRangeException.h"

#import "autorelease.h"
#import "base64.h"
#import "macros.h"

555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571

- (OFXMLElement*)XMLElementBySerializing
{
	void *pool;
	OFXMLElement *element;

	if (itemSize != 1)
		@throw [OFNotImplementedException
		    exceptionWithClass: [self class]
			      selector: _cmd];

	pool = objc_autoreleasePoolPush();
	element = [OFXMLElement
	    elementWithName: [self className]
		  namespace: OF_SERIALIZATION_NS
		stringValue: of_base64_encode(items, count * itemSize)];








|
|
<







554
555
556
557
558
559
560
561
562

563
564
565
566
567
568
569

- (OFXMLElement*)XMLElementBySerializing
{
	void *pool;
	OFXMLElement *element;

	if (itemSize != 1)
		@throw [OFInvalidArgumentException
		    exceptionWithClass: [self class]];


	pool = objc_autoreleasePoolPush();
	element = [OFXMLElement
	    elementWithName: [self className]
		  namespace: OF_SERIALIZATION_NS
		stringValue: of_base64_encode(items, count * itemSize)];

Modified src/OFDictionary.m from [8f52b3e64a] to [2f5f515df2].

12
13
14
15
16
17
18


19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#include <assert.h>

#import "OFDictionary.h"
#import "OFDictionary_hashtable.h"
#import "OFArray.h"
#import "OFString.h"
#import "OFXMLElement.h"

#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"

#import "autorelease.h"

static struct {
	Class isa;
} placeholder;








>
>









<







12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

30
31
32
33
34
35
36
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#include <assert.h>

#import "OFDictionary.h"
#import "OFDictionary_hashtable.h"
#import "OFArray.h"
#import "OFString.h"
#import "OFXMLElement.h"

#import "OFInvalidArgumentException.h"


#import "autorelease.h"

static struct {
	Class isa;
} placeholder;

109
110
111
112
113
114
115
116

117
118

119
120
121
122
123
124
125

- (void)release
{
}

- (void)dealloc
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]

						    selector: _cmd];
	[super dealloc];	/* Get rid of a stupid warning */

}
@end

@implementation OFDictionary
+ (void)initialize
{
	if (self == [OFDictionary class])







|
>
|
|
>







110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFDictionary
+ (void)initialize
{
	if (self == [OFDictionary class])
179
180
181
182
183
184
185

186


187
188
189

190
191
192
193
194
195
196

197


198
199
200

201
202
203
204
205
206
207

	return ret;
}

- init
{
	if (object_getClass(self) == [OFDictionary class]) {

		Class c = [self class];


		[self release];
		@throw [OFNotImplementedException exceptionWithClass: c
							    selector: _cmd];

	}

	return [super init];
}

- initWithDictionary: (OFDictionary*)dictionary
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithObject: (id)object
	  forKey: (id)key
{
	if (key == nil || object == nil)
		@throw [OFInvalidArgumentException







>
|
>
>
|
|
<
>







>
|
>
>
|
|
<
>







182
183
184
185
186
187
188
189
190
191
192
193
194

195
196
197
198
199
200
201
202
203
204
205
206
207
208

209
210
211
212
213
214
215
216

	return ret;
}

- init
{
	if (object_getClass(self) == [OFDictionary class]) {
		@try {
			[self doesNotRecognizeSelector: _cmd];
			abort();
		} @catch (id e) {
			[self release];
			@throw e;

		}
	}

	return [super init];
}

- initWithDictionary: (OFDictionary*)dictionary
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithObject: (id)object
	  forKey: (id)key
{
	if (key == nil || object == nil)
		@throw [OFInvalidArgumentException
235
236
237
238
239
240
241

242


243
244
245

246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263

264


265
266
267

268
269
270
271

272


273
274
275

276
277
278
279
280
281

282
283
284
285
286
287
288
289
290
291
292

293
294
295
296
297
298
299
			       count: count];
}

- initWithObjects: (id const*)objects
	  forKeys: (id const*)keys
	    count: (size_t)count
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithKeysAndObjects: (id)firstKey, ...
{
	id ret;
	va_list arguments;

	va_start(arguments, firstKey);
	ret = [self initWithKey: firstKey
		      arguments: arguments];
	va_end(arguments);

	return ret;
}

- initWithKey: (id)firstKey
    arguments: (va_list)arguments
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithSerialization: (OFXMLElement*)element
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- (id)objectForKey: (id)key
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (id)objectForKeyedSubscript: (id)key
{
	return [self objectForKey: key];
}

- (size_t)count
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- copy
{
	return [self retain];
}








>
|
>
>
|
|
<
>


















>
|
>
>
|
|
<
>




>
|
>
>
|
|
<
>




<
|
>









<
|
>







244
245
246
247
248
249
250
251
252
253
254
255
256

257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281

282
283
284
285
286
287
288
289
290
291
292

293
294
295
296
297

298
299
300
301
302
303
304
305
306
307
308

309
310
311
312
313
314
315
316
317
			       count: count];
}

- initWithObjects: (id const*)objects
	  forKeys: (id const*)keys
	    count: (size_t)count
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithKeysAndObjects: (id)firstKey, ...
{
	id ret;
	va_list arguments;

	va_start(arguments, firstKey);
	ret = [self initWithKey: firstKey
		      arguments: arguments];
	va_end(arguments);

	return ret;
}

- initWithKey: (id)firstKey
    arguments: (va_list)arguments
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithSerialization: (OFXMLElement*)element
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- (id)objectForKey: (id)key
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (id)objectForKeyedSubscript: (id)key
{
	return [self objectForKey: key];
}

- (size_t)count
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- copy
{
	return [self retain];
}

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
	}

	return ret;
}

- (OFEnumerator*)objectEnumerator
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (OFEnumerator*)keyEnumerator
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state
			   objects: (id*)objects
			     count: (int)count_
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

#if defined(OF_HAVE_BLOCKS) && defined(OF_HAVE_FAST_ENUMERATION)
- (void)enumerateKeysAndObjectsUsingBlock:
    (of_dictionary_enumeration_block_t)block
{
	BOOL stop = NO;







<
|
>




<
|
>






<
|
>







455
456
457
458
459
460
461

462
463
464
465
466
467

468
469
470
471
472
473
474
475

476
477
478
479
480
481
482
483
484
	}

	return ret;
}

- (OFEnumerator*)objectEnumerator
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (OFEnumerator*)keyEnumerator
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state
			   objects: (id*)objects
			     count: (int)count_
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

#if defined(OF_HAVE_BLOCKS) && defined(OF_HAVE_FAST_ENUMERATION)
- (void)enumerateKeysAndObjectsUsingBlock:
    (of_dictionary_enumeration_block_t)block
{
	BOOL stop = NO;

Modified src/OFDictionary_hashtable.m from [368527d2d0] to [2aa9021130].

24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#import "OFArray.h"
#import "OFString.h"
#import "OFXMLElement.h"

#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFNotImplementedException.h"

#import "autorelease.h"

static void*
copy(void *value)
{
	return [(id)value copy];







<







24
25
26
27
28
29
30

31
32
33
34
35
36
37
#import "OFArray.h"
#import "OFString.h"
#import "OFXMLElement.h"

#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"


#import "autorelease.h"

static void*
copy(void *value)
{
	return [(id)value copy];

Modified src/OFEnumerator.m from [a52bed56fc] to [6da733cb79].

12
13
14
15
16
17
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
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#import "OFEnumerator.h"

#import "OFNotImplementedException.h"

@implementation OFEnumerator
- init
{
	if (object_getClass(self) == [OFEnumerator class]) {

		Class c = [self class];


		[self release];
		@throw [OFNotImplementedException exceptionWithClass: c
							    selector: _cmd];

	}

	return [super init];
}

- (id)nextObject
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)reset
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}
@end







|

|





>
|
>
>
|
|
<
>







<
|
>




<
|
>


12
13
14
15
16
17
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
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFEnumerator.h"

@implementation OFEnumerator
- init
{
	if (object_getClass(self) == [OFEnumerator class]) {
		@try {
			[self doesNotRecognizeSelector: _cmd];
			abort();
		} @catch (id e) {
			[self release];
			@throw e;

		}
	}

	return [super init];
}

- (id)nextObject
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)reset
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}
@end

Modified src/OFFile.m from [136919bb87] to [b3c8f30967].

55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
#import "OFCreateDirectoryFailedException.h"
#import "OFDeleteDirectoryFailedException.h"
#import "OFDeleteFileFailedException.h"
#import "OFInitializationFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFLinkFailedException.h"
#import "OFLockFailedException.h"
#import "OFNotImplementedException.h"
#import "OFOpenFileFailedException.h"
#import "OFOutOfMemoryException.h"
#import "OFReadFailedException.h"
#import "OFRenameFileFailedException.h"
#import "OFSeekFailedException.h"
#import "OFSymlinkFailedException.h"
#import "OFUnlockFailedException.h"







<







55
56
57
58
59
60
61

62
63
64
65
66
67
68
#import "OFCreateDirectoryFailedException.h"
#import "OFDeleteDirectoryFailedException.h"
#import "OFDeleteFileFailedException.h"
#import "OFInitializationFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFLinkFailedException.h"
#import "OFLockFailedException.h"

#import "OFOpenFileFailedException.h"
#import "OFOutOfMemoryException.h"
#import "OFReadFailedException.h"
#import "OFRenameFileFailedException.h"
#import "OFSeekFailedException.h"
#import "OFSymlinkFailedException.h"
#import "OFUnlockFailedException.h"
634
635
636
637
638
639
640

641


642
643
644

645
646
647
648
649
650
651

	objc_autoreleasePoolPop(pool);
}
#endif

- init
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithPath: (OFString*)path
	  mode: (OFString*)mode
{
	self = [super init];








>
|
>
>
|
|
<
>







633
634
635
636
637
638
639
640
641
642
643
644
645

646
647
648
649
650
651
652
653

	objc_autoreleasePoolPop(pool);
}
#endif

- init
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithPath: (OFString*)path
	  mode: (OFString*)mode
{
	self = [super init];

760
761
762
763
764
765
766

767


768
769
770

771
772
773
774
775
776
777
	of_stdout = [[OFFileSingleton alloc] initWithFileDescriptor: 1];
	of_stderr = [[OFFileSingleton alloc] initWithFileDescriptor: 2];
}

- initWithPath: (OFString*)path
	  mode: (OFString*)mode
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- autorelease
{
	return self;
}








>
|
>
>
|
|
<
>







762
763
764
765
766
767
768
769
770
771
772
773
774

775
776
777
778
779
780
781
782
	of_stdout = [[OFFileSingleton alloc] initWithFileDescriptor: 1];
	of_stderr = [[OFFileSingleton alloc] initWithFileDescriptor: 2];
}

- initWithPath: (OFString*)path
	  mode: (OFString*)mode
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- autorelease
{
	return self;
}

787
788
789
790
791
792
793
794

795
796

797
798
799
800
801
802
803

804
805
- (unsigned int)retainCount
{
	return OF_RETAIN_COUNT_MAX;
}

- (void)dealloc
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]

						    selector: _cmd];
	[super dealloc];	/* Get rid of stupid warning */

}

- (void)lowlevelSeekToOffset: (off_t)offset
		      whence: (int)whence
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}
@end







|
>
|
|
>





<
|
>


792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808

809
810
811
812
- (unsigned int)retainCount
{
	return OF_RETAIN_COUNT_MAX;
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	abort();

	/* Get rid of stupid warning */
	[super dealloc];
}

- (void)lowlevelSeekToOffset: (off_t)offset
		      whence: (int)whence
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}
@end

Modified src/OFHTTPServer.m from [0d0597589f] to [3793430199].

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#import "OFHTTPRequest.h"
#import "OFTCPSocket.h"
#import "OFTimer.h"

#import "OFAlreadyConnectedException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfMemoryException.h"
#import "OFOutOfRangeException.h"
#import "OFWriteFailedException.h"

#import "macros.h"

#define BUFFER_SIZE 1024







<







27
28
29
30
31
32
33

34
35
36
37
38
39
40
#import "OFHTTPRequest.h"
#import "OFTCPSocket.h"
#import "OFTimer.h"

#import "OFAlreadyConnectedException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"

#import "OFOutOfMemoryException.h"
#import "OFOutOfRangeException.h"
#import "OFWriteFailedException.h"

#import "macros.h"

#define BUFFER_SIZE 1024

Modified src/OFHash.m from [a3d9e07296] to [e20cbc12c6].

12
13
14
15
16
17
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
54
55
56
57
58
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#import "OFHash.h"

#import "OFNotImplementedException.h"

@implementation OFHash
+ (instancetype)hash
{
	return [[[self alloc] init] autorelease];
}

+ (size_t)digestSize
{
	@throw [OFNotImplementedException exceptionWithClass: self
						    selector: _cmd];

}

+ (size_t)blockSize
{
	@throw [OFNotImplementedException exceptionWithClass: self
						    selector: _cmd];

}

- (void)updateWithBuffer: (const void*)buffer
		  length: (size_t)length
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (uint8_t*)digest
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (BOOL)isCalculated
{
	return calculated;
}
@end







|

|









<
|
>




<
|
>





<
|
>




<
|
>







12
13
14
15
16
17
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
54
55
56
57
58
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFHash.h"

@implementation OFHash
+ (instancetype)hash
{
	return [[[self alloc] init] autorelease];
}

+ (size_t)digestSize
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

+ (size_t)blockSize
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)updateWithBuffer: (const void*)buffer
		  length: (size_t)length
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (uint8_t*)digest
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (BOOL)isCalculated
{
	return calculated;
}
@end

Modified src/OFMapTable.m from [458807374d] to [1a1f8d234d].

12
13
14
15
16
17
18

19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"


#include <string.h>

#include <assert.h>

#import "OFMapTable.h"
#import "OFEnumerator.h"

#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfRangeException.h"

#import "macros.h"

#define MIN_CAPACITY 16

struct of_map_table_bucket {







>









<







12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

29
30
31
32
33
34
35
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>
#include <string.h>

#include <assert.h>

#import "OFMapTable.h"
#import "OFEnumerator.h"

#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"

#import "OFOutOfRangeException.h"

#import "macros.h"

#define MIN_CAPACITY 16

struct of_map_table_bucket {
86
87
88
89
90
91
92

93


94
95
96

97
98
99
100
101
102
103
	    initWithKeyFunctions: keyFunctions
		  valueFunctions: valueFunctions
			capacity: capacity] autorelease];
}

- init
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithKeyFunctions: (of_map_table_functions_t)keyFunctions_
	valueFunctions: (of_map_table_functions_t)valueFunctions_
{
	return [self initWithKeyFunctions: keyFunctions_
			   valueFunctions: valueFunctions_







>
|
>
>
|
|
<
>







86
87
88
89
90
91
92
93
94
95
96
97
98

99
100
101
102
103
104
105
106
	    initWithKeyFunctions: keyFunctions
		  valueFunctions: valueFunctions
			capacity: capacity] autorelease];
}

- init
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithKeyFunctions: (of_map_table_functions_t)keyFunctions_
	valueFunctions: (of_map_table_functions_t)valueFunctions_
{
	return [self initWithKeyFunctions: keyFunctions_
			   valueFunctions: valueFunctions_
620
621
622
623
624
625
626

627


628
629
630

631
632
633
634
635
636
637
	return valueFunctions;
}
@end

@implementation OFMapTableEnumerator
- init
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- OF_initWithMapTable: (OFMapTable*)mapTable_
	      buckets: (struct of_map_table_bucket**)buckets_
	     capacity: (uint32_t)capacity_
     mutationsPointer: (unsigned long*)mutationsPtr_
{







>
|
>
>
|
|
<
>







623
624
625
626
627
628
629
630
631
632
633
634
635

636
637
638
639
640
641
642
643
	return valueFunctions;
}
@end

@implementation OFMapTableEnumerator
- init
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- OF_initWithMapTable: (OFMapTable*)mapTable_
	      buckets: (struct of_map_table_bucket**)buckets_
	     capacity: (uint32_t)capacity_
     mutationsPointer: (unsigned long*)mutationsPtr_
{
651
652
653
654
655
656
657
658
659

660
661
662
663
664
665
666
	[mapTable release];

	[super dealloc];
}

- (void*)nextValue
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)reset
{
	if (*mutationsPtr != mutations)
		@throw [OFEnumerationMutationException
		    exceptionWithClass: [mapTable class]







<
|
>







657
658
659
660
661
662
663

664
665
666
667
668
669
670
671
672
	[mapTable release];

	[super dealloc];
}

- (void*)nextValue
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)reset
{
	if (*mutationsPtr != mutations)
		@throw [OFEnumerationMutationException
		    exceptionWithClass: [mapTable class]

Modified src/OFMutableArray.m from [7a6a7331fd] to [6e205df884].

12
13
14
15
16
17
18

19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"


#include <string.h>

#include <assert.h>

#import "OFMutableArray.h"
#import "OFMutableArray_adjacent.h"

#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfRangeException.h"

#import "autorelease.h"
#import "macros.h"

static struct {
	Class isa;







>









<







12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

29
30
31
32
33
34
35
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>
#include <string.h>

#include <assert.h>

#import "OFMutableArray.h"
#import "OFMutableArray_adjacent.h"

#import "OFEnumerationMutationException.h"
#import "OFInvalidArgumentException.h"

#import "OFOutOfRangeException.h"

#import "autorelease.h"
#import "macros.h"

static struct {
	Class isa;
142
143
144
145
146
147
148
149

150
151

152
153
154
155
156
157
158

- (void)release
{
}

- (void)dealloc
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]

						    selector: _cmd];
	[super dealloc];	/* Get rid of a stupid warning */

}
@end

@implementation OFMutableArray
+ (void)initialize
{
	if (self == [OFMutableArray class])







|
>
|
|
>







142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFMutableArray
+ (void)initialize
{
	if (self == [OFMutableArray class])
166
167
168
169
170
171
172

173


174
175
176

177
178
179
180
181
182
183

	return [super alloc];
}

- init
{
	if (object_getClass(self) == [OFMutableArray class]) {

		Class c = [self class];


		[self release];
		@throw [OFNotImplementedException exceptionWithClass: c
							    selector: _cmd];

	}

	return [super init];
}

- copy
{







>
|
>
>
|
|
<
>







168
169
170
171
172
173
174
175
176
177
178
179
180

181
182
183
184
185
186
187
188

	return [super alloc];
}

- init
{
	if (object_getClass(self) == [OFMutableArray class]) {
		@try {
			[self doesNotRecognizeSelector: _cmd];
			abort();
		} @catch (id e) {
			[self release];
			@throw e;

		}
	}

	return [super init];
}

- copy
{
195
196
197
198
199
200
201
202
203

204
205
206
207
208
209
210
	[self insertObjectsFromArray: array
			     atIndex: [self count]];
}

- (void)insertObject: (id)object
	     atIndex: (size_t)index
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)insertObjectsFromArray: (OFArray*)array
		       atIndex: (size_t)index
{
	void *pool = objc_autoreleasePoolPush();
	OFEnumerator *enumerator = [array objectEnumerator];







<
|
>







200
201
202
203
204
205
206

207
208
209
210
211
212
213
214
215
	[self insertObjectsFromArray: array
			     atIndex: [self count]];
}

- (void)insertObject: (id)object
	     atIndex: (size_t)index
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)insertObjectsFromArray: (OFArray*)array
		       atIndex: (size_t)index
{
	void *pool = objc_autoreleasePoolPush();
	OFEnumerator *enumerator = [array objectEnumerator];
221
222
223
224
225
226
227
228
229

230
231
232
233
234
235
236

	objc_autoreleasePoolPop(pool);
}

- (void)replaceObjectAtIndex: (size_t)index
		  withObject: (id)object
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

-    (void)setObject: (id)object
  atIndexedSubscript: (size_t)index
{
	[self replaceObjectAtIndex: index
			withObject: object];







<
|
>







226
227
228
229
230
231
232

233
234
235
236
237
238
239
240
241

	objc_autoreleasePoolPop(pool);
}

- (void)replaceObjectAtIndex: (size_t)index
		  withObject: (id)object
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

-    (void)setObject: (id)object
  atIndexedSubscript: (size_t)index
{
	[self replaceObjectAtIndex: index
			withObject: object];
275
276
277
278
279
280
281
282
283

284
285
286
287
288
289
290
			return;
		}
	}
}

- (void)removeObjectAtIndex: (size_t)index
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)removeObject: (id)object
{
	size_t i, count;

	if (object == nil)







<
|
>







280
281
282
283
284
285
286

287
288
289
290
291
292
293
294
295
			return;
		}
	}
}

- (void)removeObjectAtIndex: (size_t)index
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)removeObject: (id)object
{
	size_t i, count;

	if (object == nil)

Modified src/OFMutableDictionary.m from [366d9b52dc] to [89524405ee].

12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#import "OFMutableDictionary_hashtable.h"

#import "OFNotImplementedException.h"

static struct {
	Class isa;
} placeholder;

@interface OFMutableDictionary_placeholder: OFDictionary
@end







|

|







12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFMutableDictionary_hashtable.h"

static struct {
	Class isa;
} placeholder;

@interface OFMutableDictionary_placeholder: OFDictionary
@end
104
105
106
107
108
109
110
111

112
113

114
115
116
117
118
119
120

- (void)release
{
}

- (void)dealloc
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]

						    selector: _cmd];
	[super dealloc];	/* Get rid of a stupid warning */

}
@end

@implementation OFMutableDictionary
+ (void)initialize
{
	if (self == [OFMutableDictionary class])







|
>
|
|
>







104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFMutableDictionary
+ (void)initialize
{
	if (self == [OFMutableDictionary class])
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

	return [super alloc];
}

- init
{
	if (object_getClass(self) == [OFMutableDictionary class]) {

		Class c = [self class];


		[self release];
		@throw [OFNotImplementedException exceptionWithClass: c
							    selector: _cmd];

	}

	return [super init];
}

- (void)setObject: (id)object
	   forKey: (id)key
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

-   (void)setObject: (id)object
  forKeyedSubscript: (id)key
{
	[self setObject: object
		 forKey: key];
}

- (void)removeObjectForKey: (id)key
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- copy
{
	return [[OFDictionary alloc] initWithDictionary: self];
}








>
|
>
>
|
|
<
>








<
|
>











<
|
>







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

	return [super alloc];
}

- init
{
	if (object_getClass(self) == [OFMutableDictionary class]) {
		@try {
			[self doesNotRecognizeSelector: _cmd];
			abort();
		} @catch (id e) {
			[self release];
			@throw e;

		}
	}

	return [super init];
}

- (void)setObject: (id)object
	   forKey: (id)key
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

-   (void)setObject: (id)object
  forKeyedSubscript: (id)key
{
	[self setObject: object
		 forKey: key];
}

- (void)removeObjectForKey: (id)key
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- copy
{
	return [[OFDictionary alloc] initWithDictionary: self];
}

Modified src/OFMutableSet.m from [0f6765c635] to [ebca6379f5].

12
13
14
15
16
17
18


19
20
21
22
23
24
25
26
27
28
29
30
31
32
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#include <assert.h>

#import "OFMutableSet.h"
#import "OFMutableSet_hashtable.h"

#import "OFNotImplementedException.h"

#import "autorelease.h"

static struct {
	Class isa;
} placeholder;

@interface OFMutableSet_placeholder: OFMutableSet







>
>





<
<







12
13
14
15
16
17
18
19
20
21
22
23
24
25


26
27
28
29
30
31
32
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#include <assert.h>

#import "OFMutableSet.h"
#import "OFMutableSet_hashtable.h"



#import "autorelease.h"

static struct {
	Class isa;
} placeholder;

@interface OFMutableSet_placeholder: OFMutableSet
93
94
95
96
97
98
99
100

101
102

103
104
105
106
107
108
109

- (void)release
{
}

- (void)dealloc
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]

						    selector: _cmd];
	[super dealloc];	/* Get rid of a stupid warning */

}
@end

@implementation OFMutableSet
+ (void)initialize
{
	if (self == [OFMutableSet class])







|
>
|
|
>







93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFMutableSet
+ (void)initialize
{
	if (self == [OFMutableSet class])
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

	return [super alloc];
}

- init
{
	if (object_getClass(self) == [OFMutableSet class]) {

		Class c = [self class];


		[self release];
		@throw [OFNotImplementedException exceptionWithClass: c
							    selector: _cmd];

	}

	return [super init];
}

- (void)addObject: (id)object
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)removeObject: (id)object
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)minusSet: (OFSet*)set
{
	void *pool = objc_autoreleasePoolPush();
	OFEnumerator *enumerator = [set objectEnumerator];
	id object;







>
|
>
>
|
|
<
>







<
|
>




<
|
>







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

	return [super alloc];
}

- init
{
	if (object_getClass(self) == [OFMutableSet class]) {
		@try {
			[self doesNotRecognizeSelector: _cmd];
			abort();
		} @catch (id e) {
			[self release];
			@throw e;

		}
	}

	return [super init];
}

- (void)addObject: (id)object
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)removeObject: (id)object
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)minusSet: (OFSet*)set
{
	void *pool = objc_autoreleasePoolPush();
	OFEnumerator *enumerator = [set objectEnumerator];
	id object;

Modified src/OFMutableString.m from [5fcf1bb841] to [e77a1233fc].

23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <sys/types.h>

#import "OFString.h"
#import "OFMutableString_UTF8.h"

#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfRangeException.h"

#import "autorelease.h"
#import "macros.h"

#import "of_asprintf.h"
#import "unicode.h"







<







23
24
25
26
27
28
29

30
31
32
33
34
35
36
#include <sys/types.h>

#import "OFString.h"
#import "OFMutableString_UTF8.h"

#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"

#import "OFOutOfRangeException.h"

#import "autorelease.h"
#import "macros.h"

#import "of_asprintf.h"
#import "unicode.h"
229
230
231
232
233
234
235
236

237
238

239
240
241
242
243
244
245

- (void)release
{
}

- (void)dealloc
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]

						    selector: _cmd];
	[super dealloc];	/* Get rid of a stupid warning */

}
@end

@implementation OFMutableString
+ (void)initialize
{
	if (self == [OFMutableString class])







|
>
|
|
>







228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFMutableString
+ (void)initialize
{
	if (self == [OFMutableString class])
296
297
298
299
300
301
302
303
304

305
306
307
308
309
310
311

	objc_autoreleasePoolPop(pool);
}

- (void)setCharacter: (of_unichar_t)character
	     atIndex: (size_t)index
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)appendUTF8String: (const char*)UTF8String
{
	void *pool = objc_autoreleasePoolPush();

	[self appendString: [OFString stringWithUTF8String: UTF8String]];







<
|
>







297
298
299
300
301
302
303

304
305
306
307
308
309
310
311
312

	objc_autoreleasePoolPop(pool);
}

- (void)setCharacter: (of_unichar_t)character
	     atIndex: (size_t)index
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)appendUTF8String: (const char*)UTF8String
{
	void *pool = objc_autoreleasePoolPush();

	[self appendString: [OFString stringWithUTF8String: UTF8String]];
430
431
432
433
434
435
436
437
438

439
440
441
442
443
444

445
446
447
448
449
450
451
			wordStartTableSize: OF_UNICODE_TITLECASE_TABLE_SIZE
		       wordMiddleTableSize: OF_UNICODE_LOWERCASE_TABLE_SIZE];
}

- (void)insertString: (OFString*)string
	     atIndex: (size_t)index
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)deleteCharactersInRange: (of_range_t)range
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)replaceCharactersInRange: (of_range_t)range
		      withString: (OFString*)replacement
{
	[self deleteCharactersInRange: range];
	[self insertString: replacement







<
|
>




<
|
>







431
432
433
434
435
436
437

438
439
440
441
442
443

444
445
446
447
448
449
450
451
452
			wordStartTableSize: OF_UNICODE_TITLECASE_TABLE_SIZE
		       wordMiddleTableSize: OF_UNICODE_LOWERCASE_TABLE_SIZE];
}

- (void)insertString: (OFString*)string
	     atIndex: (size_t)index
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)deleteCharactersInRange: (of_range_t)range
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)replaceCharactersInRange: (of_range_t)range
		      withString: (OFString*)replacement
{
	[self deleteCharactersInRange: range];
	[self insertString: replacement

Modified src/OFNull.m from [469bfd7104] to [fdbe044d7b].

12
13
14
15
16
17
18


19
20
21
22
23
24
25
26
27
28
29
30
31
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFNull.h"
#import "OFString.h"
#import "OFXMLElement.h"

#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"

#import "autorelease.h"

static OFNull *null = nil;

@implementation OFNull
+ (void)initialize







>
>





<







12
13
14
15
16
17
18
19
20
21
22
23
24
25

26
27
28
29
30
31
32
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFNull.h"
#import "OFString.h"
#import "OFXMLElement.h"

#import "OFInvalidArgumentException.h"


#import "autorelease.h"

static OFNull *null = nil;

@implementation OFNull
+ (void)initialize
104
105
106
107
108
109
110
111

112
113

114
115
- (unsigned int)retainCount
{
	return OF_RETAIN_COUNT_MAX;
}

- (void)dealloc
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]

						    selector: _cmd];
	[super dealloc];	/* Get rid of a stupid warning */

}
@end







|
>
|
|
>


105
106
107
108
109
110
111
112
113
114
115
116
117
118
- (unsigned int)retainCount
{
	return OF_RETAIN_COUNT_MAX;
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

Modified src/OFNumber.m from [a189f6857c] to [ba1adda867].

12
13
14
15
16
17
18


19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#include <math.h>

#import "OFNumber.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFXMLAttribute.h"

#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFNotImplementedException.h"

#import "autorelease.h"
#import "macros.h"

#define RETURN_AS(t)							\
	switch (type) {							\
	case OF_NUMBER_BOOL:						\







>
>









<







12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

30
31
32
33
34
35
36
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#include <math.h>

#import "OFNumber.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFXMLAttribute.h"

#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"


#import "autorelease.h"
#import "macros.h"

#define RETURN_AS(t)							\
	switch (type) {							\
	case OF_NUMBER_BOOL:						\
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
		return [OFNumber numberWithIntPtr:			\
		    value.intptr o [n intPtrValue]];			\
	case OF_NUMBER_UINTPTR:						\
		return [OFNumber numberWithUIntPtr:			\
		    value.uintptr o [n uIntPtrValue]];			\
	case OF_NUMBER_FLOAT:						\
	case OF_NUMBER_DOUBLE:						\
		@throw [OFNotImplementedException			\
		    exceptionWithClass: [self class]			\
			      selector: _cmd];				\
	default:							\
		@throw [OFInvalidFormatException			\
		    exceptionWithClass: [self class]];			\
	}
#define CALCULATE3(o)							\







|







245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
		return [OFNumber numberWithIntPtr:			\
		    value.intptr o [n intPtrValue]];			\
	case OF_NUMBER_UINTPTR:						\
		return [OFNumber numberWithUIntPtr:			\
		    value.uintptr o [n uIntPtrValue]];			\
	case OF_NUMBER_FLOAT:						\
	case OF_NUMBER_DOUBLE:						\
		@throw [OFInvalidArgumentException			\
		    exceptionWithClass: [self class]			\
			      selector: _cmd];				\
	default:							\
		@throw [OFInvalidFormatException			\
		    exceptionWithClass: [self class]];			\
	}
#define CALCULATE3(o)							\
446
447
448
449
450
451
452
453
454





455
456
457
458
459
460
461
+ (instancetype)numberWithDouble: (double)double_
{
	return [[[self alloc] initWithDouble: double_] autorelease];
}

- init
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];





}

- initWithBool: (BOOL)bool_
{
	self = [super init];

	value.bool_ = (bool_ ? YES : NO);







|
|
>
>
>
>
>







447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
+ (instancetype)numberWithDouble: (double)double_
{
	return [[[self alloc] initWithDouble: double_] autorelease];
}

- init
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;
	}
}

- initWithBool: (BOOL)bool_
{
	self = [super init];

	value.bool_ = (bool_ ? YES : NO);

Modified src/OFObject+Serialization.m from [c7f6b6d6fd] to [15c867dc7d].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFObject.h"
#import "OFObject+Serialization.h"
#import "OFSerialization.h"
#import "OFString.h"
#import "OFXMLElement.h"

#import "OFNotImplementedException.h"

#import "autorelease.h"

int _OFObject_Serialization_reference;

@implementation OFObject (Serialization)
- (OFString*)stringBySerializing
{
	void *pool;
	OFXMLElement *element;
	OFXMLElement *root;
	OFString *ret;

	if (![self conformsToProtocol: @protocol(OFSerialization)])
		@throw [OFNotImplementedException
		    exceptionWithClass: [self class]
			      selector: @selector(stringBySerializing)];



	pool = objc_autoreleasePoolPush();
	element = [(id)self XMLElementBySerializing];

	root = [OFXMLElement elementWithName: @"serialization"
				   namespace: OF_SERIALIZATION_NS];
	[root addAttributeWithName: @"version"







>
>







<
<












|
<
|
<
>
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFObject.h"
#import "OFObject+Serialization.h"
#import "OFSerialization.h"
#import "OFString.h"
#import "OFXMLElement.h"



#import "autorelease.h"

int _OFObject_Serialization_reference;

@implementation OFObject (Serialization)
- (OFString*)stringBySerializing
{
	void *pool;
	OFXMLElement *element;
	OFXMLElement *root;
	OFString *ret;

	if (![self conformsToProtocol: @protocol(OFSerialization)]) {

		[self doesNotRecognizeSelector: _cmd];

		abort();
	}

	pool = objc_autoreleasePoolPush();
	element = [(id)self XMLElementBySerializing];

	root = [OFXMLElement elementWithName: @"serialization"
				   namespace: OF_SERIALIZATION_NS];
	[root addAttributeWithName: @"version"

Modified src/OFObject.h from [c663f1ca8f] to [fdedfa544a].

818
819
820
821
822
823
824










825
826
827
828
829
830
831
 *
 * @note When the message should not be forwarded, you should not return nil,
 *	 but instead return the result of the superclass!
 *
 * @return The target to forward the message to
 */
- (id)forwardingTargetForSelector: (SEL)selector;










@end

/*!
 * @brief A protocol for the creation of copies.
 */
@protocol OFCopying
/*!







>
>
>
>
>
>
>
>
>
>







818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
 *
 * @note When the message should not be forwarded, you should not return nil,
 *	 but instead return the result of the superclass!
 *
 * @return The target to forward the message to
 */
- (id)forwardingTargetForSelector: (SEL)selector;

/*!
 * @brief Handles messages which are not understood by the receiver.
 *
 * @warning If you override this method, you must make sure that it never
 *	    returns.
 *
 * @param selector The selector not understood by the receiver
 */
- (void)doesNotRecognizeSelector: (SEL)selector;
@end

/*!
 * @brief A protocol for the creation of copies.
 */
@protocol OFCopying
/*!

Modified src/OFObject.m from [9c302a662d] to [23e21a638e].

120
121
122
123
124
125
126
127
128
129




130
131
132
133
134
135
136
	    exceptionWithClass: [object class]
			object: object];
}

void
of_method_not_found(id obj, SEL sel)
{
	fprintf(stderr, "Runtime error: Selector %s is not implemented in "
	    "class %s!\n", sel_getName(sel),
	    class_getName(object_getClass(obj)));




	abort();
}

#ifdef OF_OBJFW_RUNTIME
static IMP
forward_handler(id obj, SEL sel)
{







|
|
<
>
>
>
>







120
121
122
123
124
125
126
127
128

129
130
131
132
133
134
135
136
137
138
139
	    exceptionWithClass: [object class]
			object: object];
}

void
of_method_not_found(id obj, SEL sel)
{
	[obj doesNotRecognizeSelector: sel];


	/*
	 * Just in case doesNotRecognizeSelector: returned, even though it must
	 * never return.
	 */
	abort();
}

#ifdef OF_OBJFW_RUNTIME
static IMP
forward_handler(id obj, SEL sel)
{
972
973
974
975
976
977
978






979
980
981
982
983
984
985
	free(PRE_MEM(pointer));
}

- (id)forwardingTargetForSelector: (SEL)selector
{
	return nil;
}







- retain
{
#if defined(OF_ATOMIC_OPS)
	of_atomic_inc_32(&PRE_IVARS->retainCount);
#elif defined(OF_THREADS)
	OF_ENSURE(of_spinlock_lock(&PRE_IVARS->retainCountSpinlock));







>
>
>
>
>
>







975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
	free(PRE_MEM(pointer));
}

- (id)forwardingTargetForSelector: (SEL)selector
{
	return nil;
}

- (void)doesNotRecognizeSelector: (SEL)selector
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: selector];
}

- retain
{
#if defined(OF_ATOMIC_OPS)
	of_atomic_inc_32(&PRE_IVARS->retainCount);
#elif defined(OF_THREADS)
	OF_ENSURE(of_spinlock_lock(&PRE_IVARS->retainCountSpinlock));
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067

1068
1069
1070
1071
1072
1073
1074
1075
1076
1077

1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089

1090
1091
1092
1093
1094
1095
1096

1097
1098
1099
1100
1101
1102
1103

1104
1105
1106
1107
1108
1109
1110
1111

1112
1113
1114
1115
1116
1117

1118
1119
1120
1121
1122
1123
1124

	free((char*)self - PRE_IVARS_ALIGN);
}

/* Required to use properties with the Apple runtime */
- copyWithZone: (void*)zone
{
	if OF_UNLIKELY (zone != NULL)
		@throw [OFNotImplementedException
		    exceptionWithClass: [self class]
			      selector: _cmd];


	return [(id)self copy];
}

- mutableCopyWithZone: (void*)zone
{
	if OF_UNLIKELY (zone != NULL)
		@throw [OFNotImplementedException
		    exceptionWithClass: [self class]
			      selector: _cmd];


	return [(id)self mutableCopy];
}

/*
 * Those are needed as the root class is the superclass of the root class's
 * metaclass and thus instance methods can be sent to class objects as well.
 */
+ (void*)allocMemoryWithSize: (size_t)size
{
	@throw [OFNotImplementedException exceptionWithClass: self
						    selector: _cmd];

}

+ (void*)allocMemoryWithSize: (size_t)size
		       count: (size_t)count
{
	@throw [OFNotImplementedException exceptionWithClass: self
						    selector: _cmd];

}

+ (void*)resizeMemory: (void*)pointer
		 size: (size_t)size
{
	@throw [OFNotImplementedException exceptionWithClass: self
						    selector: _cmd];

}

+ (void*)resizeMemory: (void*)pointer
		 size: (size_t)size
		count: (size_t)count
{
	@throw [OFNotImplementedException exceptionWithClass: self
						    selector: _cmd];

}

+ (void)freeMemory: (void*)pointer
{
	@throw [OFNotImplementedException exceptionWithClass: self
						    selector: _cmd];

}

+ retain
{
	return self;
}








|
<
|
|
>






|
<
|
|
>










<
|
>





<
|
>





<
|
>






<
|
>




<
|
>







1066
1067
1068
1069
1070
1071
1072
1073

1074
1075
1076
1077
1078
1079
1080
1081
1082
1083

1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096

1097
1098
1099
1100
1101
1102
1103

1104
1105
1106
1107
1108
1109
1110

1111
1112
1113
1114
1115
1116
1117
1118

1119
1120
1121
1122
1123
1124

1125
1126
1127
1128
1129
1130
1131
1132
1133

	free((char*)self - PRE_IVARS_ALIGN);
}

/* Required to use properties with the Apple runtime */
- copyWithZone: (void*)zone
{
	if OF_UNLIKELY (zone != NULL) {

		[self doesNotRecognizeSelector: _cmd];
		abort();
	}

	return [(id)self copy];
}

- mutableCopyWithZone: (void*)zone
{
	if OF_UNLIKELY (zone != NULL) {

		[self doesNotRecognizeSelector: _cmd];
		abort();
	}

	return [(id)self mutableCopy];
}

/*
 * Those are needed as the root class is the superclass of the root class's
 * metaclass and thus instance methods can be sent to class objects as well.
 */
+ (void*)allocMemoryWithSize: (size_t)size
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

+ (void*)allocMemoryWithSize: (size_t)size
		       count: (size_t)count
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

+ (void*)resizeMemory: (void*)pointer
		 size: (size_t)size
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

+ (void*)resizeMemory: (void*)pointer
		 size: (size_t)size
		count: (size_t)count
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

+ (void)freeMemory: (void*)pointer
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

+ retain
{
	return self;
}

1134
1135
1136
1137
1138
1139
1140
1141
1142

1143
1144
1145
1146
1147
1148

1149
1150
1151
1152
1153
1154

1155
1156

+ (void)release
{
}

+ (void)dealloc
{
	@throw [OFNotImplementedException exceptionWithClass: self
						    selector: _cmd];

}

+ copyWithZone: (void*)zone
{
	@throw [OFNotImplementedException exceptionWithClass: self
						    selector: _cmd];

}

+ mutableCopyWithZone: (void*)zone
{
	@throw [OFNotImplementedException exceptionWithClass: self
						    selector: _cmd];

}
@end







<
|
>




<
|
>




<
|
>


1143
1144
1145
1146
1147
1148
1149

1150
1151
1152
1153
1154
1155

1156
1157
1158
1159
1160
1161

1162
1163
1164
1165

+ (void)release
{
}

+ (void)dealloc
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

+ copyWithZone: (void*)zone
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

+ mutableCopyWithZone: (void*)zone
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}
@end

Modified src/OFPlugin.m from [26711ccaf1] to [260b8dfd9b].

23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <dlfcn.h>
#endif

#import "OFPlugin.h"
#import "OFString.h"

#import "OFInitializationFailedException.h"
#import "OFNotImplementedException.h"

#import "autorelease.h"

#ifdef _WIN32
# define dlopen(file, mode) LoadLibrary(file)
# define dlsym(handle, symbol) GetProcAddress(handle, symbol)
# define dlclose(handle) FreeLibrary(handle)







<







23
24
25
26
27
28
29

30
31
32
33
34
35
36
#include <dlfcn.h>
#endif

#import "OFPlugin.h"
#import "OFString.h"

#import "OFInitializationFailedException.h"


#import "autorelease.h"

#ifdef _WIN32
# define dlopen(file, mode) LoadLibrary(file)
# define dlsym(handle, symbol) GetProcAddress(handle, symbol)
# define dlclose(handle) FreeLibrary(handle)
66
67
68
69
70
71
72

73


74
75
76

77
78
79
80
81
82
83
	plugin->handle = handle;
	return plugin;
}

- init
{
	if (object_getClass(self) == [OFPlugin class]) {

		Class c = [self class];


		[self release];
		@throw [OFNotImplementedException exceptionWithClass: c
							    selector: _cmd];

	}

	return [super init];
}

- (void)dealloc
{







>
|
>
>
|
|
<
>







65
66
67
68
69
70
71
72
73
74
75
76
77

78
79
80
81
82
83
84
85
	plugin->handle = handle;
	return plugin;
}

- init
{
	if (object_getClass(self) == [OFPlugin class]) {
		@try {
			[self doesNotRecognizeSelector: _cmd];
			abort();
		} @catch (id e) {
			[self release];
			@throw e;

		}
	}

	return [super init];
}

- (void)dealloc
{

Modified src/OFProcess.m from [ed7607de4d] to [77862565be].

24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#endif

#import "OFProcess.h"
#import "OFString.h"
#import "OFArray.h"

#import "OFInitializationFailedException.h"
#import "OFNotImplementedException.h"
#import "OFReadFailedException.h"
#import "OFWriteFailedException.h"

#ifdef _WIN32
# include <windows.h>
#endif








<







24
25
26
27
28
29
30

31
32
33
34
35
36
37
#endif

#import "OFProcess.h"
#import "OFString.h"
#import "OFArray.h"

#import "OFInitializationFailedException.h"

#import "OFReadFailedException.h"
#import "OFWriteFailedException.h"

#ifdef _WIN32
# include <windows.h>
#endif

296
297
298
299
300
301
302
303
304

305
306
307
308
309
310
311
312
313
314

315
316
317
318
319
320
321
}

- (int)fileDescriptorForReading
{
#ifndef _WIN32
	return readPipe[0];
#else
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

#endif
}

- (int)fileDescriptorForWriting
{
#ifndef _WIN32
	return writePipe[1];
#else
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

#endif
}

- (void)closeForWriting
{
#ifndef _WIN32
	if (writePipe[1] != -1)







<
|
>








<
|
>







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
320
}

- (int)fileDescriptorForReading
{
#ifndef _WIN32
	return readPipe[0];
#else

	[self doesNotRecognizeSelector: _cmd];
	abort();
#endif
}

- (int)fileDescriptorForWriting
{
#ifndef _WIN32
	return writePipe[1];
#else

	[self doesNotRecognizeSelector: _cmd];
	abort();
#endif
}

- (void)closeForWriting
{
#ifndef _WIN32
	if (writePipe[1] != -1)

Modified src/OFSeekableStream.m from [ff18537f89] to [432d090484].

10
11
12
13
14
15
16

17

18
19
20
21
22
23
24
25
26

27
28
29
30
31
32
33
34
35
36
37
38
39
 *
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */


#import "OFSeekableStream.h"


#import "OFNotImplementedException.h"

@implementation OFSeekableStream
- (void)lowlevelSeekToOffset: (off_t)offset
		      whence: (int)whence
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)seekToOffset: (off_t)offset
	      whence: (int)whence
{
	[self lowlevelSeekToOffset: offset
			    whence: whence];

	[self freeMemory: cache];
	cache = NULL;
	cacheLength = 0;
}
@end







>
|
>

|





<
|
>













10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 *
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFSeekableStream.h"

@implementation OFSeekableStream
- (void)lowlevelSeekToOffset: (off_t)offset
		      whence: (int)whence
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)seekToOffset: (off_t)offset
	      whence: (int)whence
{
	[self lowlevelSeekToOffset: offset
			    whence: whence];

	[self freeMemory: cache];
	cache = NULL;
	cacheLength = 0;
}
@end

Modified src/OFSet.m from [f4c7729752] to [fdc84a25fe].

12
13
14
15
16
17
18


19
20
21
22
23
24
25
26
27
28
29
30
31
32
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFSet.h"
#import "OFSet_hashtable.h"
#import "OFString.h"
#import "OFXMLElement.h"

#import "OFNotImplementedException.h"

#import "autorelease.h"

static struct {
	Class isa;
} placeholder;

@interface OFSet_placeholder: OFSet







>
>





<
<







12
13
14
15
16
17
18
19
20
21
22
23
24
25


26
27
28
29
30
31
32
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFSet.h"
#import "OFSet_hashtable.h"
#import "OFString.h"
#import "OFXMLElement.h"



#import "autorelease.h"

static struct {
	Class isa;
} placeholder;

@interface OFSet_placeholder: OFSet
92
93
94
95
96
97
98
99

100
101

102
103
104
105
106
107
108

- (void)release
{
}

- (void)dealloc
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]

						    selector: _cmd];
	[super dealloc];	/* Get rid of a stupid warning */

}
@end

@implementation OFSet
+ (void)initialize
{
	if (self == [OFSet class])







|
>
|
|
>







92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFSet
+ (void)initialize
{
	if (self == [OFSet class])
151
152
153
154
155
156
157

158


159
160
161

162
163
164
165
166
167
168

169


170
171
172
173
174

175
176

177


178



179




180





181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207

208


209
210
211

212
213
214
215

216


217
218
219

220
221
222
223
224
225

226
227
228
229
230
231

232
233
234
235
236
237

238
239
240
241
242
243
244
245

246
247
248
249
250
251
252
	return [[[self alloc] initWithObjects: objects
					count: count] autorelease];
}

- init
{
	if (object_getClass(self) == [OFSet class]) {

		Class c = [self class];


		[self release];
		@throw [OFNotImplementedException exceptionWithClass: c
							    selector: _cmd];

	}

	return [super init];
}

- initWithSet: (OFSet*)set
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];
}


- initWithArray: (OFArray*)array
{

	Class c = [self class];


	[self release];



	@throw [OFNotImplementedException exceptionWithClass: c




						    selector: _cmd];





}

- (id)initWithObjects: (id)firstObject, ...
{
	id ret;
	va_list arguments;

	va_start(arguments, firstObject);
	ret = [self initWithObject: firstObject
			 arguments: arguments];
	va_end(arguments);

	return ret;
}

- initWithObjects: (id const*)objects
	    count: (size_t)count
{
	Class c = [self class];
	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];
}

- initWithObject: (id)firstObject
       arguments: (va_list)arguments
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithSerialization: (OFXMLElement*)element
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- (size_t)count
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (BOOL)containsObject: (id)object
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (OFEnumerator*)objectEnumerator
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state
			   objects: (id*)objects
			     count: (int)count
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (BOOL)isEqual: (id)object
{
	OFSet *otherSet;

	if (![object isKindOfClass: [OFSet class]])







>
|
>
>
|
|
<
>







>
|
>
>
|
|
<
|
|
>


>
|
>
>
|
>
>
>
|
>
>
>
>
|
>
>
>
>
>















<
<
<
<
<
<
<
<
<



>
|
>
>
|
|
<
>




>
|
>
>
|
|
<
>




<
|
>




<
|
>




<
|
>






<
|
>







153
154
155
156
157
158
159
160
161
162
163
164
165

166
167
168
169
170
171
172
173
174
175
176
177
178
179

180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218









219
220
221
222
223
224
225
226
227

228
229
230
231
232
233
234
235
236
237
238

239
240
241
242
243

244
245
246
247
248
249

250
251
252
253
254
255

256
257
258
259
260
261
262
263

264
265
266
267
268
269
270
271
272
	return [[[self alloc] initWithObjects: objects
					count: count] autorelease];
}

- init
{
	if (object_getClass(self) == [OFSet class]) {
		@try {
			[self doesNotRecognizeSelector: _cmd];
			abort();
		} @catch (id e) {
			[self release];
			@throw e;

		}
	}

	return [super init];
}

- initWithSet: (OFSet*)set
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithArray: (OFArray*)array
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;
	}
}

- initWithObjects: (id const*)objects
	    count: (size_t)count
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;
	}
}

- (id)initWithObjects: (id)firstObject, ...
{
	id ret;
	va_list arguments;

	va_start(arguments, firstObject);
	ret = [self initWithObject: firstObject
			 arguments: arguments];
	va_end(arguments);

	return ret;
}










- initWithObject: (id)firstObject
       arguments: (va_list)arguments
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithSerialization: (OFXMLElement*)element
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- (size_t)count
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (BOOL)containsObject: (id)object
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (OFEnumerator*)objectEnumerator
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state
			   objects: (id*)objects
			     count: (int)count
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (BOOL)isEqual: (id)object
{
	OFSet *otherSet;

	if (![object isKindOfClass: [OFSet class]])

Modified src/OFSortedList.m from [679b0761d3] to [85917055a7].

12
13
14
15
16
17
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
54
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#import "OFSortedList.h"

#import "OFNotImplementedException.h"

@implementation OFSortedList
- (of_list_object_t*)appendObject: (id)object
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (of_list_object_t*)prependObject: (id)object
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (of_list_object_t*)insertObject: (id)object
		 beforeListObject: (of_list_object_t*)listObject
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (of_list_object_t*)insertObject: (id)object
		  afterListObject: (of_list_object_t*)listObject
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (of_list_object_t*)insertObject: (id <OFComparing>)object
{
	of_list_object_t *iter;

	for (iter = lastListObject; iter != NULL; iter = iter->previous) {







|

|




<
|
>




<
|
>





<
|
>





<
|
>







12
13
14
15
16
17
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
54
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFSortedList.h"

@implementation OFSortedList
- (of_list_object_t*)appendObject: (id)object
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (of_list_object_t*)prependObject: (id)object
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (of_list_object_t*)insertObject: (id)object
		 beforeListObject: (of_list_object_t*)listObject
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (of_list_object_t*)insertObject: (id)object
		  afterListObject: (of_list_object_t*)listObject
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (of_list_object_t*)insertObject: (id <OFComparing>)object
{
	of_list_object_t *iter;

	for (iter = lastListObject; iter != NULL; iter = iter->previous) {

Modified src/OFStream.m from [4d480da639] to [31e482b9ed].

34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

59


60
61
62

63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

78
79
80
81
82
83
84

85
86
87
88
89
90
91

92
93
94
95
96
97
98
#import "OFStream.h"
#import "OFString.h"
#import "OFDataArray.h"
#import "OFRunLoop.h"

#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFNotImplementedException.h"
#import "OFSetOptionFailedException.h"

#import "macros.h"
#import "of_asprintf.h"

@implementation OFStream
#ifndef _WIN32
+ (void)initialize
{
	if (self == [OFStream class])
		signal(SIGPIPE, SIG_IGN);
}
#endif

- init
{
	if (object_getClass(self) == [OFStream class]) {

		Class c = [self class];


		[self release];
		@throw [OFNotImplementedException exceptionWithClass: c
							    selector: _cmd];

	}

	self = [super init];

	cache = NULL;
	writeBuffer = NULL;
	blocking = YES;

	return self;
}

- (BOOL)lowlevelIsAtEndOfStream
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (size_t)lowlevelReadIntoBuffer: (void*)buffer
			  length: (size_t)length
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)lowlevelWriteBuffer: (const void*)buffer
		     length: (size_t)length
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- copy
{
	return [self retain];
}








<

















>
|
>
>
|
|
<
>













<
|
>





<
|
>





<
|
>







34
35
36
37
38
39
40

41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

64
65
66
67
68
69
70
71
72
73
74
75
76
77

78
79
80
81
82
83
84

85
86
87
88
89
90
91

92
93
94
95
96
97
98
99
100
#import "OFStream.h"
#import "OFString.h"
#import "OFDataArray.h"
#import "OFRunLoop.h"

#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"

#import "OFSetOptionFailedException.h"

#import "macros.h"
#import "of_asprintf.h"

@implementation OFStream
#ifndef _WIN32
+ (void)initialize
{
	if (self == [OFStream class])
		signal(SIGPIPE, SIG_IGN);
}
#endif

- init
{
	if (object_getClass(self) == [OFStream class]) {
		@try {
			[self doesNotRecognizeSelector: _cmd];
			abort();
		} @catch (id e) {
			[self release];
			@throw e;

		}
	}

	self = [super init];

	cache = NULL;
	writeBuffer = NULL;
	blocking = YES;

	return self;
}

- (BOOL)lowlevelIsAtEndOfStream
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (size_t)lowlevelReadIntoBuffer: (void*)buffer
			  length: (size_t)length
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)lowlevelWriteBuffer: (const void*)buffer
		     length: (size_t)length
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- copy
{
	return [self retain];
}

1479
1480
1481
1482
1483
1484
1485
1486
1487

1488
1489
1490
1491
1492
1493
1494

1495
1496
1497
1498
1499
1500

1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511

1512
1513
1514
1515
1516
1517
1518

	if (fcntl([self fileDescriptorForReading], F_SETFL, readFlags) == -1 ||
	    fcntl([self fileDescriptorForWriting], F_SETFL, writeFlags) == -1)
		@throw [OFSetOptionFailedException
		    exceptionWithClass: [self class]
				stream: self];
#else
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

#endif
}

- (int)fileDescriptorForReading
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (int)fileDescriptorForWriting
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)cancelAsyncRequests
{
	[OFRunLoop OF_cancelAsyncRequestsForStream: self];
}

- (void)close
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (BOOL)OF_isWaitingForDelimiter
{
	return waitingForDelimiter;
}
@end







<
|
>





<
|
>




<
|
>









<
|
>







1481
1482
1483
1484
1485
1486
1487

1488
1489
1490
1491
1492
1493
1494

1495
1496
1497
1498
1499
1500

1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511

1512
1513
1514
1515
1516
1517
1518
1519
1520

	if (fcntl([self fileDescriptorForReading], F_SETFL, readFlags) == -1 ||
	    fcntl([self fileDescriptorForWriting], F_SETFL, writeFlags) == -1)
		@throw [OFSetOptionFailedException
		    exceptionWithClass: [self class]
				stream: self];
#else

	[self doesNotRecognizeSelector: _cmd];
	abort();
#endif
}

- (int)fileDescriptorForReading
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (int)fileDescriptorForWriting
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)cancelAsyncRequests
{
	[OFRunLoop OF_cancelAsyncRequestsForStream: self];
}

- (void)close
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (BOOL)OF_isWaitingForDelimiter
{
	return waitingForDelimiter;
}
@end

Modified src/OFStreamObserver.m from [df859b9099] to [77de7642b5].

14
15
16
17
18
19
20


21
22
23
24
25
26
27
 * file.
 */

#include "config.h"

#define __NO_EXT_QNX



#include <unistd.h>

#include <assert.h>

#import "OFStreamObserver.h"
#import "OFArray.h"
#import "OFDictionary.h"







>
>







14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 * file.
 */

#include "config.h"

#define __NO_EXT_QNX

#include <stdlib.h>

#include <unistd.h>

#include <assert.h>

#import "OFStreamObserver.h"
#import "OFArray.h"
#import "OFDictionary.h"
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
# import "OFStreamObserver_poll.h"
#endif
#if defined(HAVE_SYS_SELECT_H) || defined(_WIN32)
# import "OFStreamObserver_select.h"
#endif

#import "OFInitializationFailedException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfRangeException.h"

#import "autorelease.h"
#import "macros.h"

enum {
	QUEUE_ADD = 0,







<







43
44
45
46
47
48
49

50
51
52
53
54
55
56
# import "OFStreamObserver_poll.h"
#endif
#if defined(HAVE_SYS_SELECT_H) || defined(_WIN32)
# import "OFStreamObserver_select.h"
#endif

#import "OFInitializationFailedException.h"

#import "OFOutOfRangeException.h"

#import "autorelease.h"
#import "macros.h"

enum {
	QUEUE_ADD = 0,
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
	OF_ENSURE(sendto(cancelFD[1], "", 1, 0, (struct sockaddr*)&cancelAddr,
	    sizeof(cancelAddr)) > 0);
#endif
}

- (void)OF_addFileDescriptorForReading: (int)fd
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)OF_addFileDescriptorForWriting: (int)fd
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)OF_removeFileDescriptorForReading: (int)fd
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)OF_removeFileDescriptorForWriting: (int)fd
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)OF_processQueue
{
	[mutex lock];
	@try {
		OFStream **queueObjects = [queue objects];







<
|
>




<
|
>




<
|
>




<
|
>







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
	OF_ENSURE(sendto(cancelFD[1], "", 1, 0, (struct sockaddr*)&cancelAddr,
	    sizeof(cancelAddr)) > 0);
#endif
}

- (void)OF_addFileDescriptorForReading: (int)fd
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)OF_addFileDescriptorForWriting: (int)fd
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)OF_removeFileDescriptorForReading: (int)fd
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)OF_removeFileDescriptorForWriting: (int)fd
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)OF_processQueue
{
	[mutex lock];
	@try {
		OFStream **queueObjects = [queue objects];
359
360
361
362
363
364
365
366
367

368
369
370
371
372
373
374
- (void)observe
{
	[self observeWithTimeout: -1];
}

- (BOOL)observeWithTimeout: (double)timeout
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)cancel
{
#ifndef _WIN32
	OF_ENSURE(write(cancelFD[1], "", 1) > 0);
#else







<
|
>







360
361
362
363
364
365
366

367
368
369
370
371
372
373
374
375
- (void)observe
{
	[self observeWithTimeout: -1];
}

- (BOOL)observeWithTimeout: (double)timeout
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)cancel
{
#ifndef _WIN32
	OF_ENSURE(write(cancelFD[1], "", 1) > 0);
#else

Modified src/OFString.m from [9b74d0387e] to [5f30990c6d].

328
329
330
331
332
333
334
335

336
337

338
339
340
341
342
343
344

- (void)release
{
}

- (void)dealloc
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]

						    selector: _cmd];
	[super dealloc];	/* Get rid of a stupid warning */

}
@end

@implementation OFString
+ (void)initialize
{
	if (self == [OFString class])







|
>
|
|
>







328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFString
+ (void)initialize
{
	if (self == [OFString class])
505
506
507
508
509
510
511

512


513
514
515

516
517
518
519
520
521
522
	return [[[self alloc] initWithContentsOfURL: URL
					   encoding: encoding] autorelease];
}

- init
{
	if (object_getClass(self) == [OFString class]) {

		Class c = [self class];


		[self release];
		@throw [OFNotImplementedException exceptionWithClass: c
							    selector: _cmd];

	}

	return [super init];
}

- initWithUTF8String: (const char*)UTF8String
{







>
|
>
>
|
|
<
>







507
508
509
510
511
512
513
514
515
516
517
518
519

520
521
522
523
524
525
526
527
	return [[[self alloc] initWithContentsOfURL: URL
					   encoding: encoding] autorelease];
}

- init
{
	if (object_getClass(self) == [OFString class]) {
		@try {
			[self doesNotRecognizeSelector: _cmd];
			abort();
		} @catch (id e) {
			[self release];
			@throw e;

		}
	}

	return [super init];
}

- initWithUTF8String: (const char*)UTF8String
{
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
			      length: strlen(cString)];
}

- initWithCString: (const char*)cString
	 encoding: (of_string_encoding_t)encoding
	   length: (size_t)cStringLength
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithString: (OFString*)string
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithUnicodeString: (const of_unichar_t*)string
{
	return [self initWithUnicodeString: string
				 byteOrder: OF_BYTE_ORDER_NATIVE
				    length: of_unicode_string_length(string)];







>
|
>
>
|
|
<
>




>
|
>
>
|
|
<
>







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
			      length: strlen(cString)];
}

- initWithCString: (const char*)cString
	 encoding: (of_string_encoding_t)encoding
	   length: (size_t)cStringLength
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithString: (OFString*)string
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithUnicodeString: (const of_unichar_t*)string
{
	return [self initWithUnicodeString: string
				 byteOrder: OF_BYTE_ORDER_NATIVE
				    length: of_unicode_string_length(string)];
588
589
590
591
592
593
594

595


596
597
598

599
600
601
602
603
604
605
				    length: length];
}

- initWithUnicodeString: (const of_unichar_t*)string
	      byteOrder: (of_byte_order_t)byteOrder
		 length: (size_t)length
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithUTF16String: (const uint16_t*)string
{
	return [self initWithUTF16String: string
			       byteOrder: OF_BYTE_ORDER_BIG_ENDIAN
				  length: of_utf16_string_length(string)];







>
|
>
>
|
|
<
>







599
600
601
602
603
604
605
606
607
608
609
610
611

612
613
614
615
616
617
618
619
				    length: length];
}

- initWithUnicodeString: (const of_unichar_t*)string
	      byteOrder: (of_byte_order_t)byteOrder
		 length: (size_t)length
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithUTF16String: (const uint16_t*)string
{
	return [self initWithUTF16String: string
			       byteOrder: OF_BYTE_ORDER_BIG_ENDIAN
				  length: of_utf16_string_length(string)];
621
622
623
624
625
626
627

628


629
630
631

632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649

650


651
652
653

654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671

672


673
674
675

676
677
678
679
680
681
682
				  length: length];
}

- initWithUTF16String: (const uint16_t*)string
	    byteOrder: (of_byte_order_t)byteOrder
	       length: (size_t)length
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithFormat: (OFConstantString*)format, ...
{
	id ret;
	va_list arguments;

	va_start(arguments, format);
	ret = [self initWithFormat: format
			 arguments: arguments];
	va_end(arguments);

	return ret;
}

- initWithFormat: (OFConstantString*)format
       arguments: (va_list)arguments
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithPath: (OFString*)firstComponent, ...
{
	id ret;
	va_list arguments;

	va_start(arguments, firstComponent);
	ret = [self initWithPath: firstComponent
		       arguments: arguments];
	va_end(arguments);

	return ret;
}

- initWithPath: (OFString*)firstComponent
     arguments: (va_list)arguments
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithContentsOfFile: (OFString*)path
{
	return [self initWithContentsOfFile: path
				   encoding: OF_STRING_ENCODING_UTF_8];
}







>
|
>
>
|
|
<
>


















>
|
>
>
|
|
<
>


















>
|
>
>
|
|
<
>







635
636
637
638
639
640
641
642
643
644
645
646
647

648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672

673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697

698
699
700
701
702
703
704
705
				  length: length];
}

- initWithUTF16String: (const uint16_t*)string
	    byteOrder: (of_byte_order_t)byteOrder
	       length: (size_t)length
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithFormat: (OFConstantString*)format, ...
{
	id ret;
	va_list arguments;

	va_start(arguments, format);
	ret = [self initWithFormat: format
			 arguments: arguments];
	va_end(arguments);

	return ret;
}

- initWithFormat: (OFConstantString*)format
       arguments: (va_list)arguments
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithPath: (OFString*)firstComponent, ...
{
	id ret;
	va_list arguments;

	va_start(arguments, firstComponent);
	ret = [self initWithPath: firstComponent
		       arguments: arguments];
	va_end(arguments);

	return ret;
}

- initWithPath: (OFString*)firstComponent
     arguments: (va_list)arguments
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithContentsOfFile: (OFString*)path
{
	return [self initWithContentsOfFile: path
				   encoding: OF_STRING_ENCODING_UTF_8];
}
924
925
926
927
928
929
930
931
932

933
934
935
936
937
938
939
- (const char*)UTF8String
{
	return [self cStringUsingEncoding: OF_STRING_ENCODING_UTF_8];
}

- (size_t)length
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (size_t)lengthOfBytesUsingEncoding: (of_string_encoding_t)encoding
{
	switch (encoding) {
	case OF_STRING_ENCODING_UTF_8:;
		const of_unichar_t *unicodeString;







<
|
>







947
948
949
950
951
952
953

954
955
956
957
958
959
960
961
962
- (const char*)UTF8String
{
	return [self cStringUsingEncoding: OF_STRING_ENCODING_UTF_8];
}

- (size_t)length
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (size_t)lengthOfBytesUsingEncoding: (of_string_encoding_t)encoding
{
	switch (encoding) {
	case OF_STRING_ENCODING_UTF_8:;
		const of_unichar_t *unicodeString;
968
969
970
971
972
973
974
975
976

977
978
979
980
981
982
983
- (size_t)UTF8StringLength
{
	return [self lengthOfBytesUsingEncoding: OF_STRING_ENCODING_UTF_8];
}

- (of_unichar_t)characterAtIndex: (size_t)index
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)getCharacters: (of_unichar_t*)buffer
	      inRange: (of_range_t)range
{
	size_t i;








<
|
>







991
992
993
994
995
996
997

998
999
1000
1001
1002
1003
1004
1005
1006
- (size_t)UTF8StringLength
{
	return [self lengthOfBytesUsingEncoding: OF_STRING_ENCODING_UTF_8];
}

- (of_unichar_t)characterAtIndex: (size_t)index
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)getCharacters: (of_unichar_t*)buffer
	      inRange: (of_range_t)range
{
	size_t i;

Modified src/OFString_UTF8.m from [75ce5faed6] to [dfd9d65700].

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#import "OFMutableString_UTF8.h"
#import "OFArray.h"

#import "OFInitializationFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidEncodingException.h"
#import "OFInvalidFormatException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfMemoryException.h"
#import "OFOutOfRangeException.h"

#import "autorelease.h"
#import "macros.h"
#import "of_asprintf.h"
#import "unicode.h"







<







27
28
29
30
31
32
33

34
35
36
37
38
39
40
#import "OFMutableString_UTF8.h"
#import "OFArray.h"

#import "OFInitializationFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFInvalidEncodingException.h"
#import "OFInvalidFormatException.h"

#import "OFOutOfMemoryException.h"
#import "OFOutOfRangeException.h"

#import "autorelease.h"
#import "macros.h"
#import "of_asprintf.h"
#import "unicode.h"

Modified src/OFThread.m from [bdce062fba] to [ba81cccfd2].

40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

#ifdef _WIN32
# include <windows.h>
#endif

#import "OFInitializationFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfRangeException.h"
#import "OFThreadJoinFailedException.h"
#import "OFThreadStartFailedException.h"
#import "OFThreadStillRunningException.h"

#import "atomic.h"
#import "autorelease.h"







<







40
41
42
43
44
45
46

47
48
49
50
51
52
53

#ifdef _WIN32
# include <windows.h>
#endif

#import "OFInitializationFailedException.h"
#import "OFInvalidArgumentException.h"

#import "OFOutOfRangeException.h"
#import "OFThreadJoinFailedException.h"
#import "OFThreadStartFailedException.h"
#import "OFThreadStillRunningException.h"

#import "atomic.h"
#import "autorelease.h"

Modified src/OFTimer.m from [0447782afb] to [7245211e76].

12
13
14
15
16
17
18


19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#include <assert.h>

#import "OFTimer.h"
#import "OFDate.h"
#import "OFRunLoop.h"
#import "OFCondition.h"

#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"

#import "autorelease.h"
#import "macros.h"

@implementation OFTimer
+ (instancetype)scheduledTimerWithTimeInterval: (double)interval
					target: (id)target







>
>








<







12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

29
30
31
32
33
34
35
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#include <assert.h>

#import "OFTimer.h"
#import "OFDate.h"
#import "OFRunLoop.h"
#import "OFCondition.h"

#import "OFInvalidArgumentException.h"


#import "autorelease.h"
#import "macros.h"

@implementation OFTimer
+ (instancetype)scheduledTimerWithTimeInterval: (double)interval
					target: (id)target
200
201
202
203
204
205
206

207


208
209
210

211
212
213
214
215
216
217

	return [timer autorelease];
}
#endif

- init
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- OF_initWithFireDate: (OFDate*)fireDate_
	     interval: (double)interval_
	       target: (id)target_
	     selector: (SEL)selector_
	       object: (id)object1_







>
|
>
>
|
|
<
>







201
202
203
204
205
206
207
208
209
210
211
212
213

214
215
216
217
218
219
220
221

	return [timer autorelease];
}
#endif

- init
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- OF_initWithFireDate: (OFDate*)fireDate_
	     interval: (double)interval_
	       target: (id)target_
	     selector: (SEL)selector_
	       object: (id)object1_

Modified src/OFXMLElement+Serialization.m from [9ca8fe4ac9] to [0a3d66ab61].

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
54

#import "OFXMLElement.h"
#import "OFXMLElement+Serialization.h"
#import "OFSerialization.h"
#import "OFString.h"

#import "OFInvalidArgumentException.h"
#import "OFNotImplementedException.h"

#import "autorelease.h"
#import "macros.h"

int _OFXMLElement_Serialization_reference;

@implementation OFXMLElement (Serialization)
- (id)objectByDeserializing
{
	void *pool = objc_autoreleasePoolPush();
	Class class;
	id object;

	if ((class = objc_getClass([name cStringUsingEncoding:
	    OF_STRING_ENCODING_ASCII])) == Nil)

		@throw [OFNotImplementedException exceptionWithClass: Nil];

	if (![class conformsToProtocol: @protocol(OFSerialization)])
		@throw [OFNotImplementedException
		    exceptionWithClass: class
			      selector: @selector(initWithSerialization:)];

	object = [[class alloc] initWithSerialization: self];

	objc_autoreleasePoolPop(pool);

	return [object autorelease];
}
@end







<















>
|


|
|
<








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 "OFXMLElement.h"
#import "OFXMLElement+Serialization.h"
#import "OFSerialization.h"
#import "OFString.h"

#import "OFInvalidArgumentException.h"


#import "autorelease.h"
#import "macros.h"

int _OFXMLElement_Serialization_reference;

@implementation OFXMLElement (Serialization)
- (id)objectByDeserializing
{
	void *pool = objc_autoreleasePoolPush();
	Class class;
	id object;

	if ((class = objc_getClass([name cStringUsingEncoding:
	    OF_STRING_ENCODING_ASCII])) == Nil)
		@throw [OFInvalidArgumentException
		    exceptionWithClass: [self class]];

	if (![class conformsToProtocol: @protocol(OFSerialization)])
		@throw [OFInvalidArgumentException
		    exceptionWithClass: [self class]];


	object = [[class alloc] initWithSerialization: self];

	objc_autoreleasePoolPop(pool);

	return [object autorelease];
}
@end

Modified src/OFXMLElement.m from [16ca049b3f] to [5487d3f056].

12
13
14
15
16
17
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
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"


#include <string.h>

#include <assert.h>

#import "OFXMLElement.h"
#import "OFString.h"
#import "OFArray.h"
#import "OFDictionary.h"
#import "OFDataArray.h"
#import "OFXMLAttribute.h"
#import "OFXMLCharacters.h"
#import "OFXMLCDATA.h"
#import "OFXMLParser.h"
#import "OFXMLElementBuilder.h"

#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFMalformedXMLException.h"
#import "OFNotImplementedException.h"
#import "OFUnboundNamespaceException.h"

#import "autorelease.h"
#import "macros.h"

/* References for static linking */
void _references_to_categories_of_OFXMLElement(void)







>

>
















<







12
13
14
15
16
17
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
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>
#include <string.h>

#include <assert.h>

#import "OFXMLElement.h"
#import "OFString.h"
#import "OFArray.h"
#import "OFDictionary.h"
#import "OFDataArray.h"
#import "OFXMLAttribute.h"
#import "OFXMLCharacters.h"
#import "OFXMLCDATA.h"
#import "OFXMLParser.h"
#import "OFXMLElementBuilder.h"

#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFMalformedXMLException.h"

#import "OFUnboundNamespaceException.h"

#import "autorelease.h"
#import "macros.h"

/* References for static linking */
void _references_to_categories_of_OFXMLElement(void)
121
122
123
124
125
126
127

128


129
130
131

132
133
134
135
136
137
138
+ (instancetype)elementWithFile: (OFString*)path
{
	return [[[self alloc] initWithFile: path] autorelease];
}

- init
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithName: (OFString*)name_
{
	return [self initWithName: name_
			namespace: nil
		      stringValue: nil];







>
|
>
>
|
|
<
>







122
123
124
125
126
127
128
129
130
131
132
133
134

135
136
137
138
139
140
141
142
+ (instancetype)elementWithFile: (OFString*)path
{
	return [[[self alloc] initWithFile: path] autorelease];
}

- init
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithName: (OFString*)name_
{
	return [self initWithName: name_
			namespace: nil
		      stringValue: nil];

Modified src/OFXMLNode.m from [cb63feb9eb] to [6055c48f8a].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFXMLNode.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

@implementation OFXMLNode
- initWithSerialization: (OFXMLElement*)element
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- (OFString*)stringValue
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (intmax_t)decimalValue
{
	return [[self stringValue] decimalValue];
}








>
>




<
<



>
|
>
>
|
|
<
>




<
|
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFXMLNode.h"
#import "OFString.h"



@implementation OFXMLNode
- initWithSerialization: (OFXMLElement*)element
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- (OFString*)stringValue
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (intmax_t)decimalValue
{
	return [[self stringValue] decimalValue];
}

67
68
69
70
71
72
73
74
75

76
77
78
79
80
81
82
83
84
85
86

87
88
89
90
91
92
93
	return [self XMLStringWithIndentation: 0
					level: 0];
}

- (OFString*)XMLStringWithIndentation: (unsigned int)indentation
				level: (unsigned int)level
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (OFString*)description
{
	return [self XMLStringWithIndentation: 2];
}

- (OFXMLElement*)XMLElementBySerializing
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- copy
{
	return [self retain];
}
@end







<
|
>









<
|
>







70
71
72
73
74
75
76

77
78
79
80
81
82
83
84
85
86
87

88
89
90
91
92
93
94
95
96
	return [self XMLStringWithIndentation: 0
					level: 0];
}

- (OFString*)XMLStringWithIndentation: (unsigned int)indentation
				level: (unsigned int)level
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (OFString*)description
{
	return [self XMLStringWithIndentation: 2];
}

- (OFXMLElement*)XMLElementBySerializing
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- copy
{
	return [self retain];
}
@end

Modified src/exceptions/OFAcceptFailedException.m from [c457c058f0] to [6c1a76fdbf].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFAcceptFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFAcceptFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFTCPSocket*)socket
{
	return [[[self alloc] initWithClass: class_
				     socket: socket] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	 socket: (OFTCPSocket*)socket_
{
	self = [super initWithClass: class_];








>
>





<
<












>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFAcceptFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"



#import "common.h"

@implementation OFAcceptFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFTCPSocket*)socket
{
	return [[[self alloc] initWithClass: class_
				     socket: socket] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	 socket: (OFTCPSocket*)socket_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFAllocFailedException.m from [f91f71fe9f] to [353b58a3aa].

11
12
13
14
15
16
17


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
54

55
56
57
58
59
60
61
62

63
64
65
66
67
68

69
70
71
72
73
74
75
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFAllocFailedException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

@implementation OFAllocFailedException
+ alloc
{
	@throw [OFNotImplementedException exceptionWithClass: self
						    selector: _cmd];

}

- init
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];





}

- (void*)allocMemoryWithSize: (size_t)size
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void*)allocMemoryForNItems: (size_t)nitems
                     withSize: (size_t)size
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void*)resizeMemory: (void*)ptr
	       toSize: (size_t)size
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void*)resizeMemory: (void*)ptr
	     toNItems: (size_t)nitems
	     withSize: (size_t)size
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- (void)freeMemory: (void*)ptr
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]
						    selector: _cmd];

}

- retain
{
	return self;
}








>
>




<
<



<
|
>




|
|
>
>
>
>
>




<
|
>





<
|
>





<
|
>






<
|
>




<
|
>







11
12
13
14
15
16
17
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
54
55
56
57

58
59
60
61
62
63
64
65

66
67
68
69
70
71

72
73
74
75
76
77
78
79
80
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFAllocFailedException.h"
#import "OFString.h"



@implementation OFAllocFailedException
+ alloc
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- init
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;
	}
}

- (void*)allocMemoryWithSize: (size_t)size
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void*)allocMemoryForNItems: (size_t)nitems
                     withSize: (size_t)size
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void*)resizeMemory: (void*)ptr
	       toSize: (size_t)size
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void*)resizeMemory: (void*)ptr
	     toNItems: (size_t)nitems
	     withSize: (size_t)size
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- (void)freeMemory: (void*)ptr
{

	[self doesNotRecognizeSelector: _cmd];
	abort();
}

- retain
{
	return self;
}

85
86
87
88
89
90
91
92

93
94

95
96
97
98
99
100
101

- (void)release
{
}

- (void)dealloc
{
	@throw [OFNotImplementedException exceptionWithClass: [self class]

						    selector: _cmd];
	[super dealloc];	/* Get rid of a stupid warning */

}

- (OFString*)description
{
	return @"Allocating an object failed!";
}
@end







|
>
|
|
>







90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}

- (OFString*)description
{
	return @"Allocating an object failed!";
}
@end

Modified src/exceptions/OFAlreadyConnectedException.m from [5e1a345877] to [ab4527fab8].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFAlreadyConnectedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFAlreadyConnectedException
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFTCPSocket*)socket
{
	return [[[self alloc] initWithClass: class_
				     socket: socket] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	 socket: (OFTCPSocket*)socket_
{
	self = [super initWithClass: class_];








>
>





<
<












>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFAlreadyConnectedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"



#import "common.h"

@implementation OFAlreadyConnectedException
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFTCPSocket*)socket
{
	return [[[self alloc] initWithClass: class_
				     socket: socket] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	 socket: (OFTCPSocket*)socket_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFBindFailedException.m from [e975d14a09] to [dc36806f5b].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFBindFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFBindFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFTCPSocket*)socket
			      host: (OFString*)host
			      port: (uint16_t)port
{
	return [[[self alloc] initWithClass: class_
				     socket: socket
				       host: host
				       port: port] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	 socket: (OFTCPSocket*)socket_
	   host: (OFString*)host_
	   port: (uint16_t)port_
{







>
>





<
<
















>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
54
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFBindFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"



#import "common.h"

@implementation OFBindFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFTCPSocket*)socket
			      host: (OFString*)host
			      port: (uint16_t)port
{
	return [[[self alloc] initWithClass: class_
				     socket: socket
				       host: host
				       port: port] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	 socket: (OFTCPSocket*)socket_
	   host: (OFString*)host_
	   port: (uint16_t)port_
{

Modified src/exceptions/OFChangeDirectoryFailedException.m from [061077ad6c] to [7743d847c5].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFChangeDirectoryFailedException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFChangeDirectoryFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path_
{
	return [[[self alloc] initWithClass: class_
				       path: path_] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	   path: (OFString*)path_
{
	self = [super initWithClass: class_];








>
>




<
<












>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFChangeDirectoryFailedException.h"
#import "OFString.h"



#import "common.h"

@implementation OFChangeDirectoryFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path_
{
	return [[[self alloc] initWithClass: class_
				       path: path_] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	   path: (OFString*)path_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFChangeFileModeFailedException.m from [84e028f2f5] to [c910398387].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFChangeFileModeFailedException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFChangeFileModeFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path
			      mode: (mode_t)mode
{
	return [[[self alloc] initWithClass: class_
				       path: path
				       mode: mode] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	   path: (OFString*)path_
	   mode: (mode_t)mode_
{
	self = [super initWithClass: class_];







>
>




<
<














>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFChangeFileModeFailedException.h"
#import "OFString.h"



#import "common.h"

@implementation OFChangeFileModeFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path
			      mode: (mode_t)mode
{
	return [[[self alloc] initWithClass: class_
				       path: path
				       mode: mode] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	   path: (OFString*)path_
	   mode: (mode_t)mode_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFChangeFileOwnerFailedException.m from [e07fdc2eff] to [5a1ab8f6f5].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFChangeFileOwnerFailedException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "common.h"

#ifndef _WIN32
@implementation OFChangeFileOwnerFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path
			     owner: (OFString*)owner
			     group: (OFString*)group
{
	return [[[self alloc] initWithClass: class_
				       path: path
				      owner: owner
				      group: group] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	   path: (OFString*)path_
	  owner: (OFString*)owner_
	  group: (OFString*)group_
{







>
>




<
<

















>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
54
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFChangeFileOwnerFailedException.h"
#import "OFString.h"



#import "common.h"

#ifndef _WIN32
@implementation OFChangeFileOwnerFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path
			     owner: (OFString*)owner
			     group: (OFString*)group
{
	return [[[self alloc] initWithClass: class_
				       path: path
				      owner: owner
				      group: group] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	   path: (OFString*)path_
	  owner: (OFString*)owner_
	  group: (OFString*)group_
{

Modified src/exceptions/OFConditionBroadcastFailedException.m from [3559216b34] to [8cedc9960a].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFConditionBroadcastFailedException.h"
#import "OFString.h"
#import "OFCondition.h"

#import "OFNotImplementedException.h"

@implementation OFConditionBroadcastFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			 condition: (OFCondition*)condition
{
	return [[[self alloc] initWithClass: class_
				  condition: condition] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
      condition: (OFCondition*)condition_
{
	self = [super initWithClass: class_];








>
>





<
<










>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFConditionBroadcastFailedException.h"
#import "OFString.h"
#import "OFCondition.h"



@implementation OFConditionBroadcastFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			 condition: (OFCondition*)condition
{
	return [[[self alloc] initWithClass: class_
				  condition: condition] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
      condition: (OFCondition*)condition_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFConditionSignalFailedException.m from [d23e0ba837] to [496e150dc1].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFConditionSignalFailedException.h"
#import "OFString.h"
#import "OFCondition.h"

#import "OFNotImplementedException.h"

@implementation OFConditionSignalFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			 condition: (OFCondition*)condition
{
	return [[[self alloc] initWithClass: class_
				  condition: condition] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
      condition: (OFCondition*)condition_
{
	self = [super initWithClass: class_];








>
>





<
<










>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFConditionSignalFailedException.h"
#import "OFString.h"
#import "OFCondition.h"



@implementation OFConditionSignalFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			 condition: (OFCondition*)condition
{
	return [[[self alloc] initWithClass: class_
				  condition: condition] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
      condition: (OFCondition*)condition_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFConditionStillWaitingException.m from [bdcb857f81] to [69975815b7].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFConditionStillWaitingException.h"
#import "OFString.h"
#import "OFCondition.h"

#import "OFNotImplementedException.h"

@implementation OFConditionStillWaitingException
+ (instancetype)exceptionWithClass: (Class)class_
			 condition: (OFCondition*)condition
{
	return [[[self alloc] initWithClass: class_
				  condition: condition] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
      condition: (OFCondition*)condition_
{
	self = [super initWithClass: class_];








>
>





<
<










>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFConditionStillWaitingException.h"
#import "OFString.h"
#import "OFCondition.h"



@implementation OFConditionStillWaitingException
+ (instancetype)exceptionWithClass: (Class)class_
			 condition: (OFCondition*)condition
{
	return [[[self alloc] initWithClass: class_
				  condition: condition] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
      condition: (OFCondition*)condition_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFConditionWaitFailedException.m from [f57be4081a] to [46242fbae6].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFConditionWaitFailedException.h"
#import "OFString.h"
#import "OFCondition.h"

#import "OFNotImplementedException.h"

@implementation OFConditionWaitFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			 condition: (OFCondition*)condition
{
	return [[[self alloc] initWithClass: class_
				  condition: condition] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
      condition: (OFCondition*)condition_
{
	self = [super initWithClass: class_];








>
>





<
<










>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFConditionWaitFailedException.h"
#import "OFString.h"
#import "OFCondition.h"



@implementation OFConditionWaitFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			 condition: (OFCondition*)condition
{
	return [[[self alloc] initWithClass: class_
				  condition: condition] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
      condition: (OFCondition*)condition_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFConnectionFailedException.m from [c39e733948] to [489e5ee9c3].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFConnectionFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFConnectionFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFTCPSocket*)socket
			      host: (OFString*)host
			      port: (uint16_t)port
{
	return [[[self alloc] initWithClass: class_
				     socket: socket
				       host: host
				       port: port] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	 socket: (OFTCPSocket*)socket_
	   host: (OFString*)host_
	   port: (uint16_t)port_
{







>
>





<
<
















>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
54
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFConnectionFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"



#import "common.h"

@implementation OFConnectionFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFTCPSocket*)socket
			      host: (OFString*)host
			      port: (uint16_t)port
{
	return [[[self alloc] initWithClass: class_
				     socket: socket
				       host: host
				       port: port] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	 socket: (OFTCPSocket*)socket_
	   host: (OFString*)host_
	   port: (uint16_t)port_
{

Modified src/exceptions/OFCopyFileFailedException.m from [0092226d0a] to [2df64adc88].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFCopyFileFailedException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFCopyFileFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			sourcePath: (OFString*)source
		   destinationPath: (OFString*)destination
{
	return [[[self alloc] initWithClass: class_
				 sourcePath: source
			    destinationPath: destination] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

-   initWithClass: (Class)class_
       sourcePath: (OFString*)source
  destinationPath: (OFString*)destination
{
	self = [super initWithClass: class_];







>
>




<
<














>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFCopyFileFailedException.h"
#import "OFString.h"



#import "common.h"

@implementation OFCopyFileFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			sourcePath: (OFString*)source
		   destinationPath: (OFString*)destination
{
	return [[[self alloc] initWithClass: class_
				 sourcePath: source
			    destinationPath: destination] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

-   initWithClass: (Class)class_
       sourcePath: (OFString*)source
  destinationPath: (OFString*)destination
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFCreateDirectoryFailedException.m from [49460e3e5d] to [5178d57406].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFCreateDirectoryFailedException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFCreateDirectoryFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path_
{
	return [[[self alloc] initWithClass: class_
				       path: path_] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	   path: (OFString*)path_
{
	self = [super initWithClass: class_];








>
>




<
<












>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFCreateDirectoryFailedException.h"
#import "OFString.h"



#import "common.h"

@implementation OFCreateDirectoryFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path_
{
	return [[[self alloc] initWithClass: class_
				       path: path_] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	   path: (OFString*)path_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFDeleteDirectoryFailedException.m from [d0a7435971] to [ca94e78ea5].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFDeleteDirectoryFailedException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFDeleteDirectoryFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path_
{
	return [[[self alloc] initWithClass: class_
				       path: path_] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	   path: (OFString*)path_
{
	self = [super initWithClass: class_];








>
>




<
<












>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFDeleteDirectoryFailedException.h"
#import "OFString.h"



#import "common.h"

@implementation OFDeleteDirectoryFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path_
{
	return [[[self alloc] initWithClass: class_
				       path: path_] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	   path: (OFString*)path_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFDeleteFileFailedException.m from [b0c2776292] to [f17b08ef53].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFDeleteFileFailedException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFDeleteFileFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path_
{
	return [[[self alloc] initWithClass: class_
				       path: path_] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	   path: (OFString*)path_
{
	self = [super initWithClass: class_];








>
>




<
<












>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFDeleteFileFailedException.h"
#import "OFString.h"



#import "common.h"

@implementation OFDeleteFileFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path_
{
	return [[[self alloc] initWithClass: class_
				       path: path_] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	   path: (OFString*)path_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFEnumerationMutationException.m from [15571f572b] to [a29a4c4c7c].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFEnumerationMutationException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFEnumerationMutationException
+ (instancetype)exceptionWithClass: (Class)class_
			    object: (id)object
{
	return [[[self alloc] initWithClass: class_
				     object: object] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	 object: (id)object_
{
	self = [super initWithClass: class_];








>
>




<
<












>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFEnumerationMutationException.h"
#import "OFString.h"



#import "common.h"

@implementation OFEnumerationMutationException
+ (instancetype)exceptionWithClass: (Class)class_
			    object: (id)object
{
	return [[[self alloc] initWithClass: class_
				     object: object] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	 object: (id)object_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFException.m from [2112dc5f17] to [e32d14537c].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

@implementation OFException
+ (instancetype)exceptionWithClass: (Class)class_
{
	return [[[self alloc] initWithClass: class_] autorelease];
}

- init
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
{
	self = [super init];

	inClass = class_;







>
>




<
<








>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFException.h"
#import "OFString.h"



@implementation OFException
+ (instancetype)exceptionWithClass: (Class)class_
{
	return [[[self alloc] initWithClass: class_] autorelease];
}

- init
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
{
	self = [super init];

	inClass = class_;

Modified src/exceptions/OFHTTPRequestFailedException.m from [f3f841e094] to [89529e8143].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFHTTPRequestFailedException.h"
#import "OFString.h"
#import "OFHTTPRequest.h"

#import "OFNotImplementedException.h"

#import "autorelease.h"
#import "common.h"

@implementation OFHTTPRequestFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			   request: (OFHTTPRequest*)request
			    result: (OFHTTPRequestResult*)result
{
	return [[[self alloc] initWithClass: class_
				    request: request
				     result: result] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	request: (OFHTTPRequest*)request_
	 result: (OFHTTPRequestResult*)result_
{
	self = [super initWithClass: class_];







>
>





<
<















>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFHTTPRequestFailedException.h"
#import "OFString.h"
#import "OFHTTPRequest.h"



#import "autorelease.h"
#import "common.h"

@implementation OFHTTPRequestFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			   request: (OFHTTPRequest*)request
			    result: (OFHTTPRequestResult*)result
{
	return [[[self alloc] initWithClass: class_
				    request: request
				     result: result] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	request: (OFHTTPRequest*)request_
	 result: (OFHTTPRequestResult*)result_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFHashAlreadyCalculatedException.m from [483aecd301] to [1162c03304].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFHashAlreadyCalculatedException.h"
#import "OFString.h"
#import "OFHash.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFHashAlreadyCalculatedException
+ (instancetype)exceptionWithClass: (Class)class_
			      hash: (OFHash*)hash
{
	return [[[self alloc] initWithClass: class_
				       hash: hash] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	   hash: (OFHash*)hash
{
	self = [super initWithClass: class_];








>
>





<
<












>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFHashAlreadyCalculatedException.h"
#import "OFString.h"
#import "OFHash.h"



#import "common.h"

@implementation OFHashAlreadyCalculatedException
+ (instancetype)exceptionWithClass: (Class)class_
			      hash: (OFHash*)hash
{
	return [[[self alloc] initWithClass: class_
				       hash: hash] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	   hash: (OFHash*)hash
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFInvalidArgumentException.m from [18afe7f030] to [d573c7d088].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFInvalidArgumentException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFInvalidArgumentException
+ (instancetype)exceptionWithClass: (Class)class_
			  selector: (SEL)selector_
{
	return [[[self alloc] initWithClass: class_
				   selector: selector_] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
       selector: (SEL)selector_
{
	self = [super initWithClass: class_];








>
>




<
<












>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFInvalidArgumentException.h"
#import "OFString.h"



#import "common.h"

@implementation OFInvalidArgumentException
+ (instancetype)exceptionWithClass: (Class)class_
			  selector: (SEL)selector_
{
	return [[[self alloc] initWithClass: class_
				   selector: selector_] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
       selector: (SEL)selector_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFInvalidJSONException.m from [b02bc86218] to [7ebc35808d].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFInvalidJSONException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

@implementation OFInvalidJSONException
+ (instancetype)exceptionWithClass: (Class)class_
			      line: (size_t)line
{
	return [[[self alloc] initWithClass: class_
				       line: line] autorelease];
}

- init
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	   line: (size_t)line_
{
	self = [super initWithClass: class_];








>
>




<
<










>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFInvalidJSONException.h"
#import "OFString.h"



@implementation OFInvalidJSONException
+ (instancetype)exceptionWithClass: (Class)class_
			      line: (size_t)line
{
	return [[[self alloc] initWithClass: class_
				       line: line] autorelease];
}

- init
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	   line: (size_t)line_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFLinkFailedException.m from [9f6ed4a020] to [56b55d35a2].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFLinkFailedException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "common.h"

#ifndef _WIN32
@implementation OFLinkFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			sourcePath: (OFString*)source
		   destinationPath: (OFString*)destination
{
	return [[[self alloc] initWithClass: class_
				 sourcePath: source
			    destinationPath: destination] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

-   initWithClass: (Class)class_
       sourcePath: (OFString*)source
  destinationPath: (OFString*)destination
{
	self = [super initWithClass: class_];







>
>




<
<















>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFLinkFailedException.h"
#import "OFString.h"



#import "common.h"

#ifndef _WIN32
@implementation OFLinkFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			sourcePath: (OFString*)source
		   destinationPath: (OFString*)destination
{
	return [[[self alloc] initWithClass: class_
				 sourcePath: source
			    destinationPath: destination] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

-   initWithClass: (Class)class_
       sourcePath: (OFString*)source
  destinationPath: (OFString*)destination
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFListenFailedException.m from [038815ba73] to [acfa6cf611].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFListenFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFListenFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFTCPSocket*)socket
			   backLog: (int)backlog
{
	return [[[self alloc] initWithClass: class_
				     socket: socket
				    backLog: backlog] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	 socket: (OFTCPSocket*)socket_
	backLog: (int)backlog
{
	self = [super initWithClass: class_];







>
>





<
<














>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFListenFailedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"



#import "common.h"

@implementation OFListenFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFTCPSocket*)socket
			   backLog: (int)backlog
{
	return [[[self alloc] initWithClass: class_
				     socket: socket
				    backLog: backlog] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	 socket: (OFTCPSocket*)socket_
	backLog: (int)backlog
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFLockFailedException.m from [573e15c5b2] to [216c033d30].

15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 */

#include "config.h"

#import "OFLockFailedException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "macros.h"

@implementation OFLockFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      lock: (id <OFLocking>)lock
{
	return [[[self alloc] initWithClass: class_







<
<







15
16
17
18
19
20
21


22
23
24
25
26
27
28
 */

#include "config.h"

#import "OFLockFailedException.h"
#import "OFString.h"



#import "macros.h"

@implementation OFLockFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      lock: (id <OFLocking>)lock
{
	return [[[self alloc] initWithClass: class_

Modified src/exceptions/OFMalformedXMLException.m from [b3e0941446] to [006a4e8017].

16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#include "config.h"

#import "OFMalformedXMLException.h"
#import "OFString.h"
#import "OFXMLParser.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFMalformedXMLException
+ (instancetype)exceptionWithClass: (Class)class_
			    parser: (OFXMLParser*)parser
{
	return [[[self alloc] initWithClass: class_







<
<







16
17
18
19
20
21
22


23
24
25
26
27
28
29

#include "config.h"

#import "OFMalformedXMLException.h"
#import "OFString.h"
#import "OFXMLParser.h"



#import "common.h"

@implementation OFMalformedXMLException
+ (instancetype)exceptionWithClass: (Class)class_
			    parser: (OFXMLParser*)parser
{
	return [[[self alloc] initWithClass: class_

Modified src/exceptions/OFMemoryNotPartOfObjectException.m from [cbc504825f] to [2f129f6a0a].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFMemoryNotPartOfObjectException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

@implementation OFMemoryNotPartOfObjectException
+ (instancetype)exceptionWithClass: (Class)class_
			   pointer: (void*)ptr
{
	return [[[self alloc] initWithClass: class_
				    pointer: ptr] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	pointer: (void*)ptr
{
	self = [super initWithClass: class_];








>
>




<
<










>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFMemoryNotPartOfObjectException.h"
#import "OFString.h"



@implementation OFMemoryNotPartOfObjectException
+ (instancetype)exceptionWithClass: (Class)class_
			   pointer: (void*)ptr
{
	return [[[self alloc] initWithClass: class_
				    pointer: ptr] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	pointer: (void*)ptr
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFNotConnectedException.m from [24094739a0] to [0d876782a7].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFNotConnectedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFNotConnectedException
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFStreamSocket*)socket
{
	return [[[self alloc] initWithClass: class_
				     socket: socket] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	 socket: (OFStreamSocket*)socket_
{
	self = [super initWithClass: class_];








>
>





<
<












>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFNotConnectedException.h"
#import "OFString.h"
#import "OFTCPSocket.h"



#import "common.h"

@implementation OFNotConnectedException
+ (instancetype)exceptionWithClass: (Class)class_
			    socket: (OFStreamSocket*)socket
{
	return [[[self alloc] initWithClass: class_
				     socket: socket] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	 socket: (OFStreamSocket*)socket_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFNotImplementedException.m from [5283a9e0e5] to [31161653fa].

11
12
13
14
15
16
17


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
54
55
56
57
58
59
60
61
62
63
64
65
66
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFNotImplementedException.h"
#import "OFString.h"

#import "common.h"

@implementation OFNotImplementedException
+ (instancetype)exceptionWithClass: (Class)class_
			  selector: (SEL)selector
{
	return [[[self alloc] initWithClass: class_
				   selector: selector] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
       selector: (SEL)selector_
{
	self = [super initWithClass: class_];

	selector = selector_;

	return self;
}

- (OFString*)description
{
	if (description != nil)
		return description;

	description = [[OFString alloc] initWithFormat:
	    @"The method %s of class %@ is not or not fully implemented!",
	    sel_getName(selector), inClass];

	return description;
}

- (SEL)selector
{
	return selector;
}
@end







>
>
















>
|
>
>
|
|
<
>


















|
|









11
12
13
14
15
16
17
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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFNotImplementedException.h"
#import "OFString.h"

#import "common.h"

@implementation OFNotImplementedException
+ (instancetype)exceptionWithClass: (Class)class_
			  selector: (SEL)selector
{
	return [[[self alloc] initWithClass: class_
				   selector: selector] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
       selector: (SEL)selector_
{
	self = [super initWithClass: class_];

	selector = selector_;

	return self;
}

- (OFString*)description
{
	if (description != nil)
		return description;

	description = [[OFString alloc] initWithFormat:
	    @"The selector %s is not understood by class %@ or not (fully) "
	    @"implemented!", sel_getName(selector), inClass];

	return description;
}

- (SEL)selector
{
	return selector;
}
@end

Modified src/exceptions/OFOpenFileFailedException.m from [a32dab7ab4] to [94930c081e].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFOpenFileFailedException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFOpenFileFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path
			      mode: (OFString*)mode
{
	return [[[self alloc] initWithClass: class_
				       path: path
				       mode: mode] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	   path: (OFString*)path_
	   mode: (OFString*)mode_
{
	self = [super initWithClass: class_];







>
>




<
<














>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFOpenFileFailedException.h"
#import "OFString.h"



#import "common.h"

@implementation OFOpenFileFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      path: (OFString*)path
			      mode: (OFString*)mode
{
	return [[[self alloc] initWithClass: class_
				       path: path
				       mode: mode] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	   path: (OFString*)path_
	   mode: (OFString*)mode_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFReadOrWriteFailedException.m from [af417a70ea] to [e1a4cb7250].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFReadOrWriteFailedException.h"
#import "OFString.h"
#import "OFStreamSocket.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFReadOrWriteFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    stream: (OFStream*)stream
		   requestedLength: (size_t)length
{
	return [[[self alloc] initWithClass: class_
				     stream: stream
			    requestedLength: length] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

-   initWithClass: (Class)class_
	   stream: (OFStream*)stream_
  requestedLength: (size_t)length
{
	self = [super initWithClass: class_];







>
>





<
<














>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFReadOrWriteFailedException.h"
#import "OFString.h"
#import "OFStreamSocket.h"



#import "common.h"

@implementation OFReadOrWriteFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    stream: (OFStream*)stream
		   requestedLength: (size_t)length
{
	return [[[self alloc] initWithClass: class_
				     stream: stream
			    requestedLength: length] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

-   initWithClass: (Class)class_
	   stream: (OFStream*)stream_
  requestedLength: (size_t)length
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFRenameFileFailedException.m from [2f687e8aec] to [bd163b2b08].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFRenameFileFailedException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFRenameFileFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			sourcePath: (OFString*)source
		   destinationPath: (OFString*)destination
{
	return [[[self alloc] initWithClass: class_
				 sourcePath: source
			    destinationPath: destination] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

-   initWithClass: (Class)class_
       sourcePath: (OFString*)source
  destinationPath: (OFString*)destination
{
	self = [super initWithClass: class_];







>
>




<
<














>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFRenameFileFailedException.h"
#import "OFString.h"



#import "common.h"

@implementation OFRenameFileFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			sourcePath: (OFString*)source
		   destinationPath: (OFString*)destination
{
	return [[[self alloc] initWithClass: class_
				 sourcePath: source
			    destinationPath: destination] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

-   initWithClass: (Class)class_
       sourcePath: (OFString*)source
  destinationPath: (OFString*)destination
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFSeekFailedException.m from [d1cecd4b8a] to [f5ed617a11].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFSeekFailedException.h"
#import "OFString.h"
#import "OFSeekableStream.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFSeekFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    stream: (OFSeekableStream*)stream
			    offset: (off_t)offset
			    whence: (int)whence
{
	return [[[self alloc] initWithClass: class_
				     stream: stream
				     offset: offset
				     whence: whence] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	 stream: (OFSeekableStream*)stream_
	 offset: (off_t)offset_
	 whence: (int)whence_
{







>
>





<
<
















>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
54
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFSeekFailedException.h"
#import "OFString.h"
#import "OFSeekableStream.h"



#import "common.h"

@implementation OFSeekFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    stream: (OFSeekableStream*)stream
			    offset: (off_t)offset
			    whence: (int)whence
{
	return [[[self alloc] initWithClass: class_
				     stream: stream
				     offset: offset
				     whence: whence] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	 stream: (OFSeekableStream*)stream_
	 offset: (off_t)offset_
	 whence: (int)whence_
{

Modified src/exceptions/OFSetOptionFailedException.m from [df261401f3] to [58cd1e1798].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFSetOptionFailedException.h"
#import "OFString.h"
#import "OFStream.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFSetOptionFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    stream: (OFStream*)stream
{
	return [[[self alloc] initWithClass: class_
				     stream: stream] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	 stream: (OFStream*)stream_
{
	self = [super initWithClass: class_];








>
>





<
<












>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFSetOptionFailedException.h"
#import "OFString.h"
#import "OFStream.h"



#import "common.h"

@implementation OFSetOptionFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    stream: (OFStream*)stream
{
	return [[[self alloc] initWithClass: class_
				     stream: stream] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	 stream: (OFStream*)stream_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFStillLockedException.m from [89bf01b698] to [36d00b82d6].

15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 */

#include "config.h"

#import "OFStillLockedException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "macros.h"

@implementation OFStillLockedException
+ (instancetype)exceptionWithClass: (Class)class_
			      lock: (id <OFLocking>)lock
{
	return [[[self alloc] initWithClass: class_







<
<







15
16
17
18
19
20
21


22
23
24
25
26
27
28
 */

#include "config.h"

#import "OFStillLockedException.h"
#import "OFString.h"



#import "macros.h"

@implementation OFStillLockedException
+ (instancetype)exceptionWithClass: (Class)class_
			      lock: (id <OFLocking>)lock
{
	return [[[self alloc] initWithClass: class_

Modified src/exceptions/OFSymlinkFailedException.m from [9c1b009edc] to [b64d2c9b32].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFSymlinkFailedException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "common.h"

#ifndef _WIN32
@implementation OFSymlinkFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			sourcePath: (OFString*)source
		   destinationPath: (OFString*)destination
{
	return [[[self alloc] initWithClass: class_
				 sourcePath: source
			    destinationPath: destination] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

-   initWithClass: (Class)class_
       sourcePath: (OFString*)source
  destinationPath: (OFString*)destination
{
	self = [super initWithClass: class_];







>
>




<
<















>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFSymlinkFailedException.h"
#import "OFString.h"



#import "common.h"

#ifndef _WIN32
@implementation OFSymlinkFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			sourcePath: (OFString*)source
		   destinationPath: (OFString*)destination
{
	return [[[self alloc] initWithClass: class_
				 sourcePath: source
			    destinationPath: destination] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

-   initWithClass: (Class)class_
       sourcePath: (OFString*)source
  destinationPath: (OFString*)destination
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFThreadJoinFailedException.m from [dcbbd27d07] to [fc1aa36d36].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFThreadJoinFailedException.h"
#import "OFString.h"
#import "OFThread.h"

#import "OFNotImplementedException.h"

@implementation OFThreadJoinFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    thread: (OFThread*)thread
{
	return [[[self alloc] initWithClass: class_
				     thread: thread] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	 thread: (OFThread*)thread_
{
	self = [super initWithClass: class_];








>
>





<
<










>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFThreadJoinFailedException.h"
#import "OFString.h"
#import "OFThread.h"



@implementation OFThreadJoinFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    thread: (OFThread*)thread
{
	return [[[self alloc] initWithClass: class_
				     thread: thread] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	 thread: (OFThread*)thread_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFThreadStartFailedException.m from [b64a1ff539] to [354bccc4cc].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFThreadStartFailedException.h"
#import "OFString.h"
#import "OFThread.h"

#import "OFNotImplementedException.h"

@implementation OFThreadStartFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    thread: (OFThread*)thread
{
	return [[[self alloc] initWithClass: class_
				     thread: thread] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	 thread: (OFThread*)thread_
{
	self = [super initWithClass: class_];








>
>





<
<










>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFThreadStartFailedException.h"
#import "OFString.h"
#import "OFThread.h"



@implementation OFThreadStartFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			    thread: (OFThread*)thread
{
	return [[[self alloc] initWithClass: class_
				     thread: thread] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	 thread: (OFThread*)thread_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFThreadStillRunningException.m from [f3a233791c] to [c62f2a8214].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFThreadStillRunningException.h"
#import "OFString.h"
#import "OFThread.h"

#import "OFNotImplementedException.h"

@implementation OFThreadStillRunningException
+ (instancetype)exceptionWithClass: (Class)class_
			    thread: (OFThread*)thread
{
	return [[[self alloc] initWithClass: class_
				     thread: thread] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	 thread: (OFThread*)thread_
{
	self = [super initWithClass: class_];








>
>





<
<










>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFThreadStillRunningException.h"
#import "OFString.h"
#import "OFThread.h"



@implementation OFThreadStillRunningException
+ (instancetype)exceptionWithClass: (Class)class_
			    thread: (OFThread*)thread
{
	return [[[self alloc] initWithClass: class_
				     thread: thread] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	 thread: (OFThread*)thread_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFUnboundNamespaceException.m from [611f4c170e] to [d1c53e726d].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFUnboundNamespaceException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFUnboundNamespaceException
+ (instancetype)exceptionWithClass: (Class)class_
			 namespace: (OFString*)ns
{
	return [[[self alloc] initWithClass: class_
				  namespace: ns] autorelease];
}

+ (instancetype)exceptionWithClass: (Class)class_
			    prefix: (OFString*)prefix
{
	return [[[self alloc] initWithClass: class_
				     prefix: prefix] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
      namespace: (OFString*)ns_
{
	self = [super initWithClass: class_];








>
>




<
<



















>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
54
55
56
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFUnboundNamespaceException.h"
#import "OFString.h"



#import "common.h"

@implementation OFUnboundNamespaceException
+ (instancetype)exceptionWithClass: (Class)class_
			 namespace: (OFString*)ns
{
	return [[[self alloc] initWithClass: class_
				  namespace: ns] autorelease];
}

+ (instancetype)exceptionWithClass: (Class)class_
			    prefix: (OFString*)prefix
{
	return [[[self alloc] initWithClass: class_
				     prefix: prefix] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
      namespace: (OFString*)ns_
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFUnlockFailedException.m from [ef011d99a3] to [287873875d].

15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 */

#include "config.h"

#import "OFUnlockFailedException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "macros.h"

@implementation OFUnlockFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      lock: (id <OFLocking>)lock
{
	return [[[self alloc] initWithClass: class_







<
<







15
16
17
18
19
20
21


22
23
24
25
26
27
28
 */

#include "config.h"

#import "OFUnlockFailedException.h"
#import "OFString.h"



#import "macros.h"

@implementation OFUnlockFailedException
+ (instancetype)exceptionWithClass: (Class)class_
			      lock: (id <OFLocking>)lock
{
	return [[[self alloc] initWithClass: class_

Modified src/exceptions/OFUnsupportedProtocolException.m from [be041cf8f8] to [f034f4fd41].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFUnsupportedProtocolException.h"
#import "OFString.h"
#import "OFURL.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFUnsupportedProtocolException
+ (instancetype)exceptionWithClass: (Class)class_
			       URL: (OFURL*)url
{
	return [[[self alloc] initWithClass: class_
					URL: url] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	    URL: (OFURL*)url
{
	self = [super initWithClass: class_];








>
>





<
<












>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFUnsupportedProtocolException.h"
#import "OFString.h"
#import "OFURL.h"



#import "common.h"

@implementation OFUnsupportedProtocolException
+ (instancetype)exceptionWithClass: (Class)class_
			       URL: (OFURL*)url
{
	return [[[self alloc] initWithClass: class_
					URL: url] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	    URL: (OFURL*)url
{
	self = [super initWithClass: class_];

Modified src/exceptions/OFUnsupportedVersionException.m from [b93e7d43cd] to [406a681988].

11
12
13
14
15
16
17


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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"



#import "OFUnsupportedVersionException.h"
#import "OFString.h"

#import "OFNotImplementedException.h"

#import "common.h"

@implementation OFUnsupportedVersionException
+ (instancetype)exceptionWithClass: (Class)class_
			   version: (OFString*)version
{
	return [[[self alloc] initWithClass: class_
				    version: version] autorelease];
}

- initWithClass: (Class)class_
{

	Class c = [self class];


	[self release];
	@throw [OFNotImplementedException exceptionWithClass: c
						    selector: _cmd];

}

- initWithClass: (Class)class_
	version: (OFString*)version_
{
	self = [super initWithClass: class_];








>
>




<
<












>
|
>
>
|
|
<
>







11
12
13
14
15
16
17
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
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFUnsupportedVersionException.h"
#import "OFString.h"



#import "common.h"

@implementation OFUnsupportedVersionException
+ (instancetype)exceptionWithClass: (Class)class_
			   version: (OFString*)version
{
	return [[[self alloc] initWithClass: class_
				    version: version] autorelease];
}

- initWithClass: (Class)class_
{
	@try {
		[self doesNotRecognizeSelector: _cmd];
		abort();
	} @catch (id e) {
		[self release];
		@throw e;

	}
}

- initWithClass: (Class)class_
	version: (OFString*)version_
{
	self = [super initWithClass: class_];