entities.c@ 9161

Last change on this file since 9161 was 6076, checked in by vboxsync, 17 years ago
Merged dmik/s2 branch (r25959:26751) to the trunk.
Property svn:eol-style set to `native` Property svn:keywords set to `Date Revision Author Id`
File size: 25.0 KB

Line
1	/*
2	* entities.c : implementation for the XML entities handling
3	*
4	* See Copyright for the status of this software.
5	*
6	* [email protected]
7	*/
8
9	#define IN_LIBXML
10	#include "libxml.h"
11
12	#include <string.h>
13	#ifdef HAVE_STDLIB_H
14	#include <stdlib.h>
15	#endif
16	#include <libxml/xmlmemory.h>
17	#include <libxml/hash.h>
18	#include <libxml/entities.h>
19	#include <libxml/parser.h>
20	#include <libxml/parserInternals.h>
21	#include <libxml/xmlerror.h>
22	#include <libxml/globals.h>
23	#include <libxml/dict.h>
24
25	/*
26	* The XML predefined entities.
27	*/
28
29	static xmlEntity xmlEntityLt = {
30	NULL, XML_ENTITY_DECL, BAD_CAST "lt",
31	NULL, NULL, NULL, NULL, NULL, NULL,
32	BAD_CAST "<", BAD_CAST "<", 1,
33	XML_INTERNAL_PREDEFINED_ENTITY,
34	NULL, NULL, NULL, NULL, 0, 1
35	};
36	static xmlEntity xmlEntityGt = {
37	NULL, XML_ENTITY_DECL, BAD_CAST "gt",
38	NULL, NULL, NULL, NULL, NULL, NULL,
39	BAD_CAST ">", BAD_CAST ">", 1,
40	XML_INTERNAL_PREDEFINED_ENTITY,
41	NULL, NULL, NULL, NULL, 0, 1
42	};
43	static xmlEntity xmlEntityAmp = {
44	NULL, XML_ENTITY_DECL, BAD_CAST "amp",
45	NULL, NULL, NULL, NULL, NULL, NULL,
46	BAD_CAST "&", BAD_CAST "&", 1,
47	XML_INTERNAL_PREDEFINED_ENTITY,
48	NULL, NULL, NULL, NULL, 0, 1
49	};
50	static xmlEntity xmlEntityQuot = {
51	NULL, XML_ENTITY_DECL, BAD_CAST "quot",
52	NULL, NULL, NULL, NULL, NULL, NULL,
53	BAD_CAST "\"", BAD_CAST "\"", 1,
54	XML_INTERNAL_PREDEFINED_ENTITY,
55	NULL, NULL, NULL, NULL, 0, 1
56	};
57	static xmlEntity xmlEntityApos = {
58	NULL, XML_ENTITY_DECL, BAD_CAST "apos",
59	NULL, NULL, NULL, NULL, NULL, NULL,
60	BAD_CAST "'", BAD_CAST "'", 1,
61	XML_INTERNAL_PREDEFINED_ENTITY,
62	NULL, NULL, NULL, NULL, 0, 1
63	};
64
65	/**
66	* xmlEntitiesErrMemory:
67	* @extra: extra informations
68	*
69	* Handle an out of memory condition
70	*/
71	static void
72	xmlEntitiesErrMemory(const char *extra)
73	{
74	__xmlSimpleError(XML_FROM_TREE, XML_ERR_NO_MEMORY, NULL, NULL, extra);
75	}
76
77	/**
78	* xmlEntitiesErr:
79	* @code: the error code
80	* @msg: the message
81	*
82	* Handle an out of memory condition
83	*/
84	static void
85	xmlEntitiesErr(xmlParserErrors code, const char *msg)
86	{
87	__xmlSimpleError(XML_FROM_TREE, code, NULL, msg, NULL);
88	}
89
90	/*
91	* xmlFreeEntity : clean-up an entity record.
92	*/
93	static void
94	xmlFreeEntity(xmlEntityPtr entity)
95	{
96	xmlDictPtr dict = NULL;
97
98	if (entity == NULL)
99	return;
100
101	if (entity->doc != NULL)
102	dict = entity->doc->dict;
103
104
105	if ((entity->children) && (entity->owner == 1) &&
106	(entity == (xmlEntityPtr) entity->children->parent))
107	xmlFreeNodeList(entity->children);
108	if (dict != NULL) {
109	if ((entity->name != NULL) && (!xmlDictOwns(dict, entity->name)))
110	xmlFree((char *) entity->name);
111	if ((entity->ExternalID != NULL) &&
112	(!xmlDictOwns(dict, entity->ExternalID)))
113	xmlFree((char *) entity->ExternalID);
114	if ((entity->SystemID != NULL) &&
115	(!xmlDictOwns(dict, entity->SystemID)))
116	xmlFree((char *) entity->SystemID);
117	if ((entity->URI != NULL) && (!xmlDictOwns(dict, entity->URI)))
118	xmlFree((char *) entity->URI);
119	if ((entity->content != NULL)
120	&& (!xmlDictOwns(dict, entity->content)))
121	xmlFree((char *) entity->content);
122	if ((entity->orig != NULL) && (!xmlDictOwns(dict, entity->orig)))
123	xmlFree((char *) entity->orig);
124	} else {
125	if (entity->name != NULL)
126	xmlFree((char *) entity->name);
127	if (entity->ExternalID != NULL)
128	xmlFree((char *) entity->ExternalID);
129	if (entity->SystemID != NULL)
130	xmlFree((char *) entity->SystemID);
131	if (entity->URI != NULL)
132	xmlFree((char *) entity->URI);
133	if (entity->content != NULL)
134	xmlFree((char *) entity->content);
135	if (entity->orig != NULL)
136	xmlFree((char *) entity->orig);
137	}
138	xmlFree(entity);
139	}
140
141	/*
142	* xmlAddEntity : register a new entity for an entities table.
143	*/
144	static xmlEntityPtr
145	xmlAddEntity(xmlDtdPtr dtd, const xmlChar *name, int type,
146	const xmlChar ExternalID, const xmlChar SystemID,
147	const xmlChar *content) {
148	xmlDictPtr dict = NULL;
149	xmlEntitiesTablePtr table = NULL;
150	xmlEntityPtr ret;
151
152	if (name == NULL)
153	return(NULL);
154	if (dtd == NULL)
155	return(NULL);
156	if (dtd->doc != NULL)
157	dict = dtd->doc->dict;
158
159	switch (type) {
160	case XML_INTERNAL_GENERAL_ENTITY:
161	case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
162	case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
163	if (dtd->entities == NULL)
164	dtd->entities = xmlHashCreateDict(0, dict);
165	table = dtd->entities;
166	break;
167	case XML_INTERNAL_PARAMETER_ENTITY:
168	case XML_EXTERNAL_PARAMETER_ENTITY:
169	if (dtd->pentities == NULL)
170	dtd->pentities = xmlHashCreateDict(0, dict);
171	table = dtd->pentities;
172	break;
173	case XML_INTERNAL_PREDEFINED_ENTITY:
174	return(NULL);
175	}
176	if (table == NULL)
177	return(NULL);
178	ret = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
179	if (ret == NULL) {
180	xmlEntitiesErrMemory("xmlAddEntity:: malloc failed");
181	return(NULL);
182	}
183	memset(ret, 0, sizeof(xmlEntity));
184	ret->type = XML_ENTITY_DECL;
185	ret->checked = 0;
186
187	/*
188	* fill the structure.
189	*/
190	ret->etype = (xmlEntityType) type;
191	if (dict == NULL) {
192	ret->name = xmlStrdup(name);
193	if (ExternalID != NULL)
194	ret->ExternalID = xmlStrdup(ExternalID);
195	if (SystemID != NULL)
196	ret->SystemID = xmlStrdup(SystemID);
197	} else {
198	ret->name = xmlDictLookup(dict, name, -1);
199	if (ExternalID != NULL)
200	ret->ExternalID = xmlDictLookup(dict, ExternalID, -1);
201	if (SystemID != NULL)
202	ret->SystemID = xmlDictLookup(dict, SystemID, -1);
203	}
204	if (content != NULL) {
205	ret->length = xmlStrlen(content);
206	if ((dict != NULL) && (ret->length < 5))
207	ret->content = (xmlChar *)
208	xmlDictLookup(dict, content, ret->length);
209	else
210	ret->content = xmlStrndup(content, ret->length);
211	} else {
212	ret->length = 0;
213	ret->content = NULL;
214	}
215	ret->URI = NULL; /* to be computed by the layer knowing
216	the defining entity */
217	ret->orig = NULL;
218	ret->owner = 0;
219	ret->doc = dtd->doc;
220
221	if (xmlHashAddEntry(table, name, ret)) {
222	/*
223	* entity was already defined at another level.
224	*/
225	xmlFreeEntity(ret);
226	return(NULL);
227	}
228	return(ret);
229	}
230
231	/**
232	* xmlGetPredefinedEntity:
233	* @name: the entity name
234	*
235	* Check whether this name is an predefined entity.
236	*
237	* Returns NULL if not, otherwise the entity
238	*/
239	xmlEntityPtr
240	xmlGetPredefinedEntity(const xmlChar *name) {
241	if (name == NULL) return(NULL);
242	switch (name[0]) {
243	case 'l':
244	if (xmlStrEqual(name, BAD_CAST "lt"))
245	return(&xmlEntityLt);
246	break;
247	case 'g':
248	if (xmlStrEqual(name, BAD_CAST "gt"))
249	return(&xmlEntityGt);
250	break;
251	case 'a':
252	if (xmlStrEqual(name, BAD_CAST "amp"))
253	return(&xmlEntityAmp);
254	if (xmlStrEqual(name, BAD_CAST "apos"))
255	return(&xmlEntityApos);
256	break;
257	case 'q':
258	if (xmlStrEqual(name, BAD_CAST "quot"))
259	return(&xmlEntityQuot);
260	break;
261	default:
262	break;
263	}
264	return(NULL);
265	}
266
267	/**
268	* xmlAddDtdEntity:
269	* @doc: the document
270	* @name: the entity name
271	* @type: the entity type XML_xxx_yyy_ENTITY
272	* @ExternalID: the entity external ID if available
273	* @SystemID: the entity system ID if available
274	* @content: the entity content
275	*
276	* Register a new entity for this document DTD external subset.
277	*
278	* Returns a pointer to the entity or NULL in case of error
279	*/
280	xmlEntityPtr
281	xmlAddDtdEntity(xmlDocPtr doc, const xmlChar *name, int type,
282	const xmlChar ExternalID, const xmlChar SystemID,
283	const xmlChar *content) {
284	xmlEntityPtr ret;
285	xmlDtdPtr dtd;
286
287	if (doc == NULL) {
288	xmlEntitiesErr(XML_DTD_NO_DOC,
289	"xmlAddDtdEntity: document is NULL");
290	return(NULL);
291	}
292	if (doc->extSubset == NULL) {
293	xmlEntitiesErr(XML_DTD_NO_DTD,
294	"xmlAddDtdEntity: document without external subset");
295	return(NULL);
296	}
297	dtd = doc->extSubset;
298	ret = xmlAddEntity(dtd, name, type, ExternalID, SystemID, content);
299	if (ret == NULL) return(NULL);
300
301	/*
302	* Link it to the DTD
303	*/
304	ret->parent = dtd;
305	ret->doc = dtd->doc;
306	if (dtd->last == NULL) {
307	dtd->children = dtd->last = (xmlNodePtr) ret;
308	} else {
309	dtd->last->next = (xmlNodePtr) ret;
310	ret->prev = dtd->last;
311	dtd->last = (xmlNodePtr) ret;
312	}
313	return(ret);
314	}
315
316	/**
317	* xmlAddDocEntity:
318	* @doc: the document
319	* @name: the entity name
320	* @type: the entity type XML_xxx_yyy_ENTITY
321	* @ExternalID: the entity external ID if available
322	* @SystemID: the entity system ID if available
323	* @content: the entity content
324	*
325	* Register a new entity for this document.
326	*
327	* Returns a pointer to the entity or NULL in case of error
328	*/
329	xmlEntityPtr
330	xmlAddDocEntity(xmlDocPtr doc, const xmlChar *name, int type,
331	const xmlChar ExternalID, const xmlChar SystemID,
332	const xmlChar *content) {
333	xmlEntityPtr ret;
334	xmlDtdPtr dtd;
335
336	if (doc == NULL) {
337	xmlEntitiesErr(XML_DTD_NO_DOC,
338	"xmlAddDocEntity: document is NULL");
339	return(NULL);
340	}
341	if (doc->intSubset == NULL) {
342	xmlEntitiesErr(XML_DTD_NO_DTD,
343	"xmlAddDocEntity: document without internal subset");
344	return(NULL);
345	}
346	dtd = doc->intSubset;
347	ret = xmlAddEntity(dtd, name, type, ExternalID, SystemID, content);
348	if (ret == NULL) return(NULL);
349
350	/*
351	* Link it to the DTD
352	*/
353	ret->parent = dtd;
354	ret->doc = dtd->doc;
355	if (dtd->last == NULL) {
356	dtd->children = dtd->last = (xmlNodePtr) ret;
357	} else {
358	dtd->last->next = (xmlNodePtr) ret;
359	ret->prev = dtd->last;
360	dtd->last = (xmlNodePtr) ret;
361	}
362	return(ret);
363	}
364
365	/**
366	* xmlGetEntityFromTable:
367	* @table: an entity table
368	* @name: the entity name
369	* @parameter: look for parameter entities
370	*
371	* Do an entity lookup in the table.
372	* returns the corresponding parameter entity, if found.
373	*
374	* Returns A pointer to the entity structure or NULL if not found.
375	*/
376	static xmlEntityPtr
377	xmlGetEntityFromTable(xmlEntitiesTablePtr table, const xmlChar *name) {
378	return((xmlEntityPtr) xmlHashLookup(table, name));
379	}
380
381	/**
382	* xmlGetParameterEntity:
383	* @doc: the document referencing the entity
384	* @name: the entity name
385	*
386	* Do an entity lookup in the internal and external subsets and
387	* returns the corresponding parameter entity, if found.
388	*
389	* Returns A pointer to the entity structure or NULL if not found.
390	*/
391	xmlEntityPtr
392	xmlGetParameterEntity(xmlDocPtr doc, const xmlChar *name) {
393	xmlEntitiesTablePtr table;
394	xmlEntityPtr ret;
395
396	if (doc == NULL)
397	return(NULL);
398	if ((doc->intSubset != NULL) && (doc->intSubset->pentities != NULL)) {
399	table = (xmlEntitiesTablePtr) doc->intSubset->pentities;
400	ret = xmlGetEntityFromTable(table, name);
401	if (ret != NULL)
402	return(ret);
403	}
404	if ((doc->extSubset != NULL) && (doc->extSubset->pentities != NULL)) {
405	table = (xmlEntitiesTablePtr) doc->extSubset->pentities;
406	return(xmlGetEntityFromTable(table, name));
407	}
408	return(NULL);
409	}
410
411	/**
412	* xmlGetDtdEntity:
413	* @doc: the document referencing the entity
414	* @name: the entity name
415	*
416	* Do an entity lookup in the DTD entity hash table and
417	* returns the corresponding entity, if found.
418	* Note: the first argument is the document node, not the DTD node.
419	*
420	* Returns A pointer to the entity structure or NULL if not found.
421	*/
422	xmlEntityPtr
423	xmlGetDtdEntity(xmlDocPtr doc, const xmlChar *name) {
424	xmlEntitiesTablePtr table;
425
426	if (doc == NULL)
427	return(NULL);
428	if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
429	table = (xmlEntitiesTablePtr) doc->extSubset->entities;
430	return(xmlGetEntityFromTable(table, name));
431	}
432	return(NULL);
433	}
434
435	/**
436	* xmlGetDocEntity:
437	* @doc: the document referencing the entity
438	* @name: the entity name
439	*
440	* Do an entity lookup in the document entity hash table and
441	* returns the corresponding entity, otherwise a lookup is done
442	* in the predefined entities too.
443	*
444	* Returns A pointer to the entity structure or NULL if not found.
445	*/
446	xmlEntityPtr
447	xmlGetDocEntity(xmlDocPtr doc, const xmlChar *name) {
448	xmlEntityPtr cur;
449	xmlEntitiesTablePtr table;
450
451	if (doc != NULL) {
452	if ((doc->intSubset != NULL) && (doc->intSubset->entities != NULL)) {
453	table = (xmlEntitiesTablePtr) doc->intSubset->entities;
454	cur = xmlGetEntityFromTable(table, name);
455	if (cur != NULL)
456	return(cur);
457	}
458	if (doc->standalone != 1) {
459	if ((doc->extSubset != NULL) &&
460	(doc->extSubset->entities != NULL)) {
461	table = (xmlEntitiesTablePtr) doc->extSubset->entities;
462	cur = xmlGetEntityFromTable(table, name);
463	if (cur != NULL)
464	return(cur);
465	}
466	}
467	}
468	return(xmlGetPredefinedEntity(name));
469	}
470
471	/*
472	* Macro used to grow the current buffer.
473	*/
474	#define growBufferReentrant() { \
475	buffer_size *= 2; \
476	buffer = (xmlChar *) \
477	xmlRealloc(buffer, buffer_size * sizeof(xmlChar)); \
478	if (buffer == NULL) { \
479	xmlEntitiesErrMemory("xmlEncodeEntitiesReentrant: realloc failed");\
480	return(NULL); \
481	} \
482	}
483
484
485	/**
486	* xmlEncodeEntitiesReentrant:
487	* @doc: the document containing the string
488	* @input: A string to convert to XML.
489	*
490	* Do a global encoding of a string, replacing the predefined entities
491	* and non ASCII values with their entities and CharRef counterparts.
492	* Contrary to xmlEncodeEntities, this routine is reentrant, and result
493	* must be deallocated.
494	*
495	* Returns A newly allocated string with the substitution done.
496	*/
497	xmlChar *
498	xmlEncodeEntitiesReentrant(xmlDocPtr doc, const xmlChar *input) {
499	const xmlChar *cur = input;
500	xmlChar *buffer = NULL;
501	xmlChar *out = NULL;
502	int buffer_size = 0;
503	int html = 0;
504
505	if (input == NULL) return(NULL);
506	if (doc != NULL)
507	html = (doc->type == XML_HTML_DOCUMENT_NODE);
508
509	/*
510	* allocate an translation buffer.
511	*/
512	buffer_size = 1000;
513	buffer = (xmlChar ) xmlMalloc(buffer_size sizeof(xmlChar));
514	if (buffer == NULL) {
515	xmlEntitiesErrMemory("xmlEncodeEntitiesReentrant: malloc failed");
516	return(NULL);
517	}
518	out = buffer;
519
520	while (*cur != '\0') {
521	if (out - buffer > buffer_size - 100) {
522	int indx = out - buffer;
523
524	growBufferReentrant();
525	out = &buffer[indx];
526	}
527
528	/*
529	* By default one have to encode at least '<', '>', '"' and '&' !
530	*/
531	if (*cur == '<') {
532	*out++ = '&';
533	*out++ = 'l';
534	*out++ = 't';
535	*out++ = ';';
536	} else if (*cur == '>') {
537	*out++ = '&';
538	*out++ = 'g';
539	*out++ = 't';
540	*out++ = ';';
541	} else if (*cur == '&') {
542	*out++ = '&';
543	*out++ = 'a';
544	*out++ = 'm';
545	*out++ = 'p';
546	*out++ = ';';
547	} else if (((cur >= 0x20) && (cur < 0x80)) \|\|
548	(cur == '\n') \|\| (cur == '\t') \|\| ((html) && (*cur == '\r'))) {
549	/*
550	* default case, just copy !
551	*/
552	out++ = cur;
553	} else if (*cur >= 0x80) {
554	if (((doc != NULL) && (doc->encoding != NULL)) \|\| (html)) {
555	/*
556	* Bjørn Reese <[email protected]> provided the patch
557	xmlChar xc;
558	xc = (*cur & 0x3F) << 6;
559	if (cur[1] != 0) {
560	xc += *(++cur) & 0x3F;
561	*out++ = xc;
562	} else
563	*/
564	out++ = cur;
565	} else {
566	/*
567	* We assume we have UTF-8 input.
568	*/
569	char buf[11], *ptr;
570	int val = 0, l = 1;
571
572	if (*cur < 0xC0) {
573	xmlEntitiesErr(XML_CHECK_NOT_UTF8,
574	"xmlEncodeEntitiesReentrant : input not UTF-8");
575	if (doc != NULL)
576	doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
577	snprintf(buf, sizeof(buf), "&#%d;", *cur);
578	buf[sizeof(buf) - 1] = 0;
579	ptr = buf;
580	while (ptr != 0) out++ = *ptr++;
581	cur++;
582	continue;
583	} else if (*cur < 0xE0) {
584	val = (cur[0]) & 0x1F;
585	val <<= 6;
586	val \|= (cur[1]) & 0x3F;
587	l = 2;
588	} else if (*cur < 0xF0) {
589	val = (cur[0]) & 0x0F;
590	val <<= 6;
591	val \|= (cur[1]) & 0x3F;
592	val <<= 6;
593	val \|= (cur[2]) & 0x3F;
594	l = 3;
595	} else if (*cur < 0xF8) {
596	val = (cur[0]) & 0x07;
597	val <<= 6;
598	val \|= (cur[1]) & 0x3F;
599	val <<= 6;
600	val \|= (cur[2]) & 0x3F;
601	val <<= 6;
602	val \|= (cur[3]) & 0x3F;
603	l = 4;
604	}
605	if ((l == 1) \|\| (!IS_CHAR(val))) {
606	xmlEntitiesErr(XML_ERR_INVALID_CHAR,
607	"xmlEncodeEntitiesReentrant : char out of range\n");
608	if (doc != NULL)
609	doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
610	snprintf(buf, sizeof(buf), "&#%d;", *cur);
611	buf[sizeof(buf) - 1] = 0;
612	ptr = buf;
613	while (ptr != 0) out++ = *ptr++;
614	cur++;
615	continue;
616	}
617	/*
618	* We could do multiple things here. Just save as a char ref
619	*/
620	snprintf(buf, sizeof(buf), "&#x%X;", val);
621	buf[sizeof(buf) - 1] = 0;
622	ptr = buf;
623	while (ptr != 0) out++ = *ptr++;
624	cur += l;
625	continue;
626	}
627	} else if (IS_BYTE_CHAR(*cur)) {
628	char buf[11], *ptr;
629
630	snprintf(buf, sizeof(buf), "&#%d;", *cur);
631	buf[sizeof(buf) - 1] = 0;
632	ptr = buf;
633	while (ptr != 0) out++ = *ptr++;
634	}
635	cur++;
636	}
637	*out++ = 0;
638	return(buffer);
639	}
640
641	/**
642	* xmlEncodeSpecialChars:
643	* @doc: the document containing the string
644	* @input: A string to convert to XML.
645	*
646	* Do a global encoding of a string, replacing the predefined entities
647	* this routine is reentrant, and result must be deallocated.
648	*
649	* Returns A newly allocated string with the substitution done.
650	*/
651	xmlChar *
652	xmlEncodeSpecialChars(xmlDocPtr doc ATTRIBUTE_UNUSED, const xmlChar *input) {
653	const xmlChar *cur = input;
654	xmlChar *buffer = NULL;
655	xmlChar *out = NULL;
656	int buffer_size = 0;
657	if (input == NULL) return(NULL);
658
659	/*
660	* allocate an translation buffer.
661	*/
662	buffer_size = 1000;
663	buffer = (xmlChar ) xmlMalloc(buffer_size sizeof(xmlChar));
664	if (buffer == NULL) {
665	xmlEntitiesErrMemory("xmlEncodeSpecialChars: malloc failed");
666	return(NULL);
667	}
668	out = buffer;
669
670	while (*cur != '\0') {
671	if (out - buffer > buffer_size - 10) {
672	int indx = out - buffer;
673
674	growBufferReentrant();
675	out = &buffer[indx];
676	}
677
678	/*
679	* By default one have to encode at least '<', '>', '"' and '&' !
680	*/
681	if (*cur == '<') {
682	*out++ = '&';
683	*out++ = 'l';
684	*out++ = 't';
685	*out++ = ';';
686	} else if (*cur == '>') {
687	*out++ = '&';
688	*out++ = 'g';
689	*out++ = 't';
690	*out++ = ';';
691	} else if (*cur == '&') {
692	*out++ = '&';
693	*out++ = 'a';
694	*out++ = 'm';
695	*out++ = 'p';
696	*out++ = ';';
697	} else if (*cur == '"') {
698	*out++ = '&';
699	*out++ = 'q';
700	*out++ = 'u';
701	*out++ = 'o';
702	*out++ = 't';
703	*out++ = ';';
704	} else if (*cur == '\r') {
705	*out++ = '&';
706	*out++ = '#';
707	*out++ = '1';
708	*out++ = '3';
709	*out++ = ';';
710	} else {
711	/*
712	* Works because on UTF-8, all extended sequences cannot
713	* result in bytes in the ASCII range.
714	*/
715	out++ = cur;
716	}
717	cur++;
718	}
719	*out++ = 0;
720	return(buffer);
721	}
722
723	/**
724	* xmlCreateEntitiesTable:
725	*
726	* create and initialize an empty entities hash table.
727	* This really doesn't make sense and should be deprecated
728	*
729	* Returns the xmlEntitiesTablePtr just created or NULL in case of error.
730	*/
731	xmlEntitiesTablePtr
732	xmlCreateEntitiesTable(void) {
733	return((xmlEntitiesTablePtr) xmlHashCreate(0));
734	}
735
736	/**
737	* xmlFreeEntityWrapper:
738	* @entity: An entity
739	* @name: its name
740	*
741	* Deallocate the memory used by an entities in the hash table.
742	*/
743	static void
744	xmlFreeEntityWrapper(xmlEntityPtr entity,
745	const xmlChar *name ATTRIBUTE_UNUSED) {
746	if (entity != NULL)
747	xmlFreeEntity(entity);
748	}
749
750	/**
751	* xmlFreeEntitiesTable:
752	* @table: An entity table
753	*
754	* Deallocate the memory used by an entities hash table.
755	*/
756	void
757	xmlFreeEntitiesTable(xmlEntitiesTablePtr table) {
758	xmlHashFree(table, (xmlHashDeallocator) xmlFreeEntityWrapper);
759	}
760
761	#ifdef LIBXML_TREE_ENABLED
762	/**
763	* xmlCopyEntity:
764	* @ent: An entity
765	*
766	* Build a copy of an entity
767	*
768	* Returns the new xmlEntitiesPtr or NULL in case of error.
769	*/
770	static xmlEntityPtr
771	xmlCopyEntity(xmlEntityPtr ent) {
772	xmlEntityPtr cur;
773
774	cur = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
775	if (cur == NULL) {
776	xmlEntitiesErrMemory("xmlCopyEntity:: malloc failed");
777	return(NULL);
778	}
779	memset(cur, 0, sizeof(xmlEntity));
780	cur->type = XML_ENTITY_DECL;
781
782	cur->etype = ent->etype;
783	if (ent->name != NULL)
784	cur->name = xmlStrdup(ent->name);
785	if (ent->ExternalID != NULL)
786	cur->ExternalID = xmlStrdup(ent->ExternalID);
787	if (ent->SystemID != NULL)
788	cur->SystemID = xmlStrdup(ent->SystemID);
789	if (ent->content != NULL)
790	cur->content = xmlStrdup(ent->content);
791	if (ent->orig != NULL)
792	cur->orig = xmlStrdup(ent->orig);
793	if (ent->URI != NULL)
794	cur->URI = xmlStrdup(ent->URI);
795	return(cur);
796	}
797
798	/**
799	* xmlCopyEntitiesTable:
800	* @table: An entity table
801	*
802	* Build a copy of an entity table.
803	*
804	* Returns the new xmlEntitiesTablePtr or NULL in case of error.
805	*/
806	xmlEntitiesTablePtr
807	xmlCopyEntitiesTable(xmlEntitiesTablePtr table) {
808	return(xmlHashCopy(table, (xmlHashCopier) xmlCopyEntity));
809	}
810	#endif /* LIBXML_TREE_ENABLED */
811
812	#ifdef LIBXML_OUTPUT_ENABLED
813
814	/**
815	* xmlDumpEntityContent:
816	* @buf: An XML buffer.
817	* @content: The entity content.
818	*
819	* This will dump the quoted string value, taking care of the special
820	* treatment required by %
821	*/
822	static void
823	xmlDumpEntityContent(xmlBufferPtr buf, const xmlChar *content) {
824	if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return;
825	if (xmlStrchr(content, '%')) {
826	const xmlChar * base, *cur;
827
828	xmlBufferCCat(buf, "\"");
829	base = cur = content;
830	while (*cur != 0) {
831	if (*cur == '"') {
832	if (base != cur)
833	xmlBufferAdd(buf, base, cur - base);
834	xmlBufferAdd(buf, BAD_CAST """, 6);
835	cur++;
836	base = cur;
837	} else if (*cur == '%') {
838	if (base != cur)
839	xmlBufferAdd(buf, base, cur - base);
840	xmlBufferAdd(buf, BAD_CAST "%", 6);
841	cur++;
842	base = cur;
843	} else {
844	cur++;
845	}
846	}
847	if (base != cur)
848	xmlBufferAdd(buf, base, cur - base);
849	xmlBufferCCat(buf, "\"");
850	} else {
851	xmlBufferWriteQuotedString(buf, content);
852	}
853	}
854
855	/**
856	* xmlDumpEntityDecl:
857	* @buf: An XML buffer.
858	* @ent: An entity table
859	*
860	* This will dump the content of the entity table as an XML DTD definition
861	*/
862	void
863	xmlDumpEntityDecl(xmlBufferPtr buf, xmlEntityPtr ent) {
864	if ((buf == NULL) \|\| (ent == NULL)) return;
865	switch (ent->etype) {
866	case XML_INTERNAL_GENERAL_ENTITY:
867	xmlBufferWriteChar(buf, "<!ENTITY ");
868	xmlBufferWriteCHAR(buf, ent->name);
869	xmlBufferWriteChar(buf, " ");
870	if (ent->orig != NULL)
871	xmlBufferWriteQuotedString(buf, ent->orig);
872	else
873	xmlDumpEntityContent(buf, ent->content);
874	xmlBufferWriteChar(buf, ">\n");
875	break;
876	case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
877	xmlBufferWriteChar(buf, "<!ENTITY ");
878	xmlBufferWriteCHAR(buf, ent->name);
879	if (ent->ExternalID != NULL) {
880	xmlBufferWriteChar(buf, " PUBLIC ");
881	xmlBufferWriteQuotedString(buf, ent->ExternalID);
882	xmlBufferWriteChar(buf, " ");
883	xmlBufferWriteQuotedString(buf, ent->SystemID);
884	} else {
885	xmlBufferWriteChar(buf, " SYSTEM ");
886	xmlBufferWriteQuotedString(buf, ent->SystemID);
887	}
888	xmlBufferWriteChar(buf, ">\n");
889	break;
890	case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
891	xmlBufferWriteChar(buf, "<!ENTITY ");
892	xmlBufferWriteCHAR(buf, ent->name);
893	if (ent->ExternalID != NULL) {
894	xmlBufferWriteChar(buf, " PUBLIC ");
895	xmlBufferWriteQuotedString(buf, ent->ExternalID);
896	xmlBufferWriteChar(buf, " ");
897	xmlBufferWriteQuotedString(buf, ent->SystemID);
898	} else {
899	xmlBufferWriteChar(buf, " SYSTEM ");
900	xmlBufferWriteQuotedString(buf, ent->SystemID);
901	}
902	if (ent->content != NULL) { /* Should be true ! */
903	xmlBufferWriteChar(buf, " NDATA ");
904	if (ent->orig != NULL)
905	xmlBufferWriteCHAR(buf, ent->orig);
906	else
907	xmlBufferWriteCHAR(buf, ent->content);
908	}
909	xmlBufferWriteChar(buf, ">\n");
910	break;
911	case XML_INTERNAL_PARAMETER_ENTITY:
912	xmlBufferWriteChar(buf, "<!ENTITY % ");
913	xmlBufferWriteCHAR(buf, ent->name);
914	xmlBufferWriteChar(buf, " ");
915	if (ent->orig == NULL)
916	xmlDumpEntityContent(buf, ent->content);
917	else
918	xmlBufferWriteQuotedString(buf, ent->orig);
919	xmlBufferWriteChar(buf, ">\n");
920	break;
921	case XML_EXTERNAL_PARAMETER_ENTITY:
922	xmlBufferWriteChar(buf, "<!ENTITY % ");
923	xmlBufferWriteCHAR(buf, ent->name);
924	if (ent->ExternalID != NULL) {
925	xmlBufferWriteChar(buf, " PUBLIC ");
926	xmlBufferWriteQuotedString(buf, ent->ExternalID);
927	xmlBufferWriteChar(buf, " ");
928	xmlBufferWriteQuotedString(buf, ent->SystemID);
929	} else {
930	xmlBufferWriteChar(buf, " SYSTEM ");
931	xmlBufferWriteQuotedString(buf, ent->SystemID);
932	}
933	xmlBufferWriteChar(buf, ">\n");
934	break;
935	default:
936	xmlEntitiesErr(XML_DTD_UNKNOWN_ENTITY,
937	"xmlDumpEntitiesDecl: internal: unknown type entity type");
938	}
939	}
940
941	/**
942	* xmlDumpEntityDeclScan:
943	* @ent: An entity table
944	* @buf: An XML buffer.
945	*
946	* When using the hash table scan function, arguments need to be reversed
947	*/
948	static void
949	xmlDumpEntityDeclScan(xmlEntityPtr ent, xmlBufferPtr buf) {
950	xmlDumpEntityDecl(buf, ent);
951	}
952
953	/**
954	* xmlDumpEntitiesTable:
955	* @buf: An XML buffer.
956	* @table: An entity table
957	*
958	* This will dump the content of the entity table as an XML DTD definition
959	*/
960	void
961	xmlDumpEntitiesTable(xmlBufferPtr buf, xmlEntitiesTablePtr table) {
962	xmlHashScan(table, (xmlHashScanner)xmlDumpEntityDeclScan, buf);
963	}
964	#endif /* LIBXML_OUTPUT_ENABLED */
965	#define bottom_entities
966	#include "elfgcchack.h"

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/libxml2-2.6.30/entities.c@ 9161

Download in other formats: