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: */
58: static void
59: xmlSAX2ErrMemory(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: */
96: static void
97: xmlErrValid(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: */
136: static void
137: xmlFatalErrMsg(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: */
167: static void
168: xmlWarnMsg(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: */
192: static void
193: xmlNsErrMsg(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: */
216: static void
217: xmlNsWarnMsg(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: */
239: const xmlChar *
240: xmlSAX2GetPublicId(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: */
255: const xmlChar *
256: xmlSAX2GetSystemId(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: */
271: int
272: xmlSAX2GetLineNumber(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: */
287: int
288: xmlSAX2GetColumnNumber(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: */
303: int
304: xmlSAX2IsStandalone(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: */
319: int
320: xmlSAX2HasInternalSubset(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: */
335: int
336: xmlSAX2HasExternalSubset(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: */
352: void
353: xmlSAX2InternalSubset(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: */
390: void
391: xmlSAX2ExternalSubset(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: */
517: xmlParserInputPtr
518: xmlSAX2ResolveEntity(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: */
554: xmlEntityPtr
555: xmlSAX2GetEntity(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: */
634: xmlEntityPtr
635: xmlSAX2GetParameterEntity(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: */
662: void
663: xmlSAX2EntityDecl(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: */
732: void
733: xmlSAX2AttributeDecl(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: */
800: void
801: xmlSAX2ElementDecl(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: */
846: void
847: xmlSAX2NotationDecl(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: */
897: void
898: xmlSAX2UnparsedEntityDecl(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: */
965: void
966: xmlSAX2SetDocumentLocator(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: */
981: void
982: xmlSAX2StartDocument(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: ctxt->myDoc->properties = XML_DOC_HTML;
998: ctxt->myDoc->parseFlags = ctxt->options;
999: if (ctxt->myDoc == NULL) {
1000: xmlSAX2ErrMemory(ctxt, "xmlSAX2StartDocument");
1001: return;
1002: }
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: */
1046: void
1047: xmlSAX2EndDocument(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)
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: */
1094: static void
1095: xmlSAX2AttributeInternal(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: } else {
1181: val = (xmlChar *) value;
1182: }
1183:
1184: if (val[0] != 0) {
1185: xmlURIPtr uri;
1186:
1187: uri = xmlParseURI((const char *)val);
1188: if (uri == NULL) {
1189: if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
1190: ctxt->sax->warning(ctxt->userData,
1191: "xmlns: %s not a valid URI\n", val);
1192: } else {
1193: if (uri->scheme == NULL) {
1194: if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
1195: ctxt->sax->warning(ctxt->userData,
1196: "xmlns: URI %s is not absolute\n", val);
1197: }
1198: xmlFreeURI(uri);
1199: }
1200: }
1201:
1202: /* a default namespace definition */
1203: nsret = xmlNewNs(ctxt->node, val, NULL);
1204:
1205: #ifdef LIBXML_VALID_ENABLED
1206: /*
1207: * Validate also for namespace decls, they are attributes from
1208: * an XML-1.0 perspective
1209: */
1210: if (nsret != NULL && ctxt->validate && ctxt->wellFormed &&
1211: ctxt->myDoc && ctxt->myDoc->intSubset)
1212: ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
1213: ctxt->node, prefix, nsret, val);
1214: #endif /* LIBXML_VALID_ENABLED */
1215: if (name != NULL)
1216: xmlFree(name);
1217: if (nval != NULL)
1218: xmlFree(nval);
1219: if (val != value)
1220: xmlFree(val);
1221: return;
1222: }
1223: if ((!ctxt->html) &&
1224: (ns != NULL) && (ns[0] == 'x') && (ns[1] == 'm') && (ns[2] == 'l') &&
1225: (ns[3] == 'n') && (ns[4] == 's') && (ns[5] == 0)) {
1226: xmlNsPtr nsret;
1227: xmlChar *val;
1228:
1229: if (!ctxt->replaceEntities) {
1230: ctxt->depth++;
1231: val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
1232: 0,0,0);
1233: ctxt->depth--;
1234: if (val == NULL) {
1235: xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1236: xmlFree(ns);
1237: if (name != NULL)
1238: xmlFree(name);
1239: return;
1240: }
1241: } else {
1242: val = (xmlChar *) value;
1243: }
1244:
1245: if (val[0] == 0) {
1246: xmlNsErrMsg(ctxt, XML_NS_ERR_EMPTY,
1247: "Empty namespace name for prefix %s\n", name, NULL);
1248: }
1249: if ((ctxt->pedantic != 0) && (val[0] != 0)) {
1250: xmlURIPtr uri;
1251:
1252: uri = xmlParseURI((const char *)val);
1253: if (uri == NULL) {
1254: xmlNsWarnMsg(ctxt, XML_WAR_NS_URI,
1255: "xmlns:%s: %s not a valid URI\n", name, value);
1256: } else {
1257: if (uri->scheme == NULL) {
1258: xmlNsWarnMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
1259: "xmlns:%s: URI %s is not absolute\n", name, value);
1260: }
1261: xmlFreeURI(uri);
1262: }
1263: }
1264:
1265: /* a standard namespace definition */
1266: nsret = xmlNewNs(ctxt->node, val, name);
1267: xmlFree(ns);
1268: #ifdef LIBXML_VALID_ENABLED
1269: /*
1270: * Validate also for namespace decls, they are attributes from
1271: * an XML-1.0 perspective
1272: */
1273: if (nsret != NULL && ctxt->validate && ctxt->wellFormed &&
1274: ctxt->myDoc && ctxt->myDoc->intSubset)
1275: ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
1276: ctxt->node, prefix, nsret, value);
1277: #endif /* LIBXML_VALID_ENABLED */
1278: if (name != NULL)
1279: xmlFree(name);
1280: if (nval != NULL)
1281: xmlFree(nval);
1282: if (val != value)
1283: xmlFree(val);
1284: return;
1285: }
1286:
1287: if (ns != NULL) {
1288: namespace = xmlSearchNs(ctxt->myDoc, ctxt->node, ns);
1289:
1290: if (namespace == NULL) {
1291: xmlNsErrMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
1292: "Namespace prefix %s of attribute %s is not defined\n",
1293: ns, name);
1294: } else {
1295: xmlAttrPtr prop;
1296:
1297: prop = ctxt->node->properties;
1298: while (prop != NULL) {
1299: if (prop->ns != NULL) {
1300: if ((xmlStrEqual(name, prop->name)) &&
1301: ((namespace == prop->ns) ||
1302: (xmlStrEqual(namespace->href, prop->ns->href)))) {
1303: xmlNsErrMsg(ctxt, XML_ERR_ATTRIBUTE_REDEFINED,
1304: "Attribute %s in %s redefined\n",
1305: name, namespace->href);
1306: ctxt->wellFormed = 0;
1307: if (ctxt->recovery == 0) ctxt->disableSAX = 1;
1308: goto error;
1309: }
1310: }
1311: prop = prop->next;
1312: }
1313: }
1314: } else {
1315: namespace = NULL;
1316: }
1317:
1318: /* !!!!!! <a toto:arg="" xmlns:toto="http://toto.com"> */
1319: ret = xmlNewNsPropEatName(ctxt->node, namespace, name, NULL);
1320:
1321: if (ret != NULL) {
1322: if ((ctxt->replaceEntities == 0) && (!ctxt->html)) {
1323: xmlNodePtr tmp;
1324:
1325: ret->children = xmlStringGetNodeList(ctxt->myDoc, value);
1326: tmp = ret->children;
1327: while (tmp != NULL) {
1328: tmp->parent = (xmlNodePtr) ret;
1329: if (tmp->next == NULL)
1330: ret->last = tmp;
1331: tmp = tmp->next;
1332: }
1333: } else if (value != NULL) {
1334: ret->children = xmlNewDocText(ctxt->myDoc, value);
1335: ret->last = ret->children;
1336: if (ret->children != NULL)
1337: ret->children->parent = (xmlNodePtr) ret;
1338: }
1339: }
1340:
1341: #ifdef LIBXML_VALID_ENABLED
1342: if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
1343: ctxt->myDoc && ctxt->myDoc->intSubset) {
1344:
1345: /*
1346: * If we don't substitute entities, the validation should be
1347: * done on a value with replaced entities anyway.
1348: */
1349: if (!ctxt->replaceEntities) {
1350: xmlChar *val;
1351:
1352: ctxt->depth++;
1353: val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
1354: 0,0,0);
1355: ctxt->depth--;
1356:
1357: if (val == NULL)
1358: ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
1359: ctxt->myDoc, ctxt->node, ret, value);
1360: else {
1361: xmlChar *nvalnorm;
1362:
1363: /*
1364: * Do the last stage of the attribute normalization
1365: * It need to be done twice ... it's an extra burden related
1366: * to the ability to keep xmlSAX2References in attributes
1367: */
1368: nvalnorm = xmlValidNormalizeAttributeValue(ctxt->myDoc,
1369: ctxt->node, fullname, val);
1370: if (nvalnorm != NULL) {
1371: xmlFree(val);
1372: val = nvalnorm;
1373: }
1374:
1375: ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
1376: ctxt->myDoc, ctxt->node, ret, val);
1377: xmlFree(val);
1378: }
1379: } else {
1380: ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt, ctxt->myDoc,
1381: ctxt->node, ret, value);
1382: }
1383: } else
1384: #endif /* LIBXML_VALID_ENABLED */
1385: if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
1386: (((ctxt->replaceEntities == 0) && (ctxt->external != 2)) ||
1387: ((ctxt->replaceEntities != 0) && (ctxt->inSubset == 0)))) {
1388: /*
1389: * when validating, the ID registration is done at the attribute
1390: * validation level. Otherwise we have to do specific handling here.
1391: */
1392: if (xmlStrEqual(fullname, BAD_CAST "xml:id")) {
1393: /*
1394: * Add the xml:id value
1395: *
1396: * Open issue: normalization of the value.
1397: */
1398: if (xmlValidateNCName(value, 1) != 0) {
1399: xmlErrValid(ctxt, XML_DTD_XMLID_VALUE,
1400: "xml:id : attribute value %s is not an NCName\n",
1401: (const char *) value, NULL);
1402: }
1403: xmlAddID(&ctxt->vctxt, ctxt->myDoc, value, ret);
1404: } else if (xmlIsID(ctxt->myDoc, ctxt->node, ret))
1405: xmlAddID(&ctxt->vctxt, ctxt->myDoc, value, ret);
1406: else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret))
1407: xmlAddRef(&ctxt->vctxt, ctxt->myDoc, value, ret);
1408: }
1409:
1410: error:
1411: if (nval != NULL)
1412: xmlFree(nval);
1413: if (ns != NULL)
1414: xmlFree(ns);
1415: }
1416:
1417: /*
1418: * xmlCheckDefaultedAttributes:
1419: *
1420: * Check defaulted attributes from the DTD
1421: */
1422: static void
1423: xmlCheckDefaultedAttributes(xmlParserCtxtPtr ctxt, const xmlChar *name,
1424: const xmlChar *prefix, const xmlChar **atts) {
1425: xmlElementPtr elemDecl;
1426: const xmlChar *att;
1427: int internal = 1;
1428: int i;
1429:
1430: elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->intSubset, name, prefix);
1431: if (elemDecl == NULL) {
1432: elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->extSubset, name, prefix);
1433: internal = 0;
1434: }
1435:
1436: process_external_subset:
1437:
1438: if (elemDecl != NULL) {
1439: xmlAttributePtr attr = elemDecl->attributes;
1440: /*
1441: * Check against defaulted attributes from the external subset
1442: * if the document is stamped as standalone
1443: */
1444: if ((ctxt->myDoc->standalone == 1) &&
1445: (ctxt->myDoc->extSubset != NULL) &&
1446: (ctxt->validate)) {
1447: while (attr != NULL) {
1448: if ((attr->defaultValue != NULL) &&
1449: (xmlGetDtdQAttrDesc(ctxt->myDoc->extSubset,
1450: attr->elem, attr->name,
1451: attr->prefix) == attr) &&
1452: (xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
1453: attr->elem, attr->name,
1454: attr->prefix) == NULL)) {
1455: xmlChar *fulln;
1456:
1457: if (attr->prefix != NULL) {
1458: fulln = xmlStrdup(attr->prefix);
1459: fulln = xmlStrcat(fulln, BAD_CAST ":");
1460: fulln = xmlStrcat(fulln, attr->name);
1461: } else {
1462: fulln = xmlStrdup(attr->name);
1463: }
1464: if (fulln == NULL) {
1465: xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1466: break;
1467: }
1468:
1469: /*
1470: * Check that the attribute is not declared in the
1471: * serialization
1472: */
1473: att = NULL;
1474: if (atts != NULL) {
1475: i = 0;
1476: att = atts[i];
1477: while (att != NULL) {
1478: if (xmlStrEqual(att, fulln))
1479: break;
1480: i += 2;
1481: att = atts[i];
1482: }
1483: }
1484: if (att == NULL) {
1485: xmlErrValid(ctxt, XML_DTD_STANDALONE_DEFAULTED,
1486: "standalone: attribute %s on %s defaulted from external subset\n",
1487: (const char *)fulln,
1488: (const char *)attr->elem);
1489: }
1490: xmlFree(fulln);
1491: }
1492: attr = attr->nexth;
1493: }
1494: }
1495:
1496: /*
1497: * Actually insert defaulted values when needed
1498: */
1499: attr = elemDecl->attributes;
1500: while (attr != NULL) {
1501: /*
1502: * Make sure that attributes redefinition occuring in the
1503: * internal subset are not overriden by definitions in the
1504: * external subset.
1505: */
1506: if (attr->defaultValue != NULL) {
1507: /*
1508: * the element should be instantiated in the tree if:
1509: * - this is a namespace prefix
1510: * - the user required for completion in the tree
1511: * like XSLT
1512: * - there isn't already an attribute definition
1513: * in the internal subset overriding it.
1514: */
1515: if (((attr->prefix != NULL) &&
1516: (xmlStrEqual(attr->prefix, BAD_CAST "xmlns"))) ||
1517: ((attr->prefix == NULL) &&
1518: (xmlStrEqual(attr->name, BAD_CAST "xmlns"))) ||
1519: (ctxt->loadsubset & XML_COMPLETE_ATTRS)) {
1520: xmlAttributePtr tst;
1521:
1522: tst = xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
1523: attr->elem, attr->name,
1524: attr->prefix);
1525: if ((tst == attr) || (tst == NULL)) {
1526: xmlChar fn[50];
1527: xmlChar *fulln;
1528:
1529: fulln = xmlBuildQName(attr->name, attr->prefix, fn, 50);
1530: if (fulln == NULL) {
1531: xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1532: return;
1533: }
1534:
1535: /*
1536: * Check that the attribute is not declared in the
1537: * serialization
1538: */
1539: att = NULL;
1540: if (atts != NULL) {
1541: i = 0;
1542: att = atts[i];
1543: while (att != NULL) {
1544: if (xmlStrEqual(att, fulln))
1545: break;
1546: i += 2;
1547: att = atts[i];
1548: }
1549: }
1550: if (att == NULL) {
1551: xmlSAX2AttributeInternal(ctxt, fulln,
1552: attr->defaultValue, prefix);
1553: }
1554: if ((fulln != fn) && (fulln != attr->name))
1555: xmlFree(fulln);
1556: }
1557: }
1558: }
1559: attr = attr->nexth;
1560: }
1561: if (internal == 1) {
1562: elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->extSubset,
1563: name, prefix);
1564: internal = 0;
1565: goto process_external_subset;
1566: }
1567: }
1568: }
1569:
1570: /**
1571: * xmlSAX2StartElement:
1572: * @ctx: the user data (XML parser context)
1573: * @fullname: The element name, including namespace prefix
1574: * @atts: An array of name/value attributes pairs, NULL terminated
1575: *
1576: * called when an opening tag has been processed.
1577: */
1578: void
1579: xmlSAX2StartElement(void *ctx, const xmlChar *fullname, const xmlChar **atts)
1580: {
1581: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
1582: xmlNodePtr ret;
1583: xmlNodePtr parent;
1584: xmlNsPtr ns;
1585: xmlChar *name;
1586: xmlChar *prefix;
1587: const xmlChar *att;
1588: const xmlChar *value;
1589: int i;
1590:
1591: if ((ctx == NULL) || (fullname == NULL) || (ctxt->myDoc == NULL)) return;
1592: parent = ctxt->node;
1593: #ifdef DEBUG_SAX
1594: xmlGenericError(xmlGenericErrorContext,
1595: "SAX.xmlSAX2StartElement(%s)\n", fullname);
1596: #endif
1597:
1598: /*
1599: * First check on validity:
1600: */
1601: if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) &&
1602: ((ctxt->myDoc->intSubset == NULL) ||
1603: ((ctxt->myDoc->intSubset->notations == NULL) &&
1604: (ctxt->myDoc->intSubset->elements == NULL) &&
1605: (ctxt->myDoc->intSubset->attributes == NULL) &&
1606: (ctxt->myDoc->intSubset->entities == NULL)))) {
1607: xmlErrValid(ctxt, XML_ERR_NO_DTD,
1608: "Validation failed: no DTD found !", NULL, NULL);
1609: ctxt->validate = 0;
1610: }
1611:
1612:
1613: /*
1614: * Split the full name into a namespace prefix and the tag name
1615: */
1616: name = xmlSplitQName(ctxt, fullname, &prefix);
1617:
1618:
1619: /*
1620: * Note : the namespace resolution is deferred until the end of the
1621: * attributes parsing, since local namespace can be defined as
1622: * an attribute at this level.
1623: */
1624: ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL, name, NULL);
1625: if (ret == NULL) {
1626: if (prefix != NULL)
1627: xmlFree(prefix);
1628: xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
1629: return;
1630: }
1631: if (ctxt->myDoc->children == NULL) {
1632: #ifdef DEBUG_SAX_TREE
1633: xmlGenericError(xmlGenericErrorContext, "Setting %s as root\n", name);
1634: #endif
1635: xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
1636: } else if (parent == NULL) {
1637: parent = ctxt->myDoc->children;
1638: }
1639: ctxt->nodemem = -1;
1640: if (ctxt->linenumbers) {
1641: if (ctxt->input != NULL) {
1642: if (ctxt->input->line < 65535)
1643: ret->line = (short) ctxt->input->line;
1644: else
1645: ret->line = 65535;
1646: }
1647: }
1648:
1649: /*
1650: * We are parsing a new node.
1651: */
1652: #ifdef DEBUG_SAX_TREE
1653: xmlGenericError(xmlGenericErrorContext, "pushing(%s)\n", name);
1654: #endif
1655: nodePush(ctxt, ret);
1656:
1657: /*
1658: * Link the child element
1659: */
1660: if (parent != NULL) {
1661: if (parent->type == XML_ELEMENT_NODE) {
1662: #ifdef DEBUG_SAX_TREE
1663: xmlGenericError(xmlGenericErrorContext,
1664: "adding child %s to %s\n", name, parent->name);
1665: #endif
1666: xmlAddChild(parent, ret);
1667: } else {
1668: #ifdef DEBUG_SAX_TREE
1669: xmlGenericError(xmlGenericErrorContext,
1670: "adding sibling %s to ", name);
1671: xmlDebugDumpOneNode(stderr, parent, 0);
1672: #endif
1673: xmlAddSibling(parent, ret);
1674: }
1675: }
1676:
1677: /*
1678: * Insert all the defaulted attributes from the DTD especially namespaces
1679: */
1680: if ((!ctxt->html) &&
1681: ((ctxt->myDoc->intSubset != NULL) ||
1682: (ctxt->myDoc->extSubset != NULL))) {
1683: xmlCheckDefaultedAttributes(ctxt, name, prefix, atts);
1684: }
1685:
1686: /*
1687: * process all the attributes whose name start with "xmlns"
1688: */
1689: if (atts != NULL) {
1690: i = 0;
1691: att = atts[i++];
1692: value = atts[i++];
1693: if (!ctxt->html) {
1694: while ((att != NULL) && (value != NULL)) {
1695: if ((att[0] == 'x') && (att[1] == 'm') && (att[2] == 'l') &&
1696: (att[3] == 'n') && (att[4] == 's'))
1697: xmlSAX2AttributeInternal(ctxt, att, value, prefix);
1698:
1699: att = atts[i++];
1700: value = atts[i++];
1701: }
1702: }
1703: }
1704:
1705: /*
1706: * Search the namespace, note that since the attributes have been
1707: * processed, the local namespaces are available.
1708: */
1709: ns = xmlSearchNs(ctxt->myDoc, ret, prefix);
1710: if ((ns == NULL) && (parent != NULL))
1711: ns = xmlSearchNs(ctxt->myDoc, parent, prefix);
1712: if ((prefix != NULL) && (ns == NULL)) {
1713: ns = xmlNewNs(ret, NULL, prefix);
1714: xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
1715: "Namespace prefix %s is not defined\n",
1716: prefix, NULL);
1717: }
1718:
1719: /*
1720: * set the namespace node, making sure that if the default namspace
1721: * is unbound on a parent we simply kee it NULL
1722: */
1723: if ((ns != NULL) && (ns->href != NULL) &&
1724: ((ns->href[0] != 0) || (ns->prefix != NULL)))
1725: xmlSetNs(ret, ns);
1726:
1727: /*
1728: * process all the other attributes
1729: */
1730: if (atts != NULL) {
1731: i = 0;
1732: att = atts[i++];
1733: value = atts[i++];
1734: if (ctxt->html) {
1735: while (att != NULL) {
1736: xmlSAX2AttributeInternal(ctxt, att, value, NULL);
1737: att = atts[i++];
1738: value = atts[i++];
1739: }
1740: } else {
1741: while ((att != NULL) && (value != NULL)) {
1742: if ((att[0] != 'x') || (att[1] != 'm') || (att[2] != 'l') ||
1743: (att[3] != 'n') || (att[4] != 's'))
1744: xmlSAX2AttributeInternal(ctxt, att, value, NULL);
1745:
1746: /*
1747: * Next ones
1748: */
1749: att = atts[i++];
1750: value = atts[i++];
1751: }
1752: }
1753: }
1754:
1755: #ifdef LIBXML_VALID_ENABLED
1756: /*
1757: * If it's the Document root, finish the DTD validation and
1758: * check the document root element for validity
1759: */
1760: if ((ctxt->validate) && (ctxt->vctxt.finishDtd == XML_CTXT_FINISH_DTD_0)) {
1761: int chk;
1762:
1763: chk = xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
1764: if (chk <= 0)
1765: ctxt->valid = 0;
1766: if (chk < 0)
1767: ctxt->wellFormed = 0;
1768: ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
1769: ctxt->vctxt.finishDtd = XML_CTXT_FINISH_DTD_1;
1770: }
1771: #endif /* LIBXML_VALID_ENABLED */
1772:
1773: if (prefix != NULL)
1774: xmlFree(prefix);
1775:
1776: }
1777:
1778: /**
1779: * xmlSAX2EndElement:
1780: * @ctx: the user data (XML parser context)
1781: * @name: The element name
1782: *
1783: * called when the end of an element has been detected.
1784: */
1785: void
1786: xmlSAX2EndElement(void *ctx, const xmlChar *name ATTRIBUTE_UNUSED)
1787: {
1788: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
1789: xmlNodePtr cur;
1790:
1791: if (ctx == NULL) return;
1792: cur = ctxt->node;
1793: #ifdef DEBUG_SAX
1794: if (name == NULL)
1795: xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndElement(NULL)\n");
1796: else
1797: xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndElement(%s)\n", name);
1798: #endif
1799:
1800: /* Capture end position and add node */
1801: if (cur != NULL && ctxt->record_info) {
1802: ctxt->nodeInfo->end_pos = ctxt->input->cur - ctxt->input->base;
1803: ctxt->nodeInfo->end_line = ctxt->input->line;
1804: ctxt->nodeInfo->node = cur;
1805: xmlParserAddNodeInfo(ctxt, ctxt->nodeInfo);
1806: }
1807: ctxt->nodemem = -1;
1808:
1809: #ifdef LIBXML_VALID_ENABLED
1810: if (ctxt->validate && ctxt->wellFormed &&
1811: ctxt->myDoc && ctxt->myDoc->intSubset)
1812: ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc,
1813: cur);
1814: #endif /* LIBXML_VALID_ENABLED */
1815:
1816:
1817: /*
1818: * end of parsing of this node.
1819: */
1820: #ifdef DEBUG_SAX_TREE
1821: xmlGenericError(xmlGenericErrorContext, "popping(%s)\n", cur->name);
1822: #endif
1823: nodePop(ctxt);
1824: }
1825: #endif /* LIBXML_SAX1_ENABLED || LIBXML_HTML_ENABLE */
1826:
1827: /*
1828: * xmlSAX2TextNode:
1829: * @ctxt: the parser context
1830: * @str: the input string
1831: * @len: the string length
1832: *
1833: * Callback for a text node
1834: *
1835: * Returns the newly allocated string or NULL if not needed or error
1836: */
1837: static xmlNodePtr
1838: xmlSAX2TextNode(xmlParserCtxtPtr ctxt, const xmlChar *str, int len) {
1839: xmlNodePtr ret;
1840: const xmlChar *intern = NULL;
1841:
1842: /*
1843: * Allocate
1844: */
1845: if (ctxt->freeElems != NULL) {
1846: ret = ctxt->freeElems;
1847: ctxt->freeElems = ret->next;
1848: ctxt->freeElemsNr--;
1849: } else {
1850: ret = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
1851: }
1852: if (ret == NULL) {
1853: xmlErrMemory(ctxt, "xmlSAX2Characters");
1854: return(NULL);
1855: }
1856: memset(ret, 0, sizeof(xmlNode));
1857: /*
1858: * intern the formatting blanks found between tags, or the
1859: * very short strings
1860: */
1861: if (ctxt->dictNames) {
1862: xmlChar cur = str[len];
1863:
1864: if ((len < (int) (2 * sizeof(void *))) &&
1865: (ctxt->options & XML_PARSE_COMPACT)) {
1866: /* store the string in the node overriding properties and nsDef */
1867: xmlChar *tmp = (xmlChar *) &(ret->properties);
1868: memcpy(tmp, str, len);
1869: tmp[len] = 0;
1870: intern = tmp;
1871: } else if ((len <= 3) && ((cur == '"') || (cur == '\'') ||
1872: ((cur == '<') && (str[len + 1] != '!')))) {
1873: intern = xmlDictLookup(ctxt->dict, str, len);
1874: } else if (IS_BLANK_CH(*str) && (len < 60) && (cur == '<') &&
1875: (str[len + 1] != '!')) {
1876: int i;
1877:
1878: for (i = 1;i < len;i++) {
1879: if (!IS_BLANK_CH(str[i])) goto skip;
1880: }
1881: intern = xmlDictLookup(ctxt->dict, str, len);
1882: }
1883: }
1884: skip:
1885: ret->type = XML_TEXT_NODE;
1886:
1887: ret->name = xmlStringText;
1888: if (intern == NULL) {
1889: ret->content = xmlStrndup(str, len);
1890: if (ret->content == NULL) {
1891: xmlSAX2ErrMemory(ctxt, "xmlSAX2TextNode");
1892: xmlFree(ret);
1893: return(NULL);
1894: }
1895: } else
1896: ret->content = (xmlChar *) intern;
1897:
1898: if (ctxt->linenumbers) {
1899: if (ctxt->input != NULL) {
1900: if (ctxt->input->line < 65535)
1901: ret->line = (short) ctxt->input->line;
1902: else {
1903: ret->line = 65535;
1904: if (ctxt->options & XML_PARSE_BIG_LINES)
1905: ret->psvi = (void *) (long) ctxt->input->line;
1906: }
1907: }
1908: }
1909:
1910: if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
1911: xmlRegisterNodeDefaultValue(ret);
1912: return(ret);
1913: }
1914:
1915: #ifdef LIBXML_VALID_ENABLED
1916: /*
1917: * xmlSAX2DecodeAttrEntities:
1918: * @ctxt: the parser context
1919: * @str: the input string
1920: * @len: the string length
1921: *
1922: * Remove the entities from an attribute value
1923: *
1924: * Returns the newly allocated string or NULL if not needed or error
1925: */
1926: static xmlChar *
1927: xmlSAX2DecodeAttrEntities(xmlParserCtxtPtr ctxt, const xmlChar *str,
1928: const xmlChar *end) {
1929: const xmlChar *in;
1930: xmlChar *ret;
1931:
1932: in = str;
1933: while (in < end)
1934: if (*in++ == '&')
1935: goto decode;
1936: return(NULL);
1937: decode:
1938: ctxt->depth++;
1939: ret = xmlStringLenDecodeEntities(ctxt, str, end - str,
1940: XML_SUBSTITUTE_REF, 0,0,0);
1941: ctxt->depth--;
1942: return(ret);
1943: }
1944: #endif /* LIBXML_VALID_ENABLED */
1945:
1946: /**
1947: * xmlSAX2AttributeNs:
1948: * @ctx: the user data (XML parser context)
1949: * @localname: the local name of the attribute
1950: * @prefix: the attribute namespace prefix if available
1951: * @URI: the attribute namespace name if available
1952: * @value: Start of the attribute value
1953: * @valueend: end of the attribute value
1954: *
1955: * Handle an attribute that has been read by the parser.
1956: * The default handling is to convert the attribute into an
1957: * DOM subtree and past it in a new xmlAttr element added to
1958: * the element.
1959: */
1960: static void
1961: xmlSAX2AttributeNs(xmlParserCtxtPtr ctxt,
1962: const xmlChar * localname,
1963: const xmlChar * prefix,
1964: const xmlChar * value,
1965: const xmlChar * valueend)
1966: {
1967: xmlAttrPtr ret;
1968: xmlNsPtr namespace = NULL;
1969: xmlChar *dup = NULL;
1970:
1971: /*
1972: * Note: if prefix == NULL, the attribute is not in the default namespace
1973: */
1974: if (prefix != NULL)
1975: namespace = xmlSearchNs(ctxt->myDoc, ctxt->node, prefix);
1976:
1977: /*
1978: * allocate the node
1979: */
1980: if (ctxt->freeAttrs != NULL) {
1981: ret = ctxt->freeAttrs;
1982: ctxt->freeAttrs = ret->next;
1983: ctxt->freeAttrsNr--;
1984: memset(ret, 0, sizeof(xmlAttr));
1985: ret->type = XML_ATTRIBUTE_NODE;
1986:
1987: ret->parent = ctxt->node;
1988: ret->doc = ctxt->myDoc;
1989: ret->ns = namespace;
1990:
1991: if (ctxt->dictNames)
1992: ret->name = localname;
1993: else
1994: ret->name = xmlStrdup(localname);
1995:
1996: /* link at the end to preserv order, TODO speed up with a last */
1997: if (ctxt->node->properties == NULL) {
1998: ctxt->node->properties = ret;
1999: } else {
2000: xmlAttrPtr prev = ctxt->node->properties;
2001:
2002: while (prev->next != NULL) prev = prev->next;
2003: prev->next = ret;
2004: ret->prev = prev;
2005: }
2006:
2007: if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
2008: xmlRegisterNodeDefaultValue((xmlNodePtr)ret);
2009: } else {
2010: if (ctxt->dictNames)
2011: ret = xmlNewNsPropEatName(ctxt->node, namespace,
2012: (xmlChar *) localname, NULL);
2013: else
2014: ret = xmlNewNsProp(ctxt->node, namespace, localname, NULL);
2015: if (ret == NULL) {
2016: xmlErrMemory(ctxt, "xmlSAX2AttributeNs");
2017: return;
2018: }
2019: }
2020:
2021: if ((ctxt->replaceEntities == 0) && (!ctxt->html)) {
2022: xmlNodePtr tmp;
2023:
2024: /*
2025: * We know that if there is an entity reference, then
2026: * the string has been dup'ed and terminates with 0
2027: * otherwise with ' or "
2028: */
2029: if (*valueend != 0) {
2030: tmp = xmlSAX2TextNode(ctxt, value, valueend - value);
2031: ret->children = tmp;
2032: ret->last = tmp;
2033: if (tmp != NULL) {
2034: tmp->doc = ret->doc;
2035: tmp->parent = (xmlNodePtr) ret;
2036: }
2037: } else {
2038: ret->children = xmlStringLenGetNodeList(ctxt->myDoc, value,
2039: valueend - value);
2040: tmp = ret->children;
2041: while (tmp != NULL) {
2042: tmp->doc = ret->doc;
2043: tmp->parent = (xmlNodePtr) ret;
2044: if (tmp->next == NULL)
2045: ret->last = tmp;
2046: tmp = tmp->next;
2047: }
2048: }
2049: } else if (value != NULL) {
2050: xmlNodePtr tmp;
2051:
2052: tmp = xmlSAX2TextNode(ctxt, value, valueend - value);
2053: ret->children = tmp;
2054: ret->last = tmp;
2055: if (tmp != NULL) {
2056: tmp->doc = ret->doc;
2057: tmp->parent = (xmlNodePtr) ret;
2058: }
2059: }
2060:
2061: #ifdef LIBXML_VALID_ENABLED
2062: if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
2063: ctxt->myDoc && ctxt->myDoc->intSubset) {
2064: /*
2065: * If we don't substitute entities, the validation should be
2066: * done on a value with replaced entities anyway.
2067: */
2068: if (!ctxt->replaceEntities) {
2069: dup = xmlSAX2DecodeAttrEntities(ctxt, value, valueend);
2070: if (dup == NULL) {
2071: if (*valueend == 0) {
2072: ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
2073: ctxt->myDoc, ctxt->node, ret, value);
2074: } else {
2075: /*
2076: * That should already be normalized.
2077: * cheaper to finally allocate here than duplicate
2078: * entry points in the full validation code
2079: */
2080: dup = xmlStrndup(value, valueend - value);
2081:
2082: ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
2083: ctxt->myDoc, ctxt->node, ret, dup);
2084: }
2085: } else {
2086: /*
2087: * dup now contains a string of the flattened attribute
2088: * content with entities substitued. Check if we need to
2089: * apply an extra layer of normalization.
2090: * It need to be done twice ... it's an extra burden related
2091: * to the ability to keep references in attributes
2092: */
2093: if (ctxt->attsSpecial != NULL) {
2094: xmlChar *nvalnorm;
2095: xmlChar fn[50];
2096: xmlChar *fullname;
2097:
2098: fullname = xmlBuildQName(localname, prefix, fn, 50);
2099: if (fullname != NULL) {
2100: ctxt->vctxt.valid = 1;
2101: nvalnorm = xmlValidCtxtNormalizeAttributeValue(
2102: &ctxt->vctxt, ctxt->myDoc,
2103: ctxt->node, fullname, dup);
2104: if (ctxt->vctxt.valid != 1)
2105: ctxt->valid = 0;
2106:
2107: if ((fullname != fn) && (fullname != localname))
2108: xmlFree(fullname);
2109: if (nvalnorm != NULL) {
2110: xmlFree(dup);
2111: dup = nvalnorm;
2112: }
2113: }
2114: }
2115:
2116: ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
2117: ctxt->myDoc, ctxt->node, ret, dup);
2118: }
2119: } else {
2120: /*
2121: * if entities already have been substitued, then
2122: * the attribute as passed is already normalized
2123: */
2124: dup = xmlStrndup(value, valueend - value);
2125:
2126: ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
2127: ctxt->myDoc, ctxt->node, ret, dup);
2128: }
2129: } else
2130: #endif /* LIBXML_VALID_ENABLED */
2131: if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
2132: (((ctxt->replaceEntities == 0) && (ctxt->external != 2)) ||
2133: ((ctxt->replaceEntities != 0) && (ctxt->inSubset == 0)))) {
2134: /*
2135: * when validating, the ID registration is done at the attribute
2136: * validation level. Otherwise we have to do specific handling here.
2137: */
2138: if ((prefix == ctxt->str_xml) &&
2139: (localname[0] == 'i') && (localname[1] == 'd') &&
2140: (localname[2] == 0)) {
2141: /*
2142: * Add the xml:id value
2143: *
2144: * Open issue: normalization of the value.
2145: */
2146: if (dup == NULL)
2147: dup = xmlStrndup(value, valueend - value);
2148: #ifdef LIBXML_VALID_ENABLED
2149: if (xmlValidateNCName(dup, 1) != 0) {
2150: xmlErrValid(ctxt, XML_DTD_XMLID_VALUE,
2151: "xml:id : attribute value %s is not an NCName\n",
2152: (const char *) dup, NULL);
2153: }
2154: #endif
2155: xmlAddID(&ctxt->vctxt, ctxt->myDoc, dup, ret);
2156: } else if (xmlIsID(ctxt->myDoc, ctxt->node, ret)) {
2157: /* might be worth duplicate entry points and not copy */
2158: if (dup == NULL)
2159: dup = xmlStrndup(value, valueend - value);
2160: xmlAddID(&ctxt->vctxt, ctxt->myDoc, dup, ret);
2161: } else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret)) {
2162: if (dup == NULL)
2163: dup = xmlStrndup(value, valueend - value);
2164: xmlAddRef(&ctxt->vctxt, ctxt->myDoc, dup, ret);
2165: }
2166: }
2167: if (dup != NULL)
2168: xmlFree(dup);
2169: }
2170:
2171: /**
2172: * xmlSAX2StartElementNs:
2173: * @ctx: the user data (XML parser context)
2174: * @localname: the local name of the element
2175: * @prefix: the element namespace prefix if available
2176: * @URI: the element namespace name if available
2177: * @nb_namespaces: number of namespace definitions on that node
2178: * @namespaces: pointer to the array of prefix/URI pairs namespace definitions
2179: * @nb_attributes: the number of attributes on that node
2180: * @nb_defaulted: the number of defaulted attributes.
2181: * @attributes: pointer to the array of (localname/prefix/URI/value/end)
2182: * attribute values.
2183: *
2184: * SAX2 callback when an element start has been detected by the parser.
2185: * It provides the namespace informations for the element, as well as
2186: * the new namespace declarations on the element.
2187: */
2188: void
2189: xmlSAX2StartElementNs(void *ctx,
2190: const xmlChar *localname,
2191: const xmlChar *prefix,
2192: const xmlChar *URI,
2193: int nb_namespaces,
2194: const xmlChar **namespaces,
2195: int nb_attributes,
2196: int nb_defaulted,
2197: const xmlChar **attributes)
2198: {
2199: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2200: xmlNodePtr ret;
2201: xmlNodePtr parent;
2202: xmlNsPtr last = NULL, ns;
2203: const xmlChar *uri, *pref;
2204: xmlChar *lname = NULL;
2205: int i, j;
2206:
2207: if (ctx == NULL) return;
2208: parent = ctxt->node;
2209: /*
2210: * First check on validity:
2211: */
2212: if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) &&
2213: ((ctxt->myDoc->intSubset == NULL) ||
2214: ((ctxt->myDoc->intSubset->notations == NULL) &&
2215: (ctxt->myDoc->intSubset->elements == NULL) &&
2216: (ctxt->myDoc->intSubset->attributes == NULL) &&
2217: (ctxt->myDoc->intSubset->entities == NULL)))) {
2218: xmlErrValid(ctxt, XML_DTD_NO_DTD,
2219: "Validation failed: no DTD found !", NULL, NULL);
2220: ctxt->validate = 0;
2221: }
2222:
2223: /*
2224: * Take care of the rare case of an undefined namespace prefix
2225: */
2226: if ((prefix != NULL) && (URI == NULL)) {
2227: if (ctxt->dictNames) {
2228: const xmlChar *fullname;
2229:
2230: fullname = xmlDictQLookup(ctxt->dict, prefix, localname);
2231: if (fullname != NULL)
2232: localname = fullname;
2233: } else {
2234: lname = xmlBuildQName(localname, prefix, NULL, 0);
2235: }
2236: }
2237: /*
2238: * allocate the node
2239: */
2240: if (ctxt->freeElems != NULL) {
2241: ret = ctxt->freeElems;
2242: ctxt->freeElems = ret->next;
2243: ctxt->freeElemsNr--;
2244: memset(ret, 0, sizeof(xmlNode));
2245: ret->type = XML_ELEMENT_NODE;
2246:
2247: if (ctxt->dictNames)
2248: ret->name = localname;
2249: else {
2250: if (lname == NULL)
2251: ret->name = xmlStrdup(localname);
2252: else
2253: ret->name = lname;
2254: if (ret->name == NULL) {
2255: xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
2256: return;
2257: }
2258: }
2259: if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
2260: xmlRegisterNodeDefaultValue(ret);
2261: } else {
2262: if (ctxt->dictNames)
2263: ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL,
2264: (xmlChar *) localname, NULL);
2265: else if (lname == NULL)
2266: ret = xmlNewDocNode(ctxt->myDoc, NULL, localname, NULL);
2267: else
2268: ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL,
2269: (xmlChar *) lname, NULL);
2270: if (ret == NULL) {
2271: xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
2272: return;
2273: }
2274: }
2275: if (ctxt->linenumbers) {
2276: if (ctxt->input != NULL) {
2277: if (ctxt->input->line < 65535)
2278: ret->line = (short) ctxt->input->line;
2279: else
2280: ret->line = 65535;
2281: }
2282: }
2283:
2284: if (parent == NULL) {
2285: xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
2286: }
2287: /*
2288: * Build the namespace list
2289: */
2290: for (i = 0,j = 0;j < nb_namespaces;j++) {
2291: pref = namespaces[i++];
2292: uri = namespaces[i++];
2293: ns = xmlNewNs(NULL, uri, pref);
2294: if (ns != NULL) {
2295: if (last == NULL) {
2296: ret->nsDef = last = ns;
2297: } else {
2298: last->next = ns;
2299: last = ns;
2300: }
2301: if ((URI != NULL) && (prefix == pref))
2302: ret->ns = ns;
2303: } else {
2304: /*
2305: * any out of memory error would already have been raised
2306: * but we can't be garanteed it's the actual error due to the
2307: * API, best is to skip in this case
2308: */
2309: continue;
2310: }
2311: #ifdef LIBXML_VALID_ENABLED
2312: if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
2313: ctxt->myDoc && ctxt->myDoc->intSubset) {
2314: ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
2315: ret, prefix, ns, uri);
2316: }
2317: #endif /* LIBXML_VALID_ENABLED */
2318: }
2319: ctxt->nodemem = -1;
2320:
2321: /*
2322: * We are parsing a new node.
2323: */
2324: nodePush(ctxt, ret);
2325:
2326: /*
2327: * Link the child element
2328: */
2329: if (parent != NULL) {
2330: if (parent->type == XML_ELEMENT_NODE) {
2331: xmlAddChild(parent, ret);
2332: } else {
2333: xmlAddSibling(parent, ret);
2334: }
2335: }
2336:
2337: /*
2338: * Insert the defaulted attributes from the DTD only if requested:
2339: */
2340: if ((nb_defaulted != 0) &&
2341: ((ctxt->loadsubset & XML_COMPLETE_ATTRS) == 0))
2342: nb_attributes -= nb_defaulted;
2343:
2344: /*
2345: * Search the namespace if it wasn't already found
2346: * Note that, if prefix is NULL, this searches for the default Ns
2347: */
2348: if ((URI != NULL) && (ret->ns == NULL)) {
2349: ret->ns = xmlSearchNs(ctxt->myDoc, parent, prefix);
2350: if ((ret->ns == NULL) && (xmlStrEqual(prefix, BAD_CAST "xml"))) {
2351: ret->ns = xmlSearchNs(ctxt->myDoc, ret, prefix);
2352: }
2353: if (ret->ns == NULL) {
2354: ns = xmlNewNs(ret, NULL, prefix);
2355: if (ns == NULL) {
2356:
2357: xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
2358: return;
2359: }
2360: if (prefix != NULL)
2361: xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
2362: "Namespace prefix %s was not found\n",
2363: prefix, NULL);
2364: else
2365: xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
2366: "Namespace default prefix was not found\n",
2367: NULL, NULL);
2368: }
2369: }
2370:
2371: /*
2372: * process all the other attributes
2373: */
2374: if (nb_attributes > 0) {
2375: for (j = 0,i = 0;i < nb_attributes;i++,j+=5) {
2376: /*
2377: * Handle the rare case of an undefined atribute prefix
2378: */
2379: if ((attributes[j+1] != NULL) && (attributes[j+2] == NULL)) {
2380: if (ctxt->dictNames) {
2381: const xmlChar *fullname;
2382:
2383: fullname = xmlDictQLookup(ctxt->dict, attributes[j+1],
2384: attributes[j]);
2385: if (fullname != NULL) {
2386: xmlSAX2AttributeNs(ctxt, fullname, NULL,
2387: attributes[j+3], attributes[j+4]);
2388: continue;
2389: }
2390: } else {
2391: lname = xmlBuildQName(attributes[j], attributes[j+1],
2392: NULL, 0);
2393: if (lname != NULL) {
2394: xmlSAX2AttributeNs(ctxt, lname, NULL,
2395: attributes[j+3], attributes[j+4]);
2396: xmlFree(lname);
2397: continue;
2398: }
2399: }
2400: }
2401: xmlSAX2AttributeNs(ctxt, attributes[j], attributes[j+1],
2402: attributes[j+3], attributes[j+4]);
2403: }
2404: }
2405:
2406: #ifdef LIBXML_VALID_ENABLED
2407: /*
2408: * If it's the Document root, finish the DTD validation and
2409: * check the document root element for validity
2410: */
2411: if ((ctxt->validate) && (ctxt->vctxt.finishDtd == XML_CTXT_FINISH_DTD_0)) {
2412: int chk;
2413:
2414: chk = xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
2415: if (chk <= 0)
2416: ctxt->valid = 0;
2417: if (chk < 0)
2418: ctxt->wellFormed = 0;
2419: ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
2420: ctxt->vctxt.finishDtd = XML_CTXT_FINISH_DTD_1;
2421: }
2422: #endif /* LIBXML_VALID_ENABLED */
2423: }
2424:
2425: /**
2426: * xmlSAX2EndElementNs:
2427: * @ctx: the user data (XML parser context)
2428: * @localname: the local name of the element
2429: * @prefix: the element namespace prefix if available
2430: * @URI: the element namespace name if available
2431: *
2432: * SAX2 callback when an element end has been detected by the parser.
2433: * It provides the namespace informations for the element.
2434: */
2435: void
2436: xmlSAX2EndElementNs(void *ctx,
2437: const xmlChar * localname ATTRIBUTE_UNUSED,
2438: const xmlChar * prefix ATTRIBUTE_UNUSED,
2439: const xmlChar * URI ATTRIBUTE_UNUSED)
2440: {
2441: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2442: xmlParserNodeInfo node_info;
2443: xmlNodePtr cur;
2444:
2445: if (ctx == NULL) return;
2446: cur = ctxt->node;
2447: /* Capture end position and add node */
2448: if ((ctxt->record_info) && (cur != NULL)) {
2449: node_info.end_pos = ctxt->input->cur - ctxt->input->base;
2450: node_info.end_line = ctxt->input->line;
2451: node_info.node = cur;
2452: xmlParserAddNodeInfo(ctxt, &node_info);
2453: }
2454: ctxt->nodemem = -1;
2455:
2456: #ifdef LIBXML_VALID_ENABLED
2457: if (ctxt->validate && ctxt->wellFormed &&
2458: ctxt->myDoc && ctxt->myDoc->intSubset)
2459: ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc, cur);
2460: #endif /* LIBXML_VALID_ENABLED */
2461:
2462: /*
2463: * end of parsing of this node.
2464: */
2465: nodePop(ctxt);
2466: }
2467:
2468: /**
2469: * xmlSAX2Reference:
2470: * @ctx: the user data (XML parser context)
2471: * @name: The entity name
2472: *
2473: * called when an entity xmlSAX2Reference is detected.
2474: */
2475: void
2476: xmlSAX2Reference(void *ctx, const xmlChar *name)
2477: {
2478: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2479: xmlNodePtr ret;
2480:
2481: if (ctx == NULL) return;
2482: #ifdef DEBUG_SAX
2483: xmlGenericError(xmlGenericErrorContext,
2484: "SAX.xmlSAX2Reference(%s)\n", name);
2485: #endif
2486: if (name[0] == '#')
2487: ret = xmlNewCharRef(ctxt->myDoc, name);
2488: else
2489: ret = xmlNewReference(ctxt->myDoc, name);
2490: #ifdef DEBUG_SAX_TREE
2491: xmlGenericError(xmlGenericErrorContext,
2492: "add xmlSAX2Reference %s to %s \n", name, ctxt->node->name);
2493: #endif
2494: if (xmlAddChild(ctxt->node, ret) == NULL) {
2495: xmlFreeNode(ret);
2496: }
2497: }
2498:
2499: /**
2500: * xmlSAX2Characters:
2501: * @ctx: the user data (XML parser context)
2502: * @ch: a xmlChar string
2503: * @len: the number of xmlChar
2504: *
2505: * receiving some chars from the parser.
2506: */
2507: void
2508: xmlSAX2Characters(void *ctx, const xmlChar *ch, int len)
2509: {
2510: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2511: xmlNodePtr lastChild;
2512:
2513: if (ctx == NULL) return;
2514: #ifdef DEBUG_SAX
2515: xmlGenericError(xmlGenericErrorContext,
2516: "SAX.xmlSAX2Characters(%.30s, %d)\n", ch, len);
2517: #endif
2518: /*
2519: * Handle the data if any. If there is no child
2520: * add it as content, otherwise if the last child is text,
2521: * concatenate it, else create a new node of type text.
2522: */
2523:
2524: if (ctxt->node == NULL) {
2525: #ifdef DEBUG_SAX_TREE
2526: xmlGenericError(xmlGenericErrorContext,
2527: "add chars: ctxt->node == NULL !\n");
2528: #endif
2529: return;
2530: }
2531: lastChild = ctxt->node->last;
2532: #ifdef DEBUG_SAX_TREE
2533: xmlGenericError(xmlGenericErrorContext,
2534: "add chars to %s \n", ctxt->node->name);
2535: #endif
2536:
2537: /*
2538: * Here we needed an accelerator mechanism in case of very large
2539: * elements. Use an attribute in the structure !!!
2540: */
2541: if (lastChild == NULL) {
2542: lastChild = xmlSAX2TextNode(ctxt, ch, len);
2543: if (lastChild != NULL) {
2544: ctxt->node->children = lastChild;
2545: ctxt->node->last = lastChild;
2546: lastChild->parent = ctxt->node;
2547: lastChild->doc = ctxt->node->doc;
2548: ctxt->nodelen = len;
2549: ctxt->nodemem = len + 1;
2550: } else {
2551: xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters");
2552: return;
2553: }
2554: } else {
2555: int coalesceText = (lastChild != NULL) &&
2556: (lastChild->type == XML_TEXT_NODE) &&
2557: (lastChild->name == xmlStringText);
2558: if ((coalesceText) && (ctxt->nodemem != 0)) {
2559: /*
2560: * The whole point of maintaining nodelen and nodemem,
2561: * xmlTextConcat is too costly, i.e. compute length,
2562: * reallocate a new buffer, move data, append ch. Here
2563: * We try to minimaze realloc() uses and avoid copying
2564: * and recomputing length over and over.
2565: */
2566: if (lastChild->content == (xmlChar *)&(lastChild->properties)) {
2567: lastChild->content = xmlStrdup(lastChild->content);
2568: lastChild->properties = NULL;
2569: } else if ((ctxt->nodemem == ctxt->nodelen + 1) &&
2570: (xmlDictOwns(ctxt->dict, lastChild->content))) {
2571: lastChild->content = xmlStrdup(lastChild->content);
2572: }
2573: if (((size_t)ctxt->nodelen + (size_t)len > XML_MAX_TEXT_LENGTH) &&
2574: ((ctxt->options & XML_PARSE_HUGE) == 0)) {
2575: xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters: huge text node");
2576: return;
2577: }
2578: if ((size_t)ctxt->nodelen > SIZE_T_MAX - (size_t)len ||
2579: (size_t)ctxt->nodemem + (size_t)len > SIZE_T_MAX / 2) {
2580: xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters overflow prevented");
2581: return;
2582: }
2583: if (ctxt->nodelen + len >= ctxt->nodemem) {
2584: xmlChar *newbuf;
2585: size_t size;
2586:
2587: size = ctxt->nodemem + len;
2588: size *= 2;
2589: newbuf = (xmlChar *) xmlRealloc(lastChild->content,size);
2590: if (newbuf == NULL) {
2591: xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters");
2592: return;
2593: }
2594: ctxt->nodemem = size;
2595: lastChild->content = newbuf;
2596: }
2597: memcpy(&lastChild->content[ctxt->nodelen], ch, len);
2598: ctxt->nodelen += len;
2599: lastChild->content[ctxt->nodelen] = 0;
2600: } else if (coalesceText) {
2601: if (xmlTextConcat(lastChild, ch, len)) {
2602: xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters");
2603: }
2604: if (ctxt->node->children != NULL) {
2605: ctxt->nodelen = xmlStrlen(lastChild->content);
2606: ctxt->nodemem = ctxt->nodelen + 1;
2607: }
2608: } else {
2609: /* Mixed content, first time */
2610: lastChild = xmlSAX2TextNode(ctxt, ch, len);
2611: if (lastChild != NULL) {
2612: xmlAddChild(ctxt->node, lastChild);
2613: if (ctxt->node->children != NULL) {
2614: ctxt->nodelen = len;
2615: ctxt->nodemem = len + 1;
2616: }
2617: }
2618: }
2619: }
2620: }
2621:
2622: /**
2623: * xmlSAX2IgnorableWhitespace:
2624: * @ctx: the user data (XML parser context)
2625: * @ch: a xmlChar string
2626: * @len: the number of xmlChar
2627: *
2628: * receiving some ignorable whitespaces from the parser.
2629: * UNUSED: by default the DOM building will use xmlSAX2Characters
2630: */
2631: void
2632: xmlSAX2IgnorableWhitespace(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch ATTRIBUTE_UNUSED, int len ATTRIBUTE_UNUSED)
2633: {
2634: /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
2635: #ifdef DEBUG_SAX
2636: xmlGenericError(xmlGenericErrorContext,
2637: "SAX.xmlSAX2IgnorableWhitespace(%.30s, %d)\n", ch, len);
2638: #endif
2639: }
2640:
2641: /**
2642: * xmlSAX2ProcessingInstruction:
2643: * @ctx: the user data (XML parser context)
2644: * @target: the target name
2645: * @data: the PI data's
2646: *
2647: * A processing instruction has been parsed.
2648: */
2649: void
2650: xmlSAX2ProcessingInstruction(void *ctx, const xmlChar *target,
2651: const xmlChar *data)
2652: {
2653: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2654: xmlNodePtr ret;
2655: xmlNodePtr parent;
2656:
2657: if (ctx == NULL) return;
2658: parent = ctxt->node;
2659: #ifdef DEBUG_SAX
2660: xmlGenericError(xmlGenericErrorContext,
2661: "SAX.xmlSAX2ProcessingInstruction(%s, %s)\n", target, data);
2662: #endif
2663:
2664: ret = xmlNewDocPI(ctxt->myDoc, target, data);
2665: if (ret == NULL) return;
2666:
2667: if (ctxt->linenumbers) {
2668: if (ctxt->input != NULL) {
2669: if (ctxt->input->line < 65535)
2670: ret->line = (short) ctxt->input->line;
2671: else
2672: ret->line = 65535;
2673: }
2674: }
2675: if (ctxt->inSubset == 1) {
2676: xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
2677: return;
2678: } else if (ctxt->inSubset == 2) {
2679: xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
2680: return;
2681: }
2682: if (parent == NULL) {
2683: #ifdef DEBUG_SAX_TREE
2684: xmlGenericError(xmlGenericErrorContext,
2685: "Setting PI %s as root\n", target);
2686: #endif
2687: xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
2688: return;
2689: }
2690: if (parent->type == XML_ELEMENT_NODE) {
2691: #ifdef DEBUG_SAX_TREE
2692: xmlGenericError(xmlGenericErrorContext,
2693: "adding PI %s child to %s\n", target, parent->name);
2694: #endif
2695: xmlAddChild(parent, ret);
2696: } else {
2697: #ifdef DEBUG_SAX_TREE
2698: xmlGenericError(xmlGenericErrorContext,
2699: "adding PI %s sibling to ", target);
2700: xmlDebugDumpOneNode(stderr, parent, 0);
2701: #endif
2702: xmlAddSibling(parent, ret);
2703: }
2704: }
2705:
2706: /**
2707: * xmlSAX2Comment:
2708: * @ctx: the user data (XML parser context)
2709: * @value: the xmlSAX2Comment content
2710: *
2711: * A xmlSAX2Comment has been parsed.
2712: */
2713: void
2714: xmlSAX2Comment(void *ctx, const xmlChar *value)
2715: {
2716: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2717: xmlNodePtr ret;
2718: xmlNodePtr parent;
2719:
2720: if (ctx == NULL) return;
2721: parent = ctxt->node;
2722: #ifdef DEBUG_SAX
2723: xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2Comment(%s)\n", value);
2724: #endif
2725: ret = xmlNewDocComment(ctxt->myDoc, value);
2726: if (ret == NULL) return;
2727: if (ctxt->linenumbers) {
2728: if (ctxt->input != NULL) {
2729: if (ctxt->input->line < 65535)
2730: ret->line = (short) ctxt->input->line;
2731: else
2732: ret->line = 65535;
2733: }
2734: }
2735:
2736: if (ctxt->inSubset == 1) {
2737: xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
2738: return;
2739: } else if (ctxt->inSubset == 2) {
2740: xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
2741: return;
2742: }
2743: if (parent == NULL) {
2744: #ifdef DEBUG_SAX_TREE
2745: xmlGenericError(xmlGenericErrorContext,
2746: "Setting xmlSAX2Comment as root\n");
2747: #endif
2748: xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
2749: return;
2750: }
2751: if (parent->type == XML_ELEMENT_NODE) {
2752: #ifdef DEBUG_SAX_TREE
2753: xmlGenericError(xmlGenericErrorContext,
2754: "adding xmlSAX2Comment child to %s\n", parent->name);
2755: #endif
2756: xmlAddChild(parent, ret);
2757: } else {
2758: #ifdef DEBUG_SAX_TREE
2759: xmlGenericError(xmlGenericErrorContext,
2760: "adding xmlSAX2Comment sibling to ");
2761: xmlDebugDumpOneNode(stderr, parent, 0);
2762: #endif
2763: xmlAddSibling(parent, ret);
2764: }
2765: }
2766:
2767: /**
2768: * xmlSAX2CDataBlock:
2769: * @ctx: the user data (XML parser context)
2770: * @value: The pcdata content
2771: * @len: the block length
2772: *
2773: * called when a pcdata block has been parsed
2774: */
2775: void
2776: xmlSAX2CDataBlock(void *ctx, const xmlChar *value, int len)
2777: {
2778: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
2779: xmlNodePtr ret, lastChild;
2780:
2781: if (ctx == NULL) return;
2782: #ifdef DEBUG_SAX
2783: xmlGenericError(xmlGenericErrorContext,
2784: "SAX.pcdata(%.10s, %d)\n", value, len);
2785: #endif
2786: lastChild = xmlGetLastChild(ctxt->node);
2787: #ifdef DEBUG_SAX_TREE
2788: xmlGenericError(xmlGenericErrorContext,
2789: "add chars to %s \n", ctxt->node->name);
2790: #endif
2791: if ((lastChild != NULL) &&
2792: (lastChild->type == XML_CDATA_SECTION_NODE)) {
2793: xmlTextConcat(lastChild, value, len);
2794: } else {
2795: ret = xmlNewCDataBlock(ctxt->myDoc, value, len);
2796: xmlAddChild(ctxt->node, ret);
2797: }
2798: }
2799:
2800: static int xmlSAX2DefaultVersionValue = 2;
2801:
2802: #ifdef LIBXML_SAX1_ENABLED
2803: /**
2804: * xmlSAXDefaultVersion:
2805: * @version: the version, 1 or 2
2806: *
2807: * Set the default version of SAX used globally by the library.
2808: * By default, during initialization the default is set to 2.
2809: * Note that it is generally a better coding style to use
2810: * xmlSAXVersion() to set up the version explicitly for a given
2811: * parsing context.
2812: *
2813: * Returns the previous value in case of success and -1 in case of error.
2814: */
2815: int
2816: xmlSAXDefaultVersion(int version)
2817: {
2818: int ret = xmlSAX2DefaultVersionValue;
2819:
2820: if ((version != 1) && (version != 2))
2821: return(-1);
2822: xmlSAX2DefaultVersionValue = version;
2823: return(ret);
2824: }
2825: #endif /* LIBXML_SAX1_ENABLED */
2826:
2827: /**
2828: * xmlSAXVersion:
2829: * @hdlr: the SAX handler
2830: * @version: the version, 1 or 2
2831: *
2832: * Initialize the default XML SAX handler according to the version
2833: *
2834: * Returns 0 in case of success and -1 in case of error.
2835: */
2836: int
2837: xmlSAXVersion(xmlSAXHandler *hdlr, int version)
2838: {
2839: if (hdlr == NULL) return(-1);
2840: if (version == 2) {
2841: hdlr->startElement = NULL;
2842: hdlr->endElement = NULL;
2843: hdlr->startElementNs = xmlSAX2StartElementNs;
2844: hdlr->endElementNs = xmlSAX2EndElementNs;
2845: hdlr->serror = NULL;
2846: hdlr->initialized = XML_SAX2_MAGIC;
2847: #ifdef LIBXML_SAX1_ENABLED
2848: } else if (version == 1) {
2849: hdlr->startElement = xmlSAX2StartElement;
2850: hdlr->endElement = xmlSAX2EndElement;
2851: hdlr->initialized = 1;
2852: #endif /* LIBXML_SAX1_ENABLED */
2853: } else
2854: return(-1);
2855: hdlr->internalSubset = xmlSAX2InternalSubset;
2856: hdlr->externalSubset = xmlSAX2ExternalSubset;
2857: hdlr->isStandalone = xmlSAX2IsStandalone;
2858: hdlr->hasInternalSubset = xmlSAX2HasInternalSubset;
2859: hdlr->hasExternalSubset = xmlSAX2HasExternalSubset;
2860: hdlr->resolveEntity = xmlSAX2ResolveEntity;
2861: hdlr->getEntity = xmlSAX2GetEntity;
2862: hdlr->getParameterEntity = xmlSAX2GetParameterEntity;
2863: hdlr->entityDecl = xmlSAX2EntityDecl;
2864: hdlr->attributeDecl = xmlSAX2AttributeDecl;
2865: hdlr->elementDecl = xmlSAX2ElementDecl;
2866: hdlr->notationDecl = xmlSAX2NotationDecl;
2867: hdlr->unparsedEntityDecl = xmlSAX2UnparsedEntityDecl;
2868: hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
2869: hdlr->startDocument = xmlSAX2StartDocument;
2870: hdlr->endDocument = xmlSAX2EndDocument;
2871: hdlr->reference = xmlSAX2Reference;
2872: hdlr->characters = xmlSAX2Characters;
2873: hdlr->cdataBlock = xmlSAX2CDataBlock;
2874: hdlr->ignorableWhitespace = xmlSAX2Characters;
2875: hdlr->processingInstruction = xmlSAX2ProcessingInstruction;
2876: hdlr->comment = xmlSAX2Comment;
2877: hdlr->warning = xmlParserWarning;
2878: hdlr->error = xmlParserError;
2879: hdlr->fatalError = xmlParserError;
2880:
2881: return(0);
2882: }
2883:
2884: /**
2885: * xmlSAX2InitDefaultSAXHandler:
2886: * @hdlr: the SAX handler
2887: * @warning: flag if non-zero sets the handler warning procedure
2888: *
2889: * Initialize the default XML SAX2 handler
2890: */
2891: void
2892: xmlSAX2InitDefaultSAXHandler(xmlSAXHandler *hdlr, int warning)
2893: {
2894: if ((hdlr == NULL) || (hdlr->initialized != 0))
2895: return;
2896:
2897: xmlSAXVersion(hdlr, xmlSAX2DefaultVersionValue);
2898: if (warning == 0)
2899: hdlr->warning = NULL;
2900: else
2901: hdlr->warning = xmlParserWarning;
2902: }
2903:
2904: /**
2905: * xmlDefaultSAXHandlerInit:
2906: *
2907: * Initialize the default SAX2 handler
2908: */
2909: void
2910: xmlDefaultSAXHandlerInit(void)
2911: {
2912: #ifdef LIBXML_SAX1_ENABLED
2913: xmlSAXVersion((xmlSAXHandlerPtr) &xmlDefaultSAXHandler, 1);
2914: #endif /* LIBXML_SAX1_ENABLED */
2915: }
2916:
2917: #ifdef LIBXML_HTML_ENABLED
2918:
2919: /**
2920: * xmlSAX2InitHtmlDefaultSAXHandler:
2921: * @hdlr: the SAX handler
2922: *
2923: * Initialize the default HTML SAX2 handler
2924: */
2925: void
2926: xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr)
2927: {
2928: if ((hdlr == NULL) || (hdlr->initialized != 0))
2929: return;
2930:
2931: hdlr->internalSubset = xmlSAX2InternalSubset;
2932: hdlr->externalSubset = NULL;
2933: hdlr->isStandalone = NULL;
2934: hdlr->hasInternalSubset = NULL;
2935: hdlr->hasExternalSubset = NULL;
2936: hdlr->resolveEntity = NULL;
2937: hdlr->getEntity = xmlSAX2GetEntity;
2938: hdlr->getParameterEntity = NULL;
2939: hdlr->entityDecl = NULL;
2940: hdlr->attributeDecl = NULL;
2941: hdlr->elementDecl = NULL;
2942: hdlr->notationDecl = NULL;
2943: hdlr->unparsedEntityDecl = NULL;
2944: hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
2945: hdlr->startDocument = xmlSAX2StartDocument;
2946: hdlr->endDocument = xmlSAX2EndDocument;
2947: hdlr->startElement = xmlSAX2StartElement;
2948: hdlr->endElement = xmlSAX2EndElement;
2949: hdlr->reference = NULL;
2950: hdlr->characters = xmlSAX2Characters;
2951: hdlr->cdataBlock = xmlSAX2CDataBlock;
2952: hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
2953: hdlr->processingInstruction = xmlSAX2ProcessingInstruction;
2954: hdlr->comment = xmlSAX2Comment;
2955: hdlr->warning = xmlParserWarning;
2956: hdlr->error = xmlParserError;
2957: hdlr->fatalError = xmlParserError;
2958:
2959: hdlr->initialized = 1;
2960: }
2961:
2962: /**
2963: * htmlDefaultSAXHandlerInit:
2964: *
2965: * Initialize the default SAX handler
2966: */
2967: void
2968: htmlDefaultSAXHandlerInit(void)
2969: {
2970: xmlSAX2InitHtmlDefaultSAXHandler((xmlSAXHandlerPtr) &htmlDefaultSAXHandler);
2971: }
2972:
2973: #endif /* LIBXML_HTML_ENABLED */
2974:
2975: #ifdef LIBXML_DOCB_ENABLED
2976:
2977: /**
2978: * xmlSAX2InitDocbDefaultSAXHandler:
2979: * @hdlr: the SAX handler
2980: *
2981: * Initialize the default DocBook SAX2 handler
2982: */
2983: void
2984: xmlSAX2InitDocbDefaultSAXHandler(xmlSAXHandler *hdlr)
2985: {
2986: if ((hdlr == NULL) || (hdlr->initialized != 0))
2987: return;
2988:
2989: hdlr->internalSubset = xmlSAX2InternalSubset;
2990: hdlr->externalSubset = NULL;
2991: hdlr->isStandalone = xmlSAX2IsStandalone;
2992: hdlr->hasInternalSubset = xmlSAX2HasInternalSubset;
2993: hdlr->hasExternalSubset = xmlSAX2HasExternalSubset;
2994: hdlr->resolveEntity = xmlSAX2ResolveEntity;
2995: hdlr->getEntity = xmlSAX2GetEntity;
2996: hdlr->getParameterEntity = NULL;
2997: hdlr->entityDecl = xmlSAX2EntityDecl;
2998: hdlr->attributeDecl = NULL;
2999: hdlr->elementDecl = NULL;
3000: hdlr->notationDecl = NULL;
3001: hdlr->unparsedEntityDecl = NULL;
3002: hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
3003: hdlr->startDocument = xmlSAX2StartDocument;
3004: hdlr->endDocument = xmlSAX2EndDocument;
3005: hdlr->startElement = xmlSAX2StartElement;
3006: hdlr->endElement = xmlSAX2EndElement;
3007: hdlr->reference = xmlSAX2Reference;
3008: hdlr->characters = xmlSAX2Characters;
3009: hdlr->cdataBlock = NULL;
3010: hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
3011: hdlr->processingInstruction = NULL;
3012: hdlr->comment = xmlSAX2Comment;
3013: hdlr->warning = xmlParserWarning;
3014: hdlr->error = xmlParserError;
3015: hdlr->fatalError = xmlParserError;
3016:
3017: hdlr->initialized = 1;
3018: }
3019:
3020: /**
3021: * docbDefaultSAXHandlerInit:
3022: *
3023: * Initialize the default SAX handler
3024: */
3025: void
3026: docbDefaultSAXHandlerInit(void)
3027: {
3028: xmlSAX2InitDocbDefaultSAXHandler((xmlSAXHandlerPtr) &docbDefaultSAXHandler);
3029: }
3030:
3031: #endif /* LIBXML_DOCB_ENABLED */
3032: #define bottom_SAX2
3033: #include "elfgcchack.h"
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to SAX2.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2