src/xrc/xml.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        xml.cpp
// Purpose:     wxXmlDocument - XML parser & data holder class
// Author:      Vaclav Slavik
// Created:     2000/03/05
// RCS-ID:      $Id$
// Copyright:   (c) 2000 Vaclav Slavik
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "xml.h"
#pragma implementation "xmlio.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif


#include "wx/wfstream.h"
#include "wx/datstrm.h"
#include "wx/zstream.h"
#include "wx/log.h"
#include "wx/intl.h"
#include "wx/strconv.h"

#include "wx/xrc/xml.h"

#include "xmlparse.h" // from Expat

//-----------------------------------------------------------------------------
//  wxXmlNode
//-----------------------------------------------------------------------------

wxXmlNode::wxXmlNode(wxXmlNode *parent,wxXmlNodeType type,
                     const wxString& name, const wxString& content,
                     wxXmlProperty *props, wxXmlNode *next)
    : m_type(type), m_name(name), m_content(content),
      m_properties(props), m_parent(parent),
      m_children(NULL), m_next(next)
{
    if (m_parent)
    {
        if (m_parent->m_children)
        {
            m_next = m_parent->m_children;
            m_parent->m_children = this;
        }
        else
            m_parent->m_children = this;
    }
}

wxXmlNode::wxXmlNode(wxXmlNodeType type, const wxString& name,
                     const wxString& content)
    : m_type(type), m_name(name), m_content(content),
      m_properties(NULL), m_parent(NULL),
      m_children(NULL), m_next(NULL)
{}

wxXmlNode::wxXmlNode(const wxXmlNode& node)
{
    m_next = NULL;
    m_parent = NULL;
    DoCopy(node);
}

wxXmlNode::~wxXmlNode()
{
    wxXmlNode *c, *c2;
    for (c = m_children; c; c = c2)
    {
        c2 = c->m_next;
        delete c;
    }

    wxXmlProperty *p, *p2;
    for (p = m_properties; p; p = p2)
    {
        p2 = p->GetNext();
        delete p;
    }
}

wxXmlNode& wxXmlNode::operator=(const wxXmlNode& node)
{
    wxDELETE(m_properties);
    wxDELETE(m_children);
    DoCopy(node);
    return *this;
}

void wxXmlNode::DoCopy(const wxXmlNode& node)
{
    m_type = node.m_type;
    m_name = node.m_name;
    m_content = node.m_content;
    m_children = NULL;

    wxXmlNode *n = node.m_children;
    while (n)
    {
        AddChild(new wxXmlNode(*n));
        n = n->GetNext();
    }

    m_properties = NULL;
    wxXmlProperty *p = node.m_properties;
    while (p)
    {
       AddProperty(p->GetName(), p->GetValue());
       p = p->GetNext();
    }
}

bool wxXmlNode::HasProp(const wxString& propName) const
{
    wxXmlProperty *prop = GetProperties();

    while (prop)
    {
        if (prop->GetName() == propName) return TRUE;
        prop = prop->GetNext();
    }

    return FALSE;
}

bool wxXmlNode::GetPropVal(const wxString& propName, wxString *value) const
{
    wxXmlProperty *prop = GetProperties();

    while (prop)
    {
        if (prop->GetName() == propName)
        {
            *value = prop->GetValue();
            return TRUE;
        }
        prop = prop->GetNext();
    }

    return FALSE;
}

wxString wxXmlNode::GetPropVal(const wxString& propName, const wxString& defaultVal) const
{
    wxString tmp;
    if (GetPropVal(propName, &tmp))
        return tmp;
    else
        return defaultVal;
}

void wxXmlNode::AddChild(wxXmlNode *child)
{
    if (m_children == NULL)
        m_children = child;
    else
    {
        wxXmlNode *ch = m_children;
        while (ch->m_next) ch = ch->m_next;
        ch->m_next = child;
    }
    child->m_next = NULL;
    child->m_parent = this;
}

void wxXmlNode::InsertChild(wxXmlNode *child, wxXmlNode *before_node)
{
    wxASSERT_MSG(before_node->GetParent() == this, wxT("wxXmlNode::InsertChild - the node has incorrect parent"));

    if (m_children == before_node)
       m_children = child;
    else
    {
        wxXmlNode *ch = m_children;
        while (ch->m_next != before_node) ch = ch->m_next;
        ch->m_next = child;
    }

    child->m_parent = this;
    child->m_next = before_node;
}

bool wxXmlNode::RemoveChild(wxXmlNode *child)
{
    if (m_children == NULL)
        return FALSE;
    else if (m_children == child)
    {
        m_children = child->m_next;
        child->m_parent = NULL;
        child->m_next = NULL;
        return TRUE;
    }
    else
    {
        wxXmlNode *ch = m_children;
        while (ch->m_next)
        {
            if (ch->m_next == child)
            {
                ch->m_next = child->m_next;
                child->m_parent = NULL;
                child->m_next = NULL;
                return TRUE;
            }
            ch = ch->m_next;
        }
        return FALSE;
    }
}

void wxXmlNode::AddProperty(const wxString& name, const wxString& value)
{
    AddProperty(new wxXmlProperty(name, value, NULL));
}

void wxXmlNode::AddProperty(wxXmlProperty *prop)
{
    if (m_properties == NULL)
        m_properties = prop;
    else
    {
        wxXmlProperty *p = m_properties;
        while (p->GetNext()) p = p->GetNext();
        p->SetNext(prop);
    }
}

bool wxXmlNode::DeleteProperty(const wxString& name)
{
    wxXmlProperty *prop;

    if (m_properties == NULL)
        return FALSE;

    else if (m_properties->GetName() == name)
    {
        prop = m_properties;
        m_properties = prop->GetNext();
        prop->SetNext(NULL);
        delete prop;
        return TRUE;
    }

    else
    {
        wxXmlProperty *p = m_properties;
        while (p->GetNext())
        {
            if (p->GetNext()->GetName() == name)
            {
                prop = p->GetNext();
                p->SetNext(prop->GetNext());
                prop->SetNext(NULL);
                delete prop;
                return TRUE;
            }
            p = p->GetNext();
        }
        return FALSE;
    }
}


//-----------------------------------------------------------------------------
//  wxXmlDocument
//-----------------------------------------------------------------------------

wxXmlDocument::wxXmlDocument(const wxString& filename, const wxString& encoding)
                          : wxObject(), m_root(NULL)
{
    if ( !Load(filename, encoding) )
    {
        wxDELETE(m_root);
    }
}

wxXmlDocument::wxXmlDocument(wxInputStream& stream, const wxString& encoding)
                          : wxObject(), m_root(NULL)
{
    if ( !Load(stream, encoding) )
    {
        wxDELETE(m_root);
    }
}

wxXmlDocument::wxXmlDocument(const wxXmlDocument& doc)
{
    DoCopy(doc);
}

wxXmlDocument& wxXmlDocument::operator=(const wxXmlDocument& doc)
{
    wxDELETE(m_root);
    DoCopy(doc);
    return *this;
}

void wxXmlDocument::DoCopy(const wxXmlDocument& doc)
{
    m_version = doc.m_version;
#if !wxUSE_UNICODE
    m_encoding = doc.m_encoding;
#endif
    m_fileEncoding = doc.m_fileEncoding;
    m_root = new wxXmlNode(*doc.m_root);
}

bool wxXmlDocument::Load(const wxString& filename, const wxString& encoding)
{
    wxFileInputStream stream(filename);
    return Load(stream, encoding);
}

bool wxXmlDocument::Save(const wxString& filename) const
{
    wxFileOutputStream stream(filename);
    return Save(stream);
}


//-----------------------------------------------------------------------------
//  wxXmlDocument loading routines
//-----------------------------------------------------------------------------

/*
    FIXME:
       - process all elements, including CDATA
 */

// converts Expat-produced string in UTF-8 into wxString.
inline static wxString CharToString(wxMBConv *conv,
                                    const char *s, size_t len = wxSTRING_MAXLEN)
{
#if wxUSE_UNICODE
    (void)conv;
    return wxString(s, wxConvUTF8, len);
#else
    if ( conv )
    {
        size_t nLen = (len != wxSTRING_MAXLEN) ? len :
                          nLen = wxConvUTF8.MB2WC((wchar_t*) NULL, s, 0);

        wchar_t *buf = new wchar_t[nLen+1];
        wxConvUTF8.MB2WC(buf, s, nLen);
        buf[nLen] = 0;
        return wxString(buf, *conv, len);
        delete[] buf;
    }
    else
        return wxString(s, len);
#endif
}

struct wxXmlParsingContext
{
    wxMBConv  *conv;
    wxXmlNode *root;
    wxXmlNode *node;
    wxXmlNode *lastAsText;
    wxString   encoding;
    wxString   version;
};

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));
    const char **a = atts;
    while (*a)
    {
        node->AddProperty(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;
    ctx->lastAsText = NULL;
}

static void EndElementHnd(void *userData, const char* WXUNUSED(name))
{
    wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;

    ctx->node = ctx->node->GetParent();
    ctx->lastAsText = NULL;
}

static void TextHnd(void *userData, const char *s, int len)
{
    wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;
    char *buf = new char[len + 1];

    buf[len] = '\0';
    memcpy(buf, s, (size_t)len);

    if (ctx->lastAsText)
    {
        ctx->lastAsText->SetContent(ctx->lastAsText->GetContent() +
                                    CharToString(ctx->conv, buf));
    }
    else
    {
        bool whiteOnly = TRUE;
        for (char *c = buf; *c != '\0'; c++)
            if (*c != ' ' && *c != '\t' && *c != '\n' && *c != '\r')
            {
                whiteOnly = FALSE;
                break;
            }
        if (!whiteOnly)
        {
            ctx->lastAsText = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"),
                                            CharToString(ctx->conv, buf));
            ctx->node->AddChild(ctx->lastAsText);
        }
    }

    delete[] buf;
}

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)));
    }
    ctx->lastAsText = NULL;
}

static void DefaultHnd(void *userData, const char *s, int len)
{
    // XML header:
    if (len > 6 && memcmp(s, "<?xml ", 6) == 0)
    {
        wxXmlParsingContext *ctx = (wxXmlParsingContext*)userData;

        wxString buf = CharToString(ctx->conv, s, (size_t)len);
        int pos;
        pos = buf.Find(wxT("encoding="));
        if (pos != wxNOT_FOUND)
            ctx->encoding = buf.Mid(pos + 10).BeforeFirst(buf[(size_t)pos+9]);
        pos = buf.Find(wxT("version="));
        if (pos != wxNOT_FOUND)
            ctx->version = buf.Mid(pos + 9).BeforeFirst(buf[(size_t)pos+8]);
    }
}

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:
    wxCSConv conv(wxString(name, wxConvLibc));
    char mbBuf[255];
    wchar_t wcBuf[255];
    size_t i;

    for (i = 0; i < 255; i++)
        mbBuf[i] = i+1;
    mbBuf[255] = 0;
    conv.MB2WC(wcBuf, mbBuf, 255);
    wcBuf[255] = 0;

    info->map[0] = 0;
    for (i = 0; i < 255; i++)
        info->map[i+1] = (int)wcBuf[i];

    info->data = NULL;
    info->convert = NULL;
    info->release = NULL;

    return 1;
}

bool wxXmlDocument::Load(wxInputStream& stream, const wxString& encoding)
{
#if wxUSE_UNICODE
    (void)encoding;
#else
    m_encoding = encoding;
#endif

    const size_t BUFSIZE = 1024;
    char buf[BUFSIZE];
    wxXmlParsingContext ctx;
    bool done;
    XML_Parser parser = XML_ParserCreate(NULL);

    ctx.root = ctx.node = NULL;
    ctx.encoding = wxT("UTF-8"); // default in absence of encoding=""
    ctx.conv = NULL;
#if !wxUSE_UNICODE
    if ( encoding != wxT("UTF-8") && encoding != wxT("utf-8") )
        ctx.conv = new wxCSConv(encoding);
#endif

    XML_SetUserData(parser, (void*)&ctx);
    XML_SetElementHandler(parser, StartElementHnd, EndElementHnd);
    XML_SetCharacterDataHandler(parser, TextHnd);
    XML_SetCommentHandler(parser, CommentHnd);
    XML_SetDefaultHandler(parser, DefaultHnd);
    XML_SetUnknownEncodingHandler(parser, UnknownEncodingHnd, NULL);

    do
    {
        size_t len = stream.Read(buf, BUFSIZE).LastRead();
        done = (len < BUFSIZE);
        if (!XML_Parse(parser, buf, len, done))
        {
            wxLogError(_("XML parsing error: '%s' at line %d"),
                       XML_ErrorString(XML_GetErrorCode(parser)),
                       XML_GetCurrentLineNumber(parser));
          return FALSE;
        }
    } while (!done);

    SetVersion(ctx.version);
    SetFileEncoding(ctx.encoding);
    SetRoot(ctx.root);

    XML_ParserFree(parser);
#if !wxUSE_UNICODE
    if ( ctx.conv )
        delete ctx.conv;
#endif

    return TRUE;

}


//-----------------------------------------------------------------------------
//  wxXmlDocument saving routines
//-----------------------------------------------------------------------------

// write string to output:
inline static void OutputString(wxOutputStream& stream, const wxString& str,
                                wxMBConv *convMem, wxMBConv *convFile)
{
    if (str.IsEmpty()) return;
#if wxUSE_UNICODE
    const wxWX2MBbuf buf(str.mb_str(convFile ? *convFile : wxConvUTF8));
    stream.Write((const char*)buf, strlen((const char*)buf));
#else
    if ( convFile == NULL )
        stream.Write(str.mb_str(), str.Len());
    else
    {
        wxString str2(str.wc_str(*convMem), *convFile);
        stream.Write(str2.mb_str(), str2.Len());
    }
#endif
}

// Same as above, but create entities first.
// Translates '<' to "&lt;", '>' to "&gt;" and '&' to "&amp;"
static void OutputStringEnt(wxOutputStream& stream, const wxString& str,
                            wxMBConv *convMem, wxMBConv *convFile)
{
    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;")))
        {
            OutputString(stream, str.Mid(last, i - last), convMem, convFile);
            switch (c)
            {
                case wxT('<'):
                    OutputString(stream, wxT("&lt;"), NULL, NULL);
                    break;
                case wxT('>'):
                    OutputString(stream, wxT("&gt;"), NULL, NULL);
                    break;
                case wxT('&'):
                    OutputString(stream, wxT("&amp;"), NULL, NULL);
                    break;
                default: break;
            }
            last = i + 1;
        }
    }
    OutputString(stream, str.Mid(last, i - last), convMem, convFile);
}

inline static void OutputIndentation(wxOutputStream& stream, int indent)
{
    wxString str = wxT("\n");
    for (int i = 0; i < indent; i++)
        str << wxT(' ') << wxT(' ');
    OutputString(stream, str, NULL, NULL);
}

static void OutputNode(wxOutputStream& stream, wxXmlNode *node, int indent,
                       wxMBConv *convMem, wxMBConv *convFile)
{
    wxXmlNode *n, *prev;
    wxXmlProperty *prop;

    switch (node->GetType())
    {
        case wxXML_TEXT_NODE:
            OutputStringEnt(stream, node->GetContent(), convMem, convFile);
            break;

        case wxXML_ELEMENT_NODE:
            OutputString(stream, wxT("<"), NULL, NULL);
            OutputString(stream, node->GetName(), NULL, NULL);

            prop = node->GetProperties();
            while (prop)
            {
                OutputString(stream, wxT(" ") + prop->GetName() +
                             wxT("=\"") + prop->GetValue() + wxT("\""),
                             NULL, NULL);
                // FIXME - what if prop contains '"'?
                prop = prop->GetNext();
            }

            if (node->GetChildren())
            {
                OutputString(stream, wxT(">"), NULL, NULL);
                prev = NULL;
                n = node->GetChildren();
                while (n)
                {
                    if (n && n->GetType() != wxXML_TEXT_NODE)
                        OutputIndentation(stream, indent + 1);
                    OutputNode(stream, n, indent + 1, convMem, convFile);
                    prev = n;
                    n = n->GetNext();
                }
                if (prev && prev->GetType() != wxXML_TEXT_NODE)
                    OutputIndentation(stream, indent);
                OutputString(stream, wxT("</"), NULL, NULL);
                OutputString(stream, node->GetName(), NULL, NULL);
                OutputString(stream, wxT(">"), NULL, NULL);
            }
            else
                OutputString(stream, wxT("/>"), NULL, NULL);
            break;

        case wxXML_COMMENT_NODE:
            OutputString(stream, wxT("<!--"), NULL, NULL);
            OutputString(stream, node->GetContent(), convMem, convFile);
            OutputString(stream, wxT("-->"), NULL, NULL);
            break;

        default:
            wxFAIL_MSG(wxT("unsupported node type"));
    }
}

bool wxXmlDocument::Save(wxOutputStream& stream) const
{
    if ( !IsOk() )
        return FALSE;

    wxString s;

    wxMBConv *convMem = NULL, *convFile = NULL;
#if wxUSE_UNICODE
    convFile = new wxCSConv(GetFileEncoding());
#else
    if ( GetFileEncoding() != GetEncoding() )
    {
        convFile = new wxCSConv(GetFileEncoding());
        convMem = new wxCSConv(GetEncoding());
    }
#endif

    s.Printf(wxT("<?xml version=\"%s\" encoding=\"%s\"?>\n"),
             GetVersion().c_str(), GetFileEncoding().c_str());
    OutputString(stream, s, NULL, NULL);

    OutputNode(stream, GetRoot(), 0, convMem, convFile);
    OutputString(stream, wxT("\n"), NULL, NULL);

    if ( convFile )
        delete convFile;
    if ( convMem )
        delete convMem;

    return TRUE;
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: xml.cpp
	3	// Purpose: wxXmlDocument - XML parser & data holder class
	4	// Author: Vaclav Slavik
	5	// Created: 2000/03/05
	6	// RCS-ID: $Id$
	7	// Copyright: (c) 2000 Vaclav Slavik
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	#ifdef __GNUG__
	12	#pragma implementation "xml.h"
	13	#pragma implementation "xmlio.h"
	14	#endif
	15
	16	// For compilers that support precompilation, includes "wx.h".
	17	#include "wx/wxprec.h"
	18
	19	#ifdef __BORLANDC__
	20	#pragma hdrstop
	21	#endif
	22
	23
	24	#include "wx/wfstream.h"
	25	#include "wx/datstrm.h"
	26	#include "wx/zstream.h"
	27	#include "wx/log.h"
	28	#include "wx/intl.h"
	29	#include "wx/strconv.h"
	30
	31	#include "wx/xrc/xml.h"
	32
	33	#include "xmlparse.h" // from Expat
	34
	35	//-----------------------------------------------------------------------------
	36	// wxXmlNode
	37	//-----------------------------------------------------------------------------
	38
	39	wxXmlNode::wxXmlNode(wxXmlNode *parent,wxXmlNodeType type,
	40	const wxString& name, const wxString& content,
	41	wxXmlProperty props, wxXmlNode next)
	42	: m_type(type), m_name(name), m_content(content),
	43	m_properties(props), m_parent(parent),
	44	m_children(NULL), m_next(next)
	45	{
	46	if (m_parent)
	47	{
	48	if (m_parent->m_children)
	49	{
	50	m_next = m_parent->m_children;
	51	m_parent->m_children = this;
	52	}
	53	else
	54	m_parent->m_children = this;
	55	}
	56	}
	57
	58	wxXmlNode::wxXmlNode(wxXmlNodeType type, const wxString& name,
	59	const wxString& content)
	60	: m_type(type), m_name(name), m_content(content),
	61	m_properties(NULL), m_parent(NULL),
	62	m_children(NULL), m_next(NULL)
	63	{}
	64
	65	wxXmlNode::wxXmlNode(const wxXmlNode& node)
	66	{
	67	m_next = NULL;
	68	m_parent = NULL;
	69	DoCopy(node);
	70	}
	71
	72	wxXmlNode::~wxXmlNode()
	73	{
	74	wxXmlNode c, c2;
	75	for (c = m_children; c; c = c2)
	76	{
	77	c2 = c->m_next;
	78	delete c;
	79	}
	80
	81	wxXmlProperty p, p2;
	82	for (p = m_properties; p; p = p2)
	83	{
	84	p2 = p->GetNext();
	85	delete p;
	86	}
	87	}
	88
	89	wxXmlNode& wxXmlNode::operator=(const wxXmlNode& node)
	90	{
	91	wxDELETE(m_properties);
	92	wxDELETE(m_children);
	93	DoCopy(node);
	94	return *this;
	95	}
	96
	97	void wxXmlNode::DoCopy(const wxXmlNode& node)
	98	{
	99	m_type = node.m_type;
	100	m_name = node.m_name;
	101	m_content = node.m_content;
	102	m_children = NULL;
	103
	104	wxXmlNode *n = node.m_children;
	105	while (n)
	106	{
	107	AddChild(new wxXmlNode(*n));
	108	n = n->GetNext();
	109	}
	110
	111	m_properties = NULL;
	112	wxXmlProperty *p = node.m_properties;
	113	while (p)
	114	{
	115	AddProperty(p->GetName(), p->GetValue());
	116	p = p->GetNext();
	117	}
	118	}
	119
	120	bool wxXmlNode::HasProp(const wxString& propName) const
	121	{
	122	wxXmlProperty *prop = GetProperties();
	123
	124	while (prop)
	125	{
	126	if (prop->GetName() == propName) return TRUE;
	127	prop = prop->GetNext();
	128	}
	129
	130	return FALSE;
	131	}
	132
	133	bool wxXmlNode::GetPropVal(const wxString& propName, wxString *value) const
	134	{
	135	wxXmlProperty *prop = GetProperties();
	136
	137	while (prop)
	138	{
	139	if (prop->GetName() == propName)
	140	{
	141	*value = prop->GetValue();
	142	return TRUE;
	143	}
	144	prop = prop->GetNext();
	145	}
	146
	147	return FALSE;
	148	}
	149
	150	wxString wxXmlNode::GetPropVal(const wxString& propName, const wxString& defaultVal) const
	151	{
	152	wxString tmp;
	153	if (GetPropVal(propName, &tmp))
	154	return tmp;
	155	else
	156	return defaultVal;
	157	}
	158
	159	void wxXmlNode::AddChild(wxXmlNode *child)
	160	{
	161	if (m_children == NULL)
	162	m_children = child;
	163	else
	164	{
	165	wxXmlNode *ch = m_children;
	166	while (ch->m_next) ch = ch->m_next;
	167	ch->m_next = child;
	168	}
	169	child->m_next = NULL;
	170	child->m_parent = this;
	171	}
	172
	173	void wxXmlNode::InsertChild(wxXmlNode child, wxXmlNode before_node)
	174	{
	175	wxASSERT_MSG(before_node->GetParent() == this, wxT("wxXmlNode::InsertChild - the node has incorrect parent"));
	176
	177	if (m_children == before_node)
	178	m_children = child;
	179	else
	180	{
	181	wxXmlNode *ch = m_children;
	182	while (ch->m_next != before_node) ch = ch->m_next;
	183	ch->m_next = child;
	184	}
	185
	186	child->m_parent = this;
	187	child->m_next = before_node;
	188	}
	189
	190	bool wxXmlNode::RemoveChild(wxXmlNode *child)
	191	{
	192	if (m_children == NULL)
	193	return FALSE;
	194	else if (m_children == child)
	195	{
	196	m_children = child->m_next;
	197	child->m_parent = NULL;
	198	child->m_next = NULL;
	199	return TRUE;
	200	}
	201	else
	202	{
	203	wxXmlNode *ch = m_children;
	204	while (ch->m_next)
	205	{
	206	if (ch->m_next == child)
	207	{
	208	ch->m_next = child->m_next;
	209	child->m_parent = NULL;
	210	child->m_next = NULL;
	211	return TRUE;
	212	}
	213	ch = ch->m_next;
	214	}
	215	return FALSE;
	216	}
	217	}
	218
	219	void wxXmlNode::AddProperty(const wxString& name, const wxString& value)
	220	{
	221	AddProperty(new wxXmlProperty(name, value, NULL));
	222	}
	223
	224	void wxXmlNode::AddProperty(wxXmlProperty *prop)
	225	{
	226	if (m_properties == NULL)
	227	m_properties = prop;
	228	else
	229	{
	230	wxXmlProperty *p = m_properties;
	231	while (p->GetNext()) p = p->GetNext();
	232	p->SetNext(prop);
	233	}
	234	}
	235
	236	bool wxXmlNode::DeleteProperty(const wxString& name)
	237	{
	238	wxXmlProperty *prop;
	239
	240	if (m_properties == NULL)
	241	return FALSE;
	242
	243	else if (m_properties->GetName() == name)
	244	{
	245	prop = m_properties;
	246	m_properties = prop->GetNext();
	247	prop->SetNext(NULL);
	248	delete prop;
	249	return TRUE;
	250	}
	251
	252	else
	253	{
	254	wxXmlProperty *p = m_properties;
	255	while (p->GetNext())
	256	{
	257	if (p->GetNext()->GetName() == name)
	258	{
	259	prop = p->GetNext();
	260	p->SetNext(prop->GetNext());
	261	prop->SetNext(NULL);
	262	delete prop;
	263	return TRUE;
	264	}
	265	p = p->GetNext();
	266	}
	267	return FALSE;
	268	}
	269	}
	270
	271
	272
	273	//-----------------------------------------------------------------------------
	274	// wxXmlDocument
	275	//-----------------------------------------------------------------------------
	276
	277	wxXmlDocument::wxXmlDocument(const wxString& filename, const wxString& encoding)
	278	: wxObject(), m_root(NULL)
	279	{
	280	if ( !Load(filename, encoding) )
	281	{
	282	wxDELETE(m_root);
	283	}
	284	}
	285
	286	wxXmlDocument::wxXmlDocument(wxInputStream& stream, const wxString& encoding)
	287	: wxObject(), m_root(NULL)
	288	{
	289	if ( !Load(stream, encoding) )
	290	{
	291	wxDELETE(m_root);
	292	}
	293	}
	294
	295	wxXmlDocument::wxXmlDocument(const wxXmlDocument& doc)
	296	{
	297	DoCopy(doc);
	298	}
	299
	300	wxXmlDocument& wxXmlDocument::operator=(const wxXmlDocument& doc)
	301	{
	302	wxDELETE(m_root);
	303	DoCopy(doc);
	304	return *this;
	305	}
	306
	307	void wxXmlDocument::DoCopy(const wxXmlDocument& doc)
	308	{
	309	m_version = doc.m_version;
	310	#if !wxUSE_UNICODE
	311	m_encoding = doc.m_encoding;
	312	#endif
	313	m_fileEncoding = doc.m_fileEncoding;
	314	m_root = new wxXmlNode(*doc.m_root);
	315	}
	316
	317	bool wxXmlDocument::Load(const wxString& filename, const wxString& encoding)
	318	{
	319	wxFileInputStream stream(filename);
	320	return Load(stream, encoding);
	321	}
	322
	323	bool wxXmlDocument::Save(const wxString& filename) const
	324	{
	325	wxFileOutputStream stream(filename);
	326	return Save(stream);
	327	}
	328
	329
	330
	331	//-----------------------------------------------------------------------------
	332	// wxXmlDocument loading routines
	333	//-----------------------------------------------------------------------------
	334
	335	/*
	336	FIXME:
	337	- process all elements, including CDATA
	338	*/
	339
	340	// converts Expat-produced string in UTF-8 into wxString.
	341	inline static wxString CharToString(wxMBConv *conv,
	342	const char *s, size_t len = wxSTRING_MAXLEN)
	343	{
	344	#if wxUSE_UNICODE
	345	(void)conv;
	346	return wxString(s, wxConvUTF8, len);
	347	#else
	348	if ( conv )
	349	{
	350	size_t nLen = (len != wxSTRING_MAXLEN) ? len :
	351	nLen = wxConvUTF8.MB2WC((wchar_t*) NULL, s, 0);
	352
	353	wchar_t *buf = new wchar_t[nLen+1];
	354	wxConvUTF8.MB2WC(buf, s, nLen);
	355	buf[nLen] = 0;
	356	return wxString(buf, *conv, len);
	357	delete[] buf;
	358	}
	359	else
	360	return wxString(s, len);
	361	#endif
	362	}
	363
	364	struct wxXmlParsingContext
	365	{
	366	wxMBConv *conv;
	367	wxXmlNode *root;
	368	wxXmlNode *node;
	369	wxXmlNode *lastAsText;
	370	wxString encoding;
	371	wxString version;
	372	};
	373
	374	static void StartElementHnd(void userData, const char name, const char **atts)
	375	{
	376	wxXmlParsingContext ctx = (wxXmlParsingContext)userData;
	377	wxXmlNode *node = new wxXmlNode(wxXML_ELEMENT_NODE, CharToString(ctx->conv, name));
	378	const char **a = atts;
	379	while (*a)
	380	{
	381	node->AddProperty(CharToString(ctx->conv, a[0]), CharToString(ctx->conv, a[1]));
	382	a += 2;
	383	}
	384	if (ctx->root == NULL)
	385	ctx->root = node;
	386	else
	387	ctx->node->AddChild(node);
	388	ctx->node = node;
	389	ctx->lastAsText = NULL;
	390	}
	391
	392	static void EndElementHnd(void userData, const char WXUNUSED(name))
	393	{
	394	wxXmlParsingContext ctx = (wxXmlParsingContext)userData;
	395
	396	ctx->node = ctx->node->GetParent();
	397	ctx->lastAsText = NULL;
	398	}
	399
	400	static void TextHnd(void userData, const char s, int len)
	401	{
	402	wxXmlParsingContext ctx = (wxXmlParsingContext)userData;
	403	char *buf = new char[len + 1];
	404
	405	buf[len] = '\0';
	406	memcpy(buf, s, (size_t)len);
	407
	408	if (ctx->lastAsText)
	409	{
	410	ctx->lastAsText->SetContent(ctx->lastAsText->GetContent() +
	411	CharToString(ctx->conv, buf));
	412	}
	413	else
	414	{
	415	bool whiteOnly = TRUE;
	416	for (char c = buf; c != '\0'; c++)
	417	if (c != ' ' && c != '\t' && c != '\n' && c != '\r')
	418	{
	419	whiteOnly = FALSE;
	420	break;
	421	}
	422	if (!whiteOnly)
	423	{
	424	ctx->lastAsText = new wxXmlNode(wxXML_TEXT_NODE, wxT("text"),
	425	CharToString(ctx->conv, buf));
	426	ctx->node->AddChild(ctx->lastAsText);
	427	}
	428	}
	429
	430	delete[] buf;
	431	}
	432
	433	static void CommentHnd(void userData, const char data)
	434	{
	435	wxXmlParsingContext ctx = (wxXmlParsingContext)userData;
	436
	437	if (ctx->node)
	438	{
	439	// VS: ctx->node == NULL happens if there is a comment before
	440	// the root element (e.g. wxDesigner's output). We ignore such
	441	// comments, no big deal...
	442	ctx->node->AddChild(new wxXmlNode(wxXML_COMMENT_NODE,
	443	wxT("comment"), CharToString(ctx->conv, data)));
	444	}
	445	ctx->lastAsText = NULL;
	446	}
	447
	448	static void DefaultHnd(void userData, const char s, int len)
	449	{
	450	// XML header:
	451	if (len > 6 && memcmp(s, "<?xml ", 6) == 0)
	452	{
	453	wxXmlParsingContext ctx = (wxXmlParsingContext)userData;
	454
	455	wxString buf = CharToString(ctx->conv, s, (size_t)len);
	456	int pos;
	457	pos = buf.Find(wxT("encoding="));
	458	if (pos != wxNOT_FOUND)
	459	ctx->encoding = buf.Mid(pos + 10).BeforeFirst(buf[(size_t)pos+9]);
	460	pos = buf.Find(wxT("version="));
	461	if (pos != wxNOT_FOUND)
	462	ctx->version = buf.Mid(pos + 9).BeforeFirst(buf[(size_t)pos+8]);
	463	}
	464	}
	465
	466	static int UnknownEncodingHnd(void * WXUNUSED(encodingHandlerData),
	467	const XML_Char name, XML_Encoding info)
	468	{
	469	// We must build conversion table for expat. The easiest way to do so
	470	// is to let wxCSConv convert as string containing all characters to
	471	// wide character representation:
	472	wxCSConv conv(wxString(name, wxConvLibc));
	473	char mbBuf[255];
	474	wchar_t wcBuf[255];
	475	size_t i;
	476
	477	for (i = 0; i < 255; i++)
	478	mbBuf[i] = i+1;
	479	mbBuf[255] = 0;
	480	conv.MB2WC(wcBuf, mbBuf, 255);
	481	wcBuf[255] = 0;
	482
	483	info->map[0] = 0;
	484	for (i = 0; i < 255; i++)
	485	info->map[i+1] = (int)wcBuf[i];
	486
	487	info->data = NULL;
	488	info->convert = NULL;
	489	info->release = NULL;
	490
	491	return 1;
	492	}
	493
	494	bool wxXmlDocument::Load(wxInputStream& stream, const wxString& encoding)
	495	{
	496	#if wxUSE_UNICODE
	497	(void)encoding;
	498	#else
	499	m_encoding = encoding;
	500	#endif
	501
	502	const size_t BUFSIZE = 1024;
	503	char buf[BUFSIZE];
	504	wxXmlParsingContext ctx;
	505	bool done;
	506	XML_Parser parser = XML_ParserCreate(NULL);
	507
	508	ctx.root = ctx.node = NULL;
	509	ctx.encoding = wxT("UTF-8"); // default in absence of encoding=""
	510	ctx.conv = NULL;
	511	#if !wxUSE_UNICODE
	512	if ( encoding != wxT("UTF-8") && encoding != wxT("utf-8") )
	513	ctx.conv = new wxCSConv(encoding);
	514	#endif
	515
	516	XML_SetUserData(parser, (void*)&ctx);
	517	XML_SetElementHandler(parser, StartElementHnd, EndElementHnd);
	518	XML_SetCharacterDataHandler(parser, TextHnd);
	519	XML_SetCommentHandler(parser, CommentHnd);
	520	XML_SetDefaultHandler(parser, DefaultHnd);
	521	XML_SetUnknownEncodingHandler(parser, UnknownEncodingHnd, NULL);
	522
	523	do
	524	{
	525	size_t len = stream.Read(buf, BUFSIZE).LastRead();
	526	done = (len < BUFSIZE);
	527	if (!XML_Parse(parser, buf, len, done))
	528	{
	529	wxLogError(_("XML parsing error: '%s' at line %d"),
	530	XML_ErrorString(XML_GetErrorCode(parser)),
	531	XML_GetCurrentLineNumber(parser));
	532	return FALSE;
	533	}
	534	} while (!done);
	535
	536	SetVersion(ctx.version);
	537	SetFileEncoding(ctx.encoding);
	538	SetRoot(ctx.root);
	539
	540	XML_ParserFree(parser);
	541	#if !wxUSE_UNICODE
	542	if ( ctx.conv )
	543	delete ctx.conv;
	544	#endif
	545
	546	return TRUE;
	547
	548	}
	549
	550
	551
	552	//-----------------------------------------------------------------------------
	553	// wxXmlDocument saving routines
	554	//-----------------------------------------------------------------------------
	555
	556	// write string to output:
	557	inline static void OutputString(wxOutputStream& stream, const wxString& str,
	558	wxMBConv convMem, wxMBConv convFile)
	559	{
	560	if (str.IsEmpty()) return;
	561	#if wxUSE_UNICODE
	562	const wxWX2MBbuf buf(str.mb_str(convFile ? *convFile : wxConvUTF8));
	563	stream.Write((const char)buf, strlen((const char)buf));
	564	#else
	565	if ( convFile == NULL )
	566	stream.Write(str.mb_str(), str.Len());
	567	else
	568	{
	569	wxString str2(str.wc_str(convMem), convFile);
	570	stream.Write(str2.mb_str(), str2.Len());
	571	}
	572	#endif
	573	}
	574
	575	// Same as above, but create entities first.
	576	// Translates '<' to "<", '>' to ">" and '&' to "&"
	577	static void OutputStringEnt(wxOutputStream& stream, const wxString& str,
	578	wxMBConv convMem, wxMBConv convFile)
	579	{
	580	wxString buf;
	581	size_t i, last, len;
	582	wxChar c;
	583
	584	len = str.Len();
	585	last = 0;
	586	for (i = 0; i < len; i++)
	587	{
	588	c = str.GetChar(i);
	589	if (c == wxT('<') \|\| c == wxT('>') \|\|
	590	(c == wxT('&') && str.Mid(i+1, 4) != wxT("amp;")))
	591	{
	592	OutputString(stream, str.Mid(last, i - last), convMem, convFile);
	593	switch (c)
	594	{
	595	case wxT('<'):
	596	OutputString(stream, wxT("<"), NULL, NULL);
	597	break;
	598	case wxT('>'):
	599	OutputString(stream, wxT(">"), NULL, NULL);
	600	break;
	601	case wxT('&'):
	602	OutputString(stream, wxT("&"), NULL, NULL);
	603	break;
	604	default: break;
	605	}
	606	last = i + 1;
	607	}
	608	}
	609	OutputString(stream, str.Mid(last, i - last), convMem, convFile);
	610	}
	611
	612	inline static void OutputIndentation(wxOutputStream& stream, int indent)
	613	{
	614	wxString str = wxT("\n");
	615	for (int i = 0; i < indent; i++)
	616	str << wxT(' ') << wxT(' ');
	617	OutputString(stream, str, NULL, NULL);
	618	}
	619
	620	static void OutputNode(wxOutputStream& stream, wxXmlNode *node, int indent,
	621	wxMBConv convMem, wxMBConv convFile)
	622	{
	623	wxXmlNode n, prev;
	624	wxXmlProperty *prop;
	625
	626	switch (node->GetType())
	627	{
	628	case wxXML_TEXT_NODE:
	629	OutputStringEnt(stream, node->GetContent(), convMem, convFile);
	630	break;
	631
	632	case wxXML_ELEMENT_NODE:
	633	OutputString(stream, wxT("<"), NULL, NULL);
	634	OutputString(stream, node->GetName(), NULL, NULL);
	635
	636	prop = node->GetProperties();
	637	while (prop)
	638	{
	639	OutputString(stream, wxT(" ") + prop->GetName() +
	640	wxT("=\"") + prop->GetValue() + wxT("\""),
	641	NULL, NULL);
	642	// FIXME - what if prop contains '"'?
	643	prop = prop->GetNext();
	644	}
	645
	646	if (node->GetChildren())
	647	{
	648	OutputString(stream, wxT(">"), NULL, NULL);
	649	prev = NULL;
	650	n = node->GetChildren();
	651	while (n)
	652	{
	653	if (n && n->GetType() != wxXML_TEXT_NODE)
	654	OutputIndentation(stream, indent + 1);
	655	OutputNode(stream, n, indent + 1, convMem, convFile);
	656	prev = n;
	657	n = n->GetNext();
	658	}
	659	if (prev && prev->GetType() != wxXML_TEXT_NODE)
	660	OutputIndentation(stream, indent);
	661	OutputString(stream, wxT("</"), NULL, NULL);
	662	OutputString(stream, node->GetName(), NULL, NULL);
	663	OutputString(stream, wxT(">"), NULL, NULL);
	664	}
	665	else
	666	OutputString(stream, wxT("/>"), NULL, NULL);
	667	break;
	668
	669	case wxXML_COMMENT_NODE:
	670	OutputString(stream, wxT("<!--"), NULL, NULL);
	671	OutputString(stream, node->GetContent(), convMem, convFile);
	672	OutputString(stream, wxT("-->"), NULL, NULL);
	673	break;
	674
	675	default:
	676	wxFAIL_MSG(wxT("unsupported node type"));
	677	}
	678	}
	679
	680	bool wxXmlDocument::Save(wxOutputStream& stream) const
	681	{
	682	if ( !IsOk() )
	683	return FALSE;
	684
	685	wxString s;
	686
	687	wxMBConv convMem = NULL, convFile = NULL;
	688	#if wxUSE_UNICODE
	689	convFile = new wxCSConv(GetFileEncoding());
	690	#else
	691	if ( GetFileEncoding() != GetEncoding() )
	692	{
	693	convFile = new wxCSConv(GetFileEncoding());
	694	convMem = new wxCSConv(GetEncoding());
	695	}
	696	#endif
	697
	698	s.Printf(wxT("<?xml version=\"%s\" encoding=\"%s\"?>\n"),
	699	GetVersion().c_str(), GetFileEncoding().c_str());
	700	OutputString(stream, s, NULL, NULL);
	701
	702	OutputNode(stream, GetRoot(), 0, convMem, convFile);
	703	OutputString(stream, wxT("\n"), NULL, NULL);
	704
	705	if ( convFile )
	706	delete convFile;
	707	if ( convMem )
	708	delete convMem;
	709
	710	return TRUE;
	711	}