2 # ---------------------------------------------------------------------
4 # Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
6 # Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
7 # Previous Authors : Laurent Guigues, Jean-Pierre Roux
8 # CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
10 # This software is governed by the CeCILL-B license under French law and
11 # abiding by the rules of distribution of free software. You can use,
12 # modify and/ or redistribute the software under the terms of the CeCILL-B
13 # license as circulated by CEA, CNRS and INRIA at the following URL
14 # http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
15 # or in the file LICENSE.txt.
17 # As a counterpart to the access to the source code and rights to copy,
18 # modify and redistribute granted by the license, users are provided only
19 # with a limited warranty and the software's author, the holder of the
20 # economic rights, and the successive licensors have only limited
23 # The fact that you are presently reading this means that you have had
24 # knowledge of the CeCILL-B license and that you accept its terms.
25 # ------------------------------------------------------------------------ */
29 ****************************************************************************
30 * <P> XML.c - implementation file for basic XML parser written in ANSI C++
31 * for portability. It works by using recursion and a node tree for breaking
32 * down the elements of an XML document. </P>
35 * @author Frank Vanden Berghen
39 * If you add "#define STRICT_PARSING", on the first line of this file
40 * the parser will see the following XML-stream:
41 * <a><b>some text</b><b>other text </a>
42 * as an error. Otherwise, this tring will be equivalent to:
43 * <a><b>some text</b><b>other text</b></a>
47 * If you add "#define APPROXIMATE_PARSING" on the first line of this file
48 * the parser will see the following XML-stream:
52 * as equivalent to the following XML-stream:
56 * This can be useful for badly-formed XML-streams but prevent the use
57 * of the following XML-stream (problem is: tags at contiguous levels
58 * have the same names):
67 * If you add "#define _XMLPARSER_NO_MESSAGEBOX_" on the first line of this file
68 * the "openFileHelper" function will always display error messages inside the
69 * console instead of inside a message-box-window. Message-box-windows are
70 * available on windows 9x/NT/2000/XP/Vista only.
73 * Copyright (c) 2002, Frank Vanden Berghen
74 * All rights reserved.
75 * Redistribution and use in source and binary forms, with or without
76 * modification, are permitted provided that the following conditions are met:
78 * * Redistributions of source code must retain the above copyright
79 * notice, this list of conditions and the following disclaimer.
80 * * Redistributions in binary form must reproduce the above copyright
81 * notice, this list of conditions and the following disclaimer in the
82 * documentation and/or other materials provided with the distribution.
83 * * Neither the name of the Frank Vanden Berghen nor the
84 * names of its contributors may be used to endorse or promote products
85 * derived from this software without specific prior written permission.
87 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
88 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
89 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
90 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
91 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
92 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
93 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
94 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
95 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
96 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
98 ****************************************************************************
100 #ifndef _CRT_SECURE_NO_DEPRECATE
101 #define _CRT_SECURE_NO_DEPRECATE
103 #include "xmlParser.h"
106 //#define _CRTDBG_MAP_ALLOC
107 //#include <crtdbg.h>
109 #define WIN32_LEAN_AND_MEAN
110 #include <Windows.h> // to have IsTextUnicode, MultiByteToWideChar, WideCharToMultiByte to handle unicode files
111 // to have "MessageBoxA" to display error messages for openFilHelper
120 XMLCSTR XMLNode::getVersion() { return _T("v2.23"); }
121 void free_XMLDLL(void *t){free(t);}
123 static char strictUTF8Parsing=1, guessUnicodeChars=1, dropWhiteSpace=1;
125 inline int mmin( const int t1, const int t2 ) { return t1 < t2 ? t1 : t2; }
127 // You can modify the initialization of the variable "XMLClearTags" below
128 // to change the clearTags that are currently recognized by the library.
129 // The number on the second columns is the length of the string inside the
130 // first column. The "<!DOCTYPE" declaration must be the second in the list.
131 static ALLXMLClearTag XMLClearTags[] =
133 { _T("<![CDATA["),9, _T("]]>") },
134 { _T("<!DOCTYPE"),9, _T(">") },
135 { _T("<PRE>") ,5, _T("</PRE>") },
136 { _T("<Script>") ,8, _T("</Script>")},
137 { _T("<!--") ,4, _T("-->") },
140 ALLXMLClearTag* XMLNode::getClearTagTable() { return XMLClearTags; }
142 // You can modify the initialization of the variable "XMLEntities" below
143 // to change the character entities that are currently recognized by the library.
144 // The number on the second columns is the length of the string inside the
145 // first column. Additionally, the syntaxes " " and " " are recognized.
146 typedef struct { XMLCSTR s; int l; XMLCHAR c;} XMLCharacterEntity;
147 static XMLCharacterEntity XMLEntities[] =
149 { _T("&" ), 5, _T('&' )},
150 { _T("<" ), 4, _T('<' )},
151 { _T(">" ), 4, _T('>' )},
152 { _T("""), 6, _T('\"')},
153 { _T("'"), 6, _T('\'')},
157 // When rendering the XMLNode to a string (using the "createXMLString" function),
158 // you can ask for a beautiful formatting. This formatting is using the
159 // following indentation character:
160 #define INDENTCHAR _T('\t')
162 // The following function parses the XML errors into a user friendly string.
163 // You can edit this to change the output language of the library to something else.
164 XMLCSTR XMLNode::getError(XMLError xerror)
168 case eXMLErrorNone: return _T("No error");
169 case eXMLErrorMissingEndTag: return _T("Warning: Unmatched end tag");
170 case eXMLErrorEmpty: return _T("Error: No XML data");
171 case eXMLErrorFirstNotStartTag: return _T("Error: First token not start tag");
172 case eXMLErrorMissingTagName: return _T("Error: Missing start tag name");
173 case eXMLErrorMissingEndTagName: return _T("Error: Missing end tag name");
174 case eXMLErrorNoMatchingQuote: return _T("Error: Unmatched quote");
175 case eXMLErrorUnmatchedEndTag: return _T("Error: Unmatched end tag");
176 case eXMLErrorUnmatchedEndClearTag: return _T("Error: Unmatched clear tag end");
177 case eXMLErrorUnexpectedToken: return _T("Error: Unexpected token found");
178 case eXMLErrorInvalidTag: return _T("Error: Invalid tag found");
179 case eXMLErrorNoElements: return _T("Error: No elements found");
180 case eXMLErrorFileNotFound: return _T("Error: File not found");
181 case eXMLErrorFirstTagNotFound: return _T("Error: First Tag not found");
182 case eXMLErrorUnknownCharacterEntity:return _T("Error: Unknown character entity");
183 case eXMLErrorCharConversionError: return _T("Error: unable to convert between UNICODE and MultiByte chars");
184 case eXMLErrorCannotOpenWriteFile: return _T("Error: unable to open file for writing");
185 case eXMLErrorCannotWriteFile: return _T("Error: cannot write into file");
187 case eXMLErrorBase64DataSizeIsNotMultipleOf4: return _T("Warning: Base64-string length is not a multiple of 4");
188 case eXMLErrorBase64DecodeTruncatedData: return _T("Warning: Base64-string is truncated");
189 case eXMLErrorBase64DecodeIllegalCharacter: return _T("Error: Base64-string contains an illegal character");
190 case eXMLErrorBase64DecodeBufferTooSmall: return _T("Error: Base64 decode output buffer is too small");
192 return _T("Unknown");
195 // Here is an abstraction layer to access some common string manipulation functions.
196 // The abstraction layer is currently working for gcc, Microsoft Visual Studio 6.0,
197 // Microsoft Visual Studio .NET, CC (sun compiler) and Borland C++.
198 // If you plan to "port" the library to a new system/compiler, all you have to do is
199 // to edit the following lines.
200 #ifdef XML_NO_WIDE_CHAR
201 char myIsTextUnicode(const void *b, int len) { return FALSE; }
203 #if defined (UNDER_CE) || !defined(WIN32)
204 char myIsTextUnicode(const void *b, int len) // inspired by the Wine API: RtlIsTextUnicode
207 // for SPARC processors: wchar_t* buffers must always be alligned, otherwise it's a char* buffer.
208 if ((((unsigned long)b)%sizeof(wchar_t))!=0) return FALSE;
210 const wchar_t *s=(const wchar_t*)b;
213 if (len<(int)sizeof(wchar_t)) return FALSE;
216 if (len&1) return FALSE;
218 /* only checks the first 256 characters */
219 len=mmin(256,len/sizeof(wchar_t));
221 // Check for the special byte order:
222 if (*s == 0xFFFE) return FALSE; // IS_TEXT_UNICODE_REVERSE_SIGNATURE;
223 if (*s == 0xFEFF) return TRUE; // IS_TEXT_UNICODE_SIGNATURE
225 // checks for ASCII characters in the UNICODE stream
227 for (i=0; i<len; i++) if (s[i]<=(unsigned short)255) stats++;
228 if (stats>len/2) return TRUE;
230 // Check for UNICODE NULL chars
231 for (i=0; i<len; i++) if (!s[i]) return TRUE;
236 char myIsTextUnicode(const void *b,int l) { return (char)IsTextUnicode((CONST LPVOID)b,l,NULL); };
241 // for Microsoft Visual Studio 6.0 and Microsoft Visual Studio .NET,
243 wchar_t *myMultiByteToWideChar(const char *s,int l)
246 if (strictUTF8Parsing) i=(int)MultiByteToWideChar(CP_UTF8,0 ,s,l,NULL,0);
247 else i=(int)MultiByteToWideChar(CP_ACP ,MB_PRECOMPOSED,s,l,NULL,0);
248 if (i<0) return NULL;
249 wchar_t *d=(wchar_t *)malloc((i+1)*sizeof(XMLCHAR));
250 if (strictUTF8Parsing) i=(int)MultiByteToWideChar(CP_UTF8,0 ,s,l,d,i);
251 else i=(int)MultiByteToWideChar(CP_ACP ,MB_PRECOMPOSED,s,l,d,i);
256 char *myWideCharToMultiByte(const wchar_t *s,int l)
258 UINT codePage=CP_ACP; if (strictUTF8Parsing) codePage=CP_UTF8;
259 int i=(int)WideCharToMultiByte(codePage, // code page
260 0, // performance and mapping flags
261 s, // wide-character string
262 l, // number of chars in string
263 NULL, // buffer for new string
265 NULL, // default for unmappable chars
266 NULL // set when default char used
268 if (i<0) return NULL;
269 char *d=(char*)malloc(i+1);
270 WideCharToMultiByte(codePage,// code page
271 0, // performance and mapping flags
272 s, // wide-character string
273 l, // number of chars in string
274 d, // buffer for new string
276 NULL, // default for unmappable chars
277 NULL // set when default char used
284 int _strnicmp(char *c1, char *c2, int l){ return strnicmp(c1,c2,l);}
288 #ifdef XML_NO_WIDE_CHAR
289 char *myWideCharToMultiByte(const wchar_t *s, int l) { return NULL; }
291 char *myWideCharToMultiByte(const wchar_t *s, int l)
294 int i=(int)wcsrtombs(NULL,&ss,0,NULL);
295 if (i<0) return NULL;
296 char *d=(char *)malloc(i+1);
297 wcsrtombs(d,&s,i,NULL);
303 wchar_t *myMultiByteToWideChar(const char *s, int l)
306 int i=(int)mbsrtowcs(NULL,&ss,0,NULL);
307 if (i<0) return NULL;
308 wchar_t *d=(wchar_t *)malloc((i+1)*sizeof(wchar_t));
309 mbsrtowcs(d,&s,l,NULL);
313 int _tcslen(XMLCSTR c) { return wcslen(c); }
317 int _tcsnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return wsncasecmp(c1,c2,l);}
318 int _tcsicmp(XMLCSTR c1, XMLCSTR c2) { return wscasecmp(c1,c2); }
321 int _tcsnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return wcsncasecmp(c1,c2,l);}
322 int _tcsicmp(XMLCSTR c1, XMLCSTR c2) { return wcscasecmp(c1,c2); }
324 XMLSTR _tcsstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)wcsstr(c1,c2); }
325 XMLSTR _tcscpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)wcscpy(c1,c2); }
326 FILE *_tfopen(XMLCSTR filename,XMLCSTR mode)
328 char *filenameAscii=myWideCharToMultiByte(filename,0);
330 if (mode[0]==_T('r')) f=fopen(filenameAscii,"rb");
331 else f=fopen(filenameAscii,"wb");
336 FILE *_tfopen(XMLCSTR filename,XMLCSTR mode) { return fopen(filename,mode); }
337 int _tcslen(XMLCSTR c) { return strlen(c); }
338 int _tcsnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return strncasecmp(c1,c2,l);}
339 int _tcsicmp(XMLCSTR c1, XMLCSTR c2) { return strcasecmp(c1,c2); }
340 XMLSTR _tcsstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)strstr(c1,c2); }
341 XMLSTR _tcscpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)strcpy(c1,c2); }
343 int _strnicmp(const char *c1,const char *c2, int l) { return strncasecmp(c1,c2,l);}
346 /////////////////////////////////////////////////////////////////////////
347 // Here start the core implementation of the XMLParser library //
348 /////////////////////////////////////////////////////////////////////////
350 // You should normally not change anything below this point.
351 // For your own information, I suggest that you read the openFileHelper below:
352 XMLNode XMLNode::openFileHelper(XMLCSTR filename, XMLCSTR tag)
354 // guess the value of the global parameter "strictUTF8Parsing"
355 // (the guess is based on the first 200 bytes of the file).
356 FILE *f=_tfopen(filename,_T("rb"));
360 int l=(int)fread(bb,1,200,f);
361 setGlobalOptions(guessUnicodeChars,guessUTF8ParsingParameterValue(bb,l),dropWhiteSpace);
367 XMLNode xnode=XMLNode::parseFile(filename,tag,&pResults);
369 // display error message (if any)
370 if (pResults.error != eXMLErrorNone)
373 char message[2000],*s1=(char*)"",*s3=(char*)""; XMLCSTR s2=_T("");
374 if (pResults.error==eXMLErrorFirstTagNotFound) { s1=(char*)"First Tag should be '"; s2=tag; s3=(char*)"'.\n"; }
377 "XML Parsing error inside file '%S'.\n%S\nAt line %i, column %i.\n%s%S%s"
379 "XML Parsing error inside file '%s'.\n%s\nAt line %i, column %i.\n%s%s%s"
381 ,filename,XMLNode::getError(pResults.error),pResults.nLine,pResults.nColumn,s1,s2,s3);
384 #if defined(WIN32) && !defined(UNDER_CE) && !defined(_XMLPARSER_NO_MESSAGEBOX_)
385 MessageBoxA(NULL,message,"XML Parsing error",MB_OK|MB_ICONERROR|MB_TOPMOST);
387 printf("%s",message);
395 // If "strictUTF8Parsing=0" then we assume that all characters have the same length of 1 byte.
396 // If "strictUTF8Parsing=1" then the characters have different lengths (from 1 byte to 4 bytes).
397 // This table is used as lookup-table to know the length of a character (in byte) based on the
398 // content of the first byte of the character.
399 // (note: if you modify this, you must always have XML_utf8ByteTable[0]=0 ).
400 static const char XML_utf8ByteTable[256] =
402 // 0 1 2 3 4 5 6 7 8 9 a b c d e f
403 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x00
404 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x10
405 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x20
406 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x30
407 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x40
408 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x50
409 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x60
410 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x70End of ASCII range
411 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x80 0x80 to 0xc1 invalid
412 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x90
413 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xa0
414 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xb0
415 1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xc0 0xc2 to 0xdf 2 byte
416 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xd0
417 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,// 0xe0 0xe0 to 0xef 3 byte
418 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
420 static const char XML_asciiByteTable[256] =
422 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,
423 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,
424 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,
425 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,
426 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,
427 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
429 static const char *XML_ByteTable=(const char *)XML_utf8ByteTable; // the default is "strictUTF8Parsing=1"
432 XMLError XMLNode::writeToFile(XMLCSTR filename, const char *encoding, char nFormat) const
434 //printf("EED XMLNode::writeToFile 01\n");
436 XMLSTR t=createXMLString(nFormat,&i);
437 FILE *f=_tfopen(filename,_T("wb"));
438 if (!f) return eXMLErrorCannotOpenWriteFile;
440 unsigned char h[2]={ 0xFF, 0xFE };
441 if (!fwrite(h,2,1,f)) return eXMLErrorCannotWriteFile;
442 if (!isDeclaration())
444 if (!fwrite(_T("<?xml version=\"1.0\" encoding=\"utf-16\"?>\n"),sizeof(wchar_t)*40,1,f))
445 return eXMLErrorCannotWriteFile;
448 if (!isDeclaration())
450 if ((!encoding)||(XML_ByteTable==XML_utf8ByteTable))
452 // header so that windows recognize the file as UTF-8:
453 unsigned char h[3]={0xEF,0xBB,0xBF};
454 if (!fwrite(h,3,1,f)) return eXMLErrorCannotWriteFile;
455 if (!fwrite("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",39,1,f)) return eXMLErrorCannotWriteFile;
458 if (fprintf(f,"<?xml version=\"1.0\" encoding=\"%s\"?>\n",encoding)<0) return eXMLErrorCannotWriteFile;
461 if (XML_ByteTable==XML_utf8ByteTable) // test if strictUTF8Parsing==1"
463 unsigned char h[3]={0xEF,0xBB,0xBF}; if (!fwrite(h,3,1,f)) return eXMLErrorCannotWriteFile;
467 if (!fwrite(t,sizeof(XMLCHAR)*i,1,f)) return eXMLErrorCannotWriteFile;
468 //printf("EED XMLNode::writeToFile 02\n");
469 if (fclose(f)!=0) return eXMLErrorCannotWriteFile;
471 return eXMLErrorNone;
474 // Duplicate a given string.
475 XMLSTR stringDup(XMLCSTR lpszData, int cbData)
477 if (lpszData==NULL) return NULL;
480 if (cbData==0) cbData=(int)_tcslen(lpszData);
481 lpszNew = (XMLSTR)malloc((cbData+1) * sizeof(XMLCHAR));
484 memcpy(lpszNew, lpszData, (cbData) * sizeof(XMLCHAR));
485 lpszNew[cbData] = (XMLCHAR)NULL;
490 XMLNode XMLNode::emptyXMLNode;
491 XMLClear XMLNode::emptyXMLClear={ NULL, NULL, NULL};
492 XMLAttribute XMLNode::emptyXMLAttribute={ NULL, NULL};
494 // Enumeration used to decipher what type a token is
495 typedef enum XMLTokenTypeTag
499 eTokenTagStart, /* "<" */
500 eTokenTagEnd, /* "</" */
501 eTokenCloseTag, /* ">" */
502 eTokenEquals, /* "=" */
503 eTokenDeclaration, /* "<?" */
504 eTokenShortHandClose, /* "/>" */
509 // Main structure used for parsing XML
514 int nIndex,nIndexMissigEndTag;
518 XMLCSTR lpNewElement;
525 ALLXMLClearTag *pClr;
529 // Enumeration used when parsing attributes
537 // Enumeration used when parsing elements to dictate whether we are currently
545 // private (used while rendering):
546 XMLSTR toXMLString(XMLSTR dest,XMLCSTR source)
550 XMLCharacterEntity *entity;
556 if (ch==entity->c) {_tcscpy(dest,entity->s); dest+=entity->l; source++; goto out_of_loop1; }
560 *(dest++)=*(source++);
562 switch(XML_ByteTable[(unsigned char)ch])
564 case 4: *(dest++)=*(source++);
565 case 3: *(dest++)=*(source++);
566 case 2: *(dest++)=*(source++);
567 case 1: *(dest++)=*(source++);
577 // private (used while rendering):
578 int lengthXMLString(XMLCSTR source)
581 XMLCharacterEntity *entity;
588 if (ch==entity->c) { r+=entity->l; source++; goto out_of_loop1; }
594 ch=XML_ByteTable[(unsigned char)ch]; r+=ch; source+=ch;
602 XMLSTR toXMLString(XMLCSTR source)
604 XMLSTR dest=(XMLSTR)malloc((lengthXMLString(source)+1)*sizeof(XMLCHAR));
605 return toXMLString(dest,source);
608 XMLSTR toXMLStringFast(XMLSTR *dest,int *destSz, XMLCSTR source)
610 int l=lengthXMLString(source)+1;
611 if (l>*destSz) { *destSz=l; *dest=(XMLSTR)realloc(*dest,l*sizeof(XMLCHAR)); }
612 return toXMLString(*dest,source);
616 XMLSTR fromXMLString(XMLCSTR s, int lo, XML *pXML)
618 // This function is the opposite of the function "toXMLString". It decodes the escape
619 // sequences &, ", ', <, > and replace them by the characters
620 // &,",',<,>. This function is used internally by the XML Parser. All the calls to
621 // the XML library will always gives you back "decoded" strings.
623 // in: string (s) and length (lo) of string
624 // out: new allocated string converted from xml
630 XMLCharacterEntity *entity;
635 if ((lo>2)&&(s[1]==_T('#')))
638 if ((*s==_T('X'))||(*s==_T('x'))) { s++; lo--; }
639 while ((*s)&&(*s!=_T(';'))&&((lo--)>0)) s++;
642 pXML->error=eXMLErrorUnknownCharacterEntity;
651 if ((lo>=entity->l)&&(_tcsnicmp(s,entity->s,entity->l)==0)) { s+=entity->l; lo-=entity->l; break; }
656 pXML->error=eXMLErrorUnknownCharacterEntity;
665 j=XML_ByteTable[(unsigned char)*s]; s+=j; lo-=j; ll+=j-1;
671 d=(XMLSTR)malloc((ll+1)*sizeof(XMLCHAR));
680 if ((*ss==_T('X'))||(*ss==_T('x')))
685 if ((*ss>=_T('0'))&&(*ss<=_T('9'))) j=(j<<4)+*ss-_T('0');
686 else if ((*ss>=_T('A'))&&(*ss<=_T('F'))) j=(j<<4)+*ss-_T('A')+10;
687 else if ((*ss>=_T('a'))&&(*ss<=_T('f'))) j=(j<<4)+*ss-_T('a')+10;
688 else { free((void*)s); pXML->error=eXMLErrorUnknownCharacterEntity;return NULL;}
695 if ((*ss>=_T('0'))&&(*ss<=_T('9'))) j=(j*10)+*ss-_T('0');
696 else { free((void*)s); pXML->error=eXMLErrorUnknownCharacterEntity;return NULL;}
700 (*d++)=(XMLCHAR)j; ss++;
706 if (_tcsnicmp(ss,entity->s,entity->l)==0) { *(d++)=entity->c; ss+=entity->l; break; }
715 switch(XML_ByteTable[(unsigned char)*ss])
717 case 4: *(d++)=*(ss++); ll--;
718 case 3: *(d++)=*(ss++); ll--;
719 case 2: *(d++)=*(ss++); ll--;
720 case 1: *(d++)=*(ss++);
729 #define XML_isSPACECHAR(ch) ((ch==_T('\n'))||(ch==_T(' '))||(ch== _T('\t'))||(ch==_T('\r')))
732 char myTagCompare(XMLCSTR cclose, XMLCSTR copen)
733 // !!!! WARNING strange convention&:
734 // return 0 if equals
735 // return 1 if different
737 if (!cclose) return 1;
738 int l=(int)_tcslen(cclose);
739 if (_tcsnicmp(cclose, copen, l)!=0) return 1;
740 const XMLCHAR c=copen[l];
741 if (XML_isSPACECHAR(c)||
745 (c==_T('=' ))) return 0;
749 // Obtain the next character from the string.
750 static inline XMLCHAR getNextChar(XML *pXML)
752 XMLCHAR ch = pXML->lpXML[pXML->nIndex];
754 if (ch!=0) pXML->nIndex++;
756 pXML->nIndex+=XML_ByteTable[(unsigned char)ch];
761 // Find the next token in a string.
762 // pcbToken contains the number of characters that have been read.
763 static NextToken GetNextToken(XML *pXML, int *pcbToken, enum XMLTokenTypeTag *pType)
768 int indexStart,nFoundMatch,nIsText=FALSE;
769 result.pClr=NULL; // prevent warning
771 // Find next non-white space character
772 do { indexStart=pXML->nIndex; ch=getNextChar(pXML); } while XML_isSPACECHAR(ch);
776 // Cache the current string pointer
777 result.pStr = &pXML->lpXML[indexStart];
779 // First check whether the token is in the clear tag list (meaning it
780 // does not need formatting).
781 ALLXMLClearTag *ctag=XMLClearTags;
784 if (_tcsnicmp(ctag->lpszOpen, result.pStr, ctag->openTagLen)==0)
787 pXML->nIndex+=ctag->openTagLen-1;
792 } while(ctag->lpszOpen);
794 // If we didn't find a clear tag then check for standard tokens
801 *pType = eTokenQuotedText;
807 // Search through the string to find a matching quote
808 while((ch = getNextChar(pXML)))
810 if (ch==chTemp) { nFoundMatch = TRUE; break; }
811 if (ch==_T('<')) break;
814 // If we failed to find a matching quote
815 if (nFoundMatch == FALSE)
817 pXML->nIndex=indexStart+1;
823 // if (FindNonWhiteSpace(pXML)) pXML->nIndex--;
827 // Equals (used with attribute values)
829 *pType = eTokenEquals;
834 *pType = eTokenCloseTag;
837 // Check for tag start and tag end
840 // Peek at the next character to see if we have an end tag '</',
841 // or an xml declaration '<?'
842 chTemp = pXML->lpXML[pXML->nIndex];
844 // If we have a tag end...
845 if (chTemp == _T('/'))
847 // Set the type and ensure we point at the next character
849 *pType = eTokenTagEnd;
852 // If we have an XML declaration tag
853 else if (chTemp == _T('?'))
856 // Set the type and ensure we point at the next character
858 *pType = eTokenDeclaration;
861 // Otherwise we must have a start tag
864 *pType = eTokenTagStart;
868 // Check to see if we have a short hand type end tag ('/>').
871 // Peek at the next character to see if we have a short end tag '/>'
872 chTemp = pXML->lpXML[pXML->nIndex];
874 // If we have a short hand end tag...
875 if (chTemp == _T('>'))
877 // Set the type and ensure we point at the next character
879 *pType = eTokenShortHandClose;
883 // If we haven't found a short hand closing tag then drop into the
891 // If this is a TEXT node
894 // Indicate we are dealing with text
896 while((ch = getNextChar(pXML)))
898 if XML_isSPACECHAR(ch)
902 } else if (ch==_T('/'))
904 // If we find a slash then this maybe text or a short hand end tag
905 // Peek at the next character to see it we have short hand end tag
906 ch=pXML->lpXML[pXML->nIndex];
907 // If we found a short hand end tag then we need to exit the loop
908 if (ch==_T('>')) { pXML->nIndex--; break; }
910 } else if ((ch==_T('<'))||(ch==_T('>'))||(ch==_T('=')))
912 pXML->nIndex--; break;
916 *pcbToken = pXML->nIndex-indexStart;
919 // If we failed to obtain a valid character
921 *pType = eTokenError;
928 XMLCSTR XMLNode::updateName_WOSD(XMLCSTR lpszName)
930 if (d->lpszName&&(lpszName!=d->lpszName)) free((void*)d->lpszName);
931 d->lpszName=lpszName;
936 XMLNode::XMLNode(struct XMLNodeDataTag *p){ d=p; (p->ref_count)++; }
937 XMLNode::XMLNode(XMLNodeData *pParent, XMLCSTR lpszName, char isDeclaration)
939 d=(XMLNodeData*)malloc(sizeof(XMLNodeData));
948 d->isDeclaration = isDeclaration;
950 d->pParent = pParent;
957 updateName_WOSD(lpszName);
960 XMLNode XMLNode::createXMLTopNode_WOSD(XMLCSTR lpszName, char isDeclaration) { return XMLNode(NULL,lpszName,isDeclaration); }
961 XMLNode XMLNode::createXMLTopNode(XMLCSTR lpszName, char isDeclaration) { return XMLNode(NULL,stringDup(lpszName),isDeclaration); }
963 #define MEMORYINCREASE 50
965 static inline void *myRealloc(void *p, int newsize, int memInc, int sizeofElem)
967 if (p==NULL) { if (memInc) return malloc(memInc*sizeofElem); return malloc(sizeofElem); }
968 if ((memInc==0)||((newsize%memInc)==0)) p=realloc(p,(newsize+memInc)*sizeofElem);
971 // printf("XMLParser Error: Not enough memory! Aborting...\n"); exit(220);
977 int XMLNode::findPosition(XMLNodeData *d, int index, XMLElementType xtype)
979 if (index<0) return -1;
980 int i=0,j=(int)((index<<2)+xtype),*o=d->pOrder; while (o[i]!=j) i++; return i;
984 // update "order" information when deleting a content of a XMLNode
985 int XMLNode::removeOrderElement(XMLNodeData *d, XMLElementType t, int index)
987 int n=d->nChild+d->nText+d->nClear, *o=d->pOrder,i=findPosition(d,index,t);
988 memmove(o+i, o+i+1, (n-i)*sizeof(int));
990 if ((o[i]&3)==(int)t) o[i]-=4;
991 // We should normally do:
992 // d->pOrder=(int)realloc(d->pOrder,n*sizeof(int));
993 // but we skip reallocation because it's too time consuming.
994 // Anyway, at the end, it will be free'd completely at once.
998 void *XMLNode::addToOrder(int memoryIncrease,int *_pos, int nc, void *p, int size, XMLElementType xtype)
1000 // in: *_pos is the position inside d->pOrder ("-1" means "EndOf")
1001 // out: *_pos is the index inside p
1002 p=myRealloc(p,(nc+1),memoryIncrease,size);
1003 int n=d->nChild+d->nText+d->nClear;
1004 d->pOrder=(int*)myRealloc(d->pOrder,n+1,memoryIncrease*3,sizeof(int));
1005 int pos=*_pos,*o=d->pOrder;
1007 if ((pos<0)||(pos>=n)) { *_pos=nc; o[n]=(int)((nc<<2)+xtype); return p; }
1010 memmove(o+i+1, o+i, (n-i)*sizeof(int));
1012 while ((pos<n)&&((o[pos]&3)!=(int)xtype)) pos++;
1013 if (pos==n) { *_pos=nc; o[n]=(int)((nc<<2)+xtype); return p; }
1016 for (i=pos+1;i<=n;i++) if ((o[i]&3)==(int)xtype) o[i]+=4;
1018 *_pos=pos=o[pos]>>2;
1019 memmove(((char*)p)+(pos+1)*size,((char*)p)+pos*size,(nc-pos)*size);
1024 // Add a child node to the given element.
1025 XMLNode XMLNode::addChild_priv(int memoryIncrease, XMLCSTR lpszName, char isDeclaration, int pos)
1027 if (!lpszName) return emptyXMLNode;
1028 d->pChild=(XMLNode*)addToOrder(memoryIncrease,&pos,d->nChild,d->pChild,sizeof(XMLNode),eNodeChild);
1029 d->pChild[pos].d=NULL;
1030 d->pChild[pos]=XMLNode(d,lpszName,isDeclaration);
1032 return d->pChild[pos];
1035 // Add an attribute to an element.
1036 XMLAttribute *XMLNode::addAttribute_priv(int memoryIncrease,XMLCSTR lpszName, XMLCSTR lpszValuev)
1038 if (!lpszName) return &emptyXMLAttribute;
1039 int nc=d->nAttribute;
1040 d->pAttribute=(XMLAttribute*)myRealloc(d->pAttribute,(nc+1),memoryIncrease,sizeof(XMLAttribute));
1041 XMLAttribute *pAttr=d->pAttribute+nc;
1042 pAttr->lpszName = lpszName;
1043 pAttr->lpszValue = lpszValuev;
1048 // Add text to the element.
1049 XMLCSTR XMLNode::addText_priv(int memoryIncrease, XMLCSTR lpszValue, int pos)
1051 if (!lpszValue) return NULL;
1052 d->pText=(XMLCSTR*)addToOrder(memoryIncrease,&pos,d->nText,d->pText,sizeof(XMLSTR),eNodeText);
1053 d->pText[pos]=lpszValue;
1058 // Add clear (unformatted) text to the element.
1059 XMLClear *XMLNode::addClear_priv(int memoryIncrease, XMLCSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose, int pos)
1061 if (!lpszValue) return &emptyXMLClear;
1062 d->pClear=(XMLClear *)addToOrder(memoryIncrease,&pos,d->nClear,d->pClear,sizeof(XMLClear),eNodeClear);
1063 XMLClear *pNewClear=d->pClear+pos;
1064 pNewClear->lpszValue = lpszValue;
1065 if (!lpszOpen) lpszOpen=getClearTagTable()->lpszOpen;
1066 if (!lpszClose) lpszOpen=getClearTagTable()->lpszClose;
1067 pNewClear->lpszOpenTag = lpszOpen;
1068 pNewClear->lpszCloseTag = lpszClose;
1074 // Parse a clear (unformatted) type node.
1075 char XMLNode::parseClearTag(void *px, ALLXMLClearTag *pClear)
1077 XML *pXML=(XML *)px;
1079 XMLCSTR lpszTemp=NULL;
1080 XMLCSTR lpXML=&pXML->lpXML[pXML->nIndex];
1081 static XMLCSTR docTypeEnd=_T("]>");
1083 // Find the closing tag
1084 // Seems the <!DOCTYPE need a better treatment so lets handle it
1085 if (pClear->lpszOpen==XMLClearTags[1].lpszOpen)
1090 if (*pCh==_T('<')) { pClear->lpszClose=docTypeEnd; lpszTemp=_tcsstr(lpXML,docTypeEnd); break; }
1091 else if (*pCh==_T('>')) { lpszTemp=pCh; break; }
1095 pCh+=XML_ByteTable[(unsigned char)(*pCh)];
1098 } else lpszTemp=_tcsstr(lpXML, pClear->lpszClose);
1102 // Cache the size and increment the index
1103 cbTemp = (int)(lpszTemp - lpXML);
1105 pXML->nIndex += cbTemp+(int)_tcslen(pClear->lpszClose);
1107 // Add the clear node to the current element
1108 addClear_priv(MEMORYINCREASE,stringDup(lpXML,cbTemp), pClear->lpszOpen, pClear->lpszClose,-1);
1112 // If we failed to find the end tag
1113 pXML->error = eXMLErrorUnmatchedEndClearTag;
1117 void XMLNode::exactMemory(XMLNodeData *d)
1119 if (d->pOrder) d->pOrder=(int*)realloc(d->pOrder,(d->nChild+d->nText+d->nClear)*sizeof(int));
1120 if (d->pChild) d->pChild=(XMLNode*)realloc(d->pChild,d->nChild*sizeof(XMLNode));
1121 if (d->pAttribute) d->pAttribute=(XMLAttribute*)realloc(d->pAttribute,d->nAttribute*sizeof(XMLAttribute));
1122 if (d->pText) d->pText=(XMLCSTR*)realloc(d->pText,d->nText*sizeof(XMLSTR));
1123 if (d->pClear) d->pClear=(XMLClear *)realloc(d->pClear,d->nClear*sizeof(XMLClear));
1126 char XMLNode::maybeAddTxT(void *pa, XMLCSTR tokenPStr)
1128 XML *pXML=(XML *)pa;
1129 XMLCSTR lpszText=pXML->lpszText;
1130 if (!lpszText) return 0;
1131 if (dropWhiteSpace) while (XML_isSPACECHAR(*lpszText)&&(lpszText!=tokenPStr)) lpszText++;
1132 int cbText = (int)(tokenPStr - lpszText);
1133 if (!cbText) { pXML->lpszText=NULL; return 0; }
1134 if (dropWhiteSpace) { cbText--; while ((cbText)&&XML_isSPACECHAR(lpszText[cbText])) cbText--; cbText++; }
1135 if (!cbText) { pXML->lpszText=NULL; return 0; }
1136 lpszText=fromXMLString(lpszText,cbText,pXML);
1137 if (!lpszText) return 1;
1138 addText_priv(MEMORYINCREASE,lpszText,-1);
1139 pXML->lpszText=NULL;
1143 // Recursively parse an XML element.
1144 int XMLNode::ParseXMLElement(void *pa)
1146 XML *pXML=(XML *)pa;
1148 enum XMLTokenTypeTag type;
1150 XMLCSTR lpszTemp=NULL;
1154 enum Status status; // inside or outside a tag
1155 enum Attrib attrib = eAttribName;
1159 // If this is the first call to the function
1162 // Assume we are outside of a tag definition
1163 pXML->nFirst = FALSE;
1164 status = eOutsideTag;
1167 // If this is not the first call then we should only be called when inside a tag.
1168 status = eInsideTag;
1171 // Iterate through the tokens in the document
1174 // Obtain the next token
1175 token = GetNextToken(pXML, &cbToken, &type);
1177 if (type != eTokenError)
1179 // Check the current status
1183 // If we are outside of a tag definition
1186 // Check what type of token we obtained
1189 // If we have found text or quoted text
1191 case eTokenCloseTag: /* '>' */
1192 case eTokenShortHandClose: /* '/>' */
1193 case eTokenQuotedText:
1197 // If we found a start tag '<' and declarations '<?'
1198 case eTokenTagStart:
1199 case eTokenDeclaration:
1201 // Cache whether this new element is a declaration or not
1202 nDeclaration = (type == eTokenDeclaration);
1204 // If we have node text then add this to the element
1205 if (maybeAddTxT(pXML,token.pStr)) return FALSE;
1207 // Find the name of the tag
1208 token = GetNextToken(pXML, &cbToken, &type);
1210 // Return an error if we couldn't obtain the next token or
1212 if (type != eTokenText)
1214 pXML->error = eXMLErrorMissingTagName;
1218 // If we found a new element which is the same as this
1219 // element then we need to pass this back to the caller..
1221 #ifdef APPROXIMATE_PARSING
1223 myTagCompare(d->lpszName, token.pStr) == 0)
1225 // Indicate to the caller that it needs to create a
1227 pXML->lpNewElement = token.pStr;
1228 pXML->cbNewElement = cbToken;
1233 // If the name of the new element differs from the name of
1234 // the current element we need to add the new element to
1235 // the current one and recurse
1236 pNew = addChild_priv(MEMORYINCREASE,stringDup(token.pStr,cbToken), nDeclaration,-1);
1238 while (!pNew.isEmpty())
1240 // Callself to process the new node. If we return
1241 // FALSE this means we dont have any more
1242 // processing to do...
1244 if (!pNew.ParseXMLElement(pXML)) return FALSE;
1247 // If the call to recurse this function
1248 // evented in a end tag specified in XML then
1249 // we need to unwind the calls to this
1250 // function until we find the appropriate node
1251 // (the element name and end tag name must
1255 // If we are back at the root node then we
1256 // have an unmatched end tag
1259 pXML->error=eXMLErrorUnmatchedEndTag;
1263 // If the end tag matches the name of this
1264 // element then we only need to unwind
1267 if (myTagCompare(d->lpszName, pXML->lpEndTag)==0)
1274 if (pXML->cbNewElement)
1276 // If the call indicated a new element is to
1277 // be created on THIS element.
1279 // If the name of this element matches the
1280 // name of the element we need to create
1281 // then we need to return to the caller
1282 // and let it process the element.
1284 if (myTagCompare(d->lpszName, pXML->lpNewElement)==0)
1289 // Add the new element and recurse
1290 pNew = addChild_priv(MEMORYINCREASE,stringDup(pXML->lpNewElement,pXML->cbNewElement),0,-1);
1291 pXML->cbNewElement = 0;
1295 // If we didn't have a new element to create
1296 pNew = emptyXMLNode;
1304 // If we found an end tag
1307 // If we have node text then add this to the element
1308 if (maybeAddTxT(pXML,token.pStr)) return FALSE;
1310 // Find the name of the end tag
1311 token = GetNextToken(pXML, &cbTemp, &type);
1313 // The end tag should be text
1314 if (type != eTokenText)
1316 pXML->error = eXMLErrorMissingEndTagName;
1319 lpszTemp = token.pStr;
1321 // After the end tag we should find a closing tag
1322 token = GetNextToken(pXML, &cbToken, &type);
1323 if (type != eTokenCloseTag)
1325 pXML->error = eXMLErrorMissingEndTagName;
1328 pXML->lpszText=pXML->lpXML+pXML->nIndex;
1330 // We need to return to the previous caller. If the name
1331 // of the tag cannot be found we need to keep returning to
1332 // caller until we find a match
1333 if (myTagCompare(d->lpszName, lpszTemp) != 0)
1334 #ifdef STRICT_PARSING
1336 pXML->error=eXMLErrorUnmatchedEndTag;
1337 pXML->nIndexMissigEndTag=pXML->nIndex;
1342 pXML->error=eXMLErrorMissingEndTag;
1343 pXML->nIndexMissigEndTag=pXML->nIndex;
1344 pXML->lpEndTag = lpszTemp;
1345 pXML->cbEndTag = cbTemp;
1349 // Return to the caller
1353 // If we found a clear (unformatted) token
1355 // If we have node text then add this to the element
1356 if (maybeAddTxT(pXML,token.pStr)) return FALSE;
1357 if (parseClearTag(pXML, token.pClr)) return FALSE;
1358 pXML->lpszText=pXML->lpXML+pXML->nIndex;
1366 // If we are inside a tag definition we need to search for attributes
1369 // Check what part of the attribute (name, equals, value) we
1373 // If we are looking for a new attribute
1376 // Check what the current token type is
1379 // If the current type is text...
1382 // Cache the token then indicate that we are next to
1383 // look for the equals
1384 lpszTemp = token.pStr;
1386 attrib = eAttribEquals;
1389 // If we found a closing tag...
1391 case eTokenCloseTag:
1392 // We are now outside the tag
1393 status = eOutsideTag;
1394 pXML->lpszText=pXML->lpXML+pXML->nIndex;
1397 // If we found a short hand '/>' closing tag then we can
1398 // return to the caller
1399 case eTokenShortHandClose:
1401 pXML->lpszText=pXML->lpXML+pXML->nIndex;
1405 case eTokenQuotedText: /* '"SomeText"' */
1406 case eTokenTagStart: /* '<' */
1407 case eTokenTagEnd: /* '</' */
1408 case eTokenEquals: /* '=' */
1409 case eTokenDeclaration: /* '<?' */
1411 pXML->error = eXMLErrorUnexpectedToken;
1417 // If we are looking for an equals
1419 // Check what the current token type is
1422 // If the current type is text...
1423 // Eg. 'Attribute AnotherAttribute'
1425 // Add the unvalued attribute to the list
1426 addAttribute_priv(MEMORYINCREASE,stringDup(lpszTemp,cbTemp), NULL);
1427 // Cache the token then indicate. We are next to
1428 // look for the equals attribute
1429 lpszTemp = token.pStr;
1433 // If we found a closing tag 'Attribute >' or a short hand
1434 // closing tag 'Attribute />'
1435 case eTokenShortHandClose:
1436 case eTokenCloseTag:
1437 // If we are a declaration element '<?' then we need
1438 // to remove extra closing '?' if it exists
1439 pXML->lpszText=pXML->lpXML+pXML->nIndex;
1441 if (d->isDeclaration &&
1442 (lpszTemp[cbTemp-1]) == _T('?'))
1449 // Add the unvalued attribute to the list
1450 addAttribute_priv(MEMORYINCREASE,stringDup(lpszTemp,cbTemp), NULL);
1453 // If this is the end of the tag then return to the caller
1454 if (type == eTokenShortHandClose)
1460 // We are now outside the tag
1461 status = eOutsideTag;
1464 // If we found the equals token...
1465 // Eg. 'Attribute ='
1467 // Indicate that we next need to search for the value
1468 // for the attribute
1469 attrib = eAttribValue;
1473 case eTokenQuotedText: /* 'Attribute "InvalidAttr"'*/
1474 case eTokenTagStart: /* 'Attribute <' */
1475 case eTokenTagEnd: /* 'Attribute </' */
1476 case eTokenDeclaration: /* 'Attribute <?' */
1478 pXML->error = eXMLErrorUnexpectedToken;
1484 // If we are looking for an attribute value
1486 // Check what the current token type is
1489 // If the current type is text or quoted text...
1490 // Eg. 'Attribute = "Value"' or 'Attribute = Value' or
1491 // 'Attribute = 'Value''.
1493 case eTokenQuotedText:
1494 // If we are a declaration element '<?' then we need
1495 // to remove extra closing '?' if it exists
1496 if (d->isDeclaration &&
1497 (token.pStr[cbToken-1]) == _T('?'))
1504 // Add the valued attribute to the list
1505 if (type==eTokenQuotedText) { token.pStr++; cbToken-=2; }
1506 XMLCSTR attrVal=token.pStr;
1509 attrVal=fromXMLString(attrVal,cbToken,pXML);
1510 if (!attrVal) return FALSE;
1512 addAttribute_priv(MEMORYINCREASE,stringDup(lpszTemp,cbTemp),attrVal);
1515 // Indicate we are searching for a new attribute
1516 attrib = eAttribName;
1520 case eTokenTagStart: /* 'Attr = <' */
1521 case eTokenTagEnd: /* 'Attr = </' */
1522 case eTokenCloseTag: /* 'Attr = >' */
1523 case eTokenShortHandClose: /* "Attr = />" */
1524 case eTokenEquals: /* 'Attr = =' */
1525 case eTokenDeclaration: /* 'Attr = <?' */
1527 pXML->error = eXMLErrorUnexpectedToken;
1535 // If we failed to obtain the next token
1538 if ((!d->isDeclaration)&&(d->pParent))
1540 #ifdef STRICT_PARSING
1541 pXML->error=eXMLErrorUnmatchedEndTag;
1543 pXML->error=eXMLErrorMissingEndTag;
1545 pXML->nIndexMissigEndTag=pXML->nIndex;
1552 // Count the number of lines and columns in an XML string.
1553 static void CountLinesAndColumns(XMLCSTR lpXML, int nUpto, XMLResults *pResults)
1559 struct XML xml={ lpXML,lpXML, 0, 0, eXMLErrorNone, NULL, 0, NULL, 0, TRUE };
1561 pResults->nLine = 1;
1562 pResults->nColumn = 1;
1563 while (xml.nIndex<nUpto)
1565 ch = getNextChar(&xml);
1566 if (ch != _T('\n')) pResults->nColumn++;
1570 pResults->nColumn=1;
1575 // Parse XML and return the root element.
1576 XMLNode XMLNode::parseString(XMLCSTR lpszXML, XMLCSTR tag, XMLResults *pResults)
1582 pResults->error=eXMLErrorNoElements;
1584 pResults->nColumn=0;
1586 return emptyXMLNode;
1589 XMLNode xnode(NULL,NULL,FALSE);
1590 struct XML xml={ lpszXML, lpszXML, 0, 0, eXMLErrorNone, NULL, 0, NULL, 0, TRUE };
1592 // Create header element
1593 xnode.ParseXMLElement(&xml);
1594 enum XMLError error = xml.error;
1595 if ((xnode.nChildNode()==1)&&(xnode.nElement()==1)) xnode=xnode.getChildNode(); // skip the empty node
1597 // If no error occurred
1598 if ((error==eXMLErrorNone)||(error==eXMLErrorMissingEndTag))
1600 XMLCSTR name=xnode.getName();
1601 if (tag&&_tcslen(tag)&&((!name)||(_tcsicmp(xnode.getName(),tag))))
1605 while (i<xnode.nChildNode())
1607 nodeTmp=xnode.getChildNode(i);
1608 if (_tcsicmp(nodeTmp.getName(),tag)==0) break;
1609 if (nodeTmp.isDeclaration()) { xnode=nodeTmp; i=0; } else i++;
1611 if (i>=xnode.nChildNode())
1615 pResults->error=eXMLErrorFirstTagNotFound;
1617 pResults->nColumn=0;
1619 return emptyXMLNode;
1625 // Cleanup: this will destroy all the nodes
1626 xnode = emptyXMLNode;
1630 // If we have been given somewhere to place results
1633 pResults->error = error;
1635 // If we have an error
1636 if (error!=eXMLErrorNone)
1638 if (error==eXMLErrorMissingEndTag) xml.nIndex=xml.nIndexMissigEndTag;
1639 // Find which line and column it starts on.
1640 CountLinesAndColumns(xml.lpXML, xml.nIndex, pResults);
1646 XMLNode XMLNode::parseFile(XMLCSTR filename, XMLCSTR tag, XMLResults *pResults)
1648 if (pResults) { pResults->nLine=0; pResults->nColumn=0; }
1649 FILE *f=_tfopen(filename,_T("rb"));
1650 if (f==NULL) { if (pResults) pResults->error=eXMLErrorFileNotFound; return emptyXMLNode; }
1651 fseek(f,0,SEEK_END);
1652 int l=ftell(f),headerSz=0;
1653 if (!l) { if (pResults) pResults->error=eXMLErrorEmpty; return emptyXMLNode; }
1654 fseek(f,0,SEEK_SET);
1655 unsigned char *buf=(unsigned char*)malloc(l+1);
1660 if (guessUnicodeChars)
1662 if (!myIsTextUnicode(buf,l))
1664 if ((buf[0]==0xef)&&(buf[1]==0xbb)&&(buf[2]==0xbf)) headerSz=3;
1665 XMLSTR b2=myMultiByteToWideChar((const char*)(buf+headerSz),l-headerSz);
1666 free(buf); buf=(unsigned char*)b2; headerSz=0;
1669 if ((buf[0]==0xef)&&(buf[1]==0xff)) headerSz=2;
1670 if ((buf[0]==0xff)&&(buf[1]==0xfe)) headerSz=2;
1674 if (guessUnicodeChars)
1676 if (myIsTextUnicode(buf,l))
1679 if ((buf[0]==0xef)&&(buf[1]==0xff)) headerSz=2;
1680 if ((buf[0]==0xff)&&(buf[1]==0xfe)) headerSz=2;
1681 char *b2=myWideCharToMultiByte((const wchar_t*)(buf+headerSz),l-headerSz);
1682 free(buf); buf=(unsigned char*)b2; headerSz=0;
1685 if ((buf[0]==0xef)&&(buf[1]==0xbb)&&(buf[2]==0xbf)) headerSz=3;
1690 if (!buf) { if (pResults) pResults->error=eXMLErrorCharConversionError; return emptyXMLNode; }
1691 XMLNode x=parseString((XMLSTR)(buf+headerSz),tag,pResults);
1696 static inline void charmemset(XMLSTR dest,XMLCHAR c,int l) { while (l--) *(dest++)=c; }
1698 // Creates an user friendly XML string from a given element with
1699 // appropriate white space and carriage returns.
1701 // This recurses through all subnodes then adds contents of the nodes to the
1703 int XMLNode::CreateXMLStringR(XMLNodeData *pEntry, XMLSTR lpszMarker, int nFormat)
1708 int nChildFormat=-1;
1709 int nElementI=pEntry->nChild+pEntry->nText+pEntry->nClear;
1714 #define LENSTR(lpsz) (lpsz ? _tcslen(lpsz) : 0)
1716 // If the element has no name then assume this is the head node.
1717 cbElement = (int)LENSTR(pEntry->lpszName);
1722 cb = nFormat == -1 ? 0 : nFormat;
1726 if (cb) charmemset(lpszMarker, INDENTCHAR, sizeof(XMLCHAR)*cb);
1728 lpszMarker[nResult++]=_T('<');
1729 if (pEntry->isDeclaration) lpszMarker[nResult++]=_T('?');
1730 _tcscpy(&lpszMarker[nResult], pEntry->lpszName);
1732 lpszMarker[nResult++]=_T(' ');
1736 nResult+=cbElement+2+cb;
1737 if (pEntry->isDeclaration) nResult++;
1740 // Enumerate attributes and add them to the string
1741 XMLAttribute *pAttr=pEntry->pAttribute;
1742 for (i=0; i<pEntry->nAttribute; i++)
1745 cb = (int)LENSTR(pAttr->lpszName);
1748 if (lpszMarker) _tcscpy(&lpszMarker[nResult], pAttr->lpszName);
1751 if (pAttr->lpszValue)
1753 cb=(int)lengthXMLString(pAttr->lpszValue);
1756 lpszMarker[nResult]=_T('=');
1757 lpszMarker[nResult+1]=_T('"');
1758 if (cb) toXMLString(&lpszMarker[nResult+2],pAttr->lpszValue);
1759 lpszMarker[nResult+cb+2]=_T('"');
1763 if (lpszMarker) lpszMarker[nResult] = _T(' ');
1769 if (pEntry->isDeclaration)
1773 lpszMarker[nResult-1]=_T('?');
1774 lpszMarker[nResult]=_T('>');
1779 if (lpszMarker) lpszMarker[nResult]=_T('\n');
1783 // If there are child nodes we need to terminate the start tag
1786 if (lpszMarker) lpszMarker[nResult-1]=_T('>');
1789 if (lpszMarker) lpszMarker[nResult]=_T('\n');
1795 // Calculate the child format for when we recurse. This is used to
1796 // determine the number of spaces used for prefixes.
1799 if (cbElement&&(!pEntry->isDeclaration)) nChildFormat=nFormat+1;
1800 else nChildFormat=nFormat;
1803 // Enumerate through remaining children
1804 for (i=0; i<nElementI; i++)
1806 j=pEntry->pOrder[i];
1807 switch((XMLElementType)(j&3))
1813 XMLCSTR pChild=pEntry->pText[j>>2];
1814 cb = (int)lengthXMLString(pChild);
1821 charmemset(&lpszMarker[nResult],INDENTCHAR,sizeof(XMLCHAR)*(nFormat + 1));
1822 toXMLString(&lpszMarker[nResult+nFormat+1],pChild);
1823 lpszMarker[nResult+nFormat+1+cb]=_T('\n');
1825 nResult+=cb+nFormat+2;
1828 if (lpszMarker) toXMLString(&lpszMarker[nResult], pChild);
1838 XMLClear *pChild=pEntry->pClear+(j>>2);
1840 cb = (int)LENSTR(pChild->lpszOpenTag);
1847 charmemset(&lpszMarker[nResult], INDENTCHAR, sizeof(XMLCHAR)*(nFormat + 1));
1848 _tcscpy(&lpszMarker[nResult+nFormat+1], pChild->lpszOpenTag);
1850 nResult+=cb+nFormat+1;
1854 if (lpszMarker)_tcscpy(&lpszMarker[nResult], pChild->lpszOpenTag);
1860 cb = (int)LENSTR(pChild->lpszValue);
1863 if (lpszMarker) _tcscpy(&lpszMarker[nResult], pChild->lpszValue);
1867 // "OpenTag Value CloseTag"
1868 cb = (int)LENSTR(pChild->lpszCloseTag);
1871 if (lpszMarker) _tcscpy(&lpszMarker[nResult], pChild->lpszCloseTag);
1877 if (lpszMarker) lpszMarker[nResult] = _T('\n');
1886 // Recursively add child nodes
1887 nResult += CreateXMLStringR(pEntry->pChild[j>>2].d, lpszMarker ? lpszMarker + nResult : 0, nChildFormat);
1894 if ((cbElement)&&(!pEntry->isDeclaration))
1896 // If we have child entries we need to use long XML notation for
1897 // closing the element - "<elementname>blah blah blah</elementname>"
1900 // "</elementname>\0"
1907 charmemset(&lpszMarker[nResult], INDENTCHAR,sizeof(XMLCHAR)*nFormat);
1912 _tcscpy(&lpszMarker[nResult], _T("</"));
1914 _tcscpy(&lpszMarker[nResult], pEntry->lpszName);
1915 nResult += cbElement;
1919 _tcscpy(&lpszMarker[nResult], _T(">"));
1923 _tcscpy(&lpszMarker[nResult], _T(">\n"));
1928 if (nFormat != -1) nResult+=cbElement+4+nFormat;
1929 else nResult+=cbElement+3;
1933 // If there are no children we can use shorthand XML notation -
1940 _tcscpy(&lpszMarker[nResult], _T("/>"));
1945 _tcscpy(&lpszMarker[nResult], _T("/>\n"));
1951 nResult += nFormat == -1 ? 2 : 3;
1961 // Create an XML string
1962 // @param int nFormat - 0 if no formatting is required
1963 // otherwise nonzero for formatted text
1964 // with carriage returns and indentation.
1965 // @param int *pnSize - [out] pointer to the size of the
1966 // returned string not including the
1968 // @return XMLSTR - Allocated XML string, you must free
1969 // this with free().
1970 XMLSTR XMLNode::createXMLString(int nFormat, int *pnSize) const
1972 if (!d) { if (pnSize) *pnSize=0; return NULL; }
1974 XMLSTR lpszResult = NULL;
1977 // Recursively Calculate the size of the XML string
1978 if (!dropWhiteSpace) nFormat=0;
1979 nFormat = nFormat ? 0 : -1;
1980 cbStr = CreateXMLStringR(d, 0, nFormat);
1982 // Alllocate memory for the XML string + the NULL terminator and
1983 // create the recursively XML string.
1984 lpszResult=(XMLSTR)malloc((cbStr+1)*sizeof(XMLCHAR));
1985 CreateXMLStringR(d, lpszResult, nFormat);
1986 if (pnSize) *pnSize = cbStr;
1990 XMLNode::~XMLNode() { deleteNodeContent(); }
1992 int XMLNode::detachFromParent(XMLNodeData *d)
1994 XMLNode *pa=d->pParent->pChild;
1996 while (((void*)(pa[i].d))!=((void*)d)) i++;
1997 d->pParent->nChild--;
1998 if (d->pParent->nChild) memmove(pa+i,pa+i+1,(d->pParent->nChild-i)*sizeof(XMLNode));
1999 else { free(pa); d->pParent->pChild=NULL; }
2000 return removeOrderElement(d->pParent,eNodeChild,i);
2003 void XMLNode::deleteNodeContent(char force)
2007 if ((d->ref_count==0)||force)
2010 if (d->pParent) detachFromParent(d);
2011 for(i=0; i<d->nChild; i++) { d->pChild[i].d->pParent=NULL; d->pChild[i].deleteNodeContent(force); }
2013 for(i=0; i<d->nText; i++) free((void*)d->pText[i]);
2015 for(i=0; i<d->nClear; i++) free((void*)d->pClear[i].lpszValue);
2017 for(i=0; i<d->nAttribute; i++)
2019 free((void*)d->pAttribute[i].lpszName);
2020 if (d->pAttribute[i].lpszValue) free((void*)d->pAttribute[i].lpszValue);
2022 free(d->pAttribute);
2024 free((void*)d->lpszName);
2030 XMLNode XMLNode::addChild(XMLNode childNode, int pos)
2032 XMLNodeData *dc=childNode.d;
2033 if ((!dc)||(!d)) return childNode;
2034 if (dc->pParent) { if ((detachFromParent(dc)<=pos)&&(dc->pParent==d)) pos--; } else dc->ref_count++;
2036 // int nc=d->nChild;
2037 // d->pChild=(XMLNode*)myRealloc(d->pChild,(nc+1),memoryIncrease,sizeof(XMLNode));
2038 d->pChild=(XMLNode*)addToOrder(0,&pos,d->nChild,d->pChild,sizeof(XMLNode),eNodeChild);
2039 d->pChild[pos].d=dc;
2044 void XMLNode::deleteAttribute(int i)
2046 if ((!d)||(i<0)||(i>=d->nAttribute)) return;
2048 XMLAttribute *p=d->pAttribute+i;
2049 free((void*)p->lpszName);
2050 if (p->lpszValue) free((void*)p->lpszValue);
2051 if (d->nAttribute) memmove(p,p+1,(d->nAttribute-i)*sizeof(XMLAttribute)); else { free(p); d->pAttribute=NULL; }
2054 void XMLNode::deleteAttribute(XMLAttribute *a){ if (a) deleteAttribute(a->lpszName); }
2055 void XMLNode::deleteAttribute(XMLCSTR lpszName)
2058 getAttribute(lpszName,&j);
2059 if (j) deleteAttribute(j-1);
2062 XMLAttribute *XMLNode::updateAttribute_WOSD(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,int i)
2064 if (!d) return NULL;
2065 if (i>=d->nAttribute)
2067 if (lpszNewName) return addAttribute_WOSD(lpszNewName,lpszNewValue);
2070 XMLAttribute *p=d->pAttribute+i;
2071 if (p->lpszValue&&p->lpszValue!=lpszNewValue) free((void*)p->lpszValue);
2072 p->lpszValue=lpszNewValue;
2073 if (lpszNewName&&p->lpszName!=lpszNewName) { free((void*)p->lpszName); p->lpszName=lpszNewName; };
2077 XMLAttribute *XMLNode::updateAttribute_WOSD(XMLAttribute *newAttribute, XMLAttribute *oldAttribute)
2079 if (oldAttribute) return updateAttribute_WOSD(newAttribute->lpszValue,newAttribute->lpszName,oldAttribute->lpszName);
2080 return addAttribute_WOSD(newAttribute->lpszName,newAttribute->lpszValue);
2083 XMLAttribute *XMLNode::updateAttribute_WOSD(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,XMLCSTR lpszOldName)
2086 getAttribute(lpszOldName,&j);
2087 if (j) return updateAttribute_WOSD(lpszNewValue,lpszNewName,j-1);
2090 if (lpszNewName) return addAttribute_WOSD(lpszNewName,lpszNewValue);
2091 else return addAttribute_WOSD(stringDup(lpszOldName),lpszNewValue);
2095 int XMLNode::indexText(XMLCSTR lpszValue) const
2099 if (!lpszValue) { if (l) return 0; return -1; }
2100 XMLCSTR *p=d->pText;
2101 for (i=0; i<l; i++) if (lpszValue==p[i]) return i;
2105 void XMLNode::deleteText(int i)
2107 if ((!d)||(i<0)||(i>=d->nText)) return;
2109 XMLCSTR *p=d->pText+i;
2111 if (d->nText) memmove(p,p+1,(d->nText-i)*sizeof(XMLCSTR)); else { free(p); d->pText=NULL; }
2112 removeOrderElement(d,eNodeText,i);
2115 void XMLNode::deleteText(XMLCSTR lpszValue) { deleteText(indexText(lpszValue)); }
2117 XMLCSTR XMLNode::updateText_WOSD(XMLCSTR lpszNewValue, int i)
2119 if (!d) return NULL;
2120 if (i>=d->nText) return addText_WOSD(lpszNewValue);
2121 XMLCSTR *p=d->pText+i;
2122 if (*p!=lpszNewValue) { free((void*)*p); *p=lpszNewValue; }
2123 return lpszNewValue;
2126 XMLCSTR XMLNode::updateText_WOSD(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue)
2128 if (!d) return NULL;
2129 int i=indexText(lpszOldValue);
2130 if (i>=0) return updateText_WOSD(lpszNewValue,i);
2131 return addText_WOSD(lpszNewValue);
2134 void XMLNode::deleteClear(int i)
2136 if ((!d)||(i<0)||(i>=d->nClear)) return;
2138 XMLClear *p=d->pClear+i;
2139 free((void*)p->lpszValue);
2140 if (d->nClear) memmove(p,p+1,(d->nText-i)*sizeof(XMLClear)); else { free(p); d->pClear=NULL; }
2141 removeOrderElement(d,eNodeClear,i);
2144 int XMLNode::indexClear(XMLCSTR lpszValue) const
2148 if (!lpszValue) { if (l) return 0; return -1; }
2149 XMLClear *p=d->pClear;
2150 for (i=0; i<l; i++) if (lpszValue==p[i].lpszValue) return i;
2154 void XMLNode::deleteClear(XMLCSTR lpszValue) { deleteClear(indexClear(lpszValue)); }
2155 void XMLNode::deleteClear(XMLClear *a) { if (a) deleteClear(a->lpszValue); }
2157 XMLClear *XMLNode::updateClear_WOSD(XMLCSTR lpszNewContent, int i)
2159 if (!d) return NULL;
2162 return addClear_WOSD(XMLClearTags[0].lpszOpen,lpszNewContent,XMLClearTags[0].lpszClose);
2164 XMLClear *p=d->pClear+i;
2165 if (lpszNewContent!=p->lpszValue) { free((void*)p->lpszValue); p->lpszValue=lpszNewContent; }
2169 XMLClear *XMLNode::updateClear_WOSD(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue)
2171 if (!d) return NULL;
2172 int i=indexClear(lpszOldValue);
2173 if (i>=0) return updateClear_WOSD(lpszNewValue,i);
2174 return addClear_WOSD(lpszNewValue,XMLClearTags[0].lpszOpen,XMLClearTags[0].lpszClose);
2177 XMLClear *XMLNode::updateClear_WOSD(XMLClear *newP,XMLClear *oldP)
2179 if (oldP) return updateClear_WOSD(newP->lpszValue,oldP->lpszValue);
2183 XMLNode& XMLNode::operator=( const XMLNode& A )
2188 deleteNodeContent();
2190 if (d) (d->ref_count) ++ ;
2195 XMLNode::XMLNode(const XMLNode &A)
2199 if (d) (d->ref_count)++ ;
2202 int XMLNode::nChildNode(XMLCSTR name) const
2205 int i,j=0,n=d->nChild;
2206 XMLNode *pc=d->pChild;
2209 if (_tcsicmp(pc->d->lpszName, name)==0) j++;
2215 XMLNode XMLNode::getChildNode(XMLCSTR name, int *j) const
2217 if (!d) return emptyXMLNode;
2218 int i=0,n=d->nChild;
2220 XMLNode *pc=d->pChild+i;
2223 if (_tcsicmp(pc->d->lpszName, name)==0)
2230 return emptyXMLNode;
2233 XMLNode XMLNode::getChildNode(XMLCSTR name, int j) const
2235 if (!d) return emptyXMLNode;
2237 while (j-->0) getChildNode(name,&i);
2238 return getChildNode(name,&i);
2241 int XMLNode::positionOfText (int i) const { if (i>=d->nText ) i=d->nText-1; return findPosition(d,i,eNodeText ); }
2242 int XMLNode::positionOfClear (int i) const { if (i>=d->nClear) i=d->nClear-1; return findPosition(d,i,eNodeClear); }
2243 int XMLNode::positionOfChildNode(int i) const { if (i>=d->nChild) i=d->nChild-1; return findPosition(d,i,eNodeChild); }
2244 int XMLNode::positionOfText (XMLCSTR lpszValue) const { return positionOfText (indexText (lpszValue)); }
2245 int XMLNode::positionOfClear(XMLCSTR lpszValue) const { return positionOfClear(indexClear(lpszValue)); }
2246 int XMLNode::positionOfClear(XMLClear *a) const { if (a) return positionOfClear(a->lpszValue); return positionOfClear(); }
2247 int XMLNode::positionOfChildNode(XMLNode x) const
2249 if ((!d)||(!x.d)) return -1;
2250 XMLNodeData *dd=x.d;
2251 XMLNode *pc=d->pChild;
2253 while (i--) if (pc[i].d==dd) return findPosition(d,i,eNodeChild);
2256 int XMLNode::positionOfChildNode(XMLCSTR name, int count) const
2258 if (!name) return positionOfChildNode(count);
2260 do { getChildNode(name,&j); if (j<0) return -1; } while (count--);
2261 return findPosition(d,j-1,eNodeChild);
2264 XMLNode XMLNode::getChildNodeWithAttribute(XMLCSTR name,XMLCSTR attributeName,XMLCSTR attributeValue, int *k) const
2272 x=getChildNode(name,&i);
2280 t=x.getAttribute(attributeName,&j);
2281 if (t&&(_tcsicmp(attributeValue,t)==0)) { if (k) *k=i+1; return x; }
2285 if (x.isAttributeSet(attributeName)) { if (k) *k=i+1; return x; }
2288 } while (!x.isEmpty());
2289 return emptyXMLNode;
2292 // Find an attribute on an node.
2293 XMLCSTR XMLNode::getAttribute(XMLCSTR lpszAttrib, int *j) const
2295 if (!d) return NULL;
2296 int i=0,n=d->nAttribute;
2298 XMLAttribute *pAttr=d->pAttribute+i;
2301 if (_tcsicmp(pAttr->lpszName, lpszAttrib)==0)
2304 return pAttr->lpszValue;
2311 char XMLNode::isAttributeSet(XMLCSTR lpszAttrib) const
2313 if (!d) return FALSE;
2314 int i,n=d->nAttribute;
2315 XMLAttribute *pAttr=d->pAttribute;
2318 if (_tcsicmp(pAttr->lpszName, lpszAttrib)==0)
2327 XMLCSTR XMLNode::getAttribute(XMLCSTR name, int j) const
2329 if (!d) return NULL;
2331 while (j-->0) getAttribute(name,&i);
2332 return getAttribute(name,&i);
2335 XMLNodeContents XMLNode::enumContents(int i) const
2338 if (!d) { c.type=eNodeNULL; return c; }
2339 if (i<d->nAttribute)
2341 c.type=eNodeAttribute;
2342 c.attrib=d->pAttribute[i];
2346 c.type=(XMLElementType)(d->pOrder[i]&3);
2347 i=(d->pOrder[i])>>2;
2350 case eNodeChild: c.child = d->pChild[i]; break;
2351 case eNodeText: c.text = d->pText[i]; break;
2352 case eNodeClear: c.clear = d->pClear[i]; break;
2358 XMLCSTR XMLNode::getName() const { if (!d) return NULL; return d->lpszName; }
2359 int XMLNode::nText() const { if (!d) return 0; return d->nText; }
2360 int XMLNode::nChildNode() const { if (!d) return 0; return d->nChild; }
2361 int XMLNode::nAttribute() const { if (!d) return 0; return d->nAttribute; }
2362 int XMLNode::nClear() const { if (!d) return 0; return d->nClear; }
2363 int XMLNode::nElement() const { if (!d) return 0; return d->nAttribute+d->nChild+d->nText+d->nClear; }
2364 XMLClear XMLNode::getClear (int i) const { if ((!d)||(i>=d->nClear )) return emptyXMLClear; return d->pClear[i]; }
2365 XMLAttribute XMLNode::getAttribute (int i) const { if ((!d)||(i>=d->nAttribute)) return emptyXMLAttribute; return d->pAttribute[i]; }
2366 XMLCSTR XMLNode::getAttributeName (int i) const { if ((!d)||(i>=d->nAttribute)) return NULL; return d->pAttribute[i].lpszName; }
2367 XMLCSTR XMLNode::getAttributeValue(int i) const { if ((!d)||(i>=d->nAttribute)) return NULL; return d->pAttribute[i].lpszValue; }
2368 XMLCSTR XMLNode::getText (int i) const { if ((!d)||(i>=d->nText )) return NULL; return d->pText[i]; }
2369 XMLNode XMLNode::getChildNode (int i) const { if ((!d)||(i>=d->nChild )) return emptyXMLNode; return d->pChild[i]; }
2370 XMLNode XMLNode::getParentNode ( ) const { if ((!d)||(!d->pParent )) return emptyXMLNode; return XMLNode(d->pParent); }
2371 char XMLNode::isDeclaration ( ) const { if (!d) return 0; return d->isDeclaration; }
2372 char XMLNode::isEmpty ( ) const { return (d==NULL); }
2374 XMLNode XMLNode::addChild(XMLCSTR lpszName, char isDeclaration, int pos)
2375 { return addChild_priv(0,stringDup(lpszName),isDeclaration,pos); }
2376 XMLNode XMLNode::addChild_WOSD(XMLCSTR lpszName, char isDeclaration, int pos)
2377 { return addChild_priv(0,lpszName,isDeclaration,pos); }
2378 XMLAttribute *XMLNode::addAttribute(XMLCSTR lpszName, XMLCSTR lpszValue)
2379 { return addAttribute_priv(0,stringDup(lpszName),stringDup(lpszValue)); }
2380 XMLAttribute *XMLNode::addAttribute_WOSD(XMLCSTR lpszName, XMLCSTR lpszValuev)
2381 { return addAttribute_priv(0,lpszName,lpszValuev); }
2382 XMLCSTR XMLNode::addText(XMLCSTR lpszValue, int pos)
2383 { return addText_priv(0,stringDup(lpszValue),pos); }
2384 XMLCSTR XMLNode::addText_WOSD(XMLCSTR lpszValue, int pos)
2385 { return addText_priv(0,lpszValue,pos); }
2386 XMLClear *XMLNode::addClear(XMLCSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose, int pos)
2387 { return addClear_priv(0,stringDup(lpszValue),lpszOpen,lpszClose,pos); }
2388 XMLClear *XMLNode::addClear_WOSD(XMLCSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose, int pos)
2389 { return addClear_priv(0,lpszValue,lpszOpen,lpszClose,pos); }
2390 XMLCSTR XMLNode::updateName(XMLCSTR lpszName)
2391 { return updateName_WOSD(stringDup(lpszName)); }
2392 XMLAttribute *XMLNode::updateAttribute(XMLAttribute *newAttribute, XMLAttribute *oldAttribute)
2393 { return updateAttribute_WOSD(stringDup(newAttribute->lpszValue),stringDup(newAttribute->lpszName),oldAttribute->lpszName); }
2394 XMLAttribute *XMLNode::updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,int i)
2395 { return updateAttribute_WOSD(stringDup(lpszNewValue),stringDup(lpszNewName),i); }
2396 XMLAttribute *XMLNode::updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,XMLCSTR lpszOldName)
2397 { return updateAttribute_WOSD(stringDup(lpszNewValue),stringDup(lpszNewName),lpszOldName); }
2398 XMLCSTR XMLNode::updateText(XMLCSTR lpszNewValue, int i)
2399 { return updateText_WOSD(stringDup(lpszNewValue),i); }
2400 XMLCSTR XMLNode::updateText(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue)
2401 { return updateText_WOSD(stringDup(lpszNewValue),lpszOldValue); }
2402 XMLClear *XMLNode::updateClear(XMLCSTR lpszNewContent, int i)
2403 { return updateClear_WOSD(stringDup(lpszNewContent),i); }
2404 XMLClear *XMLNode::updateClear(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue)
2405 { return updateClear_WOSD(stringDup(lpszNewValue),lpszOldValue); }
2406 XMLClear *XMLNode::updateClear(XMLClear *newP,XMLClear *oldP)
2407 { return updateClear_WOSD(stringDup(newP->lpszValue),oldP->lpszValue); }
2409 void XMLNode::setGlobalOptions(char _guessUnicodeChars, char _strictUTF8Parsing, char _dropWhiteSpace)
2411 guessUnicodeChars=_guessUnicodeChars; dropWhiteSpace=_dropWhiteSpace; strictUTF8Parsing=_strictUTF8Parsing;
2413 if (_strictUTF8Parsing) XML_ByteTable=XML_utf8ByteTable; else XML_ByteTable=XML_asciiByteTable;
2417 char XMLNode::guessUTF8ParsingParameterValue(void *buf,int l, char useXMLEncodingAttribute)
2423 if (myIsTextUnicode(buf,l)) return 0;
2424 unsigned char *b=(unsigned char*)buf;
2425 if ((b[0]==0xef)&&(b[1]==0xbb)&&(b[2]==0xbf)) return 1;
2427 // Match utf-8 model ?
2430 switch (XML_utf8ByteTable[b[i]])
2432 case 4: i++; if ((i<l)&&(b[i]& 0xC0)!=0x80) return 0; // 10bbbbbb ?
2433 case 3: i++; if ((i<l)&&(b[i]& 0xC0)!=0x80) return 0; // 10bbbbbb ?
2434 case 2: i++; if ((i<l)&&(b[i]& 0xC0)!=0x80) return 0; // 10bbbbbb ?
2438 if (!useXMLEncodingAttribute) return 1;
2439 // if encoding is specified and different from utf-8 than it's non-utf8
2440 // otherwise it's utf-8
2443 memcpy(bb,buf,l); // copy buf into bb to be able to do "bb[l]=0"
2445 b=(unsigned char*)strstr(bb,"encoding");
2447 b+=8; while XML_isSPACECHAR(*b) b++; if (*b!='=') return 1;
2448 b++; while XML_isSPACECHAR(*b) b++; if ((*b!='\'')&&(*b!='"')) return 1;
2449 b++; while XML_isSPACECHAR(*b) b++; if ((_strnicmp((char*)b,"utf-8",5)==0)||
2450 (_strnicmp((char*)b,"utf8",4)==0)) return 1;
2454 #undef XML_isSPACECHAR
2456 //////////////////////////////////////////////////////////
2457 // Here starts the base64 conversion functions. //
2458 //////////////////////////////////////////////////////////
2460 static const char base64Fillchar = _T('='); // used to mark partial words at the end
2462 // this lookup table defines the base64 encoding
2463 XMLCSTR base64EncodeTable=_T("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
2465 // Decode Table gives the index of any valid base64 character in the Base64 table]
2466 // 96: '=' - 97: space char - 98: illegal char - 99: end of string
2467 const unsigned char base64DecodeTable[] = {
2468 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
2469 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
2470 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
2471 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
2472 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
2473 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
2474 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
2475 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
2476 98,98,98,98,98,98,98,98,98,98, 98,98,98,98,98,98 //240 -255
2479 XMLParserBase64Tool::~XMLParserBase64Tool(){ freeBuffer(); }
2481 void XMLParserBase64Tool::freeBuffer(){ if (buf) free(buf); buf=NULL; buflen=0; }
2483 int XMLParserBase64Tool::encodeLength(int inlen, char formatted)
2485 unsigned int i=((inlen-1)/3*4+4+1);
2486 if (formatted) i+=inlen/54;
2490 XMLSTR XMLParserBase64Tool::encode(unsigned char *inbuf, unsigned int inlen, char formatted)
2492 int i=encodeLength(inlen,formatted),k=17,eLen=inlen/3,j;
2493 alloc(i*sizeof(XMLCHAR));
2494 XMLSTR curr=(XMLSTR)buf;
2497 // Copy next three bytes into lower 24 bits of int, paying attention to sign.
2498 j=(inbuf[0]<<16)|(inbuf[1]<<8)|inbuf[2]; inbuf+=3;
2499 // Encode the int into four chars
2500 *(curr++)=base64EncodeTable[ j>>18 ];
2501 *(curr++)=base64EncodeTable[(j>>12)&0x3f];
2502 *(curr++)=base64EncodeTable[(j>> 6)&0x3f];
2503 *(curr++)=base64EncodeTable[(j )&0x3f];
2504 if (formatted) { if (!k) { *(curr++)=_T('\n'); k=18; } k--; }
2506 eLen=inlen-eLen*3; // 0 - 2.
2509 *(curr++)=base64EncodeTable[ inbuf[0]>>2 ];
2510 *(curr++)=base64EncodeTable[(inbuf[0]<<4)&0x3F];
2511 *(curr++)=base64Fillchar;
2512 *(curr++)=base64Fillchar;
2515 j=(inbuf[0]<<8)|inbuf[1];
2516 *(curr++)=base64EncodeTable[ j>>10 ];
2517 *(curr++)=base64EncodeTable[(j>> 4)&0x3f];
2518 *(curr++)=base64EncodeTable[(j<< 2)&0x3f];
2519 *(curr++)=base64Fillchar;
2525 unsigned int XMLParserBase64Tool::decodeSize(XMLCSTR data,XMLError *xe)
2527 if (xe) *xe=eXMLErrorNone;
2530 //skip any extra characters (e.g. newlines or spaces)
2534 if (*data>255) { if (xe) *xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; }
2536 c=base64DecodeTable[(unsigned char)(*data)];
2538 else if (c==98) { if (xe) *xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; }
2541 if (xe&&(size%4!=0)) *xe=eXMLErrorBase64DataSizeIsNotMultipleOf4;
2542 if (size==0) return 0;
2543 do { data--; size--; } while(*data==base64Fillchar); size++;
2544 return (unsigned int)((size*3)/4);
2547 unsigned char XMLParserBase64Tool::decode(XMLCSTR data, unsigned char *buf, int len, XMLError *xe)
2549 if (xe) *xe=eXMLErrorNone;
2556 #define BASE64DECODE_READ_NEXT_CHAR(c) \
2558 if (data[i]>255){ c=98; break; } \
2559 c=base64DecodeTable[(unsigned char)data[i++]]; \
2561 if(c==98){ if(xe)*xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; }
2563 #define BASE64DECODE_READ_NEXT_CHAR(c) \
2564 do { c=base64DecodeTable[(unsigned char)data[i++]]; }while (c==97); \
2565 if(c==98){ if(xe)*xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; }
2568 BASE64DECODE_READ_NEXT_CHAR(c)
2569 if (c==99) { return 2; }
2572 if (p==(int)len) return 2;
2573 if (xe) *xe=eXMLErrorBase64DecodeTruncatedData;
2577 BASE64DECODE_READ_NEXT_CHAR(d)
2578 if ((d==99)||(d==96)) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData; return 1; }
2579 if (p==(int)len) { if (xe) *xe=eXMLErrorBase64DecodeBufferTooSmall; return 0; }
2580 buf[p++]=(c<<2)|((d>>4)&0x3);
2582 BASE64DECODE_READ_NEXT_CHAR(c)
2583 if (c==99) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData; return 1; }
2586 if (c==96) return 2;
2587 if (xe) *xe=eXMLErrorBase64DecodeBufferTooSmall;
2590 if (c==96) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData; return 1; }
2591 buf[p++]=((d<<4)&0xf0)|((c>>2)&0xf);
2593 BASE64DECODE_READ_NEXT_CHAR(d)
2594 if (d==99 ) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData; return 1; }
2597 if (d==96) return 2;
2598 if (xe) *xe=eXMLErrorBase64DecodeBufferTooSmall;
2601 if (d==96) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData; return 1; }
2602 buf[p++]=((c<<6)&0xc0)|d;
2605 #undef BASE64DECODE_READ_NEXT_CHAR
2607 void XMLParserBase64Tool::alloc(int newsize)
2609 if ((!buf)&&(newsize)) { buf=malloc(newsize); buflen=newsize; return; }
2610 if (newsize>buflen) { buf=realloc(buf,newsize); buflen=newsize; }
2613 unsigned char *XMLParserBase64Tool::decode(XMLCSTR data, int *outlen, XMLError *xe)
2615 if (xe) *xe=eXMLErrorNone;
2616 unsigned int len=decodeSize(data,xe);
2617 if (outlen) *outlen=len;
2618 if (!len) return NULL;
2620 if(!decode(data,(unsigned char*)buf,len,xe)){ return NULL; }
2621 return (unsigned char*)buf;