xml.h

功能齐全的XML解析/生成类. 可以在Windows/WindowsCE下使用.亲自调试通过.

#ifndef _XML_H
#define _XML_H

#ifdef XML_USE_NAMESPACE
namespace XMLPP
	{
#endif
// xml.h
// v.0x144
// revision 15 - 11 - 2008
#define XML_VERSION 0x144
#define XML_VERSION_REVISION_DATE "15-11-2008"


#ifdef __unix
#define LINUX
#endif


#ifdef __BORLANDC__
#pragma warn -pck
#endif

#ifdef _MSC_VER
#define _USERENTRY __cdecl
#endif

#ifdef LINUX
#define _USERENTRY
#define __cdecl
#endif

#ifdef __WATCOMC__
#define _USERENTRY
#endif



// ANSI includes
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>

#ifdef LINUX
#include <wchar.h>
#endif

#ifdef _WIN32
#ifndef __SYMBIAN32__
#include <windows.h>
#include <commctrl.h>
#include <wininet.h>
#include <tchar.h>
#endif
#endif

#ifdef __SYMBIAN32__
#define _USERENTRY
#define strcmpi strcmp
#include <unistd.h>
#endif


#ifndef __SYMBIAN32__
#ifdef XML_USE_STL
#include <vector>
using namespace std;
#endif
#endif

#ifndef _Z_H
#define _Z_H
// Z template class
template <class T>class Z
	{
	private:

		T* d;
		size_t ss;

	public:

		Z(size_t s = 0)
			{
			if (s == 0)
				s = 1;
			d = new T[s];
			memset(d,0,s*sizeof(T));
			ss = s;
			}
		~Z()
			{
			delete[] d;
			}

		operator T*()
			{
			return d;
			}

		size_t bs()
			{
			return ss*sizeof(T);
			}

		size_t is()
			{
			return ss;
			}

		void _clear()
			{
			memset(d,0,ss*sizeof(T));
			}

		void Resize(size_t news)
			{
			if (news == ss)
				return; // same size

			// Create buffer to store existing data
			T* newd = new T[news];
			size_t newbs = news*sizeof(T);
			memset((void*)newd,0, newbs);

			if (ss < news)
				// we created a larger data structure
				memcpy((void*)newd,d,ss*sizeof(T));
			else
				// we created a smaller data structure
				memcpy((void*)newd,d,news*sizeof(T));
			delete[] d;
			d = newd;
			ss = news;
			}

		void AddResize(size_t More)
			{
			Resize(ss + More);
			}

	};
#endif // Z_H



class XMLHeader;
class XMLElement;
class XMLVariable;
class XMLComment;
class XMLContent;
class XMLCData;
class XML;

typedef struct
	{
	int VersionHigh;
	int VersionLow;
	char RDate[20];
	} XML_VERSION_INFO;


#ifdef _WIN32
struct IMPORTDBTABLEDATA
	{
	char name[256];
	char itemname[100];
	int nVariables;
	char** Variables;
	char** ReplaceVariables;
	};

struct IMPORTDBPARAMS
	{
	char* dbname;
	char* provstr;
	int nTables;
	IMPORTDBTABLEDATA* Tables;
	};
#endif

struct XMLEXPORTFORMAT
	{
	bool UseSpace;
	int nId;
	bool ElementsNoBreak;
	};

#ifdef _WIN32
struct IMPORTRKEYDATA
	{
	HKEY pK;
	int StorageType; // 0 - Native
	// 1 - Registry key from native XML
	// 2 - Registry key from registry XML
	};
#endif



// UNLOAD elements
struct XMLUNLOADELEMENT
	{
	int i;
	char* fn[300];
	};

// Enumerations
enum XML_LOAD_MODE
	{
	XML_LOAD_MODE_LOCAL_FILE = 0,
	XML_LOAD_MODE_MEMORY_BUFFER = 1,
	XML_LOAD_MODE_URL = 2,
	XML_LOAD_MODE_LOCAL_FILE_U = 7,
	};

enum XML_PARSE_STATUS
	{
	XML_PARSE_OK = 0,
	XML_PARSE_NO_HEADER = 1,
	XML_PARSE_ERROR = 2,
	};

enum XML_SAVE_MODE
	{
	XML_SAVE_MODE_ZERO = 0,
	XML_SAVE_MODE_DEFAULT = 1,
	};

enum XML_TARGET_MODE
	{
	XML_TARGET_MODE_FILE = 0,
	XML_TARGET_MODE_MEMORY = 1,
	XML_TARGET_MODE_REGISTRYKEY = 2,
	XML_TARGET_MODE_UTF16FILE = 3,
	};

// Global functions

class XML
	{
	public:

		// constructors/destructor

		XML();
		XML(const char* file,XML_LOAD_MODE LoadMode = XML_LOAD_MODE_LOCAL_FILE,class XMLTransform* eclass = 0,class XMLTransformData* edata = 0);
#ifndef LINUX
		XML(const wchar_t* file,XML_LOAD_MODE LoadMode = XML_LOAD_MODE_LOCAL_FILE,class XMLTransform* eclass = 0,class XMLTransformData* edata = 0);
#endif
		void Version(XML_VERSION_INFO*);
		size_t MemoryUsage();
		void CompressMemory();
		bool IntegrityTest();
		int Compare(XML*);

		XML(XML& x);
		XML& operator =(XML&);
		~XML();

		//      static void Kill(char* tf);
#ifdef LINUX
		int PhantomLoad(const char* file);
#else
		int PhantomLoad(const char* file,bool IsUnicode = false,bool UseMap = false);
#endif
		int PhantomElement(FILE*fp,class XMLElement* r,unsigned __int64 StartP,unsigned __int64 EndP);

		static int DoMatch(const char *text, char *p, bool IsCaseSensitive = false);
		static bool VMatching(const char *text, char *p, bool IsCaseSensitive = false);
		static bool TestMatch(const char* item1,const char* comp,const char* item2);
		static Z<char>* ReadToZ(const char*,class XMLTransform* eclass = 0,class XMLTransformData* edata = 0,bool IsU = 0);
		static int Convert2HexCharsToNumber(int c1, int c2);
		static XMLElement* Paste(char* txt = 0);

		XML_PARSE_STATUS ParseStatus(int* = 0);
		void SetUnicode(bool x);
		void SaveOnClose(bool);
		int Load(const char* data,XML_LOAD_MODE LoadMode = XML_LOAD_MODE_LOCAL_FILE,class XMLTransform* eclass = 0,class XMLTransformData* edata = 0);
		size_t LoadText(const char*);
		size_t LoadText(const wchar_t*);
		static int PartialLoad(const char* file,const char* map);
		static XMLElement * PartialElement(const char* file,const char* map);
		int Save(const char* file = 0,XML_SAVE_MODE SaveMode = XML_SAVE_MODE_DEFAULT,XML_TARGET_MODE TargetMode = XML_TARGET_MODE_FILE,class XMLTransform* eclass = 0,class XMLTransformData* edata = 0); // Default, do not encode already encoded
		void Export(FILE* fp,XML_SAVE_MODE SaveMode,XML_TARGET_MODE TargetMode = XML_TARGET_MODE_FILE,XMLHeader *hdr = 0,class XMLTransform* eclass = 0,class XMLTransformData* edata = 0);
		void SetExportFormatting(XMLEXPORTFORMAT* xf);

		void Lock(bool);
		void SetRootElement(XMLElement*);
		XMLElement* RemoveRootElementAndKeep();
		int RemoveTemporalElements();

		XMLElement* GetRootElement();
		XMLHeader* GetHeader();
		void SetHeader(XMLHeader* h);
#ifdef XML_OPTIONAL_IMPORTDB
		static XMLElement* ImportDB(IMPORTDBPARAMS* );
#endif
#ifdef XML_OPTIONAL_IMPORTRKEY
		static XMLElement* ImportRKey(IMPORTRKEYDATA*);
#endif
		static size_t XMLEncode(const char* src,char* trg);
		static size_t XMLDecode(const char* src,char* trg);
		size_t XMLGetValue(const char* section,const char* attr,char* put,size_t maxlen);
		void XMLSetValue(const char* section,const char* attr,char* put);

		// Query functions
		int XMLQuery(const char* rootsection,const char* expression,XMLElement** rv,unsigned int deep = 0xFFFFFFFF);

	private:

		void Init();
		void Clear();

		XML_PARSE_STATUS iParseStatus; // 0 Valid , 1 Error but recovered, 2 fatal error
		int iParseStatusPos;
		char* f;          // filename
#ifndef LINUX
		bool IsFileU; // unicode file
#endif
		XMLHeader* hdr;   // header (one)
		XMLElement* root; // root element (one)
		bool SOnClose;
		// For Windows


	};

#ifdef LINUX
typedef int (*fcmp) (const void *, const void *);
#endif

struct XMLBORROWELEMENT
	{
	bool Active;
	class XMLElement* x;
	};

class XMLElement
	{
	public:

		// constructors/destructor
		XMLElement(XMLElement* par,const char* el,int Type = 0,bool Temp = false);

		//XMLElement& operator =(XMLElement&);
		~XMLElement();

		XMLElement* operator[](int);
		void SetElementParam(unsigned __int64 p);
		unsigned __int64 GetElementParam();
		void Reparse(const char*el,int Type = 0);
		int GetDeep();
		int AddElement(XMLElement*);
		int AddElement(char*);
		int InsertElement(unsigned int,XMLElement*);
		int BorrowElement(XMLElement*,unsigned int = (unsigned)-1);
		int ReleaseBorrowedElements();
		int UpdateElement(XMLElement*,bool UpdateVariableValues = false);
		int FindElement(XMLElement*);
		int FindElement(const char* n);
		XMLElement* FindElementZ(XMLElement*);
		XMLElement* FindElementZ(const char* n,bool ForceCreate = false,char* el = 0,bool Temp = false);
		int RemoveElement(unsigned int i);
		int RemoveElementAndKeep(unsigned int i,XMLElement** el);
		int RemoveAllElements();
		int RemoveTemporalElements(bool Deep = false);
		int DeleteUnloadedElementFile(int i);
		int UnloadElement(unsigned int i);
		int ReloadElement(unsigned int i);
		int ReloadAllElements();
		int MoveElement(unsigned int i,unsigned int y);
#ifdef LINUX
		void SortElements(fcmp);
		void SortVariables(fcmp);
		friend int XMLElementfcmp(const void *, const void *);
		friend int XMLVariablefcmp(const void *, const void *);
#else
		void SortElements(int (_USERENTRY *fcmp)(const void *, const void *));
		void SortVariables(int (_USERENTRY *fcmp)(const void *, const void *));
		friend int _USERENTRY XMLElementfcmp(const void *, const void *);
		friend int _USERENTRY XMLVariablefcmp(const void *, const void *);
#endif
		XMLElement* Duplicate(XMLElement* = 0);
		void Copy();
		size_t MemoryUsage();
		void CompressMemory();
		bool IntegrityTest();
		int Compare(XMLElement*);

		// XMLComment