src/xml/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
/////////////////////////////////////////////////////////////////////////////

#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "xml.h"
#endif

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

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/xml/xml.h"

#if wxUSE_XML

#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 "expat.h" // from Expat

// DLL options compatibility check:
#include "wx/app.h"
WX_CHECK_BUILD_OPTIONS("wxXML")

//-----------------------------------------------------------------------------
//  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;

    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()
    : m_version(wxT("1.0")), m_fileEncoding(wxT("utf-8")), m_root(NULL)
{
#if !wxUSE_UNICODE
    m_encoding = wxT("UTF-8");
#endif
}

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 :
                          wxConvUTF8.MB2WC((wchar_t*) NULL, s, 0);

        wchar_t *buf = new wchar_t[nLen+1];
        wxConvUTF8.MB2WC(buf, s, nLen);
        buf[nLen] = 0;
        wxString str(buf, *conv, len);
        delete[] buf;
        return str;
    }
    else
        return wxString(s, len != wxSTRING_MAXLEN ? len : strlen(s));
#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[2];
    wchar_t wcBuf[10];
    size_t i;

    mbBuf[1] = 0;
    info->map[0] = 0;
    for (i = 0; i < 255; i++)
    {
        mbBuf[0] = (char)(i+1);
        if (conv.MB2WC(wcBuf, mbBuf, 2) == (size_t)-1)
        {
            // invalid/undefined byte in the encoding:
            info->map[i+1] = -1;
        }
        info->map[i+1] = (int)wcBuf[0];
    }

    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);

    bool ok = true;
    do
    {
        size_t len = stream.Read(buf, BUFSIZE).LastRead();
        done = (len < BUFSIZE);
        if (!XML_Parse(parser, buf, len, done))
        {
            wxString error(XML_ErrorString(XML_GetErrorCode(parser)),
                           *wxConvCurrent);
            wxLogError(_("XML parsing error: '%s' at line %d"),
                       error.c_str(),
                       XML_GetCurrentLineNumber(parser));
            ok = false;
            break;
        }
    } while (!done);

    if (ok)
    {
        if (!ctx.version.IsEmpty())
            SetVersion(ctx.version);
        if (!ctx.encoding.IsEmpty())
            SetFileEncoding(ctx.encoding);
        SetRoot(ctx.root);
    }
    else
    {
        delete ctx.root;
    }

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

    return ok;

}


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

// write string to output:
inline static void OutputString(wxOutputStream& stream, const wxString& str,
#if wxUSE_UNICODE
    wxMBConv * WXUNUSED(convMem),
#else
    wxMBConv *convMem,
#endif
    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,
                            bool escapeQuotes = false)
{
    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;")) ||
            (escapeQuotes && c == wxT('"')))
        {
            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;
                case wxT('"'):
                    OutputString(stream, wxT("&quot;"), 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("=\""),
                             NULL, NULL);
                OutputStringEnt(stream, prop->GetValue(), NULL, NULL,
                                true/*escapeQuotes*/);
                OutputString(stream, wxT("\""), NULL, NULL);
                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;
}

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