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