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