parser.c@ 16778

Last change on this file since 16778 was 16778, checked in by vboxsync, 16 years ago
libxml2: some fixes from upstream
Property svn:eol-style set to `native` Property svn:keywords set to `Date Revision Author Id`
File size: 366.7 KB

Line
1	/*
2	* parser.c : an XML 1.0 parser, namespaces and validity support are mostly
3	* implemented on top of the SAX interfaces
4	*
5	* References:
6	* The XML specification:
7	* http://www.w3.org/TR/REC-xml
8	* Original 1.0 version:
9	* http://www.w3.org/TR/1998/REC-xml-19980210
10	* XML second edition working draft
11	* http://www.w3.org/TR/2000/WD-xml-2e-20000814
12	*
13	* Okay this is a big file, the parser core is around 7000 lines, then it
14	* is followed by the progressive parser top routines, then the various
15	* high level APIs to call the parser and a few miscellaneous functions.
16	* A number of helper functions and deprecated ones have been moved to
17	* parserInternals.c to reduce this file size.
18	* As much as possible the functions are associated with their relative
19	* production in the XML specification. A few productions defining the
20	* different ranges of character are actually implanted either in
21	* parserInternals.h or parserInternals.c
22	* The DOM tree build is realized from the default SAX callbacks in
23	* the module SAX.c.
24	* The routines doing the validation checks are in valid.c and called either
25	* from the SAX callbacks or as standalone functions using a preparsed
26	* document.
27	*
28	* See Copyright for the status of this software.
29	*
30	* daniel@veillard.com
31	*/
32
33	#define IN_LIBXML
34	#include "libxml.h"
35
36	#if defined(WIN32) && !defined (__CYGWIN__)
37	#define XML_DIR_SEP '\\'
38	#else
39	#define XML_DIR_SEP '/'
40	#endif
41
42	#include <stdlib.h>
43	#include <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	return(ret);
4738	}
4739	cur = xmlCreateEnumeration(name);
4740	if (cur == NULL) return(ret);
4741	if (last == NULL) ret = last = cur;
4742	else {
4743	last->next = cur;
4744	last = cur;
4745	}
4746	SKIP_BLANKS;
4747	} while (RAW == '\|');
4748	if (RAW != ')') {
4749	xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
4750	if ((last != NULL) && (last != ret))
4751	xmlFreeEnumeration(last);
4752	return(ret);
4753	}
4754	NEXT;
4755	return(ret);
4756	}
4757
4758	/**
4759	* xmlParseEnumerationType:
4760	* @ctxt: an XML parser context
4761	*
4762	* parse an Enumeration attribute type.
4763	*
4764	* [59] Enumeration ::= '(' S? Nmtoken (S? '\|' S? Nmtoken)* S? ')'
4765	*
4766	* [ VC: Enumeration ]
4767	* Values of this type must match one of the Nmtoken tokens in
4768	* the declaration
4769	*
4770	* Returns: the enumeration attribute tree built while parsing
4771	*/
4772
4773	xmlEnumerationPtr
4774	xmlParseEnumerationType(xmlParserCtxtPtr ctxt) {
4775	xmlChar *name;
4776	xmlEnumerationPtr ret = NULL, last = NULL, cur;
4777
4778	if (RAW != '(') {
4779	xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
4780	return(NULL);
4781	}
4782	SHRINK;
4783	do {
4784	NEXT;
4785	SKIP_BLANKS;
4786	name = xmlParseNmtoken(ctxt);
4787	if (name == NULL) {
4788	xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
4789	return(ret);
4790	}
4791	cur = xmlCreateEnumeration(name);
4792	xmlFree(name);
4793	if (cur == NULL) return(ret);
4794	if (last == NULL) ret = last = cur;
4795	else {
4796	last->next = cur;
4797	last = cur;
4798	}
4799	SKIP_BLANKS;
4800	} while (RAW == '\|');
4801	if (RAW != ')') {
4802	xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
4803	return(ret);
4804	}
4805	NEXT;
4806	return(ret);
4807	}
4808
4809	/**
4810	* xmlParseEnumeratedType:
4811	* @ctxt: an XML parser context
4812	* @tree: the enumeration tree built while parsing
4813	*
4814	* parse an Enumerated attribute type.
4815	*
4816	* [57] EnumeratedType ::= NotationType \| Enumeration
4817	*
4818	* [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '\|' S? Name)* S? ')'
4819	*
4820	*
4821	* Returns: XML_ATTRIBUTE_ENUMERATION or XML_ATTRIBUTE_NOTATION
4822	*/
4823
4824	int
4825	xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
4826	if (CMP8(CUR_PTR, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
4827	SKIP(8);
4828	if (!IS_BLANK_CH(CUR)) {
4829	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4830	"Space required after 'NOTATION'\n");
4831	return(0);
4832	}
4833	SKIP_BLANKS;
4834	*tree = xmlParseNotationType(ctxt);
4835	if (*tree == NULL) return(0);
4836	return(XML_ATTRIBUTE_NOTATION);
4837	}
4838	*tree = xmlParseEnumerationType(ctxt);
4839	if (*tree == NULL) return(0);
4840	return(XML_ATTRIBUTE_ENUMERATION);
4841	}
4842
4843	/**
4844	* xmlParseAttributeType:
4845	* @ctxt: an XML parser context
4846	* @tree: the enumeration tree built while parsing
4847	*
4848	* parse the Attribute list def for an element
4849	*
4850	* [54] AttType ::= StringType \| TokenizedType \| EnumeratedType
4851	*
4852	* [55] StringType ::= 'CDATA'
4853	*
4854	* [56] TokenizedType ::= 'ID' \| 'IDREF' \| 'IDREFS' \| 'ENTITY' \|
4855	* 'ENTITIES' \| 'NMTOKEN' \| 'NMTOKENS'
4856	*
4857	* Validity constraints for attribute values syntax are checked in
4858	* xmlValidateAttributeValue()
4859	*
4860	* [ VC: ID ]
4861	* Values of type ID must match the Name production. A name must not
4862	* appear more than once in an XML document as a value of this type;
4863	* i.e., ID values must uniquely identify the elements which bear them.
4864	*
4865	* [ VC: One ID per Element Type ]
4866	* No element type may have more than one ID attribute specified.
4867	*
4868	* [ VC: ID Attribute Default ]
4869	* An ID attribute must have a declared default of #IMPLIED or #REQUIRED.
4870	*
4871	* [ VC: IDREF ]
4872	* Values of type IDREF must match the Name production, and values
4873	* of type IDREFS must match Names; each IDREF Name must match the value
4874	* of an ID attribute on some element in the XML document; i.e. IDREF
4875	* values must match the value of some ID attribute.
4876	*
4877	* [ VC: Entity Name ]
4878	* Values of type ENTITY must match the Name production, values
4879	* of type ENTITIES must match Names; each Entity Name must match the
4880	* name of an unparsed entity declared in the DTD.
4881	*
4882	* [ VC: Name Token ]
4883	* Values of type NMTOKEN must match the Nmtoken production; values
4884	* of type NMTOKENS must match Nmtokens.
4885	*
4886	* Returns the attribute type
4887	*/
4888	int
4889	xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
4890	SHRINK;
4891	if (CMP5(CUR_PTR, 'C', 'D', 'A', 'T', 'A')) {
4892	SKIP(5);
4893	return(XML_ATTRIBUTE_CDATA);
4894	} else if (CMP6(CUR_PTR, 'I', 'D', 'R', 'E', 'F', 'S')) {
4895	SKIP(6);
4896	return(XML_ATTRIBUTE_IDREFS);
4897	} else if (CMP5(CUR_PTR, 'I', 'D', 'R', 'E', 'F')) {
4898	SKIP(5);
4899	return(XML_ATTRIBUTE_IDREF);
4900	} else if ((RAW == 'I') && (NXT(1) == 'D')) {
4901	SKIP(2);
4902	return(XML_ATTRIBUTE_ID);
4903	} else if (CMP6(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'Y')) {
4904	SKIP(6);
4905	return(XML_ATTRIBUTE_ENTITY);
4906	} else if (CMP8(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S')) {
4907	SKIP(8);
4908	return(XML_ATTRIBUTE_ENTITIES);
4909	} else if (CMP8(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S')) {
4910	SKIP(8);
4911	return(XML_ATTRIBUTE_NMTOKENS);
4912	} else if (CMP7(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N')) {
4913	SKIP(7);
4914	return(XML_ATTRIBUTE_NMTOKEN);
4915	}
4916	return(xmlParseEnumeratedType(ctxt, tree));
4917	}
4918
4919	/**
4920	* xmlParseAttributeListDecl:
4921	* @ctxt: an XML parser context
4922	*
4923	* : parse the Attribute list def for an element
4924	*
4925	* [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'
4926	*
4927	* [53] AttDef ::= S Name S AttType S DefaultDecl
4928	*
4929	*/
4930	void
4931	xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) {
4932	const xmlChar *elemName;
4933	const xmlChar *attrName;
4934	xmlEnumerationPtr tree;
4935
4936	if (CMP9(CUR_PTR, '<', '!', 'A', 'T', 'T', 'L', 'I', 'S', 'T')) {
4937	xmlParserInputPtr input = ctxt->input;
4938
4939	SKIP(9);
4940	if (!IS_BLANK_CH(CUR)) {
4941	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4942	"Space required after '<!ATTLIST'\n");
4943	}
4944	SKIP_BLANKS;
4945	elemName = xmlParseName(ctxt);
4946	if (elemName == NULL) {
4947	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
4948	"ATTLIST: no name for Element\n");
4949	return;
4950	}
4951	SKIP_BLANKS;
4952	GROW;
4953	while (RAW != '>') {
4954	const xmlChar *check = CUR_PTR;
4955	int type;
4956	int def;
4957	xmlChar *defaultValue = NULL;
4958
4959	GROW;
4960	tree = NULL;
4961	attrName = xmlParseName(ctxt);
4962	if (attrName == NULL) {
4963	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
4964	"ATTLIST: no name for Attribute\n");
4965	break;
4966	}
4967	GROW;
4968	if (!IS_BLANK_CH(CUR)) {
4969	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4970	"Space required after the attribute name\n");
4971	break;
4972	}
4973	SKIP_BLANKS;
4974
4975	type = xmlParseAttributeType(ctxt, &tree);
4976	if (type <= 0) {
4977	break;
4978	}
4979
4980	GROW;
4981	if (!IS_BLANK_CH(CUR)) {
4982	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4983	"Space required after the attribute type\n");
4984	if (tree != NULL)
4985	xmlFreeEnumeration(tree);
4986	break;
4987	}
4988	SKIP_BLANKS;
4989
4990	def = xmlParseDefaultDecl(ctxt, &defaultValue);
4991	if (def <= 0) {
4992	if (defaultValue != NULL)
4993	xmlFree(defaultValue);
4994	if (tree != NULL)
4995	xmlFreeEnumeration(tree);
4996	break;
4997	}
4998
4999	GROW;
5000	if (RAW != '>') {
5001	if (!IS_BLANK_CH(CUR)) {
5002	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5003	"Space required after the attribute default value\n");
5004	if (defaultValue != NULL)
5005	xmlFree(defaultValue);
5006	if (tree != NULL)
5007	xmlFreeEnumeration(tree);
5008	break;
5009	}
5010	SKIP_BLANKS;
5011	}
5012	if (check == CUR_PTR) {
5013	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
5014	"in xmlParseAttributeListDecl\n");
5015	if (defaultValue != NULL)
5016	xmlFree(defaultValue);
5017	if (tree != NULL)
5018	xmlFreeEnumeration(tree);
5019	break;
5020	}
5021	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5022	(ctxt->sax->attributeDecl != NULL))
5023	ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
5024	type, def, defaultValue, tree);
5025	else if (tree != NULL)
5026	xmlFreeEnumeration(tree);
5027
5028	if ((ctxt->sax2) && (defaultValue != NULL) &&
5029	(def != XML_ATTRIBUTE_IMPLIED) &&
5030	(def != XML_ATTRIBUTE_REQUIRED)) {
5031	xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue);
5032	}
5033	if ((ctxt->sax2) && (type != XML_ATTRIBUTE_CDATA)) {
5034	xmlAddSpecialAttr(ctxt, elemName, attrName, type);
5035	}
5036	if (defaultValue != NULL)
5037	xmlFree(defaultValue);
5038	GROW;
5039	}
5040	if (RAW == '>') {
5041	if (input != ctxt->input) {
5042	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5043	"Attribute list declaration doesn't start and stop in the same entity\n");
5044	}
5045	NEXT;
5046	}
5047	}
5048	}
5049
5050	/**
5051	* xmlParseElementMixedContentDecl:
5052	* @ctxt: an XML parser context
5053	* @inputchk: the input used for the current entity, needed for boundary checks
5054	*
5055	* parse the declaration for a Mixed Element content
5056	* The leading '(' and spaces have been skipped in xmlParseElementContentDecl
5057	*
5058	* [51] Mixed ::= '(' S? '#PCDATA' (S? '\|' S? Name)* S? ')*' \|
5059	* '(' S? '#PCDATA' S? ')'
5060	*
5061	* [ VC: Proper Group/PE Nesting ] applies to [51] too (see [49])
5062	*
5063	* [ VC: No Duplicate Types ]
5064	* The same name must not appear more than once in a single
5065	* mixed-content declaration.
5066	*
5067	* returns: the list of the xmlElementContentPtr describing the element choices
5068	*/
5069	xmlElementContentPtr
5070	xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
5071	xmlElementContentPtr ret = NULL, cur = NULL, n;
5072	const xmlChar *elem = NULL;
5073
5074	GROW;
5075	if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
5076	SKIP(7);
5077	SKIP_BLANKS;
5078	SHRINK;
5079	if (RAW == ')') {
5080	if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5081	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5082	"Element content declaration doesn't start and stop in the same entity\n",
5083	NULL);
5084	}
5085	NEXT;
5086	ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
5087	if (RAW == '*') {
5088	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5089	NEXT;
5090	}
5091	return(ret);
5092	}
5093	if ((RAW == '(') \|\| (RAW == '\|')) {
5094	ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
5095	if (ret == NULL) return(NULL);
5096	}
5097	while (RAW == '\|') {
5098	NEXT;
5099	if (elem == NULL) {
5100	ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5101	if (ret == NULL) return(NULL);
5102	ret->c1 = cur;
5103	if (cur != NULL)
5104	cur->parent = ret;
5105	cur = ret;
5106	} else {
5107	n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5108	if (n == NULL) return(NULL);
5109	n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
5110	if (n->c1 != NULL)
5111	n->c1->parent = n;
5112	cur->c2 = n;
5113	if (n != NULL)
5114	n->parent = cur;
5115	cur = n;
5116	}
5117	SKIP_BLANKS;
5118	elem = xmlParseName(ctxt);
5119	if (elem == NULL) {
5120	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5121	"xmlParseElementMixedContentDecl : Name expected\n");
5122	xmlFreeDocElementContent(ctxt->myDoc, cur);
5123	return(NULL);
5124	}
5125	SKIP_BLANKS;
5126	GROW;
5127	}
5128	if ((RAW == ')') && (NXT(1) == '*')) {
5129	if (elem != NULL) {
5130	cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem,
5131	XML_ELEMENT_CONTENT_ELEMENT);
5132	if (cur->c2 != NULL)
5133	cur->c2->parent = cur;
5134	}
5135	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5136	if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5137	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5138	"Element content declaration doesn't start and stop in the same entity\n",
5139	NULL);
5140	}
5141	SKIP(2);
5142	} else {
5143	xmlFreeDocElementContent(ctxt->myDoc, ret);
5144	xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
5145	return(NULL);
5146	}
5147
5148	} else {
5149	xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
5150	}
5151	return(ret);
5152	}
5153
5154	/**
5155	* xmlParseElementChildrenContentDecl:
5156	* @ctxt: an XML parser context
5157	* @inputchk: the input used for the current entity, needed for boundary checks
5158	*
5159	* parse the declaration for a Mixed Element content
5160	* The leading '(' and spaces have been skipped in xmlParseElementContentDecl
5161	*
5162	*
5163	* [47] children ::= (choice \| seq) ('?' \| '*' \| '+')?
5164	*
5165	* [48] cp ::= (Name \| choice \| seq) ('?' \| '*' \| '+')?
5166	*
5167	* [49] choice ::= '(' S? cp ( S? '\|' S? cp )* S? ')'
5168	*
5169	* [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
5170	*
5171	* [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
5172	* TODO Parameter-entity replacement text must be properly nested
5173	* with parenthesized groups. That is to say, if either of the
5174	* opening or closing parentheses in a choice, seq, or Mixed
5175	* construct is contained in the replacement text for a parameter
5176	* entity, both must be contained in the same replacement text. For
5177	* interoperability, if a parameter-entity reference appears in a
5178	* choice, seq, or Mixed construct, its replacement text should not
5179	* be empty, and neither the first nor last non-blank character of
5180	* the replacement text should be a connector (\| or ,).
5181	*
5182	* Returns the tree of xmlElementContentPtr describing the element
5183	* hierarchy.
5184	*/
5185	xmlElementContentPtr
5186	xmlParseElementChildrenContentDecl (xmlParserCtxtPtr ctxt, int inputchk) {
5187	xmlElementContentPtr ret = NULL, cur = NULL, last = NULL, op = NULL;
5188	const xmlChar *elem;
5189	xmlChar type = 0;
5190
5191	SKIP_BLANKS;
5192	GROW;
5193	if (RAW == '(') {
5194	int inputid = ctxt->input->id;
5195
5196	/* Recurse on first child */
5197	NEXT;
5198	SKIP_BLANKS;
5199	cur = ret = xmlParseElementChildrenContentDecl(ctxt, inputid);
5200	SKIP_BLANKS;
5201	GROW;
5202	} else {
5203	elem = xmlParseName(ctxt);
5204	if (elem == NULL) {
5205	xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
5206	return(NULL);
5207	}
5208	cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
5209	if (cur == NULL) {
5210	xmlErrMemory(ctxt, NULL);
5211	return(NULL);
5212	}
5213	GROW;
5214	if (RAW == '?') {
5215	cur->ocur = XML_ELEMENT_CONTENT_OPT;
5216	NEXT;
5217	} else if (RAW == '*') {
5218	cur->ocur = XML_ELEMENT_CONTENT_MULT;
5219	NEXT;
5220	} else if (RAW == '+') {
5221	cur->ocur = XML_ELEMENT_CONTENT_PLUS;
5222	NEXT;
5223	} else {
5224	cur->ocur = XML_ELEMENT_CONTENT_ONCE;
5225	}
5226	GROW;
5227	}
5228	SKIP_BLANKS;
5229	SHRINK;
5230	while (RAW != ')') {
5231	/*
5232	* Each loop we parse one separator and one element.
5233	*/
5234	if (RAW == ',') {
5235	if (type == 0) type = CUR;
5236
5237	/*
5238	* Detect "Name \| Name , Name" error
5239	*/
5240	else if (type != CUR) {
5241	xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
5242	"xmlParseElementChildrenContentDecl : '%c' expected\n",
5243	type);
5244	if ((last != NULL) && (last != ret))
5245	xmlFreeDocElementContent(ctxt->myDoc, last);
5246	if (ret != NULL)
5247	xmlFreeDocElementContent(ctxt->myDoc, ret);
5248	return(NULL);
5249	}
5250	NEXT;
5251
5252	op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ);
5253	if (op == NULL) {
5254	if ((last != NULL) && (last != ret))
5255	xmlFreeDocElementContent(ctxt->myDoc, last);
5256	xmlFreeDocElementContent(ctxt->myDoc, ret);
5257	return(NULL);
5258	}
5259	if (last == NULL) {
5260	op->c1 = ret;
5261	if (ret != NULL)
5262	ret->parent = op;
5263	ret = cur = op;
5264	} else {
5265	cur->c2 = op;
5266	if (op != NULL)
5267	op->parent = cur;
5268	op->c1 = last;
5269	if (last != NULL)
5270	last->parent = op;
5271	cur =op;
5272	last = NULL;
5273	}
5274	} else if (RAW == '\|') {
5275	if (type == 0) type = CUR;
5276
5277	/*
5278	* Detect "Name , Name \| Name" error
5279	*/
5280	else if (type != CUR) {
5281	xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
5282	"xmlParseElementChildrenContentDecl : '%c' expected\n",
5283	type);
5284	if ((last != NULL) && (last != ret))
5285	xmlFreeDocElementContent(ctxt->myDoc, last);
5286	if (ret != NULL)
5287	xmlFreeDocElementContent(ctxt->myDoc, ret);
5288	return(NULL);
5289	}
5290	NEXT;
5291
5292	op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5293	if (op == NULL) {
5294	if ((last != NULL) && (last != ret))
5295	xmlFreeDocElementContent(ctxt->myDoc, last);
5296	if (ret != NULL)
5297	xmlFreeDocElementContent(ctxt->myDoc, ret);
5298	return(NULL);
5299	}
5300	if (last == NULL) {
5301	op->c1 = ret;
5302	if (ret != NULL)
5303	ret->parent = op;
5304	ret = cur = op;
5305	} else {
5306	cur->c2 = op;
5307	if (op != NULL)
5308	op->parent = cur;
5309	op->c1 = last;
5310	if (last != NULL)
5311	last->parent = op;
5312	cur =op;
5313	last = NULL;
5314	}
5315	} else {
5316	xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL);
5317	if (ret != NULL)
5318	xmlFreeDocElementContent(ctxt->myDoc, ret);
5319	return(NULL);
5320	}
5321	GROW;
5322	SKIP_BLANKS;
5323	GROW;
5324	if (RAW == '(') {
5325	int inputid = ctxt->input->id;
5326	/* Recurse on second child */
5327	NEXT;
5328	SKIP_BLANKS;
5329	last = xmlParseElementChildrenContentDecl(ctxt, inputid);
5330	SKIP_BLANKS;
5331	} else {
5332	elem = xmlParseName(ctxt);
5333	if (elem == NULL) {
5334	xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
5335	if (ret != NULL)
5336	xmlFreeDocElementContent(ctxt->myDoc, ret);
5337	return(NULL);
5338	}
5339	last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
5340	if (RAW == '?') {
5341	last->ocur = XML_ELEMENT_CONTENT_OPT;
5342	NEXT;
5343	} else if (RAW == '*') {
5344	last->ocur = XML_ELEMENT_CONTENT_MULT;
5345	NEXT;
5346	} else if (RAW == '+') {
5347	last->ocur = XML_ELEMENT_CONTENT_PLUS;
5348	NEXT;
5349	} else {
5350	last->ocur = XML_ELEMENT_CONTENT_ONCE;
5351	}
5352	}
5353	SKIP_BLANKS;
5354	GROW;
5355	}
5356	if ((cur != NULL) && (last != NULL)) {
5357	cur->c2 = last;
5358	if (last != NULL)
5359	last->parent = cur;
5360	}
5361	if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5362	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5363	"Element content declaration doesn't start and stop in the same entity\n",
5364	NULL);
5365	}
5366	NEXT;
5367	if (RAW == '?') {
5368	if (ret != NULL) {
5369	if ((ret->ocur == XML_ELEMENT_CONTENT_PLUS) \|\|
5370	(ret->ocur == XML_ELEMENT_CONTENT_MULT))
5371	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5372	else
5373	ret->ocur = XML_ELEMENT_CONTENT_OPT;
5374	}
5375	NEXT;
5376	} else if (RAW == '*') {
5377	if (ret != NULL) {
5378	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5379	cur = ret;
5380	/*
5381	* Some normalization:
5382	* (a \| b* \| c?)* == (a \| b \| c)*
5383	*/
5384	while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
5385	if ((cur->c1 != NULL) &&
5386	((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
5387	(cur->c1->ocur == XML_ELEMENT_CONTENT_MULT)))
5388	cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
5389	if ((cur->c2 != NULL) &&
5390	((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
5391	(cur->c2->ocur == XML_ELEMENT_CONTENT_MULT)))
5392	cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
5393	cur = cur->c2;
5394	}
5395	}
5396	NEXT;
5397	} else if (RAW == '+') {
5398	if (ret != NULL) {
5399	int found = 0;
5400
5401	if ((ret->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
5402	(ret->ocur == XML_ELEMENT_CONTENT_MULT))
5403	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5404	else
5405	ret->ocur = XML_ELEMENT_CONTENT_PLUS;
5406	/*
5407	* Some normalization:
5408	* (a \| b)+ == (a \| b)
5409	* (a \| b?)+ == (a \| b)*
5410	*/
5411	while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
5412	if ((cur->c1 != NULL) &&
5413	((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
5414	(cur->c1->ocur == XML_ELEMENT_CONTENT_MULT))) {
5415	cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
5416	found = 1;
5417	}
5418	if ((cur->c2 != NULL) &&
5419	((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
5420	(cur->c2->ocur == XML_ELEMENT_CONTENT_MULT))) {
5421	cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
5422	found = 1;
5423	}
5424	cur = cur->c2;
5425	}
5426	if (found)
5427	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5428	}
5429	NEXT;
5430	}
5431	return(ret);
5432	}
5433
5434	/**
5435	* xmlParseElementContentDecl:
5436	* @ctxt: an XML parser context
5437	* @name: the name of the element being defined.
5438	* @result: the Element Content pointer will be stored here if any
5439	*
5440	* parse the declaration for an Element content either Mixed or Children,
5441	* the cases EMPTY and ANY are handled directly in xmlParseElementDecl
5442	*
5443	* [46] contentspec ::= 'EMPTY' \| 'ANY' \| Mixed \| children
5444	*
5445	* returns: the type of element content XML_ELEMENT_TYPE_xxx
5446	*/
5447
5448	int
5449	xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name,
5450	xmlElementContentPtr *result) {
5451
5452	xmlElementContentPtr tree = NULL;
5453	int inputid = ctxt->input->id;
5454	int res;
5455
5456	*result = NULL;
5457
5458	if (RAW != '(') {
5459	xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
5460	"xmlParseElementContentDecl : %s '(' expected\n", name);
5461	return(-1);
5462	}
5463	NEXT;
5464	GROW;
5465	SKIP_BLANKS;
5466	if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
5467	tree = xmlParseElementMixedContentDecl(ctxt, inputid);
5468	res = XML_ELEMENT_TYPE_MIXED;
5469	} else {
5470	tree = xmlParseElementChildrenContentDecl(ctxt, inputid);
5471	res = XML_ELEMENT_TYPE_ELEMENT;
5472	}
5473	SKIP_BLANKS;
5474	*result = tree;
5475	return(res);
5476	}
5477
5478	/**
5479	* xmlParseElementDecl:
5480	* @ctxt: an XML parser context
5481	*
5482	* parse an Element declaration.
5483	*
5484	* [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>'
5485	*
5486	* [ VC: Unique Element Type Declaration ]
5487	* No element type may be declared more than once
5488	*
5489	* Returns the type of the element, or -1 in case of error
5490	*/
5491	int
5492	xmlParseElementDecl(xmlParserCtxtPtr ctxt) {
5493	const xmlChar *name;
5494	int ret = -1;
5495	xmlElementContentPtr content = NULL;
5496
5497	/* GROW; done in the caller */
5498	if (CMP9(CUR_PTR, '<', '!', 'E', 'L', 'E', 'M', 'E', 'N', 'T')) {
5499	xmlParserInputPtr input = ctxt->input;
5500
5501	SKIP(9);
5502	if (!IS_BLANK_CH(CUR)) {
5503	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5504	"Space required after 'ELEMENT'\n");
5505	}
5506	SKIP_BLANKS;
5507	name = xmlParseName(ctxt);
5508	if (name == NULL) {
5509	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5510	"xmlParseElementDecl: no name for Element\n");
5511	return(-1);
5512	}
5513	while ((RAW == 0) && (ctxt->inputNr > 1))
5514	xmlPopInput(ctxt);
5515	if (!IS_BLANK_CH(CUR)) {
5516	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5517	"Space required after the element name\n");
5518	}
5519	SKIP_BLANKS;
5520	if (CMP5(CUR_PTR, 'E', 'M', 'P', 'T', 'Y')) {
5521	SKIP(5);
5522	/*
5523	* Element must always be empty.
5524	*/
5525	ret = XML_ELEMENT_TYPE_EMPTY;
5526	} else if ((RAW == 'A') && (NXT(1) == 'N') &&
5527	(NXT(2) == 'Y')) {
5528	SKIP(3);
5529	/*
5530	* Element is a generic container.
5531	*/
5532	ret = XML_ELEMENT_TYPE_ANY;
5533	} else if (RAW == '(') {
5534	ret = xmlParseElementContentDecl(ctxt, name, &content);
5535	} else {
5536	/*
5537	* [ WFC: PEs in Internal Subset ] error handling.
5538	*/
5539	if ((RAW == '%') && (ctxt->external == 0) &&
5540	(ctxt->inputNr == 1)) {
5541	xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET,
5542	"PEReference: forbidden within markup decl in internal subset\n");
5543	} else {
5544	xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
5545	"xmlParseElementDecl: 'EMPTY', 'ANY' or '(' expected\n");
5546	}
5547	return(-1);
5548	}
5549
5550	SKIP_BLANKS;
5551	/*
5552	* Pop-up of finished entities.
5553	*/
5554	while ((RAW == 0) && (ctxt->inputNr > 1))
5555	xmlPopInput(ctxt);
5556	SKIP_BLANKS;
5557
5558	if (RAW != '>') {
5559	xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
5560	if (content != NULL) {
5561	xmlFreeDocElementContent(ctxt->myDoc, content);
5562	}
5563	} else {
5564	if (input != ctxt->input) {
5565	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5566	"Element declaration doesn't start and stop in the same entity\n");
5567	}
5568
5569	NEXT;
5570	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5571	(ctxt->sax->elementDecl != NULL)) {
5572	if (content != NULL)
5573	content->parent = NULL;
5574	ctxt->sax->elementDecl(ctxt->userData, name, ret,
5575	content);
5576	if ((content != NULL) && (content->parent == NULL)) {
5577	/*
5578	* this is a trick: if xmlAddElementDecl is called,
5579	* instead of copying the full tree it is plugged directly
5580	* if called from the parser. Avoid duplicating the
5581	* interfaces or change the API/ABI
5582	*/
5583	xmlFreeDocElementContent(ctxt->myDoc, content);
5584	}
5585	} else if (content != NULL) {
5586	xmlFreeDocElementContent(ctxt->myDoc, content);
5587	}
5588	}
5589	}
5590	return(ret);
5591	}
5592
5593	/**
5594	* xmlParseConditionalSections
5595	* @ctxt: an XML parser context
5596	*
5597	* [61] conditionalSect ::= includeSect \| ignoreSect
5598	* [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>'
5599	* [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>'
5600	* [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)*
5601	* [65] Ignore ::= Char* - (Char* ('<![' \| ']]>') Char*)
5602	*/
5603
5604	static void
5605	xmlParseConditionalSections(xmlParserCtxtPtr ctxt) {
5606	SKIP(3);
5607	SKIP_BLANKS;
5608	if (CMP7(CUR_PTR, 'I', 'N', 'C', 'L', 'U', 'D', 'E')) {
5609	SKIP(7);
5610	SKIP_BLANKS;
5611	if (RAW != '[') {
5612	xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
5613	} else {
5614	NEXT;
5615	}
5616	if (xmlParserDebugEntities) {
5617	if ((ctxt->input != NULL) && (ctxt->input->filename))
5618	xmlGenericError(xmlGenericErrorContext,
5619	"%s(%d): ", ctxt->input->filename,
5620	ctxt->input->line);
5621	xmlGenericError(xmlGenericErrorContext,
5622	"Entering INCLUDE Conditional Section\n");
5623	}
5624
5625	while ((RAW != 0) && ((RAW != ']') \|\| (NXT(1) != ']') \|\|
5626	(NXT(2) != '>'))) {
5627	const xmlChar *check = CUR_PTR;
5628	unsigned int cons = ctxt->input->consumed;
5629
5630	if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
5631	xmlParseConditionalSections(ctxt);
5632	} else if (IS_BLANK_CH(CUR)) {
5633	NEXT;
5634	} else if (RAW == '%') {
5635	xmlParsePEReference(ctxt);
5636	} else
5637	xmlParseMarkupDecl(ctxt);
5638
5639	/*
5640	* Pop-up of finished entities.
5641	*/
5642	while ((RAW == 0) && (ctxt->inputNr > 1))
5643	xmlPopInput(ctxt);
5644
5645	if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
5646	xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
5647	break;
5648	}
5649	}
5650	if (xmlParserDebugEntities) {
5651	if ((ctxt->input != NULL) && (ctxt->input->filename))
5652	xmlGenericError(xmlGenericErrorContext,
5653	"%s(%d): ", ctxt->input->filename,
5654	ctxt->input->line);
5655	xmlGenericError(xmlGenericErrorContext,
5656	"Leaving INCLUDE Conditional Section\n");
5657	}
5658
5659	} else if (CMP6(CUR_PTR, 'I', 'G', 'N', 'O', 'R', 'E')) {
5660	int state;
5661	xmlParserInputState instate;
5662	int depth = 0;
5663
5664	SKIP(6);
5665	SKIP_BLANKS;
5666	if (RAW != '[') {
5667	xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
5668	} else {
5669	NEXT;
5670	}
5671	if (xmlParserDebugEntities) {
5672	if ((ctxt->input != NULL) && (ctxt->input->filename))
5673	xmlGenericError(xmlGenericErrorContext,
5674	"%s(%d): ", ctxt->input->filename,
5675	ctxt->input->line);
5676	xmlGenericError(xmlGenericErrorContext,
5677	"Entering IGNORE Conditional Section\n");
5678	}
5679
5680	/*
5681	* Parse up to the end of the conditional section
5682	* But disable SAX event generating DTD building in the meantime
5683	*/
5684	state = ctxt->disableSAX;
5685	instate = ctxt->instate;
5686	if (ctxt->recovery == 0) ctxt->disableSAX = 1;
5687	ctxt->instate = XML_PARSER_IGNORE;
5688
5689	while ((depth >= 0) && (RAW != 0)) {
5690	if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
5691	depth++;
5692	SKIP(3);
5693	continue;
5694	}
5695	if ((RAW == ']') && (NXT(1) == ']') && (NXT(2) == '>')) {
5696	if (--depth >= 0) SKIP(3);
5697	continue;
5698	}
5699	NEXT;
5700	continue;
5701	}
5702
5703	ctxt->disableSAX = state;
5704	ctxt->instate = instate;
5705
5706	if (xmlParserDebugEntities) {
5707	if ((ctxt->input != NULL) && (ctxt->input->filename))
5708	xmlGenericError(xmlGenericErrorContext,
5709	"%s(%d): ", ctxt->input->filename,
5710	ctxt->input->line);
5711	xmlGenericError(xmlGenericErrorContext,
5712	"Leaving IGNORE Conditional Section\n");
5713	}
5714
5715	} else {
5716	xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
5717	}
5718
5719	if (RAW == 0)
5720	SHRINK;
5721
5722	if (RAW == 0) {
5723	xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
5724	} else {
5725	SKIP(3);
5726	}
5727	}
5728
5729	/**
5730	* xmlParseMarkupDecl:
5731	* @ctxt: an XML parser context
5732	*
5733	* parse Markup declarations
5734	*
5735	* [29] markupdecl ::= elementdecl \| AttlistDecl \| EntityDecl \|
5736	* NotationDecl \| PI \| Comment
5737	*
5738	* [ VC: Proper Declaration/PE Nesting ]
5739	* Parameter-entity replacement text must be properly nested with
5740	* markup declarations. That is to say, if either the first character
5741	* or the last character of a markup declaration (markupdecl above) is
5742	* contained in the replacement text for a parameter-entity reference,
5743	* both must be contained in the same replacement text.
5744	*
5745	* [ WFC: PEs in Internal Subset ]
5746	* In the internal DTD subset, parameter-entity references can occur
5747	* only where markup declarations can occur, not within markup declarations.
5748	* (This does not apply to references that occur in external parameter
5749	* entities or to the external subset.)
5750	*/
5751	void
5752	xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) {
5753	GROW;
5754	if (CUR == '<') {
5755	if (NXT(1) == '!') {
5756	switch (NXT(2)) {
5757	case 'E':
5758	if (NXT(3) == 'L')
5759	xmlParseElementDecl(ctxt);
5760	else if (NXT(3) == 'N')
5761	xmlParseEntityDecl(ctxt);
5762	break;
5763	case 'A':
5764	xmlParseAttributeListDecl(ctxt);
5765	break;
5766	case 'N':
5767	xmlParseNotationDecl(ctxt);
5768	break;
5769	case '-':
5770	xmlParseComment(ctxt);
5771	break;
5772	default:
5773	/* there is an error but it will be detected later */
5774	break;
5775	}
5776	} else if (NXT(1) == '?') {
5777	xmlParsePI(ctxt);
5778	}
5779	}
5780	/*
5781	* This is only for internal subset. On external entities,
5782	* the replacement is done before parsing stage
5783	*/
5784	if ((ctxt->external == 0) && (ctxt->inputNr == 1))
5785	xmlParsePEReference(ctxt);
5786
5787	/*
5788	* Conditional sections are allowed from entities included
5789	* by PE References in the internal subset.
5790	*/
5791	if ((ctxt->external == 0) && (ctxt->inputNr > 1)) {
5792	if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
5793	xmlParseConditionalSections(ctxt);
5794	}
5795	}
5796
5797	ctxt->instate = XML_PARSER_DTD;
5798	}
5799
5800	/**
5801	* xmlParseTextDecl:
5802	* @ctxt: an XML parser context
5803	*
5804	* parse an XML declaration header for external entities
5805	*
5806	* [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
5807	*
5808	* Question: Seems that EncodingDecl is mandatory ? Is that a typo ?
5809	*/
5810
5811	void
5812	xmlParseTextDecl(xmlParserCtxtPtr ctxt) {
5813	xmlChar *version;
5814	const xmlChar *encoding;
5815
5816	/*
5817	* We know that '<?xml' is here.
5818	*/
5819	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
5820	SKIP(5);
5821	} else {
5822	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL);
5823	return;
5824	}
5825
5826	if (!IS_BLANK_CH(CUR)) {
5827	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5828	"Space needed after '<?xml'\n");
5829	}
5830	SKIP_BLANKS;
5831
5832	/*
5833	* We may have the VersionInfo here.
5834	*/
5835	version = xmlParseVersionInfo(ctxt);
5836	if (version == NULL)
5837	version = xmlCharStrdup(XML_DEFAULT_VERSION);
5838	else {
5839	if (!IS_BLANK_CH(CUR)) {
5840	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5841	"Space needed here\n");
5842	}
5843	}
5844	ctxt->input->version = version;
5845
5846	/*
5847	* We must have the encoding declaration
5848	*/
5849	encoding = xmlParseEncodingDecl(ctxt);
5850	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
5851	/*
5852	* The XML REC instructs us to stop parsing right here
5853	*/
5854	return;
5855	}
5856	if ((encoding == NULL) && (ctxt->errNo == XML_ERR_OK)) {
5857	xmlFatalErrMsg(ctxt, XML_ERR_MISSING_ENCODING,
5858	"Missing encoding in text declaration\n");
5859	}
5860
5861	SKIP_BLANKS;
5862	if ((RAW == '?') && (NXT(1) == '>')) {
5863	SKIP(2);
5864	} else if (RAW == '>') {
5865	/* Deprecated old WD ... */
5866	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
5867	NEXT;
5868	} else {
5869	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
5870	MOVETO_ENDTAG(CUR_PTR);
5871	NEXT;
5872	}
5873	}
5874
5875	/**
5876	* xmlParseExternalSubset:
5877	* @ctxt: an XML parser context
5878	* @ExternalID: the external identifier
5879	* @SystemID: the system identifier (or URL)
5880	*
5881	* parse Markup declarations from an external subset
5882	*
5883	* [30] extSubset ::= textDecl? extSubsetDecl
5884	*
5885	* [31] extSubsetDecl ::= (markupdecl \| conditionalSect \| PEReference \| S) *
5886	*/
5887	void
5888	xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID,
5889	const xmlChar *SystemID) {
5890	xmlDetectSAX2(ctxt);
5891	GROW;
5892	if (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) {
5893	xmlParseTextDecl(ctxt);
5894	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
5895	/*
5896	* The XML REC instructs us to stop parsing right here
5897	*/
5898	ctxt->instate = XML_PARSER_EOF;
5899	return;
5900	}
5901	}
5902	if (ctxt->myDoc == NULL) {
5903	ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
5904	}
5905	if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
5906	xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
5907
5908	ctxt->instate = XML_PARSER_DTD;
5909	ctxt->external = 1;
5910	while (((RAW == '<') && (NXT(1) == '?')) \|\|
5911	((RAW == '<') && (NXT(1) == '!')) \|\|
5912	(RAW == '%') \|\| IS_BLANK_CH(CUR)) {
5913	const xmlChar *check = CUR_PTR;
5914	unsigned int cons = ctxt->input->consumed;
5915
5916	GROW;
5917	if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
5918	xmlParseConditionalSections(ctxt);
5919	} else if (IS_BLANK_CH(CUR)) {
5920	NEXT;
5921	} else if (RAW == '%') {
5922	xmlParsePEReference(ctxt);
5923	} else
5924	xmlParseMarkupDecl(ctxt);
5925
5926	/*
5927	* Pop-up of finished entities.
5928	*/
5929	while ((RAW == 0) && (ctxt->inputNr > 1))
5930	xmlPopInput(ctxt);
5931
5932	if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
5933	xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
5934	break;
5935	}
5936	}
5937
5938	if (RAW != 0) {
5939	xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
5940	}
5941
5942	}
5943
5944	/**
5945	* xmlParseReference:
5946	* @ctxt: an XML parser context
5947	*
5948	* parse and handle entity references in content, depending on the SAX
5949	* interface, this may end-up in a call to character() if this is a
5950	* CharRef, a predefined entity, if there is no reference() callback.
5951	* or if the parser was asked to switch to that mode.
5952	*
5953	* [67] Reference ::= EntityRef \| CharRef
5954	*/
5955	void
5956	xmlParseReference(xmlParserCtxtPtr ctxt) {
5957	xmlEntityPtr ent;
5958	xmlChar *val;
5959	if (RAW != '&') return;
5960
5961	if (NXT(1) == '#') {
5962	int i = 0;
5963	xmlChar out[10];
5964	int hex = NXT(2);
5965	int value = xmlParseCharRef(ctxt);
5966
5967	if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
5968	/*
5969	* So we are using non-UTF-8 buffers
5970	* Check that the char fit on 8bits, if not
5971	* generate a CharRef.
5972	*/
5973	if (value <= 0xFF) {
5974	out[0] = value;
5975	out[1] = 0;
5976	if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
5977	(!ctxt->disableSAX))
5978	ctxt->sax->characters(ctxt->userData, out, 1);
5979	} else {
5980	if ((hex == 'x') \|\| (hex == 'X'))
5981	snprintf((char *)out, sizeof(out), "#x%X", value);
5982	else
5983	snprintf((char *)out, sizeof(out), "#%d", value);
5984	if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
5985	(!ctxt->disableSAX))
5986	ctxt->sax->reference(ctxt->userData, out);
5987	}
5988	} else {
5989	/*
5990	* Just encode the value in UTF-8
5991	*/
5992	COPY_BUF(0 ,out, i, value);
5993	out[i] = 0;
5994	if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
5995	(!ctxt->disableSAX))
5996	ctxt->sax->characters(ctxt->userData, out, i);
5997	}
5998	} else {
5999	int was_checked;
6000
6001	ent = xmlParseEntityRef(ctxt);
6002	if (ent == NULL) return;
6003	if (!ctxt->wellFormed)
6004	return;
6005	ctxt->nbentities++;
6006	if (ctxt->nbentities >= 500000) {
6007	xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
6008	return;
6009	}
6010	was_checked = ent->checked;
6011	if ((ent->name != NULL) &&
6012	(ent->etype != XML_INTERNAL_PREDEFINED_ENTITY)) {
6013	xmlNodePtr list = NULL;
6014	xmlParserErrors ret = XML_ERR_OK;
6015
6016
6017	/*
6018	* The first reference to the entity trigger a parsing phase
6019	* where the ent->children is filled with the result from
6020	* the parsing.
6021	*/
6022	if (ent->checked == 0) {
6023	xmlChar *value;
6024
6025	value = ent->content;
6026
6027	/*
6028	* Check that this entity is well formed
6029	*/
6030	if ((value != NULL) && (value[0] != 0) &&
6031	(value[1] == 0) && (value[0] == '<') &&
6032	(xmlStrEqual(ent->name, BAD_CAST "lt"))) {
6033	/*
6034	* DONE: get definite answer on this !!!
6035	* Lots of entity decls are used to declare a single
6036	* char
6037	* <!ENTITY lt "<">
6038	* Which seems to be valid since
6039	* 2.4: The ampersand character (&) and the left angle
6040	* bracket (<) may appear in their literal form only
6041	* when used ... They are also legal within the literal
6042	* entity value of an internal entity declaration;i
6043	* see "4.3.2 Well-Formed Parsed Entities".
6044	* IMHO 2.4 and 4.3.2 are directly in contradiction.
6045	* Looking at the OASIS test suite and James Clark
6046	* tests, this is broken. However the XML REC uses
6047	* it. Is the XML REC not well-formed ????
6048	* This is a hack to avoid this problem
6049	*
6050	* ANSWER: since lt gt amp .. are already defined,
6051	* this is a redefinition and hence the fact that the
6052	* content is not well balanced is not a Wf error, this
6053	* is lousy but acceptable.
6054	*/
6055	list = xmlNewDocText(ctxt->myDoc, value);
6056	if (list != NULL) {
6057	if ((ent->etype == XML_INTERNAL_GENERAL_ENTITY) &&
6058	(ent->children == NULL)) {
6059	ent->children = list;
6060	ent->last = list;
6061	ent->owner = 1;
6062	list->parent = (xmlNodePtr) ent;
6063	} else {
6064	xmlFreeNodeList(list);
6065	}
6066	} else if (list != NULL) {
6067	xmlFreeNodeList(list);
6068	}
6069	} else {
6070	unsigned long oldnbent = ctxt->nbentities;
6071	/*
6072	* 4.3.2: An internal general parsed entity is well-formed
6073	* if its replacement text matches the production labeled
6074	* content.
6075	*/
6076
6077	void *user_data;
6078	/*
6079	* This is a bit hackish but this seems the best
6080	* way to make sure both SAX and DOM entity support
6081	* behaves okay.
6082	*/
6083	if (ctxt->userData == ctxt)
6084	user_data = NULL;
6085	else
6086	user_data = ctxt->userData;
6087
6088	if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
6089	ctxt->depth++;
6090	ret = xmlParseBalancedChunkMemoryInternal(ctxt,
6091	value, user_data, &list);
6092	ctxt->depth--;
6093	} else if (ent->etype ==
6094	XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
6095	ctxt->depth++;
6096	ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
6097	ctxt->sax, user_data, ctxt->depth,
6098	ent->URI, ent->ExternalID, &list);
6099	ctxt->depth--;
6100	} else {
6101	ret = XML_ERR_ENTITY_PE_INTERNAL;
6102	xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
6103	"invalid entity type found\n", NULL);
6104	}
6105	ent->checked = ctxt->nbentities - oldnbent;
6106	if (ret == XML_ERR_ENTITY_LOOP) {
6107	xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
6108	return;
6109	} else if ((ret == XML_ERR_OK) && (list != NULL)) {
6110	if (((ent->etype == XML_INTERNAL_GENERAL_ENTITY) \|\|
6111	(ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY))&&
6112	(ent->children == NULL)) {
6113	ent->children = list;
6114	if (ctxt->replaceEntities) {
6115	/*
6116	* Prune it directly in the generated document
6117	* except for single text nodes.
6118	*/
6119	if (((list->type == XML_TEXT_NODE) &&
6120	(list->next == NULL)) \|\|
6121	(ctxt->parseMode == XML_PARSE_READER)) {
6122	list->parent = (xmlNodePtr) ent;
6123	list = NULL;
6124	ent->owner = 1;
6125	} else {
6126	ent->owner = 0;
6127	while (list != NULL) {
6128	list->parent = (xmlNodePtr) ctxt->node;
6129	list->doc = ctxt->myDoc;
6130	if (list->next == NULL)
6131	ent->last = list;
6132	list = list->next;
6133	}
6134	list = ent->children;
6135	#ifdef LIBXML_LEGACY_ENABLED
6136	if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
6137	xmlAddEntityReference(ent, list, NULL);
6138	#endif /* LIBXML_LEGACY_ENABLED */
6139	}
6140	} else {
6141	ent->owner = 1;
6142	while (list != NULL) {
6143	list->parent = (xmlNodePtr) ent;
6144	if (list->next == NULL)
6145	ent->last = list;
6146	list = list->next;
6147	}
6148	}
6149	} else {
6150	xmlFreeNodeList(list);
6151	list = NULL;
6152	}
6153	} else if ((ret != XML_ERR_OK) &&
6154	(ret != XML_WAR_UNDECLARED_ENTITY)) {
6155	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6156	"Entity '%s' failed to parse\n", ent->name);
6157	} else if (list != NULL) {
6158	xmlFreeNodeList(list);
6159	list = NULL;
6160	}
6161	}
6162	if (ent->checked == 0)
6163	ent->checked = 1;
6164	}
6165	ctxt->nbentities += ent->checked;
6166
6167	if (ent->children == NULL) {
6168	/*
6169	* Probably running in SAX mode and the callbacks don't
6170	* build the entity content. So unless we already went
6171	* though parsing for first checking go though the entity
6172	* content to generate callbacks associated to the entity
6173	*/
6174	if (was_checked != 0) {
6175	void *user_data;
6176	/*
6177	* This is a bit hackish but this seems the best
6178	* way to make sure both SAX and DOM entity support
6179	* behaves okay.
6180	*/
6181	if (ctxt->userData == ctxt)
6182	user_data = NULL;
6183	else
6184	user_data = ctxt->userData;
6185
6186	if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
6187	ctxt->depth++;
6188	ret = xmlParseBalancedChunkMemoryInternal(ctxt,
6189	ent->content, user_data, NULL);
6190	ctxt->depth--;
6191	} else if (ent->etype ==
6192	XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
6193	ctxt->depth++;
6194	ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
6195	ctxt->sax, user_data, ctxt->depth,
6196	ent->URI, ent->ExternalID, NULL);
6197	ctxt->depth--;
6198	} else {
6199	ret = XML_ERR_ENTITY_PE_INTERNAL;
6200	xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
6201	"invalid entity type found\n", NULL);
6202	}
6203	if (ret == XML_ERR_ENTITY_LOOP) {
6204	xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
6205	return;
6206	}
6207	}
6208	if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
6209	(ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
6210	/*
6211	* Entity reference callback comes second, it's somewhat
6212	* superfluous but a compatibility to historical behaviour
6213	*/
6214	ctxt->sax->reference(ctxt->userData, ent->name);
6215	}
6216	return;
6217	}
6218	if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
6219	(ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
6220	/*
6221	* Create a node.
6222	*/
6223	ctxt->sax->reference(ctxt->userData, ent->name);
6224	return;
6225	}
6226	if ((ctxt->replaceEntities) \|\| (ent->children == NULL)) {
6227	/*
6228	* There is a problem on the handling of _private for entities
6229	* (bug 155816): Should we copy the content of the field from
6230	* the entity (possibly overwriting some value set by the user
6231	* when a copy is created), should we leave it alone, or should
6232	* we try to take care of different situations? The problem
6233	* is exacerbated by the usage of this field by the xmlReader.
6234	* To fix this bug, we look at _private on the created node
6235	* and, if it's NULL, we copy in whatever was in the entity.
6236	* If it's not NULL we leave it alone. This is somewhat of a
6237	* hack - maybe we should have further tests to determine
6238	* what to do.
6239	*/
6240	if ((ctxt->node != NULL) && (ent->children != NULL)) {
6241	/*
6242	* Seems we are generating the DOM content, do
6243	* a simple tree copy for all references except the first
6244	* In the first occurrence list contains the replacement.
6245	* progressive == 2 means we are operating on the Reader
6246	* and since nodes are discarded we must copy all the time.
6247	*/
6248	if (((list == NULL) && (ent->owner == 0)) \|\|
6249	(ctxt->parseMode == XML_PARSE_READER)) {
6250	xmlNodePtr nw = NULL, cur, firstChild = NULL;
6251
6252	/*
6253	* when operating on a reader, the entities definitions
6254	* are always owning the entities subtree.
6255	if (ctxt->parseMode == XML_PARSE_READER)
6256	ent->owner = 1;
6257	*/
6258
6259	cur = ent->children;
6260	while (cur != NULL) {
6261	nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
6262	if (nw != NULL) {
6263	if (nw->_private == NULL)
6264	nw->_private = cur->_private;
6265	if (firstChild == NULL){
6266	firstChild = nw;
6267	}
6268	nw = xmlAddChild(ctxt->node, nw);
6269	}
6270	if (cur == ent->last) {
6271	/*
6272	* needed to detect some strange empty
6273	* node cases in the reader tests
6274	*/
6275	if ((ctxt->parseMode == XML_PARSE_READER) &&
6276	(nw != NULL) &&
6277	(nw->type == XML_ELEMENT_NODE) &&
6278	(nw->children == NULL))
6279	nw->extra = 1;
6280
6281	break;
6282	}
6283	cur = cur->next;
6284	}
6285	#ifdef LIBXML_LEGACY_ENABLED
6286	if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
6287	xmlAddEntityReference(ent, firstChild, nw);
6288	#endif /* LIBXML_LEGACY_ENABLED */
6289	} else if (list == NULL) {
6290	xmlNodePtr nw = NULL, cur, next, last,
6291	firstChild = NULL;
6292	/*
6293	* Copy the entity child list and make it the new
6294	* entity child list. The goal is to make sure any
6295	* ID or REF referenced will be the one from the
6296	* document content and not the entity copy.
6297	*/
6298	cur = ent->children;
6299	ent->children = NULL;
6300	last = ent->last;
6301	ent->last = NULL;
6302	while (cur != NULL) {
6303	next = cur->next;
6304	cur->next = NULL;
6305	cur->parent = NULL;
6306	nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
6307	if (nw != NULL) {
6308	if (nw->_private == NULL)
6309	nw->_private = cur->_private;
6310	if (firstChild == NULL){
6311	firstChild = cur;
6312	}
6313	xmlAddChild((xmlNodePtr) ent, nw);
6314	xmlAddChild(ctxt->node, cur);
6315	}
6316	if (cur == last)
6317	break;
6318	cur = next;
6319	}
6320	ent->owner = 1;
6321	#ifdef LIBXML_LEGACY_ENABLED
6322	if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
6323	xmlAddEntityReference(ent, firstChild, nw);
6324	#endif /* LIBXML_LEGACY_ENABLED */
6325	} else {
6326	const xmlChar *nbktext;
6327
6328	/*
6329	* the name change is to avoid coalescing of the
6330	* node with a possible previous text one which
6331	* would make ent->children a dangling pointer
6332	*/
6333	nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
6334	-1);
6335	if (ent->children->type == XML_TEXT_NODE)
6336	ent->children->name = nbktext;
6337	if ((ent->last != ent->children) &&
6338	(ent->last->type == XML_TEXT_NODE))
6339	ent->last->name = nbktext;
6340	xmlAddChildList(ctxt->node, ent->children);
6341	}
6342
6343	/*
6344	* This is to avoid a nasty side effect, see
6345	* characters() in SAX.c
6346	*/
6347	ctxt->nodemem = 0;
6348	ctxt->nodelen = 0;
6349	return;
6350	}
6351	}
6352	} else {
6353	val = ent->content;
6354	if (val == NULL) return;
6355	/*
6356	* inline the entity.
6357	*/
6358	if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
6359	(!ctxt->disableSAX))
6360	ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
6361	}
6362	}
6363	}
6364
6365	/**
6366	* xmlParseEntityRef:
6367	* @ctxt: an XML parser context
6368	*
6369	* parse ENTITY references declarations
6370	*
6371	* [68] EntityRef ::= '&' Name ';'
6372	*
6373	* [ WFC: Entity Declared ]
6374	* In a document without any DTD, a document with only an internal DTD
6375	* subset which contains no parameter entity references, or a document
6376	* with "standalone='yes'", the Name given in the entity reference
6377	* must match that in an entity declaration, except that well-formed
6378	* documents need not declare any of the following entities: amp, lt,
6379	* gt, apos, quot. The declaration of a parameter entity must precede
6380	* any reference to it. Similarly, the declaration of a general entity
6381	* must precede any reference to it which appears in a default value in an
6382	* attribute-list declaration. Note that if entities are declared in the
6383	* external subset or in external parameter entities, a non-validating
6384	* processor is not obligated to read and process their declarations;
6385	* for such documents, the rule that an entity must be declared is a
6386	* well-formedness constraint only if standalone='yes'.
6387	*
6388	* [ WFC: Parsed Entity ]
6389	* An entity reference must not contain the name of an unparsed entity
6390	*
6391	* Returns the xmlEntityPtr if found, or NULL otherwise.
6392	*/
6393	xmlEntityPtr
6394	xmlParseEntityRef(xmlParserCtxtPtr ctxt) {
6395	const xmlChar *name;
6396	xmlEntityPtr ent = NULL;
6397
6398	GROW;
6399
6400	if (RAW == '&') {
6401	NEXT;
6402	name = xmlParseName(ctxt);
6403	if (name == NULL) {
6404	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6405	"xmlParseEntityRef: no name\n");
6406	} else {
6407	if (RAW == ';') {
6408	NEXT;
6409	/*
6410	* Ask first SAX for entity resolution, otherwise try the
6411	* predefined set.
6412	*/
6413	if (ctxt->sax != NULL) {
6414	if (ctxt->sax->getEntity != NULL)
6415	ent = ctxt->sax->getEntity(ctxt->userData, name);
6416	if ((ctxt->wellFormed == 1 ) && (ent == NULL))
6417	ent = xmlGetPredefinedEntity(name);
6418	if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
6419	(ctxt->userData==ctxt)) {
6420	ent = xmlSAX2GetEntity(ctxt, name);
6421	}
6422	}
6423	/*
6424	* [ WFC: Entity Declared ]
6425	* In a document without any DTD, a document with only an
6426	* internal DTD subset which contains no parameter entity
6427	* references, or a document with "standalone='yes'", the
6428	* Name given in the entity reference must match that in an
6429	* entity declaration, except that well-formed documents
6430	* need not declare any of the following entities: amp, lt,
6431	* gt, apos, quot.
6432	* The declaration of a parameter entity must precede any
6433	* reference to it.
6434	* Similarly, the declaration of a general entity must
6435	* precede any reference to it which appears in a default
6436	* value in an attribute-list declaration. Note that if
6437	* entities are declared in the external subset or in
6438	* external parameter entities, a non-validating processor
6439	* is not obligated to read and process their declarations;
6440	* for such documents, the rule that an entity must be
6441	* declared is a well-formedness constraint only if
6442	* standalone='yes'.
6443	*/
6444	if (ent == NULL) {
6445	if ((ctxt->standalone == 1) \|\|
6446	((ctxt->hasExternalSubset == 0) &&
6447	(ctxt->hasPErefs == 0))) {
6448	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6449	"Entity '%s' not defined\n", name);
6450	} else {
6451	xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
6452	"Entity '%s' not defined\n", name);
6453	if ((ctxt->inSubset == 0) &&
6454	(ctxt->sax != NULL) &&
6455	(ctxt->sax->reference != NULL)) {
6456	ctxt->sax->reference(ctxt->userData, name);
6457	}
6458	}
6459	ctxt->valid = 0;
6460	}
6461
6462	/*
6463	* [ WFC: Parsed Entity ]
6464	* An entity reference must not contain the name of an
6465	* unparsed entity
6466	*/
6467	else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
6468	xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
6469	"Entity reference to unparsed entity %s\n", name);
6470	}
6471
6472	/*
6473	* [ WFC: No External Entity References ]
6474	* Attribute values cannot contain direct or indirect
6475	* entity references to external entities.
6476	*/
6477	else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
6478	(ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
6479	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
6480	"Attribute references external entity '%s'\n", name);
6481	}
6482	/*
6483	* [ WFC: No < in Attribute Values ]
6484	* The replacement text of any entity referred to directly or
6485	* indirectly in an attribute value (other than "<") must
6486	* not contain a <.
6487	*/
6488	else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
6489	(ent != NULL) &&
6490	(!xmlStrEqual(ent->name, BAD_CAST "lt")) &&
6491	(ent->content != NULL) &&
6492	(xmlStrchr(ent->content, '<'))) {
6493	xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
6494	"'<' in entity '%s' is not allowed in attributes values\n", name);
6495	}
6496
6497	/*
6498	* Internal check, no parameter entities here ...
6499	*/
6500	else {
6501	switch (ent->etype) {
6502	case XML_INTERNAL_PARAMETER_ENTITY:
6503	case XML_EXTERNAL_PARAMETER_ENTITY:
6504	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
6505	"Attempt to reference the parameter entity '%s'\n",
6506	name);
6507	break;
6508	default:
6509	break;
6510	}
6511	}
6512
6513	/*
6514	* [ WFC: No Recursion ]
6515	* A parsed entity must not contain a recursive reference
6516	* to itself, either directly or indirectly.
6517	* Done somewhere else
6518	*/
6519
6520	} else {
6521	xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
6522	}
6523	}
6524	}
6525	return(ent);
6526	}
6527
6528	/**
6529	* xmlParseStringEntityRef:
6530	* @ctxt: an XML parser context
6531	* @str: a pointer to an index in the string
6532	*
6533	* parse ENTITY references declarations, but this version parses it from
6534	* a string value.
6535	*
6536	* [68] EntityRef ::= '&' Name ';'
6537	*
6538	* [ WFC: Entity Declared ]
6539	* In a document without any DTD, a document with only an internal DTD
6540	* subset which contains no parameter entity references, or a document
6541	* with "standalone='yes'", the Name given in the entity reference
6542	* must match that in an entity declaration, except that well-formed
6543	* documents need not declare any of the following entities: amp, lt,
6544	* gt, apos, quot. The declaration of a parameter entity must precede
6545	* any reference to it. Similarly, the declaration of a general entity
6546	* must precede any reference to it which appears in a default value in an
6547	* attribute-list declaration. Note that if entities are declared in the
6548	* external subset or in external parameter entities, a non-validating
6549	* processor is not obligated to read and process their declarations;
6550	* for such documents, the rule that an entity must be declared is a
6551	* well-formedness constraint only if standalone='yes'.
6552	*
6553	* [ WFC: Parsed Entity ]
6554	* An entity reference must not contain the name of an unparsed entity
6555	*
6556	* Returns the xmlEntityPtr if found, or NULL otherwise. The str pointer
6557	* is updated to the current location in the string.
6558	*/
6559	xmlEntityPtr
6560	xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
6561	xmlChar *name;
6562	const xmlChar *ptr;
6563	xmlChar cur;
6564	xmlEntityPtr ent = NULL;
6565
6566	if ((str == NULL) \|\| (*str == NULL))
6567	return(NULL);
6568	ptr = *str;
6569	cur = *ptr;
6570	if (cur == '&') {
6571	ptr++;
6572	cur = *ptr;
6573	name = xmlParseStringName(ctxt, &ptr);
6574	if (name == NULL) {
6575	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6576	"xmlParseStringEntityRef: no name\n");
6577	} else {
6578	if (*ptr == ';') {
6579	ptr++;
6580	/*
6581	* Ask first SAX for entity resolution, otherwise try the
6582	* predefined set.
6583	*/
6584	if (ctxt->sax != NULL) {
6585	if (ctxt->sax->getEntity != NULL)
6586	ent = ctxt->sax->getEntity(ctxt->userData, name);
6587	if (ent == NULL)
6588	ent = xmlGetPredefinedEntity(name);
6589	if ((ent == NULL) && (ctxt->userData==ctxt)) {
6590	ent = xmlSAX2GetEntity(ctxt, name);
6591	}
6592	}
6593	/*
6594	* [ WFC: Entity Declared ]
6595	* In a document without any DTD, a document with only an
6596	* internal DTD subset which contains no parameter entity
6597	* references, or a document with "standalone='yes'", the
6598	* Name given in the entity reference must match that in an
6599	* entity declaration, except that well-formed documents
6600	* need not declare any of the following entities: amp, lt,
6601	* gt, apos, quot.
6602	* The declaration of a parameter entity must precede any
6603	* reference to it.
6604	* Similarly, the declaration of a general entity must
6605	* precede any reference to it which appears in a default
6606	* value in an attribute-list declaration. Note that if
6607	* entities are declared in the external subset or in
6608	* external parameter entities, a non-validating processor
6609	* is not obligated to read and process their declarations;
6610	* for such documents, the rule that an entity must be
6611	* declared is a well-formedness constraint only if
6612	* standalone='yes'.
6613	*/
6614	if (ent == NULL) {
6615	if ((ctxt->standalone == 1) \|\|
6616	((ctxt->hasExternalSubset == 0) &&
6617	(ctxt->hasPErefs == 0))) {
6618	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6619	"Entity '%s' not defined\n", name);
6620	} else {
6621	xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
6622	"Entity '%s' not defined\n",
6623	name);
6624	}
6625	/* TODO ? check regressions ctxt->valid = 0; */
6626	}
6627
6628	/*
6629	* [ WFC: Parsed Entity ]
6630	* An entity reference must not contain the name of an
6631	* unparsed entity
6632	*/
6633	else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
6634	xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
6635	"Entity reference to unparsed entity %s\n", name);
6636	}
6637
6638	/*
6639	* [ WFC: No External Entity References ]
6640	* Attribute values cannot contain direct or indirect
6641	* entity references to external entities.
6642	*/
6643	else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
6644	(ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
6645	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
6646	"Attribute references external entity '%s'\n", name);
6647	}
6648	/*
6649	* [ WFC: No < in Attribute Values ]
6650	* The replacement text of any entity referred to directly or
6651	* indirectly in an attribute value (other than "<") must
6652	* not contain a <.
6653	*/
6654	else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
6655	(ent != NULL) &&
6656	(!xmlStrEqual(ent->name, BAD_CAST "lt")) &&
6657	(ent->content != NULL) &&
6658	(xmlStrchr(ent->content, '<'))) {
6659	xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
6660	"'<' in entity '%s' is not allowed in attributes values\n",
6661	name);
6662	}
6663
6664	/*
6665	* Internal check, no parameter entities here ...
6666	*/
6667	else {
6668	switch (ent->etype) {
6669	case XML_INTERNAL_PARAMETER_ENTITY:
6670	case XML_EXTERNAL_PARAMETER_ENTITY:
6671	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
6672	"Attempt to reference the parameter entity '%s'\n",
6673	name);
6674	break;
6675	default:
6676	break;
6677	}
6678	}
6679
6680	/*
6681	* [ WFC: No Recursion ]
6682	* A parsed entity must not contain a recursive reference
6683	* to itself, either directly or indirectly.
6684	* Done somewhere else
6685	*/
6686
6687	} else {
6688	xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
6689	}
6690	xmlFree(name);
6691	}
6692	}
6693	*str = ptr;
6694	return(ent);
6695	}
6696
6697	/**
6698	* xmlParsePEReference:
6699	* @ctxt: an XML parser context
6700	*
6701	* parse PEReference declarations
6702	* The entity content is handled directly by pushing it's content as
6703	* a new input stream.
6704	*
6705	* [69] PEReference ::= '%' Name ';'
6706	*
6707	* [ WFC: No Recursion ]
6708	* A parsed entity must not contain a recursive
6709	* reference to itself, either directly or indirectly.
6710	*
6711	* [ WFC: Entity Declared ]
6712	* In a document without any DTD, a document with only an internal DTD
6713	* subset which contains no parameter entity references, or a document
6714	* with "standalone='yes'", ... ... The declaration of a parameter
6715	* entity must precede any reference to it...
6716	*
6717	* [ VC: Entity Declared ]
6718	* In a document with an external subset or external parameter entities
6719	* with "standalone='no'", ... ... The declaration of a parameter entity
6720	* must precede any reference to it...
6721	*
6722	* [ WFC: In DTD ]
6723	* Parameter-entity references may only appear in the DTD.
6724	* NOTE: misleading but this is handled.
6725	*/
6726	void
6727	xmlParsePEReference(xmlParserCtxtPtr ctxt)
6728	{
6729	const xmlChar *name;
6730	xmlEntityPtr entity = NULL;
6731	xmlParserInputPtr input;
6732
6733	if (RAW == '%') {
6734	NEXT;
6735	name = xmlParseName(ctxt);
6736	if (name == NULL) {
6737	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6738	"xmlParsePEReference: no name\n");
6739	} else {
6740	if (RAW == ';') {
6741	NEXT;
6742	if ((ctxt->sax != NULL) &&
6743	(ctxt->sax->getParameterEntity != NULL))
6744	entity = ctxt->sax->getParameterEntity(ctxt->userData,
6745	name);
6746	if (entity == NULL) {
6747	/*
6748	* [ WFC: Entity Declared ]
6749	* In a document without any DTD, a document with only an
6750	* internal DTD subset which contains no parameter entity
6751	* references, or a document with "standalone='yes'", ...
6752	* ... The declaration of a parameter entity must precede
6753	* any reference to it...
6754	*/
6755	if ((ctxt->standalone == 1) \|\|
6756	((ctxt->hasExternalSubset == 0) &&
6757	(ctxt->hasPErefs == 0))) {
6758	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6759	"PEReference: %%%s; not found\n",
6760	name);
6761	} else {
6762	/*
6763	* [ VC: Entity Declared ]
6764	* In a document with an external subset or external
6765	* parameter entities with "standalone='no'", ...
6766	* ... The declaration of a parameter entity must
6767	* precede any reference to it...
6768	*/
6769	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
6770	"PEReference: %%%s; not found\n",
6771	name, NULL);
6772	ctxt->valid = 0;
6773	}
6774	} else {
6775	/*
6776	* Internal checking in case the entity quest barfed
6777	*/
6778	if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
6779	(entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
6780	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
6781	"Internal: %%%s; is not a parameter entity\n",
6782	name, NULL);
6783	} else if (ctxt->input->free != deallocblankswrapper) {
6784	input =
6785	xmlNewBlanksWrapperInputStream(ctxt, entity);
6786	xmlPushInput(ctxt, input);
6787	} else {
6788	/*
6789	* TODO !!!
6790	* handle the extra spaces added before and after
6791	* c.f. http://www.w3.org/TR/REC-xml#as-PE
6792	*/
6793	input = xmlNewEntityInputStream(ctxt, entity);
6794	xmlPushInput(ctxt, input);
6795	if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
6796	(CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
6797	(IS_BLANK_CH(NXT(5)))) {
6798	xmlParseTextDecl(ctxt);
6799	if (ctxt->errNo ==
6800	XML_ERR_UNSUPPORTED_ENCODING) {
6801	/*
6802	* The XML REC instructs us to stop parsing
6803	* right here
6804	*/
6805	ctxt->instate = XML_PARSER_EOF;
6806	return;
6807	}
6808	}
6809	}
6810	}
6811	ctxt->hasPErefs = 1;
6812	} else {
6813	xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
6814	}
6815	}
6816	}
6817	}
6818
6819	/**
6820	* xmlParseStringPEReference:
6821	* @ctxt: an XML parser context
6822	* @str: a pointer to an index in the string
6823	*
6824	* parse PEReference declarations
6825	*
6826	* [69] PEReference ::= '%' Name ';'
6827	*
6828	* [ WFC: No Recursion ]
6829	* A parsed entity must not contain a recursive
6830	* reference to itself, either directly or indirectly.
6831	*
6832	* [ WFC: Entity Declared ]
6833	* In a document without any DTD, a document with only an internal DTD
6834	* subset which contains no parameter entity references, or a document
6835	* with "standalone='yes'", ... ... The declaration of a parameter
6836	* entity must precede any reference to it...
6837	*
6838	* [ VC: Entity Declared ]
6839	* In a document with an external subset or external parameter entities
6840	* with "standalone='no'", ... ... The declaration of a parameter entity
6841	* must precede any reference to it...
6842	*
6843	* [ WFC: In DTD ]
6844	* Parameter-entity references may only appear in the DTD.
6845	* NOTE: misleading but this is handled.
6846	*
6847	* Returns the string of the entity content.
6848	* str is updated to the current value of the index
6849	*/
6850	xmlEntityPtr
6851	xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) {
6852	const xmlChar *ptr;
6853	xmlChar cur;
6854	xmlChar *name;
6855	xmlEntityPtr entity = NULL;
6856
6857	if ((str == NULL) \|\| (*str == NULL)) return(NULL);
6858	ptr = *str;
6859	cur = *ptr;
6860	if (cur == '%') {
6861	ptr++;
6862	cur = *ptr;
6863	name = xmlParseStringName(ctxt, &ptr);
6864	if (name == NULL) {
6865	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6866	"xmlParseStringPEReference: no name\n");
6867	} else {
6868	cur = *ptr;
6869	if (cur == ';') {
6870	ptr++;
6871	cur = *ptr;
6872	if ((ctxt->sax != NULL) &&
6873	(ctxt->sax->getParameterEntity != NULL))
6874	entity = ctxt->sax->getParameterEntity(ctxt->userData,
6875	name);
6876	if (entity == NULL) {
6877	/*
6878	* [ WFC: Entity Declared ]
6879	* In a document without any DTD, a document with only an
6880	* internal DTD subset which contains no parameter entity
6881	* references, or a document with "standalone='yes'", ...
6882	* ... The declaration of a parameter entity must precede
6883	* any reference to it...
6884	*/
6885	if ((ctxt->standalone == 1) \|\|
6886	((ctxt->hasExternalSubset == 0) &&
6887	(ctxt->hasPErefs == 0))) {
6888	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6889	"PEReference: %%%s; not found\n", name);
6890	} else {
6891	/*
6892	* [ VC: Entity Declared ]
6893	* In a document with an external subset or external
6894	* parameter entities with "standalone='no'", ...
6895	* ... The declaration of a parameter entity must
6896	* precede any reference to it...
6897	*/
6898	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
6899	"PEReference: %%%s; not found\n",
6900	name, NULL);
6901	ctxt->valid = 0;
6902	}
6903	} else {
6904	/*
6905	* Internal checking in case the entity quest barfed
6906	*/
6907	if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
6908	(entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
6909	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
6910	"%%%s; is not a parameter entity\n",
6911	name, NULL);
6912	}
6913	}
6914	ctxt->hasPErefs = 1;
6915	} else {
6916	xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
6917	}
6918	xmlFree(name);
6919	}
6920	}
6921	*str = ptr;
6922	return(entity);
6923	}
6924
6925	/**
6926	* xmlParseDocTypeDecl:
6927	* @ctxt: an XML parser context
6928	*
6929	* parse a DOCTYPE declaration
6930	*
6931	* [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S?
6932	* ('[' (markupdecl \| PEReference \| S)* ']' S?)? '>'
6933	*
6934	* [ VC: Root Element Type ]
6935	* The Name in the document type declaration must match the element
6936	* type of the root element.
6937	*/
6938
6939	void
6940	xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) {
6941	const xmlChar *name = NULL;
6942	xmlChar *ExternalID = NULL;
6943	xmlChar *URI = NULL;
6944
6945	/*
6946	* We know that '<!DOCTYPE' has been detected.
6947	*/
6948	SKIP(9);
6949
6950	SKIP_BLANKS;
6951
6952	/*
6953	* Parse the DOCTYPE name.
6954	*/
6955	name = xmlParseName(ctxt);
6956	if (name == NULL) {
6957	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6958	"xmlParseDocTypeDecl : no DOCTYPE name !\n");
6959	}
6960	ctxt->intSubName = name;
6961
6962	SKIP_BLANKS;
6963
6964	/*
6965	* Check for SystemID and ExternalID
6966	*/
6967	URI = xmlParseExternalID(ctxt, &ExternalID, 1);
6968
6969	if ((URI != NULL) \|\| (ExternalID != NULL)) {
6970	ctxt->hasExternalSubset = 1;
6971	}
6972	ctxt->extSubURI = URI;
6973	ctxt->extSubSystem = ExternalID;
6974
6975	SKIP_BLANKS;
6976
6977	/*
6978	* Create and update the internal subset.
6979	*/
6980	if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
6981	(!ctxt->disableSAX))
6982	ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
6983
6984	/*
6985	* Is there any internal subset declarations ?
6986	* they are handled separately in xmlParseInternalSubset()
6987	*/
6988	if (RAW == '[')
6989	return;
6990
6991	/*
6992	* We should be at the end of the DOCTYPE declaration.
6993	*/
6994	if (RAW != '>') {
6995	xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
6996	}
6997	NEXT;
6998	}
6999
7000	/**
7001	* xmlParseInternalSubset:
7002	* @ctxt: an XML parser context
7003	*
7004	* parse the internal subset declaration
7005	*
7006	* [28 end] ('[' (markupdecl \| PEReference \| S)* ']' S?)? '>'
7007	*/
7008
7009	static void
7010	xmlParseInternalSubset(xmlParserCtxtPtr ctxt) {
7011	/*
7012	* Is there any DTD definition ?
7013	*/
7014	if (RAW == '[') {
7015	ctxt->instate = XML_PARSER_DTD;
7016	NEXT;
7017	/*
7018	* Parse the succession of Markup declarations and
7019	* PEReferences.
7020	* Subsequence (markupdecl \| PEReference \| S)*
7021	*/
7022	while (RAW != ']') {
7023	const xmlChar *check = CUR_PTR;
7024	unsigned int cons = ctxt->input->consumed;
7025
7026	SKIP_BLANKS;
7027	xmlParseMarkupDecl(ctxt);
7028	xmlParsePEReference(ctxt);
7029
7030	/*
7031	* Pop-up of finished entities.
7032	*/
7033	while ((RAW == 0) && (ctxt->inputNr > 1))
7034	xmlPopInput(ctxt);
7035
7036	if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
7037	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
7038	"xmlParseInternalSubset: error detected in Markup declaration\n");
7039	break;
7040	}
7041	}
7042	if (RAW == ']') {
7043	NEXT;
7044	SKIP_BLANKS;
7045	}
7046	}
7047
7048	/*
7049	* We should be at the end of the DOCTYPE declaration.
7050	*/
7051	if (RAW != '>') {
7052	xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
7053	}
7054	NEXT;
7055	}
7056
7057	#ifdef LIBXML_SAX1_ENABLED
7058	/**
7059	* xmlParseAttribute:
7060	* @ctxt: an XML parser context
7061	* @value: a xmlChar ** used to store the value of the attribute
7062	*
7063	* parse an attribute
7064	*
7065	* [41] Attribute ::= Name Eq AttValue
7066	*
7067	* [ WFC: No External Entity References ]
7068	* Attribute values cannot contain direct or indirect entity references
7069	* to external entities.
7070	*
7071	* [ WFC: No < in Attribute Values ]
7072	* The replacement text of any entity referred to directly or indirectly in
7073	* an attribute value (other than "<") must not contain a <.
7074	*
7075	* [ VC: Attribute Value Type ]
7076	* The attribute must have been declared; the value must be of the type
7077	* declared for it.
7078	*
7079	* [25] Eq ::= S? '=' S?
7080	*
7081	* With namespace:
7082	*
7083	* [NS 11] Attribute ::= QName Eq AttValue
7084	*
7085	* Also the case QName == xmlns:??? is handled independently as a namespace
7086	* definition.
7087	*
7088	* Returns the attribute name, and the value in *value.
7089	*/
7090
7091	const xmlChar *
7092	xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) {
7093	const xmlChar *name;
7094	xmlChar *val;
7095
7096	*value = NULL;
7097	GROW;
7098	name = xmlParseName(ctxt);
7099	if (name == NULL) {
7100	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7101	"error parsing attribute name\n");
7102	return(NULL);
7103	}
7104
7105	/*
7106	* read the value
7107	*/
7108	SKIP_BLANKS;
7109	if (RAW == '=') {
7110	NEXT;
7111	SKIP_BLANKS;
7112	val = xmlParseAttValue(ctxt);
7113	ctxt->instate = XML_PARSER_CONTENT;
7114	} else {
7115	xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
7116	"Specification mandate value for attribute %s\n", name);
7117	return(NULL);
7118	}
7119
7120	/*
7121	* Check that xml:lang conforms to the specification
7122	* No more registered as an error, just generate a warning now
7123	* since this was deprecated in XML second edition
7124	*/
7125	if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
7126	if (!xmlCheckLanguageID(val)) {
7127	xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
7128	"Malformed value for xml:lang : %s\n",
7129	val, NULL);
7130	}
7131	}
7132
7133	/*
7134	* Check that xml:space conforms to the specification
7135	*/
7136	if (xmlStrEqual(name, BAD_CAST "xml:space")) {
7137	if (xmlStrEqual(val, BAD_CAST "default"))
7138	*(ctxt->space) = 0;
7139	else if (xmlStrEqual(val, BAD_CAST "preserve"))
7140	*(ctxt->space) = 1;
7141	else {
7142	xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
7143	"Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
7144	val, NULL);
7145	}
7146	}
7147
7148	*value = val;
7149	return(name);
7150	}
7151
7152	/**
7153	* xmlParseStartTag:
7154	* @ctxt: an XML parser context
7155	*
7156	* parse a start of tag either for rule element or
7157	* EmptyElement. In both case we don't parse the tag closing chars.
7158	*
7159	* [40] STag ::= '<' Name (S Attribute)* S? '>'
7160	*
7161	* [ WFC: Unique Att Spec ]
7162	* No attribute name may appear more than once in the same start-tag or
7163	* empty-element tag.
7164	*
7165	* [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
7166	*
7167	* [ WFC: Unique Att Spec ]
7168	* No attribute name may appear more than once in the same start-tag or
7169	* empty-element tag.
7170	*
7171	* With namespace:
7172	*
7173	* [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
7174	*
7175	* [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
7176	*
7177	* Returns the element name parsed
7178	*/
7179
7180	const xmlChar *
7181	xmlParseStartTag(xmlParserCtxtPtr ctxt) {
7182	const xmlChar *name;
7183	const xmlChar *attname;
7184	xmlChar *attvalue;
7185	const xmlChar **atts = ctxt->atts;
7186	int nbatts = 0;
7187	int maxatts = ctxt->maxatts;
7188	int i;
7189
7190	if (RAW != '<') return(NULL);
7191	NEXT1;
7192
7193	name = xmlParseName(ctxt);
7194	if (name == NULL) {
7195	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7196	"xmlParseStartTag: invalid element name\n");
7197	return(NULL);
7198	}
7199
7200	/*
7201	* Now parse the attributes, it ends up with the ending
7202	*
7203	* (S Attribute)* S?
7204	*/
7205	SKIP_BLANKS;
7206	GROW;
7207
7208	while ((RAW != '>') &&
7209	((RAW != '/') \|\| (NXT(1) != '>')) &&
7210	(IS_BYTE_CHAR(RAW))) {
7211	const xmlChar *q = CUR_PTR;
7212	unsigned int cons = ctxt->input->consumed;
7213
7214	attname = xmlParseAttribute(ctxt, &attvalue);
7215	if ((attname != NULL) && (attvalue != NULL)) {
7216	/*
7217	* [ WFC: Unique Att Spec ]
7218	* No attribute name may appear more than once in the same
7219	* start-tag or empty-element tag.
7220	*/
7221	for (i = 0; i < nbatts;i += 2) {
7222	if (xmlStrEqual(atts[i], attname)) {
7223	xmlErrAttributeDup(ctxt, NULL, attname);
7224	xmlFree(attvalue);
7225	goto failed;
7226	}
7227	}
7228	/*
7229	* Add the pair to atts
7230	*/
7231	if (atts == NULL) {
7232	maxatts = 22; /* allow for 10 attrs by default */
7233	atts = (const xmlChar **)
7234	xmlMalloc(maxatts * sizeof(xmlChar *));
7235	if (atts == NULL) {
7236	xmlErrMemory(ctxt, NULL);
7237	if (attvalue != NULL)
7238	xmlFree(attvalue);
7239	goto failed;
7240	}
7241	ctxt->atts = atts;
7242	ctxt->maxatts = maxatts;
7243	} else if (nbatts + 4 > maxatts) {
7244	const xmlChar **n;
7245
7246	maxatts *= 2;
7247	n = (const xmlChar *) xmlRealloc((void ) atts,
7248	maxatts * sizeof(const xmlChar *));
7249	if (n == NULL) {
7250	xmlErrMemory(ctxt, NULL);
7251	if (attvalue != NULL)
7252	xmlFree(attvalue);
7253	goto failed;
7254	}
7255	atts = n;
7256	ctxt->atts = atts;
7257	ctxt->maxatts = maxatts;
7258	}
7259	atts[nbatts++] = attname;
7260	atts[nbatts++] = attvalue;
7261	atts[nbatts] = NULL;
7262	atts[nbatts + 1] = NULL;
7263	} else {
7264	if (attvalue != NULL)
7265	xmlFree(attvalue);
7266	}
7267
7268	failed:
7269
7270	GROW
7271	if ((RAW == '>') \|\| (((RAW == '/') && (NXT(1) == '>'))))
7272	break;
7273	if (!IS_BLANK_CH(RAW)) {
7274	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
7275	"attributes construct error\n");
7276	}
7277	SKIP_BLANKS;
7278	if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
7279	(attname == NULL) && (attvalue == NULL)) {
7280	xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
7281	"xmlParseStartTag: problem parsing attributes\n");
7282	break;
7283	}
7284	SHRINK;
7285	GROW;
7286	}
7287
7288	/*
7289	* SAX: Start of Element !
7290	*/
7291	if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) &&
7292	(!ctxt->disableSAX)) {
7293	if (nbatts > 0)
7294	ctxt->sax->startElement(ctxt->userData, name, atts);
7295	else
7296	ctxt->sax->startElement(ctxt->userData, name, NULL);
7297	}
7298
7299	if (atts != NULL) {
7300	/* Free only the content strings */
7301	for (i = 1;i < nbatts;i+=2)
7302	if (atts[i] != NULL)
7303	xmlFree((xmlChar *) atts[i]);
7304	}
7305	return(name);
7306	}
7307
7308	/**
7309	* xmlParseEndTag1:
7310	* @ctxt: an XML parser context
7311	* @line: line of the start tag
7312	* @nsNr: number of namespaces on the start tag
7313	*
7314	* parse an end of tag
7315	*
7316	* [42] ETag ::= '</' Name S? '>'
7317	*
7318	* With namespace
7319	*
7320	* [NS 9] ETag ::= '</' QName S? '>'
7321	*/
7322
7323	static void
7324	xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) {
7325	const xmlChar *name;
7326
7327	GROW;
7328	if ((RAW != '<') \|\| (NXT(1) != '/')) {
7329	xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED,
7330	"xmlParseEndTag: '</' not found\n");
7331	return;
7332	}
7333	SKIP(2);
7334
7335	name = xmlParseNameAndCompare(ctxt,ctxt->name);
7336
7337	/*
7338	* We should definitely be at the ending "S? '>'" part
7339	*/
7340	GROW;
7341	SKIP_BLANKS;
7342	if ((!IS_BYTE_CHAR(RAW)) \|\| (RAW != '>')) {
7343	xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
7344	} else
7345	NEXT1;
7346
7347	/*
7348	* [ WFC: Element Type Match ]
7349	* The Name in an element's end-tag must match the element type in the
7350	* start-tag.
7351	*
7352	*/
7353	if (name != (xmlChar*)1) {
7354	if (name == NULL) name = BAD_CAST "unparseable";
7355	xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
7356	"Opening and ending tag mismatch: %s line %d and %s\n",
7357	ctxt->name, line, name);
7358	}
7359
7360	/*
7361	* SAX: End of Tag
7362	*/
7363	if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
7364	(!ctxt->disableSAX))
7365	ctxt->sax->endElement(ctxt->userData, ctxt->name);
7366
7367	namePop(ctxt);
7368	spacePop(ctxt);
7369	return;
7370	}
7371
7372	/**
7373	* xmlParseEndTag:
7374	* @ctxt: an XML parser context
7375	*
7376	* parse an end of tag
7377	*
7378	* [42] ETag ::= '</' Name S? '>'
7379	*
7380	* With namespace
7381	*
7382	* [NS 9] ETag ::= '</' QName S? '>'
7383	*/
7384
7385	void
7386	xmlParseEndTag(xmlParserCtxtPtr ctxt) {
7387	xmlParseEndTag1(ctxt, 0);
7388	}
7389	#endif /* LIBXML_SAX1_ENABLED */
7390
7391	/************************************************************************
7392	* *
7393	* SAX 2 specific operations *
7394	* *
7395	************************************************************************/
7396
7397	static const xmlChar *
7398	xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
7399	int len = 0, l;
7400	int c;
7401	int count = 0;
7402
7403	/*
7404	* Handler for more complex cases
7405	*/
7406	GROW;
7407	c = CUR_CHAR(l);
7408	if ((c == ' ') \|\| (c == '>') \|\| (c == '/') \|\| /* accelerators */
7409	(!IS_LETTER(c) && (c != '_'))) {
7410	return(NULL);
7411	}
7412
7413	while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
7414	((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\|
7415	(c == '.') \|\| (c == '-') \|\| (c == '_') \|\|
7416	(IS_COMBINING(c)) \|\|
7417	(IS_EXTENDER(c)))) {
7418	if (count++ > 100) {
7419	count = 0;
7420	GROW;
7421	}
7422	len += l;
7423	NEXTL(l);
7424	c = CUR_CHAR(l);
7425	}
7426	return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
7427	}
7428
7429	/*
7430	* xmlGetNamespace:
7431	* @ctxt: an XML parser context
7432	* @prefix: the prefix to lookup
7433	*
7434	* Lookup the namespace name for the @prefix (which ca be NULL)
7435	* The prefix must come from the @ctxt->dict dictionnary
7436	*
7437	* Returns the namespace name or NULL if not bound
7438	*/
7439	static const xmlChar *
7440	xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
7441	int i;
7442
7443	if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns);
7444	for (i = ctxt->nsNr - 2;i >= 0;i-=2)
7445	if (ctxt->nsTab[i] == prefix) {
7446	if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0))
7447	return(NULL);
7448	return(ctxt->nsTab[i + 1]);
7449	}
7450	return(NULL);
7451	}
7452
7453	/**
7454	* xmlParseNCName:
7455	* @ctxt: an XML parser context
7456	* @len: lenght of the string parsed
7457	*
7458	* parse an XML name.
7459	*
7460	* [4NS] NCNameChar ::= Letter \| Digit \| '.' \| '-' \| '_' \|
7461	* CombiningChar \| Extender
7462	*
7463	* [5NS] NCName ::= (Letter \| '_') (NCNameChar)*
7464	*
7465	* Returns the Name parsed or NULL
7466	*/
7467
7468	static const xmlChar *
7469	xmlParseNCName(xmlParserCtxtPtr ctxt) {
7470	const xmlChar *in;
7471	const xmlChar *ret;
7472	int count = 0;
7473
7474	/*
7475	* Accelerator for simple ASCII names
7476	*/
7477	in = ctxt->input->cur;
7478	if (((in >= 0x61) && (in <= 0x7A)) \|\|
7479	((in >= 0x41) && (in <= 0x5A)) \|\|
7480	(*in == '_')) {
7481	in++;
7482	while (((in >= 0x61) && (in <= 0x7A)) \|\|
7483	((in >= 0x41) && (in <= 0x5A)) \|\|
7484	((in >= 0x30) && (in <= 0x39)) \|\|
7485	(in == '_') \|\| (in == '-') \|\|
7486	(*in == '.'))
7487	in++;
7488	if ((in > 0) && (in < 0x80)) {
7489	count = in - ctxt->input->cur;
7490	ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
7491	ctxt->input->cur = in;
7492	ctxt->nbChars += count;
7493	ctxt->input->col += count;
7494	if (ret == NULL) {
7495	xmlErrMemory(ctxt, NULL);
7496	}
7497	return(ret);
7498	}
7499	}
7500	return(xmlParseNCNameComplex(ctxt));
7501	}
7502
7503	/**
7504	* xmlParseQName:
7505	* @ctxt: an XML parser context
7506	* @prefix: pointer to store the prefix part
7507	*
7508	* parse an XML Namespace QName
7509	*
7510	* [6] QName ::= (Prefix ':')? LocalPart
7511	* [7] Prefix ::= NCName
7512	* [8] LocalPart ::= NCName
7513	*
7514	* Returns the Name parsed or NULL
7515	*/
7516
7517	static const xmlChar *
7518	xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) {
7519	const xmlChar l, p;
7520
7521	GROW;
7522
7523	l = xmlParseNCName(ctxt);
7524	if (l == NULL) {
7525	if (CUR == ':') {
7526	l = xmlParseName(ctxt);
7527	if (l != NULL) {
7528	xmlNsErr(ctxt, XML_NS_ERR_QNAME,
7529	"Failed to parse QName '%s'\n", l, NULL, NULL);
7530	*prefix = NULL;
7531	return(l);
7532	}
7533	}
7534	return(NULL);
7535	}
7536	if (CUR == ':') {
7537	NEXT;
7538	p = l;
7539	l = xmlParseNCName(ctxt);
7540	if (l == NULL) {
7541	xmlChar *tmp;
7542
7543	xmlNsErr(ctxt, XML_NS_ERR_QNAME,
7544	"Failed to parse QName '%s:'\n", p, NULL, NULL);
7545	tmp = xmlBuildQName(BAD_CAST "", p, NULL, 0);
7546	p = xmlDictLookup(ctxt->dict, tmp, -1);
7547	if (tmp != NULL) xmlFree(tmp);
7548	*prefix = NULL;
7549	return(p);
7550	}
7551	if (CUR == ':') {
7552	xmlChar *tmp;
7553
7554	xmlNsErr(ctxt, XML_NS_ERR_QNAME,
7555	"Failed to parse QName '%s:%s:'\n", p, l, NULL);
7556	NEXT;
7557	tmp = (xmlChar *) xmlParseName(ctxt);
7558	if (tmp != NULL) {
7559	tmp = xmlBuildQName(tmp, l, NULL, 0);
7560	l = xmlDictLookup(ctxt->dict, tmp, -1);
7561	if (tmp != NULL) xmlFree(tmp);
7562	*prefix = p;
7563	return(l);
7564	}
7565	tmp = xmlBuildQName(BAD_CAST "", l, NULL, 0);
7566	l = xmlDictLookup(ctxt->dict, tmp, -1);
7567	if (tmp != NULL) xmlFree(tmp);
7568	*prefix = p;
7569	return(l);
7570	}
7571	*prefix = p;
7572	} else
7573	*prefix = NULL;
7574	return(l);
7575	}
7576
7577	/**
7578	* xmlParseQNameAndCompare:
7579	* @ctxt: an XML parser context
7580	* @name: the localname
7581	* @prefix: the prefix, if any.
7582	*
7583	* parse an XML name and compares for match
7584	* (specialized for endtag parsing)
7585	*
7586	* Returns NULL for an illegal name, (xmlChar*) 1 for success
7587	* and the name for mismatch
7588	*/
7589
7590	static const xmlChar *
7591	xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
7592	xmlChar const *prefix) {
7593	const xmlChar *cmp = name;
7594	const xmlChar *in;
7595	const xmlChar *ret;
7596	const xmlChar *prefix2;
7597
7598	if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
7599
7600	GROW;
7601	in = ctxt->input->cur;
7602
7603	cmp = prefix;
7604	while (in != 0 && in == *cmp) {
7605	++in;
7606	++cmp;
7607	}
7608	if ((cmp == 0) && (in == ':')) {
7609	in++;
7610	cmp = name;
7611	while (in != 0 && in == *cmp) {
7612	++in;
7613	++cmp;
7614	}
7615	if (cmp == 0 && (in == '>' \|\| IS_BLANK_CH (*in))) {
7616	/* success */
7617	ctxt->input->cur = in;
7618	return((const xmlChar*) 1);
7619	}
7620	}
7621	/*
7622	* all strings coms from the dictionary, equality can be done directly
7623	*/
7624	ret = xmlParseQName (ctxt, &prefix2);
7625	if ((ret == name) && (prefix == prefix2))
7626	return((const xmlChar*) 1);
7627	return ret;
7628	}
7629
7630	/**
7631	* xmlParseAttValueInternal:
7632	* @ctxt: an XML parser context
7633	* @len: attribute len result
7634	* @alloc: whether the attribute was reallocated as a new string
7635	* @normalize: if 1 then further non-CDATA normalization must be done
7636	*
7637	* parse a value for an attribute.
7638	* NOTE: if no normalization is needed, the routine will return pointers
7639	* directly from the data buffer.
7640	*
7641	* 3.3.3 Attribute-Value Normalization:
7642	* Before the value of an attribute is passed to the application or
7643	* checked for validity, the XML processor must normalize it as follows:
7644	* - a character reference is processed by appending the referenced
7645	* character to the attribute value
7646	* - an entity reference is processed by recursively processing the
7647	* replacement text of the entity
7648	* - a whitespace character (#x20, #xD, #xA, #x9) is processed by
7649	* appending #x20 to the normalized value, except that only a single
7650	* #x20 is appended for a "#xD#xA" sequence that is part of an external
7651	* parsed entity or the literal entity value of an internal parsed entity
7652	* - other characters are processed by appending them to the normalized value
7653	* If the declared value is not CDATA, then the XML processor must further
7654	* process the normalized attribute value by discarding any leading and
7655	* trailing space (#x20) characters, and by replacing sequences of space
7656	* (#x20) characters by a single space (#x20) character.
7657	* All attributes for which no declaration has been read should be treated
7658	* by a non-validating parser as if declared CDATA.
7659	*
7660	* Returns the AttValue parsed or NULL. The value has to be freed by the
7661	* caller if it was copied, this can be detected by val[*len] == 0.
7662	*/
7663
7664	static xmlChar *
7665	xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int len, int alloc,
7666	int normalize)
7667	{
7668	xmlChar limit = 0;
7669	const xmlChar in = NULL, start, end, last;
7670	xmlChar *ret = NULL;
7671
7672	GROW;
7673	in = (xmlChar *) CUR_PTR;
7674	if (in != '"' && in != '\'') {
7675	xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
7676	return (NULL);
7677	}
7678	ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
7679
7680	/*
7681	* try to handle in this routine the most common case where no
7682	* allocation of a new string is required and where content is
7683	* pure ASCII.
7684	*/
7685	limit = *in++;
7686	end = ctxt->input->end;
7687	start = in;
7688	if (in >= end) {
7689	const xmlChar *oldbase = ctxt->input->base;
7690	GROW;
7691	if (oldbase != ctxt->input->base) {
7692	long delta = ctxt->input->base - oldbase;
7693	start = start + delta;
7694	in = in + delta;
7695	}
7696	end = ctxt->input->end;
7697	}
7698	if (normalize) {
7699	/*
7700	* Skip any leading spaces
7701	*/
7702	while ((in < end) && (*in != limit) &&
7703	((in == 0x20) \|\| (in == 0x9) \|\|
7704	(in == 0xA) \|\| (in == 0xD))) {
7705	in++;
7706	start = in;
7707	if (in >= end) {
7708	const xmlChar *oldbase = ctxt->input->base;
7709	GROW;
7710	if (oldbase != ctxt->input->base) {
7711	long delta = ctxt->input->base - oldbase;
7712	start = start + delta;
7713	in = in + delta;
7714	}
7715	end = ctxt->input->end;
7716	}
7717	}
7718	while ((in < end) && (in != limit) && (in >= 0x20) &&
7719	(in <= 0x7f) && (in != '&') && (*in != '<')) {
7720	if ((in++ == 0x20) && (in == 0x20)) break;
7721	if (in >= end) {
7722	const xmlChar *oldbase = ctxt->input->base;
7723	GROW;
7724	if (oldbase != ctxt->input->base) {
7725	long delta = ctxt->input->base - oldbase;
7726	start = start + delta;
7727	in = in + delta;
7728	}
7729	end = ctxt->input->end;
7730	}
7731	}
7732	last = in;
7733	/*
7734	* skip the trailing blanks
7735	*/
7736	while ((last[-1] == 0x20) && (last > start)) last--;
7737	while ((in < end) && (*in != limit) &&
7738	((in == 0x20) \|\| (in == 0x9) \|\|
7739	(in == 0xA) \|\| (in == 0xD))) {
7740	in++;
7741	if (in >= end) {
7742	const xmlChar *oldbase = ctxt->input->base;
7743	GROW;
7744	if (oldbase != ctxt->input->base) {
7745	long delta = ctxt->input->base - oldbase;
7746	start = start + delta;
7747	in = in + delta;
7748	last = last + delta;
7749	}
7750	end = ctxt->input->end;
7751	}
7752	}
7753	if (*in != limit) goto need_complex;
7754	} else {
7755	while ((in < end) && (in != limit) && (in >= 0x20) &&
7756	(in <= 0x7f) && (in != '&') && (*in != '<')) {
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	}
7766	end = ctxt->input->end;
7767	}
7768	}
7769	last = in;
7770	if (*in != limit) goto need_complex;
7771	}
7772	in++;
7773	if (len != NULL) {
7774	*len = last - start;
7775	ret = (xmlChar *) start;
7776	} else {
7777	if (alloc) *alloc = 1;
7778	ret = xmlStrndup(start, last - start);
7779	}
7780	CUR_PTR = in;
7781	if (alloc) *alloc = 0;
7782	return ret;
7783	need_complex:
7784	if (alloc) *alloc = 1;
7785	return xmlParseAttValueComplex(ctxt, len, normalize);
7786	}
7787
7788	/**
7789	* xmlParseAttribute2:
7790	* @ctxt: an XML parser context
7791	* @pref: the element prefix
7792	* @elem: the element name
7793	* @prefix: a xmlChar ** used to store the value of the attribute prefix
7794	* @value: a xmlChar ** used to store the value of the attribute
7795	* @len: an int * to save the length of the attribute
7796	* @alloc: an int * to indicate if the attribute was allocated
7797	*
7798	* parse an attribute in the new SAX2 framework.
7799	*
7800	* Returns the attribute name, and the value in *value, .
7801	*/
7802
7803	static const xmlChar *
7804	xmlParseAttribute2(xmlParserCtxtPtr ctxt,
7805	const xmlChar pref, const xmlChar elem,
7806	const xmlChar prefix, xmlChar value,
7807	int len, int alloc) {
7808	const xmlChar *name;
7809	xmlChar val, internal_val = NULL;
7810	int normalize = 0;
7811
7812	*value = NULL;
7813	GROW;
7814	name = xmlParseQName(ctxt, prefix);
7815	if (name == NULL) {
7816	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7817	"error parsing attribute name\n");
7818	return(NULL);
7819	}
7820
7821	/*
7822	* get the type if needed
7823	*/
7824	if (ctxt->attsSpecial != NULL) {
7825	int type;
7826
7827	type = (int) (long) xmlHashQLookup2(ctxt->attsSpecial,
7828	pref, elem, *prefix, name);
7829	if (type != 0) normalize = 1;
7830	}
7831
7832	/*
7833	* read the value
7834	*/
7835	SKIP_BLANKS;
7836	if (RAW == '=') {
7837	NEXT;
7838	SKIP_BLANKS;
7839	val = xmlParseAttValueInternal(ctxt, len, alloc, normalize);
7840	ctxt->instate = XML_PARSER_CONTENT;
7841	} else {
7842	xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
7843	"Specification mandate value for attribute %s\n", name);
7844	return(NULL);
7845	}
7846
7847	if (*prefix == ctxt->str_xml) {
7848	/*
7849	* Check that xml:lang conforms to the specification
7850	* No more registered as an error, just generate a warning now
7851	* since this was deprecated in XML second edition
7852	*/
7853	if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) {
7854	internal_val = xmlStrndup(val, *len);
7855	if (!xmlCheckLanguageID(internal_val)) {
7856	xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
7857	"Malformed value for xml:lang : %s\n",
7858	internal_val, NULL);
7859	}
7860	}
7861
7862	/*
7863	* Check that xml:space conforms to the specification
7864	*/
7865	if (xmlStrEqual(name, BAD_CAST "space")) {
7866	internal_val = xmlStrndup(val, *len);
7867	if (xmlStrEqual(internal_val, BAD_CAST "default"))
7868	*(ctxt->space) = 0;
7869	else if (xmlStrEqual(internal_val, BAD_CAST "preserve"))
7870	*(ctxt->space) = 1;
7871	else {
7872	xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
7873	"Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
7874	internal_val, NULL);
7875	}
7876	}
7877	if (internal_val) {
7878	xmlFree(internal_val);
7879	}
7880	}
7881
7882	*value = val;
7883	return(name);
7884	}
7885
7886	/**
7887	* xmlParseStartTag2:
7888	* @ctxt: an XML parser context
7889	*
7890	* parse a start of tag either for rule element or
7891	* EmptyElement. In both case we don't parse the tag closing chars.
7892	* This routine is called when running SAX2 parsing
7893	*
7894	* [40] STag ::= '<' Name (S Attribute)* S? '>'
7895	*
7896	* [ WFC: Unique Att Spec ]
7897	* No attribute name may appear more than once in the same start-tag or
7898	* empty-element tag.
7899	*
7900	* [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
7901	*
7902	* [ WFC: Unique Att Spec ]
7903	* No attribute name may appear more than once in the same start-tag or
7904	* empty-element tag.
7905	*
7906	* With namespace:
7907	*
7908	* [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
7909	*
7910	* [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
7911	*
7912	* Returns the element name parsed
7913	*/
7914
7915	static const xmlChar *
7916	xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref,
7917	const xmlChar *URI, int tlen) {
7918	const xmlChar *localname;
7919	const xmlChar *prefix;
7920	const xmlChar *attname;
7921	const xmlChar *aprefix;
7922	const xmlChar *nsname;
7923	xmlChar *attvalue;
7924	const xmlChar **atts = ctxt->atts;
7925	int maxatts = ctxt->maxatts;
7926	int nratts, nbatts, nbdef;
7927	int i, j, nbNs, attval, oldline, oldcol;
7928	const xmlChar *base;
7929	unsigned long cur;
7930	int nsNr = ctxt->nsNr;
7931
7932	if (RAW != '<') return(NULL);
7933	NEXT1;
7934
7935	/*
7936	* NOTE: it is crucial with the SAX2 API to never call SHRINK beyond that
7937	* point since the attribute values may be stored as pointers to
7938	* the buffer and calling SHRINK would destroy them !
7939	* The Shrinking is only possible once the full set of attribute
7940	* callbacks have been done.
7941	*/
7942	reparse:
7943	SHRINK;
7944	base = ctxt->input->base;
7945	cur = ctxt->input->cur - ctxt->input->base;
7946	oldline = ctxt->input->line;
7947	oldcol = ctxt->input->col;
7948	nbatts = 0;
7949	nratts = 0;
7950	nbdef = 0;
7951	nbNs = 0;
7952	attval = 0;
7953	/* Forget any namespaces added during an earlier parse of this element. */
7954	ctxt->nsNr = nsNr;
7955
7956	localname = xmlParseQName(ctxt, &prefix);
7957	if (localname == NULL) {
7958	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7959	"StartTag: invalid element name\n");
7960	return(NULL);
7961	}
7962	*tlen = ctxt->input->cur - ctxt->input->base - cur;
7963
7964	/*
7965	* Now parse the attributes, it ends up with the ending
7966	*
7967	* (S Attribute)* S?
7968	*/
7969	SKIP_BLANKS;
7970	GROW;
7971	if (ctxt->input->base != base) goto base_changed;
7972
7973	while ((RAW != '>') &&
7974	((RAW != '/') \|\| (NXT(1) != '>')) &&
7975	(IS_BYTE_CHAR(RAW))) {
7976	const xmlChar *q = CUR_PTR;
7977	unsigned int cons = ctxt->input->consumed;
7978	int len = -1, alloc = 0;
7979
7980	attname = xmlParseAttribute2(ctxt, prefix, localname,
7981	&aprefix, &attvalue, &len, &alloc);
7982	if (ctxt->input->base != base) {
7983	if ((attvalue != NULL) && (alloc != 0))
7984	xmlFree(attvalue);
7985	attvalue = NULL;
7986	goto base_changed;
7987	}
7988	if ((attname != NULL) && (attvalue != NULL)) {
7989	if (len < 0) len = xmlStrlen(attvalue);
7990	if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
7991	const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
7992	xmlURIPtr uri;
7993
7994	if (*URL != 0) {
7995	uri = xmlParseURI((const char *) URL);
7996	if (uri == NULL) {
7997	xmlWarningMsg(ctxt, XML_WAR_NS_URI,
7998	"xmlns: %s not a valid URI\n",
7999	URL, NULL);
8000	} else {
8001	if (uri->scheme == NULL) {
8002	xmlWarningMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
8003	"xmlns: URI %s is not absolute\n",
8004	URL, NULL);
8005	}
8006	xmlFreeURI(uri);
8007	}
8008	}
8009	/*
8010	* check that it's not a defined namespace
8011	*/
8012	for (j = 1;j <= nbNs;j++)
8013	if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
8014	break;
8015	if (j <= nbNs)
8016	xmlErrAttributeDup(ctxt, NULL, attname);
8017	else
8018	if (nsPush(ctxt, NULL, URL) > 0) nbNs++;
8019	if (alloc != 0) xmlFree(attvalue);
8020	SKIP_BLANKS;
8021	continue;
8022	}
8023	if (aprefix == ctxt->str_xmlns) {
8024	const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
8025	xmlURIPtr uri;
8026
8027	if (attname == ctxt->str_xml) {
8028	if (URL != ctxt->str_xml_ns) {
8029	xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
8030	"xml namespace prefix mapped to wrong URI\n",
8031	NULL, NULL, NULL);
8032	}
8033	/*
8034	* Do not keep a namespace definition node
8035	*/
8036	if (alloc != 0) xmlFree(attvalue);
8037	SKIP_BLANKS;
8038	continue;
8039	}
8040	uri = xmlParseURI((const char *) URL);
8041	if (uri == NULL) {
8042	xmlWarningMsg(ctxt, XML_WAR_NS_URI,
8043	"xmlns:%s: '%s' is not a valid URI\n",
8044	attname, URL);
8045	} else {
8046	if ((ctxt->pedantic) && (uri->scheme == NULL)) {
8047	xmlWarningMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
8048	"xmlns:%s: URI %s is not absolute\n",
8049	attname, URL);
8050	}
8051	xmlFreeURI(uri);
8052	}
8053
8054	/*
8055	* check that it's not a defined namespace
8056	*/
8057	for (j = 1;j <= nbNs;j++)
8058	if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
8059	break;
8060	if (j <= nbNs)
8061	xmlErrAttributeDup(ctxt, aprefix, attname);
8062	else
8063	if (nsPush(ctxt, attname, URL) > 0) nbNs++;
8064	if (alloc != 0) xmlFree(attvalue);
8065	SKIP_BLANKS;
8066	if (ctxt->input->base != base) goto base_changed;
8067	continue;
8068	}
8069
8070	/*
8071	* Add the pair to atts
8072	*/
8073	if ((atts == NULL) \|\| (nbatts + 5 > maxatts)) {
8074	if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
8075	if (attvalue[len] == 0)
8076	xmlFree(attvalue);
8077	goto failed;
8078	}
8079	maxatts = ctxt->maxatts;
8080	atts = ctxt->atts;
8081	}
8082	ctxt->attallocs[nratts++] = alloc;
8083	atts[nbatts++] = attname;
8084	atts[nbatts++] = aprefix;
8085	atts[nbatts++] = NULL; /* the URI will be fetched later */
8086	atts[nbatts++] = attvalue;
8087	attvalue += len;
8088	atts[nbatts++] = attvalue;
8089	/*
8090	* tag if some deallocation is needed
8091	*/
8092	if (alloc != 0) attval = 1;
8093	} else {
8094	if ((attvalue != NULL) && (attvalue[len] == 0))
8095	xmlFree(attvalue);
8096	}
8097
8098	failed:
8099
8100	GROW
8101	if (ctxt->input->base != base) goto base_changed;
8102	if ((RAW == '>') \|\| (((RAW == '/') && (NXT(1) == '>'))))
8103	break;
8104	if (!IS_BLANK_CH(RAW)) {
8105	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
8106	"attributes construct error\n");
8107	break;
8108	}
8109	SKIP_BLANKS;
8110	if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
8111	(attname == NULL) && (attvalue == NULL)) {
8112	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8113	"xmlParseStartTag: problem parsing attributes\n");
8114	break;
8115	}
8116	GROW;
8117	if (ctxt->input->base != base) goto base_changed;
8118	}
8119
8120	/*
8121	* The attributes defaulting
8122	*/
8123	if (ctxt->attsDefault != NULL) {
8124	xmlDefAttrsPtr defaults;
8125
8126	defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
8127	if (defaults != NULL) {
8128	for (i = 0;i < defaults->nbAttrs;i++) {
8129	attname = defaults->values[4 * i];
8130	aprefix = defaults->values[4 * i + 1];
8131
8132	/*
8133	* special work for namespaces defaulted defs
8134	*/
8135	if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
8136	/*
8137	* check that it's not a defined namespace
8138	*/
8139	for (j = 1;j <= nbNs;j++)
8140	if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
8141	break;
8142	if (j <= nbNs) continue;
8143
8144	nsname = xmlGetNamespace(ctxt, NULL);
8145	if (nsname != defaults->values[4 * i + 2]) {
8146	if (nsPush(ctxt, NULL,
8147	defaults->values[4 * i + 2]) > 0)
8148	nbNs++;
8149	}
8150	} else if (aprefix == ctxt->str_xmlns) {
8151	/*
8152	* check that it's not a defined namespace
8153	*/
8154	for (j = 1;j <= nbNs;j++)
8155	if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
8156	break;
8157	if (j <= nbNs) continue;
8158
8159	nsname = xmlGetNamespace(ctxt, attname);
8160	if (nsname != defaults->values[2]) {
8161	if (nsPush(ctxt, attname,
8162	defaults->values[4 * i + 2]) > 0)
8163	nbNs++;
8164	}
8165	} else {
8166	/*
8167	* check that it's not a defined attribute
8168	*/
8169	for (j = 0;j < nbatts;j+=5) {
8170	if ((attname == atts[j]) && (aprefix == atts[j+1]))
8171	break;
8172	}
8173	if (j < nbatts) continue;
8174
8175	if ((atts == NULL) \|\| (nbatts + 5 > maxatts)) {
8176	if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
8177	return(NULL);
8178	}
8179	maxatts = ctxt->maxatts;
8180	atts = ctxt->atts;
8181	}
8182	atts[nbatts++] = attname;
8183	atts[nbatts++] = aprefix;
8184	if (aprefix == NULL)
8185	atts[nbatts++] = NULL;
8186	else
8187	atts[nbatts++] = xmlGetNamespace(ctxt, aprefix);
8188	atts[nbatts++] = defaults->values[4 * i + 2];
8189	atts[nbatts++] = defaults->values[4 * i + 3];
8190	nbdef++;
8191	}
8192	}
8193	}
8194	}
8195
8196	/*
8197	* The attributes checkings
8198	*/
8199	for (i = 0; i < nbatts;i += 5) {
8200	/*
8201	* The default namespace does not apply to attribute names.
8202	*/
8203	if (atts[i + 1] != NULL) {
8204	nsname = xmlGetNamespace(ctxt, atts[i + 1]);
8205	if (nsname == NULL) {
8206	xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
8207	"Namespace prefix %s for %s on %s is not defined\n",
8208	atts[i + 1], atts[i], localname);
8209	}
8210	atts[i + 2] = nsname;
8211	} else
8212	nsname = NULL;
8213	/*
8214	* [ WFC: Unique Att Spec ]
8215	* No attribute name may appear more than once in the same
8216	* start-tag or empty-element tag.
8217	* As extended by the Namespace in XML REC.
8218	*/
8219	for (j = 0; j < i;j += 5) {
8220	if (atts[i] == atts[j]) {
8221	if (atts[i+1] == atts[j+1]) {
8222	xmlErrAttributeDup(ctxt, atts[i+1], atts[i]);
8223	break;
8224	}
8225	if ((nsname != NULL) && (atts[j + 2] == nsname)) {
8226	xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
8227	"Namespaced Attribute %s in '%s' redefined\n",
8228	atts[i], nsname, NULL);
8229	break;
8230	}
8231	}
8232	}
8233	}
8234
8235	nsname = xmlGetNamespace(ctxt, prefix);
8236	if ((prefix != NULL) && (nsname == NULL)) {
8237	xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
8238	"Namespace prefix %s on %s is not defined\n",
8239	prefix, localname, NULL);
8240	}
8241	*pref = prefix;
8242	*URI = nsname;
8243
8244	/*
8245	* SAX: Start of Element !
8246	*/
8247	if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
8248	(!ctxt->disableSAX)) {
8249	if (nbNs > 0)
8250	ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
8251	nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs],
8252	nbatts / 5, nbdef, atts);
8253	else
8254	ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
8255	nsname, 0, NULL, nbatts / 5, nbdef, atts);
8256	}
8257
8258	/*
8259	* Free up attribute allocated strings if needed
8260	*/
8261	if (attval != 0) {
8262	for (i = 3,j = 0; j < nratts;i += 5,j++)
8263	if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
8264	xmlFree((xmlChar *) atts[i]);
8265	}
8266
8267	return(localname);
8268
8269	base_changed:
8270	/*
8271	* the attribute strings are valid iif the base didn't changed
8272	*/
8273	if (attval != 0) {
8274	for (i = 3,j = 0; j < nratts;i += 5,j++)
8275	if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
8276	xmlFree((xmlChar *) atts[i]);
8277	}
8278	ctxt->input->cur = ctxt->input->base + cur;
8279	ctxt->input->line = oldline;
8280	ctxt->input->col = oldcol;
8281	if (ctxt->wellFormed == 1) {
8282	goto reparse;
8283	}
8284	return(NULL);
8285	}
8286
8287	/**
8288	* xmlParseEndTag2:
8289	* @ctxt: an XML parser context
8290	* @line: line of the start tag
8291	* @nsNr: number of namespaces on the start tag
8292	*
8293	* parse an end of tag
8294	*
8295	* [42] ETag ::= '</' Name S? '>'
8296	*
8297	* With namespace
8298	*
8299	* [NS 9] ETag ::= '</' QName S? '>'
8300	*/
8301
8302	static void
8303	xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix,
8304	const xmlChar *URI, int line, int nsNr, int tlen) {
8305	const xmlChar *name;
8306
8307	GROW;
8308	if ((RAW != '<') \|\| (NXT(1) != '/')) {
8309	xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL);
8310	return;
8311	}
8312	SKIP(2);
8313
8314	if ((tlen > 0) && (xmlStrncmp(ctxt->input->cur, ctxt->name, tlen) == 0)) {
8315	if (ctxt->input->cur[tlen] == '>') {
8316	ctxt->input->cur += tlen + 1;
8317	goto done;
8318	}
8319	ctxt->input->cur += tlen;
8320	name = (xmlChar*)1;
8321	} else {
8322	if (prefix == NULL)
8323	name = xmlParseNameAndCompare(ctxt, ctxt->name);
8324	else
8325	name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix);
8326	}
8327
8328	/*
8329	* We should definitely be at the ending "S? '>'" part
8330	*/
8331	GROW;
8332	SKIP_BLANKS;
8333	if ((!IS_BYTE_CHAR(RAW)) \|\| (RAW != '>')) {
8334	xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
8335	} else
8336	NEXT1;
8337
8338	/*
8339	* [ WFC: Element Type Match ]
8340	* The Name in an element's end-tag must match the element type in the
8341	* start-tag.
8342	*
8343	*/
8344	if (name != (xmlChar*)1) {
8345	if (name == NULL) name = BAD_CAST "unparseable";
8346	xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
8347	"Opening and ending tag mismatch: %s line %d and %s\n",
8348	ctxt->name, line, name);
8349	}
8350
8351	/*
8352	* SAX: End of Tag
8353	*/
8354	done:
8355	if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
8356	(!ctxt->disableSAX))
8357	ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI);
8358
8359	spacePop(ctxt);
8360	if (nsNr != 0)
8361	nsPop(ctxt, nsNr);
8362	return;
8363	}
8364
8365	/**
8366	* xmlParseCDSect:
8367	* @ctxt: an XML parser context
8368	*
8369	* Parse escaped pure raw content.
8370	*
8371	* [18] CDSect ::= CDStart CData CDEnd
8372	*
8373	* [19] CDStart ::= '<![CDATA['
8374	*
8375	* [20] Data ::= (Char* - (Char* ']]>' Char*))
8376	*
8377	* [21] CDEnd ::= ']]>'
8378	*/
8379	void
8380	xmlParseCDSect(xmlParserCtxtPtr ctxt) {
8381	xmlChar *buf = NULL;
8382	int len = 0;
8383	int size = XML_PARSER_BUFFER_SIZE;
8384	int r, rl;
8385	int s, sl;
8386	int cur, l;
8387	int count = 0;
8388
8389	/* Check 2.6.0 was NXT(0) not RAW */
8390	if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
8391	SKIP(9);
8392	} else
8393	return;
8394
8395	ctxt->instate = XML_PARSER_CDATA_SECTION;
8396	r = CUR_CHAR(rl);
8397	if (!IS_CHAR(r)) {
8398	xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
8399	ctxt->instate = XML_PARSER_CONTENT;
8400	return;
8401	}
8402	NEXTL(rl);
8403	s = CUR_CHAR(sl);
8404	if (!IS_CHAR(s)) {
8405	xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
8406	ctxt->instate = XML_PARSER_CONTENT;
8407	return;
8408	}
8409	NEXTL(sl);
8410	cur = CUR_CHAR(l);
8411	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
8412	if (buf == NULL) {
8413	xmlErrMemory(ctxt, NULL);
8414	return;
8415	}
8416	while (IS_CHAR(cur) &&
8417	((r != ']') \|\| (s != ']') \|\| (cur != '>'))) {
8418	if (len + 5 >= size) {
8419	xmlChar *tmp;
8420
8421	size *= 2;
8422	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
8423	if (tmp == NULL) {
8424	xmlFree(buf);
8425	xmlErrMemory(ctxt, NULL);
8426	return;
8427	}
8428	buf = tmp;
8429	}
8430	COPY_BUF(rl,buf,len,r);
8431	r = s;
8432	rl = sl;
8433	s = cur;
8434	sl = l;
8435	count++;
8436	if (count > 50) {
8437	GROW;
8438	count = 0;
8439	}
8440	NEXTL(l);
8441	cur = CUR_CHAR(l);
8442	}
8443	buf[len] = 0;
8444	ctxt->instate = XML_PARSER_CONTENT;
8445	if (cur != '>') {
8446	xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
8447	"CData section not finished\n%.50s\n", buf);
8448	xmlFree(buf);
8449	return;
8450	}
8451	NEXTL(l);
8452
8453	/*
8454	* OK the buffer is to be consumed as cdata.
8455	*/
8456	if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
8457	if (ctxt->sax->cdataBlock != NULL)
8458	ctxt->sax->cdataBlock(ctxt->userData, buf, len);
8459	else if (ctxt->sax->characters != NULL)
8460	ctxt->sax->characters(ctxt->userData, buf, len);
8461	}
8462	xmlFree(buf);
8463	}
8464
8465	/**
8466	* xmlParseContent:
8467	* @ctxt: an XML parser context
8468	*
8469	* Parse a content:
8470	*
8471	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
8472	*/
8473
8474	void
8475	xmlParseContent(xmlParserCtxtPtr ctxt) {
8476	GROW;
8477	while ((RAW != 0) &&
8478	((RAW != '<') \|\| (NXT(1) != '/')) &&
8479	(ctxt->instate != XML_PARSER_EOF)) {
8480	const xmlChar *test = CUR_PTR;
8481	unsigned int cons = ctxt->input->consumed;
8482	const xmlChar *cur = ctxt->input->cur;
8483
8484	/*
8485	* First case : a Processing Instruction.
8486	*/
8487	if ((*cur == '<') && (cur[1] == '?')) {
8488	xmlParsePI(ctxt);
8489	}
8490
8491	/*
8492	* Second case : a CDSection
8493	*/
8494	/* 2.6.0 test was cur not RAW /
8495	else if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
8496	xmlParseCDSect(ctxt);
8497	}
8498
8499	/*
8500	* Third case : a comment
8501	*/
8502	else if ((*cur == '<') && (NXT(1) == '!') &&
8503	(NXT(2) == '-') && (NXT(3) == '-')) {
8504	xmlParseComment(ctxt);
8505	ctxt->instate = XML_PARSER_CONTENT;
8506	}
8507
8508	/*
8509	* Fourth case : a sub-element.
8510	*/
8511	else if (*cur == '<') {
8512	xmlParseElement(ctxt);
8513	}
8514
8515	/*
8516	* Fifth case : a reference. If if has not been resolved,
8517	* parsing returns it's Name, create the node
8518	*/
8519
8520	else if (*cur == '&') {
8521	xmlParseReference(ctxt);
8522	}
8523
8524	/*
8525	* Last case, text. Note that References are handled directly.
8526	*/
8527	else {
8528	xmlParseCharData(ctxt, 0);
8529	}
8530
8531	GROW;
8532	/*
8533	* Pop-up of finished entities.
8534	*/
8535	while ((RAW == 0) && (ctxt->inputNr > 1))
8536	xmlPopInput(ctxt);
8537	SHRINK;
8538
8539	if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
8540	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8541	"detected an error in element content\n");
8542	ctxt->instate = XML_PARSER_EOF;
8543	break;
8544	}
8545	}
8546	}
8547
8548	/**
8549	* xmlParseElement:
8550	* @ctxt: an XML parser context
8551	*
8552	* parse an XML element, this is highly recursive
8553	*
8554	* [39] element ::= EmptyElemTag \| STag content ETag
8555	*
8556	* [ WFC: Element Type Match ]
8557	* The Name in an element's end-tag must match the element type in the
8558	* start-tag.
8559	*
8560	*/
8561
8562	void
8563	xmlParseElement(xmlParserCtxtPtr ctxt) {
8564	const xmlChar *name;
8565	const xmlChar *prefix;
8566	const xmlChar *URI;
8567	xmlParserNodeInfo node_info;
8568	int line, tlen;
8569	xmlNodePtr ret;
8570	int nsNr = ctxt->nsNr;
8571
8572	if ((unsigned int) ctxt->nameNr > xmlParserMaxDepth) {
8573	xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
8574	"Excessive depth in document: change xmlParserMaxDepth = %d\n",
8575	xmlParserMaxDepth);
8576	ctxt->instate = XML_PARSER_EOF;
8577	return;
8578	}
8579
8580	/* Capture start position */
8581	if (ctxt->record_info) {
8582	node_info.begin_pos = ctxt->input->consumed +
8583	(CUR_PTR - ctxt->input->base);
8584	node_info.begin_line = ctxt->input->line;
8585	}
8586
8587	if (ctxt->spaceNr == 0)
8588	spacePush(ctxt, -1);
8589	else if (*ctxt->space == -2)
8590	spacePush(ctxt, -1);
8591	else
8592	spacePush(ctxt, *ctxt->space);
8593
8594	line = ctxt->input->line;
8595	#ifdef LIBXML_SAX1_ENABLED
8596	if (ctxt->sax2)
8597	#endif /* LIBXML_SAX1_ENABLED */
8598	name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
8599	#ifdef LIBXML_SAX1_ENABLED
8600	else
8601	name = xmlParseStartTag(ctxt);
8602	#endif /* LIBXML_SAX1_ENABLED */
8603	if (name == NULL) {
8604	spacePop(ctxt);
8605	return;
8606	}
8607	namePush(ctxt, name);
8608	ret = ctxt->node;
8609
8610	#ifdef LIBXML_VALID_ENABLED
8611	/*
8612	* [ VC: Root Element Type ]
8613	* The Name in the document type declaration must match the element
8614	* type of the root element.
8615	*/
8616	if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
8617	ctxt->node && (ctxt->node == ctxt->myDoc->children))
8618	ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
8619	#endif /* LIBXML_VALID_ENABLED */
8620
8621	/*
8622	* Check for an Empty Element.
8623	*/
8624	if ((RAW == '/') && (NXT(1) == '>')) {
8625	SKIP(2);
8626	if (ctxt->sax2) {
8627	if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
8628	(!ctxt->disableSAX))
8629	ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
8630	#ifdef LIBXML_SAX1_ENABLED
8631	} else {
8632	if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
8633	(!ctxt->disableSAX))
8634	ctxt->sax->endElement(ctxt->userData, name);
8635	#endif /* LIBXML_SAX1_ENABLED */
8636	}
8637	namePop(ctxt);
8638	spacePop(ctxt);
8639	if (nsNr != ctxt->nsNr)
8640	nsPop(ctxt, ctxt->nsNr - nsNr);
8641	if ( ret != NULL && ctxt->record_info ) {
8642	node_info.end_pos = ctxt->input->consumed +
8643	(CUR_PTR - ctxt->input->base);
8644	node_info.end_line = ctxt->input->line;
8645	node_info.node = ret;
8646	xmlParserAddNodeInfo(ctxt, &node_info);
8647	}
8648	return;
8649	}
8650	if (RAW == '>') {
8651	NEXT1;
8652	} else {
8653	xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED,
8654	"Couldn't find end of Start Tag %s line %d\n",
8655	name, line, NULL);
8656
8657	/*
8658	* end of parsing of this node.
8659	*/
8660	nodePop(ctxt);
8661	namePop(ctxt);
8662	spacePop(ctxt);
8663	if (nsNr != ctxt->nsNr)
8664	nsPop(ctxt, ctxt->nsNr - nsNr);
8665
8666	/*
8667	* Capture end position and add node
8668	*/
8669	if ( ret != NULL && ctxt->record_info ) {
8670	node_info.end_pos = ctxt->input->consumed +
8671	(CUR_PTR - ctxt->input->base);
8672	node_info.end_line = ctxt->input->line;
8673	node_info.node = ret;
8674	xmlParserAddNodeInfo(ctxt, &node_info);
8675	}
8676	return;
8677	}
8678
8679	/*
8680	* Parse the content of the element:
8681	*/
8682	xmlParseContent(ctxt);
8683	if (!IS_BYTE_CHAR(RAW)) {
8684	xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
8685	"Premature end of data in tag %s line %d\n",
8686	name, line, NULL);
8687
8688	/*
8689	* end of parsing of this node.
8690	*/
8691	nodePop(ctxt);
8692	namePop(ctxt);
8693	spacePop(ctxt);
8694	if (nsNr != ctxt->nsNr)
8695	nsPop(ctxt, ctxt->nsNr - nsNr);
8696	return;
8697	}
8698
8699	/*
8700	* parse the end of tag: '</' should be here.
8701	*/
8702	if (ctxt->sax2) {
8703	xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr, tlen);
8704	namePop(ctxt);
8705	}
8706	#ifdef LIBXML_SAX1_ENABLED
8707	else
8708	xmlParseEndTag1(ctxt, line);
8709	#endif /* LIBXML_SAX1_ENABLED */
8710
8711	/*
8712	* Capture end position and add node
8713	*/
8714	if ( ret != NULL && ctxt->record_info ) {
8715	node_info.end_pos = ctxt->input->consumed +
8716	(CUR_PTR - ctxt->input->base);
8717	node_info.end_line = ctxt->input->line;
8718	node_info.node = ret;
8719	xmlParserAddNodeInfo(ctxt, &node_info);
8720	}
8721	}
8722
8723	/**
8724	* xmlParseVersionNum:
8725	* @ctxt: an XML parser context
8726	*
8727	* parse the XML version value.
8728	*
8729	* [26] VersionNum ::= ([a-zA-Z0-9_.:] \| '-')+
8730	*
8731	* Returns the string giving the XML version number, or NULL
8732	*/
8733	xmlChar *
8734	xmlParseVersionNum(xmlParserCtxtPtr ctxt) {
8735	xmlChar *buf = NULL;
8736	int len = 0;
8737	int size = 10;
8738	xmlChar cur;
8739
8740	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
8741	if (buf == NULL) {
8742	xmlErrMemory(ctxt, NULL);
8743	return(NULL);
8744	}
8745	cur = CUR;
8746	while (((cur >= 'a') && (cur <= 'z')) \|\|
8747	((cur >= 'A') && (cur <= 'Z')) \|\|
8748	((cur >= '0') && (cur <= '9')) \|\|
8749	(cur == '_') \|\| (cur == '.') \|\|
8750	(cur == ':') \|\| (cur == '-')) {
8751	if (len + 1 >= size) {
8752	xmlChar *tmp;
8753
8754	size *= 2;
8755	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
8756	if (tmp == NULL) {
8757	xmlErrMemory(ctxt, NULL);
8758	return(NULL);
8759	}
8760	buf = tmp;
8761	}
8762	buf[len++] = cur;
8763	NEXT;
8764	cur=CUR;
8765	}
8766	buf[len] = 0;
8767	return(buf);
8768	}
8769
8770	/**
8771	* xmlParseVersionInfo:
8772	* @ctxt: an XML parser context
8773	*
8774	* parse the XML version.
8775	*
8776	* [24] VersionInfo ::= S 'version' Eq (' VersionNum ' \| " VersionNum ")
8777	*
8778	* [25] Eq ::= S? '=' S?
8779	*
8780	* Returns the version string, e.g. "1.0"
8781	*/
8782
8783	xmlChar *
8784	xmlParseVersionInfo(xmlParserCtxtPtr ctxt) {
8785	xmlChar *version = NULL;
8786
8787	if (CMP7(CUR_PTR, 'v', 'e', 'r', 's', 'i', 'o', 'n')) {
8788	SKIP(7);
8789	SKIP_BLANKS;
8790	if (RAW != '=') {
8791	xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
8792	return(NULL);
8793	}
8794	NEXT;
8795	SKIP_BLANKS;
8796	if (RAW == '"') {
8797	NEXT;
8798	version = xmlParseVersionNum(ctxt);
8799	if (RAW != '"') {
8800	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
8801	} else
8802	NEXT;
8803	} else if (RAW == '\''){
8804	NEXT;
8805	version = xmlParseVersionNum(ctxt);
8806	if (RAW != '\'') {
8807	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
8808	} else
8809	NEXT;
8810	} else {
8811	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
8812	}
8813	}
8814	return(version);
8815	}
8816
8817	/**
8818	* xmlParseEncName:
8819	* @ctxt: an XML parser context
8820	*
8821	* parse the XML encoding name
8822	*
8823	* [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] \| '-')*
8824	*
8825	* Returns the encoding name value or NULL
8826	*/
8827	xmlChar *
8828	xmlParseEncName(xmlParserCtxtPtr ctxt) {
8829	xmlChar *buf = NULL;
8830	int len = 0;
8831	int size = 10;
8832	xmlChar cur;
8833
8834	cur = CUR;
8835	if (((cur >= 'a') && (cur <= 'z')) \|\|
8836	((cur >= 'A') && (cur <= 'Z'))) {
8837	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
8838	if (buf == NULL) {
8839	xmlErrMemory(ctxt, NULL);
8840	return(NULL);
8841	}
8842
8843	buf[len++] = cur;
8844	NEXT;
8845	cur = CUR;
8846	while (((cur >= 'a') && (cur <= 'z')) \|\|
8847	((cur >= 'A') && (cur <= 'Z')) \|\|
8848	((cur >= '0') && (cur <= '9')) \|\|
8849	(cur == '.') \|\| (cur == '_') \|\|
8850	(cur == '-')) {
8851	if (len + 1 >= size) {
8852	xmlChar *tmp;
8853
8854	size *= 2;
8855	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
8856	if (tmp == NULL) {
8857	xmlErrMemory(ctxt, NULL);
8858	xmlFree(buf);
8859	return(NULL);
8860	}
8861	buf = tmp;
8862	}
8863	buf[len++] = cur;
8864	NEXT;
8865	cur = CUR;
8866	if (cur == 0) {
8867	SHRINK;
8868	GROW;
8869	cur = CUR;
8870	}
8871	}
8872	buf[len] = 0;
8873	} else {
8874	xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
8875	}
8876	return(buf);
8877	}
8878
8879	/**
8880	* xmlParseEncodingDecl:
8881	* @ctxt: an XML parser context
8882	*
8883	* parse the XML encoding declaration
8884	*
8885	* [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' \| "'" EncName "'")
8886	*
8887	* this setups the conversion filters.
8888	*
8889	* Returns the encoding value or NULL
8890	*/
8891
8892	const xmlChar *
8893	xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) {
8894	xmlChar *encoding = NULL;
8895
8896	SKIP_BLANKS;
8897	if (CMP8(CUR_PTR, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g')) {
8898	SKIP(8);
8899	SKIP_BLANKS;
8900	if (RAW != '=') {
8901	xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
8902	return(NULL);
8903	}
8904	NEXT;
8905	SKIP_BLANKS;
8906	if (RAW == '"') {
8907	NEXT;
8908	encoding = xmlParseEncName(ctxt);
8909	if (RAW != '"') {
8910	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
8911	} else
8912	NEXT;
8913	} else if (RAW == '\''){
8914	NEXT;
8915	encoding = xmlParseEncName(ctxt);
8916	if (RAW != '\'') {
8917	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
8918	} else
8919	NEXT;
8920	} else {
8921	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
8922	}
8923	/*
8924	* UTF-16 encoding stwich has already taken place at this stage,
8925	* more over the little-endian/big-endian selection is already done
8926	*/
8927	if ((encoding != NULL) &&
8928	((!xmlStrcasecmp(encoding, BAD_CAST "UTF-16")) \|\|
8929	(!xmlStrcasecmp(encoding, BAD_CAST "UTF16")))) {
8930	if (ctxt->encoding != NULL)
8931	xmlFree((xmlChar *) ctxt->encoding);
8932	ctxt->encoding = encoding;
8933	}
8934	/*
8935	* UTF-8 encoding is handled natively
8936	*/
8937	else if ((encoding != NULL) &&
8938	((!xmlStrcasecmp(encoding, BAD_CAST "UTF-8")) \|\|
8939	(!xmlStrcasecmp(encoding, BAD_CAST "UTF8")))) {
8940	if (ctxt->encoding != NULL)
8941	xmlFree((xmlChar *) ctxt->encoding);
8942	ctxt->encoding = encoding;
8943	}
8944	else if (encoding != NULL) {
8945	xmlCharEncodingHandlerPtr handler;
8946
8947	if (ctxt->input->encoding != NULL)
8948	xmlFree((xmlChar *) ctxt->input->encoding);
8949	ctxt->input->encoding = encoding;
8950
8951	handler = xmlFindCharEncodingHandler((const char *) encoding);
8952	if (handler != NULL) {
8953	xmlSwitchToEncoding(ctxt, handler);
8954	} else {
8955	xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
8956	"Unsupported encoding %s\n", encoding);
8957	return(NULL);
8958	}
8959	}
8960	}
8961	return(encoding);
8962	}
8963
8964	/**
8965	* xmlParseSDDecl:
8966	* @ctxt: an XML parser context
8967	*
8968	* parse the XML standalone declaration
8969	*
8970	* [32] SDDecl ::= S 'standalone' Eq
8971	* (("'" ('yes' \| 'no') "'") \| ('"' ('yes' \| 'no')'"'))
8972	*
8973	* [ VC: Standalone Document Declaration ]
8974	* TODO The standalone document declaration must have the value "no"
8975	* if any external markup declarations contain declarations of:
8976	* - attributes with default values, if elements to which these
8977	* attributes apply appear in the document without specifications
8978	* of values for these attributes, or
8979	* - entities (other than amp, lt, gt, apos, quot), if references
8980	* to those entities appear in the document, or
8981	* - attributes with values subject to normalization, where the
8982	* attribute appears in the document with a value which will change
8983	* as a result of normalization, or
8984	* - element types with element content, if white space occurs directly
8985	* within any instance of those types.
8986	*
8987	* Returns:
8988	* 1 if standalone="yes"
8989	* 0 if standalone="no"
8990	* -2 if standalone attribute is missing or invalid
8991	* (A standalone value of -2 means that the XML declaration was found,
8992	* but no value was specified for the standalone attribute).
8993	*/
8994
8995	int
8996	xmlParseSDDecl(xmlParserCtxtPtr ctxt) {
8997	int standalone = -2;
8998
8999	SKIP_BLANKS;
9000	if (CMP10(CUR_PTR, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o', 'n', 'e')) {
9001	SKIP(10);
9002	SKIP_BLANKS;
9003	if (RAW != '=') {
9004	xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
9005	return(standalone);
9006	}
9007	NEXT;
9008	SKIP_BLANKS;
9009	if (RAW == '\''){
9010	NEXT;
9011	if ((RAW == 'n') && (NXT(1) == 'o')) {
9012	standalone = 0;
9013	SKIP(2);
9014	} else if ((RAW == 'y') && (NXT(1) == 'e') &&
9015	(NXT(2) == 's')) {
9016	standalone = 1;
9017	SKIP(3);
9018	} else {
9019	xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
9020	}
9021	if (RAW != '\'') {
9022	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9023	} else
9024	NEXT;
9025	} else if (RAW == '"'){
9026	NEXT;
9027	if ((RAW == 'n') && (NXT(1) == 'o')) {
9028	standalone = 0;
9029	SKIP(2);
9030	} else if ((RAW == 'y') && (NXT(1) == 'e') &&
9031	(NXT(2) == 's')) {
9032	standalone = 1;
9033	SKIP(3);
9034	} else {
9035	xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
9036	}
9037	if (RAW != '"') {
9038	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9039	} else
9040	NEXT;
9041	} else {
9042	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
9043	}
9044	}
9045	return(standalone);
9046	}
9047
9048	/**
9049	* xmlParseXMLDecl:
9050	* @ctxt: an XML parser context
9051	*
9052	* parse an XML declaration header
9053	*
9054	* [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
9055	*/
9056
9057	void
9058	xmlParseXMLDecl(xmlParserCtxtPtr ctxt) {
9059	xmlChar *version;
9060
9061	/*
9062	* This value for standalone indicates that the document has an
9063	* XML declaration but it does not have a standalone attribute.
9064	* It will be overwritten later if a standalone attribute is found.
9065	*/
9066	ctxt->input->standalone = -2;
9067
9068	/*
9069	* We know that '<?xml' is here.
9070	*/
9071	SKIP(5);
9072
9073	if (!IS_BLANK_CH(RAW)) {
9074	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9075	"Blank needed after '<?xml'\n");
9076	}
9077	SKIP_BLANKS;
9078
9079	/*
9080	* We must have the VersionInfo here.
9081	*/
9082	version = xmlParseVersionInfo(ctxt);
9083	if (version == NULL) {
9084	xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
9085	} else {
9086	if (!xmlStrEqual(version, (const xmlChar *) XML_DEFAULT_VERSION)) {
9087	/*
9088	* TODO: Blueberry should be detected here
9089	*/
9090	xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
9091	"Unsupported version '%s'\n",
9092	version, NULL);
9093	}
9094	if (ctxt->version != NULL)
9095	xmlFree((void *) ctxt->version);
9096	ctxt->version = version;
9097	}
9098
9099	/*
9100	* We may have the encoding declaration
9101	*/
9102	if (!IS_BLANK_CH(RAW)) {
9103	if ((RAW == '?') && (NXT(1) == '>')) {
9104	SKIP(2);
9105	return;
9106	}
9107	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
9108	}
9109	xmlParseEncodingDecl(ctxt);
9110	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
9111	/*
9112	* The XML REC instructs us to stop parsing right here
9113	*/
9114	return;
9115	}
9116
9117	/*
9118	* We may have the standalone status.
9119	*/
9120	if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
9121	if ((RAW == '?') && (NXT(1) == '>')) {
9122	SKIP(2);
9123	return;
9124	}
9125	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
9126	}
9127	SKIP_BLANKS;
9128	ctxt->input->standalone = xmlParseSDDecl(ctxt);
9129
9130	SKIP_BLANKS;
9131	if ((RAW == '?') && (NXT(1) == '>')) {
9132	SKIP(2);
9133	} else if (RAW == '>') {
9134	/* Deprecated old WD ... */
9135	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
9136	NEXT;
9137	} else {
9138	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
9139	MOVETO_ENDTAG(CUR_PTR);
9140	NEXT;
9141	}
9142	}
9143
9144	/**
9145	* xmlParseMisc:
9146	* @ctxt: an XML parser context
9147	*
9148	* parse an XML Misc* optional field.
9149	*
9150	* [27] Misc ::= Comment \| PI \| S
9151	*/
9152
9153	void
9154	xmlParseMisc(xmlParserCtxtPtr ctxt) {
9155	while (((RAW == '<') && (NXT(1) == '?')) \|\|
9156	(CMP4(CUR_PTR, '<', '!', '-', '-')) \|\|
9157	IS_BLANK_CH(CUR)) {
9158	if ((RAW == '<') && (NXT(1) == '?')) {
9159	xmlParsePI(ctxt);
9160	} else if (IS_BLANK_CH(CUR)) {
9161	NEXT;
9162	} else
9163	xmlParseComment(ctxt);
9164	}
9165	}
9166
9167	/**
9168	* xmlParseDocument:
9169	* @ctxt: an XML parser context
9170	*
9171	* parse an XML document (and build a tree if using the standard SAX
9172	* interface).
9173	*
9174	* [1] document ::= prolog element Misc*
9175	*
9176	* [22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)?
9177	*
9178	* Returns 0, -1 in case of error. the parser context is augmented
9179	* as a result of the parsing.
9180	*/
9181
9182	int
9183	xmlParseDocument(xmlParserCtxtPtr ctxt) {
9184	xmlChar start[4];
9185	xmlCharEncoding enc;
9186
9187	xmlInitParser();
9188
9189	if ((ctxt == NULL) \|\| (ctxt->input == NULL))
9190	return(-1);
9191
9192	GROW;
9193
9194	/*
9195	* SAX: detecting the level.
9196	*/
9197	xmlDetectSAX2(ctxt);
9198
9199	/*
9200	* SAX: beginning of the document processing.
9201	*/
9202	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9203	ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
9204
9205	if ((ctxt->encoding == (const xmlChar *)XML_CHAR_ENCODING_NONE) &&
9206	((ctxt->input->end - ctxt->input->cur) >= 4)) {
9207	/*
9208	* Get the 4 first bytes and decode the charset
9209	* if enc != XML_CHAR_ENCODING_NONE
9210	* plug some encoding conversion routines.
9211	*/
9212	start[0] = RAW;
9213	start[1] = NXT(1);
9214	start[2] = NXT(2);
9215	start[3] = NXT(3);
9216	enc = xmlDetectCharEncoding(&start[0], 4);
9217	if (enc != XML_CHAR_ENCODING_NONE) {
9218	xmlSwitchEncoding(ctxt, enc);
9219	}
9220	}
9221
9222
9223	if (CUR == 0) {
9224	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
9225	}
9226
9227	/*
9228	* Check for the XMLDecl in the Prolog.
9229	*/
9230	GROW;
9231	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
9232
9233	/*
9234	* Note that we will switch encoding on the fly.
9235	*/
9236	xmlParseXMLDecl(ctxt);
9237	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
9238	/*
9239	* The XML REC instructs us to stop parsing right here
9240	*/
9241	return(-1);
9242	}
9243	ctxt->standalone = ctxt->input->standalone;
9244	SKIP_BLANKS;
9245	} else {
9246	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
9247	}
9248	if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
9249	ctxt->sax->startDocument(ctxt->userData);
9250
9251	/*
9252	* The Misc part of the Prolog
9253	*/
9254	GROW;
9255	xmlParseMisc(ctxt);
9256
9257	/*
9258	* Then possibly doc type declaration(s) and more Misc
9259	* (doctypedecl Misc*)?
9260	*/
9261	GROW;
9262	if (CMP9(CUR_PTR, '<', '!', 'D', 'O', 'C', 'T', 'Y', 'P', 'E')) {
9263
9264	ctxt->inSubset = 1;
9265	xmlParseDocTypeDecl(ctxt);
9266	if (RAW == '[') {
9267	ctxt->instate = XML_PARSER_DTD;
9268	xmlParseInternalSubset(ctxt);
9269	}
9270
9271	/*
9272	* Create and update the external subset.
9273	*/
9274	ctxt->inSubset = 2;
9275	if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) &&
9276	(!ctxt->disableSAX))
9277	ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
9278	ctxt->extSubSystem, ctxt->extSubURI);
9279	ctxt->inSubset = 0;
9280
9281
9282	ctxt->instate = XML_PARSER_PROLOG;
9283	xmlParseMisc(ctxt);
9284	}
9285
9286	/*
9287	* Time to start parsing the tree itself
9288	*/
9289	GROW;
9290	if (RAW != '<') {
9291	xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
9292	"Start tag expected, '<' not found\n");
9293	} else {
9294	ctxt->instate = XML_PARSER_CONTENT;
9295	xmlParseElement(ctxt);
9296	ctxt->instate = XML_PARSER_EPILOG;
9297
9298
9299	/*
9300	* The Misc part at the end
9301	*/
9302	xmlParseMisc(ctxt);
9303
9304	if (RAW != 0) {
9305	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
9306	}
9307	ctxt->instate = XML_PARSER_EOF;
9308	}
9309
9310	/*
9311	* SAX: end of the document processing.
9312	*/
9313	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9314	ctxt->sax->endDocument(ctxt->userData);
9315
9316	/*
9317	* Remove locally kept entity definitions if the tree was not built
9318	*/
9319	if ((ctxt->myDoc != NULL) &&
9320	(xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
9321	xmlFreeDoc(ctxt->myDoc);
9322	ctxt->myDoc = NULL;
9323	}
9324
9325	if (! ctxt->wellFormed) {
9326	ctxt->valid = 0;
9327	return(-1);
9328	}
9329	return(0);
9330	}
9331
9332	/**
9333	* xmlParseExtParsedEnt:
9334	* @ctxt: an XML parser context
9335	*
9336	* parse a general parsed entity
9337	* An external general parsed entity is well-formed if it matches the
9338	* production labeled extParsedEnt.
9339	*
9340	* [78] extParsedEnt ::= TextDecl? content
9341	*
9342	* Returns 0, -1 in case of error. the parser context is augmented
9343	* as a result of the parsing.
9344	*/
9345
9346	int
9347	xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) {
9348	xmlChar start[4];
9349	xmlCharEncoding enc;
9350
9351	if ((ctxt == NULL) \|\| (ctxt->input == NULL))
9352	return(-1);
9353
9354	xmlDefaultSAXHandlerInit();
9355
9356	xmlDetectSAX2(ctxt);
9357
9358	GROW;
9359
9360	/*
9361	* SAX: beginning of the document processing.
9362	*/
9363	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9364	ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
9365
9366	/*
9367	* Get the 4 first bytes and decode the charset
9368	* if enc != XML_CHAR_ENCODING_NONE
9369	* plug some encoding conversion routines.
9370	*/
9371	if ((ctxt->input->end - ctxt->input->cur) >= 4) {
9372	start[0] = RAW;
9373	start[1] = NXT(1);
9374	start[2] = NXT(2);
9375	start[3] = NXT(3);
9376	enc = xmlDetectCharEncoding(start, 4);
9377	if (enc != XML_CHAR_ENCODING_NONE) {
9378	xmlSwitchEncoding(ctxt, enc);
9379	}
9380	}
9381
9382
9383	if (CUR == 0) {
9384	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
9385	}
9386
9387	/*
9388	* Check for the XMLDecl in the Prolog.
9389	*/
9390	GROW;
9391	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
9392
9393	/*
9394	* Note that we will switch encoding on the fly.
9395	*/
9396	xmlParseXMLDecl(ctxt);
9397	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
9398	/*
9399	* The XML REC instructs us to stop parsing right here
9400	*/
9401	return(-1);
9402	}
9403	SKIP_BLANKS;
9404	} else {
9405	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
9406	}
9407	if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
9408	ctxt->sax->startDocument(ctxt->userData);
9409
9410	/*
9411	* Doing validity checking on chunk doesn't make sense
9412	*/
9413	ctxt->instate = XML_PARSER_CONTENT;
9414	ctxt->validate = 0;
9415	ctxt->loadsubset = 0;
9416	ctxt->depth = 0;
9417
9418	xmlParseContent(ctxt);
9419
9420	if ((RAW == '<') && (NXT(1) == '/')) {
9421	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
9422	} else if (RAW != 0) {
9423	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
9424	}
9425
9426	/*
9427	* SAX: end of the document processing.
9428	*/
9429	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9430	ctxt->sax->endDocument(ctxt->userData);
9431
9432	if (! ctxt->wellFormed) return(-1);
9433	return(0);
9434	}
9435
9436	#ifdef LIBXML_PUSH_ENABLED
9437	/************************************************************************
9438	* *
9439	* Progressive parsing interfaces *
9440	* *
9441	************************************************************************/
9442
9443	/**
9444	* xmlParseLookupSequence:
9445	* @ctxt: an XML parser context
9446	* @first: the first char to lookup
9447	* @next: the next char to lookup or zero
9448	* @third: the next char to lookup or zero
9449	*
9450	* Try to find if a sequence (first, next, third) or just (first next) or
9451	* (first) is available in the input stream.
9452	* This function has a side effect of (possibly) incrementing ctxt->checkIndex
9453	* to avoid rescanning sequences of bytes, it DOES change the state of the
9454	* parser, do not use liberally.
9455	*
9456	* Returns the index to the current parsing point if the full sequence
9457	* is available, -1 otherwise.
9458	*/
9459	static int
9460	xmlParseLookupSequence(xmlParserCtxtPtr ctxt, xmlChar first,
9461	xmlChar next, xmlChar third) {
9462	int base, len;
9463	xmlParserInputPtr in;
9464	const xmlChar *buf;
9465
9466	in = ctxt->input;
9467	if (in == NULL) return(-1);
9468	base = in->cur - in->base;
9469	if (base < 0) return(-1);
9470	if (ctxt->checkIndex > base)
9471	base = ctxt->checkIndex;
9472	if (in->buf == NULL) {
9473	buf = in->base;
9474	len = in->length;
9475	} else {
9476	buf = in->buf->buffer->content;
9477	len = in->buf->buffer->use;
9478	}
9479	/* take into account the sequence length */
9480	if (third) len -= 2;
9481	else if (next) len --;
9482	for (;base < len;base++) {
9483	if (buf[base] == first) {
9484	if (third != 0) {
9485	if ((buf[base + 1] != next) \|\|
9486	(buf[base + 2] != third)) continue;
9487	} else if (next != 0) {
9488	if (buf[base + 1] != next) continue;
9489	}
9490	ctxt->checkIndex = 0;
9491	#ifdef DEBUG_PUSH
9492	if (next == 0)
9493	xmlGenericError(xmlGenericErrorContext,
9494	"PP: lookup '%c' found at %d\n",
9495	first, base);
9496	else if (third == 0)
9497	xmlGenericError(xmlGenericErrorContext,
9498	"PP: lookup '%c%c' found at %d\n",
9499	first, next, base);
9500	else
9501	xmlGenericError(xmlGenericErrorContext,
9502	"PP: lookup '%c%c%c' found at %d\n",
9503	first, next, third, base);
9504	#endif
9505	return(base - (in->cur - in->base));
9506	}
9507	}
9508	ctxt->checkIndex = base;
9509	#ifdef DEBUG_PUSH
9510	if (next == 0)
9511	xmlGenericError(xmlGenericErrorContext,
9512	"PP: lookup '%c' failed\n", first);
9513	else if (third == 0)
9514	xmlGenericError(xmlGenericErrorContext,
9515	"PP: lookup '%c%c' failed\n", first, next);
9516	else
9517	xmlGenericError(xmlGenericErrorContext,
9518	"PP: lookup '%c%c%c' failed\n", first, next, third);
9519	#endif
9520	return(-1);
9521	}
9522
9523	/**
9524	* xmlParseGetLasts:
9525	* @ctxt: an XML parser context
9526	* @lastlt: pointer to store the last '<' from the input
9527	* @lastgt: pointer to store the last '>' from the input
9528	*
9529	* Lookup the last < and > in the current chunk
9530	*/
9531	static void
9532	xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt,
9533	const xmlChar **lastgt) {
9534	const xmlChar *tmp;
9535
9536	if ((ctxt == NULL) \|\| (lastlt == NULL) \|\| (lastgt == NULL)) {
9537	xmlGenericError(xmlGenericErrorContext,
9538	"Internal error: xmlParseGetLasts\n");
9539	return;
9540	}
9541	if ((ctxt->progressive != 0) && (ctxt->inputNr == 1)) {
9542	tmp = ctxt->input->end;
9543	tmp--;
9544	while ((tmp >= ctxt->input->base) && (*tmp != '<')) tmp--;
9545	if (tmp < ctxt->input->base) {
9546	*lastlt = NULL;
9547	*lastgt = NULL;
9548	} else {
9549	*lastlt = tmp;
9550	tmp++;
9551	while ((tmp < ctxt->input->end) && (*tmp != '>')) {
9552	if (*tmp == '\'') {
9553	tmp++;
9554	while ((tmp < ctxt->input->end) && (*tmp != '\'')) tmp++;
9555	if (tmp < ctxt->input->end) tmp++;
9556	} else if (*tmp == '"') {
9557	tmp++;
9558	while ((tmp < ctxt->input->end) && (*tmp != '"')) tmp++;
9559	if (tmp < ctxt->input->end) tmp++;
9560	} else
9561	tmp++;
9562	}
9563	if (tmp < ctxt->input->end)
9564	*lastgt = tmp;
9565	else {
9566	tmp = *lastlt;
9567	tmp--;
9568	while ((tmp >= ctxt->input->base) && (*tmp != '>')) tmp--;
9569	if (tmp >= ctxt->input->base)
9570	*lastgt = tmp;
9571	else
9572	*lastgt = NULL;
9573	}
9574	}
9575	} else {
9576	*lastlt = NULL;
9577	*lastgt = NULL;
9578	}
9579	}
9580	/**
9581	* xmlCheckCdataPush:
9582	* @cur: pointer to the bock of characters
9583	* @len: length of the block in bytes
9584	*
9585	* Check that the block of characters is okay as SCdata content [20]
9586	*
9587	* Returns the number of bytes to pass if okay, a negative index where an
9588	* UTF-8 error occured otherwise
9589	*/
9590	static int
9591	xmlCheckCdataPush(const xmlChar *utf, int len) {
9592	int ix;
9593	unsigned char c;
9594	int codepoint;
9595
9596	if ((utf == NULL) \|\| (len <= 0))
9597	return(0);
9598
9599	for (ix = 0; ix < len;) { /* string is 0-terminated */
9600	c = utf[ix];
9601	if ((c & 0x80) == 0x00) { /* 1-byte code, starts with 10 */
9602	if (c >= 0x20)
9603	ix++;
9604	else if ((c == 0xA) \|\| (c == 0xD) \|\| (c == 0x9))
9605	ix++;
9606	else
9607	return(-ix);
9608	} else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */
9609	if (ix + 2 > len) return(ix);
9610	if ((utf[ix+1] & 0xc0 ) != 0x80)
9611	return(-ix);
9612	codepoint = (utf[ix] & 0x1f) << 6;
9613	codepoint \|= utf[ix+1] & 0x3f;
9614	if (!xmlIsCharQ(codepoint))
9615	return(-ix);
9616	ix += 2;
9617	} else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */
9618	if (ix + 3 > len) return(ix);
9619	if (((utf[ix+1] & 0xc0) != 0x80) \|\|
9620	((utf[ix+2] & 0xc0) != 0x80))
9621	return(-ix);
9622	codepoint = (utf[ix] & 0xf) << 12;
9623	codepoint \|= (utf[ix+1] & 0x3f) << 6;
9624	codepoint \|= utf[ix+2] & 0x3f;
9625	if (!xmlIsCharQ(codepoint))
9626	return(-ix);
9627	ix += 3;
9628	} else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */
9629	if (ix + 4 > len) return(ix);
9630	if (((utf[ix+1] & 0xc0) != 0x80) \|\|
9631	((utf[ix+2] & 0xc0) != 0x80) \|\|
9632	((utf[ix+3] & 0xc0) != 0x80))
9633	return(-ix);
9634	codepoint = (utf[ix] & 0x7) << 18;
9635	codepoint \|= (utf[ix+1] & 0x3f) << 12;
9636	codepoint \|= (utf[ix+2] & 0x3f) << 6;
9637	codepoint \|= utf[ix+3] & 0x3f;
9638	if (!xmlIsCharQ(codepoint))
9639	return(-ix);
9640	ix += 4;
9641	} else /* unknown encoding */
9642	return(-ix);
9643	}
9644	return(ix);
9645	}
9646
9647	/**
9648	* xmlParseTryOrFinish:
9649	* @ctxt: an XML parser context
9650	* @terminate: last chunk indicator
9651	*
9652	* Try to progress on parsing
9653	*
9654	* Returns zero if no parsing was possible
9655	*/
9656	static int
9657	xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) {
9658	int ret = 0;
9659	int avail, tlen;
9660	xmlChar cur, next;
9661	const xmlChar lastlt, lastgt;
9662
9663	if (ctxt->input == NULL)
9664	return(0);
9665
9666	#ifdef DEBUG_PUSH
9667	switch (ctxt->instate) {
9668	case XML_PARSER_EOF:
9669	xmlGenericError(xmlGenericErrorContext,
9670	"PP: try EOF\n"); break;
9671	case XML_PARSER_START:
9672	xmlGenericError(xmlGenericErrorContext,
9673	"PP: try START\n"); break;
9674	case XML_PARSER_MISC:
9675	xmlGenericError(xmlGenericErrorContext,
9676	"PP: try MISC\n");break;
9677	case XML_PARSER_COMMENT:
9678	xmlGenericError(xmlGenericErrorContext,
9679	"PP: try COMMENT\n");break;
9680	case XML_PARSER_PROLOG:
9681	xmlGenericError(xmlGenericErrorContext,
9682	"PP: try PROLOG\n");break;
9683	case XML_PARSER_START_TAG:
9684	xmlGenericError(xmlGenericErrorContext,
9685	"PP: try START_TAG\n");break;
9686	case XML_PARSER_CONTENT:
9687	xmlGenericError(xmlGenericErrorContext,
9688	"PP: try CONTENT\n");break;
9689	case XML_PARSER_CDATA_SECTION:
9690	xmlGenericError(xmlGenericErrorContext,
9691	"PP: try CDATA_SECTION\n");break;
9692	case XML_PARSER_END_TAG:
9693	xmlGenericError(xmlGenericErrorContext,
9694	"PP: try END_TAG\n");break;
9695	case XML_PARSER_ENTITY_DECL:
9696	xmlGenericError(xmlGenericErrorContext,
9697	"PP: try ENTITY_DECL\n");break;
9698	case XML_PARSER_ENTITY_VALUE:
9699	xmlGenericError(xmlGenericErrorContext,
9700	"PP: try ENTITY_VALUE\n");break;
9701	case XML_PARSER_ATTRIBUTE_VALUE:
9702	xmlGenericError(xmlGenericErrorContext,
9703	"PP: try ATTRIBUTE_VALUE\n");break;
9704	case XML_PARSER_DTD:
9705	xmlGenericError(xmlGenericErrorContext,
9706	"PP: try DTD\n");break;
9707	case XML_PARSER_EPILOG:
9708	xmlGenericError(xmlGenericErrorContext,
9709	"PP: try EPILOG\n");break;
9710	case XML_PARSER_PI:
9711	xmlGenericError(xmlGenericErrorContext,
9712	"PP: try PI\n");break;
9713	case XML_PARSER_IGNORE:
9714	xmlGenericError(xmlGenericErrorContext,
9715	"PP: try IGNORE\n");break;
9716	}
9717	#endif
9718
9719	if ((ctxt->input != NULL) &&
9720	(ctxt->input->cur - ctxt->input->base > 4096)) {
9721	xmlSHRINK(ctxt);
9722	ctxt->checkIndex = 0;
9723	}
9724	xmlParseGetLasts(ctxt, &lastlt, &lastgt);
9725
9726	while (1) {
9727	if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
9728	return(0);
9729
9730
9731	/*
9732	* Pop-up of finished entities.
9733	*/
9734	while ((RAW == 0) && (ctxt->inputNr > 1))
9735	xmlPopInput(ctxt);
9736
9737	if (ctxt->input == NULL) break;
9738	if (ctxt->input->buf == NULL)
9739	avail = ctxt->input->length -
9740	(ctxt->input->cur - ctxt->input->base);
9741	else {
9742	/*
9743	* If we are operating on converted input, try to flush
9744	* remainng chars to avoid them stalling in the non-converted
9745	* buffer.
9746	*/
9747	if ((ctxt->input->buf->raw != NULL) &&
9748	(ctxt->input->buf->raw->use > 0)) {
9749	int base = ctxt->input->base -
9750	ctxt->input->buf->buffer->content;
9751	int current = ctxt->input->cur - ctxt->input->base;
9752
9753	xmlParserInputBufferPush(ctxt->input->buf, 0, "");
9754	ctxt->input->base = ctxt->input->buf->buffer->content + base;
9755	ctxt->input->cur = ctxt->input->base + current;
9756	ctxt->input->end =
9757	&ctxt->input->buf->buffer->content[
9758	ctxt->input->buf->buffer->use];
9759	}
9760	avail = ctxt->input->buf->buffer->use -
9761	(ctxt->input->cur - ctxt->input->base);
9762	}
9763	if (avail < 1)
9764	goto done;
9765	switch (ctxt->instate) {
9766	case XML_PARSER_EOF:
9767	/*
9768	* Document parsing is done !
9769	*/
9770	goto done;
9771	case XML_PARSER_START:
9772	if (ctxt->charset == XML_CHAR_ENCODING_NONE) {
9773	xmlChar start[4];
9774	xmlCharEncoding enc;
9775
9776	/*
9777	* Very first chars read from the document flow.
9778	*/
9779	if (avail < 4)
9780	goto done;
9781
9782	/*
9783	* Get the 4 first bytes and decode the charset
9784	* if enc != XML_CHAR_ENCODING_NONE
9785	* plug some encoding conversion routines,
9786	* else xmlSwitchEncoding will set to (default)
9787	* UTF8.
9788	*/
9789	start[0] = RAW;
9790	start[1] = NXT(1);
9791	start[2] = NXT(2);
9792	start[3] = NXT(3);
9793	enc = xmlDetectCharEncoding(start, 4);
9794	xmlSwitchEncoding(ctxt, enc);
9795	break;
9796	}
9797
9798	if (avail < 2)
9799	goto done;
9800	cur = ctxt->input->cur[0];
9801	next = ctxt->input->cur[1];
9802	if (cur == 0) {
9803	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9804	ctxt->sax->setDocumentLocator(ctxt->userData,
9805	&xmlDefaultSAXLocator);
9806	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
9807	ctxt->instate = XML_PARSER_EOF;
9808	#ifdef DEBUG_PUSH
9809	xmlGenericError(xmlGenericErrorContext,
9810	"PP: entering EOF\n");
9811	#endif
9812	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9813	ctxt->sax->endDocument(ctxt->userData);
9814	goto done;
9815	}
9816	if ((cur == '<') && (next == '?')) {
9817	/* PI or XML decl */
9818	if (avail < 5) return(ret);
9819	if ((!terminate) &&
9820	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
9821	return(ret);
9822	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9823	ctxt->sax->setDocumentLocator(ctxt->userData,
9824	&xmlDefaultSAXLocator);
9825	if ((ctxt->input->cur[2] == 'x') &&
9826	(ctxt->input->cur[3] == 'm') &&
9827	(ctxt->input->cur[4] == 'l') &&
9828	(IS_BLANK_CH(ctxt->input->cur[5]))) {
9829	ret += 5;
9830	#ifdef DEBUG_PUSH
9831	xmlGenericError(xmlGenericErrorContext,
9832	"PP: Parsing XML Decl\n");
9833	#endif
9834	xmlParseXMLDecl(ctxt);
9835	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
9836	/*
9837	* The XML REC instructs us to stop parsing right
9838	* here
9839	*/
9840	ctxt->instate = XML_PARSER_EOF;
9841	return(0);
9842	}
9843	ctxt->standalone = ctxt->input->standalone;
9844	if ((ctxt->encoding == NULL) &&
9845	(ctxt->input->encoding != NULL))
9846	ctxt->encoding = xmlStrdup(ctxt->input->encoding);
9847	if ((ctxt->sax) && (ctxt->sax->startDocument) &&
9848	(!ctxt->disableSAX))
9849	ctxt->sax->startDocument(ctxt->userData);
9850	ctxt->instate = XML_PARSER_MISC;
9851	#ifdef DEBUG_PUSH
9852	xmlGenericError(xmlGenericErrorContext,
9853	"PP: entering MISC\n");
9854	#endif
9855	} else {
9856	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
9857	if ((ctxt->sax) && (ctxt->sax->startDocument) &&
9858	(!ctxt->disableSAX))
9859	ctxt->sax->startDocument(ctxt->userData);
9860	ctxt->instate = XML_PARSER_MISC;
9861	#ifdef DEBUG_PUSH
9862	xmlGenericError(xmlGenericErrorContext,
9863	"PP: entering MISC\n");
9864	#endif
9865	}
9866	} else {
9867	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9868	ctxt->sax->setDocumentLocator(ctxt->userData,
9869	&xmlDefaultSAXLocator);
9870	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
9871	if (ctxt->version == NULL) {
9872	xmlErrMemory(ctxt, NULL);
9873	break;
9874	}
9875	if ((ctxt->sax) && (ctxt->sax->startDocument) &&
9876	(!ctxt->disableSAX))
9877	ctxt->sax->startDocument(ctxt->userData);
9878	ctxt->instate = XML_PARSER_MISC;
9879	#ifdef DEBUG_PUSH
9880	xmlGenericError(xmlGenericErrorContext,
9881	"PP: entering MISC\n");
9882	#endif
9883	}
9884	break;
9885	case XML_PARSER_START_TAG: {
9886	const xmlChar *name;
9887	const xmlChar *prefix;
9888	const xmlChar *URI;
9889	int nsNr = ctxt->nsNr;
9890
9891	if ((avail < 2) && (ctxt->inputNr == 1))
9892	goto done;
9893	cur = ctxt->input->cur[0];
9894	if (cur != '<') {
9895	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
9896	ctxt->instate = XML_PARSER_EOF;
9897	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9898	ctxt->sax->endDocument(ctxt->userData);
9899	goto done;
9900	}
9901	if (!terminate) {
9902	if (ctxt->progressive) {
9903	/* > can be found unescaped in attribute values */
9904	if ((lastgt == NULL) \|\| (ctxt->input->cur >= lastgt))
9905	goto done;
9906	} else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
9907	goto done;
9908	}
9909	}
9910	if (ctxt->spaceNr == 0)
9911	spacePush(ctxt, -1);
9912	else if (*ctxt->space == -2)
9913	spacePush(ctxt, -1);
9914	else
9915	spacePush(ctxt, *ctxt->space);
9916	#ifdef LIBXML_SAX1_ENABLED
9917	if (ctxt->sax2)
9918	#endif /* LIBXML_SAX1_ENABLED */
9919	name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
9920	#ifdef LIBXML_SAX1_ENABLED
9921	else
9922	name = xmlParseStartTag(ctxt);
9923	#endif /* LIBXML_SAX1_ENABLED */
9924	if (name == NULL) {
9925	spacePop(ctxt);
9926	ctxt->instate = XML_PARSER_EOF;
9927	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9928	ctxt->sax->endDocument(ctxt->userData);
9929	goto done;
9930	}
9931	#ifdef LIBXML_VALID_ENABLED
9932	/*
9933	* [ VC: Root Element Type ]
9934	* The Name in the document type declaration must match
9935	* the element type of the root element.
9936	*/
9937	if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
9938	ctxt->node && (ctxt->node == ctxt->myDoc->children))
9939	ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
9940	#endif /* LIBXML_VALID_ENABLED */
9941
9942	/*
9943	* Check for an Empty Element.
9944	*/
9945	if ((RAW == '/') && (NXT(1) == '>')) {
9946	SKIP(2);
9947
9948	if (ctxt->sax2) {
9949	if ((ctxt->sax != NULL) &&
9950	(ctxt->sax->endElementNs != NULL) &&
9951	(!ctxt->disableSAX))
9952	ctxt->sax->endElementNs(ctxt->userData, name,
9953	prefix, URI);
9954	if (ctxt->nsNr - nsNr > 0)
9955	nsPop(ctxt, ctxt->nsNr - nsNr);
9956	#ifdef LIBXML_SAX1_ENABLED
9957	} else {
9958	if ((ctxt->sax != NULL) &&
9959	(ctxt->sax->endElement != NULL) &&
9960	(!ctxt->disableSAX))
9961	ctxt->sax->endElement(ctxt->userData, name);
9962	#endif /* LIBXML_SAX1_ENABLED */
9963	}
9964	spacePop(ctxt);
9965	if (ctxt->nameNr == 0) {
9966	ctxt->instate = XML_PARSER_EPILOG;
9967	} else {
9968	ctxt->instate = XML_PARSER_CONTENT;
9969	}
9970	break;
9971	}
9972	if (RAW == '>') {
9973	NEXT;
9974	} else {
9975	xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED,
9976	"Couldn't find end of Start Tag %s\n",
9977	name);
9978	nodePop(ctxt);
9979	spacePop(ctxt);
9980	}
9981	if (ctxt->sax2)
9982	nameNsPush(ctxt, name, prefix, URI, ctxt->nsNr - nsNr);
9983	#ifdef LIBXML_SAX1_ENABLED
9984	else
9985	namePush(ctxt, name);
9986	#endif /* LIBXML_SAX1_ENABLED */
9987
9988	ctxt->instate = XML_PARSER_CONTENT;
9989	break;
9990	}
9991	case XML_PARSER_CONTENT: {
9992	const xmlChar *test;
9993	unsigned int cons;
9994	if ((avail < 2) && (ctxt->inputNr == 1))
9995	goto done;
9996	cur = ctxt->input->cur[0];
9997	next = ctxt->input->cur[1];
9998
9999	test = CUR_PTR;
10000	cons = ctxt->input->consumed;
10001	if ((cur == '<') && (next == '/')) {
10002	ctxt->instate = XML_PARSER_END_TAG;
10003	break;
10004	} else if ((cur == '<') && (next == '?')) {
10005	if ((!terminate) &&
10006	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10007	goto done;
10008	xmlParsePI(ctxt);
10009	} else if ((cur == '<') && (next != '!')) {
10010	ctxt->instate = XML_PARSER_START_TAG;
10011	break;
10012	} else if ((cur == '<') && (next == '!') &&
10013	(ctxt->input->cur[2] == '-') &&
10014	(ctxt->input->cur[3] == '-')) {
10015	int term;
10016
10017	if (avail < 4)
10018	goto done;
10019	ctxt->input->cur += 4;
10020	term = xmlParseLookupSequence(ctxt, '-', '-', '>');
10021	ctxt->input->cur -= 4;
10022	if ((!terminate) && (term < 0))
10023	goto done;
10024	xmlParseComment(ctxt);
10025	ctxt->instate = XML_PARSER_CONTENT;
10026	} else if ((cur == '<') && (ctxt->input->cur[1] == '!') &&
10027	(ctxt->input->cur[2] == '[') &&
10028	(ctxt->input->cur[3] == 'C') &&
10029	(ctxt->input->cur[4] == 'D') &&
10030	(ctxt->input->cur[5] == 'A') &&
10031	(ctxt->input->cur[6] == 'T') &&
10032	(ctxt->input->cur[7] == 'A') &&
10033	(ctxt->input->cur[8] == '[')) {
10034	SKIP(9);
10035	ctxt->instate = XML_PARSER_CDATA_SECTION;
10036	break;
10037	} else if ((cur == '<') && (next == '!') &&
10038	(avail < 9)) {
10039	goto done;
10040	} else if (cur == '&') {
10041	if ((!terminate) &&
10042	(xmlParseLookupSequence(ctxt, ';', 0, 0) < 0))
10043	goto done;
10044	xmlParseReference(ctxt);
10045	} else {
10046	/* TODO Avoid the extra copy, handle directly !!! */
10047	/*
10048	* Goal of the following test is:
10049	* - minimize calls to the SAX 'character' callback
10050	* when they are mergeable
10051	* - handle an problem for isBlank when we only parse
10052	* a sequence of blank chars and the next one is
10053	* not available to check against '<' presence.
10054	* - tries to homogenize the differences in SAX
10055	* callbacks between the push and pull versions
10056	* of the parser.
10057	*/
10058	if ((ctxt->inputNr == 1) &&
10059	(avail < XML_PARSER_BIG_BUFFER_SIZE)) {
10060	if (!terminate) {
10061	if (ctxt->progressive) {
10062	if ((lastlt == NULL) \|\|
10063	(ctxt->input->cur > lastlt))
10064	goto done;
10065	} else if (xmlParseLookupSequence(ctxt,
10066	'<', 0, 0) < 0) {
10067	goto done;
10068	}
10069	}
10070	}
10071	ctxt->checkIndex = 0;
10072	xmlParseCharData(ctxt, 0);
10073	}
10074	/*
10075	* Pop-up of finished entities.
10076	*/
10077	while ((RAW == 0) && (ctxt->inputNr > 1))
10078	xmlPopInput(ctxt);
10079	if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
10080	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
10081	"detected an error in element content\n");
10082	ctxt->instate = XML_PARSER_EOF;
10083	break;
10084	}
10085	break;
10086	}
10087	case XML_PARSER_END_TAG:
10088	if (avail < 2)
10089	goto done;
10090	if (!terminate) {
10091	if (ctxt->progressive) {
10092	/* > can be found unescaped in attribute values */
10093	if ((lastgt == NULL) \|\| (ctxt->input->cur >= lastgt))
10094	goto done;
10095	} else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
10096	goto done;
10097	}
10098	}
10099	if (ctxt->sax2) {
10100	xmlParseEndTag2(ctxt,
10101	(void ) ctxt->pushTab[ctxt->nameNr 3 - 3],
10102	(void ) ctxt->pushTab[ctxt->nameNr 3 - 2], 0,
10103	(int) (long) ctxt->pushTab[ctxt->nameNr * 3 - 1], 0);
10104	nameNsPop(ctxt);
10105	}
10106	#ifdef LIBXML_SAX1_ENABLED
10107	else
10108	xmlParseEndTag1(ctxt, 0);
10109	#endif /* LIBXML_SAX1_ENABLED */
10110	if (ctxt->nameNr == 0) {
10111	ctxt->instate = XML_PARSER_EPILOG;
10112	} else {
10113	ctxt->instate = XML_PARSER_CONTENT;
10114	}
10115	break;
10116	case XML_PARSER_CDATA_SECTION: {
10117	/*
10118	* The Push mode need to have the SAX callback for
10119	* cdataBlock merge back contiguous callbacks.
10120	*/
10121	int base;
10122
10123	base = xmlParseLookupSequence(ctxt, ']', ']', '>');
10124	if (base < 0) {
10125	if (avail >= XML_PARSER_BIG_BUFFER_SIZE + 2) {
10126	int tmp;
10127
10128	tmp = xmlCheckCdataPush(ctxt->input->cur,
10129	XML_PARSER_BIG_BUFFER_SIZE);
10130	if (tmp < 0) {
10131	tmp = -tmp;
10132	ctxt->input->cur += tmp;
10133	goto encoding_error;
10134	}
10135	if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
10136	if (ctxt->sax->cdataBlock != NULL)
10137	ctxt->sax->cdataBlock(ctxt->userData,
10138	ctxt->input->cur, tmp);
10139	else if (ctxt->sax->characters != NULL)
10140	ctxt->sax->characters(ctxt->userData,
10141	ctxt->input->cur, tmp);
10142	}
10143	SKIPL(tmp);
10144	ctxt->checkIndex = 0;
10145	}
10146	goto done;
10147	} else {
10148	int tmp;
10149
10150	tmp = xmlCheckCdataPush(ctxt->input->cur, base);
10151	if ((tmp < 0) \|\| (tmp != base)) {
10152	tmp = -tmp;
10153	ctxt->input->cur += tmp;
10154	goto encoding_error;
10155	}
10156	if ((ctxt->sax != NULL) && (base > 0) &&
10157	(!ctxt->disableSAX)) {
10158	if (ctxt->sax->cdataBlock != NULL)
10159	ctxt->sax->cdataBlock(ctxt->userData,
10160	ctxt->input->cur, base);
10161	else if (ctxt->sax->characters != NULL)
10162	ctxt->sax->characters(ctxt->userData,
10163	ctxt->input->cur, base);
10164	}
10165	SKIPL(base + 3);
10166	ctxt->checkIndex = 0;
10167	ctxt->instate = XML_PARSER_CONTENT;
10168	#ifdef DEBUG_PUSH
10169	xmlGenericError(xmlGenericErrorContext,
10170	"PP: entering CONTENT\n");
10171	#endif
10172	}
10173	break;
10174	}
10175	case XML_PARSER_MISC:
10176	SKIP_BLANKS;
10177	if (ctxt->input->buf == NULL)
10178	avail = ctxt->input->length -
10179	(ctxt->input->cur - ctxt->input->base);
10180	else
10181	avail = ctxt->input->buf->buffer->use -
10182	(ctxt->input->cur - ctxt->input->base);
10183	if (avail < 2)
10184	goto done;
10185	cur = ctxt->input->cur[0];
10186	next = ctxt->input->cur[1];
10187	if ((cur == '<') && (next == '?')) {
10188	if ((!terminate) &&
10189	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10190	goto done;
10191	#ifdef DEBUG_PUSH
10192	xmlGenericError(xmlGenericErrorContext,
10193	"PP: Parsing PI\n");
10194	#endif
10195	xmlParsePI(ctxt);
10196	ctxt->checkIndex = 0;
10197	} else if ((cur == '<') && (next == '!') &&
10198	(ctxt->input->cur[2] == '-') &&
10199	(ctxt->input->cur[3] == '-')) {
10200	if ((!terminate) &&
10201	(xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
10202	goto done;
10203	#ifdef DEBUG_PUSH
10204	xmlGenericError(xmlGenericErrorContext,
10205	"PP: Parsing Comment\n");
10206	#endif
10207	xmlParseComment(ctxt);
10208	ctxt->instate = XML_PARSER_MISC;
10209	ctxt->checkIndex = 0;
10210	} else if ((cur == '<') && (next == '!') &&
10211	(ctxt->input->cur[2] == 'D') &&
10212	(ctxt->input->cur[3] == 'O') &&
10213	(ctxt->input->cur[4] == 'C') &&
10214	(ctxt->input->cur[5] == 'T') &&
10215	(ctxt->input->cur[6] == 'Y') &&
10216	(ctxt->input->cur[7] == 'P') &&
10217	(ctxt->input->cur[8] == 'E')) {
10218	if ((!terminate) &&
10219	(xmlParseLookupSequence(ctxt, '>', 0, 0) < 0))
10220	goto done;
10221	#ifdef DEBUG_PUSH
10222	xmlGenericError(xmlGenericErrorContext,
10223	"PP: Parsing internal subset\n");
10224	#endif
10225	ctxt->inSubset = 1;
10226	xmlParseDocTypeDecl(ctxt);
10227	if (RAW == '[') {
10228	ctxt->instate = XML_PARSER_DTD;
10229	#ifdef DEBUG_PUSH
10230	xmlGenericError(xmlGenericErrorContext,
10231	"PP: entering DTD\n");
10232	#endif
10233	} else {
10234	/*
10235	* Create and update the external subset.
10236	*/
10237	ctxt->inSubset = 2;
10238	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
10239	(ctxt->sax->externalSubset != NULL))
10240	ctxt->sax->externalSubset(ctxt->userData,
10241	ctxt->intSubName, ctxt->extSubSystem,
10242	ctxt->extSubURI);
10243	ctxt->inSubset = 0;
10244	ctxt->instate = XML_PARSER_PROLOG;
10245	#ifdef DEBUG_PUSH
10246	xmlGenericError(xmlGenericErrorContext,
10247	"PP: entering PROLOG\n");
10248	#endif
10249	}
10250	} else if ((cur == '<') && (next == '!') &&
10251	(avail < 9)) {
10252	goto done;
10253	} else {
10254	ctxt->instate = XML_PARSER_START_TAG;
10255	ctxt->progressive = 1;
10256	xmlParseGetLasts(ctxt, &lastlt, &lastgt);
10257	#ifdef DEBUG_PUSH
10258	xmlGenericError(xmlGenericErrorContext,
10259	"PP: entering START_TAG\n");
10260	#endif
10261	}
10262	break;
10263	case XML_PARSER_PROLOG:
10264	SKIP_BLANKS;
10265	if (ctxt->input->buf == NULL)
10266	avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
10267	else
10268	avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
10269	if (avail < 2)
10270	goto done;
10271	cur = ctxt->input->cur[0];
10272	next = ctxt->input->cur[1];
10273	if ((cur == '<') && (next == '?')) {
10274	if ((!terminate) &&
10275	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10276	goto done;
10277	#ifdef DEBUG_PUSH
10278	xmlGenericError(xmlGenericErrorContext,
10279	"PP: Parsing PI\n");
10280	#endif
10281	xmlParsePI(ctxt);
10282	} else if ((cur == '<') && (next == '!') &&
10283	(ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
10284	if ((!terminate) &&
10285	(xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
10286	goto done;
10287	#ifdef DEBUG_PUSH
10288	xmlGenericError(xmlGenericErrorContext,
10289	"PP: Parsing Comment\n");
10290	#endif
10291	xmlParseComment(ctxt);
10292	ctxt->instate = XML_PARSER_PROLOG;
10293	} else if ((cur == '<') && (next == '!') &&
10294	(avail < 4)) {
10295	goto done;
10296	} else {
10297	ctxt->instate = XML_PARSER_START_TAG;
10298	if (ctxt->progressive == 0)
10299	ctxt->progressive = 1;
10300	xmlParseGetLasts(ctxt, &lastlt, &lastgt);
10301	#ifdef DEBUG_PUSH
10302	xmlGenericError(xmlGenericErrorContext,
10303	"PP: entering START_TAG\n");
10304	#endif
10305	}
10306	break;
10307	case XML_PARSER_EPILOG:
10308	SKIP_BLANKS;
10309	if (ctxt->input->buf == NULL)
10310	avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
10311	else
10312	avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
10313	if (avail < 2)
10314	goto done;
10315	cur = ctxt->input->cur[0];
10316	next = ctxt->input->cur[1];
10317	if ((cur == '<') && (next == '?')) {
10318	if ((!terminate) &&
10319	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10320	goto done;
10321	#ifdef DEBUG_PUSH
10322	xmlGenericError(xmlGenericErrorContext,
10323	"PP: Parsing PI\n");
10324	#endif
10325	xmlParsePI(ctxt);
10326	ctxt->instate = XML_PARSER_EPILOG;
10327	} else if ((cur == '<') && (next == '!') &&
10328	(ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
10329	if ((!terminate) &&
10330	(xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
10331	goto done;
10332	#ifdef DEBUG_PUSH
10333	xmlGenericError(xmlGenericErrorContext,
10334	"PP: Parsing Comment\n");
10335	#endif
10336	xmlParseComment(ctxt);
10337	ctxt->instate = XML_PARSER_EPILOG;
10338	} else if ((cur == '<') && (next == '!') &&
10339	(avail < 4)) {
10340	goto done;
10341	} else {
10342	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10343	ctxt->instate = XML_PARSER_EOF;
10344	#ifdef DEBUG_PUSH
10345	xmlGenericError(xmlGenericErrorContext,
10346	"PP: entering EOF\n");
10347	#endif
10348	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10349	ctxt->sax->endDocument(ctxt->userData);
10350	goto done;
10351	}
10352	break;
10353	case XML_PARSER_DTD: {
10354	/*
10355	* Sorry but progressive parsing of the internal subset
10356	* is not expected to be supported. We first check that
10357	* the full content of the internal subset is available and
10358	* the parsing is launched only at that point.
10359	* Internal subset ends up with "']' S? '>'" in an unescaped
10360	* section and not in a ']]>' sequence which are conditional
10361	* sections (whoever argued to keep that crap in XML deserve
10362	* a place in hell !).
10363	*/
10364	int base, i;
10365	xmlChar *buf;
10366	xmlChar quote = 0;
10367
10368	base = ctxt->input->cur - ctxt->input->base;
10369	if (base < 0) return(0);
10370	if (ctxt->checkIndex > base)
10371	base = ctxt->checkIndex;
10372	buf = ctxt->input->buf->buffer->content;
10373	for (;(unsigned int) base < ctxt->input->buf->buffer->use;
10374	base++) {
10375	if (quote != 0) {
10376	if (buf[base] == quote)
10377	quote = 0;
10378	continue;
10379	}
10380	if ((quote == 0) && (buf[base] == '<')) {
10381	int found = 0;
10382	/* special handling of comments */
10383	if (((unsigned int) base + 4 <
10384	ctxt->input->buf->buffer->use) &&
10385	(buf[base + 1] == '!') &&
10386	(buf[base + 2] == '-') &&
10387	(buf[base + 3] == '-')) {
10388	for (;(unsigned int) base + 3 <
10389	ctxt->input->buf->buffer->use; base++) {
10390	if ((buf[base] == '-') &&
10391	(buf[base + 1] == '-') &&
10392	(buf[base + 2] == '>')) {
10393	found = 1;
10394	base += 2;
10395	break;
10396	}
10397	}
10398	if (!found) {
10399	#if 0
10400	fprintf(stderr, "unfinished comment\n");
10401	#endif
10402	break; /* for */
10403	}
10404	continue;
10405	}
10406	}
10407	if (buf[base] == '"') {
10408	quote = '"';
10409	continue;
10410	}
10411	if (buf[base] == '\'') {
10412	quote = '\'';
10413	continue;
10414	}
10415	if (buf[base] == ']') {
10416	#if 0
10417	fprintf(stderr, "%c%c%c%c: ", buf[base],
10418	buf[base + 1], buf[base + 2], buf[base + 3]);
10419	#endif
10420	if ((unsigned int) base +1 >=
10421	ctxt->input->buf->buffer->use)
10422	break;
10423	if (buf[base + 1] == ']') {
10424	/* conditional crap, skip both ']' ! */
10425	base++;
10426	continue;
10427	}
10428	for (i = 1;
10429	(unsigned int) base + i < ctxt->input->buf->buffer->use;
10430	i++) {
10431	if (buf[base + i] == '>') {
10432	#if 0
10433	fprintf(stderr, "found\n");
10434	#endif
10435	goto found_end_int_subset;
10436	}
10437	if (!IS_BLANK_CH(buf[base + i])) {
10438	#if 0
10439	fprintf(stderr, "not found\n");
10440	#endif
10441	goto not_end_of_int_subset;
10442	}
10443	}
10444	#if 0
10445	fprintf(stderr, "end of stream\n");
10446	#endif
10447	break;
10448
10449	}
10450	not_end_of_int_subset:
10451	continue; /* for */
10452	}
10453	/*
10454	* We didn't found the end of the Internal subset
10455	*/
10456	#ifdef DEBUG_PUSH
10457	if (next == 0)
10458	xmlGenericError(xmlGenericErrorContext,
10459	"PP: lookup of int subset end filed\n");
10460	#endif
10461	goto done;
10462
10463	found_end_int_subset:
10464	xmlParseInternalSubset(ctxt);
10465	ctxt->inSubset = 2;
10466	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
10467	(ctxt->sax->externalSubset != NULL))
10468	ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
10469	ctxt->extSubSystem, ctxt->extSubURI);
10470	ctxt->inSubset = 0;
10471	ctxt->instate = XML_PARSER_PROLOG;
10472	ctxt->checkIndex = 0;
10473	#ifdef DEBUG_PUSH
10474	xmlGenericError(xmlGenericErrorContext,
10475	"PP: entering PROLOG\n");
10476	#endif
10477	break;
10478	}
10479	case XML_PARSER_COMMENT:
10480	xmlGenericError(xmlGenericErrorContext,
10481	"PP: internal error, state == COMMENT\n");
10482	ctxt->instate = XML_PARSER_CONTENT;
10483	#ifdef DEBUG_PUSH
10484	xmlGenericError(xmlGenericErrorContext,
10485	"PP: entering CONTENT\n");
10486	#endif
10487	break;
10488	case XML_PARSER_IGNORE:
10489	xmlGenericError(xmlGenericErrorContext,
10490	"PP: internal error, state == IGNORE");
10491	ctxt->instate = XML_PARSER_DTD;
10492	#ifdef DEBUG_PUSH
10493	xmlGenericError(xmlGenericErrorContext,
10494	"PP: entering DTD\n");
10495	#endif
10496	break;
10497	case XML_PARSER_PI:
10498	xmlGenericError(xmlGenericErrorContext,
10499	"PP: internal error, state == PI\n");
10500	ctxt->instate = XML_PARSER_CONTENT;
10501	#ifdef DEBUG_PUSH
10502	xmlGenericError(xmlGenericErrorContext,
10503	"PP: entering CONTENT\n");
10504	#endif
10505	break;
10506	case XML_PARSER_ENTITY_DECL:
10507	xmlGenericError(xmlGenericErrorContext,
10508	"PP: internal error, state == ENTITY_DECL\n");
10509	ctxt->instate = XML_PARSER_DTD;
10510	#ifdef DEBUG_PUSH
10511	xmlGenericError(xmlGenericErrorContext,
10512	"PP: entering DTD\n");
10513	#endif
10514	break;
10515	case XML_PARSER_ENTITY_VALUE:
10516	xmlGenericError(xmlGenericErrorContext,
10517	"PP: internal error, state == ENTITY_VALUE\n");
10518	ctxt->instate = XML_PARSER_CONTENT;
10519	#ifdef DEBUG_PUSH
10520	xmlGenericError(xmlGenericErrorContext,
10521	"PP: entering DTD\n");
10522	#endif
10523	break;
10524	case XML_PARSER_ATTRIBUTE_VALUE:
10525	xmlGenericError(xmlGenericErrorContext,
10526	"PP: internal error, state == ATTRIBUTE_VALUE\n");
10527	ctxt->instate = XML_PARSER_START_TAG;
10528	#ifdef DEBUG_PUSH
10529	xmlGenericError(xmlGenericErrorContext,
10530	"PP: entering START_TAG\n");
10531	#endif
10532	break;
10533	case XML_PARSER_SYSTEM_LITERAL:
10534	xmlGenericError(xmlGenericErrorContext,
10535	"PP: internal error, state == SYSTEM_LITERAL\n");
10536	ctxt->instate = XML_PARSER_START_TAG;
10537	#ifdef DEBUG_PUSH
10538	xmlGenericError(xmlGenericErrorContext,
10539	"PP: entering START_TAG\n");
10540	#endif
10541	break;
10542	case XML_PARSER_PUBLIC_LITERAL:
10543	xmlGenericError(xmlGenericErrorContext,
10544	"PP: internal error, state == PUBLIC_LITERAL\n");
10545	ctxt->instate = XML_PARSER_START_TAG;
10546	#ifdef DEBUG_PUSH
10547	xmlGenericError(xmlGenericErrorContext,
10548	"PP: entering START_TAG\n");
10549	#endif
10550	break;
10551	}
10552	}
10553	done:
10554	#ifdef DEBUG_PUSH
10555	xmlGenericError(xmlGenericErrorContext, "PP: done %d\n", ret);
10556	#endif
10557	return(ret);
10558	encoding_error:
10559	{
10560	char buffer[150];
10561
10562	snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
10563	ctxt->input->cur[0], ctxt->input->cur[1],
10564	ctxt->input->cur[2], ctxt->input->cur[3]);
10565	__xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
10566	"Input is not proper UTF-8, indicate encoding !\n%s",
10567	BAD_CAST buffer, NULL);
10568	}
10569	return(0);
10570	}
10571
10572	/**
10573	* xmlParseChunk:
10574	* @ctxt: an XML parser context
10575	* @chunk: an char array
10576	* @size: the size in byte of the chunk
10577	* @terminate: last chunk indicator
10578	*
10579	* Parse a Chunk of memory
10580	*
10581	* Returns zero if no error, the xmlParserErrors otherwise.
10582	*/
10583	int
10584	xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size,
10585	int terminate) {
10586	int end_in_lf = 0;
10587
10588	if (ctxt == NULL)
10589	return(XML_ERR_INTERNAL_ERROR);
10590	if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
10591	return(ctxt->errNo);
10592	if (ctxt->instate == XML_PARSER_START)
10593	xmlDetectSAX2(ctxt);
10594	if ((size > 0) && (chunk != NULL) && (!terminate) &&
10595	(chunk[size - 1] == '\r')) {
10596	end_in_lf = 1;
10597	size--;
10598	}
10599	if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
10600	(ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF)) {
10601	int base = ctxt->input->base - ctxt->input->buf->buffer->content;
10602	int cur = ctxt->input->cur - ctxt->input->base;
10603	int res;
10604
10605	res =xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
10606	if (res < 0) {
10607	ctxt->errNo = XML_PARSER_EOF;
10608	ctxt->disableSAX = 1;
10609	return (XML_PARSER_EOF);
10610	}
10611	ctxt->input->base = ctxt->input->buf->buffer->content + base;
10612	ctxt->input->cur = ctxt->input->base + cur;
10613	ctxt->input->end =
10614	&ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
10615	#ifdef DEBUG_PUSH
10616	xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
10617	#endif
10618
10619	} else if (ctxt->instate != XML_PARSER_EOF) {
10620	if ((ctxt->input != NULL) && ctxt->input->buf != NULL) {
10621	xmlParserInputBufferPtr in = ctxt->input->buf;
10622	if ((in->encoder != NULL) && (in->buffer != NULL) &&
10623	(in->raw != NULL)) {
10624	int nbchars;
10625
10626	nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
10627	if (nbchars < 0) {
10628	/* TODO 2.6.0 */
10629	xmlGenericError(xmlGenericErrorContext,
10630	"xmlParseChunk: encoder error\n");
10631	return(XML_ERR_INVALID_ENCODING);
10632	}
10633	}
10634	}
10635	}
10636	xmlParseTryOrFinish(ctxt, terminate);
10637	if ((end_in_lf == 1) && (ctxt->input != NULL) &&
10638	(ctxt->input->buf != NULL)) {
10639	xmlParserInputBufferPush(ctxt->input->buf, 1, "\r");
10640	}
10641	if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
10642	return(ctxt->errNo);
10643	if (terminate) {
10644	/*
10645	* Check for termination
10646	*/
10647	int avail = 0;
10648
10649	if (ctxt->input != NULL) {
10650	if (ctxt->input->buf == NULL)
10651	avail = ctxt->input->length -
10652	(ctxt->input->cur - ctxt->input->base);
10653	else
10654	avail = ctxt->input->buf->buffer->use -
10655	(ctxt->input->cur - ctxt->input->base);
10656	}
10657
10658	if ((ctxt->instate != XML_PARSER_EOF) &&
10659	(ctxt->instate != XML_PARSER_EPILOG)) {
10660	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10661	}
10662	if ((ctxt->instate == XML_PARSER_EPILOG) && (avail > 0)) {
10663	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10664	}
10665	if (ctxt->instate != XML_PARSER_EOF) {
10666	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10667	ctxt->sax->endDocument(ctxt->userData);
10668	}
10669	ctxt->instate = XML_PARSER_EOF;
10670	}
10671	return((xmlParserErrors) ctxt->errNo);
10672	}
10673
10674	/************************************************************************
10675	* *
10676	* I/O front end functions to the parser *
10677	* *
10678	************************************************************************/
10679
10680	/**
10681	* xmlCreatePushParserCtxt:
10682	* @sax: a SAX handler
10683	* @user_data: The user data returned on SAX callbacks
10684	* @chunk: a pointer to an array of chars
10685	* @size: number of chars in the array
10686	* @filename: an optional file name or URI
10687	*
10688	* Create a parser context for using the XML parser in push mode.
10689	* If @buffer and @size are non-NULL, the data is used to detect
10690	* the encoding. The remaining characters will be parsed so they
10691	* don't need to be fed in again through xmlParseChunk.
10692	* To allow content encoding detection, @size should be >= 4
10693	* The value of @filename is used for fetching external entities
10694	* and error/warning reports.
10695	*
10696	* Returns the new parser context or NULL
10697	*/
10698
10699	xmlParserCtxtPtr
10700	xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
10701	const char chunk, int size, const char filename) {
10702	xmlParserCtxtPtr ctxt;
10703	xmlParserInputPtr inputStream;
10704	xmlParserInputBufferPtr buf;
10705	xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
10706
10707	/*
10708	* plug some encoding conversion routines
10709	*/
10710	if ((chunk != NULL) && (size >= 4))
10711	enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
10712
10713	buf = xmlAllocParserInputBuffer(enc);
10714	if (buf == NULL) return(NULL);
10715
10716	ctxt = xmlNewParserCtxt();
10717	if (ctxt == NULL) {
10718	xmlErrMemory(NULL, "creating parser: out of memory\n");
10719	xmlFreeParserInputBuffer(buf);
10720	return(NULL);
10721	}
10722	ctxt->dictNames = 1;
10723	ctxt->pushTab = (void *) xmlMalloc(ctxt->nameMax 3 * sizeof(xmlChar *));
10724	if (ctxt->pushTab == NULL) {
10725	xmlErrMemory(ctxt, NULL);
10726	xmlFreeParserInputBuffer(buf);
10727	xmlFreeParserCtxt(ctxt);
10728	return(NULL);
10729	}
10730	if (sax != NULL) {
10731	#ifdef LIBXML_SAX1_ENABLED
10732	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
10733	#endif /* LIBXML_SAX1_ENABLED */
10734	xmlFree(ctxt->sax);
10735	ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
10736	if (ctxt->sax == NULL) {
10737	xmlErrMemory(ctxt, NULL);
10738	xmlFreeParserInputBuffer(buf);
10739	xmlFreeParserCtxt(ctxt);
10740	return(NULL);
10741	}
10742	memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
10743	if (sax->initialized == XML_SAX2_MAGIC)
10744	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
10745	else
10746	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
10747	if (user_data != NULL)
10748	ctxt->userData = user_data;
10749	}
10750	if (filename == NULL) {
10751	ctxt->directory = NULL;
10752	} else {
10753	ctxt->directory = xmlParserGetDirectory(filename);
10754	}
10755
10756	inputStream = xmlNewInputStream(ctxt);
10757	if (inputStream == NULL) {
10758	xmlFreeParserCtxt(ctxt);
10759	xmlFreeParserInputBuffer(buf);
10760	return(NULL);
10761	}
10762
10763	if (filename == NULL)
10764	inputStream->filename = NULL;
10765	else {
10766	inputStream->filename = (char *)
10767	xmlCanonicPath((const xmlChar *) filename);
10768	if (inputStream->filename == NULL) {
10769	xmlFreeParserCtxt(ctxt);
10770	xmlFreeParserInputBuffer(buf);
10771	return(NULL);
10772	}
10773	}
10774	inputStream->buf = buf;
10775	inputStream->base = inputStream->buf->buffer->content;
10776	inputStream->cur = inputStream->buf->buffer->content;
10777	inputStream->end =
10778	&inputStream->buf->buffer->content[inputStream->buf->buffer->use];
10779
10780	inputPush(ctxt, inputStream);
10781
10782	/*
10783	* If the caller didn't provide an initial 'chunk' for determining
10784	* the encoding, we set the context to XML_CHAR_ENCODING_NONE so
10785	* that it can be automatically determined later
10786	*/
10787	if ((size == 0) \|\| (chunk == NULL)) {
10788	ctxt->charset = XML_CHAR_ENCODING_NONE;
10789	} else if ((ctxt->input != NULL) && (ctxt->input->buf != NULL)) {
10790	int base = ctxt->input->base - ctxt->input->buf->buffer->content;
10791	int cur = ctxt->input->cur - ctxt->input->base;
10792
10793	xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
10794
10795	ctxt->input->base = ctxt->input->buf->buffer->content + base;
10796	ctxt->input->cur = ctxt->input->base + cur;
10797	ctxt->input->end =
10798	&ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
10799	#ifdef DEBUG_PUSH
10800	xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
10801	#endif
10802	}
10803
10804	if (enc != XML_CHAR_ENCODING_NONE) {
10805	xmlSwitchEncoding(ctxt, enc);
10806	}
10807
10808	return(ctxt);
10809	}
10810	#endif /* LIBXML_PUSH_ENABLED */
10811
10812	/**
10813	* xmlStopParser:
10814	* @ctxt: an XML parser context
10815	*
10816	* Blocks further parser processing
10817	*/
10818	void
10819	xmlStopParser(xmlParserCtxtPtr ctxt) {
10820	if (ctxt == NULL)
10821	return;
10822	ctxt->instate = XML_PARSER_EOF;
10823	ctxt->disableSAX = 1;
10824	if (ctxt->input != NULL) {
10825	ctxt->input->cur = BAD_CAST"";
10826	ctxt->input->base = ctxt->input->cur;
10827	}
10828	}
10829
10830	/**
10831	* xmlCreateIOParserCtxt:
10832	* @sax: a SAX handler
10833	* @user_data: The user data returned on SAX callbacks
10834	* @ioread: an I/O read function
10835	* @ioclose: an I/O close function
10836	* @ioctx: an I/O handler
10837	* @enc: the charset encoding if known
10838	*
10839	* Create a parser context for using the XML parser with an existing
10840	* I/O stream
10841	*
10842	* Returns the new parser context or NULL
10843	*/
10844	xmlParserCtxtPtr
10845	xmlCreateIOParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
10846	xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
10847	void *ioctx, xmlCharEncoding enc) {
10848	xmlParserCtxtPtr ctxt;
10849	xmlParserInputPtr inputStream;
10850	xmlParserInputBufferPtr buf;
10851
10852	if (ioread == NULL) return(NULL);
10853
10854	buf = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, enc);
10855	if (buf == NULL) return(NULL);
10856
10857	ctxt = xmlNewParserCtxt();
10858	if (ctxt == NULL) {
10859	xmlFreeParserInputBuffer(buf);
10860	return(NULL);
10861	}
10862	if (sax != NULL) {
10863	#ifdef LIBXML_SAX1_ENABLED
10864	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
10865	#endif /* LIBXML_SAX1_ENABLED */
10866	xmlFree(ctxt->sax);
10867	ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
10868	if (ctxt->sax == NULL) {
10869	xmlErrMemory(ctxt, NULL);
10870	xmlFreeParserCtxt(ctxt);
10871	return(NULL);
10872	}
10873	memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
10874	if (sax->initialized == XML_SAX2_MAGIC)
10875	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
10876	else
10877	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
10878	if (user_data != NULL)
10879	ctxt->userData = user_data;
10880	}
10881
10882	inputStream = xmlNewIOInputStream(ctxt, buf, enc);
10883	if (inputStream == NULL) {
10884	xmlFreeParserCtxt(ctxt);
10885	return(NULL);
10886	}
10887	inputPush(ctxt, inputStream);
10888
10889	return(ctxt);
10890	}
10891
10892	#ifdef LIBXML_VALID_ENABLED
10893	/************************************************************************
10894	* *
10895	* Front ends when parsing a DTD *
10896	* *
10897	************************************************************************/
10898
10899	/**
10900	* xmlIOParseDTD:
10901	* @sax: the SAX handler block or NULL
10902	* @input: an Input Buffer
10903	* @enc: the charset encoding if known
10904	*
10905	* Load and parse a DTD
10906	*
10907	* Returns the resulting xmlDtdPtr or NULL in case of error.
10908	* @input will be freed by the function in any case.
10909	*/
10910
10911	xmlDtdPtr
10912	xmlIOParseDTD(xmlSAXHandlerPtr sax, xmlParserInputBufferPtr input,
10913	xmlCharEncoding enc) {
10914	xmlDtdPtr ret = NULL;
10915	xmlParserCtxtPtr ctxt;
10916	xmlParserInputPtr pinput = NULL;
10917	xmlChar start[4];
10918
10919	if (input == NULL)
10920	return(NULL);
10921
10922	ctxt = xmlNewParserCtxt();
10923	if (ctxt == NULL) {
10924	xmlFreeParserInputBuffer(input);
10925	return(NULL);
10926	}
10927
10928	/*
10929	* Set-up the SAX context
10930	*/
10931	if (sax != NULL) {
10932	if (ctxt->sax != NULL)
10933	xmlFree(ctxt->sax);
10934	ctxt->sax = sax;
10935	ctxt->userData = ctxt;
10936	}
10937	xmlDetectSAX2(ctxt);
10938
10939	/*
10940	* generate a parser input from the I/O handler
10941	*/
10942
10943	pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
10944	if (pinput == NULL) {
10945	if (sax != NULL) ctxt->sax = NULL;
10946	xmlFreeParserInputBuffer(input);
10947	xmlFreeParserCtxt(ctxt);
10948	return(NULL);
10949	}
10950
10951	/*
10952	* plug some encoding conversion routines here.
10953	*/
10954	xmlPushInput(ctxt, pinput);
10955	if (enc != XML_CHAR_ENCODING_NONE) {
10956	xmlSwitchEncoding(ctxt, enc);
10957	}
10958
10959	pinput->filename = NULL;
10960	pinput->line = 1;
10961	pinput->col = 1;
10962	pinput->base = ctxt->input->cur;
10963	pinput->cur = ctxt->input->cur;
10964	pinput->free = NULL;
10965
10966	/*
10967	* let's parse that entity knowing it's an external subset.
10968	*/
10969	ctxt->inSubset = 2;
10970	ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
10971	ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
10972	BAD_CAST "none", BAD_CAST "none");
10973
10974	if ((enc == XML_CHAR_ENCODING_NONE) &&
10975	((ctxt->input->end - ctxt->input->cur) >= 4)) {
10976	/*
10977	* Get the 4 first bytes and decode the charset
10978	* if enc != XML_CHAR_ENCODING_NONE
10979	* plug some encoding conversion routines.
10980	*/
10981	start[0] = RAW;
10982	start[1] = NXT(1);
10983	start[2] = NXT(2);
10984	start[3] = NXT(3);
10985	enc = xmlDetectCharEncoding(start, 4);
10986	if (enc != XML_CHAR_ENCODING_NONE) {
10987	xmlSwitchEncoding(ctxt, enc);
10988	}
10989	}
10990
10991	xmlParseExternalSubset(ctxt, BAD_CAST "none", BAD_CAST "none");
10992
10993	if (ctxt->myDoc != NULL) {
10994	if (ctxt->wellFormed) {
10995	ret = ctxt->myDoc->extSubset;
10996	ctxt->myDoc->extSubset = NULL;
10997	if (ret != NULL) {
10998	xmlNodePtr tmp;
10999
11000	ret->doc = NULL;
11001	tmp = ret->children;
11002	while (tmp != NULL) {
11003	tmp->doc = NULL;
11004	tmp = tmp->next;
11005	}
11006	}
11007	} else {
11008	ret = NULL;
11009	}
11010	xmlFreeDoc(ctxt->myDoc);
11011	ctxt->myDoc = NULL;
11012	}
11013	if (sax != NULL) ctxt->sax = NULL;
11014	xmlFreeParserCtxt(ctxt);
11015
11016	return(ret);
11017	}
11018
11019	/**
11020	* xmlSAXParseDTD:
11021	* @sax: the SAX handler block
11022	* @ExternalID: a NAME* containing the External ID of the DTD
11023	* @SystemID: a NAME* containing the URL to the DTD
11024	*
11025	* Load and parse an external subset.
11026	*
11027	* Returns the resulting xmlDtdPtr or NULL in case of error.
11028	*/
11029
11030	xmlDtdPtr
11031	xmlSAXParseDTD(xmlSAXHandlerPtr sax, const xmlChar *ExternalID,
11032	const xmlChar *SystemID) {
11033	xmlDtdPtr ret = NULL;
11034	xmlParserCtxtPtr ctxt;
11035	xmlParserInputPtr input = NULL;
11036	xmlCharEncoding enc;
11037	xmlChar* systemIdCanonic;
11038
11039	if ((ExternalID == NULL) && (SystemID == NULL)) return(NULL);
11040
11041	ctxt = xmlNewParserCtxt();
11042	if (ctxt == NULL) {
11043	return(NULL);
11044	}
11045
11046	/*
11047	* Set-up the SAX context
11048	*/
11049	if (sax != NULL) {
11050	if (ctxt->sax != NULL)
11051	xmlFree(ctxt->sax);
11052	ctxt->sax = sax;
11053	ctxt->userData = ctxt;
11054	}
11055
11056	/*
11057	* Canonicalise the system ID
11058	*/
11059	systemIdCanonic = xmlCanonicPath(SystemID);
11060	if ((SystemID != NULL) && (systemIdCanonic == NULL)) {
11061	xmlFreeParserCtxt(ctxt);
11062	return(NULL);
11063	}
11064
11065	/*
11066	* Ask the Entity resolver to load the damn thing
11067	*/
11068
11069	if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
11070	input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
11071	systemIdCanonic);
11072	if (input == NULL) {
11073	if (sax != NULL) ctxt->sax = NULL;
11074	xmlFreeParserCtxt(ctxt);
11075	if (systemIdCanonic != NULL)
11076	xmlFree(systemIdCanonic);
11077	return(NULL);
11078	}
11079
11080	/*
11081	* plug some encoding conversion routines here.
11082	*/
11083	xmlPushInput(ctxt, input);
11084	if ((ctxt->input->end - ctxt->input->cur) >= 4) {
11085	enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
11086	xmlSwitchEncoding(ctxt, enc);
11087	}
11088
11089	if (input->filename == NULL)
11090	input->filename = (char *) systemIdCanonic;
11091	else
11092	xmlFree(systemIdCanonic);
11093	input->line = 1;
11094	input->col = 1;
11095	input->base = ctxt->input->cur;
11096	input->cur = ctxt->input->cur;
11097	input->free = NULL;
11098
11099	/*
11100	* let's parse that entity knowing it's an external subset.
11101	*/
11102	ctxt->inSubset = 2;
11103	ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
11104	ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
11105	ExternalID, SystemID);
11106	xmlParseExternalSubset(ctxt, ExternalID, SystemID);
11107
11108	if (ctxt->myDoc != NULL) {
11109	if (ctxt->wellFormed) {
11110	ret = ctxt->myDoc->extSubset;
11111	ctxt->myDoc->extSubset = NULL;
11112	if (ret != NULL) {
11113	xmlNodePtr tmp;
11114
11115	ret->doc = NULL;
11116	tmp = ret->children;
11117	while (tmp != NULL) {
11118	tmp->doc = NULL;
11119	tmp = tmp->next;
11120	}
11121	}
11122	} else {
11123	ret = NULL;
11124	}
11125	xmlFreeDoc(ctxt->myDoc);
11126	ctxt->myDoc = NULL;
11127	}
11128	if (sax != NULL) ctxt->sax = NULL;
11129	xmlFreeParserCtxt(ctxt);
11130
11131	return(ret);
11132	}
11133
11134
11135	/**
11136	* xmlParseDTD:
11137	* @ExternalID: a NAME* containing the External ID of the DTD
11138	* @SystemID: a NAME* containing the URL to the DTD
11139	*
11140	* Load and parse an external subset.
11141	*
11142	* Returns the resulting xmlDtdPtr or NULL in case of error.
11143	*/
11144
11145	xmlDtdPtr
11146	xmlParseDTD(const xmlChar ExternalID, const xmlChar SystemID) {
11147	return(xmlSAXParseDTD(NULL, ExternalID, SystemID));
11148	}
11149	#endif /* LIBXML_VALID_ENABLED */
11150
11151	/************************************************************************
11152	* *
11153	* Front ends when parsing an Entity *
11154	* *
11155	************************************************************************/
11156
11157	/**
11158	* xmlParseCtxtExternalEntity:
11159	* @ctx: the existing parsing context
11160	* @URL: the URL for the entity to load
11161	* @ID: the System ID for the entity to load
11162	* @lst: the return value for the set of parsed nodes
11163	*
11164	* Parse an external general entity within an existing parsing context
11165	* An external general parsed entity is well-formed if it matches the
11166	* production labeled extParsedEnt.
11167	*
11168	* [78] extParsedEnt ::= TextDecl? content
11169	*
11170	* Returns 0 if the entity is well formed, -1 in case of args problem and
11171	* the parser error code otherwise
11172	*/
11173
11174	int
11175	xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, const xmlChar *URL,
11176	const xmlChar ID, xmlNodePtr lst) {
11177	xmlParserCtxtPtr ctxt;
11178	xmlDocPtr newDoc;
11179	xmlNodePtr newRoot;
11180	xmlSAXHandlerPtr oldsax = NULL;
11181	int ret = 0;
11182	xmlChar start[4];
11183	xmlCharEncoding enc;
11184	xmlParserInputPtr inputStream;
11185	char *directory = NULL;
11186
11187	if (ctx == NULL) return(-1);
11188
11189	if ((ctx->depth > 40) \|\| (ctx->nbentities >= 500000)) {
11190	return(XML_ERR_ENTITY_LOOP);
11191	}
11192
11193	if (lst != NULL)
11194	*lst = NULL;
11195	if ((URL == NULL) && (ID == NULL))
11196	return(-1);
11197	if (ctx->myDoc == NULL) /* @@ relax but check for dereferences */
11198	return(-1);
11199
11200	ctxt = xmlNewParserCtxt();
11201	if (ctxt == NULL) {
11202	return(-1);
11203	}
11204
11205	ctxt->userData = ctxt;
11206	ctxt->_private = ctx->_private;
11207
11208	inputStream = xmlLoadExternalEntity((char )URL, (char )ID, ctxt);
11209	if (inputStream == NULL) {
11210	xmlFreeParserCtxt(ctxt);
11211	return(-1);
11212	}
11213
11214	inputPush(ctxt, inputStream);
11215
11216	if ((ctxt->directory == NULL) && (directory == NULL))
11217	directory = xmlParserGetDirectory((char *)URL);
11218	if ((ctxt->directory == NULL) && (directory != NULL))
11219	ctxt->directory = directory;
11220
11221	oldsax = ctxt->sax;
11222	ctxt->sax = ctx->sax;
11223	xmlDetectSAX2(ctxt);
11224	newDoc = xmlNewDoc(BAD_CAST "1.0");
11225	if (newDoc == NULL) {
11226	xmlFreeParserCtxt(ctxt);
11227	return(-1);
11228	}
11229	if (ctx->myDoc->dict) {
11230	newDoc->dict = ctx->myDoc->dict;
11231	xmlDictReference(newDoc->dict);
11232	}
11233	if (ctx->myDoc != NULL) {
11234	newDoc->intSubset = ctx->myDoc->intSubset;
11235	newDoc->extSubset = ctx->myDoc->extSubset;
11236	}
11237	if (ctx->myDoc->URL != NULL) {
11238	newDoc->URL = xmlStrdup(ctx->myDoc->URL);
11239	}
11240	newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
11241	if (newRoot == NULL) {
11242	ctxt->sax = oldsax;
11243	xmlFreeParserCtxt(ctxt);
11244	newDoc->intSubset = NULL;
11245	newDoc->extSubset = NULL;
11246	xmlFreeDoc(newDoc);
11247	return(-1);
11248	}
11249	xmlAddChild((xmlNodePtr) newDoc, newRoot);
11250	nodePush(ctxt, newDoc->children);
11251	if (ctx->myDoc == NULL) {
11252	ctxt->myDoc = newDoc;
11253	} else {
11254	ctxt->myDoc = ctx->myDoc;
11255	newDoc->children->doc = ctx->myDoc;
11256	}
11257
11258	/*
11259	* Get the 4 first bytes and decode the charset
11260	* if enc != XML_CHAR_ENCODING_NONE
11261	* plug some encoding conversion routines.
11262	*/
11263	GROW
11264	if ((ctxt->input->end - ctxt->input->cur) >= 4) {
11265	start[0] = RAW;
11266	start[1] = NXT(1);
11267	start[2] = NXT(2);
11268	start[3] = NXT(3);
11269	enc = xmlDetectCharEncoding(start, 4);
11270	if (enc != XML_CHAR_ENCODING_NONE) {
11271	xmlSwitchEncoding(ctxt, enc);
11272	}
11273	}
11274
11275	/*
11276	* Parse a possible text declaration first
11277	*/
11278	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
11279	xmlParseTextDecl(ctxt);
11280	}
11281
11282	/*
11283	* Doing validity checking on chunk doesn't make sense
11284	*/
11285	ctxt->instate = XML_PARSER_CONTENT;
11286	ctxt->validate = ctx->validate;
11287	ctxt->valid = ctx->valid;
11288	ctxt->loadsubset = ctx->loadsubset;
11289	ctxt->depth = ctx->depth + 1;
11290	ctxt->replaceEntities = ctx->replaceEntities;
11291	if (ctxt->validate) {
11292	ctxt->vctxt.error = ctx->vctxt.error;
11293	ctxt->vctxt.warning = ctx->vctxt.warning;
11294	} else {
11295	ctxt->vctxt.error = NULL;
11296	ctxt->vctxt.warning = NULL;
11297	}
11298	ctxt->vctxt.nodeTab = NULL;
11299	ctxt->vctxt.nodeNr = 0;
11300	ctxt->vctxt.nodeMax = 0;
11301	ctxt->vctxt.node = NULL;
11302	if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
11303	ctxt->dict = ctx->dict;
11304	ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
11305	ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
11306	ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
11307	ctxt->dictNames = ctx->dictNames;
11308	ctxt->attsDefault = ctx->attsDefault;
11309	ctxt->attsSpecial = ctx->attsSpecial;
11310	ctxt->linenumbers = ctx->linenumbers;
11311
11312	xmlParseContent(ctxt);
11313
11314	ctx->validate = ctxt->validate;
11315	ctx->valid = ctxt->valid;
11316	if ((RAW == '<') && (NXT(1) == '/')) {
11317	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11318	} else if (RAW != 0) {
11319	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11320	}
11321	if (ctxt->node != newDoc->children) {
11322	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11323	}
11324
11325	if (!ctxt->wellFormed) {
11326	if (ctxt->errNo == 0)
11327	ret = 1;
11328	else
11329	ret = ctxt->errNo;
11330	} else {
11331	if (lst != NULL) {
11332	xmlNodePtr cur;
11333
11334	/*
11335	* Return the newly created nodeset after unlinking it from
11336	* they pseudo parent.
11337	*/
11338	cur = newDoc->children->children;
11339	*lst = cur;
11340	while (cur != NULL) {
11341	cur->parent = NULL;
11342	cur = cur->next;
11343	}
11344	newDoc->children->children = NULL;
11345	}
11346	ret = 0;
11347	}
11348	ctxt->sax = oldsax;
11349	ctxt->dict = NULL;
11350	ctxt->attsDefault = NULL;
11351	ctxt->attsSpecial = NULL;
11352	xmlFreeParserCtxt(ctxt);
11353	newDoc->intSubset = NULL;
11354	newDoc->extSubset = NULL;
11355	xmlFreeDoc(newDoc);
11356
11357	return(ret);
11358	}
11359
11360	/**
11361	* xmlParseExternalEntityPrivate:
11362	* @doc: the document the chunk pertains to
11363	* @oldctxt: the previous parser context if available
11364	* @sax: the SAX handler bloc (possibly NULL)
11365	* @user_data: The user data returned on SAX callbacks (possibly NULL)
11366	* @depth: Used for loop detection, use 0
11367	* @URL: the URL for the entity to load
11368	* @ID: the System ID for the entity to load
11369	* @list: the return value for the set of parsed nodes
11370	*
11371	* Private version of xmlParseExternalEntity()
11372	*
11373	* Returns 0 if the entity is well formed, -1 in case of args problem and
11374	* the parser error code otherwise
11375	*/
11376
11377	static xmlParserErrors
11378	xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
11379	xmlSAXHandlerPtr sax,
11380	void user_data, int depth, const xmlChar URL,
11381	const xmlChar ID, xmlNodePtr list) {
11382	xmlParserCtxtPtr ctxt;
11383	xmlDocPtr newDoc;
11384	xmlNodePtr newRoot;
11385	xmlSAXHandlerPtr oldsax = NULL;
11386	xmlParserErrors ret = XML_ERR_OK;
11387	xmlChar start[4];
11388	xmlCharEncoding enc;
11389
11390	if ((depth > 40) \|\|
11391	((oldctxt != NULL) && (oldctxt->nbentities >= 500000))) {
11392	return(XML_ERR_ENTITY_LOOP);
11393	}
11394
11395
11396
11397	if (list != NULL)
11398	*list = NULL;
11399	if ((URL == NULL) && (ID == NULL))
11400	return(XML_ERR_INTERNAL_ERROR);
11401	if (doc == NULL)
11402	return(XML_ERR_INTERNAL_ERROR);
11403
11404
11405	ctxt = xmlCreateEntityParserCtxt(URL, ID, NULL);
11406	if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
11407	ctxt->userData = ctxt;
11408	if (oldctxt != NULL) {
11409	ctxt->_private = oldctxt->_private;
11410	ctxt->loadsubset = oldctxt->loadsubset;
11411	ctxt->validate = oldctxt->validate;
11412	ctxt->external = oldctxt->external;
11413	ctxt->record_info = oldctxt->record_info;
11414	ctxt->node_seq.maximum = oldctxt->node_seq.maximum;
11415	ctxt->node_seq.length = oldctxt->node_seq.length;
11416	ctxt->node_seq.buffer = oldctxt->node_seq.buffer;
11417	} else {
11418	/*
11419	* Doing validity checking on chunk without context
11420	* doesn't make sense
11421	*/
11422	ctxt->_private = NULL;
11423	ctxt->validate = 0;
11424	ctxt->external = 2;
11425	ctxt->loadsubset = 0;
11426	}
11427	if (sax != NULL) {
11428	oldsax = ctxt->sax;
11429	ctxt->sax = sax;
11430	if (user_data != NULL)
11431	ctxt->userData = user_data;
11432	}
11433	xmlDetectSAX2(ctxt);
11434	newDoc = xmlNewDoc(BAD_CAST "1.0");
11435	if (newDoc == NULL) {
11436	ctxt->node_seq.maximum = 0;
11437	ctxt->node_seq.length = 0;
11438	ctxt->node_seq.buffer = NULL;
11439	xmlFreeParserCtxt(ctxt);
11440	return(XML_ERR_INTERNAL_ERROR);
11441	}
11442	newDoc->intSubset = doc->intSubset;
11443	newDoc->extSubset = doc->extSubset;
11444	newDoc->dict = doc->dict;
11445	xmlDictReference(newDoc->dict);
11446
11447	if (doc->URL != NULL) {
11448	newDoc->URL = xmlStrdup(doc->URL);
11449	}
11450	newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
11451	if (newRoot == NULL) {
11452	if (sax != NULL)
11453	ctxt->sax = oldsax;
11454	ctxt->node_seq.maximum = 0;
11455	ctxt->node_seq.length = 0;
11456	ctxt->node_seq.buffer = NULL;
11457	xmlFreeParserCtxt(ctxt);
11458	newDoc->intSubset = NULL;
11459	newDoc->extSubset = NULL;
11460	xmlFreeDoc(newDoc);
11461	return(XML_ERR_INTERNAL_ERROR);
11462	}
11463	xmlAddChild((xmlNodePtr) newDoc, newRoot);
11464	nodePush(ctxt, newDoc->children);
11465	ctxt->myDoc = doc;
11466	newRoot->doc = doc;
11467
11468	/*
11469	* Get the 4 first bytes and decode the charset
11470	* if enc != XML_CHAR_ENCODING_NONE
11471	* plug some encoding conversion routines.
11472	*/
11473	GROW;
11474	if ((ctxt->input->end - ctxt->input->cur) >= 4) {
11475	start[0] = RAW;
11476	start[1] = NXT(1);
11477	start[2] = NXT(2);
11478	start[3] = NXT(3);
11479	enc = xmlDetectCharEncoding(start, 4);
11480	if (enc != XML_CHAR_ENCODING_NONE) {
11481	xmlSwitchEncoding(ctxt, enc);
11482	}
11483	}
11484
11485	/*
11486	* Parse a possible text declaration first
11487	*/
11488	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
11489	xmlParseTextDecl(ctxt);
11490	}
11491
11492	ctxt->instate = XML_PARSER_CONTENT;
11493	ctxt->depth = depth;
11494
11495	xmlParseContent(ctxt);
11496
11497	if ((RAW == '<') && (NXT(1) == '/')) {
11498	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11499	} else if (RAW != 0) {
11500	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11501	}
11502	if (ctxt->node != newDoc->children) {
11503	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11504	}
11505
11506	if (!ctxt->wellFormed) {
11507	if (ctxt->errNo == 0)
11508	ret = XML_ERR_INTERNAL_ERROR;
11509	else
11510	ret = (xmlParserErrors)ctxt->errNo;
11511	} else {
11512	if (list != NULL) {
11513	xmlNodePtr cur;
11514
11515	/*
11516	* Return the newly created nodeset after unlinking it from
11517	* they pseudo parent.
11518	*/
11519	cur = newDoc->children->children;
11520	*list = cur;
11521	while (cur != NULL) {
11522	cur->parent = NULL;
11523	cur = cur->next;
11524	}
11525	newDoc->children->children = NULL;
11526	}
11527	ret = XML_ERR_OK;
11528	}
11529	if (sax != NULL)
11530	ctxt->sax = oldsax;
11531	oldctxt->node_seq.maximum = ctxt->node_seq.maximum;
11532	oldctxt->node_seq.length = ctxt->node_seq.length;
11533	oldctxt->node_seq.buffer = ctxt->node_seq.buffer;
11534	oldctxt->nbentities += ctxt->nbentities;
11535	ctxt->node_seq.maximum = 0;
11536	ctxt->node_seq.length = 0;
11537	ctxt->node_seq.buffer = NULL;
11538	xmlFreeParserCtxt(ctxt);
11539	newDoc->intSubset = NULL;
11540	newDoc->extSubset = NULL;
11541	xmlFreeDoc(newDoc);
11542
11543	return(ret);
11544	}
11545
11546	#ifdef LIBXML_SAX1_ENABLED
11547	/**
11548	* xmlParseExternalEntity:
11549	* @doc: the document the chunk pertains to
11550	* @sax: the SAX handler bloc (possibly NULL)
11551	* @user_data: The user data returned on SAX callbacks (possibly NULL)
11552	* @depth: Used for loop detection, use 0
11553	* @URL: the URL for the entity to load
11554	* @ID: the System ID for the entity to load
11555	* @lst: the return value for the set of parsed nodes
11556	*
11557	* Parse an external general entity
11558	* An external general parsed entity is well-formed if it matches the
11559	* production labeled extParsedEnt.
11560	*
11561	* [78] extParsedEnt ::= TextDecl? content
11562	*
11563	* Returns 0 if the entity is well formed, -1 in case of args problem and
11564	* the parser error code otherwise
11565	*/
11566
11567	int
11568	xmlParseExternalEntity(xmlDocPtr doc, xmlSAXHandlerPtr sax, void *user_data,
11569	int depth, const xmlChar URL, const xmlChar ID, xmlNodePtr *lst) {
11570	return(xmlParseExternalEntityPrivate(doc, NULL, sax, user_data, depth, URL,
11571	ID, lst));
11572	}
11573
11574	/**
11575	* xmlParseBalancedChunkMemory:
11576	* @doc: the document the chunk pertains to
11577	* @sax: the SAX handler bloc (possibly NULL)
11578	* @user_data: The user data returned on SAX callbacks (possibly NULL)
11579	* @depth: Used for loop detection, use 0
11580	* @string: the input string in UTF8 or ISO-Latin (zero terminated)
11581	* @lst: the return value for the set of parsed nodes
11582	*
11583	* Parse a well-balanced chunk of an XML document
11584	* called by the parser
11585	* The allowed sequence for the Well Balanced Chunk is the one defined by
11586	* the content production in the XML grammar:
11587	*
11588	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
11589	*
11590	* Returns 0 if the chunk is well balanced, -1 in case of args problem and
11591	* the parser error code otherwise
11592	*/
11593
11594	int
11595	xmlParseBalancedChunkMemory(xmlDocPtr doc, xmlSAXHandlerPtr sax,
11596	void user_data, int depth, const xmlChar string, xmlNodePtr *lst) {
11597	return xmlParseBalancedChunkMemoryRecover( doc, sax, user_data,
11598	depth, string, lst, 0 );
11599	}
11600	#endif /* LIBXML_SAX1_ENABLED */
11601
11602	/**
11603	* xmlParseBalancedChunkMemoryInternal:
11604	* @oldctxt: the existing parsing context
11605	* @string: the input string in UTF8 or ISO-Latin (zero terminated)
11606	* @user_data: the user data field for the parser context
11607	* @lst: the return value for the set of parsed nodes
11608	*
11609	*
11610	* Parse a well-balanced chunk of an XML document
11611	* called by the parser
11612	* The allowed sequence for the Well Balanced Chunk is the one defined by
11613	* the content production in the XML grammar:
11614	*
11615	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
11616	*
11617	* Returns XML_ERR_OK if the chunk is well balanced, and the parser
11618	* error code otherwise
11619	*
11620	* In case recover is set to 1, the nodelist will not be empty even if
11621	* the parsed chunk is not well balanced.
11622	*/
11623	static xmlParserErrors
11624	xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
11625	const xmlChar string, void user_data, xmlNodePtr *lst) {
11626	xmlParserCtxtPtr ctxt;
11627	xmlDocPtr newDoc = NULL;
11628	xmlNodePtr newRoot;
11629	xmlSAXHandlerPtr oldsax = NULL;
11630	xmlNodePtr content = NULL;
11631	xmlNodePtr last = NULL;
11632	int size;
11633	xmlParserErrors ret = XML_ERR_OK;
11634
11635	if ((oldctxt->depth > 40) \|\| (oldctxt->nbentities >= 500000)) {
11636	return(XML_ERR_ENTITY_LOOP);
11637	}
11638
11639
11640	if (lst != NULL)
11641	*lst = NULL;
11642	if (string == NULL)
11643	return(XML_ERR_INTERNAL_ERROR);
11644
11645	size = xmlStrlen(string);
11646
11647	ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
11648	if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
11649	if (user_data != NULL)
11650	ctxt->userData = user_data;
11651	else
11652	ctxt->userData = ctxt;
11653	if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
11654	ctxt->dict = oldctxt->dict;
11655	ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
11656	ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
11657	ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
11658
11659	oldsax = ctxt->sax;
11660	ctxt->sax = oldctxt->sax;
11661	xmlDetectSAX2(ctxt);
11662	ctxt->replaceEntities = oldctxt->replaceEntities;
11663	ctxt->options = oldctxt->options;
11664
11665	ctxt->_private = oldctxt->_private;
11666	if (oldctxt->myDoc == NULL) {
11667	newDoc = xmlNewDoc(BAD_CAST "1.0");
11668	if (newDoc == NULL) {
11669	ctxt->sax = oldsax;
11670	ctxt->dict = NULL;
11671	xmlFreeParserCtxt(ctxt);
11672	return(XML_ERR_INTERNAL_ERROR);
11673	}
11674	newDoc->dict = ctxt->dict;
11675	xmlDictReference(newDoc->dict);
11676	ctxt->myDoc = newDoc;
11677	} else {
11678	ctxt->myDoc = oldctxt->myDoc;
11679	content = ctxt->myDoc->children;
11680	last = ctxt->myDoc->last;
11681	}
11682	newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL);
11683	if (newRoot == NULL) {
11684	ctxt->sax = oldsax;
11685	ctxt->dict = NULL;
11686	xmlFreeParserCtxt(ctxt);
11687	if (newDoc != NULL) {
11688	xmlFreeDoc(newDoc);
11689	}
11690	return(XML_ERR_INTERNAL_ERROR);
11691	}
11692	ctxt->myDoc->children = NULL;
11693	ctxt->myDoc->last = NULL;
11694	xmlAddChild((xmlNodePtr) ctxt->myDoc, newRoot);
11695	nodePush(ctxt, ctxt->myDoc->children);
11696	ctxt->instate = XML_PARSER_CONTENT;
11697	ctxt->depth = oldctxt->depth + 1;
11698
11699	ctxt->validate = 0;
11700	ctxt->loadsubset = oldctxt->loadsubset;
11701	if ((oldctxt->validate) \|\| (oldctxt->replaceEntities != 0)) {
11702	/*
11703	* ID/IDREF registration will be done in xmlValidateElement below
11704	*/
11705	ctxt->loadsubset \|= XML_SKIP_IDS;
11706	}
11707	ctxt->dictNames = oldctxt->dictNames;
11708	ctxt->attsDefault = oldctxt->attsDefault;
11709	ctxt->attsSpecial = oldctxt->attsSpecial;
11710
11711	xmlParseContent(ctxt);
11712	if ((RAW == '<') && (NXT(1) == '/')) {
11713	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11714	} else if (RAW != 0) {
11715	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11716	}
11717	if (ctxt->node != ctxt->myDoc->children) {
11718	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11719	}
11720
11721	if (!ctxt->wellFormed) {
11722	if (ctxt->errNo == 0)
11723	ret = XML_ERR_INTERNAL_ERROR;
11724	else
11725	ret = (xmlParserErrors)ctxt->errNo;
11726	} else {
11727	ret = XML_ERR_OK;
11728	}
11729
11730	if ((lst != NULL) && (ret == XML_ERR_OK)) {
11731	xmlNodePtr cur;
11732
11733	/*
11734	* Return the newly created nodeset after unlinking it from
11735	* they pseudo parent.
11736	*/
11737	cur = ctxt->myDoc->children->children;
11738	*lst = cur;
11739	while (cur != NULL) {
11740	#ifdef LIBXML_VALID_ENABLED
11741	if ((oldctxt->validate) && (oldctxt->wellFormed) &&
11742	(oldctxt->myDoc) && (oldctxt->myDoc->intSubset) &&
11743	(cur->type == XML_ELEMENT_NODE)) {
11744	oldctxt->valid &= xmlValidateElement(&oldctxt->vctxt,
11745	oldctxt->myDoc, cur);
11746	}
11747	#endif /* LIBXML_VALID_ENABLED */
11748	cur->parent = NULL;
11749	cur = cur->next;
11750	}
11751	ctxt->myDoc->children->children = NULL;
11752	}
11753	if (ctxt->myDoc != NULL) {
11754	xmlFreeNode(ctxt->myDoc->children);
11755	ctxt->myDoc->children = content;
11756	ctxt->myDoc->last = last;
11757	}
11758
11759	oldctxt->nbentities += ctxt->nbentities;
11760	ctxt->sax = oldsax;
11761	ctxt->dict = NULL;
11762	ctxt->attsDefault = NULL;
11763	ctxt->attsSpecial = NULL;
11764	xmlFreeParserCtxt(ctxt);
11765	if (newDoc != NULL) {
11766	xmlFreeDoc(newDoc);
11767	}
11768
11769	return(ret);
11770	}
11771
11772	/**
11773	* xmlParseInNodeContext:
11774	* @node: the context node
11775	* @data: the input string
11776	* @datalen: the input string length in bytes
11777	* @options: a combination of xmlParserOption
11778	* @lst: the return value for the set of parsed nodes
11779	*
11780	* Parse a well-balanced chunk of an XML document
11781	* within the context (DTD, namespaces, etc ...) of the given node.
11782	*
11783	* The allowed sequence for the data is a Well Balanced Chunk defined by
11784	* the content production in the XML grammar:
11785	*
11786	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
11787	*
11788	* Returns XML_ERR_OK if the chunk is well balanced, and the parser
11789	* error code otherwise
11790	*/
11791	xmlParserErrors
11792	xmlParseInNodeContext(xmlNodePtr node, const char *data, int datalen,
11793	int options, xmlNodePtr *lst) {
11794	#ifdef SAX2
11795	xmlParserCtxtPtr ctxt;
11796	xmlDocPtr doc = NULL;
11797	xmlNodePtr fake, cur;
11798	int nsnr = 0;
11799
11800	xmlParserErrors ret = XML_ERR_OK;
11801
11802	/*
11803	* check all input parameters, grab the document
11804	*/
11805	if ((lst == NULL) \|\| (node == NULL) \|\| (data == NULL) \|\| (datalen < 0))
11806	return(XML_ERR_INTERNAL_ERROR);
11807	switch (node->type) {
11808	case XML_ELEMENT_NODE:
11809	case XML_ATTRIBUTE_NODE:
11810	case XML_TEXT_NODE:
11811	case XML_CDATA_SECTION_NODE:
11812	case XML_ENTITY_REF_NODE:
11813	case XML_PI_NODE:
11814	case XML_COMMENT_NODE:
11815	case XML_DOCUMENT_NODE:
11816	case XML_HTML_DOCUMENT_NODE:
11817	break;
11818	default:
11819	return(XML_ERR_INTERNAL_ERROR);
11820
11821	}
11822	while ((node != NULL) && (node->type != XML_ELEMENT_NODE) &&
11823	(node->type != XML_DOCUMENT_NODE) &&
11824	(node->type != XML_HTML_DOCUMENT_NODE))
11825	node = node->parent;
11826	if (node == NULL)
11827	return(XML_ERR_INTERNAL_ERROR);
11828	if (node->type == XML_ELEMENT_NODE)
11829	doc = node->doc;
11830	else
11831	doc = (xmlDocPtr) node;
11832	if (doc == NULL)
11833	return(XML_ERR_INTERNAL_ERROR);
11834
11835	/*
11836	* allocate a context and set-up everything not related to the
11837	* node position in the tree
11838	*/
11839	if (doc->type == XML_DOCUMENT_NODE)
11840	ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen);
11841	#ifdef LIBXML_HTML_ENABLED
11842	else if (doc->type == XML_HTML_DOCUMENT_NODE)
11843	ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen);
11844	#endif
11845	else
11846	return(XML_ERR_INTERNAL_ERROR);
11847
11848	if (ctxt == NULL)
11849	return(XML_ERR_NO_MEMORY);
11850	fake = xmlNewComment(NULL);
11851	if (fake == NULL) {
11852	xmlFreeParserCtxt(ctxt);
11853	return(XML_ERR_NO_MEMORY);
11854	}
11855	xmlAddChild(node, fake);
11856
11857	/*
11858	* Use input doc's dict if present, else assure XML_PARSE_NODICT is set.
11859	* We need a dictionary for xmlDetectSAX2, so if there's no doc dict
11860	* we must wait until the last moment to free the original one.
11861	*/
11862	if (doc->dict != NULL) {
11863	if (ctxt->dict != NULL)
11864	xmlDictFree(ctxt->dict);
11865	ctxt->dict = doc->dict;
11866	} else
11867	options \|= XML_PARSE_NODICT;
11868
11869	xmlCtxtUseOptions(ctxt, options);
11870	xmlDetectSAX2(ctxt);
11871	ctxt->myDoc = doc;
11872
11873	if (node->type == XML_ELEMENT_NODE) {
11874	nodePush(ctxt, node);
11875	/*
11876	* initialize the SAX2 namespaces stack
11877	*/
11878	cur = node;
11879	while ((cur != NULL) && (cur->type == XML_ELEMENT_NODE)) {
11880	xmlNsPtr ns = cur->nsDef;
11881	const xmlChar iprefix, ihref;
11882
11883	while (ns != NULL) {
11884	if (ctxt->dict) {
11885	iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1);
11886	ihref = xmlDictLookup(ctxt->dict, ns->href, -1);
11887	} else {
11888	iprefix = ns->prefix;
11889	ihref = ns->href;
11890	}
11891
11892	if (xmlGetNamespace(ctxt, iprefix) == NULL) {
11893	nsPush(ctxt, iprefix, ihref);
11894	nsnr++;
11895	}
11896	ns = ns->next;
11897	}
11898	cur = cur->parent;
11899	}
11900	ctxt->instate = XML_PARSER_CONTENT;
11901	}
11902
11903	if ((ctxt->validate) \|\| (ctxt->replaceEntities != 0)) {
11904	/*
11905	* ID/IDREF registration will be done in xmlValidateElement below
11906	*/
11907	ctxt->loadsubset \|= XML_SKIP_IDS;
11908	}
11909
11910	#ifdef LIBXML_HTML_ENABLED
11911	if (doc->type == XML_HTML_DOCUMENT_NODE)
11912	__htmlParseContent(ctxt);
11913	else
11914	#endif
11915	xmlParseContent(ctxt);
11916
11917	nsPop(ctxt, nsnr);
11918	if ((RAW == '<') && (NXT(1) == '/')) {
11919	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11920	} else if (RAW != 0) {
11921	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11922	}
11923	if ((ctxt->node != NULL) && (ctxt->node != node)) {
11924	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11925	ctxt->wellFormed = 0;
11926	}
11927
11928	if (!ctxt->wellFormed) {
11929	if (ctxt->errNo == 0)
11930	ret = XML_ERR_INTERNAL_ERROR;
11931	else
11932	ret = (xmlParserErrors)ctxt->errNo;
11933	} else {
11934	ret = XML_ERR_OK;
11935	}
11936
11937	/*
11938	* Return the newly created nodeset after unlinking it from
11939	* the pseudo sibling.
11940	*/
11941
11942	cur = fake->next;
11943	fake->next = NULL;
11944	node->last = fake;
11945
11946	if (cur != NULL) {
11947	cur->prev = NULL;
11948	}
11949
11950	*lst = cur;
11951
11952	while (cur != NULL) {
11953	cur->parent = NULL;
11954	cur = cur->next;
11955	}
11956
11957	xmlUnlinkNode(fake);
11958	xmlFreeNode(fake);
11959
11960
11961	if (ret != XML_ERR_OK) {
11962	xmlFreeNodeList(*lst);
11963	*lst = NULL;
11964	}
11965
11966	if (doc->dict != NULL)
11967	ctxt->dict = NULL;
11968	xmlFreeParserCtxt(ctxt);
11969
11970	return(ret);
11971	#else /* !SAX2 */
11972	return(XML_ERR_INTERNAL_ERROR);
11973	#endif
11974	}
11975
11976	#ifdef LIBXML_SAX1_ENABLED
11977	/**
11978	* xmlParseBalancedChunkMemoryRecover:
11979	* @doc: the document the chunk pertains to
11980	* @sax: the SAX handler bloc (possibly NULL)
11981	* @user_data: The user data returned on SAX callbacks (possibly NULL)
11982	* @depth: Used for loop detection, use 0
11983	* @string: the input string in UTF8 or ISO-Latin (zero terminated)
11984	* @lst: the return value for the set of parsed nodes
11985	* @recover: return nodes even if the data is broken (use 0)
11986	*
11987	*
11988	* Parse a well-balanced chunk of an XML document
11989	* called by the parser
11990	* The allowed sequence for the Well Balanced Chunk is the one defined by
11991	* the content production in the XML grammar:
11992	*
11993	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
11994	*
11995	* Returns 0 if the chunk is well balanced, -1 in case of args problem and
11996	* the parser error code otherwise
11997	*
11998	* In case recover is set to 1, the nodelist will not be empty even if
11999	* the parsed chunk is not well balanced.
12000	*/
12001	int
12002	xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, xmlSAXHandlerPtr sax,
12003	void user_data, int depth, const xmlChar string, xmlNodePtr *lst,
12004	int recover) {
12005	xmlParserCtxtPtr ctxt;
12006	xmlDocPtr newDoc;
12007	xmlSAXHandlerPtr oldsax = NULL;
12008	xmlNodePtr content, newRoot;
12009	int size;
12010	int ret = 0;
12011
12012	if (depth > 40) {
12013	return(XML_ERR_ENTITY_LOOP);
12014	}
12015
12016
12017	if (lst != NULL)
12018	*lst = NULL;
12019	if (string == NULL)
12020	return(-1);
12021
12022	size = xmlStrlen(string);
12023
12024	ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
12025	if (ctxt == NULL) return(-1);
12026	ctxt->userData = ctxt;
12027	if (sax != NULL) {
12028	oldsax = ctxt->sax;
12029	ctxt->sax = sax;
12030	if (user_data != NULL)
12031	ctxt->userData = user_data;
12032	}
12033	newDoc = xmlNewDoc(BAD_CAST "1.0");
12034	if (newDoc == NULL) {
12035	xmlFreeParserCtxt(ctxt);
12036	return(-1);
12037	}
12038	if ((doc != NULL) && (doc->dict != NULL)) {
12039	xmlDictFree(ctxt->dict);
12040	ctxt->dict = doc->dict;
12041	xmlDictReference(ctxt->dict);
12042	ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
12043	ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
12044	ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
12045	ctxt->dictNames = 1;
12046	} else {
12047	xmlCtxtUseOptions(ctxt, XML_PARSE_NODICT);
12048	}
12049	if (doc != NULL) {
12050	newDoc->intSubset = doc->intSubset;
12051	newDoc->extSubset = doc->extSubset;
12052	}
12053	newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
12054	if (newRoot == NULL) {
12055	if (sax != NULL)
12056	ctxt->sax = oldsax;
12057	xmlFreeParserCtxt(ctxt);
12058	newDoc->intSubset = NULL;
12059	newDoc->extSubset = NULL;
12060	xmlFreeDoc(newDoc);
12061	return(-1);
12062	}
12063	xmlAddChild((xmlNodePtr) newDoc, newRoot);
12064	nodePush(ctxt, newRoot);
12065	if (doc == NULL) {
12066	ctxt->myDoc = newDoc;
12067	} else {
12068	ctxt->myDoc = newDoc;
12069	newDoc->children->doc = doc;
12070	/* Ensure that doc has XML spec namespace */
12071	xmlSearchNsByHref(doc, (xmlNodePtr)doc, XML_XML_NAMESPACE);
12072	newDoc->oldNs = doc->oldNs;
12073	}
12074	ctxt->instate = XML_PARSER_CONTENT;
12075	ctxt->depth = depth;
12076
12077	/*
12078	* Doing validity checking on chunk doesn't make sense
12079	*/
12080	ctxt->validate = 0;
12081	ctxt->loadsubset = 0;
12082	xmlDetectSAX2(ctxt);
12083
12084	if ( doc != NULL ){
12085	content = doc->children;
12086	doc->children = NULL;
12087	xmlParseContent(ctxt);
12088	doc->children = content;
12089	}
12090	else {
12091	xmlParseContent(ctxt);
12092	}
12093	if ((RAW == '<') && (NXT(1) == '/')) {
12094	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12095	} else if (RAW != 0) {
12096	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
12097	}
12098	if (ctxt->node != newDoc->children) {
12099	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12100	}
12101
12102	if (!ctxt->wellFormed) {
12103	if (ctxt->errNo == 0)
12104	ret = 1;
12105	else
12106	ret = ctxt->errNo;
12107	} else {
12108	ret = 0;
12109	}
12110
12111	if ((lst != NULL) && ((ret == 0) \|\| (recover == 1))) {
12112	xmlNodePtr cur;
12113
12114	/*
12115	* Return the newly created nodeset after unlinking it from
12116	* they pseudo parent.
12117	*/
12118	cur = newDoc->children->children;
12119	*lst = cur;
12120	while (cur != NULL) {
12121	xmlSetTreeDoc(cur, doc);
12122	cur->parent = NULL;
12123	cur = cur->next;
12124	}
12125	newDoc->children->children = NULL;
12126	}
12127
12128	if (sax != NULL)
12129	ctxt->sax = oldsax;
12130	xmlFreeParserCtxt(ctxt);
12131	newDoc->intSubset = NULL;
12132	newDoc->extSubset = NULL;
12133	newDoc->oldNs = NULL;
12134	xmlFreeDoc(newDoc);
12135
12136	return(ret);
12137	}
12138
12139	/**
12140	* xmlSAXParseEntity:
12141	* @sax: the SAX handler block
12142	* @filename: the filename
12143	*
12144	* parse an XML external entity out of context and build a tree.
12145	* It use the given SAX function block to handle the parsing callback.
12146	* If sax is NULL, fallback to the default DOM tree building routines.
12147	*
12148	* [78] extParsedEnt ::= TextDecl? content
12149	*
12150	* This correspond to a "Well Balanced" chunk
12151	*
12152	* Returns the resulting document tree
12153	*/
12154
12155	xmlDocPtr
12156	xmlSAXParseEntity(xmlSAXHandlerPtr sax, const char *filename) {
12157	xmlDocPtr ret;
12158	xmlParserCtxtPtr ctxt;
12159
12160	ctxt = xmlCreateFileParserCtxt(filename);
12161	if (ctxt == NULL) {
12162	return(NULL);
12163	}
12164	if (sax != NULL) {
12165	if (ctxt->sax != NULL)
12166	xmlFree(ctxt->sax);
12167	ctxt->sax = sax;
12168	ctxt->userData = NULL;
12169	}
12170
12171	xmlParseExtParsedEnt(ctxt);
12172
12173	if (ctxt->wellFormed)
12174	ret = ctxt->myDoc;
12175	else {
12176	ret = NULL;
12177	xmlFreeDoc(ctxt->myDoc);
12178	ctxt->myDoc = NULL;
12179	}
12180	if (sax != NULL)
12181	ctxt->sax = NULL;
12182	xmlFreeParserCtxt(ctxt);
12183
12184	return(ret);
12185	}
12186
12187	/**
12188	* xmlParseEntity:
12189	* @filename: the filename
12190	*
12191	* parse an XML external entity out of context and build a tree.
12192	*
12193	* [78] extParsedEnt ::= TextDecl? content
12194	*
12195	* This correspond to a "Well Balanced" chunk
12196	*
12197	* Returns the resulting document tree
12198	*/
12199
12200	xmlDocPtr
12201	xmlParseEntity(const char *filename) {
12202	return(xmlSAXParseEntity(NULL, filename));
12203	}
12204	#endif /* LIBXML_SAX1_ENABLED */
12205
12206	/**
12207	* xmlCreateEntityParserCtxt:
12208	* @URL: the entity URL
12209	* @ID: the entity PUBLIC ID
12210	* @base: a possible base for the target URI
12211	*
12212	* Create a parser context for an external entity
12213	* Automatic support for ZLIB/Compress compressed document is provided
12214	* by default if found at compile-time.
12215	*
12216	* Returns the new parser context or NULL
12217	*/
12218	xmlParserCtxtPtr
12219	xmlCreateEntityParserCtxt(const xmlChar URL, const xmlChar ID,
12220	const xmlChar *base) {
12221	xmlParserCtxtPtr ctxt;
12222	xmlParserInputPtr inputStream;
12223	char *directory = NULL;
12224	xmlChar *uri;
12225
12226	ctxt = xmlNewParserCtxt();
12227	if (ctxt == NULL) {
12228	return(NULL);
12229	}
12230
12231	uri = xmlBuildURI(URL, base);
12232
12233	if (uri == NULL) {
12234	inputStream = xmlLoadExternalEntity((char )URL, (char )ID, ctxt);
12235	if (inputStream == NULL) {
12236	xmlFreeParserCtxt(ctxt);
12237	return(NULL);
12238	}
12239
12240	inputPush(ctxt, inputStream);
12241
12242	if ((ctxt->directory == NULL) && (directory == NULL))
12243	directory = xmlParserGetDirectory((char *)URL);
12244	if ((ctxt->directory == NULL) && (directory != NULL))
12245	ctxt->directory = directory;
12246	} else {
12247	inputStream = xmlLoadExternalEntity((char )uri, (char )ID, ctxt);
12248	if (inputStream == NULL) {
12249	xmlFree(uri);
12250	xmlFreeParserCtxt(ctxt);
12251	return(NULL);
12252	}
12253
12254	inputPush(ctxt, inputStream);
12255
12256	if ((ctxt->directory == NULL) && (directory == NULL))
12257	directory = xmlParserGetDirectory((char *)uri);
12258	if ((ctxt->directory == NULL) && (directory != NULL))
12259	ctxt->directory = directory;
12260	xmlFree(uri);
12261	}
12262	return(ctxt);
12263	}
12264
12265	/************************************************************************
12266	* *
12267	* Front ends when parsing from a file *
12268	* *
12269	************************************************************************/
12270
12271	/**
12272	* xmlCreateURLParserCtxt:
12273	* @filename: the filename or URL
12274	* @options: a combination of xmlParserOption
12275	*
12276	* Create a parser context for a file or URL content.
12277	* Automatic support for ZLIB/Compress compressed document is provided
12278	* by default if found at compile-time and for file accesses
12279	*
12280	* Returns the new parser context or NULL
12281	*/
12282	xmlParserCtxtPtr
12283	xmlCreateURLParserCtxt(const char *filename, int options)
12284	{
12285	xmlParserCtxtPtr ctxt;
12286	xmlParserInputPtr inputStream;
12287	char *directory = NULL;
12288
12289	ctxt = xmlNewParserCtxt();
12290	if (ctxt == NULL) {
12291	xmlErrMemory(NULL, "cannot allocate parser context");
12292	return(NULL);
12293	}
12294
12295	if (options)
12296	xmlCtxtUseOptions(ctxt, options);
12297	ctxt->linenumbers = 1;
12298
12299	inputStream = xmlLoadExternalEntity(filename, NULL, ctxt);
12300	if (inputStream == NULL) {
12301	xmlFreeParserCtxt(ctxt);
12302	return(NULL);
12303	}
12304
12305	inputPush(ctxt, inputStream);
12306	if ((ctxt->directory == NULL) && (directory == NULL))
12307	directory = xmlParserGetDirectory(filename);
12308	if ((ctxt->directory == NULL) && (directory != NULL))
12309	ctxt->directory = directory;
12310
12311	return(ctxt);
12312	}
12313
12314	/**
12315	* xmlCreateFileParserCtxt:
12316	* @filename: the filename
12317	*
12318	* Create a parser context for a file content.
12319	* Automatic support for ZLIB/Compress compressed document is provided
12320	* by default if found at compile-time.
12321	*
12322	* Returns the new parser context or NULL
12323	*/
12324	xmlParserCtxtPtr
12325	xmlCreateFileParserCtxt(const char *filename)
12326	{
12327	return(xmlCreateURLParserCtxt(filename, 0));
12328	}
12329
12330	#ifdef LIBXML_SAX1_ENABLED
12331	/**
12332	* xmlSAXParseFileWithData:
12333	* @sax: the SAX handler block
12334	* @filename: the filename
12335	* @recovery: work in recovery mode, i.e. tries to read no Well Formed
12336	* documents
12337	* @data: the userdata
12338	*
12339	* parse an XML file and build a tree. Automatic support for ZLIB/Compress
12340	* compressed document is provided by default if found at compile-time.
12341	* It use the given SAX function block to handle the parsing callback.
12342	* If sax is NULL, fallback to the default DOM tree building routines.
12343	*
12344	* User data (void *) is stored within the parser context in the
12345	* context's _private member, so it is available nearly everywhere in libxml
12346	*
12347	* Returns the resulting document tree
12348	*/
12349
12350	xmlDocPtr
12351	xmlSAXParseFileWithData(xmlSAXHandlerPtr sax, const char *filename,
12352	int recovery, void *data) {
12353	xmlDocPtr ret;
12354	xmlParserCtxtPtr ctxt;
12355	char *directory = NULL;
12356
12357	xmlInitParser();
12358
12359	ctxt = xmlCreateFileParserCtxt(filename);
12360	if (ctxt == NULL) {
12361	return(NULL);
12362	}
12363	if (sax != NULL) {
12364	if (ctxt->sax != NULL)
12365	xmlFree(ctxt->sax);
12366	ctxt->sax = sax;
12367	}
12368	xmlDetectSAX2(ctxt);
12369	if (data!=NULL) {
12370	ctxt->_private = data;
12371	}
12372
12373	if ((ctxt->directory == NULL) && (directory == NULL))
12374	directory = xmlParserGetDirectory(filename);
12375	if ((ctxt->directory == NULL) && (directory != NULL))
12376	ctxt->directory = (char ) xmlStrdup((xmlChar ) directory);
12377
12378	ctxt->recovery = recovery;
12379
12380	xmlParseDocument(ctxt);
12381
12382	if ((ctxt->wellFormed) \|\| recovery) {
12383	ret = ctxt->myDoc;
12384	if (ret != NULL) {
12385	if (ctxt->input->buf->compressed > 0)
12386	ret->compression = 9;
12387	else
12388	ret->compression = ctxt->input->buf->compressed;
12389	}
12390	}
12391	else {
12392	ret = NULL;
12393	xmlFreeDoc(ctxt->myDoc);
12394	ctxt->myDoc = NULL;
12395	}
12396	if (sax != NULL)
12397	ctxt->sax = NULL;
12398	xmlFreeParserCtxt(ctxt);
12399
12400	return(ret);
12401	}
12402
12403	/**
12404	* xmlSAXParseFile:
12405	* @sax: the SAX handler block
12406	* @filename: the filename
12407	* @recovery: work in recovery mode, i.e. tries to read no Well Formed
12408	* documents
12409	*
12410	* parse an XML file and build a tree. Automatic support for ZLIB/Compress
12411	* compressed document is provided by default if found at compile-time.
12412	* It use the given SAX function block to handle the parsing callback.
12413	* If sax is NULL, fallback to the default DOM tree building routines.
12414	*
12415	* Returns the resulting document tree
12416	*/
12417
12418	xmlDocPtr
12419	xmlSAXParseFile(xmlSAXHandlerPtr sax, const char *filename,
12420	int recovery) {
12421	return(xmlSAXParseFileWithData(sax,filename,recovery,NULL));
12422	}
12423
12424	/**
12425	* xmlRecoverDoc:
12426	* @cur: a pointer to an array of xmlChar
12427	*
12428	* parse an XML in-memory document and build a tree.
12429	* In the case the document is not Well Formed, a tree is built anyway
12430	*
12431	* Returns the resulting document tree
12432	*/
12433
12434	xmlDocPtr
12435	xmlRecoverDoc(xmlChar *cur) {
12436	return(xmlSAXParseDoc(NULL, cur, 1));
12437	}
12438
12439	/**
12440	* xmlParseFile:
12441	* @filename: the filename
12442	*
12443	* parse an XML file and build a tree. Automatic support for ZLIB/Compress
12444	* compressed document is provided by default if found at compile-time.
12445	*
12446	* Returns the resulting document tree if the file was wellformed,
12447	* NULL otherwise.
12448	*/
12449
12450	xmlDocPtr
12451	xmlParseFile(const char *filename) {
12452	return(xmlSAXParseFile(NULL, filename, 0));
12453	}
12454
12455	/**
12456	* xmlRecoverFile:
12457	* @filename: the filename
12458	*
12459	* parse an XML file and build a tree. Automatic support for ZLIB/Compress
12460	* compressed document is provided by default if found at compile-time.
12461	* In the case the document is not Well Formed, a tree is built anyway
12462	*
12463	* Returns the resulting document tree
12464	*/
12465
12466	xmlDocPtr
12467	xmlRecoverFile(const char *filename) {
12468	return(xmlSAXParseFile(NULL, filename, 1));
12469	}
12470
12471
12472	/**
12473	* xmlSetupParserForBuffer:
12474	* @ctxt: an XML parser context
12475	* @buffer: a xmlChar * buffer
12476	* @filename: a file name
12477	*
12478	* Setup the parser context to parse a new buffer; Clears any prior
12479	* contents from the parser context. The buffer parameter must not be
12480	* NULL, but the filename parameter can be
12481	*/
12482	void
12483	xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer,
12484	const char* filename)
12485	{
12486	xmlParserInputPtr input;
12487
12488	if ((ctxt == NULL) \|\| (buffer == NULL))
12489	return;
12490
12491	input = xmlNewInputStream(ctxt);
12492	if (input == NULL) {
12493	xmlErrMemory(NULL, "parsing new buffer: out of memory\n");
12494	xmlClearParserCtxt(ctxt);
12495	return;
12496	}
12497
12498	xmlClearParserCtxt(ctxt);
12499	if (filename != NULL)
12500	input->filename = (char ) xmlCanonicPath((const xmlChar )filename);
12501	input->base = buffer;
12502	input->cur = buffer;
12503	input->end = &buffer[xmlStrlen(buffer)];
12504	inputPush(ctxt, input);
12505	}
12506
12507	/**
12508	* xmlSAXUserParseFile:
12509	* @sax: a SAX handler
12510	* @user_data: The user data returned on SAX callbacks
12511	* @filename: a file name
12512	*
12513	* parse an XML file and call the given SAX handler routines.
12514	* Automatic support for ZLIB/Compress compressed document is provided
12515	*
12516	* Returns 0 in case of success or a error number otherwise
12517	*/
12518	int
12519	xmlSAXUserParseFile(xmlSAXHandlerPtr sax, void *user_data,
12520	const char *filename) {
12521	int ret = 0;
12522	xmlParserCtxtPtr ctxt;
12523
12524	ctxt = xmlCreateFileParserCtxt(filename);
12525	if (ctxt == NULL) return -1;
12526	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12527	xmlFree(ctxt->sax);
12528	ctxt->sax = sax;
12529	xmlDetectSAX2(ctxt);
12530
12531	if (user_data != NULL)
12532	ctxt->userData = user_data;
12533
12534	xmlParseDocument(ctxt);
12535
12536	if (ctxt->wellFormed)
12537	ret = 0;
12538	else {
12539	if (ctxt->errNo != 0)
12540	ret = ctxt->errNo;
12541	else
12542	ret = -1;
12543	}
12544	if (sax != NULL)
12545	ctxt->sax = NULL;
12546	if (ctxt->myDoc != NULL) {
12547	xmlFreeDoc(ctxt->myDoc);
12548	ctxt->myDoc = NULL;
12549	}
12550	xmlFreeParserCtxt(ctxt);
12551
12552	return ret;
12553	}
12554	#endif /* LIBXML_SAX1_ENABLED */
12555
12556	/************************************************************************
12557	* *
12558	* Front ends when parsing from memory *
12559	* *
12560	************************************************************************/
12561
12562	/**
12563	* xmlCreateMemoryParserCtxt:
12564	* @buffer: a pointer to a char array
12565	* @size: the size of the array
12566	*
12567	* Create a parser context for an XML in-memory document.
12568	*
12569	* Returns the new parser context or NULL
12570	*/
12571	xmlParserCtxtPtr
12572	xmlCreateMemoryParserCtxt(const char *buffer, int size) {
12573	xmlParserCtxtPtr ctxt;
12574	xmlParserInputPtr input;
12575	xmlParserInputBufferPtr buf;
12576
12577	if (buffer == NULL)
12578	return(NULL);
12579	if (size <= 0)
12580	return(NULL);
12581
12582	ctxt = xmlNewParserCtxt();
12583	if (ctxt == NULL)
12584	return(NULL);
12585
12586	/* TODO: xmlParserInputBufferCreateStatic, requires some serious changes */
12587	buf = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
12588	if (buf == NULL) {
12589	xmlFreeParserCtxt(ctxt);
12590	return(NULL);
12591	}
12592
12593	input = xmlNewInputStream(ctxt);
12594	if (input == NULL) {
12595	xmlFreeParserInputBuffer(buf);
12596	xmlFreeParserCtxt(ctxt);
12597	return(NULL);
12598	}
12599
12600	input->filename = NULL;
12601	input->buf = buf;
12602	input->base = input->buf->buffer->content;
12603	input->cur = input->buf->buffer->content;
12604	input->end = &input->buf->buffer->content[input->buf->buffer->use];
12605
12606	inputPush(ctxt, input);
12607	return(ctxt);
12608	}
12609
12610	#ifdef LIBXML_SAX1_ENABLED
12611	/**
12612	* xmlSAXParseMemoryWithData:
12613	* @sax: the SAX handler block
12614	* @buffer: an pointer to a char array
12615	* @size: the size of the array
12616	* @recovery: work in recovery mode, i.e. tries to read no Well Formed
12617	* documents
12618	* @data: the userdata
12619	*
12620	* parse an XML in-memory block and use the given SAX function block
12621	* to handle the parsing callback. If sax is NULL, fallback to the default
12622	* DOM tree building routines.
12623	*
12624	* User data (void *) is stored within the parser context in the
12625	* context's _private member, so it is available nearly everywhere in libxml
12626	*
12627	* Returns the resulting document tree
12628	*/
12629
12630	xmlDocPtr
12631	xmlSAXParseMemoryWithData(xmlSAXHandlerPtr sax, const char *buffer,
12632	int size, int recovery, void *data) {
12633	xmlDocPtr ret;
12634	xmlParserCtxtPtr ctxt;
12635
12636	ctxt = xmlCreateMemoryParserCtxt(buffer, size);
12637	if (ctxt == NULL) return(NULL);
12638	if (sax != NULL) {
12639	if (ctxt->sax != NULL)
12640	xmlFree(ctxt->sax);
12641	ctxt->sax = sax;
12642	}
12643	xmlDetectSAX2(ctxt);
12644	if (data!=NULL) {
12645	ctxt->_private=data;
12646	}
12647
12648	ctxt->recovery = recovery;
12649
12650	xmlParseDocument(ctxt);
12651
12652	if ((ctxt->wellFormed) \|\| recovery) ret = ctxt->myDoc;
12653	else {
12654	ret = NULL;
12655	xmlFreeDoc(ctxt->myDoc);
12656	ctxt->myDoc = NULL;
12657	}
12658	if (sax != NULL)
12659	ctxt->sax = NULL;
12660	xmlFreeParserCtxt(ctxt);
12661
12662	return(ret);
12663	}
12664
12665	/**
12666	* xmlSAXParseMemory:
12667	* @sax: the SAX handler block
12668	* @buffer: an pointer to a char array
12669	* @size: the size of the array
12670	* @recovery: work in recovery mode, i.e. tries to read not Well Formed
12671	* documents
12672	*
12673	* parse an XML in-memory block and use the given SAX function block
12674	* to handle the parsing callback. If sax is NULL, fallback to the default
12675	* DOM tree building routines.
12676	*
12677	* Returns the resulting document tree
12678	*/
12679	xmlDocPtr
12680	xmlSAXParseMemory(xmlSAXHandlerPtr sax, const char *buffer,
12681	int size, int recovery) {
12682	return xmlSAXParseMemoryWithData(sax, buffer, size, recovery, NULL);
12683	}
12684
12685	/**
12686	* xmlParseMemory:
12687	* @buffer: an pointer to a char array
12688	* @size: the size of the array
12689	*
12690	* parse an XML in-memory block and build a tree.
12691	*
12692	* Returns the resulting document tree
12693	*/
12694
12695	xmlDocPtr xmlParseMemory(const char *buffer, int size) {
12696	return(xmlSAXParseMemory(NULL, buffer, size, 0));
12697	}
12698
12699	/**
12700	* xmlRecoverMemory:
12701	* @buffer: an pointer to a char array
12702	* @size: the size of the array
12703	*
12704	* parse an XML in-memory block and build a tree.
12705	* In the case the document is not Well Formed, a tree is built anyway
12706	*
12707	* Returns the resulting document tree
12708	*/
12709
12710	xmlDocPtr xmlRecoverMemory(const char *buffer, int size) {
12711	return(xmlSAXParseMemory(NULL, buffer, size, 1));
12712	}
12713
12714	/**
12715	* xmlSAXUserParseMemory:
12716	* @sax: a SAX handler
12717	* @user_data: The user data returned on SAX callbacks
12718	* @buffer: an in-memory XML document input
12719	* @size: the length of the XML document in bytes
12720	*
12721	* A better SAX parsing routine.
12722	* parse an XML in-memory buffer and call the given SAX handler routines.
12723	*
12724	* Returns 0 in case of success or a error number otherwise
12725	*/
12726	int xmlSAXUserParseMemory(xmlSAXHandlerPtr sax, void *user_data,
12727	const char *buffer, int size) {
12728	int ret = 0;
12729	xmlParserCtxtPtr ctxt;
12730
12731	ctxt = xmlCreateMemoryParserCtxt(buffer, size);
12732	if (ctxt == NULL) return -1;
12733	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12734	xmlFree(ctxt->sax);
12735	ctxt->sax = sax;
12736	xmlDetectSAX2(ctxt);
12737
12738	if (user_data != NULL)
12739	ctxt->userData = user_data;
12740
12741	xmlParseDocument(ctxt);
12742
12743	if (ctxt->wellFormed)
12744	ret = 0;
12745	else {
12746	if (ctxt->errNo != 0)
12747	ret = ctxt->errNo;
12748	else
12749	ret = -1;
12750	}
12751	if (sax != NULL)
12752	ctxt->sax = NULL;
12753	if (ctxt->myDoc != NULL) {
12754	xmlFreeDoc(ctxt->myDoc);
12755	ctxt->myDoc = NULL;
12756	}
12757	xmlFreeParserCtxt(ctxt);
12758
12759	return ret;
12760	}
12761	#endif /* LIBXML_SAX1_ENABLED */
12762
12763	/**
12764	* xmlCreateDocParserCtxt:
12765	* @cur: a pointer to an array of xmlChar
12766	*
12767	* Creates a parser context for an XML in-memory document.
12768	*
12769	* Returns the new parser context or NULL
12770	*/
12771	xmlParserCtxtPtr
12772	xmlCreateDocParserCtxt(const xmlChar *cur) {
12773	int len;
12774
12775	if (cur == NULL)
12776	return(NULL);
12777	len = xmlStrlen(cur);
12778	return(xmlCreateMemoryParserCtxt((const char *)cur, len));
12779	}
12780
12781	#ifdef LIBXML_SAX1_ENABLED
12782	/**
12783	* xmlSAXParseDoc:
12784	* @sax: the SAX handler block
12785	* @cur: a pointer to an array of xmlChar
12786	* @recovery: work in recovery mode, i.e. tries to read no Well Formed
12787	* documents
12788	*
12789	* parse an XML in-memory document and build a tree.
12790	* It use the given SAX function block to handle the parsing callback.
12791	* If sax is NULL, fallback to the default DOM tree building routines.
12792	*
12793	* Returns the resulting document tree
12794	*/
12795
12796	xmlDocPtr
12797	xmlSAXParseDoc(xmlSAXHandlerPtr sax, const xmlChar *cur, int recovery) {
12798	xmlDocPtr ret;
12799	xmlParserCtxtPtr ctxt;
12800	xmlSAXHandlerPtr oldsax = NULL;
12801
12802	if (cur == NULL) return(NULL);
12803
12804
12805	ctxt = xmlCreateDocParserCtxt(cur);
12806	if (ctxt == NULL) return(NULL);
12807	if (sax != NULL) {
12808	oldsax = ctxt->sax;
12809	ctxt->sax = sax;
12810	ctxt->userData = NULL;
12811	}
12812	xmlDetectSAX2(ctxt);
12813
12814	xmlParseDocument(ctxt);
12815	if ((ctxt->wellFormed) \|\| recovery) ret = ctxt->myDoc;
12816	else {
12817	ret = NULL;
12818	xmlFreeDoc(ctxt->myDoc);
12819	ctxt->myDoc = NULL;
12820	}
12821	if (sax != NULL)
12822	ctxt->sax = oldsax;
12823	xmlFreeParserCtxt(ctxt);
12824
12825	return(ret);
12826	}
12827
12828	/**
12829	* xmlParseDoc:
12830	* @cur: a pointer to an array of xmlChar
12831	*
12832	* parse an XML in-memory document and build a tree.
12833	*
12834	* Returns the resulting document tree
12835	*/
12836
12837	xmlDocPtr
12838	xmlParseDoc(const xmlChar *cur) {
12839	return(xmlSAXParseDoc(NULL, cur, 0));
12840	}
12841	#endif /* LIBXML_SAX1_ENABLED */
12842
12843	#ifdef LIBXML_LEGACY_ENABLED
12844	/************************************************************************
12845	* *
12846	* Specific function to keep track of entities references *
12847	* and used by the XSLT debugger *
12848	* *
12849	************************************************************************/
12850
12851	static xmlEntityReferenceFunc xmlEntityRefFunc = NULL;
12852
12853	/**
12854	* xmlAddEntityReference:
12855	* @ent : A valid entity
12856	* @firstNode : A valid first node for children of entity
12857	* @lastNode : A valid last node of children entity
12858	*
12859	* Notify of a reference to an entity of type XML_EXTERNAL_GENERAL_PARSED_ENTITY
12860	*/
12861	static void
12862	xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
12863	xmlNodePtr lastNode)
12864	{
12865	if (xmlEntityRefFunc != NULL) {
12866	(*xmlEntityRefFunc) (ent, firstNode, lastNode);
12867	}
12868	}
12869
12870
12871	/**
12872	* xmlSetEntityReferenceFunc:
12873	* @func: A valid function
12874	*
12875	* Set the function to call call back when a xml reference has been made
12876	*/
12877	void
12878	xmlSetEntityReferenceFunc(xmlEntityReferenceFunc func)
12879	{
12880	xmlEntityRefFunc = func;
12881	}
12882	#endif /* LIBXML_LEGACY_ENABLED */
12883
12884	/************************************************************************
12885	* *
12886	* Miscellaneous *
12887	* *
12888	************************************************************************/
12889
12890	#ifdef LIBXML_XPATH_ENABLED
12891	#include <libxml/xpath.h>
12892	#endif
12893
12894	extern void XMLCDECL xmlGenericErrorDefaultFunc(void ctx, const char msg, ...);
12895	static int xmlParserInitialized = 0;
12896
12897	/**
12898	* xmlInitParser:
12899	*
12900	* Initialization function for the XML parser.
12901	* This is not reentrant. Call once before processing in case of
12902	* use in multithreaded programs.
12903	*/
12904
12905	void
12906	xmlInitParser(void) {
12907	if (xmlParserInitialized != 0)
12908	return;
12909
12910	#ifdef LIBXML_THREAD_ENABLED
12911	__xmlGlobalInitMutexLock();
12912	if (xmlParserInitialized == 0) {
12913	#endif
12914	if ((xmlGenericError == xmlGenericErrorDefaultFunc) \|\|
12915	(xmlGenericError == NULL))
12916	initGenericErrorDefaultFunc(NULL);
12917	xmlInitGlobals();
12918	xmlInitThreads();
12919	xmlInitMemory();
12920	xmlInitCharEncodingHandlers();
12921	xmlDefaultSAXHandlerInit();
12922	xmlRegisterDefaultInputCallbacks();
12923	#ifdef LIBXML_OUTPUT_ENABLED
12924	xmlRegisterDefaultOutputCallbacks();
12925	#endif /* LIBXML_OUTPUT_ENABLED */
12926	#ifdef LIBXML_HTML_ENABLED
12927	htmlInitAutoClose();
12928	htmlDefaultSAXHandlerInit();
12929	#endif
12930	#ifdef LIBXML_XPATH_ENABLED
12931	xmlXPathInit();
12932	#endif
12933	xmlParserInitialized = 1;
12934	#ifdef LIBXML_THREAD_ENABLED
12935	}
12936	__xmlGlobalInitMutexUnlock();
12937	#endif
12938	}
12939
12940	/**
12941	* xmlCleanupParser:
12942	*
12943	* Cleanup function for the XML library. It tries to reclaim all
12944	* parsing related global memory allocated for the library processing.
12945	* It doesn't deallocate any document related memory. Calling this
12946	* function should not prevent reusing the library but one should
12947	* call xmlCleanupParser() only when the process has
12948	* finished using the library or XML document built with it.
12949	*/
12950
12951	void
12952	xmlCleanupParser(void) {
12953	if (!xmlParserInitialized)
12954	return;
12955
12956	xmlCleanupCharEncodingHandlers();
12957	#ifdef LIBXML_CATALOG_ENABLED
12958	xmlCatalogCleanup();
12959	#endif
12960	xmlDictCleanup();
12961	xmlCleanupInputCallbacks();
12962	#ifdef LIBXML_OUTPUT_ENABLED
12963	xmlCleanupOutputCallbacks();
12964	#endif
12965	#ifdef LIBXML_SCHEMAS_ENABLED
12966	xmlSchemaCleanupTypes();
12967	xmlRelaxNGCleanupTypes();
12968	#endif
12969	xmlCleanupGlobals();
12970	xmlResetLastError();
12971	xmlCleanupThreads(); /* must be last if called not from the main thread */
12972	xmlCleanupMemory();
12973	xmlParserInitialized = 0;
12974	}
12975
12976	/************************************************************************
12977	* *
12978	* New set (2.6.0) of simpler and more flexible APIs *
12979	* *
12980	************************************************************************/
12981
12982	/**
12983	* DICT_FREE:
12984	* @str: a string
12985	*
12986	* Free a string if it is not owned by the "dict" dictionnary in the
12987	* current scope
12988	*/
12989	#define DICT_FREE(str) \
12990	if ((str) && ((!dict) \|\| \
12991	(xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \
12992	xmlFree((char *)(str));
12993
12994	/**
12995	* xmlCtxtReset:
12996	* @ctxt: an XML parser context
12997	*
12998	* Reset a parser context
12999	*/
13000	void
13001	xmlCtxtReset(xmlParserCtxtPtr ctxt)
13002	{
13003	xmlParserInputPtr input;
13004	xmlDictPtr dict;
13005
13006	if (ctxt == NULL)
13007	return;
13008
13009	dict = ctxt->dict;
13010
13011	while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
13012	xmlFreeInputStream(input);
13013	}
13014	ctxt->inputNr = 0;
13015	ctxt->input = NULL;
13016
13017	ctxt->spaceNr = 0;
13018	if (ctxt->spaceTab != NULL) {
13019	ctxt->spaceTab[0] = -1;
13020	ctxt->space = &ctxt->spaceTab[0];
13021	} else {
13022	ctxt->space = NULL;
13023	}
13024
13025
13026	ctxt->nodeNr = 0;
13027	ctxt->node = NULL;
13028
13029	ctxt->nameNr = 0;
13030	ctxt->name = NULL;
13031
13032	DICT_FREE(ctxt->version);
13033	ctxt->version = NULL;
13034	DICT_FREE(ctxt->encoding);
13035	ctxt->encoding = NULL;
13036	DICT_FREE(ctxt->directory);
13037	ctxt->directory = NULL;
13038	DICT_FREE(ctxt->extSubURI);
13039	ctxt->extSubURI = NULL;
13040	DICT_FREE(ctxt->extSubSystem);
13041	ctxt->extSubSystem = NULL;
13042	if (ctxt->myDoc != NULL)
13043	xmlFreeDoc(ctxt->myDoc);
13044	ctxt->myDoc = NULL;
13045
13046	ctxt->standalone = -1;
13047	ctxt->hasExternalSubset = 0;
13048	ctxt->hasPErefs = 0;
13049	ctxt->html = 0;
13050	ctxt->external = 0;
13051	ctxt->instate = XML_PARSER_START;
13052	ctxt->token = 0;
13053
13054	ctxt->wellFormed = 1;
13055	ctxt->nsWellFormed = 1;
13056	ctxt->disableSAX = 0;
13057	ctxt->valid = 1;
13058	#if 0
13059	ctxt->vctxt.userData = ctxt;
13060	ctxt->vctxt.error = xmlParserValidityError;
13061	ctxt->vctxt.warning = xmlParserValidityWarning;
13062	#endif
13063	ctxt->record_info = 0;
13064	ctxt->nbChars = 0;
13065	ctxt->checkIndex = 0;
13066	ctxt->inSubset = 0;
13067	ctxt->errNo = XML_ERR_OK;
13068	ctxt->depth = 0;
13069	ctxt->charset = XML_CHAR_ENCODING_UTF8;
13070	ctxt->catalogs = NULL;
13071	ctxt->nbentities = 0;
13072	xmlInitNodeInfoSeq(&ctxt->node_seq);
13073
13074	if (ctxt->attsDefault != NULL) {
13075	xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
13076	ctxt->attsDefault = NULL;
13077	}
13078	if (ctxt->attsSpecial != NULL) {
13079	xmlHashFree(ctxt->attsSpecial, NULL);
13080	ctxt->attsSpecial = NULL;
13081	}
13082
13083	#ifdef LIBXML_CATALOG_ENABLED
13084	if (ctxt->catalogs != NULL)
13085	xmlCatalogFreeLocal(ctxt->catalogs);
13086	#endif
13087	if (ctxt->lastError.code != XML_ERR_OK)
13088	xmlResetError(&ctxt->lastError);
13089	}
13090
13091	/**
13092	* xmlCtxtResetPush:
13093	* @ctxt: an XML parser context
13094	* @chunk: a pointer to an array of chars
13095	* @size: number of chars in the array
13096	* @filename: an optional file name or URI
13097	* @encoding: the document encoding, or NULL
13098	*
13099	* Reset a push parser context
13100	*
13101	* Returns 0 in case of success and 1 in case of error
13102	*/
13103	int
13104	xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk,
13105	int size, const char filename, const char encoding)
13106	{
13107	xmlParserInputPtr inputStream;
13108	xmlParserInputBufferPtr buf;
13109	xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
13110
13111	if (ctxt == NULL)
13112	return(1);
13113
13114	if ((encoding == NULL) && (chunk != NULL) && (size >= 4))
13115	enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
13116
13117	buf = xmlAllocParserInputBuffer(enc);
13118	if (buf == NULL)
13119	return(1);
13120
13121	if (ctxt == NULL) {
13122	xmlFreeParserInputBuffer(buf);
13123	return(1);
13124	}
13125
13126	xmlCtxtReset(ctxt);
13127
13128	if (ctxt->pushTab == NULL) {
13129	ctxt->pushTab = (void *) xmlMalloc(ctxt->nameMax 3 *
13130	sizeof(xmlChar *));
13131	if (ctxt->pushTab == NULL) {
13132	xmlErrMemory(ctxt, NULL);
13133	xmlFreeParserInputBuffer(buf);
13134	return(1);
13135	}
13136	}
13137
13138	if (filename == NULL) {
13139	ctxt->directory = NULL;
13140	} else {
13141	ctxt->directory = xmlParserGetDirectory(filename);
13142	}
13143
13144	inputStream = xmlNewInputStream(ctxt);
13145	if (inputStream == NULL) {
13146	xmlFreeParserInputBuffer(buf);
13147	return(1);
13148	}
13149
13150	if (filename == NULL)
13151	inputStream->filename = NULL;
13152	else
13153	inputStream->filename = (char *)
13154	xmlCanonicPath((const xmlChar *) filename);
13155	inputStream->buf = buf;
13156	inputStream->base = inputStream->buf->buffer->content;
13157	inputStream->cur = inputStream->buf->buffer->content;
13158	inputStream->end =
13159	&inputStream->buf->buffer->content[inputStream->buf->buffer->use];
13160
13161	inputPush(ctxt, inputStream);
13162
13163	if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
13164	(ctxt->input->buf != NULL)) {
13165	int base = ctxt->input->base - ctxt->input->buf->buffer->content;
13166	int cur = ctxt->input->cur - ctxt->input->base;
13167
13168	xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
13169
13170	ctxt->input->base = ctxt->input->buf->buffer->content + base;
13171	ctxt->input->cur = ctxt->input->base + cur;
13172	ctxt->input->end =
13173	&ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->
13174	use];
13175	#ifdef DEBUG_PUSH
13176	xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
13177	#endif
13178	}
13179
13180	if (encoding != NULL) {
13181	xmlCharEncodingHandlerPtr hdlr;
13182
13183	hdlr = xmlFindCharEncodingHandler(encoding);
13184	if (hdlr != NULL) {
13185	xmlSwitchToEncoding(ctxt, hdlr);
13186	} else {
13187	xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
13188	"Unsupported encoding %s\n", BAD_CAST encoding);
13189	}
13190	} else if (enc != XML_CHAR_ENCODING_NONE) {
13191	xmlSwitchEncoding(ctxt, enc);
13192	}
13193
13194	return(0);
13195	}
13196
13197	/**
13198	* xmlCtxtUseOptions:
13199	* @ctxt: an XML parser context
13200	* @options: a combination of xmlParserOption
13201	*
13202	* Applies the options to the parser context
13203	*
13204	* Returns 0 in case of success, the set of unknown or unimplemented options
13205	* in case of error.
13206	*/
13207	int
13208	xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
13209	{
13210	if (ctxt == NULL)
13211	return(-1);
13212	if (options & XML_PARSE_RECOVER) {
13213	ctxt->recovery = 1;
13214	options -= XML_PARSE_RECOVER;
13215	} else
13216	ctxt->recovery = 0;
13217	if (options & XML_PARSE_DTDLOAD) {
13218	ctxt->loadsubset = XML_DETECT_IDS;
13219	options -= XML_PARSE_DTDLOAD;
13220	} else
13221	ctxt->loadsubset = 0;
13222	if (options & XML_PARSE_DTDATTR) {
13223	ctxt->loadsubset \|= XML_COMPLETE_ATTRS;
13224	options -= XML_PARSE_DTDATTR;
13225	}
13226	if (options & XML_PARSE_NOENT) {
13227	ctxt->replaceEntities = 1;
13228	/* ctxt->loadsubset \|= XML_DETECT_IDS; */
13229	options -= XML_PARSE_NOENT;
13230	} else
13231	ctxt->replaceEntities = 0;
13232	if (options & XML_PARSE_PEDANTIC) {
13233	ctxt->pedantic = 1;
13234	options -= XML_PARSE_PEDANTIC;
13235	} else
13236	ctxt->pedantic = 0;
13237	if (options & XML_PARSE_NOBLANKS) {
13238	ctxt->keepBlanks = 0;
13239	ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
13240	options -= XML_PARSE_NOBLANKS;
13241	} else
13242	ctxt->keepBlanks = 1;
13243	if (options & XML_PARSE_DTDVALID) {
13244	ctxt->validate = 1;
13245	if (options & XML_PARSE_NOWARNING)
13246	ctxt->vctxt.warning = NULL;
13247	if (options & XML_PARSE_NOERROR)
13248	ctxt->vctxt.error = NULL;
13249	options -= XML_PARSE_DTDVALID;
13250	} else
13251	ctxt->validate = 0;
13252	if (options & XML_PARSE_NOWARNING) {
13253	ctxt->sax->warning = NULL;
13254	options -= XML_PARSE_NOWARNING;
13255	}
13256	if (options & XML_PARSE_NOERROR) {
13257	ctxt->sax->error = NULL;
13258	ctxt->sax->fatalError = NULL;
13259	options -= XML_PARSE_NOERROR;
13260	}
13261	#ifdef LIBXML_SAX1_ENABLED
13262	if (options & XML_PARSE_SAX1) {
13263	ctxt->sax->startElement = xmlSAX2StartElement;
13264	ctxt->sax->endElement = xmlSAX2EndElement;
13265	ctxt->sax->startElementNs = NULL;
13266	ctxt->sax->endElementNs = NULL;
13267	ctxt->sax->initialized = 1;
13268	options -= XML_PARSE_SAX1;
13269	}
13270	#endif /* LIBXML_SAX1_ENABLED */
13271	if (options & XML_PARSE_NODICT) {
13272	ctxt->dictNames = 0;
13273	options -= XML_PARSE_NODICT;
13274	} else {
13275	ctxt->dictNames = 1;
13276	}
13277	if (options & XML_PARSE_NOCDATA) {
13278	ctxt->sax->cdataBlock = NULL;
13279	options -= XML_PARSE_NOCDATA;
13280	}
13281	if (options & XML_PARSE_NSCLEAN) {
13282	ctxt->options \|= XML_PARSE_NSCLEAN;
13283	options -= XML_PARSE_NSCLEAN;
13284	}
13285	if (options & XML_PARSE_NONET) {
13286	ctxt->options \|= XML_PARSE_NONET;
13287	options -= XML_PARSE_NONET;
13288	}
13289	if (options & XML_PARSE_COMPACT) {
13290	ctxt->options \|= XML_PARSE_COMPACT;
13291	options -= XML_PARSE_COMPACT;
13292	}
13293	ctxt->linenumbers = 1;
13294	return (options);
13295	}
13296
13297	/**
13298	* xmlDoRead:
13299	* @ctxt: an XML parser context
13300	* @URL: the base URL to use for the document
13301	* @encoding: the document encoding, or NULL
13302	* @options: a combination of xmlParserOption
13303	* @reuse: keep the context for reuse
13304	*
13305	* Common front-end for the xmlRead functions
13306	*
13307	* Returns the resulting document tree or NULL
13308	*/
13309	static xmlDocPtr
13310	xmlDoRead(xmlParserCtxtPtr ctxt, const char URL, const char encoding,
13311	int options, int reuse)
13312	{
13313	xmlDocPtr ret;
13314
13315	xmlCtxtUseOptions(ctxt, options);
13316	if (encoding != NULL) {
13317	xmlCharEncodingHandlerPtr hdlr;
13318
13319	hdlr = xmlFindCharEncodingHandler(encoding);
13320	if (hdlr != NULL)
13321	xmlSwitchToEncoding(ctxt, hdlr);
13322	}
13323	if ((URL != NULL) && (ctxt->input != NULL) &&
13324	(ctxt->input->filename == NULL))
13325	ctxt->input->filename = (char ) xmlStrdup((const xmlChar ) URL);
13326	xmlParseDocument(ctxt);
13327	if ((ctxt->wellFormed) \|\| ctxt->recovery)
13328	ret = ctxt->myDoc;
13329	else {
13330	ret = NULL;
13331	if (ctxt->myDoc != NULL) {
13332	xmlFreeDoc(ctxt->myDoc);
13333	}
13334	}
13335	ctxt->myDoc = NULL;
13336	if (!reuse) {
13337	xmlFreeParserCtxt(ctxt);
13338	}
13339
13340	return (ret);
13341	}
13342
13343	/**
13344	* xmlReadDoc:
13345	* @cur: a pointer to a zero terminated string
13346	* @URL: the base URL to use for the document
13347	* @encoding: the document encoding, or NULL
13348	* @options: a combination of xmlParserOption
13349	*
13350	* parse an XML in-memory document and build a tree.
13351	*
13352	* Returns the resulting document tree
13353	*/
13354	xmlDocPtr
13355	xmlReadDoc(const xmlChar * cur, const char URL, const char encoding, int options)
13356	{
13357	xmlParserCtxtPtr ctxt;
13358
13359	if (cur == NULL)
13360	return (NULL);
13361
13362	ctxt = xmlCreateDocParserCtxt(cur);
13363	if (ctxt == NULL)
13364	return (NULL);
13365	return (xmlDoRead(ctxt, URL, encoding, options, 0));
13366	}
13367
13368	/**
13369	* xmlReadFile:
13370	* @filename: a file or URL
13371	* @encoding: the document encoding, or NULL
13372	* @options: a combination of xmlParserOption
13373	*
13374	* parse an XML file from the filesystem or the network.
13375	*
13376	* Returns the resulting document tree
13377	*/
13378	xmlDocPtr
13379	xmlReadFile(const char filename, const char encoding, int options)
13380	{
13381	xmlParserCtxtPtr ctxt;
13382
13383	ctxt = xmlCreateURLParserCtxt(filename, options);
13384	if (ctxt == NULL)
13385	return (NULL);
13386	return (xmlDoRead(ctxt, NULL, encoding, options, 0));
13387	}
13388
13389	/**
13390	* xmlReadMemory:
13391	* @buffer: a pointer to a char array
13392	* @size: the size of the array
13393	* @URL: the base URL to use for the document
13394	* @encoding: the document encoding, or NULL
13395	* @options: a combination of xmlParserOption
13396	*
13397	* parse an XML in-memory document and build a tree.
13398	*
13399	* Returns the resulting document tree
13400	*/
13401	xmlDocPtr
13402	xmlReadMemory(const char buffer, int size, const char URL, const char *encoding, int options)
13403	{
13404	xmlParserCtxtPtr ctxt;
13405
13406	ctxt = xmlCreateMemoryParserCtxt(buffer, size);
13407	if (ctxt == NULL)
13408	return (NULL);
13409	return (xmlDoRead(ctxt, URL, encoding, options, 0));
13410	}
13411
13412	/**
13413	* xmlReadFd:
13414	* @fd: an open file descriptor
13415	* @URL: the base URL to use for the document
13416	* @encoding: the document encoding, or NULL
13417	* @options: a combination of xmlParserOption
13418	*
13419	* parse an XML from a file descriptor and build a tree.
13420	* NOTE that the file descriptor will not be closed when the
13421	* reader is closed or reset.
13422	*
13423	* Returns the resulting document tree
13424	*/
13425	xmlDocPtr
13426	xmlReadFd(int fd, const char URL, const char encoding, int options)
13427	{
13428	xmlParserCtxtPtr ctxt;
13429	xmlParserInputBufferPtr input;
13430	xmlParserInputPtr stream;
13431
13432	if (fd < 0)
13433	return (NULL);
13434
13435	input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
13436	if (input == NULL)
13437	return (NULL);
13438	input->closecallback = NULL;
13439	ctxt = xmlNewParserCtxt();
13440	if (ctxt == NULL) {
13441	xmlFreeParserInputBuffer(input);
13442	return (NULL);
13443	}
13444	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13445	if (stream == NULL) {
13446	xmlFreeParserInputBuffer(input);
13447	xmlFreeParserCtxt(ctxt);
13448	return (NULL);
13449	}
13450	inputPush(ctxt, stream);
13451	return (xmlDoRead(ctxt, URL, encoding, options, 0));
13452	}
13453
13454	/**
13455	* xmlReadIO:
13456	* @ioread: an I/O read function
13457	* @ioclose: an I/O close function
13458	* @ioctx: an I/O handler
13459	* @URL: the base URL to use for the document
13460	* @encoding: the document encoding, or NULL
13461	* @options: a combination of xmlParserOption
13462	*
13463	* parse an XML document from I/O functions and source and build a tree.
13464	*
13465	* Returns the resulting document tree
13466	*/
13467	xmlDocPtr
13468	xmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
13469	void ioctx, const char URL, const char *encoding, int options)
13470	{
13471	xmlParserCtxtPtr ctxt;
13472	xmlParserInputBufferPtr input;
13473	xmlParserInputPtr stream;
13474
13475	if (ioread == NULL)
13476	return (NULL);
13477
13478	input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
13479	XML_CHAR_ENCODING_NONE);
13480	if (input == NULL)
13481	return (NULL);
13482	ctxt = xmlNewParserCtxt();
13483	if (ctxt == NULL) {
13484	xmlFreeParserInputBuffer(input);
13485	return (NULL);
13486	}
13487	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13488	if (stream == NULL) {
13489	xmlFreeParserInputBuffer(input);
13490	xmlFreeParserCtxt(ctxt);
13491	return (NULL);
13492	}
13493	inputPush(ctxt, stream);
13494	return (xmlDoRead(ctxt, URL, encoding, options, 0));
13495	}
13496
13497	/**
13498	* xmlCtxtReadDoc:
13499	* @ctxt: an XML parser context
13500	* @cur: a pointer to a zero terminated string
13501	* @URL: the base URL to use for the document
13502	* @encoding: the document encoding, or NULL
13503	* @options: a combination of xmlParserOption
13504	*
13505	* parse an XML in-memory document and build a tree.
13506	* This reuses the existing @ctxt parser context
13507	*
13508	* Returns the resulting document tree
13509	*/
13510	xmlDocPtr
13511	xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur,
13512	const char URL, const char encoding, int options)
13513	{
13514	xmlParserInputPtr stream;
13515
13516	if (cur == NULL)
13517	return (NULL);
13518	if (ctxt == NULL)
13519	return (NULL);
13520
13521	xmlCtxtReset(ctxt);
13522
13523	stream = xmlNewStringInputStream(ctxt, cur);
13524	if (stream == NULL) {
13525	return (NULL);
13526	}
13527	inputPush(ctxt, stream);
13528	return (xmlDoRead(ctxt, URL, encoding, options, 1));
13529	}
13530
13531	/**
13532	* xmlCtxtReadFile:
13533	* @ctxt: an XML parser context
13534	* @filename: a file or URL
13535	* @encoding: the document encoding, or NULL
13536	* @options: a combination of xmlParserOption
13537	*
13538	* parse an XML file from the filesystem or the network.
13539	* This reuses the existing @ctxt parser context
13540	*
13541	* Returns the resulting document tree
13542	*/
13543	xmlDocPtr
13544	xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename,
13545	const char *encoding, int options)
13546	{
13547	xmlParserInputPtr stream;
13548
13549	if (filename == NULL)
13550	return (NULL);
13551	if (ctxt == NULL)
13552	return (NULL);
13553
13554	xmlCtxtReset(ctxt);
13555
13556	stream = xmlLoadExternalEntity(filename, NULL, ctxt);
13557	if (stream == NULL) {
13558	return (NULL);
13559	}
13560	inputPush(ctxt, stream);
13561	return (xmlDoRead(ctxt, NULL, encoding, options, 1));
13562	}
13563
13564	/**
13565	* xmlCtxtReadMemory:
13566	* @ctxt: an XML parser context
13567	* @buffer: a pointer to a char array
13568	* @size: the size of the array
13569	* @URL: the base URL to use for the document
13570	* @encoding: the document encoding, or NULL
13571	* @options: a combination of xmlParserOption
13572	*
13573	* parse an XML in-memory document and build a tree.
13574	* This reuses the existing @ctxt parser context
13575	*
13576	* Returns the resulting document tree
13577	*/
13578	xmlDocPtr
13579	xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size,
13580	const char URL, const char encoding, int options)
13581	{
13582	xmlParserInputBufferPtr input;
13583	xmlParserInputPtr stream;
13584
13585	if (ctxt == NULL)
13586	return (NULL);
13587	if (buffer == NULL)
13588	return (NULL);
13589
13590	xmlCtxtReset(ctxt);
13591
13592	input = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
13593	if (input == NULL) {
13594	return(NULL);
13595	}
13596
13597	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13598	if (stream == NULL) {
13599	xmlFreeParserInputBuffer(input);
13600	return(NULL);
13601	}
13602
13603	inputPush(ctxt, stream);
13604	return (xmlDoRead(ctxt, URL, encoding, options, 1));
13605	}
13606
13607	/**
13608	* xmlCtxtReadFd:
13609	* @ctxt: an XML parser context
13610	* @fd: an open file descriptor
13611	* @URL: the base URL to use for the document
13612	* @encoding: the document encoding, or NULL
13613	* @options: a combination of xmlParserOption
13614	*
13615	* parse an XML from a file descriptor and build a tree.
13616	* This reuses the existing @ctxt parser context
13617	* NOTE that the file descriptor will not be closed when the
13618	* reader is closed or reset.
13619	*
13620	* Returns the resulting document tree
13621	*/
13622	xmlDocPtr
13623	xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd,
13624	const char URL, const char encoding, int options)
13625	{
13626	xmlParserInputBufferPtr input;
13627	xmlParserInputPtr stream;
13628
13629	if (fd < 0)
13630	return (NULL);
13631	if (ctxt == NULL)
13632	return (NULL);
13633
13634	xmlCtxtReset(ctxt);
13635
13636
13637	input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
13638	if (input == NULL)
13639	return (NULL);
13640	input->closecallback = NULL;
13641	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13642	if (stream == NULL) {
13643	xmlFreeParserInputBuffer(input);
13644	return (NULL);
13645	}
13646	inputPush(ctxt, stream);
13647	return (xmlDoRead(ctxt, URL, encoding, options, 1));
13648	}
13649
13650	/**
13651	* xmlCtxtReadIO:
13652	* @ctxt: an XML parser context
13653	* @ioread: an I/O read function
13654	* @ioclose: an I/O close function
13655	* @ioctx: an I/O handler
13656	* @URL: the base URL to use for the document
13657	* @encoding: the document encoding, or NULL
13658	* @options: a combination of xmlParserOption
13659	*
13660	* parse an XML document from I/O functions and source and build a tree.
13661	* This reuses the existing @ctxt parser context
13662	*
13663	* Returns the resulting document tree
13664	*/
13665	xmlDocPtr
13666	xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
13667	xmlInputCloseCallback ioclose, void *ioctx,
13668	const char *URL,
13669	const char *encoding, int options)
13670	{
13671	xmlParserInputBufferPtr input;
13672	xmlParserInputPtr stream;
13673
13674	if (ioread == NULL)
13675	return (NULL);
13676	if (ctxt == NULL)
13677	return (NULL);
13678
13679	xmlCtxtReset(ctxt);
13680
13681	input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
13682	XML_CHAR_ENCODING_NONE);
13683	if (input == NULL)
13684	return (NULL);
13685	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13686	if (stream == NULL) {
13687	xmlFreeParserInputBuffer(input);
13688	return (NULL);
13689	}
13690	inputPush(ctxt, stream);
13691	return (xmlDoRead(ctxt, URL, encoding, options, 1));
13692	}
13693
13694	#define bottom_parser
13695	#include "elfgcchack.h"

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

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

Download in other formats: