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