parser.c@ 9259

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

Line
1	/*
2	* parser.c : an XML 1.0 parser, namespaces and validity support are mostly
3	* implemented on top of the SAX interfaces
4	*
5	* References:
6	* The XML specification:
7	* http://www.w3.org/TR/REC-xml
8	* Original 1.0 version:
9	* http://www.w3.org/TR/1998/REC-xml-19980210
10	* XML second edition working draft
11	* http://www.w3.org/TR/2000/WD-xml-2e-20000814
12	*
13	* Okay this is a big file, the parser core is around 7000 lines, then it
14	* is followed by the progressive parser top routines, then the various
15	* high level APIs to call the parser and a few miscellaneous functions.
16	* A number of helper functions and deprecated ones have been moved to
17	* parserInternals.c to reduce this file size.
18	* As much as possible the functions are associated with their relative
19	* production in the XML specification. A few productions defining the
20	* different ranges of character are actually implanted either in
21	* parserInternals.h or parserInternals.c
22	* The DOM tree build is realized from the default SAX callbacks in
23	* the module SAX.c.
24	* The routines doing the validation checks are in valid.c and called either
25	* from the SAX callbacks or as standalone functions using a preparsed
26	* document.
27	*
28	* See Copyright for the status of this software.
29	*
30	* [email protected]
31	*/
32
33	#define IN_LIBXML
34	#include "libxml.h"
35
36	#if defined(WIN32) && !defined (__CYGWIN__)
37	#define XML_DIR_SEP '\\'
38	#else
39	#define XML_DIR_SEP '/'
40	#endif
41
42	#include <stdlib.h>
43	#include <string.h>
44	#include <stdarg.h>
45	#include <libxml/xmlmemory.h>
46	#include <libxml/threads.h>
47	#include <libxml/globals.h>
48	#include <libxml/tree.h>
49	#include <libxml/parser.h>
50	#include <libxml/parserInternals.h>
51	#include <libxml/valid.h>
52	#include <libxml/entities.h>
53	#include <libxml/xmlerror.h>
54	#include <libxml/encoding.h>
55	#include <libxml/xmlIO.h>
56	#include <libxml/uri.h>
57	#ifdef LIBXML_CATALOG_ENABLED
58	#include <libxml/catalog.h>
59	#endif
60	#ifdef LIBXML_SCHEMAS_ENABLED
61	#include <libxml/xmlschemastypes.h>
62	#include <libxml/relaxng.h>
63	#endif
64	#ifdef HAVE_CTYPE_H
65	#include <ctype.h>
66	#endif
67	#ifdef HAVE_STDLIB_H
68	#include <stdlib.h>
69	#endif
70	#ifdef HAVE_SYS_STAT_H
71	#include <sys/stat.h>
72	#endif
73	#ifdef HAVE_FCNTL_H
74	#include <fcntl.h>
75	#endif
76	#ifdef HAVE_UNISTD_H
77	#include <unistd.h>
78	#endif
79	#ifdef HAVE_ZLIB_H
80	#include <zlib.h>
81	#endif
82
83	/**
84	* xmlParserMaxDepth:
85	*
86	* arbitrary depth limit for the XML documents that we allow to
87	* process. This is not a limitation of the parser but a safety
88	* boundary feature.
89	*/
90	unsigned int xmlParserMaxDepth = 1024;
91
92	#define SAX2 1
93
94	#define XML_PARSER_BIG_BUFFER_SIZE 300
95	#define XML_PARSER_BUFFER_SIZE 100
96
97	#define SAX_COMPAT_MODE BAD_CAST "SAX compatibility mode document"
98
99	/*
100	* List of XML prefixed PI allowed by W3C specs
101	*/
102
103	static const char *xmlW3CPIs[] = {
104	"xml-stylesheet",
105	NULL
106	};
107
108
109	/* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */
110	xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,
111	const xmlChar **str);
112
113	static xmlParserErrors
114	xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
115	xmlSAXHandlerPtr sax,
116	void user_data, int depth, const xmlChar URL,
117	const xmlChar ID, xmlNodePtr list);
118
119	#ifdef LIBXML_LEGACY_ENABLED
120	static void
121	xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
122	xmlNodePtr lastNode);
123	#endif /* LIBXML_LEGACY_ENABLED */
124
125	static xmlParserErrors
126	xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
127	const xmlChar string, void user_data, xmlNodePtr *lst);
128
129	/************************************************************************
130	* *
131	* Some factorized error routines *
132	* *
133	************************************************************************/
134
135	/**
136	* xmlErrAttributeDup:
137	* @ctxt: an XML parser context
138	* @prefix: the attribute prefix
139	* @localname: the attribute localname
140	*
141	* Handle a redefinition of attribute error
142	*/
143	static void
144	xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix,
145	const xmlChar * localname)
146	{
147	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
148	(ctxt->instate == XML_PARSER_EOF))
149	return;
150	if (ctxt != NULL)
151	ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
152	if (prefix == NULL)
153	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
154	ctxt->errNo, XML_ERR_FATAL, NULL, 0,
155	(const char *) localname, NULL, NULL, 0, 0,
156	"Attribute %s redefined\n", localname);
157	else
158	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
159	ctxt->errNo, XML_ERR_FATAL, NULL, 0,
160	(const char ) prefix, (const char ) localname,
161	NULL, 0, 0, "Attribute %s:%s redefined\n", prefix,
162	localname);
163	if (ctxt != NULL) {
164	ctxt->wellFormed = 0;
165	if (ctxt->recovery == 0)
166	ctxt->disableSAX = 1;
167	}
168	}
169
170	/**
171	* xmlFatalErr:
172	* @ctxt: an XML parser context
173	* @error: the error number
174	* @extra: extra information string
175	*
176	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
177	*/
178	static void
179	xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info)
180	{
181	const char *errmsg;
182
183	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
184	(ctxt->instate == XML_PARSER_EOF))
185	return;
186	switch (error) {
187	case XML_ERR_INVALID_HEX_CHARREF:
188	errmsg = "CharRef: invalid hexadecimal value\n";
189	break;
190	case XML_ERR_INVALID_DEC_CHARREF:
191	errmsg = "CharRef: invalid decimal value\n";
192	break;
193	case XML_ERR_INVALID_CHARREF:
194	errmsg = "CharRef: invalid value\n";
195	break;
196	case XML_ERR_INTERNAL_ERROR:
197	errmsg = "internal error";
198	break;
199	case XML_ERR_PEREF_AT_EOF:
200	errmsg = "PEReference at end of document\n";
201	break;
202	case XML_ERR_PEREF_IN_PROLOG:
203	errmsg = "PEReference in prolog\n";
204	break;
205	case XML_ERR_PEREF_IN_EPILOG:
206	errmsg = "PEReference in epilog\n";
207	break;
208	case XML_ERR_PEREF_NO_NAME:
209	errmsg = "PEReference: no name\n";
210	break;
211	case XML_ERR_PEREF_SEMICOL_MISSING:
212	errmsg = "PEReference: expecting ';'\n";
213	break;
214	case XML_ERR_ENTITY_LOOP:
215	errmsg = "Detected an entity reference loop\n";
216	break;
217	case XML_ERR_ENTITY_NOT_STARTED:
218	errmsg = "EntityValue: \" or ' expected\n";
219	break;
220	case XML_ERR_ENTITY_PE_INTERNAL:
221	errmsg = "PEReferences forbidden in internal subset\n";
222	break;
223	case XML_ERR_ENTITY_NOT_FINISHED:
224	errmsg = "EntityValue: \" or ' expected\n";
225	break;
226	case XML_ERR_ATTRIBUTE_NOT_STARTED:
227	errmsg = "AttValue: \" or ' expected\n";
228	break;
229	case XML_ERR_LT_IN_ATTRIBUTE:
230	errmsg = "Unescaped '<' not allowed in attributes values\n";
231	break;
232	case XML_ERR_LITERAL_NOT_STARTED:
233	errmsg = "SystemLiteral \" or ' expected\n";
234	break;
235	case XML_ERR_LITERAL_NOT_FINISHED:
236	errmsg = "Unfinished System or Public ID \" or ' expected\n";
237	break;
238	case XML_ERR_MISPLACED_CDATA_END:
239	errmsg = "Sequence ']]>' not allowed in content\n";
240	break;
241	case XML_ERR_URI_REQUIRED:
242	errmsg = "SYSTEM or PUBLIC, the URI is missing\n";
243	break;
244	case XML_ERR_PUBID_REQUIRED:
245	errmsg = "PUBLIC, the Public Identifier is missing\n";
246	break;
247	case XML_ERR_HYPHEN_IN_COMMENT:
248	errmsg = "Comment must not contain '--' (double-hyphen)\n";
249	break;
250	case XML_ERR_PI_NOT_STARTED:
251	errmsg = "xmlParsePI : no target name\n";
252	break;
253	case XML_ERR_RESERVED_XML_NAME:
254	errmsg = "Invalid PI name\n";
255	break;
256	case XML_ERR_NOTATION_NOT_STARTED:
257	errmsg = "NOTATION: Name expected here\n";
258	break;
259	case XML_ERR_NOTATION_NOT_FINISHED:
260	errmsg = "'>' required to close NOTATION declaration\n";
261	break;
262	case XML_ERR_VALUE_REQUIRED:
263	errmsg = "Entity value required\n";
264	break;
265	case XML_ERR_URI_FRAGMENT:
266	errmsg = "Fragment not allowed";
267	break;
268	case XML_ERR_ATTLIST_NOT_STARTED:
269	errmsg = "'(' required to start ATTLIST enumeration\n";
270	break;
271	case XML_ERR_NMTOKEN_REQUIRED:
272	errmsg = "NmToken expected in ATTLIST enumeration\n";
273	break;
274	case XML_ERR_ATTLIST_NOT_FINISHED:
275	errmsg = "')' required to finish ATTLIST enumeration\n";
276	break;
277	case XML_ERR_MIXED_NOT_STARTED:
278	errmsg = "MixedContentDecl : '\|' or ')*' expected\n";
279	break;
280	case XML_ERR_PCDATA_REQUIRED:
281	errmsg = "MixedContentDecl : '#PCDATA' expected\n";
282	break;
283	case XML_ERR_ELEMCONTENT_NOT_STARTED:
284	errmsg = "ContentDecl : Name or '(' expected\n";
285	break;
286	case XML_ERR_ELEMCONTENT_NOT_FINISHED:
287	errmsg = "ContentDecl : ',' '\|' or ')' expected\n";
288	break;
289	case XML_ERR_PEREF_IN_INT_SUBSET:
290	errmsg =
291	"PEReference: forbidden within markup decl in internal subset\n";
292	break;
293	case XML_ERR_GT_REQUIRED:
294	errmsg = "expected '>'\n";
295	break;
296	case XML_ERR_CONDSEC_INVALID:
297	errmsg = "XML conditional section '[' expected\n";
298	break;
299	case XML_ERR_EXT_SUBSET_NOT_FINISHED:
300	errmsg = "Content error in the external subset\n";
301	break;
302	case XML_ERR_CONDSEC_INVALID_KEYWORD:
303	errmsg =
304	"conditional section INCLUDE or IGNORE keyword expected\n";
305	break;
306	case XML_ERR_CONDSEC_NOT_FINISHED:
307	errmsg = "XML conditional section not closed\n";
308	break;
309	case XML_ERR_XMLDECL_NOT_STARTED:
310	errmsg = "Text declaration '<?xml' required\n";
311	break;
312	case XML_ERR_XMLDECL_NOT_FINISHED:
313	errmsg = "parsing XML declaration: '?>' expected\n";
314	break;
315	case XML_ERR_EXT_ENTITY_STANDALONE:
316	errmsg = "external parsed entities cannot be standalone\n";
317	break;
318	case XML_ERR_ENTITYREF_SEMICOL_MISSING:
319	errmsg = "EntityRef: expecting ';'\n";
320	break;
321	case XML_ERR_DOCTYPE_NOT_FINISHED:
322	errmsg = "DOCTYPE improperly terminated\n";
323	break;
324	case XML_ERR_LTSLASH_REQUIRED:
325	errmsg = "EndTag: '</' not found\n";
326	break;
327	case XML_ERR_EQUAL_REQUIRED:
328	errmsg = "expected '='\n";
329	break;
330	case XML_ERR_STRING_NOT_CLOSED:
331	errmsg = "String not closed expecting \" or '\n";
332	break;
333	case XML_ERR_STRING_NOT_STARTED:
334	errmsg = "String not started expecting ' or \"\n";
335	break;
336	case XML_ERR_ENCODING_NAME:
337	errmsg = "Invalid XML encoding name\n";
338	break;
339	case XML_ERR_STANDALONE_VALUE:
340	errmsg = "standalone accepts only 'yes' or 'no'\n";
341	break;
342	case XML_ERR_DOCUMENT_EMPTY:
343	errmsg = "Document is empty\n";
344	break;
345	case XML_ERR_DOCUMENT_END:
346	errmsg = "Extra content at the end of the document\n";
347	break;
348	case XML_ERR_NOT_WELL_BALANCED:
349	errmsg = "chunk is not well balanced\n";
350	break;
351	case XML_ERR_EXTRA_CONTENT:
352	errmsg = "extra content at the end of well balanced chunk\n";
353	break;
354	case XML_ERR_VERSION_MISSING:
355	errmsg = "Malformed declaration expecting version\n";
356	break;
357	#if 0
358	case:
359	errmsg = "\n";
360	break;
361	#endif
362	default:
363	errmsg = "Unregistered error message\n";
364	}
365	if (ctxt != NULL)
366	ctxt->errNo = error;
367	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
368	XML_ERR_FATAL, NULL, 0, info, NULL, NULL, 0, 0, errmsg,
369	info);
370	if (ctxt != NULL) {
371	ctxt->wellFormed = 0;
372	if (ctxt->recovery == 0)
373	ctxt->disableSAX = 1;
374	}
375	}
376
377	/**
378	* xmlFatalErrMsg:
379	* @ctxt: an XML parser context
380	* @error: the error number
381	* @msg: the error message
382	*
383	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
384	*/
385	static void
386	xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
387	const char *msg)
388	{
389	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
390	(ctxt->instate == XML_PARSER_EOF))
391	return;
392	if (ctxt != NULL)
393	ctxt->errNo = error;
394	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
395	XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, msg);
396	if (ctxt != NULL) {
397	ctxt->wellFormed = 0;
398	if (ctxt->recovery == 0)
399	ctxt->disableSAX = 1;
400	}
401	}
402
403	/**
404	* xmlWarningMsg:
405	* @ctxt: an XML parser context
406	* @error: the error number
407	* @msg: the error message
408	* @str1: extra data
409	* @str2: extra data
410	*
411	* Handle a warning.
412	*/
413	static void
414	xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
415	const char msg, const xmlChar str1, const xmlChar *str2)
416	{
417	xmlStructuredErrorFunc schannel = NULL;
418
419	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
420	(ctxt->instate == XML_PARSER_EOF))
421	return;
422	if ((ctxt != NULL) && (ctxt->sax != NULL) &&
423	(ctxt->sax->initialized == XML_SAX2_MAGIC))
424	schannel = ctxt->sax->serror;
425	__xmlRaiseError(schannel,
426	(ctxt->sax) ? ctxt->sax->warning : NULL,
427	ctxt->userData,
428	ctxt, NULL, XML_FROM_PARSER, error,
429	XML_ERR_WARNING, NULL, 0,
430	(const char ) str1, (const char ) str2, NULL, 0, 0,
431	msg, (const char ) str1, (const char ) str2);
432	}
433
434	/**
435	* xmlValidityError:
436	* @ctxt: an XML parser context
437	* @error: the error number
438	* @msg: the error message
439	* @str1: extra data
440	*
441	* Handle a validity error.
442	*/
443	static void
444	xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error,
445	const char msg, const xmlChar str1)
446	{
447	xmlStructuredErrorFunc schannel = NULL;
448
449	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
450	(ctxt->instate == XML_PARSER_EOF))
451	return;
452	if (ctxt != NULL) {
453	ctxt->errNo = error;
454	if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
455	schannel = ctxt->sax->serror;
456	}
457	__xmlRaiseError(schannel,
458	ctxt->vctxt.error, ctxt->vctxt.userData,
459	ctxt, NULL, XML_FROM_DTD, error,
460	XML_ERR_ERROR, NULL, 0, (const char *) str1,
461	NULL, NULL, 0, 0,
462	msg, (const char *) str1);
463	if (ctxt != NULL) {
464	ctxt->valid = 0;
465	}
466	}
467
468	/**
469	* xmlFatalErrMsgInt:
470	* @ctxt: an XML parser context
471	* @error: the error number
472	* @msg: the error message
473	* @val: an integer value
474	*
475	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
476	*/
477	static void
478	xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,
479	const char *msg, int val)
480	{
481	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
482	(ctxt->instate == XML_PARSER_EOF))
483	return;
484	if (ctxt != NULL)
485	ctxt->errNo = error;
486	__xmlRaiseError(NULL, NULL, NULL,
487	ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
488	NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
489	if (ctxt != NULL) {
490	ctxt->wellFormed = 0;
491	if (ctxt->recovery == 0)
492	ctxt->disableSAX = 1;
493	}
494	}
495
496	/**
497	* xmlFatalErrMsgStrIntStr:
498	* @ctxt: an XML parser context
499	* @error: the error number
500	* @msg: the error message
501	* @str1: an string info
502	* @val: an integer value
503	* @str2: an string info
504	*
505	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
506	*/
507	static void
508	xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
509	const char msg, const xmlChar str1, int val,
510	const xmlChar *str2)
511	{
512	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
513	(ctxt->instate == XML_PARSER_EOF))
514	return;
515	if (ctxt != NULL)
516	ctxt->errNo = error;
517	__xmlRaiseError(NULL, NULL, NULL,
518	ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
519	NULL, 0, (const char ) str1, (const char ) str2,
520	NULL, val, 0, msg, str1, val, str2);
521	if (ctxt != NULL) {
522	ctxt->wellFormed = 0;
523	if (ctxt->recovery == 0)
524	ctxt->disableSAX = 1;
525	}
526	}
527
528	/**
529	* xmlFatalErrMsgStr:
530	* @ctxt: an XML parser context
531	* @error: the error number
532	* @msg: the error message
533	* @val: a string value
534	*
535	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
536	*/
537	static void
538	xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
539	const char msg, const xmlChar val)
540	{
541	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
542	(ctxt->instate == XML_PARSER_EOF))
543	return;
544	if (ctxt != NULL)
545	ctxt->errNo = error;
546	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
547	XML_FROM_PARSER, error, XML_ERR_FATAL,
548	NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,
549	val);
550	if (ctxt != NULL) {
551	ctxt->wellFormed = 0;
552	if (ctxt->recovery == 0)
553	ctxt->disableSAX = 1;
554	}
555	}
556
557	/**
558	* xmlErrMsgStr:
559	* @ctxt: an XML parser context
560	* @error: the error number
561	* @msg: the error message
562	* @val: a string value
563	*
564	* Handle a non fatal parser error
565	*/
566	static void
567	xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
568	const char msg, const xmlChar val)
569	{
570	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
571	(ctxt->instate == XML_PARSER_EOF))
572	return;
573	if (ctxt != NULL)
574	ctxt->errNo = error;
575	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
576	XML_FROM_PARSER, error, XML_ERR_ERROR,
577	NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,
578	val);
579	}
580
581	/**
582	* xmlNsErr:
583	* @ctxt: an XML parser context
584	* @error: the error number
585	* @msg: the message
586	* @info1: extra information string
587	* @info2: extra information string
588	*
589	* Handle a fatal parser error, i.e. violating Well-Formedness constraints
590	*/
591	static void
592	xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
593	const char *msg,
594	const xmlChar * info1, const xmlChar * info2,
595	const xmlChar * info3)
596	{
597	if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
598	(ctxt->instate == XML_PARSER_EOF))
599	return;
600	if (ctxt != NULL)
601	ctxt->errNo = error;
602	__xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
603	XML_ERR_ERROR, NULL, 0, (const char *) info1,
604	(const char ) info2, (const char ) info3, 0, 0, msg,
605	info1, info2, info3);
606	if (ctxt != NULL)
607	ctxt->nsWellFormed = 0;
608	}
609
610	/************************************************************************
611	* *
612	* Library wide options *
613	* *
614	************************************************************************/
615
616	/**
617	* xmlHasFeature:
618	* @feature: the feature to be examined
619	*
620	* Examines if the library has been compiled with a given feature.
621	*
622	* Returns a non-zero value if the feature exist, otherwise zero.
623	* Returns zero (0) if the feature does not exist or an unknown
624	* unknown feature is requested, non-zero otherwise.
625	*/
626	int
627	xmlHasFeature(xmlFeature feature)
628	{
629	switch (feature) {
630	case XML_WITH_THREAD:
631	#ifdef LIBXML_THREAD_ENABLED
632	return(1);
633	#else
634	return(0);
635	#endif
636	case XML_WITH_TREE:
637	#ifdef LIBXML_TREE_ENABLED
638	return(1);
639	#else
640	return(0);
641	#endif
642	case XML_WITH_OUTPUT:
643	#ifdef LIBXML_OUTPUT_ENABLED
644	return(1);
645	#else
646	return(0);
647	#endif
648	case XML_WITH_PUSH:
649	#ifdef LIBXML_PUSH_ENABLED
650	return(1);
651	#else
652	return(0);
653	#endif
654	case XML_WITH_READER:
655	#ifdef LIBXML_READER_ENABLED
656	return(1);
657	#else
658	return(0);
659	#endif
660	case XML_WITH_PATTERN:
661	#ifdef LIBXML_PATTERN_ENABLED
662	return(1);
663	#else
664	return(0);
665	#endif
666	case XML_WITH_WRITER:
667	#ifdef LIBXML_WRITER_ENABLED
668	return(1);
669	#else
670	return(0);
671	#endif
672	case XML_WITH_SAX1:
673	#ifdef LIBXML_SAX1_ENABLED
674	return(1);
675	#else
676	return(0);
677	#endif
678	case XML_WITH_FTP:
679	#ifdef LIBXML_FTP_ENABLED
680	return(1);
681	#else
682	return(0);
683	#endif
684	case XML_WITH_HTTP:
685	#ifdef LIBXML_HTTP_ENABLED
686	return(1);
687	#else
688	return(0);
689	#endif
690	case XML_WITH_VALID:
691	#ifdef LIBXML_VALID_ENABLED
692	return(1);
693	#else
694	return(0);
695	#endif
696	case XML_WITH_HTML:
697	#ifdef LIBXML_HTML_ENABLED
698	return(1);
699	#else
700	return(0);
701	#endif
702	case XML_WITH_LEGACY:
703	#ifdef LIBXML_LEGACY_ENABLED
704	return(1);
705	#else
706	return(0);
707	#endif
708	case XML_WITH_C14N:
709	#ifdef LIBXML_C14N_ENABLED
710	return(1);
711	#else
712	return(0);
713	#endif
714	case XML_WITH_CATALOG:
715	#ifdef LIBXML_CATALOG_ENABLED
716	return(1);
717	#else
718	return(0);
719	#endif
720	case XML_WITH_XPATH:
721	#ifdef LIBXML_XPATH_ENABLED
722	return(1);
723	#else
724	return(0);
725	#endif
726	case XML_WITH_XPTR:
727	#ifdef LIBXML_XPTR_ENABLED
728	return(1);
729	#else
730	return(0);
731	#endif
732	case XML_WITH_XINCLUDE:
733	#ifdef LIBXML_XINCLUDE_ENABLED
734	return(1);
735	#else
736	return(0);
737	#endif
738	case XML_WITH_ICONV:
739	#ifdef LIBXML_ICONV_ENABLED
740	return(1);
741	#else
742	return(0);
743	#endif
744	case XML_WITH_ISO8859X:
745	#ifdef LIBXML_ISO8859X_ENABLED
746	return(1);
747	#else
748	return(0);
749	#endif
750	case XML_WITH_UNICODE:
751	#ifdef LIBXML_UNICODE_ENABLED
752	return(1);
753	#else
754	return(0);
755	#endif
756	case XML_WITH_REGEXP:
757	#ifdef LIBXML_REGEXP_ENABLED
758	return(1);
759	#else
760	return(0);
761	#endif
762	case XML_WITH_AUTOMATA:
763	#ifdef LIBXML_AUTOMATA_ENABLED
764	return(1);
765	#else
766	return(0);
767	#endif
768	case XML_WITH_EXPR:
769	#ifdef LIBXML_EXPR_ENABLED
770	return(1);
771	#else
772	return(0);
773	#endif
774	case XML_WITH_SCHEMAS:
775	#ifdef LIBXML_SCHEMAS_ENABLED
776	return(1);
777	#else
778	return(0);
779	#endif
780	case XML_WITH_SCHEMATRON:
781	#ifdef LIBXML_SCHEMATRON_ENABLED
782	return(1);
783	#else
784	return(0);
785	#endif
786	case XML_WITH_MODULES:
787	#ifdef LIBXML_MODULES_ENABLED
788	return(1);
789	#else
790	return(0);
791	#endif
792	case XML_WITH_DEBUG:
793	#ifdef LIBXML_DEBUG_ENABLED
794	return(1);
795	#else
796	return(0);
797	#endif
798	case XML_WITH_DEBUG_MEM:
799	#ifdef DEBUG_MEMORY_LOCATION
800	return(1);
801	#else
802	return(0);
803	#endif
804	case XML_WITH_DEBUG_RUN:
805	#ifdef LIBXML_DEBUG_RUNTIME
806	return(1);
807	#else
808	return(0);
809	#endif
810	case XML_WITH_ZLIB:
811	#ifdef LIBXML_ZLIB_ENABLED
812	return(1);
813	#else
814	return(0);
815	#endif
816	default:
817	break;
818	}
819	return(0);
820	}
821
822	/************************************************************************
823	* *
824	* SAX2 defaulted attributes handling *
825	* *
826	************************************************************************/
827
828	/**
829	* xmlDetectSAX2:
830	* @ctxt: an XML parser context
831	*
832	* Do the SAX2 detection and specific intialization
833	*/
834	static void
835	xmlDetectSAX2(xmlParserCtxtPtr ctxt) {
836	if (ctxt == NULL) return;
837	#ifdef LIBXML_SAX1_ENABLED
838	if ((ctxt->sax) && (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
839	((ctxt->sax->startElementNs != NULL) \|\|
840	(ctxt->sax->endElementNs != NULL))) ctxt->sax2 = 1;
841	#else
842	ctxt->sax2 = 1;
843	#endif /* LIBXML_SAX1_ENABLED */
844
845	ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
846	ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
847	ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
848	if ((ctxt->str_xml==NULL) \|\| (ctxt->str_xmlns==NULL) \|\|
849	(ctxt->str_xml_ns == NULL)) {
850	xmlErrMemory(ctxt, NULL);
851	}
852	}
853
854	typedef struct _xmlDefAttrs xmlDefAttrs;
855	typedef xmlDefAttrs *xmlDefAttrsPtr;
856	struct _xmlDefAttrs {
857	int nbAttrs; /* number of defaulted attributes on that element */
858	int maxAttrs; /* the size of the array */
859	const xmlChar values[4]; / array of localname/prefix/values */
860	};
861
862	/**
863	* xmlAddDefAttrs:
864	* @ctxt: an XML parser context
865	* @fullname: the element fullname
866	* @fullattr: the attribute fullname
867	* @value: the attribute value
868	*
869	* Add a defaulted attribute for an element
870	*/
871	static void
872	xmlAddDefAttrs(xmlParserCtxtPtr ctxt,
873	const xmlChar *fullname,
874	const xmlChar *fullattr,
875	const xmlChar *value) {
876	xmlDefAttrsPtr defaults;
877	int len;
878	const xmlChar *name;
879	const xmlChar *prefix;
880
881	if (ctxt->attsDefault == NULL) {
882	ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict);
883	if (ctxt->attsDefault == NULL)
884	goto mem_error;
885	}
886
887	/*
888	* split the element name into prefix:localname , the string found
889	* are within the DTD and then not associated to namespace names.
890	*/
891	name = xmlSplitQName3(fullname, &len);
892	if (name == NULL) {
893	name = xmlDictLookup(ctxt->dict, fullname, -1);
894	prefix = NULL;
895	} else {
896	name = xmlDictLookup(ctxt->dict, name, -1);
897	prefix = xmlDictLookup(ctxt->dict, fullname, len);
898	}
899
900	/*
901	* make sure there is some storage
902	*/
903	defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix);
904	if (defaults == NULL) {
905	defaults = (xmlDefAttrsPtr) xmlMalloc(sizeof(xmlDefAttrs) +
906	(4 * 4) * sizeof(const xmlChar *));
907	if (defaults == NULL)
908	goto mem_error;
909	defaults->nbAttrs = 0;
910	defaults->maxAttrs = 4;
911	xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix, defaults, NULL);
912	} else if (defaults->nbAttrs >= defaults->maxAttrs) {
913	xmlDefAttrsPtr temp;
914
915	temp = (xmlDefAttrsPtr) xmlRealloc(defaults, sizeof(xmlDefAttrs) +
916	(2 * defaults->maxAttrs * 4) * sizeof(const xmlChar *));
917	if (temp == NULL)
918	goto mem_error;
919	defaults = temp;
920	defaults->maxAttrs *= 2;
921	xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix, defaults, NULL);
922	}
923
924	/*
925	* Split the element name into prefix:localname , the string found
926	* are within the DTD and hen not associated to namespace names.
927	*/
928	name = xmlSplitQName3(fullattr, &len);
929	if (name == NULL) {
930	name = xmlDictLookup(ctxt->dict, fullattr, -1);
931	prefix = NULL;
932	} else {
933	name = xmlDictLookup(ctxt->dict, name, -1);
934	prefix = xmlDictLookup(ctxt->dict, fullattr, len);
935	}
936
937	defaults->values[4 * defaults->nbAttrs] = name;
938	defaults->values[4 * defaults->nbAttrs + 1] = prefix;
939	/* intern the string and precompute the end */
940	len = xmlStrlen(value);
941	value = xmlDictLookup(ctxt->dict, value, len);
942	defaults->values[4 * defaults->nbAttrs + 2] = value;
943	defaults->values[4 * defaults->nbAttrs + 3] = value + len;
944	defaults->nbAttrs++;
945
946	return;
947
948	mem_error:
949	xmlErrMemory(ctxt, NULL);
950	return;
951	}
952
953	/**
954	* xmlAddSpecialAttr:
955	* @ctxt: an XML parser context
956	* @fullname: the element fullname
957	* @fullattr: the attribute fullname
958	* @type: the attribute type
959	*
960	* Register that this attribute is not CDATA
961	*/
962	static void
963	xmlAddSpecialAttr(xmlParserCtxtPtr ctxt,
964	const xmlChar *fullname,
965	const xmlChar *fullattr,
966	int type)
967	{
968	if (ctxt->attsSpecial == NULL) {
969	ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict);
970	if (ctxt->attsSpecial == NULL)
971	goto mem_error;
972	}
973
974	xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr,
975	(void *) (long) type);
976	return;
977
978	mem_error:
979	xmlErrMemory(ctxt, NULL);
980	return;
981	}
982
983	/**
984	* xmlCheckLanguageID:
985	* @lang: pointer to the string value
986	*
987	* Checks that the value conforms to the LanguageID production:
988	*
989	* NOTE: this is somewhat deprecated, those productions were removed from
990	* the XML Second edition.
991	*
992	* [33] LanguageID ::= Langcode ('-' Subcode)*
993	* [34] Langcode ::= ISO639Code \| IanaCode \| UserCode
994	* [35] ISO639Code ::= ([a-z] \| [A-Z]) ([a-z] \| [A-Z])
995	* [36] IanaCode ::= ('i' \| 'I') '-' ([a-z] \| [A-Z])+
996	* [37] UserCode ::= ('x' \| 'X') '-' ([a-z] \| [A-Z])+
997	* [38] Subcode ::= ([a-z] \| [A-Z])+
998	*
999	* Returns 1 if correct 0 otherwise
1000	**/
1001	int
1002	xmlCheckLanguageID(const xmlChar * lang)
1003	{
1004	const xmlChar *cur = lang;
1005
1006	if (cur == NULL)
1007	return (0);
1008	if (((cur[0] == 'i') && (cur[1] == '-')) \|\|
1009	((cur[0] == 'I') && (cur[1] == '-'))) {
1010	/*
1011	* IANA code
1012	*/
1013	cur += 2;
1014	while (((cur[0] >= 'A') && (cur[0] <= 'Z')) \|\| /* non input consuming */
1015	((cur[0] >= 'a') && (cur[0] <= 'z')))
1016	cur++;
1017	} else if (((cur[0] == 'x') && (cur[1] == '-')) \|\|
1018	((cur[0] == 'X') && (cur[1] == '-'))) {
1019	/*
1020	* User code
1021	*/
1022	cur += 2;
1023	while (((cur[0] >= 'A') && (cur[0] <= 'Z')) \|\| /* non input consuming */
1024	((cur[0] >= 'a') && (cur[0] <= 'z')))
1025	cur++;
1026	} else if (((cur[0] >= 'A') && (cur[0] <= 'Z')) \|\|
1027	((cur[0] >= 'a') && (cur[0] <= 'z'))) {
1028	/*
1029	* ISO639
1030	*/
1031	cur++;
1032	if (((cur[0] >= 'A') && (cur[0] <= 'Z')) \|\|
1033	((cur[0] >= 'a') && (cur[0] <= 'z')))
1034	cur++;
1035	else
1036	return (0);
1037	} else
1038	return (0);
1039	while (cur[0] != 0) { /* non input consuming */
1040	if (cur[0] != '-')
1041	return (0);
1042	cur++;
1043	if (((cur[0] >= 'A') && (cur[0] <= 'Z')) \|\|
1044	((cur[0] >= 'a') && (cur[0] <= 'z')))
1045	cur++;
1046	else
1047	return (0);
1048	while (((cur[0] >= 'A') && (cur[0] <= 'Z')) \|\| /* non input consuming */
1049	((cur[0] >= 'a') && (cur[0] <= 'z')))
1050	cur++;
1051	}
1052	return (1);
1053	}
1054
1055	/************************************************************************
1056	* *
1057	* Parser stacks related functions and macros *
1058	* *
1059	************************************************************************/
1060
1061	xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,
1062	const xmlChar ** str);
1063
1064	#ifdef SAX2
1065	/**
1066	* nsPush:
1067	* @ctxt: an XML parser context
1068	* @prefix: the namespace prefix or NULL
1069	* @URL: the namespace name
1070	*
1071	* Pushes a new parser namespace on top of the ns stack
1072	*
1073	* Returns -1 in case of error, -2 if the namespace should be discarded
1074	* and the index in the stack otherwise.
1075	*/
1076	static int
1077	nsPush(xmlParserCtxtPtr ctxt, const xmlChar prefix, const xmlChar URL)
1078	{
1079	if (ctxt->options & XML_PARSE_NSCLEAN) {
1080	int i;
1081	for (i = 0;i < ctxt->nsNr;i += 2) {
1082	if (ctxt->nsTab[i] == prefix) {
1083	/* in scope */
1084	if (ctxt->nsTab[i + 1] == URL)
1085	return(-2);
1086	/* out of scope keep it */
1087	break;
1088	}
1089	}
1090	}
1091	if ((ctxt->nsMax == 0) \|\| (ctxt->nsTab == NULL)) {
1092	ctxt->nsMax = 10;
1093	ctxt->nsNr = 0;
1094	ctxt->nsTab = (const xmlChar **)
1095	xmlMalloc(ctxt->nsMax * sizeof(xmlChar *));
1096	if (ctxt->nsTab == NULL) {
1097	xmlErrMemory(ctxt, NULL);
1098	ctxt->nsMax = 0;
1099	return (-1);
1100	}
1101	} else if (ctxt->nsNr >= ctxt->nsMax) {
1102	ctxt->nsMax *= 2;
1103	ctxt->nsTab = (const xmlChar **)
1104	xmlRealloc((char *) ctxt->nsTab,
1105	ctxt->nsMax * sizeof(ctxt->nsTab[0]));
1106	if (ctxt->nsTab == NULL) {
1107	xmlErrMemory(ctxt, NULL);
1108	ctxt->nsMax /= 2;
1109	return (-1);
1110	}
1111	}
1112	ctxt->nsTab[ctxt->nsNr++] = prefix;
1113	ctxt->nsTab[ctxt->nsNr++] = URL;
1114	return (ctxt->nsNr);
1115	}
1116	/**
1117	* nsPop:
1118	* @ctxt: an XML parser context
1119	* @nr: the number to pop
1120	*
1121	* Pops the top @nr parser prefix/namespace from the ns stack
1122	*
1123	* Returns the number of namespaces removed
1124	*/
1125	static int
1126	nsPop(xmlParserCtxtPtr ctxt, int nr)
1127	{
1128	int i;
1129
1130	if (ctxt->nsTab == NULL) return(0);
1131	if (ctxt->nsNr < nr) {
1132	xmlGenericError(xmlGenericErrorContext, "Pbm popping %d NS\n", nr);
1133	nr = ctxt->nsNr;
1134	}
1135	if (ctxt->nsNr <= 0)
1136	return (0);
1137
1138	for (i = 0;i < nr;i++) {
1139	ctxt->nsNr--;
1140	ctxt->nsTab[ctxt->nsNr] = NULL;
1141	}
1142	return(nr);
1143	}
1144	#endif
1145
1146	static int
1147	xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) {
1148	const xmlChar **atts;
1149	int *attallocs;
1150	int maxatts;
1151
1152	if (ctxt->atts == NULL) {
1153	maxatts = 55; /* allow for 10 attrs by default */
1154	atts = (const xmlChar **)
1155	xmlMalloc(maxatts * sizeof(xmlChar *));
1156	if (atts == NULL) goto mem_error;
1157	ctxt->atts = atts;
1158	attallocs = (int ) xmlMalloc((maxatts / 5) sizeof(int));
1159	if (attallocs == NULL) goto mem_error;
1160	ctxt->attallocs = attallocs;
1161	ctxt->maxatts = maxatts;
1162	} else if (nr + 5 > ctxt->maxatts) {
1163	maxatts = (nr + 5) * 2;
1164	atts = (const xmlChar *) xmlRealloc((void ) ctxt->atts,
1165	maxatts * sizeof(const xmlChar *));
1166	if (atts == NULL) goto mem_error;
1167	ctxt->atts = atts;
1168	attallocs = (int ) xmlRealloc((void ) ctxt->attallocs,
1169	(maxatts / 5) * sizeof(int));
1170	if (attallocs == NULL) goto mem_error;
1171	ctxt->attallocs = attallocs;
1172	ctxt->maxatts = maxatts;
1173	}
1174	return(ctxt->maxatts);
1175	mem_error:
1176	xmlErrMemory(ctxt, NULL);
1177	return(-1);
1178	}
1179
1180	/**
1181	* inputPush:
1182	* @ctxt: an XML parser context
1183	* @value: the parser input
1184	*
1185	* Pushes a new parser input on top of the input stack
1186	*
1187	* Returns 0 in case of error, the index in the stack otherwise
1188	*/
1189	int
1190	inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
1191	{
1192	if ((ctxt == NULL) \|\| (value == NULL))
1193	return(0);
1194	if (ctxt->inputNr >= ctxt->inputMax) {
1195	ctxt->inputMax *= 2;
1196	ctxt->inputTab =
1197	(xmlParserInputPtr *) xmlRealloc(ctxt->inputTab,
1198	ctxt->inputMax *
1199	sizeof(ctxt->inputTab[0]));
1200	if (ctxt->inputTab == NULL) {
1201	xmlErrMemory(ctxt, NULL);
1202	return (0);
1203	}
1204	}
1205	ctxt->inputTab[ctxt->inputNr] = value;
1206	ctxt->input = value;
1207	return (ctxt->inputNr++);
1208	}
1209	/**
1210	* inputPop:
1211	* @ctxt: an XML parser context
1212	*
1213	* Pops the top parser input from the input stack
1214	*
1215	* Returns the input just removed
1216	*/
1217	xmlParserInputPtr
1218	inputPop(xmlParserCtxtPtr ctxt)
1219	{
1220	xmlParserInputPtr ret;
1221
1222	if (ctxt == NULL)
1223	return(NULL);
1224	if (ctxt->inputNr <= 0)
1225	return (NULL);
1226	ctxt->inputNr--;
1227	if (ctxt->inputNr > 0)
1228	ctxt->input = ctxt->inputTab[ctxt->inputNr - 1];
1229	else
1230	ctxt->input = NULL;
1231	ret = ctxt->inputTab[ctxt->inputNr];
1232	ctxt->inputTab[ctxt->inputNr] = NULL;
1233	return (ret);
1234	}
1235	/**
1236	* nodePush:
1237	* @ctxt: an XML parser context
1238	* @value: the element node
1239	*
1240	* Pushes a new element node on top of the node stack
1241	*
1242	* Returns 0 in case of error, the index in the stack otherwise
1243	*/
1244	int
1245	nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value)
1246	{
1247	if (ctxt == NULL) return(0);
1248	if (ctxt->nodeNr >= ctxt->nodeMax) {
1249	xmlNodePtr *tmp;
1250
1251	tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
1252	ctxt->nodeMax * 2 *
1253	sizeof(ctxt->nodeTab[0]));
1254	if (tmp == NULL) {
1255	xmlErrMemory(ctxt, NULL);
1256	return (0);
1257	}
1258	ctxt->nodeTab = tmp;
1259	ctxt->nodeMax *= 2;
1260	}
1261	if (((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) {
1262	xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
1263	"Excessive depth in document: change xmlParserMaxDepth = %d\n",
1264	xmlParserMaxDepth);
1265	ctxt->instate = XML_PARSER_EOF;
1266	return(0);
1267	}
1268	ctxt->nodeTab[ctxt->nodeNr] = value;
1269	ctxt->node = value;
1270	return (ctxt->nodeNr++);
1271	}
1272	/**
1273	* nodePop:
1274	* @ctxt: an XML parser context
1275	*
1276	* Pops the top element node from the node stack
1277	*
1278	* Returns the node just removed
1279	*/
1280	xmlNodePtr
1281	nodePop(xmlParserCtxtPtr ctxt)
1282	{
1283	xmlNodePtr ret;
1284
1285	if (ctxt == NULL) return(NULL);
1286	if (ctxt->nodeNr <= 0)
1287	return (NULL);
1288	ctxt->nodeNr--;
1289	if (ctxt->nodeNr > 0)
1290	ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
1291	else
1292	ctxt->node = NULL;
1293	ret = ctxt->nodeTab[ctxt->nodeNr];
1294	ctxt->nodeTab[ctxt->nodeNr] = NULL;
1295	return (ret);
1296	}
1297
1298	#ifdef LIBXML_PUSH_ENABLED
1299	/**
1300	* nameNsPush:
1301	* @ctxt: an XML parser context
1302	* @value: the element name
1303	* @prefix: the element prefix
1304	* @URI: the element namespace name
1305	*
1306	* Pushes a new element name/prefix/URL on top of the name stack
1307	*
1308	* Returns -1 in case of error, the index in the stack otherwise
1309	*/
1310	static int
1311	nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value,
1312	const xmlChar prefix, const xmlChar URI, int nsNr)
1313	{
1314	if (ctxt->nameNr >= ctxt->nameMax) {
1315	const xmlChar * *tmp;
1316	void **tmp2;
1317	ctxt->nameMax *= 2;
1318	tmp = (const xmlChar * ) xmlRealloc((xmlChar *)ctxt->nameTab,
1319	ctxt->nameMax *
1320	sizeof(ctxt->nameTab[0]));
1321	if (tmp == NULL) {
1322	ctxt->nameMax /= 2;
1323	goto mem_error;
1324	}
1325	ctxt->nameTab = tmp;
1326	tmp2 = (void *) xmlRealloc((void *)ctxt->pushTab,
1327	ctxt->nameMax * 3 *
1328	sizeof(ctxt->pushTab[0]));
1329	if (tmp2 == NULL) {
1330	ctxt->nameMax /= 2;
1331	goto mem_error;
1332	}
1333	ctxt->pushTab = tmp2;
1334	}
1335	ctxt->nameTab[ctxt->nameNr] = value;
1336	ctxt->name = value;
1337	ctxt->pushTab[ctxt->nameNr * 3] = (void *) prefix;
1338	ctxt->pushTab[ctxt->nameNr * 3 + 1] = (void *) URI;
1339	ctxt->pushTab[ctxt->nameNr * 3 + 2] = (void *) (long) nsNr;
1340	return (ctxt->nameNr++);
1341	mem_error:
1342	xmlErrMemory(ctxt, NULL);
1343	return (-1);
1344	}
1345	/**
1346	* nameNsPop:
1347	* @ctxt: an XML parser context
1348	*
1349	* Pops the top element/prefix/URI name from the name stack
1350	*
1351	* Returns the name just removed
1352	*/
1353	static const xmlChar *
1354	nameNsPop(xmlParserCtxtPtr ctxt)
1355	{
1356	const xmlChar *ret;
1357
1358	if (ctxt->nameNr <= 0)
1359	return (NULL);
1360	ctxt->nameNr--;
1361	if (ctxt->nameNr > 0)
1362	ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1363	else
1364	ctxt->name = NULL;
1365	ret = ctxt->nameTab[ctxt->nameNr];
1366	ctxt->nameTab[ctxt->nameNr] = NULL;
1367	return (ret);
1368	}
1369	#endif /* LIBXML_PUSH_ENABLED */
1370
1371	/**
1372	* namePush:
1373	* @ctxt: an XML parser context
1374	* @value: the element name
1375	*
1376	* Pushes a new element name on top of the name stack
1377	*
1378	* Returns -1 in case of error, the index in the stack otherwise
1379	*/
1380	int
1381	namePush(xmlParserCtxtPtr ctxt, const xmlChar * value)
1382	{
1383	if (ctxt == NULL) return (-1);
1384
1385	if (ctxt->nameNr >= ctxt->nameMax) {
1386	const xmlChar * *tmp;
1387	ctxt->nameMax *= 2;
1388	tmp = (const xmlChar * ) xmlRealloc((xmlChar *)ctxt->nameTab,
1389	ctxt->nameMax *
1390	sizeof(ctxt->nameTab[0]));
1391	if (tmp == NULL) {
1392	ctxt->nameMax /= 2;
1393	goto mem_error;
1394	}
1395	ctxt->nameTab = tmp;
1396	}
1397	ctxt->nameTab[ctxt->nameNr] = value;
1398	ctxt->name = value;
1399	return (ctxt->nameNr++);
1400	mem_error:
1401	xmlErrMemory(ctxt, NULL);
1402	return (-1);
1403	}
1404	/**
1405	* namePop:
1406	* @ctxt: an XML parser context
1407	*
1408	* Pops the top element name from the name stack
1409	*
1410	* Returns the name just removed
1411	*/
1412	const xmlChar *
1413	namePop(xmlParserCtxtPtr ctxt)
1414	{
1415	const xmlChar *ret;
1416
1417	if ((ctxt == NULL) \|\| (ctxt->nameNr <= 0))
1418	return (NULL);
1419	ctxt->nameNr--;
1420	if (ctxt->nameNr > 0)
1421	ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1422	else
1423	ctxt->name = NULL;
1424	ret = ctxt->nameTab[ctxt->nameNr];
1425	ctxt->nameTab[ctxt->nameNr] = NULL;
1426	return (ret);
1427	}
1428
1429	static int spacePush(xmlParserCtxtPtr ctxt, int val) {
1430	if (ctxt->spaceNr >= ctxt->spaceMax) {
1431	ctxt->spaceMax *= 2;
1432	ctxt->spaceTab = (int *) xmlRealloc(ctxt->spaceTab,
1433	ctxt->spaceMax * sizeof(ctxt->spaceTab[0]));
1434	if (ctxt->spaceTab == NULL) {
1435	xmlErrMemory(ctxt, NULL);
1436	return(0);
1437	}
1438	}
1439	ctxt->spaceTab[ctxt->spaceNr] = val;
1440	ctxt->space = &ctxt->spaceTab[ctxt->spaceNr];
1441	return(ctxt->spaceNr++);
1442	}
1443
1444	static int spacePop(xmlParserCtxtPtr ctxt) {
1445	int ret;
1446	if (ctxt->spaceNr <= 0) return(0);
1447	ctxt->spaceNr--;
1448	if (ctxt->spaceNr > 0)
1449	ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1];
1450	else
1451	ctxt->space = &ctxt->spaceTab[0];
1452	ret = ctxt->spaceTab[ctxt->spaceNr];
1453	ctxt->spaceTab[ctxt->spaceNr] = -1;
1454	return(ret);
1455	}
1456
1457	/*
1458	* Macros for accessing the content. Those should be used only by the parser,
1459	* and not exported.
1460	*
1461	* Dirty macros, i.e. one often need to make assumption on the context to
1462	* use them
1463	*
1464	* CUR_PTR return the current pointer to the xmlChar to be parsed.
1465	* To be used with extreme caution since operations consuming
1466	* characters may move the input buffer to a different location !
1467	* CUR returns the current xmlChar value, i.e. a 8 bit value if compiled
1468	* This should be used internally by the parser
1469	* only to compare to ASCII values otherwise it would break when
1470	* running with UTF-8 encoding.
1471	* RAW same as CUR but in the input buffer, bypass any token
1472	* extraction that may have been done
1473	* NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only
1474	* to compare on ASCII based substring.
1475	* SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
1476	* strings without newlines within the parser.
1477	* NEXT1(l) Skip 1 xmlChar, and must also be used only to skip 1 non-newline ASCII
1478	* defined char within the parser.
1479	* Clean macros, not dependent of an ASCII context, expect UTF-8 encoding
1480	*
1481	* NEXT Skip to the next character, this does the proper decoding
1482	* in UTF-8 mode. It also pop-up unfinished entities on the fly.
1483	* NEXTL(l) Skip the current unicode character of l xmlChars long.
1484	* CUR_CHAR(l) returns the current unicode character (int), set l
1485	* to the number of xmlChars used for the encoding [0-5].
1486	* CUR_SCHAR same but operate on a string instead of the context
1487	* COPY_BUF copy the current unicode char to the target buffer, increment
1488	* the index
1489	* GROW, SHRINK handling of input buffers
1490	*/
1491
1492	#define RAW (*ctxt->input->cur)
1493	#define CUR (*ctxt->input->cur)
1494	#define NXT(val) ctxt->input->cur[(val)]
1495	#define CUR_PTR ctxt->input->cur
1496
1497	#define CMP4( s, c1, c2, c3, c4 ) \
1498	( ((unsigned char ) s)[ 0 ] == c1 && ((unsigned char ) s)[ 1 ] == c2 && \
1499	((unsigned char ) s)[ 2 ] == c3 && ((unsigned char ) s)[ 3 ] == c4 )
1500	#define CMP5( s, c1, c2, c3, c4, c5 ) \
1501	( CMP4( s, c1, c2, c3, c4 ) && ((unsigned char *) s)[ 4 ] == c5 )
1502	#define CMP6( s, c1, c2, c3, c4, c5, c6 ) \
1503	( CMP5( s, c1, c2, c3, c4, c5 ) && ((unsigned char *) s)[ 5 ] == c6 )
1504	#define CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) \
1505	( CMP6( s, c1, c2, c3, c4, c5, c6 ) && ((unsigned char *) s)[ 6 ] == c7 )
1506	#define CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) \
1507	( CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) && ((unsigned char *) s)[ 7 ] == c8 )
1508	#define CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) \
1509	( CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) && \
1510	((unsigned char *) s)[ 8 ] == c9 )
1511	#define CMP10( s, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10 ) \
1512	( CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) && \
1513	((unsigned char *) s)[ 9 ] == c10 )
1514
1515	#define SKIP(val) do { \
1516	ctxt->nbChars += (val),ctxt->input->cur += (val),ctxt->input->col+=(val); \
1517	if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
1518	if ((*ctxt->input->cur == 0) && \
1519	(xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \
1520	xmlPopInput(ctxt); \
1521	} while (0)
1522
1523	#define SKIPL(val) do { \
1524	int skipl; \
1525	for(skipl=0; skipl<val; skipl++) { \
1526	if (*(ctxt->input->cur) == '\n') { \
1527	ctxt->input->line++; ctxt->input->col = 1; \
1528	} else ctxt->input->col++; \
1529	ctxt->nbChars++; \
1530	ctxt->input->cur++; \
1531	} \
1532	if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
1533	if ((*ctxt->input->cur == 0) && \
1534	(xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \
1535	xmlPopInput(ctxt); \
1536	} while (0)
1537
1538	#define SHRINK if ((ctxt->progressive == 0) && \
1539	(ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
1540	(ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
1541	xmlSHRINK (ctxt);
1542
1543	static void xmlSHRINK (xmlParserCtxtPtr ctxt) {
1544	xmlParserInputShrink(ctxt->input);
1545	if ((*ctxt->input->cur == 0) &&
1546	(xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
1547	xmlPopInput(ctxt);
1548	}
1549
1550	#define GROW if ((ctxt->progressive == 0) && \
1551	(ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)) \
1552	xmlGROW (ctxt);
1553
1554	static void xmlGROW (xmlParserCtxtPtr ctxt) {
1555	xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
1556	if ((*ctxt->input->cur == 0) &&
1557	(xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
1558	xmlPopInput(ctxt);
1559	}
1560
1561	#define SKIP_BLANKS xmlSkipBlankChars(ctxt)
1562
1563	#define NEXT xmlNextChar(ctxt)
1564
1565	#define NEXT1 { \
1566	ctxt->input->col++; \
1567	ctxt->input->cur++; \
1568	ctxt->nbChars++; \
1569	if (*ctxt->input->cur == 0) \
1570	xmlParserInputGrow(ctxt->input, INPUT_CHUNK); \
1571	}
1572
1573	#define NEXTL(l) do { \
1574	if (*(ctxt->input->cur) == '\n') { \
1575	ctxt->input->line++; ctxt->input->col = 1; \
1576	} else ctxt->input->col++; \
1577	ctxt->input->cur += l; \
1578	if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
1579	} while (0)
1580
1581	#define CUR_CHAR(l) xmlCurrentChar(ctxt, &l)
1582	#define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)
1583
1584	#define COPY_BUF(l,b,i,v) \
1585	if (l == 1) b[i++] = (xmlChar) v; \
1586	else i += xmlCopyCharMultiByte(&b[i],v)
1587
1588	/**
1589	* xmlSkipBlankChars:
1590	* @ctxt: the XML parser context
1591	*
1592	* skip all blanks character found at that point in the input streams.
1593	* It pops up finished entities in the process if allowable at that point.
1594	*
1595	* Returns the number of space chars skipped
1596	*/
1597
1598	int
1599	xmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
1600	int res = 0;
1601
1602	/*
1603	* It's Okay to use CUR/NEXT here since all the blanks are on
1604	* the ASCII range.
1605	*/
1606	if ((ctxt->inputNr == 1) && (ctxt->instate != XML_PARSER_DTD)) {
1607	const xmlChar *cur;
1608	/*
1609	* if we are in the document content, go really fast
1610	*/
1611	cur = ctxt->input->cur;
1612	while (IS_BLANK_CH(*cur)) {
1613	if (*cur == '\n') {
1614	ctxt->input->line++; ctxt->input->col = 1;
1615	}
1616	cur++;
1617	res++;
1618	if (*cur == 0) {
1619	ctxt->input->cur = cur;
1620	xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
1621	cur = ctxt->input->cur;
1622	}
1623	}
1624	ctxt->input->cur = cur;
1625	} else {
1626	int cur;
1627	do {
1628	cur = CUR;
1629	while (IS_BLANK_CH(cur)) { /* CHECKED tstblanks.xml */
1630	NEXT;
1631	cur = CUR;
1632	res++;
1633	}
1634	while ((cur == 0) && (ctxt->inputNr > 1) &&
1635	(ctxt->instate != XML_PARSER_COMMENT)) {
1636	xmlPopInput(ctxt);
1637	cur = CUR;
1638	}
1639	/*
1640	* Need to handle support of entities branching here
1641	*/
1642	if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);
1643	} while (IS_BLANK(cur)); /* CHECKED tstblanks.xml */
1644	}
1645	return(res);
1646	}
1647
1648	/************************************************************************
1649	* *
1650	* Commodity functions to handle entities *
1651	* *
1652	************************************************************************/
1653
1654	/**
1655	* xmlPopInput:
1656	* @ctxt: an XML parser context
1657	*
1658	* xmlPopInput: the current input pointed by ctxt->input came to an end
1659	* pop it and return the next char.
1660	*
1661	* Returns the current xmlChar in the parser context
1662	*/
1663	xmlChar
1664	xmlPopInput(xmlParserCtxtPtr ctxt) {
1665	if ((ctxt == NULL) \|\| (ctxt->inputNr <= 1)) return(0);
1666	if (xmlParserDebugEntities)
1667	xmlGenericError(xmlGenericErrorContext,
1668	"Popping input %d\n", ctxt->inputNr);
1669	xmlFreeInputStream(inputPop(ctxt));
1670	if ((*ctxt->input->cur == 0) &&
1671	(xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
1672	return(xmlPopInput(ctxt));
1673	return(CUR);
1674	}
1675
1676	/**
1677	* xmlPushInput:
1678	* @ctxt: an XML parser context
1679	* @input: an XML parser input fragment (entity, XML fragment ...).
1680	*
1681	* xmlPushInput: switch to a new input stream which is stacked on top
1682	* of the previous one(s).
1683	*/
1684	void
1685	xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) {
1686	if (input == NULL) return;
1687
1688	if (xmlParserDebugEntities) {
1689	if ((ctxt->input != NULL) && (ctxt->input->filename))
1690	xmlGenericError(xmlGenericErrorContext,
1691	"%s(%d): ", ctxt->input->filename,
1692	ctxt->input->line);
1693	xmlGenericError(xmlGenericErrorContext,
1694	"Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur);
1695	}
1696	inputPush(ctxt, input);
1697	GROW;
1698	}
1699
1700	/**
1701	* xmlParseCharRef:
1702	* @ctxt: an XML parser context
1703	*
1704	* parse Reference declarations
1705	*
1706	* [66] CharRef ::= '&#' [0-9]+ ';' \|
1707	* '&#x' [0-9a-fA-F]+ ';'
1708	*
1709	* [ WFC: Legal Character ]
1710	* Characters referred to using character references must match the
1711	* production for Char.
1712	*
1713	* Returns the value parsed (as an int), 0 in case of error
1714	*/
1715	int
1716	xmlParseCharRef(xmlParserCtxtPtr ctxt) {
1717	unsigned int val = 0;
1718	int count = 0;
1719	unsigned int outofrange = 0;
1720
1721	/*
1722	* Using RAW/CUR/NEXT is okay since we are working on ASCII range here
1723	*/
1724	if ((RAW == '&') && (NXT(1) == '#') &&
1725	(NXT(2) == 'x')) {
1726	SKIP(3);
1727	GROW;
1728	while (RAW != ';') { /* loop blocked by count */
1729	if (count++ > 20) {
1730	count = 0;
1731	GROW;
1732	}
1733	if ((RAW >= '0') && (RAW <= '9'))
1734	val = val * 16 + (CUR - '0');
1735	else if ((RAW >= 'a') && (RAW <= 'f') && (count < 20))
1736	val = val * 16 + (CUR - 'a') + 10;
1737	else if ((RAW >= 'A') && (RAW <= 'F') && (count < 20))
1738	val = val * 16 + (CUR - 'A') + 10;
1739	else {
1740	xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
1741	val = 0;
1742	break;
1743	}
1744	if (val > 0x10FFFF)
1745	outofrange = val;
1746
1747	NEXT;
1748	count++;
1749	}
1750	if (RAW == ';') {
1751	/* on purpose to avoid reentrancy problems with NEXT and SKIP */
1752	ctxt->input->col++;
1753	ctxt->nbChars ++;
1754	ctxt->input->cur++;
1755	}
1756	} else if ((RAW == '&') && (NXT(1) == '#')) {
1757	SKIP(2);
1758	GROW;
1759	while (RAW != ';') { /* loop blocked by count */
1760	if (count++ > 20) {
1761	count = 0;
1762	GROW;
1763	}
1764	if ((RAW >= '0') && (RAW <= '9'))
1765	val = val * 10 + (CUR - '0');
1766	else {
1767	xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
1768	val = 0;
1769	break;
1770	}
1771	if (val > 0x10FFFF)
1772	outofrange = val;
1773
1774	NEXT;
1775	count++;
1776	}
1777	if (RAW == ';') {
1778	/* on purpose to avoid reentrancy problems with NEXT and SKIP */
1779	ctxt->input->col++;
1780	ctxt->nbChars ++;
1781	ctxt->input->cur++;
1782	}
1783	} else {
1784	xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
1785	}
1786
1787	/*
1788	* [ WFC: Legal Character ]
1789	* Characters referred to using character references must match the
1790	* production for Char.
1791	*/
1792	if ((IS_CHAR(val) && (outofrange == 0))) {
1793	return(val);
1794	} else {
1795	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
1796	"xmlParseCharRef: invalid xmlChar value %d\n",
1797	val);
1798	}
1799	return(0);
1800	}
1801
1802	/**
1803	* xmlParseStringCharRef:
1804	* @ctxt: an XML parser context
1805	* @str: a pointer to an index in the string
1806	*
1807	* parse Reference declarations, variant parsing from a string rather
1808	* than an an input flow.
1809	*
1810	* [66] CharRef ::= '&#' [0-9]+ ';' \|
1811	* '&#x' [0-9a-fA-F]+ ';'
1812	*
1813	* [ WFC: Legal Character ]
1814	* Characters referred to using character references must match the
1815	* production for Char.
1816	*
1817	* Returns the value parsed (as an int), 0 in case of error, str will be
1818	* updated to the current value of the index
1819	*/
1820	static int
1821	xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) {
1822	const xmlChar *ptr;
1823	xmlChar cur;
1824	unsigned int val = 0;
1825	unsigned int outofrange = 0;
1826
1827	if ((str == NULL) \|\| (*str == NULL)) return(0);
1828	ptr = *str;
1829	cur = *ptr;
1830	if ((cur == '&') && (ptr[1] == '#') && (ptr[2] == 'x')) {
1831	ptr += 3;
1832	cur = *ptr;
1833	while (cur != ';') { /* Non input consuming loop */
1834	if ((cur >= '0') && (cur <= '9'))
1835	val = val * 16 + (cur - '0');
1836	else if ((cur >= 'a') && (cur <= 'f'))
1837	val = val * 16 + (cur - 'a') + 10;
1838	else if ((cur >= 'A') && (cur <= 'F'))
1839	val = val * 16 + (cur - 'A') + 10;
1840	else {
1841	xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
1842	val = 0;
1843	break;
1844	}
1845	if (val > 0x10FFFF)
1846	outofrange = val;
1847
1848	ptr++;
1849	cur = *ptr;
1850	}
1851	if (cur == ';')
1852	ptr++;
1853	} else if ((cur == '&') && (ptr[1] == '#')){
1854	ptr += 2;
1855	cur = *ptr;
1856	while (cur != ';') { /* Non input consuming loops */
1857	if ((cur >= '0') && (cur <= '9'))
1858	val = val * 10 + (cur - '0');
1859	else {
1860	xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
1861	val = 0;
1862	break;
1863	}
1864	if (val > 0x10FFFF)
1865	outofrange = val;
1866
1867	ptr++;
1868	cur = *ptr;
1869	}
1870	if (cur == ';')
1871	ptr++;
1872	} else {
1873	xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
1874	return(0);
1875	}
1876	*str = ptr;
1877
1878	/*
1879	* [ WFC: Legal Character ]
1880	* Characters referred to using character references must match the
1881	* production for Char.
1882	*/
1883	if ((IS_CHAR(val) && (outofrange == 0))) {
1884	return(val);
1885	} else {
1886	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
1887	"xmlParseStringCharRef: invalid xmlChar value %d\n",
1888	val);
1889	}
1890	return(0);
1891	}
1892
1893	/**
1894	* xmlNewBlanksWrapperInputStream:
1895	* @ctxt: an XML parser context
1896	* @entity: an Entity pointer
1897	*
1898	* Create a new input stream for wrapping
1899	* blanks around a PEReference
1900	*
1901	* Returns the new input stream or NULL
1902	*/
1903
1904	static void deallocblankswrapper (xmlChar *str) {xmlFree(str);}
1905
1906	static xmlParserInputPtr
1907	xmlNewBlanksWrapperInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
1908	xmlParserInputPtr input;
1909	xmlChar *buffer;
1910	size_t length;
1911	if (entity == NULL) {
1912	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
1913	"xmlNewBlanksWrapperInputStream entity\n");
1914	return(NULL);
1915	}
1916	if (xmlParserDebugEntities)
1917	xmlGenericError(xmlGenericErrorContext,
1918	"new blanks wrapper for entity: %s\n", entity->name);
1919	input = xmlNewInputStream(ctxt);
1920	if (input == NULL) {
1921	return(NULL);
1922	}
1923	length = xmlStrlen(entity->name) + 5;
1924	buffer = xmlMallocAtomic(length);
1925	if (buffer == NULL) {
1926	xmlErrMemory(ctxt, NULL);
1927	return(NULL);
1928	}
1929	buffer [0] = ' ';
1930	buffer [1] = '%';
1931	buffer [length-3] = ';';
1932	buffer [length-2] = ' ';
1933	buffer [length-1] = 0;
1934	memcpy(buffer + 2, entity->name, length - 5);
1935	input->free = deallocblankswrapper;
1936	input->base = buffer;
1937	input->cur = buffer;
1938	input->length = length;
1939	input->end = &buffer[length];
1940	return(input);
1941	}
1942
1943	/**
1944	* xmlParserHandlePEReference:
1945	* @ctxt: the parser context
1946	*
1947	* [69] PEReference ::= '%' Name ';'
1948	*
1949	* [ WFC: No Recursion ]
1950	* A parsed entity must not contain a recursive
1951	* reference to itself, either directly or indirectly.
1952	*
1953	* [ WFC: Entity Declared ]
1954	* In a document without any DTD, a document with only an internal DTD
1955	* subset which contains no parameter entity references, or a document
1956	* with "standalone='yes'", ... ... The declaration of a parameter
1957	* entity must precede any reference to it...
1958	*
1959	* [ VC: Entity Declared ]
1960	* In a document with an external subset or external parameter entities
1961	* with "standalone='no'", ... ... The declaration of a parameter entity
1962	* must precede any reference to it...
1963	*
1964	* [ WFC: In DTD ]
1965	* Parameter-entity references may only appear in the DTD.
1966	* NOTE: misleading but this is handled.
1967	*
1968	* A PEReference may have been detected in the current input stream
1969	* the handling is done accordingly to
1970	* http://www.w3.org/TR/REC-xml#entproc
1971	* i.e.
1972	* - Included in literal in entity values
1973	* - Included as Parameter Entity reference within DTDs
1974	*/
1975	void
1976	xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) {
1977	const xmlChar *name;
1978	xmlEntityPtr entity = NULL;
1979	xmlParserInputPtr input;
1980
1981	if (RAW != '%') return;
1982	switch(ctxt->instate) {
1983	case XML_PARSER_CDATA_SECTION:
1984	return;
1985	case XML_PARSER_COMMENT:
1986	return;
1987	case XML_PARSER_START_TAG:
1988	return;
1989	case XML_PARSER_END_TAG:
1990	return;
1991	case XML_PARSER_EOF:
1992	xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL);
1993	return;
1994	case XML_PARSER_PROLOG:
1995	case XML_PARSER_START:
1996	case XML_PARSER_MISC:
1997	xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL);
1998	return;
1999	case XML_PARSER_ENTITY_DECL:
2000	case XML_PARSER_CONTENT:
2001	case XML_PARSER_ATTRIBUTE_VALUE:
2002	case XML_PARSER_PI:
2003	case XML_PARSER_SYSTEM_LITERAL:
2004	case XML_PARSER_PUBLIC_LITERAL:
2005	/* we just ignore it there */
2006	return;
2007	case XML_PARSER_EPILOG:
2008	xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL);
2009	return;
2010	case XML_PARSER_ENTITY_VALUE:
2011	/*
2012	* NOTE: in the case of entity values, we don't do the
2013	* substitution here since we need the literal
2014	* entity value to be able to save the internal
2015	* subset of the document.
2016	* This will be handled by xmlStringDecodeEntities
2017	*/
2018	return;
2019	case XML_PARSER_DTD:
2020	/*
2021	* [WFC: Well-Formedness Constraint: PEs in Internal Subset]
2022	* In the internal DTD subset, parameter-entity references
2023	* can occur only where markup declarations can occur, not
2024	* within markup declarations.
2025	* In that case this is handled in xmlParseMarkupDecl
2026	*/
2027	if ((ctxt->external == 0) && (ctxt->inputNr == 1))
2028	return;
2029	if (IS_BLANK_CH(NXT(1)) \|\| NXT(1) == 0)
2030	return;
2031	break;
2032	case XML_PARSER_IGNORE:
2033	return;
2034	}
2035
2036	NEXT;
2037	name = xmlParseName(ctxt);
2038	if (xmlParserDebugEntities)
2039	xmlGenericError(xmlGenericErrorContext,
2040	"PEReference: %s\n", name);
2041	if (name == NULL) {
2042	xmlFatalErr(ctxt, XML_ERR_PEREF_NO_NAME, NULL);
2043	} else {
2044	if (RAW == ';') {
2045	NEXT;
2046	if ((ctxt->sax != NULL) && (ctxt->sax->getParameterEntity != NULL))
2047	entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
2048	if (entity == NULL) {
2049
2050	/*
2051	* [ WFC: Entity Declared ]
2052	* In a document without any DTD, a document with only an
2053	* internal DTD subset which contains no parameter entity
2054	* references, or a document with "standalone='yes'", ...
2055	* ... The declaration of a parameter entity must precede
2056	* any reference to it...
2057	*/
2058	if ((ctxt->standalone == 1) \|\|
2059	((ctxt->hasExternalSubset == 0) &&
2060	(ctxt->hasPErefs == 0))) {
2061	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
2062	"PEReference: %%%s; not found\n", name);
2063	} else {
2064	/*
2065	* [ VC: Entity Declared ]
2066	* In a document with an external subset or external
2067	* parameter entities with "standalone='no'", ...
2068	* ... The declaration of a parameter entity must precede
2069	* any reference to it...
2070	*/
2071	if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) {
2072	xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
2073	"PEReference: %%%s; not found\n",
2074	name);
2075	} else
2076	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
2077	"PEReference: %%%s; not found\n",
2078	name, NULL);
2079	ctxt->valid = 0;
2080	}
2081	} else if (ctxt->input->free != deallocblankswrapper) {
2082	input = xmlNewBlanksWrapperInputStream(ctxt, entity);
2083	xmlPushInput(ctxt, input);
2084	} else {
2085	if ((entity->etype == XML_INTERNAL_PARAMETER_ENTITY) \|\|
2086	(entity->etype == XML_EXTERNAL_PARAMETER_ENTITY)) {
2087	xmlChar start[4];
2088	xmlCharEncoding enc;
2089
2090	/*
2091	* handle the extra spaces added before and after
2092	* c.f. http://www.w3.org/TR/REC-xml#as-PE
2093	* this is done independently.
2094	*/
2095	input = xmlNewEntityInputStream(ctxt, entity);
2096	xmlPushInput(ctxt, input);
2097
2098	/*
2099	* Get the 4 first bytes and decode the charset
2100	* if enc != XML_CHAR_ENCODING_NONE
2101	* plug some encoding conversion routines.
2102	* Note that, since we may have some non-UTF8
2103	* encoding (like UTF16, bug 135229), the 'length'
2104	* is not known, but we can calculate based upon
2105	* the amount of data in the buffer.
2106	*/
2107	GROW
2108	if ((ctxt->input->end - ctxt->input->cur)>=4) {
2109	start[0] = RAW;
2110	start[1] = NXT(1);
2111	start[2] = NXT(2);
2112	start[3] = NXT(3);
2113	enc = xmlDetectCharEncoding(start, 4);
2114	if (enc != XML_CHAR_ENCODING_NONE) {
2115	xmlSwitchEncoding(ctxt, enc);
2116	}
2117	}
2118
2119	if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
2120	(CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l' )) &&
2121	(IS_BLANK_CH(NXT(5)))) {
2122	xmlParseTextDecl(ctxt);
2123	}
2124	} else {
2125	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
2126	"PEReference: %s is not a parameter entity\n",
2127	name);
2128	}
2129	}
2130	} else {
2131	xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
2132	}
2133	}
2134	}
2135
2136	/*
2137	* Macro used to grow the current buffer.
2138	*/
2139	#define growBuffer(buffer) { \
2140	xmlChar *tmp; \
2141	buffer##_size *= 2; \
2142	tmp = (xmlChar *) \
2143	xmlRealloc(buffer, buffer##_size * sizeof(xmlChar)); \
2144	if (tmp == NULL) goto mem_error; \
2145	buffer = tmp; \
2146	}
2147
2148	/**
2149	* xmlStringLenDecodeEntities:
2150	* @ctxt: the parser context
2151	* @str: the input string
2152	* @len: the string length
2153	* @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
2154	* @end: an end marker xmlChar, 0 if none
2155	* @end2: an end marker xmlChar, 0 if none
2156	* @end3: an end marker xmlChar, 0 if none
2157	*
2158	* Takes a entity string content and process to do the adequate substitutions.
2159	*
2160	* [67] Reference ::= EntityRef \| CharRef
2161	*
2162	* [69] PEReference ::= '%' Name ';'
2163	*
2164	* Returns A newly allocated string with the substitution done. The caller
2165	* must deallocate it !
2166	*/
2167	xmlChar *
2168	xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2169	int what, xmlChar end, xmlChar end2, xmlChar end3) {
2170	xmlChar *buffer = NULL;
2171	int buffer_size = 0;
2172
2173	xmlChar *current = NULL;
2174	const xmlChar *last;
2175	xmlEntityPtr ent;
2176	int c,l;
2177	int nbchars = 0;
2178
2179	if ((ctxt == NULL) \|\| (str == NULL) \|\| (len < 0))
2180	return(NULL);
2181	last = str + len;
2182
2183	if (ctxt->depth > 40) {
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 ((ent != NULL) &&
2222	(ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
2223	if (ent->content != NULL) {
2224	COPY_BUF(0,buffer,nbchars,ent->content[0]);
2225	if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
2226	growBuffer(buffer);
2227	}
2228	} else {
2229	xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
2230	"predefined entity has no content\n");
2231	}
2232	} else if ((ent != NULL) && (ent->content != NULL)) {
2233	xmlChar *rep;
2234
2235	ctxt->depth++;
2236	rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2237	0, 0, 0);
2238	ctxt->depth--;
2239	if (rep != NULL) {
2240	current = rep;
2241	while (current != 0) { / non input consuming loop */
2242	buffer[nbchars++] = *current++;
2243	if (nbchars >
2244	buffer_size - XML_PARSER_BUFFER_SIZE) {
2245	growBuffer(buffer);
2246	}
2247	}
2248	xmlFree(rep);
2249	}
2250	} else if (ent != NULL) {
2251	int i = xmlStrlen(ent->name);
2252	const xmlChar *cur = ent->name;
2253
2254	buffer[nbchars++] = '&';
2255	if (nbchars > buffer_size - i - XML_PARSER_BUFFER_SIZE) {
2256	growBuffer(buffer);
2257	}
2258	for (;i > 0;i--)
2259	buffer[nbchars++] = *cur++;
2260	buffer[nbchars++] = ';';
2261	}
2262	} else if (c == '%' && (what & XML_SUBSTITUTE_PEREF)) {
2263	if (xmlParserDebugEntities)
2264	xmlGenericError(xmlGenericErrorContext,
2265	"String decoding PE Reference: %.30s\n", str);
2266	ent = xmlParseStringPEReference(ctxt, &str);
2267	if (ent != NULL) {
2268	xmlChar *rep;
2269
2270	ctxt->depth++;
2271	rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2272	0, 0, 0);
2273	ctxt->depth--;
2274	if (rep != NULL) {
2275	current = rep;
2276	while (current != 0) { / non input consuming loop */
2277	buffer[nbchars++] = *current++;
2278	if (nbchars >
2279	buffer_size - XML_PARSER_BUFFER_SIZE) {
2280	growBuffer(buffer);
2281	}
2282	}
2283	xmlFree(rep);
2284	}
2285	}
2286	} else {
2287	COPY_BUF(l,buffer,nbchars,c);
2288	str += l;
2289	if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
2290	growBuffer(buffer);
2291	}
2292	}
2293	if (str < last)
2294	c = CUR_SCHAR(str, l);
2295	else
2296	c = 0;
2297	}
2298	buffer[nbchars++] = 0;
2299	return(buffer);
2300
2301	mem_error:
2302	xmlErrMemory(ctxt, NULL);
2303	return(NULL);
2304	}
2305
2306	/**
2307	* xmlStringDecodeEntities:
2308	* @ctxt: the parser context
2309	* @str: the input string
2310	* @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
2311	* @end: an end marker xmlChar, 0 if none
2312	* @end2: an end marker xmlChar, 0 if none
2313	* @end3: an end marker xmlChar, 0 if none
2314	*
2315	* Takes a entity string content and process to do the adequate substitutions.
2316	*
2317	* [67] Reference ::= EntityRef \| CharRef
2318	*
2319	* [69] PEReference ::= '%' Name ';'
2320	*
2321	* Returns A newly allocated string with the substitution done. The caller
2322	* must deallocate it !
2323	*/
2324	xmlChar *
2325	xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what,
2326	xmlChar end, xmlChar end2, xmlChar end3) {
2327	if ((ctxt == NULL) \|\| (str == NULL)) return(NULL);
2328	return(xmlStringLenDecodeEntities(ctxt, str, xmlStrlen(str), what,
2329	end, end2, end3));
2330	}
2331
2332	/************************************************************************
2333	* *
2334	* Commodity functions, cleanup needed ? *
2335	* *
2336	************************************************************************/
2337
2338	/**
2339	* areBlanks:
2340	* @ctxt: an XML parser context
2341	* @str: a xmlChar *
2342	* @len: the size of @str
2343	* @blank_chars: we know the chars are blanks
2344	*
2345	* Is this a sequence of blank chars that one can ignore ?
2346	*
2347	* Returns 1 if ignorable 0 otherwise.
2348	*/
2349
2350	static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2351	int blank_chars) {
2352	int i, ret;
2353	xmlNodePtr lastChild;
2354
2355	/*
2356	* Don't spend time trying to differentiate them, the same callback is
2357	* used !
2358	*/
2359	if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters)
2360	return(0);
2361
2362	/*
2363	* Check for xml:space value.
2364	*/
2365	if ((ctxt->space == NULL) \|\| (*(ctxt->space) == 1) \|\|
2366	(*(ctxt->space) == -2))
2367	return(0);
2368
2369	/*
2370	* Check that the string is made of blanks
2371	*/
2372	if (blank_chars == 0) {
2373	for (i = 0;i < len;i++)
2374	if (!(IS_BLANK_CH(str[i]))) return(0);
2375	}
2376
2377	/*
2378	* Look if the element is mixed content in the DTD if available
2379	*/
2380	if (ctxt->node == NULL) return(0);
2381	if (ctxt->myDoc != NULL) {
2382	ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name);
2383	if (ret == 0) return(1);
2384	if (ret == 1) return(0);
2385	}
2386
2387	/*
2388	* Otherwise, heuristic :-\
2389	*/
2390	if ((RAW != '<') && (RAW != 0xD)) return(0);
2391	if ((ctxt->node->children == NULL) &&
2392	(RAW == '<') && (NXT(1) == '/')) return(0);
2393
2394	lastChild = xmlGetLastChild(ctxt->node);
2395	if (lastChild == NULL) {
2396	if ((ctxt->node->type != XML_ELEMENT_NODE) &&
2397	(ctxt->node->content != NULL)) return(0);
2398	} else if (xmlNodeIsText(lastChild))
2399	return(0);
2400	else if ((ctxt->node->children != NULL) &&
2401	(xmlNodeIsText(ctxt->node->children)))
2402	return(0);
2403	return(1);
2404	}
2405
2406	/************************************************************************
2407	* *
2408	* Extra stuff for namespace support *
2409	* Relates to http://www.w3.org/TR/WD-xml-names *
2410	* *
2411	************************************************************************/
2412
2413	/**
2414	* xmlSplitQName:
2415	* @ctxt: an XML parser context
2416	* @name: an XML parser context
2417	* @prefix: a xmlChar **
2418	*
2419	* parse an UTF8 encoded XML qualified name string
2420	*
2421	* [NS 5] QName ::= (Prefix ':')? LocalPart
2422	*
2423	* [NS 6] Prefix ::= NCName
2424	*
2425	* [NS 7] LocalPart ::= NCName
2426	*
2427	* Returns the local part, and prefix is updated
2428	* to get the Prefix if any.
2429	*/
2430
2431	xmlChar *
2432	xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar name, xmlChar *prefix) {
2433	xmlChar buf[XML_MAX_NAMELEN + 5];
2434	xmlChar *buffer = NULL;
2435	int len = 0;
2436	int max = XML_MAX_NAMELEN;
2437	xmlChar *ret = NULL;
2438	const xmlChar *cur = name;
2439	int c;
2440
2441	if (prefix == NULL) return(NULL);
2442	*prefix = NULL;
2443
2444	if (cur == NULL) return(NULL);
2445
2446	#ifndef XML_XML_NAMESPACE
2447	/* xml: prefix is not really a namespace */
2448	if ((cur[0] == 'x') && (cur[1] == 'm') &&
2449	(cur[2] == 'l') && (cur[3] == ':'))
2450	return(xmlStrdup(name));
2451	#endif
2452
2453	/* nasty but well=formed */
2454	if (cur[0] == ':')
2455	return(xmlStrdup(name));
2456
2457	c = *cur++;
2458	while ((c != 0) && (c != ':') && (len < max)) { /* tested bigname.xml */
2459	buf[len++] = c;
2460	c = *cur++;
2461	}
2462	if (len >= max) {
2463	/*
2464	* Okay someone managed to make a huge name, so he's ready to pay
2465	* for the processing speed.
2466	*/
2467	max = len * 2;
2468
2469	buffer = (xmlChar ) xmlMallocAtomic(max sizeof(xmlChar));
2470	if (buffer == NULL) {
2471	xmlErrMemory(ctxt, NULL);
2472	return(NULL);
2473	}
2474	memcpy(buffer, buf, len);
2475	while ((c != 0) && (c != ':')) { /* tested bigname.xml */
2476	if (len + 10 > max) {
2477	xmlChar *tmp;
2478
2479	max *= 2;
2480	tmp = (xmlChar *) xmlRealloc(buffer,
2481	max * sizeof(xmlChar));
2482	if (tmp == NULL) {
2483	xmlFree(tmp);
2484	xmlErrMemory(ctxt, NULL);
2485	return(NULL);
2486	}
2487	buffer = tmp;
2488	}
2489	buffer[len++] = c;
2490	c = *cur++;
2491	}
2492	buffer[len] = 0;
2493	}
2494
2495	if ((c == ':') && (*cur == 0)) {
2496	if (buffer != NULL)
2497	xmlFree(buffer);
2498	*prefix = NULL;
2499	return(xmlStrdup(name));
2500	}
2501
2502	if (buffer == NULL)
2503	ret = xmlStrndup(buf, len);
2504	else {
2505	ret = buffer;
2506	buffer = NULL;
2507	max = XML_MAX_NAMELEN;
2508	}
2509
2510
2511	if (c == ':') {
2512	c = *cur;
2513	*prefix = ret;
2514	if (c == 0) {
2515	return(xmlStrndup(BAD_CAST "", 0));
2516	}
2517	len = 0;
2518
2519	/*
2520	* Check that the first character is proper to start
2521	* a new name
2522	*/
2523	if (!(((c >= 0x61) && (c <= 0x7A)) \|\|
2524	((c >= 0x41) && (c <= 0x5A)) \|\|
2525	(c == '_') \|\| (c == ':'))) {
2526	int l;
2527	int first = CUR_SCHAR(cur, l);
2528
2529	if (!IS_LETTER(first) && (first != '_')) {
2530	xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME,
2531	"Name %s is not XML Namespace compliant\n",
2532	name);
2533	}
2534	}
2535	cur++;
2536
2537	while ((c != 0) && (len < max)) { /* tested bigname2.xml */
2538	buf[len++] = c;
2539	c = *cur++;
2540	}
2541	if (len >= max) {
2542	/*
2543	* Okay someone managed to make a huge name, so he's ready to pay
2544	* for the processing speed.
2545	*/
2546	max = len * 2;
2547
2548	buffer = (xmlChar ) xmlMallocAtomic(max sizeof(xmlChar));
2549	if (buffer == NULL) {
2550	xmlErrMemory(ctxt, NULL);
2551	return(NULL);
2552	}
2553	memcpy(buffer, buf, len);
2554	while (c != 0) { /* tested bigname2.xml */
2555	if (len + 10 > max) {
2556	xmlChar *tmp;
2557
2558	max *= 2;
2559	tmp = (xmlChar *) xmlRealloc(buffer,
2560	max * sizeof(xmlChar));
2561	if (tmp == NULL) {
2562	xmlErrMemory(ctxt, NULL);
2563	xmlFree(buffer);
2564	return(NULL);
2565	}
2566	buffer = tmp;
2567	}
2568	buffer[len++] = c;
2569	c = *cur++;
2570	}
2571	buffer[len] = 0;
2572	}
2573
2574	if (buffer == NULL)
2575	ret = xmlStrndup(buf, len);
2576	else {
2577	ret = buffer;
2578	}
2579	}
2580
2581	return(ret);
2582	}
2583
2584	/************************************************************************
2585	* *
2586	* The parser itself *
2587	* Relates to http://www.w3.org/TR/REC-xml *
2588	* *
2589	************************************************************************/
2590
2591	static const xmlChar * xmlParseNameComplex(xmlParserCtxtPtr ctxt);
2592	static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt,
2593	int len, int alloc, int normalize);
2594
2595	/**
2596	* xmlParseName:
2597	* @ctxt: an XML parser context
2598	*
2599	* parse an XML name.
2600	*
2601	* [4] NameChar ::= Letter \| Digit \| '.' \| '-' \| '_' \| ':' \|
2602	* CombiningChar \| Extender
2603	*
2604	* [5] Name ::= (Letter \| '_' \| ':') (NameChar)*
2605	*
2606	* [6] Names ::= Name (#x20 Name)*
2607	*
2608	* Returns the Name parsed or NULL
2609	*/
2610
2611	const xmlChar *
2612	xmlParseName(xmlParserCtxtPtr ctxt) {
2613	const xmlChar *in;
2614	const xmlChar *ret;
2615	int count = 0;
2616
2617	GROW;
2618
2619	/*
2620	* Accelerator for simple ASCII names
2621	*/
2622	in = ctxt->input->cur;
2623	if (((in >= 0x61) && (in <= 0x7A)) \|\|
2624	((in >= 0x41) && (in <= 0x5A)) \|\|
2625	(in == '_') \|\| (in == ':')) {
2626	in++;
2627	while (((in >= 0x61) && (in <= 0x7A)) \|\|
2628	((in >= 0x41) && (in <= 0x5A)) \|\|
2629	((in >= 0x30) && (in <= 0x39)) \|\|
2630	(in == '_') \|\| (in == '-') \|\|
2631	(in == ':') \|\| (in == '.'))
2632	in++;
2633	if ((in > 0) && (in < 0x80)) {
2634	count = in - ctxt->input->cur;
2635	ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
2636	ctxt->input->cur = in;
2637	ctxt->nbChars += count;
2638	ctxt->input->col += count;
2639	if (ret == NULL)
2640	xmlErrMemory(ctxt, NULL);
2641	return(ret);
2642	}
2643	}
2644	return(xmlParseNameComplex(ctxt));
2645	}
2646
2647	/**
2648	* xmlParseNameAndCompare:
2649	* @ctxt: an XML parser context
2650	*
2651	* parse an XML name and compares for match
2652	* (specialized for endtag parsing)
2653	*
2654	* Returns NULL for an illegal name, (xmlChar*) 1 for success
2655	* and the name for mismatch
2656	*/
2657
2658	static const xmlChar *
2659	xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) {
2660	register const xmlChar *cmp = other;
2661	register const xmlChar *in;
2662	const xmlChar *ret;
2663
2664	GROW;
2665
2666	in = ctxt->input->cur;
2667	while (in != 0 && in == *cmp) {
2668	++in;
2669	++cmp;
2670	ctxt->input->col++;
2671	}
2672	if (cmp == 0 && (in == '>' \|\| IS_BLANK_CH (*in))) {
2673	/* success */
2674	ctxt->input->cur = in;
2675	return (const xmlChar*) 1;
2676	}
2677	/* failure (or end of input buffer), check with full function */
2678	ret = xmlParseName (ctxt);
2679	/* strings coming from the dictionnary direct compare possible */
2680	if (ret == other) {
2681	return (const xmlChar*) 1;
2682	}
2683	return ret;
2684	}
2685
2686	static const xmlChar *
2687	xmlParseNameComplex(xmlParserCtxtPtr ctxt) {
2688	int len = 0, l;
2689	int c;
2690	int count = 0;
2691
2692	/*
2693	* Handler for more complex cases
2694	*/
2695	GROW;
2696	c = CUR_CHAR(l);
2697	if ((c == ' ') \|\| (c == '>') \|\| (c == '/') \|\| /* accelerators */
2698	(!IS_LETTER(c) && (c != '_') &&
2699	(c != ':'))) {
2700	return(NULL);
2701	}
2702
2703	while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
2704	((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\|
2705	(c == '.') \|\| (c == '-') \|\|
2706	(c == '_') \|\| (c == ':') \|\|
2707	(IS_COMBINING(c)) \|\|
2708	(IS_EXTENDER(c)))) {
2709	if (count++ > 100) {
2710	count = 0;
2711	GROW;
2712	}
2713	len += l;
2714	NEXTL(l);
2715	c = CUR_CHAR(l);
2716	}
2717	if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r'))
2718	return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len));
2719	return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
2720	}
2721
2722	/**
2723	* xmlParseStringName:
2724	* @ctxt: an XML parser context
2725	* @str: a pointer to the string pointer (IN/OUT)
2726	*
2727	* parse an XML name.
2728	*
2729	* [4] NameChar ::= Letter \| Digit \| '.' \| '-' \| '_' \| ':' \|
2730	* CombiningChar \| Extender
2731	*
2732	* [5] Name ::= (Letter \| '_' \| ':') (NameChar)*
2733	*
2734	* [6] Names ::= Name (#x20 Name)*
2735	*
2736	* Returns the Name parsed or NULL. The @str pointer
2737	* is updated to the current location in the string.
2738	*/
2739
2740	static xmlChar *
2741	xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) {
2742	xmlChar buf[XML_MAX_NAMELEN + 5];
2743	const xmlChar cur = str;
2744	int len = 0, l;
2745	int c;
2746
2747	c = CUR_SCHAR(cur, l);
2748	if (!IS_LETTER(c) && (c != '_') &&
2749	(c != ':')) {
2750	return(NULL);
2751	}
2752
2753	while ((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\| /* test bigentname.xml */
2754	(c == '.') \|\| (c == '-') \|\|
2755	(c == '_') \|\| (c == ':') \|\|
2756	(IS_COMBINING(c)) \|\|
2757	(IS_EXTENDER(c))) {
2758	COPY_BUF(l,buf,len,c);
2759	cur += l;
2760	c = CUR_SCHAR(cur, l);
2761	if (len >= XML_MAX_NAMELEN) { /* test bigentname.xml */
2762	/*
2763	* Okay someone managed to make a huge name, so he's ready to pay
2764	* for the processing speed.
2765	*/
2766	xmlChar *buffer;
2767	int max = len * 2;
2768
2769	buffer = (xmlChar ) xmlMallocAtomic(max sizeof(xmlChar));
2770	if (buffer == NULL) {
2771	xmlErrMemory(ctxt, NULL);
2772	return(NULL);
2773	}
2774	memcpy(buffer, buf, len);
2775	while ((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\|
2776	/* test bigentname.xml */
2777	(c == '.') \|\| (c == '-') \|\|
2778	(c == '_') \|\| (c == ':') \|\|
2779	(IS_COMBINING(c)) \|\|
2780	(IS_EXTENDER(c))) {
2781	if (len + 10 > max) {
2782	xmlChar *tmp;
2783	max *= 2;
2784	tmp = (xmlChar *) xmlRealloc(buffer,
2785	max * sizeof(xmlChar));
2786	if (tmp == NULL) {
2787	xmlErrMemory(ctxt, NULL);
2788	xmlFree(buffer);
2789	return(NULL);
2790	}
2791	buffer = tmp;
2792	}
2793	COPY_BUF(l,buffer,len,c);
2794	cur += l;
2795	c = CUR_SCHAR(cur, l);
2796	}
2797	buffer[len] = 0;
2798	*str = cur;
2799	return(buffer);
2800	}
2801	}
2802	*str = cur;
2803	return(xmlStrndup(buf, len));
2804	}
2805
2806	/**
2807	* xmlParseNmtoken:
2808	* @ctxt: an XML parser context
2809	*
2810	* parse an XML Nmtoken.
2811	*
2812	* [7] Nmtoken ::= (NameChar)+
2813	*
2814	* [8] Nmtokens ::= Nmtoken (#x20 Nmtoken)*
2815	*
2816	* Returns the Nmtoken parsed or NULL
2817	*/
2818
2819	xmlChar *
2820	xmlParseNmtoken(xmlParserCtxtPtr ctxt) {
2821	xmlChar buf[XML_MAX_NAMELEN + 5];
2822	int len = 0, l;
2823	int c;
2824	int count = 0;
2825
2826	GROW;
2827	c = CUR_CHAR(l);
2828
2829	while ((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\| /* test bigtoken.xml */
2830	(c == '.') \|\| (c == '-') \|\|
2831	(c == '_') \|\| (c == ':') \|\|
2832	(IS_COMBINING(c)) \|\|
2833	(IS_EXTENDER(c))) {
2834	if (count++ > 100) {
2835	count = 0;
2836	GROW;
2837	}
2838	COPY_BUF(l,buf,len,c);
2839	NEXTL(l);
2840	c = CUR_CHAR(l);
2841	if (len >= XML_MAX_NAMELEN) {
2842	/*
2843	* Okay someone managed to make a huge token, so he's ready to pay
2844	* for the processing speed.
2845	*/
2846	xmlChar *buffer;
2847	int max = len * 2;
2848
2849	buffer = (xmlChar ) xmlMallocAtomic(max sizeof(xmlChar));
2850	if (buffer == NULL) {
2851	xmlErrMemory(ctxt, NULL);
2852	return(NULL);
2853	}
2854	memcpy(buffer, buf, len);
2855	while ((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\| /* test bigtoken.xml */
2856	(c == '.') \|\| (c == '-') \|\|
2857	(c == '_') \|\| (c == ':') \|\|
2858	(IS_COMBINING(c)) \|\|
2859	(IS_EXTENDER(c))) {
2860	if (count++ > 100) {
2861	count = 0;
2862	GROW;
2863	}
2864	if (len + 10 > max) {
2865	xmlChar *tmp;
2866
2867	max *= 2;
2868	tmp = (xmlChar *) xmlRealloc(buffer,
2869	max * sizeof(xmlChar));
2870	if (tmp == NULL) {
2871	xmlErrMemory(ctxt, NULL);
2872	xmlFree(buffer);
2873	return(NULL);
2874	}
2875	buffer = tmp;
2876	}
2877	COPY_BUF(l,buffer,len,c);
2878	NEXTL(l);
2879	c = CUR_CHAR(l);
2880	}
2881	buffer[len] = 0;
2882	return(buffer);
2883	}
2884	}
2885	if (len == 0)
2886	return(NULL);
2887	return(xmlStrndup(buf, len));
2888	}
2889
2890	/**
2891	* xmlParseEntityValue:
2892	* @ctxt: an XML parser context
2893	* @orig: if non-NULL store a copy of the original entity value
2894	*
2895	* parse a value for ENTITY declarations
2896	*
2897	* [9] EntityValue ::= '"' ([^%&"] \| PEReference \| Reference)* '"' \|
2898	* "'" ([^%&'] \| PEReference \| Reference)* "'"
2899	*
2900	* Returns the EntityValue parsed with reference substituted or NULL
2901	*/
2902
2903	xmlChar *
2904	xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) {
2905	xmlChar *buf = NULL;
2906	int len = 0;
2907	int size = XML_PARSER_BUFFER_SIZE;
2908	int c, l;
2909	xmlChar stop;
2910	xmlChar *ret = NULL;
2911	const xmlChar *cur = NULL;
2912	xmlParserInputPtr input;
2913
2914	if (RAW == '"') stop = '"';
2915	else if (RAW == '\'') stop = '\'';
2916	else {
2917	xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL);
2918	return(NULL);
2919	}
2920	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
2921	if (buf == NULL) {
2922	xmlErrMemory(ctxt, NULL);
2923	return(NULL);
2924	}
2925
2926	/*
2927	* The content of the entity definition is copied in a buffer.
2928	*/
2929
2930	ctxt->instate = XML_PARSER_ENTITY_VALUE;
2931	input = ctxt->input;
2932	GROW;
2933	NEXT;
2934	c = CUR_CHAR(l);
2935	/*
2936	* NOTE: 4.4.5 Included in Literal
2937	* When a parameter entity reference appears in a literal entity
2938	* value, ... a single or double quote character in the replacement
2939	* text is always treated as a normal data character and will not
2940	* terminate the literal.
2941	* In practice it means we stop the loop only when back at parsing
2942	* the initial entity and the quote is found
2943	*/
2944	while ((IS_CHAR(c)) && ((c != stop) \|\| /* checked */
2945	(ctxt->input != input))) {
2946	if (len + 5 >= size) {
2947	xmlChar *tmp;
2948
2949	size *= 2;
2950	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
2951	if (tmp == NULL) {
2952	xmlErrMemory(ctxt, NULL);
2953	xmlFree(buf);
2954	return(NULL);
2955	}
2956	buf = tmp;
2957	}
2958	COPY_BUF(l,buf,len,c);
2959	NEXTL(l);
2960	/*
2961	* Pop-up of finished entities.
2962	*/
2963	while ((RAW == 0) && (ctxt->inputNr > 1)) /* non input consuming */
2964	xmlPopInput(ctxt);
2965
2966	GROW;
2967	c = CUR_CHAR(l);
2968	if (c == 0) {
2969	GROW;
2970	c = CUR_CHAR(l);
2971	}
2972	}
2973	buf[len] = 0;
2974
2975	/*
2976	* Raise problem w.r.t. '&' and '%' being used in non-entities
2977	* reference constructs. Note Charref will be handled in
2978	* xmlStringDecodeEntities()
2979	*/
2980	cur = buf;
2981	while (cur != 0) { / non input consuming */
2982	if ((cur == '%') \|\| ((cur == '&') && (cur[1] != '#'))) {
2983	xmlChar *name;
2984	xmlChar tmp = *cur;
2985
2986	cur++;
2987	name = xmlParseStringName(ctxt, &cur);
2988	if ((name == NULL) \|\| (*cur != ';')) {
2989	xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR,
2990	"EntityValue: '%c' forbidden except for entities references\n",
2991	tmp);
2992	}
2993	if ((tmp == '%') && (ctxt->inSubset == 1) &&
2994	(ctxt->inputNr == 1)) {
2995	xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL);
2996	}
2997	if (name != NULL)
2998	xmlFree(name);
2999	if (*cur == 0)
3000	break;
3001	}
3002	cur++;
3003	}
3004
3005	/*
3006	* Then PEReference entities are substituted.
3007	*/
3008	if (c != stop) {
3009	xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL);
3010	xmlFree(buf);
3011	} else {
3012	NEXT;
3013	/*
3014	* NOTE: 4.4.7 Bypassed
3015	* When a general entity reference appears in the EntityValue in
3016	* an entity declaration, it is bypassed and left as is.
3017	* so XML_SUBSTITUTE_REF is not set here.
3018	*/
3019	ret = xmlStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF,
3020	0, 0, 0);
3021	if (orig != NULL)
3022	*orig = buf;
3023	else
3024	xmlFree(buf);
3025	}
3026
3027	return(ret);
3028	}
3029
3030	/**
3031	* xmlParseAttValueComplex:
3032	* @ctxt: an XML parser context
3033	* @len: the resulting attribute len
3034	* @normalize: wether to apply the inner normalization
3035	*
3036	* parse a value for an attribute, this is the fallback function
3037	* of xmlParseAttValue() when the attribute parsing requires handling
3038	* of non-ASCII characters, or normalization compaction.
3039	*
3040	* Returns the AttValue parsed or NULL. The value has to be freed by the caller.
3041	*/
3042	static xmlChar *
3043	xmlParseAttValueComplex(xmlParserCtxtPtr ctxt, int *attlen, int normalize) {
3044	xmlChar limit = 0;
3045	xmlChar *buf = NULL;
3046	int len = 0;
3047	int buf_size = 0;
3048	int c, l, in_space = 0;
3049	xmlChar *current = NULL;
3050	xmlEntityPtr ent;
3051
3052	if (NXT(0) == '"') {
3053	ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
3054	limit = '"';
3055	NEXT;
3056	} else if (NXT(0) == '\'') {
3057	limit = '\'';
3058	ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
3059	NEXT;
3060	} else {
3061	xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
3062	return(NULL);
3063	}
3064
3065	/*
3066	* allocate a translation buffer.
3067	*/
3068	buf_size = XML_PARSER_BUFFER_SIZE;
3069	buf = (xmlChar ) xmlMallocAtomic(buf_size sizeof(xmlChar));
3070	if (buf == NULL) goto mem_error;
3071
3072	/*
3073	* OK loop until we reach one of the ending char or a size limit.
3074	*/
3075	c = CUR_CHAR(l);
3076	while ((NXT(0) != limit) && /* checked */
3077	(IS_CHAR(c)) && (c != '<')) {
3078	if (c == 0) break;
3079	if (c == '&') {
3080	in_space = 0;
3081	if (NXT(1) == '#') {
3082	int val = xmlParseCharRef(ctxt);
3083
3084	if (val == '&') {
3085	if (ctxt->replaceEntities) {
3086	if (len > buf_size - 10) {
3087	growBuffer(buf);
3088	}
3089	buf[len++] = '&';
3090	} else {
3091	/*
3092	* The reparsing will be done in xmlStringGetNodeList()
3093	* called by the attribute() function in SAX.c
3094	*/
3095	if (len > buf_size - 10) {
3096	growBuffer(buf);
3097	}
3098	buf[len++] = '&';
3099	buf[len++] = '#';
3100	buf[len++] = '3';
3101	buf[len++] = '8';
3102	buf[len++] = ';';
3103	}
3104	} else {
3105	if (len > buf_size - 10) {
3106	growBuffer(buf);
3107	}
3108	len += xmlCopyChar(0, &buf[len], val);
3109	}
3110	} else {
3111	ent = xmlParseEntityRef(ctxt);
3112	if ((ent != NULL) &&
3113	(ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
3114	if (len > buf_size - 10) {
3115	growBuffer(buf);
3116	}
3117	if ((ctxt->replaceEntities == 0) &&
3118	(ent->content[0] == '&')) {
3119	buf[len++] = '&';
3120	buf[len++] = '#';
3121	buf[len++] = '3';
3122	buf[len++] = '8';
3123	buf[len++] = ';';
3124	} else {
3125	buf[len++] = ent->content[0];
3126	}
3127	} else if ((ent != NULL) &&
3128	(ctxt->replaceEntities != 0)) {
3129	xmlChar *rep;
3130
3131	if (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) {
3132	rep = xmlStringDecodeEntities(ctxt, ent->content,
3133	XML_SUBSTITUTE_REF,
3134	0, 0, 0);
3135	if (rep != NULL) {
3136	current = rep;
3137	while (current != 0) { / non input consuming */
3138	buf[len++] = *current++;
3139	if (len > buf_size - 10) {
3140	growBuffer(buf);
3141	}
3142	}
3143	xmlFree(rep);
3144	}
3145	} else {
3146	if (len > buf_size - 10) {
3147	growBuffer(buf);
3148	}
3149	if (ent->content != NULL)
3150	buf[len++] = ent->content[0];
3151	}
3152	} else if (ent != NULL) {
3153	int i = xmlStrlen(ent->name);
3154	const xmlChar *cur = ent->name;
3155
3156	/*
3157	* This may look absurd but is needed to detect
3158	* entities problems
3159	*/
3160	if ((ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
3161	(ent->content != NULL)) {
3162	xmlChar *rep;
3163	rep = xmlStringDecodeEntities(ctxt, ent->content,
3164	XML_SUBSTITUTE_REF, 0, 0, 0);
3165	if (rep != NULL)
3166	xmlFree(rep);
3167	}
3168
3169	/*
3170	* Just output the reference
3171	*/
3172	buf[len++] = '&';
3173	if (len > buf_size - i - 10) {
3174	growBuffer(buf);
3175	}
3176	for (;i > 0;i--)
3177	buf[len++] = *cur++;
3178	buf[len++] = ';';
3179	}
3180	}
3181	} else {
3182	if ((c == 0x20) \|\| (c == 0xD) \|\| (c == 0xA) \|\| (c == 0x9)) {
3183	if ((len != 0) \|\| (!normalize)) {
3184	if ((!normalize) \|\| (!in_space)) {
3185	COPY_BUF(l,buf,len,0x20);
3186	if (len > buf_size - 10) {
3187	growBuffer(buf);
3188	}
3189	}
3190	in_space = 1;
3191	}
3192	} else {
3193	in_space = 0;
3194	COPY_BUF(l,buf,len,c);
3195	if (len > buf_size - 10) {
3196	growBuffer(buf);
3197	}
3198	}
3199	NEXTL(l);
3200	}
3201	GROW;
3202	c = CUR_CHAR(l);
3203	}
3204	if ((in_space) && (normalize)) {
3205	while (buf[len - 1] == 0x20) len--;
3206	}
3207	buf[len] = 0;
3208	if (RAW == '<') {
3209	xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL);
3210	} else if (RAW != limit) {
3211	if ((c != 0) && (!IS_CHAR(c))) {
3212	xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
3213	"invalid character in attribute value\n");
3214	} else {
3215	xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
3216	"AttValue: ' expected\n");
3217	}
3218	} else
3219	NEXT;
3220	if (attlen != NULL) *attlen = len;
3221	return(buf);
3222
3223	mem_error:
3224	xmlErrMemory(ctxt, NULL);
3225	return(NULL);
3226	}
3227
3228	/**
3229	* xmlParseAttValue:
3230	* @ctxt: an XML parser context
3231	*
3232	* parse a value for an attribute
3233	* Note: the parser won't do substitution of entities here, this
3234	* will be handled later in xmlStringGetNodeList
3235	*
3236	* [10] AttValue ::= '"' ([^<&"] \| Reference)* '"' \|
3237	* "'" ([^<&'] \| Reference)* "'"
3238	*
3239	* 3.3.3 Attribute-Value Normalization:
3240	* Before the value of an attribute is passed to the application or
3241	* checked for validity, the XML processor must normalize it as follows:
3242	* - a character reference is processed by appending the referenced
3243	* character to the attribute value
3244	* - an entity reference is processed by recursively processing the
3245	* replacement text of the entity
3246	* - a whitespace character (#x20, #xD, #xA, #x9) is processed by
3247	* appending #x20 to the normalized value, except that only a single
3248	* #x20 is appended for a "#xD#xA" sequence that is part of an external
3249	* parsed entity or the literal entity value of an internal parsed entity
3250	* - other characters are processed by appending them to the normalized value
3251	* If the declared value is not CDATA, then the XML processor must further
3252	* process the normalized attribute value by discarding any leading and
3253	* trailing space (#x20) characters, and by replacing sequences of space
3254	* (#x20) characters by a single space (#x20) character.
3255	* All attributes for which no declaration has been read should be treated
3256	* by a non-validating parser as if declared CDATA.
3257	*
3258	* Returns the AttValue parsed or NULL. The value has to be freed by the caller.
3259	*/
3260
3261
3262	xmlChar *
3263	xmlParseAttValue(xmlParserCtxtPtr ctxt) {
3264	if ((ctxt == NULL) \|\| (ctxt->input == NULL)) return(NULL);
3265	return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0));
3266	}
3267
3268	/**
3269	* xmlParseSystemLiteral:
3270	* @ctxt: an XML parser context
3271	*
3272	* parse an XML Literal
3273	*
3274	* [11] SystemLiteral ::= ('"' [^"]* '"') \| ("'" [^']* "'")
3275	*
3276	* Returns the SystemLiteral parsed or NULL
3277	*/
3278
3279	xmlChar *
3280	xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) {
3281	xmlChar *buf = NULL;
3282	int len = 0;
3283	int size = XML_PARSER_BUFFER_SIZE;
3284	int cur, l;
3285	xmlChar stop;
3286	int state = ctxt->instate;
3287	int count = 0;
3288
3289	SHRINK;
3290	if (RAW == '"') {
3291	NEXT;
3292	stop = '"';
3293	} else if (RAW == '\'') {
3294	NEXT;
3295	stop = '\'';
3296	} else {
3297	xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
3298	return(NULL);
3299	}
3300
3301	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
3302	if (buf == NULL) {
3303	xmlErrMemory(ctxt, NULL);
3304	return(NULL);
3305	}
3306	ctxt->instate = XML_PARSER_SYSTEM_LITERAL;
3307	cur = CUR_CHAR(l);
3308	while ((IS_CHAR(cur)) && (cur != stop)) { /* checked */
3309	if (len + 5 >= size) {
3310	xmlChar *tmp;
3311
3312	size *= 2;
3313	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
3314	if (tmp == NULL) {
3315	xmlFree(buf);
3316	xmlErrMemory(ctxt, NULL);
3317	ctxt->instate = (xmlParserInputState) state;
3318	return(NULL);
3319	}
3320	buf = tmp;
3321	}
3322	count++;
3323	if (count > 50) {
3324	GROW;
3325	count = 0;
3326	}
3327	COPY_BUF(l,buf,len,cur);
3328	NEXTL(l);
3329	cur = CUR_CHAR(l);
3330	if (cur == 0) {
3331	GROW;
3332	SHRINK;
3333	cur = CUR_CHAR(l);
3334	}
3335	}
3336	buf[len] = 0;
3337	ctxt->instate = (xmlParserInputState) state;
3338	if (!IS_CHAR(cur)) {
3339	xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
3340	} else {
3341	NEXT;
3342	}
3343	return(buf);
3344	}
3345
3346	/**
3347	* xmlParsePubidLiteral:
3348	* @ctxt: an XML parser context
3349	*
3350	* parse an XML public literal
3351	*
3352	* [12] PubidLiteral ::= '"' PubidChar* '"' \| "'" (PubidChar - "'")* "'"
3353	*
3354	* Returns the PubidLiteral parsed or NULL.
3355	*/
3356
3357	xmlChar *
3358	xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) {
3359	xmlChar *buf = NULL;
3360	int len = 0;
3361	int size = XML_PARSER_BUFFER_SIZE;
3362	xmlChar cur;
3363	xmlChar stop;
3364	int count = 0;
3365	xmlParserInputState oldstate = ctxt->instate;
3366
3367	SHRINK;
3368	if (RAW == '"') {
3369	NEXT;
3370	stop = '"';
3371	} else if (RAW == '\'') {
3372	NEXT;
3373	stop = '\'';
3374	} else {
3375	xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
3376	return(NULL);
3377	}
3378	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
3379	if (buf == NULL) {
3380	xmlErrMemory(ctxt, NULL);
3381	return(NULL);
3382	}
3383	ctxt->instate = XML_PARSER_PUBLIC_LITERAL;
3384	cur = CUR;
3385	while ((IS_PUBIDCHAR_CH(cur)) && (cur != stop)) { /* checked */
3386	if (len + 1 >= size) {
3387	xmlChar *tmp;
3388
3389	size *= 2;
3390	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
3391	if (tmp == NULL) {
3392	xmlErrMemory(ctxt, NULL);
3393	xmlFree(buf);
3394	return(NULL);
3395	}
3396	buf = tmp;
3397	}
3398	buf[len++] = cur;
3399	count++;
3400	if (count > 50) {
3401	GROW;
3402	count = 0;
3403	}
3404	NEXT;
3405	cur = CUR;
3406	if (cur == 0) {
3407	GROW;
3408	SHRINK;
3409	cur = CUR;
3410	}
3411	}
3412	buf[len] = 0;
3413	if (cur != stop) {
3414	xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
3415	} else {
3416	NEXT;
3417	}
3418	ctxt->instate = oldstate;
3419	return(buf);
3420	}
3421
3422	void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata);
3423
3424	/*
3425	* used for the test in the inner loop of the char data testing
3426	*/
3427	static const unsigned char test_char_data[256] = {
3428	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3429	0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x9, CR/LF separated */
3430	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3431	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3432	0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x00, 0x27, /* & */
3433	0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
3434	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
3435	0x38, 0x39, 0x3A, 0x3B, 0x00, 0x3D, 0x3E, 0x3F, /* < */
3436	0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
3437	0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
3438	0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
3439	0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x00, 0x5E, 0x5F, /* ] */
3440	0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
3441	0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
3442	0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
3443	0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
3444	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* non-ascii */
3445	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3446	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3447	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3448	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3449	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3450	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3451	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3452	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3453	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3454	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3455	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3456	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3457	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3458	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3459	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
3460	};
3461
3462	/**
3463	* xmlParseCharData:
3464	* @ctxt: an XML parser context
3465	* @cdata: int indicating whether we are within a CDATA section
3466	*
3467	* parse a CharData section.
3468	* if we are within a CDATA section ']]>' marks an end of section.
3469	*
3470	* The right angle bracket (>) may be represented using the string ">",
3471	* and must, for compatibility, be escaped using ">" or a character
3472	* reference when it appears in the string "]]>" in content, when that
3473	* string is not marking the end of a CDATA section.
3474	*
3475	* [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
3476	*/
3477
3478	void
3479	xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata) {
3480	const xmlChar *in;
3481	int nbchar = 0;
3482	int line = ctxt->input->line;
3483	int col = ctxt->input->col;
3484	int ccol;
3485
3486	SHRINK;
3487	GROW;
3488	/*
3489	* Accelerated common case where input don't need to be
3490	* modified before passing it to the handler.
3491	*/
3492	if (!cdata) {
3493	in = ctxt->input->cur;
3494	do {
3495	get_more_space:
3496	while (*in == 0x20) in++;
3497	if (*in == 0xA) {
3498	do {
3499	ctxt->input->line++; ctxt->input->col = 1;
3500	in++;
3501	} while (*in == 0xA);
3502	goto get_more_space;
3503	}
3504	if (*in == '<') {
3505	nbchar = in - ctxt->input->cur;
3506	if (nbchar > 0) {
3507	const xmlChar *tmp = ctxt->input->cur;
3508	ctxt->input->cur = in;
3509
3510	if ((ctxt->sax != NULL) &&
3511	(ctxt->sax->ignorableWhitespace !=
3512	ctxt->sax->characters)) {
3513	if (areBlanks(ctxt, tmp, nbchar, 1)) {
3514	if (ctxt->sax->ignorableWhitespace != NULL)
3515	ctxt->sax->ignorableWhitespace(ctxt->userData,
3516	tmp, nbchar);
3517	} else {
3518	if (ctxt->sax->characters != NULL)
3519	ctxt->sax->characters(ctxt->userData,
3520	tmp, nbchar);
3521	if (*ctxt->space == -1)
3522	*ctxt->space = -2;
3523	}
3524	} else if ((ctxt->sax != NULL) &&
3525	(ctxt->sax->characters != NULL)) {
3526	ctxt->sax->characters(ctxt->userData,
3527	tmp, nbchar);
3528	}
3529	}
3530	return;
3531	}
3532
3533	get_more:
3534	ccol = ctxt->input->col;
3535	while (test_char_data[*in]) {
3536	in++;
3537	ccol++;
3538	}
3539	ctxt->input->col = ccol;
3540	if (*in == 0xA) {
3541	do {
3542	ctxt->input->line++; ctxt->input->col = 1;
3543	in++;
3544	} while (*in == 0xA);
3545	goto get_more;
3546	}
3547	if (*in == ']') {
3548	if ((in[1] == ']') && (in[2] == '>')) {
3549	xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
3550	ctxt->input->cur = in;
3551	return;
3552	}
3553	in++;
3554	ctxt->input->col++;
3555	goto get_more;
3556	}
3557	nbchar = in - ctxt->input->cur;
3558	if (nbchar > 0) {
3559	if ((ctxt->sax != NULL) &&
3560	(ctxt->sax->ignorableWhitespace !=
3561	ctxt->sax->characters) &&
3562	(IS_BLANK_CH(*ctxt->input->cur))) {
3563	const xmlChar *tmp = ctxt->input->cur;
3564	ctxt->input->cur = in;
3565
3566	if (areBlanks(ctxt, tmp, nbchar, 0)) {
3567	if (ctxt->sax->ignorableWhitespace != NULL)
3568	ctxt->sax->ignorableWhitespace(ctxt->userData,
3569	tmp, nbchar);
3570	} else {
3571	if (ctxt->sax->characters != NULL)
3572	ctxt->sax->characters(ctxt->userData,
3573	tmp, nbchar);
3574	if (*ctxt->space == -1)
3575	*ctxt->space = -2;
3576	}
3577	line = ctxt->input->line;
3578	col = ctxt->input->col;
3579	} else if (ctxt->sax != NULL) {
3580	if (ctxt->sax->characters != NULL)
3581	ctxt->sax->characters(ctxt->userData,
3582	ctxt->input->cur, nbchar);
3583	line = ctxt->input->line;
3584	col = ctxt->input->col;
3585	}
3586	}
3587	ctxt->input->cur = in;
3588	if (*in == 0xD) {
3589	in++;
3590	if (*in == 0xA) {
3591	ctxt->input->cur = in;
3592	in++;
3593	ctxt->input->line++; ctxt->input->col = 1;
3594	continue; /* while */
3595	}
3596	in--;
3597	}
3598	if (*in == '<') {
3599	return;
3600	}
3601	if (*in == '&') {
3602	return;
3603	}
3604	SHRINK;
3605	GROW;
3606	in = ctxt->input->cur;
3607	} while (((in >= 0x20) && (in <= 0x7F)) \|\| (*in == 0x09));
3608	nbchar = 0;
3609	}
3610	ctxt->input->line = line;
3611	ctxt->input->col = col;
3612	xmlParseCharDataComplex(ctxt, cdata);
3613	}
3614
3615	/**
3616	* xmlParseCharDataComplex:
3617	* @ctxt: an XML parser context
3618	* @cdata: int indicating whether we are within a CDATA section
3619	*
3620	* parse a CharData section.this is the fallback function
3621	* of xmlParseCharData() when the parsing requires handling
3622	* of non-ASCII characters.
3623	*/
3624	void
3625	xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata) {
3626	xmlChar buf[XML_PARSER_BIG_BUFFER_SIZE + 5];
3627	int nbchar = 0;
3628	int cur, l;
3629	int count = 0;
3630
3631	SHRINK;
3632	GROW;
3633	cur = CUR_CHAR(l);
3634	while ((cur != '<') && /* checked */
3635	(cur != '&') &&
3636	(IS_CHAR(cur))) /* test also done in xmlCurrentChar() */ {
3637	if ((cur == ']') && (NXT(1) == ']') &&
3638	(NXT(2) == '>')) {
3639	if (cdata) break;
3640	else {
3641	xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
3642	}
3643	}
3644	COPY_BUF(l,buf,nbchar,cur);
3645	if (nbchar >= XML_PARSER_BIG_BUFFER_SIZE) {
3646	buf[nbchar] = 0;
3647
3648	/*
3649	* OK the segment is to be consumed as chars.
3650	*/
3651	if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
3652	if (areBlanks(ctxt, buf, nbchar, 0)) {
3653	if (ctxt->sax->ignorableWhitespace != NULL)
3654	ctxt->sax->ignorableWhitespace(ctxt->userData,
3655	buf, nbchar);
3656	} else {
3657	if (ctxt->sax->characters != NULL)
3658	ctxt->sax->characters(ctxt->userData, buf, nbchar);
3659	if ((ctxt->sax->characters !=
3660	ctxt->sax->ignorableWhitespace) &&
3661	(*ctxt->space == -1))
3662	*ctxt->space = -2;
3663	}
3664	}
3665	nbchar = 0;
3666	}
3667	count++;
3668	if (count > 50) {
3669	GROW;
3670	count = 0;
3671	}
3672	NEXTL(l);
3673	cur = CUR_CHAR(l);
3674	}
3675	if (nbchar != 0) {
3676	buf[nbchar] = 0;
3677	/*
3678	* OK the segment is to be consumed as chars.
3679	*/
3680	if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
3681	if (areBlanks(ctxt, buf, nbchar, 0)) {
3682	if (ctxt->sax->ignorableWhitespace != NULL)
3683	ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
3684	} else {
3685	if (ctxt->sax->characters != NULL)
3686	ctxt->sax->characters(ctxt->userData, buf, nbchar);
3687	if ((ctxt->sax->characters != ctxt->sax->ignorableWhitespace) &&
3688	(*ctxt->space == -1))
3689	*ctxt->space = -2;
3690	}
3691	}
3692	}
3693	if ((cur != 0) && (!IS_CHAR(cur))) {
3694	/* Generate the error and skip the offending character */
3695	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
3696	"PCDATA invalid Char value %d\n",
3697	cur);
3698	NEXTL(l);
3699	}
3700	}
3701
3702	/**
3703	* xmlParseExternalID:
3704	* @ctxt: an XML parser context
3705	* @publicID: a xmlChar** receiving PubidLiteral
3706	* @strict: indicate whether we should restrict parsing to only
3707	* production [75], see NOTE below
3708	*
3709	* Parse an External ID or a Public ID
3710	*
3711	* NOTE: Productions [75] and [83] interact badly since [75] can generate
3712	* 'PUBLIC' S PubidLiteral S SystemLiteral
3713	*
3714	* [75] ExternalID ::= 'SYSTEM' S SystemLiteral
3715	* \| 'PUBLIC' S PubidLiteral S SystemLiteral
3716	*
3717	* [83] PublicID ::= 'PUBLIC' S PubidLiteral
3718	*
3719	* Returns the function returns SystemLiteral and in the second
3720	* case publicID receives PubidLiteral, is strict is off
3721	* it is possible to return NULL and have publicID set.
3722	*/
3723
3724	xmlChar *
3725	xmlParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) {
3726	xmlChar *URI = NULL;
3727
3728	SHRINK;
3729
3730	*publicID = NULL;
3731	if (CMP6(CUR_PTR, 'S', 'Y', 'S', 'T', 'E', 'M')) {
3732	SKIP(6);
3733	if (!IS_BLANK_CH(CUR)) {
3734	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
3735	"Space required after 'SYSTEM'\n");
3736	}
3737	SKIP_BLANKS;
3738	URI = xmlParseSystemLiteral(ctxt);
3739	if (URI == NULL) {
3740	xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
3741	}
3742	} else if (CMP6(CUR_PTR, 'P', 'U', 'B', 'L', 'I', 'C')) {
3743	SKIP(6);
3744	if (!IS_BLANK_CH(CUR)) {
3745	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
3746	"Space required after 'PUBLIC'\n");
3747	}
3748	SKIP_BLANKS;
3749	*publicID = xmlParsePubidLiteral(ctxt);
3750	if (*publicID == NULL) {
3751	xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL);
3752	}
3753	if (strict) {
3754	/*
3755	* We don't handle [83] so "S SystemLiteral" is required.
3756	*/
3757	if (!IS_BLANK_CH(CUR)) {
3758	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
3759	"Space required after the Public Identifier\n");
3760	}
3761	} else {
3762	/*
3763	* We handle [83] so we return immediately, if
3764	* "S SystemLiteral" is not detected. From a purely parsing
3765	* point of view that's a nice mess.
3766	*/
3767	const xmlChar *ptr;
3768	GROW;
3769
3770	ptr = CUR_PTR;
3771	if (!IS_BLANK_CH(*ptr)) return(NULL);
3772
3773	while (IS_BLANK_CH(ptr)) ptr++; / TODO: dangerous, fix ! */
3774	if ((ptr != '\'') && (ptr != '"')) return(NULL);
3775	}
3776	SKIP_BLANKS;
3777	URI = xmlParseSystemLiteral(ctxt);
3778	if (URI == NULL) {
3779	xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
3780	}
3781	}
3782	return(URI);
3783	}
3784
3785	/**
3786	* xmlParseCommentComplex:
3787	* @ctxt: an XML parser context
3788	* @buf: the already parsed part of the buffer
3789	* @len: number of bytes filles in the buffer
3790	* @size: allocated size of the buffer
3791	*
3792	* Skip an XML (SGML) comment <!-- .... -->
3793	* The spec says that "For compatibility, the string "--" (double-hyphen)
3794	* must not occur within comments. "
3795	* This is the slow routine in case the accelerator for ascii didn't work
3796	*
3797	* [15] Comment ::= '<!--' ((Char - '-') \| ('-' (Char - '-')))* '-->'
3798	*/
3799	static void
3800	xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf, int len, int size) {
3801	int q, ql;
3802	int r, rl;
3803	int cur, l;
3804	xmlParserInputPtr input = ctxt->input;
3805	int count = 0;
3806
3807	if (buf == NULL) {
3808	len = 0;
3809	size = XML_PARSER_BUFFER_SIZE;
3810	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
3811	if (buf == NULL) {
3812	xmlErrMemory(ctxt, NULL);
3813	return;
3814	}
3815	}
3816	GROW; /* Assure there's enough input data */
3817	q = CUR_CHAR(ql);
3818	if (q == 0)
3819	goto not_terminated;
3820	if (!IS_CHAR(q)) {
3821	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
3822	"xmlParseComment: invalid xmlChar value %d\n",
3823	q);
3824	xmlFree (buf);
3825	return;
3826	}
3827	NEXTL(ql);
3828	r = CUR_CHAR(rl);
3829	if (r == 0)
3830	goto not_terminated;
3831	if (!IS_CHAR(r)) {
3832	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
3833	"xmlParseComment: invalid xmlChar value %d\n",
3834	q);
3835	xmlFree (buf);
3836	return;
3837	}
3838	NEXTL(rl);
3839	cur = CUR_CHAR(l);
3840	if (cur == 0)
3841	goto not_terminated;
3842	while (IS_CHAR(cur) && /* checked */
3843	((cur != '>') \|\|
3844	(r != '-') \|\| (q != '-'))) {
3845	if ((r == '-') && (q == '-')) {
3846	xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL);
3847	}
3848	if (len + 5 >= size) {
3849	xmlChar *new_buf;
3850	size *= 2;
3851	new_buf = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
3852	if (new_buf == NULL) {
3853	xmlFree (buf);
3854	xmlErrMemory(ctxt, NULL);
3855	return;
3856	}
3857	buf = new_buf;
3858	}
3859	COPY_BUF(ql,buf,len,q);
3860	q = r;
3861	ql = rl;
3862	r = cur;
3863	rl = l;
3864
3865	count++;
3866	if (count > 50) {
3867	GROW;
3868	count = 0;
3869	}
3870	NEXTL(l);
3871	cur = CUR_CHAR(l);
3872	if (cur == 0) {
3873	SHRINK;
3874	GROW;
3875	cur = CUR_CHAR(l);
3876	}
3877	}
3878	buf[len] = 0;
3879	if (cur == 0) {
3880	xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
3881	"Comment not terminated \n<!--%.50s\n", buf);
3882	} else if (!IS_CHAR(cur)) {
3883	xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
3884	"xmlParseComment: invalid xmlChar value %d\n",
3885	cur);
3886	} else {
3887	if (input != ctxt->input) {
3888	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
3889	"Comment doesn't start and stop in the same entity\n");
3890	}
3891	NEXT;
3892	if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
3893	(!ctxt->disableSAX))
3894	ctxt->sax->comment(ctxt->userData, buf);
3895	}
3896	xmlFree(buf);
3897	return;
3898	not_terminated:
3899	xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
3900	"Comment not terminated\n", NULL);
3901	xmlFree(buf);
3902	return;
3903	}
3904
3905	/**
3906	* xmlParseComment:
3907	* @ctxt: an XML parser context
3908	*
3909	* Skip an XML (SGML) comment <!-- .... -->
3910	* The spec says that "For compatibility, the string "--" (double-hyphen)
3911	* must not occur within comments. "
3912	*
3913	* [15] Comment ::= '<!--' ((Char - '-') \| ('-' (Char - '-')))* '-->'
3914	*/
3915	void
3916	xmlParseComment(xmlParserCtxtPtr ctxt) {
3917	xmlChar *buf = NULL;
3918	int size = XML_PARSER_BUFFER_SIZE;
3919	int len = 0;
3920	xmlParserInputState state;
3921	const xmlChar *in;
3922	int nbchar = 0, ccol;
3923
3924	/*
3925	* Check that there is a comment right here.
3926	*/
3927	if ((RAW != '<') \|\| (NXT(1) != '!') \|\|
3928	(NXT(2) != '-') \|\| (NXT(3) != '-')) return;
3929
3930	state = ctxt->instate;
3931	ctxt->instate = XML_PARSER_COMMENT;
3932	SKIP(4);
3933	SHRINK;
3934	GROW;
3935
3936	/*
3937	* Accelerated common case where input don't need to be
3938	* modified before passing it to the handler.
3939	*/
3940	in = ctxt->input->cur;
3941	do {
3942	if (*in == 0xA) {
3943	do {
3944	ctxt->input->line++; ctxt->input->col = 1;
3945	in++;
3946	} while (*in == 0xA);
3947	}
3948	get_more:
3949	ccol = ctxt->input->col;
3950	while (((in > '-') && (in <= 0x7F)) \|\|
3951	((in >= 0x20) && (in < '-')) \|\|
3952	(*in == 0x09)) {
3953	in++;
3954	ccol++;
3955	}
3956	ctxt->input->col = ccol;
3957	if (*in == 0xA) {
3958	do {
3959	ctxt->input->line++; ctxt->input->col = 1;
3960	in++;
3961	} while (*in == 0xA);
3962	goto get_more;
3963	}
3964	nbchar = in - ctxt->input->cur;
3965	/*
3966	* save current set of data
3967	*/
3968	if (nbchar > 0) {
3969	if ((ctxt->sax != NULL) &&
3970	(ctxt->sax->comment != NULL)) {
3971	if (buf == NULL) {
3972	if ((*in == '-') && (in[1] == '-'))
3973	size = nbchar + 1;
3974	else
3975	size = XML_PARSER_BUFFER_SIZE + nbchar;
3976	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
3977	if (buf == NULL) {
3978	xmlErrMemory(ctxt, NULL);
3979	ctxt->instate = state;
3980	return;
3981	}
3982	len = 0;
3983	} else if (len + nbchar + 1 >= size) {
3984	xmlChar *new_buf;
3985	size += len + nbchar + XML_PARSER_BUFFER_SIZE;
3986	new_buf = (xmlChar *) xmlRealloc(buf,
3987	size * sizeof(xmlChar));
3988	if (new_buf == NULL) {
3989	xmlFree (buf);
3990	xmlErrMemory(ctxt, NULL);
3991	ctxt->instate = state;
3992	return;
3993	}
3994	buf = new_buf;
3995	}
3996	memcpy(&buf[len], ctxt->input->cur, nbchar);
3997	len += nbchar;
3998	buf[len] = 0;
3999	}
4000	}
4001	ctxt->input->cur = in;
4002	if (*in == 0xA) {
4003	in++;
4004	ctxt->input->line++; ctxt->input->col = 1;
4005	}
4006	if (*in == 0xD) {
4007	in++;
4008	if (*in == 0xA) {
4009	ctxt->input->cur = in;
4010	in++;
4011	ctxt->input->line++; ctxt->input->col = 1;
4012	continue; /* while */
4013	}
4014	in--;
4015	}
4016	SHRINK;
4017	GROW;
4018	in = ctxt->input->cur;
4019	if (*in == '-') {
4020	if (in[1] == '-') {
4021	if (in[2] == '>') {
4022	SKIP(3);
4023	if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
4024	(!ctxt->disableSAX)) {
4025	if (buf != NULL)
4026	ctxt->sax->comment(ctxt->userData, buf);
4027	else
4028	ctxt->sax->comment(ctxt->userData, BAD_CAST "");
4029	}
4030	if (buf != NULL)
4031	xmlFree(buf);
4032	ctxt->instate = state;
4033	return;
4034	}
4035	if (buf != NULL)
4036	xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4037	"Comment not terminated \n<!--%.50s\n",
4038	buf);
4039	else
4040	xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4041	"Comment not terminated \n", NULL);
4042	in++;
4043	ctxt->input->col++;
4044	}
4045	in++;
4046	ctxt->input->col++;
4047	goto get_more;
4048	}
4049	} while (((in >= 0x20) && (in <= 0x7F)) \|\| (*in == 0x09));
4050	xmlParseCommentComplex(ctxt, buf, len, size);
4051	ctxt->instate = state;
4052	return;
4053	}
4054
4055
4056	/**
4057	* xmlParsePITarget:
4058	* @ctxt: an XML parser context
4059	*
4060	* parse the name of a PI
4061	*
4062	* [17] PITarget ::= Name - (('X' \| 'x') ('M' \| 'm') ('L' \| 'l'))
4063	*
4064	* Returns the PITarget name or NULL
4065	*/
4066
4067	const xmlChar *
4068	xmlParsePITarget(xmlParserCtxtPtr ctxt) {
4069	const xmlChar *name;
4070
4071	name = xmlParseName(ctxt);
4072	if ((name != NULL) &&
4073	((name[0] == 'x') \|\| (name[0] == 'X')) &&
4074	((name[1] == 'm') \|\| (name[1] == 'M')) &&
4075	((name[2] == 'l') \|\| (name[2] == 'L'))) {
4076	int i;
4077	if ((name[0] == 'x') && (name[1] == 'm') &&
4078	(name[2] == 'l') && (name[3] == 0)) {
4079	xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
4080	"XML declaration allowed only at the start of the document\n");
4081	return(name);
4082	} else if (name[3] == 0) {
4083	xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL);
4084	return(name);
4085	}
4086	for (i = 0;;i++) {
4087	if (xmlW3CPIs[i] == NULL) break;
4088	if (xmlStrEqual(name, (const xmlChar *)xmlW3CPIs[i]))
4089	return(name);
4090	}
4091	xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
4092	"xmlParsePITarget: invalid name prefix 'xml'\n",
4093	NULL, NULL);
4094	}
4095	return(name);
4096	}
4097
4098	#ifdef LIBXML_CATALOG_ENABLED
4099	/**
4100	* xmlParseCatalogPI:
4101	* @ctxt: an XML parser context
4102	* @catalog: the PI value string
4103	*
4104	* parse an XML Catalog Processing Instruction.
4105	*
4106	* <?oasis-xml-catalog catalog="http://example.com/catalog.xml"?>
4107	*
4108	* Occurs only if allowed by the user and if happening in the Misc
4109	* part of the document before any doctype informations
4110	* This will add the given catalog to the parsing context in order
4111	* to be used if there is a resolution need further down in the document
4112	*/
4113
4114	static void
4115	xmlParseCatalogPI(xmlParserCtxtPtr ctxt, const xmlChar *catalog) {
4116	xmlChar *URL = NULL;
4117	const xmlChar tmp, base;
4118	xmlChar marker;
4119
4120	tmp = catalog;
4121	while (IS_BLANK_CH(*tmp)) tmp++;
4122	if (xmlStrncmp(tmp, BAD_CAST"catalog", 7))
4123	goto error;
4124	tmp += 7;
4125	while (IS_BLANK_CH(*tmp)) tmp++;
4126	if (*tmp != '=') {
4127	return;
4128	}
4129	tmp++;
4130	while (IS_BLANK_CH(*tmp)) tmp++;
4131	marker = *tmp;
4132	if ((marker != '\'') && (marker != '"'))
4133	goto error;
4134	tmp++;
4135	base = tmp;
4136	while ((tmp != 0) && (tmp != marker)) tmp++;
4137	if (*tmp == 0)
4138	goto error;
4139	URL = xmlStrndup(base, tmp - base);
4140	tmp++;
4141	while (IS_BLANK_CH(*tmp)) tmp++;
4142	if (*tmp != 0)
4143	goto error;
4144
4145	if (URL != NULL) {
4146	ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL);
4147	xmlFree(URL);
4148	}
4149	return;
4150
4151	error:
4152	xmlWarningMsg(ctxt, XML_WAR_CATALOG_PI,
4153	"Catalog PI syntax error: %s\n",
4154	catalog, NULL);
4155	if (URL != NULL)
4156	xmlFree(URL);
4157	}
4158	#endif
4159
4160	/**
4161	* xmlParsePI:
4162	* @ctxt: an XML parser context
4163	*
4164	* parse an XML Processing Instruction.
4165	*
4166	* [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'
4167	*
4168	* The processing is transfered to SAX once parsed.
4169	*/
4170
4171	void
4172	xmlParsePI(xmlParserCtxtPtr ctxt) {
4173	xmlChar *buf = NULL;
4174	int len = 0;
4175	int size = XML_PARSER_BUFFER_SIZE;
4176	int cur, l;
4177	const xmlChar *target;
4178	xmlParserInputState state;
4179	int count = 0;
4180
4181	if ((RAW == '<') && (NXT(1) == '?')) {
4182	xmlParserInputPtr input = ctxt->input;
4183	state = ctxt->instate;
4184	ctxt->instate = XML_PARSER_PI;
4185	/*
4186	* this is a Processing Instruction.
4187	*/
4188	SKIP(2);
4189	SHRINK;
4190
4191	/*
4192	* Parse the target name and check for special support like
4193	* namespace.
4194	*/
4195	target = xmlParsePITarget(ctxt);
4196	if (target != NULL) {
4197	if ((RAW == '?') && (NXT(1) == '>')) {
4198	if (input != ctxt->input) {
4199	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4200	"PI declaration doesn't start and stop in the same entity\n");
4201	}
4202	SKIP(2);
4203
4204	/*
4205	* SAX: PI detected.
4206	*/
4207	if ((ctxt->sax) && (!ctxt->disableSAX) &&
4208	(ctxt->sax->processingInstruction != NULL))
4209	ctxt->sax->processingInstruction(ctxt->userData,
4210	target, NULL);
4211	ctxt->instate = state;
4212	return;
4213	}
4214	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
4215	if (buf == NULL) {
4216	xmlErrMemory(ctxt, NULL);
4217	ctxt->instate = state;
4218	return;
4219	}
4220	cur = CUR;
4221	if (!IS_BLANK(cur)) {
4222	xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED,
4223	"ParsePI: PI %s space expected\n", target);
4224	}
4225	SKIP_BLANKS;
4226	cur = CUR_CHAR(l);
4227	while (IS_CHAR(cur) && /* checked */
4228	((cur != '?') \|\| (NXT(1) != '>'))) {
4229	if (len + 5 >= size) {
4230	xmlChar *tmp;
4231
4232	size *= 2;
4233	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
4234	if (tmp == NULL) {
4235	xmlErrMemory(ctxt, NULL);
4236	xmlFree(buf);
4237	ctxt->instate = state;
4238	return;
4239	}
4240	buf = tmp;
4241	}
4242	count++;
4243	if (count > 50) {
4244	GROW;
4245	count = 0;
4246	}
4247	COPY_BUF(l,buf,len,cur);
4248	NEXTL(l);
4249	cur = CUR_CHAR(l);
4250	if (cur == 0) {
4251	SHRINK;
4252	GROW;
4253	cur = CUR_CHAR(l);
4254	}
4255	}
4256	buf[len] = 0;
4257	if (cur != '?') {
4258	xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
4259	"ParsePI: PI %s never end ...\n", target);
4260	} else {
4261	if (input != ctxt->input) {
4262	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4263	"PI declaration doesn't start and stop in the same entity\n");
4264	}
4265	SKIP(2);
4266
4267	#ifdef LIBXML_CATALOG_ENABLED
4268	if (((state == XML_PARSER_MISC) \|\|
4269	(state == XML_PARSER_START)) &&
4270	(xmlStrEqual(target, XML_CATALOG_PI))) {
4271	xmlCatalogAllow allow = xmlCatalogGetDefaults();
4272	if ((allow == XML_CATA_ALLOW_DOCUMENT) \|\|
4273	(allow == XML_CATA_ALLOW_ALL))
4274	xmlParseCatalogPI(ctxt, buf);
4275	}
4276	#endif
4277
4278
4279	/*
4280	* SAX: PI detected.
4281	*/
4282	if ((ctxt->sax) && (!ctxt->disableSAX) &&
4283	(ctxt->sax->processingInstruction != NULL))
4284	ctxt->sax->processingInstruction(ctxt->userData,
4285	target, buf);
4286	}
4287	xmlFree(buf);
4288	} else {
4289	xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL);
4290	}
4291	ctxt->instate = state;
4292	}
4293	}
4294
4295	/**
4296	* xmlParseNotationDecl:
4297	* @ctxt: an XML parser context
4298	*
4299	* parse a notation declaration
4300	*
4301	* [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID \| PublicID) S? '>'
4302	*
4303	* Hence there is actually 3 choices:
4304	* 'PUBLIC' S PubidLiteral
4305	* 'PUBLIC' S PubidLiteral S SystemLiteral
4306	* and 'SYSTEM' S SystemLiteral
4307	*
4308	* See the NOTE on xmlParseExternalID().
4309	*/
4310
4311	void
4312	xmlParseNotationDecl(xmlParserCtxtPtr ctxt) {
4313	const xmlChar *name;
4314	xmlChar *Pubid;
4315	xmlChar *Systemid;
4316
4317	if (CMP10(CUR_PTR, '<', '!', 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
4318	xmlParserInputPtr input = ctxt->input;
4319	SHRINK;
4320	SKIP(10);
4321	if (!IS_BLANK_CH(CUR)) {
4322	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4323	"Space required after '<!NOTATION'\n");
4324	return;
4325	}
4326	SKIP_BLANKS;
4327
4328	name = xmlParseName(ctxt);
4329	if (name == NULL) {
4330	xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
4331	return;
4332	}
4333	if (!IS_BLANK_CH(CUR)) {
4334	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4335	"Space required after the NOTATION name'\n");
4336	return;
4337	}
4338	SKIP_BLANKS;
4339
4340	/*
4341	* Parse the IDs.
4342	*/
4343	Systemid = xmlParseExternalID(ctxt, &Pubid, 0);
4344	SKIP_BLANKS;
4345
4346	if (RAW == '>') {
4347	if (input != ctxt->input) {
4348	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4349	"Notation declaration doesn't start and stop in the same entity\n");
4350	}
4351	NEXT;
4352	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
4353	(ctxt->sax->notationDecl != NULL))
4354	ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid);
4355	} else {
4356	xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
4357	}
4358	if (Systemid != NULL) xmlFree(Systemid);
4359	if (Pubid != NULL) xmlFree(Pubid);
4360	}
4361	}
4362
4363	/**
4364	* xmlParseEntityDecl:
4365	* @ctxt: an XML parser context
4366	*
4367	* parse <!ENTITY declarations
4368	*
4369	* [70] EntityDecl ::= GEDecl \| PEDecl
4370	*
4371	* [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>'
4372	*
4373	* [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'
4374	*
4375	* [73] EntityDef ::= EntityValue \| (ExternalID NDataDecl?)
4376	*
4377	* [74] PEDef ::= EntityValue \| ExternalID
4378	*
4379	* [76] NDataDecl ::= S 'NDATA' S Name
4380	*
4381	* [ VC: Notation Declared ]
4382	* The Name must match the declared name of a notation.
4383	*/
4384
4385	void
4386	xmlParseEntityDecl(xmlParserCtxtPtr ctxt) {
4387	const xmlChar *name = NULL;
4388	xmlChar *value = NULL;
4389	xmlChar URI = NULL, literal = NULL;
4390	const xmlChar *ndata = NULL;
4391	int isParameter = 0;
4392	xmlChar *orig = NULL;
4393	int skipped;
4394
4395	/* GROW; done in the caller */
4396	if (CMP8(CUR_PTR, '<', '!', 'E', 'N', 'T', 'I', 'T', 'Y')) {
4397	xmlParserInputPtr input = ctxt->input;
4398	SHRINK;
4399	SKIP(8);
4400	skipped = SKIP_BLANKS;
4401	if (skipped == 0) {
4402	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4403	"Space required after '<!ENTITY'\n");
4404	}
4405
4406	if (RAW == '%') {
4407	NEXT;
4408	skipped = SKIP_BLANKS;
4409	if (skipped == 0) {
4410	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4411	"Space required after '%'\n");
4412	}
4413	isParameter = 1;
4414	}
4415
4416	name = xmlParseName(ctxt);
4417	if (name == NULL) {
4418	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
4419	"xmlParseEntityDecl: no name\n");
4420	return;
4421	}
4422	skipped = SKIP_BLANKS;
4423	if (skipped == 0) {
4424	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4425	"Space required after the entity name\n");
4426	}
4427
4428	ctxt->instate = XML_PARSER_ENTITY_DECL;
4429	/*
4430	* handle the various case of definitions...
4431	*/
4432	if (isParameter) {
4433	if ((RAW == '"') \|\| (RAW == '\'')) {
4434	value = xmlParseEntityValue(ctxt, &orig);
4435	if (value) {
4436	if ((ctxt->sax != NULL) &&
4437	(!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
4438	ctxt->sax->entityDecl(ctxt->userData, name,
4439	XML_INTERNAL_PARAMETER_ENTITY,
4440	NULL, NULL, value);
4441	}
4442	} else {
4443	URI = xmlParseExternalID(ctxt, &literal, 1);
4444	if ((URI == NULL) && (literal == NULL)) {
4445	xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
4446	}
4447	if (URI) {
4448	xmlURIPtr uri;
4449
4450	uri = xmlParseURI((const char *) URI);
4451	if (uri == NULL) {
4452	xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
4453	"Invalid URI: %s\n", URI);
4454	/*
4455	* This really ought to be a well formedness error
4456	* but the XML Core WG decided otherwise c.f. issue
4457	* E26 of the XML erratas.
4458	*/
4459	} else {
4460	if (uri->fragment != NULL) {
4461	/*
4462	* Okay this is foolish to block those but not
4463	* invalid URIs.
4464	*/
4465	xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
4466	} else {
4467	if ((ctxt->sax != NULL) &&
4468	(!ctxt->disableSAX) &&
4469	(ctxt->sax->entityDecl != NULL))
4470	ctxt->sax->entityDecl(ctxt->userData, name,
4471	XML_EXTERNAL_PARAMETER_ENTITY,
4472	literal, URI, NULL);
4473	}
4474	xmlFreeURI(uri);
4475	}
4476	}
4477	}
4478	} else {
4479	if ((RAW == '"') \|\| (RAW == '\'')) {
4480	value = xmlParseEntityValue(ctxt, &orig);
4481	if ((ctxt->sax != NULL) &&
4482	(!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
4483	ctxt->sax->entityDecl(ctxt->userData, name,
4484	XML_INTERNAL_GENERAL_ENTITY,
4485	NULL, NULL, value);
4486	/*
4487	* For expat compatibility in SAX mode.
4488	*/
4489	if ((ctxt->myDoc == NULL) \|\|
4490	(xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
4491	if (ctxt->myDoc == NULL) {
4492	ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
4493	}
4494	if (ctxt->myDoc->intSubset == NULL)
4495	ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
4496	BAD_CAST "fake", NULL, NULL);
4497
4498	xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY,
4499	NULL, NULL, value);
4500	}
4501	} else {
4502	URI = xmlParseExternalID(ctxt, &literal, 1);
4503	if ((URI == NULL) && (literal == NULL)) {
4504	xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
4505	}
4506	if (URI) {
4507	xmlURIPtr uri;
4508
4509	uri = xmlParseURI((const char *)URI);
4510	if (uri == NULL) {
4511	xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
4512	"Invalid URI: %s\n", URI);
4513	/*
4514	* This really ought to be a well formedness error
4515	* but the XML Core WG decided otherwise c.f. issue
4516	* E26 of the XML erratas.
4517	*/
4518	} else {
4519	if (uri->fragment != NULL) {
4520	/*
4521	* Okay this is foolish to block those but not
4522	* invalid URIs.
4523	*/
4524	xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
4525	}
4526	xmlFreeURI(uri);
4527	}
4528	}
4529	if ((RAW != '>') && (!IS_BLANK_CH(CUR))) {
4530	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4531	"Space required before 'NDATA'\n");
4532	}
4533	SKIP_BLANKS;
4534	if (CMP5(CUR_PTR, 'N', 'D', 'A', 'T', 'A')) {
4535	SKIP(5);
4536	if (!IS_BLANK_CH(CUR)) {
4537	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4538	"Space required after 'NDATA'\n");
4539	}
4540	SKIP_BLANKS;
4541	ndata = xmlParseName(ctxt);
4542	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
4543	(ctxt->sax->unparsedEntityDecl != NULL))
4544	ctxt->sax->unparsedEntityDecl(ctxt->userData, name,
4545	literal, URI, ndata);
4546	} else {
4547	if ((ctxt->sax != NULL) &&
4548	(!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
4549	ctxt->sax->entityDecl(ctxt->userData, name,
4550	XML_EXTERNAL_GENERAL_PARSED_ENTITY,
4551	literal, URI, NULL);
4552	/*
4553	* For expat compatibility in SAX mode.
4554	* assuming the entity repalcement was asked for
4555	*/
4556	if ((ctxt->replaceEntities != 0) &&
4557	((ctxt->myDoc == NULL) \|\|
4558	(xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) {
4559	if (ctxt->myDoc == NULL) {
4560	ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
4561	}
4562
4563	if (ctxt->myDoc->intSubset == NULL)
4564	ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
4565	BAD_CAST "fake", NULL, NULL);
4566	xmlSAX2EntityDecl(ctxt, name,
4567	XML_EXTERNAL_GENERAL_PARSED_ENTITY,
4568	literal, URI, NULL);
4569	}
4570	}
4571	}
4572	}
4573	SKIP_BLANKS;
4574	if (RAW != '>') {
4575	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
4576	"xmlParseEntityDecl: entity %s not terminated\n", name);
4577	} else {
4578	if (input != ctxt->input) {
4579	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4580	"Entity declaration doesn't start and stop in the same entity\n");
4581	}
4582	NEXT;
4583	}
4584	if (orig != NULL) {
4585	/*
4586	* Ugly mechanism to save the raw entity value.
4587	*/
4588	xmlEntityPtr cur = NULL;
4589
4590	if (isParameter) {
4591	if ((ctxt->sax != NULL) &&
4592	(ctxt->sax->getParameterEntity != NULL))
4593	cur = ctxt->sax->getParameterEntity(ctxt->userData, name);
4594	} else {
4595	if ((ctxt->sax != NULL) &&
4596	(ctxt->sax->getEntity != NULL))
4597	cur = ctxt->sax->getEntity(ctxt->userData, name);
4598	if ((cur == NULL) && (ctxt->userData==ctxt)) {
4599	cur = xmlSAX2GetEntity(ctxt, name);
4600	}
4601	}
4602	if (cur != NULL) {
4603	if (cur->orig != NULL)
4604	xmlFree(orig);
4605	else
4606	cur->orig = orig;
4607	} else
4608	xmlFree(orig);
4609	}
4610	if (value != NULL) xmlFree(value);
4611	if (URI != NULL) xmlFree(URI);
4612	if (literal != NULL) xmlFree(literal);
4613	}
4614	}
4615
4616	/**
4617	* xmlParseDefaultDecl:
4618	* @ctxt: an XML parser context
4619	* @value: Receive a possible fixed default value for the attribute
4620	*
4621	* Parse an attribute default declaration
4622	*
4623	* [60] DefaultDecl ::= '#REQUIRED' \| '#IMPLIED' \| (('#FIXED' S)? AttValue)
4624	*
4625	* [ VC: Required Attribute ]
4626	* if the default declaration is the keyword #REQUIRED, then the
4627	* attribute must be specified for all elements of the type in the
4628	* attribute-list declaration.
4629	*
4630	* [ VC: Attribute Default Legal ]
4631	* The declared default value must meet the lexical constraints of
4632	* the declared attribute type c.f. xmlValidateAttributeDecl()
4633	*
4634	* [ VC: Fixed Attribute Default ]
4635	* if an attribute has a default value declared with the #FIXED
4636	* keyword, instances of that attribute must match the default value.
4637	*
4638	* [ WFC: No < in Attribute Values ]
4639	* handled in xmlParseAttValue()
4640	*
4641	* returns: XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED
4642	* or XML_ATTRIBUTE_FIXED.
4643	*/
4644
4645	int
4646	xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) {
4647	int val;
4648	xmlChar *ret;
4649
4650	*value = NULL;
4651	if (CMP9(CUR_PTR, '#', 'R', 'E', 'Q', 'U', 'I', 'R', 'E', 'D')) {
4652	SKIP(9);
4653	return(XML_ATTRIBUTE_REQUIRED);
4654	}
4655	if (CMP8(CUR_PTR, '#', 'I', 'M', 'P', 'L', 'I', 'E', 'D')) {
4656	SKIP(8);
4657	return(XML_ATTRIBUTE_IMPLIED);
4658	}
4659	val = XML_ATTRIBUTE_NONE;
4660	if (CMP6(CUR_PTR, '#', 'F', 'I', 'X', 'E', 'D')) {
4661	SKIP(6);
4662	val = XML_ATTRIBUTE_FIXED;
4663	if (!IS_BLANK_CH(CUR)) {
4664	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4665	"Space required after '#FIXED'\n");
4666	}
4667	SKIP_BLANKS;
4668	}
4669	ret = xmlParseAttValue(ctxt);
4670	ctxt->instate = XML_PARSER_DTD;
4671	if (ret == NULL) {
4672	xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo,
4673	"Attribute default value declaration error\n");
4674	} else
4675	*value = ret;
4676	return(val);
4677	}
4678
4679	/**
4680	* xmlParseNotationType:
4681	* @ctxt: an XML parser context
4682	*
4683	* parse an Notation attribute type.
4684	*
4685	* Note: the leading 'NOTATION' S part has already being parsed...
4686	*
4687	* [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '\|' S? Name)* S? ')'
4688	*
4689	* [ VC: Notation Attributes ]
4690	* Values of this type must match one of the notation names included
4691	* in the declaration; all notation names in the declaration must be declared.
4692	*
4693	* Returns: the notation attribute tree built while parsing
4694	*/
4695
4696	xmlEnumerationPtr
4697	xmlParseNotationType(xmlParserCtxtPtr ctxt) {
4698	const xmlChar *name;
4699	xmlEnumerationPtr ret = NULL, last = NULL, cur;
4700
4701	if (RAW != '(') {
4702	xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
4703	return(NULL);
4704	}
4705	SHRINK;
4706	do {
4707	NEXT;
4708	SKIP_BLANKS;
4709	name = xmlParseName(ctxt);
4710	if (name == NULL) {
4711	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
4712	"Name expected in NOTATION declaration\n");
4713	return(ret);
4714	}
4715	cur = xmlCreateEnumeration(name);
4716	if (cur == NULL) return(ret);
4717	if (last == NULL) ret = last = cur;
4718	else {
4719	last->next = cur;
4720	last = cur;
4721	}
4722	SKIP_BLANKS;
4723	} while (RAW == '\|');
4724	if (RAW != ')') {
4725	xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
4726	if ((last != NULL) && (last != ret))
4727	xmlFreeEnumeration(last);
4728	return(ret);
4729	}
4730	NEXT;
4731	return(ret);
4732	}
4733
4734	/**
4735	* xmlParseEnumerationType:
4736	* @ctxt: an XML parser context
4737	*
4738	* parse an Enumeration attribute type.
4739	*
4740	* [59] Enumeration ::= '(' S? Nmtoken (S? '\|' S? Nmtoken)* S? ')'
4741	*
4742	* [ VC: Enumeration ]
4743	* Values of this type must match one of the Nmtoken tokens in
4744	* the declaration
4745	*
4746	* Returns: the enumeration attribute tree built while parsing
4747	*/
4748
4749	xmlEnumerationPtr
4750	xmlParseEnumerationType(xmlParserCtxtPtr ctxt) {
4751	xmlChar *name;
4752	xmlEnumerationPtr ret = NULL, last = NULL, cur;
4753
4754	if (RAW != '(') {
4755	xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
4756	return(NULL);
4757	}
4758	SHRINK;
4759	do {
4760	NEXT;
4761	SKIP_BLANKS;
4762	name = xmlParseNmtoken(ctxt);
4763	if (name == NULL) {
4764	xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
4765	return(ret);
4766	}
4767	cur = xmlCreateEnumeration(name);
4768	xmlFree(name);
4769	if (cur == NULL) return(ret);
4770	if (last == NULL) ret = last = cur;
4771	else {
4772	last->next = cur;
4773	last = cur;
4774	}
4775	SKIP_BLANKS;
4776	} while (RAW == '\|');
4777	if (RAW != ')') {
4778	xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
4779	return(ret);
4780	}
4781	NEXT;
4782	return(ret);
4783	}
4784
4785	/**
4786	* xmlParseEnumeratedType:
4787	* @ctxt: an XML parser context
4788	* @tree: the enumeration tree built while parsing
4789	*
4790	* parse an Enumerated attribute type.
4791	*
4792	* [57] EnumeratedType ::= NotationType \| Enumeration
4793	*
4794	* [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '\|' S? Name)* S? ')'
4795	*
4796	*
4797	* Returns: XML_ATTRIBUTE_ENUMERATION or XML_ATTRIBUTE_NOTATION
4798	*/
4799
4800	int
4801	xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
4802	if (CMP8(CUR_PTR, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
4803	SKIP(8);
4804	if (!IS_BLANK_CH(CUR)) {
4805	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4806	"Space required after 'NOTATION'\n");
4807	return(0);
4808	}
4809	SKIP_BLANKS;
4810	*tree = xmlParseNotationType(ctxt);
4811	if (*tree == NULL) return(0);
4812	return(XML_ATTRIBUTE_NOTATION);
4813	}
4814	*tree = xmlParseEnumerationType(ctxt);
4815	if (*tree == NULL) return(0);
4816	return(XML_ATTRIBUTE_ENUMERATION);
4817	}
4818
4819	/**
4820	* xmlParseAttributeType:
4821	* @ctxt: an XML parser context
4822	* @tree: the enumeration tree built while parsing
4823	*
4824	* parse the Attribute list def for an element
4825	*
4826	* [54] AttType ::= StringType \| TokenizedType \| EnumeratedType
4827	*
4828	* [55] StringType ::= 'CDATA'
4829	*
4830	* [56] TokenizedType ::= 'ID' \| 'IDREF' \| 'IDREFS' \| 'ENTITY' \|
4831	* 'ENTITIES' \| 'NMTOKEN' \| 'NMTOKENS'
4832	*
4833	* Validity constraints for attribute values syntax are checked in
4834	* xmlValidateAttributeValue()
4835	*
4836	* [ VC: ID ]
4837	* Values of type ID must match the Name production. A name must not
4838	* appear more than once in an XML document as a value of this type;
4839	* i.e., ID values must uniquely identify the elements which bear them.
4840	*
4841	* [ VC: One ID per Element Type ]
4842	* No element type may have more than one ID attribute specified.
4843	*
4844	* [ VC: ID Attribute Default ]
4845	* An ID attribute must have a declared default of #IMPLIED or #REQUIRED.
4846	*
4847	* [ VC: IDREF ]
4848	* Values of type IDREF must match the Name production, and values
4849	* of type IDREFS must match Names; each IDREF Name must match the value
4850	* of an ID attribute on some element in the XML document; i.e. IDREF
4851	* values must match the value of some ID attribute.
4852	*
4853	* [ VC: Entity Name ]
4854	* Values of type ENTITY must match the Name production, values
4855	* of type ENTITIES must match Names; each Entity Name must match the
4856	* name of an unparsed entity declared in the DTD.
4857	*
4858	* [ VC: Name Token ]
4859	* Values of type NMTOKEN must match the Nmtoken production; values
4860	* of type NMTOKENS must match Nmtokens.
4861	*
4862	* Returns the attribute type
4863	*/
4864	int
4865	xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
4866	SHRINK;
4867	if (CMP5(CUR_PTR, 'C', 'D', 'A', 'T', 'A')) {
4868	SKIP(5);
4869	return(XML_ATTRIBUTE_CDATA);
4870	} else if (CMP6(CUR_PTR, 'I', 'D', 'R', 'E', 'F', 'S')) {
4871	SKIP(6);
4872	return(XML_ATTRIBUTE_IDREFS);
4873	} else if (CMP5(CUR_PTR, 'I', 'D', 'R', 'E', 'F')) {
4874	SKIP(5);
4875	return(XML_ATTRIBUTE_IDREF);
4876	} else if ((RAW == 'I') && (NXT(1) == 'D')) {
4877	SKIP(2);
4878	return(XML_ATTRIBUTE_ID);
4879	} else if (CMP6(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'Y')) {
4880	SKIP(6);
4881	return(XML_ATTRIBUTE_ENTITY);
4882	} else if (CMP8(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S')) {
4883	SKIP(8);
4884	return(XML_ATTRIBUTE_ENTITIES);
4885	} else if (CMP8(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S')) {
4886	SKIP(8);
4887	return(XML_ATTRIBUTE_NMTOKENS);
4888	} else if (CMP7(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N')) {
4889	SKIP(7);
4890	return(XML_ATTRIBUTE_NMTOKEN);
4891	}
4892	return(xmlParseEnumeratedType(ctxt, tree));
4893	}
4894
4895	/**
4896	* xmlParseAttributeListDecl:
4897	* @ctxt: an XML parser context
4898	*
4899	* : parse the Attribute list def for an element
4900	*
4901	* [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'
4902	*
4903	* [53] AttDef ::= S Name S AttType S DefaultDecl
4904	*
4905	*/
4906	void
4907	xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) {
4908	const xmlChar *elemName;
4909	const xmlChar *attrName;
4910	xmlEnumerationPtr tree;
4911
4912	if (CMP9(CUR_PTR, '<', '!', 'A', 'T', 'T', 'L', 'I', 'S', 'T')) {
4913	xmlParserInputPtr input = ctxt->input;
4914
4915	SKIP(9);
4916	if (!IS_BLANK_CH(CUR)) {
4917	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4918	"Space required after '<!ATTLIST'\n");
4919	}
4920	SKIP_BLANKS;
4921	elemName = xmlParseName(ctxt);
4922	if (elemName == NULL) {
4923	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
4924	"ATTLIST: no name for Element\n");
4925	return;
4926	}
4927	SKIP_BLANKS;
4928	GROW;
4929	while (RAW != '>') {
4930	const xmlChar *check = CUR_PTR;
4931	int type;
4932	int def;
4933	xmlChar *defaultValue = NULL;
4934
4935	GROW;
4936	tree = NULL;
4937	attrName = xmlParseName(ctxt);
4938	if (attrName == NULL) {
4939	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
4940	"ATTLIST: no name for Attribute\n");
4941	break;
4942	}
4943	GROW;
4944	if (!IS_BLANK_CH(CUR)) {
4945	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4946	"Space required after the attribute name\n");
4947	break;
4948	}
4949	SKIP_BLANKS;
4950
4951	type = xmlParseAttributeType(ctxt, &tree);
4952	if (type <= 0) {
4953	break;
4954	}
4955
4956	GROW;
4957	if (!IS_BLANK_CH(CUR)) {
4958	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4959	"Space required after the attribute type\n");
4960	if (tree != NULL)
4961	xmlFreeEnumeration(tree);
4962	break;
4963	}
4964	SKIP_BLANKS;
4965
4966	def = xmlParseDefaultDecl(ctxt, &defaultValue);
4967	if (def <= 0) {
4968	if (defaultValue != NULL)
4969	xmlFree(defaultValue);
4970	if (tree != NULL)
4971	xmlFreeEnumeration(tree);
4972	break;
4973	}
4974
4975	GROW;
4976	if (RAW != '>') {
4977	if (!IS_BLANK_CH(CUR)) {
4978	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4979	"Space required after the attribute default value\n");
4980	if (defaultValue != NULL)
4981	xmlFree(defaultValue);
4982	if (tree != NULL)
4983	xmlFreeEnumeration(tree);
4984	break;
4985	}
4986	SKIP_BLANKS;
4987	}
4988	if (check == CUR_PTR) {
4989	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
4990	"in xmlParseAttributeListDecl\n");
4991	if (defaultValue != NULL)
4992	xmlFree(defaultValue);
4993	if (tree != NULL)
4994	xmlFreeEnumeration(tree);
4995	break;
4996	}
4997	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
4998	(ctxt->sax->attributeDecl != NULL))
4999	ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
5000	type, def, defaultValue, tree);
5001	else if (tree != NULL)
5002	xmlFreeEnumeration(tree);
5003
5004	if ((ctxt->sax2) && (defaultValue != NULL) &&
5005	(def != XML_ATTRIBUTE_IMPLIED) &&
5006	(def != XML_ATTRIBUTE_REQUIRED)) {
5007	xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue);
5008	}
5009	if ((ctxt->sax2) && (type != XML_ATTRIBUTE_CDATA)) {
5010	xmlAddSpecialAttr(ctxt, elemName, attrName, type);
5011	}
5012	if (defaultValue != NULL)
5013	xmlFree(defaultValue);
5014	GROW;
5015	}
5016	if (RAW == '>') {
5017	if (input != ctxt->input) {
5018	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5019	"Attribute list declaration doesn't start and stop in the same entity\n");
5020	}
5021	NEXT;
5022	}
5023	}
5024	}
5025
5026	/**
5027	* xmlParseElementMixedContentDecl:
5028	* @ctxt: an XML parser context
5029	* @inputchk: the input used for the current entity, needed for boundary checks
5030	*
5031	* parse the declaration for a Mixed Element content
5032	* The leading '(' and spaces have been skipped in xmlParseElementContentDecl
5033	*
5034	* [51] Mixed ::= '(' S? '#PCDATA' (S? '\|' S? Name)* S? ')*' \|
5035	* '(' S? '#PCDATA' S? ')'
5036	*
5037	* [ VC: Proper Group/PE Nesting ] applies to [51] too (see [49])
5038	*
5039	* [ VC: No Duplicate Types ]
5040	* The same name must not appear more than once in a single
5041	* mixed-content declaration.
5042	*
5043	* returns: the list of the xmlElementContentPtr describing the element choices
5044	*/
5045	xmlElementContentPtr
5046	xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
5047	xmlElementContentPtr ret = NULL, cur = NULL, n;
5048	const xmlChar *elem = NULL;
5049
5050	GROW;
5051	if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
5052	SKIP(7);
5053	SKIP_BLANKS;
5054	SHRINK;
5055	if (RAW == ')') {
5056	if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5057	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5058	"Element content declaration doesn't start and stop in the same entity\n",
5059	NULL);
5060	}
5061	NEXT;
5062	ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
5063	if (RAW == '*') {
5064	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5065	NEXT;
5066	}
5067	return(ret);
5068	}
5069	if ((RAW == '(') \|\| (RAW == '\|')) {
5070	ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
5071	if (ret == NULL) return(NULL);
5072	}
5073	while (RAW == '\|') {
5074	NEXT;
5075	if (elem == NULL) {
5076	ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5077	if (ret == NULL) return(NULL);
5078	ret->c1 = cur;
5079	if (cur != NULL)
5080	cur->parent = ret;
5081	cur = ret;
5082	} else {
5083	n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5084	if (n == NULL) return(NULL);
5085	n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
5086	if (n->c1 != NULL)
5087	n->c1->parent = n;
5088	cur->c2 = n;
5089	if (n != NULL)
5090	n->parent = cur;
5091	cur = n;
5092	}
5093	SKIP_BLANKS;
5094	elem = xmlParseName(ctxt);
5095	if (elem == NULL) {
5096	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5097	"xmlParseElementMixedContentDecl : Name expected\n");
5098	xmlFreeDocElementContent(ctxt->myDoc, cur);
5099	return(NULL);
5100	}
5101	SKIP_BLANKS;
5102	GROW;
5103	}
5104	if ((RAW == ')') && (NXT(1) == '*')) {
5105	if (elem != NULL) {
5106	cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem,
5107	XML_ELEMENT_CONTENT_ELEMENT);
5108	if (cur->c2 != NULL)
5109	cur->c2->parent = cur;
5110	}
5111	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5112	if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5113	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5114	"Element content declaration doesn't start and stop in the same entity\n",
5115	NULL);
5116	}
5117	SKIP(2);
5118	} else {
5119	xmlFreeDocElementContent(ctxt->myDoc, ret);
5120	xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
5121	return(NULL);
5122	}
5123
5124	} else {
5125	xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
5126	}
5127	return(ret);
5128	}
5129
5130	/**
5131	* xmlParseElementChildrenContentDecl:
5132	* @ctxt: an XML parser context
5133	* @inputchk: the input used for the current entity, needed for boundary checks
5134	*
5135	* parse the declaration for a Mixed Element content
5136	* The leading '(' and spaces have been skipped in xmlParseElementContentDecl
5137	*
5138	*
5139	* [47] children ::= (choice \| seq) ('?' \| '*' \| '+')?
5140	*
5141	* [48] cp ::= (Name \| choice \| seq) ('?' \| '*' \| '+')?
5142	*
5143	* [49] choice ::= '(' S? cp ( S? '\|' S? cp )* S? ')'
5144	*
5145	* [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
5146	*
5147	* [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
5148	* TODO Parameter-entity replacement text must be properly nested
5149	* with parenthesized groups. That is to say, if either of the
5150	* opening or closing parentheses in a choice, seq, or Mixed
5151	* construct is contained in the replacement text for a parameter
5152	* entity, both must be contained in the same replacement text. For
5153	* interoperability, if a parameter-entity reference appears in a
5154	* choice, seq, or Mixed construct, its replacement text should not
5155	* be empty, and neither the first nor last non-blank character of
5156	* the replacement text should be a connector (\| or ,).
5157	*
5158	* Returns the tree of xmlElementContentPtr describing the element
5159	* hierarchy.
5160	*/
5161	xmlElementContentPtr
5162	xmlParseElementChildrenContentDecl (xmlParserCtxtPtr ctxt, int inputchk) {
5163	xmlElementContentPtr ret = NULL, cur = NULL, last = NULL, op = NULL;
5164	const xmlChar *elem;
5165	xmlChar type = 0;
5166
5167	SKIP_BLANKS;
5168	GROW;
5169	if (RAW == '(') {
5170	int inputid = ctxt->input->id;
5171
5172	/* Recurse on first child */
5173	NEXT;
5174	SKIP_BLANKS;
5175	cur = ret = xmlParseElementChildrenContentDecl(ctxt, inputid);
5176	SKIP_BLANKS;
5177	GROW;
5178	} else {
5179	elem = xmlParseName(ctxt);
5180	if (elem == NULL) {
5181	xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
5182	return(NULL);
5183	}
5184	cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
5185	if (cur == NULL) {
5186	xmlErrMemory(ctxt, NULL);
5187	return(NULL);
5188	}
5189	GROW;
5190	if (RAW == '?') {
5191	cur->ocur = XML_ELEMENT_CONTENT_OPT;
5192	NEXT;
5193	} else if (RAW == '*') {
5194	cur->ocur = XML_ELEMENT_CONTENT_MULT;
5195	NEXT;
5196	} else if (RAW == '+') {
5197	cur->ocur = XML_ELEMENT_CONTENT_PLUS;
5198	NEXT;
5199	} else {
5200	cur->ocur = XML_ELEMENT_CONTENT_ONCE;
5201	}
5202	GROW;
5203	}
5204	SKIP_BLANKS;
5205	SHRINK;
5206	while (RAW != ')') {
5207	/*
5208	* Each loop we parse one separator and one element.
5209	*/
5210	if (RAW == ',') {
5211	if (type == 0) type = CUR;
5212
5213	/*
5214	* Detect "Name \| Name , Name" error
5215	*/
5216	else if (type != CUR) {
5217	xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
5218	"xmlParseElementChildrenContentDecl : '%c' expected\n",
5219	type);
5220	if ((last != NULL) && (last != ret))
5221	xmlFreeDocElementContent(ctxt->myDoc, last);
5222	if (ret != NULL)
5223	xmlFreeDocElementContent(ctxt->myDoc, ret);
5224	return(NULL);
5225	}
5226	NEXT;
5227
5228	op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ);
5229	if (op == NULL) {
5230	if ((last != NULL) && (last != ret))
5231	xmlFreeDocElementContent(ctxt->myDoc, last);
5232	xmlFreeDocElementContent(ctxt->myDoc, ret);
5233	return(NULL);
5234	}
5235	if (last == NULL) {
5236	op->c1 = ret;
5237	if (ret != NULL)
5238	ret->parent = op;
5239	ret = cur = op;
5240	} else {
5241	cur->c2 = op;
5242	if (op != NULL)
5243	op->parent = cur;
5244	op->c1 = last;
5245	if (last != NULL)
5246	last->parent = op;
5247	cur =op;
5248	last = NULL;
5249	}
5250	} else if (RAW == '\|') {
5251	if (type == 0) type = CUR;
5252
5253	/*
5254	* Detect "Name , Name \| Name" error
5255	*/
5256	else if (type != CUR) {
5257	xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
5258	"xmlParseElementChildrenContentDecl : '%c' expected\n",
5259	type);
5260	if ((last != NULL) && (last != ret))
5261	xmlFreeDocElementContent(ctxt->myDoc, last);
5262	if (ret != NULL)
5263	xmlFreeDocElementContent(ctxt->myDoc, ret);
5264	return(NULL);
5265	}
5266	NEXT;
5267
5268	op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5269	if (op == NULL) {
5270	if ((last != NULL) && (last != ret))
5271	xmlFreeDocElementContent(ctxt->myDoc, last);
5272	if (ret != NULL)
5273	xmlFreeDocElementContent(ctxt->myDoc, ret);
5274	return(NULL);
5275	}
5276	if (last == NULL) {
5277	op->c1 = ret;
5278	if (ret != NULL)
5279	ret->parent = op;
5280	ret = cur = op;
5281	} else {
5282	cur->c2 = op;
5283	if (op != NULL)
5284	op->parent = cur;
5285	op->c1 = last;
5286	if (last != NULL)
5287	last->parent = op;
5288	cur =op;
5289	last = NULL;
5290	}
5291	} else {
5292	xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL);
5293	if (ret != NULL)
5294	xmlFreeDocElementContent(ctxt->myDoc, ret);
5295	return(NULL);
5296	}
5297	GROW;
5298	SKIP_BLANKS;
5299	GROW;
5300	if (RAW == '(') {
5301	int inputid = ctxt->input->id;
5302	/* Recurse on second child */
5303	NEXT;
5304	SKIP_BLANKS;
5305	last = xmlParseElementChildrenContentDecl(ctxt, inputid);
5306	SKIP_BLANKS;
5307	} else {
5308	elem = xmlParseName(ctxt);
5309	if (elem == NULL) {
5310	xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
5311	if (ret != NULL)
5312	xmlFreeDocElementContent(ctxt->myDoc, ret);
5313	return(NULL);
5314	}
5315	last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
5316	if (RAW == '?') {
5317	last->ocur = XML_ELEMENT_CONTENT_OPT;
5318	NEXT;
5319	} else if (RAW == '*') {
5320	last->ocur = XML_ELEMENT_CONTENT_MULT;
5321	NEXT;
5322	} else if (RAW == '+') {
5323	last->ocur = XML_ELEMENT_CONTENT_PLUS;
5324	NEXT;
5325	} else {
5326	last->ocur = XML_ELEMENT_CONTENT_ONCE;
5327	}
5328	}
5329	SKIP_BLANKS;
5330	GROW;
5331	}
5332	if ((cur != NULL) && (last != NULL)) {
5333	cur->c2 = last;
5334	if (last != NULL)
5335	last->parent = cur;
5336	}
5337	if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5338	xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5339	"Element content declaration doesn't start and stop in the same entity\n",
5340	NULL);
5341	}
5342	NEXT;
5343	if (RAW == '?') {
5344	if (ret != NULL) {
5345	if ((ret->ocur == XML_ELEMENT_CONTENT_PLUS) \|\|
5346	(ret->ocur == XML_ELEMENT_CONTENT_MULT))
5347	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5348	else
5349	ret->ocur = XML_ELEMENT_CONTENT_OPT;
5350	}
5351	NEXT;
5352	} else if (RAW == '*') {
5353	if (ret != NULL) {
5354	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5355	cur = ret;
5356	/*
5357	* Some normalization:
5358	* (a \| b* \| c?)* == (a \| b \| c)*
5359	*/
5360	while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
5361	if ((cur->c1 != NULL) &&
5362	((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
5363	(cur->c1->ocur == XML_ELEMENT_CONTENT_MULT)))
5364	cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
5365	if ((cur->c2 != NULL) &&
5366	((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
5367	(cur->c2->ocur == XML_ELEMENT_CONTENT_MULT)))
5368	cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
5369	cur = cur->c2;
5370	}
5371	}
5372	NEXT;
5373	} else if (RAW == '+') {
5374	if (ret != NULL) {
5375	int found = 0;
5376
5377	if ((ret->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
5378	(ret->ocur == XML_ELEMENT_CONTENT_MULT))
5379	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5380	else
5381	ret->ocur = XML_ELEMENT_CONTENT_PLUS;
5382	/*
5383	* Some normalization:
5384	* (a \| b)+ == (a \| b)
5385	* (a \| b?)+ == (a \| b)*
5386	*/
5387	while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
5388	if ((cur->c1 != NULL) &&
5389	((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
5390	(cur->c1->ocur == XML_ELEMENT_CONTENT_MULT))) {
5391	cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
5392	found = 1;
5393	}
5394	if ((cur->c2 != NULL) &&
5395	((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) \|\|
5396	(cur->c2->ocur == XML_ELEMENT_CONTENT_MULT))) {
5397	cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
5398	found = 1;
5399	}
5400	cur = cur->c2;
5401	}
5402	if (found)
5403	ret->ocur = XML_ELEMENT_CONTENT_MULT;
5404	}
5405	NEXT;
5406	}
5407	return(ret);
5408	}
5409
5410	/**
5411	* xmlParseElementContentDecl:
5412	* @ctxt: an XML parser context
5413	* @name: the name of the element being defined.
5414	* @result: the Element Content pointer will be stored here if any
5415	*
5416	* parse the declaration for an Element content either Mixed or Children,
5417	* the cases EMPTY and ANY are handled directly in xmlParseElementDecl
5418	*
5419	* [46] contentspec ::= 'EMPTY' \| 'ANY' \| Mixed \| children
5420	*
5421	* returns: the type of element content XML_ELEMENT_TYPE_xxx
5422	*/
5423
5424	int
5425	xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name,
5426	xmlElementContentPtr *result) {
5427
5428	xmlElementContentPtr tree = NULL;
5429	int inputid = ctxt->input->id;
5430	int res;
5431
5432	*result = NULL;
5433
5434	if (RAW != '(') {
5435	xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
5436	"xmlParseElementContentDecl : %s '(' expected\n", name);
5437	return(-1);
5438	}
5439	NEXT;
5440	GROW;
5441	SKIP_BLANKS;
5442	if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
5443	tree = xmlParseElementMixedContentDecl(ctxt, inputid);
5444	res = XML_ELEMENT_TYPE_MIXED;
5445	} else {
5446	tree = xmlParseElementChildrenContentDecl(ctxt, inputid);
5447	res = XML_ELEMENT_TYPE_ELEMENT;
5448	}
5449	SKIP_BLANKS;
5450	*result = tree;
5451	return(res);
5452	}
5453
5454	/**
5455	* xmlParseElementDecl:
5456	* @ctxt: an XML parser context
5457	*
5458	* parse an Element declaration.
5459	*
5460	* [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>'
5461	*
5462	* [ VC: Unique Element Type Declaration ]
5463	* No element type may be declared more than once
5464	*
5465	* Returns the type of the element, or -1 in case of error
5466	*/
5467	int
5468	xmlParseElementDecl(xmlParserCtxtPtr ctxt) {
5469	const xmlChar *name;
5470	int ret = -1;
5471	xmlElementContentPtr content = NULL;
5472
5473	/* GROW; done in the caller */
5474	if (CMP9(CUR_PTR, '<', '!', 'E', 'L', 'E', 'M', 'E', 'N', 'T')) {
5475	xmlParserInputPtr input = ctxt->input;
5476
5477	SKIP(9);
5478	if (!IS_BLANK_CH(CUR)) {
5479	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5480	"Space required after 'ELEMENT'\n");
5481	}
5482	SKIP_BLANKS;
5483	name = xmlParseName(ctxt);
5484	if (name == NULL) {
5485	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5486	"xmlParseElementDecl: no name for Element\n");
5487	return(-1);
5488	}
5489	while ((RAW == 0) && (ctxt->inputNr > 1))
5490	xmlPopInput(ctxt);
5491	if (!IS_BLANK_CH(CUR)) {
5492	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5493	"Space required after the element name\n");
5494	}
5495	SKIP_BLANKS;
5496	if (CMP5(CUR_PTR, 'E', 'M', 'P', 'T', 'Y')) {
5497	SKIP(5);
5498	/*
5499	* Element must always be empty.
5500	*/
5501	ret = XML_ELEMENT_TYPE_EMPTY;
5502	} else if ((RAW == 'A') && (NXT(1) == 'N') &&
5503	(NXT(2) == 'Y')) {
5504	SKIP(3);
5505	/*
5506	* Element is a generic container.
5507	*/
5508	ret = XML_ELEMENT_TYPE_ANY;
5509	} else if (RAW == '(') {
5510	ret = xmlParseElementContentDecl(ctxt, name, &content);
5511	} else {
5512	/*
5513	* [ WFC: PEs in Internal Subset ] error handling.
5514	*/
5515	if ((RAW == '%') && (ctxt->external == 0) &&
5516	(ctxt->inputNr == 1)) {
5517	xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET,
5518	"PEReference: forbidden within markup decl in internal subset\n");
5519	} else {
5520	xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
5521	"xmlParseElementDecl: 'EMPTY', 'ANY' or '(' expected\n");
5522	}
5523	return(-1);
5524	}
5525
5526	SKIP_BLANKS;
5527	/*
5528	* Pop-up of finished entities.
5529	*/
5530	while ((RAW == 0) && (ctxt->inputNr > 1))
5531	xmlPopInput(ctxt);
5532	SKIP_BLANKS;
5533
5534	if (RAW != '>') {
5535	xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
5536	if (content != NULL) {
5537	xmlFreeDocElementContent(ctxt->myDoc, content);
5538	}
5539	} else {
5540	if (input != ctxt->input) {
5541	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5542	"Element declaration doesn't start and stop in the same entity\n");
5543	}
5544
5545	NEXT;
5546	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5547	(ctxt->sax->elementDecl != NULL)) {
5548	if (content != NULL)
5549	content->parent = NULL;
5550	ctxt->sax->elementDecl(ctxt->userData, name, ret,
5551	content);
5552	if ((content != NULL) && (content->parent == NULL)) {
5553	/*
5554	* this is a trick: if xmlAddElementDecl is called,
5555	* instead of copying the full tree it is plugged directly
5556	* if called from the parser. Avoid duplicating the
5557	* interfaces or change the API/ABI
5558	*/
5559	xmlFreeDocElementContent(ctxt->myDoc, content);
5560	}
5561	} else if (content != NULL) {
5562	xmlFreeDocElementContent(ctxt->myDoc, content);
5563	}
5564	}
5565	}
5566	return(ret);
5567	}
5568
5569	/**
5570	* xmlParseConditionalSections
5571	* @ctxt: an XML parser context
5572	*
5573	* [61] conditionalSect ::= includeSect \| ignoreSect
5574	* [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>'
5575	* [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>'
5576	* [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)*
5577	* [65] Ignore ::= Char* - (Char* ('<![' \| ']]>') Char*)
5578	*/
5579
5580	static void
5581	xmlParseConditionalSections(xmlParserCtxtPtr ctxt) {
5582	SKIP(3);
5583	SKIP_BLANKS;
5584	if (CMP7(CUR_PTR, 'I', 'N', 'C', 'L', 'U', 'D', 'E')) {
5585	SKIP(7);
5586	SKIP_BLANKS;
5587	if (RAW != '[') {
5588	xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
5589	} else {
5590	NEXT;
5591	}
5592	if (xmlParserDebugEntities) {
5593	if ((ctxt->input != NULL) && (ctxt->input->filename))
5594	xmlGenericError(xmlGenericErrorContext,
5595	"%s(%d): ", ctxt->input->filename,
5596	ctxt->input->line);
5597	xmlGenericError(xmlGenericErrorContext,
5598	"Entering INCLUDE Conditional Section\n");
5599	}
5600
5601	while ((RAW != 0) && ((RAW != ']') \|\| (NXT(1) != ']') \|\|
5602	(NXT(2) != '>'))) {
5603	const xmlChar *check = CUR_PTR;
5604	unsigned int cons = ctxt->input->consumed;
5605
5606	if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
5607	xmlParseConditionalSections(ctxt);
5608	} else if (IS_BLANK_CH(CUR)) {
5609	NEXT;
5610	} else if (RAW == '%') {
5611	xmlParsePEReference(ctxt);
5612	} else
5613	xmlParseMarkupDecl(ctxt);
5614
5615	/*
5616	* Pop-up of finished entities.
5617	*/
5618	while ((RAW == 0) && (ctxt->inputNr > 1))
5619	xmlPopInput(ctxt);
5620
5621	if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
5622	xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
5623	break;
5624	}
5625	}
5626	if (xmlParserDebugEntities) {
5627	if ((ctxt->input != NULL) && (ctxt->input->filename))
5628	xmlGenericError(xmlGenericErrorContext,
5629	"%s(%d): ", ctxt->input->filename,
5630	ctxt->input->line);
5631	xmlGenericError(xmlGenericErrorContext,
5632	"Leaving INCLUDE Conditional Section\n");
5633	}
5634
5635	} else if (CMP6(CUR_PTR, 'I', 'G', 'N', 'O', 'R', 'E')) {
5636	int state;
5637	xmlParserInputState instate;
5638	int depth = 0;
5639
5640	SKIP(6);
5641	SKIP_BLANKS;
5642	if (RAW != '[') {
5643	xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
5644	} else {
5645	NEXT;
5646	}
5647	if (xmlParserDebugEntities) {
5648	if ((ctxt->input != NULL) && (ctxt->input->filename))
5649	xmlGenericError(xmlGenericErrorContext,
5650	"%s(%d): ", ctxt->input->filename,
5651	ctxt->input->line);
5652	xmlGenericError(xmlGenericErrorContext,
5653	"Entering IGNORE Conditional Section\n");
5654	}
5655
5656	/*
5657	* Parse up to the end of the conditional section
5658	* But disable SAX event generating DTD building in the meantime
5659	*/
5660	state = ctxt->disableSAX;
5661	instate = ctxt->instate;
5662	if (ctxt->recovery == 0) ctxt->disableSAX = 1;
5663	ctxt->instate = XML_PARSER_IGNORE;
5664
5665	while ((depth >= 0) && (RAW != 0)) {
5666	if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
5667	depth++;
5668	SKIP(3);
5669	continue;
5670	}
5671	if ((RAW == ']') && (NXT(1) == ']') && (NXT(2) == '>')) {
5672	if (--depth >= 0) SKIP(3);
5673	continue;
5674	}
5675	NEXT;
5676	continue;
5677	}
5678
5679	ctxt->disableSAX = state;
5680	ctxt->instate = instate;
5681
5682	if (xmlParserDebugEntities) {
5683	if ((ctxt->input != NULL) && (ctxt->input->filename))
5684	xmlGenericError(xmlGenericErrorContext,
5685	"%s(%d): ", ctxt->input->filename,
5686	ctxt->input->line);
5687	xmlGenericError(xmlGenericErrorContext,
5688	"Leaving IGNORE Conditional Section\n");
5689	}
5690
5691	} else {
5692	xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
5693	}
5694
5695	if (RAW == 0)
5696	SHRINK;
5697
5698	if (RAW == 0) {
5699	xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
5700	} else {
5701	SKIP(3);
5702	}
5703	}
5704
5705	/**
5706	* xmlParseMarkupDecl:
5707	* @ctxt: an XML parser context
5708	*
5709	* parse Markup declarations
5710	*
5711	* [29] markupdecl ::= elementdecl \| AttlistDecl \| EntityDecl \|
5712	* NotationDecl \| PI \| Comment
5713	*
5714	* [ VC: Proper Declaration/PE Nesting ]
5715	* Parameter-entity replacement text must be properly nested with
5716	* markup declarations. That is to say, if either the first character
5717	* or the last character of a markup declaration (markupdecl above) is
5718	* contained in the replacement text for a parameter-entity reference,
5719	* both must be contained in the same replacement text.
5720	*
5721	* [ WFC: PEs in Internal Subset ]
5722	* In the internal DTD subset, parameter-entity references can occur
5723	* only where markup declarations can occur, not within markup declarations.
5724	* (This does not apply to references that occur in external parameter
5725	* entities or to the external subset.)
5726	*/
5727	void
5728	xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) {
5729	GROW;
5730	if (CUR == '<') {
5731	if (NXT(1) == '!') {
5732	switch (NXT(2)) {
5733	case 'E':
5734	if (NXT(3) == 'L')
5735	xmlParseElementDecl(ctxt);
5736	else if (NXT(3) == 'N')
5737	xmlParseEntityDecl(ctxt);
5738	break;
5739	case 'A':
5740	xmlParseAttributeListDecl(ctxt);
5741	break;
5742	case 'N':
5743	xmlParseNotationDecl(ctxt);
5744	break;
5745	case '-':
5746	xmlParseComment(ctxt);
5747	break;
5748	default:
5749	/* there is an error but it will be detected later */
5750	break;
5751	}
5752	} else if (NXT(1) == '?') {
5753	xmlParsePI(ctxt);
5754	}
5755	}
5756	/*
5757	* This is only for internal subset. On external entities,
5758	* the replacement is done before parsing stage
5759	*/
5760	if ((ctxt->external == 0) && (ctxt->inputNr == 1))
5761	xmlParsePEReference(ctxt);
5762
5763	/*
5764	* Conditional sections are allowed from entities included
5765	* by PE References in the internal subset.
5766	*/
5767	if ((ctxt->external == 0) && (ctxt->inputNr > 1)) {
5768	if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
5769	xmlParseConditionalSections(ctxt);
5770	}
5771	}
5772
5773	ctxt->instate = XML_PARSER_DTD;
5774	}
5775
5776	/**
5777	* xmlParseTextDecl:
5778	* @ctxt: an XML parser context
5779	*
5780	* parse an XML declaration header for external entities
5781	*
5782	* [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
5783	*
5784	* Question: Seems that EncodingDecl is mandatory ? Is that a typo ?
5785	*/
5786
5787	void
5788	xmlParseTextDecl(xmlParserCtxtPtr ctxt) {
5789	xmlChar *version;
5790	const xmlChar *encoding;
5791
5792	/*
5793	* We know that '<?xml' is here.
5794	*/
5795	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
5796	SKIP(5);
5797	} else {
5798	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL);
5799	return;
5800	}
5801
5802	if (!IS_BLANK_CH(CUR)) {
5803	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5804	"Space needed after '<?xml'\n");
5805	}
5806	SKIP_BLANKS;
5807
5808	/*
5809	* We may have the VersionInfo here.
5810	*/
5811	version = xmlParseVersionInfo(ctxt);
5812	if (version == NULL)
5813	version = xmlCharStrdup(XML_DEFAULT_VERSION);
5814	else {
5815	if (!IS_BLANK_CH(CUR)) {
5816	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5817	"Space needed here\n");
5818	}
5819	}
5820	ctxt->input->version = version;
5821
5822	/*
5823	* We must have the encoding declaration
5824	*/
5825	encoding = xmlParseEncodingDecl(ctxt);
5826	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
5827	/*
5828	* The XML REC instructs us to stop parsing right here
5829	*/
5830	return;
5831	}
5832	if ((encoding == NULL) && (ctxt->errNo == XML_ERR_OK)) {
5833	xmlFatalErrMsg(ctxt, XML_ERR_MISSING_ENCODING,
5834	"Missing encoding in text declaration\n");
5835	}
5836
5837	SKIP_BLANKS;
5838	if ((RAW == '?') && (NXT(1) == '>')) {
5839	SKIP(2);
5840	} else if (RAW == '>') {
5841	/* Deprecated old WD ... */
5842	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
5843	NEXT;
5844	} else {
5845	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
5846	MOVETO_ENDTAG(CUR_PTR);
5847	NEXT;
5848	}
5849	}
5850
5851	/**
5852	* xmlParseExternalSubset:
5853	* @ctxt: an XML parser context
5854	* @ExternalID: the external identifier
5855	* @SystemID: the system identifier (or URL)
5856	*
5857	* parse Markup declarations from an external subset
5858	*
5859	* [30] extSubset ::= textDecl? extSubsetDecl
5860	*
5861	* [31] extSubsetDecl ::= (markupdecl \| conditionalSect \| PEReference \| S) *
5862	*/
5863	void
5864	xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID,
5865	const xmlChar *SystemID) {
5866	xmlDetectSAX2(ctxt);
5867	GROW;
5868	if (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) {
5869	xmlParseTextDecl(ctxt);
5870	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
5871	/*
5872	* The XML REC instructs us to stop parsing right here
5873	*/
5874	ctxt->instate = XML_PARSER_EOF;
5875	return;
5876	}
5877	}
5878	if (ctxt->myDoc == NULL) {
5879	ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
5880	}
5881	if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
5882	xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
5883
5884	ctxt->instate = XML_PARSER_DTD;
5885	ctxt->external = 1;
5886	while (((RAW == '<') && (NXT(1) == '?')) \|\|
5887	((RAW == '<') && (NXT(1) == '!')) \|\|
5888	(RAW == '%') \|\| IS_BLANK_CH(CUR)) {
5889	const xmlChar *check = CUR_PTR;
5890	unsigned int cons = ctxt->input->consumed;
5891
5892	GROW;
5893	if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
5894	xmlParseConditionalSections(ctxt);
5895	} else if (IS_BLANK_CH(CUR)) {
5896	NEXT;
5897	} else if (RAW == '%') {
5898	xmlParsePEReference(ctxt);
5899	} else
5900	xmlParseMarkupDecl(ctxt);
5901
5902	/*
5903	* Pop-up of finished entities.
5904	*/
5905	while ((RAW == 0) && (ctxt->inputNr > 1))
5906	xmlPopInput(ctxt);
5907
5908	if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
5909	xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
5910	break;
5911	}
5912	}
5913
5914	if (RAW != 0) {
5915	xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
5916	}
5917
5918	}
5919
5920	/**
5921	* xmlParseReference:
5922	* @ctxt: an XML parser context
5923	*
5924	* parse and handle entity references in content, depending on the SAX
5925	* interface, this may end-up in a call to character() if this is a
5926	* CharRef, a predefined entity, if there is no reference() callback.
5927	* or if the parser was asked to switch to that mode.
5928	*
5929	* [67] Reference ::= EntityRef \| CharRef
5930	*/
5931	void
5932	xmlParseReference(xmlParserCtxtPtr ctxt) {
5933	xmlEntityPtr ent;
5934	xmlChar *val;
5935	if (RAW != '&') return;
5936
5937	if (NXT(1) == '#') {
5938	int i = 0;
5939	xmlChar out[10];
5940	int hex = NXT(2);
5941	int value = xmlParseCharRef(ctxt);
5942
5943	if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
5944	/*
5945	* So we are using non-UTF-8 buffers
5946	* Check that the char fit on 8bits, if not
5947	* generate a CharRef.
5948	*/
5949	if (value <= 0xFF) {
5950	out[0] = value;
5951	out[1] = 0;
5952	if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
5953	(!ctxt->disableSAX))
5954	ctxt->sax->characters(ctxt->userData, out, 1);
5955	} else {
5956	if ((hex == 'x') \|\| (hex == 'X'))
5957	snprintf((char *)out, sizeof(out), "#x%X", value);
5958	else
5959	snprintf((char *)out, sizeof(out), "#%d", value);
5960	if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
5961	(!ctxt->disableSAX))
5962	ctxt->sax->reference(ctxt->userData, out);
5963	}
5964	} else {
5965	/*
5966	* Just encode the value in UTF-8
5967	*/
5968	COPY_BUF(0 ,out, i, value);
5969	out[i] = 0;
5970	if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
5971	(!ctxt->disableSAX))
5972	ctxt->sax->characters(ctxt->userData, out, i);
5973	}
5974	} else {
5975	int was_checked;
5976
5977	ent = xmlParseEntityRef(ctxt);
5978	if (ent == NULL) return;
5979	if (!ctxt->wellFormed)
5980	return;
5981	was_checked = ent->checked;
5982	if ((ent->name != NULL) &&
5983	(ent->etype != XML_INTERNAL_PREDEFINED_ENTITY)) {
5984	xmlNodePtr list = NULL;
5985	xmlParserErrors ret = XML_ERR_OK;
5986
5987
5988	/*
5989	* The first reference to the entity trigger a parsing phase
5990	* where the ent->children is filled with the result from
5991	* the parsing.
5992	*/
5993	if (ent->checked == 0) {
5994	xmlChar *value;
5995
5996	value = ent->content;
5997
5998	/*
5999	* Check that this entity is well formed
6000	*/
6001	if ((value != NULL) && (value[0] != 0) &&
6002	(value[1] == 0) && (value[0] == '<') &&
6003	(xmlStrEqual(ent->name, BAD_CAST "lt"))) {
6004	/*
6005	* DONE: get definite answer on this !!!
6006	* Lots of entity decls are used to declare a single
6007	* char
6008	* <!ENTITY lt "<">
6009	* Which seems to be valid since
6010	* 2.4: The ampersand character (&) and the left angle
6011	* bracket (<) may appear in their literal form only
6012	* when used ... They are also legal within the literal
6013	* entity value of an internal entity declaration;i
6014	* see "4.3.2 Well-Formed Parsed Entities".
6015	* IMHO 2.4 and 4.3.2 are directly in contradiction.
6016	* Looking at the OASIS test suite and James Clark
6017	* tests, this is broken. However the XML REC uses
6018	* it. Is the XML REC not well-formed ????
6019	* This is a hack to avoid this problem
6020	*
6021	* ANSWER: since lt gt amp .. are already defined,
6022	* this is a redefinition and hence the fact that the
6023	* content is not well balanced is not a Wf error, this
6024	* is lousy but acceptable.
6025	*/
6026	list = xmlNewDocText(ctxt->myDoc, value);
6027	if (list != NULL) {
6028	if ((ent->etype == XML_INTERNAL_GENERAL_ENTITY) &&
6029	(ent->children == NULL)) {
6030	ent->children = list;
6031	ent->last = list;
6032	ent->owner = 1;
6033	list->parent = (xmlNodePtr) ent;
6034	} else {
6035	xmlFreeNodeList(list);
6036	}
6037	} else if (list != NULL) {
6038	xmlFreeNodeList(list);
6039	}
6040	} else {
6041	/*
6042	* 4.3.2: An internal general parsed entity is well-formed
6043	* if its replacement text matches the production labeled
6044	* content.
6045	*/
6046
6047	void *user_data;
6048	/*
6049	* This is a bit hackish but this seems the best
6050	* way to make sure both SAX and DOM entity support
6051	* behaves okay.
6052	*/
6053	if (ctxt->userData == ctxt)
6054	user_data = NULL;
6055	else
6056	user_data = ctxt->userData;
6057
6058	if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
6059	ctxt->depth++;
6060	ret = xmlParseBalancedChunkMemoryInternal(ctxt,
6061	value, user_data, &list);
6062	ctxt->depth--;
6063	} else if (ent->etype ==
6064	XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
6065	ctxt->depth++;
6066	ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
6067	ctxt->sax, user_data, ctxt->depth,
6068	ent->URI, ent->ExternalID, &list);
6069	ctxt->depth--;
6070	} else {
6071	ret = XML_ERR_ENTITY_PE_INTERNAL;
6072	xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
6073	"invalid entity type found\n", NULL);
6074	}
6075	if (ret == XML_ERR_ENTITY_LOOP) {
6076	xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
6077	return;
6078	} else if ((ret == XML_ERR_OK) && (list != NULL)) {
6079	if (((ent->etype == XML_INTERNAL_GENERAL_ENTITY) \|\|
6080	(ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY))&&
6081	(ent->children == NULL)) {
6082	ent->children = list;
6083	if (ctxt->replaceEntities) {
6084	/*
6085	* Prune it directly in the generated document
6086	* except for single text nodes.
6087	*/
6088	if (((list->type == XML_TEXT_NODE) &&
6089	(list->next == NULL)) \|\|
6090	(ctxt->parseMode == XML_PARSE_READER)) {
6091	list->parent = (xmlNodePtr) ent;
6092	list = NULL;
6093	ent->owner = 1;
6094	} else {
6095	ent->owner = 0;
6096	while (list != NULL) {
6097	list->parent = (xmlNodePtr) ctxt->node;
6098	list->doc = ctxt->myDoc;
6099	if (list->next == NULL)
6100	ent->last = list;
6101	list = list->next;
6102	}
6103	list = ent->children;
6104	#ifdef LIBXML_LEGACY_ENABLED
6105	if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
6106	xmlAddEntityReference(ent, list, NULL);
6107	#endif /* LIBXML_LEGACY_ENABLED */
6108	}
6109	} else {
6110	ent->owner = 1;
6111	while (list != NULL) {
6112	list->parent = (xmlNodePtr) ent;
6113	if (list->next == NULL)
6114	ent->last = list;
6115	list = list->next;
6116	}
6117	}
6118	} else {
6119	xmlFreeNodeList(list);
6120	list = NULL;
6121	}
6122	} else if ((ret != XML_ERR_OK) &&
6123	(ret != XML_WAR_UNDECLARED_ENTITY)) {
6124	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6125	"Entity '%s' failed to parse\n", ent->name);
6126	} else if (list != NULL) {
6127	xmlFreeNodeList(list);
6128	list = NULL;
6129	}
6130	}
6131	ent->checked = 1;
6132	}
6133
6134	if (ent->children == NULL) {
6135	/*
6136	* Probably running in SAX mode and the callbacks don't
6137	* build the entity content. So unless we already went
6138	* though parsing for first checking go though the entity
6139	* content to generate callbacks associated to the entity
6140	*/
6141	if (was_checked == 1) {
6142	void *user_data;
6143	/*
6144	* This is a bit hackish but this seems the best
6145	* way to make sure both SAX and DOM entity support
6146	* behaves okay.
6147	*/
6148	if (ctxt->userData == ctxt)
6149	user_data = NULL;
6150	else
6151	user_data = ctxt->userData;
6152
6153	if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
6154	ctxt->depth++;
6155	ret = xmlParseBalancedChunkMemoryInternal(ctxt,
6156	ent->content, user_data, NULL);
6157	ctxt->depth--;
6158	} else if (ent->etype ==
6159	XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
6160	ctxt->depth++;
6161	ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
6162	ctxt->sax, user_data, ctxt->depth,
6163	ent->URI, ent->ExternalID, NULL);
6164	ctxt->depth--;
6165	} else {
6166	ret = XML_ERR_ENTITY_PE_INTERNAL;
6167	xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
6168	"invalid entity type found\n", NULL);
6169	}
6170	if (ret == XML_ERR_ENTITY_LOOP) {
6171	xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
6172	return;
6173	}
6174	}
6175	if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
6176	(ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
6177	/*
6178	* Entity reference callback comes second, it's somewhat
6179	* superfluous but a compatibility to historical behaviour
6180	*/
6181	ctxt->sax->reference(ctxt->userData, ent->name);
6182	}
6183	return;
6184	}
6185	if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
6186	(ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
6187	/*
6188	* Create a node.
6189	*/
6190	ctxt->sax->reference(ctxt->userData, ent->name);
6191	return;
6192	}
6193	if ((ctxt->replaceEntities) \|\| (ent->children == NULL)) {
6194	/*
6195	* There is a problem on the handling of _private for entities
6196	* (bug 155816): Should we copy the content of the field from
6197	* the entity (possibly overwriting some value set by the user
6198	* when a copy is created), should we leave it alone, or should
6199	* we try to take care of different situations? The problem
6200	* is exacerbated by the usage of this field by the xmlReader.
6201	* To fix this bug, we look at _private on the created node
6202	* and, if it's NULL, we copy in whatever was in the entity.
6203	* If it's not NULL we leave it alone. This is somewhat of a
6204	* hack - maybe we should have further tests to determine
6205	* what to do.
6206	*/
6207	if ((ctxt->node != NULL) && (ent->children != NULL)) {
6208	/*
6209	* Seems we are generating the DOM content, do
6210	* a simple tree copy for all references except the first
6211	* In the first occurrence list contains the replacement.
6212	* progressive == 2 means we are operating on the Reader
6213	* and since nodes are discarded we must copy all the time.
6214	*/
6215	if (((list == NULL) && (ent->owner == 0)) \|\|
6216	(ctxt->parseMode == XML_PARSE_READER)) {
6217	xmlNodePtr nw = NULL, cur, firstChild = NULL;
6218
6219	/*
6220	* when operating on a reader, the entities definitions
6221	* are always owning the entities subtree.
6222	if (ctxt->parseMode == XML_PARSE_READER)
6223	ent->owner = 1;
6224	*/
6225
6226	cur = ent->children;
6227	while (cur != NULL) {
6228	nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
6229	if (nw != NULL) {
6230	if (nw->_private == NULL)
6231	nw->_private = cur->_private;
6232	if (firstChild == NULL){
6233	firstChild = nw;
6234	}
6235	nw = xmlAddChild(ctxt->node, nw);
6236	}
6237	if (cur == ent->last) {
6238	/*
6239	* needed to detect some strange empty
6240	* node cases in the reader tests
6241	*/
6242	if ((ctxt->parseMode == XML_PARSE_READER) &&
6243	(nw != NULL) &&
6244	(nw->type == XML_ELEMENT_NODE) &&
6245	(nw->children == NULL))
6246	nw->extra = 1;
6247
6248	break;
6249	}
6250	cur = cur->next;
6251	}
6252	#ifdef LIBXML_LEGACY_ENABLED
6253	if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
6254	xmlAddEntityReference(ent, firstChild, nw);
6255	#endif /* LIBXML_LEGACY_ENABLED */
6256	} else if (list == NULL) {
6257	xmlNodePtr nw = NULL, cur, next, last,
6258	firstChild = NULL;
6259	/*
6260	* Copy the entity child list and make it the new
6261	* entity child list. The goal is to make sure any
6262	* ID or REF referenced will be the one from the
6263	* document content and not the entity copy.
6264	*/
6265	cur = ent->children;
6266	ent->children = NULL;
6267	last = ent->last;
6268	ent->last = NULL;
6269	while (cur != NULL) {
6270	next = cur->next;
6271	cur->next = NULL;
6272	cur->parent = NULL;
6273	nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
6274	if (nw != NULL) {
6275	if (nw->_private == NULL)
6276	nw->_private = cur->_private;
6277	if (firstChild == NULL){
6278	firstChild = cur;
6279	}
6280	xmlAddChild((xmlNodePtr) ent, nw);
6281	xmlAddChild(ctxt->node, cur);
6282	}
6283	if (cur == last)
6284	break;
6285	cur = next;
6286	}
6287	ent->owner = 1;
6288	#ifdef LIBXML_LEGACY_ENABLED
6289	if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
6290	xmlAddEntityReference(ent, firstChild, nw);
6291	#endif /* LIBXML_LEGACY_ENABLED */
6292	} else {
6293	const xmlChar *nbktext;
6294
6295	/*
6296	* the name change is to avoid coalescing of the
6297	* node with a possible previous text one which
6298	* would make ent->children a dangling pointer
6299	*/
6300	nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
6301	-1);
6302	if (ent->children->type == XML_TEXT_NODE)
6303	ent->children->name = nbktext;
6304	if ((ent->last != ent->children) &&
6305	(ent->last->type == XML_TEXT_NODE))
6306	ent->last->name = nbktext;
6307	xmlAddChildList(ctxt->node, ent->children);
6308	}
6309
6310	/*
6311	* This is to avoid a nasty side effect, see
6312	* characters() in SAX.c
6313	*/
6314	ctxt->nodemem = 0;
6315	ctxt->nodelen = 0;
6316	return;
6317	}
6318	}
6319	} else {
6320	val = ent->content;
6321	if (val == NULL) return;
6322	/*
6323	* inline the entity.
6324	*/
6325	if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
6326	(!ctxt->disableSAX))
6327	ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
6328	}
6329	}
6330	}
6331
6332	/**
6333	* xmlParseEntityRef:
6334	* @ctxt: an XML parser context
6335	*
6336	* parse ENTITY references declarations
6337	*
6338	* [68] EntityRef ::= '&' Name ';'
6339	*
6340	* [ WFC: Entity Declared ]
6341	* In a document without any DTD, a document with only an internal DTD
6342	* subset which contains no parameter entity references, or a document
6343	* with "standalone='yes'", the Name given in the entity reference
6344	* must match that in an entity declaration, except that well-formed
6345	* documents need not declare any of the following entities: amp, lt,
6346	* gt, apos, quot. The declaration of a parameter entity must precede
6347	* any reference to it. Similarly, the declaration of a general entity
6348	* must precede any reference to it which appears in a default value in an
6349	* attribute-list declaration. Note that if entities are declared in the
6350	* external subset or in external parameter entities, a non-validating
6351	* processor is not obligated to read and process their declarations;
6352	* for such documents, the rule that an entity must be declared is a
6353	* well-formedness constraint only if standalone='yes'.
6354	*
6355	* [ WFC: Parsed Entity ]
6356	* An entity reference must not contain the name of an unparsed entity
6357	*
6358	* Returns the xmlEntityPtr if found, or NULL otherwise.
6359	*/
6360	xmlEntityPtr
6361	xmlParseEntityRef(xmlParserCtxtPtr ctxt) {
6362	const xmlChar *name;
6363	xmlEntityPtr ent = NULL;
6364
6365	GROW;
6366
6367	if (RAW == '&') {
6368	NEXT;
6369	name = xmlParseName(ctxt);
6370	if (name == NULL) {
6371	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6372	"xmlParseEntityRef: no name\n");
6373	} else {
6374	if (RAW == ';') {
6375	NEXT;
6376	/*
6377	* Ask first SAX for entity resolution, otherwise try the
6378	* predefined set.
6379	*/
6380	if (ctxt->sax != NULL) {
6381	if (ctxt->sax->getEntity != NULL)
6382	ent = ctxt->sax->getEntity(ctxt->userData, name);
6383	if ((ctxt->wellFormed == 1 ) && (ent == NULL))
6384	ent = xmlGetPredefinedEntity(name);
6385	if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
6386	(ctxt->userData==ctxt)) {
6387	ent = xmlSAX2GetEntity(ctxt, name);
6388	}
6389	}
6390	/*
6391	* [ WFC: Entity Declared ]
6392	* In a document without any DTD, a document with only an
6393	* internal DTD subset which contains no parameter entity
6394	* references, or a document with "standalone='yes'", the
6395	* Name given in the entity reference must match that in an
6396	* entity declaration, except that well-formed documents
6397	* need not declare any of the following entities: amp, lt,
6398	* gt, apos, quot.
6399	* The declaration of a parameter entity must precede any
6400	* reference to it.
6401	* Similarly, the declaration of a general entity must
6402	* precede any reference to it which appears in a default
6403	* value in an attribute-list declaration. Note that if
6404	* entities are declared in the external subset or in
6405	* external parameter entities, a non-validating processor
6406	* is not obligated to read and process their declarations;
6407	* for such documents, the rule that an entity must be
6408	* declared is a well-formedness constraint only if
6409	* standalone='yes'.
6410	*/
6411	if (ent == NULL) {
6412	if ((ctxt->standalone == 1) \|\|
6413	((ctxt->hasExternalSubset == 0) &&
6414	(ctxt->hasPErefs == 0))) {
6415	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6416	"Entity '%s' not defined\n", name);
6417	} else {
6418	xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
6419	"Entity '%s' not defined\n", name);
6420	if ((ctxt->inSubset == 0) &&
6421	(ctxt->sax != NULL) &&
6422	(ctxt->sax->reference != NULL)) {
6423	ctxt->sax->reference(ctxt->userData, name);
6424	}
6425	}
6426	ctxt->valid = 0;
6427	}
6428
6429	/*
6430	* [ WFC: Parsed Entity ]
6431	* An entity reference must not contain the name of an
6432	* unparsed entity
6433	*/
6434	else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
6435	xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
6436	"Entity reference to unparsed entity %s\n", name);
6437	}
6438
6439	/*
6440	* [ WFC: No External Entity References ]
6441	* Attribute values cannot contain direct or indirect
6442	* entity references to external entities.
6443	*/
6444	else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
6445	(ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
6446	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
6447	"Attribute references external entity '%s'\n", name);
6448	}
6449	/*
6450	* [ WFC: No < in Attribute Values ]
6451	* The replacement text of any entity referred to directly or
6452	* indirectly in an attribute value (other than "<") must
6453	* not contain a <.
6454	*/
6455	else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
6456	(ent != NULL) &&
6457	(!xmlStrEqual(ent->name, BAD_CAST "lt")) &&
6458	(ent->content != NULL) &&
6459	(xmlStrchr(ent->content, '<'))) {
6460	xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
6461	"'<' in entity '%s' is not allowed in attributes values\n", name);
6462	}
6463
6464	/*
6465	* Internal check, no parameter entities here ...
6466	*/
6467	else {
6468	switch (ent->etype) {
6469	case XML_INTERNAL_PARAMETER_ENTITY:
6470	case XML_EXTERNAL_PARAMETER_ENTITY:
6471	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
6472	"Attempt to reference the parameter entity '%s'\n",
6473	name);
6474	break;
6475	default:
6476	break;
6477	}
6478	}
6479
6480	/*
6481	* [ WFC: No Recursion ]
6482	* A parsed entity must not contain a recursive reference
6483	* to itself, either directly or indirectly.
6484	* Done somewhere else
6485	*/
6486
6487	} else {
6488	xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
6489	}
6490	}
6491	}
6492	return(ent);
6493	}
6494
6495	/**
6496	* xmlParseStringEntityRef:
6497	* @ctxt: an XML parser context
6498	* @str: a pointer to an index in the string
6499	*
6500	* parse ENTITY references declarations, but this version parses it from
6501	* a string value.
6502	*
6503	* [68] EntityRef ::= '&' Name ';'
6504	*
6505	* [ WFC: Entity Declared ]
6506	* In a document without any DTD, a document with only an internal DTD
6507	* subset which contains no parameter entity references, or a document
6508	* with "standalone='yes'", the Name given in the entity reference
6509	* must match that in an entity declaration, except that well-formed
6510	* documents need not declare any of the following entities: amp, lt,
6511	* gt, apos, quot. The declaration of a parameter entity must precede
6512	* any reference to it. Similarly, the declaration of a general entity
6513	* must precede any reference to it which appears in a default value in an
6514	* attribute-list declaration. Note that if entities are declared in the
6515	* external subset or in external parameter entities, a non-validating
6516	* processor is not obligated to read and process their declarations;
6517	* for such documents, the rule that an entity must be declared is a
6518	* well-formedness constraint only if standalone='yes'.
6519	*
6520	* [ WFC: Parsed Entity ]
6521	* An entity reference must not contain the name of an unparsed entity
6522	*
6523	* Returns the xmlEntityPtr if found, or NULL otherwise. The str pointer
6524	* is updated to the current location in the string.
6525	*/
6526	xmlEntityPtr
6527	xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
6528	xmlChar *name;
6529	const xmlChar *ptr;
6530	xmlChar cur;
6531	xmlEntityPtr ent = NULL;
6532
6533	if ((str == NULL) \|\| (*str == NULL))
6534	return(NULL);
6535	ptr = *str;
6536	cur = *ptr;
6537	if (cur == '&') {
6538	ptr++;
6539	cur = *ptr;
6540	name = xmlParseStringName(ctxt, &ptr);
6541	if (name == NULL) {
6542	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6543	"xmlParseStringEntityRef: no name\n");
6544	} else {
6545	if (*ptr == ';') {
6546	ptr++;
6547	/*
6548	* Ask first SAX for entity resolution, otherwise try the
6549	* predefined set.
6550	*/
6551	if (ctxt->sax != NULL) {
6552	if (ctxt->sax->getEntity != NULL)
6553	ent = ctxt->sax->getEntity(ctxt->userData, name);
6554	if (ent == NULL)
6555	ent = xmlGetPredefinedEntity(name);
6556	if ((ent == NULL) && (ctxt->userData==ctxt)) {
6557	ent = xmlSAX2GetEntity(ctxt, name);
6558	}
6559	}
6560	/*
6561	* [ WFC: Entity Declared ]
6562	* In a document without any DTD, a document with only an
6563	* internal DTD subset which contains no parameter entity
6564	* references, or a document with "standalone='yes'", the
6565	* Name given in the entity reference must match that in an
6566	* entity declaration, except that well-formed documents
6567	* need not declare any of the following entities: amp, lt,
6568	* gt, apos, quot.
6569	* The declaration of a parameter entity must precede any
6570	* reference to it.
6571	* Similarly, the declaration of a general entity must
6572	* precede any reference to it which appears in a default
6573	* value in an attribute-list declaration. Note that if
6574	* entities are declared in the external subset or in
6575	* external parameter entities, a non-validating processor
6576	* is not obligated to read and process their declarations;
6577	* for such documents, the rule that an entity must be
6578	* declared is a well-formedness constraint only if
6579	* standalone='yes'.
6580	*/
6581	if (ent == NULL) {
6582	if ((ctxt->standalone == 1) \|\|
6583	((ctxt->hasExternalSubset == 0) &&
6584	(ctxt->hasPErefs == 0))) {
6585	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6586	"Entity '%s' not defined\n", name);
6587	} else {
6588	xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
6589	"Entity '%s' not defined\n",
6590	name);
6591	}
6592	/* TODO ? check regressions ctxt->valid = 0; */
6593	}
6594
6595	/*
6596	* [ WFC: Parsed Entity ]
6597	* An entity reference must not contain the name of an
6598	* unparsed entity
6599	*/
6600	else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
6601	xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
6602	"Entity reference to unparsed entity %s\n", name);
6603	}
6604
6605	/*
6606	* [ WFC: No External Entity References ]
6607	* Attribute values cannot contain direct or indirect
6608	* entity references to external entities.
6609	*/
6610	else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
6611	(ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
6612	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
6613	"Attribute references external entity '%s'\n", name);
6614	}
6615	/*
6616	* [ WFC: No < in Attribute Values ]
6617	* The replacement text of any entity referred to directly or
6618	* indirectly in an attribute value (other than "<") must
6619	* not contain a <.
6620	*/
6621	else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
6622	(ent != NULL) &&
6623	(!xmlStrEqual(ent->name, BAD_CAST "lt")) &&
6624	(ent->content != NULL) &&
6625	(xmlStrchr(ent->content, '<'))) {
6626	xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
6627	"'<' in entity '%s' is not allowed in attributes values\n",
6628	name);
6629	}
6630
6631	/*
6632	* Internal check, no parameter entities here ...
6633	*/
6634	else {
6635	switch (ent->etype) {
6636	case XML_INTERNAL_PARAMETER_ENTITY:
6637	case XML_EXTERNAL_PARAMETER_ENTITY:
6638	xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
6639	"Attempt to reference the parameter entity '%s'\n",
6640	name);
6641	break;
6642	default:
6643	break;
6644	}
6645	}
6646
6647	/*
6648	* [ WFC: No Recursion ]
6649	* A parsed entity must not contain a recursive reference
6650	* to itself, either directly or indirectly.
6651	* Done somewhere else
6652	*/
6653
6654	} else {
6655	xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
6656	}
6657	xmlFree(name);
6658	}
6659	}
6660	*str = ptr;
6661	return(ent);
6662	}
6663
6664	/**
6665	* xmlParsePEReference:
6666	* @ctxt: an XML parser context
6667	*
6668	* parse PEReference declarations
6669	* The entity content is handled directly by pushing it's content as
6670	* a new input stream.
6671	*
6672	* [69] PEReference ::= '%' Name ';'
6673	*
6674	* [ WFC: No Recursion ]
6675	* A parsed entity must not contain a recursive
6676	* reference to itself, either directly or indirectly.
6677	*
6678	* [ WFC: Entity Declared ]
6679	* In a document without any DTD, a document with only an internal DTD
6680	* subset which contains no parameter entity references, or a document
6681	* with "standalone='yes'", ... ... The declaration of a parameter
6682	* entity must precede any reference to it...
6683	*
6684	* [ VC: Entity Declared ]
6685	* In a document with an external subset or external parameter entities
6686	* with "standalone='no'", ... ... The declaration of a parameter entity
6687	* must precede any reference to it...
6688	*
6689	* [ WFC: In DTD ]
6690	* Parameter-entity references may only appear in the DTD.
6691	* NOTE: misleading but this is handled.
6692	*/
6693	void
6694	xmlParsePEReference(xmlParserCtxtPtr ctxt)
6695	{
6696	const xmlChar *name;
6697	xmlEntityPtr entity = NULL;
6698	xmlParserInputPtr input;
6699
6700	if (RAW == '%') {
6701	NEXT;
6702	name = xmlParseName(ctxt);
6703	if (name == NULL) {
6704	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6705	"xmlParsePEReference: no name\n");
6706	} else {
6707	if (RAW == ';') {
6708	NEXT;
6709	if ((ctxt->sax != NULL) &&
6710	(ctxt->sax->getParameterEntity != NULL))
6711	entity = ctxt->sax->getParameterEntity(ctxt->userData,
6712	name);
6713	if (entity == NULL) {
6714	/*
6715	* [ WFC: Entity Declared ]
6716	* In a document without any DTD, a document with only an
6717	* internal DTD subset which contains no parameter entity
6718	* references, or a document with "standalone='yes'", ...
6719	* ... The declaration of a parameter entity must precede
6720	* any reference to it...
6721	*/
6722	if ((ctxt->standalone == 1) \|\|
6723	((ctxt->hasExternalSubset == 0) &&
6724	(ctxt->hasPErefs == 0))) {
6725	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6726	"PEReference: %%%s; not found\n",
6727	name);
6728	} else {
6729	/*
6730	* [ VC: Entity Declared ]
6731	* In a document with an external subset or external
6732	* parameter entities with "standalone='no'", ...
6733	* ... The declaration of a parameter entity must
6734	* precede any reference to it...
6735	*/
6736	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
6737	"PEReference: %%%s; not found\n",
6738	name, NULL);
6739	ctxt->valid = 0;
6740	}
6741	} else {
6742	/*
6743	* Internal checking in case the entity quest barfed
6744	*/
6745	if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
6746	(entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
6747	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
6748	"Internal: %%%s; is not a parameter entity\n",
6749	name, NULL);
6750	} else if (ctxt->input->free != deallocblankswrapper) {
6751	input =
6752	xmlNewBlanksWrapperInputStream(ctxt, entity);
6753	xmlPushInput(ctxt, input);
6754	} else {
6755	/*
6756	* TODO !!!
6757	* handle the extra spaces added before and after
6758	* c.f. http://www.w3.org/TR/REC-xml#as-PE
6759	*/
6760	input = xmlNewEntityInputStream(ctxt, entity);
6761	xmlPushInput(ctxt, input);
6762	if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
6763	(CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
6764	(IS_BLANK_CH(NXT(5)))) {
6765	xmlParseTextDecl(ctxt);
6766	if (ctxt->errNo ==
6767	XML_ERR_UNSUPPORTED_ENCODING) {
6768	/*
6769	* The XML REC instructs us to stop parsing
6770	* right here
6771	*/
6772	ctxt->instate = XML_PARSER_EOF;
6773	return;
6774	}
6775	}
6776	}
6777	}
6778	ctxt->hasPErefs = 1;
6779	} else {
6780	xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
6781	}
6782	}
6783	}
6784	}
6785
6786	/**
6787	* xmlParseStringPEReference:
6788	* @ctxt: an XML parser context
6789	* @str: a pointer to an index in the string
6790	*
6791	* parse PEReference declarations
6792	*
6793	* [69] PEReference ::= '%' Name ';'
6794	*
6795	* [ WFC: No Recursion ]
6796	* A parsed entity must not contain a recursive
6797	* reference to itself, either directly or indirectly.
6798	*
6799	* [ WFC: Entity Declared ]
6800	* In a document without any DTD, a document with only an internal DTD
6801	* subset which contains no parameter entity references, or a document
6802	* with "standalone='yes'", ... ... The declaration of a parameter
6803	* entity must precede any reference to it...
6804	*
6805	* [ VC: Entity Declared ]
6806	* In a document with an external subset or external parameter entities
6807	* with "standalone='no'", ... ... The declaration of a parameter entity
6808	* must precede any reference to it...
6809	*
6810	* [ WFC: In DTD ]
6811	* Parameter-entity references may only appear in the DTD.
6812	* NOTE: misleading but this is handled.
6813	*
6814	* Returns the string of the entity content.
6815	* str is updated to the current value of the index
6816	*/
6817	xmlEntityPtr
6818	xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) {
6819	const xmlChar *ptr;
6820	xmlChar cur;
6821	xmlChar *name;
6822	xmlEntityPtr entity = NULL;
6823
6824	if ((str == NULL) \|\| (*str == NULL)) return(NULL);
6825	ptr = *str;
6826	cur = *ptr;
6827	if (cur == '%') {
6828	ptr++;
6829	cur = *ptr;
6830	name = xmlParseStringName(ctxt, &ptr);
6831	if (name == NULL) {
6832	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6833	"xmlParseStringPEReference: no name\n");
6834	} else {
6835	cur = *ptr;
6836	if (cur == ';') {
6837	ptr++;
6838	cur = *ptr;
6839	if ((ctxt->sax != NULL) &&
6840	(ctxt->sax->getParameterEntity != NULL))
6841	entity = ctxt->sax->getParameterEntity(ctxt->userData,
6842	name);
6843	if (entity == NULL) {
6844	/*
6845	* [ WFC: Entity Declared ]
6846	* In a document without any DTD, a document with only an
6847	* internal DTD subset which contains no parameter entity
6848	* references, or a document with "standalone='yes'", ...
6849	* ... The declaration of a parameter entity must precede
6850	* any reference to it...
6851	*/
6852	if ((ctxt->standalone == 1) \|\|
6853	((ctxt->hasExternalSubset == 0) &&
6854	(ctxt->hasPErefs == 0))) {
6855	xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
6856	"PEReference: %%%s; not found\n", name);
6857	} else {
6858	/*
6859	* [ VC: Entity Declared ]
6860	* In a document with an external subset or external
6861	* parameter entities with "standalone='no'", ...
6862	* ... The declaration of a parameter entity must
6863	* precede any reference to it...
6864	*/
6865	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
6866	"PEReference: %%%s; not found\n",
6867	name, NULL);
6868	ctxt->valid = 0;
6869	}
6870	} else {
6871	/*
6872	* Internal checking in case the entity quest barfed
6873	*/
6874	if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
6875	(entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
6876	xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
6877	"%%%s; is not a parameter entity\n",
6878	name, NULL);
6879	}
6880	}
6881	ctxt->hasPErefs = 1;
6882	} else {
6883	xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
6884	}
6885	xmlFree(name);
6886	}
6887	}
6888	*str = ptr;
6889	return(entity);
6890	}
6891
6892	/**
6893	* xmlParseDocTypeDecl:
6894	* @ctxt: an XML parser context
6895	*
6896	* parse a DOCTYPE declaration
6897	*
6898	* [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S?
6899	* ('[' (markupdecl \| PEReference \| S)* ']' S?)? '>'
6900	*
6901	* [ VC: Root Element Type ]
6902	* The Name in the document type declaration must match the element
6903	* type of the root element.
6904	*/
6905
6906	void
6907	xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) {
6908	const xmlChar *name = NULL;
6909	xmlChar *ExternalID = NULL;
6910	xmlChar *URI = NULL;
6911
6912	/*
6913	* We know that '<!DOCTYPE' has been detected.
6914	*/
6915	SKIP(9);
6916
6917	SKIP_BLANKS;
6918
6919	/*
6920	* Parse the DOCTYPE name.
6921	*/
6922	name = xmlParseName(ctxt);
6923	if (name == NULL) {
6924	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6925	"xmlParseDocTypeDecl : no DOCTYPE name !\n");
6926	}
6927	ctxt->intSubName = name;
6928
6929	SKIP_BLANKS;
6930
6931	/*
6932	* Check for SystemID and ExternalID
6933	*/
6934	URI = xmlParseExternalID(ctxt, &ExternalID, 1);
6935
6936	if ((URI != NULL) \|\| (ExternalID != NULL)) {
6937	ctxt->hasExternalSubset = 1;
6938	}
6939	ctxt->extSubURI = URI;
6940	ctxt->extSubSystem = ExternalID;
6941
6942	SKIP_BLANKS;
6943
6944	/*
6945	* Create and update the internal subset.
6946	*/
6947	if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
6948	(!ctxt->disableSAX))
6949	ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
6950
6951	/*
6952	* Is there any internal subset declarations ?
6953	* they are handled separately in xmlParseInternalSubset()
6954	*/
6955	if (RAW == '[')
6956	return;
6957
6958	/*
6959	* We should be at the end of the DOCTYPE declaration.
6960	*/
6961	if (RAW != '>') {
6962	xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
6963	}
6964	NEXT;
6965	}
6966
6967	/**
6968	* xmlParseInternalSubset:
6969	* @ctxt: an XML parser context
6970	*
6971	* parse the internal subset declaration
6972	*
6973	* [28 end] ('[' (markupdecl \| PEReference \| S)* ']' S?)? '>'
6974	*/
6975
6976	static void
6977	xmlParseInternalSubset(xmlParserCtxtPtr ctxt) {
6978	/*
6979	* Is there any DTD definition ?
6980	*/
6981	if (RAW == '[') {
6982	ctxt->instate = XML_PARSER_DTD;
6983	NEXT;
6984	/*
6985	* Parse the succession of Markup declarations and
6986	* PEReferences.
6987	* Subsequence (markupdecl \| PEReference \| S)*
6988	*/
6989	while (RAW != ']') {
6990	const xmlChar *check = CUR_PTR;
6991	unsigned int cons = ctxt->input->consumed;
6992
6993	SKIP_BLANKS;
6994	xmlParseMarkupDecl(ctxt);
6995	xmlParsePEReference(ctxt);
6996
6997	/*
6998	* Pop-up of finished entities.
6999	*/
7000	while ((RAW == 0) && (ctxt->inputNr > 1))
7001	xmlPopInput(ctxt);
7002
7003	if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
7004	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
7005	"xmlParseInternalSubset: error detected in Markup declaration\n");
7006	break;
7007	}
7008	}
7009	if (RAW == ']') {
7010	NEXT;
7011	SKIP_BLANKS;
7012	}
7013	}
7014
7015	/*
7016	* We should be at the end of the DOCTYPE declaration.
7017	*/
7018	if (RAW != '>') {
7019	xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
7020	}
7021	NEXT;
7022	}
7023
7024	#ifdef LIBXML_SAX1_ENABLED
7025	/**
7026	* xmlParseAttribute:
7027	* @ctxt: an XML parser context
7028	* @value: a xmlChar ** used to store the value of the attribute
7029	*
7030	* parse an attribute
7031	*
7032	* [41] Attribute ::= Name Eq AttValue
7033	*
7034	* [ WFC: No External Entity References ]
7035	* Attribute values cannot contain direct or indirect entity references
7036	* to external entities.
7037	*
7038	* [ WFC: No < in Attribute Values ]
7039	* The replacement text of any entity referred to directly or indirectly in
7040	* an attribute value (other than "<") must not contain a <.
7041	*
7042	* [ VC: Attribute Value Type ]
7043	* The attribute must have been declared; the value must be of the type
7044	* declared for it.
7045	*
7046	* [25] Eq ::= S? '=' S?
7047	*
7048	* With namespace:
7049	*
7050	* [NS 11] Attribute ::= QName Eq AttValue
7051	*
7052	* Also the case QName == xmlns:??? is handled independently as a namespace
7053	* definition.
7054	*
7055	* Returns the attribute name, and the value in *value.
7056	*/
7057
7058	const xmlChar *
7059	xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) {
7060	const xmlChar *name;
7061	xmlChar *val;
7062
7063	*value = NULL;
7064	GROW;
7065	name = xmlParseName(ctxt);
7066	if (name == NULL) {
7067	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7068	"error parsing attribute name\n");
7069	return(NULL);
7070	}
7071
7072	/*
7073	* read the value
7074	*/
7075	SKIP_BLANKS;
7076	if (RAW == '=') {
7077	NEXT;
7078	SKIP_BLANKS;
7079	val = xmlParseAttValue(ctxt);
7080	ctxt->instate = XML_PARSER_CONTENT;
7081	} else {
7082	xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
7083	"Specification mandate value for attribute %s\n", name);
7084	return(NULL);
7085	}
7086
7087	/*
7088	* Check that xml:lang conforms to the specification
7089	* No more registered as an error, just generate a warning now
7090	* since this was deprecated in XML second edition
7091	*/
7092	if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
7093	if (!xmlCheckLanguageID(val)) {
7094	xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
7095	"Malformed value for xml:lang : %s\n",
7096	val, NULL);
7097	}
7098	}
7099
7100	/*
7101	* Check that xml:space conforms to the specification
7102	*/
7103	if (xmlStrEqual(name, BAD_CAST "xml:space")) {
7104	if (xmlStrEqual(val, BAD_CAST "default"))
7105	*(ctxt->space) = 0;
7106	else if (xmlStrEqual(val, BAD_CAST "preserve"))
7107	*(ctxt->space) = 1;
7108	else {
7109	xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
7110	"Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
7111	val, NULL);
7112	}
7113	}
7114
7115	*value = val;
7116	return(name);
7117	}
7118
7119	/**
7120	* xmlParseStartTag:
7121	* @ctxt: an XML parser context
7122	*
7123	* parse a start of tag either for rule element or
7124	* EmptyElement. In both case we don't parse the tag closing chars.
7125	*
7126	* [40] STag ::= '<' Name (S Attribute)* S? '>'
7127	*
7128	* [ WFC: Unique Att Spec ]
7129	* No attribute name may appear more than once in the same start-tag or
7130	* empty-element tag.
7131	*
7132	* [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
7133	*
7134	* [ WFC: Unique Att Spec ]
7135	* No attribute name may appear more than once in the same start-tag or
7136	* empty-element tag.
7137	*
7138	* With namespace:
7139	*
7140	* [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
7141	*
7142	* [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
7143	*
7144	* Returns the element name parsed
7145	*/
7146
7147	const xmlChar *
7148	xmlParseStartTag(xmlParserCtxtPtr ctxt) {
7149	const xmlChar *name;
7150	const xmlChar *attname;
7151	xmlChar *attvalue;
7152	const xmlChar **atts = ctxt->atts;
7153	int nbatts = 0;
7154	int maxatts = ctxt->maxatts;
7155	int i;
7156
7157	if (RAW != '<') return(NULL);
7158	NEXT1;
7159
7160	name = xmlParseName(ctxt);
7161	if (name == NULL) {
7162	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7163	"xmlParseStartTag: invalid element name\n");
7164	return(NULL);
7165	}
7166
7167	/*
7168	* Now parse the attributes, it ends up with the ending
7169	*
7170	* (S Attribute)* S?
7171	*/
7172	SKIP_BLANKS;
7173	GROW;
7174
7175	while ((RAW != '>') &&
7176	((RAW != '/') \|\| (NXT(1) != '>')) &&
7177	(IS_BYTE_CHAR(RAW))) {
7178	const xmlChar *q = CUR_PTR;
7179	unsigned int cons = ctxt->input->consumed;
7180
7181	attname = xmlParseAttribute(ctxt, &attvalue);
7182	if ((attname != NULL) && (attvalue != NULL)) {
7183	/*
7184	* [ WFC: Unique Att Spec ]
7185	* No attribute name may appear more than once in the same
7186	* start-tag or empty-element tag.
7187	*/
7188	for (i = 0; i < nbatts;i += 2) {
7189	if (xmlStrEqual(atts[i], attname)) {
7190	xmlErrAttributeDup(ctxt, NULL, attname);
7191	xmlFree(attvalue);
7192	goto failed;
7193	}
7194	}
7195	/*
7196	* Add the pair to atts
7197	*/
7198	if (atts == NULL) {
7199	maxatts = 22; /* allow for 10 attrs by default */
7200	atts = (const xmlChar **)
7201	xmlMalloc(maxatts * sizeof(xmlChar *));
7202	if (atts == NULL) {
7203	xmlErrMemory(ctxt, NULL);
7204	if (attvalue != NULL)
7205	xmlFree(attvalue);
7206	goto failed;
7207	}
7208	ctxt->atts = atts;
7209	ctxt->maxatts = maxatts;
7210	} else if (nbatts + 4 > maxatts) {
7211	const xmlChar **n;
7212
7213	maxatts *= 2;
7214	n = (const xmlChar *) xmlRealloc((void ) atts,
7215	maxatts * sizeof(const xmlChar *));
7216	if (n == NULL) {
7217	xmlErrMemory(ctxt, NULL);
7218	if (attvalue != NULL)
7219	xmlFree(attvalue);
7220	goto failed;
7221	}
7222	atts = n;
7223	ctxt->atts = atts;
7224	ctxt->maxatts = maxatts;
7225	}
7226	atts[nbatts++] = attname;
7227	atts[nbatts++] = attvalue;
7228	atts[nbatts] = NULL;
7229	atts[nbatts + 1] = NULL;
7230	} else {
7231	if (attvalue != NULL)
7232	xmlFree(attvalue);
7233	}
7234
7235	failed:
7236
7237	GROW
7238	if ((RAW == '>') \|\| (((RAW == '/') && (NXT(1) == '>'))))
7239	break;
7240	if (!IS_BLANK_CH(RAW)) {
7241	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
7242	"attributes construct error\n");
7243	}
7244	SKIP_BLANKS;
7245	if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
7246	(attname == NULL) && (attvalue == NULL)) {
7247	xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
7248	"xmlParseStartTag: problem parsing attributes\n");
7249	break;
7250	}
7251	SHRINK;
7252	GROW;
7253	}
7254
7255	/*
7256	* SAX: Start of Element !
7257	*/
7258	if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) &&
7259	(!ctxt->disableSAX)) {
7260	if (nbatts > 0)
7261	ctxt->sax->startElement(ctxt->userData, name, atts);
7262	else
7263	ctxt->sax->startElement(ctxt->userData, name, NULL);
7264	}
7265
7266	if (atts != NULL) {
7267	/* Free only the content strings */
7268	for (i = 1;i < nbatts;i+=2)
7269	if (atts[i] != NULL)
7270	xmlFree((xmlChar *) atts[i]);
7271	}
7272	return(name);
7273	}
7274
7275	/**
7276	* xmlParseEndTag1:
7277	* @ctxt: an XML parser context
7278	* @line: line of the start tag
7279	* @nsNr: number of namespaces on the start tag
7280	*
7281	* parse an end of tag
7282	*
7283	* [42] ETag ::= '</' Name S? '>'
7284	*
7285	* With namespace
7286	*
7287	* [NS 9] ETag ::= '</' QName S? '>'
7288	*/
7289
7290	static void
7291	xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) {
7292	const xmlChar *name;
7293
7294	GROW;
7295	if ((RAW != '<') \|\| (NXT(1) != '/')) {
7296	xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED,
7297	"xmlParseEndTag: '</' not found\n");
7298	return;
7299	}
7300	SKIP(2);
7301
7302	name = xmlParseNameAndCompare(ctxt,ctxt->name);
7303
7304	/*
7305	* We should definitely be at the ending "S? '>'" part
7306	*/
7307	GROW;
7308	SKIP_BLANKS;
7309	if ((!IS_BYTE_CHAR(RAW)) \|\| (RAW != '>')) {
7310	xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
7311	} else
7312	NEXT1;
7313
7314	/*
7315	* [ WFC: Element Type Match ]
7316	* The Name in an element's end-tag must match the element type in the
7317	* start-tag.
7318	*
7319	*/
7320	if (name != (xmlChar*)1) {
7321	if (name == NULL) name = BAD_CAST "unparseable";
7322	xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
7323	"Opening and ending tag mismatch: %s line %d and %s\n",
7324	ctxt->name, line, name);
7325	}
7326
7327	/*
7328	* SAX: End of Tag
7329	*/
7330	if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
7331	(!ctxt->disableSAX))
7332	ctxt->sax->endElement(ctxt->userData, ctxt->name);
7333
7334	namePop(ctxt);
7335	spacePop(ctxt);
7336	return;
7337	}
7338
7339	/**
7340	* xmlParseEndTag:
7341	* @ctxt: an XML parser context
7342	*
7343	* parse an end of tag
7344	*
7345	* [42] ETag ::= '</' Name S? '>'
7346	*
7347	* With namespace
7348	*
7349	* [NS 9] ETag ::= '</' QName S? '>'
7350	*/
7351
7352	void
7353	xmlParseEndTag(xmlParserCtxtPtr ctxt) {
7354	xmlParseEndTag1(ctxt, 0);
7355	}
7356	#endif /* LIBXML_SAX1_ENABLED */
7357
7358	/************************************************************************
7359	* *
7360	* SAX 2 specific operations *
7361	* *
7362	************************************************************************/
7363
7364	static const xmlChar *
7365	xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
7366	int len = 0, l;
7367	int c;
7368	int count = 0;
7369
7370	/*
7371	* Handler for more complex cases
7372	*/
7373	GROW;
7374	c = CUR_CHAR(l);
7375	if ((c == ' ') \|\| (c == '>') \|\| (c == '/') \|\| /* accelerators */
7376	(!IS_LETTER(c) && (c != '_'))) {
7377	return(NULL);
7378	}
7379
7380	while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
7381	((IS_LETTER(c)) \|\| (IS_DIGIT(c)) \|\|
7382	(c == '.') \|\| (c == '-') \|\| (c == '_') \|\|
7383	(IS_COMBINING(c)) \|\|
7384	(IS_EXTENDER(c)))) {
7385	if (count++ > 100) {
7386	count = 0;
7387	GROW;
7388	}
7389	len += l;
7390	NEXTL(l);
7391	c = CUR_CHAR(l);
7392	}
7393	return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
7394	}
7395
7396	/*
7397	* xmlGetNamespace:
7398	* @ctxt: an XML parser context
7399	* @prefix: the prefix to lookup
7400	*
7401	* Lookup the namespace name for the @prefix (which ca be NULL)
7402	* The prefix must come from the @ctxt->dict dictionnary
7403	*
7404	* Returns the namespace name or NULL if not bound
7405	*/
7406	static const xmlChar *
7407	xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
7408	int i;
7409
7410	if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns);
7411	for (i = ctxt->nsNr - 2;i >= 0;i-=2)
7412	if (ctxt->nsTab[i] == prefix) {
7413	if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0))
7414	return(NULL);
7415	return(ctxt->nsTab[i + 1]);
7416	}
7417	return(NULL);
7418	}
7419
7420	/**
7421	* xmlParseNCName:
7422	* @ctxt: an XML parser context
7423	* @len: lenght of the string parsed
7424	*
7425	* parse an XML name.
7426	*
7427	* [4NS] NCNameChar ::= Letter \| Digit \| '.' \| '-' \| '_' \|
7428	* CombiningChar \| Extender
7429	*
7430	* [5NS] NCName ::= (Letter \| '_') (NCNameChar)*
7431	*
7432	* Returns the Name parsed or NULL
7433	*/
7434
7435	static const xmlChar *
7436	xmlParseNCName(xmlParserCtxtPtr ctxt) {
7437	const xmlChar *in;
7438	const xmlChar *ret;
7439	int count = 0;
7440
7441	/*
7442	* Accelerator for simple ASCII names
7443	*/
7444	in = ctxt->input->cur;
7445	if (((in >= 0x61) && (in <= 0x7A)) \|\|
7446	((in >= 0x41) && (in <= 0x5A)) \|\|
7447	(*in == '_')) {
7448	in++;
7449	while (((in >= 0x61) && (in <= 0x7A)) \|\|
7450	((in >= 0x41) && (in <= 0x5A)) \|\|
7451	((in >= 0x30) && (in <= 0x39)) \|\|
7452	(in == '_') \|\| (in == '-') \|\|
7453	(*in == '.'))
7454	in++;
7455	if ((in > 0) && (in < 0x80)) {
7456	count = in - ctxt->input->cur;
7457	ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
7458	ctxt->input->cur = in;
7459	ctxt->nbChars += count;
7460	ctxt->input->col += count;
7461	if (ret == NULL) {
7462	xmlErrMemory(ctxt, NULL);
7463	}
7464	return(ret);
7465	}
7466	}
7467	return(xmlParseNCNameComplex(ctxt));
7468	}
7469
7470	/**
7471	* xmlParseQName:
7472	* @ctxt: an XML parser context
7473	* @prefix: pointer to store the prefix part
7474	*
7475	* parse an XML Namespace QName
7476	*
7477	* [6] QName ::= (Prefix ':')? LocalPart
7478	* [7] Prefix ::= NCName
7479	* [8] LocalPart ::= NCName
7480	*
7481	* Returns the Name parsed or NULL
7482	*/
7483
7484	static const xmlChar *
7485	xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) {
7486	const xmlChar l, p;
7487
7488	GROW;
7489
7490	l = xmlParseNCName(ctxt);
7491	if (l == NULL) {
7492	if (CUR == ':') {
7493	l = xmlParseName(ctxt);
7494	if (l != NULL) {
7495	xmlNsErr(ctxt, XML_NS_ERR_QNAME,
7496	"Failed to parse QName '%s'\n", l, NULL, NULL);
7497	*prefix = NULL;
7498	return(l);
7499	}
7500	}
7501	return(NULL);
7502	}
7503	if (CUR == ':') {
7504	NEXT;
7505	p = l;
7506	l = xmlParseNCName(ctxt);
7507	if (l == NULL) {
7508	xmlChar *tmp;
7509
7510	xmlNsErr(ctxt, XML_NS_ERR_QNAME,
7511	"Failed to parse QName '%s:'\n", p, NULL, NULL);
7512	tmp = xmlBuildQName(BAD_CAST "", p, NULL, 0);
7513	p = xmlDictLookup(ctxt->dict, tmp, -1);
7514	if (tmp != NULL) xmlFree(tmp);
7515	*prefix = NULL;
7516	return(p);
7517	}
7518	if (CUR == ':') {
7519	xmlChar *tmp;
7520
7521	xmlNsErr(ctxt, XML_NS_ERR_QNAME,
7522	"Failed to parse QName '%s:%s:'\n", p, l, NULL);
7523	NEXT;
7524	tmp = (xmlChar *) xmlParseName(ctxt);
7525	if (tmp != NULL) {
7526	tmp = xmlBuildQName(tmp, l, NULL, 0);
7527	l = xmlDictLookup(ctxt->dict, tmp, -1);
7528	if (tmp != NULL) xmlFree(tmp);
7529	*prefix = p;
7530	return(l);
7531	}
7532	tmp = xmlBuildQName(BAD_CAST "", l, NULL, 0);
7533	l = xmlDictLookup(ctxt->dict, tmp, -1);
7534	if (tmp != NULL) xmlFree(tmp);
7535	*prefix = p;
7536	return(l);
7537	}
7538	*prefix = p;
7539	} else
7540	*prefix = NULL;
7541	return(l);
7542	}
7543
7544	/**
7545	* xmlParseQNameAndCompare:
7546	* @ctxt: an XML parser context
7547	* @name: the localname
7548	* @prefix: the prefix, if any.
7549	*
7550	* parse an XML name and compares for match
7551	* (specialized for endtag parsing)
7552	*
7553	* Returns NULL for an illegal name, (xmlChar*) 1 for success
7554	* and the name for mismatch
7555	*/
7556
7557	static const xmlChar *
7558	xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
7559	xmlChar const *prefix) {
7560	const xmlChar *cmp = name;
7561	const xmlChar *in;
7562	const xmlChar *ret;
7563	const xmlChar *prefix2;
7564
7565	if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
7566
7567	GROW;
7568	in = ctxt->input->cur;
7569
7570	cmp = prefix;
7571	while (in != 0 && in == *cmp) {
7572	++in;
7573	++cmp;
7574	}
7575	if ((cmp == 0) && (in == ':')) {
7576	in++;
7577	cmp = name;
7578	while (in != 0 && in == *cmp) {
7579	++in;
7580	++cmp;
7581	}
7582	if (cmp == 0 && (in == '>' \|\| IS_BLANK_CH (*in))) {
7583	/* success */
7584	ctxt->input->cur = in;
7585	return((const xmlChar*) 1);
7586	}
7587	}
7588	/*
7589	* all strings coms from the dictionary, equality can be done directly
7590	*/
7591	ret = xmlParseQName (ctxt, &prefix2);
7592	if ((ret == name) && (prefix == prefix2))
7593	return((const xmlChar*) 1);
7594	return ret;
7595	}
7596
7597	/**
7598	* xmlParseAttValueInternal:
7599	* @ctxt: an XML parser context
7600	* @len: attribute len result
7601	* @alloc: whether the attribute was reallocated as a new string
7602	* @normalize: if 1 then further non-CDATA normalization must be done
7603	*
7604	* parse a value for an attribute.
7605	* NOTE: if no normalization is needed, the routine will return pointers
7606	* directly from the data buffer.
7607	*
7608	* 3.3.3 Attribute-Value Normalization:
7609	* Before the value of an attribute is passed to the application or
7610	* checked for validity, the XML processor must normalize it as follows:
7611	* - a character reference is processed by appending the referenced
7612	* character to the attribute value
7613	* - an entity reference is processed by recursively processing the
7614	* replacement text of the entity
7615	* - a whitespace character (#x20, #xD, #xA, #x9) is processed by
7616	* appending #x20 to the normalized value, except that only a single
7617	* #x20 is appended for a "#xD#xA" sequence that is part of an external
7618	* parsed entity or the literal entity value of an internal parsed entity
7619	* - other characters are processed by appending them to the normalized value
7620	* If the declared value is not CDATA, then the XML processor must further
7621	* process the normalized attribute value by discarding any leading and
7622	* trailing space (#x20) characters, and by replacing sequences of space
7623	* (#x20) characters by a single space (#x20) character.
7624	* All attributes for which no declaration has been read should be treated
7625	* by a non-validating parser as if declared CDATA.
7626	*
7627	* Returns the AttValue parsed or NULL. The value has to be freed by the
7628	* caller if it was copied, this can be detected by val[*len] == 0.
7629	*/
7630
7631	static xmlChar *
7632	xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int len, int alloc,
7633	int normalize)
7634	{
7635	xmlChar limit = 0;
7636	const xmlChar in = NULL, start, end, last;
7637	xmlChar *ret = NULL;
7638
7639	GROW;
7640	in = (xmlChar *) CUR_PTR;
7641	if (in != '"' && in != '\'') {
7642	xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
7643	return (NULL);
7644	}
7645	ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
7646
7647	/*
7648	* try to handle in this routine the most common case where no
7649	* allocation of a new string is required and where content is
7650	* pure ASCII.
7651	*/
7652	limit = *in++;
7653	end = ctxt->input->end;
7654	start = in;
7655	if (in >= end) {
7656	const xmlChar *oldbase = ctxt->input->base;
7657	GROW;
7658	if (oldbase != ctxt->input->base) {
7659	long delta = ctxt->input->base - oldbase;
7660	start = start + delta;
7661	in = in + delta;
7662	}
7663	end = ctxt->input->end;
7664	}
7665	if (normalize) {
7666	/*
7667	* Skip any leading spaces
7668	*/
7669	while ((in < end) && (*in != limit) &&
7670	((in == 0x20) \|\| (in == 0x9) \|\|
7671	(in == 0xA) \|\| (in == 0xD))) {
7672	in++;
7673	start = in;
7674	if (in >= end) {
7675	const xmlChar *oldbase = ctxt->input->base;
7676	GROW;
7677	if (oldbase != ctxt->input->base) {
7678	long delta = ctxt->input->base - oldbase;
7679	start = start + delta;
7680	in = in + delta;
7681	}
7682	end = ctxt->input->end;
7683	}
7684	}
7685	while ((in < end) && (in != limit) && (in >= 0x20) &&
7686	(in <= 0x7f) && (in != '&') && (*in != '<')) {
7687	if ((in++ == 0x20) && (in == 0x20)) break;
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	}
7699	last = in;
7700	/*
7701	* skip the trailing blanks
7702	*/
7703	while ((last[-1] == 0x20) && (last > start)) last--;
7704	while ((in < end) && (*in != limit) &&
7705	((in == 0x20) \|\| (in == 0x9) \|\|
7706	(in == 0xA) \|\| (in == 0xD))) {
7707	in++;
7708	if (in >= end) {
7709	const xmlChar *oldbase = ctxt->input->base;
7710	GROW;
7711	if (oldbase != ctxt->input->base) {
7712	long delta = ctxt->input->base - oldbase;
7713	start = start + delta;
7714	in = in + delta;
7715	last = last + delta;
7716	}
7717	end = ctxt->input->end;
7718	}
7719	}
7720	if (*in != limit) goto need_complex;
7721	} else {
7722	while ((in < end) && (in != limit) && (in >= 0x20) &&
7723	(in <= 0x7f) && (in != '&') && (*in != '<')) {
7724	in++;
7725	if (in >= end) {
7726	const xmlChar *oldbase = ctxt->input->base;
7727	GROW;
7728	if (oldbase != ctxt->input->base) {
7729	long delta = ctxt->input->base - oldbase;
7730	start = start + delta;
7731	in = in + delta;
7732	}
7733	end = ctxt->input->end;
7734	}
7735	}
7736	last = in;
7737	if (*in != limit) goto need_complex;
7738	}
7739	in++;
7740	if (len != NULL) {
7741	*len = last - start;
7742	ret = (xmlChar *) start;
7743	} else {
7744	if (alloc) *alloc = 1;
7745	ret = xmlStrndup(start, last - start);
7746	}
7747	CUR_PTR = in;
7748	if (alloc) *alloc = 0;
7749	return ret;
7750	need_complex:
7751	if (alloc) *alloc = 1;
7752	return xmlParseAttValueComplex(ctxt, len, normalize);
7753	}
7754
7755	/**
7756	* xmlParseAttribute2:
7757	* @ctxt: an XML parser context
7758	* @pref: the element prefix
7759	* @elem: the element name
7760	* @prefix: a xmlChar ** used to store the value of the attribute prefix
7761	* @value: a xmlChar ** used to store the value of the attribute
7762	* @len: an int * to save the length of the attribute
7763	* @alloc: an int * to indicate if the attribute was allocated
7764	*
7765	* parse an attribute in the new SAX2 framework.
7766	*
7767	* Returns the attribute name, and the value in *value, .
7768	*/
7769
7770	static const xmlChar *
7771	xmlParseAttribute2(xmlParserCtxtPtr ctxt,
7772	const xmlChar pref, const xmlChar elem,
7773	const xmlChar prefix, xmlChar value,
7774	int len, int alloc) {
7775	const xmlChar *name;
7776	xmlChar val, internal_val = NULL;
7777	int normalize = 0;
7778
7779	*value = NULL;
7780	GROW;
7781	name = xmlParseQName(ctxt, prefix);
7782	if (name == NULL) {
7783	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7784	"error parsing attribute name\n");
7785	return(NULL);
7786	}
7787
7788	/*
7789	* get the type if needed
7790	*/
7791	if (ctxt->attsSpecial != NULL) {
7792	int type;
7793
7794	type = (int) (long) xmlHashQLookup2(ctxt->attsSpecial,
7795	pref, elem, *prefix, name);
7796	if (type != 0) normalize = 1;
7797	}
7798
7799	/*
7800	* read the value
7801	*/
7802	SKIP_BLANKS;
7803	if (RAW == '=') {
7804	NEXT;
7805	SKIP_BLANKS;
7806	val = xmlParseAttValueInternal(ctxt, len, alloc, normalize);
7807	ctxt->instate = XML_PARSER_CONTENT;
7808	} else {
7809	xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
7810	"Specification mandate value for attribute %s\n", name);
7811	return(NULL);
7812	}
7813
7814	if (*prefix == ctxt->str_xml) {
7815	/*
7816	* Check that xml:lang conforms to the specification
7817	* No more registered as an error, just generate a warning now
7818	* since this was deprecated in XML second edition
7819	*/
7820	if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) {
7821	internal_val = xmlStrndup(val, *len);
7822	if (!xmlCheckLanguageID(internal_val)) {
7823	xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
7824	"Malformed value for xml:lang : %s\n",
7825	internal_val, NULL);
7826	}
7827	}
7828
7829	/*
7830	* Check that xml:space conforms to the specification
7831	*/
7832	if (xmlStrEqual(name, BAD_CAST "space")) {
7833	internal_val = xmlStrndup(val, *len);
7834	if (xmlStrEqual(internal_val, BAD_CAST "default"))
7835	*(ctxt->space) = 0;
7836	else if (xmlStrEqual(internal_val, BAD_CAST "preserve"))
7837	*(ctxt->space) = 1;
7838	else {
7839	xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
7840	"Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
7841	internal_val, NULL);
7842	}
7843	}
7844	if (internal_val) {
7845	xmlFree(internal_val);
7846	}
7847	}
7848
7849	*value = val;
7850	return(name);
7851	}
7852
7853	/**
7854	* xmlParseStartTag2:
7855	* @ctxt: an XML parser context
7856	*
7857	* parse a start of tag either for rule element or
7858	* EmptyElement. In both case we don't parse the tag closing chars.
7859	* This routine is called when running SAX2 parsing
7860	*
7861	* [40] STag ::= '<' Name (S Attribute)* S? '>'
7862	*
7863	* [ WFC: Unique Att Spec ]
7864	* No attribute name may appear more than once in the same start-tag or
7865	* empty-element tag.
7866	*
7867	* [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
7868	*
7869	* [ WFC: Unique Att Spec ]
7870	* No attribute name may appear more than once in the same start-tag or
7871	* empty-element tag.
7872	*
7873	* With namespace:
7874	*
7875	* [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
7876	*
7877	* [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
7878	*
7879	* Returns the element name parsed
7880	*/
7881
7882	static const xmlChar *
7883	xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref,
7884	const xmlChar *URI, int tlen) {
7885	const xmlChar *localname;
7886	const xmlChar *prefix;
7887	const xmlChar *attname;
7888	const xmlChar *aprefix;
7889	const xmlChar *nsname;
7890	xmlChar *attvalue;
7891	const xmlChar **atts = ctxt->atts;
7892	int maxatts = ctxt->maxatts;
7893	int nratts, nbatts, nbdef;
7894	int i, j, nbNs, attval, oldline, oldcol;
7895	const xmlChar *base;
7896	unsigned long cur;
7897	int nsNr = ctxt->nsNr;
7898
7899	if (RAW != '<') return(NULL);
7900	NEXT1;
7901
7902	/*
7903	* NOTE: it is crucial with the SAX2 API to never call SHRINK beyond that
7904	* point since the attribute values may be stored as pointers to
7905	* the buffer and calling SHRINK would destroy them !
7906	* The Shrinking is only possible once the full set of attribute
7907	* callbacks have been done.
7908	*/
7909	reparse:
7910	SHRINK;
7911	base = ctxt->input->base;
7912	cur = ctxt->input->cur - ctxt->input->base;
7913	oldline = ctxt->input->line;
7914	oldcol = ctxt->input->col;
7915	nbatts = 0;
7916	nratts = 0;
7917	nbdef = 0;
7918	nbNs = 0;
7919	attval = 0;
7920	/* Forget any namespaces added during an earlier parse of this element. */
7921	ctxt->nsNr = nsNr;
7922
7923	localname = xmlParseQName(ctxt, &prefix);
7924	if (localname == NULL) {
7925	xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7926	"StartTag: invalid element name\n");
7927	return(NULL);
7928	}
7929	*tlen = ctxt->input->cur - ctxt->input->base - cur;
7930
7931	/*
7932	* Now parse the attributes, it ends up with the ending
7933	*
7934	* (S Attribute)* S?
7935	*/
7936	SKIP_BLANKS;
7937	GROW;
7938	if (ctxt->input->base != base) goto base_changed;
7939
7940	while ((RAW != '>') &&
7941	((RAW != '/') \|\| (NXT(1) != '>')) &&
7942	(IS_BYTE_CHAR(RAW))) {
7943	const xmlChar *q = CUR_PTR;
7944	unsigned int cons = ctxt->input->consumed;
7945	int len = -1, alloc = 0;
7946
7947	attname = xmlParseAttribute2(ctxt, prefix, localname,
7948	&aprefix, &attvalue, &len, &alloc);
7949	if (ctxt->input->base != base) {
7950	if ((attvalue != NULL) && (alloc != 0))
7951	xmlFree(attvalue);
7952	attvalue = NULL;
7953	goto base_changed;
7954	}
7955	if ((attname != NULL) && (attvalue != NULL)) {
7956	if (len < 0) len = xmlStrlen(attvalue);
7957	if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
7958	const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
7959	xmlURIPtr uri;
7960
7961	if (*URL != 0) {
7962	uri = xmlParseURI((const char *) URL);
7963	if (uri == NULL) {
7964	xmlWarningMsg(ctxt, XML_WAR_NS_URI,
7965	"xmlns: %s not a valid URI\n",
7966	URL, NULL);
7967	} else {
7968	if (uri->scheme == NULL) {
7969	xmlWarningMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
7970	"xmlns: URI %s is not absolute\n",
7971	URL, NULL);
7972	}
7973	xmlFreeURI(uri);
7974	}
7975	}
7976	/*
7977	* check that it's not a defined namespace
7978	*/
7979	for (j = 1;j <= nbNs;j++)
7980	if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
7981	break;
7982	if (j <= nbNs)
7983	xmlErrAttributeDup(ctxt, NULL, attname);
7984	else
7985	if (nsPush(ctxt, NULL, URL) > 0) nbNs++;
7986	if (alloc != 0) xmlFree(attvalue);
7987	SKIP_BLANKS;
7988	continue;
7989	}
7990	if (aprefix == ctxt->str_xmlns) {
7991	const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
7992	xmlURIPtr uri;
7993
7994	if (attname == ctxt->str_xml) {
7995	if (URL != ctxt->str_xml_ns) {
7996	xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
7997	"xml namespace prefix mapped to wrong URI\n",
7998	NULL, NULL, NULL);
7999	}
8000	/*
8001	* Do not keep a namespace definition node
8002	*/
8003	if (alloc != 0) xmlFree(attvalue);
8004	SKIP_BLANKS;
8005	continue;
8006	}
8007	uri = xmlParseURI((const char *) URL);
8008	if (uri == NULL) {
8009	xmlWarningMsg(ctxt, XML_WAR_NS_URI,
8010	"xmlns:%s: '%s' is not a valid URI\n",
8011	attname, URL);
8012	} else {
8013	if ((ctxt->pedantic) && (uri->scheme == NULL)) {
8014	xmlWarningMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
8015	"xmlns:%s: URI %s is not absolute\n",
8016	attname, URL);
8017	}
8018	xmlFreeURI(uri);
8019	}
8020
8021	/*
8022	* check that it's not a defined namespace
8023	*/
8024	for (j = 1;j <= nbNs;j++)
8025	if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
8026	break;
8027	if (j <= nbNs)
8028	xmlErrAttributeDup(ctxt, aprefix, attname);
8029	else
8030	if (nsPush(ctxt, attname, URL) > 0) nbNs++;
8031	if (alloc != 0) xmlFree(attvalue);
8032	SKIP_BLANKS;
8033	if (ctxt->input->base != base) goto base_changed;
8034	continue;
8035	}
8036
8037	/*
8038	* Add the pair to atts
8039	*/
8040	if ((atts == NULL) \|\| (nbatts + 5 > maxatts)) {
8041	if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
8042	if (attvalue[len] == 0)
8043	xmlFree(attvalue);
8044	goto failed;
8045	}
8046	maxatts = ctxt->maxatts;
8047	atts = ctxt->atts;
8048	}
8049	ctxt->attallocs[nratts++] = alloc;
8050	atts[nbatts++] = attname;
8051	atts[nbatts++] = aprefix;
8052	atts[nbatts++] = NULL; /* the URI will be fetched later */
8053	atts[nbatts++] = attvalue;
8054	attvalue += len;
8055	atts[nbatts++] = attvalue;
8056	/*
8057	* tag if some deallocation is needed
8058	*/
8059	if (alloc != 0) attval = 1;
8060	} else {
8061	if ((attvalue != NULL) && (attvalue[len] == 0))
8062	xmlFree(attvalue);
8063	}
8064
8065	failed:
8066
8067	GROW
8068	if (ctxt->input->base != base) goto base_changed;
8069	if ((RAW == '>') \|\| (((RAW == '/') && (NXT(1) == '>'))))
8070	break;
8071	if (!IS_BLANK_CH(RAW)) {
8072	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
8073	"attributes construct error\n");
8074	break;
8075	}
8076	SKIP_BLANKS;
8077	if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
8078	(attname == NULL) && (attvalue == NULL)) {
8079	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8080	"xmlParseStartTag: problem parsing attributes\n");
8081	break;
8082	}
8083	GROW;
8084	if (ctxt->input->base != base) goto base_changed;
8085	}
8086
8087	/*
8088	* The attributes defaulting
8089	*/
8090	if (ctxt->attsDefault != NULL) {
8091	xmlDefAttrsPtr defaults;
8092
8093	defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
8094	if (defaults != NULL) {
8095	for (i = 0;i < defaults->nbAttrs;i++) {
8096	attname = defaults->values[4 * i];
8097	aprefix = defaults->values[4 * i + 1];
8098
8099	/*
8100	* special work for namespaces defaulted defs
8101	*/
8102	if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
8103	/*
8104	* check that it's not a defined namespace
8105	*/
8106	for (j = 1;j <= nbNs;j++)
8107	if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
8108	break;
8109	if (j <= nbNs) continue;
8110
8111	nsname = xmlGetNamespace(ctxt, NULL);
8112	if (nsname != defaults->values[4 * i + 2]) {
8113	if (nsPush(ctxt, NULL,
8114	defaults->values[4 * i + 2]) > 0)
8115	nbNs++;
8116	}
8117	} else if (aprefix == ctxt->str_xmlns) {
8118	/*
8119	* check that it's not a defined namespace
8120	*/
8121	for (j = 1;j <= nbNs;j++)
8122	if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
8123	break;
8124	if (j <= nbNs) continue;
8125
8126	nsname = xmlGetNamespace(ctxt, attname);
8127	if (nsname != defaults->values[2]) {
8128	if (nsPush(ctxt, attname,
8129	defaults->values[4 * i + 2]) > 0)
8130	nbNs++;
8131	}
8132	} else {
8133	/*
8134	* check that it's not a defined attribute
8135	*/
8136	for (j = 0;j < nbatts;j+=5) {
8137	if ((attname == atts[j]) && (aprefix == atts[j+1]))
8138	break;
8139	}
8140	if (j < nbatts) continue;
8141
8142	if ((atts == NULL) \|\| (nbatts + 5 > maxatts)) {
8143	if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
8144	return(NULL);
8145	}
8146	maxatts = ctxt->maxatts;
8147	atts = ctxt->atts;
8148	}
8149	atts[nbatts++] = attname;
8150	atts[nbatts++] = aprefix;
8151	if (aprefix == NULL)
8152	atts[nbatts++] = NULL;
8153	else
8154	atts[nbatts++] = xmlGetNamespace(ctxt, aprefix);
8155	atts[nbatts++] = defaults->values[4 * i + 2];
8156	atts[nbatts++] = defaults->values[4 * i + 3];
8157	nbdef++;
8158	}
8159	}
8160	}
8161	}
8162
8163	/*
8164	* The attributes checkings
8165	*/
8166	for (i = 0; i < nbatts;i += 5) {
8167	/*
8168	* The default namespace does not apply to attribute names.
8169	*/
8170	if (atts[i + 1] != NULL) {
8171	nsname = xmlGetNamespace(ctxt, atts[i + 1]);
8172	if (nsname == NULL) {
8173	xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
8174	"Namespace prefix %s for %s on %s is not defined\n",
8175	atts[i + 1], atts[i], localname);
8176	}
8177	atts[i + 2] = nsname;
8178	} else
8179	nsname = NULL;
8180	/*
8181	* [ WFC: Unique Att Spec ]
8182	* No attribute name may appear more than once in the same
8183	* start-tag or empty-element tag.
8184	* As extended by the Namespace in XML REC.
8185	*/
8186	for (j = 0; j < i;j += 5) {
8187	if (atts[i] == atts[j]) {
8188	if (atts[i+1] == atts[j+1]) {
8189	xmlErrAttributeDup(ctxt, atts[i+1], atts[i]);
8190	break;
8191	}
8192	if ((nsname != NULL) && (atts[j + 2] == nsname)) {
8193	xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
8194	"Namespaced Attribute %s in '%s' redefined\n",
8195	atts[i], nsname, NULL);
8196	break;
8197	}
8198	}
8199	}
8200	}
8201
8202	nsname = xmlGetNamespace(ctxt, prefix);
8203	if ((prefix != NULL) && (nsname == NULL)) {
8204	xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
8205	"Namespace prefix %s on %s is not defined\n",
8206	prefix, localname, NULL);
8207	}
8208	*pref = prefix;
8209	*URI = nsname;
8210
8211	/*
8212	* SAX: Start of Element !
8213	*/
8214	if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
8215	(!ctxt->disableSAX)) {
8216	if (nbNs > 0)
8217	ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
8218	nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs],
8219	nbatts / 5, nbdef, atts);
8220	else
8221	ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
8222	nsname, 0, NULL, nbatts / 5, nbdef, atts);
8223	}
8224
8225	/*
8226	* Free up attribute allocated strings if needed
8227	*/
8228	if (attval != 0) {
8229	for (i = 3,j = 0; j < nratts;i += 5,j++)
8230	if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
8231	xmlFree((xmlChar *) atts[i]);
8232	}
8233
8234	return(localname);
8235
8236	base_changed:
8237	/*
8238	* the attribute strings are valid iif the base didn't changed
8239	*/
8240	if (attval != 0) {
8241	for (i = 3,j = 0; j < nratts;i += 5,j++)
8242	if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
8243	xmlFree((xmlChar *) atts[i]);
8244	}
8245	ctxt->input->cur = ctxt->input->base + cur;
8246	ctxt->input->line = oldline;
8247	ctxt->input->col = oldcol;
8248	if (ctxt->wellFormed == 1) {
8249	goto reparse;
8250	}
8251	return(NULL);
8252	}
8253
8254	/**
8255	* xmlParseEndTag2:
8256	* @ctxt: an XML parser context
8257	* @line: line of the start tag
8258	* @nsNr: number of namespaces on the start tag
8259	*
8260	* parse an end of tag
8261	*
8262	* [42] ETag ::= '</' Name S? '>'
8263	*
8264	* With namespace
8265	*
8266	* [NS 9] ETag ::= '</' QName S? '>'
8267	*/
8268
8269	static void
8270	xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix,
8271	const xmlChar *URI, int line, int nsNr, int tlen) {
8272	const xmlChar *name;
8273
8274	GROW;
8275	if ((RAW != '<') \|\| (NXT(1) != '/')) {
8276	xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL);
8277	return;
8278	}
8279	SKIP(2);
8280
8281	if ((tlen > 0) && (xmlStrncmp(ctxt->input->cur, ctxt->name, tlen) == 0)) {
8282	if (ctxt->input->cur[tlen] == '>') {
8283	ctxt->input->cur += tlen + 1;
8284	goto done;
8285	}
8286	ctxt->input->cur += tlen;
8287	name = (xmlChar*)1;
8288	} else {
8289	if (prefix == NULL)
8290	name = xmlParseNameAndCompare(ctxt, ctxt->name);
8291	else
8292	name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix);
8293	}
8294
8295	/*
8296	* We should definitely be at the ending "S? '>'" part
8297	*/
8298	GROW;
8299	SKIP_BLANKS;
8300	if ((!IS_BYTE_CHAR(RAW)) \|\| (RAW != '>')) {
8301	xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
8302	} else
8303	NEXT1;
8304
8305	/*
8306	* [ WFC: Element Type Match ]
8307	* The Name in an element's end-tag must match the element type in the
8308	* start-tag.
8309	*
8310	*/
8311	if (name != (xmlChar*)1) {
8312	if (name == NULL) name = BAD_CAST "unparseable";
8313	xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
8314	"Opening and ending tag mismatch: %s line %d and %s\n",
8315	ctxt->name, line, name);
8316	}
8317
8318	/*
8319	* SAX: End of Tag
8320	*/
8321	done:
8322	if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
8323	(!ctxt->disableSAX))
8324	ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI);
8325
8326	spacePop(ctxt);
8327	if (nsNr != 0)
8328	nsPop(ctxt, nsNr);
8329	return;
8330	}
8331
8332	/**
8333	* xmlParseCDSect:
8334	* @ctxt: an XML parser context
8335	*
8336	* Parse escaped pure raw content.
8337	*
8338	* [18] CDSect ::= CDStart CData CDEnd
8339	*
8340	* [19] CDStart ::= '<![CDATA['
8341	*
8342	* [20] Data ::= (Char* - (Char* ']]>' Char*))
8343	*
8344	* [21] CDEnd ::= ']]>'
8345	*/
8346	void
8347	xmlParseCDSect(xmlParserCtxtPtr ctxt) {
8348	xmlChar *buf = NULL;
8349	int len = 0;
8350	int size = XML_PARSER_BUFFER_SIZE;
8351	int r, rl;
8352	int s, sl;
8353	int cur, l;
8354	int count = 0;
8355
8356	/* Check 2.6.0 was NXT(0) not RAW */
8357	if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
8358	SKIP(9);
8359	} else
8360	return;
8361
8362	ctxt->instate = XML_PARSER_CDATA_SECTION;
8363	r = CUR_CHAR(rl);
8364	if (!IS_CHAR(r)) {
8365	xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
8366	ctxt->instate = XML_PARSER_CONTENT;
8367	return;
8368	}
8369	NEXTL(rl);
8370	s = CUR_CHAR(sl);
8371	if (!IS_CHAR(s)) {
8372	xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
8373	ctxt->instate = XML_PARSER_CONTENT;
8374	return;
8375	}
8376	NEXTL(sl);
8377	cur = CUR_CHAR(l);
8378	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
8379	if (buf == NULL) {
8380	xmlErrMemory(ctxt, NULL);
8381	return;
8382	}
8383	while (IS_CHAR(cur) &&
8384	((r != ']') \|\| (s != ']') \|\| (cur != '>'))) {
8385	if (len + 5 >= size) {
8386	xmlChar *tmp;
8387
8388	size *= 2;
8389	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
8390	if (tmp == NULL) {
8391	xmlFree(buf);
8392	xmlErrMemory(ctxt, NULL);
8393	return;
8394	}
8395	buf = tmp;
8396	}
8397	COPY_BUF(rl,buf,len,r);
8398	r = s;
8399	rl = sl;
8400	s = cur;
8401	sl = l;
8402	count++;
8403	if (count > 50) {
8404	GROW;
8405	count = 0;
8406	}
8407	NEXTL(l);
8408	cur = CUR_CHAR(l);
8409	}
8410	buf[len] = 0;
8411	ctxt->instate = XML_PARSER_CONTENT;
8412	if (cur != '>') {
8413	xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
8414	"CData section not finished\n%.50s\n", buf);
8415	xmlFree(buf);
8416	return;
8417	}
8418	NEXTL(l);
8419
8420	/*
8421	* OK the buffer is to be consumed as cdata.
8422	*/
8423	if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
8424	if (ctxt->sax->cdataBlock != NULL)
8425	ctxt->sax->cdataBlock(ctxt->userData, buf, len);
8426	else if (ctxt->sax->characters != NULL)
8427	ctxt->sax->characters(ctxt->userData, buf, len);
8428	}
8429	xmlFree(buf);
8430	}
8431
8432	/**
8433	* xmlParseContent:
8434	* @ctxt: an XML parser context
8435	*
8436	* Parse a content:
8437	*
8438	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
8439	*/
8440
8441	void
8442	xmlParseContent(xmlParserCtxtPtr ctxt) {
8443	GROW;
8444	while ((RAW != 0) &&
8445	((RAW != '<') \|\| (NXT(1) != '/')) &&
8446	(ctxt->instate != XML_PARSER_EOF)) {
8447	const xmlChar *test = CUR_PTR;
8448	unsigned int cons = ctxt->input->consumed;
8449	const xmlChar *cur = ctxt->input->cur;
8450
8451	/*
8452	* First case : a Processing Instruction.
8453	*/
8454	if ((*cur == '<') && (cur[1] == '?')) {
8455	xmlParsePI(ctxt);
8456	}
8457
8458	/*
8459	* Second case : a CDSection
8460	*/
8461	/* 2.6.0 test was cur not RAW /
8462	else if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
8463	xmlParseCDSect(ctxt);
8464	}
8465
8466	/*
8467	* Third case : a comment
8468	*/
8469	else if ((*cur == '<') && (NXT(1) == '!') &&
8470	(NXT(2) == '-') && (NXT(3) == '-')) {
8471	xmlParseComment(ctxt);
8472	ctxt->instate = XML_PARSER_CONTENT;
8473	}
8474
8475	/*
8476	* Fourth case : a sub-element.
8477	*/
8478	else if (*cur == '<') {
8479	xmlParseElement(ctxt);
8480	}
8481
8482	/*
8483	* Fifth case : a reference. If if has not been resolved,
8484	* parsing returns it's Name, create the node
8485	*/
8486
8487	else if (*cur == '&') {
8488	xmlParseReference(ctxt);
8489	}
8490
8491	/*
8492	* Last case, text. Note that References are handled directly.
8493	*/
8494	else {
8495	xmlParseCharData(ctxt, 0);
8496	}
8497
8498	GROW;
8499	/*
8500	* Pop-up of finished entities.
8501	*/
8502	while ((RAW == 0) && (ctxt->inputNr > 1))
8503	xmlPopInput(ctxt);
8504	SHRINK;
8505
8506	if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
8507	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8508	"detected an error in element content\n");
8509	ctxt->instate = XML_PARSER_EOF;
8510	break;
8511	}
8512	}
8513	}
8514
8515	/**
8516	* xmlParseElement:
8517	* @ctxt: an XML parser context
8518	*
8519	* parse an XML element, this is highly recursive
8520	*
8521	* [39] element ::= EmptyElemTag \| STag content ETag
8522	*
8523	* [ WFC: Element Type Match ]
8524	* The Name in an element's end-tag must match the element type in the
8525	* start-tag.
8526	*
8527	*/
8528
8529	void
8530	xmlParseElement(xmlParserCtxtPtr ctxt) {
8531	const xmlChar *name;
8532	const xmlChar *prefix;
8533	const xmlChar *URI;
8534	xmlParserNodeInfo node_info;
8535	int line, tlen;
8536	xmlNodePtr ret;
8537	int nsNr = ctxt->nsNr;
8538
8539	if ((unsigned int) ctxt->nameNr > xmlParserMaxDepth) {
8540	xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
8541	"Excessive depth in document: change xmlParserMaxDepth = %d\n",
8542	xmlParserMaxDepth);
8543	ctxt->instate = XML_PARSER_EOF;
8544	return;
8545	}
8546
8547	/* Capture start position */
8548	if (ctxt->record_info) {
8549	node_info.begin_pos = ctxt->input->consumed +
8550	(CUR_PTR - ctxt->input->base);
8551	node_info.begin_line = ctxt->input->line;
8552	}
8553
8554	if (ctxt->spaceNr == 0)
8555	spacePush(ctxt, -1);
8556	else if (*ctxt->space == -2)
8557	spacePush(ctxt, -1);
8558	else
8559	spacePush(ctxt, *ctxt->space);
8560
8561	line = ctxt->input->line;
8562	#ifdef LIBXML_SAX1_ENABLED
8563	if (ctxt->sax2)
8564	#endif /* LIBXML_SAX1_ENABLED */
8565	name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
8566	#ifdef LIBXML_SAX1_ENABLED
8567	else
8568	name = xmlParseStartTag(ctxt);
8569	#endif /* LIBXML_SAX1_ENABLED */
8570	if (name == NULL) {
8571	spacePop(ctxt);
8572	return;
8573	}
8574	namePush(ctxt, name);
8575	ret = ctxt->node;
8576
8577	#ifdef LIBXML_VALID_ENABLED
8578	/*
8579	* [ VC: Root Element Type ]
8580	* The Name in the document type declaration must match the element
8581	* type of the root element.
8582	*/
8583	if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
8584	ctxt->node && (ctxt->node == ctxt->myDoc->children))
8585	ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
8586	#endif /* LIBXML_VALID_ENABLED */
8587
8588	/*
8589	* Check for an Empty Element.
8590	*/
8591	if ((RAW == '/') && (NXT(1) == '>')) {
8592	SKIP(2);
8593	if (ctxt->sax2) {
8594	if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
8595	(!ctxt->disableSAX))
8596	ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
8597	#ifdef LIBXML_SAX1_ENABLED
8598	} else {
8599	if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
8600	(!ctxt->disableSAX))
8601	ctxt->sax->endElement(ctxt->userData, name);
8602	#endif /* LIBXML_SAX1_ENABLED */
8603	}
8604	namePop(ctxt);
8605	spacePop(ctxt);
8606	if (nsNr != ctxt->nsNr)
8607	nsPop(ctxt, ctxt->nsNr - nsNr);
8608	if ( ret != NULL && ctxt->record_info ) {
8609	node_info.end_pos = ctxt->input->consumed +
8610	(CUR_PTR - ctxt->input->base);
8611	node_info.end_line = ctxt->input->line;
8612	node_info.node = ret;
8613	xmlParserAddNodeInfo(ctxt, &node_info);
8614	}
8615	return;
8616	}
8617	if (RAW == '>') {
8618	NEXT1;
8619	} else {
8620	xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED,
8621	"Couldn't find end of Start Tag %s line %d\n",
8622	name, line, NULL);
8623
8624	/*
8625	* end of parsing of this node.
8626	*/
8627	nodePop(ctxt);
8628	namePop(ctxt);
8629	spacePop(ctxt);
8630	if (nsNr != ctxt->nsNr)
8631	nsPop(ctxt, ctxt->nsNr - nsNr);
8632
8633	/*
8634	* Capture end position and add node
8635	*/
8636	if ( ret != NULL && ctxt->record_info ) {
8637	node_info.end_pos = ctxt->input->consumed +
8638	(CUR_PTR - ctxt->input->base);
8639	node_info.end_line = ctxt->input->line;
8640	node_info.node = ret;
8641	xmlParserAddNodeInfo(ctxt, &node_info);
8642	}
8643	return;
8644	}
8645
8646	/*
8647	* Parse the content of the element:
8648	*/
8649	xmlParseContent(ctxt);
8650	if (!IS_BYTE_CHAR(RAW)) {
8651	xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
8652	"Premature end of data in tag %s line %d\n",
8653	name, line, NULL);
8654
8655	/*
8656	* end of parsing of this node.
8657	*/
8658	nodePop(ctxt);
8659	namePop(ctxt);
8660	spacePop(ctxt);
8661	if (nsNr != ctxt->nsNr)
8662	nsPop(ctxt, ctxt->nsNr - nsNr);
8663	return;
8664	}
8665
8666	/*
8667	* parse the end of tag: '</' should be here.
8668	*/
8669	if (ctxt->sax2) {
8670	xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr, tlen);
8671	namePop(ctxt);
8672	}
8673	#ifdef LIBXML_SAX1_ENABLED
8674	else
8675	xmlParseEndTag1(ctxt, line);
8676	#endif /* LIBXML_SAX1_ENABLED */
8677
8678	/*
8679	* Capture end position and add node
8680	*/
8681	if ( ret != NULL && ctxt->record_info ) {
8682	node_info.end_pos = ctxt->input->consumed +
8683	(CUR_PTR - ctxt->input->base);
8684	node_info.end_line = ctxt->input->line;
8685	node_info.node = ret;
8686	xmlParserAddNodeInfo(ctxt, &node_info);
8687	}
8688	}
8689
8690	/**
8691	* xmlParseVersionNum:
8692	* @ctxt: an XML parser context
8693	*
8694	* parse the XML version value.
8695	*
8696	* [26] VersionNum ::= ([a-zA-Z0-9_.:] \| '-')+
8697	*
8698	* Returns the string giving the XML version number, or NULL
8699	*/
8700	xmlChar *
8701	xmlParseVersionNum(xmlParserCtxtPtr ctxt) {
8702	xmlChar *buf = NULL;
8703	int len = 0;
8704	int size = 10;
8705	xmlChar cur;
8706
8707	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
8708	if (buf == NULL) {
8709	xmlErrMemory(ctxt, NULL);
8710	return(NULL);
8711	}
8712	cur = CUR;
8713	while (((cur >= 'a') && (cur <= 'z')) \|\|
8714	((cur >= 'A') && (cur <= 'Z')) \|\|
8715	((cur >= '0') && (cur <= '9')) \|\|
8716	(cur == '_') \|\| (cur == '.') \|\|
8717	(cur == ':') \|\| (cur == '-')) {
8718	if (len + 1 >= size) {
8719	xmlChar *tmp;
8720
8721	size *= 2;
8722	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
8723	if (tmp == NULL) {
8724	xmlErrMemory(ctxt, NULL);
8725	return(NULL);
8726	}
8727	buf = tmp;
8728	}
8729	buf[len++] = cur;
8730	NEXT;
8731	cur=CUR;
8732	}
8733	buf[len] = 0;
8734	return(buf);
8735	}
8736
8737	/**
8738	* xmlParseVersionInfo:
8739	* @ctxt: an XML parser context
8740	*
8741	* parse the XML version.
8742	*
8743	* [24] VersionInfo ::= S 'version' Eq (' VersionNum ' \| " VersionNum ")
8744	*
8745	* [25] Eq ::= S? '=' S?
8746	*
8747	* Returns the version string, e.g. "1.0"
8748	*/
8749
8750	xmlChar *
8751	xmlParseVersionInfo(xmlParserCtxtPtr ctxt) {
8752	xmlChar *version = NULL;
8753
8754	if (CMP7(CUR_PTR, 'v', 'e', 'r', 's', 'i', 'o', 'n')) {
8755	SKIP(7);
8756	SKIP_BLANKS;
8757	if (RAW != '=') {
8758	xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
8759	return(NULL);
8760	}
8761	NEXT;
8762	SKIP_BLANKS;
8763	if (RAW == '"') {
8764	NEXT;
8765	version = xmlParseVersionNum(ctxt);
8766	if (RAW != '"') {
8767	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
8768	} else
8769	NEXT;
8770	} else if (RAW == '\''){
8771	NEXT;
8772	version = xmlParseVersionNum(ctxt);
8773	if (RAW != '\'') {
8774	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
8775	} else
8776	NEXT;
8777	} else {
8778	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
8779	}
8780	}
8781	return(version);
8782	}
8783
8784	/**
8785	* xmlParseEncName:
8786	* @ctxt: an XML parser context
8787	*
8788	* parse the XML encoding name
8789	*
8790	* [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] \| '-')*
8791	*
8792	* Returns the encoding name value or NULL
8793	*/
8794	xmlChar *
8795	xmlParseEncName(xmlParserCtxtPtr ctxt) {
8796	xmlChar *buf = NULL;
8797	int len = 0;
8798	int size = 10;
8799	xmlChar cur;
8800
8801	cur = CUR;
8802	if (((cur >= 'a') && (cur <= 'z')) \|\|
8803	((cur >= 'A') && (cur <= 'Z'))) {
8804	buf = (xmlChar ) xmlMallocAtomic(size sizeof(xmlChar));
8805	if (buf == NULL) {
8806	xmlErrMemory(ctxt, NULL);
8807	return(NULL);
8808	}
8809
8810	buf[len++] = cur;
8811	NEXT;
8812	cur = CUR;
8813	while (((cur >= 'a') && (cur <= 'z')) \|\|
8814	((cur >= 'A') && (cur <= 'Z')) \|\|
8815	((cur >= '0') && (cur <= '9')) \|\|
8816	(cur == '.') \|\| (cur == '_') \|\|
8817	(cur == '-')) {
8818	if (len + 1 >= size) {
8819	xmlChar *tmp;
8820
8821	size *= 2;
8822	tmp = (xmlChar ) xmlRealloc(buf, size sizeof(xmlChar));
8823	if (tmp == NULL) {
8824	xmlErrMemory(ctxt, NULL);
8825	xmlFree(buf);
8826	return(NULL);
8827	}
8828	buf = tmp;
8829	}
8830	buf[len++] = cur;
8831	NEXT;
8832	cur = CUR;
8833	if (cur == 0) {
8834	SHRINK;
8835	GROW;
8836	cur = CUR;
8837	}
8838	}
8839	buf[len] = 0;
8840	} else {
8841	xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
8842	}
8843	return(buf);
8844	}
8845
8846	/**
8847	* xmlParseEncodingDecl:
8848	* @ctxt: an XML parser context
8849	*
8850	* parse the XML encoding declaration
8851	*
8852	* [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' \| "'" EncName "'")
8853	*
8854	* this setups the conversion filters.
8855	*
8856	* Returns the encoding value or NULL
8857	*/
8858
8859	const xmlChar *
8860	xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) {
8861	xmlChar *encoding = NULL;
8862
8863	SKIP_BLANKS;
8864	if (CMP8(CUR_PTR, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g')) {
8865	SKIP(8);
8866	SKIP_BLANKS;
8867	if (RAW != '=') {
8868	xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
8869	return(NULL);
8870	}
8871	NEXT;
8872	SKIP_BLANKS;
8873	if (RAW == '"') {
8874	NEXT;
8875	encoding = xmlParseEncName(ctxt);
8876	if (RAW != '"') {
8877	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
8878	} else
8879	NEXT;
8880	} else if (RAW == '\''){
8881	NEXT;
8882	encoding = xmlParseEncName(ctxt);
8883	if (RAW != '\'') {
8884	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
8885	} else
8886	NEXT;
8887	} else {
8888	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
8889	}
8890	/*
8891	* UTF-16 encoding stwich has already taken place at this stage,
8892	* more over the little-endian/big-endian selection is already done
8893	*/
8894	if ((encoding != NULL) &&
8895	((!xmlStrcasecmp(encoding, BAD_CAST "UTF-16")) \|\|
8896	(!xmlStrcasecmp(encoding, BAD_CAST "UTF16")))) {
8897	if (ctxt->encoding != NULL)
8898	xmlFree((xmlChar *) ctxt->encoding);
8899	ctxt->encoding = encoding;
8900	}
8901	/*
8902	* UTF-8 encoding is handled natively
8903	*/
8904	else if ((encoding != NULL) &&
8905	((!xmlStrcasecmp(encoding, BAD_CAST "UTF-8")) \|\|
8906	(!xmlStrcasecmp(encoding, BAD_CAST "UTF8")))) {
8907	if (ctxt->encoding != NULL)
8908	xmlFree((xmlChar *) ctxt->encoding);
8909	ctxt->encoding = encoding;
8910	}
8911	else if (encoding != NULL) {
8912	xmlCharEncodingHandlerPtr handler;
8913
8914	if (ctxt->input->encoding != NULL)
8915	xmlFree((xmlChar *) ctxt->input->encoding);
8916	ctxt->input->encoding = encoding;
8917
8918	handler = xmlFindCharEncodingHandler((const char *) encoding);
8919	if (handler != NULL) {
8920	xmlSwitchToEncoding(ctxt, handler);
8921	} else {
8922	xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
8923	"Unsupported encoding %s\n", encoding);
8924	return(NULL);
8925	}
8926	}
8927	}
8928	return(encoding);
8929	}
8930
8931	/**
8932	* xmlParseSDDecl:
8933	* @ctxt: an XML parser context
8934	*
8935	* parse the XML standalone declaration
8936	*
8937	* [32] SDDecl ::= S 'standalone' Eq
8938	* (("'" ('yes' \| 'no') "'") \| ('"' ('yes' \| 'no')'"'))
8939	*
8940	* [ VC: Standalone Document Declaration ]
8941	* TODO The standalone document declaration must have the value "no"
8942	* if any external markup declarations contain declarations of:
8943	* - attributes with default values, if elements to which these
8944	* attributes apply appear in the document without specifications
8945	* of values for these attributes, or
8946	* - entities (other than amp, lt, gt, apos, quot), if references
8947	* to those entities appear in the document, or
8948	* - attributes with values subject to normalization, where the
8949	* attribute appears in the document with a value which will change
8950	* as a result of normalization, or
8951	* - element types with element content, if white space occurs directly
8952	* within any instance of those types.
8953	*
8954	* Returns:
8955	* 1 if standalone="yes"
8956	* 0 if standalone="no"
8957	* -2 if standalone attribute is missing or invalid
8958	* (A standalone value of -2 means that the XML declaration was found,
8959	* but no value was specified for the standalone attribute).
8960	*/
8961
8962	int
8963	xmlParseSDDecl(xmlParserCtxtPtr ctxt) {
8964	int standalone = -2;
8965
8966	SKIP_BLANKS;
8967	if (CMP10(CUR_PTR, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o', 'n', 'e')) {
8968	SKIP(10);
8969	SKIP_BLANKS;
8970	if (RAW != '=') {
8971	xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
8972	return(standalone);
8973	}
8974	NEXT;
8975	SKIP_BLANKS;
8976	if (RAW == '\''){
8977	NEXT;
8978	if ((RAW == 'n') && (NXT(1) == 'o')) {
8979	standalone = 0;
8980	SKIP(2);
8981	} else if ((RAW == 'y') && (NXT(1) == 'e') &&
8982	(NXT(2) == 's')) {
8983	standalone = 1;
8984	SKIP(3);
8985	} else {
8986	xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
8987	}
8988	if (RAW != '\'') {
8989	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
8990	} else
8991	NEXT;
8992	} else if (RAW == '"'){
8993	NEXT;
8994	if ((RAW == 'n') && (NXT(1) == 'o')) {
8995	standalone = 0;
8996	SKIP(2);
8997	} else if ((RAW == 'y') && (NXT(1) == 'e') &&
8998	(NXT(2) == 's')) {
8999	standalone = 1;
9000	SKIP(3);
9001	} else {
9002	xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
9003	}
9004	if (RAW != '"') {
9005	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9006	} else
9007	NEXT;
9008	} else {
9009	xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
9010	}
9011	}
9012	return(standalone);
9013	}
9014
9015	/**
9016	* xmlParseXMLDecl:
9017	* @ctxt: an XML parser context
9018	*
9019	* parse an XML declaration header
9020	*
9021	* [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
9022	*/
9023
9024	void
9025	xmlParseXMLDecl(xmlParserCtxtPtr ctxt) {
9026	xmlChar *version;
9027
9028	/*
9029	* This value for standalone indicates that the document has an
9030	* XML declaration but it does not have a standalone attribute.
9031	* It will be overwritten later if a standalone attribute is found.
9032	*/
9033	ctxt->input->standalone = -2;
9034
9035	/*
9036	* We know that '<?xml' is here.
9037	*/
9038	SKIP(5);
9039
9040	if (!IS_BLANK_CH(RAW)) {
9041	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9042	"Blank needed after '<?xml'\n");
9043	}
9044	SKIP_BLANKS;
9045
9046	/*
9047	* We must have the VersionInfo here.
9048	*/
9049	version = xmlParseVersionInfo(ctxt);
9050	if (version == NULL) {
9051	xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
9052	} else {
9053	if (!xmlStrEqual(version, (const xmlChar *) XML_DEFAULT_VERSION)) {
9054	/*
9055	* TODO: Blueberry should be detected here
9056	*/
9057	xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
9058	"Unsupported version '%s'\n",
9059	version, NULL);
9060	}
9061	if (ctxt->version != NULL)
9062	xmlFree((void *) ctxt->version);
9063	ctxt->version = version;
9064	}
9065
9066	/*
9067	* We may have the encoding declaration
9068	*/
9069	if (!IS_BLANK_CH(RAW)) {
9070	if ((RAW == '?') && (NXT(1) == '>')) {
9071	SKIP(2);
9072	return;
9073	}
9074	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
9075	}
9076	xmlParseEncodingDecl(ctxt);
9077	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
9078	/*
9079	* The XML REC instructs us to stop parsing right here
9080	*/
9081	return;
9082	}
9083
9084	/*
9085	* We may have the standalone status.
9086	*/
9087	if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
9088	if ((RAW == '?') && (NXT(1) == '>')) {
9089	SKIP(2);
9090	return;
9091	}
9092	xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
9093	}
9094	SKIP_BLANKS;
9095	ctxt->input->standalone = xmlParseSDDecl(ctxt);
9096
9097	SKIP_BLANKS;
9098	if ((RAW == '?') && (NXT(1) == '>')) {
9099	SKIP(2);
9100	} else if (RAW == '>') {
9101	/* Deprecated old WD ... */
9102	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
9103	NEXT;
9104	} else {
9105	xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
9106	MOVETO_ENDTAG(CUR_PTR);
9107	NEXT;
9108	}
9109	}
9110
9111	/**
9112	* xmlParseMisc:
9113	* @ctxt: an XML parser context
9114	*
9115	* parse an XML Misc* optional field.
9116	*
9117	* [27] Misc ::= Comment \| PI \| S
9118	*/
9119
9120	void
9121	xmlParseMisc(xmlParserCtxtPtr ctxt) {
9122	while (((RAW == '<') && (NXT(1) == '?')) \|\|
9123	(CMP4(CUR_PTR, '<', '!', '-', '-')) \|\|
9124	IS_BLANK_CH(CUR)) {
9125	if ((RAW == '<') && (NXT(1) == '?')) {
9126	xmlParsePI(ctxt);
9127	} else if (IS_BLANK_CH(CUR)) {
9128	NEXT;
9129	} else
9130	xmlParseComment(ctxt);
9131	}
9132	}
9133
9134	/**
9135	* xmlParseDocument:
9136	* @ctxt: an XML parser context
9137	*
9138	* parse an XML document (and build a tree if using the standard SAX
9139	* interface).
9140	*
9141	* [1] document ::= prolog element Misc*
9142	*
9143	* [22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)?
9144	*
9145	* Returns 0, -1 in case of error. the parser context is augmented
9146	* as a result of the parsing.
9147	*/
9148
9149	int
9150	xmlParseDocument(xmlParserCtxtPtr ctxt) {
9151	xmlChar start[4];
9152	xmlCharEncoding enc;
9153
9154	xmlInitParser();
9155
9156	if ((ctxt == NULL) \|\| (ctxt->input == NULL))
9157	return(-1);
9158
9159	GROW;
9160
9161	/*
9162	* SAX: detecting the level.
9163	*/
9164	xmlDetectSAX2(ctxt);
9165
9166	/*
9167	* SAX: beginning of the document processing.
9168	*/
9169	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9170	ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
9171
9172	if ((ctxt->encoding == (const xmlChar *)XML_CHAR_ENCODING_NONE) &&
9173	((ctxt->input->end - ctxt->input->cur) >= 4)) {
9174	/*
9175	* Get the 4 first bytes and decode the charset
9176	* if enc != XML_CHAR_ENCODING_NONE
9177	* plug some encoding conversion routines.
9178	*/
9179	start[0] = RAW;
9180	start[1] = NXT(1);
9181	start[2] = NXT(2);
9182	start[3] = NXT(3);
9183	enc = xmlDetectCharEncoding(&start[0], 4);
9184	if (enc != XML_CHAR_ENCODING_NONE) {
9185	xmlSwitchEncoding(ctxt, enc);
9186	}
9187	}
9188
9189
9190	if (CUR == 0) {
9191	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
9192	}
9193
9194	/*
9195	* Check for the XMLDecl in the Prolog.
9196	*/
9197	GROW;
9198	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
9199
9200	/*
9201	* Note that we will switch encoding on the fly.
9202	*/
9203	xmlParseXMLDecl(ctxt);
9204	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
9205	/*
9206	* The XML REC instructs us to stop parsing right here
9207	*/
9208	return(-1);
9209	}
9210	ctxt->standalone = ctxt->input->standalone;
9211	SKIP_BLANKS;
9212	} else {
9213	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
9214	}
9215	if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
9216	ctxt->sax->startDocument(ctxt->userData);
9217
9218	/*
9219	* The Misc part of the Prolog
9220	*/
9221	GROW;
9222	xmlParseMisc(ctxt);
9223
9224	/*
9225	* Then possibly doc type declaration(s) and more Misc
9226	* (doctypedecl Misc*)?
9227	*/
9228	GROW;
9229	if (CMP9(CUR_PTR, '<', '!', 'D', 'O', 'C', 'T', 'Y', 'P', 'E')) {
9230
9231	ctxt->inSubset = 1;
9232	xmlParseDocTypeDecl(ctxt);
9233	if (RAW == '[') {
9234	ctxt->instate = XML_PARSER_DTD;
9235	xmlParseInternalSubset(ctxt);
9236	}
9237
9238	/*
9239	* Create and update the external subset.
9240	*/
9241	ctxt->inSubset = 2;
9242	if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) &&
9243	(!ctxt->disableSAX))
9244	ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
9245	ctxt->extSubSystem, ctxt->extSubURI);
9246	ctxt->inSubset = 0;
9247
9248
9249	ctxt->instate = XML_PARSER_PROLOG;
9250	xmlParseMisc(ctxt);
9251	}
9252
9253	/*
9254	* Time to start parsing the tree itself
9255	*/
9256	GROW;
9257	if (RAW != '<') {
9258	xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
9259	"Start tag expected, '<' not found\n");
9260	} else {
9261	ctxt->instate = XML_PARSER_CONTENT;
9262	xmlParseElement(ctxt);
9263	ctxt->instate = XML_PARSER_EPILOG;
9264
9265
9266	/*
9267	* The Misc part at the end
9268	*/
9269	xmlParseMisc(ctxt);
9270
9271	if (RAW != 0) {
9272	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
9273	}
9274	ctxt->instate = XML_PARSER_EOF;
9275	}
9276
9277	/*
9278	* SAX: end of the document processing.
9279	*/
9280	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9281	ctxt->sax->endDocument(ctxt->userData);
9282
9283	/*
9284	* Remove locally kept entity definitions if the tree was not built
9285	*/
9286	if ((ctxt->myDoc != NULL) &&
9287	(xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
9288	xmlFreeDoc(ctxt->myDoc);
9289	ctxt->myDoc = NULL;
9290	}
9291
9292	if (! ctxt->wellFormed) {
9293	ctxt->valid = 0;
9294	return(-1);
9295	}
9296	return(0);
9297	}
9298
9299	/**
9300	* xmlParseExtParsedEnt:
9301	* @ctxt: an XML parser context
9302	*
9303	* parse a general parsed entity
9304	* An external general parsed entity is well-formed if it matches the
9305	* production labeled extParsedEnt.
9306	*
9307	* [78] extParsedEnt ::= TextDecl? content
9308	*
9309	* Returns 0, -1 in case of error. the parser context is augmented
9310	* as a result of the parsing.
9311	*/
9312
9313	int
9314	xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) {
9315	xmlChar start[4];
9316	xmlCharEncoding enc;
9317
9318	if ((ctxt == NULL) \|\| (ctxt->input == NULL))
9319	return(-1);
9320
9321	xmlDefaultSAXHandlerInit();
9322
9323	xmlDetectSAX2(ctxt);
9324
9325	GROW;
9326
9327	/*
9328	* SAX: beginning of the document processing.
9329	*/
9330	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9331	ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
9332
9333	/*
9334	* Get the 4 first bytes and decode the charset
9335	* if enc != XML_CHAR_ENCODING_NONE
9336	* plug some encoding conversion routines.
9337	*/
9338	if ((ctxt->input->end - ctxt->input->cur) >= 4) {
9339	start[0] = RAW;
9340	start[1] = NXT(1);
9341	start[2] = NXT(2);
9342	start[3] = NXT(3);
9343	enc = xmlDetectCharEncoding(start, 4);
9344	if (enc != XML_CHAR_ENCODING_NONE) {
9345	xmlSwitchEncoding(ctxt, enc);
9346	}
9347	}
9348
9349
9350	if (CUR == 0) {
9351	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
9352	}
9353
9354	/*
9355	* Check for the XMLDecl in the Prolog.
9356	*/
9357	GROW;
9358	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
9359
9360	/*
9361	* Note that we will switch encoding on the fly.
9362	*/
9363	xmlParseXMLDecl(ctxt);
9364	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
9365	/*
9366	* The XML REC instructs us to stop parsing right here
9367	*/
9368	return(-1);
9369	}
9370	SKIP_BLANKS;
9371	} else {
9372	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
9373	}
9374	if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
9375	ctxt->sax->startDocument(ctxt->userData);
9376
9377	/*
9378	* Doing validity checking on chunk doesn't make sense
9379	*/
9380	ctxt->instate = XML_PARSER_CONTENT;
9381	ctxt->validate = 0;
9382	ctxt->loadsubset = 0;
9383	ctxt->depth = 0;
9384
9385	xmlParseContent(ctxt);
9386
9387	if ((RAW == '<') && (NXT(1) == '/')) {
9388	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
9389	} else if (RAW != 0) {
9390	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
9391	}
9392
9393	/*
9394	* SAX: end of the document processing.
9395	*/
9396	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9397	ctxt->sax->endDocument(ctxt->userData);
9398
9399	if (! ctxt->wellFormed) return(-1);
9400	return(0);
9401	}
9402
9403	#ifdef LIBXML_PUSH_ENABLED
9404	/************************************************************************
9405	* *
9406	* Progressive parsing interfaces *
9407	* *
9408	************************************************************************/
9409
9410	/**
9411	* xmlParseLookupSequence:
9412	* @ctxt: an XML parser context
9413	* @first: the first char to lookup
9414	* @next: the next char to lookup or zero
9415	* @third: the next char to lookup or zero
9416	*
9417	* Try to find if a sequence (first, next, third) or just (first next) or
9418	* (first) is available in the input stream.
9419	* This function has a side effect of (possibly) incrementing ctxt->checkIndex
9420	* to avoid rescanning sequences of bytes, it DOES change the state of the
9421	* parser, do not use liberally.
9422	*
9423	* Returns the index to the current parsing point if the full sequence
9424	* is available, -1 otherwise.
9425	*/
9426	static int
9427	xmlParseLookupSequence(xmlParserCtxtPtr ctxt, xmlChar first,
9428	xmlChar next, xmlChar third) {
9429	int base, len;
9430	xmlParserInputPtr in;
9431	const xmlChar *buf;
9432
9433	in = ctxt->input;
9434	if (in == NULL) return(-1);
9435	base = in->cur - in->base;
9436	if (base < 0) return(-1);
9437	if (ctxt->checkIndex > base)
9438	base = ctxt->checkIndex;
9439	if (in->buf == NULL) {
9440	buf = in->base;
9441	len = in->length;
9442	} else {
9443	buf = in->buf->buffer->content;
9444	len = in->buf->buffer->use;
9445	}
9446	/* take into account the sequence length */
9447	if (third) len -= 2;
9448	else if (next) len --;
9449	for (;base < len;base++) {
9450	if (buf[base] == first) {
9451	if (third != 0) {
9452	if ((buf[base + 1] != next) \|\|
9453	(buf[base + 2] != third)) continue;
9454	} else if (next != 0) {
9455	if (buf[base + 1] != next) continue;
9456	}
9457	ctxt->checkIndex = 0;
9458	#ifdef DEBUG_PUSH
9459	if (next == 0)
9460	xmlGenericError(xmlGenericErrorContext,
9461	"PP: lookup '%c' found at %d\n",
9462	first, base);
9463	else if (third == 0)
9464	xmlGenericError(xmlGenericErrorContext,
9465	"PP: lookup '%c%c' found at %d\n",
9466	first, next, base);
9467	else
9468	xmlGenericError(xmlGenericErrorContext,
9469	"PP: lookup '%c%c%c' found at %d\n",
9470	first, next, third, base);
9471	#endif
9472	return(base - (in->cur - in->base));
9473	}
9474	}
9475	ctxt->checkIndex = base;
9476	#ifdef DEBUG_PUSH
9477	if (next == 0)
9478	xmlGenericError(xmlGenericErrorContext,
9479	"PP: lookup '%c' failed\n", first);
9480	else if (third == 0)
9481	xmlGenericError(xmlGenericErrorContext,
9482	"PP: lookup '%c%c' failed\n", first, next);
9483	else
9484	xmlGenericError(xmlGenericErrorContext,
9485	"PP: lookup '%c%c%c' failed\n", first, next, third);
9486	#endif
9487	return(-1);
9488	}
9489
9490	/**
9491	* xmlParseGetLasts:
9492	* @ctxt: an XML parser context
9493	* @lastlt: pointer to store the last '<' from the input
9494	* @lastgt: pointer to store the last '>' from the input
9495	*
9496	* Lookup the last < and > in the current chunk
9497	*/
9498	static void
9499	xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt,
9500	const xmlChar **lastgt) {
9501	const xmlChar *tmp;
9502
9503	if ((ctxt == NULL) \|\| (lastlt == NULL) \|\| (lastgt == NULL)) {
9504	xmlGenericError(xmlGenericErrorContext,
9505	"Internal error: xmlParseGetLasts\n");
9506	return;
9507	}
9508	if ((ctxt->progressive != 0) && (ctxt->inputNr == 1)) {
9509	tmp = ctxt->input->end;
9510	tmp--;
9511	while ((tmp >= ctxt->input->base) && (*tmp != '<')) tmp--;
9512	if (tmp < ctxt->input->base) {
9513	*lastlt = NULL;
9514	*lastgt = NULL;
9515	} else {
9516	*lastlt = tmp;
9517	tmp++;
9518	while ((tmp < ctxt->input->end) && (*tmp != '>')) {
9519	if (*tmp == '\'') {
9520	tmp++;
9521	while ((tmp < ctxt->input->end) && (*tmp != '\'')) tmp++;
9522	if (tmp < ctxt->input->end) tmp++;
9523	} else if (*tmp == '"') {
9524	tmp++;
9525	while ((tmp < ctxt->input->end) && (*tmp != '"')) tmp++;
9526	if (tmp < ctxt->input->end) tmp++;
9527	} else
9528	tmp++;
9529	}
9530	if (tmp < ctxt->input->end)
9531	*lastgt = tmp;
9532	else {
9533	tmp = *lastlt;
9534	tmp--;
9535	while ((tmp >= ctxt->input->base) && (*tmp != '>')) tmp--;
9536	if (tmp >= ctxt->input->base)
9537	*lastgt = tmp;
9538	else
9539	*lastgt = NULL;
9540	}
9541	}
9542	} else {
9543	*lastlt = NULL;
9544	*lastgt = NULL;
9545	}
9546	}
9547	/**
9548	* xmlCheckCdataPush:
9549	* @cur: pointer to the bock of characters
9550	* @len: length of the block in bytes
9551	*
9552	* Check that the block of characters is okay as SCdata content [20]
9553	*
9554	* Returns the number of bytes to pass if okay, a negative index where an
9555	* UTF-8 error occured otherwise
9556	*/
9557	static int
9558	xmlCheckCdataPush(const xmlChar *utf, int len) {
9559	int ix;
9560	unsigned char c;
9561	int codepoint;
9562
9563	if ((utf == NULL) \|\| (len <= 0))
9564	return(0);
9565
9566	for (ix = 0; ix < len;) { /* string is 0-terminated */
9567	c = utf[ix];
9568	if ((c & 0x80) == 0x00) { /* 1-byte code, starts with 10 */
9569	if (c >= 0x20)
9570	ix++;
9571	else if ((c == 0xA) \|\| (c == 0xD) \|\| (c == 0x9))
9572	ix++;
9573	else
9574	return(-ix);
9575	} else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */
9576	if (ix + 2 > len) return(ix);
9577	if ((utf[ix+1] & 0xc0 ) != 0x80)
9578	return(-ix);
9579	codepoint = (utf[ix] & 0x1f) << 6;
9580	codepoint \|= utf[ix+1] & 0x3f;
9581	if (!xmlIsCharQ(codepoint))
9582	return(-ix);
9583	ix += 2;
9584	} else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */
9585	if (ix + 3 > len) return(ix);
9586	if (((utf[ix+1] & 0xc0) != 0x80) \|\|
9587	((utf[ix+2] & 0xc0) != 0x80))
9588	return(-ix);
9589	codepoint = (utf[ix] & 0xf) << 12;
9590	codepoint \|= (utf[ix+1] & 0x3f) << 6;
9591	codepoint \|= utf[ix+2] & 0x3f;
9592	if (!xmlIsCharQ(codepoint))
9593	return(-ix);
9594	ix += 3;
9595	} else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */
9596	if (ix + 4 > len) return(ix);
9597	if (((utf[ix+1] & 0xc0) != 0x80) \|\|
9598	((utf[ix+2] & 0xc0) != 0x80) \|\|
9599	((utf[ix+3] & 0xc0) != 0x80))
9600	return(-ix);
9601	codepoint = (utf[ix] & 0x7) << 18;
9602	codepoint \|= (utf[ix+1] & 0x3f) << 12;
9603	codepoint \|= (utf[ix+2] & 0x3f) << 6;
9604	codepoint \|= utf[ix+3] & 0x3f;
9605	if (!xmlIsCharQ(codepoint))
9606	return(-ix);
9607	ix += 4;
9608	} else /* unknown encoding */
9609	return(-ix);
9610	}
9611	return(ix);
9612	}
9613
9614	/**
9615	* xmlParseTryOrFinish:
9616	* @ctxt: an XML parser context
9617	* @terminate: last chunk indicator
9618	*
9619	* Try to progress on parsing
9620	*
9621	* Returns zero if no parsing was possible
9622	*/
9623	static int
9624	xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) {
9625	int ret = 0;
9626	int avail, tlen;
9627	xmlChar cur, next;
9628	const xmlChar lastlt, lastgt;
9629
9630	if (ctxt->input == NULL)
9631	return(0);
9632
9633	#ifdef DEBUG_PUSH
9634	switch (ctxt->instate) {
9635	case XML_PARSER_EOF:
9636	xmlGenericError(xmlGenericErrorContext,
9637	"PP: try EOF\n"); break;
9638	case XML_PARSER_START:
9639	xmlGenericError(xmlGenericErrorContext,
9640	"PP: try START\n"); break;
9641	case XML_PARSER_MISC:
9642	xmlGenericError(xmlGenericErrorContext,
9643	"PP: try MISC\n");break;
9644	case XML_PARSER_COMMENT:
9645	xmlGenericError(xmlGenericErrorContext,
9646	"PP: try COMMENT\n");break;
9647	case XML_PARSER_PROLOG:
9648	xmlGenericError(xmlGenericErrorContext,
9649	"PP: try PROLOG\n");break;
9650	case XML_PARSER_START_TAG:
9651	xmlGenericError(xmlGenericErrorContext,
9652	"PP: try START_TAG\n");break;
9653	case XML_PARSER_CONTENT:
9654	xmlGenericError(xmlGenericErrorContext,
9655	"PP: try CONTENT\n");break;
9656	case XML_PARSER_CDATA_SECTION:
9657	xmlGenericError(xmlGenericErrorContext,
9658	"PP: try CDATA_SECTION\n");break;
9659	case XML_PARSER_END_TAG:
9660	xmlGenericError(xmlGenericErrorContext,
9661	"PP: try END_TAG\n");break;
9662	case XML_PARSER_ENTITY_DECL:
9663	xmlGenericError(xmlGenericErrorContext,
9664	"PP: try ENTITY_DECL\n");break;
9665	case XML_PARSER_ENTITY_VALUE:
9666	xmlGenericError(xmlGenericErrorContext,
9667	"PP: try ENTITY_VALUE\n");break;
9668	case XML_PARSER_ATTRIBUTE_VALUE:
9669	xmlGenericError(xmlGenericErrorContext,
9670	"PP: try ATTRIBUTE_VALUE\n");break;
9671	case XML_PARSER_DTD:
9672	xmlGenericError(xmlGenericErrorContext,
9673	"PP: try DTD\n");break;
9674	case XML_PARSER_EPILOG:
9675	xmlGenericError(xmlGenericErrorContext,
9676	"PP: try EPILOG\n");break;
9677	case XML_PARSER_PI:
9678	xmlGenericError(xmlGenericErrorContext,
9679	"PP: try PI\n");break;
9680	case XML_PARSER_IGNORE:
9681	xmlGenericError(xmlGenericErrorContext,
9682	"PP: try IGNORE\n");break;
9683	}
9684	#endif
9685
9686	if ((ctxt->input != NULL) &&
9687	(ctxt->input->cur - ctxt->input->base > 4096)) {
9688	xmlSHRINK(ctxt);
9689	ctxt->checkIndex = 0;
9690	}
9691	xmlParseGetLasts(ctxt, &lastlt, &lastgt);
9692
9693	while (1) {
9694	if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
9695	return(0);
9696
9697
9698	/*
9699	* Pop-up of finished entities.
9700	*/
9701	while ((RAW == 0) && (ctxt->inputNr > 1))
9702	xmlPopInput(ctxt);
9703
9704	if (ctxt->input == NULL) break;
9705	if (ctxt->input->buf == NULL)
9706	avail = ctxt->input->length -
9707	(ctxt->input->cur - ctxt->input->base);
9708	else {
9709	/*
9710	* If we are operating on converted input, try to flush
9711	* remainng chars to avoid them stalling in the non-converted
9712	* buffer.
9713	*/
9714	if ((ctxt->input->buf->raw != NULL) &&
9715	(ctxt->input->buf->raw->use > 0)) {
9716	int base = ctxt->input->base -
9717	ctxt->input->buf->buffer->content;
9718	int current = ctxt->input->cur - ctxt->input->base;
9719
9720	xmlParserInputBufferPush(ctxt->input->buf, 0, "");
9721	ctxt->input->base = ctxt->input->buf->buffer->content + base;
9722	ctxt->input->cur = ctxt->input->base + current;
9723	ctxt->input->end =
9724	&ctxt->input->buf->buffer->content[
9725	ctxt->input->buf->buffer->use];
9726	}
9727	avail = ctxt->input->buf->buffer->use -
9728	(ctxt->input->cur - ctxt->input->base);
9729	}
9730	if (avail < 1)
9731	goto done;
9732	switch (ctxt->instate) {
9733	case XML_PARSER_EOF:
9734	/*
9735	* Document parsing is done !
9736	*/
9737	goto done;
9738	case XML_PARSER_START:
9739	if (ctxt->charset == XML_CHAR_ENCODING_NONE) {
9740	xmlChar start[4];
9741	xmlCharEncoding enc;
9742
9743	/*
9744	* Very first chars read from the document flow.
9745	*/
9746	if (avail < 4)
9747	goto done;
9748
9749	/*
9750	* Get the 4 first bytes and decode the charset
9751	* if enc != XML_CHAR_ENCODING_NONE
9752	* plug some encoding conversion routines,
9753	* else xmlSwitchEncoding will set to (default)
9754	* UTF8.
9755	*/
9756	start[0] = RAW;
9757	start[1] = NXT(1);
9758	start[2] = NXT(2);
9759	start[3] = NXT(3);
9760	enc = xmlDetectCharEncoding(start, 4);
9761	xmlSwitchEncoding(ctxt, enc);
9762	break;
9763	}
9764
9765	if (avail < 2)
9766	goto done;
9767	cur = ctxt->input->cur[0];
9768	next = ctxt->input->cur[1];
9769	if (cur == 0) {
9770	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9771	ctxt->sax->setDocumentLocator(ctxt->userData,
9772	&xmlDefaultSAXLocator);
9773	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
9774	ctxt->instate = XML_PARSER_EOF;
9775	#ifdef DEBUG_PUSH
9776	xmlGenericError(xmlGenericErrorContext,
9777	"PP: entering EOF\n");
9778	#endif
9779	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9780	ctxt->sax->endDocument(ctxt->userData);
9781	goto done;
9782	}
9783	if ((cur == '<') && (next == '?')) {
9784	/* PI or XML decl */
9785	if (avail < 5) return(ret);
9786	if ((!terminate) &&
9787	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
9788	return(ret);
9789	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9790	ctxt->sax->setDocumentLocator(ctxt->userData,
9791	&xmlDefaultSAXLocator);
9792	if ((ctxt->input->cur[2] == 'x') &&
9793	(ctxt->input->cur[3] == 'm') &&
9794	(ctxt->input->cur[4] == 'l') &&
9795	(IS_BLANK_CH(ctxt->input->cur[5]))) {
9796	ret += 5;
9797	#ifdef DEBUG_PUSH
9798	xmlGenericError(xmlGenericErrorContext,
9799	"PP: Parsing XML Decl\n");
9800	#endif
9801	xmlParseXMLDecl(ctxt);
9802	if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
9803	/*
9804	* The XML REC instructs us to stop parsing right
9805	* here
9806	*/
9807	ctxt->instate = XML_PARSER_EOF;
9808	return(0);
9809	}
9810	ctxt->standalone = ctxt->input->standalone;
9811	if ((ctxt->encoding == NULL) &&
9812	(ctxt->input->encoding != NULL))
9813	ctxt->encoding = xmlStrdup(ctxt->input->encoding);
9814	if ((ctxt->sax) && (ctxt->sax->startDocument) &&
9815	(!ctxt->disableSAX))
9816	ctxt->sax->startDocument(ctxt->userData);
9817	ctxt->instate = XML_PARSER_MISC;
9818	#ifdef DEBUG_PUSH
9819	xmlGenericError(xmlGenericErrorContext,
9820	"PP: entering MISC\n");
9821	#endif
9822	} else {
9823	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
9824	if ((ctxt->sax) && (ctxt->sax->startDocument) &&
9825	(!ctxt->disableSAX))
9826	ctxt->sax->startDocument(ctxt->userData);
9827	ctxt->instate = XML_PARSER_MISC;
9828	#ifdef DEBUG_PUSH
9829	xmlGenericError(xmlGenericErrorContext,
9830	"PP: entering MISC\n");
9831	#endif
9832	}
9833	} else {
9834	if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
9835	ctxt->sax->setDocumentLocator(ctxt->userData,
9836	&xmlDefaultSAXLocator);
9837	ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
9838	if (ctxt->version == NULL) {
9839	xmlErrMemory(ctxt, NULL);
9840	break;
9841	}
9842	if ((ctxt->sax) && (ctxt->sax->startDocument) &&
9843	(!ctxt->disableSAX))
9844	ctxt->sax->startDocument(ctxt->userData);
9845	ctxt->instate = XML_PARSER_MISC;
9846	#ifdef DEBUG_PUSH
9847	xmlGenericError(xmlGenericErrorContext,
9848	"PP: entering MISC\n");
9849	#endif
9850	}
9851	break;
9852	case XML_PARSER_START_TAG: {
9853	const xmlChar *name;
9854	const xmlChar *prefix;
9855	const xmlChar *URI;
9856	int nsNr = ctxt->nsNr;
9857
9858	if ((avail < 2) && (ctxt->inputNr == 1))
9859	goto done;
9860	cur = ctxt->input->cur[0];
9861	if (cur != '<') {
9862	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
9863	ctxt->instate = XML_PARSER_EOF;
9864	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9865	ctxt->sax->endDocument(ctxt->userData);
9866	goto done;
9867	}
9868	if (!terminate) {
9869	if (ctxt->progressive) {
9870	/* > can be found unescaped in attribute values */
9871	if ((lastgt == NULL) \|\| (ctxt->input->cur >= lastgt))
9872	goto done;
9873	} else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
9874	goto done;
9875	}
9876	}
9877	if (ctxt->spaceNr == 0)
9878	spacePush(ctxt, -1);
9879	else if (*ctxt->space == -2)
9880	spacePush(ctxt, -1);
9881	else
9882	spacePush(ctxt, *ctxt->space);
9883	#ifdef LIBXML_SAX1_ENABLED
9884	if (ctxt->sax2)
9885	#endif /* LIBXML_SAX1_ENABLED */
9886	name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
9887	#ifdef LIBXML_SAX1_ENABLED
9888	else
9889	name = xmlParseStartTag(ctxt);
9890	#endif /* LIBXML_SAX1_ENABLED */
9891	if (name == NULL) {
9892	spacePop(ctxt);
9893	ctxt->instate = XML_PARSER_EOF;
9894	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
9895	ctxt->sax->endDocument(ctxt->userData);
9896	goto done;
9897	}
9898	#ifdef LIBXML_VALID_ENABLED
9899	/*
9900	* [ VC: Root Element Type ]
9901	* The Name in the document type declaration must match
9902	* the element type of the root element.
9903	*/
9904	if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
9905	ctxt->node && (ctxt->node == ctxt->myDoc->children))
9906	ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
9907	#endif /* LIBXML_VALID_ENABLED */
9908
9909	/*
9910	* Check for an Empty Element.
9911	*/
9912	if ((RAW == '/') && (NXT(1) == '>')) {
9913	SKIP(2);
9914
9915	if (ctxt->sax2) {
9916	if ((ctxt->sax != NULL) &&
9917	(ctxt->sax->endElementNs != NULL) &&
9918	(!ctxt->disableSAX))
9919	ctxt->sax->endElementNs(ctxt->userData, name,
9920	prefix, URI);
9921	if (ctxt->nsNr - nsNr > 0)
9922	nsPop(ctxt, ctxt->nsNr - nsNr);
9923	#ifdef LIBXML_SAX1_ENABLED
9924	} else {
9925	if ((ctxt->sax != NULL) &&
9926	(ctxt->sax->endElement != NULL) &&
9927	(!ctxt->disableSAX))
9928	ctxt->sax->endElement(ctxt->userData, name);
9929	#endif /* LIBXML_SAX1_ENABLED */
9930	}
9931	spacePop(ctxt);
9932	if (ctxt->nameNr == 0) {
9933	ctxt->instate = XML_PARSER_EPILOG;
9934	} else {
9935	ctxt->instate = XML_PARSER_CONTENT;
9936	}
9937	break;
9938	}
9939	if (RAW == '>') {
9940	NEXT;
9941	} else {
9942	xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED,
9943	"Couldn't find end of Start Tag %s\n",
9944	name);
9945	nodePop(ctxt);
9946	spacePop(ctxt);
9947	}
9948	if (ctxt->sax2)
9949	nameNsPush(ctxt, name, prefix, URI, ctxt->nsNr - nsNr);
9950	#ifdef LIBXML_SAX1_ENABLED
9951	else
9952	namePush(ctxt, name);
9953	#endif /* LIBXML_SAX1_ENABLED */
9954
9955	ctxt->instate = XML_PARSER_CONTENT;
9956	break;
9957	}
9958	case XML_PARSER_CONTENT: {
9959	const xmlChar *test;
9960	unsigned int cons;
9961	if ((avail < 2) && (ctxt->inputNr == 1))
9962	goto done;
9963	cur = ctxt->input->cur[0];
9964	next = ctxt->input->cur[1];
9965
9966	test = CUR_PTR;
9967	cons = ctxt->input->consumed;
9968	if ((cur == '<') && (next == '/')) {
9969	ctxt->instate = XML_PARSER_END_TAG;
9970	break;
9971	} else if ((cur == '<') && (next == '?')) {
9972	if ((!terminate) &&
9973	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
9974	goto done;
9975	xmlParsePI(ctxt);
9976	} else if ((cur == '<') && (next != '!')) {
9977	ctxt->instate = XML_PARSER_START_TAG;
9978	break;
9979	} else if ((cur == '<') && (next == '!') &&
9980	(ctxt->input->cur[2] == '-') &&
9981	(ctxt->input->cur[3] == '-')) {
9982	int term;
9983
9984	if (avail < 4)
9985	goto done;
9986	ctxt->input->cur += 4;
9987	term = xmlParseLookupSequence(ctxt, '-', '-', '>');
9988	ctxt->input->cur -= 4;
9989	if ((!terminate) && (term < 0))
9990	goto done;
9991	xmlParseComment(ctxt);
9992	ctxt->instate = XML_PARSER_CONTENT;
9993	} else if ((cur == '<') && (ctxt->input->cur[1] == '!') &&
9994	(ctxt->input->cur[2] == '[') &&
9995	(ctxt->input->cur[3] == 'C') &&
9996	(ctxt->input->cur[4] == 'D') &&
9997	(ctxt->input->cur[5] == 'A') &&
9998	(ctxt->input->cur[6] == 'T') &&
9999	(ctxt->input->cur[7] == 'A') &&
10000	(ctxt->input->cur[8] == '[')) {
10001	SKIP(9);
10002	ctxt->instate = XML_PARSER_CDATA_SECTION;
10003	break;
10004	} else if ((cur == '<') && (next == '!') &&
10005	(avail < 9)) {
10006	goto done;
10007	} else if (cur == '&') {
10008	if ((!terminate) &&
10009	(xmlParseLookupSequence(ctxt, ';', 0, 0) < 0))
10010	goto done;
10011	xmlParseReference(ctxt);
10012	} else {
10013	/* TODO Avoid the extra copy, handle directly !!! */
10014	/*
10015	* Goal of the following test is:
10016	* - minimize calls to the SAX 'character' callback
10017	* when they are mergeable
10018	* - handle an problem for isBlank when we only parse
10019	* a sequence of blank chars and the next one is
10020	* not available to check against '<' presence.
10021	* - tries to homogenize the differences in SAX
10022	* callbacks between the push and pull versions
10023	* of the parser.
10024	*/
10025	if ((ctxt->inputNr == 1) &&
10026	(avail < XML_PARSER_BIG_BUFFER_SIZE)) {
10027	if (!terminate) {
10028	if (ctxt->progressive) {
10029	if ((lastlt == NULL) \|\|
10030	(ctxt->input->cur > lastlt))
10031	goto done;
10032	} else if (xmlParseLookupSequence(ctxt,
10033	'<', 0, 0) < 0) {
10034	goto done;
10035	}
10036	}
10037	}
10038	ctxt->checkIndex = 0;
10039	xmlParseCharData(ctxt, 0);
10040	}
10041	/*
10042	* Pop-up of finished entities.
10043	*/
10044	while ((RAW == 0) && (ctxt->inputNr > 1))
10045	xmlPopInput(ctxt);
10046	if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
10047	xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
10048	"detected an error in element content\n");
10049	ctxt->instate = XML_PARSER_EOF;
10050	break;
10051	}
10052	break;
10053	}
10054	case XML_PARSER_END_TAG:
10055	if (avail < 2)
10056	goto done;
10057	if (!terminate) {
10058	if (ctxt->progressive) {
10059	/* > can be found unescaped in attribute values */
10060	if ((lastgt == NULL) \|\| (ctxt->input->cur >= lastgt))
10061	goto done;
10062	} else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
10063	goto done;
10064	}
10065	}
10066	if (ctxt->sax2) {
10067	xmlParseEndTag2(ctxt,
10068	(void ) ctxt->pushTab[ctxt->nameNr 3 - 3],
10069	(void ) ctxt->pushTab[ctxt->nameNr 3 - 2], 0,
10070	(int) (long) ctxt->pushTab[ctxt->nameNr * 3 - 1], 0);
10071	nameNsPop(ctxt);
10072	}
10073	#ifdef LIBXML_SAX1_ENABLED
10074	else
10075	xmlParseEndTag1(ctxt, 0);
10076	#endif /* LIBXML_SAX1_ENABLED */
10077	if (ctxt->nameNr == 0) {
10078	ctxt->instate = XML_PARSER_EPILOG;
10079	} else {
10080	ctxt->instate = XML_PARSER_CONTENT;
10081	}
10082	break;
10083	case XML_PARSER_CDATA_SECTION: {
10084	/*
10085	* The Push mode need to have the SAX callback for
10086	* cdataBlock merge back contiguous callbacks.
10087	*/
10088	int base;
10089
10090	base = xmlParseLookupSequence(ctxt, ']', ']', '>');
10091	if (base < 0) {
10092	if (avail >= XML_PARSER_BIG_BUFFER_SIZE + 2) {
10093	int tmp;
10094
10095	tmp = xmlCheckCdataPush(ctxt->input->cur,
10096	XML_PARSER_BIG_BUFFER_SIZE);
10097	if (tmp < 0) {
10098	tmp = -tmp;
10099	ctxt->input->cur += tmp;
10100	goto encoding_error;
10101	}
10102	if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
10103	if (ctxt->sax->cdataBlock != NULL)
10104	ctxt->sax->cdataBlock(ctxt->userData,
10105	ctxt->input->cur, tmp);
10106	else if (ctxt->sax->characters != NULL)
10107	ctxt->sax->characters(ctxt->userData,
10108	ctxt->input->cur, tmp);
10109	}
10110	SKIPL(tmp);
10111	ctxt->checkIndex = 0;
10112	}
10113	goto done;
10114	} else {
10115	int tmp;
10116
10117	tmp = xmlCheckCdataPush(ctxt->input->cur, base);
10118	if ((tmp < 0) \|\| (tmp != base)) {
10119	tmp = -tmp;
10120	ctxt->input->cur += tmp;
10121	goto encoding_error;
10122	}
10123	if ((ctxt->sax != NULL) && (base > 0) &&
10124	(!ctxt->disableSAX)) {
10125	if (ctxt->sax->cdataBlock != NULL)
10126	ctxt->sax->cdataBlock(ctxt->userData,
10127	ctxt->input->cur, base);
10128	else if (ctxt->sax->characters != NULL)
10129	ctxt->sax->characters(ctxt->userData,
10130	ctxt->input->cur, base);
10131	}
10132	SKIPL(base + 3);
10133	ctxt->checkIndex = 0;
10134	ctxt->instate = XML_PARSER_CONTENT;
10135	#ifdef DEBUG_PUSH
10136	xmlGenericError(xmlGenericErrorContext,
10137	"PP: entering CONTENT\n");
10138	#endif
10139	}
10140	break;
10141	}
10142	case XML_PARSER_MISC:
10143	SKIP_BLANKS;
10144	if (ctxt->input->buf == NULL)
10145	avail = ctxt->input->length -
10146	(ctxt->input->cur - ctxt->input->base);
10147	else
10148	avail = ctxt->input->buf->buffer->use -
10149	(ctxt->input->cur - ctxt->input->base);
10150	if (avail < 2)
10151	goto done;
10152	cur = ctxt->input->cur[0];
10153	next = ctxt->input->cur[1];
10154	if ((cur == '<') && (next == '?')) {
10155	if ((!terminate) &&
10156	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10157	goto done;
10158	#ifdef DEBUG_PUSH
10159	xmlGenericError(xmlGenericErrorContext,
10160	"PP: Parsing PI\n");
10161	#endif
10162	xmlParsePI(ctxt);
10163	ctxt->checkIndex = 0;
10164	} else if ((cur == '<') && (next == '!') &&
10165	(ctxt->input->cur[2] == '-') &&
10166	(ctxt->input->cur[3] == '-')) {
10167	if ((!terminate) &&
10168	(xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
10169	goto done;
10170	#ifdef DEBUG_PUSH
10171	xmlGenericError(xmlGenericErrorContext,
10172	"PP: Parsing Comment\n");
10173	#endif
10174	xmlParseComment(ctxt);
10175	ctxt->instate = XML_PARSER_MISC;
10176	ctxt->checkIndex = 0;
10177	} else if ((cur == '<') && (next == '!') &&
10178	(ctxt->input->cur[2] == 'D') &&
10179	(ctxt->input->cur[3] == 'O') &&
10180	(ctxt->input->cur[4] == 'C') &&
10181	(ctxt->input->cur[5] == 'T') &&
10182	(ctxt->input->cur[6] == 'Y') &&
10183	(ctxt->input->cur[7] == 'P') &&
10184	(ctxt->input->cur[8] == 'E')) {
10185	if ((!terminate) &&
10186	(xmlParseLookupSequence(ctxt, '>', 0, 0) < 0))
10187	goto done;
10188	#ifdef DEBUG_PUSH
10189	xmlGenericError(xmlGenericErrorContext,
10190	"PP: Parsing internal subset\n");
10191	#endif
10192	ctxt->inSubset = 1;
10193	xmlParseDocTypeDecl(ctxt);
10194	if (RAW == '[') {
10195	ctxt->instate = XML_PARSER_DTD;
10196	#ifdef DEBUG_PUSH
10197	xmlGenericError(xmlGenericErrorContext,
10198	"PP: entering DTD\n");
10199	#endif
10200	} else {
10201	/*
10202	* Create and update the external subset.
10203	*/
10204	ctxt->inSubset = 2;
10205	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
10206	(ctxt->sax->externalSubset != NULL))
10207	ctxt->sax->externalSubset(ctxt->userData,
10208	ctxt->intSubName, ctxt->extSubSystem,
10209	ctxt->extSubURI);
10210	ctxt->inSubset = 0;
10211	ctxt->instate = XML_PARSER_PROLOG;
10212	#ifdef DEBUG_PUSH
10213	xmlGenericError(xmlGenericErrorContext,
10214	"PP: entering PROLOG\n");
10215	#endif
10216	}
10217	} else if ((cur == '<') && (next == '!') &&
10218	(avail < 9)) {
10219	goto done;
10220	} else {
10221	ctxt->instate = XML_PARSER_START_TAG;
10222	ctxt->progressive = 1;
10223	xmlParseGetLasts(ctxt, &lastlt, &lastgt);
10224	#ifdef DEBUG_PUSH
10225	xmlGenericError(xmlGenericErrorContext,
10226	"PP: entering START_TAG\n");
10227	#endif
10228	}
10229	break;
10230	case XML_PARSER_PROLOG:
10231	SKIP_BLANKS;
10232	if (ctxt->input->buf == NULL)
10233	avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
10234	else
10235	avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
10236	if (avail < 2)
10237	goto done;
10238	cur = ctxt->input->cur[0];
10239	next = ctxt->input->cur[1];
10240	if ((cur == '<') && (next == '?')) {
10241	if ((!terminate) &&
10242	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10243	goto done;
10244	#ifdef DEBUG_PUSH
10245	xmlGenericError(xmlGenericErrorContext,
10246	"PP: Parsing PI\n");
10247	#endif
10248	xmlParsePI(ctxt);
10249	} else if ((cur == '<') && (next == '!') &&
10250	(ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
10251	if ((!terminate) &&
10252	(xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
10253	goto done;
10254	#ifdef DEBUG_PUSH
10255	xmlGenericError(xmlGenericErrorContext,
10256	"PP: Parsing Comment\n");
10257	#endif
10258	xmlParseComment(ctxt);
10259	ctxt->instate = XML_PARSER_PROLOG;
10260	} else if ((cur == '<') && (next == '!') &&
10261	(avail < 4)) {
10262	goto done;
10263	} else {
10264	ctxt->instate = XML_PARSER_START_TAG;
10265	if (ctxt->progressive == 0)
10266	ctxt->progressive = 1;
10267	xmlParseGetLasts(ctxt, &lastlt, &lastgt);
10268	#ifdef DEBUG_PUSH
10269	xmlGenericError(xmlGenericErrorContext,
10270	"PP: entering START_TAG\n");
10271	#endif
10272	}
10273	break;
10274	case XML_PARSER_EPILOG:
10275	SKIP_BLANKS;
10276	if (ctxt->input->buf == NULL)
10277	avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
10278	else
10279	avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
10280	if (avail < 2)
10281	goto done;
10282	cur = ctxt->input->cur[0];
10283	next = ctxt->input->cur[1];
10284	if ((cur == '<') && (next == '?')) {
10285	if ((!terminate) &&
10286	(xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10287	goto done;
10288	#ifdef DEBUG_PUSH
10289	xmlGenericError(xmlGenericErrorContext,
10290	"PP: Parsing PI\n");
10291	#endif
10292	xmlParsePI(ctxt);
10293	ctxt->instate = XML_PARSER_EPILOG;
10294	} else if ((cur == '<') && (next == '!') &&
10295	(ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
10296	if ((!terminate) &&
10297	(xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
10298	goto done;
10299	#ifdef DEBUG_PUSH
10300	xmlGenericError(xmlGenericErrorContext,
10301	"PP: Parsing Comment\n");
10302	#endif
10303	xmlParseComment(ctxt);
10304	ctxt->instate = XML_PARSER_EPILOG;
10305	} else if ((cur == '<') && (next == '!') &&
10306	(avail < 4)) {
10307	goto done;
10308	} else {
10309	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10310	ctxt->instate = XML_PARSER_EOF;
10311	#ifdef DEBUG_PUSH
10312	xmlGenericError(xmlGenericErrorContext,
10313	"PP: entering EOF\n");
10314	#endif
10315	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10316	ctxt->sax->endDocument(ctxt->userData);
10317	goto done;
10318	}
10319	break;
10320	case XML_PARSER_DTD: {
10321	/*
10322	* Sorry but progressive parsing of the internal subset
10323	* is not expected to be supported. We first check that
10324	* the full content of the internal subset is available and
10325	* the parsing is launched only at that point.
10326	* Internal subset ends up with "']' S? '>'" in an unescaped
10327	* section and not in a ']]>' sequence which are conditional
10328	* sections (whoever argued to keep that crap in XML deserve
10329	* a place in hell !).
10330	*/
10331	int base, i;
10332	xmlChar *buf;
10333	xmlChar quote = 0;
10334
10335	base = ctxt->input->cur - ctxt->input->base;
10336	if (base < 0) return(0);
10337	if (ctxt->checkIndex > base)
10338	base = ctxt->checkIndex;
10339	buf = ctxt->input->buf->buffer->content;
10340	for (;(unsigned int) base < ctxt->input->buf->buffer->use;
10341	base++) {
10342	if (quote != 0) {
10343	if (buf[base] == quote)
10344	quote = 0;
10345	continue;
10346	}
10347	if ((quote == 0) && (buf[base] == '<')) {
10348	int found = 0;
10349	/* special handling of comments */
10350	if (((unsigned int) base + 4 <
10351	ctxt->input->buf->buffer->use) &&
10352	(buf[base + 1] == '!') &&
10353	(buf[base + 2] == '-') &&
10354	(buf[base + 3] == '-')) {
10355	for (;(unsigned int) base + 3 <
10356	ctxt->input->buf->buffer->use; base++) {
10357	if ((buf[base] == '-') &&
10358	(buf[base + 1] == '-') &&
10359	(buf[base + 2] == '>')) {
10360	found = 1;
10361	base += 2;
10362	break;
10363	}
10364	}
10365	if (!found) {
10366	#if 0
10367	fprintf(stderr, "unfinished comment\n");
10368	#endif
10369	break; /* for */
10370	}
10371	continue;
10372	}
10373	}
10374	if (buf[base] == '"') {
10375	quote = '"';
10376	continue;
10377	}
10378	if (buf[base] == '\'') {
10379	quote = '\'';
10380	continue;
10381	}
10382	if (buf[base] == ']') {
10383	#if 0
10384	fprintf(stderr, "%c%c%c%c: ", buf[base],
10385	buf[base + 1], buf[base + 2], buf[base + 3]);
10386	#endif
10387	if ((unsigned int) base +1 >=
10388	ctxt->input->buf->buffer->use)
10389	break;
10390	if (buf[base + 1] == ']') {
10391	/* conditional crap, skip both ']' ! */
10392	base++;
10393	continue;
10394	}
10395	for (i = 1;
10396	(unsigned int) base + i < ctxt->input->buf->buffer->use;
10397	i++) {
10398	if (buf[base + i] == '>') {
10399	#if 0
10400	fprintf(stderr, "found\n");
10401	#endif
10402	goto found_end_int_subset;
10403	}
10404	if (!IS_BLANK_CH(buf[base + i])) {
10405	#if 0
10406	fprintf(stderr, "not found\n");
10407	#endif
10408	goto not_end_of_int_subset;
10409	}
10410	}
10411	#if 0
10412	fprintf(stderr, "end of stream\n");
10413	#endif
10414	break;
10415
10416	}
10417	not_end_of_int_subset:
10418	continue; /* for */
10419	}
10420	/*
10421	* We didn't found the end of the Internal subset
10422	*/
10423	#ifdef DEBUG_PUSH
10424	if (next == 0)
10425	xmlGenericError(xmlGenericErrorContext,
10426	"PP: lookup of int subset end filed\n");
10427	#endif
10428	goto done;
10429
10430	found_end_int_subset:
10431	xmlParseInternalSubset(ctxt);
10432	ctxt->inSubset = 2;
10433	if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
10434	(ctxt->sax->externalSubset != NULL))
10435	ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
10436	ctxt->extSubSystem, ctxt->extSubURI);
10437	ctxt->inSubset = 0;
10438	ctxt->instate = XML_PARSER_PROLOG;
10439	ctxt->checkIndex = 0;
10440	#ifdef DEBUG_PUSH
10441	xmlGenericError(xmlGenericErrorContext,
10442	"PP: entering PROLOG\n");
10443	#endif
10444	break;
10445	}
10446	case XML_PARSER_COMMENT:
10447	xmlGenericError(xmlGenericErrorContext,
10448	"PP: internal error, state == COMMENT\n");
10449	ctxt->instate = XML_PARSER_CONTENT;
10450	#ifdef DEBUG_PUSH
10451	xmlGenericError(xmlGenericErrorContext,
10452	"PP: entering CONTENT\n");
10453	#endif
10454	break;
10455	case XML_PARSER_IGNORE:
10456	xmlGenericError(xmlGenericErrorContext,
10457	"PP: internal error, state == IGNORE");
10458	ctxt->instate = XML_PARSER_DTD;
10459	#ifdef DEBUG_PUSH
10460	xmlGenericError(xmlGenericErrorContext,
10461	"PP: entering DTD\n");
10462	#endif
10463	break;
10464	case XML_PARSER_PI:
10465	xmlGenericError(xmlGenericErrorContext,
10466	"PP: internal error, state == PI\n");
10467	ctxt->instate = XML_PARSER_CONTENT;
10468	#ifdef DEBUG_PUSH
10469	xmlGenericError(xmlGenericErrorContext,
10470	"PP: entering CONTENT\n");
10471	#endif
10472	break;
10473	case XML_PARSER_ENTITY_DECL:
10474	xmlGenericError(xmlGenericErrorContext,
10475	"PP: internal error, state == ENTITY_DECL\n");
10476	ctxt->instate = XML_PARSER_DTD;
10477	#ifdef DEBUG_PUSH
10478	xmlGenericError(xmlGenericErrorContext,
10479	"PP: entering DTD\n");
10480	#endif
10481	break;
10482	case XML_PARSER_ENTITY_VALUE:
10483	xmlGenericError(xmlGenericErrorContext,
10484	"PP: internal error, state == ENTITY_VALUE\n");
10485	ctxt->instate = XML_PARSER_CONTENT;
10486	#ifdef DEBUG_PUSH
10487	xmlGenericError(xmlGenericErrorContext,
10488	"PP: entering DTD\n");
10489	#endif
10490	break;
10491	case XML_PARSER_ATTRIBUTE_VALUE:
10492	xmlGenericError(xmlGenericErrorContext,
10493	"PP: internal error, state == ATTRIBUTE_VALUE\n");
10494	ctxt->instate = XML_PARSER_START_TAG;
10495	#ifdef DEBUG_PUSH
10496	xmlGenericError(xmlGenericErrorContext,
10497	"PP: entering START_TAG\n");
10498	#endif
10499	break;
10500	case XML_PARSER_SYSTEM_LITERAL:
10501	xmlGenericError(xmlGenericErrorContext,
10502	"PP: internal error, state == SYSTEM_LITERAL\n");
10503	ctxt->instate = XML_PARSER_START_TAG;
10504	#ifdef DEBUG_PUSH
10505	xmlGenericError(xmlGenericErrorContext,
10506	"PP: entering START_TAG\n");
10507	#endif
10508	break;
10509	case XML_PARSER_PUBLIC_LITERAL:
10510	xmlGenericError(xmlGenericErrorContext,
10511	"PP: internal error, state == PUBLIC_LITERAL\n");
10512	ctxt->instate = XML_PARSER_START_TAG;
10513	#ifdef DEBUG_PUSH
10514	xmlGenericError(xmlGenericErrorContext,
10515	"PP: entering START_TAG\n");
10516	#endif
10517	break;
10518	}
10519	}
10520	done:
10521	#ifdef DEBUG_PUSH
10522	xmlGenericError(xmlGenericErrorContext, "PP: done %d\n", ret);
10523	#endif
10524	return(ret);
10525	encoding_error:
10526	{
10527	char buffer[150];
10528
10529	snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
10530	ctxt->input->cur[0], ctxt->input->cur[1],
10531	ctxt->input->cur[2], ctxt->input->cur[3]);
10532	__xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
10533	"Input is not proper UTF-8, indicate encoding !\n%s",
10534	BAD_CAST buffer, NULL);
10535	}
10536	return(0);
10537	}
10538
10539	/**
10540	* xmlParseChunk:
10541	* @ctxt: an XML parser context
10542	* @chunk: an char array
10543	* @size: the size in byte of the chunk
10544	* @terminate: last chunk indicator
10545	*
10546	* Parse a Chunk of memory
10547	*
10548	* Returns zero if no error, the xmlParserErrors otherwise.
10549	*/
10550	int
10551	xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size,
10552	int terminate) {
10553	int end_in_lf = 0;
10554
10555	if (ctxt == NULL)
10556	return(XML_ERR_INTERNAL_ERROR);
10557	if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
10558	return(ctxt->errNo);
10559	if (ctxt->instate == XML_PARSER_START)
10560	xmlDetectSAX2(ctxt);
10561	if ((size > 0) && (chunk != NULL) && (!terminate) &&
10562	(chunk[size - 1] == '\r')) {
10563	end_in_lf = 1;
10564	size--;
10565	}
10566	if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
10567	(ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF)) {
10568	int base = ctxt->input->base - ctxt->input->buf->buffer->content;
10569	int cur = ctxt->input->cur - ctxt->input->base;
10570	int res;
10571
10572	res =xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
10573	if (res < 0) {
10574	ctxt->errNo = XML_PARSER_EOF;
10575	ctxt->disableSAX = 1;
10576	return (XML_PARSER_EOF);
10577	}
10578	ctxt->input->base = ctxt->input->buf->buffer->content + base;
10579	ctxt->input->cur = ctxt->input->base + cur;
10580	ctxt->input->end =
10581	&ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
10582	#ifdef DEBUG_PUSH
10583	xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
10584	#endif
10585
10586	} else if (ctxt->instate != XML_PARSER_EOF) {
10587	if ((ctxt->input != NULL) && ctxt->input->buf != NULL) {
10588	xmlParserInputBufferPtr in = ctxt->input->buf;
10589	if ((in->encoder != NULL) && (in->buffer != NULL) &&
10590	(in->raw != NULL)) {
10591	int nbchars;
10592
10593	nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
10594	if (nbchars < 0) {
10595	/* TODO 2.6.0 */
10596	xmlGenericError(xmlGenericErrorContext,
10597	"xmlParseChunk: encoder error\n");
10598	return(XML_ERR_INVALID_ENCODING);
10599	}
10600	}
10601	}
10602	}
10603	xmlParseTryOrFinish(ctxt, terminate);
10604	if ((end_in_lf == 1) && (ctxt->input != NULL) &&
10605	(ctxt->input->buf != NULL)) {
10606	xmlParserInputBufferPush(ctxt->input->buf, 1, "\r");
10607	}
10608	if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
10609	return(ctxt->errNo);
10610	if (terminate) {
10611	/*
10612	* Check for termination
10613	*/
10614	int avail = 0;
10615
10616	if (ctxt->input != NULL) {
10617	if (ctxt->input->buf == NULL)
10618	avail = ctxt->input->length -
10619	(ctxt->input->cur - ctxt->input->base);
10620	else
10621	avail = ctxt->input->buf->buffer->use -
10622	(ctxt->input->cur - ctxt->input->base);
10623	}
10624
10625	if ((ctxt->instate != XML_PARSER_EOF) &&
10626	(ctxt->instate != XML_PARSER_EPILOG)) {
10627	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10628	}
10629	if ((ctxt->instate == XML_PARSER_EPILOG) && (avail > 0)) {
10630	xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10631	}
10632	if (ctxt->instate != XML_PARSER_EOF) {
10633	if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10634	ctxt->sax->endDocument(ctxt->userData);
10635	}
10636	ctxt->instate = XML_PARSER_EOF;
10637	}
10638	return((xmlParserErrors) ctxt->errNo);
10639	}
10640
10641	/************************************************************************
10642	* *
10643	* I/O front end functions to the parser *
10644	* *
10645	************************************************************************/
10646
10647	/**
10648	* xmlCreatePushParserCtxt:
10649	* @sax: a SAX handler
10650	* @user_data: The user data returned on SAX callbacks
10651	* @chunk: a pointer to an array of chars
10652	* @size: number of chars in the array
10653	* @filename: an optional file name or URI
10654	*
10655	* Create a parser context for using the XML parser in push mode.
10656	* If @buffer and @size are non-NULL, the data is used to detect
10657	* the encoding. The remaining characters will be parsed so they
10658	* don't need to be fed in again through xmlParseChunk.
10659	* To allow content encoding detection, @size should be >= 4
10660	* The value of @filename is used for fetching external entities
10661	* and error/warning reports.
10662	*
10663	* Returns the new parser context or NULL
10664	*/
10665
10666	xmlParserCtxtPtr
10667	xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
10668	const char chunk, int size, const char filename) {
10669	xmlParserCtxtPtr ctxt;
10670	xmlParserInputPtr inputStream;
10671	xmlParserInputBufferPtr buf;
10672	xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
10673
10674	/*
10675	* plug some encoding conversion routines
10676	*/
10677	if ((chunk != NULL) && (size >= 4))
10678	enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
10679
10680	buf = xmlAllocParserInputBuffer(enc);
10681	if (buf == NULL) return(NULL);
10682
10683	ctxt = xmlNewParserCtxt();
10684	if (ctxt == NULL) {
10685	xmlErrMemory(NULL, "creating parser: out of memory\n");
10686	xmlFreeParserInputBuffer(buf);
10687	return(NULL);
10688	}
10689	ctxt->dictNames = 1;
10690	ctxt->pushTab = (void *) xmlMalloc(ctxt->nameMax 3 * sizeof(xmlChar *));
10691	if (ctxt->pushTab == NULL) {
10692	xmlErrMemory(ctxt, NULL);
10693	xmlFreeParserInputBuffer(buf);
10694	xmlFreeParserCtxt(ctxt);
10695	return(NULL);
10696	}
10697	if (sax != NULL) {
10698	#ifdef LIBXML_SAX1_ENABLED
10699	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
10700	#endif /* LIBXML_SAX1_ENABLED */
10701	xmlFree(ctxt->sax);
10702	ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
10703	if (ctxt->sax == NULL) {
10704	xmlErrMemory(ctxt, NULL);
10705	xmlFreeParserInputBuffer(buf);
10706	xmlFreeParserCtxt(ctxt);
10707	return(NULL);
10708	}
10709	memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
10710	if (sax->initialized == XML_SAX2_MAGIC)
10711	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
10712	else
10713	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
10714	if (user_data != NULL)
10715	ctxt->userData = user_data;
10716	}
10717	if (filename == NULL) {
10718	ctxt->directory = NULL;
10719	} else {
10720	ctxt->directory = xmlParserGetDirectory(filename);
10721	}
10722
10723	inputStream = xmlNewInputStream(ctxt);
10724	if (inputStream == NULL) {
10725	xmlFreeParserCtxt(ctxt);
10726	xmlFreeParserInputBuffer(buf);
10727	return(NULL);
10728	}
10729
10730	if (filename == NULL)
10731	inputStream->filename = NULL;
10732	else {
10733	inputStream->filename = (char *)
10734	xmlCanonicPath((const xmlChar *) filename);
10735	if (inputStream->filename == NULL) {
10736	xmlFreeParserCtxt(ctxt);
10737	xmlFreeParserInputBuffer(buf);
10738	return(NULL);
10739	}
10740	}
10741	inputStream->buf = buf;
10742	inputStream->base = inputStream->buf->buffer->content;
10743	inputStream->cur = inputStream->buf->buffer->content;
10744	inputStream->end =
10745	&inputStream->buf->buffer->content[inputStream->buf->buffer->use];
10746
10747	inputPush(ctxt, inputStream);
10748
10749	/*
10750	* If the caller didn't provide an initial 'chunk' for determining
10751	* the encoding, we set the context to XML_CHAR_ENCODING_NONE so
10752	* that it can be automatically determined later
10753	*/
10754	if ((size == 0) \|\| (chunk == NULL)) {
10755	ctxt->charset = XML_CHAR_ENCODING_NONE;
10756	} else if ((ctxt->input != NULL) && (ctxt->input->buf != NULL)) {
10757	int base = ctxt->input->base - ctxt->input->buf->buffer->content;
10758	int cur = ctxt->input->cur - ctxt->input->base;
10759
10760	xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
10761
10762	ctxt->input->base = ctxt->input->buf->buffer->content + base;
10763	ctxt->input->cur = ctxt->input->base + cur;
10764	ctxt->input->end =
10765	&ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
10766	#ifdef DEBUG_PUSH
10767	xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
10768	#endif
10769	}
10770
10771	if (enc != XML_CHAR_ENCODING_NONE) {
10772	xmlSwitchEncoding(ctxt, enc);
10773	}
10774
10775	return(ctxt);
10776	}
10777	#endif /* LIBXML_PUSH_ENABLED */
10778
10779	/**
10780	* xmlStopParser:
10781	* @ctxt: an XML parser context
10782	*
10783	* Blocks further parser processing
10784	*/
10785	void
10786	xmlStopParser(xmlParserCtxtPtr ctxt) {
10787	if (ctxt == NULL)
10788	return;
10789	ctxt->instate = XML_PARSER_EOF;
10790	ctxt->disableSAX = 1;
10791	if (ctxt->input != NULL) {
10792	ctxt->input->cur = BAD_CAST"";
10793	ctxt->input->base = ctxt->input->cur;
10794	}
10795	}
10796
10797	/**
10798	* xmlCreateIOParserCtxt:
10799	* @sax: a SAX handler
10800	* @user_data: The user data returned on SAX callbacks
10801	* @ioread: an I/O read function
10802	* @ioclose: an I/O close function
10803	* @ioctx: an I/O handler
10804	* @enc: the charset encoding if known
10805	*
10806	* Create a parser context for using the XML parser with an existing
10807	* I/O stream
10808	*
10809	* Returns the new parser context or NULL
10810	*/
10811	xmlParserCtxtPtr
10812	xmlCreateIOParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
10813	xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
10814	void *ioctx, xmlCharEncoding enc) {
10815	xmlParserCtxtPtr ctxt;
10816	xmlParserInputPtr inputStream;
10817	xmlParserInputBufferPtr buf;
10818
10819	if (ioread == NULL) return(NULL);
10820
10821	buf = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, enc);
10822	if (buf == NULL) return(NULL);
10823
10824	ctxt = xmlNewParserCtxt();
10825	if (ctxt == NULL) {
10826	xmlFreeParserInputBuffer(buf);
10827	return(NULL);
10828	}
10829	if (sax != NULL) {
10830	#ifdef LIBXML_SAX1_ENABLED
10831	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
10832	#endif /* LIBXML_SAX1_ENABLED */
10833	xmlFree(ctxt->sax);
10834	ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
10835	if (ctxt->sax == NULL) {
10836	xmlErrMemory(ctxt, NULL);
10837	xmlFreeParserCtxt(ctxt);
10838	return(NULL);
10839	}
10840	memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
10841	if (sax->initialized == XML_SAX2_MAGIC)
10842	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
10843	else
10844	memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
10845	if (user_data != NULL)
10846	ctxt->userData = user_data;
10847	}
10848
10849	inputStream = xmlNewIOInputStream(ctxt, buf, enc);
10850	if (inputStream == NULL) {
10851	xmlFreeParserCtxt(ctxt);
10852	return(NULL);
10853	}
10854	inputPush(ctxt, inputStream);
10855
10856	return(ctxt);
10857	}
10858
10859	#ifdef LIBXML_VALID_ENABLED
10860	/************************************************************************
10861	* *
10862	* Front ends when parsing a DTD *
10863	* *
10864	************************************************************************/
10865
10866	/**
10867	* xmlIOParseDTD:
10868	* @sax: the SAX handler block or NULL
10869	* @input: an Input Buffer
10870	* @enc: the charset encoding if known
10871	*
10872	* Load and parse a DTD
10873	*
10874	* Returns the resulting xmlDtdPtr or NULL in case of error.
10875	* @input will be freed by the function in any case.
10876	*/
10877
10878	xmlDtdPtr
10879	xmlIOParseDTD(xmlSAXHandlerPtr sax, xmlParserInputBufferPtr input,
10880	xmlCharEncoding enc) {
10881	xmlDtdPtr ret = NULL;
10882	xmlParserCtxtPtr ctxt;
10883	xmlParserInputPtr pinput = NULL;
10884	xmlChar start[4];
10885
10886	if (input == NULL)
10887	return(NULL);
10888
10889	ctxt = xmlNewParserCtxt();
10890	if (ctxt == NULL) {
10891	xmlFreeParserInputBuffer(input);
10892	return(NULL);
10893	}
10894
10895	/*
10896	* Set-up the SAX context
10897	*/
10898	if (sax != NULL) {
10899	if (ctxt->sax != NULL)
10900	xmlFree(ctxt->sax);
10901	ctxt->sax = sax;
10902	ctxt->userData = ctxt;
10903	}
10904	xmlDetectSAX2(ctxt);
10905
10906	/*
10907	* generate a parser input from the I/O handler
10908	*/
10909
10910	pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
10911	if (pinput == NULL) {
10912	if (sax != NULL) ctxt->sax = NULL;
10913	xmlFreeParserInputBuffer(input);
10914	xmlFreeParserCtxt(ctxt);
10915	return(NULL);
10916	}
10917
10918	/*
10919	* plug some encoding conversion routines here.
10920	*/
10921	xmlPushInput(ctxt, pinput);
10922	if (enc != XML_CHAR_ENCODING_NONE) {
10923	xmlSwitchEncoding(ctxt, enc);
10924	}
10925
10926	pinput->filename = NULL;
10927	pinput->line = 1;
10928	pinput->col = 1;
10929	pinput->base = ctxt->input->cur;
10930	pinput->cur = ctxt->input->cur;
10931	pinput->free = NULL;
10932
10933	/*
10934	* let's parse that entity knowing it's an external subset.
10935	*/
10936	ctxt->inSubset = 2;
10937	ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
10938	ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
10939	BAD_CAST "none", BAD_CAST "none");
10940
10941	if ((enc == XML_CHAR_ENCODING_NONE) &&
10942	((ctxt->input->end - ctxt->input->cur) >= 4)) {
10943	/*
10944	* Get the 4 first bytes and decode the charset
10945	* if enc != XML_CHAR_ENCODING_NONE
10946	* plug some encoding conversion routines.
10947	*/
10948	start[0] = RAW;
10949	start[1] = NXT(1);
10950	start[2] = NXT(2);
10951	start[3] = NXT(3);
10952	enc = xmlDetectCharEncoding(start, 4);
10953	if (enc != XML_CHAR_ENCODING_NONE) {
10954	xmlSwitchEncoding(ctxt, enc);
10955	}
10956	}
10957
10958	xmlParseExternalSubset(ctxt, BAD_CAST "none", BAD_CAST "none");
10959
10960	if (ctxt->myDoc != NULL) {
10961	if (ctxt->wellFormed) {
10962	ret = ctxt->myDoc->extSubset;
10963	ctxt->myDoc->extSubset = NULL;
10964	if (ret != NULL) {
10965	xmlNodePtr tmp;
10966
10967	ret->doc = NULL;
10968	tmp = ret->children;
10969	while (tmp != NULL) {
10970	tmp->doc = NULL;
10971	tmp = tmp->next;
10972	}
10973	}
10974	} else {
10975	ret = NULL;
10976	}
10977	xmlFreeDoc(ctxt->myDoc);
10978	ctxt->myDoc = NULL;
10979	}
10980	if (sax != NULL) ctxt->sax = NULL;
10981	xmlFreeParserCtxt(ctxt);
10982
10983	return(ret);
10984	}
10985
10986	/**
10987	* xmlSAXParseDTD:
10988	* @sax: the SAX handler block
10989	* @ExternalID: a NAME* containing the External ID of the DTD
10990	* @SystemID: a NAME* containing the URL to the DTD
10991	*
10992	* Load and parse an external subset.
10993	*
10994	* Returns the resulting xmlDtdPtr or NULL in case of error.
10995	*/
10996
10997	xmlDtdPtr
10998	xmlSAXParseDTD(xmlSAXHandlerPtr sax, const xmlChar *ExternalID,
10999	const xmlChar *SystemID) {
11000	xmlDtdPtr ret = NULL;
11001	xmlParserCtxtPtr ctxt;
11002	xmlParserInputPtr input = NULL;
11003	xmlCharEncoding enc;
11004	xmlChar* systemIdCanonic;
11005
11006	if ((ExternalID == NULL) && (SystemID == NULL)) return(NULL);
11007
11008	ctxt = xmlNewParserCtxt();
11009	if (ctxt == NULL) {
11010	return(NULL);
11011	}
11012
11013	/*
11014	* Set-up the SAX context
11015	*/
11016	if (sax != NULL) {
11017	if (ctxt->sax != NULL)
11018	xmlFree(ctxt->sax);
11019	ctxt->sax = sax;
11020	ctxt->userData = ctxt;
11021	}
11022
11023	/*
11024	* Canonicalise the system ID
11025	*/
11026	systemIdCanonic = xmlCanonicPath(SystemID);
11027	if ((SystemID != NULL) && (systemIdCanonic == NULL)) {
11028	xmlFreeParserCtxt(ctxt);
11029	return(NULL);
11030	}
11031
11032	/*
11033	* Ask the Entity resolver to load the damn thing
11034	*/
11035
11036	if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
11037	input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
11038	systemIdCanonic);
11039	if (input == NULL) {
11040	if (sax != NULL) ctxt->sax = NULL;
11041	xmlFreeParserCtxt(ctxt);
11042	if (systemIdCanonic != NULL)
11043	xmlFree(systemIdCanonic);
11044	return(NULL);
11045	}
11046
11047	/*
11048	* plug some encoding conversion routines here.
11049	*/
11050	xmlPushInput(ctxt, input);
11051	if ((ctxt->input->end - ctxt->input->cur) >= 4) {
11052	enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
11053	xmlSwitchEncoding(ctxt, enc);
11054	}
11055
11056	if (input->filename == NULL)
11057	input->filename = (char *) systemIdCanonic;
11058	else
11059	xmlFree(systemIdCanonic);
11060	input->line = 1;
11061	input->col = 1;
11062	input->base = ctxt->input->cur;
11063	input->cur = ctxt->input->cur;
11064	input->free = NULL;
11065
11066	/*
11067	* let's parse that entity knowing it's an external subset.
11068	*/
11069	ctxt->inSubset = 2;
11070	ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
11071	ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
11072	ExternalID, SystemID);
11073	xmlParseExternalSubset(ctxt, ExternalID, SystemID);
11074
11075	if (ctxt->myDoc != NULL) {
11076	if (ctxt->wellFormed) {
11077	ret = ctxt->myDoc->extSubset;
11078	ctxt->myDoc->extSubset = NULL;
11079	if (ret != NULL) {
11080	xmlNodePtr tmp;
11081
11082	ret->doc = NULL;
11083	tmp = ret->children;
11084	while (tmp != NULL) {
11085	tmp->doc = NULL;
11086	tmp = tmp->next;
11087	}
11088	}
11089	} else {
11090	ret = NULL;
11091	}
11092	xmlFreeDoc(ctxt->myDoc);
11093	ctxt->myDoc = NULL;
11094	}
11095	if (sax != NULL) ctxt->sax = NULL;
11096	xmlFreeParserCtxt(ctxt);
11097
11098	return(ret);
11099	}
11100
11101
11102	/**
11103	* xmlParseDTD:
11104	* @ExternalID: a NAME* containing the External ID of the DTD
11105	* @SystemID: a NAME* containing the URL to the DTD
11106	*
11107	* Load and parse an external subset.
11108	*
11109	* Returns the resulting xmlDtdPtr or NULL in case of error.
11110	*/
11111
11112	xmlDtdPtr
11113	xmlParseDTD(const xmlChar ExternalID, const xmlChar SystemID) {
11114	return(xmlSAXParseDTD(NULL, ExternalID, SystemID));
11115	}
11116	#endif /* LIBXML_VALID_ENABLED */
11117
11118	/************************************************************************
11119	* *
11120	* Front ends when parsing an Entity *
11121	* *
11122	************************************************************************/
11123
11124	/**
11125	* xmlParseCtxtExternalEntity:
11126	* @ctx: the existing parsing context
11127	* @URL: the URL for the entity to load
11128	* @ID: the System ID for the entity to load
11129	* @lst: the return value for the set of parsed nodes
11130	*
11131	* Parse an external general entity within an existing parsing context
11132	* An external general parsed entity is well-formed if it matches the
11133	* production labeled extParsedEnt.
11134	*
11135	* [78] extParsedEnt ::= TextDecl? content
11136	*
11137	* Returns 0 if the entity is well formed, -1 in case of args problem and
11138	* the parser error code otherwise
11139	*/
11140
11141	int
11142	xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, const xmlChar *URL,
11143	const xmlChar ID, xmlNodePtr lst) {
11144	xmlParserCtxtPtr ctxt;
11145	xmlDocPtr newDoc;
11146	xmlNodePtr newRoot;
11147	xmlSAXHandlerPtr oldsax = NULL;
11148	int ret = 0;
11149	xmlChar start[4];
11150	xmlCharEncoding enc;
11151	xmlParserInputPtr inputStream;
11152	char *directory = NULL;
11153
11154	if (ctx == NULL) return(-1);
11155
11156	if (ctx->depth > 40) {
11157	return(XML_ERR_ENTITY_LOOP);
11158	}
11159
11160	if (lst != NULL)
11161	*lst = NULL;
11162	if ((URL == NULL) && (ID == NULL))
11163	return(-1);
11164	if (ctx->myDoc == NULL) /* @@ relax but check for dereferences */
11165	return(-1);
11166
11167	ctxt = xmlNewParserCtxt();
11168	if (ctxt == NULL) {
11169	return(-1);
11170	}
11171
11172	ctxt->userData = ctxt;
11173	ctxt->_private = ctx->_private;
11174
11175	inputStream = xmlLoadExternalEntity((char )URL, (char )ID, ctxt);
11176	if (inputStream == NULL) {
11177	xmlFreeParserCtxt(ctxt);
11178	return(-1);
11179	}
11180
11181	inputPush(ctxt, inputStream);
11182
11183	if ((ctxt->directory == NULL) && (directory == NULL))
11184	directory = xmlParserGetDirectory((char *)URL);
11185	if ((ctxt->directory == NULL) && (directory != NULL))
11186	ctxt->directory = directory;
11187
11188	oldsax = ctxt->sax;
11189	ctxt->sax = ctx->sax;
11190	xmlDetectSAX2(ctxt);
11191	newDoc = xmlNewDoc(BAD_CAST "1.0");
11192	if (newDoc == NULL) {
11193	xmlFreeParserCtxt(ctxt);
11194	return(-1);
11195	}
11196	if (ctx->myDoc->dict) {
11197	newDoc->dict = ctx->myDoc->dict;
11198	xmlDictReference(newDoc->dict);
11199	}
11200	if (ctx->myDoc != NULL) {
11201	newDoc->intSubset = ctx->myDoc->intSubset;
11202	newDoc->extSubset = ctx->myDoc->extSubset;
11203	}
11204	if (ctx->myDoc->URL != NULL) {
11205	newDoc->URL = xmlStrdup(ctx->myDoc->URL);
11206	}
11207	newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
11208	if (newRoot == NULL) {
11209	ctxt->sax = oldsax;
11210	xmlFreeParserCtxt(ctxt);
11211	newDoc->intSubset = NULL;
11212	newDoc->extSubset = NULL;
11213	xmlFreeDoc(newDoc);
11214	return(-1);
11215	}
11216	xmlAddChild((xmlNodePtr) newDoc, newRoot);
11217	nodePush(ctxt, newDoc->children);
11218	if (ctx->myDoc == NULL) {
11219	ctxt->myDoc = newDoc;
11220	} else {
11221	ctxt->myDoc = ctx->myDoc;
11222	newDoc->children->doc = ctx->myDoc;
11223	}
11224
11225	/*
11226	* Get the 4 first bytes and decode the charset
11227	* if enc != XML_CHAR_ENCODING_NONE
11228	* plug some encoding conversion routines.
11229	*/
11230	GROW
11231	if ((ctxt->input->end - ctxt->input->cur) >= 4) {
11232	start[0] = RAW;
11233	start[1] = NXT(1);
11234	start[2] = NXT(2);
11235	start[3] = NXT(3);
11236	enc = xmlDetectCharEncoding(start, 4);
11237	if (enc != XML_CHAR_ENCODING_NONE) {
11238	xmlSwitchEncoding(ctxt, enc);
11239	}
11240	}
11241
11242	/*
11243	* Parse a possible text declaration first
11244	*/
11245	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
11246	xmlParseTextDecl(ctxt);
11247	}
11248
11249	/*
11250	* Doing validity checking on chunk doesn't make sense
11251	*/
11252	ctxt->instate = XML_PARSER_CONTENT;
11253	ctxt->validate = ctx->validate;
11254	ctxt->valid = ctx->valid;
11255	ctxt->loadsubset = ctx->loadsubset;
11256	ctxt->depth = ctx->depth + 1;
11257	ctxt->replaceEntities = ctx->replaceEntities;
11258	if (ctxt->validate) {
11259	ctxt->vctxt.error = ctx->vctxt.error;
11260	ctxt->vctxt.warning = ctx->vctxt.warning;
11261	} else {
11262	ctxt->vctxt.error = NULL;
11263	ctxt->vctxt.warning = NULL;
11264	}
11265	ctxt->vctxt.nodeTab = NULL;
11266	ctxt->vctxt.nodeNr = 0;
11267	ctxt->vctxt.nodeMax = 0;
11268	ctxt->vctxt.node = NULL;
11269	if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
11270	ctxt->dict = ctx->dict;
11271	ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
11272	ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
11273	ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
11274	ctxt->dictNames = ctx->dictNames;
11275	ctxt->attsDefault = ctx->attsDefault;
11276	ctxt->attsSpecial = ctx->attsSpecial;
11277	ctxt->linenumbers = ctx->linenumbers;
11278
11279	xmlParseContent(ctxt);
11280
11281	ctx->validate = ctxt->validate;
11282	ctx->valid = ctxt->valid;
11283	if ((RAW == '<') && (NXT(1) == '/')) {
11284	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11285	} else if (RAW != 0) {
11286	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11287	}
11288	if (ctxt->node != newDoc->children) {
11289	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11290	}
11291
11292	if (!ctxt->wellFormed) {
11293	if (ctxt->errNo == 0)
11294	ret = 1;
11295	else
11296	ret = ctxt->errNo;
11297	} else {
11298	if (lst != NULL) {
11299	xmlNodePtr cur;
11300
11301	/*
11302	* Return the newly created nodeset after unlinking it from
11303	* they pseudo parent.
11304	*/
11305	cur = newDoc->children->children;
11306	*lst = cur;
11307	while (cur != NULL) {
11308	cur->parent = NULL;
11309	cur = cur->next;
11310	}
11311	newDoc->children->children = NULL;
11312	}
11313	ret = 0;
11314	}
11315	ctxt->sax = oldsax;
11316	ctxt->dict = NULL;
11317	ctxt->attsDefault = NULL;
11318	ctxt->attsSpecial = NULL;
11319	xmlFreeParserCtxt(ctxt);
11320	newDoc->intSubset = NULL;
11321	newDoc->extSubset = NULL;
11322	xmlFreeDoc(newDoc);
11323
11324	return(ret);
11325	}
11326
11327	/**
11328	* xmlParseExternalEntityPrivate:
11329	* @doc: the document the chunk pertains to
11330	* @oldctxt: the previous parser context if available
11331	* @sax: the SAX handler bloc (possibly NULL)
11332	* @user_data: The user data returned on SAX callbacks (possibly NULL)
11333	* @depth: Used for loop detection, use 0
11334	* @URL: the URL for the entity to load
11335	* @ID: the System ID for the entity to load
11336	* @list: the return value for the set of parsed nodes
11337	*
11338	* Private version of xmlParseExternalEntity()
11339	*
11340	* Returns 0 if the entity is well formed, -1 in case of args problem and
11341	* the parser error code otherwise
11342	*/
11343
11344	static xmlParserErrors
11345	xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
11346	xmlSAXHandlerPtr sax,
11347	void user_data, int depth, const xmlChar URL,
11348	const xmlChar ID, xmlNodePtr list) {
11349	xmlParserCtxtPtr ctxt;
11350	xmlDocPtr newDoc;
11351	xmlNodePtr newRoot;
11352	xmlSAXHandlerPtr oldsax = NULL;
11353	xmlParserErrors ret = XML_ERR_OK;
11354	xmlChar start[4];
11355	xmlCharEncoding enc;
11356
11357	if (depth > 40) {
11358	return(XML_ERR_ENTITY_LOOP);
11359	}
11360
11361
11362
11363	if (list != NULL)
11364	*list = NULL;
11365	if ((URL == NULL) && (ID == NULL))
11366	return(XML_ERR_INTERNAL_ERROR);
11367	if (doc == NULL)
11368	return(XML_ERR_INTERNAL_ERROR);
11369
11370
11371	ctxt = xmlCreateEntityParserCtxt(URL, ID, NULL);
11372	if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
11373	ctxt->userData = ctxt;
11374	if (oldctxt != NULL) {
11375	ctxt->_private = oldctxt->_private;
11376	ctxt->loadsubset = oldctxt->loadsubset;
11377	ctxt->validate = oldctxt->validate;
11378	ctxt->external = oldctxt->external;
11379	ctxt->record_info = oldctxt->record_info;
11380	ctxt->node_seq.maximum = oldctxt->node_seq.maximum;
11381	ctxt->node_seq.length = oldctxt->node_seq.length;
11382	ctxt->node_seq.buffer = oldctxt->node_seq.buffer;
11383	} else {
11384	/*
11385	* Doing validity checking on chunk without context
11386	* doesn't make sense
11387	*/
11388	ctxt->_private = NULL;
11389	ctxt->validate = 0;
11390	ctxt->external = 2;
11391	ctxt->loadsubset = 0;
11392	}
11393	if (sax != NULL) {
11394	oldsax = ctxt->sax;
11395	ctxt->sax = sax;
11396	if (user_data != NULL)
11397	ctxt->userData = user_data;
11398	}
11399	xmlDetectSAX2(ctxt);
11400	newDoc = xmlNewDoc(BAD_CAST "1.0");
11401	if (newDoc == NULL) {
11402	ctxt->node_seq.maximum = 0;
11403	ctxt->node_seq.length = 0;
11404	ctxt->node_seq.buffer = NULL;
11405	xmlFreeParserCtxt(ctxt);
11406	return(XML_ERR_INTERNAL_ERROR);
11407	}
11408	newDoc->intSubset = doc->intSubset;
11409	newDoc->extSubset = doc->extSubset;
11410	newDoc->dict = doc->dict;
11411	xmlDictReference(newDoc->dict);
11412
11413	if (doc->URL != NULL) {
11414	newDoc->URL = xmlStrdup(doc->URL);
11415	}
11416	newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
11417	if (newRoot == NULL) {
11418	if (sax != NULL)
11419	ctxt->sax = oldsax;
11420	ctxt->node_seq.maximum = 0;
11421	ctxt->node_seq.length = 0;
11422	ctxt->node_seq.buffer = NULL;
11423	xmlFreeParserCtxt(ctxt);
11424	newDoc->intSubset = NULL;
11425	newDoc->extSubset = NULL;
11426	xmlFreeDoc(newDoc);
11427	return(XML_ERR_INTERNAL_ERROR);
11428	}
11429	xmlAddChild((xmlNodePtr) newDoc, newRoot);
11430	nodePush(ctxt, newDoc->children);
11431	ctxt->myDoc = doc;
11432	newRoot->doc = doc;
11433
11434	/*
11435	* Get the 4 first bytes and decode the charset
11436	* if enc != XML_CHAR_ENCODING_NONE
11437	* plug some encoding conversion routines.
11438	*/
11439	GROW;
11440	if ((ctxt->input->end - ctxt->input->cur) >= 4) {
11441	start[0] = RAW;
11442	start[1] = NXT(1);
11443	start[2] = NXT(2);
11444	start[3] = NXT(3);
11445	enc = xmlDetectCharEncoding(start, 4);
11446	if (enc != XML_CHAR_ENCODING_NONE) {
11447	xmlSwitchEncoding(ctxt, enc);
11448	}
11449	}
11450
11451	/*
11452	* Parse a possible text declaration first
11453	*/
11454	if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
11455	xmlParseTextDecl(ctxt);
11456	}
11457
11458	ctxt->instate = XML_PARSER_CONTENT;
11459	ctxt->depth = depth;
11460
11461	xmlParseContent(ctxt);
11462
11463	if ((RAW == '<') && (NXT(1) == '/')) {
11464	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11465	} else if (RAW != 0) {
11466	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11467	}
11468	if (ctxt->node != newDoc->children) {
11469	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11470	}
11471
11472	if (!ctxt->wellFormed) {
11473	if (ctxt->errNo == 0)
11474	ret = XML_ERR_INTERNAL_ERROR;
11475	else
11476	ret = (xmlParserErrors)ctxt->errNo;
11477	} else {
11478	if (list != NULL) {
11479	xmlNodePtr cur;
11480
11481	/*
11482	* Return the newly created nodeset after unlinking it from
11483	* they pseudo parent.
11484	*/
11485	cur = newDoc->children->children;
11486	*list = cur;
11487	while (cur != NULL) {
11488	cur->parent = NULL;
11489	cur = cur->next;
11490	}
11491	newDoc->children->children = NULL;
11492	}
11493	ret = XML_ERR_OK;
11494	}
11495	if (sax != NULL)
11496	ctxt->sax = oldsax;
11497	oldctxt->node_seq.maximum = ctxt->node_seq.maximum;
11498	oldctxt->node_seq.length = ctxt->node_seq.length;
11499	oldctxt->node_seq.buffer = ctxt->node_seq.buffer;
11500	ctxt->node_seq.maximum = 0;
11501	ctxt->node_seq.length = 0;
11502	ctxt->node_seq.buffer = NULL;
11503	xmlFreeParserCtxt(ctxt);
11504	newDoc->intSubset = NULL;
11505	newDoc->extSubset = NULL;
11506	xmlFreeDoc(newDoc);
11507
11508	return(ret);
11509	}
11510
11511	#ifdef LIBXML_SAX1_ENABLED
11512	/**
11513	* xmlParseExternalEntity:
11514	* @doc: the document the chunk pertains to
11515	* @sax: the SAX handler bloc (possibly NULL)
11516	* @user_data: The user data returned on SAX callbacks (possibly NULL)
11517	* @depth: Used for loop detection, use 0
11518	* @URL: the URL for the entity to load
11519	* @ID: the System ID for the entity to load
11520	* @lst: the return value for the set of parsed nodes
11521	*
11522	* Parse an external general entity
11523	* An external general parsed entity is well-formed if it matches the
11524	* production labeled extParsedEnt.
11525	*
11526	* [78] extParsedEnt ::= TextDecl? content
11527	*
11528	* Returns 0 if the entity is well formed, -1 in case of args problem and
11529	* the parser error code otherwise
11530	*/
11531
11532	int
11533	xmlParseExternalEntity(xmlDocPtr doc, xmlSAXHandlerPtr sax, void *user_data,
11534	int depth, const xmlChar URL, const xmlChar ID, xmlNodePtr *lst) {
11535	return(xmlParseExternalEntityPrivate(doc, NULL, sax, user_data, depth, URL,
11536	ID, lst));
11537	}
11538
11539	/**
11540	* xmlParseBalancedChunkMemory:
11541	* @doc: the document the chunk pertains to
11542	* @sax: the SAX handler bloc (possibly NULL)
11543	* @user_data: The user data returned on SAX callbacks (possibly NULL)
11544	* @depth: Used for loop detection, use 0
11545	* @string: the input string in UTF8 or ISO-Latin (zero terminated)
11546	* @lst: the return value for the set of parsed nodes
11547	*
11548	* Parse a well-balanced chunk of an XML document
11549	* called by the parser
11550	* The allowed sequence for the Well Balanced Chunk is the one defined by
11551	* the content production in the XML grammar:
11552	*
11553	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
11554	*
11555	* Returns 0 if the chunk is well balanced, -1 in case of args problem and
11556	* the parser error code otherwise
11557	*/
11558
11559	int
11560	xmlParseBalancedChunkMemory(xmlDocPtr doc, xmlSAXHandlerPtr sax,
11561	void user_data, int depth, const xmlChar string, xmlNodePtr *lst) {
11562	return xmlParseBalancedChunkMemoryRecover( doc, sax, user_data,
11563	depth, string, lst, 0 );
11564	}
11565	#endif /* LIBXML_SAX1_ENABLED */
11566
11567	/**
11568	* xmlParseBalancedChunkMemoryInternal:
11569	* @oldctxt: the existing parsing context
11570	* @string: the input string in UTF8 or ISO-Latin (zero terminated)
11571	* @user_data: the user data field for the parser context
11572	* @lst: the return value for the set of parsed nodes
11573	*
11574	*
11575	* Parse a well-balanced chunk of an XML document
11576	* called by the parser
11577	* The allowed sequence for the Well Balanced Chunk is the one defined by
11578	* the content production in the XML grammar:
11579	*
11580	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
11581	*
11582	* Returns XML_ERR_OK if the chunk is well balanced, and the parser
11583	* error code otherwise
11584	*
11585	* In case recover is set to 1, the nodelist will not be empty even if
11586	* the parsed chunk is not well balanced.
11587	*/
11588	static xmlParserErrors
11589	xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
11590	const xmlChar string, void user_data, xmlNodePtr *lst) {
11591	xmlParserCtxtPtr ctxt;
11592	xmlDocPtr newDoc = NULL;
11593	xmlNodePtr newRoot;
11594	xmlSAXHandlerPtr oldsax = NULL;
11595	xmlNodePtr content = NULL;
11596	xmlNodePtr last = NULL;
11597	int size;
11598	xmlParserErrors ret = XML_ERR_OK;
11599
11600	if (oldctxt->depth > 40) {
11601	return(XML_ERR_ENTITY_LOOP);
11602	}
11603
11604
11605	if (lst != NULL)
11606	*lst = NULL;
11607	if (string == NULL)
11608	return(XML_ERR_INTERNAL_ERROR);
11609
11610	size = xmlStrlen(string);
11611
11612	ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
11613	if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
11614	if (user_data != NULL)
11615	ctxt->userData = user_data;
11616	else
11617	ctxt->userData = ctxt;
11618	if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
11619	ctxt->dict = oldctxt->dict;
11620	ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
11621	ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
11622	ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
11623
11624	oldsax = ctxt->sax;
11625	ctxt->sax = oldctxt->sax;
11626	xmlDetectSAX2(ctxt);
11627	ctxt->replaceEntities = oldctxt->replaceEntities;
11628	ctxt->options = oldctxt->options;
11629
11630	ctxt->_private = oldctxt->_private;
11631	if (oldctxt->myDoc == NULL) {
11632	newDoc = xmlNewDoc(BAD_CAST "1.0");
11633	if (newDoc == NULL) {
11634	ctxt->sax = oldsax;
11635	ctxt->dict = NULL;
11636	xmlFreeParserCtxt(ctxt);
11637	return(XML_ERR_INTERNAL_ERROR);
11638	}
11639	newDoc->dict = ctxt->dict;
11640	xmlDictReference(newDoc->dict);
11641	ctxt->myDoc = newDoc;
11642	} else {
11643	ctxt->myDoc = oldctxt->myDoc;
11644	content = ctxt->myDoc->children;
11645	last = ctxt->myDoc->last;
11646	}
11647	newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL);
11648	if (newRoot == NULL) {
11649	ctxt->sax = oldsax;
11650	ctxt->dict = NULL;
11651	xmlFreeParserCtxt(ctxt);
11652	if (newDoc != NULL) {
11653	xmlFreeDoc(newDoc);
11654	}
11655	return(XML_ERR_INTERNAL_ERROR);
11656	}
11657	ctxt->myDoc->children = NULL;
11658	ctxt->myDoc->last = NULL;
11659	xmlAddChild((xmlNodePtr) ctxt->myDoc, newRoot);
11660	nodePush(ctxt, ctxt->myDoc->children);
11661	ctxt->instate = XML_PARSER_CONTENT;
11662	ctxt->depth = oldctxt->depth + 1;
11663
11664	ctxt->validate = 0;
11665	ctxt->loadsubset = oldctxt->loadsubset;
11666	if ((oldctxt->validate) \|\| (oldctxt->replaceEntities != 0)) {
11667	/*
11668	* ID/IDREF registration will be done in xmlValidateElement below
11669	*/
11670	ctxt->loadsubset \|= XML_SKIP_IDS;
11671	}
11672	ctxt->dictNames = oldctxt->dictNames;
11673	ctxt->attsDefault = oldctxt->attsDefault;
11674	ctxt->attsSpecial = oldctxt->attsSpecial;
11675
11676	xmlParseContent(ctxt);
11677	if ((RAW == '<') && (NXT(1) == '/')) {
11678	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11679	} else if (RAW != 0) {
11680	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11681	}
11682	if (ctxt->node != ctxt->myDoc->children) {
11683	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11684	}
11685
11686	if (!ctxt->wellFormed) {
11687	if (ctxt->errNo == 0)
11688	ret = XML_ERR_INTERNAL_ERROR;
11689	else
11690	ret = (xmlParserErrors)ctxt->errNo;
11691	} else {
11692	ret = XML_ERR_OK;
11693	}
11694
11695	if ((lst != NULL) && (ret == XML_ERR_OK)) {
11696	xmlNodePtr cur;
11697
11698	/*
11699	* Return the newly created nodeset after unlinking it from
11700	* they pseudo parent.
11701	*/
11702	cur = ctxt->myDoc->children->children;
11703	*lst = cur;
11704	while (cur != NULL) {
11705	#ifdef LIBXML_VALID_ENABLED
11706	if ((oldctxt->validate) && (oldctxt->wellFormed) &&
11707	(oldctxt->myDoc) && (oldctxt->myDoc->intSubset) &&
11708	(cur->type == XML_ELEMENT_NODE)) {
11709	oldctxt->valid &= xmlValidateElement(&oldctxt->vctxt,
11710	oldctxt->myDoc, cur);
11711	}
11712	#endif /* LIBXML_VALID_ENABLED */
11713	cur->parent = NULL;
11714	cur = cur->next;
11715	}
11716	ctxt->myDoc->children->children = NULL;
11717	}
11718	if (ctxt->myDoc != NULL) {
11719	xmlFreeNode(ctxt->myDoc->children);
11720	ctxt->myDoc->children = content;
11721	ctxt->myDoc->last = last;
11722	}
11723
11724	ctxt->sax = oldsax;
11725	ctxt->dict = NULL;
11726	ctxt->attsDefault = NULL;
11727	ctxt->attsSpecial = NULL;
11728	xmlFreeParserCtxt(ctxt);
11729	if (newDoc != NULL) {
11730	xmlFreeDoc(newDoc);
11731	}
11732
11733	return(ret);
11734	}
11735
11736	/**
11737	* xmlParseInNodeContext:
11738	* @node: the context node
11739	* @data: the input string
11740	* @datalen: the input string length in bytes
11741	* @options: a combination of xmlParserOption
11742	* @lst: the return value for the set of parsed nodes
11743	*
11744	* Parse a well-balanced chunk of an XML document
11745	* within the context (DTD, namespaces, etc ...) of the given node.
11746	*
11747	* The allowed sequence for the data is a Well Balanced Chunk defined by
11748	* the content production in the XML grammar:
11749	*
11750	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
11751	*
11752	* Returns XML_ERR_OK if the chunk is well balanced, and the parser
11753	* error code otherwise
11754	*/
11755	xmlParserErrors
11756	xmlParseInNodeContext(xmlNodePtr node, const char *data, int datalen,
11757	int options, xmlNodePtr *lst) {
11758	#ifdef SAX2
11759	xmlParserCtxtPtr ctxt;
11760	xmlDocPtr doc = NULL;
11761	xmlNodePtr fake, cur;
11762	int nsnr = 0;
11763
11764	xmlParserErrors ret = XML_ERR_OK;
11765
11766	/*
11767	* check all input parameters, grab the document
11768	*/
11769	if ((lst == NULL) \|\| (node == NULL) \|\| (data == NULL) \|\| (datalen < 0))
11770	return(XML_ERR_INTERNAL_ERROR);
11771	switch (node->type) {
11772	case XML_ELEMENT_NODE:
11773	case XML_ATTRIBUTE_NODE:
11774	case XML_TEXT_NODE:
11775	case XML_CDATA_SECTION_NODE:
11776	case XML_ENTITY_REF_NODE:
11777	case XML_PI_NODE:
11778	case XML_COMMENT_NODE:
11779	case XML_DOCUMENT_NODE:
11780	case XML_HTML_DOCUMENT_NODE:
11781	break;
11782	default:
11783	return(XML_ERR_INTERNAL_ERROR);
11784
11785	}
11786	while ((node != NULL) && (node->type != XML_ELEMENT_NODE) &&
11787	(node->type != XML_DOCUMENT_NODE) &&
11788	(node->type != XML_HTML_DOCUMENT_NODE))
11789	node = node->parent;
11790	if (node == NULL)
11791	return(XML_ERR_INTERNAL_ERROR);
11792	if (node->type == XML_ELEMENT_NODE)
11793	doc = node->doc;
11794	else
11795	doc = (xmlDocPtr) node;
11796	if (doc == NULL)
11797	return(XML_ERR_INTERNAL_ERROR);
11798
11799	/*
11800	* allocate a context and set-up everything not related to the
11801	* node position in the tree
11802	*/
11803	if (doc->type == XML_DOCUMENT_NODE)
11804	ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen);
11805	#ifdef LIBXML_HTML_ENABLED
11806	else if (doc->type == XML_HTML_DOCUMENT_NODE)
11807	ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen);
11808	#endif
11809	else
11810	return(XML_ERR_INTERNAL_ERROR);
11811
11812	if (ctxt == NULL)
11813	return(XML_ERR_NO_MEMORY);
11814	fake = xmlNewComment(NULL);
11815	if (fake == NULL) {
11816	xmlFreeParserCtxt(ctxt);
11817	return(XML_ERR_NO_MEMORY);
11818	}
11819	xmlAddChild(node, fake);
11820
11821	/*
11822	* Use input doc's dict if present, else assure XML_PARSE_NODICT is set.
11823	* We need a dictionary for xmlDetectSAX2, so if there's no doc dict
11824	* we must wait until the last moment to free the original one.
11825	*/
11826	if (doc->dict != NULL) {
11827	if (ctxt->dict != NULL)
11828	xmlDictFree(ctxt->dict);
11829	ctxt->dict = doc->dict;
11830	} else
11831	options \|= XML_PARSE_NODICT;
11832
11833	xmlCtxtUseOptions(ctxt, options);
11834	xmlDetectSAX2(ctxt);
11835	ctxt->myDoc = doc;
11836
11837	if (node->type == XML_ELEMENT_NODE) {
11838	nodePush(ctxt, node);
11839	/*
11840	* initialize the SAX2 namespaces stack
11841	*/
11842	cur = node;
11843	while ((cur != NULL) && (cur->type == XML_ELEMENT_NODE)) {
11844	xmlNsPtr ns = cur->nsDef;
11845	const xmlChar iprefix, ihref;
11846
11847	while (ns != NULL) {
11848	if (ctxt->dict) {
11849	iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1);
11850	ihref = xmlDictLookup(ctxt->dict, ns->href, -1);
11851	} else {
11852	iprefix = ns->prefix;
11853	ihref = ns->href;
11854	}
11855
11856	if (xmlGetNamespace(ctxt, iprefix) == NULL) {
11857	nsPush(ctxt, iprefix, ihref);
11858	nsnr++;
11859	}
11860	ns = ns->next;
11861	}
11862	cur = cur->parent;
11863	}
11864	ctxt->instate = XML_PARSER_CONTENT;
11865	}
11866
11867	if ((ctxt->validate) \|\| (ctxt->replaceEntities != 0)) {
11868	/*
11869	* ID/IDREF registration will be done in xmlValidateElement below
11870	*/
11871	ctxt->loadsubset \|= XML_SKIP_IDS;
11872	}
11873
11874	#ifdef LIBXML_HTML_ENABLED
11875	if (doc->type == XML_HTML_DOCUMENT_NODE)
11876	__htmlParseContent(ctxt);
11877	else
11878	#endif
11879	xmlParseContent(ctxt);
11880
11881	nsPop(ctxt, nsnr);
11882	if ((RAW == '<') && (NXT(1) == '/')) {
11883	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11884	} else if (RAW != 0) {
11885	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11886	}
11887	if ((ctxt->node != NULL) && (ctxt->node != node)) {
11888	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11889	ctxt->wellFormed = 0;
11890	}
11891
11892	if (!ctxt->wellFormed) {
11893	if (ctxt->errNo == 0)
11894	ret = XML_ERR_INTERNAL_ERROR;
11895	else
11896	ret = (xmlParserErrors)ctxt->errNo;
11897	} else {
11898	ret = XML_ERR_OK;
11899	}
11900
11901	/*
11902	* Return the newly created nodeset after unlinking it from
11903	* the pseudo sibling.
11904	*/
11905
11906	cur = fake->next;
11907	fake->next = NULL;
11908	node->last = fake;
11909
11910	if (cur != NULL) {
11911	cur->prev = NULL;
11912	}
11913
11914	*lst = cur;
11915
11916	while (cur != NULL) {
11917	cur->parent = NULL;
11918	cur = cur->next;
11919	}
11920
11921	xmlUnlinkNode(fake);
11922	xmlFreeNode(fake);
11923
11924
11925	if (ret != XML_ERR_OK) {
11926	xmlFreeNodeList(*lst);
11927	*lst = NULL;
11928	}
11929
11930	if (doc->dict != NULL)
11931	ctxt->dict = NULL;
11932	xmlFreeParserCtxt(ctxt);
11933
11934	return(ret);
11935	#else /* !SAX2 */
11936	return(XML_ERR_INTERNAL_ERROR);
11937	#endif
11938	}
11939
11940	#ifdef LIBXML_SAX1_ENABLED
11941	/**
11942	* xmlParseBalancedChunkMemoryRecover:
11943	* @doc: the document the chunk pertains to
11944	* @sax: the SAX handler bloc (possibly NULL)
11945	* @user_data: The user data returned on SAX callbacks (possibly NULL)
11946	* @depth: Used for loop detection, use 0
11947	* @string: the input string in UTF8 or ISO-Latin (zero terminated)
11948	* @lst: the return value for the set of parsed nodes
11949	* @recover: return nodes even if the data is broken (use 0)
11950	*
11951	*
11952	* Parse a well-balanced chunk of an XML document
11953	* called by the parser
11954	* The allowed sequence for the Well Balanced Chunk is the one defined by
11955	* the content production in the XML grammar:
11956	*
11957	* [43] content ::= (element \| CharData \| Reference \| CDSect \| PI \| Comment)*
11958	*
11959	* Returns 0 if the chunk is well balanced, -1 in case of args problem and
11960	* the parser error code otherwise
11961	*
11962	* In case recover is set to 1, the nodelist will not be empty even if
11963	* the parsed chunk is not well balanced.
11964	*/
11965	int
11966	xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, xmlSAXHandlerPtr sax,
11967	void user_data, int depth, const xmlChar string, xmlNodePtr *lst,
11968	int recover) {
11969	xmlParserCtxtPtr ctxt;
11970	xmlDocPtr newDoc;
11971	xmlSAXHandlerPtr oldsax = NULL;
11972	xmlNodePtr content, newRoot;
11973	int size;
11974	int ret = 0;
11975
11976	if (depth > 40) {
11977	return(XML_ERR_ENTITY_LOOP);
11978	}
11979
11980
11981	if (lst != NULL)
11982	*lst = NULL;
11983	if (string == NULL)
11984	return(-1);
11985
11986	size = xmlStrlen(string);
11987
11988	ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
11989	if (ctxt == NULL) return(-1);
11990	ctxt->userData = ctxt;
11991	if (sax != NULL) {
11992	oldsax = ctxt->sax;
11993	ctxt->sax = sax;
11994	if (user_data != NULL)
11995	ctxt->userData = user_data;
11996	}
11997	newDoc = xmlNewDoc(BAD_CAST "1.0");
11998	if (newDoc == NULL) {
11999	xmlFreeParserCtxt(ctxt);
12000	return(-1);
12001	}
12002	if ((doc != NULL) && (doc->dict != NULL)) {
12003	xmlDictFree(ctxt->dict);
12004	ctxt->dict = doc->dict;
12005	xmlDictReference(ctxt->dict);
12006	ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
12007	ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
12008	ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
12009	ctxt->dictNames = 1;
12010	} else {
12011	xmlCtxtUseOptions(ctxt, XML_PARSE_NODICT);
12012	}
12013	if (doc != NULL) {
12014	newDoc->intSubset = doc->intSubset;
12015	newDoc->extSubset = doc->extSubset;
12016	}
12017	newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
12018	if (newRoot == NULL) {
12019	if (sax != NULL)
12020	ctxt->sax = oldsax;
12021	xmlFreeParserCtxt(ctxt);
12022	newDoc->intSubset = NULL;
12023	newDoc->extSubset = NULL;
12024	xmlFreeDoc(newDoc);
12025	return(-1);
12026	}
12027	xmlAddChild((xmlNodePtr) newDoc, newRoot);
12028	nodePush(ctxt, newRoot);
12029	if (doc == NULL) {
12030	ctxt->myDoc = newDoc;
12031	} else {
12032	ctxt->myDoc = newDoc;
12033	newDoc->children->doc = doc;
12034	/* Ensure that doc has XML spec namespace */
12035	xmlSearchNsByHref(doc, (xmlNodePtr)doc, XML_XML_NAMESPACE);
12036	newDoc->oldNs = doc->oldNs;
12037	}
12038	ctxt->instate = XML_PARSER_CONTENT;
12039	ctxt->depth = depth;
12040
12041	/*
12042	* Doing validity checking on chunk doesn't make sense
12043	*/
12044	ctxt->validate = 0;
12045	ctxt->loadsubset = 0;
12046	xmlDetectSAX2(ctxt);
12047
12048	if ( doc != NULL ){
12049	content = doc->children;
12050	doc->children = NULL;
12051	xmlParseContent(ctxt);
12052	doc->children = content;
12053	}
12054	else {
12055	xmlParseContent(ctxt);
12056	}
12057	if ((RAW == '<') && (NXT(1) == '/')) {
12058	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12059	} else if (RAW != 0) {
12060	xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
12061	}
12062	if (ctxt->node != newDoc->children) {
12063	xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12064	}
12065
12066	if (!ctxt->wellFormed) {
12067	if (ctxt->errNo == 0)
12068	ret = 1;
12069	else
12070	ret = ctxt->errNo;
12071	} else {
12072	ret = 0;
12073	}
12074
12075	if ((lst != NULL) && ((ret == 0) \|\| (recover == 1))) {
12076	xmlNodePtr cur;
12077
12078	/*
12079	* Return the newly created nodeset after unlinking it from
12080	* they pseudo parent.
12081	*/
12082	cur = newDoc->children->children;
12083	*lst = cur;
12084	while (cur != NULL) {
12085	xmlSetTreeDoc(cur, doc);
12086	cur->parent = NULL;
12087	cur = cur->next;
12088	}
12089	newDoc->children->children = NULL;
12090	}
12091
12092	if (sax != NULL)
12093	ctxt->sax = oldsax;
12094	xmlFreeParserCtxt(ctxt);
12095	newDoc->intSubset = NULL;
12096	newDoc->extSubset = NULL;
12097	newDoc->oldNs = NULL;
12098	xmlFreeDoc(newDoc);
12099
12100	return(ret);
12101	}
12102
12103	/**
12104	* xmlSAXParseEntity:
12105	* @sax: the SAX handler block
12106	* @filename: the filename
12107	*
12108	* parse an XML external entity out of context and build a tree.
12109	* It use the given SAX function block to handle the parsing callback.
12110	* If sax is NULL, fallback to the default DOM tree building routines.
12111	*
12112	* [78] extParsedEnt ::= TextDecl? content
12113	*
12114	* This correspond to a "Well Balanced" chunk
12115	*
12116	* Returns the resulting document tree
12117	*/
12118
12119	xmlDocPtr
12120	xmlSAXParseEntity(xmlSAXHandlerPtr sax, const char *filename) {
12121	xmlDocPtr ret;
12122	xmlParserCtxtPtr ctxt;
12123
12124	ctxt = xmlCreateFileParserCtxt(filename);
12125	if (ctxt == NULL) {
12126	return(NULL);
12127	}
12128	if (sax != NULL) {
12129	if (ctxt->sax != NULL)
12130	xmlFree(ctxt->sax);
12131	ctxt->sax = sax;
12132	ctxt->userData = NULL;
12133	}
12134
12135	xmlParseExtParsedEnt(ctxt);
12136
12137	if (ctxt->wellFormed)
12138	ret = ctxt->myDoc;
12139	else {
12140	ret = NULL;
12141	xmlFreeDoc(ctxt->myDoc);
12142	ctxt->myDoc = NULL;
12143	}
12144	if (sax != NULL)
12145	ctxt->sax = NULL;
12146	xmlFreeParserCtxt(ctxt);
12147
12148	return(ret);
12149	}
12150
12151	/**
12152	* xmlParseEntity:
12153	* @filename: the filename
12154	*
12155	* parse an XML external entity out of context and build a tree.
12156	*
12157	* [78] extParsedEnt ::= TextDecl? content
12158	*
12159	* This correspond to a "Well Balanced" chunk
12160	*
12161	* Returns the resulting document tree
12162	*/
12163
12164	xmlDocPtr
12165	xmlParseEntity(const char *filename) {
12166	return(xmlSAXParseEntity(NULL, filename));
12167	}
12168	#endif /* LIBXML_SAX1_ENABLED */
12169
12170	/**
12171	* xmlCreateEntityParserCtxt:
12172	* @URL: the entity URL
12173	* @ID: the entity PUBLIC ID
12174	* @base: a possible base for the target URI
12175	*
12176	* Create a parser context for an external entity
12177	* Automatic support for ZLIB/Compress compressed document is provided
12178	* by default if found at compile-time.
12179	*
12180	* Returns the new parser context or NULL
12181	*/
12182	xmlParserCtxtPtr
12183	xmlCreateEntityParserCtxt(const xmlChar URL, const xmlChar ID,
12184	const xmlChar *base) {
12185	xmlParserCtxtPtr ctxt;
12186	xmlParserInputPtr inputStream;
12187	char *directory = NULL;
12188	xmlChar *uri;
12189
12190	ctxt = xmlNewParserCtxt();
12191	if (ctxt == NULL) {
12192	return(NULL);
12193	}
12194
12195	uri = xmlBuildURI(URL, base);
12196
12197	if (uri == NULL) {
12198	inputStream = xmlLoadExternalEntity((char )URL, (char )ID, ctxt);
12199	if (inputStream == NULL) {
12200	xmlFreeParserCtxt(ctxt);
12201	return(NULL);
12202	}
12203
12204	inputPush(ctxt, inputStream);
12205
12206	if ((ctxt->directory == NULL) && (directory == NULL))
12207	directory = xmlParserGetDirectory((char *)URL);
12208	if ((ctxt->directory == NULL) && (directory != NULL))
12209	ctxt->directory = directory;
12210	} else {
12211	inputStream = xmlLoadExternalEntity((char )uri, (char )ID, ctxt);
12212	if (inputStream == NULL) {
12213	xmlFree(uri);
12214	xmlFreeParserCtxt(ctxt);
12215	return(NULL);
12216	}
12217
12218	inputPush(ctxt, inputStream);
12219
12220	if ((ctxt->directory == NULL) && (directory == NULL))
12221	directory = xmlParserGetDirectory((char *)uri);
12222	if ((ctxt->directory == NULL) && (directory != NULL))
12223	ctxt->directory = directory;
12224	xmlFree(uri);
12225	}
12226	return(ctxt);
12227	}
12228
12229	/************************************************************************
12230	* *
12231	* Front ends when parsing from a file *
12232	* *
12233	************************************************************************/
12234
12235	/**
12236	* xmlCreateURLParserCtxt:
12237	* @filename: the filename or URL
12238	* @options: a combination of xmlParserOption
12239	*
12240	* Create a parser context for a file or URL content.
12241	* Automatic support for ZLIB/Compress compressed document is provided
12242	* by default if found at compile-time and for file accesses
12243	*
12244	* Returns the new parser context or NULL
12245	*/
12246	xmlParserCtxtPtr
12247	xmlCreateURLParserCtxt(const char *filename, int options)
12248	{
12249	xmlParserCtxtPtr ctxt;
12250	xmlParserInputPtr inputStream;
12251	char *directory = NULL;
12252
12253	ctxt = xmlNewParserCtxt();
12254	if (ctxt == NULL) {
12255	xmlErrMemory(NULL, "cannot allocate parser context");
12256	return(NULL);
12257	}
12258
12259	if (options)
12260	xmlCtxtUseOptions(ctxt, options);
12261	ctxt->linenumbers = 1;
12262
12263	inputStream = xmlLoadExternalEntity(filename, NULL, ctxt);
12264	if (inputStream == NULL) {
12265	xmlFreeParserCtxt(ctxt);
12266	return(NULL);
12267	}
12268
12269	inputPush(ctxt, inputStream);
12270	if ((ctxt->directory == NULL) && (directory == NULL))
12271	directory = xmlParserGetDirectory(filename);
12272	if ((ctxt->directory == NULL) && (directory != NULL))
12273	ctxt->directory = directory;
12274
12275	return(ctxt);
12276	}
12277
12278	/**
12279	* xmlCreateFileParserCtxt:
12280	* @filename: the filename
12281	*
12282	* Create a parser context for a file content.
12283	* Automatic support for ZLIB/Compress compressed document is provided
12284	* by default if found at compile-time.
12285	*
12286	* Returns the new parser context or NULL
12287	*/
12288	xmlParserCtxtPtr
12289	xmlCreateFileParserCtxt(const char *filename)
12290	{
12291	return(xmlCreateURLParserCtxt(filename, 0));
12292	}
12293
12294	#ifdef LIBXML_SAX1_ENABLED
12295	/**
12296	* xmlSAXParseFileWithData:
12297	* @sax: the SAX handler block
12298	* @filename: the filename
12299	* @recovery: work in recovery mode, i.e. tries to read no Well Formed
12300	* documents
12301	* @data: the userdata
12302	*
12303	* parse an XML file and build a tree. Automatic support for ZLIB/Compress
12304	* compressed document is provided by default if found at compile-time.
12305	* It use the given SAX function block to handle the parsing callback.
12306	* If sax is NULL, fallback to the default DOM tree building routines.
12307	*
12308	* User data (void *) is stored within the parser context in the
12309	* context's _private member, so it is available nearly everywhere in libxml
12310	*
12311	* Returns the resulting document tree
12312	*/
12313
12314	xmlDocPtr
12315	xmlSAXParseFileWithData(xmlSAXHandlerPtr sax, const char *filename,
12316	int recovery, void *data) {
12317	xmlDocPtr ret;
12318	xmlParserCtxtPtr ctxt;
12319	char *directory = NULL;
12320
12321	xmlInitParser();
12322
12323	ctxt = xmlCreateFileParserCtxt(filename);
12324	if (ctxt == NULL) {
12325	return(NULL);
12326	}
12327	if (sax != NULL) {
12328	if (ctxt->sax != NULL)
12329	xmlFree(ctxt->sax);
12330	ctxt->sax = sax;
12331	}
12332	xmlDetectSAX2(ctxt);
12333	if (data!=NULL) {
12334	ctxt->_private = data;
12335	}
12336
12337	if ((ctxt->directory == NULL) && (directory == NULL))
12338	directory = xmlParserGetDirectory(filename);
12339	if ((ctxt->directory == NULL) && (directory != NULL))
12340	ctxt->directory = (char ) xmlStrdup((xmlChar ) directory);
12341
12342	ctxt->recovery = recovery;
12343
12344	xmlParseDocument(ctxt);
12345
12346	if ((ctxt->wellFormed) \|\| recovery) {
12347	ret = ctxt->myDoc;
12348	if (ret != NULL) {
12349	if (ctxt->input->buf->compressed > 0)
12350	ret->compression = 9;
12351	else
12352	ret->compression = ctxt->input->buf->compressed;
12353	}
12354	}
12355	else {
12356	ret = NULL;
12357	xmlFreeDoc(ctxt->myDoc);
12358	ctxt->myDoc = NULL;
12359	}
12360	if (sax != NULL)
12361	ctxt->sax = NULL;
12362	xmlFreeParserCtxt(ctxt);
12363
12364	return(ret);
12365	}
12366
12367	/**
12368	* xmlSAXParseFile:
12369	* @sax: the SAX handler block
12370	* @filename: the filename
12371	* @recovery: work in recovery mode, i.e. tries to read no Well Formed
12372	* documents
12373	*
12374	* parse an XML file and build a tree. Automatic support for ZLIB/Compress
12375	* compressed document is provided by default if found at compile-time.
12376	* It use the given SAX function block to handle the parsing callback.
12377	* If sax is NULL, fallback to the default DOM tree building routines.
12378	*
12379	* Returns the resulting document tree
12380	*/
12381
12382	xmlDocPtr
12383	xmlSAXParseFile(xmlSAXHandlerPtr sax, const char *filename,
12384	int recovery) {
12385	return(xmlSAXParseFileWithData(sax,filename,recovery,NULL));
12386	}
12387
12388	/**
12389	* xmlRecoverDoc:
12390	* @cur: a pointer to an array of xmlChar
12391	*
12392	* parse an XML in-memory document and build a tree.
12393	* In the case the document is not Well Formed, a tree is built anyway
12394	*
12395	* Returns the resulting document tree
12396	*/
12397
12398	xmlDocPtr
12399	xmlRecoverDoc(xmlChar *cur) {
12400	return(xmlSAXParseDoc(NULL, cur, 1));
12401	}
12402
12403	/**
12404	* xmlParseFile:
12405	* @filename: the filename
12406	*
12407	* parse an XML file and build a tree. Automatic support for ZLIB/Compress
12408	* compressed document is provided by default if found at compile-time.
12409	*
12410	* Returns the resulting document tree if the file was wellformed,
12411	* NULL otherwise.
12412	*/
12413
12414	xmlDocPtr
12415	xmlParseFile(const char *filename) {
12416	return(xmlSAXParseFile(NULL, filename, 0));
12417	}
12418
12419	/**
12420	* xmlRecoverFile:
12421	* @filename: the filename
12422	*
12423	* parse an XML file and build a tree. Automatic support for ZLIB/Compress
12424	* compressed document is provided by default if found at compile-time.
12425	* In the case the document is not Well Formed, a tree is built anyway
12426	*
12427	* Returns the resulting document tree
12428	*/
12429
12430	xmlDocPtr
12431	xmlRecoverFile(const char *filename) {
12432	return(xmlSAXParseFile(NULL, filename, 1));
12433	}
12434
12435
12436	/**
12437	* xmlSetupParserForBuffer:
12438	* @ctxt: an XML parser context
12439	* @buffer: a xmlChar * buffer
12440	* @filename: a file name
12441	*
12442	* Setup the parser context to parse a new buffer; Clears any prior
12443	* contents from the parser context. The buffer parameter must not be
12444	* NULL, but the filename parameter can be
12445	*/
12446	void
12447	xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer,
12448	const char* filename)
12449	{
12450	xmlParserInputPtr input;
12451
12452	if ((ctxt == NULL) \|\| (buffer == NULL))
12453	return;
12454
12455	input = xmlNewInputStream(ctxt);
12456	if (input == NULL) {
12457	xmlErrMemory(NULL, "parsing new buffer: out of memory\n");
12458	xmlClearParserCtxt(ctxt);
12459	return;
12460	}
12461
12462	xmlClearParserCtxt(ctxt);
12463	if (filename != NULL)
12464	input->filename = (char ) xmlCanonicPath((const xmlChar )filename);
12465	input->base = buffer;
12466	input->cur = buffer;
12467	input->end = &buffer[xmlStrlen(buffer)];
12468	inputPush(ctxt, input);
12469	}
12470
12471	/**
12472	* xmlSAXUserParseFile:
12473	* @sax: a SAX handler
12474	* @user_data: The user data returned on SAX callbacks
12475	* @filename: a file name
12476	*
12477	* parse an XML file and call the given SAX handler routines.
12478	* Automatic support for ZLIB/Compress compressed document is provided
12479	*
12480	* Returns 0 in case of success or a error number otherwise
12481	*/
12482	int
12483	xmlSAXUserParseFile(xmlSAXHandlerPtr sax, void *user_data,
12484	const char *filename) {
12485	int ret = 0;
12486	xmlParserCtxtPtr ctxt;
12487
12488	ctxt = xmlCreateFileParserCtxt(filename);
12489	if (ctxt == NULL) return -1;
12490	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12491	xmlFree(ctxt->sax);
12492	ctxt->sax = sax;
12493	xmlDetectSAX2(ctxt);
12494
12495	if (user_data != NULL)
12496	ctxt->userData = user_data;
12497
12498	xmlParseDocument(ctxt);
12499
12500	if (ctxt->wellFormed)
12501	ret = 0;
12502	else {
12503	if (ctxt->errNo != 0)
12504	ret = ctxt->errNo;
12505	else
12506	ret = -1;
12507	}
12508	if (sax != NULL)
12509	ctxt->sax = NULL;
12510	if (ctxt->myDoc != NULL) {
12511	xmlFreeDoc(ctxt->myDoc);
12512	ctxt->myDoc = NULL;
12513	}
12514	xmlFreeParserCtxt(ctxt);
12515
12516	return ret;
12517	}
12518	#endif /* LIBXML_SAX1_ENABLED */
12519
12520	/************************************************************************
12521	* *
12522	* Front ends when parsing from memory *
12523	* *
12524	************************************************************************/
12525
12526	/**
12527	* xmlCreateMemoryParserCtxt:
12528	* @buffer: a pointer to a char array
12529	* @size: the size of the array
12530	*
12531	* Create a parser context for an XML in-memory document.
12532	*
12533	* Returns the new parser context or NULL
12534	*/
12535	xmlParserCtxtPtr
12536	xmlCreateMemoryParserCtxt(const char *buffer, int size) {
12537	xmlParserCtxtPtr ctxt;
12538	xmlParserInputPtr input;
12539	xmlParserInputBufferPtr buf;
12540
12541	if (buffer == NULL)
12542	return(NULL);
12543	if (size <= 0)
12544	return(NULL);
12545
12546	ctxt = xmlNewParserCtxt();
12547	if (ctxt == NULL)
12548	return(NULL);
12549
12550	/* TODO: xmlParserInputBufferCreateStatic, requires some serious changes */
12551	buf = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
12552	if (buf == NULL) {
12553	xmlFreeParserCtxt(ctxt);
12554	return(NULL);
12555	}
12556
12557	input = xmlNewInputStream(ctxt);
12558	if (input == NULL) {
12559	xmlFreeParserInputBuffer(buf);
12560	xmlFreeParserCtxt(ctxt);
12561	return(NULL);
12562	}
12563
12564	input->filename = NULL;
12565	input->buf = buf;
12566	input->base = input->buf->buffer->content;
12567	input->cur = input->buf->buffer->content;
12568	input->end = &input->buf->buffer->content[input->buf->buffer->use];
12569
12570	inputPush(ctxt, input);
12571	return(ctxt);
12572	}
12573
12574	#ifdef LIBXML_SAX1_ENABLED
12575	/**
12576	* xmlSAXParseMemoryWithData:
12577	* @sax: the SAX handler block
12578	* @buffer: an pointer to a char array
12579	* @size: the size of the array
12580	* @recovery: work in recovery mode, i.e. tries to read no Well Formed
12581	* documents
12582	* @data: the userdata
12583	*
12584	* parse an XML in-memory block and use the given SAX function block
12585	* to handle the parsing callback. If sax is NULL, fallback to the default
12586	* DOM tree building routines.
12587	*
12588	* User data (void *) is stored within the parser context in the
12589	* context's _private member, so it is available nearly everywhere in libxml
12590	*
12591	* Returns the resulting document tree
12592	*/
12593
12594	xmlDocPtr
12595	xmlSAXParseMemoryWithData(xmlSAXHandlerPtr sax, const char *buffer,
12596	int size, int recovery, void *data) {
12597	xmlDocPtr ret;
12598	xmlParserCtxtPtr ctxt;
12599
12600	ctxt = xmlCreateMemoryParserCtxt(buffer, size);
12601	if (ctxt == NULL) return(NULL);
12602	if (sax != NULL) {
12603	if (ctxt->sax != NULL)
12604	xmlFree(ctxt->sax);
12605	ctxt->sax = sax;
12606	}
12607	xmlDetectSAX2(ctxt);
12608	if (data!=NULL) {
12609	ctxt->_private=data;
12610	}
12611
12612	ctxt->recovery = recovery;
12613
12614	xmlParseDocument(ctxt);
12615
12616	if ((ctxt->wellFormed) \|\| recovery) ret = ctxt->myDoc;
12617	else {
12618	ret = NULL;
12619	xmlFreeDoc(ctxt->myDoc);
12620	ctxt->myDoc = NULL;
12621	}
12622	if (sax != NULL)
12623	ctxt->sax = NULL;
12624	xmlFreeParserCtxt(ctxt);
12625
12626	return(ret);
12627	}
12628
12629	/**
12630	* xmlSAXParseMemory:
12631	* @sax: the SAX handler block
12632	* @buffer: an pointer to a char array
12633	* @size: the size of the array
12634	* @recovery: work in recovery mode, i.e. tries to read not Well Formed
12635	* documents
12636	*
12637	* parse an XML in-memory block and use the given SAX function block
12638	* to handle the parsing callback. If sax is NULL, fallback to the default
12639	* DOM tree building routines.
12640	*
12641	* Returns the resulting document tree
12642	*/
12643	xmlDocPtr
12644	xmlSAXParseMemory(xmlSAXHandlerPtr sax, const char *buffer,
12645	int size, int recovery) {
12646	return xmlSAXParseMemoryWithData(sax, buffer, size, recovery, NULL);
12647	}
12648
12649	/**
12650	* xmlParseMemory:
12651	* @buffer: an pointer to a char array
12652	* @size: the size of the array
12653	*
12654	* parse an XML in-memory block and build a tree.
12655	*
12656	* Returns the resulting document tree
12657	*/
12658
12659	xmlDocPtr xmlParseMemory(const char *buffer, int size) {
12660	return(xmlSAXParseMemory(NULL, buffer, size, 0));
12661	}
12662
12663	/**
12664	* xmlRecoverMemory:
12665	* @buffer: an pointer to a char array
12666	* @size: the size of the array
12667	*
12668	* parse an XML in-memory block and build a tree.
12669	* In the case the document is not Well Formed, a tree is built anyway
12670	*
12671	* Returns the resulting document tree
12672	*/
12673
12674	xmlDocPtr xmlRecoverMemory(const char *buffer, int size) {
12675	return(xmlSAXParseMemory(NULL, buffer, size, 1));
12676	}
12677
12678	/**
12679	* xmlSAXUserParseMemory:
12680	* @sax: a SAX handler
12681	* @user_data: The user data returned on SAX callbacks
12682	* @buffer: an in-memory XML document input
12683	* @size: the length of the XML document in bytes
12684	*
12685	* A better SAX parsing routine.
12686	* parse an XML in-memory buffer and call the given SAX handler routines.
12687	*
12688	* Returns 0 in case of success or a error number otherwise
12689	*/
12690	int xmlSAXUserParseMemory(xmlSAXHandlerPtr sax, void *user_data,
12691	const char *buffer, int size) {
12692	int ret = 0;
12693	xmlParserCtxtPtr ctxt;
12694
12695	ctxt = xmlCreateMemoryParserCtxt(buffer, size);
12696	if (ctxt == NULL) return -1;
12697	if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12698	xmlFree(ctxt->sax);
12699	ctxt->sax = sax;
12700	xmlDetectSAX2(ctxt);
12701
12702	if (user_data != NULL)
12703	ctxt->userData = user_data;
12704
12705	xmlParseDocument(ctxt);
12706
12707	if (ctxt->wellFormed)
12708	ret = 0;
12709	else {
12710	if (ctxt->errNo != 0)
12711	ret = ctxt->errNo;
12712	else
12713	ret = -1;
12714	}
12715	if (sax != NULL)
12716	ctxt->sax = NULL;
12717	if (ctxt->myDoc != NULL) {
12718	xmlFreeDoc(ctxt->myDoc);
12719	ctxt->myDoc = NULL;
12720	}
12721	xmlFreeParserCtxt(ctxt);
12722
12723	return ret;
12724	}
12725	#endif /* LIBXML_SAX1_ENABLED */
12726
12727	/**
12728	* xmlCreateDocParserCtxt:
12729	* @cur: a pointer to an array of xmlChar
12730	*
12731	* Creates a parser context for an XML in-memory document.
12732	*
12733	* Returns the new parser context or NULL
12734	*/
12735	xmlParserCtxtPtr
12736	xmlCreateDocParserCtxt(const xmlChar *cur) {
12737	int len;
12738
12739	if (cur == NULL)
12740	return(NULL);
12741	len = xmlStrlen(cur);
12742	return(xmlCreateMemoryParserCtxt((const char *)cur, len));
12743	}
12744
12745	#ifdef LIBXML_SAX1_ENABLED
12746	/**
12747	* xmlSAXParseDoc:
12748	* @sax: the SAX handler block
12749	* @cur: a pointer to an array of xmlChar
12750	* @recovery: work in recovery mode, i.e. tries to read no Well Formed
12751	* documents
12752	*
12753	* parse an XML in-memory document and build a tree.
12754	* It use the given SAX function block to handle the parsing callback.
12755	* If sax is NULL, fallback to the default DOM tree building routines.
12756	*
12757	* Returns the resulting document tree
12758	*/
12759
12760	xmlDocPtr
12761	xmlSAXParseDoc(xmlSAXHandlerPtr sax, const xmlChar *cur, int recovery) {
12762	xmlDocPtr ret;
12763	xmlParserCtxtPtr ctxt;
12764	xmlSAXHandlerPtr oldsax = NULL;
12765
12766	if (cur == NULL) return(NULL);
12767
12768
12769	ctxt = xmlCreateDocParserCtxt(cur);
12770	if (ctxt == NULL) return(NULL);
12771	if (sax != NULL) {
12772	oldsax = ctxt->sax;
12773	ctxt->sax = sax;
12774	ctxt->userData = NULL;
12775	}
12776	xmlDetectSAX2(ctxt);
12777
12778	xmlParseDocument(ctxt);
12779	if ((ctxt->wellFormed) \|\| recovery) ret = ctxt->myDoc;
12780	else {
12781	ret = NULL;
12782	xmlFreeDoc(ctxt->myDoc);
12783	ctxt->myDoc = NULL;
12784	}
12785	if (sax != NULL)
12786	ctxt->sax = oldsax;
12787	xmlFreeParserCtxt(ctxt);
12788
12789	return(ret);
12790	}
12791
12792	/**
12793	* xmlParseDoc:
12794	* @cur: a pointer to an array of xmlChar
12795	*
12796	* parse an XML in-memory document and build a tree.
12797	*
12798	* Returns the resulting document tree
12799	*/
12800
12801	xmlDocPtr
12802	xmlParseDoc(const xmlChar *cur) {
12803	return(xmlSAXParseDoc(NULL, cur, 0));
12804	}
12805	#endif /* LIBXML_SAX1_ENABLED */
12806
12807	#ifdef LIBXML_LEGACY_ENABLED
12808	/************************************************************************
12809	* *
12810	* Specific function to keep track of entities references *
12811	* and used by the XSLT debugger *
12812	* *
12813	************************************************************************/
12814
12815	static xmlEntityReferenceFunc xmlEntityRefFunc = NULL;
12816
12817	/**
12818	* xmlAddEntityReference:
12819	* @ent : A valid entity
12820	* @firstNode : A valid first node for children of entity
12821	* @lastNode : A valid last node of children entity
12822	*
12823	* Notify of a reference to an entity of type XML_EXTERNAL_GENERAL_PARSED_ENTITY
12824	*/
12825	static void
12826	xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
12827	xmlNodePtr lastNode)
12828	{
12829	if (xmlEntityRefFunc != NULL) {
12830	(*xmlEntityRefFunc) (ent, firstNode, lastNode);
12831	}
12832	}
12833
12834
12835	/**
12836	* xmlSetEntityReferenceFunc:
12837	* @func: A valid function
12838	*
12839	* Set the function to call call back when a xml reference has been made
12840	*/
12841	void
12842	xmlSetEntityReferenceFunc(xmlEntityReferenceFunc func)
12843	{
12844	xmlEntityRefFunc = func;
12845	}
12846	#endif /* LIBXML_LEGACY_ENABLED */
12847
12848	/************************************************************************
12849	* *
12850	* Miscellaneous *
12851	* *
12852	************************************************************************/
12853
12854	#ifdef LIBXML_XPATH_ENABLED
12855	#include <libxml/xpath.h>
12856	#endif
12857
12858	extern void XMLCDECL xmlGenericErrorDefaultFunc(void ctx, const char msg, ...);
12859	static int xmlParserInitialized = 0;
12860
12861	/**
12862	* xmlInitParser:
12863	*
12864	* Initialization function for the XML parser.
12865	* This is not reentrant. Call once before processing in case of
12866	* use in multithreaded programs.
12867	*/
12868
12869	void
12870	xmlInitParser(void) {
12871	if (xmlParserInitialized != 0)
12872	return;
12873
12874	#ifdef LIBXML_THREAD_ENABLED
12875	__xmlGlobalInitMutexLock();
12876	if (xmlParserInitialized == 0) {
12877	#endif
12878	if ((xmlGenericError == xmlGenericErrorDefaultFunc) \|\|
12879	(xmlGenericError == NULL))
12880	initGenericErrorDefaultFunc(NULL);
12881	xmlInitGlobals();
12882	xmlInitThreads();
12883	xmlInitMemory();
12884	xmlInitCharEncodingHandlers();
12885	xmlDefaultSAXHandlerInit();
12886	xmlRegisterDefaultInputCallbacks();
12887	#ifdef LIBXML_OUTPUT_ENABLED
12888	xmlRegisterDefaultOutputCallbacks();
12889	#endif /* LIBXML_OUTPUT_ENABLED */
12890	#ifdef LIBXML_HTML_ENABLED
12891	htmlInitAutoClose();
12892	htmlDefaultSAXHandlerInit();
12893	#endif
12894	#ifdef LIBXML_XPATH_ENABLED
12895	xmlXPathInit();
12896	#endif
12897	xmlParserInitialized = 1;
12898	#ifdef LIBXML_THREAD_ENABLED
12899	}
12900	__xmlGlobalInitMutexUnlock();
12901	#endif
12902	}
12903
12904	/**
12905	* xmlCleanupParser:
12906	*
12907	* Cleanup function for the XML library. It tries to reclaim all
12908	* parsing related global memory allocated for the library processing.
12909	* It doesn't deallocate any document related memory. Calling this
12910	* function should not prevent reusing the library but one should
12911	* call xmlCleanupParser() only when the process has
12912	* finished using the library or XML document built with it.
12913	*/
12914
12915	void
12916	xmlCleanupParser(void) {
12917	if (!xmlParserInitialized)
12918	return;
12919
12920	xmlCleanupCharEncodingHandlers();
12921	#ifdef LIBXML_CATALOG_ENABLED
12922	xmlCatalogCleanup();
12923	#endif
12924	xmlDictCleanup();
12925	xmlCleanupInputCallbacks();
12926	#ifdef LIBXML_OUTPUT_ENABLED
12927	xmlCleanupOutputCallbacks();
12928	#endif
12929	#ifdef LIBXML_SCHEMAS_ENABLED
12930	xmlSchemaCleanupTypes();
12931	xmlRelaxNGCleanupTypes();
12932	#endif
12933	xmlCleanupGlobals();
12934	xmlResetLastError();
12935	xmlCleanupThreads(); /* must be last if called not from the main thread */
12936	xmlCleanupMemory();
12937	xmlParserInitialized = 0;
12938	}
12939
12940	/************************************************************************
12941	* *
12942	* New set (2.6.0) of simpler and more flexible APIs *
12943	* *
12944	************************************************************************/
12945
12946	/**
12947	* DICT_FREE:
12948	* @str: a string
12949	*
12950	* Free a string if it is not owned by the "dict" dictionnary in the
12951	* current scope
12952	*/
12953	#define DICT_FREE(str) \
12954	if ((str) && ((!dict) \|\| \
12955	(xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \
12956	xmlFree((char *)(str));
12957
12958	/**
12959	* xmlCtxtReset:
12960	* @ctxt: an XML parser context
12961	*
12962	* Reset a parser context
12963	*/
12964	void
12965	xmlCtxtReset(xmlParserCtxtPtr ctxt)
12966	{
12967	xmlParserInputPtr input;
12968	xmlDictPtr dict;
12969
12970	if (ctxt == NULL)
12971	return;
12972
12973	dict = ctxt->dict;
12974
12975	while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
12976	xmlFreeInputStream(input);
12977	}
12978	ctxt->inputNr = 0;
12979	ctxt->input = NULL;
12980
12981	ctxt->spaceNr = 0;
12982	if (ctxt->spaceTab != NULL) {
12983	ctxt->spaceTab[0] = -1;
12984	ctxt->space = &ctxt->spaceTab[0];
12985	} else {
12986	ctxt->space = NULL;
12987	}
12988
12989
12990	ctxt->nodeNr = 0;
12991	ctxt->node = NULL;
12992
12993	ctxt->nameNr = 0;
12994	ctxt->name = NULL;
12995
12996	DICT_FREE(ctxt->version);
12997	ctxt->version = NULL;
12998	DICT_FREE(ctxt->encoding);
12999	ctxt->encoding = NULL;
13000	DICT_FREE(ctxt->directory);
13001	ctxt->directory = NULL;
13002	DICT_FREE(ctxt->extSubURI);
13003	ctxt->extSubURI = NULL;
13004	DICT_FREE(ctxt->extSubSystem);
13005	ctxt->extSubSystem = NULL;
13006	if (ctxt->myDoc != NULL)
13007	xmlFreeDoc(ctxt->myDoc);
13008	ctxt->myDoc = NULL;
13009
13010	ctxt->standalone = -1;
13011	ctxt->hasExternalSubset = 0;
13012	ctxt->hasPErefs = 0;
13013	ctxt->html = 0;
13014	ctxt->external = 0;
13015	ctxt->instate = XML_PARSER_START;
13016	ctxt->token = 0;
13017
13018	ctxt->wellFormed = 1;
13019	ctxt->nsWellFormed = 1;
13020	ctxt->disableSAX = 0;
13021	ctxt->valid = 1;
13022	#if 0
13023	ctxt->vctxt.userData = ctxt;
13024	ctxt->vctxt.error = xmlParserValidityError;
13025	ctxt->vctxt.warning = xmlParserValidityWarning;
13026	#endif
13027	ctxt->record_info = 0;
13028	ctxt->nbChars = 0;
13029	ctxt->checkIndex = 0;
13030	ctxt->inSubset = 0;
13031	ctxt->errNo = XML_ERR_OK;
13032	ctxt->depth = 0;
13033	ctxt->charset = XML_CHAR_ENCODING_UTF8;
13034	ctxt->catalogs = NULL;
13035	xmlInitNodeInfoSeq(&ctxt->node_seq);
13036
13037	if (ctxt->attsDefault != NULL) {
13038	xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
13039	ctxt->attsDefault = NULL;
13040	}
13041	if (ctxt->attsSpecial != NULL) {
13042	xmlHashFree(ctxt->attsSpecial, NULL);
13043	ctxt->attsSpecial = NULL;
13044	}
13045
13046	#ifdef LIBXML_CATALOG_ENABLED
13047	if (ctxt->catalogs != NULL)
13048	xmlCatalogFreeLocal(ctxt->catalogs);
13049	#endif
13050	if (ctxt->lastError.code != XML_ERR_OK)
13051	xmlResetError(&ctxt->lastError);
13052	}
13053
13054	/**
13055	* xmlCtxtResetPush:
13056	* @ctxt: an XML parser context
13057	* @chunk: a pointer to an array of chars
13058	* @size: number of chars in the array
13059	* @filename: an optional file name or URI
13060	* @encoding: the document encoding, or NULL
13061	*
13062	* Reset a push parser context
13063	*
13064	* Returns 0 in case of success and 1 in case of error
13065	*/
13066	int
13067	xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk,
13068	int size, const char filename, const char encoding)
13069	{
13070	xmlParserInputPtr inputStream;
13071	xmlParserInputBufferPtr buf;
13072	xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
13073
13074	if (ctxt == NULL)
13075	return(1);
13076
13077	if ((encoding == NULL) && (chunk != NULL) && (size >= 4))
13078	enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
13079
13080	buf = xmlAllocParserInputBuffer(enc);
13081	if (buf == NULL)
13082	return(1);
13083
13084	if (ctxt == NULL) {
13085	xmlFreeParserInputBuffer(buf);
13086	return(1);
13087	}
13088
13089	xmlCtxtReset(ctxt);
13090
13091	if (ctxt->pushTab == NULL) {
13092	ctxt->pushTab = (void *) xmlMalloc(ctxt->nameMax 3 *
13093	sizeof(xmlChar *));
13094	if (ctxt->pushTab == NULL) {
13095	xmlErrMemory(ctxt, NULL);
13096	xmlFreeParserInputBuffer(buf);
13097	return(1);
13098	}
13099	}
13100
13101	if (filename == NULL) {
13102	ctxt->directory = NULL;
13103	} else {
13104	ctxt->directory = xmlParserGetDirectory(filename);
13105	}
13106
13107	inputStream = xmlNewInputStream(ctxt);
13108	if (inputStream == NULL) {
13109	xmlFreeParserInputBuffer(buf);
13110	return(1);
13111	}
13112
13113	if (filename == NULL)
13114	inputStream->filename = NULL;
13115	else
13116	inputStream->filename = (char *)
13117	xmlCanonicPath((const xmlChar *) filename);
13118	inputStream->buf = buf;
13119	inputStream->base = inputStream->buf->buffer->content;
13120	inputStream->cur = inputStream->buf->buffer->content;
13121	inputStream->end =
13122	&inputStream->buf->buffer->content[inputStream->buf->buffer->use];
13123
13124	inputPush(ctxt, inputStream);
13125
13126	if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
13127	(ctxt->input->buf != NULL)) {
13128	int base = ctxt->input->base - ctxt->input->buf->buffer->content;
13129	int cur = ctxt->input->cur - ctxt->input->base;
13130
13131	xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
13132
13133	ctxt->input->base = ctxt->input->buf->buffer->content + base;
13134	ctxt->input->cur = ctxt->input->base + cur;
13135	ctxt->input->end =
13136	&ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->
13137	use];
13138	#ifdef DEBUG_PUSH
13139	xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
13140	#endif
13141	}
13142
13143	if (encoding != NULL) {
13144	xmlCharEncodingHandlerPtr hdlr;
13145
13146	hdlr = xmlFindCharEncodingHandler(encoding);
13147	if (hdlr != NULL) {
13148	xmlSwitchToEncoding(ctxt, hdlr);
13149	} else {
13150	xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
13151	"Unsupported encoding %s\n", BAD_CAST encoding);
13152	}
13153	} else if (enc != XML_CHAR_ENCODING_NONE) {
13154	xmlSwitchEncoding(ctxt, enc);
13155	}
13156
13157	return(0);
13158	}
13159
13160	/**
13161	* xmlCtxtUseOptions:
13162	* @ctxt: an XML parser context
13163	* @options: a combination of xmlParserOption
13164	*
13165	* Applies the options to the parser context
13166	*
13167	* Returns 0 in case of success, the set of unknown or unimplemented options
13168	* in case of error.
13169	*/
13170	int
13171	xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
13172	{
13173	if (ctxt == NULL)
13174	return(-1);
13175	if (options & XML_PARSE_RECOVER) {
13176	ctxt->recovery = 1;
13177	options -= XML_PARSE_RECOVER;
13178	} else
13179	ctxt->recovery = 0;
13180	if (options & XML_PARSE_DTDLOAD) {
13181	ctxt->loadsubset = XML_DETECT_IDS;
13182	options -= XML_PARSE_DTDLOAD;
13183	} else
13184	ctxt->loadsubset = 0;
13185	if (options & XML_PARSE_DTDATTR) {
13186	ctxt->loadsubset \|= XML_COMPLETE_ATTRS;
13187	options -= XML_PARSE_DTDATTR;
13188	}
13189	if (options & XML_PARSE_NOENT) {
13190	ctxt->replaceEntities = 1;
13191	/* ctxt->loadsubset \|= XML_DETECT_IDS; */
13192	options -= XML_PARSE_NOENT;
13193	} else
13194	ctxt->replaceEntities = 0;
13195	if (options & XML_PARSE_PEDANTIC) {
13196	ctxt->pedantic = 1;
13197	options -= XML_PARSE_PEDANTIC;
13198	} else
13199	ctxt->pedantic = 0;
13200	if (options & XML_PARSE_NOBLANKS) {
13201	ctxt->keepBlanks = 0;
13202	ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
13203	options -= XML_PARSE_NOBLANKS;
13204	} else
13205	ctxt->keepBlanks = 1;
13206	if (options & XML_PARSE_DTDVALID) {
13207	ctxt->validate = 1;
13208	if (options & XML_PARSE_NOWARNING)
13209	ctxt->vctxt.warning = NULL;
13210	if (options & XML_PARSE_NOERROR)
13211	ctxt->vctxt.error = NULL;
13212	options -= XML_PARSE_DTDVALID;
13213	} else
13214	ctxt->validate = 0;
13215	if (options & XML_PARSE_NOWARNING) {
13216	ctxt->sax->warning = NULL;
13217	options -= XML_PARSE_NOWARNING;
13218	}
13219	if (options & XML_PARSE_NOERROR) {
13220	ctxt->sax->error = NULL;
13221	ctxt->sax->fatalError = NULL;
13222	options -= XML_PARSE_NOERROR;
13223	}
13224	#ifdef LIBXML_SAX1_ENABLED
13225	if (options & XML_PARSE_SAX1) {
13226	ctxt->sax->startElement = xmlSAX2StartElement;
13227	ctxt->sax->endElement = xmlSAX2EndElement;
13228	ctxt->sax->startElementNs = NULL;
13229	ctxt->sax->endElementNs = NULL;
13230	ctxt->sax->initialized = 1;
13231	options -= XML_PARSE_SAX1;
13232	}
13233	#endif /* LIBXML_SAX1_ENABLED */
13234	if (options & XML_PARSE_NODICT) {
13235	ctxt->dictNames = 0;
13236	options -= XML_PARSE_NODICT;
13237	} else {
13238	ctxt->dictNames = 1;
13239	}
13240	if (options & XML_PARSE_NOCDATA) {
13241	ctxt->sax->cdataBlock = NULL;
13242	options -= XML_PARSE_NOCDATA;
13243	}
13244	if (options & XML_PARSE_NSCLEAN) {
13245	ctxt->options \|= XML_PARSE_NSCLEAN;
13246	options -= XML_PARSE_NSCLEAN;
13247	}
13248	if (options & XML_PARSE_NONET) {
13249	ctxt->options \|= XML_PARSE_NONET;
13250	options -= XML_PARSE_NONET;
13251	}
13252	if (options & XML_PARSE_COMPACT) {
13253	ctxt->options \|= XML_PARSE_COMPACT;
13254	options -= XML_PARSE_COMPACT;
13255	}
13256	ctxt->linenumbers = 1;
13257	return (options);
13258	}
13259
13260	/**
13261	* xmlDoRead:
13262	* @ctxt: an XML parser context
13263	* @URL: the base URL to use for the document
13264	* @encoding: the document encoding, or NULL
13265	* @options: a combination of xmlParserOption
13266	* @reuse: keep the context for reuse
13267	*
13268	* Common front-end for the xmlRead functions
13269	*
13270	* Returns the resulting document tree or NULL
13271	*/
13272	static xmlDocPtr
13273	xmlDoRead(xmlParserCtxtPtr ctxt, const char URL, const char encoding,
13274	int options, int reuse)
13275	{
13276	xmlDocPtr ret;
13277
13278	xmlCtxtUseOptions(ctxt, options);
13279	if (encoding != NULL) {
13280	xmlCharEncodingHandlerPtr hdlr;
13281
13282	hdlr = xmlFindCharEncodingHandler(encoding);
13283	if (hdlr != NULL)
13284	xmlSwitchToEncoding(ctxt, hdlr);
13285	}
13286	if ((URL != NULL) && (ctxt->input != NULL) &&
13287	(ctxt->input->filename == NULL))
13288	ctxt->input->filename = (char ) xmlStrdup((const xmlChar ) URL);
13289	xmlParseDocument(ctxt);
13290	if ((ctxt->wellFormed) \|\| ctxt->recovery)
13291	ret = ctxt->myDoc;
13292	else {
13293	ret = NULL;
13294	if (ctxt->myDoc != NULL) {
13295	xmlFreeDoc(ctxt->myDoc);
13296	}
13297	}
13298	ctxt->myDoc = NULL;
13299	if (!reuse) {
13300	xmlFreeParserCtxt(ctxt);
13301	}
13302
13303	return (ret);
13304	}
13305
13306	/**
13307	* xmlReadDoc:
13308	* @cur: a pointer to a zero terminated string
13309	* @URL: the base URL to use for the document
13310	* @encoding: the document encoding, or NULL
13311	* @options: a combination of xmlParserOption
13312	*
13313	* parse an XML in-memory document and build a tree.
13314	*
13315	* Returns the resulting document tree
13316	*/
13317	xmlDocPtr
13318	xmlReadDoc(const xmlChar * cur, const char URL, const char encoding, int options)
13319	{
13320	xmlParserCtxtPtr ctxt;
13321
13322	if (cur == NULL)
13323	return (NULL);
13324
13325	ctxt = xmlCreateDocParserCtxt(cur);
13326	if (ctxt == NULL)
13327	return (NULL);
13328	return (xmlDoRead(ctxt, URL, encoding, options, 0));
13329	}
13330
13331	/**
13332	* xmlReadFile:
13333	* @filename: a file or URL
13334	* @encoding: the document encoding, or NULL
13335	* @options: a combination of xmlParserOption
13336	*
13337	* parse an XML file from the filesystem or the network.
13338	*
13339	* Returns the resulting document tree
13340	*/
13341	xmlDocPtr
13342	xmlReadFile(const char filename, const char encoding, int options)
13343	{
13344	xmlParserCtxtPtr ctxt;
13345
13346	ctxt = xmlCreateURLParserCtxt(filename, options);
13347	if (ctxt == NULL)
13348	return (NULL);
13349	return (xmlDoRead(ctxt, NULL, encoding, options, 0));
13350	}
13351
13352	/**
13353	* xmlReadMemory:
13354	* @buffer: a pointer to a char array
13355	* @size: the size of the array
13356	* @URL: the base URL to use for the document
13357	* @encoding: the document encoding, or NULL
13358	* @options: a combination of xmlParserOption
13359	*
13360	* parse an XML in-memory document and build a tree.
13361	*
13362	* Returns the resulting document tree
13363	*/
13364	xmlDocPtr
13365	xmlReadMemory(const char buffer, int size, const char URL, const char *encoding, int options)
13366	{
13367	xmlParserCtxtPtr ctxt;
13368
13369	ctxt = xmlCreateMemoryParserCtxt(buffer, size);
13370	if (ctxt == NULL)
13371	return (NULL);
13372	return (xmlDoRead(ctxt, URL, encoding, options, 0));
13373	}
13374
13375	/**
13376	* xmlReadFd:
13377	* @fd: an open file descriptor
13378	* @URL: the base URL to use for the document
13379	* @encoding: the document encoding, or NULL
13380	* @options: a combination of xmlParserOption
13381	*
13382	* parse an XML from a file descriptor and build a tree.
13383	* NOTE that the file descriptor will not be closed when the
13384	* reader is closed or reset.
13385	*
13386	* Returns the resulting document tree
13387	*/
13388	xmlDocPtr
13389	xmlReadFd(int fd, const char URL, const char encoding, int options)
13390	{
13391	xmlParserCtxtPtr ctxt;
13392	xmlParserInputBufferPtr input;
13393	xmlParserInputPtr stream;
13394
13395	if (fd < 0)
13396	return (NULL);
13397
13398	input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
13399	if (input == NULL)
13400	return (NULL);
13401	input->closecallback = NULL;
13402	ctxt = xmlNewParserCtxt();
13403	if (ctxt == NULL) {
13404	xmlFreeParserInputBuffer(input);
13405	return (NULL);
13406	}
13407	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13408	if (stream == NULL) {
13409	xmlFreeParserInputBuffer(input);
13410	xmlFreeParserCtxt(ctxt);
13411	return (NULL);
13412	}
13413	inputPush(ctxt, stream);
13414	return (xmlDoRead(ctxt, URL, encoding, options, 0));
13415	}
13416
13417	/**
13418	* xmlReadIO:
13419	* @ioread: an I/O read function
13420	* @ioclose: an I/O close function
13421	* @ioctx: an I/O handler
13422	* @URL: the base URL to use for the document
13423	* @encoding: the document encoding, or NULL
13424	* @options: a combination of xmlParserOption
13425	*
13426	* parse an XML document from I/O functions and source and build a tree.
13427	*
13428	* Returns the resulting document tree
13429	*/
13430	xmlDocPtr
13431	xmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
13432	void ioctx, const char URL, const char *encoding, int options)
13433	{
13434	xmlParserCtxtPtr ctxt;
13435	xmlParserInputBufferPtr input;
13436	xmlParserInputPtr stream;
13437
13438	if (ioread == NULL)
13439	return (NULL);
13440
13441	input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
13442	XML_CHAR_ENCODING_NONE);
13443	if (input == NULL)
13444	return (NULL);
13445	ctxt = xmlNewParserCtxt();
13446	if (ctxt == NULL) {
13447	xmlFreeParserInputBuffer(input);
13448	return (NULL);
13449	}
13450	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13451	if (stream == NULL) {
13452	xmlFreeParserInputBuffer(input);
13453	xmlFreeParserCtxt(ctxt);
13454	return (NULL);
13455	}
13456	inputPush(ctxt, stream);
13457	return (xmlDoRead(ctxt, URL, encoding, options, 0));
13458	}
13459
13460	/**
13461	* xmlCtxtReadDoc:
13462	* @ctxt: an XML parser context
13463	* @cur: a pointer to a zero terminated string
13464	* @URL: the base URL to use for the document
13465	* @encoding: the document encoding, or NULL
13466	* @options: a combination of xmlParserOption
13467	*
13468	* parse an XML in-memory document and build a tree.
13469	* This reuses the existing @ctxt parser context
13470	*
13471	* Returns the resulting document tree
13472	*/
13473	xmlDocPtr
13474	xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur,
13475	const char URL, const char encoding, int options)
13476	{
13477	xmlParserInputPtr stream;
13478
13479	if (cur == NULL)
13480	return (NULL);
13481	if (ctxt == NULL)
13482	return (NULL);
13483
13484	xmlCtxtReset(ctxt);
13485
13486	stream = xmlNewStringInputStream(ctxt, cur);
13487	if (stream == NULL) {
13488	return (NULL);
13489	}
13490	inputPush(ctxt, stream);
13491	return (xmlDoRead(ctxt, URL, encoding, options, 1));
13492	}
13493
13494	/**
13495	* xmlCtxtReadFile:
13496	* @ctxt: an XML parser context
13497	* @filename: a file or URL
13498	* @encoding: the document encoding, or NULL
13499	* @options: a combination of xmlParserOption
13500	*
13501	* parse an XML file from the filesystem or the network.
13502	* This reuses the existing @ctxt parser context
13503	*
13504	* Returns the resulting document tree
13505	*/
13506	xmlDocPtr
13507	xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename,
13508	const char *encoding, int options)
13509	{
13510	xmlParserInputPtr stream;
13511
13512	if (filename == NULL)
13513	return (NULL);
13514	if (ctxt == NULL)
13515	return (NULL);
13516
13517	xmlCtxtReset(ctxt);
13518
13519	stream = xmlLoadExternalEntity(filename, NULL, ctxt);
13520	if (stream == NULL) {
13521	return (NULL);
13522	}
13523	inputPush(ctxt, stream);
13524	return (xmlDoRead(ctxt, NULL, encoding, options, 1));
13525	}
13526
13527	/**
13528	* xmlCtxtReadMemory:
13529	* @ctxt: an XML parser context
13530	* @buffer: a pointer to a char array
13531	* @size: the size of the array
13532	* @URL: the base URL to use for the document
13533	* @encoding: the document encoding, or NULL
13534	* @options: a combination of xmlParserOption
13535	*
13536	* parse an XML in-memory document and build a tree.
13537	* This reuses the existing @ctxt parser context
13538	*
13539	* Returns the resulting document tree
13540	*/
13541	xmlDocPtr
13542	xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size,
13543	const char URL, const char encoding, int options)
13544	{
13545	xmlParserInputBufferPtr input;
13546	xmlParserInputPtr stream;
13547
13548	if (ctxt == NULL)
13549	return (NULL);
13550	if (buffer == NULL)
13551	return (NULL);
13552
13553	xmlCtxtReset(ctxt);
13554
13555	input = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
13556	if (input == NULL) {
13557	return(NULL);
13558	}
13559
13560	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13561	if (stream == NULL) {
13562	xmlFreeParserInputBuffer(input);
13563	return(NULL);
13564	}
13565
13566	inputPush(ctxt, stream);
13567	return (xmlDoRead(ctxt, URL, encoding, options, 1));
13568	}
13569
13570	/**
13571	* xmlCtxtReadFd:
13572	* @ctxt: an XML parser context
13573	* @fd: an open file descriptor
13574	* @URL: the base URL to use for the document
13575	* @encoding: the document encoding, or NULL
13576	* @options: a combination of xmlParserOption
13577	*
13578	* parse an XML from a file descriptor and build a tree.
13579	* This reuses the existing @ctxt parser context
13580	* NOTE that the file descriptor will not be closed when the
13581	* reader is closed or reset.
13582	*
13583	* Returns the resulting document tree
13584	*/
13585	xmlDocPtr
13586	xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd,
13587	const char URL, const char encoding, int options)
13588	{
13589	xmlParserInputBufferPtr input;
13590	xmlParserInputPtr stream;
13591
13592	if (fd < 0)
13593	return (NULL);
13594	if (ctxt == NULL)
13595	return (NULL);
13596
13597	xmlCtxtReset(ctxt);
13598
13599
13600	input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
13601	if (input == NULL)
13602	return (NULL);
13603	input->closecallback = NULL;
13604	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13605	if (stream == NULL) {
13606	xmlFreeParserInputBuffer(input);
13607	return (NULL);
13608	}
13609	inputPush(ctxt, stream);
13610	return (xmlDoRead(ctxt, URL, encoding, options, 1));
13611	}
13612
13613	/**
13614	* xmlCtxtReadIO:
13615	* @ctxt: an XML parser context
13616	* @ioread: an I/O read function
13617	* @ioclose: an I/O close function
13618	* @ioctx: an I/O handler
13619	* @URL: the base URL to use for the document
13620	* @encoding: the document encoding, or NULL
13621	* @options: a combination of xmlParserOption
13622	*
13623	* parse an XML document from I/O functions and source and build a tree.
13624	* This reuses the existing @ctxt parser context
13625	*
13626	* Returns the resulting document tree
13627	*/
13628	xmlDocPtr
13629	xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
13630	xmlInputCloseCallback ioclose, void *ioctx,
13631	const char *URL,
13632	const char *encoding, int options)
13633	{
13634	xmlParserInputBufferPtr input;
13635	xmlParserInputPtr stream;
13636
13637	if (ioread == NULL)
13638	return (NULL);
13639	if (ctxt == NULL)
13640	return (NULL);
13641
13642	xmlCtxtReset(ctxt);
13643
13644	input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
13645	XML_CHAR_ENCODING_NONE);
13646	if (input == NULL)
13647	return (NULL);
13648	stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
13649	if (stream == NULL) {
13650	xmlFreeParserInputBuffer(input);
13651	return (NULL);
13652	}
13653	inputPush(ctxt, stream);
13654	return (xmlDoRead(ctxt, URL, encoding, options, 1));
13655	}
13656
13657	#define bottom_parser
13658	#include "elfgcchack.h"

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

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

Download in other formats: