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 */ 54int 55xmlIsXHTML(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 78struct _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 */ 108static void 109xmlSaveErrMemory(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 */ 122static void 123xmlSaveErr(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 ************************************************************************/ 151static unsigned char * 152xmlSerializeHexCharRef(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 */ 207static int 208xmlEscapeEntities(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); 313error: 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 */ 330static void 331xmlSaveCtxtInit(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 */ 361static void 362xmlFreeSaveCtxt(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 */ 379static xmlSaveCtxtPtr 380xmlNewSaveCtxt(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 */ 434static void 435xmlAttrSerializeContent(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 */ 467void 468xmlBufDumpNotationTable(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 */ 490void 491xmlBufDumpElementDecl(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 */ 513void 514xmlBufDumpAttributeDecl(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 */ 535void 536xmlBufDumpEntityDecl(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 556static 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 580static 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 591static void 592xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur); 593#endif 594static void xmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur); 595static void xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNodePtr cur); 596void xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur); 597static 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 */ 606static void 607xmlOutputBufferWriteWSNonSig(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 */ 631static void 632xmlNsDumpOutput(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 */ 662static void 663xmlNsDumpOutputCtxt(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 */ 675static void 676xmlNsListDumpOutputCtxt(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 */ 691void 692xmlNsListDumpOutput(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 */ 706static void 707xmlDtdDumpOutput(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 */ 763static void 764xmlAttrDumpOutput(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 */ 793static void 794xmlAttrListDumpOutput(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 */ 810static void 811xmlNodeListDumpOutput(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 */ 840static int 841htmlNodeDumpOutputInternal(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 */ 899static void 900xmlNodeDumpOutputInternal(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 */ 1101static int 1102xmlDocContentDumpOutput(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 */ 1268static int 1269xhtmlIsEmpty(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 */ 1333static void 1334xhtmlAttrListDumpOutput(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 */ 1419static void 1420xhtmlNodeListDumpOutput(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 */ 1451static void 1452xhtmlNodeDumpOutput(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 */ 1804xmlSaveCtxtPtr 1805xmlSaveToFd(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 */ 1831xmlSaveCtxtPtr 1832xmlSaveToFilename(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 1860xmlSaveCtxtPtr 1861xmlSaveToBuffer(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 */ 1902xmlSaveCtxtPtr 1903xmlSaveToIO(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 */ 1930long 1931xmlSaveDoc(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 */ 1952long 1953xmlSaveTree(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 */ 1971int 1972xmlSaveFlush(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 */ 1988int 1989xmlSaveClose(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 */ 2008int 2009xmlSaveSetEscape(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 */ 2025int 2026xmlSaveSetAttrEscape(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 */ 2048void 2049xmlBufAttrSerializeTxtContent(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 " ", 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 " ", 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 "	", 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 """, 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 "<", 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 ">", 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 "&", 5); 2098 cur++; 2099 base = cur; 2100 } else if ((*cur >= 0x80) && ((doc == NULL) || 2101 (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 if (doc != NULL) 2113 doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1"); 2114 xmlSerializeHexCharRef(tmp, *cur); 2115 xmlBufAdd(buf, (xmlChar *) tmp, -1); 2116 cur++; 2117 base = cur; 2118 continue; 2119 } else if (*cur < 0xE0) { 2120 val = (cur[0]) & 0x1F; 2121 val <<= 6; 2122 val |= (cur[1]) & 0x3F; 2123 l = 2; 2124 } else if (*cur < 0xF0) { 2125 val = (cur[0]) & 0x0F; 2126 val <<= 6; 2127 val |= (cur[1]) & 0x3F; 2128 val <<= 6; 2129 val |= (cur[2]) & 0x3F; 2130 l = 3; 2131 } else if (*cur < 0xF8) { 2132 val = (cur[0]) & 0x07; 2133 val <<= 6; 2134 val |= (cur[1]) & 0x3F; 2135 val <<= 6; 2136 val |= (cur[2]) & 0x3F; 2137 val <<= 6; 2138 val |= (cur[3]) & 0x3F; 2139 l = 4; 2140 } 2141 if ((l == 1) || (!IS_CHAR(val))) { 2142 xmlSaveErr(XML_SAVE_CHAR_INVALID, (xmlNodePtr) attr, NULL); 2143 if (doc != NULL) 2144 doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1"); 2145 2146 xmlSerializeHexCharRef(tmp, *cur); 2147 xmlBufAdd(buf, (xmlChar *) tmp, -1); 2148 cur++; 2149 base = cur; 2150 continue; 2151 } 2152 /* 2153 * We could do multiple things here. Just save 2154 * as a char ref 2155 */ 2156 xmlSerializeHexCharRef(tmp, val); 2157 xmlBufAdd(buf, (xmlChar *) tmp, -1); 2158 cur += l; 2159 base = cur; 2160 } else { 2161 cur++; 2162 } 2163 } 2164 if (base != cur) 2165 xmlBufAdd(buf, base, cur - base); 2166} 2167 2168/** 2169 * xmlAttrSerializeTxtContent: 2170 * @buf: the XML buffer output 2171 * @doc: the document 2172 * @attr: the attribute node 2173 * @string: the text content 2174 * 2175 * Serialize text attribute values to an xml simple buffer 2176 */ 2177void 2178xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr doc, 2179 xmlAttrPtr attr, const xmlChar * string) 2180{ 2181 xmlBufPtr buffer; 2182 2183 if ((buf == NULL) || (string == NULL)) 2184 return; 2185 buffer = xmlBufFromBuffer(buf); 2186 if (buffer == NULL) 2187 return; 2188 xmlBufAttrSerializeTxtContent(buffer, doc, attr, string); 2189 xmlBufBackToBuffer(buffer); 2190} 2191 2192/** 2193 * xmlNodeDump: 2194 * @buf: the XML buffer output 2195 * @doc: the document 2196 * @cur: the current node 2197 * @level: the imbrication level for indenting 2198 * @format: is formatting allowed 2199 * 2200 * Dump an XML node, recursive behaviour,children are printed too. 2201 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 2202 * or xmlKeepBlanksDefault(0) was called 2203 * Since this is using xmlBuffer structures it is limited to 2GB and somehow 2204 * deprecated, use xmlBufNodeDump() instead. 2205 * 2206 * Returns the number of bytes written to the buffer or -1 in case of error 2207 */ 2208int 2209xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level, 2210 int format) 2211{ 2212 xmlBufPtr buffer; 2213 int ret; 2214 2215 if ((buf == NULL) || (cur == NULL)) 2216 return(-1); 2217 buffer = xmlBufFromBuffer(buf); 2218 if (buffer == NULL) 2219 return(-1); 2220 ret = xmlBufNodeDump(buffer, doc, cur, level, format); 2221 xmlBufBackToBuffer(buffer); 2222 if (ret > INT_MAX) 2223 return(-1); 2224 return((int) ret); 2225} 2226 2227/** 2228 * xmlBufNodeDump: 2229 * @buf: the XML buffer output 2230 * @doc: the document 2231 * @cur: the current node 2232 * @level: the imbrication level for indenting 2233 * @format: is formatting allowed 2234 * 2235 * Dump an XML node, recursive behaviour,children are printed too. 2236 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 2237 * or xmlKeepBlanksDefault(0) was called 2238 * 2239 * Returns the number of bytes written to the buffer, in case of error 0 2240 * is returned or @buf stores the error 2241 */ 2242 2243size_t 2244xmlBufNodeDump(xmlBufPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level, 2245 int format) 2246{ 2247 size_t use; 2248 int ret; 2249 xmlOutputBufferPtr outbuf; 2250 int oldalloc; 2251 2252 xmlInitParser(); 2253 2254 if (cur == NULL) { 2255#ifdef DEBUG_TREE 2256 xmlGenericError(xmlGenericErrorContext, 2257 "xmlNodeDump : node == NULL\n"); 2258#endif 2259 return (-1); 2260 } 2261 if (buf == NULL) { 2262#ifdef DEBUG_TREE 2263 xmlGenericError(xmlGenericErrorContext, 2264 "xmlNodeDump : buf == NULL\n"); 2265#endif 2266 return (-1); 2267 } 2268 outbuf = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer)); 2269 if (outbuf == NULL) { 2270 xmlSaveErrMemory("creating buffer"); 2271 return (-1); 2272 } 2273 memset(outbuf, 0, (size_t) sizeof(xmlOutputBuffer)); 2274 outbuf->buffer = buf; 2275 outbuf->encoder = NULL; 2276 outbuf->writecallback = NULL; 2277 outbuf->closecallback = NULL; 2278 outbuf->context = NULL; 2279 outbuf->written = 0; 2280 2281 use = xmlBufUse(buf); 2282 oldalloc = xmlBufGetAllocationScheme(buf); 2283 xmlBufSetAllocationScheme(buf, XML_BUFFER_ALLOC_DOUBLEIT); 2284 xmlNodeDumpOutput(outbuf, doc, cur, level, format, NULL); 2285 xmlBufSetAllocationScheme(buf, oldalloc); 2286 xmlFree(outbuf); 2287 ret = xmlBufUse(buf) - use; 2288 return (ret); 2289} 2290 2291/** 2292 * xmlElemDump: 2293 * @f: the FILE * for the output 2294 * @doc: the document 2295 * @cur: the current node 2296 * 2297 * Dump an XML/HTML node, recursive behaviour, children are printed too. 2298 */ 2299void 2300xmlElemDump(FILE * f, xmlDocPtr doc, xmlNodePtr cur) 2301{ 2302 xmlOutputBufferPtr outbuf; 2303 2304 xmlInitParser(); 2305 2306 if (cur == NULL) { 2307#ifdef DEBUG_TREE 2308 xmlGenericError(xmlGenericErrorContext, 2309 "xmlElemDump : cur == NULL\n"); 2310#endif 2311 return; 2312 } 2313#ifdef DEBUG_TREE 2314 if (doc == NULL) { 2315 xmlGenericError(xmlGenericErrorContext, 2316 "xmlElemDump : doc == NULL\n"); 2317 } 2318#endif 2319 2320 outbuf = xmlOutputBufferCreateFile(f, NULL); 2321 if (outbuf == NULL) 2322 return; 2323 if ((doc != NULL) && (doc->type == XML_HTML_DOCUMENT_NODE)) { 2324#ifdef LIBXML_HTML_ENABLED 2325 htmlNodeDumpOutput(outbuf, doc, cur, NULL); 2326#else 2327 xmlSaveErr(XML_ERR_INTERNAL_ERROR, cur, "HTML support not compiled in\n"); 2328#endif /* LIBXML_HTML_ENABLED */ 2329 } else 2330 xmlNodeDumpOutput(outbuf, doc, cur, 0, 1, NULL); 2331 xmlOutputBufferClose(outbuf); 2332} 2333 2334/************************************************************************ 2335 * * 2336 * Saving functions front-ends * 2337 * * 2338 ************************************************************************/ 2339 2340/** 2341 * xmlNodeDumpOutput: 2342 * @buf: the XML buffer output 2343 * @doc: the document 2344 * @cur: the current node 2345 * @level: the imbrication level for indenting 2346 * @format: is formatting allowed 2347 * @encoding: an optional encoding string 2348 * 2349 * Dump an XML node, recursive behaviour, children are printed too. 2350 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 2351 * or xmlKeepBlanksDefault(0) was called 2352 */ 2353void 2354xmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, 2355 int level, int format, const char *encoding) 2356{ 2357 xmlSaveCtxt ctxt; 2358#ifdef LIBXML_HTML_ENABLED 2359 xmlDtdPtr dtd; 2360 int is_xhtml = 0; 2361#endif 2362 2363 xmlInitParser(); 2364 2365 if ((buf == NULL) || (cur == NULL)) return; 2366 2367 if (encoding == NULL) 2368 encoding = "UTF-8"; 2369 2370 memset(&ctxt, 0, sizeof(ctxt)); 2371 ctxt.doc = doc; 2372 ctxt.buf = buf; 2373 ctxt.level = level; 2374 ctxt.format = format ? 1 : 0; 2375 ctxt.encoding = (const xmlChar *) encoding; 2376 xmlSaveCtxtInit(&ctxt); 2377 ctxt.options |= XML_SAVE_AS_XML; 2378 2379#ifdef LIBXML_HTML_ENABLED 2380 dtd = xmlGetIntSubset(doc); 2381 if (dtd != NULL) { 2382 is_xhtml = xmlIsXHTML(dtd->SystemID, dtd->ExternalID); 2383 if (is_xhtml < 0) 2384 is_xhtml = 0; 2385 } 2386 2387 if (is_xhtml) 2388 xhtmlNodeDumpOutput(&ctxt, cur); 2389 else 2390#endif 2391 xmlNodeDumpOutputInternal(&ctxt, cur); 2392} 2393 2394/** 2395 * xmlDocDumpFormatMemoryEnc: 2396 * @out_doc: Document to generate XML text from 2397 * @doc_txt_ptr: Memory pointer for allocated XML text 2398 * @doc_txt_len: Length of the generated XML text 2399 * @txt_encoding: Character encoding to use when generating XML text 2400 * @format: should formatting spaces been added 2401 * 2402 * Dump the current DOM tree into memory using the character encoding specified 2403 * by the caller. Note it is up to the caller of this function to free the 2404 * allocated memory with xmlFree(). 2405 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 2406 * or xmlKeepBlanksDefault(0) was called 2407 */ 2408 2409void 2410xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc, xmlChar **doc_txt_ptr, 2411 int * doc_txt_len, const char * txt_encoding, 2412 int format) { 2413 xmlSaveCtxt ctxt; 2414 int dummy = 0; 2415 xmlOutputBufferPtr out_buff = NULL; 2416 xmlCharEncodingHandlerPtr conv_hdlr = NULL; 2417 2418 if (doc_txt_len == NULL) { 2419 doc_txt_len = &dummy; /* Continue, caller just won't get length */ 2420 } 2421 2422 if (doc_txt_ptr == NULL) { 2423 *doc_txt_len = 0; 2424 return; 2425 } 2426 2427 *doc_txt_ptr = NULL; 2428 *doc_txt_len = 0; 2429 2430 if (out_doc == NULL) { 2431 /* No document, no output */ 2432 return; 2433 } 2434 2435 /* 2436 * Validate the encoding value, if provided. 2437 * This logic is copied from xmlSaveFileEnc. 2438 */ 2439 2440 if (txt_encoding == NULL) 2441 txt_encoding = (const char *) out_doc->encoding; 2442 if (txt_encoding != NULL) { 2443 conv_hdlr = xmlFindCharEncodingHandler(txt_encoding); 2444 if ( conv_hdlr == NULL ) { 2445 xmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, (xmlNodePtr) out_doc, 2446 txt_encoding); 2447 return; 2448 } 2449 } 2450 2451 if ((out_buff = xmlAllocOutputBuffer(conv_hdlr)) == NULL ) { 2452 xmlSaveErrMemory("creating buffer"); 2453 return; 2454 } 2455 2456 memset(&ctxt, 0, sizeof(ctxt)); 2457 ctxt.doc = out_doc; 2458 ctxt.buf = out_buff; 2459 ctxt.level = 0; 2460 ctxt.format = format ? 1 : 0; 2461 ctxt.encoding = (const xmlChar *) txt_encoding; 2462 xmlSaveCtxtInit(&ctxt); 2463 ctxt.options |= XML_SAVE_AS_XML; 2464 xmlDocContentDumpOutput(&ctxt, out_doc); 2465 xmlOutputBufferFlush(out_buff); 2466 if (out_buff->conv != NULL) { 2467 *doc_txt_len = xmlBufUse(out_buff->conv); 2468 *doc_txt_ptr = xmlStrndup(xmlBufContent(out_buff->conv), *doc_txt_len); 2469 } else { 2470 *doc_txt_len = xmlBufUse(out_buff->buffer); 2471 *doc_txt_ptr = xmlStrndup(xmlBufContent(out_buff->buffer),*doc_txt_len); 2472 } 2473 (void)xmlOutputBufferClose(out_buff); 2474 2475 if ((*doc_txt_ptr == NULL) && (*doc_txt_len > 0)) { 2476 *doc_txt_len = 0; 2477 xmlSaveErrMemory("creating output"); 2478 } 2479 2480 return; 2481} 2482 2483/** 2484 * xmlDocDumpMemory: 2485 * @cur: the document 2486 * @mem: OUT: the memory pointer 2487 * @size: OUT: the memory length 2488 * 2489 * Dump an XML document in memory and return the #xmlChar * and it's size 2490 * in bytes. It's up to the caller to free the memory with xmlFree(). 2491 * The resulting byte array is zero terminated, though the last 0 is not 2492 * included in the returned size. 2493 */ 2494void 2495xmlDocDumpMemory(xmlDocPtr cur, xmlChar**mem, int *size) { 2496 xmlDocDumpFormatMemoryEnc(cur, mem, size, NULL, 0); 2497} 2498 2499/** 2500 * xmlDocDumpFormatMemory: 2501 * @cur: the document 2502 * @mem: OUT: the memory pointer 2503 * @size: OUT: the memory length 2504 * @format: should formatting spaces been added 2505 * 2506 * 2507 * Dump an XML document in memory and return the #xmlChar * and it's size. 2508 * It's up to the caller to free the memory with xmlFree(). 2509 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 2510 * or xmlKeepBlanksDefault(0) was called 2511 */ 2512void 2513xmlDocDumpFormatMemory(xmlDocPtr cur, xmlChar**mem, int *size, int format) { 2514 xmlDocDumpFormatMemoryEnc(cur, mem, size, NULL, format); 2515} 2516 2517/** 2518 * xmlDocDumpMemoryEnc: 2519 * @out_doc: Document to generate XML text from 2520 * @doc_txt_ptr: Memory pointer for allocated XML text 2521 * @doc_txt_len: Length of the generated XML text 2522 * @txt_encoding: Character encoding to use when generating XML text 2523 * 2524 * Dump the current DOM tree into memory using the character encoding specified 2525 * by the caller. Note it is up to the caller of this function to free the 2526 * allocated memory with xmlFree(). 2527 */ 2528 2529void 2530xmlDocDumpMemoryEnc(xmlDocPtr out_doc, xmlChar **doc_txt_ptr, 2531 int * doc_txt_len, const char * txt_encoding) { 2532 xmlDocDumpFormatMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len, 2533 txt_encoding, 0); 2534} 2535 2536/** 2537 * xmlDocFormatDump: 2538 * @f: the FILE* 2539 * @cur: the document 2540 * @format: should formatting spaces been added 2541 * 2542 * Dump an XML document to an open FILE. 2543 * 2544 * returns: the number of bytes written or -1 in case of failure. 2545 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 2546 * or xmlKeepBlanksDefault(0) was called 2547 */ 2548int 2549xmlDocFormatDump(FILE *f, xmlDocPtr cur, int format) { 2550 xmlSaveCtxt ctxt; 2551 xmlOutputBufferPtr buf; 2552 const char * encoding; 2553 xmlCharEncodingHandlerPtr handler = NULL; 2554 int ret; 2555 2556 if (cur == NULL) { 2557#ifdef DEBUG_TREE 2558 xmlGenericError(xmlGenericErrorContext, 2559 "xmlDocDump : document == NULL\n"); 2560#endif 2561 return(-1); 2562 } 2563 encoding = (const char *) cur->encoding; 2564 2565 if (encoding != NULL) { 2566 handler = xmlFindCharEncodingHandler(encoding); 2567 if (handler == NULL) { 2568 xmlFree((char *) cur->encoding); 2569 cur->encoding = NULL; 2570 encoding = NULL; 2571 } 2572 } 2573 buf = xmlOutputBufferCreateFile(f, handler); 2574 if (buf == NULL) return(-1); 2575 memset(&ctxt, 0, sizeof(ctxt)); 2576 ctxt.doc = cur; 2577 ctxt.buf = buf; 2578 ctxt.level = 0; 2579 ctxt.format = format ? 1 : 0; 2580 ctxt.encoding = (const xmlChar *) encoding; 2581 xmlSaveCtxtInit(&ctxt); 2582 ctxt.options |= XML_SAVE_AS_XML; 2583 xmlDocContentDumpOutput(&ctxt, cur); 2584 2585 ret = xmlOutputBufferClose(buf); 2586 return(ret); 2587} 2588 2589/** 2590 * xmlDocDump: 2591 * @f: the FILE* 2592 * @cur: the document 2593 * 2594 * Dump an XML document to an open FILE. 2595 * 2596 * returns: the number of bytes written or -1 in case of failure. 2597 */ 2598int 2599xmlDocDump(FILE *f, xmlDocPtr cur) { 2600 return(xmlDocFormatDump (f, cur, 0)); 2601} 2602 2603/** 2604 * xmlSaveFileTo: 2605 * @buf: an output I/O buffer 2606 * @cur: the document 2607 * @encoding: the encoding if any assuming the I/O layer handles the trancoding 2608 * 2609 * Dump an XML document to an I/O buffer. 2610 * Warning ! This call xmlOutputBufferClose() on buf which is not available 2611 * after this call. 2612 * 2613 * returns: the number of bytes written or -1 in case of failure. 2614 */ 2615int 2616xmlSaveFileTo(xmlOutputBufferPtr buf, xmlDocPtr cur, const char *encoding) { 2617 xmlSaveCtxt ctxt; 2618 int ret; 2619 2620 if (buf == NULL) return(-1); 2621 if (cur == NULL) { 2622 xmlOutputBufferClose(buf); 2623 return(-1); 2624 } 2625 memset(&ctxt, 0, sizeof(ctxt)); 2626 ctxt.doc = cur; 2627 ctxt.buf = buf; 2628 ctxt.level = 0; 2629 ctxt.format = 0; 2630 ctxt.encoding = (const xmlChar *) encoding; 2631 xmlSaveCtxtInit(&ctxt); 2632 ctxt.options |= XML_SAVE_AS_XML; 2633 xmlDocContentDumpOutput(&ctxt, cur); 2634 ret = xmlOutputBufferClose(buf); 2635 return(ret); 2636} 2637 2638/** 2639 * xmlSaveFormatFileTo: 2640 * @buf: an output I/O buffer 2641 * @cur: the document 2642 * @encoding: the encoding if any assuming the I/O layer handles the trancoding 2643 * @format: should formatting spaces been added 2644 * 2645 * Dump an XML document to an I/O buffer. 2646 * Warning ! This call xmlOutputBufferClose() on buf which is not available 2647 * after this call. 2648 * 2649 * returns: the number of bytes written or -1 in case of failure. 2650 */ 2651int 2652xmlSaveFormatFileTo(xmlOutputBufferPtr buf, xmlDocPtr cur, 2653 const char *encoding, int format) 2654{ 2655 xmlSaveCtxt ctxt; 2656 int ret; 2657 2658 if (buf == NULL) return(-1); 2659 if ((cur == NULL) || 2660 ((cur->type != XML_DOCUMENT_NODE) && 2661 (cur->type != XML_HTML_DOCUMENT_NODE))) { 2662 xmlOutputBufferClose(buf); 2663 return(-1); 2664 } 2665 memset(&ctxt, 0, sizeof(ctxt)); 2666 ctxt.doc = cur; 2667 ctxt.buf = buf; 2668 ctxt.level = 0; 2669 ctxt.format = format ? 1 : 0; 2670 ctxt.encoding = (const xmlChar *) encoding; 2671 xmlSaveCtxtInit(&ctxt); 2672 ctxt.options |= XML_SAVE_AS_XML; 2673 xmlDocContentDumpOutput(&ctxt, cur); 2674 ret = xmlOutputBufferClose(buf); 2675 return (ret); 2676} 2677 2678/** 2679 * xmlSaveFormatFileEnc: 2680 * @filename: the filename or URL to output 2681 * @cur: the document being saved 2682 * @encoding: the name of the encoding to use or NULL. 2683 * @format: should formatting spaces be added. 2684 * 2685 * Dump an XML document to a file or an URL. 2686 * 2687 * Returns the number of bytes written or -1 in case of error. 2688 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 2689 * or xmlKeepBlanksDefault(0) was called 2690 */ 2691int 2692xmlSaveFormatFileEnc( const char * filename, xmlDocPtr cur, 2693 const char * encoding, int format ) { 2694 xmlSaveCtxt ctxt; 2695 xmlOutputBufferPtr buf; 2696 xmlCharEncodingHandlerPtr handler = NULL; 2697 int ret; 2698 2699 if (cur == NULL) 2700 return(-1); 2701 2702 if (encoding == NULL) 2703 encoding = (const char *) cur->encoding; 2704 2705 if (encoding != NULL) { 2706 2707 handler = xmlFindCharEncodingHandler(encoding); 2708 if (handler == NULL) 2709 return(-1); 2710 } 2711 2712#ifdef HAVE_ZLIB_H 2713 if (cur->compression < 0) cur->compression = xmlGetCompressMode(); 2714#endif 2715 /* 2716 * save the content to a temp buffer. 2717 */ 2718 buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression); 2719 if (buf == NULL) return(-1); 2720 memset(&ctxt, 0, sizeof(ctxt)); 2721 ctxt.doc = cur; 2722 ctxt.buf = buf; 2723 ctxt.level = 0; 2724 ctxt.format = format ? 1 : 0; 2725 ctxt.encoding = (const xmlChar *) encoding; 2726 xmlSaveCtxtInit(&ctxt); 2727 ctxt.options |= XML_SAVE_AS_XML; 2728 2729 xmlDocContentDumpOutput(&ctxt, cur); 2730 2731 ret = xmlOutputBufferClose(buf); 2732 return(ret); 2733} 2734 2735 2736/** 2737 * xmlSaveFileEnc: 2738 * @filename: the filename (or URL) 2739 * @cur: the document 2740 * @encoding: the name of an encoding (or NULL) 2741 * 2742 * Dump an XML document, converting it to the given encoding 2743 * 2744 * returns: the number of bytes written or -1 in case of failure. 2745 */ 2746int 2747xmlSaveFileEnc(const char *filename, xmlDocPtr cur, const char *encoding) { 2748 return ( xmlSaveFormatFileEnc( filename, cur, encoding, 0 ) ); 2749} 2750 2751/** 2752 * xmlSaveFormatFile: 2753 * @filename: the filename (or URL) 2754 * @cur: the document 2755 * @format: should formatting spaces been added 2756 * 2757 * Dump an XML document to a file. Will use compression if 2758 * compiled in and enabled. If @filename is "-" the stdout file is 2759 * used. If @format is set then the document will be indented on output. 2760 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 2761 * or xmlKeepBlanksDefault(0) was called 2762 * 2763 * returns: the number of bytes written or -1 in case of failure. 2764 */ 2765int 2766xmlSaveFormatFile(const char *filename, xmlDocPtr cur, int format) { 2767 return ( xmlSaveFormatFileEnc( filename, cur, NULL, format ) ); 2768} 2769 2770/** 2771 * xmlSaveFile: 2772 * @filename: the filename (or URL) 2773 * @cur: the document 2774 * 2775 * Dump an XML document to a file. Will use compression if 2776 * compiled in and enabled. If @filename is "-" the stdout file is 2777 * used. 2778 * returns: the number of bytes written or -1 in case of failure. 2779 */ 2780int 2781xmlSaveFile(const char *filename, xmlDocPtr cur) { 2782 return(xmlSaveFormatFileEnc(filename, cur, NULL, 0)); 2783} 2784 2785#endif /* LIBXML_OUTPUT_ENABLED */ 2786 2787#define bottom_xmlsave 2788#include "elfgcchack.h" 2789