version 1.1, 2012/02/21 23:37:58
|
version 1.1.1.3, 2014/06/15 19:53:29
|
Line 19
|
Line 19
|
|
|
#include <libxml/HTMLtree.h> |
#include <libxml/HTMLtree.h> |
|
|
|
#include "buf.h" |
|
#include "enc.h" |
|
#include "save.h" |
|
|
/************************************************************************ |
/************************************************************************ |
* * |
* * |
* XHTML detection * |
* XHTML detection * |
Line 66 xmlIsXHTML(const xmlChar *systemID, const xmlChar *pub
|
Line 70 xmlIsXHTML(const xmlChar *systemID, const xmlChar *pub
|
|
|
#ifdef LIBXML_OUTPUT_ENABLED |
#ifdef LIBXML_OUTPUT_ENABLED |
|
|
#define TODO \ | #define TODO \ |
xmlGenericError(xmlGenericErrorContext, \ |
xmlGenericError(xmlGenericErrorContext, \ |
"Unimplemented block at %s:%d\n", \ |
"Unimplemented block at %s:%d\n", \ |
__FILE__, __LINE__); |
__FILE__, __LINE__); |
Line 92 struct _xmlSaveCtxt {
|
Line 96 struct _xmlSaveCtxt {
|
|
|
/************************************************************************ |
/************************************************************************ |
* * |
* * |
* Output error handlers * | * Output error handlers * |
* * |
* * |
************************************************************************/ |
************************************************************************/ |
/** |
/** |
Line 210 xmlEscapeEntities(unsigned char* out, int *outlen,
|
Line 214 xmlEscapeEntities(unsigned char* out, int *outlen,
|
int val; |
int val; |
|
|
inend = in + (*inlen); |
inend = in + (*inlen); |
| |
while ((in < inend) && (out < outend)) { |
while ((in < inend) && (out < outend)) { |
if (*in == '<') { | if (*in == '<') { |
if (outend - out < 4) break; |
if (outend - out < 4) break; |
*out++ = '&'; |
*out++ = '&'; |
*out++ = 'l'; |
*out++ = 'l'; |
Line 248 xmlEscapeEntities(unsigned char* out, int *outlen,
|
Line 252 xmlEscapeEntities(unsigned char* out, int *outlen,
|
/* |
/* |
* We assume we have UTF-8 input. |
* We assume we have UTF-8 input. |
*/ |
*/ |
if (outend - out < 10) break; | if (outend - out < 11) break; |
|
|
if (*in < 0xC0) { |
if (*in < 0xC0) { |
xmlSaveErr(XML_SAVE_NOT_UTF8, NULL, NULL); |
xmlSaveErr(XML_SAVE_NOT_UTF8, NULL, NULL); |
Line 416 xmlNewSaveCtxt(const char *encoding, int options)
|
Line 420 xmlNewSaveCtxt(const char *encoding, int options)
|
|
|
/************************************************************************ |
/************************************************************************ |
* * |
* * |
* Dumping XML tree content to a simple buffer * | * Dumping XML tree content to a simple buffer * |
* * |
* * |
************************************************************************/ |
************************************************************************/ |
/** |
/** |
Line 436 xmlAttrSerializeContent(xmlOutputBufferPtr buf, xmlAtt
|
Line 440 xmlAttrSerializeContent(xmlOutputBufferPtr buf, xmlAtt
|
while (children != NULL) { |
while (children != NULL) { |
switch (children->type) { |
switch (children->type) { |
case XML_TEXT_NODE: |
case XML_TEXT_NODE: |
xmlAttrSerializeTxtContent(buf->buffer, attr->doc, | xmlBufAttrSerializeTxtContent(buf->buffer, attr->doc, |
attr, children->content); | attr, children->content); |
break; |
break; |
case XML_ENTITY_REF_NODE: |
case XML_ENTITY_REF_NODE: |
xmlBufferAdd(buf->buffer, BAD_CAST "&", 1); | xmlBufAdd(buf->buffer, BAD_CAST "&", 1); |
xmlBufferAdd(buf->buffer, children->name, | xmlBufAdd(buf->buffer, children->name, |
xmlStrlen(children->name)); |
xmlStrlen(children->name)); |
xmlBufferAdd(buf->buffer, BAD_CAST ";", 1); | xmlBufAdd(buf->buffer, BAD_CAST ";", 1); |
break; |
break; |
default: |
default: |
/* should not happen unless we have a badly built tree */ |
/* should not happen unless we have a badly built tree */ |
Line 453 xmlAttrSerializeContent(xmlOutputBufferPtr buf, xmlAtt
|
Line 457 xmlAttrSerializeContent(xmlOutputBufferPtr buf, xmlAtt
|
} |
} |
} |
} |
|
|
|
/** |
|
* xmlBufDumpNotationTable: |
|
* @buf: an xmlBufPtr output |
|
* @table: A notation table |
|
* |
|
* This will dump the content of the notation table as an XML DTD definition |
|
*/ |
|
void |
|
xmlBufDumpNotationTable(xmlBufPtr buf, xmlNotationTablePtr table) { |
|
xmlBufferPtr buffer; |
|
|
|
buffer = xmlBufferCreate(); |
|
if (buffer == NULL) { |
|
/* |
|
* TODO set the error in buf |
|
*/ |
|
return; |
|
} |
|
xmlDumpNotationTable(buffer, table); |
|
xmlBufMergeBuffer(buf, buffer); |
|
} |
|
|
|
/** |
|
* xmlBufDumpElementDecl: |
|
* @buf: an xmlBufPtr output |
|
* @elem: An element table |
|
* |
|
* This will dump the content of the element declaration as an XML |
|
* DTD definition |
|
*/ |
|
void |
|
xmlBufDumpElementDecl(xmlBufPtr buf, xmlElementPtr elem) { |
|
xmlBufferPtr buffer; |
|
|
|
buffer = xmlBufferCreate(); |
|
if (buffer == NULL) { |
|
/* |
|
* TODO set the error in buf |
|
*/ |
|
return; |
|
} |
|
xmlDumpElementDecl(buffer, elem); |
|
xmlBufMergeBuffer(buf, buffer); |
|
} |
|
|
|
/** |
|
* xmlBufDumpAttributeDecl: |
|
* @buf: an xmlBufPtr output |
|
* @attr: An attribute declaration |
|
* |
|
* This will dump the content of the attribute declaration as an XML |
|
* DTD definition |
|
*/ |
|
void |
|
xmlBufDumpAttributeDecl(xmlBufPtr buf, xmlAttributePtr attr) { |
|
xmlBufferPtr buffer; |
|
|
|
buffer = xmlBufferCreate(); |
|
if (buffer == NULL) { |
|
/* |
|
* TODO set the error in buf |
|
*/ |
|
return; |
|
} |
|
xmlDumpAttributeDecl(buffer, attr); |
|
xmlBufMergeBuffer(buf, buffer); |
|
} |
|
|
|
/** |
|
* xmlBufDumpEntityDecl: |
|
* @buf: an xmlBufPtr output |
|
* @ent: An entity table |
|
* |
|
* This will dump the content of the entity table as an XML DTD definition |
|
*/ |
|
void |
|
xmlBufDumpEntityDecl(xmlBufPtr buf, xmlEntityPtr ent) { |
|
xmlBufferPtr buffer; |
|
|
|
buffer = xmlBufferCreate(); |
|
if (buffer == NULL) { |
|
/* |
|
* TODO set the error in buf |
|
*/ |
|
return; |
|
} |
|
xmlDumpEntityDecl(buffer, ent); |
|
xmlBufMergeBuffer(buf, buffer); |
|
} |
|
|
/************************************************************************ |
/************************************************************************ |
* * |
* * |
* Dumping XML tree content to an I/O output buffer * | * Dumping XML tree content to an I/O output buffer * |
* * |
* * |
************************************************************************/ |
************************************************************************/ |
|
|
Line 469 static int xmlSaveSwitchEncoding(xmlSaveCtxtPtr ctxt,
|
Line 563 static int xmlSaveSwitchEncoding(xmlSaveCtxtPtr ctxt,
|
(const char *)encoding); |
(const char *)encoding); |
return(-1); |
return(-1); |
} |
} |
buf->conv = xmlBufferCreate(); | buf->conv = xmlBufCreate(); |
if (buf->conv == NULL) { |
if (buf->conv == NULL) { |
xmlCharEncCloseFunc(buf->encoder); |
xmlCharEncCloseFunc(buf->encoder); |
xmlSaveErrMemory("creating encoding buffer"); |
xmlSaveErrMemory("creating encoding buffer"); |
Line 478 static int xmlSaveSwitchEncoding(xmlSaveCtxtPtr ctxt,
|
Line 572 static int xmlSaveSwitchEncoding(xmlSaveCtxtPtr ctxt,
|
/* |
/* |
* initialize the state, e.g. if outputting a BOM |
* initialize the state, e.g. if outputting a BOM |
*/ |
*/ |
xmlCharEncOutFunc(buf->encoder, buf->conv, NULL); | xmlCharEncOutput(buf, 1); |
} |
} |
return(0); |
return(0); |
} |
} |
Line 487 static int xmlSaveClearEncoding(xmlSaveCtxtPtr ctxt) {
|
Line 581 static int xmlSaveClearEncoding(xmlSaveCtxtPtr ctxt) {
|
xmlOutputBufferPtr buf = ctxt->buf; |
xmlOutputBufferPtr buf = ctxt->buf; |
xmlOutputBufferFlush(buf); |
xmlOutputBufferFlush(buf); |
xmlCharEncCloseFunc(buf->encoder); |
xmlCharEncCloseFunc(buf->encoder); |
xmlBufferFree(buf->conv); | xmlBufFree(buf->conv); |
buf->encoder = NULL; |
buf->encoder = NULL; |
buf->conv = NULL; |
buf->conv = NULL; |
return(0); |
return(0); |
Line 553 xmlNsDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur,
|
Line 647 xmlNsDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur,
|
} else |
} else |
xmlOutputBufferWrite(buf, 5, "xmlns"); |
xmlOutputBufferWrite(buf, 5, "xmlns"); |
xmlOutputBufferWrite(buf, 1, "="); |
xmlOutputBufferWrite(buf, 1, "="); |
xmlBufferWriteQuotedString(buf->buffer, cur->href); | xmlBufWriteQuotedString(buf->buffer, cur->href); |
} |
} |
} |
} |
|
|
Line 606 xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr c
|
Line 700 xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr c
|
* xmlDtdDumpOutput: |
* xmlDtdDumpOutput: |
* @buf: the XML buffer output |
* @buf: the XML buffer output |
* @dtd: the pointer to the DTD |
* @dtd: the pointer to the DTD |
* | * |
* Dump the XML document DTD, if any. |
* Dump the XML document DTD, if any. |
*/ |
*/ |
static void |
static void |
Line 623 xmlDtdDumpOutput(xmlSaveCtxtPtr ctxt, xmlDtdPtr dtd) {
|
Line 717 xmlDtdDumpOutput(xmlSaveCtxtPtr ctxt, xmlDtdPtr dtd) {
|
xmlOutputBufferWriteString(buf, (const char *)dtd->name); |
xmlOutputBufferWriteString(buf, (const char *)dtd->name); |
if (dtd->ExternalID != NULL) { |
if (dtd->ExternalID != NULL) { |
xmlOutputBufferWrite(buf, 8, " PUBLIC "); |
xmlOutputBufferWrite(buf, 8, " PUBLIC "); |
xmlBufferWriteQuotedString(buf->buffer, dtd->ExternalID); | xmlBufWriteQuotedString(buf->buffer, dtd->ExternalID); |
xmlOutputBufferWrite(buf, 1, " "); |
xmlOutputBufferWrite(buf, 1, " "); |
xmlBufferWriteQuotedString(buf->buffer, dtd->SystemID); | xmlBufWriteQuotedString(buf->buffer, dtd->SystemID); |
} else if (dtd->SystemID != NULL) { |
} else if (dtd->SystemID != NULL) { |
xmlOutputBufferWrite(buf, 8, " SYSTEM "); |
xmlOutputBufferWrite(buf, 8, " SYSTEM "); |
xmlBufferWriteQuotedString(buf->buffer, dtd->SystemID); | xmlBufWriteQuotedString(buf->buffer, dtd->SystemID); |
} |
} |
if ((dtd->entities == NULL) && (dtd->elements == NULL) && |
if ((dtd->entities == NULL) && (dtd->elements == NULL) && |
(dtd->attributes == NULL) && (dtd->notations == NULL) && |
(dtd->attributes == NULL) && (dtd->notations == NULL) && |
Line 643 xmlDtdDumpOutput(xmlSaveCtxtPtr ctxt, xmlDtdPtr dtd) {
|
Line 737 xmlDtdDumpOutput(xmlSaveCtxtPtr ctxt, xmlDtdPtr dtd) {
|
*/ |
*/ |
if ((dtd->notations != NULL) && ((dtd->doc == NULL) || |
if ((dtd->notations != NULL) && ((dtd->doc == NULL) || |
(dtd->doc->intSubset == dtd))) { |
(dtd->doc->intSubset == dtd))) { |
xmlDumpNotationTable(buf->buffer, (xmlNotationTablePtr) dtd->notations); | xmlBufDumpNotationTable(buf->buffer, |
| (xmlNotationTablePtr) dtd->notations); |
} |
} |
format = ctxt->format; |
format = ctxt->format; |
level = ctxt->level; |
level = ctxt->level; |
Line 724 xmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr
|
Line 819 xmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr
|
(cur->type == XML_COMMENT_NODE) || |
(cur->type == XML_COMMENT_NODE) || |
(cur->type == XML_PI_NODE))) |
(cur->type == XML_PI_NODE))) |
xmlOutputBufferWrite(buf, ctxt->indent_size * |
xmlOutputBufferWrite(buf, ctxt->indent_size * |
(ctxt->level > ctxt->indent_nr ? | (ctxt->level > ctxt->indent_nr ? |
ctxt->indent_nr : ctxt->level), |
ctxt->indent_nr : ctxt->level), |
ctxt->indent); |
ctxt->indent); |
xmlNodeDumpOutputInternal(ctxt, cur); |
xmlNodeDumpOutputInternal(ctxt, cur); |
Line 841 xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNode
|
Line 936 xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNode
|
return; |
return; |
} |
} |
if (cur->type == XML_ELEMENT_DECL) { |
if (cur->type == XML_ELEMENT_DECL) { |
xmlDumpElementDecl(buf->buffer, (xmlElementPtr) cur); | xmlBufDumpElementDecl(buf->buffer, (xmlElementPtr) cur); |
return; |
return; |
} |
} |
if (cur->type == XML_ATTRIBUTE_DECL) { |
if (cur->type == XML_ATTRIBUTE_DECL) { |
xmlDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur); | xmlBufDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur); |
return; |
return; |
} |
} |
if (cur->type == XML_ENTITY_DECL) { |
if (cur->type == XML_ENTITY_DECL) { |
xmlDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur); | xmlBufDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur); |
return; |
return; |
} |
} |
if (cur->type == XML_TEXT_NODE) { |
if (cur->type == XML_TEXT_NODE) { |
Line 980 xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNode
|
Line 1075 xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNode
|
if (ctxt->level > 0) ctxt->level--; |
if (ctxt->level > 0) ctxt->level--; |
if ((xmlIndentTreeOutput) && (ctxt->format == 1)) |
if ((xmlIndentTreeOutput) && (ctxt->format == 1)) |
xmlOutputBufferWrite(buf, ctxt->indent_size * |
xmlOutputBufferWrite(buf, ctxt->indent_size * |
(ctxt->level > ctxt->indent_nr ? | (ctxt->level > ctxt->indent_nr ? |
ctxt->indent_nr : ctxt->level), |
ctxt->indent_nr : ctxt->level), |
ctxt->indent); |
ctxt->indent); |
} |
} |
Line 1096 xmlDocContentDumpOutput(xmlSaveCtxtPtr ctxt, xmlDocPtr
|
Line 1191 xmlDocContentDumpOutput(xmlSaveCtxtPtr ctxt, xmlDocPtr
|
*/ |
*/ |
if ((ctxt->options & XML_SAVE_NO_DECL) == 0) { |
if ((ctxt->options & XML_SAVE_NO_DECL) == 0) { |
xmlOutputBufferWrite(buf, 14, "<?xml version="); |
xmlOutputBufferWrite(buf, 14, "<?xml version="); |
if (cur->version != NULL) | if (cur->version != NULL) |
xmlBufferWriteQuotedString(buf->buffer, cur->version); | xmlBufWriteQuotedString(buf->buffer, cur->version); |
else |
else |
xmlOutputBufferWrite(buf, 5, "\"1.0\""); |
xmlOutputBufferWrite(buf, 5, "\"1.0\""); |
if (encoding != NULL) { |
if (encoding != NULL) { |
xmlOutputBufferWrite(buf, 10, " encoding="); |
xmlOutputBufferWrite(buf, 10, " encoding="); |
xmlBufferWriteQuotedString(buf->buffer, (xmlChar *) encoding); | xmlBufWriteQuotedString(buf->buffer, (xmlChar *) encoding); |
} |
} |
switch (cur->standalone) { |
switch (cur->standalone) { |
case 0: |
case 0: |
Line 1260 xhtmlAttrListDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPt
|
Line 1355 xhtmlAttrListDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPt
|
if ((cur->ns != NULL) && (xmlStrEqual(cur->name, BAD_CAST "lang")) && |
if ((cur->ns != NULL) && (xmlStrEqual(cur->name, BAD_CAST "lang")) && |
(xmlStrEqual(cur->ns->prefix, BAD_CAST "xml"))) |
(xmlStrEqual(cur->ns->prefix, BAD_CAST "xml"))) |
xml_lang = cur; |
xml_lang = cur; |
else if ((cur->ns == NULL) && | else if ((cur->ns == NULL) && |
((cur->children == NULL) || |
((cur->children == NULL) || |
(cur->children->content == NULL) || |
(cur->children->content == NULL) || |
(cur->children->content[0] == 0)) && |
(cur->children->content[0] == 0)) && |
Line 1300 xhtmlAttrListDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPt
|
Line 1395 xhtmlAttrListDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPt
|
xmlOutputBufferWrite(buf, 11, " xml:lang=\""); |
xmlOutputBufferWrite(buf, 11, " xml:lang=\""); |
xmlAttrSerializeContent(buf, lang); |
xmlAttrSerializeContent(buf, lang); |
xmlOutputBufferWrite(buf, 1, "\""); |
xmlOutputBufferWrite(buf, 1, "\""); |
} else | } else |
if ((xml_lang != NULL) && (lang == NULL)) { |
if ((xml_lang != NULL) && (lang == NULL)) { |
xmlOutputBufferWrite(buf, 7, " lang=\""); |
xmlOutputBufferWrite(buf, 7, " lang=\""); |
xmlAttrSerializeContent(buf, xml_lang); |
xmlAttrSerializeContent(buf, xml_lang); |
Line 1331 xhtmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePt
|
Line 1426 xhtmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePt
|
if ((ctxt->format == 1) && (xmlIndentTreeOutput) && |
if ((ctxt->format == 1) && (xmlIndentTreeOutput) && |
(cur->type == XML_ELEMENT_NODE)) |
(cur->type == XML_ELEMENT_NODE)) |
xmlOutputBufferWrite(buf, ctxt->indent_size * |
xmlOutputBufferWrite(buf, ctxt->indent_size * |
(ctxt->level > ctxt->indent_nr ? | (ctxt->level > ctxt->indent_nr ? |
ctxt->indent_nr : ctxt->level), |
ctxt->indent_nr : ctxt->level), |
ctxt->indent); |
ctxt->indent); |
xhtmlNodeDumpOutput(ctxt, cur); |
xhtmlNodeDumpOutput(ctxt, cur); |
Line 1370 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
|
Line 1465 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
|
return; |
return; |
if (cur->type == XML_XINCLUDE_END) |
if (cur->type == XML_XINCLUDE_END) |
return; |
return; |
|
if (cur->type == XML_NAMESPACE_DECL) { |
|
xmlNsDumpOutputCtxt(ctxt, (xmlNsPtr) cur); |
|
return; |
|
} |
if (cur->type == XML_DTD_NODE) { |
if (cur->type == XML_DTD_NODE) { |
xmlDtdDumpOutput(ctxt, (xmlDtdPtr) cur); |
xmlDtdDumpOutput(ctxt, (xmlDtdPtr) cur); |
return; |
return; |
Line 1380 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
|
Line 1479 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
|
} |
} |
buf = ctxt->buf; |
buf = ctxt->buf; |
if (cur->type == XML_ELEMENT_DECL) { |
if (cur->type == XML_ELEMENT_DECL) { |
xmlDumpElementDecl(buf->buffer, (xmlElementPtr) cur); | xmlBufDumpElementDecl(buf->buffer, (xmlElementPtr) cur); |
return; |
return; |
} |
} |
if (cur->type == XML_ATTRIBUTE_DECL) { |
if (cur->type == XML_ATTRIBUTE_DECL) { |
xmlDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur); | xmlBufDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur); |
return; |
return; |
} |
} |
if (cur->type == XML_ENTITY_DECL) { |
if (cur->type == XML_ENTITY_DECL) { |
xmlDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur); | xmlBufDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur); |
return; |
return; |
} |
} |
if (cur->type == XML_TEXT_NODE) { |
if (cur->type == XML_TEXT_NODE) { |
Line 1468 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
|
Line 1567 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
|
if (format == 1) { |
if (format == 1) { |
tmp = cur->children; |
tmp = cur->children; |
while (tmp != NULL) { |
while (tmp != NULL) { |
if ((tmp->type == XML_TEXT_NODE) || | if ((tmp->type == XML_TEXT_NODE) || |
(tmp->type == XML_ENTITY_REF_NODE)) { |
(tmp->type == XML_ENTITY_REF_NODE)) { |
format = 0; |
format = 0; |
break; |
break; |
Line 1496 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
|
Line 1595 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
|
if (cur->properties != NULL) |
if (cur->properties != NULL) |
xhtmlAttrListDumpOutput(ctxt, cur->properties); |
xhtmlAttrListDumpOutput(ctxt, cur->properties); |
|
|
if ((cur->type == XML_ELEMENT_NODE) && | if ((cur->type == XML_ELEMENT_NODE) && |
(cur->parent != NULL) && | (cur->parent != NULL) && |
(cur->parent->parent == (xmlNodePtr) cur->doc) && | (cur->parent->parent == (xmlNodePtr) cur->doc) && |
xmlStrEqual(cur->name, BAD_CAST"head") && | xmlStrEqual(cur->name, BAD_CAST"head") && |
xmlStrEqual(cur->parent->name, BAD_CAST"html")) { |
xmlStrEqual(cur->parent->name, BAD_CAST"html")) { |
|
|
tmp = cur->children; |
tmp = cur->children; |
Line 1536 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
|
Line 1635 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
|
xmlOutputBufferWrite(buf, 1, "\n"); |
xmlOutputBufferWrite(buf, 1, "\n"); |
if (xmlIndentTreeOutput) |
if (xmlIndentTreeOutput) |
xmlOutputBufferWrite(buf, ctxt->indent_size * |
xmlOutputBufferWrite(buf, ctxt->indent_size * |
(ctxt->level + 1 > ctxt->indent_nr ? | (ctxt->level + 1 > ctxt->indent_nr ? |
ctxt->indent_nr : ctxt->level + 1), ctxt->indent); |
ctxt->indent_nr : ctxt->level + 1), ctxt->indent); |
} |
} |
xmlOutputBufferWriteString(buf, |
xmlOutputBufferWriteString(buf, |
Line 1571 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
|
Line 1670 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
|
xmlOutputBufferWrite(buf, 1, "\n"); |
xmlOutputBufferWrite(buf, 1, "\n"); |
if (xmlIndentTreeOutput) |
if (xmlIndentTreeOutput) |
xmlOutputBufferWrite(buf, ctxt->indent_size * |
xmlOutputBufferWrite(buf, ctxt->indent_size * |
(ctxt->level + 1 > ctxt->indent_nr ? | (ctxt->level + 1 > ctxt->indent_nr ? |
ctxt->indent_nr : ctxt->level + 1), ctxt->indent); |
ctxt->indent_nr : ctxt->level + 1), ctxt->indent); |
} |
} |
xmlOutputBufferWriteString(buf, |
xmlOutputBufferWriteString(buf, |
Line 1661 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
|
Line 1760 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
|
|
|
if (cur->children != NULL) { |
if (cur->children != NULL) { |
int indent = ctxt->format; |
int indent = ctxt->format; |
| |
if (format == 1) xmlOutputBufferWrite(buf, 1, "\n"); |
if (format == 1) xmlOutputBufferWrite(buf, 1, "\n"); |
if (ctxt->level >= 0) ctxt->level++; |
if (ctxt->level >= 0) ctxt->level++; |
ctxt->format = format; |
ctxt->format = format; |
Line 1670 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
|
Line 1769 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cu
|
ctxt->format = indent; |
ctxt->format = indent; |
if ((xmlIndentTreeOutput) && (format == 1)) |
if ((xmlIndentTreeOutput) && (format == 1)) |
xmlOutputBufferWrite(buf, ctxt->indent_size * |
xmlOutputBufferWrite(buf, ctxt->indent_size * |
(ctxt->level > ctxt->indent_nr ? | (ctxt->level > ctxt->indent_nr ? |
ctxt->indent_nr : ctxt->level), |
ctxt->indent_nr : ctxt->level), |
ctxt->indent); |
ctxt->indent); |
} |
} |
Line 1936 xmlSaveSetAttrEscape(xmlSaveCtxtPtr ctxt, xmlCharEncod
|
Line 2035 xmlSaveSetAttrEscape(xmlSaveCtxtPtr ctxt, xmlCharEncod
|
* Public entry points based on buffers * |
* Public entry points based on buffers * |
* * |
* * |
************************************************************************/ |
************************************************************************/ |
|
|
/** |
/** |
* xmlAttrSerializeTxtContent: | * xmlBufAttrSerializeTxtContent: |
* @buf: the XML buffer output | * @buf: and xmlBufPtr output |
* @doc: the document |
* @doc: the document |
* @attr: the attribute node |
* @attr: the attribute node |
* @string: the text content |
* @string: the text content |
* |
* |
* Serialize text attribute values to an xml simple buffer | * Serialize text attribute values to an xmlBufPtr |
*/ |
*/ |
void |
void |
xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr doc, | xmlBufAttrSerializeTxtContent(xmlBufPtr buf, xmlDocPtr doc, |
xmlAttrPtr attr, const xmlChar * string) | xmlAttrPtr attr, const xmlChar * string) |
{ |
{ |
xmlChar *base, *cur; |
xmlChar *base, *cur; |
|
|
Line 1957 xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
|
Line 2057 xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
|
while (*cur != 0) { |
while (*cur != 0) { |
if (*cur == '\n') { |
if (*cur == '\n') { |
if (base != cur) |
if (base != cur) |
xmlBufferAdd(buf, base, cur - base); | xmlBufAdd(buf, base, cur - base); |
xmlBufferAdd(buf, BAD_CAST " ", 5); | xmlBufAdd(buf, BAD_CAST " ", 5); |
cur++; |
cur++; |
base = cur; |
base = cur; |
} else if (*cur == '\r') { |
} else if (*cur == '\r') { |
if (base != cur) |
if (base != cur) |
xmlBufferAdd(buf, base, cur - base); | xmlBufAdd(buf, base, cur - base); |
xmlBufferAdd(buf, BAD_CAST " ", 5); | xmlBufAdd(buf, BAD_CAST " ", 5); |
cur++; |
cur++; |
base = cur; |
base = cur; |
} else if (*cur == '\t') { |
} else if (*cur == '\t') { |
if (base != cur) |
if (base != cur) |
xmlBufferAdd(buf, base, cur - base); | xmlBufAdd(buf, base, cur - base); |
xmlBufferAdd(buf, BAD_CAST "	", 4); | xmlBufAdd(buf, BAD_CAST "	", 4); |
cur++; |
cur++; |
base = cur; |
base = cur; |
} else if (*cur == '"') { |
} else if (*cur == '"') { |
if (base != cur) |
if (base != cur) |
xmlBufferAdd(buf, base, cur - base); | xmlBufAdd(buf, base, cur - base); |
xmlBufferAdd(buf, BAD_CAST """, 6); | xmlBufAdd(buf, BAD_CAST """, 6); |
cur++; |
cur++; |
base = cur; |
base = cur; |
} else if (*cur == '<') { |
} else if (*cur == '<') { |
if (base != cur) |
if (base != cur) |
xmlBufferAdd(buf, base, cur - base); | xmlBufAdd(buf, base, cur - base); |
xmlBufferAdd(buf, BAD_CAST "<", 4); | xmlBufAdd(buf, BAD_CAST "<", 4); |
cur++; |
cur++; |
base = cur; |
base = cur; |
} else if (*cur == '>') { |
} else if (*cur == '>') { |
if (base != cur) |
if (base != cur) |
xmlBufferAdd(buf, base, cur - base); | xmlBufAdd(buf, base, cur - base); |
xmlBufferAdd(buf, BAD_CAST ">", 4); | xmlBufAdd(buf, BAD_CAST ">", 4); |
cur++; |
cur++; |
base = cur; |
base = cur; |
} else if (*cur == '&') { |
} else if (*cur == '&') { |
if (base != cur) |
if (base != cur) |
xmlBufferAdd(buf, base, cur - base); | xmlBufAdd(buf, base, cur - base); |
xmlBufferAdd(buf, BAD_CAST "&", 5); | xmlBufAdd(buf, BAD_CAST "&", 5); |
cur++; |
cur++; |
base = cur; |
base = cur; |
} else if ((*cur >= 0x80) && ((doc == NULL) || |
} else if ((*cur >= 0x80) && ((doc == NULL) || |
Line 2002 xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
|
Line 2102 xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
|
/* |
/* |
* We assume we have UTF-8 content. |
* We assume we have UTF-8 content. |
*/ |
*/ |
unsigned char tmp[10]; | unsigned char tmp[12]; |
int val = 0, l = 1; |
int val = 0, l = 1; |
|
|
if (base != cur) |
if (base != cur) |
xmlBufferAdd(buf, base, cur - base); | xmlBufAdd(buf, base, cur - base); |
if (*cur < 0xC0) { |
if (*cur < 0xC0) { |
xmlSaveErr(XML_SAVE_NOT_UTF8, (xmlNodePtr) attr, NULL); |
xmlSaveErr(XML_SAVE_NOT_UTF8, (xmlNodePtr) attr, NULL); |
if (doc != NULL) |
if (doc != NULL) |
doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1"); |
doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1"); |
xmlSerializeHexCharRef(tmp, *cur); |
xmlSerializeHexCharRef(tmp, *cur); |
xmlBufferAdd(buf, (xmlChar *) tmp, -1); | xmlBufAdd(buf, (xmlChar *) tmp, -1); |
cur++; |
cur++; |
base = cur; |
base = cur; |
continue; |
continue; |
Line 2042 xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
|
Line 2142 xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
|
xmlSaveErr(XML_SAVE_CHAR_INVALID, (xmlNodePtr) attr, NULL); |
xmlSaveErr(XML_SAVE_CHAR_INVALID, (xmlNodePtr) attr, NULL); |
if (doc != NULL) |
if (doc != NULL) |
doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1"); |
doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1"); |
| |
xmlSerializeHexCharRef(tmp, *cur); |
xmlSerializeHexCharRef(tmp, *cur); |
xmlBufferAdd(buf, (xmlChar *) tmp, -1); | xmlBufAdd(buf, (xmlChar *) tmp, -1); |
cur++; |
cur++; |
base = cur; |
base = cur; |
continue; |
continue; |
Line 2054 xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
|
Line 2154 xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
|
* as a char ref |
* as a char ref |
*/ |
*/ |
xmlSerializeHexCharRef(tmp, val); |
xmlSerializeHexCharRef(tmp, val); |
xmlBufferAdd(buf, (xmlChar *) tmp, -1); | xmlBufAdd(buf, (xmlChar *) tmp, -1); |
cur += l; |
cur += l; |
base = cur; |
base = cur; |
} else { |
} else { |
Line 2062 xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
|
Line 2162 xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
|
} |
} |
} |
} |
if (base != cur) |
if (base != cur) |
xmlBufferAdd(buf, base, cur - base); | xmlBufAdd(buf, base, cur - base); |
} |
} |
|
|
/** |
/** |
|
* xmlAttrSerializeTxtContent: |
|
* @buf: the XML buffer output |
|
* @doc: the document |
|
* @attr: the attribute node |
|
* @string: the text content |
|
* |
|
* Serialize text attribute values to an xml simple buffer |
|
*/ |
|
void |
|
xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr doc, |
|
xmlAttrPtr attr, const xmlChar * string) |
|
{ |
|
xmlBufPtr buffer; |
|
|
|
if ((buf == NULL) || (string == NULL)) |
|
return; |
|
buffer = xmlBufFromBuffer(buf); |
|
if (buffer == NULL) |
|
return; |
|
xmlBufAttrSerializeTxtContent(buffer, doc, attr, string); |
|
xmlBufBackToBuffer(buffer); |
|
} |
|
|
|
/** |
* xmlNodeDump: |
* xmlNodeDump: |
* @buf: the XML buffer output |
* @buf: the XML buffer output |
* @doc: the document |
* @doc: the document |
Line 2076 xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
|
Line 2200 xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr
|
* Dump an XML node, recursive behaviour,children are printed too. |
* Dump an XML node, recursive behaviour,children are printed too. |
* Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 |
* Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 |
* or xmlKeepBlanksDefault(0) was called |
* or xmlKeepBlanksDefault(0) was called |
|
* Since this is using xmlBuffer structures it is limited to 2GB and somehow |
|
* deprecated, use xmlBufNodeDump() instead. |
* |
* |
* Returns the number of bytes written to the buffer or -1 in case of error |
* Returns the number of bytes written to the buffer or -1 in case of error |
*/ |
*/ |
Line 2083 int
|
Line 2209 int
|
xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level, |
xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level, |
int format) |
int format) |
{ |
{ |
unsigned int use; | xmlBufPtr buffer; |
int ret; |
int ret; |
|
|
|
if ((buf == NULL) || (cur == NULL)) |
|
return(-1); |
|
buffer = xmlBufFromBuffer(buf); |
|
if (buffer == NULL) |
|
return(-1); |
|
ret = xmlBufNodeDump(buffer, doc, cur, level, format); |
|
xmlBufBackToBuffer(buffer); |
|
if (ret > INT_MAX) |
|
return(-1); |
|
return((int) ret); |
|
} |
|
|
|
/** |
|
* xmlBufNodeDump: |
|
* @buf: the XML buffer output |
|
* @doc: the document |
|
* @cur: the current node |
|
* @level: the imbrication level for indenting |
|
* @format: is formatting allowed |
|
* |
|
* Dump an XML node, recursive behaviour,children are printed too. |
|
* Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1 |
|
* or xmlKeepBlanksDefault(0) was called |
|
* |
|
* Returns the number of bytes written to the buffer, in case of error 0 |
|
* is returned or @buf stores the error |
|
*/ |
|
|
|
size_t |
|
xmlBufNodeDump(xmlBufPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level, |
|
int format) |
|
{ |
|
size_t use; |
|
int ret; |
xmlOutputBufferPtr outbuf; |
xmlOutputBufferPtr outbuf; |
|
int oldalloc; |
|
|
xmlInitParser(); |
xmlInitParser(); |
|
|
Line 2116 xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePt
|
Line 2278 xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePt
|
outbuf->context = NULL; |
outbuf->context = NULL; |
outbuf->written = 0; |
outbuf->written = 0; |
|
|
use = buf->use; | use = xmlBufUse(buf); |
| oldalloc = xmlBufGetAllocationScheme(buf); |
| xmlBufSetAllocationScheme(buf, XML_BUFFER_ALLOC_DOUBLEIT); |
xmlNodeDumpOutput(outbuf, doc, cur, level, format, NULL); |
xmlNodeDumpOutput(outbuf, doc, cur, level, format, NULL); |
|
xmlBufSetAllocationScheme(buf, oldalloc); |
xmlFree(outbuf); |
xmlFree(outbuf); |
ret = buf->use - use; | ret = xmlBufUse(buf) - use; |
return (ret); |
return (ret); |
} |
} |
|
|
Line 2299 xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc, xmlChar *
|
Line 2464 xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc, xmlChar *
|
xmlDocContentDumpOutput(&ctxt, out_doc); |
xmlDocContentDumpOutput(&ctxt, out_doc); |
xmlOutputBufferFlush(out_buff); |
xmlOutputBufferFlush(out_buff); |
if (out_buff->conv != NULL) { |
if (out_buff->conv != NULL) { |
*doc_txt_len = out_buff->conv->use; | *doc_txt_len = xmlBufUse(out_buff->conv); |
*doc_txt_ptr = xmlStrndup(out_buff->conv->content, *doc_txt_len); | *doc_txt_ptr = xmlStrndup(xmlBufContent(out_buff->conv), *doc_txt_len); |
} else { |
} else { |
*doc_txt_len = out_buff->buffer->use; | *doc_txt_len = xmlBufUse(out_buff->buffer); |
*doc_txt_ptr = xmlStrndup(out_buff->buffer->content, *doc_txt_len); | *doc_txt_ptr = xmlStrndup(xmlBufContent(out_buff->buffer),*doc_txt_len); |
} |
} |
(void)xmlOutputBufferClose(out_buff); |
(void)xmlOutputBufferClose(out_buff); |
|
|
Line 2547 xmlSaveFormatFileEnc( const char * filename, xmlDocPtr
|
Line 2712 xmlSaveFormatFileEnc( const char * filename, xmlDocPtr
|
#ifdef HAVE_ZLIB_H |
#ifdef HAVE_ZLIB_H |
if (cur->compression < 0) cur->compression = xmlGetCompressMode(); |
if (cur->compression < 0) cur->compression = xmlGetCompressMode(); |
#endif |
#endif |
/* | /* |
* save the content to a temp buffer. |
* save the content to a temp buffer. |
*/ |
*/ |
buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression); |
buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression); |