parser.c@ 24225

Last change on this file since 24225 was 22405, checked in by vboxsync, 15 years ago
libxml2: fixes from upstream
Property svn:eol-style set to `native` Property svn:keywords set to `Date Revision Author Id`
File size: 367.2 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	* [email protected]
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 <string.h>
44	#include <stdarg.h>
45	#include <libxml/xmlmemory.h>
46	#include <libxml/threads.h>
47	#include <libxml/globals.h>
48	#include <libxml/tree.h>
49	#include <libxml/parser.h>
50	#include <libxml/parserInternals.h>
51	#include <libxml/valid.h>
52	#include <libxml/entities.h>
53	#include <libxml/xmlerror.h>
54	#include <libxml/encoding.h>
55	#include <libxml/xmlIO.h>
56	#include <libxml/uri.h>
57	#ifdef LIBXML_CATALOG_ENABLED
58	#include <libxml/catalog.h>
59	#endif
60	#ifdef LIBXML_SCHEMAS_ENABLED
61	#include <libxml/xmlschemastypes.h>
62	#include <libxml/relaxng.h>
63	#endif
64	#ifdef HAVE_CTYPE_H
65	#include <ctype.h>
66	#endif
67	#ifdef HAVE_STDLIB_H
68	#include <stdlib.h>
69	#endif
70	#ifdef HAVE_SYS_STAT_H
71	#include <sys/stat.h>
72	#endif
73	#ifdef HAVE_FCNTL_H
74	#include <fcntl.h>
75	#endif
76	#ifdef HAVE_UNISTD_H
77	#include <unistd.h>
78	#endif
79	#ifdef HAVE_ZLIB_H
80	#include <zlib.h>
81	#endif
82
83	/**
84	* xmlParserMaxDepth:
85	*
86	* arbitrary depth limit for the XML documents that we allow to
87	* process. This is not a limitation of the parser but a safety
88	* boundary feature.
89	*/
90	unsigned int xmlParserMaxDepth = 1024;
91
92	#define SAX2 1
93
94	#define XML_PARSER_BIG_BUFFER_SIZE 300
95	#define XML_PARSER_BUFFER_SIZE 100
96
97	#define SAX_COMPAT_MODE BAD_CAST "SAX compatibility mode document"
98
99	/*
100	* List of XML prefixed PI allowed by W3C specs
101	*/
102
103	static const char *xmlW3CPIs[] = {
104	"xml-stylesheet",
105	NULL
106	};
107
108
109	/* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */
110	xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,
111	const xmlChar **str);
112
113	static xmlParserErrors
114	xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
115	xmlSAXHandlerPtr sax,
116	void user_data, int depth, const xmlChar URL,
117	const xmlChar ID, xmlNodePtr list);
118
119	#ifdef LIBXML_LEGACY_ENABLED
120	static void
121	xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
122	xmlNodePtr lastNode);
123	#endif /* LIBXML_LEGACY_ENABLED */
124
125	static xmlParserErrors
126	xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
127	const xmlChar string, void user_data, xmlNodePtr *lst);
128
129	/************************************************************************
130	* *
131	* Some factorized error routines *
132	* *
133	************************************************************************/
134
135	/**
136	* xmlErrAttributeDup:
137	* @ctxt: an XML parser context
138	* @prefix: the attribute prefix
139	* @localname: the attribute localname
140	*
141	* Handle a redefinition of attribute error
142	*/
143	static void
144	xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix,
145	const xmlChar * localname)
146	{
147	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
148	(ctxt->instate == XML_PARSER_EOF))
149	return;
150	if (ctxt != NULL)
151	ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
152	if (prefix == NULL)
153	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
154	ctxt->errNo, XML_ERR_FATAL, NULL, 0,
155	(const char *) localname, NULL, NULL, 0, 0,
156	"Attribute %s redefined\n", localname);
157	else
158	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
159	ctxt->errNo, XML_ERR_FATAL, NULL, 0,
160	(const char ) prefix, (const char ) localname,
161	NULL, 0, 0, "Attribute %s:%s redefined\n", prefix,
162	localname);
163	if (ctxt != NULL) {
164	ctxt->wellFormed = 0;
165	if (ctxt->recovery == 0)
166	ctxt->disableSAX = 1;
167	}
168	}
169
170	/**
171	* xmlFatalErr:
172	* @ctxt: an XML parser context
173	* @error: the error number
174	* @extra: extra information string
175	*
176	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
177	*/
178	static void
179	xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info)
180	{
181	const char *errmsg;
182
183	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
184	(ctxt->instate == XML_PARSER_EOF))
185	return;
186	switch (error) {
187	case XML_ERR_INVALID_HEX_CHARREF:
188	errmsg = "CharRef: invalid hexadecimal value\n";
189	break;
190	case XML_ERR_INVALID_DEC_CHARREF:
191	errmsg = "CharRef: invalid decimal value\n";
192	break;
193	case XML_ERR_INVALID_CHARREF:
194	errmsg = "CharRef: invalid value\n";
195	break;
196	case XML_ERR_INTERNAL_ERROR:
197	errmsg = "internal error";
198	break;
199	case XML_ERR_PEREF_AT_EOF:
200	errmsg = "PEReference at end of document\n";
201	break;
202	case XML_ERR_PEREF_IN_PROLOG:
203	errmsg = "PEReference in prolog\n";
204	break;
205	case XML_ERR_PEREF_IN_EPILOG:
206	errmsg = "PEReference in epilog\n";
207	break;
208	case XML_ERR_PEREF_NO_NAME:
209	errmsg = "PEReference: no name\n";
210	break;
211	case XML_ERR_PEREF_SEMICOL_MISSING:
212	errmsg = "PEReference: expecting ';'\n";
213	break;
214	case XML_ERR_ENTITY_LOOP:
215	errmsg = "Detected an entity reference loop\n";
216	break;
217	case XML_ERR_ENTITY_NOT_STARTED:
218	errmsg = "EntityValue: \" or ' expected\n";
219	break;
220	case XML_ERR_ENTITY_PE_INTERNAL:
221	errmsg = "PEReferences forbidden in internal subset\n";
222	break;
223	case XML_ERR_ENTITY_NOT_FINISHED:
224	errmsg = "EntityValue: \" or ' expected\n";
225	break;
226	case XML_ERR_ATTRIBUTE_NOT_STARTED:
227	errmsg = "AttValue: \" or ' expected\n";
228	break;
229	case XML_ERR_LT_IN_ATTRIBUTE:
230	errmsg = "Unescaped '<' not allowed in attributes values\n";
231	break;
232	case XML_ERR_LITERAL_NOT_STARTED:
233	errmsg = "SystemLiteral \" or ' expected\n";
234	break;
235	case XML_ERR_LITERAL_NOT_FINISHED:
236	errmsg = "Unfinished System or Public ID \" or ' expected\n";
237	break;
238	case XML_ERR_MISPLACED_CDATA_END:
239	errmsg = "Sequence ']]>' not allowed in content\n";
240	break;
241	case XML_ERR_URI_REQUIRED:
242	errmsg = "SYSTEM or PUBLIC, the URI is missing\n";
243	break;
244	case XML_ERR_PUBID_REQUIRED:
245	errmsg = "PUBLIC, the Public Identifier is missing\n";
246	break;
247	case XML_ERR_HYPHEN_IN_COMMENT:
248	errmsg = "Comment must not contain '--' (double-hyphen)\n";
249	break;
250	case XML_ERR_PI_NOT_STARTED:
251	errmsg = "xmlParsePI : no target name\n";
252	break;
253	case XML_ERR_RESERVED_XML_NAME:
254	errmsg = "Invalid PI name\n";
255	break;
256	case XML_ERR_NOTATION_NOT_STARTED:
257	errmsg = "NOTATION: Name expected here\n";
258	break;
259	case XML_ERR_NOTATION_NOT_FINISHED:
260	errmsg = "'>' required to close NOTATION declaration\n";
261	break;
262	case XML_ERR_VALUE_REQUIRED:
263	errmsg = "Entity value required\n";
264	break;
265	case XML_ERR_URI_FRAGMENT:
266	errmsg = "Fragment not allowed";
267	break;
268	case XML_ERR_ATTLIST_NOT_STARTED:
269	errmsg = "'(' required to start ATTLIST enumeration\n";
270	break;
271	case XML_ERR_NMTOKEN_REQUIRED:
272	errmsg = "NmToken expected in ATTLIST enumeration\n";
273	break;
274	case XML_ERR_ATTLIST_NOT_FINISHED:
275	errmsg = "')' required to finish ATTLIST enumeration\n";
276	break;
277	case XML_ERR_MIXED_NOT_STARTED:
278	errmsg = "MixedContentDecl : '\|' or ')*' expected\n";
279	break;
280	case XML_ERR_PCDATA_REQUIRED:
281	errmsg = "MixedContentDecl : '#PCDATA' expected\n";
282	break;
283	case XML_ERR_ELEMCONTENT_NOT_STARTED:
284	errmsg = "ContentDecl : Name or '(' expected\n";
285	break;
286	case XML_ERR_ELEMCONTENT_NOT_FINISHED:
287	errmsg = "ContentDecl : ',' '\|' or ')' expected\n";
288	break;
289	case XML_ERR_PEREF_IN_INT_SUBSET:
290	errmsg =
291	"PEReference: forbidden within markup decl in internal subset\n";
292	break;
293	case XML_ERR_GT_REQUIRED:
294	errmsg = "expected '>'\n";
295	break;
296	case XML_ERR_CONDSEC_INVALID:
297	errmsg = "XML conditional section '[' expected\n";
298	break;
299	case XML_ERR_EXT_SUBSET_NOT_FINISHED:
300	errmsg = "Content error in the external subset\n";
301	break;
302	case XML_ERR_CONDSEC_INVALID_KEYWORD:
303	errmsg =
304	"conditional section INCLUDE or IGNORE keyword expected\n";
305	break;
306	case XML_ERR_CONDSEC_NOT_FINISHED:
307	errmsg = "XML conditional section not closed\n";
308	break;
309	case XML_ERR_XMLDECL_NOT_STARTED:
310	errmsg = "Text declaration '<?xml' required\n";
311	break;
312	case XML_ERR_XMLDECL_NOT_FINISHED:
313	errmsg = "parsing XML declaration: '?>' expected\n";
314	break;
315	case XML_ERR_EXT_ENTITY_STANDALONE:
316	errmsg = "external parsed entities cannot be standalone\n";
317	break;
318	case XML_ERR_ENTITYREF_SEMICOL_MISSING:
319	errmsg = "EntityRef: expecting ';'\n";
320	break;
321	case XML_ERR_DOCTYPE_NOT_FINISHED:
322	errmsg = "DOCTYPE improperly terminated\n";
323	break;
324	case XML_ERR_LTSLASH_REQUIRED:
325	errmsg = "EndTag: '</' not found\n";
326	break;
327	case XML_ERR_EQUAL_REQUIRED:
328	errmsg = "expected '='\n";
329	break;
330	case XML_ERR_STRING_NOT_CLOSED:
331	errmsg = "String not closed expecting \" or '\n";
332	break;
333	case XML_ERR_STRING_NOT_STARTED:
334	errmsg = "String not started expecting ' or \"\n";
335	break;
336	case XML_ERR_ENCODING_NAME:
337	errmsg = "Invalid XML encoding name\n";
338	break;
339	case XML_ERR_STANDALONE_VALUE:
340	errmsg = "standalone accepts only 'yes' or 'no'\n";
341	break;
342	case XML_ERR_DOCUMENT_EMPTY:
343	errmsg = "Document is empty\n";
344	break;
345	case XML_ERR_DOCUMENT_END:
346	errmsg = "Extra content at the end of the document\n";
347	break;
348	case XML_ERR_NOT_WELL_BALANCED:
349	errmsg = "chunk is not well balanced\n";
350	break;
351	case XML_ERR_EXTRA_CONTENT:
352	errmsg = "extra content at the end of well balanced chunk\n";
353	break;
354	case XML_ERR_VERSION_MISSING:
355	errmsg = "Malformed declaration expecting version\n";
356	break;
357	#if 0
358	case:
359	errmsg = "\n";
360	break;
361	#endif
362	default:
363	errmsg = "Unregistered error message\n";
364	}
365	if (ctxt != NULL)
366	ctxt->errNo = error;
367	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
368	XML_ERR_FATAL, NULL, 0, info, NULL, NULL, 0, 0, errmsg,
369	info);
370	if (ctxt != NULL) {
371	ctxt->wellFormed = 0;
372	if (ctxt->recovery == 0)
373	ctxt->disableSAX = 1;
374	}
375	}
376
377	/**
378	* xmlFatalErrMsg:
379	* @ctxt: an XML parser context
380	* @error: the error number
381	* @msg: the error message
382	*
383	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
384	*/
385	static void
386	xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
387	const char *msg)
388	{
389	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
390	(ctxt->instate == XML_PARSER_EOF))
391	return;
392	if (ctxt != NULL)
393	ctxt->errNo = error;
394	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
395	XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, msg);
396	if (ctxt != NULL) {
397	ctxt->wellFormed = 0;
398	if (ctxt->recovery == 0)
399	ctxt->disableSAX = 1;
400	}
401	}
402
403	/**
404	* xmlWarningMsg:
405	* @ctxt: an XML parser context
406	* @error: the error number
407	* @msg: the error message
408	* @str1: extra data
409	* @str2: extra data
410	*
411	* Handle a warning.
412	*/
413	static void
414	xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
415	const char msg, const xmlChar str1, const xmlChar *str2)
416	{
417	xmlStructuredErrorFunc schannel = NULL;
418
419	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
420	(ctxt->instate == XML_PARSER_EOF))
421	return;
422	if ((ctxt != NULL) && (ctxt->sax != NULL) &&
423	(ctxt->sax->initialized == XML_SAX2_MAGIC))
424	schannel = ctxt->sax->serror;
425	__xmlRaiseError(schannel,
426	(ctxt->sax) ? ctxt->sax->warning : NULL,
427	ctxt->userData,
428	ctxt, NULL, XML_FROM_PARSER, error,
429	XML_ERR_WARNING, NULL, 0,
430	(const char ) str1, (const char ) str2, NULL, 0, 0,
431	msg, (const char ) str1, (const char ) str2);
432	}
433
434	/**
435	* xmlValidityError:
436	* @ctxt: an XML parser context
437	* @error: the error number
438	* @msg: the error message
439	* @str1: extra data
440	*
441	* Handle a validity error.
442	*/
443	static void
444	xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error,
445	const char msg, const xmlChar str1)
446	{
447	xmlStructuredErrorFunc schannel = NULL;
448
449	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
450	(ctxt->instate == XML_PARSER_EOF))
451	return;
452	if (ctxt != NULL) {
453	ctxt->errNo = error;
454	if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
455	schannel = ctxt->sax->serror;
456	}
457	__xmlRaiseError(schannel,
458	ctxt->vctxt.error, ctxt->vctxt.userData,
459	ctxt, NULL, XML_FROM_DTD, error,
460	XML_ERR_ERROR, NULL, 0, (const char *) str1,
461	NULL, NULL, 0, 0,
462	msg, (const char *) str1);
463	if (ctxt != NULL) {
464	ctxt->valid = 0;
465	}
466	}
467
468	/**
469	* xmlFatalErrMsgInt:
470	* @ctxt: an XML parser context
471	* @error: the error number
472	* @msg: the error message
473	* @val: an integer value
474	*
475	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
476	*/
477	static void
478	xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,
479	const char *msg, int val)
480	{
481	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
482	(ctxt->instate == XML_PARSER_EOF))
483	return;
484	if (ctxt != NULL)
485	ctxt->errNo = error;
486	__xmlRaiseError(NULL, NULL, NULL,
487	ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
488	NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
489	if (ctxt != NULL) {
490	ctxt->wellFormed = 0;
491	if (ctxt->recovery == 0)
492	ctxt->disableSAX = 1;
493	}
494	}
495
496	/**
497	* xmlFatalErrMsgStrIntStr:
498	* @ctxt: an XML parser context
499	* @error: the error number
500	* @msg: the error message
501	* @str1: an string info
502	* @val: an integer value
503	* @str2: an string info
504	*
505	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
506	*/
507	static void
508	xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
509	const char msg, const xmlChar str1, int val,
510	const xmlChar *str2)
511	{
512	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
513	(ctxt->instate == XML_PARSER_EOF))
514	return;
515	if (ctxt != NULL)
516	ctxt->errNo = error;
517	__xmlRaiseError(NULL, NULL, NULL,
518	ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
519	NULL, 0, (const char ) str1, (const char ) str2,
520	NULL, val, 0, msg, str1, val, str2);
521	if (ctxt != NULL) {
522	ctxt->wellFormed = 0;
523	if (ctxt->recovery == 0)
524	ctxt->disableSAX = 1;
525	}
526	}
527
528	/**
529	* xmlFatalErrMsgStr:
530	* @ctxt: an XML parser context
531	* @error: the error number
532	* @msg: the error message
533	* @val: a string value
534	*
535	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
536	*/
537	static void
538	xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
539	const char msg, const xmlChar val)
540	{
541	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
542	(ctxt->instate == XML_PARSER_EOF))
543	return;
544	if (ctxt != NULL)
545	ctxt->errNo = error;
546	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
547	XML_FROM_PARSER, error, XML_ERR_FATAL,
548	NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,
549	val);
550	if (ctxt != NULL) {
551	ctxt->wellFormed = 0;
552	if (ctxt->recovery == 0)
553	ctxt->disableSAX = 1;
554	}
555	}
556
557	/**
558	* xmlErrMsgStr:
559	* @ctxt: an XML parser context
560	* @error: the error number
561	* @msg: the error message
562	* @val: a string value
563	*
564	* Handle a non fatal parser error
565	*/
566	static void
567	xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
568	const char msg, const xmlChar val)
569	{
570	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
571	(ctxt->instate == XML_PARSER_EOF))
572	return;
573	if (ctxt != NULL)
574	ctxt->errNo = error;
575	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
576	XML_FROM_PARSER, error, XML_ERR_ERROR,
577	NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,
578	val);
579	}
580
581	/**
582	* xmlNsErr:
583	* @ctxt: an XML parser context
584	* @error: the error number
585	* @msg: the message
586	* @info1: extra information string
587	* @info2: extra information string
588	*
589	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
590	*/
591	static void
592	xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
593	const char *msg,
594	const xmlChar * info1, const xmlChar * info2,
595	const xmlChar * info3)
596	{
597	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
598	(ctxt->instate == XML_PARSER_EOF))
599	return;
600	if (ctxt != NULL)
601	ctxt->errNo = error;
602	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
603	XML_ERR_ERROR, NULL, 0, (const char *) info1,
604	(const char ) info2, (const char ) info3, 0, 0, msg,
605	info1, info2, info3);
606	if (ctxt != NULL)
607	ctxt->nsWellFormed = 0;
608	}
609
610	/************************************************************************
611	* *
612	* Library wide options *
613	* *
614	************************************************************************/
615
616	/**
617	* xmlHasFeature:
618	* @feature: the feature to be examined
619	*
620	* Examines if the library has been compiled with a given feature.
621	*
622	* Returns a non-zero value if the feature exist, otherwise zero.
623	* Returns zero (0) if the feature does not exist or an unknown
624	* unknown feature is requested, non-zero otherwise.
625	*/
626	int
627	xmlHasFeature(xmlFeature feature)
628	{
629	switch (feature) {
630	case XML_WITH_THREAD:
631	#ifdef LIBXML_THREAD_ENABLED
632	return(1);
633	#else
634	return(0);
635	#endif
636	case XML_WITH_TREE:
637	#ifdef LIBXML_TREE_ENABLED
638	return(1);
639	#else
640	return(0);
641	#endif
642	case XML_WITH_OUTPUT:
643	#ifdef LIBXML_OUTPUT_ENABLED
644	return(1);
645	#else
646	return(0);
647	#endif
648	case XML_WITH_PUSH:
649	#ifdef LIBXML_PUSH_ENABLED
650	return(1);
651	#else
652	return(0);
653	#endif
654	case XML_WITH_READER:
655	#ifdef LIBXML_READER_ENABLED
656	return(1);
657	#else
658	return(0);
659	#endif
660	case XML_WITH_PATTERN:
661	#ifdef LIBXML_PATTERN_ENABLED
662	return(1);
663	#else
664	return(0);
665	#endif
666	case XML_WITH_WRITER:
667	#ifdef LIBXML_WRITER_ENABLED
668	return(1);
669	#else
670	return(0);
671	#endif
672	case XML_WITH_SAX1:
673	#ifdef LIBXML_SAX1_ENABLED
674	return(1);
675	#else
676	return(0);
677	#endif
678	case XML_WITH_FTP:
679	#ifdef LIBXML_FTP_ENABLED
680	return(1);
681	#else
682	return(0);
683	#endif
684	case XML_WITH_HTTP:
685	#ifdef LIBXML_HTTP_ENABLED
686	return(1);
687	#else
688	return(0);
689	#endif
690	case XML_WITH_VALID:
691	#ifdef LIBXML_VALID_ENABLED
692	return(1);
693	#else
694	return(0);
695	#endif
696	case XML_WITH_HTML:
697	#ifdef LIBXML_HTML_ENABLED
698	return(1);
699	#else
700	return(0);
701	#endif
702	case XML_WITH_LEGACY:
703	#ifdef LIBXML_LEGACY_ENABLED
704	return(1);
705	#else
706	return(0);
707	#endif
708	case XML_WITH_C14N:
709	#ifdef LIBXML_C14N_ENABLED
710	return(1);
711	#else
712	return(0);
713	#endif
714	case XML_WITH_CATALOG:
715	#ifdef LIBXML_CATALOG_ENABLED
716	return(1);
717	#else
718	return(0);
719	#endif
720	case XML_WITH_XPATH:
721	#ifdef LIBXML_XPATH_ENABLED
722	return(1);
723	#else
724	return(0);
725	#endif
726	case XML_WITH_XPTR:
727	#ifdef LIBXML_XPTR_ENABLED
728	return(1);
729	#else
730	return(0);
731	#endif
732	case XML_WITH_XINCLUDE:
733	#ifdef LIBXML_XINCLUDE_ENABLED
734	return(1);
735	#else
736	return(0);
737	#endif
738	case XML_WITH_ICONV:
739	#ifdef LIBXML_ICONV_ENABLED
740	return(1);
741	#else
742	return(0);
743	#endif
744	case XML_WITH_ISO8859X:
745	#ifdef LIBXML_ISO8859X_ENABLED
746	return(1);
747	#else
748	return(0);
749	#endif
750	case XML_WITH_UNICODE:
751	#ifdef LIBXML_UNICODE_ENABLED
752	return(1);
753	#else
754	return(0);
755	#endif
756	case XML_WITH_REGEXP:
757	#ifdef LIBXML_REGEXP_ENABLED
758	return(1);
759	#else
760	return(0);
761	#endif
762	case XML_WITH_AUTOMATA:
763	#ifdef LIBXML_AUTOMATA_ENABLED
764	return(1);
765	#else
766	return(0);
767	#endif
768	case XML_WITH_EXPR:
769	#ifdef LIBXML_EXPR_ENABLED
770	return(1);
771	#else
772	return(0);
773	#endif
774	case XML_WITH_SCHEMAS:
775	#ifdef LIBXML_SCHEMAS_ENABLED
776	return(1);
777	#else
778	return(0);
779	#endif
780	case XML_WITH_SCHEMATRON:
781	#ifdef LIBXML_SCHEMATRON_ENABLED
782	return(1);
783	#else
784	return(0);
785	#endif
786	case XML_WITH_MODULES:
787	#ifdef LIBXML_MODULES_ENABLED
788	return(1);
789	#else
790	return(0);
791	#endif
792	case XML_WITH_DEBUG:
793	#ifdef LIBXML_DEBUG_ENABLED
794	return(1);
795	#else
796	return(0);
797	#endif
798	case XML_WITH_DEBUG_MEM:
799	#ifdef DEBUG_MEMORY_LOCATION
800	return(1);
801	#else
802	return(0);
803	#endif
804	case XML_WITH_DEBUG_RUN:
805	#ifdef LIBXML_DEBUG_RUNTIME
806	return(1);
807	#else
808	return(0);
809	#endif
810	case XML_WITH_ZLIB:
811	#ifdef LIBXML_ZLIB_ENABLED
812	return(1);
813	#else
814	return(0);
815	#endif
816	default:
817	break;
818	}
819	return(0);
820	}
821
822	/************************************************************************
823	* *
824	* SAX2 defaulted attributes handling *
825	* *
826	************************************************************************/
827
828	/**
829	* xmlDetectSAX2:
830	* @ctxt: an XML parser context
831	*
832	* Do the SAX2 detection and specific intialization
833	*/
834	static void
835	xmlDetectSAX2(xmlParserCtxtPtr ctxt) {
836	if (ctxt == NULL) return;
837	#ifdef LIBXML_SAX1_ENABLED
838	if ((ctxt->sax) && (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
839	((ctxt->sax->startElementNs != NULL) \|\|
840	(ctxt->sax->endElementNs != NULL))) ctxt->sax2 = 1;
841	#else
842	ctxt->sax2 = 1;
843	#endif /* LIBXML_SAX1_ENABLED */
844
845	ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
846	ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
847	ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
848	if ((ctxt->str_xml==NULL) \|\| (ctxt->str_xmlns==NULL) \|\|
849	(ctxt->str_xml_ns == NULL)) {
850	xmlErrMemory(ctxt, NULL);
851	}
852	}
853
854	typedef struct _xmlDefAttrs xmlDefAttrs;
855	typedef xmlDefAttrs *xmlDefAttrsPtr;
856	struct _xmlDefAttrs {
857	int nbAttrs; /* number of defaulted attributes on that element */
858	int maxAttrs; /* the size of the array */
859	const xmlChar values[4]; / array of localname/prefix/values */
860	};
861
862	/**
863	* xmlAddDefAttrs:
864	* @ctxt: an XML parser context
865	* @fullname: the element fullname
866	* @fullattr: the attribute fullname
867	* @value: the attribute value
868	*
869	* Add a defaulted attribute for an element
870	*/
871	static void
872	xmlAddDefAttrs(xmlParserCtxtPtr ctxt,
873	const xmlChar *fullname,
874	const xmlChar *fullattr,
875	const xmlChar *value) {
876	xmlDefAttrsPtr defaults;
877	int len;
878	const xmlChar *name;
879	const xmlChar *prefix;
880
881	if (ctxt->attsDefault == NULL) {
882	ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict);
883	if (ctxt->attsDefault == NULL)
884	goto mem_error;
885	}
886
887	/*
888	* split the element name into prefix:localname , the string found
889	* are within the DTD and then not associated to namespace names.
890	*/
891	name = xmlSplitQName3(fullname, &len);
892	if (name == NULL) {
893	name = xmlDictLookup(ctxt->dict, fullname, -1);
894	prefix = NULL;
895	} else {
896	name = xmlDictLookup(ctxt->dict, name, -1);
897	prefix = xmlDictLookup(ctxt->dict, fullname, len);
898	}
899
900	/*
901	* make sure there is some storage
902	*/
903	defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix);
904	if (defaults == NULL) {
905	defaults = (xmlDefAttrsPtr) xmlMalloc(sizeof(xmlDefAttrs) +
906	(4 * 4) * sizeof(const xmlChar *));
907	if (defaults == NULL)
908	goto mem_error;
909	defaults->nbAttrs = 0;
910	defaults->maxAttrs = 4;
911	xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix, defaults, NULL);
912	} else if (defaults->nbAttrs >= defaults->maxAttrs) {
913	xmlDefAttrsPtr temp;
914
915	temp = (xmlDefAttrsPtr) xmlRealloc(defaults, sizeof(xmlDefAttrs) +
916	(2 * defaults->maxAttrs * 4) * sizeof(const xmlChar *));
917	if (temp == NULL)
918	goto mem_error;
919	defaults = temp;
920	defaults->maxAttrs *= 2;
921	xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix, defaults, NULL);
922	}
923
924	/*
925	* Split the element name into prefix:localname , the string found
926	* are within the DTD and hen not associated to namespace names.
927	*/
928	name = xmlSplitQName3(fullattr, &len);
929	if (name == NULL) {
930	name = xmlDictLookup(ctxt->dict, fullattr, -1);
931	prefix = NULL;
932	} else {
933	name = xmlDictLookup(ctxt->dict, name, -1);
934	prefix = xmlDictLookup(ctxt->dict, fullattr, len);
935	}
936
937	defaults->values[4 * defaults->nbAttrs] = name;
938	defaults->values[4 * defaults->nbAttrs + 1] = prefix;
939	/* intern the string and precompute the end */
940	len = xmlStrlen(value);
941	value = xmlDictLookup(ctxt->dict, value, len);
942	defaults->values[4 * defaults->nbAttrs + 2] = value;
943	defaults->values[4 * defaults->nbAttrs + 3] = value + len;
944	defaults->nbAttrs++;
945
946	return;
947
948	mem_error:
949	xmlErrMemory(ctxt, NULL);
950	return;
951	}
952
953	/**
954	* xmlAddSpecialAttr:
955	* @ctxt: an XML parser context
956	* @fullname: the element fullname
957	* @fullattr: the attribute fullname
958	* @type: the attribute type
959	*
960	* Register that this attribute is not CDATA
961	*/
962	static void
963	xmlAddSpecialAttr(xmlParserCtxtPtr ctxt,
964	const xmlChar *fullname,
965	const xmlChar *fullattr,
966	int type)
967	{
968	if (ctxt->attsSpecial == NULL) {
969	ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict);
970	if (ctxt->attsSpecial == NULL)
971	goto mem_error;
972	}
973
974	xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr,
975	(void *) (long) type);
976	return;
977
978	mem_error:
979	xmlErrMemory(ctxt, NULL);
980	return;
981	}
982
983	/**
984	* xmlCheckLanguageID:
985	* @lang: pointer to the string value
986	*
987	* Checks that the value conforms to the LanguageID production:
988	*
989	* NOTE: this is somewhat deprecated, those productions were removed from
990	* the XML Second edition.
991	*
992	* [33] LanguageID ::= Langcode ('-' Subcode)*
993	* [34] Langcode ::= ISO639Code \| IanaCode \| UserCode
994	* [35] ISO639Code ::= ([a-z] \| [A-Z]) ([a-z] \| [A-Z])
995	* [36] IanaCode ::= ('i' \| 'I') '-' ([a-z] \| [A-Z])+
996	* [37] UserCode ::= ('x' \| 'X') '-' ([a-z] \| [A-Z])+
997	* [38] Subcode ::= ([a-z] \| [A-Z])+
998	*
999	* Returns 1 if correct 0 otherwise
1000	**/
1001	int
1002	xmlCheckLanguageID(const xmlChar * lang)
1003	{
1004	const xmlChar *cur = lang;
1005
1006	if (cur == NULL)
1007	return (0);
1008	if (((cur[0] == 'i') && (cur[1] == '-')) \|\|
1009	((cur[0] == 'I') && (cur[1] == '-'))) {
1010	/*
1011	* IANA code
1012	*/
1013	cur += 2;
1014	while (((cur[0] >= 'A') && (cur[0] <= 'Z')) \|\| /* non input consuming */
1015	((cur[0] >= 'a') && (cur[0] <= 'z')))
1016	cur++;
1017	} else if (((cur[0] == 'x') && (cur[1] == '-')) \|\|
1018	((cur[0] == 'X') && (cur[1] == '-'))) {
1019	/*
1020	* User code
1021	*/
1022	cur += 2;
1023	while (((cur[0] >= 'A') && (cur[0] <= 'Z')) \|\| /* non input consuming */
1024	((cur[0] >= 'a') && (cur[0] <= 'z')))
1025	cur++;
1026	} else if (((cur[0] >= 'A') && (cur[0] <= 'Z')) \|\|
1027	((cur[0] >= 'a') && (cur[0] <= 'z'))) {
1028	/*
1029	* ISO639
1030	*/
1031	cur++;
1032	if (((cur[0] >= 'A') && (cur[0] <= 'Z')) \|\|
1033	((cur[0] >= 'a') && (cur[0] <= 'z')))
1034	cur++;
1035	else
1036	return (0);
1037	} else
1038	return (0);
1039	while (cur[0] != 0) { /* non input consuming */
1040	if (cur[0] != '-')
1041	return (0);
1042	cur++;
1043	if (((cur[0] >= 'A') && (cur[0] <= 'Z')) \|\|
1044	((cur[0] >= 'a') && (cur[0] <= 'z')))
1045	cur++;
1046	else
1047	return (0);
1048	while (((cur[0] >= 'A') && (cur[0] <= 'Z')) \|\| /* non input consuming */
1049	((cur[0] >= 'a') && (cur[0] <= 'z')))
1050	cur++;
1051	}
1052	return (1);
1053	}
1054
1055	/************************************************************************
1056	* *
1057	* Parser stacks related functions and macros *
1058	* *
1059	************************************************************************/
1060
1061	xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,
1062	const xmlChar ** str);
1063
1064	#ifdef SAX2
1065	/**
1066	* nsPush:
1067	* @ctxt: an XML parser context
1068	* @prefix: the namespace prefix or NULL
1069	* @URL: the namespace name
1070	*
1071	* Pushes a new parser namespace on top of the ns stack
1072	*
1073	* Returns -1 in case of error, -2 if the namespace should be discarded
1074	* and the index in the stack otherwise.
1075	*/
1076	static int
1077	nsPush(xmlParserCtxtPtr ctxt, const xmlChar prefix, const xmlChar URL)
1078	{
1079	if (ctxt->options & XML_PARSE_NSCLEAN) {
1080	int i;
1081	for (i = 0;i < ctxt->nsNr;i += 2) {
1082	if (ctxt->nsTab[i] == prefix) {
1083	/* in scope */
1084	if (ctxt->nsTab[i + 1] == URL)
1085	return(-2);
1086	/* out of scope keep it */
1087	break;
1088	}
1089	}
1090	}
1091	if ((ctxt->nsMax == 0) \|\| (ctxt->nsTab == NULL)) {
1092	ctxt->nsMax = 10;
1093	ctxt->nsNr = 0;
1094	ctxt->nsTab = (const xmlChar **)
1095	xmlMalloc(ctxt->nsMax * sizeof(xmlChar *));
1096	if (ctxt->nsTab == NULL) {
1097	xmlErrMemory(ctxt, NULL);
1098	ctxt->nsMax = 0;
1099	return (-1);
1100	}
1101	} else if (ctxt->nsNr >= ctxt->nsMax) {
1102	ctxt->nsMax *= 2;
1103	ctxt->nsTab = (const xmlChar **)
1104	xmlRealloc((char *) ctxt->nsTab,
1105	ctxt->nsMax * sizeof(ctxt->nsTab[0]));
1106	if (ctxt->nsTab == NULL) {
1107	xmlErrMemory(ctxt, NULL);
1108	ctxt->nsMax /= 2;
1109	return (-1);
1110	}
1111	}
1112	ctxt->nsTab[ctxt->nsNr++] = prefix;
1113	ctxt->nsTab[ctxt->nsNr++] = URL;
1114	return (ctxt->nsNr);
1115	}
1116	/**
1117	* nsPop:
1118	* @ctxt: an XML parser context
1119	* @nr: the number to pop
1120	*
1121	* Pops the top @nr parser prefix/namespace from the ns stack
1122	*
1123	* Returns the number of namespaces removed
1124	*/
1125	static int
1126	nsPop(xmlParserCtxtPtr ctxt, int nr)
1127	{
1128	int i;
1129
1130	if (ctxt->nsTab == NULL) return(0);
1131	if (ctxt->nsNr < nr) {
1132	xmlGenericError(xmlGenericErrorContext, "Pbm popping %d NS\n", nr);
1133	nr = ctxt->nsNr;
1134	}
1135	if (ctxt->nsNr <= 0)
1136	return (0);
1137
1138	for (i = 0;i < nr;i++) {
1139	ctxt->nsNr--;
1140	ctxt->nsTab[ctxt->nsNr] = NULL;
1141	}
1142	return(nr);
1143	}
1144	#endif
1145
1146	static int
1147	xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) {
1148	const xmlChar **atts;
1149	int *attallocs;
1150	int maxatts;
1151
1152	if (ctxt->atts == NULL) {
1153	maxatts = 55; /* allow for 10 attrs by default */
1154	atts = (const xmlChar **)
1155	xmlMalloc(maxatts * sizeof(xmlChar *));
1156	if (atts == NULL) goto mem_error;
1157	ctxt->atts = atts;
1158	attallocs = (int ) xmlMalloc((maxatts / 5) sizeof(int));
1159	if (attallocs == NULL) goto mem_error;
1160	ctxt->attallocs = attallocs;
1161	ctxt->maxatts = maxatts;
1162	} else if (nr + 5 > ctxt->maxatts) {
1163	maxatts = (nr + 5) * 2;
1164	atts = (const xmlChar *) xmlRealloc((void ) ctxt->atts,
1165	maxatts * sizeof(const xmlChar *));
1166	if (atts == NULL) goto mem_error;
1167	ctxt->atts = atts;
1168	attallocs = (int ) xmlRealloc((void ) ctxt->attallocs,
1169	(maxatts / 5) * sizeof(int));
1170	if (attallocs == NULL) goto mem_error;
1171	ctxt->attallocs = attallocs;
1172	ctxt->maxatts = maxatts;
1173	}
1174	return(ctxt->maxatts);
1175	mem_error:
1176	xmlErrMemory(ctxt, NULL);
1177	return(-1);
1178	}
1179
1180	/**
1181	* inputPush:
1182	* @ctxt: an XML parser context
1183	* @value: the parser input
1184	*
1185	* Pushes a new parser input on top of the input stack
1186	*
1187	* Returns 0 in case of error, the index in the stack otherwise
1188	*/
1189	int
1190	inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
1191	{
1192	if ((ctxt == NULL) \|\| (value == NULL))
1193	return(0);
1194	if (ctxt->inputNr >= ctxt->inputMax) {
1195	ctxt->inputMax *= 2;
1196	ctxt->inputTab =
1197	(xmlParserInputPtr *) xmlRealloc(ctxt->inputTab,
1198	ctxt->inputMax *
1199	sizeof(ctxt->inputTab[0]));
1200	if (ctxt->inputTab == NULL) {
1201	xmlErrMemory(ctxt, NULL);
1202	return (0);
1203	}
1204	}
1205	ctxt->inputTab[ctxt->inputNr] = value;
1206	ctxt->input = value;
1207	return (ctxt->inputNr++);
1208	}
1209	/**
1210	* inputPop:
1211	* @ctxt: an XML parser context
1212	*
1213	* Pops the top parser input from the input stack
1214	*
1215	* Returns the input just removed
1216	*/
1217	xmlParserInputPtr
1218	inputPop(xmlParserCtxtPtr ctxt)
1219	{
1220	xmlParserInputPtr ret;
1221
1222	if (ctxt == NULL)
1223	return(NULL);
1224	if (ctxt->inputNr <= 0)
1225	return (NULL);
1226	ctxt->inputNr--;
1227	if (ctxt->inputNr > 0)
1228	ctxt->input = ctxt->inputTab[ctxt->inputNr - 1];
1229	else
1230	ctxt->input = NULL;
1231	ret = ctxt->inputTab[ctxt->inputNr];
1232	ctxt->inputTab[ctxt->inputNr] = NULL;
1233	return (ret);
1234	}
1235	/**
1236	* nodePush:
1237	* @ctxt: an XML parser context
1238	* @value: the element node
1239	*
1240	* Pushes a new element node on top of the node stack
1241	*
1242	* Returns 0 in case of error, the index in the stack otherwise
1243	*/
1244	int
1245	nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value)
1246	{
1247	if (ctxt == NULL) return(0);
1248	if (ctxt->nodeNr >= ctxt->nodeMax) {
1249	xmlNodePtr *tmp;
1250
1251	tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
1252	ctxt->nodeMax * 2 *
1253	sizeof(ctxt->nodeTab[0]));
1254	if (tmp == NULL) {
1255	xmlErrMemory(ctxt, NULL);
1256	return (0);
1257	}
1258	ctxt->nodeTab = tmp;
1259	ctxt->nodeMax *= 2;
1260	}
1261	if (((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) {
1262	xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
1263	"Excessive depth in document: change xmlParserMaxDepth = %d\n",
1264	xmlParserMaxDepth);
1265	ctxt->instate = XML_PARSER_EOF;
1266	return(0);
1267	}
1268	ctxt->nodeTab[ctxt->nodeNr] = value;
1269	ctxt->node = value;
1270	return (ctxt->nodeNr++);
1271	}
1272	/**
1273	* nodePop:
1274	* @ctxt: an XML parser context
1275	*
1276	* Pops the top element node from the node stack
1277	*
1278	* Returns the node just removed
1279	*/
1280	xmlNodePtr
1281	nodePop(xmlParserCtxtPtr ctxt)
1282	{
1283	xmlNodePtr ret;
1284
1285	if (ctxt == NULL) return(NULL);
1286	if (ctxt->nodeNr <= 0)
1287	return (NULL);
1288	ctxt->nodeNr--;
1289	if (ctxt->nodeNr > 0)
1290	ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
1291	else
1292	ctxt->node = NULL;
1293	ret = ctxt->nodeTab[ctxt->nodeNr];
1294	ctxt->nodeTab[ctxt->nodeNr] = NULL;
1295	return (ret);
1296	}
1297
1298	#ifdef LIBXML_PUSH_ENABLED
1299	/**
1300	* nameNsPush:
1301	* @ctxt: an XML parser context
1302	* @value: the element name
1303	* @prefix: the element prefix
1304	* @URI: the element namespace name
1305	*
1306	* Pushes a new element name/prefix/URL on top of the name stack
1307	*
1308	* Returns -1 in case of error, the index in the stack otherwise
1309	*/
1310	static int
1311	nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value,
1312	const xmlChar prefix, const xmlChar URI, int nsNr)
1313	{
1314	if (ctxt->nameNr >= ctxt->nameMax) {
1315	const xmlChar * *tmp;
1316	void **tmp2;
1317	ctxt->nameMax *= 2;
1318	tmp = (const xmlChar * ) xmlRealloc((xmlChar *)ctxt->nameTab,
1319	ctxt->nameMax *
1320	sizeof(ctxt->nameTab[0]));
1321	if (tmp == NULL) {
1322	ctxt->nameMax /= 2;
1323	goto mem_error;
1324	}
1325	ctxt->nameTab = tmp;
1326	tmp2 = (void *) xmlRealloc((void *)ctxt->pushTab,
1327	ctxt->nameMax * 3 *
1328	sizeof(ctxt->pushTab[0]));
1329	if (tmp2 == NULL) {
1330	ctxt->nameMax /= 2;
1331	goto mem_error;
1332	}
1333	ctxt->pushTab = tmp2;
1334	}
1335	ctxt->nameTab[ctxt->nameNr] = value;
1336	ctxt->name = value;
1337	ctxt->pushTab[ctxt->nameNr * 3] = (void *) prefix;
1338	ctxt->pushTab[ctxt->nameNr * 3 + 1] = (void *) URI;
1339	ctxt->pushTab[ctxt->nameNr * 3 + 2] = (void *) (long) nsNr;
1340	return (ctxt->nameNr++);
1341	mem_error:
1342	xmlErrMemory(ctxt, NULL);
1343	return (-1);
1344	}
1345	/**
1346	* nameNsPop:
1347	* @ctxt: an XML parser context
1348	*
1349	* Pops the top element/prefix/URI name from the name stack
1350	*
1351	* Returns the name just removed
1352	*/
1353	static const xmlChar *
1354	nameNsPop(xmlParserCtxtPtr ctxt)
1355	{
1356	const xmlChar *ret;
1357
1358	if (ctxt->nameNr <= 0)
1359	return (NULL);
1360	ctxt->nameNr--;
1361	if (ctxt->nameNr > 0)
1362	ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1363	else
1364	ctxt->name = NULL;
1365	ret = ctxt->nameTab[ctxt->nameNr];
1366	ctxt->nameTab[ctxt->nameNr] = NULL;
1367	return (ret);
1368	}
1369	#endif /* LIBXML_PUSH_ENABLED */
1370
1371	/**
1372	* namePush:
1373	* @ctxt: an XML parser context
1374	* @value: the element name
1375	*
1376	* Pushes a new element name on top of the name stack
1377	*
1378	* Returns -1 in case of error, the index in the stack otherwise
1379	*/
1380	int
1381	namePush(xmlParserCtxtPtr ctxt, const xmlChar * value)
1382	{
1383	if (ctxt == NULL) return (-1);
1384
1385	if (ctxt->nameNr >= ctxt->nameMax) {
1386	const xmlChar * *tmp;
1387	ctxt->nameMax *= 2;
1388	tmp = (const xmlChar * ) xmlRealloc((xmlChar *)ctxt->nameTab,
1389	ctxt->nameMax *
1390	sizeof(ctxt->nameTab[0]));
1391	if (tmp == NULL) {
1392	ctxt->nameMax /= 2;
1393	goto mem_error;
1394	}
1395	ctxt->nameTab = tmp;
1396	}
1397	ctxt->nameTab[ctxt->nameNr] = value;
1398	ctxt->name = value;
1399	return (ctxt->nameNr++);
1400	mem_error:
1401	xmlErrMemory(ctxt, NULL);
1402	return (-1);
1403	}
1404	/**
1405	* namePop:
1406	* @ctxt: an XML parser context
1407	*
1408	* Pops the top element name from the name stack
1409	*
1410	* Returns the name just removed
1411	*/
1412	const xmlChar *
1413	namePop(xmlParserCtxtPtr ctxt)
1414	{
1415	const xmlChar *ret;
1416
1417	if ((ctxt == NULL) \|\| (ctxt->nameNr <= 0))
1418	return (NULL);
1419	ctxt->nameNr--;
1420	if (ctxt->nameNr > 0)
1421	ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1422	else
1423	ctxt->name = NULL;
1424	ret = ctxt->nameTab[ctxt->nameNr];
1425	ctxt->nameTab[ctxt->nameNr] = NULL;
1426	return (ret);
1427	}
1428
1429	static int spacePush(xmlParserCtxtPtr ctxt, int val) {
1430	if (ctxt->spaceNr >= ctxt->spaceMax) {
1431	ctxt->spaceMax *= 2;
1432	ctxt->spaceTab = (int *) xmlRealloc(ctxt->spaceTab,
1433	ctxt->spaceMax * sizeof(ctxt->spaceTab[0]));
1434	if (ctxt->spaceTab == NULL) {
1435	xmlErrMemory(ctxt, NULL);
1436	return(0);
1437	}
1438	}
1439	ctxt->spaceTab[ctxt->spaceNr] = val;
1440	ctxt->space = &ctxt->spaceTab[ctxt->spaceNr];
1441	return(ctxt->spaceNr++);
1442	}
1443
1444	static int spacePop(xmlParserCtxtPtr ctxt) {
1445	int ret;
1446	if (ctxt->spaceNr <= 0) return(0);
1447	ctxt->spaceNr--;
1448	if (ctxt->spaceNr > 0)
1449	ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1];
1450	else
1451	ctxt->space = &ctxt->spaceTab[0];
1452	ret = ctxt->spaceTab[ctxt->spaceNr];
1453	ctxt->spaceTab[ctxt->spaceNr] = -1;
1454	return(ret);
1455	}
1456
1457	/*
1458	* Macros for accessing the content. Those should be used only by the parser,
1459	* and not exported.
1460	*
1461	* Dirty macros, i.e. one often need to make assumption on the context to
1462	* use them
1463	*
1464	* CUR_PTR return the current pointer to the xmlChar to be parsed.
1465	* To be used with extreme caution since operations consuming
1466	* characters may move the input buffer to a different location !
1467	* CUR returns the current xmlChar value, i.e. a 8 bit value if compiled
1468	* This should be used internally by the parser
1469	* only to compare to ASCII values otherwise it would break when
1470	* running with UTF-8 encoding.
1471	* RAW same as CUR but in the input buffer, bypass any token
1472	* extraction that may have been done
1473	* NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only
1474	* to compare on ASCII based substring.
1475	* SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
1476	* strings without newlines within the parser.
1477	* NEXT1(l) Skip 1 xmlChar, and must also be used only to skip 1 non-newline ASCII
1478	* defined char within the parser.
1479	* Clean macros, not dependent of an ASCII context, expect UTF-8 encoding
1480	*
1481	* NEXT Skip to the next character, this does the proper decoding
1482	* in UTF-8 mode. It also pop-up unfinished entities on the fly.
1483	* NEXTL(l) Skip the current unicode character of l xmlChars long.
1484	* CUR_CHAR(l) returns the current unicode character (int), set l
1485	* to the number of xmlChars used for the encoding [0-5].
1486	* CUR_SCHAR same but operate on a string instead of the context
1487	* COPY_BUF copy the current unicode char to the target buffer, increment
1488	* the index
1489	* GROW, SHRINK handling of input buffers
1490	*/
1491
1492	#define RAW (*ctxt->input->cur)
1493	#define CUR (*ctxt->input->cur)
1494	#define NXT(val) ctxt->input->cur[(val)]
1495	#define CUR_PTR ctxt->input->cur
1496
1497	#define CMP4( s, c1, c2, c3, c4 ) \
1498	( ((unsigned char ) s)[ 0 ] == c1 && ((unsigned char ) s)[ 1 ] == c2 && \
1499	((unsigned char ) s)[ 2 ] == c3 && ((unsigned char ) s)[ 3 ] == c4 )
1500	#define CMP5( s, c1, c2, c3, c4, c5 ) \
1501	( CMP4( s, c1, c2, c3, c4 ) && ((unsigned char *) s)[ 4 ] == c5 )
1502	#define CMP6( s, c1, c2, c3, c4, c5, c6 ) \
1503	( CMP5( s, c1, c2, c3, c4, c5 ) && ((unsigned char *) s)[ 5 ] == c6 )
1504	#define CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) \
1505	( CMP6( s, c1, c2, c3, c4, c5, c6 ) && ((unsigned char *) s)[ 6 ] == c7 )
1506	#define CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) \
1507	( CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) && ((unsigned char *) s)[ 7 ] == c8 )
1508	#define CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) \
1509	( CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) && \
1510	((unsigned char *) s)[ 8 ] == c9 )
1511	#define CMP10( s, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10 ) \
1512	( CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) && \
1513	((unsigned char *) s)[ 9 ] == c10 )
1514
1515	#define SKIP(val) do { \
1516	ctxt->nbChars += (val),ctxt->input->cur += (val),ctxt->input->col+=(val); \
1517	if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
1518	if ((*ctxt->input->cur == 0) && \
1519	(xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \
1520	xmlPopInput(ctxt); \
1521	} while (0)
1522
1523	#define SKIPL(val) do { \
1524	int skipl; \
1525	for(skipl=0; skipl<val; skipl++) { \
1526	if (*(ctxt->input->cur) == '\n') { \
1527	ctxt->input->line++; ctxt->input->col = 1; \
1528	} else ctxt->input->col++; \
1529	ctxt->nbChars++; \
1530	ctxt->input->cur++; \
1531	} \
1532	if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
1533	if ((*ctxt->input->cur == 0) && \
1534	(xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \
1535	xmlPopInput(ctxt); \
1536	} while (0)
1537
1538	#define SHRINK if ((ctxt->progressive == 0) && \
1539	(ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
1540	(ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
1541	xmlSHRINK (ctxt);
1542
1543	static void xmlSHRINK (xmlParserCtxtPtr ctxt) {
1544	xmlParserInputShrink(ctxt->input);
1545	if ((*ctxt->input->cur == 0) &&
1546	(xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
1547	xmlPopInput(ctxt);
1548	}
1549
1550	#define GROW if ((ctxt->progressive == 0) && \
1551	(ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)) \
1552	xmlGROW (ctxt);
1553
1554	static void xmlGROW (xmlParserCtxtPtr ctxt) {
1555	xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
1556	if ((*ctxt->input->cur == 0) &&
1557	(xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
1558	xmlPopInput(ctxt);
1559	}
1560
1561	#define SKIP_BLANKS xmlSkipBlankChars(ctxt)
1562
1563	#define NEXT xmlNextChar(ctxt)
1564
1565	#define NEXT1 { \
1566	ctxt->input->col++; \
1567	ctxt->input->cur++; \
1568	ctxt->nbChars++; \
1569	if (*ctxt->input->cur == 0) \
1570	xmlParserInputGrow(ctxt->input, INPUT_CHUNK); \
1571	}
1572
1573	#define NEXTL(l) do { \
1574	if (*(ctxt->input->cur) == '\n') { \
1575	ctxt->input->line++; ctxt->input->col = 1; \
1576	} else ctxt->input->col++; \
1577	ctxt->input->cur += l; \
1578	if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
1579	} while (0)
1580
1581	#define CUR_CHAR(l) xmlCurrentChar(ctxt, &l)
1582	#define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)
1583
1584	#define COPY_BUF(l,b,i,v) \
1585	if (l == 1) b[i++] = (xmlChar) v; \
1586	else i += xmlCopyCharMultiByte(&b[i],v)
1587
1588	/**
1589	* xmlSkipBlankChars:
1590	* @ctxt: the XML parser context
1591	*
1592	* skip all blanks character found at that point in the input streams.
1593	* It pops up finished entities in the process if allowable at that point.
1594	*
1595	* Returns the number of space chars skipped
1596	*/
1597
1598	int
1599	xmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
1600	int res = 0;
1601
1602	/*
1603	* It's Okay to use CUR/NEXT here since all the blanks are on
1604	* the ASCII range.
1605	*/
1606	if ((ctxt->inputNr == 1) && (ctxt->instate != XML_PARSER_DTD)) {
1607	const xmlChar *cur;
1608	/*
1609	* if we are in the document content, go really fast
1610	*/
1611	cur = ctxt->input->cur;
1612	while (IS_BLANK_CH(*cur)) {
1613	if (*cur == '\n') {
1614	ctxt->input->line++; ctxt->input->col = 1;
1615	}
1616	cur++;
1617	res++;
1618	if (*cur == 0) {
1619	ctxt->input->cur = cur;
1620	xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
1621	cur = ctxt->input->cur;
1622	}
1623	}
1624	ctxt->input->cur = cur;
1625	} else {
1626	int cur;
1627	do {
1628	cur = CUR;
1629	while (IS_BLANK_CH(cur)) { /* CHECKED tstblanks.xml */
1630	NEXT;
1631	cur = CUR;
1632	res++;
1633	}
1634	while ((cur == 0) && (ctxt->inputNr > 1) &&
1635	(ctxt->instate != XML_PARSER_COMMENT)) {
1636	xmlPopInput(ctxt);
1637	cur = CUR;
1638	}
1639	/*
1640	* Need to handle support of entities branching here
1641	*/
1642	if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);
1643	} while (IS_BLANK(cur)); /* CHECKED tstblanks.xml */
1644	}
1645	return(res);
1646	}
1647
1648	/************************************************************************
1649	* *
1650	* Commodity functions to handle entities *
1651	* *
1652	************************************************************************/
1653
1654	/**
1655	* xmlPopInput:
1656	* @ctxt: an XML parser context
1657	*
1658	* xmlPopInput: the current input pointed by ctxt->input came to an end
1659	* pop it and return the next char.
1660	*
1661	* Returns the current xmlChar in the parser context
1662	*/
1663	xmlChar
1664	xmlPopInput(xmlParserCtxtPtr ctxt) {
1665	if ((ctxt == NULL) \|\| (ctxt->inputNr <= 1)) return(0);
1666	if (xmlParserDebugEntities)
1667	xmlGenericError(xmlGenericErrorContext,
1668	"Popping input %d\n", ctxt->inputNr);
1669	xmlFreeInputStream(inputPop(ctxt));
1670	if ((*ctxt->input->cur == 0) &&
1671	(xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
1672	return(xmlPopInput(ctxt));
1673	return(CUR);
1674	}
1675
1676	/**
1677	* xmlPushInput:
1678	* @ctxt: an XML parser context
1679	* @input: an XML parser input fragment (entity, XML fragment ...).
1680	*
1681	* xmlPushInput: switch to a new input stream which is stacked on top
1682	* of the previous one(s).
1683	*/
1684	void
1685	xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) {
1686	if (input == NULL) return;
1687
1688	if (xmlParserDebugEntities) {
1689	if ((ctxt->input != NULL) && (ctxt->input->filename))
1690	xmlGenericError(xmlGenericErrorContext,
1691	"%s(%d): ", ctxt->input->filename,
1692	ctxt->input->line);
1693	xmlGenericError(xmlGenericErrorContext,
1694	"Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur);
1695	}
1696	inputPush(ctxt, input);
1697	GROW;
1698	}
1699
1700	/**
1701	* xmlParseCharRef:
1702	* @ctxt: an XML parser context
1703	*
1704	* parse Reference declarations
1705	*
1706	* [66] CharRef ::= '&#' [0-9]+ ';' \|
1707	* '&#x' [0-9a-fA-F]+ ';'
1708	*
1709	* [ WFC: Legal Character ]
1710	* Characters referred to using character references must match the
1711	* production for Char.
1712	*
1713	* Returns the value parsed (as an int), 0 in case of error
1714	*/
1715	int
1716	xmlParseCharRef(xmlParserCtxtPtr ctxt) {
1717	unsigned int val = 0;
1718	int count = 0;
1719	unsigned int outofrange = 0;
1720
1721	/*
1722	* Using RAW/CUR/NEXT is okay since we are working on ASCII range here
1723	*/
1724	if ((RAW == '&') && (NXT(1) == '#') &&
1725	(NXT(2) == 'x')) {
1726	SKIP(3);
1727	GROW;
1728	while (RAW != ';') { /* loop blocked by count */
1729	if (count++ > 20) {
1730	count = 0;
1731	GROW;
1732	}
1733	if ((RAW >= '0') && (RAW <= '9'))
1734	val = val * 16 + (CUR - '0');
1735	else if ((RAW >= 'a') && (RAW <= 'f') && (count < 20))
1736	val = val * 16 + (CUR - 'a') + 10;
1737	else if ((RAW >= 'A') && (RAW <= 'F') && (count < 20))
1738	val = val * 16 + (CUR - 'A') + 10;
1739	else {
1740	xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
1741	val = 0;
1742	break;
1743	}
1744	if (val > 0x10FFFF)
1745	outofrange = val;
1746
1747	NEXT;
1748	count++;
1749	}
1750	if (RAW == ';') {
1751	/* on purpose to avoid reentrancy problems with NEXT and SKIP */
1752	ctxt->input->col++;
1753	ctxt->nbChars ++;
1754	ctxt->input->cur++;
1755	}
1756	} else if ((RAW == '&') && (NXT(1) == '#')) {
1757	SKIP(2);
1758	GROW;
1759	while (RAW != ';') { /* loop blocked by count */
1760	if (count++ > 20) {
1761	count = 0;
1762	GROW;
1763	}
1764	if ((RAW >= '0') && (RAW <= '9'))
1765	val = val * 10 + (CUR - '0');
1766	else {
1767	xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
1768	val = 0;
1769	break;
1770	}
1771	if (val > 0x10FFFF)
1772	outofrange = val;
1773
1774	NEXT;
1775	count++;
1776	}
1777	if (RAW == ';') {
1778	/* on purpose to avoid reentrancy problems with NEXT and SKIP */
1779	ctxt->input->col++;
1780	ctxt->nbChars ++;
1781	ctxt->input->cur++;
1782	}
1783	} else {
1784	xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
1785	}
1786
1787	/*
1788	* [ WFC: Legal Character ]
1789	* Characters referred to using character references must match the
1790	* production for Char.
1791	*/
1792	if ((IS_CHAR(val) && (outofrange == 0))) {
1793	return(val);
1794	} else {
1795	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
1796	"xmlParseCharRef: invalid xmlChar value %d\n",
1797	val);
1798	}
1799	return(0);
1800	}
1801
1802	/**
1803	* xmlParseStringCharRef:
1804	* @ctxt: an XML parser context
1805	* @str: a pointer to an index in the string
1806	*
1807	* parse Reference declarations, variant parsing from a string rather
1808	* than an an input flow.
1809	*
1810	* [66] CharRef ::= '&#' [0-9]+ ';' \|
1811	* '&#x' [0-9a-fA-F]+ ';'
1812	*
1813	* [ WFC: Legal Character ]
1814	* Characters referred to using character references must match the
1815	* production for Char.
1816	*
1817	* Returns the value parsed (as an int), 0 in case of error, str will be
1818	* updated to the current value of the index
1819	*/
1820	static int
1821	xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) {
1822	const xmlChar *ptr;
1823	xmlChar cur;
1824	unsigned int val = 0;
1825	unsigned int outofrange = 0;
1826
1827	if ((str == NULL) \|\| (*str == NULL)) return(0);
1828	ptr = *str;
1829	cur = *ptr;
1830	if ((cur == '&') && (ptr[1] == '#') && (ptr[2] == 'x')) {
1831	ptr += 3;
1832	cur = *ptr;
1833	while (cur != ';') { /* Non input consuming loop */
1834	if ((cur >= '0') && (cur <= '9'))
1835	val = val * 16 + (cur - '0');
1836	else if ((cur >= 'a') && (cur <= 'f'))
1837	val = val * 16 + (cur - 'a') + 10;
1838	else if ((cur >= 'A') && (cur <= 'F'))
1839	val = val * 16 + (cur - 'A') + 10;
1840	else {
1841	xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
1842	val = 0;
1843	break;
1844	}
1845	if (val > 0x10FFFF)
1846	outofrange = val;
1847
1848	ptr++;
1849	cur = *ptr;
1850	}
1851	if (cur == ';')
1852	ptr++;
1853	} else if ((cur == '&') && (ptr[1] == '#')){
1854	ptr += 2;
1855	cur = *ptr;
1856	while (cur != ';') { /* Non input consuming loops */
1857	if ((cur >= '0') && (cur <= '9'))
1858	val = val * 10 + (cur - '0');
1859	else {
1860	xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
1861	val = 0;
1862	break;
1863	}
1864	if (val > 0x10FFFF)
1865	outofrange = val;
1866
1867	ptr++;
1868	cur = *ptr;
1869	}
1870	if (cur == ';')
1871	ptr++;
1872	} else {
1873	xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
1874	return(0);
1875	}
1876	*str = ptr;
1877
1878	/*
1879	* [ WFC: Legal Character ]
1880	* Characters referred to using character references must match the
1881	* production for Char.
1882	*/
1883	if ((IS_CHAR(val) && (outofrange == 0))) {
1884	return(val);
1885	} else {
1886	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
1887	"xmlParseStringCharRef: invalid xmlChar value %d\n",
1888	val);
1889	}
1890	return(0);
1891	}
1892
1893	/**
1894	* xmlNewBlanksWrapperInputStream:
1895	* @ctxt: an XML parser context
1896	* @entity: an Entity pointer
1897	*
1898	* Create a new input stream for wrapping
1899	* blanks around a PEReference
1900	*
1901	* Returns the new input stream or NULL
1902	*/
1903
1904	static void deallocblankswrapper (xmlChar *str) {xmlFree(str);}
1905
1906	static xmlParserInputPtr
1907	xmlNewBlanksWrapperInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
1908	xmlParserInputPtr input;
1909	xmlChar *buffer;
1910	size_t length;
1911	if (entity == NULL) {
1912	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
1913	"xmlNewBlanksWrapperInputStream entity\n");
1914	return(NULL);
1915	}
1916	if (xmlParserDebugEntities)
1917	xmlGenericError(xmlGenericErrorContext,
1918	"new blanks wrapper for entity: %s\n", entity->name);
1919	input = xmlNewInputStream(ctxt);
1920	if (input == NULL) {
1921	return(NULL);
1922	}
1923	length = xmlStrlen(entity->name) + 5;
1924	buffer = xmlMallocAtomic(length);
1925	if (buffer == NULL) {
1926	xmlErrMemory(ctxt, NULL);
1927	return(NULL);
1928	}
1929	buffer [0] = ' ';
1930	buffer [1] = '%';
1931	buffer [length-3] = ';';
1932	buffer [length-2] = ' ';
1933	buffer [length-1] = 0;
1934	memcpy(buffer + 2, entity->name, length - 5);
1935	input->free = deallocblankswrapper;
1936	input->base = buffer;
1937	input->cur = buffer;
1938	input->length = length;
1939	input->end = &buffer[length];
1940	return(input);
1941	}
1942
1943	/**
1944	* xmlParserHandlePEReference:
1945	* @ctxt: the parser context
1946	*
1947	* [69] PEReference ::= '%' Name ';'
1948	*
1949	* [ WFC: No Recursion ]
1950	* A parsed entity must not contain a recursive
1951	* reference to itself, either directly or indirectly.
1952	*
1953	* [ WFC: Entity Declared ]
1954	* In a document without any DTD, a document with only an internal DTD
1955	* subset which contains no parameter entity references, or a document
1956	* with "standalone='yes'", ... ... The declaration of a parameter
1957	* entity must precede any reference to it...
1958	*
1959	* [ VC: Entity Declared ]
1960	* In a document with an external subset or external parameter entities
1961	* with "standalone='no'", ... ... The declaration of a parameter entity
1962	* must precede any reference to it...
1963	*
1964	* [ WFC: In DTD ]
1965	* Parameter-entity references may only appear in the DTD.
1966	* NOTE: misleading but this is handled.
1967	*
1968	* A PEReference may have been detected in the current input stream
1969	* the handling is done accordingly to
1970	* http://www.w3.org/TR/REC-xml#entproc
1971	* i.e.
1972	* - Included in literal in entity values
1973	* - Included as Parameter Entity reference within DTDs
1974	*/
1975	void
1976	xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) {
1977	const xmlChar *name;
1978	xmlEntityPtr entity = NULL;
1979	xmlParserInputPtr input;
1980
1981	if (RAW != '%') return;
1982	switch(ctxt->instate) {
1983	case XML_PARSER_CDATA_SECTION:
1984	return;
1985	case XML_PARSER_COMMENT:
1986	return;
1987	case XML_PARSER_START_TAG:
1988	return;
1989	case XML_PARSER_END_TAG:
1990	return;
1991	case XML_PARSER_EOF:
1992	xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL);
1993	return;
1994	case XML_PARSER_PROLOG:
1995	case XML_PARSER_START:
1996	case XML_PARSER_MISC:
1997	xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL);
1998	return;
1999	case XML_PARSER_ENTITY_DECL:
2000	case XML_PARSER_CONTENT:
2001	case XML_PARSER_ATTRIBUTE_VALUE:
2002	case XML_PARSER_PI:
2003	case XML_PARSER_SYSTEM_LITERAL:
2004	case XML_PARSER_PUBLIC_LITERAL:
2005	/* we just ignore it there */
2006	return;
2007	case XML_PARSER_EPILOG:
2008	xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL);
2009	return;
2010	case XML_PARSER_ENTITY_VALUE:
2011	/*
2012	* NOTE: in the case of entity values, we don't do the
2013	* substitution here since we need the literal
2014	* entity value to be able to save the internal
2015	* subset of the document.
2016	* This will be handled by xmlStringDecodeEntities
2017	*/
2018	return;
2019	case XML_PARSER_DTD:
2020	/*
2021	* [WFC: Well-Formedness Constraint: PEs in Internal Subset]
2022	* In the internal DTD subset, parameter-entity references
2023	* can occur only where markup declarations can occur, not
2024	* within markup declarations.
2025	* In that case this is handled in xmlParseMarkupDecl
2026	*/
2027	if ((ctxt->external == 0) && (ctxt->inputNr == 1))
2028	return;
2029	if (IS_BLANK_CH(NXT(1)) \|\| NXT(1) == 0)
2030	return;
2031	break;
2032	case XML_PARSER_IGNORE:
2033	return;
2034	}
2035
2036	NEXT;
2037	name = xmlParseName(ctxt);
2038	if (xmlParserDebugEntities)
2039	xmlGenericError(xmlGenericErrorContext,
2040	"PEReference: %s\n", name);
2041	if (name == NULL) {
2042	xmlFatalErr(ctxt, XML_ERR_PEREF_NO_NAME, NULL);
2043	} else {
2044	if (RAW == ';') {
2045	NEXT;
2046	if ((ctxt->sax != NULL) && (ctxt->sax->getParameterEntity != NULL))
2047	entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
2048	if (entity == NULL) {
2049
2050	/*
2051	* [ WFC: Entity Declared ]
2052	* In a document without any DTD, a document with only an
2053	* internal DTD subset which contains no parameter entity
2054	* references, or a document with "standalone='yes'", ...
2055	* ... The declaration of a parameter entity must precede
2056	* any reference to it...
2057	*/
2058	if ((ctxt->standalone == 1) \|\|
2059	((ctxt->hasExternalSubset == 0) &&
2060	(ctxt->hasPErefs == 0))) {
2061	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
2062	"PEReference: %%%s; not found\n", name);
2063	} else {
2064	/*
2065	* [ VC: Entity Declared ]
2066	* In a document with an external subset or external
2067	* parameter entities with "standalone='no'", ...
2068	* ... The declaration of a parameter entity must precede
2069	* any reference to it...
2070	*/
2071	if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) {
2072	xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
2073	"PEReference: %%%s; not found\n",
2074	name);
2075	} else
2076	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
2077	"PEReference: %%%s; not found\n",
2078	name, NULL);
2079	ctxt->valid = 0;
2080	}
2081	} else if (ctxt->input->free != deallocblankswrapper) {
2082	input = xmlNewBlanksWrapperInputStream(ctxt, entity);
2083	xmlPushInput(ctxt, input);
2084	} else {
2085	if ((entity->etype == XML_INTERNAL_PARAMETER_ENTITY) \|\|
2086	(entity->etype == XML_EXTERNAL_PARAMETER_ENTITY)) {
2087	xmlChar start[4];
2088	xmlCharEncoding enc;
2089
2090	/*
2091	* handle the extra spaces added before and after
2092	* c.f. http://www.w3.org/TR/REC-xml#as-PE
2093	* this is done independently.
2094	*/
2095	input = xmlNewEntityInputStream(ctxt, entity);
2096	xmlPushInput(ctxt, input);
2097
2098	/*
2099	* Get the 4 first bytes and decode the charset
2100	* if enc != XML_CHAR_ENCODING_NONE
2101	* plug some encoding conversion routines.
2102	* Note that, since we may have some non-UTF8
2103	* encoding (like UTF16, bug 135229), the 'length'
2104	* is not known, but we can calculate based upon
2105	* the amount of data in the buffer.
2106	*/
2107	GROW
2108	if ((ctxt->input->end - ctxt->input->cur)>=4) {
2109	start[0] = RAW;
2110	start[1] = NXT(1);
2111	start[2] = NXT(2);
2112	start[3] = NXT(3);
2113	enc = xmlDetectCharEncoding(start, 4);
2114	if (enc != XML_CHAR_ENCODING_NONE) {
2115	xmlSwitchEncoding(ctxt, enc);
2116	}
2117	}
2118
2119	if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
2120	(CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l' )) &&
2121	(IS_BLANK_CH(NXT(5)))) {
2122	xmlParseTextDecl(ctxt);
2123	}
2124	} else {
2125	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
2126	"PEReference: %s is not a parameter entity\n",
2127	name);
2128	}
2129	}
2130	} else {
2131	xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
2132	}
2133	}
2134	}
2135
2136	/*
2137	* Macro used to grow the current buffer.
2138	*/
2139	#define growBuffer(buffer) { \
2140	xmlChar *tmp; \
2141	buffer##_size *= 2; \
2142	tmp = (xmlChar *) \
2143	xmlRealloc(buffer, buffer##_size * sizeof(xmlChar)); \
2144	if (tmp == NULL) goto mem_error; \
2145	buffer = tmp; \
2146	}
2147
2148	/**
2149	* xmlStringLenDecodeEntities:
2150	* @ctxt: the parser context
2151	* @str: the input string
2152	* @len: the string length
2153	* @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
2154	* @end: an end marker xmlChar, 0 if none
2155	* @end2: an end marker xmlChar, 0 if none
2156	* @end3: an end marker xmlChar, 0 if none
2157	*
2158	* Takes a entity string content and process to do the adequate substitutions.
2159	*
2160	* [67] Reference ::= EntityRef \| CharRef
2161	*
2162	* [69] PEReference ::= '%' Name ';'
2163	*
2164	* Returns A newly allocated string with the substitution done. The caller
2165	* must deallocate it !
2166	*/
2167	xmlChar *
2168	xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2169	int what, xmlChar end, xmlChar end2, xmlChar end3) {
2170	xmlChar *buffer = NULL;
2171	int buffer_size = 0;
2172
2173	xmlChar *current = NULL;
2174	const xmlChar *last;
2175	xmlEntityPtr ent;
2176	int c,l;
2177	int nbchars = 0;
2178
2179	if ((ctxt == NULL) \|\| (str == NULL) \|\| (len < 0))
2180	return(NULL);
2181	last = str + len;
2182
2183	if ((ctxt->depth > 40) \|\| (ctxt->nbentities >= 500000)) {
2184	xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
2185	return(NULL);
2186	}
2187
2188	/*
2189	* allocate a translation buffer.
2190	*/
2191	buffer_size = XML_PARSER_BIG_BUFFER_SIZE;
2192	buffer = (xmlChar ) xmlMallocAtomic(buffer_size sizeof(xmlChar));
2193	if (buffer == NULL) goto mem_error;
2194
2195	/*
2196	* OK loop until we reach one of the ending char or a size limit.
2197	* we are operating on already parsed values.
2198	*/
2199	if (str < last)
2200	c = CUR_SCHAR(str, l);
2201	else
2202	c = 0;
2203	while ((c != 0) && (c != end) && /* non input consuming loop */
2204	(c != end2) && (c != end3)) {
2205
2206	if (c == 0) break;
2207	if ((c == '&') && (str[1] == '#')) {
2208	int val = xmlParseStringCharRef(ctxt, &str);
2209	if (val != 0) {
2210	COPY_BUF(0,buffer,nbchars,val);
2211	}
2212	if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
2213	growBuffer(buffer);
2214	}
2215	} else if ((c == '&') && (what & XML_SUBSTITUTE_REF)) {
2216	if (xmlParserDebugEntities)
2217	xmlGenericError(xmlGenericErrorContext,
2218	"String decoding Entity Reference: %.30s\n",
2219	str);
2220	ent = xmlParseStringEntityRef(ctxt, &str);
2221	if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
2222	goto int_error;
2223	ctxt->nbentities++;
2224	if (ent != NULL)
2225	ctxt->nbentities += ent->checked;
2226	if ((ent != NULL) &&
2227	(ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
2228	if (ent->content != NULL) {
2229	COPY_BUF(0,buffer,nbchars,ent->content[0]);
2230	if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
2231	growBuffer(buffer);
2232	}
2233	} else {
2234	xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
2235	"predefined entity has no content\n");
2236	}
2237	} else if ((ent != NULL) && (ent->content != NULL)) {
2238	xmlChar *rep;
2239
2240	ctxt->depth++;
2241	rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2242	0, 0, 0);
2243	ctxt->depth--;
2244	if (rep != NULL) {
2245	current = rep;
2246	while (current != 0) { / non input consuming loop */
2247	buffer[nbchars++] = *current++;
2248	if (nbchars >
2249	buffer_size - XML_PARSER_BUFFER_SIZE) {
2250	growBuffer(buffer);
2251	}
2252	}
2253	xmlFree(rep);
2254	}
2255	} else if (ent != NULL) {
2256	int i = xmlStrlen(ent->name);
2257	const xmlChar *cur = ent->name;
2258
2259	buffer[nbchars++] = '&';
2260	if (nbchars > buffer_size - i - XML_PARSER_BUFFER_SIZE) {
2261	growBuffer(buffer);
2262	}
2263	for (;i > 0;i--)
2264	buffer[nbchars++] = *cur++;
2265	buffer[nbchars++] = ';';
2266	}
2267	} else if (c == '%' && (what & XML_SUBSTITUTE_PEREF)) {
2268	if (xmlParserDebugEntities)
2269	xmlGenericError(xmlGenericErrorContext,
2270	"String decoding PE Reference: %.30s\n", str);
2271	ent = xmlParseStringPEReference(ctxt, &str);
2272	if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
2273	goto int_error;
2274	ctxt->nbentities++;
2275	if (ent != NULL)
2276	ctxt->nbentities += ent->checked;
2277	if (ent != NULL) {
2278	xmlChar *rep;
2279
2280	ctxt->depth++;
2281	rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2282	0, 0, 0);
2283	ctxt->depth--;
2284	if (rep != NULL) {
2285	current = rep;
2286	while (current != 0) { / non input consuming loop */
2287	buffer[nbchars++] = *current++;
2288	if (nbchars >
2289	buffer_size - XML_PARSER_BUFFER_SIZE) {
2290	growBuffer(buffer);
2291	}
2292	}
2293	xmlFree(rep);
2294	}
2295	}
2296	} else {
2297	COPY_BUF(l,buffer,nbchars,c);
2298	str += l;
2299	if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
2300	growBuffer(buffer);
2301	}
2302	}
2303	if (str < last)
2304	c = CUR_SCHAR(str, l);
2305	else
2306	c = 0;
2307	}
2308	buffer[nbchars++] = 0;
2309	return(buffer);
2310
2311	mem_error:
2312	xmlErrMemory(ctxt, NULL);
2313	int_error:
2314	if (buffer != NULL)
2315	xmlFree(buffer);
2316	return(NULL);
2317	}
2318
2319	/**
2320	* xmlStringDecodeEntities:
2321	* @ctxt: the parser context
2322	* @str: the input string
2323	* @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
2324	* @end: an end marker xmlChar, 0 if none
2325	* @end2: an end marker xmlChar, 0 if none
2326	* @end3: an end marker xmlChar, 0 if none
2327	*
2328	* Takes a entity string content and process to do the adequate substitutions.
2329	*
2330	* [67] Reference ::= EntityRef \| CharRef
2331	*
2332	* [69] PEReference ::= '%' Name ';'
2333	*
2334	* Returns A newly allocated string with the substitution done. The caller
2335	* must deallocate it !
2336	*/
2337	xmlChar *
2338	xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what,
2339	xmlChar end, xmlChar end2, xmlChar end3) {
2340	if ((ctxt == NULL) \|\| (str == NULL)) return(NULL);
2341	return(xmlStringLenDecodeEntities(ctxt, str, xmlStrlen(str), what,
2342	end, end2, end3));
2343	}
2344
2345	/************************************************************************
2346	* *
2347	* Commodity functions, cleanup needed ? *
2348	* *
2349	************************************************************************/
2350
2351	/**
2352	* areBlanks:
2353	* @ctxt: an XML parser context
2354	* @str: a xmlChar *
2355	* @len: the size of @str
2356	* @blank_chars: we know the chars are blanks
2357	*
2358	* Is this a sequence of blank chars that one can ignore ?
2359	*
2360	* Returns 1 if ignorable 0 otherwise.
2361	*/
2362
2363	static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2364	int blank_chars) {
2365	int i, ret;
2366	xmlNodePtr lastChild;
2367
2368	/*
2369	* Don't spend time trying to differentiate them, the same callback is
2370	* used !
2371	*/
2372	if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters)
2373	return(0);
2374
2375	/*
2376	* Check for xml:space value.
2377	*/
2378	if ((ctxt->space == NULL) \|\| (*(ctxt->space) == 1) \|\|
2379	(*(ctxt->space) == -2))
2380	return(0);
2381
2382	/*
2383	* Check that the string is made of blanks
2384	*/
2385	if (blank_chars == 0) {
2386	for (i = 0;i < len;i++)
2387	if (!(IS_BLANK_CH(str[i]))) return(0);
2388	}
2389
2390	/*
2391	* Look if the element is mixed content in the DTD if available
2392	*/
2393	if (ctxt->node == NULL) return(0);
2394	if (ctxt->myDoc != NULL) {
2395	ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name);
2396	if (ret == 0) return(1);
2397	if (ret == 1) return(0);
2398	}
2399
2400	/*
2401	* Otherwise, heuristic :-\
2402	*/
2403	if ((RAW != '<') && (RAW != 0xD)) return(0);
2404	if ((ctxt->node->children == NULL) &&
2405	(RAW == '<') && (NXT(1) == '/')) return(0);
2406
2407	lastChild = xmlGetLastChild(ctxt->node);
2408	if (lastChild == NULL) {
2409	if ((ctxt->node->type != XML_ELEMENT_NODE) &&
2410	(ctxt->node->content != NULL)) return(0);
2411	} else if (xmlNodeIsText(lastChild))
2412	return(0);
2413	else if ((ctxt->node->children != NULL) &&
2414	(xmlNodeIsText(ctxt->node->children)))
2415	return(0);
2416	return(1);
2417	}
2418
2419	/************************************************************************
2420	* *
2421	* Extra stuff for namespace support *
2422	* Relates to http://www.w3.org/TR/WD-xml-names *
2423	* *
2424	************************************************************************/
2425
2426	/**
2427	* xmlSplitQName:
2428	* @ctxt: an XML parser context
2429	* @name: an XML parser context
2430	* @prefix: a xmlChar **
2431	*
2432	* parse an UTF8 encoded XML qualified name string
2433	*
2434	* [NS 5] QName ::= (Prefix ':')? LocalPart
2435	*
2436	* [NS 6] Prefix ::= NCName
2437	*
2438	* [NS 7] LocalPart ::= NCName
2439	*
2440	* Returns the local part, and prefix is updated
2441	* to get the Prefix if any.
2442	*/
2443
2444	xmlChar *
2445	xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar name, xmlChar *prefix) {
2446	xmlChar buf[XML_MAX_NAMELEN + 5];
2447	xmlChar *buffer = NULL;
2448	int len = 0;
2449	int max = XML_MAX_NAMELEN;
2450	xmlChar *ret = NULL;
2451	const xmlChar *cur = name;
2452	int c;
2453
2454	if (prefix == NULL) return(NULL);
2455	*prefix = NULL;
2456
2457	if (cur == NULL) return(NULL);
2458
2459	#ifndef XML_XML_NAMESPACE
2460	/* xml: prefix is not really a namespace */
2461	if ((cur[0] == 'x') && (cur[1] == 'm') &&
2462	(cur[2] == 'l') && (cur[3] == ':'))
2463	return(xmlStrdup(name));
2464	#endif
2465
2466	/* nasty but well=formed */
2467	if (cur[0] == ':')
2468	return(xmlStrdup(name));
2469
2470	c = *cur++;
2471	while ((c != 0) && (c != ':') && (len < max)) { /* tested bigname.xml */
2472	buf[len++] = c;
2473	c = *cur++;
2474	}
2475	if (len >= max) {
2476	/*
2477	* Okay someone managed to make a huge name, so he's ready to pay
2478	* for the processing speed.
2479	*/
2480	max = len * 2;
2481
2482	buffer = (xmlChar ) xmlMallocAtomic(max sizeof(xmlChar));
2483	if (buffer == NULL) {
2484	xmlErrMemory(ctxt, NULL);
2485	return(NULL);
2486	}
2487	memcpy(buffer, buf, len);
2488	while ((c != 0) && (c != ':')) { /* tested bigname.xml */
2489	if (len + 10 > max) {
2490	xmlChar *tmp;
2491
2492	max *= 2;
2493	tmp = (xmlChar *) xmlRealloc(buffer,
2494	max * sizeof(xmlChar));
2495	if (tmp == NULL) {
2496	xmlFree(tmp);
2497	xmlErrMemory(ctxt, NULL);
2498	return(NULL);
2499	}
2500	buffer = tmp;
2501	}
2502	buffer[len++] = c;
2503	c = *cur++;
2504	}
2505	buffer[len] = 0;
2506	}
2507
2508	if ((c == ':') && (*cur == 0)) {
2509	if (buffer != NULL)
2510	xmlFree(buffer);
2511	*prefix = NULL;
2512	return(xmlStrdup(name));
2513	}
2514
2515	if (buffer == NULL)
2516	ret = xmlStrndup(buf, len);
2517	else {
2518	ret = buffer;
2519	buffer = NULL;
2520	max = XML_MAX_NAMELEN;
2521	}
2522
2523
2524	if (c == ':') {
2525	c = *cur;
2526	*prefix = ret;
2527	if (c == 0) {
2528	return(xmlStrndup(BAD_CAST "", 0));
2529	}
2530	len = 0;
2531
2532	/*
2533	* Check that the first character is proper to start
2534	* a new name
2535	*/
2536	if (!(((c >= 0x61) && (c <= 0x7A)) \|\|
2537	((c >= 0x41) && (c <= 0x5A)) \|\|
2538	(c == '_') \|\| (c == ':'))) {
2539	int l;
2540	int first = CUR_SCHAR(cur, l);
2541
2542	if (!IS_LETTER(first) && (first != '_')) {
2543	xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME,
2544	"Name %s is not XML Namespace compliant\n",
2545	name);
2546	}
2547	}
2548	cur++;
2549
2550	while ((c != 0) && (len < max)) { /* tested bigname2.xml */
2551	buf[len++] = c;
2552	c = *cur++;
2553	}
2554	if (len >= max) {
2555	/*
2556	* Okay someone managed to make a huge name, so he's ready to pay
2557	* for the processing speed.
2558	*/
2559	max = len * 2;
2560
2561	buffer = (xmlChar ) xmlMallocAtomic(max sizeof(xmlChar));
2562	if (buffer == NULL) {
2563	xmlErrMemory(ctxt, NULL);
2564	return(NULL);
2565	}
2566	memcpy(buffer, buf, len);
2567	while (c != 0) { /* tested bigname2.xml */
2568	if (len + 10 > max) {
2569	xmlChar *tmp;
2570
2571	max *= 2;
2572	tmp = (xmlChar *) xmlRealloc(buffer,
2573	max * sizeof(xmlChar));
2574	if (tmp == NULL) {
2575	xmlErrMemory(ctxt, NULL);
2576	xmlFree(buffer);
2577	return(NULL);
2578	}
2579	buffer = tmp;
2580	}
2581	buffer[len++] = c;
2582	c = *cur++;
2583	}
2584	buffer[len] = 0;
2585	}
2586
2587	if (buffer == NULL)
2588	ret = xmlStrndup(buf, len);
2589	else {
2590	ret = buffer;
2591	}
2592	}
2593
2594	return(ret);
2595	}
2596
2597	/************************************************************************
2598	* *
2599	* The parser itself *
2600	* Relates to http://www.w3.org/TR/REC-xml *
2601	* *
2602	************************************************************************/
2603
2604	static const xmlChar * xmlParseNameComplex(xmlParserCtxtPtr ctxt);
2605	static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt,
2606	int len, int alloc, int normalize);
2607
2608	/**
2609	* xmlParseName:
2610	* @ctxt: an XML parser context
2611	*
2612	* parse an XML name.
2613	*
2614	* [4] NameChar ::= Letter \| Digit \| '.' \| '-' \| '_' \| ':' \|
2615	* CombiningChar \| Extender
2616	*
2617	* [5] Name ::= (Letter \| '_' \| ':') (NameChar)*
2618	*
2619	* [6] Names ::= Name (#x20 Name)*
2620	*
2621	* Returns the Name parsed or NULL
2622	*/
2623
2624	const xmlChar *
2625	xmlParseName(xmlParserCtxtPtr ctxt) {
2626	const xmlChar *in;
2627	const xmlChar *ret;
2628	int count = 0;
2629
2630	GROW;
2631
2632	/*
2633	* Accelerator for simple ASCII names
2634	*/
2635	in = ctxt->input->cur;
2636	if (((in >= 0x61) && (in <= 0x7A)) \|\|
2637	((in >= 0x41) && (in <= 0x5A)) \|\|
2638	(in == '_') \|\| (in == ':')) {
2639	in++;
2640	while (((in >= 0x61) && (in <= 0x7A)) \|\|
2641	((in >= 0x41) && (in <= 0x5A)) \|\|
2642	((in >= 0x30) && (in <= 0x39)) \|\|
2643	(in == '_') \|\| (in == '-') \|\|
2644	(in == ':') \|\| (in == '.'))
2645	in++;
2646	if ((in > 0) && (in < 0x80)) {
2647	count = in - ctxt->input->cur;
2648	ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
2649	ctxt->input->cur = in;
2650	ctxt->nbChars += count;
2651	ctxt->input->col += count;
2652	if (ret == NULL)
2653	xmlErrMemory(ctxt, NULL);
2654	return(ret);
2655	}
2656	}
2657	return(xmlParseNameComplex(ctxt));
2658	}
2659
2660	/**
2661	* xmlParseNameAndCompare:
2662	* @ctxt: an XML parser context
2663	*
2664	* parse an XML name and compares for match
2665	* (specialized for endtag parsing)
2666	*
2667	* Returns NULL for an illegal name, (xmlChar*) 1 for success
2668	* and the name for mismatch
2669	*/
2670
2671	static const xmlChar *
2672	xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) {
2673	register const xmlChar *cmp = other;
2674	register const xmlChar *in;
2675	const xmlChar *ret;
2676
2677	GROW;
2678
2679	in = ctxt->input->cur;
2680	while (in != 0 && in == *cmp) {
2681	++in;
2682	++cmp;
2683	ctxt->input->col++;
2684	}
2685	if (cmp == 0 && (in == '>' \|\| IS_BLANK_CH (*in))) {
2686	/* success */
2687	ctxt->input->cur = in;
2688	return (const xmlChar*) 1;
2689	}
2690	/* failure (or end of input buffer), check with full function */
2691	ret = xmlParseName (ctxt);
2692	/* strings coming from the dictionnary direct compare possible */
2693	if (ret == other) {
2694	return (const xmlChar*) 1;
2695	}
2696	return ret;
2697	}
2698
2699	static const xmlChar *
2700	xmlParseNameComplex(xmlParserCtxtPtr ctxt) {
2701	int len = 0, l;
2702	int c;
2703	int count = 0;
2704
2705	/*
2706	* Handler for more complex cases
2707	*/
2708	GROW;
2709	c = CUR_CHAR(l);
2710	if ((c == ' ') \|\| (c == '>') \|\| (c == '/') \|\| /* accelerators */
2711	(!IS_LETTER(c) && (c != '_') &&
2712	(c != ':'))) {
2713	return(NULL);
2714	}
2715
2716	while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
2717	((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\|
2718	(c == '.') \|\| (c == '-') \|\|
2719	(c == '_') \|\| (c == ':') \|\|
2720	(IS_COMBINING(c)) \|\|
2721	(IS_EXTENDER(c)))) {
2722	if (count++ > 100) {
2723	count = 0;
2724	GROW;
2725	}
2726	len += l;
2727	NEXTL(l);
2728	c = CUR_CHAR(l);
2729	}
2730	if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r'))
2731	return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len));
2732	return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
2733	}
2734
2735	/**
2736	* xmlParseStringName:
2737	* @ctxt: an XML parser context
2738	* @str: a pointer to the string pointer (IN/OUT)
2739	*
2740	* parse an XML name.
2741	*
2742	* [4] NameChar ::= Letter \| Digit \| '.' \| '-' \| '_' \| ':' \|
2743	* CombiningChar \| Extender
2744	*
2745	* [5] Name ::= (Letter \| '_' \| ':') (NameChar)*
2746	*
2747	* [6] Names ::= Name (#x20 Name)*
2748	*
2749	* Returns the Name parsed or NULL. The @str pointer
2750	* is updated to the current location in the string.
2751	*/
2752
2753	static xmlChar *
2754	xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) {
2755	xmlChar buf[XML_MAX_NAMELEN + 5];
2756	const xmlChar cur = str;
2757	int len = 0, l;
2758	int c;
2759
2760	c = CUR_SCHAR(cur, l);
2761	if (!IS_LETTER(c) && (c != '_') &&
2762	(c != ':')) {
2763	return(NULL);
2764	}
2765
2766	while ((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\| /* test bigentname.xml */
2767	(c == '.') \|\| (c == '-') \|\|
2768	(c == '_') \|\| (c == ':') \|\|
2769	(IS_COMBINING(c)) \|\|
2770	(IS_EXTENDER(c))) {
2771	COPY_BUF(l,buf,len,c);
2772	cur += l;
2773	c = CUR_SCHAR(cur, l);
2774	if (len >= XML_MAX_NAMELEN) { /* test bigentname.xml */
2775	/*
2776	* Okay someone managed to make a huge name, so he's ready to pay
2777	* for the processing speed.
2778	*/
2779	xmlChar *buffer;
2780	int max = len * 2;
2781
2782	buffer = (xmlChar ) xmlMallocAtomic(max sizeof(xmlChar));
2783	if (buffer == NULL) {
2784	xmlErrMemory(ctxt, NULL);
2785	return(NULL);
2786	}
2787	memcpy(buffer, buf, len);
2788	while ((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\|
2789	/* test bigentname.xml */
2790	(c == '.') \|\| (c == '-') \|\|
2791	(c == '_') \|\| (c == ':') \|\|
2792	(IS_COMBINING(c)) \|\|
2793	(IS_EXTENDER(c))) {
2794	if (len + 10 > max) {
2795	xmlChar *tmp;
2796	max *= 2;
2797	tmp = (xmlChar *) xmlRealloc(buffer,
2798	max * sizeof(xmlChar));
2799	if (tmp == NULL) {
2800	xmlErrMemory(ctxt, NULL);
2801	xmlFree(buffer);
2802	return(NULL);
2803	}
2804	buffer = tmp;
2805	}
2806	COPY_BUF(l,buffer,len,c);
2807	cur += l;
2808	c = CUR_SCHAR(cur, l);
2809	}
2810	buffer[len] = 0;
2811	*str = cur;
2812	return(buffer);
2813	}
2814	}
2815	*str = cur;
2816	return(xmlStrndup(buf, len));
2817	}
2818
2819	/**
2820	* xmlParseNmtoken:
2821	* @ctxt: an XML parser context
2822	*
2823	* parse an XML Nmtoken.
2824	*
2825	* [7] Nmtoken ::= (NameChar)+
2826	*
2827	* [8] Nmtokens ::= Nmtoken (#x20 Nmtoken)*
2828	*
2829	* Returns the Nmtoken parsed or NULL
2830	*/
2831
2832	xmlChar *
2833	xmlParseNmtoken(xmlParserCtxtPtr ctxt) {
2834	xmlChar buf[XML_MAX_NAMELEN + 5];
2835	int len = 0, l;
2836	int c;
2837	int count = 0;
2838
2839	GROW;
2840	c = CUR_CHAR(l);
2841
2842	while ((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\| /* test bigtoken.xml */
2843	(c == '.') \|\| (c == '-') \|\|
2844	(c == '_') \|\| (c == ':') \|\|
2845	(IS_COMBINING(c)) \|\|
2846	(IS_EXTENDER(c))) {
2847	if (count++ > 100) {
2848	count = 0;
2849	GROW;
2850	}
2851	COPY_BUF(l,buf,len,c);
2852	NEXTL(l);
2853	c = CUR_CHAR(l);
2854	if (len >= XML_MAX_NAMELEN) {
2855	/*
2856	* Okay someone managed to make a huge token, so he's ready to pay
2857	* for the processing speed.
2858	*/
2859	xmlChar *buffer;
2860	int max = len * 2;
2861
2862	buffer = (xmlChar ) xmlMallocAtomic(max sizeof(xmlChar));
2863	if (buffer == NULL) {
2864	xmlErrMemory(ctxt, NULL);
2865	return(NULL);
2866	}
2867	memcpy(buffer, buf, len);
2868	while ((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\| /* test bigtoken.xml */
2869	(c == '.') \|\| (c == '-') \|\|
2870	(c == '_') \|\| (c == ':') \|\|
2871	(IS_COMBINING(c)) \|\|
2872	(IS_EXTENDER(c))) {
2873	if (count++ > 100) {
2874	count = 0;
2875	GROW;
2876	}
2877	if (len + 10 > max) {
2878	xmlChar *tmp;
2879
2880	max *= 2;
2881	tmp = (xmlChar *) xmlRealloc(buffer,
2882	max * sizeof(xmlChar));
2883	if (tmp == NULL) {
2884	xmlErrMemory(ctxt, NULL);
2885	xmlFree(buffer);
2886	return(NULL);
2887	}
2888	buffer = tmp;
2889	}
2890	COPY_BUF(l,buffer,len,c);
2891	NEXTL(l);
2892	c = CUR_CHAR(l);
2893	}
2894	buffer[len] = 0;
2895	return(buffer);
2896	}
2897	}
2898	if (len == 0)
2899	return(NULL);
2900	return(xmlStrndup(buf, len));
2901	}
2902
2903	/**
2904	* xmlParseEntityValue:
2905	* @ctxt: an XML parser context
2906	* @orig: if non-NULL store a copy of the original entity value
2907	*
2908	* parse a value for ENTITY declarations
2909	*
2910	* [9] EntityValue ::= '"' ([^%&"] \| PEReference \| Reference)* '"' \|
2911	* "'" ([^%&'] \| PEReference \| Reference)* "'"
2912	*
2913	* Returns the EntityValue parsed with reference substituted or NULL
2914	*/
2915
2916	xmlChar *
2917	xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) {
2918	xmlChar *buf = NULL;
2919	int len = 0;
2920	int size = XML_PARSER_BUFFER_SIZE;
2921	int c, l;
2922	xmlChar stop;
2923	xmlChar *ret = NULL;
2924	const xmlChar *cur = NULL;
2925	xmlParserInputPtr input;
2926
2927	if (RAW == '"') stop = '"';
2928	else if (RAW == '\'') stop = '\'';
2929	else {
2930	xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL);
2931	return(NULL);
2932	}
2933	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
2934	if (buf == NULL) {
2935	xmlErrMemory(ctxt, NULL);
2936	return(NULL);
2937	}
2938
2939	/*
2940	* The content of the entity definition is copied in a buffer.
2941	*/
2942
2943	ctxt->instate = XML_PARSER_ENTITY_VALUE;
2944	input = ctxt->input;
2945	GROW;
2946	NEXT;
2947	c = CUR_CHAR(l);
2948	/*
2949	* NOTE: 4.4.5 Included in Literal
2950	* When a parameter entity reference appears in a literal entity
2951	* value, ... a single or double quote character in the replacement
2952	* text is always treated as a normal data character and will not
2953	* terminate the literal.
2954	* In practice it means we stop the loop only when back at parsing
2955	* the initial entity and the quote is found
2956	*/
2957	while ((IS_CHAR(c)) && ((c != stop) \|\| /* checked */
2958	(ctxt->input != input))) {
2959	if (len + 5 >= size) {
2960	xmlChar *tmp;
2961
2962	size *= 2;
2963	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
2964	if (tmp == NULL) {
2965	xmlErrMemory(ctxt, NULL);
2966	xmlFree(buf);
2967	return(NULL);
2968	}
2969	buf = tmp;
2970	}
2971	COPY_BUF(l,buf,len,c);
2972	NEXTL(l);
2973	/*
2974	* Pop-up of finished entities.
2975	*/
2976	while ((RAW == 0) && (ctxt->inputNr > 1)) /* non input consuming */
2977	xmlPopInput(ctxt);
2978
2979	GROW;
2980	c = CUR_CHAR(l);
2981	if (c == 0) {
2982	GROW;
2983	c = CUR_CHAR(l);
2984	}
2985	}
2986	buf[len] = 0;
2987
2988	/*
2989	* Raise problem w.r.t. '&' and '%' being used in non-entities
2990	* reference constructs. Note Charref will be handled in
2991	* xmlStringDecodeEntities()
2992	*/
2993	cur = buf;
2994	while (cur != 0) { / non input consuming */
2995	if ((cur == '%') \|\| ((cur == '&') && (cur[1] != '#'))) {
2996	xmlChar *name;
2997	xmlChar tmp = *cur;
2998
2999	cur++;
3000	name = xmlParseStringName(ctxt, &cur);
3001	if ((name == NULL) \|\| (*cur != ';')) {
3002	xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR,
3003	"EntityValue: '%c' forbidden except for entities references\n",
3004	tmp);
3005	}
3006	if ((tmp == '%') && (ctxt->inSubset == 1) &&
3007	(ctxt->inputNr == 1)) {
3008	xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL);
3009	}
3010	if (name != NULL)
3011	xmlFree(name);
3012	if (*cur == 0)
3013	break;
3014	}
3015	cur++;
3016	}
3017
3018	/*
3019	* Then PEReference entities are substituted.
3020	*/
3021	if (c != stop) {
3022	xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL);
3023	xmlFree(buf);
3024	} else {
3025	NEXT;
3026	/*
3027	* NOTE: 4.4.7 Bypassed
3028	* When a general entity reference appears in the EntityValue in
3029	* an entity declaration, it is bypassed and left as is.
3030	* so XML_SUBSTITUTE_REF is not set here.
3031	*/
3032	ret = xmlStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF,
3033	0, 0, 0);
3034	if (orig != NULL)
3035	*orig = buf;
3036	else
3037	xmlFree(buf);
3038	}
3039
3040	return(ret);
3041	}
3042
3043	/**
3044	* xmlParseAttValueComplex:
3045	* @ctxt: an XML parser context
3046	* @len: the resulting attribute len
3047	* @normalize: wether to apply the inner normalization
3048	*
3049	* parse a value for an attribute, this is the fallback function
3050	* of xmlParseAttValue() when the attribute parsing requires handling
3051	* of non-ASCII characters, or normalization compaction.
3052	*
3053	* Returns the AttValue parsed or NULL. The value has to be freed by the caller.
3054	*/
3055	static xmlChar *
3056	xmlParseAttValueComplex(xmlParserCtxtPtr ctxt, int *attlen, int normalize) {
3057	xmlChar limit = 0;
3058	xmlChar *buf = NULL;
3059	int len = 0;
3060	int buf_size = 0;
3061	int c, l, in_space = 0;
3062	xmlChar *current = NULL;
3063	xmlEntityPtr ent;
3064
3065	if (NXT(0) == '"') {
3066	ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
3067	limit = '"';
3068	NEXT;
3069	} else if (NXT(0) == '\'') {
3070	limit = '\'';
3071	ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
3072	NEXT;
3073	} else {
3074	xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
3075	return(NULL);
3076	}
3077
3078	/*
3079	* allocate a translation buffer.
3080	*/
3081	buf_size = XML_PARSER_BUFFER_SIZE;
3082	buf = (xmlChar ) xmlMallocAtomic(buf_size sizeof(xmlChar));
3083	if (buf == NULL) goto mem_error;
3084
3085	/*
3086	* OK loop until we reach one of the ending char or a size limit.
3087	*/
3088	c = CUR_CHAR(l);
3089	while ((NXT(0) != limit) && /* checked */
3090	(IS_CHAR(c)) && (c != '<')) {
3091	if (c == 0) break;
3092	if (c == '&') {
3093	in_space = 0;
3094	if (NXT(1) == '#') {
3095	int val = xmlParseCharRef(ctxt);
3096
3097	if (val == '&') {
3098	if (ctxt->replaceEntities) {
3099	if (len > buf_size - 10) {
3100	growBuffer(buf);
3101	}
3102	buf[len++] = '&';
3103	} else {
3104	/*
3105	* The reparsing will be done in xmlStringGetNodeList()
3106	* called by the attribute() function in SAX.c
3107	*/
3108	if (len > buf_size - 10) {
3109	growBuffer(buf);
3110	}
3111	buf[len++] = '&';
3112	buf[len++] = '#';
3113	buf[len++] = '3';
3114	buf[len++] = '8';
3115	buf[len++] = ';';
3116	}
3117	} else {
3118	if (len > buf_size - 10) {
3119	growBuffer(buf);
3120	}
3121	len += xmlCopyChar(0, &buf[len], val);
3122	}
3123	} else {
3124	ent = xmlParseEntityRef(ctxt);
3125	ctxt->nbentities++;
3126	if (ent != NULL)
3127	ctxt->nbentities += ent->checked;
3128	if ((ent != NULL) &&
3129	(ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
3130	if (len > buf_size - 10) {
3131	growBuffer(buf);
3132	}
3133	if ((ctxt->replaceEntities == 0) &&
3134	(ent->content[0] == '&')) {
3135	buf[len++] = '&';
3136	buf[len++] = '#';
3137	buf[len++] = '3';
3138	buf[len++] = '8';
3139	buf[len++] = ';';
3140	} else {
3141	buf[len++] = ent->content[0];
3142	}
3143	} else if ((ent != NULL) &&
3144	(ctxt->replaceEntities != 0)) {
3145	xmlChar *rep;
3146
3147	if (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) {
3148	rep = xmlStringDecodeEntities(ctxt, ent->content,
3149	XML_SUBSTITUTE_REF,
3150	0, 0, 0);
3151	if (rep != NULL) {
3152	current = rep;
3153	while (current != 0) { / non input consuming */
3154	buf[len++] = *current++;
3155	if (len > buf_size - 10) {
3156	growBuffer(buf);
3157	}
3158	}
3159	xmlFree(rep);
3160	}
3161	} else {
3162	if (len > buf_size - 10) {
3163	growBuffer(buf);
3164	}
3165	if (ent->content != NULL)
3166	buf[len++] = ent->content[0];
3167	}
3168	} else if (ent != NULL) {
3169	int i = xmlStrlen(ent->name);
3170	const xmlChar *cur = ent->name;
3171
3172	/*
3173	* This may look absurd but is needed to detect
3174	* entities problems
3175	*/
3176	if ((ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
3177	(ent->content != NULL)) {
3178	xmlChar *rep;
3179	rep = xmlStringDecodeEntities(ctxt, ent->content,
3180	XML_SUBSTITUTE_REF, 0, 0, 0);
3181	if (rep != NULL)
3182	xmlFree(rep);
3183	}
3184
3185	/*
3186	* Just output the reference
3187	*/
3188	buf[len++] = '&';
3189	if (len > buf_size - i - 10) {
3190	growBuffer(buf);
3191	}
3192	for (;i > 0;i--)
3193	buf[len++] = *cur++;
3194	buf[len++] = ';';
3195	}
3196	}
3197	} else {
3198	if ((c == 0x20) \|\| (c == 0xD) \|\| (c == 0xA) \|\| (c == 0x9)) {
3199	if ((len != 0) \|\| (!normalize)) {
3200	if ((!normalize) \|\| (!in_space)) {
3201	COPY_BUF(l,buf,len,0x20);
3202	if (len > buf_size - 10) {
3203	growBuffer(buf);
3204	}
3205	}
3206	in_space = 1;
3207	}
3208	} else {
3209	in_space = 0;
3210	COPY_BUF(l,buf,len,c);
3211	if (len > buf_size - 10) {
3212	growBuffer(buf);
3213	}
3214	}
3215	NEXTL(l);
3216	}
3217	GROW;
3218	c = CUR_CHAR(l);
3219	}
3220	if ((in_space) && (normalize)) {
3221	while (buf[len - 1] == 0x20) len--;
3222	}
3223	buf[len] = 0;
3224	if (RAW == '<') {
3225	xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL);
3226	} else if (RAW != limit) {
3227	if ((c != 0) && (!IS_CHAR(c))) {
3228	xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
3229	"invalid character in attribute value\n");
3230	} else {
3231	xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
3232	"AttValue: ' expected\n");
3233	}
3234	} else
3235	NEXT;
3236	if (attlen != NULL) *attlen = len;
3237	return(buf);
3238
3239	mem_error:
3240	xmlErrMemory(ctxt, NULL);
3241	return(NULL);
3242	}
3243
3244	/**
3245	* xmlParseAttValue:
3246	* @ctxt: an XML parser context
3247	*
3248	* parse a value for an attribute
3249	* Note: the parser won't do substitution of entities here, this
3250	* will be handled later in xmlStringGetNodeList
3251	*
3252	* [10] AttValue ::= '"' ([^<&"] \| Reference)* '"' \|
3253	* "'" ([^<&'] \| Reference)* "'"
3254	*
3255	* 3.3.3 Attribute-Value Normalization:
3256	* Before the value of an attribute is passed to the application or
3257	* checked for validity, the XML processor must normalize it as follows:
3258	* - a character reference is processed by appending the referenced
3259	* character to the attribute value
3260	* - an entity reference is processed by recursively processing the
3261	* replacement text of the entity
3262	* - a whitespace character (#x20, #xD, #xA, #x9) is processed by
3263	* appending #x20 to the normalized value, except that only a single
3264	* #x20 is appended for a "#xD#xA" sequence that is part of an external
3265	* parsed entity or the literal entity value of an internal parsed entity
3266	* - other characters are processed by appending them to the normalized value
3267	* If the declared value is not CDATA, then the XML processor must further
3268	* process the normalized attribute value by discarding any leading and
3269	* trailing space (#x20) characters, and by replacing sequences of space
3270	* (#x20) characters by a single space (#x20) character.
3271	* All attributes for which no declaration has been read should be treated
3272	* by a non-validating parser as if declared CDATA.
3273	*
3274	* Returns the AttValue parsed or NULL. The value has to be freed by the caller.
3275	*/
3276
3277
3278	xmlChar *
3279	xmlParseAttValue(xmlParserCtxtPtr ctxt) {
3280	if ((ctxt == NULL) \|\| (ctxt->input == NULL)) return(NULL);
3281	return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0));
3282	}
3283
3284	/**
3285	* xmlParseSystemLiteral:
3286	* @ctxt: an XML parser context
3287	*
3288	* parse an XML Literal
3289	*
3290	* [11] SystemLiteral ::= ('"' [^"]* '"') \| ("'" [^']* "'")
3291	*
3292	* Returns the SystemLiteral parsed or NULL
3293	*/
3294
3295	xmlChar *
3296	xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) {
3297	xmlChar *buf = NULL;
3298	int len = 0;
3299	int size = XML_PARSER_BUFFER_SIZE;
3300	int cur, l;
3301	xmlChar stop;
3302	int state = ctxt->instate;
3303	int count = 0;
3304
3305	SHRINK;
3306	if (RAW == '"') {
3307	NEXT;
3308	stop = '"';
3309	} else if (RAW == '\'') {
3310	NEXT;
3311	stop = '\'';
3312	} else {
3313	xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
3314	return(NULL);
3315	}
3316
3317	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
3318	if (buf == NULL) {
3319	xmlErrMemory(ctxt, NULL);
3320	return(NULL);
3321	}
3322	ctxt->instate = XML_PARSER_SYSTEM_LITERAL;
3323	cur = CUR_CHAR(l);
3324	while ((IS_CHAR(cur)) && (cur != stop)) { /* checked */
3325	if (len + 5 >= size) {
3326	xmlChar *tmp;
3327
3328	size *= 2;
3329	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
3330	if (tmp == NULL) {
3331	xmlFree(buf);
3332	xmlErrMemory(ctxt, NULL);
3333	ctxt->instate = (xmlParserInputState) state;
3334	return(NULL);
3335	}
3336	buf = tmp;
3337	}
3338	count++;
3339	if (count > 50) {
3340	GROW;
3341	count = 0;
3342	}
3343	COPY_BUF(l,buf,len,cur);
3344	NEXTL(l);
3345	cur = CUR_CHAR(l);
3346	if (cur == 0) {
3347	GROW;
3348	SHRINK;
3349	cur = CUR_CHAR(l);
3350	}
3351	}
3352	buf[len] = 0;
3353	ctxt->instate = (xmlParserInputState) state;
3354	if (!IS_CHAR(cur)) {
3355	xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
3356	} else {
3357	NEXT;
3358	}
3359	return(buf);
3360	}
3361
3362	/**
3363	* xmlParsePubidLiteral:
3364	* @ctxt: an XML parser context
3365	*
3366	* parse an XML public literal
3367	*
3368	* [12] PubidLiteral ::= '"' PubidChar* '"' \| "'" (PubidChar - "'")* "'"
3369	*
3370	* Returns the PubidLiteral parsed or NULL.
3371	*/
3372
3373	xmlChar *
3374	xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) {
3375	xmlChar *buf = NULL;
3376	int len = 0;
3377	int size = XML_PARSER_BUFFER_SIZE;
3378	xmlChar cur;
3379	xmlChar stop;
3380	int count = 0;
3381	xmlParserInputState oldstate = ctxt->instate;
3382
3383	SHRINK;
3384	if (RAW == '"') {
3385	NEXT;
3386	stop = '"';
3387	} else if (RAW == '\'') {
3388	NEXT;
3389	stop = '\'';
3390	} else {
3391	xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
3392	return(NULL);
3393	}
3394	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
3395	if (buf == NULL) {
3396	xmlErrMemory(ctxt, NULL);
3397	return(NULL);
3398	}
3399	ctxt->instate = XML_PARSER_PUBLIC_LITERAL;
3400	cur = CUR;
3401	while ((IS_PUBIDCHAR_CH(cur)) && (cur != stop)) { /* checked */
3402	if (len + 1 >= size) {
3403	xmlChar *tmp;
3404
3405	size *= 2;
3406	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
3407	if (tmp == NULL) {
3408	xmlErrMemory(ctxt, NULL);
3409	xmlFree(buf);
3410	return(NULL);
3411	}
3412	buf = tmp;
3413	}
3414	buf[len++] = cur;
3415	count++;
3416	if (count > 50) {
3417	GROW;
3418	count = 0;
3419	}
3420	NEXT;
3421	cur = CUR;
3422	if (cur == 0) {
3423	GROW;
3424	SHRINK;
3425	cur = CUR;
3426	}
3427	}
3428	buf[len] = 0;
3429	if (cur != stop) {
3430	xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
3431	} else {
3432	NEXT;
3433	}
3434	ctxt->instate = oldstate;
3435	return(buf);
3436	}
3437
3438	void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata);
3439
3440	/*
3441	* used for the test in the inner loop of the char data testing
3442	*/
3443	static const unsigned char test_char_data[256] = {
3444	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3445	0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x9, CR/LF separated */
3446	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3447	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3448	0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x00, 0x27, /* & */
3449	0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
3450	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
3451	0x38, 0x39, 0x3A, 0x3B, 0x00, 0x3D, 0x3E, 0x3F, /* < */
3452	0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
3453	0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
3454	0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
3455	0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x00, 0x5E, 0x5F, /* ] */
3456	0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
3457	0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
3458	0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
3459	0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
3460	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* non-ascii */
3461	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3462	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3463	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3464	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3465	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3466	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3467	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3468	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3469	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3470	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3471	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3472	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3473	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3474	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3475	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
3476	};
3477
3478	/**
3479	* xmlParseCharData:
3480	* @ctxt: an XML parser context
3481	* @cdata: int indicating whether we are within a CDATA section
3482	*
3483	* parse a CharData section.
3484	* if we are within a CDATA section ']]>' marks an end of section.
3485	*
3486	* The right angle bracket (>) may be represented using the string ">",
3487	* and must, for compatibility, be escaped using ">" or a character
3488	* reference when it appears in the string "]]>" in content, when that
3489	* string is not marking the end of a CDATA section.
3490	*
3491	* [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
3492	*/
3493
3494	void
3495	xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata) {
3496	const xmlChar *in;
3497	int nbchar = 0;
3498	int line = ctxt->input->line;
3499	int col = ctxt->input->col;
3500	int ccol;
3501
3502	SHRINK;
3503	GROW;
3504	/*
3505	* Accelerated common case where input don't need to be
3506	* modified before passing it to the handler.
3507	*/
3508	if (!cdata) {
3509	in = ctxt->input->cur;
3510	do {
3511	get_more_space:
3512	while (*in == 0x20) in++;
3513	if (*in == 0xA) {
3514	do {
3515	ctxt->input->line++; ctxt->input->col = 1;
3516	in++;
3517	} while (*in == 0xA);
3518	goto get_more_space;
3519	}
3520	if (*in == '<') {
3521	nbchar = in - ctxt->input->cur;
3522	if (nbchar > 0) {
3523	const xmlChar *tmp = ctxt->input->cur;
3524	ctxt->input->cur = in;
3525
3526	if ((ctxt->sax != NULL) &&
3527	(ctxt->sax->ignorableWhitespace !=
3528	ctxt->sax->characters)) {
3529	if (areBlanks(ctxt, tmp, nbchar, 1)) {
3530	if (ctxt->sax->ignorableWhitespace != NULL)
3531	ctxt->sax->ignorableWhitespace(ctxt->userData,
3532	tmp, nbchar);
3533	} else {
3534	if (ctxt->sax->characters != NULL)
3535	ctxt->sax->characters(ctxt->userData,
3536	tmp, nbchar);
3537	if (*ctxt->space == -1)
3538	*ctxt->space = -2;
3539	}
3540	} else if ((ctxt->sax != NULL) &&
3541	(ctxt->sax->characters != NULL)) {
3542	ctxt->sax->characters(ctxt->userData,
3543	tmp, nbchar);
3544	}
3545	}
3546	return;
3547	}
3548
3549	get_more:
3550	ccol = ctxt->input->col;
3551	while (test_char_data[*in]) {
3552	in++;
3553	ccol++;
3554	}
3555	ctxt->input->col = ccol;
3556	if (*in == 0xA) {
3557	do {
3558	ctxt->input->line++; ctxt->input->col = 1;
3559	in++;
3560	} while (*in == 0xA);
3561	goto get_more;
3562	}
3563	if (*in == ']') {
3564	if ((in[1] == ']') && (in[2] == '>')) {
3565	xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
3566	ctxt->input->cur = in;
3567	return;
3568	}
3569	in++;
3570	ctxt->input->col++;
3571	goto get_more;
3572	}
3573	nbchar = in - ctxt->input->cur;
3574	if (nbchar > 0) {
3575	if ((ctxt->sax != NULL) &&
3576	(ctxt->sax->ignorableWhitespace !=
3577	ctxt->sax->characters) &&
3578	(IS_BLANK_CH(*ctxt->input->cur))) {
3579	const xmlChar *tmp = ctxt->input->cur;
3580	ctxt->input->cur = in;
3581
3582	if (areBlanks(ctxt, tmp, nbchar, 0)) {
3583	if (ctxt->sax->ignorableWhitespace != NULL)
3584	ctxt->sax->ignorableWhitespace(ctxt->userData,
3585	tmp, nbchar);
3586	} else {
3587	if (ctxt->sax->characters != NULL)
3588	ctxt->sax->characters(ctxt->userData,
3589	tmp, nbchar);
3590	if (*ctxt->space == -1)
3591	*ctxt->space = -2;
3592	}
3593	line = ctxt->input->line;
3594	col = ctxt->input->col;
3595	} else if (ctxt->sax != NULL) {
3596	if (ctxt->sax->characters != NULL)
3597	ctxt->sax->characters(ctxt->userData,
3598	ctxt->input->cur, nbchar);
3599	line = ctxt->input->line;
3600	col = ctxt->input->col;
3601	}
3602	/* something really bad happened in the SAX callback */
3603	if (ctxt->instate != XML_PARSER_CONTENT)
3604	return;
3605	}
3606	ctxt->input->cur = in;
3607	if (*in == 0xD) {
3608	in++;
3609	if (*in == 0xA) {
3610	ctxt->input->cur = in;
3611	in++;
3612	ctxt->input->line++; ctxt->input->col = 1;
3613	continue; /* while */
3614	}
3615	in--;
3616	}
3617	if (*in == '<') {
3618	return;
3619	}
3620	if (*in == '&') {
3621	return;
3622	}
3623	SHRINK;
3624	GROW;
3625	in = ctxt->input->cur;
3626	} while (((in >= 0x20) && (in <= 0x7F)) \|\| (*in == 0x09));
3627	nbchar = 0;
3628	}
3629	ctxt->input->line = line;
3630	ctxt->input->col = col;
3631	xmlParseCharDataComplex(ctxt, cdata);
3632	}
3633
3634	/**
3635	* xmlParseCharDataComplex:
3636	* @ctxt: an XML parser context
3637	* @cdata: int indicating whether we are within a CDATA section
3638	*
3639	* parse a CharData section.this is the fallback function
3640	* of xmlParseCharData() when the parsing requires handling
3641	* of non-ASCII characters.
3642	*/
3643	void
3644	xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata) {
3645	xmlChar buf[XML_PARSER_BIG_BUFFER_SIZE + 5];
3646	int nbchar = 0;
3647	int cur, l;
3648	int count = 0;
3649
3650	SHRINK;
3651	GROW;
3652	cur = CUR_CHAR(l);
3653	while ((cur != '<') && /* checked */
3654	(cur != '&') &&
3655	(IS_CHAR(cur))) /* test also done in xmlCurrentChar() */ {
3656	if ((cur == ']') && (NXT(1) == ']') &&
3657	(NXT(2) == '>')) {
3658	if (cdata) break;
3659	else {
3660	xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
3661	}
3662	}
3663	COPY_BUF(l,buf,nbchar,cur);
3664	if (nbchar >= XML_PARSER_BIG_BUFFER_SIZE) {
3665	buf[nbchar] = 0;
3666
3667	/*
3668	* OK the segment is to be consumed as chars.
3669	*/
3670	if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
3671	if (areBlanks(ctxt, buf, nbchar, 0)) {
3672	if (ctxt->sax->ignorableWhitespace != NULL)
3673	ctxt->sax->ignorableWhitespace(ctxt->userData,
3674	buf, nbchar);
3675	} else {
3676	if (ctxt->sax->characters != NULL)
3677	ctxt->sax->characters(ctxt->userData, buf, nbchar);
3678	if ((ctxt->sax->characters !=
3679	ctxt->sax->ignorableWhitespace) &&
3680	(*ctxt->space == -1))
3681	*ctxt->space = -2;
3682	}
3683	}
3684	nbchar = 0;
3685	/* something really bad happened in the SAX callback */
3686	if (ctxt->instate != XML_PARSER_CONTENT)
3687	return;
3688	}
3689	count++;
3690	if (count > 50) {
3691	GROW;
3692	count = 0;
3693	}
3694	NEXTL(l);
3695	cur = CUR_CHAR(l);
3696	}
3697	if (nbchar != 0) {
3698	buf[nbchar] = 0;
3699	/*
3700	* OK the segment is to be consumed as chars.
3701	*/
3702	if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
3703	if (areBlanks(ctxt, buf, nbchar, 0)) {
3704	if (ctxt->sax->ignorableWhitespace != NULL)
3705	ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
3706	} else {
3707	if (ctxt->sax->characters != NULL)
3708	ctxt->sax->characters(ctxt->userData, buf, nbchar);
3709	if ((ctxt->sax->characters != ctxt->sax->ignorableWhitespace) &&
3710	(*ctxt->space == -1))
3711	*ctxt->space = -2;
3712	}
3713	}
3714	}
3715	if ((cur != 0) && (!IS_CHAR(cur))) {
3716	/* Generate the error and skip the offending character */
3717	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
3718	"PCDATA invalid Char value %d\n",
3719	cur);
3720	NEXTL(l);
3721	}
3722	}
3723
3724	/**
3725	* xmlParseExternalID:
3726	* @ctxt: an XML parser context
3727	* @publicID: a xmlChar** receiving PubidLiteral
3728	* @strict: indicate whether we should restrict parsing to only
3729	* production [75], see NOTE below
3730	*
3731	* Parse an External ID or a Public ID
3732	*
3733	* NOTE: Productions [75] and [83] interact badly since [75] can generate
3734	* 'PUBLIC' S PubidLiteral S SystemLiteral
3735	*
3736	* [75] ExternalID ::= 'SYSTEM' S SystemLiteral
3737	* \| 'PUBLIC' S PubidLiteral S SystemLiteral
3738	*
3739	* [83] PublicID ::= 'PUBLIC' S PubidLiteral
3740	*
3741	* Returns the function returns SystemLiteral and in the second
3742	* case publicID receives PubidLiteral, is strict is off
3743	* it is possible to return NULL and have publicID set.
3744	*/
3745
3746	xmlChar *
3747	xmlParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) {
3748	xmlChar *URI = NULL;
3749
3750	SHRINK;
3751
3752	*publicID = NULL;
3753	if (CMP6(CUR_PTR, 'S', 'Y', 'S', 'T', 'E', 'M')) {
3754	SKIP(6);
3755	if (!IS_BLANK_CH(CUR)) {
3756	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
3757	"Space required after 'SYSTEM'\n");
3758	}
3759	SKIP_BLANKS;
3760	URI = xmlParseSystemLiteral(ctxt);
3761	if (URI == NULL) {
3762	xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
3763	}
3764	} else if (CMP6(CUR_PTR, 'P', 'U', 'B', 'L', 'I', 'C')) {
3765	SKIP(6);
3766	if (!IS_BLANK_CH(CUR)) {
3767	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
3768	"Space required after 'PUBLIC'\n");
3769	}
3770	SKIP_BLANKS;
3771	*publicID = xmlParsePubidLiteral(ctxt);
3772	if (*publicID == NULL) {
3773	xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL);
3774	}
3775	if (strict) {
3776	/*
3777	* We don't handle [83] so "S SystemLiteral" is required.
3778	*/
3779	if (!IS_BLANK_CH(CUR)) {
3780	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
3781	"Space required after the Public Identifier\n");
3782	}
3783	} else {
3784	/*
3785	* We handle [83] so we return immediately, if
3786	* "S SystemLiteral" is not detected. From a purely parsing
3787	* point of view that's a nice mess.
3788	*/
3789	const xmlChar *ptr;
3790	GROW;
3791
3792	ptr = CUR_PTR;
3793	if (!IS_BLANK_CH(*ptr)) return(NULL);
3794
3795	while (IS_BLANK_CH(ptr)) ptr++; / TODO: dangerous, fix ! */
3796	if ((ptr != '\'') && (ptr != '"')) return(NULL);
3797	}
3798	SKIP_BLANKS;
3799	URI = xmlParseSystemLiteral(ctxt);
3800	if (URI == NULL) {
3801	xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
3802	}
3803	}
3804	return(URI);
3805	}
3806
3807	/**
3808	* xmlParseCommentComplex:
3809	* @ctxt: an XML parser context
3810	* @buf: the already parsed part of the buffer
3811	* @len: number of bytes filles in the buffer
3812	* @size: allocated size of the buffer
3813	*
3814	* Skip an XML (SGML) comment <!-- .... -->
3815	* The spec says that "For compatibility, the string "--" (double-hyphen)
3816	* must not occur within comments. "
3817	* This is the slow routine in case the accelerator for ascii didn't work
3818	*
3819	* [15] Comment ::= '<!--' ((Char - '-') \| ('-' (Char - '-')))* '-->'
3820	*/
3821	static void
3822	xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf, int len, int size) {
3823	int q, ql;
3824	int r, rl;
3825	int cur, l;
3826	xmlParserInputPtr input = ctxt->input;
3827	int count = 0;
3828
3829	if (buf == NULL) {
3830	len = 0;
3831	size = XML_PARSER_BUFFER_SIZE;
3832	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
3833	if (buf == NULL) {
3834	xmlErrMemory(ctxt, NULL);
3835	return;
3836	}
3837	}
3838	GROW; /* Assure there's enough input data */
3839	q = CUR_CHAR(ql);
3840	if (q == 0)
3841	goto not_terminated;
3842	if (!IS_CHAR(q)) {
3843	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
3844	"xmlParseComment: invalid xmlChar value %d\n",
3845	q);
3846	xmlFree (buf);
3847	return;
3848	}
3849	NEXTL(ql);
3850	r = CUR_CHAR(rl);
3851	if (r == 0)
3852	goto not_terminated;
3853	if (!IS_CHAR(r)) {
3854	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
3855	"xmlParseComment: invalid xmlChar value %d\n",
3856	q);
3857	xmlFree (buf);
3858	return;
3859	}
3860	NEXTL(rl);
3861	cur = CUR_CHAR(l);
3862	if (cur == 0)
3863	goto not_terminated;
3864	while (IS_CHAR(cur) && /* checked */
3865	((cur != '>') \|\|
3866	(r != '-') \|\| (q != '-'))) {
3867	if ((r == '-') && (q == '-')) {
3868	xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL);
3869	}
3870	if (len + 5 >= size) {
3871	xmlChar *new_buf;
3872	size *= 2;
3873	new_buf = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
3874	if (new_buf == NULL) {
3875	xmlFree (buf);
3876	xmlErrMemory(ctxt, NULL);
3877	return;
3878	}
3879	buf = new_buf;
3880	}
3881	COPY_BUF(ql,buf,len,q);
3882	q = r;
3883	ql = rl;
3884	r = cur;
3885	rl = l;
3886
3887	count++;
3888	if (count > 50) {
3889	GROW;
3890	count = 0;
3891	}
3892	NEXTL(l);
3893	cur = CUR_CHAR(l);
3894	if (cur == 0) {
3895	SHRINK;
3896	GROW;
3897	cur = CUR_CHAR(l);
3898	}
3899	}
3900	buf[len] = 0;
3901	if (cur == 0) {
3902	xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
3903	"Comment not terminated \n<!--%.50s\n", buf);
3904	} else if (!IS_CHAR(cur)) {
3905	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
3906	"xmlParseComment: invalid xmlChar value %d\n",
3907	cur);
3908	} else {
3909	if (input != ctxt->input) {
3910	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
3911	"Comment doesn't start and stop in the same entity\n");
3912	}
3913	NEXT;
3914	if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
3915	(!ctxt->disableSAX))
3916	ctxt->sax->comment(ctxt->userData, buf);
3917	}
3918	xmlFree(buf);
3919	return;
3920	not_terminated:
3921	xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
3922	"Comment not terminated\n", NULL);
3923	xmlFree(buf);
3924	return;
3925	}
3926
3927	/**
3928	* xmlParseComment:
3929	* @ctxt: an XML parser context
3930	*
3931	* Skip an XML (SGML) comment <!-- .... -->
3932	* The spec says that "For compatibility, the string "--" (double-hyphen)
3933	* must not occur within comments. "
3934	*
3935	* [15] Comment ::= '<!--' ((Char - '-') \| ('-' (Char - '-')))* '-->'
3936	*/
3937	void
3938	xmlParseComment(xmlParserCtxtPtr ctxt) {
3939	xmlChar *buf = NULL;
3940	int size = XML_PARSER_BUFFER_SIZE;
3941	int len = 0;
3942	xmlParserInputState state;
3943	const xmlChar *in;
3944	int nbchar = 0, ccol;
3945
3946	/*
3947	* Check that there is a comment right here.
3948	*/
3949	if ((RAW != '<') \|\| (NXT(1) != '!') \|\|
3950	(NXT(2) != '-') \|\| (NXT(3) != '-')) return;
3951
3952	state = ctxt->instate;
3953	ctxt->instate = XML_PARSER_COMMENT;
3954	SKIP(4);
3955	SHRINK;
3956	GROW;
3957
3958	/*
3959	* Accelerated common case where input don't need to be
3960	* modified before passing it to the handler.
3961	*/
3962	in = ctxt->input->cur;
3963	do {
3964	if (*in == 0xA) {
3965	do {
3966	ctxt->input->line++; ctxt->input->col = 1;
3967	in++;
3968	} while (*in == 0xA);
3969	}
3970	get_more:
3971	ccol = ctxt->input->col;
3972	while (((in > '-') && (in <= 0x7F)) \|\|
3973	((in >= 0x20) && (in < '-')) \|\|
3974	(*in == 0x09)) {
3975	in++;
3976	ccol++;
3977	}
3978	ctxt->input->col = ccol;
3979	if (*in == 0xA) {
3980	do {
3981	ctxt->input->line++; ctxt->input->col = 1;
3982	in++;
3983	} while (*in == 0xA);
3984	goto get_more;
3985	}
3986	nbchar = in - ctxt->input->cur;
3987	/*
3988	* save current set of data
3989	*/
3990	if (nbchar > 0) {
3991	if ((ctxt->sax != NULL) &&
3992	(ctxt->sax->comment != NULL)) {
3993	if (buf == NULL) {
3994	if ((*in == '-') && (in[1] == '-'))
3995	size = nbchar + 1;
3996	else
3997	size = XML_PARSER_BUFFER_SIZE + nbchar;
3998	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
3999	if (buf == NULL) {
4000	xmlErrMemory(ctxt, NULL);
4001	ctxt->instate = state;
4002	return;
4003	}
4004	len = 0;
4005	} else if (len + nbchar + 1 >= size) {
4006	xmlChar *new_buf;
4007	size += len + nbchar + XML_PARSER_BUFFER_SIZE;
4008	new_buf = (xmlChar *) xmlRealloc(buf,
4009	size * sizeof(xmlChar));
4010	if (new_buf == NULL) {
4011	xmlFree (buf);
4012	xmlErrMemory(ctxt, NULL);
4013	ctxt->instate = state;
4014	return;
4015	}
4016	buf = new_buf;
4017	}
4018	memcpy(&buf[len], ctxt->input->cur, nbchar);
4019	len += nbchar;
4020	buf[len] = 0;
4021	}
4022	}
4023	ctxt->input->cur = in;
4024	if (*in == 0xA) {
4025	in++;
4026	ctxt->input->line++; ctxt->input->col = 1;
4027	}
4028	if (*in == 0xD) {
4029	in++;
4030	if (*in == 0xA) {
4031	ctxt->input->cur = in;
4032	in++;
4033	ctxt->input->line++; ctxt->input->col = 1;
4034	continue; /* while */
4035	}
4036	in--;
4037	}
4038	SHRINK;
4039	GROW;
4040	in = ctxt->input->cur;
4041	if (*in == '-') {
4042	if (in[1] == '-') {
4043	if (in[2] == '>') {
4044	SKIP(3);
4045	if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
4046	(!ctxt->disableSAX)) {
4047	if (buf != NULL)
4048	ctxt->sax->comment(ctxt->userData, buf);
4049	else
4050	ctxt->sax->comment(ctxt->userData, BAD_CAST "");
4051	}
4052	if (buf != NULL)
4053	xmlFree(buf);
4054	ctxt->instate = state;
4055	return;
4056	}
4057	if (buf != NULL)
4058	xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4059	"Comment not terminated \n<!--%.50s\n",
4060	buf);
4061	else
4062	xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4063	"Comment not terminated \n", NULL);
4064	in++;
4065	ctxt->input->col++;
4066	}
4067	in++;
4068	ctxt->input->col++;
4069	goto get_more;
4070	}
4071	} while (((in >= 0x20) && (in <= 0x7F)) \|\| (*in == 0x09));
4072	xmlParseCommentComplex(ctxt, buf, len, size);
4073	ctxt->instate = state;
4074	return;
4075	}
4076
4077
4078	/**
4079	* xmlParsePITarget:
4080	* @ctxt: an XML parser context
4081	*
4082	* parse the name of a PI
4083	*
4084	* [17] PITarget ::= Name - (('X' \| 'x') ('M' \| 'm') ('L' \| 'l'))
4085	*
4086	* Returns the PITarget name or NULL
4087	*/
4088
4089	const xmlChar *
4090	xmlParsePITarget(xmlParserCtxtPtr ctxt) {
4091	const xmlChar *name;
4092
4093	name = xmlParseName(ctxt);
4094	if ((name != NULL) &&
4095	((name[0] == 'x') \|\| (name[0] == 'X')) &&
4096	((name[1] == 'm') \|\| (name[1] == 'M')) &&
4097	((name[2] == 'l') \|\| (name[2] == 'L'))) {
4098	int i;
4099	if ((name[0] == 'x') && (name[1] == 'm') &&
4100	(name[2] == 'l') && (name[3] == 0)) {
4101	xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
4102	"XML declaration allowed only at the start of the document\n");
4103	return(name);
4104	} else if (name[3] == 0) {
4105	xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL);
4106	return(name);
4107	}
4108	for (i = 0;;i++) {
4109	if (xmlW3CPIs[i] == NULL) break;
4110	if (xmlStrEqual(name, (const xmlChar *)xmlW3CPIs[i]))
4111	return(name);
4112	}
4113	xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
4114	"xmlParsePITarget: invalid name prefix 'xml'\n",
4115	NULL, NULL);
4116	}
4117	return(name);
4118	}
4119
4120	#ifdef LIBXML_CATALOG_ENABLED
4121	/**
4122	* xmlParseCatalogPI:
4123	* @ctxt: an XML parser context
4124	* @catalog: the PI value string
4125	*
4126	* parse an XML Catalog Processing Instruction.
4127	*
4128	* <?oasis-xml-catalog catalog="http://example.com/catalog.xml"?>
4129	*
4130	* Occurs only if allowed by the user and if happening in the Misc
4131	* part of the document before any doctype informations
4132	* This will add the given catalog to the parsing context in order
4133	* to be used if there is a resolution need further down in the document
4134	*/
4135
4136	static void
4137	xmlParseCatalogPI(xmlParserCtxtPtr ctxt, const xmlChar *catalog) {
4138	xmlChar *URL = NULL;
4139	const xmlChar tmp, base;
4140	xmlChar marker;
4141
4142	tmp = catalog;
4143	while (IS_BLANK_CH(*tmp)) tmp++;
4144	if (xmlStrncmp(tmp, BAD_CAST"catalog", 7))
4145	goto error;
4146	tmp += 7;
4147	while (IS_BLANK_CH(*tmp)) tmp++;
4148	if (*tmp != '=') {
4149	return;
4150	}
4151	tmp++;
4152	while (IS_BLANK_CH(*tmp)) tmp++;
4153	marker = *tmp;
4154	if ((marker != '\'') && (marker != '"'))
4155	goto error;
4156	tmp++;
4157	base = tmp;
4158	while ((tmp != 0) && (tmp != marker)) tmp++;
4159	if (*tmp == 0)
4160	goto error;
4161	URL = xmlStrndup(base, tmp - base);
4162	tmp++;
4163	while (IS_BLANK_CH(*tmp)) tmp++;
4164	if (*tmp != 0)
4165	goto error;
4166
4167	if (URL != NULL) {
4168	ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL);
4169	xmlFree(URL);
4170	}
4171	return;
4172
4173	error:
4174	xmlWarningMsg(ctxt, XML_WAR_CATALOG_PI,
4175	"Catalog PI syntax error: %s\n",
4176	catalog, NULL);
4177	if (URL != NULL)
4178	xmlFree(URL);
4179	}
4180	#endif
4181
4182	/**
4183	* xmlParsePI:
4184	* @ctxt: an XML parser context
4185	*
4186	* parse an XML Processing Instruction.
4187	*
4188	* [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'
4189	*
4190	* The processing is transfered to SAX once parsed.
4191	*/
4192
4193	void
4194	xmlParsePI(xmlParserCtxtPtr ctxt) {
4195	xmlChar *buf = NULL;
4196	int len = 0;
4197	int size = XML_PARSER_BUFFER_SIZE;
4198	int cur, l;
4199	const xmlChar *target;
4200	xmlParserInputState state;
4201	int count = 0;
4202
4203	if ((RAW == '<') && (NXT(1) == '?')) {
4204	xmlParserInputPtr input = ctxt->input;
4205	state = ctxt->instate;
4206	ctxt->instate = XML_PARSER_PI;
4207	/*
4208	* this is a Processing Instruction.
4209	*/
4210	SKIP(2);
4211	SHRINK;
4212
4213	/*
4214	* Parse the target name and check for special support like
4215	* namespace.
4216	*/
4217	target = xmlParsePITarget(ctxt);
4218	if (target != NULL) {
4219	if ((RAW == '?') && (NXT(1) == '>')) {
4220	if (input != ctxt->input) {
4221	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4222	"PI declaration doesn't start and stop in the same entity\n");
4223	}
4224	SKIP(2);
4225
4226	/*
4227	* SAX: PI detected.
4228	*/
4229	if ((ctxt->sax) && (!ctxt->disableSAX) &&
4230	(ctxt->sax->processingInstruction != NULL))
4231	ctxt->sax->processingInstruction(ctxt->userData,
4232	target, NULL);
4233	ctxt->instate = state;
4234	return;
4235	}
4236	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
4237	if (buf == NULL) {
4238	xmlErrMemory(ctxt, NULL);
4239	ctxt->instate = state;
4240	return;
4241	}
4242	cur = CUR;
4243	if (!IS_BLANK(cur)) {
4244	xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED,
4245	"ParsePI: PI %s space expected\n", target);
4246	}
4247	SKIP_BLANKS;
4248	cur = CUR_CHAR(l);
4249	while (IS_CHAR(cur) && /* checked */
4250	((cur != '?') \|\| (NXT(1) != '>'))) {
4251	if (len + 5 >= size) {
4252	xmlChar *tmp;
4253
4254	size *= 2;
4255	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
4256	if (tmp == NULL) {
4257	xmlErrMemory(ctxt, NULL);
4258	xmlFree(buf);
4259	ctxt->instate = state;
4260	return;
4261	}
4262	buf = tmp;
4263	}
4264	count++;
4265	if (count > 50) {
4266	GROW;
4267	count = 0;
4268	}
4269	COPY_BUF(l,buf,len,cur);
4270	NEXTL(l);
4271	cur = CUR_CHAR(l);
4272	if (cur == 0) {
4273	SHRINK;
4274	GROW;
4275	cur = CUR_CHAR(l);
4276	}
4277	}
4278	buf[len] = 0;
4279	if (cur != '?') {
4280	xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
4281	"ParsePI: PI %s never end ...\n", target);
4282	} else {
4283	if (input != ctxt->input) {
4284	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4285	"PI declaration doesn't start and stop in the same entity\n");
4286	}
4287	SKIP(2);
4288
4289	#ifdef LIBXML_CATALOG_ENABLED
4290	if (((state == XML_PARSER_MISC) \|\|
4291	(state == XML_PARSER_START)) &&
4292	(xmlStrEqual(target, XML_CATALOG_PI))) {
4293	xmlCatalogAllow allow = xmlCatalogGetDefaults();
4294	if ((allow == XML_CATA_ALLOW_DOCUMENT) \|\|
4295	(allow == XML_CATA_ALLOW_ALL))
4296	xmlParseCatalogPI(ctxt, buf);
4297	}
4298	#endif
4299
4300
4301	/*
4302	* SAX: PI detected.
4303	*/
4304	if ((ctxt->sax) && (!ctxt->disableSAX) &&
4305	(ctxt->sax->processingInstruction != NULL))
4306	ctxt->sax->processingInstruction(ctxt->userData,
4307	target, buf);
4308	}
4309	xmlFree(buf);
4310	} else {
4311	xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL);
4312	}
4313	ctxt->instate = state;
4314	}
4315	}
4316
4317	/**
4318	* xmlParseNotationDecl:
4319	* @ctxt: an XML parser context
4320	*
4321	* parse a notation declaration
4322	*
4323	* [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID \| PublicID) S? '>'
4324	*
4325	* Hence there is actually 3 choices:
4326	* 'PUBLIC' S PubidLiteral
4327	* 'PUBLIC' S PubidLiteral S SystemLiteral
4328	* and 'SYSTEM' S SystemLiteral
4329	*
4330	* See the NOTE on xmlParseExternalID().
4331	*/
4332
4333	void
4334	xmlParseNotationDecl(xmlParserCtxtPtr ctxt) {
4335	const xmlChar *name;
4336	xmlChar *Pubid;
4337	xmlChar *Systemid;
4338
4339	if (CMP10(CUR_PTR, '<', '!', 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
4340	xmlParserInputPtr input = ctxt->input;
4341	SHRINK;
4342	SKIP(10);
4343	if (!IS_BLANK_CH(CUR)) {
4344	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4345	"Space required after '<!NOTATION'\n");
4346	return;
4347	}
4348	SKIP_BLANKS;
4349
4350	name = xmlParseName(ctxt);
4351	if (name == NULL) {
4352	xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
4353	return;
4354	}
4355	if (!IS_BLANK_CH(CUR)) {
4356	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4357	"Space required after the NOTATION name'\n");
4358	return;
4359	}
4360	SKIP_BLANKS;
4361
4362	/*
4363	* Parse the IDs.
4364	*/
4365	Systemid = xmlParseExternalID(ctxt, &Pubid, 0);
4366	SKIP_BLANKS;
4367
4368	if (RAW == '>') {
4369	if (input != ctxt->input) {
4370	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4371	"Notation declaration doesn't start and stop in the same entity\n");
4372	}
4373	NEXT;
4374	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
4375	(ctxt->sax->notationDecl != NULL))
4376	ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid);
4377	} else {
4378	xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
4379	}
4380	if (Systemid != NULL) xmlFree(Systemid);
4381	if (Pubid != NULL) xmlFree(Pubid);
4382	}
4383	}
4384
4385	/**
4386	* xmlParseEntityDecl:
4387	* @ctxt: an XML parser context
4388	*
4389	* parse <!ENTITY declarations
4390	*
4391	* [70] EntityDecl ::= GEDecl \| PEDecl
4392	*
4393	* [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>'
4394	*
4395	* [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'
4396	*
4397	* [73] EntityDef ::= EntityValue \| (ExternalID NDataDecl?)
4398	*
4399	* [74] PEDef ::= EntityValue \| ExternalID
4400	*
4401	* [76] NDataDecl ::= S 'NDATA' S Name
4402	*
4403	* [ VC: Notation Declared ]
4404	* The Name must match the declared name of a notation.
4405	*/
4406
4407	void
4408	xmlParseEntityDecl(xmlParserCtxtPtr ctxt) {
4409	const xmlChar *name = NULL;
4410	xmlChar *value = NULL;
4411	xmlChar URI = NULL, literal = NULL;
4412	const xmlChar *ndata = NULL;
4413	int isParameter = 0;
4414	xmlChar *orig = NULL;
4415	int skipped;
4416	unsigned long oldnbent = ctxt->nbentities;
4417
4418	/* GROW; done in the caller */
4419	if (CMP8(CUR_PTR, '<', '!', 'E', 'N', 'T', 'I', 'T', 'Y')) {
4420	xmlParserInputPtr input = ctxt->input;
4421	SHRINK;
4422	SKIP(8);
4423	skipped = SKIP_BLANKS;
4424	if (skipped == 0) {
4425	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4426	"Space required after '<!ENTITY'\n");
4427	}
4428
4429	if (RAW == '%') {
4430	NEXT;
4431	skipped = SKIP_BLANKS;
4432	if (skipped == 0) {
4433	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4434	"Space required after '%'\n");
4435	}
4436	isParameter = 1;
4437	}
4438
4439	name = xmlParseName(ctxt);
4440	if (name == NULL) {
4441	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
4442	"xmlParseEntityDecl: no name\n");
4443	return;
4444	}
4445	skipped = SKIP_BLANKS;
4446	if (skipped == 0) {
4447	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4448	"Space required after the entity name\n");
4449	}
4450
4451	ctxt->instate = XML_PARSER_ENTITY_DECL;
4452	/*
4453	* handle the various case of definitions...
4454	*/
4455	if (isParameter) {
4456	if ((RAW == '"') \|\| (RAW == '\'')) {
4457	value = xmlParseEntityValue(ctxt, &orig);
4458	if (value) {
4459	if ((ctxt->sax != NULL) &&
4460	(!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
4461	ctxt->sax->entityDecl(ctxt->userData, name,
4462	XML_INTERNAL_PARAMETER_ENTITY,
4463	NULL, NULL, value);
4464	}
4465	} else {
4466	URI = xmlParseExternalID(ctxt, &literal, 1);
4467	if ((URI == NULL) && (literal == NULL)) {
4468	xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
4469	}
4470	if (URI) {
4471	xmlURIPtr uri;
4472
4473	uri = xmlParseURI((const char *) URI);
4474	if (uri == NULL) {
4475	xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
4476	"Invalid URI: %s\n", URI);
4477	/*
4478	* This really ought to be a well formedness error
4479	* but the XML Core WG decided otherwise c.f. issue
4480	* E26 of the XML erratas.
4481	*/
4482	} else {
4483	if (uri->fragment != NULL) {
4484	/*
4485	* Okay this is foolish to block those but not
4486	* invalid URIs.
4487	*/
4488	xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
4489	} else {
4490	if ((ctxt->sax != NULL) &&
4491	(!ctxt->disableSAX) &&
4492	(ctxt->sax->entityDecl != NULL))
4493	ctxt->sax->entityDecl(ctxt->userData, name,
4494	XML_EXTERNAL_PARAMETER_ENTITY,
4495	literal, URI, NULL);
4496	}
4497	xmlFreeURI(uri);
4498	}
4499	}
4500	}
4501	} else {
4502	if ((RAW == '"') \|\| (RAW == '\'')) {
4503	value = xmlParseEntityValue(ctxt, &orig);
4504	if ((ctxt->sax != NULL) &&
4505	(!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
4506	ctxt->sax->entityDecl(ctxt->userData, name,
4507	XML_INTERNAL_GENERAL_ENTITY,
4508	NULL, NULL, value);
4509	/*
4510	* For expat compatibility in SAX mode.
4511	*/
4512	if ((ctxt->myDoc == NULL) \|\|
4513	(xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
4514	if (ctxt->myDoc == NULL) {
4515	ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
4516	}
4517	if (ctxt->myDoc->intSubset == NULL)
4518	ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
4519	BAD_CAST "fake", NULL, NULL);
4520
4521	xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY,
4522	NULL, NULL, value);
4523	}
4524	} else {
4525	URI = xmlParseExternalID(ctxt, &literal, 1);
4526	if ((URI == NULL) && (literal == NULL)) {
4527	xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
4528	}
4529	if (URI) {
4530	xmlURIPtr uri;
4531
4532	uri = xmlParseURI((const char *)URI);
4533	if (uri == NULL) {
4534	xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
4535	"Invalid URI: %s\n", URI);
4536	/*
4537	* This really ought to be a well formedness error
4538	* but the XML Core WG decided otherwise c.f. issue
4539	* E26 of the XML erratas.
4540	*/
4541	} else {
4542	if (uri->fragment != NULL) {
4543	/*
4544	* Okay this is foolish to block those but not
4545	* invalid URIs.
4546	*/
4547	xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
4548	}
4549	xmlFreeURI(uri);
4550	}
4551	}
4552	if ((RAW != '>') && (!IS_BLANK_CH(CUR))) {
4553	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4554	"Space required before 'NDATA'\n");
4555	}
4556	SKIP_BLANKS;
4557	if (CMP5(CUR_PTR, 'N', 'D', 'A', 'T', 'A')) {
4558	SKIP(5);
4559	if (!IS_BLANK_CH(CUR)) {
4560	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4561	"Space required after 'NDATA'\n");
4562	}
4563	SKIP_BLANKS;
4564	ndata = xmlParseName(ctxt);
4565	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
4566	(ctxt->sax->unparsedEntityDecl != NULL))
4567	ctxt->sax->unparsedEntityDecl(ctxt->userData, name,
4568	literal, URI, ndata);
4569	} else {
4570	if ((ctxt->sax != NULL) &&
4571	(!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
4572	ctxt->sax->entityDecl(ctxt->userData, name,
4573	XML_EXTERNAL_GENERAL_PARSED_ENTITY,
4574	literal, URI, NULL);
4575	/*
4576	* For expat compatibility in SAX mode.
4577	* assuming the entity repalcement was asked for
4578	*/
4579	if ((ctxt->replaceEntities != 0) &&
4580	((ctxt->myDoc == NULL) \|\|
4581	(xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) {
4582	if (ctxt->myDoc == NULL) {
4583	ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
4584	}
4585
4586	if (ctxt->myDoc->intSubset == NULL)
4587	ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
4588	BAD_CAST "fake", NULL, NULL);
4589	xmlSAX2EntityDecl(ctxt, name,
4590	XML_EXTERNAL_GENERAL_PARSED_ENTITY,
4591	literal, URI, NULL);
4592	}
4593	}
4594	}
4595	}
4596	SKIP_BLANKS;
4597	if (RAW != '>') {
4598	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
4599	"xmlParseEntityDecl: entity %s not terminated\n", name);
4600	} else {
4601	if (input != ctxt->input) {
4602	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4603	"Entity declaration doesn't start and stop in the same entity\n");
4604	}
4605	NEXT;
4606	}
4607	if (orig != NULL) {
4608	/*
4609	* Ugly mechanism to save the raw entity value.
4610	*/
4611	xmlEntityPtr cur = NULL;
4612
4613	if (isParameter) {
4614	if ((ctxt->sax != NULL) &&
4615	(ctxt->sax->getParameterEntity != NULL))
4616	cur = ctxt->sax->getParameterEntity(ctxt->userData, name);
4617	} else {
4618	if ((ctxt->sax != NULL) &&
4619	(ctxt->sax->getEntity != NULL))
4620	cur = ctxt->sax->getEntity(ctxt->userData, name);
4621	if ((cur == NULL) && (ctxt->userData==ctxt)) {
4622	cur = xmlSAX2GetEntity(ctxt, name);
4623	}
4624	}
4625	if (cur != NULL) {
4626	cur->checked = ctxt->nbentities - oldnbent;
4627	if (cur->orig != NULL)
4628	xmlFree(orig);
4629	else
4630	cur->orig = orig;
4631	} else
4632	xmlFree(orig);
4633	}
4634	if (value != NULL) xmlFree(value);
4635	if (URI != NULL) xmlFree(URI);
4636	if (literal != NULL) xmlFree(literal);
4637	}
4638	}
4639
4640	/**
4641	* xmlParseDefaultDecl:
4642	* @ctxt: an XML parser context
4643	* @value: Receive a possible fixed default value for the attribute
4644	*
4645	* Parse an attribute default declaration
4646	*
4647	* [60] DefaultDecl ::= '#REQUIRED' \| '#IMPLIED' \| (('#FIXED' S)? AttValue)
4648	*
4649	* [ VC: Required Attribute ]
4650	* if the default declaration is the keyword #REQUIRED, then the
4651	* attribute must be specified for all elements of the type in the
4652	* attribute-list declaration.
4653	*
4654	* [ VC: Attribute Default Legal ]
4655	* The declared default value must meet the lexical constraints of
4656	* the declared attribute type c.f. xmlValidateAttributeDecl()
4657	*
4658	* [ VC: Fixed Attribute Default ]
4659	* if an attribute has a default value declared with the #FIXED
4660	* keyword, instances of that attribute must match the default value.
4661	*
4662	* [ WFC: No < in Attribute Values ]
4663	* handled in xmlParseAttValue()
4664	*
4665	* returns: XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED
4666	* or XML_ATTRIBUTE_FIXED.
4667	*/
4668
4669	int
4670	xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) {
4671	int val;
4672	xmlChar *ret;
4673
4674	*value = NULL;
4675	if (CMP9(CUR_PTR, '#', 'R', 'E', 'Q', 'U', 'I', 'R', 'E', 'D')) {
4676	SKIP(9);
4677	return(XML_ATTRIBUTE_REQUIRED);
4678	}
4679	if (CMP8(CUR_PTR, '#', 'I', 'M', 'P', 'L', 'I', 'E', 'D')) {
4680	SKIP(8);
4681	return(XML_ATTRIBUTE_IMPLIED);
4682	}
4683	val = XML_ATTRIBUTE_NONE;
4684	if (CMP6(CUR_PTR, '#', 'F', 'I', 'X', 'E', 'D')) {
4685	SKIP(6);
4686	val = XML_ATTRIBUTE_FIXED;
4687	if (!IS_BLANK_CH(CUR)) {
4688	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4689	"Space required after '#FIXED'\n");
4690	}
4691	SKIP_BLANKS;
4692	}
4693	ret = xmlParseAttValue(ctxt);
4694	ctxt->instate = XML_PARSER_DTD;
4695	if (ret == NULL) {
4696	xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo,
4697	"Attribute default value declaration error\n");
4698	} else
4699	*value = ret;
4700	return(val);
4701	}
4702
4703	/**
4704	* xmlParseNotationType:
4705	* @ctxt: an XML parser context
4706	*
4707	* parse an Notation attribute type.
4708	*
4709	* Note: the leading 'NOTATION' S part has already being parsed...
4710	*
4711	* [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '\|' S? Name)* S? ')'
4712	*
4713	* [ VC: Notation Attributes ]
4714	* Values of this type must match one of the notation names included
4715	* in the declaration; all notation names in the declaration must be declared.
4716	*
4717	* Returns: the notation attribute tree built while parsing
4718	*/
4719
4720	xmlEnumerationPtr
4721	xmlParseNotationType(xmlParserCtxtPtr ctxt) {
4722	const xmlChar *name;
4723	xmlEnumerationPtr ret = NULL, last = NULL, cur;
4724
4725	if (RAW != '(') {
4726	xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
4727	return(NULL);
4728	}
4729	SHRINK;
4730	do {
4731	NEXT;
4732	SKIP_BLANKS;
4733	name = xmlParseName(ctxt);
4734	if (name == NULL) {
4735	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
4736	"Name expected in NOTATION declaration\n");
4737	xmlFreeEnumeration(ret);
4738	return(NULL);
4739	}
4740	cur = xmlCreateEnumeration(name);
4741	if (cur == NULL) {
4742	xmlFreeEnumeration(ret);
4743	return(NULL);
4744	}
4745	if (last == NULL) ret = last = cur;
4746	else {
4747	last->next = cur;
4748	last = cur;
4749	}
4750	SKIP_BLANKS;
4751	} while (RAW == '\|');
4752	if (RAW != ')') {
4753	xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
4754	xmlFreeEnumeration(ret);
4755	return(NULL);
4756	}
4757	NEXT;
4758	return(ret);
4759	}
4760
4761	/**
4762	* xmlParseEnumerationType:
4763	* @ctxt: an XML parser context
4764	*
4765	* parse an Enumeration attribute type.
4766	*
4767	* [59] Enumeration ::= '(' S? Nmtoken (S? '\|' S? Nmtoken)* S? ')'
4768	*
4769	* [ VC: Enumeration ]
4770	* Values of this type must match one of the Nmtoken tokens in
4771	* the declaration
4772	*
4773	* Returns: the enumeration attribute tree built while parsing
4774	*/
4775
4776	xmlEnumerationPtr
4777	xmlParseEnumerationType(xmlParserCtxtPtr ctxt) {
4778	xmlChar *name;
4779	xmlEnumerationPtr ret = NULL, last = NULL, cur;
4780
4781	if (RAW != '(') {
4782	xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
4783	return(NULL);
4784	}
4785	SHRINK;
4786	do {
4787	NEXT;
4788	SKIP_BLANKS;
4789	name = xmlParseNmtoken(ctxt);
4790	if (name == NULL) {
4791	xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
4792	return(ret);
4793	}
4794	cur = xmlCreateEnumeration(name);
4795	xmlFree(name);
4796	if (cur == NULL) {
4797	xmlFreeEnumeration(ret);
4798	return(NULL);
4799	}
4800	if (last == NULL) ret = last = cur;
4801	else {
4802	last->next = cur;
4803	last = cur;
4804	}
4805	SKIP_BLANKS;
4806	} while (RAW == '\|');
4807	if (RAW != ')') {
4808	xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
4809	return(ret);
4810	}
4811	NEXT;
4812	return(ret);
4813	}
4814
4815	/**
4816	* xmlParseEnumeratedType:
4817	* @ctxt: an XML parser context
4818	* @tree: the enumeration tree built while parsing
4819	*
4820	* parse an Enumerated attribute type.
4821	*
4822	* [57] EnumeratedType ::= NotationType \| Enumeration
4823	*
4824	* [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '\|' S? Name)* S? ')'
4825	*
4826	*
4827	* Returns: XML_ATTRIBUTE_ENUMERATION or XML_ATTRIBUTE_NOTATION
4828	*/
4829
4830	int
4831	xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
4832	if (CMP8(CUR_PTR, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
4833	SKIP(8);
4834	if (!IS_BLANK_CH(CUR)) {
4835	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4836	"Space required after 'NOTATION'\n");
4837	return(0);
4838	}
4839	SKIP_BLANKS;
4840	*tree = xmlParseNotationType(ctxt);
4841	if (*tree == NULL) return(0);
4842	return(XML_ATTRIBUTE_NOTATION);
4843	}
4844	*tree = xmlParseEnumerationType(ctxt);
4845	if (*tree == NULL) return(0);
4846	return(XML_ATTRIBUTE_ENUMERATION);
4847	}
4848
4849	/**
4850	* xmlParseAttributeType:
4851	* @ctxt: an XML parser context
4852	* @tree: the enumeration tree built while parsing
4853	*
4854	* parse the Attribute list def for an element
4855	*
4856	* [54] AttType ::= StringType \| TokenizedType \| EnumeratedType
4857	*
4858	* [55] StringType ::= 'CDATA'
4859	*
4860	* [56] TokenizedType ::= 'ID' \| 'IDREF' \| 'IDREFS' \| 'ENTITY' \|
4861	* 'ENTITIES' \| 'NMTOKEN' \| 'NMTOKENS'
4862	*
4863	* Validity constraints for attribute values syntax are checked in
4864	* xmlValidateAttributeValue()
4865	*
4866	* [ VC: ID ]
4867	* Values of type ID must match the Name production. A name must not
4868	* appear more than once in an XML document as a value of this type;
4869	* i.e., ID values must uniquely identify the elements which bear them.
4870	*
4871	* [ VC: One ID per Element Type ]
4872	* No element type may have more than one ID attribute specified.
4873	*
4874	* [ VC: ID Attribute Default ]
4875	* An ID attribute must have a declared default of #IMPLIED or #REQUIRED.
4876	*
4877	* [ VC: IDREF ]
4878	* Values of type IDREF must match the Name production, and values
4879	* of type IDREFS must match Names; each IDREF Name must match the value
4880	* of an ID attribute on some element in the XML document; i.e. IDREF
4881	* values must match the value of some ID attribute.
4882	*
4883	* [ VC: Entity Name ]
4884	* Values of type ENTITY must match the Name production, values
4885	* of type ENTITIES must match Names; each Entity Name must match the
4886	* name of an unparsed entity declared in the DTD.
4887	*
4888	* [ VC: Name Token ]
4889	* Values of type NMTOKEN must match the Nmtoken production; values
4890	* of type NMTOKENS must match Nmtokens.
4891	*
4892	* Returns the attribute type
4893	*/
4894	int
4895	xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
4896	SHRINK;
4897	if (CMP5(CUR_PTR, 'C', 'D', 'A', 'T', 'A')) {
4898	SKIP(5);
4899	return(XML_ATTRIBUTE_CDATA);
4900	} else if (CMP6(CUR_PTR, 'I', 'D', 'R', 'E', 'F', 'S')) {
4901	SKIP(6);
4902	return(XML_ATTRIBUTE_IDREFS);
4903	} else if (CMP5(CUR_PTR, 'I', 'D', 'R', 'E', 'F')) {
4904	SKIP(5);
4905	return(XML_ATTRIBUTE_IDREF);
4906	} else if ((RAW == 'I') && (NXT(1) == 'D')) {
4907	SKIP(2);
4908	return(XML_ATTRIBUTE_ID);
4909	} else if (CMP6(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'Y')) {
4910	SKIP(6);
4911	return(XML_ATTRIBUTE_ENTITY);
4912	} else if (CMP8(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S')) {
4913	SKIP(8);
4914	return(XML_ATTRIBUTE_ENTITIES);
4915	} else if (CMP8(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S')) {
4916	SKIP(8);
4917	return(XML_ATTRIBUTE_NMTOKENS);
4918	} else if (CMP7(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N')) {
4919	SKIP(7);
4920	return(XML_ATTRIBUTE_NMTOKEN);
4921	}
4922	return(xmlParseEnumeratedType(ctxt, tree));
4923	}
4924
4925	/**
4926	* xmlParseAttributeListDecl:
4927	* @ctxt: an XML parser context
4928	*
4929	* : parse the Attribute list def for an element
4930	*
4931	* [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'
4932	*
4933	* [53] AttDef ::= S Name S AttType S DefaultDecl
4934	*
4935	*/
4936	void
4937	xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) {
4938	const xmlChar *elemName;
4939	const xmlChar *attrName;
4940	xmlEnumerationPtr tree;
4941
4942	if (CMP9(CUR_PTR, '<', '!', 'A', 'T', 'T', 'L', 'I', 'S', 'T')) {
4943	xmlParserInputPtr input = ctxt->input;
4944
4945	SKIP(9);
4946	if (!IS_BLANK_CH(CUR)) {
4947	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4948	"Space required after '<!ATTLIST'\n");
4949	}
4950	SKIP_BLANKS;
4951	elemName = xmlParseName(ctxt);
4952	if (elemName == NULL) {
4953	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
4954	"ATTLIST: no name for Element\n");
4955	return;
4956	}
4957	SKIP_BLANKS;
4958	GROW;
4959	while (RAW != '>') {
4960	const xmlChar *check = CUR_PTR;
4961	int type;
4962	int def;
4963	xmlChar *defaultValue = NULL;
4964
4965	GROW;
4966	tree = NULL;
4967	attrName = xmlParseName(ctxt);
4968	if (attrName == NULL) {
4969	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
4970	"ATTLIST: no name for Attribute\n");
4971	break;
4972	}
4973	GROW;
4974	if (!IS_BLANK_CH(CUR)) {
4975	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4976	"Space required after the attribute name\n");
4977	break;
4978	}
4979	SKIP_BLANKS;
4980
4981	type = xmlParseAttributeType(ctxt, &tree);
4982	if (type <= 0) {
4983	break;
4984	}
4985
4986	GROW;
4987	if (!IS_BLANK_CH(CUR)) {
4988	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4989	"Space required after the attribute type\n");
4990	if (tree != NULL)
4991	xmlFreeEnumeration(tree);
4992	break;
4993	}
4994	SKIP_BLANKS;
4995
4996	def = xmlParseDefaultDecl(ctxt, &defaultValue);
4997	if (def <= 0) {
4998	if (defaultValue != NULL)
4999	xmlFree(defaultValue);
5000	if (tree != NULL)
5001	xmlFreeEnumeration(tree);
5002	break;
5003	}
5004
5005	GROW;
5006	if (RAW != '>') {
5007	if (!IS_BLANK_CH(CUR)) {
5008	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5009	"Space required after the attribute default value\n");
5010	if (defaultValue != NULL)
5011	xmlFree(defaultValue);
5012	if (tree != NULL)
5013	xmlFreeEnumeration(tree);
5014	break;
5015	}
5016	SKIP_BLANKS;
5017	}
5018	if (check == CUR_PTR) {
5019	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
5020	"in xmlParseAttributeListDecl\n");
5021	if (defaultValue != NULL)
5022	xmlFree(defaultValue);
5023	if (tree != NULL)
5024	xmlFreeEnumeration(tree);
5025	break;
5026	}
5027	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5028	(ctxt->sax->attributeDecl != NULL))
5029	ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
5030	type, def, defaultValue, tree);
5031	else if (tree != NULL)
5032	xmlFreeEnumeration(tree);
5033
5034	if ((ctxt->sax2) && (defaultValue != NULL) &&
5035	(def != XML_ATTRIBUTE_IMPLIED) &&
5036	(def != XML_ATTRIBUTE_REQUIRED)) {
5037	xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue);
5038	}
5039	if ((ctxt->sax2) && (type != XML_ATTRIBUTE_CDATA)) {
5040	xmlAddSpecialAttr(ctxt, elemName, attrName, type);
5041	}
5042	if (defaultValue != NULL)
5043	xmlFree(defaultValue);
5044	GROW;
5045	}
5046	if (RAW == '>') {
5047	if (input != ctxt->input) {
5048	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5049	"Attribute list declaration doesn't start and stop in the same entity\n");
5050	}
5051	NEXT;
5052	}
5053	}
5054	}
5055
5056	/**
5057	* xmlParseElementMixedContentDecl:
5058	* @ctxt: an XML parser context
5059	* @inputchk: the input used for the current entity, needed for boundary checks
5060	*
5061	* parse the declaration for a Mixed Element content
5062	* The leading '(' and spaces have been skipped in xmlParseElementContentDecl
5063	*
5064	* [51] Mixed ::= '(' S? '#PCDATA' (S? '\|' S? Name)* S? ')*' \|
5065	* '(' S? '#PCDATA' S? ')'
5066	*
5067	* [ VC: Proper Group/PE Nesting ] applies to [51] too (see [49])
5068	*
5069	* [ VC: No Duplicate Types ]
5070	* The same name must not appear more than once in a single
5071	* mixed-content declaration.
5072	*
5073	* returns: the list of the xmlElementContentPtr describing the element choices
5074	*/
5075	xmlElementContentPtr
5076	xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
5077	xmlElementContentPtr ret = NULL, cur = NULL, n;
5078	const xmlChar *elem = NULL;
5079
5080	GROW;
5081	if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
5082	SKIP(7);
5083	SKIP_BLANKS;
5084	SHRINK;
5085	if (RAW == ')') {
5086	if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5087	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5088	"Element content declaration doesn't start and stop in the same entity\n",
5089	NULL);
5090	}
5091	NEXT;
5092	ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
5093	if (RAW == '*') {
5094	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5095	NEXT;
5096	}
5097	return(ret);
5098	}
5099	if ((RAW == '(') \|\| (RAW == '\|')) {
5100	ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
5101	if (ret == NULL) return(NULL);
5102	}
5103	while (RAW == '\|') {
5104	NEXT;
5105	if (elem == NULL) {
5106	ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5107	if (ret == NULL) return(NULL);
5108	ret->c1 = cur;
5109	if (cur != NULL)
5110	cur->parent = ret;
5111	cur = ret;
5112	} else {
5113	n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5114	if (n == NULL) return(NULL);
5115	n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
5116	if (n->c1 != NULL)
5117	n->c1->parent = n;
5118	cur->c2 = n;
5119	if (n != NULL)
5120	n->parent = cur;
5121	cur = n;
5122	}
5123	SKIP_BLANKS;
5124	elem = xmlParseName(ctxt);
5125	if (elem == NULL) {
5126	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5127	"xmlParseElementMixedContentDecl : Name expected\n");
5128	xmlFreeDocElementContent(ctxt->myDoc, cur);
5129	return(NULL);
5130	}
5131	SKIP_BLANKS;
5132	GROW;
5133	}
5134	if ((RAW == ')') && (NXT(1) == '*')) {
5135	if (elem != NULL) {
5136	cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem,
5137	XML_ELEMENT_CONTENT_ELEMENT);
5138	if (cur->c2 != NULL)
5139	cur->c2->parent = cur;
5140	}
5141	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5142	if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5143	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5144	"Element content declaration doesn't start and stop in the same entity\n",
5145	NULL);
5146	}
5147	SKIP(2);
5148	} else {
5149	xmlFreeDocElementContent(ctxt->myDoc, ret);
5150	xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
5151	return(NULL);
5152	}
5153
5154	} else {
5155	xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
5156	}
5157	return(ret);
5158	}
5159
5160	/**
5161	* xmlParseElementChildrenContentDecl:
5162	* @ctxt: an XML parser context
5163	* @inputchk: the input used for the current entity, needed for boundary checks
5164	*
5165	* parse the declaration for a Mixed Element content
5166	* The leading '(' and spaces have been skipped in xmlParseElementContentDecl
5167	*
5168	*
5169	* [47] children ::= (choice \| seq) ('?' \| '*' \| '+')?
5170	*
5171	* [48] cp ::= (Name \| choice \| seq) ('?' \| '*' \| '+')?
5172	*
5173	* [49] choice ::= '(' S? cp ( S? '\|' S? cp )* S? ')'
5174	*
5175	* [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
5176	*
5177	* [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
5178	* TODO Parameter-entity replacement text must be properly nested
5179	* with parenthesized groups. That is to say, if either of the
5180	* opening or closing parentheses in a choice, seq, or Mixed
5181	* construct is contained in the replacement text for a parameter
5182	* entity, both must be contained in the same replacement text. For
5183	* interoperability, if a parameter-entity reference appears in a
5184	* choice, seq, or Mixed construct, its replacement text should not
5185	* be empty, and neither the first nor last non-blank character of
5186	* the replacement text should be a connector (\| or ,).
5187	*
5188	* Returns the tree of xmlElementContentPtr describing the element
5189	* hierarchy.
5190	*/
5191	xmlElementContentPtr
5192	xmlParseElementChildrenContentDecl (xmlParserCtxtPtr ctxt, int inputchk) {
5193	xmlElementContentPtr ret = NULL, cur = NULL, last = NULL, op = NULL;
5194	const xmlChar *elem;
5195	xmlChar type = 0;
5196
5197	if (ctxt->depth > 128) {
5198	xmlFatalErrMsgInt(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED,
5199	"xmlParseElementChildrenContentDecl : depth %d too deep\n",
5200	ctxt->depth);
5201	return(NULL);
5202	}
5203
5204	SKIP_BLANKS;
5205	GROW;
5206	if (RAW == '(') {
5207	int inputid = ctxt->input->id;
5208
5209	/* Recurse on first child */
5210	NEXT;
5211	SKIP_BLANKS;
5212	ctxt->depth++;
5213	cur = ret = xmlParseElementChildrenContentDecl(ctxt, inputid);
5214	ctxt->depth--;
5215	SKIP_BLANKS;
5216	GROW;
5217	} else {
5218	elem = xmlParseName(ctxt);
5219	if (elem == NULL) {
5220	xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
5221	return(NULL);
5222	}
5223	cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
5224	if (cur == NULL) {
5225	xmlErrMemory(ctxt, NULL);
5226	return(NULL);
5227	}
5228	GROW;
5229	if (RAW == '?') {
5230	cur->ocur = XML_ELEMENT_CONTENT_OPT;
5231	NEXT;
5232	} else if (RAW == '*') {
5233	cur->ocur = XML_ELEMENT_CONTENT_MULT;
5234	NEXT;
5235	} else if (RAW == '+') {
5236	cur->ocur = XML_ELEMENT_CONTENT_PLUS;
5237	NEXT;
5238	} else {
5239	cur->ocur = XML_ELEMENT_CONTENT_ONCE;
5240	}
5241	GROW;
5242	}
5243	SKIP_BLANKS;
5244	SHRINK;
5245	while (RAW != ')') {
5246	/*
5247	* Each loop we parse one separator and one element.
5248	*/
5249	if (RAW == ',') {
5250	if (type == 0) type = CUR;
5251
5252	/*
5253	* Detect "Name \| Name , Name" error
5254	*/
5255	else if (type != CUR) {
5256	xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
5257	"xmlParseElementChildrenContentDecl : '%c' expected\n",
5258	type);
5259	if ((last != NULL) && (last != ret))
5260	xmlFreeDocElementContent(ctxt->myDoc, last);
5261	if (ret != NULL)
5262	xmlFreeDocElementContent(ctxt->myDoc, ret);
5263	return(NULL);
5264	}
5265	NEXT;
5266
5267	op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ);
5268	if (op == NULL) {
5269	if ((last != NULL) && (last != ret))
5270	xmlFreeDocElementContent(ctxt->myDoc, last);
5271	xmlFreeDocElementContent(ctxt->myDoc, ret);
5272	return(NULL);
5273	}
5274	if (last == NULL) {
5275	op->c1 = ret;
5276	if (ret != NULL)
5277	ret->parent = op;
5278	ret = cur = op;
5279	} else {
5280	cur->c2 = op;
5281	if (op != NULL)
5282	op->parent = cur;
5283	op->c1 = last;
5284	if (last != NULL)
5285	last->parent = op;
5286	cur =op;
5287	last = NULL;
5288	}
5289	} else if (RAW == '\|') {
5290	if (type == 0) type = CUR;
5291
5292	/*
5293	* Detect "Name , Name \| Name" error
5294	*/
5295	else if (type != CUR) {
5296	xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
5297	"xmlParseElementChildrenContentDecl : '%c' expected\n",
5298	type);
5299	if ((last != NULL) && (last != ret))
5300	xmlFreeDocElementContent(ctxt->myDoc, last);
5301	if (ret != NULL)
5302	xmlFreeDocElementContent(ctxt->myDoc, ret);
5303	return(NULL);
5304	}
5305	NEXT;
5306
5307	op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5308	if (op == NULL) {
5309	if ((last != NULL) && (last != ret))
5310	xmlFreeDocElementContent(ctxt->myDoc, last);
5311	if (ret != NULL)
5312	xmlFreeDocElementContent(ctxt->myDoc, ret);
5313	return(NULL);
5314	}
5315	if (last == NULL) {
5316	op->c1 = ret;
5317	if (ret != NULL)
5318	ret->parent = op;
5319	ret = cur = op;
5320	} else {
5321	cur->c2 = op;
5322	if (op != NULL)
5323	op->parent = cur;
5324	op->c1 = last;
5325	if (last != NULL)
5326	last->parent = op;
5327	cur =op;
5328	last = NULL;
5329	}
5330	} else {
5331	xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL);
5332	if (ret != NULL)
5333	xmlFreeDocElementContent(ctxt->myDoc, ret);
5334	return(NULL);
5335	}
5336	GROW;
5337	SKIP_BLANKS;
5338	GROW;
5339	if (RAW == '(') {
5340	int inputid = ctxt->input->id;
5341	/* Recurse on second child */
5342	NEXT;
5343	SKIP_BLANKS;
5344	ctxt->depth++;
5345	last = xmlParseElementChildrenContentDecl(ctxt, inputid);
5346	ctxt->depth--;
5347	SKIP_BLANKS;
5348	} else {
5349	elem = xmlParseName(ctxt);
5350	if (elem == NULL) {
5351	xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
5352	if (ret != NULL)
5353	xmlFreeDocElementContent(ctxt->myDoc, ret);
5354	return(NULL);
5355	}
5356	last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
5357	if (RAW == '?') {
5358	last->ocur = XML_ELEMENT_CONTENT_OPT;
5359	NEXT;
5360	} else if (RAW == '*') {
5361	last->ocur = XML_ELEMENT_CONTENT_MULT;
5362	NEXT;
5363	} else if (RAW == '+') {
5364	last->ocur = XML_ELEMENT_CONTENT_PLUS;
5365	NEXT;
5366	} else {
5367	last->ocur = XML_ELEMENT_CONTENT_ONCE;
5368	}
5369	}
5370	SKIP_BLANKS;
5371	GROW;
5372	}
5373	if ((cur != NULL) && (last != NULL)) {
5374	cur->c2 = last;
5375	if (last != NULL)
5376	last->parent = cur;
5377	}
5378	if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5379	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5380	"Element content declaration doesn't start and stop in the same entity\n",
5381	NULL);
5382	}
5383	NEXT;
5384	if (RAW == '?') {
5385	if (ret != NULL) {
5386	if ((ret->ocur == XML_ELEMENT_CONTENT_PLUS) \|\|
5387	(ret->ocur == XML_ELEMENT_CONTENT_MULT))
5388	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5389	else
5390	ret->ocur = XML_ELEMENT_CONTENT_OPT;
5391	}
5392	NEXT;
5393	} else if (RAW == '*') {
5394	if (ret != NULL) {
5395	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5396	cur = ret;
5397	/*
5398	* Some normalization:
5399	* (a \| b* \| c?)* == (a \| b \| c)*
5400	*/
5401	while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
5402	if ((cur->c1 != NULL) &&
5403	((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
5404	(cur->c1->ocur == XML_ELEMENT_CONTENT_MULT)))
5405	cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
5406	if ((cur->c2 != NULL) &&
5407	((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
5408	(cur->c2->ocur == XML_ELEMENT_CONTENT_MULT)))
5409	cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
5410	cur = cur->c2;
5411	}
5412	}
5413	NEXT;
5414	} else if (RAW == '+') {
5415	if (ret != NULL) {
5416	int found = 0;
5417
5418	if ((ret->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
5419	(ret->ocur == XML_ELEMENT_CONTENT_MULT))
5420	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5421	else
5422	ret->ocur = XML_ELEMENT_CONTENT_PLUS;
5423	/*
5424	* Some normalization:
5425	* (a \| b)+ == (a \| b)
5426	* (a \| b?)+ == (a \| b)*
5427	*/
5428	while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
5429	if ((cur->c1 != NULL) &&
5430	((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
5431	(cur->c1->ocur == XML_ELEMENT_CONTENT_MULT))) {
5432	cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
5433	found = 1;
5434	}
5435	if ((cur->c2 != NULL) &&
5436	((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
5437	(cur->c2->ocur == XML_ELEMENT_CONTENT_MULT))) {
5438	cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
5439	found = 1;
5440	}
5441	cur = cur->c2;
5442	}
5443	if (found)
5444	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5445	}
5446	NEXT;
5447	}
5448	return(ret);
5449	}
5450
5451	/**
5452	* xmlParseElementContentDecl:
5453	* @ctxt: an XML parser context
5454	* @name: the name of the element being defined.
5455	* @result: the Element Content pointer will be stored here if any
5456	*
5457	* parse the declaration for an Element content either Mixed or Children,
5458	* the cases EMPTY and ANY are handled directly in xmlParseElementDecl
5459	*
5460	* [46] contentspec ::= 'EMPTY' \| 'ANY' \| Mixed \| children
5461	*
5462	* returns: the type of element content XML_ELEMENT_TYPE_xxx
5463	*/
5464
5465	int
5466	xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name,
5467	xmlElementContentPtr *result) {
5468
5469	xmlElementContentPtr tree = NULL;
5470	int inputid = ctxt->input->id;
5471	int res;
5472
5473	*result = NULL;
5474
5475	if (RAW != '(') {
5476	xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
5477	"xmlParseElementContentDecl : %s '(' expected\n", name);
5478	return(-1);
5479	}
5480	NEXT;
5481	GROW;
5482	SKIP_BLANKS;
5483	if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
5484	tree = xmlParseElementMixedContentDecl(ctxt, inputid);
5485	res = XML_ELEMENT_TYPE_MIXED;
5486	} else {
5487	tree = xmlParseElementChildrenContentDecl(ctxt, inputid);
5488	res = XML_ELEMENT_TYPE_ELEMENT;
5489	}
5490	SKIP_BLANKS;
5491	*result = tree;
5492	return(res);
5493	}
5494
5495	/**
5496	* xmlParseElementDecl:
5497	* @ctxt: an XML parser context
5498	*
5499	* parse an Element declaration.
5500	*
5501	* [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>'
5502	*
5503	* [ VC: Unique Element Type Declaration ]
5504	* No element type may be declared more than once
5505	*
5506	* Returns the type of the element, or -1 in case of error
5507	*/
5508	int
5509	xmlParseElementDecl(xmlParserCtxtPtr ctxt) {
5510	const xmlChar *name;
5511	int ret = -1;
5512	xmlElementContentPtr content = NULL;
5513
5514	/* GROW; done in the caller */
5515	if (CMP9(CUR_PTR, '<', '!', 'E', 'L', 'E', 'M', 'E', 'N', 'T')) {
5516	xmlParserInputPtr input = ctxt->input;
5517
5518	SKIP(9);
5519	if (!IS_BLANK_CH(CUR)) {
5520	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5521	"Space required after 'ELEMENT'\n");
5522	}
5523	SKIP_BLANKS;
5524	name = xmlParseName(ctxt);
5525	if (name == NULL) {
5526	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5527	"xmlParseElementDecl: no name for Element\n");
5528	return(-1);
5529	}
5530	while ((RAW == 0) && (ctxt->inputNr > 1))
5531	xmlPopInput(ctxt);
5532	if (!IS_BLANK_CH(CUR)) {
5533	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5534	"Space required after the element name\n");
5535	}
5536	SKIP_BLANKS;
5537	if (CMP5(CUR_PTR, 'E', 'M', 'P', 'T', 'Y')) {
5538	SKIP(5);
5539	/*
5540	* Element must always be empty.
5541	*/
5542	ret = XML_ELEMENT_TYPE_EMPTY;
5543	} else if ((RAW == 'A') && (NXT(1) == 'N') &&
5544	(NXT(2) == 'Y')) {
5545	SKIP(3);
5546	/*
5547	* Element is a generic container.
5548	*/
5549	ret = XML_ELEMENT_TYPE_ANY;
5550	} else if (RAW == '(') {
5551	ret = xmlParseElementContentDecl(ctxt, name, &content);
5552	} else {
5553	/*
5554	* [ WFC: PEs in Internal Subset ] error handling.
5555	*/
5556	if ((RAW == '%') && (ctxt->external == 0) &&
5557	(ctxt->inputNr == 1)) {
5558	xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET,
5559	"PEReference: forbidden within markup decl in internal subset\n");
5560	} else {
5561	xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
5562	"xmlParseElementDecl: 'EMPTY', 'ANY' or '(' expected\n");
5563	}
5564	return(-1);
5565	}
5566
5567	SKIP_BLANKS;
5568	/*
5569	* Pop-up of finished entities.
5570	*/
5571	while ((RAW == 0) && (ctxt->inputNr > 1))
5572	xmlPopInput(ctxt);
5573	SKIP_BLANKS;
5574
5575	if (RAW != '>') {
5576	xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
5577	if (content != NULL) {
5578	xmlFreeDocElementContent(ctxt->myDoc, content);
5579	}
5580	} else {
5581	if (input != ctxt->input) {
5582	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5583	"Element declaration doesn't start and stop in the same entity\n");
5584	}
5585
5586	NEXT;
5587	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5588	(ctxt->sax->elementDecl != NULL)) {
5589	if (content != NULL)
5590	content->parent = NULL;
5591	ctxt->sax->elementDecl(ctxt->userData, name, ret,
5592	content);
5593	if ((content != NULL) && (content->parent == NULL)) {
5594	/*
5595	* this is a trick: if xmlAddElementDecl is called,
5596	* instead of copying the full tree it is plugged directly
5597	* if called from the parser. Avoid duplicating the
5598	* interfaces or change the API/ABI
5599	*/
5600	xmlFreeDocElementContent(ctxt->myDoc, content);
5601	}
5602	} else if (content != NULL) {
5603	xmlFreeDocElementContent(ctxt->myDoc, content);
5604	}
5605	}
5606	}
5607	return(ret);
5608	}
5609
5610	/**
5611	* xmlParseConditionalSections
5612	* @ctxt: an XML parser context
5613	*
5614	* [61] conditionalSect ::= includeSect \| ignoreSect
5615	* [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>'
5616	* [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>'
5617	* [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)*
5618	* [65] Ignore ::= Char* - (Char* ('<![' \| ']]>') Char*)
5619	*/
5620
5621	static void
5622	xmlParseConditionalSections(xmlParserCtxtPtr ctxt) {
5623	SKIP(3);
5624	SKIP_BLANKS;
5625	if (CMP7(CUR_PTR, 'I', 'N', 'C', 'L', 'U', 'D', 'E')) {
5626	SKIP(7);
5627	SKIP_BLANKS;
5628	if (RAW != '[') {
5629	xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
5630	} else {
5631	NEXT;
5632	}
5633	if (xmlParserDebugEntities) {
5634	if ((ctxt->input != NULL) && (ctxt->input->filename))
5635	xmlGenericError(xmlGenericErrorContext,
5636	"%s(%d): ", ctxt->input->filename,
5637	ctxt->input->line);
5638	xmlGenericError(xmlGenericErrorContext,
5639	"Entering INCLUDE Conditional Section\n");
5640	}
5641
5642	while ((RAW != 0) && ((RAW != ']') \|\| (NXT(1) != ']') \|\|
5643	(NXT(2) != '>'))) {
5644	const xmlChar *check = CUR_PTR;
5645	unsigned int cons = ctxt->input->consumed;
5646
5647	if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
5648	xmlParseConditionalSections(ctxt);
5649	} else if (IS_BLANK_CH(CUR)) {
5650	NEXT;
5651	} else if (RAW == '%') {
5652	xmlParsePEReference(ctxt);
5653	} else
5654	xmlParseMarkupDecl(ctxt);
5655
5656	/*
5657	* Pop-up of finished entities.
5658	*/
5659	while ((RAW == 0) && (ctxt->inputNr > 1))
5660	xmlPopInput(ctxt);
5661
5662	if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
5663	xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
5664	break;
5665	}
5666	}
5667	if (xmlParserDebugEntities) {
5668	if ((ctxt->input != NULL) && (ctxt->input->filename))
5669	xmlGenericError(xmlGenericErrorContext,
5670	"%s(%d): ", ctxt->input->filename,
5671	ctxt->input->line);
5672	xmlGenericError(xmlGenericErrorContext,
5673	"Leaving INCLUDE Conditional Section\n");
5674	}
5675
5676	} else if (CMP6(CUR_PTR, 'I', 'G', 'N', 'O', 'R', 'E')) {
5677	int state;
5678	xmlParserInputState instate;
5679	int depth = 0;
5680
5681	SKIP(6);
5682	SKIP_BLANKS;
5683	if (RAW != '[') {
5684	xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
5685	} else {
5686	NEXT;
5687	}
5688	if (xmlParserDebugEntities) {
5689	if ((ctxt->input != NULL) && (ctxt->input->filename))
5690	xmlGenericError(xmlGenericErrorContext,
5691	"%s(%d): ", ctxt->input->filename,
5692	ctxt->input->line);
5693	xmlGenericError(xmlGenericErrorContext,
5694	"Entering IGNORE Conditional Section\n");
5695	}
5696
5697	/*
5698	* Parse up to the end of the conditional section
5699	* But disable SAX event generating DTD building in the meantime
5700	*/
5701	state = ctxt->disableSAX;
5702	instate = ctxt->instate;
5703	if (ctxt->recovery == 0) ctxt->disableSAX = 1;
5704	ctxt->instate = XML_PARSER_IGNORE;
5705
5706	while ((depth >= 0) && (RAW != 0)) {
5707	if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
5708	depth++;
5709	SKIP(3);
5710	continue;
5711	}
5712	if ((RAW == ']') && (NXT(1) == ']') && (NXT(2) == '>')) {
5713	if (--depth >= 0) SKIP(3);
5714	continue;
5715	}
5716	NEXT;
5717	continue;
5718	}
5719
5720	ctxt->disableSAX = state;
5721	ctxt->instate = instate;
5722
5723	if (xmlParserDebugEntities) {
5724	if ((ctxt->input != NULL) && (ctxt->input->filename))
5725	xmlGenericError(xmlGenericErrorContext,
5726	"%s(%d): ", ctxt->input->filename,
5727	ctxt->input->line);
5728	xmlGenericError(xmlGenericErrorContext,
5729	"Leaving IGNORE Conditional Section\n");
5730	}
5731
5732	} else {
5733	xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
5734	}
5735
5736	if (RAW == 0)
5737	SHRINK;
5738
5739	if (RAW == 0) {
5740	xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
5741	} else {
5742	SKIP(3);
5743	}
5744	}
5745
5746	/**
5747	* xmlParseMarkupDecl:
5748	* @ctxt: an XML parser context
5749	*
5750	* parse Markup declarations
5751	*
5752	* [29] markupdecl ::= elementdecl \| AttlistDecl \| EntityDecl \|
5753	* NotationDecl \| PI \| Comment
5754	*
5755	* [ VC: Proper Declaration/PE Nesting ]
5756	* Parameter-entity replacement text must be properly nested with
5757	* markup declarations. That is to say, if either the first character
5758	* or the last character of a markup declaration (markupdecl above) is
5759	* contained in the replacement text for a parameter-entity reference,
5760	* both must be contained in the same replacement text.
5761	*
5762	* [ WFC: PEs in Internal Subset ]
5763	* In the internal DTD subset, parameter-entity references can occur
5764	* only where markup declarations can occur, not within markup declarations.
5765	* (This does not apply to references that occur in external parameter
5766	* entities or to the external subset.)
5767	*/
5768	void
5769	xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) {
5770	GROW;
5771	if (CUR == '<') {
5772	if (NXT(1) == '!') {
5773	switch (NXT(2)) {
5774	case 'E':
5775	if (NXT(3) == 'L')
5776	xmlParseElementDecl(ctxt);
5777	else if (NXT(3) == 'N')
5778	xmlParseEntityDecl(ctxt);
5779	break;
5780	case 'A':
5781	xmlParseAttributeListDecl(ctxt);
5782	break;
5783	case 'N':
5784	xmlParseNotationDecl(ctxt);
5785	break;
5786	case '-':
5787	xmlParseComment(ctxt);
5788	break;
5789	default:
5790	/* there is an error but it will be detected later */
5791	break;
5792	}
5793	} else if (NXT(1) == '?') {
5794	xmlParsePI(ctxt);
5795	}
5796	}
5797	/*
5798	* This is only for internal subset. On external entities,
5799	* the replacement is done before parsing stage
5800	*/
5801	if ((ctxt->external == 0) && (ctxt->inputNr == 1))
5802	xmlParsePEReference(ctxt);
5803
5804	/*
5805	* Conditional sections are allowed from entities included
5806	* by PE References in the internal subset.
5807	*/
5808	if ((ctxt->external == 0) && (ctxt->inputNr > 1)) {
5809	if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
5810	xmlParseConditionalSections(ctxt);
5811	}
5812	}
5813
5814	ctxt->instate = XML_PARSER_DTD;
5815	}
5816
5817	/**
5818	* xmlParseTextDecl:
5819	* @ctxt: an XML parser context
5820	*
5821	* parse an XML declaration header for external entities
5822	*
5823	* [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
5824	*
5825	* Question: Seems that EncodingDecl is mandatory ? Is that a typo ?
5826	*/
5827
5828	void
5829	xmlParseTextDecl(xmlParserCtxtPtr ctxt) {
5830	xmlChar *version;
5831	const xmlChar *encoding;
5832
5833	/*
5834	* We know that '<?xml' is here.
5835	*/
5836	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
5837	SKIP(5);
5838	} else {
5839	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL);
5840	return;
5841	}
5842
5843	if (!IS_BLANK_CH(CUR)) {
5844	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5845	"Space needed after '<?xml'\n");
5846	}
5847	SKIP_BLANKS;
5848
5849	/*
5850	* We may have the VersionInfo here.
5851	*/
5852	version = xmlParseVersionInfo(ctxt);
5853	if (version == NULL)
5854	version = xmlCharStrdup(XML_DEFAULT_VERSION);
5855	else {
5856	if (!IS_BLANK_CH(CUR)) {
5857	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5858	"Space needed here\n");
5859	}
5860	}
5861	ctxt->input->version = version;
5862
5863	/*
5864	* We must have the encoding declaration
5865	*/
5866	encoding = xmlParseEncodingDecl(ctxt);
5867	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
5868	/*
5869	* The XML REC instructs us to stop parsing right here
5870	*/
5871	return;
5872	}
5873	if ((encoding == NULL) && (ctxt->errNo == XML_ERR_OK)) {
5874	xmlFatalErrMsg(ctxt, XML_ERR_MISSING_ENCODING,
5875	"Missing encoding in text declaration\n");
5876	}
5877
5878	SKIP_BLANKS;
5879	if ((RAW == '?') && (NXT(1) == '>')) {
5880	SKIP(2);
5881	} else if (RAW == '>') {
5882	/* Deprecated old WD ... */
5883	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
5884	NEXT;
5885	} else {
5886	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
5887	MOVETO_ENDTAG(CUR_PTR);
5888	NEXT;
5889	}
5890	}
5891
5892	/**
5893	* xmlParseExternalSubset:
5894	* @ctxt: an XML parser context
5895	* @ExternalID: the external identifier
5896	* @SystemID: the system identifier (or URL)
5897	*
5898	* parse Markup declarations from an external subset
5899	*
5900	* [30] extSubset ::= textDecl? extSubsetDecl
5901	*
5902	* [31] extSubsetDecl ::= (markupdecl \| conditionalSect \| PEReference \| S) *
5903	*/
5904	void
5905	xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID,
5906	const xmlChar *SystemID) {
5907	xmlDetectSAX2(ctxt);
5908	GROW;
5909	if (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) {
5910	xmlParseTextDecl(ctxt);
5911	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
5912	/*
5913	* The XML REC instructs us to stop parsing right here
5914	*/
5915	ctxt->instate = XML_PARSER_EOF;
5916	return;
5917	}
5918	}
5919	if (ctxt->myDoc == NULL) {
5920	ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
5921	}
5922	if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
5923	xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
5924
5925	ctxt->instate = XML_PARSER_DTD;
5926	ctxt->external = 1;
5927	while (((RAW == '<') && (NXT(1) == '?')) \|\|
5928	((RAW == '<') && (NXT(1) == '!')) \|\|
5929	(RAW == '%') \|\| IS_BLANK_CH(CUR)) {
5930	const xmlChar *check = CUR_PTR;
5931	unsigned int cons = ctxt->input->consumed;
5932
5933	GROW;
5934	if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
5935	xmlParseConditionalSections(ctxt);
5936	} else if (IS_BLANK_CH(CUR)) {
5937	NEXT;
5938	} else if (RAW == '%') {
5939	xmlParsePEReference(ctxt);
5940	} else
5941	xmlParseMarkupDecl(ctxt);
5942
5943	/*
5944	* Pop-up of finished entities.
5945	*/
5946	while ((RAW == 0) && (ctxt->inputNr > 1))
5947	xmlPopInput(ctxt);
5948
5949	if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
5950	xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
5951	break;
5952	}
5953	}
5954
5955	if (RAW != 0) {
5956	xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
5957	}
5958
5959	}
5960
5961	/**
5962	* xmlParseReference:
5963	* @ctxt: an XML parser context
5964	*
5965	* parse and handle entity references in content, depending on the SAX
5966	* interface, this may end-up in a call to character() if this is a
5967	* CharRef, a predefined entity, if there is no reference() callback.
5968	* or if the parser was asked to switch to that mode.
5969	*
5970	* [67] Reference ::= EntityRef \| CharRef
5971	*/
5972	void
5973	xmlParseReference(xmlParserCtxtPtr ctxt) {
5974	xmlEntityPtr ent;
5975	xmlChar *val;
5976	if (RAW != '&') return;
5977
5978	if (NXT(1) == '#') {
5979	int i = 0;
5980	xmlChar out[10];
5981	int hex = NXT(2);
5982	int value = xmlParseCharRef(ctxt);
5983
5984	if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
5985	/*
5986	* So we are using non-UTF-8 buffers
5987	* Check that the char fit on 8bits, if not
5988	* generate a CharRef.
5989	*/
5990	if (value <= 0xFF) {
5991	out[0] = value;
5992	out[1] = 0;
5993	if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
5994	(!ctxt->disableSAX))
5995	ctxt->sax->characters(ctxt->userData, out, 1);
5996	} else {
5997	if ((hex == 'x') \|\| (hex == 'X'))
5998	snprintf((char *)out, sizeof(out), "#x%X", value);
5999	else
6000	snprintf((char *)out, sizeof(out), "#%d", value);
6001	if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
6002	(!ctxt->disableSAX))
6003	ctxt->sax->reference(ctxt->userData, out);
6004	}
6005	} else {
6006	/*
6007	* Just encode the value in UTF-8
6008	*/
6009	COPY_BUF(0 ,out, i, value);
6010	out[i] = 0;
6011	if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
6012	(!ctxt->disableSAX))
6013	ctxt->sax->characters(ctxt->userData, out, i);
6014	}
6015	} else {
6016	int was_checked;
6017
6018	ent = xmlParseEntityRef(ctxt);
6019	if (ent == NULL) return;
6020	if (!ctxt->wellFormed)
6021	return;
6022	ctxt->nbentities++;
6023	if (ctxt->nbentities >= 500000) {
6024	xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
6025	return;
6026	}
6027	was_checked = ent->checked;
6028	if ((ent->name != NULL) &&
6029	(ent->etype != XML_INTERNAL_PREDEFINED_ENTITY)) {
6030	xmlNodePtr list = NULL;
6031	xmlParserErrors ret = XML_ERR_OK;
6032
6033
6034	/*
6035	* The first reference to the entity trigger a parsing phase
6036	* where the ent->children is filled with the result from
6037	* the parsing.
6038	*/
6039	if (ent->checked == 0) {
6040	xmlChar *value;
6041
6042	value = ent->content;
6043
6044	/*
6045	* Check that this entity is well formed
6046	*/
6047	if ((value != NULL) && (value[0] != 0) &&
6048	(value[1] == 0) && (value[0] == '<') &&
6049	(xmlStrEqual(ent->name, BAD_CAST "lt"))) {
6050	/*
6051	* DONE: get definite answer on this !!!
6052	* Lots of entity decls are used to declare a single
6053	* char
6054	* <!ENTITY lt "<">
6055	* Which seems to be valid since
6056	* 2.4: The ampersand character (&) and the left angle
6057	* bracket (<) may appear in their literal form only
6058	* when used ... They are also legal within the literal
6059	* entity value of an internal entity declaration;i
6060	* see "4.3.2 Well-Formed Parsed Entities".
6061	* IMHO 2.4 and 4.3.2 are directly in contradiction.
6062	* Looking at the OASIS test suite and James Clark
6063	* tests, this is broken. However the XML REC uses
6064	* it. Is the XML REC not well-formed ????
6065	* This is a hack to avoid this problem
6066	*
6067	* ANSWER: since lt gt amp .. are already defined,
6068	* this is a redefinition and hence the fact that the
6069	* content is not well balanced is not a Wf error, this
6070	* is lousy but acceptable.
6071	*/
6072	list = xmlNewDocText(ctxt->myDoc, value);
6073	if (list != NULL) {
6074	if ((ent->etype == XML_INTERNAL_GENERAL_ENTITY) &&
6075	(ent->children == NULL)) {
6076	ent->children = list;
6077	ent->last = list;
6078	ent->owner = 1;
6079	list->parent = (xmlNodePtr) ent;
6080	} else {
6081	xmlFreeNodeList(list);
6082	}
6083	} else if (list != NULL) {
6084	xmlFreeNodeList(list);
6085	}
6086	} else {
6087	unsigned long oldnbent = ctxt->nbentities;
6088	/*
6089	* 4.3.2: An internal general parsed entity is well-formed
6090	* if its replacement text matches the production labeled
6091	* content.
6092	*/
6093
6094	void *user_data;
6095	/*
6096	* This is a bit hackish but this seems the best
6097	* way to make sure both SAX and DOM entity support
6098	* behaves okay.
6099	*/
6100	if (ctxt->userData == ctxt)
6101	user_data = NULL;
6102	else
6103	user_data = ctxt->userData;
6104
6105	if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
6106	ctxt->depth++;
6107	ret = xmlParseBalancedChunkMemoryInternal(ctxt,
6108	value, user_data, &list);
6109	ctxt->depth--;
6110	} else if (ent->etype ==
6111	XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
6112	ctxt->depth++;
6113	ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
6114	ctxt->sax, user_data, ctxt->depth,
6115	ent->URI, ent->ExternalID, &list);
6116	ctxt->depth--;
6117	} else {
6118	ret = XML_ERR_ENTITY_PE_INTERNAL;
6119	xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
6120	"invalid entity type found\n", NULL);
6121	}
6122	ent->checked = ctxt->nbentities - oldnbent;
6123	if (ret == XML_ERR_ENTITY_LOOP) {
6124	xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
6125	return;
6126	} else if ((ret == XML_ERR_OK) && (list != NULL)) {
6127	if (((ent->etype == XML_INTERNAL_GENERAL_ENTITY) \|\|
6128	(ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY))&&
6129	(ent->children == NULL)) {
6130	ent->children = list;
6131	if (ctxt->replaceEntities) {
6132	/*
6133	* Prune it directly in the generated document
6134	* except for single text nodes.
6135	*/
6136	if (((list->type == XML_TEXT_NODE) &&
6137	(list->next == NULL)) \|\|
6138	(ctxt->parseMode == XML_PARSE_READER)) {
6139	list->parent = (xmlNodePtr) ent;
6140	list = NULL;
6141	ent->owner = 1;
6142	} else {
6143	ent->owner = 0;
6144	while (list != NULL) {
6145	list->parent = (xmlNodePtr) ctxt->node;
6146	list->doc = ctxt->myDoc;
6147	if (list->next == NULL)
6148	ent->last = list;
6149	list = list->next;
6150	}
6151	list = ent->children;
6152	#ifdef LIBXML_LEGACY_ENABLED
6153	if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
6154	xmlAddEntityReference(ent, list, NULL);
6155	#endif /* LIBXML_LEGACY_ENABLED */
6156	}
6157	} else {
6158	ent->owner = 1;
6159	while (list != NULL) {
6160	list->parent = (xmlNodePtr) ent;
6161	if (list->next == NULL)
6162	ent->last = list;
6163	list = list->next;
6164	}
6165	}
6166	} else {
6167	xmlFreeNodeList(list);
6168	list = NULL;
6169	}
6170	} else if ((ret != XML_ERR_OK) &&
6171	(ret != XML_WAR_UNDECLARED_ENTITY)) {
6172	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6173	"Entity '%s' failed to parse\n", ent->name);
6174	} else if (list != NULL) {
6175	xmlFreeNodeList(list);
6176	list = NULL;
6177	}
6178	}
6179	if (ent->checked == 0)
6180	ent->checked = 1;
6181	}
6182	ctxt->nbentities += ent->checked;
6183
6184	if (ent->children == NULL) {
6185	/*
6186	* Probably running in SAX mode and the callbacks don't
6187	* build the entity content. So unless we already went
6188	* though parsing for first checking go though the entity
6189	* content to generate callbacks associated to the entity
6190	*/
6191	if (was_checked != 0) {
6192	void *user_data;
6193	/*
6194	* This is a bit hackish but this seems the best
6195	* way to make sure both SAX and DOM entity support
6196	* behaves okay.
6197	*/
6198	if (ctxt->userData == ctxt)
6199	user_data = NULL;
6200	else
6201	user_data = ctxt->userData;
6202
6203	if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
6204	ctxt->depth++;
6205	ret = xmlParseBalancedChunkMemoryInternal(ctxt,
6206	ent->content, user_data, NULL);
6207	ctxt->depth--;
6208	} else if (ent->etype ==
6209	XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
6210	ctxt->depth++;
6211	ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
6212	ctxt->sax, user_data, ctxt->depth,
6213	ent->URI, ent->ExternalID, NULL);
6214	ctxt->depth--;
6215	} else {
6216	ret = XML_ERR_ENTITY_PE_INTERNAL;
6217	xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
6218	"invalid entity type found\n", NULL);
6219	}
6220	if (ret == XML_ERR_ENTITY_LOOP) {
6221	xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
6222	return;
6223	}
6224	}
6225	if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
6226	(ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
6227	/*
6228	* Entity reference callback comes second, it's somewhat
6229	* superfluous but a compatibility to historical behaviour
6230	*/
6231	ctxt->sax->reference(ctxt->userData, ent->name);
6232	}
6233	return;
6234	}
6235	if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
6236	(ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
6237	/*
6238	* Create a node.
6239	*/
6240	ctxt->sax->reference(ctxt->userData, ent->name);
6241	return;
6242	}
6243	if ((ctxt->replaceEntities) \|\| (ent->children == NULL)) {
6244	/*
6245	* There is a problem on the handling of _private for entities
6246	* (bug 155816): Should we copy the content of the field from
6247	* the entity (possibly overwriting some value set by the user
6248	* when a copy is created), should we leave it alone, or should
6249	* we try to take care of different situations? The problem
6250	* is exacerbated by the usage of this field by the xmlReader.
6251	* To fix this bug, we look at _private on the created node
6252	* and, if it's NULL, we copy in whatever was in the entity.
6253	* If it's not NULL we leave it alone. This is somewhat of a
6254	* hack - maybe we should have further tests to determine
6255	* what to do.
6256	*/
6257	if ((ctxt->node != NULL) && (ent->children != NULL)) {
6258	/*
6259	* Seems we are generating the DOM content, do
6260	* a simple tree copy for all references except the first
6261	* In the first occurrence list contains the replacement.
6262	* progressive == 2 means we are operating on the Reader
6263	* and since nodes are discarded we must copy all the time.
6264	*/
6265	if (((list == NULL) && (ent->owner == 0)) \|\|
6266	(ctxt->parseMode == XML_PARSE_READER)) {
6267	xmlNodePtr nw = NULL, cur, firstChild = NULL;
6268
6269	/*
6270	* when operating on a reader, the entities definitions
6271	* are always owning the entities subtree.
6272	if (ctxt->parseMode == XML_PARSE_READER)
6273	ent->owner = 1;
6274	*/
6275
6276	cur = ent->children;
6277	while (cur != NULL) {
6278	nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
6279	if (nw != NULL) {
6280	if (nw->_private == NULL)
6281	nw->_private = cur->_private;
6282	if (firstChild == NULL){
6283	firstChild = nw;
6284	}
6285	nw = xmlAddChild(ctxt->node, nw);
6286	}
6287	if (cur == ent->last) {
6288	/*
6289	* needed to detect some strange empty
6290	* node cases in the reader tests
6291	*/
6292	if ((ctxt->parseMode == XML_PARSE_READER) &&
6293	(nw != NULL) &&
6294	(nw->type == XML_ELEMENT_NODE) &&
6295	(nw->children == NULL))
6296	nw->extra = 1;
6297
6298	break;
6299	}
6300	cur = cur->next;
6301	}
6302	#ifdef LIBXML_LEGACY_ENABLED
6303	if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
6304	xmlAddEntityReference(ent, firstChild, nw);
6305	#endif /* LIBXML_LEGACY_ENABLED */
6306	} else if (list == NULL) {
6307	xmlNodePtr nw = NULL, cur, next, last,
6308	firstChild = NULL;
6309	/*
6310	* Copy the entity child list and make it the new
6311	* entity child list. The goal is to make sure any
6312	* ID or REF referenced will be the one from the
6313	* document content and not the entity copy.
6314	*/
6315	cur = ent->children;
6316	ent->children = NULL;
6317	last = ent->last;
6318	ent->last = NULL;
6319	while (cur != NULL) {
6320	next = cur->next;
6321	cur->next = NULL;
6322	cur->parent = NULL;
6323	nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
6324	if (nw != NULL) {
6325	if (nw->_private == NULL)
6326	nw->_private = cur->_private;
6327	if (firstChild == NULL){
6328	firstChild = cur;
6329	}
6330	xmlAddChild((xmlNodePtr) ent, nw);
6331	xmlAddChild(ctxt->node, cur);
6332	}
6333	if (cur == last)
6334	break;
6335	cur = next;
6336	}
6337	ent->owner = 1;
6338	#ifdef LIBXML_LEGACY_ENABLED
6339	if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
6340	xmlAddEntityReference(ent, firstChild, nw);
6341	#endif /* LIBXML_LEGACY_ENABLED */
6342	} else {
6343	const xmlChar *nbktext;
6344
6345	/*
6346	* the name change is to avoid coalescing of the
6347	* node with a possible previous text one which
6348	* would make ent->children a dangling pointer
6349	*/
6350	nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
6351	-1);
6352	if (ent->children->type == XML_TEXT_NODE)
6353	ent->children->name = nbktext;
6354	if ((ent->last != ent->children) &&
6355	(ent->last->type == XML_TEXT_NODE))
6356	ent->last->name = nbktext;
6357	xmlAddChildList(ctxt->node, ent->children);
6358	}
6359
6360	/*
6361	* This is to avoid a nasty side effect, see
6362	* characters() in SAX.c
6363	*/
6364	ctxt->nodemem = 0;
6365	ctxt->nodelen = 0;
6366	return;
6367	}
6368	}
6369	} else {
6370	val = ent->content;
6371	if (val == NULL) return;
6372	/*
6373	* inline the entity.
6374	*/
6375	if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
6376	(!ctxt->disableSAX))
6377	ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
6378	}
6379	}
6380	}
6381
6382	/**
6383	* xmlParseEntityRef:
6384	* @ctxt: an XML parser context
6385	*
6386	* parse ENTITY references declarations
6387	*
6388	* [68] EntityRef ::= '&' Name ';'
6389	*
6390	* [ WFC: Entity Declared ]
6391	* In a document without any DTD, a document with only an internal DTD
6392	* subset which contains no parameter entity references, or a document
6393	* with "standalone='yes'", the Name given in the entity reference
6394	* must match that in an entity declaration, except that well-formed
6395	* documents need not declare any of the following entities: amp, lt,
6396	* gt, apos, quot. The declaration of a parameter entity must precede
6397	* any reference to it. Similarly, the declaration of a general entity
6398	* must precede any reference to it which appears in a default value in an
6399	* attribute-list declaration. Note that if entities are declared in the
6400	* external subset or in external parameter entities, a non-validating
6401	* processor is not obligated to read and process their declarations;
6402	* for such documents, the rule that an entity must be declared is a
6403	* well-formedness constraint only if standalone='yes'.
6404	*
6405	* [ WFC: Parsed Entity ]
6406	* An entity reference must not contain the name of an unparsed entity
6407	*
6408	* Returns the xmlEntityPtr if found, or NULL otherwise.
6409	*/
6410	xmlEntityPtr
6411	xmlParseEntityRef(xmlParserCtxtPtr ctxt) {
6412	const xmlChar *name;
6413	xmlEntityPtr ent = NULL;
6414
6415	GROW;
6416
6417	if (RAW == '&') {
6418	NEXT;
6419	name = xmlParseName(ctxt);
6420	if (name == NULL) {
6421	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6422	"xmlParseEntityRef: no name\n");
6423	} else {
6424	if (RAW == ';') {
6425	NEXT;
6426	/*
6427	* Ask first SAX for entity resolution, otherwise try the
6428	* predefined set.
6429	*/
6430	if (ctxt->sax != NULL) {
6431	if (ctxt->sax->getEntity != NULL)
6432	ent = ctxt->sax->getEntity(ctxt->userData, name);
6433	if ((ctxt->wellFormed == 1 ) && (ent == NULL))
6434	ent = xmlGetPredefinedEntity(name);
6435	if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
6436	(ctxt->userData==ctxt)) {
6437	ent = xmlSAX2GetEntity(ctxt, name);
6438	}
6439	}
6440	/*
6441	* [ WFC: Entity Declared ]
6442	* In a document without any DTD, a document with only an
6443	* internal DTD subset which contains no parameter entity
6444	* references, or a document with "standalone='yes'", the
6445	* Name given in the entity reference must match that in an
6446	* entity declaration, except that well-formed documents
6447	* need not declare any of the following entities: amp, lt,
6448	* gt, apos, quot.
6449	* The declaration of a parameter entity must precede any
6450	* reference to it.
6451	* Similarly, the declaration of a general entity must
6452	* precede any reference to it which appears in a default
6453	* value in an attribute-list declaration. Note that if
6454	* entities are declared in the external subset or in
6455	* external parameter entities, a non-validating processor
6456	* is not obligated to read and process their declarations;
6457	* for such documents, the rule that an entity must be
6458	* declared is a well-formedness constraint only if
6459	* standalone='yes'.
6460	*/
6461	if (ent == NULL) {
6462	if ((ctxt->standalone == 1) \|\|
6463	((ctxt->hasExternalSubset == 0) &&
6464	(ctxt->hasPErefs == 0))) {
6465	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6466	"Entity '%s' not defined\n", name);
6467	} else {
6468	xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
6469	"Entity '%s' not defined\n", name);
6470	if ((ctxt->inSubset == 0) &&
6471	(ctxt->sax != NULL) &&
6472	(ctxt->sax->reference != NULL)) {
6473	ctxt->sax->reference(ctxt->userData, name);
6474	}
6475	}
6476	ctxt->valid = 0;
6477	}
6478
6479	/*
6480	* [ WFC: Parsed Entity ]
6481	* An entity reference must not contain the name of an
6482	* unparsed entity
6483	*/
6484	else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
6485	xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
6486	"Entity reference to unparsed entity %s\n", name);
6487	}
6488
6489	/*
6490	* [ WFC: No External Entity References ]
6491	* Attribute values cannot contain direct or indirect
6492	* entity references to external entities.
6493	*/
6494	else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
6495	(ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
6496	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
6497	"Attribute references external entity '%s'\n", name);
6498	}
6499	/*
6500	* [ WFC: No < in Attribute Values ]
6501	* The replacement text of any entity referred to directly or
6502	* indirectly in an attribute value (other than "<") must
6503	* not contain a <.
6504	*/
6505	else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
6506	(ent != NULL) &&
6507	(!xmlStrEqual(ent->name, BAD_CAST "lt")) &&
6508	(ent->content != NULL) &&
6509	(xmlStrchr(ent->content, '<'))) {
6510	xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
6511	"'<' in entity '%s' is not allowed in attributes values\n", name);
6512	}
6513
6514	/*
6515	* Internal check, no parameter entities here ...
6516	*/
6517	else {
6518	switch (ent->etype) {
6519	case XML_INTERNAL_PARAMETER_ENTITY:
6520	case XML_EXTERNAL_PARAMETER_ENTITY:
6521	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
6522	"Attempt to reference the parameter entity '%s'\n",
6523	name);
6524	break;
6525	default:
6526	break;
6527	}
6528	}
6529
6530	/*
6531	* [ WFC: No Recursion ]
6532	* A parsed entity must not contain a recursive reference
6533	* to itself, either directly or indirectly.
6534	* Done somewhere else
6535	*/
6536
6537	} else {
6538	xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
6539	}
6540	}
6541	}
6542	return(ent);
6543	}
6544
6545	/**
6546	* xmlParseStringEntityRef:
6547	* @ctxt: an XML parser context
6548	* @str: a pointer to an index in the string
6549	*
6550	* parse ENTITY references declarations, but this version parses it from
6551	* a string value.
6552	*
6553	* [68] EntityRef ::= '&' Name ';'
6554	*
6555	* [ WFC: Entity Declared ]
6556	* In a document without any DTD, a document with only an internal DTD
6557	* subset which contains no parameter entity references, or a document
6558	* with "standalone='yes'", the Name given in the entity reference
6559	* must match that in an entity declaration, except that well-formed
6560	* documents need not declare any of the following entities: amp, lt,
6561	* gt, apos, quot. The declaration of a parameter entity must precede
6562	* any reference to it. Similarly, the declaration of a general entity
6563	* must precede any reference to it which appears in a default value in an
6564	* attribute-list declaration. Note that if entities are declared in the
6565	* external subset or in external parameter entities, a non-validating
6566	* processor is not obligated to read and process their declarations;
6567	* for such documents, the rule that an entity must be declared is a
6568	* well-formedness constraint only if standalone='yes'.
6569	*
6570	* [ WFC: Parsed Entity ]
6571	* An entity reference must not contain the name of an unparsed entity
6572	*
6573	* Returns the xmlEntityPtr if found, or NULL otherwise. The str pointer
6574	* is updated to the current location in the string.
6575	*/
6576	xmlEntityPtr
6577	xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
6578	xmlChar *name;
6579	const xmlChar *ptr;
6580	xmlChar cur;
6581	xmlEntityPtr ent = NULL;
6582
6583	if ((str == NULL) \|\| (*str == NULL))
6584	return(NULL);
6585	ptr = *str;
6586	cur = *ptr;
6587	if (cur == '&') {
6588	ptr++;
6589	cur = *ptr;
6590	name = xmlParseStringName(ctxt, &ptr);
6591	if (name == NULL) {
6592	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6593	"xmlParseStringEntityRef: no name\n");
6594	} else {
6595	if (*ptr == ';') {
6596	ptr++;
6597	/*
6598	* Ask first SAX for entity resolution, otherwise try the
6599	* predefined set.
6600	*/
6601	if (ctxt->sax != NULL) {
6602	if (ctxt->sax->getEntity != NULL)
6603	ent = ctxt->sax->getEntity(ctxt->userData, name);
6604	if (ent == NULL)
6605	ent = xmlGetPredefinedEntity(name);
6606	if ((ent == NULL) && (ctxt->userData==ctxt)) {
6607	ent = xmlSAX2GetEntity(ctxt, name);
6608	}
6609	}
6610	/*
6611	* [ WFC: Entity Declared ]
6612	* In a document without any DTD, a document with only an
6613	* internal DTD subset which contains no parameter entity
6614	* references, or a document with "standalone='yes'", the
6615	* Name given in the entity reference must match that in an
6616	* entity declaration, except that well-formed documents
6617	* need not declare any of the following entities: amp, lt,
6618	* gt, apos, quot.
6619	* The declaration of a parameter entity must precede any
6620	* reference to it.
6621	* Similarly, the declaration of a general entity must
6622	* precede any reference to it which appears in a default
6623	* value in an attribute-list declaration. Note that if
6624	* entities are declared in the external subset or in
6625	* external parameter entities, a non-validating processor
6626	* is not obligated to read and process their declarations;
6627	* for such documents, the rule that an entity must be
6628	* declared is a well-formedness constraint only if
6629	* standalone='yes'.
6630	*/
6631	if (ent == NULL) {
6632	if ((ctxt->standalone == 1) \|\|
6633	((ctxt->hasExternalSubset == 0) &&
6634	(ctxt->hasPErefs == 0))) {
6635	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6636	"Entity '%s' not defined\n", name);
6637	} else {
6638	xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
6639	"Entity '%s' not defined\n",
6640	name);
6641	}
6642	/* TODO ? check regressions ctxt->valid = 0; */
6643	}
6644
6645	/*
6646	* [ WFC: Parsed Entity ]
6647	* An entity reference must not contain the name of an
6648	* unparsed entity
6649	*/
6650	else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
6651	xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
6652	"Entity reference to unparsed entity %s\n", name);
6653	}
6654
6655	/*
6656	* [ WFC: No External Entity References ]
6657	* Attribute values cannot contain direct or indirect
6658	* entity references to external entities.
6659	*/
6660	else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
6661	(ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
6662	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
6663	"Attribute references external entity '%s'\n", name);
6664	}
6665	/*
6666	* [ WFC: No < in Attribute Values ]
6667	* The replacement text of any entity referred to directly or
6668	* indirectly in an attribute value (other than "<") must
6669	* not contain a <.
6670	*/
6671	else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
6672	(ent != NULL) &&
6673	(!xmlStrEqual(ent->name, BAD_CAST "lt")) &&
6674	(ent->content != NULL) &&
6675	(xmlStrchr(ent->content, '<'))) {
6676	xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
6677	"'<' in entity '%s' is not allowed in attributes values\n",
6678	name);
6679	}
6680
6681	/*
6682	* Internal check, no parameter entities here ...
6683	*/
6684	else {
6685	switch (ent->etype) {
6686	case XML_INTERNAL_PARAMETER_ENTITY:
6687	case XML_EXTERNAL_PARAMETER_ENTITY:
6688	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
6689	"Attempt to reference the parameter entity '%s'\n",
6690	name);
6691	break;
6692	default:
6693	break;
6694	}
6695	}
6696
6697	/*
6698	* [ WFC: No Recursion ]
6699	* A parsed entity must not contain a recursive reference
6700	* to itself, either directly or indirectly.
6701	* Done somewhere else
6702	*/
6703
6704	} else {
6705	xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
6706	}
6707	xmlFree(name);
6708	}
6709	}
6710	*str = ptr;
6711	return(ent);
6712	}
6713
6714	/**
6715	* xmlParsePEReference:
6716	* @ctxt: an XML parser context
6717	*
6718	* parse PEReference declarations
6719	* The entity content is handled directly by pushing it's content as
6720	* a new input stream.
6721	*
6722	* [69] PEReference ::= '%' Name ';'
6723	*
6724	* [ WFC: No Recursion ]
6725	* A parsed entity must not contain a recursive
6726	* reference to itself, either directly or indirectly.
6727	*
6728	* [ WFC: Entity Declared ]
6729	* In a document without any DTD, a document with only an internal DTD
6730	* subset which contains no parameter entity references, or a document
6731	* with "standalone='yes'", ... ... The declaration of a parameter
6732	* entity must precede any reference to it...
6733	*
6734	* [ VC: Entity Declared ]
6735	* In a document with an external subset or external parameter entities
6736	* with "standalone='no'", ... ... The declaration of a parameter entity
6737	* must precede any reference to it...
6738	*
6739	* [ WFC: In DTD ]
6740	* Parameter-entity references may only appear in the DTD.
6741	* NOTE: misleading but this is handled.
6742	*/
6743	void
6744	xmlParsePEReference(xmlParserCtxtPtr ctxt)
6745	{
6746	const xmlChar *name;
6747	xmlEntityPtr entity = NULL;
6748	xmlParserInputPtr input;
6749
6750	if (RAW == '%') {
6751	NEXT;
6752	name = xmlParseName(ctxt);
6753	if (name == NULL) {
6754	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6755	"xmlParsePEReference: no name\n");
6756	} else {
6757	if (RAW == ';') {
6758	NEXT;
6759	if ((ctxt->sax != NULL) &&
6760	(ctxt->sax->getParameterEntity != NULL))
6761	entity = ctxt->sax->getParameterEntity(ctxt->userData,
6762	name);
6763	if (entity == NULL) {
6764	/*
6765	* [ WFC: Entity Declared ]
6766	* In a document without any DTD, a document with only an
6767	* internal DTD subset which contains no parameter entity
6768	* references, or a document with "standalone='yes'", ...
6769	* ... The declaration of a parameter entity must precede
6770	* any reference to it...
6771	*/
6772	if ((ctxt->standalone == 1) \|\|
6773	((ctxt->hasExternalSubset == 0) &&
6774	(ctxt->hasPErefs == 0))) {
6775	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6776	"PEReference: %%%s; not found\n",
6777	name);
6778	} else {
6779	/*
6780	* [ VC: Entity Declared ]
6781	* In a document with an external subset or external
6782	* parameter entities with "standalone='no'", ...
6783	* ... The declaration of a parameter entity must
6784	* precede any reference to it...
6785	*/
6786	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
6787	"PEReference: %%%s; not found\n",
6788	name, NULL);
6789	ctxt->valid = 0;
6790	}
6791	} else {
6792	/*
6793	* Internal checking in case the entity quest barfed
6794	*/
6795	if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
6796	(entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
6797	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
6798	"Internal: %%%s; is not a parameter entity\n",
6799	name, NULL);
6800	} else if (ctxt->input->free != deallocblankswrapper) {
6801	input =
6802	xmlNewBlanksWrapperInputStream(ctxt, entity);
6803	xmlPushInput(ctxt, input);
6804	} else {
6805	/*
6806	* TODO !!!
6807	* handle the extra spaces added before and after
6808	* c.f. http://www.w3.org/TR/REC-xml#as-PE
6809	*/
6810	input = xmlNewEntityInputStream(ctxt, entity);
6811	xmlPushInput(ctxt, input);
6812	if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
6813	(CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
6814	(IS_BLANK_CH(NXT(5)))) {
6815	xmlParseTextDecl(ctxt);
6816	if (ctxt->errNo ==
6817	XML_ERR_UNSUPPORTED_ENCODING) {
6818	/*
6819	* The XML REC instructs us to stop parsing
6820	* right here
6821	*/
6822	ctxt->instate = XML_PARSER_EOF;
6823	return;
6824	}
6825	}
6826	}
6827	}
6828	ctxt->hasPErefs = 1;
6829	} else {
6830	xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
6831	}
6832	}
6833	}
6834	}
6835
6836	/**
6837	* xmlParseStringPEReference:
6838	* @ctxt: an XML parser context
6839	* @str: a pointer to an index in the string
6840	*
6841	* parse PEReference declarations
6842	*
6843	* [69] PEReference ::= '%' Name ';'
6844	*
6845	* [ WFC: No Recursion ]
6846	* A parsed entity must not contain a recursive
6847	* reference to itself, either directly or indirectly.
6848	*
6849	* [ WFC: Entity Declared ]
6850	* In a document without any DTD, a document with only an internal DTD
6851	* subset which contains no parameter entity references, or a document
6852	* with "standalone='yes'", ... ... The declaration of a parameter
6853	* entity must precede any reference to it...
6854	*
6855	* [ VC: Entity Declared ]
6856	* In a document with an external subset or external parameter entities
6857	* with "standalone='no'", ... ... The declaration of a parameter entity
6858	* must precede any reference to it...
6859	*
6860	* [ WFC: In DTD ]
6861	* Parameter-entity references may only appear in the DTD.
6862	* NOTE: misleading but this is handled.
6863	*
6864	* Returns the string of the entity content.
6865	* str is updated to the current value of the index
6866	*/
6867	xmlEntityPtr
6868	xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) {
6869	const xmlChar *ptr;
6870	xmlChar cur;
6871	xmlChar *name;
6872	xmlEntityPtr entity = NULL;
6873
6874	if ((str == NULL) \|\| (*str == NULL)) return(NULL);
6875	ptr = *str;
6876	cur = *ptr;
6877	if (cur == '%') {
6878	ptr++;
6879	cur = *ptr;
6880	name = xmlParseStringName(ctxt, &ptr);
6881	if (name == NULL) {
6882	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6883	"xmlParseStringPEReference: no name\n");
6884	} else {
6885	cur = *ptr;
6886	if (cur == ';') {
6887	ptr++;
6888	cur = *ptr;
6889	if ((ctxt->sax != NULL) &&
6890	(ctxt->sax->getParameterEntity != NULL))
6891	entity = ctxt->sax->getParameterEntity(ctxt->userData,
6892	name);
6893	if (entity == NULL) {
6894	/*
6895	* [ WFC: Entity Declared ]
6896	* In a document without any DTD, a document with only an
6897	* internal DTD subset which contains no parameter entity
6898	* references, or a document with "standalone='yes'", ...
6899	* ... The declaration of a parameter entity must precede
6900	* any reference to it...
6901	*/
6902	if ((ctxt->standalone == 1) \|\|
6903	((ctxt->hasExternalSubset == 0) &&
6904	(ctxt->hasPErefs == 0))) {
6905	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6906	"PEReference: %%%s; not found\n", name);
6907	} else {
6908	/*
6909	* [ VC: Entity Declared ]
6910	* In a document with an external subset or external
6911	* parameter entities with "standalone='no'", ...
6912	* ... The declaration of a parameter entity must
6913	* precede any reference to it...
6914	*/
6915	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
6916	"PEReference: %%%s; not found\n",
6917	name, NULL);
6918	ctxt->valid = 0;
6919	}
6920	} else {
6921	/*
6922	* Internal checking in case the entity quest barfed
6923	*/
6924	if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
6925	(entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
6926	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
6927	"%%%s; is not a parameter entity\n",
6928	name, NULL);
6929	}
6930	}
6931	ctxt->hasPErefs = 1;
6932	} else {
6933	xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
6934	}
6935	xmlFree(name);
6936	}
6937	}
6938	*str = ptr;
6939	return(entity);
6940	}
6941
6942	/**
6943	* xmlParseDocTypeDecl:
6944	* @ctxt: an XML parser context
6945	*
6946	* parse a DOCTYPE declaration
6947	*
6948	* [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S?
6949	* ('[' (markupdecl \| PEReference \| S)* ']' S?)? '>'
6950	*
6951	* [ VC: Root Element Type ]
6952	* The Name in the document type declaration must match the element
6953	* type of the root element.
6954	*/
6955
6956	void
6957	xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) {
6958	const xmlChar *name = NULL;
6959	xmlChar *ExternalID = NULL;
6960	xmlChar *URI = NULL;
6961
6962	/*
6963	* We know that '<!DOCTYPE' has been detected.
6964	*/
6965	SKIP(9);
6966
6967	SKIP_BLANKS;
6968
6969	/*
6970	* Parse the DOCTYPE name.
6971	*/
6972	name = xmlParseName(ctxt);
6973	if (name == NULL) {
6974	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6975	"xmlParseDocTypeDecl : no DOCTYPE name !\n");
6976	}
6977	ctxt->intSubName = name;
6978
6979	SKIP_BLANKS;
6980
6981	/*
6982	* Check for SystemID and ExternalID
6983	*/
6984	URI = xmlParseExternalID(ctxt, &ExternalID, 1);
6985
6986	if ((URI != NULL) \|\| (ExternalID != NULL)) {
6987	ctxt->hasExternalSubset = 1;
6988	}
6989	ctxt->extSubURI = URI;
6990	ctxt->extSubSystem = ExternalID;
6991
6992	SKIP_BLANKS;
6993
6994	/*
6995	* Create and update the internal subset.
6996	*/
6997	if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
6998	(!ctxt->disableSAX))
6999	ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
7000
7001	/*
7002	* Is there any internal subset declarations ?
7003	* they are handled separately in xmlParseInternalSubset()
7004	*/
7005	if (RAW == '[')
7006	return;
7007
7008	/*
7009	* We should be at the end of the DOCTYPE declaration.
7010	*/
7011	if (RAW != '>') {
7012	xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
7013	}
7014	NEXT;
7015	}
7016
7017	/**
7018	* xmlParseInternalSubset:
7019	* @ctxt: an XML parser context
7020	*
7021	* parse the internal subset declaration
7022	*
7023	* [28 end] ('[' (markupdecl \| PEReference \| S)* ']' S?)? '>'
7024	*/
7025
7026	static void
7027	xmlParseInternalSubset(xmlParserCtxtPtr ctxt) {
7028	/*
7029	* Is there any DTD definition ?
7030	*/
7031	if (RAW == '[') {
7032	ctxt->instate = XML_PARSER_DTD;
7033	NEXT;
7034	/*
7035	* Parse the succession of Markup declarations and
7036	* PEReferences.
7037	* Subsequence (markupdecl \| PEReference \| S)*
7038	*/
7039	while (RAW != ']') {
7040	const xmlChar *check = CUR_PTR;
7041	unsigned int cons = ctxt->input->consumed;
7042
7043	SKIP_BLANKS;
7044	xmlParseMarkupDecl(ctxt);
7045	xmlParsePEReference(ctxt);
7046
7047	/*
7048	* Pop-up of finished entities.
7049	*/
7050	while ((RAW == 0) && (ctxt->inputNr > 1))
7051	xmlPopInput(ctxt);
7052
7053	if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
7054	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
7055	"xmlParseInternalSubset: error detected in Markup declaration\n");
7056	break;
7057	}
7058	}
7059	if (RAW == ']') {
7060	NEXT;
7061	SKIP_BLANKS;
7062	}
7063	}
7064
7065	/*
7066	* We should be at the end of the DOCTYPE declaration.
7067	*/
7068	if (RAW != '>') {
7069	xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
7070	}
7071	NEXT;
7072	}
7073
7074	#ifdef LIBXML_SAX1_ENABLED
7075	/**
7076	* xmlParseAttribute:
7077	* @ctxt: an XML parser context
7078	* @value: a xmlChar ** used to store the value of the attribute
7079	*
7080	* parse an attribute
7081	*
7082	* [41] Attribute ::= Name Eq AttValue
7083	*
7084	* [ WFC: No External Entity References ]
7085	* Attribute values cannot contain direct or indirect entity references
7086	* to external entities.
7087	*
7088	* [ WFC: No < in Attribute Values ]
7089	* The replacement text of any entity referred to directly or indirectly in
7090	* an attribute value (other than "<") must not contain a <.
7091	*
7092	* [ VC: Attribute Value Type ]
7093	* The attribute must have been declared; the value must be of the type
7094	* declared for it.
7095	*
7096	* [25] Eq ::= S? '=' S?
7097	*
7098	* With namespace:
7099	*
7100	* [NS 11] Attribute ::= QName Eq AttValue
7101	*
7102	* Also the case QName == xmlns:??? is handled independently as a namespace
7103	* definition.
7104	*
7105	* Returns the attribute name, and the value in *value.
7106	*/
7107
7108	const xmlChar *
7109	xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) {
7110	const xmlChar *name;
7111	xmlChar *val;
7112
7113	*value = NULL;
7114	GROW;
7115	name = xmlParseName(ctxt);
7116	if (name == NULL) {
7117	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7118	"error parsing attribute name\n");
7119	return(NULL);
7120	}
7121
7122	/*
7123	* read the value
7124	*/
7125	SKIP_BLANKS;
7126	if (RAW == '=') {
7127	NEXT;
7128	SKIP_BLANKS;
7129	val = xmlParseAttValue(ctxt);
7130	ctxt->instate = XML_PARSER_CONTENT;
7131	} else {
7132	xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
7133	"Specification mandate value for attribute %s\n", name);
7134	return(NULL);
7135	}
7136
7137	/*
7138	* Check that xml:lang conforms to the specification
7139	* No more registered as an error, just generate a warning now
7140	* since this was deprecated in XML second edition
7141	*/
7142	if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
7143	if (!xmlCheckLanguageID(val)) {
7144	xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
7145	"Malformed value for xml:lang : %s\n",
7146	val, NULL);
7147	}
7148	}
7149
7150	/*
7151	* Check that xml:space conforms to the specification
7152	*/
7153	if (xmlStrEqual(name, BAD_CAST "xml:space")) {
7154	if (xmlStrEqual(val, BAD_CAST "default"))
7155	*(ctxt->space) = 0;
7156	else if (xmlStrEqual(val, BAD_CAST "preserve"))
7157	*(ctxt->space) = 1;
7158	else {
7159	xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
7160	"Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
7161	val, NULL);
7162	}
7163	}
7164
7165	*value = val;
7166	return(name);
7167	}
7168
7169	/**
7170	* xmlParseStartTag:
7171	* @ctxt: an XML parser context
7172	*
7173	* parse a start of tag either for rule element or
7174	* EmptyElement. In both case we don't parse the tag closing chars.
7175	*
7176	* [40] STag ::= '<' Name (S Attribute)* S? '>'
7177	*
7178	* [ WFC: Unique Att Spec ]
7179	* No attribute name may appear more than once in the same start-tag or
7180	* empty-element tag.
7181	*
7182	* [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
7183	*
7184	* [ WFC: Unique Att Spec ]
7185	* No attribute name may appear more than once in the same start-tag or
7186	* empty-element tag.
7187	*
7188	* With namespace:
7189	*
7190	* [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
7191	*
7192	* [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
7193	*
7194	* Returns the element name parsed
7195	*/
7196
7197	const xmlChar *
7198	xmlParseStartTag(xmlParserCtxtPtr ctxt) {
7199	const xmlChar *name;
7200	const xmlChar *attname;
7201	xmlChar *attvalue;
7202	const xmlChar **atts = ctxt->atts;
7203	int nbatts = 0;
7204	int maxatts = ctxt->maxatts;
7205	int i;
7206
7207	if (RAW != '<') return(NULL);
7208	NEXT1;
7209
7210	name = xmlParseName(ctxt);
7211	if (name == NULL) {
7212	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7213	"xmlParseStartTag: invalid element name\n");
7214	return(NULL);
7215	}
7216
7217	/*
7218	* Now parse the attributes, it ends up with the ending
7219	*
7220	* (S Attribute)* S?
7221	*/
7222	SKIP_BLANKS;
7223	GROW;
7224
7225	while ((RAW != '>') &&
7226	((RAW != '/') \|\| (NXT(1) != '>')) &&
7227	(IS_BYTE_CHAR(RAW))) {
7228	const xmlChar *q = CUR_PTR;
7229	unsigned int cons = ctxt->input->consumed;
7230
7231	attname = xmlParseAttribute(ctxt, &attvalue);
7232	if ((attname != NULL) && (attvalue != NULL)) {
7233	/*
7234	* [ WFC: Unique Att Spec ]
7235	* No attribute name may appear more than once in the same
7236	* start-tag or empty-element tag.
7237	*/
7238	for (i = 0; i < nbatts;i += 2) {
7239	if (xmlStrEqual(atts[i], attname)) {
7240	xmlErrAttributeDup(ctxt, NULL, attname);
7241	xmlFree(attvalue);
7242	goto failed;
7243	}
7244	}
7245	/*
7246	* Add the pair to atts
7247	*/
7248	if (atts == NULL) {
7249	maxatts = 22; /* allow for 10 attrs by default */
7250	atts = (const xmlChar **)
7251	xmlMalloc(maxatts * sizeof(xmlChar *));
7252	if (atts == NULL) {
7253	xmlErrMemory(ctxt, NULL);
7254	if (attvalue != NULL)
7255	xmlFree(attvalue);
7256	goto failed;
7257	}
7258	ctxt->atts = atts;
7259	ctxt->maxatts = maxatts;
7260	} else if (nbatts + 4 > maxatts) {
7261	const xmlChar **n;
7262
7263	maxatts *= 2;
7264	n = (const xmlChar *) xmlRealloc((void ) atts,
7265	maxatts * sizeof(const xmlChar *));
7266	if (n == NULL) {
7267	xmlErrMemory(ctxt, NULL);
7268	if (attvalue != NULL)
7269	xmlFree(attvalue);
7270	goto failed;
7271	}
7272	atts = n;
7273	ctxt->atts = atts;
7274	ctxt->maxatts = maxatts;
7275	}
7276	atts[nbatts++] = attname;
7277	atts[nbatts++] = attvalue;
7278	atts[nbatts] = NULL;
7279	atts[nbatts + 1] = NULL;
7280	} else {
7281	if (attvalue != NULL)
7282	xmlFree(attvalue);
7283	}
7284
7285	failed:
7286
7287	GROW
7288	if ((RAW == '>') \|\| (((RAW == '/') && (NXT(1) == '>'))))
7289	break;
7290	if (!IS_BLANK_CH(RAW)) {
7291	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
7292	"attributes construct error\n");
7293	}
7294	SKIP_BLANKS;
7295	if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
7296	(attname == NULL) && (attvalue == NULL)) {
7297	xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
7298	"xmlParseStartTag: problem parsing attributes\n");
7299	break;
7300	}
7301	SHRINK;
7302	GROW;
7303	}
7304
7305	/*
7306	* SAX: Start of Element !
7307	*/
7308	if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) &&
7309	(!ctxt->disableSAX)) {
7310	if (nbatts > 0)
7311	ctxt->sax->startElement(ctxt->userData, name, atts);
7312	else
7313	ctxt->sax->startElement(ctxt->userData, name, NULL);
7314	}
7315
7316	if (atts != NULL) {
7317	/* Free only the content strings */
7318	for (i = 1;i < nbatts;i+=2)
7319	if (atts[i] != NULL)
7320	xmlFree((xmlChar *) atts[i]);
7321	}
7322	return(name);
7323	}
7324
7325	/**
7326	* xmlParseEndTag1:
7327	* @ctxt: an XML parser context
7328	* @line: line of the start tag
7329	* @nsNr: number of namespaces on the start tag
7330	*
7331	* parse an end of tag
7332	*
7333	* [42] ETag ::= '</' Name S? '>'
7334	*
7335	* With namespace
7336	*
7337	* [NS 9] ETag ::= '</' QName S? '>'
7338	*/
7339
7340	static void
7341	xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) {
7342	const xmlChar *name;
7343
7344	GROW;
7345	if ((RAW != '<') \|\| (NXT(1) != '/')) {
7346	xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED,
7347	"xmlParseEndTag: '</' not found\n");
7348	return;
7349	}
7350	SKIP(2);
7351
7352	name = xmlParseNameAndCompare(ctxt,ctxt->name);
7353
7354	/*
7355	* We should definitely be at the ending "S? '>'" part
7356	*/
7357	GROW;
7358	SKIP_BLANKS;
7359	if ((!IS_BYTE_CHAR(RAW)) \|\| (RAW != '>')) {
7360	xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
7361	} else
7362	NEXT1;
7363
7364	/*
7365	* [ WFC: Element Type Match ]
7366	* The Name in an element's end-tag must match the element type in the
7367	* start-tag.
7368	*
7369	*/
7370	if (name != (xmlChar*)1) {
7371	if (name == NULL) name = BAD_CAST "unparseable";
7372	xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
7373	"Opening and ending tag mismatch: %s line %d and %s\n",
7374	ctxt->name, line, name);
7375	}
7376
7377	/*
7378	* SAX: End of Tag
7379	*/
7380	if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
7381	(!ctxt->disableSAX))
7382	ctxt->sax->endElement(ctxt->userData, ctxt->name);
7383
7384	namePop(ctxt);
7385	spacePop(ctxt);
7386	return;
7387	}
7388
7389	/**
7390	* xmlParseEndTag:
7391	* @ctxt: an XML parser context
7392	*
7393	* parse an end of tag
7394	*
7395	* [42] ETag ::= '</' Name S? '>'
7396	*
7397	* With namespace
7398	*
7399	* [NS 9] ETag ::= '</' QName S? '>'
7400	*/
7401
7402	void
7403	xmlParseEndTag(xmlParserCtxtPtr ctxt) {
7404	xmlParseEndTag1(ctxt, 0);
7405	}
7406	#endif /* LIBXML_SAX1_ENABLED */
7407
7408	/************************************************************************
7409	* *
7410	* SAX 2 specific operations *
7411	* *
7412	************************************************************************/
7413
7414	static const xmlChar *
7415	xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
7416	int len = 0, l;
7417	int c;
7418	int count = 0;
7419
7420	/*
7421	* Handler for more complex cases
7422	*/
7423	GROW;
7424	c = CUR_CHAR(l);
7425	if ((c == ' ') \|\| (c == '>') \|\| (c == '/') \|\| /* accelerators */
7426	(!IS_LETTER(c) && (c != '_'))) {
7427	return(NULL);
7428	}
7429
7430	while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
7431	((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\|
7432	(c == '.') \|\| (c == '-') \|\| (c == '_') \|\|
7433	(IS_COMBINING(c)) \|\|
7434	(IS_EXTENDER(c)))) {
7435	if (count++ > 100) {
7436	count = 0;
7437	GROW;
7438	}
7439	len += l;
7440	NEXTL(l);
7441	c = CUR_CHAR(l);
7442	}
7443	return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
7444	}
7445
7446	/*
7447	* xmlGetNamespace:
7448	* @ctxt: an XML parser context
7449	* @prefix: the prefix to lookup
7450	*
7451	* Lookup the namespace name for the @prefix (which ca be NULL)
7452	* The prefix must come from the @ctxt->dict dictionnary
7453	*
7454	* Returns the namespace name or NULL if not bound
7455	*/
7456	static const xmlChar *
7457	xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
7458	int i;
7459
7460	if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns);
7461	for (i = ctxt->nsNr - 2;i >= 0;i-=2)
7462	if (ctxt->nsTab[i] == prefix) {
7463	if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0))
7464	return(NULL);
7465	return(ctxt->nsTab[i + 1]);
7466	}
7467	return(NULL);
7468	}
7469
7470	/**
7471	* xmlParseNCName:
7472	* @ctxt: an XML parser context
7473	* @len: lenght of the string parsed
7474	*
7475	* parse an XML name.
7476	*
7477	* [4NS] NCNameChar ::= Letter \| Digit \| '.' \| '-' \| '_' \|
7478	* CombiningChar \| Extender
7479	*
7480	* [5NS] NCName ::= (Letter \| '_') (NCNameChar)*
7481	*
7482	* Returns the Name parsed or NULL
7483	*/
7484
7485	static const xmlChar *
7486	xmlParseNCName(xmlParserCtxtPtr ctxt) {
7487	const xmlChar *in;
7488	const xmlChar *ret;
7489	int count = 0;
7490
7491	/*
7492	* Accelerator for simple ASCII names
7493	*/
7494	in = ctxt->input->cur;
7495	if (((in >= 0x61) && (in <= 0x7A)) \|\|
7496	((in >= 0x41) && (in <= 0x5A)) \|\|
7497	(*in == '_')) {
7498	in++;
7499	while (((in >= 0x61) && (in <= 0x7A)) \|\|
7500	((in >= 0x41) && (in <= 0x5A)) \|\|
7501	((in >= 0x30) && (in <= 0x39)) \|\|
7502	(in == '_') \|\| (in == '-') \|\|
7503	(*in == '.'))
7504	in++;
7505	if ((in > 0) && (in < 0x80)) {
7506	count = in - ctxt->input->cur;
7507	ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
7508	ctxt->input->cur = in;
7509	ctxt->nbChars += count;
7510	ctxt->input->col += count;
7511	if (ret == NULL) {
7512	xmlErrMemory(ctxt, NULL);
7513	}
7514	return(ret);
7515	}
7516	}
7517	return(xmlParseNCNameComplex(ctxt));
7518	}
7519
7520	/**
7521	* xmlParseQName:
7522	* @ctxt: an XML parser context
7523	* @prefix: pointer to store the prefix part
7524	*
7525	* parse an XML Namespace QName
7526	*
7527	* [6] QName ::= (Prefix ':')? LocalPart
7528	* [7] Prefix ::= NCName
7529	* [8] LocalPart ::= NCName
7530	*
7531	* Returns the Name parsed or NULL
7532	*/
7533
7534	static const xmlChar *
7535	xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) {
7536	const xmlChar l, p;
7537
7538	GROW;
7539
7540	l = xmlParseNCName(ctxt);
7541	if (l == NULL) {
7542	if (CUR == ':') {
7543	l = xmlParseName(ctxt);
7544	if (l != NULL) {
7545	xmlNsErr(ctxt, XML_NS_ERR_QNAME,
7546	"Failed to parse QName '%s'\n", l, NULL, NULL);
7547	*prefix = NULL;
7548	return(l);
7549	}
7550	}
7551	return(NULL);
7552	}
7553	if (CUR == ':') {
7554	NEXT;
7555	p = l;
7556	l = xmlParseNCName(ctxt);
7557	if (l == NULL) {
7558	xmlChar *tmp;
7559
7560	xmlNsErr(ctxt, XML_NS_ERR_QNAME,
7561	"Failed to parse QName '%s:'\n", p, NULL, NULL);
7562	tmp = xmlBuildQName(BAD_CAST "", p, NULL, 0);
7563	p = xmlDictLookup(ctxt->dict, tmp, -1);
7564	if (tmp != NULL) xmlFree(tmp);
7565	*prefix = NULL;
7566	return(p);
7567	}
7568	if (CUR == ':') {
7569	xmlChar *tmp;
7570
7571	xmlNsErr(ctxt, XML_NS_ERR_QNAME,
7572	"Failed to parse QName '%s:%s:'\n", p, l, NULL);
7573	NEXT;
7574	tmp = (xmlChar *) xmlParseName(ctxt);
7575	if (tmp != NULL) {
7576	tmp = xmlBuildQName(tmp, l, NULL, 0);
7577	l = xmlDictLookup(ctxt->dict, tmp, -1);
7578	if (tmp != NULL) xmlFree(tmp);
7579	*prefix = p;
7580	return(l);
7581	}
7582	tmp = xmlBuildQName(BAD_CAST "", l, NULL, 0);
7583	l = xmlDictLookup(ctxt->dict, tmp, -1);
7584	if (tmp != NULL) xmlFree(tmp);
7585	*prefix = p;
7586	return(l);
7587	}
7588	*prefix = p;
7589	} else
7590	*prefix = NULL;
7591	return(l);
7592	}
7593
7594	/**
7595	* xmlParseQNameAndCompare:
7596	* @ctxt: an XML parser context
7597	* @name: the localname
7598	* @prefix: the prefix, if any.
7599	*
7600	* parse an XML name and compares for match
7601	* (specialized for endtag parsing)
7602	*
7603	* Returns NULL for an illegal name, (xmlChar*) 1 for success
7604	* and the name for mismatch
7605	*/
7606
7607	static const xmlChar *
7608	xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
7609	xmlChar const *prefix) {
7610	const xmlChar *cmp = name;
7611	const xmlChar *in;
7612	const xmlChar *ret;
7613	const xmlChar *prefix2;
7614
7615	if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
7616
7617	GROW;
7618	in = ctxt->input->cur;
7619
7620	cmp = prefix;
7621	while (in != 0 && in == *cmp) {
7622	++in;
7623	++cmp;
7624	}
7625	if ((cmp == 0) && (in == ':')) {
7626	in++;
7627	cmp = name;
7628	while (in != 0 && in == *cmp) {
7629	++in;
7630	++cmp;
7631	}
7632	if (cmp == 0 && (in == '>' \|\| IS_BLANK_CH (*in))) {
7633	/* success */
7634	ctxt->input->cur = in;
7635	return((const xmlChar*) 1);
7636	}
7637	}
7638	/*
7639	* all strings coms from the dictionary, equality can be done directly
7640	*/
7641	ret = xmlParseQName (ctxt, &prefix2);
7642	if ((ret == name) && (prefix == prefix2))
7643	return((const xmlChar*) 1);
7644	return ret;
7645	}
7646
7647	/**
7648	* xmlParseAttValueInternal:
7649	* @ctxt: an XML parser context
7650	* @len: attribute len result
7651	* @alloc: whether the attribute was reallocated as a new string
7652	* @normalize: if 1 then further non-CDATA normalization must be done
7653	*
7654	* parse a value for an attribute.
7655	* NOTE: if no normalization is needed, the routine will return pointers
7656	* directly from the data buffer.
7657	*
7658	* 3.3.3 Attribute-Value Normalization:
7659	* Before the value of an attribute is passed to the application or
7660	* checked for validity, the XML processor must normalize it as follows:
7661	* - a character reference is processed by appending the referenced
7662	* character to the attribute value
7663	* - an entity reference is processed by recursively processing the
7664	* replacement text of the entity
7665	* - a whitespace character (#x20, #xD, #xA, #x9) is processed by
7666	* appending #x20 to the normalized value, except that only a single
7667	* #x20 is appended for a "#xD#xA" sequence that is part of an external
7668	* parsed entity or the literal entity value of an internal parsed entity
7669	* - other characters are processed by appending them to the normalized value
7670	* If the declared value is not CDATA, then the XML processor must further
7671	* process the normalized attribute value by discarding any leading and
7672	* trailing space (#x20) characters, and by replacing sequences of space
7673	* (#x20) characters by a single space (#x20) character.
7674	* All attributes for which no declaration has been read should be treated
7675	* by a non-validating parser as if declared CDATA.
7676	*
7677	* Returns the AttValue parsed or NULL. The value has to be freed by the
7678	* caller if it was copied, this can be detected by val[*len] == 0.
7679	*/
7680
7681	static xmlChar *
7682	xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int len, int alloc,
7683	int normalize)
7684	{
7685	xmlChar limit = 0;
7686	const xmlChar in = NULL, start, end, last;
7687	xmlChar *ret = NULL;
7688
7689	GROW;
7690	in = (xmlChar *) CUR_PTR;
7691	if (in != '"' && in != '\'') {
7692	xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
7693	return (NULL);
7694	}
7695	ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
7696
7697	/*
7698	* try to handle in this routine the most common case where no
7699	* allocation of a new string is required and where content is
7700	* pure ASCII.
7701	*/
7702	limit = *in++;
7703	end = ctxt->input->end;
7704	start = in;
7705	if (in >= end) {
7706	const xmlChar *oldbase = ctxt->input->base;
7707	GROW;
7708	if (oldbase != ctxt->input->base) {
7709	long delta = ctxt->input->base - oldbase;
7710	start = start + delta;
7711	in = in + delta;
7712	}
7713	end = ctxt->input->end;
7714	}
7715	if (normalize) {
7716	/*
7717	* Skip any leading spaces
7718	*/
7719	while ((in < end) && (*in != limit) &&
7720	((in == 0x20) \|\| (in == 0x9) \|\|
7721	(in == 0xA) \|\| (in == 0xD))) {
7722	in++;
7723	start = in;
7724	if (in >= end) {
7725	const xmlChar *oldbase = ctxt->input->base;
7726	GROW;
7727	if (oldbase != ctxt->input->base) {
7728	long delta = ctxt->input->base - oldbase;
7729	start = start + delta;
7730	in = in + delta;
7731	}
7732	end = ctxt->input->end;
7733	}
7734	}
7735	while ((in < end) && (in != limit) && (in >= 0x20) &&
7736	(in <= 0x7f) && (in != '&') && (*in != '<')) {
7737	if ((in++ == 0x20) && (in == 0x20)) break;
7738	if (in >= end) {
7739	const xmlChar *oldbase = ctxt->input->base;
7740	GROW;
7741	if (oldbase != ctxt->input->base) {
7742	long delta = ctxt->input->base - oldbase;
7743	start = start + delta;
7744	in = in + delta;
7745	}
7746	end = ctxt->input->end;
7747	}
7748	}
7749	last = in;
7750	/*
7751	* skip the trailing blanks
7752	*/
7753	while ((last[-1] == 0x20) && (last > start)) last--;
7754	while ((in < end) && (*in != limit) &&
7755	((in == 0x20) \|\| (in == 0x9) \|\|
7756	(in == 0xA) \|\| (in == 0xD))) {
7757	in++;
7758	if (in >= end) {
7759	const xmlChar *oldbase = ctxt->input->base;
7760	GROW;
7761	if (oldbase != ctxt->input->base) {
7762	long delta = ctxt->input->base - oldbase;
7763	start = start + delta;
7764	in = in + delta;
7765	last = last + delta;
7766	}
7767	end = ctxt->input->end;
7768	}
7769	}
7770	if (*in != limit) goto need_complex;
7771	} else {
7772	while ((in < end) && (in != limit) && (in >= 0x20) &&
7773	(in <= 0x7f) && (in != '&') && (*in != '<')) {
7774	in++;
7775	if (in >= end) {
7776	const xmlChar *oldbase = ctxt->input->base;
7777	GROW;
7778	if (oldbase != ctxt->input->base) {
7779	long delta = ctxt->input->base - oldbase;
7780	start = start + delta;
7781	in = in + delta;
7782	}
7783	end = ctxt->input->end;
7784	}
7785	}
7786	last = in;
7787	if (*in != limit) goto need_complex;
7788	}
7789	in++;
7790	if (len != NULL) {
7791	*len = last - start;
7792	ret = (xmlChar *) start;
7793	} else {
7794	if (alloc) *alloc = 1;
7795	ret = xmlStrndup(start, last - start);
7796	}
7797	CUR_PTR = in;
7798	if (alloc) *alloc = 0;
7799	return ret;
7800	need_complex:
7801	if (alloc) *alloc = 1;
7802	return xmlParseAttValueComplex(ctxt, len, normalize);
7803	}
7804
7805	/**
7806	* xmlParseAttribute2:
7807	* @ctxt: an XML parser context
7808	* @pref: the element prefix
7809	* @elem: the element name
7810	* @prefix: a xmlChar ** used to store the value of the attribute prefix
7811	* @value: a xmlChar ** used to store the value of the attribute
7812	* @len: an int * to save the length of the attribute
7813	* @alloc: an int * to indicate if the attribute was allocated
7814	*
7815	* parse an attribute in the new SAX2 framework.
7816	*
7817	* Returns the attribute name, and the value in *value, .
7818	*/
7819
7820	static const xmlChar *
7821	xmlParseAttribute2(xmlParserCtxtPtr ctxt,
7822	const xmlChar pref, const xmlChar elem,
7823	const xmlChar prefix, xmlChar value,
7824	int len, int alloc) {
7825	const xmlChar *name;
7826	xmlChar val, internal_val = NULL;
7827	int normalize = 0;
7828
7829	*value = NULL;
7830	GROW;
7831	name = xmlParseQName(ctxt, prefix);
7832	if (name == NULL) {
7833	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7834	"error parsing attribute name\n");
7835	return(NULL);
7836	}
7837
7838	/*
7839	* get the type if needed
7840	*/
7841	if (ctxt->attsSpecial != NULL) {
7842	int type;
7843
7844	type = (int) (long) xmlHashQLookup2(ctxt->attsSpecial,
7845	pref, elem, *prefix, name);
7846	if (type != 0) normalize = 1;
7847	}
7848
7849	/*
7850	* read the value
7851	*/
7852	SKIP_BLANKS;
7853	if (RAW == '=') {
7854	NEXT;
7855	SKIP_BLANKS;
7856	val = xmlParseAttValueInternal(ctxt, len, alloc, normalize);
7857	ctxt->instate = XML_PARSER_CONTENT;
7858	} else {
7859	xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
7860	"Specification mandate value for attribute %s\n", name);
7861	return(NULL);
7862	}
7863
7864	if (*prefix == ctxt->str_xml) {
7865	/*
7866	* Check that xml:lang conforms to the specification
7867	* No more registered as an error, just generate a warning now
7868	* since this was deprecated in XML second edition
7869	*/
7870	if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) {
7871	internal_val = xmlStrndup(val, *len);
7872	if (!xmlCheckLanguageID(internal_val)) {
7873	xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
7874	"Malformed value for xml:lang : %s\n",
7875	internal_val, NULL);
7876	}
7877	}
7878
7879	/*
7880	* Check that xml:space conforms to the specification
7881	*/
7882	if (xmlStrEqual(name, BAD_CAST "space")) {
7883	internal_val = xmlStrndup(val, *len);
7884	if (xmlStrEqual(internal_val, BAD_CAST "default"))
7885	*(ctxt->space) = 0;
7886	else if (xmlStrEqual(internal_val, BAD_CAST "preserve"))
7887	*(ctxt->space) = 1;
7888	else {
7889	xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
7890	"Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
7891	internal_val, NULL);
7892	}
7893	}
7894	if (internal_val) {
7895	xmlFree(internal_val);
7896	}
7897	}
7898
7899	*value = val;
7900	return(name);
7901	}
7902
7903	/**
7904	* xmlParseStartTag2:
7905	* @ctxt: an XML parser context
7906	*
7907	* parse a start of tag either for rule element or
7908	* EmptyElement. In both case we don't parse the tag closing chars.
7909	* This routine is called when running SAX2 parsing
7910	*
7911	* [40] STag ::= '<' Name (S Attribute)* S? '>'
7912	*
7913	* [ WFC: Unique Att Spec ]
7914	* No attribute name may appear more than once in the same start-tag or
7915	* empty-element tag.
7916	*
7917	* [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
7918	*
7919	* [ WFC: Unique Att Spec ]
7920	* No attribute name may appear more than once in the same start-tag or
7921	* empty-element tag.
7922	*
7923	* With namespace:
7924	*
7925	* [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
7926	*
7927	* [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
7928	*
7929	* Returns the element name parsed
7930	*/
7931
7932	static const xmlChar *
7933	xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref,
7934	const xmlChar *URI, int tlen) {
7935	const xmlChar *localname;
7936	const xmlChar *prefix;
7937	const xmlChar *attname;
7938	const xmlChar *aprefix;
7939	const xmlChar *nsname;
7940	xmlChar *attvalue;
7941	const xmlChar **atts = ctxt->atts;
7942	int maxatts = ctxt->maxatts;
7943	int nratts, nbatts, nbdef;
7944	int i, j, nbNs, attval, oldline, oldcol;
7945	const xmlChar *base;
7946	unsigned long cur;
7947	int nsNr = ctxt->nsNr;
7948
7949	if (RAW != '<') return(NULL);
7950	NEXT1;
7951
7952	/*
7953	* NOTE: it is crucial with the SAX2 API to never call SHRINK beyond that
7954	* point since the attribute values may be stored as pointers to
7955	* the buffer and calling SHRINK would destroy them !
7956	* The Shrinking is only possible once the full set of attribute
7957	* callbacks have been done.
7958	*/
7959	reparse:
7960	SHRINK;
7961	base = ctxt->input->base;
7962	cur = ctxt->input->cur - ctxt->input->base;
7963	oldline = ctxt->input->line;
7964	oldcol = ctxt->input->col;
7965	nbatts = 0;
7966	nratts = 0;
7967	nbdef = 0;
7968	nbNs = 0;
7969	attval = 0;
7970	/* Forget any namespaces added during an earlier parse of this element. */
7971	ctxt->nsNr = nsNr;
7972
7973	localname = xmlParseQName(ctxt, &prefix);
7974	if (localname == NULL) {
7975	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7976	"StartTag: invalid element name\n");
7977	return(NULL);
7978	}
7979	*tlen = ctxt->input->cur - ctxt->input->base - cur;
7980
7981	/*
7982	* Now parse the attributes, it ends up with the ending
7983	*
7984	* (S Attribute)* S?
7985	*/
7986	SKIP_BLANKS;
7987	GROW;
7988	if (ctxt->input->base != base) goto base_changed;
7989
7990	while ((RAW != '>') &&
7991	((RAW != '/') \|\| (NXT(1) != '>')) &&
7992	(IS_BYTE_CHAR(RAW))) {
7993	const xmlChar *q = CUR_PTR;
7994	unsigned int cons = ctxt->input->consumed;
7995	int len = -1, alloc = 0;
7996
7997	attname = xmlParseAttribute2(ctxt, prefix, localname,
7998	&aprefix, &attvalue, &len, &alloc);
7999	if (ctxt->input->base != base) {
8000	if ((attvalue != NULL) && (alloc != 0))
8001	xmlFree(attvalue);
8002	attvalue = NULL;
8003	goto base_changed;
8004	}
8005	if ((attname != NULL) && (attvalue != NULL)) {
8006	if (len < 0) len = xmlStrlen(attvalue);
8007	if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
8008	const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
8009	xmlURIPtr uri;
8010
8011	if (*URL != 0) {
8012	uri = xmlParseURI((const char *) URL);
8013	if (uri == NULL) {
8014	xmlWarningMsg(ctxt, XML_WAR_NS_URI,
8015	"xmlns: %s not a valid URI\n",
8016	URL, NULL);
8017	} else {
8018	if (uri->scheme == NULL) {
8019	xmlWarningMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
8020	"xmlns: URI %s is not absolute\n",
8021	URL, NULL);
8022	}
8023	xmlFreeURI(uri);
8024	}
8025	}
8026	/*
8027	* check that it's not a defined namespace
8028	*/
8029	for (j = 1;j <= nbNs;j++)
8030	if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
8031	break;
8032	if (j <= nbNs)
8033	xmlErrAttributeDup(ctxt, NULL, attname);
8034	else
8035	if (nsPush(ctxt, NULL, URL) > 0) nbNs++;
8036	if (alloc != 0) xmlFree(attvalue);
8037	SKIP_BLANKS;
8038	continue;
8039	}
8040	if (aprefix == ctxt->str_xmlns) {
8041	const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
8042	xmlURIPtr uri;
8043
8044	if (attname == ctxt->str_xml) {
8045	if (URL != ctxt->str_xml_ns) {
8046	xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
8047	"xml namespace prefix mapped to wrong URI\n",
8048	NULL, NULL, NULL);
8049	}
8050	/*
8051	* Do not keep a namespace definition node
8052	*/
8053	if (alloc != 0) xmlFree(attvalue);
8054	SKIP_BLANKS;
8055	continue;
8056	}
8057	uri = xmlParseURI((const char *) URL);
8058	if (uri == NULL) {
8059	xmlWarningMsg(ctxt, XML_WAR_NS_URI,
8060	"xmlns:%s: '%s' is not a valid URI\n",
8061	attname, URL);
8062	} else {
8063	if ((ctxt->pedantic) && (uri->scheme == NULL)) {
8064	xmlWarningMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
8065	"xmlns:%s: URI %s is not absolute\n",
8066	attname, URL);
8067	}
8068	xmlFreeURI(uri);
8069	}
8070
8071	/*
8072	* check that it's not a defined namespace
8073	*/
8074	for (j = 1;j <= nbNs;j++)
8075	if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
8076	break;
8077	if (j <= nbNs)
8078	xmlErrAttributeDup(ctxt, aprefix, attname);
8079	else
8080	if (nsPush(ctxt, attname, URL) > 0) nbNs++;
8081	if (alloc != 0) xmlFree(attvalue);
8082	SKIP_BLANKS;
8083	if (ctxt->input->base != base) goto base_changed;
8084	continue;
8085	}
8086
8087	/*
8088	* Add the pair to atts
8089	*/
8090	if ((atts == NULL) \|\| (nbatts + 5 > maxatts)) {
8091	if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
8092	if (attvalue[len] == 0)
8093	xmlFree(attvalue);
8094	goto failed;
8095	}
8096	maxatts = ctxt->maxatts;
8097	atts = ctxt->atts;
8098	}
8099	ctxt->attallocs[nratts++] = alloc;
8100	atts[nbatts++] = attname;
8101	atts[nbatts++] = aprefix;
8102	atts[nbatts++] = NULL; /* the URI will be fetched later */
8103	atts[nbatts++] = attvalue;
8104	attvalue += len;
8105	atts[nbatts++] = attvalue;
8106	/*
8107	* tag if some deallocation is needed
8108	*/
8109	if (alloc != 0) attval = 1;
8110	} else {
8111	if ((attvalue != NULL) && (attvalue[len] == 0))
8112	xmlFree(attvalue);
8113	}
8114
8115	failed:
8116
8117	GROW
8118	if (ctxt->input->base != base) goto base_changed;
8119	if ((RAW == '>') \|\| (((RAW == '/') && (NXT(1) == '>'))))
8120	break;
8121	if (!IS_BLANK_CH(RAW)) {
8122	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
8123	"attributes construct error\n");
8124	break;
8125	}
8126	SKIP_BLANKS;
8127	if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
8128	(attname == NULL) && (attvalue == NULL)) {
8129	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8130	"xmlParseStartTag: problem parsing attributes\n");
8131	break;
8132	}
8133	GROW;
8134	if (ctxt->input->base != base) goto base_changed;
8135	}
8136
8137	/*
8138	* The attributes defaulting
8139	*/
8140	if (ctxt->attsDefault != NULL) {
8141	xmlDefAttrsPtr defaults;
8142
8143	defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
8144	if (defaults != NULL) {
8145	for (i = 0;i < defaults->nbAttrs;i++) {
8146	attname = defaults->values[4 * i];
8147	aprefix = defaults->values[4 * i + 1];
8148
8149	/*
8150	* special work for namespaces defaulted defs
8151	*/
8152	if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
8153	/*
8154	* check that it's not a defined namespace
8155	*/
8156	for (j = 1;j <= nbNs;j++)
8157	if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
8158	break;
8159	if (j <= nbNs) continue;
8160
8161	nsname = xmlGetNamespace(ctxt, NULL);
8162	if (nsname != defaults->values[4 * i + 2]) {
8163	if (nsPush(ctxt, NULL,
8164	defaults->values[4 * i + 2]) > 0)
8165	nbNs++;
8166	}
8167	} else if (aprefix == ctxt->str_xmlns) {
8168	/*
8169	* check that it's not a defined namespace
8170	*/
8171	for (j = 1;j <= nbNs;j++)
8172	if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
8173	break;
8174	if (j <= nbNs) continue;
8175
8176	nsname = xmlGetNamespace(ctxt, attname);
8177	if (nsname != defaults->values[2]) {
8178	if (nsPush(ctxt, attname,
8179	defaults->values[4 * i + 2]) > 0)
8180	nbNs++;
8181	}
8182	} else {
8183	/*
8184	* check that it's not a defined attribute
8185	*/
8186	for (j = 0;j < nbatts;j+=5) {
8187	if ((attname == atts[j]) && (aprefix == atts[j+1]))
8188	break;
8189	}
8190	if (j < nbatts) continue;
8191
8192	if ((atts == NULL) \|\| (nbatts + 5 > maxatts)) {
8193	if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
8194	return(NULL);
8195	}
8196	maxatts = ctxt->maxatts;
8197	atts = ctxt->atts;
8198	}
8199	atts[nbatts++] = attname;
8200	atts[nbatts++] = aprefix;
8201	if (aprefix == NULL)
8202	atts[nbatts++] = NULL;
8203	else
8204	atts[nbatts++] = xmlGetNamespace(ctxt, aprefix);
8205	atts[nbatts++] = defaults->values[4 * i + 2];
8206	atts[nbatts++] = defaults->values[4 * i + 3];
8207	nbdef++;
8208	}
8209	}
8210	}
8211	}
8212
8213	/*
8214	* The attributes checkings
8215	*/
8216	for (i = 0; i < nbatts;i += 5) {
8217	/*
8218	* The default namespace does not apply to attribute names.
8219	*/
8220	if (atts[i + 1] != NULL) {
8221	nsname = xmlGetNamespace(ctxt, atts[i + 1]);
8222	if (nsname == NULL) {
8223	xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
8224	"Namespace prefix %s for %s on %s is not defined\n",
8225	atts[i + 1], atts[i], localname);
8226	}
8227	atts[i + 2] = nsname;
8228	} else
8229	nsname = NULL;
8230	/*
8231	* [ WFC: Unique Att Spec ]
8232	* No attribute name may appear more than once in the same
8233	* start-tag or empty-element tag.
8234	* As extended by the Namespace in XML REC.
8235	*/
8236	for (j = 0; j < i;j += 5) {
8237	if (atts[i] == atts[j]) {
8238	if (atts[i+1] == atts[j+1]) {
8239	xmlErrAttributeDup(ctxt, atts[i+1], atts[i]);
8240	break;
8241	}
8242	if ((nsname != NULL) && (atts[j + 2] == nsname)) {
8243	xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
8244	"Namespaced Attribute %s in '%s' redefined\n",
8245	atts[i], nsname, NULL);
8246	break;
8247	}
8248	}
8249	}
8250	}
8251
8252	nsname = xmlGetNamespace(ctxt, prefix);
8253	if ((prefix != NULL) && (nsname == NULL)) {
8254	xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
8255	"Namespace prefix %s on %s is not defined\n",
8256	prefix, localname, NULL);
8257	}
8258	*pref = prefix;
8259	*URI = nsname;
8260
8261	/*
8262	* SAX: Start of Element !
8263	*/
8264	if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
8265	(!ctxt->disableSAX)) {
8266	if (nbNs > 0)
8267	ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
8268	nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs],
8269	nbatts / 5, nbdef, atts);
8270	else
8271	ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
8272	nsname, 0, NULL, nbatts / 5, nbdef, atts);
8273	}
8274
8275	/*
8276	* Free up attribute allocated strings if needed
8277	*/
8278	if (attval != 0) {
8279	for (i = 3,j = 0; j < nratts;i += 5,j++)
8280	if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
8281	xmlFree((xmlChar *) atts[i]);
8282	}
8283
8284	return(localname);
8285
8286	base_changed:
8287	/*
8288	* the attribute strings are valid iif the base didn't changed
8289	*/
8290	if (attval != 0) {
8291	for (i = 3,j = 0; j < nratts;i += 5,j++)
8292	if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
8293	xmlFree((xmlChar *) atts[i]);
8294	}
8295	ctxt->input->cur = ctxt->input->base + cur;
8296	ctxt->input->line = oldline;
8297	ctxt->input->col = oldcol;
8298	if (ctxt->wellFormed == 1) {
8299	goto reparse;
8300	}
8301	return(NULL);
8302	}
8303
8304	/**
8305	* xmlParseEndTag2:
8306	* @ctxt: an XML parser context
8307	* @line: line of the start tag
8308	* @nsNr: number of namespaces on the start tag
8309	*
8310	* parse an end of tag
8311	*
8312	* [42] ETag ::= '</' Name S? '>'
8313	*
8314	* With namespace
8315	*
8316	* [NS 9] ETag ::= '</' QName S? '>'
8317	*/
8318
8319	static void
8320	xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix,
8321	const xmlChar *URI, int line, int nsNr, int tlen) {
8322	const xmlChar *name;
8323
8324	GROW;
8325	if ((RAW != '<') \|\| (NXT(1) != '/')) {
8326	xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL);
8327	return;
8328	}
8329	SKIP(2);
8330
8331	if ((tlen > 0) && (xmlStrncmp(ctxt->input->cur, ctxt->name, tlen) == 0)) {
8332	if (ctxt->input->cur[tlen] == '>') {
8333	ctxt->input->cur += tlen + 1;
8334	goto done;
8335	}
8336	ctxt->input->cur += tlen;
8337	name = (xmlChar*)1;
8338	} else {
8339	if (prefix == NULL)
8340	name = xmlParseNameAndCompare(ctxt, ctxt->name);
8341	else
8342	name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix);
8343	}
8344
8345	/*
8346	* We should definitely be at the ending "S? '>'" part
8347	*/
8348	GROW;
8349	SKIP_BLANKS;
8350	if ((!IS_BYTE_CHAR(RAW)) \|\| (RAW != '>')) {
8351	xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
8352	} else
8353	NEXT1;
8354
8355	/*
8356	* [ WFC: Element Type Match ]
8357	* The Name in an element's end-tag must match the element type in the
8358	* start-tag.
8359	*
8360	*/
8361	if (name != (xmlChar*)1) {
8362	if (name == NULL) name = BAD_CAST "unparseable";
8363	xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
8364	"Opening and ending tag mismatch: %s line %d and %s\n",
8365	ctxt->name, line, name);
8366	}
8367
8368	/*
8369	* SAX: End of Tag
8370	*/
8371	done:
8372	if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
8373	(!ctxt->disableSAX))
8374	ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI);
8375
8376	spacePop(ctxt);
8377	if (nsNr != 0)
8378	nsPop(ctxt, nsNr);
8379	return;
8380	}
8381
8382	/**
8383	* xmlParseCDSect:
8384	* @ctxt: an XML parser context
8385	*
8386	* Parse escaped pure raw content.
8387	*
8388	* [18] CDSect ::= CDStart CData CDEnd
8389	*
8390	* [19] CDStart ::= '<![CDATA['
8391	*
8392	* [20] Data ::= (Char* - (Char* ']]>' Char*))
8393	*
8394	* [21] CDEnd ::= ']]>'
8395	*/
8396	void
8397	xmlParseCDSect(xmlParserCtxtPtr ctxt) {
8398	xmlChar *buf = NULL;
8399	int len = 0;
8400	int size = XML_PARSER_BUFFER_SIZE;
8401	int r, rl;
8402	int s, sl;
8403	int cur, l;
8404	int count = 0;
8405
8406	/* Check 2.6.0 was NXT(0) not RAW */
8407	if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
8408	SKIP(9);
8409	} else
8410	return;
8411
8412	ctxt->instate = XML_PARSER_CDATA_SECTION;
8413	r = CUR_CHAR(rl);
8414	if (!IS_CHAR(r)) {
8415	xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
8416	ctxt->instate = XML_PARSER_CONTENT;
8417	return;
8418	}
8419	NEXTL(rl);
8420	s = CUR_CHAR(sl);
8421	if (!IS_CHAR(s)) {
8422	xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
8423	ctxt->instate = XML_PARSER_CONTENT;
8424	return;
8425	}
8426	NEXTL(sl);
8427	cur = CUR_CHAR(l);
8428	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
8429	if (buf == NULL) {
8430	xmlErrMemory(ctxt, NULL);
8431	return;
8432	}
8433	while (IS_CHAR(cur) &&
8434	((r != ']') \|\| (s != ']') \|\| (cur != '>'))) {
8435	if (len + 5 >= size) {
8436	xmlChar *tmp;
8437
8438	size *= 2;
8439	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
8440	if (tmp == NULL) {
8441	xmlFree(buf);
8442	xmlErrMemory(ctxt, NULL);
8443	return;
8444	}
8445	buf = tmp;
8446	}
8447	COPY_BUF(rl,buf,len,r);
8448	r = s;
8449	rl = sl;
8450	s = cur;
8451	sl = l;
8452	count++;
8453	if (count > 50) {
8454	GROW;
8455	count = 0;
8456	}
8457	NEXTL(l);
8458	cur = CUR_CHAR(l);
8459	}
8460	buf[len] = 0;
8461	ctxt->instate = XML_PARSER_CONTENT;
8462	if (cur != '>') {
8463	xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
8464	"CData section not finished\n%.50s\n", buf);
8465	xmlFree(buf);
8466	return;
8467	}
8468	NEXTL(l);
8469
8470	/*
8471	* OK the buffer is to be consumed as cdata.
8472	*/
8473	if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
8474	if (ctxt->sax->cdataBlock != NULL)
8475	ctxt->sax->cdataBlock(ctxt->userData, buf, len);
8476	else if (ctxt->sax->characters != NULL)
8477	ctxt->sax->characters(ctxt->userData, buf, len);
8478	}
8479	xmlFree(buf);
8480	}
8481
8482	/**
8483	* xmlParseContent:
8484	* @ctxt: an XML parser context
8485	*
8486	* Parse a content:
8487	*
8488	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
8489	*/
8490
8491	void
8492	xmlParseContent(xmlParserCtxtPtr ctxt) {
8493	GROW;
8494	while ((RAW != 0) &&
8495	((RAW != '<') \|\| (NXT(1) != '/')) &&
8496	(ctxt->instate != XML_PARSER_EOF)) {
8497	const xmlChar *test = CUR_PTR;
8498	unsigned int cons = ctxt->input->consumed;
8499	const xmlChar *cur = ctxt->input->cur;
8500
8501	/*
8502	* First case : a Processing Instruction.
8503	*/
8504	if ((*cur == '<') && (cur[1] == '?')) {
8505	xmlParsePI(ctxt);
8506	}
8507
8508	/*
8509	* Second case : a CDSection
8510	*/
8511	/* 2.6.0 test was cur not RAW /
8512	else if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
8513	xmlParseCDSect(ctxt);
8514	}
8515
8516	/*
8517	* Third case : a comment
8518	*/
8519	else if ((*cur == '<') && (NXT(1) == '!') &&
8520	(NXT(2) == '-') && (NXT(3) == '-')) {
8521	xmlParseComment(ctxt);
8522	ctxt->instate = XML_PARSER_CONTENT;
8523	}
8524
8525	/*
8526	* Fourth case : a sub-element.
8527	*/
8528	else if (*cur == '<') {
8529	xmlParseElement(ctxt);
8530	}
8531
8532	/*
8533	* Fifth case : a reference. If if has not been resolved,
8534	* parsing returns it's Name, create the node
8535	*/
8536
8537	else if (*cur == '&') {
8538	xmlParseReference(ctxt);
8539	}
8540
8541	/*
8542	* Last case, text. Note that References are handled directly.
8543	*/
8544	else {
8545	xmlParseCharData(ctxt, 0);
8546	}
8547
8548	GROW;
8549	/*
8550	* Pop-up of finished entities.
8551	*/
8552	while ((RAW == 0) && (ctxt->inputNr > 1))
8553	xmlPopInput(ctxt);
8554	SHRINK;
8555
8556	if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
8557	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8558	"detected an error in element content\n");
8559	ctxt->instate = XML_PARSER_EOF;
8560	break;
8561	}
8562	}
8563	}
8564
8565	/**
8566	* xmlParseElement:
8567	* @ctxt: an XML parser context
8568	*
8569	* parse an XML element, this is highly recursive
8570	*
8571	* [39] element ::= EmptyElemTag \| STag content ETag
8572	*
8573	* [ WFC: Element Type Match ]
8574	* The Name in an element's end-tag must match the element type in the
8575	* start-tag.
8576	*
8577	*/
8578
8579	void
8580	xmlParseElement(xmlParserCtxtPtr ctxt) {
8581	const xmlChar *name;
8582	const xmlChar *prefix;
8583	const xmlChar *URI;
8584	xmlParserNodeInfo node_info;
8585	int line, tlen;
8586	xmlNodePtr ret;
8587	int nsNr = ctxt->nsNr;
8588
8589	if ((unsigned int) ctxt->nameNr > xmlParserMaxDepth) {
8590	xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
8591	"Excessive depth in document: change xmlParserMaxDepth = %d\n",
8592	xmlParserMaxDepth);
8593	ctxt->instate = XML_PARSER_EOF;
8594	return;
8595	}
8596
8597	/* Capture start position */
8598	if (ctxt->record_info) {
8599	node_info.begin_pos = ctxt->input->consumed +
8600	(CUR_PTR - ctxt->input->base);
8601	node_info.begin_line = ctxt->input->line;
8602	}
8603
8604	if (ctxt->spaceNr == 0)
8605	spacePush(ctxt, -1);
8606	else if (*ctxt->space == -2)
8607	spacePush(ctxt, -1);
8608	else
8609	spacePush(ctxt, *ctxt->space);
8610
8611	line = ctxt->input->line;
8612	#ifdef LIBXML_SAX1_ENABLED
8613	if (ctxt->sax2)
8614	#endif /* LIBXML_SAX1_ENABLED */
8615	name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
8616	#ifdef LIBXML_SAX1_ENABLED
8617	else
8618	name = xmlParseStartTag(ctxt);
8619	#endif /* LIBXML_SAX1_ENABLED */
8620	if (name == NULL) {
8621	spacePop(ctxt);
8622	return;
8623	}
8624	namePush(ctxt, name);
8625	ret = ctxt->node;
8626
8627	#ifdef LIBXML_VALID_ENABLED
8628	/*
8629	* [ VC: Root Element Type ]
8630	* The Name in the document type declaration must match the element
8631	* type of the root element.
8632	*/
8633	if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
8634	ctxt->node && (ctxt->node == ctxt->myDoc->children))
8635	ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
8636	#endif /* LIBXML_VALID_ENABLED */
8637
8638	/*
8639	* Check for an Empty Element.
8640	*/
8641	if ((RAW == '/') && (NXT(1) == '>')) {
8642	SKIP(2);
8643	if (ctxt->sax2) {
8644	if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
8645	(!ctxt->disableSAX))
8646	ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
8647	#ifdef LIBXML_SAX1_ENABLED
8648	} else {
8649	if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
8650	(!ctxt->disableSAX))
8651	ctxt->sax->endElement(ctxt->userData, name);
8652	#endif /* LIBXML_SAX1_ENABLED */
8653	}
8654	namePop(ctxt);
8655	spacePop(ctxt);
8656	if (nsNr != ctxt->nsNr)
8657	nsPop(ctxt, ctxt->nsNr - nsNr);
8658	if ( ret != NULL && ctxt->record_info ) {
8659	node_info.end_pos = ctxt->input->consumed +
8660	(CUR_PTR - ctxt->input->base);
8661	node_info.end_line = ctxt->input->line;
8662	node_info.node = ret;
8663	xmlParserAddNodeInfo(ctxt, &node_info);
8664	}
8665	return;
8666	}
8667	if (RAW == '>') {
8668	NEXT1;
8669	} else {
8670	xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED,
8671	"Couldn't find end of Start Tag %s line %d\n",
8672	name, line, NULL);
8673
8674	/*
8675	* end of parsing of this node.
8676	*/
8677	nodePop(ctxt);
8678	namePop(ctxt);
8679	spacePop(ctxt);
8680	if (nsNr != ctxt->nsNr)
8681	nsPop(ctxt, ctxt->nsNr - nsNr);
8682
8683	/*
8684	* Capture end position and add node
8685	*/
8686	if ( ret != NULL && ctxt->record_info ) {
8687	node_info.end_pos = ctxt->input->consumed +
8688	(CUR_PTR - ctxt->input->base);
8689	node_info.end_line = ctxt->input->line;
8690	node_info.node = ret;
8691	xmlParserAddNodeInfo(ctxt, &node_info);
8692	}
8693	return;
8694	}
8695
8696	/*
8697	* Parse the content of the element:
8698	*/
8699	xmlParseContent(ctxt);
8700	if (!IS_BYTE_CHAR(RAW)) {
8701	xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
8702	"Premature end of data in tag %s line %d\n",
8703	name, line, NULL);
8704
8705	/*
8706	* end of parsing of this node.
8707	*/
8708	nodePop(ctxt);
8709	namePop(ctxt);
8710	spacePop(ctxt);
8711	if (nsNr != ctxt->nsNr)
8712	nsPop(ctxt, ctxt->nsNr - nsNr);
8713	return;
8714	}
8715
8716	/*
8717	* parse the end of tag: '</' should be here.
8718	*/
8719	if (ctxt->sax2) {
8720	xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr, tlen);
8721	namePop(ctxt);
8722	}
8723	#ifdef LIBXML_SAX1_ENABLED
8724	else
8725	xmlParseEndTag1(ctxt, line);
8726	#endif /* LIBXML_SAX1_ENABLED */
8727
8728	/*
8729	* Capture end position and add node
8730	*/
8731	if ( ret != NULL && ctxt->record_info ) {
8732	node_info.end_pos = ctxt->input->consumed +
8733	(CUR_PTR - ctxt->input->base);
8734	node_info.end_line = ctxt->input->line;
8735	node_info.node = ret;
8736	xmlParserAddNodeInfo(ctxt, &node_info);
8737	}
8738	}
8739
8740	/**
8741	* xmlParseVersionNum:
8742	* @ctxt: an XML parser context
8743	*
8744	* parse the XML version value.
8745	*
8746	* [26] VersionNum ::= ([a-zA-Z0-9_.:] \| '-')+
8747	*
8748	* Returns the string giving the XML version number, or NULL
8749	*/
8750	xmlChar *
8751	xmlParseVersionNum(xmlParserCtxtPtr ctxt) {
8752	xmlChar *buf = NULL;
8753	int len = 0;
8754	int size = 10;
8755	xmlChar cur;
8756
8757	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
8758	if (buf == NULL) {
8759	xmlErrMemory(ctxt, NULL);
8760	return(NULL);
8761	}
8762	cur = CUR;
8763	while (((cur >= 'a') && (cur <= 'z')) \|\|
8764	((cur >= 'A') && (cur <= 'Z')) \|\|
8765	((cur >= '0') && (cur <= '9')) \|\|
8766	(cur == '_') \|\| (cur == '.') \|\|
8767	(cur == ':') \|\| (cur == '-')) {
8768	if (len + 1 >= size) {
8769	xmlChar *tmp;
8770
8771	size *= 2;
8772	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
8773	if (tmp == NULL) {
8774	xmlErrMemory(ctxt, NULL);
8775	return(NULL);
8776	}
8777	buf = tmp;
8778	}
8779	buf[len++] = cur;
8780	NEXT;
8781	cur=CUR;
8782	}
8783	buf[len] = 0;
8784	return(buf);
8785	}
8786
8787	/**
8788	* xmlParseVersionInfo:
8789	* @ctxt: an XML parser context
8790	*
8791	* parse the XML version.
8792	*
8793	* [24] VersionInfo ::= S 'version' Eq (' VersionNum ' \| " VersionNum ")
8794	*
8795	* [25] Eq ::= S? '=' S?
8796	*
8797	* Returns the version string, e.g. "1.0"
8798	*/
8799
8800	xmlChar *
8801	xmlParseVersionInfo(xmlParserCtxtPtr ctxt) {
8802	xmlChar *version = NULL;
8803
8804	if (CMP7(CUR_PTR, 'v', 'e', 'r', 's', 'i', 'o', 'n')) {
8805	SKIP(7);
8806	SKIP_BLANKS;
8807	if (RAW != '=') {
8808	xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
8809	return(NULL);
8810	}
8811	NEXT;
8812	SKIP_BLANKS;
8813	if (RAW == '"') {
8814	NEXT;
8815	version = xmlParseVersionNum(ctxt);
8816	if (RAW != '"') {
8817	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
8818	} else
8819	NEXT;
8820	} else if (RAW == '\''){
8821	NEXT;
8822	version = xmlParseVersionNum(ctxt);
8823	if (RAW != '\'') {
8824	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
8825	} else
8826	NEXT;
8827	} else {
8828	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
8829	}
8830	}
8831	return(version);
8832	}
8833
8834	/**
8835	* xmlParseEncName:
8836	* @ctxt: an XML parser context
8837	*
8838	* parse the XML encoding name
8839	*
8840	* [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] \| '-')*
8841	*
8842	* Returns the encoding name value or NULL
8843	*/
8844	xmlChar *
8845	xmlParseEncName(xmlParserCtxtPtr ctxt) {
8846	xmlChar *buf = NULL;
8847	int len = 0;
8848	int size = 10;
8849	xmlChar cur;
8850
8851	cur = CUR;
8852	if (((cur >= 'a') && (cur <= 'z')) \|\|
8853	((cur >= 'A') && (cur <= 'Z'))) {
8854	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
8855	if (buf == NULL) {
8856	xmlErrMemory(ctxt, NULL);
8857	return(NULL);
8858	}
8859
8860	buf[len++] = cur;
8861	NEXT;
8862	cur = CUR;
8863	while (((cur >= 'a') && (cur <= 'z')) \|\|
8864	((cur >= 'A') && (cur <= 'Z')) \|\|
8865	((cur >= '0') && (cur <= '9')) \|\|
8866	(cur == '.') \|\| (cur == '_') \|\|
8867	(cur == '-')) {
8868	if (len + 1 >= size) {
8869	xmlChar *tmp;
8870
8871	size *= 2;
8872	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
8873	if (tmp == NULL) {
8874	xmlErrMemory(ctxt, NULL);
8875	xmlFree(buf);
8876	return(NULL);
8877	}
8878	buf = tmp;
8879	}
8880	buf[len++] = cur;
8881	NEXT;
8882	cur = CUR;
8883	if (cur == 0) {
8884	SHRINK;
8885	GROW;
8886	cur = CUR;
8887	}
8888	}
8889	buf[len] = 0;
8890	} else {
8891	xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
8892	}
8893	return(buf);
8894	}
8895
8896	/**
8897	* xmlParseEncodingDecl:
8898	* @ctxt: an XML parser context
8899	*
8900	* parse the XML encoding declaration
8901	*
8902	* [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' \| "'" EncName "'")
8903	*
8904	* this setups the conversion filters.
8905	*
8906	* Returns the encoding value or NULL
8907	*/
8908
8909	const xmlChar *
8910	xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) {
8911	xmlChar *encoding = NULL;
8912
8913	SKIP_BLANKS;
8914	if (CMP8(CUR_PTR, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g')) {
8915	SKIP(8);
8916	SKIP_BLANKS;
8917	if (RAW != '=') {
8918	xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
8919	return(NULL);
8920	}
8921	NEXT;
8922	SKIP_BLANKS;
8923	if (RAW == '"') {
8924	NEXT;
8925	encoding = xmlParseEncName(ctxt);
8926	if (RAW != '"') {
8927	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
8928	} else
8929	NEXT;
8930	} else if (RAW == '\''){
8931	NEXT;
8932	encoding = xmlParseEncName(ctxt);
8933	if (RAW != '\'') {
8934	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
8935	} else
8936	NEXT;
8937	} else {
8938	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
8939	}
8940	/*
8941	* UTF-16 encoding stwich has already taken place at this stage,
8942	* more over the little-endian/big-endian selection is already done
8943	*/
8944	if ((encoding != NULL) &&
8945	((!xmlStrcasecmp(encoding, BAD_CAST "UTF-16")) \|\|
8946	(!xmlStrcasecmp(encoding, BAD_CAST "UTF16")))) {
8947	if (ctxt->encoding != NULL)
8948	xmlFree((xmlChar *) ctxt->encoding);
8949	ctxt->encoding = encoding;
8950	}
8951	/*
8952	* UTF-8 encoding is handled natively
8953	*/
8954	else if ((encoding != NULL) &&
8955	((!xmlStrcasecmp(encoding, BAD_CAST "UTF-8")) \|\|
8956	(!xmlStrcasecmp(encoding, BAD_CAST "UTF8")))) {
8957	if (ctxt->encoding != NULL)
8958	xmlFree((xmlChar *) ctxt->encoding);
8959	ctxt->encoding = encoding;
8960	}
8961	else if (encoding != NULL) {
8962	xmlCharEncodingHandlerPtr handler;
8963
8964	if (ctxt->input->encoding != NULL)
8965	xmlFree((xmlChar *) ctxt->input->encoding);
8966	ctxt->input->encoding = encoding;
8967
8968	handler = xmlFindCharEncodingHandler((const char *) encoding);
8969	if (handler != NULL) {
8970	xmlSwitchToEncoding(ctxt, handler);
8971	} else {
8972	xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
8973	"Unsupported encoding %s\n", encoding);
8974	return(NULL);
8975	}
8976	}
8977	}
8978	return(encoding);
8979	}
8980
8981	/**
8982	* xmlParseSDDecl:
8983	* @ctxt: an XML parser context
8984	*
8985	* parse the XML standalone declaration
8986	*
8987	* [32] SDDecl ::= S 'standalone' Eq
8988	* (("'" ('yes' \| 'no') "'") \| ('"' ('yes' \| 'no')'"'))
8989	*
8990	* [ VC: Standalone Document Declaration ]
8991	* TODO The standalone document declaration must have the value "no"
8992	* if any external markup declarations contain declarations of:
8993	* - attributes with default values, if elements to which these
8994	* attributes apply appear in the document without specifications
8995	* of values for these attributes, or
8996	* - entities (other than amp, lt, gt, apos, quot), if references
8997	* to those entities appear in the document, or
8998	* - attributes with values subject to normalization, where the
8999	* attribute appears in the document with a value which will change
9000	* as a result of normalization, or
9001	* - element types with element content, if white space occurs directly
9002	* within any instance of those types.
9003	*
9004	* Returns:
9005	* 1 if standalone="yes"
9006	* 0 if standalone="no"
9007	* -2 if standalone attribute is missing or invalid
9008	* (A standalone value of -2 means that the XML declaration was found,
9009	* but no value was specified for the standalone attribute).
9010	*/
9011
9012	int
9013	xmlParseSDDecl(xmlParserCtxtPtr ctxt) {
9014	int standalone = -2;
9015
9016	SKIP_BLANKS;
9017	if (CMP10(CUR_PTR, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o', 'n', 'e')) {
9018	SKIP(10);
9019	SKIP_BLANKS;
9020	if (RAW != '=') {
9021	xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
9022	return(standalone);
9023	}
9024	NEXT;
9025	SKIP_BLANKS;
9026	if (RAW == '\''){
9027	NEXT;
9028	if ((RAW == 'n') && (NXT(1) == 'o')) {
9029	standalone = 0;
9030	SKIP(2);
9031	} else if ((RAW == 'y') && (NXT(1) == 'e') &&
9032	(NXT(2) == 's')) {
9033	standalone = 1;
9034	SKIP(3);
9035	} else {
9036	xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
9037	}
9038	if (RAW != '\'') {
9039	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9040	} else
9041	NEXT;
9042	} else if (RAW == '"'){
9043	NEXT;
9044	if ((RAW == 'n') && (NXT(1) == 'o')) {
9045	standalone = 0;
9046	SKIP(2);
9047	} else if ((RAW == 'y') && (NXT(1) == 'e') &&
9048	(NXT(2) == 's')) {
9049	standalone = 1;
9050	SKIP(3);
9051	} else {
9052	xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
9053	}
9054	if (RAW != '"') {
9055	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9056	} else
9057	NEXT;
9058	} else {
9059	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
9060	}
9061	}
9062	return(standalone);
9063	}
9064
9065	/**
9066	* xmlParseXMLDecl:
9067	* @ctxt: an XML parser context
9068	*
9069	* parse an XML declaration header
9070	*
9071	* [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
9072	*/
9073
9074	void
9075	xmlParseXMLDecl(xmlParserCtxtPtr ctxt) {
9076	xmlChar *version;
9077
9078	/*
9079	* This value for standalone indicates that the document has an
9080	* XML declaration but it does not have a standalone attribute.
9081	* It will be overwritten later if a standalone attribute is found.
9082	*/
9083	ctxt->input->standalone = -2;
9084
9085	/*
9086	* We know that '<?xml' is here.
9087	*/
9088	SKIP(5);
9089
9090	if (!IS_BLANK_CH(RAW)) {
9091	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9092	"Blank needed after '<?xml'\n");
9093	}
9094	SKIP_BLANKS;
9095
9096	/*
9097	* We must have the VersionInfo here.
9098	*/
9099	version = xmlParseVersionInfo(ctxt);
9100	if (version == NULL) {
9101	xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
9102	} else {
9103	if (!xmlStrEqual(version, (const xmlChar *) XML_DEFAULT_VERSION)) {
9104	/*
9105	* TODO: Blueberry should be detected here
9106	*/
9107	xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
9108	"Unsupported version '%s'\n",
9109	version, NULL);
9110	}
9111	if (ctxt->version != NULL)
9112	xmlFree((void *) ctxt->version);
9113	ctxt->version = version;
9114	}
9115
9116	/*
9117	* We may have the encoding declaration
9118	*/
9119	if (!IS_BLANK_CH(RAW)) {
9120	if ((RAW == '?') && (NXT(1) == '>')) {
9121	SKIP(2);
9122	return;
9123	}
9124	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
9125	}
9126	xmlParseEncodingDecl(ctxt);
9127	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
9128	/*
9129	* The XML REC instructs us to stop parsing right here
9130	*/
9131	return;
9132	}
9133
9134	/*
9135	* We may have the standalone status.
9136	*/
9137	if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
9138	if ((RAW == '?') && (NXT(1) == '>')) {
9139	SKIP(2);
9140	return;
9141	}
9142	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
9143	}
9144	SKIP_BLANKS;
9145	ctxt->input->standalone = xmlParseSDDecl(ctxt);
9146
9147	SKIP_BLANKS;
9148	if ((RAW == '?') && (NXT(1) == '>')) {
9149	SKIP(2);
9150	} else if (RAW == '>') {
9151	/* Deprecated old WD ... */
9152	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
9153	NEXT;
9154	} else {
9155	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
9156	MOVETO_ENDTAG(CUR_PTR);
9157	NEXT;
9158	}
9159	}
9160
9161	/**
9162	* xmlParseMisc:
9163	* @ctxt: an XML parser context
9164	*
9165	* parse an XML Misc* optional field.
9166	*
9167	* [27] Misc ::= Comment \| PI \| S
9168	*/
9169
9170	void
9171	xmlParseMisc(xmlParserCtxtPtr ctxt) {
9172	while (((RAW == '<') && (NXT(1) == '?')) \|\|
9173	(CMP4(CUR_PTR, '<', '!', '-', '-')) \|\|
9174	IS_BLANK_CH(CUR)) {
9175	if ((RAW == '<') && (NXT(1) == '?')) {
9176	xmlParsePI(ctxt);
9177	} else if (IS_BLANK_CH(CUR)) {
9178	NEXT;
9179	} else
9180	xmlParseComment(ctxt);
9181	}
9182	}
9183
9184	/**
9185	* xmlParseDocument:
9186	* @ctxt: an XML parser context
9187	*
9188	* parse an XML document (and build a tree if using the standard SAX
9189	* interface).
9190	*
9191	* [1] document ::= prolog element Misc*
9192	*
9193	* [22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)?
9194	*
9195	* Returns 0, -1 in case of error. the parser context is augmented
9196	* as a result of the parsing.
9197	*/
9198
9199	int
9200	xmlParseDocument(xmlParserCtxtPtr ctxt) {
9201	xmlChar start[4];
9202	xmlCharEncoding enc;
9203
9204	xmlInitParser();
9205
9206	if ((ctxt == NULL) \|\| (ctxt->input == NULL))
9207	return(-1);
9208
9209	GROW;
9210
9211	/*
9212	* SAX: detecting the level.
9213	*/
9214	xmlDetectSAX2(ctxt);
9215
9216	/*
9217	* SAX: beginning of the document processing.
9218	*/
9219	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9220	ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
9221
9222	if ((ctxt->encoding == (const xmlChar *)XML_CHAR_ENCODING_NONE) &&
9223	((ctxt->input->end - ctxt->input->cur) >= 4)) {
9224	/*
9225	* Get the 4 first bytes and decode the charset
9226	* if enc != XML_CHAR_ENCODING_NONE
9227	* plug some encoding conversion routines.
9228	*/
9229	start[0] = RAW;
9230	start[1] = NXT(1);
9231	start[2] = NXT(2);
9232	start[3] = NXT(3);
9233	enc = xmlDetectCharEncoding(&start[0], 4);
9234	if (enc != XML_CHAR_ENCODING_NONE) {
9235	xmlSwitchEncoding(ctxt, enc);
9236	}
9237	}
9238
9239
9240	if (CUR == 0) {
9241	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
9242	}
9243
9244	/*
9245	* Check for the XMLDecl in the Prolog.
9246	*/
9247	GROW;
9248	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
9249
9250	/*
9251	* Note that we will switch encoding on the fly.
9252	*/
9253	xmlParseXMLDecl(ctxt);
9254	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
9255	/*
9256	* The XML REC instructs us to stop parsing right here
9257	*/
9258	return(-1);
9259	}
9260	ctxt->standalone = ctxt->input->standalone;
9261	SKIP_BLANKS;
9262	} else {
9263	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
9264	}
9265	if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
9266	ctxt->sax->startDocument(ctxt->userData);
9267
9268	/*
9269	* The Misc part of the Prolog
9270	*/
9271	GROW;
9272	xmlParseMisc(ctxt);
9273
9274	/*
9275	* Then possibly doc type declaration(s) and more Misc
9276	* (doctypedecl Misc*)?
9277	*/
9278	GROW;
9279	if (CMP9(CUR_PTR, '<', '!', 'D', 'O', 'C', 'T', 'Y', 'P', 'E')) {
9280
9281	ctxt->inSubset = 1;
9282	xmlParseDocTypeDecl(ctxt);
9283	if (RAW == '[') {
9284	ctxt->instate = XML_PARSER_DTD;
9285	xmlParseInternalSubset(ctxt);
9286	}
9287
9288	/*
9289	* Create and update the external subset.
9290	*/
9291	ctxt->inSubset = 2;
9292	if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) &&
9293	(!ctxt->disableSAX))
9294	ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
9295	ctxt->extSubSystem, ctxt->extSubURI);
9296	ctxt->inSubset = 0;
9297
9298
9299	ctxt->instate = XML_PARSER_PROLOG;
9300	xmlParseMisc(ctxt);
9301	}
9302
9303	/*
9304	* Time to start parsing the tree itself
9305	*/
9306	GROW;
9307	if (RAW != '<') {
9308	xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
9309	"Start tag expected, '<' not found\n");
9310	} else {
9311	ctxt->instate = XML_PARSER_CONTENT;
9312	xmlParseElement(ctxt);
9313	ctxt->instate = XML_PARSER_EPILOG;
9314
9315
9316	/*
9317	* The Misc part at the end
9318	*/
9319	xmlParseMisc(ctxt);
9320
9321	if (RAW != 0) {
9322	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
9323	}
9324	ctxt->instate = XML_PARSER_EOF;
9325	}
9326
9327	/*
9328	* SAX: end of the document processing.
9329	*/
9330	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9331	ctxt->sax->endDocument(ctxt->userData);
9332
9333	/*
9334	* Remove locally kept entity definitions if the tree was not built
9335	*/
9336	if ((ctxt->myDoc != NULL) &&
9337	(xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
9338	xmlFreeDoc(ctxt->myDoc);
9339	ctxt->myDoc = NULL;
9340	}
9341
9342	if (! ctxt->wellFormed) {
9343	ctxt->valid = 0;
9344	return(-1);
9345	}
9346	return(0);
9347	}
9348
9349	/**
9350	* xmlParseExtParsedEnt:
9351	* @ctxt: an XML parser context
9352	*
9353	* parse a general parsed entity
9354	* An external general parsed entity is well-formed if it matches the
9355	* production labeled extParsedEnt.
9356	*
9357	* [78] extParsedEnt ::= TextDecl? content
9358	*
9359	* Returns 0, -1 in case of error. the parser context is augmented
9360	* as a result of the parsing.
9361	*/
9362
9363	int
9364	xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) {
9365	xmlChar start[4];
9366	xmlCharEncoding enc;
9367
9368	if ((ctxt == NULL) \|\| (ctxt->input == NULL))
9369	return(-1);
9370
9371	xmlDefaultSAXHandlerInit();
9372
9373	xmlDetectSAX2(ctxt);
9374
9375	GROW;
9376
9377	/*
9378	* SAX: beginning of the document processing.
9379	*/
9380	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9381	ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
9382
9383	/*
9384	* Get the 4 first bytes and decode the charset
9385	* if enc != XML_CHAR_ENCODING_NONE
9386	* plug some encoding conversion routines.
9387	*/
9388	if ((ctxt->input->end - ctxt->input->cur) >= 4) {
9389	start[0] = RAW;
9390	start[1] = NXT(1);
9391	start[2] = NXT(2);
9392	start[3] = NXT(3);
9393	enc = xmlDetectCharEncoding(start, 4);
9394	if (enc != XML_CHAR_ENCODING_NONE) {
9395	xmlSwitchEncoding(ctxt, enc);
9396	}
9397	}
9398
9399
9400	if (CUR == 0) {
9401	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
9402	}
9403
9404	/*
9405	* Check for the XMLDecl in the Prolog.
9406	*/
9407	GROW;
9408	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
9409
9410	/*
9411	* Note that we will switch encoding on the fly.
9412	*/
9413	xmlParseXMLDecl(ctxt);
9414	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
9415	/*
9416	* The XML REC instructs us to stop parsing right here
9417	*/
9418	return(-1);
9419	}
9420	SKIP_BLANKS;
9421	} else {
9422	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
9423	}
9424	if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
9425	ctxt->sax->startDocument(ctxt->userData);
9426
9427	/*
9428	* Doing validity checking on chunk doesn't make sense
9429	*/
9430	ctxt->instate = XML_PARSER_CONTENT;
9431	ctxt->validate = 0;
9432	ctxt->loadsubset = 0;
9433	ctxt->depth = 0;
9434
9435	xmlParseContent(ctxt);
9436
9437	if ((RAW == '<') && (NXT(1) == '/')) {
9438	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
9439	} else if (RAW != 0) {
9440	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
9441	}
9442
9443	/*
9444	* SAX: end of the document processing.
9445	*/
9446	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9447	ctxt->sax->endDocument(ctxt->userData);
9448
9449	if (! ctxt->wellFormed) return(-1);
9450	return(0);
9451	}
9452
9453	#ifdef LIBXML_PUSH_ENABLED
9454	/************************************************************************
9455	* *
9456	* Progressive parsing interfaces *
9457	* *
9458	************************************************************************/
9459
9460	/**
9461	* xmlParseLookupSequence:
9462	* @ctxt: an XML parser context
9463	* @first: the first char to lookup
9464	* @next: the next char to lookup or zero
9465	* @third: the next char to lookup or zero
9466	*
9467	* Try to find if a sequence (first, next, third) or just (first next) or
9468	* (first) is available in the input stream.
9469	* This function has a side effect of (possibly) incrementing ctxt->checkIndex
9470	* to avoid rescanning sequences of bytes, it DOES change the state of the
9471	* parser, do not use liberally.
9472	*
9473	* Returns the index to the current parsing point if the full sequence
9474	* is available, -1 otherwise.
9475	*/
9476	static int
9477	xmlParseLookupSequence(xmlParserCtxtPtr ctxt, xmlChar first,
9478	xmlChar next, xmlChar third) {
9479	int base, len;
9480	xmlParserInputPtr in;
9481	const xmlChar *buf;
9482
9483	in = ctxt->input;
9484	if (in == NULL) return(-1);
9485	base = in->cur - in->base;
9486	if (base < 0) return(-1);
9487	if (ctxt->checkIndex > base)
9488	base = ctxt->checkIndex;
9489	if (in->buf == NULL) {
9490	buf = in->base;
9491	len = in->length;
9492	} else {
9493	buf = in->buf->buffer->content;
9494	len = in->buf->buffer->use;
9495	}
9496	/* take into account the sequence length */
9497	if (third) len -= 2;
9498	else if (next) len --;
9499	for (;base < len;base++) {
9500	if (buf[base] == first) {
9501	if (third != 0) {
9502	if ((buf[base + 1] != next) \|\|
9503	(buf[base + 2] != third)) continue;
9504	} else if (next != 0) {
9505	if (buf[base + 1] != next) continue;
9506	}
9507	ctxt->checkIndex = 0;
9508	#ifdef DEBUG_PUSH
9509	if (next == 0)
9510	xmlGenericError(xmlGenericErrorContext,
9511	"PP: lookup '%c' found at %d\n",
9512	first, base);
9513	else if (third == 0)
9514	xmlGenericError(xmlGenericErrorContext,
9515	"PP: lookup '%c%c' found at %d\n",
9516	first, next, base);
9517	else
9518	xmlGenericError(xmlGenericErrorContext,
9519	"PP: lookup '%c%c%c' found at %d\n",
9520	first, next, third, base);
9521	#endif
9522	return(base - (in->cur - in->base));
9523	}
9524	}
9525	ctxt->checkIndex = base;
9526	#ifdef DEBUG_PUSH
9527	if (next == 0)
9528	xmlGenericError(xmlGenericErrorContext,
9529	"PP: lookup '%c' failed\n", first);
9530	else if (third == 0)
9531	xmlGenericError(xmlGenericErrorContext,
9532	"PP: lookup '%c%c' failed\n", first, next);
9533	else
9534	xmlGenericError(xmlGenericErrorContext,
9535	"PP: lookup '%c%c%c' failed\n", first, next, third);
9536	#endif
9537	return(-1);
9538	}
9539
9540	/**
9541	* xmlParseGetLasts:
9542	* @ctxt: an XML parser context
9543	* @lastlt: pointer to store the last '<' from the input
9544	* @lastgt: pointer to store the last '>' from the input
9545	*
9546	* Lookup the last < and > in the current chunk
9547	*/
9548	static void
9549	xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt,
9550	const xmlChar **lastgt) {
9551	const xmlChar *tmp;
9552
9553	if ((ctxt == NULL) \|\| (lastlt == NULL) \|\| (lastgt == NULL)) {
9554	xmlGenericError(xmlGenericErrorContext,
9555	"Internal error: xmlParseGetLasts\n");
9556	return;
9557	}
9558	if ((ctxt->progressive != 0) && (ctxt->inputNr == 1)) {
9559	tmp = ctxt->input->end;
9560	tmp--;
9561	while ((tmp >= ctxt->input->base) && (*tmp != '<')) tmp--;
9562	if (tmp < ctxt->input->base) {
9563	*lastlt = NULL;
9564	*lastgt = NULL;
9565	} else {
9566	*lastlt = tmp;
9567	tmp++;
9568	while ((tmp < ctxt->input->end) && (*tmp != '>')) {
9569	if (*tmp == '\'') {
9570	tmp++;
9571	while ((tmp < ctxt->input->end) && (*tmp != '\'')) tmp++;
9572	if (tmp < ctxt->input->end) tmp++;
9573	} else if (*tmp == '"') {
9574	tmp++;
9575	while ((tmp < ctxt->input->end) && (*tmp != '"')) tmp++;
9576	if (tmp < ctxt->input->end) tmp++;
9577	} else
9578	tmp++;
9579	}
9580	if (tmp < ctxt->input->end)
9581	*lastgt = tmp;
9582	else {
9583	tmp = *lastlt;
9584	tmp--;
9585	while ((tmp >= ctxt->input->base) && (*tmp != '>')) tmp--;
9586	if (tmp >= ctxt->input->base)
9587	*lastgt = tmp;
9588	else
9589	*lastgt = NULL;
9590	}
9591	}
9592	} else {
9593	*lastlt = NULL;
9594	*lastgt = NULL;
9595	}
9596	}
9597	/**
9598	* xmlCheckCdataPush:
9599	* @cur: pointer to the bock of characters
9600	* @len: length of the block in bytes
9601	*
9602	* Check that the block of characters is okay as SCdata content [20]
9603	*
9604	* Returns the number of bytes to pass if okay, a negative index where an
9605	* UTF-8 error occured otherwise
9606	*/
9607	static int
9608	xmlCheckCdataPush(const xmlChar *utf, int len) {
9609	int ix;
9610	unsigned char c;
9611	int codepoint;
9612
9613	if ((utf == NULL) \|\| (len <= 0))
9614	return(0);
9615
9616	for (ix = 0; ix < len;) { /* string is 0-terminated */
9617	c = utf[ix];
9618	if ((c & 0x80) == 0x00) { /* 1-byte code, starts with 10 */
9619	if (c >= 0x20)
9620	ix++;
9621	else if ((c == 0xA) \|\| (c == 0xD) \|\| (c == 0x9))
9622	ix++;
9623	else
9624	return(-ix);
9625	} else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */
9626	if (ix + 2 > len) return(ix);
9627	if ((utf[ix+1] & 0xc0 ) != 0x80)
9628	return(-ix);
9629	codepoint = (utf[ix] & 0x1f) << 6;
9630	codepoint \|= utf[ix+1] & 0x3f;
9631	if (!xmlIsCharQ(codepoint))
9632	return(-ix);
9633	ix += 2;
9634	} else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */
9635	if (ix + 3 > len) return(ix);
9636	if (((utf[ix+1] & 0xc0) != 0x80) \|\|
9637	((utf[ix+2] & 0xc0) != 0x80))
9638	return(-ix);
9639	codepoint = (utf[ix] & 0xf) << 12;
9640	codepoint \|= (utf[ix+1] & 0x3f) << 6;
9641	codepoint \|= utf[ix+2] & 0x3f;
9642	if (!xmlIsCharQ(codepoint))
9643	return(-ix);
9644	ix += 3;
9645	} else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */
9646	if (ix + 4 > len) return(ix);
9647	if (((utf[ix+1] & 0xc0) != 0x80) \|\|
9648	((utf[ix+2] & 0xc0) != 0x80) \|\|
9649	((utf[ix+3] & 0xc0) != 0x80))
9650	return(-ix);
9651	codepoint = (utf[ix] & 0x7) << 18;
9652	codepoint \|= (utf[ix+1] & 0x3f) << 12;
9653	codepoint \|= (utf[ix+2] & 0x3f) << 6;
9654	codepoint \|= utf[ix+3] & 0x3f;
9655	if (!xmlIsCharQ(codepoint))
9656	return(-ix);
9657	ix += 4;
9658	} else /* unknown encoding */
9659	return(-ix);
9660	}
9661	return(ix);
9662	}
9663
9664	/**
9665	* xmlParseTryOrFinish:
9666	* @ctxt: an XML parser context
9667	* @terminate: last chunk indicator
9668	*
9669	* Try to progress on parsing
9670	*
9671	* Returns zero if no parsing was possible
9672	*/
9673	static int
9674	xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) {
9675	int ret = 0;
9676	int avail, tlen;
9677	xmlChar cur, next;
9678	const xmlChar lastlt, lastgt;
9679
9680	if (ctxt->input == NULL)
9681	return(0);
9682
9683	#ifdef DEBUG_PUSH
9684	switch (ctxt->instate) {
9685	case XML_PARSER_EOF:
9686	xmlGenericError(xmlGenericErrorContext,
9687	"PP: try EOF\n"); break;
9688	case XML_PARSER_START:
9689	xmlGenericError(xmlGenericErrorContext,
9690	"PP: try START\n"); break;
9691	case XML_PARSER_MISC:
9692	xmlGenericError(xmlGenericErrorContext,
9693	"PP: try MISC\n");break;
9694	case XML_PARSER_COMMENT:
9695	xmlGenericError(xmlGenericErrorContext,
9696	"PP: try COMMENT\n");break;
9697	case XML_PARSER_PROLOG:
9698	xmlGenericError(xmlGenericErrorContext,
9699	"PP: try PROLOG\n");break;
9700	case XML_PARSER_START_TAG:
9701	xmlGenericError(xmlGenericErrorContext,
9702	"PP: try START_TAG\n");break;
9703	case XML_PARSER_CONTENT:
9704	xmlGenericError(xmlGenericErrorContext,
9705	"PP: try CONTENT\n");break;
9706	case XML_PARSER_CDATA_SECTION:
9707	xmlGenericError(xmlGenericErrorContext,
9708	"PP: try CDATA_SECTION\n");break;
9709	case XML_PARSER_END_TAG:
9710	xmlGenericError(xmlGenericErrorContext,
9711	"PP: try END_TAG\n");break;
9712	case XML_PARSER_ENTITY_DECL:
9713	xmlGenericError(xmlGenericErrorContext,
9714	"PP: try ENTITY_DECL\n");break;
9715	case XML_PARSER_ENTITY_VALUE:
9716	xmlGenericError(xmlGenericErrorContext,
9717	"PP: try ENTITY_VALUE\n");break;
9718	case XML_PARSER_ATTRIBUTE_VALUE:
9719	xmlGenericError(xmlGenericErrorContext,
9720	"PP: try ATTRIBUTE_VALUE\n");break;
9721	case XML_PARSER_DTD:
9722	xmlGenericError(xmlGenericErrorContext,
9723	"PP: try DTD\n");break;
9724	case XML_PARSER_EPILOG:
9725	xmlGenericError(xmlGenericErrorContext,
9726	"PP: try EPILOG\n");break;
9727	case XML_PARSER_PI:
9728	xmlGenericError(xmlGenericErrorContext,
9729	"PP: try PI\n");break;
9730	case XML_PARSER_IGNORE:
9731	xmlGenericError(xmlGenericErrorContext,
9732	"PP: try IGNORE\n");break;
9733	}
9734	#endif
9735
9736	if ((ctxt->input != NULL) &&
9737	(ctxt->input->cur - ctxt->input->base > 4096)) {
9738	xmlSHRINK(ctxt);
9739	ctxt->checkIndex = 0;
9740	}
9741	xmlParseGetLasts(ctxt, &lastlt, &lastgt);
9742
9743	while (1) {
9744	if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
9745	return(0);
9746
9747
9748	/*
9749	* Pop-up of finished entities.
9750	*/
9751	while ((RAW == 0) && (ctxt->inputNr > 1))
9752	xmlPopInput(ctxt);
9753
9754	if (ctxt->input == NULL) break;
9755	if (ctxt->input->buf == NULL)
9756	avail = ctxt->input->length -
9757	(ctxt->input->cur - ctxt->input->base);
9758	else {
9759	/*
9760	* If we are operating on converted input, try to flush
9761	* remainng chars to avoid them stalling in the non-converted
9762	* buffer.
9763	*/
9764	if ((ctxt->input->buf->raw != NULL) &&
9765	(ctxt->input->buf->raw->use > 0)) {
9766	int base = ctxt->input->base -
9767	ctxt->input->buf->buffer->content;
9768	int current = ctxt->input->cur - ctxt->input->base;
9769
9770	xmlParserInputBufferPush(ctxt->input->buf, 0, "");
9771	ctxt->input->base = ctxt->input->buf->buffer->content + base;
9772	ctxt->input->cur = ctxt->input->base + current;
9773	ctxt->input->end =
9774	&ctxt->input->buf->buffer->content[
9775	ctxt->input->buf->buffer->use];
9776	}
9777	avail = ctxt->input->buf->buffer->use -
9778	(ctxt->input->cur - ctxt->input->base);
9779	}
9780	if (avail < 1)
9781	goto done;
9782	switch (ctxt->instate) {
9783	case XML_PARSER_EOF:
9784	/*
9785	* Document parsing is done !
9786	*/
9787	goto done;
9788	case XML_PARSER_START:
9789	if (ctxt->charset == XML_CHAR_ENCODING_NONE) {
9790	xmlChar start[4];
9791	xmlCharEncoding enc;
9792
9793	/*
9794	* Very first chars read from the document flow.
9795	*/
9796	if (avail < 4)
9797	goto done;
9798
9799	/*
9800	* Get the 4 first bytes and decode the charset
9801	* if enc != XML_CHAR_ENCODING_NONE
9802	* plug some encoding conversion routines,
9803	* else xmlSwitchEncoding will set to (default)
9804	* UTF8.
9805	*/
9806	start[0] = RAW;
9807	start[1] = NXT(1);
9808	start[2] = NXT(2);
9809	start[3] = NXT(3);
9810	enc = xmlDetectCharEncoding(start, 4);
9811	xmlSwitchEncoding(ctxt, enc);
9812	break;
9813	}
9814
9815	if (avail < 2)
9816	goto done;
9817	cur = ctxt->input->cur[0];
9818	next = ctxt->input->cur[1];
9819	if (cur == 0) {
9820	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9821	ctxt->sax->setDocumentLocator(ctxt->userData,
9822	&xmlDefaultSAXLocator);
9823	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
9824	ctxt->instate = XML_PARSER_EOF;
9825	#ifdef DEBUG_PUSH
9826	xmlGenericError(xmlGenericErrorContext,
9827	"PP: entering EOF\n");
9828	#endif
9829	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9830	ctxt->sax->endDocument(ctxt->userData);
9831	goto done;
9832	}
9833	if ((cur == '<') && (next == '?')) {
9834	/* PI or XML decl */
9835	if (avail < 5) return(ret);
9836	if ((!terminate) &&
9837	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
9838	return(ret);
9839	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9840	ctxt->sax->setDocumentLocator(ctxt->userData,
9841	&xmlDefaultSAXLocator);
9842	if ((ctxt->input->cur[2] == 'x') &&
9843	(ctxt->input->cur[3] == 'm') &&
9844	(ctxt->input->cur[4] == 'l') &&
9845	(IS_BLANK_CH(ctxt->input->cur[5]))) {
9846	ret += 5;
9847	#ifdef DEBUG_PUSH
9848	xmlGenericError(xmlGenericErrorContext,
9849	"PP: Parsing XML Decl\n");
9850	#endif
9851	xmlParseXMLDecl(ctxt);
9852	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
9853	/*
9854	* The XML REC instructs us to stop parsing right
9855	* here
9856	*/
9857	ctxt->instate = XML_PARSER_EOF;
9858	return(0);
9859	}
9860	ctxt->standalone = ctxt->input->standalone;
9861	if ((ctxt->encoding == NULL) &&
9862	(ctxt->input->encoding != NULL))
9863	ctxt->encoding = xmlStrdup(ctxt->input->encoding);
9864	if ((ctxt->sax) && (ctxt->sax->startDocument) &&
9865	(!ctxt->disableSAX))
9866	ctxt->sax->startDocument(ctxt->userData);
9867	ctxt->instate = XML_PARSER_MISC;
9868	#ifdef DEBUG_PUSH
9869	xmlGenericError(xmlGenericErrorContext,
9870	"PP: entering MISC\n");
9871	#endif
9872	} else {
9873	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
9874	if ((ctxt->sax) && (ctxt->sax->startDocument) &&
9875	(!ctxt->disableSAX))
9876	ctxt->sax->startDocument(ctxt->userData);
9877	ctxt->instate = XML_PARSER_MISC;
9878	#ifdef DEBUG_PUSH
9879	xmlGenericError(xmlGenericErrorContext,
9880	"PP: entering MISC\n");
9881	#endif
9882	}
9883	} else {
9884	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9885	ctxt->sax->setDocumentLocator(ctxt->userData,
9886	&xmlDefaultSAXLocator);
9887	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
9888	if (ctxt->version == NULL) {
9889	xmlErrMemory(ctxt, NULL);
9890	break;
9891	}
9892	if ((ctxt->sax) && (ctxt->sax->startDocument) &&
9893	(!ctxt->disableSAX))
9894	ctxt->sax->startDocument(ctxt->userData);
9895	ctxt->instate = XML_PARSER_MISC;
9896	#ifdef DEBUG_PUSH
9897	xmlGenericError(xmlGenericErrorContext,
9898	"PP: entering MISC\n");
9899	#endif
9900	}
9901	break;
9902	case XML_PARSER_START_TAG: {
9903	const xmlChar *name;
9904	const xmlChar *prefix;
9905	const xmlChar *URI;
9906	int nsNr = ctxt->nsNr;
9907
9908	if ((avail < 2) && (ctxt->inputNr == 1))
9909	goto done;
9910	cur = ctxt->input->cur[0];
9911	if (cur != '<') {
9912	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
9913	ctxt->instate = XML_PARSER_EOF;
9914	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9915	ctxt->sax->endDocument(ctxt->userData);
9916	goto done;
9917	}
9918	if (!terminate) {
9919	if (ctxt->progressive) {
9920	/* > can be found unescaped in attribute values */
9921	if ((lastgt == NULL) \|\| (ctxt->input->cur >= lastgt))
9922	goto done;
9923	} else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
9924	goto done;
9925	}
9926	}
9927	if (ctxt->spaceNr == 0)
9928	spacePush(ctxt, -1);
9929	else if (*ctxt->space == -2)
9930	spacePush(ctxt, -1);
9931	else
9932	spacePush(ctxt, *ctxt->space);
9933	#ifdef LIBXML_SAX1_ENABLED
9934	if (ctxt->sax2)
9935	#endif /* LIBXML_SAX1_ENABLED */
9936	name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
9937	#ifdef LIBXML_SAX1_ENABLED
9938	else
9939	name = xmlParseStartTag(ctxt);
9940	#endif /* LIBXML_SAX1_ENABLED */
9941	if (name == NULL) {
9942	spacePop(ctxt);
9943	ctxt->instate = XML_PARSER_EOF;
9944	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9945	ctxt->sax->endDocument(ctxt->userData);
9946	goto done;
9947	}
9948	#ifdef LIBXML_VALID_ENABLED
9949	/*
9950	* [ VC: Root Element Type ]
9951	* The Name in the document type declaration must match
9952	* the element type of the root element.
9953	*/
9954	if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
9955	ctxt->node && (ctxt->node == ctxt->myDoc->children))
9956	ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
9957	#endif /* LIBXML_VALID_ENABLED */
9958
9959	/*
9960	* Check for an Empty Element.
9961	*/
9962	if ((RAW == '/') && (NXT(1) == '>')) {
9963	SKIP(2);
9964
9965	if (ctxt->sax2) {
9966	if ((ctxt->sax != NULL) &&
9967	(ctxt->sax->endElementNs != NULL) &&
9968	(!ctxt->disableSAX))
9969	ctxt->sax->endElementNs(ctxt->userData, name,
9970	prefix, URI);
9971	if (ctxt->nsNr - nsNr > 0)
9972	nsPop(ctxt, ctxt->nsNr - nsNr);
9973	#ifdef LIBXML_SAX1_ENABLED
9974	} else {
9975	if ((ctxt->sax != NULL) &&
9976	(ctxt->sax->endElement != NULL) &&
9977	(!ctxt->disableSAX))
9978	ctxt->sax->endElement(ctxt->userData, name);
9979	#endif /* LIBXML_SAX1_ENABLED */
9980	}
9981	spacePop(ctxt);
9982	if (ctxt->nameNr == 0) {
9983	ctxt->instate = XML_PARSER_EPILOG;
9984	} else {
9985	ctxt->instate = XML_PARSER_CONTENT;
9986	}
9987	break;
9988	}
9989	if (RAW == '>') {
9990	NEXT;
9991	} else {
9992	xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED,
9993	"Couldn't find end of Start Tag %s\n",
9994	name);
9995	nodePop(ctxt);
9996	spacePop(ctxt);
9997	}
9998	if (ctxt->sax2)
9999	nameNsPush(ctxt, name, prefix, URI, ctxt->nsNr - nsNr);
10000	#ifdef LIBXML_SAX1_ENABLED
10001	else
10002	namePush(ctxt, name);
10003	#endif /* LIBXML_SAX1_ENABLED */
10004
10005	ctxt->instate = XML_PARSER_CONTENT;
10006	break;
10007	}
10008	case XML_PARSER_CONTENT: {
10009	const xmlChar *test;
10010	unsigned int cons;
10011	if ((avail < 2) && (ctxt->inputNr == 1))
10012	goto done;
10013	cur = ctxt->input->cur[0];
10014	next = ctxt->input->cur[1];
10015
10016	test = CUR_PTR;
10017	cons = ctxt->input->consumed;
10018	if ((cur == '<') && (next == '/')) {
10019	ctxt->instate = XML_PARSER_END_TAG;
10020	break;
10021	} else if ((cur == '<') && (next == '?')) {
10022	if ((!terminate) &&
10023	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10024	goto done;
10025	xmlParsePI(ctxt);
10026	} else if ((cur == '<') && (next != '!')) {
10027	ctxt->instate = XML_PARSER_START_TAG;
10028	break;
10029	} else if ((cur == '<') && (next == '!') &&
10030	(ctxt->input->cur[2] == '-') &&
10031	(ctxt->input->cur[3] == '-')) {
10032	int term;
10033
10034	if (avail < 4)
10035	goto done;
10036	ctxt->input->cur += 4;
10037	term = xmlParseLookupSequence(ctxt, '-', '-', '>');
10038	ctxt->input->cur -= 4;
10039	if ((!terminate) && (term < 0))
10040	goto done;
10041	xmlParseComment(ctxt);
10042	ctxt->instate = XML_PARSER_CONTENT;
10043	} else if ((cur == '<') && (ctxt->input->cur[1] == '!') &&
10044	(ctxt->input->cur[2] == '[') &&
10045	(ctxt->input->cur[3] == 'C') &&
10046	(ctxt->input->cur[4] == 'D') &&
10047	(ctxt->input->cur[5] == 'A') &&
10048	(ctxt->input->cur[6] == 'T') &&
10049	(ctxt->input->cur[7] == 'A') &&
10050	(ctxt->input->cur[8] == '[')) {
10051	SKIP(9);
10052	ctxt->instate = XML_PARSER_CDATA_SECTION;
10053	break;
10054	} else if ((cur == '<') && (next == '!') &&
10055	(avail < 9)) {
10056	goto done;
10057	} else if (cur == '&') {
10058	if ((!terminate) &&
10059	(xmlParseLookupSequence(ctxt, ';', 0, 0) < 0))
10060	goto done;
10061	xmlParseReference(ctxt);
10062	} else {
10063	/* TODO Avoid the extra copy, handle directly !!! */
10064	/*
10065	* Goal of the following test is:
10066	* - minimize calls to the SAX 'character' callback
10067	* when they are mergeable
10068	* - handle an problem for isBlank when we only parse
10069	* a sequence of blank chars and the next one is
10070	* not available to check against '<' presence.
10071	* - tries to homogenize the differences in SAX
10072	* callbacks between the push and pull versions
10073	* of the parser.
10074	*/
10075	if ((ctxt->inputNr == 1) &&
10076	(avail < XML_PARSER_BIG_BUFFER_SIZE)) {
10077	if (!terminate) {
10078	if (ctxt->progressive) {
10079	if ((lastlt == NULL) \|\|
10080	(ctxt->input->cur > lastlt))
10081	goto done;
10082	} else if (xmlParseLookupSequence(ctxt,
10083	'<', 0, 0) < 0) {
10084	goto done;
10085	}
10086	}
10087	}
10088	ctxt->checkIndex = 0;
10089	xmlParseCharData(ctxt, 0);
10090	}
10091	/*
10092	* Pop-up of finished entities.
10093	*/
10094	while ((RAW == 0) && (ctxt->inputNr > 1))
10095	xmlPopInput(ctxt);
10096	if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
10097	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
10098	"detected an error in element content\n");
10099	ctxt->instate = XML_PARSER_EOF;
10100	break;
10101	}
10102	break;
10103	}
10104	case XML_PARSER_END_TAG:
10105	if (avail < 2)
10106	goto done;
10107	if (!terminate) {
10108	if (ctxt->progressive) {
10109	/* > can be found unescaped in attribute values */
10110	if ((lastgt == NULL) \|\| (ctxt->input->cur >= lastgt))
10111	goto done;
10112	} else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
10113	goto done;
10114	}
10115	}
10116	if (ctxt->sax2) {
10117	xmlParseEndTag2(ctxt,
10118	(void ) ctxt->pushTab[ctxt->nameNr 3 - 3],
10119	(void ) ctxt->pushTab[ctxt->nameNr 3 - 2], 0,
10120	(int) (long) ctxt->pushTab[ctxt->nameNr * 3 - 1], 0);
10121	nameNsPop(ctxt);
10122	}
10123	#ifdef LIBXML_SAX1_ENABLED
10124	else
10125	xmlParseEndTag1(ctxt, 0);
10126	#endif /* LIBXML_SAX1_ENABLED */
10127	if (ctxt->nameNr == 0) {
10128	ctxt->instate = XML_PARSER_EPILOG;
10129	} else {
10130	ctxt->instate = XML_PARSER_CONTENT;
10131	}
10132	break;
10133	case XML_PARSER_CDATA_SECTION: {
10134	/*
10135	* The Push mode need to have the SAX callback for
10136	* cdataBlock merge back contiguous callbacks.
10137	*/
10138	int base;
10139
10140	base = xmlParseLookupSequence(ctxt, ']', ']', '>');
10141	if (base < 0) {
10142	if (avail >= XML_PARSER_BIG_BUFFER_SIZE + 2) {
10143	int tmp;
10144
10145	tmp = xmlCheckCdataPush(ctxt->input->cur,
10146	XML_PARSER_BIG_BUFFER_SIZE);
10147	if (tmp < 0) {
10148	tmp = -tmp;
10149	ctxt->input->cur += tmp;
10150	goto encoding_error;
10151	}
10152	if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
10153	if (ctxt->sax->cdataBlock != NULL)
10154	ctxt->sax->cdataBlock(ctxt->userData,
10155	ctxt->input->cur, tmp);
10156	else if (ctxt->sax->characters != NULL)
10157	ctxt->sax->characters(ctxt->userData,
10158	ctxt->input->cur, tmp);
10159	}
10160	SKIPL(tmp);
10161	ctxt->checkIndex = 0;
10162	}
10163	goto done;
10164	} else {
10165	int tmp;
10166
10167	tmp = xmlCheckCdataPush(ctxt->input->cur, base);
10168	if ((tmp < 0) \|\| (tmp != base)) {
10169	tmp = -tmp;
10170	ctxt->input->cur += tmp;
10171	goto encoding_error;
10172	}
10173	if ((ctxt->sax != NULL) && (base > 0) &&
10174	(!ctxt->disableSAX)) {
10175	if (ctxt->sax->cdataBlock != NULL)
10176	ctxt->sax->cdataBlock(ctxt->userData,
10177	ctxt->input->cur, base);
10178	else if (ctxt->sax->characters != NULL)
10179	ctxt->sax->characters(ctxt->userData,
10180	ctxt->input->cur, base);
10181	}
10182	SKIPL(base + 3);
10183	ctxt->checkIndex = 0;
10184	ctxt->instate = XML_PARSER_CONTENT;
10185	#ifdef DEBUG_PUSH
10186	xmlGenericError(xmlGenericErrorContext,
10187	"PP: entering CONTENT\n");
10188	#endif
10189	}
10190	break;
10191	}
10192	case XML_PARSER_MISC:
10193	SKIP_BLANKS;
10194	if (ctxt->input->buf == NULL)
10195	avail = ctxt->input->length -
10196	(ctxt->input->cur - ctxt->input->base);
10197	else
10198	avail = ctxt->input->buf->buffer->use -
10199	(ctxt->input->cur - ctxt->input->base);
10200	if (avail < 2)
10201	goto done;
10202	cur = ctxt->input->cur[0];
10203	next = ctxt->input->cur[1];
10204	if ((cur == '<') && (next == '?')) {
10205	if ((!terminate) &&
10206	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10207	goto done;
10208	#ifdef DEBUG_PUSH
10209	xmlGenericError(xmlGenericErrorContext,
10210	"PP: Parsing PI\n");
10211	#endif
10212	xmlParsePI(ctxt);
10213	ctxt->checkIndex = 0;
10214	} else if ((cur == '<') && (next == '!') &&
10215	(ctxt->input->cur[2] == '-') &&
10216	(ctxt->input->cur[3] == '-')) {
10217	if ((!terminate) &&
10218	(xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
10219	goto done;
10220	#ifdef DEBUG_PUSH
10221	xmlGenericError(xmlGenericErrorContext,
10222	"PP: Parsing Comment\n");
10223	#endif
10224	xmlParseComment(ctxt);
10225	ctxt->instate = XML_PARSER_MISC;
10226	ctxt->checkIndex = 0;
10227	} else if ((cur == '<') && (next == '!') &&
10228	(ctxt->input->cur[2] == 'D') &&
10229	(ctxt->input->cur[3] == 'O') &&
10230	(ctxt->input->cur[4] == 'C') &&
10231	(ctxt->input->cur[5] == 'T') &&
10232	(ctxt->input->cur[6] == 'Y') &&
10233	(ctxt->input->cur[7] == 'P') &&
10234	(ctxt->input->cur[8] == 'E')) {
10235	if ((!terminate) &&
10236	(xmlParseLookupSequence(ctxt, '>', 0, 0) < 0))
10237	goto done;
10238	#ifdef DEBUG_PUSH
10239	xmlGenericError(xmlGenericErrorContext,
10240	"PP: Parsing internal subset\n");
10241	#endif
10242	ctxt->inSubset = 1;
10243	xmlParseDocTypeDecl(ctxt);
10244	if (RAW == '[') {
10245	ctxt->instate = XML_PARSER_DTD;
10246	#ifdef DEBUG_PUSH
10247	xmlGenericError(xmlGenericErrorContext,
10248	"PP: entering DTD\n");
10249	#endif
10250	} else {
10251	/*
10252	* Create and update the external subset.
10253	*/
10254	ctxt->inSubset = 2;
10255	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
10256	(ctxt->sax->externalSubset != NULL))
10257	ctxt->sax->externalSubset(ctxt->userData,
10258	ctxt->intSubName, ctxt->extSubSystem,
10259	ctxt->extSubURI);
10260	ctxt->inSubset = 0;
10261	ctxt->instate = XML_PARSER_PROLOG;
10262	#ifdef DEBUG_PUSH
10263	xmlGenericError(xmlGenericErrorContext,
10264	"PP: entering PROLOG\n");
10265	#endif
10266	}
10267	} else if ((cur == '<') && (next == '!') &&
10268	(avail < 9)) {
10269	goto done;
10270	} else {
10271	ctxt->instate = XML_PARSER_START_TAG;
10272	ctxt->progressive = 1;
10273	xmlParseGetLasts(ctxt, &lastlt, &lastgt);
10274	#ifdef DEBUG_PUSH
10275	xmlGenericError(xmlGenericErrorContext,
10276	"PP: entering START_TAG\n");
10277	#endif
10278	}
10279	break;
10280	case XML_PARSER_PROLOG:
10281	SKIP_BLANKS;
10282	if (ctxt->input->buf == NULL)
10283	avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
10284	else
10285	avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
10286	if (avail < 2)
10287	goto done;
10288	cur = ctxt->input->cur[0];
10289	next = ctxt->input->cur[1];
10290	if ((cur == '<') && (next == '?')) {
10291	if ((!terminate) &&
10292	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10293	goto done;
10294	#ifdef DEBUG_PUSH
10295	xmlGenericError(xmlGenericErrorContext,
10296	"PP: Parsing PI\n");
10297	#endif
10298	xmlParsePI(ctxt);
10299	} else if ((cur == '<') && (next == '!') &&
10300	(ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
10301	if ((!terminate) &&
10302	(xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
10303	goto done;
10304	#ifdef DEBUG_PUSH
10305	xmlGenericError(xmlGenericErrorContext,
10306	"PP: Parsing Comment\n");
10307	#endif
10308	xmlParseComment(ctxt);
10309	ctxt->instate = XML_PARSER_PROLOG;
10310	} else if ((cur == '<') && (next == '!') &&
10311	(avail < 4)) {
10312	goto done;
10313	} else {
10314	ctxt->instate = XML_PARSER_START_TAG;
10315	if (ctxt->progressive == 0)
10316	ctxt->progressive = 1;
10317	xmlParseGetLasts(ctxt, &lastlt, &lastgt);
10318	#ifdef DEBUG_PUSH
10319	xmlGenericError(xmlGenericErrorContext,
10320	"PP: entering START_TAG\n");
10321	#endif
10322	}
10323	break;
10324	case XML_PARSER_EPILOG:
10325	SKIP_BLANKS;
10326	if (ctxt->input->buf == NULL)
10327	avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
10328	else
10329	avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
10330	if (avail < 2)
10331	goto done;
10332	cur = ctxt->input->cur[0];
10333	next = ctxt->input->cur[1];
10334	if ((cur == '<') && (next == '?')) {
10335	if ((!terminate) &&
10336	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10337	goto done;
10338	#ifdef DEBUG_PUSH
10339	xmlGenericError(xmlGenericErrorContext,
10340	"PP: Parsing PI\n");
10341	#endif
10342	xmlParsePI(ctxt);
10343	ctxt->instate = XML_PARSER_EPILOG;
10344	} else if ((cur == '<') && (next == '!') &&
10345	(ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
10346	if ((!terminate) &&
10347	(xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
10348	goto done;
10349	#ifdef DEBUG_PUSH
10350	xmlGenericError(xmlGenericErrorContext,
10351	"PP: Parsing Comment\n");
10352	#endif
10353	xmlParseComment(ctxt);
10354	ctxt->instate = XML_PARSER_EPILOG;
10355	} else if ((cur == '<') && (next == '!') &&
10356	(avail < 4)) {
10357	goto done;
10358	} else {
10359	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10360	ctxt->instate = XML_PARSER_EOF;
10361	#ifdef DEBUG_PUSH
10362	xmlGenericError(xmlGenericErrorContext,
10363	"PP: entering EOF\n");
10364	#endif
10365	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10366	ctxt->sax->endDocument(ctxt->userData);
10367	goto done;
10368	}
10369	break;
10370	case XML_PARSER_DTD: {
10371	/*
10372	* Sorry but progressive parsing of the internal subset
10373	* is not expected to be supported. We first check that
10374	* the full content of the internal subset is available and
10375	* the parsing is launched only at that point.
10376	* Internal subset ends up with "']' S? '>'" in an unescaped
10377	* section and not in a ']]>' sequence which are conditional
10378	* sections (whoever argued to keep that crap in XML deserve
10379	* a place in hell !).
10380	*/
10381	int base, i;
10382	xmlChar *buf;
10383	xmlChar quote = 0;
10384
10385	base = ctxt->input->cur - ctxt->input->base;
10386	if (base < 0) return(0);
10387	if (ctxt->checkIndex > base)
10388	base = ctxt->checkIndex;
10389	buf = ctxt->input->buf->buffer->content;
10390	for (;(unsigned int) base < ctxt->input->buf->buffer->use;
10391	base++) {
10392	if (quote != 0) {
10393	if (buf[base] == quote)
10394	quote = 0;
10395	continue;
10396	}
10397	if ((quote == 0) && (buf[base] == '<')) {
10398	int found = 0;
10399	/* special handling of comments */
10400	if (((unsigned int) base + 4 <
10401	ctxt->input->buf->buffer->use) &&
10402	(buf[base + 1] == '!') &&
10403	(buf[base + 2] == '-') &&
10404	(buf[base + 3] == '-')) {
10405	for (;(unsigned int) base + 3 <
10406	ctxt->input->buf->buffer->use; base++) {
10407	if ((buf[base] == '-') &&
10408	(buf[base + 1] == '-') &&
10409	(buf[base + 2] == '>')) {
10410	found = 1;
10411	base += 2;
10412	break;
10413	}
10414	}
10415	if (!found) {
10416	#if 0
10417	fprintf(stderr, "unfinished comment\n");
10418	#endif
10419	break; /* for */
10420	}
10421	continue;
10422	}
10423	}
10424	if (buf[base] == '"') {
10425	quote = '"';
10426	continue;
10427	}
10428	if (buf[base] == '\'') {
10429	quote = '\'';
10430	continue;
10431	}
10432	if (buf[base] == ']') {
10433	#if 0
10434	fprintf(stderr, "%c%c%c%c: ", buf[base],
10435	buf[base + 1], buf[base + 2], buf[base + 3]);
10436	#endif
10437	if ((unsigned int) base +1 >=
10438	ctxt->input->buf->buffer->use)
10439	break;
10440	if (buf[base + 1] == ']') {
10441	/* conditional crap, skip both ']' ! */
10442	base++;
10443	continue;
10444	}
10445	for (i = 1;
10446	(unsigned int) base + i < ctxt->input->buf->buffer->use;
10447	i++) {
10448	if (buf[base + i] == '>') {
10449	#if 0
10450	fprintf(stderr, "found\n");
10451	#endif
10452	goto found_end_int_subset;
10453	}
10454	if (!IS_BLANK_CH(buf[base + i])) {
10455	#if 0
10456	fprintf(stderr, "not found\n");
10457	#endif
10458	goto not_end_of_int_subset;
10459	}
10460	}
10461	#if 0
10462	fprintf(stderr, "end of stream\n");
10463	#endif
10464	break;
10465
10466	}
10467	not_end_of_int_subset:
10468	continue; /* for */
10469	}
10470	/*
10471	* We didn't found the end of the Internal subset
10472	*/
10473	#ifdef DEBUG_PUSH
10474	if (next == 0)
10475	xmlGenericError(xmlGenericErrorContext,
10476	"PP: lookup of int subset end filed\n");
10477	#endif
10478	goto done;
10479
10480	found_end_int_subset:
10481	xmlParseInternalSubset(ctxt);
10482	ctxt->inSubset = 2;
10483	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
10484	(ctxt->sax->externalSubset != NULL))
10485	ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
10486	ctxt->extSubSystem, ctxt->extSubURI);
10487	ctxt->inSubset = 0;
10488	ctxt->instate = XML_PARSER_PROLOG;
10489	ctxt->checkIndex = 0;
10490	#ifdef DEBUG_PUSH
10491	xmlGenericError(xmlGenericErrorContext,
10492	"PP: entering PROLOG\n");
10493	#endif
10494	break;
10495	}
10496	case XML_PARSER_COMMENT:
10497	xmlGenericError(xmlGenericErrorContext,
10498	"PP: internal error, state == COMMENT\n");
10499	ctxt->instate = XML_PARSER_CONTENT;
10500	#ifdef DEBUG_PUSH
10501	xmlGenericError(xmlGenericErrorContext,
10502	"PP: entering CONTENT\n");
10503	#endif
10504	break;
10505	case XML_PARSER_IGNORE:
10506	xmlGenericError(xmlGenericErrorContext,
10507	"PP: internal error, state == IGNORE");
10508	ctxt->instate = XML_PARSER_DTD;
10509	#ifdef DEBUG_PUSH
10510	xmlGenericError(xmlGenericErrorContext,
10511	"PP: entering DTD\n");
10512	#endif
10513	break;
10514	case XML_PARSER_PI:
10515	xmlGenericError(xmlGenericErrorContext,
10516	"PP: internal error, state == PI\n");
10517	ctxt->instate = XML_PARSER_CONTENT;
10518	#ifdef DEBUG_PUSH
10519	xmlGenericError(xmlGenericErrorContext,
10520	"PP: entering CONTENT\n");
10521	#endif
10522	break;
10523	case XML_PARSER_ENTITY_DECL:
10524	xmlGenericError(xmlGenericErrorContext,
10525	"PP: internal error, state == ENTITY_DECL\n");
10526	ctxt->instate = XML_PARSER_DTD;
10527	#ifdef DEBUG_PUSH
10528	xmlGenericError(xmlGenericErrorContext,
10529	"PP: entering DTD\n");
10530	#endif
10531	break;
10532	case XML_PARSER_ENTITY_VALUE:
10533	xmlGenericError(xmlGenericErrorContext,
10534	"PP: internal error, state == ENTITY_VALUE\n");
10535	ctxt->instate = XML_PARSER_CONTENT;
10536	#ifdef DEBUG_PUSH
10537	xmlGenericError(xmlGenericErrorContext,
10538	"PP: entering DTD\n");
10539	#endif
10540	break;
10541	case XML_PARSER_ATTRIBUTE_VALUE:
10542	xmlGenericError(xmlGenericErrorContext,
10543	"PP: internal error, state == ATTRIBUTE_VALUE\n");
10544	ctxt->instate = XML_PARSER_START_TAG;
10545	#ifdef DEBUG_PUSH
10546	xmlGenericError(xmlGenericErrorContext,
10547	"PP: entering START_TAG\n");
10548	#endif
10549	break;
10550	case XML_PARSER_SYSTEM_LITERAL:
10551	xmlGenericError(xmlGenericErrorContext,
10552	"PP: internal error, state == SYSTEM_LITERAL\n");
10553	ctxt->instate = XML_PARSER_START_TAG;
10554	#ifdef DEBUG_PUSH
10555	xmlGenericError(xmlGenericErrorContext,
10556	"PP: entering START_TAG\n");
10557	#endif
10558	break;
10559	case XML_PARSER_PUBLIC_LITERAL:
10560	xmlGenericError(xmlGenericErrorContext,
10561	"PP: internal error, state == PUBLIC_LITERAL\n");
10562	ctxt->instate = XML_PARSER_START_TAG;
10563	#ifdef DEBUG_PUSH
10564	xmlGenericError(xmlGenericErrorContext,
10565	"PP: entering START_TAG\n");
10566	#endif
10567	break;
10568	}
10569	}
10570	done:
10571	#ifdef DEBUG_PUSH
10572	xmlGenericError(xmlGenericErrorContext, "PP: done %d\n", ret);
10573	#endif
10574	return(ret);
10575	encoding_error:
10576	{
10577	char buffer[150];
10578
10579	snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
10580	ctxt->input->cur[0], ctxt->input->cur[1],
10581	ctxt->input->cur[2], ctxt->input->cur[3]);
10582	__xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
10583	"Input is not proper UTF-8, indicate encoding !\n%s",
10584	BAD_CAST buffer, NULL);
10585	}
10586	return(0);
10587	}
10588
10589	/**
10590	* xmlParseChunk:
10591	* @ctxt: an XML parser context
10592	* @chunk: an char array
10593	* @size: the size in byte of the chunk
10594	* @terminate: last chunk indicator
10595	*
10596	* Parse a Chunk of memory
10597	*
10598	* Returns zero if no error, the xmlParserErrors otherwise.
10599	*/
10600	int
10601	xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size,
10602	int terminate) {
10603	int end_in_lf = 0;
10604
10605	if (ctxt == NULL)
10606	return(XML_ERR_INTERNAL_ERROR);
10607	if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
10608	return(ctxt->errNo);
10609	if (ctxt->instate == XML_PARSER_START)
10610	xmlDetectSAX2(ctxt);
10611	if ((size > 0) && (chunk != NULL) && (!terminate) &&
10612	(chunk[size - 1] == '\r')) {
10613	end_in_lf = 1;
10614	size--;
10615	}
10616	if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
10617	(ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF)) {
10618	int base = ctxt->input->base - ctxt->input->buf->buffer->content;
10619	int cur = ctxt->input->cur - ctxt->input->base;
10620	int res;
10621
10622	res =xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
10623	if (res < 0) {
10624	ctxt->errNo = XML_PARSER_EOF;
10625	ctxt->disableSAX = 1;
10626	return (XML_PARSER_EOF);
10627	}
10628	ctxt->input->base = ctxt->input->buf->buffer->content + base;
10629	ctxt->input->cur = ctxt->input->base + cur;
10630	ctxt->input->end =
10631	&ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
10632	#ifdef DEBUG_PUSH
10633	xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
10634	#endif
10635
10636	} else if (ctxt->instate != XML_PARSER_EOF) {
10637	if ((ctxt->input != NULL) && ctxt->input->buf != NULL) {
10638	xmlParserInputBufferPtr in = ctxt->input->buf;
10639	if ((in->encoder != NULL) && (in->buffer != NULL) &&
10640	(in->raw != NULL)) {
10641	int nbchars;
10642
10643	nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
10644	if (nbchars < 0) {
10645	/* TODO 2.6.0 */
10646	xmlGenericError(xmlGenericErrorContext,
10647	"xmlParseChunk: encoder error\n");
10648	return(XML_ERR_INVALID_ENCODING);
10649	}
10650	}
10651	}
10652	}
10653	xmlParseTryOrFinish(ctxt, terminate);
10654	if ((end_in_lf == 1) && (ctxt->input != NULL) &&
10655	(ctxt->input->buf != NULL)) {
10656	xmlParserInputBufferPush(ctxt->input->buf, 1, "\r");
10657	}
10658	if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
10659	return(ctxt->errNo);
10660	if (terminate) {
10661	/*
10662	* Check for termination
10663	*/
10664	int avail = 0;
10665
10666	if (ctxt->input != NULL) {
10667	if (ctxt->input->buf == NULL)
10668	avail = ctxt->input->length -
10669	(ctxt->input->cur - ctxt->input->base);
10670	else
10671	avail = ctxt->input->buf->buffer->use -
10672	(ctxt->input->cur - ctxt->input->base);
10673	}
10674
10675	if ((ctxt->instate != XML_PARSER_EOF) &&
10676	(ctxt->instate != XML_PARSER_EPILOG)) {
10677	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10678	}
10679	if ((ctxt->instate == XML_PARSER_EPILOG) && (avail > 0)) {
10680	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10681	}
10682	if (ctxt->instate != XML_PARSER_EOF) {
10683	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10684	ctxt->sax->endDocument(ctxt->userData);
10685	}
10686	ctxt->instate = XML_PARSER_EOF;
10687	}
10688	return((xmlParserErrors) ctxt->errNo);
10689	}
10690
10691	/************************************************************************
10692	* *
10693	* I/O front end functions to the parser *
10694	* *
10695	************************************************************************/
10696
10697	/**
10698	* xmlCreatePushParserCtxt:
10699	* @sax: a SAX handler
10700	* @user_data: The user data returned on SAX callbacks
10701	* @chunk: a pointer to an array of chars
10702	* @size: number of chars in the array
10703	* @filename: an optional file name or URI
10704	*
10705	* Create a parser context for using the XML parser in push mode.
10706	* If @buffer and @size are non-NULL, the data is used to detect
10707	* the encoding. The remaining characters will be parsed so they
10708	* don't need to be fed in again through xmlParseChunk.
10709	* To allow content encoding detection, @size should be >= 4
10710	* The value of @filename is used for fetching external entities
10711	* and error/warning reports.
10712	*
10713	* Returns the new parser context or NULL
10714	*/
10715
10716	xmlParserCtxtPtr
10717	xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
10718	const char chunk, int size, const char filename) {
10719	xmlParserCtxtPtr ctxt;
10720	xmlParserInputPtr inputStream;
10721	xmlParserInputBufferPtr buf;
10722	xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
10723
10724	/*
10725	* plug some encoding conversion routines
10726	*/
10727	if ((chunk != NULL) && (size >= 4))
10728	enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
10729
10730	buf = xmlAllocParserInputBuffer(enc);
10731	if (buf == NULL) return(NULL);
10732
10733	ctxt = xmlNewParserCtxt();
10734	if (ctxt == NULL) {
10735	xmlErrMemory(NULL, "creating parser: out of memory\n");
10736	xmlFreeParserInputBuffer(buf);
10737	return(NULL);
10738	}
10739	ctxt->dictNames = 1;
10740	ctxt->pushTab = (void *) xmlMalloc(ctxt->nameMax 3 * sizeof(xmlChar *));
10741	if (ctxt->pushTab == NULL) {
10742	xmlErrMemory(ctxt, NULL);
10743	xmlFreeParserInputBuffer(buf);
10744	xmlFreeParserCtxt(ctxt);
10745	return(NULL);
10746	}
10747	if (sax != NULL) {
10748	#ifdef LIBXML_SAX1_ENABLED
10749	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
10750	#endif /* LIBXML_SAX1_ENABLED */
10751	xmlFree(ctxt->sax);
10752	ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
10753	if (ctxt->sax == NULL) {
10754	xmlErrMemory(ctxt, NULL);
10755	xmlFreeParserInputBuffer(buf);
10756	xmlFreeParserCtxt(ctxt);
10757	return(NULL);
10758	}
10759	memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
10760	if (sax->initialized == XML_SAX2_MAGIC)
10761	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
10762	else
10763	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
10764	if (user_data != NULL)
10765	ctxt->userData = user_data;
10766	}
10767	if (filename == NULL) {
10768	ctxt->directory = NULL;
10769	} else {
10770	ctxt->directory = xmlParserGetDirectory(filename);
10771	}
10772
10773	inputStream = xmlNewInputStream(ctxt);
10774	if (inputStream == NULL) {
10775	xmlFreeParserCtxt(ctxt);
10776	xmlFreeParserInputBuffer(buf);
10777	return(NULL);
10778	}
10779
10780	if (filename == NULL)
10781	inputStream->filename = NULL;
10782	else {
10783	inputStream->filename = (char *)
10784	xmlCanonicPath((const xmlChar *) filename);
10785	if (inputStream->filename == NULL) {
10786	xmlFreeParserCtxt(ctxt);
10787	xmlFreeParserInputBuffer(buf);
10788	return(NULL);
10789	}
10790	}
10791	inputStream->buf = buf;
10792	inputStream->base = inputStream->buf->buffer->content;
10793	inputStream->cur = inputStream->buf->buffer->content;
10794	inputStream->end =
10795	&inputStream->buf->buffer->content[inputStream->buf->buffer->use];
10796
10797	inputPush(ctxt, inputStream);
10798
10799	/*
10800	* If the caller didn't provide an initial 'chunk' for determining
10801	* the encoding, we set the context to XML_CHAR_ENCODING_NONE so
10802	* that it can be automatically determined later
10803	*/
10804	if ((size == 0) \|\| (chunk == NULL)) {
10805	ctxt->charset = XML_CHAR_ENCODING_NONE;
10806	} else if ((ctxt->input != NULL) && (ctxt->input->buf != NULL)) {
10807	int base = ctxt->input->base - ctxt->input->buf->buffer->content;
10808	int cur = ctxt->input->cur - ctxt->input->base;
10809
10810	xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
10811
10812	ctxt->input->base = ctxt->input->buf->buffer->content + base;
10813	ctxt->input->cur = ctxt->input->base + cur;
10814	ctxt->input->end =
10815	&ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
10816	#ifdef DEBUG_PUSH
10817	xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
10818	#endif
10819	}
10820
10821	if (enc != XML_CHAR_ENCODING_NONE) {
10822	xmlSwitchEncoding(ctxt, enc);
10823	}
10824
10825	return(ctxt);
10826	}
10827	#endif /* LIBXML_PUSH_ENABLED */
10828
10829	/**
10830	* xmlStopParser:
10831	* @ctxt: an XML parser context
10832	*
10833	* Blocks further parser processing
10834	*/
10835	void
10836	xmlStopParser(xmlParserCtxtPtr ctxt) {
10837	if (ctxt == NULL)
10838	return;
10839	ctxt->instate = XML_PARSER_EOF;
10840	ctxt->disableSAX = 1;
10841	if (ctxt->input != NULL) {
10842	ctxt->input->cur = BAD_CAST"";
10843	ctxt->input->base = ctxt->input->cur;
10844	}
10845	}
10846
10847	/**
10848	* xmlCreateIOParserCtxt:
10849	* @sax: a SAX handler
10850	* @user_data: The user data returned on SAX callbacks
10851	* @ioread: an I/O read function
10852	* @ioclose: an I/O close function
10853	* @ioctx: an I/O handler
10854	* @enc: the charset encoding if known
10855	*
10856	* Create a parser context for using the XML parser with an existing
10857	* I/O stream
10858	*
10859	* Returns the new parser context or NULL
10860	*/
10861	xmlParserCtxtPtr
10862	xmlCreateIOParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
10863	xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
10864	void *ioctx, xmlCharEncoding enc) {
10865	xmlParserCtxtPtr ctxt;
10866	xmlParserInputPtr inputStream;
10867	xmlParserInputBufferPtr buf;
10868
10869	if (ioread == NULL) return(NULL);
10870
10871	buf = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, enc);
10872	if (buf == NULL) return(NULL);
10873
10874	ctxt = xmlNewParserCtxt();
10875	if (ctxt == NULL) {
10876	xmlFreeParserInputBuffer(buf);
10877	return(NULL);
10878	}
10879	if (sax != NULL) {
10880	#ifdef LIBXML_SAX1_ENABLED
10881	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
10882	#endif /* LIBXML_SAX1_ENABLED */
10883	xmlFree(ctxt->sax);
10884	ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
10885	if (ctxt->sax == NULL) {
10886	xmlErrMemory(ctxt, NULL);
10887	xmlFreeParserCtxt(ctxt);
10888	return(NULL);
10889	}
10890	memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
10891	if (sax->initialized == XML_SAX2_MAGIC)
10892	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
10893	else
10894	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
10895	if (user_data != NULL)
10896	ctxt->userData = user_data;
10897	}
10898
10899	inputStream = xmlNewIOInputStream(ctxt, buf, enc);
10900	if (inputStream == NULL) {
10901	xmlFreeParserCtxt(ctxt);
10902	return(NULL);
10903	}
10904	inputPush(ctxt, inputStream);
10905
10906	return(ctxt);
10907	}
10908
10909	#ifdef LIBXML_VALID_ENABLED
10910	/************************************************************************
10911	* *
10912	* Front ends when parsing a DTD *
10913	* *
10914	************************************************************************/
10915
10916	/**
10917	* xmlIOParseDTD:
10918	* @sax: the SAX handler block or NULL
10919	* @input: an Input Buffer
10920	* @enc: the charset encoding if known
10921	*
10922	* Load and parse a DTD
10923	*
10924	* Returns the resulting xmlDtdPtr or NULL in case of error.
10925	* @input will be freed by the function in any case.
10926	*/
10927
10928	xmlDtdPtr
10929	xmlIOParseDTD(xmlSAXHandlerPtr sax, xmlParserInputBufferPtr input,
10930	xmlCharEncoding enc) {
10931	xmlDtdPtr ret = NULL;
10932	xmlParserCtxtPtr ctxt;
10933	xmlParserInputPtr pinput = NULL;
10934	xmlChar start[4];
10935
10936	if (input == NULL)
10937	return(NULL);
10938
10939	ctxt = xmlNewParserCtxt();
10940	if (ctxt == NULL) {
10941	xmlFreeParserInputBuffer(input);
10942	return(NULL);
10943	}
10944
10945	/*
10946	* Set-up the SAX context
10947	*/
10948	if (sax != NULL) {
10949	if (ctxt->sax != NULL)
10950	xmlFree(ctxt->sax);
10951	ctxt->sax = sax;
10952	ctxt->userData = ctxt;
10953	}
10954	xmlDetectSAX2(ctxt);
10955
10956	/*
10957	* generate a parser input from the I/O handler
10958	*/
10959
10960	pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
10961	if (pinput == NULL) {
10962	if (sax != NULL) ctxt->sax = NULL;
10963	xmlFreeParserInputBuffer(input);
10964	xmlFreeParserCtxt(ctxt);
10965	return(NULL);
10966	}
10967
10968	/*
10969	* plug some encoding conversion routines here.
10970	*/
10971	xmlPushInput(ctxt, pinput);
10972	if (enc != XML_CHAR_ENCODING_NONE) {
10973	xmlSwitchEncoding(ctxt, enc);
10974	}
10975
10976	pinput->filename = NULL;
10977	pinput->line = 1;
10978	pinput->col = 1;
10979	pinput->base = ctxt->input->cur;
10980	pinput->cur = ctxt->input->cur;
10981	pinput->free = NULL;
10982
10983	/*
10984	* let's parse that entity knowing it's an external subset.
10985	*/
10986	ctxt->inSubset = 2;
10987	ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
10988	ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
10989	BAD_CAST "none", BAD_CAST "none");
10990
10991	if ((enc == XML_CHAR_ENCODING_NONE) &&
10992	((ctxt->input->end - ctxt->input->cur) >= 4)) {
10993	/*
10994	* Get the 4 first bytes and decode the charset
10995	* if enc != XML_CHAR_ENCODING_NONE
10996	* plug some encoding conversion routines.
10997	*/
10998	start[0] = RAW;
10999	start[1] = NXT(1);
11000	start[2] = NXT(2);
11001	start[3] = NXT(3);
11002	enc = xmlDetectCharEncoding(start, 4);
11003	if (enc != XML_CHAR_ENCODING_NONE) {
11004	xmlSwitchEncoding(ctxt, enc);
11005	}
11006	}
11007
11008	xmlParseExternalSubset(ctxt, BAD_CAST "none", BAD_CAST "none");
11009
11010	if (ctxt->myDoc != NULL) {
11011	if (ctxt->wellFormed) {
11012	ret = ctxt->myDoc->extSubset;
11013	ctxt->myDoc->extSubset = NULL;
11014	if (ret != NULL) {
11015	xmlNodePtr tmp;
11016
11017	ret->doc = NULL;
11018	tmp = ret->children;
11019	while (tmp != NULL) {
11020	tmp->doc = NULL;
11021	tmp = tmp->next;
11022	}
11023	}
11024	} else {
11025	ret = NULL;
11026	}
11027	xmlFreeDoc(ctxt->myDoc);
11028	ctxt->myDoc = NULL;
11029	}
11030	if (sax != NULL) ctxt->sax = NULL;
11031	xmlFreeParserCtxt(ctxt);
11032
11033	return(ret);
11034	}
11035
11036	/**
11037	* xmlSAXParseDTD:
11038	* @sax: the SAX handler block
11039	* @ExternalID: a NAME* containing the External ID of the DTD
11040	* @SystemID: a NAME* containing the URL to the DTD
11041	*
11042	* Load and parse an external subset.
11043	*
11044	* Returns the resulting xmlDtdPtr or NULL in case of error.
11045	*/
11046
11047	xmlDtdPtr
11048	xmlSAXParseDTD(xmlSAXHandlerPtr sax, const xmlChar *ExternalID,
11049	const xmlChar *SystemID) {
11050	xmlDtdPtr ret = NULL;
11051	xmlParserCtxtPtr ctxt;
11052	xmlParserInputPtr input = NULL;
11053	xmlCharEncoding enc;
11054	xmlChar* systemIdCanonic;
11055
11056	if ((ExternalID == NULL) && (SystemID == NULL)) return(NULL);
11057
11058	ctxt = xmlNewParserCtxt();
11059	if (ctxt == NULL) {
11060	return(NULL);
11061	}
11062
11063	/*
11064	* Set-up the SAX context
11065	*/
11066	if (sax != NULL) {
11067	if (ctxt->sax != NULL)
11068	xmlFree(ctxt->sax);
11069	ctxt->sax = sax;
11070	ctxt->userData = ctxt;
11071	}
11072
11073	/*
11074	* Canonicalise the system ID
11075	*/
11076	systemIdCanonic = xmlCanonicPath(SystemID);
11077	if ((SystemID != NULL) && (systemIdCanonic == NULL)) {
11078	xmlFreeParserCtxt(ctxt);
11079	return(NULL);
11080	}
11081
11082	/*
11083	* Ask the Entity resolver to load the damn thing
11084	*/
11085
11086	if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
11087	input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
11088	systemIdCanonic);
11089	if (input == NULL) {
11090	if (sax != NULL) ctxt->sax = NULL;
11091	xmlFreeParserCtxt(ctxt);
11092	if (systemIdCanonic != NULL)
11093	xmlFree(systemIdCanonic);
11094	return(NULL);
11095	}
11096
11097	/*
11098	* plug some encoding conversion routines here.
11099	*/
11100	xmlPushInput(ctxt, input);
11101	if ((ctxt->input->end - ctxt->input->cur) >= 4) {
11102	enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
11103	xmlSwitchEncoding(ctxt, enc);
11104	}
11105
11106	if (input->filename == NULL)
11107	input->filename = (char *) systemIdCanonic;
11108	else
11109	xmlFree(systemIdCanonic);
11110	input->line = 1;
11111	input->col = 1;
11112	input->base = ctxt->input->cur;
11113	input->cur = ctxt->input->cur;
11114	input->free = NULL;
11115
11116	/*
11117	* let's parse that entity knowing it's an external subset.
11118	*/
11119	ctxt->inSubset = 2;
11120	ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
11121	ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
11122	ExternalID, SystemID);
11123	xmlParseExternalSubset(ctxt, ExternalID, SystemID);
11124
11125	if (ctxt->myDoc != NULL) {
11126	if (ctxt->wellFormed) {
11127	ret = ctxt->myDoc->extSubset;
11128	ctxt->myDoc->extSubset = NULL;
11129	if (ret != NULL) {
11130	xmlNodePtr tmp;
11131
11132	ret->doc = NULL;
11133	tmp = ret->children;
11134	while (tmp != NULL) {
11135	tmp->doc = NULL;
11136	tmp = tmp->next;
11137	}
11138	}
11139	} else {
11140	ret = NULL;
11141	}
11142	xmlFreeDoc(ctxt->myDoc);
11143	ctxt->myDoc = NULL;
11144	}
11145	if (sax != NULL) ctxt->sax = NULL;
11146	xmlFreeParserCtxt(ctxt);
11147
11148	return(ret);
11149	}
11150
11151
11152	/**
11153	* xmlParseDTD:
11154	* @ExternalID: a NAME* containing the External ID of the DTD
11155	* @SystemID: a NAME* containing the URL to the DTD
11156	*
11157	* Load and parse an external subset.
11158	*
11159	* Returns the resulting xmlDtdPtr or NULL in case of error.
11160	*/
11161
11162	xmlDtdPtr
11163	xmlParseDTD(const xmlChar ExternalID, const xmlChar SystemID) {
11164	return(xmlSAXParseDTD(NULL, ExternalID, SystemID));
11165	}
11166	#endif /* LIBXML_VALID_ENABLED */
11167
11168	/************************************************************************
11169	* *
11170	* Front ends when parsing an Entity *
11171	* *
11172	************************************************************************/
11173
11174	/**
11175	* xmlParseCtxtExternalEntity:
11176	* @ctx: the existing parsing context
11177	* @URL: the URL for the entity to load
11178	* @ID: the System ID for the entity to load
11179	* @lst: the return value for the set of parsed nodes
11180	*
11181	* Parse an external general entity within an existing parsing context
11182	* An external general parsed entity is well-formed if it matches the
11183	* production labeled extParsedEnt.
11184	*
11185	* [78] extParsedEnt ::= TextDecl? content
11186	*
11187	* Returns 0 if the entity is well formed, -1 in case of args problem and
11188	* the parser error code otherwise
11189	*/
11190
11191	int
11192	xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, const xmlChar *URL,
11193	const xmlChar ID, xmlNodePtr lst) {
11194	xmlParserCtxtPtr ctxt;
11195	xmlDocPtr newDoc;
11196	xmlNodePtr newRoot;
11197	xmlSAXHandlerPtr oldsax = NULL;
11198	int ret = 0;
11199	xmlChar start[4];
11200	xmlCharEncoding enc;
11201	xmlParserInputPtr inputStream;
11202	char *directory = NULL;
11203
11204	if (ctx == NULL) return(-1);
11205
11206	if ((ctx->depth > 40) \|\| (ctx->nbentities >= 500000)) {
11207	return(XML_ERR_ENTITY_LOOP);
11208	}
11209
11210	if (lst != NULL)
11211	*lst = NULL;
11212	if ((URL == NULL) && (ID == NULL))
11213	return(-1);
11214	if (ctx->myDoc == NULL) /* @@ relax but check for dereferences */
11215	return(-1);
11216
11217	ctxt = xmlNewParserCtxt();
11218	if (ctxt == NULL) {
11219	return(-1);
11220	}
11221
11222	ctxt->userData = ctxt;
11223	ctxt->_private = ctx->_private;
11224
11225	inputStream = xmlLoadExternalEntity((char )URL, (char )ID, ctxt);
11226	if (inputStream == NULL) {
11227	xmlFreeParserCtxt(ctxt);
11228	return(-1);
11229	}
11230
11231	inputPush(ctxt, inputStream);
11232
11233	if ((ctxt->directory == NULL) && (directory == NULL))
11234	directory = xmlParserGetDirectory((char *)URL);
11235	if ((ctxt->directory == NULL) && (directory != NULL))
11236	ctxt->directory = directory;
11237
11238	oldsax = ctxt->sax;
11239	ctxt->sax = ctx->sax;
11240	xmlDetectSAX2(ctxt);
11241	newDoc = xmlNewDoc(BAD_CAST "1.0");
11242	if (newDoc == NULL) {
11243	xmlFreeParserCtxt(ctxt);
11244	return(-1);
11245	}
11246	if (ctx->myDoc->dict) {
11247	newDoc->dict = ctx->myDoc->dict;
11248	xmlDictReference(newDoc->dict);
11249	}
11250	if (ctx->myDoc != NULL) {
11251	newDoc->intSubset = ctx->myDoc->intSubset;
11252	newDoc->extSubset = ctx->myDoc->extSubset;
11253	}
11254	if (ctx->myDoc->URL != NULL) {
11255	newDoc->URL = xmlStrdup(ctx->myDoc->URL);
11256	}
11257	newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
11258	if (newRoot == NULL) {
11259	ctxt->sax = oldsax;
11260	xmlFreeParserCtxt(ctxt);
11261	newDoc->intSubset = NULL;
11262	newDoc->extSubset = NULL;
11263	xmlFreeDoc(newDoc);
11264	return(-1);
11265	}
11266	xmlAddChild((xmlNodePtr) newDoc, newRoot);
11267	nodePush(ctxt, newDoc->children);
11268	if (ctx->myDoc == NULL) {
11269	ctxt->myDoc = newDoc;
11270	} else {
11271	ctxt->myDoc = ctx->myDoc;
11272	newDoc->children->doc = ctx->myDoc;
11273	}
11274
11275	/*
11276	* Get the 4 first bytes and decode the charset
11277	* if enc != XML_CHAR_ENCODING_NONE
11278	* plug some encoding conversion routines.
11279	*/
11280	GROW
11281	if ((ctxt->input->end - ctxt->input->cur) >= 4) {
11282	start[0] = RAW;
11283	start[1] = NXT(1);
11284	start[2] = NXT(2);
11285	start[3] = NXT(3);
11286	enc = xmlDetectCharEncoding(start, 4);
11287	if (enc != XML_CHAR_ENCODING_NONE) {
11288	xmlSwitchEncoding(ctxt, enc);
11289	}
11290	}
11291
11292	/*
11293	* Parse a possible text declaration first
11294	*/
11295	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
11296	xmlParseTextDecl(ctxt);
11297	}
11298
11299	/*
11300	* Doing validity checking on chunk doesn't make sense
11301	*/
11302	ctxt->instate = XML_PARSER_CONTENT;
11303	ctxt->validate = ctx->validate;
11304	ctxt->valid = ctx->valid;
11305	ctxt->loadsubset = ctx->loadsubset;
11306	ctxt->depth = ctx->depth + 1;
11307	ctxt->replaceEntities = ctx->replaceEntities;
11308	if (ctxt->validate) {
11309	ctxt->vctxt.error = ctx->vctxt.error;
11310	ctxt->vctxt.warning = ctx->vctxt.warning;
11311	} else {
11312	ctxt->vctxt.error = NULL;
11313	ctxt->vctxt.warning = NULL;
11314	}
11315	ctxt->vctxt.nodeTab = NULL;
11316	ctxt->vctxt.nodeNr = 0;
11317	ctxt->vctxt.nodeMax = 0;
11318	ctxt->vctxt.node = NULL;
11319	if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
11320	ctxt->dict = ctx->dict;
11321	ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
11322	ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
11323	ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
11324	ctxt->dictNames = ctx->dictNames;
11325	ctxt->attsDefault = ctx->attsDefault;
11326	ctxt->attsSpecial = ctx->attsSpecial;
11327	ctxt->linenumbers = ctx->linenumbers;
11328
11329	xmlParseContent(ctxt);
11330
11331	ctx->validate = ctxt->validate;
11332	ctx->valid = ctxt->valid;
11333	if ((RAW == '<') && (NXT(1) == '/')) {
11334	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11335	} else if (RAW != 0) {
11336	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11337	}
11338	if (ctxt->node != newDoc->children) {
11339	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11340	}
11341
11342	if (!ctxt->wellFormed) {
11343	if (ctxt->errNo == 0)
11344	ret = 1;
11345	else
11346	ret = ctxt->errNo;
11347	} else {
11348	if (lst != NULL) {
11349	xmlNodePtr cur;
11350
11351	/*
11352	* Return the newly created nodeset after unlinking it from
11353	* they pseudo parent.
11354	*/
11355	cur = newDoc->children->children;
11356	*lst = cur;
11357	while (cur != NULL) {
11358	cur->parent = NULL;
11359	cur = cur->next;
11360	}
11361	newDoc->children->children = NULL;
11362	}
11363	ret = 0;
11364	}
11365	ctxt->sax = oldsax;
11366	ctxt->dict = NULL;
11367	ctxt->attsDefault = NULL;
11368	ctxt->attsSpecial = NULL;
11369	xmlFreeParserCtxt(ctxt);
11370	newDoc->intSubset = NULL;
11371	newDoc->extSubset = NULL;
11372	xmlFreeDoc(newDoc);
11373
11374	return(ret);
11375	}
11376
11377	/**
11378	* xmlParseExternalEntityPrivate:
11379	* @doc: the document the chunk pertains to
11380	* @oldctxt: the previous parser context if available
11381	* @sax: the SAX handler bloc (possibly NULL)
11382	* @user_data: The user data returned on SAX callbacks (possibly NULL)
11383	* @depth: Used for loop detection, use 0
11384	* @URL: the URL for the entity to load
11385	* @ID: the System ID for the entity to load
11386	* @list: the return value for the set of parsed nodes
11387	*
11388	* Private version of xmlParseExternalEntity()
11389	*
11390	* Returns 0 if the entity is well formed, -1 in case of args problem and
11391	* the parser error code otherwise
11392	*/
11393
11394	static xmlParserErrors
11395	xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
11396	xmlSAXHandlerPtr sax,
11397	void user_data, int depth, const xmlChar URL,
11398	const xmlChar ID, xmlNodePtr list) {
11399	xmlParserCtxtPtr ctxt;
11400	xmlDocPtr newDoc;
11401	xmlNodePtr newRoot;
11402	xmlSAXHandlerPtr oldsax = NULL;
11403	xmlParserErrors ret = XML_ERR_OK;
11404	xmlChar start[4];
11405	xmlCharEncoding enc;
11406
11407	if ((depth > 40) \|\|
11408	((oldctxt != NULL) && (oldctxt->nbentities >= 500000))) {
11409	return(XML_ERR_ENTITY_LOOP);
11410	}
11411
11412
11413
11414	if (list != NULL)
11415	*list = NULL;
11416	if ((URL == NULL) && (ID == NULL))
11417	return(XML_ERR_INTERNAL_ERROR);
11418	if (doc == NULL)
11419	return(XML_ERR_INTERNAL_ERROR);
11420
11421
11422	ctxt = xmlCreateEntityParserCtxt(URL, ID, NULL);
11423	if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
11424	ctxt->userData = ctxt;
11425	if (oldctxt != NULL) {
11426	ctxt->_private = oldctxt->_private;
11427	ctxt->loadsubset = oldctxt->loadsubset;
11428	ctxt->validate = oldctxt->validate;
11429	ctxt->external = oldctxt->external;
11430	ctxt->record_info = oldctxt->record_info;
11431	ctxt->node_seq.maximum = oldctxt->node_seq.maximum;
11432	ctxt->node_seq.length = oldctxt->node_seq.length;
11433	ctxt->node_seq.buffer = oldctxt->node_seq.buffer;
11434	} else {
11435	/*
11436	* Doing validity checking on chunk without context
11437	* doesn't make sense
11438	*/
11439	ctxt->_private = NULL;
11440	ctxt->validate = 0;
11441	ctxt->external = 2;
11442	ctxt->loadsubset = 0;
11443	}
11444	if (sax != NULL) {
11445	oldsax = ctxt->sax;
11446	ctxt->sax = sax;
11447	if (user_data != NULL)
11448	ctxt->userData = user_data;
11449	}
11450	xmlDetectSAX2(ctxt);
11451	newDoc = xmlNewDoc(BAD_CAST "1.0");
11452	if (newDoc == NULL) {
11453	ctxt->node_seq.maximum = 0;
11454	ctxt->node_seq.length = 0;
11455	ctxt->node_seq.buffer = NULL;
11456	xmlFreeParserCtxt(ctxt);
11457	return(XML_ERR_INTERNAL_ERROR);
11458	}
11459	newDoc->intSubset = doc->intSubset;
11460	newDoc->extSubset = doc->extSubset;
11461	newDoc->dict = doc->dict;
11462	xmlDictReference(newDoc->dict);
11463
11464	if (doc->URL != NULL) {
11465	newDoc->URL = xmlStrdup(doc->URL);
11466	}
11467	newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
11468	if (newRoot == NULL) {
11469	if (sax != NULL)
11470	ctxt->sax = oldsax;
11471	ctxt->node_seq.maximum = 0;
11472	ctxt->node_seq.length = 0;
11473	ctxt->node_seq.buffer = NULL;
11474	xmlFreeParserCtxt(ctxt);
11475	newDoc->intSubset = NULL;
11476	newDoc->extSubset = NULL;
11477	xmlFreeDoc(newDoc);
11478	return(XML_ERR_INTERNAL_ERROR);
11479	}
11480	xmlAddChild((xmlNodePtr) newDoc, newRoot);
11481	nodePush(ctxt, newDoc->children);
11482	ctxt->myDoc = doc;
11483	newRoot->doc = doc;
11484
11485	/*
11486	* Get the 4 first bytes and decode the charset
11487	* if enc != XML_CHAR_ENCODING_NONE
11488	* plug some encoding conversion routines.
11489	*/
11490	GROW;
11491	if ((ctxt->input->end - ctxt->input->cur) >= 4) {
11492	start[0] = RAW;
11493	start[1] = NXT(1);
11494	start[2] = NXT(2);
11495	start[3] = NXT(3);
11496	enc = xmlDetectCharEncoding(start, 4);
11497	if (enc != XML_CHAR_ENCODING_NONE) {
11498	xmlSwitchEncoding(ctxt, enc);
11499	}
11500	}
11501
11502	/*
11503	* Parse a possible text declaration first
11504	*/
11505	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
11506	xmlParseTextDecl(ctxt);
11507	}
11508
11509	ctxt->instate = XML_PARSER_CONTENT;
11510	ctxt->depth = depth;
11511
11512	xmlParseContent(ctxt);
11513
11514	if ((RAW == '<') && (NXT(1) == '/')) {
11515	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11516	} else if (RAW != 0) {
11517	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11518	}
11519	if (ctxt->node != newDoc->children) {
11520	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11521	}
11522
11523	if (!ctxt->wellFormed) {
11524	if (ctxt->errNo == 0)
11525	ret = XML_ERR_INTERNAL_ERROR;
11526	else
11527	ret = (xmlParserErrors)ctxt->errNo;
11528	} else {
11529	if (list != NULL) {
11530	xmlNodePtr cur;
11531
11532	/*
11533	* Return the newly created nodeset after unlinking it from
11534	* they pseudo parent.
11535	*/
11536	cur = newDoc->children->children;
11537	*list = cur;
11538	while (cur != NULL) {
11539	cur->parent = NULL;
11540	cur = cur->next;
11541	}
11542	newDoc->children->children = NULL;
11543	}
11544	ret = XML_ERR_OK;
11545	}
11546	if (sax != NULL)
11547	ctxt->sax = oldsax;
11548	oldctxt->node_seq.maximum = ctxt->node_seq.maximum;
11549	oldctxt->node_seq.length = ctxt->node_seq.length;
11550	oldctxt->node_seq.buffer = ctxt->node_seq.buffer;
11551	oldctxt->nbentities += ctxt->nbentities;
11552	ctxt->node_seq.maximum = 0;
11553	ctxt->node_seq.length = 0;
11554	ctxt->node_seq.buffer = NULL;
11555	xmlFreeParserCtxt(ctxt);
11556	newDoc->intSubset = NULL;
11557	newDoc->extSubset = NULL;
11558	xmlFreeDoc(newDoc);
11559
11560	return(ret);
11561	}
11562
11563	#ifdef LIBXML_SAX1_ENABLED
11564	/**
11565	* xmlParseExternalEntity:
11566	* @doc: the document the chunk pertains to
11567	* @sax: the SAX handler bloc (possibly NULL)
11568	* @user_data: The user data returned on SAX callbacks (possibly NULL)
11569	* @depth: Used for loop detection, use 0
11570	* @URL: the URL for the entity to load
11571	* @ID: the System ID for the entity to load
11572	* @lst: the return value for the set of parsed nodes
11573	*
11574	* Parse an external general entity
11575	* An external general parsed entity is well-formed if it matches the
11576	* production labeled extParsedEnt.
11577	*
11578	* [78] extParsedEnt ::= TextDecl? content
11579	*
11580	* Returns 0 if the entity is well formed, -1 in case of args problem and
11581	* the parser error code otherwise
11582	*/
11583
11584	int
11585	xmlParseExternalEntity(xmlDocPtr doc, xmlSAXHandlerPtr sax, void *user_data,
11586	int depth, const xmlChar URL, const xmlChar ID, xmlNodePtr *lst) {
11587	return(xmlParseExternalEntityPrivate(doc, NULL, sax, user_data, depth, URL,
11588	ID, lst));
11589	}
11590
11591	/**
11592	* xmlParseBalancedChunkMemory:
11593	* @doc: the document the chunk pertains to
11594	* @sax: the SAX handler bloc (possibly NULL)
11595	* @user_data: The user data returned on SAX callbacks (possibly NULL)
11596	* @depth: Used for loop detection, use 0
11597	* @string: the input string in UTF8 or ISO-Latin (zero terminated)
11598	* @lst: the return value for the set of parsed nodes
11599	*
11600	* Parse a well-balanced chunk of an XML document
11601	* called by the parser
11602	* The allowed sequence for the Well Balanced Chunk is the one defined by
11603	* the content production in the XML grammar:
11604	*
11605	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
11606	*
11607	* Returns 0 if the chunk is well balanced, -1 in case of args problem and
11608	* the parser error code otherwise
11609	*/
11610
11611	int
11612	xmlParseBalancedChunkMemory(xmlDocPtr doc, xmlSAXHandlerPtr sax,
11613	void user_data, int depth, const xmlChar string, xmlNodePtr *lst) {
11614	return xmlParseBalancedChunkMemoryRecover( doc, sax, user_data,
11615	depth, string, lst, 0 );
11616	}
11617	#endif /* LIBXML_SAX1_ENABLED */
11618
11619	/**
11620	* xmlParseBalancedChunkMemoryInternal:
11621	* @oldctxt: the existing parsing context
11622	* @string: the input string in UTF8 or ISO-Latin (zero terminated)
11623	* @user_data: the user data field for the parser context
11624	* @lst: the return value for the set of parsed nodes
11625	*
11626	*
11627	* Parse a well-balanced chunk of an XML document
11628	* called by the parser
11629	* The allowed sequence for the Well Balanced Chunk is the one defined by
11630	* the content production in the XML grammar:
11631	*
11632	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
11633	*
11634	* Returns XML_ERR_OK if the chunk is well balanced, and the parser
11635	* error code otherwise
11636	*
11637	* In case recover is set to 1, the nodelist will not be empty even if
11638	* the parsed chunk is not well balanced.
11639	*/
11640	static xmlParserErrors
11641	xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
11642	const xmlChar string, void user_data, xmlNodePtr *lst) {
11643	xmlParserCtxtPtr ctxt;
11644	xmlDocPtr newDoc = NULL;
11645	xmlNodePtr newRoot;
11646	xmlSAXHandlerPtr oldsax = NULL;
11647	xmlNodePtr content = NULL;
11648	xmlNodePtr last = NULL;
11649	int size;
11650	xmlParserErrors ret = XML_ERR_OK;
11651
11652	if ((oldctxt->depth > 40) \|\| (oldctxt->nbentities >= 500000)) {
11653	return(XML_ERR_ENTITY_LOOP);
11654	}
11655
11656
11657	if (lst != NULL)
11658	*lst = NULL;
11659	if (string == NULL)
11660	return(XML_ERR_INTERNAL_ERROR);
11661
11662	size = xmlStrlen(string);
11663
11664	ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
11665	if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
11666	if (user_data != NULL)
11667	ctxt->userData = user_data;
11668	else
11669	ctxt->userData = ctxt;
11670	if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
11671	ctxt->dict = oldctxt->dict;
11672	ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
11673	ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
11674	ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
11675
11676	oldsax = ctxt->sax;
11677	ctxt->sax = oldctxt->sax;
11678	xmlDetectSAX2(ctxt);
11679	ctxt->replaceEntities = oldctxt->replaceEntities;
11680	ctxt->options = oldctxt->options;
11681
11682	ctxt->_private = oldctxt->_private;
11683	if (oldctxt->myDoc == NULL) {
11684	newDoc = xmlNewDoc(BAD_CAST "1.0");
11685	if (newDoc == NULL) {
11686	ctxt->sax = oldsax;
11687	ctxt->dict = NULL;
11688	xmlFreeParserCtxt(ctxt);
11689	return(XML_ERR_INTERNAL_ERROR);
11690	}
11691	newDoc->dict = ctxt->dict;
11692	xmlDictReference(newDoc->dict);
11693	ctxt->myDoc = newDoc;
11694	} else {
11695	ctxt->myDoc = oldctxt->myDoc;
11696	content = ctxt->myDoc->children;
11697	last = ctxt->myDoc->last;
11698	}
11699	newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL);
11700	if (newRoot == NULL) {
11701	ctxt->sax = oldsax;
11702	ctxt->dict = NULL;
11703	xmlFreeParserCtxt(ctxt);
11704	if (newDoc != NULL) {
11705	xmlFreeDoc(newDoc);
11706	}
11707	return(XML_ERR_INTERNAL_ERROR);
11708	}
11709	ctxt->myDoc->children = NULL;
11710	ctxt->myDoc->last = NULL;
11711	xmlAddChild((xmlNodePtr) ctxt->myDoc, newRoot);
11712	nodePush(ctxt, ctxt->myDoc->children);
11713	ctxt->instate = XML_PARSER_CONTENT;
11714	ctxt->depth = oldctxt->depth + 1;
11715
11716	ctxt->validate = 0;
11717	ctxt->loadsubset = oldctxt->loadsubset;
11718	if ((oldctxt->validate) \|\| (oldctxt->replaceEntities != 0)) {
11719	/*
11720	* ID/IDREF registration will be done in xmlValidateElement below
11721	*/
11722	ctxt->loadsubset \|= XML_SKIP_IDS;
11723	}
11724	ctxt->dictNames = oldctxt->dictNames;
11725	ctxt->attsDefault = oldctxt->attsDefault;
11726	ctxt->attsSpecial = oldctxt->attsSpecial;
11727
11728	xmlParseContent(ctxt);
11729	if ((RAW == '<') && (NXT(1) == '/')) {
11730	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11731	} else if (RAW != 0) {
11732	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11733	}
11734	if (ctxt->node != ctxt->myDoc->children) {
11735	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11736	}
11737
11738	if (!ctxt->wellFormed) {
11739	if (ctxt->errNo == 0)
11740	ret = XML_ERR_INTERNAL_ERROR;
11741	else
11742	ret = (xmlParserErrors)ctxt->errNo;
11743	} else {
11744	ret = XML_ERR_OK;
11745	}
11746
11747	if ((lst != NULL) && (ret == XML_ERR_OK)) {
11748	xmlNodePtr cur;
11749
11750	/*
11751	* Return the newly created nodeset after unlinking it from
11752	* they pseudo parent.
11753	*/
11754	cur = ctxt->myDoc->children->children;
11755	*lst = cur;
11756	while (cur != NULL) {
11757	#ifdef LIBXML_VALID_ENABLED
11758	if ((oldctxt->validate) && (oldctxt->wellFormed) &&
11759	(oldctxt->myDoc) && (oldctxt->myDoc->intSubset) &&
11760	(cur->type == XML_ELEMENT_NODE)) {
11761	oldctxt->valid &= xmlValidateElement(&oldctxt->vctxt,
11762	oldctxt->myDoc, cur);
11763	}
11764	#endif /* LIBXML_VALID_ENABLED */
11765	cur->parent = NULL;
11766	cur = cur->next;
11767	}
11768	ctxt->myDoc->children->children = NULL;
11769	}
11770	if (ctxt->myDoc != NULL) {
11771	xmlFreeNode(ctxt->myDoc->children);
11772	ctxt->myDoc->children = content;
11773	ctxt->myDoc->last = last;
11774	}
11775
11776	oldctxt->nbentities += ctxt->nbentities;
11777	ctxt->sax = oldsax;
11778	ctxt->dict = NULL;
11779	ctxt->attsDefault = NULL;
11780	ctxt->attsSpecial = NULL;
11781	xmlFreeParserCtxt(ctxt);
11782	if (newDoc != NULL) {
11783	xmlFreeDoc(newDoc);
11784	}
11785
11786	return(ret);
11787	}
11788
11789	/**
11790	* xmlParseInNodeContext:
11791	* @node: the context node
11792	* @data: the input string
11793	* @datalen: the input string length in bytes
11794	* @options: a combination of xmlParserOption
11795	* @lst: the return value for the set of parsed nodes
11796	*
11797	* Parse a well-balanced chunk of an XML document
11798	* within the context (DTD, namespaces, etc ...) of the given node.
11799	*
11800	* The allowed sequence for the data is a Well Balanced Chunk defined by
11801	* the content production in the XML grammar:
11802	*
11803	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
11804	*
11805	* Returns XML_ERR_OK if the chunk is well balanced, and the parser
11806	* error code otherwise
11807	*/
11808	xmlParserErrors
11809	xmlParseInNodeContext(xmlNodePtr node, const char *data, int datalen,
11810	int options, xmlNodePtr *lst) {
11811	#ifdef SAX2
11812	xmlParserCtxtPtr ctxt;
11813	xmlDocPtr doc = NULL;
11814	xmlNodePtr fake, cur;
11815	int nsnr = 0;
11816
11817	xmlParserErrors ret = XML_ERR_OK;
11818
11819	/*
11820	* check all input parameters, grab the document
11821	*/
11822	if ((lst == NULL) \|\| (node == NULL) \|\| (data == NULL) \|\| (datalen < 0))
11823	return(XML_ERR_INTERNAL_ERROR);
11824	switch (node->type) {
11825	case XML_ELEMENT_NODE:
11826	case XML_ATTRIBUTE_NODE:
11827	case XML_TEXT_NODE:
11828	case XML_CDATA_SECTION_NODE:
11829	case XML_ENTITY_REF_NODE:
11830	case XML_PI_NODE:
11831	case XML_COMMENT_NODE:
11832	case XML_DOCUMENT_NODE:
11833	case XML_HTML_DOCUMENT_NODE:
11834	break;
11835	default:
11836	return(XML_ERR_INTERNAL_ERROR);
11837
11838	}
11839	while ((node != NULL) && (node->type != XML_ELEMENT_NODE) &&
11840	(node->type != XML_DOCUMENT_NODE) &&
11841	(node->type != XML_HTML_DOCUMENT_NODE))
11842	node = node->parent;
11843	if (node == NULL)
11844	return(XML_ERR_INTERNAL_ERROR);
11845	if (node->type == XML_ELEMENT_NODE)
11846	doc = node->doc;
11847	else
11848	doc = (xmlDocPtr) node;
11849	if (doc == NULL)
11850	return(XML_ERR_INTERNAL_ERROR);
11851
11852	/*
11853	* allocate a context and set-up everything not related to the
11854	* node position in the tree
11855	*/
11856	if (doc->type == XML_DOCUMENT_NODE)
11857	ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen);
11858	#ifdef LIBXML_HTML_ENABLED
11859	else if (doc->type == XML_HTML_DOCUMENT_NODE)
11860	ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen);
11861	#endif
11862	else
11863	return(XML_ERR_INTERNAL_ERROR);
11864
11865	if (ctxt == NULL)
11866	return(XML_ERR_NO_MEMORY);
11867	fake = xmlNewComment(NULL);
11868	if (fake == NULL) {
11869	xmlFreeParserCtxt(ctxt);
11870	return(XML_ERR_NO_MEMORY);
11871	}
11872	xmlAddChild(node, fake);
11873
11874	/*
11875	* Use input doc's dict if present, else assure XML_PARSE_NODICT is set.
11876	* We need a dictionary for xmlDetectSAX2, so if there's no doc dict
11877	* we must wait until the last moment to free the original one.
11878	*/
11879	if (doc->dict != NULL) {
11880	if (ctxt->dict != NULL)
11881	xmlDictFree(ctxt->dict);
11882	ctxt->dict = doc->dict;
11883	} else
11884	options \|= XML_PARSE_NODICT;
11885
11886	xmlCtxtUseOptions(ctxt, options);
11887	xmlDetectSAX2(ctxt);
11888	ctxt->myDoc = doc;
11889
11890	if (node->type == XML_ELEMENT_NODE) {
11891	nodePush(ctxt, node);
11892	/*
11893	* initialize the SAX2 namespaces stack
11894	*/
11895	cur = node;
11896	while ((cur != NULL) && (cur->type == XML_ELEMENT_NODE)) {
11897	xmlNsPtr ns = cur->nsDef;
11898	const xmlChar iprefix, ihref;
11899
11900	while (ns != NULL) {
11901	if (ctxt->dict) {
11902	iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1);
11903	ihref = xmlDictLookup(ctxt->dict, ns->href, -1);
11904	} else {
11905	iprefix = ns->prefix;
11906	ihref = ns->href;
11907	}
11908
11909	if (xmlGetNamespace(ctxt, iprefix) == NULL) {
11910	nsPush(ctxt, iprefix, ihref);
11911	nsnr++;
11912	}
11913	ns = ns->next;
11914	}
11915	cur = cur->parent;
11916	}
11917	ctxt->instate = XML_PARSER_CONTENT;
11918	}
11919
11920	if ((ctxt->validate) \|\| (ctxt->replaceEntities != 0)) {
11921	/*
11922	* ID/IDREF registration will be done in xmlValidateElement below
11923	*/
11924	ctxt->loadsubset \|= XML_SKIP_IDS;
11925	}
11926
11927	#ifdef LIBXML_HTML_ENABLED
11928	if (doc->type == XML_HTML_DOCUMENT_NODE)
11929	__htmlParseContent(ctxt);
11930	else
11931	#endif
11932	xmlParseContent(ctxt);
11933
11934	nsPop(ctxt, nsnr);
11935	if ((RAW == '<') && (NXT(1) == '/')) {
11936	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11937	} else if (RAW != 0) {
11938	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11939	}
11940	if ((ctxt->node != NULL) && (ctxt->node != node)) {
11941	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11942	ctxt->wellFormed = 0;
11943	}
11944
11945	if (!ctxt->wellFormed) {
11946	if (ctxt->errNo == 0)
11947	ret = XML_ERR_INTERNAL_ERROR;
11948	else
11949	ret = (xmlParserErrors)ctxt->errNo;
11950	} else {
11951	ret = XML_ERR_OK;
11952	}
11953
11954	/*
11955	* Return the newly created nodeset after unlinking it from
11956	* the pseudo sibling.
11957	*/
11958
11959	cur = fake->next;
11960	fake->next = NULL;
11961	node->last = fake;
11962
11963	if (cur != NULL) {
11964	cur->prev = NULL;
11965	}
11966
11967	*lst = cur;
11968
11969	while (cur != NULL) {
11970	cur->parent = NULL;
11971	cur = cur->next;
11972	}
11973
11974	xmlUnlinkNode(fake);
11975	xmlFreeNode(fake);
11976
11977
11978	if (ret != XML_ERR_OK) {
11979	xmlFreeNodeList(*lst);
11980	*lst = NULL;
11981	}
11982
11983	if (doc->dict != NULL)
11984	ctxt->dict = NULL;
11985	xmlFreeParserCtxt(ctxt);
11986
11987	return(ret);
11988	#else /* !SAX2 */
11989	return(XML_ERR_INTERNAL_ERROR);
11990	#endif
11991	}
11992
11993	#ifdef LIBXML_SAX1_ENABLED
11994	/**
11995	* xmlParseBalancedChunkMemoryRecover:
11996	* @doc: the document the chunk pertains to
11997	* @sax: the SAX handler bloc (possibly NULL)
11998	* @user_data: The user data returned on SAX callbacks (possibly NULL)
11999	* @depth: Used for loop detection, use 0
12000	* @string: the input string in UTF8 or ISO-Latin (zero terminated)
12001	* @lst: the return value for the set of parsed nodes
12002	* @recover: return nodes even if the data is broken (use 0)
12003	*
12004	*
12005	* Parse a well-balanced chunk of an XML document
12006	* called by the parser
12007	* The allowed sequence for the Well Balanced Chunk is the one defined by
12008	* the content production in the XML grammar:
12009	*
12010	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
12011	*
12012	* Returns 0 if the chunk is well balanced, -1 in case of args problem and
12013	* the parser error code otherwise
12014	*
12015	* In case recover is set to 1, the nodelist will not be empty even if
12016	* the parsed chunk is not well balanced.
12017	*/
12018	int
12019	xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, xmlSAXHandlerPtr sax,
12020	void user_data, int depth, const xmlChar string, xmlNodePtr *lst,
12021	int recover) {
12022	xmlParserCtxtPtr ctxt;
12023	xmlDocPtr newDoc;
12024	xmlSAXHandlerPtr oldsax = NULL;
12025	xmlNodePtr content, newRoot;
12026	int size;
12027	int ret = 0;
12028
12029	if (depth > 40) {
12030	return(XML_ERR_ENTITY_LOOP);
12031	}
12032
12033
12034	if (lst != NULL)
12035	*lst = NULL;
12036	if (string == NULL)
12037	return(-1);
12038
12039	size = xmlStrlen(string);
12040
12041	ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
12042	if (ctxt == NULL) return(-1);
12043	ctxt->userData = ctxt;
12044	if (sax != NULL) {
12045	oldsax = ctxt->sax;
12046	ctxt->sax = sax;
12047	if (user_data != NULL)
12048	ctxt->userData = user_data;
12049	}
12050	newDoc = xmlNewDoc(BAD_CAST "1.0");
12051	if (newDoc == NULL) {
12052	xmlFreeParserCtxt(ctxt);
12053	return(-1);
12054	}
12055	if ((doc != NULL) && (doc->dict != NULL)) {
12056	xmlDictFree(ctxt->dict);
12057	ctxt->dict = doc->dict;
12058	xmlDictReference(ctxt->dict);
12059	ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
12060	ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
12061	ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
12062	ctxt->dictNames = 1;
12063	} else {
12064	xmlCtxtUseOptions(ctxt, XML_PARSE_NODICT);
12065	}
12066	if (doc != NULL) {
12067	newDoc->intSubset = doc->intSubset;
12068	newDoc->extSubset = doc->extSubset;
12069	}
12070	newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
12071	if (newRoot == NULL) {
12072	if (sax != NULL)
12073	ctxt->sax = oldsax;
12074	xmlFreeParserCtxt(ctxt);
12075	newDoc->intSubset = NULL;
12076	newDoc->extSubset = NULL;
12077	xmlFreeDoc(newDoc);
12078	return(-1);
12079	}
12080	xmlAddChild((xmlNodePtr) newDoc, newRoot);
12081	nodePush(ctxt, newRoot);
12082	if (doc == NULL) {
12083	ctxt->myDoc = newDoc;
12084	} else {
12085	ctxt->myDoc = newDoc;
12086	newDoc->children->doc = doc;
12087	/* Ensure that doc has XML spec namespace */
12088	xmlSearchNsByHref(doc, (xmlNodePtr)doc, XML_XML_NAMESPACE);
12089	newDoc->oldNs = doc->oldNs;
12090	}
12091	ctxt->instate = XML_PARSER_CONTENT;
12092	ctxt->depth = depth;
12093
12094	/*
12095	* Doing validity checking on chunk doesn't make sense
12096	*/
12097	ctxt->validate = 0;
12098	ctxt->loadsubset = 0;
12099	xmlDetectSAX2(ctxt);
12100
12101	if ( doc != NULL ){
12102	content = doc->children;
12103	doc->children = NULL;
12104	xmlParseContent(ctxt);
12105	doc->children = content;
12106	}
12107	else {
12108	xmlParseContent(ctxt);
12109	}
12110	if ((RAW == '<') && (NXT(1) == '/')) {
12111	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12112	} else if (RAW != 0) {
12113	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
12114	}
12115	if (ctxt->node != newDoc->children) {
12116	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12117	}
12118
12119	if (!ctxt->wellFormed) {
12120	if (ctxt->errNo == 0)
12121	ret = 1;
12122	else
12123	ret = ctxt->errNo;
12124	} else {
12125	ret = 0;
12126	}
12127
12128	if ((lst != NULL) && ((ret == 0) \|\| (recover == 1))) {
12129	xmlNodePtr cur;
12130
12131	/*
12132	* Return the newly created nodeset after unlinking it from
12133	* they pseudo parent.
12134	*/
12135	cur = newDoc->children->children;
12136	*lst = cur;
12137	while (cur != NULL) {
12138	xmlSetTreeDoc(cur, doc);
12139	cur->parent = NULL;
12140	cur = cur->next;
12141	}
12142	newDoc->children->children = NULL;
12143	}
12144
12145	if (sax != NULL)
12146	ctxt->sax = oldsax;
12147	xmlFreeParserCtxt(ctxt);
12148	newDoc->intSubset = NULL;
12149	newDoc->extSubset = NULL;
12150	newDoc->oldNs = NULL;
12151	xmlFreeDoc(newDoc);
12152
12153	return(ret);
12154	}
12155
12156	/**
12157	* xmlSAXParseEntity:
12158	* @sax: the SAX handler block
12159	* @filename: the filename
12160	*
12161	* parse an XML external entity out of context and build a tree.
12162	* It use the given SAX function block to handle the parsing callback.
12163	* If sax is NULL, fallback to the default DOM tree building routines.
12164	*
12165	* [78] extParsedEnt ::= TextDecl? content
12166	*
12167	* This correspond to a "Well Balanced" chunk
12168	*
12169	* Returns the resulting document tree
12170	*/
12171
12172	xmlDocPtr
12173	xmlSAXParseEntity(xmlSAXHandlerPtr sax, const char *filename) {
12174	xmlDocPtr ret;
12175	xmlParserCtxtPtr ctxt;
12176
12177	ctxt = xmlCreateFileParserCtxt(filename);
12178	if (ctxt == NULL) {
12179	return(NULL);
12180	}
12181	if (sax != NULL) {
12182	if (ctxt->sax != NULL)
12183	xmlFree(ctxt->sax);
12184	ctxt->sax = sax;
12185	ctxt->userData = NULL;
12186	}
12187
12188	xmlParseExtParsedEnt(ctxt);
12189
12190	if (ctxt->wellFormed)
12191	ret = ctxt->myDoc;
12192	else {
12193	ret = NULL;
12194	xmlFreeDoc(ctxt->myDoc);
12195	ctxt->myDoc = NULL;
12196	}
12197	if (sax != NULL)
12198	ctxt->sax = NULL;
12199	xmlFreeParserCtxt(ctxt);
12200
12201	return(ret);
12202	}
12203
12204	/**
12205	* xmlParseEntity:
12206	* @filename: the filename
12207	*
12208	* parse an XML external entity out of context and build a tree.
12209	*
12210	* [78] extParsedEnt ::= TextDecl? content
12211	*
12212	* This correspond to a "Well Balanced" chunk
12213	*
12214	* Returns the resulting document tree
12215	*/
12216
12217	xmlDocPtr
12218	xmlParseEntity(const char *filename) {
12219	return(xmlSAXParseEntity(NULL, filename));
12220	}
12221	#endif /* LIBXML_SAX1_ENABLED */
12222
12223	/**
12224	* xmlCreateEntityParserCtxt:
12225	* @URL: the entity URL
12226	* @ID: the entity PUBLIC ID
12227	* @base: a possible base for the target URI
12228	*
12229	* Create a parser context for an external entity
12230	* Automatic support for ZLIB/Compress compressed document is provided
12231	* by default if found at compile-time.
12232	*
12233	* Returns the new parser context or NULL
12234	*/
12235	xmlParserCtxtPtr
12236	xmlCreateEntityParserCtxt(const xmlChar URL, const xmlChar ID,
12237	const xmlChar *base) {
12238	xmlParserCtxtPtr ctxt;
12239	xmlParserInputPtr inputStream;
12240	char *directory = NULL;
12241	xmlChar *uri;
12242
12243	ctxt = xmlNewParserCtxt();
12244	if (ctxt == NULL) {
12245	return(NULL);
12246	}
12247
12248	uri = xmlBuildURI(URL, base);
12249
12250	if (uri == NULL) {
12251	inputStream = xmlLoadExternalEntity((char )URL, (char )ID, ctxt);
12252	if (inputStream == NULL) {
12253	xmlFreeParserCtxt(ctxt);
12254	return(NULL);
12255	}
12256
12257	inputPush(ctxt, inputStream);
12258
12259	if ((ctxt->directory == NULL) && (directory == NULL))
12260	directory = xmlParserGetDirectory((char *)URL);
12261	if ((ctxt->directory == NULL) && (directory != NULL))
12262	ctxt->directory = directory;
12263	} else {
12264	inputStream = xmlLoadExternalEntity((char )uri, (char )ID, ctxt);
12265	if (inputStream == NULL) {
12266	xmlFree(uri);
12267	xmlFreeParserCtxt(ctxt);
12268	return(NULL);
12269	}
12270
12271	inputPush(ctxt, inputStream);
12272
12273	if ((ctxt->directory == NULL) && (directory == NULL))
12274	directory = xmlParserGetDirectory((char *)uri);
12275	if ((ctxt->directory == NULL) && (directory != NULL))
12276	ctxt->directory = directory;
12277	xmlFree(uri);
12278	}
12279	return(ctxt);
12280	}
12281
12282	/************************************************************************
12283	* *
12284	* Front ends when parsing from a file *
12285	* *
12286	************************************************************************/
12287
12288	/**
12289	* xmlCreateURLParserCtxt:
12290	* @filename: the filename or URL
12291	* @options: a combination of xmlParserOption
12292	*
12293	* Create a parser context for a file or URL content.
12294	* Automatic support for ZLIB/Compress compressed document is provided
12295	* by default if found at compile-time and for file accesses
12296	*
12297	* Returns the new parser context or NULL
12298	*/
12299	xmlParserCtxtPtr
12300	xmlCreateURLParserCtxt(const char *filename, int options)
12301	{
12302	xmlParserCtxtPtr ctxt;
12303	xmlParserInputPtr inputStream;
12304	char *directory = NULL;
12305
12306	ctxt = xmlNewParserCtxt();
12307	if (ctxt == NULL) {
12308	xmlErrMemory(NULL, "cannot allocate parser context");
12309	return(NULL);
12310	}
12311
12312	if (options)
12313	xmlCtxtUseOptions(ctxt, options);
12314	ctxt->linenumbers = 1;
12315
12316	inputStream = xmlLoadExternalEntity(filename, NULL, ctxt);
12317	if (inputStream == NULL) {
12318	xmlFreeParserCtxt(ctxt);
12319	return(NULL);
12320	}
12321
12322	inputPush(ctxt, inputStream);
12323	if ((ctxt->directory == NULL) && (directory == NULL))
12324	directory = xmlParserGetDirectory(filename);
12325	if ((ctxt->directory == NULL) && (directory != NULL))
12326	ctxt->directory = directory;
12327
12328	return(ctxt);
12329	}
12330
12331	/**
12332	* xmlCreateFileParserCtxt:
12333	* @filename: the filename
12334	*
12335	* Create a parser context for a file content.
12336	* Automatic support for ZLIB/Compress compressed document is provided
12337	* by default if found at compile-time.
12338	*
12339	* Returns the new parser context or NULL
12340	*/
12341	xmlParserCtxtPtr
12342	xmlCreateFileParserCtxt(const char *filename)
12343	{
12344	return(xmlCreateURLParserCtxt(filename, 0));
12345	}
12346
12347	#ifdef LIBXML_SAX1_ENABLED
12348	/**
12349	* xmlSAXParseFileWithData:
12350	* @sax: the SAX handler block
12351	* @filename: the filename
12352	* @recovery: work in recovery mode, i.e. tries to read no Well Formed
12353	* documents
12354	* @data: the userdata
12355	*
12356	* parse an XML file and build a tree. Automatic support for ZLIB/Compress
12357	* compressed document is provided by default if found at compile-time.
12358	* It use the given SAX function block to handle the parsing callback.
12359	* If sax is NULL, fallback to the default DOM tree building routines.
12360	*
12361	* User data (void *) is stored within the parser context in the
12362	* context's _private member, so it is available nearly everywhere in libxml
12363	*
12364	* Returns the resulting document tree
12365	*/
12366
12367	xmlDocPtr
12368	xmlSAXParseFileWithData(xmlSAXHandlerPtr sax, const char *filename,
12369	int recovery, void *data) {
12370	xmlDocPtr ret;
12371	xmlParserCtxtPtr ctxt;
12372	char *directory = NULL;
12373
12374	xmlInitParser();
12375
12376	ctxt = xmlCreateFileParserCtxt(filename);
12377	if (ctxt == NULL) {
12378	return(NULL);
12379	}
12380	if (sax != NULL) {
12381	if (ctxt->sax != NULL)
12382	xmlFree(ctxt->sax);
12383	ctxt->sax = sax;
12384	}
12385	xmlDetectSAX2(ctxt);
12386	if (data!=NULL) {
12387	ctxt->_private = data;
12388	}
12389
12390	if ((ctxt->directory == NULL) && (directory == NULL))
12391	directory = xmlParserGetDirectory(filename);
12392	if ((ctxt->directory == NULL) && (directory != NULL))
12393	ctxt->directory = (char ) xmlStrdup((xmlChar ) directory);
12394
12395	ctxt->recovery = recovery;
12396
12397	xmlParseDocument(ctxt);
12398
12399	if ((ctxt->wellFormed) \|\| recovery) {
12400	ret = ctxt->myDoc;
12401	if (ret != NULL) {
12402	if (ctxt->input->buf->compressed > 0)
12403	ret->compression = 9;
12404	else
12405	ret->compression = ctxt->input->buf->compressed;
12406	}
12407	}
12408	else {
12409	ret = NULL;
12410	xmlFreeDoc(ctxt->myDoc);
12411	ctxt->myDoc = NULL;
12412	}
12413	if (sax != NULL)
12414	ctxt->sax = NULL;
12415	xmlFreeParserCtxt(ctxt);
12416
12417	return(ret);
12418	}
12419
12420	/**
12421	* xmlSAXParseFile:
12422	* @sax: the SAX handler block
12423	* @filename: the filename
12424	* @recovery: work in recovery mode, i.e. tries to read no Well Formed
12425	* documents
12426	*
12427	* parse an XML file and build a tree. Automatic support for ZLIB/Compress
12428	* compressed document is provided by default if found at compile-time.
12429	* It use the given SAX function block to handle the parsing callback.
12430	* If sax is NULL, fallback to the default DOM tree building routines.
12431	*
12432	* Returns the resulting document tree
12433	*/
12434
12435	xmlDocPtr
12436	xmlSAXParseFile(xmlSAXHandlerPtr sax, const char *filename,
12437	int recovery) {
12438	return(xmlSAXParseFileWithData(sax,filename,recovery,NULL));
12439	}
12440
12441	/**
12442	* xmlRecoverDoc:
12443	* @cur: a pointer to an array of xmlChar
12444	*
12445	* parse an XML in-memory document and build a tree.
12446	* In the case the document is not Well Formed, a tree is built anyway
12447	*
12448	* Returns the resulting document tree
12449	*/
12450
12451	xmlDocPtr
12452	xmlRecoverDoc(xmlChar *cur) {
12453	return(xmlSAXParseDoc(NULL, cur, 1));
12454	}
12455
12456	/**
12457	* xmlParseFile:
12458	* @filename: the filename
12459	*
12460	* parse an XML file and build a tree. Automatic support for ZLIB/Compress
12461	* compressed document is provided by default if found at compile-time.
12462	*
12463	* Returns the resulting document tree if the file was wellformed,
12464	* NULL otherwise.
12465	*/
12466
12467	xmlDocPtr
12468	xmlParseFile(const char *filename) {
12469	return(xmlSAXParseFile(NULL, filename, 0));
12470	}
12471
12472	/**
12473	* xmlRecoverFile:
12474	* @filename: the filename
12475	*
12476	* parse an XML file and build a tree. Automatic support for ZLIB/Compress
12477	* compressed document is provided by default if found at compile-time.
12478	* In the case the document is not Well Formed, a tree is built anyway
12479	*
12480	* Returns the resulting document tree
12481	*/
12482
12483	xmlDocPtr
12484	xmlRecoverFile(const char *filename) {
12485	return(xmlSAXParseFile(NULL, filename, 1));
12486	}
12487
12488
12489	/**
12490	* xmlSetupParserForBuffer:
12491	* @ctxt: an XML parser context
12492	* @buffer: a xmlChar * buffer
12493	* @filename: a file name
12494	*
12495	* Setup the parser context to parse a new buffer; Clears any prior
12496	* contents from the parser context. The buffer parameter must not be
12497	* NULL, but the filename parameter can be
12498	*/
12499	void
12500	xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer,
12501	const char* filename)
12502	{
12503	xmlParserInputPtr input;
12504
12505	if ((ctxt == NULL) \|\| (buffer == NULL))
12506	return;
12507
12508	input = xmlNewInputStream(ctxt);
12509	if (input == NULL) {
12510	xmlErrMemory(NULL, "parsing new buffer: out of memory\n");
12511	xmlClearParserCtxt(ctxt);
12512	return;
12513	}
12514
12515	xmlClearParserCtxt(ctxt);
12516	if (filename != NULL)
12517	input->filename = (char ) xmlCanonicPath((const xmlChar )filename);
12518	input->base = buffer;
12519	input->cur = buffer;
12520	input->end = &buffer[xmlStrlen(buffer)];
12521	inputPush(ctxt, input);
12522	}
12523
12524	/**
12525	* xmlSAXUserParseFile:
12526	* @sax: a SAX handler
12527	* @user_data: The user data returned on SAX callbacks
12528	* @filename: a file name
12529	*
12530	* parse an XML file and call the given SAX handler routines.
12531	* Automatic support for ZLIB/Compress compressed document is provided
12532	*
12533	* Returns 0 in case of success or a error number otherwise
12534	*/
12535	int
12536	xmlSAXUserParseFile(xmlSAXHandlerPtr sax, void *user_data,
12537	const char *filename) {
12538	int ret = 0;
12539	xmlParserCtxtPtr ctxt;
12540
12541	ctxt = xmlCreateFileParserCtxt(filename);
12542	if (ctxt == NULL) return -1;
12543	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12544	xmlFree(ctxt->sax);
12545	ctxt->sax = sax;
12546	xmlDetectSAX2(ctxt);
12547
12548	if (user_data != NULL)
12549	ctxt->userData = user_data;
12550
12551	xmlParseDocument(ctxt);
12552
12553	if (ctxt->wellFormed)
12554	ret = 0;
12555	else {
12556	if (ctxt->errNo != 0)
12557	ret = ctxt->errNo;
12558	else
12559	ret = -1;
12560	}
12561	if (sax != NULL)
12562	ctxt->sax = NULL;
12563	if (ctxt->myDoc != NULL) {
12564	xmlFreeDoc(ctxt->myDoc);
12565	ctxt->myDoc = NULL;
12566	}
12567	xmlFreeParserCtxt(ctxt);
12568
12569	return ret;
12570	}
12571	#endif /* LIBXML_SAX1_ENABLED */
12572
12573	/************************************************************************
12574	* *
12575	* Front ends when parsing from memory *
12576	* *
12577	************************************************************************/
12578
12579	/**
12580	* xmlCreateMemoryParserCtxt:
12581	* @buffer: a pointer to a char array
12582	* @size: the size of the array
12583	*
12584	* Create a parser context for an XML in-memory document.
12585	*
12586	* Returns the new parser context or NULL
12587	*/
12588	xmlParserCtxtPtr
12589	xmlCreateMemoryParserCtxt(const char *buffer, int size) {
12590	xmlParserCtxtPtr ctxt;
12591	xmlParserInputPtr input;
12592	xmlParserInputBufferPtr buf;
12593
12594	if (buffer == NULL)
12595	return(NULL);
12596	if (size <= 0)
12597	return(NULL);
12598
12599	ctxt = xmlNewParserCtxt();
12600	if (ctxt == NULL)
12601	return(NULL);
12602
12603	/* TODO: xmlParserInputBufferCreateStatic, requires some serious changes */
12604	buf = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
12605	if (buf == NULL) {
12606	xmlFreeParserCtxt(ctxt);
12607	return(NULL);
12608	}
12609
12610	input = xmlNewInputStream(ctxt);
12611	if (input == NULL) {
12612	xmlFreeParserInputBuffer(buf);
12613	xmlFreeParserCtxt(ctxt);
12614	return(NULL);
12615	}
12616
12617	input->filename = NULL;
12618	input->buf = buf;
12619	input->base = input->buf->buffer->content;
12620	input->cur = input->buf->buffer->content;
12621	input->end = &input->buf->buffer->content[input->buf->buffer->use];
12622
12623	inputPush(ctxt, input);
12624	return(ctxt);
12625	}
12626
12627	#ifdef LIBXML_SAX1_ENABLED
12628	/**
12629	* xmlSAXParseMemoryWithData:
12630	* @sax: the SAX handler block
12631	* @buffer: an pointer to a char array
12632	* @size: the size of the array
12633	* @recovery: work in recovery mode, i.e. tries to read no Well Formed
12634	* documents
12635	* @data: the userdata
12636	*
12637	* parse an XML in-memory block and use the given SAX function block
12638	* to handle the parsing callback. If sax is NULL, fallback to the default
12639	* DOM tree building routines.
12640	*
12641	* User data (void *) is stored within the parser context in the
12642	* context's _private member, so it is available nearly everywhere in libxml
12643	*
12644	* Returns the resulting document tree
12645	*/
12646
12647	xmlDocPtr
12648	xmlSAXParseMemoryWithData(xmlSAXHandlerPtr sax, const char *buffer,
12649	int size, int recovery, void *data) {
12650	xmlDocPtr ret;
12651	xmlParserCtxtPtr ctxt;
12652
12653	ctxt = xmlCreateMemoryParserCtxt(buffer, size);
12654	if (ctxt == NULL) return(NULL);
12655	if (sax != NULL) {
12656	if (ctxt->sax != NULL)
12657	xmlFree(ctxt->sax);
12658	ctxt->sax = sax;
12659	}
12660	xmlDetectSAX2(ctxt);
12661	if (data!=NULL) {
12662	ctxt->_private=data;
12663	}
12664
12665	ctxt->recovery = recovery;
12666
12667	xmlParseDocument(ctxt);
12668
12669	if ((ctxt->wellFormed) \|\| recovery) ret = ctxt->myDoc;
12670	else {
12671	ret = NULL;
12672	xmlFreeDoc(ctxt->myDoc);
12673	ctxt->myDoc = NULL;
12674	}
12675	if (sax != NULL)
12676	ctxt->sax = NULL;
12677	xmlFreeParserCtxt(ctxt);
12678
12679	return(ret);
12680	}
12681
12682	/**
12683	* xmlSAXParseMemory:
12684	* @sax: the SAX handler block
12685	* @buffer: an pointer to a char array
12686	* @size: the size of the array
12687	* @recovery: work in recovery mode, i.e. tries to read not Well Formed
12688	* documents
12689	*
12690	* parse an XML in-memory block and use the given SAX function block
12691	* to handle the parsing callback. If sax is NULL, fallback to the default
12692	* DOM tree building routines.
12693	*
12694	* Returns the resulting document tree
12695	*/
12696	xmlDocPtr
12697	xmlSAXParseMemory(xmlSAXHandlerPtr sax, const char *buffer,
12698	int size, int recovery) {
12699	return xmlSAXParseMemoryWithData(sax, buffer, size, recovery, NULL);
12700	}
12701
12702	/**
12703	* xmlParseMemory:
12704	* @buffer: an pointer to a char array
12705	* @size: the size of the array
12706	*
12707	* parse an XML in-memory block and build a tree.
12708	*
12709	* Returns the resulting document tree
12710	*/
12711
12712	xmlDocPtr xmlParseMemory(const char *buffer, int size) {
12713	return(xmlSAXParseMemory(NULL, buffer, size, 0));
12714	}
12715
12716	/**
12717	* xmlRecoverMemory:
12718	* @buffer: an pointer to a char array
12719	* @size: the size of the array
12720	*
12721	* parse an XML in-memory block and build a tree.
12722	* In the case the document is not Well Formed, a tree is built anyway
12723	*
12724	* Returns the resulting document tree
12725	*/
12726
12727	xmlDocPtr xmlRecoverMemory(const char *buffer, int size) {
12728	return(xmlSAXParseMemory(NULL, buffer, size, 1));
12729	}
12730
12731	/**
12732	* xmlSAXUserParseMemory:
12733	* @sax: a SAX handler
12734	* @user_data: The user data returned on SAX callbacks
12735	* @buffer: an in-memory XML document input
12736	* @size: the length of the XML document in bytes
12737	*
12738	* A better SAX parsing routine.
12739	* parse an XML in-memory buffer and call the given SAX handler routines.
12740	*
12741	* Returns 0 in case of success or a error number otherwise
12742	*/
12743	int xmlSAXUserParseMemory(xmlSAXHandlerPtr sax, void *user_data,
12744	const char *buffer, int size) {
12745	int ret = 0;
12746	xmlParserCtxtPtr ctxt;
12747
12748	ctxt = xmlCreateMemoryParserCtxt(buffer, size);
12749	if (ctxt == NULL) return -1;
12750	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12751	xmlFree(ctxt->sax);
12752	ctxt->sax = sax;
12753	xmlDetectSAX2(ctxt);
12754
12755	if (user_data != NULL)
12756	ctxt->userData = user_data;
12757
12758	xmlParseDocument(ctxt);
12759
12760	if (ctxt->wellFormed)
12761	ret = 0;
12762	else {
12763	if (ctxt->errNo != 0)
12764	ret = ctxt->errNo;
12765	else
12766	ret = -1;
12767	}
12768	if (sax != NULL)
12769	ctxt->sax = NULL;
12770	if (ctxt->myDoc != NULL) {
12771	xmlFreeDoc(ctxt->myDoc);
12772	ctxt->myDoc = NULL;
12773	}
12774	xmlFreeParserCtxt(ctxt);
12775
12776	return ret;
12777	}
12778	#endif /* LIBXML_SAX1_ENABLED */
12779
12780	/**
12781	* xmlCreateDocParserCtxt:
12782	* @cur: a pointer to an array of xmlChar
12783	*
12784	* Creates a parser context for an XML in-memory document.
12785	*
12786	* Returns the new parser context or NULL
12787	*/
12788	xmlParserCtxtPtr
12789	xmlCreateDocParserCtxt(const xmlChar *cur) {
12790	int len;
12791
12792	if (cur == NULL)
12793	return(NULL);
12794	len = xmlStrlen(cur);
12795	return(xmlCreateMemoryParserCtxt((const char *)cur, len));
12796	}
12797
12798	#ifdef LIBXML_SAX1_ENABLED
12799	/**
12800	* xmlSAXParseDoc:
12801	* @sax: the SAX handler block
12802	* @cur: a pointer to an array of xmlChar
12803	* @recovery: work in recovery mode, i.e. tries to read no Well Formed
12804	* documents
12805	*
12806	* parse an XML in-memory document and build a tree.
12807	* It use the given SAX function block to handle the parsing callback.
12808	* If sax is NULL, fallback to the default DOM tree building routines.
12809	*
12810	* Returns the resulting document tree
12811	*/
12812
12813	xmlDocPtr
12814	xmlSAXParseDoc(xmlSAXHandlerPtr sax, const xmlChar *cur, int recovery) {
12815	xmlDocPtr ret;
12816	xmlParserCtxtPtr ctxt;
12817	xmlSAXHandlerPtr oldsax = NULL;
12818
12819	if (cur == NULL) return(NULL);
12820
12821
12822	ctxt = xmlCreateDocParserCtxt(cur);
12823	if (ctxt == NULL) return(NULL);
12824	if (sax != NULL) {
12825	oldsax = ctxt->sax;
12826	ctxt->sax = sax;
12827	ctxt->userData = NULL;
12828	}
12829	xmlDetectSAX2(ctxt);
12830
12831	xmlParseDocument(ctxt);
12832	if ((ctxt->wellFormed) \|\| recovery) ret = ctxt->myDoc;
12833	else {
12834	ret = NULL;
12835	xmlFreeDoc(ctxt->myDoc);
12836	ctxt->myDoc = NULL;
12837	}
12838	if (sax != NULL)
12839	ctxt->sax = oldsax;
12840	xmlFreeParserCtxt(ctxt);
12841
12842	return(ret);
12843	}
12844
12845	/**
12846	* xmlParseDoc:
12847	* @cur: a pointer to an array of xmlChar
12848	*
12849	* parse an XML in-memory document and build a tree.
12850	*
12851	* Returns the resulting document tree
12852	*/
12853
12854	xmlDocPtr
12855	xmlParseDoc(const xmlChar *cur) {
12856	return(xmlSAXParseDoc(NULL, cur, 0));
12857	}
12858	#endif /* LIBXML_SAX1_ENABLED */
12859
12860	#ifdef LIBXML_LEGACY_ENABLED
12861	/************************************************************************
12862	* *
12863	* Specific function to keep track of entities references *
12864	* and used by the XSLT debugger *
12865	* *
12866	************************************************************************/
12867
12868	static xmlEntityReferenceFunc xmlEntityRefFunc = NULL;
12869
12870	/**
12871	* xmlAddEntityReference:
12872	* @ent : A valid entity
12873	* @firstNode : A valid first node for children of entity
12874	* @lastNode : A valid last node of children entity
12875	*
12876	* Notify of a reference to an entity of type XML_EXTERNAL_GENERAL_PARSED_ENTITY
12877	*/
12878	static void
12879	xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
12880	xmlNodePtr lastNode)
12881	{
12882	if (xmlEntityRefFunc != NULL) {
12883	(*xmlEntityRefFunc) (ent, firstNode, lastNode);
12884	}
12885	}
12886
12887
12888	/**
12889	* xmlSetEntityReferenceFunc:
12890	* @func: A valid function
12891	*
12892	* Set the function to call call back when a xml reference has been made
12893	*/
12894	void
12895	xmlSetEntityReferenceFunc(xmlEntityReferenceFunc func)
12896	{
12897	xmlEntityRefFunc = func;
12898	}
12899	#endif /* LIBXML_LEGACY_ENABLED */
12900
12901	/************************************************************************
12902	* *
12903	* Miscellaneous *
12904	* *
12905	************************************************************************/
12906
12907	#ifdef LIBXML_XPATH_ENABLED
12908	#include <libxml/xpath.h>
12909	#endif
12910
12911	extern void XMLCDECL xmlGenericErrorDefaultFunc(void ctx, const char msg, ...);
12912	static int xmlParserInitialized = 0;
12913
12914	/**
12915	* xmlInitParser:
12916	*
12917	* Initialization function for the XML parser.
12918	* This is not reentrant. Call once before processing in case of
12919	* use in multithreaded programs.
12920	*/
12921
12922	void
12923	xmlInitParser(void) {
12924	if (xmlParserInitialized != 0)
12925	return;
12926
12927	#ifdef LIBXML_THREAD_ENABLED
12928	__xmlGlobalInitMutexLock();
12929	if (xmlParserInitialized == 0) {
12930	#endif
12931	if ((xmlGenericError == xmlGenericErrorDefaultFunc) \|\|
12932	(xmlGenericError == NULL))
12933	initGenericErrorDefaultFunc(NULL);
12934	xmlInitGlobals();
12935	xmlInitThreads();
12936	xmlInitMemory();
12937	xmlInitCharEncodingHandlers();
12938	xmlDefaultSAXHandlerInit();
12939	xmlRegisterDefaultInputCallbacks();
12940	#ifdef LIBXML_OUTPUT_ENABLED
12941	xmlRegisterDefaultOutputCallbacks();
12942	#endif /* LIBXML_OUTPUT_ENABLED */
12943	#ifdef LIBXML_HTML_ENABLED
12944	htmlInitAutoClose();
12945	htmlDefaultSAXHandlerInit();
12946	#endif
12947	#ifdef LIBXML_XPATH_ENABLED
12948	xmlXPathInit();
12949	#endif
12950	xmlParserInitialized = 1;
12951	#ifdef LIBXML_THREAD_ENABLED
12952	}
12953	__xmlGlobalInitMutexUnlock();
12954	#endif
12955	}
12956
12957	/**
12958	* xmlCleanupParser:
12959	*
12960	* Cleanup function for the XML library. It tries to reclaim all
12961	* parsing related global memory allocated for the library processing.
12962	* It doesn't deallocate any document related memory. Calling this
12963	* function should not prevent reusing the library but one should
12964	* call xmlCleanupParser() only when the process has
12965	* finished using the library or XML document built with it.
12966	*/
12967
12968	void
12969	xmlCleanupParser(void) {
12970	if (!xmlParserInitialized)
12971	return;
12972
12973	xmlCleanupCharEncodingHandlers();
12974	#ifdef LIBXML_CATALOG_ENABLED
12975	xmlCatalogCleanup();
12976	#endif
12977	xmlDictCleanup();
12978	xmlCleanupInputCallbacks();
12979	#ifdef LIBXML_OUTPUT_ENABLED
12980	xmlCleanupOutputCallbacks();
12981	#endif
12982	#ifdef LIBXML_SCHEMAS_ENABLED
12983	xmlSchemaCleanupTypes();
12984	xmlRelaxNGCleanupTypes();
12985	#endif
12986	xmlCleanupGlobals();
12987	xmlResetLastError();
12988	xmlCleanupThreads(); /* must be last if called not from the main thread */
12989	xmlCleanupMemory();
12990	xmlParserInitialized = 0;
12991	}
12992
12993	/************************************************************************
12994	* *
12995	* New set (2.6.0) of simpler and more flexible APIs *
12996	* *
12997	************************************************************************/
12998
12999	/**
13000	* DICT_FREE:
13001	* @str: a string
13002	*
13003	* Free a string if it is not owned by the "dict" dictionnary in the
13004	* current scope
13005	*/
13006	#define DICT_FREE(str) \
13007	if ((str) && ((!dict) \|\| \
13008	(xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \
13009	xmlFree((char *)(str));
13010
13011	/**
13012	* xmlCtxtReset:
13013	* @ctxt: an XML parser context
13014	*
13015	* Reset a parser context
13016	*/
13017	void
13018	xmlCtxtReset(xmlParserCtxtPtr ctxt)
13019	{
13020	xmlParserInputPtr input;
13021	xmlDictPtr dict;
13022
13023	if (ctxt == NULL)
13024	return;
13025
13026	dict = ctxt->dict;
13027
13028	while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
13029	xmlFreeInputStream(input);
13030	}
13031	ctxt->inputNr = 0;
13032	ctxt->input = NULL;
13033
13034	ctxt->spaceNr = 0;
13035	if (ctxt->spaceTab != NULL) {
13036	ctxt->spaceTab[0] = -1;
13037	ctxt->space = &ctxt->spaceTab[0];
13038	} else {
13039	ctxt->space = NULL;
13040	}
13041
13042
13043	ctxt->nodeNr = 0;
13044	ctxt->node = NULL;
13045
13046	ctxt->nameNr = 0;
13047	ctxt->name = NULL;
13048
13049	DICT_FREE(ctxt->version);
13050	ctxt->version = NULL;
13051	DICT_FREE(ctxt->encoding);
13052	ctxt->encoding = NULL;
13053	DICT_FREE(ctxt->directory);
13054	ctxt->directory = NULL;
13055	DICT_FREE(ctxt->extSubURI);
13056	ctxt->extSubURI = NULL;
13057	DICT_FREE(ctxt->extSubSystem);
13058	ctxt->extSubSystem = NULL;
13059	if (ctxt->myDoc != NULL)
13060	xmlFreeDoc(ctxt->myDoc);
13061	ctxt->myDoc = NULL;
13062
13063	ctxt->standalone = -1;
13064	ctxt->hasExternalSubset = 0;
13065	ctxt->hasPErefs = 0;
13066	ctxt->html = 0;
13067	ctxt->external = 0;
13068	ctxt->instate = XML_PARSER_START;
13069	ctxt->token = 0;
13070
13071	ctxt->wellFormed = 1;
13072	ctxt->nsWellFormed = 1;
13073	ctxt->disableSAX = 0;
13074	ctxt->valid = 1;
13075	#if 0
13076	ctxt->vctxt.userData = ctxt;
13077	ctxt->vctxt.error = xmlParserValidityError;
13078	ctxt->vctxt.warning = xmlParserValidityWarning;
13079	#endif
13080	ctxt->record_info = 0;
13081	ctxt->nbChars = 0;
13082	ctxt->checkIndex = 0;
13083	ctxt->inSubset = 0;
13084	ctxt->errNo = XML_ERR_OK;
13085	ctxt->depth = 0;
13086	ctxt->charset = XML_CHAR_ENCODING_UTF8;
13087	ctxt->catalogs = NULL;
13088	ctxt->nbentities = 0;
13089	xmlInitNodeInfoSeq(&ctxt->node_seq);
13090
13091	if (ctxt->attsDefault != NULL) {
13092	xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
13093	ctxt->attsDefault = NULL;
13094	}
13095	if (ctxt->attsSpecial != NULL) {
13096	xmlHashFree(ctxt->attsSpecial, NULL);
13097	ctxt->attsSpecial = NULL;
13098	}
13099
13100	#ifdef LIBXML_CATALOG_ENABLED
13101	if (ctxt->catalogs != NULL)
13102	xmlCatalogFreeLocal(ctxt->catalogs);
13103	#endif
13104	if (ctxt->lastError.code != XML_ERR_OK)
13105	xmlResetError(&ctxt->lastError);
13106	}
13107
13108	/**
13109	* xmlCtxtResetPush:
13110	* @ctxt: an XML parser context
13111	* @chunk: a pointer to an array of chars
13112	* @size: number of chars in the array
13113	* @filename: an optional file name or URI
13114	* @encoding: the document encoding, or NULL
13115	*
13116	* Reset a push parser context
13117	*
13118	* Returns 0 in case of success and 1 in case of error
13119	*/
13120	int
13121	xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk,
13122	int size, const char filename, const char encoding)
13123	{
13124	xmlParserInputPtr inputStream;
13125	xmlParserInputBufferPtr buf;
13126	xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
13127
13128	if (ctxt == NULL)
13129	return(1);
13130
13131	if ((encoding == NULL) && (chunk != NULL) && (size >= 4))
13132	enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
13133
13134	buf = xmlAllocParserInputBuffer(enc);
13135	if (buf == NULL)
13136	return(1);
13137
13138	if (ctxt == NULL) {
13139	xmlFreeParserInputBuffer(buf);
13140	return(1);
13141	}
13142
13143	xmlCtxtReset(ctxt);
13144
13145	if (ctxt->pushTab == NULL) {
13146	ctxt->pushTab = (void *) xmlMalloc(ctxt->nameMax 3 *
13147	sizeof(xmlChar *));
13148	if (ctxt->pushTab == NULL) {
13149	xmlErrMemory(ctxt, NULL);
13150	xmlFreeParserInputBuffer(buf);
13151	return(1);
13152	}
13153	}
13154
13155	if (filename == NULL) {
13156	ctxt->directory = NULL;
13157	} else {
13158	ctxt->directory = xmlParserGetDirectory(filename);
13159	}
13160
13161	inputStream = xmlNewInputStream(ctxt);
13162	if (inputStream == NULL) {
13163	xmlFreeParserInputBuffer(buf);
13164	return(1);
13165	}
13166
13167	if (filename == NULL)
13168	inputStream->filename = NULL;
13169	else
13170	inputStream->filename = (char *)
13171	xmlCanonicPath((const xmlChar *) filename);
13172	inputStream->buf = buf;
13173	inputStream->base = inputStream->buf->buffer->content;
13174	inputStream->cur = inputStream->buf->buffer->content;
13175	inputStream->end =
13176	&inputStream->buf->buffer->content[inputStream->buf->buffer->use];
13177
13178	inputPush(ctxt, inputStream);
13179
13180	if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
13181	(ctxt->input->buf != NULL)) {
13182	int base = ctxt->input->base - ctxt->input->buf->buffer->content;
13183	int cur = ctxt->input->cur - ctxt->input->base;
13184
13185	xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
13186
13187	ctxt->input->base = ctxt->input->buf->buffer->content + base;
13188	ctxt->input->cur = ctxt->input->base + cur;
13189	ctxt->input->end =
13190	&ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->
13191	use];
13192	#ifdef DEBUG_PUSH
13193	xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
13194	#endif
13195	}
13196
13197	if (encoding != NULL) {
13198	xmlCharEncodingHandlerPtr hdlr;
13199
13200	hdlr = xmlFindCharEncodingHandler(encoding);
13201	if (hdlr != NULL) {
13202	xmlSwitchToEncoding(ctxt, hdlr);
13203	} else {
13204	xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
13205	"Unsupported encoding %s\n", BAD_CAST encoding);
13206	}
13207	} else if (enc != XML_CHAR_ENCODING_NONE) {
13208	xmlSwitchEncoding(ctxt, enc);
13209	}
13210
13211	return(0);
13212	}
13213
13214	/**
13215	* xmlCtxtUseOptions:
13216	* @ctxt: an XML parser context
13217	* @options: a combination of xmlParserOption
13218	*
13219	* Applies the options to the parser context
13220	*
13221	* Returns 0 in case of success, the set of unknown or unimplemented options
13222	* in case of error.
13223	*/
13224	int
13225	xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
13226	{
13227	if (ctxt == NULL)
13228	return(-1);
13229	if (options & XML_PARSE_RECOVER) {
13230	ctxt->recovery = 1;
13231	options -= XML_PARSE_RECOVER;
13232	} else
13233	ctxt->recovery = 0;
13234	if (options & XML_PARSE_DTDLOAD) {
13235	ctxt->loadsubset = XML_DETECT_IDS;
13236	options -= XML_PARSE_DTDLOAD;
13237	} else
13238	ctxt->loadsubset = 0;
13239	if (options & XML_PARSE_DTDATTR) {
13240	ctxt->loadsubset \|= XML_COMPLETE_ATTRS;
13241	options -= XML_PARSE_DTDATTR;
13242	}
13243	if (options & XML_PARSE_NOENT) {
13244	ctxt->replaceEntities = 1;
13245	/* ctxt->loadsubset \|= XML_DETECT_IDS; */
13246	options -= XML_PARSE_NOENT;
13247	} else
13248	ctxt->replaceEntities = 0;
13249	if (options & XML_PARSE_PEDANTIC) {
13250	ctxt->pedantic = 1;
13251	options -= XML_PARSE_PEDANTIC;
13252	} else
13253	ctxt->pedantic = 0;
13254	if (options & XML_PARSE_NOBLANKS) {
13255	ctxt->keepBlanks = 0;
13256	ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
13257	options -= XML_PARSE_NOBLANKS;
13258	} else
13259	ctxt->keepBlanks = 1;
13260	if (options & XML_PARSE_DTDVALID) {
13261	ctxt->validate = 1;
13262	if (options & XML_PARSE_NOWARNING)
13263	ctxt->vctxt.warning = NULL;
13264	if (options & XML_PARSE_NOERROR)
13265	ctxt->vctxt.error = NULL;
13266	options -= XML_PARSE_DTDVALID;
13267	} else
13268	ctxt->validate = 0;
13269	if (options & XML_PARSE_NOWARNING) {
13270	ctxt->sax->warning = NULL;
13271	options -= XML_PARSE_NOWARNING;
13272	}
13273	if (options & XML_PARSE_NOERROR) {
13274	ctxt->sax->error = NULL;
13275	ctxt->sax->fatalError = NULL;
13276	options -= XML_PARSE_NOERROR;
13277	}
13278	#ifdef LIBXML_SAX1_ENABLED
13279	if (options & XML_PARSE_SAX1) {
13280	ctxt->sax->startElement = xmlSAX2StartElement;
13281	ctxt->sax->endElement = xmlSAX2EndElement;
13282	ctxt->sax->startElementNs = NULL;
13283	ctxt->sax->endElementNs = NULL;
13284	ctxt->sax->initialized = 1;
13285	options -= XML_PARSE_SAX1;
13286	}
13287	#endif /* LIBXML_SAX1_ENABLED */
13288	if (options & XML_PARSE_NODICT) {
13289	ctxt->dictNames = 0;
13290	options -= XML_PARSE_NODICT;
13291	} else {
13292	ctxt->dictNames = 1;
13293	}
13294	if (options & XML_PARSE_NOCDATA) {
13295	ctxt->sax->cdataBlock = NULL;
13296	options -= XML_PARSE_NOCDATA;
13297	}
13298	if (options & XML_PARSE_NSCLEAN) {
13299	ctxt->options \|= XML_PARSE_NSCLEAN;
13300	options -= XML_PARSE_NSCLEAN;
13301	}
13302	if (options & XML_PARSE_NONET) {
13303	ctxt->options \|= XML_PARSE_NONET;
13304	options -= XML_PARSE_NONET;
13305	}
13306	if (options & XML_PARSE_COMPACT) {
13307	ctxt->options \|= XML_PARSE_COMPACT;
13308	options -= XML_PARSE_COMPACT;
13309	}
13310	ctxt->linenumbers = 1;
13311	return (options);
13312	}
13313
13314	/**
13315	* xmlDoRead:
13316	* @ctxt: an XML parser context
13317	* @URL: the base URL to use for the document
13318	* @encoding: the document encoding, or NULL
13319	* @options: a combination of xmlParserOption
13320	* @reuse: keep the context for reuse
13321	*
13322	* Common front-end for the xmlRead functions
13323	*
13324	* Returns the resulting document tree or NULL
13325	*/
13326	static xmlDocPtr
13327	xmlDoRead(xmlParserCtxtPtr ctxt, const char URL, const char encoding,
13328	int options, int reuse)
13329	{
13330	xmlDocPtr ret;
13331
13332	xmlCtxtUseOptions(ctxt, options);
13333	if (encoding != NULL) {
13334	xmlCharEncodingHandlerPtr hdlr;
13335
13336	hdlr = xmlFindCharEncodingHandler(encoding);
13337	if (hdlr != NULL)
13338	xmlSwitchToEncoding(ctxt, hdlr);
13339	}
13340	if ((URL != NULL) && (ctxt->input != NULL) &&
13341	(ctxt->input->filename == NULL))
13342	ctxt->input->filename = (char ) xmlStrdup((const xmlChar ) URL);
13343	xmlParseDocument(ctxt);
13344	if ((ctxt->wellFormed) \|\| ctxt->recovery)
13345	ret = ctxt->myDoc;
13346	else {
13347	ret = NULL;
13348	if (ctxt->myDoc != NULL) {
13349	xmlFreeDoc(ctxt->myDoc);
13350	}
13351	}
13352	ctxt->myDoc = NULL;
13353	if (!reuse) {
13354	xmlFreeParserCtxt(ctxt);
13355	}
13356
13357	return (ret);
13358	}
13359
13360	/**
13361	* xmlReadDoc:
13362	* @cur: a pointer to a zero terminated string
13363	* @URL: the base URL to use for the document
13364	* @encoding: the document encoding, or NULL
13365	* @options: a combination of xmlParserOption
13366	*
13367	* parse an XML in-memory document and build a tree.
13368	*
13369	* Returns the resulting document tree
13370	*/
13371	xmlDocPtr
13372	xmlReadDoc(const xmlChar * cur, const char URL, const char encoding, int options)
13373	{
13374	xmlParserCtxtPtr ctxt;
13375
13376	if (cur == NULL)
13377	return (NULL);
13378
13379	ctxt = xmlCreateDocParserCtxt(cur);
13380	if (ctxt == NULL)
13381	return (NULL);
13382	return (xmlDoRead(ctxt, URL, encoding, options, 0));
13383	}
13384
13385	/**
13386	* xmlReadFile:
13387	* @filename: a file or URL
13388	* @encoding: the document encoding, or NULL
13389	* @options: a combination of xmlParserOption
13390	*
13391	* parse an XML file from the filesystem or the network.
13392	*
13393	* Returns the resulting document tree
13394	*/
13395	xmlDocPtr
13396	xmlReadFile(const char filename, const char encoding, int options)
13397	{
13398	xmlParserCtxtPtr ctxt;
13399
13400	ctxt = xmlCreateURLParserCtxt(filename, options);
13401	if (ctxt == NULL)
13402	return (NULL);
13403	return (xmlDoRead(ctxt, NULL, encoding, options, 0));
13404	}
13405
13406	/**
13407	* xmlReadMemory:
13408	* @buffer: a pointer to a char array
13409	* @size: the size of the array
13410	* @URL: the base URL to use for the document
13411	* @encoding: the document encoding, or NULL
13412	* @options: a combination of xmlParserOption
13413	*
13414	* parse an XML in-memory document and build a tree.
13415	*
13416	* Returns the resulting document tree
13417	*/
13418	xmlDocPtr
13419	xmlReadMemory(const char buffer, int size, const char URL, const char *encoding, int options)
13420	{
13421	xmlParserCtxtPtr ctxt;
13422
13423	ctxt = xmlCreateMemoryParserCtxt(buffer, size);
13424	if (ctxt == NULL)
13425	return (NULL);
13426	return (xmlDoRead(ctxt, URL, encoding, options, 0));
13427	}
13428
13429	/**
13430	* xmlReadFd:
13431	* @fd: an open file descriptor
13432	* @URL: the base URL to use for the document
13433	* @encoding: the document encoding, or NULL
13434	* @options: a combination of xmlParserOption
13435	*
13436	* parse an XML from a file descriptor and build a tree.
13437	* NOTE that the file descriptor will not be closed when the
13438	* reader is closed or reset.
13439	*
13440	* Returns the resulting document tree
13441	*/
13442	xmlDocPtr
13443	xmlReadFd(int fd, const char URL, const char encoding, int options)
13444	{
13445	xmlParserCtxtPtr ctxt;
13446	xmlParserInputBufferPtr input;
13447	xmlParserInputPtr stream;
13448
13449	if (fd < 0)
13450	return (NULL);
13451
13452	input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
13453	if (input == NULL)
13454	return (NULL);
13455	input->closecallback = NULL;
13456	ctxt = xmlNewParserCtxt();
13457	if (ctxt == NULL) {
13458	xmlFreeParserInputBuffer(input);
13459	return (NULL);
13460	}
13461	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13462	if (stream == NULL) {
13463	xmlFreeParserInputBuffer(input);
13464	xmlFreeParserCtxt(ctxt);
13465	return (NULL);
13466	}
13467	inputPush(ctxt, stream);
13468	return (xmlDoRead(ctxt, URL, encoding, options, 0));
13469	}
13470
13471	/**
13472	* xmlReadIO:
13473	* @ioread: an I/O read function
13474	* @ioclose: an I/O close function
13475	* @ioctx: an I/O handler
13476	* @URL: the base URL to use for the document
13477	* @encoding: the document encoding, or NULL
13478	* @options: a combination of xmlParserOption
13479	*
13480	* parse an XML document from I/O functions and source and build a tree.
13481	*
13482	* Returns the resulting document tree
13483	*/
13484	xmlDocPtr
13485	xmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
13486	void ioctx, const char URL, const char *encoding, int options)
13487	{
13488	xmlParserCtxtPtr ctxt;
13489	xmlParserInputBufferPtr input;
13490	xmlParserInputPtr stream;
13491
13492	if (ioread == NULL)
13493	return (NULL);
13494
13495	input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
13496	XML_CHAR_ENCODING_NONE);
13497	if (input == NULL)
13498	return (NULL);
13499	ctxt = xmlNewParserCtxt();
13500	if (ctxt == NULL) {
13501	xmlFreeParserInputBuffer(input);
13502	return (NULL);
13503	}
13504	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13505	if (stream == NULL) {
13506	xmlFreeParserInputBuffer(input);
13507	xmlFreeParserCtxt(ctxt);
13508	return (NULL);
13509	}
13510	inputPush(ctxt, stream);
13511	return (xmlDoRead(ctxt, URL, encoding, options, 0));
13512	}
13513
13514	/**
13515	* xmlCtxtReadDoc:
13516	* @ctxt: an XML parser context
13517	* @cur: a pointer to a zero terminated string
13518	* @URL: the base URL to use for the document
13519	* @encoding: the document encoding, or NULL
13520	* @options: a combination of xmlParserOption
13521	*
13522	* parse an XML in-memory document and build a tree.
13523	* This reuses the existing @ctxt parser context
13524	*
13525	* Returns the resulting document tree
13526	*/
13527	xmlDocPtr
13528	xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur,
13529	const char URL, const char encoding, int options)
13530	{
13531	xmlParserInputPtr stream;
13532
13533	if (cur == NULL)
13534	return (NULL);
13535	if (ctxt == NULL)
13536	return (NULL);
13537
13538	xmlCtxtReset(ctxt);
13539
13540	stream = xmlNewStringInputStream(ctxt, cur);
13541	if (stream == NULL) {
13542	return (NULL);
13543	}
13544	inputPush(ctxt, stream);
13545	return (xmlDoRead(ctxt, URL, encoding, options, 1));
13546	}
13547
13548	/**
13549	* xmlCtxtReadFile:
13550	* @ctxt: an XML parser context
13551	* @filename: a file or URL
13552	* @encoding: the document encoding, or NULL
13553	* @options: a combination of xmlParserOption
13554	*
13555	* parse an XML file from the filesystem or the network.
13556	* This reuses the existing @ctxt parser context
13557	*
13558	* Returns the resulting document tree
13559	*/
13560	xmlDocPtr
13561	xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename,
13562	const char *encoding, int options)
13563	{
13564	xmlParserInputPtr stream;
13565
13566	if (filename == NULL)
13567	return (NULL);
13568	if (ctxt == NULL)
13569	return (NULL);
13570
13571	xmlCtxtReset(ctxt);
13572
13573	stream = xmlLoadExternalEntity(filename, NULL, ctxt);
13574	if (stream == NULL) {
13575	return (NULL);
13576	}
13577	inputPush(ctxt, stream);
13578	return (xmlDoRead(ctxt, NULL, encoding, options, 1));
13579	}
13580
13581	/**
13582	* xmlCtxtReadMemory:
13583	* @ctxt: an XML parser context
13584	* @buffer: a pointer to a char array
13585	* @size: the size of the array
13586	* @URL: the base URL to use for the document
13587	* @encoding: the document encoding, or NULL
13588	* @options: a combination of xmlParserOption
13589	*
13590	* parse an XML in-memory document and build a tree.
13591	* This reuses the existing @ctxt parser context
13592	*
13593	* Returns the resulting document tree
13594	*/
13595	xmlDocPtr
13596	xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size,
13597	const char URL, const char encoding, int options)
13598	{
13599	xmlParserInputBufferPtr input;
13600	xmlParserInputPtr stream;
13601
13602	if (ctxt == NULL)
13603	return (NULL);
13604	if (buffer == NULL)
13605	return (NULL);
13606
13607	xmlCtxtReset(ctxt);
13608
13609	input = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
13610	if (input == NULL) {
13611	return(NULL);
13612	}
13613
13614	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13615	if (stream == NULL) {
13616	xmlFreeParserInputBuffer(input);
13617	return(NULL);
13618	}
13619
13620	inputPush(ctxt, stream);
13621	return (xmlDoRead(ctxt, URL, encoding, options, 1));
13622	}
13623
13624	/**
13625	* xmlCtxtReadFd:
13626	* @ctxt: an XML parser context
13627	* @fd: an open file descriptor
13628	* @URL: the base URL to use for the document
13629	* @encoding: the document encoding, or NULL
13630	* @options: a combination of xmlParserOption
13631	*
13632	* parse an XML from a file descriptor and build a tree.
13633	* This reuses the existing @ctxt parser context
13634	* NOTE that the file descriptor will not be closed when the
13635	* reader is closed or reset.
13636	*
13637	* Returns the resulting document tree
13638	*/
13639	xmlDocPtr
13640	xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd,
13641	const char URL, const char encoding, int options)
13642	{
13643	xmlParserInputBufferPtr input;
13644	xmlParserInputPtr stream;
13645
13646	if (fd < 0)
13647	return (NULL);
13648	if (ctxt == NULL)
13649	return (NULL);
13650
13651	xmlCtxtReset(ctxt);
13652
13653
13654	input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
13655	if (input == NULL)
13656	return (NULL);
13657	input->closecallback = NULL;
13658	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13659	if (stream == NULL) {
13660	xmlFreeParserInputBuffer(input);
13661	return (NULL);
13662	}
13663	inputPush(ctxt, stream);
13664	return (xmlDoRead(ctxt, URL, encoding, options, 1));
13665	}
13666
13667	/**
13668	* xmlCtxtReadIO:
13669	* @ctxt: an XML parser context
13670	* @ioread: an I/O read function
13671	* @ioclose: an I/O close function
13672	* @ioctx: an I/O handler
13673	* @URL: the base URL to use for the document
13674	* @encoding: the document encoding, or NULL
13675	* @options: a combination of xmlParserOption
13676	*
13677	* parse an XML document from I/O functions and source and build a tree.
13678	* This reuses the existing @ctxt parser context
13679	*
13680	* Returns the resulting document tree
13681	*/
13682	xmlDocPtr
13683	xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
13684	xmlInputCloseCallback ioclose, void *ioctx,
13685	const char *URL,
13686	const char *encoding, int options)
13687	{
13688	xmlParserInputBufferPtr input;
13689	xmlParserInputPtr stream;
13690
13691	if (ioread == NULL)
13692	return (NULL);
13693	if (ctxt == NULL)
13694	return (NULL);
13695
13696	xmlCtxtReset(ctxt);
13697
13698	input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
13699	XML_CHAR_ENCODING_NONE);
13700	if (input == NULL)
13701	return (NULL);
13702	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13703	if (stream == NULL) {
13704	xmlFreeParserInputBuffer(input);
13705	return (NULL);
13706	}
13707	inputPush(ctxt, stream);
13708	return (xmlDoRead(ctxt, URL, encoding, options, 1));
13709	}
13710
13711	#define bottom_parser
13712	#include "elfgcchack.h"

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

source: vbox/trunk/src/libs/libxml2-2.6.30/parser.c@ 24225

Download in other formats: