kernel/src/xmlParser.cpp

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