ObjFW  Check-in [c53d661daf]

Overview
Comment:Rename a methods in OFXMLParserDelegate and add -[parser:foundCDATA].
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA3-256: c53d661daf597aeeaf38298c1141134df758eb53fba212b1e7ed200202449b96
User & Date: js on 2010-06-16 19:54:57
Other Links: manifest | tags
Context
2010-06-16
19:58
Add runtime column to PLATFORMS. check-in: c85802faf2 user: js tags: trunk
19:54
Rename a methods in OFXMLParserDelegate and add -[parser:foundCDATA]. check-in: c53d661daf user: js tags: trunk
19:38
Update PLATFORMS. check-in: 39f395427b user: js tags: trunk
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Modified src/OFString+XMLUnescaping.h from [b597a59e83] to [ddb946d7cf].

︙
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

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








+
-
+

















-
-
+
+


 * unescape XML. The callback is supposed to return a substitution for the
 * entity or nil if it is unknown to the callback as well, in which case an
 * exception will be thrown.
 *
 * \param entity The name of the entity that is unknown
 * \return A substitution for the entity or nil
 */
-	   (OFString*)string: (OFString*)str
- (OFString*)didFindUnknownEntityNamed: (OFString*)entity;
  containsUnknownEntityNamed: (OFString*)entity;
@end

/**
 * \brief A category for unescaping XML in strings.
 */
@interface OFString (XMLUnescaping)
/**
 * Unescapes XML in the string.
 */
- (OFString*)stringByXMLUnescaping;

/**
 * Unescapes XML in the string and uses the specified handler for unknown
 * entities.
 *
 * \param h An OFXMLUnescapingDelegate as a handler for unknown entities
 */
- (OFString*)stringByXMLUnescapingWithHandler:
    (OFObject <OFStringXMLUnescapingDelegate>*)h;
- (OFString*)stringByXMLUnescapingWithDelegate:
    (OFObject <OFStringXMLUnescapingDelegate>*)delegate;
@end

Modified src/OFString+XMLUnescaping.m from [8b7255c2dd] to [79011c0f14].

︙
67
68
69
70
71
72
73
74

75
76
77
78


79
80
81
82
83
84
85

67
68
69
70
71
72
73

74
75
76


77
78
79
80
81
82
83
84
85








-
+


-
-
+
+








	return [OFString stringWithCString: buf
				    length: i];
}

@implementation OFString (XMLUnescaping)
- (OFString*)stringByXMLUnescaping
{
	return [self stringByXMLUnescapingWithHandler: nil];
	return [self stringByXMLUnescapingWithDelegate: nil];
}

- (OFString*)stringByXMLUnescapingWithHandler:
    (OFObject <OFStringXMLUnescapingDelegate>*)h
- (OFString*)stringByXMLUnescapingWithDelegate:
    (OFObject <OFStringXMLUnescapingDelegate>*)delegate
{
	size_t i, last;
	BOOL in_entity;
	OFMutableString *ret;

	last = 0;
	in_entity = NO;
︙
128
129
130
131
132
133
134
135

136
137
138
139
140
141
142

143

144
145
146
147
148
149
150

128
129
130
131
132
133
134

135
136
137
138
139
140
141
142
143

144
145
146
147
148
149
150
151








-
+







+
-
+









				if (tmp == nil)
					@throw [OFInvalidEncodingException
					    newWithClass: isa];

				[ret appendString: tmp];
				[pool release];
			} else if (h != nil) {
			} else if (delegate != nil) {
				OFAutoreleasePool *pool;
				OFString *n, *tmp;

				pool = [[OFAutoreleasePool alloc] init];

				n = [OFString stringWithCString: entity
							 length: len];
				tmp =	  [delegate string: self
				tmp = [h didFindUnknownEntityNamed: n];
				containsUnknownEntityNamed: n];

				if (tmp == nil)
					@throw [OFInvalidEncodingException
					    newWithClass: isa];

				[ret appendString: tmp];
				[pool release];
︙

Modified src/OFXMLParser.h from [5b79a3d936] to [fda97e43af].

︙
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
81
82
83
84


85
86
87
88
89
90
91

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
81
82
83
84
85
86
87
88
89
90
91


92
93
94
95
96
97
98
99
100








-
-
-
-
-
+
+
+
+
+









-
-
-
-
+
+
+
+


-
+







-
-
+
+
+
+
+
+
+
+
+
+
+







-
-
+
+











-
-
+
+








 *
 * \param parser The parser which found a new tag
 * \param name The name of the tag which just started
 * \param prefix The prefix of the tag which just started or nil
 * \param ns The namespace of the tag which just started or nil
 * \param attrs The attributes included in the tag which just started or nil
 */
-     (void)xmlParser: (OFXMLParser*)parser
  didStartTagWithName: (OFString*)name
	       prefix: (OFString*)prefix
	    namespace: (OFString*)ns
	   attributes: (OFArray*)attrs;
-    (void)parser: (OFXMLParser*)parser
  didStartElement: (OFString*)name
       withPrefix: (OFString*)prefix
	namespace: (OFString*)ns
       attributes: (OFArray*)attrs;

/**
 * This callback is called when the XML parser found the end of a tag.
 *
 * \param parser The parser which found the end of a tag
 * \param name The name of the tag which just ended
 * \param prefix The prefix of the tag which just ended or nil
 * \param ns The namespace of the tag which just ended or nil
 */
-   (void)xmlParser: (OFXMLParser*)parser
  didEndTagWithName: (OFString*)name
	     prefix: (OFString*)prefix
	  namespace: (OFString*)ns;
-  (void)parser: (OFXMLParser*)parser
  didEndElement: (OFString*)name
     withPrefix: (OFString*)prefix
      namespace: (OFString*)ns;

/**
 * This callback is called when the XML parser found a string.
 * This callback is called when the XML parser found characters.
 *
 * In case there are comments or CDATA, it is possible that this callback is
 * called multiple times in a row.
 *
 * \param parser The parser which found a string
 * \param string The string the XML parser found
 */
- (void)xmlParser: (OFXMLParser*)parser
    didFindString: (OFString*)string;
-    (void)parser: (OFXMLParser*)parser
  foundCharacters: (OFString*)string;

/**
 * This callback is called when the XML parser found CDATA.
 *
 * \param parser The parser which found a string
 * \param string The string the XML parser found
 */
- (void)parser: (OFXMLParser*)parser
    foundCDATA: (OFString*)cdata;

/**
 * This callback is called when the XML parser found a comment.
 *
 * \param parser The parser which found a comment
 * \param comment The comment the XML parser found
 */
- (void)xmlParser: (OFXMLParser*)parser
   didFindComment: (OFString*)comment;
- (void)parser: (OFXMLParser*)parser
  foundComment: (OFString*)comment;

/**
 * This callback is called when the XML parser found an entity it doesn't know.
 * The callback is supposed to return a substitution for the entity or nil if
 * it is not known to the callback as well, in which case an exception will be
 * risen.
 *
 * \param parser The parser which found an unknown entity
 * \param entity The name of the entity the XML parser didn't know
 * \return A substitution for the entity or nil
 */
-      (OFString*)xmlParser: (OFXMLParser*)parser
  didFindUnknownEntityNamed: (OFString*)entity;
-	(OFString*)parser: (OFXMLParser*)parser
  foundUnknownEntityNamed: (OFString*)entity;
@end

/**
 * \brief An event-based XML parser.
 *
 * OFXMLParser is an event-based XML parser which calls the delegate's callbacks
 * as soon asit finds something, thus suitable for streams as well.
︙

Modified src/OFXMLParser.m from [86523e53cd] to [b05b5824cd].

︙
21
22
23
24
25
26
27
28

29
30
31
32
33
34

35
36
37
38
39
40
41

21
22
23
24
25
26
27

28
29
30
31
32
33

34
35
36
37
38
39
40
41








-
+





-
+








#import "OFXMLAttribute.h"
#import "OFAutoreleasePool.h"
#import "OFExceptions.h"
#import "macros.h"

static OF_INLINE OFString*
transform_string(OFMutableString *cache,
    OFObject <OFStringXMLUnescapingDelegate> *handler)
    OFObject <OFStringXMLUnescapingDelegate> *delegate)
{
	[cache replaceOccurrencesOfString: @"\r\n"
			       withString: @"\n"];
	[cache replaceOccurrencesOfString: @"\r"
			       withString: @"\n"];
	return [cache stringByXMLUnescapingWithHandler: handler];
	return [cache stringByXMLUnescapingWithDelegate: delegate];
}

static OF_INLINE OFString*
namespace_for_prefix(OFString *prefix, OFArray *namespaces)
{
	OFDictionary **carray = [namespaces cArray];
	ssize_t i;
︙
134
135
136
137
138
139
140
141
142


143
144
145
146
147
148
149

134
135
136
137
138
139
140


141
142
143
144
145
146
147
148
149








-
-
+
+








					    length: len];

				if ([cache cStringLength] > 0) {
					OFString *str;

					pool = [[OFAutoreleasePool alloc] init];
					str = transform_string(cache, self);
					[delegate xmlParser: self
					      didFindString: str];
					[delegate parser: self
					 foundCharacters: str];
					[pool release];
				}

				[cache setToCString: ""];

				last = i + 1;
				state = OF_XMLPARSER_TAG_OPENED;
︙
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

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








-
-
-
-
-
+
+
+
+
+


-
-
-
-
+
+
+
+









					if (prefix != nil && ns == nil)
						@throw
						    [OFUnboundNamespaceException
						    newWithClass: isa
							  prefix: prefix];

					[delegate xmlParser: self
					didStartTagWithName: name
						     prefix: prefix
						  namespace: ns
						 attributes: nil];
					[delegate parser: self
					 didStartElement: name
					      withPrefix: prefix
					       namespace: ns
					      attributes: nil];

					if (buf[i] == '/')
						[delegate xmlParser: self
						  didEndTagWithName: name
							     prefix: prefix
							  namespace: ns];
						[delegate parser: self
						   didEndElement: name
						      withPrefix: prefix
						       namespace: ns];
					else
						[previous addObject:
						    [[cache copy] autorelease]];

					[pool release];

					[name release];
︙
287
288
289
290
291
292
293
294
295
296
297




298
299
300
301
302
303
304

287
288
289
290
291
292
293




294
295
296
297
298
299
300
301
302
303
304








-
-
-
-
+
+
+
+








				ns = namespace_for_prefix(prefix, namespaces);
				if (prefix != nil && ns == nil)
					@throw [OFUnboundNamespaceException
					    newWithClass: isa
						  prefix: prefix];
				[namespaces removeNObjects: 1];

				[delegate xmlParser: self
				  didEndTagWithName: name
					     prefix: prefix
					  namespace: ns];
				[delegate parser: self
				   didEndElement: name
				      withPrefix: prefix
				       namespace: ns];

				[pool release];

				[name release];
				[prefix release];
				name = prefix = nil;
︙
318
319
320
321
322
323
324
325
326
327
328
329





330
331
332
333
334
335




336
337
338
339
340
341
342

318
319
320
321
322
323
324





325
326
327
328
329
330
331




332
333
334
335
336
337
338
339
340
341
342








-
-
-
-
-
+
+
+
+
+


-
-
-
-
+
+
+
+








				ns = namespace_for_prefix(prefix, namespaces);

				if (prefix != nil && ns == nil)
					@throw [OFUnboundNamespaceException
					    newWithClass: isa
						  prefix: prefix];

				[delegate xmlParser: self
				didStartTagWithName: name
					     prefix: prefix
					  namespace: ns
					 attributes: attrs];
				[delegate parser: self
				 didStartElement: name
				      withPrefix: prefix
				       namespace: ns
				      attributes: attrs];

				if (buf[i] == '/') {
					[delegate xmlParser: self
					  didEndTagWithName: name
						     prefix: prefix
						  namespace: ns];
					[delegate parser: self
					   didEndElement: name
					      withPrefix: prefix
					       namespace: ns];
					[namespaces removeNObjects: 1];
				} else if (prefix != nil) {
					OFString *str = [OFString
					    stringWithFormat: @"%s:%s",
							      [prefix cString],
							      [name cString]];
					[previous addObject: str];
︙
564
565
566
567
568
569
570
571
572


573
574
575
576
577
578
579

564
565
566
567
568
569
570


571
572
573
574
575
576
577
578
579








-
-
+
+








				    appendCStringWithoutUTF8Checking: buf + last
							      length: i - last];
				cdata = [[cache mutableCopy] autorelease];
				len = [cdata length];

				[cdata removeCharactersFromIndex: len - 2
							 toIndex: len];
				[delegate xmlParser: self
				      didFindString: cdata];
				[delegate parser: self
				      foundCDATA: cdata];
				[pool release];

				[cache setToCString: ""];

				last = i + 1;
				state = OF_XMLPARSER_OUTSIDE_TAG;
			} else if (buf[i] != ']')
︙
607
608
609
610
611
612
613
614
615


616
617
618
619
620
621
622

607
608
609
610
611
612
613


614
615
616
617
618
619
620
621
622








-
-
+
+








				    appendCStringWithoutUTF8Checking: buf + last
							      length: i - last];
				comment = [[cache mutableCopy] autorelease];
				len = [comment length];

				[comment removeCharactersFromIndex: len - 2
							   toIndex: len];
				[delegate xmlParser: self
				     didFindComment: comment];
				[delegate parser: self
				    foundComment: comment];
				[pool release];

				[cache setToCString: ""];

				last = i + 1;
				state = OF_XMLPARSER_OUTSIDE_TAG;
			} else
︙
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

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








+
-
+

-
-
+
+




-
-
-
-
-
+
+
+
+
+



-
-
-
-
+
+
+
+



-
-
+
+



-
-
+
+
+
+
+
+
+



-
-
+
+





	len = size - last;
	/* In OF_XMLPARSER_IN_TAG, there can be only spaces */
	if (len > 0 && state != OF_XMLPARSER_IN_TAG)
		[cache appendCStringWithoutUTF8Checking: buf + last
						 length: len];
}

-	   (OFString*)string: (OFString*)string
- (OFString*)didFindUnknownEntityNamed: (OFString*)entity
  containsUnknownEntityNamed: (OFString*)entity
{
	return [delegate xmlParser: self
	 didFindUnknownEntityNamed: entity];
	return [delegate parser: self
	foundUnknownEntityNamed: entity];
}
@end

@implementation OFObject (OFXMLParserDelegate)
-     (void)xmlParser: (OFXMLParser*)parser
  didStartTagWithName: (OFString*)name
	       prefix: (OFString*)prefix
	    namespace: (OFString*)ns
	   attributes: (OFArray*)attrs
-    (void)parser: (OFXMLParser*)parser
  didStartElement: (OFString*)name
       withPrefix: (OFString*)prefix
	namespace: (OFString*)ns
       attributes: (OFArray*)attrs
{
}

-   (void)xmlParser: (OFXMLParser*)parser
  didEndTagWithName: (OFString*)name
	     prefix: (OFString*)prefix
	  namespace: (OFString*)ns
-  (void)parser: (OFXMLParser*)parser
  didEndElement: (OFString*)name
     withPrefix: (OFString*)prefix
      namespace: (OFString*)ns
{
}

- (void)xmlParser: (OFXMLParser*)parser
    didFindString: (OFString*)string
-    (void)parser: (OFXMLParser*)parser
  foundCharacters: (OFString*)string
{
}

- (void)xmlParser: (OFXMLParser*)parser
   didFindComment: (OFString*)comment
- (void)parser: (OFXMLParser*)parser
    foundCDATA: (OFString*)cdata
{
}

- (void)parser: (OFXMLParser*)parser
  foundComment: (OFString*)comment
{
}

-      (OFString*)xmlParser: (OFXMLParser*)parser
  didFindUnknownEntityNamed: (OFString*)entity
-	(OFString*)parser: (OFXMLParser*)parser
  foundUnknownEntityNamed: (OFString*)entity
{
	return nil;
}
@end

Modified tests/OFStringTests.m from [db370d10b8] to [d62d62cd6e].

︙
24
25
26
27
28
29
30

31

32
33
34
35
36
37
38

24
25
26
27
28
29
30
31

32
33
34
35
36
37
38
39








+
-
+








	@" \t\t  \t\t  \t \t"
};

@interface EntityHandler: OFObject <OFStringXMLUnescapingDelegate>
@end

@implementation EntityHandler
-	   (OFString*)string: (OFString*)string
- (OFString*)didFindUnknownEntityNamed: (OFString*)entity
  containsUnknownEntityNamed: (OFString*)entity
{
	if ([entity isEqual: @"foo"])
		return @"bar";

	return nil;
}
@end
︙
353
354
355
356
357
358
359
360

361
362
363
364
365

354
355
356
357
358
359
360

361
362
363
364
365
366








-
+






	EXPECT_EXCEPTION(@"Detect invalid entities in -[stringByXMLUnescaping] "
	    @"#5", OFInvalidEncodingException, [@"&#g;" stringByXMLUnescaping])
	EXPECT_EXCEPTION(@"Detect invalid entities in -[stringByXMLUnescaping] "
	    @"#6", OFInvalidEncodingException, [@"&#xg;" stringByXMLUnescaping])

	TEST(@"-[stringByXMLUnescapingWithHandler:]",
	    (h = [[[EntityHandler alloc] init] autorelease]) &&
	    [[@"x&foo;y" stringByXMLUnescapingWithHandler: h]
	    [[@"x&foo;y" stringByXMLUnescapingWithDelegate: h]
	    isEqual: @"xbary"])

	[pool drain];
}
@end

Modified tests/OFXMLParserTests.m from [ff036615fe] to [5780bef1f6].

︙
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

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








+




-
-
-
-
-
-
-
+
+
+
+
+
+
+















-
+








static OFString *module = @"OFXMLParser";
static int i = 0;

enum event_type {
	TAG_START,
	TAG_END,
	STRING,
	CDATA,
	COMMENT
};

@implementation TestsAppDelegate (OFXMLParser)
- (void)xmlParserCallbackWithEventType: (enum event_type)et
				  name: (OFString*)name
				prefix: (OFString*)prefix
			     namespace: (OFString*)ns
			    attributes: (OFArray*)attrs
				string: (OFString*)string
			       comment: (OFString*)comment
- (void)parserCallbackWithEventType: (enum event_type)et
			       name: (OFString*)name
			     prefix: (OFString*)prefix
			  namespace: (OFString*)ns
			 attributes: (OFArray*)attrs
			     string: (OFString*)string
			    comment: (OFString*)comment
{
	OFString *msg;

	i++;
	msg = [OFString stringWithFormat: @"Parsing part #%d", i];

	switch (i) {
	case 1:
		TEST(msg, et == TAG_START && [name isEqual: @"root"] &&
		    prefix == nil && ns == nil && [attrs count] == 0)
		break;
	case 2:
		TEST(msg, et == STRING && [string isEqual: @"\n "])
		break;
	case 3:
		TEST(msg, et == STRING && [string isEqual: @"f<oo"])
		TEST(msg, et == CDATA && [string isEqual: @"f<oo"])
		break;
	case 4:
		TEST(msg, et == TAG_START && [name isEqual: @"bar"] &&
		    prefix == nil && ns == nil && attrs == nil)
		break;
	case 5:
		TEST(msg, et == TAG_END && [name isEqual: @"bar"] &&
︙
223
224
225
226
227
228
229
230
231
232
233
234





235
236
237
238
239
240
241
242







243
244
245
246
247
248




249
250
251
252
253
254
255
256







257
258
259
260


261
262
263
264
265
266
267
268







269
270
271
272














273
274
275
276
277
278
279
280







281
282
283
284


285
286
287
288
289
290
291

224
225
226
227
228
229
230





231
232
233
234
235
236







237
238
239
240
241
242
243
244
245




246
247
248
249
250







251
252
253
254
255
256
257
258
259


260
261
262







263
264
265
266
267
268
269
270
271


272
273
274
275
276
277
278
279
280
281
282
283
284
285
286







287
288
289
290
291
292
293
294
295


296
297
298
299
300
301
302
303
304








-
-
-
-
-
+
+
+
+
+

-
-
-
-
-
-
-
+
+
+
+
+
+
+


-
-
-
-
+
+
+
+

-
-
-
-
-
-
-
+
+
+
+
+
+
+


-
-
+
+

-
-
-
-
-
-
-
+
+
+
+
+
+
+


-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+

-
-
-
-
-
-
-
+
+
+
+
+
+
+


-
-
+
+








	case 30:
		TEST(msg, et == TAG_END && [name isEqual: @"root"] &&
		    prefix == nil && ns == nil);
		break;
	}
}

-     (void)xmlParser: (OFXMLParser*)parser
  didStartTagWithName: (OFString*)name
	       prefix: (OFString*)prefix
	    namespace: (OFString*)ns
	   attributes: (OFArray*)attrs
-    (void)parser: (OFXMLParser*)parser
  didStartElement: (OFString*)name
       withPrefix: (OFString*)prefix
	namespace: (OFString*)ns
       attributes: (OFArray*)attrs
{
	[self xmlParserCallbackWithEventType: TAG_START
					name: name
				      prefix: prefix
				   namespace: ns
				  attributes: attrs
				      string: nil
				     comment: nil];
	[self parserCallbackWithEventType: TAG_START
				     name: name
				   prefix: prefix
				namespace: ns
			       attributes: attrs
				   string: nil
				  comment: nil];
}

-   (void)xmlParser: (OFXMLParser*)parser
  didEndTagWithName: (OFString*)name
	     prefix: (OFString*)prefix
	  namespace: (OFString*)ns
-  (void)parser: (OFXMLParser*)parser
  didEndElement: (OFString*)name
     withPrefix: (OFString*)prefix
      namespace: (OFString*)ns
{
	[self xmlParserCallbackWithEventType: TAG_END
					name: name
				      prefix: prefix
				   namespace: ns
				  attributes: nil
				      string: nil
				     comment: nil];
	[self parserCallbackWithEventType: TAG_END
				     name: name
				   prefix: prefix
				namespace: ns
			       attributes: nil
				   string: nil
				  comment: nil];
}

- (void)xmlParser: (OFXMLParser*)parser
    didFindString: (OFString*)string
-    (void)parser: (OFXMLParser*)parser
  foundCharacters: (OFString*)string
{
	[self xmlParserCallbackWithEventType: STRING
					name: nil
				      prefix: nil
				   namespace: nil
				  attributes: nil
				      string: string
				     comment: nil];
	[self parserCallbackWithEventType: STRING
				     name: nil
				   prefix: nil
				namespace: nil
			       attributes: nil
				   string: string
				  comment: nil];
}

- (void)xmlParser: (OFXMLParser*)parser
   didFindComment: (OFString*)comment
- (void)parser: (OFXMLParser*)parser
    foundCDATA: (OFString*)cdata
{
	[self parserCallbackWithEventType: CDATA
				     name: nil
				   prefix: nil
				namespace: nil
			       attributes: nil
				   string: cdata
				  comment: nil];
}

- (void)parser: (OFXMLParser*)parser
  foundComment: (OFString*)comment
{
	[self xmlParserCallbackWithEventType: COMMENT
					name: nil
				      prefix: nil
				   namespace: nil
				  attributes: nil
				      string: nil
				     comment: comment];
	[self parserCallbackWithEventType: COMMENT
				     name: nil
				   prefix: nil
				namespace: nil
			       attributes: nil
				   string: nil
				  comment: comment];
}

-      (OFString*)xmlParser: (OFXMLParser*)parser
  didFindUnknownEntityNamed: (OFString*)entity
-	(OFString*)parser: (OFXMLParser*)parser
  foundUnknownEntityNamed: (OFString*)entity
{
	if ([entity isEqual: @"foo"])
		return @"foobar";

	return nil;
}
︙

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