#include "wx/datstrm.h"
#include "wx/zstream.h"
#include "wx/strconv.h"
+#include "wx/scopedptr.h"
+#include "wx/versioninfo.h"
#include "expat.h" // from Expat
// a private utility used by wxXML
-static bool wxIsWhiteOnly(const wxChar *buf);
+static bool wxIsWhiteOnly(const wxString& buf);
//-----------------------------------------------------------------------------
wxXmlNode::wxXmlNode(wxXmlNode *parent,wxXmlNodeType type,
const wxString& name, const wxString& content,
- wxXmlProperty *props, wxXmlNode *next)
+ wxXmlAttribute *attrs, wxXmlNode *next, int lineNo)
: m_type(type), m_name(name), m_content(content),
- m_properties(props), m_parent(parent),
- m_children(NULL), m_next(next)
+ m_attrs(attrs), m_parent(parent),
+ m_children(NULL), m_next(next),
+ m_lineNo(lineNo),
+ m_noConversion(false)
{
if (m_parent)
{
}
wxXmlNode::wxXmlNode(wxXmlNodeType type, const wxString& name,
- const wxString& content)
+ const wxString& content,
+ int lineNo)
: m_type(type), m_name(name), m_content(content),
- m_properties(NULL), m_parent(NULL),
- m_children(NULL), m_next(NULL)
+ m_attrs(NULL), m_parent(NULL),
+ m_children(NULL), m_next(NULL),
+ m_lineNo(lineNo), m_noConversion(false)
{}
wxXmlNode::wxXmlNode(const wxXmlNode& node)
delete c;
}
- wxXmlProperty *p, *p2;
- for (p = m_properties; p; p = p2)
+ wxXmlAttribute *p, *p2;
+ for (p = m_attrs; p; p = p2)
{
p2 = p->GetNext();
delete p;
wxXmlNode& wxXmlNode::operator=(const wxXmlNode& node)
{
- wxDELETE(m_properties);
+ wxDELETE(m_attrs);
wxDELETE(m_children);
DoCopy(node);
return *this;
m_type = node.m_type;
m_name = node.m_name;
m_content = node.m_content;
+ m_lineNo = node.m_lineNo;
+ m_noConversion = node.m_noConversion;
m_children = NULL;
wxXmlNode *n = node.m_children;
n = n->GetNext();
}
- m_properties = NULL;
- wxXmlProperty *p = node.m_properties;
+ m_attrs = NULL;
+ wxXmlAttribute *p = node.m_attrs;
while (p)
{
- AddProperty(p->GetName(), p->GetValue());
+ AddAttribute(p->GetName(), p->GetValue());
p = p->GetNext();
}
}
-bool wxXmlNode::HasProp(const wxString& propName) const
+bool wxXmlNode::HasAttribute(const wxString& attrName) const
{
- wxXmlProperty *prop = GetProperties();
+ wxXmlAttribute *attr = GetAttributes();
- while (prop)
+ while (attr)
{
- if (prop->GetName() == propName) return true;
- prop = prop->GetNext();
+ if (attr->GetName() == attrName) return true;
+ attr = attr->GetNext();
}
return false;
}
-bool wxXmlNode::GetPropVal(const wxString& propName, wxString *value) const
+bool wxXmlNode::GetAttribute(const wxString& attrName, wxString *value) const
{
- wxXmlProperty *prop = GetProperties();
+ wxCHECK_MSG( value, false, "value argument must not be NULL" );
- while (prop)
+ wxXmlAttribute *attr = GetAttributes();
+
+ while (attr)
{
- if (prop->GetName() == propName)
+ if (attr->GetName() == attrName)
{
- *value = prop->GetValue();
+ *value = attr->GetValue();
return true;
}
- prop = prop->GetNext();
+ attr = attr->GetNext();
}
return false;
}
-wxString wxXmlNode::GetPropVal(const wxString& propName, const wxString& defaultVal) const
+wxString wxXmlNode::GetAttribute(const wxString& attrName, const wxString& defaultVal) const
{
wxString tmp;
- if (GetPropVal(propName, &tmp))
+ if (GetAttribute(attrName, &tmp))
return tmp;
return defaultVal;
child->m_parent = this;
}
-bool wxXmlNode::InsertChild(wxXmlNode *child, wxXmlNode *before_node)
+// inserts a new node in front of 'followingNode'
+bool wxXmlNode::InsertChild(wxXmlNode *child, wxXmlNode *followingNode)
{
- wxCHECK_MSG(before_node == NULL || before_node->GetParent() == this, false,
- wxT("wxXmlNode::InsertChild - the node has incorrect parent"));
- wxCHECK_MSG(child, false, wxT("Cannot insert a NULL pointer!"));
-
- if (m_children == before_node)
- m_children = child;
- else if (m_children == NULL)
- {
- if (before_node != NULL)
- return false; // we have no children so we don't need to search
- m_children = child;
- }
- else if (before_node == NULL)
+ wxCHECK_MSG( child, false, "cannot insert a NULL node!" );
+ wxCHECK_MSG( child->m_parent == NULL, false, "node already has a parent" );
+ wxCHECK_MSG( child->m_next == NULL, false, "node already has m_next" );
+ wxCHECK_MSG( followingNode == NULL || followingNode->GetParent() == this,
+ false,
+ "wxXmlNode::InsertChild - followingNode has incorrect parent" );
+
+ // this is for backward compatibility, NULL was allowed here thanks to
+ // the confusion about followingNode's meaning
+ if ( followingNode == NULL )
+ followingNode = m_children;
+
+ if ( m_children == followingNode )
{
- // prepend child
- child->m_parent = this;
child->m_next = m_children;
m_children = child;
- return true;
}
else
{
wxXmlNode *ch = m_children;
- while (ch && ch->m_next != before_node) ch = ch->m_next;
- if (!ch)
- return false; // before_node not found
+ while ( ch && ch->m_next != followingNode )
+ ch = ch->m_next;
+ if ( !ch )
+ {
+ wxFAIL_MSG( "followingNode has this node as parent, but couldn't be found among children" );
+ return false;
+ }
+
+ child->m_next = followingNode;
ch->m_next = child;
}
child->m_parent = this;
- child->m_next = before_node;
+ return true;
+}
+
+// inserts a new node right after 'precedingNode'
+bool wxXmlNode::InsertChildAfter(wxXmlNode *child, wxXmlNode *precedingNode)
+{
+ wxCHECK_MSG( child, false, "cannot insert a NULL node!" );
+ wxCHECK_MSG( child->m_parent == NULL, false, "node already has a parent" );
+ wxCHECK_MSG( child->m_next == NULL, false, "node already has m_next" );
+ wxCHECK_MSG( precedingNode == NULL || precedingNode->m_parent == this, false,
+ "precedingNode has wrong parent" );
+
+ if ( precedingNode )
+ {
+ child->m_next = precedingNode->m_next;
+ precedingNode->m_next = child;
+ }
+ else // precedingNode == NULL
+ {
+ wxCHECK_MSG( m_children == NULL, false,
+ "NULL precedingNode only makes sense when there are no children" );
+
+ child->m_next = m_children;
+ m_children = child;
+ }
+
+ child->m_parent = this;
return true;
}
}
}
+void wxXmlNode::AddAttribute(const wxString& name, const wxString& value)
+{
+ AddProperty(name, value);
+}
+
+void wxXmlNode::AddAttribute(wxXmlAttribute *attr)
+{
+ AddProperty(attr);
+}
+
+bool wxXmlNode::DeleteAttribute(const wxString& name)
+{
+ return DeleteProperty(name);
+}
+
void wxXmlNode::AddProperty(const wxString& name, const wxString& value)
{
- AddProperty(new wxXmlProperty(name, value, NULL));
+ AddProperty(new wxXmlAttribute(name, value, NULL));
}
-void wxXmlNode::AddProperty(wxXmlProperty *prop)
+void wxXmlNode::AddProperty(wxXmlAttribute *attr)
{
- if (m_properties == NULL)
- m_properties = prop;
+ if (m_attrs == NULL)
+ m_attrs = attr;
else
{
- wxXmlProperty *p = m_properties;
+ wxXmlAttribute *p = m_attrs;
while (p->GetNext()) p = p->GetNext();
- p->SetNext(prop);
+ p->SetNext(attr);
}
}
bool wxXmlNode::DeleteProperty(const wxString& name)
{
- wxXmlProperty *prop;
+ wxXmlAttribute *attr;
- if (m_properties == NULL)
+ if (m_attrs == NULL)
return false;
- else if (m_properties->GetName() == name)
+ else if (m_attrs->GetName() == name)
{
- prop = m_properties;
- m_properties = prop->GetNext();
- prop->SetNext(NULL);
- delete prop;
+ attr = m_attrs;
+ m_attrs = attr->GetNext();
+ attr->SetNext(NULL);
+ delete attr;
return true;
}
else
{
- wxXmlProperty *p = m_properties;
+ wxXmlAttribute *p = m_attrs;
while (p->GetNext())
{
if (p->GetNext()->GetName() == name)
{
- prop = p->GetNext();
- p->SetNext(prop->GetNext());
- prop->SetNext(NULL);
- delete prop;
+ attr = p->GetNext();
+ p->SetNext(attr->GetNext());
+ attr->SetNext(NULL);
+ delete attr;
return true;
}
p = p->GetNext();
//-----------------------------------------------------------------------------
wxXmlDocument::wxXmlDocument()
- : m_version(wxT("1.0")), m_fileEncoding(wxT("utf-8")), m_root(NULL)
+ : m_version(wxS("1.0")), m_fileEncoding(wxS("utf-8")), m_root(NULL)
{
#if !wxUSE_UNICODE
- m_encoding = wxT("UTF-8");
+ m_encoding = wxS("UTF-8");
#endif
}
// converts Expat-produced string in UTF-8 into wxString using the specified
// conv or keep in UTF-8 if conv is NULL
static wxString CharToString(wxMBConv *conv,
- const char *s, size_t len = wxString::npos)
+ const char *s, size_t len = wxString::npos)
{
-#if wxUSE_UNICODE
- wxUnusedVar(conv);
-
- return wxString(s, wxConvUTF8, len);
-#else // !wxUSE_UNICODE
+#if !wxUSE_UNICODE
if ( conv )
{
// there can be no embedded NULs in this string so we don't need the
return wxString(wbuf, *conv);
}
- else // already in UTF-8, no conversion needed
- {
- return wxString(s, len != wxString::npos ? len : strlen(s));
- }
-#endif // wxUSE_UNICODE/!wxUSE_UNICODE
+ // else: the string is wanted in UTF-8
+#endif // !wxUSE_UNICODE
+
+ wxUnusedVar(conv);
+ return wxString::FromUTF8Unchecked(s, len);
}
// returns true if the given string contains only whitespaces
-bool wxIsWhiteOnly(const wxChar *buf)
+bool wxIsWhiteOnly(const wxString& buf)
{
- for (const wxChar *c = buf; *c != wxT('\0'); c++)
- if (*c != wxT(' ') && *c != wxT('\t') && *c != wxT('\n') && *c != wxT('\r'))
+ for ( wxString::const_iterator i = buf.begin(); i != buf.end(); ++i )
+ {
+ wxChar c = *i;
+ if ( c != wxS(' ') && c != wxS('\t') && c != wxS('\n') && c != wxS('\r'))
return false;
+ }
return true;
}
struct wxXmlParsingContext
{
+ wxXmlParsingContext()
+ : conv(NULL),
+ root(NULL),
+ node(NULL),
+ lastChild(NULL),
+ lastAsText(NULL),
+ removeWhiteOnlyNodes(false)
+ {}
+
+ XML_Parser parser;
wxMBConv *conv;
wxXmlNode *root;
- wxXmlNode *node;
- wxXmlNode *lastAsText;
+ wxXmlNode *node; // the node being parsed
+ wxXmlNode *lastChild; // the last child of "node"
+ wxXmlNode *lastAsText; // the last _text_ child of "node"
wxString encoding;
wxString version;
- bool bLastCdata;
bool removeWhiteOnlyNodes;
};
+// checks that ctx->lastChild is in consistent state
+#define ASSERT_LAST_CHILD_OK(ctx) \
+ wxASSERT( ctx->lastChild == NULL || \
+ ctx->lastChild->GetNext() == NULL ); \
+ wxASSERT( ctx->lastChild == NULL || \
+ ctx->lastChild->GetParent() == ctx->node )
+
extern "C" {
static void StartElementHnd(void *userData, const char *name, const char **atts)
{
wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
- wxXmlNode *node = new wxXmlNode(wxXML_ELEMENT_NODE, CharToString(ctx->conv, name));
+ wxXmlNode *node = new wxXmlNode(wxXML_ELEMENT_NODE,
+ CharToString(ctx->conv, name),
+ wxEmptyString,
+ XML_GetCurrentLineNumber(ctx->parser));
const char **a = atts;
+
+ // add node attributes
while (*a)
{
- node->AddProperty(CharToString(ctx->conv, a[0]), CharToString(ctx->conv, a[1]));
+ node->AddAttribute(CharToString(ctx->conv, a[0]), CharToString(ctx->conv, a[1]));
a += 2;
}
+
if (ctx->root == NULL)
+ {
ctx->root = node;
+ }
else
- ctx->node->AddChild(node);
- ctx->node = node;
+ {
+ ASSERT_LAST_CHILD_OK(ctx);
+ ctx->node->InsertChildAfter(node, ctx->lastChild);
+ }
+
ctx->lastAsText = NULL;
-}
+ ctx->lastChild = NULL; // our new node "node" has no children yet
+
+ ctx->node = node;
}
-extern "C" {
static void EndElementHnd(void *userData, const char* WXUNUSED(name))
{
wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
+ // we're exiting the last children of ctx->node->GetParent() and going
+ // back one level up, so current value of ctx->node points to the last
+ // child of ctx->node->GetParent()
+ ctx->lastChild = ctx->node;
+
ctx->node = ctx->node->GetParent();
ctx->lastAsText = NULL;
}
-}
-extern "C" {
static void TextHnd(void *userData, const char *s, int len)
{
wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
if (ctx->lastAsText)
{
- if ( ctx->bLastCdata )
- {
- ctx->lastAsText->SetContent(ctx->lastAsText->GetContent() +
- CharToString(NULL, s, len));
- }
- else
- {
- ctx->lastAsText->SetContent(ctx->lastAsText->GetContent() + str);
- }
+ ctx->lastAsText->SetContent(ctx->lastAsText->GetContent() + str);
}
else
{
if (!whiteOnly)
{
- ctx->lastAsText = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"), str);
- ctx->node->AddChild(ctx->lastAsText);
+ wxXmlNode *textnode =
+ new wxXmlNode(wxXML_TEXT_NODE, wxS("text"), str,
+ XML_GetCurrentLineNumber(ctx->parser));
+
+ ASSERT_LAST_CHILD_OK(ctx);
+ ctx->node->InsertChildAfter(textnode, ctx->lastChild);
+ ctx->lastChild= ctx->lastAsText = textnode;
}
}
}
-}
-extern "C" {
static void StartCdataHnd(void *userData)
{
wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
- ctx->bLastCdata = true;
+ wxXmlNode *textnode =
+ new wxXmlNode(wxXML_CDATA_SECTION_NODE, wxS("cdata"), wxS(""),
+ XML_GetCurrentLineNumber(ctx->parser));
- ctx->lastAsText = new wxXmlNode(wxXML_CDATA_SECTION_NODE, wxT("cdata"),wxT(""));
- ctx->node->AddChild(ctx->lastAsText);
-}
+ ASSERT_LAST_CHILD_OK(ctx);
+ ctx->node->InsertChildAfter(textnode, ctx->lastChild);
+ ctx->lastChild= ctx->lastAsText = textnode;
}
-extern "C" {
static void EndCdataHnd(void *userData)
{
wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
- ctx->bLastCdata = false;
-}
+ // we need to reset this pointer so that subsequent text nodes don't append
+ // their contents to this one but create new wxXML_TEXT_NODE objects (or
+ // not create anything at all if only white space follows the CDATA section
+ // and wxXMLDOC_KEEP_WHITESPACE_NODES is not used as is commonly the case)
+ ctx->lastAsText = NULL;
}
-extern "C" {
static void CommentHnd(void *userData, const char *data)
{
wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
if (ctx->node)
{
- // VS: ctx->node == NULL happens if there is a comment before
- // the root element (e.g. wxDesigner's output). We ignore such
- // comments, no big deal...
- ctx->node->AddChild(new wxXmlNode(wxXML_COMMENT_NODE,
- wxT("comment"), CharToString(ctx->conv, data)));
+ wxXmlNode *commentnode =
+ new wxXmlNode(wxXML_COMMENT_NODE,
+ wxS("comment"), CharToString(ctx->conv, data),
+ XML_GetCurrentLineNumber(ctx->parser));
+
+ ASSERT_LAST_CHILD_OK(ctx);
+ ctx->node->InsertChildAfter(commentnode, ctx->lastChild);
+ ctx->lastChild = commentnode;
}
+ //else: ctx->node == NULL happens if there is a comment before
+ // the root element. We current don't have a way to represent
+ // these in wxXmlDocument (FIXME).
+
ctx->lastAsText = NULL;
}
-}
-extern "C" {
static void DefaultHnd(void *userData, const char *s, int len)
{
// XML header:
wxString buf = CharToString(ctx->conv, s, (size_t)len);
int pos;
- pos = buf.Find(wxT("encoding="));
+ pos = buf.Find(wxS("encoding="));
if (pos != wxNOT_FOUND)
ctx->encoding = buf.Mid(pos + 10).BeforeFirst(buf[(size_t)pos+9]);
- pos = buf.Find(wxT("version="));
+ pos = buf.Find(wxS("version="));
if (pos != wxNOT_FOUND)
ctx->version = buf.Mid(pos + 9).BeforeFirst(buf[(size_t)pos+8]);
}
}
-}
-extern "C" {
static int UnknownEncodingHnd(void * WXUNUSED(encodingHandlerData),
const XML_Char *name, XML_Encoding *info)
{
// We must build conversion table for expat. The easiest way to do so
// is to let wxCSConv convert as string containing all characters to
// wide character representation:
- wxString str(name, wxConvLibc);
- wxCSConv conv(str);
+ wxCSConv conv(name);
char mbBuf[2];
wchar_t wcBuf[10];
size_t i;
return 1;
}
-}
+
+} // extern "C"
bool wxXmlDocument::Load(wxInputStream& stream, const wxString& encoding, int flags)
{
bool done;
XML_Parser parser = XML_ParserCreate(NULL);
- ctx.root = ctx.node = NULL;
- ctx.encoding = wxT("UTF-8"); // default in absence of encoding=""
+ ctx.encoding = wxS("UTF-8"); // default in absence of encoding=""
ctx.conv = NULL;
#if !wxUSE_UNICODE
- if ( encoding.CmpNoCase(wxT("UTF-8")) != 0 )
+ if ( encoding.CmpNoCase(wxS("UTF-8")) != 0 )
ctx.conv = new wxCSConv(encoding);
#endif
ctx.removeWhiteOnlyNodes = (flags & wxXMLDOC_KEEP_WHITESPACE_NODES) == 0;
- ctx.bLastCdata = false;
+ ctx.parser = parser;
XML_SetUserData(parser, (void*)&ctx);
XML_SetElementHandler(parser, StartElementHnd, EndElementHnd);
XML_SetCharacterDataHandler(parser, TextHnd);
- XML_SetCdataSectionHandler(parser, StartCdataHnd, EndCdataHnd );
+ XML_SetCdataSectionHandler(parser, StartCdataHnd, EndCdataHnd);;
XML_SetCommentHandler(parser, CommentHnd);
XML_SetDefaultHandler(parser, DefaultHnd);
XML_SetUnknownEncodingHandler(parser, UnknownEncodingHnd, NULL);
*wxConvCurrent);
wxLogError(_("XML parsing error: '%s' at line %d"),
error.c_str(),
- XML_GetCurrentLineNumber(parser));
+ (int)XML_GetCurrentLineNumber(parser));
ok = false;
break;
}
// wxXmlDocument saving routines
//-----------------------------------------------------------------------------
+// helpers for XML generation
+namespace
+{
+
// write string to output:
-inline static void OutputString(wxOutputStream& stream, const wxString& str,
- wxMBConv *convMem = NULL,
- wxMBConv *convFile = NULL)
+bool OutputString(wxOutputStream& stream,
+ const wxString& str,
+ wxMBConv *convMem,
+ wxMBConv *convFile)
{
if (str.empty())
- return;
+ return true;
#if wxUSE_UNICODE
wxUnusedVar(convMem);
+ if ( !convFile )
+ convFile = &wxConvUTF8;
+
+ const wxScopedCharBuffer buf(str.mb_str(*convFile));
+ if ( !buf.length() )
+ {
+ // conversion failed, can't write this string in an XML file in this
+ // (presumably non-UTF-8) encoding
+ return false;
+ }
- const wxWX2MBbuf buf(str.mb_str(*(convFile ? convFile : &wxConvUTF8)));
- stream.Write((const char*)buf, strlen((const char*)buf));
+ stream.Write(buf, buf.length());
#else // !wxUSE_UNICODE
if ( convFile && convMem )
{
wxString str2(str.wc_str(*convMem), *convFile);
- stream.Write(str2.mb_str(), str2.Len());
+ stream.Write(str2.mb_str(), str2.length());
}
else // no conversions to do
{
- stream.Write(str.mb_str(), str.Len());
+ stream.Write(str.mb_str(), str.length());
}
#endif // wxUSE_UNICODE/!wxUSE_UNICODE
+
+ return stream.IsOk();
}
-// flags for OutputStringEnt()
-enum
+enum EscapingMode
{
- XML_ESCAPE_QUOTES = 1
+ Escape_Text,
+ Escape_Attribute
};
// Same as above, but create entities first.
-// Translates '<' to "<", '>' to ">" and '&' to "&"
-static void OutputStringEnt(wxOutputStream& stream, const wxString& str,
- wxMBConv *convMem = NULL,
- wxMBConv *convFile = NULL,
- int flags = 0)
-{
- wxString buf;
- size_t i, last, len;
- wxChar c;
-
- len = str.Len();
- last = 0;
- for (i = 0; i < len; i++)
- {
- c = str.GetChar(i);
- if (c == wxT('<') || c == wxT('>') ||
- (c == wxT('&') && str.Mid(i+1, 4) != wxT("amp;")) ||
- ((flags & XML_ESCAPE_QUOTES) && c == wxT('"')))
+// Translates '<' to "<", '>' to ">" and so on, according to the spec:
+// http://www.w3.org/TR/2000/WD-xml-c14n-20000119.html#charescaping
+bool OutputEscapedString(wxOutputStream& stream,
+ const wxString& str,
+ wxMBConv *convMem,
+ wxMBConv *convFile,
+ EscapingMode mode)
+{
+ wxString escaped;
+ escaped.reserve(str.length());
+
+ for ( wxString::const_iterator i = str.begin(); i != str.end(); ++i )
+ {
+ const wxChar c = *i;
+
+ switch ( c )
{
- OutputString(stream, str.Mid(last, i - last), convMem, convFile);
- switch (c)
- {
- case wxT('<'):
- OutputString(stream, wxT("<"));
- break;
- case wxT('>'):
- OutputString(stream, wxT(">"));
- break;
- case wxT('&'):
- OutputString(stream, wxT("&"));
- break;
- case wxT('"'):
- OutputString(stream, wxT("""));
- break;
- default:
- break;
- }
- last = i + 1;
+ case wxS('<'):
+ escaped.append(wxS("<"));
+ break;
+ case wxS('>'):
+ escaped.append(wxS(">"));
+ break;
+ case wxS('&'):
+ escaped.append(wxS("&"));
+ break;
+ case wxS('\r'):
+ escaped.append(wxS("
"));
+ break;
+ default:
+ if ( mode == Escape_Attribute )
+ {
+ switch ( c )
+ {
+ case wxS('"'):
+ escaped.append(wxS("""));
+ break;
+ case wxS('\t'):
+ escaped.append(wxS("	"));
+ break;
+ case wxS('\n'):
+ escaped.append(wxS("
"));
+ break;
+ default:
+ escaped.append(c);
+ }
+
+ }
+ else
+ {
+ escaped.append(c);
+ }
}
}
- OutputString(stream, str.Mid(last, i - last), convMem, convFile);
+
+ return OutputString(stream, escaped, convMem, convFile);
}
-inline static void OutputIndentation(wxOutputStream& stream, int indent)
+bool OutputIndentation(wxOutputStream& stream,
+ int indent,
+ wxMBConv *convMem,
+ wxMBConv *convFile)
{
- wxString str = wxT("\n");
- for (int i = 0; i < indent; i++)
- str << wxT(' ') << wxT(' ');
- OutputString(stream, str);
+ wxString str(wxS("\n"));
+ str += wxString(indent, wxS(' '));
+ return OutputString(stream, str, convMem, convFile);
}
-static void OutputNode(wxOutputStream& stream, wxXmlNode *node, int indent,
- wxMBConv *convMem, wxMBConv *convFile, int indentstep)
+bool OutputNode(wxOutputStream& stream,
+ wxXmlNode *node,
+ int indent,
+ wxMBConv *convMem,
+ wxMBConv *convFile,
+ int indentstep)
{
- wxXmlNode *n, *prev;
- wxXmlProperty *prop;
-
+ bool rc;
switch (node->GetType())
{
case wxXML_CDATA_SECTION_NODE:
- OutputString( stream, wxT("<![CDATA["));
- OutputString( stream, node->GetContent() );
- OutputString( stream, wxT("]]>") );
+ rc = OutputString(stream, wxS("<![CDATA["), convMem, convFile) &&
+ OutputString(stream, node->GetContent(), convMem, convFile) &&
+ OutputString(stream, wxS("]]>"), convMem, convFile);
break;
case wxXML_TEXT_NODE:
- OutputStringEnt(stream, node->GetContent(), convMem, convFile);
+ if (node->GetNoConversion())
+ {
+ stream.Write(node->GetContent().c_str(), node->GetContent().Length());
+ rc = true;
+ }
+ else
+ rc = OutputEscapedString(stream, node->GetContent(),
+ convMem, convFile,
+ Escape_Text);
break;
case wxXML_ELEMENT_NODE:
- OutputString(stream, wxT("<"));
- OutputString(stream, node->GetName());
+ rc = OutputString(stream, wxS("<"), convMem, convFile) &&
+ OutputString(stream, node->GetName(), convMem, convFile);
- prop = node->GetProperties();
- while (prop)
+ if ( rc )
{
- OutputString(stream, wxT(" ") + prop->GetName() + wxT("=\""));
- OutputStringEnt(stream, prop->GetValue(), convMem, convFile,
- XML_ESCAPE_QUOTES);
- OutputString(stream, wxT("\""));
- prop = prop->GetNext();
+ for ( wxXmlAttribute *attr = node->GetAttributes();
+ attr && rc;
+ attr = attr->GetNext() )
+ {
+ rc = OutputString(stream,
+ wxS(" ") + attr->GetName() + wxS("=\""),
+ convMem, convFile) &&
+ OutputEscapedString(stream, attr->GetValue(),
+ convMem, convFile,
+ Escape_Attribute) &&
+ OutputString(stream, wxS("\""), convMem, convFile);
+ }
}
- if (node->GetChildren())
+ if ( node->GetChildren() )
{
- OutputString(stream, wxT(">"));
- prev = NULL;
- n = node->GetChildren();
- while (n)
+ rc = OutputString(stream, wxS(">"), convMem, convFile);
+
+ wxXmlNode *prev = NULL;
+ for ( wxXmlNode *n = node->GetChildren();
+ n && rc;
+ n = n->GetNext() )
{
- if (indentstep >= 0 && n && n->GetType() != wxXML_TEXT_NODE)
- OutputIndentation(stream, indent + indentstep);
- OutputNode(stream, n, indent + indentstep, convMem, convFile, indentstep);
+ if ( indentstep >= 0 && n->GetType() != wxXML_TEXT_NODE )
+ {
+ rc = OutputIndentation(stream, indent + indentstep,
+ convMem, convFile);
+ }
+
+ if ( rc )
+ rc = OutputNode(stream, n, indent + indentstep,
+ convMem, convFile, indentstep);
+
prev = n;
- n = n->GetNext();
}
- if (indentstep >= 0 && prev && prev->GetType() != wxXML_TEXT_NODE)
- OutputIndentation(stream, indent);
- OutputString(stream, wxT("</"));
- OutputString(stream, node->GetName());
- OutputString(stream, wxT(">"));
+
+ if ( rc && indentstep >= 0 &&
+ prev && prev->GetType() != wxXML_TEXT_NODE )
+ {
+ rc = OutputIndentation(stream, indent, convMem, convFile);
+ }
+
+ if ( rc )
+ {
+ rc = OutputString(stream, wxS("</"), convMem, convFile) &&
+ OutputString(stream, node->GetName(),
+ convMem, convFile) &&
+ OutputString(stream, wxS(">"), convMem, convFile);
+ }
+ }
+ else // no children, output "<foo/>"
+ {
+ rc = OutputString(stream, wxS("/>"), convMem, convFile);
}
- else
- OutputString(stream, wxT("/>"));
break;
case wxXML_COMMENT_NODE:
- OutputString(stream, wxT("<!--"));
- OutputString(stream, node->GetContent(), convMem, convFile);
- OutputString(stream, wxT("-->"));
+ rc = OutputString(stream, wxS("<!--"), convMem, convFile) &&
+ OutputString(stream, node->GetContent(), convMem, convFile) &&
+ OutputString(stream, wxS("-->"), convMem, convFile);
break;
default:
- wxFAIL_MSG(wxT("unsupported node type"));
+ wxFAIL_MSG("unsupported node type");
+ rc = false;
}
+
+ return rc;
}
+} // anonymous namespace
+
bool wxXmlDocument::Save(wxOutputStream& stream, int indentstep) const
{
if ( !IsOk() )
return false;
- wxString s;
-
- wxMBConv *convMem = NULL,
- *convFile;
+ wxScopedPtr<wxMBConv> convMem, convFile;
#if wxUSE_UNICODE
- convFile = new wxCSConv(GetFileEncoding());
- convMem = NULL;
+ convFile.reset(new wxCSConv(GetFileEncoding()));
#else
if ( GetFileEncoding().CmpNoCase(GetEncoding()) != 0 )
{
- convFile = new wxCSConv(GetFileEncoding());
- convMem = new wxCSConv(GetEncoding());
- }
- else // file and in-memory encodings are the same, no conversion needed
- {
- convFile =
- convMem = NULL;
+ convFile.reset(new wxCSConv(GetFileEncoding()));
+ convMem.reset(new wxCSConv(GetEncoding()));
}
+ //else: file and in-memory encodings are the same, no conversion needed
#endif
- s.Printf(wxT("<?xml version=\"%s\" encoding=\"%s\"?>\n"),
- GetVersion().c_str(), GetFileEncoding().c_str());
- OutputString(stream, s);
-
- OutputNode(stream, GetRoot(), 0, convMem, convFile, indentstep);
- OutputString(stream, wxT("\n"));
-
- delete convFile;
- delete convMem;
+ return OutputString(stream,
+ wxString::Format
+ (
+ wxS("<?xml version=\"%s\" encoding=\"%s\"?>\n"),
+ GetVersion(), GetFileEncoding()
+ ),
+ convMem.get(),
+ convFile.get()) &&
+ OutputNode(stream, GetRoot(), 0,
+ convMem.get(), convFile.get(), indentstep) &&
+ OutputString(stream, wxS("\n"), convMem.get(), convFile.get());
+}
- return true;
+/*static*/ wxVersionInfo wxXmlDocument::GetLibraryVersionInfo()
+{
+ return wxVersionInfo("expat",
+ XML_MAJOR_VERSION,
+ XML_MINOR_VERSION,
+ XML_MICRO_VERSION);
}
#endif // wxUSE_XML
projects / wxWidgets.git / blobdiff