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