contrib/src/xml/xmlpars.cpp

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

#ifdef __GNUG__
// nothing - already in xml.cpp
#endif

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

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/wfstream.h"
#include "wx/intl.h"
#include "wx/log.h"
#include "wx/dynlib.h"
#include "wx/xml/xmlio.h"

#include <libxml/parser.h>

// dynamically loaded functions from libxml:
typedef xmlParserCtxtPtr (*type_xmlCreatePushParserCtxt)
             (xmlSAXHandlerPtr sax, void *, const char *, int, const char *);
typedef xmlNodePtr (*type_xmlNewText)(const xmlChar *);
typedef xmlAttrPtr (*type_xmlSetProp)(xmlNodePtr, const xmlChar *, const xmlChar *);
typedef int (*type_xmlParseChunk)(xmlParserCtxtPtr, const char *, int, int);
typedef void (*type_xmlFreeParserCtxt)(xmlParserCtxtPtr);
typedef xmlDocPtr (*type_xmlNewDoc)(const xmlChar *);
typedef void (*type_xmlFreeDoc)(xmlDocPtr);
typedef xmlNodePtr (*type_xmlNewDocNode)(xmlDocPtr, xmlNsPtr, const xmlChar *, const xmlChar *);
typedef void (*type_xmlDocDumpMemory)(xmlDocPtr, xmlChar**, int *);
typedef xmlNodePtr (*type_xmlAddChild)(xmlNodePtr, xmlNodePtr);
typedef xmlNodePtr (*type_xmlNewChild)(xmlNodePtr, xmlNsPtr, const xmlChar *, const xmlChar *);
typedef xmlChar * (*type_xmlNodeListGetString)(xmlDocPtr, xmlNodePtr, int);
typedef xmlNodePtr (*type_xmlDocGetRootElement)(xmlDocPtr);
typedef xmlNodePtr (*type_xmlDocSetRootElement)(xmlDocPtr doc, xmlNodePtr root);

static struct
{
    wxDllType Handle;

    type_xmlCreatePushParserCtxt xmlCreatePushParserCtxt;
    type_xmlNewText xmlNewText;
    type_xmlSetProp xmlSetProp;
    type_xmlParseChunk xmlParseChunk;
    type_xmlFreeParserCtxt xmlFreeParserCtxt;
    type_xmlNewDoc xmlNewDoc;
    type_xmlFreeDoc xmlFreeDoc;
    type_xmlNewDocNode xmlNewDocNode;
    type_xmlDocDumpMemory xmlDocDumpMemory;
    type_xmlAddChild xmlAddChild;
    type_xmlNewChild xmlNewChild;
    type_xmlNodeListGetString xmlNodeListGetString;
    type_xmlDocGetRootElement xmlDocGetRootElement;
    type_xmlDocSetRootElement xmlDocSetRootElement;
} gs_libxmlDLL;

static bool gs_libxmlLoaded = FALSE;
static bool gs_libxmlLoadFailed = FALSE;


static void ReleaseLibxml()
{
    if (gs_libxmlLoaded)
    {
        wxLogDebug("Releasing libxml.so.2");
        wxDllLoader::UnloadLibrary(gs_libxmlDLL.Handle);
    }
    gs_libxmlLoaded = FALSE;
    gs_libxmlLoadFailed = FALSE;
}


static bool LoadLibxml()
{
    if (gs_libxmlLoaded) return TRUE;
    if (gs_libxmlLoadFailed) return FALSE;
    gs_libxmlLoadFailed = TRUE;

    wxLogDebug("Loading libxml.so.2...");
#ifdef __UNIX__
    gs_libxmlDLL.Handle =
        wxDllLoader::LoadLibrary(_T("libxml.so.2"), &gs_libxmlLoaded);
#endif

    if (!gs_libxmlLoaded) return FALSE;

#define LOAD_SYMBOL(sym) \
    gs_libxmlDLL.sym = \
        (type_##sym)wxDllLoader::GetSymbol(gs_libxmlDLL.Handle, _T(#sym)); \
    if (!gs_libxmlDLL.sym) { ReleaseLibxml(); return FALSE; }

    LOAD_SYMBOL(xmlCreatePushParserCtxt)
    LOAD_SYMBOL(xmlNewText)
    LOAD_SYMBOL(xmlSetProp)
    LOAD_SYMBOL(xmlParseChunk)
    LOAD_SYMBOL(xmlFreeParserCtxt)
    LOAD_SYMBOL(xmlNewDoc)
    LOAD_SYMBOL(xmlFreeDoc)
    LOAD_SYMBOL(xmlNewDocNode)
    LOAD_SYMBOL(xmlDocDumpMemory)
    LOAD_SYMBOL(xmlAddChild)
    LOAD_SYMBOL(xmlNewChild)
    LOAD_SYMBOL(xmlNodeListGetString)
    LOAD_SYMBOL(xmlDocGetRootElement)
    LOAD_SYMBOL(xmlDocSetRootElement)

#undef LOAD_SYMBOL

    gs_libxmlLoadFailed = FALSE;

    wxLogDebug("...succeed");
    return TRUE;
}


bool wxXmlIOHandlerLibxml::CanLoad(wxInputStream& stream)
{
    if (!LoadLibxml()) return FALSE;
    char cheader[7];
    cheader[6] = 0;
    stream.Read(cheader, 6);
    stream.SeekI(-6, wxFromCurrent);
    return strcmp(cheader, "<?xml ") == 0;
}


bool wxXmlIOHandlerLibxml::CanSave()
{
    return LoadLibxml();
}


static wxXmlProperty *CreateWXProperty(xmlDocPtr doc, xmlAttrPtr attr)
{
    if (attr == NULL) return NULL;

    unsigned char *val =
        gs_libxmlDLL.xmlNodeListGetString(doc, attr->children, 1);
    wxXmlProperty *prop =
        new wxXmlProperty(attr->name, val, CreateWXProperty(doc, attr->next));
    free(val);
    return prop;
}


static wxXmlNode *CreateWXNode(xmlDocPtr doc, wxXmlNode *parent, xmlNodePtr node)
{
    if (node == NULL) return NULL;

    wxXmlNode *nd = new wxXmlNode(parent, (wxXmlNodeType)node->type,
                          node->name, node->content,
                          CreateWXProperty(doc, node->properties),
                          CreateWXNode(doc, parent, node->next));
    CreateWXNode(doc, nd, node->children);
    return nd;
}


bool wxXmlIOHandlerLibxml::Load(wxInputStream& stream, wxXmlDocument& doc)
{
    if (!LoadLibxml()) return FALSE;

    xmlDocPtr dc;
    xmlParserCtxtPtr ctxt;

    char buffer[1024];
    int  res;

    res = stream.Read(buffer, 4).LastRead();
    if (res > 0)
    {
        bool okay = TRUE;
        ctxt = gs_libxmlDLL.xmlCreatePushParserCtxt(NULL, NULL,
                                               buffer, res, ""/*docname*/);
        while ((res = stream.Read(buffer, 1024).LastRead()) > 0)
            if (gs_libxmlDLL.xmlParseChunk(ctxt, buffer, res, 0) != 0)
               okay = FALSE;
        if (gs_libxmlDLL.xmlParseChunk(ctxt, buffer, 0, 1) != 0) okay = FALSE;
        dc = ctxt->myDoc;
        gs_libxmlDLL.xmlFreeParserCtxt(ctxt);

        doc.SetVersion(dc->version);
        doc.SetEncoding(dc->encoding);
        doc.SetRoot(CreateWXNode(dc, NULL, gs_libxmlDLL.xmlDocGetRootElement(dc)));

        gs_libxmlDLL.xmlFreeDoc(dc);

        return okay;
    }
    else return FALSE;
}


static void CreateLibxmlNode(xmlNodePtr node, wxXmlNode *wxnode)
{
    node->type = (xmlElementType)wxnode->GetType();

    wxXmlProperty *prop = wxnode->GetProperties();
    while (prop)
    {
        gs_libxmlDLL.xmlSetProp(node, (xmlChar*)prop->GetName().mb_str(),
                         (xmlChar*)prop->GetValue().mb_str());
        prop = prop->GetNext();
    }

    wxXmlNode *child = wxnode->GetChildren();
    xmlNodePtr n;
    xmlChar *content, *name;

    while (child)
    {
        name = (xmlChar*)child->GetName().mb_str();
        if (!child->GetContent()) content = NULL;
        else content = (xmlChar*)child->GetContent().mb_str();
        if (child->GetType() == wxXML_TEXT_NODE)
            gs_libxmlDLL.xmlAddChild(node, n = gs_libxmlDLL.xmlNewText(content));
        else
            n = gs_libxmlDLL.xmlNewChild(node, NULL, name, content);
        CreateLibxmlNode(n, child);
        child = child->GetNext();
    }
}


bool wxXmlIOHandlerLibxml::Save(wxOutputStream& stream, const wxXmlDocument& doc)
{
    if (!LoadLibxml()) return FALSE;

    xmlDocPtr dc;

    wxASSERT_MSG(doc.GetRoot() != NULL, _("Trying to save empty document!"));

    dc = gs_libxmlDLL.xmlNewDoc((xmlChar*)doc.GetVersion().mb_str());

    gs_libxmlDLL.xmlDocSetRootElement(dc,
         gs_libxmlDLL.xmlNewDocNode(dc, NULL,
                        (xmlChar*)doc.GetRoot()->GetName().mb_str(), NULL));
    CreateLibxmlNode(gs_libxmlDLL.xmlDocGetRootElement(dc), doc.GetRoot());

    xmlChar *buffer;
    int size;

    gs_libxmlDLL.xmlDocDumpMemory(dc, &buffer, &size);
    gs_libxmlDLL.xmlFreeDoc(dc);
    stream.Write(buffer, size);
    free(buffer);
    return stream.LastWrite() == (unsigned)size;
}


#include "wx/module.h"

class wxXmlLibxmlModule: public wxModule
{
    DECLARE_DYNAMIC_CLASS(wxXmlLibxmlModule)
    public:
        wxXmlLibxmlModule() {}
        bool OnInit() { return TRUE; }
        void OnExit() { ReleaseLibxml(); }
};

IMPLEMENT_DYNAMIC_CLASS(wxXmlLibxmlModule, wxModule)
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: xmlpars.cpp
	3	// Purpose: wxXmlDocument - XML parser
	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	// nothing - already in xml.cpp
	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/wfstream.h"
	23	#include "wx/intl.h"
	24	#include "wx/log.h"
	25	#include "wx/dynlib.h"
	26	#include "wx/xml/xmlio.h"
	27
	28	#include <libxml/parser.h>
	29
	30	// dynamically loaded functions from libxml:
	31	typedef xmlParserCtxtPtr (*type_xmlCreatePushParserCtxt)
	32	(xmlSAXHandlerPtr sax, void , const char , int, const char *);
	33	typedef xmlNodePtr (type_xmlNewText)(const xmlChar );
	34	typedef xmlAttrPtr (type_xmlSetProp)(xmlNodePtr, const xmlChar , const xmlChar *);
	35	typedef int (type_xmlParseChunk)(xmlParserCtxtPtr, const char , int, int);
	36	typedef void (*type_xmlFreeParserCtxt)(xmlParserCtxtPtr);
	37	typedef xmlDocPtr (type_xmlNewDoc)(const xmlChar );
	38	typedef void (*type_xmlFreeDoc)(xmlDocPtr);
	39	typedef xmlNodePtr (type_xmlNewDocNode)(xmlDocPtr, xmlNsPtr, const xmlChar , const xmlChar *);
	40	typedef void (type_xmlDocDumpMemory)(xmlDocPtr, xmlChar, int );
	41	typedef xmlNodePtr (*type_xmlAddChild)(xmlNodePtr, xmlNodePtr);
	42	typedef xmlNodePtr (type_xmlNewChild)(xmlNodePtr, xmlNsPtr, const xmlChar , const xmlChar *);
	43	typedef xmlChar * (*type_xmlNodeListGetString)(xmlDocPtr, xmlNodePtr, int);
	44	typedef xmlNodePtr (*type_xmlDocGetRootElement)(xmlDocPtr);
	45	typedef xmlNodePtr (*type_xmlDocSetRootElement)(xmlDocPtr doc, xmlNodePtr root);
	46
	47	static struct
	48	{
	49	wxDllType Handle;
	50
	51	type_xmlCreatePushParserCtxt xmlCreatePushParserCtxt;
	52	type_xmlNewText xmlNewText;
	53	type_xmlSetProp xmlSetProp;
	54	type_xmlParseChunk xmlParseChunk;
	55	type_xmlFreeParserCtxt xmlFreeParserCtxt;
	56	type_xmlNewDoc xmlNewDoc;
	57	type_xmlFreeDoc xmlFreeDoc;
	58	type_xmlNewDocNode xmlNewDocNode;
	59	type_xmlDocDumpMemory xmlDocDumpMemory;
	60	type_xmlAddChild xmlAddChild;
	61	type_xmlNewChild xmlNewChild;
	62	type_xmlNodeListGetString xmlNodeListGetString;
	63	type_xmlDocGetRootElement xmlDocGetRootElement;
	64	type_xmlDocSetRootElement xmlDocSetRootElement;
	65	} gs_libxmlDLL;
	66
	67	static bool gs_libxmlLoaded = FALSE;
	68	static bool gs_libxmlLoadFailed = FALSE;
	69
	70
	71
	72	static void ReleaseLibxml()
	73	{
	74	if (gs_libxmlLoaded)
	75	{
	76	wxLogDebug("Releasing libxml.so.2");
	77	wxDllLoader::UnloadLibrary(gs_libxmlDLL.Handle);
	78	}
	79	gs_libxmlLoaded = FALSE;
	80	gs_libxmlLoadFailed = FALSE;
	81	}
	82
	83
	84	static bool LoadLibxml()
	85	{
	86	if (gs_libxmlLoaded) return TRUE;
	87	if (gs_libxmlLoadFailed) return FALSE;
	88	gs_libxmlLoadFailed = TRUE;
	89
	90	wxLogDebug("Loading libxml.so.2...");
	91	#ifdef __UNIX__
	92	gs_libxmlDLL.Handle =
	93	wxDllLoader::LoadLibrary(_T("libxml.so.2"), &gs_libxmlLoaded);
	94	#endif
	95
	96	if (!gs_libxmlLoaded) return FALSE;
	97
	98	#define LOAD_SYMBOL(sym) \
	99	gs_libxmlDLL.sym = \
	100	(type_##sym)wxDllLoader::GetSymbol(gs_libxmlDLL.Handle, _T(#sym)); \
	101	if (!gs_libxmlDLL.sym) { ReleaseLibxml(); return FALSE; }
	102
	103	LOAD_SYMBOL(xmlCreatePushParserCtxt)
	104	LOAD_SYMBOL(xmlNewText)
	105	LOAD_SYMBOL(xmlSetProp)
	106	LOAD_SYMBOL(xmlParseChunk)
	107	LOAD_SYMBOL(xmlFreeParserCtxt)
	108	LOAD_SYMBOL(xmlNewDoc)
	109	LOAD_SYMBOL(xmlFreeDoc)
	110	LOAD_SYMBOL(xmlNewDocNode)
	111	LOAD_SYMBOL(xmlDocDumpMemory)
	112	LOAD_SYMBOL(xmlAddChild)
	113	LOAD_SYMBOL(xmlNewChild)
	114	LOAD_SYMBOL(xmlNodeListGetString)
	115	LOAD_SYMBOL(xmlDocGetRootElement)
	116	LOAD_SYMBOL(xmlDocSetRootElement)
	117
	118	#undef LOAD_SYMBOL
	119
	120	gs_libxmlLoadFailed = FALSE;
	121
	122	wxLogDebug("...succeed");
	123	return TRUE;
	124	}
	125
	126
	127
	128
	129	bool wxXmlIOHandlerLibxml::CanLoad(wxInputStream& stream)
	130	{
	131	if (!LoadLibxml()) return FALSE;
	132	char cheader[7];
	133	cheader[6] = 0;
	134	stream.Read(cheader, 6);
	135	stream.SeekI(-6, wxFromCurrent);
	136	return strcmp(cheader, "<?xml ") == 0;
	137	}
	138
	139
	140
	141	bool wxXmlIOHandlerLibxml::CanSave()
	142	{
	143	return LoadLibxml();
	144	}
	145
	146
	147
	148	static wxXmlProperty *CreateWXProperty(xmlDocPtr doc, xmlAttrPtr attr)
	149	{
	150	if (attr == NULL) return NULL;
	151
	152	unsigned char *val =
	153	gs_libxmlDLL.xmlNodeListGetString(doc, attr->children, 1);
	154	wxXmlProperty *prop =
	155	new wxXmlProperty(attr->name, val, CreateWXProperty(doc, attr->next));
	156	free(val);
	157	return prop;
	158	}
	159
	160
	161
	162	static wxXmlNode CreateWXNode(xmlDocPtr doc, wxXmlNode parent, xmlNodePtr node)
	163	{
	164	if (node == NULL) return NULL;
	165
	166	wxXmlNode *nd = new wxXmlNode(parent, (wxXmlNodeType)node->type,
	167	node->name, node->content,
	168	CreateWXProperty(doc, node->properties),
	169	CreateWXNode(doc, parent, node->next));
	170	CreateWXNode(doc, nd, node->children);
	171	return nd;
	172	}
	173
	174
	175
	176	bool wxXmlIOHandlerLibxml::Load(wxInputStream& stream, wxXmlDocument& doc)
	177	{
	178	if (!LoadLibxml()) return FALSE;
	179
	180	xmlDocPtr dc;
	181	xmlParserCtxtPtr ctxt;
	182
	183	char buffer[1024];
	184	int res;
	185
	186	res = stream.Read(buffer, 4).LastRead();
	187	if (res > 0)
	188	{
	189	bool okay = TRUE;
	190	ctxt = gs_libxmlDLL.xmlCreatePushParserCtxt(NULL, NULL,
	191	buffer, res, ""/docname/);
	192	while ((res = stream.Read(buffer, 1024).LastRead()) > 0)
	193	if (gs_libxmlDLL.xmlParseChunk(ctxt, buffer, res, 0) != 0)
	194	okay = FALSE;
	195	if (gs_libxmlDLL.xmlParseChunk(ctxt, buffer, 0, 1) != 0) okay = FALSE;
	196	dc = ctxt->myDoc;
	197	gs_libxmlDLL.xmlFreeParserCtxt(ctxt);
	198
	199	doc.SetVersion(dc->version);
	200	doc.SetEncoding(dc->encoding);
	201	doc.SetRoot(CreateWXNode(dc, NULL, gs_libxmlDLL.xmlDocGetRootElement(dc)));
	202
	203	gs_libxmlDLL.xmlFreeDoc(dc);
	204
	205	return okay;
	206	}
	207	else return FALSE;
	208	}
	209
	210
	211
	212	static void CreateLibxmlNode(xmlNodePtr node, wxXmlNode *wxnode)
	213	{
	214	node->type = (xmlElementType)wxnode->GetType();
	215
	216	wxXmlProperty *prop = wxnode->GetProperties();
	217	while (prop)
	218	{
	219	gs_libxmlDLL.xmlSetProp(node, (xmlChar*)prop->GetName().mb_str(),
	220	(xmlChar*)prop->GetValue().mb_str());
	221	prop = prop->GetNext();
	222	}
	223
	224	wxXmlNode *child = wxnode->GetChildren();
	225	xmlNodePtr n;
	226	xmlChar content, name;
	227
	228	while (child)
	229	{
	230	name = (xmlChar*)child->GetName().mb_str();
	231	if (!child->GetContent()) content = NULL;
	232	else content = (xmlChar*)child->GetContent().mb_str();
	233	if (child->GetType() == wxXML_TEXT_NODE)
	234	gs_libxmlDLL.xmlAddChild(node, n = gs_libxmlDLL.xmlNewText(content));
	235	else
	236	n = gs_libxmlDLL.xmlNewChild(node, NULL, name, content);
	237	CreateLibxmlNode(n, child);
	238	child = child->GetNext();
	239	}
	240	}
	241
	242
	243
	244	bool wxXmlIOHandlerLibxml::Save(wxOutputStream& stream, const wxXmlDocument& doc)
	245	{
	246	if (!LoadLibxml()) return FALSE;
	247
	248	xmlDocPtr dc;
	249
	250	wxASSERT_MSG(doc.GetRoot() != NULL, _("Trying to save empty document!"));
	251
	252	dc = gs_libxmlDLL.xmlNewDoc((xmlChar*)doc.GetVersion().mb_str());
	253
	254	gs_libxmlDLL.xmlDocSetRootElement(dc,
	255	gs_libxmlDLL.xmlNewDocNode(dc, NULL,
	256	(xmlChar*)doc.GetRoot()->GetName().mb_str(), NULL));
	257	CreateLibxmlNode(gs_libxmlDLL.xmlDocGetRootElement(dc), doc.GetRoot());
	258
	259	xmlChar *buffer;
	260	int size;
	261
	262	gs_libxmlDLL.xmlDocDumpMemory(dc, &buffer, &size);
	263	gs_libxmlDLL.xmlFreeDoc(dc);
	264	stream.Write(buffer, size);
	265	free(buffer);
	266	return stream.LastWrite() == (unsigned)size;
	267	}
	268
	269
	270
	271
	272	#include "wx/module.h"
	273
	274	class wxXmlLibxmlModule: public wxModule
	275	{
	276	DECLARE_DYNAMIC_CLASS(wxXmlLibxmlModule)
	277	public:
	278	wxXmlLibxmlModule() {}
	279	bool OnInit() { return TRUE; }
	280	void OnExit() { ReleaseLibxml(); }
	281	};
	282
	283	IMPLEMENT_DYNAMIC_CLASS(wxXmlLibxmlModule, wxModule)