开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
SAX.c
资源名称：rtsp-1.0.1.tar.gz　[点击查看]
上传用户：sy_wanhua
上传日期：2013-07-25
资源大小：3048k
文件大小：37k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

C/C++

SAX.c：源码内容
  1. /*
  2.  * SAX.c : Default SAX handler to build a tree.
  3.  *
  4.  * See Copyright for the status of this software.
  5.  *
  6.  * Daniel Veillard <Daniel.Veillard@w3.org>
  7.  */
  10. #ifdef WIN32
  11. #include "win32config.h"
  12. #else
  13. #include "config.h"
  14. #endif
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <libxml/xmlmemory.h>
  18. #include <libxml/tree.h>
  19. #include <libxml/parser.h>
  20. #include <libxml/parserInternals.h>
  21. #include <libxml/valid.h>
  22. #include <libxml/entities.h>
  23. #include "xml-error.h"
  24. #include <libxml/debugXML.h>
  25. #include <libxml/xmlIO.h>
  26. #include <libxml/SAX.h>
  28. /* #define DEBUG_SAX */
  29. /* #define DEBUG_SAX_TREE */
  31. /**
  32.  * getPublicId:
  33.  * @ctx: the user data (XML parser context)
  34.  *
  35.  * Return the public ID e.g. "-//SGMLSOURCE//DTD DEMO//EN"
  36.  *
  37.  * Returns a xmlChar *
  38.  */
  39. const xmlChar *
  40. getPublicId(void *ctx)
  41. {
  42.     /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
  43.     return(NULL);
  44. }
  46. /**
  47.  * getSystemId:
  48.  * @ctx: the user data (XML parser context)
  49.  *
  50.  * Return the system ID, basically URL or filename e.g.
  51.  * http://www.sgmlsource.com/dtds/memo.dtd
  52.  *
  53.  * Returns a xmlChar *
  54.  */
  55. const xmlChar *
  56. getSystemId(void *ctx)
  57. {
  58.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  59.     return(BAD_CAST ctxt->input->filename); 
  60. }
  62. /**
  63.  * getLineNumber:
  64.  * @ctx: the user data (XML parser context)
  65.  *
  66.  * Return the line number of the current parsing point.
  67.  *
  68.  * Returns an int
  69.  */
  70. int
  71. getLineNumber(void *ctx)
  72. {
  73.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  74.     return(ctxt->input->line);
  75. }
  77. /**
  78.  * getColumnNumber:
  79.  * @ctx: the user data (XML parser context)
  80.  *
  81.  * Return the column number of the current parsing point.
  82.  *
  83.  * Returns an int
  84.  */
  85. int
  86. getColumnNumber(void *ctx)
  87. {
  88.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  89.     return(ctxt->input->col);
  90. }
  92. /*
  93.  * The default SAX Locator.
  94.  */
  96. xmlSAXLocator xmlDefaultSAXLocator = {
  97.     getPublicId, getSystemId, getLineNumber, getColumnNumber
  98. };
  100. /**
  101.  * isStandalone:
  102.  * @ctx: the user data (XML parser context)
  103.  *
  104.  * Is this document tagged standalone ?
  105.  *
  106.  * Returns 1 if true
  107.  */
  108. int
  109. isStandalone(void *ctx)
  110. {
  111.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  112.     return(ctxt->myDoc->standalone == 1);
  113. }
  115. /**
  116.  * hasInternalSubset:
  117.  * @ctx: the user data (XML parser context)
  118.  *
  119.  * Does this document has an internal subset
  120.  *
  121.  * Returns 1 if true
  122.  */
  123. int
  124. hasInternalSubset(void *ctx)
  125. {
  126.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  127.     return(ctxt->myDoc->intSubset != NULL);
  128. }
  130. /**
  131.  * hasExternalSubset:
  132.  * @ctx: the user data (XML parser context)
  133.  *
  134.  * Does this document has an external subset
  135.  *
  136.  * Returns 1 if true
  137.  */
  138. int
  139. hasExternalSubset(void *ctx)
  140. {
  141.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  142.     return(ctxt->myDoc->extSubset != NULL);
  143. }
  145. /**
  146.  * internalSubset:
  147.  * @ctx: the user data (XML parser context)
  148.  *
  149.  * Callback on internal subset declaration.
  150.  */
  151. void
  152. internalSubset(void *ctx, const xmlChar *name,
  153.        const xmlChar *ExternalID, const xmlChar *SystemID)
  154. {
  155.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  156. #ifdef DEBUG_SAX
  157.     fprintf(stderr, "SAX.internalSubset(%s, %s, %s)n",
  158.             name, ExternalID, SystemID);
  159. #endif
  160.     xmlCreateIntSubset(ctxt->myDoc, name, ExternalID, SystemID);
  161. }
  163. /**
  164.  * externalSubset:
  165.  * @ctx: the user data (XML parser context)
  166.  *
  167.  * Callback on external subset declaration.
  168.  */
  169. void
  170. externalSubset(void *ctx, const xmlChar *name,
  171.        const xmlChar *ExternalID, const xmlChar *SystemID)
  172. {
  173.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  174. #ifdef DEBUG_SAX
  175.     fprintf(stderr, "SAX.externalSubset(%s, %s, %s)n",
  176.             name, ExternalID, SystemID);
  177. #endif
  178.     if (((ExternalID != NULL) || (SystemID != NULL)) &&
  179.         (ctxt->validate && ctxt->wellFormed && ctxt->myDoc)) {
  180. /*
  181.  * Try to fetch and parse the external subset.
  182.  */
  183. xmlParserInputPtr oldinput;
  184. int oldinputNr;
  185. int oldinputMax;
  186. xmlParserInputPtr *oldinputTab;
  187. int oldwellFormed;
  188. xmlParserInputPtr input = NULL;
  189. xmlCharEncoding enc;
  191. /*
  192.  * Ask the Entity resolver to load the damn thing
  193.  */
  194. if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
  195.     input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
  196.                                         SystemID);
  197. if (input == NULL) {
  198.     return;
  199. }
  201. xmlNewDtd(ctxt->myDoc, name, ExternalID, SystemID);
  203. /*
  204.  * make sure we won't destroy the main document context
  205.  */
  206. oldinput = ctxt->input;
  207. oldinputNr = ctxt->inputNr;
  208. oldinputMax = ctxt->inputMax;
  209. oldinputTab = ctxt->inputTab;
  210. oldwellFormed = ctxt->wellFormed;
  212. ctxt->inputTab = (xmlParserInputPtr *)
  213.                  xmlMalloc(5 * sizeof(xmlParserInputPtr));
  214. if (ctxt->inputTab == NULL) {
  215.     ctxt->errNo = XML_ERR_NO_MEMORY;
  216.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  217. ctxt->sax->error(ctxt->userData, 
  218.      "externalSubset: out of memoryn");
  219.     ctxt->errNo = XML_ERR_NO_MEMORY;
  220.     ctxt->input = oldinput;
  221.     ctxt->inputNr = oldinputNr;
  222.     ctxt->inputMax = oldinputMax;
  223.     ctxt->inputTab = oldinputTab;
  224.     return;
  225. }
  226. ctxt->inputNr = 0;
  227. ctxt->inputMax = 5;
  228. ctxt->input = NULL;
  229. xmlPushInput(ctxt, input);
  231. /*
  232.  * On the fly encoding conversion if needed
  233.  */
  234. enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
  235. xmlSwitchEncoding(ctxt, enc);
  237. if (input->filename == NULL)
  238.     input->filename = (char *) xmlStrdup(SystemID);
  239. input->line = 1;
  240. input->col = 1;
  241. input->base = ctxt->input->cur;
  242. input->cur = ctxt->input->cur;
  243. input->free = NULL;
  245. /*
  246.  * let's parse that entity knowing it's an external subset.
  247.  */
  248. xmlParseExternalSubset(ctxt, ExternalID, SystemID);
  250.         /*
  251.  * Free up the external entities
  252.  */
  254. while (ctxt->inputNr > 1)
  255.     xmlPopInput(ctxt);
  256. xmlFreeInputStream(ctxt->input);
  257.         xmlFree(ctxt->inputTab);
  259. /*
  260.  * Restore the parsing context of the main entity
  261.  */
  262. ctxt->input = oldinput;
  263. ctxt->inputNr = oldinputNr;
  264. ctxt->inputMax = oldinputMax;
  265. ctxt->inputTab = oldinputTab;
  266. /* ctxt->wellFormed = oldwellFormed; */
  267.     }
  268. }
  270. /**
  271.  * resolveEntity:
  272.  * @ctx: the user data (XML parser context)
  273.  * @publicId: The public ID of the entity
  274.  * @systemId: The system ID of the entity
  275.  *
  276.  * The entity loader, to control the loading of external entities,
  277.  * the application can either:
  278.  *    - override this resolveEntity() callback in the SAX block
  279.  *    - or better use the xmlSetExternalEntityLoader() function to
  280.  *      set up it's own entity resolution routine
  281.  *
  282.  * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
  283.  */
  284. xmlParserInputPtr
  285. resolveEntity(void *ctx, const xmlChar *publicId, const xmlChar *systemId)
  286. {
  287.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  289. #ifdef DEBUG_SAX
  290.     fprintf(stderr, "SAX.resolveEntity(%s, %s)n", publicId, systemId);
  291. #endif
  293.     return(xmlLoadExternalEntity((const char *) systemId,
  294.  (const char *) publicId, ctxt));
  295. }
  297. /**
  298.  * getEntity:
  299.  * @ctx: the user data (XML parser context)
  300.  * @name: The entity name
  301.  *
  302.  * Get an entity by name
  303.  *
  304.  * Returns the xmlEntityPtr if found.
  305.  */
  306. xmlEntityPtr
  307. getEntity(void *ctx, const xmlChar *name)
  308. {
  309.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  310.     xmlEntityPtr ret;
  312. #ifdef DEBUG_SAX
  313.     fprintf(stderr, "SAX.getEntity(%s)n", name);
  314. #endif
  316.     ret = xmlGetDocEntity(ctxt->myDoc, name);
  317.     return(ret);
  318. }
  320. /**
  321.  * getParameterEntity:
  322.  * @ctx: the user data (XML parser context)
  323.  * @name: The entity name
  324.  *
  325.  * Get a parameter entity by name
  326.  *
  327.  * Returns the xmlEntityPtr if found.
  328.  */
  329. xmlEntityPtr
  330. getParameterEntity(void *ctx, const xmlChar *name)
  331. {
  332.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  333.     xmlEntityPtr ret;
  335. #ifdef DEBUG_SAX
  336.     fprintf(stderr, "SAX.getParameterEntity(%s)n", name);
  337. #endif
  339.     ret = xmlGetParameterEntity(ctxt->myDoc, name);
  340.     return(ret);
  341. }
  344. /**
  345.  * entityDecl:
  346.  * @ctx: the user data (XML parser context)
  347.  * @name:  the entity name 
  348.  * @type:  the entity type 
  349.  * @publicId: The public ID of the entity
  350.  * @systemId: The system ID of the entity
  351.  * @content: the entity value (without processing).
  352.  *
  353.  * An entity definition has been parsed
  354.  */
  355. void
  356. entityDecl(void *ctx, const xmlChar *name, int type,
  357.           const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
  358. {
  359.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  361. #ifdef DEBUG_SAX
  362.     fprintf(stderr, "SAX.entityDecl(%s, %d, %s, %s, %s)n",
  363.             name, type, publicId, systemId, content);
  364. #endif
  365.     if (ctxt->inSubset == 1)
  366. xmlAddDocEntity(ctxt->myDoc, name, type, publicId,
  367.               systemId, content);
  368.     else if (ctxt->inSubset == 2)
  369. xmlAddDtdEntity(ctxt->myDoc, name, type, publicId,
  370.               systemId, content);
  371.     else {
  372. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  373.     ctxt->sax->error(ctxt, 
  374.      "SAX.entityDecl(%s) called while not in subsetn", name);
  375.     }
  376. }
  378. /**
  379.  * attributeDecl:
  380.  * @ctx: the user data (XML parser context)
  381.  * @fullname:  the attribute name 
  382.  * @type:  the attribute type 
  383.  * @publicId: The public ID of the attribute
  384.  * @systemId: The system ID of the attribute
  385.  * @content: the attribute value (without processing).
  386.  *
  387.  * An attribute definition has been parsed
  388.  */
  389. void
  390. attributeDecl(void *ctx, const xmlChar *elem, const xmlChar *fullname,
  391.               int type, int def, const xmlChar *defaultValue,
  392.       xmlEnumerationPtr tree)
  393. {
  394.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  395.     xmlAttributePtr attr;
  396.     xmlChar *name = NULL, *prefix = NULL;
  398. #ifdef DEBUG_SAX
  399.     fprintf(stderr, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)n",
  400.             elem, fullname, type, def, defaultValue);
  401. #endif
  402.     name = xmlSplitQName(ctxt, fullname, &prefix);
  403.     if (ctxt->inSubset == 1)
  404. attr = xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, elem,
  405.                                name, prefix, type, def, defaultValue, tree);
  406.     else if (ctxt->inSubset == 2)
  407. attr = xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, elem,
  408.                                name, prefix, type, def, defaultValue, tree);
  409.     else {
  410. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  411.     ctxt->sax->error(ctxt, 
  412.      "SAX.attributeDecl(%s) called while not in subsetn", name);
  413. return;
  414.     }
  415.     if (attr == 0) ctxt->valid = 0;
  416.     if (ctxt->validate && ctxt->wellFormed &&
  417.         ctxt->myDoc && ctxt->myDoc->intSubset)
  418. ctxt->valid &= xmlValidateAttributeDecl(&ctxt->vctxt, ctxt->myDoc,
  419.                                         attr);
  420.     if (prefix != NULL)
  421. xmlFree(prefix);
  422.     if (name != NULL)
  423. xmlFree(name);
  424. }
  426. /**
  427.  * elementDecl:
  428.  * @ctx: the user data (XML parser context)
  429.  * @name:  the element name 
  430.  * @type:  the element type 
  431.  * @publicId: The public ID of the element
  432.  * @systemId: The system ID of the element
  433.  * @content: the element value (without processing).
  434.  *
  435.  * An element definition has been parsed
  436.  */
  437. void
  438. elementDecl(void *ctx, const xmlChar *name, int type,
  439.     xmlElementContentPtr content)
  440. {
  441.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  442.     xmlElementPtr elem = NULL;
  444. #ifdef DEBUG_SAX
  445.     fprintf(stderr, "SAX.elementDecl(%s, %d, ...)n",
  446.             fullname, type);
  447. #endif
  448.     
  449.     if (ctxt->inSubset == 1)
  450. elem = xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->intSubset,
  451.                              name, type, content);
  452.     else if (ctxt->inSubset == 2)
  453. elem = xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->extSubset,
  454.                              name, type, content);
  455.     else {
  456. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  457.     ctxt->sax->error(ctxt, 
  458.      "SAX.elementDecl(%s) called while not in subsetn", name);
  459. return;
  460.     }
  461.     if (elem == NULL) ctxt->valid = 0;
  462.     if (ctxt->validate && ctxt->wellFormed &&
  463.         ctxt->myDoc && ctxt->myDoc->intSubset)
  464. ctxt->valid &= xmlValidateElementDecl(&ctxt->vctxt, ctxt->myDoc, elem);
  465. }
  467. /**
  468.  * notationDecl:
  469.  * @ctx: the user data (XML parser context)
  470.  * @name: The name of the notation
  471.  * @publicId: The public ID of the entity
  472.  * @systemId: The system ID of the entity
  473.  *
  474.  * What to do when a notation declaration has been parsed.
  475.  */
  476. void
  477. notationDecl(void *ctx, const xmlChar *name,
  478.      const xmlChar *publicId, const xmlChar *systemId)
  479. {
  480.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  481.     xmlNotationPtr nota = NULL;
  483. #ifdef DEBUG_SAX
  484.     fprintf(stderr, "SAX.notationDecl(%s, %s, %s)n", name, publicId, systemId);
  485. #endif
  487.     if (ctxt->inSubset == 1)
  488. nota = xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, name,
  489.                               publicId, systemId);
  490.     else if (ctxt->inSubset == 2)
  491. nota = xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, name,
  492.                               publicId, systemId);
  493.     else {
  494. if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  495.     ctxt->sax->error(ctxt, 
  496.      "SAX.notationDecl(%s) called while not in subsetn", name);
  497. return;
  498.     }
  499.     if (nota == NULL) ctxt->valid = 0;
  500.     if (ctxt->validate && ctxt->wellFormed &&
  501.         ctxt->myDoc && ctxt->myDoc->intSubset)
  502. ctxt->valid &= xmlValidateNotationDecl(&ctxt->vctxt, ctxt->myDoc,
  503.                                        nota);
  504. }
  506. /**
  507.  * unparsedEntityDecl:
  508.  * @ctx: the user data (XML parser context)
  509.  * @name: The name of the entity
  510.  * @publicId: The public ID of the entity
  511.  * @systemId: The system ID of the entity
  512.  * @notationName: the name of the notation
  513.  *
  514.  * What to do when an unparsed entity declaration is parsed
  515.  */
  516. void
  517. unparsedEntityDecl(void *ctx, const xmlChar *name,
  518.    const xmlChar *publicId, const xmlChar *systemId,
  519.    const xmlChar *notationName)
  520. {
  521.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  522. #ifdef DEBUG_SAX
  523.     fprintf(stderr, "SAX.unparsedEntityDecl(%s, %s, %s, %s)n",
  524.             name, publicId, systemId, notationName);
  525. #endif
  526.     if (ctxt->validate && ctxt->wellFormed &&
  527.         ctxt->myDoc && ctxt->myDoc->intSubset)
  528. ctxt->valid &= xmlValidateNotationUse(&ctxt->vctxt, ctxt->myDoc,
  529.                                       notationName);
  530.     xmlAddDocEntity(ctxt->myDoc, name,
  531.                     XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
  532.     publicId, systemId, notationName);
  533. }
  535. /**
  536.  * setDocumentLocator:
  537.  * @ctx: the user data (XML parser context)
  538.  * @loc: A SAX Locator
  539.  *
  540.  * Receive the document locator at startup, actually xmlDefaultSAXLocator
  541.  * Everything is available on the context, so this is useless in our case.
  542.  */
  543. void
  544. setDocumentLocator(void *ctx, xmlSAXLocatorPtr loc)
  545. {
  546.     /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
  547. #ifdef DEBUG_SAX
  548.     fprintf(stderr, "SAX.setDocumentLocator()n");
  549. #endif
  550. }
  552. /**
  553.  * startDocument:
  554.  * @ctx: the user data (XML parser context)
  555.  *
  556.  * called when the document start being processed.
  557.  */
  558. void
  559. startDocument(void *ctx)
  560. {
  561.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  562.     xmlDocPtr doc;
  564. #ifdef DEBUG_SAX
  565.     fprintf(stderr, "SAX.startDocument()n");
  566. #endif
  567.     doc = ctxt->myDoc = xmlNewDoc(ctxt->version);
  568.     if (doc != NULL) {
  569. if (ctxt->encoding != NULL)
  570.     doc->encoding = xmlStrdup(ctxt->encoding);
  571. else
  572.     doc->encoding = NULL;
  573. doc->standalone = ctxt->standalone;
  574.     }
  575. }
  577. /**
  578.  * endDocument:
  579.  * @ctx: the user data (XML parser context)
  580.  *
  581.  * called when the document end has been detected.
  582.  */
  583. void
  584. endDocument(void *ctx)
  585. {
  586.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  587. #ifdef DEBUG_SAX
  588.     fprintf(stderr, "SAX.endDocument()n");
  589. #endif
  590.     if (ctxt->validate && ctxt->wellFormed &&
  591.         ctxt->myDoc && ctxt->myDoc->intSubset)
  592. ctxt->valid &= xmlValidateDocumentFinal(&ctxt->vctxt, ctxt->myDoc);
  593. }
  595. /**
  596.  * attribute:
  597.  * @ctx: the user data (XML parser context)
  598.  * @name:  The attribute name
  599.  * @value:  The attribute value
  600.  *
  601.  * Handle an attribute that has been read by the parser.
  602.  * The default handling is to convert the attribute into an
  603.  * DOM subtree and past it in a new xmlAttr element added to
  604.  * the element.
  605.  */
  606. void
  607. attribute(void *ctx, const xmlChar *fullname, const xmlChar *value)
  608. {
  609.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  610.     xmlAttrPtr ret;
  611.     xmlChar *name;
  612.     xmlChar *ns;
  613.     xmlChar *nval;
  614.     xmlNsPtr namespace;
  616. /****************
  617. #ifdef DEBUG_SAX
  618.     fprintf(stderr, "SAX.attribute(%s, %s)n", fullname, value);
  619. #endif
  620.  ****************/
  621.     /*
  622.      * Split the full name into a namespace prefix and the tag name
  623.      */
  624.     name = xmlSplitQName(ctxt, fullname, &ns);
  626.     /*
  627.      * Do the last stave of the attribute normalization
  628.      */
  629.     nval = xmlValidNormalizeAttributeValue(ctxt->myDoc,
  630.        ctxt->node, fullname, value);
  631.     if (nval != NULL)
  632. value = nval;
  634.     /*
  635.      * Check whether it's a namespace definition
  636.      */
  637.     if ((ns == NULL) &&
  638.         (name[0] == 'x') && (name[1] == 'm') && (name[2] == 'l') &&
  639.         (name[3] == 'n') && (name[4] == 's') && (name[5] == 0)) {
  640. /* a default namespace definition */
  641. xmlNewNs(ctxt->node, value, NULL);
  642. if (name != NULL) 
  643.     xmlFree(name);
  644. if (nval != NULL)
  645.     xmlFree(nval);
  646. return;
  647.     }
  648.     if ((ns != NULL) && (ns[0] == 'x') && (ns[1] == 'm') && (ns[2] == 'l') &&
  649.         (ns[3] == 'n') && (ns[4] == 's') && (ns[5] == 0)) {
  650. /*
  651.  * Validate also for namespace decls, they are attributes from
  652.  * an XML-1.0 perspective
  653.  TODO ... doesn't map well with current API
  654.         if (ctxt->validate && ctxt->wellFormed &&
  655.     ctxt->myDoc && ctxt->myDoc->intSubset)
  656.     ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt, ctxt->myDoc,
  657.        ctxt->node, ret, value);
  658.  */
  659. /* a standard namespace definition */
  660. xmlNewNs(ctxt->node, value, name);
  661. xmlFree(ns);
  662. if (name != NULL) 
  663.     xmlFree(name);
  664. if (nval != NULL)
  665.     xmlFree(nval);
  666. return;
  667.     }
  669.     if (ns != NULL)
  670. namespace = xmlSearchNs(ctxt->myDoc, ctxt->node, ns);
  671.     else {
  672. namespace = NULL;
  673.     }
  675.     /* !!!!!! <a toto:arg="" xmlns:toto="http://toto.com"> */
  676.     ret = xmlNewNsProp(ctxt->node, namespace, name, NULL);
  678.     if (ret != NULL) {
  679.         if ((ctxt->replaceEntities == 0) && (!ctxt->html)) {
  680.     xmlNodePtr tmp;
  682.     ret->children = xmlStringGetNodeList(ctxt->myDoc, value);
  683.     tmp = ret->children;
  684.     while (tmp != NULL) {
  685. tmp->parent = (xmlNodePtr) ret;
  686. if (tmp->next == NULL)
  687.     ret->last = tmp;
  688. tmp = tmp->next;
  689.     }
  690. } else {
  691.     ret->children = xmlNewDocText(ctxt->myDoc, value);
  692.     ret->last = ret->children;
  693.     if (ret->children != NULL)
  694. ret->children->parent = (xmlNodePtr) ret;
  695. }
  696.     }
  698.     if (ctxt->validate && ctxt->wellFormed &&
  699.         ctxt->myDoc && ctxt->myDoc->intSubset) {
  701. /*
  702.  * If we don't substitute entities, the validation should be
  703.  * done on a value with replaced entities anyway.
  704.  */
  705.         if (!ctxt->replaceEntities) {
  706.     xmlChar *val;
  708.     ctxt->depth++;
  709.     val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
  710.                           0,0,0);
  711.     ctxt->depth--;
  712.     if (val == NULL)
  713. ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
  714. ctxt->myDoc, ctxt->node, ret, value);
  715.     else {
  716. ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
  717.         ctxt->myDoc, ctxt->node, ret, val);
  718.                 xmlFree(val);
  719.     }
  720. } else {
  721.     ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt, ctxt->myDoc,
  722.        ctxt->node, ret, value);
  723. }
  724.     } else {
  725.         /*
  726.  * when validating, the ID registration is done at the attribute
  727.  * validation level. Otherwise we have to do specific handling here.
  728.  */
  729. if (xmlIsID(ctxt->myDoc, ctxt->node, ret))
  730.     xmlAddID(&ctxt->vctxt, ctxt->myDoc, value, ret);
  731. else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret))
  732.     xmlAddRef(&ctxt->vctxt, ctxt->myDoc, value, ret);
  733.     }
  735.     if (nval != NULL)
  736. xmlFree(nval);
  737.     if (name != NULL) 
  738. xmlFree(name);
  739.     if (ns != NULL) 
  740. xmlFree(ns);
  741. }
  743. /**
  744.  * startElement:
  745.  * @ctx: the user data (XML parser context)
  746.  * @name:  The element name
  747.  * @atts:  An array of name/value attributes pairs, NULL terminated
  748.  *
  749.  * called when an opening tag has been processed.
  750.  */
  751. void
  752. startElement(void *ctx, const xmlChar *fullname, const xmlChar **atts)
  753. {
  754.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  755.     xmlNodePtr ret;
  756.     xmlNodePtr parent = ctxt->node;
  757.     xmlNsPtr ns;
  758.     xmlChar *name;
  759.     xmlChar *prefix;
  760.     const xmlChar *att;
  761.     const xmlChar *value;
  762.     int i;
  764. #ifdef DEBUG_SAX
  765.     fprintf(stderr, "SAX.startElement(%s)n", fullname);
  766. #endif
  768.     /*
  769.      * First check on validity:
  770.      */
  771.     if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) && 
  772.         ((ctxt->myDoc->intSubset == NULL) ||
  773.  ((ctxt->myDoc->intSubset->notations == NULL) && 
  774.   (ctxt->myDoc->intSubset->elements == NULL) &&
  775.   (ctxt->myDoc->intSubset->attributes == NULL) && 
  776.   (ctxt->myDoc->intSubset->entities == NULL)))) {
  777. if (ctxt->vctxt.error != NULL) {
  778.             ctxt->vctxt.error(ctxt->vctxt.userData,
  779.       "Validation failed: no DTD found !n");
  780. }
  781. ctxt->validate = 0;
  782.     }
  783.        
  785.     /*
  786.      * Split the full name into a namespace prefix and the tag name
  787.      */
  788.     name = xmlSplitQName(ctxt, fullname, &prefix);
  791.     /*
  792.      * Note : the namespace resolution is deferred until the end of the
  793.      *        attributes parsing, since local namespace can be defined as
  794.      *        an attribute at this level.
  795.      */
  796.     ret = xmlNewDocNode(ctxt->myDoc, NULL, name, NULL);
  797.     if (ret == NULL) return;
  798.     if (ctxt->myDoc->children == NULL) {
  799. #ifdef DEBUG_SAX_TREE
  800. fprintf(stderr, "Setting %s as rootn", name);
  801. #endif
  802.         xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
  803.     } else if (parent == NULL) {
  804.         parent = ctxt->myDoc->children;
  805.     }
  807.     /*
  808.      * We are parsing a new node.
  809.      */
  810. #ifdef DEBUG_SAX_TREE
  811.     fprintf(stderr, "pushing(%s)n", name);
  812. #endif
  813.     nodePush(ctxt, ret);
  815.     /*
  816.      * Link the child element
  817.      */
  818.     if (parent != NULL) {
  819.         if (parent->type == XML_ELEMENT_NODE) {
  820. #ifdef DEBUG_SAX_TREE
  821.     fprintf(stderr, "adding child %s to %sn", name, parent->name);
  822. #endif
  823.     xmlAddChild(parent, ret);
  824. } else {
  825. #ifdef DEBUG_SAX_TREE
  826.     fprintf(stderr, "adding sibling %s to ", name);
  827.     xmlDebugDumpOneNode(stderr, parent, 0);
  828. #endif
  829.     xmlAddSibling(parent, ret);
  830. }
  831.     }
  833.     /*
  834.      * If it's the Document root, finish the Dtd validation and
  835.      * check the document root element for validity
  836.      */
  837.     if ((ctxt->validate) && (ctxt->vctxt.finishDtd == 0)) {
  838. ctxt->valid &= xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
  839. ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
  840. ctxt->vctxt.finishDtd = 1;
  841.     }
  842.     /*
  843.      * process all the attributes whose name start with "xml"
  844.      */
  845.     if (atts != NULL) {
  846.         i = 0;
  847. att = atts[i++];
  848. value = atts[i++];
  849.         while ((att != NULL) && (value != NULL)) {
  850.     if ((att[0] == 'x') && (att[1] == 'm') && (att[2] == 'l'))
  851. attribute(ctxt, att, value);
  853.     att = atts[i++];
  854.     value = atts[i++];
  855. }
  856.     }
  858.     /*
  859.      * process all the other attributes
  860.      */
  861.     if (atts != NULL) {
  862.         i = 0;
  863. att = atts[i++];
  864. value = atts[i++];
  865.         while ((att != NULL) && (value != NULL)) {
  866.     if ((att[0] != 'x') || (att[1] != 'm') || (att[2] != 'l'))
  867. attribute(ctxt, att, value);
  869.     /*
  870.      * Next ones
  871.      */
  872.     att = atts[i++];
  873.     value = atts[i++];
  874. }
  875.     }
  877.     /*
  878.      * Search the namespace, note that since the attributes have been
  879.      * processed, the local namespaces are available.
  880.      */
  881.     ns = xmlSearchNs(ctxt->myDoc, ret, prefix);
  882.     if ((ns == NULL) && (parent != NULL))
  883. ns = xmlSearchNs(ctxt->myDoc, parent, prefix);
  884.     xmlSetNs(ret, ns);
  886.     if (prefix != NULL)
  887. xmlFree(prefix);
  888.     if (name != NULL)
  889. xmlFree(name);
  891. }
  893. /**
  894.  * endElement:
  895.  * @ctx: the user data (XML parser context)
  896.  * @name:  The element name
  897.  *
  898.  * called when the end of an element has been detected.
  899.  */
  900. void
  901. endElement(void *ctx, const xmlChar *name)
  902. {
  903.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  904.     xmlParserNodeInfo node_info;
  905.     xmlNodePtr cur = ctxt->node;
  907. #ifdef DEBUG_SAX
  908.     if (name == NULL)
  909.         fprintf(stderr, "SAX.endElement(NULL)n");
  910.     else
  911. fprintf(stderr, "SAX.endElement(%s)n", name);
  912. #endif
  913.     
  914.     /* Capture end position and add node */
  915.     if (cur != NULL && ctxt->record_info) {
  916.       node_info.end_pos = ctxt->input->cur - ctxt->input->base;
  917.       node_info.end_line = ctxt->input->line;
  918.       node_info.node = cur;
  919.       xmlParserAddNodeInfo(ctxt, &node_info);
  920.     }
  922.     if (ctxt->validate && ctxt->wellFormed &&
  923.         ctxt->myDoc && ctxt->myDoc->intSubset)
  924.         ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc,
  925.      cur);
  927.     
  928.     /*
  929.      * end of parsing of this node.
  930.      */
  931. #ifdef DEBUG_SAX_TREE
  932.     fprintf(stderr, "popping(%s)n", cur->name);
  933. #endif
  934.     nodePop(ctxt);
  935. }
  937. /**
  938.  * reference:
  939.  * @ctx: the user data (XML parser context)
  940.  * @name:  The entity name
  941.  *
  942.  * called when an entity reference is detected. 
  943.  */
  944. void
  945. reference(void *ctx, const xmlChar *name)
  946. {
  947.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  948.     xmlNodePtr ret;
  950. #ifdef DEBUG_SAX
  951.     fprintf(stderr, "SAX.reference(%s)n", name);
  952. #endif
  953.     if (name[0] == '#')
  954. ret = xmlNewCharRef(ctxt->myDoc, name);
  955.     else
  956. ret = xmlNewReference(ctxt->myDoc, name);
  957. #ifdef DEBUG_SAX_TREE
  958.     fprintf(stderr, "add reference %s to %s n", name, ctxt->node->name);
  959. #endif
  960.     xmlAddChild(ctxt->node, ret);
  961. }
  963. /**
  964.  * characters:
  965.  * @ctx: the user data (XML parser context)
  966.  * @ch:  a xmlChar string
  967.  * @len: the number of xmlChar
  968.  *
  969.  * receiving some chars from the parser.
  970.  * Question: how much at a time ???
  971.  */
  972. void
  973. characters(void *ctx, const xmlChar *ch, int len)
  974. {
  975.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  976.     xmlNodePtr lastChild;
  978. #ifdef DEBUG_SAX
  979.     fprintf(stderr, "SAX.characters(%.30s, %d)n", ch, len);
  980. #endif
  981.     /*
  982.      * Handle the data if any. If there is no child
  983.      * add it as content, otherwise if the last child is text,
  984.      * concatenate it, else create a new node of type text.
  985.      */
  987.     if (ctxt->node == NULL) {
  988. #ifdef DEBUG_SAX_TREE
  989. fprintf(stderr, "add chars: ctxt->node == NULL !n");
  990. #endif
  991.         return;
  992.     }
  993.     lastChild = xmlGetLastChild(ctxt->node);
  994. #ifdef DEBUG_SAX_TREE
  995.     fprintf(stderr, "add chars to %s n", ctxt->node->name);
  996. #endif
  997.     if (lastChild == NULL)
  998. xmlNodeAddContentLen(ctxt->node, ch, len);
  999.     else {
  1000. if (xmlNodeIsText(lastChild))
  1001.     xmlTextConcat(lastChild, ch, len);
  1002. else {
  1003.     lastChild = xmlNewTextLen(ch, len);
  1004.     xmlAddChild(ctxt->node, lastChild);
  1005. }
  1006.     }
  1007. }
  1009. /**
  1010.  * ignorableWhitespace:
  1011.  * @ctx: the user data (XML parser context)
  1012.  * @ch:  a xmlChar string
  1013.  * @len: the number of xmlChar
  1014.  *
  1015.  * receiving some ignorable whitespaces from the parser.
  1016.  * Question: how much at a time ???
  1017.  */
  1018. void
  1019. ignorableWhitespace(void *ctx, const xmlChar *ch, int len)
  1020. {
  1021.     /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
  1022. #ifdef DEBUG_SAX
  1023.     fprintf(stderr, "SAX.ignorableWhitespace(%.30s, %d)n", ch, len);
  1024. #endif
  1025. }
  1027. /**
  1028.  * processingInstruction:
  1029.  * @ctx: the user data (XML parser context)
  1030.  * @target:  the target name
  1031.  * @data: the PI data's
  1032.  * @len: the number of xmlChar
  1033.  *
  1034.  * A processing instruction has been parsed.
  1035.  */
  1036. void
  1037. processingInstruction(void *ctx, const xmlChar *target,
  1038.                       const xmlChar *data)
  1039. {
  1040.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  1041.     xmlNodePtr ret;
  1042.     xmlNodePtr parent = ctxt->node;
  1044. #ifdef DEBUG_SAX
  1045.     fprintf(stderr, "SAX.processingInstruction(%s, %s)n", target, data);
  1046. #endif
  1048.     ret = xmlNewPI(target, data);
  1049.     if (ret == NULL) return;
  1050.     parent = ctxt->node;
  1052.     if (ctxt->inSubset == 1) {
  1053. xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
  1054. return;
  1055.     } else if (ctxt->inSubset == 2) {
  1056. xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
  1057. return;
  1058.     }
  1059.     if ((ctxt->myDoc->children == NULL) || (parent == NULL)) {
  1060. #ifdef DEBUG_SAX_TREE
  1061.     fprintf(stderr, "Setting PI %s as rootn", target);
  1062. #endif
  1063.         xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
  1064. return;
  1065.     }
  1066.     if (parent->type == XML_ELEMENT_NODE) {
  1067. #ifdef DEBUG_SAX_TREE
  1068. fprintf(stderr, "adding PI %s child to %sn", target, parent->name);
  1069. #endif
  1070. xmlAddChild(parent, ret);
  1071.     } else {
  1072. #ifdef DEBUG_SAX_TREE
  1073. fprintf(stderr, "adding PI %s sibling to ", target);
  1074. xmlDebugDumpOneNode(stderr, parent, 0);
  1075. #endif
  1076. xmlAddSibling(parent, ret);
  1077.     }
  1078. }
  1080. /**
  1081.  * globalNamespace:
  1082.  * @ctx: the user data (XML parser context)
  1083.  * @href:  the namespace associated URN
  1084.  * @prefix: the namespace prefix
  1085.  *
  1086.  * An old global namespace has been parsed.
  1087.  */
  1088. void
  1089. globalNamespace(void *ctx, const xmlChar *href, const xmlChar *prefix)
  1090. {
  1091.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  1092. #ifdef DEBUG_SAX
  1093.     fprintf(stderr, "SAX.globalNamespace(%s, %s)n", href, prefix);
  1094. #endif
  1095.     xmlNewGlobalNs(ctxt->myDoc, href, prefix);
  1096. }
  1098. /**
  1099.  * setNamespace:
  1100.  * @ctx: the user data (XML parser context)
  1101.  * @name:  the namespace prefix
  1102.  *
  1103.  * Set the current element namespace.
  1104.  */
  1105. void
  1106. setNamespace(void *ctx, const xmlChar *name)
  1107. {
  1108.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  1109.     xmlNsPtr ns;
  1110.     xmlNodePtr parent;
  1112. #ifdef DEBUG_SAX
  1113.     fprintf(stderr, "SAX.setNamespace(%s)n", name);
  1114. #endif
  1115.     ns = xmlSearchNs(ctxt->myDoc, ctxt->node, name);
  1116.     if (ns == NULL) { /* ctxt->node may not have a parent yet ! */
  1117.         if (ctxt->nodeNr >= 2) {
  1118.     parent = ctxt->nodeTab[ctxt->nodeNr - 2];
  1119.     if (parent != NULL)
  1120. ns = xmlSearchNs(ctxt->myDoc, parent, name);
  1121. }
  1122.     }
  1123.     xmlSetNs(ctxt->node, ns);
  1124. }
  1126. /**
  1127.  * getNamespace:
  1128.  * @ctx: the user data (XML parser context)
  1129.  *
  1130.  * Get the current element namespace.
  1131.  */
  1132. xmlNsPtr
  1133. getNamespace(void *ctx)
  1134. {
  1135.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  1136.     xmlNsPtr ret;
  1138. #ifdef DEBUG_SAX
  1139.     fprintf(stderr, "SAX.getNamespace()n");
  1140. #endif
  1141.     ret = ctxt->node->ns;
  1142.     return(ret);
  1143. }
  1145. /**
  1146.  * checkNamespace:
  1147.  * @ctx: the user data (XML parser context)
  1148.  * @namespace: the namespace to check against
  1149.  *
  1150.  * Check that the current element namespace is the same as the
  1151.  * one read upon parsing.
  1152.  */
  1153. int
  1154. checkNamespace(void *ctx, xmlChar *namespace)
  1155. {
  1156.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  1157.     xmlNodePtr cur = ctxt->node;
  1159. #ifdef DEBUG_SAX
  1160.     fprintf(stderr, "SAX.checkNamespace(%s)n", namespace);
  1161. #endif
  1163.     /*
  1164.      * Check that the Name in the ETag is the same as in the STag.
  1165.      */
  1166.     if (namespace == NULL) {
  1167.         if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
  1168.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1169. ctxt->sax->error(ctxt, 
  1170.  "End tags for %s don't hold the namespace %sn",
  1171.                  cur->name, cur->ns->prefix);
  1172.     ctxt->wellFormed = 0;
  1173. }
  1174.     } else {
  1175.         if ((cur->ns == NULL) || (cur->ns->prefix == NULL)) {
  1176.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1177. ctxt->sax->error(ctxt, 
  1178.  "End tags %s holds a prefix %s not used by the open tagn",
  1179.                  cur->name, namespace);
  1180.     ctxt->wellFormed = 0;
  1181. } else if (xmlStrcmp(namespace, cur->ns->prefix)) {
  1182.     if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
  1183. ctxt->sax->error(ctxt, 
  1184.     "Start and End tags for %s don't use the same namespaces: %s and %sn",
  1185.                          cur->name, cur->ns->prefix, namespace);
  1186.     ctxt->wellFormed = 0;
  1187. } else
  1188.     return(1);
  1189.     }
  1190.     return(0);
  1191. }
  1193. /**
  1194.  * namespaceDecl:
  1195.  * @ctx: the user data (XML parser context)
  1196.  * @href:  the namespace associated URN
  1197.  * @prefix: the namespace prefix
  1198.  *
  1199.  * A namespace has been parsed.
  1200.  */
  1201. void
  1202. namespaceDecl(void *ctx, const xmlChar *href, const xmlChar *prefix)
  1203. {
  1204.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  1205. #ifdef DEBUG_SAX
  1206.     if (prefix == NULL)
  1207. fprintf(stderr, "SAX.namespaceDecl(%s, NULL)n", href);
  1208.     else
  1209. fprintf(stderr, "SAX.namespaceDecl(%s, %s)n", href, prefix);
  1210. #endif
  1211.     xmlNewNs(ctxt->node, href, prefix);
  1212. }
  1214. /**
  1215.  * comment:
  1216.  * @ctx: the user data (XML parser context)
  1217.  * @value:  the comment content
  1218.  *
  1219.  * A comment has been parsed.
  1220.  */
  1221. void
  1222. comment(void *ctx, const xmlChar *value)
  1223. {
  1224.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  1225.     xmlNodePtr ret;
  1226.     xmlNodePtr parent = ctxt->node;
  1228. #ifdef DEBUG_SAX
  1229.     fprintf(stderr, "SAX.comment(%s)n", value);
  1230. #endif
  1231.     ret = xmlNewDocComment(ctxt->myDoc, value);
  1232.     if (ret == NULL) return;
  1234.     if (ctxt->inSubset == 1) {
  1235. xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
  1236. return;
  1237.     } else if (ctxt->inSubset == 2) {
  1238. xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
  1239. return;
  1240.     }
  1241.     if ((ctxt->myDoc->children == NULL) || (parent == NULL)) {
  1242. #ifdef DEBUG_SAX_TREE
  1243.     fprintf(stderr, "Setting comment as rootn");
  1244. #endif
  1245.         xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
  1246. return;
  1247.     }
  1248.     if (parent->type == XML_ELEMENT_NODE) {
  1249. #ifdef DEBUG_SAX_TREE
  1250. fprintf(stderr, "adding comment child to %sn", parent->name);
  1251. #endif
  1252. xmlAddChild(parent, ret);
  1253.     } else {
  1254. #ifdef DEBUG_SAX_TREE
  1255. fprintf(stderr, "adding comment sibling to ");
  1256. xmlDebugDumpOneNode(stderr, parent, 0);
  1257. #endif
  1258. xmlAddSibling(parent, ret);
  1259.     }
  1260. }
  1262. /**
  1263.  * cdataBlock:
  1264.  * @ctx: the user data (XML parser context)
  1265.  * @value:  The pcdata content
  1266.  * @len:  the block length
  1267.  *
  1268.  * called when a pcdata block has been parsed
  1269.  */
  1270. void
  1271. cdataBlock(void *ctx, const xmlChar *value, int len)
  1272. {
  1273.     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
  1274.     xmlNodePtr ret, lastChild;
  1276. #ifdef DEBUG_SAX
  1277.     fprintf(stderr, "SAX.pcdata(%.10s, %d)n", value, len);
  1278. #endif
  1279.     lastChild = xmlGetLastChild(ctxt->node);
  1280. #ifdef DEBUG_SAX_TREE
  1281.     fprintf(stderr, "add chars to %s n", ctxt->node->name);
  1282. #endif
  1283.     if ((lastChild != NULL) &&
  1284.         (lastChild->type == XML_CDATA_SECTION_NODE)) {
  1285. xmlTextConcat(lastChild, value, len);
  1286.     } else {
  1287. ret = xmlNewCDataBlock(ctxt->myDoc, value, len);
  1288. xmlAddChild(ctxt->node, ret);
  1289.     }
  1290. }
  1292. /*
  1293.  * Default handler for XML, builds the DOM tree
  1294.  */
  1295. xmlSAXHandler xmlDefaultSAXHandler = {
  1296.     internalSubset,
  1297.     isStandalone,
  1298.     hasInternalSubset,
  1299.     hasExternalSubset,
  1300.     resolveEntity,
  1301.     getEntity,
  1302.     entityDecl,
  1303.     notationDecl,
  1304.     attributeDecl,
  1305.     elementDecl,
  1306.     unparsedEntityDecl,
  1307.     setDocumentLocator,
  1308.     startDocument,
  1309.     endDocument,
  1310.     startElement,
  1311.     endElement,
  1312.     reference,
  1313.     characters,
  1314.     ignorableWhitespace,
  1315.     processingInstruction,
  1316.     comment,
  1317.     xmlParserWarning,
  1318.     xmlParserError,
  1319.     xmlParserError,
  1320.     getParameterEntity,
  1321.     cdataBlock,
  1322.     externalSubset,
  1323. };
  1325. /**
  1326.  * xmlDefaultSAXHandlerInit:
  1327.  *
  1328.  * Initialize the default SAX handler
  1329.  */
  1330. void
  1331. xmlDefaultSAXHandlerInit(void)
  1332. {
  1333.     xmlDefaultSAXHandler.internalSubset = internalSubset;
  1334.     xmlDefaultSAXHandler.externalSubset = externalSubset;
  1335.     xmlDefaultSAXHandler.isStandalone = isStandalone;
  1336.     xmlDefaultSAXHandler.hasInternalSubset = hasInternalSubset;
  1337.     xmlDefaultSAXHandler.hasExternalSubset = hasExternalSubset;
  1338.     xmlDefaultSAXHandler.resolveEntity = resolveEntity;
  1339.     xmlDefaultSAXHandler.getEntity = getEntity;
  1340.     xmlDefaultSAXHandler.getParameterEntity = getParameterEntity;
  1341.     xmlDefaultSAXHandler.entityDecl = entityDecl;
  1342.     xmlDefaultSAXHandler.attributeDecl = attributeDecl;
  1343.     xmlDefaultSAXHandler.elementDecl = elementDecl;
  1344.     xmlDefaultSAXHandler.notationDecl = notationDecl;
  1345.     xmlDefaultSAXHandler.unparsedEntityDecl = unparsedEntityDecl;
  1346.     xmlDefaultSAXHandler.setDocumentLocator = setDocumentLocator;
  1347.     xmlDefaultSAXHandler.startDocument = startDocument;
  1348.     xmlDefaultSAXHandler.endDocument = endDocument;
  1349.     xmlDefaultSAXHandler.startElement = startElement;
  1350.     xmlDefaultSAXHandler.endElement = endElement;
  1351.     xmlDefaultSAXHandler.reference = reference;
  1352.     xmlDefaultSAXHandler.characters = characters;
  1353.     xmlDefaultSAXHandler.cdataBlock = cdataBlock;
  1354.     xmlDefaultSAXHandler.ignorableWhitespace = ignorableWhitespace;
  1355.     xmlDefaultSAXHandler.processingInstruction = processingInstruction;
  1356.     xmlDefaultSAXHandler.comment = comment;
  1357.     if (xmlGetWarningsDefaultValue == 0)
  1358. xmlDefaultSAXHandler.warning = NULL;
  1359.     else
  1360. xmlDefaultSAXHandler.warning = xmlParserWarning;
  1361.     xmlDefaultSAXHandler.error = xmlParserError;
  1362.     xmlDefaultSAXHandler.fatalError = xmlParserError;
  1363. }
  1365. /*
  1366.  * Default handler for HTML, builds the DOM tree
  1367.  */
  1368. xmlSAXHandler htmlDefaultSAXHandler = {
  1369.     NULL,
  1370.     NULL,
  1371.     NULL,
  1372.     NULL,
  1373.     NULL,
  1374.     getEntity,
  1375.     NULL,
  1376.     NULL,
  1377.     NULL,
  1378.     NULL,
  1379.     NULL,
  1380.     setDocumentLocator,
  1381.     startDocument,
  1382.     endDocument,
  1383.     startElement,
  1384.     endElement,
  1385.     NULL,
  1386.     characters,
  1387.     ignorableWhitespace,
  1388.     NULL,
  1389.     comment,
  1390.     xmlParserWarning,
  1391.     xmlParserError,
  1392.     xmlParserError,
  1393.     getParameterEntity,
  1394.     NULL,
  1395.     NULL,
  1396. };
  1398. /**
  1399.  * htmlDefaultSAXHandlerInit:
  1400.  *
  1401.  * Initialize the default SAX handler
  1402.  */
  1403. void
  1404. htmlDefaultSAXHandlerInit(void)
  1405. {
  1406.     htmlDefaultSAXHandler.internalSubset = NULL;
  1407.     htmlDefaultSAXHandler.externalSubset = NULL;
  1408.     htmlDefaultSAXHandler.isStandalone = NULL;
  1409.     htmlDefaultSAXHandler.hasInternalSubset = NULL;
  1410.     htmlDefaultSAXHandler.hasExternalSubset = NULL;
  1411.     htmlDefaultSAXHandler.resolveEntity = NULL;
  1412.     htmlDefaultSAXHandler.getEntity = getEntity;
  1413.     htmlDefaultSAXHandler.getParameterEntity = NULL;
  1414.     htmlDefaultSAXHandler.entityDecl = NULL;
  1415.     htmlDefaultSAXHandler.attributeDecl = NULL;
  1416.     htmlDefaultSAXHandler.elementDecl = NULL;
  1417.     htmlDefaultSAXHandler.notationDecl = NULL;
  1418.     htmlDefaultSAXHandler.unparsedEntityDecl = NULL;
  1419.     htmlDefaultSAXHandler.setDocumentLocator = setDocumentLocator;
  1420.     htmlDefaultSAXHandler.startDocument = startDocument;
  1421.     htmlDefaultSAXHandler.endDocument = endDocument;
  1422.     htmlDefaultSAXHandler.startElement = startElement;
  1423.     htmlDefaultSAXHandler.endElement = endElement;
  1424.     htmlDefaultSAXHandler.reference = NULL;
  1425.     htmlDefaultSAXHandler.characters = characters;
  1426.     htmlDefaultSAXHandler.cdataBlock = NULL;
  1427.     htmlDefaultSAXHandler.ignorableWhitespace = ignorableWhitespace;
  1428.     htmlDefaultSAXHandler.processingInstruction = NULL;
  1429.     htmlDefaultSAXHandler.comment = comment;
  1430.     htmlDefaultSAXHandler.warning = xmlParserWarning;
  1431.     htmlDefaultSAXHandler.error = xmlParserError;
  1432.     htmlDefaultSAXHandler.fatalError = xmlParserError;
  1433. }