xmlsave.c

   1 /*
   2  * xmlsave.c: Implemetation of the document serializer
   3  *
   4  * See Copyright for the status of this software.
   5  *
   6  * daniel@veillard.com
   7  */
   8
   9 #define IN_LIBXML
  10 #include "libxml.h"
  11
  12 #include <string.h>
  13 #include <libxml/xmlmemory.h>
  14 #include <libxml/parserInternals.h>
  15 #include <libxml/tree.h>
  16 #include <libxml/xmlsave.h>
  17
  18 #define MAX_INDENT 60
  19
  20 #include <libxml/HTMLtree.h>
  21
  22 /************************************************************************
  23  *                                                                      *
  24  *                      XHTML detection                                 *
  25  *                                                                      *
  26  ************************************************************************/
  27 #define XHTML_STRICT_PUBLIC_ID BAD_CAST \
  28    "-//W3C//DTD XHTML 1.0 Strict//EN"
  29 #define XHTML_STRICT_SYSTEM_ID BAD_CAST \
  30    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
  31 #define XHTML_FRAME_PUBLIC_ID BAD_CAST \
  32    "-//W3C//DTD XHTML 1.0 Frameset//EN"
  33 #define XHTML_FRAME_SYSTEM_ID BAD_CAST \
  34    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd"
  35 #define XHTML_TRANS_PUBLIC_ID BAD_CAST \
  36    "-//W3C//DTD XHTML 1.0 Transitional//EN"
  37 #define XHTML_TRANS_SYSTEM_ID BAD_CAST \
  38    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"
  39
  40 #define XHTML_NS_NAME BAD_CAST "http://www.w3.org/1999/xhtml"
  41 /**
  42  * xmlIsXHTML:
  43  * @systemID:  the system identifier
  44  * @publicID:  the public identifier
  45  *
  46  * Try to find if the document correspond to an XHTML DTD
  47  *
  48  * Returns 1 if true, 0 if not and -1 in case of error
  49  */
  50 int
  51 xmlIsXHTML(const xmlChar *systemID, const xmlChar *publicID) {
  52     if ((systemID == NULL) && (publicID == NULL))
  53         return(-1);
  54     if (publicID != NULL) {
  55         if (xmlStrEqual(publicID, XHTML_STRICT_PUBLIC_ID)) return(1);
  56         if (xmlStrEqual(publicID, XHTML_FRAME_PUBLIC_ID)) return(1);
  57         if (xmlStrEqual(publicID, XHTML_TRANS_PUBLIC_ID)) return(1);
  58     }
  59     if (systemID != NULL) {
  60         if (xmlStrEqual(systemID, XHTML_STRICT_SYSTEM_ID)) return(1);
  61         if (xmlStrEqual(systemID, XHTML_FRAME_SYSTEM_ID)) return(1);
  62         if (xmlStrEqual(systemID, XHTML_TRANS_SYSTEM_ID)) return(1);
  63     }
  64     return(0);
  65 }
  66
  67 #ifdef LIBXML_OUTPUT_ENABLED
  68
  69 #define TODO                                                            \
  70     xmlGenericError(xmlGenericErrorContext,                             \
  71             "Unimplemented block at %s:%d\n",                           \
  72             __FILE__, __LINE__);
  73
  74 struct _xmlSaveCtxt {
  75     void *_private;
  76     int type;
  77     int fd;
  78     const xmlChar *filename;
  79     const xmlChar *encoding;
  80     xmlCharEncodingHandlerPtr handler;
  81     xmlOutputBufferPtr buf;
  82     xmlDocPtr doc;
  83     int options;
  84     int level;
  85     int format;
  86     char indent[MAX_INDENT + 1];        /* array for indenting output */
  87     int indent_nr;
  88     int indent_size;
  89     xmlCharEncodingOutputFunc escape;   /* used for element content */
  90     xmlCharEncodingOutputFunc escapeAttr;/* used for attribute content */
  91 };
  92
  93 /************************************************************************
  94  *                                                                      *
  95  *                      Output error handlers                           *
  96  *                                                                      *
  97  ************************************************************************/
  98 /**
  99  * xmlSaveErrMemory:
 100  * @extra:  extra informations
 101  *
 102  * Handle an out of memory condition
 103  */
 104 static void
 105 xmlSaveErrMemory(const char *extra)
 106 {
 107     __xmlSimpleError(XML_FROM_OUTPUT, XML_ERR_NO_MEMORY, NULL, NULL, extra);
 108 }
 109
 110 /**
 111  * xmlSaveErr:
 112  * @code:  the error number
 113  * @node:  the location of the error.
 114  * @extra:  extra informations
 115  *
 116  * Handle an out of memory condition
 117  */
 118 static void
 119 xmlSaveErr(int code, xmlNodePtr node, const char *extra)
 120 {
 121     const char *msg = NULL;
 122
 123     switch(code) {
 124         case XML_SAVE_NOT_UTF8:
 125             msg = "string is not in UTF-8\n";
 126             break;
 127         case XML_SAVE_CHAR_INVALID:
 128             msg = "invalid character value\n";
 129             break;
 130         case XML_SAVE_UNKNOWN_ENCODING:
 131             msg = "unknown encoding %s\n";
 132             break;
 133         case XML_SAVE_NO_DOCTYPE:
 134             msg = "document has no DOCTYPE\n";
 135             break;
 136         default:
 137             msg = "unexpected error number\n";
 138     }
 139     __xmlSimpleError(XML_FROM_OUTPUT, code, node, msg, extra);
 140 }
 141
 142 /************************************************************************
 143  *                                                                      *
 144  *                      Special escaping routines                       *
 145  *                                                                      *
 146  ************************************************************************/
 147 static unsigned char *
 148 xmlSerializeHexCharRef(unsigned char *out, int val) {
 149     unsigned char *ptr;
 150
 151     *out++ = '&';
 152     *out++ = '#';
 153     *out++ = 'x';
 154     if (val < 0x10) ptr = out;
 155     else if (val < 0x100) ptr = out + 1;
 156     else if (val < 0x1000) ptr = out + 2;
 157     else if (val < 0x10000) ptr = out + 3;
 158     else if (val < 0x100000) ptr = out + 4;
 159     else ptr = out + 5;
 160     out = ptr + 1;
 161     while (val > 0) {
 162         switch (val & 0xF) {
 163             case 0: *ptr-- = '0'; break;
 164             case 1: *ptr-- = '1'; break;
 165             case 2: *ptr-- = '2'; break;
 166             case 3: *ptr-- = '3'; break;
 167             case 4: *ptr-- = '4'; break;
 168             case 5: *ptr-- = '5'; break;
 169             case 6: *ptr-- = '6'; break;
 170             case 7: *ptr-- = '7'; break;
 171             case 8: *ptr-- = '8'; break;
 172             case 9: *ptr-- = '9'; break;
 173             case 0xA: *ptr-- = 'A'; break;
 174             case 0xB: *ptr-- = 'B'; break;
 175             case 0xC: *ptr-- = 'C'; break;
 176             case 0xD: *ptr-- = 'D'; break;
 177             case 0xE: *ptr-- = 'E'; break;
 178             case 0xF: *ptr-- = 'F'; break;
 179             default: *ptr-- = '0'; break;
 180         }
 181         val >>= 4;
 182     }
 183     *out++ = ';';
 184     *out = 0;
 185     return(out);
 186 }
 187
 188 /**
 189  * xmlEscapeEntities:
 190  * @out:  a pointer to an array of bytes to store the result
 191  * @outlen:  the length of @out
 192  * @in:  a pointer to an array of unescaped UTF-8 bytes
 193  * @inlen:  the length of @in
 194  *
 195  * Take a block of UTF-8 chars in and escape them. Used when there is no
 196  * encoding specified.
 197  *
 198  * Returns 0 if success, or -1 otherwise
 199  * The value of @inlen after return is the number of octets consumed
 200  *     if the return value is positive, else unpredictable.
 201  * The value of @outlen after return is the number of octets consumed.
 202  */
 203 static int
 204 xmlEscapeEntities(unsigned char* out, int *outlen,
 205                  const xmlChar* in, int *inlen) {
 206     unsigned char* outstart = out;
 207     const unsigned char* base = in;
 208     unsigned char* outend = out + *outlen;
 209     const unsigned char* inend;
 210     int val;
 211
 212     inend = in + (*inlen);
 213
 214     while ((in < inend) && (out < outend)) {
 215         if (*in == '<') {
 216             if (outend - out < 4) break;
 217             *out++ = '&';
 218             *out++ = 'l';
 219             *out++ = 't';
 220             *out++ = ';';
 221             in++;
 222             continue;
 223         } else if (*in == '>') {
 224             if (outend - out < 4) break;
 225             *out++ = '&';
 226             *out++ = 'g';
 227             *out++ = 't';
 228             *out++ = ';';
 229             in++;
 230             continue;
 231         } else if (*in == '&') {
 232             if (outend - out < 5) break;
 233             *out++ = '&';
 234             *out++ = 'a';
 235             *out++ = 'm';
 236             *out++ = 'p';
 237             *out++ = ';';
 238             in++;
 239             continue;
 240         } else if (((*in >= 0x20) && (*in < 0x80)) ||
 241                    (*in == '\n') || (*in == '\t')) {
 242             /*
 243              * default case, just copy !
 244              */
 245             *out++ = *in++;
 246             continue;
 247         } else if (*in >= 0x80) {
 248             /*
 249              * We assume we have UTF-8 input.
 250              */
 251             if (outend - out < 10) break;
 252
 253             if (*in < 0xC0) {
 254                 xmlSaveErr(XML_SAVE_NOT_UTF8, NULL, NULL);
 255                 in++;
 256                 goto error;
 257             } else if (*in < 0xE0) {
 258                 if (inend - in < 2) break;
 259                 val = (in[0]) & 0x1F;
 260                 val <<= 6;
 261                 val |= (in[1]) & 0x3F;
 262                 in += 2;
 263             } else if (*in < 0xF0) {
 264                 if (inend - in < 3) break;
 265                 val = (in[0]) & 0x0F;
 266                 val <<= 6;
 267                 val |= (in[1]) & 0x3F;
 268                 val <<= 6;
 269                 val |= (in[2]) & 0x3F;
 270                 in += 3;
 271             } else if (*in < 0xF8) {
 272                 if (inend - in < 4) break;
 273                 val = (in[0]) & 0x07;
 274                 val <<= 6;
 275                 val |= (in[1]) & 0x3F;
 276                 val <<= 6;
 277                 val |= (in[2]) & 0x3F;
 278                 val <<= 6;
 279                 val |= (in[3]) & 0x3F;
 280                 in += 4;
 281             } else {
 282                 xmlSaveErr(XML_SAVE_CHAR_INVALID, NULL, NULL);
 283                 in++;
 284                 goto error;
 285             }
 286             if (!IS_CHAR(val)) {
 287                 xmlSaveErr(XML_SAVE_CHAR_INVALID, NULL, NULL);
 288                 in++;
 289                 goto error;
 290             }
 291
 292             /*
 293              * We could do multiple things here. Just save as a char ref
 294              */
 295             out = xmlSerializeHexCharRef(out, val);
 296         } else if (IS_BYTE_CHAR(*in)) {
 297             if (outend - out < 6) break;
 298             out = xmlSerializeHexCharRef(out, *in++);
 299         } else {
 300             xmlGenericError(xmlGenericErrorContext,
 301                 "xmlEscapeEntities : char out of range\n");
 302             in++;
 303             goto error;
 304         }
 305     }
 306     *outlen = out - outstart;
 307     *inlen = in - base;
 308     return(0);
 309 error:
 310     *outlen = out - outstart;
 311     *inlen = in - base;
 312     return(-1);
 313 }
 314
 315 /************************************************************************
 316  *                                                                      *
 317  *                      Allocation and deallocation                     *
 318  *                                                                      *
 319  ************************************************************************/
 320 /**
 321  * xmlSaveCtxtInit:
 322  * @ctxt: the saving context
 323  *
 324  * Initialize a saving context
 325  */
 326 static void
 327 xmlSaveCtxtInit(xmlSaveCtxtPtr ctxt)
 328 {
 329     int i;
 330     int len;
 331
 332     if (ctxt == NULL) return;
 333     if ((ctxt->encoding == NULL) && (ctxt->escape == NULL))
 334         ctxt->escape = xmlEscapeEntities;
 335     len = xmlStrlen((xmlChar *)xmlTreeIndentString);
 336     if ((xmlTreeIndentString == NULL) || (len == 0)) {
 337         memset(&ctxt->indent[0], 0, MAX_INDENT + 1);
 338     } else {
 339         ctxt->indent_size = len;
 340         ctxt->indent_nr = MAX_INDENT / ctxt->indent_size;
 341         for (i = 0;i < ctxt->indent_nr;i++)
 342             memcpy(&ctxt->indent[i * ctxt->indent_size], xmlTreeIndentString,
 343                    ctxt->indent_size);
 344         ctxt->indent[ctxt->indent_nr * ctxt->indent_size] = 0;
 345     }
 346
 347     if (xmlSaveNoEmptyTags) {
 348         ctxt->options |= XML_SAVE_NO_EMPTY;
 349     }
 350 }
 351
 352 /**
 353  * xmlFreeSaveCtxt:
 354  *
 355  * Free a saving context, destroying the ouptut in any remaining buffer
 356  */
 357 static void
 358 xmlFreeSaveCtxt(xmlSaveCtxtPtr ctxt)
 359 {
 360     if (ctxt == NULL) return;
 361     if (ctxt->encoding != NULL)
 362         xmlFree((char *) ctxt->encoding);
 363     if (ctxt->buf != NULL)
 364         xmlOutputBufferClose(ctxt->buf);
 365     xmlFree(ctxt);
 366 }
 367
 368 /**
 369  * xmlNewSaveCtxt:
 370  *
 371  * Create a new saving context
 372  *
 373  * Returns the new structure or NULL in case of error
 374  */
 375 static xmlSaveCtxtPtr
 376 xmlNewSaveCtxt(const char *encoding, int options)
 377 {
 378     xmlSaveCtxtPtr ret;
 379
 380     ret = (xmlSaveCtxtPtr) xmlMalloc(sizeof(xmlSaveCtxt));
 381     if (ret == NULL) {
 382         xmlSaveErrMemory("creating saving context");
 383         return ( NULL );
 384     }
 385     memset(ret, 0, sizeof(xmlSaveCtxt));
 386
 387     if (encoding != NULL) {
 388         ret->handler = xmlFindCharEncodingHandler(encoding);
 389         if (ret->handler == NULL) {
 390             xmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
 391             xmlFreeSaveCtxt(ret);
 392             return(NULL);
 393         }
 394         ret->encoding = xmlStrdup((const xmlChar *)encoding);
 395         ret->escape = NULL;
 396     }
 397     xmlSaveCtxtInit(ret);
 398
 399     /*
 400      * Use the options
 401      */
 402
 403     /* Re-check this option as it may already have been set */
 404     if ((ret->options & XML_SAVE_NO_EMPTY) && ! (options & XML_SAVE_NO_EMPTY)) {
 405         options |= XML_SAVE_NO_EMPTY;
 406     }
 407
 408     ret->options = options;
 409     if (options & XML_SAVE_FORMAT)
 410         ret->format = 1;
 411     else if (options & XML_SAVE_WSNONSIG)
 412         ret->format = 2;
 413
 414     return(ret);
 415 }
 416
 417 /************************************************************************
 418  *                                                                      *
 419  *              Dumping XML tree content to a simple buffer             *
 420  *                                                                      *
 421  ************************************************************************/
 422 /**
 423  * xmlAttrSerializeContent:
 424  * @buf:  the XML buffer output
 425  * @doc:  the document
 426  * @attr:  the attribute pointer
 427  *
 428  * Serialize the attribute in the buffer
 429  */
 430 static void
 431 xmlAttrSerializeContent(xmlOutputBufferPtr buf, xmlAttrPtr attr)
 432 {
 433     xmlNodePtr children;
 434
 435     children = attr->children;
 436     while (children != NULL) {
 437         switch (children->type) {
 438             case XML_TEXT_NODE:
 439                 xmlAttrSerializeTxtContent(buf->buffer, attr->doc,
 440                                            attr, children->content);
 441                 break;
 442             case XML_ENTITY_REF_NODE:
 443                 xmlBufferAdd(buf->buffer, BAD_CAST "&", 1);
 444                 xmlBufferAdd(buf->buffer, children->name,
 445                              xmlStrlen(children->name));
 446                 xmlBufferAdd(buf->buffer, BAD_CAST ";", 1);
 447                 break;
 448             default:
 449                 /* should not happen unless we have a badly built tree */
 450                 break;
 451         }
 452         children = children->next;
 453     }
 454 }
 455
 456 /************************************************************************
 457  *                                                                      *
 458  *              Dumping XML tree content to an I/O output buffer        *
 459  *                                                                      *
 460  ************************************************************************/
 461
 462 static int xmlSaveSwitchEncoding(xmlSaveCtxtPtr ctxt, const char *encoding) {
 463     xmlOutputBufferPtr buf = ctxt->buf;
 464
 465     if ((encoding != NULL) && (buf->encoder == NULL) && (buf->conv == NULL)) {
 466         buf->encoder = xmlFindCharEncodingHandler((const char *)encoding);
 467         if (buf->encoder == NULL) {
 468             xmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL,
 469                        (const char *)encoding);
 470             return(-1);
 471         }
 472         buf->conv = xmlBufferCreate();
 473         if (buf->conv == NULL) {
 474             xmlCharEncCloseFunc(buf->encoder);
 475             xmlSaveErrMemory("creating encoding buffer");
 476             return(-1);
 477         }
 478         /*
 479          * initialize the state, e.g. if outputting a BOM
 480          */
 481         xmlCharEncOutFunc(buf->encoder, buf->conv, NULL);
 482     }
 483     return(0);
 484 }
 485
 486 static int xmlSaveClearEncoding(xmlSaveCtxtPtr ctxt) {
 487     xmlOutputBufferPtr buf = ctxt->buf;
 488     xmlOutputBufferFlush(buf);
 489     xmlCharEncCloseFunc(buf->encoder);
 490     xmlBufferFree(buf->conv);
 491     buf->encoder = NULL;
 492     buf->conv = NULL;
 493     return(0);
 494 }
 495
 496 #ifdef LIBXML_HTML_ENABLED
 497 static void
 498 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur);
 499 #endif
 500 static void xmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur);
 501 static void xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNodePtr cur);
 502 void xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur);
 503 static int xmlDocContentDumpOutput(xmlSaveCtxtPtr ctxt, xmlDocPtr cur);
 504
 505 /**
 506  * xmlOutputBufferWriteWSNonSig:
 507  * @ctxt:  The save context
 508  * @extra: Number of extra indents to apply to ctxt->level
 509  *
 510  * Write out formatting for non-significant whitespace output.
 511  */
 512 static void
 513 xmlOutputBufferWriteWSNonSig(xmlSaveCtxtPtr ctxt, int extra)
 514 {
 515     int i;
 516     if ((ctxt == NULL) || (ctxt->buf == NULL))
 517         return;
 518     xmlOutputBufferWrite(ctxt->buf, 1, "\n");
 519     for (i = 0; i < (ctxt->level + extra); i += ctxt->indent_nr) {
 520         xmlOutputBufferWrite(ctxt->buf, ctxt->indent_size *
 521                 ((ctxt->level + extra - i) > ctxt->indent_nr ?
 522                  ctxt->indent_nr : (ctxt->level + extra - i)),
 523                 ctxt->indent);
 524     }
 525 }
 526
 527 /**
 528  * xmlNsDumpOutput:
 529  * @buf:  the XML buffer output
 530  * @cur:  a namespace
 531  * @ctxt: the output save context. Optional.
 532  *
 533  * Dump a local Namespace definition.
 534  * Should be called in the context of attributes dumps.
 535  * If @ctxt is supplied, @buf should be its buffer.
 536  */
 537 static void
 538 xmlNsDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur, xmlSaveCtxtPtr ctxt) {
 539     if ((cur == NULL) || (buf == NULL)) return;
 540     if ((cur->type == XML_LOCAL_NAMESPACE) && (cur->href != NULL)) {
 541         if (xmlStrEqual(cur->prefix, BAD_CAST "xml"))
 542             return;
 543
 544         if (ctxt != NULL && ctxt->format == 2)
 545             xmlOutputBufferWriteWSNonSig(ctxt, 2);
 546         else
 547             xmlOutputBufferWrite(buf, 1, " ");
 548
 549         /* Within the context of an element attributes */
 550         if (cur->prefix != NULL) {
 551             xmlOutputBufferWrite(buf, 6, "xmlns:");
 552             xmlOutputBufferWriteString(buf, (const char *)cur->prefix);
 553         } else
 554             xmlOutputBufferWrite(buf, 5, "xmlns");
 555         xmlOutputBufferWrite(buf, 1, "=");
 556         xmlBufferWriteQuotedString(buf->buffer, cur->href);
 557     }
 558 }
 559
 560 /**
 561  * xmlNsDumpOutputCtxt
 562  * @ctxt: the save context
 563  * @cur:  a namespace
 564  *
 565  * Dump a local Namespace definition to a save context.
 566  * Should be called in the context of attribute dumps.
 567  */
 568 static void
 569 xmlNsDumpOutputCtxt(xmlSaveCtxtPtr ctxt, xmlNsPtr cur) {
 570     xmlNsDumpOutput(ctxt->buf, cur, ctxt);
 571 }
 572
 573 /**
 574  * xmlNsListDumpOutputCtxt
 575  * @ctxt: the save context
 576  * @cur:  the first namespace
 577  *
 578  * Dump a list of local namespace definitions to a save context.
 579  * Should be called in the context of attribute dumps.
 580  */
 581 static void
 582 xmlNsListDumpOutputCtxt(xmlSaveCtxtPtr ctxt, xmlNsPtr cur) {
 583     while (cur != NULL) {
 584         xmlNsDumpOutput(ctxt->buf, cur, ctxt);
 585         cur = cur->next;
 586     }
 587 }
 588
 589 /**
 590  * xmlNsListDumpOutput:
 591  * @buf:  the XML buffer output
 592  * @cur:  the first namespace
 593  *
 594  * Dump a list of local Namespace definitions.
 595  * Should be called in the context of attributes dumps.
 596  */
 597 void
 598 xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur) {
 599     while (cur != NULL) {
 600         xmlNsDumpOutput(buf, cur, NULL);
 601         cur = cur->next;
 602     }
 603 }
 604
 605 /**
 606  * xmlDtdDumpOutput:
 607  * @buf:  the XML buffer output
 608  * @dtd:  the pointer to the DTD
 609  *
 610  * Dump the XML document DTD, if any.
 611  */
 612 static void
 613 xmlDtdDumpOutput(xmlSaveCtxtPtr ctxt, xmlDtdPtr dtd) {
 614     xmlOutputBufferPtr buf;
 615     int format, level;
 616     xmlDocPtr doc;
 617
 618     if (dtd == NULL) return;
 619     if ((ctxt == NULL) || (ctxt->buf == NULL))
 620         return;
 621     buf = ctxt->buf;
 622     xmlOutputBufferWrite(buf, 10, "<!DOCTYPE ");
 623     xmlOutputBufferWriteString(buf, (const char *)dtd->name);
 624     if (dtd->ExternalID != NULL) {
 625         xmlOutputBufferWrite(buf, 8, " PUBLIC ");
 626         xmlBufferWriteQuotedString(buf->buffer, dtd->ExternalID);
 627         xmlOutputBufferWrite(buf, 1, " ");
 628         xmlBufferWriteQuotedString(buf->buffer, dtd->SystemID);
 629     }  else if (dtd->SystemID != NULL) {
 630         xmlOutputBufferWrite(buf, 8, " SYSTEM ");
 631         xmlBufferWriteQuotedString(buf->buffer, dtd->SystemID);
 632     }
 633     if ((dtd->entities == NULL) && (dtd->elements == NULL) &&
 634         (dtd->attributes == NULL) && (dtd->notations == NULL) &&
 635         (dtd->pentities == NULL)) {
 636         xmlOutputBufferWrite(buf, 1, ">");
 637         return;
 638     }
 639     xmlOutputBufferWrite(buf, 3, " [\n");
 640     /*
 641      * Dump the notations first they are not in the DTD children list
 642      * Do this only on a standalone DTD or on the internal subset though.
 643      */
 644     if ((dtd->notations != NULL) && ((dtd->doc == NULL) ||
 645         (dtd->doc->intSubset == dtd))) {
 646         xmlDumpNotationTable(buf->buffer, (xmlNotationTablePtr) dtd->notations);
 647     }
 648     format = ctxt->format;
 649     level = ctxt->level;
 650     doc = ctxt->doc;
 651     ctxt->format = 0;
 652     ctxt->level = -1;
 653     ctxt->doc = dtd->doc;
 654     xmlNodeListDumpOutput(ctxt, dtd->children);
 655     ctxt->format = format;
 656     ctxt->level = level;
 657     ctxt->doc = doc;
 658     xmlOutputBufferWrite(buf, 2, "]>");
 659 }
 660
 661 /**
 662  * xmlAttrDumpOutput:
 663  * @buf:  the XML buffer output
 664  * @cur:  the attribute pointer
 665  *
 666  * Dump an XML attribute
 667  */
 668 static void
 669 xmlAttrDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPtr cur) {
 670     xmlOutputBufferPtr buf;
 671
 672     if (cur == NULL) return;
 673     buf = ctxt->buf;
 674     if (buf == NULL) return;
 675     if (ctxt->format == 2)
 676         xmlOutputBufferWriteWSNonSig(ctxt, 2);
 677     else
 678         xmlOutputBufferWrite(buf, 1, " ");
 679     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
 680         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
 681         xmlOutputBufferWrite(buf, 1, ":");
 682     }
 683     xmlOutputBufferWriteString(buf, (const char *)cur->name);
 684     xmlOutputBufferWrite(buf, 2, "=\"");
 685     xmlAttrSerializeContent(buf, cur);
 686     xmlOutputBufferWrite(buf, 1, "\"");
 687 }
 688
 689 /**
 690  * xmlAttrListDumpOutput:
 691  * @buf:  the XML buffer output
 692  * @doc:  the document
 693  * @cur:  the first attribute pointer
 694  * @encoding:  an optional encoding string
 695  *
 696  * Dump a list of XML attributes
 697  */
 698 static void
 699 xmlAttrListDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPtr cur) {
 700     if (cur == NULL) return;
 701     while (cur != NULL) {
 702         xmlAttrDumpOutput(ctxt, cur);
 703         cur = cur->next;
 704     }
 705 }
 706
 707
 708
 709 /**
 710  * xmlNodeListDumpOutput:
 711  * @cur:  the first node
 712  *
 713  * Dump an XML node list, recursive behaviour, children are printed too.
 714  */
 715 static void
 716 xmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
 717     xmlOutputBufferPtr buf;
 718
 719     if (cur == NULL) return;
 720     buf = ctxt->buf;
 721     while (cur != NULL) {
 722         if ((ctxt->format == 1) && (xmlIndentTreeOutput) &&
 723             ((cur->type == XML_ELEMENT_NODE) ||
 724              (cur->type == XML_COMMENT_NODE) ||
 725              (cur->type == XML_PI_NODE)))
 726             xmlOutputBufferWrite(buf, ctxt->indent_size *
 727                                  (ctxt->level > ctxt->indent_nr ?
 728                                   ctxt->indent_nr : ctxt->level),
 729                                  ctxt->indent);
 730         xmlNodeDumpOutputInternal(ctxt, cur);
 731         if (ctxt->format == 1) {
 732             xmlOutputBufferWrite(buf, 1, "\n");
 733         }
 734         cur = cur->next;
 735     }
 736 }
 737
 738 #ifdef LIBXML_HTML_ENABLED
 739 /**
 740  * xmlNodeDumpOutputInternal:
 741  * @cur:  the current node
 742  *
 743  * Dump an HTML node, recursive behaviour, children are printed too.
 744  */
 745 static int
 746 htmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
 747     const xmlChar *oldenc = NULL;
 748     const xmlChar *oldctxtenc = ctxt->encoding;
 749     const xmlChar *encoding = ctxt->encoding;
 750     xmlOutputBufferPtr buf = ctxt->buf;
 751     int switched_encoding = 0;
 752     xmlDocPtr doc;
 753
 754     xmlInitParser();
 755
 756     doc = cur->doc;
 757     if (doc != NULL) {
 758         oldenc = doc->encoding;
 759         if (ctxt->encoding != NULL) {
 760             doc->encoding = BAD_CAST ctxt->encoding;
 761         } else if (doc->encoding != NULL) {
 762             encoding = doc->encoding;
 763         }
 764     }
 765
 766     if ((encoding != NULL) && (doc != NULL))
 767         htmlSetMetaEncoding(doc, (const xmlChar *) encoding);
 768     if ((encoding == NULL) && (doc != NULL))
 769         encoding = htmlGetMetaEncoding(doc);
 770     if (encoding == NULL)
 771         encoding = BAD_CAST "HTML";
 772     if ((encoding != NULL) && (oldctxtenc == NULL) &&
 773         (buf->encoder == NULL) && (buf->conv == NULL)) {
 774         if (xmlSaveSwitchEncoding(ctxt, (const char*) encoding) < 0) {
 775             doc->encoding = oldenc;
 776             return(-1);
 777         }
 778         switched_encoding = 1;
 779     }
 780     if (ctxt->options & XML_SAVE_FORMAT)
 781         htmlNodeDumpFormatOutput(buf, doc, cur,
 782                                        (const char *)encoding, 1);
 783     else
 784         htmlNodeDumpFormatOutput(buf, doc, cur,
 785                                        (const char *)encoding, 0);
 786     /*
 787      * Restore the state of the saving context at the end of the document
 788      */
 789     if ((switched_encoding) && (oldctxtenc == NULL)) {
 790         xmlSaveClearEncoding(ctxt);
 791     }
 792     if (doc != NULL)
 793         doc->encoding = oldenc;
 794     return(0);
 795 }
 796 #endif
 797
 798 /**
 799  * xmlNodeDumpOutputInternal:
 800  * @cur:  the current node
 801  *
 802  * Dump an XML node, recursive behaviour, children are printed too.
 803  */
 804 static void
 805 xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
 806     int format;
 807     xmlNodePtr tmp;
 808     xmlChar *start, *end;
 809     xmlOutputBufferPtr buf;
 810
 811     if (cur == NULL) return;
 812     buf = ctxt->buf;
 813     if (cur->type == XML_XINCLUDE_START)
 814         return;
 815     if (cur->type == XML_XINCLUDE_END)
 816         return;
 817     if ((cur->type == XML_DOCUMENT_NODE) ||
 818         (cur->type == XML_HTML_DOCUMENT_NODE)) {
 819         xmlDocContentDumpOutput(ctxt, (xmlDocPtr) cur);
 820         return;
 821     }
 822 #ifdef LIBXML_HTML_ENABLED
 823     if (ctxt->options & XML_SAVE_XHTML) {
 824         xhtmlNodeDumpOutput(ctxt, cur);
 825         return;
 826     }
 827     if (((cur->type != XML_NAMESPACE_DECL) && (cur->doc != NULL) &&
 828          (cur->doc->type == XML_HTML_DOCUMENT_NODE) &&
 829          ((ctxt->options & XML_SAVE_AS_XML) == 0)) ||
 830         (ctxt->options & XML_SAVE_AS_HTML)) {
 831         htmlNodeDumpOutputInternal(ctxt, cur);
 832         return;
 833     }
 834 #endif
 835     if (cur->type == XML_DTD_NODE) {
 836         xmlDtdDumpOutput(ctxt, (xmlDtdPtr) cur);
 837         return;
 838     }
 839     if (cur->type == XML_DOCUMENT_FRAG_NODE) {
 840         xmlNodeListDumpOutput(ctxt, cur->children);
 841         return;
 842     }
 843     if (cur->type == XML_ELEMENT_DECL) {
 844         xmlDumpElementDecl(buf->buffer, (xmlElementPtr) cur);
 845         return;
 846     }
 847     if (cur->type == XML_ATTRIBUTE_DECL) {
 848         xmlDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur);
 849         return;
 850     }
 851     if (cur->type == XML_ENTITY_DECL) {
 852         xmlDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur);
 853         return;
 854     }
 855     if (cur->type == XML_TEXT_NODE) {
 856         if (cur->content != NULL) {
 857             if (cur->name != xmlStringTextNoenc) {
 858                 xmlOutputBufferWriteEscape(buf, cur->content, ctxt->escape);
 859             } else {
 860                 /*
 861                  * Disable escaping, needed for XSLT
 862                  */
 863                 xmlOutputBufferWriteString(buf, (const char *) cur->content);
 864             }
 865         }
 866
 867         return;
 868     }
 869     if (cur->type == XML_PI_NODE) {
 870         if (cur->content != NULL) {
 871             xmlOutputBufferWrite(buf, 2, "<?");
 872             xmlOutputBufferWriteString(buf, (const char *)cur->name);
 873             if (cur->content != NULL) {
 874                 if (ctxt->format == 2)
 875                     xmlOutputBufferWriteWSNonSig(ctxt, 0);
 876                 else
 877                     xmlOutputBufferWrite(buf, 1, " ");
 878                 xmlOutputBufferWriteString(buf, (const char *)cur->content);
 879             }
 880             xmlOutputBufferWrite(buf, 2, "?>");
 881         } else {
 882             xmlOutputBufferWrite(buf, 2, "<?");
 883             xmlOutputBufferWriteString(buf, (const char *)cur->name);
 884             if (ctxt->format == 2)
 885                 xmlOutputBufferWriteWSNonSig(ctxt, 0);
 886             xmlOutputBufferWrite(buf, 2, "?>");
 887         }
 888         return;
 889     }
 890     if (cur->type == XML_COMMENT_NODE) {
 891         if (cur->content != NULL) {
 892             xmlOutputBufferWrite(buf, 4, "<!--");
 893             xmlOutputBufferWriteString(buf, (const char *)cur->content);
 894             xmlOutputBufferWrite(buf, 3, "-->");
 895         }
 896         return;
 897     }
 898     if (cur->type == XML_ENTITY_REF_NODE) {
 899         xmlOutputBufferWrite(buf, 1, "&");
 900         xmlOutputBufferWriteString(buf, (const char *)cur->name);
 901         xmlOutputBufferWrite(buf, 1, ";");
 902         return;
 903     }
 904     if (cur->type == XML_CDATA_SECTION_NODE) {
 905         if (cur->content == NULL || *cur->content == '\0') {
 906             xmlOutputBufferWrite(buf, 12, "<![CDATA[]]>");
 907         } else {
 908             start = end = cur->content;
 909             while (*end != '\0') {
 910                 if ((*end == ']') && (*(end + 1) == ']') &&
 911                     (*(end + 2) == '>')) {
 912                     end = end + 2;
 913                     xmlOutputBufferWrite(buf, 9, "<![CDATA[");
 914                     xmlOutputBufferWrite(buf, end - start, (const char *)start);
 915                     xmlOutputBufferWrite(buf, 3, "]]>");
 916                     start = end;
 917                 }
 918                 end++;
 919             }
 920             if (start != end) {
 921                 xmlOutputBufferWrite(buf, 9, "<![CDATA[");
 922                 xmlOutputBufferWriteString(buf, (const char *)start);
 923                 xmlOutputBufferWrite(buf, 3, "]]>");
 924             }
 925         }
 926         return;
 927     }
 928     if (cur->type == XML_ATTRIBUTE_NODE) {
 929         xmlAttrDumpOutput(ctxt, (xmlAttrPtr) cur);
 930         return;
 931     }
 932     if (cur->type == XML_NAMESPACE_DECL) {
 933         xmlNsDumpOutputCtxt(ctxt, (xmlNsPtr) cur);
 934         return;
 935     }
 936
 937     format = ctxt->format;
 938     if (format == 1) {
 939         tmp = cur->children;
 940         while (tmp != NULL) {
 941             if ((tmp->type == XML_TEXT_NODE) ||
 942                 (tmp->type == XML_CDATA_SECTION_NODE) ||
 943                 (tmp->type == XML_ENTITY_REF_NODE)) {
 944                 ctxt->format = 0;
 945                 break;
 946             }
 947             tmp = tmp->next;
 948         }
 949     }
 950     xmlOutputBufferWrite(buf, 1, "<");
 951     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
 952         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
 953         xmlOutputBufferWrite(buf, 1, ":");
 954     }
 955
 956     xmlOutputBufferWriteString(buf, (const char *)cur->name);
 957     if (cur->nsDef)
 958         xmlNsListDumpOutputCtxt(ctxt, cur->nsDef);
 959     if (cur->properties != NULL)
 960         xmlAttrListDumpOutput(ctxt, cur->properties);
 961
 962     if (((cur->type == XML_ELEMENT_NODE) || (cur->content == NULL)) &&
 963         (cur->children == NULL) && ((ctxt->options & XML_SAVE_NO_EMPTY) == 0)) {
 964         if (ctxt->format == 2)
 965             xmlOutputBufferWriteWSNonSig(ctxt, 0);
 966         xmlOutputBufferWrite(buf, 2, "/>");
 967         ctxt->format = format;
 968         return;
 969     }
 970     if (ctxt->format == 2)
 971         xmlOutputBufferWriteWSNonSig(ctxt, 1);
 972     xmlOutputBufferWrite(buf, 1, ">");
 973     if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
 974         xmlOutputBufferWriteEscape(buf, cur->content, ctxt->escape);
 975     }
 976     if (cur->children != NULL) {
 977         if (ctxt->format == 1) xmlOutputBufferWrite(buf, 1, "\n");
 978         if (ctxt->level >= 0) ctxt->level++;
 979         xmlNodeListDumpOutput(ctxt, cur->children);
 980         if (ctxt->level > 0) ctxt->level--;
 981         if ((xmlIndentTreeOutput) && (ctxt->format == 1))
 982             xmlOutputBufferWrite(buf, ctxt->indent_size *
 983                                  (ctxt->level > ctxt->indent_nr ?
 984                                   ctxt->indent_nr : ctxt->level),
 985                                  ctxt->indent);
 986     }
 987     xmlOutputBufferWrite(buf, 2, "</");
 988     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
 989         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
 990         xmlOutputBufferWrite(buf, 1, ":");
 991     }
 992
 993     xmlOutputBufferWriteString(buf, (const char *)cur->name);
 994     if (ctxt->format == 2)
 995         xmlOutputBufferWriteWSNonSig(ctxt, 0);
 996     xmlOutputBufferWrite(buf, 1, ">");
 997     ctxt->format = format;
 998 }
 999
1000 /**
1001  * xmlDocContentDumpOutput:
1002  * @cur:  the document
1003  *
1004  * Dump an XML document.
1005  */
1006 static int
1007 xmlDocContentDumpOutput(xmlSaveCtxtPtr ctxt, xmlDocPtr cur) {
1008 #ifdef LIBXML_HTML_ENABLED
1009     xmlDtdPtr dtd;
1010     int is_xhtml = 0;
1011 #endif
1012     const xmlChar *oldenc = cur->encoding;
1013     const xmlChar *oldctxtenc = ctxt->encoding;
1014     const xmlChar *encoding = ctxt->encoding;
1015     xmlCharEncodingOutputFunc oldescape = ctxt->escape;
1016     xmlCharEncodingOutputFunc oldescapeAttr = ctxt->escapeAttr;
1017     xmlOutputBufferPtr buf = ctxt->buf;
1018     xmlCharEncoding enc;
1019     int switched_encoding = 0;
1020
1021     xmlInitParser();
1022
1023     if ((cur->type != XML_HTML_DOCUMENT_NODE) &&
1024         (cur->type != XML_DOCUMENT_NODE))
1025          return(-1);
1026
1027     if (ctxt->encoding != NULL) {
1028         cur->encoding = BAD_CAST ctxt->encoding;
1029     } else if (cur->encoding != NULL) {
1030         encoding = cur->encoding;
1031     } else if (cur->charset != XML_CHAR_ENCODING_UTF8) {
1032         encoding = (const xmlChar *)
1033                      xmlGetCharEncodingName((xmlCharEncoding) cur->charset);
1034     }
1035
1036     if (((cur->type == XML_HTML_DOCUMENT_NODE) &&
1037          ((ctxt->options & XML_SAVE_AS_XML) == 0) &&
1038          ((ctxt->options & XML_SAVE_XHTML) == 0)) ||
1039         (ctxt->options & XML_SAVE_AS_HTML)) {
1040 #ifdef LIBXML_HTML_ENABLED
1041         if (encoding != NULL)
1042             htmlSetMetaEncoding(cur, (const xmlChar *) encoding);
1043         if (encoding == NULL)
1044             encoding = htmlGetMetaEncoding(cur);
1045         if (encoding == NULL)
1046             encoding = BAD_CAST "HTML";
1047         if ((encoding != NULL) && (oldctxtenc == NULL) &&
1048             (buf->encoder == NULL) && (buf->conv == NULL)) {
1049             if (xmlSaveSwitchEncoding(ctxt, (const char*) encoding) < 0) {
1050                 cur->encoding = oldenc;
1051                 return(-1);
1052             }
1053         }
1054         if (ctxt->options & XML_SAVE_FORMAT)
1055             htmlDocContentDumpFormatOutput(buf, cur,
1056                                            (const char *)encoding, 1);
1057         else
1058             htmlDocContentDumpFormatOutput(buf, cur,
1059                                            (const char *)encoding, 0);
1060         if (ctxt->encoding != NULL)
1061             cur->encoding = oldenc;
1062         return(0);
1063 #else
1064         return(-1);
1065 #endif
1066     } else if ((cur->type == XML_DOCUMENT_NODE) ||
1067                (ctxt->options & XML_SAVE_AS_XML) ||
1068                (ctxt->options & XML_SAVE_XHTML)) {
1069         enc = xmlParseCharEncoding((const char*) encoding);
1070         if ((encoding != NULL) && (oldctxtenc == NULL) &&
1071             (buf->encoder == NULL) && (buf->conv == NULL) &&
1072             ((ctxt->options & XML_SAVE_NO_DECL) == 0)) {
1073             if ((enc != XML_CHAR_ENCODING_UTF8) &&
1074                 (enc != XML_CHAR_ENCODING_NONE) &&
1075                 (enc != XML_CHAR_ENCODING_ASCII)) {
1076                 /*
1077                  * we need to switch to this encoding but just for this
1078                  * document since we output the XMLDecl the conversion
1079                  * must be done to not generate not well formed documents.
1080                  */
1081                 if (xmlSaveSwitchEncoding(ctxt, (const char*) encoding) < 0) {
1082                     cur->encoding = oldenc;
1083                     return(-1);
1084                 }
1085                 switched_encoding = 1;
1086             }
1087             if (ctxt->escape == xmlEscapeEntities)
1088                 ctxt->escape = NULL;
1089             if (ctxt->escapeAttr == xmlEscapeEntities)
1090                 ctxt->escapeAttr = NULL;
1091         }
1092
1093
1094         /*
1095          * Save the XML declaration
1096          */
1097         if ((ctxt->options & XML_SAVE_NO_DECL) == 0) {
1098             xmlOutputBufferWrite(buf, 14, "<?xml version=");
1099             if (cur->version != NULL)
1100                 xmlBufferWriteQuotedString(buf->buffer, cur->version);
1101             else
1102                 xmlOutputBufferWrite(buf, 5, "\"1.0\"");
1103             if (encoding != NULL) {
1104                 xmlOutputBufferWrite(buf, 10, " encoding=");
1105                 xmlBufferWriteQuotedString(buf->buffer, (xmlChar *) encoding);
1106             }
1107             switch (cur->standalone) {
1108                 case 0:
1109                     xmlOutputBufferWrite(buf, 16, " standalone=\"no\"");
1110                     break;
1111                 case 1:
1112                     xmlOutputBufferWrite(buf, 17, " standalone=\"yes\"");
1113                     break;
1114             }
1115             xmlOutputBufferWrite(buf, 3, "?>\n");
1116         }
1117
1118 #ifdef LIBXML_HTML_ENABLED
1119         if (ctxt->options & XML_SAVE_XHTML)
1120             is_xhtml = 1;
1121         if ((ctxt->options & XML_SAVE_NO_XHTML) == 0) {
1122             dtd = xmlGetIntSubset(cur);
1123             if (dtd != NULL) {
1124                 is_xhtml = xmlIsXHTML(dtd->SystemID, dtd->ExternalID);
1125                 if (is_xhtml < 0) is_xhtml = 0;
1126             }
1127         }
1128 #endif
1129         if (cur->children != NULL) {
1130             xmlNodePtr child = cur->children;
1131
1132             while (child != NULL) {
1133                 ctxt->level = 0;
1134 #ifdef LIBXML_HTML_ENABLED
1135                 if (is_xhtml)
1136                     xhtmlNodeDumpOutput(ctxt, child);
1137                 else
1138 #endif
1139                     xmlNodeDumpOutputInternal(ctxt, child);
1140                 xmlOutputBufferWrite(buf, 1, "\n");
1141                 child = child->next;
1142             }
1143         }
1144     }
1145
1146     /*
1147      * Restore the state of the saving context at the end of the document
1148      */
1149     if ((switched_encoding) && (oldctxtenc == NULL)) {
1150         xmlSaveClearEncoding(ctxt);
1151         ctxt->escape = oldescape;
1152         ctxt->escapeAttr = oldescapeAttr;
1153     }
1154     cur->encoding = oldenc;
1155     return(0);
1156 }
1157
1158 #ifdef LIBXML_HTML_ENABLED
1159 /************************************************************************
1160  *                                                                      *
1161  *              Functions specific to XHTML serialization               *
1162  *                                                                      *
1163  ************************************************************************/
1164
1165 /**
1166  * xhtmlIsEmpty:
1167  * @node:  the node
1168  *
1169  * Check if a node is an empty xhtml node
1170  *
1171  * Returns 1 if the node is an empty node, 0 if not and -1 in case of error
1172  */
1173 static int
1174 xhtmlIsEmpty(xmlNodePtr node) {
1175     if (node == NULL)
1176         return(-1);
1177     if (node->type != XML_ELEMENT_NODE)
1178         return(0);
1179     if ((node->ns != NULL) && (!xmlStrEqual(node->ns->href, XHTML_NS_NAME)))
1180         return(0);
1181     if (node->children != NULL)
1182         return(0);
1183     switch (node->name[0]) {
1184         case 'a':
1185             if (xmlStrEqual(node->name, BAD_CAST "area"))
1186                 return(1);
1187             return(0);
1188         case 'b':
1189             if (xmlStrEqual(node->name, BAD_CAST "br"))
1190                 return(1);
1191             if (xmlStrEqual(node->name, BAD_CAST "base"))
1192                 return(1);
1193             if (xmlStrEqual(node->name, BAD_CAST "basefont"))
1194                 return(1);
1195             return(0);
1196         case 'c':
1197             if (xmlStrEqual(node->name, BAD_CAST "col"))
1198                 return(1);
1199             return(0);
1200         case 'f':
1201             if (xmlStrEqual(node->name, BAD_CAST "frame"))
1202                 return(1);
1203             return(0);
1204         case 'h':
1205             if (xmlStrEqual(node->name, BAD_CAST "hr"))
1206                 return(1);
1207             return(0);
1208         case 'i':
1209             if (xmlStrEqual(node->name, BAD_CAST "img"))
1210                 return(1);
1211             if (xmlStrEqual(node->name, BAD_CAST "input"))
1212                 return(1);
1213             if (xmlStrEqual(node->name, BAD_CAST "isindex"))
1214                 return(1);
1215             return(0);
1216         case 'l':
1217             if (xmlStrEqual(node->name, BAD_CAST "link"))
1218                 return(1);
1219             return(0);
1220         case 'm':
1221             if (xmlStrEqual(node->name, BAD_CAST "meta"))
1222                 return(1);
1223             return(0);
1224         case 'p':
1225             if (xmlStrEqual(node->name, BAD_CAST "param"))
1226                 return(1);
1227             return(0);
1228     }
1229     return(0);
1230 }
1231
1232 /**
1233  * xhtmlAttrListDumpOutput:
1234  * @cur:  the first attribute pointer
1235  *
1236  * Dump a list of XML attributes
1237  */
1238 static void
1239 xhtmlAttrListDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPtr cur) {
1240     xmlAttrPtr xml_lang = NULL;
1241     xmlAttrPtr lang = NULL;
1242     xmlAttrPtr name = NULL;
1243     xmlAttrPtr id = NULL;
1244     xmlNodePtr parent;
1245     xmlOutputBufferPtr buf;
1246
1247     if (cur == NULL) return;
1248     buf = ctxt->buf;
1249     parent = cur->parent;
1250     while (cur != NULL) {
1251         if ((cur->ns == NULL) && (xmlStrEqual(cur->name, BAD_CAST "id")))
1252             id = cur;
1253         else
1254         if ((cur->ns == NULL) && (xmlStrEqual(cur->name, BAD_CAST "name")))
1255             name = cur;
1256         else
1257         if ((cur->ns == NULL) && (xmlStrEqual(cur->name, BAD_CAST "lang")))
1258             lang = cur;
1259         else
1260         if ((cur->ns != NULL) && (xmlStrEqual(cur->name, BAD_CAST "lang")) &&
1261             (xmlStrEqual(cur->ns->prefix, BAD_CAST "xml")))
1262             xml_lang = cur;
1263         else if ((cur->ns == NULL) &&
1264                  ((cur->children == NULL) ||
1265                   (cur->children->content == NULL) ||
1266                   (cur->children->content[0] == 0)) &&
1267                  (htmlIsBooleanAttr(cur->name))) {
1268             if (cur->children != NULL)
1269                 xmlFreeNode(cur->children);
1270             cur->children = xmlNewText(cur->name);
1271             if (cur->children != NULL)
1272                 cur->children->parent = (xmlNodePtr) cur;
1273         }
1274         xmlAttrDumpOutput(ctxt, cur);
1275         cur = cur->next;
1276     }
1277     /*
1278      * C.8
1279      */
1280     if ((name != NULL) && (id == NULL)) {
1281         if ((parent != NULL) && (parent->name != NULL) &&
1282             ((xmlStrEqual(parent->name, BAD_CAST "a")) ||
1283              (xmlStrEqual(parent->name, BAD_CAST "p")) ||
1284              (xmlStrEqual(parent->name, BAD_CAST "div")) ||
1285              (xmlStrEqual(parent->name, BAD_CAST "img")) ||
1286              (xmlStrEqual(parent->name, BAD_CAST "map")) ||
1287              (xmlStrEqual(parent->name, BAD_CAST "applet")) ||
1288              (xmlStrEqual(parent->name, BAD_CAST "form")) ||
1289              (xmlStrEqual(parent->name, BAD_CAST "frame")) ||
1290              (xmlStrEqual(parent->name, BAD_CAST "iframe")))) {
1291             xmlOutputBufferWrite(buf, 5, " id=\"");
1292             xmlAttrSerializeContent(buf, name);
1293             xmlOutputBufferWrite(buf, 1, "\"");
1294         }
1295     }
1296     /*
1297      * C.7.
1298      */
1299     if ((lang != NULL) && (xml_lang == NULL)) {
1300         xmlOutputBufferWrite(buf, 11, " xml:lang=\"");
1301         xmlAttrSerializeContent(buf, lang);
1302         xmlOutputBufferWrite(buf, 1, "\"");
1303     } else
1304     if ((xml_lang != NULL) && (lang == NULL)) {
1305         xmlOutputBufferWrite(buf, 7, " lang=\"");
1306         xmlAttrSerializeContent(buf, xml_lang);
1307         xmlOutputBufferWrite(buf, 1, "\"");
1308     }
1309 }
1310
1311 /**
1312  * xhtmlNodeListDumpOutput:
1313  * @buf:  the XML buffer output
1314  * @doc:  the XHTML document
1315  * @cur:  the first node
1316  * @level: the imbrication level for indenting
1317  * @format: is formatting allowed
1318  * @encoding:  an optional encoding string
1319  *
1320  * Dump an XML node list, recursive behaviour, children are printed too.
1321  * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
1322  * or xmlKeepBlanksDefault(0) was called
1323  */
1324 static void
1325 xhtmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
1326     xmlOutputBufferPtr buf;
1327
1328     if (cur == NULL) return;
1329     buf = ctxt->buf;
1330     while (cur != NULL) {
1331         if ((ctxt->format == 1) && (xmlIndentTreeOutput) &&
1332             (cur->type == XML_ELEMENT_NODE))
1333             xmlOutputBufferWrite(buf, ctxt->indent_size *
1334                                  (ctxt->level > ctxt->indent_nr ?
1335                                   ctxt->indent_nr : ctxt->level),
1336                                  ctxt->indent);
1337         xhtmlNodeDumpOutput(ctxt, cur);
1338         if (ctxt->format == 1) {
1339             xmlOutputBufferWrite(buf, 1, "\n");
1340         }
1341         cur = cur->next;
1342     }
1343 }
1344
1345 /**
1346  * xhtmlNodeDumpOutput:
1347  * @buf:  the XML buffer output
1348  * @doc:  the XHTML document
1349  * @cur:  the current node
1350  * @level: the imbrication level for indenting
1351  * @format: is formatting allowed
1352  * @encoding:  an optional encoding string
1353  *
1354  * Dump an XHTML node, recursive behaviour, children are printed too.
1355  */
1356 static void
1357 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
1358     int format, addmeta = 0;
1359     xmlNodePtr tmp;
1360     xmlChar *start, *end;
1361     xmlOutputBufferPtr buf;
1362
1363     if (cur == NULL) return;
1364     if ((cur->type == XML_DOCUMENT_NODE) ||
1365         (cur->type == XML_HTML_DOCUMENT_NODE)) {
1366         xmlDocContentDumpOutput(ctxt, (xmlDocPtr) cur);
1367         return;
1368     }
1369     if (cur->type == XML_XINCLUDE_START)
1370         return;
1371     if (cur->type == XML_XINCLUDE_END)
1372         return;
1373     if (cur->type == XML_DTD_NODE) {
1374         xmlDtdDumpOutput(ctxt, (xmlDtdPtr) cur);
1375         return;
1376     }
1377     if (cur->type == XML_DOCUMENT_FRAG_NODE) {
1378         xhtmlNodeListDumpOutput(ctxt, cur->children);
1379         return;
1380     }
1381     buf = ctxt->buf;
1382     if (cur->type == XML_ELEMENT_DECL) {
1383         xmlDumpElementDecl(buf->buffer, (xmlElementPtr) cur);
1384         return;
1385     }
1386     if (cur->type == XML_ATTRIBUTE_DECL) {
1387         xmlDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur);
1388         return;
1389     }
1390     if (cur->type == XML_ENTITY_DECL) {
1391         xmlDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur);
1392         return;
1393     }
1394     if (cur->type == XML_TEXT_NODE) {
1395         if (cur->content != NULL) {
1396             if ((cur->name == xmlStringText) ||
1397                 (cur->name != xmlStringTextNoenc)) {
1398                 xmlOutputBufferWriteEscape(buf, cur->content, ctxt->escape);
1399             } else {
1400                 /*
1401                  * Disable escaping, needed for XSLT
1402                  */
1403                 xmlOutputBufferWriteString(buf, (const char *) cur->content);
1404             }
1405         }
1406
1407         return;
1408     }
1409     if (cur->type == XML_PI_NODE) {
1410         if (cur->content != NULL) {
1411             xmlOutputBufferWrite(buf, 2, "<?");
1412             xmlOutputBufferWriteString(buf, (const char *)cur->name);
1413             if (cur->content != NULL) {
1414                 xmlOutputBufferWrite(buf, 1, " ");
1415                 xmlOutputBufferWriteString(buf, (const char *)cur->content);
1416             }
1417             xmlOutputBufferWrite(buf, 2, "?>");
1418         } else {
1419             xmlOutputBufferWrite(buf, 2, "<?");
1420             xmlOutputBufferWriteString(buf, (const char *)cur->name);
1421             xmlOutputBufferWrite(buf, 2, "?>");
1422         }
1423         return;
1424     }
1425     if (cur->type == XML_COMMENT_NODE) {
1426         if (cur->content != NULL) {
1427             xmlOutputBufferWrite(buf, 4, "<!--");
1428             xmlOutputBufferWriteString(buf, (const char *)cur->content);
1429             xmlOutputBufferWrite(buf, 3, "-->");
1430         }
1431         return;
1432     }
1433     if (cur->type == XML_ENTITY_REF_NODE) {
1434         xmlOutputBufferWrite(buf, 1, "&");
1435         xmlOutputBufferWriteString(buf, (const char *)cur->name);
1436         xmlOutputBufferWrite(buf, 1, ";");
1437         return;
1438     }
1439     if (cur->type == XML_CDATA_SECTION_NODE) {
1440         if (cur->content == NULL || *cur->content == '\0') {
1441             xmlOutputBufferWrite(buf, 12, "<![CDATA[]]>");
1442         } else {
1443             start = end = cur->content;
1444             while (*end != '\0') {
1445                 if (*end == ']' && *(end + 1) == ']' && *(end + 2) == '>') {
1446                     end = end + 2;
1447                     xmlOutputBufferWrite(buf, 9, "<![CDATA[");
1448                     xmlOutputBufferWrite(buf, end - start, (const char *)start);
1449                     xmlOutputBufferWrite(buf, 3, "]]>");
1450                     start = end;
1451                 }
1452                 end++;
1453             }
1454             if (start != end) {
1455                 xmlOutputBufferWrite(buf, 9, "<![CDATA[");
1456                 xmlOutputBufferWriteString(buf, (const char *)start);
1457                 xmlOutputBufferWrite(buf, 3, "]]>");
1458             }
1459         }
1460         return;
1461     }
1462     if (cur->type == XML_ATTRIBUTE_NODE) {
1463         xmlAttrDumpOutput(ctxt, (xmlAttrPtr) cur);
1464         return;
1465     }
1466
1467     format = ctxt->format;
1468     if (format == 1) {
1469         tmp = cur->children;
1470         while (tmp != NULL) {
1471             if ((tmp->type == XML_TEXT_NODE) ||
1472                 (tmp->type == XML_ENTITY_REF_NODE)) {
1473                 format = 0;
1474                 break;
1475             }
1476             tmp = tmp->next;
1477         }
1478     }
1479     xmlOutputBufferWrite(buf, 1, "<");
1480     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
1481         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
1482         xmlOutputBufferWrite(buf, 1, ":");
1483     }
1484
1485     xmlOutputBufferWriteString(buf, (const char *)cur->name);
1486     if (cur->nsDef)
1487         xmlNsListDumpOutputCtxt(ctxt, cur->nsDef);
1488     if ((xmlStrEqual(cur->name, BAD_CAST "html") &&
1489         (cur->ns == NULL) && (cur->nsDef == NULL))) {
1490         /*
1491          * 3.1.1. Strictly Conforming Documents A.3.1.1 3/
1492          */
1493         xmlOutputBufferWriteString(buf,
1494                 " xmlns=\"http://www.w3.org/1999/xhtml\"");
1495     }
1496     if (cur->properties != NULL)
1497         xhtmlAttrListDumpOutput(ctxt, cur->properties);
1498
1499         if ((cur->type == XML_ELEMENT_NODE) &&
1500                 (cur->parent != NULL) &&
1501                 (cur->parent->parent == (xmlNodePtr) cur->doc) &&
1502                 xmlStrEqual(cur->name, BAD_CAST"head") &&
1503                 xmlStrEqual(cur->parent->name, BAD_CAST"html")) {
1504
1505                 tmp = cur->children;
1506                 while (tmp != NULL) {
1507                         if (xmlStrEqual(tmp->name, BAD_CAST"meta")) {
1508                                 xmlChar *httpequiv;
1509
1510                                 httpequiv = xmlGetProp(tmp, BAD_CAST"http-equiv");
1511                                 if (httpequiv != NULL) {
1512                                         if (xmlStrcasecmp(httpequiv, BAD_CAST"Content-Type") == 0) {
1513                                                 xmlFree(httpequiv);
1514                                                 break;
1515                                         }
1516                                         xmlFree(httpequiv);
1517                                 }
1518                         }
1519                         tmp = tmp->next;
1520                 }
1521                 if (tmp == NULL)
1522                         addmeta = 1;
1523         }
1524
1525     if ((cur->type == XML_ELEMENT_NODE) && (cur->children == NULL)) {
1526         if (((cur->ns == NULL) || (cur->ns->prefix == NULL)) &&
1527             ((xhtmlIsEmpty(cur) == 1) && (addmeta == 0))) {
1528             /*
1529              * C.2. Empty Elements
1530              */
1531             xmlOutputBufferWrite(buf, 3, " />");
1532         } else {
1533                 if (addmeta == 1) {
1534                         xmlOutputBufferWrite(buf, 1, ">");
1535                         if (ctxt->format == 1) {
1536                                 xmlOutputBufferWrite(buf, 1, "\n");
1537                                 if (xmlIndentTreeOutput)
1538                                         xmlOutputBufferWrite(buf, ctxt->indent_size *
1539                                         (ctxt->level + 1 > ctxt->indent_nr ?
1540                                         ctxt->indent_nr : ctxt->level + 1), ctxt->indent);
1541                         }
1542                         xmlOutputBufferWriteString(buf,
1543                                 "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=");
1544                         if (ctxt->encoding) {
1545                                 xmlOutputBufferWriteString(buf, (const char *)ctxt->encoding);
1546                         } else {
1547                                 xmlOutputBufferWrite(buf, 5, "UTF-8");
1548                         }
1549                         xmlOutputBufferWrite(buf, 4, "\" />");
1550                         if (ctxt->format == 1)
1551                                 xmlOutputBufferWrite(buf, 1, "\n");
1552                 } else {
1553                         xmlOutputBufferWrite(buf, 1, ">");
1554                 }
1555             /*
1556              * C.3. Element Minimization and Empty Element Content
1557              */
1558             xmlOutputBufferWrite(buf, 2, "</");
1559             if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
1560                 xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
1561                 xmlOutputBufferWrite(buf, 1, ":");
1562             }
1563             xmlOutputBufferWriteString(buf, (const char *)cur->name);
1564             xmlOutputBufferWrite(buf, 1, ">");
1565         }
1566         return;
1567     }
1568     xmlOutputBufferWrite(buf, 1, ">");
1569         if (addmeta == 1) {
1570                 if (ctxt->format == 1) {
1571                         xmlOutputBufferWrite(buf, 1, "\n");
1572                         if (xmlIndentTreeOutput)
1573                                 xmlOutputBufferWrite(buf, ctxt->indent_size *
1574                                 (ctxt->level + 1 > ctxt->indent_nr ?
1575                                 ctxt->indent_nr : ctxt->level + 1), ctxt->indent);
1576                 }
1577                 xmlOutputBufferWriteString(buf,
1578                         "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=");
1579                 if (ctxt->encoding) {
1580                         xmlOutputBufferWriteString(buf, (const char *)ctxt->encoding);
1581                 } else {
1582                         xmlOutputBufferWrite(buf, 5, "UTF-8");
1583                 }
1584                 xmlOutputBufferWrite(buf, 4, "\" />");
1585         }
1586     if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
1587         xmlOutputBufferWriteEscape(buf, cur->content, ctxt->escape);
1588     }
1589
1590 #if 0
1591     /*
1592     * This was removed due to problems with HTML processors.
1593     * See bug #345147.
1594     */
1595     /*
1596      * 4.8. Script and Style elements
1597      */
1598     if ((cur->type == XML_ELEMENT_NODE) &&
1599         ((xmlStrEqual(cur->name, BAD_CAST "script")) ||
1600          (xmlStrEqual(cur->name, BAD_CAST "style"))) &&
1601         ((cur->ns == NULL) ||
1602          (xmlStrEqual(cur->ns->href, XHTML_NS_NAME)))) {
1603         xmlNodePtr child = cur->children;
1604
1605         while (child != NULL) {
1606             if (child->type == XML_TEXT_NODE) {
1607                 if ((xmlStrchr(child->content, '<') == NULL) &&
1608                     (xmlStrchr(child->content, '&') == NULL) &&
1609                     (xmlStrstr(child->content, BAD_CAST "]]>") == NULL)) {
1610                     /* Nothing to escape, so just output as is... */
1611                     /* FIXME: Should we do something about "--" also? */
1612                     int level = ctxt->level;
1613                     int indent = ctxt->format;
1614
1615                     ctxt->level = 0;
1616                     ctxt->format = 0;
1617                     xmlOutputBufferWriteString(buf, (const char *) child->content);
1618                     /* (We cannot use xhtmlNodeDumpOutput() here because
1619                      * we wish to leave '>' unescaped!) */
1620                     ctxt->level = level;
1621                     ctxt->format = indent;
1622                 } else {
1623                     /* We must use a CDATA section.  Unfortunately,
1624                      * this will break CSS and JavaScript when read by
1625                      * a browser in HTML4-compliant mode. :-( */
1626                     start = end = child->content;
1627                     while (*end != '\0') {
1628                         if (*end == ']' &&
1629                             *(end + 1) == ']' &&
1630                             *(end + 2) == '>') {
1631                             end = end + 2;
1632                             xmlOutputBufferWrite(buf, 9, "<![CDATA[");
1633                             xmlOutputBufferWrite(buf, end - start,
1634                                                  (const char *)start);
1635                             xmlOutputBufferWrite(buf, 3, "]]>");
1636                             start = end;
1637                         }
1638                         end++;
1639                     }
1640                     if (start != end) {
1641                         xmlOutputBufferWrite(buf, 9, "<![CDATA[");
1642                         xmlOutputBufferWrite(buf, end - start,
1643                                              (const char *)start);
1644                         xmlOutputBufferWrite(buf, 3, "]]>");
1645                     }
1646                 }
1647             } else {
1648                 int level = ctxt->level;
1649                 int indent = ctxt->format;
1650
1651                 ctxt->level = 0;
1652                 ctxt->format = 0;
1653                 xhtmlNodeDumpOutput(ctxt, child);
1654                 ctxt->level = level;
1655                 ctxt->format = indent;
1656             }
1657             child = child->next;
1658         }
1659     }
1660 #endif
1661
1662     if (cur->children != NULL) {
1663         int indent = ctxt->format;
1664
1665         if (format == 1) xmlOutputBufferWrite(buf, 1, "\n");
1666         if (ctxt->level >= 0) ctxt->level++;
1667         ctxt->format = format;
1668         xhtmlNodeListDumpOutput(ctxt, cur->children);
1669         if (ctxt->level > 0) ctxt->level--;
1670         ctxt->format = indent;
1671         if ((xmlIndentTreeOutput) && (format == 1))
1672             xmlOutputBufferWrite(buf, ctxt->indent_size *
1673                                  (ctxt->level > ctxt->indent_nr ?
1674                                   ctxt->indent_nr : ctxt->level),
1675                                  ctxt->indent);
1676     }
1677     xmlOutputBufferWrite(buf, 2, "</");
1678     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
1679         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
1680         xmlOutputBufferWrite(buf, 1, ":");
1681     }
1682
1683     xmlOutputBufferWriteString(buf, (const char *)cur->name);
1684     xmlOutputBufferWrite(buf, 1, ">");
1685 }
1686 #endif
1687
1688 /************************************************************************
1689  *                                                                      *
1690  *                      Public entry points                             *
1691  *                                                                      *
1692  ************************************************************************/
1693
1694 /**
1695  * xmlSaveToFd:
1696  * @fd:  a file descriptor number
1697  * @encoding:  the encoding name to use or NULL
1698  * @options:  a set of xmlSaveOptions
1699  *
1700  * Create a document saving context serializing to a file descriptor
1701  * with the encoding and the options given.
1702  *
1703  * Returns a new serialization context or NULL in case of error.
1704  */
1705 xmlSaveCtxtPtr
1706 xmlSaveToFd(int fd, const char *encoding, int options)
1707 {
1708     xmlSaveCtxtPtr ret;
1709
1710     ret = xmlNewSaveCtxt(encoding, options);
1711     if (ret == NULL) return(NULL);
1712     ret->buf = xmlOutputBufferCreateFd(fd, ret->handler);
1713     if (ret->buf == NULL) {
1714         xmlFreeSaveCtxt(ret);
1715         return(NULL);
1716     }
1717     return(ret);
1718 }
1719
1720 /**
1721  * xmlSaveToFilename:
1722  * @filename:  a file name or an URL
1723  * @encoding:  the encoding name to use or NULL
1724  * @options:  a set of xmlSaveOptions
1725  *
1726  * Create a document saving context serializing to a filename or possibly
1727  * to an URL (but this is less reliable) with the encoding and the options
1728  * given.
1729  *
1730  * Returns a new serialization context or NULL in case of error.
1731  */
1732 xmlSaveCtxtPtr
1733 xmlSaveToFilename(const char *filename, const char *encoding, int options)
1734 {
1735     xmlSaveCtxtPtr ret;
1736     int compression = 0; /* TODO handle compression option */
1737
1738     ret = xmlNewSaveCtxt(encoding, options);
1739     if (ret == NULL) return(NULL);
1740     ret->buf = xmlOutputBufferCreateFilename(filename, ret->handler,
1741                                              compression);
1742     if (ret->buf == NULL) {
1743         xmlFreeSaveCtxt(ret);
1744         return(NULL);
1745     }
1746     return(ret);
1747 }
1748
1749 /**
1750  * xmlSaveToBuffer:
1751  * @buffer:  a buffer
1752  * @encoding:  the encoding name to use or NULL
1753  * @options:  a set of xmlSaveOptions
1754  *
1755  * Create a document saving context serializing to a buffer
1756  * with the encoding and the options given
1757  *
1758  * Returns a new serialization context or NULL in case of error.
1759  */
1760
1761 xmlSaveCtxtPtr
1762 xmlSaveToBuffer(xmlBufferPtr buffer, const char *encoding, int options)
1763 {
1764     xmlSaveCtxtPtr ret;
1765     xmlOutputBufferPtr out_buff;
1766     xmlCharEncodingHandlerPtr handler;
1767
1768     ret = xmlNewSaveCtxt(encoding, options);
1769     if (ret == NULL) return(NULL);
1770
1771     if (encoding != NULL) {
1772         handler = xmlFindCharEncodingHandler(encoding);
1773         if (handler == NULL) {
1774             xmlFree(ret);
1775             return(NULL);
1776         }
1777     } else
1778         handler = NULL;
1779     out_buff = xmlOutputBufferCreateBuffer(buffer, handler);
1780     if (out_buff == NULL) {
1781         xmlFree(ret);
1782         if (handler) xmlCharEncCloseFunc(handler);
1783         return(NULL);
1784     }
1785
1786     ret->buf = out_buff;
1787     return(ret);
1788 }
1789
1790 /**
1791  * xmlSaveToIO:
1792  * @iowrite:  an I/O write function
1793  * @ioclose:  an I/O close function
1794  * @ioctx:  an I/O handler
1795  * @encoding:  the encoding name to use or NULL
1796  * @options:  a set of xmlSaveOptions
1797  *
1798  * Create a document saving context serializing to a file descriptor
1799  * with the encoding and the options given
1800  *
1801  * Returns a new serialization context or NULL in case of error.
1802  */
1803 xmlSaveCtxtPtr
1804 xmlSaveToIO(xmlOutputWriteCallback iowrite,
1805             xmlOutputCloseCallback ioclose,
1806             void *ioctx, const char *encoding, int options)
1807 {
1808     xmlSaveCtxtPtr ret;
1809
1810     ret = xmlNewSaveCtxt(encoding, options);
1811     if (ret == NULL) return(NULL);
1812     ret->buf = xmlOutputBufferCreateIO(iowrite, ioclose, ioctx, ret->handler);
1813     if (ret->buf == NULL) {
1814         xmlFreeSaveCtxt(ret);
1815         return(NULL);
1816     }
1817     return(ret);
1818 }
1819
1820 /**
1821  * xmlSaveDoc:
1822  * @ctxt:  a document saving context
1823  * @doc:  a document
1824  *
1825  * Save a full document to a saving context
1826  * TODO: The function is not fully implemented yet as it does not return the
1827  * byte count but 0 instead
1828  *
1829  * Returns the number of byte written or -1 in case of error
1830  */
1831 long
1832 xmlSaveDoc(xmlSaveCtxtPtr ctxt, xmlDocPtr doc)
1833 {
1834     long ret = 0;
1835
1836     if ((ctxt == NULL) || (doc == NULL)) return(-1);
1837     if (xmlDocContentDumpOutput(ctxt, doc) < 0)
1838         return(-1);
1839     return(ret);
1840 }
1841
1842 /**
1843  * xmlSaveTree:
1844  * @ctxt:  a document saving context
1845  * @node:  the top node of the subtree to save
1846  *
1847  * Save a subtree starting at the node parameter to a saving context
1848  * TODO: The function is not fully implemented yet as it does not return the
1849  * byte count but 0 instead
1850  *
1851  * Returns the number of byte written or -1 in case of error
1852  */
1853 long
1854 xmlSaveTree(xmlSaveCtxtPtr ctxt, xmlNodePtr node)
1855 {
1856     long ret = 0;
1857
1858     if ((ctxt == NULL) || (node == NULL)) return(-1);
1859     xmlNodeDumpOutputInternal(ctxt, node);
1860     return(ret);
1861 }
1862
1863 /**
1864  * xmlSaveFlush:
1865  * @ctxt:  a document saving context
1866  *
1867  * Flush a document saving context, i.e. make sure that all bytes have
1868  * been output.
1869  *
1870  * Returns the number of byte written or -1 in case of error.
1871  */
1872 int
1873 xmlSaveFlush(xmlSaveCtxtPtr ctxt)
1874 {
1875     if (ctxt == NULL) return(-1);
1876     if (ctxt->buf == NULL) return(-1);
1877     return(xmlOutputBufferFlush(ctxt->buf));
1878 }
1879
1880 /**
1881  * xmlSaveClose:
1882  * @ctxt:  a document saving context
1883  *
1884  * Close a document saving context, i.e. make sure that all bytes have
1885  * been output and free the associated data.
1886  *
1887  * Returns the number of byte written or -1 in case of error.
1888  */
1889 int
1890 xmlSaveClose(xmlSaveCtxtPtr ctxt)
1891 {
1892     int ret;
1893
1894     if (ctxt == NULL) return(-1);
1895     ret = xmlSaveFlush(ctxt);
1896     xmlFreeSaveCtxt(ctxt);
1897     return(ret);
1898 }
1899
1900 /**
1901  * xmlSaveSetEscape:
1902  * @ctxt:  a document saving context
1903  * @escape:  the escaping function
1904  *
1905  * Set a custom escaping function to be used for text in element content
1906  *
1907  * Returns 0 if successful or -1 in case of error.
1908  */
1909 int
1910 xmlSaveSetEscape(xmlSaveCtxtPtr ctxt, xmlCharEncodingOutputFunc escape)
1911 {
1912     if (ctxt == NULL) return(-1);
1913     ctxt->escape = escape;
1914     return(0);
1915 }
1916
1917 /**
1918  * xmlSaveSetAttrEscape:
1919  * @ctxt:  a document saving context
1920  * @escape:  the escaping function
1921  *
1922  * Set a custom escaping function to be used for text in attribute content
1923  *
1924  * Returns 0 if successful or -1 in case of error.
1925  */
1926 int
1927 xmlSaveSetAttrEscape(xmlSaveCtxtPtr ctxt, xmlCharEncodingOutputFunc escape)
1928 {
1929     if (ctxt == NULL) return(-1);
1930     ctxt->escapeAttr = escape;
1931     return(0);
1932 }
1933
1934 /************************************************************************
1935  *                                                                      *
1936  *              Public entry points based on buffers                    *
1937  *                                                                      *
1938  ************************************************************************/
1939 /**
1940  * xmlAttrSerializeTxtContent:
1941  * @buf:  the XML buffer output
1942  * @doc:  the document
1943  * @attr: the attribute node
1944  * @string: the text content
1945  *
1946  * Serialize text attribute values to an xml simple buffer
1947  */
1948 void
1949 xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr doc,
1950                            xmlAttrPtr attr, const xmlChar * string)
1951 {
1952     xmlChar *base, *cur;
1953
1954     if (string == NULL)
1955         return;
1956     base = cur = (xmlChar *) string;
1957     while (*cur != 0) {
1958         if (*cur == '\n') {
1959             if (base != cur)
1960                 xmlBufferAdd(buf, base, cur - base);
1961             xmlBufferAdd(buf, BAD_CAST "&#10;", 5);
1962             cur++;
1963             base = cur;
1964         } else if (*cur == '\r') {
1965             if (base != cur)
1966                 xmlBufferAdd(buf, base, cur - base);
1967             xmlBufferAdd(buf, BAD_CAST "&#13;", 5);
1968             cur++;
1969             base = cur;
1970         } else if (*cur == '\t') {
1971             if (base != cur)
1972                 xmlBufferAdd(buf, base, cur - base);
1973             xmlBufferAdd(buf, BAD_CAST "&#9;", 4);
1974             cur++;
1975             base = cur;
1976         } else if (*cur == '"') {
1977             if (base != cur)
1978                 xmlBufferAdd(buf, base, cur - base);
1979             xmlBufferAdd(buf, BAD_CAST "&quot;", 6);
1980             cur++;
1981             base = cur;
1982         } else if (*cur == '<') {
1983             if (base != cur)
1984                 xmlBufferAdd(buf, base, cur - base);
1985             xmlBufferAdd(buf, BAD_CAST "&lt;", 4);
1986             cur++;
1987             base = cur;
1988         } else if (*cur == '>') {
1989             if (base != cur)
1990                 xmlBufferAdd(buf, base, cur - base);
1991             xmlBufferAdd(buf, BAD_CAST "&gt;", 4);
1992             cur++;
1993             base = cur;
1994         } else if (*cur == '&') {
1995             if (base != cur)
1996                 xmlBufferAdd(buf, base, cur - base);
1997             xmlBufferAdd(buf, BAD_CAST "&amp;", 5);
1998             cur++;
1999             base = cur;
2000         } else if ((*cur >= 0x80) && ((doc == NULL) ||
2001                                       (doc->encoding == NULL))) {
2002             /*
2003              * We assume we have UTF-8 content.
2004              */
2005             unsigned char tmp[10];
2006             int val = 0, l = 1;
2007
2008             if (base != cur)
2009                 xmlBufferAdd(buf, base, cur - base);
2010             if (*cur < 0xC0) {
2011                 xmlSaveErr(XML_SAVE_NOT_UTF8, (xmlNodePtr) attr, NULL);
2012                 if (doc != NULL)
2013                     doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
2014                 xmlSerializeHexCharRef(tmp, *cur);
2015                 xmlBufferAdd(buf, (xmlChar *) tmp, -1);
2016                 cur++;
2017                 base = cur;
2018                 continue;
2019             } else if (*cur < 0xE0) {
2020                 val = (cur[0]) & 0x1F;
2021                 val <<= 6;
2022                 val |= (cur[1]) & 0x3F;
2023                 l = 2;
2024             } else if (*cur < 0xF0) {
2025                 val = (cur[0]) & 0x0F;
2026                 val <<= 6;
2027                 val |= (cur[1]) & 0x3F;
2028                 val <<= 6;
2029                 val |= (cur[2]) & 0x3F;
2030                 l = 3;
2031             } else if (*cur < 0xF8) {
2032                 val = (cur[0]) & 0x07;
2033                 val <<= 6;
2034                 val |= (cur[1]) & 0x3F;
2035                 val <<= 6;
2036                 val |= (cur[2]) & 0x3F;
2037                 val <<= 6;
2038                 val |= (cur[3]) & 0x3F;
2039                 l = 4;
2040             }
2041             if ((l == 1) || (!IS_CHAR(val))) {
2042                 xmlSaveErr(XML_SAVE_CHAR_INVALID, (xmlNodePtr) attr, NULL);
2043                 if (doc != NULL)
2044                     doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
2045
2046                 xmlSerializeHexCharRef(tmp, *cur);
2047                 xmlBufferAdd(buf, (xmlChar *) tmp, -1);
2048                 cur++;
2049                 base = cur;
2050                 continue;
2051             }
2052             /*
2053              * We could do multiple things here. Just save
2054              * as a char ref
2055              */
2056             xmlSerializeHexCharRef(tmp, val);
2057             xmlBufferAdd(buf, (xmlChar *) tmp, -1);
2058             cur += l;
2059             base = cur;
2060         } else {
2061             cur++;
2062         }
2063     }
2064     if (base != cur)
2065         xmlBufferAdd(buf, base, cur - base);
2066 }
2067
2068 /**
2069  * xmlNodeDump:
2070  * @buf:  the XML buffer output
2071  * @doc:  the document
2072  * @cur:  the current node
2073  * @level: the imbrication level for indenting
2074  * @format: is formatting allowed
2075  *
2076  * Dump an XML node, recursive behaviour,children are printed too.
2077  * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2078  * or xmlKeepBlanksDefault(0) was called
2079  *
2080  * Returns the number of bytes written to the buffer or -1 in case of error
2081  */
2082 int
2083 xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level,
2084             int format)
2085 {
2086     unsigned int use;
2087     int ret;
2088     xmlOutputBufferPtr outbuf;
2089
2090     xmlInitParser();
2091
2092     if (cur == NULL) {
2093 #ifdef DEBUG_TREE
2094         xmlGenericError(xmlGenericErrorContext,
2095                         "xmlNodeDump : node == NULL\n");
2096 #endif
2097         return (-1);
2098     }
2099     if (buf == NULL) {
2100 #ifdef DEBUG_TREE
2101         xmlGenericError(xmlGenericErrorContext,
2102                         "xmlNodeDump : buf == NULL\n");
2103 #endif
2104         return (-1);
2105     }
2106     outbuf = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
2107     if (outbuf == NULL) {
2108         xmlSaveErrMemory("creating buffer");
2109         return (-1);
2110     }
2111     memset(outbuf, 0, (size_t) sizeof(xmlOutputBuffer));
2112     outbuf->buffer = buf;
2113     outbuf->encoder = NULL;
2114     outbuf->writecallback = NULL;
2115     outbuf->closecallback = NULL;
2116     outbuf->context = NULL;
2117     outbuf->written = 0;
2118
2119     use = buf->use;
2120     xmlNodeDumpOutput(outbuf, doc, cur, level, format, NULL);
2121     xmlFree(outbuf);
2122     ret = buf->use - use;
2123     return (ret);
2124 }
2125
2126 /**
2127  * xmlElemDump:
2128  * @f:  the FILE * for the output
2129  * @doc:  the document
2130  * @cur:  the current node
2131  *
2132  * Dump an XML/HTML node, recursive behaviour, children are printed too.
2133  */
2134 void
2135 xmlElemDump(FILE * f, xmlDocPtr doc, xmlNodePtr cur)
2136 {
2137     xmlOutputBufferPtr outbuf;
2138
2139     xmlInitParser();
2140
2141     if (cur == NULL) {
2142 #ifdef DEBUG_TREE
2143         xmlGenericError(xmlGenericErrorContext,
2144                         "xmlElemDump : cur == NULL\n");
2145 #endif
2146         return;
2147     }
2148 #ifdef DEBUG_TREE
2149     if (doc == NULL) {
2150         xmlGenericError(xmlGenericErrorContext,
2151                         "xmlElemDump : doc == NULL\n");
2152     }
2153 #endif
2154
2155     outbuf = xmlOutputBufferCreateFile(f, NULL);
2156     if (outbuf == NULL)
2157         return;
2158     if ((doc != NULL) && (doc->type == XML_HTML_DOCUMENT_NODE)) {
2159 #ifdef LIBXML_HTML_ENABLED
2160         htmlNodeDumpOutput(outbuf, doc, cur, NULL);
2161 #else
2162         xmlSaveErr(XML_ERR_INTERNAL_ERROR, cur, "HTML support not compiled in\n");
2163 #endif /* LIBXML_HTML_ENABLED */
2164     } else
2165         xmlNodeDumpOutput(outbuf, doc, cur, 0, 1, NULL);
2166     xmlOutputBufferClose(outbuf);
2167 }
2168
2169 /************************************************************************
2170  *                                                                      *
2171  *              Saving functions front-ends                             *
2172  *                                                                      *
2173  ************************************************************************/
2174
2175 /**
2176  * xmlNodeDumpOutput:
2177  * @buf:  the XML buffer output
2178  * @doc:  the document
2179  * @cur:  the current node
2180  * @level: the imbrication level for indenting
2181  * @format: is formatting allowed
2182  * @encoding:  an optional encoding string
2183  *
2184  * Dump an XML node, recursive behaviour, children are printed too.
2185  * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2186  * or xmlKeepBlanksDefault(0) was called
2187  */
2188 void
2189 xmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
2190                   int level, int format, const char *encoding)
2191 {
2192     xmlSaveCtxt ctxt;
2193 #ifdef LIBXML_HTML_ENABLED
2194     xmlDtdPtr dtd;
2195     int is_xhtml = 0;
2196 #endif
2197
2198     xmlInitParser();
2199
2200     if ((buf == NULL) || (cur == NULL)) return;
2201
2202     if (encoding == NULL)
2203         encoding = "UTF-8";
2204
2205     memset(&ctxt, 0, sizeof(ctxt));
2206     ctxt.doc = doc;
2207     ctxt.buf = buf;
2208     ctxt.level = level;
2209     ctxt.format = format ? 1 : 0;
2210     ctxt.encoding = (const xmlChar *) encoding;
2211     xmlSaveCtxtInit(&ctxt);
2212     ctxt.options |= XML_SAVE_AS_XML;
2213
2214 #ifdef LIBXML_HTML_ENABLED
2215     dtd = xmlGetIntSubset(doc);
2216     if (dtd != NULL) {
2217         is_xhtml = xmlIsXHTML(dtd->SystemID, dtd->ExternalID);
2218         if (is_xhtml < 0)
2219             is_xhtml = 0;
2220     }
2221
2222     if (is_xhtml)
2223         xhtmlNodeDumpOutput(&ctxt, cur);
2224     else
2225 #endif
2226         xmlNodeDumpOutputInternal(&ctxt, cur);
2227 }
2228
2229 /**
2230  * xmlDocDumpFormatMemoryEnc:
2231  * @out_doc:  Document to generate XML text from
2232  * @doc_txt_ptr:  Memory pointer for allocated XML text
2233  * @doc_txt_len:  Length of the generated XML text
2234  * @txt_encoding:  Character encoding to use when generating XML text
2235  * @format:  should formatting spaces been added
2236  *
2237  * Dump the current DOM tree into memory using the character encoding specified
2238  * by the caller.  Note it is up to the caller of this function to free the
2239  * allocated memory with xmlFree().
2240  * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2241  * or xmlKeepBlanksDefault(0) was called
2242  */
2243
2244 void
2245 xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc, xmlChar **doc_txt_ptr,
2246                 int * doc_txt_len, const char * txt_encoding,
2247                 int format) {
2248     xmlSaveCtxt ctxt;
2249     int                         dummy = 0;
2250     xmlOutputBufferPtr          out_buff = NULL;
2251     xmlCharEncodingHandlerPtr   conv_hdlr = NULL;
2252
2253     if (doc_txt_len == NULL) {
2254         doc_txt_len = &dummy;   /*  Continue, caller just won't get length */
2255     }
2256
2257     if (doc_txt_ptr == NULL) {
2258         *doc_txt_len = 0;
2259         return;
2260     }
2261
2262     *doc_txt_ptr = NULL;
2263     *doc_txt_len = 0;
2264
2265     if (out_doc == NULL) {
2266         /*  No document, no output  */
2267         return;
2268     }
2269
2270     /*
2271      *  Validate the encoding value, if provided.
2272      *  This logic is copied from xmlSaveFileEnc.
2273      */
2274
2275     if (txt_encoding == NULL)
2276         txt_encoding = (const char *) out_doc->encoding;
2277     if (txt_encoding != NULL) {
2278         conv_hdlr = xmlFindCharEncodingHandler(txt_encoding);
2279         if ( conv_hdlr == NULL ) {
2280             xmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, (xmlNodePtr) out_doc,
2281                        txt_encoding);
2282             return;
2283         }
2284     }
2285
2286     if ((out_buff = xmlAllocOutputBuffer(conv_hdlr)) == NULL ) {
2287         xmlSaveErrMemory("creating buffer");
2288         return;
2289     }
2290
2291     memset(&ctxt, 0, sizeof(ctxt));
2292     ctxt.doc = out_doc;
2293     ctxt.buf = out_buff;
2294     ctxt.level = 0;
2295     ctxt.format = format ? 1 : 0;
2296     ctxt.encoding = (const xmlChar *) txt_encoding;
2297     xmlSaveCtxtInit(&ctxt);
2298     ctxt.options |= XML_SAVE_AS_XML;
2299     xmlDocContentDumpOutput(&ctxt, out_doc);
2300     xmlOutputBufferFlush(out_buff);
2301     if (out_buff->conv != NULL) {
2302         *doc_txt_len = out_buff->conv->use;
2303         *doc_txt_ptr = xmlStrndup(out_buff->conv->content, *doc_txt_len);
2304     } else {
2305         *doc_txt_len = out_buff->buffer->use;
2306         *doc_txt_ptr = xmlStrndup(out_buff->buffer->content, *doc_txt_len);
2307     }
2308     (void)xmlOutputBufferClose(out_buff);
2309
2310     if ((*doc_txt_ptr == NULL) && (*doc_txt_len > 0)) {
2311         *doc_txt_len = 0;
2312         xmlSaveErrMemory("creating output");
2313     }
2314
2315     return;
2316 }
2317
2318 /**
2319  * xmlDocDumpMemory:
2320  * @cur:  the document
2321  * @mem:  OUT: the memory pointer
2322  * @size:  OUT: the memory length
2323  *
2324  * Dump an XML document in memory and return the #xmlChar * and it's size
2325  * in bytes. It's up to the caller to free the memory with xmlFree().
2326  * The resulting byte array is zero terminated, though the last 0 is not
2327  * included in the returned size.
2328  */
2329 void
2330 xmlDocDumpMemory(xmlDocPtr cur, xmlChar**mem, int *size) {
2331     xmlDocDumpFormatMemoryEnc(cur, mem, size, NULL, 0);
2332 }
2333
2334 /**
2335  * xmlDocDumpFormatMemory:
2336  * @cur:  the document
2337  * @mem:  OUT: the memory pointer
2338  * @size:  OUT: the memory length
2339  * @format:  should formatting spaces been added
2340  *
2341  *
2342  * Dump an XML document in memory and return the #xmlChar * and it's size.
2343  * It's up to the caller to free the memory with xmlFree().
2344  * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2345  * or xmlKeepBlanksDefault(0) was called
2346  */
2347 void
2348 xmlDocDumpFormatMemory(xmlDocPtr cur, xmlChar**mem, int *size, int format) {
2349     xmlDocDumpFormatMemoryEnc(cur, mem, size, NULL, format);
2350 }
2351
2352 /**
2353  * xmlDocDumpMemoryEnc:
2354  * @out_doc:  Document to generate XML text from
2355  * @doc_txt_ptr:  Memory pointer for allocated XML text
2356  * @doc_txt_len:  Length of the generated XML text
2357  * @txt_encoding:  Character encoding to use when generating XML text
2358  *
2359  * Dump the current DOM tree into memory using the character encoding specified
2360  * by the caller.  Note it is up to the caller of this function to free the
2361  * allocated memory with xmlFree().
2362  */
2363
2364 void
2365 xmlDocDumpMemoryEnc(xmlDocPtr out_doc, xmlChar **doc_txt_ptr,
2366                     int * doc_txt_len, const char * txt_encoding) {
2367     xmlDocDumpFormatMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len,
2368                               txt_encoding, 0);
2369 }
2370
2371 /**
2372  * xmlDocFormatDump:
2373  * @f:  the FILE*
2374  * @cur:  the document
2375  * @format: should formatting spaces been added
2376  *
2377  * Dump an XML document to an open FILE.
2378  *
2379  * returns: the number of bytes written or -1 in case of failure.
2380  * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2381  * or xmlKeepBlanksDefault(0) was called
2382  */
2383 int
2384 xmlDocFormatDump(FILE *f, xmlDocPtr cur, int format) {
2385     xmlSaveCtxt ctxt;
2386     xmlOutputBufferPtr buf;
2387     const char * encoding;
2388     xmlCharEncodingHandlerPtr handler = NULL;
2389     int ret;
2390
2391     if (cur == NULL) {
2392 #ifdef DEBUG_TREE
2393         xmlGenericError(xmlGenericErrorContext,
2394                 "xmlDocDump : document == NULL\n");
2395 #endif
2396         return(-1);
2397     }
2398     encoding = (const char *) cur->encoding;
2399
2400     if (encoding != NULL) {
2401         handler = xmlFindCharEncodingHandler(encoding);
2402         if (handler == NULL) {
2403             xmlFree((char *) cur->encoding);
2404             cur->encoding = NULL;
2405             encoding = NULL;
2406         }
2407     }
2408     buf = xmlOutputBufferCreateFile(f, handler);
2409     if (buf == NULL) return(-1);
2410     memset(&ctxt, 0, sizeof(ctxt));
2411     ctxt.doc = cur;
2412     ctxt.buf = buf;
2413     ctxt.level = 0;
2414     ctxt.format = format ? 1 : 0;
2415     ctxt.encoding = (const xmlChar *) encoding;
2416     xmlSaveCtxtInit(&ctxt);
2417     ctxt.options |= XML_SAVE_AS_XML;
2418     xmlDocContentDumpOutput(&ctxt, cur);
2419
2420     ret = xmlOutputBufferClose(buf);
2421     return(ret);
2422 }
2423
2424 /**
2425  * xmlDocDump:
2426  * @f:  the FILE*
2427  * @cur:  the document
2428  *
2429  * Dump an XML document to an open FILE.
2430  *
2431  * returns: the number of bytes written or -1 in case of failure.
2432  */
2433 int
2434 xmlDocDump(FILE *f, xmlDocPtr cur) {
2435     return(xmlDocFormatDump (f, cur, 0));
2436 }
2437
2438 /**
2439  * xmlSaveFileTo:
2440  * @buf:  an output I/O buffer
2441  * @cur:  the document
2442  * @encoding:  the encoding if any assuming the I/O layer handles the trancoding
2443  *
2444  * Dump an XML document to an I/O buffer.
2445  * Warning ! This call xmlOutputBufferClose() on buf which is not available
2446  * after this call.
2447  *
2448  * returns: the number of bytes written or -1 in case of failure.
2449  */
2450 int
2451 xmlSaveFileTo(xmlOutputBufferPtr buf, xmlDocPtr cur, const char *encoding) {
2452     xmlSaveCtxt ctxt;
2453     int ret;
2454
2455     if (buf == NULL) return(-1);
2456     if (cur == NULL) {
2457         xmlOutputBufferClose(buf);
2458         return(-1);
2459     }
2460     memset(&ctxt, 0, sizeof(ctxt));
2461     ctxt.doc = cur;
2462     ctxt.buf = buf;
2463     ctxt.level = 0;
2464     ctxt.format = 0;
2465     ctxt.encoding = (const xmlChar *) encoding;
2466     xmlSaveCtxtInit(&ctxt);
2467     ctxt.options |= XML_SAVE_AS_XML;
2468     xmlDocContentDumpOutput(&ctxt, cur);
2469     ret = xmlOutputBufferClose(buf);
2470     return(ret);
2471 }
2472
2473 /**
2474  * xmlSaveFormatFileTo:
2475  * @buf:  an output I/O buffer
2476  * @cur:  the document
2477  * @encoding:  the encoding if any assuming the I/O layer handles the trancoding
2478  * @format: should formatting spaces been added
2479  *
2480  * Dump an XML document to an I/O buffer.
2481  * Warning ! This call xmlOutputBufferClose() on buf which is not available
2482  * after this call.
2483  *
2484  * returns: the number of bytes written or -1 in case of failure.
2485  */
2486 int
2487 xmlSaveFormatFileTo(xmlOutputBufferPtr buf, xmlDocPtr cur,
2488                     const char *encoding, int format)
2489 {
2490     xmlSaveCtxt ctxt;
2491     int ret;
2492
2493     if (buf == NULL) return(-1);
2494     if ((cur == NULL) ||
2495         ((cur->type != XML_DOCUMENT_NODE) &&
2496          (cur->type != XML_HTML_DOCUMENT_NODE))) {
2497         xmlOutputBufferClose(buf);
2498         return(-1);
2499     }
2500     memset(&ctxt, 0, sizeof(ctxt));
2501     ctxt.doc = cur;
2502     ctxt.buf = buf;
2503     ctxt.level = 0;
2504     ctxt.format = format ? 1 : 0;
2505     ctxt.encoding = (const xmlChar *) encoding;
2506     xmlSaveCtxtInit(&ctxt);
2507     ctxt.options |= XML_SAVE_AS_XML;
2508     xmlDocContentDumpOutput(&ctxt, cur);
2509     ret = xmlOutputBufferClose(buf);
2510     return (ret);
2511 }
2512
2513 /**
2514  * xmlSaveFormatFileEnc:
2515  * @filename:  the filename or URL to output
2516  * @cur:  the document being saved
2517  * @encoding:  the name of the encoding to use or NULL.
2518  * @format:  should formatting spaces be added.
2519  *
2520  * Dump an XML document to a file or an URL.
2521  *
2522  * Returns the number of bytes written or -1 in case of error.
2523  * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2524  * or xmlKeepBlanksDefault(0) was called
2525  */
2526 int
2527 xmlSaveFormatFileEnc( const char * filename, xmlDocPtr cur,
2528                         const char * encoding, int format ) {
2529     xmlSaveCtxt ctxt;
2530     xmlOutputBufferPtr buf;
2531     xmlCharEncodingHandlerPtr handler = NULL;
2532     int ret;
2533
2534     if (cur == NULL)
2535         return(-1);
2536
2537     if (encoding == NULL)
2538         encoding = (const char *) cur->encoding;
2539
2540     if (encoding != NULL) {
2541
2542             handler = xmlFindCharEncodingHandler(encoding);
2543             if (handler == NULL)
2544                 return(-1);
2545     }
2546
2547 #ifdef HAVE_ZLIB_H
2548     if (cur->compression < 0) cur->compression = xmlGetCompressMode();
2549 #endif
2550     /*
2551      * save the content to a temp buffer.
2552      */
2553     buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression);
2554     if (buf == NULL) return(-1);
2555     memset(&ctxt, 0, sizeof(ctxt));
2556     ctxt.doc = cur;
2557     ctxt.buf = buf;
2558     ctxt.level = 0;
2559     ctxt.format = format ? 1 : 0;
2560     ctxt.encoding = (const xmlChar *) encoding;
2561     xmlSaveCtxtInit(&ctxt);
2562     ctxt.options |= XML_SAVE_AS_XML;
2563
2564     xmlDocContentDumpOutput(&ctxt, cur);
2565
2566     ret = xmlOutputBufferClose(buf);
2567     return(ret);
2568 }
2569
2570
2571 /**
2572  * xmlSaveFileEnc:
2573  * @filename:  the filename (or URL)
2574  * @cur:  the document
2575  * @encoding:  the name of an encoding (or NULL)
2576  *
2577  * Dump an XML document, converting it to the given encoding
2578  *
2579  * returns: the number of bytes written or -1 in case of failure.
2580  */
2581 int
2582 xmlSaveFileEnc(const char *filename, xmlDocPtr cur, const char *encoding) {
2583     return ( xmlSaveFormatFileEnc( filename, cur, encoding, 0 ) );
2584 }
2585
2586 /**
2587  * xmlSaveFormatFile:
2588  * @filename:  the filename (or URL)
2589  * @cur:  the document
2590  * @format:  should formatting spaces been added
2591  *
2592  * Dump an XML document to a file. Will use compression if
2593  * compiled in and enabled. If @filename is "-" the stdout file is
2594  * used. If @format is set then the document will be indented on output.
2595  * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2596  * or xmlKeepBlanksDefault(0) was called
2597  *
2598  * returns: the number of bytes written or -1 in case of failure.
2599  */
2600 int
2601 xmlSaveFormatFile(const char *filename, xmlDocPtr cur, int format) {
2602     return ( xmlSaveFormatFileEnc( filename, cur, NULL, format ) );
2603 }
2604
2605 /**
2606  * xmlSaveFile:
2607  * @filename:  the filename (or URL)
2608  * @cur:  the document
2609  *
2610  * Dump an XML document to a file. Will use compression if
2611  * compiled in and enabled. If @filename is "-" the stdout file is
2612  * used.
2613  * returns: the number of bytes written or -1 in case of failure.
2614  */
2615 int
2616 xmlSaveFile(const char *filename, xmlDocPtr cur) {
2617     return(xmlSaveFormatFileEnc(filename, cur, NULL, 0));
2618 }
2619
2620 #endif /* LIBXML_OUTPUT_ENABLED */
2621
2622 #define bottom_xmlsave
2623 #include "elfgcchack.h"