SAX2.c revision a136fc2e5a8893a02b0912862d26a575fcbd641a 
1/*
2 * SAX2.c : Default SAX2 handler to build a tree.
3 *
4 * See Copyright for the status of this software.
5 *
6 * Daniel Veillard <daniel@veillard.com>
7 */
8
9
10#define IN_LIBXML
11#include "libxml.h"
12#include <stdlib.h>
13#include <string.h>
14#include <limits.h>
15#include <libxml/xmlmemory.h>
16#include <libxml/tree.h>
17#include <libxml/parser.h>
18#include <libxml/parserInternals.h>
19#include <libxml/valid.h>
20#include <libxml/entities.h>
21#include <libxml/xmlerror.h>
22#include <libxml/debugXML.h>
23#include <libxml/xmlIO.h>
24#include <libxml/SAX.h>
25#include <libxml/uri.h>
26#include <libxml/valid.h>
27#include <libxml/HTMLtree.h>
28#include <libxml/globals.h>
29
30/* Define SIZE_T_MAX unless defined through <limits.h>. */
31#ifndef SIZE_T_MAX
32# define SIZE_T_MAX     ((size_t)-1)
33#endif /* !SIZE_T_MAX */
34
35/* #define DEBUG_SAX2 */
36/* #define DEBUG_SAX2_TREE */
37
38/**
39 * TODO:
40 *
41 * macro to flag unimplemented blocks
42 * XML_CATALOG_PREFER user env to select between system/public prefered
43 * option. C.f. Richard Tobin <richard@cogsci.ed.ac.uk>
44 *> Just FYI, I am using an environment variable XML_CATALOG_PREFER with
45 *> values "system" and "public".  I have made the default be "system" to
46 *> match yours.
47 */
48#define TODO								\
49    xmlGenericError(xmlGenericErrorContext,				\
50	    "Unimplemented block at %s:%d\n",				\
51            __FILE__, __LINE__);
52
53/*
54 * xmlSAX2ErrMemory:
55 * @ctxt:  an XML validation parser context
56 * @msg:   a string to accompany the error message
57 */
58static void LIBXML_ATTR_FORMAT(2,0)
59xmlSAX2ErrMemory(xmlParserCtxtPtr ctxt, const char *msg) {
60    xmlStructuredErrorFunc schannel = NULL;
61    const char *str1 = "out of memory\n";
62
63    if (ctxt != NULL) {
64	ctxt->errNo = XML_ERR_NO_MEMORY;
65	if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
66	    schannel = ctxt->sax->serror;
67	__xmlRaiseError(schannel,
68			ctxt->vctxt.error, ctxt->vctxt.userData,
69			ctxt, NULL, XML_FROM_PARSER, XML_ERR_NO_MEMORY,
70			XML_ERR_ERROR, NULL, 0, (const char *) str1,
71			NULL, NULL, 0, 0,
72			msg, (const char *) str1, NULL);
73	ctxt->errNo = XML_ERR_NO_MEMORY;
74	ctxt->instate = XML_PARSER_EOF;
75	ctxt->disableSAX = 1;
76    } else {
77	__xmlRaiseError(schannel,
78			NULL, NULL,
79			ctxt, NULL, XML_FROM_PARSER, XML_ERR_NO_MEMORY,
80			XML_ERR_ERROR, NULL, 0, (const char *) str1,
81			NULL, NULL, 0, 0,
82			msg, (const char *) str1, NULL);
83    }
84}
85
86/**
87 * xmlValidError:
88 * @ctxt:  an XML validation parser context
89 * @error:  the error number
90 * @msg:  the error message
91 * @str1:  extra data
92 * @str2:  extra data
93 *
94 * Handle a validation error
95 */
96static void LIBXML_ATTR_FORMAT(3,0)
97xmlErrValid(xmlParserCtxtPtr ctxt, xmlParserErrors error,
98            const char *msg, const char *str1, const char *str2)
99{
100    xmlStructuredErrorFunc schannel = NULL;
101
102    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
103        (ctxt->instate == XML_PARSER_EOF))
104	return;
105    if (ctxt != NULL) {
106	ctxt->errNo = error;
107	if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
108	    schannel = ctxt->sax->serror;
109	__xmlRaiseError(schannel,
110			ctxt->vctxt.error, ctxt->vctxt.userData,
111			ctxt, NULL, XML_FROM_DTD, error,
112			XML_ERR_ERROR, NULL, 0, (const char *) str1,
113			(const char *) str2, NULL, 0, 0,
114			msg, (const char *) str1, (const char *) str2);
115	ctxt->valid = 0;
116    } else {
117	__xmlRaiseError(schannel,
118			NULL, NULL,
119			ctxt, NULL, XML_FROM_DTD, error,
120			XML_ERR_ERROR, NULL, 0, (const char *) str1,
121			(const char *) str2, NULL, 0, 0,
122			msg, (const char *) str1, (const char *) str2);
123    }
124}
125
126/**
127 * xmlFatalErrMsg:
128 * @ctxt:  an XML parser context
129 * @error:  the error number
130 * @msg:  the error message
131 * @str1:  an error string
132 * @str2:  an error string
133 *
134 * Handle a fatal parser error, i.e. violating Well-Formedness constraints
135 */
136static void LIBXML_ATTR_FORMAT(3,0)
137xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
138               const char *msg, const xmlChar *str1, const xmlChar *str2)
139{
140    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
141        (ctxt->instate == XML_PARSER_EOF))
142	return;
143    if (ctxt != NULL)
144	ctxt->errNo = error;
145    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
146                    XML_ERR_FATAL, NULL, 0,
147		    (const char *) str1, (const char *) str2,
148		    NULL, 0, 0, msg, str1, str2);
149    if (ctxt != NULL) {
150	ctxt->wellFormed = 0;
151	ctxt->valid = 0;
152	if (ctxt->recovery == 0)
153	    ctxt->disableSAX = 1;
154    }
155}
156
157/**
158 * xmlWarnMsg:
159 * @ctxt:  an XML parser context
160 * @error:  the error number
161 * @msg:  the error message
162 * @str1:  an error string
163 * @str2:  an error string
164 *
165 * Handle a parser warning
166 */
167static void LIBXML_ATTR_FORMAT(3,0)
168xmlWarnMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
169               const char *msg, const xmlChar *str1)
170{
171    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
172        (ctxt->instate == XML_PARSER_EOF))
173	return;
174    if (ctxt != NULL)
175	ctxt->errNo = error;
176    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
177                    XML_ERR_WARNING, NULL, 0,
178		    (const char *) str1, NULL,
179		    NULL, 0, 0, msg, str1);
180}
181
182/**
183 * xmlNsErrMsg:
184 * @ctxt:  an XML parser context
185 * @error:  the error number
186 * @msg:  the error message
187 * @str1:  an error string
188 * @str2:  an error string
189 *
190 * Handle a namespace error
191 */
192static void LIBXML_ATTR_FORMAT(3,0)
193xmlNsErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
194            const char *msg, const xmlChar *str1, const xmlChar *str2)
195{
196    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
197        (ctxt->instate == XML_PARSER_EOF))
198	return;
199    if (ctxt != NULL)
200	ctxt->errNo = error;
201    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
202                    XML_ERR_ERROR, NULL, 0,
203		    (const char *) str1, (const char *) str2,
204		    NULL, 0, 0, msg, str1, str2);
205}
206
207/**
208 * xmlNsWarnMsg:
209 * @ctxt:  an XML parser context
210 * @error:  the error number
211 * @msg:  the error message
212 * @str1:  an error string
213 *
214 * Handle a namespace warning
215 */
216static void LIBXML_ATTR_FORMAT(3,0)
217xmlNsWarnMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
218             const char *msg, const xmlChar *str1, const xmlChar *str2)
219{
220    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
221        (ctxt->instate == XML_PARSER_EOF))
222	return;
223    if (ctxt != NULL)
224	ctxt->errNo = error;
225    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
226                    XML_ERR_WARNING, NULL, 0,
227		    (const char *) str1, (const char *) str2,
228		    NULL, 0, 0, msg, str1, str2);
229}
230
231/**
232 * xmlSAX2GetPublicId:
233 * @ctx: the user data (XML parser context)
234 *
235 * Provides the public ID e.g. "-//SGMLSOURCE//DTD DEMO//EN"
236 *
237 * Returns a xmlChar *
238 */
239const xmlChar *
240xmlSAX2GetPublicId(void *ctx ATTRIBUTE_UNUSED)
241{
242    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
243    return(NULL);
244}
245
246/**
247 * xmlSAX2GetSystemId:
248 * @ctx: the user data (XML parser context)
249 *
250 * Provides the system ID, basically URL or filename e.g.
251 * http://www.sgmlsource.com/dtds/memo.dtd
252 *
253 * Returns a xmlChar *
254 */
255const xmlChar *
256xmlSAX2GetSystemId(void *ctx)
257{
258    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
259    if ((ctx == NULL) || (ctxt->input == NULL)) return(NULL);
260    return((const xmlChar *) ctxt->input->filename);
261}
262
263/**
264 * xmlSAX2GetLineNumber:
265 * @ctx: the user data (XML parser context)
266 *
267 * Provide the line number of the current parsing point.
268 *
269 * Returns an int
270 */
271int
272xmlSAX2GetLineNumber(void *ctx)
273{
274    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
275    if ((ctx == NULL) || (ctxt->input == NULL)) return(0);
276    return(ctxt->input->line);
277}
278
279/**
280 * xmlSAX2GetColumnNumber:
281 * @ctx: the user data (XML parser context)
282 *
283 * Provide the column number of the current parsing point.
284 *
285 * Returns an int
286 */
287int
288xmlSAX2GetColumnNumber(void *ctx)
289{
290    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
291    if ((ctx == NULL) || (ctxt->input == NULL)) return(0);
292    return(ctxt->input->col);
293}
294
295/**
296 * xmlSAX2IsStandalone:
297 * @ctx: the user data (XML parser context)
298 *
299 * Is this document tagged standalone ?
300 *
301 * Returns 1 if true
302 */
303int
304xmlSAX2IsStandalone(void *ctx)
305{
306    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
307    if ((ctx == NULL) || (ctxt->myDoc == NULL)) return(0);
308    return(ctxt->myDoc->standalone == 1);
309}
310
311/**
312 * xmlSAX2HasInternalSubset:
313 * @ctx: the user data (XML parser context)
314 *
315 * Does this document has an internal subset
316 *
317 * Returns 1 if true
318 */
319int
320xmlSAX2HasInternalSubset(void *ctx)
321{
322    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
323    if ((ctxt == NULL) || (ctxt->myDoc == NULL)) return(0);
324    return(ctxt->myDoc->intSubset != NULL);
325}
326
327/**
328 * xmlSAX2HasExternalSubset:
329 * @ctx: the user data (XML parser context)
330 *
331 * Does this document has an external subset
332 *
333 * Returns 1 if true
334 */
335int
336xmlSAX2HasExternalSubset(void *ctx)
337{
338    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
339    if ((ctxt == NULL) || (ctxt->myDoc == NULL)) return(0);
340    return(ctxt->myDoc->extSubset != NULL);
341}
342
343/**
344 * xmlSAX2InternalSubset:
345 * @ctx:  the user data (XML parser context)
346 * @name:  the root element name
347 * @ExternalID:  the external ID
348 * @SystemID:  the SYSTEM ID (e.g. filename or URL)
349 *
350 * Callback on internal subset declaration.
351 */
352void
353xmlSAX2InternalSubset(void *ctx, const xmlChar *name,
354	       const xmlChar *ExternalID, const xmlChar *SystemID)
355{
356    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
357    xmlDtdPtr dtd;
358    if (ctx == NULL) return;
359#ifdef DEBUG_SAX
360    xmlGenericError(xmlGenericErrorContext,
361	    "SAX.xmlSAX2InternalSubset(%s, %s, %s)\n",
362            name, ExternalID, SystemID);
363#endif
364
365    if (ctxt->myDoc == NULL)
366	return;
367    dtd = xmlGetIntSubset(ctxt->myDoc);
368    if (dtd != NULL) {
369	if (ctxt->html)
370	    return;
371	xmlUnlinkNode((xmlNodePtr) dtd);
372	xmlFreeDtd(dtd);
373	ctxt->myDoc->intSubset = NULL;
374    }
375    ctxt->myDoc->intSubset =
376	xmlCreateIntSubset(ctxt->myDoc, name, ExternalID, SystemID);
377    if (ctxt->myDoc->intSubset == NULL)
378        xmlSAX2ErrMemory(ctxt, "xmlSAX2InternalSubset");
379}
380
381/**
382 * xmlSAX2ExternalSubset:
383 * @ctx: the user data (XML parser context)
384 * @name:  the root element name
385 * @ExternalID:  the external ID
386 * @SystemID:  the SYSTEM ID (e.g. filename or URL)
387 *
388 * Callback on external subset declaration.
389 */
390void
391xmlSAX2ExternalSubset(void *ctx, const xmlChar *name,
392	       const xmlChar *ExternalID, const xmlChar *SystemID)
393{
394    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
395    if (ctx == NULL) return;
396#ifdef DEBUG_SAX
397    xmlGenericError(xmlGenericErrorContext,
398	    "SAX.xmlSAX2ExternalSubset(%s, %s, %s)\n",
399            name, ExternalID, SystemID);
400#endif
401    if (((ExternalID != NULL) || (SystemID != NULL)) &&
402        (((ctxt->validate) || (ctxt->loadsubset != 0)) &&
403	 (ctxt->wellFormed && ctxt->myDoc))) {
404	/*
405	 * Try to fetch and parse the external subset.
406	 */
407	xmlParserInputPtr oldinput;
408	int oldinputNr;
409	int oldinputMax;
410	xmlParserInputPtr *oldinputTab;
411	xmlParserInputPtr input = NULL;
412	xmlCharEncoding enc;
413	int oldcharset;
414	const xmlChar *oldencoding;
415
416	/*
417	 * Ask the Entity resolver to load the damn thing
418	 */
419	if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
420	    input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
421	                                        SystemID);
422	if (input == NULL) {
423	    return;
424	}
425
426	xmlNewDtd(ctxt->myDoc, name, ExternalID, SystemID);
427
428	/*
429	 * make sure we won't destroy the main document context
430	 */
431	oldinput = ctxt->input;
432	oldinputNr = ctxt->inputNr;
433	oldinputMax = ctxt->inputMax;
434	oldinputTab = ctxt->inputTab;
435	oldcharset = ctxt->charset;
436	oldencoding = ctxt->encoding;
437	ctxt->encoding = NULL;
438
439	ctxt->inputTab = (xmlParserInputPtr *)
440	                 xmlMalloc(5 * sizeof(xmlParserInputPtr));
441	if (ctxt->inputTab == NULL) {
442	    xmlSAX2ErrMemory(ctxt, "xmlSAX2ExternalSubset");
443	    ctxt->input = oldinput;
444	    ctxt->inputNr = oldinputNr;
445	    ctxt->inputMax = oldinputMax;
446	    ctxt->inputTab = oldinputTab;
447	    ctxt->charset = oldcharset;
448	    ctxt->encoding = oldencoding;
449	    return;
450	}
451	ctxt->inputNr = 0;
452	ctxt->inputMax = 5;
453	ctxt->input = NULL;
454	xmlPushInput(ctxt, input);
455
456	/*
457	 * On the fly encoding conversion if needed
458	 */
459	if (ctxt->input->length >= 4) {
460	    enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
461	    xmlSwitchEncoding(ctxt, enc);
462	}
463
464	if (input->filename == NULL)
465	    input->filename = (char *) xmlCanonicPath(SystemID);
466	input->line = 1;
467	input->col = 1;
468	input->base = ctxt->input->cur;
469	input->cur = ctxt->input->cur;
470	input->free = NULL;
471
472	/*
473	 * let's parse that entity knowing it's an external subset.
474	 */
475	xmlParseExternalSubset(ctxt, ExternalID, SystemID);
476
477        /*
478	 * Free up the external entities
479	 */
480
481	while (ctxt->inputNr > 1)
482	    xmlPopInput(ctxt);
483	xmlFreeInputStream(ctxt->input);
484        xmlFree(ctxt->inputTab);
485
486	/*
487	 * Restore the parsing context of the main entity
488	 */
489	ctxt->input = oldinput;
490	ctxt->inputNr = oldinputNr;
491	ctxt->inputMax = oldinputMax;
492	ctxt->inputTab = oldinputTab;
493	ctxt->charset = oldcharset;
494	if ((ctxt->encoding != NULL) &&
495	    ((ctxt->dict == NULL) ||
496	     (!xmlDictOwns(ctxt->dict, ctxt->encoding))))
497	    xmlFree((xmlChar *) ctxt->encoding);
498	ctxt->encoding = oldencoding;
499	/* ctxt->wellFormed = oldwellFormed; */
500    }
501}
502
503/**
504 * xmlSAX2ResolveEntity:
505 * @ctx: the user data (XML parser context)
506 * @publicId: The public ID of the entity
507 * @systemId: The system ID of the entity
508 *
509 * The entity loader, to control the loading of external entities,
510 * the application can either:
511 *    - override this xmlSAX2ResolveEntity() callback in the SAX block
512 *    - or better use the xmlSetExternalEntityLoader() function to
513 *      set up it's own entity resolution routine
514 *
515 * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
516 */
517xmlParserInputPtr
518xmlSAX2ResolveEntity(void *ctx, const xmlChar *publicId, const xmlChar *systemId)
519{
520    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
521    xmlParserInputPtr ret;
522    xmlChar *URI;
523    const char *base = NULL;
524
525    if (ctx == NULL) return(NULL);
526    if (ctxt->input != NULL)
527	base = ctxt->input->filename;
528    if (base == NULL)
529	base = ctxt->directory;
530
531    URI = xmlBuildURI(systemId, (const xmlChar *) base);
532
533#ifdef DEBUG_SAX
534    xmlGenericError(xmlGenericErrorContext,
535	    "SAX.xmlSAX2ResolveEntity(%s, %s)\n", publicId, systemId);
536#endif
537
538    ret = xmlLoadExternalEntity((const char *) URI,
539				(const char *) publicId, ctxt);
540    if (URI != NULL)
541	xmlFree(URI);
542    return(ret);
543}
544
545/**
546 * xmlSAX2GetEntity:
547 * @ctx: the user data (XML parser context)
548 * @name: The entity name
549 *
550 * Get an entity by name
551 *
552 * Returns the xmlEntityPtr if found.
553 */
554xmlEntityPtr
555xmlSAX2GetEntity(void *ctx, const xmlChar *name)
556{
557    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
558    xmlEntityPtr ret = NULL;
559
560    if (ctx == NULL) return(NULL);
561#ifdef DEBUG_SAX
562    xmlGenericError(xmlGenericErrorContext,
563	    "SAX.xmlSAX2GetEntity(%s)\n", name);
564#endif
565
566    if (ctxt->inSubset == 0) {
567	ret = xmlGetPredefinedEntity(name);
568	if (ret != NULL)
569	    return(ret);
570    }
571    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->standalone == 1)) {
572	if (ctxt->inSubset == 2) {
573	    ctxt->myDoc->standalone = 0;
574	    ret = xmlGetDocEntity(ctxt->myDoc, name);
575	    ctxt->myDoc->standalone = 1;
576	} else {
577	    ret = xmlGetDocEntity(ctxt->myDoc, name);
578	    if (ret == NULL) {
579		ctxt->myDoc->standalone = 0;
580		ret = xmlGetDocEntity(ctxt->myDoc, name);
581		if (ret != NULL) {
582		    xmlFatalErrMsg(ctxt, XML_ERR_NOT_STANDALONE,
583	 "Entity(%s) document marked standalone but requires external subset\n",
584				   name, NULL);
585		}
586		ctxt->myDoc->standalone = 1;
587	    }
588	}
589    } else {
590	ret = xmlGetDocEntity(ctxt->myDoc, name);
591    }
592    if ((ret != NULL) &&
593	((ctxt->validate) || (ctxt->replaceEntities)) &&
594	(ret->children == NULL) &&
595	(ret->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
596	int val;
597
598	/*
599	 * for validation purposes we really need to fetch and
600	 * parse the external entity
601	 */
602	xmlNodePtr children;
603	unsigned long oldnbent = ctxt->nbentities;
604
605        val = xmlParseCtxtExternalEntity(ctxt, ret->URI,
606		                         ret->ExternalID, &children);
607	if (val == 0) {
608	    xmlAddChildList((xmlNodePtr) ret, children);
609	} else {
610	    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_PROCESSING,
611		           "Failure to process entity %s\n", name, NULL);
612	    ctxt->validate = 0;
613	    return(NULL);
614	}
615	ret->owner = 1;
616	if (ret->checked == 0) {
617	    ret->checked = (ctxt->nbentities - oldnbent + 1) * 2;
618	    if ((ret->content != NULL) && (xmlStrchr(ret->content, '<')))
619	        ret->checked |= 1;
620	}
621    }
622    return(ret);
623}
624
625/**
626 * xmlSAX2GetParameterEntity:
627 * @ctx: the user data (XML parser context)
628 * @name: The entity name
629 *
630 * Get a parameter entity by name
631 *
632 * Returns the xmlEntityPtr if found.
633 */
634xmlEntityPtr
635xmlSAX2GetParameterEntity(void *ctx, const xmlChar *name)
636{
637    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
638    xmlEntityPtr ret;
639
640    if (ctx == NULL) return(NULL);
641#ifdef DEBUG_SAX
642    xmlGenericError(xmlGenericErrorContext,
643	    "SAX.xmlSAX2GetParameterEntity(%s)\n", name);
644#endif
645
646    ret = xmlGetParameterEntity(ctxt->myDoc, name);
647    return(ret);
648}
649
650
651/**
652 * xmlSAX2EntityDecl:
653 * @ctx: the user data (XML parser context)
654 * @name:  the entity name
655 * @type:  the entity type
656 * @publicId: The public ID of the entity
657 * @systemId: The system ID of the entity
658 * @content: the entity value (without processing).
659 *
660 * An entity definition has been parsed
661 */
662void
663xmlSAX2EntityDecl(void *ctx, const xmlChar *name, int type,
664          const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
665{
666    xmlEntityPtr ent;
667    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
668
669    if (ctx == NULL) return;
670#ifdef DEBUG_SAX
671    xmlGenericError(xmlGenericErrorContext,
672	    "SAX.xmlSAX2EntityDecl(%s, %d, %s, %s, %s)\n",
673            name, type, publicId, systemId, content);
674#endif
675    if (ctxt->inSubset == 1) {
676	ent = xmlAddDocEntity(ctxt->myDoc, name, type, publicId,
677		              systemId, content);
678	if ((ent == NULL) && (ctxt->pedantic))
679	    xmlWarnMsg(ctxt, XML_WAR_ENTITY_REDEFINED,
680	     "Entity(%s) already defined in the internal subset\n",
681	               name);
682	if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
683	    xmlChar *URI;
684	    const char *base = NULL;
685
686	    if (ctxt->input != NULL)
687		base = ctxt->input->filename;
688	    if (base == NULL)
689		base = ctxt->directory;
690
691	    URI = xmlBuildURI(systemId, (const xmlChar *) base);
692	    ent->URI = URI;
693	}
694    } else if (ctxt->inSubset == 2) {
695	ent = xmlAddDtdEntity(ctxt->myDoc, name, type, publicId,
696		              systemId, content);
697	if ((ent == NULL) && (ctxt->pedantic) &&
698	    (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
699	    ctxt->sax->warning(ctxt->userData,
700	     "Entity(%s) already defined in the external subset\n", name);
701	if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
702	    xmlChar *URI;
703	    const char *base = NULL;
704
705	    if (ctxt->input != NULL)
706		base = ctxt->input->filename;
707	    if (base == NULL)
708		base = ctxt->directory;
709
710	    URI = xmlBuildURI(systemId, (const xmlChar *) base);
711	    ent->URI = URI;
712	}
713    } else {
714	xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_PROCESSING,
715	               "SAX.xmlSAX2EntityDecl(%s) called while not in subset\n",
716		       name, NULL);
717    }
718}
719
720/**
721 * xmlSAX2AttributeDecl:
722 * @ctx: the user data (XML parser context)
723 * @elem:  the name of the element
724 * @fullname:  the attribute name
725 * @type:  the attribute type
726 * @def:  the type of default value
727 * @defaultValue: the attribute default value
728 * @tree:  the tree of enumerated value set
729 *
730 * An attribute definition has been parsed
731 */
732void
733xmlSAX2AttributeDecl(void *ctx, const xmlChar *elem, const xmlChar *fullname,
734              int type, int def, const xmlChar *defaultValue,
735	      xmlEnumerationPtr tree)
736{
737    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
738    xmlAttributePtr attr;
739    xmlChar *name = NULL, *prefix = NULL;
740
741    if ((ctxt == NULL) || (ctxt->myDoc == NULL))
742        return;
743
744#ifdef DEBUG_SAX
745    xmlGenericError(xmlGenericErrorContext,
746	    "SAX.xmlSAX2AttributeDecl(%s, %s, %d, %d, %s, ...)\n",
747            elem, fullname, type, def, defaultValue);
748#endif
749    if ((xmlStrEqual(fullname, BAD_CAST "xml:id")) &&
750        (type != XML_ATTRIBUTE_ID)) {
751	/*
752	 * Raise the error but keep the validity flag
753	 */
754	int tmp = ctxt->valid;
755	xmlErrValid(ctxt, XML_DTD_XMLID_TYPE,
756	      "xml:id : attribute type should be ID\n", NULL, NULL);
757	ctxt->valid = tmp;
758    }
759    /* TODO: optimize name/prefix allocation */
760    name = xmlSplitQName(ctxt, fullname, &prefix);
761    ctxt->vctxt.valid = 1;
762    if (ctxt->inSubset == 1)
763	attr = xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, elem,
764	       name, prefix, (xmlAttributeType) type,
765	       (xmlAttributeDefault) def, defaultValue, tree);
766    else if (ctxt->inSubset == 2)
767	attr = xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, elem,
768	   name, prefix, (xmlAttributeType) type,
769	   (xmlAttributeDefault) def, defaultValue, tree);
770    else {
771        xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
772	     "SAX.xmlSAX2AttributeDecl(%s) called while not in subset\n",
773	               name, NULL);
774	xmlFreeEnumeration(tree);
775	return;
776    }
777#ifdef LIBXML_VALID_ENABLED
778    if (ctxt->vctxt.valid == 0)
779	ctxt->valid = 0;
780    if ((attr != NULL) && (ctxt->validate) && (ctxt->wellFormed) &&
781        (ctxt->myDoc->intSubset != NULL))
782	ctxt->valid &= xmlValidateAttributeDecl(&ctxt->vctxt, ctxt->myDoc,
783	                                        attr);
784#endif /* LIBXML_VALID_ENABLED */
785    if (prefix != NULL)
786	xmlFree(prefix);
787    if (name != NULL)
788	xmlFree(name);
789}
790
791/**
792 * xmlSAX2ElementDecl:
793 * @ctx: the user data (XML parser context)
794 * @name:  the element name
795 * @type:  the element type
796 * @content: the element value tree
797 *
798 * An element definition has been parsed
799 */
800void
801xmlSAX2ElementDecl(void *ctx, const xmlChar * name, int type,
802            xmlElementContentPtr content)
803{
804    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
805    xmlElementPtr elem = NULL;
806
807    if ((ctxt == NULL) || (ctxt->myDoc == NULL))
808        return;
809
810#ifdef DEBUG_SAX
811    xmlGenericError(xmlGenericErrorContext,
812                    "SAX.xmlSAX2ElementDecl(%s, %d, ...)\n", name, type);
813#endif
814
815    if (ctxt->inSubset == 1)
816        elem = xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->intSubset,
817                                 name, (xmlElementTypeVal) type, content);
818    else if (ctxt->inSubset == 2)
819        elem = xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->extSubset,
820                                 name, (xmlElementTypeVal) type, content);
821    else {
822        xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
823	     "SAX.xmlSAX2ElementDecl(%s) called while not in subset\n",
824	               name, NULL);
825        return;
826    }
827#ifdef LIBXML_VALID_ENABLED
828    if (elem == NULL)
829        ctxt->valid = 0;
830    if (ctxt->validate && ctxt->wellFormed &&
831        ctxt->myDoc && ctxt->myDoc->intSubset)
832        ctxt->valid &=
833            xmlValidateElementDecl(&ctxt->vctxt, ctxt->myDoc, elem);
834#endif /* LIBXML_VALID_ENABLED */
835}
836
837/**
838 * xmlSAX2NotationDecl:
839 * @ctx: the user data (XML parser context)
840 * @name: The name of the notation
841 * @publicId: The public ID of the entity
842 * @systemId: The system ID of the entity
843 *
844 * What to do when a notation declaration has been parsed.
845 */
846void
847xmlSAX2NotationDecl(void *ctx, const xmlChar *name,
848	     const xmlChar *publicId, const xmlChar *systemId)
849{
850    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
851    xmlNotationPtr nota = NULL;
852
853    if ((ctxt == NULL) || (ctxt->myDoc == NULL))
854        return;
855
856#ifdef DEBUG_SAX
857    xmlGenericError(xmlGenericErrorContext,
858	    "SAX.xmlSAX2NotationDecl(%s, %s, %s)\n", name, publicId, systemId);
859#endif
860
861    if ((publicId == NULL) && (systemId == NULL)) {
862	xmlFatalErrMsg(ctxt, XML_ERR_NOTATION_PROCESSING,
863	     "SAX.xmlSAX2NotationDecl(%s) externalID or PublicID missing\n",
864	               name, NULL);
865	return;
866    } else if (ctxt->inSubset == 1)
867	nota = xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, name,
868                              publicId, systemId);
869    else if (ctxt->inSubset == 2)
870	nota = xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, name,
871                              publicId, systemId);
872    else {
873	xmlFatalErrMsg(ctxt, XML_ERR_NOTATION_PROCESSING,
874	     "SAX.xmlSAX2NotationDecl(%s) called while not in subset\n",
875	               name, NULL);
876	return;
877    }
878#ifdef LIBXML_VALID_ENABLED
879    if (nota == NULL) ctxt->valid = 0;
880    if ((ctxt->validate) && (ctxt->wellFormed) &&
881        (ctxt->myDoc->intSubset != NULL))
882	ctxt->valid &= xmlValidateNotationDecl(&ctxt->vctxt, ctxt->myDoc,
883	                                       nota);
884#endif /* LIBXML_VALID_ENABLED */
885}
886
887/**
888 * xmlSAX2UnparsedEntityDecl:
889 * @ctx: the user data (XML parser context)
890 * @name: The name of the entity
891 * @publicId: The public ID of the entity
892 * @systemId: The system ID of the entity
893 * @notationName: the name of the notation
894 *
895 * What to do when an unparsed entity declaration is parsed
896 */
897void
898xmlSAX2UnparsedEntityDecl(void *ctx, const xmlChar *name,
899		   const xmlChar *publicId, const xmlChar *systemId,
900		   const xmlChar *notationName)
901{
902    xmlEntityPtr ent;
903    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
904    if (ctx == NULL) return;
905#ifdef DEBUG_SAX
906    xmlGenericError(xmlGenericErrorContext,
907	    "SAX.xmlSAX2UnparsedEntityDecl(%s, %s, %s, %s)\n",
908            name, publicId, systemId, notationName);
909#endif
910    if (ctxt->inSubset == 1) {
911	ent = xmlAddDocEntity(ctxt->myDoc, name,
912			XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
913			publicId, systemId, notationName);
914	if ((ent == NULL) && (ctxt->pedantic) &&
915	    (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
916	    ctxt->sax->warning(ctxt->userData,
917	     "Entity(%s) already defined in the internal subset\n", name);
918	if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
919	    xmlChar *URI;
920	    const char *base = NULL;
921
922	    if (ctxt->input != NULL)
923		base = ctxt->input->filename;
924	    if (base == NULL)
925		base = ctxt->directory;
926
927	    URI = xmlBuildURI(systemId, (const xmlChar *) base);
928	    ent->URI = URI;
929	}
930    } else if (ctxt->inSubset == 2) {
931	ent = xmlAddDtdEntity(ctxt->myDoc, name,
932			XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
933			publicId, systemId, notationName);
934	if ((ent == NULL) && (ctxt->pedantic) &&
935	    (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
936	    ctxt->sax->warning(ctxt->userData,
937	     "Entity(%s) already defined in the external subset\n", name);
938	if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
939	    xmlChar *URI;
940	    const char *base = NULL;
941
942	    if (ctxt->input != NULL)
943		base = ctxt->input->filename;
944	    if (base == NULL)
945		base = ctxt->directory;
946
947	    URI = xmlBuildURI(systemId, (const xmlChar *) base);
948	    ent->URI = URI;
949	}
950    } else {
951        xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
952	     "SAX.xmlSAX2UnparsedEntityDecl(%s) called while not in subset\n",
953	               name, NULL);
954    }
955}
956
957/**
958 * xmlSAX2SetDocumentLocator:
959 * @ctx: the user data (XML parser context)
960 * @loc: A SAX Locator
961 *
962 * Receive the document locator at startup, actually xmlDefaultSAXLocator
963 * Everything is available on the context, so this is useless in our case.
964 */
965void
966xmlSAX2SetDocumentLocator(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
967{
968    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
969#ifdef DEBUG_SAX
970    xmlGenericError(xmlGenericErrorContext,
971	    "SAX.xmlSAX2SetDocumentLocator()\n");
972#endif
973}
974
975/**
976 * xmlSAX2StartDocument:
977 * @ctx: the user data (XML parser context)
978 *
979 * called when the document start being processed.
980 */
981void
982xmlSAX2StartDocument(void *ctx)
983{
984    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
985    xmlDocPtr doc;
986
987    if (ctx == NULL) return;
988
989#ifdef DEBUG_SAX
990    xmlGenericError(xmlGenericErrorContext,
991	    "SAX.xmlSAX2StartDocument()\n");
992#endif
993    if (ctxt->html) {
994#ifdef LIBXML_HTML_ENABLED
995	if (ctxt->myDoc == NULL)
996	    ctxt->myDoc = htmlNewDocNoDtD(NULL, NULL);
997	if (ctxt->myDoc == NULL) {
998	    xmlSAX2ErrMemory(ctxt, "xmlSAX2StartDocument");
999	    return;
1000	}
1001	ctxt->myDoc->properties = XML_DOC_HTML;
1002	ctxt->myDoc->parseFlags = ctxt->options;
1003#else
1004        xmlGenericError(xmlGenericErrorContext,
1005		"libxml2 built without HTML support\n");
1006	ctxt->errNo = XML_ERR_INTERNAL_ERROR;
1007	ctxt->instate = XML_PARSER_EOF;
1008	ctxt->disableSAX = 1;
1009	return;
1010#endif
1011    } else {
1012	doc = ctxt->myDoc = xmlNewDoc(ctxt->version);
1013	if (doc != NULL) {
1014	    doc->properties = 0;
1015	    if (ctxt->options & XML_PARSE_OLD10)
1016	        doc->properties |= XML_DOC_OLD10;
1017	    doc->parseFlags = ctxt->options;
1018	    if (ctxt->encoding != NULL)
1019		doc->encoding = xmlStrdup(ctxt->encoding);
1020	    else
1021		doc->encoding = NULL;
1022	    doc->standalone = ctxt->standalone;
1023	} else {
1024	    xmlSAX2ErrMemory(ctxt, "xmlSAX2StartDocument");
1025	    return;
1026	}
1027	if ((ctxt->dictNames) && (doc != NULL)) {
1028	    doc->dict = ctxt->dict;
1029	    xmlDictReference(doc->dict);
1030	}
1031    }
1032    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->URL == NULL) &&
1033	(ctxt->input != NULL) && (ctxt->input->filename != NULL)) {
1034	ctxt->myDoc->URL = xmlPathToURI((const xmlChar *)ctxt->input->filename);
1035	if (ctxt->myDoc->URL == NULL)
1036	    xmlSAX2ErrMemory(ctxt, "xmlSAX2StartDocument");
1037    }
1038}
1039
1040/**
1041 * xmlSAX2EndDocument:
1042 * @ctx: the user data (XML parser context)
1043 *
1044 * called when the document end has been detected.
1045 */
1046void
1047xmlSAX2EndDocument(void *ctx)
1048{
1049    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
1050#ifdef DEBUG_SAX
1051    xmlGenericError(xmlGenericErrorContext,
1052	    "SAX.xmlSAX2EndDocument()\n");
1053#endif
1054    if (ctx == NULL) return;
1055#ifdef LIBXML_VALID_ENABLED
1056    if (ctxt->validate && ctxt->wellFormed &&
1057        ctxt->myDoc && ctxt->myDoc->intSubset)
1058	ctxt->valid &= xmlValidateDocumentFinal(&ctxt->vctxt, ctxt->myDoc);
1059#endif /* LIBXML_VALID_ENABLED */
1060
1061    /*
1062     * Grab the encoding if it was added on-the-fly
1063     */
1064    if ((ctxt->encoding != NULL) && (ctxt->myDoc != NULL) &&
1065	(ctxt->myDoc->encoding == NULL)) {
1066	ctxt->myDoc->encoding = ctxt->encoding;
1067	ctxt->encoding = NULL;
1068    }
1069    if ((ctxt->inputTab != NULL) &&
1070        (ctxt->inputNr > 0) && (ctxt->inputTab[0] != NULL) &&
1071        (ctxt->inputTab[0]->encoding != NULL) && (ctxt->myDoc != NULL) &&
1072	(ctxt->myDoc->encoding == NULL)) {
1073	ctxt->myDoc->encoding = xmlStrdup(ctxt->inputTab[0]->encoding);
1074    }
1075    if ((ctxt->charset != XML_CHAR_ENCODING_NONE) && (ctxt->myDoc != NULL) &&
1076	(ctxt->myDoc->charset == XML_CHAR_ENCODING_NONE)) {
1077	ctxt->myDoc->charset = ctxt->charset;
1078    }
1079}
1080
1081#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) || defined(LIBXML_LEGACY_ENABLED)
1082/**
1083 * xmlSAX2AttributeInternal:
1084 * @ctx: the user data (XML parser context)
1085 * @fullname:  The attribute name, including namespace prefix
1086 * @value:  The attribute value
1087 * @prefix: the prefix on the element node
1088 *
1089 * Handle an attribute that has been read by the parser.
1090 * The default handling is to convert the attribute into an
1091 * DOM subtree and past it in a new xmlAttr element added to
1092 * the element.
1093 */
1094static void
1095xmlSAX2AttributeInternal(void *ctx, const xmlChar *fullname,
1096             const xmlChar *value, const xmlChar *prefix ATTRIBUTE_UNUSED)
1097{
1098    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
1099    xmlAttrPtr ret;
1100    xmlChar *name;
1101    xmlChar *ns;
1102    xmlChar *nval;
1103    xmlNsPtr namespace;
1104
1105    if (ctxt->html) {
1106	name = xmlStrdup(fullname);
1107	ns = NULL;
1108	namespace = NULL;
1109    } else {
1110	/*
1111	 * Split the full name into a namespace prefix and the tag name
1112	 */
1113	name = xmlSplitQName(ctxt, fullname, &ns);
1114	if ((name != NULL) && (name[0] == 0)) {
1115	    if (xmlStrEqual(ns, BAD_CAST "xmlns")) {
1116		xmlNsErrMsg(ctxt, XML_ERR_NS_DECL_ERROR,
1117			    "invalid namespace declaration '%s'\n",
1118			    fullname, NULL);
1119	    } else {
1120		xmlNsWarnMsg(ctxt, XML_WAR_NS_COLUMN,
1121			     "Avoid attribute ending with ':' like '%s'\n",
1122			     fullname, NULL);
1123	    }
1124	    if (ns != NULL)
1125		xmlFree(ns);
1126	    ns = NULL;
1127	    xmlFree(name);
1128	    name = xmlStrdup(fullname);
1129	}
1130    }
1131    if (name == NULL) {
1132        xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1133	if (ns != NULL)
1134	    xmlFree(ns);
1135	return;
1136    }
1137
1138#ifdef LIBXML_HTML_ENABLED
1139    if ((ctxt->html) &&
1140        (value == NULL) && (htmlIsBooleanAttr(fullname))) {
1141            nval = xmlStrdup(fullname);
1142            value = (const xmlChar *) nval;
1143    } else
1144#endif
1145    {
1146#ifdef LIBXML_VALID_ENABLED
1147        /*
1148         * Do the last stage of the attribute normalization
1149         * Needed for HTML too:
1150         *   http://www.w3.org/TR/html4/types.html#h-6.2
1151         */
1152        ctxt->vctxt.valid = 1;
1153        nval = xmlValidCtxtNormalizeAttributeValue(&ctxt->vctxt,
1154                                               ctxt->myDoc, ctxt->node,
1155                                               fullname, value);
1156        if (ctxt->vctxt.valid != 1) {
1157            ctxt->valid = 0;
1158        }
1159        if (nval != NULL)
1160            value = nval;
1161#else
1162        nval = NULL;
1163#endif /* LIBXML_VALID_ENABLED */
1164    }
1165
1166    /*
1167     * Check whether it's a namespace definition
1168     */
1169    if ((!ctxt->html) && (ns == NULL) &&
1170        (name[0] == 'x') && (name[1] == 'm') && (name[2] == 'l') &&
1171        (name[3] == 'n') && (name[4] == 's') && (name[5] == 0)) {
1172	xmlNsPtr nsret;
1173	xmlChar *val;
1174
1175        if (!ctxt->replaceEntities) {
1176	    ctxt->depth++;
1177	    val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
1178		                          0,0,0);
1179	    ctxt->depth--;
1180	    if (val == NULL) {
1181	        xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1182		if (name != NULL)
1183		    xmlFree(name);
1184		return;
1185	    }
1186	} else {
1187	    val = (xmlChar *) value;
1188	}
1189
1190	if (val[0] != 0) {
1191	    xmlURIPtr uri;
1192
1193	    uri = xmlParseURI((const char *)val);
1194	    if (uri == NULL) {
1195		if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
1196		    ctxt->sax->warning(ctxt->userData,
1197			 "xmlns: %s not a valid URI\n", val);
1198	    } else {
1199		if (uri->scheme == NULL) {
1200		    if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
1201			ctxt->sax->warning(ctxt->userData,
1202			     "xmlns: URI %s is not absolute\n", val);
1203		}
1204		xmlFreeURI(uri);
1205	    }
1206	}
1207
1208	/* a default namespace definition */
1209	nsret = xmlNewNs(ctxt->node, val, NULL);
1210
1211#ifdef LIBXML_VALID_ENABLED
1212	/*
1213	 * Validate also for namespace decls, they are attributes from
1214	 * an XML-1.0 perspective
1215	 */
1216        if (nsret != NULL && ctxt->validate && ctxt->wellFormed &&
1217	    ctxt->myDoc && ctxt->myDoc->intSubset)
1218	    ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
1219					   ctxt->node, prefix, nsret, val);
1220#endif /* LIBXML_VALID_ENABLED */
1221	if (name != NULL)
1222	    xmlFree(name);
1223	if (nval != NULL)
1224	    xmlFree(nval);
1225	if (val != value)
1226	    xmlFree(val);
1227	return;
1228    }
1229    if ((!ctxt->html) &&
1230	(ns != NULL) && (ns[0] == 'x') && (ns[1] == 'm') && (ns[2] == 'l') &&
1231        (ns[3] == 'n') && (ns[4] == 's') && (ns[5] == 0)) {
1232	xmlNsPtr nsret;
1233	xmlChar *val;
1234
1235        if (!ctxt->replaceEntities) {
1236	    ctxt->depth++;
1237	    val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
1238		                          0,0,0);
1239	    ctxt->depth--;
1240	    if (val == NULL) {
1241	        xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1242	        xmlFree(ns);
1243		if (name != NULL)
1244		    xmlFree(name);
1245		return;
1246	    }
1247	} else {
1248	    val = (xmlChar *) value;
1249	}
1250
1251	if (val[0] == 0) {
1252	    xmlNsErrMsg(ctxt, XML_NS_ERR_EMPTY,
1253		        "Empty namespace name for prefix %s\n", name, NULL);
1254	}
1255	if ((ctxt->pedantic != 0) && (val[0] != 0)) {
1256	    xmlURIPtr uri;
1257
1258	    uri = xmlParseURI((const char *)val);
1259	    if (uri == NULL) {
1260	        xmlNsWarnMsg(ctxt, XML_WAR_NS_URI,
1261			 "xmlns:%s: %s not a valid URI\n", name, value);
1262	    } else {
1263		if (uri->scheme == NULL) {
1264		    xmlNsWarnMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
1265			   "xmlns:%s: URI %s is not absolute\n", name, value);
1266		}
1267		xmlFreeURI(uri);
1268	    }
1269	}
1270
1271	/* a standard namespace definition */
1272	nsret = xmlNewNs(ctxt->node, val, name);
1273	xmlFree(ns);
1274#ifdef LIBXML_VALID_ENABLED
1275	/*
1276	 * Validate also for namespace decls, they are attributes from
1277	 * an XML-1.0 perspective
1278	 */
1279        if (nsret != NULL && ctxt->validate && ctxt->wellFormed &&
1280	    ctxt->myDoc && ctxt->myDoc->intSubset)
1281	    ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
1282					   ctxt->node, prefix, nsret, value);
1283#endif /* LIBXML_VALID_ENABLED */
1284	if (name != NULL)
1285	    xmlFree(name);
1286	if (nval != NULL)
1287	    xmlFree(nval);
1288	if (val != value)
1289	    xmlFree(val);
1290	return;
1291    }
1292
1293    if (ns != NULL) {
1294	namespace = xmlSearchNs(ctxt->myDoc, ctxt->node, ns);
1295
1296	if (namespace == NULL) {
1297	    xmlNsErrMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
1298		    "Namespace prefix %s of attribute %s is not defined\n",
1299		             ns, name);
1300	} else {
1301            xmlAttrPtr prop;
1302
1303            prop = ctxt->node->properties;
1304            while (prop != NULL) {
1305                if (prop->ns != NULL) {
1306                    if ((xmlStrEqual(name, prop->name)) &&
1307                        ((namespace == prop->ns) ||
1308                         (xmlStrEqual(namespace->href, prop->ns->href)))) {
1309                            xmlNsErrMsg(ctxt, XML_ERR_ATTRIBUTE_REDEFINED,
1310                                    "Attribute %s in %s redefined\n",
1311                                             name, namespace->href);
1312                        ctxt->wellFormed = 0;
1313                        if (ctxt->recovery == 0) ctxt->disableSAX = 1;
1314                        goto error;
1315                    }
1316                }
1317                prop = prop->next;
1318            }
1319        }
1320    } else {
1321	namespace = NULL;
1322    }
1323
1324    /* !!!!!! <a toto:arg="" xmlns:toto="http://toto.com"> */
1325    ret = xmlNewNsPropEatName(ctxt->node, namespace, name, NULL);
1326
1327    if (ret != NULL) {
1328        if ((ctxt->replaceEntities == 0) && (!ctxt->html)) {
1329	    xmlNodePtr tmp;
1330
1331	    ret->children = xmlStringGetNodeList(ctxt->myDoc, value);
1332	    tmp = ret->children;
1333	    while (tmp != NULL) {
1334		tmp->parent = (xmlNodePtr) ret;
1335		if (tmp->next == NULL)
1336		    ret->last = tmp;
1337		tmp = tmp->next;
1338	    }
1339	} else if (value != NULL) {
1340	    ret->children = xmlNewDocText(ctxt->myDoc, value);
1341	    ret->last = ret->children;
1342	    if (ret->children != NULL)
1343		ret->children->parent = (xmlNodePtr) ret;
1344	}
1345    }
1346
1347#ifdef LIBXML_VALID_ENABLED
1348    if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
1349        ctxt->myDoc && ctxt->myDoc->intSubset) {
1350
1351	/*
1352	 * If we don't substitute entities, the validation should be
1353	 * done on a value with replaced entities anyway.
1354	 */
1355        if (!ctxt->replaceEntities) {
1356	    xmlChar *val;
1357
1358	    ctxt->depth++;
1359	    val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
1360		                          0,0,0);
1361	    ctxt->depth--;
1362
1363	    if (val == NULL)
1364		ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
1365				ctxt->myDoc, ctxt->node, ret, value);
1366	    else {
1367		xmlChar *nvalnorm;
1368
1369		/*
1370		 * Do the last stage of the attribute normalization
1371		 * It need to be done twice ... it's an extra burden related
1372		 * to the ability to keep xmlSAX2References in attributes
1373		 */
1374		nvalnorm = xmlValidNormalizeAttributeValue(ctxt->myDoc,
1375					    ctxt->node, fullname, val);
1376		if (nvalnorm != NULL) {
1377		    xmlFree(val);
1378		    val = nvalnorm;
1379		}
1380
1381		ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
1382			        ctxt->myDoc, ctxt->node, ret, val);
1383                xmlFree(val);
1384	    }
1385	} else {
1386	    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt, ctxt->myDoc,
1387					       ctxt->node, ret, value);
1388	}
1389    } else
1390#endif /* LIBXML_VALID_ENABLED */
1391           if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
1392	       (((ctxt->replaceEntities == 0) && (ctxt->external != 2)) ||
1393	        ((ctxt->replaceEntities != 0) && (ctxt->inSubset == 0)))) {
1394        /*
1395	 * when validating, the ID registration is done at the attribute
1396	 * validation level. Otherwise we have to do specific handling here.
1397	 */
1398	if (xmlStrEqual(fullname, BAD_CAST "xml:id")) {
1399	    /*
1400	     * Add the xml:id value
1401	     *
1402	     * Open issue: normalization of the value.
1403	     */
1404	    if (xmlValidateNCName(value, 1) != 0) {
1405	        xmlErrValid(ctxt, XML_DTD_XMLID_VALUE,
1406		      "xml:id : attribute value %s is not an NCName\n",
1407			    (const char *) value, NULL);
1408	    }
1409	    xmlAddID(&ctxt->vctxt, ctxt->myDoc, value, ret);
1410	} else if (xmlIsID(ctxt->myDoc, ctxt->node, ret))
1411	    xmlAddID(&ctxt->vctxt, ctxt->myDoc, value, ret);
1412	else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret))
1413	    xmlAddRef(&ctxt->vctxt, ctxt->myDoc, value, ret);
1414    }
1415
1416error:
1417    if (nval != NULL)
1418	xmlFree(nval);
1419    if (ns != NULL)
1420	xmlFree(ns);
1421}
1422
1423/*
1424 * xmlCheckDefaultedAttributes:
1425 *
1426 * Check defaulted attributes from the DTD
1427 */
1428static void
1429xmlCheckDefaultedAttributes(xmlParserCtxtPtr ctxt, const xmlChar *name,
1430	const xmlChar *prefix, const xmlChar **atts) {
1431    xmlElementPtr elemDecl;
1432    const xmlChar *att;
1433    int internal = 1;
1434    int i;
1435
1436    elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->intSubset, name, prefix);
1437    if (elemDecl == NULL) {
1438	elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->extSubset, name, prefix);
1439	internal = 0;
1440    }
1441
1442process_external_subset:
1443
1444    if (elemDecl != NULL) {
1445	xmlAttributePtr attr = elemDecl->attributes;
1446	/*
1447	 * Check against defaulted attributes from the external subset
1448	 * if the document is stamped as standalone
1449	 */
1450	if ((ctxt->myDoc->standalone == 1) &&
1451	    (ctxt->myDoc->extSubset != NULL) &&
1452	    (ctxt->validate)) {
1453	    while (attr != NULL) {
1454		if ((attr->defaultValue != NULL) &&
1455		    (xmlGetDtdQAttrDesc(ctxt->myDoc->extSubset,
1456					attr->elem, attr->name,
1457					attr->prefix) == attr) &&
1458		    (xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
1459					attr->elem, attr->name,
1460					attr->prefix) == NULL)) {
1461		    xmlChar *fulln;
1462
1463		    if (attr->prefix != NULL) {
1464			fulln = xmlStrdup(attr->prefix);
1465			fulln = xmlStrcat(fulln, BAD_CAST ":");
1466			fulln = xmlStrcat(fulln, attr->name);
1467		    } else {
1468			fulln = xmlStrdup(attr->name);
1469		    }
1470                    if (fulln == NULL) {
1471                        xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1472                        break;
1473                    }
1474
1475		    /*
1476		     * Check that the attribute is not declared in the
1477		     * serialization
1478		     */
1479		    att = NULL;
1480		    if (atts != NULL) {
1481			i = 0;
1482			att = atts[i];
1483			while (att != NULL) {
1484			    if (xmlStrEqual(att, fulln))
1485				break;
1486			    i += 2;
1487			    att = atts[i];
1488			}
1489		    }
1490		    if (att == NULL) {
1491		        xmlErrValid(ctxt, XML_DTD_STANDALONE_DEFAULTED,
1492      "standalone: attribute %s on %s defaulted from external subset\n",
1493				    (const char *)fulln,
1494				    (const char *)attr->elem);
1495		    }
1496                    xmlFree(fulln);
1497		}
1498		attr = attr->nexth;
1499	    }
1500	}
1501
1502	/*
1503	 * Actually insert defaulted values when needed
1504	 */
1505	attr = elemDecl->attributes;
1506	while (attr != NULL) {
1507	    /*
1508	     * Make sure that attributes redefinition occuring in the
1509	     * internal subset are not overriden by definitions in the
1510	     * external subset.
1511	     */
1512	    if (attr->defaultValue != NULL) {
1513		/*
1514		 * the element should be instantiated in the tree if:
1515		 *  - this is a namespace prefix
1516		 *  - the user required for completion in the tree
1517		 *    like XSLT
1518		 *  - there isn't already an attribute definition
1519		 *    in the internal subset overriding it.
1520		 */
1521		if (((attr->prefix != NULL) &&
1522		     (xmlStrEqual(attr->prefix, BAD_CAST "xmlns"))) ||
1523		    ((attr->prefix == NULL) &&
1524		     (xmlStrEqual(attr->name, BAD_CAST "xmlns"))) ||
1525		    (ctxt->loadsubset & XML_COMPLETE_ATTRS)) {
1526		    xmlAttributePtr tst;
1527
1528		    tst = xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
1529					     attr->elem, attr->name,
1530					     attr->prefix);
1531		    if ((tst == attr) || (tst == NULL)) {
1532		        xmlChar fn[50];
1533			xmlChar *fulln;
1534
1535                        fulln = xmlBuildQName(attr->name, attr->prefix, fn, 50);
1536			if (fulln == NULL) {
1537			    xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1538			    return;
1539			}
1540
1541			/*
1542			 * Check that the attribute is not declared in the
1543			 * serialization
1544			 */
1545			att = NULL;
1546			if (atts != NULL) {
1547			    i = 0;
1548			    att = atts[i];
1549			    while (att != NULL) {
1550				if (xmlStrEqual(att, fulln))
1551				    break;
1552				i += 2;
1553				att = atts[i];
1554			    }
1555			}
1556			if (att == NULL) {
1557			    xmlSAX2AttributeInternal(ctxt, fulln,
1558						 attr->defaultValue, prefix);
1559			}
1560			if ((fulln != fn) && (fulln != attr->name))
1561			    xmlFree(fulln);
1562		    }
1563		}
1564	    }
1565	    attr = attr->nexth;
1566	}
1567	if (internal == 1) {
1568	    elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->extSubset,
1569		                             name, prefix);
1570	    internal = 0;
1571	    goto process_external_subset;
1572	}
1573    }
1574}
1575
1576/**
1577 * xmlSAX2StartElement:
1578 * @ctx: the user data (XML parser context)
1579 * @fullname:  The element name, including namespace prefix
1580 * @atts:  An array of name/value attributes pairs, NULL terminated
1581 *
1582 * called when an opening tag has been processed.
1583 */
1584void
1585xmlSAX2StartElement(void *ctx, const xmlChar *fullname, const xmlChar **atts)
1586{
1587    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
1588    xmlNodePtr ret;
1589    xmlNodePtr parent;
1590    xmlNsPtr ns;
1591    xmlChar *name;
1592    xmlChar *prefix;
1593    const xmlChar *att;
1594    const xmlChar *value;
1595    int i;
1596
1597    if ((ctx == NULL) || (fullname == NULL) || (ctxt->myDoc == NULL)) return;
1598    parent = ctxt->node;
1599#ifdef DEBUG_SAX
1600    xmlGenericError(xmlGenericErrorContext,
1601	    "SAX.xmlSAX2StartElement(%s)\n", fullname);
1602#endif
1603
1604    /*
1605     * First check on validity:
1606     */
1607    if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) &&
1608        ((ctxt->myDoc->intSubset == NULL) ||
1609	 ((ctxt->myDoc->intSubset->notations == NULL) &&
1610	  (ctxt->myDoc->intSubset->elements == NULL) &&
1611	  (ctxt->myDoc->intSubset->attributes == NULL) &&
1612	  (ctxt->myDoc->intSubset->entities == NULL)))) {
1613	xmlErrValid(ctxt, XML_ERR_NO_DTD,
1614	  "Validation failed: no DTD found !", NULL, NULL);
1615	ctxt->validate = 0;
1616    }
1617
1618
1619    /*
1620     * Split the full name into a namespace prefix and the tag name
1621     */
1622    name = xmlSplitQName(ctxt, fullname, &prefix);
1623
1624
1625    /*
1626     * Note : the namespace resolution is deferred until the end of the
1627     *        attributes parsing, since local namespace can be defined as
1628     *        an attribute at this level.
1629     */
1630    ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL, name, NULL);
1631    if (ret == NULL) {
1632        if (prefix != NULL)
1633	    xmlFree(prefix);
1634	xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1635        return;
1636    }
1637    if (ctxt->myDoc->children == NULL) {
1638#ifdef DEBUG_SAX_TREE
1639	xmlGenericError(xmlGenericErrorContext, "Setting %s as root\n", name);
1640#endif
1641        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
1642    } else if (parent == NULL) {
1643        parent = ctxt->myDoc->children;
1644    }
1645    ctxt->nodemem = -1;
1646    if (ctxt->linenumbers) {
1647	if (ctxt->input != NULL) {
1648	    if (ctxt->input->line < 65535)
1649		ret->line = (short) ctxt->input->line;
1650	    else
1651	        ret->line = 65535;
1652	}
1653    }
1654
1655    /*
1656     * We are parsing a new node.
1657     */
1658#ifdef DEBUG_SAX_TREE
1659    xmlGenericError(xmlGenericErrorContext, "pushing(%s)\n", name);
1660#endif
1661    nodePush(ctxt, ret);
1662
1663    /*
1664     * Link the child element
1665     */
1666    if (parent != NULL) {
1667        if (parent->type == XML_ELEMENT_NODE) {
1668#ifdef DEBUG_SAX_TREE
1669	    xmlGenericError(xmlGenericErrorContext,
1670		    "adding child %s to %s\n", name, parent->name);
1671#endif
1672	    xmlAddChild(parent, ret);
1673	} else {
1674#ifdef DEBUG_SAX_TREE
1675	    xmlGenericError(xmlGenericErrorContext,
1676		    "adding sibling %s to ", name);
1677	    xmlDebugDumpOneNode(stderr, parent, 0);
1678#endif
1679	    xmlAddSibling(parent, ret);
1680	}
1681    }
1682
1683    /*
1684     * Insert all the defaulted attributes from the DTD especially namespaces
1685     */
1686    if ((!ctxt->html) &&
1687	((ctxt->myDoc->intSubset != NULL) ||
1688	 (ctxt->myDoc->extSubset != NULL))) {
1689	xmlCheckDefaultedAttributes(ctxt, name, prefix, atts);
1690    }
1691
1692    /*
1693     * process all the attributes whose name start with "xmlns"
1694     */
1695    if (atts != NULL) {
1696        i = 0;
1697	att = atts[i++];
1698	value = atts[i++];
1699	if (!ctxt->html) {
1700	    while ((att != NULL) && (value != NULL)) {
1701		if ((att[0] == 'x') && (att[1] == 'm') && (att[2] == 'l') &&
1702		    (att[3] == 'n') && (att[4] == 's'))
1703		    xmlSAX2AttributeInternal(ctxt, att, value, prefix);
1704
1705		att = atts[i++];
1706		value = atts[i++];
1707	    }
1708	}
1709    }
1710
1711    /*
1712     * Search the namespace, note that since the attributes have been
1713     * processed, the local namespaces are available.
1714     */
1715    ns = xmlSearchNs(ctxt->myDoc, ret, prefix);
1716    if ((ns == NULL) && (parent != NULL))
1717	ns = xmlSearchNs(ctxt->myDoc, parent, prefix);
1718    if ((prefix != NULL) && (ns == NULL)) {
1719	ns = xmlNewNs(ret, NULL, prefix);
1720	xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
1721		     "Namespace prefix %s is not defined\n",
1722		     prefix, NULL);
1723    }
1724
1725    /*
1726     * set the namespace node, making sure that if the default namspace
1727     * is unbound on a parent we simply kee it NULL
1728     */
1729    if ((ns != NULL) && (ns->href != NULL) &&
1730	((ns->href[0] != 0) || (ns->prefix != NULL)))
1731	xmlSetNs(ret, ns);
1732
1733    /*
1734     * process all the other attributes
1735     */
1736    if (atts != NULL) {
1737        i = 0;
1738	att = atts[i++];
1739	value = atts[i++];
1740	if (ctxt->html) {
1741	    while (att != NULL) {
1742		xmlSAX2AttributeInternal(ctxt, att, value, NULL);
1743		att = atts[i++];
1744		value = atts[i++];
1745	    }
1746	} else {
1747	    while ((att != NULL) && (value != NULL)) {
1748		if ((att[0] != 'x') || (att[1] != 'm') || (att[2] != 'l') ||
1749		    (att[3] != 'n') || (att[4] != 's'))
1750		    xmlSAX2AttributeInternal(ctxt, att, value, NULL);
1751
1752		/*
1753		 * Next ones
1754		 */
1755		att = atts[i++];
1756		value = atts[i++];
1757	    }
1758	}
1759    }
1760
1761#ifdef LIBXML_VALID_ENABLED
1762    /*
1763     * If it's the Document root, finish the DTD validation and
1764     * check the document root element for validity
1765     */
1766    if ((ctxt->validate) && (ctxt->vctxt.finishDtd == XML_CTXT_FINISH_DTD_0)) {
1767	int chk;
1768
1769	chk = xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
1770	if (chk <= 0)
1771	    ctxt->valid = 0;
1772	if (chk < 0)
1773	    ctxt->wellFormed = 0;
1774	ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
1775	ctxt->vctxt.finishDtd = XML_CTXT_FINISH_DTD_1;
1776    }
1777#endif /* LIBXML_VALID_ENABLED */
1778
1779    if (prefix != NULL)
1780	xmlFree(prefix);
1781
1782}
1783
1784/**
1785 * xmlSAX2EndElement:
1786 * @ctx: the user data (XML parser context)
1787 * @name:  The element name
1788 *
1789 * called when the end of an element has been detected.
1790 */
1791void
1792xmlSAX2EndElement(void *ctx, const xmlChar *name ATTRIBUTE_UNUSED)
1793{
1794    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
1795    xmlNodePtr cur;
1796
1797    if (ctx == NULL) return;
1798    cur = ctxt->node;
1799#ifdef DEBUG_SAX
1800    if (name == NULL)
1801        xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndElement(NULL)\n");
1802    else
1803	xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndElement(%s)\n", name);
1804#endif
1805
1806    /* Capture end position and add node */
1807    if (cur != NULL && ctxt->record_info) {
1808      ctxt->nodeInfo->end_pos = ctxt->input->cur - ctxt->input->base;
1809      ctxt->nodeInfo->end_line = ctxt->input->line;
1810      ctxt->nodeInfo->node = cur;
1811      xmlParserAddNodeInfo(ctxt, ctxt->nodeInfo);
1812    }
1813    ctxt->nodemem = -1;
1814
1815#ifdef LIBXML_VALID_ENABLED
1816    if (ctxt->validate && ctxt->wellFormed &&
1817        ctxt->myDoc && ctxt->myDoc->intSubset)
1818        ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc,
1819					     cur);
1820#endif /* LIBXML_VALID_ENABLED */
1821
1822
1823    /*
1824     * end of parsing of this node.
1825     */
1826#ifdef DEBUG_SAX_TREE
1827    xmlGenericError(xmlGenericErrorContext, "popping(%s)\n", cur->name);
1828#endif
1829    nodePop(ctxt);
1830}
1831#endif /* LIBXML_SAX1_ENABLED || LIBXML_HTML_ENABLED || LIBXML_LEGACY_ENABLED */
1832
1833/*
1834 * xmlSAX2TextNode:
1835 * @ctxt:  the parser context
1836 * @str:  the input string
1837 * @len: the string length
1838 *
1839 * Callback for a text node
1840 *
1841 * Returns the newly allocated string or NULL if not needed or error
1842 */
1843static xmlNodePtr
1844xmlSAX2TextNode(xmlParserCtxtPtr ctxt, const xmlChar *str, int len) {
1845    xmlNodePtr ret;
1846    const xmlChar *intern = NULL;
1847
1848    /*
1849     * Allocate
1850     */
1851    if (ctxt->freeElems != NULL) {
1852	ret = ctxt->freeElems;
1853	ctxt->freeElems = ret->next;
1854	ctxt->freeElemsNr--;
1855    } else {
1856	ret = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
1857    }
1858    if (ret == NULL) {
1859        xmlErrMemory(ctxt, "xmlSAX2Characters");
1860	return(NULL);
1861    }
1862    memset(ret, 0, sizeof(xmlNode));
1863    /*
1864     * intern the formatting blanks found between tags, or the
1865     * very short strings
1866     */
1867    if (ctxt->dictNames) {
1868        xmlChar cur = str[len];
1869
1870	if ((len < (int) (2 * sizeof(void *))) &&
1871	    (ctxt->options & XML_PARSE_COMPACT)) {
1872	    /* store the string in the node overriding properties and nsDef */
1873	    xmlChar *tmp = (xmlChar *) &(ret->properties);
1874	    memcpy(tmp, str, len);
1875	    tmp[len] = 0;
1876	    intern = tmp;
1877	} else if ((len <= 3) && ((cur == '"') || (cur == '\'') ||
1878	    ((cur == '<') && (str[len + 1] != '!')))) {
1879	    intern = xmlDictLookup(ctxt->dict, str, len);
1880	} else if (IS_BLANK_CH(*str) && (len < 60) && (cur == '<') &&
1881	           (str[len + 1] != '!')) {
1882	    int i;
1883
1884	    for (i = 1;i < len;i++) {
1885		if (!IS_BLANK_CH(str[i])) goto skip;
1886	    }
1887	    intern = xmlDictLookup(ctxt->dict, str, len);
1888	}
1889    }
1890skip:
1891    ret->type = XML_TEXT_NODE;
1892
1893    ret->name = xmlStringText;
1894    if (intern == NULL) {
1895	ret->content = xmlStrndup(str, len);
1896	if (ret->content == NULL) {
1897	    xmlSAX2ErrMemory(ctxt, "xmlSAX2TextNode");
1898	    xmlFree(ret);
1899	    return(NULL);
1900	}
1901    } else
1902	ret->content = (xmlChar *) intern;
1903
1904    if (ctxt->linenumbers) {
1905	if (ctxt->input != NULL) {
1906	    if (ctxt->input->line < 65535)
1907		ret->line = (short) ctxt->input->line;
1908	    else {
1909	        ret->line = 65535;
1910		if (ctxt->options & XML_PARSE_BIG_LINES)
1911		    ret->psvi = (void *) (long) ctxt->input->line;
1912	    }
1913	}
1914    }
1915
1916    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
1917	xmlRegisterNodeDefaultValue(ret);
1918    return(ret);
1919}
1920
1921#ifdef LIBXML_VALID_ENABLED
1922/*
1923 * xmlSAX2DecodeAttrEntities:
1924 * @ctxt:  the parser context
1925 * @str:  the input string
1926 * @len: the string length
1927 *
1928 * Remove the entities from an attribute value
1929 *
1930 * Returns the newly allocated string or NULL if not needed or error
1931 */
1932static xmlChar *
1933xmlSAX2DecodeAttrEntities(xmlParserCtxtPtr ctxt, const xmlChar *str,
1934                          const xmlChar *end) {
1935    const xmlChar *in;
1936    xmlChar *ret;
1937
1938    in = str;
1939    while (in < end)
1940        if (*in++ == '&')
1941	    goto decode;
1942    return(NULL);
1943decode:
1944    ctxt->depth++;
1945    ret = xmlStringLenDecodeEntities(ctxt, str, end - str,
1946				     XML_SUBSTITUTE_REF, 0,0,0);
1947    ctxt->depth--;
1948    return(ret);
1949}
1950#endif /* LIBXML_VALID_ENABLED */
1951
1952/**
1953 * xmlSAX2AttributeNs:
1954 * @ctx: the user data (XML parser context)
1955 * @localname:  the local name of the attribute
1956 * @prefix:  the attribute namespace prefix if available
1957 * @URI:  the attribute namespace name if available
1958 * @value:  Start of the attribute value
1959 * @valueend: end of the attribute value
1960 *
1961 * Handle an attribute that has been read by the parser.
1962 * The default handling is to convert the attribute into an
1963 * DOM subtree and past it in a new xmlAttr element added to
1964 * the element.
1965 */
1966static void
1967xmlSAX2AttributeNs(xmlParserCtxtPtr ctxt,
1968                   const xmlChar * localname,
1969                   const xmlChar * prefix,
1970		   const xmlChar * value,
1971		   const xmlChar * valueend)
1972{
1973    xmlAttrPtr ret;
1974    xmlNsPtr namespace = NULL;
1975    xmlChar *dup = NULL;
1976
1977    /*
1978     * Note: if prefix == NULL, the attribute is not in the default namespace
1979     */
1980    if (prefix != NULL)
1981	namespace = xmlSearchNs(ctxt->myDoc, ctxt->node, prefix);
1982
1983    /*
1984     * allocate the node
1985     */
1986    if (ctxt->freeAttrs != NULL) {
1987        ret = ctxt->freeAttrs;
1988	ctxt->freeAttrs = ret->next;
1989	ctxt->freeAttrsNr--;
1990	memset(ret, 0, sizeof(xmlAttr));
1991	ret->type = XML_ATTRIBUTE_NODE;
1992
1993	ret->parent = ctxt->node;
1994	ret->doc = ctxt->myDoc;
1995	ret->ns = namespace;
1996
1997	if (ctxt->dictNames)
1998	    ret->name = localname;
1999	else
2000	    ret->name = xmlStrdup(localname);
2001
2002        /* link at the end to preserv order, TODO speed up with a last */
2003	if (ctxt->node->properties == NULL) {
2004	    ctxt->node->properties = ret;
2005	} else {
2006	    xmlAttrPtr prev = ctxt->node->properties;
2007
2008	    while (prev->next != NULL) prev = prev->next;
2009	    prev->next = ret;
2010	    ret->prev = prev;
2011	}
2012
2013	if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
2014	    xmlRegisterNodeDefaultValue((xmlNodePtr)ret);
2015    } else {
2016	if (ctxt->dictNames)
2017	    ret = xmlNewNsPropEatName(ctxt->node, namespace,
2018	                              (xmlChar *) localname, NULL);
2019	else
2020	    ret = xmlNewNsProp(ctxt->node, namespace, localname, NULL);
2021	if (ret == NULL) {
2022	    xmlErrMemory(ctxt, "xmlSAX2AttributeNs");
2023	    return;
2024	}
2025    }
2026
2027    if ((ctxt->replaceEntities == 0) && (!ctxt->html)) {
2028	xmlNodePtr tmp;
2029
2030	/*
2031	 * We know that if there is an entity reference, then
2032	 * the string has been dup'ed and terminates with 0
2033	 * otherwise with ' or "
2034	 */
2035	if (*valueend != 0) {
2036	    tmp = xmlSAX2TextNode(ctxt, value, valueend - value);
2037	    ret->children = tmp;
2038	    ret->last = tmp;
2039	    if (tmp != NULL) {
2040		tmp->doc = ret->doc;
2041		tmp->parent = (xmlNodePtr) ret;
2042	    }
2043	} else {
2044	    ret->children = xmlStringLenGetNodeList(ctxt->myDoc, value,
2045						    valueend - value);
2046	    tmp = ret->children;
2047	    while (tmp != NULL) {
2048	        tmp->doc = ret->doc;
2049		tmp->parent = (xmlNodePtr) ret;
2050		if (tmp->next == NULL)
2051		    ret->last = tmp;
2052		tmp = tmp->next;
2053	    }
2054	}
2055    } else if (value != NULL) {
2056	xmlNodePtr tmp;
2057
2058	tmp = xmlSAX2TextNode(ctxt, value, valueend - value);
2059	ret->children = tmp;
2060	ret->last = tmp;
2061	if (tmp != NULL) {
2062	    tmp->doc = ret->doc;
2063	    tmp->parent = (xmlNodePtr) ret;
2064	}
2065    }
2066
2067#ifdef LIBXML_VALID_ENABLED
2068    if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
2069        ctxt->myDoc && ctxt->myDoc->intSubset) {
2070	/*
2071	 * If we don't substitute entities, the validation should be
2072	 * done on a value with replaced entities anyway.
2073	 */
2074        if (!ctxt->replaceEntities) {
2075	    dup = xmlSAX2DecodeAttrEntities(ctxt, value, valueend);
2076	    if (dup == NULL) {
2077	        if (*valueend == 0) {
2078		    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
2079				    ctxt->myDoc, ctxt->node, ret, value);
2080		} else {
2081		    /*
2082		     * That should already be normalized.
2083		     * cheaper to finally allocate here than duplicate
2084		     * entry points in the full validation code
2085		     */
2086		    dup = xmlStrndup(value, valueend - value);
2087
2088		    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
2089				    ctxt->myDoc, ctxt->node, ret, dup);
2090		}
2091	    } else {
2092	        /*
2093		 * dup now contains a string of the flattened attribute
2094		 * content with entities substitued. Check if we need to
2095		 * apply an extra layer of normalization.
2096		 * It need to be done twice ... it's an extra burden related
2097		 * to the ability to keep references in attributes
2098		 */
2099		if (ctxt->attsSpecial != NULL) {
2100		    xmlChar *nvalnorm;
2101		    xmlChar fn[50];
2102		    xmlChar *fullname;
2103
2104		    fullname = xmlBuildQName(localname, prefix, fn, 50);
2105		    if (fullname != NULL) {
2106			ctxt->vctxt.valid = 1;
2107		        nvalnorm = xmlValidCtxtNormalizeAttributeValue(
2108			                 &ctxt->vctxt, ctxt->myDoc,
2109					 ctxt->node, fullname, dup);
2110			if (ctxt->vctxt.valid != 1)
2111			    ctxt->valid = 0;
2112
2113			if ((fullname != fn) && (fullname != localname))
2114			    xmlFree(fullname);
2115			if (nvalnorm != NULL) {
2116			    xmlFree(dup);
2117			    dup = nvalnorm;
2118			}
2119		    }
2120		}
2121
2122		ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
2123			        ctxt->myDoc, ctxt->node, ret, dup);
2124	    }
2125	} else {
2126	    /*
2127	     * if entities already have been substitued, then
2128	     * the attribute as passed is already normalized
2129	     */
2130	    dup = xmlStrndup(value, valueend - value);
2131
2132	    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
2133	                             ctxt->myDoc, ctxt->node, ret, dup);
2134	}
2135    } else
2136#endif /* LIBXML_VALID_ENABLED */
2137           if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
2138	       (((ctxt->replaceEntities == 0) && (ctxt->external != 2)) ||
2139	        ((ctxt->replaceEntities != 0) && (ctxt->inSubset == 0)))) {
2140        /*
2141	 * when validating, the ID registration is done at the attribute
2142	 * validation level. Otherwise we have to do specific handling here.
2143	 */
2144        if ((prefix == ctxt->str_xml) &&
2145	           (localname[0] == 'i') && (localname[1] == 'd') &&
2146		   (localname[2] == 0)) {
2147	    /*
2148	     * Add the xml:id value
2149	     *
2150	     * Open issue: normalization of the value.
2151	     */
2152	    if (dup == NULL)
2153	        dup = xmlStrndup(value, valueend - value);
2154#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) || defined(LIBXML_LEGACY_ENABLED)
2155#ifdef LIBXML_VALID_ENABLED
2156	    if (xmlValidateNCName(dup, 1) != 0) {
2157	        xmlErrValid(ctxt, XML_DTD_XMLID_VALUE,
2158		      "xml:id : attribute value %s is not an NCName\n",
2159			    (const char *) dup, NULL);
2160	    }
2161#endif
2162#endif
2163	    xmlAddID(&ctxt->vctxt, ctxt->myDoc, dup, ret);
2164	} else if (xmlIsID(ctxt->myDoc, ctxt->node, ret)) {
2165	    /* might be worth duplicate entry points and not copy */
2166	    if (dup == NULL)
2167	        dup = xmlStrndup(value, valueend - value);
2168	    xmlAddID(&ctxt->vctxt, ctxt->myDoc, dup, ret);
2169	} else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret)) {
2170	    if (dup == NULL)
2171	        dup = xmlStrndup(value, valueend - value);
2172	    xmlAddRef(&ctxt->vctxt, ctxt->myDoc, dup, ret);
2173	}
2174    }
2175    if (dup != NULL)
2176	xmlFree(dup);
2177}
2178
2179/**
2180 * xmlSAX2StartElementNs:
2181 * @ctx:  the user data (XML parser context)
2182 * @localname:  the local name of the element
2183 * @prefix:  the element namespace prefix if available
2184 * @URI:  the element namespace name if available
2185 * @nb_namespaces:  number of namespace definitions on that node
2186 * @namespaces:  pointer to the array of prefix/URI pairs namespace definitions
2187 * @nb_attributes:  the number of attributes on that node
2188 * @nb_defaulted:  the number of defaulted attributes.
2189 * @attributes:  pointer to the array of (localname/prefix/URI/value/end)
2190 *               attribute values.
2191 *
2192 * SAX2 callback when an element start has been detected by the parser.
2193 * It provides the namespace informations for the element, as well as
2194 * the new namespace declarations on the element.
2195 */
2196void
2197xmlSAX2StartElementNs(void *ctx,
2198                      const xmlChar *localname,
2199		      const xmlChar *prefix,
2200		      const xmlChar *URI,
2201		      int nb_namespaces,
2202		      const xmlChar **namespaces,
2203		      int nb_attributes,
2204		      int nb_defaulted,
2205		      const xmlChar **attributes)
2206{
2207    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2208    xmlNodePtr ret;
2209    xmlNodePtr parent;
2210    xmlNsPtr last = NULL, ns;
2211    const xmlChar *uri, *pref;
2212    xmlChar *lname = NULL;
2213    int i, j;
2214
2215    if (ctx == NULL) return;
2216    parent = ctxt->node;
2217    /*
2218     * First check on validity:
2219     */
2220    if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) &&
2221        ((ctxt->myDoc->intSubset == NULL) ||
2222	 ((ctxt->myDoc->intSubset->notations == NULL) &&
2223	  (ctxt->myDoc->intSubset->elements == NULL) &&
2224	  (ctxt->myDoc->intSubset->attributes == NULL) &&
2225	  (ctxt->myDoc->intSubset->entities == NULL)))) {
2226	xmlErrValid(ctxt, XML_DTD_NO_DTD,
2227	  "Validation failed: no DTD found !", NULL, NULL);
2228	ctxt->validate = 0;
2229    }
2230
2231    /*
2232     * Take care of the rare case of an undefined namespace prefix
2233     */
2234    if ((prefix != NULL) && (URI == NULL)) {
2235        if (ctxt->dictNames) {
2236	    const xmlChar *fullname;
2237
2238	    fullname = xmlDictQLookup(ctxt->dict, prefix, localname);
2239	    if (fullname != NULL)
2240	        localname = fullname;
2241	} else {
2242	    lname = xmlBuildQName(localname, prefix, NULL, 0);
2243	}
2244    }
2245    /*
2246     * allocate the node
2247     */
2248    if (ctxt->freeElems != NULL) {
2249        ret = ctxt->freeElems;
2250	ctxt->freeElems = ret->next;
2251	ctxt->freeElemsNr--;
2252	memset(ret, 0, sizeof(xmlNode));
2253	ret->type = XML_ELEMENT_NODE;
2254
2255	if (ctxt->dictNames)
2256	    ret->name = localname;
2257	else {
2258	    if (lname == NULL)
2259		ret->name = xmlStrdup(localname);
2260	    else
2261	        ret->name = lname;
2262	    if (ret->name == NULL) {
2263	        xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
2264		return;
2265	    }
2266	}
2267	if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
2268	    xmlRegisterNodeDefaultValue(ret);
2269    } else {
2270	if (ctxt->dictNames)
2271	    ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL,
2272	                               (xmlChar *) localname, NULL);
2273	else if (lname == NULL)
2274	    ret = xmlNewDocNode(ctxt->myDoc, NULL, localname, NULL);
2275	else
2276	    ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL,
2277	                               (xmlChar *) lname, NULL);
2278	if (ret == NULL) {
2279	    xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
2280	    return;
2281	}
2282    }
2283    if (ctxt->linenumbers) {
2284	if (ctxt->input != NULL) {
2285	    if (ctxt->input->line < 65535)
2286		ret->line = (short) ctxt->input->line;
2287	    else
2288	        ret->line = 65535;
2289	}
2290    }
2291
2292    if (parent == NULL) {
2293        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
2294    }
2295    /*
2296     * Build the namespace list
2297     */
2298    for (i = 0,j = 0;j < nb_namespaces;j++) {
2299        pref = namespaces[i++];
2300	uri = namespaces[i++];
2301	ns = xmlNewNs(NULL, uri, pref);
2302	if (ns != NULL) {
2303	    if (last == NULL) {
2304	        ret->nsDef = last = ns;
2305	    } else {
2306	        last->next = ns;
2307		last = ns;
2308	    }
2309	    if ((URI != NULL) && (prefix == pref))
2310		ret->ns = ns;
2311	} else {
2312            /*
2313             * any out of memory error would already have been raised
2314             * but we can't be garanteed it's the actual error due to the
2315             * API, best is to skip in this case
2316             */
2317	    continue;
2318	}
2319#ifdef LIBXML_VALID_ENABLED
2320	if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
2321	    ctxt->myDoc && ctxt->myDoc->intSubset) {
2322	    ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
2323	                                           ret, prefix, ns, uri);
2324	}
2325#endif /* LIBXML_VALID_ENABLED */
2326    }
2327    ctxt->nodemem = -1;
2328
2329    /*
2330     * We are parsing a new node.
2331     */
2332    nodePush(ctxt, ret);
2333
2334    /*
2335     * Link the child element
2336     */
2337    if (parent != NULL) {
2338        if (parent->type == XML_ELEMENT_NODE) {
2339	    xmlAddChild(parent, ret);
2340	} else {
2341	    xmlAddSibling(parent, ret);
2342	}
2343    }
2344
2345    /*
2346     * Insert the defaulted attributes from the DTD only if requested:
2347     */
2348    if ((nb_defaulted != 0) &&
2349        ((ctxt->loadsubset & XML_COMPLETE_ATTRS) == 0))
2350	nb_attributes -= nb_defaulted;
2351
2352    /*
2353     * Search the namespace if it wasn't already found
2354     * Note that, if prefix is NULL, this searches for the default Ns
2355     */
2356    if ((URI != NULL) && (ret->ns == NULL)) {
2357        ret->ns = xmlSearchNs(ctxt->myDoc, parent, prefix);
2358	if ((ret->ns == NULL) && (xmlStrEqual(prefix, BAD_CAST "xml"))) {
2359	    ret->ns = xmlSearchNs(ctxt->myDoc, ret, prefix);
2360	}
2361	if (ret->ns == NULL) {
2362	    ns = xmlNewNs(ret, NULL, prefix);
2363	    if (ns == NULL) {
2364
2365	        xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
2366		return;
2367	    }
2368            if (prefix != NULL)
2369                xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
2370                             "Namespace prefix %s was not found\n",
2371                             prefix, NULL);
2372            else
2373                xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
2374                             "Namespace default prefix was not found\n",
2375                             NULL, NULL);
2376	}
2377    }
2378
2379    /*
2380     * process all the other attributes
2381     */
2382    if (nb_attributes > 0) {
2383        for (j = 0,i = 0;i < nb_attributes;i++,j+=5) {
2384	    /*
2385	     * Handle the rare case of an undefined atribute prefix
2386	     */
2387	    if ((attributes[j+1] != NULL) && (attributes[j+2] == NULL)) {
2388		if (ctxt->dictNames) {
2389		    const xmlChar *fullname;
2390
2391		    fullname = xmlDictQLookup(ctxt->dict, attributes[j+1],
2392		                              attributes[j]);
2393		    if (fullname != NULL) {
2394			xmlSAX2AttributeNs(ctxt, fullname, NULL,
2395			                   attributes[j+3], attributes[j+4]);
2396		        continue;
2397		    }
2398		} else {
2399		    lname = xmlBuildQName(attributes[j], attributes[j+1],
2400		                          NULL, 0);
2401		    if (lname != NULL) {
2402			xmlSAX2AttributeNs(ctxt, lname, NULL,
2403			                   attributes[j+3], attributes[j+4]);
2404			xmlFree(lname);
2405		        continue;
2406		    }
2407		}
2408	    }
2409	    xmlSAX2AttributeNs(ctxt, attributes[j], attributes[j+1],
2410			       attributes[j+3], attributes[j+4]);
2411	}
2412    }
2413
2414#ifdef LIBXML_VALID_ENABLED
2415    /*
2416     * If it's the Document root, finish the DTD validation and
2417     * check the document root element for validity
2418     */
2419    if ((ctxt->validate) && (ctxt->vctxt.finishDtd == XML_CTXT_FINISH_DTD_0)) {
2420	int chk;
2421
2422	chk = xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
2423	if (chk <= 0)
2424	    ctxt->valid = 0;
2425	if (chk < 0)
2426	    ctxt->wellFormed = 0;
2427	ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
2428	ctxt->vctxt.finishDtd = XML_CTXT_FINISH_DTD_1;
2429    }
2430#endif /* LIBXML_VALID_ENABLED */
2431}
2432
2433/**
2434 * xmlSAX2EndElementNs:
2435 * @ctx:  the user data (XML parser context)
2436 * @localname:  the local name of the element
2437 * @prefix:  the element namespace prefix if available
2438 * @URI:  the element namespace name if available
2439 *
2440 * SAX2 callback when an element end has been detected by the parser.
2441 * It provides the namespace informations for the element.
2442 */
2443void
2444xmlSAX2EndElementNs(void *ctx,
2445                    const xmlChar * localname ATTRIBUTE_UNUSED,
2446                    const xmlChar * prefix ATTRIBUTE_UNUSED,
2447		    const xmlChar * URI ATTRIBUTE_UNUSED)
2448{
2449    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2450    xmlParserNodeInfo node_info;
2451    xmlNodePtr cur;
2452
2453    if (ctx == NULL) return;
2454    cur = ctxt->node;
2455    /* Capture end position and add node */
2456    if ((ctxt->record_info) && (cur != NULL)) {
2457        node_info.end_pos = ctxt->input->cur - ctxt->input->base;
2458        node_info.end_line = ctxt->input->line;
2459        node_info.node = cur;
2460        xmlParserAddNodeInfo(ctxt, &node_info);
2461    }
2462    ctxt->nodemem = -1;
2463
2464#ifdef LIBXML_VALID_ENABLED
2465    if (ctxt->validate && ctxt->wellFormed &&
2466        ctxt->myDoc && ctxt->myDoc->intSubset)
2467        ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc, cur);
2468#endif /* LIBXML_VALID_ENABLED */
2469
2470    /*
2471     * end of parsing of this node.
2472     */
2473    nodePop(ctxt);
2474}
2475
2476/**
2477 * xmlSAX2Reference:
2478 * @ctx: the user data (XML parser context)
2479 * @name:  The entity name
2480 *
2481 * called when an entity xmlSAX2Reference is detected.
2482 */
2483void
2484xmlSAX2Reference(void *ctx, const xmlChar *name)
2485{
2486    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2487    xmlNodePtr ret;
2488
2489    if (ctx == NULL) return;
2490#ifdef DEBUG_SAX
2491    xmlGenericError(xmlGenericErrorContext,
2492	    "SAX.xmlSAX2Reference(%s)\n", name);
2493#endif
2494    if (name[0] == '#')
2495	ret = xmlNewCharRef(ctxt->myDoc, name);
2496    else
2497	ret = xmlNewReference(ctxt->myDoc, name);
2498#ifdef DEBUG_SAX_TREE
2499    xmlGenericError(xmlGenericErrorContext,
2500	    "add xmlSAX2Reference %s to %s \n", name, ctxt->node->name);
2501#endif
2502    if (xmlAddChild(ctxt->node, ret) == NULL) {
2503        xmlFreeNode(ret);
2504    }
2505}
2506
2507/**
2508 * xmlSAX2Characters:
2509 * @ctx: the user data (XML parser context)
2510 * @ch:  a xmlChar string
2511 * @len: the number of xmlChar
2512 *
2513 * receiving some chars from the parser.
2514 */
2515void
2516xmlSAX2Characters(void *ctx, const xmlChar *ch, int len)
2517{
2518    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2519    xmlNodePtr lastChild;
2520
2521    if (ctx == NULL) return;
2522#ifdef DEBUG_SAX
2523    xmlGenericError(xmlGenericErrorContext,
2524	    "SAX.xmlSAX2Characters(%.30s, %d)\n", ch, len);
2525#endif
2526    /*
2527     * Handle the data if any. If there is no child
2528     * add it as content, otherwise if the last child is text,
2529     * concatenate it, else create a new node of type text.
2530     */
2531
2532    if (ctxt->node == NULL) {
2533#ifdef DEBUG_SAX_TREE
2534	xmlGenericError(xmlGenericErrorContext,
2535		"add chars: ctxt->node == NULL !\n");
2536#endif
2537        return;
2538    }
2539    lastChild = ctxt->node->last;
2540#ifdef DEBUG_SAX_TREE
2541    xmlGenericError(xmlGenericErrorContext,
2542	    "add chars to %s \n", ctxt->node->name);
2543#endif
2544
2545    /*
2546     * Here we needed an accelerator mechanism in case of very large
2547     * elements. Use an attribute in the structure !!!
2548     */
2549    if (lastChild == NULL) {
2550        lastChild = xmlSAX2TextNode(ctxt, ch, len);
2551	if (lastChild != NULL) {
2552	    ctxt->node->children = lastChild;
2553	    ctxt->node->last = lastChild;
2554	    lastChild->parent = ctxt->node;
2555	    lastChild->doc = ctxt->node->doc;
2556	    ctxt->nodelen = len;
2557	    ctxt->nodemem = len + 1;
2558	} else {
2559	    xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters");
2560	    return;
2561	}
2562    } else {
2563	int coalesceText = (lastChild != NULL) &&
2564	    (lastChild->type == XML_TEXT_NODE) &&
2565	    (lastChild->name == xmlStringText);
2566	if ((coalesceText) && (ctxt->nodemem != 0)) {
2567	    /*
2568	     * The whole point of maintaining nodelen and nodemem,
2569	     * xmlTextConcat is too costly, i.e. compute length,
2570	     * reallocate a new buffer, move data, append ch. Here
2571	     * We try to minimaze realloc() uses and avoid copying
2572	     * and recomputing length over and over.
2573	     */
2574	    if (lastChild->content == (xmlChar *)&(lastChild->properties)) {
2575		lastChild->content = xmlStrdup(lastChild->content);
2576		lastChild->properties = NULL;
2577	    } else if ((ctxt->nodemem == ctxt->nodelen + 1) &&
2578	               (xmlDictOwns(ctxt->dict, lastChild->content))) {
2579		lastChild->content = xmlStrdup(lastChild->content);
2580	    }
2581	    if (lastChild->content == NULL) {
2582		xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters: xmlStrdup returned NULL");
2583		return;
2584 	    }
2585            if (((size_t)ctxt->nodelen + (size_t)len > XML_MAX_TEXT_LENGTH) &&
2586                ((ctxt->options & XML_PARSE_HUGE) == 0)) {
2587                xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters: huge text node");
2588                return;
2589            }
2590	    if ((size_t)ctxt->nodelen > SIZE_T_MAX - (size_t)len ||
2591	        (size_t)ctxt->nodemem + (size_t)len > SIZE_T_MAX / 2) {
2592                xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters overflow prevented");
2593                return;
2594	    }
2595	    if (ctxt->nodelen + len >= ctxt->nodemem) {
2596		xmlChar *newbuf;
2597		size_t size;
2598
2599		size = ctxt->nodemem + len;
2600		size *= 2;
2601                newbuf = (xmlChar *) xmlRealloc(lastChild->content,size);
2602		if (newbuf == NULL) {
2603		    xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters");
2604		    return;
2605		}
2606		ctxt->nodemem = size;
2607		lastChild->content = newbuf;
2608	    }
2609	    memcpy(&lastChild->content[ctxt->nodelen], ch, len);
2610	    ctxt->nodelen += len;
2611	    lastChild->content[ctxt->nodelen] = 0;
2612	} else if (coalesceText) {
2613	    if (xmlTextConcat(lastChild, ch, len)) {
2614		xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters");
2615	    }
2616	    if (ctxt->node->children != NULL) {
2617		ctxt->nodelen = xmlStrlen(lastChild->content);
2618		ctxt->nodemem = ctxt->nodelen + 1;
2619	    }
2620	} else {
2621	    /* Mixed content, first time */
2622	    lastChild = xmlSAX2TextNode(ctxt, ch, len);
2623	    if (lastChild != NULL) {
2624		xmlAddChild(ctxt->node, lastChild);
2625		if (ctxt->node->children != NULL) {
2626		    ctxt->nodelen = len;
2627		    ctxt->nodemem = len + 1;
2628		}
2629	    }
2630	}
2631    }
2632}
2633
2634/**
2635 * xmlSAX2IgnorableWhitespace:
2636 * @ctx: the user data (XML parser context)
2637 * @ch:  a xmlChar string
2638 * @len: the number of xmlChar
2639 *
2640 * receiving some ignorable whitespaces from the parser.
2641 * UNUSED: by default the DOM building will use xmlSAX2Characters
2642 */
2643void
2644xmlSAX2IgnorableWhitespace(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch ATTRIBUTE_UNUSED, int len ATTRIBUTE_UNUSED)
2645{
2646    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
2647#ifdef DEBUG_SAX
2648    xmlGenericError(xmlGenericErrorContext,
2649	    "SAX.xmlSAX2IgnorableWhitespace(%.30s, %d)\n", ch, len);
2650#endif
2651}
2652
2653/**
2654 * xmlSAX2ProcessingInstruction:
2655 * @ctx: the user data (XML parser context)
2656 * @target:  the target name
2657 * @data: the PI data's
2658 *
2659 * A processing instruction has been parsed.
2660 */
2661void
2662xmlSAX2ProcessingInstruction(void *ctx, const xmlChar *target,
2663                      const xmlChar *data)
2664{
2665    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2666    xmlNodePtr ret;
2667    xmlNodePtr parent;
2668
2669    if (ctx == NULL) return;
2670    parent = ctxt->node;
2671#ifdef DEBUG_SAX
2672    xmlGenericError(xmlGenericErrorContext,
2673	    "SAX.xmlSAX2ProcessingInstruction(%s, %s)\n", target, data);
2674#endif
2675
2676    ret = xmlNewDocPI(ctxt->myDoc, target, data);
2677    if (ret == NULL) return;
2678
2679    if (ctxt->linenumbers) {
2680	if (ctxt->input != NULL) {
2681	    if (ctxt->input->line < 65535)
2682		ret->line = (short) ctxt->input->line;
2683	    else
2684	        ret->line = 65535;
2685	}
2686    }
2687    if (ctxt->inSubset == 1) {
2688	xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
2689	return;
2690    } else if (ctxt->inSubset == 2) {
2691	xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
2692	return;
2693    }
2694    if (parent == NULL) {
2695#ifdef DEBUG_SAX_TREE
2696	    xmlGenericError(xmlGenericErrorContext,
2697		    "Setting PI %s as root\n", target);
2698#endif
2699        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
2700	return;
2701    }
2702    if (parent->type == XML_ELEMENT_NODE) {
2703#ifdef DEBUG_SAX_TREE
2704	xmlGenericError(xmlGenericErrorContext,
2705		"adding PI %s child to %s\n", target, parent->name);
2706#endif
2707	xmlAddChild(parent, ret);
2708    } else {
2709#ifdef DEBUG_SAX_TREE
2710	xmlGenericError(xmlGenericErrorContext,
2711		"adding PI %s sibling to ", target);
2712	xmlDebugDumpOneNode(stderr, parent, 0);
2713#endif
2714	xmlAddSibling(parent, ret);
2715    }
2716}
2717
2718/**
2719 * xmlSAX2Comment:
2720 * @ctx: the user data (XML parser context)
2721 * @value:  the xmlSAX2Comment content
2722 *
2723 * A xmlSAX2Comment has been parsed.
2724 */
2725void
2726xmlSAX2Comment(void *ctx, const xmlChar *value)
2727{
2728    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2729    xmlNodePtr ret;
2730    xmlNodePtr parent;
2731
2732    if (ctx == NULL) return;
2733    parent = ctxt->node;
2734#ifdef DEBUG_SAX
2735    xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2Comment(%s)\n", value);
2736#endif
2737    ret = xmlNewDocComment(ctxt->myDoc, value);
2738    if (ret == NULL) return;
2739    if (ctxt->linenumbers) {
2740	if (ctxt->input != NULL) {
2741	    if (ctxt->input->line < 65535)
2742		ret->line = (short) ctxt->input->line;
2743	    else
2744	        ret->line = 65535;
2745	}
2746    }
2747
2748    if (ctxt->inSubset == 1) {
2749	xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
2750	return;
2751    } else if (ctxt->inSubset == 2) {
2752	xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
2753	return;
2754    }
2755    if (parent == NULL) {
2756#ifdef DEBUG_SAX_TREE
2757	    xmlGenericError(xmlGenericErrorContext,
2758		    "Setting xmlSAX2Comment as root\n");
2759#endif
2760        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
2761	return;
2762    }
2763    if (parent->type == XML_ELEMENT_NODE) {
2764#ifdef DEBUG_SAX_TREE
2765	xmlGenericError(xmlGenericErrorContext,
2766		"adding xmlSAX2Comment child to %s\n", parent->name);
2767#endif
2768	xmlAddChild(parent, ret);
2769    } else {
2770#ifdef DEBUG_SAX_TREE
2771	xmlGenericError(xmlGenericErrorContext,
2772		"adding xmlSAX2Comment sibling to ");
2773	xmlDebugDumpOneNode(stderr, parent, 0);
2774#endif
2775	xmlAddSibling(parent, ret);
2776    }
2777}
2778
2779/**
2780 * xmlSAX2CDataBlock:
2781 * @ctx: the user data (XML parser context)
2782 * @value:  The pcdata content
2783 * @len:  the block length
2784 *
2785 * called when a pcdata block has been parsed
2786 */
2787void
2788xmlSAX2CDataBlock(void *ctx, const xmlChar *value, int len)
2789{
2790    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2791    xmlNodePtr ret, lastChild;
2792
2793    if (ctx == NULL) return;
2794#ifdef DEBUG_SAX
2795    xmlGenericError(xmlGenericErrorContext,
2796	    "SAX.pcdata(%.10s, %d)\n", value, len);
2797#endif
2798    lastChild = xmlGetLastChild(ctxt->node);
2799#ifdef DEBUG_SAX_TREE
2800    xmlGenericError(xmlGenericErrorContext,
2801	    "add chars to %s \n", ctxt->node->name);
2802#endif
2803    if ((lastChild != NULL) &&
2804        (lastChild->type == XML_CDATA_SECTION_NODE)) {
2805	xmlTextConcat(lastChild, value, len);
2806    } else {
2807	ret = xmlNewCDataBlock(ctxt->myDoc, value, len);
2808	xmlAddChild(ctxt->node, ret);
2809    }
2810}
2811
2812static int xmlSAX2DefaultVersionValue = 2;
2813
2814#ifdef LIBXML_SAX1_ENABLED
2815/**
2816 * xmlSAXDefaultVersion:
2817 * @version:  the version, 1 or 2
2818 *
2819 * Set the default version of SAX used globally by the library.
2820 * By default, during initialization the default is set to 2.
2821 * Note that it is generally a better coding style to use
2822 * xmlSAXVersion() to set up the version explicitly for a given
2823 * parsing context.
2824 *
2825 * Returns the previous value in case of success and -1 in case of error.
2826 */
2827int
2828xmlSAXDefaultVersion(int version)
2829{
2830    int ret = xmlSAX2DefaultVersionValue;
2831
2832    if ((version != 1) && (version != 2))
2833        return(-1);
2834    xmlSAX2DefaultVersionValue = version;
2835    return(ret);
2836}
2837#endif /* LIBXML_SAX1_ENABLED */
2838
2839/**
2840 * xmlSAXVersion:
2841 * @hdlr:  the SAX handler
2842 * @version:  the version, 1 or 2
2843 *
2844 * Initialize the default XML SAX handler according to the version
2845 *
2846 * Returns 0 in case of success and -1 in case of error.
2847 */
2848int
2849xmlSAXVersion(xmlSAXHandler *hdlr, int version)
2850{
2851    if (hdlr == NULL) return(-1);
2852    if (version == 2) {
2853	hdlr->startElement = NULL;
2854	hdlr->endElement = NULL;
2855	hdlr->startElementNs = xmlSAX2StartElementNs;
2856	hdlr->endElementNs = xmlSAX2EndElementNs;
2857	hdlr->serror = NULL;
2858	hdlr->initialized = XML_SAX2_MAGIC;
2859#ifdef LIBXML_SAX1_ENABLED
2860    } else if (version == 1) {
2861	hdlr->startElement = xmlSAX2StartElement;
2862	hdlr->endElement = xmlSAX2EndElement;
2863	hdlr->initialized = 1;
2864#endif /* LIBXML_SAX1_ENABLED */
2865    } else
2866        return(-1);
2867    hdlr->internalSubset = xmlSAX2InternalSubset;
2868    hdlr->externalSubset = xmlSAX2ExternalSubset;
2869    hdlr->isStandalone = xmlSAX2IsStandalone;
2870    hdlr->hasInternalSubset = xmlSAX2HasInternalSubset;
2871    hdlr->hasExternalSubset = xmlSAX2HasExternalSubset;
2872    hdlr->resolveEntity = xmlSAX2ResolveEntity;
2873    hdlr->getEntity = xmlSAX2GetEntity;
2874    hdlr->getParameterEntity = xmlSAX2GetParameterEntity;
2875    hdlr->entityDecl = xmlSAX2EntityDecl;
2876    hdlr->attributeDecl = xmlSAX2AttributeDecl;
2877    hdlr->elementDecl = xmlSAX2ElementDecl;
2878    hdlr->notationDecl = xmlSAX2NotationDecl;
2879    hdlr->unparsedEntityDecl = xmlSAX2UnparsedEntityDecl;
2880    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
2881    hdlr->startDocument = xmlSAX2StartDocument;
2882    hdlr->endDocument = xmlSAX2EndDocument;
2883    hdlr->reference = xmlSAX2Reference;
2884    hdlr->characters = xmlSAX2Characters;
2885    hdlr->cdataBlock = xmlSAX2CDataBlock;
2886    hdlr->ignorableWhitespace = xmlSAX2Characters;
2887    hdlr->processingInstruction = xmlSAX2ProcessingInstruction;
2888    hdlr->comment = xmlSAX2Comment;
2889    hdlr->warning = xmlParserWarning;
2890    hdlr->error = xmlParserError;
2891    hdlr->fatalError = xmlParserError;
2892
2893    return(0);
2894}
2895
2896/**
2897 * xmlSAX2InitDefaultSAXHandler:
2898 * @hdlr:  the SAX handler
2899 * @warning:  flag if non-zero sets the handler warning procedure
2900 *
2901 * Initialize the default XML SAX2 handler
2902 */
2903void
2904xmlSAX2InitDefaultSAXHandler(xmlSAXHandler *hdlr, int warning)
2905{
2906    if ((hdlr == NULL) || (hdlr->initialized != 0))
2907	return;
2908
2909    xmlSAXVersion(hdlr, xmlSAX2DefaultVersionValue);
2910    if (warning == 0)
2911	hdlr->warning = NULL;
2912    else
2913	hdlr->warning = xmlParserWarning;
2914}
2915
2916/**
2917 * xmlDefaultSAXHandlerInit:
2918 *
2919 * Initialize the default SAX2 handler
2920 */
2921void
2922xmlDefaultSAXHandlerInit(void)
2923{
2924#ifdef LIBXML_SAX1_ENABLED
2925    xmlSAXVersion((xmlSAXHandlerPtr) &xmlDefaultSAXHandler, 1);
2926#endif /* LIBXML_SAX1_ENABLED */
2927}
2928
2929#ifdef LIBXML_HTML_ENABLED
2930
2931/**
2932 * xmlSAX2InitHtmlDefaultSAXHandler:
2933 * @hdlr:  the SAX handler
2934 *
2935 * Initialize the default HTML SAX2 handler
2936 */
2937void
2938xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr)
2939{
2940    if ((hdlr == NULL) || (hdlr->initialized != 0))
2941	return;
2942
2943    hdlr->internalSubset = xmlSAX2InternalSubset;
2944    hdlr->externalSubset = NULL;
2945    hdlr->isStandalone = NULL;
2946    hdlr->hasInternalSubset = NULL;
2947    hdlr->hasExternalSubset = NULL;
2948    hdlr->resolveEntity = NULL;
2949    hdlr->getEntity = xmlSAX2GetEntity;
2950    hdlr->getParameterEntity = NULL;
2951    hdlr->entityDecl = NULL;
2952    hdlr->attributeDecl = NULL;
2953    hdlr->elementDecl = NULL;
2954    hdlr->notationDecl = NULL;
2955    hdlr->unparsedEntityDecl = NULL;
2956    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
2957    hdlr->startDocument = xmlSAX2StartDocument;
2958    hdlr->endDocument = xmlSAX2EndDocument;
2959    hdlr->startElement = xmlSAX2StartElement;
2960    hdlr->endElement = xmlSAX2EndElement;
2961    hdlr->reference = NULL;
2962    hdlr->characters = xmlSAX2Characters;
2963    hdlr->cdataBlock = xmlSAX2CDataBlock;
2964    hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
2965    hdlr->processingInstruction = xmlSAX2ProcessingInstruction;
2966    hdlr->comment = xmlSAX2Comment;
2967    hdlr->warning = xmlParserWarning;
2968    hdlr->error = xmlParserError;
2969    hdlr->fatalError = xmlParserError;
2970
2971    hdlr->initialized = 1;
2972}
2973
2974/**
2975 * htmlDefaultSAXHandlerInit:
2976 *
2977 * Initialize the default SAX handler
2978 */
2979void
2980htmlDefaultSAXHandlerInit(void)
2981{
2982    xmlSAX2InitHtmlDefaultSAXHandler((xmlSAXHandlerPtr) &htmlDefaultSAXHandler);
2983}
2984
2985#endif /* LIBXML_HTML_ENABLED */
2986
2987#ifdef LIBXML_DOCB_ENABLED
2988
2989/**
2990 * xmlSAX2InitDocbDefaultSAXHandler:
2991 * @hdlr:  the SAX handler
2992 *
2993 * Initialize the default DocBook SAX2 handler
2994 */
2995void
2996xmlSAX2InitDocbDefaultSAXHandler(xmlSAXHandler *hdlr)
2997{
2998    if ((hdlr == NULL) || (hdlr->initialized != 0))
2999	return;
3000
3001    hdlr->internalSubset = xmlSAX2InternalSubset;
3002    hdlr->externalSubset = NULL;
3003    hdlr->isStandalone = xmlSAX2IsStandalone;
3004    hdlr->hasInternalSubset = xmlSAX2HasInternalSubset;
3005    hdlr->hasExternalSubset = xmlSAX2HasExternalSubset;
3006    hdlr->resolveEntity = xmlSAX2ResolveEntity;
3007    hdlr->getEntity = xmlSAX2GetEntity;
3008    hdlr->getParameterEntity = NULL;
3009    hdlr->entityDecl = xmlSAX2EntityDecl;
3010    hdlr->attributeDecl = NULL;
3011    hdlr->elementDecl = NULL;
3012    hdlr->notationDecl = NULL;
3013    hdlr->unparsedEntityDecl = NULL;
3014    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
3015    hdlr->startDocument = xmlSAX2StartDocument;
3016    hdlr->endDocument = xmlSAX2EndDocument;
3017    hdlr->startElement = xmlSAX2StartElement;
3018    hdlr->endElement = xmlSAX2EndElement;
3019    hdlr->reference = xmlSAX2Reference;
3020    hdlr->characters = xmlSAX2Characters;
3021    hdlr->cdataBlock = NULL;
3022    hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
3023    hdlr->processingInstruction = NULL;
3024    hdlr->comment = xmlSAX2Comment;
3025    hdlr->warning = xmlParserWarning;
3026    hdlr->error = xmlParserError;
3027    hdlr->fatalError = xmlParserError;
3028
3029    hdlr->initialized = 1;
3030}
3031
3032/**
3033 * docbDefaultSAXHandlerInit:
3034 *
3035 * Initialize the default SAX handler
3036 */
3037void
3038docbDefaultSAXHandlerInit(void)
3039{
3040    xmlSAX2InitDocbDefaultSAXHandler((xmlSAXHandlerPtr) &docbDefaultSAXHandler);
3041}
3042
3043#endif /* LIBXML_DOCB_ENABLED */
3044#define bottom_SAX2
3045#include "elfgcchack.h"
3046