Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

xmlParser.cpp @ 2197

Revision 2197, 91.2 KB checked in by szirmay, 18 years ago (diff)

Line
1	#include "dxstdafx.h"
2	/**
3	****************************************************************************
4	* <P> XML.c - implementation file for basic XML parser written in ANSI C++
5	* for portability. It works by using recursion and a node tree for breaking
6	* down the elements of an XML document. </P>
7	*
8	* @version V2.20
9	* @author Frank Vanden Bergh²en
10	*
11	* NOTE:
12	*
13	* If you add "#define STRICT_PARSING", on the first line of this file
14	* the parser will see the following XML-stream:
15	* <a><b>some text</b><b>other text </a>
16	* as an error. Otherwise, this tring will be equivalent to:
17	* <a><b>some text</b><b>other text</b></a>
18	*
19	* NOTE:
20	*
21	* If you add "#define APPROXIMATE_PARSING" on the first line of this file
22	* the parser will see the following XML-stream:
23	* <data name="n1">
24	* <data name="n2">
25	* <data name="n3" />
26	* as equivalent to the following XML-stream:
27	* <data name="n1" />
28	* <data name="n2" />
29	* <data name="n3" />
30	* This can be useful for badly-formed XML-streams but prevent the use
31	* of the following XML-stream (problem is: tags at contiguous levels
32	* have the same names):
33	* <data name="n1">
34	* <data name="n2">
35	* <data name="n3" />
36	* </data>
37	* </data>
38	*
39	* NOTE:
40	*
41	* If you add "#define _XMLPARSER_NO_MESSAGEBOX_" on the first line of this file
42	* the "openFileHelper" function will always display error messages inside the
43	* console instead of inside a message-box-window. Message-box-windows are
44	* available on windows 9x/NT/2000/XP/Vista only.
45	*
46	* BSD license:
47	* Copyright (c) 2002, Frank Vanden Berghen
48	* All rights reserved.
49	* Redistribution and use in source and binary forms, with or without
50	* modification, are permitted provided that the following conditions are met:
51	*
52	* * Redistributions of source code must retain the above copyright
53	* notice, this list of conditions and the following disclaimer.
54	* * Redistributions in binary form must reproduce the above copyright
55	* notice, this list of conditions and the following disclaimer in the
56	* documentation and/or other materials provided with the distribution.
57	* * Neither the name of the Frank Vanden Berghen nor the
58	* names of its contributors may be used to endorse or promote products
59	* derived from this software without specific prior written permission.
60	*
61	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
62	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
63	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
64	* DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
65	* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
66	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
67	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
68	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
69	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
70	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
71	*
72	****************************************************************************
73	*/
74	#ifndef _CRT_SECURE_NO_DEPRECATE
75	#define _CRT_SECURE_NO_DEPRECATE
76	#endif
77	#include "xmlParser.h"
78	#ifdef _XMLWINDOWS
79	//#ifdef _DEBUG
80	//#define _CRTDBG_MAP_ALLOC
81	//#include <crtdbg.h>
82	//#endif
83	#define WIN32_LEAN_AND_MEAN
84	#include <Windows.h> // to have IsTextUnicode, MultiByteToWideChar, WideCharToMultiByte to handle unicode files
85	// to have "MessageBoxA" to display error messages for openFilHelper
86	#endif
87
88	#include <memory.h>
89	#include <assert.h>
90	#include <stdio.h>
91	#include <string.h>
92	#include <stdlib.h>
93
94	LPCTSTR XMLNode::getVersion() { return _T("v2.20"); }
95	void free_XMLDLL(void *t){free(t);}
96
97	static char strictUTF8Parsing=1, guessUnicodeChars=1, dropWhiteSpace=1;
98
99	inline int mmin( const int t1, const int t2 ) { return t1 < t2 ? t1 : t2; }
100
101	// You can modify the initialization of the variable "XMLClearTags" below
102	// to change the clearTags that are currently recognized by the library.
103	// The number on the second columns is the length of the string inside the
104	// first column. The "<!DOCTYPE" declaration must be the second in the list.
105	static ALLXMLClearTag XMLClearTags[] =
106	{
107	{ _T("<![CDATA["),9, _T("]]>") },
108	{ _T("<!DOCTYPE"),9, _T(">") },
109	{ _T("<PRE>") ,5, _T("</PRE>") },
110	{ _T("<Script>") ,8, _T("</Script>")},
111	{ _T("<!--") ,4, _T("-->") },
112	{ NULL ,0, NULL }
113	};
114	ALLXMLClearTag* XMLNode::getClearTagTable() { return XMLClearTags; }
115
116	// You can modify the initialization of the variable "XMLEntities" below
117	// to change the character entities that are currently recognized by the library.
118	// The number on the second columns is the length of the string inside the
119	// first column. Additionally, the syntaxes " " and " " are recognized.
120	typedef struct { XMLCSTR s; int l; XMLCHAR c;} XMLCharacterEntity;
121	static XMLCharacterEntity XMLEntities[] =
122	{
123	{ _T("&" ), 5, _T('&' )},
124	{ _T("<" ), 4, _T('<' )},
125	{ _T(">" ), 4, _T('>' )},
126	{ _T("""), 6, _T('\"')},
127	{ _T("'"), 6, _T('\'')},
128	{ NULL , 0, '\0' }
129	};
130
131	// When rendering the XMLNode to a string (using the "createXMLString" function),
132	// you can ask for a beautiful formatting. This formatting is using the
133	// following indentation character:
134	#define INDENTCHAR _T('\t')
135
136	// The following function parses the XML errors into a user friendly string.
137	// You can edit this to change the output language of the library to something else.
138	XMLCSTR XMLNode::getError(XMLError xerror)
139	{
140	switch (xerror)
141	{
142	case eXMLErrorNone: return _T("No error");
143	case eXMLErrorMissingEndTag: return _T("Warning: Unmatched end tag");
144	case eXMLErrorEmpty: return _T("Error: No XML data");
145	case eXMLErrorFirstNotStartTag: return _T("Error: First token not start tag");
146	case eXMLErrorMissingTagName: return _T("Error: Missing start tag name");
147	case eXMLErrorMissingEndTagName: return _T("Error: Missing end tag name");
148	case eXMLErrorNoMatchingQuote: return _T("Error: Unmatched quote");
149	case eXMLErrorUnmatchedEndTag: return _T("Error: Unmatched end tag");
150	case eXMLErrorUnmatchedEndClearTag: return _T("Error: Unmatched clear tag end");
151	case eXMLErrorUnexpectedToken: return _T("Error: Unexpected token found");
152	case eXMLErrorInvalidTag: return _T("Error: Invalid tag found");
153	case eXMLErrorNoElements: return _T("Error: No elements found");
154	case eXMLErrorFileNotFound: return _T("Error: File not found");
155	case eXMLErrorFirstTagNotFound: return _T("Error: First Tag not found");
156	case eXMLErrorUnknownCharacterEntity:return _T("Error: Unknown character entity");
157	case eXMLErrorCharConversionError: return _T("Error: unable to convert between UNICODE and MultiByte chars");
158	case eXMLErrorCannotOpenWriteFile: return _T("Error: unable to open file for writing");
159	case eXMLErrorCannotWriteFile: return _T("Error: cannot write into file");
160
161	case eXMLErrorBase64DataSizeIsNotMultipleOf4: return _T("Warning: Base64-string length is not a multiple of 4");
162	case eXMLErrorBase64DecodeTruncatedData: return _T("Warning: Base64-string is truncated");
163	case eXMLErrorBase64DecodeIllegalCharacter: return _T("Error: Base64-string contains an illegal character");
164	case eXMLErrorBase64DecodeBufferTooSmall: return _T("Error: Base64 decode output buffer is too small");
165	};
166	return _T("Unknown");
167	}
168
169	// Here is an abstraction layer to access some common string manipulation functions.
170	// The abstraction layer is currently working for gcc, Microsoft Visual Studio 6.0,
171	// Microsoft Visual Studio .NET, CC (sun compiler) and Borland C++.
172	// If you plan to "port" the library to a new system/compiler, all you have to do is
173	// to edit the following lines.
174	#ifdef XML_NO_WIDE_CHAR
175	char myIsTextUnicode(const void *b, int len) { return FALSE; }
176	#else
177	#if defined (UNDER_CE) \|\| !defined(WIN32)
178	char myIsTextUnicode(const void *b, int len) // inspired by the Wine API: RtlIsTextUnicode
179	{
180	const wchar_t s=(const wchar_t)b;
181
182	// buffer too small:
183	if (len<(int)sizeof(wchar_t)) return FALSE;
184
185	// odd length test
186	if (len&1) return FALSE;
187
188	/* only checks the first 256 characters */
189	len=mmin(256,len/sizeof(wchar_t));
190
191	// Check for the special byte order:
192	if (*s == 0xFFFE) return FALSE; // IS_TEXT_UNICODE_REVERSE_SIGNATURE;
193	if (*s == 0xFEFF) return TRUE; // IS_TEXT_UNICODE_SIGNATURE
194
195	// checks for ASCII characters in the UNICODE stream
196	int i,stats=0;
197	for (i=0; i<len; i++) if (s[i]<=(unsigned short)255) stats++;
198	if (stats>len/2) return TRUE;
199
200	// Check for UNICODE NULL chars
201	for (i=0; i<len; i++) if (!s[i]) return TRUE;
202
203	return FALSE;
204	}
205	#else
206	char myIsTextUnicode(const void *b,int l) { return (char)IsTextUnicode((CONST LPVOID)b,l,NULL); };
207	#endif
208	#endif
209
210	#ifdef _XMLWINDOWS
211	// for Microsoft Visual Studio 6.0 and Microsoft Visual Studio .NET,
212	#ifdef _XMLUNICODE
213	wchar_t myMultiByteToWideChar(const char s,int l)
214	{
215	int i;
216	if (strictUTF8Parsing) i=(int)MultiByteToWideChar(CP_UTF8,0 ,s,l,NULL,0);
217	else i=(int)MultiByteToWideChar(CP_ACP ,MB_PRECOMPOSED,s,l,NULL,0);
218	if (i<0) return NULL;
219	wchar_t d=(wchar_t )malloc((i+1)*sizeof(XMLCHAR));
220	if (strictUTF8Parsing) i=(int)MultiByteToWideChar(CP_UTF8,0 ,s,l,d,i);
221	else i=(int)MultiByteToWideChar(CP_ACP ,MB_PRECOMPOSED,s,l,d,i);
222	d[i]=0;
223	return d;
224	}
225	#else
226	char myWideCharToMultiByte(const wchar_t s,int l)
227	{
228	UINT codePage=CP_ACP; if (strictUTF8Parsing) codePage=CP_UTF8;
229	int i=(int)WideCharToMultiByte(codePage, // code page
230	0, // performance and mapping flags
231	s, // wide-character string
232	l, // number of chars in string
233	NULL, // buffer for new string
234	0, // size of buffer
235	NULL, // default for unmappable chars
236	NULL // set when default char used
237	);
238	if (i<0) return NULL;
239	char d=(char)malloc(i+1);
240	WideCharToMultiByte(codePage, // code page
241	0, // performance and mapping flags
242	s, // wide-character string
243	l, // number of chars in string
244	d, // buffer for new string
245	i, // size of buffer
246	NULL, // default for unmappable chars
247	NULL // set when default char used
248	);
249	d[i]=0;
250	return d;
251	}
252	#endif
253	#ifdef __BORLANDC__
254	int _strnicmp(char c1, char c2, int l){ return strnicmp(c1,c2,l);}
255	#endif
256	#else
257	// for gcc and CC
258	#ifdef XML_NO_WIDE_CHAR
259	char myWideCharToMultiByte(const wchar_t s, int l) { return NULL; }
260	#else
261	char myWideCharToMultiByte(const wchar_t s, int l)
262	{
263	const wchar_t *ss=s;
264	int i=(int)wcsrtombs(NULL,&ss,0,NULL);
265	if (i<0) return NULL;
266	char d=(char )malloc(i+1);
267	wcsrtombs(d,&s,i,NULL);
268	d[i]=0;
269	return d;
270	}
271	#endif
272	#ifdef _XMLUNICODE
273	wchar_t myMultiByteToWideChar(const char s, int l)
274	{
275	const char *ss=s;
276	int i=(int)mbsrtowcs(NULL,&ss,0,NULL);
277	if (i<0) return NULL;
278	wchar_t d=(wchar_t )malloc((i+1)*sizeof(wchar_t));
279	mbsrtowcs(d,&s,l,NULL);
280	d[i]=0;
281	return d;
282	}
283	int _tcslen(XMLCSTR c) { return wcslen(c); }
284	#ifdef sun
285	// for CC
286	#include <widec.h>
287	int _tcsnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return wsncasecmp(c1,c2,l);}
288	int _tcsicmp(XMLCSTR c1, XMLCSTR c2) { return wscasecmp(c1,c2); }
289	#else
290	// for gcc
291	int _tcsnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return wcsncasecmp(c1,c2,l);}
292	int _tcsicmp(XMLCSTR c1, XMLCSTR c2) { return wcscasecmp(c1,c2); }
293	#endif
294	XMLSTR _tcsstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)wcsstr(c1,c2); }
295	XMLSTR _tcscpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)wcscpy(c1,c2); }
296	FILE *_tfopen(XMLCSTR filename,XMLCSTR mode)
297	{
298	char *filenameAscii=myWideCharToMultiByte(filename,0);
299	FILE *f;
300	if (mode[0]==_T('r')) f=fopen(filenameAscii,"rb");
301	else f=fopen(filenameAscii,"wb");
302	free(filenameAscii);
303	return f;
304	}
305	#else
306	FILE *_tfopen(XMLCSTR filename,XMLCSTR mode) { return fopen(filename,mode); }
307	int _tcslen(XMLCSTR c) { return strlen(c); }
308	int _tcsnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return strncasecmp(c1,c2,l);}
309	int _tcsicmp(XMLCSTR c1, XMLCSTR c2) { return strcasecmp(c1,c2); }
310	XMLSTR _tcsstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)strstr(c1,c2); }
311	XMLSTR _tcscpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)strcpy(c1,c2); }
312	#endif
313	int _strnicmp(const char c1,const char c2, int l) { return strncasecmp(c1,c2,l);}
314	#endif
315
316	/////////////////////////////////////////////////////////////////////////
317	// Here start the core implementation of the XMLParser library //
318	/////////////////////////////////////////////////////////////////////////
319
320	// You should normally not change anything below this point.
321	// For your own information, I suggest that you read the openFileHelper below:
322	XMLNode XMLNode::openFileHelper(XMLCSTR filename, XMLCSTR tag)
323	{
324	// guess the value of the global parameter "strictUTF8Parsing"
325	// (the guess is based on the first 200 bytes of the file).
326	FILE *f=_tfopen(filename,_T("rb"));
327	if (f)
328	{
329	char bb[205];
330	int l=(int)fread(bb,1,200,f);
331	setGlobalOptions(guessUnicodeChars,guessUTF8ParsingParameterValue(bb,l),dropWhiteSpace);
332	fclose(f);
333	}
334
335	// parse the file
336	XMLResults pResults;
337	XMLNode xnode=XMLNode::parseFile(filename,tag,&pResults);
338
339	// display error message (if any)
340	if (pResults.error != eXMLErrorNone)
341	{
342	// create message
343	char message[2000],s1=(char)"",s3=(char)""; XMLCSTR s2=_T("");
344	if (pResults.error==eXMLErrorFirstTagNotFound) { s1=(char)"First Tag should be '"; s2=tag; s3=(char)"'.\n"; }
345	sprintf(message,
346	#ifdef _XMLUNICODE
347	"XML Parsing error inside file '%S'.\n%S\nAt line %i, column %i.\n%s%S%s"
348	#else
349	"XML Parsing error inside file '%s'.\n%s\nAt line %i, column %i.\n%s%s%s"
350	#endif
351	,filename,XMLNode::getError(pResults.error),pResults.nLine,pResults.nColumn,s1,s2,s3);
352
353	// display message
354	#if defined(WIN32) && !defined(UNDER_CE) && !defined(_XMLPARSER_NO_MESSAGEBOX_)
355	MessageBoxA(NULL,message,"XML Parsing error",MB_OK\|MB_ICONERROR\|MB_TOPMOST);
356	#else
357	printf("%s",message);
358	#endif
359	exit(255);
360	}
361	return xnode;
362	}
363
364	#ifndef _XMLUNICODE
365	// If "strictUTF8Parsing=0" then we assume that all characters have the same length of 1 byte.
366	// If "strictUTF8Parsing=1" then the characters have different lengths (from 1 byte to 4 bytes).
367	// This table is used as lookup-table to know the length of a character (in byte) based on the
368	// content of the first byte of the character.
369	// (note: if you modify this, you must always have XML_utf8ByteTable[0]=0 ).
370	static const char XML_utf8ByteTable[256] =
371	{
372	// 0 1 2 3 4 5 6 7 8 9 a b c d e f
373	0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x00
374	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x10
375	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x20
376	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x30
377	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x40
378	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x50
379	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x60
380	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x70End of ASCII range
381	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x80 0x80 to 0xc1 invalid
382	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x90
383	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xa0
384	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xb0
385	1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xc0 0xc2 to 0xdf 2 byte
386	2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xd0
387	3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,// 0xe0 0xe0 to 0xef 3 byte
388	4,4,4,4,4,1,1,1,1,1,1,1,1,1,1,1 // 0xf0 0xf0 to 0xf4 4 byte, 0xf5 and higher invalid
389	};
390	static const char XML_asciiByteTable[256] =
391	{
392	0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
393	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
394	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
395	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
396	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
397	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
398	};
399	static const char XML_ByteTable=(const char )XML_utf8ByteTable; // the default is "strictUTF8Parsing=1"
400	#endif
401
402	XMLError XMLNode::writeToFile(XMLCSTR filename, const char *encoding, char nFormat) const
403	{
404	int i;
405	XMLSTR t=createXMLString(nFormat,&i);
406	FILE *f=_tfopen(filename,_T("wb"));
407	if (!f) return eXMLErrorCannotOpenWriteFile;
408	#ifdef _XMLUNICODE
409	unsigned char h[2]={ 0xFF, 0xFE };
410	if (!fwrite(h,2,1,f)) return eXMLErrorCannotWriteFile;
411	if (!isDeclaration())
412	{
413	if (!fwrite(_T("<?xml version=\"1.0\" encoding=\"utf-16\"?>\n"),sizeof(wchar_t)*40,1,f))
414	return eXMLErrorCannotWriteFile;
415	}
416	#else
417	if (!isDeclaration())
418	{
419	if ((!encoding)\|\|(XML_ByteTable==XML_utf8ByteTable))
420	{
421	// header so that windows recognize the file as UTF-8:
422	unsigned char h[3]={0xEF,0xBB,0xBF};
423	if (!fwrite(h,3,1,f)) return eXMLErrorCannotWriteFile;
424	if (!fwrite("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",39,1,f)) return eXMLErrorCannotWriteFile;
425	}
426	else
427	if (fprintf(f,"<?xml version=\"1.0\" encoding=\"%s\"?>\n",encoding)<0) return eXMLErrorCannotWriteFile;
428	} else
429	{
430	if (XML_ByteTable==XML_utf8ByteTable) // test if strictUTF8Parsing==1"
431	{
432	unsigned char h[3]={0xEF,0xBB,0xBF}; if (!fwrite(h,3,1,f)) return eXMLErrorCannotWriteFile;
433	}
434	}
435	#endif
436	if (!fwrite(t,sizeof(XMLCHAR)*i,1,f)) return eXMLErrorCannotWriteFile;
437	if (fclose(f)!=0) return eXMLErrorCannotWriteFile;
438	free(t);
439	return eXMLErrorNone;
440	}
441
442	// Duplicate a given string.
443	XMLSTR stringDup(XMLCSTR lpszData, int cbData)
444	{
445	if (lpszData==NULL) return NULL;
446
447	XMLSTR lpszNew;
448	if (cbData==0) cbData=(int)_tcslen(lpszData);
449	lpszNew = (XMLSTR)malloc((cbData+1) * sizeof(XMLCHAR));
450	if (lpszNew)
451	{
452	memcpy(lpszNew, lpszData, (cbData) * sizeof(XMLCHAR));
453	lpszNew[cbData] = (XMLCHAR)NULL;
454	}
455	return lpszNew;
456	}
457
458	XMLNode XMLNode::emptyXMLNode;
459	XMLClear XMLNode::emptyXMLClear={ NULL, NULL, NULL};
460	XMLAttribute XMLNode::emptyXMLAttribute={ NULL, NULL};
461
462	// Enumeration used to decipher what type a token is
463	typedef enum XMLTokenTypeTag
464	{
465	eTokenText = 0,
466	eTokenQuotedText,
467	eTokenTagStart, /* "<" */
468	eTokenTagEnd, /* "</" */
469	eTokenCloseTag, /* ">" */
470	eTokenEquals, /* "=" */
471	eTokenDeclaration, /* "<?" */
472	eTokenShortHandClose, /* "/>" */
473	eTokenClear,
474	eTokenError
475	} XMLTokenType;
476
477	// Main structure used for parsing XML
478	typedef struct XML
479	{
480	XMLCSTR lpXML;
481	XMLCSTR lpszText;
482	int nIndex,nIndexMissigEndTag;
483	enum XMLError error;
484	XMLCSTR lpEndTag;
485	int cbEndTag;
486	XMLCSTR lpNewElement;
487	int cbNewElement;
488	int nFirst;
489	} XML;
490
491	typedef struct
492	{
493	ALLXMLClearTag *pClr;
494	XMLCSTR pStr;
495	} NextToken;
496
497	// Enumeration used when parsing attributes
498	typedef enum Attrib
499	{
500	eAttribName = 0,
501	eAttribEquals,
502	eAttribValue
503	} Attrib;
504
505	// Enumeration used when parsing elements to dictate whether we are currently
506	// inside a tag
507	typedef enum Status
508	{
509	eInsideTag = 0,
510	eOutsideTag
511	} Status;
512
513	// private (used while rendering):
514	XMLSTR toXMLString(XMLSTR dest,XMLCSTR source)
515	{
516	XMLSTR dd=dest;
517	XMLCHAR ch;
518	XMLCharacterEntity *entity;
519	while ((ch=*source))
520	{
521	entity=XMLEntities;
522	do
523	{
524	if (ch==entity->c) {_tcscpy(dest,entity->s); dest+=entity->l; source++; goto out_of_loop1; }
525	entity++;
526	} while(entity->s);
527	#ifdef _XMLUNICODE
528	(dest++)=(source++);
529	#else
530	switch(XML_ByteTable[(unsigned char)ch])
531	{
532	case 4: (dest++)=(source++);
533	case 3: (dest++)=(source++);
534	case 2: (dest++)=(source++);
535	case 1: (dest++)=(source++);
536	}
537	#endif
538	out_of_loop1:
539	;
540	}
541	*dest=0;
542	return dd;
543	}
544
545	// private (used while rendering):
546	int lengthXMLString(XMLCSTR source)
547	{
548	int r=0;
549	XMLCharacterEntity *entity;
550	XMLCHAR ch;
551	while ((ch=*source))
552	{
553	entity=XMLEntities;
554	do
555	{
556	if (ch==entity->c) { r+=entity->l; source++; goto out_of_loop1; }
557	entity++;
558	} while(entity->s);
559	#ifdef _XMLUNICODE
560	r++; source++;
561	#else
562	ch=XML_ByteTable[(unsigned char)ch]; r+=ch; source+=ch;
563	#endif
564	out_of_loop1:
565	;
566	}
567	return r;
568	}
569
570	XMLSTR toXMLString(XMLCSTR source)
571	{
572	XMLSTR dest=(XMLSTR)malloc((lengthXMLString(source)+1)*sizeof(XMLCHAR));
573	return toXMLString(dest,source);
574	}
575
576	XMLSTR toXMLStringFast(XMLSTR dest,int destSz, XMLCSTR source)
577	{
578	int l=lengthXMLString(source)+1;
579	if (l>destSz) { destSz=l; dest=(XMLSTR)realloc(dest,l*sizeof(XMLCHAR)); }
580	return toXMLString(*dest,source);
581	}
582
583	// private:
584	XMLSTR fromXMLString(XMLCSTR s, int lo, XML *pXML)
585	{
586	// This function is the opposite of the function "toXMLString". It decodes the escape
587	// sequences &, ", ', <, > and replace them by the characters
588	// &,",',<,>. This function is used internally by the XML Parser. All the calls to
589	// the XML library will always gives you back "decoded" strings.
590	//
591	// in: string (s) and length (lo) of string
592	// out: new allocated string converted from xml
593	if (!s) return NULL;
594
595	int ll=0,j;
596	XMLSTR d;
597	XMLCSTR ss=s;
598	XMLCharacterEntity *entity;
599	while ((lo>0)&&(*s))
600	{
601	if (*s==_T('&'))
602	{
603	if ((lo>2)&&(s[1]==_T('#')))
604	{
605	s+=2; lo-=2;
606	if ((s==_T('X'))\|\|(s==_T('x'))) { s++; lo--; }
607	while ((s)&&(s!=_T(';'))&&((lo--)>0)) s++;
608	if (*s!=_T(';'))
609	{
610	pXML->error=eXMLErrorUnknownCharacterEntity;
611	return NULL;
612	}
613	s++; lo--;
614	} else
615	{
616	entity=XMLEntities;
617	do
618	{
619	if ((lo>=entity->l)&&(_tcsnicmp(s,entity->s,entity->l)==0)) { s+=entity->l; lo-=entity->l; break; }
620	entity++;
621	} while(entity->s);
622	if (!entity->s)
623	{
624	pXML->error=eXMLErrorUnknownCharacterEntity;
625	return NULL;
626	}
627	}
628	} else
629	{
630	#ifdef _XMLUNICODE
631	s++; lo--;
632	#else
633	j=XML_ByteTable[(unsigned char)*s]; s+=j; lo-=j; ll+=j-1;
634	#endif
635	}
636	ll++;
637	}
638
639	d=(XMLSTR)malloc((ll+1)*sizeof(XMLCHAR));
640	s=d;
641	while (ll-->0)
642	{
643	if (*ss==_T('&'))
644	{
645	if (ss[1]==_T('#'))
646	{
647	ss+=2; j=0;
648	if ((ss==_T('X'))\|\|(ss==_T('x')))
649	{
650	ss++;
651	while (*ss!=_T(';'))
652	{
653	if ((ss>=_T('0'))&&(ss<=_T('9'))) j=(j<<4)+*ss-_T('0');
654	else if ((ss>=_T('A'))&&(ss<=_T('F'))) j=(j<<4)+*ss-_T('A')+10;
655	else if ((ss>=_T('a'))&&(ss<=_T('f'))) j=(j<<4)+*ss-_T('a')+10;
656	else { free((void*)s); pXML->error=eXMLErrorUnknownCharacterEntity;return NULL;}
657	ss++;
658	}
659	} else
660	{
661	while (*ss!=_T(';'))
662	{
663	if ((ss>=_T('0'))&&(ss<=_T('9'))) j=(j10)+ss-_T('0');
664	else { free((void*)s); pXML->error=eXMLErrorUnknownCharacterEntity;return NULL;}
665	ss++;
666	}
667	}
668	(*d++)=(XMLCHAR)j; ss++;
669	} else
670	{
671	entity=XMLEntities;
672	do
673	{
674	if (_tcsnicmp(ss,entity->s,entity->l)==0) { *(d++)=entity->c; ss+=entity->l; break; }
675	entity++;
676	} while(entity->s);
677	}
678	} else
679	{
680	#ifdef _XMLUNICODE
681	(d++)=(ss++);
682	#else
683	switch(XML_ByteTable[(unsigned char)*ss])
684	{
685	case 4: (d++)=(ss++); ll--;
686	case 3: (d++)=(ss++); ll--;
687	case 2: (d++)=(ss++); ll--;
688	case 1: (d++)=(ss++);
689	}
690	#endif
691	}
692	}
693	*d=0;
694	return (XMLSTR)s;
695	}
696
697	#define XML_isSPACECHAR(ch) ((ch==_T('\n'))\|\|(ch==_T(' '))\|\|(ch== _T('\t'))\|\|(ch==_T('\r')))
698
699	// private:
700	char myTagCompare(XMLCSTR cclose, XMLCSTR copen)
701	// !!!! WARNING strange convention&:
702	// return 0 if equals
703	// return 1 if different
704	{
705	if (!cclose) return 1;
706	int l=(int)_tcslen(cclose);
707	if (_tcsnicmp(cclose, copen, l)!=0) return 1;
708	const XMLCHAR c=copen[l];
709	if (XML_isSPACECHAR(c)\|\|
710	(c==_T('/' ))\|\|
711	(c==_T('<' ))\|\|
712	(c==_T('>' ))\|\|
713	(c==_T('=' ))) return 0;
714	return 1;
715	}
716
717	// Obtain the next character from the string.
718	static inline XMLCHAR getNextChar(XML *pXML)
719	{
720	XMLCHAR ch = pXML->lpXML[pXML->nIndex];
721	#ifdef _XMLUNICODE
722	if (ch!=0) pXML->nIndex++;
723	#else
724	pXML->nIndex+=XML_ByteTable[(unsigned char)ch];
725	#endif
726	return ch;
727	}
728
729	// Find the next token in a string.
730	// pcbToken contains the number of characters that have been read.
731	static NextToken GetNextToken(XML pXML, int pcbToken, enum XMLTokenTypeTag *pType)
732	{
733	NextToken result;
734	XMLCHAR ch;
735	XMLCHAR chTemp;
736	int indexStart,nFoundMatch,nIsText=FALSE;
737	result.pClr=NULL; // prevent warning
738
739	// Find next non-white space character
740	do { indexStart=pXML->nIndex; ch=getNextChar(pXML); } while XML_isSPACECHAR(ch);
741
742	if (ch)
743	{
744	// Cache the current string pointer
745	result.pStr = &pXML->lpXML[indexStart];
746
747	// First check whether the token is in the clear tag list (meaning it
748	// does not need formatting).
749	ALLXMLClearTag *ctag=XMLClearTags;
750	do
751	{
752	if (_tcsnicmp(ctag->lpszOpen, result.pStr, ctag->openTagLen)==0)
753	{
754	result.pClr=ctag;
755	pXML->nIndex+=ctag->openTagLen-1;
756	*pType=eTokenClear;
757	return result;
758	}
759	ctag++;
760	} while(ctag->lpszOpen);
761
762	// If we didn't find a clear tag then check for standard tokens
763	switch(ch)
764	{
765	// Check for quotes
766	case _T('\''):
767	case _T('\"'):
768	// Type of token
769	*pType = eTokenQuotedText;
770	chTemp = ch;
771
772	// Set the size
773	nFoundMatch = FALSE;
774
775	// Search through the string to find a matching quote
776	while((ch = getNextChar(pXML)))
777	{
778	if (ch==chTemp) { nFoundMatch = TRUE; break; }
779	if (ch==_T('<')) break;
780	}
781
782	// If we failed to find a matching quote
783	if (nFoundMatch == FALSE)
784	{
785	pXML->nIndex=indexStart+1;
786	nIsText=TRUE;
787	break;
788	}
789
790	// 4.02.2002
791	// if (FindNonWhiteSpace(pXML)) pXML->nIndex--;
792
793	break;
794
795	// Equals (used with attribute values)
796	case _T('='):
797	*pType = eTokenEquals;
798	break;
799
800	// Close tag
801	case _T('>'):
802	*pType = eTokenCloseTag;
803	break;
804
805	// Check for tag start and tag end
806	case _T('<'):
807
808	// Peek at the next character to see if we have an end tag '</',
809	// or an xml declaration '<?'
810	chTemp = pXML->lpXML[pXML->nIndex];
811
812	// If we have a tag end...
813	if (chTemp == _T('/'))
814	{
815	// Set the type and ensure we point at the next character
816	getNextChar(pXML);
817	*pType = eTokenTagEnd;
818	}
819
820	// If we have an XML declaration tag
821	else if (chTemp == _T('?'))
822	{
823
824	// Set the type and ensure we point at the next character
825	getNextChar(pXML);
826	*pType = eTokenDeclaration;
827	}
828
829	// Otherwise we must have a start tag
830	else
831	{
832	*pType = eTokenTagStart;
833	}
834	break;
835
836	// Check to see if we have a short hand type end tag ('/>').
837	case _T('/'):
838
839	// Peek at the next character to see if we have a short end tag '/>'
840	chTemp = pXML->lpXML[pXML->nIndex];
841
842	// If we have a short hand end tag...
843	if (chTemp == _T('>'))
844	{
845	// Set the type and ensure we point at the next character
846	getNextChar(pXML);
847	*pType = eTokenShortHandClose;
848	break;
849	}
850
851	// If we haven't found a short hand closing tag then drop into the
852	// text process
853
854	// Other characters
855	default:
856	nIsText = TRUE;
857	}
858
859	// If this is a TEXT node
860	if (nIsText)
861	{
862	// Indicate we are dealing with text
863	*pType = eTokenText;
864	while((ch = getNextChar(pXML)))
865	{
866	if XML_isSPACECHAR(ch)
867	{
868	indexStart++; break;
869
870	} else if (ch==_T('/'))
871	{
872	// If we find a slash then this maybe text or a short hand end tag
873	// Peek at the next character to see it we have short hand end tag
874	ch=pXML->lpXML[pXML->nIndex];
875	// If we found a short hand end tag then we need to exit the loop
876	if (ch==_T('>')) { pXML->nIndex--; break; }
877
878	} else if ((ch==_T('<'))\|\|(ch==_T('>'))\|\|(ch==_T('=')))
879	{
880	pXML->nIndex--; break;
881	}
882	}
883	}
884	*pcbToken = pXML->nIndex-indexStart;
885	} else
886	{
887	// If we failed to obtain a valid character
888	*pcbToken = 0;
889	*pType = eTokenError;
890	result.pStr=NULL;
891	}
892
893	return result;
894	}
895
896	XMLCSTR XMLNode::updateName_WOSD(XMLCSTR lpszName)
897	{
898	if (d->lpszName&&(lpszName!=d->lpszName)) free((void*)d->lpszName);
899	d->lpszName=lpszName;
900	return lpszName;
901	}
902
903	// private:
904	XMLNode::XMLNode(struct XMLNodeDataTag *p){ d=p; (p->ref_count)++; }
905	XMLNode::XMLNode(XMLNodeData *pParent, XMLCSTR lpszName, char isDeclaration)
906	{
907	d=(XMLNodeData*)malloc(sizeof(XMLNodeData));
908	d->ref_count=1;
909
910	d->lpszName=NULL;
911	d->nChild= 0;
912	d->nText = 0;
913	d->nClear = 0;
914	d->nAttribute = 0;
915
916	d->isDeclaration = isDeclaration;
917
918	d->pParent = pParent;
919	d->pChild= NULL;
920	d->pText= NULL;
921	d->pClear= NULL;
922	d->pAttribute= NULL;
923	d->pOrder= NULL;
924
925	updateName_WOSD(lpszName);
926	}
927
928	XMLNode XMLNode::createXMLTopNode_WOSD(XMLCSTR lpszName, char isDeclaration) { return XMLNode(NULL,lpszName,isDeclaration); }
929	XMLNode XMLNode::createXMLTopNode(XMLCSTR lpszName, char isDeclaration) { return XMLNode(NULL,stringDup(lpszName),isDeclaration); }
930
931	#define MEMORYINCREASE 50
932	static int memoryIncrease=0;
933
934	static inline void myRealloc(void p, int newsize, int memInc, int sizeofElem)
935	{
936	if (p==NULL) { if (memInc) return malloc(memInc*sizeofElem); return malloc(sizeofElem); }
937	if ((memInc==0)\|\|((newsize%memInc)==0)) p=realloc(p,(newsize+memInc)*sizeofElem);
938	// if (!p)
939	// {
940	// printf("XMLParser Error: Not enough memory! Aborting...\n"); exit(220);
941	// }
942	return p;
943	}
944
945	// private:
946	int XMLNode::findPosition(XMLNodeData *d, int index, XMLElementType xtype)
947	{
948	if (index<0) return -1;
949	int i=0,j=(int)((index<<2)+xtype),*o=d->pOrder; while (o[i]!=j) i++; return i;
950	}
951
952	// private:
953	// update "order" information when deleting a content of a XMLNode
954	int XMLNode::removeOrderElement(XMLNodeData *d, XMLElementType t, int index)
955	{
956	int n=d->nChild+d->nText+d->nClear, *o=d->pOrder,i=findPosition(d,index,t);
957	memmove(o+i, o+i+1, (n-i)*sizeof(int));
958	for (;i<n;i++)
959	if ((o[i]&3)==(int)t) o[i]-=4;
960	// We should normally do:
961	// d->pOrder=(int)realloc(d->pOrder,n*sizeof(int));
962	// but we skip reallocation because it's too time consuming.
963	// Anyway, at the end, it will be free'd completely at once.
964	return i;
965	}
966
967	void XMLNode::addToOrder(int _pos, int nc, void *p, int size, XMLElementType xtype)
968	{
969	// in: *_pos is the position inside d->pOrder ("-1" means "EndOf")
970	// out: *_pos is the index inside p
971	p=myRealloc(p,(nc+1),memoryIncrease,size);
972	int n=d->nChild+d->nText+d->nClear;
973	d->pOrder=(int)myRealloc(d->pOrder,n+1,memoryIncrease3,sizeof(int));
974	int pos=_pos,o=d->pOrder;
975
976	if ((pos<0)\|\|(pos>=n)) { *_pos=nc; o[n]=(int)((nc<<2)+xtype); return p; }
977
978	int i=pos;
979	memmove(o+i+1, o+i, (n-i)*sizeof(int));
980
981	while ((pos<n)&&((o[pos]&3)!=(int)xtype)) pos++;
982	if (pos==n) { *_pos=nc; o[n]=(int)((nc<<2)+xtype); return p; }
983
984	o[i]=o[pos];
985	for (i=pos+1;i<=n;i++) if ((o[i]&3)==(int)xtype) o[i]+=4;
986
987	*_pos=pos=o[pos]>>2;
988	memmove(((char)p)+(pos+1)size,((char)p)+possize,(nc-pos)*size);
989
990	return p;
991	}
992
993	// Add a child node to the given element.
994	XMLNode XMLNode::addChild_WOSD(XMLCSTR lpszName, char isDeclaration, int pos)
995	{
996	if (!lpszName) return emptyXMLNode;
997	d->pChild=(XMLNode*)addToOrder(&pos,d->nChild,d->pChild,sizeof(XMLNode),eNodeChild);
998	d->pChild[pos].d=NULL;
999	d->pChild[pos]=XMLNode(d,lpszName,isDeclaration);
1000	d->nChild++;
1001	return d->pChild[pos];
1002	}
1003
1004	// Add an attribute to an element.
1005	XMLAttribute *XMLNode::addAttribute_WOSD(XMLCSTR lpszName, XMLCSTR lpszValuev)
1006	{
1007	if (!lpszName) return &emptyXMLAttribute;
1008	int nc=d->nAttribute;
1009	d->pAttribute=(XMLAttribute*)myRealloc(d->pAttribute,(nc+1),memoryIncrease,sizeof(XMLAttribute));
1010	XMLAttribute *pAttr=d->pAttribute+nc;
1011	pAttr->lpszName = lpszName;
1012	pAttr->lpszValue = lpszValuev;
1013	d->nAttribute++;
1014	return pAttr;
1015	}
1016
1017	// Add text to the element.
1018	XMLCSTR XMLNode::addText_WOSD(XMLCSTR lpszValue, int pos)
1019	{
1020	if (!lpszValue) return NULL;
1021	d->pText=(XMLCSTR*)addToOrder(&pos,d->nText,d->pText,sizeof(XMLSTR),eNodeText);
1022	d->pText[pos]=lpszValue;
1023	d->nText++;
1024	return lpszValue;
1025	}
1026
1027	// Add clear (unformatted) text to the element.
1028	XMLClear *XMLNode::addClear_WOSD(XMLCSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose, int pos)
1029	{
1030	if (!lpszValue) return &emptyXMLClear;
1031	d->pClear=(XMLClear *)addToOrder(&pos,d->nClear,d->pClear,sizeof(XMLClear),eNodeClear);
1032	XMLClear *pNewClear=d->pClear+pos;
1033	pNewClear->lpszValue = lpszValue;
1034	if (!lpszOpen) lpszOpen=getClearTagTable()->lpszOpen;
1035	if (!lpszClose) lpszOpen=getClearTagTable()->lpszClose;
1036	pNewClear->lpszOpenTag = lpszOpen;
1037	pNewClear->lpszCloseTag = lpszClose;
1038	d->nClear++;
1039	return pNewClear;
1040	}
1041
1042	// private:
1043	// Parse a clear (unformatted) type node.
1044	char XMLNode::parseClearTag(void px, ALLXMLClearTag pClear)
1045	{
1046	XML pXML=(XML )px;
1047	int cbTemp=0;
1048	XMLCSTR lpszTemp=NULL;
1049	XMLCSTR lpXML=&pXML->lpXML[pXML->nIndex];
1050
1051	// Find the closing tag
1052	// Seems the <!DOCTYPE need a better treatment so lets handle it
1053	if (pClear->lpszOpen==XMLClearTags[1].lpszOpen)
1054	{
1055	int openCount=1;
1056	XMLCSTR pCh=lpXML;
1057	while (*pCh)
1058	{
1059	if (*pCh==_T('<')) openCount++;
1060	else if (*pCh==_T('>')) { openCount--; if (!openCount) { lpszTemp=pCh; break; } }
1061	#ifdef _XMLUNICODE
1062	pCh++;
1063	#else
1064	pCh+=XML_ByteTable[(unsigned char)(*pCh)];
1065	#endif
1066	}
1067	} else lpszTemp = _tcsstr(lpXML, pClear->lpszClose);
1068
1069	if (lpszTemp)
1070	{
1071	// Cache the size and increment the index
1072	cbTemp = (int)(lpszTemp - lpXML);
1073
1074	pXML->nIndex += cbTemp+(int)_tcslen(pClear->lpszClose);
1075
1076	// Add the clear node to the current element
1077	addClear_WOSD(stringDup(lpXML,cbTemp), pClear->lpszOpen, pClear->lpszClose);
1078	return 0;
1079	}
1080
1081	// If we failed to find the end tag
1082	pXML->error = eXMLErrorUnmatchedEndClearTag;
1083	return 1;
1084	}
1085
1086	void XMLNode::exactMemory(XMLNodeData *d)
1087	{
1088	if (memoryIncrease<=1) return;
1089	if (d->pOrder) d->pOrder=(int)realloc(d->pOrder,(d->nChild+d->nAttribute+d->nText+d->nClear)sizeof(int));
1090	if (d->pChild) d->pChild=(XMLNode)realloc(d->pChild,d->nChildsizeof(XMLNode));
1091	if (d->pAttribute) d->pAttribute=(XMLAttribute)realloc(d->pAttribute,d->nAttributesizeof(XMLAttribute));
1092	if (d->pText) d->pText=(XMLCSTR)realloc(d->pText,d->nTextsizeof(XMLSTR));
1093	if (d->pClear) d->pClear=(XMLClear )realloc(d->pClear,d->nClearsizeof(XMLClear));
1094	}
1095
1096	char XMLNode::maybeAddTxT(void *pa, XMLCSTR tokenPStr)
1097	{
1098	XML pXML=(XML )pa;
1099	XMLCSTR lpszText=pXML->lpszText;
1100	if (!lpszText) return 0;
1101	if (dropWhiteSpace) while (XML_isSPACECHAR(*lpszText)&&(lpszText!=tokenPStr)) lpszText++;
1102	int cbText = (int)(tokenPStr - lpszText);
1103	if (!cbText) { pXML->lpszText=NULL; return 0; }
1104	if (dropWhiteSpace) { cbText--; while ((cbText)&&XML_isSPACECHAR(lpszText[cbText])) cbText--; cbText++; }
1105	if (!cbText) { pXML->lpszText=NULL; return 0; }
1106	lpszText=fromXMLString(lpszText,cbText,pXML);
1107	if (!lpszText) return 1;
1108	addText_WOSD(lpszText);
1109	pXML->lpszText=NULL;
1110	return 0;
1111	}
1112	// private:
1113	// Recursively parse an XML element.
1114	int XMLNode::ParseXMLElement(void *pa)
1115	{
1116	XML pXML=(XML )pa;
1117	int cbToken;
1118	enum XMLTokenTypeTag type;
1119	NextToken token;
1120	XMLCSTR lpszTemp=NULL;
1121	int cbTemp=0;
1122	char nDeclaration;
1123	XMLNode pNew;
1124	enum Status status; // inside or outside a tag
1125	enum Attrib attrib = eAttribName;
1126
1127	assert(pXML);
1128
1129	// If this is the first call to the function
1130	if (pXML->nFirst)
1131	{
1132	// Assume we are outside of a tag definition
1133	pXML->nFirst = FALSE;
1134	status = eOutsideTag;
1135	} else
1136	{
1137	// If this is not the first call then we should only be called when inside a tag.
1138	status = eInsideTag;
1139	}
1140
1141	// Iterate through the tokens in the document
1142	for(;;)
1143	{
1144	// Obtain the next token
1145	token = GetNextToken(pXML, &cbToken, &type);
1146
1147	if (type != eTokenError)
1148	{
1149	// Check the current status
1150	switch(status)
1151	{
1152
1153	// If we are outside of a tag definition
1154	case eOutsideTag:
1155
1156	// Check what type of token we obtained
1157	switch(type)
1158	{
1159	// If we have found text or quoted text
1160	case eTokenText:
1161	case eTokenCloseTag: /* '>' */
1162	case eTokenShortHandClose: /* '/>' */
1163	case eTokenQuotedText:
1164	case eTokenEquals:
1165	break;
1166
1167	// If we found a start tag '<' and declarations '<?'
1168	case eTokenTagStart:
1169	case eTokenDeclaration:
1170
1171	// Cache whether this new element is a declaration or not
1172	nDeclaration = (type == eTokenDeclaration);
1173
1174	// If we have node text then add this to the element
1175	if (maybeAddTxT(pXML,token.pStr)) return FALSE;
1176
1177	// Find the name of the tag
1178	token = GetNextToken(pXML, &cbToken, &type);
1179
1180	// Return an error if we couldn't obtain the next token or
1181	// it wasnt text
1182	if (type != eTokenText)
1183	{
1184	pXML->error = eXMLErrorMissingTagName;
1185	return FALSE;
1186	}
1187
1188	// If we found a new element which is the same as this
1189	// element then we need to pass this back to the caller..
1190
1191	#ifdef APPROXIMATE_PARSING
1192	if (d->lpszName &&
1193	myTagCompare(d->lpszName, token.pStr) == 0)
1194	{
1195	// Indicate to the caller that it needs to create a
1196	// new element.
1197	pXML->lpNewElement = token.pStr;
1198	pXML->cbNewElement = cbToken;
1199	return TRUE;
1200	} else
1201	#endif
1202	{
1203	// If the name of the new element differs from the name of
1204	// the current element we need to add the new element to
1205	// the current one and recurse
1206	pNew = addChild_WOSD(stringDup(token.pStr,cbToken), nDeclaration);
1207
1208	while (!pNew.isEmpty())
1209	{
1210	// Callself to process the new node. If we return
1211	// FALSE this means we dont have any more
1212	// processing to do...
1213
1214	if (!pNew.ParseXMLElement(pXML)) return FALSE;
1215	else
1216	{
1217	// If the call to recurse this function
1218	// evented in a end tag specified in XML then
1219	// we need to unwind the calls to this
1220	// function until we find the appropriate node
1221	// (the element name and end tag name must
1222	// match)
1223	if (pXML->cbEndTag)
1224	{
1225	// If we are back at the root node then we
1226	// have an unmatched end tag
1227	if (!d->lpszName)
1228	{
1229	pXML->error=eXMLErrorUnmatchedEndTag;
1230	return FALSE;
1231	}
1232
1233	// If the end tag matches the name of this
1234	// element then we only need to unwind
1235	// once more...
1236
1237	if (myTagCompare(d->lpszName, pXML->lpEndTag)==0)
1238	{
1239	pXML->cbEndTag = 0;
1240	}
1241
1242	return TRUE;
1243	} else
1244	if (pXML->cbNewElement)
1245	{
1246	// If the call indicated a new element is to
1247	// be created on THIS element.
1248
1249	// If the name of this element matches the
1250	// name of the element we need to create
1251	// then we need to return to the caller
1252	// and let it process the element.
1253
1254	if (myTagCompare(d->lpszName, pXML->lpNewElement)==0)
1255	{
1256	return TRUE;
1257	}
1258
1259	// Add the new element and recurse
1260	pNew = addChild_WOSD(stringDup(pXML->lpNewElement,pXML->cbNewElement));
1261	pXML->cbNewElement = 0;
1262	}
1263	else
1264	{
1265	// If we didn't have a new element to create
1266	pNew = emptyXMLNode;
1267
1268	}
1269	}
1270	}
1271	}
1272	break;
1273
1274	// If we found an end tag
1275	case eTokenTagEnd:
1276
1277	// If we have node text then add this to the element
1278	if (maybeAddTxT(pXML,token.pStr)) return FALSE;
1279
1280	// Find the name of the end tag
1281	token = GetNextToken(pXML, &cbTemp, &type);
1282
1283	// The end tag should be text
1284	if (type != eTokenText)
1285	{
1286	pXML->error = eXMLErrorMissingEndTagName;
1287	return FALSE;
1288	}
1289	lpszTemp = token.pStr;
1290
1291	// After the end tag we should find a closing tag
1292	token = GetNextToken(pXML, &cbToken, &type);
1293	if (type != eTokenCloseTag)
1294	{
1295	pXML->error = eXMLErrorMissingEndTagName;
1296	return FALSE;
1297	}
1298	pXML->lpszText=pXML->lpXML+pXML->nIndex;
1299
1300	// We need to return to the previous caller. If the name
1301	// of the tag cannot be found we need to keep returning to
1302	// caller until we find a match
1303	if (myTagCompare(d->lpszName, lpszTemp) != 0)
1304	#ifdef STRICT_PARSING
1305	{
1306	pXML->error=eXMLErrorUnmatchedEndTag;
1307	pXML->nIndexMissigEndTag=pXML->nIndex;
1308	return FALSE;
1309	}
1310	#else
1311	{
1312	pXML->error=eXMLErrorMissingEndTag;
1313	pXML->nIndexMissigEndTag=pXML->nIndex;
1314	pXML->lpEndTag = lpszTemp;
1315	pXML->cbEndTag = cbTemp;
1316	}
1317	#endif
1318
1319	// Return to the caller
1320	exactMemory(d);
1321	return TRUE;
1322
1323	// If we found a clear (unformatted) token
1324	case eTokenClear:
1325	// If we have node text then add this to the element
1326	if (maybeAddTxT(pXML,token.pStr)) return FALSE;
1327	if (parseClearTag(pXML, token.pClr)) return FALSE;
1328	pXML->lpszText=pXML->lpXML+pXML->nIndex;
1329	break;
1330
1331	default:
1332	break;
1333	}
1334	break;
1335
1336	// If we are inside a tag definition we need to search for attributes
1337	case eInsideTag:
1338
1339	// Check what part of the attribute (name, equals, value) we
1340	// are looking for.
1341	switch(attrib)
1342	{
1343	// If we are looking for a new attribute
1344	case eAttribName:
1345
1346	// Check what the current token type is
1347	switch(type)
1348	{
1349	// If the current type is text...
1350	// Eg. 'attribute'
1351	case eTokenText:
1352	// Cache the token then indicate that we are next to
1353	// look for the equals
1354	lpszTemp = token.pStr;
1355	cbTemp = cbToken;
1356	attrib = eAttribEquals;
1357	break;
1358
1359	// If we found a closing tag...
1360	// Eg. '>'
1361	case eTokenCloseTag:
1362	// We are now outside the tag
1363	status = eOutsideTag;
1364	pXML->lpszText=pXML->lpXML+pXML->nIndex;
1365	break;
1366
1367	// If we found a short hand '/>' closing tag then we can
1368	// return to the caller
1369	case eTokenShortHandClose:
1370	exactMemory(d);
1371	pXML->lpszText=pXML->lpXML+pXML->nIndex;
1372	return TRUE;
1373
1374	// Errors...
1375	case eTokenQuotedText: /* '"SomeText"' */
1376	case eTokenTagStart: /* '<' */
1377	case eTokenTagEnd: /* '</' */
1378	case eTokenEquals: /* '=' */
1379	case eTokenDeclaration: /* '<?' */
1380	case eTokenClear:
1381	pXML->error = eXMLErrorUnexpectedToken;
1382	return FALSE;
1383	default: break;
1384	}
1385	break;
1386
1387	// If we are looking for an equals
1388	case eAttribEquals:
1389	// Check what the current token type is
1390	switch(type)
1391	{
1392	// If the current type is text...
1393	// Eg. 'Attribute AnotherAttribute'
1394	case eTokenText:
1395	// Add the unvalued attribute to the list
1396	addAttribute_WOSD(stringDup(lpszTemp,cbTemp), NULL);
1397	// Cache the token then indicate. We are next to
1398	// look for the equals attribute
1399	lpszTemp = token.pStr;
1400	cbTemp = cbToken;
1401	break;
1402
1403	// If we found a closing tag 'Attribute >' or a short hand
1404	// closing tag 'Attribute />'
1405	case eTokenShortHandClose:
1406	case eTokenCloseTag:
1407	// If we are a declaration element '<?' then we need
1408	// to remove extra closing '?' if it exists
1409	pXML->lpszText=pXML->lpXML+pXML->nIndex;
1410
1411	if (d->isDeclaration &&
1412	(lpszTemp[cbTemp-1]) == _T('?'))
1413	{
1414	cbTemp--;
1415	}
1416
1417	if (cbTemp)
1418	{
1419	// Add the unvalued attribute to the list
1420	addAttribute_WOSD(stringDup(lpszTemp,cbTemp), NULL);
1421	}
1422
1423	// If this is the end of the tag then return to the caller
1424	if (type == eTokenShortHandClose)
1425	{
1426	exactMemory(d);
1427	return TRUE;
1428	}
1429
1430	// We are now outside the tag
1431	status = eOutsideTag;
1432	break;
1433
1434	// If we found the equals token...
1435	// Eg. 'Attribute ='
1436	case eTokenEquals:
1437	// Indicate that we next need to search for the value
1438	// for the attribute
1439	attrib = eAttribValue;
1440	break;
1441
1442	// Errors...
1443	case eTokenQuotedText: /* 'Attribute "InvalidAttr"'*/
1444	case eTokenTagStart: /* 'Attribute <' */
1445	case eTokenTagEnd: /* 'Attribute </' */
1446	case eTokenDeclaration: /* 'Attribute <?' */
1447	case eTokenClear:
1448	pXML->error = eXMLErrorUnexpectedToken;
1449	return FALSE;
1450	default: break;
1451	}
1452	break;
1453
1454	// If we are looking for an attribute value
1455	case eAttribValue:
1456	// Check what the current token type is
1457	switch(type)
1458	{
1459	// If the current type is text or quoted text...
1460	// Eg. 'Attribute = "Value"' or 'Attribute = Value' or
1461	// 'Attribute = 'Value''.
1462	case eTokenText:
1463	case eTokenQuotedText:
1464	// If we are a declaration element '<?' then we need
1465	// to remove extra closing '?' if it exists
1466	if (d->isDeclaration &&
1467	(token.pStr[cbToken-1]) == _T('?'))
1468	{
1469	cbToken--;
1470	}
1471
1472	if (cbTemp)
1473	{
1474	// Add the valued attribute to the list
1475	if (type==eTokenQuotedText) { token.pStr++; cbToken-=2; }
1476	XMLCSTR attrVal=token.pStr;
1477	if (attrVal)
1478	{
1479	attrVal=fromXMLString(attrVal,cbToken,pXML);
1480	if (!attrVal) return FALSE;
1481	}
1482	addAttribute_WOSD(stringDup(lpszTemp,cbTemp),attrVal);
1483	}
1484
1485	// Indicate we are searching for a new attribute
1486	attrib = eAttribName;
1487	break;
1488
1489	// Errors...
1490	case eTokenTagStart: /* 'Attr = <' */
1491	case eTokenTagEnd: /* 'Attr = </' */
1492	case eTokenCloseTag: /* 'Attr = >' */
1493	case eTokenShortHandClose: /* "Attr = />" */
1494	case eTokenEquals: /* 'Attr = =' */
1495	case eTokenDeclaration: /* 'Attr = <?' */
1496	case eTokenClear:
1497	pXML->error = eXMLErrorUnexpectedToken;
1498	return FALSE;
1499	break;
1500	default: break;
1501	}
1502	}
1503	}
1504	}
1505	// If we failed to obtain the next token
1506	else
1507	{
1508	if ((!d->isDeclaration)&&(d->pParent))
1509	{
1510	#ifdef STRICT_PARSING
1511	pXML->error=eXMLErrorUnmatchedEndTag;
1512	#else
1513	pXML->error=eXMLErrorMissingEndTag;
1514	#endif
1515	pXML->nIndexMissigEndTag=pXML->nIndex;
1516	}
1517	return FALSE;
1518	}
1519	}
1520	}
1521
1522	// Count the number of lines and columns in an XML string.
1523	static void CountLinesAndColumns(XMLCSTR lpXML, int nUpto, XMLResults *pResults)
1524	{
1525	XMLCHAR ch;
1526	assert(lpXML);
1527	assert(pResults);
1528
1529	struct XML xml={ lpXML,lpXML, 0, 0, eXMLErrorNone, NULL, 0, NULL, 0, TRUE };
1530
1531	pResults->nLine = 1;
1532	pResults->nColumn = 1;
1533	while (xml.nIndex<nUpto)
1534	{
1535	ch = getNextChar(&xml);
1536	if (ch != _T('\n')) pResults->nColumn++;
1537	else
1538	{
1539	pResults->nLine++;
1540	pResults->nColumn=1;
1541	}
1542	}
1543	}
1544
1545	// Parse XML and return the root element.
1546	XMLNode XMLNode::parseString(XMLCSTR lpszXML, XMLCSTR tag, XMLResults *pResults)
1547	{
1548	if (!lpszXML)
1549	{
1550	if (pResults)
1551	{
1552	pResults->error=eXMLErrorNoElements;
1553	pResults->nLine=0;
1554	pResults->nColumn=0;
1555	}
1556	return emptyXMLNode;
1557	}
1558
1559	XMLNode xnode(NULL,NULL,FALSE);
1560	struct XML xml={ lpszXML, lpszXML, 0, 0, eXMLErrorNone, NULL, 0, NULL, 0, TRUE };
1561
1562	// Create header element
1563	memoryIncrease=MEMORYINCREASE; xnode.ParseXMLElement(&xml); memoryIncrease=0;
1564	enum XMLError error = xml.error;
1565	if ((xnode.nChildNode()==1)&&(xnode.nElement()==1)) xnode=xnode.getChildNode(); // skip the empty node
1566
1567	// If no error occurred
1568	if ((error==eXMLErrorNone)\|\|(error==eXMLErrorMissingEndTag))
1569	{
1570	if (tag&&_tcslen(tag)&&_tcsicmp(xnode.getName(),tag))
1571	{
1572	XMLNode nodeTmp;
1573	int i=0;
1574	while (i<xnode.nChildNode())
1575	{
1576	nodeTmp=xnode.getChildNode(i);
1577	if (_tcsicmp(nodeTmp.getName(),tag)==0) break;
1578	if (nodeTmp.isDeclaration()) { xnode=nodeTmp; i=0; } else i++;
1579	}
1580	if (i>=xnode.nChildNode())
1581	{
1582	if (pResults)
1583	{
1584	pResults->error=eXMLErrorFirstTagNotFound;
1585	pResults->nLine=0;
1586	pResults->nColumn=0;
1587	}
1588	return emptyXMLNode;
1589	}
1590	xnode=nodeTmp;
1591	}
1592	} else
1593	{
1594	// Cleanup: this will destroy all the nodes
1595	xnode = emptyXMLNode;
1596	}
1597
1598
1599	// If we have been given somewhere to place results
1600	if (pResults)
1601	{
1602	pResults->error = error;
1603
1604	// If we have an error
1605	if (error!=eXMLErrorNone)
1606	{
1607	if (error==eXMLErrorMissingEndTag) xml.nIndex=xml.nIndexMissigEndTag;
1608	// Find which line and column it starts on.
1609	CountLinesAndColumns(xml.lpXML, xml.nIndex, pResults);
1610	}
1611	}
1612	return xnode;
1613	}
1614
1615	XMLNode XMLNode::parseFile(XMLCSTR filename, XMLCSTR tag, XMLResults *pResults)
1616	{
1617	if (pResults) { pResults->nLine=0; pResults->nColumn=0; }
1618	FILE *f=_tfopen(filename,_T("rb"));
1619	if (f==NULL) { if (pResults) pResults->error=eXMLErrorFileNotFound; return emptyXMLNode; }
1620	fseek(f,0,SEEK_END);
1621	int l=ftell(f),headerSz=0;
1622	if (!l) { if (pResults) pResults->error=eXMLErrorEmpty; return emptyXMLNode; }
1623	fseek(f,0,SEEK_SET);
1624	unsigned char buf=(unsigned char)malloc(l+1);
1625	fread(buf,l,1,f);
1626	fclose(f);
1627	buf[l]=0;
1628	#ifdef _XMLUNICODE
1629	if (guessUnicodeChars)
1630	{
1631	if (!myIsTextUnicode(buf,l))
1632	{
1633	if ((buf[0]==0xef)&&(buf[1]==0xbb)&&(buf[2]==0xbf)) headerSz=3;
1634	XMLSTR b2=myMultiByteToWideChar((const char*)(buf+headerSz),l-headerSz);
1635	free(buf); buf=(unsigned char*)b2; headerSz=0;
1636	} else
1637	{
1638	if ((buf[0]==0xef)&&(buf[1]==0xff)) headerSz=2;
1639	if ((buf[0]==0xff)&&(buf[1]==0xfe)) headerSz=2;
1640	}
1641	}
1642	#else
1643	if (guessUnicodeChars)
1644	{
1645	if (myIsTextUnicode(buf,l))
1646	{
1647	l/=sizeof(wchar_t);
1648	if ((buf[0]==0xef)&&(buf[1]==0xff)) headerSz=2;
1649	if ((buf[0]==0xff)&&(buf[1]==0xfe)) headerSz=2;
1650	char b2=myWideCharToMultiByte((const wchar_t)(buf+headerSz),l-headerSz);
1651	free(buf); buf=(unsigned char*)b2; headerSz=0;
1652	} else
1653	{
1654	if ((buf[0]==0xef)&&(buf[1]==0xbb)&&(buf[2]==0xbf)) headerSz=3;
1655	}
1656	}
1657	#endif
1658
1659	if (!buf) { if (pResults) pResults->error=eXMLErrorCharConversionError; return emptyXMLNode; }
1660	XMLNode x=parseString((XMLSTR)(buf+headerSz),tag,pResults);
1661	free(buf);
1662	return x;
1663	}
1664
1665	static inline void charmemset(XMLSTR dest,XMLCHAR c,int l) { while (l--) *(dest++)=c; }
1666	// private:
1667	// Creates an user friendly XML string from a given element with
1668	// appropriate white space and carriage returns.
1669	//
1670	// This recurses through all subnodes then adds contents of the nodes to the
1671	// string.
1672	int XMLNode::CreateXMLStringR(XMLNodeData *pEntry, XMLSTR lpszMarker, int nFormat)
1673	{
1674	int nResult = 0;
1675	int cb;
1676	int cbElement;
1677	int nChildFormat=-1;
1678	int nElementI=pEntry->nChild+pEntry->nText+pEntry->nClear;
1679	int i,j;
1680
1681	assert(pEntry);
1682
1683	#define LENSTR(lpsz) (lpsz ? _tcslen(lpsz) : 0)
1684
1685	// If the element has no name then assume this is the head node.
1686	cbElement = (int)LENSTR(pEntry->lpszName);
1687
1688	if (cbElement)
1689	{
1690	// "<elementname "
1691	cb = nFormat == -1 ? 0 : nFormat;
1692
1693	if (lpszMarker)
1694	{
1695	if (cb) charmemset(lpszMarker, INDENTCHAR, sizeof(XMLCHAR)*cb);
1696	nResult = cb;
1697	lpszMarker[nResult++]=_T('<');
1698	if (pEntry->isDeclaration) lpszMarker[nResult++]=_T('?');
1699	_tcscpy(&lpszMarker[nResult], pEntry->lpszName);
1700	nResult+=cbElement;
1701	lpszMarker[nResult++]=_T(' ');
1702
1703	} else
1704	{
1705	nResult+=cbElement+2+cb;
1706	if (pEntry->isDeclaration) nResult++;
1707	}
1708
1709	// Enumerate attributes and add them to the string
1710	XMLAttribute *pAttr=pEntry->pAttribute;
1711	for (i=0; i<pEntry->nAttribute; i++)
1712	{
1713	// "Attrib
1714	cb = (int)LENSTR(pAttr->lpszName);
1715	if (cb)
1716	{
1717	if (lpszMarker) _tcscpy(&lpszMarker[nResult], pAttr->lpszName);
1718	nResult += cb;
1719	// "Attrib=Value "
1720	if (pAttr->lpszValue)
1721	{
1722	cb=(int)lengthXMLString(pAttr->lpszValue);
1723	if (lpszMarker)
1724	{
1725	lpszMarker[nResult]=_T('=');
1726	lpszMarker[nResult+1]=_T('"');
1727	if (cb) toXMLString(&lpszMarker[nResult+2],pAttr->lpszValue);
1728	lpszMarker[nResult+cb+2]=_T('"');
1729	}
1730	nResult+=cb+3;
1731	}
1732	if (lpszMarker) lpszMarker[nResult] = _T(' ');
1733	nResult++;
1734	}
1735	pAttr++;
1736	}
1737
1738	if (pEntry->isDeclaration)
1739	{
1740	if (lpszMarker)
1741	{
1742	lpszMarker[nResult-1]=_T('?');
1743	lpszMarker[nResult]=_T('>');
1744	}
1745	nResult++;
1746	if (nFormat!=-1)
1747	{
1748	if (lpszMarker) lpszMarker[nResult]=_T('\n');
1749	nResult++;
1750	}
1751	} else
1752	// If there are child nodes we need to terminate the start tag
1753	if (nElementI)
1754	{
1755	if (lpszMarker) lpszMarker[nResult-1]=_T('>');
1756	if (nFormat!=-1)
1757	{
1758	if (lpszMarker) lpszMarker[nResult]=_T('\n');
1759	nResult++;
1760	}
1761	} else nResult--;
1762	}
1763
1764	// Calculate the child format for when we recurse. This is used to
1765	// determine the number of spaces used for prefixes.
1766	if (nFormat!=-1)
1767	{
1768	if (cbElement&&(!pEntry->isDeclaration)) nChildFormat=nFormat+1;
1769	else nChildFormat=nFormat;
1770	}
1771
1772	// Enumerate through remaining children
1773	for (i=0; i<nElementI; i++)
1774	{
1775	j=pEntry->pOrder[i];
1776	switch((XMLElementType)(j&3))
1777	{
1778	// Text nodes
1779	case eNodeText:
1780	{
1781	// "Text"
1782	XMLCSTR pChild=pEntry->pText[j>>2];
1783	cb = (int)lengthXMLString(pChild);
1784	if (cb)
1785	{
1786	if (nFormat!=-1)
1787	{
1788	if (lpszMarker)
1789	{
1790	charmemset(&lpszMarker[nResult],INDENTCHAR,sizeof(XMLCHAR)*(nFormat + 1));
1791	toXMLString(&lpszMarker[nResult+nFormat+1],pChild);
1792	lpszMarker[nResult+nFormat+1+cb]=_T('\n');
1793	}
1794	nResult+=cb+nFormat+2;
1795	} else
1796	{
1797	if (lpszMarker) toXMLString(&lpszMarker[nResult], pChild);
1798	nResult += cb;
1799	}
1800	}
1801	break;
1802	}
1803
1804	// Clear type nodes
1805	case eNodeClear:
1806	{
1807	XMLClear *pChild=pEntry->pClear+(j>>2);
1808	// "OpenTag"
1809	cb = (int)LENSTR(pChild->lpszOpenTag);
1810	if (cb)
1811	{
1812	if (nFormat!=-1)
1813	{
1814	if (lpszMarker)
1815	{
1816	charmemset(&lpszMarker[nResult], INDENTCHAR, sizeof(XMLCHAR)*(nFormat + 1));
1817	_tcscpy(&lpszMarker[nResult+nFormat+1], pChild->lpszOpenTag);
1818	}
1819	nResult+=cb+nFormat+1;
1820	}
1821	else
1822	{
1823	if (lpszMarker)_tcscpy(&lpszMarker[nResult], pChild->lpszOpenTag);
1824	nResult += cb;
1825	}
1826	}
1827
1828	// "OpenTag Value"
1829	cb = (int)LENSTR(pChild->lpszValue);
1830	if (cb)
1831	{
1832	if (lpszMarker) _tcscpy(&lpszMarker[nResult], pChild->lpszValue);
1833	nResult += cb;
1834	}
1835
1836	// "OpenTag Value CloseTag"
1837	cb = (int)LENSTR(pChild->lpszCloseTag);
1838	if (cb)
1839	{
1840	if (lpszMarker) _tcscpy(&lpszMarker[nResult], pChild->lpszCloseTag);
1841	nResult += cb;
1842	}
1843
1844	if (nFormat!=-1)
1845	{
1846	if (lpszMarker) lpszMarker[nResult] = _T('\n');
1847	nResult++;
1848	}
1849	break;
1850	}
1851
1852	// Element nodes
1853	case eNodeChild:
1854	{
1855	// Recursively add child nodes
1856	nResult += CreateXMLStringR(pEntry->pChild[j>>2].d, lpszMarker ? lpszMarker + nResult : 0, nChildFormat);
1857	break;
1858	}
1859	default: break;
1860	}
1861	}
1862
1863	if ((cbElement)&&(!pEntry->isDeclaration))
1864	{
1865	// If we have child entries we need to use long XML notation for
1866	// closing the element - "<elementname>blah blah blah</elementname>"
1867	if (nElementI)
1868	{
1869	// "</elementname>\0"
1870	if (lpszMarker)
1871	{
1872	if (nFormat != -1)
1873	{
1874	if (nFormat)
1875	{
1876	charmemset(&lpszMarker[nResult], INDENTCHAR,sizeof(XMLCHAR)*nFormat);
1877	nResult+=nFormat;
1878	}
1879	}
1880
1881	_tcscpy(&lpszMarker[nResult], _T("</"));
1882	nResult += 2;
1883	_tcscpy(&lpszMarker[nResult], pEntry->lpszName);
1884	nResult += cbElement;
1885
1886	if (nFormat == -1)
1887	{
1888	_tcscpy(&lpszMarker[nResult], _T(">"));
1889	nResult++;
1890	} else
1891	{
1892	_tcscpy(&lpszMarker[nResult], _T(">\n"));
1893	nResult+=2;
1894	}
1895	} else
1896	{
1897	if (nFormat != -1) nResult+=cbElement+4+nFormat;
1898	else nResult+=cbElement+3;
1899	}
1900	} else
1901	{
1902	// If there are no children we can use shorthand XML notation -
1903	// "<elementname/>"
1904	// "/>\0"
1905	if (lpszMarker)
1906	{
1907	if (nFormat == -1)
1908	{
1909	_tcscpy(&lpszMarker[nResult], _T("/>"));
1910	nResult += 2;
1911	}
1912	else
1913	{
1914	_tcscpy(&lpszMarker[nResult], _T("/>\n"));
1915	nResult += 3;
1916	}
1917	}
1918	else
1919	{
1920	nResult += nFormat == -1 ? 2 : 3;
1921	}
1922	}
1923	}
1924
1925	return nResult;
1926	}
1927
1928	#undef LENSTR
1929
1930	// Create an XML string
1931	// @param int nFormat - 0 if no formatting is required
1932	// otherwise nonzero for formatted text
1933	// with carriage returns and indentation.
1934	// @param int *pnSize - [out] pointer to the size of the
1935	// returned string not including the
1936	// NULL terminator.
1937	// @return XMLSTR - Allocated XML string, you must free
1938	// this with free().
1939	XMLSTR XMLNode::createXMLString(int nFormat, int *pnSize) const
1940	{
1941	if (!d) { if (pnSize) *pnSize=0; return NULL; }
1942
1943	XMLSTR lpszResult = NULL;
1944	int cbStr;
1945
1946	// Recursively Calculate the size of the XML string
1947	if (!dropWhiteSpace) nFormat=0;
1948	nFormat = nFormat ? 0 : -1;
1949	cbStr = CreateXMLStringR(d, 0, nFormat);
1950	assert(cbStr);
1951	// Alllocate memory for the XML string + the NULL terminator and
1952	// create the recursively XML string.
1953	lpszResult=(XMLSTR)malloc((cbStr+1)*sizeof(XMLCHAR));
1954	CreateXMLStringR(d, lpszResult, nFormat);
1955	if (pnSize) *pnSize = cbStr;
1956	return lpszResult;
1957	}
1958
1959	XMLNode::~XMLNode() { deleteNodeContent(); }
1960
1961	int XMLNode::detachFromParent(XMLNodeData *d)
1962	{
1963	XMLNode *pa=d->pParent->pChild;
1964	int i=0;
1965	while (((void)(pa[i].d))!=((void)d)) i++;
1966	d->pParent->nChild--;
1967	if (d->pParent->nChild) memmove(pa+i,pa+i+1,(d->pParent->nChild-i)*sizeof(XMLNode));
1968	else { free(pa); d->pParent->pChild=NULL; }
1969	return removeOrderElement(d->pParent,eNodeChild,i);
1970	}
1971
1972	void XMLNode::deleteNodeContent(char force)
1973	{
1974	if (!d) return;
1975	(d->ref_count) --;
1976	if ((d->ref_count==0)\|\|force)
1977	{
1978	int i;
1979	if (d->pParent) detachFromParent(d);
1980	for(i=0; i<d->nChild; i++) { d->pChild[i].d->pParent=NULL; d->pChild[i].deleteNodeContent(force); }
1981	free(d->pChild);
1982	for(i=0; i<d->nText; i++) free((void*)d->pText[i]);
1983	free(d->pText);
1984	for(i=0; i<d->nClear; i++) free((void*)d->pClear[i].lpszValue);
1985	free(d->pClear);
1986	for(i=0; i<d->nAttribute; i++)
1987	{
1988	free((void*)d->pAttribute[i].lpszName);
1989	if (d->pAttribute[i].lpszValue) free((void*)d->pAttribute[i].lpszValue);
1990	}
1991	free(d->pAttribute);
1992	free(d->pOrder);
1993	free((void*)d->lpszName);
1994	free(d);
1995	d=NULL;
1996	}
1997	}
1998
1999	XMLNode XMLNode::addChild(XMLNode childNode, int pos)
2000	{
2001	XMLNodeData *dc=childNode.d;
2002	if ((!dc)\|\|(!d)) return childNode;
2003	if (dc->pParent) { if ((detachFromParent(dc)<=pos)&&(dc->pParent==d)) pos--; } else dc->ref_count++;
2004	dc->pParent=d;
2005	// int nc=d->nChild;
2006	// d->pChild=(XMLNode*)myRealloc(d->pChild,(nc+1),memoryIncrease,sizeof(XMLNode));
2007	d->pChild=(XMLNode*)addToOrder(&pos,d->nChild,d->pChild,sizeof(XMLNode),eNodeChild);
2008	d->pChild[pos].d=dc;
2009	d->nChild++;
2010	return childNode;
2011	}
2012
2013	void XMLNode::deleteAttribute(int i)
2014	{
2015	if ((!d)\|\|(i<0)\|\|(i>=d->nAttribute)) return;
2016	d->nAttribute--;
2017	XMLAttribute *p=d->pAttribute+i;
2018	free((void*)p->lpszName);
2019	if (p->lpszValue) free((void*)p->lpszValue);
2020	if (d->nAttribute) memmove(p,p+1,(d->nAttribute-i)*sizeof(XMLAttribute)); else { free(p); d->pAttribute=NULL; }
2021	}
2022
2023	void XMLNode::deleteAttribute(XMLAttribute *a){ if (a) deleteAttribute(a->lpszName); }
2024	void XMLNode::deleteAttribute(XMLCSTR lpszName)
2025	{
2026	int j=0;
2027	getAttribute(lpszName,&j);
2028	if (j) deleteAttribute(j-1);
2029	}
2030
2031	XMLAttribute *XMLNode::updateAttribute_WOSD(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,int i)
2032	{
2033	if (!d) return NULL;
2034	if (i>=d->nAttribute)
2035	{
2036	if (lpszNewName) return addAttribute_WOSD(lpszNewName,lpszNewValue);
2037	return NULL;
2038	}
2039	XMLAttribute *p=d->pAttribute+i;
2040	if (p->lpszValue&&p->lpszValue!=lpszNewValue) free((void*)p->lpszValue);
2041	p->lpszValue=lpszNewValue;
2042	if (lpszNewName&&p->lpszName!=lpszNewName) { free((void*)p->lpszName); p->lpszName=lpszNewName; };
2043	return p;
2044	}
2045
2046	XMLAttribute XMLNode::updateAttribute_WOSD(XMLAttribute newAttribute, XMLAttribute *oldAttribute)
2047	{
2048	if (oldAttribute) return updateAttribute_WOSD(newAttribute->lpszValue,newAttribute->lpszName,oldAttribute->lpszName);
2049	return addAttribute_WOSD(newAttribute->lpszName,newAttribute->lpszValue);
2050	}
2051
2052	XMLAttribute *XMLNode::updateAttribute_WOSD(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,XMLCSTR lpszOldName)
2053	{
2054	int j=0;
2055	getAttribute(lpszOldName,&j);
2056	if (j) return updateAttribute_WOSD(lpszNewValue,lpszNewName,j-1);
2057	else
2058	{
2059	if (lpszNewName) return addAttribute_WOSD(lpszNewName,lpszNewValue);
2060	else return addAttribute_WOSD(stringDup(lpszOldName),lpszNewValue);
2061	}
2062	}
2063
2064	int XMLNode::indexText(XMLCSTR lpszValue) const
2065	{
2066	if (!d) return -1;
2067	int i,l=d->nText;
2068	if (!lpszValue) { if (l) return 0; return -1; }
2069	XMLCSTR *p=d->pText;
2070	for (i=0; i<l; i++) if (lpszValue==p[i]) return i;
2071	return -1;
2072	}
2073
2074	void XMLNode::deleteText(int i)
2075	{
2076	if ((!d)\|\|(i<0)\|\|(i>=d->nText)) return;
2077	d->nText--;
2078	XMLCSTR *p=d->pText+i;
2079	free((void)p);
2080	if (d->nText) memmove(p,p+1,(d->nText-i)*sizeof(XMLCSTR)); else { free(p); d->pText=NULL; }
2081	removeOrderElement(d,eNodeText,i);
2082	}
2083
2084	void XMLNode::deleteText(XMLCSTR lpszValue) { deleteText(indexText(lpszValue)); }
2085
2086	XMLCSTR XMLNode::updateText_WOSD(XMLCSTR lpszNewValue, int i)
2087	{
2088	if (!d) return NULL;
2089	if (i>=d->nText) return addText_WOSD(lpszNewValue);
2090	XMLCSTR *p=d->pText+i;
2091	if (p!=lpszNewValue) { free((void)p); p=lpszNewValue; }
2092	return lpszNewValue;
2093	}
2094
2095	XMLCSTR XMLNode::updateText_WOSD(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue)
2096	{
2097	if (!d) return NULL;
2098	int i=indexText(lpszOldValue);
2099	if (i>=0) return updateText_WOSD(lpszNewValue,i);
2100	return addText_WOSD(lpszNewValue);
2101	}
2102
2103	void XMLNode::deleteClear(int i)
2104	{
2105	if ((!d)\|\|(i<0)\|\|(i>=d->nClear)) return;
2106	d->nClear--;
2107	XMLClear *p=d->pClear+i;
2108	free((void*)p->lpszValue);
2109	if (d->nClear) memmove(p,p+1,(d->nText-i)*sizeof(XMLClear)); else { free(p); d->pClear=NULL; }
2110	removeOrderElement(d,eNodeClear,i);
2111	}
2112
2113	int XMLNode::indexClear(XMLCSTR lpszValue) const
2114	{
2115	if (!d) return -1;
2116	int i,l=d->nClear;
2117	if (!lpszValue) { if (l) return 0; return -1; }
2118	XMLClear *p=d->pClear;
2119	for (i=0; i<l; i++) if (lpszValue==p[i].lpszValue) return i;
2120	return -1;
2121	}
2122
2123	void XMLNode::deleteClear(XMLCSTR lpszValue) { deleteClear(indexClear(lpszValue)); }
2124	void XMLNode::deleteClear(XMLClear *a) { if (a) deleteClear(a->lpszValue); }
2125
2126	XMLClear *XMLNode::updateClear_WOSD(XMLCSTR lpszNewContent, int i)
2127	{
2128	if (!d) return NULL;
2129	if (i>=d->nClear)
2130	{
2131	return addClear_WOSD(XMLClearTags[0].lpszOpen,lpszNewContent,XMLClearTags[0].lpszClose);
2132	}
2133	XMLClear *p=d->pClear+i;
2134	if (lpszNewContent!=p->lpszValue) { free((void*)p->lpszValue); p->lpszValue=lpszNewContent; }
2135	return p;
2136	}
2137
2138	XMLClear *XMLNode::updateClear_WOSD(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue)
2139	{
2140	if (!d) return NULL;
2141	int i=indexClear(lpszOldValue);
2142	if (i>=0) return updateClear_WOSD(lpszNewValue,i);
2143	return addClear_WOSD(lpszNewValue,XMLClearTags[0].lpszOpen,XMLClearTags[0].lpszClose);
2144	}
2145
2146	XMLClear XMLNode::updateClear_WOSD(XMLClear newP,XMLClear *oldP)
2147	{
2148	if (oldP) return updateClear_WOSD(newP->lpszValue,oldP->lpszValue);
2149	return NULL;
2150	}
2151
2152	XMLNode& XMLNode::operator=( const XMLNode& A )
2153	{
2154	// shallow copy
2155	if (this != &A)
2156	{
2157	deleteNodeContent();
2158	d=A.d;
2159	if (d) (d->ref_count) ++ ;
2160	}
2161	return *this;
2162	}
2163
2164	XMLNode::XMLNode(const XMLNode &A)
2165	{
2166	// shallow copy
2167	d=A.d;
2168	if (d) (d->ref_count)++ ;
2169	}
2170
2171	int XMLNode::nChildNode(XMLCSTR name) const
2172	{
2173	if (!d) return 0;
2174	int i,j=0,n=d->nChild;
2175	XMLNode *pc=d->pChild;
2176	for (i=0; i<n; i++)
2177	{
2178	if (_tcsicmp(pc->d->lpszName, name)==0) j++;
2179	pc++;
2180	}
2181	return j;
2182	}
2183
2184	XMLNode XMLNode::getChildNode(XMLCSTR name, int *j) const
2185	{
2186	if (!d) return emptyXMLNode;
2187	int i=0,n=d->nChild;
2188	if (j) i=*j;
2189	XMLNode *pc=d->pChild+i;
2190	for (; i<n; i++)
2191	{
2192	if (_tcsicmp(pc->d->lpszName, name)==0)
2193	{
2194	if (j) *j=i+1;
2195	return *pc;
2196	}
2197	pc++;
2198	}
2199	return emptyXMLNode;
2200	}
2201
2202	XMLNode XMLNode::getChildNode(XMLCSTR name, int j) const
2203	{
2204	if (!d) return emptyXMLNode;
2205	int i=0;
2206	while (j-->0) getChildNode(name,&i);
2207	return getChildNode(name,&i);
2208	}
2209
2210	int XMLNode::positionOfText (int i) const { if (i>=d->nText ) i=d->nText-1; return findPosition(d,i,eNodeText ); }
2211	int XMLNode::positionOfClear (int i) const { if (i>=d->nClear) i=d->nClear-1; return findPosition(d,i,eNodeClear); }
2212	int XMLNode::positionOfChildNode(int i) const { if (i>=d->nChild) i=d->nChild-1; return findPosition(d,i,eNodeChild); }
2213	int XMLNode::positionOfText (XMLCSTR lpszValue) const { return positionOfText (indexText (lpszValue)); }
2214	int XMLNode::positionOfClear(XMLCSTR lpszValue) const { return positionOfClear(indexClear(lpszValue)); }
2215	int XMLNode::positionOfClear(XMLClear *a) const { if (a) return positionOfClear(a->lpszValue); return positionOfClear(); }
2216	int XMLNode::positionOfChildNode(XMLNode x) const
2217	{
2218	if ((!d)\|\|(!x.d)) return -1;
2219	XMLNodeData *dd=x.d;
2220	XMLNode *pc=d->pChild;
2221	int i=d->nChild;
2222	while (i--) if (pc[i].d==dd) return findPosition(d,i,eNodeChild);
2223	return -1;
2224	}
2225	int XMLNode::positionOfChildNode(XMLCSTR name, int count) const
2226	{
2227	if (!name) return positionOfChildNode(count);
2228	int j=0;
2229	do { getChildNode(name,&j); if (j<0) return -1; } while (count--);
2230	return findPosition(d,j-1,eNodeChild);
2231	}
2232
2233	XMLNode XMLNode::getChildNodeWithAttribute(XMLCSTR name,XMLCSTR attributeName,XMLCSTR attributeValue, int *k) const
2234	{
2235	int i=0,j;
2236	if (k) i=*k;
2237	XMLNode x;
2238	XMLCSTR t;
2239	do
2240	{
2241	x=getChildNode(name,&i);
2242	if (!x.isEmpty())
2243	{
2244	if (attributeValue)
2245	{
2246	j=0;
2247	do
2248	{
2249	t=x.getAttribute(attributeName,&j);
2250	if (t&&(_tcsicmp(attributeValue,t)==0)) { if (k) *k=i+1; return x; }
2251	} while (t);
2252	} else
2253	{
2254	if (x.isAttributeSet(attributeName)) { if (k) *k=i+1; return x; }
2255	}
2256	}
2257	} while (!x.isEmpty());
2258	return emptyXMLNode;
2259	}
2260
2261	// Find an attribute on an node.
2262	XMLCSTR XMLNode::getAttribute(XMLCSTR lpszAttrib, int *j) const
2263	{
2264	if (!d) return NULL;
2265	int i=0,n=d->nAttribute;
2266	if (j) i=*j;
2267	XMLAttribute *pAttr=d->pAttribute+i;
2268	for (; i<n; i++)
2269	{
2270	if (_tcsicmp(pAttr->lpszName, lpszAttrib)==0)
2271	{
2272	if (j) *j=i+1;
2273	return pAttr->lpszValue;
2274	}
2275	pAttr++;
2276	}
2277	return NULL;
2278	}
2279
2280	char XMLNode::isAttributeSet(XMLCSTR lpszAttrib) const
2281	{
2282	if (!d) return FALSE;
2283	int i,n=d->nAttribute;
2284	XMLAttribute *pAttr=d->pAttribute;
2285	for (i=0; i<n; i++)
2286	{
2287	if (_tcsicmp(pAttr->lpszName, lpszAttrib)==0)
2288	{
2289	return TRUE;
2290	}
2291	pAttr++;
2292	}
2293	return FALSE;
2294	}
2295
2296	XMLCSTR XMLNode::getAttribute(XMLCSTR name, int j) const
2297	{
2298	if (!d) return NULL;
2299	int i=0;
2300	while (j-->0) getAttribute(name,&i);
2301	return getAttribute(name,&i);
2302	}
2303
2304	XMLNodeContents XMLNode::enumContents(int i) const
2305	{
2306	XMLNodeContents c;
2307	if (!d) { c.type=eNodeNULL; return c; }
2308	if (i<d->nAttribute)
2309	{
2310	c.type=eNodeAttribute;
2311	c.attrib=d->pAttribute[i];
2312	return c;
2313	}
2314	i-=d->nAttribute;
2315	c.type=(XMLElementType)(d->pOrder[i]&3);
2316	i=(d->pOrder[i])>>2;
2317	switch (c.type)
2318	{
2319	case eNodeChild: c.child = d->pChild[i]; break;
2320	case eNodeText: c.text = d->pText[i]; break;
2321	case eNodeClear: c.clear = d->pClear[i]; break;
2322	default: break;
2323	}
2324	return c;
2325	}
2326
2327	XMLCSTR XMLNode::getName() const { if (!d) return NULL; return d->lpszName; }
2328	int XMLNode::nText() const { if (!d) return 0; return d->nText; }
2329	int XMLNode::nChildNode() const { if (!d) return 0; return d->nChild; }
2330	int XMLNode::nAttribute() const { if (!d) return 0; return d->nAttribute; }
2331	int XMLNode::nClear() const { if (!d) return 0; return d->nClear; }
2332	int XMLNode::nElement() const { if (!d) return 0; return d->nAttribute+d->nChild+d->nText+d->nClear; }
2333	XMLClear XMLNode::getClear (int i) const { if ((!d)\|\|(i>=d->nClear )) return emptyXMLClear; return d->pClear[i]; }
2334	XMLAttribute XMLNode::getAttribute (int i) const { if ((!d)\|\|(i>=d->nAttribute)) return emptyXMLAttribute; return d->pAttribute[i]; }
2335	XMLCSTR XMLNode::getAttributeName (int i) const { if ((!d)\|\|(i>=d->nAttribute)) return NULL; return d->pAttribute[i].lpszName; }
2336	XMLCSTR XMLNode::getAttributeValue(int i) const { if ((!d)\|\|(i>=d->nAttribute)) return NULL; return d->pAttribute[i].lpszValue; }
2337	XMLCSTR XMLNode::getText (int i) const { if ((!d)\|\|(i>=d->nText )) return NULL; return d->pText[i]; }
2338	XMLNode XMLNode::getChildNode (int i) const { if ((!d)\|\|(i>=d->nChild )) return emptyXMLNode; return d->pChild[i]; }
2339	XMLNode XMLNode::getParentNode ( ) const { if ((!d)\|\|(!d->pParent )) return emptyXMLNode; return XMLNode(d->pParent); }
2340	char XMLNode::isDeclaration ( ) const { if (!d) return 0; return d->isDeclaration; }
2341	char XMLNode::isEmpty ( ) const { return (d==NULL); }
2342
2343	XMLNode XMLNode::addChild(XMLCSTR lpszName, char isDeclaration, int pos)
2344	{ return addChild_WOSD(stringDup(lpszName),isDeclaration,pos); }
2345	XMLAttribute *XMLNode::addAttribute(XMLCSTR lpszName, XMLCSTR lpszValue)
2346	{ return addAttribute_WOSD(stringDup(lpszName),stringDup(lpszValue)); }
2347	XMLCSTR XMLNode::addText(XMLCSTR lpszValue, int pos)
2348	{ return addText_WOSD(stringDup(lpszValue),pos); }
2349	XMLClear *XMLNode::addClear(XMLCSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose, int pos)
2350	{ return addClear_WOSD(stringDup(lpszValue),lpszOpen,lpszClose,pos); }
2351	XMLCSTR XMLNode::updateName(XMLCSTR lpszName)
2352	{ return updateName_WOSD(stringDup(lpszName)); }
2353	XMLAttribute XMLNode::updateAttribute(XMLAttribute newAttribute, XMLAttribute *oldAttribute)
2354	{ return updateAttribute_WOSD(stringDup(newAttribute->lpszValue),stringDup(newAttribute->lpszName),oldAttribute->lpszName); }
2355	XMLAttribute *XMLNode::updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,int i)
2356	{ return updateAttribute_WOSD(stringDup(lpszNewValue),stringDup(lpszNewName),i); }
2357	XMLAttribute *XMLNode::updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,XMLCSTR lpszOldName)
2358	{ return updateAttribute_WOSD(stringDup(lpszNewValue),stringDup(lpszNewName),lpszOldName); }
2359	XMLCSTR XMLNode::updateText(XMLCSTR lpszNewValue, int i)
2360	{ return updateText_WOSD(stringDup(lpszNewValue),i); }
2361	XMLCSTR XMLNode::updateText(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue)
2362	{ return updateText_WOSD(stringDup(lpszNewValue),lpszOldValue); }
2363	XMLClear *XMLNode::updateClear(XMLCSTR lpszNewContent, int i)
2364	{ return updateClear_WOSD(stringDup(lpszNewContent),i); }
2365	XMLClear *XMLNode::updateClear(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue)
2366	{ return updateClear_WOSD(stringDup(lpszNewValue),lpszOldValue); }
2367	XMLClear XMLNode::updateClear(XMLClear newP,XMLClear *oldP)
2368	{ return updateClear_WOSD(stringDup(newP->lpszValue),oldP->lpszValue); }
2369
2370	void XMLNode::setGlobalOptions(char _guessUnicodeChars, char _strictUTF8Parsing, char _dropWhiteSpace)
2371	{
2372	guessUnicodeChars=_guessUnicodeChars; dropWhiteSpace=_dropWhiteSpace; strictUTF8Parsing=_strictUTF8Parsing;
2373	#ifndef _XMLUNICODE
2374	if (strictUTF8Parsing) XML_ByteTable=XML_utf8ByteTable; else XML_ByteTable=XML_asciiByteTable;
2375	#endif
2376	}
2377
2378	char XMLNode::guessUTF8ParsingParameterValue(void *buf,int l, char useXMLEncodingAttribute)
2379	{
2380	#ifdef _XMLUNICODE
2381	return 0;
2382	#else
2383	if (l<25) return 0;
2384	if (myIsTextUnicode(buf,l)) return 0;
2385	unsigned char b=(unsigned char)buf;
2386	if ((b[0]==0xef)&&(b[1]==0xbb)&&(b[2]==0xbf)) return 1;
2387
2388	// Match utf-8 model ?
2389	int i=0;
2390	while (i<l)
2391	switch (XML_utf8ByteTable[b[i]])
2392	{
2393	case 4: i++; if ((i<l)&&(b[i]& 0xC0)!=0x80) return 0; // 10bbbbbb ?
2394	case 3: i++; if ((i<l)&&(b[i]& 0xC0)!=0x80) return 0; // 10bbbbbb ?
2395	case 2: i++; if ((i<l)&&(b[i]& 0xC0)!=0x80) return 0; // 10bbbbbb ?
2396	case 1: i++; break;
2397	case 0: i=l;
2398	}
2399	if (!useXMLEncodingAttribute) return 1;
2400	// if encoding is specified and different from utf-8 than it's non-utf8
2401	// otherwise it's utf-8
2402	char bb[201];
2403	l=mmin(l,200);
2404	memcpy(bb,buf,l); // copy buf into bb to be able to do "bb[l]=0"
2405	bb[l]=0;
2406	b=(unsigned char*)strstr(bb,"encoding");
2407	if (!b) return 1;
2408	b+=8; while XML_isSPACECHAR(b) b++; if (b!='=') return 1;
2409	b++; while XML_isSPACECHAR(b) b++; if ((b!='\'')&&(*b!='"')) return 1;
2410	b++; while XML_isSPACECHAR(b) b++; if ((_strnicmp((char)b,"utf-8",5)==0)\|\|
2411	(_strnicmp((char*)b,"utf8",4)==0)) return 1;
2412	return 0;
2413	#endif
2414	}
2415	#undef XML_isSPACECHAR
2416
2417	//////////////////////////////////////////////////////////
2418	// Here starts the base64 conversion functions. //
2419	//////////////////////////////////////////////////////////
2420
2421	static const char base64Fillchar = _T('='); // used to mark partial words at the end
2422
2423	// this lookup table defines the base64 encoding
2424	XMLCSTR base64EncodeTable=_T("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
2425
2426	// Decode Table gives the index of any valid base64 character in the Base64 table]
2427	// 96: '=' - 97: space char - 98: illegal char - 99: end of string
2428	const unsigned char base64DecodeTable[] = {
2429	99,98,98,98,98,98,98,98,98,97, 97,98,98,97,98,98,98,98,98,98, 98,98,98,98,98,98,98,98,98,98, //00 -29
2430	98,98,97,98,98,98,98,98,98,98, 98,98,98,62,98,98,98,63,52,53, 54,55,56,57,58,59,60,61,98,98, //30 -59
2431	98,96,98,98,98, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14, 15,16,17,18,19,20,21,22,23,24, //60 -89
2432	25,98,98,98,98,98,98,26,27,28, 29,30,31,32,33,34,35,36,37,38, 39,40,41,42,43,44,45,46,47,48, //90 -119
2433	49,50,51,98,98,98,98,98,98,98, 98,98,98,98,98,98,98,98,98,98, 98,98,98,98,98,98,98,98,98,98, //120 -149
2434	98,98,98,98,98,98,98,98,98,98, 98,98,98,98,98,98,98,98,98,98, 98,98,98,98,98,98,98,98,98,98, //150 -179
2435	98,98,98,98,98,98,98,98,98,98, 98,98,98,98,98,98,98,98,98,98, 98,98,98,98,98,98,98,98,98,98, //180 -209
2436	98,98,98,98,98,98,98,98,98,98, 98,98,98,98,98,98,98,98,98,98, 98,98,98,98,98,98,98,98,98,98, //210 -239
2437	98,98,98,98,98,98,98,98,98,98, 98,98,98,98,98,98 //240 -255
2438	};
2439
2440	XMLParserBase64Tool::~XMLParserBase64Tool(){ freeBuffer(); }
2441
2442	void XMLParserBase64Tool::freeBuffer(){ if (buf) free(buf); buf=NULL; buflen=0; }
2443
2444	int XMLParserBase64Tool::encodeLength(int inlen, char formatted)
2445	{
2446	unsigned int i=((inlen-1)/3*4+4+1);
2447	if (formatted) i+=inlen/54;
2448	return i;
2449	}
2450
2451	XMLSTR XMLParserBase64Tool::encode(unsigned char *inbuf, unsigned int inlen, char formatted)
2452	{
2453	int i=encodeLength(inlen,formatted),k=17,eLen=inlen/3,j;
2454	alloc(i*sizeof(XMLCHAR));
2455	XMLSTR curr=(XMLSTR)buf;
2456	for(i=0;i<eLen;i++)
2457	{
2458	// Copy next three bytes into lower 24 bits of int, paying attention to sign.
2459	j=(inbuf[0]<<16)\|(inbuf[1]<<8)\|inbuf[2]; inbuf+=3;
2460	// Encode the int into four chars
2461	*(curr++)=base64EncodeTable[ j>>18 ];
2462	*(curr++)=base64EncodeTable[(j>>12)&0x3f];
2463	*(curr++)=base64EncodeTable[(j>> 6)&0x3f];
2464	*(curr++)=base64EncodeTable[(j )&0x3f];
2465	if (formatted) { if (!k) { *(curr++)=_T('\n'); k=18; } k--; }
2466	}
2467	eLen=inlen-eLen*3; // 0 - 2.
2468	if (eLen==1)
2469	{
2470	*(curr++)=base64EncodeTable[ inbuf[0]>>2 ];
2471	*(curr++)=base64EncodeTable[(inbuf[0]<<4)&0x3F];
2472	*(curr++)=base64Fillchar;
2473	*(curr++)=base64Fillchar;
2474	} else if (eLen==2)
2475	{
2476	j=(inbuf[0]<<8)\|inbuf[1];
2477	*(curr++)=base64EncodeTable[ j>>10 ];
2478	*(curr++)=base64EncodeTable[(j>> 4)&0x3f];
2479	*(curr++)=base64EncodeTable[(j<< 2)&0x3f];
2480	*(curr++)=base64Fillchar;
2481	}
2482	*(curr++)=0;
2483	return (XMLSTR)buf;
2484	}
2485
2486	unsigned int XMLParserBase64Tool::decodeSize(XMLCSTR data,XMLError *xe)
2487	{
2488	if (xe) *xe=eXMLErrorNone;
2489	int size=0;
2490	unsigned char c;
2491	//skip any extra characters (e.g. newlines or spaces)
2492	while (*data)
2493	{
2494	#ifdef _XMLUNICODE
2495	if (data>255) { if (xe) xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; }
2496	#endif
2497	c=base64DecodeTable[(unsigned char)(*data)];
2498	if (c<97) size++;
2499	else if (c==98) { if (xe) *xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; }
2500	data++;
2501	}
2502	if (xe&&(size%4!=0)) *xe=eXMLErrorBase64DataSizeIsNotMultipleOf4;
2503	if (size==0) return 0;
2504	do { data--; size--; } while(*data==base64Fillchar); size++;
2505	return (unsigned int)((size*3)/4);
2506	}
2507
2508	unsigned char XMLParserBase64Tool::decode(XMLCSTR data, unsigned char buf, int len, XMLError xe)
2509	{
2510	if (xe) *xe=eXMLErrorNone;
2511	int i=0,p=0;
2512	unsigned char d,c;
2513	for(;;)
2514	{
2515
2516	#ifdef _XMLUNICODE
2517	#define BASE64DECODE_READ_NEXT_CHAR(c) \
2518	do { \
2519	if (data[i]>255){ c=98; break; } \
2520	c=base64DecodeTable[(unsigned char)data[i++]]; \
2521	}while (c==97); \
2522	if(c==98){ if(xe)*xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; }
2523	#else
2524	#define BASE64DECODE_READ_NEXT_CHAR(c) \
2525	do { c=base64DecodeTable[(unsigned char)data[i++]]; }while (c==97); \
2526	if(c==98){ if(xe)*xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; }
2527	#endif
2528
2529	BASE64DECODE_READ_NEXT_CHAR(c)
2530	if (c==99) { return 2; }
2531	if (c==96)
2532	{
2533	if (p==(int)len) return 2;
2534	if (xe) *xe=eXMLErrorBase64DecodeTruncatedData;
2535	return 1;
2536	}
2537
2538	BASE64DECODE_READ_NEXT_CHAR(d)
2539	if ((d==99)\|\|(d==96)) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData; return 1; }
2540	if (p==(int)len) { if (xe) *xe=eXMLErrorBase64DecodeBufferTooSmall; return 0; }
2541	buf[p++]=(c<<2)\|((d>>4)&0x3);
2542
2543	BASE64DECODE_READ_NEXT_CHAR(c)
2544	if (c==99) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData; return 1; }
2545	if (p==(int)len)
2546	{
2547	if (c==96) return 2;
2548	if (xe) *xe=eXMLErrorBase64DecodeBufferTooSmall;
2549	return 0;
2550	}
2551	if (c==96) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData; return 1; }
2552	buf[p++]=((d<<4)&0xf0)\|((c>>2)&0xf);
2553
2554	BASE64DECODE_READ_NEXT_CHAR(d)
2555	if (d==99 ) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData; return 1; }
2556	if (p==(int)len)
2557	{
2558	if (d==96) return 2;
2559	if (xe) *xe=eXMLErrorBase64DecodeBufferTooSmall;
2560	return 0;
2561	}
2562	if (d==96) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData; return 1; }
2563	buf[p++]=((c<<6)&0xc0)\|d;
2564	}
2565	}
2566	#undef BASE64DECODE_READ_NEXT_CHAR
2567
2568	void XMLParserBase64Tool::alloc(int newsize)
2569	{
2570	if ((!buf)&&(newsize)) { buf=malloc(newsize); buflen=newsize; return; }
2571	if (newsize>buflen) { buf=realloc(buf,newsize); buflen=newsize; }
2572	}
2573
2574	unsigned char XMLParserBase64Tool::decode(XMLCSTR data, int outlen, XMLError *xe)
2575	{
2576	if (xe) *xe=eXMLErrorNone;
2577	unsigned int len=decodeSize(data,xe);
2578	if (outlen) *outlen=len;
2579	if (!len) return NULL;
2580	alloc(len+1);
2581	if(!decode(data,(unsigned char*)buf,len,xe)){ return NULL; }
2582	return (unsigned char*)buf;
2583	}
2584
2585	XMLNode XMLNode::operator/(XMLCSTR name)
2586	{
2587	return getChildNode(name);
2588	}
2589
2590	XMLCSTR XMLNode::operator\|(XMLCSTR name)
2591	{
2592	return getAttribute(name);
2593	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: GTP/trunk/App/Demos/Illum/pathmap/xmlParser.cpp @ 2197

Download in other formats: