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