SAX2.c

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