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