parser.c@ 93943

Last change on this file since 93943 was 65950, checked in by vboxsync, 8 years ago
libxml 2.9.4: fix export
Property svn:eol-style set to `native`
File size: 430.7 KB

Line
1	/*
2	* parser.c : an XML 1.0 parser, namespaces and validity support are mostly
3	* implemented on top of the SAX interfaces
4	*
5	* References:
6	* The XML specification:
7	* http://www.w3.org/TR/REC-xml
8	* Original 1.0 version:
9	* http://www.w3.org/TR/1998/REC-xml-19980210
10	* XML second edition working draft
11	* http://www.w3.org/TR/2000/WD-xml-2e-20000814
12	*
13	* Okay this is a big file, the parser core is around 7000 lines, then it
14	* is followed by the progressive parser top routines, then the various
15	* high level APIs to call the parser and a few miscellaneous functions.
16	* A number of helper functions and deprecated ones have been moved to
17	* parserInternals.c to reduce this file size.
18	* As much as possible the functions are associated with their relative
19	* production in the XML specification. A few productions defining the
20	* different ranges of character are actually implanted either in
21	* parserInternals.h or parserInternals.c
22	* The DOM tree build is realized from the default SAX callbacks in
23	* the module SAX.c.
24	* The routines doing the validation checks are in valid.c and called either
25	* from the SAX callbacks or as standalone functions using a preparsed
26	* document.
27	*
28	* See Copyright for the status of this software.
29	*
30	* daniel@veillard.com
31	*/
32
33	#define IN_LIBXML
34	#include "libxml.h"
35
36	#if defined(WIN32) && !defined (__CYGWIN__)
37	#define XML_DIR_SEP '\\'
38	#else
39	#define XML_DIR_SEP '/'
40	#endif
41
42	#include <stdlib.h>
43	#include <limits.h>
44	#include <string.h>
45	#include <stdarg.h>
46	#include <libxml/xmlmemory.h>
47	#include <libxml/threads.h>
48	#include <libxml/globals.h>
49	#include <libxml/tree.h>
50	#include <libxml/parser.h>
51	#include <libxml/parserInternals.h>
52	#include <libxml/valid.h>
53	#include <libxml/entities.h>
54	#include <libxml/xmlerror.h>
55	#include <libxml/encoding.h>
56	#include <libxml/xmlIO.h>
57	#include <libxml/uri.h>
58	#ifdef LIBXML_CATALOG_ENABLED
59	#include <libxml/catalog.h>
60	#endif
61	#ifdef LIBXML_SCHEMAS_ENABLED
62	#include <libxml/xmlschemastypes.h>
63	#include <libxml/relaxng.h>
64	#endif
65	#ifdef HAVE_CTYPE_H
66	#include <ctype.h>
67	#endif
68	#ifdef HAVE_STDLIB_H
69	#include <stdlib.h>
70	#endif
71	#ifdef HAVE_SYS_STAT_H
72	#include <sys/stat.h>
73	#endif
74	#ifdef HAVE_FCNTL_H
75	#include <fcntl.h>
76	#endif
77	#ifdef HAVE_UNISTD_H
78	#include <unistd.h>
79	#endif
80	#ifdef HAVE_ZLIB_H
81	#include <zlib.h>
82	#endif
83	#ifdef HAVE_LZMA_H
84	#include <lzma.h>
85	#endif
86
87	#include "buf.h"
88	#include "enc.h"
89
90	static void
91	xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info);
92
93	static xmlParserCtxtPtr
94	xmlCreateEntityParserCtxtInternal(const xmlChar URL, const xmlChar ID,
95	const xmlChar *base, xmlParserCtxtPtr pctx);
96
97	static void xmlHaltParser(xmlParserCtxtPtr ctxt);
98
99	/************************************************************************
100	* *
101	* Arbitrary limits set in the parser. See XML_PARSE_HUGE *
102	* *
103	************************************************************************/
104
105	#define XML_PARSER_BIG_ENTITY 1000
106	#define XML_PARSER_LOT_ENTITY 5000
107
108	/*
109	* XML_PARSER_NON_LINEAR is the threshold where the ratio of parsed entity
110	* replacement over the size in byte of the input indicates that you have
111	* and eponential behaviour. A value of 10 correspond to at least 3 entity
112	* replacement per byte of input.
113	*/
114	#define XML_PARSER_NON_LINEAR 10
115
116	/*
117	* xmlParserEntityCheck
118	*
119	* Function to check non-linear entity expansion behaviour
120	* This is here to detect and stop exponential linear entity expansion
121	* This is not a limitation of the parser but a safety
122	* boundary feature. It can be disabled with the XML_PARSE_HUGE
123	* parser option.
124	*/
125	static int
126	xmlParserEntityCheck(xmlParserCtxtPtr ctxt, size_t size,
127	xmlEntityPtr ent, size_t replacement)
128	{
129	size_t consumed = 0;
130
131	if ((ctxt == NULL) \|\| (ctxt->options & XML_PARSE_HUGE))
132	return (0);
133	if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
134	return (1);
135
136	/*
137	* This may look absurd but is needed to detect
138	* entities problems
139	*/
140	if ((ent != NULL) && (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
141	(ent->content != NULL) && (ent->checked == 0) &&
142	(ctxt->errNo != XML_ERR_ENTITY_LOOP)) {
143	unsigned long oldnbent = ctxt->nbentities;
144	xmlChar *rep;
145
146	ent->checked = 1;
147
148	++ctxt->depth;
149	rep = xmlStringDecodeEntities(ctxt, ent->content,
150	XML_SUBSTITUTE_REF, 0, 0, 0);
151	--ctxt->depth;
152	if (ctxt->errNo == XML_ERR_ENTITY_LOOP) {
153	ent->content[0] = 0;
154	}
155
156	ent->checked = (ctxt->nbentities - oldnbent + 1) * 2;
157	if (rep != NULL) {
158	if (xmlStrchr(rep, '<'))
159	ent->checked \|= 1;
160	xmlFree(rep);
161	rep = NULL;
162	}
163	}
164	if (replacement != 0) {
165	if (replacement < XML_MAX_TEXT_LENGTH)
166	return(0);
167
168	/*
169	* If the volume of entity copy reaches 10 times the
170	* amount of parsed data and over the large text threshold
171	* then that's very likely to be an abuse.
172	*/
173	if (ctxt->input != NULL) {
174	consumed = ctxt->input->consumed +
175	(ctxt->input->cur - ctxt->input->base);
176	}
177	consumed += ctxt->sizeentities;
178
179	if (replacement < XML_PARSER_NON_LINEAR * consumed)
180	return(0);
181	} else if (size != 0) {
182	/*
183	* Do the check based on the replacement size of the entity
184	*/
185	if (size < XML_PARSER_BIG_ENTITY)
186	return(0);
187
188	/*
189	* A limit on the amount of text data reasonably used
190	*/
191	if (ctxt->input != NULL) {
192	consumed = ctxt->input->consumed +
193	(ctxt->input->cur - ctxt->input->base);
194	}
195	consumed += ctxt->sizeentities;
196
197	if ((size < XML_PARSER_NON_LINEAR * consumed) &&
198	(ctxt->nbentities * 3 < XML_PARSER_NON_LINEAR * consumed))
199	return (0);
200	} else if (ent != NULL) {
201	/*
202	* use the number of parsed entities in the replacement
203	*/
204	size = ent->checked / 2;
205
206	/*
207	* The amount of data parsed counting entities size only once
208	*/
209	if (ctxt->input != NULL) {
210	consumed = ctxt->input->consumed +
211	(ctxt->input->cur - ctxt->input->base);
212	}
213	consumed += ctxt->sizeentities;
214
215	/*
216	* Check the density of entities for the amount of data
217	* knowing an entity reference will take at least 3 bytes
218	*/
219	if (size * 3 < consumed * XML_PARSER_NON_LINEAR)
220	return (0);
221	} else {
222	/*
223	* strange we got no data for checking
224	*/
225	if (((ctxt->lastError.code != XML_ERR_UNDECLARED_ENTITY) &&
226	(ctxt->lastError.code != XML_WAR_UNDECLARED_ENTITY)) \|\|
227	(ctxt->nbentities <= 10000))
228	return (0);
229	}
230	xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
231	return (1);
232	}
233
234	/**
235	* xmlParserMaxDepth:
236	*
237	* arbitrary depth limit for the XML documents that we allow to
238	* process. This is not a limitation of the parser but a safety
239	* boundary feature. It can be disabled with the XML_PARSE_HUGE
240	* parser option.
241	*/
242	unsigned int xmlParserMaxDepth = 256;
243
244
245
246	#define SAX2 1
247	#define XML_PARSER_BIG_BUFFER_SIZE 300
248	#define XML_PARSER_BUFFER_SIZE 100
249	#define SAX_COMPAT_MODE BAD_CAST "SAX compatibility mode document"
250
251	/**
252	* XML_PARSER_CHUNK_SIZE
253	*
254	* When calling GROW that's the minimal amount of data
255	* the parser expected to have received. It is not a hard
256	* limit but an optimization when reading strings like Names
257	* It is not strictly needed as long as inputs available characters
258	* are followed by 0, which should be provided by the I/O level
259	*/
260	#define XML_PARSER_CHUNK_SIZE 100
261
262	/*
263	* List of XML prefixed PI allowed by W3C specs
264	*/
265
266	static const char *xmlW3CPIs[] = {
267	"xml-stylesheet",
268	"xml-model",
269	NULL
270	};
271
272
273	/* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */
274	static xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,
275	const xmlChar **str);
276
277	static xmlParserErrors
278	xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
279	xmlSAXHandlerPtr sax,
280	void user_data, int depth, const xmlChar URL,
281	const xmlChar ID, xmlNodePtr list);
282
283	static int
284	xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options,
285	const char *encoding);
286	#ifdef LIBXML_LEGACY_ENABLED
287	static void
288	xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
289	xmlNodePtr lastNode);
290	#endif /* LIBXML_LEGACY_ENABLED */
291
292	static xmlParserErrors
293	xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
294	const xmlChar string, void user_data, xmlNodePtr *lst);
295
296	static int
297	xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity);
298
299	/************************************************************************
300	* *
301	* Some factorized error routines *
302	* *
303	************************************************************************/
304
305	/**
306	* xmlErrAttributeDup:
307	* @ctxt: an XML parser context
308	* @prefix: the attribute prefix
309	* @localname: the attribute localname
310	*
311	* Handle a redefinition of attribute error
312	*/
313	static void
314	xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix,
315	const xmlChar * localname)
316	{
317	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
318	(ctxt->instate == XML_PARSER_EOF))
319	return;
320	if (ctxt != NULL)
321	ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
322
323	if (prefix == NULL)
324	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
325	XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0,
326	(const char *) localname, NULL, NULL, 0, 0,
327	"Attribute %s redefined\n", localname);
328	else
329	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
330	XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0,
331	(const char ) prefix, (const char ) localname,
332	NULL, 0, 0, "Attribute %s:%s redefined\n", prefix,
333	localname);
334	if (ctxt != NULL) {
335	ctxt->wellFormed = 0;
336	if (ctxt->recovery == 0)
337	ctxt->disableSAX = 1;
338	}
339	}
340
341	/**
342	* xmlFatalErr:
343	* @ctxt: an XML parser context
344	* @error: the error number
345	* @extra: extra information string
346	*
347	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
348	*/
349	static void
350	xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info)
351	{
352	const char *errmsg;
353
354	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
355	(ctxt->instate == XML_PARSER_EOF))
356	return;
357	switch (error) {
358	case XML_ERR_INVALID_HEX_CHARREF:
359	errmsg = "CharRef: invalid hexadecimal value";
360	break;
361	case XML_ERR_INVALID_DEC_CHARREF:
362	errmsg = "CharRef: invalid decimal value";
363	break;
364	case XML_ERR_INVALID_CHARREF:
365	errmsg = "CharRef: invalid value";
366	break;
367	case XML_ERR_INTERNAL_ERROR:
368	errmsg = "internal error";
369	break;
370	case XML_ERR_PEREF_AT_EOF:
371	errmsg = "PEReference at end of document";
372	break;
373	case XML_ERR_PEREF_IN_PROLOG:
374	errmsg = "PEReference in prolog";
375	break;
376	case XML_ERR_PEREF_IN_EPILOG:
377	errmsg = "PEReference in epilog";
378	break;
379	case XML_ERR_PEREF_NO_NAME:
380	errmsg = "PEReference: no name";
381	break;
382	case XML_ERR_PEREF_SEMICOL_MISSING:
383	errmsg = "PEReference: expecting ';'";
384	break;
385	case XML_ERR_ENTITY_LOOP:
386	errmsg = "Detected an entity reference loop";
387	break;
388	case XML_ERR_ENTITY_NOT_STARTED:
389	errmsg = "EntityValue: \" or ' expected";
390	break;
391	case XML_ERR_ENTITY_PE_INTERNAL:
392	errmsg = "PEReferences forbidden in internal subset";
393	break;
394	case XML_ERR_ENTITY_NOT_FINISHED:
395	errmsg = "EntityValue: \" or ' expected";
396	break;
397	case XML_ERR_ATTRIBUTE_NOT_STARTED:
398	errmsg = "AttValue: \" or ' expected";
399	break;
400	case XML_ERR_LT_IN_ATTRIBUTE:
401	errmsg = "Unescaped '<' not allowed in attributes values";
402	break;
403	case XML_ERR_LITERAL_NOT_STARTED:
404	errmsg = "SystemLiteral \" or ' expected";
405	break;
406	case XML_ERR_LITERAL_NOT_FINISHED:
407	errmsg = "Unfinished System or Public ID \" or ' expected";
408	break;
409	case XML_ERR_MISPLACED_CDATA_END:
410	errmsg = "Sequence ']]>' not allowed in content";
411	break;
412	case XML_ERR_URI_REQUIRED:
413	errmsg = "SYSTEM or PUBLIC, the URI is missing";
414	break;
415	case XML_ERR_PUBID_REQUIRED:
416	errmsg = "PUBLIC, the Public Identifier is missing";
417	break;
418	case XML_ERR_HYPHEN_IN_COMMENT:
419	errmsg = "Comment must not contain '--' (double-hyphen)";
420	break;
421	case XML_ERR_PI_NOT_STARTED:
422	errmsg = "xmlParsePI : no target name";
423	break;
424	case XML_ERR_RESERVED_XML_NAME:
425	errmsg = "Invalid PI name";
426	break;
427	case XML_ERR_NOTATION_NOT_STARTED:
428	errmsg = "NOTATION: Name expected here";
429	break;
430	case XML_ERR_NOTATION_NOT_FINISHED:
431	errmsg = "'>' required to close NOTATION declaration";
432	break;
433	case XML_ERR_VALUE_REQUIRED:
434	errmsg = "Entity value required";
435	break;
436	case XML_ERR_URI_FRAGMENT:
437	errmsg = "Fragment not allowed";
438	break;
439	case XML_ERR_ATTLIST_NOT_STARTED:
440	errmsg = "'(' required to start ATTLIST enumeration";
441	break;
442	case XML_ERR_NMTOKEN_REQUIRED:
443	errmsg = "NmToken expected in ATTLIST enumeration";
444	break;
445	case XML_ERR_ATTLIST_NOT_FINISHED:
446	errmsg = "')' required to finish ATTLIST enumeration";
447	break;
448	case XML_ERR_MIXED_NOT_STARTED:
449	errmsg = "MixedContentDecl : '\|' or ')*' expected";
450	break;
451	case XML_ERR_PCDATA_REQUIRED:
452	errmsg = "MixedContentDecl : '#PCDATA' expected";
453	break;
454	case XML_ERR_ELEMCONTENT_NOT_STARTED:
455	errmsg = "ContentDecl : Name or '(' expected";
456	break;
457	case XML_ERR_ELEMCONTENT_NOT_FINISHED:
458	errmsg = "ContentDecl : ',' '\|' or ')' expected";
459	break;
460	case XML_ERR_PEREF_IN_INT_SUBSET:
461	errmsg =
462	"PEReference: forbidden within markup decl in internal subset";
463	break;
464	case XML_ERR_GT_REQUIRED:
465	errmsg = "expected '>'";
466	break;
467	case XML_ERR_CONDSEC_INVALID:
468	errmsg = "XML conditional section '[' expected";
469	break;
470	case XML_ERR_EXT_SUBSET_NOT_FINISHED:
471	errmsg = "Content error in the external subset";
472	break;
473	case XML_ERR_CONDSEC_INVALID_KEYWORD:
474	errmsg =
475	"conditional section INCLUDE or IGNORE keyword expected";
476	break;
477	case XML_ERR_CONDSEC_NOT_FINISHED:
478	errmsg = "XML conditional section not closed";
479	break;
480	case XML_ERR_XMLDECL_NOT_STARTED:
481	errmsg = "Text declaration '<?xml' required";
482	break;
483	case XML_ERR_XMLDECL_NOT_FINISHED:
484	errmsg = "parsing XML declaration: '?>' expected";
485	break;
486	case XML_ERR_EXT_ENTITY_STANDALONE:
487	errmsg = "external parsed entities cannot be standalone";
488	break;
489	case XML_ERR_ENTITYREF_SEMICOL_MISSING:
490	errmsg = "EntityRef: expecting ';'";
491	break;
492	case XML_ERR_DOCTYPE_NOT_FINISHED:
493	errmsg = "DOCTYPE improperly terminated";
494	break;
495	case XML_ERR_LTSLASH_REQUIRED:
496	errmsg = "EndTag: '</' not found";
497	break;
498	case XML_ERR_EQUAL_REQUIRED:
499	errmsg = "expected '='";
500	break;
501	case XML_ERR_STRING_NOT_CLOSED:
502	errmsg = "String not closed expecting \" or '";
503	break;
504	case XML_ERR_STRING_NOT_STARTED:
505	errmsg = "String not started expecting ' or \"";
506	break;
507	case XML_ERR_ENCODING_NAME:
508	errmsg = "Invalid XML encoding name";
509	break;
510	case XML_ERR_STANDALONE_VALUE:
511	errmsg = "standalone accepts only 'yes' or 'no'";
512	break;
513	case XML_ERR_DOCUMENT_EMPTY:
514	errmsg = "Document is empty";
515	break;
516	case XML_ERR_DOCUMENT_END:
517	errmsg = "Extra content at the end of the document";
518	break;
519	case XML_ERR_NOT_WELL_BALANCED:
520	errmsg = "chunk is not well balanced";
521	break;
522	case XML_ERR_EXTRA_CONTENT:
523	errmsg = "extra content at the end of well balanced chunk";
524	break;
525	case XML_ERR_VERSION_MISSING:
526	errmsg = "Malformed declaration expecting version";
527	break;
528	case XML_ERR_NAME_TOO_LONG:
529	errmsg = "Name too long use XML_PARSE_HUGE option";
530	break;
531	#if 0
532	case:
533	errmsg = "";
534	break;
535	#endif
536	default:
537	errmsg = "Unregistered error message";
538	}
539	if (ctxt != NULL)
540	ctxt->errNo = error;
541	if (info == NULL) {
542	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
543	XML_ERR_FATAL, NULL, 0, info, NULL, NULL, 0, 0, "%s\n",
544	errmsg);
545	} else {
546	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
547	XML_ERR_FATAL, NULL, 0, info, NULL, NULL, 0, 0, "%s: %s\n",
548	errmsg, info);
549	}
550	if (ctxt != NULL) {
551	ctxt->wellFormed = 0;
552	if (ctxt->recovery == 0)
553	ctxt->disableSAX = 1;
554	}
555	}
556
557	/**
558	* xmlFatalErrMsg:
559	* @ctxt: an XML parser context
560	* @error: the error number
561	* @msg: the error message
562	*
563	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
564	*/
565	static void LIBXML_ATTR_FORMAT(3,0)
566	xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
567	const char *msg)
568	{
569	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
570	(ctxt->instate == XML_PARSER_EOF))
571	return;
572	if (ctxt != NULL)
573	ctxt->errNo = error;
574	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
575	XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, "%s", msg);
576	if (ctxt != NULL) {
577	ctxt->wellFormed = 0;
578	if (ctxt->recovery == 0)
579	ctxt->disableSAX = 1;
580	}
581	}
582
583	/**
584	* xmlWarningMsg:
585	* @ctxt: an XML parser context
586	* @error: the error number
587	* @msg: the error message
588	* @str1: extra data
589	* @str2: extra data
590	*
591	* Handle a warning.
592	*/
593	static void LIBXML_ATTR_FORMAT(3,0)
594	xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
595	const char msg, const xmlChar str1, const xmlChar *str2)
596	{
597	xmlStructuredErrorFunc schannel = NULL;
598
599	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
600	(ctxt->instate == XML_PARSER_EOF))
601	return;
602	if ((ctxt != NULL) && (ctxt->sax != NULL) &&
603	(ctxt->sax->initialized == XML_SAX2_MAGIC))
604	schannel = ctxt->sax->serror;
605	if (ctxt != NULL) {
606	__xmlRaiseError(schannel,
607	(ctxt->sax) ? ctxt->sax->warning : NULL,
608	ctxt->userData,
609	ctxt, NULL, XML_FROM_PARSER, error,
610	XML_ERR_WARNING, NULL, 0,
611	(const char ) str1, (const char ) str2, NULL, 0, 0,
612	msg, (const char ) str1, (const char ) str2);
613	} else {
614	__xmlRaiseError(schannel, NULL, NULL,
615	ctxt, NULL, XML_FROM_PARSER, error,
616	XML_ERR_WARNING, NULL, 0,
617	(const char ) str1, (const char ) str2, NULL, 0, 0,
618	msg, (const char ) str1, (const char ) str2);
619	}
620	}
621
622	/**
623	* xmlValidityError:
624	* @ctxt: an XML parser context
625	* @error: the error number
626	* @msg: the error message
627	* @str1: extra data
628	*
629	* Handle a validity error.
630	*/
631	static void LIBXML_ATTR_FORMAT(3,0)
632	xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error,
633	const char msg, const xmlChar str1, const xmlChar *str2)
634	{
635	xmlStructuredErrorFunc schannel = NULL;
636
637	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
638	(ctxt->instate == XML_PARSER_EOF))
639	return;
640	if (ctxt != NULL) {
641	ctxt->errNo = error;
642	if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
643	schannel = ctxt->sax->serror;
644	}
645	if (ctxt != NULL) {
646	__xmlRaiseError(schannel,
647	ctxt->vctxt.error, ctxt->vctxt.userData,
648	ctxt, NULL, XML_FROM_DTD, error,
649	XML_ERR_ERROR, NULL, 0, (const char *) str1,
650	(const char *) str2, NULL, 0, 0,
651	msg, (const char ) str1, (const char ) str2);
652	ctxt->valid = 0;
653	} else {
654	__xmlRaiseError(schannel, NULL, NULL,
655	ctxt, NULL, XML_FROM_DTD, error,
656	XML_ERR_ERROR, NULL, 0, (const char *) str1,
657	(const char *) str2, NULL, 0, 0,
658	msg, (const char ) str1, (const char ) str2);
659	}
660	}
661
662	/**
663	* xmlFatalErrMsgInt:
664	* @ctxt: an XML parser context
665	* @error: the error number
666	* @msg: the error message
667	* @val: an integer value
668	*
669	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
670	*/
671	static void LIBXML_ATTR_FORMAT(3,0)
672	xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,
673	const char *msg, int val)
674	{
675	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
676	(ctxt->instate == XML_PARSER_EOF))
677	return;
678	if (ctxt != NULL)
679	ctxt->errNo = error;
680	__xmlRaiseError(NULL, NULL, NULL,
681	ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
682	NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
683	if (ctxt != NULL) {
684	ctxt->wellFormed = 0;
685	if (ctxt->recovery == 0)
686	ctxt->disableSAX = 1;
687	}
688	}
689
690	/**
691	* xmlFatalErrMsgStrIntStr:
692	* @ctxt: an XML parser context
693	* @error: the error number
694	* @msg: the error message
695	* @str1: an string info
696	* @val: an integer value
697	* @str2: an string info
698	*
699	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
700	*/
701	static void LIBXML_ATTR_FORMAT(3,0)
702	xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
703	const char msg, const xmlChar str1, int val,
704	const xmlChar *str2)
705	{
706	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
707	(ctxt->instate == XML_PARSER_EOF))
708	return;
709	if (ctxt != NULL)
710	ctxt->errNo = error;
711	__xmlRaiseError(NULL, NULL, NULL,
712	ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
713	NULL, 0, (const char ) str1, (const char ) str2,
714	NULL, val, 0, msg, str1, val, str2);
715	if (ctxt != NULL) {
716	ctxt->wellFormed = 0;
717	if (ctxt->recovery == 0)
718	ctxt->disableSAX = 1;
719	}
720	}
721
722	/**
723	* xmlFatalErrMsgStr:
724	* @ctxt: an XML parser context
725	* @error: the error number
726	* @msg: the error message
727	* @val: a string value
728	*
729	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
730	*/
731	static void LIBXML_ATTR_FORMAT(3,0)
732	xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
733	const char msg, const xmlChar val)
734	{
735	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
736	(ctxt->instate == XML_PARSER_EOF))
737	return;
738	if (ctxt != NULL)
739	ctxt->errNo = error;
740	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
741	XML_FROM_PARSER, error, XML_ERR_FATAL,
742	NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,
743	val);
744	if (ctxt != NULL) {
745	ctxt->wellFormed = 0;
746	if (ctxt->recovery == 0)
747	ctxt->disableSAX = 1;
748	}
749	}
750
751	/**
752	* xmlErrMsgStr:
753	* @ctxt: an XML parser context
754	* @error: the error number
755	* @msg: the error message
756	* @val: a string value
757	*
758	* Handle a non fatal parser error
759	*/
760	static void LIBXML_ATTR_FORMAT(3,0)
761	xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
762	const char msg, const xmlChar val)
763	{
764	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
765	(ctxt->instate == XML_PARSER_EOF))
766	return;
767	if (ctxt != NULL)
768	ctxt->errNo = error;
769	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
770	XML_FROM_PARSER, error, XML_ERR_ERROR,
771	NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,
772	val);
773	}
774
775	/**
776	* xmlNsErr:
777	* @ctxt: an XML parser context
778	* @error: the error number
779	* @msg: the message
780	* @info1: extra information string
781	* @info2: extra information string
782	*
783	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
784	*/
785	static void LIBXML_ATTR_FORMAT(3,0)
786	xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
787	const char *msg,
788	const xmlChar * info1, const xmlChar * info2,
789	const xmlChar * info3)
790	{
791	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
792	(ctxt->instate == XML_PARSER_EOF))
793	return;
794	if (ctxt != NULL)
795	ctxt->errNo = error;
796	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
797	XML_ERR_ERROR, NULL, 0, (const char *) info1,
798	(const char ) info2, (const char ) info3, 0, 0, msg,
799	info1, info2, info3);
800	if (ctxt != NULL)
801	ctxt->nsWellFormed = 0;
802	}
803
804	/**
805	* xmlNsWarn
806	* @ctxt: an XML parser context
807	* @error: the error number
808	* @msg: the message
809	* @info1: extra information string
810	* @info2: extra information string
811	*
812	* Handle a namespace warning error
813	*/
814	static void LIBXML_ATTR_FORMAT(3,0)
815	xmlNsWarn(xmlParserCtxtPtr ctxt, xmlParserErrors error,
816	const char *msg,
817	const xmlChar * info1, const xmlChar * info2,
818	const xmlChar * info3)
819	{
820	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
821	(ctxt->instate == XML_PARSER_EOF))
822	return;
823	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
824	XML_ERR_WARNING, NULL, 0, (const char *) info1,
825	(const char ) info2, (const char ) info3, 0, 0, msg,
826	info1, info2, info3);
827	}
828
829	/************************************************************************
830	* *
831	* Library wide options *
832	* *
833	************************************************************************/
834
835	/**
836	* xmlHasFeature:
837	* @feature: the feature to be examined
838	*
839	* Examines if the library has been compiled with a given feature.
840	*
841	* Returns a non-zero value if the feature exist, otherwise zero.
842	* Returns zero (0) if the feature does not exist or an unknown
843	* unknown feature is requested, non-zero otherwise.
844	*/
845	int
846	xmlHasFeature(xmlFeature feature)
847	{
848	switch (feature) {
849	case XML_WITH_THREAD:
850	#ifdef LIBXML_THREAD_ENABLED
851	return(1);
852	#else
853	return(0);
854	#endif
855	case XML_WITH_TREE:
856	#ifdef LIBXML_TREE_ENABLED
857	return(1);
858	#else
859	return(0);
860	#endif
861	case XML_WITH_OUTPUT:
862	#ifdef LIBXML_OUTPUT_ENABLED
863	return(1);
864	#else
865	return(0);
866	#endif
867	case XML_WITH_PUSH:
868	#ifdef LIBXML_PUSH_ENABLED
869	return(1);
870	#else
871	return(0);
872	#endif
873	case XML_WITH_READER:
874	#ifdef LIBXML_READER_ENABLED
875	return(1);
876	#else
877	return(0);
878	#endif
879	case XML_WITH_PATTERN:
880	#ifdef LIBXML_PATTERN_ENABLED
881	return(1);
882	#else
883	return(0);
884	#endif
885	case XML_WITH_WRITER:
886	#ifdef LIBXML_WRITER_ENABLED
887	return(1);
888	#else
889	return(0);
890	#endif
891	case XML_WITH_SAX1:
892	#ifdef LIBXML_SAX1_ENABLED
893	return(1);
894	#else
895	return(0);
896	#endif
897	case XML_WITH_FTP:
898	#ifdef LIBXML_FTP_ENABLED
899	return(1);
900	#else
901	return(0);
902	#endif
903	case XML_WITH_HTTP:
904	#ifdef LIBXML_HTTP_ENABLED
905	return(1);
906	#else
907	return(0);
908	#endif
909	case XML_WITH_VALID:
910	#ifdef LIBXML_VALID_ENABLED
911	return(1);
912	#else
913	return(0);
914	#endif
915	case XML_WITH_HTML:
916	#ifdef LIBXML_HTML_ENABLED
917	return(1);
918	#else
919	return(0);
920	#endif
921	case XML_WITH_LEGACY:
922	#ifdef LIBXML_LEGACY_ENABLED
923	return(1);
924	#else
925	return(0);
926	#endif
927	case XML_WITH_C14N:
928	#ifdef LIBXML_C14N_ENABLED
929	return(1);
930	#else
931	return(0);
932	#endif
933	case XML_WITH_CATALOG:
934	#ifdef LIBXML_CATALOG_ENABLED
935	return(1);
936	#else
937	return(0);
938	#endif
939	case XML_WITH_XPATH:
940	#ifdef LIBXML_XPATH_ENABLED
941	return(1);
942	#else
943	return(0);
944	#endif
945	case XML_WITH_XPTR:
946	#ifdef LIBXML_XPTR_ENABLED
947	return(1);
948	#else
949	return(0);
950	#endif
951	case XML_WITH_XINCLUDE:
952	#ifdef LIBXML_XINCLUDE_ENABLED
953	return(1);
954	#else
955	return(0);
956	#endif
957	case XML_WITH_ICONV:
958	#ifdef LIBXML_ICONV_ENABLED
959	return(1);
960	#else
961	return(0);
962	#endif
963	case XML_WITH_ISO8859X:
964	#ifdef LIBXML_ISO8859X_ENABLED
965	return(1);
966	#else
967	return(0);
968	#endif
969	case XML_WITH_UNICODE:
970	#ifdef LIBXML_UNICODE_ENABLED
971	return(1);
972	#else
973	return(0);
974	#endif
975	case XML_WITH_REGEXP:
976	#ifdef LIBXML_REGEXP_ENABLED
977	return(1);
978	#else
979	return(0);
980	#endif
981	case XML_WITH_AUTOMATA:
982	#ifdef LIBXML_AUTOMATA_ENABLED
983	return(1);
984	#else
985	return(0);
986	#endif
987	case XML_WITH_EXPR:
988	#ifdef LIBXML_EXPR_ENABLED
989	return(1);
990	#else
991	return(0);
992	#endif
993	case XML_WITH_SCHEMAS:
994	#ifdef LIBXML_SCHEMAS_ENABLED
995	return(1);
996	#else
997	return(0);
998	#endif
999	case XML_WITH_SCHEMATRON:
1000	#ifdef LIBXML_SCHEMATRON_ENABLED
1001	return(1);
1002	#else
1003	return(0);
1004	#endif
1005	case XML_WITH_MODULES:
1006	#ifdef LIBXML_MODULES_ENABLED
1007	return(1);
1008	#else
1009	return(0);
1010	#endif
1011	case XML_WITH_DEBUG:
1012	#ifdef LIBXML_DEBUG_ENABLED
1013	return(1);
1014	#else
1015	return(0);
1016	#endif
1017	case XML_WITH_DEBUG_MEM:
1018	#ifdef DEBUG_MEMORY_LOCATION
1019	return(1);
1020	#else
1021	return(0);
1022	#endif
1023	case XML_WITH_DEBUG_RUN:
1024	#ifdef LIBXML_DEBUG_RUNTIME
1025	return(1);
1026	#else
1027	return(0);
1028	#endif
1029	case XML_WITH_ZLIB:
1030	#ifdef LIBXML_ZLIB_ENABLED
1031	return(1);
1032	#else
1033	return(0);
1034	#endif
1035	case XML_WITH_LZMA:
1036	#ifdef LIBXML_LZMA_ENABLED
1037	return(1);
1038	#else
1039	return(0);
1040	#endif
1041	case XML_WITH_ICU:
1042	#ifdef LIBXML_ICU_ENABLED
1043	return(1);
1044	#else
1045	return(0);
1046	#endif
1047	default:
1048	break;
1049	}
1050	return(0);
1051	}
1052
1053	/************************************************************************
1054	* *
1055	* SAX2 defaulted attributes handling *
1056	* *
1057	************************************************************************/
1058
1059	/**
1060	* xmlDetectSAX2:
1061	* @ctxt: an XML parser context
1062	*
1063	* Do the SAX2 detection and specific intialization
1064	*/
1065	static void
1066	xmlDetectSAX2(xmlParserCtxtPtr ctxt) {
1067	if (ctxt == NULL) return;
1068	#ifdef LIBXML_SAX1_ENABLED
1069	if ((ctxt->sax) && (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
1070	((ctxt->sax->startElementNs != NULL) \|\|
1071	(ctxt->sax->endElementNs != NULL))) ctxt->sax2 = 1;
1072	#else
1073	ctxt->sax2 = 1;
1074	#endif /* LIBXML_SAX1_ENABLED */
1075
1076	ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
1077	ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
1078	ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
1079	if ((ctxt->str_xml==NULL) \|\| (ctxt->str_xmlns==NULL) \|\|
1080	(ctxt->str_xml_ns == NULL)) {
1081	xmlErrMemory(ctxt, NULL);
1082	}
1083	}
1084
1085	typedef struct _xmlDefAttrs xmlDefAttrs;
1086	typedef xmlDefAttrs *xmlDefAttrsPtr;
1087	struct _xmlDefAttrs {
1088	int nbAttrs; /* number of defaulted attributes on that element */
1089	int maxAttrs; /* the size of the array */
1090	const xmlChar values[5]; / array of localname/prefix/values/external */
1091	};
1092
1093	/**
1094	* xmlAttrNormalizeSpace:
1095	* @src: the source string
1096	* @dst: the target string
1097	*
1098	* Normalize the space in non CDATA attribute values:
1099	* If the attribute type is not CDATA, then the XML processor MUST further
1100	* process the normalized attribute value by discarding any leading and
1101	* trailing space (#x20) characters, and by replacing sequences of space
1102	* (#x20) characters by a single space (#x20) character.
1103	* Note that the size of dst need to be at least src, and if one doesn't need
1104	* to preserve dst (and it doesn't come from a dictionary or read-only) then
1105	* passing src as dst is just fine.
1106	*
1107	* Returns a pointer to the normalized value (dst) or NULL if no conversion
1108	* is needed.
1109	*/
1110	static xmlChar *
1111	xmlAttrNormalizeSpace(const xmlChar src, xmlChar dst)
1112	{
1113	if ((src == NULL) \|\| (dst == NULL))
1114	return(NULL);
1115
1116	while (*src == 0x20) src++;
1117	while (*src != 0) {
1118	if (*src == 0x20) {
1119	while (*src == 0x20) src++;
1120	if (*src != 0)
1121	*dst++ = 0x20;
1122	} else {
1123	dst++ = src++;
1124	}
1125	}
1126	*dst = 0;
1127	if (dst == src)
1128	return(NULL);
1129	return(dst);
1130	}
1131
1132	/**
1133	* xmlAttrNormalizeSpace2:
1134	* @src: the source string
1135	*
1136	* Normalize the space in non CDATA attribute values, a slightly more complex
1137	* front end to avoid allocation problems when running on attribute values
1138	* coming from the input.
1139	*
1140	* Returns a pointer to the normalized value (dst) or NULL if no conversion
1141	* is needed.
1142	*/
1143	static const xmlChar *
1144	xmlAttrNormalizeSpace2(xmlParserCtxtPtr ctxt, xmlChar src, int len)
1145	{
1146	int i;
1147	int remove_head = 0;
1148	int need_realloc = 0;
1149	const xmlChar *cur;
1150
1151	if ((ctxt == NULL) \|\| (src == NULL) \|\| (len == NULL))
1152	return(NULL);
1153	i = *len;
1154	if (i <= 0)
1155	return(NULL);
1156
1157	cur = src;
1158	while (*cur == 0x20) {
1159	cur++;
1160	remove_head++;
1161	}
1162	while (*cur != 0) {
1163	if (*cur == 0x20) {
1164	cur++;
1165	if ((cur == 0x20) \|\| (cur == 0)) {
1166	need_realloc = 1;
1167	break;
1168	}
1169	} else
1170	cur++;
1171	}
1172	if (need_realloc) {
1173	xmlChar *ret;
1174
1175	ret = xmlStrndup(src + remove_head, i - remove_head + 1);
1176	if (ret == NULL) {
1177	xmlErrMemory(ctxt, NULL);
1178	return(NULL);
1179	}
1180	xmlAttrNormalizeSpace(ret, ret);
1181	len = (int) strlen((const char )ret);
1182	return(ret);
1183	} else if (remove_head) {
1184	*len -= remove_head;
1185	memmove(src, src + remove_head, 1 + *len);
1186	return(src);
1187	}
1188	return(NULL);
1189	}
1190
1191	/**
1192	* xmlAddDefAttrs:
1193	* @ctxt: an XML parser context
1194	* @fullname: the element fullname
1195	* @fullattr: the attribute fullname
1196	* @value: the attribute value
1197	*
1198	* Add a defaulted attribute for an element
1199	*/
1200	static void
1201	xmlAddDefAttrs(xmlParserCtxtPtr ctxt,
1202	const xmlChar *fullname,
1203	const xmlChar *fullattr,
1204	const xmlChar *value) {
1205	xmlDefAttrsPtr defaults;
1206	int len;
1207	const xmlChar *name;
1208	const xmlChar *prefix;
1209
1210	/*
1211	* Allows to detect attribute redefinitions
1212	*/
1213	if (ctxt->attsSpecial != NULL) {
1214	if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1215	return;
1216	}
1217
1218	if (ctxt->attsDefault == NULL) {
1219	ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict);
1220	if (ctxt->attsDefault == NULL)
1221	goto mem_error;
1222	}
1223
1224	/*
1225	* split the element name into prefix:localname , the string found
1226	* are within the DTD and then not associated to namespace names.
1227	*/
1228	name = xmlSplitQName3(fullname, &len);
1229	if (name == NULL) {
1230	name = xmlDictLookup(ctxt->dict, fullname, -1);
1231	prefix = NULL;
1232	} else {
1233	name = xmlDictLookup(ctxt->dict, name, -1);
1234	prefix = xmlDictLookup(ctxt->dict, fullname, len);
1235	}
1236
1237	/*
1238	* make sure there is some storage
1239	*/
1240	defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix);
1241	if (defaults == NULL) {
1242	defaults = (xmlDefAttrsPtr) xmlMalloc(sizeof(xmlDefAttrs) +
1243	(4 * 5) * sizeof(const xmlChar *));
1244	if (defaults == NULL)
1245	goto mem_error;
1246	defaults->nbAttrs = 0;
1247	defaults->maxAttrs = 4;
1248	if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
1249	defaults, NULL) < 0) {
1250	xmlFree(defaults);
1251	goto mem_error;
1252	}
1253	} else if (defaults->nbAttrs >= defaults->maxAttrs) {
1254	xmlDefAttrsPtr temp;
1255
1256	temp = (xmlDefAttrsPtr) xmlRealloc(defaults, sizeof(xmlDefAttrs) +
1257	(2 * defaults->maxAttrs * 5) * sizeof(const xmlChar *));
1258	if (temp == NULL)
1259	goto mem_error;
1260	defaults = temp;
1261	defaults->maxAttrs *= 2;
1262	if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
1263	defaults, NULL) < 0) {
1264	xmlFree(defaults);
1265	goto mem_error;
1266	}
1267	}
1268
1269	/*
1270	* Split the element name into prefix:localname , the string found
1271	* are within the DTD and hen not associated to namespace names.
1272	*/
1273	name = xmlSplitQName3(fullattr, &len);
1274	if (name == NULL) {
1275	name = xmlDictLookup(ctxt->dict, fullattr, -1);
1276	prefix = NULL;
1277	} else {
1278	name = xmlDictLookup(ctxt->dict, name, -1);
1279	prefix = xmlDictLookup(ctxt->dict, fullattr, len);
1280	}
1281
1282	defaults->values[5 * defaults->nbAttrs] = name;
1283	defaults->values[5 * defaults->nbAttrs + 1] = prefix;
1284	/* intern the string and precompute the end */
1285	len = xmlStrlen(value);
1286	value = xmlDictLookup(ctxt->dict, value, len);
1287	defaults->values[5 * defaults->nbAttrs + 2] = value;
1288	defaults->values[5 * defaults->nbAttrs + 3] = value + len;
1289	if (ctxt->external)
1290	defaults->values[5 * defaults->nbAttrs + 4] = BAD_CAST "external";
1291	else
1292	defaults->values[5 * defaults->nbAttrs + 4] = NULL;
1293	defaults->nbAttrs++;
1294
1295	return;
1296
1297	mem_error:
1298	xmlErrMemory(ctxt, NULL);
1299	return;
1300	}
1301
1302	/**
1303	* xmlAddSpecialAttr:
1304	* @ctxt: an XML parser context
1305	* @fullname: the element fullname
1306	* @fullattr: the attribute fullname
1307	* @type: the attribute type
1308	*
1309	* Register this attribute type
1310	*/
1311	static void
1312	xmlAddSpecialAttr(xmlParserCtxtPtr ctxt,
1313	const xmlChar *fullname,
1314	const xmlChar *fullattr,
1315	int type)
1316	{
1317	if (ctxt->attsSpecial == NULL) {
1318	ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict);
1319	if (ctxt->attsSpecial == NULL)
1320	goto mem_error;
1321	}
1322
1323	if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1324	return;
1325
1326	xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr,
1327	(void *) (long) type);
1328	return;
1329
1330	mem_error:
1331	xmlErrMemory(ctxt, NULL);
1332	return;
1333	}
1334
1335	/**
1336	* xmlCleanSpecialAttrCallback:
1337	*
1338	* Removes CDATA attributes from the special attribute table
1339	*/
1340	static void
1341	xmlCleanSpecialAttrCallback(void payload, void data,
1342	const xmlChar fullname, const xmlChar fullattr,
1343	const xmlChar *unused ATTRIBUTE_UNUSED) {
1344	xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) data;
1345
1346	if (((long) payload) == XML_ATTRIBUTE_CDATA) {
1347	xmlHashRemoveEntry2(ctxt->attsSpecial, fullname, fullattr, NULL);
1348	}
1349	}
1350
1351	/**
1352	* xmlCleanSpecialAttr:
1353	* @ctxt: an XML parser context
1354	*
1355	* Trim the list of attributes defined to remove all those of type
1356	* CDATA as they are not special. This call should be done when finishing
1357	* to parse the DTD and before starting to parse the document root.
1358	*/
1359	static void
1360	xmlCleanSpecialAttr(xmlParserCtxtPtr ctxt)
1361	{
1362	if (ctxt->attsSpecial == NULL)
1363	return;
1364
1365	xmlHashScanFull(ctxt->attsSpecial, xmlCleanSpecialAttrCallback, ctxt);
1366
1367	if (xmlHashSize(ctxt->attsSpecial) == 0) {
1368	xmlHashFree(ctxt->attsSpecial, NULL);
1369	ctxt->attsSpecial = NULL;
1370	}
1371	return;
1372	}
1373
1374	/**
1375	* xmlCheckLanguageID:
1376	* @lang: pointer to the string value
1377	*
1378	* Checks that the value conforms to the LanguageID production:
1379	*
1380	* NOTE: this is somewhat deprecated, those productions were removed from
1381	* the XML Second edition.
1382	*
1383	* [33] LanguageID ::= Langcode ('-' Subcode)*
1384	* [34] Langcode ::= ISO639Code \| IanaCode \| UserCode
1385	* [35] ISO639Code ::= ([a-z] \| [A-Z]) ([a-z] \| [A-Z])
1386	* [36] IanaCode ::= ('i' \| 'I') '-' ([a-z] \| [A-Z])+
1387	* [37] UserCode ::= ('x' \| 'X') '-' ([a-z] \| [A-Z])+
1388	* [38] Subcode ::= ([a-z] \| [A-Z])+
1389	*
1390	* The current REC reference the sucessors of RFC 1766, currently 5646
1391	*
1392	* http://www.rfc-editor.org/rfc/rfc5646.txt
1393	* langtag = language
1394	* ["-" script]
1395	* ["-" region]
1396	* *("-" variant)
1397	* *("-" extension)
1398	* ["-" privateuse]
1399	* language = 2*3ALPHA ; shortest ISO 639 code
1400	* ["-" extlang] ; sometimes followed by
1401	* ; extended language subtags
1402	* / 4ALPHA ; or reserved for future use
1403	* / 5*8ALPHA ; or registered language subtag
1404	*
1405	* extlang = 3ALPHA ; selected ISO 639 codes
1406	* *2("-" 3ALPHA) ; permanently reserved
1407	*
1408	* script = 4ALPHA ; ISO 15924 code
1409	*
1410	* region = 2ALPHA ; ISO 3166-1 code
1411	* / 3DIGIT ; UN M.49 code
1412	*
1413	* variant = 5*8alphanum ; registered variants
1414	* / (DIGIT 3alphanum)
1415	*
1416	* extension = singleton 1("-" (28alphanum))
1417	*
1418	* ; Single alphanumerics
1419	* ; "x" reserved for private use
1420	* singleton = DIGIT ; 0 - 9
1421	* / %x41-57 ; A - W
1422	* / %x59-5A ; Y - Z
1423	* / %x61-77 ; a - w
1424	* / %x79-7A ; y - z
1425	*
1426	* it sounds right to still allow Irregular i-xxx IANA and user codes too
1427	* The parser below doesn't try to cope with extension or privateuse
1428	* that could be added but that's not interoperable anyway
1429	*
1430	* Returns 1 if correct 0 otherwise
1431	**/
1432	int
1433	xmlCheckLanguageID(const xmlChar * lang)
1434	{
1435	const xmlChar cur = lang, nxt;
1436
1437	if (cur == NULL)
1438	return (0);
1439	if (((cur[0] == 'i') && (cur[1] == '-')) \|\|
1440	((cur[0] == 'I') && (cur[1] == '-')) \|\|
1441	((cur[0] == 'x') && (cur[1] == '-')) \|\|
1442	((cur[0] == 'X') && (cur[1] == '-'))) {
1443	/*
1444	* Still allow IANA code and user code which were coming
1445	* from the previous version of the XML-1.0 specification
1446	* it's deprecated but we should not fail
1447	*/
1448	cur += 2;
1449	while (((cur[0] >= 'A') && (cur[0] <= 'Z')) \|\|
1450	((cur[0] >= 'a') && (cur[0] <= 'z')))
1451	cur++;
1452	return(cur[0] == 0);
1453	}
1454	nxt = cur;
1455	while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) \|\|
1456	((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1457	nxt++;
1458	if (nxt - cur >= 4) {
1459	/*
1460	* Reserved
1461	*/
1462	if ((nxt - cur > 8) \|\| (nxt[0] != 0))
1463	return(0);
1464	return(1);
1465	}
1466	if (nxt - cur < 2)
1467	return(0);
1468	/* we got an ISO 639 code */
1469	if (nxt[0] == 0)
1470	return(1);
1471	if (nxt[0] != '-')
1472	return(0);
1473
1474	nxt++;
1475	cur = nxt;
1476	/* now we can have extlang or script or region or variant */
1477	if ((nxt[0] >= '0') && (nxt[0] <= '9'))
1478	goto region_m49;
1479
1480	while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) \|\|
1481	((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1482	nxt++;
1483	if (nxt - cur == 4)
1484	goto script;
1485	if (nxt - cur == 2)
1486	goto region;
1487	if ((nxt - cur >= 5) && (nxt - cur <= 8))
1488	goto variant;
1489	if (nxt - cur != 3)
1490	return(0);
1491	/* we parsed an extlang */
1492	if (nxt[0] == 0)
1493	return(1);
1494	if (nxt[0] != '-')
1495	return(0);
1496
1497	nxt++;
1498	cur = nxt;
1499	/* now we can have script or region or variant */
1500	if ((nxt[0] >= '0') && (nxt[0] <= '9'))
1501	goto region_m49;
1502
1503	while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) \|\|
1504	((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1505	nxt++;
1506	if (nxt - cur == 2)
1507	goto region;
1508	if ((nxt - cur >= 5) && (nxt - cur <= 8))
1509	goto variant;
1510	if (nxt - cur != 4)
1511	return(0);
1512	/* we parsed a script */
1513	script:
1514	if (nxt[0] == 0)
1515	return(1);
1516	if (nxt[0] != '-')
1517	return(0);
1518
1519	nxt++;
1520	cur = nxt;
1521	/* now we can have region or variant */
1522	if ((nxt[0] >= '0') && (nxt[0] <= '9'))
1523	goto region_m49;
1524
1525	while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) \|\|
1526	((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1527	nxt++;
1528
1529	if ((nxt - cur >= 5) && (nxt - cur <= 8))
1530	goto variant;
1531	if (nxt - cur != 2)
1532	return(0);
1533	/* we parsed a region */
1534	region:
1535	if (nxt[0] == 0)
1536	return(1);
1537	if (nxt[0] != '-')
1538	return(0);
1539
1540	nxt++;
1541	cur = nxt;
1542	/* now we can just have a variant */
1543	while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) \|\|
1544	((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1545	nxt++;
1546
1547	if ((nxt - cur < 5) \|\| (nxt - cur > 8))
1548	return(0);
1549
1550	/* we parsed a variant */
1551	variant:
1552	if (nxt[0] == 0)
1553	return(1);
1554	if (nxt[0] != '-')
1555	return(0);
1556	/* extensions and private use subtags not checked */
1557	return (1);
1558
1559	region_m49:
1560	if (((nxt[1] >= '0') && (nxt[1] <= '9')) &&
1561	((nxt[2] >= '0') && (nxt[2] <= '9'))) {
1562	nxt += 3;
1563	goto region;
1564	}
1565	return(0);
1566	}
1567
1568	/************************************************************************
1569	* *
1570	* Parser stacks related functions and macros *
1571	* *
1572	************************************************************************/
1573
1574	static xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,
1575	const xmlChar ** str);
1576
1577	#ifdef SAX2
1578	/**
1579	* nsPush:
1580	* @ctxt: an XML parser context
1581	* @prefix: the namespace prefix or NULL
1582	* @URL: the namespace name
1583	*
1584	* Pushes a new parser namespace on top of the ns stack
1585	*
1586	* Returns -1 in case of error, -2 if the namespace should be discarded
1587	* and the index in the stack otherwise.
1588	*/
1589	static int
1590	nsPush(xmlParserCtxtPtr ctxt, const xmlChar prefix, const xmlChar URL)
1591	{
1592	if (ctxt->options & XML_PARSE_NSCLEAN) {
1593	int i;
1594	for (i = ctxt->nsNr - 2;i >= 0;i -= 2) {
1595	if (ctxt->nsTab[i] == prefix) {
1596	/* in scope */
1597	if (ctxt->nsTab[i + 1] == URL)
1598	return(-2);
1599	/* out of scope keep it */
1600	break;
1601	}
1602	}
1603	}
1604	if ((ctxt->nsMax == 0) \|\| (ctxt->nsTab == NULL)) {
1605	ctxt->nsMax = 10;
1606	ctxt->nsNr = 0;
1607	ctxt->nsTab = (const xmlChar **)
1608	xmlMalloc(ctxt->nsMax * sizeof(xmlChar *));
1609	if (ctxt->nsTab == NULL) {
1610	xmlErrMemory(ctxt, NULL);
1611	ctxt->nsMax = 0;
1612	return (-1);
1613	}
1614	} else if (ctxt->nsNr >= ctxt->nsMax) {
1615	const xmlChar ** tmp;
1616	ctxt->nsMax *= 2;
1617	tmp = (const xmlChar *) xmlRealloc((char ) ctxt->nsTab,
1618	ctxt->nsMax * sizeof(ctxt->nsTab[0]));
1619	if (tmp == NULL) {
1620	xmlErrMemory(ctxt, NULL);
1621	ctxt->nsMax /= 2;
1622	return (-1);
1623	}
1624	ctxt->nsTab = tmp;
1625	}
1626	ctxt->nsTab[ctxt->nsNr++] = prefix;
1627	ctxt->nsTab[ctxt->nsNr++] = URL;
1628	return (ctxt->nsNr);
1629	}
1630	/**
1631	* nsPop:
1632	* @ctxt: an XML parser context
1633	* @nr: the number to pop
1634	*
1635	* Pops the top @nr parser prefix/namespace from the ns stack
1636	*
1637	* Returns the number of namespaces removed
1638	*/
1639	static int
1640	nsPop(xmlParserCtxtPtr ctxt, int nr)
1641	{
1642	int i;
1643
1644	if (ctxt->nsTab == NULL) return(0);
1645	if (ctxt->nsNr < nr) {
1646	xmlGenericError(xmlGenericErrorContext, "Pbm popping %d NS\n", nr);
1647	nr = ctxt->nsNr;
1648	}
1649	if (ctxt->nsNr <= 0)
1650	return (0);
1651
1652	for (i = 0;i < nr;i++) {
1653	ctxt->nsNr--;
1654	ctxt->nsTab[ctxt->nsNr] = NULL;
1655	}
1656	return(nr);
1657	}
1658	#endif
1659
1660	static int
1661	xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) {
1662	const xmlChar **atts;
1663	int *attallocs;
1664	int maxatts;
1665
1666	if (ctxt->atts == NULL) {
1667	maxatts = 55; /* allow for 10 attrs by default */
1668	atts = (const xmlChar **)
1669	xmlMalloc(maxatts * sizeof(xmlChar *));
1670	if (atts == NULL) goto mem_error;
1671	ctxt->atts = atts;
1672	attallocs = (int ) xmlMalloc((maxatts / 5) sizeof(int));
1673	if (attallocs == NULL) goto mem_error;
1674	ctxt->attallocs = attallocs;
1675	ctxt->maxatts = maxatts;
1676	} else if (nr + 5 > ctxt->maxatts) {
1677	maxatts = (nr + 5) * 2;
1678	atts = (const xmlChar *) xmlRealloc((void ) ctxt->atts,
1679	maxatts * sizeof(const xmlChar *));
1680	if (atts == NULL) goto mem_error;
1681	ctxt->atts = atts;
1682	attallocs = (int ) xmlRealloc((void ) ctxt->attallocs,
1683	(maxatts / 5) * sizeof(int));
1684	if (attallocs == NULL) goto mem_error;
1685	ctxt->attallocs = attallocs;
1686	ctxt->maxatts = maxatts;
1687	}
1688	return(ctxt->maxatts);
1689	mem_error:
1690	xmlErrMemory(ctxt, NULL);
1691	return(-1);
1692	}
1693
1694	/**
1695	* inputPush:
1696	* @ctxt: an XML parser context
1697	* @value: the parser input
1698	*
1699	* Pushes a new parser input on top of the input stack
1700	*
1701	* Returns -1 in case of error, the index in the stack otherwise
1702	*/
1703	int
1704	inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
1705	{
1706	if ((ctxt == NULL) \|\| (value == NULL))
1707	return(-1);
1708	if (ctxt->inputNr >= ctxt->inputMax) {
1709	ctxt->inputMax *= 2;
1710	ctxt->inputTab =
1711	(xmlParserInputPtr *) xmlRealloc(ctxt->inputTab,
1712	ctxt->inputMax *
1713	sizeof(ctxt->inputTab[0]));
1714	if (ctxt->inputTab == NULL) {
1715	xmlErrMemory(ctxt, NULL);
1716	xmlFreeInputStream(value);
1717	ctxt->inputMax /= 2;
1718	value = NULL;
1719	return (-1);
1720	}
1721	}
1722	ctxt->inputTab[ctxt->inputNr] = value;
1723	ctxt->input = value;
1724	return (ctxt->inputNr++);
1725	}
1726	/**
1727	* inputPop:
1728	* @ctxt: an XML parser context
1729	*
1730	* Pops the top parser input from the input stack
1731	*
1732	* Returns the input just removed
1733	*/
1734	xmlParserInputPtr
1735	inputPop(xmlParserCtxtPtr ctxt)
1736	{
1737	xmlParserInputPtr ret;
1738
1739	if (ctxt == NULL)
1740	return(NULL);
1741	if (ctxt->inputNr <= 0)
1742	return (NULL);
1743	ctxt->inputNr--;
1744	if (ctxt->inputNr > 0)
1745	ctxt->input = ctxt->inputTab[ctxt->inputNr - 1];
1746	else
1747	ctxt->input = NULL;
1748	ret = ctxt->inputTab[ctxt->inputNr];
1749	ctxt->inputTab[ctxt->inputNr] = NULL;
1750	return (ret);
1751	}
1752	/**
1753	* nodePush:
1754	* @ctxt: an XML parser context
1755	* @value: the element node
1756	*
1757	* Pushes a new element node on top of the node stack
1758	*
1759	* Returns -1 in case of error, the index in the stack otherwise
1760	*/
1761	int
1762	nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value)
1763	{
1764	if (ctxt == NULL) return(0);
1765	if (ctxt->nodeNr >= ctxt->nodeMax) {
1766	xmlNodePtr *tmp;
1767
1768	tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
1769	ctxt->nodeMax * 2 *
1770	sizeof(ctxt->nodeTab[0]));
1771	if (tmp == NULL) {
1772	xmlErrMemory(ctxt, NULL);
1773	return (-1);
1774	}
1775	ctxt->nodeTab = tmp;
1776	ctxt->nodeMax *= 2;
1777	}
1778	if ((((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) &&
1779	((ctxt->options & XML_PARSE_HUGE) == 0)) {
1780	xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
1781	"Excessive depth in document: %d use XML_PARSE_HUGE option\n",
1782	xmlParserMaxDepth);
1783	xmlHaltParser(ctxt);
1784	return(-1);
1785	}
1786	ctxt->nodeTab[ctxt->nodeNr] = value;
1787	ctxt->node = value;
1788	return (ctxt->nodeNr++);
1789	}
1790
1791	/**
1792	* nodePop:
1793	* @ctxt: an XML parser context
1794	*
1795	* Pops the top element node from the node stack
1796	*
1797	* Returns the node just removed
1798	*/
1799	xmlNodePtr
1800	nodePop(xmlParserCtxtPtr ctxt)
1801	{
1802	xmlNodePtr ret;
1803
1804	if (ctxt == NULL) return(NULL);
1805	if (ctxt->nodeNr <= 0)
1806	return (NULL);
1807	ctxt->nodeNr--;
1808	if (ctxt->nodeNr > 0)
1809	ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
1810	else
1811	ctxt->node = NULL;
1812	ret = ctxt->nodeTab[ctxt->nodeNr];
1813	ctxt->nodeTab[ctxt->nodeNr] = NULL;
1814	return (ret);
1815	}
1816
1817	#ifdef LIBXML_PUSH_ENABLED
1818	/**
1819	* nameNsPush:
1820	* @ctxt: an XML parser context
1821	* @value: the element name
1822	* @prefix: the element prefix
1823	* @URI: the element namespace name
1824	*
1825	* Pushes a new element name/prefix/URL on top of the name stack
1826	*
1827	* Returns -1 in case of error, the index in the stack otherwise
1828	*/
1829	static int
1830	nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value,
1831	const xmlChar prefix, const xmlChar URI, int nsNr)
1832	{
1833	if (ctxt->nameNr >= ctxt->nameMax) {
1834	const xmlChar * *tmp;
1835	void **tmp2;
1836	ctxt->nameMax *= 2;
1837	tmp = (const xmlChar * ) xmlRealloc((xmlChar *)ctxt->nameTab,
1838	ctxt->nameMax *
1839	sizeof(ctxt->nameTab[0]));
1840	if (tmp == NULL) {
1841	ctxt->nameMax /= 2;
1842	goto mem_error;
1843	}
1844	ctxt->nameTab = tmp;
1845	tmp2 = (void *) xmlRealloc((void *)ctxt->pushTab,
1846	ctxt->nameMax * 3 *
1847	sizeof(ctxt->pushTab[0]));
1848	if (tmp2 == NULL) {
1849	ctxt->nameMax /= 2;
1850	goto mem_error;
1851	}
1852	ctxt->pushTab = tmp2;
1853	}
1854	ctxt->nameTab[ctxt->nameNr] = value;
1855	ctxt->name = value;
1856	ctxt->pushTab[ctxt->nameNr * 3] = (void *) prefix;
1857	ctxt->pushTab[ctxt->nameNr * 3 + 1] = (void *) URI;
1858	ctxt->pushTab[ctxt->nameNr * 3 + 2] = (void *) (long) nsNr;
1859	return (ctxt->nameNr++);
1860	mem_error:
1861	xmlErrMemory(ctxt, NULL);
1862	return (-1);
1863	}
1864	/**
1865	* nameNsPop:
1866	* @ctxt: an XML parser context
1867	*
1868	* Pops the top element/prefix/URI name from the name stack
1869	*
1870	* Returns the name just removed
1871	*/
1872	static const xmlChar *
1873	nameNsPop(xmlParserCtxtPtr ctxt)
1874	{
1875	const xmlChar *ret;
1876
1877	if (ctxt->nameNr <= 0)
1878	return (NULL);
1879	ctxt->nameNr--;
1880	if (ctxt->nameNr > 0)
1881	ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1882	else
1883	ctxt->name = NULL;
1884	ret = ctxt->nameTab[ctxt->nameNr];
1885	ctxt->nameTab[ctxt->nameNr] = NULL;
1886	return (ret);
1887	}
1888	#endif /* LIBXML_PUSH_ENABLED */
1889
1890	/**
1891	* namePush:
1892	* @ctxt: an XML parser context
1893	* @value: the element name
1894	*
1895	* Pushes a new element name on top of the name stack
1896	*
1897	* Returns -1 in case of error, the index in the stack otherwise
1898	*/
1899	int
1900	namePush(xmlParserCtxtPtr ctxt, const xmlChar * value)
1901	{
1902	if (ctxt == NULL) return (-1);
1903
1904	if (ctxt->nameNr >= ctxt->nameMax) {
1905	const xmlChar * *tmp;
1906	tmp = (const xmlChar * ) xmlRealloc((xmlChar *)ctxt->nameTab,
1907	ctxt->nameMax * 2 *
1908	sizeof(ctxt->nameTab[0]));
1909	if (tmp == NULL) {
1910	goto mem_error;
1911	}
1912	ctxt->nameTab = tmp;
1913	ctxt->nameMax *= 2;
1914	}
1915	ctxt->nameTab[ctxt->nameNr] = value;
1916	ctxt->name = value;
1917	return (ctxt->nameNr++);
1918	mem_error:
1919	xmlErrMemory(ctxt, NULL);
1920	return (-1);
1921	}
1922	/**
1923	* namePop:
1924	* @ctxt: an XML parser context
1925	*
1926	* Pops the top element name from the name stack
1927	*
1928	* Returns the name just removed
1929	*/
1930	const xmlChar *
1931	namePop(xmlParserCtxtPtr ctxt)
1932	{
1933	const xmlChar *ret;
1934
1935	if ((ctxt == NULL) \|\| (ctxt->nameNr <= 0))
1936	return (NULL);
1937	ctxt->nameNr--;
1938	if (ctxt->nameNr > 0)
1939	ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1940	else
1941	ctxt->name = NULL;
1942	ret = ctxt->nameTab[ctxt->nameNr];
1943	ctxt->nameTab[ctxt->nameNr] = NULL;
1944	return (ret);
1945	}
1946
1947	static int spacePush(xmlParserCtxtPtr ctxt, int val) {
1948	if (ctxt->spaceNr >= ctxt->spaceMax) {
1949	int *tmp;
1950
1951	ctxt->spaceMax *= 2;
1952	tmp = (int *) xmlRealloc(ctxt->spaceTab,
1953	ctxt->spaceMax * sizeof(ctxt->spaceTab[0]));
1954	if (tmp == NULL) {
1955	xmlErrMemory(ctxt, NULL);
1956	ctxt->spaceMax /=2;
1957	return(-1);
1958	}
1959	ctxt->spaceTab = tmp;
1960	}
1961	ctxt->spaceTab[ctxt->spaceNr] = val;
1962	ctxt->space = &ctxt->spaceTab[ctxt->spaceNr];
1963	return(ctxt->spaceNr++);
1964	}
1965
1966	static int spacePop(xmlParserCtxtPtr ctxt) {
1967	int ret;
1968	if (ctxt->spaceNr <= 0) return(0);
1969	ctxt->spaceNr--;
1970	if (ctxt->spaceNr > 0)
1971	ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1];
1972	else
1973	ctxt->space = &ctxt->spaceTab[0];
1974	ret = ctxt->spaceTab[ctxt->spaceNr];
1975	ctxt->spaceTab[ctxt->spaceNr] = -1;
1976	return(ret);
1977	}
1978
1979	/*
1980	* Macros for accessing the content. Those should be used only by the parser,
1981	* and not exported.
1982	*
1983	* Dirty macros, i.e. one often need to make assumption on the context to
1984	* use them
1985	*
1986	* CUR_PTR return the current pointer to the xmlChar to be parsed.
1987	* To be used with extreme caution since operations consuming
1988	* characters may move the input buffer to a different location !
1989	* CUR returns the current xmlChar value, i.e. a 8 bit value if compiled
1990	* This should be used internally by the parser
1991	* only to compare to ASCII values otherwise it would break when
1992	* running with UTF-8 encoding.
1993	* RAW same as CUR but in the input buffer, bypass any token
1994	* extraction that may have been done
1995	* NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only
1996	* to compare on ASCII based substring.
1997	* SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
1998	* strings without newlines within the parser.
1999	* NEXT1(l) Skip 1 xmlChar, and must also be used only to skip 1 non-newline ASCII
2000	* defined char within the parser.
2001	* Clean macros, not dependent of an ASCII context, expect UTF-8 encoding
2002	*
2003	* NEXT Skip to the next character, this does the proper decoding
2004	* in UTF-8 mode. It also pop-up unfinished entities on the fly.
2005	* NEXTL(l) Skip the current unicode character of l xmlChars long.
2006	* CUR_CHAR(l) returns the current unicode character (int), set l
2007	* to the number of xmlChars used for the encoding [0-5].
2008	* CUR_SCHAR same but operate on a string instead of the context
2009	* COPY_BUF copy the current unicode char to the target buffer, increment
2010	* the index
2011	* GROW, SHRINK handling of input buffers
2012	*/
2013
2014	#define RAW (*ctxt->input->cur)
2015	#define CUR (*ctxt->input->cur)
2016	#define NXT(val) ctxt->input->cur[(val)]
2017	#define CUR_PTR ctxt->input->cur
2018	#define BASE_PTR ctxt->input->base
2019
2020	#define CMP4( s, c1, c2, c3, c4 ) \
2021	( ((unsigned char ) s)[ 0 ] == c1 && ((unsigned char ) s)[ 1 ] == c2 && \
2022	((unsigned char ) s)[ 2 ] == c3 && ((unsigned char ) s)[ 3 ] == c4 )
2023	#define CMP5( s, c1, c2, c3, c4, c5 ) \
2024	( CMP4( s, c1, c2, c3, c4 ) && ((unsigned char *) s)[ 4 ] == c5 )
2025	#define CMP6( s, c1, c2, c3, c4, c5, c6 ) \
2026	( CMP5( s, c1, c2, c3, c4, c5 ) && ((unsigned char *) s)[ 5 ] == c6 )
2027	#define CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) \
2028	( CMP6( s, c1, c2, c3, c4, c5, c6 ) && ((unsigned char *) s)[ 6 ] == c7 )
2029	#define CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) \
2030	( CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) && ((unsigned char *) s)[ 7 ] == c8 )
2031	#define CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) \
2032	( CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) && \
2033	((unsigned char *) s)[ 8 ] == c9 )
2034	#define CMP10( s, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10 ) \
2035	( CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) && \
2036	((unsigned char *) s)[ 9 ] == c10 )
2037
2038	#define SKIP(val) do { \
2039	ctxt->nbChars += (val),ctxt->input->cur += (val),ctxt->input->col+=(val); \
2040	if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
2041	if ((*ctxt->input->cur == 0) && \
2042	(xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \
2043	xmlPopInput(ctxt); \
2044	} while (0)
2045
2046	#define SKIPL(val) do { \
2047	int skipl; \
2048	for(skipl=0; skipl<val; skipl++) { \
2049	if (*(ctxt->input->cur) == '\n') { \
2050	ctxt->input->line++; ctxt->input->col = 1; \
2051	} else ctxt->input->col++; \
2052	ctxt->nbChars++; \
2053	ctxt->input->cur++; \
2054	} \
2055	if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
2056	if ((*ctxt->input->cur == 0) && \
2057	(xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \
2058	xmlPopInput(ctxt); \
2059	} while (0)
2060
2061	#define SHRINK if ((ctxt->progressive == 0) && \
2062	(ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
2063	(ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
2064	xmlSHRINK (ctxt);
2065
2066	static void xmlSHRINK (xmlParserCtxtPtr ctxt) {
2067	xmlParserInputShrink(ctxt->input);
2068	if ((*ctxt->input->cur == 0) &&
2069	(xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
2070	xmlPopInput(ctxt);
2071	}
2072
2073	#define GROW if ((ctxt->progressive == 0) && \
2074	(ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)) \
2075	xmlGROW (ctxt);
2076
2077	static void xmlGROW (xmlParserCtxtPtr ctxt) {
2078	unsigned long curEnd = ctxt->input->end - ctxt->input->cur;
2079	unsigned long curBase = ctxt->input->cur - ctxt->input->base;
2080
2081	if (((curEnd > (unsigned long) XML_MAX_LOOKUP_LIMIT) \|\|
2082	(curBase > (unsigned long) XML_MAX_LOOKUP_LIMIT)) &&
2083	((ctxt->input->buf) && (ctxt->input->buf->readcallback != (xmlInputReadCallback) xmlNop)) &&
2084	((ctxt->options & XML_PARSE_HUGE) == 0)) {
2085	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "Huge input lookup");
2086	xmlHaltParser(ctxt);
2087	return;
2088	}
2089	xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
2090	if ((ctxt->input->cur > ctxt->input->end) \|\|
2091	(ctxt->input->cur < ctxt->input->base)) {
2092	xmlHaltParser(ctxt);
2093	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "cur index out of bound");
2094	return;
2095	}
2096	if ((ctxt->input->cur != NULL) && (*ctxt->input->cur == 0) &&
2097	(xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
2098	xmlPopInput(ctxt);
2099	}
2100
2101	#define SKIP_BLANKS xmlSkipBlankChars(ctxt)
2102
2103	#define NEXT xmlNextChar(ctxt)
2104
2105	#define NEXT1 { \
2106	ctxt->input->col++; \
2107	ctxt->input->cur++; \
2108	ctxt->nbChars++; \
2109	if (*ctxt->input->cur == 0) \
2110	xmlParserInputGrow(ctxt->input, INPUT_CHUNK); \
2111	}
2112
2113	#define NEXTL(l) do { \
2114	if (*(ctxt->input->cur) == '\n') { \
2115	ctxt->input->line++; ctxt->input->col = 1; \
2116	} else ctxt->input->col++; \
2117	ctxt->input->cur += l; \
2118	if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
2119	} while (0)
2120
2121	#define CUR_CHAR(l) xmlCurrentChar(ctxt, &l)
2122	#define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)
2123
2124	#define COPY_BUF(l,b,i,v) \
2125	if (l == 1) b[i++] = (xmlChar) v; \
2126	else i += xmlCopyCharMultiByte(&b[i],v)
2127
2128	/**
2129	* xmlSkipBlankChars:
2130	* @ctxt: the XML parser context
2131	*
2132	* skip all blanks character found at that point in the input streams.
2133	* It pops up finished entities in the process if allowable at that point.
2134	*
2135	* Returns the number of space chars skipped
2136	*/
2137
2138	int
2139	xmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
2140	int res = 0;
2141
2142	/*
2143	* It's Okay to use CUR/NEXT here since all the blanks are on
2144	* the ASCII range.
2145	*/
2146	if ((ctxt->inputNr == 1) && (ctxt->instate != XML_PARSER_DTD)) {
2147	const xmlChar *cur;
2148	/*
2149	* if we are in the document content, go really fast
2150	*/
2151	cur = ctxt->input->cur;
2152	while (IS_BLANK_CH(*cur)) {
2153	if (*cur == '\n') {
2154	ctxt->input->line++; ctxt->input->col = 1;
2155	} else {
2156	ctxt->input->col++;
2157	}
2158	cur++;
2159	res++;
2160	if (*cur == 0) {
2161	ctxt->input->cur = cur;
2162	xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
2163	cur = ctxt->input->cur;
2164	}
2165	}
2166	ctxt->input->cur = cur;
2167	} else {
2168	int cur;
2169	do {
2170	cur = CUR;
2171	while ((IS_BLANK_CH(cur) && /* CHECKED tstblanks.xml */
2172	(ctxt->instate != XML_PARSER_EOF))) {
2173	NEXT;
2174	cur = CUR;
2175	res++;
2176	}
2177	while ((cur == 0) && (ctxt->inputNr > 1) &&
2178	(ctxt->instate != XML_PARSER_COMMENT)) {
2179	xmlPopInput(ctxt);
2180	cur = CUR;
2181	}
2182	/*
2183	* Need to handle support of entities branching here
2184	*/
2185	if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);
2186	} while ((IS_BLANK(cur)) && /* CHECKED tstblanks.xml */
2187	(ctxt->instate != XML_PARSER_EOF));
2188	}
2189	return(res);
2190	}
2191
2192	/************************************************************************
2193	* *
2194	* Commodity functions to handle entities *
2195	* *
2196	************************************************************************/
2197
2198	/**
2199	* xmlPopInput:
2200	* @ctxt: an XML parser context
2201	*
2202	* xmlPopInput: the current input pointed by ctxt->input came to an end
2203	* pop it and return the next char.
2204	*
2205	* Returns the current xmlChar in the parser context
2206	*/
2207	xmlChar
2208	xmlPopInput(xmlParserCtxtPtr ctxt) {
2209	if ((ctxt == NULL) \|\| (ctxt->inputNr <= 1)) return(0);
2210	if (xmlParserDebugEntities)
2211	xmlGenericError(xmlGenericErrorContext,
2212	"Popping input %d\n", ctxt->inputNr);
2213	xmlFreeInputStream(inputPop(ctxt));
2214	if ((*ctxt->input->cur == 0) &&
2215	(xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
2216	return(xmlPopInput(ctxt));
2217	return(CUR);
2218	}
2219
2220	/**
2221	* xmlPushInput:
2222	* @ctxt: an XML parser context
2223	* @input: an XML parser input fragment (entity, XML fragment ...).
2224	*
2225	* xmlPushInput: switch to a new input stream which is stacked on top
2226	* of the previous one(s).
2227	* Returns -1 in case of error or the index in the input stack
2228	*/
2229	int
2230	xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) {
2231	int ret;
2232	if (input == NULL) return(-1);
2233
2234	if (xmlParserDebugEntities) {
2235	if ((ctxt->input != NULL) && (ctxt->input->filename))
2236	xmlGenericError(xmlGenericErrorContext,
2237	"%s(%d): ", ctxt->input->filename,
2238	ctxt->input->line);
2239	xmlGenericError(xmlGenericErrorContext,
2240	"Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur);
2241	}
2242	ret = inputPush(ctxt, input);
2243	if (ctxt->instate == XML_PARSER_EOF)
2244	return(-1);
2245	GROW;
2246	return(ret);
2247	}
2248
2249	/**
2250	* xmlParseCharRef:
2251	* @ctxt: an XML parser context
2252	*
2253	* parse Reference declarations
2254	*
2255	* [66] CharRef ::= '&#' [0-9]+ ';' \|
2256	* '&#x' [0-9a-fA-F]+ ';'
2257	*
2258	* [ WFC: Legal Character ]
2259	* Characters referred to using character references must match the
2260	* production for Char.
2261	*
2262	* Returns the value parsed (as an int), 0 in case of error
2263	*/
2264	int
2265	xmlParseCharRef(xmlParserCtxtPtr ctxt) {
2266	unsigned int val = 0;
2267	int count = 0;
2268	unsigned int outofrange = 0;
2269
2270	/*
2271	* Using RAW/CUR/NEXT is okay since we are working on ASCII range here
2272	*/
2273	if ((RAW == '&') && (NXT(1) == '#') &&
2274	(NXT(2) == 'x')) {
2275	SKIP(3);
2276	GROW;
2277	while (RAW != ';') { /* loop blocked by count */
2278	if (count++ > 20) {
2279	count = 0;
2280	GROW;
2281	if (ctxt->instate == XML_PARSER_EOF)
2282	return(0);
2283	}
2284	if ((RAW >= '0') && (RAW <= '9'))
2285	val = val * 16 + (CUR - '0');
2286	else if ((RAW >= 'a') && (RAW <= 'f') && (count < 20))
2287	val = val * 16 + (CUR - 'a') + 10;
2288	else if ((RAW >= 'A') && (RAW <= 'F') && (count < 20))
2289	val = val * 16 + (CUR - 'A') + 10;
2290	else {
2291	xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2292	val = 0;
2293	break;
2294	}
2295	if (val > 0x10FFFF)
2296	outofrange = val;
2297
2298	NEXT;
2299	count++;
2300	}
2301	if (RAW == ';') {
2302	/* on purpose to avoid reentrancy problems with NEXT and SKIP */
2303	ctxt->input->col++;
2304	ctxt->nbChars ++;
2305	ctxt->input->cur++;
2306	}
2307	} else if ((RAW == '&') && (NXT(1) == '#')) {
2308	SKIP(2);
2309	GROW;
2310	while (RAW != ';') { /* loop blocked by count */
2311	if (count++ > 20) {
2312	count = 0;
2313	GROW;
2314	if (ctxt->instate == XML_PARSER_EOF)
2315	return(0);
2316	}
2317	if ((RAW >= '0') && (RAW <= '9'))
2318	val = val * 10 + (CUR - '0');
2319	else {
2320	xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2321	val = 0;
2322	break;
2323	}
2324	if (val > 0x10FFFF)
2325	outofrange = val;
2326
2327	NEXT;
2328	count++;
2329	}
2330	if (RAW == ';') {
2331	/* on purpose to avoid reentrancy problems with NEXT and SKIP */
2332	ctxt->input->col++;
2333	ctxt->nbChars ++;
2334	ctxt->input->cur++;
2335	}
2336	} else {
2337	xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2338	}
2339
2340	/*
2341	* [ WFC: Legal Character ]
2342	* Characters referred to using character references must match the
2343	* production for Char.
2344	*/
2345	if ((IS_CHAR(val) && (outofrange == 0))) {
2346	return(val);
2347	} else {
2348	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2349	"xmlParseCharRef: invalid xmlChar value %d\n",
2350	val);
2351	}
2352	return(0);
2353	}
2354
2355	/**
2356	* xmlParseStringCharRef:
2357	* @ctxt: an XML parser context
2358	* @str: a pointer to an index in the string
2359	*
2360	* parse Reference declarations, variant parsing from a string rather
2361	* than an an input flow.
2362	*
2363	* [66] CharRef ::= '&#' [0-9]+ ';' \|
2364	* '&#x' [0-9a-fA-F]+ ';'
2365	*
2366	* [ WFC: Legal Character ]
2367	* Characters referred to using character references must match the
2368	* production for Char.
2369	*
2370	* Returns the value parsed (as an int), 0 in case of error, str will be
2371	* updated to the current value of the index
2372	*/
2373	static int
2374	xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) {
2375	const xmlChar *ptr;
2376	xmlChar cur;
2377	unsigned int val = 0;
2378	unsigned int outofrange = 0;
2379
2380	if ((str == NULL) \|\| (*str == NULL)) return(0);
2381	ptr = *str;
2382	cur = *ptr;
2383	if ((cur == '&') && (ptr[1] == '#') && (ptr[2] == 'x')) {
2384	ptr += 3;
2385	cur = *ptr;
2386	while (cur != ';') { /* Non input consuming loop */
2387	if ((cur >= '0') && (cur <= '9'))
2388	val = val * 16 + (cur - '0');
2389	else if ((cur >= 'a') && (cur <= 'f'))
2390	val = val * 16 + (cur - 'a') + 10;
2391	else if ((cur >= 'A') && (cur <= 'F'))
2392	val = val * 16 + (cur - 'A') + 10;
2393	else {
2394	xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2395	val = 0;
2396	break;
2397	}
2398	if (val > 0x10FFFF)
2399	outofrange = val;
2400
2401	ptr++;
2402	cur = *ptr;
2403	}
2404	if (cur == ';')
2405	ptr++;
2406	} else if ((cur == '&') && (ptr[1] == '#')){
2407	ptr += 2;
2408	cur = *ptr;
2409	while (cur != ';') { /* Non input consuming loops */
2410	if ((cur >= '0') && (cur <= '9'))
2411	val = val * 10 + (cur - '0');
2412	else {
2413	xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2414	val = 0;
2415	break;
2416	}
2417	if (val > 0x10FFFF)
2418	outofrange = val;
2419
2420	ptr++;
2421	cur = *ptr;
2422	}
2423	if (cur == ';')
2424	ptr++;
2425	} else {
2426	xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2427	return(0);
2428	}
2429	*str = ptr;
2430
2431	/*
2432	* [ WFC: Legal Character ]
2433	* Characters referred to using character references must match the
2434	* production for Char.
2435	*/
2436	if ((IS_CHAR(val) && (outofrange == 0))) {
2437	return(val);
2438	} else {
2439	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2440	"xmlParseStringCharRef: invalid xmlChar value %d\n",
2441	val);
2442	}
2443	return(0);
2444	}
2445
2446	/**
2447	* xmlNewBlanksWrapperInputStream:
2448	* @ctxt: an XML parser context
2449	* @entity: an Entity pointer
2450	*
2451	* Create a new input stream for wrapping
2452	* blanks around a PEReference
2453	*
2454	* Returns the new input stream or NULL
2455	*/
2456
2457	static void deallocblankswrapper (xmlChar *str) {xmlFree(str);}
2458
2459	static xmlParserInputPtr
2460	xmlNewBlanksWrapperInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
2461	xmlParserInputPtr input;
2462	xmlChar *buffer;
2463	size_t length;
2464	if (entity == NULL) {
2465	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
2466	"xmlNewBlanksWrapperInputStream entity\n");
2467	return(NULL);
2468	}
2469	if (xmlParserDebugEntities)
2470	xmlGenericError(xmlGenericErrorContext,
2471	"new blanks wrapper for entity: %s\n", entity->name);
2472	input = xmlNewInputStream(ctxt);
2473	if (input == NULL) {
2474	return(NULL);
2475	}
2476	length = xmlStrlen(entity->name) + 5;
2477	buffer = xmlMallocAtomic(length);
2478	if (buffer == NULL) {
2479	xmlErrMemory(ctxt, NULL);
2480	xmlFree(input);
2481	return(NULL);
2482	}
2483	buffer [0] = ' ';
2484	buffer [1] = '%';
2485	buffer [length-3] = ';';
2486	buffer [length-2] = ' ';
2487	buffer [length-1] = 0;
2488	memcpy(buffer + 2, entity->name, length - 5);
2489	input->free = deallocblankswrapper;
2490	input->base = buffer;
2491	input->cur = buffer;
2492	input->length = length;
2493	input->end = &buffer[length];
2494	return(input);
2495	}
2496
2497	/**
2498	* xmlParserHandlePEReference:
2499	* @ctxt: the parser context
2500	*
2501	* [69] PEReference ::= '%' Name ';'
2502	*
2503	* [ WFC: No Recursion ]
2504	* A parsed entity must not contain a recursive
2505	* reference to itself, either directly or indirectly.
2506	*
2507	* [ WFC: Entity Declared ]
2508	* In a document without any DTD, a document with only an internal DTD
2509	* subset which contains no parameter entity references, or a document
2510	* with "standalone='yes'", ... ... The declaration of a parameter
2511	* entity must precede any reference to it...
2512	*
2513	* [ VC: Entity Declared ]
2514	* In a document with an external subset or external parameter entities
2515	* with "standalone='no'", ... ... The declaration of a parameter entity
2516	* must precede any reference to it...
2517	*
2518	* [ WFC: In DTD ]
2519	* Parameter-entity references may only appear in the DTD.
2520	* NOTE: misleading but this is handled.
2521	*
2522	* A PEReference may have been detected in the current input stream
2523	* the handling is done accordingly to
2524	* http://www.w3.org/TR/REC-xml#entproc
2525	* i.e.
2526	* - Included in literal in entity values
2527	* - Included as Parameter Entity reference within DTDs
2528	*/
2529	void
2530	xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) {
2531	const xmlChar *name;
2532	xmlEntityPtr entity = NULL;
2533	xmlParserInputPtr input;
2534
2535	if (RAW != '%') return;
2536	switch(ctxt->instate) {
2537	case XML_PARSER_CDATA_SECTION:
2538	return;
2539	case XML_PARSER_COMMENT:
2540	return;
2541	case XML_PARSER_START_TAG:
2542	return;
2543	case XML_PARSER_END_TAG:
2544	return;
2545	case XML_PARSER_EOF:
2546	xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL);
2547	return;
2548	case XML_PARSER_PROLOG:
2549	case XML_PARSER_START:
2550	case XML_PARSER_MISC:
2551	xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL);
2552	return;
2553	case XML_PARSER_ENTITY_DECL:
2554	case XML_PARSER_CONTENT:
2555	case XML_PARSER_ATTRIBUTE_VALUE:
2556	case XML_PARSER_PI:
2557	case XML_PARSER_SYSTEM_LITERAL:
2558	case XML_PARSER_PUBLIC_LITERAL:
2559	/* we just ignore it there */
2560	return;
2561	case XML_PARSER_EPILOG:
2562	xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL);
2563	return;
2564	case XML_PARSER_ENTITY_VALUE:
2565	/*
2566	* NOTE: in the case of entity values, we don't do the
2567	* substitution here since we need the literal
2568	* entity value to be able to save the internal
2569	* subset of the document.
2570	* This will be handled by xmlStringDecodeEntities
2571	*/
2572	return;
2573	case XML_PARSER_DTD:
2574	/*
2575	* [WFC: Well-Formedness Constraint: PEs in Internal Subset]
2576	* In the internal DTD subset, parameter-entity references
2577	* can occur only where markup declarations can occur, not
2578	* within markup declarations.
2579	* In that case this is handled in xmlParseMarkupDecl
2580	*/
2581	if ((ctxt->external == 0) && (ctxt->inputNr == 1))
2582	return;
2583	if (IS_BLANK_CH(NXT(1)) \|\| NXT(1) == 0)
2584	return;
2585	break;
2586	case XML_PARSER_IGNORE:
2587	return;
2588	}
2589
2590	NEXT;
2591	name = xmlParseName(ctxt);
2592	if (xmlParserDebugEntities)
2593	xmlGenericError(xmlGenericErrorContext,
2594	"PEReference: %s\n", name);
2595	if (name == NULL) {
2596	xmlFatalErr(ctxt, XML_ERR_PEREF_NO_NAME, NULL);
2597	} else {
2598	if (RAW == ';') {
2599	NEXT;
2600	if ((ctxt->sax != NULL) && (ctxt->sax->getParameterEntity != NULL))
2601	entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
2602	if (ctxt->instate == XML_PARSER_EOF)
2603	return;
2604	if (entity == NULL) {
2605
2606	/*
2607	* [ WFC: Entity Declared ]
2608	* In a document without any DTD, a document with only an
2609	* internal DTD subset which contains no parameter entity
2610	* references, or a document with "standalone='yes'", ...
2611	* ... The declaration of a parameter entity must precede
2612	* any reference to it...
2613	*/
2614	if ((ctxt->standalone == 1) \|\|
2615	((ctxt->hasExternalSubset == 0) &&
2616	(ctxt->hasPErefs == 0))) {
2617	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
2618	"PEReference: %%%s; not found\n", name);
2619	} else {
2620	/*
2621	* [ VC: Entity Declared ]
2622	* In a document with an external subset or external
2623	* parameter entities with "standalone='no'", ...
2624	* ... The declaration of a parameter entity must precede
2625	* any reference to it...
2626	*/
2627	if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) {
2628	xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
2629	"PEReference: %%%s; not found\n",
2630	name, NULL);
2631	} else
2632	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
2633	"PEReference: %%%s; not found\n",
2634	name, NULL);
2635	ctxt->valid = 0;
2636	}
2637	xmlParserEntityCheck(ctxt, 0, NULL, 0);
2638	} else if (ctxt->input->free != deallocblankswrapper) {
2639	input = xmlNewBlanksWrapperInputStream(ctxt, entity);
2640	if (xmlPushInput(ctxt, input) < 0)
2641	return;
2642	} else {
2643	if ((entity->etype == XML_INTERNAL_PARAMETER_ENTITY) \|\|
2644	(entity->etype == XML_EXTERNAL_PARAMETER_ENTITY)) {
2645	xmlChar start[4];
2646	xmlCharEncoding enc;
2647
2648	/*
2649	* Note: external parameter entities will not be loaded, it
2650	* is not required for a non-validating parser, unless the
2651	* option of validating, or substituting entities were
2652	* given. Doing so is far more secure as the parser will
2653	* only process data coming from the document entity by
2654	* default.
2655	*/
2656	if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
2657	((ctxt->options & XML_PARSE_NOENT) == 0) &&
2658	((ctxt->options & XML_PARSE_DTDVALID) == 0) &&
2659	((ctxt->options & XML_PARSE_DTDLOAD) == 0) &&
2660	((ctxt->options & XML_PARSE_DTDATTR) == 0) &&
2661	(ctxt->replaceEntities == 0) &&
2662	(ctxt->validate == 0))
2663	return;
2664
2665	/*
2666	* handle the extra spaces added before and after
2667	* c.f. http://www.w3.org/TR/REC-xml#as-PE
2668	* this is done independently.
2669	*/
2670	input = xmlNewEntityInputStream(ctxt, entity);
2671	if (xmlPushInput(ctxt, input) < 0)
2672	return;
2673
2674	/*
2675	* Get the 4 first bytes and decode the charset
2676	* if enc != XML_CHAR_ENCODING_NONE
2677	* plug some encoding conversion routines.
2678	* Note that, since we may have some non-UTF8
2679	* encoding (like UTF16, bug 135229), the 'length'
2680	* is not known, but we can calculate based upon
2681	* the amount of data in the buffer.
2682	*/
2683	GROW
2684	if (ctxt->instate == XML_PARSER_EOF)
2685	return;
2686	if ((ctxt->input->end - ctxt->input->cur)>=4) {
2687	start[0] = RAW;
2688	start[1] = NXT(1);
2689	start[2] = NXT(2);
2690	start[3] = NXT(3);
2691	enc = xmlDetectCharEncoding(start, 4);
2692	if (enc != XML_CHAR_ENCODING_NONE) {
2693	xmlSwitchEncoding(ctxt, enc);
2694	}
2695	}
2696
2697	if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
2698	(CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l' )) &&
2699	(IS_BLANK_CH(NXT(5)))) {
2700	xmlParseTextDecl(ctxt);
2701	}
2702	} else {
2703	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
2704	"PEReference: %s is not a parameter entity\n",
2705	name);
2706	}
2707	}
2708	} else {
2709	xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
2710	}
2711	}
2712	}
2713
2714	/*
2715	* Macro used to grow the current buffer.
2716	* buffer##_size is expected to be a size_t
2717	* mem_error: is expected to handle memory allocation failures
2718	*/
2719	#define growBuffer(buffer, n) { \
2720	xmlChar *tmp; \
2721	size_t new_size = buffer##_size * 2 + n; \
2722	if (new_size < buffer##_size) goto mem_error; \
2723	tmp = (xmlChar *) xmlRealloc(buffer, new_size); \
2724	if (tmp == NULL) goto mem_error; \
2725	buffer = tmp; \
2726	buffer##_size = new_size; \
2727	}
2728
2729	/**
2730	* xmlStringLenDecodeEntities:
2731	* @ctxt: the parser context
2732	* @str: the input string
2733	* @len: the string length
2734	* @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
2735	* @end: an end marker xmlChar, 0 if none
2736	* @end2: an end marker xmlChar, 0 if none
2737	* @end3: an end marker xmlChar, 0 if none
2738	*
2739	* Takes a entity string content and process to do the adequate substitutions.
2740	*
2741	* [67] Reference ::= EntityRef \| CharRef
2742	*
2743	* [69] PEReference ::= '%' Name ';'
2744	*
2745	* Returns A newly allocated string with the substitution done. The caller
2746	* must deallocate it !
2747	*/
2748	xmlChar *
2749	xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2750	int what, xmlChar end, xmlChar end2, xmlChar end3) {
2751	xmlChar *buffer = NULL;
2752	size_t buffer_size = 0;
2753	size_t nbchars = 0;
2754
2755	xmlChar *current = NULL;
2756	xmlChar *rep = NULL;
2757	const xmlChar *last;
2758	xmlEntityPtr ent;
2759	int c,l;
2760
2761	if ((ctxt == NULL) \|\| (str == NULL) \|\| (len < 0))
2762	return(NULL);
2763	last = str + len;
2764
2765	if (((ctxt->depth > 40) &&
2766	((ctxt->options & XML_PARSE_HUGE) == 0)) \|\|
2767	(ctxt->depth > 1024)) {
2768	xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
2769	return(NULL);
2770	}
2771
2772	/*
2773	* allocate a translation buffer.
2774	*/
2775	buffer_size = XML_PARSER_BIG_BUFFER_SIZE;
2776	buffer = (xmlChar *) xmlMallocAtomic(buffer_size);
2777	if (buffer == NULL) goto mem_error;
2778
2779	/*
2780	* OK loop until we reach one of the ending char or a size limit.
2781	* we are operating on already parsed values.
2782	*/
2783	if (str < last)
2784	c = CUR_SCHAR(str, l);
2785	else
2786	c = 0;
2787	while ((c != 0) && (c != end) && /* non input consuming loop */
2788	(c != end2) && (c != end3)) {
2789
2790	if (c == 0) break;
2791	if ((c == '&') && (str[1] == '#')) {
2792	int val = xmlParseStringCharRef(ctxt, &str);
2793	if (val != 0) {
2794	COPY_BUF(0,buffer,nbchars,val);
2795	}
2796	if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
2797	growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2798	}
2799	} else if ((c == '&') && (what & XML_SUBSTITUTE_REF)) {
2800	if (xmlParserDebugEntities)
2801	xmlGenericError(xmlGenericErrorContext,
2802	"String decoding Entity Reference: %.30s\n",
2803	str);
2804	ent = xmlParseStringEntityRef(ctxt, &str);
2805	if ((ctxt->lastError.code == XML_ERR_ENTITY_LOOP) \|\|
2806	(ctxt->lastError.code == XML_ERR_INTERNAL_ERROR))
2807	goto int_error;
2808	xmlParserEntityCheck(ctxt, 0, ent, 0);
2809	if (ent != NULL)
2810	ctxt->nbentities += ent->checked / 2;
2811	if ((ent != NULL) &&
2812	(ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
2813	if (ent->content != NULL) {
2814	COPY_BUF(0,buffer,nbchars,ent->content[0]);
2815	if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
2816	growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2817	}
2818	} else {
2819	xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
2820	"predefined entity has no content\n");
2821	}
2822	} else if ((ent != NULL) && (ent->content != NULL)) {
2823	ctxt->depth++;
2824	rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2825	0, 0, 0);
2826	ctxt->depth--;
2827
2828	if ((ctxt->lastError.code == XML_ERR_ENTITY_LOOP) \|\|
2829	(ctxt->lastError.code == XML_ERR_INTERNAL_ERROR))
2830	goto int_error;
2831
2832	if (rep != NULL) {
2833	current = rep;
2834	while (current != 0) { / non input consuming loop */
2835	buffer[nbchars++] = *current++;
2836	if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
2837	if (xmlParserEntityCheck(ctxt, nbchars, ent, 0))
2838	goto int_error;
2839	growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2840	}
2841	}
2842	xmlFree(rep);
2843	rep = NULL;
2844	}
2845	} else if (ent != NULL) {
2846	int i = xmlStrlen(ent->name);
2847	const xmlChar *cur = ent->name;
2848
2849	buffer[nbchars++] = '&';
2850	if (nbchars + i + XML_PARSER_BUFFER_SIZE > buffer_size) {
2851	growBuffer(buffer, i + XML_PARSER_BUFFER_SIZE);
2852	}
2853	for (;i > 0;i--)
2854	buffer[nbchars++] = *cur++;
2855	buffer[nbchars++] = ';';
2856	}
2857	} else if (c == '%' && (what & XML_SUBSTITUTE_PEREF)) {
2858	if (xmlParserDebugEntities)
2859	xmlGenericError(xmlGenericErrorContext,
2860	"String decoding PE Reference: %.30s\n", str);
2861	ent = xmlParseStringPEReference(ctxt, &str);
2862	if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
2863	goto int_error;
2864	xmlParserEntityCheck(ctxt, 0, ent, 0);
2865	if (ent != NULL)
2866	ctxt->nbentities += ent->checked / 2;
2867	if (ent != NULL) {
2868	if (ent->content == NULL) {
2869	/*
2870	* Note: external parsed entities will not be loaded,
2871	* it is not required for a non-validating parser to
2872	* complete external PEreferences coming from the
2873	* internal subset
2874	*/
2875	if (((ctxt->options & XML_PARSE_NOENT) != 0) \|\|
2876	((ctxt->options & XML_PARSE_DTDVALID) != 0) \|\|
2877	(ctxt->validate != 0)) {
2878	xmlLoadEntityContent(ctxt, ent);
2879	} else {
2880	xmlWarningMsg(ctxt, XML_ERR_ENTITY_PROCESSING,
2881	"not validating will not read content for PE entity %s\n",
2882	ent->name, NULL);
2883	}
2884	}
2885	ctxt->depth++;
2886	rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2887	0, 0, 0);
2888	ctxt->depth--;
2889	if (rep != NULL) {
2890	current = rep;
2891	while (current != 0) { / non input consuming loop */
2892	buffer[nbchars++] = *current++;
2893	if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
2894	if (xmlParserEntityCheck(ctxt, nbchars, ent, 0))
2895	goto int_error;
2896	growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2897	}
2898	}
2899	xmlFree(rep);
2900	rep = NULL;
2901	}
2902	}
2903	} else {
2904	COPY_BUF(l,buffer,nbchars,c);
2905	str += l;
2906	if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
2907	growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2908	}
2909	}
2910	if (str < last)
2911	c = CUR_SCHAR(str, l);
2912	else
2913	c = 0;
2914	}
2915	buffer[nbchars] = 0;
2916	return(buffer);
2917
2918	mem_error:
2919	xmlErrMemory(ctxt, NULL);
2920	int_error:
2921	if (rep != NULL)
2922	xmlFree(rep);
2923	if (buffer != NULL)
2924	xmlFree(buffer);
2925	return(NULL);
2926	}
2927
2928	/**
2929	* xmlStringDecodeEntities:
2930	* @ctxt: the parser context
2931	* @str: the input string
2932	* @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
2933	* @end: an end marker xmlChar, 0 if none
2934	* @end2: an end marker xmlChar, 0 if none
2935	* @end3: an end marker xmlChar, 0 if none
2936	*
2937	* Takes a entity string content and process to do the adequate substitutions.
2938	*
2939	* [67] Reference ::= EntityRef \| CharRef
2940	*
2941	* [69] PEReference ::= '%' Name ';'
2942	*
2943	* Returns A newly allocated string with the substitution done. The caller
2944	* must deallocate it !
2945	*/
2946	xmlChar *
2947	xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what,
2948	xmlChar end, xmlChar end2, xmlChar end3) {
2949	if ((ctxt == NULL) \|\| (str == NULL)) return(NULL);
2950	return(xmlStringLenDecodeEntities(ctxt, str, xmlStrlen(str), what,
2951	end, end2, end3));
2952	}
2953
2954	/************************************************************************
2955	* *
2956	* Commodity functions, cleanup needed ? *
2957	* *
2958	************************************************************************/
2959
2960	/**
2961	* areBlanks:
2962	* @ctxt: an XML parser context
2963	* @str: a xmlChar *
2964	* @len: the size of @str
2965	* @blank_chars: we know the chars are blanks
2966	*
2967	* Is this a sequence of blank chars that one can ignore ?
2968	*
2969	* Returns 1 if ignorable 0 otherwise.
2970	*/
2971
2972	static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2973	int blank_chars) {
2974	int i, ret;
2975	xmlNodePtr lastChild;
2976
2977	/*
2978	* Don't spend time trying to differentiate them, the same callback is
2979	* used !
2980	*/
2981	if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters)
2982	return(0);
2983
2984	/*
2985	* Check for xml:space value.
2986	*/
2987	if ((ctxt->space == NULL) \|\| (*(ctxt->space) == 1) \|\|
2988	(*(ctxt->space) == -2))
2989	return(0);
2990
2991	/*
2992	* Check that the string is made of blanks
2993	*/
2994	if (blank_chars == 0) {
2995	for (i = 0;i < len;i++)
2996	if (!(IS_BLANK_CH(str[i]))) return(0);
2997	}
2998
2999	/*
3000	* Look if the element is mixed content in the DTD if available
3001	*/
3002	if (ctxt->node == NULL) return(0);
3003	if (ctxt->myDoc != NULL) {
3004	ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name);
3005	if (ret == 0) return(1);
3006	if (ret == 1) return(0);
3007	}
3008
3009	/*
3010	* Otherwise, heuristic :-\
3011	*/
3012	if ((RAW != '<') && (RAW != 0xD)) return(0);
3013	if ((ctxt->node->children == NULL) &&
3014	(RAW == '<') && (NXT(1) == '/')) return(0);
3015
3016	lastChild = xmlGetLastChild(ctxt->node);
3017	if (lastChild == NULL) {
3018	if ((ctxt->node->type != XML_ELEMENT_NODE) &&
3019	(ctxt->node->content != NULL)) return(0);
3020	} else if (xmlNodeIsText(lastChild))
3021	return(0);
3022	else if ((ctxt->node->children != NULL) &&
3023	(xmlNodeIsText(ctxt->node->children)))
3024	return(0);
3025	return(1);
3026	}
3027
3028	/************************************************************************
3029	* *
3030	* Extra stuff for namespace support *
3031	* Relates to http://www.w3.org/TR/WD-xml-names *
3032	* *
3033	************************************************************************/
3034
3035	/**
3036	* xmlSplitQName:
3037	* @ctxt: an XML parser context
3038	* @name: an XML parser context
3039	* @prefix: a xmlChar **
3040	*
3041	* parse an UTF8 encoded XML qualified name string
3042	*
3043	* [NS 5] QName ::= (Prefix ':')? LocalPart
3044	*
3045	* [NS 6] Prefix ::= NCName
3046	*
3047	* [NS 7] LocalPart ::= NCName
3048	*
3049	* Returns the local part, and prefix is updated
3050	* to get the Prefix if any.
3051	*/
3052
3053	xmlChar *
3054	xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar name, xmlChar *prefix) {
3055	xmlChar buf[XML_MAX_NAMELEN + 5];
3056	xmlChar *buffer = NULL;
3057	int len = 0;
3058	int max = XML_MAX_NAMELEN;
3059	xmlChar *ret = NULL;
3060	const xmlChar *cur = name;
3061	int c;
3062
3063	if (prefix == NULL) return(NULL);
3064	*prefix = NULL;
3065
3066	if (cur == NULL) return(NULL);
3067
3068	#ifndef XML_XML_NAMESPACE
3069	/* xml: prefix is not really a namespace */
3070	if ((cur[0] == 'x') && (cur[1] == 'm') &&
3071	(cur[2] == 'l') && (cur[3] == ':'))
3072	return(xmlStrdup(name));
3073	#endif
3074
3075	/* nasty but well=formed */
3076	if (cur[0] == ':')
3077	return(xmlStrdup(name));
3078
3079	c = *cur++;
3080	while ((c != 0) && (c != ':') && (len < max)) { /* tested bigname.xml */
3081	buf[len++] = c;
3082	c = *cur++;
3083	}
3084	if (len >= max) {
3085	/*
3086	* Okay someone managed to make a huge name, so he's ready to pay
3087	* for the processing speed.
3088	*/
3089	max = len * 2;
3090
3091	buffer = (xmlChar ) xmlMallocAtomic(max sizeof(xmlChar));
3092	if (buffer == NULL) {
3093	xmlErrMemory(ctxt, NULL);
3094	return(NULL);
3095	}
3096	memcpy(buffer, buf, len);
3097	while ((c != 0) && (c != ':')) { /* tested bigname.xml */
3098	if (len + 10 > max) {
3099	xmlChar *tmp;
3100
3101	max *= 2;
3102	tmp = (xmlChar *) xmlRealloc(buffer,
3103	max * sizeof(xmlChar));
3104	if (tmp == NULL) {
3105	xmlFree(buffer);
3106	xmlErrMemory(ctxt, NULL);
3107	return(NULL);
3108	}
3109	buffer = tmp;
3110	}
3111	buffer[len++] = c;
3112	c = *cur++;
3113	}
3114	buffer[len] = 0;
3115	}
3116
3117	if ((c == ':') && (*cur == 0)) {
3118	if (buffer != NULL)
3119	xmlFree(buffer);
3120	*prefix = NULL;
3121	return(xmlStrdup(name));
3122	}
3123
3124	if (buffer == NULL)
3125	ret = xmlStrndup(buf, len);
3126	else {
3127	ret = buffer;
3128	buffer = NULL;
3129	max = XML_MAX_NAMELEN;
3130	}
3131
3132
3133	if (c == ':') {
3134	c = *cur;
3135	*prefix = ret;
3136	if (c == 0) {
3137	return(xmlStrndup(BAD_CAST "", 0));
3138	}
3139	len = 0;
3140
3141	/*
3142	* Check that the first character is proper to start
3143	* a new name
3144	*/
3145	if (!(((c >= 0x61) && (c <= 0x7A)) \|\|
3146	((c >= 0x41) && (c <= 0x5A)) \|\|
3147	(c == '_') \|\| (c == ':'))) {
3148	int l;
3149	int first = CUR_SCHAR(cur, l);
3150
3151	if (!IS_LETTER(first) && (first != '_')) {
3152	xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME,
3153	"Name %s is not XML Namespace compliant\n",
3154	name);
3155	}
3156	}
3157	cur++;
3158
3159	while ((c != 0) && (len < max)) { /* tested bigname2.xml */
3160	buf[len++] = c;
3161	c = *cur++;
3162	}
3163	if (len >= max) {
3164	/*
3165	* Okay someone managed to make a huge name, so he's ready to pay
3166	* for the processing speed.
3167	*/
3168	max = len * 2;
3169
3170	buffer = (xmlChar ) xmlMallocAtomic(max sizeof(xmlChar));
3171	if (buffer == NULL) {
3172	xmlErrMemory(ctxt, NULL);
3173	return(NULL);
3174	}
3175	memcpy(buffer, buf, len);
3176	while (c != 0) { /* tested bigname2.xml */
3177	if (len + 10 > max) {
3178	xmlChar *tmp;
3179
3180	max *= 2;
3181	tmp = (xmlChar *) xmlRealloc(buffer,
3182	max * sizeof(xmlChar));
3183	if (tmp == NULL) {
3184	xmlErrMemory(ctxt, NULL);
3185	xmlFree(buffer);
3186	return(NULL);
3187	}
3188	buffer = tmp;
3189	}
3190	buffer[len++] = c;
3191	c = *cur++;
3192	}
3193	buffer[len] = 0;
3194	}
3195
3196	if (buffer == NULL)
3197	ret = xmlStrndup(buf, len);
3198	else {
3199	ret = buffer;
3200	}
3201	}
3202
3203	return(ret);
3204	}
3205
3206	/************************************************************************
3207	* *
3208	* The parser itself *
3209	* Relates to http://www.w3.org/TR/REC-xml *
3210	* *
3211	************************************************************************/
3212
3213	/************************************************************************
3214	* *
3215	* Routines to parse Name, NCName and NmToken *
3216	* *
3217	************************************************************************/
3218	#ifdef DEBUG
3219	static unsigned long nbParseName = 0;
3220	static unsigned long nbParseNmToken = 0;
3221	static unsigned long nbParseNCName = 0;
3222	static unsigned long nbParseNCNameComplex = 0;
3223	static unsigned long nbParseNameComplex = 0;
3224	static unsigned long nbParseStringName = 0;
3225	#endif
3226
3227	/*
3228	* The two following functions are related to the change of accepted
3229	* characters for Name and NmToken in the Revision 5 of XML-1.0
3230	* They correspond to the modified production [4] and the new production [4a]
3231	* changes in that revision. Also note that the macros used for the
3232	* productions Letter, Digit, CombiningChar and Extender are not needed
3233	* anymore.
3234	* We still keep compatibility to pre-revision5 parsing semantic if the
3235	* new XML_PARSE_OLD10 option is given to the parser.
3236	*/
3237	static int
3238	xmlIsNameStartChar(xmlParserCtxtPtr ctxt, int c) {
3239	if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3240	/*
3241	* Use the new checks of production [4] [4a] amd [5] of the
3242	* Update 5 of XML-1.0
3243	*/
3244	if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
3245	(((c >= 'a') && (c <= 'z')) \|\|
3246	((c >= 'A') && (c <= 'Z')) \|\|
3247	(c == '_') \|\| (c == ':') \|\|
3248	((c >= 0xC0) && (c <= 0xD6)) \|\|
3249	((c >= 0xD8) && (c <= 0xF6)) \|\|
3250	((c >= 0xF8) && (c <= 0x2FF)) \|\|
3251	((c >= 0x370) && (c <= 0x37D)) \|\|
3252	((c >= 0x37F) && (c <= 0x1FFF)) \|\|
3253	((c >= 0x200C) && (c <= 0x200D)) \|\|
3254	((c >= 0x2070) && (c <= 0x218F)) \|\|
3255	((c >= 0x2C00) && (c <= 0x2FEF)) \|\|
3256	((c >= 0x3001) && (c <= 0xD7FF)) \|\|
3257	((c >= 0xF900) && (c <= 0xFDCF)) \|\|
3258	((c >= 0xFDF0) && (c <= 0xFFFD)) \|\|
3259	((c >= 0x10000) && (c <= 0xEFFFF))))
3260	return(1);
3261	} else {
3262	if (IS_LETTER(c) \|\| (c == '_') \|\| (c == ':'))
3263	return(1);
3264	}
3265	return(0);
3266	}
3267
3268	static int
3269	xmlIsNameChar(xmlParserCtxtPtr ctxt, int c) {
3270	if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3271	/*
3272	* Use the new checks of production [4] [4a] amd [5] of the
3273	* Update 5 of XML-1.0
3274	*/
3275	if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
3276	(((c >= 'a') && (c <= 'z')) \|\|
3277	((c >= 'A') && (c <= 'Z')) \|\|
3278	((c >= '0') && (c <= '9')) \|\| /* !start */
3279	(c == '_') \|\| (c == ':') \|\|
3280	(c == '-') \|\| (c == '.') \|\| (c == 0xB7) \|\| /* !start */
3281	((c >= 0xC0) && (c <= 0xD6)) \|\|
3282	((c >= 0xD8) && (c <= 0xF6)) \|\|
3283	((c >= 0xF8) && (c <= 0x2FF)) \|\|
3284	((c >= 0x300) && (c <= 0x36F)) \|\| /* !start */
3285	((c >= 0x370) && (c <= 0x37D)) \|\|
3286	((c >= 0x37F) && (c <= 0x1FFF)) \|\|
3287	((c >= 0x200C) && (c <= 0x200D)) \|\|
3288	((c >= 0x203F) && (c <= 0x2040)) \|\| /* !start */
3289	((c >= 0x2070) && (c <= 0x218F)) \|\|
3290	((c >= 0x2C00) && (c <= 0x2FEF)) \|\|
3291	((c >= 0x3001) && (c <= 0xD7FF)) \|\|
3292	((c >= 0xF900) && (c <= 0xFDCF)) \|\|
3293	((c >= 0xFDF0) && (c <= 0xFFFD)) \|\|
3294	((c >= 0x10000) && (c <= 0xEFFFF))))
3295	return(1);
3296	} else {
3297	if ((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\|
3298	(c == '.') \|\| (c == '-') \|\|
3299	(c == '_') \|\| (c == ':') \|\|
3300	(IS_COMBINING(c)) \|\|
3301	(IS_EXTENDER(c)))
3302	return(1);
3303	}
3304	return(0);
3305	}
3306
3307	static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt,
3308	int len, int alloc, int normalize);
3309
3310	static const xmlChar *
3311	xmlParseNameComplex(xmlParserCtxtPtr ctxt) {
3312	int len = 0, l;
3313	int c;
3314	int count = 0;
3315
3316	#ifdef DEBUG
3317	nbParseNameComplex++;
3318	#endif
3319
3320	/*
3321	* Handler for more complex cases
3322	*/
3323	GROW;
3324	if (ctxt->instate == XML_PARSER_EOF)
3325	return(NULL);
3326	c = CUR_CHAR(l);
3327	if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3328	/*
3329	* Use the new checks of production [4] [4a] amd [5] of the
3330	* Update 5 of XML-1.0
3331	*/
3332	if ((c == ' ') \|\| (c == '>') \|\| (c == '/') \|\| /* accelerators */
3333	(!(((c >= 'a') && (c <= 'z')) \|\|
3334	((c >= 'A') && (c <= 'Z')) \|\|
3335	(c == '_') \|\| (c == ':') \|\|
3336	((c >= 0xC0) && (c <= 0xD6)) \|\|
3337	((c >= 0xD8) && (c <= 0xF6)) \|\|
3338	((c >= 0xF8) && (c <= 0x2FF)) \|\|
3339	((c >= 0x370) && (c <= 0x37D)) \|\|
3340	((c >= 0x37F) && (c <= 0x1FFF)) \|\|
3341	((c >= 0x200C) && (c <= 0x200D)) \|\|
3342	((c >= 0x2070) && (c <= 0x218F)) \|\|
3343	((c >= 0x2C00) && (c <= 0x2FEF)) \|\|
3344	((c >= 0x3001) && (c <= 0xD7FF)) \|\|
3345	((c >= 0xF900) && (c <= 0xFDCF)) \|\|
3346	((c >= 0xFDF0) && (c <= 0xFFFD)) \|\|
3347	((c >= 0x10000) && (c <= 0xEFFFF))))) {
3348	return(NULL);
3349	}
3350	len += l;
3351	NEXTL(l);
3352	c = CUR_CHAR(l);
3353	while ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
3354	(((c >= 'a') && (c <= 'z')) \|\|
3355	((c >= 'A') && (c <= 'Z')) \|\|
3356	((c >= '0') && (c <= '9')) \|\| /* !start */
3357	(c == '_') \|\| (c == ':') \|\|
3358	(c == '-') \|\| (c == '.') \|\| (c == 0xB7) \|\| /* !start */
3359	((c >= 0xC0) && (c <= 0xD6)) \|\|
3360	((c >= 0xD8) && (c <= 0xF6)) \|\|
3361	((c >= 0xF8) && (c <= 0x2FF)) \|\|
3362	((c >= 0x300) && (c <= 0x36F)) \|\| /* !start */
3363	((c >= 0x370) && (c <= 0x37D)) \|\|
3364	((c >= 0x37F) && (c <= 0x1FFF)) \|\|
3365	((c >= 0x200C) && (c <= 0x200D)) \|\|
3366	((c >= 0x203F) && (c <= 0x2040)) \|\| /* !start */
3367	((c >= 0x2070) && (c <= 0x218F)) \|\|
3368	((c >= 0x2C00) && (c <= 0x2FEF)) \|\|
3369	((c >= 0x3001) && (c <= 0xD7FF)) \|\|
3370	((c >= 0xF900) && (c <= 0xFDCF)) \|\|
3371	((c >= 0xFDF0) && (c <= 0xFFFD)) \|\|
3372	((c >= 0x10000) && (c <= 0xEFFFF))
3373	)) {
3374	if (count++ > XML_PARSER_CHUNK_SIZE) {
3375	count = 0;
3376	GROW;
3377	if (ctxt->instate == XML_PARSER_EOF)
3378	return(NULL);
3379	}
3380	len += l;
3381	NEXTL(l);
3382	c = CUR_CHAR(l);
3383	}
3384	} else {
3385	if ((c == ' ') \|\| (c == '>') \|\| (c == '/') \|\| /* accelerators */
3386	(!IS_LETTER(c) && (c != '_') &&
3387	(c != ':'))) {
3388	return(NULL);
3389	}
3390	len += l;
3391	NEXTL(l);
3392	c = CUR_CHAR(l);
3393
3394	while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
3395	((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\|
3396	(c == '.') \|\| (c == '-') \|\|
3397	(c == '_') \|\| (c == ':') \|\|
3398	(IS_COMBINING(c)) \|\|
3399	(IS_EXTENDER(c)))) {
3400	if (count++ > XML_PARSER_CHUNK_SIZE) {
3401	count = 0;
3402	GROW;
3403	if (ctxt->instate == XML_PARSER_EOF)
3404	return(NULL);
3405	}
3406	len += l;
3407	NEXTL(l);
3408	c = CUR_CHAR(l);
3409	if (c == 0) {
3410	count = 0;
3411	GROW;
3412	if (ctxt->instate == XML_PARSER_EOF)
3413	return(NULL);
3414	c = CUR_CHAR(l);
3415	}
3416	}
3417	}
3418	if ((len > XML_MAX_NAME_LENGTH) &&
3419	((ctxt->options & XML_PARSE_HUGE) == 0)) {
3420	xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name");
3421	return(NULL);
3422	}
3423	if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r'))
3424	return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len));
3425	return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
3426	}
3427
3428	/**
3429	* xmlParseName:
3430	* @ctxt: an XML parser context
3431	*
3432	* parse an XML name.
3433	*
3434	* [4] NameChar ::= Letter \| Digit \| '.' \| '-' \| '_' \| ':' \|
3435	* CombiningChar \| Extender
3436	*
3437	* [5] Name ::= (Letter \| '_' \| ':') (NameChar)*
3438	*
3439	* [6] Names ::= Name (#x20 Name)*
3440	*
3441	* Returns the Name parsed or NULL
3442	*/
3443
3444	const xmlChar *
3445	xmlParseName(xmlParserCtxtPtr ctxt) {
3446	const xmlChar *in;
3447	const xmlChar *ret;
3448	int count = 0;
3449
3450	GROW;
3451
3452	#ifdef DEBUG
3453	nbParseName++;
3454	#endif
3455
3456	/*
3457	* Accelerator for simple ASCII names
3458	*/
3459	in = ctxt->input->cur;
3460	if (((in >= 0x61) && (in <= 0x7A)) \|\|
3461	((in >= 0x41) && (in <= 0x5A)) \|\|
3462	(in == '_') \|\| (in == ':')) {
3463	in++;
3464	while (((in >= 0x61) && (in <= 0x7A)) \|\|
3465	((in >= 0x41) && (in <= 0x5A)) \|\|
3466	((in >= 0x30) && (in <= 0x39)) \|\|
3467	(in == '_') \|\| (in == '-') \|\|
3468	(in == ':') \|\| (in == '.'))
3469	in++;
3470	if ((in > 0) && (in < 0x80)) {
3471	count = in - ctxt->input->cur;
3472	if ((count > XML_MAX_NAME_LENGTH) &&
3473	((ctxt->options & XML_PARSE_HUGE) == 0)) {
3474	xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name");
3475	return(NULL);
3476	}
3477	ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3478	ctxt->input->cur = in;
3479	ctxt->nbChars += count;
3480	ctxt->input->col += count;
3481	if (ret == NULL)
3482	xmlErrMemory(ctxt, NULL);
3483	return(ret);
3484	}
3485	}
3486	/* accelerator for special cases */
3487	return(xmlParseNameComplex(ctxt));
3488	}
3489
3490	static const xmlChar *
3491	xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
3492	int len = 0, l;
3493	int c;
3494	int count = 0;
3495	size_t startPosition = 0;
3496
3497	#ifdef DEBUG
3498	nbParseNCNameComplex++;
3499	#endif
3500
3501	/*
3502	* Handler for more complex cases
3503	*/
3504	GROW;
3505	startPosition = CUR_PTR - BASE_PTR;
3506	c = CUR_CHAR(l);
3507	if ((c == ' ') \|\| (c == '>') \|\| (c == '/') \|\| /* accelerators */
3508	(!xmlIsNameStartChar(ctxt, c) \|\| (c == ':'))) {
3509	return(NULL);
3510	}
3511
3512	while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
3513	(xmlIsNameChar(ctxt, c) && (c != ':'))) {
3514	if (count++ > XML_PARSER_CHUNK_SIZE) {
3515	if ((len > XML_MAX_NAME_LENGTH) &&
3516	((ctxt->options & XML_PARSE_HUGE) == 0)) {
3517	xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3518	return(NULL);
3519	}
3520	count = 0;
3521	GROW;
3522	if (ctxt->instate == XML_PARSER_EOF)
3523	return(NULL);
3524	}
3525	len += l;
3526	NEXTL(l);
3527	c = CUR_CHAR(l);
3528	if (c == 0) {
3529	count = 0;
3530	/*
3531	* when shrinking to extend the buffer we really need to preserve
3532	* the part of the name we already parsed. Hence rolling back
3533	* by current lenght.
3534	*/
3535	ctxt->input->cur -= l;
3536	GROW;
3537	ctxt->input->cur += l;
3538	if (ctxt->instate == XML_PARSER_EOF)
3539	return(NULL);
3540	c = CUR_CHAR(l);
3541	}
3542	}
3543	if ((len > XML_MAX_NAME_LENGTH) &&
3544	((ctxt->options & XML_PARSE_HUGE) == 0)) {
3545	xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3546	return(NULL);
3547	}
3548	return(xmlDictLookup(ctxt->dict, (BASE_PTR + startPosition), len));
3549	}
3550
3551	/**
3552	* xmlParseNCName:
3553	* @ctxt: an XML parser context
3554	* @len: length of the string parsed
3555	*
3556	* parse an XML name.
3557	*
3558	* [4NS] NCNameChar ::= Letter \| Digit \| '.' \| '-' \| '_' \|
3559	* CombiningChar \| Extender
3560	*
3561	* [5NS] NCName ::= (Letter \| '_') (NCNameChar)*
3562	*
3563	* Returns the Name parsed or NULL
3564	*/
3565
3566	static const xmlChar *
3567	xmlParseNCName(xmlParserCtxtPtr ctxt) {
3568	const xmlChar in, e;
3569	const xmlChar *ret;
3570	int count = 0;
3571
3572	#ifdef DEBUG
3573	nbParseNCName++;
3574	#endif
3575
3576	/*
3577	* Accelerator for simple ASCII names
3578	*/
3579	in = ctxt->input->cur;
3580	e = ctxt->input->end;
3581	if ((((in >= 0x61) && (in <= 0x7A)) \|\|
3582	((in >= 0x41) && (in <= 0x5A)) \|\|
3583	(*in == '_')) && (in < e)) {
3584	in++;
3585	while ((((in >= 0x61) && (in <= 0x7A)) \|\|
3586	((in >= 0x41) && (in <= 0x5A)) \|\|
3587	((in >= 0x30) && (in <= 0x39)) \|\|
3588	(in == '_') \|\| (in == '-') \|\|
3589	(*in == '.')) && (in < e))
3590	in++;
3591	if (in >= e)
3592	goto complex;
3593	if ((in > 0) && (in < 0x80)) {
3594	count = in - ctxt->input->cur;
3595	if ((count > XML_MAX_NAME_LENGTH) &&
3596	((ctxt->options & XML_PARSE_HUGE) == 0)) {
3597	xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3598	return(NULL);
3599	}
3600	ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3601	ctxt->input->cur = in;
3602	ctxt->nbChars += count;
3603	ctxt->input->col += count;
3604	if (ret == NULL) {
3605	xmlErrMemory(ctxt, NULL);
3606	}
3607	return(ret);
3608	}
3609	}
3610	complex:
3611	return(xmlParseNCNameComplex(ctxt));
3612	}
3613
3614	/**
3615	* xmlParseNameAndCompare:
3616	* @ctxt: an XML parser context
3617	*
3618	* parse an XML name and compares for match
3619	* (specialized for endtag parsing)
3620	*
3621	* Returns NULL for an illegal name, (xmlChar*) 1 for success
3622	* and the name for mismatch
3623	*/
3624
3625	static const xmlChar *
3626	xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) {
3627	register const xmlChar *cmp = other;
3628	register const xmlChar *in;
3629	const xmlChar *ret;
3630
3631	GROW;
3632	if (ctxt->instate == XML_PARSER_EOF)
3633	return(NULL);
3634
3635	in = ctxt->input->cur;
3636	while (in != 0 && in == *cmp) {
3637	++in;
3638	++cmp;
3639	ctxt->input->col++;
3640	}
3641	if (cmp == 0 && (in == '>' \|\| IS_BLANK_CH (*in))) {
3642	/* success */
3643	ctxt->input->cur = in;
3644	return (const xmlChar*) 1;
3645	}
3646	/* failure (or end of input buffer), check with full function */
3647	ret = xmlParseName (ctxt);
3648	/* strings coming from the dictionary direct compare possible */
3649	if (ret == other) {
3650	return (const xmlChar*) 1;
3651	}
3652	return ret;
3653	}
3654
3655	/**
3656	* xmlParseStringName:
3657	* @ctxt: an XML parser context
3658	* @str: a pointer to the string pointer (IN/OUT)
3659	*
3660	* parse an XML name.
3661	*
3662	* [4] NameChar ::= Letter \| Digit \| '.' \| '-' \| '_' \| ':' \|
3663	* CombiningChar \| Extender
3664	*
3665	* [5] Name ::= (Letter \| '_' \| ':') (NameChar)*
3666	*
3667	* [6] Names ::= Name (#x20 Name)*
3668	*
3669	* Returns the Name parsed or NULL. The @str pointer
3670	* is updated to the current location in the string.
3671	*/
3672
3673	static xmlChar *
3674	xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) {
3675	xmlChar buf[XML_MAX_NAMELEN + 5];
3676	const xmlChar cur = str;
3677	int len = 0, l;
3678	int c;
3679
3680	#ifdef DEBUG
3681	nbParseStringName++;
3682	#endif
3683
3684	c = CUR_SCHAR(cur, l);
3685	if (!xmlIsNameStartChar(ctxt, c)) {
3686	return(NULL);
3687	}
3688
3689	COPY_BUF(l,buf,len,c);
3690	cur += l;
3691	c = CUR_SCHAR(cur, l);
3692	while (xmlIsNameChar(ctxt, c)) {
3693	COPY_BUF(l,buf,len,c);
3694	cur += l;
3695	c = CUR_SCHAR(cur, l);
3696	if (len >= XML_MAX_NAMELEN) { /* test bigentname.xml */
3697	/*
3698	* Okay someone managed to make a huge name, so he's ready to pay
3699	* for the processing speed.
3700	*/
3701	xmlChar *buffer;
3702	int max = len * 2;
3703
3704	buffer = (xmlChar ) xmlMallocAtomic(max sizeof(xmlChar));
3705	if (buffer == NULL) {
3706	xmlErrMemory(ctxt, NULL);
3707	return(NULL);
3708	}
3709	memcpy(buffer, buf, len);
3710	while (xmlIsNameChar(ctxt, c)) {
3711	if (len + 10 > max) {
3712	xmlChar *tmp;
3713
3714	if ((len > XML_MAX_NAME_LENGTH) &&
3715	((ctxt->options & XML_PARSE_HUGE) == 0)) {
3716	xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3717	xmlFree(buffer);
3718	return(NULL);
3719	}
3720	max *= 2;
3721	tmp = (xmlChar *) xmlRealloc(buffer,
3722	max * sizeof(xmlChar));
3723	if (tmp == NULL) {
3724	xmlErrMemory(ctxt, NULL);
3725	xmlFree(buffer);
3726	return(NULL);
3727	}
3728	buffer = tmp;
3729	}
3730	COPY_BUF(l,buffer,len,c);
3731	cur += l;
3732	c = CUR_SCHAR(cur, l);
3733	}
3734	buffer[len] = 0;
3735	*str = cur;
3736	return(buffer);
3737	}
3738	}
3739	if ((len > XML_MAX_NAME_LENGTH) &&
3740	((ctxt->options & XML_PARSE_HUGE) == 0)) {
3741	xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3742	return(NULL);
3743	}
3744	*str = cur;
3745	return(xmlStrndup(buf, len));
3746	}
3747
3748	/**
3749	* xmlParseNmtoken:
3750	* @ctxt: an XML parser context
3751	*
3752	* parse an XML Nmtoken.
3753	*
3754	* [7] Nmtoken ::= (NameChar)+
3755	*
3756	* [8] Nmtokens ::= Nmtoken (#x20 Nmtoken)*
3757	*
3758	* Returns the Nmtoken parsed or NULL
3759	*/
3760
3761	xmlChar *
3762	xmlParseNmtoken(xmlParserCtxtPtr ctxt) {
3763	xmlChar buf[XML_MAX_NAMELEN + 5];
3764	int len = 0, l;
3765	int c;
3766	int count = 0;
3767
3768	#ifdef DEBUG
3769	nbParseNmToken++;
3770	#endif
3771
3772	GROW;
3773	if (ctxt->instate == XML_PARSER_EOF)
3774	return(NULL);
3775	c = CUR_CHAR(l);
3776
3777	while (xmlIsNameChar(ctxt, c)) {
3778	if (count++ > XML_PARSER_CHUNK_SIZE) {
3779	count = 0;
3780	GROW;
3781	}
3782	COPY_BUF(l,buf,len,c);
3783	NEXTL(l);
3784	c = CUR_CHAR(l);
3785	if (c == 0) {
3786	count = 0;
3787	GROW;
3788	if (ctxt->instate == XML_PARSER_EOF)
3789	return(NULL);
3790	c = CUR_CHAR(l);
3791	}
3792	if (len >= XML_MAX_NAMELEN) {
3793	/*
3794	* Okay someone managed to make a huge token, so he's ready to pay
3795	* for the processing speed.
3796	*/
3797	xmlChar *buffer;
3798	int max = len * 2;
3799
3800	buffer = (xmlChar ) xmlMallocAtomic(max sizeof(xmlChar));
3801	if (buffer == NULL) {
3802	xmlErrMemory(ctxt, NULL);
3803	return(NULL);
3804	}
3805	memcpy(buffer, buf, len);
3806	while (xmlIsNameChar(ctxt, c)) {
3807	if (count++ > XML_PARSER_CHUNK_SIZE) {
3808	count = 0;
3809	GROW;
3810	if (ctxt->instate == XML_PARSER_EOF) {
3811	xmlFree(buffer);
3812	return(NULL);
3813	}
3814	}
3815	if (len + 10 > max) {
3816	xmlChar *tmp;
3817
3818	if ((max > XML_MAX_NAME_LENGTH) &&
3819	((ctxt->options & XML_PARSE_HUGE) == 0)) {
3820	xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken");
3821	xmlFree(buffer);
3822	return(NULL);
3823	}
3824	max *= 2;
3825	tmp = (xmlChar *) xmlRealloc(buffer,
3826	max * sizeof(xmlChar));
3827	if (tmp == NULL) {
3828	xmlErrMemory(ctxt, NULL);
3829	xmlFree(buffer);
3830	return(NULL);
3831	}
3832	buffer = tmp;
3833	}
3834	COPY_BUF(l,buffer,len,c);
3835	NEXTL(l);
3836	c = CUR_CHAR(l);
3837	}
3838	buffer[len] = 0;
3839	return(buffer);
3840	}
3841	}
3842	if (len == 0)
3843	return(NULL);
3844	if ((len > XML_MAX_NAME_LENGTH) &&
3845	((ctxt->options & XML_PARSE_HUGE) == 0)) {
3846	xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken");
3847	return(NULL);
3848	}
3849	return(xmlStrndup(buf, len));
3850	}
3851
3852	/**
3853	* xmlParseEntityValue:
3854	* @ctxt: an XML parser context
3855	* @orig: if non-NULL store a copy of the original entity value
3856	*
3857	* parse a value for ENTITY declarations
3858	*
3859	* [9] EntityValue ::= '"' ([^%&"] \| PEReference \| Reference)* '"' \|
3860	* "'" ([^%&'] \| PEReference \| Reference)* "'"
3861	*
3862	* Returns the EntityValue parsed with reference substituted or NULL
3863	*/
3864
3865	xmlChar *
3866	xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) {
3867	xmlChar *buf = NULL;
3868	int len = 0;
3869	int size = XML_PARSER_BUFFER_SIZE;
3870	int c, l;
3871	xmlChar stop;
3872	xmlChar *ret = NULL;
3873	const xmlChar *cur = NULL;
3874	xmlParserInputPtr input;
3875
3876	if (RAW == '"') stop = '"';
3877	else if (RAW == '\'') stop = '\'';
3878	else {
3879	xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL);
3880	return(NULL);
3881	}
3882	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
3883	if (buf == NULL) {
3884	xmlErrMemory(ctxt, NULL);
3885	return(NULL);
3886	}
3887
3888	/*
3889	* The content of the entity definition is copied in a buffer.
3890	*/
3891
3892	ctxt->instate = XML_PARSER_ENTITY_VALUE;
3893	input = ctxt->input;
3894	GROW;
3895	if (ctxt->instate == XML_PARSER_EOF) {
3896	xmlFree(buf);
3897	return(NULL);
3898	}
3899	NEXT;
3900	c = CUR_CHAR(l);
3901	/*
3902	* NOTE: 4.4.5 Included in Literal
3903	* When a parameter entity reference appears in a literal entity
3904	* value, ... a single or double quote character in the replacement
3905	* text is always treated as a normal data character and will not
3906	* terminate the literal.
3907	* In practice it means we stop the loop only when back at parsing
3908	* the initial entity and the quote is found
3909	*/
3910	while (((IS_CHAR(c)) && ((c != stop) \|\| /* checked */
3911	(ctxt->input != input))) && (ctxt->instate != XML_PARSER_EOF)) {
3912	if (len + 5 >= size) {
3913	xmlChar *tmp;
3914
3915	size *= 2;
3916	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
3917	if (tmp == NULL) {
3918	xmlErrMemory(ctxt, NULL);
3919	xmlFree(buf);
3920	return(NULL);
3921	}
3922	buf = tmp;
3923	}
3924	COPY_BUF(l,buf,len,c);
3925	NEXTL(l);
3926	/*
3927	* Pop-up of finished entities.
3928	*/
3929	while ((RAW == 0) && (ctxt->inputNr > 1)) /* non input consuming */
3930	xmlPopInput(ctxt);
3931
3932	GROW;
3933	c = CUR_CHAR(l);
3934	if (c == 0) {
3935	GROW;
3936	c = CUR_CHAR(l);
3937	}
3938	}
3939	buf[len] = 0;
3940	if (ctxt->instate == XML_PARSER_EOF) {
3941	xmlFree(buf);
3942	return(NULL);
3943	}
3944
3945	/*
3946	* Raise problem w.r.t. '&' and '%' being used in non-entities
3947	* reference constructs. Note Charref will be handled in
3948	* xmlStringDecodeEntities()
3949	*/
3950	cur = buf;
3951	while (cur != 0) { / non input consuming */
3952	if ((cur == '%') \|\| ((cur == '&') && (cur[1] != '#'))) {
3953	xmlChar *name;
3954	xmlChar tmp = *cur;
3955
3956	cur++;
3957	name = xmlParseStringName(ctxt, &cur);
3958	if ((name == NULL) \|\| (*cur != ';')) {
3959	xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR,
3960	"EntityValue: '%c' forbidden except for entities references\n",
3961	tmp);
3962	}
3963	if ((tmp == '%') && (ctxt->inSubset == 1) &&
3964	(ctxt->inputNr == 1)) {
3965	xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL);
3966	}
3967	if (name != NULL)
3968	xmlFree(name);
3969	if (*cur == 0)
3970	break;
3971	}
3972	cur++;
3973	}
3974
3975	/*
3976	* Then PEReference entities are substituted.
3977	*/
3978	if (c != stop) {
3979	xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL);
3980	xmlFree(buf);
3981	} else {
3982	NEXT;
3983	/*
3984	* NOTE: 4.4.7 Bypassed
3985	* When a general entity reference appears in the EntityValue in
3986	* an entity declaration, it is bypassed and left as is.
3987	* so XML_SUBSTITUTE_REF is not set here.
3988	*/
3989	++ctxt->depth;
3990	ret = xmlStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF,
3991	0, 0, 0);
3992	--ctxt->depth;
3993	if (orig != NULL)
3994	*orig = buf;
3995	else
3996	xmlFree(buf);
3997	}
3998
3999	return(ret);
4000	}
4001
4002	/**
4003	* xmlParseAttValueComplex:
4004	* @ctxt: an XML parser context
4005	* @len: the resulting attribute len
4006	* @normalize: wether to apply the inner normalization
4007	*
4008	* parse a value for an attribute, this is the fallback function
4009	* of xmlParseAttValue() when the attribute parsing requires handling
4010	* of non-ASCII characters, or normalization compaction.
4011	*
4012	* Returns the AttValue parsed or NULL. The value has to be freed by the caller.
4013	*/
4014	static xmlChar *
4015	xmlParseAttValueComplex(xmlParserCtxtPtr ctxt, int *attlen, int normalize) {
4016	xmlChar limit = 0;
4017	xmlChar *buf = NULL;
4018	xmlChar *rep = NULL;
4019	size_t len = 0;
4020	size_t buf_size = 0;
4021	int c, l, in_space = 0;
4022	xmlChar *current = NULL;
4023	xmlEntityPtr ent;
4024
4025	if (NXT(0) == '"') {
4026	ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
4027	limit = '"';
4028	NEXT;
4029	} else if (NXT(0) == '\'') {
4030	limit = '\'';
4031	ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
4032	NEXT;
4033	} else {
4034	xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
4035	return(NULL);
4036	}
4037
4038	/*
4039	* allocate a translation buffer.
4040	*/
4041	buf_size = XML_PARSER_BUFFER_SIZE;
4042	buf = (xmlChar *) xmlMallocAtomic(buf_size);
4043	if (buf == NULL) goto mem_error;
4044
4045	/*
4046	* OK loop until we reach one of the ending char or a size limit.
4047	*/
4048	c = CUR_CHAR(l);
4049	while (((NXT(0) != limit) && /* checked */
4050	(IS_CHAR(c)) && (c != '<')) &&
4051	(ctxt->instate != XML_PARSER_EOF)) {
4052	/*
4053	* Impose a reasonable limit on attribute size, unless XML_PARSE_HUGE
4054	* special option is given
4055	*/
4056	if ((len > XML_MAX_TEXT_LENGTH) &&
4057	((ctxt->options & XML_PARSE_HUGE) == 0)) {
4058	xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
4059	"AttValue length too long\n");
4060	goto mem_error;
4061	}
4062	if (c == 0) break;
4063	if (c == '&') {
4064	in_space = 0;
4065	if (NXT(1) == '#') {
4066	int val = xmlParseCharRef(ctxt);
4067
4068	if (val == '&') {
4069	if (ctxt->replaceEntities) {
4070	if (len + 10 > buf_size) {
4071	growBuffer(buf, 10);
4072	}
4073	buf[len++] = '&';
4074	} else {
4075	/*
4076	* The reparsing will be done in xmlStringGetNodeList()
4077	* called by the attribute() function in SAX.c
4078	*/
4079	if (len + 10 > buf_size) {
4080	growBuffer(buf, 10);
4081	}
4082	buf[len++] = '&';
4083	buf[len++] = '#';
4084	buf[len++] = '3';
4085	buf[len++] = '8';
4086	buf[len++] = ';';
4087	}
4088	} else if (val != 0) {
4089	if (len + 10 > buf_size) {
4090	growBuffer(buf, 10);
4091	}
4092	len += xmlCopyChar(0, &buf[len], val);
4093	}
4094	} else {
4095	ent = xmlParseEntityRef(ctxt);
4096	ctxt->nbentities++;
4097	if (ent != NULL)
4098	ctxt->nbentities += ent->owner;
4099	if ((ent != NULL) &&
4100	(ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
4101	if (len + 10 > buf_size) {
4102	growBuffer(buf, 10);
4103	}
4104	if ((ctxt->replaceEntities == 0) &&
4105	(ent->content[0] == '&')) {
4106	buf[len++] = '&';
4107	buf[len++] = '#';
4108	buf[len++] = '3';
4109	buf[len++] = '8';
4110	buf[len++] = ';';
4111	} else {
4112	buf[len++] = ent->content[0];
4113	}
4114	} else if ((ent != NULL) &&
4115	(ctxt->replaceEntities != 0)) {
4116	if (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) {
4117	++ctxt->depth;
4118	rep = xmlStringDecodeEntities(ctxt, ent->content,
4119	XML_SUBSTITUTE_REF,
4120	0, 0, 0);
4121	--ctxt->depth;
4122	if (rep != NULL) {
4123	current = rep;
4124	while (current != 0) { / non input consuming */
4125	if ((current == 0xD) \|\| (current == 0xA) \|\|
4126	(*current == 0x9)) {
4127	buf[len++] = 0x20;
4128	current++;
4129	} else
4130	buf[len++] = *current++;
4131	if (len + 10 > buf_size) {
4132	growBuffer(buf, 10);
4133	}
4134	}
4135	xmlFree(rep);
4136	rep = NULL;
4137	}
4138	} else {
4139	if (len + 10 > buf_size) {
4140	growBuffer(buf, 10);
4141	}
4142	if (ent->content != NULL)
4143	buf[len++] = ent->content[0];
4144	}
4145	} else if (ent != NULL) {
4146	int i = xmlStrlen(ent->name);
4147	const xmlChar *cur = ent->name;
4148
4149	/*
4150	* This may look absurd but is needed to detect
4151	* entities problems
4152	*/
4153	if ((ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
4154	(ent->content != NULL) && (ent->checked == 0)) {
4155	unsigned long oldnbent = ctxt->nbentities;
4156
4157	++ctxt->depth;
4158	rep = xmlStringDecodeEntities(ctxt, ent->content,
4159	XML_SUBSTITUTE_REF, 0, 0, 0);
4160	--ctxt->depth;
4161
4162	ent->checked = (ctxt->nbentities - oldnbent + 1) * 2;
4163	if (rep != NULL) {
4164	if (xmlStrchr(rep, '<'))
4165	ent->checked \|= 1;
4166	xmlFree(rep);
4167	rep = NULL;
4168	}
4169	}
4170
4171	/*
4172	* Just output the reference
4173	*/
4174	buf[len++] = '&';
4175	while (len + i + 10 > buf_size) {
4176	growBuffer(buf, i + 10);
4177	}
4178	for (;i > 0;i--)
4179	buf[len++] = *cur++;
4180	buf[len++] = ';';
4181	}
4182	}
4183	} else {
4184	if ((c == 0x20) \|\| (c == 0xD) \|\| (c == 0xA) \|\| (c == 0x9)) {
4185	if ((len != 0) \|\| (!normalize)) {
4186	if ((!normalize) \|\| (!in_space)) {
4187	COPY_BUF(l,buf,len,0x20);
4188	while (len + 10 > buf_size) {
4189	growBuffer(buf, 10);
4190	}
4191	}
4192	in_space = 1;
4193	}
4194	} else {
4195	in_space = 0;
4196	COPY_BUF(l,buf,len,c);
4197	if (len + 10 > buf_size) {
4198	growBuffer(buf, 10);
4199	}
4200	}
4201	NEXTL(l);
4202	}
4203	GROW;
4204	c = CUR_CHAR(l);
4205	}
4206	if (ctxt->instate == XML_PARSER_EOF)
4207	goto error;
4208
4209	if ((in_space) && (normalize)) {
4210	while ((len > 0) && (buf[len - 1] == 0x20)) len--;
4211	}
4212	buf[len] = 0;
4213	if (RAW == '<') {
4214	xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL);
4215	} else if (RAW != limit) {
4216	if ((c != 0) && (!IS_CHAR(c))) {
4217	xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
4218	"invalid character in attribute value\n");
4219	} else {
4220	xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
4221	"AttValue: ' expected\n");
4222	}
4223	} else
4224	NEXT;
4225
4226	/*
4227	* There we potentially risk an overflow, don't allow attribute value of
4228	* length more than INT_MAX it is a very reasonnable assumption !
4229	*/
4230	if (len >= INT_MAX) {
4231	xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
4232	"AttValue length too long\n");
4233	goto mem_error;
4234	}
4235
4236	if (attlen != NULL) *attlen = (int) len;
4237	return(buf);
4238
4239	mem_error:
4240	xmlErrMemory(ctxt, NULL);
4241	error:
4242	if (buf != NULL)
4243	xmlFree(buf);
4244	if (rep != NULL)
4245	xmlFree(rep);
4246	return(NULL);
4247	}
4248
4249	/**
4250	* xmlParseAttValue:
4251	* @ctxt: an XML parser context
4252	*
4253	* parse a value for an attribute
4254	* Note: the parser won't do substitution of entities here, this
4255	* will be handled later in xmlStringGetNodeList
4256	*
4257	* [10] AttValue ::= '"' ([^<&"] \| Reference)* '"' \|
4258	* "'" ([^<&'] \| Reference)* "'"
4259	*
4260	* 3.3.3 Attribute-Value Normalization:
4261	* Before the value of an attribute is passed to the application or
4262	* checked for validity, the XML processor must normalize it as follows:
4263	* - a character reference is processed by appending the referenced
4264	* character to the attribute value
4265	* - an entity reference is processed by recursively processing the
4266	* replacement text of the entity
4267	* - a whitespace character (#x20, #xD, #xA, #x9) is processed by
4268	* appending #x20 to the normalized value, except that only a single
4269	* #x20 is appended for a "#xD#xA" sequence that is part of an external
4270	* parsed entity or the literal entity value of an internal parsed entity
4271	* - other characters are processed by appending them to the normalized value
4272	* If the declared value is not CDATA, then the XML processor must further
4273	* process the normalized attribute value by discarding any leading and
4274	* trailing space (#x20) characters, and by replacing sequences of space
4275	* (#x20) characters by a single space (#x20) character.
4276	* All attributes for which no declaration has been read should be treated
4277	* by a non-validating parser as if declared CDATA.
4278	*
4279	* Returns the AttValue parsed or NULL. The value has to be freed by the caller.
4280	*/
4281
4282
4283	xmlChar *
4284	xmlParseAttValue(xmlParserCtxtPtr ctxt) {
4285	if ((ctxt == NULL) \|\| (ctxt->input == NULL)) return(NULL);
4286	return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0));
4287	}
4288
4289	/**
4290	* xmlParseSystemLiteral:
4291	* @ctxt: an XML parser context
4292	*
4293	* parse an XML Literal
4294	*
4295	* [11] SystemLiteral ::= ('"' [^"]* '"') \| ("'" [^']* "'")
4296	*
4297	* Returns the SystemLiteral parsed or NULL
4298	*/
4299
4300	xmlChar *
4301	xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) {
4302	xmlChar *buf = NULL;
4303	int len = 0;
4304	int size = XML_PARSER_BUFFER_SIZE;
4305	int cur, l;
4306	xmlChar stop;
4307	int state = ctxt->instate;
4308	int count = 0;
4309
4310	SHRINK;
4311	if (RAW == '"') {
4312	NEXT;
4313	stop = '"';
4314	} else if (RAW == '\'') {
4315	NEXT;
4316	stop = '\'';
4317	} else {
4318	xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4319	return(NULL);
4320	}
4321
4322	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
4323	if (buf == NULL) {
4324	xmlErrMemory(ctxt, NULL);
4325	return(NULL);
4326	}
4327	ctxt->instate = XML_PARSER_SYSTEM_LITERAL;
4328	cur = CUR_CHAR(l);
4329	while ((IS_CHAR(cur)) && (cur != stop)) { /* checked */
4330	if (len + 5 >= size) {
4331	xmlChar *tmp;
4332
4333	if ((size > XML_MAX_NAME_LENGTH) &&
4334	((ctxt->options & XML_PARSE_HUGE) == 0)) {
4335	xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "SystemLiteral");
4336	xmlFree(buf);
4337	ctxt->instate = (xmlParserInputState) state;
4338	return(NULL);
4339	}
4340	size *= 2;
4341	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
4342	if (tmp == NULL) {
4343	xmlFree(buf);
4344	xmlErrMemory(ctxt, NULL);
4345	ctxt->instate = (xmlParserInputState) state;
4346	return(NULL);
4347	}
4348	buf = tmp;
4349	}
4350	count++;
4351	if (count > 50) {
4352	GROW;
4353	count = 0;
4354	if (ctxt->instate == XML_PARSER_EOF) {
4355	xmlFree(buf);
4356	return(NULL);
4357	}
4358	}
4359	COPY_BUF(l,buf,len,cur);
4360	NEXTL(l);
4361	cur = CUR_CHAR(l);
4362	if (cur == 0) {
4363	GROW;
4364	SHRINK;
4365	cur = CUR_CHAR(l);
4366	}
4367	}
4368	buf[len] = 0;
4369	ctxt->instate = (xmlParserInputState) state;
4370	if (!IS_CHAR(cur)) {
4371	xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4372	} else {
4373	NEXT;
4374	}
4375	return(buf);
4376	}
4377
4378	/**
4379	* xmlParsePubidLiteral:
4380	* @ctxt: an XML parser context
4381	*
4382	* parse an XML public literal
4383	*
4384	* [12] PubidLiteral ::= '"' PubidChar* '"' \| "'" (PubidChar - "'")* "'"
4385	*
4386	* Returns the PubidLiteral parsed or NULL.
4387	*/
4388
4389	xmlChar *
4390	xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) {
4391	xmlChar *buf = NULL;
4392	int len = 0;
4393	int size = XML_PARSER_BUFFER_SIZE;
4394	xmlChar cur;
4395	xmlChar stop;
4396	int count = 0;
4397	xmlParserInputState oldstate = ctxt->instate;
4398
4399	SHRINK;
4400	if (RAW == '"') {
4401	NEXT;
4402	stop = '"';
4403	} else if (RAW == '\'') {
4404	NEXT;
4405	stop = '\'';
4406	} else {
4407	xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4408	return(NULL);
4409	}
4410	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
4411	if (buf == NULL) {
4412	xmlErrMemory(ctxt, NULL);
4413	return(NULL);
4414	}
4415	ctxt->instate = XML_PARSER_PUBLIC_LITERAL;
4416	cur = CUR;
4417	while ((IS_PUBIDCHAR_CH(cur)) && (cur != stop)) { /* checked */
4418	if (len + 1 >= size) {
4419	xmlChar *tmp;
4420
4421	if ((size > XML_MAX_NAME_LENGTH) &&
4422	((ctxt->options & XML_PARSE_HUGE) == 0)) {
4423	xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Public ID");
4424	xmlFree(buf);
4425	return(NULL);
4426	}
4427	size *= 2;
4428	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
4429	if (tmp == NULL) {
4430	xmlErrMemory(ctxt, NULL);
4431	xmlFree(buf);
4432	return(NULL);
4433	}
4434	buf = tmp;
4435	}
4436	buf[len++] = cur;
4437	count++;
4438	if (count > 50) {
4439	GROW;
4440	count = 0;
4441	if (ctxt->instate == XML_PARSER_EOF) {
4442	xmlFree(buf);
4443	return(NULL);
4444	}
4445	}
4446	NEXT;
4447	cur = CUR;
4448	if (cur == 0) {
4449	GROW;
4450	SHRINK;
4451	cur = CUR;
4452	}
4453	}
4454	buf[len] = 0;
4455	if (cur != stop) {
4456	xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4457	} else {
4458	NEXT;
4459	}
4460	ctxt->instate = oldstate;
4461	return(buf);
4462	}
4463
4464	static void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata);
4465
4466	/*
4467	* used for the test in the inner loop of the char data testing
4468	*/
4469	static const unsigned char test_char_data[256] = {
4470	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4471	0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x9, CR/LF separated */
4472	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4473	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4474	0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x00, 0x27, /* & */
4475	0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
4476	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
4477	0x38, 0x39, 0x3A, 0x3B, 0x00, 0x3D, 0x3E, 0x3F, /* < */
4478	0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
4479	0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
4480	0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
4481	0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x00, 0x5E, 0x5F, /* ] */
4482	0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
4483	0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
4484	0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
4485	0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
4486	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* non-ascii */
4487	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4488	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4489	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4490	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4491	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4492	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4493	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4494	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4495	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4496	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4497	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4498	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4499	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4500	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4501	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
4502	};
4503
4504	/**
4505	* xmlParseCharData:
4506	* @ctxt: an XML parser context
4507	* @cdata: int indicating whether we are within a CDATA section
4508	*
4509	* parse a CharData section.
4510	* if we are within a CDATA section ']]>' marks an end of section.
4511	*
4512	* The right angle bracket (>) may be represented using the string ">",
4513	* and must, for compatibility, be escaped using ">" or a character
4514	* reference when it appears in the string "]]>" in content, when that
4515	* string is not marking the end of a CDATA section.
4516	*
4517	* [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
4518	*/
4519
4520	void
4521	xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata) {
4522	const xmlChar *in;
4523	int nbchar = 0;
4524	int line = ctxt->input->line;
4525	int col = ctxt->input->col;
4526	int ccol;
4527
4528	SHRINK;
4529	GROW;
4530	/*
4531	* Accelerated common case where input don't need to be
4532	* modified before passing it to the handler.
4533	*/
4534	if (!cdata) {
4535	in = ctxt->input->cur;
4536	do {
4537	get_more_space:
4538	while (*in == 0x20) { in++; ctxt->input->col++; }
4539	if (*in == 0xA) {
4540	do {
4541	ctxt->input->line++; ctxt->input->col = 1;
4542	in++;
4543	} while (*in == 0xA);
4544	goto get_more_space;
4545	}
4546	if (*in == '<') {
4547	nbchar = in - ctxt->input->cur;
4548	if (nbchar > 0) {
4549	const xmlChar *tmp = ctxt->input->cur;
4550	ctxt->input->cur = in;
4551
4552	if ((ctxt->sax != NULL) &&
4553	(ctxt->sax->ignorableWhitespace !=
4554	ctxt->sax->characters)) {
4555	if (areBlanks(ctxt, tmp, nbchar, 1)) {
4556	if (ctxt->sax->ignorableWhitespace != NULL)
4557	ctxt->sax->ignorableWhitespace(ctxt->userData,
4558	tmp, nbchar);
4559	} else {
4560	if (ctxt->sax->characters != NULL)
4561	ctxt->sax->characters(ctxt->userData,
4562	tmp, nbchar);
4563	if (*ctxt->space == -1)
4564	*ctxt->space = -2;
4565	}
4566	} else if ((ctxt->sax != NULL) &&
4567	(ctxt->sax->characters != NULL)) {
4568	ctxt->sax->characters(ctxt->userData,
4569	tmp, nbchar);
4570	}
4571	}
4572	return;
4573	}
4574
4575	get_more:
4576	ccol = ctxt->input->col;
4577	while (test_char_data[*in]) {
4578	in++;
4579	ccol++;
4580	}
4581	ctxt->input->col = ccol;
4582	if (*in == 0xA) {
4583	do {
4584	ctxt->input->line++; ctxt->input->col = 1;
4585	in++;
4586	} while (*in == 0xA);
4587	goto get_more;
4588	}
4589	if (*in == ']') {
4590	if ((in[1] == ']') && (in[2] == '>')) {
4591	xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4592	ctxt->input->cur = in;
4593	return;
4594	}
4595	in++;
4596	ctxt->input->col++;
4597	goto get_more;
4598	}
4599	nbchar = in - ctxt->input->cur;
4600	if (nbchar > 0) {
4601	if ((ctxt->sax != NULL) &&
4602	(ctxt->sax->ignorableWhitespace !=
4603	ctxt->sax->characters) &&
4604	(IS_BLANK_CH(*ctxt->input->cur))) {
4605	const xmlChar *tmp = ctxt->input->cur;
4606	ctxt->input->cur = in;
4607
4608	if (areBlanks(ctxt, tmp, nbchar, 0)) {
4609	if (ctxt->sax->ignorableWhitespace != NULL)
4610	ctxt->sax->ignorableWhitespace(ctxt->userData,
4611	tmp, nbchar);
4612	} else {
4613	if (ctxt->sax->characters != NULL)
4614	ctxt->sax->characters(ctxt->userData,
4615	tmp, nbchar);
4616	if (*ctxt->space == -1)
4617	*ctxt->space = -2;
4618	}
4619	line = ctxt->input->line;
4620	col = ctxt->input->col;
4621	} else if (ctxt->sax != NULL) {
4622	if (ctxt->sax->characters != NULL)
4623	ctxt->sax->characters(ctxt->userData,
4624	ctxt->input->cur, nbchar);
4625	line = ctxt->input->line;
4626	col = ctxt->input->col;
4627	}
4628	/* something really bad happened in the SAX callback */
4629	if (ctxt->instate != XML_PARSER_CONTENT)
4630	return;
4631	}
4632	ctxt->input->cur = in;
4633	if (*in == 0xD) {
4634	in++;
4635	if (*in == 0xA) {
4636	ctxt->input->cur = in;
4637	in++;
4638	ctxt->input->line++; ctxt->input->col = 1;
4639	continue; /* while */
4640	}
4641	in--;
4642	}
4643	if (*in == '<') {
4644	return;
4645	}
4646	if (*in == '&') {
4647	return;
4648	}
4649	SHRINK;
4650	GROW;
4651	if (ctxt->instate == XML_PARSER_EOF)
4652	return;
4653	in = ctxt->input->cur;
4654	} while (((in >= 0x20) && (in <= 0x7F)) \|\| (*in == 0x09));
4655	nbchar = 0;
4656	}
4657	ctxt->input->line = line;
4658	ctxt->input->col = col;
4659	xmlParseCharDataComplex(ctxt, cdata);
4660	}
4661
4662	/**
4663	* xmlParseCharDataComplex:
4664	* @ctxt: an XML parser context
4665	* @cdata: int indicating whether we are within a CDATA section
4666	*
4667	* parse a CharData section.this is the fallback function
4668	* of xmlParseCharData() when the parsing requires handling
4669	* of non-ASCII characters.
4670	*/
4671	static void
4672	xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata) {
4673	xmlChar buf[XML_PARSER_BIG_BUFFER_SIZE + 5];
4674	int nbchar = 0;
4675	int cur, l;
4676	int count = 0;
4677
4678	SHRINK;
4679	GROW;
4680	cur = CUR_CHAR(l);
4681	while ((cur != '<') && /* checked */
4682	(cur != '&') &&
4683	(IS_CHAR(cur))) /* test also done in xmlCurrentChar() */ {
4684	if ((cur == ']') && (NXT(1) == ']') &&
4685	(NXT(2) == '>')) {
4686	if (cdata) break;
4687	else {
4688	xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4689	}
4690	}
4691	COPY_BUF(l,buf,nbchar,cur);
4692	if (nbchar >= XML_PARSER_BIG_BUFFER_SIZE) {
4693	buf[nbchar] = 0;
4694
4695	/*
4696	* OK the segment is to be consumed as chars.
4697	*/
4698	if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
4699	if (areBlanks(ctxt, buf, nbchar, 0)) {
4700	if (ctxt->sax->ignorableWhitespace != NULL)
4701	ctxt->sax->ignorableWhitespace(ctxt->userData,
4702	buf, nbchar);
4703	} else {
4704	if (ctxt->sax->characters != NULL)
4705	ctxt->sax->characters(ctxt->userData, buf, nbchar);
4706	if ((ctxt->sax->characters !=
4707	ctxt->sax->ignorableWhitespace) &&
4708	(*ctxt->space == -1))
4709	*ctxt->space = -2;
4710	}
4711	}
4712	nbchar = 0;
4713	/* something really bad happened in the SAX callback */
4714	if (ctxt->instate != XML_PARSER_CONTENT)
4715	return;
4716	}
4717	count++;
4718	if (count > 50) {
4719	GROW;
4720	count = 0;
4721	if (ctxt->instate == XML_PARSER_EOF)
4722	return;
4723	}
4724	NEXTL(l);
4725	cur = CUR_CHAR(l);
4726	}
4727	if (nbchar != 0) {
4728	buf[nbchar] = 0;
4729	/*
4730	* OK the segment is to be consumed as chars.
4731	*/
4732	if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
4733	if (areBlanks(ctxt, buf, nbchar, 0)) {
4734	if (ctxt->sax->ignorableWhitespace != NULL)
4735	ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
4736	} else {
4737	if (ctxt->sax->characters != NULL)
4738	ctxt->sax->characters(ctxt->userData, buf, nbchar);
4739	if ((ctxt->sax->characters != ctxt->sax->ignorableWhitespace) &&
4740	(*ctxt->space == -1))
4741	*ctxt->space = -2;
4742	}
4743	}
4744	}
4745	if ((cur != 0) && (!IS_CHAR(cur))) {
4746	/* Generate the error and skip the offending character */
4747	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4748	"PCDATA invalid Char value %d\n",
4749	cur);
4750	NEXTL(l);
4751	}
4752	}
4753
4754	/**
4755	* xmlParseExternalID:
4756	* @ctxt: an XML parser context
4757	* @publicID: a xmlChar** receiving PubidLiteral
4758	* @strict: indicate whether we should restrict parsing to only
4759	* production [75], see NOTE below
4760	*
4761	* Parse an External ID or a Public ID
4762	*
4763	* NOTE: Productions [75] and [83] interact badly since [75] can generate
4764	* 'PUBLIC' S PubidLiteral S SystemLiteral
4765	*
4766	* [75] ExternalID ::= 'SYSTEM' S SystemLiteral
4767	* \| 'PUBLIC' S PubidLiteral S SystemLiteral
4768	*
4769	* [83] PublicID ::= 'PUBLIC' S PubidLiteral
4770	*
4771	* Returns the function returns SystemLiteral and in the second
4772	* case publicID receives PubidLiteral, is strict is off
4773	* it is possible to return NULL and have publicID set.
4774	*/
4775
4776	xmlChar *
4777	xmlParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) {
4778	xmlChar *URI = NULL;
4779
4780	SHRINK;
4781
4782	*publicID = NULL;
4783	if (CMP6(CUR_PTR, 'S', 'Y', 'S', 'T', 'E', 'M')) {
4784	SKIP(6);
4785	if (!IS_BLANK_CH(CUR)) {
4786	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4787	"Space required after 'SYSTEM'\n");
4788	}
4789	SKIP_BLANKS;
4790	URI = xmlParseSystemLiteral(ctxt);
4791	if (URI == NULL) {
4792	xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
4793	}
4794	} else if (CMP6(CUR_PTR, 'P', 'U', 'B', 'L', 'I', 'C')) {
4795	SKIP(6);
4796	if (!IS_BLANK_CH(CUR)) {
4797	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4798	"Space required after 'PUBLIC'\n");
4799	}
4800	SKIP_BLANKS;
4801	*publicID = xmlParsePubidLiteral(ctxt);
4802	if (*publicID == NULL) {
4803	xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL);
4804	}
4805	if (strict) {
4806	/*
4807	* We don't handle [83] so "S SystemLiteral" is required.
4808	*/
4809	if (!IS_BLANK_CH(CUR)) {
4810	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4811	"Space required after the Public Identifier\n");
4812	}
4813	} else {
4814	/*
4815	* We handle [83] so we return immediately, if
4816	* "S SystemLiteral" is not detected. From a purely parsing
4817	* point of view that's a nice mess.
4818	*/
4819	const xmlChar *ptr;
4820	GROW;
4821
4822	ptr = CUR_PTR;
4823	if (!IS_BLANK_CH(*ptr)) return(NULL);
4824
4825	while (IS_BLANK_CH(ptr)) ptr++; / TODO: dangerous, fix ! */
4826	if ((ptr != '\'') && (ptr != '"')) return(NULL);
4827	}
4828	SKIP_BLANKS;
4829	URI = xmlParseSystemLiteral(ctxt);
4830	if (URI == NULL) {
4831	xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
4832	}
4833	}
4834	return(URI);
4835	}
4836
4837	/**
4838	* xmlParseCommentComplex:
4839	* @ctxt: an XML parser context
4840	* @buf: the already parsed part of the buffer
4841	* @len: number of bytes filles in the buffer
4842	* @size: allocated size of the buffer
4843	*
4844	* Skip an XML (SGML) comment <!-- .... -->
4845	* The spec says that "For compatibility, the string "--" (double-hyphen)
4846	* must not occur within comments. "
4847	* This is the slow routine in case the accelerator for ascii didn't work
4848	*
4849	* [15] Comment ::= '<!--' ((Char - '-') \| ('-' (Char - '-')))* '-->'
4850	*/
4851	static void
4852	xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf,
4853	size_t len, size_t size) {
4854	int q, ql;
4855	int r, rl;
4856	int cur, l;
4857	size_t count = 0;
4858	int inputid;
4859
4860	inputid = ctxt->input->id;
4861
4862	if (buf == NULL) {
4863	len = 0;
4864	size = XML_PARSER_BUFFER_SIZE;
4865	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
4866	if (buf == NULL) {
4867	xmlErrMemory(ctxt, NULL);
4868	return;
4869	}
4870	}
4871	GROW; /* Assure there's enough input data */
4872	q = CUR_CHAR(ql);
4873	if (q == 0)
4874	goto not_terminated;
4875	if (!IS_CHAR(q)) {
4876	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4877	"xmlParseComment: invalid xmlChar value %d\n",
4878	q);
4879	xmlFree (buf);
4880	return;
4881	}
4882	NEXTL(ql);
4883	r = CUR_CHAR(rl);
4884	if (r == 0)
4885	goto not_terminated;
4886	if (!IS_CHAR(r)) {
4887	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4888	"xmlParseComment: invalid xmlChar value %d\n",
4889	q);
4890	xmlFree (buf);
4891	return;
4892	}
4893	NEXTL(rl);
4894	cur = CUR_CHAR(l);
4895	if (cur == 0)
4896	goto not_terminated;
4897	while (IS_CHAR(cur) && /* checked */
4898	((cur != '>') \|\|
4899	(r != '-') \|\| (q != '-'))) {
4900	if ((r == '-') && (q == '-')) {
4901	xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL);
4902	}
4903	if ((len > XML_MAX_TEXT_LENGTH) &&
4904	((ctxt->options & XML_PARSE_HUGE) == 0)) {
4905	xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4906	"Comment too big found", NULL);
4907	xmlFree (buf);
4908	return;
4909	}
4910	if (len + 5 >= size) {
4911	xmlChar *new_buf;
4912	size_t new_size;
4913
4914	new_size = size * 2;
4915	new_buf = (xmlChar *) xmlRealloc(buf, new_size);
4916	if (new_buf == NULL) {
4917	xmlFree (buf);
4918	xmlErrMemory(ctxt, NULL);
4919	return;
4920	}
4921	buf = new_buf;
4922	size = new_size;
4923	}
4924	COPY_BUF(ql,buf,len,q);
4925	q = r;
4926	ql = rl;
4927	r = cur;
4928	rl = l;
4929
4930	count++;
4931	if (count > 50) {
4932	GROW;
4933	count = 0;
4934	if (ctxt->instate == XML_PARSER_EOF) {
4935	xmlFree(buf);
4936	return;
4937	}
4938	}
4939	NEXTL(l);
4940	cur = CUR_CHAR(l);
4941	if (cur == 0) {
4942	SHRINK;
4943	GROW;
4944	cur = CUR_CHAR(l);
4945	}
4946	}
4947	buf[len] = 0;
4948	if (cur == 0) {
4949	xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4950	"Comment not terminated \n<!--%.50s\n", buf);
4951	} else if (!IS_CHAR(cur)) {
4952	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4953	"xmlParseComment: invalid xmlChar value %d\n",
4954	cur);
4955	} else {
4956	if (inputid != ctxt->input->id) {
4957	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4958	"Comment doesn't start and stop in the same entity\n");
4959	}
4960	NEXT;
4961	if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
4962	(!ctxt->disableSAX))
4963	ctxt->sax->comment(ctxt->userData, buf);
4964	}
4965	xmlFree(buf);
4966	return;
4967	not_terminated:
4968	xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4969	"Comment not terminated\n", NULL);
4970	xmlFree(buf);
4971	return;
4972	}
4973
4974	/**
4975	* xmlParseComment:
4976	* @ctxt: an XML parser context
4977	*
4978	* Skip an XML (SGML) comment <!-- .... -->
4979	* The spec says that "For compatibility, the string "--" (double-hyphen)
4980	* must not occur within comments. "
4981	*
4982	* [15] Comment ::= '<!--' ((Char - '-') \| ('-' (Char - '-')))* '-->'
4983	*/
4984	void
4985	xmlParseComment(xmlParserCtxtPtr ctxt) {
4986	xmlChar *buf = NULL;
4987	size_t size = XML_PARSER_BUFFER_SIZE;
4988	size_t len = 0;
4989	xmlParserInputState state;
4990	const xmlChar *in;
4991	size_t nbchar = 0;
4992	int ccol;
4993	int inputid;
4994
4995	/*
4996	* Check that there is a comment right here.
4997	*/
4998	if ((RAW != '<') \|\| (NXT(1) != '!') \|\|
4999	(NXT(2) != '-') \|\| (NXT(3) != '-')) return;
5000	state = ctxt->instate;
5001	ctxt->instate = XML_PARSER_COMMENT;
5002	inputid = ctxt->input->id;
5003	SKIP(4);
5004	SHRINK;
5005	GROW;
5006
5007	/*
5008	* Accelerated common case where input don't need to be
5009	* modified before passing it to the handler.
5010	*/
5011	in = ctxt->input->cur;
5012	do {
5013	if (*in == 0xA) {
5014	do {
5015	ctxt->input->line++; ctxt->input->col = 1;
5016	in++;
5017	} while (*in == 0xA);
5018	}
5019	get_more:
5020	ccol = ctxt->input->col;
5021	while (((in > '-') && (in <= 0x7F)) \|\|
5022	((in >= 0x20) && (in < '-')) \|\|
5023	(*in == 0x09)) {
5024	in++;
5025	ccol++;
5026	}
5027	ctxt->input->col = ccol;
5028	if (*in == 0xA) {
5029	do {
5030	ctxt->input->line++; ctxt->input->col = 1;
5031	in++;
5032	} while (*in == 0xA);
5033	goto get_more;
5034	}
5035	nbchar = in - ctxt->input->cur;
5036	/*
5037	* save current set of data
5038	*/
5039	if (nbchar > 0) {
5040	if ((ctxt->sax != NULL) &&
5041	(ctxt->sax->comment != NULL)) {
5042	if (buf == NULL) {
5043	if ((*in == '-') && (in[1] == '-'))
5044	size = nbchar + 1;
5045	else
5046	size = XML_PARSER_BUFFER_SIZE + nbchar;
5047	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
5048	if (buf == NULL) {
5049	xmlErrMemory(ctxt, NULL);
5050	ctxt->instate = state;
5051	return;
5052	}
5053	len = 0;
5054	} else if (len + nbchar + 1 >= size) {
5055	xmlChar *new_buf;
5056	size += len + nbchar + XML_PARSER_BUFFER_SIZE;
5057	new_buf = (xmlChar *) xmlRealloc(buf,
5058	size * sizeof(xmlChar));
5059	if (new_buf == NULL) {
5060	xmlFree (buf);
5061	xmlErrMemory(ctxt, NULL);
5062	ctxt->instate = state;
5063	return;
5064	}
5065	buf = new_buf;
5066	}
5067	memcpy(&buf[len], ctxt->input->cur, nbchar);
5068	len += nbchar;
5069	buf[len] = 0;
5070	}
5071	}
5072	if ((len > XML_MAX_TEXT_LENGTH) &&
5073	((ctxt->options & XML_PARSE_HUGE) == 0)) {
5074	xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
5075	"Comment too big found", NULL);
5076	xmlFree (buf);
5077	return;
5078	}
5079	ctxt->input->cur = in;
5080	if (*in == 0xA) {
5081	in++;
5082	ctxt->input->line++; ctxt->input->col = 1;
5083	}
5084	if (*in == 0xD) {
5085	in++;
5086	if (*in == 0xA) {
5087	ctxt->input->cur = in;
5088	in++;
5089	ctxt->input->line++; ctxt->input->col = 1;
5090	continue; /* while */
5091	}
5092	in--;
5093	}
5094	SHRINK;
5095	GROW;
5096	if (ctxt->instate == XML_PARSER_EOF) {
5097	xmlFree(buf);
5098	return;
5099	}
5100	in = ctxt->input->cur;
5101	if (*in == '-') {
5102	if (in[1] == '-') {
5103	if (in[2] == '>') {
5104	if (ctxt->input->id != inputid) {
5105	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5106	"comment doesn't start and stop in the same entity\n");
5107	}
5108	SKIP(3);
5109	if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
5110	(!ctxt->disableSAX)) {
5111	if (buf != NULL)
5112	ctxt->sax->comment(ctxt->userData, buf);
5113	else
5114	ctxt->sax->comment(ctxt->userData, BAD_CAST "");
5115	}
5116	if (buf != NULL)
5117	xmlFree(buf);
5118	if (ctxt->instate != XML_PARSER_EOF)
5119	ctxt->instate = state;
5120	return;
5121	}
5122	if (buf != NULL) {
5123	xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT,
5124	"Double hyphen within comment: "
5125	"<!--%.50s\n",
5126	buf);
5127	} else
5128	xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT,
5129	"Double hyphen within comment\n", NULL);
5130	in++;
5131	ctxt->input->col++;
5132	}
5133	in++;
5134	ctxt->input->col++;
5135	goto get_more;
5136	}
5137	} while (((in >= 0x20) && (in <= 0x7F)) \|\| (*in == 0x09));
5138	xmlParseCommentComplex(ctxt, buf, len, size);
5139	ctxt->instate = state;
5140	return;
5141	}
5142
5143
5144	/**
5145	* xmlParsePITarget:
5146	* @ctxt: an XML parser context
5147	*
5148	* parse the name of a PI
5149	*
5150	* [17] PITarget ::= Name - (('X' \| 'x') ('M' \| 'm') ('L' \| 'l'))
5151	*
5152	* Returns the PITarget name or NULL
5153	*/
5154
5155	const xmlChar *
5156	xmlParsePITarget(xmlParserCtxtPtr ctxt) {
5157	const xmlChar *name;
5158
5159	name = xmlParseName(ctxt);
5160	if ((name != NULL) &&
5161	((name[0] == 'x') \|\| (name[0] == 'X')) &&
5162	((name[1] == 'm') \|\| (name[1] == 'M')) &&
5163	((name[2] == 'l') \|\| (name[2] == 'L'))) {
5164	int i;
5165	if ((name[0] == 'x') && (name[1] == 'm') &&
5166	(name[2] == 'l') && (name[3] == 0)) {
5167	xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
5168	"XML declaration allowed only at the start of the document\n");
5169	return(name);
5170	} else if (name[3] == 0) {
5171	xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL);
5172	return(name);
5173	}
5174	for (i = 0;;i++) {
5175	if (xmlW3CPIs[i] == NULL) break;
5176	if (xmlStrEqual(name, (const xmlChar *)xmlW3CPIs[i]))
5177	return(name);
5178	}
5179	xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
5180	"xmlParsePITarget: invalid name prefix 'xml'\n",
5181	NULL, NULL);
5182	}
5183	if ((name != NULL) && (xmlStrchr(name, ':') != NULL)) {
5184	xmlNsErr(ctxt, XML_NS_ERR_COLON,
5185	"colons are forbidden from PI names '%s'\n", name, NULL, NULL);
5186	}
5187	return(name);
5188	}
5189
5190	#ifdef LIBXML_CATALOG_ENABLED
5191	/**
5192	* xmlParseCatalogPI:
5193	* @ctxt: an XML parser context
5194	* @catalog: the PI value string
5195	*
5196	* parse an XML Catalog Processing Instruction.
5197	*
5198	* <?oasis-xml-catalog catalog="http://example.com/catalog.xml"?>
5199	*
5200	* Occurs only if allowed by the user and if happening in the Misc
5201	* part of the document before any doctype informations
5202	* This will add the given catalog to the parsing context in order
5203	* to be used if there is a resolution need further down in the document
5204	*/
5205
5206	static void
5207	xmlParseCatalogPI(xmlParserCtxtPtr ctxt, const xmlChar *catalog) {
5208	xmlChar *URL = NULL;
5209	const xmlChar tmp, base;
5210	xmlChar marker;
5211
5212	tmp = catalog;
5213	while (IS_BLANK_CH(*tmp)) tmp++;
5214	if (xmlStrncmp(tmp, BAD_CAST"catalog", 7))
5215	goto error;
5216	tmp += 7;
5217	while (IS_BLANK_CH(*tmp)) tmp++;
5218	if (*tmp != '=') {
5219	return;
5220	}
5221	tmp++;
5222	while (IS_BLANK_CH(*tmp)) tmp++;
5223	marker = *tmp;
5224	if ((marker != '\'') && (marker != '"'))
5225	goto error;
5226	tmp++;
5227	base = tmp;
5228	while ((tmp != 0) && (tmp != marker)) tmp++;
5229	if (*tmp == 0)
5230	goto error;
5231	URL = xmlStrndup(base, tmp - base);
5232	tmp++;
5233	while (IS_BLANK_CH(*tmp)) tmp++;
5234	if (*tmp != 0)
5235	goto error;
5236
5237	if (URL != NULL) {
5238	ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL);
5239	xmlFree(URL);
5240	}
5241	return;
5242
5243	error:
5244	xmlWarningMsg(ctxt, XML_WAR_CATALOG_PI,
5245	"Catalog PI syntax error: %s\n",
5246	catalog, NULL);
5247	if (URL != NULL)
5248	xmlFree(URL);
5249	}
5250	#endif
5251
5252	/**
5253	* xmlParsePI:
5254	* @ctxt: an XML parser context
5255	*
5256	* parse an XML Processing Instruction.
5257	*
5258	* [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'
5259	*
5260	* The processing is transfered to SAX once parsed.
5261	*/
5262
5263	void
5264	xmlParsePI(xmlParserCtxtPtr ctxt) {
5265	xmlChar *buf = NULL;
5266	size_t len = 0;
5267	size_t size = XML_PARSER_BUFFER_SIZE;
5268	int cur, l;
5269	const xmlChar *target;
5270	xmlParserInputState state;
5271	int count = 0;
5272
5273	if ((RAW == '<') && (NXT(1) == '?')) {
5274	xmlParserInputPtr input = ctxt->input;
5275	state = ctxt->instate;
5276	ctxt->instate = XML_PARSER_PI;
5277	/*
5278	* this is a Processing Instruction.
5279	*/
5280	SKIP(2);
5281	SHRINK;
5282
5283	/*
5284	* Parse the target name and check for special support like
5285	* namespace.
5286	*/
5287	target = xmlParsePITarget(ctxt);
5288	if (target != NULL) {
5289	if ((RAW == '?') && (NXT(1) == '>')) {
5290	if (input != ctxt->input) {
5291	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5292	"PI declaration doesn't start and stop in the same entity\n");
5293	}
5294	SKIP(2);
5295
5296	/*
5297	* SAX: PI detected.
5298	*/
5299	if ((ctxt->sax) && (!ctxt->disableSAX) &&
5300	(ctxt->sax->processingInstruction != NULL))
5301	ctxt->sax->processingInstruction(ctxt->userData,
5302	target, NULL);
5303	if (ctxt->instate != XML_PARSER_EOF)
5304	ctxt->instate = state;
5305	return;
5306	}
5307	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
5308	if (buf == NULL) {
5309	xmlErrMemory(ctxt, NULL);
5310	ctxt->instate = state;
5311	return;
5312	}
5313	cur = CUR;
5314	if (!IS_BLANK(cur)) {
5315	xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED,
5316	"ParsePI: PI %s space expected\n", target);
5317	}
5318	SKIP_BLANKS;
5319	cur = CUR_CHAR(l);
5320	while (IS_CHAR(cur) && /* checked */
5321	((cur != '?') \|\| (NXT(1) != '>'))) {
5322	if (len + 5 >= size) {
5323	xmlChar *tmp;
5324	size_t new_size = size * 2;
5325	tmp = (xmlChar *) xmlRealloc(buf, new_size);
5326	if (tmp == NULL) {
5327	xmlErrMemory(ctxt, NULL);
5328	xmlFree(buf);
5329	ctxt->instate = state;
5330	return;
5331	}
5332	buf = tmp;
5333	size = new_size;
5334	}
5335	count++;
5336	if (count > 50) {
5337	GROW;
5338	if (ctxt->instate == XML_PARSER_EOF) {
5339	xmlFree(buf);
5340	return;
5341	}
5342	count = 0;
5343	if ((len > XML_MAX_TEXT_LENGTH) &&
5344	((ctxt->options & XML_PARSE_HUGE) == 0)) {
5345	xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5346	"PI %s too big found", target);
5347	xmlFree(buf);
5348	ctxt->instate = state;
5349	return;
5350	}
5351	}
5352	COPY_BUF(l,buf,len,cur);
5353	NEXTL(l);
5354	cur = CUR_CHAR(l);
5355	if (cur == 0) {
5356	SHRINK;
5357	GROW;
5358	cur = CUR_CHAR(l);
5359	}
5360	}
5361	if ((len > XML_MAX_TEXT_LENGTH) &&
5362	((ctxt->options & XML_PARSE_HUGE) == 0)) {
5363	xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5364	"PI %s too big found", target);
5365	xmlFree(buf);
5366	ctxt->instate = state;
5367	return;
5368	}
5369	buf[len] = 0;
5370	if (cur != '?') {
5371	xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5372	"ParsePI: PI %s never end ...\n", target);
5373	} else {
5374	if (input != ctxt->input) {
5375	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5376	"PI declaration doesn't start and stop in the same entity\n");
5377	}
5378	SKIP(2);
5379
5380	#ifdef LIBXML_CATALOG_ENABLED
5381	if (((state == XML_PARSER_MISC) \|\|
5382	(state == XML_PARSER_START)) &&
5383	(xmlStrEqual(target, XML_CATALOG_PI))) {
5384	xmlCatalogAllow allow = xmlCatalogGetDefaults();
5385	if ((allow == XML_CATA_ALLOW_DOCUMENT) \|\|
5386	(allow == XML_CATA_ALLOW_ALL))
5387	xmlParseCatalogPI(ctxt, buf);
5388	}
5389	#endif
5390
5391
5392	/*
5393	* SAX: PI detected.
5394	*/
5395	if ((ctxt->sax) && (!ctxt->disableSAX) &&
5396	(ctxt->sax->processingInstruction != NULL))
5397	ctxt->sax->processingInstruction(ctxt->userData,
5398	target, buf);
5399	}
5400	xmlFree(buf);
5401	} else {
5402	xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL);
5403	}
5404	if (ctxt->instate != XML_PARSER_EOF)
5405	ctxt->instate = state;
5406	}
5407	}
5408
5409	/**
5410	* xmlParseNotationDecl:
5411	* @ctxt: an XML parser context
5412	*
5413	* parse a notation declaration
5414	*
5415	* [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID \| PublicID) S? '>'
5416	*
5417	* Hence there is actually 3 choices:
5418	* 'PUBLIC' S PubidLiteral
5419	* 'PUBLIC' S PubidLiteral S SystemLiteral
5420	* and 'SYSTEM' S SystemLiteral
5421	*
5422	* See the NOTE on xmlParseExternalID().
5423	*/
5424
5425	void
5426	xmlParseNotationDecl(xmlParserCtxtPtr ctxt) {
5427	const xmlChar *name;
5428	xmlChar *Pubid;
5429	xmlChar *Systemid;
5430
5431	if (CMP10(CUR_PTR, '<', '!', 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
5432	xmlParserInputPtr input = ctxt->input;
5433	SHRINK;
5434	SKIP(10);
5435	if (!IS_BLANK_CH(CUR)) {
5436	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5437	"Space required after '<!NOTATION'\n");
5438	return;
5439	}
5440	SKIP_BLANKS;
5441
5442	name = xmlParseName(ctxt);
5443	if (name == NULL) {
5444	xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5445	return;
5446	}
5447	if (!IS_BLANK_CH(CUR)) {
5448	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5449	"Space required after the NOTATION name'\n");
5450	return;
5451	}
5452	if (xmlStrchr(name, ':') != NULL) {
5453	xmlNsErr(ctxt, XML_NS_ERR_COLON,
5454	"colons are forbidden from notation names '%s'\n",
5455	name, NULL, NULL);
5456	}
5457	SKIP_BLANKS;
5458
5459	/*
5460	* Parse the IDs.
5461	*/
5462	Systemid = xmlParseExternalID(ctxt, &Pubid, 0);
5463	SKIP_BLANKS;
5464
5465	if (RAW == '>') {
5466	if (input != ctxt->input) {
5467	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5468	"Notation declaration doesn't start and stop in the same entity\n");
5469	}
5470	NEXT;
5471	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5472	(ctxt->sax->notationDecl != NULL))
5473	ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid);
5474	} else {
5475	xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5476	}
5477	if (Systemid != NULL) xmlFree(Systemid);
5478	if (Pubid != NULL) xmlFree(Pubid);
5479	}
5480	}
5481
5482	/**
5483	* xmlParseEntityDecl:
5484	* @ctxt: an XML parser context
5485	*
5486	* parse <!ENTITY declarations
5487	*
5488	* [70] EntityDecl ::= GEDecl \| PEDecl
5489	*
5490	* [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>'
5491	*
5492	* [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'
5493	*
5494	* [73] EntityDef ::= EntityValue \| (ExternalID NDataDecl?)
5495	*
5496	* [74] PEDef ::= EntityValue \| ExternalID
5497	*
5498	* [76] NDataDecl ::= S 'NDATA' S Name
5499	*
5500	* [ VC: Notation Declared ]
5501	* The Name must match the declared name of a notation.
5502	*/
5503
5504	void
5505	xmlParseEntityDecl(xmlParserCtxtPtr ctxt) {
5506	const xmlChar *name = NULL;
5507	xmlChar *value = NULL;
5508	xmlChar URI = NULL, literal = NULL;
5509	const xmlChar *ndata = NULL;
5510	int isParameter = 0;
5511	xmlChar *orig = NULL;
5512	int skipped;
5513
5514	/* GROW; done in the caller */
5515	if (CMP8(CUR_PTR, '<', '!', 'E', 'N', 'T', 'I', 'T', 'Y')) {
5516	xmlParserInputPtr input = ctxt->input;
5517	SHRINK;
5518	SKIP(8);
5519	skipped = SKIP_BLANKS;
5520	if (skipped == 0) {
5521	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5522	"Space required after '<!ENTITY'\n");
5523	}
5524
5525	if (RAW == '%') {
5526	NEXT;
5527	skipped = SKIP_BLANKS;
5528	if (skipped == 0) {
5529	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5530	"Space required after '%%'\n");
5531	}
5532	isParameter = 1;
5533	}
5534
5535	name = xmlParseName(ctxt);
5536	if (name == NULL) {
5537	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5538	"xmlParseEntityDecl: no name\n");
5539	return;
5540	}
5541	if (xmlStrchr(name, ':') != NULL) {
5542	xmlNsErr(ctxt, XML_NS_ERR_COLON,
5543	"colons are forbidden from entities names '%s'\n",
5544	name, NULL, NULL);
5545	}
5546	skipped = SKIP_BLANKS;
5547	if (skipped == 0) {
5548	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5549	"Space required after the entity name\n");
5550	}
5551
5552	ctxt->instate = XML_PARSER_ENTITY_DECL;
5553	/*
5554	* handle the various case of definitions...
5555	*/
5556	if (isParameter) {
5557	if ((RAW == '"') \|\| (RAW == '\'')) {
5558	value = xmlParseEntityValue(ctxt, &orig);
5559	if (value) {
5560	if ((ctxt->sax != NULL) &&
5561	(!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5562	ctxt->sax->entityDecl(ctxt->userData, name,
5563	XML_INTERNAL_PARAMETER_ENTITY,
5564	NULL, NULL, value);
5565	}
5566	} else {
5567	URI = xmlParseExternalID(ctxt, &literal, 1);
5568	if ((URI == NULL) && (literal == NULL)) {
5569	xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5570	}
5571	if (URI) {
5572	xmlURIPtr uri;
5573
5574	uri = xmlParseURI((const char *) URI);
5575	if (uri == NULL) {
5576	xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
5577	"Invalid URI: %s\n", URI);
5578	/*
5579	* This really ought to be a well formedness error
5580	* but the XML Core WG decided otherwise c.f. issue
5581	* E26 of the XML erratas.
5582	*/
5583	} else {
5584	if (uri->fragment != NULL) {
5585	/*
5586	* Okay this is foolish to block those but not
5587	* invalid URIs.
5588	*/
5589	xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5590	} else {
5591	if ((ctxt->sax != NULL) &&
5592	(!ctxt->disableSAX) &&
5593	(ctxt->sax->entityDecl != NULL))
5594	ctxt->sax->entityDecl(ctxt->userData, name,
5595	XML_EXTERNAL_PARAMETER_ENTITY,
5596	literal, URI, NULL);
5597	}
5598	xmlFreeURI(uri);
5599	}
5600	}
5601	}
5602	} else {
5603	if ((RAW == '"') \|\| (RAW == '\'')) {
5604	value = xmlParseEntityValue(ctxt, &orig);
5605	if ((ctxt->sax != NULL) &&
5606	(!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5607	ctxt->sax->entityDecl(ctxt->userData, name,
5608	XML_INTERNAL_GENERAL_ENTITY,
5609	NULL, NULL, value);
5610	/*
5611	* For expat compatibility in SAX mode.
5612	*/
5613	if ((ctxt->myDoc == NULL) \|\|
5614	(xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
5615	if (ctxt->myDoc == NULL) {
5616	ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5617	if (ctxt->myDoc == NULL) {
5618	xmlErrMemory(ctxt, "New Doc failed");
5619	return;
5620	}
5621	ctxt->myDoc->properties = XML_DOC_INTERNAL;
5622	}
5623	if (ctxt->myDoc->intSubset == NULL)
5624	ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5625	BAD_CAST "fake", NULL, NULL);
5626
5627	xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY,
5628	NULL, NULL, value);
5629	}
5630	} else {
5631	URI = xmlParseExternalID(ctxt, &literal, 1);
5632	if ((URI == NULL) && (literal == NULL)) {
5633	xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5634	}
5635	if (URI) {
5636	xmlURIPtr uri;
5637
5638	uri = xmlParseURI((const char *)URI);
5639	if (uri == NULL) {
5640	xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
5641	"Invalid URI: %s\n", URI);
5642	/*
5643	* This really ought to be a well formedness error
5644	* but the XML Core WG decided otherwise c.f. issue
5645	* E26 of the XML erratas.
5646	*/
5647	} else {
5648	if (uri->fragment != NULL) {
5649	/*
5650	* Okay this is foolish to block those but not
5651	* invalid URIs.
5652	*/
5653	xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5654	}
5655	xmlFreeURI(uri);
5656	}
5657	}
5658	if ((RAW != '>') && (!IS_BLANK_CH(CUR))) {
5659	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5660	"Space required before 'NDATA'\n");
5661	}
5662	SKIP_BLANKS;
5663	if (CMP5(CUR_PTR, 'N', 'D', 'A', 'T', 'A')) {
5664	SKIP(5);
5665	if (!IS_BLANK_CH(CUR)) {
5666	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5667	"Space required after 'NDATA'\n");
5668	}
5669	SKIP_BLANKS;
5670	ndata = xmlParseName(ctxt);
5671	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5672	(ctxt->sax->unparsedEntityDecl != NULL))
5673	ctxt->sax->unparsedEntityDecl(ctxt->userData, name,
5674	literal, URI, ndata);
5675	} else {
5676	if ((ctxt->sax != NULL) &&
5677	(!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5678	ctxt->sax->entityDecl(ctxt->userData, name,
5679	XML_EXTERNAL_GENERAL_PARSED_ENTITY,
5680	literal, URI, NULL);
5681	/*
5682	* For expat compatibility in SAX mode.
5683	* assuming the entity repalcement was asked for
5684	*/
5685	if ((ctxt->replaceEntities != 0) &&
5686	((ctxt->myDoc == NULL) \|\|
5687	(xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) {
5688	if (ctxt->myDoc == NULL) {
5689	ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5690	if (ctxt->myDoc == NULL) {
5691	xmlErrMemory(ctxt, "New Doc failed");
5692	return;
5693	}
5694	ctxt->myDoc->properties = XML_DOC_INTERNAL;
5695	}
5696
5697	if (ctxt->myDoc->intSubset == NULL)
5698	ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5699	BAD_CAST "fake", NULL, NULL);
5700	xmlSAX2EntityDecl(ctxt, name,
5701	XML_EXTERNAL_GENERAL_PARSED_ENTITY,
5702	literal, URI, NULL);
5703	}
5704	}
5705	}
5706	}
5707	if (ctxt->instate == XML_PARSER_EOF)
5708	return;
5709	SKIP_BLANKS;
5710	if (RAW != '>') {
5711	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
5712	"xmlParseEntityDecl: entity %s not terminated\n", name);
5713	xmlHaltParser(ctxt);
5714	} else {
5715	if (input != ctxt->input) {
5716	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5717	"Entity declaration doesn't start and stop in the same entity\n");
5718	}
5719	NEXT;
5720	}
5721	if (orig != NULL) {
5722	/*
5723	* Ugly mechanism to save the raw entity value.
5724	*/
5725	xmlEntityPtr cur = NULL;
5726
5727	if (isParameter) {
5728	if ((ctxt->sax != NULL) &&
5729	(ctxt->sax->getParameterEntity != NULL))
5730	cur = ctxt->sax->getParameterEntity(ctxt->userData, name);
5731	} else {
5732	if ((ctxt->sax != NULL) &&
5733	(ctxt->sax->getEntity != NULL))
5734	cur = ctxt->sax->getEntity(ctxt->userData, name);
5735	if ((cur == NULL) && (ctxt->userData==ctxt)) {
5736	cur = xmlSAX2GetEntity(ctxt, name);
5737	}
5738	}
5739	if (cur != NULL) {
5740	if (cur->orig != NULL)
5741	xmlFree(orig);
5742	else
5743	cur->orig = orig;
5744	} else
5745	xmlFree(orig);
5746	}
5747	if (value != NULL) xmlFree(value);
5748	if (URI != NULL) xmlFree(URI);
5749	if (literal != NULL) xmlFree(literal);
5750	}
5751	}
5752
5753	/**
5754	* xmlParseDefaultDecl:
5755	* @ctxt: an XML parser context
5756	* @value: Receive a possible fixed default value for the attribute
5757	*
5758	* Parse an attribute default declaration
5759	*
5760	* [60] DefaultDecl ::= '#REQUIRED' \| '#IMPLIED' \| (('#FIXED' S)? AttValue)
5761	*
5762	* [ VC: Required Attribute ]
5763	* if the default declaration is the keyword #REQUIRED, then the
5764	* attribute must be specified for all elements of the type in the
5765	* attribute-list declaration.
5766	*
5767	* [ VC: Attribute Default Legal ]
5768	* The declared default value must meet the lexical constraints of
5769	* the declared attribute type c.f. xmlValidateAttributeDecl()
5770	*
5771	* [ VC: Fixed Attribute Default ]
5772	* if an attribute has a default value declared with the #FIXED
5773	* keyword, instances of that attribute must match the default value.
5774	*
5775	* [ WFC: No < in Attribute Values ]
5776	* handled in xmlParseAttValue()
5777	*
5778	* returns: XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED
5779	* or XML_ATTRIBUTE_FIXED.
5780	*/
5781
5782	int
5783	xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) {
5784	int val;
5785	xmlChar *ret;
5786
5787	*value = NULL;
5788	if (CMP9(CUR_PTR, '#', 'R', 'E', 'Q', 'U', 'I', 'R', 'E', 'D')) {
5789	SKIP(9);
5790	return(XML_ATTRIBUTE_REQUIRED);
5791	}
5792	if (CMP8(CUR_PTR, '#', 'I', 'M', 'P', 'L', 'I', 'E', 'D')) {
5793	SKIP(8);
5794	return(XML_ATTRIBUTE_IMPLIED);
5795	}
5796	val = XML_ATTRIBUTE_NONE;
5797	if (CMP6(CUR_PTR, '#', 'F', 'I', 'X', 'E', 'D')) {
5798	SKIP(6);
5799	val = XML_ATTRIBUTE_FIXED;
5800	if (!IS_BLANK_CH(CUR)) {
5801	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5802	"Space required after '#FIXED'\n");
5803	}
5804	SKIP_BLANKS;
5805	}
5806	ret = xmlParseAttValue(ctxt);
5807	ctxt->instate = XML_PARSER_DTD;
5808	if (ret == NULL) {
5809	xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo,
5810	"Attribute default value declaration error\n");
5811	} else
5812	*value = ret;
5813	return(val);
5814	}
5815
5816	/**
5817	* xmlParseNotationType:
5818	* @ctxt: an XML parser context
5819	*
5820	* parse an Notation attribute type.
5821	*
5822	* Note: the leading 'NOTATION' S part has already being parsed...
5823	*
5824	* [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '\|' S? Name)* S? ')'
5825	*
5826	* [ VC: Notation Attributes ]
5827	* Values of this type must match one of the notation names included
5828	* in the declaration; all notation names in the declaration must be declared.
5829	*
5830	* Returns: the notation attribute tree built while parsing
5831	*/
5832
5833	xmlEnumerationPtr
5834	xmlParseNotationType(xmlParserCtxtPtr ctxt) {
5835	const xmlChar *name;
5836	xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp;
5837
5838	if (RAW != '(') {
5839	xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5840	return(NULL);
5841	}
5842	SHRINK;
5843	do {
5844	NEXT;
5845	SKIP_BLANKS;
5846	name = xmlParseName(ctxt);
5847	if (name == NULL) {
5848	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5849	"Name expected in NOTATION declaration\n");
5850	xmlFreeEnumeration(ret);
5851	return(NULL);
5852	}
5853	tmp = ret;
5854	while (tmp != NULL) {
5855	if (xmlStrEqual(name, tmp->name)) {
5856	xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
5857	"standalone: attribute notation value token %s duplicated\n",
5858	name, NULL);
5859	if (!xmlDictOwns(ctxt->dict, name))
5860	xmlFree((xmlChar *) name);
5861	break;
5862	}
5863	tmp = tmp->next;
5864	}
5865	if (tmp == NULL) {
5866	cur = xmlCreateEnumeration(name);
5867	if (cur == NULL) {
5868	xmlFreeEnumeration(ret);
5869	return(NULL);
5870	}
5871	if (last == NULL) ret = last = cur;
5872	else {
5873	last->next = cur;
5874	last = cur;
5875	}
5876	}
5877	SKIP_BLANKS;
5878	} while (RAW == '\|');
5879	if (RAW != ')') {
5880	xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5881	xmlFreeEnumeration(ret);
5882	return(NULL);
5883	}
5884	NEXT;
5885	return(ret);
5886	}
5887
5888	/**
5889	* xmlParseEnumerationType:
5890	* @ctxt: an XML parser context
5891	*
5892	* parse an Enumeration attribute type.
5893	*
5894	* [59] Enumeration ::= '(' S? Nmtoken (S? '\|' S? Nmtoken)* S? ')'
5895	*
5896	* [ VC: Enumeration ]
5897	* Values of this type must match one of the Nmtoken tokens in
5898	* the declaration
5899	*
5900	* Returns: the enumeration attribute tree built while parsing
5901	*/
5902
5903	xmlEnumerationPtr
5904	xmlParseEnumerationType(xmlParserCtxtPtr ctxt) {
5905	xmlChar *name;
5906	xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp;
5907
5908	if (RAW != '(') {
5909	xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
5910	return(NULL);
5911	}
5912	SHRINK;
5913	do {
5914	NEXT;
5915	SKIP_BLANKS;
5916	name = xmlParseNmtoken(ctxt);
5917	if (name == NULL) {
5918	xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
5919	return(ret);
5920	}
5921	tmp = ret;
5922	while (tmp != NULL) {
5923	if (xmlStrEqual(name, tmp->name)) {
5924	xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
5925	"standalone: attribute enumeration value token %s duplicated\n",
5926	name, NULL);
5927	if (!xmlDictOwns(ctxt->dict, name))
5928	xmlFree(name);
5929	break;
5930	}
5931	tmp = tmp->next;
5932	}
5933	if (tmp == NULL) {
5934	cur = xmlCreateEnumeration(name);
5935	if (!xmlDictOwns(ctxt->dict, name))
5936	xmlFree(name);
5937	if (cur == NULL) {
5938	xmlFreeEnumeration(ret);
5939	return(NULL);
5940	}
5941	if (last == NULL) ret = last = cur;
5942	else {
5943	last->next = cur;
5944	last = cur;
5945	}
5946	}
5947	SKIP_BLANKS;
5948	} while (RAW == '\|');
5949	if (RAW != ')') {
5950	xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
5951	return(ret);
5952	}
5953	NEXT;
5954	return(ret);
5955	}
5956
5957	/**
5958	* xmlParseEnumeratedType:
5959	* @ctxt: an XML parser context
5960	* @tree: the enumeration tree built while parsing
5961	*
5962	* parse an Enumerated attribute type.
5963	*
5964	* [57] EnumeratedType ::= NotationType \| Enumeration
5965	*
5966	* [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '\|' S? Name)* S? ')'
5967	*
5968	*
5969	* Returns: XML_ATTRIBUTE_ENUMERATION or XML_ATTRIBUTE_NOTATION
5970	*/
5971
5972	int
5973	xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
5974	if (CMP8(CUR_PTR, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
5975	SKIP(8);
5976	if (!IS_BLANK_CH(CUR)) {
5977	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5978	"Space required after 'NOTATION'\n");
5979	return(0);
5980	}
5981	SKIP_BLANKS;
5982	*tree = xmlParseNotationType(ctxt);
5983	if (*tree == NULL) return(0);
5984	return(XML_ATTRIBUTE_NOTATION);
5985	}
5986	*tree = xmlParseEnumerationType(ctxt);
5987	if (*tree == NULL) return(0);
5988	return(XML_ATTRIBUTE_ENUMERATION);
5989	}
5990
5991	/**
5992	* xmlParseAttributeType:
5993	* @ctxt: an XML parser context
5994	* @tree: the enumeration tree built while parsing
5995	*
5996	* parse the Attribute list def for an element
5997	*
5998	* [54] AttType ::= StringType \| TokenizedType \| EnumeratedType
5999	*
6000	* [55] StringType ::= 'CDATA'
6001	*
6002	* [56] TokenizedType ::= 'ID' \| 'IDREF' \| 'IDREFS' \| 'ENTITY' \|
6003	* 'ENTITIES' \| 'NMTOKEN' \| 'NMTOKENS'
6004	*
6005	* Validity constraints for attribute values syntax are checked in
6006	* xmlValidateAttributeValue()
6007	*
6008	* [ VC: ID ]
6009	* Values of type ID must match the Name production. A name must not
6010	* appear more than once in an XML document as a value of this type;
6011	* i.e., ID values must uniquely identify the elements which bear them.
6012	*
6013	* [ VC: One ID per Element Type ]
6014	* No element type may have more than one ID attribute specified.
6015	*
6016	* [ VC: ID Attribute Default ]
6017	* An ID attribute must have a declared default of #IMPLIED or #REQUIRED.
6018	*
6019	* [ VC: IDREF ]
6020	* Values of type IDREF must match the Name production, and values
6021	* of type IDREFS must match Names; each IDREF Name must match the value
6022	* of an ID attribute on some element in the XML document; i.e. IDREF
6023	* values must match the value of some ID attribute.
6024	*
6025	* [ VC: Entity Name ]
6026	* Values of type ENTITY must match the Name production, values
6027	* of type ENTITIES must match Names; each Entity Name must match the
6028	* name of an unparsed entity declared in the DTD.
6029	*
6030	* [ VC: Name Token ]
6031	* Values of type NMTOKEN must match the Nmtoken production; values
6032	* of type NMTOKENS must match Nmtokens.
6033	*
6034	* Returns the attribute type
6035	*/
6036	int
6037	xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
6038	SHRINK;
6039	if (CMP5(CUR_PTR, 'C', 'D', 'A', 'T', 'A')) {
6040	SKIP(5);
6041	return(XML_ATTRIBUTE_CDATA);
6042	} else if (CMP6(CUR_PTR, 'I', 'D', 'R', 'E', 'F', 'S')) {
6043	SKIP(6);
6044	return(XML_ATTRIBUTE_IDREFS);
6045	} else if (CMP5(CUR_PTR, 'I', 'D', 'R', 'E', 'F')) {
6046	SKIP(5);
6047	return(XML_ATTRIBUTE_IDREF);
6048	} else if ((RAW == 'I') && (NXT(1) == 'D')) {
6049	SKIP(2);
6050	return(XML_ATTRIBUTE_ID);
6051	} else if (CMP6(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'Y')) {
6052	SKIP(6);
6053	return(XML_ATTRIBUTE_ENTITY);
6054	} else if (CMP8(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S')) {
6055	SKIP(8);
6056	return(XML_ATTRIBUTE_ENTITIES);
6057	} else if (CMP8(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S')) {
6058	SKIP(8);
6059	return(XML_ATTRIBUTE_NMTOKENS);
6060	} else if (CMP7(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N')) {
6061	SKIP(7);
6062	return(XML_ATTRIBUTE_NMTOKEN);
6063	}
6064	return(xmlParseEnumeratedType(ctxt, tree));
6065	}
6066
6067	/**
6068	* xmlParseAttributeListDecl:
6069	* @ctxt: an XML parser context
6070	*
6071	* : parse the Attribute list def for an element
6072	*
6073	* [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'
6074	*
6075	* [53] AttDef ::= S Name S AttType S DefaultDecl
6076	*
6077	*/
6078	void
6079	xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) {
6080	const xmlChar *elemName;
6081	const xmlChar *attrName;
6082	xmlEnumerationPtr tree;
6083
6084	if (CMP9(CUR_PTR, '<', '!', 'A', 'T', 'T', 'L', 'I', 'S', 'T')) {
6085	xmlParserInputPtr input = ctxt->input;
6086
6087	SKIP(9);
6088	if (!IS_BLANK_CH(CUR)) {
6089	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6090	"Space required after '<!ATTLIST'\n");
6091	}
6092	SKIP_BLANKS;
6093	elemName = xmlParseName(ctxt);
6094	if (elemName == NULL) {
6095	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6096	"ATTLIST: no name for Element\n");
6097	return;
6098	}
6099	SKIP_BLANKS;
6100	GROW;
6101	while ((RAW != '>') && (ctxt->instate != XML_PARSER_EOF)) {
6102	const xmlChar *check = CUR_PTR;
6103	int type;
6104	int def;
6105	xmlChar *defaultValue = NULL;
6106
6107	GROW;
6108	tree = NULL;
6109	attrName = xmlParseName(ctxt);
6110	if (attrName == NULL) {
6111	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6112	"ATTLIST: no name for Attribute\n");
6113	break;
6114	}
6115	GROW;
6116	if (!IS_BLANK_CH(CUR)) {
6117	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6118	"Space required after the attribute name\n");
6119	break;
6120	}
6121	SKIP_BLANKS;
6122
6123	type = xmlParseAttributeType(ctxt, &tree);
6124	if (type <= 0) {
6125	break;
6126	}
6127
6128	GROW;
6129	if (!IS_BLANK_CH(CUR)) {
6130	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6131	"Space required after the attribute type\n");
6132	if (tree != NULL)
6133	xmlFreeEnumeration(tree);
6134	break;
6135	}
6136	SKIP_BLANKS;
6137
6138	def = xmlParseDefaultDecl(ctxt, &defaultValue);
6139	if (def <= 0) {
6140	if (defaultValue != NULL)
6141	xmlFree(defaultValue);
6142	if (tree != NULL)
6143	xmlFreeEnumeration(tree);
6144	break;
6145	}
6146	if ((type != XML_ATTRIBUTE_CDATA) && (defaultValue != NULL))
6147	xmlAttrNormalizeSpace(defaultValue, defaultValue);
6148
6149	GROW;
6150	if (RAW != '>') {
6151	if (!IS_BLANK_CH(CUR)) {
6152	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6153	"Space required after the attribute default value\n");
6154	if (defaultValue != NULL)
6155	xmlFree(defaultValue);
6156	if (tree != NULL)
6157	xmlFreeEnumeration(tree);
6158	break;
6159	}
6160	SKIP_BLANKS;
6161	}
6162	if (check == CUR_PTR) {
6163	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
6164	"in xmlParseAttributeListDecl\n");
6165	if (defaultValue != NULL)
6166	xmlFree(defaultValue);
6167	if (tree != NULL)
6168	xmlFreeEnumeration(tree);
6169	break;
6170	}
6171	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
6172	(ctxt->sax->attributeDecl != NULL))
6173	ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
6174	type, def, defaultValue, tree);
6175	else if (tree != NULL)
6176	xmlFreeEnumeration(tree);
6177
6178	if ((ctxt->sax2) && (defaultValue != NULL) &&
6179	(def != XML_ATTRIBUTE_IMPLIED) &&
6180	(def != XML_ATTRIBUTE_REQUIRED)) {
6181	xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue);
6182	}
6183	if (ctxt->sax2) {
6184	xmlAddSpecialAttr(ctxt, elemName, attrName, type);
6185	}
6186	if (defaultValue != NULL)
6187	xmlFree(defaultValue);
6188	GROW;
6189	}
6190	if (RAW == '>') {
6191	if (input != ctxt->input) {
6192	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6193	"Attribute list declaration doesn't start and stop in the same entity\n",
6194	NULL, NULL);
6195	}
6196	NEXT;
6197	}
6198	}
6199	}
6200
6201	/**
6202	* xmlParseElementMixedContentDecl:
6203	* @ctxt: an XML parser context
6204	* @inputchk: the input used for the current entity, needed for boundary checks
6205	*
6206	* parse the declaration for a Mixed Element content
6207	* The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6208	*
6209	* [51] Mixed ::= '(' S? '#PCDATA' (S? '\|' S? Name)* S? ')*' \|
6210	* '(' S? '#PCDATA' S? ')'
6211	*
6212	* [ VC: Proper Group/PE Nesting ] applies to [51] too (see [49])
6213	*
6214	* [ VC: No Duplicate Types ]
6215	* The same name must not appear more than once in a single
6216	* mixed-content declaration.
6217	*
6218	* returns: the list of the xmlElementContentPtr describing the element choices
6219	*/
6220	xmlElementContentPtr
6221	xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
6222	xmlElementContentPtr ret = NULL, cur = NULL, n;
6223	const xmlChar *elem = NULL;
6224
6225	GROW;
6226	if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
6227	SKIP(7);
6228	SKIP_BLANKS;
6229	SHRINK;
6230	if (RAW == ')') {
6231	if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
6232	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6233	"Element content declaration doesn't start and stop in the same entity\n",
6234	NULL, NULL);
6235	}
6236	NEXT;
6237	ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
6238	if (ret == NULL)
6239	return(NULL);
6240	if (RAW == '*') {
6241	ret->ocur = XML_ELEMENT_CONTENT_MULT;
6242	NEXT;
6243	}
6244	return(ret);
6245	}
6246	if ((RAW == '(') \|\| (RAW == '\|')) {
6247	ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
6248	if (ret == NULL) return(NULL);
6249	}
6250	while ((RAW == '\|') && (ctxt->instate != XML_PARSER_EOF)) {
6251	NEXT;
6252	if (elem == NULL) {
6253	ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6254	if (ret == NULL) return(NULL);
6255	ret->c1 = cur;
6256	if (cur != NULL)
6257	cur->parent = ret;
6258	cur = ret;
6259	} else {
6260	n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6261	if (n == NULL) return(NULL);
6262	n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6263	if (n->c1 != NULL)
6264	n->c1->parent = n;
6265	cur->c2 = n;
6266	if (n != NULL)
6267	n->parent = cur;
6268	cur = n;
6269	}
6270	SKIP_BLANKS;
6271	elem = xmlParseName(ctxt);
6272	if (elem == NULL) {
6273	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6274	"xmlParseElementMixedContentDecl : Name expected\n");
6275	xmlFreeDocElementContent(ctxt->myDoc, cur);
6276	return(NULL);
6277	}
6278	SKIP_BLANKS;
6279	GROW;
6280	}
6281	if ((RAW == ')') && (NXT(1) == '*')) {
6282	if (elem != NULL) {
6283	cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem,
6284	XML_ELEMENT_CONTENT_ELEMENT);
6285	if (cur->c2 != NULL)
6286	cur->c2->parent = cur;
6287	}
6288	if (ret != NULL)
6289	ret->ocur = XML_ELEMENT_CONTENT_MULT;
6290	if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
6291	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6292	"Element content declaration doesn't start and stop in the same entity\n",
6293	NULL, NULL);
6294	}
6295	SKIP(2);
6296	} else {
6297	xmlFreeDocElementContent(ctxt->myDoc, ret);
6298	xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
6299	return(NULL);
6300	}
6301
6302	} else {
6303	xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
6304	}
6305	return(ret);
6306	}
6307
6308	/**
6309	* xmlParseElementChildrenContentDeclPriv:
6310	* @ctxt: an XML parser context
6311	* @inputchk: the input used for the current entity, needed for boundary checks
6312	* @depth: the level of recursion
6313	*
6314	* parse the declaration for a Mixed Element content
6315	* The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6316	*
6317	*
6318	* [47] children ::= (choice \| seq) ('?' \| '*' \| '+')?
6319	*
6320	* [48] cp ::= (Name \| choice \| seq) ('?' \| '*' \| '+')?
6321	*
6322	* [49] choice ::= '(' S? cp ( S? '\|' S? cp )* S? ')'
6323	*
6324	* [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
6325	*
6326	* [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
6327	* TODO Parameter-entity replacement text must be properly nested
6328	* with parenthesized groups. That is to say, if either of the
6329	* opening or closing parentheses in a choice, seq, or Mixed
6330	* construct is contained in the replacement text for a parameter
6331	* entity, both must be contained in the same replacement text. For
6332	* interoperability, if a parameter-entity reference appears in a
6333	* choice, seq, or Mixed construct, its replacement text should not
6334	* be empty, and neither the first nor last non-blank character of
6335	* the replacement text should be a connector (\| or ,).
6336	*
6337	* Returns the tree of xmlElementContentPtr describing the element
6338	* hierarchy.
6339	*/
6340	static xmlElementContentPtr
6341	xmlParseElementChildrenContentDeclPriv(xmlParserCtxtPtr ctxt, int inputchk,
6342	int depth) {
6343	xmlElementContentPtr ret = NULL, cur = NULL, last = NULL, op = NULL;
6344	const xmlChar *elem;
6345	xmlChar type = 0;
6346
6347	if (((depth > 128) && ((ctxt->options & XML_PARSE_HUGE) == 0)) \|\|
6348	(depth > 2048)) {
6349	xmlFatalErrMsgInt(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED,
6350	"xmlParseElementChildrenContentDecl : depth %d too deep, use XML_PARSE_HUGE\n",
6351	depth);
6352	return(NULL);
6353	}
6354	SKIP_BLANKS;
6355	GROW;
6356	if (RAW == '(') {
6357	int inputid = ctxt->input->id;
6358
6359	/* Recurse on first child */
6360	NEXT;
6361	SKIP_BLANKS;
6362	cur = ret = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
6363	depth + 1);
6364	SKIP_BLANKS;
6365	GROW;
6366	} else {
6367	elem = xmlParseName(ctxt);
6368	if (elem == NULL) {
6369	xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6370	return(NULL);
6371	}
6372	cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6373	if (cur == NULL) {
6374	xmlErrMemory(ctxt, NULL);
6375	return(NULL);
6376	}
6377	GROW;
6378	if (RAW == '?') {
6379	cur->ocur = XML_ELEMENT_CONTENT_OPT;
6380	NEXT;
6381	} else if (RAW == '*') {
6382	cur->ocur = XML_ELEMENT_CONTENT_MULT;
6383	NEXT;
6384	} else if (RAW == '+') {
6385	cur->ocur = XML_ELEMENT_CONTENT_PLUS;
6386	NEXT;
6387	} else {
6388	cur->ocur = XML_ELEMENT_CONTENT_ONCE;
6389	}
6390	GROW;
6391	}
6392	SKIP_BLANKS;
6393	SHRINK;
6394	while ((RAW != ')') && (ctxt->instate != XML_PARSER_EOF)) {
6395	/*
6396	* Each loop we parse one separator and one element.
6397	*/
6398	if (RAW == ',') {
6399	if (type == 0) type = CUR;
6400
6401	/*
6402	* Detect "Name \| Name , Name" error
6403	*/
6404	else if (type != CUR) {
6405	xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6406	"xmlParseElementChildrenContentDecl : '%c' expected\n",
6407	type);
6408	if ((last != NULL) && (last != ret))
6409	xmlFreeDocElementContent(ctxt->myDoc, last);
6410	if (ret != NULL)
6411	xmlFreeDocElementContent(ctxt->myDoc, ret);
6412	return(NULL);
6413	}
6414	NEXT;
6415
6416	op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ);
6417	if (op == NULL) {
6418	if ((last != NULL) && (last != ret))
6419	xmlFreeDocElementContent(ctxt->myDoc, last);
6420	xmlFreeDocElementContent(ctxt->myDoc, ret);
6421	return(NULL);
6422	}
6423	if (last == NULL) {
6424	op->c1 = ret;
6425	if (ret != NULL)
6426	ret->parent = op;
6427	ret = cur = op;
6428	} else {
6429	cur->c2 = op;
6430	if (op != NULL)
6431	op->parent = cur;
6432	op->c1 = last;
6433	if (last != NULL)
6434	last->parent = op;
6435	cur =op;
6436	last = NULL;
6437	}
6438	} else if (RAW == '\|') {
6439	if (type == 0) type = CUR;
6440
6441	/*
6442	* Detect "Name , Name \| Name" error
6443	*/
6444	else if (type != CUR) {
6445	xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6446	"xmlParseElementChildrenContentDecl : '%c' expected\n",
6447	type);
6448	if ((last != NULL) && (last != ret))
6449	xmlFreeDocElementContent(ctxt->myDoc, last);
6450	if (ret != NULL)
6451	xmlFreeDocElementContent(ctxt->myDoc, ret);
6452	return(NULL);
6453	}
6454	NEXT;
6455
6456	op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6457	if (op == NULL) {
6458	if ((last != NULL) && (last != ret))
6459	xmlFreeDocElementContent(ctxt->myDoc, last);
6460	if (ret != NULL)
6461	xmlFreeDocElementContent(ctxt->myDoc, ret);
6462	return(NULL);
6463	}
6464	if (last == NULL) {
6465	op->c1 = ret;
6466	if (ret != NULL)
6467	ret->parent = op;
6468	ret = cur = op;
6469	} else {
6470	cur->c2 = op;
6471	if (op != NULL)
6472	op->parent = cur;
6473	op->c1 = last;
6474	if (last != NULL)
6475	last->parent = op;
6476	cur =op;
6477	last = NULL;
6478	}
6479	} else {
6480	xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL);
6481	if ((last != NULL) && (last != ret))
6482	xmlFreeDocElementContent(ctxt->myDoc, last);
6483	if (ret != NULL)
6484	xmlFreeDocElementContent(ctxt->myDoc, ret);
6485	return(NULL);
6486	}
6487	GROW;
6488	SKIP_BLANKS;
6489	GROW;
6490	if (RAW == '(') {
6491	int inputid = ctxt->input->id;
6492	/* Recurse on second child */
6493	NEXT;
6494	SKIP_BLANKS;
6495	last = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
6496	depth + 1);
6497	SKIP_BLANKS;
6498	} else {
6499	elem = xmlParseName(ctxt);
6500	if (elem == NULL) {
6501	xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6502	if (ret != NULL)
6503	xmlFreeDocElementContent(ctxt->myDoc, ret);
6504	return(NULL);
6505	}
6506	last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6507	if (last == NULL) {
6508	if (ret != NULL)
6509	xmlFreeDocElementContent(ctxt->myDoc, ret);
6510	return(NULL);
6511	}
6512	if (RAW == '?') {
6513	last->ocur = XML_ELEMENT_CONTENT_OPT;
6514	NEXT;
6515	} else if (RAW == '*') {
6516	last->ocur = XML_ELEMENT_CONTENT_MULT;
6517	NEXT;
6518	} else if (RAW == '+') {
6519	last->ocur = XML_ELEMENT_CONTENT_PLUS;
6520	NEXT;
6521	} else {
6522	last->ocur = XML_ELEMENT_CONTENT_ONCE;
6523	}
6524	}
6525	SKIP_BLANKS;
6526	GROW;
6527	}
6528	if ((cur != NULL) && (last != NULL)) {
6529	cur->c2 = last;
6530	if (last != NULL)
6531	last->parent = cur;
6532	}
6533	if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
6534	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6535	"Element content declaration doesn't start and stop in the same entity\n",
6536	NULL, NULL);
6537	}
6538	NEXT;
6539	if (RAW == '?') {
6540	if (ret != NULL) {
6541	if ((ret->ocur == XML_ELEMENT_CONTENT_PLUS) \|\|
6542	(ret->ocur == XML_ELEMENT_CONTENT_MULT))
6543	ret->ocur = XML_ELEMENT_CONTENT_MULT;
6544	else
6545	ret->ocur = XML_ELEMENT_CONTENT_OPT;
6546	}
6547	NEXT;
6548	} else if (RAW == '*') {
6549	if (ret != NULL) {
6550	ret->ocur = XML_ELEMENT_CONTENT_MULT;
6551	cur = ret;
6552	/*
6553	* Some normalization:
6554	* (a \| b* \| c?)* == (a \| b \| c)*
6555	*/
6556	while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
6557	if ((cur->c1 != NULL) &&
6558	((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
6559	(cur->c1->ocur == XML_ELEMENT_CONTENT_MULT)))
6560	cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
6561	if ((cur->c2 != NULL) &&
6562	((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
6563	(cur->c2->ocur == XML_ELEMENT_CONTENT_MULT)))
6564	cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
6565	cur = cur->c2;
6566	}
6567	}
6568	NEXT;
6569	} else if (RAW == '+') {
6570	if (ret != NULL) {
6571	int found = 0;
6572
6573	if ((ret->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
6574	(ret->ocur == XML_ELEMENT_CONTENT_MULT))
6575	ret->ocur = XML_ELEMENT_CONTENT_MULT;
6576	else
6577	ret->ocur = XML_ELEMENT_CONTENT_PLUS;
6578	/*
6579	* Some normalization:
6580	* (a \| b)+ == (a \| b)
6581	* (a \| b?)+ == (a \| b)*
6582	*/
6583	while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
6584	if ((cur->c1 != NULL) &&
6585	((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
6586	(cur->c1->ocur == XML_ELEMENT_CONTENT_MULT))) {
6587	cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
6588	found = 1;
6589	}
6590	if ((cur->c2 != NULL) &&
6591	((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
6592	(cur->c2->ocur == XML_ELEMENT_CONTENT_MULT))) {
6593	cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
6594	found = 1;
6595	}
6596	cur = cur->c2;
6597	}
6598	if (found)
6599	ret->ocur = XML_ELEMENT_CONTENT_MULT;
6600	}
6601	NEXT;
6602	}
6603	return(ret);
6604	}
6605
6606	/**
6607	* xmlParseElementChildrenContentDecl:
6608	* @ctxt: an XML parser context
6609	* @inputchk: the input used for the current entity, needed for boundary checks
6610	*
6611	* parse the declaration for a Mixed Element content
6612	* The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6613	*
6614	* [47] children ::= (choice \| seq) ('?' \| '*' \| '+')?
6615	*
6616	* [48] cp ::= (Name \| choice \| seq) ('?' \| '*' \| '+')?
6617	*
6618	* [49] choice ::= '(' S? cp ( S? '\|' S? cp )* S? ')'
6619	*
6620	* [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
6621	*
6622	* [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
6623	* TODO Parameter-entity replacement text must be properly nested
6624	* with parenthesized groups. That is to say, if either of the
6625	* opening or closing parentheses in a choice, seq, or Mixed
6626	* construct is contained in the replacement text for a parameter
6627	* entity, both must be contained in the same replacement text. For
6628	* interoperability, if a parameter-entity reference appears in a
6629	* choice, seq, or Mixed construct, its replacement text should not
6630	* be empty, and neither the first nor last non-blank character of
6631	* the replacement text should be a connector (\| or ,).
6632	*
6633	* Returns the tree of xmlElementContentPtr describing the element
6634	* hierarchy.
6635	*/
6636	xmlElementContentPtr
6637	xmlParseElementChildrenContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
6638	/* stub left for API/ABI compat */
6639	return(xmlParseElementChildrenContentDeclPriv(ctxt, inputchk, 1));
6640	}
6641
6642	/**
6643	* xmlParseElementContentDecl:
6644	* @ctxt: an XML parser context
6645	* @name: the name of the element being defined.
6646	* @result: the Element Content pointer will be stored here if any
6647	*
6648	* parse the declaration for an Element content either Mixed or Children,
6649	* the cases EMPTY and ANY are handled directly in xmlParseElementDecl
6650	*
6651	* [46] contentspec ::= 'EMPTY' \| 'ANY' \| Mixed \| children
6652	*
6653	* returns: the type of element content XML_ELEMENT_TYPE_xxx
6654	*/
6655
6656	int
6657	xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name,
6658	xmlElementContentPtr *result) {
6659
6660	xmlElementContentPtr tree = NULL;
6661	int inputid = ctxt->input->id;
6662	int res;
6663
6664	*result = NULL;
6665
6666	if (RAW != '(') {
6667	xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6668	"xmlParseElementContentDecl : %s '(' expected\n", name);
6669	return(-1);
6670	}
6671	NEXT;
6672	GROW;
6673	if (ctxt->instate == XML_PARSER_EOF)
6674	return(-1);
6675	SKIP_BLANKS;
6676	if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
6677	tree = xmlParseElementMixedContentDecl(ctxt, inputid);
6678	res = XML_ELEMENT_TYPE_MIXED;
6679	} else {
6680	tree = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 1);
6681	res = XML_ELEMENT_TYPE_ELEMENT;
6682	}
6683	SKIP_BLANKS;
6684	*result = tree;
6685	return(res);
6686	}
6687
6688	/**
6689	* xmlParseElementDecl:
6690	* @ctxt: an XML parser context
6691	*
6692	* parse an Element declaration.
6693	*
6694	* [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>'
6695	*
6696	* [ VC: Unique Element Type Declaration ]
6697	* No element type may be declared more than once
6698	*
6699	* Returns the type of the element, or -1 in case of error
6700	*/
6701	int
6702	xmlParseElementDecl(xmlParserCtxtPtr ctxt) {
6703	const xmlChar *name;
6704	int ret = -1;
6705	xmlElementContentPtr content = NULL;
6706
6707	/* GROW; done in the caller */
6708	if (CMP9(CUR_PTR, '<', '!', 'E', 'L', 'E', 'M', 'E', 'N', 'T')) {
6709	xmlParserInputPtr input = ctxt->input;
6710
6711	SKIP(9);
6712	if (!IS_BLANK_CH(CUR)) {
6713	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6714	"Space required after 'ELEMENT'\n");
6715	return(-1);
6716	}
6717	SKIP_BLANKS;
6718	name = xmlParseName(ctxt);
6719	if (name == NULL) {
6720	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6721	"xmlParseElementDecl: no name for Element\n");
6722	return(-1);
6723	}
6724	while ((RAW == 0) && (ctxt->inputNr > 1))
6725	xmlPopInput(ctxt);
6726	if (!IS_BLANK_CH(CUR)) {
6727	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6728	"Space required after the element name\n");
6729	}
6730	SKIP_BLANKS;
6731	if (CMP5(CUR_PTR, 'E', 'M', 'P', 'T', 'Y')) {
6732	SKIP(5);
6733	/*
6734	* Element must always be empty.
6735	*/
6736	ret = XML_ELEMENT_TYPE_EMPTY;
6737	} else if ((RAW == 'A') && (NXT(1) == 'N') &&
6738	(NXT(2) == 'Y')) {
6739	SKIP(3);
6740	/*
6741	* Element is a generic container.
6742	*/
6743	ret = XML_ELEMENT_TYPE_ANY;
6744	} else if (RAW == '(') {
6745	ret = xmlParseElementContentDecl(ctxt, name, &content);
6746	} else {
6747	/*
6748	* [ WFC: PEs in Internal Subset ] error handling.
6749	*/
6750	if ((RAW == '%') && (ctxt->external == 0) &&
6751	(ctxt->inputNr == 1)) {
6752	xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET,
6753	"PEReference: forbidden within markup decl in internal subset\n");
6754	} else {
6755	xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6756	"xmlParseElementDecl: 'EMPTY', 'ANY' or '(' expected\n");
6757	}
6758	return(-1);
6759	}
6760
6761	SKIP_BLANKS;
6762	/*
6763	* Pop-up of finished entities.
6764	*/
6765	while ((RAW == 0) && (ctxt->inputNr > 1))
6766	xmlPopInput(ctxt);
6767	SKIP_BLANKS;
6768
6769	if (RAW != '>') {
6770	xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
6771	if (content != NULL) {
6772	xmlFreeDocElementContent(ctxt->myDoc, content);
6773	}
6774	} else {
6775	if (input != ctxt->input) {
6776	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6777	"Element declaration doesn't start and stop in the same entity\n");
6778	}
6779
6780	NEXT;
6781	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
6782	(ctxt->sax->elementDecl != NULL)) {
6783	if (content != NULL)
6784	content->parent = NULL;
6785	ctxt->sax->elementDecl(ctxt->userData, name, ret,
6786	content);
6787	if ((content != NULL) && (content->parent == NULL)) {
6788	/*
6789	* this is a trick: if xmlAddElementDecl is called,
6790	* instead of copying the full tree it is plugged directly
6791	* if called from the parser. Avoid duplicating the
6792	* interfaces or change the API/ABI
6793	*/
6794	xmlFreeDocElementContent(ctxt->myDoc, content);
6795	}
6796	} else if (content != NULL) {
6797	xmlFreeDocElementContent(ctxt->myDoc, content);
6798	}
6799	}
6800	}
6801	return(ret);
6802	}
6803
6804	/**
6805	* xmlParseConditionalSections
6806	* @ctxt: an XML parser context
6807	*
6808	* [61] conditionalSect ::= includeSect \| ignoreSect
6809	* [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>'
6810	* [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>'
6811	* [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)*
6812	* [65] Ignore ::= Char* - (Char* ('<![' \| ']]>') Char*)
6813	*/
6814
6815	static void
6816	xmlParseConditionalSections(xmlParserCtxtPtr ctxt) {
6817	int id = ctxt->input->id;
6818
6819	SKIP(3);
6820	SKIP_BLANKS;
6821	if (CMP7(CUR_PTR, 'I', 'N', 'C', 'L', 'U', 'D', 'E')) {
6822	SKIP(7);
6823	SKIP_BLANKS;
6824	if (RAW != '[') {
6825	xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
6826	xmlHaltParser(ctxt);
6827	return;
6828	} else {
6829	if (ctxt->input->id != id) {
6830	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6831	"All markup of the conditional section is not in the same entity\n",
6832	NULL, NULL);
6833	}
6834	NEXT;
6835	}
6836	if (xmlParserDebugEntities) {
6837	if ((ctxt->input != NULL) && (ctxt->input->filename))
6838	xmlGenericError(xmlGenericErrorContext,
6839	"%s(%d): ", ctxt->input->filename,
6840	ctxt->input->line);
6841	xmlGenericError(xmlGenericErrorContext,
6842	"Entering INCLUDE Conditional Section\n");
6843	}
6844
6845	while (((RAW != 0) && ((RAW != ']') \|\| (NXT(1) != ']') \|\|
6846	(NXT(2) != '>'))) && (ctxt->instate != XML_PARSER_EOF)) {
6847	const xmlChar *check = CUR_PTR;
6848	unsigned int cons = ctxt->input->consumed;
6849
6850	if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
6851	xmlParseConditionalSections(ctxt);
6852	} else if (IS_BLANK_CH(CUR)) {
6853	NEXT;
6854	} else if (RAW == '%') {
6855	xmlParsePEReference(ctxt);
6856	} else
6857	xmlParseMarkupDecl(ctxt);
6858
6859	/*
6860	* Pop-up of finished entities.
6861	*/
6862	while ((RAW == 0) && (ctxt->inputNr > 1))
6863	xmlPopInput(ctxt);
6864
6865	if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
6866	xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6867	xmlHaltParser(ctxt);
6868	break;
6869	}
6870	}
6871	if (xmlParserDebugEntities) {
6872	if ((ctxt->input != NULL) && (ctxt->input->filename))
6873	xmlGenericError(xmlGenericErrorContext,
6874	"%s(%d): ", ctxt->input->filename,
6875	ctxt->input->line);
6876	xmlGenericError(xmlGenericErrorContext,
6877	"Leaving INCLUDE Conditional Section\n");
6878	}
6879
6880	} else if (CMP6(CUR_PTR, 'I', 'G', 'N', 'O', 'R', 'E')) {
6881	int state;
6882	xmlParserInputState instate;
6883	int depth = 0;
6884
6885	SKIP(6);
6886	SKIP_BLANKS;
6887	if (RAW != '[') {
6888	xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
6889	xmlHaltParser(ctxt);
6890	return;
6891	} else {
6892	if (ctxt->input->id != id) {
6893	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6894	"All markup of the conditional section is not in the same entity\n",
6895	NULL, NULL);
6896	}
6897	NEXT;
6898	}
6899	if (xmlParserDebugEntities) {
6900	if ((ctxt->input != NULL) && (ctxt->input->filename))
6901	xmlGenericError(xmlGenericErrorContext,
6902	"%s(%d): ", ctxt->input->filename,
6903	ctxt->input->line);
6904	xmlGenericError(xmlGenericErrorContext,
6905	"Entering IGNORE Conditional Section\n");
6906	}
6907
6908	/*
6909	* Parse up to the end of the conditional section
6910	* But disable SAX event generating DTD building in the meantime
6911	*/
6912	state = ctxt->disableSAX;
6913	instate = ctxt->instate;
6914	if (ctxt->recovery == 0) ctxt->disableSAX = 1;
6915	ctxt->instate = XML_PARSER_IGNORE;
6916
6917	while (((depth >= 0) && (RAW != 0)) &&
6918	(ctxt->instate != XML_PARSER_EOF)) {
6919	if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
6920	depth++;
6921	SKIP(3);
6922	continue;
6923	}
6924	if ((RAW == ']') && (NXT(1) == ']') && (NXT(2) == '>')) {
6925	if (--depth >= 0) SKIP(3);
6926	continue;
6927	}
6928	NEXT;
6929	continue;
6930	}
6931
6932	ctxt->disableSAX = state;
6933	ctxt->instate = instate;
6934
6935	if (xmlParserDebugEntities) {
6936	if ((ctxt->input != NULL) && (ctxt->input->filename))
6937	xmlGenericError(xmlGenericErrorContext,
6938	"%s(%d): ", ctxt->input->filename,
6939	ctxt->input->line);
6940	xmlGenericError(xmlGenericErrorContext,
6941	"Leaving IGNORE Conditional Section\n");
6942	}
6943
6944	} else {
6945	xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
6946	xmlHaltParser(ctxt);
6947	return;
6948	}
6949
6950	if (RAW == 0)
6951	SHRINK;
6952
6953	if (RAW == 0) {
6954	xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
6955	} else {
6956	if (ctxt->input->id != id) {
6957	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6958	"All markup of the conditional section is not in the same entity\n",
6959	NULL, NULL);
6960	}
6961	if ((ctxt-> instate != XML_PARSER_EOF) &&
6962	((ctxt->input->cur + 3) <= ctxt->input->end))
6963	SKIP(3);
6964	}
6965	}
6966
6967	/**
6968	* xmlParseMarkupDecl:
6969	* @ctxt: an XML parser context
6970	*
6971	* parse Markup declarations
6972	*
6973	* [29] markupdecl ::= elementdecl \| AttlistDecl \| EntityDecl \|
6974	* NotationDecl \| PI \| Comment
6975	*
6976	* [ VC: Proper Declaration/PE Nesting ]
6977	* Parameter-entity replacement text must be properly nested with
6978	* markup declarations. That is to say, if either the first character
6979	* or the last character of a markup declaration (markupdecl above) is
6980	* contained in the replacement text for a parameter-entity reference,
6981	* both must be contained in the same replacement text.
6982	*
6983	* [ WFC: PEs in Internal Subset ]
6984	* In the internal DTD subset, parameter-entity references can occur
6985	* only where markup declarations can occur, not within markup declarations.
6986	* (This does not apply to references that occur in external parameter
6987	* entities or to the external subset.)
6988	*/
6989	void
6990	xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) {
6991	GROW;
6992	if (CUR == '<') {
6993	if (NXT(1) == '!') {
6994	switch (NXT(2)) {
6995	case 'E':
6996	if (NXT(3) == 'L')
6997	xmlParseElementDecl(ctxt);
6998	else if (NXT(3) == 'N')
6999	xmlParseEntityDecl(ctxt);
7000	break;
7001	case 'A':
7002	xmlParseAttributeListDecl(ctxt);
7003	break;
7004	case 'N':
7005	xmlParseNotationDecl(ctxt);
7006	break;
7007	case '-':
7008	xmlParseComment(ctxt);
7009	break;
7010	default:
7011	/* there is an error but it will be detected later */
7012	break;
7013	}
7014	} else if (NXT(1) == '?') {
7015	xmlParsePI(ctxt);
7016	}
7017	}
7018
7019	/*
7020	* detect requirement to exit there and act accordingly
7021	* and avoid having instate overriden later on
7022	*/
7023	if (ctxt->instate == XML_PARSER_EOF)
7024	return;
7025
7026	/*
7027	* This is only for internal subset. On external entities,
7028	* the replacement is done before parsing stage
7029	*/
7030	if ((ctxt->external == 0) && (ctxt->inputNr == 1))
7031	xmlParsePEReference(ctxt);
7032
7033	/*
7034	* Conditional sections are allowed from entities included
7035	* by PE References in the internal subset.
7036	*/
7037	if ((ctxt->external == 0) && (ctxt->inputNr > 1)) {
7038	if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
7039	xmlParseConditionalSections(ctxt);
7040	}
7041	}
7042
7043	ctxt->instate = XML_PARSER_DTD;
7044	}
7045
7046	/**
7047	* xmlParseTextDecl:
7048	* @ctxt: an XML parser context
7049	*
7050	* parse an XML declaration header for external entities
7051	*
7052	* [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
7053	*/
7054
7055	void
7056	xmlParseTextDecl(xmlParserCtxtPtr ctxt) {
7057	xmlChar *version;
7058	const xmlChar *encoding;
7059
7060	/*
7061	* We know that '<?xml' is here.
7062	*/
7063	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
7064	SKIP(5);
7065	} else {
7066	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL);
7067	return;
7068	}
7069
7070	if (!IS_BLANK_CH(CUR)) {
7071	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
7072	"Space needed after '<?xml'\n");
7073	}
7074	SKIP_BLANKS;
7075
7076	/*
7077	* We may have the VersionInfo here.
7078	*/
7079	version = xmlParseVersionInfo(ctxt);
7080	if (version == NULL)
7081	version = xmlCharStrdup(XML_DEFAULT_VERSION);
7082	else {
7083	if (!IS_BLANK_CH(CUR)) {
7084	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
7085	"Space needed here\n");
7086	}
7087	}
7088	ctxt->input->version = version;
7089
7090	/*
7091	* We must have the encoding declaration
7092	*/
7093	encoding = xmlParseEncodingDecl(ctxt);
7094	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
7095	/*
7096	* The XML REC instructs us to stop parsing right here
7097	*/
7098	return;
7099	}
7100	if ((encoding == NULL) && (ctxt->errNo == XML_ERR_OK)) {
7101	xmlFatalErrMsg(ctxt, XML_ERR_MISSING_ENCODING,
7102	"Missing encoding in text declaration\n");
7103	}
7104
7105	SKIP_BLANKS;
7106	if ((RAW == '?') && (NXT(1) == '>')) {
7107	SKIP(2);
7108	} else if (RAW == '>') {
7109	/* Deprecated old WD ... */
7110	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
7111	NEXT;
7112	} else {
7113	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
7114	MOVETO_ENDTAG(CUR_PTR);
7115	NEXT;
7116	}
7117	}
7118
7119	/**
7120	* xmlParseExternalSubset:
7121	* @ctxt: an XML parser context
7122	* @ExternalID: the external identifier
7123	* @SystemID: the system identifier (or URL)
7124	*
7125	* parse Markup declarations from an external subset
7126	*
7127	* [30] extSubset ::= textDecl? extSubsetDecl
7128	*
7129	* [31] extSubsetDecl ::= (markupdecl \| conditionalSect \| PEReference \| S) *
7130	*/
7131	void
7132	xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID,
7133	const xmlChar *SystemID) {
7134	xmlDetectSAX2(ctxt);
7135	GROW;
7136
7137	if ((ctxt->encoding == NULL) &&
7138	(ctxt->input->end - ctxt->input->cur >= 4)) {
7139	xmlChar start[4];
7140	xmlCharEncoding enc;
7141
7142	start[0] = RAW;
7143	start[1] = NXT(1);
7144	start[2] = NXT(2);
7145	start[3] = NXT(3);
7146	enc = xmlDetectCharEncoding(start, 4);
7147	if (enc != XML_CHAR_ENCODING_NONE)
7148	xmlSwitchEncoding(ctxt, enc);
7149	}
7150
7151	if (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) {
7152	xmlParseTextDecl(ctxt);
7153	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
7154	/*
7155	* The XML REC instructs us to stop parsing right here
7156	*/
7157	xmlHaltParser(ctxt);
7158	return;
7159	}
7160	}
7161	if (ctxt->myDoc == NULL) {
7162	ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
7163	if (ctxt->myDoc == NULL) {
7164	xmlErrMemory(ctxt, "New Doc failed");
7165	return;
7166	}
7167	ctxt->myDoc->properties = XML_DOC_INTERNAL;
7168	}
7169	if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
7170	xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
7171
7172	ctxt->instate = XML_PARSER_DTD;
7173	ctxt->external = 1;
7174	while (((RAW == '<') && (NXT(1) == '?')) \|\|
7175	((RAW == '<') && (NXT(1) == '!')) \|\|
7176	(RAW == '%') \|\| IS_BLANK_CH(CUR)) {
7177	const xmlChar *check = CUR_PTR;
7178	unsigned int cons = ctxt->input->consumed;
7179
7180	GROW;
7181	if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
7182	xmlParseConditionalSections(ctxt);
7183	} else if (IS_BLANK_CH(CUR)) {
7184	NEXT;
7185	} else if (RAW == '%') {
7186	xmlParsePEReference(ctxt);
7187	} else
7188	xmlParseMarkupDecl(ctxt);
7189
7190	/*
7191	* Pop-up of finished entities.
7192	*/
7193	while ((RAW == 0) && (ctxt->inputNr > 1))
7194	xmlPopInput(ctxt);
7195
7196	if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
7197	xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
7198	break;
7199	}
7200	}
7201
7202	if (RAW != 0) {
7203	xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
7204	}
7205
7206	}
7207
7208	/**
7209	* xmlParseReference:
7210	* @ctxt: an XML parser context
7211	*
7212	* parse and handle entity references in content, depending on the SAX
7213	* interface, this may end-up in a call to character() if this is a
7214	* CharRef, a predefined entity, if there is no reference() callback.
7215	* or if the parser was asked to switch to that mode.
7216	*
7217	* [67] Reference ::= EntityRef \| CharRef
7218	*/
7219	void
7220	xmlParseReference(xmlParserCtxtPtr ctxt) {
7221	xmlEntityPtr ent;
7222	xmlChar *val;
7223	int was_checked;
7224	xmlNodePtr list = NULL;
7225	xmlParserErrors ret = XML_ERR_OK;
7226
7227
7228	if (RAW != '&')
7229	return;
7230
7231	/*
7232	* Simple case of a CharRef
7233	*/
7234	if (NXT(1) == '#') {
7235	int i = 0;
7236	xmlChar out[10];
7237	int hex = NXT(2);
7238	int value = xmlParseCharRef(ctxt);
7239
7240	if (value == 0)
7241	return;
7242	if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
7243	/*
7244	* So we are using non-UTF-8 buffers
7245	* Check that the char fit on 8bits, if not
7246	* generate a CharRef.
7247	*/
7248	if (value <= 0xFF) {
7249	out[0] = value;
7250	out[1] = 0;
7251	if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7252	(!ctxt->disableSAX))
7253	ctxt->sax->characters(ctxt->userData, out, 1);
7254	} else {
7255	if ((hex == 'x') \|\| (hex == 'X'))
7256	snprintf((char *)out, sizeof(out), "#x%X", value);
7257	else
7258	snprintf((char *)out, sizeof(out), "#%d", value);
7259	if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7260	(!ctxt->disableSAX))
7261	ctxt->sax->reference(ctxt->userData, out);
7262	}
7263	} else {
7264	/*
7265	* Just encode the value in UTF-8
7266	*/
7267	COPY_BUF(0 ,out, i, value);
7268	out[i] = 0;
7269	if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7270	(!ctxt->disableSAX))
7271	ctxt->sax->characters(ctxt->userData, out, i);
7272	}
7273	return;
7274	}
7275
7276	/*
7277	* We are seeing an entity reference
7278	*/
7279	ent = xmlParseEntityRef(ctxt);
7280	if (ent == NULL) return;
7281	if (!ctxt->wellFormed)
7282	return;
7283	was_checked = ent->checked;
7284
7285	/* special case of predefined entities */
7286	if ((ent->name == NULL) \|\|
7287	(ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
7288	val = ent->content;
7289	if (val == NULL) return;
7290	/*
7291	* inline the entity.
7292	*/
7293	if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7294	(!ctxt->disableSAX))
7295	ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
7296	return;
7297	}
7298
7299	/*
7300	* The first reference to the entity trigger a parsing phase
7301	* where the ent->children is filled with the result from
7302	* the parsing.
7303	* Note: external parsed entities will not be loaded, it is not
7304	* required for a non-validating parser, unless the parsing option
7305	* of validating, or substituting entities were given. Doing so is
7306	* far more secure as the parser will only process data coming from
7307	* the document entity by default.
7308	*/
7309	if (((ent->checked == 0) \|\|
7310	((ent->children == NULL) && (ctxt->options & XML_PARSE_NOENT))) &&
7311	((ent->etype != XML_EXTERNAL_GENERAL_PARSED_ENTITY) \|\|
7312	(ctxt->options & (XML_PARSE_NOENT \| XML_PARSE_DTDVALID)))) {
7313	unsigned long oldnbent = ctxt->nbentities;
7314
7315	/*
7316	* This is a bit hackish but this seems the best
7317	* way to make sure both SAX and DOM entity support
7318	* behaves okay.
7319	*/
7320	void *user_data;
7321	if (ctxt->userData == ctxt)
7322	user_data = NULL;
7323	else
7324	user_data = ctxt->userData;
7325
7326	/*
7327	* Check that this entity is well formed
7328	* 4.3.2: An internal general parsed entity is well-formed
7329	* if its replacement text matches the production labeled
7330	* content.
7331	*/
7332	if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
7333	ctxt->depth++;
7334	ret = xmlParseBalancedChunkMemoryInternal(ctxt, ent->content,
7335	user_data, &list);
7336	ctxt->depth--;
7337
7338	} else if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
7339	ctxt->depth++;
7340	ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt, ctxt->sax,
7341	user_data, ctxt->depth, ent->URI,
7342	ent->ExternalID, &list);
7343	ctxt->depth--;
7344	} else {
7345	ret = XML_ERR_ENTITY_PE_INTERNAL;
7346	xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
7347	"invalid entity type found\n", NULL);
7348	}
7349
7350	/*
7351	* Store the number of entities needing parsing for this entity
7352	* content and do checkings
7353	*/
7354	ent->checked = (ctxt->nbentities - oldnbent + 1) * 2;
7355	if ((ent->content != NULL) && (xmlStrchr(ent->content, '<')))
7356	ent->checked \|= 1;
7357	if (ret == XML_ERR_ENTITY_LOOP) {
7358	xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
7359	xmlFreeNodeList(list);
7360	return;
7361	}
7362	if (xmlParserEntityCheck(ctxt, 0, ent, 0)) {
7363	xmlFreeNodeList(list);
7364	return;
7365	}
7366
7367	if ((ret == XML_ERR_OK) && (list != NULL)) {
7368	if (((ent->etype == XML_INTERNAL_GENERAL_ENTITY) \|\|
7369	(ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY))&&
7370	(ent->children == NULL)) {
7371	ent->children = list;
7372	if (ctxt->replaceEntities) {
7373	/*
7374	* Prune it directly in the generated document
7375	* except for single text nodes.
7376	*/
7377	if (((list->type == XML_TEXT_NODE) &&
7378	(list->next == NULL)) \|\|
7379	(ctxt->parseMode == XML_PARSE_READER)) {
7380	list->parent = (xmlNodePtr) ent;
7381	list = NULL;
7382	ent->owner = 1;
7383	} else {
7384	ent->owner = 0;
7385	while (list != NULL) {
7386	list->parent = (xmlNodePtr) ctxt->node;
7387	list->doc = ctxt->myDoc;
7388	if (list->next == NULL)
7389	ent->last = list;
7390	list = list->next;
7391	}
7392	list = ent->children;
7393	#ifdef LIBXML_LEGACY_ENABLED
7394	if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
7395	xmlAddEntityReference(ent, list, NULL);
7396	#endif /* LIBXML_LEGACY_ENABLED */
7397	}
7398	} else {
7399	ent->owner = 1;
7400	while (list != NULL) {
7401	list->parent = (xmlNodePtr) ent;
7402	xmlSetTreeDoc(list, ent->doc);
7403	if (list->next == NULL)
7404	ent->last = list;
7405	list = list->next;
7406	}
7407	}
7408	} else {
7409	xmlFreeNodeList(list);
7410	list = NULL;
7411	}
7412	} else if ((ret != XML_ERR_OK) &&
7413	(ret != XML_WAR_UNDECLARED_ENTITY)) {
7414	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7415	"Entity '%s' failed to parse\n", ent->name);
7416	xmlParserEntityCheck(ctxt, 0, ent, 0);
7417	} else if (list != NULL) {
7418	xmlFreeNodeList(list);
7419	list = NULL;
7420	}
7421	if (ent->checked == 0)
7422	ent->checked = 2;
7423	} else if (ent->checked != 1) {
7424	ctxt->nbentities += ent->checked / 2;
7425	}
7426
7427	/*
7428	* Now that the entity content has been gathered
7429	* provide it to the application, this can take different forms based
7430	* on the parsing modes.
7431	*/
7432	if (ent->children == NULL) {
7433	/*
7434	* Probably running in SAX mode and the callbacks don't
7435	* build the entity content. So unless we already went
7436	* though parsing for first checking go though the entity
7437	* content to generate callbacks associated to the entity
7438	*/
7439	if (was_checked != 0) {
7440	void *user_data;
7441	/*
7442	* This is a bit hackish but this seems the best
7443	* way to make sure both SAX and DOM entity support
7444	* behaves okay.
7445	*/
7446	if (ctxt->userData == ctxt)
7447	user_data = NULL;
7448	else
7449	user_data = ctxt->userData;
7450
7451	if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
7452	ctxt->depth++;
7453	ret = xmlParseBalancedChunkMemoryInternal(ctxt,
7454	ent->content, user_data, NULL);
7455	ctxt->depth--;
7456	} else if (ent->etype ==
7457	XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
7458	ctxt->depth++;
7459	ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
7460	ctxt->sax, user_data, ctxt->depth,
7461	ent->URI, ent->ExternalID, NULL);
7462	ctxt->depth--;
7463	} else {
7464	ret = XML_ERR_ENTITY_PE_INTERNAL;
7465	xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
7466	"invalid entity type found\n", NULL);
7467	}
7468	if (ret == XML_ERR_ENTITY_LOOP) {
7469	xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
7470	return;
7471	}
7472	}
7473	if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7474	(ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
7475	/*
7476	* Entity reference callback comes second, it's somewhat
7477	* superfluous but a compatibility to historical behaviour
7478	*/
7479	ctxt->sax->reference(ctxt->userData, ent->name);
7480	}
7481	return;
7482	}
7483
7484	/*
7485	* If we didn't get any children for the entity being built
7486	*/
7487	if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7488	(ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
7489	/*
7490	* Create a node.
7491	*/
7492	ctxt->sax->reference(ctxt->userData, ent->name);
7493	return;
7494	}
7495
7496	if ((ctxt->replaceEntities) \|\| (ent->children == NULL)) {
7497	/*
7498	* There is a problem on the handling of _private for entities
7499	* (bug 155816): Should we copy the content of the field from
7500	* the entity (possibly overwriting some value set by the user
7501	* when a copy is created), should we leave it alone, or should
7502	* we try to take care of different situations? The problem
7503	* is exacerbated by the usage of this field by the xmlReader.
7504	* To fix this bug, we look at _private on the created node
7505	* and, if it's NULL, we copy in whatever was in the entity.
7506	* If it's not NULL we leave it alone. This is somewhat of a
7507	* hack - maybe we should have further tests to determine
7508	* what to do.
7509	*/
7510	if ((ctxt->node != NULL) && (ent->children != NULL)) {
7511	/*
7512	* Seems we are generating the DOM content, do
7513	* a simple tree copy for all references except the first
7514	* In the first occurrence list contains the replacement.
7515	*/
7516	if (((list == NULL) && (ent->owner == 0)) \|\|
7517	(ctxt->parseMode == XML_PARSE_READER)) {
7518	xmlNodePtr nw = NULL, cur, firstChild = NULL;
7519
7520	/*
7521	* We are copying here, make sure there is no abuse
7522	*/
7523	ctxt->sizeentcopy += ent->length + 5;
7524	if (xmlParserEntityCheck(ctxt, 0, ent, ctxt->sizeentcopy))
7525	return;
7526
7527	/*
7528	* when operating on a reader, the entities definitions
7529	* are always owning the entities subtree.
7530	if (ctxt->parseMode == XML_PARSE_READER)
7531	ent->owner = 1;
7532	*/
7533
7534	cur = ent->children;
7535	while (cur != NULL) {
7536	nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7537	if (nw != NULL) {
7538	if (nw->_private == NULL)
7539	nw->_private = cur->_private;
7540	if (firstChild == NULL){
7541	firstChild = nw;
7542	}
7543	nw = xmlAddChild(ctxt->node, nw);
7544	}
7545	if (cur == ent->last) {
7546	/*
7547	* needed to detect some strange empty
7548	* node cases in the reader tests
7549	*/
7550	if ((ctxt->parseMode == XML_PARSE_READER) &&
7551	(nw != NULL) &&
7552	(nw->type == XML_ELEMENT_NODE) &&
7553	(nw->children == NULL))
7554	nw->extra = 1;
7555
7556	break;
7557	}
7558	cur = cur->next;
7559	}
7560	#ifdef LIBXML_LEGACY_ENABLED
7561	if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
7562	xmlAddEntityReference(ent, firstChild, nw);
7563	#endif /* LIBXML_LEGACY_ENABLED */
7564	} else if ((list == NULL) \|\| (ctxt->inputNr > 0)) {
7565	xmlNodePtr nw = NULL, cur, next, last,
7566	firstChild = NULL;
7567
7568	/*
7569	* We are copying here, make sure there is no abuse
7570	*/
7571	ctxt->sizeentcopy += ent->length + 5;
7572	if (xmlParserEntityCheck(ctxt, 0, ent, ctxt->sizeentcopy))
7573	return;
7574
7575	/*
7576	* Copy the entity child list and make it the new
7577	* entity child list. The goal is to make sure any
7578	* ID or REF referenced will be the one from the
7579	* document content and not the entity copy.
7580	*/
7581	cur = ent->children;
7582	ent->children = NULL;
7583	last = ent->last;
7584	ent->last = NULL;
7585	while (cur != NULL) {
7586	next = cur->next;
7587	cur->next = NULL;
7588	cur->parent = NULL;
7589	nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7590	if (nw != NULL) {
7591	if (nw->_private == NULL)
7592	nw->_private = cur->_private;
7593	if (firstChild == NULL){
7594	firstChild = cur;
7595	}
7596	xmlAddChild((xmlNodePtr) ent, nw);
7597	xmlAddChild(ctxt->node, cur);
7598	}
7599	if (cur == last)
7600	break;
7601	cur = next;
7602	}
7603	if (ent->owner == 0)
7604	ent->owner = 1;
7605	#ifdef LIBXML_LEGACY_ENABLED
7606	if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
7607	xmlAddEntityReference(ent, firstChild, nw);
7608	#endif /* LIBXML_LEGACY_ENABLED */
7609	} else {
7610	const xmlChar *nbktext;
7611
7612	/*
7613	* the name change is to avoid coalescing of the
7614	* node with a possible previous text one which
7615	* would make ent->children a dangling pointer
7616	*/
7617	nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
7618	-1);
7619	if (ent->children->type == XML_TEXT_NODE)
7620	ent->children->name = nbktext;
7621	if ((ent->last != ent->children) &&
7622	(ent->last->type == XML_TEXT_NODE))
7623	ent->last->name = nbktext;
7624	xmlAddChildList(ctxt->node, ent->children);
7625	}
7626
7627	/*
7628	* This is to avoid a nasty side effect, see
7629	* characters() in SAX.c
7630	*/
7631	ctxt->nodemem = 0;
7632	ctxt->nodelen = 0;
7633	return;
7634	}
7635	}
7636	}
7637
7638	/**
7639	* xmlParseEntityRef:
7640	* @ctxt: an XML parser context
7641	*
7642	* parse ENTITY references declarations
7643	*
7644	* [68] EntityRef ::= '&' Name ';'
7645	*
7646	* [ WFC: Entity Declared ]
7647	* In a document without any DTD, a document with only an internal DTD
7648	* subset which contains no parameter entity references, or a document
7649	* with "standalone='yes'", the Name given in the entity reference
7650	* must match that in an entity declaration, except that well-formed
7651	* documents need not declare any of the following entities: amp, lt,
7652	* gt, apos, quot. The declaration of a parameter entity must precede
7653	* any reference to it. Similarly, the declaration of a general entity
7654	* must precede any reference to it which appears in a default value in an
7655	* attribute-list declaration. Note that if entities are declared in the
7656	* external subset or in external parameter entities, a non-validating
7657	* processor is not obligated to read and process their declarations;
7658	* for such documents, the rule that an entity must be declared is a
7659	* well-formedness constraint only if standalone='yes'.
7660	*
7661	* [ WFC: Parsed Entity ]
7662	* An entity reference must not contain the name of an unparsed entity
7663	*
7664	* Returns the xmlEntityPtr if found, or NULL otherwise.
7665	*/
7666	xmlEntityPtr
7667	xmlParseEntityRef(xmlParserCtxtPtr ctxt) {
7668	const xmlChar *name;
7669	xmlEntityPtr ent = NULL;
7670
7671	GROW;
7672	if (ctxt->instate == XML_PARSER_EOF)
7673	return(NULL);
7674
7675	if (RAW != '&')
7676	return(NULL);
7677	NEXT;
7678	name = xmlParseName(ctxt);
7679	if (name == NULL) {
7680	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7681	"xmlParseEntityRef: no name\n");
7682	return(NULL);
7683	}
7684	if (RAW != ';') {
7685	xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7686	return(NULL);
7687	}
7688	NEXT;
7689
7690	/*
7691	* Predefined entities override any extra definition
7692	*/
7693	if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7694	ent = xmlGetPredefinedEntity(name);
7695	if (ent != NULL)
7696	return(ent);
7697	}
7698
7699	/*
7700	* Increase the number of entity references parsed
7701	*/
7702	ctxt->nbentities++;
7703
7704	/*
7705	* Ask first SAX for entity resolution, otherwise try the
7706	* entities which may have stored in the parser context.
7707	*/
7708	if (ctxt->sax != NULL) {
7709	if (ctxt->sax->getEntity != NULL)
7710	ent = ctxt->sax->getEntity(ctxt->userData, name);
7711	if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7712	(ctxt->options & XML_PARSE_OLDSAX))
7713	ent = xmlGetPredefinedEntity(name);
7714	if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7715	(ctxt->userData==ctxt)) {
7716	ent = xmlSAX2GetEntity(ctxt, name);
7717	}
7718	}
7719	if (ctxt->instate == XML_PARSER_EOF)
7720	return(NULL);
7721	/*
7722	* [ WFC: Entity Declared ]
7723	* In a document without any DTD, a document with only an
7724	* internal DTD subset which contains no parameter entity
7725	* references, or a document with "standalone='yes'", the
7726	* Name given in the entity reference must match that in an
7727	* entity declaration, except that well-formed documents
7728	* need not declare any of the following entities: amp, lt,
7729	* gt, apos, quot.
7730	* The declaration of a parameter entity must precede any
7731	* reference to it.
7732	* Similarly, the declaration of a general entity must
7733	* precede any reference to it which appears in a default
7734	* value in an attribute-list declaration. Note that if
7735	* entities are declared in the external subset or in
7736	* external parameter entities, a non-validating processor
7737	* is not obligated to read and process their declarations;
7738	* for such documents, the rule that an entity must be
7739	* declared is a well-formedness constraint only if
7740	* standalone='yes'.
7741	*/
7742	if (ent == NULL) {
7743	if ((ctxt->standalone == 1) \|\|
7744	((ctxt->hasExternalSubset == 0) &&
7745	(ctxt->hasPErefs == 0))) {
7746	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7747	"Entity '%s' not defined\n", name);
7748	} else {
7749	xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7750	"Entity '%s' not defined\n", name);
7751	if ((ctxt->inSubset == 0) &&
7752	(ctxt->sax != NULL) &&
7753	(ctxt->sax->reference != NULL)) {
7754	ctxt->sax->reference(ctxt->userData, name);
7755	}
7756	}
7757	xmlParserEntityCheck(ctxt, 0, ent, 0);
7758	ctxt->valid = 0;
7759	}
7760
7761	/*
7762	* [ WFC: Parsed Entity ]
7763	* An entity reference must not contain the name of an
7764	* unparsed entity
7765	*/
7766	else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
7767	xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7768	"Entity reference to unparsed entity %s\n", name);
7769	}
7770
7771	/*
7772	* [ WFC: No External Entity References ]
7773	* Attribute values cannot contain direct or indirect
7774	* entity references to external entities.
7775	*/
7776	else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7777	(ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
7778	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7779	"Attribute references external entity '%s'\n", name);
7780	}
7781	/*
7782	* [ WFC: No < in Attribute Values ]
7783	* The replacement text of any entity referred to directly or
7784	* indirectly in an attribute value (other than "<") must
7785	* not contain a <.
7786	*/
7787	else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7788	(ent != NULL) &&
7789	(ent->etype != XML_INTERNAL_PREDEFINED_ENTITY)) {
7790	if (((ent->checked & 1) \|\| (ent->checked == 0)) &&
7791	(ent->content != NULL) && (xmlStrchr(ent->content, '<'))) {
7792	xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
7793	"'<' in entity '%s' is not allowed in attributes values\n", name);
7794	}
7795	}
7796
7797	/*
7798	* Internal check, no parameter entities here ...
7799	*/
7800	else {
7801	switch (ent->etype) {
7802	case XML_INTERNAL_PARAMETER_ENTITY:
7803	case XML_EXTERNAL_PARAMETER_ENTITY:
7804	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
7805	"Attempt to reference the parameter entity '%s'\n",
7806	name);
7807	break;
7808	default:
7809	break;
7810	}
7811	}
7812
7813	/*
7814	* [ WFC: No Recursion ]
7815	* A parsed entity must not contain a recursive reference
7816	* to itself, either directly or indirectly.
7817	* Done somewhere else
7818	*/
7819	return(ent);
7820	}
7821
7822	/**
7823	* xmlParseStringEntityRef:
7824	* @ctxt: an XML parser context
7825	* @str: a pointer to an index in the string
7826	*
7827	* parse ENTITY references declarations, but this version parses it from
7828	* a string value.
7829	*
7830	* [68] EntityRef ::= '&' Name ';'
7831	*
7832	* [ WFC: Entity Declared ]
7833	* In a document without any DTD, a document with only an internal DTD
7834	* subset which contains no parameter entity references, or a document
7835	* with "standalone='yes'", the Name given in the entity reference
7836	* must match that in an entity declaration, except that well-formed
7837	* documents need not declare any of the following entities: amp, lt,
7838	* gt, apos, quot. The declaration of a parameter entity must precede
7839	* any reference to it. Similarly, the declaration of a general entity
7840	* must precede any reference to it which appears in a default value in an
7841	* attribute-list declaration. Note that if entities are declared in the
7842	* external subset or in external parameter entities, a non-validating
7843	* processor is not obligated to read and process their declarations;
7844	* for such documents, the rule that an entity must be declared is a
7845	* well-formedness constraint only if standalone='yes'.
7846	*
7847	* [ WFC: Parsed Entity ]
7848	* An entity reference must not contain the name of an unparsed entity
7849	*
7850	* Returns the xmlEntityPtr if found, or NULL otherwise. The str pointer
7851	* is updated to the current location in the string.
7852	*/
7853	static xmlEntityPtr
7854	xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
7855	xmlChar *name;
7856	const xmlChar *ptr;
7857	xmlChar cur;
7858	xmlEntityPtr ent = NULL;
7859
7860	if ((str == NULL) \|\| (*str == NULL))
7861	return(NULL);
7862	ptr = *str;
7863	cur = *ptr;
7864	if (cur != '&')
7865	return(NULL);
7866
7867	ptr++;
7868	name = xmlParseStringName(ctxt, &ptr);
7869	if (name == NULL) {
7870	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7871	"xmlParseStringEntityRef: no name\n");
7872	*str = ptr;
7873	return(NULL);
7874	}
7875	if (*ptr != ';') {
7876	xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7877	xmlFree(name);
7878	*str = ptr;
7879	return(NULL);
7880	}
7881	ptr++;
7882
7883
7884	/*
7885	* Predefined entities override any extra definition
7886	*/
7887	if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7888	ent = xmlGetPredefinedEntity(name);
7889	if (ent != NULL) {
7890	xmlFree(name);
7891	*str = ptr;
7892	return(ent);
7893	}
7894	}
7895
7896	/*
7897	* Increate the number of entity references parsed
7898	*/
7899	ctxt->nbentities++;
7900
7901	/*
7902	* Ask first SAX for entity resolution, otherwise try the
7903	* entities which may have stored in the parser context.
7904	*/
7905	if (ctxt->sax != NULL) {
7906	if (ctxt->sax->getEntity != NULL)
7907	ent = ctxt->sax->getEntity(ctxt->userData, name);
7908	if ((ent == NULL) && (ctxt->options & XML_PARSE_OLDSAX))
7909	ent = xmlGetPredefinedEntity(name);
7910	if ((ent == NULL) && (ctxt->userData==ctxt)) {
7911	ent = xmlSAX2GetEntity(ctxt, name);
7912	}
7913	}
7914	if (ctxt->instate == XML_PARSER_EOF) {
7915	xmlFree(name);
7916	return(NULL);
7917	}
7918
7919	/*
7920	* [ WFC: Entity Declared ]
7921	* In a document without any DTD, a document with only an
7922	* internal DTD subset which contains no parameter entity
7923	* references, or a document with "standalone='yes'", the
7924	* Name given in the entity reference must match that in an
7925	* entity declaration, except that well-formed documents
7926	* need not declare any of the following entities: amp, lt,
7927	* gt, apos, quot.
7928	* The declaration of a parameter entity must precede any
7929	* reference to it.
7930	* Similarly, the declaration of a general entity must
7931	* precede any reference to it which appears in a default
7932	* value in an attribute-list declaration. Note that if
7933	* entities are declared in the external subset or in
7934	* external parameter entities, a non-validating processor
7935	* is not obligated to read and process their declarations;
7936	* for such documents, the rule that an entity must be
7937	* declared is a well-formedness constraint only if
7938	* standalone='yes'.
7939	*/
7940	if (ent == NULL) {
7941	if ((ctxt->standalone == 1) \|\|
7942	((ctxt->hasExternalSubset == 0) &&
7943	(ctxt->hasPErefs == 0))) {
7944	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7945	"Entity '%s' not defined\n", name);
7946	} else {
7947	xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7948	"Entity '%s' not defined\n",
7949	name);
7950	}
7951	xmlParserEntityCheck(ctxt, 0, ent, 0);
7952	/* TODO ? check regressions ctxt->valid = 0; */
7953	}
7954
7955	/*
7956	* [ WFC: Parsed Entity ]
7957	* An entity reference must not contain the name of an
7958	* unparsed entity
7959	*/
7960	else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
7961	xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7962	"Entity reference to unparsed entity %s\n", name);
7963	}
7964
7965	/*
7966	* [ WFC: No External Entity References ]
7967	* Attribute values cannot contain direct or indirect
7968	* entity references to external entities.
7969	*/
7970	else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7971	(ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
7972	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7973	"Attribute references external entity '%s'\n", name);
7974	}
7975	/*
7976	* [ WFC: No < in Attribute Values ]
7977	* The replacement text of any entity referred to directly or
7978	* indirectly in an attribute value (other than "<") must
7979	* not contain a <.
7980	*/
7981	else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7982	(ent != NULL) && (ent->content != NULL) &&
7983	(ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
7984	(xmlStrchr(ent->content, '<'))) {
7985	xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
7986	"'<' in entity '%s' is not allowed in attributes values\n",
7987	name);
7988	}
7989
7990	/*
7991	* Internal check, no parameter entities here ...
7992	*/
7993	else {
7994	switch (ent->etype) {
7995	case XML_INTERNAL_PARAMETER_ENTITY:
7996	case XML_EXTERNAL_PARAMETER_ENTITY:
7997	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
7998	"Attempt to reference the parameter entity '%s'\n",
7999	name);
8000	break;
8001	default:
8002	break;
8003	}
8004	}
8005
8006	/*
8007	* [ WFC: No Recursion ]
8008	* A parsed entity must not contain a recursive reference
8009	* to itself, either directly or indirectly.
8010	* Done somewhere else
8011	*/
8012
8013	xmlFree(name);
8014	*str = ptr;
8015	return(ent);
8016	}
8017
8018	/**
8019	* xmlParsePEReference:
8020	* @ctxt: an XML parser context
8021	*
8022	* parse PEReference declarations
8023	* The entity content is handled directly by pushing it's content as
8024	* a new input stream.
8025	*
8026	* [69] PEReference ::= '%' Name ';'
8027	*
8028	* [ WFC: No Recursion ]
8029	* A parsed entity must not contain a recursive
8030	* reference to itself, either directly or indirectly.
8031	*
8032	* [ WFC: Entity Declared ]
8033	* In a document without any DTD, a document with only an internal DTD
8034	* subset which contains no parameter entity references, or a document
8035	* with "standalone='yes'", ... ... The declaration of a parameter
8036	* entity must precede any reference to it...
8037	*
8038	* [ VC: Entity Declared ]
8039	* In a document with an external subset or external parameter entities
8040	* with "standalone='no'", ... ... The declaration of a parameter entity
8041	* must precede any reference to it...
8042	*
8043	* [ WFC: In DTD ]
8044	* Parameter-entity references may only appear in the DTD.
8045	* NOTE: misleading but this is handled.
8046	*/
8047	void
8048	xmlParsePEReference(xmlParserCtxtPtr ctxt)
8049	{
8050	const xmlChar *name;
8051	xmlEntityPtr entity = NULL;
8052	xmlParserInputPtr input;
8053
8054	if (RAW != '%')
8055	return;
8056	NEXT;
8057	name = xmlParseName(ctxt);
8058	if (name == NULL) {
8059	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8060	"xmlParsePEReference: no name\n");
8061	return;
8062	}
8063	if (RAW != ';') {
8064	xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
8065	return;
8066	}
8067
8068	NEXT;
8069
8070	/*
8071	* Increate the number of entity references parsed
8072	*/
8073	ctxt->nbentities++;
8074
8075	/*
8076	* Request the entity from SAX
8077	*/
8078	if ((ctxt->sax != NULL) &&
8079	(ctxt->sax->getParameterEntity != NULL))
8080	entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
8081	if (ctxt->instate == XML_PARSER_EOF)
8082	return;
8083	if (entity == NULL) {
8084	/*
8085	* [ WFC: Entity Declared ]
8086	* In a document without any DTD, a document with only an
8087	* internal DTD subset which contains no parameter entity
8088	* references, or a document with "standalone='yes'", ...
8089	* ... The declaration of a parameter entity must precede
8090	* any reference to it...
8091	*/
8092	if ((ctxt->standalone == 1) \|\|
8093	((ctxt->hasExternalSubset == 0) &&
8094	(ctxt->hasPErefs == 0))) {
8095	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
8096	"PEReference: %%%s; not found\n",
8097	name);
8098	} else {
8099	/*
8100	* [ VC: Entity Declared ]
8101	* In a document with an external subset or external
8102	* parameter entities with "standalone='no'", ...
8103	* ... The declaration of a parameter entity must
8104	* precede any reference to it...
8105	*/
8106	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8107	"PEReference: %%%s; not found\n",
8108	name, NULL);
8109	ctxt->valid = 0;
8110	}
8111	xmlParserEntityCheck(ctxt, 0, NULL, 0);
8112	} else {
8113	/*
8114	* Internal checking in case the entity quest barfed
8115	*/
8116	if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
8117	(entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
8118	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8119	"Internal: %%%s; is not a parameter entity\n",
8120	name, NULL);
8121	} else if (ctxt->input->free != deallocblankswrapper) {
8122	input = xmlNewBlanksWrapperInputStream(ctxt, entity);
8123	if (xmlPushInput(ctxt, input) < 0)
8124	return;
8125	} else {
8126	/*
8127	* TODO !!!
8128	* handle the extra spaces added before and after
8129	* c.f. http://www.w3.org/TR/REC-xml#as-PE
8130	*/
8131	input = xmlNewEntityInputStream(ctxt, entity);
8132	if (xmlPushInput(ctxt, input) < 0)
8133	return;
8134	if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
8135	(CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
8136	(IS_BLANK_CH(NXT(5)))) {
8137	xmlParseTextDecl(ctxt);
8138	if (ctxt->errNo ==
8139	XML_ERR_UNSUPPORTED_ENCODING) {
8140	/*
8141	* The XML REC instructs us to stop parsing
8142	* right here
8143	*/
8144	xmlHaltParser(ctxt);
8145	return;
8146	}
8147	}
8148	}
8149	}
8150	ctxt->hasPErefs = 1;
8151	}
8152
8153	/**
8154	* xmlLoadEntityContent:
8155	* @ctxt: an XML parser context
8156	* @entity: an unloaded system entity
8157	*
8158	* Load the original content of the given system entity from the
8159	* ExternalID/SystemID given. This is to be used for Included in Literal
8160	* http://www.w3.org/TR/REC-xml/#inliteral processing of entities references
8161	*
8162	* Returns 0 in case of success and -1 in case of failure
8163	*/
8164	static int
8165	xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
8166	xmlParserInputPtr input;
8167	xmlBufferPtr buf;
8168	int l, c;
8169	int count = 0;
8170
8171	if ((ctxt == NULL) \|\| (entity == NULL) \|\|
8172	((entity->etype != XML_EXTERNAL_PARAMETER_ENTITY) &&
8173	(entity->etype != XML_EXTERNAL_GENERAL_PARSED_ENTITY)) \|\|
8174	(entity->content != NULL)) {
8175	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8176	"xmlLoadEntityContent parameter error");
8177	return(-1);
8178	}
8179
8180	if (xmlParserDebugEntities)
8181	xmlGenericError(xmlGenericErrorContext,
8182	"Reading %s entity content input\n", entity->name);
8183
8184	buf = xmlBufferCreate();
8185	if (buf == NULL) {
8186	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8187	"xmlLoadEntityContent parameter error");
8188	return(-1);
8189	}
8190
8191	input = xmlNewEntityInputStream(ctxt, entity);
8192	if (input == NULL) {
8193	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8194	"xmlLoadEntityContent input error");
8195	xmlBufferFree(buf);
8196	return(-1);
8197	}
8198
8199	/*
8200	* Push the entity as the current input, read char by char
8201	* saving to the buffer until the end of the entity or an error
8202	*/
8203	if (xmlPushInput(ctxt, input) < 0) {
8204	xmlBufferFree(buf);
8205	return(-1);
8206	}
8207
8208	GROW;
8209	c = CUR_CHAR(l);
8210	while ((ctxt->input == input) && (ctxt->input->cur < ctxt->input->end) &&
8211	(IS_CHAR(c))) {
8212	xmlBufferAdd(buf, ctxt->input->cur, l);
8213	if (count++ > XML_PARSER_CHUNK_SIZE) {
8214	count = 0;
8215	GROW;
8216	if (ctxt->instate == XML_PARSER_EOF) {
8217	xmlBufferFree(buf);
8218	return(-1);
8219	}
8220	}
8221	NEXTL(l);
8222	c = CUR_CHAR(l);
8223	if (c == 0) {
8224	count = 0;
8225	GROW;
8226	if (ctxt->instate == XML_PARSER_EOF) {
8227	xmlBufferFree(buf);
8228	return(-1);
8229	}
8230	c = CUR_CHAR(l);
8231	}
8232	}
8233
8234	if ((ctxt->input == input) && (ctxt->input->cur >= ctxt->input->end)) {
8235	xmlPopInput(ctxt);
8236	} else if (!IS_CHAR(c)) {
8237	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
8238	"xmlLoadEntityContent: invalid char value %d\n",
8239	c);
8240	xmlBufferFree(buf);
8241	return(-1);
8242	}
8243	entity->content = buf->content;
8244	buf->content = NULL;
8245	xmlBufferFree(buf);
8246
8247	return(0);
8248	}
8249
8250	/**
8251	* xmlParseStringPEReference:
8252	* @ctxt: an XML parser context
8253	* @str: a pointer to an index in the string
8254	*
8255	* parse PEReference declarations
8256	*
8257	* [69] PEReference ::= '%' Name ';'
8258	*
8259	* [ WFC: No Recursion ]
8260	* A parsed entity must not contain a recursive
8261	* reference to itself, either directly or indirectly.
8262	*
8263	* [ WFC: Entity Declared ]
8264	* In a document without any DTD, a document with only an internal DTD
8265	* subset which contains no parameter entity references, or a document
8266	* with "standalone='yes'", ... ... The declaration of a parameter
8267	* entity must precede any reference to it...
8268	*
8269	* [ VC: Entity Declared ]
8270	* In a document with an external subset or external parameter entities
8271	* with "standalone='no'", ... ... The declaration of a parameter entity
8272	* must precede any reference to it...
8273	*
8274	* [ WFC: In DTD ]
8275	* Parameter-entity references may only appear in the DTD.
8276	* NOTE: misleading but this is handled.
8277	*
8278	* Returns the string of the entity content.
8279	* str is updated to the current value of the index
8280	*/
8281	static xmlEntityPtr
8282	xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) {
8283	const xmlChar *ptr;
8284	xmlChar cur;
8285	xmlChar *name;
8286	xmlEntityPtr entity = NULL;
8287
8288	if ((str == NULL) \|\| (*str == NULL)) return(NULL);
8289	ptr = *str;
8290	cur = *ptr;
8291	if (cur != '%')
8292	return(NULL);
8293	ptr++;
8294	name = xmlParseStringName(ctxt, &ptr);
8295	if (name == NULL) {
8296	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8297	"xmlParseStringPEReference: no name\n");
8298	*str = ptr;
8299	return(NULL);
8300	}
8301	cur = *ptr;
8302	if (cur != ';') {
8303	xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
8304	xmlFree(name);
8305	*str = ptr;
8306	return(NULL);
8307	}
8308	ptr++;
8309
8310	/*
8311	* Increate the number of entity references parsed
8312	*/
8313	ctxt->nbentities++;
8314
8315	/*
8316	* Request the entity from SAX
8317	*/
8318	if ((ctxt->sax != NULL) &&
8319	(ctxt->sax->getParameterEntity != NULL))
8320	entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
8321	if (ctxt->instate == XML_PARSER_EOF) {
8322	xmlFree(name);
8323	return(NULL);
8324	}
8325	if (entity == NULL) {
8326	/*
8327	* [ WFC: Entity Declared ]
8328	* In a document without any DTD, a document with only an
8329	* internal DTD subset which contains no parameter entity
8330	* references, or a document with "standalone='yes'", ...
8331	* ... The declaration of a parameter entity must precede
8332	* any reference to it...
8333	*/
8334	if ((ctxt->standalone == 1) \|\|
8335	((ctxt->hasExternalSubset == 0) && (ctxt->hasPErefs == 0))) {
8336	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
8337	"PEReference: %%%s; not found\n", name);
8338	} else {
8339	/*
8340	* [ VC: Entity Declared ]
8341	* In a document with an external subset or external
8342	* parameter entities with "standalone='no'", ...
8343	* ... The declaration of a parameter entity must
8344	* precede any reference to it...
8345	*/
8346	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8347	"PEReference: %%%s; not found\n",
8348	name, NULL);
8349	ctxt->valid = 0;
8350	}
8351	xmlParserEntityCheck(ctxt, 0, NULL, 0);
8352	} else {
8353	/*
8354	* Internal checking in case the entity quest barfed
8355	*/
8356	if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
8357	(entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
8358	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8359	"%%%s; is not a parameter entity\n",
8360	name, NULL);
8361	}
8362	}
8363	ctxt->hasPErefs = 1;
8364	xmlFree(name);
8365	*str = ptr;
8366	return(entity);
8367	}
8368
8369	/**
8370	* xmlParseDocTypeDecl:
8371	* @ctxt: an XML parser context
8372	*
8373	* parse a DOCTYPE declaration
8374	*
8375	* [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S?
8376	* ('[' (markupdecl \| PEReference \| S)* ']' S?)? '>'
8377	*
8378	* [ VC: Root Element Type ]
8379	* The Name in the document type declaration must match the element
8380	* type of the root element.
8381	*/
8382
8383	void
8384	xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) {
8385	const xmlChar *name = NULL;
8386	xmlChar *ExternalID = NULL;
8387	xmlChar *URI = NULL;
8388
8389	/*
8390	* We know that '<!DOCTYPE' has been detected.
8391	*/
8392	SKIP(9);
8393
8394	SKIP_BLANKS;
8395
8396	/*
8397	* Parse the DOCTYPE name.
8398	*/
8399	name = xmlParseName(ctxt);
8400	if (name == NULL) {
8401	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8402	"xmlParseDocTypeDecl : no DOCTYPE name !\n");
8403	}
8404	ctxt->intSubName = name;
8405
8406	SKIP_BLANKS;
8407
8408	/*
8409	* Check for SystemID and ExternalID
8410	*/
8411	URI = xmlParseExternalID(ctxt, &ExternalID, 1);
8412
8413	if ((URI != NULL) \|\| (ExternalID != NULL)) {
8414	ctxt->hasExternalSubset = 1;
8415	}
8416	ctxt->extSubURI = URI;
8417	ctxt->extSubSystem = ExternalID;
8418
8419	SKIP_BLANKS;
8420
8421	/*
8422	* Create and update the internal subset.
8423	*/
8424	if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
8425	(!ctxt->disableSAX))
8426	ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
8427	if (ctxt->instate == XML_PARSER_EOF)
8428	return;
8429
8430	/*
8431	* Is there any internal subset declarations ?
8432	* they are handled separately in xmlParseInternalSubset()
8433	*/
8434	if (RAW == '[')
8435	return;
8436
8437	/*
8438	* We should be at the end of the DOCTYPE declaration.
8439	*/
8440	if (RAW != '>') {
8441	xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8442	}
8443	NEXT;
8444	}
8445
8446	/**
8447	* xmlParseInternalSubset:
8448	* @ctxt: an XML parser context
8449	*
8450	* parse the internal subset declaration
8451	*
8452	* [28 end] ('[' (markupdecl \| PEReference \| S)* ']' S?)? '>'
8453	*/
8454
8455	static void
8456	xmlParseInternalSubset(xmlParserCtxtPtr ctxt) {
8457	/*
8458	* Is there any DTD definition ?
8459	*/
8460	if (RAW == '[') {
8461	ctxt->instate = XML_PARSER_DTD;
8462	NEXT;
8463	/*
8464	* Parse the succession of Markup declarations and
8465	* PEReferences.
8466	* Subsequence (markupdecl \| PEReference \| S)*
8467	*/
8468	while ((RAW != ']') && (ctxt->instate != XML_PARSER_EOF)) {
8469	const xmlChar *check = CUR_PTR;
8470	unsigned int cons = ctxt->input->consumed;
8471
8472	SKIP_BLANKS;
8473	xmlParseMarkupDecl(ctxt);
8474	xmlParsePEReference(ctxt);
8475
8476	/*
8477	* Pop-up of finished entities.
8478	*/
8479	while ((RAW == 0) && (ctxt->inputNr > 1))
8480	xmlPopInput(ctxt);
8481
8482	if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
8483	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8484	"xmlParseInternalSubset: error detected in Markup declaration\n");
8485	break;
8486	}
8487	}
8488	if (RAW == ']') {
8489	NEXT;
8490	SKIP_BLANKS;
8491	}
8492	}
8493
8494	/*
8495	* We should be at the end of the DOCTYPE declaration.
8496	*/
8497	if (RAW != '>') {
8498	xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8499	return;
8500	}
8501	NEXT;
8502	}
8503
8504	#ifdef LIBXML_SAX1_ENABLED
8505	/**
8506	* xmlParseAttribute:
8507	* @ctxt: an XML parser context
8508	* @value: a xmlChar ** used to store the value of the attribute
8509	*
8510	* parse an attribute
8511	*
8512	* [41] Attribute ::= Name Eq AttValue
8513	*
8514	* [ WFC: No External Entity References ]
8515	* Attribute values cannot contain direct or indirect entity references
8516	* to external entities.
8517	*
8518	* [ WFC: No < in Attribute Values ]
8519	* The replacement text of any entity referred to directly or indirectly in
8520	* an attribute value (other than "<") must not contain a <.
8521	*
8522	* [ VC: Attribute Value Type ]
8523	* The attribute must have been declared; the value must be of the type
8524	* declared for it.
8525	*
8526	* [25] Eq ::= S? '=' S?
8527	*
8528	* With namespace:
8529	*
8530	* [NS 11] Attribute ::= QName Eq AttValue
8531	*
8532	* Also the case QName == xmlns:??? is handled independently as a namespace
8533	* definition.
8534	*
8535	* Returns the attribute name, and the value in *value.
8536	*/
8537
8538	const xmlChar *
8539	xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) {
8540	const xmlChar *name;
8541	xmlChar *val;
8542
8543	*value = NULL;
8544	GROW;
8545	name = xmlParseName(ctxt);
8546	if (name == NULL) {
8547	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8548	"error parsing attribute name\n");
8549	return(NULL);
8550	}
8551
8552	/*
8553	* read the value
8554	*/
8555	SKIP_BLANKS;
8556	if (RAW == '=') {
8557	NEXT;
8558	SKIP_BLANKS;
8559	val = xmlParseAttValue(ctxt);
8560	ctxt->instate = XML_PARSER_CONTENT;
8561	} else {
8562	xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
8563	"Specification mandate value for attribute %s\n", name);
8564	return(NULL);
8565	}
8566
8567	/*
8568	* Check that xml:lang conforms to the specification
8569	* No more registered as an error, just generate a warning now
8570	* since this was deprecated in XML second edition
8571	*/
8572	if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
8573	if (!xmlCheckLanguageID(val)) {
8574	xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
8575	"Malformed value for xml:lang : %s\n",
8576	val, NULL);
8577	}
8578	}
8579
8580	/*
8581	* Check that xml:space conforms to the specification
8582	*/
8583	if (xmlStrEqual(name, BAD_CAST "xml:space")) {
8584	if (xmlStrEqual(val, BAD_CAST "default"))
8585	*(ctxt->space) = 0;
8586	else if (xmlStrEqual(val, BAD_CAST "preserve"))
8587	*(ctxt->space) = 1;
8588	else {
8589	xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
8590	"Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
8591	val, NULL);
8592	}
8593	}
8594
8595	*value = val;
8596	return(name);
8597	}
8598
8599	/**
8600	* xmlParseStartTag:
8601	* @ctxt: an XML parser context
8602	*
8603	* parse a start of tag either for rule element or
8604	* EmptyElement. In both case we don't parse the tag closing chars.
8605	*
8606	* [40] STag ::= '<' Name (S Attribute)* S? '>'
8607	*
8608	* [ WFC: Unique Att Spec ]
8609	* No attribute name may appear more than once in the same start-tag or
8610	* empty-element tag.
8611	*
8612	* [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
8613	*
8614	* [ WFC: Unique Att Spec ]
8615	* No attribute name may appear more than once in the same start-tag or
8616	* empty-element tag.
8617	*
8618	* With namespace:
8619	*
8620	* [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
8621	*
8622	* [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
8623	*
8624	* Returns the element name parsed
8625	*/
8626
8627	const xmlChar *
8628	xmlParseStartTag(xmlParserCtxtPtr ctxt) {
8629	const xmlChar *name;
8630	const xmlChar *attname;
8631	xmlChar *attvalue;
8632	const xmlChar **atts = ctxt->atts;
8633	int nbatts = 0;
8634	int maxatts = ctxt->maxatts;
8635	int i;
8636
8637	if (RAW != '<') return(NULL);
8638	NEXT1;
8639
8640	name = xmlParseName(ctxt);
8641	if (name == NULL) {
8642	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8643	"xmlParseStartTag: invalid element name\n");
8644	return(NULL);
8645	}
8646
8647	/*
8648	* Now parse the attributes, it ends up with the ending
8649	*
8650	* (S Attribute)* S?
8651	*/
8652	SKIP_BLANKS;
8653	GROW;
8654
8655	while (((RAW != '>') &&
8656	((RAW != '/') \|\| (NXT(1) != '>')) &&
8657	(IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) {
8658	const xmlChar *q = CUR_PTR;
8659	unsigned int cons = ctxt->input->consumed;
8660
8661	attname = xmlParseAttribute(ctxt, &attvalue);
8662	if ((attname != NULL) && (attvalue != NULL)) {
8663	/*
8664	* [ WFC: Unique Att Spec ]
8665	* No attribute name may appear more than once in the same
8666	* start-tag or empty-element tag.
8667	*/
8668	for (i = 0; i < nbatts;i += 2) {
8669	if (xmlStrEqual(atts[i], attname)) {
8670	xmlErrAttributeDup(ctxt, NULL, attname);
8671	xmlFree(attvalue);
8672	goto failed;
8673	}
8674	}
8675	/*
8676	* Add the pair to atts
8677	*/
8678	if (atts == NULL) {
8679	maxatts = 22; /* allow for 10 attrs by default */
8680	atts = (const xmlChar **)
8681	xmlMalloc(maxatts * sizeof(xmlChar *));
8682	if (atts == NULL) {
8683	xmlErrMemory(ctxt, NULL);
8684	if (attvalue != NULL)
8685	xmlFree(attvalue);
8686	goto failed;
8687	}
8688	ctxt->atts = atts;
8689	ctxt->maxatts = maxatts;
8690	} else if (nbatts + 4 > maxatts) {
8691	const xmlChar **n;
8692
8693	maxatts *= 2;
8694	n = (const xmlChar *) xmlRealloc((void ) atts,
8695	maxatts * sizeof(const xmlChar *));
8696	if (n == NULL) {
8697	xmlErrMemory(ctxt, NULL);
8698	if (attvalue != NULL)
8699	xmlFree(attvalue);
8700	goto failed;
8701	}
8702	atts = n;
8703	ctxt->atts = atts;
8704	ctxt->maxatts = maxatts;
8705	}
8706	atts[nbatts++] = attname;
8707	atts[nbatts++] = attvalue;
8708	atts[nbatts] = NULL;
8709	atts[nbatts + 1] = NULL;
8710	} else {
8711	if (attvalue != NULL)
8712	xmlFree(attvalue);
8713	}
8714
8715	failed:
8716
8717	GROW
8718	if ((RAW == '>') \|\| (((RAW == '/') && (NXT(1) == '>'))))
8719	break;
8720	if (!IS_BLANK_CH(RAW)) {
8721	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
8722	"attributes construct error\n");
8723	}
8724	SKIP_BLANKS;
8725	if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
8726	(attname == NULL) && (attvalue == NULL)) {
8727	xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
8728	"xmlParseStartTag: problem parsing attributes\n");
8729	break;
8730	}
8731	SHRINK;
8732	GROW;
8733	}
8734
8735	/*
8736	* SAX: Start of Element !
8737	*/
8738	if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) &&
8739	(!ctxt->disableSAX)) {
8740	if (nbatts > 0)
8741	ctxt->sax->startElement(ctxt->userData, name, atts);
8742	else
8743	ctxt->sax->startElement(ctxt->userData, name, NULL);
8744	}
8745
8746	if (atts != NULL) {
8747	/* Free only the content strings */
8748	for (i = 1;i < nbatts;i+=2)
8749	if (atts[i] != NULL)
8750	xmlFree((xmlChar *) atts[i]);
8751	}
8752	return(name);
8753	}
8754
8755	/**
8756	* xmlParseEndTag1:
8757	* @ctxt: an XML parser context
8758	* @line: line of the start tag
8759	* @nsNr: number of namespaces on the start tag
8760	*
8761	* parse an end of tag
8762	*
8763	* [42] ETag ::= '</' Name S? '>'
8764	*
8765	* With namespace
8766	*
8767	* [NS 9] ETag ::= '</' QName S? '>'
8768	*/
8769
8770	static void
8771	xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) {
8772	const xmlChar *name;
8773
8774	GROW;
8775	if ((RAW != '<') \|\| (NXT(1) != '/')) {
8776	xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED,
8777	"xmlParseEndTag: '</' not found\n");
8778	return;
8779	}
8780	SKIP(2);
8781
8782	name = xmlParseNameAndCompare(ctxt,ctxt->name);
8783
8784	/*
8785	* We should definitely be at the ending "S? '>'" part
8786	*/
8787	GROW;
8788	SKIP_BLANKS;
8789	if ((!IS_BYTE_CHAR(RAW)) \|\| (RAW != '>')) {
8790	xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
8791	} else
8792	NEXT1;
8793
8794	/*
8795	* [ WFC: Element Type Match ]
8796	* The Name in an element's end-tag must match the element type in the
8797	* start-tag.
8798	*
8799	*/
8800	if (name != (xmlChar*)1) {
8801	if (name == NULL) name = BAD_CAST "unparseable";
8802	xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
8803	"Opening and ending tag mismatch: %s line %d and %s\n",
8804	ctxt->name, line, name);
8805	}
8806
8807	/*
8808	* SAX: End of Tag
8809	*/
8810	if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
8811	(!ctxt->disableSAX))
8812	ctxt->sax->endElement(ctxt->userData, ctxt->name);
8813
8814	namePop(ctxt);
8815	spacePop(ctxt);
8816	return;
8817	}
8818
8819	/**
8820	* xmlParseEndTag:
8821	* @ctxt: an XML parser context
8822	*
8823	* parse an end of tag
8824	*
8825	* [42] ETag ::= '</' Name S? '>'
8826	*
8827	* With namespace
8828	*
8829	* [NS 9] ETag ::= '</' QName S? '>'
8830	*/
8831
8832	void
8833	xmlParseEndTag(xmlParserCtxtPtr ctxt) {
8834	xmlParseEndTag1(ctxt, 0);
8835	}
8836	#endif /* LIBXML_SAX1_ENABLED */
8837
8838	/************************************************************************
8839	* *
8840	* SAX 2 specific operations *
8841	* *
8842	************************************************************************/
8843
8844	/*
8845	* xmlGetNamespace:
8846	* @ctxt: an XML parser context
8847	* @prefix: the prefix to lookup
8848	*
8849	* Lookup the namespace name for the @prefix (which ca be NULL)
8850	* The prefix must come from the @ctxt->dict dictionary
8851	*
8852	* Returns the namespace name or NULL if not bound
8853	*/
8854	static const xmlChar *
8855	xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
8856	int i;
8857
8858	if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns);
8859	for (i = ctxt->nsNr - 2;i >= 0;i-=2)
8860	if (ctxt->nsTab[i] == prefix) {
8861	if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0))
8862	return(NULL);
8863	return(ctxt->nsTab[i + 1]);
8864	}
8865	return(NULL);
8866	}
8867
8868	/**
8869	* xmlParseQName:
8870	* @ctxt: an XML parser context
8871	* @prefix: pointer to store the prefix part
8872	*
8873	* parse an XML Namespace QName
8874	*
8875	* [6] QName ::= (Prefix ':')? LocalPart
8876	* [7] Prefix ::= NCName
8877	* [8] LocalPart ::= NCName
8878	*
8879	* Returns the Name parsed or NULL
8880	*/
8881
8882	static const xmlChar *
8883	xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) {
8884	const xmlChar l, p;
8885
8886	GROW;
8887
8888	l = xmlParseNCName(ctxt);
8889	if (l == NULL) {
8890	if (CUR == ':') {
8891	l = xmlParseName(ctxt);
8892	if (l != NULL) {
8893	xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8894	"Failed to parse QName '%s'\n", l, NULL, NULL);
8895	*prefix = NULL;
8896	return(l);
8897	}
8898	}
8899	return(NULL);
8900	}
8901	if (CUR == ':') {
8902	NEXT;
8903	p = l;
8904	l = xmlParseNCName(ctxt);
8905	if (l == NULL) {
8906	xmlChar *tmp;
8907
8908	xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8909	"Failed to parse QName '%s:'\n", p, NULL, NULL);
8910	l = xmlParseNmtoken(ctxt);
8911	if (l == NULL)
8912	tmp = xmlBuildQName(BAD_CAST "", p, NULL, 0);
8913	else {
8914	tmp = xmlBuildQName(l, p, NULL, 0);
8915	xmlFree((char *)l);
8916	}
8917	p = xmlDictLookup(ctxt->dict, tmp, -1);
8918	if (tmp != NULL) xmlFree(tmp);
8919	*prefix = NULL;
8920	return(p);
8921	}
8922	if (CUR == ':') {
8923	xmlChar *tmp;
8924
8925	xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8926	"Failed to parse QName '%s:%s:'\n", p, l, NULL);
8927	NEXT;
8928	tmp = (xmlChar *) xmlParseName(ctxt);
8929	if (tmp != NULL) {
8930	tmp = xmlBuildQName(tmp, l, NULL, 0);
8931	l = xmlDictLookup(ctxt->dict, tmp, -1);
8932	if (tmp != NULL) xmlFree(tmp);
8933	*prefix = p;
8934	return(l);
8935	}
8936	tmp = xmlBuildQName(BAD_CAST "", l, NULL, 0);
8937	l = xmlDictLookup(ctxt->dict, tmp, -1);
8938	if (tmp != NULL) xmlFree(tmp);
8939	*prefix = p;
8940	return(l);
8941	}
8942	*prefix = p;
8943	} else
8944	*prefix = NULL;
8945	return(l);
8946	}
8947
8948	/**
8949	* xmlParseQNameAndCompare:
8950	* @ctxt: an XML parser context
8951	* @name: the localname
8952	* @prefix: the prefix, if any.
8953	*
8954	* parse an XML name and compares for match
8955	* (specialized for endtag parsing)
8956	*
8957	* Returns NULL for an illegal name, (xmlChar*) 1 for success
8958	* and the name for mismatch
8959	*/
8960
8961	static const xmlChar *
8962	xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
8963	xmlChar const *prefix) {
8964	const xmlChar *cmp;
8965	const xmlChar *in;
8966	const xmlChar *ret;
8967	const xmlChar *prefix2;
8968
8969	if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
8970
8971	GROW;
8972	in = ctxt->input->cur;
8973
8974	cmp = prefix;
8975	while (in != 0 && in == *cmp) {
8976	++in;
8977	++cmp;
8978	}
8979	if ((cmp == 0) && (in == ':')) {
8980	in++;
8981	cmp = name;
8982	while (in != 0 && in == *cmp) {
8983	++in;
8984	++cmp;
8985	}
8986	if (cmp == 0 && (in == '>' \|\| IS_BLANK_CH (*in))) {
8987	/* success */
8988	ctxt->input->cur = in;
8989	return((const xmlChar*) 1);
8990	}
8991	}
8992	/*
8993	* all strings coms from the dictionary, equality can be done directly
8994	*/
8995	ret = xmlParseQName (ctxt, &prefix2);
8996	if ((ret == name) && (prefix == prefix2))
8997	return((const xmlChar*) 1);
8998	return ret;
8999	}
9000
9001	/**
9002	* xmlParseAttValueInternal:
9003	* @ctxt: an XML parser context
9004	* @len: attribute len result
9005	* @alloc: whether the attribute was reallocated as a new string
9006	* @normalize: if 1 then further non-CDATA normalization must be done
9007	*
9008	* parse a value for an attribute.
9009	* NOTE: if no normalization is needed, the routine will return pointers
9010	* directly from the data buffer.
9011	*
9012	* 3.3.3 Attribute-Value Normalization:
9013	* Before the value of an attribute is passed to the application or
9014	* checked for validity, the XML processor must normalize it as follows:
9015	* - a character reference is processed by appending the referenced
9016	* character to the attribute value
9017	* - an entity reference is processed by recursively processing the
9018	* replacement text of the entity
9019	* - a whitespace character (#x20, #xD, #xA, #x9) is processed by
9020	* appending #x20 to the normalized value, except that only a single
9021	* #x20 is appended for a "#xD#xA" sequence that is part of an external
9022	* parsed entity or the literal entity value of an internal parsed entity
9023	* - other characters are processed by appending them to the normalized value
9024	* If the declared value is not CDATA, then the XML processor must further
9025	* process the normalized attribute value by discarding any leading and
9026	* trailing space (#x20) characters, and by replacing sequences of space
9027	* (#x20) characters by a single space (#x20) character.
9028	* All attributes for which no declaration has been read should be treated
9029	* by a non-validating parser as if declared CDATA.
9030	*
9031	* Returns the AttValue parsed or NULL. The value has to be freed by the
9032	* caller if it was copied, this can be detected by val[*len] == 0.
9033	*/
9034
9035	static xmlChar *
9036	xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int len, int alloc,
9037	int normalize)
9038	{
9039	xmlChar limit = 0;
9040	const xmlChar in = NULL, start, end, last;
9041	xmlChar *ret = NULL;
9042	int line, col;
9043
9044	GROW;
9045	in = (xmlChar *) CUR_PTR;
9046	line = ctxt->input->line;
9047	col = ctxt->input->col;
9048	if (in != '"' && in != '\'') {
9049	xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
9050	return (NULL);
9051	}
9052	ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
9053
9054	/*
9055	* try to handle in this routine the most common case where no
9056	* allocation of a new string is required and where content is
9057	* pure ASCII.
9058	*/
9059	limit = *in++;
9060	col++;
9061	end = ctxt->input->end;
9062	start = in;
9063	if (in >= end) {
9064	const xmlChar *oldbase = ctxt->input->base;
9065	GROW;
9066	if (oldbase != ctxt->input->base) {
9067	long delta = ctxt->input->base - oldbase;
9068	start = start + delta;
9069	in = in + delta;
9070	}
9071	end = ctxt->input->end;
9072	}
9073	if (normalize) {
9074	/*
9075	* Skip any leading spaces
9076	*/
9077	while ((in < end) && (*in != limit) &&
9078	((in == 0x20) \|\| (in == 0x9) \|\|
9079	(in == 0xA) \|\| (in == 0xD))) {
9080	if (*in == 0xA) {
9081	line++; col = 1;
9082	} else {
9083	col++;
9084	}
9085	in++;
9086	start = in;
9087	if (in >= end) {
9088	const xmlChar *oldbase = ctxt->input->base;
9089	GROW;
9090	if (ctxt->instate == XML_PARSER_EOF)
9091	return(NULL);
9092	if (oldbase != ctxt->input->base) {
9093	long delta = ctxt->input->base - oldbase;
9094	start = start + delta;
9095	in = in + delta;
9096	}
9097	end = ctxt->input->end;
9098	if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9099	((ctxt->options & XML_PARSE_HUGE) == 0)) {
9100	xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9101	"AttValue length too long\n");
9102	return(NULL);
9103	}
9104	}
9105	}
9106	while ((in < end) && (in != limit) && (in >= 0x20) &&
9107	(in <= 0x7f) && (in != '&') && (*in != '<')) {
9108	col++;
9109	if ((in++ == 0x20) && (in == 0x20)) break;
9110	if (in >= end) {
9111	const xmlChar *oldbase = ctxt->input->base;
9112	GROW;
9113	if (ctxt->instate == XML_PARSER_EOF)
9114	return(NULL);
9115	if (oldbase != ctxt->input->base) {
9116	long delta = ctxt->input->base - oldbase;
9117	start = start + delta;
9118	in = in + delta;
9119	}
9120	end = ctxt->input->end;
9121	if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9122	((ctxt->options & XML_PARSE_HUGE) == 0)) {
9123	xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9124	"AttValue length too long\n");
9125	return(NULL);
9126	}
9127	}
9128	}
9129	last = in;
9130	/*
9131	* skip the trailing blanks
9132	*/
9133	while ((last[-1] == 0x20) && (last > start)) last--;
9134	while ((in < end) && (*in != limit) &&
9135	((in == 0x20) \|\| (in == 0x9) \|\|
9136	(in == 0xA) \|\| (in == 0xD))) {
9137	if (*in == 0xA) {
9138	line++, col = 1;
9139	} else {
9140	col++;
9141	}
9142	in++;
9143	if (in >= end) {
9144	const xmlChar *oldbase = ctxt->input->base;
9145	GROW;
9146	if (ctxt->instate == XML_PARSER_EOF)
9147	return(NULL);
9148	if (oldbase != ctxt->input->base) {
9149	long delta = ctxt->input->base - oldbase;
9150	start = start + delta;
9151	in = in + delta;
9152	last = last + delta;
9153	}
9154	end = ctxt->input->end;
9155	if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9156	((ctxt->options & XML_PARSE_HUGE) == 0)) {
9157	xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9158	"AttValue length too long\n");
9159	return(NULL);
9160	}
9161	}
9162	}
9163	if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9164	((ctxt->options & XML_PARSE_HUGE) == 0)) {
9165	xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9166	"AttValue length too long\n");
9167	return(NULL);
9168	}
9169	if (*in != limit) goto need_complex;
9170	} else {
9171	while ((in < end) && (in != limit) && (in >= 0x20) &&
9172	(in <= 0x7f) && (in != '&') && (*in != '<')) {
9173	in++;
9174	col++;
9175	if (in >= end) {
9176	const xmlChar *oldbase = ctxt->input->base;
9177	GROW;
9178	if (ctxt->instate == XML_PARSER_EOF)
9179	return(NULL);
9180	if (oldbase != ctxt->input->base) {
9181	long delta = ctxt->input->base - oldbase;
9182	start = start + delta;
9183	in = in + delta;
9184	}
9185	end = ctxt->input->end;
9186	if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9187	((ctxt->options & XML_PARSE_HUGE) == 0)) {
9188	xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9189	"AttValue length too long\n");
9190	return(NULL);
9191	}
9192	}
9193	}
9194	last = in;
9195	if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9196	((ctxt->options & XML_PARSE_HUGE) == 0)) {
9197	xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9198	"AttValue length too long\n");
9199	return(NULL);
9200	}
9201	if (*in != limit) goto need_complex;
9202	}
9203	in++;
9204	col++;
9205	if (len != NULL) {
9206	*len = last - start;
9207	ret = (xmlChar *) start;
9208	} else {
9209	if (alloc) *alloc = 1;
9210	ret = xmlStrndup(start, last - start);
9211	}
9212	CUR_PTR = in;
9213	ctxt->input->line = line;
9214	ctxt->input->col = col;
9215	if (alloc) *alloc = 0;
9216	return ret;
9217	need_complex:
9218	if (alloc) *alloc = 1;
9219	return xmlParseAttValueComplex(ctxt, len, normalize);
9220	}
9221
9222	/**
9223	* xmlParseAttribute2:
9224	* @ctxt: an XML parser context
9225	* @pref: the element prefix
9226	* @elem: the element name
9227	* @prefix: a xmlChar ** used to store the value of the attribute prefix
9228	* @value: a xmlChar ** used to store the value of the attribute
9229	* @len: an int * to save the length of the attribute
9230	* @alloc: an int * to indicate if the attribute was allocated
9231	*
9232	* parse an attribute in the new SAX2 framework.
9233	*
9234	* Returns the attribute name, and the value in *value, .
9235	*/
9236
9237	static const xmlChar *
9238	xmlParseAttribute2(xmlParserCtxtPtr ctxt,
9239	const xmlChar * pref, const xmlChar * elem,
9240	const xmlChar prefix, xmlChar value,
9241	int len, int alloc)
9242	{
9243	const xmlChar *name;
9244	xmlChar val, internal_val = NULL;
9245	int normalize = 0;
9246
9247	*value = NULL;
9248	GROW;
9249	name = xmlParseQName(ctxt, prefix);
9250	if (name == NULL) {
9251	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
9252	"error parsing attribute name\n");
9253	return (NULL);
9254	}
9255
9256	/*
9257	* get the type if needed
9258	*/
9259	if (ctxt->attsSpecial != NULL) {
9260	int type;
9261
9262	type = (int) (long) xmlHashQLookup2(ctxt->attsSpecial,
9263	pref, elem, *prefix, name);
9264	if (type != 0)
9265	normalize = 1;
9266	}
9267
9268	/*
9269	* read the value
9270	*/
9271	SKIP_BLANKS;
9272	if (RAW == '=') {
9273	NEXT;
9274	SKIP_BLANKS;
9275	val = xmlParseAttValueInternal(ctxt, len, alloc, normalize);
9276	if (normalize) {
9277	/*
9278	* Sometimes a second normalisation pass for spaces is needed
9279	* but that only happens if charrefs or entities refernces
9280	* have been used in the attribute value, i.e. the attribute
9281	* value have been extracted in an allocated string already.
9282	*/
9283	if (*alloc) {
9284	const xmlChar *val2;
9285
9286	val2 = xmlAttrNormalizeSpace2(ctxt, val, len);
9287	if ((val2 != NULL) && (val2 != val)) {
9288	xmlFree(val);
9289	val = (xmlChar *) val2;
9290	}
9291	}
9292	}
9293	ctxt->instate = XML_PARSER_CONTENT;
9294	} else {
9295	xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
9296	"Specification mandate value for attribute %s\n",
9297	name);
9298	return (NULL);
9299	}
9300
9301	if (*prefix == ctxt->str_xml) {
9302	/*
9303	* Check that xml:lang conforms to the specification
9304	* No more registered as an error, just generate a warning now
9305	* since this was deprecated in XML second edition
9306	*/
9307	if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) {
9308	internal_val = xmlStrndup(val, *len);
9309	if (!xmlCheckLanguageID(internal_val)) {
9310	xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
9311	"Malformed value for xml:lang : %s\n",
9312	internal_val, NULL);
9313	}
9314	}
9315
9316	/*
9317	* Check that xml:space conforms to the specification
9318	*/
9319	if (xmlStrEqual(name, BAD_CAST "space")) {
9320	internal_val = xmlStrndup(val, *len);
9321	if (xmlStrEqual(internal_val, BAD_CAST "default"))
9322	*(ctxt->space) = 0;
9323	else if (xmlStrEqual(internal_val, BAD_CAST "preserve"))
9324	*(ctxt->space) = 1;
9325	else {
9326	xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
9327	"Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
9328	internal_val, NULL);
9329	}
9330	}
9331	if (internal_val) {
9332	xmlFree(internal_val);
9333	}
9334	}
9335
9336	*value = val;
9337	return (name);
9338	}
9339	/**
9340	* xmlParseStartTag2:
9341	* @ctxt: an XML parser context
9342	*
9343	* parse a start of tag either for rule element or
9344	* EmptyElement. In both case we don't parse the tag closing chars.
9345	* This routine is called when running SAX2 parsing
9346	*
9347	* [40] STag ::= '<' Name (S Attribute)* S? '>'
9348	*
9349	* [ WFC: Unique Att Spec ]
9350	* No attribute name may appear more than once in the same start-tag or
9351	* empty-element tag.
9352	*
9353	* [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
9354	*
9355	* [ WFC: Unique Att Spec ]
9356	* No attribute name may appear more than once in the same start-tag or
9357	* empty-element tag.
9358	*
9359	* With namespace:
9360	*
9361	* [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
9362	*
9363	* [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
9364	*
9365	* Returns the element name parsed
9366	*/
9367
9368	static const xmlChar *
9369	xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref,
9370	const xmlChar *URI, int tlen) {
9371	const xmlChar *localname;
9372	const xmlChar *prefix;
9373	const xmlChar *attname;
9374	const xmlChar *aprefix;
9375	const xmlChar *nsname;
9376	xmlChar *attvalue;
9377	const xmlChar **atts = ctxt->atts;
9378	int maxatts = ctxt->maxatts;
9379	int nratts, nbatts, nbdef;
9380	int i, j, nbNs, attval, oldline, oldcol, inputNr;
9381	const xmlChar *base;
9382	unsigned long cur;
9383	int nsNr = ctxt->nsNr;
9384
9385	if (RAW != '<') return(NULL);
9386	NEXT1;
9387
9388	/*
9389	* NOTE: it is crucial with the SAX2 API to never call SHRINK beyond that
9390	* point since the attribute values may be stored as pointers to
9391	* the buffer and calling SHRINK would destroy them !
9392	* The Shrinking is only possible once the full set of attribute
9393	* callbacks have been done.
9394	*/
9395	reparse:
9396	SHRINK;
9397	base = ctxt->input->base;
9398	cur = ctxt->input->cur - ctxt->input->base;
9399	inputNr = ctxt->inputNr;
9400	oldline = ctxt->input->line;
9401	oldcol = ctxt->input->col;
9402	nbatts = 0;
9403	nratts = 0;
9404	nbdef = 0;
9405	nbNs = 0;
9406	attval = 0;
9407	/* Forget any namespaces added during an earlier parse of this element. */
9408	ctxt->nsNr = nsNr;
9409
9410	localname = xmlParseQName(ctxt, &prefix);
9411	if (localname == NULL) {
9412	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
9413	"StartTag: invalid element name\n");
9414	return(NULL);
9415	}
9416	*tlen = ctxt->input->cur - ctxt->input->base - cur;
9417
9418	/*
9419	* Now parse the attributes, it ends up with the ending
9420	*
9421	* (S Attribute)* S?
9422	*/
9423	SKIP_BLANKS;
9424	GROW;
9425	if ((ctxt->input->base != base) \|\| (inputNr != ctxt->inputNr))
9426	goto base_changed;
9427
9428	while (((RAW != '>') &&
9429	((RAW != '/') \|\| (NXT(1) != '>')) &&
9430	(IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) {
9431	const xmlChar *q = CUR_PTR;
9432	unsigned int cons = ctxt->input->consumed;
9433	int len = -1, alloc = 0;
9434
9435	attname = xmlParseAttribute2(ctxt, prefix, localname,
9436	&aprefix, &attvalue, &len, &alloc);
9437	if ((ctxt->input->base != base) \|\| (inputNr != ctxt->inputNr)) {
9438	if ((attvalue != NULL) && (alloc != 0))
9439	xmlFree(attvalue);
9440	attvalue = NULL;
9441	goto base_changed;
9442	}
9443	if ((attname != NULL) && (attvalue != NULL)) {
9444	if (len < 0) len = xmlStrlen(attvalue);
9445	if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
9446	const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
9447	xmlURIPtr uri;
9448
9449	if (URL == NULL) {
9450	xmlErrMemory(ctxt, "dictionary allocation failure");
9451	if ((attvalue != NULL) && (alloc != 0))
9452	xmlFree(attvalue);
9453	return(NULL);
9454	}
9455	if (*URL != 0) {
9456	uri = xmlParseURI((const char *) URL);
9457	if (uri == NULL) {
9458	xmlNsErr(ctxt, XML_WAR_NS_URI,
9459	"xmlns: '%s' is not a valid URI\n",
9460	URL, NULL, NULL);
9461	} else {
9462	if (uri->scheme == NULL) {
9463	xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
9464	"xmlns: URI %s is not absolute\n",
9465	URL, NULL, NULL);
9466	}
9467	xmlFreeURI(uri);
9468	}
9469	if (URL == ctxt->str_xml_ns) {
9470	if (attname != ctxt->str_xml) {
9471	xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9472	"xml namespace URI cannot be the default namespace\n",
9473	NULL, NULL, NULL);
9474	}
9475	goto skip_default_ns;
9476	}
9477	if ((len == 29) &&
9478	(xmlStrEqual(URL,
9479	BAD_CAST "http://www.w3.org/2000/xmlns/"))) {
9480	xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9481	"reuse of the xmlns namespace name is forbidden\n",
9482	NULL, NULL, NULL);
9483	goto skip_default_ns;
9484	}
9485	}
9486	/*
9487	* check that it's not a defined namespace
9488	*/
9489	for (j = 1;j <= nbNs;j++)
9490	if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
9491	break;
9492	if (j <= nbNs)
9493	xmlErrAttributeDup(ctxt, NULL, attname);
9494	else
9495	if (nsPush(ctxt, NULL, URL) > 0) nbNs++;
9496	skip_default_ns:
9497	if ((attvalue != NULL) && (alloc != 0)) {
9498	xmlFree(attvalue);
9499	attvalue = NULL;
9500	}
9501	if ((RAW == '>') \|\| (((RAW == '/') && (NXT(1) == '>'))))
9502	break;
9503	if (!IS_BLANK_CH(RAW)) {
9504	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9505	"attributes construct error\n");
9506	break;
9507	}
9508	SKIP_BLANKS;
9509	if ((ctxt->input->base != base) \|\| (inputNr != ctxt->inputNr))
9510	goto base_changed;
9511	continue;
9512	}
9513	if (aprefix == ctxt->str_xmlns) {
9514	const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
9515	xmlURIPtr uri;
9516
9517	if (attname == ctxt->str_xml) {
9518	if (URL != ctxt->str_xml_ns) {
9519	xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9520	"xml namespace prefix mapped to wrong URI\n",
9521	NULL, NULL, NULL);
9522	}
9523	/*
9524	* Do not keep a namespace definition node
9525	*/
9526	goto skip_ns;
9527	}
9528	if (URL == ctxt->str_xml_ns) {
9529	if (attname != ctxt->str_xml) {
9530	xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9531	"xml namespace URI mapped to wrong prefix\n",
9532	NULL, NULL, NULL);
9533	}
9534	goto skip_ns;
9535	}
9536	if (attname == ctxt->str_xmlns) {
9537	xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9538	"redefinition of the xmlns prefix is forbidden\n",
9539	NULL, NULL, NULL);
9540	goto skip_ns;
9541	}
9542	if ((len == 29) &&
9543	(xmlStrEqual(URL,
9544	BAD_CAST "http://www.w3.org/2000/xmlns/"))) {
9545	xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9546	"reuse of the xmlns namespace name is forbidden\n",
9547	NULL, NULL, NULL);
9548	goto skip_ns;
9549	}
9550	if ((URL == NULL) \|\| (URL[0] == 0)) {
9551	xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9552	"xmlns:%s: Empty XML namespace is not allowed\n",
9553	attname, NULL, NULL);
9554	goto skip_ns;
9555	} else {
9556	uri = xmlParseURI((const char *) URL);
9557	if (uri == NULL) {
9558	xmlNsErr(ctxt, XML_WAR_NS_URI,
9559	"xmlns:%s: '%s' is not a valid URI\n",
9560	attname, URL, NULL);
9561	} else {
9562	if ((ctxt->pedantic) && (uri->scheme == NULL)) {
9563	xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
9564	"xmlns:%s: URI %s is not absolute\n",
9565	attname, URL, NULL);
9566	}
9567	xmlFreeURI(uri);
9568	}
9569	}
9570
9571	/*
9572	* check that it's not a defined namespace
9573	*/
9574	for (j = 1;j <= nbNs;j++)
9575	if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
9576	break;
9577	if (j <= nbNs)
9578	xmlErrAttributeDup(ctxt, aprefix, attname);
9579	else
9580	if (nsPush(ctxt, attname, URL) > 0) nbNs++;
9581	skip_ns:
9582	if ((attvalue != NULL) && (alloc != 0)) {
9583	xmlFree(attvalue);
9584	attvalue = NULL;
9585	}
9586	if ((RAW == '>') \|\| (((RAW == '/') && (NXT(1) == '>'))))
9587	break;
9588	if (!IS_BLANK_CH(RAW)) {
9589	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9590	"attributes construct error\n");
9591	break;
9592	}
9593	SKIP_BLANKS;
9594	if ((ctxt->input->base != base) \|\| (inputNr != ctxt->inputNr))
9595	goto base_changed;
9596	continue;
9597	}
9598
9599	/*
9600	* Add the pair to atts
9601	*/
9602	if ((atts == NULL) \|\| (nbatts + 5 > maxatts)) {
9603	if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
9604	if (attvalue[len] == 0)
9605	xmlFree(attvalue);
9606	goto failed;
9607	}
9608	maxatts = ctxt->maxatts;
9609	atts = ctxt->atts;
9610	}
9611	ctxt->attallocs[nratts++] = alloc;
9612	atts[nbatts++] = attname;
9613	atts[nbatts++] = aprefix;
9614	atts[nbatts++] = NULL; /* the URI will be fetched later */
9615	atts[nbatts++] = attvalue;
9616	attvalue += len;
9617	atts[nbatts++] = attvalue;
9618	/*
9619	* tag if some deallocation is needed
9620	*/
9621	if (alloc != 0) attval = 1;
9622	} else {
9623	if ((attvalue != NULL) && (attvalue[len] == 0))
9624	xmlFree(attvalue);
9625	}
9626
9627	failed:
9628
9629	GROW
9630	if (ctxt->instate == XML_PARSER_EOF)
9631	break;
9632	if ((ctxt->input->base != base) \|\| (inputNr != ctxt->inputNr))
9633	goto base_changed;
9634	if ((RAW == '>') \|\| (((RAW == '/') && (NXT(1) == '>'))))
9635	break;
9636	if (!IS_BLANK_CH(RAW)) {
9637	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9638	"attributes construct error\n");
9639	break;
9640	}
9641	SKIP_BLANKS;
9642	if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
9643	(attname == NULL) && (attvalue == NULL)) {
9644	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
9645	"xmlParseStartTag: problem parsing attributes\n");
9646	break;
9647	}
9648	GROW;
9649	if ((ctxt->input->base != base) \|\| (inputNr != ctxt->inputNr))
9650	goto base_changed;
9651	}
9652
9653	/*
9654	* The attributes defaulting
9655	*/
9656	if (ctxt->attsDefault != NULL) {
9657	xmlDefAttrsPtr defaults;
9658
9659	defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
9660	if (defaults != NULL) {
9661	for (i = 0;i < defaults->nbAttrs;i++) {
9662	attname = defaults->values[5 * i];
9663	aprefix = defaults->values[5 * i + 1];
9664
9665	/*
9666	* special work for namespaces defaulted defs
9667	*/
9668	if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
9669	/*
9670	* check that it's not a defined namespace
9671	*/
9672	for (j = 1;j <= nbNs;j++)
9673	if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
9674	break;
9675	if (j <= nbNs) continue;
9676
9677	nsname = xmlGetNamespace(ctxt, NULL);
9678	if (nsname != defaults->values[5 * i + 2]) {
9679	if (nsPush(ctxt, NULL,
9680	defaults->values[5 * i + 2]) > 0)
9681	nbNs++;
9682	}
9683	} else if (aprefix == ctxt->str_xmlns) {
9684	/*
9685	* check that it's not a defined namespace
9686	*/
9687	for (j = 1;j <= nbNs;j++)
9688	if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
9689	break;
9690	if (j <= nbNs) continue;
9691
9692	nsname = xmlGetNamespace(ctxt, attname);
9693	if (nsname != defaults->values[2]) {
9694	if (nsPush(ctxt, attname,
9695	defaults->values[5 * i + 2]) > 0)
9696	nbNs++;
9697	}
9698	} else {
9699	/*
9700	* check that it's not a defined attribute
9701	*/
9702	for (j = 0;j < nbatts;j+=5) {
9703	if ((attname == atts[j]) && (aprefix == atts[j+1]))
9704	break;
9705	}
9706	if (j < nbatts) continue;
9707
9708	if ((atts == NULL) \|\| (nbatts + 5 > maxatts)) {
9709	if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
9710	return(NULL);
9711	}
9712	maxatts = ctxt->maxatts;
9713	atts = ctxt->atts;
9714	}
9715	atts[nbatts++] = attname;
9716	atts[nbatts++] = aprefix;
9717	if (aprefix == NULL)
9718	atts[nbatts++] = NULL;
9719	else
9720	atts[nbatts++] = xmlGetNamespace(ctxt, aprefix);
9721	atts[nbatts++] = defaults->values[5 * i + 2];
9722	atts[nbatts++] = defaults->values[5 * i + 3];
9723	if ((ctxt->standalone == 1) &&
9724	(defaults->values[5 * i + 4] != NULL)) {
9725	xmlValidityError(ctxt, XML_DTD_STANDALONE_DEFAULTED,
9726	"standalone: attribute %s on %s defaulted from external subset\n",
9727	attname, localname);
9728	}
9729	nbdef++;
9730	}
9731	}
9732	}
9733	}
9734
9735	/*
9736	* The attributes checkings
9737	*/
9738	for (i = 0; i < nbatts;i += 5) {
9739	/*
9740	* The default namespace does not apply to attribute names.
9741	*/
9742	if (atts[i + 1] != NULL) {
9743	nsname = xmlGetNamespace(ctxt, atts[i + 1]);
9744	if (nsname == NULL) {
9745	xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9746	"Namespace prefix %s for %s on %s is not defined\n",
9747	atts[i + 1], atts[i], localname);
9748	}
9749	atts[i + 2] = nsname;
9750	} else
9751	nsname = NULL;
9752	/*
9753	* [ WFC: Unique Att Spec ]
9754	* No attribute name may appear more than once in the same
9755	* start-tag or empty-element tag.
9756	* As extended by the Namespace in XML REC.
9757	*/
9758	for (j = 0; j < i;j += 5) {
9759	if (atts[i] == atts[j]) {
9760	if (atts[i+1] == atts[j+1]) {
9761	xmlErrAttributeDup(ctxt, atts[i+1], atts[i]);
9762	break;
9763	}
9764	if ((nsname != NULL) && (atts[j + 2] == nsname)) {
9765	xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
9766	"Namespaced Attribute %s in '%s' redefined\n",
9767	atts[i], nsname, NULL);
9768	break;
9769	}
9770	}
9771	}
9772	}
9773
9774	nsname = xmlGetNamespace(ctxt, prefix);
9775	if ((prefix != NULL) && (nsname == NULL)) {
9776	xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9777	"Namespace prefix %s on %s is not defined\n",
9778	prefix, localname, NULL);
9779	}
9780	*pref = prefix;
9781	*URI = nsname;
9782
9783	/*
9784	* SAX: Start of Element !
9785	*/
9786	if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
9787	(!ctxt->disableSAX)) {
9788	if (nbNs > 0)
9789	ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
9790	nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs],
9791	nbatts / 5, nbdef, atts);
9792	else
9793	ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
9794	nsname, 0, NULL, nbatts / 5, nbdef, atts);
9795	}
9796
9797	/*
9798	* Free up attribute allocated strings if needed
9799	*/
9800	if (attval != 0) {
9801	for (i = 3,j = 0; j < nratts;i += 5,j++)
9802	if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
9803	xmlFree((xmlChar *) atts[i]);
9804	}
9805
9806	return(localname);
9807
9808	base_changed:
9809	/*
9810	* the attribute strings are valid iif the base didn't changed
9811	*/
9812	if (attval != 0) {
9813	for (i = 3,j = 0; j < nratts;i += 5,j++)
9814	if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
9815	xmlFree((xmlChar *) atts[i]);
9816	}
9817
9818	/*
9819	* We can't switch from one entity to another in the middle
9820	* of a start tag
9821	*/
9822	if (inputNr != ctxt->inputNr) {
9823	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
9824	"Start tag doesn't start and stop in the same entity\n");
9825	return(NULL);
9826	}
9827
9828	ctxt->input->cur = ctxt->input->base + cur;
9829	ctxt->input->line = oldline;
9830	ctxt->input->col = oldcol;
9831	if (ctxt->wellFormed == 1) {
9832	goto reparse;
9833	}
9834	return(NULL);
9835	}
9836
9837	/**
9838	* xmlParseEndTag2:
9839	* @ctxt: an XML parser context
9840	* @line: line of the start tag
9841	* @nsNr: number of namespaces on the start tag
9842	*
9843	* parse an end of tag
9844	*
9845	* [42] ETag ::= '</' Name S? '>'
9846	*
9847	* With namespace
9848	*
9849	* [NS 9] ETag ::= '</' QName S? '>'
9850	*/
9851
9852	static void
9853	xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix,
9854	const xmlChar *URI, int line, int nsNr, int tlen) {
9855	const xmlChar *name;
9856	size_t curLength;
9857
9858	GROW;
9859	if ((RAW != '<') \|\| (NXT(1) != '/')) {
9860	xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL);
9861	return;
9862	}
9863	SKIP(2);
9864
9865	curLength = ctxt->input->end - ctxt->input->cur;
9866	if ((tlen > 0) && (curLength >= (size_t)tlen) &&
9867	(xmlStrncmp(ctxt->input->cur, ctxt->name, tlen) == 0)) {
9868	if ((curLength >= (size_t)(tlen + 1)) &&
9869	(ctxt->input->cur[tlen] == '>')) {
9870	ctxt->input->cur += tlen + 1;
9871	ctxt->input->col += tlen + 1;
9872	goto done;
9873	}
9874	ctxt->input->cur += tlen;
9875	ctxt->input->col += tlen;
9876	name = (xmlChar*)1;
9877	} else {
9878	if (prefix == NULL)
9879	name = xmlParseNameAndCompare(ctxt, ctxt->name);
9880	else
9881	name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix);
9882	}
9883
9884	/*
9885	* We should definitely be at the ending "S? '>'" part
9886	*/
9887	GROW;
9888	if (ctxt->instate == XML_PARSER_EOF)
9889	return;
9890	SKIP_BLANKS;
9891	if ((!IS_BYTE_CHAR(RAW)) \|\| (RAW != '>')) {
9892	xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
9893	} else
9894	NEXT1;
9895
9896	/*
9897	* [ WFC: Element Type Match ]
9898	* The Name in an element's end-tag must match the element type in the
9899	* start-tag.
9900	*
9901	*/
9902	if (name != (xmlChar*)1) {
9903	if (name == NULL) name = BAD_CAST "unparseable";
9904	if ((line == 0) && (ctxt->node != NULL))
9905	line = ctxt->node->line;
9906	xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
9907	"Opening and ending tag mismatch: %s line %d and %s\n",
9908	ctxt->name, line, name);
9909	}
9910
9911	/*
9912	* SAX: End of Tag
9913	*/
9914	done:
9915	if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
9916	(!ctxt->disableSAX))
9917	ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI);
9918
9919	spacePop(ctxt);
9920	if (nsNr != 0)
9921	nsPop(ctxt, nsNr);
9922	return;
9923	}
9924
9925	/**
9926	* xmlParseCDSect:
9927	* @ctxt: an XML parser context
9928	*
9929	* Parse escaped pure raw content.
9930	*
9931	* [18] CDSect ::= CDStart CData CDEnd
9932	*
9933	* [19] CDStart ::= '<![CDATA['
9934	*
9935	* [20] Data ::= (Char* - (Char* ']]>' Char*))
9936	*
9937	* [21] CDEnd ::= ']]>'
9938	*/
9939	void
9940	xmlParseCDSect(xmlParserCtxtPtr ctxt) {
9941	xmlChar *buf = NULL;
9942	int len = 0;
9943	int size = XML_PARSER_BUFFER_SIZE;
9944	int r, rl;
9945	int s, sl;
9946	int cur, l;
9947	int count = 0;
9948
9949	/* Check 2.6.0 was NXT(0) not RAW */
9950	if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
9951	SKIP(9);
9952	} else
9953	return;
9954
9955	ctxt->instate = XML_PARSER_CDATA_SECTION;
9956	r = CUR_CHAR(rl);
9957	if (!IS_CHAR(r)) {
9958	xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9959	ctxt->instate = XML_PARSER_CONTENT;
9960	return;
9961	}
9962	NEXTL(rl);
9963	s = CUR_CHAR(sl);
9964	if (!IS_CHAR(s)) {
9965	xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9966	ctxt->instate = XML_PARSER_CONTENT;
9967	return;
9968	}
9969	NEXTL(sl);
9970	cur = CUR_CHAR(l);
9971	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
9972	if (buf == NULL) {
9973	xmlErrMemory(ctxt, NULL);
9974	return;
9975	}
9976	while (IS_CHAR(cur) &&
9977	((r != ']') \|\| (s != ']') \|\| (cur != '>'))) {
9978	if (len + 5 >= size) {
9979	xmlChar *tmp;
9980
9981	if ((size > XML_MAX_TEXT_LENGTH) &&
9982	((ctxt->options & XML_PARSE_HUGE) == 0)) {
9983	xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
9984	"CData section too big found", NULL);
9985	xmlFree (buf);
9986	return;
9987	}
9988	tmp = (xmlChar ) xmlRealloc(buf, size 2 * sizeof(xmlChar));
9989	if (tmp == NULL) {
9990	xmlFree(buf);
9991	xmlErrMemory(ctxt, NULL);
9992	return;
9993	}
9994	buf = tmp;
9995	size *= 2;
9996	}
9997	COPY_BUF(rl,buf,len,r);
9998	r = s;
9999	rl = sl;
10000	s = cur;
10001	sl = l;
10002	count++;
10003	if (count > 50) {
10004	GROW;
10005	if (ctxt->instate == XML_PARSER_EOF) {
10006	xmlFree(buf);
10007	return;
10008	}
10009	count = 0;
10010	}
10011	NEXTL(l);
10012	cur = CUR_CHAR(l);
10013	}
10014	buf[len] = 0;
10015	ctxt->instate = XML_PARSER_CONTENT;
10016	if (cur != '>') {
10017	xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
10018	"CData section not finished\n%.50s\n", buf);
10019	xmlFree(buf);
10020	return;
10021	}
10022	NEXTL(l);
10023
10024	/*
10025	* OK the buffer is to be consumed as cdata.
10026	*/
10027	if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
10028	if (ctxt->sax->cdataBlock != NULL)
10029	ctxt->sax->cdataBlock(ctxt->userData, buf, len);
10030	else if (ctxt->sax->characters != NULL)
10031	ctxt->sax->characters(ctxt->userData, buf, len);
10032	}
10033	xmlFree(buf);
10034	}
10035
10036	/**
10037	* xmlParseContent:
10038	* @ctxt: an XML parser context
10039	*
10040	* Parse a content:
10041	*
10042	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
10043	*/
10044
10045	void
10046	xmlParseContent(xmlParserCtxtPtr ctxt) {
10047	GROW;
10048	while ((RAW != 0) &&
10049	((RAW != '<') \|\| (NXT(1) != '/')) &&
10050	(ctxt->instate != XML_PARSER_EOF)) {
10051	const xmlChar *test = CUR_PTR;
10052	unsigned int cons = ctxt->input->consumed;
10053	const xmlChar *cur = ctxt->input->cur;
10054
10055	/*
10056	* First case : a Processing Instruction.
10057	*/
10058	if ((*cur == '<') && (cur[1] == '?')) {
10059	xmlParsePI(ctxt);
10060	}
10061
10062	/*
10063	* Second case : a CDSection
10064	*/
10065	/* 2.6.0 test was cur not RAW /
10066	else if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
10067	xmlParseCDSect(ctxt);
10068	}
10069
10070	/*
10071	* Third case : a comment
10072	*/
10073	else if ((*cur == '<') && (NXT(1) == '!') &&
10074	(NXT(2) == '-') && (NXT(3) == '-')) {
10075	xmlParseComment(ctxt);
10076	ctxt->instate = XML_PARSER_CONTENT;
10077	}
10078
10079	/*
10080	* Fourth case : a sub-element.
10081	*/
10082	else if (*cur == '<') {
10083	xmlParseElement(ctxt);
10084	}
10085
10086	/*
10087	* Fifth case : a reference. If if has not been resolved,
10088	* parsing returns it's Name, create the node
10089	*/
10090
10091	else if (*cur == '&') {
10092	xmlParseReference(ctxt);
10093	}
10094
10095	/*
10096	* Last case, text. Note that References are handled directly.
10097	*/
10098	else {
10099	xmlParseCharData(ctxt, 0);
10100	}
10101
10102	GROW;
10103	/*
10104	* Pop-up of finished entities.
10105	*/
10106	while ((RAW == 0) && (ctxt->inputNr > 1))
10107	xmlPopInput(ctxt);
10108	SHRINK;
10109
10110	if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
10111	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
10112	"detected an error in element content\n");
10113	xmlHaltParser(ctxt);
10114	break;
10115	}
10116	}
10117	}
10118
10119	/**
10120	* xmlParseElement:
10121	* @ctxt: an XML parser context
10122	*
10123	* parse an XML element, this is highly recursive
10124	*
10125	* [39] element ::= EmptyElemTag \| STag content ETag
10126	*
10127	* [ WFC: Element Type Match ]
10128	* The Name in an element's end-tag must match the element type in the
10129	* start-tag.
10130	*
10131	*/
10132
10133	void
10134	xmlParseElement(xmlParserCtxtPtr ctxt) {
10135	const xmlChar *name;
10136	const xmlChar *prefix = NULL;
10137	const xmlChar *URI = NULL;
10138	xmlParserNodeInfo node_info;
10139	int line, tlen = 0;
10140	xmlNodePtr ret;
10141	int nsNr = ctxt->nsNr;
10142
10143	if (((unsigned int) ctxt->nameNr > xmlParserMaxDepth) &&
10144	((ctxt->options & XML_PARSE_HUGE) == 0)) {
10145	xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
10146	"Excessive depth in document: %d use XML_PARSE_HUGE option\n",
10147	xmlParserMaxDepth);
10148	xmlHaltParser(ctxt);
10149	return;
10150	}
10151
10152	/* Capture start position */
10153	if (ctxt->record_info) {
10154	node_info.begin_pos = ctxt->input->consumed +
10155	(CUR_PTR - ctxt->input->base);
10156	node_info.begin_line = ctxt->input->line;
10157	}
10158
10159	if (ctxt->spaceNr == 0)
10160	spacePush(ctxt, -1);
10161	else if (*ctxt->space == -2)
10162	spacePush(ctxt, -1);
10163	else
10164	spacePush(ctxt, *ctxt->space);
10165
10166	line = ctxt->input->line;
10167	#ifdef LIBXML_SAX1_ENABLED
10168	if (ctxt->sax2)
10169	#endif /* LIBXML_SAX1_ENABLED */
10170	name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
10171	#ifdef LIBXML_SAX1_ENABLED
10172	else
10173	name = xmlParseStartTag(ctxt);
10174	#endif /* LIBXML_SAX1_ENABLED */
10175	if (ctxt->instate == XML_PARSER_EOF)
10176	return;
10177	if (name == NULL) {
10178	spacePop(ctxt);
10179	return;
10180	}
10181	namePush(ctxt, name);
10182	ret = ctxt->node;
10183
10184	#ifdef LIBXML_VALID_ENABLED
10185	/*
10186	* [ VC: Root Element Type ]
10187	* The Name in the document type declaration must match the element
10188	* type of the root element.
10189	*/
10190	if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
10191	ctxt->node && (ctxt->node == ctxt->myDoc->children))
10192	ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
10193	#endif /* LIBXML_VALID_ENABLED */
10194
10195	/*
10196	* Check for an Empty Element.
10197	*/
10198	if ((RAW == '/') && (NXT(1) == '>')) {
10199	SKIP(2);
10200	if (ctxt->sax2) {
10201	if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
10202	(!ctxt->disableSAX))
10203	ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
10204	#ifdef LIBXML_SAX1_ENABLED
10205	} else {
10206	if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
10207	(!ctxt->disableSAX))
10208	ctxt->sax->endElement(ctxt->userData, name);
10209	#endif /* LIBXML_SAX1_ENABLED */
10210	}
10211	namePop(ctxt);
10212	spacePop(ctxt);
10213	if (nsNr != ctxt->nsNr)
10214	nsPop(ctxt, ctxt->nsNr - nsNr);
10215	if ( ret != NULL && ctxt->record_info ) {
10216	node_info.end_pos = ctxt->input->consumed +
10217	(CUR_PTR - ctxt->input->base);
10218	node_info.end_line = ctxt->input->line;
10219	node_info.node = ret;
10220	xmlParserAddNodeInfo(ctxt, &node_info);
10221	}
10222	return;
10223	}
10224	if (RAW == '>') {
10225	NEXT1;
10226	} else {
10227	xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED,
10228	"Couldn't find end of Start Tag %s line %d\n",
10229	name, line, NULL);
10230
10231	/*
10232	* end of parsing of this node.
10233	*/
10234	nodePop(ctxt);
10235	namePop(ctxt);
10236	spacePop(ctxt);
10237	if (nsNr != ctxt->nsNr)
10238	nsPop(ctxt, ctxt->nsNr - nsNr);
10239
10240	/*
10241	* Capture end position and add node
10242	*/
10243	if ( ret != NULL && ctxt->record_info ) {
10244	node_info.end_pos = ctxt->input->consumed +
10245	(CUR_PTR - ctxt->input->base);
10246	node_info.end_line = ctxt->input->line;
10247	node_info.node = ret;
10248	xmlParserAddNodeInfo(ctxt, &node_info);
10249	}
10250	return;
10251	}
10252
10253	/*
10254	* Parse the content of the element:
10255	*/
10256	xmlParseContent(ctxt);
10257	if (ctxt->instate == XML_PARSER_EOF)
10258	return;
10259	if (!IS_BYTE_CHAR(RAW)) {
10260	xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
10261	"Premature end of data in tag %s line %d\n",
10262	name, line, NULL);
10263
10264	/*
10265	* end of parsing of this node.
10266	*/
10267	nodePop(ctxt);
10268	namePop(ctxt);
10269	spacePop(ctxt);
10270	if (nsNr != ctxt->nsNr)
10271	nsPop(ctxt, ctxt->nsNr - nsNr);
10272	return;
10273	}
10274
10275	/*
10276	* parse the end of tag: '</' should be here.
10277	*/
10278	if (ctxt->sax2) {
10279	xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr, tlen);
10280	namePop(ctxt);
10281	}
10282	#ifdef LIBXML_SAX1_ENABLED
10283	else
10284	xmlParseEndTag1(ctxt, line);
10285	#endif /* LIBXML_SAX1_ENABLED */
10286
10287	/*
10288	* Capture end position and add node
10289	*/
10290	if ( ret != NULL && ctxt->record_info ) {
10291	node_info.end_pos = ctxt->input->consumed +
10292	(CUR_PTR - ctxt->input->base);
10293	node_info.end_line = ctxt->input->line;
10294	node_info.node = ret;
10295	xmlParserAddNodeInfo(ctxt, &node_info);
10296	}
10297	}
10298
10299	/**
10300	* xmlParseVersionNum:
10301	* @ctxt: an XML parser context
10302	*
10303	* parse the XML version value.
10304	*
10305	* [26] VersionNum ::= '1.' [0-9]+
10306	*
10307	* In practice allow [0-9].[0-9]+ at that level
10308	*
10309	* Returns the string giving the XML version number, or NULL
10310	*/
10311	xmlChar *
10312	xmlParseVersionNum(xmlParserCtxtPtr ctxt) {
10313	xmlChar *buf = NULL;
10314	int len = 0;
10315	int size = 10;
10316	xmlChar cur;
10317
10318	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
10319	if (buf == NULL) {
10320	xmlErrMemory(ctxt, NULL);
10321	return(NULL);
10322	}
10323	cur = CUR;
10324	if (!((cur >= '0') && (cur <= '9'))) {
10325	xmlFree(buf);
10326	return(NULL);
10327	}
10328	buf[len++] = cur;
10329	NEXT;
10330	cur=CUR;
10331	if (cur != '.') {
10332	xmlFree(buf);
10333	return(NULL);
10334	}
10335	buf[len++] = cur;
10336	NEXT;
10337	cur=CUR;
10338	while ((cur >= '0') && (cur <= '9')) {
10339	if (len + 1 >= size) {
10340	xmlChar *tmp;
10341
10342	size *= 2;
10343	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
10344	if (tmp == NULL) {
10345	xmlFree(buf);
10346	xmlErrMemory(ctxt, NULL);
10347	return(NULL);
10348	}
10349	buf = tmp;
10350	}
10351	buf[len++] = cur;
10352	NEXT;
10353	cur=CUR;
10354	}
10355	buf[len] = 0;
10356	return(buf);
10357	}
10358
10359	/**
10360	* xmlParseVersionInfo:
10361	* @ctxt: an XML parser context
10362	*
10363	* parse the XML version.
10364	*
10365	* [24] VersionInfo ::= S 'version' Eq (' VersionNum ' \| " VersionNum ")
10366	*
10367	* [25] Eq ::= S? '=' S?
10368	*
10369	* Returns the version string, e.g. "1.0"
10370	*/
10371
10372	xmlChar *
10373	xmlParseVersionInfo(xmlParserCtxtPtr ctxt) {
10374	xmlChar *version = NULL;
10375
10376	if (CMP7(CUR_PTR, 'v', 'e', 'r', 's', 'i', 'o', 'n')) {
10377	SKIP(7);
10378	SKIP_BLANKS;
10379	if (RAW != '=') {
10380	xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10381	return(NULL);
10382	}
10383	NEXT;
10384	SKIP_BLANKS;
10385	if (RAW == '"') {
10386	NEXT;
10387	version = xmlParseVersionNum(ctxt);
10388	if (RAW != '"') {
10389	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10390	} else
10391	NEXT;
10392	} else if (RAW == '\''){
10393	NEXT;
10394	version = xmlParseVersionNum(ctxt);
10395	if (RAW != '\'') {
10396	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10397	} else
10398	NEXT;
10399	} else {
10400	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10401	}
10402	}
10403	return(version);
10404	}
10405
10406	/**
10407	* xmlParseEncName:
10408	* @ctxt: an XML parser context
10409	*
10410	* parse the XML encoding name
10411	*
10412	* [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] \| '-')*
10413	*
10414	* Returns the encoding name value or NULL
10415	*/
10416	xmlChar *
10417	xmlParseEncName(xmlParserCtxtPtr ctxt) {
10418	xmlChar *buf = NULL;
10419	int len = 0;
10420	int size = 10;
10421	xmlChar cur;
10422
10423	cur = CUR;
10424	if (((cur >= 'a') && (cur <= 'z')) \|\|
10425	((cur >= 'A') && (cur <= 'Z'))) {
10426	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
10427	if (buf == NULL) {
10428	xmlErrMemory(ctxt, NULL);
10429	return(NULL);
10430	}
10431
10432	buf[len++] = cur;
10433	NEXT;
10434	cur = CUR;
10435	while (((cur >= 'a') && (cur <= 'z')) \|\|
10436	((cur >= 'A') && (cur <= 'Z')) \|\|
10437	((cur >= '0') && (cur <= '9')) \|\|
10438	(cur == '.') \|\| (cur == '_') \|\|
10439	(cur == '-')) {
10440	if (len + 1 >= size) {
10441	xmlChar *tmp;
10442
10443	size *= 2;
10444	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
10445	if (tmp == NULL) {
10446	xmlErrMemory(ctxt, NULL);
10447	xmlFree(buf);
10448	return(NULL);
10449	}
10450	buf = tmp;
10451	}
10452	buf[len++] = cur;
10453	NEXT;
10454	cur = CUR;
10455	if (cur == 0) {
10456	SHRINK;
10457	GROW;
10458	cur = CUR;
10459	}
10460	}
10461	buf[len] = 0;
10462	} else {
10463	xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
10464	}
10465	return(buf);
10466	}
10467
10468	/**
10469	* xmlParseEncodingDecl:
10470	* @ctxt: an XML parser context
10471	*
10472	* parse the XML encoding declaration
10473	*
10474	* [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' \| "'" EncName "'")
10475	*
10476	* this setups the conversion filters.
10477	*
10478	* Returns the encoding value or NULL
10479	*/
10480
10481	const xmlChar *
10482	xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) {
10483	xmlChar *encoding = NULL;
10484
10485	SKIP_BLANKS;
10486	if (CMP8(CUR_PTR, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g')) {
10487	SKIP(8);
10488	SKIP_BLANKS;
10489	if (RAW != '=') {
10490	xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10491	return(NULL);
10492	}
10493	NEXT;
10494	SKIP_BLANKS;
10495	if (RAW == '"') {
10496	NEXT;
10497	encoding = xmlParseEncName(ctxt);
10498	if (RAW != '"') {
10499	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10500	xmlFree((xmlChar *) encoding);
10501	return(NULL);
10502	} else
10503	NEXT;
10504	} else if (RAW == '\''){
10505	NEXT;
10506	encoding = xmlParseEncName(ctxt);
10507	if (RAW != '\'') {
10508	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10509	xmlFree((xmlChar *) encoding);
10510	return(NULL);
10511	} else
10512	NEXT;
10513	} else {
10514	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10515	}
10516
10517	/*
10518	* Non standard parsing, allowing the user to ignore encoding
10519	*/
10520	if (ctxt->options & XML_PARSE_IGNORE_ENC) {
10521	xmlFree((xmlChar *) encoding);
10522	return(NULL);
10523	}
10524
10525	/*
10526	* UTF-16 encoding stwich has already taken place at this stage,
10527	* more over the little-endian/big-endian selection is already done
10528	*/
10529	if ((encoding != NULL) &&
10530	((!xmlStrcasecmp(encoding, BAD_CAST "UTF-16")) \|\|
10531	(!xmlStrcasecmp(encoding, BAD_CAST "UTF16")))) {
10532	/*
10533	* If no encoding was passed to the parser, that we are
10534	* using UTF-16 and no decoder is present i.e. the
10535	* document is apparently UTF-8 compatible, then raise an
10536	* encoding mismatch fatal error
10537	*/
10538	if ((ctxt->encoding == NULL) &&
10539	(ctxt->input->buf != NULL) &&
10540	(ctxt->input->buf->encoder == NULL)) {
10541	xmlFatalErrMsg(ctxt, XML_ERR_INVALID_ENCODING,
10542	"Document labelled UTF-16 but has UTF-8 content\n");
10543	}
10544	if (ctxt->encoding != NULL)
10545	xmlFree((xmlChar *) ctxt->encoding);
10546	ctxt->encoding = encoding;
10547	}
10548	/*
10549	* UTF-8 encoding is handled natively
10550	*/
10551	else if ((encoding != NULL) &&
10552	((!xmlStrcasecmp(encoding, BAD_CAST "UTF-8")) \|\|
10553	(!xmlStrcasecmp(encoding, BAD_CAST "UTF8")))) {
10554	if (ctxt->encoding != NULL)
10555	xmlFree((xmlChar *) ctxt->encoding);
10556	ctxt->encoding = encoding;
10557	}
10558	else if (encoding != NULL) {
10559	xmlCharEncodingHandlerPtr handler;
10560
10561	if (ctxt->input->encoding != NULL)
10562	xmlFree((xmlChar *) ctxt->input->encoding);
10563	ctxt->input->encoding = encoding;
10564
10565	handler = xmlFindCharEncodingHandler((const char *) encoding);
10566	if (handler != NULL) {
10567	if (xmlSwitchToEncoding(ctxt, handler) < 0) {
10568	/* failed to convert */
10569	ctxt->errNo = XML_ERR_UNSUPPORTED_ENCODING;
10570	return(NULL);
10571	}
10572	} else {
10573	xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
10574	"Unsupported encoding %s\n", encoding);
10575	return(NULL);
10576	}
10577	}
10578	}
10579	return(encoding);
10580	}
10581
10582	/**
10583	* xmlParseSDDecl:
10584	* @ctxt: an XML parser context
10585	*
10586	* parse the XML standalone declaration
10587	*
10588	* [32] SDDecl ::= S 'standalone' Eq
10589	* (("'" ('yes' \| 'no') "'") \| ('"' ('yes' \| 'no')'"'))
10590	*
10591	* [ VC: Standalone Document Declaration ]
10592	* TODO The standalone document declaration must have the value "no"
10593	* if any external markup declarations contain declarations of:
10594	* - attributes with default values, if elements to which these
10595	* attributes apply appear in the document without specifications
10596	* of values for these attributes, or
10597	* - entities (other than amp, lt, gt, apos, quot), if references
10598	* to those entities appear in the document, or
10599	* - attributes with values subject to normalization, where the
10600	* attribute appears in the document with a value which will change
10601	* as a result of normalization, or
10602	* - element types with element content, if white space occurs directly
10603	* within any instance of those types.
10604	*
10605	* Returns:
10606	* 1 if standalone="yes"
10607	* 0 if standalone="no"
10608	* -2 if standalone attribute is missing or invalid
10609	* (A standalone value of -2 means that the XML declaration was found,
10610	* but no value was specified for the standalone attribute).
10611	*/
10612
10613	int
10614	xmlParseSDDecl(xmlParserCtxtPtr ctxt) {
10615	int standalone = -2;
10616
10617	SKIP_BLANKS;
10618	if (CMP10(CUR_PTR, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o', 'n', 'e')) {
10619	SKIP(10);
10620	SKIP_BLANKS;
10621	if (RAW != '=') {
10622	xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10623	return(standalone);
10624	}
10625	NEXT;
10626	SKIP_BLANKS;
10627	if (RAW == '\''){
10628	NEXT;
10629	if ((RAW == 'n') && (NXT(1) == 'o')) {
10630	standalone = 0;
10631	SKIP(2);
10632	} else if ((RAW == 'y') && (NXT(1) == 'e') &&
10633	(NXT(2) == 's')) {
10634	standalone = 1;
10635	SKIP(3);
10636	} else {
10637	xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10638	}
10639	if (RAW != '\'') {
10640	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10641	} else
10642	NEXT;
10643	} else if (RAW == '"'){
10644	NEXT;
10645	if ((RAW == 'n') && (NXT(1) == 'o')) {
10646	standalone = 0;
10647	SKIP(2);
10648	} else if ((RAW == 'y') && (NXT(1) == 'e') &&
10649	(NXT(2) == 's')) {
10650	standalone = 1;
10651	SKIP(3);
10652	} else {
10653	xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10654	}
10655	if (RAW != '"') {
10656	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10657	} else
10658	NEXT;
10659	} else {
10660	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10661	}
10662	}
10663	return(standalone);
10664	}
10665
10666	/**
10667	* xmlParseXMLDecl:
10668	* @ctxt: an XML parser context
10669	*
10670	* parse an XML declaration header
10671	*
10672	* [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
10673	*/
10674
10675	void
10676	xmlParseXMLDecl(xmlParserCtxtPtr ctxt) {
10677	xmlChar *version;
10678
10679	/*
10680	* This value for standalone indicates that the document has an
10681	* XML declaration but it does not have a standalone attribute.
10682	* It will be overwritten later if a standalone attribute is found.
10683	*/
10684	ctxt->input->standalone = -2;
10685
10686	/*
10687	* We know that '<?xml' is here.
10688	*/
10689	SKIP(5);
10690
10691	if (!IS_BLANK_CH(RAW)) {
10692	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
10693	"Blank needed after '<?xml'\n");
10694	}
10695	SKIP_BLANKS;
10696
10697	/*
10698	* We must have the VersionInfo here.
10699	*/
10700	version = xmlParseVersionInfo(ctxt);
10701	if (version == NULL) {
10702	xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
10703	} else {
10704	if (!xmlStrEqual(version, (const xmlChar *) XML_DEFAULT_VERSION)) {
10705	/*
10706	* Changed here for XML-1.0 5th edition
10707	*/
10708	if (ctxt->options & XML_PARSE_OLD10) {
10709	xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10710	"Unsupported version '%s'\n",
10711	version);
10712	} else {
10713	if ((version[0] == '1') && ((version[1] == '.'))) {
10714	xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
10715	"Unsupported version '%s'\n",
10716	version, NULL);
10717	} else {
10718	xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10719	"Unsupported version '%s'\n",
10720	version);
10721	}
10722	}
10723	}
10724	if (ctxt->version != NULL)
10725	xmlFree((void *) ctxt->version);
10726	ctxt->version = version;
10727	}
10728
10729	/*
10730	* We may have the encoding declaration
10731	*/
10732	if (!IS_BLANK_CH(RAW)) {
10733	if ((RAW == '?') && (NXT(1) == '>')) {
10734	SKIP(2);
10735	return;
10736	}
10737	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10738	}
10739	xmlParseEncodingDecl(ctxt);
10740	if ((ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) \|\|
10741	(ctxt->instate == XML_PARSER_EOF)) {
10742	/*
10743	* The XML REC instructs us to stop parsing right here
10744	*/
10745	return;
10746	}
10747
10748	/*
10749	* We may have the standalone status.
10750	*/
10751	if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
10752	if ((RAW == '?') && (NXT(1) == '>')) {
10753	SKIP(2);
10754	return;
10755	}
10756	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10757	}
10758
10759	/*
10760	* We can grow the input buffer freely at that point
10761	*/
10762	GROW;
10763
10764	SKIP_BLANKS;
10765	ctxt->input->standalone = xmlParseSDDecl(ctxt);
10766
10767	SKIP_BLANKS;
10768	if ((RAW == '?') && (NXT(1) == '>')) {
10769	SKIP(2);
10770	} else if (RAW == '>') {
10771	/* Deprecated old WD ... */
10772	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10773	NEXT;
10774	} else {
10775	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10776	MOVETO_ENDTAG(CUR_PTR);
10777	NEXT;
10778	}
10779	}
10780
10781	/**
10782	* xmlParseMisc:
10783	* @ctxt: an XML parser context
10784	*
10785	* parse an XML Misc* optional field.
10786	*
10787	* [27] Misc ::= Comment \| PI \| S
10788	*/
10789
10790	void
10791	xmlParseMisc(xmlParserCtxtPtr ctxt) {
10792	while ((ctxt->instate != XML_PARSER_EOF) &&
10793	(((RAW == '<') && (NXT(1) == '?')) \|\|
10794	(CMP4(CUR_PTR, '<', '!', '-', '-')) \|\|
10795	IS_BLANK_CH(CUR))) {
10796	if ((RAW == '<') && (NXT(1) == '?')) {
10797	xmlParsePI(ctxt);
10798	} else if (IS_BLANK_CH(CUR)) {
10799	NEXT;
10800	} else
10801	xmlParseComment(ctxt);
10802	}
10803	}
10804
10805	/**
10806	* xmlParseDocument:
10807	* @ctxt: an XML parser context
10808	*
10809	* parse an XML document (and build a tree if using the standard SAX
10810	* interface).
10811	*
10812	* [1] document ::= prolog element Misc*
10813	*
10814	* [22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)?
10815	*
10816	* Returns 0, -1 in case of error. the parser context is augmented
10817	* as a result of the parsing.
10818	*/
10819
10820	int
10821	xmlParseDocument(xmlParserCtxtPtr ctxt) {
10822	xmlChar start[4];
10823	xmlCharEncoding enc;
10824
10825	xmlInitParser();
10826
10827	if ((ctxt == NULL) \|\| (ctxt->input == NULL))
10828	return(-1);
10829
10830	GROW;
10831
10832	/*
10833	* SAX: detecting the level.
10834	*/
10835	xmlDetectSAX2(ctxt);
10836
10837	/*
10838	* SAX: beginning of the document processing.
10839	*/
10840	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10841	ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
10842	if (ctxt->instate == XML_PARSER_EOF)
10843	return(-1);
10844
10845	if ((ctxt->encoding == NULL) &&
10846	((ctxt->input->end - ctxt->input->cur) >= 4)) {
10847	/*
10848	* Get the 4 first bytes and decode the charset
10849	* if enc != XML_CHAR_ENCODING_NONE
10850	* plug some encoding conversion routines.
10851	*/
10852	start[0] = RAW;
10853	start[1] = NXT(1);
10854	start[2] = NXT(2);
10855	start[3] = NXT(3);
10856	enc = xmlDetectCharEncoding(&start[0], 4);
10857	if (enc != XML_CHAR_ENCODING_NONE) {
10858	xmlSwitchEncoding(ctxt, enc);
10859	}
10860	}
10861
10862
10863	if (CUR == 0) {
10864	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10865	return(-1);
10866	}
10867
10868	/*
10869	* Check for the XMLDecl in the Prolog.
10870	* do not GROW here to avoid the detected encoder to decode more
10871	* than just the first line, unless the amount of data is really
10872	* too small to hold "<?xml version="1.0" encoding="foo"
10873	*/
10874	if ((ctxt->input->end - ctxt->input->cur) < 35) {
10875	GROW;
10876	}
10877	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
10878
10879	/*
10880	* Note that we will switch encoding on the fly.
10881	*/
10882	xmlParseXMLDecl(ctxt);
10883	if ((ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) \|\|
10884	(ctxt->instate == XML_PARSER_EOF)) {
10885	/*
10886	* The XML REC instructs us to stop parsing right here
10887	*/
10888	return(-1);
10889	}
10890	ctxt->standalone = ctxt->input->standalone;
10891	SKIP_BLANKS;
10892	} else {
10893	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10894	}
10895	if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
10896	ctxt->sax->startDocument(ctxt->userData);
10897	if (ctxt->instate == XML_PARSER_EOF)
10898	return(-1);
10899	if ((ctxt->myDoc != NULL) && (ctxt->input != NULL) &&
10900	(ctxt->input->buf != NULL) && (ctxt->input->buf->compressed >= 0)) {
10901	ctxt->myDoc->compression = ctxt->input->buf->compressed;
10902	}
10903
10904	/*
10905	* The Misc part of the Prolog
10906	*/
10907	GROW;
10908	xmlParseMisc(ctxt);
10909
10910	/*
10911	* Then possibly doc type declaration(s) and more Misc
10912	* (doctypedecl Misc*)?
10913	*/
10914	GROW;
10915	if (CMP9(CUR_PTR, '<', '!', 'D', 'O', 'C', 'T', 'Y', 'P', 'E')) {
10916
10917	ctxt->inSubset = 1;
10918	xmlParseDocTypeDecl(ctxt);
10919	if (RAW == '[') {
10920	ctxt->instate = XML_PARSER_DTD;
10921	xmlParseInternalSubset(ctxt);
10922	if (ctxt->instate == XML_PARSER_EOF)
10923	return(-1);
10924	}
10925
10926	/*
10927	* Create and update the external subset.
10928	*/
10929	ctxt->inSubset = 2;
10930	if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) &&
10931	(!ctxt->disableSAX))
10932	ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
10933	ctxt->extSubSystem, ctxt->extSubURI);
10934	if (ctxt->instate == XML_PARSER_EOF)
10935	return(-1);
10936	ctxt->inSubset = 0;
10937
10938	xmlCleanSpecialAttr(ctxt);
10939
10940	ctxt->instate = XML_PARSER_PROLOG;
10941	xmlParseMisc(ctxt);
10942	}
10943
10944	/*
10945	* Time to start parsing the tree itself
10946	*/
10947	GROW;
10948	if (RAW != '<') {
10949	xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
10950	"Start tag expected, '<' not found\n");
10951	} else {
10952	ctxt->instate = XML_PARSER_CONTENT;
10953	xmlParseElement(ctxt);
10954	ctxt->instate = XML_PARSER_EPILOG;
10955
10956
10957	/*
10958	* The Misc part at the end
10959	*/
10960	xmlParseMisc(ctxt);
10961
10962	if (RAW != 0) {
10963	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10964	}
10965	ctxt->instate = XML_PARSER_EOF;
10966	}
10967
10968	/*
10969	* SAX: end of the document processing.
10970	*/
10971	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10972	ctxt->sax->endDocument(ctxt->userData);
10973
10974	/*
10975	* Remove locally kept entity definitions if the tree was not built
10976	*/
10977	if ((ctxt->myDoc != NULL) &&
10978	(xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
10979	xmlFreeDoc(ctxt->myDoc);
10980	ctxt->myDoc = NULL;
10981	}
10982
10983	if ((ctxt->wellFormed) && (ctxt->myDoc != NULL)) {
10984	ctxt->myDoc->properties \|= XML_DOC_WELLFORMED;
10985	if (ctxt->valid)
10986	ctxt->myDoc->properties \|= XML_DOC_DTDVALID;
10987	if (ctxt->nsWellFormed)
10988	ctxt->myDoc->properties \|= XML_DOC_NSVALID;
10989	if (ctxt->options & XML_PARSE_OLD10)
10990	ctxt->myDoc->properties \|= XML_DOC_OLD10;
10991	}
10992	if (! ctxt->wellFormed) {
10993	ctxt->valid = 0;
10994	return(-1);
10995	}
10996	return(0);
10997	}
10998
10999	/**
11000	* xmlParseExtParsedEnt:
11001	* @ctxt: an XML parser context
11002	*
11003	* parse a general parsed entity
11004	* An external general parsed entity is well-formed if it matches the
11005	* production labeled extParsedEnt.
11006	*
11007	* [78] extParsedEnt ::= TextDecl? content
11008	*
11009	* Returns 0, -1 in case of error. the parser context is augmented
11010	* as a result of the parsing.
11011	*/
11012
11013	int
11014	xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) {
11015	xmlChar start[4];
11016	xmlCharEncoding enc;
11017
11018	if ((ctxt == NULL) \|\| (ctxt->input == NULL))
11019	return(-1);
11020
11021	xmlDefaultSAXHandlerInit();
11022
11023	xmlDetectSAX2(ctxt);
11024
11025	GROW;
11026
11027	/*
11028	* SAX: beginning of the document processing.
11029	*/
11030	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11031	ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
11032
11033	/*
11034	* Get the 4 first bytes and decode the charset
11035	* if enc != XML_CHAR_ENCODING_NONE
11036	* plug some encoding conversion routines.
11037	*/
11038	if ((ctxt->input->end - ctxt->input->cur) >= 4) {
11039	start[0] = RAW;
11040	start[1] = NXT(1);
11041	start[2] = NXT(2);
11042	start[3] = NXT(3);
11043	enc = xmlDetectCharEncoding(start, 4);
11044	if (enc != XML_CHAR_ENCODING_NONE) {
11045	xmlSwitchEncoding(ctxt, enc);
11046	}
11047	}
11048
11049
11050	if (CUR == 0) {
11051	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
11052	}
11053
11054	/*
11055	* Check for the XMLDecl in the Prolog.
11056	*/
11057	GROW;
11058	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
11059
11060	/*
11061	* Note that we will switch encoding on the fly.
11062	*/
11063	xmlParseXMLDecl(ctxt);
11064	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
11065	/*
11066	* The XML REC instructs us to stop parsing right here
11067	*/
11068	return(-1);
11069	}
11070	SKIP_BLANKS;
11071	} else {
11072	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
11073	}
11074	if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
11075	ctxt->sax->startDocument(ctxt->userData);
11076	if (ctxt->instate == XML_PARSER_EOF)
11077	return(-1);
11078
11079	/*
11080	* Doing validity checking on chunk doesn't make sense
11081	*/
11082	ctxt->instate = XML_PARSER_CONTENT;
11083	ctxt->validate = 0;
11084	ctxt->loadsubset = 0;
11085	ctxt->depth = 0;
11086
11087	xmlParseContent(ctxt);
11088	if (ctxt->instate == XML_PARSER_EOF)
11089	return(-1);
11090
11091	if ((RAW == '<') && (NXT(1) == '/')) {
11092	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11093	} else if (RAW != 0) {
11094	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11095	}
11096
11097	/*
11098	* SAX: end of the document processing.
11099	*/
11100	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11101	ctxt->sax->endDocument(ctxt->userData);
11102
11103	if (! ctxt->wellFormed) return(-1);
11104	return(0);
11105	}
11106
11107	#ifdef LIBXML_PUSH_ENABLED
11108	/************************************************************************
11109	* *
11110	* Progressive parsing interfaces *
11111	* *
11112	************************************************************************/
11113
11114	/**
11115	* xmlParseLookupSequence:
11116	* @ctxt: an XML parser context
11117	* @first: the first char to lookup
11118	* @next: the next char to lookup or zero
11119	* @third: the next char to lookup or zero
11120	*
11121	* Try to find if a sequence (first, next, third) or just (first next) or
11122	* (first) is available in the input stream.
11123	* This function has a side effect of (possibly) incrementing ctxt->checkIndex
11124	* to avoid rescanning sequences of bytes, it DOES change the state of the
11125	* parser, do not use liberally.
11126	*
11127	* Returns the index to the current parsing point if the full sequence
11128	* is available, -1 otherwise.
11129	*/
11130	static int
11131	xmlParseLookupSequence(xmlParserCtxtPtr ctxt, xmlChar first,
11132	xmlChar next, xmlChar third) {
11133	int base, len;
11134	xmlParserInputPtr in;
11135	const xmlChar *buf;
11136
11137	in = ctxt->input;
11138	if (in == NULL) return(-1);
11139	base = in->cur - in->base;
11140	if (base < 0) return(-1);
11141	if (ctxt->checkIndex > base)
11142	base = ctxt->checkIndex;
11143	if (in->buf == NULL) {
11144	buf = in->base;
11145	len = in->length;
11146	} else {
11147	buf = xmlBufContent(in->buf->buffer);
11148	len = xmlBufUse(in->buf->buffer);
11149	}
11150	/* take into account the sequence length */
11151	if (third) len -= 2;
11152	else if (next) len --;
11153	for (;base < len;base++) {
11154	if (buf[base] == first) {
11155	if (third != 0) {
11156	if ((buf[base + 1] != next) \|\|
11157	(buf[base + 2] != third)) continue;
11158	} else if (next != 0) {
11159	if (buf[base + 1] != next) continue;
11160	}
11161	ctxt->checkIndex = 0;
11162	#ifdef DEBUG_PUSH
11163	if (next == 0)
11164	xmlGenericError(xmlGenericErrorContext,
11165	"PP: lookup '%c' found at %d\n",
11166	first, base);
11167	else if (third == 0)
11168	xmlGenericError(xmlGenericErrorContext,
11169	"PP: lookup '%c%c' found at %d\n",
11170	first, next, base);
11171	else
11172	xmlGenericError(xmlGenericErrorContext,
11173	"PP: lookup '%c%c%c' found at %d\n",
11174	first, next, third, base);
11175	#endif
11176	return(base - (in->cur - in->base));
11177	}
11178	}
11179	ctxt->checkIndex = base;
11180	#ifdef DEBUG_PUSH
11181	if (next == 0)
11182	xmlGenericError(xmlGenericErrorContext,
11183	"PP: lookup '%c' failed\n", first);
11184	else if (third == 0)
11185	xmlGenericError(xmlGenericErrorContext,
11186	"PP: lookup '%c%c' failed\n", first, next);
11187	else
11188	xmlGenericError(xmlGenericErrorContext,
11189	"PP: lookup '%c%c%c' failed\n", first, next, third);
11190	#endif
11191	return(-1);
11192	}
11193
11194	/**
11195	* xmlParseGetLasts:
11196	* @ctxt: an XML parser context
11197	* @lastlt: pointer to store the last '<' from the input
11198	* @lastgt: pointer to store the last '>' from the input
11199	*
11200	* Lookup the last < and > in the current chunk
11201	*/
11202	static void
11203	xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt,
11204	const xmlChar **lastgt) {
11205	const xmlChar *tmp;
11206
11207	if ((ctxt == NULL) \|\| (lastlt == NULL) \|\| (lastgt == NULL)) {
11208	xmlGenericError(xmlGenericErrorContext,
11209	"Internal error: xmlParseGetLasts\n");
11210	return;
11211	}
11212	if ((ctxt->progressive != 0) && (ctxt->inputNr == 1)) {
11213	tmp = ctxt->input->end;
11214	tmp--;
11215	while ((tmp >= ctxt->input->base) && (*tmp != '<')) tmp--;
11216	if (tmp < ctxt->input->base) {
11217	*lastlt = NULL;
11218	*lastgt = NULL;
11219	} else {
11220	*lastlt = tmp;
11221	tmp++;
11222	while ((tmp < ctxt->input->end) && (*tmp != '>')) {
11223	if (*tmp == '\'') {
11224	tmp++;
11225	while ((tmp < ctxt->input->end) && (*tmp != '\'')) tmp++;
11226	if (tmp < ctxt->input->end) tmp++;
11227	} else if (*tmp == '"') {
11228	tmp++;
11229	while ((tmp < ctxt->input->end) && (*tmp != '"')) tmp++;
11230	if (tmp < ctxt->input->end) tmp++;
11231	} else
11232	tmp++;
11233	}
11234	if (tmp < ctxt->input->end)
11235	*lastgt = tmp;
11236	else {
11237	tmp = *lastlt;
11238	tmp--;
11239	while ((tmp >= ctxt->input->base) && (*tmp != '>')) tmp--;
11240	if (tmp >= ctxt->input->base)
11241	*lastgt = tmp;
11242	else
11243	*lastgt = NULL;
11244	}
11245	}
11246	} else {
11247	*lastlt = NULL;
11248	*lastgt = NULL;
11249	}
11250	}
11251	/**
11252	* xmlCheckCdataPush:
11253	* @cur: pointer to the block of characters
11254	* @len: length of the block in bytes
11255	* @complete: 1 if complete CDATA block is passed in, 0 if partial block
11256	*
11257	* Check that the block of characters is okay as SCdata content [20]
11258	*
11259	* Returns the number of bytes to pass if okay, a negative index where an
11260	* UTF-8 error occured otherwise
11261	*/
11262	static int
11263	xmlCheckCdataPush(const xmlChar *utf, int len, int complete) {
11264	int ix;
11265	unsigned char c;
11266	int codepoint;
11267
11268	if ((utf == NULL) \|\| (len <= 0))
11269	return(0);
11270
11271	for (ix = 0; ix < len;) { /* string is 0-terminated */
11272	c = utf[ix];
11273	if ((c & 0x80) == 0x00) { /* 1-byte code, starts with 10 */
11274	if (c >= 0x20)
11275	ix++;
11276	else if ((c == 0xA) \|\| (c == 0xD) \|\| (c == 0x9))
11277	ix++;
11278	else
11279	return(-ix);
11280	} else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */
11281	if (ix + 2 > len) return(complete ? -ix : ix);
11282	if ((utf[ix+1] & 0xc0 ) != 0x80)
11283	return(-ix);
11284	codepoint = (utf[ix] & 0x1f) << 6;
11285	codepoint \|= utf[ix+1] & 0x3f;
11286	if (!xmlIsCharQ(codepoint))
11287	return(-ix);
11288	ix += 2;
11289	} else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */
11290	if (ix + 3 > len) return(complete ? -ix : ix);
11291	if (((utf[ix+1] & 0xc0) != 0x80) \|\|
11292	((utf[ix+2] & 0xc0) != 0x80))
11293	return(-ix);
11294	codepoint = (utf[ix] & 0xf) << 12;
11295	codepoint \|= (utf[ix+1] & 0x3f) << 6;
11296	codepoint \|= utf[ix+2] & 0x3f;
11297	if (!xmlIsCharQ(codepoint))
11298	return(-ix);
11299	ix += 3;
11300	} else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */
11301	if (ix + 4 > len) return(complete ? -ix : ix);
11302	if (((utf[ix+1] & 0xc0) != 0x80) \|\|
11303	((utf[ix+2] & 0xc0) != 0x80) \|\|
11304	((utf[ix+3] & 0xc0) != 0x80))
11305	return(-ix);
11306	codepoint = (utf[ix] & 0x7) << 18;
11307	codepoint \|= (utf[ix+1] & 0x3f) << 12;
11308	codepoint \|= (utf[ix+2] & 0x3f) << 6;
11309	codepoint \|= utf[ix+3] & 0x3f;
11310	if (!xmlIsCharQ(codepoint))
11311	return(-ix);
11312	ix += 4;
11313	} else /* unknown encoding */
11314	return(-ix);
11315	}
11316	return(ix);
11317	}
11318
11319	/**
11320	* xmlParseTryOrFinish:
11321	* @ctxt: an XML parser context
11322	* @terminate: last chunk indicator
11323	*
11324	* Try to progress on parsing
11325	*
11326	* Returns zero if no parsing was possible
11327	*/
11328	static int
11329	xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) {
11330	int ret = 0;
11331	int avail, tlen;
11332	xmlChar cur, next;
11333	const xmlChar lastlt, lastgt;
11334
11335	if (ctxt->input == NULL)
11336	return(0);
11337
11338	#ifdef DEBUG_PUSH
11339	switch (ctxt->instate) {
11340	case XML_PARSER_EOF:
11341	xmlGenericError(xmlGenericErrorContext,
11342	"PP: try EOF\n"); break;
11343	case XML_PARSER_START:
11344	xmlGenericError(xmlGenericErrorContext,
11345	"PP: try START\n"); break;
11346	case XML_PARSER_MISC:
11347	xmlGenericError(xmlGenericErrorContext,
11348	"PP: try MISC\n");break;
11349	case XML_PARSER_COMMENT:
11350	xmlGenericError(xmlGenericErrorContext,
11351	"PP: try COMMENT\n");break;
11352	case XML_PARSER_PROLOG:
11353	xmlGenericError(xmlGenericErrorContext,
11354	"PP: try PROLOG\n");break;
11355	case XML_PARSER_START_TAG:
11356	xmlGenericError(xmlGenericErrorContext,
11357	"PP: try START_TAG\n");break;
11358	case XML_PARSER_CONTENT:
11359	xmlGenericError(xmlGenericErrorContext,
11360	"PP: try CONTENT\n");break;
11361	case XML_PARSER_CDATA_SECTION:
11362	xmlGenericError(xmlGenericErrorContext,
11363	"PP: try CDATA_SECTION\n");break;
11364	case XML_PARSER_END_TAG:
11365	xmlGenericError(xmlGenericErrorContext,
11366	"PP: try END_TAG\n");break;
11367	case XML_PARSER_ENTITY_DECL:
11368	xmlGenericError(xmlGenericErrorContext,
11369	"PP: try ENTITY_DECL\n");break;
11370	case XML_PARSER_ENTITY_VALUE:
11371	xmlGenericError(xmlGenericErrorContext,
11372	"PP: try ENTITY_VALUE\n");break;
11373	case XML_PARSER_ATTRIBUTE_VALUE:
11374	xmlGenericError(xmlGenericErrorContext,
11375	"PP: try ATTRIBUTE_VALUE\n");break;
11376	case XML_PARSER_DTD:
11377	xmlGenericError(xmlGenericErrorContext,
11378	"PP: try DTD\n");break;
11379	case XML_PARSER_EPILOG:
11380	xmlGenericError(xmlGenericErrorContext,
11381	"PP: try EPILOG\n");break;
11382	case XML_PARSER_PI:
11383	xmlGenericError(xmlGenericErrorContext,
11384	"PP: try PI\n");break;
11385	case XML_PARSER_IGNORE:
11386	xmlGenericError(xmlGenericErrorContext,
11387	"PP: try IGNORE\n");break;
11388	}
11389	#endif
11390
11391	if ((ctxt->input != NULL) &&
11392	(ctxt->input->cur - ctxt->input->base > 4096)) {
11393	xmlSHRINK(ctxt);
11394	ctxt->checkIndex = 0;
11395	}
11396	xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11397
11398	while (ctxt->instate != XML_PARSER_EOF) {
11399	if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
11400	return(0);
11401
11402
11403	/*
11404	* Pop-up of finished entities.
11405	*/
11406	while ((RAW == 0) && (ctxt->inputNr > 1))
11407	xmlPopInput(ctxt);
11408
11409	if (ctxt->input == NULL) break;
11410	if (ctxt->input->buf == NULL)
11411	avail = ctxt->input->length -
11412	(ctxt->input->cur - ctxt->input->base);
11413	else {
11414	/*
11415	* If we are operating on converted input, try to flush
11416	* remainng chars to avoid them stalling in the non-converted
11417	* buffer. But do not do this in document start where
11418	* encoding="..." may not have been read and we work on a
11419	* guessed encoding.
11420	*/
11421	if ((ctxt->instate != XML_PARSER_START) &&
11422	(ctxt->input->buf->raw != NULL) &&
11423	(xmlBufIsEmpty(ctxt->input->buf->raw) == 0)) {
11424	size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer,
11425	ctxt->input);
11426	size_t current = ctxt->input->cur - ctxt->input->base;
11427
11428	xmlParserInputBufferPush(ctxt->input->buf, 0, "");
11429	xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input,
11430	base, current);
11431	}
11432	avail = xmlBufUse(ctxt->input->buf->buffer) -
11433	(ctxt->input->cur - ctxt->input->base);
11434	}
11435	if (avail < 1)
11436	goto done;
11437	switch (ctxt->instate) {
11438	case XML_PARSER_EOF:
11439	/*
11440	* Document parsing is done !
11441	*/
11442	goto done;
11443	case XML_PARSER_START:
11444	if (ctxt->charset == XML_CHAR_ENCODING_NONE) {
11445	xmlChar start[4];
11446	xmlCharEncoding enc;
11447
11448	/*
11449	* Very first chars read from the document flow.
11450	*/
11451	if (avail < 4)
11452	goto done;
11453
11454	/*
11455	* Get the 4 first bytes and decode the charset
11456	* if enc != XML_CHAR_ENCODING_NONE
11457	* plug some encoding conversion routines,
11458	* else xmlSwitchEncoding will set to (default)
11459	* UTF8.
11460	*/
11461	start[0] = RAW;
11462	start[1] = NXT(1);
11463	start[2] = NXT(2);
11464	start[3] = NXT(3);
11465	enc = xmlDetectCharEncoding(start, 4);
11466	xmlSwitchEncoding(ctxt, enc);
11467	break;
11468	}
11469
11470	if (avail < 2)
11471	goto done;
11472	cur = ctxt->input->cur[0];
11473	next = ctxt->input->cur[1];
11474	if (cur == 0) {
11475	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11476	ctxt->sax->setDocumentLocator(ctxt->userData,
11477	&xmlDefaultSAXLocator);
11478	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
11479	xmlHaltParser(ctxt);
11480	#ifdef DEBUG_PUSH
11481	xmlGenericError(xmlGenericErrorContext,
11482	"PP: entering EOF\n");
11483	#endif
11484	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11485	ctxt->sax->endDocument(ctxt->userData);
11486	goto done;
11487	}
11488	if ((cur == '<') && (next == '?')) {
11489	/* PI or XML decl */
11490	if (avail < 5) return(ret);
11491	if ((!terminate) &&
11492	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11493	return(ret);
11494	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11495	ctxt->sax->setDocumentLocator(ctxt->userData,
11496	&xmlDefaultSAXLocator);
11497	if ((ctxt->input->cur[2] == 'x') &&
11498	(ctxt->input->cur[3] == 'm') &&
11499	(ctxt->input->cur[4] == 'l') &&
11500	(IS_BLANK_CH(ctxt->input->cur[5]))) {
11501	ret += 5;
11502	#ifdef DEBUG_PUSH
11503	xmlGenericError(xmlGenericErrorContext,
11504	"PP: Parsing XML Decl\n");
11505	#endif
11506	xmlParseXMLDecl(ctxt);
11507	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
11508	/*
11509	* The XML REC instructs us to stop parsing right
11510	* here
11511	*/
11512	xmlHaltParser(ctxt);
11513	return(0);
11514	}
11515	ctxt->standalone = ctxt->input->standalone;
11516	if ((ctxt->encoding == NULL) &&
11517	(ctxt->input->encoding != NULL))
11518	ctxt->encoding = xmlStrdup(ctxt->input->encoding);
11519	if ((ctxt->sax) && (ctxt->sax->startDocument) &&
11520	(!ctxt->disableSAX))
11521	ctxt->sax->startDocument(ctxt->userData);
11522	ctxt->instate = XML_PARSER_MISC;
11523	#ifdef DEBUG_PUSH
11524	xmlGenericError(xmlGenericErrorContext,
11525	"PP: entering MISC\n");
11526	#endif
11527	} else {
11528	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
11529	if ((ctxt->sax) && (ctxt->sax->startDocument) &&
11530	(!ctxt->disableSAX))
11531	ctxt->sax->startDocument(ctxt->userData);
11532	ctxt->instate = XML_PARSER_MISC;
11533	#ifdef DEBUG_PUSH
11534	xmlGenericError(xmlGenericErrorContext,
11535	"PP: entering MISC\n");
11536	#endif
11537	}
11538	} else {
11539	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11540	ctxt->sax->setDocumentLocator(ctxt->userData,
11541	&xmlDefaultSAXLocator);
11542	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
11543	if (ctxt->version == NULL) {
11544	xmlErrMemory(ctxt, NULL);
11545	break;
11546	}
11547	if ((ctxt->sax) && (ctxt->sax->startDocument) &&
11548	(!ctxt->disableSAX))
11549	ctxt->sax->startDocument(ctxt->userData);
11550	ctxt->instate = XML_PARSER_MISC;
11551	#ifdef DEBUG_PUSH
11552	xmlGenericError(xmlGenericErrorContext,
11553	"PP: entering MISC\n");
11554	#endif
11555	}
11556	break;
11557	case XML_PARSER_START_TAG: {
11558	const xmlChar *name;
11559	const xmlChar *prefix = NULL;
11560	const xmlChar *URI = NULL;
11561	int nsNr = ctxt->nsNr;
11562
11563	if ((avail < 2) && (ctxt->inputNr == 1))
11564	goto done;
11565	cur = ctxt->input->cur[0];
11566	if (cur != '<') {
11567	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
11568	xmlHaltParser(ctxt);
11569	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11570	ctxt->sax->endDocument(ctxt->userData);
11571	goto done;
11572	}
11573	if (!terminate) {
11574	if (ctxt->progressive) {
11575	/* > can be found unescaped in attribute values */
11576	if ((lastgt == NULL) \|\| (ctxt->input->cur >= lastgt))
11577	goto done;
11578	} else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
11579	goto done;
11580	}
11581	}
11582	if (ctxt->spaceNr == 0)
11583	spacePush(ctxt, -1);
11584	else if (*ctxt->space == -2)
11585	spacePush(ctxt, -1);
11586	else
11587	spacePush(ctxt, *ctxt->space);
11588	#ifdef LIBXML_SAX1_ENABLED
11589	if (ctxt->sax2)
11590	#endif /* LIBXML_SAX1_ENABLED */
11591	name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
11592	#ifdef LIBXML_SAX1_ENABLED
11593	else
11594	name = xmlParseStartTag(ctxt);
11595	#endif /* LIBXML_SAX1_ENABLED */
11596	if (ctxt->instate == XML_PARSER_EOF)
11597	goto done;
11598	if (name == NULL) {
11599	spacePop(ctxt);
11600	xmlHaltParser(ctxt);
11601	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11602	ctxt->sax->endDocument(ctxt->userData);
11603	goto done;
11604	}
11605	#ifdef LIBXML_VALID_ENABLED
11606	/*
11607	* [ VC: Root Element Type ]
11608	* The Name in the document type declaration must match
11609	* the element type of the root element.
11610	*/
11611	if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
11612	ctxt->node && (ctxt->node == ctxt->myDoc->children))
11613	ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
11614	#endif /* LIBXML_VALID_ENABLED */
11615
11616	/*
11617	* Check for an Empty Element.
11618	*/
11619	if ((RAW == '/') && (NXT(1) == '>')) {
11620	SKIP(2);
11621
11622	if (ctxt->sax2) {
11623	if ((ctxt->sax != NULL) &&
11624	(ctxt->sax->endElementNs != NULL) &&
11625	(!ctxt->disableSAX))
11626	ctxt->sax->endElementNs(ctxt->userData, name,
11627	prefix, URI);
11628	if (ctxt->nsNr - nsNr > 0)
11629	nsPop(ctxt, ctxt->nsNr - nsNr);
11630	#ifdef LIBXML_SAX1_ENABLED
11631	} else {
11632	if ((ctxt->sax != NULL) &&
11633	(ctxt->sax->endElement != NULL) &&
11634	(!ctxt->disableSAX))
11635	ctxt->sax->endElement(ctxt->userData, name);
11636	#endif /* LIBXML_SAX1_ENABLED */
11637	}
11638	if (ctxt->instate == XML_PARSER_EOF)
11639	goto done;
11640	spacePop(ctxt);
11641	if (ctxt->nameNr == 0) {
11642	ctxt->instate = XML_PARSER_EPILOG;
11643	} else {
11644	ctxt->instate = XML_PARSER_CONTENT;
11645	}
11646	ctxt->progressive = 1;
11647	break;
11648	}
11649	if (RAW == '>') {
11650	NEXT;
11651	} else {
11652	xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED,
11653	"Couldn't find end of Start Tag %s\n",
11654	name);
11655	nodePop(ctxt);
11656	spacePop(ctxt);
11657	}
11658	if (ctxt->sax2)
11659	nameNsPush(ctxt, name, prefix, URI, ctxt->nsNr - nsNr);
11660	#ifdef LIBXML_SAX1_ENABLED
11661	else
11662	namePush(ctxt, name);
11663	#endif /* LIBXML_SAX1_ENABLED */
11664
11665	ctxt->instate = XML_PARSER_CONTENT;
11666	ctxt->progressive = 1;
11667	break;
11668	}
11669	case XML_PARSER_CONTENT: {
11670	const xmlChar *test;
11671	unsigned int cons;
11672	if ((avail < 2) && (ctxt->inputNr == 1))
11673	goto done;
11674	cur = ctxt->input->cur[0];
11675	next = ctxt->input->cur[1];
11676
11677	test = CUR_PTR;
11678	cons = ctxt->input->consumed;
11679	if ((cur == '<') && (next == '/')) {
11680	ctxt->instate = XML_PARSER_END_TAG;
11681	break;
11682	} else if ((cur == '<') && (next == '?')) {
11683	if ((!terminate) &&
11684	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11685	ctxt->progressive = XML_PARSER_PI;
11686	goto done;
11687	}
11688	xmlParsePI(ctxt);
11689	ctxt->instate = XML_PARSER_CONTENT;
11690	ctxt->progressive = 1;
11691	} else if ((cur == '<') && (next != '!')) {
11692	ctxt->instate = XML_PARSER_START_TAG;
11693	break;
11694	} else if ((cur == '<') && (next == '!') &&
11695	(ctxt->input->cur[2] == '-') &&
11696	(ctxt->input->cur[3] == '-')) {
11697	int term;
11698
11699	if (avail < 4)
11700	goto done;
11701	ctxt->input->cur += 4;
11702	term = xmlParseLookupSequence(ctxt, '-', '-', '>');
11703	ctxt->input->cur -= 4;
11704	if ((!terminate) && (term < 0)) {
11705	ctxt->progressive = XML_PARSER_COMMENT;
11706	goto done;
11707	}
11708	xmlParseComment(ctxt);
11709	ctxt->instate = XML_PARSER_CONTENT;
11710	ctxt->progressive = 1;
11711	} else if ((cur == '<') && (ctxt->input->cur[1] == '!') &&
11712	(ctxt->input->cur[2] == '[') &&
11713	(ctxt->input->cur[3] == 'C') &&
11714	(ctxt->input->cur[4] == 'D') &&
11715	(ctxt->input->cur[5] == 'A') &&
11716	(ctxt->input->cur[6] == 'T') &&
11717	(ctxt->input->cur[7] == 'A') &&
11718	(ctxt->input->cur[8] == '[')) {
11719	SKIP(9);
11720	ctxt->instate = XML_PARSER_CDATA_SECTION;
11721	break;
11722	} else if ((cur == '<') && (next == '!') &&
11723	(avail < 9)) {
11724	goto done;
11725	} else if (cur == '&') {
11726	if ((!terminate) &&
11727	(xmlParseLookupSequence(ctxt, ';', 0, 0) < 0))
11728	goto done;
11729	xmlParseReference(ctxt);
11730	} else {
11731	/* TODO Avoid the extra copy, handle directly !!! */
11732	/*
11733	* Goal of the following test is:
11734	* - minimize calls to the SAX 'character' callback
11735	* when they are mergeable
11736	* - handle an problem for isBlank when we only parse
11737	* a sequence of blank chars and the next one is
11738	* not available to check against '<' presence.
11739	* - tries to homogenize the differences in SAX
11740	* callbacks between the push and pull versions
11741	* of the parser.
11742	*/
11743	if ((ctxt->inputNr == 1) &&
11744	(avail < XML_PARSER_BIG_BUFFER_SIZE)) {
11745	if (!terminate) {
11746	if (ctxt->progressive) {
11747	if ((lastlt == NULL) \|\|
11748	(ctxt->input->cur > lastlt))
11749	goto done;
11750	} else if (xmlParseLookupSequence(ctxt,
11751	'<', 0, 0) < 0) {
11752	goto done;
11753	}
11754	}
11755	}
11756	ctxt->checkIndex = 0;
11757	xmlParseCharData(ctxt, 0);
11758	}
11759	/*
11760	* Pop-up of finished entities.
11761	*/
11762	while ((RAW == 0) && (ctxt->inputNr > 1))
11763	xmlPopInput(ctxt);
11764	if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
11765	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
11766	"detected an error in element content\n");
11767	xmlHaltParser(ctxt);
11768	break;
11769	}
11770	break;
11771	}
11772	case XML_PARSER_END_TAG:
11773	if (avail < 2)
11774	goto done;
11775	if (!terminate) {
11776	if (ctxt->progressive) {
11777	/* > can be found unescaped in attribute values */
11778	if ((lastgt == NULL) \|\| (ctxt->input->cur >= lastgt))
11779	goto done;
11780	} else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
11781	goto done;
11782	}
11783	}
11784	if (ctxt->sax2) {
11785	xmlParseEndTag2(ctxt,
11786	(void ) ctxt->pushTab[ctxt->nameNr 3 - 3],
11787	(void ) ctxt->pushTab[ctxt->nameNr 3 - 2], 0,
11788	(int) (long) ctxt->pushTab[ctxt->nameNr * 3 - 1], 0);
11789	nameNsPop(ctxt);
11790	}
11791	#ifdef LIBXML_SAX1_ENABLED
11792	else
11793	xmlParseEndTag1(ctxt, 0);
11794	#endif /* LIBXML_SAX1_ENABLED */
11795	if (ctxt->instate == XML_PARSER_EOF) {
11796	/* Nothing */
11797	} else if (ctxt->nameNr == 0) {
11798	ctxt->instate = XML_PARSER_EPILOG;
11799	} else {
11800	ctxt->instate = XML_PARSER_CONTENT;
11801	}
11802	break;
11803	case XML_PARSER_CDATA_SECTION: {
11804	/*
11805	* The Push mode need to have the SAX callback for
11806	* cdataBlock merge back contiguous callbacks.
11807	*/
11808	int base;
11809
11810	base = xmlParseLookupSequence(ctxt, ']', ']', '>');
11811	if (base < 0) {
11812	if (avail >= XML_PARSER_BIG_BUFFER_SIZE + 2) {
11813	int tmp;
11814
11815	tmp = xmlCheckCdataPush(ctxt->input->cur,
11816	XML_PARSER_BIG_BUFFER_SIZE, 0);
11817	if (tmp < 0) {
11818	tmp = -tmp;
11819	ctxt->input->cur += tmp;
11820	goto encoding_error;
11821	}
11822	if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
11823	if (ctxt->sax->cdataBlock != NULL)
11824	ctxt->sax->cdataBlock(ctxt->userData,
11825	ctxt->input->cur, tmp);
11826	else if (ctxt->sax->characters != NULL)
11827	ctxt->sax->characters(ctxt->userData,
11828	ctxt->input->cur, tmp);
11829	}
11830	if (ctxt->instate == XML_PARSER_EOF)
11831	goto done;
11832	SKIPL(tmp);
11833	ctxt->checkIndex = 0;
11834	}
11835	goto done;
11836	} else {
11837	int tmp;
11838
11839	tmp = xmlCheckCdataPush(ctxt->input->cur, base, 1);
11840	if ((tmp < 0) \|\| (tmp != base)) {
11841	tmp = -tmp;
11842	ctxt->input->cur += tmp;
11843	goto encoding_error;
11844	}
11845	if ((ctxt->sax != NULL) && (base == 0) &&
11846	(ctxt->sax->cdataBlock != NULL) &&
11847	(!ctxt->disableSAX)) {
11848	/*
11849	* Special case to provide identical behaviour
11850	* between pull and push parsers on enpty CDATA
11851	* sections
11852	*/
11853	if ((ctxt->input->cur - ctxt->input->base >= 9) &&
11854	(!strncmp((const char *)&ctxt->input->cur[-9],
11855	"<![CDATA[", 9)))
11856	ctxt->sax->cdataBlock(ctxt->userData,
11857	BAD_CAST "", 0);
11858	} else if ((ctxt->sax != NULL) && (base > 0) &&
11859	(!ctxt->disableSAX)) {
11860	if (ctxt->sax->cdataBlock != NULL)
11861	ctxt->sax->cdataBlock(ctxt->userData,
11862	ctxt->input->cur, base);
11863	else if (ctxt->sax->characters != NULL)
11864	ctxt->sax->characters(ctxt->userData,
11865	ctxt->input->cur, base);
11866	}
11867	if (ctxt->instate == XML_PARSER_EOF)
11868	goto done;
11869	SKIPL(base + 3);
11870	ctxt->checkIndex = 0;
11871	ctxt->instate = XML_PARSER_CONTENT;
11872	#ifdef DEBUG_PUSH
11873	xmlGenericError(xmlGenericErrorContext,
11874	"PP: entering CONTENT\n");
11875	#endif
11876	}
11877	break;
11878	}
11879	case XML_PARSER_MISC:
11880	SKIP_BLANKS;
11881	if (ctxt->input->buf == NULL)
11882	avail = ctxt->input->length -
11883	(ctxt->input->cur - ctxt->input->base);
11884	else
11885	avail = xmlBufUse(ctxt->input->buf->buffer) -
11886	(ctxt->input->cur - ctxt->input->base);
11887	if (avail < 2)
11888	goto done;
11889	cur = ctxt->input->cur[0];
11890	next = ctxt->input->cur[1];
11891	if ((cur == '<') && (next == '?')) {
11892	if ((!terminate) &&
11893	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11894	ctxt->progressive = XML_PARSER_PI;
11895	goto done;
11896	}
11897	#ifdef DEBUG_PUSH
11898	xmlGenericError(xmlGenericErrorContext,
11899	"PP: Parsing PI\n");
11900	#endif
11901	xmlParsePI(ctxt);
11902	if (ctxt->instate == XML_PARSER_EOF)
11903	goto done;
11904	ctxt->instate = XML_PARSER_MISC;
11905	ctxt->progressive = 1;
11906	ctxt->checkIndex = 0;
11907	} else if ((cur == '<') && (next == '!') &&
11908	(ctxt->input->cur[2] == '-') &&
11909	(ctxt->input->cur[3] == '-')) {
11910	if ((!terminate) &&
11911	(xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) {
11912	ctxt->progressive = XML_PARSER_COMMENT;
11913	goto done;
11914	}
11915	#ifdef DEBUG_PUSH
11916	xmlGenericError(xmlGenericErrorContext,
11917	"PP: Parsing Comment\n");
11918	#endif
11919	xmlParseComment(ctxt);
11920	if (ctxt->instate == XML_PARSER_EOF)
11921	goto done;
11922	ctxt->instate = XML_PARSER_MISC;
11923	ctxt->progressive = 1;
11924	ctxt->checkIndex = 0;
11925	} else if ((cur == '<') && (next == '!') &&
11926	(ctxt->input->cur[2] == 'D') &&
11927	(ctxt->input->cur[3] == 'O') &&
11928	(ctxt->input->cur[4] == 'C') &&
11929	(ctxt->input->cur[5] == 'T') &&
11930	(ctxt->input->cur[6] == 'Y') &&
11931	(ctxt->input->cur[7] == 'P') &&
11932	(ctxt->input->cur[8] == 'E')) {
11933	if ((!terminate) &&
11934	(xmlParseLookupSequence(ctxt, '>', 0, 0) < 0)) {
11935	ctxt->progressive = XML_PARSER_DTD;
11936	goto done;
11937	}
11938	#ifdef DEBUG_PUSH
11939	xmlGenericError(xmlGenericErrorContext,
11940	"PP: Parsing internal subset\n");
11941	#endif
11942	ctxt->inSubset = 1;
11943	ctxt->progressive = 0;
11944	ctxt->checkIndex = 0;
11945	xmlParseDocTypeDecl(ctxt);
11946	if (ctxt->instate == XML_PARSER_EOF)
11947	goto done;
11948	if (RAW == '[') {
11949	ctxt->instate = XML_PARSER_DTD;
11950	#ifdef DEBUG_PUSH
11951	xmlGenericError(xmlGenericErrorContext,
11952	"PP: entering DTD\n");
11953	#endif
11954	} else {
11955	/*
11956	* Create and update the external subset.
11957	*/
11958	ctxt->inSubset = 2;
11959	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
11960	(ctxt->sax->externalSubset != NULL))
11961	ctxt->sax->externalSubset(ctxt->userData,
11962	ctxt->intSubName, ctxt->extSubSystem,
11963	ctxt->extSubURI);
11964	ctxt->inSubset = 0;
11965	xmlCleanSpecialAttr(ctxt);
11966	ctxt->instate = XML_PARSER_PROLOG;
11967	#ifdef DEBUG_PUSH
11968	xmlGenericError(xmlGenericErrorContext,
11969	"PP: entering PROLOG\n");
11970	#endif
11971	}
11972	} else if ((cur == '<') && (next == '!') &&
11973	(avail < 9)) {
11974	goto done;
11975	} else {
11976	ctxt->instate = XML_PARSER_START_TAG;
11977	ctxt->progressive = XML_PARSER_START_TAG;
11978	xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11979	#ifdef DEBUG_PUSH
11980	xmlGenericError(xmlGenericErrorContext,
11981	"PP: entering START_TAG\n");
11982	#endif
11983	}
11984	break;
11985	case XML_PARSER_PROLOG:
11986	SKIP_BLANKS;
11987	if (ctxt->input->buf == NULL)
11988	avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
11989	else
11990	avail = xmlBufUse(ctxt->input->buf->buffer) -
11991	(ctxt->input->cur - ctxt->input->base);
11992	if (avail < 2)
11993	goto done;
11994	cur = ctxt->input->cur[0];
11995	next = ctxt->input->cur[1];
11996	if ((cur == '<') && (next == '?')) {
11997	if ((!terminate) &&
11998	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11999	ctxt->progressive = XML_PARSER_PI;
12000	goto done;
12001	}
12002	#ifdef DEBUG_PUSH
12003	xmlGenericError(xmlGenericErrorContext,
12004	"PP: Parsing PI\n");
12005	#endif
12006	xmlParsePI(ctxt);
12007	if (ctxt->instate == XML_PARSER_EOF)
12008	goto done;
12009	ctxt->instate = XML_PARSER_PROLOG;
12010	ctxt->progressive = 1;
12011	} else if ((cur == '<') && (next == '!') &&
12012	(ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
12013	if ((!terminate) &&
12014	(xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) {
12015	ctxt->progressive = XML_PARSER_COMMENT;
12016	goto done;
12017	}
12018	#ifdef DEBUG_PUSH
12019	xmlGenericError(xmlGenericErrorContext,
12020	"PP: Parsing Comment\n");
12021	#endif
12022	xmlParseComment(ctxt);
12023	if (ctxt->instate == XML_PARSER_EOF)
12024	goto done;
12025	ctxt->instate = XML_PARSER_PROLOG;
12026	ctxt->progressive = 1;
12027	} else if ((cur == '<') && (next == '!') &&
12028	(avail < 4)) {
12029	goto done;
12030	} else {
12031	ctxt->instate = XML_PARSER_START_TAG;
12032	if (ctxt->progressive == 0)
12033	ctxt->progressive = XML_PARSER_START_TAG;
12034	xmlParseGetLasts(ctxt, &lastlt, &lastgt);
12035	#ifdef DEBUG_PUSH
12036	xmlGenericError(xmlGenericErrorContext,
12037	"PP: entering START_TAG\n");
12038	#endif
12039	}
12040	break;
12041	case XML_PARSER_EPILOG:
12042	SKIP_BLANKS;
12043	if (ctxt->input->buf == NULL)
12044	avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
12045	else
12046	avail = xmlBufUse(ctxt->input->buf->buffer) -
12047	(ctxt->input->cur - ctxt->input->base);
12048	if (avail < 2)
12049	goto done;
12050	cur = ctxt->input->cur[0];
12051	next = ctxt->input->cur[1];
12052	if ((cur == '<') && (next == '?')) {
12053	if ((!terminate) &&
12054	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
12055	ctxt->progressive = XML_PARSER_PI;
12056	goto done;
12057	}
12058	#ifdef DEBUG_PUSH
12059	xmlGenericError(xmlGenericErrorContext,
12060	"PP: Parsing PI\n");
12061	#endif
12062	xmlParsePI(ctxt);
12063	if (ctxt->instate == XML_PARSER_EOF)
12064	goto done;
12065	ctxt->instate = XML_PARSER_EPILOG;
12066	ctxt->progressive = 1;
12067	} else if ((cur == '<') && (next == '!') &&
12068	(ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
12069	if ((!terminate) &&
12070	(xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) {
12071	ctxt->progressive = XML_PARSER_COMMENT;
12072	goto done;
12073	}
12074	#ifdef DEBUG_PUSH
12075	xmlGenericError(xmlGenericErrorContext,
12076	"PP: Parsing Comment\n");
12077	#endif
12078	xmlParseComment(ctxt);
12079	if (ctxt->instate == XML_PARSER_EOF)
12080	goto done;
12081	ctxt->instate = XML_PARSER_EPILOG;
12082	ctxt->progressive = 1;
12083	} else if ((cur == '<') && (next == '!') &&
12084	(avail < 4)) {
12085	goto done;
12086	} else {
12087	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
12088	xmlHaltParser(ctxt);
12089	#ifdef DEBUG_PUSH
12090	xmlGenericError(xmlGenericErrorContext,
12091	"PP: entering EOF\n");
12092	#endif
12093	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
12094	ctxt->sax->endDocument(ctxt->userData);
12095	goto done;
12096	}
12097	break;
12098	case XML_PARSER_DTD: {
12099	/*
12100	* Sorry but progressive parsing of the internal subset
12101	* is not expected to be supported. We first check that
12102	* the full content of the internal subset is available and
12103	* the parsing is launched only at that point.
12104	* Internal subset ends up with "']' S? '>'" in an unescaped
12105	* section and not in a ']]>' sequence which are conditional
12106	* sections (whoever argued to keep that crap in XML deserve
12107	* a place in hell !).
12108	*/
12109	int base, i;
12110	xmlChar *buf;
12111	xmlChar quote = 0;
12112	size_t use;
12113
12114	base = ctxt->input->cur - ctxt->input->base;
12115	if (base < 0) return(0);
12116	if (ctxt->checkIndex > base)
12117	base = ctxt->checkIndex;
12118	buf = xmlBufContent(ctxt->input->buf->buffer);
12119	use = xmlBufUse(ctxt->input->buf->buffer);
12120	for (;(unsigned int) base < use; base++) {
12121	if (quote != 0) {
12122	if (buf[base] == quote)
12123	quote = 0;
12124	continue;
12125	}
12126	if ((quote == 0) && (buf[base] == '<')) {
12127	int found = 0;
12128	/* special handling of comments */
12129	if (((unsigned int) base + 4 < use) &&
12130	(buf[base + 1] == '!') &&
12131	(buf[base + 2] == '-') &&
12132	(buf[base + 3] == '-')) {
12133	for (;(unsigned int) base + 3 < use; base++) {
12134	if ((buf[base] == '-') &&
12135	(buf[base + 1] == '-') &&
12136	(buf[base + 2] == '>')) {
12137	found = 1;
12138	base += 2;
12139	break;
12140	}
12141	}
12142	if (!found) {
12143	#if 0
12144	fprintf(stderr, "unfinished comment\n");
12145	#endif
12146	break; /* for */
12147	}
12148	continue;
12149	}
12150	}
12151	if (buf[base] == '"') {
12152	quote = '"';
12153	continue;
12154	}
12155	if (buf[base] == '\'') {
12156	quote = '\'';
12157	continue;
12158	}
12159	if (buf[base] == ']') {
12160	#if 0
12161	fprintf(stderr, "%c%c%c%c: ", buf[base],
12162	buf[base + 1], buf[base + 2], buf[base + 3]);
12163	#endif
12164	if ((unsigned int) base +1 >= use)
12165	break;
12166	if (buf[base + 1] == ']') {
12167	/* conditional crap, skip both ']' ! */
12168	base++;
12169	continue;
12170	}
12171	for (i = 1; (unsigned int) base + i < use; i++) {
12172	if (buf[base + i] == '>') {
12173	#if 0
12174	fprintf(stderr, "found\n");
12175	#endif
12176	goto found_end_int_subset;
12177	}
12178	if (!IS_BLANK_CH(buf[base + i])) {
12179	#if 0
12180	fprintf(stderr, "not found\n");
12181	#endif
12182	goto not_end_of_int_subset;
12183	}
12184	}
12185	#if 0
12186	fprintf(stderr, "end of stream\n");
12187	#endif
12188	break;
12189
12190	}
12191	not_end_of_int_subset:
12192	continue; /* for */
12193	}
12194	/*
12195	* We didn't found the end of the Internal subset
12196	*/
12197	if (quote == 0)
12198	ctxt->checkIndex = base;
12199	else
12200	ctxt->checkIndex = 0;
12201	#ifdef DEBUG_PUSH
12202	if (next == 0)
12203	xmlGenericError(xmlGenericErrorContext,
12204	"PP: lookup of int subset end filed\n");
12205	#endif
12206	goto done;
12207
12208	found_end_int_subset:
12209	ctxt->checkIndex = 0;
12210	xmlParseInternalSubset(ctxt);
12211	if (ctxt->instate == XML_PARSER_EOF)
12212	goto done;
12213	ctxt->inSubset = 2;
12214	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
12215	(ctxt->sax->externalSubset != NULL))
12216	ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
12217	ctxt->extSubSystem, ctxt->extSubURI);
12218	ctxt->inSubset = 0;
12219	xmlCleanSpecialAttr(ctxt);
12220	if (ctxt->instate == XML_PARSER_EOF)
12221	goto done;
12222	ctxt->instate = XML_PARSER_PROLOG;
12223	ctxt->checkIndex = 0;
12224	#ifdef DEBUG_PUSH
12225	xmlGenericError(xmlGenericErrorContext,
12226	"PP: entering PROLOG\n");
12227	#endif
12228	break;
12229	}
12230	case XML_PARSER_COMMENT:
12231	xmlGenericError(xmlGenericErrorContext,
12232	"PP: internal error, state == COMMENT\n");
12233	ctxt->instate = XML_PARSER_CONTENT;
12234	#ifdef DEBUG_PUSH
12235	xmlGenericError(xmlGenericErrorContext,
12236	"PP: entering CONTENT\n");
12237	#endif
12238	break;
12239	case XML_PARSER_IGNORE:
12240	xmlGenericError(xmlGenericErrorContext,
12241	"PP: internal error, state == IGNORE");
12242	ctxt->instate = XML_PARSER_DTD;
12243	#ifdef DEBUG_PUSH
12244	xmlGenericError(xmlGenericErrorContext,
12245	"PP: entering DTD\n");
12246	#endif
12247	break;
12248	case XML_PARSER_PI:
12249	xmlGenericError(xmlGenericErrorContext,
12250	"PP: internal error, state == PI\n");
12251	ctxt->instate = XML_PARSER_CONTENT;
12252	#ifdef DEBUG_PUSH
12253	xmlGenericError(xmlGenericErrorContext,
12254	"PP: entering CONTENT\n");
12255	#endif
12256	break;
12257	case XML_PARSER_ENTITY_DECL:
12258	xmlGenericError(xmlGenericErrorContext,
12259	"PP: internal error, state == ENTITY_DECL\n");
12260	ctxt->instate = XML_PARSER_DTD;
12261	#ifdef DEBUG_PUSH
12262	xmlGenericError(xmlGenericErrorContext,
12263	"PP: entering DTD\n");
12264	#endif
12265	break;
12266	case XML_PARSER_ENTITY_VALUE:
12267	xmlGenericError(xmlGenericErrorContext,
12268	"PP: internal error, state == ENTITY_VALUE\n");
12269	ctxt->instate = XML_PARSER_CONTENT;
12270	#ifdef DEBUG_PUSH
12271	xmlGenericError(xmlGenericErrorContext,
12272	"PP: entering DTD\n");
12273	#endif
12274	break;
12275	case XML_PARSER_ATTRIBUTE_VALUE:
12276	xmlGenericError(xmlGenericErrorContext,
12277	"PP: internal error, state == ATTRIBUTE_VALUE\n");
12278	ctxt->instate = XML_PARSER_START_TAG;
12279	#ifdef DEBUG_PUSH
12280	xmlGenericError(xmlGenericErrorContext,
12281	"PP: entering START_TAG\n");
12282	#endif
12283	break;
12284	case XML_PARSER_SYSTEM_LITERAL:
12285	xmlGenericError(xmlGenericErrorContext,
12286	"PP: internal error, state == SYSTEM_LITERAL\n");
12287	ctxt->instate = XML_PARSER_START_TAG;
12288	#ifdef DEBUG_PUSH
12289	xmlGenericError(xmlGenericErrorContext,
12290	"PP: entering START_TAG\n");
12291	#endif
12292	break;
12293	case XML_PARSER_PUBLIC_LITERAL:
12294	xmlGenericError(xmlGenericErrorContext,
12295	"PP: internal error, state == PUBLIC_LITERAL\n");
12296	ctxt->instate = XML_PARSER_START_TAG;
12297	#ifdef DEBUG_PUSH
12298	xmlGenericError(xmlGenericErrorContext,
12299	"PP: entering START_TAG\n");
12300	#endif
12301	break;
12302	}
12303	}
12304	done:
12305	#ifdef DEBUG_PUSH
12306	xmlGenericError(xmlGenericErrorContext, "PP: done %d\n", ret);
12307	#endif
12308	return(ret);
12309	encoding_error:
12310	{
12311	char buffer[150];
12312
12313	snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
12314	ctxt->input->cur[0], ctxt->input->cur[1],
12315	ctxt->input->cur[2], ctxt->input->cur[3]);
12316	__xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
12317	"Input is not proper UTF-8, indicate encoding !\n%s",
12318	BAD_CAST buffer, NULL);
12319	}
12320	return(0);
12321	}
12322
12323	/**
12324	* xmlParseCheckTransition:
12325	* @ctxt: an XML parser context
12326	* @chunk: a char array
12327	* @size: the size in byte of the chunk
12328	*
12329	* Check depending on the current parser state if the chunk given must be
12330	* processed immediately or one need more data to advance on parsing.
12331	*
12332	* Returns -1 in case of error, 0 if the push is not needed and 1 if needed
12333	*/
12334	static int
12335	xmlParseCheckTransition(xmlParserCtxtPtr ctxt, const char *chunk, int size) {
12336	if ((ctxt == NULL) \|\| (chunk == NULL) \|\| (size < 0))
12337	return(-1);
12338	if (ctxt->instate == XML_PARSER_START_TAG) {
12339	if (memchr(chunk, '>', size) != NULL)
12340	return(1);
12341	return(0);
12342	}
12343	if (ctxt->progressive == XML_PARSER_COMMENT) {
12344	if (memchr(chunk, '>', size) != NULL)
12345	return(1);
12346	return(0);
12347	}
12348	if (ctxt->instate == XML_PARSER_CDATA_SECTION) {
12349	if (memchr(chunk, '>', size) != NULL)
12350	return(1);
12351	return(0);
12352	}
12353	if (ctxt->progressive == XML_PARSER_PI) {
12354	if (memchr(chunk, '>', size) != NULL)
12355	return(1);
12356	return(0);
12357	}
12358	if (ctxt->instate == XML_PARSER_END_TAG) {
12359	if (memchr(chunk, '>', size) != NULL)
12360	return(1);
12361	return(0);
12362	}
12363	if ((ctxt->progressive == XML_PARSER_DTD) \|\|
12364	(ctxt->instate == XML_PARSER_DTD)) {
12365	if (memchr(chunk, '>', size) != NULL)
12366	return(1);
12367	return(0);
12368	}
12369	return(1);
12370	}
12371
12372	/**
12373	* xmlParseChunk:
12374	* @ctxt: an XML parser context
12375	* @chunk: an char array
12376	* @size: the size in byte of the chunk
12377	* @terminate: last chunk indicator
12378	*
12379	* Parse a Chunk of memory
12380	*
12381	* Returns zero if no error, the xmlParserErrors otherwise.
12382	*/
12383	int
12384	xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size,
12385	int terminate) {
12386	int end_in_lf = 0;
12387	int remain = 0;
12388	size_t old_avail = 0;
12389	size_t avail = 0;
12390
12391	if (ctxt == NULL)
12392	return(XML_ERR_INTERNAL_ERROR);
12393	if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
12394	return(ctxt->errNo);
12395	if (ctxt->instate == XML_PARSER_EOF)
12396	return(-1);
12397	if (ctxt->instate == XML_PARSER_START)
12398	xmlDetectSAX2(ctxt);
12399	if ((size > 0) && (chunk != NULL) && (!terminate) &&
12400	(chunk[size - 1] == '\r')) {
12401	end_in_lf = 1;
12402	size--;
12403	}
12404
12405	xmldecl_done:
12406
12407	if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
12408	(ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF)) {
12409	size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
12410	size_t cur = ctxt->input->cur - ctxt->input->base;
12411	int res;
12412
12413	old_avail = xmlBufUse(ctxt->input->buf->buffer);
12414	/*
12415	* Specific handling if we autodetected an encoding, we should not
12416	* push more than the first line ... which depend on the encoding
12417	* And only push the rest once the final encoding was detected
12418	*/
12419	if ((ctxt->instate == XML_PARSER_START) && (ctxt->input != NULL) &&
12420	(ctxt->input->buf != NULL) && (ctxt->input->buf->encoder != NULL)) {
12421	unsigned int len = 45;
12422
12423	if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12424	BAD_CAST "UTF-16")) \|\|
12425	(xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12426	BAD_CAST "UTF16")))
12427	len = 90;
12428	else if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12429	BAD_CAST "UCS-4")) \|\|
12430	(xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12431	BAD_CAST "UCS4")))
12432	len = 180;
12433
12434	if (ctxt->input->buf->rawconsumed < len)
12435	len -= ctxt->input->buf->rawconsumed;
12436
12437	/*
12438	* Change size for reading the initial declaration only
12439	* if size is greater than len. Otherwise, memmove in xmlBufferAdd
12440	* will blindly copy extra bytes from memory.
12441	*/
12442	if ((unsigned int) size > len) {
12443	remain = size - len;
12444	size = len;
12445	} else {
12446	remain = 0;
12447	}
12448	}
12449	res = xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
12450	if (res < 0) {
12451	ctxt->errNo = XML_PARSER_EOF;
12452	xmlHaltParser(ctxt);
12453	return (XML_PARSER_EOF);
12454	}
12455	xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
12456	#ifdef DEBUG_PUSH
12457	xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
12458	#endif
12459
12460	} else if (ctxt->instate != XML_PARSER_EOF) {
12461	if ((ctxt->input != NULL) && ctxt->input->buf != NULL) {
12462	xmlParserInputBufferPtr in = ctxt->input->buf;
12463	if ((in->encoder != NULL) && (in->buffer != NULL) &&
12464	(in->raw != NULL)) {
12465	int nbchars;
12466	size_t base = xmlBufGetInputBase(in->buffer, ctxt->input);
12467	size_t current = ctxt->input->cur - ctxt->input->base;
12468
12469	nbchars = xmlCharEncInput(in, terminate);
12470	if (nbchars < 0) {
12471	/* TODO 2.6.0 */
12472	xmlGenericError(xmlGenericErrorContext,
12473	"xmlParseChunk: encoder error\n");
12474	return(XML_ERR_INVALID_ENCODING);
12475	}
12476	xmlBufSetInputBaseCur(in->buffer, ctxt->input, base, current);
12477	}
12478	}
12479	}
12480	if (remain != 0) {
12481	xmlParseTryOrFinish(ctxt, 0);
12482	} else {
12483	if ((ctxt->input != NULL) && (ctxt->input->buf != NULL))
12484	avail = xmlBufUse(ctxt->input->buf->buffer);
12485	/*
12486	* Depending on the current state it may not be such
12487	* a good idea to try parsing if there is nothing in the chunk
12488	* which would be worth doing a parser state transition and we
12489	* need to wait for more data
12490	*/
12491	if ((terminate) \|\| (avail > XML_MAX_TEXT_LENGTH) \|\|
12492	(old_avail == 0) \|\| (avail == 0) \|\|
12493	(xmlParseCheckTransition(ctxt,
12494	(const char *)&ctxt->input->base[old_avail],
12495	avail - old_avail)))
12496	xmlParseTryOrFinish(ctxt, terminate);
12497	}
12498	if (ctxt->instate == XML_PARSER_EOF)
12499	return(ctxt->errNo);
12500
12501	if ((ctxt->input != NULL) &&
12502	(((ctxt->input->end - ctxt->input->cur) > XML_MAX_LOOKUP_LIMIT) \|\|
12503	((ctxt->input->cur - ctxt->input->base) > XML_MAX_LOOKUP_LIMIT)) &&
12504	((ctxt->options & XML_PARSE_HUGE) == 0)) {
12505	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "Huge input lookup");
12506	xmlHaltParser(ctxt);
12507	}
12508	if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
12509	return(ctxt->errNo);
12510
12511	if (remain != 0) {
12512	chunk += size;
12513	size = remain;
12514	remain = 0;
12515	goto xmldecl_done;
12516	}
12517	if ((end_in_lf == 1) && (ctxt->input != NULL) &&
12518	(ctxt->input->buf != NULL)) {
12519	size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer,
12520	ctxt->input);
12521	size_t current = ctxt->input->cur - ctxt->input->base;
12522
12523	xmlParserInputBufferPush(ctxt->input->buf, 1, "\r");
12524
12525	xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input,
12526	base, current);
12527	}
12528	if (terminate) {
12529	/*
12530	* Check for termination
12531	*/
12532	int cur_avail = 0;
12533
12534	if (ctxt->input != NULL) {
12535	if (ctxt->input->buf == NULL)
12536	cur_avail = ctxt->input->length -
12537	(ctxt->input->cur - ctxt->input->base);
12538	else
12539	cur_avail = xmlBufUse(ctxt->input->buf->buffer) -
12540	(ctxt->input->cur - ctxt->input->base);
12541	}
12542
12543	if ((ctxt->instate != XML_PARSER_EOF) &&
12544	(ctxt->instate != XML_PARSER_EPILOG)) {
12545	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
12546	}
12547	if ((ctxt->instate == XML_PARSER_EPILOG) && (cur_avail > 0)) {
12548	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
12549	}
12550	if (ctxt->instate != XML_PARSER_EOF) {
12551	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
12552	ctxt->sax->endDocument(ctxt->userData);
12553	}
12554	ctxt->instate = XML_PARSER_EOF;
12555	}
12556	if (ctxt->wellFormed == 0)
12557	return((xmlParserErrors) ctxt->errNo);
12558	else
12559	return(0);
12560	}
12561
12562	/************************************************************************
12563	* *
12564	* I/O front end functions to the parser *
12565	* *
12566	************************************************************************/
12567
12568	/**
12569	* xmlCreatePushParserCtxt:
12570	* @sax: a SAX handler
12571	* @user_data: The user data returned on SAX callbacks
12572	* @chunk: a pointer to an array of chars
12573	* @size: number of chars in the array
12574	* @filename: an optional file name or URI
12575	*
12576	* Create a parser context for using the XML parser in push mode.
12577	* If @buffer and @size are non-NULL, the data is used to detect
12578	* the encoding. The remaining characters will be parsed so they
12579	* don't need to be fed in again through xmlParseChunk.
12580	* To allow content encoding detection, @size should be >= 4
12581	* The value of @filename is used for fetching external entities
12582	* and error/warning reports.
12583	*
12584	* Returns the new parser context or NULL
12585	*/
12586
12587	xmlParserCtxtPtr
12588	xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
12589	const char chunk, int size, const char filename) {
12590	xmlParserCtxtPtr ctxt;
12591	xmlParserInputPtr inputStream;
12592	xmlParserInputBufferPtr buf;
12593	xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
12594
12595	/*
12596	* plug some encoding conversion routines
12597	*/
12598	if ((chunk != NULL) && (size >= 4))
12599	enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
12600
12601	buf = xmlAllocParserInputBuffer(enc);
12602	if (buf == NULL) return(NULL);
12603
12604	ctxt = xmlNewParserCtxt();
12605	if (ctxt == NULL) {
12606	xmlErrMemory(NULL, "creating parser: out of memory\n");
12607	xmlFreeParserInputBuffer(buf);
12608	return(NULL);
12609	}
12610	ctxt->dictNames = 1;
12611	ctxt->pushTab = (void *) xmlMalloc(ctxt->nameMax 3 * sizeof(xmlChar *));
12612	if (ctxt->pushTab == NULL) {
12613	xmlErrMemory(ctxt, NULL);
12614	xmlFreeParserInputBuffer(buf);
12615	xmlFreeParserCtxt(ctxt);
12616	return(NULL);
12617	}
12618	if (sax != NULL) {
12619	#ifdef LIBXML_SAX1_ENABLED
12620	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12621	#endif /* LIBXML_SAX1_ENABLED */
12622	xmlFree(ctxt->sax);
12623	ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
12624	if (ctxt->sax == NULL) {
12625	xmlErrMemory(ctxt, NULL);
12626	xmlFreeParserInputBuffer(buf);
12627	xmlFreeParserCtxt(ctxt);
12628	return(NULL);
12629	}
12630	memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
12631	if (sax->initialized == XML_SAX2_MAGIC)
12632	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
12633	else
12634	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
12635	if (user_data != NULL)
12636	ctxt->userData = user_data;
12637	}
12638	if (filename == NULL) {
12639	ctxt->directory = NULL;
12640	} else {
12641	ctxt->directory = xmlParserGetDirectory(filename);
12642	}
12643
12644	inputStream = xmlNewInputStream(ctxt);
12645	if (inputStream == NULL) {
12646	xmlFreeParserCtxt(ctxt);
12647	xmlFreeParserInputBuffer(buf);
12648	return(NULL);
12649	}
12650
12651	if (filename == NULL)
12652	inputStream->filename = NULL;
12653	else {
12654	inputStream->filename = (char *)
12655	xmlCanonicPath((const xmlChar *) filename);
12656	if (inputStream->filename == NULL) {
12657	xmlFreeParserCtxt(ctxt);
12658	xmlFreeParserInputBuffer(buf);
12659	return(NULL);
12660	}
12661	}
12662	inputStream->buf = buf;
12663	xmlBufResetInput(inputStream->buf->buffer, inputStream);
12664	inputPush(ctxt, inputStream);
12665
12666	/*
12667	* If the caller didn't provide an initial 'chunk' for determining
12668	* the encoding, we set the context to XML_CHAR_ENCODING_NONE so
12669	* that it can be automatically determined later
12670	*/
12671	if ((size == 0) \|\| (chunk == NULL)) {
12672	ctxt->charset = XML_CHAR_ENCODING_NONE;
12673	} else if ((ctxt->input != NULL) && (ctxt->input->buf != NULL)) {
12674	size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
12675	size_t cur = ctxt->input->cur - ctxt->input->base;
12676
12677	xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
12678
12679	xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
12680	#ifdef DEBUG_PUSH
12681	xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
12682	#endif
12683	}
12684
12685	if (enc != XML_CHAR_ENCODING_NONE) {
12686	xmlSwitchEncoding(ctxt, enc);
12687	}
12688
12689	return(ctxt);
12690	}
12691	#endif /* LIBXML_PUSH_ENABLED */
12692
12693	/**
12694	* xmlHaltParser:
12695	* @ctxt: an XML parser context
12696	*
12697	* Blocks further parser processing don't override error
12698	* for internal use
12699	*/
12700	static void
12701	xmlHaltParser(xmlParserCtxtPtr ctxt) {
12702	if (ctxt == NULL)
12703	return;
12704	ctxt->instate = XML_PARSER_EOF;
12705	ctxt->disableSAX = 1;
12706	if (ctxt->input != NULL) {
12707	/*
12708	* in case there was a specific allocation deallocate before
12709	* overriding base
12710	*/
12711	if (ctxt->input->free != NULL) {
12712	ctxt->input->free((xmlChar *) ctxt->input->base);
12713	ctxt->input->free = NULL;
12714	}
12715	ctxt->input->cur = BAD_CAST"";
12716	ctxt->input->base = ctxt->input->cur;
12717	}
12718	}
12719
12720	/**
12721	* xmlStopParser:
12722	* @ctxt: an XML parser context
12723	*
12724	* Blocks further parser processing
12725	*/
12726	void
12727	xmlStopParser(xmlParserCtxtPtr ctxt) {
12728	if (ctxt == NULL)
12729	return;
12730	xmlHaltParser(ctxt);
12731	ctxt->errNo = XML_ERR_USER_STOP;
12732	}
12733
12734	/**
12735	* xmlCreateIOParserCtxt:
12736	* @sax: a SAX handler
12737	* @user_data: The user data returned on SAX callbacks
12738	* @ioread: an I/O read function
12739	* @ioclose: an I/O close function
12740	* @ioctx: an I/O handler
12741	* @enc: the charset encoding if known
12742	*
12743	* Create a parser context for using the XML parser with an existing
12744	* I/O stream
12745	*
12746	* Returns the new parser context or NULL
12747	*/
12748	xmlParserCtxtPtr
12749	xmlCreateIOParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
12750	xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
12751	void *ioctx, xmlCharEncoding enc) {
12752	xmlParserCtxtPtr ctxt;
12753	xmlParserInputPtr inputStream;
12754	xmlParserInputBufferPtr buf;
12755
12756	if (ioread == NULL) return(NULL);
12757
12758	buf = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, enc);
12759	if (buf == NULL) {
12760	if (ioclose != NULL)
12761	ioclose(ioctx);
12762	return (NULL);
12763	}
12764
12765	ctxt = xmlNewParserCtxt();
12766	if (ctxt == NULL) {
12767	xmlFreeParserInputBuffer(buf);
12768	return(NULL);
12769	}
12770	if (sax != NULL) {
12771	#ifdef LIBXML_SAX1_ENABLED
12772	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12773	#endif /* LIBXML_SAX1_ENABLED */
12774	xmlFree(ctxt->sax);
12775	ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
12776	if (ctxt->sax == NULL) {
12777	xmlErrMemory(ctxt, NULL);
12778	xmlFreeParserCtxt(ctxt);
12779	return(NULL);
12780	}
12781	memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
12782	if (sax->initialized == XML_SAX2_MAGIC)
12783	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
12784	else
12785	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
12786	if (user_data != NULL)
12787	ctxt->userData = user_data;
12788	}
12789
12790	inputStream = xmlNewIOInputStream(ctxt, buf, enc);
12791	if (inputStream == NULL) {
12792	xmlFreeParserCtxt(ctxt);
12793	return(NULL);
12794	}
12795	inputPush(ctxt, inputStream);
12796
12797	return(ctxt);
12798	}
12799
12800	#ifdef LIBXML_VALID_ENABLED
12801	/************************************************************************
12802	* *
12803	* Front ends when parsing a DTD *
12804	* *
12805	************************************************************************/
12806
12807	/**
12808	* xmlIOParseDTD:
12809	* @sax: the SAX handler block or NULL
12810	* @input: an Input Buffer
12811	* @enc: the charset encoding if known
12812	*
12813	* Load and parse a DTD
12814	*
12815	* Returns the resulting xmlDtdPtr or NULL in case of error.
12816	* @input will be freed by the function in any case.
12817	*/
12818
12819	xmlDtdPtr
12820	xmlIOParseDTD(xmlSAXHandlerPtr sax, xmlParserInputBufferPtr input,
12821	xmlCharEncoding enc) {
12822	xmlDtdPtr ret = NULL;
12823	xmlParserCtxtPtr ctxt;
12824	xmlParserInputPtr pinput = NULL;
12825	xmlChar start[4];
12826
12827	if (input == NULL)
12828	return(NULL);
12829
12830	ctxt = xmlNewParserCtxt();
12831	if (ctxt == NULL) {
12832	xmlFreeParserInputBuffer(input);
12833	return(NULL);
12834	}
12835
12836	/* We are loading a DTD */
12837	ctxt->options \|= XML_PARSE_DTDLOAD;
12838
12839	/*
12840	* Set-up the SAX context
12841	*/
12842	if (sax != NULL) {
12843	if (ctxt->sax != NULL)
12844	xmlFree(ctxt->sax);
12845	ctxt->sax = sax;
12846	ctxt->userData = ctxt;
12847	}
12848	xmlDetectSAX2(ctxt);
12849
12850	/*
12851	* generate a parser input from the I/O handler
12852	*/
12853
12854	pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
12855	if (pinput == NULL) {
12856	if (sax != NULL) ctxt->sax = NULL;
12857	xmlFreeParserInputBuffer(input);
12858	xmlFreeParserCtxt(ctxt);
12859	return(NULL);
12860	}
12861
12862	/*
12863	* plug some encoding conversion routines here.
12864	*/
12865	if (xmlPushInput(ctxt, pinput) < 0) {
12866	if (sax != NULL) ctxt->sax = NULL;
12867	xmlFreeParserCtxt(ctxt);
12868	return(NULL);
12869	}
12870	if (enc != XML_CHAR_ENCODING_NONE) {
12871	xmlSwitchEncoding(ctxt, enc);
12872	}
12873
12874	pinput->filename = NULL;
12875	pinput->line = 1;
12876	pinput->col = 1;
12877	pinput->base = ctxt->input->cur;
12878	pinput->cur = ctxt->input->cur;
12879	pinput->free = NULL;
12880
12881	/*
12882	* let's parse that entity knowing it's an external subset.
12883	*/
12884	ctxt->inSubset = 2;
12885	ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
12886	if (ctxt->myDoc == NULL) {
12887	xmlErrMemory(ctxt, "New Doc failed");
12888	return(NULL);
12889	}
12890	ctxt->myDoc->properties = XML_DOC_INTERNAL;
12891	ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
12892	BAD_CAST "none", BAD_CAST "none");
12893
12894	if ((enc == XML_CHAR_ENCODING_NONE) &&
12895	((ctxt->input->end - ctxt->input->cur) >= 4)) {
12896	/*
12897	* Get the 4 first bytes and decode the charset
12898	* if enc != XML_CHAR_ENCODING_NONE
12899	* plug some encoding conversion routines.
12900	*/
12901	start[0] = RAW;
12902	start[1] = NXT(1);
12903	start[2] = NXT(2);
12904	start[3] = NXT(3);
12905	enc = xmlDetectCharEncoding(start, 4);
12906	if (enc != XML_CHAR_ENCODING_NONE) {
12907	xmlSwitchEncoding(ctxt, enc);
12908	}
12909	}
12910
12911	xmlParseExternalSubset(ctxt, BAD_CAST "none", BAD_CAST "none");
12912
12913	if (ctxt->myDoc != NULL) {
12914	if (ctxt->wellFormed) {
12915	ret = ctxt->myDoc->extSubset;
12916	ctxt->myDoc->extSubset = NULL;
12917	if (ret != NULL) {
12918	xmlNodePtr tmp;
12919
12920	ret->doc = NULL;
12921	tmp = ret->children;
12922	while (tmp != NULL) {
12923	tmp->doc = NULL;
12924	tmp = tmp->next;
12925	}
12926	}
12927	} else {
12928	ret = NULL;
12929	}
12930	xmlFreeDoc(ctxt->myDoc);
12931	ctxt->myDoc = NULL;
12932	}
12933	if (sax != NULL) ctxt->sax = NULL;
12934	xmlFreeParserCtxt(ctxt);
12935
12936	return(ret);
12937	}
12938
12939	/**
12940	* xmlSAXParseDTD:
12941	* @sax: the SAX handler block
12942	* @ExternalID: a NAME* containing the External ID of the DTD
12943	* @SystemID: a NAME* containing the URL to the DTD
12944	*
12945	* Load and parse an external subset.
12946	*
12947	* Returns the resulting xmlDtdPtr or NULL in case of error.
12948	*/
12949
12950	xmlDtdPtr
12951	xmlSAXParseDTD(xmlSAXHandlerPtr sax, const xmlChar *ExternalID,
12952	const xmlChar *SystemID) {
12953	xmlDtdPtr ret = NULL;
12954	xmlParserCtxtPtr ctxt;
12955	xmlParserInputPtr input = NULL;
12956	xmlCharEncoding enc;
12957	xmlChar* systemIdCanonic;
12958
12959	if ((ExternalID == NULL) && (SystemID == NULL)) return(NULL);
12960
12961	ctxt = xmlNewParserCtxt();
12962	if (ctxt == NULL) {
12963	return(NULL);
12964	}
12965
12966	/* We are loading a DTD */
12967	ctxt->options \|= XML_PARSE_DTDLOAD;
12968
12969	/*
12970	* Set-up the SAX context
12971	*/
12972	if (sax != NULL) {
12973	if (ctxt->sax != NULL)
12974	xmlFree(ctxt->sax);
12975	ctxt->sax = sax;
12976	ctxt->userData = ctxt;
12977	}
12978
12979	/*
12980	* Canonicalise the system ID
12981	*/
12982	systemIdCanonic = xmlCanonicPath(SystemID);
12983	if ((SystemID != NULL) && (systemIdCanonic == NULL)) {
12984	xmlFreeParserCtxt(ctxt);
12985	return(NULL);
12986	}
12987
12988	/*
12989	* Ask the Entity resolver to load the damn thing
12990	*/
12991
12992	if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
12993	input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
12994	systemIdCanonic);
12995	if (input == NULL) {
12996	if (sax != NULL) ctxt->sax = NULL;
12997	xmlFreeParserCtxt(ctxt);
12998	if (systemIdCanonic != NULL)
12999	xmlFree(systemIdCanonic);
13000	return(NULL);
13001	}
13002
13003	/*
13004	* plug some encoding conversion routines here.
13005	*/
13006	if (xmlPushInput(ctxt, input) < 0) {
13007	if (sax != NULL) ctxt->sax = NULL;
13008	xmlFreeParserCtxt(ctxt);
13009	if (systemIdCanonic != NULL)
13010	xmlFree(systemIdCanonic);
13011	return(NULL);
13012	}
13013	if ((ctxt->input->end - ctxt->input->cur) >= 4) {
13014	enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
13015	xmlSwitchEncoding(ctxt, enc);
13016	}
13017
13018	if (input->filename == NULL)
13019	input->filename = (char *) systemIdCanonic;
13020	else
13021	xmlFree(systemIdCanonic);
13022	input->line = 1;
13023	input->col = 1;
13024	input->base = ctxt->input->cur;
13025	input->cur = ctxt->input->cur;
13026	input->free = NULL;
13027
13028	/*
13029	* let's parse that entity knowing it's an external subset.
13030	*/
13031	ctxt->inSubset = 2;
13032	ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
13033	if (ctxt->myDoc == NULL) {
13034	xmlErrMemory(ctxt, "New Doc failed");
13035	if (sax != NULL) ctxt->sax = NULL;
13036	xmlFreeParserCtxt(ctxt);
13037	return(NULL);
13038	}
13039	ctxt->myDoc->properties = XML_DOC_INTERNAL;
13040	ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
13041	ExternalID, SystemID);
13042	xmlParseExternalSubset(ctxt, ExternalID, SystemID);
13043
13044	if (ctxt->myDoc != NULL) {
13045	if (ctxt->wellFormed) {
13046	ret = ctxt->myDoc->extSubset;
13047	ctxt->myDoc->extSubset = NULL;
13048	if (ret != NULL) {
13049	xmlNodePtr tmp;
13050
13051	ret->doc = NULL;
13052	tmp = ret->children;
13053	while (tmp != NULL) {
13054	tmp->doc = NULL;
13055	tmp = tmp->next;
13056	}
13057	}
13058	} else {
13059	ret = NULL;
13060	}
13061	xmlFreeDoc(ctxt->myDoc);
13062	ctxt->myDoc = NULL;
13063	}
13064	if (sax != NULL) ctxt->sax = NULL;
13065	xmlFreeParserCtxt(ctxt);
13066
13067	return(ret);
13068	}
13069
13070
13071	/**
13072	* xmlParseDTD:
13073	* @ExternalID: a NAME* containing the External ID of the DTD
13074	* @SystemID: a NAME* containing the URL to the DTD
13075	*
13076	* Load and parse an external subset.
13077	*
13078	* Returns the resulting xmlDtdPtr or NULL in case of error.
13079	*/
13080
13081	xmlDtdPtr
13082	xmlParseDTD(const xmlChar ExternalID, const xmlChar SystemID) {
13083	return(xmlSAXParseDTD(NULL, ExternalID, SystemID));
13084	}
13085	#endif /* LIBXML_VALID_ENABLED */
13086
13087	/************************************************************************
13088	* *
13089	* Front ends when parsing an Entity *
13090	* *
13091	************************************************************************/
13092
13093	/**
13094	* xmlParseCtxtExternalEntity:
13095	* @ctx: the existing parsing context
13096	* @URL: the URL for the entity to load
13097	* @ID: the System ID for the entity to load
13098	* @lst: the return value for the set of parsed nodes
13099	*
13100	* Parse an external general entity within an existing parsing context
13101	* An external general parsed entity is well-formed if it matches the
13102	* production labeled extParsedEnt.
13103	*
13104	* [78] extParsedEnt ::= TextDecl? content
13105	*
13106	* Returns 0 if the entity is well formed, -1 in case of args problem and
13107	* the parser error code otherwise
13108	*/
13109
13110	int
13111	xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, const xmlChar *URL,
13112	const xmlChar ID, xmlNodePtr lst) {
13113	xmlParserCtxtPtr ctxt;
13114	xmlDocPtr newDoc;
13115	xmlNodePtr newRoot;
13116	xmlSAXHandlerPtr oldsax = NULL;
13117	int ret = 0;
13118	xmlChar start[4];
13119	xmlCharEncoding enc;
13120
13121	if (ctx == NULL) return(-1);
13122
13123	if (((ctx->depth > 40) && ((ctx->options & XML_PARSE_HUGE) == 0)) \|\|
13124	(ctx->depth > 1024)) {
13125	return(XML_ERR_ENTITY_LOOP);
13126	}
13127
13128	if (lst != NULL)
13129	*lst = NULL;
13130	if ((URL == NULL) && (ID == NULL))
13131	return(-1);
13132	if (ctx->myDoc == NULL) /* @@ relax but check for dereferences */
13133	return(-1);
13134
13135	ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, ctx);
13136	if (ctxt == NULL) {
13137	return(-1);
13138	}
13139
13140	oldsax = ctxt->sax;
13141	ctxt->sax = ctx->sax;
13142	xmlDetectSAX2(ctxt);
13143	newDoc = xmlNewDoc(BAD_CAST "1.0");
13144	if (newDoc == NULL) {
13145	xmlFreeParserCtxt(ctxt);
13146	return(-1);
13147	}
13148	newDoc->properties = XML_DOC_INTERNAL;
13149	if (ctx->myDoc->dict) {
13150	newDoc->dict = ctx->myDoc->dict;
13151	xmlDictReference(newDoc->dict);
13152	}
13153	if (ctx->myDoc != NULL) {
13154	newDoc->intSubset = ctx->myDoc->intSubset;
13155	newDoc->extSubset = ctx->myDoc->extSubset;
13156	}
13157	if (ctx->myDoc->URL != NULL) {
13158	newDoc->URL = xmlStrdup(ctx->myDoc->URL);
13159	}
13160	newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
13161	if (newRoot == NULL) {
13162	ctxt->sax = oldsax;
13163	xmlFreeParserCtxt(ctxt);
13164	newDoc->intSubset = NULL;
13165	newDoc->extSubset = NULL;
13166	xmlFreeDoc(newDoc);
13167	return(-1);
13168	}
13169	xmlAddChild((xmlNodePtr) newDoc, newRoot);
13170	nodePush(ctxt, newDoc->children);
13171	if (ctx->myDoc == NULL) {
13172	ctxt->myDoc = newDoc;
13173	} else {
13174	ctxt->myDoc = ctx->myDoc;
13175	newDoc->children->doc = ctx->myDoc;
13176	}
13177
13178	/*
13179	* Get the 4 first bytes and decode the charset
13180	* if enc != XML_CHAR_ENCODING_NONE
13181	* plug some encoding conversion routines.
13182	*/
13183	GROW
13184	if ((ctxt->input->end - ctxt->input->cur) >= 4) {
13185	start[0] = RAW;
13186	start[1] = NXT(1);
13187	start[2] = NXT(2);
13188	start[3] = NXT(3);
13189	enc = xmlDetectCharEncoding(start, 4);
13190	if (enc != XML_CHAR_ENCODING_NONE) {
13191	xmlSwitchEncoding(ctxt, enc);
13192	}
13193	}
13194
13195	/*
13196	* Parse a possible text declaration first
13197	*/
13198	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
13199	xmlParseTextDecl(ctxt);
13200	/*
13201	* An XML-1.0 document can't reference an entity not XML-1.0
13202	*/
13203	if ((xmlStrEqual(ctx->version, BAD_CAST "1.0")) &&
13204	(!xmlStrEqual(ctxt->input->version, BAD_CAST "1.0"))) {
13205	xmlFatalErrMsg(ctxt, XML_ERR_VERSION_MISMATCH,
13206	"Version mismatch between document and entity\n");
13207	}
13208	}
13209
13210	/*
13211	* If the user provided its own SAX callbacks then reuse the
13212	* useData callback field, otherwise the expected setup in a
13213	* DOM builder is to have userData == ctxt
13214	*/
13215	if (ctx->userData == ctx)
13216	ctxt->userData = ctxt;
13217	else
13218	ctxt->userData = ctx->userData;
13219
13220	/*
13221	* Doing validity checking on chunk doesn't make sense
13222	*/
13223	ctxt->instate = XML_PARSER_CONTENT;
13224	ctxt->validate = ctx->validate;
13225	ctxt->valid = ctx->valid;
13226	ctxt->loadsubset = ctx->loadsubset;
13227	ctxt->depth = ctx->depth + 1;
13228	ctxt->replaceEntities = ctx->replaceEntities;
13229	if (ctxt->validate) {
13230	ctxt->vctxt.error = ctx->vctxt.error;
13231	ctxt->vctxt.warning = ctx->vctxt.warning;
13232	} else {
13233	ctxt->vctxt.error = NULL;
13234	ctxt->vctxt.warning = NULL;
13235	}
13236	ctxt->vctxt.nodeTab = NULL;
13237	ctxt->vctxt.nodeNr = 0;
13238	ctxt->vctxt.nodeMax = 0;
13239	ctxt->vctxt.node = NULL;
13240	if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
13241	ctxt->dict = ctx->dict;
13242	ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
13243	ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
13244	ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
13245	ctxt->dictNames = ctx->dictNames;
13246	ctxt->attsDefault = ctx->attsDefault;
13247	ctxt->attsSpecial = ctx->attsSpecial;
13248	ctxt->linenumbers = ctx->linenumbers;
13249
13250	xmlParseContent(ctxt);
13251
13252	ctx->validate = ctxt->validate;
13253	ctx->valid = ctxt->valid;
13254	if ((RAW == '<') && (NXT(1) == '/')) {
13255	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13256	} else if (RAW != 0) {
13257	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13258	}
13259	if (ctxt->node != newDoc->children) {
13260	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13261	}
13262
13263	if (!ctxt->wellFormed) {
13264	if (ctxt->errNo == 0)
13265	ret = 1;
13266	else
13267	ret = ctxt->errNo;
13268	} else {
13269	if (lst != NULL) {
13270	xmlNodePtr cur;
13271
13272	/*
13273	* Return the newly created nodeset after unlinking it from
13274	* they pseudo parent.
13275	*/
13276	cur = newDoc->children->children;
13277	*lst = cur;
13278	while (cur != NULL) {
13279	cur->parent = NULL;
13280	cur = cur->next;
13281	}
13282	newDoc->children->children = NULL;
13283	}
13284	ret = 0;
13285	}
13286	ctxt->sax = oldsax;
13287	ctxt->dict = NULL;
13288	ctxt->attsDefault = NULL;
13289	ctxt->attsSpecial = NULL;
13290	xmlFreeParserCtxt(ctxt);
13291	newDoc->intSubset = NULL;
13292	newDoc->extSubset = NULL;
13293	xmlFreeDoc(newDoc);
13294
13295	return(ret);
13296	}
13297
13298	/**
13299	* xmlParseExternalEntityPrivate:
13300	* @doc: the document the chunk pertains to
13301	* @oldctxt: the previous parser context if available
13302	* @sax: the SAX handler bloc (possibly NULL)
13303	* @user_data: The user data returned on SAX callbacks (possibly NULL)
13304	* @depth: Used for loop detection, use 0
13305	* @URL: the URL for the entity to load
13306	* @ID: the System ID for the entity to load
13307	* @list: the return value for the set of parsed nodes
13308	*
13309	* Private version of xmlParseExternalEntity()
13310	*
13311	* Returns 0 if the entity is well formed, -1 in case of args problem and
13312	* the parser error code otherwise
13313	*/
13314
13315	static xmlParserErrors
13316	xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
13317	xmlSAXHandlerPtr sax,
13318	void user_data, int depth, const xmlChar URL,
13319	const xmlChar ID, xmlNodePtr list) {
13320	xmlParserCtxtPtr ctxt;
13321	xmlDocPtr newDoc;
13322	xmlNodePtr newRoot;
13323	xmlSAXHandlerPtr oldsax = NULL;
13324	xmlParserErrors ret = XML_ERR_OK;
13325	xmlChar start[4];
13326	xmlCharEncoding enc;
13327
13328	if (((depth > 40) &&
13329	((oldctxt == NULL) \|\| (oldctxt->options & XML_PARSE_HUGE) == 0)) \|\|
13330	(depth > 1024)) {
13331	return(XML_ERR_ENTITY_LOOP);
13332	}
13333
13334	if (list != NULL)
13335	*list = NULL;
13336	if ((URL == NULL) && (ID == NULL))
13337	return(XML_ERR_INTERNAL_ERROR);
13338	if (doc == NULL)
13339	return(XML_ERR_INTERNAL_ERROR);
13340
13341
13342	ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, oldctxt);
13343	if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
13344	ctxt->userData = ctxt;
13345	if (oldctxt != NULL) {
13346	ctxt->_private = oldctxt->_private;
13347	ctxt->loadsubset = oldctxt->loadsubset;
13348	ctxt->validate = oldctxt->validate;
13349	ctxt->external = oldctxt->external;
13350	ctxt->record_info = oldctxt->record_info;
13351	ctxt->node_seq.maximum = oldctxt->node_seq.maximum;
13352	ctxt->node_seq.length = oldctxt->node_seq.length;
13353	ctxt->node_seq.buffer = oldctxt->node_seq.buffer;
13354	} else {
13355	/*
13356	* Doing validity checking on chunk without context
13357	* doesn't make sense
13358	*/
13359	ctxt->_private = NULL;
13360	ctxt->validate = 0;
13361	ctxt->external = 2;
13362	ctxt->loadsubset = 0;
13363	}
13364	if (sax != NULL) {
13365	oldsax = ctxt->sax;
13366	ctxt->sax = sax;
13367	if (user_data != NULL)
13368	ctxt->userData = user_data;
13369	}
13370	xmlDetectSAX2(ctxt);
13371	newDoc = xmlNewDoc(BAD_CAST "1.0");
13372	if (newDoc == NULL) {
13373	ctxt->node_seq.maximum = 0;
13374	ctxt->node_seq.length = 0;
13375	ctxt->node_seq.buffer = NULL;
13376	xmlFreeParserCtxt(ctxt);
13377	return(XML_ERR_INTERNAL_ERROR);
13378	}
13379	newDoc->properties = XML_DOC_INTERNAL;
13380	newDoc->intSubset = doc->intSubset;
13381	newDoc->extSubset = doc->extSubset;
13382	newDoc->dict = doc->dict;
13383	xmlDictReference(newDoc->dict);
13384
13385	if (doc->URL != NULL) {
13386	newDoc->URL = xmlStrdup(doc->URL);
13387	}
13388	newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
13389	if (newRoot == NULL) {
13390	if (sax != NULL)
13391	ctxt->sax = oldsax;
13392	ctxt->node_seq.maximum = 0;
13393	ctxt->node_seq.length = 0;
13394	ctxt->node_seq.buffer = NULL;
13395	xmlFreeParserCtxt(ctxt);
13396	newDoc->intSubset = NULL;
13397	newDoc->extSubset = NULL;
13398	xmlFreeDoc(newDoc);
13399	return(XML_ERR_INTERNAL_ERROR);
13400	}
13401	xmlAddChild((xmlNodePtr) newDoc, newRoot);
13402	nodePush(ctxt, newDoc->children);
13403	ctxt->myDoc = doc;
13404	newRoot->doc = doc;
13405
13406	/*
13407	* Get the 4 first bytes and decode the charset
13408	* if enc != XML_CHAR_ENCODING_NONE
13409	* plug some encoding conversion routines.
13410	*/
13411	GROW;
13412	if ((ctxt->input->end - ctxt->input->cur) >= 4) {
13413	start[0] = RAW;
13414	start[1] = NXT(1);
13415	start[2] = NXT(2);
13416	start[3] = NXT(3);
13417	enc = xmlDetectCharEncoding(start, 4);
13418	if (enc != XML_CHAR_ENCODING_NONE) {
13419	xmlSwitchEncoding(ctxt, enc);
13420	}
13421	}
13422
13423	/*
13424	* Parse a possible text declaration first
13425	*/
13426	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
13427	xmlParseTextDecl(ctxt);
13428	}
13429
13430	ctxt->instate = XML_PARSER_CONTENT;
13431	ctxt->depth = depth;
13432
13433	xmlParseContent(ctxt);
13434
13435	if ((RAW == '<') && (NXT(1) == '/')) {
13436	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13437	} else if (RAW != 0) {
13438	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13439	}
13440	if (ctxt->node != newDoc->children) {
13441	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13442	}
13443
13444	if (!ctxt->wellFormed) {
13445	if (ctxt->errNo == 0)
13446	ret = XML_ERR_INTERNAL_ERROR;
13447	else
13448	ret = (xmlParserErrors)ctxt->errNo;
13449	} else {
13450	if (list != NULL) {
13451	xmlNodePtr cur;
13452
13453	/*
13454	* Return the newly created nodeset after unlinking it from
13455	* they pseudo parent.
13456	*/
13457	cur = newDoc->children->children;
13458	*list = cur;
13459	while (cur != NULL) {
13460	cur->parent = NULL;
13461	cur = cur->next;
13462	}
13463	newDoc->children->children = NULL;
13464	}
13465	ret = XML_ERR_OK;
13466	}
13467
13468	/*
13469	* Record in the parent context the number of entities replacement
13470	* done when parsing that reference.
13471	*/
13472	if (oldctxt != NULL)
13473	oldctxt->nbentities += ctxt->nbentities;
13474
13475	/*
13476	* Also record the size of the entity parsed
13477	*/
13478	if (ctxt->input != NULL && oldctxt != NULL) {
13479	oldctxt->sizeentities += ctxt->input->consumed;
13480	oldctxt->sizeentities += (ctxt->input->cur - ctxt->input->base);
13481	}
13482	/*
13483	* And record the last error if any
13484	*/
13485	if (ctxt->lastError.code != XML_ERR_OK)
13486	xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
13487
13488	if (sax != NULL)
13489	ctxt->sax = oldsax;
13490	if (oldctxt != NULL) {
13491	oldctxt->node_seq.maximum = ctxt->node_seq.maximum;
13492	oldctxt->node_seq.length = ctxt->node_seq.length;
13493	oldctxt->node_seq.buffer = ctxt->node_seq.buffer;
13494	}
13495	ctxt->node_seq.maximum = 0;
13496	ctxt->node_seq.length = 0;
13497	ctxt->node_seq.buffer = NULL;
13498	xmlFreeParserCtxt(ctxt);
13499	newDoc->intSubset = NULL;
13500	newDoc->extSubset = NULL;
13501	xmlFreeDoc(newDoc);
13502
13503	return(ret);
13504	}
13505
13506	#ifdef LIBXML_SAX1_ENABLED
13507	/**
13508	* xmlParseExternalEntity:
13509	* @doc: the document the chunk pertains to
13510	* @sax: the SAX handler bloc (possibly NULL)
13511	* @user_data: The user data returned on SAX callbacks (possibly NULL)
13512	* @depth: Used for loop detection, use 0
13513	* @URL: the URL for the entity to load
13514	* @ID: the System ID for the entity to load
13515	* @lst: the return value for the set of parsed nodes
13516	*
13517	* Parse an external general entity
13518	* An external general parsed entity is well-formed if it matches the
13519	* production labeled extParsedEnt.
13520	*
13521	* [78] extParsedEnt ::= TextDecl? content
13522	*
13523	* Returns 0 if the entity is well formed, -1 in case of args problem and
13524	* the parser error code otherwise
13525	*/
13526
13527	int
13528	xmlParseExternalEntity(xmlDocPtr doc, xmlSAXHandlerPtr sax, void *user_data,
13529	int depth, const xmlChar URL, const xmlChar ID, xmlNodePtr *lst) {
13530	return(xmlParseExternalEntityPrivate(doc, NULL, sax, user_data, depth, URL,
13531	ID, lst));
13532	}
13533
13534	/**
13535	* xmlParseBalancedChunkMemory:
13536	* @doc: the document the chunk pertains to
13537	* @sax: the SAX handler bloc (possibly NULL)
13538	* @user_data: The user data returned on SAX callbacks (possibly NULL)
13539	* @depth: Used for loop detection, use 0
13540	* @string: the input string in UTF8 or ISO-Latin (zero terminated)
13541	* @lst: the return value for the set of parsed nodes
13542	*
13543	* Parse a well-balanced chunk of an XML document
13544	* called by the parser
13545	* The allowed sequence for the Well Balanced Chunk is the one defined by
13546	* the content production in the XML grammar:
13547	*
13548	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
13549	*
13550	* Returns 0 if the chunk is well balanced, -1 in case of args problem and
13551	* the parser error code otherwise
13552	*/
13553
13554	int
13555	xmlParseBalancedChunkMemory(xmlDocPtr doc, xmlSAXHandlerPtr sax,
13556	void user_data, int depth, const xmlChar string, xmlNodePtr *lst) {
13557	return xmlParseBalancedChunkMemoryRecover( doc, sax, user_data,
13558	depth, string, lst, 0 );
13559	}
13560	#endif /* LIBXML_SAX1_ENABLED */
13561
13562	/**
13563	* xmlParseBalancedChunkMemoryInternal:
13564	* @oldctxt: the existing parsing context
13565	* @string: the input string in UTF8 or ISO-Latin (zero terminated)
13566	* @user_data: the user data field for the parser context
13567	* @lst: the return value for the set of parsed nodes
13568	*
13569	*
13570	* Parse a well-balanced chunk of an XML document
13571	* called by the parser
13572	* The allowed sequence for the Well Balanced Chunk is the one defined by
13573	* the content production in the XML grammar:
13574	*
13575	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
13576	*
13577	* Returns XML_ERR_OK if the chunk is well balanced, and the parser
13578	* error code otherwise
13579	*
13580	* In case recover is set to 1, the nodelist will not be empty even if
13581	* the parsed chunk is not well balanced.
13582	*/
13583	static xmlParserErrors
13584	xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
13585	const xmlChar string, void user_data, xmlNodePtr *lst) {
13586	xmlParserCtxtPtr ctxt;
13587	xmlDocPtr newDoc = NULL;
13588	xmlNodePtr newRoot;
13589	xmlSAXHandlerPtr oldsax = NULL;
13590	xmlNodePtr content = NULL;
13591	xmlNodePtr last = NULL;
13592	int size;
13593	xmlParserErrors ret = XML_ERR_OK;
13594	#ifdef SAX2
13595	int i;
13596	#endif
13597
13598	if (((oldctxt->depth > 40) && ((oldctxt->options & XML_PARSE_HUGE) == 0)) \|\|
13599	(oldctxt->depth > 1024)) {
13600	return(XML_ERR_ENTITY_LOOP);
13601	}
13602
13603
13604	if (lst != NULL)
13605	*lst = NULL;
13606	if (string == NULL)
13607	return(XML_ERR_INTERNAL_ERROR);
13608
13609	size = xmlStrlen(string);
13610
13611	ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
13612	if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
13613	if (user_data != NULL)
13614	ctxt->userData = user_data;
13615	else
13616	ctxt->userData = ctxt;
13617	if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
13618	ctxt->dict = oldctxt->dict;
13619	ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
13620	ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
13621	ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
13622
13623	#ifdef SAX2
13624	/* propagate namespaces down the entity */
13625	for (i = 0;i < oldctxt->nsNr;i += 2) {
13626	nsPush(ctxt, oldctxt->nsTab[i], oldctxt->nsTab[i+1]);
13627	}
13628	#endif
13629
13630	oldsax = ctxt->sax;
13631	ctxt->sax = oldctxt->sax;
13632	xmlDetectSAX2(ctxt);
13633	ctxt->replaceEntities = oldctxt->replaceEntities;
13634	ctxt->options = oldctxt->options;
13635
13636	ctxt->_private = oldctxt->_private;
13637	if (oldctxt->myDoc == NULL) {
13638	newDoc = xmlNewDoc(BAD_CAST "1.0");
13639	if (newDoc == NULL) {
13640	ctxt->sax = oldsax;
13641	ctxt->dict = NULL;
13642	xmlFreeParserCtxt(ctxt);
13643	return(XML_ERR_INTERNAL_ERROR);
13644	}
13645	newDoc->properties = XML_DOC_INTERNAL;
13646	newDoc->dict = ctxt->dict;
13647	xmlDictReference(newDoc->dict);
13648	ctxt->myDoc = newDoc;
13649	} else {
13650	ctxt->myDoc = oldctxt->myDoc;
13651	content = ctxt->myDoc->children;
13652	last = ctxt->myDoc->last;
13653	}
13654	newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL);
13655	if (newRoot == NULL) {
13656	ctxt->sax = oldsax;
13657	ctxt->dict = NULL;
13658	xmlFreeParserCtxt(ctxt);
13659	if (newDoc != NULL) {
13660	xmlFreeDoc(newDoc);
13661	}
13662	return(XML_ERR_INTERNAL_ERROR);
13663	}
13664	ctxt->myDoc->children = NULL;
13665	ctxt->myDoc->last = NULL;
13666	xmlAddChild((xmlNodePtr) ctxt->myDoc, newRoot);
13667	nodePush(ctxt, ctxt->myDoc->children);
13668	ctxt->instate = XML_PARSER_CONTENT;
13669	ctxt->depth = oldctxt->depth + 1;
13670
13671	ctxt->validate = 0;
13672	ctxt->loadsubset = oldctxt->loadsubset;
13673	if ((oldctxt->validate) \|\| (oldctxt->replaceEntities != 0)) {
13674	/*
13675	* ID/IDREF registration will be done in xmlValidateElement below
13676	*/
13677	ctxt->loadsubset \|= XML_SKIP_IDS;
13678	}
13679	ctxt->dictNames = oldctxt->dictNames;
13680	ctxt->attsDefault = oldctxt->attsDefault;
13681	ctxt->attsSpecial = oldctxt->attsSpecial;
13682
13683	xmlParseContent(ctxt);
13684	if ((RAW == '<') && (NXT(1) == '/')) {
13685	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13686	} else if (RAW != 0) {
13687	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13688	}
13689	if (ctxt->node != ctxt->myDoc->children) {
13690	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13691	}
13692
13693	if (!ctxt->wellFormed) {
13694	if (ctxt->errNo == 0)
13695	ret = XML_ERR_INTERNAL_ERROR;
13696	else
13697	ret = (xmlParserErrors)ctxt->errNo;
13698	} else {
13699	ret = XML_ERR_OK;
13700	}
13701
13702	if ((lst != NULL) && (ret == XML_ERR_OK)) {
13703	xmlNodePtr cur;
13704
13705	/*
13706	* Return the newly created nodeset after unlinking it from
13707	* they pseudo parent.
13708	*/
13709	cur = ctxt->myDoc->children->children;
13710	*lst = cur;
13711	while (cur != NULL) {
13712	#ifdef LIBXML_VALID_ENABLED
13713	if ((oldctxt->validate) && (oldctxt->wellFormed) &&
13714	(oldctxt->myDoc) && (oldctxt->myDoc->intSubset) &&
13715	(cur->type == XML_ELEMENT_NODE)) {
13716	oldctxt->valid &= xmlValidateElement(&oldctxt->vctxt,
13717	oldctxt->myDoc, cur);
13718	}
13719	#endif /* LIBXML_VALID_ENABLED */
13720	cur->parent = NULL;
13721	cur = cur->next;
13722	}
13723	ctxt->myDoc->children->children = NULL;
13724	}
13725	if (ctxt->myDoc != NULL) {
13726	xmlFreeNode(ctxt->myDoc->children);
13727	ctxt->myDoc->children = content;
13728	ctxt->myDoc->last = last;
13729	}
13730
13731	/*
13732	* Record in the parent context the number of entities replacement
13733	* done when parsing that reference.
13734	*/
13735	if (oldctxt != NULL)
13736	oldctxt->nbentities += ctxt->nbentities;
13737
13738	/*
13739	* Also record the last error if any
13740	*/
13741	if (ctxt->lastError.code != XML_ERR_OK)
13742	xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
13743
13744	ctxt->sax = oldsax;
13745	ctxt->dict = NULL;
13746	ctxt->attsDefault = NULL;
13747	ctxt->attsSpecial = NULL;
13748	xmlFreeParserCtxt(ctxt);
13749	if (newDoc != NULL) {
13750	xmlFreeDoc(newDoc);
13751	}
13752
13753	return(ret);
13754	}
13755
13756	/**
13757	* xmlParseInNodeContext:
13758	* @node: the context node
13759	* @data: the input string
13760	* @datalen: the input string length in bytes
13761	* @options: a combination of xmlParserOption
13762	* @lst: the return value for the set of parsed nodes
13763	*
13764	* Parse a well-balanced chunk of an XML document
13765	* within the context (DTD, namespaces, etc ...) of the given node.
13766	*
13767	* The allowed sequence for the data is a Well Balanced Chunk defined by
13768	* the content production in the XML grammar:
13769	*
13770	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
13771	*
13772	* Returns XML_ERR_OK if the chunk is well balanced, and the parser
13773	* error code otherwise
13774	*/
13775	xmlParserErrors
13776	xmlParseInNodeContext(xmlNodePtr node, const char *data, int datalen,
13777	int options, xmlNodePtr *lst) {
13778	#ifdef SAX2
13779	xmlParserCtxtPtr ctxt;
13780	xmlDocPtr doc = NULL;
13781	xmlNodePtr fake, cur;
13782	int nsnr = 0;
13783
13784	xmlParserErrors ret = XML_ERR_OK;
13785
13786	/*
13787	* check all input parameters, grab the document
13788	*/
13789	if ((lst == NULL) \|\| (node == NULL) \|\| (data == NULL) \|\| (datalen < 0))
13790	return(XML_ERR_INTERNAL_ERROR);
13791	switch (node->type) {
13792	case XML_ELEMENT_NODE:
13793	case XML_ATTRIBUTE_NODE:
13794	case XML_TEXT_NODE:
13795	case XML_CDATA_SECTION_NODE:
13796	case XML_ENTITY_REF_NODE:
13797	case XML_PI_NODE:
13798	case XML_COMMENT_NODE:
13799	case XML_DOCUMENT_NODE:
13800	case XML_HTML_DOCUMENT_NODE:
13801	break;
13802	default:
13803	return(XML_ERR_INTERNAL_ERROR);
13804
13805	}
13806	while ((node != NULL) && (node->type != XML_ELEMENT_NODE) &&
13807	(node->type != XML_DOCUMENT_NODE) &&
13808	(node->type != XML_HTML_DOCUMENT_NODE))
13809	node = node->parent;
13810	if (node == NULL)
13811	return(XML_ERR_INTERNAL_ERROR);
13812	if (node->type == XML_ELEMENT_NODE)
13813	doc = node->doc;
13814	else
13815	doc = (xmlDocPtr) node;
13816	if (doc == NULL)
13817	return(XML_ERR_INTERNAL_ERROR);
13818
13819	/*
13820	* allocate a context and set-up everything not related to the
13821	* node position in the tree
13822	*/
13823	if (doc->type == XML_DOCUMENT_NODE)
13824	ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen);
13825	#ifdef LIBXML_HTML_ENABLED
13826	else if (doc->type == XML_HTML_DOCUMENT_NODE) {
13827	ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen);
13828	/*
13829	* When parsing in context, it makes no sense to add implied
13830	* elements like html/body/etc...
13831	*/
13832	options \|= HTML_PARSE_NOIMPLIED;
13833	}
13834	#endif
13835	else
13836	return(XML_ERR_INTERNAL_ERROR);
13837
13838	if (ctxt == NULL)
13839	return(XML_ERR_NO_MEMORY);
13840
13841	/*
13842	* Use input doc's dict if present, else assure XML_PARSE_NODICT is set.
13843	* We need a dictionary for xmlDetectSAX2, so if there's no doc dict
13844	* we must wait until the last moment to free the original one.
13845	*/
13846	if (doc->dict != NULL) {
13847	if (ctxt->dict != NULL)
13848	xmlDictFree(ctxt->dict);
13849	ctxt->dict = doc->dict;
13850	} else
13851	options \|= XML_PARSE_NODICT;
13852
13853	if (doc->encoding != NULL) {
13854	xmlCharEncodingHandlerPtr hdlr;
13855
13856	if (ctxt->encoding != NULL)
13857	xmlFree((xmlChar *) ctxt->encoding);
13858	ctxt->encoding = xmlStrdup((const xmlChar *) doc->encoding);
13859
13860	hdlr = xmlFindCharEncodingHandler((const char *) doc->encoding);
13861	if (hdlr != NULL) {
13862	xmlSwitchToEncoding(ctxt, hdlr);
13863	} else {
13864	return(XML_ERR_UNSUPPORTED_ENCODING);
13865	}
13866	}
13867
13868	xmlCtxtUseOptionsInternal(ctxt, options, NULL);
13869	xmlDetectSAX2(ctxt);
13870	ctxt->myDoc = doc;
13871	/* parsing in context, i.e. as within existing content */
13872	ctxt->instate = XML_PARSER_CONTENT;
13873
13874	fake = xmlNewComment(NULL);
13875	if (fake == NULL) {
13876	xmlFreeParserCtxt(ctxt);
13877	return(XML_ERR_NO_MEMORY);
13878	}
13879	xmlAddChild(node, fake);
13880
13881	if (node->type == XML_ELEMENT_NODE) {
13882	nodePush(ctxt, node);
13883	/*
13884	* initialize the SAX2 namespaces stack
13885	*/
13886	cur = node;
13887	while ((cur != NULL) && (cur->type == XML_ELEMENT_NODE)) {
13888	xmlNsPtr ns = cur->nsDef;
13889	const xmlChar iprefix, ihref;
13890
13891	while (ns != NULL) {
13892	if (ctxt->dict) {
13893	iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1);
13894	ihref = xmlDictLookup(ctxt->dict, ns->href, -1);
13895	} else {
13896	iprefix = ns->prefix;
13897	ihref = ns->href;
13898	}
13899
13900	if (xmlGetNamespace(ctxt, iprefix) == NULL) {
13901	nsPush(ctxt, iprefix, ihref);
13902	nsnr++;
13903	}
13904	ns = ns->next;
13905	}
13906	cur = cur->parent;
13907	}
13908	}
13909
13910	if ((ctxt->validate) \|\| (ctxt->replaceEntities != 0)) {
13911	/*
13912	* ID/IDREF registration will be done in xmlValidateElement below
13913	*/
13914	ctxt->loadsubset \|= XML_SKIP_IDS;
13915	}
13916
13917	#ifdef LIBXML_HTML_ENABLED
13918	if (doc->type == XML_HTML_DOCUMENT_NODE)
13919	__htmlParseContent(ctxt);
13920	else
13921	#endif
13922	xmlParseContent(ctxt);
13923
13924	nsPop(ctxt, nsnr);
13925	if ((RAW == '<') && (NXT(1) == '/')) {
13926	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13927	} else if (RAW != 0) {
13928	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13929	}
13930	if ((ctxt->node != NULL) && (ctxt->node != node)) {
13931	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13932	ctxt->wellFormed = 0;
13933	}
13934
13935	if (!ctxt->wellFormed) {
13936	if (ctxt->errNo == 0)
13937	ret = XML_ERR_INTERNAL_ERROR;
13938	else
13939	ret = (xmlParserErrors)ctxt->errNo;
13940	} else {
13941	ret = XML_ERR_OK;
13942	}
13943
13944	/*
13945	* Return the newly created nodeset after unlinking it from
13946	* the pseudo sibling.
13947	*/
13948
13949	cur = fake->next;
13950	fake->next = NULL;
13951	node->last = fake;
13952
13953	if (cur != NULL) {
13954	cur->prev = NULL;
13955	}
13956
13957	*lst = cur;
13958
13959	while (cur != NULL) {
13960	cur->parent = NULL;
13961	cur = cur->next;
13962	}
13963
13964	xmlUnlinkNode(fake);
13965	xmlFreeNode(fake);
13966
13967
13968	if (ret != XML_ERR_OK) {
13969	xmlFreeNodeList(*lst);
13970	*lst = NULL;
13971	}
13972
13973	if (doc->dict != NULL)
13974	ctxt->dict = NULL;
13975	xmlFreeParserCtxt(ctxt);
13976
13977	return(ret);
13978	#else /* !SAX2 */
13979	return(XML_ERR_INTERNAL_ERROR);
13980	#endif
13981	}
13982
13983	#ifdef LIBXML_SAX1_ENABLED
13984	/**
13985	* xmlParseBalancedChunkMemoryRecover:
13986	* @doc: the document the chunk pertains to
13987	* @sax: the SAX handler bloc (possibly NULL)
13988	* @user_data: The user data returned on SAX callbacks (possibly NULL)
13989	* @depth: Used for loop detection, use 0
13990	* @string: the input string in UTF8 or ISO-Latin (zero terminated)
13991	* @lst: the return value for the set of parsed nodes
13992	* @recover: return nodes even if the data is broken (use 0)
13993	*
13994	*
13995	* Parse a well-balanced chunk of an XML document
13996	* called by the parser
13997	* The allowed sequence for the Well Balanced Chunk is the one defined by
13998	* the content production in the XML grammar:
13999	*
14000	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
14001	*
14002	* Returns 0 if the chunk is well balanced, -1 in case of args problem and
14003	* the parser error code otherwise
14004	*
14005	* In case recover is set to 1, the nodelist will not be empty even if
14006	* the parsed chunk is not well balanced, assuming the parsing succeeded to
14007	* some extent.
14008	*/
14009	int
14010	xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, xmlSAXHandlerPtr sax,
14011	void user_data, int depth, const xmlChar string, xmlNodePtr *lst,
14012	int recover) {
14013	xmlParserCtxtPtr ctxt;
14014	xmlDocPtr newDoc;
14015	xmlSAXHandlerPtr oldsax = NULL;
14016	xmlNodePtr content, newRoot;
14017	int size;
14018	int ret = 0;
14019
14020	if (depth > 40) {
14021	return(XML_ERR_ENTITY_LOOP);
14022	}
14023
14024
14025	if (lst != NULL)
14026	*lst = NULL;
14027	if (string == NULL)
14028	return(-1);
14029
14030	size = xmlStrlen(string);
14031
14032	ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
14033	if (ctxt == NULL) return(-1);
14034	ctxt->userData = ctxt;
14035	if (sax != NULL) {
14036	oldsax = ctxt->sax;
14037	ctxt->sax = sax;
14038	if (user_data != NULL)
14039	ctxt->userData = user_data;
14040	}
14041	newDoc = xmlNewDoc(BAD_CAST "1.0");
14042	if (newDoc == NULL) {
14043	xmlFreeParserCtxt(ctxt);
14044	return(-1);
14045	}
14046	newDoc->properties = XML_DOC_INTERNAL;
14047	if ((doc != NULL) && (doc->dict != NULL)) {
14048	xmlDictFree(ctxt->dict);
14049	ctxt->dict = doc->dict;
14050	xmlDictReference(ctxt->dict);
14051	ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
14052	ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
14053	ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
14054	ctxt->dictNames = 1;
14055	} else {
14056	xmlCtxtUseOptionsInternal(ctxt, XML_PARSE_NODICT, NULL);
14057	}
14058	if (doc != NULL) {
14059	newDoc->intSubset = doc->intSubset;
14060	newDoc->extSubset = doc->extSubset;
14061	}
14062	newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
14063	if (newRoot == NULL) {
14064	if (sax != NULL)
14065	ctxt->sax = oldsax;
14066	xmlFreeParserCtxt(ctxt);
14067	newDoc->intSubset = NULL;
14068	newDoc->extSubset = NULL;
14069	xmlFreeDoc(newDoc);
14070	return(-1);
14071	}
14072	xmlAddChild((xmlNodePtr) newDoc, newRoot);
14073	nodePush(ctxt, newRoot);
14074	if (doc == NULL) {
14075	ctxt->myDoc = newDoc;
14076	} else {
14077	ctxt->myDoc = newDoc;
14078	newDoc->children->doc = doc;
14079	/* Ensure that doc has XML spec namespace */
14080	xmlSearchNsByHref(doc, (xmlNodePtr)doc, XML_XML_NAMESPACE);
14081	newDoc->oldNs = doc->oldNs;
14082	}
14083	ctxt->instate = XML_PARSER_CONTENT;
14084	ctxt->depth = depth;
14085
14086	/*
14087	* Doing validity checking on chunk doesn't make sense
14088	*/
14089	ctxt->validate = 0;
14090	ctxt->loadsubset = 0;
14091	xmlDetectSAX2(ctxt);
14092
14093	if ( doc != NULL ){
14094	content = doc->children;
14095	doc->children = NULL;
14096	xmlParseContent(ctxt);
14097	doc->children = content;
14098	}
14099	else {
14100	xmlParseContent(ctxt);
14101	}
14102	if ((RAW == '<') && (NXT(1) == '/')) {
14103	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
14104	} else if (RAW != 0) {
14105	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
14106	}
14107	if (ctxt->node != newDoc->children) {
14108	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
14109	}
14110
14111	if (!ctxt->wellFormed) {
14112	if (ctxt->errNo == 0)
14113	ret = 1;
14114	else
14115	ret = ctxt->errNo;
14116	} else {
14117	ret = 0;
14118	}
14119
14120	if ((lst != NULL) && ((ret == 0) \|\| (recover == 1))) {
14121	xmlNodePtr cur;
14122
14123	/*
14124	* Return the newly created nodeset after unlinking it from
14125	* they pseudo parent.
14126	*/
14127	cur = newDoc->children->children;
14128	*lst = cur;
14129	while (cur != NULL) {
14130	xmlSetTreeDoc(cur, doc);
14131	cur->parent = NULL;
14132	cur = cur->next;
14133	}
14134	newDoc->children->children = NULL;
14135	}
14136
14137	if (sax != NULL)
14138	ctxt->sax = oldsax;
14139	xmlFreeParserCtxt(ctxt);
14140	newDoc->intSubset = NULL;
14141	newDoc->extSubset = NULL;
14142	newDoc->oldNs = NULL;
14143	xmlFreeDoc(newDoc);
14144
14145	return(ret);
14146	}
14147
14148	/**
14149	* xmlSAXParseEntity:
14150	* @sax: the SAX handler block
14151	* @filename: the filename
14152	*
14153	* parse an XML external entity out of context and build a tree.
14154	* It use the given SAX function block to handle the parsing callback.
14155	* If sax is NULL, fallback to the default DOM tree building routines.
14156	*
14157	* [78] extParsedEnt ::= TextDecl? content
14158	*
14159	* This correspond to a "Well Balanced" chunk
14160	*
14161	* Returns the resulting document tree
14162	*/
14163
14164	xmlDocPtr
14165	xmlSAXParseEntity(xmlSAXHandlerPtr sax, const char *filename) {
14166	xmlDocPtr ret;
14167	xmlParserCtxtPtr ctxt;
14168
14169	ctxt = xmlCreateFileParserCtxt(filename);
14170	if (ctxt == NULL) {
14171	return(NULL);
14172	}
14173	if (sax != NULL) {
14174	if (ctxt->sax != NULL)
14175	xmlFree(ctxt->sax);
14176	ctxt->sax = sax;
14177	ctxt->userData = NULL;
14178	}
14179
14180	xmlParseExtParsedEnt(ctxt);
14181
14182	if (ctxt->wellFormed)
14183	ret = ctxt->myDoc;
14184	else {
14185	ret = NULL;
14186	xmlFreeDoc(ctxt->myDoc);
14187	ctxt->myDoc = NULL;
14188	}
14189	if (sax != NULL)
14190	ctxt->sax = NULL;
14191	xmlFreeParserCtxt(ctxt);
14192
14193	return(ret);
14194	}
14195
14196	/**
14197	* xmlParseEntity:
14198	* @filename: the filename
14199	*
14200	* parse an XML external entity out of context and build a tree.
14201	*
14202	* [78] extParsedEnt ::= TextDecl? content
14203	*
14204	* This correspond to a "Well Balanced" chunk
14205	*
14206	* Returns the resulting document tree
14207	*/
14208
14209	xmlDocPtr
14210	xmlParseEntity(const char *filename) {
14211	return(xmlSAXParseEntity(NULL, filename));
14212	}
14213	#endif /* LIBXML_SAX1_ENABLED */
14214
14215	/**
14216	* xmlCreateEntityParserCtxtInternal:
14217	* @URL: the entity URL
14218	* @ID: the entity PUBLIC ID
14219	* @base: a possible base for the target URI
14220	* @pctx: parser context used to set options on new context
14221	*
14222	* Create a parser context for an external entity
14223	* Automatic support for ZLIB/Compress compressed document is provided
14224	* by default if found at compile-time.
14225	*
14226	* Returns the new parser context or NULL
14227	*/
14228	static xmlParserCtxtPtr
14229	xmlCreateEntityParserCtxtInternal(const xmlChar URL, const xmlChar ID,
14230	const xmlChar *base, xmlParserCtxtPtr pctx) {
14231	xmlParserCtxtPtr ctxt;
14232	xmlParserInputPtr inputStream;
14233	char *directory = NULL;
14234	xmlChar *uri;
14235
14236	ctxt = xmlNewParserCtxt();
14237	if (ctxt == NULL) {
14238	return(NULL);
14239	}
14240
14241	if (pctx != NULL) {
14242	ctxt->options = pctx->options;
14243	ctxt->_private = pctx->_private;
14244	}
14245
14246	uri = xmlBuildURI(URL, base);
14247
14248	if (uri == NULL) {
14249	inputStream = xmlLoadExternalEntity((char )URL, (char )ID, ctxt);
14250	if (inputStream == NULL) {
14251	xmlFreeParserCtxt(ctxt);
14252	return(NULL);
14253	}
14254
14255	inputPush(ctxt, inputStream);
14256
14257	if ((ctxt->directory == NULL) && (directory == NULL))
14258	directory = xmlParserGetDirectory((char *)URL);
14259	if ((ctxt->directory == NULL) && (directory != NULL))
14260	ctxt->directory = directory;
14261	} else {
14262	inputStream = xmlLoadExternalEntity((char )uri, (char )ID, ctxt);
14263	if (inputStream == NULL) {
14264	xmlFree(uri);
14265	xmlFreeParserCtxt(ctxt);
14266	return(NULL);
14267	}
14268
14269	inputPush(ctxt, inputStream);
14270
14271	if ((ctxt->directory == NULL) && (directory == NULL))
14272	directory = xmlParserGetDirectory((char *)uri);
14273	if ((ctxt->directory == NULL) && (directory != NULL))
14274	ctxt->directory = directory;
14275	xmlFree(uri);
14276	}
14277	return(ctxt);
14278	}
14279
14280	/**
14281	* xmlCreateEntityParserCtxt:
14282	* @URL: the entity URL
14283	* @ID: the entity PUBLIC ID
14284	* @base: a possible base for the target URI
14285	*
14286	* Create a parser context for an external entity
14287	* Automatic support for ZLIB/Compress compressed document is provided
14288	* by default if found at compile-time.
14289	*
14290	* Returns the new parser context or NULL
14291	*/
14292	xmlParserCtxtPtr
14293	xmlCreateEntityParserCtxt(const xmlChar URL, const xmlChar ID,
14294	const xmlChar *base) {
14295	return xmlCreateEntityParserCtxtInternal(URL, ID, base, NULL);
14296
14297	}
14298
14299	/************************************************************************
14300	* *
14301	* Front ends when parsing from a file *
14302	* *
14303	************************************************************************/
14304
14305	/**
14306	* xmlCreateURLParserCtxt:
14307	* @filename: the filename or URL
14308	* @options: a combination of xmlParserOption
14309	*
14310	* Create a parser context for a file or URL content.
14311	* Automatic support for ZLIB/Compress compressed document is provided
14312	* by default if found at compile-time and for file accesses
14313	*
14314	* Returns the new parser context or NULL
14315	*/
14316	xmlParserCtxtPtr
14317	xmlCreateURLParserCtxt(const char *filename, int options)
14318	{
14319	xmlParserCtxtPtr ctxt;
14320	xmlParserInputPtr inputStream;
14321	char *directory = NULL;
14322
14323	ctxt = xmlNewParserCtxt();
14324	if (ctxt == NULL) {
14325	xmlErrMemory(NULL, "cannot allocate parser context");
14326	return(NULL);
14327	}
14328
14329	if (options)
14330	xmlCtxtUseOptionsInternal(ctxt, options, NULL);
14331	ctxt->linenumbers = 1;
14332
14333	inputStream = xmlLoadExternalEntity(filename, NULL, ctxt);
14334	if (inputStream == NULL) {
14335	xmlFreeParserCtxt(ctxt);
14336	return(NULL);
14337	}
14338
14339	inputPush(ctxt, inputStream);
14340	if ((ctxt->directory == NULL) && (directory == NULL))
14341	directory = xmlParserGetDirectory(filename);
14342	if ((ctxt->directory == NULL) && (directory != NULL))
14343	ctxt->directory = directory;
14344
14345	return(ctxt);
14346	}
14347
14348	/**
14349	* xmlCreateFileParserCtxt:
14350	* @filename: the filename
14351	*
14352	* Create a parser context for a file content.
14353	* Automatic support for ZLIB/Compress compressed document is provided
14354	* by default if found at compile-time.
14355	*
14356	* Returns the new parser context or NULL
14357	*/
14358	xmlParserCtxtPtr
14359	xmlCreateFileParserCtxt(const char *filename)
14360	{
14361	return(xmlCreateURLParserCtxt(filename, 0));
14362	}
14363
14364	#ifdef LIBXML_SAX1_ENABLED
14365	/**
14366	* xmlSAXParseFileWithData:
14367	* @sax: the SAX handler block
14368	* @filename: the filename
14369	* @recovery: work in recovery mode, i.e. tries to read no Well Formed
14370	* documents
14371	* @data: the userdata
14372	*
14373	* parse an XML file and build a tree. Automatic support for ZLIB/Compress
14374	* compressed document is provided by default if found at compile-time.
14375	* It use the given SAX function block to handle the parsing callback.
14376	* If sax is NULL, fallback to the default DOM tree building routines.
14377	*
14378	* User data (void *) is stored within the parser context in the
14379	* context's _private member, so it is available nearly everywhere in libxml
14380	*
14381	* Returns the resulting document tree
14382	*/
14383
14384	xmlDocPtr
14385	xmlSAXParseFileWithData(xmlSAXHandlerPtr sax, const char *filename,
14386	int recovery, void *data) {
14387	xmlDocPtr ret;
14388	xmlParserCtxtPtr ctxt;
14389
14390	xmlInitParser();
14391
14392	ctxt = xmlCreateFileParserCtxt(filename);
14393	if (ctxt == NULL) {
14394	return(NULL);
14395	}
14396	if (sax != NULL) {
14397	if (ctxt->sax != NULL)
14398	xmlFree(ctxt->sax);
14399	ctxt->sax = sax;
14400	}
14401	xmlDetectSAX2(ctxt);
14402	if (data!=NULL) {
14403	ctxt->_private = data;
14404	}
14405
14406	if (ctxt->directory == NULL)
14407	ctxt->directory = xmlParserGetDirectory(filename);
14408
14409	ctxt->recovery = recovery;
14410
14411	xmlParseDocument(ctxt);
14412
14413	if ((ctxt->wellFormed) \|\| recovery) {
14414	ret = ctxt->myDoc;
14415	if (ret != NULL) {
14416	if (ctxt->input->buf->compressed > 0)
14417	ret->compression = 9;
14418	else
14419	ret->compression = ctxt->input->buf->compressed;
14420	}
14421	}
14422	else {
14423	ret = NULL;
14424	xmlFreeDoc(ctxt->myDoc);
14425	ctxt->myDoc = NULL;
14426	}
14427	if (sax != NULL)
14428	ctxt->sax = NULL;
14429	xmlFreeParserCtxt(ctxt);
14430
14431	return(ret);
14432	}
14433
14434	/**
14435	* xmlSAXParseFile:
14436	* @sax: the SAX handler block
14437	* @filename: the filename
14438	* @recovery: work in recovery mode, i.e. tries to read no Well Formed
14439	* documents
14440	*
14441	* parse an XML file and build a tree. Automatic support for ZLIB/Compress
14442	* compressed document is provided by default if found at compile-time.
14443	* It use the given SAX function block to handle the parsing callback.
14444	* If sax is NULL, fallback to the default DOM tree building routines.
14445	*
14446	* Returns the resulting document tree
14447	*/
14448
14449	xmlDocPtr
14450	xmlSAXParseFile(xmlSAXHandlerPtr sax, const char *filename,
14451	int recovery) {
14452	return(xmlSAXParseFileWithData(sax,filename,recovery,NULL));
14453	}
14454
14455	/**
14456	* xmlRecoverDoc:
14457	* @cur: a pointer to an array of xmlChar
14458	*
14459	* parse an XML in-memory document and build a tree.
14460	* In the case the document is not Well Formed, a attempt to build a
14461	* tree is tried anyway
14462	*
14463	* Returns the resulting document tree or NULL in case of failure
14464	*/
14465
14466	xmlDocPtr
14467	xmlRecoverDoc(const xmlChar *cur) {
14468	return(xmlSAXParseDoc(NULL, cur, 1));
14469	}
14470
14471	/**
14472	* xmlParseFile:
14473	* @filename: the filename
14474	*
14475	* parse an XML file and build a tree. Automatic support for ZLIB/Compress
14476	* compressed document is provided by default if found at compile-time.
14477	*
14478	* Returns the resulting document tree if the file was wellformed,
14479	* NULL otherwise.
14480	*/
14481
14482	xmlDocPtr
14483	xmlParseFile(const char *filename) {
14484	return(xmlSAXParseFile(NULL, filename, 0));
14485	}
14486
14487	/**
14488	* xmlRecoverFile:
14489	* @filename: the filename
14490	*
14491	* parse an XML file and build a tree. Automatic support for ZLIB/Compress
14492	* compressed document is provided by default if found at compile-time.
14493	* In the case the document is not Well Formed, it attempts to build
14494	* a tree anyway
14495	*
14496	* Returns the resulting document tree or NULL in case of failure
14497	*/
14498
14499	xmlDocPtr
14500	xmlRecoverFile(const char *filename) {
14501	return(xmlSAXParseFile(NULL, filename, 1));
14502	}
14503
14504
14505	/**
14506	* xmlSetupParserForBuffer:
14507	* @ctxt: an XML parser context
14508	* @buffer: a xmlChar * buffer
14509	* @filename: a file name
14510	*
14511	* Setup the parser context to parse a new buffer; Clears any prior
14512	* contents from the parser context. The buffer parameter must not be
14513	* NULL, but the filename parameter can be
14514	*/
14515	void
14516	xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer,
14517	const char* filename)
14518	{
14519	xmlParserInputPtr input;
14520
14521	if ((ctxt == NULL) \|\| (buffer == NULL))
14522	return;
14523
14524	input = xmlNewInputStream(ctxt);
14525	if (input == NULL) {
14526	xmlErrMemory(NULL, "parsing new buffer: out of memory\n");
14527	xmlClearParserCtxt(ctxt);
14528	return;
14529	}
14530
14531	xmlClearParserCtxt(ctxt);
14532	if (filename != NULL)
14533	input->filename = (char ) xmlCanonicPath((const xmlChar )filename);
14534	input->base = buffer;
14535	input->cur = buffer;
14536	input->end = &buffer[xmlStrlen(buffer)];
14537	inputPush(ctxt, input);
14538	}
14539
14540	/**
14541	* xmlSAXUserParseFile:
14542	* @sax: a SAX handler
14543	* @user_data: The user data returned on SAX callbacks
14544	* @filename: a file name
14545	*
14546	* parse an XML file and call the given SAX handler routines.
14547	* Automatic support for ZLIB/Compress compressed document is provided
14548	*
14549	* Returns 0 in case of success or a error number otherwise
14550	*/
14551	int
14552	xmlSAXUserParseFile(xmlSAXHandlerPtr sax, void *user_data,
14553	const char *filename) {
14554	int ret = 0;
14555	xmlParserCtxtPtr ctxt;
14556
14557	ctxt = xmlCreateFileParserCtxt(filename);
14558	if (ctxt == NULL) return -1;
14559	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
14560	xmlFree(ctxt->sax);
14561	ctxt->sax = sax;
14562	xmlDetectSAX2(ctxt);
14563
14564	if (user_data != NULL)
14565	ctxt->userData = user_data;
14566
14567	xmlParseDocument(ctxt);
14568
14569	if (ctxt->wellFormed)
14570	ret = 0;
14571	else {
14572	if (ctxt->errNo != 0)
14573	ret = ctxt->errNo;
14574	else
14575	ret = -1;
14576	}
14577	if (sax != NULL)
14578	ctxt->sax = NULL;
14579	if (ctxt->myDoc != NULL) {
14580	xmlFreeDoc(ctxt->myDoc);
14581	ctxt->myDoc = NULL;
14582	}
14583	xmlFreeParserCtxt(ctxt);
14584
14585	return ret;
14586	}
14587	#endif /* LIBXML_SAX1_ENABLED */
14588
14589	/************************************************************************
14590	* *
14591	* Front ends when parsing from memory *
14592	* *
14593	************************************************************************/
14594
14595	/**
14596	* xmlCreateMemoryParserCtxt:
14597	* @buffer: a pointer to a char array
14598	* @size: the size of the array
14599	*
14600	* Create a parser context for an XML in-memory document.
14601	*
14602	* Returns the new parser context or NULL
14603	*/
14604	xmlParserCtxtPtr
14605	xmlCreateMemoryParserCtxt(const char *buffer, int size) {
14606	xmlParserCtxtPtr ctxt;
14607	xmlParserInputPtr input;
14608	xmlParserInputBufferPtr buf;
14609
14610	if (buffer == NULL)
14611	return(NULL);
14612	if (size <= 0)
14613	return(NULL);
14614
14615	ctxt = xmlNewParserCtxt();
14616	if (ctxt == NULL)
14617	return(NULL);
14618
14619	/* TODO: xmlParserInputBufferCreateStatic, requires some serious changes */
14620	buf = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
14621	if (buf == NULL) {
14622	xmlFreeParserCtxt(ctxt);
14623	return(NULL);
14624	}
14625
14626	input = xmlNewInputStream(ctxt);
14627	if (input == NULL) {
14628	xmlFreeParserInputBuffer(buf);
14629	xmlFreeParserCtxt(ctxt);
14630	return(NULL);
14631	}
14632
14633	input->filename = NULL;
14634	input->buf = buf;
14635	xmlBufResetInput(input->buf->buffer, input);
14636
14637	inputPush(ctxt, input);
14638	return(ctxt);
14639	}
14640
14641	#ifdef LIBXML_SAX1_ENABLED
14642	/**
14643	* xmlSAXParseMemoryWithData:
14644	* @sax: the SAX handler block
14645	* @buffer: an pointer to a char array
14646	* @size: the size of the array
14647	* @recovery: work in recovery mode, i.e. tries to read no Well Formed
14648	* documents
14649	* @data: the userdata
14650	*
14651	* parse an XML in-memory block and use the given SAX function block
14652	* to handle the parsing callback. If sax is NULL, fallback to the default
14653	* DOM tree building routines.
14654	*
14655	* User data (void *) is stored within the parser context in the
14656	* context's _private member, so it is available nearly everywhere in libxml
14657	*
14658	* Returns the resulting document tree
14659	*/
14660
14661	xmlDocPtr
14662	xmlSAXParseMemoryWithData(xmlSAXHandlerPtr sax, const char *buffer,
14663	int size, int recovery, void *data) {
14664	xmlDocPtr ret;
14665	xmlParserCtxtPtr ctxt;
14666
14667	xmlInitParser();
14668
14669	ctxt = xmlCreateMemoryParserCtxt(buffer, size);
14670	if (ctxt == NULL) return(NULL);
14671	if (sax != NULL) {
14672	if (ctxt->sax != NULL)
14673	xmlFree(ctxt->sax);
14674	ctxt->sax = sax;
14675	}
14676	xmlDetectSAX2(ctxt);
14677	if (data!=NULL) {
14678	ctxt->_private=data;
14679	}
14680
14681	ctxt->recovery = recovery;
14682
14683	xmlParseDocument(ctxt);
14684
14685	if ((ctxt->wellFormed) \|\| recovery) ret = ctxt->myDoc;
14686	else {
14687	ret = NULL;
14688	xmlFreeDoc(ctxt->myDoc);
14689	ctxt->myDoc = NULL;
14690	}
14691	if (sax != NULL)
14692	ctxt->sax = NULL;
14693	xmlFreeParserCtxt(ctxt);
14694
14695	return(ret);
14696	}
14697
14698	/**
14699	* xmlSAXParseMemory:
14700	* @sax: the SAX handler block
14701	* @buffer: an pointer to a char array
14702	* @size: the size of the array
14703	* @recovery: work in recovery mode, i.e. tries to read not Well Formed
14704	* documents
14705	*
14706	* parse an XML in-memory block and use the given SAX function block
14707	* to handle the parsing callback. If sax is NULL, fallback to the default
14708	* DOM tree building routines.
14709	*
14710	* Returns the resulting document tree
14711	*/
14712	xmlDocPtr
14713	xmlSAXParseMemory(xmlSAXHandlerPtr sax, const char *buffer,
14714	int size, int recovery) {
14715	return xmlSAXParseMemoryWithData(sax, buffer, size, recovery, NULL);
14716	}
14717
14718	/**
14719	* xmlParseMemory:
14720	* @buffer: an pointer to a char array
14721	* @size: the size of the array
14722	*
14723	* parse an XML in-memory block and build a tree.
14724	*
14725	* Returns the resulting document tree
14726	*/
14727
14728	xmlDocPtr xmlParseMemory(const char *buffer, int size) {
14729	return(xmlSAXParseMemory(NULL, buffer, size, 0));
14730	}
14731
14732	/**
14733	* xmlRecoverMemory:
14734	* @buffer: an pointer to a char array
14735	* @size: the size of the array
14736	*
14737	* parse an XML in-memory block and build a tree.
14738	* In the case the document is not Well Formed, an attempt to
14739	* build a tree is tried anyway
14740	*
14741	* Returns the resulting document tree or NULL in case of error
14742	*/
14743
14744	xmlDocPtr xmlRecoverMemory(const char *buffer, int size) {
14745	return(xmlSAXParseMemory(NULL, buffer, size, 1));
14746	}
14747
14748	/**
14749	* xmlSAXUserParseMemory:
14750	* @sax: a SAX handler
14751	* @user_data: The user data returned on SAX callbacks
14752	* @buffer: an in-memory XML document input
14753	* @size: the length of the XML document in bytes
14754	*
14755	* A better SAX parsing routine.
14756	* parse an XML in-memory buffer and call the given SAX handler routines.
14757	*
14758	* Returns 0 in case of success or a error number otherwise
14759	*/
14760	int xmlSAXUserParseMemory(xmlSAXHandlerPtr sax, void *user_data,
14761	const char *buffer, int size) {
14762	int ret = 0;
14763	xmlParserCtxtPtr ctxt;
14764
14765	xmlInitParser();
14766
14767	ctxt = xmlCreateMemoryParserCtxt(buffer, size);
14768	if (ctxt == NULL) return -1;
14769	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
14770	xmlFree(ctxt->sax);
14771	ctxt->sax = sax;
14772	xmlDetectSAX2(ctxt);
14773
14774	if (user_data != NULL)
14775	ctxt->userData = user_data;
14776
14777	xmlParseDocument(ctxt);
14778
14779	if (ctxt->wellFormed)
14780	ret = 0;
14781	else {
14782	if (ctxt->errNo != 0)
14783	ret = ctxt->errNo;
14784	else
14785	ret = -1;
14786	}
14787	if (sax != NULL)
14788	ctxt->sax = NULL;
14789	if (ctxt->myDoc != NULL) {
14790	xmlFreeDoc(ctxt->myDoc);
14791	ctxt->myDoc = NULL;
14792	}
14793	xmlFreeParserCtxt(ctxt);
14794
14795	return ret;
14796	}
14797	#endif /* LIBXML_SAX1_ENABLED */
14798
14799	/**
14800	* xmlCreateDocParserCtxt:
14801	* @cur: a pointer to an array of xmlChar
14802	*
14803	* Creates a parser context for an XML in-memory document.
14804	*
14805	* Returns the new parser context or NULL
14806	*/
14807	xmlParserCtxtPtr
14808	xmlCreateDocParserCtxt(const xmlChar *cur) {
14809	int len;
14810
14811	if (cur == NULL)
14812	return(NULL);
14813	len = xmlStrlen(cur);
14814	return(xmlCreateMemoryParserCtxt((const char *)cur, len));
14815	}
14816
14817	#ifdef LIBXML_SAX1_ENABLED
14818	/**
14819	* xmlSAXParseDoc:
14820	* @sax: the SAX handler block
14821	* @cur: a pointer to an array of xmlChar
14822	* @recovery: work in recovery mode, i.e. tries to read no Well Formed
14823	* documents
14824	*
14825	* parse an XML in-memory document and build a tree.
14826	* It use the given SAX function block to handle the parsing callback.
14827	* If sax is NULL, fallback to the default DOM tree building routines.
14828	*
14829	* Returns the resulting document tree
14830	*/
14831
14832	xmlDocPtr
14833	xmlSAXParseDoc(xmlSAXHandlerPtr sax, const xmlChar *cur, int recovery) {
14834	xmlDocPtr ret;
14835	xmlParserCtxtPtr ctxt;
14836	xmlSAXHandlerPtr oldsax = NULL;
14837
14838	if (cur == NULL) return(NULL);
14839
14840
14841	ctxt = xmlCreateDocParserCtxt(cur);
14842	if (ctxt == NULL) return(NULL);
14843	if (sax != NULL) {
14844	oldsax = ctxt->sax;
14845	ctxt->sax = sax;
14846	ctxt->userData = NULL;
14847	}
14848	xmlDetectSAX2(ctxt);
14849
14850	xmlParseDocument(ctxt);
14851	if ((ctxt->wellFormed) \|\| recovery) ret = ctxt->myDoc;
14852	else {
14853	ret = NULL;
14854	xmlFreeDoc(ctxt->myDoc);
14855	ctxt->myDoc = NULL;
14856	}
14857	if (sax != NULL)
14858	ctxt->sax = oldsax;
14859	xmlFreeParserCtxt(ctxt);
14860
14861	return(ret);
14862	}
14863
14864	/**
14865	* xmlParseDoc:
14866	* @cur: a pointer to an array of xmlChar
14867	*
14868	* parse an XML in-memory document and build a tree.
14869	*
14870	* Returns the resulting document tree
14871	*/
14872
14873	xmlDocPtr
14874	xmlParseDoc(const xmlChar *cur) {
14875	return(xmlSAXParseDoc(NULL, cur, 0));
14876	}
14877	#endif /* LIBXML_SAX1_ENABLED */
14878
14879	#ifdef LIBXML_LEGACY_ENABLED
14880	/************************************************************************
14881	* *
14882	* Specific function to keep track of entities references *
14883	* and used by the XSLT debugger *
14884	* *
14885	************************************************************************/
14886
14887	static xmlEntityReferenceFunc xmlEntityRefFunc = NULL;
14888
14889	/**
14890	* xmlAddEntityReference:
14891	* @ent : A valid entity
14892	* @firstNode : A valid first node for children of entity
14893	* @lastNode : A valid last node of children entity
14894	*
14895	* Notify of a reference to an entity of type XML_EXTERNAL_GENERAL_PARSED_ENTITY
14896	*/
14897	static void
14898	xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
14899	xmlNodePtr lastNode)
14900	{
14901	if (xmlEntityRefFunc != NULL) {
14902	(*xmlEntityRefFunc) (ent, firstNode, lastNode);
14903	}
14904	}
14905
14906
14907	/**
14908	* xmlSetEntityReferenceFunc:
14909	* @func: A valid function
14910	*
14911	* Set the function to call call back when a xml reference has been made
14912	*/
14913	void
14914	xmlSetEntityReferenceFunc(xmlEntityReferenceFunc func)
14915	{
14916	xmlEntityRefFunc = func;
14917	}
14918	#endif /* LIBXML_LEGACY_ENABLED */
14919
14920	/************************************************************************
14921	* *
14922	* Miscellaneous *
14923	* *
14924	************************************************************************/
14925
14926	#ifdef LIBXML_XPATH_ENABLED
14927	#include <libxml/xpath.h>
14928	#endif
14929
14930	extern void XMLCDECL xmlGenericErrorDefaultFunc(void ctx, const char msg, ...);
14931	static int xmlParserInitialized = 0;
14932
14933	/**
14934	* xmlInitParser:
14935	*
14936	* Initialization function for the XML parser.
14937	* This is not reentrant. Call once before processing in case of
14938	* use in multithreaded programs.
14939	*/
14940
14941	void
14942	xmlInitParser(void) {
14943	if (xmlParserInitialized != 0)
14944	return;
14945
14946	#ifdef LIBXML_THREAD_ENABLED
14947	__xmlGlobalInitMutexLock();
14948	if (xmlParserInitialized == 0) {
14949	#endif
14950	xmlInitThreads();
14951	xmlInitGlobals();
14952	if ((xmlGenericError == xmlGenericErrorDefaultFunc) \|\|
14953	(xmlGenericError == NULL))
14954	initGenericErrorDefaultFunc(NULL);
14955	xmlInitMemory();
14956	xmlInitializeDict();
14957	xmlInitCharEncodingHandlers();
14958	xmlDefaultSAXHandlerInit();
14959	xmlRegisterDefaultInputCallbacks();
14960	#ifdef LIBXML_OUTPUT_ENABLED
14961	xmlRegisterDefaultOutputCallbacks();
14962	#endif /* LIBXML_OUTPUT_ENABLED */
14963	#ifdef LIBXML_HTML_ENABLED
14964	htmlInitAutoClose();
14965	htmlDefaultSAXHandlerInit();
14966	#endif
14967	#ifdef LIBXML_XPATH_ENABLED
14968	xmlXPathInit();
14969	#endif
14970	xmlParserInitialized = 1;
14971	#ifdef LIBXML_THREAD_ENABLED
14972	}
14973	__xmlGlobalInitMutexUnlock();
14974	#endif
14975	}
14976
14977	/**
14978	* xmlCleanupParser:
14979	*
14980	* This function name is somewhat misleading. It does not clean up
14981	* parser state, it cleans up memory allocated by the library itself.
14982	* It is a cleanup function for the XML library. It tries to reclaim all
14983	* related global memory allocated for the library processing.
14984	* It doesn't deallocate any document related memory. One should
14985	* call xmlCleanupParser() only when the process has finished using
14986	* the library and all XML/HTML documents built with it.
14987	* See also xmlInitParser() which has the opposite function of preparing
14988	* the library for operations.
14989	*
14990	* WARNING: if your application is multithreaded or has plugin support
14991	* calling this may crash the application if another thread or
14992	* a plugin is still using libxml2. It's sometimes very hard to
14993	* guess if libxml2 is in use in the application, some libraries
14994	* or plugins may use it without notice. In case of doubt abstain
14995	* from calling this function or do it just before calling exit()
14996	* to avoid leak reports from valgrind !
14997	*/
14998
14999	void
15000	xmlCleanupParser(void) {
15001	if (!xmlParserInitialized)
15002	return;
15003
15004	xmlCleanupCharEncodingHandlers();
15005	#ifdef LIBXML_CATALOG_ENABLED
15006	xmlCatalogCleanup();
15007	#endif
15008	xmlDictCleanup();
15009	xmlCleanupInputCallbacks();
15010	#ifdef LIBXML_OUTPUT_ENABLED
15011	xmlCleanupOutputCallbacks();
15012	#endif
15013	#ifdef LIBXML_SCHEMAS_ENABLED
15014	xmlSchemaCleanupTypes();
15015	xmlRelaxNGCleanupTypes();
15016	#endif
15017	xmlResetLastError();
15018	xmlCleanupGlobals();
15019	xmlCleanupThreads(); /* must be last if called not from the main thread */
15020	xmlCleanupMemory();
15021	xmlParserInitialized = 0;
15022	}
15023
15024	/************************************************************************
15025	* *
15026	* New set (2.6.0) of simpler and more flexible APIs *
15027	* *
15028	************************************************************************/
15029
15030	/**
15031	* DICT_FREE:
15032	* @str: a string
15033	*
15034	* Free a string if it is not owned by the "dict" dictionary in the
15035	* current scope
15036	*/
15037	#define DICT_FREE(str) \
15038	if ((str) && ((!dict) \|\| \
15039	(xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \
15040	xmlFree((char *)(str));
15041
15042	/**
15043	* xmlCtxtReset:
15044	* @ctxt: an XML parser context
15045	*
15046	* Reset a parser context
15047	*/
15048	void
15049	xmlCtxtReset(xmlParserCtxtPtr ctxt)
15050	{
15051	xmlParserInputPtr input;
15052	xmlDictPtr dict;
15053
15054	if (ctxt == NULL)
15055	return;
15056
15057	dict = ctxt->dict;
15058
15059	while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
15060	xmlFreeInputStream(input);
15061	}
15062	ctxt->inputNr = 0;
15063	ctxt->input = NULL;
15064
15065	ctxt->spaceNr = 0;
15066	if (ctxt->spaceTab != NULL) {
15067	ctxt->spaceTab[0] = -1;
15068	ctxt->space = &ctxt->spaceTab[0];
15069	} else {
15070	ctxt->space = NULL;
15071	}
15072
15073
15074	ctxt->nodeNr = 0;
15075	ctxt->node = NULL;
15076
15077	ctxt->nameNr = 0;
15078	ctxt->name = NULL;
15079
15080	DICT_FREE(ctxt->version);
15081	ctxt->version = NULL;
15082	DICT_FREE(ctxt->encoding);
15083	ctxt->encoding = NULL;
15084	DICT_FREE(ctxt->directory);
15085	ctxt->directory = NULL;
15086	DICT_FREE(ctxt->extSubURI);
15087	ctxt->extSubURI = NULL;
15088	DICT_FREE(ctxt->extSubSystem);
15089	ctxt->extSubSystem = NULL;
15090	if (ctxt->myDoc != NULL)
15091	xmlFreeDoc(ctxt->myDoc);
15092	ctxt->myDoc = NULL;
15093
15094	ctxt->standalone = -1;
15095	ctxt->hasExternalSubset = 0;
15096	ctxt->hasPErefs = 0;
15097	ctxt->html = 0;
15098	ctxt->external = 0;
15099	ctxt->instate = XML_PARSER_START;
15100	ctxt->token = 0;
15101
15102	ctxt->wellFormed = 1;
15103	ctxt->nsWellFormed = 1;
15104	ctxt->disableSAX = 0;
15105	ctxt->valid = 1;
15106	#if 0
15107	ctxt->vctxt.userData = ctxt;
15108	ctxt->vctxt.error = xmlParserValidityError;
15109	ctxt->vctxt.warning = xmlParserValidityWarning;
15110	#endif
15111	ctxt->record_info = 0;
15112	ctxt->nbChars = 0;
15113	ctxt->checkIndex = 0;
15114	ctxt->inSubset = 0;
15115	ctxt->errNo = XML_ERR_OK;
15116	ctxt->depth = 0;
15117	ctxt->charset = XML_CHAR_ENCODING_UTF8;
15118	ctxt->catalogs = NULL;
15119	ctxt->nbentities = 0;
15120	ctxt->sizeentities = 0;
15121	ctxt->sizeentcopy = 0;
15122	xmlInitNodeInfoSeq(&ctxt->node_seq);
15123
15124	if (ctxt->attsDefault != NULL) {
15125	xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
15126	ctxt->attsDefault = NULL;
15127	}
15128	if (ctxt->attsSpecial != NULL) {
15129	xmlHashFree(ctxt->attsSpecial, NULL);
15130	ctxt->attsSpecial = NULL;
15131	}
15132
15133	#ifdef LIBXML_CATALOG_ENABLED
15134	if (ctxt->catalogs != NULL)
15135	xmlCatalogFreeLocal(ctxt->catalogs);
15136	#endif
15137	if (ctxt->lastError.code != XML_ERR_OK)
15138	xmlResetError(&ctxt->lastError);
15139	}
15140
15141	/**
15142	* xmlCtxtResetPush:
15143	* @ctxt: an XML parser context
15144	* @chunk: a pointer to an array of chars
15145	* @size: number of chars in the array
15146	* @filename: an optional file name or URI
15147	* @encoding: the document encoding, or NULL
15148	*
15149	* Reset a push parser context
15150	*
15151	* Returns 0 in case of success and 1 in case of error
15152	*/
15153	int
15154	xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk,
15155	int size, const char filename, const char encoding)
15156	{
15157	xmlParserInputPtr inputStream;
15158	xmlParserInputBufferPtr buf;
15159	xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
15160
15161	if (ctxt == NULL)
15162	return(1);
15163
15164	if ((encoding == NULL) && (chunk != NULL) && (size >= 4))
15165	enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
15166
15167	buf = xmlAllocParserInputBuffer(enc);
15168	if (buf == NULL)
15169	return(1);
15170
15171	if (ctxt == NULL) {
15172	xmlFreeParserInputBuffer(buf);
15173	return(1);
15174	}
15175
15176	xmlCtxtReset(ctxt);
15177
15178	if (ctxt->pushTab == NULL) {
15179	ctxt->pushTab = (void *) xmlMalloc(ctxt->nameMax 3 *
15180	sizeof(xmlChar *));
15181	if (ctxt->pushTab == NULL) {
15182	xmlErrMemory(ctxt, NULL);
15183	xmlFreeParserInputBuffer(buf);
15184	return(1);
15185	}
15186	}
15187
15188	if (filename == NULL) {
15189	ctxt->directory = NULL;
15190	} else {
15191	ctxt->directory = xmlParserGetDirectory(filename);
15192	}
15193
15194	inputStream = xmlNewInputStream(ctxt);
15195	if (inputStream == NULL) {
15196	xmlFreeParserInputBuffer(buf);
15197	return(1);
15198	}
15199
15200	if (filename == NULL)
15201	inputStream->filename = NULL;
15202	else
15203	inputStream->filename = (char *)
15204	xmlCanonicPath((const xmlChar *) filename);
15205	inputStream->buf = buf;
15206	xmlBufResetInput(buf->buffer, inputStream);
15207
15208	inputPush(ctxt, inputStream);
15209
15210	if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
15211	(ctxt->input->buf != NULL)) {
15212	size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
15213	size_t cur = ctxt->input->cur - ctxt->input->base;
15214
15215	xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
15216
15217	xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
15218	#ifdef DEBUG_PUSH
15219	xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
15220	#endif
15221	}
15222
15223	if (encoding != NULL) {
15224	xmlCharEncodingHandlerPtr hdlr;
15225
15226	if (ctxt->encoding != NULL)
15227	xmlFree((xmlChar *) ctxt->encoding);
15228	ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
15229
15230	hdlr = xmlFindCharEncodingHandler(encoding);
15231	if (hdlr != NULL) {
15232	xmlSwitchToEncoding(ctxt, hdlr);
15233	} else {
15234	xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
15235	"Unsupported encoding %s\n", BAD_CAST encoding);
15236	}
15237	} else if (enc != XML_CHAR_ENCODING_NONE) {
15238	xmlSwitchEncoding(ctxt, enc);
15239	}
15240
15241	return(0);
15242	}
15243
15244
15245	/**
15246	* xmlCtxtUseOptionsInternal:
15247	* @ctxt: an XML parser context
15248	* @options: a combination of xmlParserOption
15249	* @encoding: the user provided encoding to use
15250	*
15251	* Applies the options to the parser context
15252	*
15253	* Returns 0 in case of success, the set of unknown or unimplemented options
15254	* in case of error.
15255	*/
15256	static int
15257	xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options, const char *encoding)
15258	{
15259	if (ctxt == NULL)
15260	return(-1);
15261	if (encoding != NULL) {
15262	if (ctxt->encoding != NULL)
15263	xmlFree((xmlChar *) ctxt->encoding);
15264	ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
15265	}
15266	if (options & XML_PARSE_RECOVER) {
15267	ctxt->recovery = 1;
15268	options -= XML_PARSE_RECOVER;
15269	ctxt->options \|= XML_PARSE_RECOVER;
15270	} else
15271	ctxt->recovery = 0;
15272	if (options & XML_PARSE_DTDLOAD) {
15273	ctxt->loadsubset = XML_DETECT_IDS;
15274	options -= XML_PARSE_DTDLOAD;
15275	ctxt->options \|= XML_PARSE_DTDLOAD;
15276	} else
15277	ctxt->loadsubset = 0;
15278	if (options & XML_PARSE_DTDATTR) {
15279	ctxt->loadsubset \|= XML_COMPLETE_ATTRS;
15280	options -= XML_PARSE_DTDATTR;
15281	ctxt->options \|= XML_PARSE_DTDATTR;
15282	}
15283	if (options & XML_PARSE_NOENT) {
15284	ctxt->replaceEntities = 1;
15285	/* ctxt->loadsubset \|= XML_DETECT_IDS; */
15286	options -= XML_PARSE_NOENT;
15287	ctxt->options \|= XML_PARSE_NOENT;
15288	} else
15289	ctxt->replaceEntities = 0;
15290	if (options & XML_PARSE_PEDANTIC) {
15291	ctxt->pedantic = 1;
15292	options -= XML_PARSE_PEDANTIC;
15293	ctxt->options \|= XML_PARSE_PEDANTIC;
15294	} else
15295	ctxt->pedantic = 0;
15296	if (options & XML_PARSE_NOBLANKS) {
15297	ctxt->keepBlanks = 0;
15298	ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
15299	options -= XML_PARSE_NOBLANKS;
15300	ctxt->options \|= XML_PARSE_NOBLANKS;
15301	} else
15302	ctxt->keepBlanks = 1;
15303	if (options & XML_PARSE_DTDVALID) {
15304	ctxt->validate = 1;
15305	if (options & XML_PARSE_NOWARNING)
15306	ctxt->vctxt.warning = NULL;
15307	if (options & XML_PARSE_NOERROR)
15308	ctxt->vctxt.error = NULL;
15309	options -= XML_PARSE_DTDVALID;
15310	ctxt->options \|= XML_PARSE_DTDVALID;
15311	} else
15312	ctxt->validate = 0;
15313	if (options & XML_PARSE_NOWARNING) {
15314	ctxt->sax->warning = NULL;
15315	options -= XML_PARSE_NOWARNING;
15316	}
15317	if (options & XML_PARSE_NOERROR) {
15318	ctxt->sax->error = NULL;
15319	ctxt->sax->fatalError = NULL;
15320	options -= XML_PARSE_NOERROR;
15321	}
15322	#ifdef LIBXML_SAX1_ENABLED
15323	if (options & XML_PARSE_SAX1) {
15324	ctxt->sax->startElement = xmlSAX2StartElement;
15325	ctxt->sax->endElement = xmlSAX2EndElement;
15326	ctxt->sax->startElementNs = NULL;
15327	ctxt->sax->endElementNs = NULL;
15328	ctxt->sax->initialized = 1;
15329	options -= XML_PARSE_SAX1;
15330	ctxt->options \|= XML_PARSE_SAX1;
15331	}
15332	#endif /* LIBXML_SAX1_ENABLED */
15333	if (options & XML_PARSE_NODICT) {
15334	ctxt->dictNames = 0;
15335	options -= XML_PARSE_NODICT;
15336	ctxt->options \|= XML_PARSE_NODICT;
15337	} else {
15338	ctxt->dictNames = 1;
15339	}
15340	if (options & XML_PARSE_NOCDATA) {
15341	ctxt->sax->cdataBlock = NULL;
15342	options -= XML_PARSE_NOCDATA;
15343	ctxt->options \|= XML_PARSE_NOCDATA;
15344	}
15345	if (options & XML_PARSE_NSCLEAN) {
15346	ctxt->options \|= XML_PARSE_NSCLEAN;
15347	options -= XML_PARSE_NSCLEAN;
15348	}
15349	if (options & XML_PARSE_NONET) {
15350	ctxt->options \|= XML_PARSE_NONET;
15351	options -= XML_PARSE_NONET;
15352	}
15353	if (options & XML_PARSE_COMPACT) {
15354	ctxt->options \|= XML_PARSE_COMPACT;
15355	options -= XML_PARSE_COMPACT;
15356	}
15357	if (options & XML_PARSE_OLD10) {
15358	ctxt->options \|= XML_PARSE_OLD10;
15359	options -= XML_PARSE_OLD10;
15360	}
15361	if (options & XML_PARSE_NOBASEFIX) {
15362	ctxt->options \|= XML_PARSE_NOBASEFIX;
15363	options -= XML_PARSE_NOBASEFIX;
15364	}
15365	if (options & XML_PARSE_HUGE) {
15366	ctxt->options \|= XML_PARSE_HUGE;
15367	options -= XML_PARSE_HUGE;
15368	if (ctxt->dict != NULL)
15369	xmlDictSetLimit(ctxt->dict, 0);
15370	}
15371	if (options & XML_PARSE_OLDSAX) {
15372	ctxt->options \|= XML_PARSE_OLDSAX;
15373	options -= XML_PARSE_OLDSAX;
15374	}
15375	if (options & XML_PARSE_IGNORE_ENC) {
15376	ctxt->options \|= XML_PARSE_IGNORE_ENC;
15377	options -= XML_PARSE_IGNORE_ENC;
15378	}
15379	if (options & XML_PARSE_BIG_LINES) {
15380	ctxt->options \|= XML_PARSE_BIG_LINES;
15381	options -= XML_PARSE_BIG_LINES;
15382	}
15383	ctxt->linenumbers = 1;
15384	return (options);
15385	}
15386
15387	/**
15388	* xmlCtxtUseOptions:
15389	* @ctxt: an XML parser context
15390	* @options: a combination of xmlParserOption
15391	*
15392	* Applies the options to the parser context
15393	*
15394	* Returns 0 in case of success, the set of unknown or unimplemented options
15395	* in case of error.
15396	*/
15397	int
15398	xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
15399	{
15400	return(xmlCtxtUseOptionsInternal(ctxt, options, NULL));
15401	}
15402
15403	/**
15404	* xmlDoRead:
15405	* @ctxt: an XML parser context
15406	* @URL: the base URL to use for the document
15407	* @encoding: the document encoding, or NULL
15408	* @options: a combination of xmlParserOption
15409	* @reuse: keep the context for reuse
15410	*
15411	* Common front-end for the xmlRead functions
15412	*
15413	* Returns the resulting document tree or NULL
15414	*/
15415	static xmlDocPtr
15416	xmlDoRead(xmlParserCtxtPtr ctxt, const char URL, const char encoding,
15417	int options, int reuse)
15418	{
15419	xmlDocPtr ret;
15420
15421	xmlCtxtUseOptionsInternal(ctxt, options, encoding);
15422	if (encoding != NULL) {
15423	xmlCharEncodingHandlerPtr hdlr;
15424
15425	hdlr = xmlFindCharEncodingHandler(encoding);
15426	if (hdlr != NULL)
15427	xmlSwitchToEncoding(ctxt, hdlr);
15428	}
15429	if ((URL != NULL) && (ctxt->input != NULL) &&
15430	(ctxt->input->filename == NULL))
15431	ctxt->input->filename = (char ) xmlStrdup((const xmlChar ) URL);
15432	xmlParseDocument(ctxt);
15433	if ((ctxt->wellFormed) \|\| ctxt->recovery)
15434	ret = ctxt->myDoc;
15435	else {
15436	ret = NULL;
15437	if (ctxt->myDoc != NULL) {
15438	xmlFreeDoc(ctxt->myDoc);
15439	}
15440	}
15441	ctxt->myDoc = NULL;
15442	if (!reuse) {
15443	xmlFreeParserCtxt(ctxt);
15444	}
15445
15446	return (ret);
15447	}
15448
15449	/**
15450	* xmlReadDoc:
15451	* @cur: a pointer to a zero terminated string
15452	* @URL: the base URL to use for the document
15453	* @encoding: the document encoding, or NULL
15454	* @options: a combination of xmlParserOption
15455	*
15456	* parse an XML in-memory document and build a tree.
15457	*
15458	* Returns the resulting document tree
15459	*/
15460	xmlDocPtr
15461	xmlReadDoc(const xmlChar * cur, const char URL, const char encoding, int options)
15462	{
15463	xmlParserCtxtPtr ctxt;
15464
15465	if (cur == NULL)
15466	return (NULL);
15467	xmlInitParser();
15468
15469	ctxt = xmlCreateDocParserCtxt(cur);
15470	if (ctxt == NULL)
15471	return (NULL);
15472	return (xmlDoRead(ctxt, URL, encoding, options, 0));
15473	}
15474
15475	/**
15476	* xmlReadFile:
15477	* @filename: a file or URL
15478	* @encoding: the document encoding, or NULL
15479	* @options: a combination of xmlParserOption
15480	*
15481	* parse an XML file from the filesystem or the network.
15482	*
15483	* Returns the resulting document tree
15484	*/
15485	xmlDocPtr
15486	xmlReadFile(const char filename, const char encoding, int options)
15487	{
15488	xmlParserCtxtPtr ctxt;
15489
15490	xmlInitParser();
15491	ctxt = xmlCreateURLParserCtxt(filename, options);
15492	if (ctxt == NULL)
15493	return (NULL);
15494	return (xmlDoRead(ctxt, NULL, encoding, options, 0));
15495	}
15496
15497	/**
15498	* xmlReadMemory:
15499	* @buffer: a pointer to a char array
15500	* @size: the size of the array
15501	* @URL: the base URL to use for the document
15502	* @encoding: the document encoding, or NULL
15503	* @options: a combination of xmlParserOption
15504	*
15505	* parse an XML in-memory document and build a tree.
15506	*
15507	* Returns the resulting document tree
15508	*/
15509	xmlDocPtr
15510	xmlReadMemory(const char buffer, int size, const char URL, const char *encoding, int options)
15511	{
15512	xmlParserCtxtPtr ctxt;
15513
15514	xmlInitParser();
15515	ctxt = xmlCreateMemoryParserCtxt(buffer, size);
15516	if (ctxt == NULL)
15517	return (NULL);
15518	return (xmlDoRead(ctxt, URL, encoding, options, 0));
15519	}
15520
15521	/**
15522	* xmlReadFd:
15523	* @fd: an open file descriptor
15524	* @URL: the base URL to use for the document
15525	* @encoding: the document encoding, or NULL
15526	* @options: a combination of xmlParserOption
15527	*
15528	* parse an XML from a file descriptor and build a tree.
15529	* NOTE that the file descriptor will not be closed when the
15530	* reader is closed or reset.
15531	*
15532	* Returns the resulting document tree
15533	*/
15534	xmlDocPtr
15535	xmlReadFd(int fd, const char URL, const char encoding, int options)
15536	{
15537	xmlParserCtxtPtr ctxt;
15538	xmlParserInputBufferPtr input;
15539	xmlParserInputPtr stream;
15540
15541	if (fd < 0)
15542	return (NULL);
15543	xmlInitParser();
15544
15545	input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
15546	if (input == NULL)
15547	return (NULL);
15548	input->closecallback = NULL;
15549	ctxt = xmlNewParserCtxt();
15550	if (ctxt == NULL) {
15551	xmlFreeParserInputBuffer(input);
15552	return (NULL);
15553	}
15554	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15555	if (stream == NULL) {
15556	xmlFreeParserInputBuffer(input);
15557	xmlFreeParserCtxt(ctxt);
15558	return (NULL);
15559	}
15560	inputPush(ctxt, stream);
15561	return (xmlDoRead(ctxt, URL, encoding, options, 0));
15562	}
15563
15564	/**
15565	* xmlReadIO:
15566	* @ioread: an I/O read function
15567	* @ioclose: an I/O close function
15568	* @ioctx: an I/O handler
15569	* @URL: the base URL to use for the document
15570	* @encoding: the document encoding, or NULL
15571	* @options: a combination of xmlParserOption
15572	*
15573	* parse an XML document from I/O functions and source and build a tree.
15574	*
15575	* Returns the resulting document tree
15576	*/
15577	xmlDocPtr
15578	xmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
15579	void ioctx, const char URL, const char *encoding, int options)
15580	{
15581	xmlParserCtxtPtr ctxt;
15582	xmlParserInputBufferPtr input;
15583	xmlParserInputPtr stream;
15584
15585	if (ioread == NULL)
15586	return (NULL);
15587	xmlInitParser();
15588
15589	input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
15590	XML_CHAR_ENCODING_NONE);
15591	if (input == NULL) {
15592	if (ioclose != NULL)
15593	ioclose(ioctx);
15594	return (NULL);
15595	}
15596	ctxt = xmlNewParserCtxt();
15597	if (ctxt == NULL) {
15598	xmlFreeParserInputBuffer(input);
15599	return (NULL);
15600	}
15601	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15602	if (stream == NULL) {
15603	xmlFreeParserInputBuffer(input);
15604	xmlFreeParserCtxt(ctxt);
15605	return (NULL);
15606	}
15607	inputPush(ctxt, stream);
15608	return (xmlDoRead(ctxt, URL, encoding, options, 0));
15609	}
15610
15611	/**
15612	* xmlCtxtReadDoc:
15613	* @ctxt: an XML parser context
15614	* @cur: a pointer to a zero terminated string
15615	* @URL: the base URL to use for the document
15616	* @encoding: the document encoding, or NULL
15617	* @options: a combination of xmlParserOption
15618	*
15619	* parse an XML in-memory document and build a tree.
15620	* This reuses the existing @ctxt parser context
15621	*
15622	* Returns the resulting document tree
15623	*/
15624	xmlDocPtr
15625	xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur,
15626	const char URL, const char encoding, int options)
15627	{
15628	xmlParserInputPtr stream;
15629
15630	if (cur == NULL)
15631	return (NULL);
15632	if (ctxt == NULL)
15633	return (NULL);
15634	xmlInitParser();
15635
15636	xmlCtxtReset(ctxt);
15637
15638	stream = xmlNewStringInputStream(ctxt, cur);
15639	if (stream == NULL) {
15640	return (NULL);
15641	}
15642	inputPush(ctxt, stream);
15643	return (xmlDoRead(ctxt, URL, encoding, options, 1));
15644	}
15645
15646	/**
15647	* xmlCtxtReadFile:
15648	* @ctxt: an XML parser context
15649	* @filename: a file or URL
15650	* @encoding: the document encoding, or NULL
15651	* @options: a combination of xmlParserOption
15652	*
15653	* parse an XML file from the filesystem or the network.
15654	* This reuses the existing @ctxt parser context
15655	*
15656	* Returns the resulting document tree
15657	*/
15658	xmlDocPtr
15659	xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename,
15660	const char *encoding, int options)
15661	{
15662	xmlParserInputPtr stream;
15663
15664	if (filename == NULL)
15665	return (NULL);
15666	if (ctxt == NULL)
15667	return (NULL);
15668	xmlInitParser();
15669
15670	xmlCtxtReset(ctxt);
15671
15672	stream = xmlLoadExternalEntity(filename, NULL, ctxt);
15673	if (stream == NULL) {
15674	return (NULL);
15675	}
15676	inputPush(ctxt, stream);
15677	return (xmlDoRead(ctxt, NULL, encoding, options, 1));
15678	}
15679
15680	/**
15681	* xmlCtxtReadMemory:
15682	* @ctxt: an XML parser context
15683	* @buffer: a pointer to a char array
15684	* @size: the size of the array
15685	* @URL: the base URL to use for the document
15686	* @encoding: the document encoding, or NULL
15687	* @options: a combination of xmlParserOption
15688	*
15689	* parse an XML in-memory document and build a tree.
15690	* This reuses the existing @ctxt parser context
15691	*
15692	* Returns the resulting document tree
15693	*/
15694	xmlDocPtr
15695	xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size,
15696	const char URL, const char encoding, int options)
15697	{
15698	xmlParserInputBufferPtr input;
15699	xmlParserInputPtr stream;
15700
15701	if (ctxt == NULL)
15702	return (NULL);
15703	if (buffer == NULL)
15704	return (NULL);
15705	xmlInitParser();
15706
15707	xmlCtxtReset(ctxt);
15708
15709	input = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
15710	if (input == NULL) {
15711	return(NULL);
15712	}
15713
15714	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15715	if (stream == NULL) {
15716	xmlFreeParserInputBuffer(input);
15717	return(NULL);
15718	}
15719
15720	inputPush(ctxt, stream);
15721	return (xmlDoRead(ctxt, URL, encoding, options, 1));
15722	}
15723
15724	/**
15725	* xmlCtxtReadFd:
15726	* @ctxt: an XML parser context
15727	* @fd: an open file descriptor
15728	* @URL: the base URL to use for the document
15729	* @encoding: the document encoding, or NULL
15730	* @options: a combination of xmlParserOption
15731	*
15732	* parse an XML from a file descriptor and build a tree.
15733	* This reuses the existing @ctxt parser context
15734	* NOTE that the file descriptor will not be closed when the
15735	* reader is closed or reset.
15736	*
15737	* Returns the resulting document tree
15738	*/
15739	xmlDocPtr
15740	xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd,
15741	const char URL, const char encoding, int options)
15742	{
15743	xmlParserInputBufferPtr input;
15744	xmlParserInputPtr stream;
15745
15746	if (fd < 0)
15747	return (NULL);
15748	if (ctxt == NULL)
15749	return (NULL);
15750	xmlInitParser();
15751
15752	xmlCtxtReset(ctxt);
15753
15754
15755	input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
15756	if (input == NULL)
15757	return (NULL);
15758	input->closecallback = NULL;
15759	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15760	if (stream == NULL) {
15761	xmlFreeParserInputBuffer(input);
15762	return (NULL);
15763	}
15764	inputPush(ctxt, stream);
15765	return (xmlDoRead(ctxt, URL, encoding, options, 1));
15766	}
15767
15768	/**
15769	* xmlCtxtReadIO:
15770	* @ctxt: an XML parser context
15771	* @ioread: an I/O read function
15772	* @ioclose: an I/O close function
15773	* @ioctx: an I/O handler
15774	* @URL: the base URL to use for the document
15775	* @encoding: the document encoding, or NULL
15776	* @options: a combination of xmlParserOption
15777	*
15778	* parse an XML document from I/O functions and source and build a tree.
15779	* This reuses the existing @ctxt parser context
15780	*
15781	* Returns the resulting document tree
15782	*/
15783	xmlDocPtr
15784	xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
15785	xmlInputCloseCallback ioclose, void *ioctx,
15786	const char *URL,
15787	const char *encoding, int options)
15788	{
15789	xmlParserInputBufferPtr input;
15790	xmlParserInputPtr stream;
15791
15792	if (ioread == NULL)
15793	return (NULL);
15794	if (ctxt == NULL)
15795	return (NULL);
15796	xmlInitParser();
15797
15798	xmlCtxtReset(ctxt);
15799
15800	input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
15801	XML_CHAR_ENCODING_NONE);
15802	if (input == NULL) {
15803	if (ioclose != NULL)
15804	ioclose(ioctx);
15805	return (NULL);
15806	}
15807	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15808	if (stream == NULL) {
15809	xmlFreeParserInputBuffer(input);
15810	return (NULL);
15811	}
15812	inputPush(ctxt, stream);
15813	return (xmlDoRead(ctxt, URL, encoding, options, 1));
15814	}
15815
15816	#define bottom_parser
15817	#include "elfgcchack.h"

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

source: vbox/trunk/src/libs/libxml2-2.9.4/parser.c@ 93943

Download in other formats: